<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">ChangeSet 1.1288, 2003/12/12 11:49:05-08:00, zaitcev@redhat.com

[PATCH] USB: Backport of printer 2.6=&gt;2.4

&gt; Pete, I tested your backport + this change above on 2.4.23 and it works
&gt; well on my HP psc 2110.

&gt; I did have to apply part of the patch by hand, so I rediffed it against
&gt; 2.4.23.  Patch is below.

OK, either way is good. However, I don't understand why it
didn't apply for you. I tried this way and that, it all matches.
The patch you posted applies cleanly, too. Hmmm.... I think the
attached should be perfect. I do not much like the syntax of
"while ( 1==1 )", but if 2.6 has it...


 drivers/usb/printer.c |  285 +++++++++++++++++++++++++++++++++-----------------
 1 files changed, 192 insertions(+), 93 deletions(-)


diff -Nru a/drivers/usb/printer.c b/drivers/usb/printer.c
--- a/drivers/usb/printer.c	Fri Dec 12 15:05:46 2003
+++ b/drivers/usb/printer.c	Fri Dec 12 15:05:46 2003
@@ -22,8 +22,11 @@
  *	v0.7 - fixed bulk-IN read and poll (David Paschal)
  *	v0.8 - add devfs support
  *	v0.9 - fix unplug-while-open paths
- *	v0.10 - add proto_bias option (Pete Zaitcev)
- *	v0.11 - add hpoj.sourceforge.net ioctls (David Paschal)
+ *	v0.10- remove sleep_on, fix error on oom (oliver@neukum.org)
+ *	v0.11 - add proto_bias option (Pete Zaitcev)
+ *	v0.12 - add hpoj.sourceforge.net ioctls (David Paschal)
+ *	v0.13 - alloc space for statusbuf (&lt;status&gt; not on stack);
+ *		use usb_buffer_alloc() for read buf &amp; write buf;
  */
 
 /*
@@ -58,12 +61,12 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.11"
+#define DRIVER_VERSION "v0.13"
 #define DRIVER_AUTHOR "Michael Gee, Pavel Machek, Vojtech Pavlik, Randy Dunlap, Pete Zaitcev, David Paschal"
 #define DRIVER_DESC "USB Printer Device Class driver"
 
 #define USBLP_BUF_SIZE		8192
-#define DEVICE_ID_SIZE		1024
+#define USBLP_DEVICE_ID_SIZE	1024
 
 /* ioctls: */
 #define LPGETSTATUS		0x060b		/* same as in drivers/char/lp.c */
@@ -115,12 +118,20 @@
 #define USBLP_LAST_PROTOCOL	3
 #define USBLP_MAX_PROTOCOLS	(USBLP_LAST_PROTOCOL+1)
 
+/*
+ * some arbitrary status buffer size;
+ * need a status buffer that is allocated via kmalloc(), not on stack
+ */
+#define STATUS_BUF_SIZE		8
+
 struct usblp {
 	struct usb_device 	*dev;			/* USB device */
 	devfs_handle_t		devfs;			/* devfs device */
 	struct semaphore	sem;			/* locks this struct, especially "dev" */
-	char			*buf;		/* writeurb.transfer_buffer */
-	struct urb		readurb, writeurb;	/* The urbs */
+	char			*writebuf;		/* write transfer_buffer */
+	char			*readbuf;		/* read transfer_buffer */
+	char			*statusbuf;		/* status transfer_buffer */
+	struct urb		*readurb, *writeurb;	/* The urbs */
 	wait_queue_head_t	wait;			/* Zzzzz ... */
 	int			readcount;		/* Counter for reads */
 	int			ifnum;			/* Interface number */
@@ -133,8 +144,11 @@
 	}			protocol[USBLP_MAX_PROTOCOLS];
 	int			current_protocol;
 	int			minor;			/* minor number of device */
+	int			wcomplete;		/* writing is completed */
+	int			rcomplete;		/* reading is completed */
 	unsigned int		quirks;			/* quirks flags */
 	unsigned char		used;			/* True if open */
