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