?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usb-serial: add missing tests and debug lines
[linux-2.6/mini2440.git] / drivers / usb / serial / usb-serial.c
blob9a3258046c8cdc4daf4079208f4da556858ae841
1 /*
2 * USB Serial Converter driver
3 *
4 * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
6 * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version
10 * 2 as published by the Free Software Foundation.
11 *
12 * This driver was originally based on the ACM driver by Armin Fuerst (which was
13 * based on a driver by Brad Keryan)
14 *
15 * See Documentation/usb/usb-serial.txt for more information on using this
16 * driver
17 *
18 */
19
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/smp_lock.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/moduleparam.h>
30 #include <linux/seq_file.h>
31 #include <linux/spinlock.h>
32 #include <linux/mutex.h>
33 #include <linux/list.h>
34 #include <linux/uaccess.h>
35 #include <linux/serial.h>
36 #include <linux/usb.h>
37 #include <linux/usb/serial.h>
38 #include "pl2303.h"
39
40 /*
41 * Version Information
42 */
43 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
44 #define DRIVER_DESC "USB Serial Driver core"
45
46 /* Driver structure we register with the USB core */
47 static struct usb_driver usb_serial_driver = {
48 .name = "usbserial",
49 .probe = usb_serial_probe,
50 .disconnect = usb_serial_disconnect,
51 .suspend = usb_serial_suspend,
52 .resume = usb_serial_resume,
53 .no_dynamic_id = 1,
54 };
55
56 /* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead
57 the MODULE_DEVICE_TABLE declarations in each serial driver
58 cause the "hotplug" program to pull in whatever module is necessary
59 via modprobe, and modprobe will load usbserial because the serial
60 drivers depend on it.
61 */
62
63 static int debug;
64 /* initially all NULL */
65 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
66 static DEFINE_MUTEX(table_lock);
67 static LIST_HEAD(usb_serial_driver_list);
68
69 /*
70 * Look up the serial structure. If it is found and it hasn't been
71 * disconnected, return with its disc_mutex held and its refcount
72 * incremented. Otherwise return NULL.
73 */
74 struct usb_serial *usb_serial_get_by_index(unsigned index)
75 {
76 struct usb_serial *serial;
77
78 mutex_lock(&table_lock);
79 serial = serial_table[index];
80
81 if (serial) {
82 mutex_lock(&serial->disc_mutex);
83 if (serial->disconnected) {
84 mutex_unlock(&serial->disc_mutex);
85 serial = NULL;
86 } else {
87 kref_get(&serial->kref);
88 }
89 }
90 mutex_unlock(&table_lock);
91 return serial;
92 }
93
94 static struct usb_serial *get_free_serial(struct usb_serial *serial,
95 int num_ports, unsigned int *minor)
96 {
97 unsigned int i, j;
98 int good_spot;
99
100 dbg("%s %d", __func__, num_ports);
101
102 *minor = 0;
103 mutex_lock(&table_lock);
104 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
105 if (serial_table[i])
106 continue;
107
108 good_spot = 1;
109 for (j = 1; j <= num_ports-1; ++j)
110 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
111 good_spot = 0;
112 i += j;
113 break;
114 }
115 if (good_spot == 0)
116 continue;
117
118 *minor = i;
119 j = 0;
120 dbg("%s - minor base = %d", __func__, *minor);
121 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
122 serial_table[i] = serial;
123 serial->port[j++]->number = i;
124 }
125 mutex_unlock(&table_lock);
126 return serial;
127 }
128 mutex_unlock(&table_lock);
129 return NULL;
130 }
131
132 static void return_serial(struct usb_serial *serial)
133 {
134 int i;
135
136 dbg("%s", __func__);
137
138 mutex_lock(&table_lock);
139 for (i = 0; i < serial->num_ports; ++i)
140 serial_table[serial->minor + i] = NULL;
141 mutex_unlock(&table_lock);
142 }
143
144 static void destroy_serial(struct kref *kref)
145 {
146 struct usb_serial *serial;
147 struct usb_serial_port *port;
148 int i;
149
150 serial = to_usb_serial(kref);
151
152 dbg("%s - %s", __func__, serial->type->description);
153
154 /* return the minor range that this device had */
155 if (serial->minor != SERIAL_TTY_NO_MINOR)
156 return_serial(serial);
157
158 serial->type->release(serial);
159
160 /* Now that nothing is using the ports, they can be freed */
161 for (i = 0; i < serial->num_port_pointers; ++i) {
162 port = serial->port[i];
163 if (port) {
164 port->serial = NULL;
165 put_device(&port->dev);
166 }
167 }
168
169 usb_put_dev(serial->dev);
170 kfree(serial);
171 }
172
173 void usb_serial_put(struct usb_serial *serial)
174 {
175 kref_put(&serial->kref, destroy_serial);
176 }
177
178 /*****************************************************************************
179 * Driver tty interface functions
180 *****************************************************************************/
181
182 /**
183 * serial_install - install tty
184 * @driver: the driver (USB in our case)
185 * @tty: the tty being created
186 *
187 * Create the termios objects for this tty. We use the default
188 * USB serial settings but permit them to be overridden by
189 * serial->type->init_termios.
190 *
191 * This is the first place a new tty gets used. Hence this is where we
192 * acquire references to the usb_serial structure and the driver module,
193 * where we store a pointer to the port, and where we do an autoresume.
194 * All these actions are reversed in serial_release().
195 */
196 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
197 {
198 int idx = tty->index;
199 struct usb_serial *serial;
200 struct usb_serial_port *port;
201 int retval = -ENODEV;
202
203 dbg("%s", __func__);
204
205 serial = usb_serial_get_by_index(idx);
206 if (!serial)
207 return retval;
208
209 port = serial->port[idx - serial->minor];
210 if (!port)
211 goto error_no_port;
212 if (!try_module_get(serial->type->driver.owner))
213 goto error_module_get;
214
215 /* perform the standard setup */
216 retval = tty_init_termios(tty);
217 if (retval)
218 goto error_init_termios;
219
220 retval = usb_autopm_get_interface(serial->interface);
221 if (retval)
222 goto error_get_interface;
223
224 mutex_unlock(&serial->disc_mutex);
225
226 /* allow the driver to update the settings */
227 if (serial->type->init_termios)
228 serial->type->init_termios(tty);
229
230 tty->driver_data = port;
231
232 /* Final install (we use the default method) */
233 tty_driver_kref_get(driver);
234 tty->count++;
235 driver->ttys[idx] = tty;
236 return retval;
237
238 error_get_interface:
239 error_init_termios:
240 module_put(serial->type->driver.owner);
241 error_module_get:
242 error_no_port:
243 usb_serial_put(serial);
244 mutex_unlock(&serial->disc_mutex);
245 return retval;
246 }
247
248 static int serial_open (struct tty_struct *tty, struct file *filp)
249 {
250 struct usb_serial *serial;
251 struct usb_serial_port *port;
252 int retval = 0;
253 int first = 0;
254
255 port = tty->driver_data;
256 serial = port->serial;
257
258 dbg("%s - port %d", __func__, port->number);
259
260 if (mutex_lock_interruptible(&port->mutex))
261 return -ERESTARTSYS;
262
263 ++port->port.count;
264 tty_port_tty_set(&port->port, tty);
265
266 /* If the console is attached, the device is already open */
267 if (port->port.count == 1 && !port->console) {
268 first = 1;
269 mutex_lock(&serial->disc_mutex);
270
271 /* only call the device specific open if this
272 * is the first time the port is opened */
273 retval = serial->type->open(tty, port);
274 if (retval)
275 goto bailout_module_put;
276 mutex_unlock(&serial->disc_mutex);
277 set_bit(ASYNCB_INITIALIZED, &port->port.flags);
278 }
279 mutex_unlock(&port->mutex);
280 /* Now do the correct tty layer semantics */
281 retval = tty_port_block_til_ready(&port->port, tty, filp);
282 if (retval == 0) {
283 if (!first)
284 usb_serial_put(serial);
285 return 0;
286 }
287 mutex_lock(&port->mutex);
288 if (first == 0)
289 goto bailout_mutex_unlock;
290 /* Undo the initial port actions */
291 mutex_lock(&serial->disc_mutex);
292 bailout_module_put:
293 mutex_unlock(&serial->disc_mutex);
294 bailout_mutex_unlock:
295 port->port.count = 0;
296 mutex_unlock(&port->mutex);
297 return retval;
298 }
299
300 /**
301 * serial_down - shut down hardware
302 * @port: port to shut down
303 *
304 * Shut down a USB serial port unless it is the console. We never
305 * shut down the console hardware as it will always be in use.
306 */
307 static void serial_down(struct usb_serial_port *port)
308 {
309 struct usb_serial_driver *drv = port->serial->type;
310 struct usb_serial *serial;
311 struct module *owner;
312
313 /*
314 * The console is magical. Do not hang up the console hardware
315 * or there will be tears.
316 */
317 if (port->console)
318 return;
319
320 /* Don't call the close method if the hardware hasn't been
321 * initialized.
322 */
323 if (!test_and_clear_bit(ASYNCB_INITIALIZED, &port->port.flags))
324 return;
325
326 mutex_lock(&port->mutex);
327 serial = port->serial;
328 owner = serial->type->driver.owner;
329
330 if (drv->close)
331 drv->close(port);
332
333 mutex_unlock(&port->mutex);
334 }
335
336 static void serial_hangup(struct tty_struct *tty)
337 {
338 struct usb_serial_port *port = tty->driver_data;
339
340 dbg("%s - port %d", __func__, port->number);
341
342 serial_down(port);
343 tty_port_hangup(&port->port);
344 }
345
346 static void serial_close(struct tty_struct *tty, struct file *filp)
347 {
348 struct usb_serial_port *port = tty->driver_data;
349
350 dbg("%s - port %d", __func__, port->number);
351
352 if (tty_hung_up_p(filp))
353 return;
354 if (tty_port_close_start(&port->port, tty, filp) == 0)
355 return;
356 serial_down(port);
357 tty_port_close_end(&port->port, tty);
358 tty_port_tty_set(&port->port, NULL);
359 }
360
361 /**
362 * serial_release - free resources post close/hangup
363 * @port: port to free up
364 *
365 * Do the resource freeing and refcount dropping for the port.
366 * Avoid freeing the console.
367 *
368 * Called when the last tty kref is dropped.
369 */
370 static void serial_release(struct tty_struct *tty)
371 {
372 struct usb_serial_port *port = tty->driver_data;
373 struct usb_serial *serial;
374 struct module *owner;
375
376 /* The console is magical. Do not hang up the console hardware
377 * or there will be tears.
378 */
379 if (port->console)
380 return;
381
382 dbg("%s - port %d", __func__, port->number);
383
384 /* Standard shutdown processing */
385 tty_shutdown(tty);
386
387 tty->driver_data = NULL;
388
389 serial = port->serial;
390 owner = serial->type->driver.owner;
391
392 mutex_lock(&serial->disc_mutex);
393 if (!serial->disconnected)
394 usb_autopm_put_interface(serial->interface);
395 mutex_unlock(&serial->disc_mutex);
396
397 usb_serial_put(serial);
398 module_put(owner);
399 }
400
401 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
402 int count)
403 {
404 struct usb_serial_port *port = tty->driver_data;
405 int retval = -ENODEV;
406
407 if (port->serial->dev->state == USB_STATE_NOTATTACHED)
408 goto exit;
409
410 dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
411
412 /* count is managed under the mutex lock for the tty so cannot
413 drop to zero until after the last close completes */
414 WARN_ON(!port->port.count);
415
416 /* pass on to the driver specific version of this function */
417 retval = port->serial->type->write(tty, port, buf, count);
418
419 exit:
420 return retval;
421 }
422
423 static int serial_write_room(struct tty_struct *tty)
424 {
425 struct usb_serial_port *port = tty->driver_data;
426 dbg("%s - port %d", __func__, port->number);
427 WARN_ON(!port->port.count);
428 /* pass on to the driver specific version of this function */
429 return port->serial->type->write_room(tty);
430 }
431
432 static int serial_chars_in_buffer(struct tty_struct *tty)
433 {
434 struct usb_serial_port *port = tty->driver_data;
435 dbg("%s = port %d", __func__, port->number);
436
437 /* if the device was unplugged then any remaining characters
438 fell out of the connector ;) */
439 if (port->serial->disconnected)
440 return 0;
441 /* pass on to the driver specific version of this function */
442 return port->serial->type->chars_in_buffer(tty);
443 }
444
445 static void serial_throttle(struct tty_struct *tty)
446 {
447 struct usb_serial_port *port = tty->driver_data;
448 dbg("%s - port %d", __func__, port->number);
449
450 WARN_ON(!port->port.count);
451 /* pass on to the driver specific version of this function */
452 if (port->serial->type->throttle)
453 port->serial->type->throttle(tty);
454 }
455
456 static void serial_unthrottle(struct tty_struct *tty)
457 {
458 struct usb_serial_port *port = tty->driver_data;
459 dbg("%s - port %d", __func__, port->number);
460
461 WARN_ON(!port->port.count);
462 /* pass on to the driver specific version of this function */
463 if (port->serial->type->unthrottle)
464 port->serial->type->unthrottle(tty);
465 }
466
467 static int serial_ioctl(struct tty_struct *tty, struct file *file,
468 unsigned int cmd, unsigned long arg)
469 {
470 struct usb_serial_port *port = tty->driver_data;
471 int retval = -ENODEV;
472
473 dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
474
475 WARN_ON(!port->port.count);
476
477 /* pass on to the driver specific version of this function
478 if it is available */
479 if (port->serial->type->ioctl) {
480 retval = port->serial->type->ioctl(tty, file, cmd, arg);
481 } else
482 retval = -ENOIOCTLCMD;
483 return retval;
484 }
485
486 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
487 {
488 struct usb_serial_port *port = tty->driver_data;
489 dbg("%s - port %d", __func__, port->number);
490
491 WARN_ON(!port->port.count);
492 /* pass on to the driver specific version of this function
493 if it is available */
494 if (port->serial->type->set_termios)
495 port->serial->type->set_termios(tty, port, old);
496 else
497 tty_termios_copy_hw(tty->termios, old);
498 }
499
500 static int serial_break(struct tty_struct *tty, int break_state)
501 {
502 struct usb_serial_port *port = tty->driver_data;
503
504 dbg("%s - port %d", __func__, port->number);
505
506 WARN_ON(!port->port.count);
507 /* pass on to the driver specific version of this function
508 if it is available */
509 if (port->serial->type->break_ctl)
510 port->serial->type->break_ctl(tty, break_state);
511 return 0;
512 }
513
514 static int serial_proc_show(struct seq_file *m, void *v)
515 {
516 struct usb_serial *serial;
517 int i;
518 char tmp[40];
519
520 dbg("%s", __func__);
521 seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
522 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
523 serial = usb_serial_get_by_index(i);
524 if (serial == NULL)
525 continue;
526
527 seq_printf(m, "%d:", i);
528 if (serial->type->driver.owner)
529 seq_printf(m, " module:%s",
530 module_name(serial->type->driver.owner));
531 seq_printf(m, " name:\"%s\"",
532 serial->type->description);
533 seq_printf(m, " vendor:%04x product:%04x",
534 le16_to_cpu(serial->dev->descriptor.idVendor),
535 le16_to_cpu(serial->dev->descriptor.idProduct));
536 seq_printf(m, " num_ports:%d", serial->num_ports);
537 seq_printf(m, " port:%d", i - serial->minor + 1);
538 usb_make_path(serial->dev, tmp, sizeof(tmp));
539 seq_printf(m, " path:%s", tmp);
540
541 seq_putc(m, '\n');
542 usb_serial_put(serial);
543 mutex_unlock(&serial->disc_mutex);
544 }
545 return 0;
546 }
547
548 static int serial_proc_open(struct inode *inode, struct file *file)
549 {
550 return single_open(file, serial_proc_show, NULL);
551 }
552
553 static const struct file_operations serial_proc_fops = {
554 .owner = THIS_MODULE,
555 .open = serial_proc_open,
556 .read = seq_read,
557 .llseek = seq_lseek,
558 .release = single_release,
559 };
560
561 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
562 {
563 struct usb_serial_port *port = tty->driver_data;
564
565 dbg("%s - port %d", __func__, port->number);
566
567 WARN_ON(!port->port.count);
568 if (port->serial->type->tiocmget)
569 return port->serial->type->tiocmget(tty, file);
570 return -EINVAL;
571 }
572
573 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
574 unsigned int set, unsigned int clear)
575 {
576 struct usb_serial_port *port = tty->driver_data;
577
578 dbg("%s - port %d", __func__, port->number);
579
580 WARN_ON(!port->port.count);
581 if (port->serial->type->tiocmset)
582 return port->serial->type->tiocmset(tty, file, set, clear);
583 return -EINVAL;
584 }
585
586 /*
587 * We would be calling tty_wakeup here, but unfortunately some line
588 * disciplines have an annoying habit of calling tty->write from
589 * the write wakeup callback (e.g. n_hdlc.c).
590 */
591 void usb_serial_port_softint(struct usb_serial_port *port)
592 {
593 schedule_work(&port->work);
594 }
595 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
596
597 static void usb_serial_port_work(struct work_struct *work)
598 {
599 struct usb_serial_port *port =
600 container_of(work, struct usb_serial_port, work);
601 struct tty_struct *tty;
602
603 dbg("%s - port %d", __func__, port->number);
604
605 tty = tty_port_tty_get(&port->port);
606 if (!tty)
607 return;
608
609 tty_wakeup(tty);
610 tty_kref_put(tty);
611 }
612
613 static void kill_traffic(struct usb_serial_port *port)
614 {
615 usb_kill_urb(port->read_urb);
616 usb_kill_urb(port->write_urb);
617 /*
618 * This is tricky.
619 * Some drivers submit the read_urb in the
620 * handler for the write_urb or vice versa
621 * this order determines the order in which
622 * usb_kill_urb() must be used to reliably
623 * kill the URBs. As it is unknown here,
624 * both orders must be used in turn.
625 * The call below is not redundant.
626 */
627 usb_kill_urb(port->read_urb);
628 usb_kill_urb(port->interrupt_in_urb);
629 usb_kill_urb(port->interrupt_out_urb);
630 }
631
632 static void port_release(struct device *dev)
633 {
634 struct usb_serial_port *port = to_usb_serial_port(dev);
635
636 dbg ("%s - %s", __func__, dev_name(dev));
637
638 /*
639 * Stop all the traffic before cancelling the work, so that
640 * nobody will restart it by calling usb_serial_port_softint.
641 */
642 kill_traffic(port);
643 cancel_work_sync(&port->work);
644
645 usb_free_urb(port->read_urb);
646 usb_free_urb(port->write_urb);
647 usb_free_urb(port->interrupt_in_urb);
648 usb_free_urb(port->interrupt_out_urb);
649 kfree(port->bulk_in_buffer);
650 kfree(port->bulk_out_buffer);
651 kfree(port->interrupt_in_buffer);
652 kfree(port->interrupt_out_buffer);
653 kfree(port);
654 }
655
656 static struct usb_serial *create_serial(struct usb_device *dev,
657 struct usb_interface *interface,
658 struct usb_serial_driver *driver)
659 {
660 struct usb_serial *serial;
661
662 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
663 if (!serial) {
664 dev_err(&dev->dev, "%s - out of memory\n", __func__);
665 return NULL;
666 }
667 serial->dev = usb_get_dev(dev);
668 serial->type = driver;
669 serial->interface = interface;
670 kref_init(&serial->kref);
671 mutex_init(&serial->disc_mutex);
672 serial->minor = SERIAL_TTY_NO_MINOR;
673
674 return serial;
675 }
676
677 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
678 struct usb_serial_driver *drv)
679 {
680 struct usb_dynid *dynid;
681
682 spin_lock(&drv->dynids.lock);
683 list_for_each_entry(dynid, &drv->dynids.list, node) {
684 if (usb_match_one_id(intf, &dynid->id)) {
685 spin_unlock(&drv->dynids.lock);
686 return &dynid->id;
687 }
688 }
689 spin_unlock(&drv->dynids.lock);
690 return NULL;
691 }
692
693 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
694 struct usb_interface *intf)
695 {
696 const struct usb_device_id *id;
697
698 id = usb_match_id(intf, drv->id_table);
699 if (id) {
700 dbg("static descriptor matches");
701 goto exit;
702 }
703 id = match_dynamic_id(intf, drv);
704 if (id)
705 dbg("dynamic descriptor matches");
706 exit:
707 return id;
708 }
709
710 static struct usb_serial_driver *search_serial_device(
711 struct usb_interface *iface)
712 {
713 const struct usb_device_id *id;
714 struct usb_serial_driver *drv;
715
716 /* Check if the usb id matches a known device */
717 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
718 id = get_iface_id(drv, iface);
719 if (id)
720 return drv;
721 }
722
723 return NULL;
724 }
725
726 static int serial_carrier_raised(struct tty_port *port)
727 {
728 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
729 struct usb_serial_driver *drv = p->serial->type;
730 if (drv->carrier_raised)
731 return drv->carrier_raised(p);
732 /* No carrier control - don't block */
733 return 1;
734 }
735
736 static void serial_dtr_rts(struct tty_port *port, int on)
737 {
738 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
739 struct usb_serial_driver *drv = p->serial->type;
740 if (drv->dtr_rts)
741 drv->dtr_rts(p, on);
742 }
743
744 static const struct tty_port_operations serial_port_ops = {
745 .carrier_raised = serial_carrier_raised,
746 .dtr_rts = serial_dtr_rts,
747 };
748
749 int usb_serial_probe(struct usb_interface *interface,
750 const struct usb_device_id *id)
751 {
752 struct usb_device *dev = interface_to_usbdev(interface);
753 struct usb_serial *serial = NULL;
754 struct usb_serial_port *port;
755 struct usb_host_interface *iface_desc;
756 struct usb_endpoint_descriptor *endpoint;
757 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
758 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
759 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
760 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
761 struct usb_serial_driver *type = NULL;
762 int retval;
763 unsigned int minor;
764 int buffer_size;
765 int i;
766 int num_interrupt_in = 0;
767 int num_interrupt_out = 0;
768 int num_bulk_in = 0;
769 int num_bulk_out = 0;
770 int num_ports = 0;
771 int max_endpoints;
772
773 lock_kernel(); /* guard against unloading a serial driver module */
774 type = search_serial_device(interface);
775 if (!type) {
776 unlock_kernel();
777 dbg("none matched");
778 return -ENODEV;
779 }
780
781 serial = create_serial(dev, interface, type);
782 if (!serial) {
783 unlock_kernel();
784 dev_err(&interface->dev, "%s - out of memory\n", __func__);
785 return -ENOMEM;
786 }
787
788 /* if this device type has a probe function, call it */
789 if (type->probe) {
790 const struct usb_device_id *id;
791
792 if (!try_module_get(type->driver.owner)) {
793 unlock_kernel();
794 dev_err(&interface->dev,
795 "module get failed, exiting\n");
796 kfree(serial);
797 return -EIO;
798 }
799
800 id = get_iface_id(type, interface);
801 retval = type->probe(serial, id);
802 module_put(type->driver.owner);
803
804 if (retval) {
805 unlock_kernel();
806 dbg("sub driver rejected device");
807 kfree(serial);
808 return retval;
809 }
810 }
811
812 /* descriptor matches, let's find the endpoints needed */
813 /* check out the endpoints */
814 iface_desc = interface->cur_altsetting;
815 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
816 endpoint = &iface_desc->endpoint[i].desc;
817
818 if (usb_endpoint_is_bulk_in(endpoint)) {
819 /* we found a bulk in endpoint */
820 dbg("found bulk in on endpoint %d", i);
821 bulk_in_endpoint[num_bulk_in] = endpoint;
822 ++num_bulk_in;
823 }
824
825 if (usb_endpoint_is_bulk_out(endpoint)) {
826 /* we found a bulk out endpoint */
827 dbg("found bulk out on endpoint %d", i);
828 bulk_out_endpoint[num_bulk_out] = endpoint;
829 ++num_bulk_out;
830 }
831
832 if (usb_endpoint_is_int_in(endpoint)) {
833 /* we found a interrupt in endpoint */
834 dbg("found interrupt in on endpoint %d", i);
835 interrupt_in_endpoint[num_interrupt_in] = endpoint;
836 ++num_interrupt_in;
837 }
838
839 if (usb_endpoint_is_int_out(endpoint)) {
840 /* we found an interrupt out endpoint */
841 dbg("found interrupt out on endpoint %d", i);
842 interrupt_out_endpoint[num_interrupt_out] = endpoint;
843 ++num_interrupt_out;
844 }
845 }
846
847 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
848 /* BEGIN HORRIBLE HACK FOR PL2303 */
849 /* this is needed due to the looney way its endpoints are set up */
850 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
851 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
852 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
853 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
854 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
855 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
856 ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
857 (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
858 if (interface != dev->actconfig->interface[0]) {
859 /* check out the endpoints of the other interface*/
860 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
861 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
862 endpoint = &iface_desc->endpoint[i].desc;
863 if (usb_endpoint_is_int_in(endpoint)) {
864 /* we found a interrupt in endpoint */
865 dbg("found interrupt in for Prolific device on separate interface");
866 interrupt_in_endpoint[num_interrupt_in] = endpoint;
867 ++num_interrupt_in;
868 }
869 }
870 }
871
872 /* Now make sure the PL-2303 is configured correctly.
873 * If not, give up now and hope this hack will work
874 * properly during a later invocation of usb_serial_probe
875 */
876 if (num_bulk_in == 0 || num_bulk_out == 0) {
877 unlock_kernel();
878 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
879 kfree(serial);
880 return -ENODEV;
881 }
882 }
883 /* END HORRIBLE HACK FOR PL2303 */
884 #endif
885
886 #ifdef CONFIG_USB_SERIAL_GENERIC
887 if (type == &usb_serial_generic_device) {
888 num_ports = num_bulk_out;
889 if (num_ports == 0) {
890 unlock_kernel();
891 dev_err(&interface->dev,
892 "Generic device with no bulk out, not allowed.\n");
893 kfree(serial);
894 return -EIO;
895 }
896 }
897 #endif
898 if (!num_ports) {
899 /* if this device type has a calc_num_ports function, call it */
900 if (type->calc_num_ports) {
901 if (!try_module_get(type->driver.owner)) {
902 unlock_kernel();
903 dev_err(&interface->dev,
904 "module get failed, exiting\n");
905 kfree(serial);
906 return -EIO;
907 }
908 num_ports = type->calc_num_ports(serial);
909 module_put(type->driver.owner);
910 }
911 if (!num_ports)
912 num_ports = type->num_ports;
913 }
914
915 serial->num_ports = num_ports;
916 serial->num_bulk_in = num_bulk_in;
917 serial->num_bulk_out = num_bulk_out;
918 serial->num_interrupt_in = num_interrupt_in;
919 serial->num_interrupt_out = num_interrupt_out;
920
921 /* found all that we need */
922 dev_info(&interface->dev, "%s converter detected\n",
923 type->description);
924
925 /* create our ports, we need as many as the max endpoints */
926 /* we don't use num_ports here because some devices have more
927 endpoint pairs than ports */
928 max_endpoints = max(num_bulk_in, num_bulk_out);
929 max_endpoints = max(max_endpoints, num_interrupt_in);
930 max_endpoints = max(max_endpoints, num_interrupt_out);
931 max_endpoints = max(max_endpoints, (int)serial->num_ports);
932 serial->num_port_pointers = max_endpoints;
933 unlock_kernel();
934
935 dbg("%s - setting up %d port structures for this device",
936 __func__, max_endpoints);
937 for (i = 0; i < max_endpoints; ++i) {
938 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
939 if (!port)
940 goto probe_error;
941 tty_port_init(&port->port);
942 port->port.ops = &serial_port_ops;
943 port->serial = serial;
944 spin_lock_init(&port->lock);
945 mutex_init(&port->mutex);
946 INIT_WORK(&port->work, usb_serial_port_work);
947 serial->port[i] = port;
948 port->dev.parent = &interface->dev;
949 port->dev.driver = NULL;
950 port->dev.bus = &usb_serial_bus_type;
951 port->dev.release = &port_release;
952 device_initialize(&port->dev);
953 }
954
955 /* set up the endpoint information */
956 for (i = 0; i < num_bulk_in; ++i) {
957 endpoint = bulk_in_endpoint[i];
958 port = serial->port[i];
959 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
960 if (!port->read_urb) {
961 dev_err(&interface->dev, "No free urbs available\n");
962 goto probe_error;
963 }
964 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
965 port->bulk_in_size = buffer_size;
966 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
967 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
968 if (!port->bulk_in_buffer) {
969 dev_err(&interface->dev,
970 "Couldn't allocate bulk_in_buffer\n");
971 goto probe_error;
972 }
973 usb_fill_bulk_urb(port->read_urb, dev,
974 usb_rcvbulkpipe(dev,
975 endpoint->bEndpointAddress),
976 port->bulk_in_buffer, buffer_size,
977 serial->type->read_bulk_callback, port);
978 }
979
980 for (i = 0; i < num_bulk_out; ++i) {
981 endpoint = bulk_out_endpoint[i];
982 port = serial->port[i];
983 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
984 if (!port->write_urb) {
985 dev_err(&interface->dev, "No free urbs available\n");
986 goto probe_error;
987 }
988 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
989 port->bulk_out_size = buffer_size;
990 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
991 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
992 if (!port->bulk_out_buffer) {
993 dev_err(&interface->dev,
994 "Couldn't allocate bulk_out_buffer\n");
995 goto probe_error;
996 }
997 usb_fill_bulk_urb(port->write_urb, dev,
998 usb_sndbulkpipe(dev,
999 endpoint->bEndpointAddress),
1000 port->bulk_out_buffer, buffer_size,
1001 serial->type->write_bulk_callback, port);
1002 }
1003
1004 if (serial->type->read_int_callback) {
1005 for (i = 0; i < num_interrupt_in; ++i) {
1006 endpoint = interrupt_in_endpoint[i];
1007 port = serial->port[i];
1008 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
1009 if (!port->interrupt_in_urb) {
1010 dev_err(&interface->dev,
1011 "No free urbs available\n");
1012 goto probe_error;
1013 }
1014 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1015 port->interrupt_in_endpointAddress =
1016 endpoint->bEndpointAddress;
1017 port->interrupt_in_buffer = kmalloc(buffer_size,
1018 GFP_KERNEL);
1019 if (!port->interrupt_in_buffer) {
1020 dev_err(&interface->dev,
1021 "Couldn't allocate interrupt_in_buffer\n");
1022 goto probe_error;
1023 }
1024 usb_fill_int_urb(port->interrupt_in_urb, dev,
1025 usb_rcvintpipe(dev,
1026 endpoint->bEndpointAddress),
1027 port->interrupt_in_buffer, buffer_size,
1028 serial->type->read_int_callback, port,
1029 endpoint->bInterval);
1030 }
1031 } else if (num_interrupt_in) {
1032 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1033 }
1034
1035 if (serial->type->write_int_callback) {
1036 for (i = 0; i < num_interrupt_out; ++i) {
1037 endpoint = interrupt_out_endpoint[i];
1038 port = serial->port[i];
1039 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1040 if (!port->interrupt_out_urb) {
1041 dev_err(&interface->dev,
1042 "No free urbs available\n");
1043 goto probe_error;
1044 }
1045 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1046 port->interrupt_out_size = buffer_size;
1047 port->interrupt_out_endpointAddress =
1048 endpoint->bEndpointAddress;
1049 port->interrupt_out_buffer = kmalloc(buffer_size,
1050 GFP_KERNEL);
1051 if (!port->interrupt_out_buffer) {
1052 dev_err(&interface->dev,
1053 "Couldn't allocate interrupt_out_buffer\n");
1054 goto probe_error;
1055 }
1056 usb_fill_int_urb(port->interrupt_out_urb, dev,
1057 usb_sndintpipe(dev,
1058 endpoint->bEndpointAddress),
1059 port->interrupt_out_buffer, buffer_size,
1060 serial->type->write_int_callback, port,
1061 endpoint->bInterval);
1062 }
1063 } else if (num_interrupt_out) {
1064 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1065 }
1066
1067 /* if this device type has an attach function, call it */
1068 if (type->attach) {
1069 if (!try_module_get(type->driver.owner)) {
1070 dev_err(&interface->dev,
1071 "module get failed, exiting\n");
1072 goto probe_error;
1073 }
1074 retval = type->attach(serial);
1075 module_put(type->driver.owner);
1076 if (retval < 0)
1077 goto probe_error;
1078 if (retval > 0) {
1079 /* quietly accept this device, but don't bind to a
1080 serial port as it's about to disappear */
1081 serial->num_ports = 0;
1082 goto exit;
1083 }
1084 }
1085
1086 if (get_free_serial(serial, num_ports, &minor) == NULL) {
1087 dev_err(&interface->dev, "No more free serial devices\n");
1088 goto probe_error;
1089 }
1090 serial->minor = minor;
1091
1092 /* register all of the individual ports with the driver core */
1093 for (i = 0; i < num_ports; ++i) {
1094 port = serial->port[i];
1095 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1096 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1097 port->dev_state = PORT_REGISTERING;
1098 retval = device_add(&port->dev);
1099 if (retval) {
1100 dev_err(&port->dev, "Error registering port device, "
1101 "continuing\n");
1102 port->dev_state = PORT_UNREGISTERED;
1103 } else {
1104 port->dev_state = PORT_REGISTERED;
1105 }
1106 }
1107
1108 usb_serial_console_init(debug, minor);
1109
1110 exit:
1111 /* success */
1112 usb_set_intfdata(interface, serial);
1113 return 0;
1114
1115 probe_error:
1116 usb_serial_put(serial);
1117 return -EIO;
1118 }
1119 EXPORT_SYMBOL_GPL(usb_serial_probe);
1120
1121 void usb_serial_disconnect(struct usb_interface *interface)
1122 {
1123 int i;
1124 struct usb_serial *serial = usb_get_intfdata(interface);
1125 struct device *dev = &interface->dev;
1126 struct usb_serial_port *port;
1127
1128 usb_serial_console_disconnect(serial);
1129 dbg("%s", __func__);
1130
1131 mutex_lock(&serial->disc_mutex);
1132 usb_set_intfdata(interface, NULL);
1133 /* must set a flag, to signal subdrivers */
1134 serial->disconnected = 1;
1135 mutex_unlock(&serial->disc_mutex);
1136
1137 for (i = 0; i < serial->num_ports; ++i) {
1138 port = serial->port[i];
1139 if (port) {
1140 struct tty_struct *tty = tty_port_tty_get(&port->port);
1141 if (tty) {
1142 tty_vhangup(tty);
1143 tty_kref_put(tty);
1144 }
1145 kill_traffic(port);
1146 cancel_work_sync(&port->work);
1147 if (port->dev_state == PORT_REGISTERED) {
1148
1149 /* Make sure the port is bound so that the
1150 * driver's port_remove method is called.
1151 */
1152 if (!port->dev.driver) {
1153 int rc;
1154
1155 port->dev.driver =
1156 &serial->type->driver;
1157 rc = device_bind_driver(&port->dev);
1158 }
1159 port->dev_state = PORT_UNREGISTERING;
1160 device_del(&port->dev);
1161 port->dev_state = PORT_UNREGISTERED;
1162 }
1163 }
1164 }
1165 serial->type->disconnect(serial);
1166
1167 /* let the last holder of this object cause it to be cleaned up */
1168 usb_serial_put(serial);
1169 dev_info(dev, "device disconnected\n");
1170 }
1171 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1172
1173 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1174 {
1175 struct usb_serial *serial = usb_get_intfdata(intf);
1176 struct usb_serial_port *port;
1177 int i, r = 0;
1178
1179 serial->suspending = 1;
1180
1181 for (i = 0; i < serial->num_ports; ++i) {
1182 port = serial->port[i];
1183 if (port)
1184 kill_traffic(port);
1185 }
1186
1187 if (serial->type->suspend)
1188 r = serial->type->suspend(serial, message);
1189
1190 return r;
1191 }
1192 EXPORT_SYMBOL(usb_serial_suspend);
1193
1194 int usb_serial_resume(struct usb_interface *intf)
1195 {
1196 struct usb_serial *serial = usb_get_intfdata(intf);
1197 int rv;
1198
1199 serial->suspending = 0;
1200 if (serial->type->resume)
1201 rv = serial->type->resume(serial);
1202 else
1203 rv = usb_serial_generic_resume(serial);
1204
1205 return rv;
1206 }
1207 EXPORT_SYMBOL(usb_serial_resume);
1208
1209 static const struct tty_operations serial_ops = {
1210 .open = serial_open,
1211 .close = serial_close,
1212 .write = serial_write,
1213 .hangup = serial_hangup,
1214 .write_room = serial_write_room,
1215 .ioctl = serial_ioctl,
1216 .set_termios = serial_set_termios,
1217 .throttle = serial_throttle,
1218 .unthrottle = serial_unthrottle,
1219 .break_ctl = serial_break,
1220 .chars_in_buffer = serial_chars_in_buffer,
1221 .tiocmget = serial_tiocmget,
1222 .tiocmset = serial_tiocmset,
1223 .shutdown = serial_release,
1224 .install = serial_install,
1225 .proc_fops = &serial_proc_fops,
1226 };
1227
1228
1229 struct tty_driver *usb_serial_tty_driver;
1230
1231 static int __init usb_serial_init(void)
1232 {
1233 int i;
1234 int result;
1235
1236 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1237 if (!usb_serial_tty_driver)
1238 return -ENOMEM;
1239
1240 /* Initialize our global data */
1241 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1242 serial_table[i] = NULL;
1243
1244 result = bus_register(&usb_serial_bus_type);
1245 if (result) {
1246 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1247 "failed\n", __func__);
1248 goto exit_bus;
1249 }
1250
1251 usb_serial_tty_driver->owner = THIS_MODULE;
1252 usb_serial_tty_driver->driver_name = "usbserial";
1253 usb_serial_tty_driver->name = "ttyUSB";
1254 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1255 usb_serial_tty_driver->minor_start = 0;
1256 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1257 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1258 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1259 TTY_DRIVER_DYNAMIC_DEV;
1260 usb_serial_tty_driver->init_termios = tty_std_termios;
1261 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1262 | HUPCL | CLOCAL;
1263 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1264 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1265 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1266 result = tty_register_driver(usb_serial_tty_driver);
1267 if (result) {
1268 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1269 __func__);
1270 goto exit_reg_driver;
1271 }
1272
1273 /* register the USB driver */
1274 result = usb_register(&usb_serial_driver);
1275 if (result < 0) {
1276 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1277 __func__);
1278 goto exit_tty;
1279 }
1280
1281 /* register the generic driver, if we should */
1282 result = usb_serial_generic_register(debug);
1283 if (result < 0) {
1284 printk(KERN_ERR "usb-serial: %s - registering generic "
1285 "driver failed\n", __func__);
1286 goto exit_generic;
1287 }
1288
1289 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1290
1291 return result;
1292
1293 exit_generic:
1294 usb_deregister(&usb_serial_driver);
1295
1296 exit_tty:
1297 tty_unregister_driver(usb_serial_tty_driver);
1298
1299 exit_reg_driver:
1300 bus_unregister(&usb_serial_bus_type);
1301
1302 exit_bus:
1303 printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1304 __func__, result);
1305 put_tty_driver(usb_serial_tty_driver);
1306 return result;
1307 }
1308
1309
1310 static void __exit usb_serial_exit(void)
1311 {
1312 usb_serial_console_exit();
1313
1314 usb_serial_generic_deregister();
1315
1316 usb_deregister(&usb_serial_driver);
1317 tty_unregister_driver(usb_serial_tty_driver);
1318 put_tty_driver(usb_serial_tty_driver);
1319 bus_unregister(&usb_serial_bus_type);
1320 }
1321
1322
1323 module_init(usb_serial_init);
1324 module_exit(usb_serial_exit);
1325
1326 #define set_to_generic_if_null(type, function) \
1327 do { \
1328 if (!type->function) { \
1329 type->function = usb_serial_generic_##function; \
1330 dbg("Had to override the " #function \
1331 " usb serial operation with the generic one.");\
1332 } \
1333 } while (0)
1334
1335 static void fixup_generic(struct usb_serial_driver *device)
1336 {
1337 set_to_generic_if_null(device, open);
1338 set_to_generic_if_null(device, write);
1339 set_to_generic_if_null(device, close);
1340 set_to_generic_if_null(device, write_room);
1341 set_to_generic_if_null(device, chars_in_buffer);
1342 set_to_generic_if_null(device, read_bulk_callback);
1343 set_to_generic_if_null(device, write_bulk_callback);
1344 set_to_generic_if_null(device, disconnect);
1345 set_to_generic_if_null(device, release);
1346 }
1347
1348 int usb_serial_register(struct usb_serial_driver *driver)
1349 {
1350 /* must be called with BKL held */
1351 int retval;
1352
1353 if (usb_disabled())
1354 return -ENODEV;
1355
1356 fixup_generic(driver);
1357
1358 if (!driver->description)
1359 driver->description = driver->driver.name;
1360
1361 /* Add this device to our list of devices */
1362 list_add(&driver->driver_list, &usb_serial_driver_list);
1363
1364 retval = usb_serial_bus_register(driver);
1365 if (retval) {
1366 printk(KERN_ERR "usb-serial: problem %d when registering "
1367 "driver %s\n", retval, driver->description);
1368 list_del(&driver->driver_list);
1369 } else
1370 printk(KERN_INFO "USB Serial support registered for %s\n",
1371 driver->description);
1372
1373 return retval;
1374 }
1375 EXPORT_SYMBOL_GPL(usb_serial_register);
1376
1377
1378 void usb_serial_deregister(struct usb_serial_driver *device)
1379 {
1380 /* must be called with BKL held */
1381 printk(KERN_INFO "USB Serial deregistering driver %s\n",
1382 device->description);
1383 list_del(&device->driver_list);
1384 usb_serial_bus_deregister(device);
1385 }
1386 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1387
1388 /* Module information */
1389 MODULE_AUTHOR(DRIVER_AUTHOR);
1390 MODULE_DESCRIPTION(DRIVER_DESC);
1391 MODULE_LICENSE("GPL");
1392
1393 module_param(debug, bool, S_IRUGO | S_IWUSR);
1394 MODULE_PARM_DESC(debug, "Debug enabled or not");
Support for the Chinese Samsung S3C2440 based development boards