Return to auerchar.c CVS log

Up to [Development] / linux-2.4-xfs / drivers / usb

Initial Import 2.4.24pre2

/*****************************************************************************/
/*
 *      auerchar.c  --  Auerswald PBX/System Telephone character interface.
 *
 *      Copyright (C) 2002  Wolfgang Mües (wolfgang@iksw-muees.de)
 *
 *      Very much code of this driver is borrowed from dabusb.c (Deti Fliegl)
 *      and from the USB Skeleton driver (Greg Kroah-Hartman). Thank you.
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 /*****************************************************************************/

#undef DEBUG			/* include debug macros until it's done */
#include <linux/usb.h>
#include "auerchar.h"
#include "auermain.h"
#include <linux/slab.h>
#include <asm/uaccess.h>	/* user area access functions */

/*-------------------------------------------------------------------*/

/* wake up waiting readers */
static void auerchar_disconnect(struct auerscon *scp)
{
	struct auerchar *ccp =((struct auerchar *) ((char *) (scp) - (unsigned long) (&((struct auerchar *) 0)->scontext)));
	dbg("auerchar_disconnect called");
	ccp->removed = 1;
	wake_up(&ccp->readwait);
}


/* dispatch a read paket to a waiting character device */
static void auerchar_ctrlread_dispatch(struct auerscon *scp,
				       struct auerbuf *bp)
{
	unsigned long flags;
	struct auerchar *ccp;
	struct auerbuf *newbp = NULL;
	char *charp;
	dbg("auerchar_ctrlread_dispatch called");
	ccp =((struct auerchar *) ((char *) (scp) - (unsigned long)(&((struct auerchar *) 0)->scontext)));

	/* get a read buffer from character device context */
	newbp = auerbuf_getbuf(&ccp->bufctl);
	if (!newbp) {
		dbg("No read buffer available, discard paket!");
		return;		/* no buffer, no dispatch */
	}

	/* copy information to new buffer element
	   (all buffers have the same length) */
	charp = newbp->bufp;
	newbp->bufp = bp->bufp;
	bp->bufp = charp;
	newbp->len = bp->len;

	/* insert new buffer in read list */
	spin_lock_irqsave(&ccp->bufctl.lock, flags);
	list_add_tail(&newbp->buff_list, &ccp->bufctl.rec_buff_list);
	spin_unlock_irqrestore(&ccp->bufctl.lock, flags);
	dbg("read buffer appended to rec_list");

	/* wake up pending synchronous reads */
	wake_up(&ccp->readwait);
}


/* Delete an auerswald character context */
void auerchar_delete(struct auerchar *ccp)
{
	dbg("auerchar_delete");
	if (ccp == NULL)
		return;

	/* wake up pending synchronous reads */
	ccp->removed = 1;
	wake_up(&ccp->readwait);

	/* remove the read buffer */
	if (ccp->readbuf) {
		auerbuf_releasebuf(ccp->readbuf);
		ccp->readbuf = NULL;
	}

	/* remove the character buffers */
	auerbuf_free_buffers(&ccp->bufctl);

	/* release the memory */
	kfree(ccp);
}


/* --------------------------------------------------------------------- */
/* Char device functions                                                 */

/* Open a new character device */
int auerchar_open(struct inode *inode, struct file *file)
{
	int dtindex = MINOR(inode->i_rdev) - AUER_MINOR_BASE;
	struct auerswald *cp = NULL;
	struct auerchar *ccp = NULL;
	int ret;

	/* minor number in range? */
	if ((dtindex < 0) || (dtindex >= AUER_MAX_DEVICES)) {
		return -ENODEV;
	}
	/* usb device available? */
	if (down_interruptible(&auerdev_table_mutex)) {
		return -ERESTARTSYS;
	}
	cp = auerdev_table[dtindex];
	if (cp == NULL) {
		up(&auerdev_table_mutex);
		return -ENODEV;
	}
	if (down_interruptible(&cp->mutex)) {
		up(&auerdev_table_mutex);
		return -ERESTARTSYS;
	}
	up(&auerdev_table_mutex);

	/* we have access to the device. Now lets allocate memory */
	ccp = (struct auerchar *) kmalloc(sizeof(struct auerchar), GFP_KERNEL);
	if (ccp == NULL) {
		err("out of memory");
		ret = -ENOMEM;
		goto ofail;
	}

	/* Initialize device descriptor */
	memset(ccp, 0, sizeof(struct auerchar));
	init_MUTEX(&ccp->mutex);
	init_MUTEX(&ccp->readmutex);
	auerbuf_init(&ccp->bufctl);
	ccp->scontext.id = AUH_UNASSIGNED;
	ccp->scontext.dispatch = auerchar_ctrlread_dispatch;
	ccp->scontext.disconnect = auerchar_disconnect;
	init_waitqueue_head(&ccp->readwait);

	ret =
	    auerbuf_setup(&ccp->bufctl, AU_RBUFFERS,
			  cp->maxControlLength + AUH_SIZE);
	if (ret) {
		goto ofail;
	}

	cp->open_count++;
	ccp->auerdev = cp;
	dbg("open %s as /dev/usb/%s", cp->dev_desc, cp->name);
	up(&cp->mutex);

	/* file IO stuff */
	file->f_pos = 0;
	file->private_data = ccp;
	return 0;

	/* Error exit */
      ofail:up(&cp->mutex);
	auerchar_delete(ccp);
	return ret;
}


