speedtch testatm.c, NONE, 1.1 Makefile, 1.13, 1.14 cxacru2.c, 1.4, 1.5 usbatm.h, 1.6, 1.7 usbatm2.c, 1.17, 1.18

Duncan Sands duncan at infradead.org
Fri Jan 28 18:51:56 EST 2005 

Update of /home/cvs/speedtch
In directory phoenix.infradead.org:/tmp/cvs-serv20235

Modified Files:
	Makefile cxacru2.c usbatm.h usbatm2.c 
Added Files:
	testatm.c 
Log Message:
Change udsl to usbatm everywhere.  Tweak debugging info.  Add test driver.


--- NEW FILE testatm.c ---
/******************************************************************************
 *  testatm.c  -  driver for testing the usbatm core
 *
 *  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., 59
 *  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 ******************************************************************************/

#include <linux/module.h>

#include "usbatm.h"

static const char testatm_driver_name[] = "testatm";

uint	idVendor;
module_param(idVendor, uint, 0444);

uint	idProduct;
module_param(idProduct, uint, 0444);

static struct usb_device_id testatm_usb_ids[] = {
	{}, {}
};

static struct usb_driver testatm_usb_driver = {
	.owner		= THIS_MODULE,
	.name		= testatm_driver_name,
	.probe		= usbatm_usb_probe,
	.disconnect	= usbatm_usb_disconnect,
	.id_table	= testatm_usb_ids
};

static struct usbatm_driver testatm_driver_1 = {
        .owner          = THIS_MODULE,
        .driver_name    = testatm_driver_name
};

static int __init testatm_init(void)
{
	int ret;

	dbg("testatm_init");

	printk("idVendor: %04x\n", idVendor);
	printk("idProduct: %04x\n", idProduct);

	testatm_usb_ids[0].match_flags	= USB_DEVICE_ID_MATCH_DEVICE;
	testatm_usb_ids[0].idVendor	= idVendor;
	testatm_usb_ids[0].idProduct	= idProduct;

	if ((ret = usbatm_register(&testatm_driver_1)) < 0)
		goto fail_0;

	if ((ret = usb_register(&testatm_usb_driver)) < 0)
		goto fail_all;

	return 0;

 fail_all:
	usbatm_deregister(&testatm_driver_1);

 fail_0:
	return ret;
}
module_init(testatm_init);

static void __exit testatm_exit(void)
{
	dbg("testatm_exit entered");

	usb_deregister(&testatm_usb_driver);
	usbatm_deregister(&testatm_driver_1);
}
module_exit(testatm_exit);

MODULE_LICENSE("GPL");

Index: Makefile
===================================================================
RCS file: /home/cvs/speedtch/Makefile,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -r1.13 -r1.14
--- Makefile	28 Jan 2005 14:58:17 -0000	1.13
+++ Makefile	28 Jan 2005 23:51:52 -0000	1.14
@@ -5,7 +5,7 @@
 FIRMWARE_EXTRACTOR := firmware
 
 #obj-m := cxacru.o speedtch.o usb_atm.o usbatm2.o speedtch2.o cxacru2.o
-obj-m := cxacru2.o usbatm2.o
+obj-m := cxacru2.o testatm.o usbatm2.o
 
 all help modules modules_install:
 	$(MAKE) -C $(KERNELDIR) M=$(PWD) $(filter-out all,$(MAKECMDGOALS)) EXTRA_CFLAGS=-DDEBUG

Index: cxacru2.c
===================================================================
RCS file: /home/cvs/speedtch/cxacru2.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- cxacru2.c	28 Jan 2005 14:58:17 -0000	1.4
+++ cxacru2.c	28 Jan 2005 23:51:52 -0000	1.5
@@ -779,43 +779,43 @@
 static const struct usb_device_id cxacru_usb_ids[] = {
 	{
 		/* V = Conexant				P = ADSL modem (Euphrates project)	*/
-		USB_DEVICE(0x0572, 0xcafe),
+		USB_DEVICE(0x0572, 0xcafe)
 	},
 	{
 		/* V = Conexant				P = ADSL modem (Hasbani project)	*/
-		USB_DEVICE(0x0572, 0xcb00),
+		USB_DEVICE(0x0572, 0xcb00)
 	},
 	{
 		/* V = Conexant				P = ADSL modem				*/
-		USB_DEVICE(0x0572, 0xcb01),
+		USB_DEVICE(0x0572, 0xcb01)
 	},
 	{
 		/* V = Conexant				P = ADSL modem				*/
-		USB_DEVICE(0x0572, 0xcb06),
+		USB_DEVICE(0x0572, 0xcb06)
 	},
 	{
 		/* V = Olitec				P = ADSL modem version 2		*/
-		USB_DEVICE(0x08e3, 0x0100),
+		USB_DEVICE(0x08e3, 0x0100)
 	},
 	{
 		/* V = Olitec				P = ADSL modem version 3		*/
-		USB_DEVICE(0x08e3, 0x0102),
+		USB_DEVICE(0x08e3, 0x0102)
 	},
 	{
 		/* V = Trust/Amigo Technology Co.	P = AMX-CA86U				*/
-		USB_DEVICE(0x0eb0, 0x3457),
+		USB_DEVICE(0x0eb0, 0x3457)
 	},
 	{
 		/* V = Zoom				P = 5510				*/
-		USB_DEVICE(0x1803, 0x5510),
+		USB_DEVICE(0x1803, 0x5510)
 	},
 	{
 		/* V = Draytek				P = Vigor 318				*/
-		USB_DEVICE(0x0675, 0x0200),
+		USB_DEVICE(0x0675, 0x0200)
 	},
 	{
 		/* V = Zyxel				P = 630-C1 aka OMNI ADSL USB modem	*/
-		USB_DEVICE(0x0586, 0x330a),
+		USB_DEVICE(0x0586, 0x330a)
 	},
 	{}
 };

Index: usbatm.h
===================================================================
RCS file: /home/cvs/speedtch/usbatm.h,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -r1.6 -r1.7
--- usbatm.h	28 Jan 2005 14:58:17 -0000	1.6
+++ usbatm.h	28 Jan 2005 23:51:52 -0000	1.7
@@ -29,8 +29,8 @@
 #include <linux/atmdev.h>
 #include <linux/completion.h>
 #include <linux/config.h>
-#include <linux/list.h>
 #include <linux/kref.h>
+#include <linux/list.h>
 
 /*
 #define DEBUG
@@ -119,15 +119,15 @@
 
 /* receive */
 
