blob: ab769dbea1b3e6f66d4df15ce6166caca8a17a50 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * USB Keyspan PDA / Xircom / Entregra Converter driver
3 *
4 * Copyright (C) 1999 - 2001 Greg Kroah-Hartman <greg@kroah.com>
5 * Copyright (C) 1999, 2000 Brian Warner <warner@lothar.com>
6 * Copyright (C) 2000 Al Borchers <borchers@steinerpoint.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
Alan Cox9e70f312008-07-22 11:13:42 +010013 * See Documentation/usb/usb-serial.txt for more information on using this
14 * driver
15 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 * (09/07/2001) gkh
17 * cleaned up the Xircom support. Added ids for Entregra device which is
18 * the same as the Xircom device. Enabled the code to be compiled for
19 * either Xircom or Keyspan devices.
20 *
21 * (08/11/2001) Cristian M. Craciunescu
22 * support for Xircom PGSDB9
23 *
24 * (05/31/2001) gkh
Alan Cox9e70f312008-07-22 11:13:42 +010025 * switched from using spinlock to a semaphore, which fixes lots of
26 * problems.
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 *
28 * (04/08/2001) gb
29 * Identify version on module load.
Alan Cox9e70f312008-07-22 11:13:42 +010030 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 * (11/01/2000) Adam J. Richter
32 * usb_device_id table support
Alan Cox9e70f312008-07-22 11:13:42 +010033 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 * (10/05/2000) gkh
35 * Fixed bug with urb->dev not being set properly, now that the usb
36 * core needs it.
Alan Cox9e70f312008-07-22 11:13:42 +010037 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 * (08/28/2000) gkh
39 * Added locks for SMP safeness.
Alan Cox9e70f312008-07-22 11:13:42 +010040 * Fixed MOD_INC and MOD_DEC logic and the ability to open a port more
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * than once.
Alan Cox9e70f312008-07-22 11:13:42 +010042 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 * (07/20/2000) borchers
44 * - keyspan_pda_write no longer sleeps if it is called on interrupt time;
45 * PPP and the line discipline with stty echo on can call write on
46 * interrupt time and this would cause an oops if write slept
47 * - if keyspan_pda_write is in an interrupt, it will not call
48 * usb_control_msg (which sleeps) to query the room in the device
49 * buffer, it simply uses the current room value it has
50 * - if the urb is busy or if it is throttled keyspan_pda_write just
51 * returns 0, rather than sleeping to wait for this to change; the
52 * write_chan code in n_tty.c will sleep if needed before calling
53 * keyspan_pda_write again
54 * - if the device needs to be unthrottled, write now queues up the
55 * call to usb_control_msg (which sleeps) to unthrottle the device
56 * - the wakeups from keyspan_pda_write_bulk_callback are queued rather
57 * than done directly from the callback to avoid the race in write_chan
58 * - keyspan_pda_chars_in_buffer also indicates its buffer is full if the
59 * urb status is -EINPROGRESS, meaning it cannot write at the moment
Alan Cox9e70f312008-07-22 11:13:42 +010060 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 * (07/19/2000) gkh
62 * Added module_init and module_exit functions to handle the fact that this
63 * driver is a loadable module now.
64 *
65 * (03/26/2000) gkh
66 * Split driver up into device specific pieces.
Alan Cox9e70f312008-07-22 11:13:42 +010067 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 */
69
70
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include <linux/kernel.h>
72#include <linux/errno.h>
73#include <linux/init.h>
74#include <linux/slab.h>
75#include <linux/tty.h>
76#include <linux/tty_driver.h>
77#include <linux/tty_flip.h>
78#include <linux/module.h>
79#include <linux/spinlock.h>
80#include <linux/workqueue.h>
David Woodhouse3edbf982008-05-30 15:15:13 +030081#include <linux/firmware.h>
82#include <linux/ihex.h>
Alan Cox9e70f312008-07-22 11:13:42 +010083#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070084#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070085#include <linux/usb/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
87static int debug;
88
Linus Torvalds1da177e2005-04-16 15:20:36 -070089/* make a simple define to handle if we are compiling keyspan_pda or xircom support */
90#if defined(CONFIG_USB_SERIAL_KEYSPAN_PDA) || defined(CONFIG_USB_SERIAL_KEYSPAN_PDA_MODULE)
91 #define KEYSPAN
92#else
93 #undef KEYSPAN
94#endif
95#if defined(CONFIG_USB_SERIAL_XIRCOM) || defined(CONFIG_USB_SERIAL_XIRCOM_MODULE)
96 #define XIRCOM
97#else
98 #undef XIRCOM
99#endif
100
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101/*
102 * Version Information
103 */
104#define DRIVER_VERSION "v1.1"
105#define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
106#define DRIVER_DESC "USB Keyspan PDA Converter driver"
107
108struct keyspan_pda_private {
109 int tx_room;
110 int tx_throttled;
111 struct work_struct wakeup_work;
112 struct work_struct unthrottle_work;
David Howellsc4028952006-11-22 14:57:56 +0000113 struct usb_serial *serial;
114 struct usb_serial_port *port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115};
116
117
118#define KEYSPAN_VENDOR_ID 0x06cd
119#define KEYSPAN_PDA_FAKE_ID 0x0103
120#define KEYSPAN_PDA_ID 0x0104 /* no clue */
121
122/* For Xircom PGSDB9 and older Entregra version of the same device */
123#define XIRCOM_VENDOR_ID 0x085a
124#define XIRCOM_FAKE_ID 0x8027
125#define ENTREGRA_VENDOR_ID 0x1645
126#define ENTREGRA_FAKE_ID 0x8093
127
128static struct usb_device_id id_table_combined [] = {
129#ifdef KEYSPAN
130 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
131#endif
132#ifdef XIRCOM
133 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
134 { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
135#endif
136 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
137 { } /* Terminating entry */
138};
139
Alan Cox9e70f312008-07-22 11:13:42 +0100140MODULE_DEVICE_TABLE(usb, id_table_combined);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
142static struct usb_driver keyspan_pda_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 .name = "keyspan_pda",
144 .probe = usb_serial_probe,
145 .disconnect = usb_serial_disconnect,
146 .id_table = id_table_combined,
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800147 .no_dynamic_id = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148};
149
150static struct usb_device_id id_table_std [] = {
151 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
152 { } /* Terminating entry */
153};
154
155#ifdef KEYSPAN
156static struct usb_device_id id_table_fake [] = {
157 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
158 { } /* Terminating entry */
159};
160#endif
161
162#ifdef XIRCOM
163static struct usb_device_id id_table_fake_xircom [] = {
Alan Cox9e70f312008-07-22 11:13:42 +0100164 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
165 { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
166 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167};
168#endif
169
David Howellsc4028952006-11-22 14:57:56 +0000170static void keyspan_pda_wakeup_write(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
David Howellsc4028952006-11-22 14:57:56 +0000172 struct keyspan_pda_private *priv =
173 container_of(work, struct keyspan_pda_private, wakeup_work);
174 struct usb_serial_port *port = priv->port;
Alan Cox4a90f092008-10-13 10:39:46 +0100175 struct tty_struct *tty = tty_port_tty_get(&port->port);
176 tty_wakeup(tty);
177 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178}
179
David Howellsc4028952006-11-22 14:57:56 +0000180static void keyspan_pda_request_unthrottle(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181{
David Howellsc4028952006-11-22 14:57:56 +0000182 struct keyspan_pda_private *priv =
183 container_of(work, struct keyspan_pda_private, unthrottle_work);
184 struct usb_serial *serial = priv->serial;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 int result;
186
187 dbg(" request_unthrottle");
188 /* ask the device to tell us when the tx buffer becomes
189 sufficiently empty */
Alan Cox9e70f312008-07-22 11:13:42 +0100190 result = usb_control_msg(serial->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 usb_sndctrlpipe(serial->dev, 0),
192 7, /* request_unthrottle */
193 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
194 | USB_DIR_OUT,
195 16, /* value: threshold */
196 0, /* index */
197 NULL,
198 0,
199 2000);
200 if (result < 0)
Alan Cox9e70f312008-07-22 11:13:42 +0100201 dbg("%s - error %d from usb_control_msg",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800202 __func__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203}
204
205
Alan Cox9e70f312008-07-22 11:13:42 +0100206static void keyspan_pda_rx_interrupt(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207{
Ming Leicdc97792008-02-24 18:41:47 +0800208 struct usb_serial_port *port = urb->context;
Alan Cox4a90f092008-10-13 10:39:46 +0100209 struct tty_struct *tty = tty_port_tty_get(&port->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 unsigned char *data = urb->transfer_buffer;
Greg Kroah-Hartman23189ae2007-06-15 15:44:13 -0700211 int retval;
212 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 struct keyspan_pda_private *priv;
214 priv = usb_get_serial_port_data(port);
215
Greg Kroah-Hartman23189ae2007-06-15 15:44:13 -0700216 switch (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 case 0:
218 /* success */
219 break;
220 case -ECONNRESET:
221 case -ENOENT:
222 case -ESHUTDOWN:
223 /* this urb is terminated, clean up */
Greg Kroah-Hartman23189ae2007-06-15 15:44:13 -0700224 dbg("%s - urb shutting down with status: %d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800225 __func__, status);
Alan Cox4a90f092008-10-13 10:39:46 +0100226 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 default:
Greg Kroah-Hartman23189ae2007-06-15 15:44:13 -0700228 dbg("%s - nonzero urb status received: %d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800229 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 goto exit;
231 }
232
Alan Cox9e70f312008-07-22 11:13:42 +0100233 /* see if the message is data or a status interrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 switch (data[0]) {
235 case 0:
236 /* rest of message is rx data */
237 if (urb->actual_length) {
Alan Cox8dd03a52008-07-22 11:13:51 +0100238 tty_insert_flip_string(tty, data + 1,
239 urb->actual_length - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 tty_flip_buffer_push(tty);
241 }
242 break;
243 case 1:
244 /* status interrupt */
245 dbg(" rx int, d1=%d, d2=%d", data[1], data[2]);
246 switch (data[1]) {
247 case 1: /* modemline change */
248 break;
249 case 2: /* tx unthrottle interrupt */
250 priv->tx_throttled = 0;
251 /* queue up a wakeup at scheduler time */
252 schedule_work(&priv->wakeup_work);
253 break;
254 default:
255 break;
256 }
257 break;
258 default:
259 break;
260 }
261
262exit:
Alan Cox9e70f312008-07-22 11:13:42 +0100263 retval = usb_submit_urb(urb, GFP_ATOMIC);
Greg Kroah-Hartman23189ae2007-06-15 15:44:13 -0700264 if (retval)
Alan Cox4a90f092008-10-13 10:39:46 +0100265 dev_err(&port->dev,
266 "%s - usb_submit_urb failed with result %d",
267 __func__, retval);
268out:
269 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270}
271
272
Alan Cox95da3102008-07-22 11:09:07 +0100273static void keyspan_pda_rx_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274{
275 /* stop receiving characters. We just turn off the URB request, and
276 let chars pile up in the device. If we're doing hardware
277 flowcontrol, the device will signal the other end when its buffer
278 fills up. If we're doing XON/XOFF, this would be a good time to
279 send an XOFF, although it might make sense to foist that off
280 upon the device too. */
Alan Cox95da3102008-07-22 11:09:07 +0100281 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 dbg("keyspan_pda_rx_throttle port %d", port->number);
283 usb_kill_urb(port->interrupt_in_urb);
284}
285
286
Alan Cox95da3102008-07-22 11:09:07 +0100287static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
Alan Cox95da3102008-07-22 11:09:07 +0100289 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 /* just restart the receive interrupt URB */
291 dbg("keyspan_pda_rx_unthrottle port %d", port->number);
292 port->interrupt_in_urb->dev = port->serial->dev;
293 if (usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC))
294 dbg(" usb_submit_urb(read urb) failed");
295 return;
296}
297
298
Alan Cox9e70f312008-07-22 11:13:42 +0100299static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300{
301 int rc;
302 int bindex;
303
Alan Cox9e70f312008-07-22 11:13:42 +0100304 switch (baud) {
305 case 110:
306 bindex = 0;
307 break;
308 case 300:
309 bindex = 1;
310 break;
311 case 1200:
312 bindex = 2;
313 break;
314 case 2400:
315 bindex = 3;
316 break;
317 case 4800:
318 bindex = 4;
319 break;
320 case 9600:
321 bindex = 5;
322 break;
323 case 19200:
324 bindex = 6;
325 break;
326 case 38400:
327 bindex = 7;
328 break;
329 case 57600:
330 bindex = 8;
331 break;
332 case 115200:
333 bindex = 9;
334 break;
335 default:
336 bindex = 5; /* Default to 9600 */
337 baud = 9600;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 }
339
340 /* rather than figure out how to sleep while waiting for this
341 to complete, I just use the "legacy" API. */
342 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
343 0, /* set baud */
Alan Cox9e70f312008-07-22 11:13:42 +0100344 USB_TYPE_VENDOR
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 | USB_RECIP_INTERFACE
346 | USB_DIR_OUT, /* type */
347 bindex, /* value */
348 0, /* index */
349 NULL, /* &data */
350 0, /* size */
351 2000); /* timeout */
Alan Coxe7806e32007-12-13 16:15:28 -0800352 if (rc < 0)
353 return 0;
354 return baud;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355}
356
357
Alan Cox95da3102008-07-22 11:09:07 +0100358static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
Alan Cox95da3102008-07-22 11:09:07 +0100360 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 struct usb_serial *serial = port->serial;
362 int value;
363 int result;
364
365 if (break_state == -1)
366 value = 1; /* start break */
367 else
368 value = 0; /* clear break */
369 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
Alan Cox9e70f312008-07-22 11:13:42 +0100370 4, /* set break */
371 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
372 value, 0, NULL, 0, 2000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 if (result < 0)
Alan Cox9e70f312008-07-22 11:13:42 +0100374 dbg("%s - error %d from usb_control_msg",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800375 __func__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 /* there is something funky about this.. the TCSBRK that 'cu' performs
377 ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
378 seconds apart, but it feels like the break sent isn't as long as it
379 is on /dev/ttyS0 */
380}
381
382
Alan Cox95da3102008-07-22 11:09:07 +0100383static void keyspan_pda_set_termios(struct tty_struct *tty,
384 struct usb_serial_port *port, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385{
386 struct usb_serial *serial = port->serial;
Alan Coxe7806e32007-12-13 16:15:28 -0800387 speed_t speed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
389 /* cflag specifies lots of stuff: number of stop bits, parity, number
390 of data bits, baud. What can the device actually handle?:
391 CSTOPB (1 stop bit or 2)
392 PARENB (parity)
393 CSIZE (5bit .. 8bit)
394 There is minimal hw support for parity (a PSW bit seems to hold the
395 parity of whatever is in the accumulator). The UART either deals
396 with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
397 1 special, stop). So, with firmware changes, we could do:
398 8N1: 10 bit
399 8N2: 11 bit, extra bit always (mark?)
400 8[EOMS]1: 11 bit, extra bit is parity
401 7[EOMS]1: 10 bit, b0/b7 is parity
402 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
403
404 HW flow control is dictated by the tty->termios->c_cflags & CRTSCTS
405 bit.
406
407 For now, just do baud. */
408
Alan Cox95da3102008-07-22 11:09:07 +0100409 speed = tty_get_baud_rate(tty);
Alan Coxe7806e32007-12-13 16:15:28 -0800410 speed = keyspan_pda_setbaud(serial, speed);
411
412 if (speed == 0) {
413 dbg("can't handle requested baud rate");
414 /* It hasn't changed so.. */
415 speed = tty_termios_baud_rate(old_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 }
Alan Coxe7806e32007-12-13 16:15:28 -0800417 /* Only speed can change so copy the old h/w parameters
418 then encode the new speed */
Alan Cox95da3102008-07-22 11:09:07 +0100419 tty_termios_copy_hw(tty->termios, old_termios);
420 tty_encode_baud_rate(tty, speed, speed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421}
422
423
424/* modem control pins: DTR and RTS are outputs and can be controlled.
425 DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
426 read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
427
428static int keyspan_pda_get_modem_info(struct usb_serial *serial,
429 unsigned char *value)
430{
431 int rc;
432 unsigned char data;
433 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
434 3, /* get pins */
435 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
436 0, 0, &data, 1, 2000);
Benny Halevy3b36a8f2008-06-27 12:22:32 +0300437 if (rc >= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 *value = data;
439 return rc;
440}
441
442
443static int keyspan_pda_set_modem_info(struct usb_serial *serial,
444 unsigned char value)
445{
446 int rc;
447 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
448 3, /* set pins */
449 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
450 value, 0, NULL, 0, 2000);
451 return rc;
452}
453
Alan Cox95da3102008-07-22 11:09:07 +0100454static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455{
Alan Cox95da3102008-07-22 11:09:07 +0100456 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 struct usb_serial *serial = port->serial;
458 int rc;
459 unsigned char status;
460 int value;
461
462 rc = keyspan_pda_get_modem_info(serial, &status);
463 if (rc < 0)
464 return rc;
465 value =
466 ((status & (1<<7)) ? TIOCM_DTR : 0) |
467 ((status & (1<<6)) ? TIOCM_CAR : 0) |
468 ((status & (1<<5)) ? TIOCM_RNG : 0) |
469 ((status & (1<<4)) ? TIOCM_DSR : 0) |
470 ((status & (1<<3)) ? TIOCM_CTS : 0) |
471 ((status & (1<<2)) ? TIOCM_RTS : 0);
472 return value;
473}
474
Alan Cox95da3102008-07-22 11:09:07 +0100475static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 unsigned int set, unsigned int clear)
477{
Alan Cox95da3102008-07-22 11:09:07 +0100478 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 struct usb_serial *serial = port->serial;
480 int rc;
481 unsigned char status;
482
483 rc = keyspan_pda_get_modem_info(serial, &status);
484 if (rc < 0)
485 return rc;
486
487 if (set & TIOCM_RTS)
488 status |= (1<<2);
489 if (set & TIOCM_DTR)
490 status |= (1<<7);
491
492 if (clear & TIOCM_RTS)
493 status &= ~(1<<2);
494 if (clear & TIOCM_DTR)
495 status &= ~(1<<7);
496 rc = keyspan_pda_set_modem_info(serial, status);
497 return rc;
498}
499
Alan Cox95da3102008-07-22 11:09:07 +0100500static int keyspan_pda_write(struct tty_struct *tty,
501 struct usb_serial_port *port, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
503 struct usb_serial *serial = port->serial;
504 int request_unthrottle = 0;
505 int rc = 0;
506 struct keyspan_pda_private *priv;
507
508 priv = usb_get_serial_port_data(port);
509 /* guess how much room is left in the device's ring buffer, and if we
510 want to send more than that, check first, updating our notion of
511 what is left. If our write will result in no room left, ask the
512 device to give us an interrupt when the room available rises above
513 a threshold, and hold off all writers (eventually, those using
514 select() or poll() too) until we receive that unthrottle interrupt.
515 Block if we can't write anything at all, otherwise write as much as
516 we can. */
Alan Cox9e70f312008-07-22 11:13:42 +0100517 dbg("keyspan_pda_write(%d)", count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (count == 0) {
519 dbg(" write request of 0 bytes");
Alan Cox9e70f312008-07-22 11:13:42 +0100520 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
522
523 /* we might block because of:
524 the TX urb is in-flight (wait until it completes)
525 the device is full (wait until it says there is room)
526 */
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200527 spin_lock_bh(&port->lock);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700528 if (port->write_urb_busy || priv->tx_throttled) {
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200529 spin_unlock_bh(&port->lock);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700530 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700532 port->write_urb_busy = 1;
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200533 spin_unlock_bh(&port->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
535 /* At this point the URB is in our control, nobody else can submit it
536 again (the only sudden transition was the one from EINPROGRESS to
537 finished). Also, the tx process is not throttled. So we are
538 ready to write. */
539
540 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
541
542 /* Check if we might overrun the Tx buffer. If so, ask the
543 device how much room it really has. This is done only on
544 scheduler time, since usb_control_msg() sleeps. */
545 if (count > priv->tx_room && !in_interrupt()) {
546 unsigned char room;
Alan Cox9e70f312008-07-22 11:13:42 +0100547 rc = usb_control_msg(serial->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 usb_rcvctrlpipe(serial->dev, 0),
549 6, /* write_room */
550 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
551 | USB_DIR_IN,
552 0, /* value: 0 means "remaining room" */
553 0, /* index */
554 &room,
555 1,
556 2000);
557 if (rc < 0) {
558 dbg(" roomquery failed");
559 goto exit;
560 }
561 if (rc == 0) {
562 dbg(" roomquery returned 0 bytes");
563 rc = -EIO; /* device didn't return any data */
564 goto exit;
565 }
566 dbg(" roomquery says %d", room);
567 priv->tx_room = room;
568 }
569 if (count > priv->tx_room) {
570 /* we're about to completely fill the Tx buffer, so
571 we'll be throttled afterwards. */
572 count = priv->tx_room;
573 request_unthrottle = 1;
574 }
575
576 if (count) {
577 /* now transfer data */
Alan Cox9e70f312008-07-22 11:13:42 +0100578 memcpy(port->write_urb->transfer_buffer, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 /* send the data out the bulk port */
580 port->write_urb->transfer_buffer_length = count;
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700581
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 priv->tx_room -= count;
583
584 port->write_urb->dev = port->serial->dev;
585 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
586 if (rc) {
587 dbg(" usb_submit_urb(write bulk) failed");
588 goto exit;
589 }
Alan Cox9e70f312008-07-22 11:13:42 +0100590 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 /* There wasn't any room left, so we are throttled until
592 the buffer empties a bit */
593 request_unthrottle = 1;
594 }
595
596 if (request_unthrottle) {
597 priv->tx_throttled = 1; /* block writers */
598 schedule_work(&priv->unthrottle_work);
599 }
600
601 rc = count;
602exit:
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700603 if (rc < 0)
604 port->write_urb_busy = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 return rc;
606}
607
608
Alan Cox9e70f312008-07-22 11:13:42 +0100609static void keyspan_pda_write_bulk_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610{
Ming Leicdc97792008-02-24 18:41:47 +0800611 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 struct keyspan_pda_private *priv;
613
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700614 port->write_urb_busy = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 priv = usb_get_serial_port_data(port);
616
617 /* queue up a wakeup at scheduler time */
618 schedule_work(&priv->wakeup_work);
619}
620
621
Alan Cox95da3102008-07-22 11:09:07 +0100622static int keyspan_pda_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623{
Alan Cox95da3102008-07-22 11:09:07 +0100624 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 struct keyspan_pda_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 priv = usb_get_serial_port_data(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 /* used by n_tty.c for processing of tabs and such. Giving it our
628 conservative guess is probably good enough, but needs testing by
629 running a console through the device. */
Alan Cox9e70f312008-07-22 11:13:42 +0100630 return priv->tx_room;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631}
632
633
Alan Cox95da3102008-07-22 11:09:07 +0100634static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635{
Alan Cox95da3102008-07-22 11:09:07 +0100636 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 struct keyspan_pda_private *priv;
Alan Coxa5b6f602008-04-08 17:16:06 +0100638 unsigned long flags;
639 int ret = 0;
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700640
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 priv = usb_get_serial_port_data(port);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700642
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 /* when throttled, return at least WAKEUP_CHARS to tell select() (via
644 n_tty.c:normal_poll() ) that we're not writeable. */
Alan Coxa5b6f602008-04-08 17:16:06 +0100645
646 spin_lock_irqsave(&port->lock, flags);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700647 if (port->write_urb_busy || priv->tx_throttled)
Alan Coxa5b6f602008-04-08 17:16:06 +0100648 ret = 256;
649 spin_unlock_irqrestore(&port->lock, flags);
650 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651}
652
653
Alan Cox335f8512009-06-11 12:26:29 +0100654static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
655{
656 struct usb_serial *serial = port->serial;
657
658 if (serial->dev) {
659 if (on)
660 keyspan_pda_set_modem_info(serial, (1<<7) | (1<< 2));
661 else
662 keyspan_pda_set_modem_info(serial, 0);
663 }
664}
665
666static int keyspan_pda_carrier_raised(struct usb_serial_port *port)
667{
668 struct usb_serial *serial = port->serial;
669 unsigned char modembits;
670
671 /* If we can read the modem status and the DCD is low then
672 carrier is not raised yet */
673 if (keyspan_pda_get_modem_info(serial, &modembits) >= 0) {
674 if (!(modembits & (1>>6)))
675 return 0;
676 }
677 /* Carrier raised, or we failed (eg disconnected) so
678 progress accordingly */
679 return 1;
680}
681
682
Alan Cox95da3102008-07-22 11:09:07 +0100683static int keyspan_pda_open(struct tty_struct *tty,
684 struct usb_serial_port *port, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685{
686 struct usb_serial *serial = port->serial;
687 unsigned char room;
688 int rc = 0;
689 struct keyspan_pda_private *priv;
690
691 /* find out how much room is in the Tx ring */
692 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
693 6, /* write_room */
694 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
695 | USB_DIR_IN,
696 0, /* value */
697 0, /* index */
698 &room,
699 1,
700 2000);
701 if (rc < 0) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800702 dbg("%s - roomquery failed", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 goto error;
704 }
705 if (rc == 0) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800706 dbg("%s - roomquery returned 0 bytes", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 rc = -EIO;
708 goto error;
709 }
710 priv = usb_get_serial_port_data(port);
711 priv->tx_room = room;
712 priv->tx_throttled = room ? 0 : 1;
713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 /*Start reading from the device*/
715 port->interrupt_in_urb->dev = serial->dev;
716 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
717 if (rc) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800718 dbg("%s - usb_submit_urb(read int) failed", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 goto error;
720 }
721
722error:
723 return rc;
724}
Alan Cox335f8512009-06-11 12:26:29 +0100725static void keyspan_pda_close(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726{
727 struct usb_serial *serial = port->serial;
728
729 if (serial->dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 /* shutdown our bulk reads and writes */
731 usb_kill_urb(port->write_urb);
732 usb_kill_urb(port->interrupt_in_urb);
733 }
734}
735
736
737/* download the firmware to a "fake" device (pre-renumeration) */
Alan Cox9e70f312008-07-22 11:13:42 +0100738static int keyspan_pda_fake_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739{
740 int response;
David Woodhouse3edbf982008-05-30 15:15:13 +0300741 const char *fw_name;
742 const struct ihex_binrec *record;
743 const struct firmware *fw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
745 /* download the firmware here ... */
746 response = ezusb_set_reset(serial, 1);
747
David Woodhouse3edbf982008-05-30 15:15:13 +0300748 if (0) { ; }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749#ifdef KEYSPAN
David Woodhouse3edbf982008-05-30 15:15:13 +0300750 else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
751 fw_name = "keyspan_pda/keyspan_pda.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752#endif
753#ifdef XIRCOM
David Woodhouse3edbf982008-05-30 15:15:13 +0300754 else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
755 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
756 fw_name = "keyspan_pda/xircom_pgs.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757#endif
David Woodhouse3edbf982008-05-30 15:15:13 +0300758 else {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700759 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
760 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 return -ENODEV;
762 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300763 if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700764 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
765 fw_name);
David Woodhouse3edbf982008-05-30 15:15:13 +0300766 return -ENOENT;
767 }
768 record = (const struct ihex_binrec *)fw->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
David Woodhouse3edbf982008-05-30 15:15:13 +0300770 while (record) {
771 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 (unsigned char *)record->data,
David Woodhouse3edbf982008-05-30 15:15:13 +0300773 be16_to_cpu(record->len), 0xa0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 if (response < 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700775 dev_err(&serial->dev->dev, "ezusb_writememory failed "
776 "for Keyspan PDA firmware (%d %04X %p %d)\n",
777 response, be32_to_cpu(record->addr),
778 record->data, be16_to_cpu(record->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 break;
780 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300781 record = ihex_next_binrec(record);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300783 release_firmware(fw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 /* bring device out of reset. Renumeration will occur in a moment
785 and the new device will bind to the real driver */
786 response = ezusb_set_reset(serial, 0);
787
788 /* we want this device to fail to have a driver assigned to it. */
Alan Cox9e70f312008-07-22 11:13:42 +0100789 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790}
791
Alan Cox9e70f312008-07-22 11:13:42 +0100792static int keyspan_pda_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793{
794
795 struct keyspan_pda_private *priv;
796
797 /* allocate the private data structures for all ports. Well, for all
798 one ports. */
799
800 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
801 if (!priv)
Alan Cox9e70f312008-07-22 11:13:42 +0100802 return 1; /* error */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 usb_set_serial_port_data(serial->port[0], priv);
804 init_waitqueue_head(&serial->port[0]->write_wait);
David Howellsc4028952006-11-22 14:57:56 +0000805 INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
806 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
807 priv->serial = serial;
808 priv->port = serial->port[0];
Alan Cox9e70f312008-07-22 11:13:42 +0100809 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810}
811
Alan Cox9e70f312008-07-22 11:13:42 +0100812static void keyspan_pda_shutdown(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800814 dbg("%s", __func__);
Alan Cox9e70f312008-07-22 11:13:42 +0100815
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 kfree(usb_get_serial_port_data(serial->port[0]));
817}
818
819#ifdef KEYSPAN
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700820static struct usb_serial_driver keyspan_pda_fake_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700821 .driver = {
822 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700823 .name = "keyspan_pda_pre",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700824 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700825 .description = "Keyspan PDA - (prerenumeration)",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100826 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 .id_table = id_table_fake,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 .num_ports = 1,
829 .attach = keyspan_pda_fake_startup,
830};
831#endif
832
833#ifdef XIRCOM
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700834static struct usb_serial_driver xircom_pgs_fake_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700835 .driver = {
836 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700837 .name = "xircom_no_firm",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700838 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700839 .description = "Xircom / Entregra PGS - (prerenumeration)",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100840 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 .id_table = id_table_fake_xircom,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 .num_ports = 1,
843 .attach = keyspan_pda_fake_startup,
844};
845#endif
846
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700847static struct usb_serial_driver keyspan_pda_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700848 .driver = {
849 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700850 .name = "keyspan_pda",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700851 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700852 .description = "Keyspan PDA",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100853 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 .id_table = id_table_std,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 .num_ports = 1,
Alan Cox335f8512009-06-11 12:26:29 +0100856 .dtr_rts = keyspan_pda_dtr_rts,
857 .carrier_raised = keyspan_pda_carrier_raised,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 .open = keyspan_pda_open,
859 .close = keyspan_pda_close,
860 .write = keyspan_pda_write,
861 .write_room = keyspan_pda_write_room,
862 .write_bulk_callback = keyspan_pda_write_bulk_callback,
863 .read_int_callback = keyspan_pda_rx_interrupt,
864 .chars_in_buffer = keyspan_pda_chars_in_buffer,
865 .throttle = keyspan_pda_rx_throttle,
866 .unthrottle = keyspan_pda_rx_unthrottle,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 .set_termios = keyspan_pda_set_termios,
868 .break_ctl = keyspan_pda_break_ctl,
869 .tiocmget = keyspan_pda_tiocmget,
870 .tiocmset = keyspan_pda_tiocmset,
871 .attach = keyspan_pda_startup,
872 .shutdown = keyspan_pda_shutdown,
873};
874
875
Alan Cox9e70f312008-07-22 11:13:42 +0100876static int __init keyspan_pda_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877{
878 int retval;
879 retval = usb_serial_register(&keyspan_pda_device);
880 if (retval)
881 goto failed_pda_register;
882#ifdef KEYSPAN
883 retval = usb_serial_register(&keyspan_pda_fake_device);
884 if (retval)
885 goto failed_pda_fake_register;
886#endif
887#ifdef XIRCOM
888 retval = usb_serial_register(&xircom_pgs_fake_device);
889 if (retval)
890 goto failed_xircom_register;
891#endif
892 retval = usb_register(&keyspan_pda_driver);
893 if (retval)
894 goto failed_usb_register;
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -0700895 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
896 DRIVER_DESC "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 return 0;
Alan Cox9e70f312008-07-22 11:13:42 +0100898failed_usb_register:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899#ifdef XIRCOM
900 usb_serial_deregister(&xircom_pgs_fake_device);
901failed_xircom_register:
902#endif /* XIRCOM */
903#ifdef KEYSPAN
904 usb_serial_deregister(&keyspan_pda_fake_device);
905#endif
906#ifdef KEYSPAN
907failed_pda_fake_register:
908#endif
909 usb_serial_deregister(&keyspan_pda_device);
910failed_pda_register:
911 return retval;
912}
913
914
Alan Cox9e70f312008-07-22 11:13:42 +0100915static void __exit keyspan_pda_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916{
Alan Cox9e70f312008-07-22 11:13:42 +0100917 usb_deregister(&keyspan_pda_driver);
918 usb_serial_deregister(&keyspan_pda_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919#ifdef KEYSPAN
Alan Cox9e70f312008-07-22 11:13:42 +0100920 usb_serial_deregister(&keyspan_pda_fake_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921#endif
922#ifdef XIRCOM
Alan Cox9e70f312008-07-22 11:13:42 +0100923 usb_serial_deregister(&xircom_pgs_fake_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924#endif
925}
926
927
928module_init(keyspan_pda_init);
929module_exit(keyspan_pda_exit);
930
Alan Cox9e70f312008-07-22 11:13:42 +0100931MODULE_AUTHOR(DRIVER_AUTHOR);
932MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933MODULE_LICENSE("GPL");
934
935module_param(debug, bool, S_IRUGO | S_IWUSR);
936MODULE_PARM_DESC(debug, "Debug enabled or not");
937