Subversion Repositories or1k

/*****************************************************************************/
 
/*
 *      dabusb.c  --  dab usb driver.
 *
 *      Copyright (C) 1999  Deti Fliegl (deti@fliegl.de)
 *
 *      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.
 *
 *
 *
 *  $Id: dabusb.c,v 1.1.1.1 2004-04-15 01:54:14 phoenix Exp $
 *
 */
 
/*****************************************************************************/
 
#include <linux/module.h>
#include <linux/socket.h>
#include <linux/miscdevice.h>
#include <linux/list.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
#include <linux/delay.h>
#include <linux/usb.h>
#include <linux/smp_lock.h>
 
#include "dabusb.h"
#include "dabfirmware.h"
 
/*
 * Version Information
 */
#define DRIVER_VERSION "v1.54"
#define DRIVER_AUTHOR "Deti Fliegl, deti@fliegl.de"
#define DRIVER_DESC "DAB-USB Interface Driver for Linux (c)1999"
 
/* --------------------------------------------------------------------- */
 
#define NRDABUSB 4
 
/*-------------------------------------------------------------------*/
 
static dabusb_t dabusb[NRDABUSB];
static int buffers = 256;
 
/*-------------------------------------------------------------------*/
 
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);
 
	if (list_empty (src)) {
		// no elements in source buffer
		ret = -1;
		goto err;
	}
	tmp = src->next;
	list_del (tmp);
	list_add_tail (tmp, dst);
 
  err:	spin_unlock_irqrestore (&s->lock, flags);
	return ret;
}
/*-------------------------------------------------------------------*/
#ifdef DEBUG 
static void dump_urb (struct urb *purb)
{
	dbg("urb                   :%p", purb);
	dbg("next                  :%p", purb->next);
	dbg("dev                   :%p", purb->dev);
	dbg("pipe                  :%08X", purb->pipe);
	dbg("status                :%d", purb->status);
	dbg("transfer_flags        :%08X", purb->transfer_flags);
	dbg("transfer_buffer       :%p", purb->transfer_buffer);
	dbg("transfer_buffer_length:%d", purb->transfer_buffer_length);
	dbg("actual_length         :%d", purb->actual_length);
	dbg("setup_packet          :%p", purb->setup_packet);
	dbg("start_frame           :%d", purb->start_frame);
	dbg("number_of_packets     :%d", purb->number_of_packets);
	dbg("interval              :%d", purb->interval);
	dbg("error_count           :%d", purb->error_count);
	dbg("context               :%p", purb->context);
	dbg("complete              :%p", purb->complete);
}
#endif
/*-------------------------------------------------------------------*/
static int dabusb_cancel_queue (pdabusb_t s, struct list_head *q)
{
	unsigned long flags;
	struct list_head *p;
	pbuff_t b;
 
	dbg("dabusb_cancel_queue");
 
	spin_lock_irqsave (&s->lock, flags);
 
	for (p = q->next; p != q; p = p->next) {
		b = list_entry (p, buff_t, buff_list);
 
#ifdef DEBUG
		dump_urb(b->purb);
#endif
		usb_unlink_urb (b->purb);
	}
	spin_unlock_irqrestore (&s->lock, flags);
	return 0;
}
/*-------------------------------------------------------------------*/
static int dabusb_free_queue (struct list_head *q)
{
	struct list_head *tmp;
	struct list_head *p;
	pbuff_t b;
 
	dbg("dabusb_free_queue");
	for (p = q->next; p != q;) {
		b = list_entry (p, buff_t, buff_list);
 
#ifdef DEBUG 
		dump_urb(b->purb);
#endif
		if (b->purb->transfer_buffer)
			kfree (b->purb->transfer_buffer);
		usb_free_urb(b->purb);
		tmp = p->next;
		list_del (p);
		kfree (b);
		p = tmp;
	}
 
	return 0;
}
/*-------------------------------------------------------------------*/
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);
 
	spin_unlock_irqrestore(&s->lock, flags);
 
	s->got_mem = 0;
	return 0;
}
/*-------------------------------------------------------------------*/
static void dabusb_iso_complete (struct urb *purb)
{
	pbuff_t b = purb->context;
	pdabusb_t s = b->s;
	int i;
	int len;
	int dst = 0;
	void *buf = purb->transfer_buffer;
 
	dbg("dabusb_iso_complete");
 
	// 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));
		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);
					dst += len;
				}
				else
					err("dabusb_iso_complete: invalid len %d", len);
			}
			else
				warn("dabusb_iso_complete: corrupted packet status: %d", purb->iso_frame_desc[i].status);
		if (dst != purb->actual_length)
			err("dst!=purb->actual_length:%d!=%d", dst, purb->actual_length);
	}
 
	if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) {
		s->overruns++;
		err("overrun (%d)", s->overruns);
	}
	wake_up (&s->wait);
}
/*-------------------------------------------------------------------*/
static int dabusb_alloc_buffers (pdabusb_t s)
{
	int buffers = 0;
	pbuff_t b;
	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;
 
	dbg("dabusb_alloc_buffers pipesize:%d packets:%d transfer_buffer_len:%d",
		 pipesize, packets, transfer_buffer_length);
 
	while (buffers < (s->total_buffer_size << 10)) {
		b = (pbuff_t) kmalloc (sizeof (buff_t), GFP_KERNEL);
		if (!b) {
			err("kmalloc(sizeof(buff_t))==NULL");
			goto err;
		}
		memset (b, 0, sizeof (buff_t));
		b->s = s;
		b->purb = usb_alloc_urb(packets);
		if (!b->purb) {
			err("usb_alloc_urb == NULL");
			kfree (b);
			goto err;
		}
 
		b->purb->transfer_buffer = kmalloc (transfer_buffer_length, GFP_KERNEL);
		if (!b->purb->transfer_buffer) {
			kfree (b->purb);
			kfree (b);
			err("kmalloc(%d)==NULL", transfer_buffer_length);
			goto err;
		}
 
		b->purb->transfer_buffer_length = transfer_buffer_length;
		b->purb->number_of_packets = packets;
		b->purb->complete = dabusb_iso_complete;
		b->purb->context = b;
		b->purb->dev = s->usbdev;
		b->purb->pipe = pipe;
		b->purb->transfer_flags = USB_ISO_ASAP;
 
		for (i = 0; i < packets; i++) {
			b->purb->iso_frame_desc[i].offset = i * pipesize;
			b->purb->iso_frame_desc[i].length = pipesize;
		}
 
		buffers += transfer_buffer_length;
		list_add_tail (&b->buff_list, &s->free_buff_list);
	}
	s->got_mem = buffers;
 
	return 0;
 
	err:
	dabusb_free_buffers (s);
	return -ENOMEM;
}
/*-------------------------------------------------------------------*/
static int dabusb_bulk (pdabusb_t s, pbulk_transfer_t pb)
{
	int ret;
	unsigned int pipe;
	int actual_length;
 
	dbg("dabusb_bulk");
 
	if (!pb->pipe)
		pipe = usb_rcvbulkpipe (s->usbdev, 2);
	else
		pipe = usb_sndbulkpipe (s->usbdev, 2);
 
	ret=usb_bulk_msg(s->usbdev, pipe, pb->data, pb->size, &actual_length, 100);
	if(ret<0) {
		err("dabusb: usb_bulk_msg failed(%d)",ret);
 
		if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
			err("set_interface failed");
			return -EINVAL;
		}
 
	}
 
	if( ret == -EPIPE ) {
		warn("CLEAR_FEATURE request to remove STALL condition.");
		if(usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
			err("request failed");
	}
 
	pb->size = actual_length;
	return ret;
}
/* --------------------------------------------------------------------- */
static int dabusb_writemem (pdabusb_t s, int pos, unsigned char *data, int len)
{
	int ret;
	unsigned char *transfer_buffer =  kmalloc (len, GFP_KERNEL);
 
	if (!transfer_buffer) {
		err("dabusb_writemem: kmalloc(%d) failed.", len);
		return -ENOMEM;
	}
 
	memcpy (transfer_buffer, data, len);
 
	ret=usb_control_msg(s->usbdev, usb_sndctrlpipe( s->usbdev, 0 ), 0xa0, 0x40, pos, 0, transfer_buffer, len, 300);
 
	kfree (transfer_buffer);
	return ret;
}
/* --------------------------------------------------------------------- */
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);
}
/* --------------------------------------------------------------------- */
static int dabusb_loadmem (pdabusb_t s, const char *fname)
{
	int ret;
	PINTEL_HEX_RECORD ptr = firmware;
 
	dbg("Enter dabusb_loadmem (internal)");
 
	ret = dabusb_8051_reset (s, 1);
	while (ptr->Type == 0) {
 
		dbg("dabusb_writemem: %04X %p %d)", ptr->Address, ptr->Data, ptr->Length);
 
		ret = dabusb_writemem (s, ptr->Address, ptr->Data, ptr->Length);
		if (ret < 0) {
			err("dabusb_writemem failed (%d %04X %p %d)", ret, ptr->Address, ptr->Data, ptr->Length);
			break;
		}
		ptr++;
	}
	ret = dabusb_8051_reset (s, 0);
 
	dbg("dabusb_loadmem: exit");
 
	return ret;
}
/* --------------------------------------------------------------------- */
static int dabusb_fpga_clear (pdabusb_t s, pbulk_transfer_t b)
{
	b->size = 4;
	b->data[0] = 0x2a;
	b->data[1] = 0;
	b->data[2] = 0;
	b->data[3] = 0;
 
	dbg("dabusb_fpga_clear");
 
	return dabusb_bulk (s, b);
}
/* --------------------------------------------------------------------- */
static int dabusb_fpga_init (pdabusb_t s, pbulk_transfer_t b)
{
	b->size = 4;
	b->data[0] = 0x2c;
	b->data[1] = 0;
	b->data[2] = 0;
	b->data[3] = 0;
 
	dbg("dabusb_fpga_init");
 
	return dabusb_bulk (s, b);
}
/* --------------------------------------------------------------------- */
static int dabusb_fpga_download (pdabusb_t s, const char *fname)
{
	pbulk_transfer_t b = kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
	unsigned int blen, n;
	int ret;
	unsigned char *buf = bitstream;
 
	dbg("Enter dabusb_fpga_download (internal)");
 
	if (!b) {
		err("kmalloc(sizeof(bulk_transfer_t))==NULL");
		return -ENOMEM;
	}
 
	b->pipe = 1;
	ret = dabusb_fpga_clear (s, b);
	mdelay (10);
	blen = buf[73] + (buf[72] << 8);
 
	dbg("Bitstream len: %i", blen);
 
	b->data[0] = 0x2b;
	b->data[1] = 0;
	b->data[2] = 0;
	b->data[3] = 60;
 
	for (n = 0; n <= blen + 60; n += 60) {
		// some cclks for startup
		b->size = 64;
		memcpy (b->data + 4, buf + 74 + n, 60);
		ret = dabusb_bulk (s, b);
		if (ret < 0) {
			err("dabusb_bulk failed.");
			break;
		}
		mdelay (1);
	}
 
	ret = dabusb_fpga_init (s, b);
	kfree (b);
 
	dbg("exit dabusb_fpga_download");
 
	return ret;
}
 
