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