blob: 427d377c9d3eaccea583d02d5b3f4aa30e7875ef [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;
Oliver Neukum63832512009-10-07 10:50:23 +0200293 if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 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;
Johan Hovoldca65d252009-12-28 23:01:51 +0100432 u8 *data;
433
434 data = kmalloc(1, GFP_KERNEL);
435 if (!data)
436 return -ENOMEM;
437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
439 3, /* get pins */
440 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
Johan Hovoldca65d252009-12-28 23:01:51 +0100441 0, 0, data, 1, 2000);
Benny Halevy3b36a8f2008-06-27 12:22:32 +0300442 if (rc >= 0)
Johan Hovoldca65d252009-12-28 23:01:51 +0100443 *value = *data;
444
445 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 return rc;
447}
448
449
450static int keyspan_pda_set_modem_info(struct usb_serial *serial,
451 unsigned char value)
452{
453 int rc;
454 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
455 3, /* set pins */
456 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
457 value, 0, NULL, 0, 2000);
458 return rc;
459}
460
Alan Cox95da3102008-07-22 11:09:07 +0100461static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462{
Alan Cox95da3102008-07-22 11:09:07 +0100463 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 struct usb_serial *serial = port->serial;
465 int rc;
466 unsigned char status;
467 int value;
468
469 rc = keyspan_pda_get_modem_info(serial, &status);
470 if (rc < 0)
471 return rc;
472 value =
473 ((status & (1<<7)) ? TIOCM_DTR : 0) |
474 ((status & (1<<6)) ? TIOCM_CAR : 0) |
475 ((status & (1<<5)) ? TIOCM_RNG : 0) |
476 ((status & (1<<4)) ? TIOCM_DSR : 0) |
477 ((status & (1<<3)) ? TIOCM_CTS : 0) |
478 ((status & (1<<2)) ? TIOCM_RTS : 0);
479 return value;
480}
481
Alan Cox95da3102008-07-22 11:09:07 +0100482static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 unsigned int set, unsigned int clear)
484{
Alan Cox95da3102008-07-22 11:09:07 +0100485 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 struct usb_serial *serial = port->serial;
487 int rc;
488 unsigned char status;
489
490 rc = keyspan_pda_get_modem_info(serial, &status);
491 if (rc < 0)
492 return rc;
493
494 if (set & TIOCM_RTS)
495 status |= (1<<2);
496 if (set & TIOCM_DTR)
497 status |= (1<<7);
498
499 if (clear & TIOCM_RTS)
500 status &= ~(1<<2);
501 if (clear & TIOCM_DTR)
502 status &= ~(1<<7);
503 rc = keyspan_pda_set_modem_info(serial, status);
504 return rc;
505}
506
Alan Cox95da3102008-07-22 11:09:07 +0100507static int keyspan_pda_write(struct tty_struct *tty,
508 struct usb_serial_port *port, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509{
510 struct usb_serial *serial = port->serial;
511 int request_unthrottle = 0;
512 int rc = 0;
513 struct keyspan_pda_private *priv;
514
515 priv = usb_get_serial_port_data(port);
516 /* guess how much room is left in the device's ring buffer, and if we
517 want to send more than that, check first, updating our notion of
518 what is left. If our write will result in no room left, ask the
519 device to give us an interrupt when the room available rises above
520 a threshold, and hold off all writers (eventually, those using
521 select() or poll() too) until we receive that unthrottle interrupt.
522 Block if we can't write anything at all, otherwise write as much as
523 we can. */
Alan Cox9e70f312008-07-22 11:13:42 +0100524 dbg("keyspan_pda_write(%d)", count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (count == 0) {
526 dbg(" write request of 0 bytes");
Alan Cox9e70f312008-07-22 11:13:42 +0100527 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 }
529
530 /* we might block because of:
531 the TX urb is in-flight (wait until it completes)
532 the device is full (wait until it says there is room)
533 */
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200534 spin_lock_bh(&port->lock);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700535 if (port->write_urb_busy || priv->tx_throttled) {
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200536 spin_unlock_bh(&port->lock);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700537 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 }
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700539 port->write_urb_busy = 1;
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200540 spin_unlock_bh(&port->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
542 /* At this point the URB is in our control, nobody else can submit it
543 again (the only sudden transition was the one from EINPROGRESS to
544 finished). Also, the tx process is not throttled. So we are
545 ready to write. */
546
547 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
548
549 /* Check if we might overrun the Tx buffer. If so, ask the
550 device how much room it really has. This is done only on
551 scheduler time, since usb_control_msg() sleeps. */
552 if (count > priv->tx_room && !in_interrupt()) {
Johan Hovoldca65d252009-12-28 23:01:51 +0100553 u8 *room;
554
555 room = kmalloc(1, GFP_KERNEL);
556 if (!room) {
557 rc = -ENOMEM;
558 goto exit;
559 }
560
Alan Cox9e70f312008-07-22 11:13:42 +0100561 rc = usb_control_msg(serial->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 usb_rcvctrlpipe(serial->dev, 0),
563 6, /* write_room */
564 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
565 | USB_DIR_IN,
566 0, /* value: 0 means "remaining room" */
567 0, /* index */
Johan Hovoldca65d252009-12-28 23:01:51 +0100568 room,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 1,
570 2000);
Johan Hovoldca65d252009-12-28 23:01:51 +0100571 if (rc > 0) {
572 dbg(" roomquery says %d", *room);
573 priv->tx_room = *room;
574 }
575 kfree(room);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 if (rc < 0) {
577 dbg(" roomquery failed");
578 goto exit;
579 }
580 if (rc == 0) {
581 dbg(" roomquery returned 0 bytes");
582 rc = -EIO; /* device didn't return any data */
583 goto exit;
584 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 }
586 if (count > priv->tx_room) {
587 /* we're about to completely fill the Tx buffer, so
588 we'll be throttled afterwards. */
589 count = priv->tx_room;
590 request_unthrottle = 1;
591 }
592
593 if (count) {
594 /* now transfer data */
Alan Cox9e70f312008-07-22 11:13:42 +0100595 memcpy(port->write_urb->transfer_buffer, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 /* send the data out the bulk port */
597 port->write_urb->transfer_buffer_length = count;
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700598
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 priv->tx_room -= count;
600
601 port->write_urb->dev = port->serial->dev;
602 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
603 if (rc) {
604 dbg(" usb_submit_urb(write bulk) failed");
605 goto exit;
606 }
Alan Cox9e70f312008-07-22 11:13:42 +0100607 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 /* There wasn't any room left, so we are throttled until
609 the buffer empties a bit */
610 request_unthrottle = 1;
611 }
612
613 if (request_unthrottle) {
614 priv->tx_throttled = 1; /* block writers */
615 schedule_work(&priv->unthrottle_work);
616 }
617
618 rc = count;
619exit:
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700620 if (rc < 0)
621 port->write_urb_busy = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 return rc;
623}
624
625
Alan Cox9e70f312008-07-22 11:13:42 +0100626static void keyspan_pda_write_bulk_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627{
Ming Leicdc97792008-02-24 18:41:47 +0800628 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 struct keyspan_pda_private *priv;
630
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700631 port->write_urb_busy = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 priv = usb_get_serial_port_data(port);
633
634 /* queue up a wakeup at scheduler time */
635 schedule_work(&priv->wakeup_work);
636}
637
638
Alan Cox95da3102008-07-22 11:09:07 +0100639static int keyspan_pda_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640{
Alan Cox95da3102008-07-22 11:09:07 +0100641 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 struct keyspan_pda_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 priv = usb_get_serial_port_data(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 /* used by n_tty.c for processing of tabs and such. Giving it our
645 conservative guess is probably good enough, but needs testing by
646 running a console through the device. */
Alan Cox9e70f312008-07-22 11:13:42 +0100647 return priv->tx_room;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648}
649
650
Alan Cox95da3102008-07-22 11:09:07 +0100651static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652{
Alan Cox95da3102008-07-22 11:09:07 +0100653 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 struct keyspan_pda_private *priv;
Alan Coxa5b6f602008-04-08 17:16:06 +0100655 unsigned long flags;
656 int ret = 0;
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700657
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 priv = usb_get_serial_port_data(port);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 /* when throttled, return at least WAKEUP_CHARS to tell select() (via
661 n_tty.c:normal_poll() ) that we're not writeable. */
Alan Coxa5b6f602008-04-08 17:16:06 +0100662
663 spin_lock_irqsave(&port->lock, flags);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700664 if (port->write_urb_busy || priv->tx_throttled)
Alan Coxa5b6f602008-04-08 17:16:06 +0100665 ret = 256;
666 spin_unlock_irqrestore(&port->lock, flags);
667 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668}
669
670
Alan Cox335f8512009-06-11 12:26:29 +0100671static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
672{
673 struct usb_serial *serial = port->serial;
674
675 if (serial->dev) {
676 if (on)
677 keyspan_pda_set_modem_info(serial, (1<<7) | (1<< 2));
678 else
679 keyspan_pda_set_modem_info(serial, 0);
680 }
681}
682
683static int keyspan_pda_carrier_raised(struct usb_serial_port *port)
684{
685 struct usb_serial *serial = port->serial;
686 unsigned char modembits;
687
688 /* If we can read the modem status and the DCD is low then
689 carrier is not raised yet */
690 if (keyspan_pda_get_modem_info(serial, &modembits) >= 0) {
691 if (!(modembits & (1>>6)))
692 return 0;
693 }
694 /* Carrier raised, or we failed (eg disconnected) so
695 progress accordingly */
696 return 1;
697}
698
699
Alan Cox95da3102008-07-22 11:09:07 +0100700static int keyspan_pda_open(struct tty_struct *tty,
Alan Coxa509a7e2009-09-19 13:13:26 -0700701 struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702{
703 struct usb_serial *serial = port->serial;
Johan Hovoldca65d252009-12-28 23:01:51 +0100704 u8 *room;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 int rc = 0;
706 struct keyspan_pda_private *priv;
707
708 /* find out how much room is in the Tx ring */
Johan Hovoldca65d252009-12-28 23:01:51 +0100709 room = kmalloc(1, GFP_KERNEL);
710 if (!room)
711 return -ENOMEM;
712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
714 6, /* write_room */
715 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
716 | USB_DIR_IN,
717 0, /* value */
718 0, /* index */
Johan Hovoldca65d252009-12-28 23:01:51 +0100719 room,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 1,
721 2000);
722 if (rc < 0) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800723 dbg("%s - roomquery failed", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 goto error;
725 }
726 if (rc == 0) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800727 dbg("%s - roomquery returned 0 bytes", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 rc = -EIO;
729 goto error;
730 }
731 priv = usb_get_serial_port_data(port);
Johan Hovoldca65d252009-12-28 23:01:51 +0100732 priv->tx_room = *room;
733 priv->tx_throttled = *room ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 /*Start reading from the device*/
736 port->interrupt_in_urb->dev = serial->dev;
737 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
738 if (rc) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800739 dbg("%s - usb_submit_urb(read int) failed", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 goto error;
741 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742error:
Johan Hovoldca65d252009-12-28 23:01:51 +0100743 kfree(room);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 return rc;
745}
Alan Cox335f8512009-06-11 12:26:29 +0100746static void keyspan_pda_close(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747{
748 struct usb_serial *serial = port->serial;
749
750 if (serial->dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 /* shutdown our bulk reads and writes */
752 usb_kill_urb(port->write_urb);
753 usb_kill_urb(port->interrupt_in_urb);
754 }
755}
756
757
758/* download the firmware to a "fake" device (pre-renumeration) */
Alan Cox9e70f312008-07-22 11:13:42 +0100759static int keyspan_pda_fake_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760{
761 int response;
David Woodhouse3edbf982008-05-30 15:15:13 +0300762 const char *fw_name;
763 const struct ihex_binrec *record;
764 const struct firmware *fw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
766 /* download the firmware here ... */
767 response = ezusb_set_reset(serial, 1);
768
David Woodhouse3edbf982008-05-30 15:15:13 +0300769 if (0) { ; }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770#ifdef KEYSPAN
David Woodhouse3edbf982008-05-30 15:15:13 +0300771 else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
772 fw_name = "keyspan_pda/keyspan_pda.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773#endif
774#ifdef XIRCOM
David Woodhouse3edbf982008-05-30 15:15:13 +0300775 else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
776 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
777 fw_name = "keyspan_pda/xircom_pgs.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778#endif
David Woodhouse3edbf982008-05-30 15:15:13 +0300779 else {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700780 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
781 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 return -ENODEV;
783 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300784 if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700785 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
786 fw_name);
David Woodhouse3edbf982008-05-30 15:15:13 +0300787 return -ENOENT;
788 }
789 record = (const struct ihex_binrec *)fw->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
David Woodhouse3edbf982008-05-30 15:15:13 +0300791 while (record) {
792 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 (unsigned char *)record->data,
David Woodhouse3edbf982008-05-30 15:15:13 +0300794 be16_to_cpu(record->len), 0xa0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 if (response < 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700796 dev_err(&serial->dev->dev, "ezusb_writememory failed "
797 "for Keyspan PDA firmware (%d %04X %p %d)\n",
798 response, be32_to_cpu(record->addr),
799 record->data, be16_to_cpu(record->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 break;
801 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300802 record = ihex_next_binrec(record);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300804 release_firmware(fw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 /* bring device out of reset. Renumeration will occur in a moment
806 and the new device will bind to the real driver */
807 response = ezusb_set_reset(serial, 0);
808
809 /* we want this device to fail to have a driver assigned to it. */
Alan Cox9e70f312008-07-22 11:13:42 +0100810 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811}
812
Alan Cox9e70f312008-07-22 11:13:42 +0100813static int keyspan_pda_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814{
815
816 struct keyspan_pda_private *priv;
817
818 /* allocate the private data structures for all ports. Well, for all
819 one ports. */
820
821 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
822 if (!priv)
Alan Cox9e70f312008-07-22 11:13:42 +0100823 return 1; /* error */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 usb_set_serial_port_data(serial->port[0], priv);
825 init_waitqueue_head(&serial->port[0]->write_wait);
David Howellsc4028952006-11-22 14:57:56 +0000826 INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
827 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
828 priv->serial = serial;
829 priv->port = serial->port[0];
Alan Cox9e70f312008-07-22 11:13:42 +0100830 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831}
832
Alan Sternf9c99bb2009-06-02 11:53:55 -0400833static void keyspan_pda_release(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800835 dbg("%s", __func__);
Alan Cox9e70f312008-07-22 11:13:42 +0100836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 kfree(usb_get_serial_port_data(serial->port[0]));
838}
839
840#ifdef KEYSPAN
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700841static struct usb_serial_driver keyspan_pda_fake_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700842 .driver = {
843 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700844 .name = "keyspan_pda_pre",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700845 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700846 .description = "Keyspan PDA - (prerenumeration)",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100847 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 .id_table = id_table_fake,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 .num_ports = 1,
850 .attach = keyspan_pda_fake_startup,
851};
852#endif
853
854#ifdef XIRCOM
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700855static struct usb_serial_driver xircom_pgs_fake_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700856 .driver = {
857 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700858 .name = "xircom_no_firm",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700859 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700860 .description = "Xircom / Entregra PGS - (prerenumeration)",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100861 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 .id_table = id_table_fake_xircom,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 .num_ports = 1,
864 .attach = keyspan_pda_fake_startup,
865};
866#endif
867
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700868static struct usb_serial_driver keyspan_pda_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700869 .driver = {
870 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700871 .name = "keyspan_pda",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700872 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700873 .description = "Keyspan PDA",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100874 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 .id_table = id_table_std,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 .num_ports = 1,
Alan Cox335f8512009-06-11 12:26:29 +0100877 .dtr_rts = keyspan_pda_dtr_rts,
878 .carrier_raised = keyspan_pda_carrier_raised,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 .open = keyspan_pda_open,
880 .close = keyspan_pda_close,
881 .write = keyspan_pda_write,
882 .write_room = keyspan_pda_write_room,
883 .write_bulk_callback = keyspan_pda_write_bulk_callback,
884 .read_int_callback = keyspan_pda_rx_interrupt,
885 .chars_in_buffer = keyspan_pda_chars_in_buffer,
886 .throttle = keyspan_pda_rx_throttle,
887 .unthrottle = keyspan_pda_rx_unthrottle,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 .set_termios = keyspan_pda_set_termios,
889 .break_ctl = keyspan_pda_break_ctl,
890 .tiocmget = keyspan_pda_tiocmget,
891 .tiocmset = keyspan_pda_tiocmset,
892 .attach = keyspan_pda_startup,
Alan Sternf9c99bb2009-06-02 11:53:55 -0400893 .release = keyspan_pda_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894};
895
896
Alan Cox9e70f312008-07-22 11:13:42 +0100897static int __init keyspan_pda_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898{
899 int retval;
900 retval = usb_serial_register(&keyspan_pda_device);
901 if (retval)
902 goto failed_pda_register;
903#ifdef KEYSPAN
904 retval = usb_serial_register(&keyspan_pda_fake_device);
905 if (retval)
906 goto failed_pda_fake_register;
907#endif
908#ifdef XIRCOM
909 retval = usb_serial_register(&xircom_pgs_fake_device);
910 if (retval)
911 goto failed_xircom_register;
912#endif
913 retval = usb_register(&keyspan_pda_driver);
914 if (retval)
915 goto failed_usb_register;
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -0700916 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
917 DRIVER_DESC "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 return 0;
Alan Cox9e70f312008-07-22 11:13:42 +0100919failed_usb_register:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920#ifdef XIRCOM
921 usb_serial_deregister(&xircom_pgs_fake_device);
922failed_xircom_register:
923#endif /* XIRCOM */
924#ifdef KEYSPAN
925 usb_serial_deregister(&keyspan_pda_fake_device);
926#endif
927#ifdef KEYSPAN
928failed_pda_fake_register:
929#endif
930 usb_serial_deregister(&keyspan_pda_device);
931failed_pda_register:
932 return retval;
933}
934
935
Alan Cox9e70f312008-07-22 11:13:42 +0100936static void __exit keyspan_pda_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937{
Alan Cox9e70f312008-07-22 11:13:42 +0100938 usb_deregister(&keyspan_pda_driver);
939 usb_serial_deregister(&keyspan_pda_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940#ifdef KEYSPAN
Alan Cox9e70f312008-07-22 11:13:42 +0100941 usb_serial_deregister(&keyspan_pda_fake_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942#endif
943#ifdef XIRCOM
Alan Cox9e70f312008-07-22 11:13:42 +0100944 usb_serial_deregister(&xircom_pgs_fake_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945#endif
946}
947
948
949module_init(keyspan_pda_init);
950module_exit(keyspan_pda_exit);
951
Alan Cox9e70f312008-07-22 11:13:42 +0100952MODULE_AUTHOR(DRIVER_AUTHOR);
953MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954MODULE_LICENSE("GPL");
955
956module_param(debug, bool, S_IRUGO | S_IWUSR);
957MODULE_PARM_DESC(debug, "Debug enabled or not");
958