?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: serial: don't call release without attach
[linux-2.6/verdex.git] / drivers / usb / serial / usb-serial.c
blob3292e0391e28b9696f3f9177b395f97bb8b2e9be
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 if (serial->attached)
159 serial->type->release(serial);
160
161 /* Now that nothing is using the ports, they can be freed */
162 for (i = 0; i < serial->num_port_pointers; ++i) {
163 port = serial->port[i];
164 if (port) {
165 port->serial = NULL;
166 put_device(&port->dev);
167 }
168 }
169
170 usb_put_dev(serial->dev);
171 kfree(serial);
172 }
173
174 void usb_serial_put(struct usb_serial *serial)
175 {
176 kref_put(&serial->kref, destroy_serial);
177 }
178
179 /*****************************************************************************
180 * Driver tty interface functions
181 *****************************************************************************/
182
183 /**
184 * serial_install - install tty
185 * @driver: the driver (USB in our case)
186 * @tty: the tty being created
187 *
188 * Create the termios objects for this tty. We use the default
189 * USB serial settings but permit them to be overridden by
190 * serial->type->init_termios.
191 *
192 * This is the first place a new tty gets used. Hence this is where we
193 * acquire references to the usb_serial structure and the driver module,
194 * where we store a pointer to the port, and where we do an autoresume.
195 * All these actions are reversed in serial_release().
196 */
197 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
198 {
199 int idx = tty->index;
200 struct usb_serial *serial;
201 struct usb_serial_port *port;
202 int retval = -ENODEV;
203
204 dbg("%s", __func__);
205
206 serial = usb_serial_get_by_index(idx);
207 if (!serial)
208 return retval;
209
210 port = serial->port[idx - serial->minor];
211 if (!port)
212 goto error_no_port;
213 if (!try_module_get(serial->type->driver.owner))
214 goto error_module_get;
215
216 /* perform the standard setup */
217 retval = tty_init_termios(tty);
218 if (retval)
219 goto error_init_termios;
220
221 retval = usb_autopm_get_interface(serial->interface);
222 if (retval)
223 goto error_get_interface;
224
225 mutex_unlock(&serial->disc_mutex);
226
227 /* allow the driver to update the settings */
228 if (serial->type->init_termios)
229 serial->type->init_termios(tty);
230
231 tty->driver_data = port;
232
233 /* Final install (we use the default method) */
234 tty_driver_kref_get(driver);
235 tty->count++;
236 driver->ttys[idx] = tty;
237 return retval;
238
239 error_get_interface:
240 error_init_termios:
241 module_put(serial->type->driver.owner);
242 error_module_get:
243 error_no_port:
244 usb_serial_put(serial);
245 mutex_unlock(&serial->disc_mutex);
246 return retval;
247 }
248
249 static int serial_open(struct tty_struct *tty, struct file *filp)
250 {
251 struct usb_serial_port *port = tty->driver_data;
252 struct usb_serial *serial = port->serial;
253 int retval;
254
255 dbg("%s - port %d", __func__, port->number);
256
257 spin_lock_irq(&port->port.lock);
258 if (!tty_hung_up_p(filp))
259 ++port->port.count;
260 spin_unlock_irq(&port->port.lock);
261 tty_port_tty_set(&port->port, tty);
262
263 /* Do the device-specific open only if the hardware isn't
264 * already initialized.
265 */
266 if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) {
267 if (mutex_lock_interruptible(&port->mutex))
268 return -ERESTARTSYS;
269 mutex_lock(&serial->disc_mutex);
270 if (serial->disconnected)
271 retval = -ENODEV;
272 else
273 retval = port->serial->type->open(tty, port, filp);
274 mutex_unlock(&serial->disc_mutex);
275 mutex_unlock(&port->mutex);
276 if (retval)
277 return retval;
278 set_bit(ASYNCB_INITIALIZED, &port->port.flags);
279 }
280
281 /* Now do the correct tty layer semantics */
282 retval = tty_port_block_til_ready(&port->port, tty, filp);
283 return retval;
284 }
285
286 /**
287 * serial_down - shut down hardware
288 * @port: port to shut down
289 *
290 * Shut down a USB serial port unless it is the console. We never
291 * shut down the console hardware as it will always be in use.
292 */
293 static void serial_down(struct usb_serial_port *port)
294 {
295 struct usb_serial_driver *drv = port->serial->type;
296 struct usb_serial *serial;
297 struct module *owner;
298
299 /*
300 * The console is magical. Do not hang up the console hardware
301 * or there will be tears.
302 */
303 if (port->console)
304 return;
305
306 /* Don't call the close method if the hardware hasn't been
307 * initialized.
308 */
309 if (!test_and_clear_bit(ASYNCB_INITIALIZED, &port->port.flags))
310 return;
311
312 mutex_lock(&port->mutex);
313 serial = port->serial;
314 owner = serial->type->driver.owner;
315
316 if (drv->close)
317 drv->close(port);
318
319 mutex_unlock(&port->mutex);
320 }
321
322 static void serial_hangup(struct tty_struct *tty)
323 {
324 struct usb_serial_port *port = tty->driver_data;
325
326 dbg("%s - port %d", __func__, port->number);
327
328 serial_down(port);
329 tty_port_hangup(&port->port);
330 }
331
332 static void serial_close(struct tty_struct *tty, struct file *filp)
333 {
334 struct usb_serial_port *port = tty->driver_data;
335
336 dbg("%s - port %d", __func__, port->number);
337
338 if (tty_hung_up_p(filp))
339 return;
340 if (tty_port_close_start(&port->port, tty, filp) == 0)
341 return;
342 serial_down(port);
343 tty_port_close_end(&port->port, tty);
344 tty_port_tty_set(&port->port, NULL);
345 }
346
347 /**
348 * serial_release - free resources post close/hangup
349 * @port: port to free up
350 *
351 * Do the resource freeing and refcount dropping for the port.
352 * Avoid freeing the console.
353 *
354 * Called when the last tty kref is dropped.
355 */
356 static void serial_release(struct tty_struct *tty)
357 {
358 struct usb_serial_port *port = tty->driver_data;
359 struct usb_serial *serial;
360 struct module *owner;
361
362 /* The console is magical. Do not hang up the console hardware
363 * or there will be tears.
364 */
365 if (port->console)
366 return;
367
368 dbg("%s - port %d", __func__, port->number);
369
370 /* Standard shutdown processing */
371 tty_shutdown(tty);
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 serial->attached = 1;
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 } else {
1072 serial->attached = 1;
1073 }
1074
1075 if (get_free_serial(serial, num_ports, &minor) == NULL) {
1076 dev_err(&interface->dev, "No more free serial devices\n");
1077 goto probe_error;
1078 }
1079 serial->minor = minor;
1080
1081 /* register all of the individual ports with the driver core */
1082 for (i = 0; i < num_ports; ++i) {
1083 port = serial->port[i];
1084 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1085 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1086 port->dev_state = PORT_REGISTERING;
1087 retval = device_add(&port->dev);
1088 if (retval) {
1089 dev_err(&port->dev, "Error registering port device, "
1090 "continuing\n");
1091 port->dev_state = PORT_UNREGISTERED;
1092 } else {
1093 port->dev_state = PORT_REGISTERED;
1094 }
1095 }
1096
1097 usb_serial_console_init(debug, minor);
1098
1099 exit:
1100 /* success */
1101 usb_set_intfdata(interface, serial);
1102 return 0;
1103
1104 probe_error:
1105 usb_serial_put(serial);
1106 return -EIO;
1107 }
1108 EXPORT_SYMBOL_GPL(usb_serial_probe);
1109
1110 void usb_serial_disconnect(struct usb_interface *interface)
1111 {
1112 int i;
1113 struct usb_serial *serial = usb_get_intfdata(interface);
1114 struct device *dev = &interface->dev;
1115 struct usb_serial_port *port;
1116
1117 usb_serial_console_disconnect(serial);
1118 dbg("%s", __func__);
1119
1120 mutex_lock(&serial->disc_mutex);
1121 usb_set_intfdata(interface, NULL);
1122 /* must set a flag, to signal subdrivers */
1123 serial->disconnected = 1;
1124 mutex_unlock(&serial->disc_mutex);
1125
1126 for (i = 0; i < serial->num_ports; ++i) {
1127 port = serial->port[i];
1128 if (port) {
1129 struct tty_struct *tty = tty_port_tty_get(&port->port);
1130 if (tty) {
1131 tty_vhangup(tty);
1132 tty_kref_put(tty);
1133 }
1134 kill_traffic(port);
1135 cancel_work_sync(&port->work);
1136 if (port->dev_state == PORT_REGISTERED) {
1137
1138 /* Make sure the port is bound so that the
1139 * driver's port_remove method is called.
1140 */
1141 if (!port->dev.driver) {
1142 int rc;
1143
1144 port->dev.driver =
1145 &serial->type->driver;
1146 rc = device_bind_driver(&port->dev);
1147 }
1148 port->dev_state = PORT_UNREGISTERING;
1149 device_del(&port->dev);
1150 port->dev_state = PORT_UNREGISTERED;
1151 }
1152 }
1153 }
1154 serial->type->disconnect(serial);
1155
1156 /* let the last holder of this object cause it to be cleaned up */
1157 usb_serial_put(serial);
1158 dev_info(dev, "device disconnected\n");
1159 }
1160 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1161
1162 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1163 {
1164 struct usb_serial *serial = usb_get_intfdata(intf);
1165 struct usb_serial_port *port;
1166 int i, r = 0;
1167
1168 serial->suspending = 1;
1169
1170 for (i = 0; i < serial->num_ports; ++i) {
1171 port = serial->port[i];
1172 if (port)
1173 kill_traffic(port);
1174 }
1175
1176 if (serial->type->suspend)
1177 r = serial->type->suspend(serial, message);
1178
1179 return r;
1180 }
1181 EXPORT_SYMBOL(usb_serial_suspend);
1182
1183 int usb_serial_resume(struct usb_interface *intf)
1184 {
1185 struct usb_serial *serial = usb_get_intfdata(intf);
1186 int rv;
1187
1188 serial->suspending = 0;
1189 if (serial->type->resume)
1190 rv = serial->type->resume(serial);
1191 else
1192 rv = usb_serial_generic_resume(serial);
1193
1194 return rv;
1195 }
1196 EXPORT_SYMBOL(usb_serial_resume);
1197
1198 static const struct tty_operations serial_ops = {
1199 .open = serial_open,
1200 .close = serial_close,
1201 .write = serial_write,
1202 .hangup = serial_hangup,
1203 .write_room = serial_write_room,
1204 .ioctl = serial_ioctl,
1205 .set_termios = serial_set_termios,
1206 .throttle = serial_throttle,
1207 .unthrottle = serial_unthrottle,
1208 .break_ctl = serial_break,
1209 .chars_in_buffer = serial_chars_in_buffer,
1210 .tiocmget = serial_tiocmget,
1211 .tiocmset = serial_tiocmset,
1212 .shutdown = serial_release,
1213 .install = serial_install,
1214 .proc_fops = &serial_proc_fops,
1215 };
1216
1217
1218 struct tty_driver *usb_serial_tty_driver;
1219
1220 static int __init usb_serial_init(void)
1221 {
1222 int i;
1223 int result;
1224
1225 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1226 if (!usb_serial_tty_driver)
1227 return -ENOMEM;
1228
1229 /* Initialize our global data */
1230 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1231 serial_table[i] = NULL;
1232
1233 result = bus_register(&usb_serial_bus_type);
1234 if (result) {
1235 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1236 "failed\n", __func__);
1237 goto exit_bus;
1238 }
1239
1240 usb_serial_tty_driver->owner = THIS_MODULE;
1241 usb_serial_tty_driver->driver_name = "usbserial";
1242 usb_serial_tty_driver->name = "ttyUSB";
1243 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1244 usb_serial_tty_driver->minor_start = 0;
1245 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1246 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1247 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1248 TTY_DRIVER_DYNAMIC_DEV;
1249 usb_serial_tty_driver->init_termios = tty_std_termios;
1250 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1251 | HUPCL | CLOCAL;
1252 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1253 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1254 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1255 result = tty_register_driver(usb_serial_tty_driver);
1256 if (result) {
1257 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1258 __func__);
1259 goto exit_reg_driver;
1260 }
1261
1262 /* register the USB driver */
1263 result = usb_register(&usb_serial_driver);
1264 if (result < 0) {
1265 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1266 __func__);
1267 goto exit_tty;
1268 }
1269
1270 /* register the generic driver, if we should */
1271 result = usb_serial_generic_register(debug);
1272 if (result < 0) {
1273 printk(KERN_ERR "usb-serial: %s - registering generic "
1274 "driver failed\n", __func__);
1275 goto exit_generic;
1276 }
1277
1278 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1279
1280 return result;
1281
1282 exit_generic:
1283 usb_deregister(&usb_serial_driver);
1284
1285 exit_tty:
1286 tty_unregister_driver(usb_serial_tty_driver);
1287
1288 exit_reg_driver:
1289 bus_unregister(&usb_serial_bus_type);
1290
1291 exit_bus:
1292 printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1293 __func__, result);
1294 put_tty_driver(usb_serial_tty_driver);
1295 return result;
1296 }
1297
1298
1299 static void __exit usb_serial_exit(void)
1300 {
1301 usb_serial_console_exit();
1302
1303 usb_serial_generic_deregister();
1304
1305 usb_deregister(&usb_serial_driver);
1306 tty_unregister_driver(usb_serial_tty_driver);
1307 put_tty_driver(usb_serial_tty_driver);
1308 bus_unregister(&usb_serial_bus_type);
1309 }
1310
1311
1312 module_init(usb_serial_init);
1313 module_exit(usb_serial_exit);
1314
1315 #define set_to_generic_if_null(type, function) \
1316 do { \
1317 if (!type->function) { \
1318 type->function = usb_serial_generic_##function; \
1319 dbg("Had to override the " #function \
1320 " usb serial operation with the generic one.");\
1321 } \
1322 } while (0)
1323
1324 static void fixup_generic(struct usb_serial_driver *device)
1325 {
1326 set_to_generic_if_null(device, open);
1327 set_to_generic_if_null(device, write);
1328 set_to_generic_if_null(device, close);
1329 set_to_generic_if_null(device, write_room);
1330 set_to_generic_if_null(device, chars_in_buffer);
1331 set_to_generic_if_null(device, read_bulk_callback);
1332 set_to_generic_if_null(device, write_bulk_callback);
1333 set_to_generic_if_null(device, disconnect);
1334 set_to_generic_if_null(device, release);
1335 }
1336
1337 int usb_serial_register(struct usb_serial_driver *driver)
1338 {
1339 /* must be called with BKL held */
1340 int retval;
1341
1342 if (usb_disabled())
1343 return -ENODEV;
1344
1345 fixup_generic(driver);
1346
1347 if (!driver->description)
1348 driver->description = driver->driver.name;
1349
1350 /* Add this device to our list of devices */
1351 list_add(&driver->driver_list, &usb_serial_driver_list);
1352
1353 retval = usb_serial_bus_register(driver);
1354 if (retval) {
1355 printk(KERN_ERR "usb-serial: problem %d when registering "
1356 "driver %s\n", retval, driver->description);
1357 list_del(&driver->driver_list);
1358 } else
1359 printk(KERN_INFO "USB Serial support registered for %s\n",
1360 driver->description);
1361
1362 return retval;
1363 }
1364 EXPORT_SYMBOL_GPL(usb_serial_register);
1365
1366
1367 void usb_serial_deregister(struct usb_serial_driver *device)
1368 {
1369 /* must be called with BKL held */
1370 printk(KERN_INFO "USB Serial deregistering driver %s\n",
1371 device->description);
1372 list_del(&device->driver_list);
1373 usb_serial_bus_deregister(device);
1374 }
1375 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1376
1377 /* Module information */
1378 MODULE_AUTHOR(DRIVER_AUTHOR);
1379 MODULE_DESCRIPTION(DRIVER_DESC);
1380 MODULE_LICENSE("GPL");
1381
1382 module_param(debug, bool, S_IRUGO | S_IWUSR);
1383 MODULE_PARM_DESC(debug, "Debug enabled or not");
Verdex Pro support