+	unsigned char		present;		/* True if not disconnected */
 	unsigned char		bidir;			/* interface is bidirectional */
 	unsigned char		*device_id_string;	/* IEEE 1284 DEVICE ID string (ptr) */
 							/* first 2 bytes are (big-endian) length */
@@ -146,8 +160,11 @@
 
 	dbg("usblp=0x%p", usblp);
 	dbg("dev=0x%p", usblp-&gt;dev);
-	dbg("devfs=0x%p", usblp-&gt;devfs);
-	dbg("buf=0x%p", usblp-&gt;buf);
+	dbg("present=%d", usblp-&gt;present);
+	dbg("readbuf=0x%p", usblp-&gt;readbuf);
+	dbg("writebuf=0x%p", usblp-&gt;writebuf);
+	dbg("readurb=0x%p", usblp-&gt;readurb);
+	dbg("writeurb=0x%p", usblp-&gt;writeurb);
 	dbg("readcount=%d", usblp-&gt;readcount);
 	dbg("ifnum=%d", usblp-&gt;ifnum);
     for (p = USBLP_FIRST_PROTOCOL; p &lt;= USBLP_LAST_PROTOCOL; p++) {
@@ -157,6 +174,8 @@
     }
 	dbg("current_protocol=%d", usblp-&gt;current_protocol);
 	dbg("minor=%d", usblp-&gt;minor);
+	dbg("wcomplete=%d", usblp-&gt;wcomplete);
+	dbg("rcomplete=%d", usblp-&gt;rcomplete);
 	dbg("quirks=%d", usblp-&gt;quirks);
 	dbg("used=%d", usblp-&gt;used);
 	dbg("bidir=%d", usblp-&gt;bidir);
@@ -239,17 +258,31 @@
  * URB callback.
  */
 
-static void usblp_bulk(struct urb *urb)
+static void usblp_bulk_read(struct urb *urb)
 {
 	struct usblp *usblp = urb-&gt;context;
 
-	if (!usblp || !usblp-&gt;dev || !usblp-&gt;used)
+	if (!usblp || !usblp-&gt;dev || !usblp-&gt;used || !usblp-&gt;present)
 		return;
 
-	if (urb-&gt;status)
+	if (unlikely(urb-&gt;status))
 		warn("usblp%d: nonzero read/write bulk status received: %d",
 			usblp-&gt;minor, urb-&gt;status);
+	usblp-&gt;rcomplete = 1;
+	wake_up_interruptible(&amp;usblp-&gt;wait);
+}
+
+static void usblp_bulk_write(struct urb *urb)
+{
+	struct usblp *usblp = urb-&gt;context;
+
+	if (!usblp || !usblp-&gt;dev || !usblp-&gt;used || !usblp-&gt;present)
+		return;
 
+	if (unlikely(urb-&gt;status))
+		warn("usblp%d: nonzero read/write bulk status received: %d",
+			usblp-&gt;minor, urb-&gt;status);
+	usblp-&gt;wcomplete = 1;
 	wake_up_interruptible(&amp;usblp-&gt;wait);
 }
 
@@ -257,25 +290,28 @@
  * Get and print printer errors.
  */
 