/* IOCTL functions */
int auerchar_ioctl(struct inode *inode, struct file *file,
		   unsigned int cmd, unsigned long arg)
{
	struct auerchar *ccp = (struct auerchar *) file->private_data;
	int ret = 0;
	struct audevinfo devinfo;
	struct auerswald *cp = NULL;
	unsigned int u;
	dbg("ioctl");

	/* get the mutexes */
	if (down_interruptible(&ccp->mutex)) {
		return -ERESTARTSYS;
	}
	cp = ccp->auerdev;
	if (!cp) {
		up(&ccp->mutex);
		return -ENODEV;
	}
	if (down_interruptible(&cp->mutex)) {
		up(&ccp->mutex);
		return -ERESTARTSYS;
	}

	/* Check for removal */
	if (!cp->usbdev) {
		up(&cp->mutex);
		up(&ccp->mutex);
		return -ENODEV;
	}

	switch (cmd) {

		/* return != 0 if Transmitt channel ready to send */
	case IOCTL_AU_TXREADY:
		dbg("IOCTL_AU_TXREADY");
		u = ccp->auerdev && (ccp->scontext.id != AUH_UNASSIGNED)
		    && !list_empty(&cp->bufctl.free_buff_list);
		ret = put_user(u, (unsigned int *) arg);
		break;

		/* return != 0 if connected to a service channel */
	case IOCTL_AU_CONNECT:
		dbg("IOCTL_AU_CONNECT");
		u = (ccp->scontext.id != AUH_UNASSIGNED);
		ret = put_user(u, (unsigned int *) arg);
		break;

		/* return != 0 if Receive Data available */
	case IOCTL_AU_RXAVAIL:
		dbg("IOCTL_AU_RXAVAIL");
		if (ccp->scontext.id == AUH_UNASSIGNED) {
			ret = -EIO;
			break;
		}
		u = 0;		/* no data */
		if (ccp->readbuf) {
			int restlen = ccp->readbuf->len - ccp->readoffset;
			if (restlen > 0)
				u = 1;
		}
		if (!u) {
			if (!list_empty(&ccp->bufctl.rec_buff_list)) {
				u = 1;
			}
		}
		ret = put_user(u, (unsigned int *) arg);
		break;

		/* return the max. buffer length for the device */
	case IOCTL_AU_BUFLEN:
		dbg("IOCTL_AU_BUFLEN");
		u = cp->maxControlLength;
		ret = put_user(u, (unsigned int *) arg);
		break;

		/* requesting a service channel */
	case IOCTL_AU_SERVREQ:
		dbg("IOCTL_AU_SERVREQ");
		/* requesting a service means: release the previous one first */
		auerswald_removeservice(cp, &ccp->scontext);
		/* get the channel number */
		ret = get_user(u, (unsigned int *) arg);
		if (ret) {
			break;
		}
		if ((u < AUH_FIRSTUSERCH) || (u >= AUH_TYPESIZE)) {
			ret = -EIO;
			break;
		}
		dbg("auerchar service request parameters are ok");
		ccp->scontext.id = u;

		/* request the service now */
		ret = auerswald_addservice(cp, &ccp->scontext);
		if (ret) {
			/* no: revert service entry */
			ccp->scontext.id = AUH_UNASSIGNED;
		}
		break;

		/* get a string descriptor for the device */
	case IOCTL_AU_DEVINFO:
		dbg("IOCTL_AU_DEVINFO");
		if (copy_from_user
		    (&devinfo, (void *) arg, sizeof(struct audevinfo))) {
			ret = -EFAULT;
			break;
		}
		u = strlen(cp->dev_desc) + 1;
		if (u > devinfo.bsize) {
			u = devinfo.bsize;
		}
		ret = copy_to_user(devinfo.buf, cp->dev_desc, u);
		break;

		/* get the max. string descriptor length */
	case IOCTL_AU_SLEN:
		dbg("IOCTL_AU_SLEN");
		u = AUSI_DLEN;
		ret = put_user(u, (unsigned int *) arg);
		break;

	default:
		dbg("IOCTL_AU_UNKNOWN");
		ret = -ENOIOCTLCMD;
		break;
	}
	/* release the mutexes */
	up(&cp->mutex);
	up(&ccp->mutex);
	return ret;
}


