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