#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/init.h>
-#include <asm/uaccess.h>
-#include <asm/atomic.h>
+#include <linux/uaccess.h>
+#include <linux/atomic.h>
#include <linux/delay.h>
#include <linux/usb.h>
#include <linux/mutex.h>
/*-------------------------------------------------------------------*/
-static int dabusb_add_buf_tail (pdabusb_t s, struct list_head *dst, struct list_head *src)
+static int dabusb_add_buf_tail(pdabusb_t s, struct list_head *dst,
+ struct list_head *src)
{
unsigned long flags;
struct list_head *tmp;
int ret = 0;
- spin_lock_irqsave (&s->lock, flags);
+ spin_lock_irqsave(&s->lock, flags);
- if (list_empty (src)) {
- // no elements in source buffer
+ if (list_empty(src)) {
+ /* no elements in source buffer */
ret = -1;
goto err;
}
tmp = src->next;
- list_move_tail (tmp, dst);
+ list_move_tail(tmp, dst);
- err: spin_unlock_irqrestore (&s->lock, flags);
+err: spin_unlock_irqrestore(&s->lock, flags);
return ret;
}
/*-------------------------------------------------------------------*/
#ifdef DEBUG
-static void dump_urb (struct urb *urb)
+static void dump_urb(struct urb *urb)
{
dbg("urb :%p", urb);
dbg("dev :%p", urb->dev);
}
#endif
/*-------------------------------------------------------------------*/
-static int dabusb_cancel_queue (pdabusb_t s, struct list_head *q)
+static int dabusb_cancel_queue(pdabusb_t s, struct list_head *q)
{
unsigned long flags;
pbuff_t b;
dbg("dabusb_cancel_queue");
- spin_lock_irqsave (&s->lock, flags);
+ spin_lock_irqsave(&s->lock, flags);
list_for_each_entry(b, q, buff_list) {
#ifdef DEBUG
dump_urb(b->purb);
#endif
- usb_unlink_urb (b->purb);
+ usb_unlink_urb(b->purb);
}
- spin_unlock_irqrestore (&s->lock, flags);
+ spin_unlock_irqrestore(&s->lock, flags);
return 0;
}
/*-------------------------------------------------------------------*/
-static int dabusb_free_queue (struct list_head *q)
+static int dabusb_free_queue(struct list_head *q)
{
struct list_head *tmp;
struct list_head *p;
dbg("dabusb_free_queue");
for (p = q->next; p != q;) {
- b = list_entry (p, buff_t, buff_list);
+ b = list_entry(p, buff_t, buff_list);
#ifdef DEBUG
dump_urb(b->purb);
kfree(b->purb->transfer_buffer);
usb_free_urb(b->purb);
tmp = p->next;
- list_del (p);
- kfree (b);
+ list_del(p);
+ kfree(b);
p = tmp;
}
return 0;
}
/*-------------------------------------------------------------------*/
-static int dabusb_free_buffers (pdabusb_t s)
+static int dabusb_free_buffers(pdabusb_t s)
{
unsigned long flags;
dbg("dabusb_free_buffers");
spin_lock_irqsave(&s->lock, flags);
- dabusb_free_queue (&s->free_buff_list);
- dabusb_free_queue (&s->rec_buff_list);
+ dabusb_free_queue(&s->free_buff_list);
+ dabusb_free_queue(&s->rec_buff_list);
spin_unlock_irqrestore(&s->lock, flags);
return 0;
}
/*-------------------------------------------------------------------*/
-static void dabusb_iso_complete (struct urb *purb)
+static void dabusb_iso_complete(struct urb *purb)
{
pbuff_t b = purb->context;
pdabusb_t s = b->s;
dbg("dabusb_iso_complete");
- // process if URB was not killed
+ /* process if URB was not killed */
if (purb->status != -ENOENT) {
- unsigned int pipe = usb_rcvisocpipe (purb->dev, _DABUSB_ISOPIPE);
- int pipesize = usb_maxpacket (purb->dev, pipe, usb_pipeout (pipe));
+ unsigned int pipe = usb_rcvisocpipe(purb->dev, _DABUSB_ISOPIPE);
+ int pipesize = usb_maxpacket(purb->dev, pipe,
+ usb_pipeout(pipe));
for (i = 0; i < purb->number_of_packets; i++)
if (!purb->iso_frame_desc[i].status) {
len = purb->iso_frame_desc[i].actual_length;
if (len <= pipesize) {
- memcpy (buf + dst, buf + purb->iso_frame_desc[i].offset, len);
+ memcpy(buf + dst, buf + purb->iso_frame_desc[i].offset, len);
dst += len;
- }
- else
+ } else
dev_err(&purb->dev->dev,
- "dabusb_iso_complete: invalid len %d\n", len);
- }
- else
- dev_warn(&purb->dev->dev, "dabusb_iso_complete: corrupted packet status: %d\n", purb->iso_frame_desc[i].status);
+ "dabusb_iso_complete: invalid len %d\n",
+ len);
+ } else
+ dev_warn(&purb->dev->dev,
+ "dabusb_iso_complete: corrupted packet status: %d\n",
+ purb->iso_frame_desc[i].status);
if (dst != purb->actual_length)
dev_err(&purb->dev->dev,
"dst!=purb->actual_length:%d!=%d\n",
dst, purb->actual_length);
}
- if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) {
+ if (atomic_dec_and_test(&s->pending_io) &&
+ !s->remove_pending && s->state != _stopped) {
s->overruns++;
dev_err(&purb->dev->dev, "overrun (%d)\n", s->overruns);
}
- wake_up (&s->wait);
+ wake_up(&s->wait);
}
/*-------------------------------------------------------------------*/
-static int dabusb_alloc_buffers (pdabusb_t s)
+static int dabusb_alloc_buffers(pdabusb_t s)
{
int transfer_len = 0;
pbuff_t b;
- unsigned int pipe = usb_rcvisocpipe (s->usbdev, _DABUSB_ISOPIPE);
- int pipesize = usb_maxpacket (s->usbdev, pipe, usb_pipeout (pipe));
+ unsigned int pipe = usb_rcvisocpipe(s->usbdev, _DABUSB_ISOPIPE);
+ int pipesize = usb_maxpacket(s->usbdev, pipe, usb_pipeout(pipe));
int packets = _ISOPIPESIZE / pipesize;
int transfer_buffer_length = packets * pipesize;
int i;
pipesize, packets, transfer_buffer_length);
while (transfer_len < (s->total_buffer_size << 10)) {
- b = kzalloc(sizeof (buff_t), GFP_KERNEL);
+ b = kzalloc(sizeof(buff_t), GFP_KERNEL);
if (!b) {
dev_err(&s->usbdev->dev,
"kzalloc(sizeof(buff_t))==NULL\n");
b->purb = usb_alloc_urb(packets, GFP_KERNEL);
if (!b->purb) {
dev_err(&s->usbdev->dev, "usb_alloc_urb == NULL\n");
- kfree (b);
+ kfree(b);
goto err;
}
- b->purb->transfer_buffer = kmalloc (transfer_buffer_length, GFP_KERNEL);
+ b->purb->transfer_buffer = kmalloc(transfer_buffer_length,
+ GFP_KERNEL);
if (!b->purb->transfer_buffer) {
- kfree (b->purb);
- kfree (b);
+ kfree(b->purb);
+ kfree(b);
dev_err(&s->usbdev->dev,
"kmalloc(%d)==NULL\n", transfer_buffer_length);
goto err;
}
transfer_len += transfer_buffer_length;
- list_add_tail (&b->buff_list, &s->free_buff_list);
+ list_add_tail(&b->buff_list, &s->free_buff_list);
}
s->got_mem = transfer_len;
return 0;
- err:
- dabusb_free_buffers (s);
+err:
+ dabusb_free_buffers(s);
return -ENOMEM;
}
/*-------------------------------------------------------------------*/
-static int dabusb_bulk (pdabusb_t s, pbulk_transfer_t pb)
+static int dabusb_bulk(pdabusb_t s, pbulk_transfer_t pb)
{
int ret;
unsigned int pipe;
dbg("dabusb_bulk");
if (!pb->pipe)
- pipe = usb_rcvbulkpipe (s->usbdev, 2);
+ pipe = usb_rcvbulkpipe(s->usbdev, 2);
else
- pipe = usb_sndbulkpipe (s->usbdev, 2);
+ pipe = usb_sndbulkpipe(s->usbdev, 2);
- ret=usb_bulk_msg(s->usbdev, pipe, pb->data, pb->size, &actual_length, 100);
- if(ret<0) {
+ ret = usb_bulk_msg(s->usbdev, pipe, pb->data,
+ pb->size, &actual_length, 100);
+ if (ret < 0) {
dev_err(&s->usbdev->dev,
"usb_bulk_msg failed(%d)\n", ret);
- if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
+ if (usb_set_interface(s->usbdev, _DABUSB_IF, 1) < 0) {
dev_err(&s->usbdev->dev, "set_interface failed\n");
return -EINVAL;
}
}
- if( ret == -EPIPE ) {
+ if (ret == -EPIPE) {
dev_warn(&s->usbdev->dev, "CLEAR_FEATURE request to remove STALL condition.\n");
- if(usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
+ if (usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
dev_err(&s->usbdev->dev, "request failed\n");
}
return ret;
}
/* --------------------------------------------------------------------- */
-static int dabusb_writemem (pdabusb_t s, int pos, const unsigned char *data,
+static int dabusb_writemem(pdabusb_t s, int pos, const unsigned char *data,
int len)
{
int ret;
- unsigned char *transfer_buffer = kmalloc (len, GFP_KERNEL);
+ unsigned char *transfer_buffer = kmalloc(len, GFP_KERNEL);
if (!transfer_buffer) {
dev_err(&s->usbdev->dev,
return -ENOMEM;
}
- memcpy (transfer_buffer, data, len);
+ memcpy(transfer_buffer, data, len);
- ret=usb_control_msg(s->usbdev, usb_sndctrlpipe( s->usbdev, 0 ), 0xa0, 0x40, pos, 0, transfer_buffer, len, 300);
+ ret = usb_control_msg(s->usbdev, usb_sndctrlpipe(s->usbdev, 0),
+ 0xa0, 0x40, pos, 0, transfer_buffer, len, 300);
- kfree (transfer_buffer);
+ kfree(transfer_buffer);
return ret;
}
/* --------------------------------------------------------------------- */
-static int dabusb_8051_reset (pdabusb_t s, unsigned char reset_bit)
+static int dabusb_8051_reset(pdabusb_t s, unsigned char reset_bit)
{
- dbg("dabusb_8051_reset: %d",reset_bit);
- return dabusb_writemem (s, CPUCS_REG, &reset_bit, 1);
+ dbg("dabusb_8051_reset: %d", reset_bit);
+ return dabusb_writemem(s, CPUCS_REG, &reset_bit, 1);
}
/* --------------------------------------------------------------------- */
-static int dabusb_loadmem (pdabusb_t s, const char *fname)
+static int dabusb_loadmem(pdabusb_t s, const char *fname)
{
int ret;
const struct ihex_binrec *rec;
"Failed to load \"dabusb/firmware.fw\": %d\n", ret);
goto out;
}
- ret = dabusb_8051_reset (s, 1);
+ ret = dabusb_8051_reset(s, 1);
for (rec = (const struct ihex_binrec *)fw->data; rec;
rec = ihex_next_binrec(rec)) {
break;
}
}
- ret = dabusb_8051_reset (s, 0);
+ ret = dabusb_8051_reset(s, 0);
release_firmware(fw);
out:
dbg("dabusb_loadmem: exit");
return ret;
}
/* --------------------------------------------------------------------- */
-static int dabusb_fpga_clear (pdabusb_t s, pbulk_transfer_t b)
+static int dabusb_fpga_clear(pdabusb_t s, pbulk_transfer_t b)
{
b->size = 4;
b->data[0] = 0x2a;
dbg("dabusb_fpga_clear");
- return dabusb_bulk (s, b);
+ return dabusb_bulk(s, b);
}
/* --------------------------------------------------------------------- */
-static int dabusb_fpga_init (pdabusb_t s, pbulk_transfer_t b)
+static int dabusb_fpga_init(pdabusb_t s, pbulk_transfer_t b)
{
b->size = 4;
b->data[0] = 0x2c;
dbg("dabusb_fpga_init");
- return dabusb_bulk (s, b);
+ return dabusb_bulk(s, b);
}
/* --------------------------------------------------------------------- */
-static int dabusb_fpga_download (pdabusb_t s, const char *fname)
+static int dabusb_fpga_download(pdabusb_t s, const char *fname)
{
- pbulk_transfer_t b = kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
+ pbulk_transfer_t b = kmalloc(sizeof(bulk_transfer_t), GFP_KERNEL);
const struct firmware *fw;
unsigned int blen, n;
int ret;
}
b->pipe = 1;
- ret = dabusb_fpga_clear (s, b);
- mdelay (10);
+ ret = dabusb_fpga_clear(s, b);
+ mdelay(10);
blen = fw->data[73] + (fw->data[72] << 8);
dbg("Bitstream len: %i", blen);
b->data[3] = 60;
for (n = 0; n <= blen + 60; n += 60) {
- // some cclks for startup
+ /* some cclks for startup */
b->size = 64;
- memcpy (b->data + 4, fw->data + 74 + n, 60);
- ret = dabusb_bulk (s, b);
+ memcpy(b->data + 4, fw->data + 74 + n, 60);
+ ret = dabusb_bulk(s, b);
if (ret < 0) {
dev_err(&s->usbdev->dev, "dabusb_bulk failed.\n");
break;
}
- mdelay (1);
+ mdelay(1);
}
- ret = dabusb_fpga_init (s, b);
- kfree (b);
+ ret = dabusb_fpga_init(s, b);
+ kfree(b);
release_firmware(fw);
dbg("exit dabusb_fpga_download");
return ret;
}
-static int dabusb_stop (pdabusb_t s)
+static int dabusb_stop(pdabusb_t s)
{
dbg("dabusb_stop");
s->state = _stopped;
- dabusb_cancel_queue (s, &s->rec_buff_list);
+ dabusb_cancel_queue(s, &s->rec_buff_list);
dbg("pending_io: %d", s->pending_io.counter);
return 0;
}
-static int dabusb_startrek (pdabusb_t s)
+static int dabusb_startrek(pdabusb_t s)
{
if (!s->got_mem && s->state != _started) {
dbg("dabusb_startrek");
- if (dabusb_alloc_buffers (s) < 0)
+ if (dabusb_alloc_buffers(s) < 0)
return -ENOMEM;
- dabusb_stop (s);
+ dabusb_stop(s);
s->state = _started;
s->readptr = 0;
}
- if (!list_empty (&s->free_buff_list)) {
+ if (!list_empty(&s->free_buff_list)) {
pbuff_t end;
int ret;
- while (!dabusb_add_buf_tail (s, &s->rec_buff_list, &s->free_buff_list)) {
+ while (!dabusb_add_buf_tail(s, &s->rec_buff_list, &s->free_buff_list)) {
- dbg("submitting: end:%p s->rec_buff_list:%p", s->rec_buff_list.prev, &s->rec_buff_list);
+ dbg("submitting: end:%p s->rec_buff_list:%p",
+ s->rec_buff_list.prev, &s->rec_buff_list);
- end = list_entry (s->rec_buff_list.prev, buff_t, buff_list);
+ end = list_entry(s->rec_buff_list.prev,
+ buff_t, buff_list);
- ret = usb_submit_urb (end->purb, GFP_KERNEL);
+ ret = usb_submit_urb(end->purb, GFP_KERNEL);
if (ret) {
dev_err(&s->usbdev->dev,
"usb_submit_urb returned:%d\n", ret);
- if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
+ if (dabusb_add_buf_tail(s, &s->free_buff_list,
+ &s->rec_buff_list))
dev_err(&s->usbdev->dev,
"startrek: dabusb_add_buf_tail failed\n");
break;
- }
- else
- atomic_inc (&s->pending_io);
+ } else
+ atomic_inc(&s->pending_io);
}
- dbg("pending_io: %d",s->pending_io.counter);
+ dbg("pending_io: %d", s->pending_io.counter);
}
return 0;
}
-static ssize_t dabusb_read (struct file *file, char __user *buf, size_t count, loff_t * ppos)
+static ssize_t dabusb_read(struct file *file, char __user *buf,
+ size_t count, loff_t *ppos)
{
- pdabusb_t s = (pdabusb_t) file->private_data;
+ pdabusb_t s = (pdabusb_t)file->private_data;
unsigned long flags;
unsigned ret = 0;
int rem;
return -EIO;
while (count > 0) {
- dabusb_startrek (s);
+ dabusb_startrek(s);
- spin_lock_irqsave (&s->lock, flags);
+ spin_lock_irqsave(&s->lock, flags);
- if (list_empty (&s->rec_buff_list)) {
+ if (list_empty(&s->rec_buff_list)) {
spin_unlock_irqrestore(&s->lock, flags);
goto err;
}
- b = list_entry (s->rec_buff_list.next, buff_t, buff_list);
+ b = list_entry(s->rec_buff_list.next, buff_t, buff_list);
purb = b->purb;
spin_unlock_irqrestore(&s->lock, flags);
if (purb->status == -EINPROGRESS) {
- if (file->f_flags & O_NONBLOCK) // return nonblocking
- {
+ /* return nonblocking */
+ if (file->f_flags & O_NONBLOCK) {
if (!ret)
ret = -EAGAIN;
goto err;
}
- interruptible_sleep_on (&s->wait);
+ interruptible_sleep_on(&s->wait);
- if (signal_pending (current)) {
+ if (signal_pending(current)) {
if (!ret)
ret = -ERESTARTSYS;
goto err;
}
- spin_lock_irqsave (&s->lock, flags);
+ spin_lock_irqsave(&s->lock, flags);
- if (list_empty (&s->rec_buff_list)) {
+ if (list_empty(&s->rec_buff_list)) {
spin_unlock_irqrestore(&s->lock, flags);
dev_err(&s->usbdev->dev,
"error: still no buffer available.\n");
goto err;
}
- rem = purb->actual_length - s->readptr; // set remaining bytes to copy
+ /* set remaining bytes to copy */
+ rem = purb->actual_length - s->readptr;
if (count >= rem)
cnt = rem;
else
cnt = count;
- dbg("copy_to_user:%p %p %d",buf, purb->transfer_buffer + s->readptr, cnt);
+ dbg("copy_to_user:%p %p %d", buf,
+ purb->transfer_buffer + s->readptr, cnt);
- if (copy_to_user (buf, purb->transfer_buffer + s->readptr, cnt)) {
+ if (copy_to_user(buf,
+ purb->transfer_buffer + s->readptr,
+ cnt)) {
dev_err(&s->usbdev->dev, "read: copy_to_user failed\n");
if (!ret)
ret = -EFAULT;
ret += cnt;
if (s->readptr == purb->actual_length) {
- // finished, take next buffer
- if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
+ /* finished, take next buffer */
+ if (dabusb_add_buf_tail(s, &s->free_buff_list,
+ &s->rec_buff_list))
dev_err(&s->usbdev->dev,
"read: dabusb_add_buf_tail failed\n");
s->readptr = 0;
}
}
- err: //mutex_unlock(&s->mutex);
+err: /*mutex_unlock(&s->mutex);*/
return ret;
}
-static int dabusb_open (struct inode *inode, struct file *file)
+static int dabusb_open(struct inode *inode, struct file *file)
{
int devnum = iminor(inode);
pdabusb_t s;
return -EBUSY;
msleep_interruptible(500);
- if (signal_pending (current))
+ if (signal_pending(current))
return -EAGAIN;
mutex_lock(&s->mutex);
}
- if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
+ if (usb_set_interface(s->usbdev, _DABUSB_IF, 1) < 0) {
mutex_unlock(&s->mutex);
dev_err(&s->usbdev->dev, "set_interface failed\n");
return -EINVAL;
return r;
}
-static int dabusb_release (struct inode *inode, struct file *file)
+static int dabusb_release(struct inode *inode, struct file *file)
{
- pdabusb_t s = (pdabusb_t) file->private_data;
+ pdabusb_t s = (pdabusb_t)file->private_data;
dbg("dabusb_release");
mutex_lock(&s->mutex);
- dabusb_stop (s);
- dabusb_free_buffers (s);
+ dabusb_stop(s);
+ dabusb_free_buffers(s);
mutex_unlock(&s->mutex);
if (!s->remove_pending) {
- if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
+ if (usb_set_interface(s->usbdev, _DABUSB_IF, 0) < 0)
dev_err(&s->usbdev->dev, "set_interface failed\n");
- }
- else
- wake_up (&s->remove_ok);
+ } else
+ wake_up(&s->remove_ok);
s->opened = 0;
return 0;
}
-static long dabusb_ioctl (struct file *file, unsigned int cmd, unsigned long arg)
+static long dabusb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
- pdabusb_t s = (pdabusb_t) file->private_data;
+ pdabusb_t s = (pdabusb_t)file->private_data;
pbulk_transfer_t pbulk;
int ret = 0;
int version = DABUSB_VERSION;
break;
}
- ret=dabusb_bulk (s, pbulk);
- if(ret==0)
+ ret = dabusb_bulk(s, pbulk);
+ if (ret == 0)
if (copy_to_user((void __user *)arg, pbulk,
sizeof(bulk_transfer_t)))
ret = -EFAULT;
- kfree (pbulk);
+ kfree(pbulk);
break;
case IOCTL_DAB_OVERRUNS:
- ret = put_user (s->overruns, (unsigned int __user *) arg);
+ ret = put_user(s->overruns, (unsigned int __user *) arg);
break;
case IOCTL_DAB_VERSION:
- ret = put_user (version, (unsigned int __user *) arg);
+ ret = put_user(version, (unsigned int __user *) arg);
break;
default:
return ret;
}
-static const struct file_operations dabusb_fops =
-{
+static const struct file_operations dabusb_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read = dabusb_read,
/* --------------------------------------------------------------------- */
-static int dabusb_probe (struct usb_interface *intf,
+static int dabusb_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct usb_device *usbdev = interface_to_usbdev(intf);
s->usbdev = usbdev;
s->devnum = intf->minor;
- if (usb_reset_configuration (usbdev) < 0) {
+ if (usb_reset_configuration(usbdev) < 0) {
dev_err(&intf->dev, "reset_configuration failed\n");
goto reject;
}
if (le16_to_cpu(usbdev->descriptor.idProduct) == 0x2131) {
- dabusb_loadmem (s, NULL);
+ dabusb_loadmem(s, NULL);
goto reject;
- }
- else {
- dabusb_fpga_download (s, NULL);
+ } else {
+ dabusb_fpga_download(s, NULL);
- if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
+ if (usb_set_interface(s->usbdev, _DABUSB_IF, 0) < 0) {
dev_err(&intf->dev, "set_interface failed\n");
goto reject;
}
}
dbg("bound to interface: %d", intf->altsetting->desc.bInterfaceNumber);
- usb_set_intfdata (intf, s);
+ usb_set_intfdata(intf, s);
mutex_unlock(&s->mutex);
retval = usb_register_dev(intf, &dabusb_class);
if (retval) {
- usb_set_intfdata (intf, NULL);
+ usb_set_intfdata(intf, NULL);
return -ENOMEM;
}
return 0;
- reject:
+reject:
mutex_unlock(&s->mutex);
s->usbdev = NULL;
return -ENODEV;
}
-static void dabusb_disconnect (struct usb_interface *intf)
+static void dabusb_disconnect(struct usb_interface *intf)
{
wait_queue_t __wait;
- pdabusb_t s = usb_get_intfdata (intf);
+ pdabusb_t s = usb_get_intfdata(intf);
dbg("dabusb_disconnect");
init_waitqueue_entry(&__wait, current);
- usb_set_intfdata (intf, NULL);
+ usb_set_intfdata(intf, NULL);
if (s) {
- usb_deregister_dev (intf, &dabusb_class);
+ usb_deregister_dev(intf, &dabusb_class);
s->remove_pending = 1;
- wake_up (&s->wait);
+ wake_up(&s->wait);
add_wait_queue(&s->remove_ok, &__wait);
set_current_state(TASK_UNINTERRUPTIBLE);
if (s->state == _started)
}
}
-static struct usb_device_id dabusb_ids [] = {
- // { USB_DEVICE(0x0547, 0x2131) }, /* An2131 chip, no boot ROM */
+static struct usb_device_id dabusb_ids[] = {
+ /* { USB_DEVICE(0x0547, 0x2131) },*/ /* An2131 chip, no boot ROM */
{ USB_DEVICE(0x0547, 0x9999) },
{ } /* Terminating entry */
};
-MODULE_DEVICE_TABLE (usb, dabusb_ids);
+MODULE_DEVICE_TABLE(usb, dabusb_ids);
static struct usb_driver dabusb_driver = {
.name = "dabusb",
/* --------------------------------------------------------------------- */
-static int __init dabusb_init (void)
+static int __init dabusb_init(void)
{
int retval;
unsigned u;
/* initialize struct */
for (u = 0; u < NRDABUSB; u++) {
pdabusb_t s = &dabusb[u];
- memset (s, 0, sizeof (dabusb_t));
- mutex_init (&s->mutex);
+ memset(s, 0, sizeof(dabusb_t));
+ mutex_init(&s->mutex);
s->usbdev = NULL;
s->total_buffer_size = buffers;
- init_waitqueue_head (&s->wait);
- init_waitqueue_head (&s->remove_ok);
- spin_lock_init (&s->lock);
- INIT_LIST_HEAD (&s->free_buff_list);
- INIT_LIST_HEAD (&s->rec_buff_list);
+ init_waitqueue_head(&s->wait);
+ init_waitqueue_head(&s->remove_ok);
+ spin_lock_init(&s->lock);
+ INIT_LIST_HEAD(&s->free_buff_list);
+ INIT_LIST_HEAD(&s->rec_buff_list);
}
/* register misc device */
return retval;
}
-static void __exit dabusb_cleanup (void)
+static void __exit dabusb_cleanup(void)
{
dbg("dabusb_cleanup");
- usb_deregister (&dabusb_driver);
+ usb_deregister(&dabusb_driver);
}
/* --------------------------------------------------------------------- */
-MODULE_AUTHOR( DRIVER_AUTHOR );
-MODULE_DESCRIPTION( DRIVER_DESC );
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
MODULE_FIRMWARE("dabusb/firmware.fw");
MODULE_FIRMWARE("dabusb/bitstream.bin");
module_param(buffers, int, 0);
-MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
+MODULE_PARM_DESC(buffers, "Number of buffers (default=256)");
-module_init (dabusb_init);
-module_exit (dabusb_cleanup);
+module_init(dabusb_init);
+module_exit(dabusb_cleanup);
/* --------------------------------------------------------------------- */
projects / GitHub / MotorolaMobilityLLC / kernel-slsi.git / commitdiff