static int dabusb_stop (pdabusb_t s)
{
	dbg("dabusb_stop");
 
	s->state = _stopped;
	dabusb_cancel_queue (s, &s->rec_buff_list);
 
	dbg("pending_io: %d", s->pending_io.counter);
 
	s->pending_io.counter = 0;
	return 0;
}
 
static int dabusb_startrek (pdabusb_t s)
{
	if (!s->got_mem && s->state != _started) {
 
		dbg("dabusb_startrek");
 
		if (dabusb_alloc_buffers (s) < 0)
			return -ENOMEM;
		dabusb_stop (s);
		s->state = _started;
		s->readptr = 0;
	}
 
	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)) {
 
			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);
 
			ret = usb_submit_urb (end->purb);
			if (ret) {
				err("usb_submit_urb returned:%d", ret);
				if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
					err("startrek: dabusb_add_buf_tail failed");
				break;
			}
			else
				atomic_inc (&s->pending_io);
		}
		dbg("pending_io: %d",s->pending_io.counter);
	}
 
	return 0;
}
 
static ssize_t dabusb_read (struct file *file, char *buf, size_t count, loff_t * ppos)
{
	pdabusb_t s = (pdabusb_t) file->private_data;
	unsigned long flags;
	unsigned ret = 0;
	int rem;
	int cnt;
	pbuff_t b;
	struct urb *purb = NULL;
 
	dbg("dabusb_read");
 
	if (*ppos)
		return -ESPIPE;
 
	if (s->remove_pending)
		return -EIO;
 
 
	if (!s->usbdev)
		return -EIO;
 
	while (count > 0) {
		dabusb_startrek (s);
 
		spin_lock_irqsave (&s->lock, flags);
 
		if (list_empty (&s->rec_buff_list)) {
 
			spin_unlock_irqrestore(&s->lock, flags);
 
			err("error: rec_buf_list is empty");
			goto err;
		}
 
		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
			 {
				if (!ret)
					ret = -EAGAIN;
				goto err;
			}
 
			interruptible_sleep_on (&s->wait);
 
			if (signal_pending (current)) {
				if (!ret)
					ret = -ERESTARTSYS;
				goto err;
			}
 
			spin_lock_irqsave (&s->lock, flags);
 
			if (list_empty (&s->rec_buff_list)) {
				spin_unlock_irqrestore(&s->lock, flags);
				err("error: still no buffer available.");
				goto err;
			}
			spin_unlock_irqrestore(&s->lock, flags);
			s->readptr = 0;
		}
		if (s->remove_pending) {
			ret = -EIO;
			goto err;
		}
 
		rem = purb->actual_length - s->readptr;		// set remaining bytes to copy
 
		if (count >= rem)
			cnt = rem;
		else
			cnt = count;
 
		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)) {
			err("read: copy_to_user failed");
			if (!ret)
				ret = -EFAULT;
			goto err;
		}
 
		s->readptr += cnt;
		count -= cnt;
		buf += cnt;
		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))
				err("read: dabusb_add_buf_tail failed");
			s->readptr = 0;
		}
	}
      err:			//up(&s->mutex);
	return ret;
}
 