-struct udsl_receive_buffer {
+struct usbatm_receive_buffer {
 	struct list_head list;
 	unsigned char *base;
 	unsigned int filled_cells;
 };
 
-struct udsl_receiver {
+struct usbatm_receiver {
 	struct list_head list;
-	struct udsl_receive_buffer *buffer;
+	struct usbatm_receive_buffer *buffer;
 	struct urb *urb;
 	struct usbatm_data *instance;
 };
@@ -135,16 +135,16 @@
 
 /* send */
 
-struct udsl_send_buffer {
+struct usbatm_send_buffer {
 	struct list_head list;
 	unsigned char *base;
 	unsigned char *free_start;
 	unsigned int free_cells;
 };
 
-struct udsl_sender {
+struct usbatm_sender {
 	struct list_head list;
-	struct udsl_send_buffer *buffer;
+	struct usbatm_send_buffer *buffer;
 	struct urb *urb;
 	struct usbatm_data *instance;
 };
@@ -179,8 +179,8 @@
 	struct list_head vcc_list;
 
 	/* receive */
-	struct udsl_receiver receivers[UDSL_MAX_RCV_URBS];
-	struct udsl_receive_buffer receive_buffers[UDSL_MAX_RCV_BUFS];
+	struct usbatm_receiver receivers[UDSL_MAX_RCV_URBS];
+	struct usbatm_receive_buffer receive_buffers[UDSL_MAX_RCV_BUFS];
 
 	spinlock_t receive_lock;
 	struct list_head spare_receivers;
@@ -190,8 +190,8 @@
 	struct list_head spare_receive_buffers;
 
 	/* send */
-	struct udsl_sender senders[UDSL_MAX_SND_URBS];
-	struct udsl_send_buffer send_buffers[UDSL_MAX_SND_BUFS];
+	struct usbatm_sender senders[UDSL_MAX_SND_URBS];
+	struct usbatm_send_buffer send_buffers[UDSL_MAX_SND_BUFS];
 
 	struct sk_buff_head sndqueue;
 
@@ -201,7 +201,7 @@
 
 	struct tasklet_struct send_tasklet;
 	struct sk_buff *current_skb;			/* being emptied */
-	struct udsl_send_buffer *current_buffer;	/* being filled */
+	struct usbatm_send_buffer *current_buffer;	/* being filled */
 	struct list_head filled_send_buffers;
 };
 

Index: usbatm2.c
===================================================================
RCS file: /home/cvs/speedtch/usbatm2.c,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -r1.17 -r1.18
--- usbatm2.c	28 Jan 2005 15:14:20 -0000	1.17
+++ usbatm2.c	28 Jan 2005 23:51:52 -0000	1.18
@@ -3,7 +3,7 @@
  *
  *  Copyright (C) 2001, Alcatel
  *  Copyright (C) 2003, Duncan Sands, SolNegro, Josep Comas
- *  Copyright (C) 2004, David Woodhouse
+ *  Copyright (C) 2004, David Woodhouse, Roman Kagan
  *
  *  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
@@ -41,9 +41,9 @@
  *  1.5A:	- Version for inclusion in 2.5 series kernel
  *		- Modifications by Richard Purdie (rpurdie at rpsys.net)
  *		- made compatible with kernel 2.5.6 onwards by changing
- *		udsl_usb_send_data_context->urb to a pointer and adding code
+ *		usbatm_usb_send_data_context->urb to a pointer and adding code
  *		to alloc and free it
- *		- remove_wait_queue() added to udsl_atm_processqueue_thread()
+ *		- remove_wait_queue() added to usbatm_atm_processqueue_thread()
  *
  *  1.5:	- fixed memory leak when atmsar_decode_aal5 returned NULL.
  *		(reported by stephen.robinson at zen.co.uk)
@@ -57,23 +57,17 @@
  *		- fixed memory leak and vcc->tx_inuse starvation bug
  *		  when not enough memory left in vcc.
  *
- *  1.2:	- Fixed race condition in udsl_usb_send_data()
+ *  1.2:	- Fixed race condition in usbatm_usb_send_data()
  *  1.1:	- Turned off packet debugging
  *
  */
 
 #include <asm/uaccess.h>
-#include <linux/atm.h>
-#include <linux/atmdev.h>
-#include <linux/completion.h>
-#include <linux/config.h>
 #include <linux/crc32.h>
 #include <linux/errno.h>
-#include <linux/firmware.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
-#include <linux/list.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/proc_fs.h>
@@ -87,8 +81,8 @@
 #include "usbatm.h"
 
 #ifdef VERBOSE_DEBUG
-static int udsl_print_packet(const unsigned char *data, int len);
-#define PACKETDEBUG(arg...)	udsl_print_packet (arg)
+static int usbatm_print_packet(const unsigned char *data, int len);
+#define PACKETDEBUG(arg...)	usbatm_print_packet (arg)
 #define vdbg(arg...)		dbg (arg)
 #else
 #define PACKETDEBUG(arg...)
@@ -120,7 +114,7 @@
 
 /* receive */
 
-struct udsl_vcc_data {
+struct usbatm_vcc_data {
 	/* vpi/vci lookup */
 	struct list_head list;
 	short vpi;
@@ -134,7 +128,7 @@
 
 /* send */
 
-struct udsl_control {
+struct usbatm_control {
 	struct atm_skb_data atm_data;
 	unsigned int num_cells;
 	unsigned int num_entire;
@@ -142,7 +136,7 @@
 	unsigned char aal5_trailer[ATM_AAL5_TRAILER];
 };
 
-#define UDSL_SKB(x)		((struct udsl_control *)(x)->cb)
+#define UDSL_SKB(x)		((struct usbatm_control *)(x)->cb)
 
 
 static unsigned int num_rcv_urbs = UDSL_DEFAULT_RCV_URBS;
@@ -190,20 +184,20 @@
 
 /* ATM */
 
-static void udsl_atm_dev_close(struct atm_dev *dev);
-static int udsl_atm_open(struct atm_vcc *vcc);
-static void udsl_atm_close(struct atm_vcc *vcc);
-static int udsl_atm_ioctl(struct atm_dev *dev, unsigned int cmd, void __user * arg);
-static int udsl_atm_send(struct atm_vcc *vcc, struct sk_buff *skb);
-static int udsl_atm_proc_read(struct atm_dev *atm_dev, loff_t * pos, char *page);
-
-static struct atmdev_ops udsl_atm_devops = {
-	.dev_close	= udsl_atm_dev_close,
-	.open		= udsl_atm_open,
-	.close		= udsl_atm_close,
-	.ioctl		= udsl_atm_ioctl,
-	.send		= udsl_atm_send,
-	.proc_read	= udsl_atm_proc_read,
+static void usbatm_atm_dev_close(struct atm_dev *dev);
+static int usbatm_atm_open(struct atm_vcc *vcc);
+static void usbatm_atm_close(struct atm_vcc *vcc);
+static int usbatm_atm_ioctl(struct atm_dev *dev, unsigned int cmd, void __user * arg);
+static int usbatm_atm_send(struct atm_vcc *vcc, struct sk_buff *skb);
+static int usbatm_atm_proc_read(struct atm_dev *atm_dev, loff_t * pos, char *page);
+
+static struct atmdev_ops usbatm_atm_devops = {
+	.dev_close	= usbatm_atm_dev_close,
+	.open		= usbatm_atm_open,
+	.close		= usbatm_atm_close,
+	.ioctl		= usbatm_atm_ioctl,
+	.send		= usbatm_atm_send,
+	.proc_read	= usbatm_atm_proc_read,
 	.owner		= THIS_MODULE,
 };
 
@@ -218,7 +212,7 @@
 **  misc  **
 ***********/
 
-static inline void udsl_pop(struct atm_vcc *vcc, struct sk_buff *skb)
+static inline void usbatm_pop(struct atm_vcc *vcc, struct sk_buff *skb)
 {
 	if (vcc->pop)
 		vcc->pop(vcc, skb);
@@ -230,10 +224,10 @@
 **  decode  **
 *************/
 
-static inline struct udsl_vcc_data *udsl_find_vcc(struct usbatm_data *instance,
+static inline struct usbatm_vcc_data *usbatm_find_vcc(struct usbatm_data *instance,
 						  short vpi, int vci)
 {
-	struct udsl_vcc_data *vcc;
+	struct usbatm_vcc_data *vcc;
 
 	list_for_each_entry(vcc, &instance->vcc_list, list)
 		if ((vcc->vci == vci) && (vcc->vpi == vpi))
@@ -241,13 +235,13 @@
 	return NULL;
 }
 
-static void udsl_extract_cells(struct usbatm_data *instance,
+static void usbatm_extract_cells(struct usbatm_data *instance,
 			       unsigned char *source, unsigned int howmany)
 {
-	struct udsl_vcc_data *cached_vcc = NULL;
+	struct usbatm_vcc_data *cached_vcc = NULL;
 	struct atm_vcc *vcc;
 	struct sk_buff *sarb;
-	struct udsl_vcc_data *vcc_data;
+	struct usbatm_vcc_data *vcc_data;
 	int cached_vci = 0;
 	unsigned int i;
 	int pti;
@@ -261,16 +255,16 @@
 		vci = ((source[1] & 0x0f) << 12) | (source[2] << 4) | (source[3] >> 4);
 		pti = (source[3] & 0x2) != 0;
 
-		vdbg("udsl_extract_cells: vpi %hd, vci %d, pti %d", vpi, vci, pti);
+		vdbg("usbatm_extract_cells: vpi %hd, vci %d, pti %d", vpi, vci, pti);
 
 		if (cached_vcc && (vci == cached_vci) && (vpi == cached_vpi))
 			vcc_data = cached_vcc;
-		else if ((vcc_data = udsl_find_vcc(instance, vpi, vci))) {
+		else if ((vcc_data = usbatm_find_vcc(instance, vpi, vci))) {
 			cached_vcc = vcc_data;
 			cached_vpi = vpi;
 			cached_vci = vci;
 		} else {
-			dbg("udsl_extract_cells: unknown vpi/vci (%hd/%d)!", vpi, vci);
+			dbg("usbatm_extract_cells: unknown vpi/vci (%hd/%d)!", vpi, vci);
 			continue;
 		}
 
@@ -278,7 +272,7 @@
 		sarb = vcc_data->sarb;
 
 		if (sarb->tail + ATM_CELL_PAYLOAD > sarb->end) {
-			dbg("udsl_extract_cells: buffer overrun (sarb->len %u, vcc: 0x%p)!", sarb->len, vcc);
+			dbg("usbatm_extract_cells: buffer overrun (sarb->len %u, vcc: 0x%p)!", sarb->len, vcc);
 			/* discard cells already received */
 			skb_trim(sarb, 0);
 		}
@@ -295,7 +289,7 @@
 
 			/* guard against overflow */
 			if (length > ATM_MAX_AAL5_PDU) {
-				dbg("udsl_extract_cells: bogus length %u (vcc: 0x%p)!", length, vcc);
+				dbg("usbatm_extract_cells: bogus length %u (vcc: 0x%p)!", length, vcc);
 				atomic_inc(&vcc->stats->rx_err);
 				goto out;
 			}
@@ -303,29 +297,29 @@
 			pdu_length = UDSL_NUM_CELLS(length) * ATM_CELL_PAYLOAD;
 
 			if (sarb->len < pdu_length) {
-				dbg("udsl_extract_cells: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!", pdu_length, sarb->len, vcc);
+				dbg("usbatm_extract_cells: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!", pdu_length, sarb->len, vcc);
 				atomic_inc(&vcc->stats->rx_err);
 				goto out;
 			}
 
 			if (crc32_be(~0, sarb->tail - pdu_length, pdu_length) != 0xc704dd7b) {
-				dbg("udsl_extract_cells: packet failed crc check (vcc: 0x%p)!", vcc);
+				dbg("usbatm_extract_cells: packet failed crc check (vcc: 0x%p)!", vcc);
 				atomic_inc(&vcc->stats->rx_err);
 				goto out;
 			}
 
-			vdbg("udsl_extract_cells: got packet (length: %u, pdu_length: %u, vcc: 0x%p)", length, pdu_length, vcc);
+			vdbg("usbatm_extract_cells: got packet (length: %u, pdu_length: %u, vcc: 0x%p)", length, pdu_length, vcc);
 
 			if (!(skb = dev_alloc_skb(length))) {
-				dbg("udsl_extract_cells: no memory for skb (length: %u)!", length);
+				dbg("usbatm_extract_cells: no memory for skb (length: %u)!", length);
 				atomic_inc(&vcc->stats->rx_drop);
 				goto out;
 			}
 
-			vdbg("udsl_extract_cells: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)", skb, skb->truesize);
+			vdbg("usbatm_extract_cells: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)", skb, skb->truesize);
 
 			if (!atm_charge(vcc, skb->truesize)) {
-				dbg("udsl_extract_cells: failed atm_charge (skb->truesize: %u)!", skb->truesize);
+				dbg("usbatm_extract_cells: failed atm_charge (skb->truesize: %u)!", skb->truesize);
 				dev_kfree_skb(skb);
 				goto out;	/* atm_charge increments rx_drop */
 			}
@@ -333,7 +327,7 @@
 			memcpy(skb->data, sarb->tail - pdu_length, length);
 			__skb_put(skb, length);
 
-			vdbg("udsl_extract_cells: sending skb 0x%p, skb->len %u, skb->truesize %u", skb, skb->len, skb->truesize);
+			vdbg("usbatm_extract_cells: sending skb 0x%p, skb->len %u, skb->truesize %u", skb, skb->len, skb->truesize);
 
 			PACKETDEBUG(skb->data, skb->len);
 
@@ -350,7 +344,7 @@
 **  encode  **
 *************/
 
-static inline void udsl_fill_cell_header(unsigned char *target, struct atm_vcc *vcc)
+static inline void usbatm_fill_cell_header(unsigned char *target, struct atm_vcc *vcc)
 {
 	target[0] = vcc->vpi >> 4;
 	target[1] = (vcc->vpi << 4) | (vcc->vci >> 12);
@@ -361,9 +355,9 @@
 
 static const unsigned char zeros[ATM_CELL_PAYLOAD];
 
-static void udsl_groom_skb(struct atm_vcc *vcc, struct sk_buff *skb)
+static void usbatm_groom_skb(struct atm_vcc *vcc, struct sk_buff *skb)
 {
-	struct udsl_control *ctrl = UDSL_SKB(skb);
+	struct usbatm_control *ctrl = UDSL_SKB(skb);
 	unsigned int zero_padding;
 	u32 crc;
 
@@ -395,21 +389,21 @@
 	ctrl->aal5_trailer[7] = crc;
 }
 
-static unsigned int udsl_write_cells(struct usbatm_data *instance,
+static unsigned int usbatm_write_cells(struct usbatm_data *instance,
 				     unsigned int howmany, struct sk_buff *skb,
 				     unsigned char **target_p)
 {
-	struct udsl_control *ctrl = UDSL_SKB(skb);
+	struct usbatm_control *ctrl = UDSL_SKB(skb);
 	unsigned char *target = *target_p;
 	unsigned int nc, ne, i;
 
-	vdbg("udsl_write_cells: howmany=%u, skb->len=%d, num_cells=%u, num_entire=%u, pdu_padding=%u", howmany, skb->len, ctrl->num_cells, ctrl->num_entire, ctrl->pdu_padding);
+	vdbg("usbatm_write_cells: howmany=%u, skb->len=%d, num_cells=%u, num_entire=%u, pdu_padding=%u", howmany, skb->len, ctrl->num_cells, ctrl->num_entire, ctrl->pdu_padding);
 
 	nc = ctrl->num_cells;
 	ne = min(howmany, ctrl->num_entire);
 
 	for (i = 0; i < ne; i++) {
-		udsl_fill_cell_header(target, ctrl->atm_data.vcc);
+		usbatm_fill_cell_header(target, ctrl->atm_data.vcc);
 		target += ATM_CELL_HEADER;
 		memcpy(target, skb->data, ATM_CELL_PAYLOAD);
 		target += ATM_CELL_PAYLOAD;
@@ -425,7 +419,7 @@
 	if (!(ctrl->num_cells -= ne) || !(howmany -= ne))
 		goto out;
 
-	udsl_fill_cell_header(target, ctrl->atm_data.vcc);
+	usbatm_fill_cell_header(target, ctrl->atm_data.vcc);
 	target += ATM_CELL_HEADER;
 	memcpy(target, skb->data, skb->len);
 	target += skb->len;
@@ -443,7 +437,7 @@
 			memset(target, 0, instance->tx_padding);
 			target += instance->tx_padding;
 		}
-		udsl_fill_cell_header(target, ctrl->atm_data.vcc);
+		usbatm_fill_cell_header(target, ctrl->atm_data.vcc);
 		target += ATM_CELL_HEADER;
 		memset(target, 0, ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER);
 		target += ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER;
@@ -469,15 +463,15 @@
 **  receive  **
 **************/
 
-static void udsl_complete_receive(struct urb *urb, struct pt_regs *regs)
+static void usbatm_complete_receive(struct urb *urb, struct pt_regs *regs)
 {
-	struct udsl_receive_buffer *buf;
+	struct usbatm_receive_buffer *buf;
 	struct usbatm_data *instance;
-	struct udsl_receiver *rcv;
+	struct usbatm_receiver *rcv;
 	unsigned long flags;
 
 	if (!urb || !(rcv = urb->context)) {
-		dbg("udsl_complete_receive: bad urb!");
+		dbg("usbatm_complete_receive: bad urb!");
 		return;
 	}
 
@@ -486,7 +480,7 @@
 
 	buf->filled_cells = urb->actual_length / (ATM_CELL_SIZE + instance->rx_padding);
 
-	vdbg("udsl_complete_receive: urb 0x%p, status %d, actual_length %d, filled_cells %u, rcv 0x%p, buf 0x%p", urb, urb->status, urb->actual_length, buf->filled_cells, rcv, buf);
+	vdbg("usbatm_complete_receive: urb 0x%p, status %d, actual_length %d, filled_cells %u, rcv 0x%p, buf 0x%p", urb, urb->status, urb->actual_length, buf->filled_cells, rcv, buf);
 
 	UDSL_ASSERT(buf->filled_cells <= rcv_buf_size);
 
@@ -499,11 +493,11 @@
 	spin_unlock_irqrestore(&instance->receive_lock, flags);
 }
 
-static void udsl_process_receive(unsigned long data)
+static void usbatm_process_receive(unsigned long data)
 {
-	struct udsl_receive_buffer *buf;
+	struct usbatm_receive_buffer *buf;
 	struct usbatm_data *instance = (struct usbatm_data *)data;
-	struct udsl_receiver *rcv;
+	struct usbatm_receiver *rcv;
 	int err;
 
  made_progress:
@@ -514,12 +508,12 @@
 			break;
 		}
 		rcv = list_entry(instance->spare_receivers.next,
-				 struct udsl_receiver, list);
+				 struct usbatm_receiver, list);
 		list_del(&rcv->list);
 		spin_unlock_irq(&instance->receive_lock);
 
 		buf = list_entry(instance->spare_receive_buffers.next,
-				 struct udsl_receive_buffer, list);
+				 struct usbatm_receive_buffer, list);
 		list_del(&buf->list);
 
 		rcv->buffer = buf;
@@ -528,13 +522,13 @@
 				  instance->rx_endpoint,
 				  buf->base,
 				  rcv_buf_size * (ATM_CELL_SIZE + instance->rx_padding),
-				  udsl_complete_receive, rcv);
+				  usbatm_complete_receive, rcv);
 
-		vdbg("udsl_process_receive: sending urb 0x%p, rcv 0x%p, buf 0x%p",
+		vdbg("usbatm_process_receive: sending urb 0x%p, rcv 0x%p, buf 0x%p",
 		     rcv->urb, rcv, buf);
 
 		if ((err = usb_submit_urb(rcv->urb, GFP_ATOMIC)) < 0) {
-			dbg("udsl_process_receive: urb submission failed (%d)!", err);
+			dbg("usbatm_process_receive: urb submission failed (%d)!", err);
 			list_add(&buf->list, &instance->spare_receive_buffers);
 			spin_lock_irq(&instance->receive_lock);
 			list_add(&rcv->list, &instance->spare_receivers);
@@ -549,12 +543,12 @@
 		return;		/* done - no more buffers */
 	}
 	buf = list_entry(instance->filled_receive_buffers.next,
-			 struct udsl_receive_buffer, list);
+			 struct usbatm_receive_buffer, list);
 	list_del(&buf->list);
 	spin_unlock_irq(&instance->receive_lock);
 
-	vdbg("udsl_process_receive: processing buf 0x%p", buf);
-	udsl_extract_cells(instance, buf->base, buf->filled_cells);
+	vdbg("usbatm_process_receive: processing buf 0x%p", buf);
+	usbatm_extract_cells(instance, buf->base, buf->filled_cells);
 	list_add(&buf->list, &instance->spare_receive_buffers);
 	goto made_progress;
 }
@@ -563,18 +557,18 @@
 **  send  **
 ***********/
 
-static void udsl_complete_send(struct urb *urb, struct pt_regs *regs)
+static void usbatm_complete_send(struct urb *urb, struct pt_regs *regs)
 {
 	struct usbatm_data *instance;
-	struct udsl_sender *snd;
+	struct usbatm_sender *snd;
 	unsigned long flags;
 
 	if (!urb || !(snd = urb->context) || !(instance = snd->instance)) {
-		dbg("udsl_complete_send: bad urb!");
+		dbg("usbatm_complete_send: bad urb!");
 		return;
 	}
 
-	vdbg("udsl_complete_send: urb 0x%p, status %d, snd 0x%p, buf 0x%p", urb,
+	vdbg("usbatm_complete_send: urb 0x%p, status %d, snd 0x%p, buf 0x%p", urb,
 	     urb->status, snd, snd->buffer);
 
 	/* may not be in_interrupt() */
@@ -585,12 +579,12 @@
 	spin_unlock_irqrestore(&instance->send_lock, flags);
 }
 
-static void udsl_process_send(unsigned long data)
+static void usbatm_process_send(unsigned long data)
 {
-	struct udsl_send_buffer *buf;
+	struct usbatm_send_buffer *buf;
 	struct usbatm_data *instance = (struct usbatm_data *)data;
 	struct sk_buff *skb;
-	struct udsl_sender *snd;
+	struct usbatm_sender *snd;
 	int err;
 	unsigned int num_written;
 
@@ -599,7 +593,7 @@
 	while (!list_empty(&instance->spare_senders)) {
 		if (!list_empty(&instance->filled_send_buffers)) {
 			buf = list_entry(instance->filled_send_buffers.next,
-					 struct udsl_send_buffer, list);
+					 struct usbatm_send_buffer, list);
 			list_del(&buf->list);
 		} else if ((buf = instance->current_buffer)) {
 			instance->current_buffer = NULL;
@@ -607,7 +601,7 @@
 			break;
 
 		snd = list_entry(instance->spare_senders.next,
-				 struct udsl_sender, list);
+				 struct usbatm_sender, list);
 		list_del(&snd->list);
 		spin_unlock_irq(&instance->send_lock);
 
@@ -616,13 +610,13 @@
 				  instance->tx_endpoint,
 				  buf->base,
 				  (snd_buf_size - buf->free_cells) * (ATM_CELL_SIZE + instance->tx_padding),
-				  udsl_complete_send, snd);
+				  usbatm_complete_send, snd);
 
-		vdbg("udsl_process_send: submitting urb 0x%p (%d cells), snd 0x%p, buf 0x%p",
+		vdbg("usbatm_process_send: submitting urb 0x%p (%d cells), snd 0x%p, buf 0x%p",
 		     snd->urb, snd_buf_size - buf->free_cells, snd, buf);
 
 		if ((err = usb_submit_urb(snd->urb, GFP_ATOMIC)) < 0) {
-			dbg("udsl_process_send: urb submission failed (%d)!", err);
+			dbg("usbatm_process_send: urb submission failed (%d)!", err);
 			spin_lock_irq(&instance->send_lock);
 			list_add(&snd->list, &instance->spare_senders);
 			spin_unlock_irq(&instance->send_lock);
@@ -649,7 +643,7 @@
 			return;	/* done - no more buffers */
 		}
 		buf = list_entry(instance->spare_send_buffers.next,
-			       struct udsl_send_buffer, list);
+			       struct usbatm_send_buffer, list);
 		list_del(&buf->list);
 		spin_unlock_irq(&instance->send_lock);
 
@@ -659,9 +653,9 @@
 		instance->current_buffer = buf;
 	}
 
-	num_written = udsl_write_cells(instance, buf->free_cells, skb, &buf->free_start);
+	num_written = usbatm_write_cells(instance, buf->free_cells, skb, &buf->free_start);
 
-	vdbg("udsl_process_send: wrote %u cells from skb 0x%p to buffer 0x%p",
+	vdbg("usbatm_process_send: wrote %u cells from skb 0x%p to buffer 0x%p",
 	     num_written, skb, buf);
 
 	if (!(buf->free_cells -= num_written)) {
@@ -669,13 +663,13 @@
 		instance->current_buffer = NULL;
 	}
 
-	vdbg("udsl_process_send: buffer contains %d cells, %d left",
+	vdbg("usbatm_process_send: buffer contains %d cells, %d left",
 	     snd_buf_size - buf->free_cells, buf->free_cells);
 
 	if (!UDSL_SKB(skb)->num_cells) {
 		struct atm_vcc *vcc = UDSL_SKB(skb)->atm_data.vcc;
 
-		udsl_pop(vcc, skb);
+		usbatm_pop(vcc, skb);
 		instance->current_skb = NULL;
 
 		atomic_inc(&vcc->stats->tx);
@@ -684,54 +678,54 @@
 	goto made_progress;
 }
 
-static void udsl_cancel_send(struct usbatm_data *instance,
+static void usbatm_cancel_send(struct usbatm_data *instance,
 			     struct atm_vcc *vcc)
 {
 	struct sk_buff *skb, *n;
 
-	dbg("udsl_cancel_send entered");
+	dbg("usbatm_cancel_send entered");
 	spin_lock_irq(&instance->sndqueue.lock);
 	for (skb = instance->sndqueue.next, n = skb->next;
 	     skb != (struct sk_buff *)&instance->sndqueue;
 	     skb = n, n = skb->next)
 		if (UDSL_SKB(skb)->atm_data.vcc == vcc) {
-			dbg("udsl_cancel_send: popping skb 0x%p", skb);
+			dbg("usbatm_cancel_send: popping skb 0x%p", skb);
 			__skb_unlink(skb, &instance->sndqueue);
-			udsl_pop(vcc, skb);
+			usbatm_pop(vcc, skb);
 		}
 	spin_unlock_irq(&instance->sndqueue.lock);
 
 	tasklet_disable(&instance->send_tasklet);
 	if ((skb = instance->current_skb) && (UDSL_SKB(skb)->atm_data.vcc == vcc)) {
-		dbg("udsl_cancel_send: popping current skb (0x%p)", skb);
+		dbg("usbatm_cancel_send: popping current skb (0x%p)", skb);
 		instance->current_skb = NULL;
-		udsl_pop(vcc, skb);
+		usbatm_pop(vcc, skb);
 	}
 	tasklet_enable(&instance->send_tasklet);
-	dbg("udsl_cancel_send done");
+	dbg("usbatm_cancel_send done");
 }
 
-static int udsl_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
+static int usbatm_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
 {
 	struct usbatm_data *instance = vcc->dev->dev_data;
 	int err;
 
-	vdbg("udsl_atm_send called (skb 0x%p, len %u)", skb, skb->len);
+	vdbg("usbatm_atm_send called (skb 0x%p, len %u)", skb, skb->len);
 
 	if (!instance) {
-		dbg("udsl_atm_send: NULL data!");
+		dbg("usbatm_atm_send: NULL data!");
 		err = -ENODEV;
 		goto fail;
 	}
 
 	if (vcc->qos.aal != ATM_AAL5) {
-		dbg("udsl_atm_send: unsupported ATM type %d!", vcc->qos.aal);
+		dbg("usbatm_atm_send: unsupported ATM type %d!", vcc->qos.aal);
 		err = -EINVAL;
 		goto fail;
 	}
 
 	if (skb->len > ATM_MAX_AAL5_PDU) {
-		dbg("udsl_atm_send: packet too long (%d vs %d)!", skb->len,
+		dbg("usbatm_atm_send: packet too long (%d vs %d)!", skb->len,
 		    ATM_MAX_AAL5_PDU);
 		err = -EINVAL;
 		goto fail;
@@ -739,14 +733,14 @@
 
 	PACKETDEBUG(skb->data, skb->len);
 
-	udsl_groom_skb(vcc, skb);
+	usbatm_groom_skb(vcc, skb);
 	skb_queue_tail(&instance->sndqueue, skb);
 	tasklet_schedule(&instance->send_tasklet);
 
 	return 0;
 
  fail:
-	udsl_pop(vcc, skb);
+	usbatm_pop(vcc, skb);
 	return err;
 }
 
@@ -755,7 +749,7 @@
 **  bean counting  **
 ********************/
 
-static void udsl_destroy_instance(struct kref *kref)
+static void usbatm_destroy_instance(struct kref *kref)
 {
 	struct usbatm_data *instance = container_of(kref, struct usbatm_data, refcount);
 
@@ -765,14 +759,14 @@
 	kfree(instance);
 }
 
-void udsl_get_instance(struct usbatm_data *instance)
+void usbatm_get_instance(struct usbatm_data *instance)
 {
 	kref_get(&instance->refcount);
 }
 
-void udsl_put_instance(struct usbatm_data *instance)
+void usbatm_put_instance(struct usbatm_data *instance)
 {
-	kref_put(&instance->refcount, udsl_destroy_instance);
+	kref_put(&instance->refcount, usbatm_destroy_instance);
 }
 
 
@@ -780,7 +774,7 @@
 **  ATM  **
 **********/
 
-static void udsl_atm_dev_close(struct atm_dev *dev)
+static void usbatm_atm_dev_close(struct atm_dev *dev)
 {
 	struct usbatm_data *instance = dev->dev_data;
 
@@ -788,16 +782,16 @@
 		return;
 
 	dev->dev_data = NULL;
-	udsl_put_instance(instance);	/* taken in usbatm_atm_init */
+	usbatm_put_instance(instance);	/* taken in usbatm_atm_init */
 }
 
-static int udsl_atm_proc_read(struct atm_dev *atm_dev, loff_t * pos, char *page)
+static int usbatm_atm_proc_read(struct atm_dev *atm_dev, loff_t * pos, char *page)
 {
 	struct usbatm_data *instance = atm_dev->dev_data;
 	int left = *pos;
 
 	if (!instance) {
-		dbg("udsl_atm_proc_read: NULL instance!");
+		dbg("usbatm_atm_proc_read: NULL instance!");
 		return -ENODEV;
 	}
 
@@ -838,51 +832,51 @@
 	return 0;
 }
 
-static int udsl_atm_open(struct atm_vcc *vcc)
+static int usbatm_atm_open(struct atm_vcc *vcc)
 {
 	struct usbatm_data *instance = vcc->dev->dev_data;
-	struct udsl_vcc_data *new;
+	struct usbatm_vcc_data *new;
 	unsigned int max_pdu;
 	int vci = vcc->vci;
 	short vpi = vcc->vpi;
 
-	dbg("udsl_atm_open: vpi %hd, vci %d", vpi, vci);
+	dbg("usbatm_atm_open: vpi %hd, vci %d", vpi, vci);
 
 	if (!instance) {
-		dbg("udsl_atm_open: NULL data!");
+		dbg("usbatm_atm_open: NULL data!");
 		return -ENODEV;
 	}
 
 	/* only support AAL5 */
 	if ((vcc->qos.aal != ATM_AAL5) || (vcc->qos.rxtp.max_sdu < 0)
 	    || (vcc->qos.rxtp.max_sdu > ATM_MAX_AAL5_PDU)) {
-		dbg("udsl_atm_open: unsupported ATM type %d!", vcc->qos.aal);
+		dbg("usbatm_atm_open: unsupported ATM type %d!", vcc->qos.aal);
 		return -EINVAL;
 	}
 
-	down(&instance->serialize);	/* vs self, udsl_atm_close */
+	down(&instance->serialize);	/* vs self, usbatm_atm_close */
 
-	if (udsl_find_vcc(instance, vpi, vci)) {
-		dbg("udsl_atm_open: %hd/%d already in use!", vpi, vci);
+	if (usbatm_find_vcc(instance, vpi, vci)) {
+		dbg("usbatm_atm_open: %hd/%d already in use!", vpi, vci);
 		up(&instance->serialize);
 		return -EADDRINUSE;
 	}
 
-	if (!(new = kmalloc(sizeof(struct udsl_vcc_data), GFP_KERNEL))) {
-		dbg("udsl_atm_open: no memory for vcc_data!");
+	if (!(new = kmalloc(sizeof(struct usbatm_vcc_data), GFP_KERNEL))) {
+		dbg("usbatm_atm_open: no memory for vcc_data!");
 		up(&instance->serialize);
 		return -ENOMEM;
 	}
 
-	memset(new, 0, sizeof(struct udsl_vcc_data));
+	memset(new, 0, sizeof(struct usbatm_vcc_data));
 	new->vcc = vcc;
 	new->vpi = vpi;
 	new->vci = vci;
 
-	/* udsl_extract_cells requires at least one cell */
+	/* usbatm_extract_cells requires at least one cell */
 	max_pdu = max(1, UDSL_NUM_CELLS(vcc->qos.rxtp.max_sdu)) * ATM_CELL_PAYLOAD;
 	if (!(new->sarb = alloc_skb(max_pdu, GFP_KERNEL))) {
-		dbg("udsl_atm_open: no memory for SAR buffer!");
+		dbg("usbatm_atm_open: no memory for SAR buffer!");
 		kfree(new);
 		up(&instance->serialize);
 		return -ENOMEM;
@@ -902,29 +896,29 @@
 
 	tasklet_schedule(&instance->receive_tasklet);
 
-	dbg("udsl_atm_open: allocated vcc data 0x%p (max_pdu: %u)", new, max_pdu);
+	dbg("usbatm_atm_open: allocated vcc data 0x%p (max_pdu: %u)", new, max_pdu);
 
 	return 0;
 }
 
-static void udsl_atm_close(struct atm_vcc *vcc)
+static void usbatm_atm_close(struct atm_vcc *vcc)
 {
 	struct usbatm_data *instance = vcc->dev->dev_data;
-	struct udsl_vcc_data *vcc_data = vcc->dev_data;
+	struct usbatm_vcc_data *vcc_data = vcc->dev_data;
 
-	dbg("udsl_atm_close called");
+	dbg("usbatm_atm_close called");
 
 	if (!instance || !vcc_data) {
-		dbg("udsl_atm_close: NULL data!");
+		dbg("usbatm_atm_close: NULL data!");
 		return;
 	}
 
-	dbg("udsl_atm_close: deallocating vcc 0x%p with vpi %d vci %d",
+	dbg("usbatm_atm_close: deallocating vcc 0x%p with vpi %d vci %d",
 	    vcc_data, vcc_data->vpi, vcc_data->vci);
 
-	udsl_cancel_send(instance, vcc);
+	usbatm_cancel_send(instance, vcc);
 
-	down(&instance->serialize);	/* vs self, udsl_atm_open */
+	down(&instance->serialize);	/* vs self, usbatm_atm_open */
 
 	tasklet_disable(&instance->receive_tasklet);
 	list_del(&vcc_data->list);
@@ -944,10 +938,10 @@
 
 	up(&instance->serialize);
 
-	dbg("udsl_atm_close successful");
+	dbg("usbatm_atm_close successful");
 }
 
-static int udsl_atm_ioctl(struct atm_dev *dev, unsigned int cmd,
+static int usbatm_atm_ioctl(struct atm_dev *dev, unsigned int cmd,
 			  void __user * arg)
 {
 	switch (cmd) {
@@ -964,7 +958,7 @@
 	int ret;
 
 	/* ATM init */
-	atm_dev = atm_dev_register(instance->driver->driver_name, &udsl_atm_devops, -1, NULL);
+	atm_dev = atm_dev_register(instance->driver->driver_name, &usbatm_atm_devops, -1, NULL);
 	if (!atm_dev) {
 		dbg("usbatm_atm_init: failed to register ATM device!");
 		return -1;
@@ -983,7 +977,7 @@
 		goto fail;
 
 	/* ready for ATM callbacks */
-	udsl_get_instance(instance);	/* dropped in udsl_atm_dev_close */
+	usbatm_get_instance(instance);	/* dropped in usbatm_atm_dev_close */
 	mb();
 	atm_dev->dev_data = instance;
 
@@ -991,7 +985,7 @@
 
  fail:
 	instance->atm_dev = NULL;
-	shutdown_atm_dev(atm_dev); /* udsl_atm_dev_close will eventually be called */
+	shutdown_atm_dev(atm_dev); /* usbatm_atm_dev_close will eventually be called */
 	return ret;
 }
 
@@ -1061,8 +1055,10 @@
 		}
 	up(&usbatm_driver_sem);
 
-	if (!driver)
+	if (!driver) {
+		dev_dbg(&intf->dev, "no matching usbatm driver!\n");
 		return -ENODEV;
+	}
 
 	/* instance init */
 	if (!(instance = kmalloc(sizeof(*instance), GFP_KERNEL))) {
@@ -1095,7 +1091,7 @@
 	INIT_LIST_HEAD(&instance->spare_receivers);
 	INIT_LIST_HEAD(&instance->filled_receive_buffers);
 
-	tasklet_init(&instance->receive_tasklet, udsl_process_receive, (unsigned long)instance);
+	tasklet_init(&instance->receive_tasklet, usbatm_process_receive, (unsigned long)instance);
 	INIT_LIST_HEAD(&instance->spare_receive_buffers);
 
 	skb_queue_head_init(&instance->sndqueue);
@@ -1104,16 +1100,16 @@
 	INIT_LIST_HEAD(&instance->spare_senders);
 	INIT_LIST_HEAD(&instance->spare_send_buffers);
 
-	tasklet_init(&instance->send_tasklet, udsl_process_send,
+	tasklet_init(&instance->send_tasklet, usbatm_process_send,
 		     (unsigned long)instance);
 	INIT_LIST_HEAD(&instance->filled_send_buffers);
 
 	/* receive init */
 	for (i = 0; i < num_rcv_urbs; i++) {
-		struct udsl_receiver *rcv = &(instance->receivers[i]);
+		struct usbatm_receiver *rcv = &(instance->receivers[i]);
 
 		if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
-			dbg("udsl_usb_probe: no memory for receive urb %d!", i);
+			dev_dbg(&intf->dev, "no memory for receive urb %d!\n", i);
 			goto fail;
 		}
 
@@ -1123,12 +1119,12 @@
 	}
 
 	for (i = 0; i < num_rcv_bufs; i++) {
-		struct udsl_receive_buffer *buf = &(instance->receive_buffers[i]);
+		struct usbatm_receive_buffer *buf = &(instance->receive_buffers[i]);
 
 		buf->base = kmalloc(rcv_buf_size * (ATM_CELL_SIZE + instance->rx_padding),
 				    GFP_KERNEL);
 		if (!buf->base) {
-			dbg("udsl_usb_probe: no memory for receive buffer %d!", i);
+			dev_dbg(&intf->dev, "no memory for receive buffer %d!\n", i);
 			goto fail;
 		}
 
@@ -1137,10 +1133,10 @@
 
 	/* send init */
 	for (i = 0; i < num_snd_urbs; i++) {
-		struct udsl_sender *snd = &(instance->senders[i]);
+		struct usbatm_sender *snd = &(instance->senders[i]);
 
 		if (!(snd->urb = usb_alloc_urb(0, GFP_KERNEL))) {
-			dbg("udsl_usb_probe: no memory for send urb %d!", i);
+			dev_dbg(&intf->dev, "usbatm_usb_probe: no memory for send urb %d!\n", i);
 			goto fail;
 		}
 
@@ -1150,12 +1146,12 @@
 	}
 
 	for (i = 0; i < num_snd_bufs; i++) {
-		struct udsl_send_buffer *buf = &(instance->send_buffers[i]);
+		struct usbatm_send_buffer *buf = &(instance->send_buffers[i]);
 
 		buf->base = kmalloc(snd_buf_size * (ATM_CELL_SIZE + instance->tx_padding),
 				    GFP_KERNEL);
 		if (!buf->base) {
-			dbg("udsl_usb_probe: no memory for send buffer %d!", i);
+			dev_dbg(&intf->dev, "no memory for send buffer %d!\n", i);
 			goto fail;
 		}
 
@@ -1200,7 +1196,7 @@
 		goto fail;
 
 	usb_get_dev(dev);
-	udsl_get_instance(instance);	/* dropped in usbatm_usb_disconnect */
+	usbatm_get_instance(instance);	/* dropped in usbatm_usb_disconnect */
 	usb_set_intfdata(intf, instance);
 
 	return 0;
@@ -1229,10 +1225,10 @@
 	struct usbatm_data *instance = usb_get_intfdata(intf);
 	int i;
 
-	dbg("udsl_instance_disconnect entered");
+	dev_dbg(&intf->dev, "disconnect entered\n");
 
 	if (!instance) {
-		dbg("udsl_instance_disconnect: NULL instance!");
+		dev_dbg(&intf->dev, "NULL instance!\n");
 		return;
 	}
 
@@ -1292,7 +1288,7 @@
 	if (instance->atm_dev)
 		shutdown_atm_dev(instance->atm_dev);
 
-	udsl_put_instance(instance);	/* taken in usbatm_usb_probe */
+	usbatm_put_instance(instance);	/* taken in usbatm_usb_probe */
 }
 EXPORT_SYMBOL_GPL(usbatm_usb_disconnect);
 
@@ -1303,6 +1299,8 @@
 
 int usbatm_register (struct usbatm_driver *driver)
 {
+	dbg("registering usbatm driver %s", driver->driver_name);
+
 	down(&usbatm_driver_sem);
 	list_add(&driver->driver_list, &usbatm_driver_list);
 	up(&usbatm_driver_sem);
@@ -1313,17 +1311,19 @@
 
 void usbatm_deregister (struct usbatm_driver *driver)
 {
+	dbg("deregistering usbatm driver %s", driver->driver_name);
+
 	down(&usbatm_driver_sem);
 	list_del(&driver->driver_list);
 	up(&usbatm_driver_sem);
 }
 EXPORT_SYMBOL_GPL(usbatm_deregister);
 
-static int __init udsl_usb_init(void)
+static int __init usbatm_usb_init(void)
 {
-	dbg("udsl_usb_init: driver version " DRIVER_VERSION);
+	dbg("usbatm_usb_init: driver version " DRIVER_VERSION);
 
-	if (sizeof(struct udsl_control) > sizeof(((struct sk_buff *) 0)->cb)) {
+	if (sizeof(struct usbatm_control) > sizeof(((struct sk_buff *) 0)->cb)) {
 		printk(KERN_ERR __FILE__ ": unusable with this kernel!\n");
 		return -EIO;
 	}
@@ -1338,12 +1338,13 @@
 
 	return 0;
 }
-module_init(udsl_usb_init);
+module_init(usbatm_usb_init);
 
-static void __exit udsl_usb_exit(void)
+static void __exit usbatm_usb_exit(void)
 {
+	dbg("usbatm_usb_exit");
 }
-module_exit(udsl_usb_exit);
+module_exit(usbatm_usb_exit);
 
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
@@ -1355,7 +1356,7 @@
 ************/
 
 #ifdef VERBOSE_DEBUG
-static int udsl_print_packet(const unsigned char *data, int len)
+static int usbatm_print_packet(const unsigned char *data, int len)
 {
 	unsigned char buffer[256];
 	int i = 0, j = 0;

More information about the Usbatm-commits mailing list