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