Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 476b8477 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Staging: comedi: fix checkpatch.pl errors in comedi_fops.c 



There are still some >80 character lines in there, but
this catches the majority of the issues.

Cc: Ian Abbott <abbotti@mev.co.uk>
Cc: Frank Mori Hess <fmhess@users.sourceforge.net>
Cc: David Schleef <ds@schleef.org>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent e0dcef71

drivers/staging/comedi/comedi_fops.c

+263 −265
Original line number Diff line number Diff line
@@ -45,10 +45,10 @@ 
#include "comedidev.h"

#include <linux/cdev.h>



#include <asm/io.h>

#include <asm/uaccess.h>

#include <linux/io.h>

#include <linux/uaccess.h>



//#include "kvmem.h"

/* #include "kvmem.h" */



MODULE_AUTHOR("http://www.comedi.org");

MODULE_DESCRIPTION("Comedi core module");
@@ -60,7 +60,8 @@ module_param(comedi_debug, int, 0644); 
#endif



static DEFINE_SPINLOCK(comedi_file_info_table_lock);

static struct comedi_device_file_info* comedi_file_info_table[COMEDI_NUM_MINORS];

static struct comedi_device_file_info

    *comedi_file_info_table[COMEDI_NUM_MINORS];



static int do_devconfig_ioctl(comedi_device *dev, comedi_devconfig *arg);

static int do_bufconfig_ioctl(comedi_device *dev, void *arg);
@@ -79,7 +80,7 @@ static int do_insnlist_ioctl(comedi_device * dev, void *arg, void *file); 
static int do_insn_ioctl(comedi_device *dev, void *arg, void *file);

static int do_poll_ioctl(comedi_device *dev, unsigned int subd, void *file);



void do_become_nonbusy(comedi_device * dev, comedi_subdevice * s);

extern void do_become_nonbusy(comedi_device *dev, comedi_subdevice *s);

static int do_cancel(comedi_device *dev, comedi_subdevice *s);



