projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ar71xx: sync kernel config
[openwrt.git] / target / linux / brcm-2.4 / patches / 014-sierra_support.patch
1 --- /dev/null
2 +++ b/drivers/usb/serial/sierra.c
3 @@ -0,0 +1,1446 @@
4 +/*
5 + * Sierra Wireless CDMA Wireless Serial USB drive
6 + *
7 + * Current Copy modified by: Kevin Lloyd <linux@sierrawireless.com>
8 + * Original Copy written by: 2005 Greg Kroah-Hartman <gregkh <at> suse.de>
9 + *
10 + *
11 + * This program is free software; you can redistribute it and/or
12 + * modify it under the terms of the GNU General Public License version
13 + * 2 as published by the Free Software Foundation.
14 + *
15 + * Version history:
16 + Version 1.03 (Lloyd):
17 + Included support for DTR control and enhanced buffering (should help
18 + speed).
19 + */
20 +
21 +#include <linux/config.h>
22 +#include <linux/kernel.h>
23 +#include <linux/init.h>
24 +#include <linux/slab.h>
25 +#include <linux/tty.h>
26 +#include <linux/tty_driver.h>
27 +#include <linux/tty_flip.h>
28 +#include <linux/module.h>
29 +#include <linux/usb.h>
30 +#include <linux/mm.h>
31 +#include <asm/uaccess.h>
32 +#include <linux/errno.h>
33 +#include <linux/list.h>
34 +#include <linux/spinlock.h>
35 +#include <linux/smp_lock.h>
36 +
37 +#ifdef CONFIG_USB_SERIAL_DEBUG
38 + static int debug = 1;
39 +#else
40 + static int debug;
41 +#endif
42 +
43 +#include "usb-serial.h"
44 +#include "sierra.h"
45 +#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
46 +#include "pl2303.h" // see /* BEGIN HORRIBLE HACK FOR PL2303 */ below
47 +#endif
48 +
49 +#define DRIVER_VERSION "v1.03"
50 +
51 +#if 0
52 +#define USB_VENDER_REQUEST_SET_DEVICE_POWER_STATE 0
53 +
54 +#define USB_DEVICE_POWER_STATE_D0 0x0000
55 +#define USB_DEVICE_POWER_STATE_D1 0x0001
56 +#define USB_DEVICE_POWER_STATE_D2 0x0002
57 +#define USB_DEVICE_POWER_STATE_D3 0x0003
58 +
59 +#define SET_CONTROL_LINE_STATE 0x22
60 +/*
61 + * Output control lines.
62 + */
63 +
64 +#define ACM_CTRL_DTR 0x01
65 +#define ACM_CTRL_RTS 0x02
66 +#endif
67 +
68 +//static int sw_attach(struct usb_serial *serial);
69 +static void sw_usb_serial_generic_shutdown(struct usb_serial *serial);
70 +
71 +static int sw_usb_serial_generic_open(struct usb_serial_port *port, struct file *filp);
72 +static void sw_usb_serial_generic_close(struct usb_serial_port *port, struct file *filp);
73 +
74 +#if 1
75 +/*-----------------------------------------------------------*/
76 +static int serial_refcount;
77 +static struct tty_driver serial_tty_driver;
78 +static struct tty_struct * serial_tty[SERIAL_TTY_MINORS];
79 +static struct termios * serial_termios[SERIAL_TTY_MINORS];
80 +static struct termios * serial_termios_locked[SERIAL_TTY_MINORS];
81 +static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */
82 +
83 +static LIST_HEAD(usb_serial_driver_list);
84 +static struct usb_serial *get_free_serial (int num_ports, int *minor);
85 +static void generic_write_bulk_callback (struct urb *urb);
86 +static void * usb_serial_probe(struct usb_device *dev, unsigned int ifnum,const struct usb_device_id *id);
87 +static void usb_serial_disconnect(struct usb_device *dev, void *ptr);
88 +static void sw_usb_serial_generic_read_bulk_callback (struct urb *urb);
89 +static void port_softint(void *private);
90 +static void return_serial (struct usb_serial *serial);
91 +static struct usb_serial *get_free_serial (int num_ports, int *minor);
92 +static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data);
93 +/*-----------------------------------------------------------*/
94 +
95 +#endif
96 +
97 +
98 +static struct usb_device_id id_table [] = {
99 + { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
100 + { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
101 + { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
102 + { USB_DEVICE(0x0f30, 0x1b1d) }, /* Sierra Wireless MC5720 */
103 + { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
104 + { USB_DEVICE(0x1199, 0x0220) }, /* Sierra Wireless MC5725 */
105 + { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
106 + { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
107 + { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless USB Dongle 595U */
108 + { USB_DEVICE(0x1199, 0x0023) }, /* Sierra Wireless C597 */
109 +
110 + { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
111 + { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
112 + { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
113 + { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 & AC 875U */
114 + { USB_DEVICE(0x1199, 0x6813) }, /* Sierra Wireless MC8775 (Thinkpad internal) */
115 + { USB_DEVICE(0x1199, 0x6815) }, /* Sierra Wireless MC8775 */
116 + { USB_DEVICE(0x03f0, 0x1e1d) }, /* HP hs2300 a.k.a MC8775 */
117 + { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
118 + { USB_DEVICE(0x1199, 0x6821) }, /* Sierra Wireless AirCard 875U */
119 + { USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780*/
120 + { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781*/
121 + { USB_DEVICE(0x1199, 0x683B) }, /* Sierra Wireless MC8785 Composite*/
122 + { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
123 + { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
124 + { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880 E */
125 + { USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881 E */
126 + { USB_DEVICE(0x1199, 0x6855) }, /* Sierra Wireless AirCard 880 U */
127 + { USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881 U */
128 + { USB_DEVICE(0x1199, 0x6859) }, /* Sierra Wireless AirCard 885 E */
129 + { USB_DEVICE(0x1199, 0x685A) }, /* Sierra Wireless AirCard 885 E */
130 +
131 + { USB_DEVICE(0x1199, 0x6468) }, /* Sierra Wireless MP3G - EVDO */
132 + { USB_DEVICE(0x1199, 0x6469) }, /* Sierra Wireless MP3G - UMTS/HSPA */
133 +
134 + { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
135 + { USB_DEVICE(0x0F3D, 0x0112) }, /* AirPrime/Sierra Wireless PC 5220 */
136 + { USB_DEVICE(0x05C6, 0x6613) }, /* Onda H600/ZTE MF330 */
137 + { }
138 +};
139 +
140 +MODULE_DEVICE_TABLE(usb, id_table);
141 +
142 +static struct usb_driver sierra_driver = {
143 +// .owner = THIS_MODULE,
144 + .name = "Sierra wireless",
145 + .probe = usb_serial_probe,
146 + .disconnect = usb_serial_disconnect,
147 + .id_table = id_table,
148 +};
149 +
150 +static struct usb_serial_device_type sierra_device = {
151 +// .driver = {
152 + .owner = THIS_MODULE,
153 + .name = "Sierra Wireless",
154 +// },
155 + .id_table = id_table,
156 + .num_interrupt_in = NUM_DONT_CARE,
157 + .num_bulk_in = NUM_DONT_CARE,
158 + .num_bulk_out = NUM_DONT_CARE,
159 + .num_ports = 3,
160 + //.startup = sw_attach,
161 + .shutdown = sw_usb_serial_generic_shutdown,
162 + .open = sw_usb_serial_generic_open,
163 + .close = sw_usb_serial_generic_close,
164 +};
165 +
166 +#define MAX_NUM_PORTS 8
167 +
168 +/* local function prototypes */
169 +static int serial_open (struct tty_struct *tty, struct file * filp);
170 +static void serial_close (struct tty_struct *tty, struct file * filp);
171 +static int serial_write (struct tty_struct * tty, int from_user, const unsigned char *buf, int count);
172 +static int serial_write_room (struct tty_struct *tty);
173 +static int serial_chars_in_buffer (struct tty_struct *tty);
174 +static void serial_throttle (struct tty_struct * tty);
175 +static void serial_unthrottle (struct tty_struct * tty);
176 +static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg);
177 +static void serial_set_termios (struct tty_struct *tty, struct termios * old);
178 +//static void serial_shutdown (struct usb_serial *serial);
179 +static void serial_break (struct tty_struct *tty, int break_state);
180 +static int generic_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count);
181 +static int generic_write_room (struct usb_serial_port *port);
182 +static void generic_cleanup (struct usb_serial_port *port);
183 +static int generic_chars_in_buffer (struct usb_serial_port *port);
184 +//static void generic_shutdown (struct usb_serial *serial);
185 +
186 +#if 1
187 +static struct tty_driver serial_tty_driver = {
188 + .magic = TTY_DRIVER_MAGIC,
189 + .driver_name = "usb-serial",
190 +#ifndef CONFIG_DEVFS_FS
191 + .name = "ttyUSB",
192 +#else
193 + .name = "usb/tts/%d",
194 +#endif
195 + .major = SERIAL_TTY_MAJOR,
196 + .minor_start = 0,
197 + .num = SERIAL_TTY_MINORS,
198 + .type = TTY_DRIVER_TYPE_SERIAL,
199 + .subtype = SERIAL_TYPE_NORMAL,
200 + .flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS,
201 +
202 + .refcount = &serial_refcount,
203 + .table = serial_tty,
204 + .termios = serial_termios,
205 + .termios_locked = serial_termios_locked,
206 +
207 + .open = serial_open,
208 + .close = serial_close,
209 + .write = serial_write,
210 + .write_room = serial_write_room,
211 + .ioctl = serial_ioctl,
212 + .set_termios = serial_set_termios,
213 + .throttle = serial_throttle,
214 + .unthrottle = serial_unthrottle,
215 + .break_ctl = serial_break,
216 + .chars_in_buffer = serial_chars_in_buffer,
217 + .read_proc = serial_read_proc,
218 +};
219 +#endif
220 +
221 +
222 +/*****************************************************************************
223 + * Driver tty interface functions
224 + *****************************************************************************/
225 +static struct usb_serial *get_serial_by_minor (unsigned int minor)
226 +{
227 + return serial_table[minor];
228 +}
229 +
230 +static int serial_open (struct tty_struct *tty, struct file * filp)
231 +{
232 + struct usb_serial *serial;
233 + struct usb_serial_port *port;
234 + unsigned int portNumber;
235 + int retval = 0;
236 +
237 + dbg("%s", __FUNCTION__);
238 +
239 + /* initialize the pointer incase something fails */
240 + tty->driver_data = NULL;
241 +
242 + /* get the serial object associated with this tty pointer */
243 + serial = get_serial_by_minor (MINOR(tty->device));
244 +
245 + if (serial_paranoia_check (serial, __FUNCTION__))
246 + return -ENODEV;
247 +
248 + /* set up our port structure making the tty driver remember our port object, and us it */
249 + portNumber = MINOR(tty->device) - serial->minor;
250 + port = &serial->port[portNumber];
251 + tty->driver_data = port;
252 +
253 + down (&port->sem);
254 + port->tty = tty;
255 +
256 + /* lock this module before we call it */
257 + if (serial->type->owner)
258 + __MOD_INC_USE_COUNT(serial->type->owner);
259 +
260 + ++port->open_count;
261 + if (port->open_count == 1) {
262 + /* only call the device specific open if this
263 + * is the first time the port is opened */
264 + if (serial->type->open)
265 + retval = serial->type->open(port, filp);
266 + else
267 + retval = sw_usb_serial_generic_open(port, filp);//@.@
268 + }
269 +
270 + if (retval) {
271 + port->open_count = 0;
272 + if (serial->type->owner)
273 + __MOD_DEC_USE_COUNT(serial->type->owner);
274 + }
275 +
276 + up (&port->sem);
277 + return retval;
278 +}
279 +
280 +static void __serial_close(struct usb_serial_port *port, struct file *filp)
281 +{
282 + if (!port->open_count) {
283 + dbg ("%s - port not opened", __FUNCTION__);
284 + return;
285 + }
286 +
287 + --port->open_count;
288 + if (port->open_count <= 0) {
289 + /* only call the device specific close if this
290 + * port is being closed by the last owner */
291 + if (port->serial->type->close)
292 + port->serial->type->close(port, filp);
293 + else
294 + //generic_close(port, filp);
295 + sw_usb_serial_generic_close(port, filp);
296 + port->open_count = 0;
297 + }
298 +
299 + if (port->serial->type->owner)
300 + __MOD_DEC_USE_COUNT(port->serial->type->owner);
301 +}
302 +
303 +static void serial_close(struct tty_struct *tty, struct file * filp)
304 +{
305 + struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
306 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
307 +
308 + if (!serial)
309 + return;
310 +
311 + down (&port->sem);
312 +
313 + dbg("%s - port %d", __FUNCTION__, port->number);
314 +
315 + /* if disconnect beat us to the punch here, there's nothing to do */
316 + if (tty->driver_data) {
317 + __serial_close(port, filp);
318 + }
319 +
320 + up (&port->sem);
321 +}
322 +
323 +static int serial_write (struct tty_struct * tty, int from_user, const unsigned char *buf, int count)
324 +{
325 + struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
326 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
327 + int retval = -EINVAL;
328 +
329 + if (!serial)
330 + return -ENODEV;
331 +
332 + down (&port->sem);
333 +
334 + dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
335 +
336 + if (!port->open_count) {
337 + dbg("%s - port not opened", __FUNCTION__);
338 + goto exit;
339 + }
340 +
341 + /* pass on to the driver specific version of this function if it is available */
342 + if (serial->type->write)
343 + retval = serial->type->write(port, from_user, buf, count);
344 + else
345 + retval = generic_write(port, from_user, buf, count);
346 +
347 +exit:
348 + up (&port->sem);
349 + return retval;
350 +}
351 +
352 +static int serial_write_room (struct tty_struct *tty)
353 +{
354 + struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
355 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
356 + int retval = -EINVAL;
357 +
358 + if (!serial)
359 + return -ENODEV;
360 +
361 + down (&port->sem);
362 +
363 + dbg("%s - port %d", __FUNCTION__, port->number);
364 +
365 + if (!port->open_count) {
366 + dbg("%s - port not open", __FUNCTION__);
367 + goto exit;
368 + }
369 +
370 + /* pass on to the driver specific version of this function if it is available */
371 + if (serial->type->write_room)
372 + retval = serial->type->write_room(port);
373 + else
374 + retval = generic_write_room(port);
375 +
376 +exit:
377 + up (&port->sem);
378 + return retval;
379 +}
380 +
381 +static int serial_chars_in_buffer (struct tty_struct *tty)
382 +{
383 + struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
384 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
385 + int retval = -EINVAL;
386 +
387 + if (!serial)
388 + return -ENODEV;
389 +
390 + down (&port->sem);
391 +
392 + dbg("%s = port %d", __FUNCTION__, port->number);
393 +
394 + if (!port->open_count) {
395 + dbg("%s - port not open", __FUNCTION__);
396 + goto exit;
397 + }
398 +
399 + /* pass on to the driver specific version of this function if it is available */
400 + if (serial->type->chars_in_buffer)
401 + retval = serial->type->chars_in_buffer(port);
402 + else
403 + retval = generic_chars_in_buffer(port);
404 +
405 +exit:
406 + up (&port->sem);
407 + return retval;
408 +}
409 +
410 +static void serial_throttle (struct tty_struct * tty)
411 +{
412 + struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
413 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
414 +
415 + if (!serial)
416 + return;
417 +
418 + down (&port->sem);
419 +
420 + dbg("%s - port %d", __FUNCTION__, port->number);
421 +
422 + if (!port->open_count) {
423 + dbg ("%s - port not open", __FUNCTION__);
424 + goto exit;
425 + }
426 +
427 + /* pass on to the driver specific version of this function */
428 + if (serial->type->throttle)
429 + serial->type->throttle(port);
430 +
431 +exit:
432 + up (&port->sem);
433 +}
434 +
435 +static void serial_unthrottle (struct tty_struct * tty)
436 +{
437 + struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
438 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
439 +
440 + if (!serial)
441 + return;
442 +
443 + down (&port->sem);
444 +
445 + dbg("%s - port %d", __FUNCTION__, port->number);
446 +
447 + if (!port->open_count) {
448 + dbg("%s - port not open", __FUNCTION__);
449 + goto exit;
450 + }
451 +
452 + /* pass on to the driver specific version of this function */
453 + if (serial->type->unthrottle)
454 + serial->type->unthrottle(port);
455 +
456 +exit:
457 + up (&port->sem);
458 +}
459 +
460 +static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
461 +{
462 + struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
463 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
464 + int retval = -ENODEV;
465 +
466 + if (!serial)
467 + return -ENODEV;
468 +
469 + down (&port->sem);
470 +
471 + dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
472 +
473 + if (!port->open_count) {
474 + dbg ("%s - port not open", __FUNCTION__);
475 + goto exit;
476 + }
477 +
478 + /* pass on to the driver specific version of this function if it is available */
479 + if (serial->type->ioctl)
480 + retval = serial->type->ioctl(port, file, cmd, arg);
481 + else
482 + retval = -ENOIOCTLCMD;
483 +
484 +exit:
485 + up (&port->sem);
486 + return retval;
487 +}
488 +
489 +static void serial_set_termios (struct tty_struct *tty, struct termios * old)
490 +{
491 + struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
492 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
493 +
494 + if (!serial)
495 + return;
496 +
497 + down (&port->sem);
498 +
499 + dbg("%s - port %d", __FUNCTION__, port->number);
500 +
501 + if (!port->open_count) {
502 + dbg("%s - port not open", __FUNCTION__);
503 + goto exit;
504 + }
505 +
506 + /* pass on to the driver specific version of this function if it is available */
507 + if (serial->type->set_termios)
508 + serial->type->set_termios(port, old);
509 +
510 +exit:
511 + up (&port->sem);
512 +}
513 +
514 +static void serial_break (struct tty_struct *tty, int break_state)
515 +{
516 + struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
517 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
518 +
519 + if (!serial)
520 + return;
521 +
522 + down (&port->sem);
523 +
524 + dbg("%s - port %d", __FUNCTION__, port->number);
525 +
526 + if (!port->open_count) {
527 + dbg("%s - port not open", __FUNCTION__);
528 + goto exit;
529 + }
530 +
531 + /* pass on to the driver specific version of this function if it is available */
532 + if (serial->type->break_ctl)
533 + serial->type->break_ctl(port, break_state);
534 +
535 +exit:
536 + up (&port->sem);
537 +}
538 +#if 0
539 +static void serial_shutdown (struct usb_serial *serial)
540 +{
541 + dbg ("%s", __FUNCTION__);
542 +
543 + if (serial->type->shutdown)
544 + serial->type->shutdown(serial);
545 + else
546 + generic_shutdown(serial);
547 +}
548 +#endif
549 +static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
550 +{
551 + struct usb_serial *serial;
552 + int length = 0;
553 + int i;
554 + off_t begin = 0;
555 + char tmp[40];
556 +
557 + dbg("%s", __FUNCTION__);
558 + length += sprintf (page, "usbserinfo:1.0 driver:%s\n", DRIVER_VERSION);
559 + for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
560 + serial = get_serial_by_minor(i);
561 + if (serial == NULL)
562 + continue;
563 +
564 + length += sprintf (page+length, "%d:", i);
565 + if (serial->type->owner)
566 + length += sprintf (page+length, " module:%s", serial->type->owner->name);
567 + length += sprintf (page+length, " name:\"%s\"", serial->type->name);
568 + length += sprintf (page+length, " vendor:%04x product:%04x", serial->vendor, serial->product);
569 + length += sprintf (page+length, " num_ports:%d", serial->num_ports);
570 + length += sprintf (page+length, " port:%d", i - serial->minor + 1);
571 +
572 + usb_make_path(serial->dev, tmp, sizeof(tmp));
573 + length += sprintf (page+length, " path:%s", tmp);
574 +
575 + length += sprintf (page+length, "\n");
576 + if ((length + begin) > (off + count))
577 + goto done;
578 + if ((length + begin) < off) {
579 + begin += length;
580 + length = 0;
581 + }
582 + }
583 + *eof = 1;
584 +done:
585 + if (off >= (length + begin))
586 + return 0;
587 + *start = page + (off-begin);
588 + return ((count < begin+length-off) ? count : begin+length-off);
589 +}
590 +
591 +
592 +/*-----------------------------------------------------------*/
593 +static int generic_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count)
594 +{
595 + struct usb_serial *serial = port->serial;
596 + int result;
597 +
598 + dbg("%s - port %d", __FUNCTION__, port->number);
599 +
600 + if (count == 0) {
601 + dbg("%s - write request of 0 bytes", __FUNCTION__);
602 + return (0);
603 + }
604 +
605 + /* only do something if we have a bulk out endpoint */
606 + if (serial->num_bulk_out) {
607 + if (port->write_urb->status == -EINPROGRESS) {
608 + dbg("%s - already writing", __FUNCTION__);
609 + return (0);
610 + }
611 +
612 + count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
613 +
614 + if (from_user) {
615 + if (copy_from_user(port->write_urb->transfer_buffer, buf, count))
616 + return -EFAULT;
617 + }
618 + else {
619 + memcpy (port->write_urb->transfer_buffer, buf, count);
620 + }
621 +
622 + usb_serial_debug_data (__FILE__, __FUNCTION__, count, port->write_urb->transfer_buffer);
623 +
624 + /* set up our urb */
625 + usb_fill_bulk_urb (port->write_urb, serial->dev,
626 + usb_sndbulkpipe (serial->dev,
627 + port->bulk_out_endpointAddress),
628 + port->write_urb->transfer_buffer, count,
629 + ((serial->type->write_bulk_callback) ?
630 + serial->type->write_bulk_callback :
631 + generic_write_bulk_callback), port);
632 +
633 + /* send the data out the bulk port */
634 + result = usb_submit_urb(port->write_urb);
635 + if (result)
636 + err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
637 + else
638 + result = count;
639 +
640 + return result;
641 + }
642 +
643 + /* no bulk out, so return 0 bytes written */
644 + return (0);
645 +}
646 +
647 +static int generic_write_room (struct usb_serial_port *port)
648 +{
649 + struct usb_serial *serial = port->serial;
650 + int room = 0;
651 +
652 + dbg("%s - port %d", __FUNCTION__, port->number);
653 +
654 + if (serial->num_bulk_out) {
655 + if (port->write_urb->status != -EINPROGRESS)
656 + room = port->bulk_out_size;
657 + }
658 +
659 + dbg("%s - returns %d", __FUNCTION__, room);
660 + return (room);
661 +}
662 +
663 +static int generic_chars_in_buffer (struct usb_serial_port *port)
664 +{
665 + struct usb_serial *serial = port->serial;
666 + int chars = 0;
667 +
668 + dbg("%s - port %d", __FUNCTION__, port->number);
669 +
670 + if (serial->num_bulk_out) {
671 + if (port->write_urb->status == -EINPROGRESS)
672 + chars = port->write_urb->transfer_buffer_length;
673 + }
674 +
675 + dbg("%s - returns %d", __FUNCTION__, chars);
676 + return (chars);
677 +}
678 +#if 0
679 +static void generic_shutdown (struct usb_serial *serial)
680 +{
681 + int i;
682 +
683 + dbg("%s", __FUNCTION__);
684 +
685 + /* stop reads and writes on all ports */
686 + for (i=0; i < serial->num_ports; ++i) {
687 + generic_cleanup (&serial->port[i]);
688 + }
689 +}
690 +static void generic_cleanup (struct usb_serial_port *port)
691 +{
692 + struct usb_serial *serial = port->serial;
693 +
694 + dbg("%s - port %d", __FUNCTION__, port->number);
695 +
696 + if (serial->dev) {
697 + /* shutdown any bulk reads that might be going on */
698 + if (serial->num_bulk_out)
699 + usb_unlink_urb (port->write_urb);
700 + if (serial->num_bulk_in)
701 + usb_unlink_urb (port->read_urb);
702 + }
703 +}
704 +#endif
705 +/*----------------------------------------------------------*/
706 +static void generic_write_bulk_callback (struct urb *urb)
707 +{
708 + struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
709 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
710 +
711 + dbg("%s - port %d", __FUNCTION__, port->number);
712 +
713 + if (!serial) {
714 + dbg("%s - bad serial pointer, exiting", __FUNCTION__);
715 + return;
716 + }
717 +
718 + if (urb->status) {
719 + dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status);
720 + return;
721 + }
722 +
723 + queue_task(&port->tqueue, &tq_immediate);
724 + mark_bh(IMMEDIATE_BH);
725 +
726 + return;
727 +}
728 +
729 +static struct usb_serial *get_free_serial (int num_ports, int *minor)
730 +{
731 + struct usb_serial *serial = NULL;
732 + int i, j;
733 + int good_spot;
734 +
735 + dbg("%s %d", __FUNCTION__, num_ports);
736 +
737 + *minor = 0;
738 + for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
739 + if (serial_table[i])
740 + continue;
741 +
742 + good_spot = 1;
743 + for (j = 1; j <= num_ports-1; ++j)
744 + if (serial_table[i+j])
745 + good_spot = 0;
746 + if (good_spot == 0)
747 + continue;
748 +
749 + if (!(serial = kmalloc(sizeof(struct usb_serial), GFP_KERNEL))) {
750 + err("%s - Out of memory", __FUNCTION__);
751 + return NULL;
752 + }
753 + memset(serial, 0, sizeof(struct usb_serial));
754 + serial->magic = USB_SERIAL_MAGIC;
755 + serial_table[i] = serial;
756 + *minor = i;
757 + dbg("%s - minor base = %d", __FUNCTION__, *minor);
758 + for (i = *minor+1; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
759 + serial_table[i] = serial;
760 + return serial;
761 + }
762 + return NULL;
763 +}
764 +
765 +static void return_serial (struct usb_serial *serial)
766 +{
767 + int i;
768 +
769 + dbg("%s", __FUNCTION__);
770 +
771 + if (serial == NULL)
772 + return;
773 +
774 + for (i = 0; i < serial->num_ports; ++i) {
775 + serial_table[serial->minor + i] = NULL;
776 + }
777 +
778 + return;
779 +}
780 +
781 +static void port_softint(void *private)
782 +{
783 + struct usb_serial_port *port = (struct usb_serial_port *)private;
784 + struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
785 + struct tty_struct *tty;
786 +
787 + dbg("%s - port %d", __FUNCTION__, port->number);
788 +
789 + if (!serial)
790 + return;
791 +
792 + tty = port->tty;
793 + if (!tty)
794 + return;
795 +
796 + if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) {
797 + dbg("%s - write wakeup call.", __FUNCTION__);
798 + (tty->ldisc.write_wakeup)(tty);
799 + }
800 +
801 + wake_up_interruptible(&tty->write_wait);
802 +}
803 +
804 +
805 +static void * usb_serial_probe(struct usb_device *dev, unsigned int ifnum,
806 + const struct usb_device_id *id)
807 +{
808 + struct usb_serial *serial = NULL;
809 + struct usb_serial_port *port;
810 + struct usb_interface *interface;
811 + struct usb_interface_descriptor *iface_desc;
812 + struct usb_endpoint_descriptor *endpoint;
813 + struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
814 + struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
815 + struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
816 + struct usb_serial_device_type *type = NULL;
817 + struct list_head *tmp;
818 + int found;
819 + int minor;
820 + int buffer_size;
821 + int i;
822 + int num_interrupt_in = 0;
823 + int num_bulk_in = 0;
824 + int num_bulk_out = 0;
825 + int num_ports;
826 + int max_endpoints;
827 + const struct usb_device_id *id_pattern = NULL;
828 +
829 + /* loop through our list of known serial converters, and see if this
830 + device matches. */
831 + found = 0;
832 + interface = &dev->actconfig->interface[ifnum];
833 + list_for_each (tmp, &usb_serial_driver_list) {
834 + type = list_entry(tmp, struct usb_serial_device_type, driver_list);
835 + id_pattern = usb_match_id(dev, interface, type->id_table);
836 + if (id_pattern != NULL) {
837 + dbg("descriptor matches");
838 + found = 1;
839 + break;
840 + }
841 + }
842 + if (!found) {
843 + /* no match */
844 + dbg("none matched");
845 + return(NULL);
846 + }
847 + /* descriptor matches, let's find the endpoints needed */
848 + /* check out the endpoints */
849 + iface_desc = &interface->altsetting[0];
850 + for (i = 0; i < iface_desc->bNumEndpoints; ++i) {
851 + endpoint = &iface_desc->endpoint[i];
852 +
853 + if ((endpoint->bEndpointAddress & 0x80) &&
854 + ((endpoint->bmAttributes & 3) == 0x02)) {
855 + /* we found a bulk in endpoint */
856 + dbg("found bulk in");
857 + bulk_in_endpoint[num_bulk_in] = endpoint;
858 + ++num_bulk_in;
859 + }
860 +
861 + if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
862 + ((endpoint->bmAttributes & 3) == 0x02)) {
863 + /* we found a bulk out endpoint */
864 + dbg("found bulk out");
865 + bulk_out_endpoint[num_bulk_out] = endpoint;
866 + ++num_bulk_out;
867 + }
868 +
869 + if ((endpoint->bEndpointAddress & 0x80) &&
870 + ((endpoint->bmAttributes & 3) == 0x03)) {
871 + /* we found a interrupt in endpoint */
872 + dbg("found interrupt in");
873 + interrupt_in_endpoint[num_interrupt_in] = endpoint;
874 + ++num_interrupt_in;
875 + }
876 + }
877 +
878 +#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
879 + /* BEGIN HORRIBLE HACK FOR PL2303 */
880 + /* this is needed due to the looney way its endpoints are set up */
881 + if (((dev->descriptor.idVendor == PL2303_VENDOR_ID) &&
882 + (dev->descriptor.idProduct == PL2303_PRODUCT_ID)) ||
883 + ((dev->descriptor.idVendor == ATEN_VENDOR_ID) &&
884 + (dev->descriptor.idProduct == ATEN_PRODUCT_ID))) {
885 + if (ifnum == 1) {
886 + /* check out the endpoints of the other interface*/
887 + interface = &dev->actconfig->interface[ifnum ^ 1];
888 + iface_desc = &interface->altsetting[0];
889 + for (i = 0; i < iface_desc->bNumEndpoints; ++i) {
890 + endpoint = &iface_desc->endpoint[i];
891 + if ((endpoint->bEndpointAddress & 0x80) &&
892 + ((endpoint->bmAttributes & 3) == 0x03)) {
893 + /* we found a interrupt in endpoint */
894 + dbg("found interrupt in for Prolific device on separate interface");
895 + interrupt_in_endpoint[num_interrupt_in] = endpoint;
896 + ++num_interrupt_in;
897 + }
898 + }
899 + }
900 +
901 + /* Now make sure the PL-2303 is configured correctly.
902 + * If not, give up now and hope this hack will work
903 + * properly during a later invocation of usb_serial_probe
904 + */
905 + if (num_bulk_in == 0 || num_bulk_out == 0) {
906 + info("PL-2303 hack: descriptors matched but endpoints did not");
907 + return NULL;
908 + }
909 + }
910 + /* END HORRIBLE HACK FOR PL2303 */
911 +#endif
912 +
913 + /* found all that we need */
914 + info("%s converter detected", type->name);
915 +
916 +#ifdef CONFIG_USB_SERIAL_SIERRAWIRELESS
917 + if (type == &sierra_driver) {
918 + num_ports = num_bulk_out;
919 + if (num_ports == 0) {
920 + err("Sierra 3G device with no bulk out, not allowed.");
921 + return NULL;
922 + }
923 + } else
924 +#endif
925 + num_ports = type->num_ports;
926 +
927 + serial = get_free_serial (num_ports, &minor);
928 + if (serial == NULL) {
929 + err("No more free serial devices");
930 + return NULL;
931 + }
932 +
933 + serial->dev = dev;
934 + serial->type = type;
935 + serial->interface = interface;
936 + serial->minor = minor;
937 + serial->num_ports = num_ports;
938 + serial->num_bulk_in = num_bulk_in;
939 + serial->num_bulk_out = num_bulk_out;
940 + serial->num_interrupt_in = num_interrupt_in;
941 + serial->vendor = dev->descriptor.idVendor;
942 + serial->product = dev->descriptor.idProduct;
943 +
944 + /* set up the endpoint information */
945 + for (i = 0; i < num_bulk_in; ++i) {
946 + endpoint = bulk_in_endpoint[i];
947 + port = &serial->port[i];
948 + port->read_urb = usb_alloc_urb (0);
949 + if (!port->read_urb) {
950 + err("No free urbs available");
951 + goto probe_error;
952 + }
953 +//Amin marked buffer_size = endpoint->wMaxPacketSize;
954 +// ===> 20060310 Amin modify for improve EVDO and HSDPA Card
955 + buffer_size = 2048;
956 + printk("KERNEL DEBUG => USBSERIAL.O buffer_size = 2048\n");
957 +// <=== 20060310 Amin modify for improve EVDO and HSDPA Card
958 + port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
959 + port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
960 + if (!port->bulk_in_buffer) {
961 + err("Couldn't allocate bulk_in_buffer");
962 + goto probe_error;
963 + }
964 + usb_fill_bulk_urb (port->read_urb, dev,
965 + usb_rcvbulkpipe (dev,
966 + endpoint->bEndpointAddress),
967 + port->bulk_in_buffer, buffer_size,
968 + ((serial->type->read_bulk_callback) ?
969 + serial->type->read_bulk_callback :
970 + sw_usb_serial_generic_read_bulk_callback),
971 + port);
972 + }
973 +
974 + for (i = 0; i < num_bulk_out; ++i) {
975 + endpoint = bulk_out_endpoint[i];
976 + port = &serial->port[i];
977 + port->write_urb = usb_alloc_urb(0);
978 + if (!port->write_urb) {
979 + err("No free urbs available");
980 + goto probe_error;
981 + }
982 + buffer_size = endpoint->wMaxPacketSize;
983 + port->bulk_out_size = buffer_size;
984 + port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
985 + port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
986 + if (!port->bulk_out_buffer) {
987 + err("Couldn't allocate bulk_out_buffer");
988 + goto probe_error;
989 + }
990 + usb_fill_bulk_urb (port->write_urb, dev,
991 + usb_sndbulkpipe (dev,
992 + endpoint->bEndpointAddress),
993 + port->bulk_out_buffer, buffer_size,
994 + ((serial->type->write_bulk_callback) ?
995 + serial->type->write_bulk_callback :
996 + generic_write_bulk_callback),
997 + port);
998 + }
999 +
1000 + for (i = 0; i < num_interrupt_in; ++i) {
1001 + endpoint = interrupt_in_endpoint[i];
1002 + port = &serial->port[i];
1003 + port->interrupt_in_urb = usb_alloc_urb(0);
1004 + if (!port->interrupt_in_urb) {
1005 + err("No free urbs available");
1006 + goto probe_error;
1007 + }
1008 + buffer_size = endpoint->wMaxPacketSize;
1009 + port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
1010 + port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
1011 + if (!port->interrupt_in_buffer) {
1012 + err("Couldn't allocate interrupt_in_buffer");
1013 + goto probe_error;
1014 + }
1015 + usb_fill_int_urb (port->interrupt_in_urb, dev,
1016 + usb_rcvintpipe (dev,
1017 + endpoint->bEndpointAddress),
1018 + port->interrupt_in_buffer, buffer_size,
1019 + serial->type->read_int_callback, port,
1020 + endpoint->bInterval);
1021 + }
1022 +
1023 + /* initialize some parts of the port structures */
1024 + /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
1025 + max_endpoints = max(num_bulk_in, num_bulk_out);
1026 + max_endpoints = max(max_endpoints, num_interrupt_in);
1027 + max_endpoints = max(max_endpoints, (int)serial->num_ports);
1028 + dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
1029 + for (i = 0; i < max_endpoints; ++i) {
1030 + port = &serial->port[i];
1031 + port->number = i + serial->minor;
1032 + port->serial = serial;
1033 + port->magic = USB_SERIAL_PORT_MAGIC;
1034 + port->tqueue.routine = port_softint;
1035 + port->tqueue.data = port;
1036 + init_MUTEX (&port->sem);
1037 + }
1038 +
1039 + /* if this device type has a startup function, call it */
1040 + if (type->startup) {
1041 + i = type->startup (serial);
1042 + if (i < 0)
1043 + goto probe_error;
1044 + if (i > 0)
1045 + return serial;
1046 + }
1047 +
1048 + /* initialize the devfs nodes for this device and let the user know what ports we are bound to */
1049 + for (i = 0; i < serial->num_ports; ++i) {
1050 + tty_register_devfs (&serial_tty_driver, 0, serial->port[i].number);
1051 + info("%s converter now attached to ttyUSB%d (or usb/tts/%d for devfs)",
1052 + type->name, serial->port[i].number, serial->port[i].number);
1053 + }
1054 +
1055 + return serial; /* success */
1056 +
1057 +
1058 +probe_error:
1059 + for (i = 0; i < num_bulk_in; ++i) {
1060 + port = &serial->port[i];
1061 + if (port->read_urb)
1062 + usb_free_urb (port->read_urb);
1063 + if (port->bulk_in_buffer)
1064 + kfree (port->bulk_in_buffer);
1065 + }
1066 + for (i = 0; i < num_bulk_out; ++i) {
1067 + port = &serial->port[i];
1068 + if (port->write_urb)
1069 + usb_free_urb (port->write_urb);
1070 + if (port->bulk_out_buffer)
1071 + kfree (port->bulk_out_buffer);
1072 + }
1073 + for (i = 0; i < num_interrupt_in; ++i) {
1074 + port = &serial->port[i];
1075 + if (port->interrupt_in_urb)
1076 + usb_free_urb (port->interrupt_in_urb);
1077 + if (port->interrupt_in_buffer)
1078 + kfree (port->interrupt_in_buffer);
1079 + }
1080 +
1081 + /* return the minor range that this device had */
1082 + return_serial (serial);
1083 +
1084 + /* free up any memory that we allocated */
1085 + kfree (serial);
1086 + return NULL;
1087 +}
1088 +
1089 +static void usb_serial_disconnect(struct usb_device *dev, void *ptr)
1090 +{
1091 + struct usb_serial *serial = (struct usb_serial *) ptr;
1092 + struct usb_serial_port *port;
1093 + int i;
1094 +
1095 + dbg ("%s", __FUNCTION__);
1096 + if (serial) {
1097 + /* fail all future close/read/write/ioctl/etc calls */
1098 + for (i = 0; i < serial->num_ports; ++i) {
1099 + port = &serial->port[i];
1100 + down (&port->sem);
1101 + if (port->tty != NULL) {
1102 + while (port->open_count > 0) {
1103 + //__serial_close(port, NULL);
1104 + sw_usb_serial_generic_close(port,NULL);
1105 + }
1106 + port->tty->driver_data = NULL;
1107 + }
1108 + up (&port->sem);
1109 + }
1110 +
1111 + serial->dev = NULL;
1112 + //serial_shutdown (serial);
1113 + sw_usb_serial_generic_shutdown(serial);
1114 +
1115 + for (i = 0; i < serial->num_ports; ++i)
1116 + serial->port[i].open_count = 0;
1117 +
1118 + for (i = 0; i < serial->num_bulk_in; ++i) {
1119 + port = &serial->port[i];
1120 + if (port->read_urb) {
1121 + usb_unlink_urb (port->read_urb);
1122 + usb_free_urb (port->read_urb);
1123 + }
1124 + if (port->bulk_in_buffer)
1125 + kfree (port->bulk_in_buffer);
1126 + }
1127 + for (i = 0; i < serial->num_bulk_out; ++i) {
1128 + port = &serial->port[i];
1129 + if (port->write_urb) {
1130 + usb_unlink_urb (port->write_urb);
1131 + usb_free_urb (port->write_urb);
1132 + }
1133 + if (port->bulk_out_buffer)
1134 + kfree (port->bulk_out_buffer);
1135 + }
1136 + for (i = 0; i < serial->num_interrupt_in; ++i) {
1137 + port = &serial->port[i];
1138 + if (port->interrupt_in_urb) {
1139 + usb_unlink_urb (port->interrupt_in_urb);
1140 + usb_free_urb (port->interrupt_in_urb);
1141 + }
1142 + if (port->interrupt_in_buffer)
1143 + kfree (port->interrupt_in_buffer);
1144 + }
1145 +
1146 + for (i = 0; i < serial->num_ports; ++i) {
1147 + tty_unregister_devfs (&serial_tty_driver, serial->port[i].number);
1148 + info("%s converter now disconnected from ttyUSB%d", serial->type->name, serial->port[i].number);
1149 + }
1150 +
1151 + /* return the minor range that this device had */
1152 + return_serial (serial);
1153 +
1154 + /* free up any memory that we allocated */
1155 + kfree (serial);
1156 +
1157 + } else {
1158 + info("device disconnected");
1159 + }
1160 +
1161 +}
1162 +
1163 +#if 0
1164 +static int sw_attach(struct usb_serial *serial)
1165 +{
1166 + struct usb_device *hdev = serial->dev;
1167 + int rc;
1168 +
1169 + dbg("%s - serial(0x%p)", __FUNCTION__, serial);
1170 +
1171 + rc = usb_control_msg(
1172 + hdev,
1173 + usb_sndctrlpipe(hdev, 0),
1174 + USB_VENDER_REQUEST_SET_DEVICE_POWER_STATE, /* bRequest */
1175 + USB_TYPE_VENDOR|USB_RECIP_DEVICE, /* bmRequestType */
1176 + USB_DEVICE_POWER_STATE_D0, /* wValue */
1177 + 0, /* wIndex */
1178 + NULL, /* Data */
1179 + 0, /* wLength */
1180 + 1000); /* Timeout */
1181 +
1182 + err("%s - rc(%d)", __FUNCTION__, rc);
1183 + return rc;
1184 +}
1185 +#endif
1186 +//void sw_usb_serial_generic_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
1187 +static void sw_usb_serial_generic_read_bulk_callback (struct urb *urb)
1188 +{
1189 + struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1190 + struct usb_serial *serial = port->serial;
1191 + struct tty_struct *tty;
1192 + unsigned char *data = urb->transfer_buffer;
1193 + int result;
1194 + int i;
1195 +
1196 + dbg("%s - port %d", __FUNCTION__, port->number);
1197 +
1198 + if (urb->status) {
1199 + dbg("%s - nonzero read bulk status received: %d", __FUNCTION__, urb->status);
1200 + return;
1201 + }
1202 +
1203 + //usb_serial_dbg_data(__FILE__, __FUNCTION__, urb->actual_length, data);
1204 +
1205 + tty = port->tty;
1206 + if (tty && urb->actual_length) {
1207 + #if 0
1208 + tty_buffer_request_room(tty, urb->actual_length);
1209 + tty_insert_flip_string(tty, data, urb->actual_length);
1210 + tty_flip_buffer_push(tty);
1211 + #endif
1212 + #if 1
1213 + for (i = 0; i < urb->actual_length ; ++i) {
1214 + /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
1215 + if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
1216 + tty_flip_buffer_push(tty);
1217 + }
1218 + /* this doesn't actually push the data through unless tty->low_latency is set */
1219 + tty_insert_flip_char(tty, data[i], 0);
1220 + }
1221 + tty_flip_buffer_push(tty);
1222 + #endif
1223 +
1224 + }
1225 + else
1226 + dbg("%s: empty read urb received", __FUNCTION__);
1227 +
1228 + /* Continue trying to always read */
1229 + usb_fill_bulk_urb (port->read_urb, serial->dev,
1230 + usb_rcvbulkpipe (serial->dev,
1231 + port->bulk_in_endpointAddress),
1232 + port->read_urb->transfer_buffer,
1233 + port->read_urb->transfer_buffer_length,
1234 + ((serial->type->read_bulk_callback) ?
1235 + serial->type->read_bulk_callback :
1236 + sw_usb_serial_generic_read_bulk_callback), port);
1237 + result = usb_submit_urb(port->read_urb);
1238 + //result = usb_submit_urb(port->read_urb, GFP_ATOMIC); //for kernel 2.6
1239 + if (result)
1240 + dbg("%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
1241 +}
1242 +#if 1
1243 +static int generic_open (struct usb_serial_port *port, struct file *filp)
1244 +{
1245 + struct usb_serial *serial = port->serial;
1246 + int result = 0;
1247 +
1248 + dbg("%s - port %d", __FUNCTION__, port->number);
1249 +
1250 + /* force low_latency on so that our tty_push actually forces the data through,
1251 + otherwise it is scheduled, and with high data rates (like with OHCI) data
1252 + can get lost. */
1253 + if (port->tty)
1254 + port->tty->low_latency = 1;
1255 +
1256 + /* if we have a bulk interrupt, start reading from it */
1257 + if (serial->num_bulk_in) {
1258 + /* Start reading from the device */
1259 + usb_fill_bulk_urb (port->read_urb, serial->dev,
1260 + usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
1261 + port->read_urb->transfer_buffer,
1262 + port->read_urb->transfer_buffer_length,
1263 + ((serial->type->read_bulk_callback) ?
1264 + serial->type->read_bulk_callback :
1265 + sw_usb_serial_generic_read_bulk_callback),
1266 + port);
1267 + result = usb_submit_urb(port->read_urb); //, GFP_KERNEL);
1268 + if (result)
1269 + //dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
1270 + dbg("%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
1271 +
1272 + }
1273 +
1274 + return result;
1275 +}
1276 +#endif
1277 +int sw_usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
1278 +{
1279 + int rc;
1280 + struct usb_serial *serial = port->serial;
1281 + struct usb_device *hdev = serial->dev;
1282 +
1283 + dbg("%s - port %d", __FUNCTION__, port->number);
1284 +
1285 + rc = generic_open(port, filp);
1286 + err("%s - rc(%d)", __FUNCTION__, rc);
1287 +
1288 + if(0 == rc)
1289 + {
1290 + rc = usb_control_msg(
1291 + hdev,
1292 + usb_sndctrlpipe(hdev, 0),
1293 + SET_CONTROL_LINE_STATE, /* bRequest */
1294 + USB_TYPE_CLASS|USB_RECIP_INTERFACE, /* bmRequestType */
1295 + ACM_CTRL_DTR|ACM_CTRL_RTS, /* wValue */
1296 + 0, /* wIndex */
1297 + NULL, /* Data */
1298 + 0, /* wLength */
1299 + 1000); /* Timeout */
1300 + err("%s - usb_control_msg: rc(%d)", __FUNCTION__, rc);
1301 + }
1302 +
1303 + return rc;
1304 +}
1305 +
1306 +static void generic_cleanup (struct usb_serial_port *port)
1307 +{
1308 + struct usb_serial *serial = port->serial;
1309 +
1310 + dbg("%s - port %d", __FUNCTION__, port->number);
1311 +
1312 + if (serial->dev) {
1313 + /* shutdown any bulk reads that might be going on */
1314 + if (serial->num_bulk_out)
1315 + usb_unlink_urb(port->write_urb);
1316 + //usb_kill_urb(port->write_urb);
1317 + if (serial->num_bulk_in)
1318 + usb_unlink_urb(port->read_urb);
1319 + //usb_kill_urb(port->read_urb);
1320 + }
1321 +}
1322 +
1323 +static void sw_usb_serial_generic_close (struct usb_serial_port *port, struct file * filp)
1324 +{
1325 + int rc;
1326 + struct usb_serial *serial = port->serial;
1327 + struct usb_device *hdev = serial->dev;
1328 +
1329 + dbg("%s - port %d", __FUNCTION__, port->number);
1330 +
1331 + rc = usb_control_msg(
1332 + hdev,
1333 + usb_sndctrlpipe(hdev, 0),
1334 + SET_CONTROL_LINE_STATE, /* bRequest */
1335 + USB_TYPE_CLASS|USB_RECIP_INTERFACE, /* bmRequestType */
1336 + 0, /* wValue */
1337 + 0, /* wIndex */
1338 + NULL, /* Data */
1339 + 0, /* wLength */
1340 + 1000); /* Timeout */
1341 + err("%s - rc(%d)", __FUNCTION__, rc);
1342 +
1343 + generic_cleanup (port);
1344 +}
1345 +
1346 +static void sw_usb_serial_generic_shutdown(struct usb_serial *serial)
1347 +{
1348 + int i, rc;
1349 + struct usb_device *hdev = serial->dev;
1350 +
1351 + dbg("%s serial(0x%p)", __FUNCTION__, serial);
1352 +
1353 + if(hdev)
1354 + {
1355 + rc = usb_control_msg(
1356 + hdev,
1357 + usb_sndctrlpipe(hdev, 0),
1358 + USB_VENDER_REQUEST_SET_DEVICE_POWER_STATE, /* bRequest */
1359 + USB_TYPE_VENDOR|USB_RECIP_DEVICE, /* bmRequestType */
1360 + USB_DEVICE_POWER_STATE_D3, /* wValue */
1361 + 0, /* wIndex */
1362 + NULL, /* Data */
1363 + 0, /* wLength */
1364 + 1000); /* Timeout */
1365 + err("%s - rc(%d)", __FUNCTION__, rc);
1366 + }
1367 +
1368 + /* stop reads and writes on all ports */
1369 + for (i=0; i < serial->num_ports; ++i) {
1370 + generic_cleanup(&serial->port[i]);
1371 + }
1372 +}
1373 +int usb_serial_register(struct usb_serial_device_type *new_device)
1374 +{
1375 + /* Add this device to our list of devices */
1376 + list_add(&new_device->driver_list, &usb_serial_driver_list);
1377 +
1378 + info ("USB Serial support registered for %s", new_device->name);
1379 +
1380 + usb_scan_devices();
1381 +
1382 + return 0;
1383 +}
1384 +
1385 +
1386 +void usb_serial_deregister(struct usb_serial_device_type *device)
1387 +{
1388 + struct usb_serial *serial;
1389 + int i;
1390 +
1391 + info("USB Serial deregistering driver %s", device->name);
1392 +
1393 + /* clear out the serial_table if the device is attached to a port */
1394 + for(i = 0; i < SERIAL_TTY_MINORS; ++i) {
1395 + serial = serial_table[i];
1396 + if ((serial != NULL) && (serial->type == device)) {
1397 + usb_driver_release_interface (&sierra_driver, serial->interface);
1398 + usb_serial_disconnect (NULL, serial);
1399 + }
1400 + }
1401 +
1402 + list_del(&device->driver_list);
1403 +}
1404 +
1405 +static int __init sierra_init(void)
1406 +{
1407 + int retval;
1408 + int i;
1409 +
1410 + /* Initalize our global data */
1411 + for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1412 + serial_table[i] = NULL;
1413 + }
1414 +
1415 + /* register the tty driver */
1416 + serial_tty_driver.init_termios = tty_std_termios;
1417 + serial_tty_driver.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1418 + if (tty_register_driver (&serial_tty_driver)) {
1419 + err("%s - failed to register tty driver", __FUNCTION__);
1420 + return -1;
1421 + }
1422 +
1423 + retval = usb_serial_register(&sierra_device);
1424 + if (retval)
1425 + {
1426 + tty_unregister_driver(&serial_tty_driver);
1427 + printk("%s return usb_serial_register. retval=[%d].\n",__FUNCTION__, retval);
1428 + return retval;
1429 + }
1430 + retval = usb_register(&sierra_driver);
1431 + if (retval){
1432 + usb_serial_deregister(&sierra_device);
1433 + tty_unregister_driver(&serial_tty_driver);
1434 + err("usb_register failed for the Sierra 3G USB-Serial driver. Error number %d\n", retval);
1435 + return -1;
1436 + }
1437 +
1438 + return retval;
1439 +}
1440 +
1441 +static void __exit sierra_exit(void)
1442 +{
1443 + usb_deregister(&sierra_driver);
1444 + usb_serial_deregister(&sierra_device);
1445 +}
1446 +
1447 +module_init(sierra_init);
1448 +module_exit(sierra_exit);
1449 +MODULE_LICENSE("GPL");
1450 --- /dev/null
1451 +++ b/drivers/usb/serial/sierra.h
1452 @@ -0,0 +1,32 @@
1453 +/*
1454 + * Sierra Wireless CDMA Wireless Serial USB drive
1455 + *
1456 + * Current Copy modified by: Kevin Lloyd <linux@sierrawireless.com>
1457 + * Original Copy written by: 2005 Greg Kroah-Hartman <gregkh <at> suse.de>
1458 + *
1459 + *
1460 + * This program is free software; you can redistribute it and/or
1461 + * modify it under the terms of the GNU General Public License version
1462 + * 2 as published by the Free Software Foundation.
1463 + *
1464 + * Version history:
1465 + Version 1.03 (Lloyd):
1466 + Included support for DTR control and enhanced buffering (should help
1467 + speed).
1468 + */
1469 +
1470 +#define USB_VENDER_REQUEST_SET_DEVICE_POWER_STATE 0
1471 +
1472 +#define USB_DEVICE_POWER_STATE_D0 0x0000
1473 +#define USB_DEVICE_POWER_STATE_D1 0x0001
1474 +#define USB_DEVICE_POWER_STATE_D2 0x0002
1475 +#define USB_DEVICE_POWER_STATE_D3 0x0003
1476 +
1477 +#define SET_CONTROL_LINE_STATE 0x22
1478 +/*
1479 + * Output control lines.
1480 + */
1481 +
1482 +#define ACM_CTRL_DTR 0x01
1483 +#define ACM_CTRL_RTS 0x02
1484 +
Personal OpenWRT clone
This page took 0.098367 seconds and 5 git commands to generate.