?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
m68knommu: Add Coldfire DMA Timer support
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / serial / usb-serial.c
blob8c2d531eedea1f3bf2759ec9796dcf96cb8dcfff
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 if (serial == NULL)
126 return;
127
128 for (i = 0; i < serial->num_ports; ++i)
129 serial_table[serial->minor + i] = NULL;
130 }
131
132 static void destroy_serial(struct kref *kref)
133 {
134 struct usb_serial *serial;
135 struct usb_serial_port *port;
136 int i;
137
138 serial = to_usb_serial(kref);
139
140 dbg("%s - %s", __func__, serial->type->description);
141
142 serial->type->shutdown(serial);
143
144 /* return the minor range that this device had */
145 return_serial(serial);
146
147 for (i = 0; i < serial->num_ports; ++i)
148 serial->port[i]->port.count = 0;
149
150 /* the ports are cleaned up and released in port_release() */
151 for (i = 0; i < serial->num_ports; ++i)
152 if (serial->port[i]->dev.parent != NULL) {
153 device_unregister(&serial->port[i]->dev);
154 serial->port[i] = NULL;
155 }
156
157 /* If this is a "fake" port, we have to clean it up here, as it will
158 * not get cleaned up in port_release() as it was never registered with
159 * the driver core */
160 if (serial->num_ports < serial->num_port_pointers) {
161 for (i = serial->num_ports;
162 i < serial->num_port_pointers; ++i) {
163 port = serial->port[i];
164 if (!port)
165 continue;
166 port_free(port);
167 }
168 }
169
170 usb_put_dev(serial->dev);
171
172 /* free up any memory that we allocated */
173 kfree(serial);
174 }
175
176 void usb_serial_put(struct usb_serial *serial)
177 {
178 mutex_lock(&table_lock);
179 kref_put(&serial->kref, destroy_serial);
180 mutex_unlock(&table_lock);
181 }
182
183 /*****************************************************************************
184 * Driver tty interface functions
185 *****************************************************************************/
186 static int serial_open (struct tty_struct *tty, struct file *filp)
187 {
188 struct usb_serial *serial;
189 struct usb_serial_port *port;
190 unsigned int portNumber;
191 int retval;
192
193 dbg("%s", __func__);
194
195 /* get the serial object associated with this tty pointer */
196 serial = usb_serial_get_by_index(tty->index);
197 if (!serial) {
198 tty->driver_data = NULL;
199 return -ENODEV;
200 }
201
202 portNumber = tty->index - serial->minor;
203 port = serial->port[portNumber];
204 if (!port) {
205 retval = -ENODEV;
206 goto bailout_kref_put;
207 }
208
209 if (mutex_lock_interruptible(&port->mutex)) {
210 retval = -ERESTARTSYS;
211 goto bailout_kref_put;
212 }
213
214 ++port->port.count;
215
216 /* set up our port structure making the tty driver
217 * remember our port object, and us it */
218 tty->driver_data = port;
219 port->port.tty = tty;
220
221 if (port->port.count == 1) {
222
223 /* lock this module before we call it
224 * this may fail, which means we must bail out,
225 * safe because we are called with BKL held */
226 if (!try_module_get(serial->type->driver.owner)) {
227 retval = -ENODEV;
228 goto bailout_mutex_unlock;
229 }
230
231 retval = usb_autopm_get_interface(serial->interface);
232 if (retval)
233 goto bailout_module_put;
234 /* only call the device specific open if this
235 * is the first time the port is opened */
236 retval = serial->type->open(tty, port, filp);
237 if (retval)
238 goto bailout_interface_put;
239 }
240
241 mutex_unlock(&port->mutex);
242 return 0;
243
244 bailout_interface_put:
245 usb_autopm_put_interface(serial->interface);
246 bailout_module_put:
247 module_put(serial->type->driver.owner);
248 bailout_mutex_unlock:
249 port->port.count = 0;
250 tty->driver_data = NULL;
251 port->port.tty = NULL;
252 mutex_unlock(&port->mutex);
253 bailout_kref_put:
254 usb_serial_put(serial);
255 return retval;
256 }
257
258 static void serial_close(struct tty_struct *tty, struct file *filp)
259 {
260 struct usb_serial_port *port = tty->driver_data;
261
262 if (!port)
263 return;
264
265 dbg("%s - port %d", __func__, port->number);
266
267 mutex_lock(&port->mutex);
268
269 if (port->port.count == 0) {
270 mutex_unlock(&port->mutex);
271 return;
272 }
273
274 --port->port.count;
275 if (port->port.count == 0)
276 /* only call the device specific close if this
277 * port is being closed by the last owner */
278 port->serial->type->close(tty, port, filp);
279
280 if (port->port.count == (port->console? 1 : 0)) {
281 if (port->port.tty) {
282 if (port->port.tty->driver_data)
283 port->port.tty->driver_data = NULL;
284 port->port.tty = NULL;
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 = port->port.tty;
514 if (!tty)
515 return;
516
517 tty_wakeup(tty);
518 }
519
520 static void port_release(struct device *dev)
521 {
522 struct usb_serial_port *port = to_usb_serial_port(dev);
523
524 dbg ("%s - %s", __func__, dev_name(dev));
525 port_free(port);
526 }
527
528 static void kill_traffic(struct usb_serial_port *port)
529 {
530 usb_kill_urb(port->read_urb);
531 usb_kill_urb(port->write_urb);
532 /*
533 * This is tricky.
534 * Some drivers submit the read_urb in the
535 * handler for the write_urb or vice versa
536 * this order determines the order in which
537 * usb_kill_urb() must be used to reliably
538 * kill the URBs. As it is unknown here,
539 * both orders must be used in turn.
540 * The call below is not redundant.
541 */
542 usb_kill_urb(port->read_urb);
543 usb_kill_urb(port->interrupt_in_urb);
544 usb_kill_urb(port->interrupt_out_urb);
545 }
546
547 static void port_free(struct usb_serial_port *port)
548 {
549 kill_traffic(port);
550 usb_free_urb(port->read_urb);
551 usb_free_urb(port->write_urb);
552 usb_free_urb(port->interrupt_in_urb);
553 usb_free_urb(port->interrupt_out_urb);
554 kfree(port->bulk_in_buffer);
555 kfree(port->bulk_out_buffer);
556 kfree(port->interrupt_in_buffer);
557 kfree(port->interrupt_out_buffer);
558 flush_scheduled_work(); /* port->work */
559 kfree(port);
560 }
561
562 static struct usb_serial *create_serial(struct usb_device *dev,
563 struct usb_interface *interface,
564 struct usb_serial_driver *driver)
565 {
566 struct usb_serial *serial;
567
568 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
569 if (!serial) {
570 dev_err(&dev->dev, "%s - out of memory\n", __func__);
571 return NULL;
572 }
573 serial->dev = usb_get_dev(dev);
574 serial->type = driver;
575 serial->interface = interface;
576 kref_init(&serial->kref);
577 mutex_init(&serial->disc_mutex);
578
579 return serial;
580 }
581
582 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
583 struct usb_serial_driver *drv)
584 {
585 struct usb_dynid *dynid;
586
587 spin_lock(&drv->dynids.lock);
588 list_for_each_entry(dynid, &drv->dynids.list, node) {
589 if (usb_match_one_id(intf, &dynid->id)) {
590 spin_unlock(&drv->dynids.lock);
591 return &dynid->id;
592 }
593 }
594 spin_unlock(&drv->dynids.lock);
595 return NULL;
596 }
597
598 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
599 struct usb_interface *intf)
600 {
601 const struct usb_device_id *id;
602
603 id = usb_match_id(intf, drv->id_table);
604 if (id) {
605 dbg("static descriptor matches");
606 goto exit;
607 }
608 id = match_dynamic_id(intf, drv);
609 if (id)
610 dbg("dynamic descriptor matches");
611 exit:
612 return id;
613 }
614
615 static struct usb_serial_driver *search_serial_device(
616 struct usb_interface *iface)
617 {
618 const struct usb_device_id *id;
619 struct usb_serial_driver *drv;
620
621 /* Check if the usb id matches a known device */
622 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
623 id = get_iface_id(drv, iface);
624 if (id)
625 return drv;
626 }
627
628 return NULL;
629 }
630
631 int usb_serial_probe(struct usb_interface *interface,
632 const struct usb_device_id *id)
633 {
634 struct usb_device *dev = interface_to_usbdev(interface);
635 struct usb_serial *serial = NULL;
636 struct usb_serial_port *port;
637 struct usb_host_interface *iface_desc;
638 struct usb_endpoint_descriptor *endpoint;
639 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
640 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
641 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
642 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
643 struct usb_serial_driver *type = NULL;
644 int retval;
645 unsigned int minor;
646 int buffer_size;
647 int i;
648 int num_interrupt_in = 0;
649 int num_interrupt_out = 0;
650 int num_bulk_in = 0;
651 int num_bulk_out = 0;
652 int num_ports = 0;
653 int max_endpoints;
654
655 lock_kernel(); /* guard against unloading a serial driver module */
656 type = search_serial_device(interface);
657 if (!type) {
658 unlock_kernel();
659 dbg("none matched");
660 return -ENODEV;
661 }
662
663 serial = create_serial(dev, interface, type);
664 if (!serial) {
665 unlock_kernel();
666 dev_err(&interface->dev, "%s - out of memory\n", __func__);
667 return -ENOMEM;
668 }
669
670 /* if this device type has a probe function, call it */
671 if (type->probe) {
672 const struct usb_device_id *id;
673
674 if (!try_module_get(type->driver.owner)) {
675 unlock_kernel();
676 dev_err(&interface->dev,
677 "module get failed, exiting\n");
678 kfree(serial);
679 return -EIO;
680 }
681
682 id = get_iface_id(type, interface);
683 retval = type->probe(serial, id);
684 module_put(type->driver.owner);
685
686 if (retval) {
687 unlock_kernel();
688 dbg("sub driver rejected device");
689 kfree(serial);
690 return retval;
691 }
692 }
693
694 /* descriptor matches, let's find the endpoints needed */
695 /* check out the endpoints */
696 iface_desc = interface->cur_altsetting;
697 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
698 endpoint = &iface_desc->endpoint[i].desc;
699
700 if (usb_endpoint_is_bulk_in(endpoint)) {
701 /* we found a bulk in endpoint */
702 dbg("found bulk in on endpoint %d", i);
703 bulk_in_endpoint[num_bulk_in] = endpoint;
704 ++num_bulk_in;
705 }
706
707 if (usb_endpoint_is_bulk_out(endpoint)) {
708 /* we found a bulk out endpoint */
709 dbg("found bulk out on endpoint %d", i);
710 bulk_out_endpoint[num_bulk_out] = endpoint;
711 ++num_bulk_out;
712 }
713
714 if (usb_endpoint_is_int_in(endpoint)) {
715 /* we found a interrupt in endpoint */
716 dbg("found interrupt in on endpoint %d", i);
717 interrupt_in_endpoint[num_interrupt_in] = endpoint;
718 ++num_interrupt_in;
719 }
720
721 if (usb_endpoint_is_int_out(endpoint)) {
722 /* we found an interrupt out endpoint */
723 dbg("found interrupt out on endpoint %d", i);
724 interrupt_out_endpoint[num_interrupt_out] = endpoint;
725 ++num_interrupt_out;
726 }
727 }
728
729 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
730 /* BEGIN HORRIBLE HACK FOR PL2303 */
731 /* this is needed due to the looney way its endpoints are set up */
732 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
733 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
734 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
735 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
736 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
737 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID))) {
738 if (interface != dev->actconfig->interface[0]) {
739 /* check out the endpoints of the other interface*/
740 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
741 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
742 endpoint = &iface_desc->endpoint[i].desc;
743 if (usb_endpoint_is_int_in(endpoint)) {
744 /* we found a interrupt in endpoint */
745 dbg("found interrupt in for Prolific device on separate interface");
746 interrupt_in_endpoint[num_interrupt_in] = endpoint;
747 ++num_interrupt_in;
748 }
749 }
750 }
751
752 /* Now make sure the PL-2303 is configured correctly.
753 * If not, give up now and hope this hack will work
754 * properly during a later invocation of usb_serial_probe
755 */
756 if (num_bulk_in == 0 || num_bulk_out == 0) {
757 unlock_kernel();
758 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
759 kfree(serial);
760 return -ENODEV;
761 }
762 }
763 /* END HORRIBLE HACK FOR PL2303 */
764 #endif
765
766 #ifdef CONFIG_USB_SERIAL_GENERIC
767 if (type == &usb_serial_generic_device) {
768 num_ports = num_bulk_out;
769 if (num_ports == 0) {
770 unlock_kernel();
771 dev_err(&interface->dev,
772 "Generic device with no bulk out, not allowed.\n");
773 kfree(serial);
774 return -EIO;
775 }
776 }
777 #endif
778 if (!num_ports) {
779 /* if this device type has a calc_num_ports function, call it */
780 if (type->calc_num_ports) {
781 if (!try_module_get(type->driver.owner)) {
782 unlock_kernel();
783 dev_err(&interface->dev,
784 "module get failed, exiting\n");
785 kfree(serial);
786 return -EIO;
787 }
788 num_ports = type->calc_num_ports(serial);
789 module_put(type->driver.owner);
790 }
791 if (!num_ports)
792 num_ports = type->num_ports;
793 }
794
795 serial->num_ports = num_ports;
796 serial->num_bulk_in = num_bulk_in;
797 serial->num_bulk_out = num_bulk_out;
798 serial->num_interrupt_in = num_interrupt_in;
799 serial->num_interrupt_out = num_interrupt_out;
800
801 /* found all that we need */
802 dev_info(&interface->dev, "%s converter detected\n",
803 type->description);
804
805 /* create our ports, we need as many as the max endpoints */
806 /* we don't use num_ports here because some devices have more
807 endpoint pairs than ports */
808 max_endpoints = max(num_bulk_in, num_bulk_out);
809 max_endpoints = max(max_endpoints, num_interrupt_in);
810 max_endpoints = max(max_endpoints, num_interrupt_out);
811 max_endpoints = max(max_endpoints, (int)serial->num_ports);
812 serial->num_port_pointers = max_endpoints;
813 unlock_kernel();
814
815 dbg("%s - setting up %d port structures for this device",
816 __func__, max_endpoints);
817 for (i = 0; i < max_endpoints; ++i) {
818 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
819 if (!port)
820 goto probe_error;
821 port->serial = serial;
822 spin_lock_init(&port->lock);
823 mutex_init(&port->mutex);
824 INIT_WORK(&port->work, usb_serial_port_work);
825 serial->port[i] = port;
826 }
827
828 /* set up the endpoint information */
829 for (i = 0; i < num_bulk_in; ++i) {
830 endpoint = bulk_in_endpoint[i];
831 port = serial->port[i];
832 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
833 if (!port->read_urb) {
834 dev_err(&interface->dev, "No free urbs available\n");
835 goto probe_error;
836 }
837 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
838 port->bulk_in_size = buffer_size;
839 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
840 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
841 if (!port->bulk_in_buffer) {
842 dev_err(&interface->dev,
843 "Couldn't allocate bulk_in_buffer\n");
844 goto probe_error;
845 }
846 usb_fill_bulk_urb(port->read_urb, dev,
847 usb_rcvbulkpipe(dev,
848 endpoint->bEndpointAddress),
849 port->bulk_in_buffer, buffer_size,
850 serial->type->read_bulk_callback, port);
851 }
852
853 for (i = 0; i < num_bulk_out; ++i) {
854 endpoint = bulk_out_endpoint[i];
855 port = serial->port[i];
856 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
857 if (!port->write_urb) {
858 dev_err(&interface->dev, "No free urbs available\n");
859 goto probe_error;
860 }
861 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
862 port->bulk_out_size = buffer_size;
863 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
864 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
865 if (!port->bulk_out_buffer) {
866 dev_err(&interface->dev,
867 "Couldn't allocate bulk_out_buffer\n");
868 goto probe_error;
869 }
870 usb_fill_bulk_urb(port->write_urb, dev,
871 usb_sndbulkpipe(dev,
872 endpoint->bEndpointAddress),
873 port->bulk_out_buffer, buffer_size,
874 serial->type->write_bulk_callback, port);
875 }
876
877 if (serial->type->read_int_callback) {
878 for (i = 0; i < num_interrupt_in; ++i) {
879 endpoint = interrupt_in_endpoint[i];
880 port = serial->port[i];
881 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
882 if (!port->interrupt_in_urb) {
883 dev_err(&interface->dev,
884 "No free urbs available\n");
885 goto probe_error;
886 }
887 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
888 port->interrupt_in_endpointAddress =
889 endpoint->bEndpointAddress;
890 port->interrupt_in_buffer = kmalloc(buffer_size,
891 GFP_KERNEL);
892 if (!port->interrupt_in_buffer) {
893 dev_err(&interface->dev,
894 "Couldn't allocate interrupt_in_buffer\n");
895 goto probe_error;
896 }
897 usb_fill_int_urb(port->interrupt_in_urb, dev,
898 usb_rcvintpipe(dev,
899 endpoint->bEndpointAddress),
900 port->interrupt_in_buffer, buffer_size,
901 serial->type->read_int_callback, port,
902 endpoint->bInterval);
903 }
904 } else if (num_interrupt_in) {
905 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
906 }
907
908 if (serial->type->write_int_callback) {
909 for (i = 0; i < num_interrupt_out; ++i) {
910 endpoint = interrupt_out_endpoint[i];
911 port = serial->port[i];
912 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
913 if (!port->interrupt_out_urb) {
914 dev_err(&interface->dev,
915 "No free urbs available\n");
916 goto probe_error;
917 }
918 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
919 port->interrupt_out_size = buffer_size;
920 port->interrupt_out_endpointAddress =
921 endpoint->bEndpointAddress;
922 port->interrupt_out_buffer = kmalloc(buffer_size,
923 GFP_KERNEL);
924 if (!port->interrupt_out_buffer) {
925 dev_err(&interface->dev,
926 "Couldn't allocate interrupt_out_buffer\n");
927 goto probe_error;
928 }
929 usb_fill_int_urb(port->interrupt_out_urb, dev,
930 usb_sndintpipe(dev,
931 endpoint->bEndpointAddress),
932 port->interrupt_out_buffer, buffer_size,
933 serial->type->write_int_callback, port,
934 endpoint->bInterval);
935 }
936 } else if (num_interrupt_out) {
937 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
938 }
939
940 /* if this device type has an attach function, call it */
941 if (type->attach) {
942 if (!try_module_get(type->driver.owner)) {
943 dev_err(&interface->dev,
944 "module get failed, exiting\n");
945 goto probe_error;
946 }
947 retval = type->attach(serial);
948 module_put(type->driver.owner);
949 if (retval < 0)
950 goto probe_error;
951 if (retval > 0) {
952 /* quietly accept this device, but don't bind to a
953 serial port as it's about to disappear */
954 goto exit;
955 }
956 }
957
958 if (get_free_serial(serial, num_ports, &minor) == NULL) {
959 dev_err(&interface->dev, "No more free serial devices\n");
960 goto probe_error;
961 }
962 serial->minor = minor;
963
964 /* register all of the individual ports with the driver core */
965 for (i = 0; i < num_ports; ++i) {
966 port = serial->port[i];
967 port->dev.parent = &interface->dev;
968 port->dev.driver = NULL;
969 port->dev.bus = &usb_serial_bus_type;
970 port->dev.release = &port_release;
971
972 dev_set_name(&port->dev, "ttyUSB%d", port->number);
973 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
974 retval = device_register(&port->dev);
975 if (retval)
976 dev_err(&port->dev, "Error registering port device, "
977 "continuing\n");
978 }
979
980 usb_serial_console_init(debug, minor);
981
982 exit:
983 /* success */
984 usb_set_intfdata(interface, serial);
985 return 0;
986
987 probe_error:
988 for (i = 0; i < num_bulk_in; ++i) {
989 port = serial->port[i];
990 if (!port)
991 continue;
992 usb_free_urb(port->read_urb);
993 kfree(port->bulk_in_buffer);
994 }
995 for (i = 0; i < num_bulk_out; ++i) {
996 port = serial->port[i];
997 if (!port)
998 continue;
999 usb_free_urb(port->write_urb);
1000 kfree(port->bulk_out_buffer);
1001 }
1002 for (i = 0; i < num_interrupt_in; ++i) {
1003 port = serial->port[i];
1004 if (!port)
1005 continue;
1006 usb_free_urb(port->interrupt_in_urb);
1007 kfree(port->interrupt_in_buffer);
1008 }
1009 for (i = 0; i < num_interrupt_out; ++i) {
1010 port = serial->port[i];
1011 if (!port)
1012 continue;
1013 usb_free_urb(port->interrupt_out_urb);
1014 kfree(port->interrupt_out_buffer);
1015 }
1016
1017 /* free up any memory that we allocated */
1018 for (i = 0; i < serial->num_port_pointers; ++i)
1019 kfree(serial->port[i]);
1020 kfree(serial);
1021 return -EIO;
1022 }
1023 EXPORT_SYMBOL_GPL(usb_serial_probe);
1024
1025 void usb_serial_disconnect(struct usb_interface *interface)
1026 {
1027 int i;
1028 struct usb_serial *serial = usb_get_intfdata(interface);
1029 struct device *dev = &interface->dev;
1030 struct usb_serial_port *port;
1031
1032 usb_serial_console_disconnect(serial);
1033 dbg("%s", __func__);
1034
1035 mutex_lock(&serial->disc_mutex);
1036 usb_set_intfdata(interface, NULL);
1037 /* must set a flag, to signal subdrivers */
1038 serial->disconnected = 1;
1039 for (i = 0; i < serial->num_ports; ++i) {
1040 port = serial->port[i];
1041 if (port) {
1042 if (port->port.tty)
1043 tty_hangup(port->port.tty);
1044 kill_traffic(port);
1045 }
1046 }
1047 /* let the last holder of this object
1048 * cause it to be cleaned up */
1049 mutex_unlock(&serial->disc_mutex);
1050 usb_serial_put(serial);
1051 dev_info(dev, "device disconnected\n");
1052 }
1053 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1054
1055 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1056 {
1057 struct usb_serial *serial = usb_get_intfdata(intf);
1058 struct usb_serial_port *port;
1059 int i, r = 0;
1060
1061 for (i = 0; i < serial->num_ports; ++i) {
1062 port = serial->port[i];
1063 if (port)
1064 kill_traffic(port);
1065 }
1066
1067 if (serial->type->suspend)
1068 r = serial->type->suspend(serial, message);
1069
1070 return r;
1071 }
1072 EXPORT_SYMBOL(usb_serial_suspend);
1073
1074 int usb_serial_resume(struct usb_interface *intf)
1075 {
1076 struct usb_serial *serial = usb_get_intfdata(intf);
1077
1078 if (serial->type->resume)
1079 return serial->type->resume(serial);
1080 return 0;
1081 }
1082 EXPORT_SYMBOL(usb_serial_resume);
1083
1084 static const struct tty_operations serial_ops = {
1085 .open = serial_open,
1086 .close = serial_close,
1087 .write = serial_write,
1088 .write_room = serial_write_room,
1089 .ioctl = serial_ioctl,
1090 .set_termios = serial_set_termios,
1091 .throttle = serial_throttle,
1092 .unthrottle = serial_unthrottle,
1093 .break_ctl = serial_break,
1094 .chars_in_buffer = serial_chars_in_buffer,
1095 .read_proc = serial_read_proc,
1096 .tiocmget = serial_tiocmget,
1097 .tiocmset = serial_tiocmset,
1098 };
1099
1100 struct tty_driver *usb_serial_tty_driver;
1101
1102 static int __init usb_serial_init(void)
1103 {
1104 int i;
1105 int result;
1106
1107 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1108 if (!usb_serial_tty_driver)
1109 return -ENOMEM;
1110
1111 /* Initialize our global data */
1112 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1113 serial_table[i] = NULL;
1114
1115 result = bus_register(&usb_serial_bus_type);
1116 if (result) {
1117 err("%s - registering bus driver failed", __func__);
1118 goto exit_bus;
1119 }
1120
1121 usb_serial_tty_driver->owner = THIS_MODULE;
1122 usb_serial_tty_driver->driver_name = "usbserial";
1123 usb_serial_tty_driver->name = "ttyUSB";
1124 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1125 usb_serial_tty_driver->minor_start = 0;
1126 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1127 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1128 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1129 TTY_DRIVER_DYNAMIC_DEV;
1130 usb_serial_tty_driver->init_termios = tty_std_termios;
1131 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1132 | HUPCL | CLOCAL;
1133 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1134 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1135 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1136 result = tty_register_driver(usb_serial_tty_driver);
1137 if (result) {
1138 err("%s - tty_register_driver failed", __func__);
1139 goto exit_reg_driver;
1140 }
1141
1142 /* register the USB driver */
1143 result = usb_register(&usb_serial_driver);
1144 if (result < 0) {
1145 err("%s - usb_register failed", __func__);
1146 goto exit_tty;
1147 }
1148
1149 /* register the generic driver, if we should */
1150 result = usb_serial_generic_register(debug);
1151 if (result < 0) {
1152 err("%s - registering generic driver failed", __func__);
1153 goto exit_generic;
1154 }
1155
1156 info(DRIVER_DESC);
1157
1158 return result;
1159
1160 exit_generic:
1161 usb_deregister(&usb_serial_driver);
1162
1163 exit_tty:
1164 tty_unregister_driver(usb_serial_tty_driver);
1165
1166 exit_reg_driver:
1167 bus_unregister(&usb_serial_bus_type);
1168
1169 exit_bus:
1170 err("%s - returning with error %d", __func__, result);
1171 put_tty_driver(usb_serial_tty_driver);
1172 return result;
1173 }
1174
1175
1176 static void __exit usb_serial_exit(void)
1177 {
1178 usb_serial_console_exit();
1179
1180 usb_serial_generic_deregister();
1181
1182 usb_deregister(&usb_serial_driver);
1183 tty_unregister_driver(usb_serial_tty_driver);
1184 put_tty_driver(usb_serial_tty_driver);
1185 bus_unregister(&usb_serial_bus_type);
1186 }
1187
1188
1189 module_init(usb_serial_init);
1190 module_exit(usb_serial_exit);
1191
1192 #define set_to_generic_if_null(type, function) \
1193 do { \
1194 if (!type->function) { \
1195 type->function = usb_serial_generic_##function; \
1196 dbg("Had to override the " #function \
1197 " usb serial operation with the generic one.");\
1198 } \
1199 } while (0)
1200
1201 static void fixup_generic(struct usb_serial_driver *device)
1202 {
1203 set_to_generic_if_null(device, open);
1204 set_to_generic_if_null(device, write);
1205 set_to_generic_if_null(device, close);
1206 set_to_generic_if_null(device, write_room);
1207 set_to_generic_if_null(device, chars_in_buffer);
1208 set_to_generic_if_null(device, read_bulk_callback);
1209 set_to_generic_if_null(device, write_bulk_callback);
1210 set_to_generic_if_null(device, shutdown);
1211 set_to_generic_if_null(device, resume);
1212 }
1213
1214 int usb_serial_register(struct usb_serial_driver *driver)
1215 {
1216 /* must be called with BKL held */
1217 int retval;
1218
1219 fixup_generic(driver);
1220
1221 if (!driver->description)
1222 driver->description = driver->driver.name;
1223
1224 /* Add this device to our list of devices */
1225 list_add(&driver->driver_list, &usb_serial_driver_list);
1226
1227 retval = usb_serial_bus_register(driver);
1228 if (retval) {
1229 err("problem %d when registering driver %s",
1230 retval, driver->description);
1231 list_del(&driver->driver_list);
1232 } else
1233 info("USB Serial support registered for %s",
1234 driver->description);
1235
1236 return retval;
1237 }
1238 EXPORT_SYMBOL_GPL(usb_serial_register);
1239
1240
1241 void usb_serial_deregister(struct usb_serial_driver *device)
1242 {
1243 /* must be called with BKL held */
1244 info("USB Serial deregistering driver %s", device->description);
1245 list_del(&device->driver_list);
1246 usb_serial_bus_deregister(device);
1247 }
1248 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1249
1250 /* Module information */
1251 MODULE_AUTHOR(DRIVER_AUTHOR);
1252 MODULE_DESCRIPTION(DRIVER_DESC);
1253 MODULE_LICENSE("GPL");
1254
1255 module_param(debug, bool, S_IRUGO | S_IWUSR);
1256 MODULE_PARM_DESC(debug, "Debug enabled or not");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree