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