static int dabusb_open (struct inode *inode, struct file *file)
{
	int devnum = MINOR (inode->i_rdev);
	pdabusb_t s;
 
	if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
		return -EIO;
 
	s = &dabusb[devnum - DABUSB_MINOR];
 
	dbg("dabusb_open");
	down (&s->mutex);
 
	while (!s->usbdev || s->opened) {
		up (&s->mutex);
 
		if (file->f_flags & O_NONBLOCK) {
			return -EBUSY;
		}
		schedule_timeout (HZ / 2);
 
		if (signal_pending (current)) {
			return -EAGAIN;
		}
		down (&s->mutex);
	}
	if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
		err("set_interface failed");
		up(&s->mutex);
		return -EINVAL;
	}
	s->opened = 1;
	up (&s->mutex);
 
	file->f_pos = 0;
	file->private_data = s;
 
	return 0;
}
 
static int dabusb_release (struct inode *inode, struct file *file)
{
	pdabusb_t s = (pdabusb_t) file->private_data;
 
	dbg("dabusb_release");
 
	lock_kernel();
	down (&s->mutex);
	dabusb_stop (s);
	dabusb_free_buffers (s);
	up (&s->mutex);
 
	if (!s->remove_pending) {
		if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
			err("set_interface failed");
	}
	else
		wake_up (&s->remove_ok);
 
	s->opened = 0;
	unlock_kernel();
	return 0;
}
 