/* Seek is not supported */
loff_t auerchar_llseek(struct file * file, loff_t offset, int origin)
{
	dbg("auerchar_seek");
	return -ESPIPE;
}


/* Read data from the device */
ssize_t auerchar_read(struct file * file, char *buf, size_t count,
		      loff_t * ppos)
{
	unsigned long flags;
	struct auerchar *ccp = (struct auerchar *) file->private_data;
	struct auerbuf *bp = NULL;
	wait_queue_t wait;

	dbg("auerchar_read");

	/* Error checking */
	if (!ccp)
		return -EIO;
	if (*ppos)
		return -ESPIPE;
	if (count == 0)
		return 0;

	/* get the mutex */
	if (down_interruptible(&ccp->mutex))
		return -ERESTARTSYS;

	/* Can we expect to read something? */
	if (ccp->scontext.id == AUH_UNASSIGNED) {
		up(&ccp->mutex);
		return -EIO;
	}

	/* only one reader per device allowed */
	if (down_interruptible(&ccp->readmutex)) {
		up(&ccp->mutex);
		return -ERESTARTSYS;
	}

	/* read data from readbuf, if available */
      doreadbuf:
	bp = ccp->readbuf;
	if (bp) {
		/* read the maximum bytes */
		int restlen = bp->len - ccp->readoffset;
		if (restlen < 0)
			restlen = 0;
		if (count > restlen)
			count = restlen;
		if (count) {
			if (copy_to_user
			    (buf, bp->bufp + ccp->readoffset, count)) {
				dbg("auerswald_read: copy_to_user failed");
				up(&ccp->readmutex);
				up(&ccp->mutex);
				return -EFAULT;
			}
		}
		/* advance the read offset */
		ccp->readoffset += count;
		restlen -= count;
		// reuse the read buffer
		if (restlen <= 0) {
			auerbuf_releasebuf(bp);
			ccp->readbuf = NULL;
		}
		/* return with number of bytes read */
		if (count) {
			up(&ccp->readmutex);
			up(&ccp->mutex);
			return count;
		}
	}

	/* a read buffer is not available. Try to get the next data block. */
      doreadlist:
	/* Preparing for sleep */
	init_waitqueue_entry(&wait, current);
	set_current_state(TASK_INTERRUPTIBLE);
	add_wait_queue(&ccp->readwait, &wait);

	bp = NULL;
	spin_lock_irqsave(&ccp->bufctl.lock, flags);
	if (!list_empty(&ccp->bufctl.rec_buff_list)) {
		/* yes: get the entry */
		struct list_head *tmp = ccp->bufctl.rec_buff_list.next;
		list_del(tmp);
		bp = list_entry(tmp, struct auerbuf, buff_list);
	}
	spin_unlock_irqrestore(&ccp->bufctl.lock, flags);

	/* have we got data? */
	if (bp) {
		ccp->readbuf = bp;
		ccp->readoffset = AUH_SIZE;	/* for headerbyte */
		set_current_state(TASK_RUNNING);
		remove_wait_queue(&ccp->readwait, &wait);
		goto doreadbuf;	/* now we can read! */
	}

	/* no data available. Should we wait? */
	if (file->f_flags & O_NONBLOCK) {
		dbg("No read buffer available, returning -EAGAIN");
		set_current_state(TASK_RUNNING);
		remove_wait_queue(&ccp->readwait, &wait);
		up(&ccp->readmutex);
		up(&ccp->mutex);
		return -EAGAIN;	/* nonblocking, no data available */
	}

	/* yes, we should wait! */
	up(&ccp->mutex);	/* allow other operations while we wait */
	schedule();
	remove_wait_queue(&ccp->readwait, &wait);
	if (signal_pending(current)) {
		/* waked up by a signal */
		up(&ccp->readmutex);
		return -ERESTARTSYS;
	}

	/* Anything left to read? */
	if ((ccp->scontext.id == AUH_UNASSIGNED) || ccp->removed) {
		up(&ccp->readmutex);
		return -EIO;
	}

	if (down_interruptible(&ccp->mutex)) {
		up(&ccp->readmutex);
		return -ERESTARTSYS;
	}

	/* try to read the incomming data again */
	goto doreadlist;
}