static int comedi_fasync(int fd, struct file *file, int on);
@@ -95,7 +96,8 @@ static int comedi_ioctl(struct inode *inode, struct file *file, 
#endif

{

	const unsigned minor = iminor(file->f_dentry->d_inode);

	struct comedi_device_file_info *dev_file_info = comedi_get_device_file_info(minor);

	struct comedi_device_file_info *dev_file_info =

	    comedi_get_device_file_info(minor);

	comedi_device *dev = dev_file_info->device;

	int rc;
@@ -193,8 +195,7 @@ static int do_devconfig_ioctl(comedi_device * dev, comedi_devconfig * arg) 
	if (arg == NULL) {

		if (is_device_busy(dev))

			return -EBUSY;

		if(dev->attached)

		{

		if (dev->attached) {

			struct module *driver_module = dev->driver->module;

			comedi_device_detach(dev);

			module_put(driver_module);
@@ -234,8 +235,7 @@ static int do_devconfig_ioctl(comedi_device * dev, comedi_devconfig * arg) 
	}



	ret = comedi_device_attach(dev, &it);

	if(ret == 0)

	{

	if (ret == 0) {

		if (!try_module_get(dev->driver->module)) {

			comedi_device_detach(dev);

			return -ENOSYS;
@@ -355,9 +355,12 @@ static int do_devinfo_ioctl(comedi_device * dev, comedi_devinfo * arg, 
{

	comedi_devinfo devinfo;

	const unsigned minor = iminor(file->f_dentry->d_inode);

	struct comedi_device_file_info *dev_file_info = comedi_get_device_file_info(minor);

	comedi_subdevice *read_subdev = comedi_get_read_subdevice(dev_file_info);

	comedi_subdevice *write_subdev = comedi_get_write_subdevice(dev_file_info);

	struct comedi_device_file_info *dev_file_info =

	    comedi_get_device_file_info(minor);

	comedi_subdevice *read_subdev =

	    comedi_get_read_subdevice(dev_file_info);

	comedi_subdevice *write_subdev =

	    comedi_get_write_subdevice(dev_file_info);



	memset(&devinfo, 0, sizeof(devinfo));
@@ -367,16 +370,15 @@ static int do_devinfo_ioctl(comedi_device * dev, comedi_devinfo * arg, 
	memcpy(devinfo.driver_name, dev->driver->driver_name, COMEDI_NAMELEN);

	memcpy(devinfo.board_name, dev->board_name, COMEDI_NAMELEN);



	if (read_subdev) {

	if (read_subdev)

		devinfo.read_subdevice = read_subdev - dev->subdevices;

	} else {

	else

		devinfo.read_subdevice = -1;

	}

	if (write_subdev) {



	if (write_subdev)

		devinfo.write_subdevice = write_subdev - dev->subdevices;

	} else {

	else

		devinfo.write_subdevice = -1;

	}



	if (copy_to_user(arg, &devinfo, sizeof(comedi_devinfo)))

		return -EFAULT;
@@ -425,8 +427,7 @@ static int do_subdinfo_ioctl(comedi_device * dev, comedi_subdinfo * arg, 
		us->maxdata = s->maxdata;

		if (s->range_table) {

			us->range_type =

				(i << 24) | (0 << 16) | (s->

				range_table->length);

			    (i << 24) | (0 << 16) | (s->range_table->length);

		} else {

			us->range_type = 0;	/* XXX */

		}
@@ -519,8 +520,11 @@ static int do_chaninfo_ioctl(comedi_device * dev, comedi_chaninfo * arg) 
			    (s->range_table_list[i]->length);

			put_user(x, it.rangelist + i);

		}

		//if(copy_to_user(it.rangelist,s->range_type_list,s->n_chan*sizeof(unsigned int)))

		//      return -EFAULT;

#if 0

		if (copy_to_user(it.rangelist, s->range_type_list,

				 s->n_chan*sizeof(unsigned int)))

			return -EFAULT;

#endif

	}



	return 0;
@@ -674,9 +678,7 @@ static int do_insnlist_ioctl(comedi_device * dev, void *arg, void *file) 
	}



error:

	if (insns)

	kfree(insns);

	if (data)

	kfree(data);



	if (ret < 0)
@@ -686,7 +688,8 @@ static int do_insnlist_ioctl(comedi_device * dev, void *arg, void *file) 


static int check_insn_config_length(comedi_insn *insn, lsampl_t *data)

{

	if(insn->n < 1) return -EINVAL;

	if (insn->n < 1)

		return -EINVAL;



	switch (data[0]) {

	case INSN_CONFIG_DIO_OUTPUT:
@@ -730,12 +733,13 @@ static int check_insn_config_length(comedi_insn * insn, lsampl_t * data) 
		if (insn->n == 5)

			return 0;

		break;

		//by default we allow the insn since we don't have checks for all possible cases yet

	/* by default we allow the insn since we don't have checks for

	 * all possible cases yet */

	default:

		rt_printk

			("comedi: no check for data length of config insn id %i is implemented.\n"

		rt_printk("comedi: no check for data length of config insn id "

			  "%i is implemented.\n"

			  " Add a check to %s in %s.\n"

			" Assuming n=%i is correct.\n", data[0], __FUNCTION__,

			  " Assuming n=%i is correct.\n", data[0], __func__,

			  __FILE__, insn->n);

		return 0;

		break;
@@ -833,7 +837,8 @@ static int parse_insn(comedi_device * dev, comedi_insn * insn, lsampl_t * data, 
			goto out;

		}



		if ((ret = check_chanlist(s, 1, &insn->chanspec)) < 0) {

		ret = check_chanlist(s, 1, &insn->chanspec);

		if (ret < 0) {

			ret = -EINVAL;

			DPRINTK("bad chanspec\n");

			goto out;
@@ -940,7 +945,6 @@ static int do_insn_ioctl(comedi_device * dev, void *arg, void *file) 
	ret = insn.n;



error:

	if (data)

	kfree(data);



	return ret;
@@ -973,7 +977,7 @@ static int do_cmd_ioctl(comedi_device * dev, void *arg, void *file) 
		DPRINTK("bad cmd address\n");

		return -EFAULT;

	}

	// save user's chanlist pointer so it can be restored later

	/* save user's chanlist pointer so it can be restored later */

	chanlist_saver = user_cmd.chanlist;



	if (user_cmd.subdev >= dev->n_subdevices) {
@@ -1024,7 +1028,6 @@ static int do_cmd_ioctl(comedi_device * dev, void *arg, void *file) 
		goto cleanup;

	}



	if (async->cmd.chanlist)

	kfree(async->cmd.chanlist);

	async->cmd = user_cmd;

	async->cmd.data = NULL;
@@ -1045,8 +1048,8 @@ static int do_cmd_ioctl(comedi_device * dev, void *arg, void *file) 
	}



	/* make sure each element in channel/gain list is valid */

	if ((ret = check_chanlist(s, async->cmd.chanlist_len,

				async->cmd.chanlist)) < 0) {

	ret = check_chanlist(s, async->cmd.chanlist_len, async->cmd.chanlist);

	if (ret < 0) {

		DPRINTK("bad chanlist\n");

		goto cleanup;

	}
@@ -1056,7 +1059,7 @@ static int do_cmd_ioctl(comedi_device * dev, void *arg, void *file) 
	if (async->cmd.flags & TRIG_BOGUS || ret) {

		DPRINTK("test returned %d\n", ret);

		user_cmd = async->cmd;

		// restore chanlist pointer before copying back

		/* restore chanlist pointer before copying back */

		user_cmd.chanlist = chanlist_saver;

		user_cmd.data = NULL;

		if (copy_to_user(arg, &user_cmd, sizeof(comedi_cmd))) {
@@ -1079,9 +1082,8 @@ static int do_cmd_ioctl(comedi_device * dev, void *arg, void *file) 
	async->cb_mask =

	    COMEDI_CB_EOA | COMEDI_CB_BLOCK | COMEDI_CB_ERROR |

	    COMEDI_CB_OVERFLOW;

	if (async->cmd.flags & TRIG_WAKE_EOS) {

	if (async->cmd.flags & TRIG_WAKE_EOS)

		async->cb_mask |= COMEDI_CB_EOS;

	}



	comedi_set_subdevice_runflags(s, ~0, SRF_USER | SRF_RUNNING);
@@ -1129,7 +1131,7 @@ static int do_cmdtest_ioctl(comedi_device * dev, void *arg, void *file) 
		DPRINTK("bad cmd address\n");

		return -EFAULT;

	}

	// save user's chanlist pointer so it can be restored later

	/* save user's chanlist pointer so it can be restored later */

	chanlist_saver = user_cmd.chanlist;



	if (user_cmd.subdev >= dev->n_subdevices) {
@@ -1160,8 +1162,7 @@ static int do_cmdtest_ioctl(comedi_device * dev, void *arg, void *file) 
	/* load channel/gain list */

	if (user_cmd.chanlist) {

		chanlist =

			kmalloc(user_cmd.chanlist_len * sizeof(int),

			GFP_KERNEL);

		    kmalloc(user_cmd.chanlist_len * sizeof(int), GFP_KERNEL);

		if (!chanlist) {

			DPRINTK("allocation failed\n");

			ret = -ENOMEM;
@@ -1176,8 +1177,8 @@ static int do_cmdtest_ioctl(comedi_device * dev, void *arg, void *file) 
		}



		/* make sure each element in channel/gain list is valid */

		if ((ret = check_chanlist(s, user_cmd.chanlist_len,

					chanlist)) < 0) {

		ret = check_chanlist(s, user_cmd.chanlist_len, chanlist);

		if (ret < 0) {

			DPRINTK("bad chanlist\n");

			goto cleanup;

		}
@@ -1187,7 +1188,7 @@ static int do_cmdtest_ioctl(comedi_device * dev, void *arg, void *file) 


	ret = s->do_cmdtest(dev, s, &user_cmd);



	// restore chanlist pointer before copying back

	/* restore chanlist pointer before copying back */

	user_cmd.chanlist = chanlist_saver;



	if (copy_to_user(arg, &user_cmd, sizeof(comedi_cmd))) {
@@ -1196,7 +1197,6 @@ static int do_cmdtest_ioctl(comedi_device * dev, void *arg, void *file) 
		goto cleanup;

	}

cleanup:

	if (chanlist)

	kfree(chanlist);



	return ret;
@@ -1228,11 +1228,10 @@ static int do_lock_ioctl(comedi_device * dev, unsigned int arg, void *file) 
	s = dev->subdevices + arg;



	comedi_spin_lock_irqsave(&s->spin_lock, flags);

	if (s->busy || s->lock) {

	if (s->busy || s->lock)

		ret = -EBUSY;

	} else {

	else

		s->lock = file;

	}

	comedi_spin_unlock_irqrestore(&s->spin_lock, flags);



	if (ret < 0)
@@ -1387,13 +1386,14 @@ void comedi_unmap(struct vm_area_struct *area) 
}



static struct vm_operations_struct comedi_vm_ops = {

      close:comedi_unmap,

	.close =	comedi_unmap,

};



static int comedi_mmap(struct file *file, struct vm_area_struct *vma)

{

	const unsigned minor = iminor(file->f_dentry->d_inode);

	struct comedi_device_file_info *dev_file_info = comedi_get_device_file_info(minor);

	struct comedi_device_file_info *dev_file_info =

	    comedi_get_device_file_info(minor);

	comedi_device *dev = dev_file_info->device;

	comedi_async *async = NULL;

	unsigned long start = vma->vm_start;
@@ -1409,11 +1409,11 @@ static int comedi_mmap(struct file *file, struct vm_area_struct *vma) 
		retval = -ENODEV;

		goto done;

	}

	if (vma->vm_flags & VM_WRITE) {

	if (vma->vm_flags & VM_WRITE)

		s = comedi_get_write_subdevice(dev_file_info);

	} else {

	else

		s = comedi_get_read_subdevice(dev_file_info);

	}



	if (s == NULL) {

		retval = -EINVAL;

		goto done;
@@ -1444,7 +1444,8 @@ static int comedi_mmap(struct file *file, struct vm_area_struct *vma) 
	for (i = 0; i < n_pages; ++i) {

		if (remap_pfn_range(vma, start,

				    page_to_pfn(virt_to_page(async->

						buf_page_list[i].virt_addr)),

							     buf_page_list[i].

							     virt_addr)),

				    PAGE_SIZE, PAGE_SHARED)) {

			retval = -EAGAIN;

			goto done;
@@ -1467,7 +1468,8 @@ static unsigned int comedi_poll(struct file *file, poll_table * wait) 
{

	unsigned int mask = 0;

	const unsigned minor = iminor(file->f_dentry->d_inode);

	struct comedi_device_file_info *dev_file_info = comedi_get_device_file_info(minor);

	struct comedi_device_file_info *dev_file_info =

	    comedi_get_device_file_info(minor);

	comedi_device *dev = dev_file_info->device;

	comedi_subdevice *read_subdev;

	comedi_subdevice *write_subdev;
@@ -1493,7 +1495,8 @@ static unsigned int comedi_poll(struct file *file, poll_table * wait) 
	write_subdev = comedi_get_write_subdevice(dev_file_info);

	if (write_subdev) {

		poll_wait(file, &write_subdev->async->wait_head, wait);

		comedi_buf_write_alloc(write_subdev->async, write_subdev->async->prealloc_bufsz);

		comedi_buf_write_alloc(write_subdev->async,

				       write_subdev->async->prealloc_bufsz);

		if (!write_subdev->busy

		    || !(comedi_get_subdevice_runflags(write_subdev) &

			 SRF_RUNNING)
@@ -1515,7 +1518,8 @@ static ssize_t comedi_write(struct file *file, const char *buf, size_t nbytes, 
	int n, m, count = 0, retval = 0;

	DECLARE_WAITQUEUE(wait, current);

	const unsigned minor = iminor(file->f_dentry->d_inode);

	struct comedi_device_file_info *dev_file_info = comedi_get_device_file_info(minor);

	struct comedi_device_file_info *dev_file_info =

	    comedi_get_device_file_info(minor);

	comedi_device *dev = dev_file_info->device;



	if (!dev->attached) {
@@ -1550,13 +1554,11 @@ static ssize_t comedi_write(struct file *file, const char *buf, size_t nbytes, 
		n = nbytes;



		m = n;

		if (async->buf_write_ptr + m > async->prealloc_bufsz) {

		if (async->buf_write_ptr + m > async->prealloc_bufsz)

			m = async->prealloc_bufsz - async->buf_write_ptr;

		}

		comedi_buf_write_alloc(async, async->prealloc_bufsz);

		if (m > comedi_buf_write_n_allocated(async)) {

		if (m > comedi_buf_write_n_allocated(async))

			m = comedi_buf_write_n_allocated(async);

		}

		if (m < n)

			n = m;
@@ -1580,9 +1582,8 @@ static ssize_t comedi_write(struct file *file, const char *buf, size_t nbytes, 
				break;

			}

			schedule();

			if (!s->busy) {

			if (!s->busy)

				break;

			}

			if (s->busy != file) {

				retval = -EACCES;

				break;
@@ -1608,7 +1609,7 @@ static ssize_t comedi_write(struct file *file, const char *buf, size_t nbytes, 
	remove_wait_queue(&async->wait_head, &wait);



done:

	return (count ? count : retval);

	return count ? count : retval;

}



static ssize_t comedi_read(struct file *file, char *buf, size_t nbytes,
@@ -1619,7 +1620,8 @@ static ssize_t comedi_read(struct file *file, char *buf, size_t nbytes, 
	int n, m, count = 0, retval = 0;

	DECLARE_WAITQUEUE(wait, current);

	const unsigned minor = iminor(file->f_dentry->d_inode);

	struct comedi_device_file_info *dev_file_info = comedi_get_device_file_info(minor);

	struct comedi_device_file_info *dev_file_info =

	    comedi_get_device_file_info(minor);

	comedi_device *dev = dev_file_info->device;



	if (!dev->attached) {
@@ -1654,11 +1656,10 @@ static ssize_t comedi_read(struct file *file, char *buf, size_t nbytes, 
		n = nbytes;



		m = comedi_buf_read_n_available(async);

//printk("%d available\n",m);

		if (async->buf_read_ptr + m > async->prealloc_bufsz) {

		/* printk("%d available\n",m); */

		if (async->buf_read_ptr + m > async->prealloc_bufsz)

			m = async->prealloc_bufsz - async->buf_read_ptr;

		}

//printk("%d contiguous\n",m);

		/* printk("%d contiguous\n",m); */

		if (m < n)

			n = m;
@@ -1716,7 +1717,7 @@ static ssize_t comedi_read(struct file *file, char *buf, size_t nbytes, 
	remove_wait_queue(&async->wait_head, &wait);



done:

	return (count ? count : retval);

	return count ? count : retval;

}



/*
@@ -1737,7 +1738,8 @@ void do_become_nonbusy(comedi_device * dev, comedi_subdevice * s) 
		comedi_reset_async_buf(async);

		async->inttrig = NULL;

	} else {

		printk("BUG: (?) do_become_nonbusy called with async=0\n");

		printk(KERN_ERR

		       "BUG: (?) do_become_nonbusy called with async=0\n");

	}



	s->busy = NULL;
@@ -1747,7 +1749,8 @@ static int comedi_open(struct inode *inode, struct file *file) 
{

	char mod[32];

	const unsigned minor = iminor(inode);

	struct comedi_device_file_info *dev_file_info = comedi_get_device_file_info(minor);

	struct comedi_device_file_info *dev_file_info =

	    comedi_get_device_file_info(minor);

	comedi_device *dev = dev_file_info->device;

	if (dev == NULL) {

		DPRINTK("invalid minor number\n");
@@ -1805,9 +1808,8 @@ static int comedi_open(struct inode *inode, struct file *file) 
		}

	}



	if (dev->attached && dev->use_count == 0 && dev->open) {

	if (dev->attached && dev->use_count == 0 && dev->open)

		dev->open(dev);

	}



	dev->use_count++;
@@ -1819,7 +1821,8 @@ static int comedi_open(struct inode *inode, struct file *file) 
static int comedi_close(struct inode *inode, struct file *file)

{

	const unsigned minor = iminor(inode);

	struct comedi_device_file_info *dev_file_info = comedi_get_device_file_info(minor);

	struct comedi_device_file_info *dev_file_info =

	    comedi_get_device_file_info(minor);

	comedi_device *dev = dev_file_info->device;

	comedi_subdevice *s = NULL;

	int i;
@@ -1830,30 +1833,25 @@ static int comedi_close(struct inode *inode, struct file *file) 
		for (i = 0; i < dev->n_subdevices; i++) {

			s = dev->subdevices + i;



			if (s->busy == file) {

			if (s->busy == file)

				do_cancel(dev, s);

			}

			if (s->lock == file) {

			if (s->lock == file)

				s->lock = NULL;

		}

	}

	}

	if (dev->attached && dev->use_count == 1 && dev->close) {

	if (dev->attached && dev->use_count == 1 && dev->close)

		dev->close(dev);

	}



	module_put(THIS_MODULE);

	if (dev->attached) {

	if (dev->attached)

		module_put(dev->driver->module);

	}



	dev->use_count--;



	mutex_unlock(&dev->mutex);



	if (file->f_flags & FASYNC) {

	if (file->f_flags & FASYNC)

		comedi_fasync(-1, file, 0);

	}



	return 0;

}
@@ -1861,51 +1859,54 @@ static int comedi_close(struct inode *inode, struct file *file) 
static int comedi_fasync(int fd, struct file *file, int on)

{

	const unsigned minor = iminor(file->f_dentry->d_inode);

	struct comedi_device_file_info *dev_file_info = comedi_get_device_file_info(minor);

	struct comedi_device_file_info *dev_file_info =

	    comedi_get_device_file_info(minor);



	comedi_device *dev = dev_file_info->device;



	return fasync_helper(fd, file, on, &dev->async_queue);

}



const struct file_operations comedi_fops = {

      owner:THIS_MODULE,

      .owner =		THIS_MODULE,

#ifdef HAVE_UNLOCKED_IOCTL

      unlocked_ioctl:comedi_unlocked_ioctl,

      .unlocked_ioctl =	comedi_unlocked_ioctl,

#else

      ioctl:comedi_ioctl,

      .ioctl =		comedi_ioctl,

#endif

#ifdef HAVE_COMPAT_IOCTL

      compat_ioctl:comedi_compat_ioctl,

      .compat_ioctl =	comedi_compat_ioctl,

#endif

      open:comedi_open,

      release:comedi_close,

      read:comedi_read,

      write:comedi_write,

      mmap:comedi_mmap,

      poll:comedi_poll,

      fasync:comedi_fasync,

      .open =		comedi_open,

      .release =	comedi_close,

      .read =		comedi_read,

      .write =		comedi_write,

      .mmap =		comedi_mmap,

      .poll =		comedi_poll,

      .fasync =		comedi_fasync,

};



struct class *comedi_class = NULL;

struct class *comedi_class;

static struct cdev comedi_cdev;



static void comedi_cleanup_legacy_minors(void)

{

	unsigned i;

	for (i = 0; i < COMEDI_NUM_LEGACY_MINORS; i++) {



	for (i = 0; i < COMEDI_NUM_LEGACY_MINORS; i++)

		comedi_free_board_minor(i);

}

}



static int __init comedi_init(void)

{

	int i;

	int retval;



	printk("comedi: version " COMEDI_RELEASE

	printk(KERN_INFO "comedi: version " COMEDI_RELEASE

	       " - http://www.comedi.org\n");



	memset(comedi_file_info_table, 0, sizeof(struct comedi_device_file_info*) * COMEDI_NUM_MINORS);

	memset(comedi_file_info_table, 0,

	       sizeof(struct comedi_device_file_info *) * COMEDI_NUM_MINORS);



	retval = register_chrdev_region(MKDEV(COMEDI_MAJOR, 0),

					COMEDI_NUM_MINORS, "comedi");
@@ -1931,12 +1932,11 @@ static int __init comedi_init(void) 
	/* XXX requires /proc interface */

	comedi_proc_init();



	// create devices files for legacy/manual use

	/* create devices files for legacy/manual use */

	for (i = 0; i < COMEDI_NUM_LEGACY_MINORS; i++) {

		int minor;

		minor = comedi_alloc_board_minor(NULL);

		if(minor < 0)

		{

		if (minor < 0) {

			comedi_cleanup_legacy_minors();

			cdev_del(&comedi_cdev);

			unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
@@ -1958,9 +1958,8 @@ static void __exit comedi_cleanup(void) 


	comedi_cleanup_legacy_minors();

	for (i = 0; i < COMEDI_NUM_MINORS; ++i)

	{

		BUG_ON(comedi_file_info_table[i]);

	}





	class_destroy(comedi_class);

	cdev_del(&comedi_cdev);
@@ -1988,14 +1987,13 @@ void comedi_event(comedi_device * dev, comedi_subdevice * s) 
	unsigned runflags = 0;

	unsigned runflags_mask = 0;



	//DPRINTK("comedi_event 0x%x\n",mask);

	/* DPRINTK("comedi_event 0x%x\n",mask); */



	if ((comedi_get_subdevice_runflags(s) & SRF_RUNNING) == 0)

		return;



	if (s->async->

		events & (COMEDI_CB_EOA | COMEDI_CB_ERROR | COMEDI_CB_OVERFLOW))

	{

	    events & (COMEDI_CB_EOA | COMEDI_CB_ERROR | COMEDI_CB_OVERFLOW)) {

		runflags_mask |= SRF_RUNNING;

	}

	/* remember if an error event has occured, so an error
@@ -2014,10 +2012,11 @@ void comedi_event(comedi_device * dev, comedi_subdevice * s) 


			if (dev->rt) {

#ifdef CONFIG_COMEDI_RT

				// pend wake up

				/* pend wake up */

				comedi_rt_pend_wakeup(&async->wait_head);

#else

				printk("BUG: comedi_event() code unreachable\n");

				printk

				    ("BUG: comedi_event() code unreachable\n");

#endif

			} else {

				wake_up_interruptible(&async->wait_head);
@@ -2094,7 +2093,8 @@ void comedi_device_init(comedi_device *dev) 


void comedi_device_cleanup(comedi_device *dev)

{

	if(dev == NULL) return;

	if (dev == NULL)

		return;

	mutex_lock(&dev->mutex);

	comedi_device_detach(dev);

	mutex_unlock(&dev->mutex);
@@ -2109,38 +2109,37 @@ int comedi_alloc_board_minor(struct device *hardware_device) 
	unsigned i;



	info = kzalloc(sizeof(struct comedi_device_file_info), GFP_KERNEL);

	if(info == NULL) return -ENOMEM;

	if (info == NULL)

		return -ENOMEM;

	info->device = kzalloc(sizeof(comedi_device), GFP_KERNEL);

	if(info->device == NULL)

	{

	if (info->device == NULL) {

		kfree(info);

		return -ENOMEM;

	}

	comedi_device_init(info->device);

	comedi_spin_lock_irqsave(&comedi_file_info_table_lock, flags);

	for(i = 0; i < COMEDI_NUM_BOARD_MINORS; ++i)

	{

		if(comedi_file_info_table[i] == NULL)

		{

	for (i = 0; i < COMEDI_NUM_BOARD_MINORS; ++i) {

		if (comedi_file_info_table[i] == NULL) {

			comedi_file_info_table[i] = info;

			break;

		}

	}

	comedi_spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);

	if(i == COMEDI_NUM_BOARD_MINORS)

	{

	if (i == COMEDI_NUM_BOARD_MINORS) {

		comedi_device_cleanup(info->device);

		kfree(info->device);

		kfree(info);

		rt_printk("comedi: error: ran out of minor numbers for board device files.\n");

		rt_printk

		    ("comedi: error: ran out of minor numbers for board device files.\n");

		return -EBUSY;

	}

	info->device->minor = i;

	csdev = COMEDI_DEVICE_CREATE(comedi_class, NULL,

		MKDEV(COMEDI_MAJOR, i), NULL, hardware_device, "comedi%i", i);

	if(!IS_ERR(csdev)) {

				     MKDEV(COMEDI_MAJOR, i), NULL,

				     hardware_device, "comedi%i", i);

	if (!IS_ERR(csdev))

		info->device->class_dev = csdev;

	}



	return i;

}
@@ -2155,14 +2154,12 @@ void comedi_free_board_minor(unsigned minor) 
	comedi_file_info_table[minor] = NULL;

	comedi_spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);



	if(info)

	{

	if (info) {

		comedi_device *dev = info->device;

		if(dev)

		{

			if(dev->class_dev)

			{

				device_destroy(comedi_class, MKDEV(COMEDI_MAJOR, dev->minor));

		if (dev) {

			if (dev->class_dev) {

				device_destroy(comedi_class,

					       MKDEV(COMEDI_MAJOR, dev->minor));

			}

			comedi_device_cleanup(dev);

			kfree(dev);
@@ -2179,33 +2176,33 @@ int comedi_alloc_subdevice_minor(comedi_device *dev, comedi_subdevice *s) 
	unsigned i;



	info = kmalloc(sizeof(struct comedi_device_file_info), GFP_KERNEL);

	if(info == NULL) return -ENOMEM;

	if (info == NULL)

		return -ENOMEM;

	info->device = dev;

	info->read_subdevice = s;

	info->write_subdevice = s;

	comedi_spin_lock_irqsave(&comedi_file_info_table_lock, flags);

	for(i = COMEDI_FIRST_SUBDEVICE_MINOR; i < COMEDI_NUM_BOARD_MINORS; ++i)

	{

		if(comedi_file_info_table[i] == NULL)

		{

	for (i = COMEDI_FIRST_SUBDEVICE_MINOR; i < COMEDI_NUM_BOARD_MINORS; ++i) {

		if (comedi_file_info_table[i] == NULL) {

			comedi_file_info_table[i] = info;

			break;

		}

	}

	comedi_spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);

	if(i == COMEDI_NUM_MINORS)

	{

	if (i == COMEDI_NUM_MINORS) {

		kfree(info);

		rt_printk("comedi: error: ran out of minor numbers for board device files.\n");

		rt_printk

		    ("comedi: error: ran out of minor numbers for board device files.\n");

		return -EBUSY;

	}

	s->minor = i;

	csdev = COMEDI_DEVICE_CREATE(comedi_class, dev->class_dev,

		MKDEV(COMEDI_MAJOR, i), NULL, NULL, "comedi%i_subd%i", dev->minor, (int)(s - dev->subdevices));

				     MKDEV(COMEDI_MAJOR, i), NULL, NULL,

				     "comedi%i_subd%i", dev->minor,

				     (int)(s - dev->subdevices));

	if (!IS_ERR(csdev))

	{

		s->class_dev = csdev;

	}



	return i;

}
@@ -2214,8 +2211,10 @@ void comedi_free_subdevice_minor(comedi_subdevice *s) 
	unsigned long flags;

	struct comedi_device_file_info *info;



	if(s == NULL) return;

	if(s->minor < 0) return;

	if (s == NULL)

		return;

	if (s->minor < 0)

		return;



	BUG_ON(s->minor >= COMEDI_NUM_MINORS);

	BUG_ON(s->minor < COMEDI_FIRST_SUBDEVICE_MINOR);
@@ -2225,8 +2224,7 @@ void comedi_free_subdevice_minor(comedi_subdevice *s) 
	comedi_file_info_table[s->minor] = NULL;

	comedi_spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);



	if(s->class_dev)

	{

	if (s->class_dev) {

		device_destroy(comedi_class, MKDEV(COMEDI_MAJOR, s->minor));

		s->class_dev = NULL;

	}