static int dabusb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	pdabusb_t s = (pdabusb_t) file->private_data;
	pbulk_transfer_t pbulk;
	int ret = 0;
	int version = DABUSB_VERSION;
 
	dbg("dabusb_ioctl");
 
	if (s->remove_pending)
		return -EIO;
 
	down (&s->mutex);
 
	if (!s->usbdev) {
		up (&s->mutex);
		return -EIO;
	}
 
	switch (cmd) {
 
	case IOCTL_DAB_BULK:
		pbulk = (pbulk_transfer_t) kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
 
		if (!pbulk) {
			ret = -ENOMEM;
			break;
		}
 
		if (copy_from_user (pbulk, (void *) arg, sizeof (bulk_transfer_t))) {
			ret = -EFAULT;
			kfree (pbulk);
			break;
		}
 
		ret=dabusb_bulk (s, pbulk);
		if(ret==0)
			ret = copy_to_user ((void *) arg, pbulk, sizeof (bulk_transfer_t));
		kfree (pbulk);
		break;
 
	case IOCTL_DAB_OVERRUNS:
		ret = put_user (s->overruns, (unsigned int *) arg);
		break;
 
	case IOCTL_DAB_VERSION:
		ret = put_user (version, (unsigned int *) arg);
		break;
 
	default:
		ret = -ENOIOCTLCMD;
		break;
	}
	up (&s->mutex);
	return ret;
}
 
