Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 9908a32e94de2141463e104c9924279ed3509447

Authored by Greg Kroah-Hartman 2008-08-15 00:37:34 +0800

1 parent 194343d936

Exists in master and in 7 other branches

USB: remove err() macro from usb class drivers

USB should not be having it's own printk macros, so remove err() and
use the system-wide standard of dev_err() wherever possible.  In the
few places that will not work out, use a basic printk().

Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

Showing 3 changed files with 48 additions and 30 deletions Inline Diff

drivers/usb/class/cdc-acm.c
drivers/usb/class/cdc-wdm.c
drivers/usb/class/usblp.c

drivers/usb/class/cdc-acm.c

Diff comments View file @ 9908a32

 /*
  * cdc-acm.c
  *
  * Copyright (c) 1999 Armin Fuerst	<fuerst@in.tum.de>
  * Copyright (c) 1999 Pavel Machek	<pavel@suse.cz>
  * Copyright (c) 1999 Johannes Erdfelt	<johannes@erdfelt.com>
  * Copyright (c) 2000 Vojtech Pavlik	<vojtech@suse.cz>
  * Copyright (c) 2004 Oliver Neukum	<oliver@neukum.name>
  * Copyright (c) 2005 David Kubicek	<dave@awk.cz>
  *
  * USB Abstract Control Model driver for USB modems and ISDN adapters
  *
  * Sponsored by SuSE
  *
  * ChangeLog:
  *	v0.9  - thorough cleaning, URBification, almost a rewrite
  *	v0.10 - some more cleanups
  *	v0.11 - fixed flow control, read error doesn't stop reads
  *	v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
  *	v0.13 - added termios, added hangup
  *	v0.14 - sized down struct acm
  *	v0.15 - fixed flow control again - characters could be lost
  *	v0.16 - added code for modems with swapped data and control interfaces
  *	v0.17 - added new style probing
  *	v0.18 - fixed new style probing for devices with more configurations
  *	v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
  *	v0.20 - switched to probing on interface (rather than device) class
  *	v0.21 - revert to probing on device for devices with multiple configs
  *	v0.22 - probe only the control interface. if usbcore doesn't choose the
  *		config we want, sysadmin changes bConfigurationValue in sysfs.
  *	v0.23 - use softirq for rx processing, as needed by tty layer
  *	v0.24 - change probe method to evaluate CDC union descriptor
  *	v0.25 - downstream tasks paralelized to maximize throughput
  *	v0.26 - multiple write urbs, writesize increased
  */
 /*
  * 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
  */
 #undef DEBUG
 #undef VERBOSE_DEBUG
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <asm/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/cdc.h>
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
 #include <linux/list.h>
 #include "cdc-acm.h"
 #define ACM_CLOSE_TIMEOUT	15	/* seconds to let writes drain */
 /*
  * Version Information
  */
 #define DRIVER_VERSION "v0.26"
 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
 static struct usb_driver acm_driver;
 static struct tty_driver *acm_tty_driver;
 static struct acm *acm_table[ACM_TTY_MINORS];
 static DEFINE_MUTEX(open_mutex);
 #define ACM_READY(acm)	(acm && acm->dev && acm->used)
 #ifdef VERBOSE_DEBUG
 #define verbose	1
 #else
 #define verbose	0
 #endif
 /*
  * Functions for ACM control messages.
  */
 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
 {
 	int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
 		request, USB_RT_ACM, value,
 		acm->control->altsetting[0].desc.bInterfaceNumber,
 		buf, len, 5000);
 	dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
 	return retval < 0 ? retval : 0;
 }
 /* devices aren't required to support these requests.
  * the cdc acm descriptor tells whether they do...
  */
 #define acm_set_control(acm, control) \
 	acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
 #define acm_set_line(acm, line) \
 	acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
 #define acm_send_break(acm, ms) \
 	acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
 /*
  * Write buffer management.
  * All of these assume proper locks taken by the caller.
  */
 static int acm_wb_alloc(struct acm *acm)
 {
 	int i, wbn;
 	struct acm_wb *wb;
 	wbn = 0;
 	i = 0;
 	for (;;) {
 		wb = &acm->wb[wbn];
 		if (!wb->use) {
 			wb->use = 1;
 			return wbn;
 		}
 		wbn = (wbn + 1) % ACM_NW;
 		if (++i >= ACM_NW)
 			return -1;
 	}
 }
 static int acm_wb_is_avail(struct acm *acm)
 {
 	int i, n;
 	unsigned long flags;
 	n = ACM_NW;
 	spin_lock_irqsave(&acm->write_lock, flags);
 	for (i = 0; i < ACM_NW; i++) {
 		n -= acm->wb[i].use;
 	}
 	spin_unlock_irqrestore(&acm->write_lock, flags);
 	return n;
 }
 /*
  * Finish write.
  */
 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&acm->write_lock, flags);
 	wb->use = 0;
 	acm->transmitting--;
 	spin_unlock_irqrestore(&acm->write_lock, flags);
 }
 /*
  * Poke write.
  *
  * the caller is responsible for locking
  */
 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 {
 	int rc;
 	acm->transmitting++;
 	wb->urb->transfer_buffer = wb->buf;
 	wb->urb->transfer_dma = wb->dmah;
 	wb->urb->transfer_buffer_length = wb->len;
 	wb->urb->dev = acm->dev;
 	if ((rc = usb_submit_urb(wb->urb, GFP_ATOMIC)) < 0) {
 		dbg("usb_submit_urb(write bulk) failed: %d", rc);
 		acm_write_done(acm, wb);
 	}
 	return rc;
 }
 static int acm_write_start(struct acm *acm, int wbn)
 {
 	unsigned long flags;
 	struct acm_wb *wb = &acm->wb[wbn];
 	int rc;
 	spin_lock_irqsave(&acm->write_lock, flags);
 	if (!acm->dev) {
 		wb->use = 0;
 		spin_unlock_irqrestore(&acm->write_lock, flags);
 		return -ENODEV;
 	}
 	dbg("%s susp_count: %d", __func__, acm->susp_count);
 	if (acm->susp_count) {
 		acm->delayed_wb = wb;
 		schedule_work(&acm->waker);
 		spin_unlock_irqrestore(&acm->write_lock, flags);
 		return 0;	/* A white lie */
 	}
 	usb_mark_last_busy(acm->dev);
 	rc = acm_start_wb(acm, wb);
 	spin_unlock_irqrestore(&acm->write_lock, flags);
 	return rc;
 }
 /*
  * attributes exported through sysfs
  */
 static ssize_t show_caps
 (struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct usb_interface *intf = to_usb_interface(dev);
 	struct acm *acm = usb_get_intfdata(intf);
 	return sprintf(buf, "%d", acm->ctrl_caps);
 }
 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
 static ssize_t show_country_codes
 (struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct usb_interface *intf = to_usb_interface(dev);
 	struct acm *acm = usb_get_intfdata(intf);
 	memcpy(buf, acm->country_codes, acm->country_code_size);
 	return acm->country_code_size;
 }
 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
 static ssize_t show_country_rel_date
 (struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct usb_interface *intf = to_usb_interface(dev);
 	struct acm *acm = usb_get_intfdata(intf);
 	return sprintf(buf, "%d", acm->country_rel_date);
 }
 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
 /*
  * Interrupt handlers for various ACM device responses
  */
 /* control interface reports status changes with "interrupt" transfers */
 static void acm_ctrl_irq(struct urb *urb)
 {
 	struct acm *acm = urb->context;
 	struct usb_cdc_notification *dr = urb->transfer_buffer;
 	unsigned char *data;
 	int newctrl;
 	int retval;
 	int status = urb->status;
 	switch (status) {
 	case 0:
 		/* success */
 		break;
 	case -ECONNRESET:
 	case -ENOENT:
 	case -ESHUTDOWN:
 		/* this urb is terminated, clean up */
 		dbg("%s - urb shutting down with status: %d", __func__, status);
 		return;
 	default:
 		dbg("%s - nonzero urb status received: %d", __func__, status);
 		goto exit;
 	}
 	if (!ACM_READY(acm))
 		goto exit;
 	data = (unsigned char *)(dr + 1);
 	switch (dr->bNotificationType) {
 		case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 			dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
 			break;
 		case USB_CDC_NOTIFY_SERIAL_STATE:
 			newctrl = get_unaligned_le16(data);
 			if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 				dbg("calling hangup");
 				tty_hangup(acm->tty);
 			}
 			acm->ctrlin = newctrl;
 			dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
 				acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',	acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 				acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',	acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 				acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',	acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 				acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 			break;
 		default:
 			dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
 				dr->bNotificationType, dr->wIndex,
 				dr->wLength, data[0], data[1]);
 			break;
 	}
 exit:
 	usb_mark_last_busy(acm->dev);
 	retval = usb_submit_urb (urb, GFP_ATOMIC);
 	if (retval)