-static char *usblp_messages[] = { "ok", "out of paper", "off-line", "unknown error" };
+static char *usblp_messages[] = { "ok", "out of paper", "off-line", "on fire" };
 
 static int usblp_check_status(struct usblp *usblp, int err)
 {
 	unsigned char status, newerr = 0;
 	int error;
 
-	error = usblp_read_status (usblp, &amp;status);
+	error = usblp_read_status (usblp, usblp-&gt;statusbuf);
 	if (error &lt; 0) {
 		err("usblp%d: error %d reading printer status",
 			usblp-&gt;minor, error);
 		return 0;
 	}
 
-	if (~status &amp; LP_PERRORP) {
+	status = *usblp-&gt;statusbuf;
+
+	if (~status &amp; LP_PERRORP)
 		newerr = 3;
-		if (status &amp; LP_POUTPA) newerr = 1;
-		if (~status &amp; LP_PSELECD) newerr = 2;
-	}
+	if (status &amp; LP_POUTPA)
+		newerr = 1;
+	if (~status &amp; LP_PSELECD)
+		newerr = 2;
 
 	if (newerr != err)
 		info("usblp%d: %s", usblp-&gt;minor, usblp_messages[newerr]);
@@ -300,7 +336,7 @@
 	usblp  = usblp_table[minor];
 
 	retval = -ENODEV;
-	if (!usblp || !usblp-&gt;dev)
+	if (!usblp || !usblp-&gt;dev || !usblp-&gt;present)
 		goto out;
 
 	retval = -EBUSY;
@@ -324,13 +360,14 @@
 	usblp-&gt;used = 1;
 	file-&gt;private_data = usblp;
 
-	usblp-&gt;writeurb.transfer_buffer_length = 0;
-	usblp-&gt;writeurb.status = 0;
+	usblp-&gt;writeurb-&gt;transfer_buffer_length = 0;
+	usblp-&gt;wcomplete = 1; /* we begin writeable */
+	usblp-&gt;rcomplete = 0;
 
 	if (usblp-&gt;bidir) {
 		usblp-&gt;readcount = 0;
-		usblp-&gt;readurb.dev = usblp-&gt;dev;
-		if (usb_submit_urb(&amp;usblp-&gt;readurb) &lt; 0) {
+		usblp-&gt;readurb-&gt;dev = usblp-&gt;dev;
+		if (usb_submit_urb(usblp-&gt;readurb) &lt; 0) {
 			retval = -EIO;
 			usblp-&gt;used = 0;
 			file-&gt;private_data = NULL;
@@ -347,16 +384,20 @@
 	usblp_table [usblp-&gt;minor] = NULL;
 	info("usblp%d: removed", usblp-&gt;minor);
 
-	kfree (usblp-&gt;writeurb.transfer_buffer);
+	kfree (usblp-&gt;writebuf);
+	kfree (usblp-&gt;readbuf);
 	kfree (usblp-&gt;device_id_string);
+	kfree (usblp-&gt;statusbuf);
+	usb_free_urb(usblp-&gt;writeurb);
+	usb_free_urb(usblp-&gt;readurb);
 	kfree (usblp);
 }
 
 static void usblp_unlink_urbs(struct usblp *usblp)
 {
-	usb_unlink_urb(&amp;usblp-&gt;writeurb);
+	usb_unlink_urb(usblp-&gt;writeurb);
 	if (usblp-&gt;bidir)
-		usb_unlink_urb(&amp;usblp-&gt;readurb);
+		usb_unlink_urb(usblp-&gt;readurb);
 }
 
 static int usblp_release(struct inode *inode, struct file *file)
@@ -366,7 +407,7 @@
 	down (&amp;usblp-&gt;sem);
 	lock_kernel();
 	usblp-&gt;used = 0;
-	if (usblp-&gt;dev) {
+	if (usblp-&gt;present) {
 		usblp_unlink_urbs(usblp);
 		up(&amp;usblp-&gt;sem);
 	} else 		/* finish cleanup from disconnect */
@@ -380,21 +421,21 @@
 {
 	struct usblp *usblp = file-&gt;private_data;
 	poll_wait(file, &amp;usblp-&gt;wait, wait);
- 	return ((!usblp-&gt;bidir || usblp-&gt;readurb.status  == -EINPROGRESS) ? 0 : POLLIN  | POLLRDNORM)
- 			       | (usblp-&gt;writeurb.status == -EINPROGRESS  ? 0 : POLLOUT | POLLWRNORM);
+ 	return ((!usblp-&gt;bidir || !usblp-&gt;rcomplete) ? 0 : POLLIN  | POLLRDNORM)
+ 			       | (!usblp-&gt;wcomplete ? 0 : POLLOUT | POLLWRNORM);
 }
 
 static int usblp_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct usblp *usblp = file-&gt;private_data;
 	int length, err, i;
-	unsigned char lpstatus, newChannel;
+	unsigned char newChannel;
 	int status;
 	int twoints[2];
 	int retval = 0;
 
 	down (&amp;usblp-&gt;sem);
-	if (!usblp-&gt;dev) {
+	if (!usblp-&gt;present) {
 		retval = -ENODEV;
 		goto done;
 	}
@@ -534,24 +575,24 @@
 				break;
 
 			default:
-				retval = -EINVAL;
+				retval = -ENOTTY;
 		}
 	else	/* old-style ioctl value */
 		switch (cmd) {
 
 			case LPGETSTATUS:
-				if (usblp_read_status(usblp, &amp;lpstatus)) {
+				if (usblp_read_status(usblp, usblp-&gt;statusbuf)) {
 					err("usblp%d: failed reading printer status", usblp-&gt;minor);
 					retval = -EIO;
 					goto done;
 				}
-				status = lpstatus;
+				status = *usblp-&gt;statusbuf;
 				if (copy_to_user ((int *)arg, &amp;status, sizeof(int)))
 					retval = -EFAULT;
 				break;
 
 			default:
-				retval = -EINVAL;
+				retval = -ENOTTY;
 		}
 
 done:
@@ -561,41 +602,48 @@
 
 static ssize_t usblp_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
 {
+	DECLARE_WAITQUEUE(wait, current);
 	struct usblp *usblp = file-&gt;private_data;
 	int timeout, err = 0;
 	size_t writecount = 0;
 
 	while (writecount &lt; count) {
-
-		// FIXME:  only use urb-&gt;status inside completion
-		// callbacks; this way is racey...
-		if (usblp-&gt;writeurb.status == -EINPROGRESS) {
-
+		if (!usblp-&gt;wcomplete) {
+			barrier();
 			if (file-&gt;f_flags &amp; O_NONBLOCK)
 				return -EAGAIN;
 
 			timeout = USBLP_WRITE_TIMEOUT;
-			while (timeout &amp;&amp; usblp-&gt;writeurb.status == -EINPROGRESS) {
+			add_wait_queue(&amp;usblp-&gt;wait, &amp;wait);
+			while ( 1==1 ) {
 
-				if (signal_pending(current))
+				if (signal_pending(current)) {
+					remove_wait_queue(&amp;usblp-&gt;wait, &amp;wait);
 					return writecount ? writecount : -EINTR;
-
-				timeout = interruptible_sleep_on_timeout(&amp;usblp-&gt;wait, timeout);
+				}
+				set_current_state(TASK_INTERRUPTIBLE);
+				if (timeout &amp;&amp; !usblp-&gt;wcomplete) {
+					timeout = schedule_timeout(timeout);
+				} else {
+					set_current_state(TASK_RUNNING);
+					break;
+				}
 			}
+			remove_wait_queue(&amp;usblp-&gt;wait, &amp;wait);
 		}
 
 		down (&amp;usblp-&gt;sem);
-		if (!usblp-&gt;dev) {
+		if (!usblp-&gt;present) {
 			up (&amp;usblp-&gt;sem);
 			return -ENODEV;
 		}
 
-		if (usblp-&gt;writeurb.status != 0) {
+		if (usblp-&gt;writeurb-&gt;status != 0) {
 			if (usblp-&gt;quirks &amp; USBLP_QUIRK_BIDIR) {
-				if (usblp-&gt;writeurb.status != -EINPROGRESS)
+				if (!usblp-&gt;wcomplete)
 					err("usblp%d: error %d writing to printer",
-						usblp-&gt;minor, usblp-&gt;writeurb.status);
-				err = usblp-&gt;writeurb.status;
+						usblp-&gt;minor, usblp-&gt;writeurb-&gt;status);
+				err = usblp-&gt;writeurb-&gt;status;
 			} else
 				err = usblp_check_status(usblp, err);
 			up (&amp;usblp-&gt;sem);
@@ -607,25 +655,30 @@
 			continue;
 		}
 
-		writecount += usblp-&gt;writeurb.transfer_buffer_length;
-		usblp-&gt;writeurb.transfer_buffer_length = 0;
+		writecount += usblp-&gt;writeurb-&gt;transfer_buffer_length;
+		usblp-&gt;writeurb-&gt;transfer_buffer_length = 0;
 
 		if (writecount == count) {
 			up (&amp;usblp-&gt;sem);
 			break;
 		}
 
-		usblp-&gt;writeurb.transfer_buffer_length = (count - writecount) &lt; USBLP_BUF_SIZE ?
-							 (count - writecount) : USBLP_BUF_SIZE;
+		usblp-&gt;writeurb-&gt;transfer_buffer_length = (count - writecount) &lt; USBLP_BUF_SIZE ?
+							  (count - writecount) : USBLP_BUF_SIZE;
 
-		if (copy_from_user(usblp-&gt;writeurb.transfer_buffer, buffer + writecount,
-				usblp-&gt;writeurb.transfer_buffer_length)) {
+		if (copy_from_user(usblp-&gt;writeurb-&gt;transfer_buffer, buffer + writecount,
+				usblp-&gt;writeurb-&gt;transfer_buffer_length)) {
 			up(&amp;usblp-&gt;sem);
 			return writecount ? writecount : -EFAULT;
 		}
 
-		usblp-&gt;writeurb.dev = usblp-&gt;dev;
-		usb_submit_urb(&amp;usblp-&gt;writeurb);
+		usblp-&gt;writeurb-&gt;dev = usblp-&gt;dev;
+		usblp-&gt;wcomplete = 0;
+		if (usb_submit_urb(usblp-&gt;writeurb)) {
+			count = -EIO;
+			up (&amp;usblp-&gt;sem);
+			break;
+		}
 		up (&amp;usblp-&gt;sem);
 	}
 
@@ -635,63 +688,77 @@
 static ssize_t usblp_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
 {
 	struct usblp *usblp = file-&gt;private_data;
+	DECLARE_WAITQUEUE(wait, current);
 
 	if (!usblp-&gt;bidir)
 		return -EINVAL;
 
 	down (&amp;usblp-&gt;sem);
-	if (!usblp-&gt;dev) {
+	if (!usblp-&gt;present) {
 		count = -ENODEV;
 		goto done;
 	}
 
-	if (usblp-&gt;readurb.status == -EINPROGRESS) {
+	if (!usblp-&gt;rcomplete) {
+		barrier();
 
 		if (file-&gt;f_flags &amp; O_NONBLOCK) {
 			count = -EAGAIN;
 			goto done;
 		}
 
-		// FIXME:  only use urb-&gt;status inside completion
-		// callbacks; this way is racey...
-		while (usblp-&gt;readurb.status == -EINPROGRESS) {
+		add_wait_queue(&amp;usblp-&gt;wait, &amp;wait);
+		while (1==1) {
 			if (signal_pending(current)) {
 				count = -EINTR;
+				remove_wait_queue(&amp;usblp-&gt;wait, &amp;wait);
 				goto done;
 			}
 			up (&amp;usblp-&gt;sem);
-			interruptible_sleep_on(&amp;usblp-&gt;wait);
+			set_current_state(TASK_INTERRUPTIBLE);
+			if (!usblp-&gt;rcomplete) {
+				schedule();
+			} else {
+				set_current_state(TASK_RUNNING);
+				break;
+			}
 			down (&amp;usblp-&gt;sem);
 		}
+		remove_wait_queue(&amp;usblp-&gt;wait, &amp;wait);
 	}
 
-	if (!usblp-&gt;dev) {
+	if (!usblp-&gt;present) {
 		count = -ENODEV;
 		goto done;
 	}
 
-	if (usblp-&gt;readurb.status) {
+	if (usblp-&gt;readurb-&gt;status) {
 		err("usblp%d: error %d reading from printer",
-			usblp-&gt;minor, usblp-&gt;readurb.status);
-		usblp-&gt;readurb.dev = usblp-&gt;dev;
+			usblp-&gt;minor, usblp-&gt;readurb-&gt;status);
+		usblp-&gt;readurb-&gt;dev = usblp-&gt;dev;
  		usblp-&gt;readcount = 0;
-		usb_submit_urb(&amp;usblp-&gt;readurb);
+		if (usb_submit_urb(usblp-&gt;readurb) &lt; 0)
+			dbg("error submitting urb");
 		count = -EIO;
 		goto done;
 	}
 
-	count = count &lt; usblp-&gt;readurb.actual_length - usblp-&gt;readcount ?
-		count :	usblp-&gt;readurb.actual_length - usblp-&gt;readcount;
+	count = count &lt; usblp-&gt;readurb-&gt;actual_length - usblp-&gt;readcount ?
+		count :	usblp-&gt;readurb-&gt;actual_length - usblp-&gt;readcount;
 
-	if (copy_to_user(buffer, usblp-&gt;readurb.transfer_buffer + usblp-&gt;readcount, count)) {
+	if (copy_to_user(buffer, usblp-&gt;readurb-&gt;transfer_buffer + usblp-&gt;readcount, count)) {
 		count = -EFAULT;
 		goto done;
 	}
 
-	if ((usblp-&gt;readcount += count) == usblp-&gt;readurb.actual_length) {
+	if ((usblp-&gt;readcount += count) == usblp-&gt;readurb-&gt;actual_length) {
 		usblp-&gt;readcount = 0;
-		usblp-&gt;readurb.dev = usblp-&gt;dev;
-		usb_submit_urb(&amp;usblp-&gt;readurb);
+		usblp-&gt;readurb-&gt;dev = usblp-&gt;dev;
+		usblp-&gt;rcomplete = 0;
+		if (usb_submit_urb(usblp-&gt;readurb)) {
+			count = -EIO;
+			goto done;
+		}
 	}
 
 done:
@@ -766,19 +833,42 @@
 		}
 	}
 
+	usblp-&gt;writeurb = usb_alloc_urb(0);
+	if (!usblp-&gt;writeurb) {
+		err("out of memory");
+		goto abort;
+	}
+	usblp-&gt;readurb = usb_alloc_urb(0);
+	if (!usblp-&gt;readurb) {
+		err("out of memory");
+		goto abort;
+	}
+
 	/* Malloc device ID string buffer to the largest expected length,
 	 * since we can re-query it on an ioctl and a dynamic string
 	 * could change in length. */
-	if (!(usblp-&gt;device_id_string = kmalloc(DEVICE_ID_SIZE, GFP_KERNEL))) {
+	if (!(usblp-&gt;device_id_string = kmalloc(USBLP_DEVICE_ID_SIZE, GFP_KERNEL))) {
 		err("out of memory for device_id_string");
 		goto abort;
 	}
 
-	/* Malloc write/read buffers in one chunk.  We somewhat wastefully
+	usblp-&gt;writebuf = usblp-&gt;readbuf = NULL;
+	/* Malloc write &amp; read buffers.  We somewhat wastefully
 	 * malloc both regardless of bidirectionality, because the
 	 * alternate setting can be changed later via an ioctl. */
-	if (!(usblp-&gt;buf = kmalloc(2 * USBLP_BUF_SIZE, GFP_KERNEL))) {
-		err("out of memory for buf");
+	if (!(usblp-&gt;writebuf = kmalloc(USBLP_BUF_SIZE, GFP_KERNEL))) {
+		err("out of memory for write buf");
+		goto abort;
+	}
+	if (!(usblp-&gt;readbuf = kmalloc(USBLP_BUF_SIZE, GFP_KERNEL))) {
+		err("out of memory for read buf");
+		goto abort;
+	}
+
+	/* Allocate buffer for printer status */
+	usblp-&gt;statusbuf = kmalloc(STATUS_BUF_SIZE, GFP_KERNEL);
+	if (!usblp-&gt;statusbuf) {
+		err("out of memory for statusbuf");
 		goto abort;
 	}
 
@@ -818,17 +908,26 @@
 
 	info("usblp%d: USB %sdirectional printer dev %d "
 		"if %d alt %d proto %d vid 0x%4.4X pid 0x%4.4X",
-		usblp-&gt;minor, usblp-&gt;bidir ? "Bi" : "Uni", dev-&gt;devnum, ifnum,
+		usblp-&gt;minor, usblp-&gt;bidir ? "Bi" : "Uni", dev-&gt;devnum,
+		usblp-&gt;ifnum,
 		usblp-&gt;protocol[usblp-&gt;current_protocol].alt_setting,
 		usblp-&gt;current_protocol, usblp-&gt;dev-&gt;descriptor.idVendor,
 		usblp-&gt;dev-&gt;descriptor.idProduct);
 
+	usblp-&gt;present = 1;
+
 	return usblp;
 
 abort:
 	if (usblp) {
-		if (usblp-&gt;buf) kfree(usblp-&gt;buf);
-		if (usblp-&gt;device_id_string) kfree(usblp-&gt;device_id_string);
+		if (usblp-&gt;writebuf)
+			kfree (usblp-&gt;writebuf);
+		if (usblp-&gt;readbuf)
+			kfree (usblp-&gt;readbuf);
+		kfree(usblp-&gt;statusbuf);
+		kfree(usblp-&gt;device_id_string);
+		usb_free_urb(usblp-&gt;writeurb);
+		usb_free_urb(usblp-&gt;readurb);
 		kfree(usblp);
 	}
 	return NULL;
@@ -943,19 +1042,19 @@
 		return r;
 	}
 
-	FILL_BULK_URB(&amp;usblp-&gt;writeurb, usblp-&gt;dev,
+	usb_fill_bulk_urb(usblp-&gt;writeurb, usblp-&gt;dev,
 		usb_sndbulkpipe(usblp-&gt;dev,
-		 usblp-&gt;protocol[protocol].epwrite-&gt;bEndpointAddress),
-		usblp-&gt;buf, 0,
-		usblp_bulk, usblp);
+		  usblp-&gt;protocol[protocol].epwrite-&gt;bEndpointAddress),
+		usblp-&gt;writebuf, 0,
+		usblp_bulk_write, usblp);
 
 	usblp-&gt;bidir = (usblp-&gt;protocol[protocol].epread != 0);
 	if (usblp-&gt;bidir)
-		FILL_BULK_URB(&amp;usblp-&gt;readurb, usblp-&gt;dev,
+		usb_fill_bulk_urb(usblp-&gt;readurb, usblp-&gt;dev,
 			usb_rcvbulkpipe(usblp-&gt;dev,
-			 usblp-&gt;protocol[protocol].epread-&gt;bEndpointAddress),
-			usblp-&gt;buf + USBLP_BUF_SIZE, USBLP_BUF_SIZE,
-			usblp_bulk, usblp);
+			  usblp-&gt;protocol[protocol].epread-&gt;bEndpointAddress),
+			usblp-&gt;readbuf, USBLP_BUF_SIZE,
+			usblp_bulk_read, usblp);
 
 	usblp-&gt;current_protocol = protocol;
 	dbg("usblp%d set protocol %d", usblp-&gt;minor, protocol);
@@ -969,7 +1068,7 @@
 {
 	int err, length;
 
-	err = usblp_get_id(usblp, 0, usblp-&gt;device_id_string, DEVICE_ID_SIZE - 1);
+	err = usblp_get_id(usblp, 0, usblp-&gt;device_id_string, USBLP_DEVICE_ID_SIZE - 1);
 	if (err &lt; 0) {
 		dbg("usblp%d: error = %d reading IEEE-1284 Device ID string",
 			usblp-&gt;minor, err);
@@ -983,8 +1082,8 @@
 	length = (usblp-&gt;device_id_string[0] &lt;&lt; 8) + usblp-&gt;device_id_string[1];
 	if (length &lt; 2)
 		length = 2;
-	else if (length &gt;= DEVICE_ID_SIZE)
-		length = DEVICE_ID_SIZE - 1;
+	else if (length &gt;= USBLP_DEVICE_ID_SIZE)
+		length = USBLP_DEVICE_ID_SIZE - 1;
 	usblp-&gt;device_id_string[length] = '\0';
 
 	dbg("usblp%d Device ID string [len=%d]=\"%s\"",
@@ -1004,13 +1103,13 @@
 
 	down (&amp;usblp-&gt;sem);
 	lock_kernel();
-	usblp-&gt;dev = NULL;
+	usblp-&gt;present = 0;
 
 	usblp_unlink_urbs(usblp);
 
 	if (!usblp-&gt;used)
 		usblp_cleanup (usblp);
-	else 	/* cleanup later, on close */
+	else 	/* cleanup later, on release */
 		up (&amp;usblp-&gt;sem);
 	unlock_kernel();
 }
</pre></body></html>