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