-		err ("%s - usb_submit_urb failed with result %d",
+		dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
-		     __func__, retval);
+			"result %d", __func__, retval);
 }
 /* data interface returns incoming bytes, or we got unthrottled */
 static void acm_read_bulk(struct urb *urb)
 {
 	struct acm_rb *buf;
 	struct acm_ru *rcv = urb->context;
 	struct acm *acm = rcv->instance;
 	int status = urb->status;
 	dbg("Entering acm_read_bulk with status %d", status);
 	if (!ACM_READY(acm)) {
 		dev_dbg(&acm->data->dev, "Aborting, acm not ready");
 		return;
 	}
 	usb_mark_last_busy(acm->dev);
 	if (status)
 		dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
 	buf = rcv->buffer;
 	buf->size = urb->actual_length;
 	if (likely(status == 0)) {
 		spin_lock(&acm->read_lock);
 		acm->processing++;
 		list_add_tail(&rcv->list, &acm->spare_read_urbs);
 		list_add_tail(&buf->list, &acm->filled_read_bufs);
 		spin_unlock(&acm->read_lock);
 	} else {
 		/* we drop the buffer due to an error */
 		spin_lock(&acm->read_lock);
 		list_add_tail(&rcv->list, &acm->spare_read_urbs);
 		list_add(&buf->list, &acm->spare_read_bufs);
 		spin_unlock(&acm->read_lock);
 		/* nevertheless the tasklet must be kicked unconditionally
 		so the queue cannot dry up */
 	}
 	if (likely(!acm->susp_count))
 		tasklet_schedule(&acm->urb_task);
 }
 static void acm_rx_tasklet(unsigned long _acm)
 {
 	struct acm *acm = (void *)_acm;
 	struct acm_rb *buf;
 	struct tty_struct *tty = acm->tty;
 	struct acm_ru *rcv;
 	unsigned long flags;
 	unsigned char throttled;
 	dbg("Entering acm_rx_tasklet");
 	if (!ACM_READY(acm))
 	{
 		dbg("acm_rx_tasklet: ACM not ready");
 		return;
 	}
 	spin_lock_irqsave(&acm->throttle_lock, flags);
 	throttled = acm->throttle;
 	spin_unlock_irqrestore(&acm->throttle_lock, flags);
 	if (throttled)
 	{
 		dbg("acm_rx_tasklet: throttled");
 		return;
 	}
 next_buffer:
 	spin_lock_irqsave(&acm->read_lock, flags);
 	if (list_empty(&acm->filled_read_bufs)) {
 		spin_unlock_irqrestore(&acm->read_lock, flags);
 		goto urbs;
 	}
 	buf = list_entry(acm->filled_read_bufs.next,
 			 struct acm_rb, list);
 	list_del(&buf->list);
 	spin_unlock_irqrestore(&acm->read_lock, flags);
 	dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
 	tty_buffer_request_room(tty, buf->size);
 	spin_lock_irqsave(&acm->throttle_lock, flags);
 	throttled = acm->throttle;
 	spin_unlock_irqrestore(&acm->throttle_lock, flags);
 	if (!throttled)
 		tty_insert_flip_string(tty, buf->base, buf->size);
 	tty_flip_buffer_push(tty);
 	if (throttled) {
 		dbg("Throttling noticed");
 		spin_lock_irqsave(&acm->read_lock, flags);
 		list_add(&buf->list, &acm->filled_read_bufs);
 		spin_unlock_irqrestore(&acm->read_lock, flags);
 		return;
 	}
 	spin_lock_irqsave(&acm->read_lock, flags);
 	list_add(&buf->list, &acm->spare_read_bufs);
 	spin_unlock_irqrestore(&acm->read_lock, flags);
 	goto next_buffer;
 urbs:
 	while (!list_empty(&acm->spare_read_bufs)) {
 		spin_lock_irqsave(&acm->read_lock, flags);
 		if (list_empty(&acm->spare_read_urbs)) {
 			acm->processing = 0;
 			spin_unlock_irqrestore(&acm->read_lock, flags);
 			return;
 		}
 		rcv = list_entry(acm->spare_read_urbs.next,
 				 struct acm_ru, list);
 		list_del(&rcv->list);
 		spin_unlock_irqrestore(&acm->read_lock, flags);
 		buf = list_entry(acm->spare_read_bufs.next,
 				 struct acm_rb, list);
 		list_del(&buf->list);
 		rcv->buffer = buf;
 		usb_fill_bulk_urb(rcv->urb, acm->dev,
 				  acm->rx_endpoint,
 				  buf->base,
 				  acm->readsize,
 				  acm_read_bulk, rcv);
 		rcv->urb->transfer_dma = buf->dma;
 		rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 		/* This shouldn't kill the driver as unsuccessful URBs are returned to the
 		   free-urbs-pool and resubmited ASAP */
 		spin_lock_irqsave(&acm->read_lock, flags);
 		if (acm->susp_count || usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 			list_add(&buf->list, &acm->spare_read_bufs);
 			list_add(&rcv->list, &acm->spare_read_urbs);
 			acm->processing = 0;
 			spin_unlock_irqrestore(&acm->read_lock, flags);
 			return;
 		} else {
 			spin_unlock_irqrestore(&acm->read_lock, flags);
 			dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 		}
 	}
 	spin_lock_irqsave(&acm->read_lock, flags);
 	acm->processing = 0;
 	spin_unlock_irqrestore(&acm->read_lock, flags);
 }
 /* data interface wrote those outgoing bytes */
 static void acm_write_bulk(struct urb *urb)
 {
 	struct acm_wb *wb = urb->context;
 	struct acm *acm = wb->instance;
 	if (verbose || urb->status
 			|| (urb->actual_length != urb->transfer_buffer_length))
 		dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
 			urb->actual_length,
 			urb->transfer_buffer_length,
 			urb->status);
 	acm_write_done(acm, wb);
 	if (ACM_READY(acm))
 		schedule_work(&acm->work);
 	else
 		wake_up_interruptible(&acm->drain_wait);
 }
 static void acm_softint(struct work_struct *work)
 {
 	struct acm *acm = container_of(work, struct acm, work);
 	dev_vdbg(&acm->data->dev, "tx work\n");
 	if (!ACM_READY(acm))
 		return;
 	tty_wakeup(acm->tty);
 }
 static void acm_waker(struct work_struct *waker)
 {
 	struct acm *acm = container_of(waker, struct acm, waker);
 	int rv;
 	rv = usb_autopm_get_interface(acm->control);
 	if (rv < 0) {
-		err("Autopm failure in %s", __func__);
+		dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__);
 		return;
 	}
 	if (acm->delayed_wb) {
 		acm_start_wb(acm, acm->delayed_wb);
 		acm->delayed_wb = NULL;
 	}
 	usb_autopm_put_interface(acm->control);
 }
 /*
  * TTY handlers
  */
 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 {
 	struct acm *acm;
 	int rv = -EINVAL;
 	int i;
 	dbg("Entering acm_tty_open.");
 	mutex_lock(&open_mutex);
 	acm = acm_table[tty->index];
 	if (!acm || !acm->dev)
 		goto err_out;
 	else
 		rv = 0;
 	set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 	tty->driver_data = acm;
 	acm->tty = tty;
 	/* force low_latency on so that our tty_push actually forces the data through,
 	   otherwise it is scheduled, and with high data rates data can get lost. */
 	tty->low_latency = 1;
 	if (usb_autopm_get_interface(acm->control) < 0)
 		goto early_bail;
 	else
 		acm->control->needs_remote_wakeup = 1;
 	mutex_lock(&acm->mutex);
 	if (acm->used++) {
 		usb_autopm_put_interface(acm->control);
 		goto done;
         }
 	acm->ctrlurb->dev = acm->dev;
 	if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 		dbg("usb_submit_urb(ctrl irq) failed");
 		goto bail_out;
 	}
 	if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
 	    (acm->ctrl_caps & USB_CDC_CAP_LINE))
 		goto full_bailout;
 	usb_autopm_put_interface(acm->control);
 	INIT_LIST_HEAD(&acm->spare_read_urbs);
 	INIT_LIST_HEAD(&acm->spare_read_bufs);
 	INIT_LIST_HEAD(&acm->filled_read_bufs);
 	for (i = 0; i < acm->rx_buflimit; i++) {
 		list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 	}
 	for (i = 0; i < acm->rx_buflimit; i++) {
 		list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 	}
 	acm->throttle = 0;
 	tasklet_schedule(&acm->urb_task);
 done:
 	mutex_unlock(&acm->mutex);
 err_out:
 	mutex_unlock(&open_mutex);
 	return rv;
 full_bailout:
 	usb_kill_urb(acm->ctrlurb);
 bail_out:
 	usb_autopm_put_interface(acm->control);
 	acm->used--;
 	mutex_unlock(&acm->mutex);
 early_bail:
 	mutex_unlock(&open_mutex);
 	return -EIO;
 }
 static void acm_tty_unregister(struct acm *acm)
 {
 	int i,nr;
 	nr = acm->rx_buflimit;
 	tty_unregister_device(acm_tty_driver, acm->minor);
 	usb_put_intf(acm->control);
 	acm_table[acm->minor] = NULL;
 	usb_free_urb(acm->ctrlurb);
 	for (i = 0; i < ACM_NW; i++)
 		usb_free_urb(acm->wb[i].urb);
 	for (i = 0; i < nr; i++)
 		usb_free_urb(acm->ru[i].urb);
 	kfree(acm->country_codes);
 	kfree(acm);
 }
 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 {
 	struct acm *acm = tty->driver_data;
 	int i,nr;
 	if (!acm || !acm->used)
 		return;
 	nr = acm->rx_buflimit;
 	mutex_lock(&open_mutex);
 	if (!--acm->used) {
 		if (acm->dev) {
 			usb_autopm_get_interface(acm->control);
 			acm_set_control(acm, acm->ctrlout = 0);
 			/* try letting the last writes drain naturally */
 			wait_event_interruptible_timeout(acm->drain_wait,
 					(ACM_NW == acm_wb_is_avail(acm))
 						|| !acm->dev,
 					ACM_CLOSE_TIMEOUT * HZ);
 			usb_kill_urb(acm->ctrlurb);
 			for (i = 0; i < ACM_NW; i++)
 				usb_kill_urb(acm->wb[i].urb);
 			for (i = 0; i < nr; i++)
 				usb_kill_urb(acm->ru[i].urb);
 			acm->control->needs_remote_wakeup = 0;
 			usb_autopm_put_interface(acm->control);
 		} else
 			acm_tty_unregister(acm);
 	}
 	mutex_unlock(&open_mutex);
 }
 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
 {
 	struct acm *acm = tty->driver_data;
 	int stat;
 	unsigned long flags;
 	int wbn;
 	struct acm_wb *wb;
 	dbg("Entering acm_tty_write to write %d bytes,", count);
 	if (!ACM_READY(acm))
 		return -EINVAL;
 	if (!count)
 		return 0;
 	spin_lock_irqsave(&acm->write_lock, flags);
 	if ((wbn = acm_wb_alloc(acm)) < 0) {
 		spin_unlock_irqrestore(&acm->write_lock, flags);
 		return 0;
 	}
 	wb = &acm->wb[wbn];
 	count = (count > acm->writesize) ? acm->writesize : count;
 	dbg("Get %d bytes...", count);
 	memcpy(wb->buf, buf, count);
 	wb->len = count;
 	spin_unlock_irqrestore(&acm->write_lock, flags);
 	if ((stat = acm_write_start(acm, wbn)) < 0)
 		return stat;
 	return count;
 }
 static int acm_tty_write_room(struct tty_struct *tty)
 {
 	struct acm *acm = tty->driver_data;
 	if (!ACM_READY(acm))
 		return -EINVAL;
 	/*
 	 * Do not let the line discipline to know that we have a reserve,
 	 * or it might get too enthusiastic.
 	 */
 	return acm_wb_is_avail(acm) ? acm->writesize : 0;
 }
 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 {
 	struct acm *acm = tty->driver_data;
 	if (!ACM_READY(acm))
 		return -EINVAL;
 	/*
 	 * This is inaccurate (overcounts), but it works.
 	 */
 	return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 }
 static void acm_tty_throttle(struct tty_struct *tty)
 {
 	struct acm *acm = tty->driver_data;
 	if (!ACM_READY(acm))
 		return;
 	spin_lock_bh(&acm->throttle_lock);
 	acm->throttle = 1;
 	spin_unlock_bh(&acm->throttle_lock);
 }
 static void acm_tty_unthrottle(struct tty_struct *tty)
 {
 	struct acm *acm = tty->driver_data;
 	if (!ACM_READY(acm))
 		return;
 	spin_lock_bh(&acm->throttle_lock);
 	acm->throttle = 0;
 	spin_unlock_bh(&acm->throttle_lock);
 	tasklet_schedule(&acm->urb_task);
 }
 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 {
 	struct acm *acm = tty->driver_data;
 	int retval;
 	if (!ACM_READY(acm))
 		return -EINVAL;
 	retval = acm_send_break(acm, state ? 0xffff : 0);
 	if (retval < 0)
 		dbg("send break failed");
 	return retval;
 }
 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 {
 	struct acm *acm = tty->driver_data;
 	if (!ACM_READY(acm))
 		return -EINVAL;
 	return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 	       (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 	       (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 	       (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 	       (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 	       TIOCM_CTS;
 }
 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 			    unsigned int set, unsigned int clear)
 {
 	struct acm *acm = tty->driver_data;
 	unsigned int newctrl;
 	if (!ACM_READY(acm))
 		return -EINVAL;
 	newctrl = acm->ctrlout;
 	set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 	clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 	newctrl = (newctrl & ~clear) | set;
 	if (acm->ctrlout == newctrl)
 		return 0;
 	return acm_set_control(acm, acm->ctrlout = newctrl);
 }
 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct acm *acm = tty->driver_data;
 	if (!ACM_READY(acm))
 		return -EINVAL;
 	return -ENOIOCTLCMD;
 }
 static const __u32 acm_tty_speed[] = {
 	0, 50, 75, 110, 134, 150, 200, 300, 600,
 	1200, 1800, 2400, 4800, 9600, 19200, 38400,
 	57600, 115200, 230400, 460800, 500000, 576000,
 	921600, 1000000, 1152000, 1500000, 2000000,
 	2500000, 3000000, 3500000, 4000000
 };
 static const __u8 acm_tty_size[] = {
 	5, 6, 7, 8
 };
 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
 {
 	struct acm *acm = tty->driver_data;
 	struct ktermios *termios = tty->termios;
 	struct usb_cdc_line_coding newline;
 	int newctrl = acm->ctrlout;
 	if (!ACM_READY(acm))
 		return;
 	newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
 		(termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
 	newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 	newline.bParityType = termios->c_cflag & PARENB ?
 		(termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 	newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 	acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 	if (!newline.dwDTERate) {
 		newline.dwDTERate = acm->line.dwDTERate;
 		newctrl &= ~ACM_CTRL_DTR;
 	} else  newctrl |=  ACM_CTRL_DTR;
 	if (newctrl != acm->ctrlout)
 		acm_set_control(acm, acm->ctrlout = newctrl);
 	if (memcmp(&acm->line, &newline, sizeof newline)) {
 		memcpy(&acm->line, &newline, sizeof newline);
 		dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 			newline.bCharFormat, newline.bParityType,
 			newline.bDataBits);
 		acm_set_line(acm, &acm->line);
 	}
 }
 /*
  * USB probe and disconnect routines.
  */
 /* Little helpers: write/read buffers free */
 static void acm_write_buffers_free(struct acm *acm)
 {
 	int i;
 	struct acm_wb *wb;
 	for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 		usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
 	}
 }
 static void acm_read_buffers_free(struct acm *acm)
 {
 	struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 	int i, n = acm->rx_buflimit;
 	for (i = 0; i < n; i++)
 		usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
 }
 /* Little helper: write buffers allocate */
 static int acm_write_buffers_alloc(struct acm *acm)
 {
 	int i;
 	struct acm_wb *wb;
 	for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 		wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
 		    &wb->dmah);
 		if (!wb->buf) {
 			while (i != 0) {
 				--i;
 				--wb;
 				usb_buffer_free(acm->dev, acm->writesize,
 				    wb->buf, wb->dmah);
 			}
 			return -ENOMEM;
 		}
 	}
 	return 0;
 }
 static int acm_probe (struct usb_interface *intf,
 		      const struct usb_device_id *id)
 {
 	struct usb_cdc_union_desc *union_header = NULL;
 	struct usb_cdc_country_functional_desc *cfd = NULL;
 	unsigned char *buffer = intf->altsetting->extra;
 	int buflen = intf->altsetting->extralen;
 	struct usb_interface *control_interface;
 	struct usb_interface *data_interface;
 	struct usb_endpoint_descriptor *epctrl;
 	struct usb_endpoint_descriptor *epread;
 	struct usb_endpoint_descriptor *epwrite;
 	struct usb_device *usb_dev = interface_to_usbdev(intf);
 	struct acm *acm;
 	int minor;
 	int ctrlsize,readsize;
 	u8 *buf;
 	u8 ac_management_function = 0;
 	u8 call_management_function = 0;
 	int call_interface_num = -1;
 	int data_interface_num;
 	unsigned long quirks;
 	int num_rx_buf;
 	int i;
 	/* normal quirks */
 	quirks = (unsigned long)id->driver_info;
 	num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 	/* handle quirks deadly to normal probing*/
 	if (quirks == NO_UNION_NORMAL) {
 		data_interface = usb_ifnum_to_if(usb_dev, 1);
 		control_interface = usb_ifnum_to_if(usb_dev, 0);
 		goto skip_normal_probe;
 	}
 	/* normal probing*/
 	if (!buffer) {
-		err("Weird descriptor references\n");
+		dev_err(&intf->dev, "Weird descriptor references\n");
 		return -EINVAL;
 	}
 	if (!buflen) {
 		if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
 			dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
 			buflen = intf->cur_altsetting->endpoint->extralen;
 			buffer = intf->cur_altsetting->endpoint->extra;
 		} else {
-			err("Zero length descriptor references\n");
+			dev_err(&intf->dev,
+				"Zero length descriptor references\n");
 			return -EINVAL;
 		}
 	}
 	while (buflen > 0) {
 		if (buffer [1] != USB_DT_CS_INTERFACE) {
-			err("skipping garbage\n");
+			dev_err(&intf->dev, "skipping garbage\n");
 			goto next_desc;
 		}
 		switch (buffer [2]) {
 			case USB_CDC_UNION_TYPE: /* we've found it */
 				if (union_header) {
-					err("More than one union descriptor, skipping ...");
+					dev_err(&intf->dev, "More than one "
+						"union descriptor, "
+						"skipping ...\n");
 					goto next_desc;
 				}
 				union_header = (struct usb_cdc_union_desc *)
 							buffer;
 				break;
 			case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
 				cfd = (struct usb_cdc_country_functional_desc *)buffer;
 				break;
 			case USB_CDC_HEADER_TYPE: /* maybe check version */
 				break; /* for now we ignore it */
 			case USB_CDC_ACM_TYPE:
 				ac_management_function = buffer[3];
 				break;
 			case USB_CDC_CALL_MANAGEMENT_TYPE:
 				call_management_function = buffer[3];
 				call_interface_num = buffer[4];
 				if ((call_management_function & 3) != 3)
-					err("This device cannot do calls on its own. It is no modem.");
+					dev_err(&intf->dev, "This device "
+						"cannot do calls on its own. "
+						"It is no modem.\n");
 				break;
 			default:
 				/* there are LOTS more CDC descriptors that
 				 * could legitimately be found here.
 				 */
 				dev_dbg(&intf->dev, "Ignoring descriptor: "
 						"type %02x, length %d\n",
 						buffer[2], buffer[0]);
 				break;
 			}
 next_desc:
 		buflen -= buffer[0];
 		buffer += buffer[0];
 	}
 	if (!union_header) {
 		if (call_interface_num > 0) {
 			dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
 			data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
 			control_interface = intf;
 		} else {
 			dev_dbg(&intf->dev,"No union descriptor, giving up\n");
 			return -ENODEV;
 		}
 	} else {
 		control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 		data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 		if (!control_interface || !data_interface) {
 			dev_dbg(&intf->dev,"no interfaces\n");
 			return -ENODEV;
 		}
 	}
 	if (data_interface_num != call_interface_num)
 		dev_dbg(&intf->dev,"Separate call control interface. That is not fully supported.\n");
 skip_normal_probe:
 	/*workaround for switched interfaces */
 	if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
 		if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
 			struct usb_interface *t;
 			dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
 			t = control_interface;
 			control_interface = data_interface;
 			data_interface = t;
 		} else {
 			return -EINVAL;
 		}
 	}
 	/* Accept probe requests only for the control interface */
 	if (intf != control_interface)
 		return -ENODEV;
 	if (usb_interface_claimed(data_interface)) { /* valid in this context */
 		dev_dbg(&intf->dev,"The data interface isn't available\n");
 		return -EBUSY;
 	}
 	if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
 		return -EINVAL;
 	epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
 	epread = &data_interface->cur_altsetting->endpoint[0].desc;
 	epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
 	/* workaround for switched endpoints */
 	if (!usb_endpoint_dir_in(epread)) {
 		/* descriptors are swapped */
 		struct usb_endpoint_descriptor *t;
 		dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
 		t = epread;
 		epread = epwrite;
 		epwrite = t;
 	}
 	dbg("interfaces are valid");
 	for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 	if (minor == ACM_TTY_MINORS) {
-		err("no more free acm devices");
+		dev_err(&intf->dev, "no more free acm devices\n");
 		return -ENODEV;
 	}
 	if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
 		dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
 		goto alloc_fail;
 	}
 	ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
 	readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
 	acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
 	acm->control = control_interface;
 	acm->data = data_interface;
 	acm->minor = minor;
 	acm->dev = usb_dev;
 	acm->ctrl_caps = ac_management_function;
 	acm->ctrlsize = ctrlsize;
 	acm->readsize = readsize;
 	acm->rx_buflimit = num_rx_buf;
 	acm->urb_task.func = acm_rx_tasklet;
 	acm->urb_task.data = (unsigned long) acm;
 	INIT_WORK(&acm->work, acm_softint);
 	INIT_WORK(&acm->waker, acm_waker);
 	init_waitqueue_head(&acm->drain_wait);
 	spin_lock_init(&acm->throttle_lock);
 	spin_lock_init(&acm->write_lock);
 	spin_lock_init(&acm->read_lock);
 	mutex_init(&acm->mutex);
 	acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
 	buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
 	if (!buf) {
 		dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
 		goto alloc_fail2;
 	}
 	acm->ctrl_buffer = buf;
 	if (acm_write_buffers_alloc(acm) < 0) {
 		dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
 		goto alloc_fail4;
 	}
 	acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
 	if (!acm->ctrlurb) {
 		dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
 		goto alloc_fail5;
 	}
 	for (i = 0; i < num_rx_buf; i++) {
 		struct acm_ru *rcv = &(acm->ru[i]);
 		if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
 			dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
 			goto alloc_fail7;
 		}
 		rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 		rcv->instance = acm;
 	}
 	for (i = 0; i < num_rx_buf; i++) {
 		struct acm_rb *rb = &(acm->rb[i]);
 		rb->base = usb_buffer_alloc(acm->dev, readsize,
 				GFP_KERNEL, &rb->dma);
 		if (!rb->base) {
 			dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
 			goto alloc_fail7;
 		}
 	}
 	for(i = 0; i < ACM_NW; i++)
 	{
 		struct acm_wb *snd = &(acm->wb[i]);
 		if (!(snd->urb = usb_alloc_urb(0, GFP_KERNEL))) {
 			dev_dbg(&intf->dev, "out of memory (write urbs usb_alloc_urb)");
 			goto alloc_fail7;
 		}
 		usb_fill_bulk_urb(snd->urb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
 				NULL, acm->writesize, acm_write_bulk, snd);
 		snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 		snd->instance = acm;
 	}
 	usb_set_intfdata (intf, acm);
 	i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
 	if (i < 0)
 		goto alloc_fail8;
 	if (cfd) { /* export the country data */
 		acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
 		if (!acm->country_codes)
 			goto skip_countries;
 		acm->country_code_size = cfd->bLength - 4;
 		memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
 		acm->country_rel_date = cfd->iCountryCodeRelDate;
 		i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
 		if (i < 0) {
 			kfree(acm->country_codes);
 			goto skip_countries;
 		}
 		i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
 		if (i < 0) {
 			kfree(acm->country_codes);
 			goto skip_countries;
 		}
 	}
 skip_countries:
 	usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
 			 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
 	acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 	acm->ctrlurb->transfer_dma = acm->ctrl_dma;
 	dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
 	acm_set_control(acm, acm->ctrlout);
 	acm->line.dwDTERate = cpu_to_le32(9600);
 	acm->line.bDataBits = 8;
 	acm_set_line(acm, &acm->line);
 	usb_driver_claim_interface(&acm_driver, data_interface, acm);
 	usb_set_intfdata(data_interface, acm);
 	usb_get_intf(control_interface);
 	tty_register_device(acm_tty_driver, minor, &control_interface->dev);
 	acm_table[minor] = acm;
 	return 0;
 alloc_fail8:
 	for (i = 0; i < ACM_NW; i++)
 		usb_free_urb(acm->wb[i].urb);
 alloc_fail7:
 	acm_read_buffers_free(acm);
 	for (i = 0; i < num_rx_buf; i++)
 		usb_free_urb(acm->ru[i].urb);
 	usb_free_urb(acm->ctrlurb);
 alloc_fail5:
 	acm_write_buffers_free(acm);
 alloc_fail4:
 	usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
 alloc_fail2:
 	kfree(acm);
 alloc_fail:
 	return -ENOMEM;
 }
 static void stop_data_traffic(struct acm *acm)
 {
 	int i;
 	dbg("Entering stop_data_traffic");
 	tasklet_disable(&acm->urb_task);
 	usb_kill_urb(acm->ctrlurb);
 	for(i = 0; i < ACM_NW; i++)
 		usb_kill_urb(acm->wb[i].urb);
 	for (i = 0; i < acm->rx_buflimit; i++)
 		usb_kill_urb(acm->ru[i].urb);
 	tasklet_enable(&acm->urb_task);
 	cancel_work_sync(&acm->work);
 	cancel_work_sync(&acm->waker);
 }
 static void acm_disconnect(struct usb_interface *intf)
 {
 	struct acm *acm = usb_get_intfdata(intf);
 	struct usb_device *usb_dev = interface_to_usbdev(intf);
 	/* sibling interface is already cleaning up */
 	if (!acm)
 		return;
 	mutex_lock(&open_mutex);
 	if (acm->country_codes){
 		device_remove_file(&acm->control->dev,
 				&dev_attr_wCountryCodes);
 		device_remove_file(&acm->control->dev,
 				&dev_attr_iCountryCodeRelDate);
 	}
 	device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
 	acm->dev = NULL;
 	usb_set_intfdata(acm->control, NULL);
 	usb_set_intfdata(acm->data, NULL);
 	stop_data_traffic(acm);
 	acm_write_buffers_free(acm);
 	usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
 	acm_read_buffers_free(acm);
 	usb_driver_release_interface(&acm_driver, intf == acm->control ?
 					acm->data : acm->control);
 	if (!acm->used) {
 		acm_tty_unregister(acm);
 		mutex_unlock(&open_mutex);
 		return;
 	}
 	mutex_unlock(&open_mutex);
 	if (acm->tty)
 		tty_hangup(acm->tty);
 }
 #ifdef CONFIG_PM
 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
 {
 	struct acm *acm = usb_get_intfdata(intf);
 	int cnt;
 	if (acm->dev->auto_pm) {
 		int b;
 		spin_lock_irq(&acm->read_lock);
 		spin_lock(&acm->write_lock);
 		b = acm->processing + acm->transmitting;
 		spin_unlock(&acm->write_lock);
 		spin_unlock_irq(&acm->read_lock);
 		if (b)
 			return -EBUSY;
 	}
 	spin_lock_irq(&acm->read_lock);
 	spin_lock(&acm->write_lock);
 	cnt = acm->susp_count++;
 	spin_unlock(&acm->write_lock);
 	spin_unlock_irq(&acm->read_lock);
 	if (cnt)
 		return 0;
 	/*
 	we treat opened interfaces differently,
 	we must guard against open
 	*/
 	mutex_lock(&acm->mutex);
 	if (acm->used)
 		stop_data_traffic(acm);
 	mutex_unlock(&acm->mutex);
 	return 0;
 }
 static int acm_resume(struct usb_interface *intf)
 {
 	struct acm *acm = usb_get_intfdata(intf);
 	int rv = 0;
 	int cnt;
 	spin_lock_irq(&acm->read_lock);
 	acm->susp_count -= 1;
 	cnt = acm->susp_count;
 	spin_unlock_irq(&acm->read_lock);
 	if (cnt)
 		return 0;
 	mutex_lock(&acm->mutex);
 	if (acm->used) {
 		rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
 		if (rv < 0)
 			goto err_out;
 		tasklet_schedule(&acm->urb_task);
 	}
 err_out:
 	mutex_unlock(&acm->mutex);
 	return rv;
 }
 #endif /* CONFIG_PM */
 /*
  * USB driver structure.
  */
 static struct usb_device_id acm_ids[] = {
 	/* quirky and broken devices */
 	{ USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
 	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
 	},
 	{ USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
 	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
 	},
 	{ USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
 	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
 	},
 	{ USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
 	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
 	},
 	{ USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
 	.driver_info = SINGLE_RX_URB, /* firmware bug */
 	},
 	{ USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
 	.driver_info = SINGLE_RX_URB, /* firmware bug */
 	},
 	{ USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
 	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
 	},
 	{ USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
 	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
 	},
 	{ USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
 	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
 	},
 	/* control interfaces with various AT-command sets */
 	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
 		USB_CDC_ACM_PROTO_AT_V25TER) },
 	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
 		USB_CDC_ACM_PROTO_AT_PCCA101) },
 	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
 		USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
 	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
 		USB_CDC_ACM_PROTO_AT_GSM) },
 	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
 		USB_CDC_ACM_PROTO_AT_3G	) },
 	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
 		USB_CDC_ACM_PROTO_AT_CDMA) },
 	/* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
 	{ }
 };
 MODULE_DEVICE_TABLE (usb, acm_ids);
 static struct usb_driver acm_driver = {
 	.name =		"cdc_acm",
 	.probe =	acm_probe,
 	.disconnect =	acm_disconnect,
 #ifdef CONFIG_PM
 	.suspend =	acm_suspend,
 	.resume =	acm_resume,
 #endif
 	.id_table =	acm_ids,
 #ifdef CONFIG_PM
 	.supports_autosuspend = 1,
 #endif
 };
 /*
  * TTY driver structures.
  */
 static const struct tty_operations acm_ops = {
 	.open =			acm_tty_open,
 	.close =		acm_tty_close,
 	.write =		acm_tty_write,
 	.write_room =		acm_tty_write_room,
 	.ioctl =		acm_tty_ioctl,
 	.throttle =		acm_tty_throttle,
 	.unthrottle =		acm_tty_unthrottle,
 	.chars_in_buffer =	acm_tty_chars_in_buffer,
 	.break_ctl =		acm_tty_break_ctl,
 	.set_termios =		acm_tty_set_termios,
 	.tiocmget =		acm_tty_tiocmget,
 	.tiocmset =		acm_tty_tiocmset,
 };
 /*
  * Init / exit.
  */
 static int __init acm_init(void)
 {
 	int retval;
 	acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
 	if (!acm_tty_driver)
 		return -ENOMEM;
 	acm_tty_driver->owner = THIS_MODULE,
 	acm_tty_driver->driver_name = "acm",
 	acm_tty_driver->name = "ttyACM",
 	acm_tty_driver->major = ACM_TTY_MAJOR,
 	acm_tty_driver->minor_start = 0,
 	acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
 	acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
 	acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
 	acm_tty_driver->init_termios = tty_std_termios;
 	acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
 	tty_set_operations(acm_tty_driver, &acm_ops);
 	retval = tty_register_driver(acm_tty_driver);
 	if (retval) {
 		put_tty_driver(acm_tty_driver);
 		return retval;
 	}
 	retval = usb_register(&acm_driver);
 	if (retval) {
 		tty_unregister_driver(acm_tty_driver);
 		put_tty_driver(acm_tty_driver);
 		return retval;
 	}
 	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 	       DRIVER_DESC "\n");
 	return 0;
 }
 static void __exit acm_exit(void)
 {
 	usb_deregister(&acm_driver);
 	tty_unregister_driver(acm_tty_driver);
 	put_tty_driver(acm_tty_driver);
 }
 module_init(acm_init);
 module_exit(acm_exit);
 MODULE_AUTHOR( DRIVER_AUTHOR );
 MODULE_DESCRIPTION( DRIVER_DESC );
 MODULE_LICENSE("GPL");

