Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[sfrench/cifs-2.6.git] / drivers / usb / serial / option.c
1 /*
2   USB Driver for GSM modems
3
4   Copyright (C) 2005  Matthias Urlichs <smurf@smurf.noris.de>
5
6   This driver is free software; you can redistribute it and/or modify
7   it under the terms of Version 2 of the GNU General Public License as
8   published by the Free Software Foundation.
9
10   Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org>
11
12   History: see the git log.
13
14   Work sponsored by: Sigos GmbH, Germany <info@sigos.de>
15
16   This driver exists because the "normal" serial driver doesn't work too well
17   with GSM modems. Issues:
18   - data loss -- one single Receive URB is not nearly enough
19   - nonstandard flow (Option devices) control
20   - controlling the baud rate doesn't make sense
21
22   This driver is named "option" because the most common device it's
23   used for is a PC-Card (with an internal OHCI-USB interface, behind
24   which the GSM interface sits), made by Option Inc.
25
26   Some of the "one port" devices actually exhibit multiple USB instances
27   on the USB bus. This is not a bug, these ports are used for different
28   device features.
29 */
30
31 #define DRIVER_VERSION "v0.7.1"
32 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>"
33 #define DRIVER_DESC "USB Driver for GSM modems"
34
35 #include <linux/kernel.h>
36 #include <linux/jiffies.h>
37 #include <linux/errno.h>
38 #include <linux/tty.h>
39 #include <linux/tty_flip.h>
40 #include <linux/module.h>
41 #include <linux/bitops.h>
42 #include <linux/usb.h>
43 #include <linux/usb/serial.h>
44
45 /* Function prototypes */
46 static int  option_open(struct usb_serial_port *port, struct file *filp);
47 static void option_close(struct usb_serial_port *port, struct file *filp);
48 static int  option_startup(struct usb_serial *serial);
49 static void option_shutdown(struct usb_serial *serial);
50 static void option_rx_throttle(struct usb_serial_port *port);
51 static void option_rx_unthrottle(struct usb_serial_port *port);
52 static int  option_write_room(struct usb_serial_port *port);
53
54 static void option_instat_callback(struct urb *urb);
55
56 static int option_write(struct usb_serial_port *port,
57                         const unsigned char *buf, int count);
58
59 static int  option_chars_in_buffer(struct usb_serial_port *port);
60 static int  option_ioctl(struct usb_serial_port *port, struct file *file,
61                         unsigned int cmd, unsigned long arg);
62 static void option_set_termios(struct usb_serial_port *port,
63                                 struct ktermios *old);
64 static void option_break_ctl(struct usb_serial_port *port, int break_state);
65 static int  option_tiocmget(struct usb_serial_port *port, struct file *file);
66 static int  option_tiocmset(struct usb_serial_port *port, struct file *file,
67                                 unsigned int set, unsigned int clear);
68 static int  option_send_setup(struct usb_serial_port *port);
69
70 /* Vendor and product IDs */
71 #define OPTION_VENDOR_ID                        0x0AF0
72 #define OPTION_PRODUCT_COLT                     0x5000
73 #define OPTION_PRODUCT_RICOLA                   0x6000
74 #define OPTION_PRODUCT_RICOLA_LIGHT             0x6100
75 #define OPTION_PRODUCT_RICOLA_QUAD              0x6200
76 #define OPTION_PRODUCT_RICOLA_QUAD_LIGHT        0x6300
77 #define OPTION_PRODUCT_RICOLA_NDIS              0x6050
78 #define OPTION_PRODUCT_RICOLA_NDIS_LIGHT        0x6150
79 #define OPTION_PRODUCT_RICOLA_NDIS_QUAD         0x6250
80 #define OPTION_PRODUCT_RICOLA_NDIS_QUAD_LIGHT   0x6350
81 #define OPTION_PRODUCT_COBRA                    0x6500
82 #define OPTION_PRODUCT_COBRA_BUS                0x6501
83 #define OPTION_PRODUCT_VIPER                    0x6600
84 #define OPTION_PRODUCT_VIPER_BUS                0x6601
85 #define OPTION_PRODUCT_GT_MAX_READY             0x6701
86 #define OPTION_PRODUCT_GT_MAX                   0x6711
87 #define OPTION_PRODUCT_FUJI_MODEM_LIGHT         0x6721
88 #define OPTION_PRODUCT_FUJI_MODEM_GT            0x6741
89 #define OPTION_PRODUCT_FUJI_MODEM_EX            0x6761
90 #define OPTION_PRODUCT_FUJI_NETWORK_LIGHT       0x6731
91 #define OPTION_PRODUCT_FUJI_NETWORK_GT          0x6751
92 #define OPTION_PRODUCT_FUJI_NETWORK_EX          0x6771
93 #define OPTION_PRODUCT_KOI_MODEM                0x6800
94 #define OPTION_PRODUCT_KOI_NETWORK              0x6811
95 #define OPTION_PRODUCT_SCORPION_MODEM           0x6901
96 #define OPTION_PRODUCT_SCORPION_NETWORK         0x6911
97 #define OPTION_PRODUCT_ETNA_MODEM               0x7001
98 #define OPTION_PRODUCT_ETNA_NETWORK             0x7011
99 #define OPTION_PRODUCT_ETNA_MODEM_LITE          0x7021
100 #define OPTION_PRODUCT_ETNA_MODEM_GT            0x7041
101 #define OPTION_PRODUCT_ETNA_MODEM_EX            0x7061
102 #define OPTION_PRODUCT_ETNA_NETWORK_LITE        0x7031
103 #define OPTION_PRODUCT_ETNA_NETWORK_GT          0x7051
104 #define OPTION_PRODUCT_ETNA_NETWORK_EX          0x7071
105 #define OPTION_PRODUCT_ETNA_KOI_MODEM           0x7100
106 #define OPTION_PRODUCT_ETNA_KOI_NETWORK         0x7111
107
108 #define HUAWEI_VENDOR_ID                        0x12D1
109 #define HUAWEI_PRODUCT_E600                     0x1001
110 #define HUAWEI_PRODUCT_E220                     0x1003
111 #define HUAWEI_PRODUCT_E220BIS                  0x1004
112
113 #define NOVATELWIRELESS_VENDOR_ID               0x1410
114
115 /* MERLIN EVDO PRODUCTS */
116 #define NOVATELWIRELESS_PRODUCT_V640            0x1100
117 #define NOVATELWIRELESS_PRODUCT_V620            0x1110
118 #define NOVATELWIRELESS_PRODUCT_V740            0x1120
119 #define NOVATELWIRELESS_PRODUCT_V720            0x1130
120
121 /* MERLIN HSDPA/HSPA PRODUCTS */
122 #define NOVATELWIRELESS_PRODUCT_U730            0x1400
123 #define NOVATELWIRELESS_PRODUCT_U740            0x1410
124 #define NOVATELWIRELESS_PRODUCT_U870            0x1420
125 #define NOVATELWIRELESS_PRODUCT_XU870           0x1430
126 #define NOVATELWIRELESS_PRODUCT_X950D           0x1450
127
128 /* EXPEDITE PRODUCTS */
129 #define NOVATELWIRELESS_PRODUCT_EV620           0x2100
130 #define NOVATELWIRELESS_PRODUCT_ES720           0x2110
131 #define NOVATELWIRELESS_PRODUCT_E725            0x2120
132 #define NOVATELWIRELESS_PRODUCT_EU730           0x2400
133 #define NOVATELWIRELESS_PRODUCT_EU740           0x2410
134 #define NOVATELWIRELESS_PRODUCT_EU870D          0x2420
135
136 /* OVATION PRODUCTS */
137 #define NOVATELWIRELESS_PRODUCT_MC727           0x4100
138 #define NOVATELWIRELESS_PRODUCT_MC950D          0x4400
139
140 /* FUTURE NOVATEL PRODUCTS */
141 #define NOVATELWIRELESS_PRODUCT_EVDO_1          0x6000
142 #define NOVATELWIRELESS_PRODUCT_HSPA_1          0x7000
143 #define NOVATELWIRELESS_PRODUCT_EMBEDDED_1      0x8000
144 #define NOVATELWIRELESS_PRODUCT_GLOBAL_1        0x9000
145 #define NOVATELWIRELESS_PRODUCT_EVDO_2          0x6001
146 #define NOVATELWIRELESS_PRODUCT_HSPA_2          0x7001
147 #define NOVATELWIRELESS_PRODUCT_EMBEDDED_2      0x8001
148 #define NOVATELWIRELESS_PRODUCT_GLOBAL_2        0x9001
149
150 #define DELL_VENDOR_ID                          0x413C
151
152 #define KYOCERA_VENDOR_ID                       0x0c88
153 #define KYOCERA_PRODUCT_KPC680                  0x180a
154
155 #define ANYDATA_VENDOR_ID                       0x16d5
156 #define ANYDATA_PRODUCT_ADU_E100A               0x6501
157 #define ANYDATA_PRODUCT_ADU_500A                0x6502
158
159 #define AXESSTEL_VENDOR_ID                      0x1726
160 #define AXESSTEL_PRODUCT_MV110H                 0x1000
161
162 #define BANDRICH_VENDOR_ID                      0x1A8D
163 #define BANDRICH_PRODUCT_C100_1                 0x1002
164 #define BANDRICH_PRODUCT_C100_2                 0x1003
165
166 #define QUALCOMM_VENDOR_ID                      0x05C6
167
168 static struct usb_device_id option_ids[] = {
169         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
170         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
171         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_LIGHT) },
172         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD) },
173         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_QUAD_LIGHT) },
174         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS) },
175         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_LIGHT) },
176         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD) },
177         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_NDIS_QUAD_LIGHT) },
178         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) },
179         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA_BUS) },
180         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER) },
181         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_VIPER_BUS) },
182         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX_READY) },
183         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_GT_MAX) },
184         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_LIGHT) },
185         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_GT) },
186         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_MODEM_EX) },
187         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_LIGHT) },
188         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_GT) },
189         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUJI_NETWORK_EX) },
190         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_MODEM) },
191         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_KOI_NETWORK) },
192         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_MODEM) },
193         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_SCORPION_NETWORK) },
194         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM) },
195         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK) },
196         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_LITE) },
197         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_GT) },
198         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_MODEM_EX) },
199         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_LITE) },
200         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_GT) },
201         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_EX) },
202         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_MODEM) },
203         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_NETWORK) },
204         { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
205         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220, 0xff, 0xff, 0xff) },
206         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220BIS, 0xff, 0xff, 0xff) },
207         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) }, /* Novatel Merlin V640/XV620 */
208         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V620) }, /* Novatel Merlin V620/S620 */
209         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V740) }, /* Novatel Merlin EX720/V740/X720 */
210         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V720) }, /* Novatel Merlin V720/S720/PC720 */
211         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_U730) }, /* Novatel U730/U740 (VF version) */
212         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_U740) }, /* Novatel U740 */
213         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_U870) }, /* Novatel U870 */
214         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_XU870) }, /* Novatel Merlin XU870 HSDPA/3G */
215         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_X950D) }, /* Novatel X950D */
216         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EV620) }, /* Novatel EV620/ES620 CDMA/EV-DO */
217         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_ES720) }, /* Novatel ES620/ES720/U720/USB720 */
218         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_E725) }, /* Novatel E725/E726 */
219         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2130) }, /* Novatel Merlin ES620 SM Bus */
220         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EU730) }, /* Novatel EU730 and Vodafone EU740 */
221         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EU740) }, /* Novatel non-Vodafone EU740 */
222         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EU870D) }, /* Novatel EU850D/EU860D/EU870D */
223         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC950D) }, /* Novatel MC930D/MC950D */
224         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC727) }, /* Novatel MC727/U727/USB727 */
225         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x5010) }, /* Novatel U727 */
226         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_1) }, /* Novatel EVDO product */
227         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_1) }, /* Novatel HSPA product */
228         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EMBEDDED_1) }, /* Novatel Embedded product */
229         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_GLOBAL_1) }, /* Novatel Global product */
230         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_2) }, /* Novatel EVDO product */
231         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_2) }, /* Novatel HSPA product */
232         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EMBEDDED_2) }, /* Novatel Embedded product */
233         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_GLOBAL_2) }, /* Novatel Global product */
234
235         { USB_DEVICE(DELL_VENDOR_ID, 0x8114) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite EV620 CDMA/EV-DO */
236         { USB_DEVICE(DELL_VENDOR_ID, 0x8115) }, /* Dell Wireless 5500 Mobile Broadband HSDPA Mini-Card == Novatel Expedite EU740 HSDPA/3G */
237         { USB_DEVICE(DELL_VENDOR_ID, 0x8116) }, /* Dell Wireless 5505 Mobile Broadband HSDPA Mini-Card == Novatel Expedite EU740 HSDPA/3G */
238         { USB_DEVICE(DELL_VENDOR_ID, 0x8117) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO ExpressCard == Novatel Merlin XV620 CDMA/EV-DO */
239         { USB_DEVICE(DELL_VENDOR_ID, 0x8118) }, /* Dell Wireless 5510 Mobile Broadband HSDPA ExpressCard == Novatel Merlin XU870 HSDPA/3G */
240         { USB_DEVICE(DELL_VENDOR_ID, 0x8128) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite E720 CDMA/EV-DO */
241         { USB_DEVICE(DELL_VENDOR_ID, 0x8129) }, /* Dell Wireless 5700 Mobile Broadband CDMA/EVDO Mini-Card == Novatel Expedite ET620 CDMA/EV-DO */
242         { USB_DEVICE(DELL_VENDOR_ID, 0x8133) }, /* Dell Wireless 5720 == Novatel EV620 CDMA/EV-DO */
243         { USB_DEVICE(DELL_VENDOR_ID, 0x8136) }, /* Dell Wireless HSDPA 5520 == Novatel Expedite EU860D */
244         { USB_DEVICE(DELL_VENDOR_ID, 0x8137) }, /* Dell Wireless HSDPA 5520 */
245         { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_E100A) },
246         { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_500A) },
247         { USB_DEVICE(AXESSTEL_VENDOR_ID, AXESSTEL_PRODUCT_MV110H) },
248         { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1) },
249         { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2) },
250         { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC680) },
251         { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */
252         { } /* Terminating entry */
253 };
254 MODULE_DEVICE_TABLE(usb, option_ids);
255
256 static struct usb_driver option_driver = {
257         .name       = "option",
258         .probe      = usb_serial_probe,
259         .disconnect = usb_serial_disconnect,
260         .id_table   = option_ids,
261         .no_dynamic_id =        1,
262 };
263
264 /* The card has three separate interfaces, which the serial driver
265  * recognizes separately, thus num_port=1.
266  */
267
268 static struct usb_serial_driver option_1port_device = {
269         .driver = {
270                 .owner =        THIS_MODULE,
271                 .name =         "option1",
272         },
273         .description       = "GSM modem (1-port)",
274         .usb_driver        = &option_driver,
275         .id_table          = option_ids,
276         .num_interrupt_in  = NUM_DONT_CARE,
277         .num_bulk_in       = NUM_DONT_CARE,
278         .num_bulk_out      = NUM_DONT_CARE,
279         .num_ports         = 1,
280         .open              = option_open,
281         .close             = option_close,
282         .write             = option_write,
283         .write_room        = option_write_room,
284         .chars_in_buffer   = option_chars_in_buffer,
285         .throttle          = option_rx_throttle,
286         .unthrottle        = option_rx_unthrottle,
287         .ioctl             = option_ioctl,
288         .set_termios       = option_set_termios,
289         .break_ctl         = option_break_ctl,
290         .tiocmget          = option_tiocmget,
291         .tiocmset          = option_tiocmset,
292         .attach            = option_startup,
293         .shutdown          = option_shutdown,
294         .read_int_callback = option_instat_callback,
295 };
296
297 #ifdef CONFIG_USB_DEBUG
298 static int debug;
299 #else
300 #define debug 0
301 #endif
302
303 /* per port private data */
304
305 #define N_IN_URB 4
306 #define N_OUT_URB 1
307 #define IN_BUFLEN 4096
308 #define OUT_BUFLEN 128
309
310 struct option_port_private {
311         /* Input endpoints and buffer for this port */
312         struct urb *in_urbs[N_IN_URB];
313         u8 *in_buffer[N_IN_URB];
314         /* Output endpoints and buffer for this port */
315         struct urb *out_urbs[N_OUT_URB];
316         u8 *out_buffer[N_OUT_URB];
317         unsigned long out_busy;         /* Bit vector of URBs in use */
318
319         /* Settings for the port */
320         int rts_state;  /* Handshaking pins (outputs) */
321         int dtr_state;
322         int cts_state;  /* Handshaking pins (inputs) */
323         int dsr_state;
324         int dcd_state;
325         int ri_state;
326
327         unsigned long tx_start_time[N_OUT_URB];
328 };
329
330 /* Functions used by new usb-serial code. */
331 static int __init option_init(void)
332 {
333         int retval;
334         retval = usb_serial_register(&option_1port_device);
335         if (retval)
336                 goto failed_1port_device_register;
337         retval = usb_register(&option_driver);
338         if (retval)
339                 goto failed_driver_register;
340
341         info(DRIVER_DESC ": " DRIVER_VERSION);
342
343         return 0;
344
345 failed_driver_register:
346         usb_serial_deregister (&option_1port_device);
347 failed_1port_device_register:
348         return retval;
349 }
350
351 static void __exit option_exit(void)
352 {
353         usb_deregister (&option_driver);
354         usb_serial_deregister (&option_1port_device);
355 }
356
357 module_init(option_init);
358 module_exit(option_exit);
359
360 static void option_rx_throttle(struct usb_serial_port *port)
361 {
362         dbg("%s", __FUNCTION__);
363 }
364
365 static void option_rx_unthrottle(struct usb_serial_port *port)
366 {
367         dbg("%s", __FUNCTION__);
368 }
369
370 static void option_break_ctl(struct usb_serial_port *port, int break_state)
371 {
372         /* Unfortunately, I don't know how to send a break */
373         dbg("%s", __FUNCTION__);
374 }
375
376 static void option_set_termios(struct usb_serial_port *port,
377                         struct ktermios *old_termios)
378 {
379         dbg("%s", __FUNCTION__);
380         /* Doesn't support option setting */
381         tty_termios_copy_hw(port->tty->termios, old_termios);
382         option_send_setup(port);
383 }
384
385 static int option_tiocmget(struct usb_serial_port *port, struct file *file)
386 {
387         unsigned int value;
388         struct option_port_private *portdata;
389
390         portdata = usb_get_serial_port_data(port);
391
392         value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
393                 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
394                 ((portdata->cts_state) ? TIOCM_CTS : 0) |
395                 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
396                 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
397                 ((portdata->ri_state) ? TIOCM_RNG : 0);
398
399         return value;
400 }
401
402 static int option_tiocmset(struct usb_serial_port *port, struct file *file,
403                         unsigned int set, unsigned int clear)
404 {
405         struct option_port_private *portdata;
406
407         portdata = usb_get_serial_port_data(port);
408
409         if (set & TIOCM_RTS)
410                 portdata->rts_state = 1;
411         if (set & TIOCM_DTR)
412                 portdata->dtr_state = 1;
413
414         if (clear & TIOCM_RTS)
415                 portdata->rts_state = 0;
416         if (clear & TIOCM_DTR)
417                 portdata->dtr_state = 0;
418         return option_send_setup(port);
419 }
420
421 static int option_ioctl(struct usb_serial_port *port, struct file *file,
422                         unsigned int cmd, unsigned long arg)
423 {
424         return -ENOIOCTLCMD;
425 }
426
427 /* Write */
428 static int option_write(struct usb_serial_port *port,
429                         const unsigned char *buf, int count)
430 {
431         struct option_port_private *portdata;
432         int i;
433         int left, todo;
434         struct urb *this_urb = NULL; /* spurious */
435         int err;
436
437         portdata = usb_get_serial_port_data(port);
438
439         dbg("%s: write (%d chars)", __FUNCTION__, count);
440
441         i = 0;
442         left = count;
443         for (i=0; left > 0 && i < N_OUT_URB; i++) {
444                 todo = left;
445                 if (todo > OUT_BUFLEN)
446                         todo = OUT_BUFLEN;
447
448                 this_urb = portdata->out_urbs[i];
449                 if (test_and_set_bit(i, &portdata->out_busy)) {
450                         if (time_before(jiffies,
451                                         portdata->tx_start_time[i] + 10 * HZ))
452                                 continue;
453                         usb_unlink_urb(this_urb);
454                         continue;
455                 }
456                 if (this_urb->status != 0)
457                         dbg("usb_write %p failed (err=%d)",
458                                 this_urb, this_urb->status);
459
460                 dbg("%s: endpoint %d buf %d", __FUNCTION__,
461                         usb_pipeendpoint(this_urb->pipe), i);
462
463                 /* send the data */
464                 memcpy (this_urb->transfer_buffer, buf, todo);
465                 this_urb->transfer_buffer_length = todo;
466
467                 this_urb->dev = port->serial->dev;
468                 err = usb_submit_urb(this_urb, GFP_ATOMIC);
469                 if (err) {
470                         dbg("usb_submit_urb %p (write bulk) failed "
471                                 "(%d, has %d)", this_urb,
472                                 err, this_urb->status);
473                         clear_bit(i, &portdata->out_busy);
474                         continue;
475                 }
476                 portdata->tx_start_time[i] = jiffies;
477                 buf += todo;
478                 left -= todo;
479         }
480
481         count -= left;
482         dbg("%s: wrote (did %d)", __FUNCTION__, count);
483         return count;
484 }
485
486 static void option_indat_callback(struct urb *urb)
487 {
488         int err;
489         int endpoint;
490         struct usb_serial_port *port;
491         struct tty_struct *tty;
492         unsigned char *data = urb->transfer_buffer;
493         int status = urb->status;
494
495         dbg("%s: %p", __FUNCTION__, urb);
496
497         endpoint = usb_pipeendpoint(urb->pipe);
498         port = (struct usb_serial_port *) urb->context;
499
500         if (status) {
501                 dbg("%s: nonzero status: %d on endpoint %02x.",
502                     __FUNCTION__, status, endpoint);
503         } else {
504                 tty = port->tty;
505                 if (urb->actual_length) {
506                         tty_buffer_request_room(tty, urb->actual_length);
507                         tty_insert_flip_string(tty, data, urb->actual_length);
508                         tty_flip_buffer_push(tty);
509                 } else {
510                         dbg("%s: empty read urb received", __FUNCTION__);
511                 }
512
513                 /* Resubmit urb so we continue receiving */
514                 if (port->open_count && status != -ESHUTDOWN) {
515                         err = usb_submit_urb(urb, GFP_ATOMIC);
516                         if (err)
517                                 printk(KERN_ERR "%s: resubmit read urb failed. "
518                                         "(%d)", __FUNCTION__, err);
519                 }
520         }
521         return;
522 }
523
524 static void option_outdat_callback(struct urb *urb)
525 {
526         struct usb_serial_port *port;
527         struct option_port_private *portdata;
528         int i;
529
530         dbg("%s", __FUNCTION__);
531
532         port = (struct usb_serial_port *) urb->context;
533
534         usb_serial_port_softint(port);
535
536         portdata = usb_get_serial_port_data(port);
537         for (i = 0; i < N_OUT_URB; ++i) {
538                 if (portdata->out_urbs[i] == urb) {
539                         smp_mb__before_clear_bit();
540                         clear_bit(i, &portdata->out_busy);
541                         break;
542                 }
543         }
544 }
545
546 static void option_instat_callback(struct urb *urb)
547 {
548         int err;
549         int status = urb->status;
550         struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
551         struct option_port_private *portdata = usb_get_serial_port_data(port);
552         struct usb_serial *serial = port->serial;
553
554         dbg("%s", __FUNCTION__);
555         dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
556
557         if (status == 0) {
558                 struct usb_ctrlrequest *req_pkt =
559                                 (struct usb_ctrlrequest *)urb->transfer_buffer;
560
561                 if (!req_pkt) {
562                         dbg("%s: NULL req_pkt\n", __FUNCTION__);
563                         return;
564                 }
565                 if ((req_pkt->bRequestType == 0xA1) &&
566                                 (req_pkt->bRequest == 0x20)) {
567                         int old_dcd_state;
568                         unsigned char signals = *((unsigned char *)
569                                         urb->transfer_buffer +
570                                         sizeof(struct usb_ctrlrequest));
571
572                         dbg("%s: signal x%x", __FUNCTION__, signals);
573
574                         old_dcd_state = portdata->dcd_state;
575                         portdata->cts_state = 1;
576                         portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
577                         portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
578                         portdata->ri_state = ((signals & 0x08) ? 1 : 0);
579
580                         if (port->tty && !C_CLOCAL(port->tty) &&
581                                         old_dcd_state && !portdata->dcd_state)
582                                 tty_hangup(port->tty);
583                 } else {
584                         dbg("%s: type %x req %x", __FUNCTION__,
585                                 req_pkt->bRequestType,req_pkt->bRequest);
586                 }
587         } else
588                 dbg("%s: error %d", __FUNCTION__, status);
589
590         /* Resubmit urb so we continue receiving IRQ data */
591         if (status != -ESHUTDOWN) {
592                 urb->dev = serial->dev;
593                 err = usb_submit_urb(urb, GFP_ATOMIC);
594                 if (err)
595                         dbg("%s: resubmit intr urb failed. (%d)",
596                                 __FUNCTION__, err);
597         }
598 }
599
600 static int option_write_room(struct usb_serial_port *port)
601 {
602         struct option_port_private *portdata;
603         int i;
604         int data_len = 0;
605         struct urb *this_urb;
606
607         portdata = usb_get_serial_port_data(port);
608
609         for (i=0; i < N_OUT_URB; i++) {
610                 this_urb = portdata->out_urbs[i];
611                 if (this_urb && !test_bit(i, &portdata->out_busy))
612                         data_len += OUT_BUFLEN;
613         }
614
615         dbg("%s: %d", __FUNCTION__, data_len);
616         return data_len;
617 }
618
619 static int option_chars_in_buffer(struct usb_serial_port *port)
620 {
621         struct option_port_private *portdata;
622         int i;
623         int data_len = 0;
624         struct urb *this_urb;
625
626         portdata = usb_get_serial_port_data(port);
627
628         for (i=0; i < N_OUT_URB; i++) {
629                 this_urb = portdata->out_urbs[i];
630                 if (this_urb && test_bit(i, &portdata->out_busy))
631                         data_len += this_urb->transfer_buffer_length;
632         }
633         dbg("%s: %d", __FUNCTION__, data_len);
634         return data_len;
635 }
636
637 static int option_open(struct usb_serial_port *port, struct file *filp)
638 {
639         struct option_port_private *portdata;
640         struct usb_serial *serial = port->serial;
641         int i, err;
642         struct urb *urb;
643
644         portdata = usb_get_serial_port_data(port);
645
646         dbg("%s", __FUNCTION__);
647
648         /* Set some sane defaults */
649         portdata->rts_state = 1;
650         portdata->dtr_state = 1;
651
652         /* Reset low level data toggle and start reading from endpoints */
653         for (i = 0; i < N_IN_URB; i++) {
654                 urb = portdata->in_urbs[i];
655                 if (! urb)
656                         continue;
657                 if (urb->dev != serial->dev) {
658                         dbg("%s: dev %p != %p", __FUNCTION__,
659                                 urb->dev, serial->dev);
660                         continue;
661                 }
662
663                 /*
664                  * make sure endpoint data toggle is synchronized with the
665                  * device
666                  */
667                 usb_clear_halt(urb->dev, urb->pipe);
668
669                 err = usb_submit_urb(urb, GFP_KERNEL);
670                 if (err) {
671                         dbg("%s: submit urb %d failed (%d) %d",
672                                 __FUNCTION__, i, err,
673                                 urb->transfer_buffer_length);
674                 }
675         }
676
677         /* Reset low level data toggle on out endpoints */
678         for (i = 0; i < N_OUT_URB; i++) {
679                 urb = portdata->out_urbs[i];
680                 if (! urb)
681                         continue;
682                 urb->dev = serial->dev;
683                 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
684                                 usb_pipeout(urb->pipe), 0); */
685         }
686
687         port->tty->low_latency = 1;
688
689         option_send_setup(port);
690
691         return (0);
692 }
693
694 static void option_close(struct usb_serial_port *port, struct file *filp)
695 {
696         int i;
697         struct usb_serial *serial = port->serial;
698         struct option_port_private *portdata;
699
700         dbg("%s", __FUNCTION__);
701         portdata = usb_get_serial_port_data(port);
702
703         portdata->rts_state = 0;
704         portdata->dtr_state = 0;
705
706         if (serial->dev) {
707                 mutex_lock(&serial->disc_mutex);
708                 if (!serial->disconnected)
709                         option_send_setup(port);
710                 mutex_unlock(&serial->disc_mutex);
711
712                 /* Stop reading/writing urbs */
713                 for (i = 0; i < N_IN_URB; i++)
714                         usb_kill_urb(portdata->in_urbs[i]);
715                 for (i = 0; i < N_OUT_URB; i++)
716                         usb_kill_urb(portdata->out_urbs[i]);
717         }
718         port->tty = NULL;
719 }
720
721 /* Helper functions used by option_setup_urbs */
722 static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint,
723                 int dir, void *ctx, char *buf, int len,
724                 void (*callback)(struct urb *))
725 {
726         struct urb *urb;
727
728         if (endpoint == -1)
729                 return NULL;            /* endpoint not needed */
730
731         urb = usb_alloc_urb(0, GFP_KERNEL);             /* No ISO */
732         if (urb == NULL) {
733                 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
734                 return NULL;
735         }
736
737                 /* Fill URB using supplied data. */
738         usb_fill_bulk_urb(urb, serial->dev,
739                       usb_sndbulkpipe(serial->dev, endpoint) | dir,
740                       buf, len, callback, ctx);
741
742         return urb;
743 }
744
745 /* Setup urbs */
746 static void option_setup_urbs(struct usb_serial *serial)
747 {
748         int i,j;
749         struct usb_serial_port *port;
750         struct option_port_private *portdata;
751
752         dbg("%s", __FUNCTION__);
753
754         for (i = 0; i < serial->num_ports; i++) {
755                 port = serial->port[i];
756                 portdata = usb_get_serial_port_data(port);
757
758         /* Do indat endpoints first */
759                 for (j = 0; j < N_IN_URB; ++j) {
760                         portdata->in_urbs[j] = option_setup_urb (serial,
761                         port->bulk_in_endpointAddress, USB_DIR_IN, port,
762                         portdata->in_buffer[j], IN_BUFLEN, option_indat_callback);
763                 }
764
765                 /* outdat endpoints */
766                 for (j = 0; j < N_OUT_URB; ++j) {
767                         portdata->out_urbs[j] = option_setup_urb (serial,
768                         port->bulk_out_endpointAddress, USB_DIR_OUT, port,
769                         portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback);
770                 }
771         }
772 }
773
774 static int option_send_setup(struct usb_serial_port *port)
775 {
776         struct usb_serial *serial = port->serial;
777         struct option_port_private *portdata;
778
779         dbg("%s", __FUNCTION__);
780
781         if (port->number != 0)
782                 return 0;
783
784         portdata = usb_get_serial_port_data(port);
785
786         if (port->tty) {
787                 int val = 0;
788                 if (portdata->dtr_state)
789                         val |= 0x01;
790                 if (portdata->rts_state)
791                         val |= 0x02;
792
793                 return usb_control_msg(serial->dev,
794                                 usb_rcvctrlpipe(serial->dev, 0),
795                                 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
796         }
797
798         return 0;
799 }
800
801 static int option_startup(struct usb_serial *serial)
802 {
803         int i, j, err;
804         struct usb_serial_port *port;
805         struct option_port_private *portdata;
806         u8 *buffer;
807
808         dbg("%s", __FUNCTION__);
809
810         /* Now setup per port private data */
811         for (i = 0; i < serial->num_ports; i++) {
812                 port = serial->port[i];
813                 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
814                 if (!portdata) {
815                         dbg("%s: kmalloc for option_port_private (%d) failed!.",
816                                         __FUNCTION__, i);
817                         return (1);
818                 }
819
820                 for (j = 0; j < N_IN_URB; j++) {
821                         buffer = (u8 *)__get_free_page(GFP_KERNEL);
822                         if (!buffer)
823                                 goto bail_out_error;
824                         portdata->in_buffer[j] = buffer;
825                 }
826
827                 for (j = 0; j < N_OUT_URB; j++) {
828                         buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
829                         if (!buffer)
830                                 goto bail_out_error2;
831                         portdata->out_buffer[j] = buffer;
832                 }
833
834                 usb_set_serial_port_data(port, portdata);
835
836                 if (! port->interrupt_in_urb)
837                         continue;
838                 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
839                 if (err)
840                         dbg("%s: submit irq_in urb failed %d",
841                                 __FUNCTION__, err);
842         }
843
844         option_setup_urbs(serial);
845
846         return (0);
847
848 bail_out_error2:
849         for (j = 0; j < N_OUT_URB; j++)
850                 kfree(portdata->out_buffer[j]);
851 bail_out_error:
852         for (j = 0; j < N_IN_URB; j++)
853                 if (portdata->in_buffer[j])
854                         free_page((unsigned long)portdata->in_buffer[j]);
855         kfree(portdata);
856         return 1;
857 }
858
859 static void option_shutdown(struct usb_serial *serial)
860 {
861         int i, j;
862         struct usb_serial_port *port;
863         struct option_port_private *portdata;
864
865         dbg("%s", __FUNCTION__);
866
867         /* Stop reading/writing urbs */
868         for (i = 0; i < serial->num_ports; ++i) {
869                 port = serial->port[i];
870                 portdata = usb_get_serial_port_data(port);
871                 for (j = 0; j < N_IN_URB; j++)
872                         usb_kill_urb(portdata->in_urbs[j]);
873                 for (j = 0; j < N_OUT_URB; j++)
874                         usb_kill_urb(portdata->out_urbs[j]);
875         }
876
877         /* Now free them */
878         for (i = 0; i < serial->num_ports; ++i) {
879                 port = serial->port[i];
880                 portdata = usb_get_serial_port_data(port);
881
882                 for (j = 0; j < N_IN_URB; j++) {
883                         if (portdata->in_urbs[j]) {
884                                 usb_free_urb(portdata->in_urbs[j]);
885                                 free_page((unsigned long)portdata->in_buffer[j]);
886                                 portdata->in_urbs[j] = NULL;
887                         }
888                 }
889                 for (j = 0; j < N_OUT_URB; j++) {
890                         if (portdata->out_urbs[j]) {
891                                 usb_free_urb(portdata->out_urbs[j]);
892                                 kfree(portdata->out_buffer[j]);
893                                 portdata->out_urbs[j] = NULL;
894                         }
895                 }
896         }
897
898         /* Now free per port private data */
899         for (i = 0; i < serial->num_ports; i++) {
900                 port = serial->port[i];
901                 kfree(usb_get_serial_port_data(port));
902         }
903 }
904
905 MODULE_AUTHOR(DRIVER_AUTHOR);
906 MODULE_DESCRIPTION(DRIVER_DESC);
907 MODULE_VERSION(DRIVER_VERSION);
908 MODULE_LICENSE("GPL");
909
910 #ifdef CONFIG_USB_DEBUG
911 module_param(debug, bool, S_IRUGO | S_IWUSR);
912 MODULE_PARM_DESC(debug, "Debug messages");
913 #endif
914