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