drivers/usb/class/cdc-wdm.c

Diff comments View file @ 9908a32

 /*
  * cdc-wdm.c
  *
  * This driver supports USB CDC WCM Device Management.
  *
  * Copyright (c) 2007-2008 Oliver Neukum
  *
  * Some code taken from cdc-acm.c
  *
  * Released under the GPLv2.
  *
  * Many thanks to Carl Nordbeck
  */
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/smp_lock.h>
 #include <linux/mutex.h>
 #include <linux/uaccess.h>
 #include <linux/bitops.h>
 #include <linux/poll.h>
 #include <linux/usb.h>
 #include <linux/usb/cdc.h>
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
 /*
  * Version Information
  */
 #define DRIVER_VERSION "v0.03"
 #define DRIVER_AUTHOR "Oliver Neukum"
 #define DRIVER_DESC "USB Abstract Control Model driver for USB WCM Device Management"
 static struct usb_device_id wdm_ids[] = {
 	{
 		.match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
 				 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 		.bInterfaceClass = USB_CLASS_COMM,
 		.bInterfaceSubClass = USB_CDC_SUBCLASS_DMM
 	},
 	{ }
 };
 #define WDM_MINOR_BASE	176
 #define WDM_IN_USE		1
 #define WDM_DISCONNECTING	2
 #define WDM_RESULT		3
 #define WDM_READ		4
 #define WDM_INT_STALL		5
 #define WDM_POLL_RUNNING	6
 #define WDM_MAX			16
 static DEFINE_MUTEX(wdm_mutex);
 /* --- method tables --- */
 struct wdm_device {
 	u8			*inbuf; /* buffer for response */
 	u8			*outbuf; /* buffer for command */
 	u8			*sbuf; /* buffer for status */
 	u8			*ubuf; /* buffer for copy to user space */
 	struct urb		*command;
 	struct urb		*response;
 	struct urb		*validity;
 	struct usb_interface	*intf;
 	struct usb_ctrlrequest	*orq;
 	struct usb_ctrlrequest	*irq;
 	spinlock_t		iuspin;
 	unsigned long		flags;
 	u16			bufsize;
 	u16			wMaxCommand;
 	u16			wMaxPacketSize;
 	u16			bMaxPacketSize0;
 	__le16			inum;
 	int			reslength;
 	int			length;
 	int			read;
 	int			count;
 	dma_addr_t		shandle;
 	dma_addr_t		ihandle;
 	struct mutex		wlock;
 	struct mutex		rlock;
 	struct mutex		plock;
 	wait_queue_head_t	wait;
 	struct work_struct	rxwork;
 	int			werr;
 	int			rerr;
 };
 static struct usb_driver wdm_driver;
 /* --- callbacks --- */
 static void wdm_out_callback(struct urb *urb)
 {
 	struct wdm_device *desc;
 	desc = urb->context;
 	spin_lock(&desc->iuspin);
 	desc->werr = urb->status;
 	spin_unlock(&desc->iuspin);
 	clear_bit(WDM_IN_USE, &desc->flags);
 	kfree(desc->outbuf);
 	wake_up(&desc->wait);
 }
 static void wdm_in_callback(struct urb *urb)
 {
 	struct wdm_device *desc = urb->context;
 	int status = urb->status;
 	spin_lock(&desc->iuspin);
 	if (status) {
 		switch (status) {
 		case -ENOENT:
 			dev_dbg(&desc->intf->dev,
 				"nonzero urb status received: -ENOENT");
 			break;
 		case -ECONNRESET:
 			dev_dbg(&desc->intf->dev,
 				"nonzero urb status received: -ECONNRESET");
 			break;
 		case -ESHUTDOWN:
 			dev_dbg(&desc->intf->dev,
 				"nonzero urb status received: -ESHUTDOWN");
 			break;
 		case -EPIPE:
-			err("nonzero urb status received: -EPIPE");
+			dev_err(&desc->intf->dev,
+				"nonzero urb status received: -EPIPE\n");
 			break;
 		default:
-			err("Unexpected error %d", status);
+			dev_err(&desc->intf->dev,
+				"Unexpected error %d\n", status);
 			break;
 		}
 	}
 	desc->rerr = status;
 	desc->reslength = urb->actual_length;
 	memmove(desc->ubuf + desc->length, desc->inbuf, desc->reslength);
 	desc->length += desc->reslength;
 	wake_up(&desc->wait);
 	set_bit(WDM_READ, &desc->flags);
 	spin_unlock(&desc->iuspin);
 }
 static void wdm_int_callback(struct urb *urb)
 {
 	int rv = 0;
 	int status = urb->status;
 	struct wdm_device *desc;
 	struct usb_ctrlrequest *req;
 	struct usb_cdc_notification *dr;
 	desc = urb->context;
 	req = desc->irq;
 	dr = (struct usb_cdc_notification *)desc->sbuf;
 	if (status) {
 		switch (status) {
 		case -ESHUTDOWN:
 		case -ENOENT:
 		case -ECONNRESET:
 			return; /* unplug */
 		case -EPIPE:
 			set_bit(WDM_INT_STALL, &desc->flags);
-			err("Stall on int endpoint");
+			dev_err(&desc->intf->dev, "Stall on int endpoint\n");
 			goto sw; /* halt is cleared in work */
 		default:
-			err("nonzero urb status received: %d", status);
+			dev_err(&desc->intf->dev,
+				"nonzero urb status received: %d\n", status);
 			break;
 		}
 	}
 	if (urb->actual_length < sizeof(struct usb_cdc_notification)) {
-		err("wdm_int_callback - %d bytes", urb->actual_length);
+		dev_err(&desc->intf->dev, "wdm_int_callback - %d bytes\n",
+			urb->actual_length);
 		goto exit;
 	}
 	switch (dr->bNotificationType) {
 	case USB_CDC_NOTIFY_RESPONSE_AVAILABLE:
 		dev_dbg(&desc->intf->dev,
 			"NOTIFY_RESPONSE_AVAILABLE received: index %d len %d",
 			dr->wIndex, dr->wLength);
 		break;
 	case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 		dev_dbg(&desc->intf->dev,
 			"NOTIFY_NETWORK_CONNECTION %s network",
 			dr->wValue ? "connected to" : "disconnected from");
 		goto exit;
 	default:
 		clear_bit(WDM_POLL_RUNNING, &desc->flags);
-		err("unknown notification %d received: index %d len %d",
+		dev_err(&desc->intf->dev,
+			"unknown notification %d received: index %d len %d\n",
 			dr->bNotificationType, dr->wIndex, dr->wLength);
 		goto exit;
 	}
 	req->bRequestType = (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
 	req->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
 	req->wValue = 0;
 	req->wIndex = desc->inum;
 	req->wLength = cpu_to_le16(desc->wMaxCommand);
 	usb_fill_control_urb(
 		desc->response,
 		interface_to_usbdev(desc->intf),
 		/* using common endpoint 0 */
 		usb_rcvctrlpipe(interface_to_usbdev(desc->intf), 0),
 		(unsigned char *)req,
 		desc->inbuf,
 		desc->wMaxCommand,
 		wdm_in_callback,
 		desc
 	);
 	desc->response->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 	spin_lock(&desc->iuspin);
 	clear_bit(WDM_READ, &desc->flags);
 	if (!test_bit(WDM_DISCONNECTING, &desc->flags)) {
 		rv = usb_submit_urb(desc->response, GFP_ATOMIC);
 		dev_dbg(&desc->intf->dev, "%s: usb_submit_urb %d",
 			__func__, rv);
 	}
 	spin_unlock(&desc->iuspin);
 	if (rv < 0) {
 		if (rv == -EPERM)
 			return;
 		if (rv == -ENOMEM) {
 sw:
 			rv = schedule_work(&desc->rxwork);
 			if (rv)
-				err("Cannot schedule work");
+				dev_err(&desc->intf->dev,
+					"Cannot schedule work\n");
 		}
 	}
 exit:
 	rv = usb_submit_urb(urb, GFP_ATOMIC);
 	if (rv)
-		err("%s - usb_submit_urb failed with result %d",
+		dev_err(&desc->intf->dev,
-		     __func__, rv);
+			"%s - usb_submit_urb failed with result %d\n",
+			__func__, rv);
 }
 static void kill_urbs(struct wdm_device *desc)
 {
 	/* the order here is essential */
 	usb_kill_urb(desc->command);
 	usb_kill_urb(desc->validity);
 	usb_kill_urb(desc->response);
 }
 static void free_urbs(struct wdm_device *desc)
 {
 	usb_free_urb(desc->validity);
 	usb_free_urb(desc->response);
 	usb_free_urb(desc->command);
 }
 static void cleanup(struct wdm_device *desc)
 {
 	usb_buffer_free(interface_to_usbdev(desc->intf),
 			desc->wMaxPacketSize,
 			desc->sbuf,
 			desc->validity->transfer_dma);
 	usb_buffer_free(interface_to_usbdev(desc->intf),
 			desc->wMaxCommand,
 			desc->inbuf,
 			desc->response->transfer_dma);
 	kfree(desc->orq);
 	kfree(desc->irq);
 	kfree(desc->ubuf);
 	free_urbs(desc);
 	kfree(desc);
 }
 static ssize_t wdm_write
 (struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
 	u8 *buf;
 	int rv = -EMSGSIZE, r, we;
 	struct wdm_device *desc = file->private_data;
 	struct usb_ctrlrequest *req;
 	if (count > desc->wMaxCommand)
 		count = desc->wMaxCommand;
 	spin_lock_irq(&desc->iuspin);
 	we = desc->werr;
 	desc->werr = 0;
 	spin_unlock_irq(&desc->iuspin);
 	if (we < 0)
 		return -EIO;
 	r = mutex_lock_interruptible(&desc->wlock); /* concurrent writes */
 	rv = -ERESTARTSYS;
 	if (r)
 		goto outnl;
 	r = usb_autopm_get_interface(desc->intf);
 	if (r < 0)
 		goto outnp;
 	r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
 							   &desc->flags));
 	if (r < 0)
 		goto out;
 	if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
 		rv = -ENODEV;
 		goto out;
 	}
 	desc->outbuf = buf = kmalloc(count, GFP_KERNEL);
 	if (!buf) {
 		rv = -ENOMEM;
 		goto out;
 	}
 	r = copy_from_user(buf, buffer, count);
 	if (r > 0) {
 		kfree(buf);
 		rv = -EFAULT;
 		goto out;
 	}
 	req = desc->orq;
 	usb_fill_control_urb(
 		desc->command,
 		interface_to_usbdev(desc->intf),
 		/* using common endpoint 0 */
 		usb_sndctrlpipe(interface_to_usbdev(desc->intf), 0),
 		(unsigned char *)req,
 		buf,
 		count,
 		wdm_out_callback,
 		desc
 	);
 	req->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |
 			     USB_RECIP_INTERFACE);
 	req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
 	req->wValue = 0;
 	req->wIndex = desc->inum;
 	req->wLength = cpu_to_le16(count);
 	set_bit(WDM_IN_USE, &desc->flags);
 	rv = usb_submit_urb(desc->command, GFP_KERNEL);
 	if (rv < 0) {
 		kfree(buf);
 		clear_bit(WDM_IN_USE, &desc->flags);
-		err("Tx URB error: %d", rv);
+		dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv);
 	} else {
 		dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d",
 			req->wIndex);
 	}
 out:
 	usb_autopm_put_interface(desc->intf);
 outnp:
 	mutex_unlock(&desc->wlock);
 outnl:
 	return rv < 0 ? rv : count;
 }
 static ssize_t wdm_read
 (struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 {
 	int rv, cntr;
 	int i = 0;
 	struct wdm_device *desc = file->private_data;
 	rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */
 	if (rv < 0)
 		return -ERESTARTSYS;
 	if (desc->length == 0) {
 		desc->read = 0;
 retry:
 		i++;
 		rv = wait_event_interruptible(desc->wait,
 					      test_bit(WDM_READ, &desc->flags));
 		if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
 			rv = -ENODEV;
 			goto err;
 		}
 		usb_mark_last_busy(interface_to_usbdev(desc->intf));
 		if (rv < 0) {
 			rv = -ERESTARTSYS;
 			goto err;
 		}
 		spin_lock_irq(&desc->iuspin);
 		if (desc->rerr) { /* read completed, error happened */
 			int t = desc->rerr;
 			desc->rerr = 0;
 			spin_unlock_irq(&desc->iuspin);
-			err("reading had resulted in %d", t);
+			dev_err(&desc->intf->dev,
+				"reading had resulted in %d\n", t);
 			rv = -EIO;
 			goto err;
 		}
 		/*
 		 * recheck whether we've lost the race
 		 * against the completion handler
 		 */
 		if (!test_bit(WDM_READ, &desc->flags)) { /* lost race */
 			spin_unlock_irq(&desc->iuspin);
 			goto retry;
 		}
 		if (!desc->reslength) { /* zero length read */
 			spin_unlock_irq(&desc->iuspin);
 			goto retry;
 		}
 		clear_bit(WDM_READ, &desc->flags);
 		spin_unlock_irq(&desc->iuspin);
 	}
 	cntr = count > desc->length ? desc->length : count;
 	rv = copy_to_user(buffer, desc->ubuf, cntr);
 	if (rv > 0) {
 		rv = -EFAULT;
 		goto err;
 	}
 	for (i = 0; i < desc->length - cntr; i++)
 		desc->ubuf[i] = desc->ubuf[i + cntr];
 	desc->length -= cntr;
 	/* in case we had outstanding data */
 	if (!desc->length)
 		clear_bit(WDM_READ, &desc->flags);
 	rv = cntr;
 err:
 	mutex_unlock(&desc->rlock);
 	if (rv < 0)
-		err("wdm_read: exit error");
+		dev_err(&desc->intf->dev, "wdm_read: exit error\n");
 	return rv;
 }
 static int wdm_flush(struct file *file, fl_owner_t id)
 {
 	struct wdm_device *desc = file->private_data;
 	wait_event(desc->wait, !test_bit(WDM_IN_USE, &desc->flags));
 	if (desc->werr < 0)
-		err("Error in flush path: %d", desc->werr);
+		dev_err(&desc->intf->dev, "Error in flush path: %d\n",
+			desc->werr);
 	return desc->werr;
 }
 static unsigned int wdm_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct wdm_device *desc = file->private_data;
 	unsigned long flags;
 	unsigned int mask = 0;
 	spin_lock_irqsave(&desc->iuspin, flags);
 	if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
 		mask = POLLERR;
 		spin_unlock_irqrestore(&desc->iuspin, flags);
 		goto desc_out;
 	}
 	if (test_bit(WDM_READ, &desc->flags))
 		mask = POLLIN | POLLRDNORM;
 	if (desc->rerr || desc->werr)
 		mask |= POLLERR;
 	if (!test_bit(WDM_IN_USE, &desc->flags))
 		mask |= POLLOUT | POLLWRNORM;
 	spin_unlock_irqrestore(&desc->iuspin, flags);
 	poll_wait(file, &desc->wait, wait);
 desc_out:
 	return mask;
 }
 static int wdm_open(struct inode *inode, struct file *file)
 {
 	int minor = iminor(inode);
 	int rv = -ENODEV;
 	struct usb_interface *intf;
 	struct wdm_device *desc;
 	mutex_lock(&wdm_mutex);
 	intf = usb_find_interface(&wdm_driver, minor);
 	if (!intf)
 		goto out;
 	desc = usb_get_intfdata(intf);
 	if (test_bit(WDM_DISCONNECTING, &desc->flags))
 		goto out;
 	;
 	file->private_data = desc;
 	rv = usb_autopm_get_interface(desc->intf);
 	if (rv < 0) {
-		err("Error autopm - %d", rv);
+		dev_err(&desc->intf->dev, "Error autopm - %d\n", rv);
 		goto out;
 	}
 	intf->needs_remote_wakeup = 1;
 	mutex_lock(&desc->plock);
 	if (!desc->count++) {
 		rv = usb_submit_urb(desc->validity, GFP_KERNEL);
 		if (rv < 0) {
 			desc->count--;
-			err("Error submitting int urb - %d", rv);
+			dev_err(&desc->intf->dev,
+				"Error submitting int urb - %d\n", rv);
 		}
 	} else {
 		rv = 0;
 	}
 	mutex_unlock(&desc->plock);
 	usb_autopm_put_interface(desc->intf);
 out:
 	mutex_unlock(&wdm_mutex);
 	return rv;
 }
 static int wdm_release(struct inode *inode, struct file *file)
 {
 	struct wdm_device *desc = file->private_data;
 	mutex_lock(&wdm_mutex);
 	mutex_lock(&desc->plock);
 	desc->count--;
 	mutex_unlock(&desc->plock);
 	if (!desc->count) {
 		dev_dbg(&desc->intf->dev, "wdm_release: cleanup");
 		kill_urbs(desc);
 		if (!test_bit(WDM_DISCONNECTING, &desc->flags))
 			desc->intf->needs_remote_wakeup = 0;
 	}
 	mutex_unlock(&wdm_mutex);
 	return 0;
 }
 static const struct file_operations wdm_fops = {
 	.owner =	THIS_MODULE,
 	.read =		wdm_read,
 	.write =	wdm_write,
 	.open =		wdm_open,
 	.flush =	wdm_flush,
 	.release =	wdm_release,
 	.poll =		wdm_poll
 };
 static struct usb_class_driver wdm_class = {
 	.name =		"cdc-wdm%d",
 	.fops =		&wdm_fops,
 	.minor_base =	WDM_MINOR_BASE,
 };
 /* --- error handling --- */
 static void wdm_rxwork(struct work_struct *work)
 {
 	struct wdm_device *desc = container_of(work, struct wdm_device, rxwork);
 	unsigned long flags;
 	int rv;
 	spin_lock_irqsave(&desc->iuspin, flags);
 	if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
 		spin_unlock_irqrestore(&desc->iuspin, flags);
 	} else {
 		spin_unlock_irqrestore(&desc->iuspin, flags);
 		rv = usb_submit_urb(desc->response, GFP_KERNEL);
 		if (rv < 0 && rv != -EPERM) {
 			spin_lock_irqsave(&desc->iuspin, flags);
 			if (!test_bit(WDM_DISCONNECTING, &desc->flags))
 				schedule_work(&desc->rxwork);
 			spin_unlock_irqrestore(&desc->iuspin, flags);
 		}
 	}
 }
 /* --- hotplug --- */
 static int wdm_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
 	int rv = -EINVAL;
 	struct usb_device *udev = interface_to_usbdev(intf);
 	struct wdm_device *desc;
 	struct usb_host_interface *iface;
 	struct usb_endpoint_descriptor *ep;
 	struct usb_cdc_dmm_desc *dmhd;
 	u8 *buffer = intf->altsetting->extra;
 	int buflen = intf->altsetting->extralen;
 	u16 maxcom = 0;
 	if (!buffer)
 		goto out;
 	while (buflen > 0) {
 		if (buffer [1] != USB_DT_CS_INTERFACE) {
-			err("skipping garbage");
+			dev_err(&intf->dev, "skipping garbage\n");
 			goto next_desc;
 		}
 		switch (buffer [2]) {
 		case USB_CDC_HEADER_TYPE:
 			break;
 		case USB_CDC_DMM_TYPE:
 			dmhd = (struct usb_cdc_dmm_desc *)buffer;
 			maxcom = le16_to_cpu(dmhd->wMaxCommand);
 			dev_dbg(&intf->dev,
 				"Finding maximum buffer length: %d", maxcom);
 			break;
 		default:
-			err("Ignoring extra header, type %d, length %d",
+			dev_err(&intf->dev,
+				"Ignoring extra header, type %d, length %d\n",
 				buffer[2], buffer[0]);
 			break;
 		}
 next_desc:
 		buflen -= buffer[0];
 		buffer += buffer[0];
 	}
 	rv = -ENOMEM;
 	desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL);
 	if (!desc)
 		goto out;
 	mutex_init(&desc->wlock);
 	mutex_init(&desc->rlock);
 	mutex_init(&desc->plock);
 	spin_lock_init(&desc->iuspin);
 	init_waitqueue_head(&desc->wait);
 	desc->wMaxCommand = maxcom;
 	desc->inum = cpu_to_le16((u16)intf->cur_altsetting->desc.bInterfaceNumber);
 	desc->intf = intf;
 	INIT_WORK(&desc->rxwork, wdm_rxwork);
 	iface = &intf->altsetting[0];
 	ep = &iface->endpoint[0].desc;
 	if (!usb_endpoint_is_int_in(ep)) {
 		rv = -EINVAL;
 		goto err;
 	}
 	desc->wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);
 	desc->bMaxPacketSize0 = udev->descriptor.bMaxPacketSize0;
 	desc->orq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
 	if (!desc->orq)
 		goto err;
 	desc->irq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
 	if (!desc->irq)
 		goto err;
 	desc->validity = usb_alloc_urb(0, GFP_KERNEL);
 	if (!desc->validity)
 		goto err;
 	desc->response = usb_alloc_urb(0, GFP_KERNEL);
 	if (!desc->response)
 		goto err;
 	desc->command = usb_alloc_urb(0, GFP_KERNEL);
 	if (!desc->command)
 		goto err;
 	desc->ubuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
 	if (!desc->ubuf)
 		goto err;
 	desc->sbuf = usb_buffer_alloc(interface_to_usbdev(intf),
 					desc->wMaxPacketSize,
 					GFP_KERNEL,
 					&desc->validity->transfer_dma);
 	if (!desc->sbuf)
 		goto err;
 	desc->inbuf = usb_buffer_alloc(interface_to_usbdev(intf),
 					desc->bMaxPacketSize0,
 					GFP_KERNEL,
 					&desc->response->transfer_dma);
 	if (!desc->inbuf)
 		goto err2;
 	usb_fill_int_urb(
 		desc->validity,
 		interface_to_usbdev(intf),
 		usb_rcvintpipe(interface_to_usbdev(intf), ep->bEndpointAddress),
 		desc->sbuf,
 		desc->wMaxPacketSize,
 		wdm_int_callback,
 		desc,
 		ep->bInterval
 	);
 	desc->validity->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 	usb_set_intfdata(intf, desc);
 	rv = usb_register_dev(intf, &wdm_class);
 	dev_info(&intf->dev, "cdc-wdm%d: USB WDM device\n",
 		 intf->minor - WDM_MINOR_BASE);
 	if (rv < 0)
 		goto err;
 out:
 	return rv;
 err2:
 	usb_buffer_free(interface_to_usbdev(desc->intf),
 			desc->wMaxPacketSize,
 			desc->sbuf,
 			desc->validity->transfer_dma);
 err:
 	free_urbs(desc);
 	kfree(desc->ubuf);
 	kfree(desc->orq);
 	kfree(desc->irq);
 	kfree(desc);
 	return rv;
 }
 static void wdm_disconnect(struct usb_interface *intf)
 {
 	struct wdm_device *desc;
 	unsigned long flags;
 	usb_deregister_dev(intf, &wdm_class);
 	mutex_lock(&wdm_mutex);
 	desc = usb_get_intfdata(intf);
 	/* the spinlock makes sure no new urbs are generated in the callbacks */
 	spin_lock_irqsave(&desc->iuspin, flags);
 	set_bit(WDM_DISCONNECTING, &desc->flags);
 	set_bit(WDM_READ, &desc->flags);
 	/* to terminate pending flushes */
 	clear_bit(WDM_IN_USE, &desc->flags);
 	spin_unlock_irqrestore(&desc->iuspin, flags);
 	cancel_work_sync(&desc->rxwork);
 	kill_urbs(desc);
 	wake_up_all(&desc->wait);
 	if (!desc->count)
 		cleanup(desc);
 	mutex_unlock(&wdm_mutex);
 }
 static int wdm_suspend(struct usb_interface *intf, pm_message_t message)
 {
 	struct wdm_device *desc = usb_get_intfdata(intf);
 	int rv = 0;
 	dev_dbg(&desc->intf->dev, "wdm%d_suspend\n", intf->minor);
 	mutex_lock(&desc->plock);
 #ifdef CONFIG_PM
 	if (interface_to_usbdev(desc->intf)->auto_pm && test_bit(WDM_IN_USE, &desc->flags)) {
 		rv = -EBUSY;
 	} else {
 #endif
 		cancel_work_sync(&desc->rxwork);
 		kill_urbs(desc);
 #ifdef CONFIG_PM
 	}
 #endif
 	mutex_unlock(&desc->plock);
 	return rv;
 }
 static int recover_from_urb_loss(struct wdm_device *desc)
 {
 	int rv = 0;
 	if (desc->count) {
 		rv = usb_submit_urb(desc->validity, GFP_NOIO);
 		if (rv < 0)
-			err("Error resume submitting int urb - %d", rv);
+			dev_err(&desc->intf->dev,
+				"Error resume submitting int urb - %d\n", rv);
 	}
 	return rv;
 }
 static int wdm_resume(struct usb_interface *intf)
 {
 	struct wdm_device *desc = usb_get_intfdata(intf);
 	int rv;
 	dev_dbg(&desc->intf->dev, "wdm%d_resume\n", intf->minor);
 	mutex_lock(&desc->plock);
 	rv = recover_from_urb_loss(desc);
 	mutex_unlock(&desc->plock);
 	return rv;
 }
 static int wdm_pre_reset(struct usb_interface *intf)
 {
 	struct wdm_device *desc = usb_get_intfdata(intf);
 	mutex_lock(&desc->plock);
 	return 0;
 }
 static int wdm_post_reset(struct usb_interface *intf)
 {
 	struct wdm_device *desc = usb_get_intfdata(intf);
 	int rv;
 	rv = recover_from_urb_loss(desc);
 	mutex_unlock(&desc->plock);
 	return 0;
 }
 static struct usb_driver wdm_driver = {
 	.name =		"cdc_wdm",
 	.probe =	wdm_probe,
 	.disconnect =	wdm_disconnect,
 	.suspend =	wdm_suspend,
 	.resume =	wdm_resume,
 	.reset_resume =	wdm_resume,
 	.pre_reset =	wdm_pre_reset,
 	.post_reset =	wdm_post_reset,
 	.id_table =	wdm_ids,
 	.supports_autosuspend = 1,
 };
 /* --- low level module stuff --- */
 static int __init wdm_init(void)
 {
 	int rv;
 	rv = usb_register(&wdm_driver);
 	return rv;
 }
 static void __exit wdm_exit(void)
 {
 	usb_deregister(&wdm_driver);
 }
 module_init(wdm_init);
 module_exit(wdm_exit);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");

