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