/* Write a data block into the right service channel of the device */
ssize_t auerchar_write(struct file *file, const char *buf, size_t len,
		       loff_t * ppos)
{
	struct auerchar *ccp = (struct auerchar *) file->private_data;
	struct auerswald *cp = NULL;
	struct auerbuf *bp;
	int ret;
	wait_queue_t wait;

	dbg("auerchar_write %d bytes", len);

	/* Error checking */
	if (!ccp)
		return -EIO;
	if (*ppos)
		return -ESPIPE;
	if (len == 0)
		return 0;

      write_again:
	/* get the mutex */
	if (down_interruptible(&ccp->mutex))
		return -ERESTARTSYS;

	/* Can we expect to write something? */
	if (ccp->scontext.id == AUH_UNASSIGNED) {
		up(&ccp->mutex);
		return -EIO;
	}

	cp = ccp->auerdev;
	if (!cp) {
		up(&ccp->mutex);
		return -ERESTARTSYS;
	}
	if (down_interruptible(&cp->mutex)) {
		up(&ccp->mutex);
		return -ERESTARTSYS;
	}
	if (!cp->usbdev) {
		up(&cp->mutex);
		up(&ccp->mutex);
		return -EIO;
	}
	/* Prepare for sleep */
	init_waitqueue_entry(&wait, current);
	set_current_state(TASK_INTERRUPTIBLE);
	add_wait_queue(&cp->bufferwait, &wait);

	/* Try to get a buffer from the device pool.
	   We can't use a buffer from ccp->bufctl because the write
	   command will last beond a release() */
	bp = auerbuf_getbuf(&cp->bufctl);
	/* are there any buffers left? */
	if (!bp) {
		up(&cp->mutex);
		up(&ccp->mutex);

		/* NONBLOCK: don't wait */
		if (file->f_flags & O_NONBLOCK) {
			set_current_state(TASK_RUNNING);
			remove_wait_queue(&cp->bufferwait, &wait);
			return -EAGAIN;
		}

		/* BLOCKING: wait */
		schedule();
		remove_wait_queue(&cp->bufferwait, &wait);
		if (signal_pending(current)) {
			/* waked up by a signal */
			return -ERESTARTSYS;
		}
		goto write_again;
	} else {
		set_current_state(TASK_RUNNING);
		remove_wait_queue(&cp->bufferwait, &wait);
	}

	/* protect against too big write requests */
	if (len > cp->maxControlLength)
		len = cp->maxControlLength;

	/* Fill the buffer */
	if (copy_from_user(bp->bufp + AUH_SIZE, buf, len)) {
		dbg("copy_from_user failed");
		auerbuf_releasebuf(bp);
		/* Wake up all processes waiting for a buffer */
		wake_up(&cp->bufferwait);
		up(&cp->mutex);
		up(&ccp->mutex);
		return -EIO;
	}

	/* set the header byte */
	*(bp->bufp) = ccp->scontext.id | AUH_DIRECT | AUH_UNSPLIT;

	/* Set the transfer Parameters */
	bp->len = len + AUH_SIZE;
	bp->dr->bRequestType = AUT_WREQ;
	bp->dr->bRequest = AUV_WBLOCK;
	bp->dr->wValue = cpu_to_le16(0);
	bp->dr->wIndex =
	    cpu_to_le16(ccp->scontext.id | AUH_DIRECT | AUH_UNSPLIT);
	bp->dr->wLength = cpu_to_le16(len + AUH_SIZE);
	FILL_CONTROL_URB(bp->urbp, cp->usbdev,
			 usb_sndctrlpipe(cp->usbdev, 0),
			 (unsigned char *) bp->dr, bp->bufp,
			 len + AUH_SIZE, auerchar_ctrlwrite_complete, bp);
	/* up we go */
	ret = auerchain_submit_urb(&cp->controlchain, bp->urbp);
	up(&cp->mutex);
	if (ret) {
		dbg("auerchar_write: nonzero result of auerchain_submit_urb %d", ret);
		auerbuf_releasebuf(bp);
		/* Wake up all processes waiting for a buffer */
		wake_up(&cp->bufferwait);
		up(&ccp->mutex);
		return -EIO;
	} else {
		dbg("auerchar_write: Write OK");
		up(&ccp->mutex);
		return len;
	}
}


/* Close a character device */
int auerchar_release(struct inode *inode, struct file *file)
{
	struct auerchar *ccp = (struct auerchar *) file->private_data;
	struct auerswald *cp;
	dbg("release");

	/* get the mutexes */
	if (down_interruptible(&ccp->mutex)) {
		return -ERESTARTSYS;
	}
	cp = ccp->auerdev;
	if (cp) {
		if (down_interruptible(&cp->mutex)) {
			up(&ccp->mutex);
			return -ERESTARTSYS;
		}
		/* remove an open service */
		auerswald_removeservice(cp, &ccp->scontext);
		/* detach from device */
		if ((--cp->open_count <= 0) && (cp->usbdev == NULL)) {
			/* usb device waits for removal */
			up(&cp->mutex);
			auerswald_delete(cp);
		} else {
			up(&cp->mutex);
		}
		cp = NULL;
		ccp->auerdev = NULL;
	}
	up(&ccp->mutex);
	auerchar_delete(ccp);

	return 0;
}