drivers/usb/class/usblp.c

Diff comments View file @ 9908a32

 /*
  * usblp.c
  *
  * Copyright (c) 1999 Michael Gee	<michael@linuxspecific.com>
  * Copyright (c) 1999 Pavel Machek	<pavel@suse.cz>
  * Copyright (c) 2000 Randy Dunlap	<rdunlap@xenotime.net>
  * Copyright (c) 2000 Vojtech Pavlik	<vojtech@suse.cz>
  # Copyright (c) 2001 Pete Zaitcev	<zaitcev@redhat.com>
  # Copyright (c) 2001 David Paschal	<paschal@rcsis.com>
  * Copyright (c) 2006 Oliver Neukum	<oliver@neukum.name>
  *
  * USB Printer Device Class driver for USB printers and printer cables
  *
  * Sponsored by SuSE
  *
  * ChangeLog:
  *	v0.1 - thorough cleaning, URBification, almost a rewrite
  *	v0.2 - some more cleanups
  *	v0.3 - cleaner again, waitqueue fixes
  *	v0.4 - fixes in unidirectional mode
  *	v0.5 - add DEVICE_ID string support
  *	v0.6 - never time out
  *	v0.7 - fixed bulk-IN read and poll (David Paschal)
  *	v0.8 - add devfs support
  *	v0.9 - fix unplug-while-open paths
  *	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 (<status> not on stack);
  *		use usb_buffer_alloc() for read buf & write buf;
  *      none  - Maintained in Linux kernel after v0.13
  */
 /*
  * 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 <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/signal.h>
 #include <linux/poll.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/lp.h>
 #include <linux/mutex.h>
 #undef DEBUG
 #include <linux/usb.h>
 /*
  * Version Information
  */
 #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 USBLP_BUF_SIZE_IN	1024
 #define USBLP_DEVICE_ID_SIZE	1024
 /* ioctls: */
 #define IOCNR_GET_DEVICE_ID		1
 #define IOCNR_GET_PROTOCOLS		2
 #define IOCNR_SET_PROTOCOL		3
 #define IOCNR_HP_SET_CHANNEL		4
 #define IOCNR_GET_BUS_ADDRESS		5
 #define IOCNR_GET_VID_PID		6
 #define IOCNR_SOFT_RESET		7
 /* Get device_id string: */
 #define LPIOC_GET_DEVICE_ID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_DEVICE_ID, len)
 /* The following ioctls were added for http://hpoj.sourceforge.net: */
 /* Get two-int array:
  * [0]=current protocol (1=7/1/1, 2=7/1/2, 3=7/1/3),
  * [1]=supported protocol mask (mask&(1<<n)!=0 means 7/1/n supported): */
 #define LPIOC_GET_PROTOCOLS(len) _IOC(_IOC_READ, 'P', IOCNR_GET_PROTOCOLS, len)
 /* Set protocol (arg: 1=7/1/1, 2=7/1/2, 3=7/1/3): */
 #define LPIOC_SET_PROTOCOL _IOC(_IOC_WRITE, 'P', IOCNR_SET_PROTOCOL, 0)
 /* Set channel number (HP Vendor-specific command): */
 #define LPIOC_HP_SET_CHANNEL _IOC(_IOC_WRITE, 'P', IOCNR_HP_SET_CHANNEL, 0)
 /* Get two-int array: [0]=bus number, [1]=device address: */
 #define LPIOC_GET_BUS_ADDRESS(len) _IOC(_IOC_READ, 'P', IOCNR_GET_BUS_ADDRESS, len)
 /* Get two-int array: [0]=vendor ID, [1]=product ID: */
 #define LPIOC_GET_VID_PID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_VID_PID, len)
 /* Perform class specific soft reset */
 #define LPIOC_SOFT_RESET _IOC(_IOC_NONE, 'P', IOCNR_SOFT_RESET, 0);
 /*
  * A DEVICE_ID string may include the printer's serial number.
  * It should end with a semi-colon (';').
  * An example from an HP 970C DeskJet printer is (this is one long string,
  * with the serial number changed):
 MFG:HEWLETT-PACKARD;MDL:DESKJET 970C;CMD:MLC,PCL,PML;CLASS:PRINTER;DESCRIPTION:Hewlett-Packard DeskJet 970C;SERN:US970CSEPROF;VSTATUS:$HB0$NC0,ff,DN,IDLE,CUT,K1,C0,DP,NR,KP000,CP027;VP:0800,FL,B0;VJ:                    ;
  */
 /*
  * USB Printer Requests
  */
 #define USBLP_REQ_GET_ID			0x00
 #define USBLP_REQ_GET_STATUS			0x01
 #define USBLP_REQ_RESET				0x02
 #define USBLP_REQ_HP_CHANNEL_CHANGE_REQUEST	0x00	/* HP Vendor-specific */
 #define USBLP_MINORS		16
 #define USBLP_MINOR_BASE	0
 #define USBLP_CTL_TIMEOUT	5000			/* 5 seconds */
 #define USBLP_FIRST_PROTOCOL	1
 #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
 /*
  * Locks down the locking order:
  * ->wmut locks wstatus.
  * ->mut locks the whole usblp, except [rw]complete, and thus, by indirection,
  * [rw]status. We only touch status when we know the side idle.
  * ->lock locks what interrupt accesses.
  */
 struct usblp {
 	struct usb_device 	*dev;			/* USB device */
 	struct mutex		wmut;
 	struct mutex		mut;
 	spinlock_t		lock;		/* locks rcomplete, wcomplete */
 	char			*readbuf;		/* read transfer_buffer */
 	char			*statusbuf;		/* status transfer_buffer */
 	struct usb_anchor	urbs;
 	wait_queue_head_t	rwait, wwait;
 	int			readcount;		/* Counter for reads */
 	int			ifnum;			/* Interface number */
 	struct usb_interface	*intf;			/* The interface */
 	/* Alternate-setting numbers and endpoints for each protocol
 	 * (7/1/{index=1,2,3}) that the device supports: */
 	struct {
 		int				alt_setting;
 		struct usb_endpoint_descriptor	*epwrite;
 		struct usb_endpoint_descriptor	*epread;
 	}			protocol[USBLP_MAX_PROTOCOLS];
 	int			current_protocol;
 	int			minor;			/* minor number of device */
 	int			wcomplete, rcomplete;
 	int			wstatus;	/* bytes written or error */
 	int			rstatus;	/* bytes ready or error */
 	unsigned int		quirks;			/* quirks flags */
 	unsigned int		flags;			/* mode flags */
 	unsigned char		used;			/* True if open */
 	unsigned char		present;		/* True if not disconnected */
 	unsigned char		bidir;			/* interface is bidirectional */
 	unsigned char		sleeping;		/* interface is suspended */
 	unsigned char		no_paper;		/* Paper Out happened */
 	unsigned char		*device_id_string;	/* IEEE 1284 DEVICE ID string (ptr) */
 							/* first 2 bytes are (big-endian) length */
 };
 #ifdef DEBUG
 static void usblp_dump(struct usblp *usblp) {
 	int p;
 	dbg("usblp=0x%p", usblp);
 	dbg("dev=0x%p", usblp->dev);
 	dbg("present=%d", usblp->present);
 	dbg("readbuf=0x%p", usblp->readbuf);
 	dbg("readcount=%d", usblp->readcount);
 	dbg("ifnum=%d", usblp->ifnum);
     for (p = USBLP_FIRST_PROTOCOL; p <= USBLP_LAST_PROTOCOL; p++) {
 	dbg("protocol[%d].alt_setting=%d", p, usblp->protocol[p].alt_setting);
 	dbg("protocol[%d].epwrite=%p", p, usblp->protocol[p].epwrite);
 	dbg("protocol[%d].epread=%p", p, usblp->protocol[p].epread);
     }
 	dbg("current_protocol=%d", usblp->current_protocol);
 	dbg("minor=%d", usblp->minor);
 	dbg("wstatus=%d", usblp->wstatus);
 	dbg("rstatus=%d", usblp->rstatus);
 	dbg("quirks=%d", usblp->quirks);
 	dbg("used=%d", usblp->used);
 	dbg("bidir=%d", usblp->bidir);
 	dbg("sleeping=%d", usblp->sleeping);
 	dbg("device_id_string=\"%s\"",
 		usblp->device_id_string ?
 			usblp->device_id_string + 2 :
 			(unsigned char *)"(null)");
 }
 #endif
 /* Quirks: various printer quirks are handled by this table & its flags. */
 struct quirk_printer_struct {
 	__u16 vendorId;
 	__u16 productId;
 	unsigned int quirks;
 };
 #define USBLP_QUIRK_BIDIR	0x1	/* reports bidir but requires unidirectional mode (no INs/reads) */
 #define USBLP_QUIRK_USB_INIT	0x2	/* needs vendor USB init string */
 #define USBLP_QUIRK_BAD_CLASS	0x4	/* descriptor uses vendor-specific Class or SubClass */
 static const struct quirk_printer_struct quirk_printers[] = {
 	{ 0x03f0, 0x0004, USBLP_QUIRK_BIDIR }, /* HP DeskJet 895C */
 	{ 0x03f0, 0x0104, USBLP_QUIRK_BIDIR }, /* HP DeskJet 880C */
 	{ 0x03f0, 0x0204, USBLP_QUIRK_BIDIR }, /* HP DeskJet 815C */
 	{ 0x03f0, 0x0304, USBLP_QUIRK_BIDIR }, /* HP DeskJet 810C/812C */
 	{ 0x03f0, 0x0404, USBLP_QUIRK_BIDIR }, /* HP DeskJet 830C */
 	{ 0x03f0, 0x0504, USBLP_QUIRK_BIDIR }, /* HP DeskJet 885C */
 	{ 0x03f0, 0x0604, USBLP_QUIRK_BIDIR }, /* HP DeskJet 840C */
 	{ 0x03f0, 0x0804, USBLP_QUIRK_BIDIR }, /* HP DeskJet 816C */
 	{ 0x03f0, 0x1104, USBLP_QUIRK_BIDIR }, /* HP Deskjet 959C */
 	{ 0x0409, 0xefbe, USBLP_QUIRK_BIDIR }, /* NEC Picty900 (HP OEM) */
 	{ 0x0409, 0xbef4, USBLP_QUIRK_BIDIR }, /* NEC Picty760 (HP OEM) */
 	{ 0x0409, 0xf0be, USBLP_QUIRK_BIDIR }, /* NEC Picty920 (HP OEM) */
 	{ 0x0409, 0xf1be, USBLP_QUIRK_BIDIR }, /* NEC Picty800 (HP OEM) */
 	{ 0x0482, 0x0010, USBLP_QUIRK_BIDIR }, /* Kyocera Mita FS 820, by zut <kernel@zut.de> */
 	{ 0x04b8, 0x0202, USBLP_QUIRK_BAD_CLASS }, /* Seiko Epson Receipt Printer M129C */
 	{ 0, 0 }
 };
 static int usblp_wwait(struct usblp *usblp, int nonblock);
 static int usblp_wtest(struct usblp *usblp, int nonblock);
 static int usblp_rwait_and_lock(struct usblp *usblp, int nonblock);
 static int usblp_rtest(struct usblp *usblp, int nonblock);
 static int usblp_submit_read(struct usblp *usblp);
 static int usblp_select_alts(struct usblp *usblp);
 static int usblp_set_protocol(struct usblp *usblp, int protocol);
 static int usblp_cache_device_id_string(struct usblp *usblp);
 /* forward reference to make our lives easier */
 static struct usb_driver usblp_driver;
 static DEFINE_MUTEX(usblp_mutex);	/* locks the existence of usblp's */
 /*
  * Functions for usblp control messages.
  */
 static int usblp_ctrl_msg(struct usblp *usblp, int request, int type, int dir, int recip, int value, void *buf, int len)
 {
 	int retval;
 	int index = usblp->ifnum;
 	/* High byte has the interface index.
 	   Low byte has the alternate setting.
 	 */
 	if ((request == USBLP_REQ_GET_ID) && (type == USB_TYPE_CLASS)) {
 	  index = (usblp->ifnum<<8)|usblp->protocol[usblp->current_protocol].alt_setting;
 	}
 	retval = usb_control_msg(usblp->dev,
 		dir ? usb_rcvctrlpipe(usblp->dev, 0) : usb_sndctrlpipe(usblp->dev, 0),
 		request, type | dir | recip, value, index, buf, len, USBLP_CTL_TIMEOUT);
 	dbg("usblp_control_msg: rq: 0x%02x dir: %d recip: %d value: %d idx: %d len: %#x result: %d",
 		request, !!dir, recip, value, index, len, retval);
 	return retval < 0 ? retval : 0;
 }
 #define usblp_read_status(usblp, status)\
 	usblp_ctrl_msg(usblp, USBLP_REQ_GET_STATUS, USB_TYPE_CLASS, USB_DIR_IN, USB_RECIP_INTERFACE, 0, status, 1)
 #define usblp_get_id(usblp, config, id, maxlen)\
 	usblp_ctrl_msg(usblp, USBLP_REQ_GET_ID, USB_TYPE_CLASS, USB_DIR_IN, USB_RECIP_INTERFACE, config, id, maxlen)
 #define usblp_reset(usblp)\
 	usblp_ctrl_msg(usblp, USBLP_REQ_RESET, USB_TYPE_CLASS, USB_DIR_OUT, USB_RECIP_OTHER, 0, NULL, 0)
 #define usblp_hp_channel_change_request(usblp, channel, buffer) \
 	usblp_ctrl_msg(usblp, USBLP_REQ_HP_CHANNEL_CHANGE_REQUEST, USB_TYPE_VENDOR, USB_DIR_IN, USB_RECIP_INTERFACE, channel, buffer, 1)
 /*
  * See the description for usblp_select_alts() below for the usage
  * explanation.  Look into your /proc/bus/usb/devices and dmesg in
  * case of any trouble.
  */
 static int proto_bias = -1;
 /*
  * URB callback.
  */
 static void usblp_bulk_read(struct urb *urb)
 {
 	struct usblp *usblp = urb->context;
 	int status = urb->status;
 	if (usblp->present && usblp->used) {
 		if (status)
 			printk(KERN_WARNING "usblp%d: "
 			    "nonzero read bulk status received: %d\n",
 			    usblp->minor, status);
 	}
 	spin_lock(&usblp->lock);
 	if (status < 0)
 		usblp->rstatus = status;
 	else
 		usblp->rstatus = urb->actual_length;
 	usblp->rcomplete = 1;
 	wake_up(&usblp->rwait);
 	spin_unlock(&usblp->lock);
 	usb_free_urb(urb);
 }
 static void usblp_bulk_write(struct urb *urb)
 {
 	struct usblp *usblp = urb->context;
 	int status = urb->status;
 	if (usblp->present && usblp->used) {
 		if (status)
 			printk(KERN_WARNING "usblp%d: "
 			    "nonzero write bulk status received: %d\n",
 			    usblp->minor, status);
 	}
 	spin_lock(&usblp->lock);
 	if (status < 0)
 		usblp->wstatus = status;
 	else
 		usblp->wstatus = urb->actual_length;
 	usblp->no_paper = 0;
 	usblp->wcomplete = 1;
 	wake_up(&usblp->wwait);
 	spin_unlock(&usblp->lock);
 	usb_free_urb(urb);
 }
 /*
  * Get and print printer errors.
  */
 static const 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;
 	mutex_lock(&usblp->mut);
 	if ((error = usblp_read_status(usblp, usblp->statusbuf)) < 0) {
 		mutex_unlock(&usblp->mut);
 		if (printk_ratelimit())
 			printk(KERN_ERR
 				"usblp%d: error %d reading printer status\n",
 				usblp->minor, error);
 		return 0;
 	}
 	status = *usblp->statusbuf;
 	mutex_unlock(&usblp->mut);
 	if (~status & LP_PERRORP)
 		newerr = 3;
 	if (status & LP_POUTPA)
 		newerr = 1;
 	if (~status & LP_PSELECD)
 		newerr = 2;
 	if (newerr != err) {
 		printk(KERN_INFO "usblp%d: %s\n",
 		   usblp->minor, usblp_messages[newerr]);
 	}
 	return newerr;
 }
 static int handle_bidir (struct usblp *usblp)
 {
 	if (usblp->bidir && usblp->used && !usblp->sleeping) {
 		if (usblp_submit_read(usblp) < 0)
 			return -EIO;
 	}
 	return 0;
 }
 /*
  * File op functions.
  */
 static int usblp_open(struct inode *inode, struct file *file)
 {
 	int minor = iminor(inode);
 	struct usblp *usblp;
 	struct usb_interface *intf;
 	int retval;
 	if (minor < 0)
 		return -ENODEV;
 	mutex_lock (&usblp_mutex);
 	retval = -ENODEV;
 	intf = usb_find_interface(&usblp_driver, minor);
 	if (!intf) {
 		goto out;
 	}
 	usblp = usb_get_intfdata (intf);
 	if (!usblp || !usblp->dev || !usblp->present)
 		goto out;
 	retval = -EBUSY;
 	if (usblp->used)
 		goto out;
 	/*
 	 * We do not implement LP_ABORTOPEN/LPABORTOPEN for two reasons:
 	 *  - We do not want persistent state which close(2) does not clear
 	 *  - It is not used anyway, according to CUPS people
 	 */
 	retval = usb_autopm_get_interface(intf);
 	if (retval < 0)
 		goto out;
 	usblp->used = 1;
 	file->private_data = usblp;
 	usblp->wcomplete = 1; /* we begin writeable */
 	usblp->wstatus = 0;
 	usblp->rcomplete = 0;
 	if (handle_bidir(usblp) < 0) {
 		usb_autopm_put_interface(intf);
 		usblp->used = 0;
 		file->private_data = NULL;
 		retval = -EIO;
 	}
 out:
 	mutex_unlock (&usblp_mutex);
 	return retval;
 }
 static void usblp_cleanup (struct usblp *usblp)
 {
 	printk(KERN_INFO "usblp%d: removed\n", usblp->minor);
 	kfree(usblp->readbuf);
 	kfree (usblp->device_id_string);
 	kfree (usblp->statusbuf);
 	kfree (usblp);
 }
 static void usblp_unlink_urbs(struct usblp *usblp)
 {
 	usb_kill_anchored_urbs(&usblp->urbs);
 }
 static int usblp_release(struct inode *inode, struct file *file)
 {
 	struct usblp *usblp = file->private_data;
 	usblp->flags &= ~LP_ABORT;
 	mutex_lock (&usblp_mutex);
 	usblp->used = 0;
 	if (usblp->present) {
 		usblp_unlink_urbs(usblp);
 		usb_autopm_put_interface(usblp->intf);
 	} else 		/* finish cleanup from disconnect */
 		usblp_cleanup (usblp);
 	mutex_unlock (&usblp_mutex);
 	return 0;
 }
 /* No kernel lock - fine */
 static unsigned int usblp_poll(struct file *file, struct poll_table_struct *wait)
 {
 	int ret;
 	unsigned long flags;
 	struct usblp *usblp = file->private_data;
 	/* Should we check file->f_mode & FMODE_WRITE before poll_wait()? */
 	poll_wait(file, &usblp->rwait, wait);
 	poll_wait(file, &usblp->wwait, wait);
 	spin_lock_irqsave(&usblp->lock, flags);
 	ret = ((usblp->bidir && usblp->rcomplete) ? POLLIN  | POLLRDNORM : 0) |
 	   ((usblp->no_paper || usblp->wcomplete) ? POLLOUT | POLLWRNORM : 0);
 	spin_unlock_irqrestore(&usblp->lock, flags);
 	return ret;
 }
 static long usblp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct usblp *usblp = file->private_data;
 	int length, err, i;
 	unsigned char newChannel;
 	int status;
 	int twoints[2];
 	int retval = 0;
 	mutex_lock (&usblp->mut);
 	if (!usblp->present) {
 		retval = -ENODEV;
 		goto done;
 	}
 	if (usblp->sleeping) {
 		retval = -ENODEV;
 		goto done;
 	}
 	dbg("usblp_ioctl: cmd=0x%x (%c nr=%d len=%d dir=%d)", cmd, _IOC_TYPE(cmd),
 		_IOC_NR(cmd), _IOC_SIZE(cmd), _IOC_DIR(cmd) );
 	if (_IOC_TYPE(cmd) == 'P')	/* new-style ioctl number */
 		switch (_IOC_NR(cmd)) {
 			case IOCNR_GET_DEVICE_ID: /* get the DEVICE_ID string */
 				if (_IOC_DIR(cmd) != _IOC_READ) {
 					retval = -EINVAL;
 					goto done;
 				}
 				length = usblp_cache_device_id_string(usblp);
 				if (length < 0) {
 					retval = length;
 					goto done;
 				}
 				if (length > _IOC_SIZE(cmd))
 					length = _IOC_SIZE(cmd); /* truncate */
 				if (copy_to_user((void __user *) arg,
 						usblp->device_id_string,
 						(unsigned long) length)) {
 					retval = -EFAULT;
 					goto done;
 				}
 				break;
 			case IOCNR_GET_PROTOCOLS:
 				if (_IOC_DIR(cmd) != _IOC_READ ||
 				    _IOC_SIZE(cmd) < sizeof(twoints)) {
 					retval = -EINVAL;
 					goto done;
 				}
 				twoints[0] = usblp->current_protocol;
 				twoints[1] = 0;
 				for (i = USBLP_FIRST_PROTOCOL;
 				     i <= USBLP_LAST_PROTOCOL; i++) {
 					if (usblp->protocol[i].alt_setting >= 0)
 						twoints[1] |= (1<<i);
 				}
 				if (copy_to_user((void __user *)arg,
 						(unsigned char *)twoints,
 						sizeof(twoints))) {
 					retval = -EFAULT;
 					goto done;
 				}
 				break;
 			case IOCNR_SET_PROTOCOL:
 				if (_IOC_DIR(cmd) != _IOC_WRITE) {
 					retval = -EINVAL;
 					goto done;
 				}
 #ifdef DEBUG
 				if (arg == -10) {
 					usblp_dump(usblp);
 					break;
 				}
 #endif
 				usblp_unlink_urbs(usblp);
 				retval = usblp_set_protocol(usblp, arg);
 				if (retval < 0) {
 					usblp_set_protocol(usblp,
 						usblp->current_protocol);
 				}
 				break;
 			case IOCNR_HP_SET_CHANNEL:
 				if (_IOC_DIR(cmd) != _IOC_WRITE ||
 				    le16_to_cpu(usblp->dev->descriptor.idVendor) != 0x03F0 ||
 				    usblp->quirks & USBLP_QUIRK_BIDIR) {
 					retval = -EINVAL;
 					goto done;
 				}
 				err = usblp_hp_channel_change_request(usblp,
 					arg, &newChannel);
 				if (err < 0) {
-					err("usblp%d: error = %d setting "
+					dev_err(&usblp->dev->dev,
-						"HP channel",
+						"usblp%d: error = %d setting "
+						"HP channel\n",
 						usblp->minor, err);
 					retval = -EIO;
 					goto done;
 				}
 				dbg("usblp%d requested/got HP channel %ld/%d",
 					usblp->minor, arg, newChannel);
 				break;
 			case IOCNR_GET_BUS_ADDRESS:
 				if (_IOC_DIR(cmd) != _IOC_READ ||
 				    _IOC_SIZE(cmd) < sizeof(twoints)) {
 					retval = -EINVAL;
 					goto done;
 				}
 				twoints[0] = usblp->dev->bus->busnum;
 				twoints[1] = usblp->dev->devnum;
 				if (copy_to_user((void __user *)arg,
 						(unsigned char *)twoints,
 						sizeof(twoints))) {
 					retval = -EFAULT;
 					goto done;
 				}
 				dbg("usblp%d is bus=%d, device=%d",
 					usblp->minor, twoints[0], twoints[1]);
 				break;
 			case IOCNR_GET_VID_PID:
 				if (_IOC_DIR(cmd) != _IOC_READ ||
 				    _IOC_SIZE(cmd) < sizeof(twoints)) {
 					retval = -EINVAL;
 					goto done;
 				}
 				twoints[0] = le16_to_cpu(usblp->dev->descriptor.idVendor);
 				twoints[1] = le16_to_cpu(usblp->dev->descriptor.idProduct);
 				if (copy_to_user((void __user *)arg,
 						(unsigned char *)twoints,
 						sizeof(twoints))) {
 					retval = -EFAULT;
 					goto done;
 				}
 				dbg("usblp%d is VID=0x%4.4X, PID=0x%4.4X",
 					usblp->minor, twoints[0], twoints[1]);
 				break;
 			case IOCNR_SOFT_RESET:
 				if (_IOC_DIR(cmd) != _IOC_NONE) {
 					retval = -EINVAL;
 					goto done;
 				}
 				retval = usblp_reset(usblp);
 				break;
 			default:
 				retval = -ENOTTY;
 		}
 	else	/* old-style ioctl value */
 		switch (cmd) {
 			case LPGETSTATUS:
 				if ((retval = usblp_read_status(usblp, usblp->statusbuf))) {
 					if (printk_ratelimit())
 						printk(KERN_ERR "usblp%d:"
 						    "failed reading printer status (%d)\n",
 						    usblp->minor, retval);
 					retval = -EIO;
 					goto done;
 				}
 				status = *usblp->statusbuf;
 				if (copy_to_user ((void __user *)arg, &status, sizeof(int)))
 					retval = -EFAULT;
 				break;
 			case LPABORT:
 				if (arg)
 					usblp->flags |= LP_ABORT;
 				else
 					usblp->flags &= ~LP_ABORT;
 				break;
 			default:
 				retval = -ENOTTY;
 		}
 done:
 	mutex_unlock (&usblp->mut);
 	return retval;
 }
 static struct urb *usblp_new_writeurb(struct usblp *usblp, int transfer_length)
 {
 	struct urb *urb;
 	char *writebuf;
 	if ((writebuf = kmalloc(transfer_length, GFP_KERNEL)) == NULL)
 		return NULL;
 	if ((urb = usb_alloc_urb(0, GFP_KERNEL)) == NULL) {
 		kfree(writebuf);
 		return NULL;
 	}
 	usb_fill_bulk_urb(urb, usblp->dev,
 		usb_sndbulkpipe(usblp->dev,
 		 usblp->protocol[usblp->current_protocol].epwrite->bEndpointAddress),
 		writebuf, transfer_length, usblp_bulk_write, usblp);
 	urb->transfer_flags |= URB_FREE_BUFFER;
 	return urb;
 }
 static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct usblp *usblp = file->private_data;
 	struct urb *writeurb;
 	int rv;
 	int transfer_length;
 	ssize_t writecount = 0;
 	if (mutex_lock_interruptible(&usblp->wmut)) {
 		rv = -EINTR;
 		goto raise_biglock;
 	}
 	if ((rv = usblp_wwait(usblp, !!(file->f_flags & O_NONBLOCK))) < 0)
 		goto raise_wait;
 	while (writecount < count) {
 		/*
 		 * Step 1: Submit next block.
 		 */
 		if ((transfer_length = count - writecount) > USBLP_BUF_SIZE)
 			transfer_length = USBLP_BUF_SIZE;
 		rv = -ENOMEM;
 		if ((writeurb = usblp_new_writeurb(usblp, transfer_length)) == NULL)
 			goto raise_urb;
 		usb_anchor_urb(writeurb, &usblp->urbs);
 		if (copy_from_user(writeurb->transfer_buffer,
 				   buffer + writecount, transfer_length)) {
 			rv = -EFAULT;
 			goto raise_badaddr;
 		}
 		spin_lock_irq(&usblp->lock);
 		usblp->wcomplete = 0;
 		spin_unlock_irq(&usblp->lock);
 		if ((rv = usb_submit_urb(writeurb, GFP_KERNEL)) < 0) {
 			usblp->wstatus = 0;
 			spin_lock_irq(&usblp->lock);
 			usblp->no_paper = 0;
 			usblp->wcomplete = 1;
 			wake_up(&usblp->wwait);
 			spin_unlock_irq(&usblp->lock);
 			if (rv != -ENOMEM)
 				rv = -EIO;
 			goto raise_submit;
 		}
 		/*
 		 * Step 2: Wait for transfer to end, collect results.
 		 */
 		rv = usblp_wwait(usblp, !!(file->f_flags&O_NONBLOCK));
 		if (rv < 0) {
 			if (rv == -EAGAIN) {
 				/* Presume that it's going to complete well. */
 				writecount += transfer_length;
 			}
 			if (rv == -ENOSPC) {
 				spin_lock_irq(&usblp->lock);
 				usblp->no_paper = 1;	/* Mark for poll(2) */
 				spin_unlock_irq(&usblp->lock);
 				writecount += transfer_length;
 			}
 			/* Leave URB dangling, to be cleaned on close. */
 			goto collect_error;
 		}
 		if (usblp->wstatus < 0) {
 			rv = -EIO;
 			goto collect_error;
 		}
 		/*
 		 * This is critical: it must be our URB, not other writer's.
 		 * The wmut exists mainly to cover us here.
 		 */
 		writecount += usblp->wstatus;
 	}
 	mutex_unlock(&usblp->wmut);
 	return writecount;
 raise_submit:
 raise_badaddr:
 	usb_unanchor_urb(writeurb);
 	usb_free_urb(writeurb);
 raise_urb:
 raise_wait:
 collect_error:		/* Out of raise sequence */
 	mutex_unlock(&usblp->wmut);
 raise_biglock:
 	return writecount ? writecount : rv;
 }
 /*
  * Notice that we fail to restart in a few cases: on EFAULT, on restart
  * error, etc. This is the historical behaviour. In all such cases we return
  * EIO, and applications loop in order to get the new read going.
  */
 static ssize_t usblp_read(struct file *file, char __user *buffer, size_t len, loff_t *ppos)
 {
 	struct usblp *usblp = file->private_data;
 	ssize_t count;
 	ssize_t avail;
 	int rv;
 	if (!usblp->bidir)
 		return -EINVAL;
 	rv = usblp_rwait_and_lock(usblp, !!(file->f_flags & O_NONBLOCK));
 	if (rv < 0)
 		return rv;
 	if ((avail = usblp->rstatus) < 0) {
 		printk(KERN_ERR "usblp%d: error %d reading from printer\n",
 		    usblp->minor, (int)avail);
 		usblp_submit_read(usblp);
 		count = -EIO;
 		goto done;
 	}
 	count = len < avail - usblp->readcount ? len : avail - usblp->readcount;
 	if (count != 0 &&
 	    copy_to_user(buffer, usblp->readbuf + usblp->readcount, count)) {
 		count = -EFAULT;
 		goto done;
 	}
 	if ((usblp->readcount += count) == avail) {
 		if (usblp_submit_read(usblp) < 0) {
 			/* We don't want to leak USB return codes into errno. */
 			if (count == 0)
 				count = -EIO;
 			goto done;
 		}
 	}
 done:
 	mutex_unlock (&usblp->mut);
 	return count;
 }
 /*
  * Wait for the write path to come idle.
  * This is called under the ->wmut, so the idle path stays idle.
  *
  * Our write path has a peculiar property: it does not buffer like a tty,
  * but waits for the write to succeed. This allows our ->release to bug out
  * without waiting for writes to drain. But it obviously does not work
  * when O_NONBLOCK is set. So, applications setting O_NONBLOCK must use
  * select(2) or poll(2) to wait for the buffer to drain before closing.
  * Alternatively, set blocking mode with fcntl and issue a zero-size write.
  */
 static int usblp_wwait(struct usblp *usblp, int nonblock)
 {
 	DECLARE_WAITQUEUE(waita, current);
 	int rc;
 	int err = 0;
 	add_wait_queue(&usblp->wwait, &waita);
 	for (;;) {
 		set_current_state(TASK_INTERRUPTIBLE);
 		if (mutex_lock_interruptible(&usblp->mut)) {
 			rc = -EINTR;
 			break;
 		}
 		rc = usblp_wtest(usblp, nonblock);
 		mutex_unlock(&usblp->mut);
 		if (rc <= 0)
 			break;
 		if (usblp->flags & LP_ABORT) {
 			if (schedule_timeout(msecs_to_jiffies(5000)) == 0) {
 				err = usblp_check_status(usblp, err);
 				if (err == 1) {	/* Paper out */
 					rc = -ENOSPC;
 					break;
 				}
 			}
 		} else {
 			schedule();
 		}
 	}
 	set_current_state(TASK_RUNNING);
 	remove_wait_queue(&usblp->wwait, &waita);
 	return rc;
 }
 static int usblp_wtest(struct usblp *usblp, int nonblock)
 {
 	unsigned long flags;
 	if (!usblp->present)
 		return -ENODEV;
 	if (signal_pending(current))
 		return -EINTR;
 	spin_lock_irqsave(&usblp->lock, flags);
 	if (usblp->wcomplete) {
 		spin_unlock_irqrestore(&usblp->lock, flags);
 		return 0;
 	}
 	spin_unlock_irqrestore(&usblp->lock, flags);
 	if (usblp->sleeping)
 		return -ENODEV;
 	if (nonblock)
 		return -EAGAIN;
 	return 1;
 }
 /*
  * Wait for read bytes to become available. This probably should have been
  * called usblp_r_lock_and_wait(), because we lock first. But it's a traditional
  * name for functions which lock and return.
  *
  * We do not use wait_event_interruptible because it makes locking iffy.
  */
 static int usblp_rwait_and_lock(struct usblp *usblp, int nonblock)
 {
 	DECLARE_WAITQUEUE(waita, current);
 	int rc;
 	add_wait_queue(&usblp->rwait, &waita);
 	for (;;) {
 		if (mutex_lock_interruptible(&usblp->mut)) {
 			rc = -EINTR;
 			break;
 		}
 		set_current_state(TASK_INTERRUPTIBLE);
 		if ((rc = usblp_rtest(usblp, nonblock)) < 0) {
 			mutex_unlock(&usblp->mut);
 			break;
 		}
 		if (rc == 0)	/* Keep it locked */
 			break;
 		mutex_unlock(&usblp->mut);
 		schedule();
 	}
 	set_current_state(TASK_RUNNING);
 	remove_wait_queue(&usblp->rwait, &waita);
 	return rc;
 }
 static int usblp_rtest(struct usblp *usblp, int nonblock)
 {
 	unsigned long flags;
 	if (!usblp->present)
 		return -ENODEV;
 	if (signal_pending(current))
 		return -EINTR;
 	spin_lock_irqsave(&usblp->lock, flags);
 	if (usblp->rcomplete) {
 		spin_unlock_irqrestore(&usblp->lock, flags);
 		return 0;
 	}
 	spin_unlock_irqrestore(&usblp->lock, flags);
 	if (usblp->sleeping)
 		return -ENODEV;
 	if (nonblock)
 		return -EAGAIN;
 	return 1;
 }
 /*
  * Please check ->bidir and other such things outside for now.
  */
 static int usblp_submit_read(struct usblp *usblp)
 {
 	struct urb *urb;
 	unsigned long flags;
 	int rc;
 	rc = -ENOMEM;
 	if ((urb = usb_alloc_urb(0, GFP_KERNEL)) == NULL)
 		goto raise_urb;
 	usb_fill_bulk_urb(urb, usblp->dev,
 		usb_rcvbulkpipe(usblp->dev,
 		  usblp->protocol[usblp->current_protocol].epread->bEndpointAddress),
 		usblp->readbuf, USBLP_BUF_SIZE_IN,
 		usblp_bulk_read, usblp);
 	usb_anchor_urb(urb, &usblp->urbs);
 	spin_lock_irqsave(&usblp->lock, flags);
 	usblp->readcount = 0; /* XXX Why here? */
 	usblp->rcomplete = 0;
 	spin_unlock_irqrestore(&usblp->lock, flags);
 	if ((rc = usb_submit_urb(urb, GFP_KERNEL)) < 0) {
 		dbg("error submitting urb (%d)", rc);
 		spin_lock_irqsave(&usblp->lock, flags);
 		usblp->rstatus = rc;
 		usblp->rcomplete = 1;
 		spin_unlock_irqrestore(&usblp->lock, flags);
 		goto raise_submit;
 	}
 	return 0;
 raise_submit:
 	usb_unanchor_urb(urb);
 	usb_free_urb(urb);
 raise_urb:
 	return rc;
 }
 /*
  * Checks for printers that have quirks, such as requiring unidirectional
  * communication but reporting bidirectional; currently some HP printers
  * have this flaw (HP 810, 880, 895, etc.), or needing an init string
  * sent at each open (like some Epsons).
  * Returns 1 if found, 0 if not found.
  *
  * HP recommended that we use the bidirectional interface but
  * don't attempt any bulk IN transfers from the IN endpoint.
  * Here's some more detail on the problem:
  * The problem is not that it isn't bidirectional though. The problem
  * is that if you request a device ID, or status information, while
  * the buffers are full, the return data will end up in the print data
  * buffer. For example if you make sure you never request the device ID
  * while you are sending print data, and you don't try to query the
  * printer status every couple of milliseconds, you will probably be OK.
  */
 static unsigned int usblp_quirks (__u16 vendor, __u16 product)
 {
 	int i;
 	for (i = 0; quirk_printers[i].vendorId; i++) {
 		if (vendor == quirk_printers[i].vendorId &&
 		    product == quirk_printers[i].productId)
 			return quirk_printers[i].quirks;
  	}
 	return 0;
 }
 static const struct file_operations usblp_fops = {
 	.owner =	THIS_MODULE,
 	.read =		usblp_read,
 	.write =	usblp_write,
 	.poll =		usblp_poll,
 	.unlocked_ioctl =	usblp_ioctl,
 	.compat_ioctl =		usblp_ioctl,
 	.open =		usblp_open,
 	.release =	usblp_release,
 };
 static struct usb_class_driver usblp_class = {
 	.name =		"lp%d",
 	.fops =		&usblp_fops,
 	.minor_base =	USBLP_MINOR_BASE,
 };
 static ssize_t usblp_show_ieee1284_id(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct usb_interface *intf = to_usb_interface(dev);
 	struct usblp *usblp = usb_get_intfdata (intf);
 	if (usblp->device_id_string[0] == 0 &&
 	    usblp->device_id_string[1] == 0)
 		return 0;
 	return sprintf(buf, "%s", usblp->device_id_string+2);
 }
 static DEVICE_ATTR(ieee1284_id, S_IRUGO, usblp_show_ieee1284_id, NULL);
 static int usblp_probe(struct usb_interface *intf,
 		       const struct usb_device_id *id)
 {
 	struct usb_device *dev = interface_to_usbdev (intf);
 	struct usblp *usblp;
 	int protocol;
 	int retval;
 	/* Malloc and start initializing usblp structure so we can use it
 	 * directly. */
 	usblp = kzalloc(sizeof(struct usblp), GFP_KERNEL);
 	if (!usblp) {
 		retval = -ENOMEM;
 		goto abort_ret;
 	}
 	usblp->dev = dev;
 	mutex_init(&usblp->wmut);
 	mutex_init (&usblp->mut);
 	spin_lock_init(&usblp->lock);
 	init_waitqueue_head(&usblp->rwait);
 	init_waitqueue_head(&usblp->wwait);
 	init_usb_anchor(&usblp->urbs);
 	usblp->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
 	usblp->intf = intf;
 	/* 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->device_id_string = kmalloc(USBLP_DEVICE_ID_SIZE, GFP_KERNEL))) {
 		retval = -ENOMEM;
 		goto abort;
 	}
 	/*
 	 * Allocate read buffer. We somewhat wastefully
 	 * malloc both regardless of bidirectionality, because the
 	 * alternate setting can be changed later via an ioctl.
 	 */
 	if (!(usblp->readbuf = kmalloc(USBLP_BUF_SIZE_IN, GFP_KERNEL))) {
 		retval = -ENOMEM;
 		goto abort;
 	}
 	/* Allocate buffer for printer status */
 	usblp->statusbuf = kmalloc(STATUS_BUF_SIZE, GFP_KERNEL);
 	if (!usblp->statusbuf) {
 		retval = -ENOMEM;
 		goto abort;
 	}
 	/* Lookup quirks for this printer. */
 	usblp->quirks = usblp_quirks(
 		le16_to_cpu(dev->descriptor.idVendor),
 		le16_to_cpu(dev->descriptor.idProduct));
 	/* Analyze and pick initial alternate settings and endpoints. */
 	protocol = usblp_select_alts(usblp);
 	if (protocol < 0) {
 		dbg("incompatible printer-class device 0x%4.4X/0x%4.4X",
 			le16_to_cpu(dev->descriptor.idVendor),
 			le16_to_cpu(dev->descriptor.idProduct));
 		retval = -ENODEV;
 		goto abort;
 	}
 	/* Setup the selected alternate setting and endpoints. */
 	if (usblp_set_protocol(usblp, protocol) < 0) {
 		retval = -ENODEV;	/* ->probe isn't ->ioctl */
 		goto abort;
 	}
 	/* Retrieve and store the device ID string. */
 	usblp_cache_device_id_string(usblp);
 	retval = device_create_file(&intf->dev, &dev_attr_ieee1284_id);
 	if (retval)
 		goto abort_intfdata;
 #ifdef DEBUG
 	usblp_check_status(usblp, 0);
 #endif
 	usb_set_intfdata (intf, usblp);
 	usblp->present = 1;
 	retval = usb_register_dev(intf, &usblp_class);
 	if (retval) {
 		printk(KERN_ERR "usblp: Not able to get a minor"
 		    " (base %u, slice default): %d\n",
 		    USBLP_MINOR_BASE, retval);
 		goto abort_intfdata;
 	}
 	usblp->minor = intf->minor;
 	printk(KERN_INFO "usblp%d: USB %sdirectional printer dev %d "
 		"if %d alt %d proto %d vid 0x%4.4X pid 0x%4.4X\n",
 		usblp->minor, usblp->bidir ? "Bi" : "Uni", dev->devnum,
 		usblp->ifnum,
 		usblp->protocol[usblp->current_protocol].alt_setting,
 		usblp->current_protocol,
 		le16_to_cpu(usblp->dev->descriptor.idVendor),
 		le16_to_cpu(usblp->dev->descriptor.idProduct));
 	return 0;
 abort_intfdata:
 	usb_set_intfdata (intf, NULL);
 	device_remove_file(&intf->dev, &dev_attr_ieee1284_id);
 abort:
 	kfree(usblp->readbuf);
 	kfree(usblp->statusbuf);
 	kfree(usblp->device_id_string);
 	kfree(usblp);
 abort_ret:
 	return retval;
 }
 /*
  * We are a "new" style driver with usb_device_id table,
  * but our requirements are too intricate for simple match to handle.
  *
  * The "proto_bias" option may be used to specify the preferred protocol
  * for all USB printers (1=7/1/1, 2=7/1/2, 3=7/1/3).  If the device
  * supports the preferred protocol, then we bind to it.
  *
  * The best interface for us is 7/1/2, because it is compatible
  * with a stream of characters. If we find it, we bind to it.
  *
  * Note that the people from hpoj.sourceforge.net need to be able to
  * bind to 7/1/3 (MLC/1284.4), so we provide them ioctls for this purpose.
  *
  * Failing 7/1/2, we look for 7/1/3, even though it's probably not
  * stream-compatible, because this matches the behaviour of the old code.
  *
  * If nothing else, we bind to 7/1/1 - the unidirectional interface.
  */
 static int usblp_select_alts(struct usblp *usblp)
 {
 	struct usb_interface *if_alt;
 	struct usb_host_interface *ifd;
 	struct usb_endpoint_descriptor *epd, *epwrite, *epread;
 	int p, i, e;
 	if_alt = usblp->intf;
 	for (p = 0; p < USBLP_MAX_PROTOCOLS; p++)
 		usblp->protocol[p].alt_setting = -1;
 	/* Find out what we have. */
 	for (i = 0; i < if_alt->num_altsetting; i++) {
 		ifd = &if_alt->altsetting[i];
 		if (ifd->desc.bInterfaceClass != 7 || ifd->desc.bInterfaceSubClass != 1)
 			if (!(usblp->quirks & USBLP_QUIRK_BAD_CLASS))
 				continue;
 		if (ifd->desc.bInterfaceProtocol < USBLP_FIRST_PROTOCOL ||
 		    ifd->desc.bInterfaceProtocol > USBLP_LAST_PROTOCOL)
 			continue;
 		/* Look for bulk OUT and IN endpoints. */
 		epwrite = epread = NULL;
 		for (e = 0; e < ifd->desc.bNumEndpoints; e++) {
 			epd = &ifd->endpoint[e].desc;
 			if (usb_endpoint_is_bulk_out(epd))
 				if (!epwrite)
 					epwrite = epd;
 			if (usb_endpoint_is_bulk_in(epd))
 				if (!epread)
 					epread = epd;
 		}
 		/* Ignore buggy hardware without the right endpoints. */
 		if (!epwrite || (ifd->desc.bInterfaceProtocol > 1 && !epread))
 			continue;
 		/* Turn off reads for 7/1/1 (unidirectional) interfaces
 		 * and buggy bidirectional printers. */
 		if (ifd->desc.bInterfaceProtocol == 1) {
 			epread = NULL;
 		} else if (usblp->quirks & USBLP_QUIRK_BIDIR) {
 			printk(KERN_INFO "usblp%d: Disabling reads from "
 			    "problematic bidirectional printer\n",
 			    usblp->minor);
 			epread = NULL;
 		}
 		usblp->protocol[ifd->desc.bInterfaceProtocol].alt_setting =
 				ifd->desc.bAlternateSetting;
 		usblp->protocol[ifd->desc.bInterfaceProtocol].epwrite = epwrite;
 		usblp->protocol[ifd->desc.bInterfaceProtocol].epread = epread;
 	}
 	/* If our requested protocol is supported, then use it. */
 	if (proto_bias >= USBLP_FIRST_PROTOCOL &&
 	    proto_bias <= USBLP_LAST_PROTOCOL &&
 	    usblp->protocol[proto_bias].alt_setting != -1)
 		return proto_bias;
 	/* Ordering is important here. */
 	if (usblp->protocol[2].alt_setting != -1)
 		return 2;
 	if (usblp->protocol[1].alt_setting != -1)
 		return 1;
 	if (usblp->protocol[3].alt_setting != -1)
 		return 3;
 	/* If nothing is available, then don't bind to this device. */
 	return -1;
 }
 static int usblp_set_protocol(struct usblp *usblp, int protocol)
 {
 	int r, alts;
 	if (protocol < USBLP_FIRST_PROTOCOL || protocol > USBLP_LAST_PROTOCOL)
 		return -EINVAL;
 	alts = usblp->protocol[protocol].alt_setting;
 	if (alts < 0)
 		return -EINVAL;
 	r = usb_set_interface(usblp->dev, usblp->ifnum, alts);
 	if (r < 0) {
 		printk(KERN_ERR "usblp: can't set desired altsetting %d on interface %d\n",
 			alts, usblp->ifnum);
 		return r;
 	}
 	usblp->bidir = (usblp->protocol[protocol].epread != NULL);
 	usblp->current_protocol = protocol;
 	dbg("usblp%d set protocol %d", usblp->minor, protocol);
 	return 0;
 }
 /* Retrieves and caches device ID string.
  * Returns length, including length bytes but not null terminator.
  * On error, returns a negative errno value. */
 static int usblp_cache_device_id_string(struct usblp *usblp)
 {
 	int err, length;
 	err = usblp_get_id(usblp, 0, usblp->device_id_string, USBLP_DEVICE_ID_SIZE - 1);
 	if (err < 0) {
 		dbg("usblp%d: error = %d reading IEEE-1284 Device ID string",
 			usblp->minor, err);
 		usblp->device_id_string[0] = usblp->device_id_string[1] = '\0';
 		return -EIO;
 	}
 	/* First two bytes are length in big-endian.
 	 * They count themselves, and we copy them into
 	 * the user's buffer. */
 	length = be16_to_cpu(*((__be16 *)usblp->device_id_string));
 	if (length < 2)
 		length = 2;
 	else if (length >= USBLP_DEVICE_ID_SIZE)
 		length = USBLP_DEVICE_ID_SIZE - 1;
 	usblp->device_id_string[length] = '\0';
 	dbg("usblp%d Device ID string [len=%d]=\"%s\"",
 		usblp->minor, length, &usblp->device_id_string[2]);
 	return length;
 }
 static void usblp_disconnect(struct usb_interface *intf)
 {
 	struct usblp *usblp = usb_get_intfdata (intf);
 	usb_deregister_dev(intf, &usblp_class);
 	if (!usblp || !usblp->dev) {
-		err("bogus disconnect");
+		dev_err(&intf->dev, "bogus disconnect\n");
 		BUG ();
 	}
 	device_remove_file(&intf->dev, &dev_attr_ieee1284_id);
 	mutex_lock (&usblp_mutex);
 	mutex_lock (&usblp->mut);
 	usblp->present = 0;
 	wake_up(&usblp->wwait);
 	wake_up(&usblp->rwait);
 	usb_set_intfdata (intf, NULL);
 	usblp_unlink_urbs(usblp);
 	mutex_unlock (&usblp->mut);
 	if (!usblp->used)
 		usblp_cleanup (usblp);
 	mutex_unlock (&usblp_mutex);
 }
 static int usblp_suspend (struct usb_interface *intf, pm_message_t message)
 {
 	struct usblp *usblp = usb_get_intfdata (intf);
 	/* we take no more IO */
 	usblp->sleeping = 1;
 	usblp_unlink_urbs(usblp);
 #if 0 /* XXX Do we want this? What if someone is reading, should we fail? */
 	/* not strictly necessary, but just in case */
 	wake_up(&usblp->wwait);
 	wake_up(&usblp->rwait);
 #endif
 	return 0;
 }
 static int usblp_resume (struct usb_interface *intf)
 {
 	struct usblp *usblp = usb_get_intfdata (intf);
 	int r;
 	usblp->sleeping = 0;
 	r = handle_bidir (usblp);
 	return r;
 }
 static struct usb_device_id usblp_ids [] = {
 	{ USB_DEVICE_INFO(7, 1, 1) },
 	{ USB_DEVICE_INFO(7, 1, 2) },
 	{ USB_DEVICE_INFO(7, 1, 3) },
 	{ USB_INTERFACE_INFO(7, 1, 1) },
 	{ USB_INTERFACE_INFO(7, 1, 2) },
 	{ USB_INTERFACE_INFO(7, 1, 3) },
 	{ USB_DEVICE(0x04b8, 0x0202) },	/* Seiko Epson Receipt Printer M129C */
 	{ }						/* Terminating entry */
 };
 MODULE_DEVICE_TABLE (usb, usblp_ids);
 static struct usb_driver usblp_driver = {
 	.name =		"usblp",
 	.probe =	usblp_probe,
 	.disconnect =	usblp_disconnect,
 	.suspend =	usblp_suspend,
 	.resume =	usblp_resume,
 	.id_table =	usblp_ids,
 	.supports_autosuspend =	1,
 };
 static int __init usblp_init(void)
 {
 	return usb_register(&usblp_driver);
 }
 static void __exit usblp_exit(void)
 {
 	usb_deregister(&usblp_driver);
 }
 module_init(usblp_init);
 module_exit(usblp_exit);
 MODULE_AUTHOR( DRIVER_AUTHOR );
 MODULE_DESCRIPTION( DRIVER_DESC );
 module_param(proto_bias, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(proto_bias, "Favourite protocol number");
 MODULE_LICENSE("GPL");