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