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