microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

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: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Greg Kroah-Hartman 2008-11-13 17:05:58 -08:00
Родитель e0dcef71f6
Коммит 476b847733
1 изменённых файлов: 261 добавлений и 263 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

296
drivers/staging/comedi/comedi_fops.c
Просмотреть файл

@ -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 @@ ok:
}
}
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 @@ ok:
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;
}