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