blob: 49ad2baf77cd78b94e98106ed583d20dd1606cba [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
Németh Márton7d40d7e2010-01-10 15:34:24 +0100128static const struct usb_device_id id_table_combined[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129#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
Németh Márton7d40d7e2010-01-10 15:34:24 +0100150static const struct usb_device_id id_table_std[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
152 { } /* Terminating entry */
153};
154
155#ifdef KEYSPAN
Németh Márton7d40d7e2010-01-10 15:34:24 +0100156static const struct usb_device_id id_table_fake[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
158 { } /* Terminating entry */
159};
160#endif
161
162#ifdef XIRCOM
Németh Márton7d40d7e2010-01-10 15:34:24 +0100163static const 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");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295}
296
297
Alan Cox9e70f312008-07-22 11:13:42 +0100298static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299{
300 int rc;
301 int bindex;
302
Alan Cox9e70f312008-07-22 11:13:42 +0100303 switch (baud) {
304 case 110:
305 bindex = 0;
306 break;
307 case 300:
308 bindex = 1;
309 break;
310 case 1200:
311 bindex = 2;
312 break;
313 case 2400:
314 bindex = 3;
315 break;
316 case 4800:
317 bindex = 4;
318 break;
319 case 9600:
320 bindex = 5;
321 break;
322 case 19200:
323 bindex = 6;
324 break;
325 case 38400:
326 bindex = 7;
327 break;
328 case 57600:
329 bindex = 8;
330 break;
331 case 115200:
332 bindex = 9;
333 break;
334 default:
335 bindex = 5; /* Default to 9600 */
336 baud = 9600;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 }
338
339 /* rather than figure out how to sleep while waiting for this
340 to complete, I just use the "legacy" API. */
341 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
342 0, /* set baud */
Alan Cox9e70f312008-07-22 11:13:42 +0100343 USB_TYPE_VENDOR
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 | USB_RECIP_INTERFACE
345 | USB_DIR_OUT, /* type */
346 bindex, /* value */
347 0, /* index */
348 NULL, /* &data */
349 0, /* size */
350 2000); /* timeout */
Alan Coxe7806e32007-12-13 16:15:28 -0800351 if (rc < 0)
352 return 0;
353 return baud;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354}
355
356
Alan Cox95da3102008-07-22 11:09:07 +0100357static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
Alan Cox95da3102008-07-22 11:09:07 +0100359 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 struct usb_serial *serial = port->serial;
361 int value;
362 int result;
363
364 if (break_state == -1)
365 value = 1; /* start break */
366 else
367 value = 0; /* clear break */
368 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
Alan Cox9e70f312008-07-22 11:13:42 +0100369 4, /* set break */
370 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
371 value, 0, NULL, 0, 2000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 if (result < 0)
Alan Cox9e70f312008-07-22 11:13:42 +0100373 dbg("%s - error %d from usb_control_msg",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800374 __func__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 /* there is something funky about this.. the TCSBRK that 'cu' performs
376 ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
377 seconds apart, but it feels like the break sent isn't as long as it
378 is on /dev/ttyS0 */
379}
380
381
Alan Cox95da3102008-07-22 11:09:07 +0100382static void keyspan_pda_set_termios(struct tty_struct *tty,
383 struct usb_serial_port *port, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384{
385 struct usb_serial *serial = port->serial;
Alan Coxe7806e32007-12-13 16:15:28 -0800386 speed_t speed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
388 /* cflag specifies lots of stuff: number of stop bits, parity, number
389 of data bits, baud. What can the device actually handle?:
390 CSTOPB (1 stop bit or 2)
391 PARENB (parity)
392 CSIZE (5bit .. 8bit)
393 There is minimal hw support for parity (a PSW bit seems to hold the
394 parity of whatever is in the accumulator). The UART either deals
395 with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
396 1 special, stop). So, with firmware changes, we could do:
397 8N1: 10 bit
398 8N2: 11 bit, extra bit always (mark?)
399 8[EOMS]1: 11 bit, extra bit is parity
400 7[EOMS]1: 10 bit, b0/b7 is parity
401 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
402
403 HW flow control is dictated by the tty->termios->c_cflags & CRTSCTS
404 bit.
405
406 For now, just do baud. */
407
Alan Cox95da3102008-07-22 11:09:07 +0100408 speed = tty_get_baud_rate(tty);
Alan Coxe7806e32007-12-13 16:15:28 -0800409 speed = keyspan_pda_setbaud(serial, speed);
410
411 if (speed == 0) {
412 dbg("can't handle requested baud rate");
413 /* It hasn't changed so.. */
414 speed = tty_termios_baud_rate(old_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 }
Alan Coxe7806e32007-12-13 16:15:28 -0800416 /* Only speed can change so copy the old h/w parameters
417 then encode the new speed */
Alan Cox95da3102008-07-22 11:09:07 +0100418 tty_termios_copy_hw(tty->termios, old_termios);
419 tty_encode_baud_rate(tty, speed, speed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420}
421
422
423/* modem control pins: DTR and RTS are outputs and can be controlled.
424 DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
425 read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
426
427static int keyspan_pda_get_modem_info(struct usb_serial *serial,
428 unsigned char *value)
429{
430 int rc;
Johan Hovoldca65d252009-12-28 23:01:51 +0100431 u8 *data;
432
433 data = kmalloc(1, GFP_KERNEL);
434 if (!data)
435 return -ENOMEM;
436
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
438 3, /* get pins */
439 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
Johan Hovoldca65d252009-12-28 23:01:51 +0100440 0, 0, data, 1, 2000);
Benny Halevy3b36a8f2008-06-27 12:22:32 +0300441 if (rc >= 0)
Johan Hovoldca65d252009-12-28 23:01:51 +0100442 *value = *data;
443
444 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 return rc;
446}
447
448
449static int keyspan_pda_set_modem_info(struct usb_serial *serial,
450 unsigned char value)
451{
452 int rc;
453 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
454 3, /* set pins */
455 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
456 value, 0, NULL, 0, 2000);
457 return rc;
458}
459
Alan Cox60b33c12011-02-14 16:26:14 +0000460static int keyspan_pda_tiocmget(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461{
Alan Cox95da3102008-07-22 11:09:07 +0100462 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 struct usb_serial *serial = port->serial;
464 int rc;
465 unsigned char status;
466 int value;
467
468 rc = keyspan_pda_get_modem_info(serial, &status);
469 if (rc < 0)
470 return rc;
471 value =
472 ((status & (1<<7)) ? TIOCM_DTR : 0) |
473 ((status & (1<<6)) ? TIOCM_CAR : 0) |
474 ((status & (1<<5)) ? TIOCM_RNG : 0) |
475 ((status & (1<<4)) ? TIOCM_DSR : 0) |
476 ((status & (1<<3)) ? TIOCM_CTS : 0) |
477 ((status & (1<<2)) ? TIOCM_RTS : 0);
478 return value;
479}
480
Alan Cox95da3102008-07-22 11:09:07 +0100481static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 unsigned int set, unsigned int clear)
483{
Alan Cox95da3102008-07-22 11:09:07 +0100484 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 struct usb_serial *serial = port->serial;
486 int rc;
487 unsigned char status;
488
489 rc = keyspan_pda_get_modem_info(serial, &status);
490 if (rc < 0)
491 return rc;
492
493 if (set & TIOCM_RTS)
494 status |= (1<<2);
495 if (set & TIOCM_DTR)
496 status |= (1<<7);
497
498 if (clear & TIOCM_RTS)
499 status &= ~(1<<2);
500 if (clear & TIOCM_DTR)
501 status &= ~(1<<7);
502 rc = keyspan_pda_set_modem_info(serial, status);
503 return rc;
504}
505
Alan Cox95da3102008-07-22 11:09:07 +0100506static int keyspan_pda_write(struct tty_struct *tty,
507 struct usb_serial_port *port, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508{
509 struct usb_serial *serial = port->serial;
510 int request_unthrottle = 0;
511 int rc = 0;
512 struct keyspan_pda_private *priv;
513
514 priv = usb_get_serial_port_data(port);
515 /* guess how much room is left in the device's ring buffer, and if we
516 want to send more than that, check first, updating our notion of
517 what is left. If our write will result in no room left, ask the
518 device to give us an interrupt when the room available rises above
519 a threshold, and hold off all writers (eventually, those using
520 select() or poll() too) until we receive that unthrottle interrupt.
521 Block if we can't write anything at all, otherwise write as much as
522 we can. */
Alan Cox9e70f312008-07-22 11:13:42 +0100523 dbg("keyspan_pda_write(%d)", count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 if (count == 0) {
525 dbg(" write request of 0 bytes");
Alan Cox9e70f312008-07-22 11:13:42 +0100526 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 }
528
529 /* we might block because of:
530 the TX urb is in-flight (wait until it completes)
531 the device is full (wait until it says there is room)
532 */
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200533 spin_lock_bh(&port->lock);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700534 if (port->write_urb_busy || priv->tx_throttled) {
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200535 spin_unlock_bh(&port->lock);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700536 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 }
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700538 port->write_urb_busy = 1;
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200539 spin_unlock_bh(&port->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
541 /* At this point the URB is in our control, nobody else can submit it
542 again (the only sudden transition was the one from EINPROGRESS to
543 finished). Also, the tx process is not throttled. So we are
544 ready to write. */
545
546 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
547
548 /* Check if we might overrun the Tx buffer. If so, ask the
549 device how much room it really has. This is done only on
550 scheduler time, since usb_control_msg() sleeps. */
551 if (count > priv->tx_room && !in_interrupt()) {
Johan Hovoldca65d252009-12-28 23:01:51 +0100552 u8 *room;
553
554 room = kmalloc(1, GFP_KERNEL);
555 if (!room) {
556 rc = -ENOMEM;
557 goto exit;
558 }
559
Alan Cox9e70f312008-07-22 11:13:42 +0100560 rc = usb_control_msg(serial->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 usb_rcvctrlpipe(serial->dev, 0),
562 6, /* write_room */
563 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
564 | USB_DIR_IN,
565 0, /* value: 0 means "remaining room" */
566 0, /* index */
Johan Hovoldca65d252009-12-28 23:01:51 +0100567 room,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 1,
569 2000);
Johan Hovoldca65d252009-12-28 23:01:51 +0100570 if (rc > 0) {
571 dbg(" roomquery says %d", *room);
572 priv->tx_room = *room;
573 }
574 kfree(room);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 if (rc < 0) {
576 dbg(" roomquery failed");
577 goto exit;
578 }
579 if (rc == 0) {
580 dbg(" roomquery returned 0 bytes");
581 rc = -EIO; /* device didn't return any data */
582 goto exit;
583 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 }
585 if (count > priv->tx_room) {
586 /* we're about to completely fill the Tx buffer, so
587 we'll be throttled afterwards. */
588 count = priv->tx_room;
589 request_unthrottle = 1;
590 }
591
592 if (count) {
593 /* now transfer data */
Alan Cox9e70f312008-07-22 11:13:42 +0100594 memcpy(port->write_urb->transfer_buffer, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 /* send the data out the bulk port */
596 port->write_urb->transfer_buffer_length = count;
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700597
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 priv->tx_room -= count;
599
600 port->write_urb->dev = port->serial->dev;
601 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
602 if (rc) {
603 dbg(" usb_submit_urb(write bulk) failed");
604 goto exit;
605 }
Alan Cox9e70f312008-07-22 11:13:42 +0100606 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 /* There wasn't any room left, so we are throttled until
608 the buffer empties a bit */
609 request_unthrottle = 1;
610 }
611
612 if (request_unthrottle) {
613 priv->tx_throttled = 1; /* block writers */
614 schedule_work(&priv->unthrottle_work);
615 }
616
617 rc = count;
618exit:
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700619 if (rc < 0)
620 port->write_urb_busy = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 return rc;
622}
623
624
Alan Cox9e70f312008-07-22 11:13:42 +0100625static void keyspan_pda_write_bulk_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626{
Ming Leicdc97792008-02-24 18:41:47 +0800627 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 struct keyspan_pda_private *priv;
629
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700630 port->write_urb_busy = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 priv = usb_get_serial_port_data(port);
632
633 /* queue up a wakeup at scheduler time */
634 schedule_work(&priv->wakeup_work);
635}
636
637
Alan Cox95da3102008-07-22 11:09:07 +0100638static int keyspan_pda_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639{
Alan Cox95da3102008-07-22 11:09:07 +0100640 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 struct keyspan_pda_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 priv = usb_get_serial_port_data(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 /* used by n_tty.c for processing of tabs and such. Giving it our
644 conservative guess is probably good enough, but needs testing by
645 running a console through the device. */
Alan Cox9e70f312008-07-22 11:13:42 +0100646 return priv->tx_room;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647}
648
649
Alan Cox95da3102008-07-22 11:09:07 +0100650static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651{
Alan Cox95da3102008-07-22 11:09:07 +0100652 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 struct keyspan_pda_private *priv;
Alan Coxa5b6f602008-04-08 17:16:06 +0100654 unsigned long flags;
655 int ret = 0;
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700656
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 priv = usb_get_serial_port_data(port);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700658
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 /* when throttled, return at least WAKEUP_CHARS to tell select() (via
660 n_tty.c:normal_poll() ) that we're not writeable. */
Alan Coxa5b6f602008-04-08 17:16:06 +0100661
662 spin_lock_irqsave(&port->lock, flags);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700663 if (port->write_urb_busy || priv->tx_throttled)
Alan Coxa5b6f602008-04-08 17:16:06 +0100664 ret = 256;
665 spin_unlock_irqrestore(&port->lock, flags);
666 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667}
668
669
Alan Cox335f8512009-06-11 12:26:29 +0100670static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
671{
672 struct usb_serial *serial = port->serial;
673
674 if (serial->dev) {
675 if (on)
676 keyspan_pda_set_modem_info(serial, (1<<7) | (1<< 2));
677 else
678 keyspan_pda_set_modem_info(serial, 0);
679 }
680}
681
Alan Cox335f8512009-06-11 12:26:29 +0100682
Alan Cox95da3102008-07-22 11:09:07 +0100683static int keyspan_pda_open(struct tty_struct *tty,
Alan Coxa509a7e2009-09-19 13:13:26 -0700684 struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685{
686 struct usb_serial *serial = port->serial;
Johan Hovoldca65d252009-12-28 23:01:51 +0100687 u8 *room;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 int rc = 0;
689 struct keyspan_pda_private *priv;
690
691 /* find out how much room is in the Tx ring */
Johan Hovoldca65d252009-12-28 23:01:51 +0100692 room = kmalloc(1, GFP_KERNEL);
693 if (!room)
694 return -ENOMEM;
695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
697 6, /* write_room */
698 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
699 | USB_DIR_IN,
700 0, /* value */
701 0, /* index */
Johan Hovoldca65d252009-12-28 23:01:51 +0100702 room,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 1,
704 2000);
705 if (rc < 0) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800706 dbg("%s - roomquery failed", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 goto error;
708 }
709 if (rc == 0) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800710 dbg("%s - roomquery returned 0 bytes", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 rc = -EIO;
712 goto error;
713 }
714 priv = usb_get_serial_port_data(port);
Johan Hovoldca65d252009-12-28 23:01:51 +0100715 priv->tx_room = *room;
716 priv->tx_throttled = *room ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 /*Start reading from the device*/
719 port->interrupt_in_urb->dev = serial->dev;
720 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
721 if (rc) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800722 dbg("%s - usb_submit_urb(read int) failed", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 goto error;
724 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725error:
Johan Hovoldca65d252009-12-28 23:01:51 +0100726 kfree(room);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 return rc;
728}
Alan Cox335f8512009-06-11 12:26:29 +0100729static void keyspan_pda_close(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730{
731 struct usb_serial *serial = port->serial;
732
733 if (serial->dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 /* shutdown our bulk reads and writes */
735 usb_kill_urb(port->write_urb);
736 usb_kill_urb(port->interrupt_in_urb);
737 }
738}
739
740
741/* download the firmware to a "fake" device (pre-renumeration) */
Alan Cox9e70f312008-07-22 11:13:42 +0100742static int keyspan_pda_fake_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743{
744 int response;
David Woodhouse3edbf982008-05-30 15:15:13 +0300745 const char *fw_name;
746 const struct ihex_binrec *record;
747 const struct firmware *fw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
749 /* download the firmware here ... */
750 response = ezusb_set_reset(serial, 1);
751
David Woodhouse3edbf982008-05-30 15:15:13 +0300752 if (0) { ; }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753#ifdef KEYSPAN
David Woodhouse3edbf982008-05-30 15:15:13 +0300754 else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
755 fw_name = "keyspan_pda/keyspan_pda.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756#endif
757#ifdef XIRCOM
David Woodhouse3edbf982008-05-30 15:15:13 +0300758 else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
759 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
760 fw_name = "keyspan_pda/xircom_pgs.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761#endif
David Woodhouse3edbf982008-05-30 15:15:13 +0300762 else {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700763 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
764 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 return -ENODEV;
766 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300767 if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700768 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
769 fw_name);
David Woodhouse3edbf982008-05-30 15:15:13 +0300770 return -ENOENT;
771 }
772 record = (const struct ihex_binrec *)fw->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
David Woodhouse3edbf982008-05-30 15:15:13 +0300774 while (record) {
775 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 (unsigned char *)record->data,
David Woodhouse3edbf982008-05-30 15:15:13 +0300777 be16_to_cpu(record->len), 0xa0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 if (response < 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700779 dev_err(&serial->dev->dev, "ezusb_writememory failed "
780 "for Keyspan PDA firmware (%d %04X %p %d)\n",
781 response, be32_to_cpu(record->addr),
782 record->data, be16_to_cpu(record->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 break;
784 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300785 record = ihex_next_binrec(record);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300787 release_firmware(fw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 /* bring device out of reset. Renumeration will occur in a moment
789 and the new device will bind to the real driver */
790 response = ezusb_set_reset(serial, 0);
791
792 /* we want this device to fail to have a driver assigned to it. */
Alan Cox9e70f312008-07-22 11:13:42 +0100793 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794}
795
Ben Hutchingse6c4ef92010-01-13 23:34:18 +0000796#ifdef KEYSPAN
797MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
798#endif
799#ifdef XIRCOM
800MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
801#endif
802
Alan Cox9e70f312008-07-22 11:13:42 +0100803static int keyspan_pda_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804{
805
806 struct keyspan_pda_private *priv;
807
808 /* allocate the private data structures for all ports. Well, for all
809 one ports. */
810
811 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
812 if (!priv)
Alan Cox9e70f312008-07-22 11:13:42 +0100813 return 1; /* error */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 usb_set_serial_port_data(serial->port[0], priv);
815 init_waitqueue_head(&serial->port[0]->write_wait);
David Howellsc4028952006-11-22 14:57:56 +0000816 INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
817 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
818 priv->serial = serial;
819 priv->port = serial->port[0];
Alan Cox9e70f312008-07-22 11:13:42 +0100820 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821}
822
Alan Sternf9c99bb2009-06-02 11:53:55 -0400823static void keyspan_pda_release(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800825 dbg("%s", __func__);
Alan Cox9e70f312008-07-22 11:13:42 +0100826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 kfree(usb_get_serial_port_data(serial->port[0]));
828}
829
830#ifdef KEYSPAN
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700831static struct usb_serial_driver keyspan_pda_fake_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700832 .driver = {
833 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700834 .name = "keyspan_pda_pre",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700835 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700836 .description = "Keyspan PDA - (prerenumeration)",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100837 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 .id_table = id_table_fake,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 .num_ports = 1,
840 .attach = keyspan_pda_fake_startup,
841};
842#endif
843
844#ifdef XIRCOM
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700845static struct usb_serial_driver xircom_pgs_fake_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700846 .driver = {
847 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700848 .name = "xircom_no_firm",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700849 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700850 .description = "Xircom / Entregra PGS - (prerenumeration)",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100851 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 .id_table = id_table_fake_xircom,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 .num_ports = 1,
854 .attach = keyspan_pda_fake_startup,
855};
856#endif
857
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700858static struct usb_serial_driver keyspan_pda_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700859 .driver = {
860 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700861 .name = "keyspan_pda",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700862 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700863 .description = "Keyspan PDA",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100864 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 .id_table = id_table_std,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 .num_ports = 1,
Alan Cox335f8512009-06-11 12:26:29 +0100867 .dtr_rts = keyspan_pda_dtr_rts,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 .open = keyspan_pda_open,
869 .close = keyspan_pda_close,
870 .write = keyspan_pda_write,
871 .write_room = keyspan_pda_write_room,
872 .write_bulk_callback = keyspan_pda_write_bulk_callback,
873 .read_int_callback = keyspan_pda_rx_interrupt,
874 .chars_in_buffer = keyspan_pda_chars_in_buffer,
875 .throttle = keyspan_pda_rx_throttle,
876 .unthrottle = keyspan_pda_rx_unthrottle,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 .set_termios = keyspan_pda_set_termios,
878 .break_ctl = keyspan_pda_break_ctl,
879 .tiocmget = keyspan_pda_tiocmget,
880 .tiocmset = keyspan_pda_tiocmset,
881 .attach = keyspan_pda_startup,
Alan Sternf9c99bb2009-06-02 11:53:55 -0400882 .release = keyspan_pda_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883};
884
885
Alan Cox9e70f312008-07-22 11:13:42 +0100886static int __init keyspan_pda_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887{
888 int retval;
889 retval = usb_serial_register(&keyspan_pda_device);
890 if (retval)
891 goto failed_pda_register;
892#ifdef KEYSPAN
893 retval = usb_serial_register(&keyspan_pda_fake_device);
894 if (retval)
895 goto failed_pda_fake_register;
896#endif
897#ifdef XIRCOM
898 retval = usb_serial_register(&xircom_pgs_fake_device);
899 if (retval)
900 goto failed_xircom_register;
901#endif
902 retval = usb_register(&keyspan_pda_driver);
903 if (retval)
904 goto failed_usb_register;
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -0700905 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
906 DRIVER_DESC "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 return 0;
Alan Cox9e70f312008-07-22 11:13:42 +0100908failed_usb_register:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909#ifdef XIRCOM
910 usb_serial_deregister(&xircom_pgs_fake_device);
911failed_xircom_register:
912#endif /* XIRCOM */
913#ifdef KEYSPAN
914 usb_serial_deregister(&keyspan_pda_fake_device);
915#endif
916#ifdef KEYSPAN
917failed_pda_fake_register:
918#endif
919 usb_serial_deregister(&keyspan_pda_device);
920failed_pda_register:
921 return retval;
922}
923
924
Alan Cox9e70f312008-07-22 11:13:42 +0100925static void __exit keyspan_pda_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926{
Alan Cox9e70f312008-07-22 11:13:42 +0100927 usb_deregister(&keyspan_pda_driver);
928 usb_serial_deregister(&keyspan_pda_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929#ifdef KEYSPAN
Alan Cox9e70f312008-07-22 11:13:42 +0100930 usb_serial_deregister(&keyspan_pda_fake_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931#endif
932#ifdef XIRCOM
Alan Cox9e70f312008-07-22 11:13:42 +0100933 usb_serial_deregister(&xircom_pgs_fake_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934#endif
935}
936
937
938module_init(keyspan_pda_init);
939module_exit(keyspan_pda_exit);
940
Alan Cox9e70f312008-07-22 11:13:42 +0100941MODULE_AUTHOR(DRIVER_AUTHOR);
942MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943MODULE_LICENSE("GPL");
944
945module_param(debug, bool, S_IRUGO | S_IWUSR);
946MODULE_PARM_DESC(debug, "Debug enabled or not");
947