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