static struct file_operations dabusb_fops =
{
	owner:		THIS_MODULE,
	llseek:		no_llseek,
	read:		dabusb_read,
	ioctl:		dabusb_ioctl,
	open:		dabusb_open,
	release:	dabusb_release,
};
 
static int dabusb_find_struct (void)
{
	int u;
 
	for (u = 0; u < NRDABUSB; u++) {
		pdabusb_t s = &dabusb[u];
		if (!s->usbdev)
			return u;
	}
	return -1;
}
 
/* --------------------------------------------------------------------- */
static void *dabusb_probe (struct usb_device *usbdev, unsigned int ifnum,
			   const struct usb_device_id *id)
{
	int devnum;
	pdabusb_t s;
 
	dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
	  usbdev->descriptor.idVendor, usbdev->descriptor.idProduct, ifnum);
 
	/* We don't handle multiple configurations */
	if (usbdev->descriptor.bNumConfigurations != 1)
		return NULL;
 
	if (ifnum != _DABUSB_IF && usbdev->descriptor.idProduct == 0x9999)
		return NULL;
 
	devnum = dabusb_find_struct ();
	if (devnum == -1)
		return NULL;
 
	s = &dabusb[devnum];
 
	down (&s->mutex);
	s->remove_pending = 0;
	s->usbdev = usbdev;
 
	if (usb_set_configuration (usbdev, usbdev->config[0].bConfigurationValue) < 0) {
		err("set_configuration failed");
		goto reject;
	}
	if (usbdev->descriptor.idProduct == 0x2131) {
		dabusb_loadmem (s, NULL);
		goto reject;
	}
	else {
		dabusb_fpga_download (s, NULL);
 
		if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
			err("set_interface failed");
			goto reject;
		}
	}
	dbg("bound to interface: %d", ifnum);
	up (&s->mutex);
	MOD_INC_USE_COUNT;
	return s;
 
      reject:
	up (&s->mutex);
	s->usbdev = NULL;
	return NULL;
}
 
static void dabusb_disconnect (struct usb_device *usbdev, void *ptr)
{
	pdabusb_t s = (pdabusb_t) ptr;
 
	dbg("dabusb_disconnect");
 
	s->remove_pending = 1;
	wake_up (&s->wait);
	if (s->state == _started)
		sleep_on (&s->remove_ok);
	s->usbdev = NULL;
	s->overruns = 0;
	MOD_DEC_USE_COUNT;
}
 
static struct usb_device_id dabusb_ids [] = {
	{ USB_DEVICE(0x0547, 0x2131) },
	{ USB_DEVICE(0x0547, 0x9999) },
	{ }						/* Terminating entry */
};
 
MODULE_DEVICE_TABLE (usb, dabusb_ids);
 
static struct usb_driver dabusb_driver =
{
	name:		"dabusb",
	probe:		dabusb_probe,
	disconnect:	dabusb_disconnect,
	fops:		&dabusb_fops,
	minor:		DABUSB_MINOR,
	id_table:	dabusb_ids,
};
 
/* --------------------------------------------------------------------- */
 
static int __init dabusb_init (void)
{
	unsigned u;
 
	/* initialize struct */
	for (u = 0; u < NRDABUSB; u++) {
		pdabusb_t s = &dabusb[u];
		memset (s, 0, sizeof (dabusb_t));
		init_MUTEX (&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);
	}
 
	/* register misc device */
	if (usb_register(&dabusb_driver))
		return -1;
 
	dbg("dabusb_init: driver registered");
 
	info(DRIVER_VERSION ":" DRIVER_DESC);
 
	return 0;
}
 
static void __exit dabusb_cleanup (void)
{
	dbg("dabusb_cleanup");
 
	usb_deregister (&dabusb_driver);
}
 
/* --------------------------------------------------------------------- */
 
MODULE_AUTHOR( DRIVER_AUTHOR );
MODULE_DESCRIPTION( DRIVER_DESC );
MODULE_LICENSE("GPL");
 
MODULE_PARM (buffers, "i");
MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
 
module_init (dabusb_init);
module_exit (dabusb_cleanup);
 
/* --------------------------------------------------------------------- */