?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ia64/kvm: compilation fix. export account_system_vtime.
[pv_ops_mirror.git] / drivers / usb / serial / usb-serial.c
blob0cb0d77dc429b2b5d0f0dbd916feac063db7a4f6
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", __func__, 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", __func__, *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", __func__);
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", __func__, 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", __func__);
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 retval = usb_autopm_get_interface(serial->interface);
229 if (retval)
230 goto bailout_module_put;
231 /* only call the device specific open if this
232 * is the first time the port is opened */
233 retval = serial->type->open(port, filp);
234 if (retval)
235 goto bailout_interface_put;
236 }
237
238 mutex_unlock(&port->mutex);
239 return 0;
240
241 bailout_interface_put:
242 usb_autopm_put_interface(serial->interface);
243 bailout_module_put:
244 module_put(serial->type->driver.owner);
245 bailout_mutex_unlock:
246 port->open_count = 0;
247 tty->driver_data = NULL;
248 port->tty = NULL;
249 mutex_unlock(&port->mutex);
250 bailout_kref_put:
251 usb_serial_put(serial);
252 return retval;
253 }
254
255 static void serial_close(struct tty_struct *tty, struct file * filp)
256 {
257 struct usb_serial_port *port = tty->driver_data;
258
259 if (!port)
260 return;
261
262 dbg("%s - port %d", __func__, port->number);
263
264 mutex_lock(&port->mutex);
265
266 if (port->open_count == 0) {
267 mutex_unlock(&port->mutex);
268 return;
269 }
270
271 --port->open_count;
272 if (port->open_count == 0)
273 /* only call the device specific close if this
274 * port is being closed by the last owner */
275 port->serial->type->close(port, filp);
276
277 if (port->open_count == (port->console? 1 : 0)) {
278 if (port->tty) {
279 if (port->tty->driver_data)
280 port->tty->driver_data = NULL;
281 port->tty = NULL;
282 }
283 }
284
285 if (port->open_count == 0) {
286 usb_autopm_put_interface(port->serial->interface);
287 module_put(port->serial->type->driver.owner);
288 }
289
290 mutex_unlock(&port->mutex);
291 usb_serial_put(port->serial);
292 }
293
294 static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count)
295 {
296 struct usb_serial_port *port = tty->driver_data;
297 int retval = -ENODEV;
298
299 if (port->serial->dev->state == USB_STATE_NOTATTACHED)
300 goto exit;
301
302 dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
303
304 /* open_count is managed under the mutex lock for the tty so cannot
305 drop to zero until after the last close completes */
306 WARN_ON(!port->open_count);
307
308 /* pass on to the driver specific version of this function */
309 retval = port->serial->type->write(port, buf, count);
310
311 exit:
312 return retval;
313 }
314
315 static int serial_write_room (struct tty_struct *tty)
316 {
317 struct usb_serial_port *port = tty->driver_data;
318 dbg("%s - port %d", __func__, port->number);
319 WARN_ON(!port->open_count);
320 /* pass on to the driver specific version of this function */
321 return port->serial->type->write_room(port);
322 }
323
324 static int serial_chars_in_buffer (struct tty_struct *tty)
325 {
326 struct usb_serial_port *port = tty->driver_data;
327 dbg("%s = port %d", __func__, port->number);
328
329 WARN_ON(!port->open_count);
330 /* pass on to the driver specific version of this function */
331 return port->serial->type->chars_in_buffer(port);
332 }
333
334 static void serial_throttle (struct tty_struct * tty)
335 {
336 struct usb_serial_port *port = tty->driver_data;
337 dbg("%s - port %d", __func__, port->number);
338
339 WARN_ON(!port->open_count);
340 /* pass on to the driver specific version of this function */
341 if (port->serial->type->throttle)
342 port->serial->type->throttle(port);
343 }
344
345 static void serial_unthrottle (struct tty_struct * tty)
346 {
347 struct usb_serial_port *port = tty->driver_data;
348 dbg("%s - port %d", __func__, port->number);
349
350 WARN_ON(!port->open_count);
351 /* pass on to the driver specific version of this function */
352 if (port->serial->type->unthrottle)
353 port->serial->type->unthrottle(port);
354 }
355
356 static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
357 {
358 struct usb_serial_port *port = tty->driver_data;
359 int retval = -ENODEV;
360
361 dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
362
363 WARN_ON(!port->open_count);
364
365 /* pass on to the driver specific version of this function if it is available */
366 if (port->serial->type->ioctl) {
367 lock_kernel();
368 retval = port->serial->type->ioctl(port, file, cmd, arg);
369 unlock_kernel();
370 }
371 else
372 retval = -ENOIOCTLCMD;
373 return retval;
374 }
375
376 static void serial_set_termios (struct tty_struct *tty, struct ktermios * old)
377 {
378 struct usb_serial_port *port = tty->driver_data;
379 dbg("%s - port %d", __func__, port->number);
380
381 WARN_ON(!port->open_count);
382 /* pass on to the driver specific version of this function if it is available */
383 if (port->serial->type->set_termios)
384 port->serial->type->set_termios(port, old);
385 else
386 tty_termios_copy_hw(tty->termios, old);
387 }
388
389 static void serial_break (struct tty_struct *tty, int break_state)
390 {
391 struct usb_serial_port *port = tty->driver_data;
392
393 dbg("%s - port %d", __func__, port->number);
394
395 WARN_ON(!port->open_count);
396 /* pass on to the driver specific version of this function if it is available */
397 if (port->serial->type->break_ctl) {
398 lock_kernel();
399 port->serial->type->break_ctl(port, break_state);
400 unlock_kernel();
401 }
402 }
403
404 static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
405 {
406 struct usb_serial *serial;
407 int length = 0;
408 int i;
409 off_t begin = 0;
410 char tmp[40];
411
412 dbg("%s", __func__);
413 length += sprintf (page, "usbserinfo:1.0 driver:2.0\n");
414 for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
415 serial = usb_serial_get_by_index(i);
416 if (serial == NULL)
417 continue;
418
419 length += sprintf (page+length, "%d:", i);
420 if (serial->type->driver.owner)
421 length += sprintf (page+length, " module:%s", module_name(serial->type->driver.owner));
422 length += sprintf (page+length, " name:\"%s\"", serial->type->description);
423 length += sprintf (page+length, " vendor:%04x product:%04x",
424 le16_to_cpu(serial->dev->descriptor.idVendor),
425 le16_to_cpu(serial->dev->descriptor.idProduct));
426 length += sprintf (page+length, " num_ports:%d", serial->num_ports);
427 length += sprintf (page+length, " port:%d", i - serial->minor + 1);
428
429 usb_make_path(serial->dev, tmp, sizeof(tmp));
430 length += sprintf (page+length, " path:%s", tmp);
431
432 length += sprintf (page+length, "\n");
433 if ((length + begin) > (off + count)) {
434 usb_serial_put(serial);
435 goto done;
436 }
437 if ((length + begin) < off) {
438 begin += length;
439 length = 0;
440 }
441 usb_serial_put(serial);
442 }
443 *eof = 1;
444 done:
445 if (off >= (length + begin))
446 return 0;
447 *start = page + (off-begin);
448 return ((count < begin+length-off) ? count : begin+length-off);
449 }
450
451 static int serial_tiocmget (struct tty_struct *tty, struct file *file)
452 {
453 struct usb_serial_port *port = tty->driver_data;
454
455 dbg("%s - port %d", __func__, port->number);
456
457 WARN_ON(!port->open_count);
458 if (port->serial->type->tiocmget)
459 return port->serial->type->tiocmget(port, file);
460 return -EINVAL;
461 }
462
463 static int serial_tiocmset (struct tty_struct *tty, struct file *file,
464 unsigned int set, unsigned int clear)
465 {
466 struct usb_serial_port *port = tty->driver_data;
467
468 dbg("%s - port %d", __func__, port->number);
469
470 WARN_ON(!port->open_count);
471 if (port->serial->type->tiocmset)
472 return port->serial->type->tiocmset(port, file, set, clear);
473 return -EINVAL;
474 }
475
476 /*
477 * We would be calling tty_wakeup here, but unfortunately some line
478 * disciplines have an annoying habit of calling tty->write from
479 * the write wakeup callback (e.g. n_hdlc.c).
480 */
481 void usb_serial_port_softint(struct usb_serial_port *port)
482 {
483 schedule_work(&port->work);
484 }
485
486 static void usb_serial_port_work(struct work_struct *work)
487 {
488 struct usb_serial_port *port =
489 container_of(work, struct usb_serial_port, work);
490 struct tty_struct *tty;
491
492 dbg("%s - port %d", __func__, port->number);
493
494 if (!port)
495 return;
496
497 tty = port->tty;
498 if (!tty)
499 return;
500
501 tty_wakeup(tty);
502 }
503
504 static void port_release(struct device *dev)
505 {
506 struct usb_serial_port *port = to_usb_serial_port(dev);
507
508 dbg ("%s - %s", __func__, dev->bus_id);
509 port_free(port);
510 }
511
512 static void kill_traffic(struct usb_serial_port *port)
513 {
514 usb_kill_urb(port->read_urb);
515 usb_kill_urb(port->write_urb);
516 /*
517 * This is tricky.
518 * Some drivers submit the read_urb in the
519 * handler for the write_urb or vice versa
520 * this order determines the order in which
521 * usb_kill_urb() must be used to reliably
522 * kill the URBs. As it is unknown here,
523 * both orders must be used in turn.
524 * The call below is not redundant.
525 */
526 usb_kill_urb(port->read_urb);
527 usb_kill_urb(port->interrupt_in_urb);
528 usb_kill_urb(port->interrupt_out_urb);
529 }
530
531 static void port_free(struct usb_serial_port *port)
532 {
533 kill_traffic(port);
534 usb_free_urb(port->read_urb);
535 usb_free_urb(port->write_urb);
536 usb_free_urb(port->interrupt_in_urb);
537 usb_free_urb(port->interrupt_out_urb);
538 kfree(port->bulk_in_buffer);
539 kfree(port->bulk_out_buffer);
540 kfree(port->interrupt_in_buffer);
541 kfree(port->interrupt_out_buffer);
542 flush_scheduled_work(); /* port->work */
543 kfree(port);
544 }
545
546 static struct usb_serial * create_serial (struct usb_device *dev,
547 struct usb_interface *interface,
548 struct usb_serial_driver *driver)
549 {
550 struct usb_serial *serial;
551
552 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
553 if (!serial) {
554 dev_err(&dev->dev, "%s - out of memory\n", __func__);
555 return NULL;
556 }
557 serial->dev = usb_get_dev(dev);
558 serial->type = driver;
559 serial->interface = interface;
560 kref_init(&serial->kref);
561 mutex_init(&serial->disc_mutex);
562
563 return serial;
564 }
565
566 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
567 struct usb_serial_driver *drv)
568 {
569 struct usb_dynid *dynid;
570
571 spin_lock(&drv->dynids.lock);
572 list_for_each_entry(dynid, &drv->dynids.list, node) {
573 if (usb_match_one_id(intf, &dynid->id)) {
574 spin_unlock(&drv->dynids.lock);
575 return &dynid->id;
576 }
577 }
578 spin_unlock(&drv->dynids.lock);
579 return NULL;
580 }
581
582 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
583 struct usb_interface *intf)
584 {
585 const struct usb_device_id *id;
586
587 id = usb_match_id(intf, drv->id_table);
588 if (id) {
589 dbg("static descriptor matches");
590 goto exit;
591 }
592 id = match_dynamic_id(intf, drv);
593 if (id)
594 dbg("dynamic descriptor matches");
595 exit:
596 return id;
597 }
598
599 static struct usb_serial_driver *search_serial_device(struct usb_interface *iface)
600 {
601 const struct usb_device_id *id;
602 struct usb_serial_driver *drv;
603
604 /* Check if the usb id matches a known device */
605 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
606 id = get_iface_id(drv, iface);
607 if (id)
608 return drv;
609 }
610
611 return NULL;
612 }
613
614 int usb_serial_probe(struct usb_interface *interface,
615 const struct usb_device_id *id)
616 {
617 struct usb_device *dev = interface_to_usbdev (interface);
618 struct usb_serial *serial = NULL;
619 struct usb_serial_port *port;
620 struct usb_host_interface *iface_desc;
621 struct usb_endpoint_descriptor *endpoint;
622 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
623 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
624 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
625 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
626 struct usb_serial_driver *type = NULL;
627 int retval;
628 int minor;
629 int buffer_size;
630 int i;
631 int num_interrupt_in = 0;
632 int num_interrupt_out = 0;
633 int num_bulk_in = 0;
634 int num_bulk_out = 0;
635 int num_ports = 0;
636 int max_endpoints;
637
638 lock_kernel(); /* guard against unloading a serial driver module */
639 type = search_serial_device(interface);
640 if (!type) {
641 unlock_kernel();
642 dbg("none matched");
643 return -ENODEV;
644 }
645
646 serial = create_serial (dev, interface, type);
647 if (!serial) {
648 unlock_kernel();
649 dev_err(&interface->dev, "%s - out of memory\n", __func__);
650 return -ENOMEM;
651 }
652
653 /* if this device type has a probe function, call it */
654 if (type->probe) {
655 const struct usb_device_id *id;
656
657 if (!try_module_get(type->driver.owner)) {
658 unlock_kernel();
659 dev_err(&interface->dev, "module get failed, exiting\n");
660 kfree (serial);
661 return -EIO;
662 }
663
664 id = get_iface_id(type, interface);
665 retval = type->probe(serial, id);
666 module_put(type->driver.owner);
667
668 if (retval) {
669 unlock_kernel();
670 dbg ("sub driver rejected device");
671 kfree (serial);
672 return retval;
673 }
674 }
675
676 /* descriptor matches, let's find the endpoints needed */
677 /* check out the endpoints */
678 iface_desc = interface->cur_altsetting;
679 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
680 endpoint = &iface_desc->endpoint[i].desc;
681
682 if (usb_endpoint_is_bulk_in(endpoint)) {
683 /* we found a bulk in endpoint */
684 dbg("found bulk in on endpoint %d", i);
685 bulk_in_endpoint[num_bulk_in] = endpoint;
686 ++num_bulk_in;
687 }
688
689 if (usb_endpoint_is_bulk_out(endpoint)) {
690 /* we found a bulk out endpoint */
691 dbg("found bulk out on endpoint %d", i);
692 bulk_out_endpoint[num_bulk_out] = endpoint;
693 ++num_bulk_out;
694 }
695
696 if (usb_endpoint_is_int_in(endpoint)) {
697 /* we found a interrupt in endpoint */
698 dbg("found interrupt in on endpoint %d", i);
699 interrupt_in_endpoint[num_interrupt_in] = endpoint;
700 ++num_interrupt_in;
701 }
702
703 if (usb_endpoint_is_int_out(endpoint)) {
704 /* we found an interrupt out endpoint */
705 dbg("found interrupt out on endpoint %d", i);
706 interrupt_out_endpoint[num_interrupt_out] = endpoint;
707 ++num_interrupt_out;
708 }
709 }
710
711 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
712 /* BEGIN HORRIBLE HACK FOR PL2303 */
713 /* this is needed due to the looney way its endpoints are set up */
714 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
715 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
716 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
717 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
718 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
719 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID))) {
720 if (interface != dev->actconfig->interface[0]) {
721 /* check out the endpoints of the other interface*/
722 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
723 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
724 endpoint = &iface_desc->endpoint[i].desc;
725 if (usb_endpoint_is_int_in(endpoint)) {
726 /* we found a interrupt in endpoint */
727 dbg("found interrupt in for Prolific device on separate interface");
728 interrupt_in_endpoint[num_interrupt_in] = endpoint;
729 ++num_interrupt_in;
730 }
731 }
732 }
733
734 /* Now make sure the PL-2303 is configured correctly.
735 * If not, give up now and hope this hack will work
736 * properly during a later invocation of usb_serial_probe
737 */
738 if (num_bulk_in == 0 || num_bulk_out == 0) {
739 unlock_kernel();
740 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
741 kfree (serial);
742 return -ENODEV;
743 }
744 }
745 /* END HORRIBLE HACK FOR PL2303 */
746 #endif
747
748 #ifdef CONFIG_USB_SERIAL_GENERIC
749 if (type == &usb_serial_generic_device) {
750 num_ports = num_bulk_out;
751 if (num_ports == 0) {
752 unlock_kernel();
753 dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n");
754 kfree (serial);
755 return -EIO;
756 }
757 }
758 #endif
759 if (!num_ports) {
760 /* if this device type has a calc_num_ports function, call it */
761 if (type->calc_num_ports) {
762 if (!try_module_get(type->driver.owner)) {
763 unlock_kernel();
764 dev_err(&interface->dev, "module get failed, exiting\n");
765 kfree (serial);
766 return -EIO;
767 }
768 num_ports = type->calc_num_ports (serial);
769 module_put(type->driver.owner);
770 }
771 if (!num_ports)
772 num_ports = type->num_ports;
773 }
774
775 serial->num_ports = num_ports;
776 serial->num_bulk_in = num_bulk_in;
777 serial->num_bulk_out = num_bulk_out;
778 serial->num_interrupt_in = num_interrupt_in;
779 serial->num_interrupt_out = num_interrupt_out;
780
781 /* found all that we need */
782 dev_info(&interface->dev, "%s converter detected\n",
783 type->description);
784
785 /* create our ports, we need as many as the max endpoints */
786 /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
787 max_endpoints = max(num_bulk_in, num_bulk_out);
788 max_endpoints = max(max_endpoints, num_interrupt_in);
789 max_endpoints = max(max_endpoints, num_interrupt_out);
790 max_endpoints = max(max_endpoints, (int)serial->num_ports);
791 serial->num_port_pointers = max_endpoints;
792 unlock_kernel();
793
794 dbg("%s - setting up %d port structures for this device", __func__, max_endpoints);
795 for (i = 0; i < max_endpoints; ++i) {
796 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
797 if (!port)
798 goto probe_error;
799 port->serial = serial;
800 spin_lock_init(&port->lock);
801 mutex_init(&port->mutex);
802 INIT_WORK(&port->work, usb_serial_port_work);
803 serial->port[i] = port;
804 }
805
806 /* set up the endpoint information */
807 for (i = 0; i < num_bulk_in; ++i) {
808 endpoint = bulk_in_endpoint[i];
809 port = serial->port[i];
810 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
811 if (!port->read_urb) {
812 dev_err(&interface->dev, "No free urbs available\n");
813 goto probe_error;
814 }
815 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
816 port->bulk_in_size = buffer_size;
817 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
818 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
819 if (!port->bulk_in_buffer) {
820 dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
821 goto probe_error;
822 }
823 usb_fill_bulk_urb (port->read_urb, dev,
824 usb_rcvbulkpipe (dev,
825 endpoint->bEndpointAddress),
826 port->bulk_in_buffer, buffer_size,
827 serial->type->read_bulk_callback,
828 port);
829 }
830
831 for (i = 0; i < num_bulk_out; ++i) {
832 endpoint = bulk_out_endpoint[i];
833 port = serial->port[i];
834 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
835 if (!port->write_urb) {
836 dev_err(&interface->dev, "No free urbs available\n");
837 goto probe_error;
838 }
839 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
840 port->bulk_out_size = buffer_size;
841 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
842 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
843 if (!port->bulk_out_buffer) {
844 dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n");
845 goto probe_error;
846 }
847 usb_fill_bulk_urb (port->write_urb, dev,
848 usb_sndbulkpipe (dev,
849 endpoint->bEndpointAddress),
850 port->bulk_out_buffer, buffer_size,
851 serial->type->write_bulk_callback,
852 port);
853 }
854
855 if (serial->type->read_int_callback) {
856 for (i = 0; i < num_interrupt_in; ++i) {
857 endpoint = interrupt_in_endpoint[i];
858 port = serial->port[i];
859 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
860 if (!port->interrupt_in_urb) {
861 dev_err(&interface->dev, "No free urbs available\n");
862 goto probe_error;
863 }
864 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
865 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
866 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
867 if (!port->interrupt_in_buffer) {
868 dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
869 goto probe_error;
870 }
871 usb_fill_int_urb (port->interrupt_in_urb, dev,
872 usb_rcvintpipe (dev,
873 endpoint->bEndpointAddress),
874 port->interrupt_in_buffer, buffer_size,
875 serial->type->read_int_callback, port,
876 endpoint->bInterval);
877 }
878 } else if (num_interrupt_in) {
879 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
880 }
881
882 if (serial->type->write_int_callback) {
883 for (i = 0; i < num_interrupt_out; ++i) {
884 endpoint = interrupt_out_endpoint[i];
885 port = serial->port[i];
886 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
887 if (!port->interrupt_out_urb) {
888 dev_err(&interface->dev, "No free urbs available\n");
889 goto probe_error;
890 }
891 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
892 port->interrupt_out_size = buffer_size;
893 port->interrupt_out_endpointAddress = endpoint->bEndpointAddress;
894 port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
895 if (!port->interrupt_out_buffer) {
896 dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n");
897 goto probe_error;
898 }
899 usb_fill_int_urb (port->interrupt_out_urb, dev,
900 usb_sndintpipe (dev,
901 endpoint->bEndpointAddress),
902 port->interrupt_out_buffer, buffer_size,
903 serial->type->write_int_callback, port,
904 endpoint->bInterval);
905 }
906 } else if (num_interrupt_out) {
907 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
908 }
909
910 /* if this device type has an attach function, call it */
911 if (type->attach) {
912 if (!try_module_get(type->driver.owner)) {
913 dev_err(&interface->dev, "module get failed, exiting\n");
914 goto probe_error;
915 }
916 retval = type->attach (serial);
917 module_put(type->driver.owner);
918 if (retval < 0)
919 goto probe_error;
920 if (retval > 0) {
921 /* quietly accept this device, but don't bind to a serial port
922 * as it's about to disappear */
923 goto exit;
924 }
925 }
926
927 if (get_free_serial (serial, num_ports, &minor) == NULL) {
928 dev_err(&interface->dev, "No more free serial devices\n");
929 goto probe_error;
930 }
931 serial->minor = minor;
932
933 /* register all of the individual ports with the driver core */
934 for (i = 0; i < num_ports; ++i) {
935 port = serial->port[i];
936 port->dev.parent = &interface->dev;
937 port->dev.driver = NULL;
938 port->dev.bus = &usb_serial_bus_type;
939 port->dev.release = &port_release;
940
941 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
942 dbg ("%s - registering %s", __func__, port->dev.bus_id);
943 retval = device_register(&port->dev);
944 if (retval)
945 dev_err(&port->dev, "Error registering port device, "
946 "continuing\n");
947 }
948
949 usb_serial_console_init (debug, minor);
950
951 exit:
952 /* success */
953 usb_set_intfdata (interface, serial);
954 return 0;
955
956 probe_error:
957 for (i = 0; i < num_bulk_in; ++i) {
958 port = serial->port[i];
959 if (!port)
960 continue;
961 usb_free_urb(port->read_urb);
962 kfree(port->bulk_in_buffer);
963 }
964 for (i = 0; i < num_bulk_out; ++i) {
965 port = serial->port[i];
966 if (!port)
967 continue;
968 usb_free_urb(port->write_urb);
969 kfree(port->bulk_out_buffer);
970 }
971 for (i = 0; i < num_interrupt_in; ++i) {
972 port = serial->port[i];
973 if (!port)
974 continue;
975 usb_free_urb(port->interrupt_in_urb);
976 kfree(port->interrupt_in_buffer);
977 }
978 for (i = 0; i < num_interrupt_out; ++i) {
979 port = serial->port[i];
980 if (!port)
981 continue;
982 usb_free_urb(port->interrupt_out_urb);
983 kfree(port->interrupt_out_buffer);
984 }
985
986 /* free up any memory that we allocated */
987 for (i = 0; i < serial->num_port_pointers; ++i)
988 kfree(serial->port[i]);
989 kfree (serial);
990 return -EIO;
991 }
992
993 void usb_serial_disconnect(struct usb_interface *interface)
994 {
995 int i;
996 struct usb_serial *serial = usb_get_intfdata (interface);
997 struct device *dev = &interface->dev;
998 struct usb_serial_port *port;
999
1000 usb_serial_console_disconnect(serial);
1001 dbg ("%s", __func__);
1002
1003 mutex_lock(&serial->disc_mutex);
1004 usb_set_intfdata (interface, NULL);
1005 /* must set a flag, to signal subdrivers */
1006 serial->disconnected = 1;
1007 for (i = 0; i < serial->num_ports; ++i) {
1008 port = serial->port[i];
1009 if (port) {
1010 if (port->tty)
1011 tty_hangup(port->tty);
1012 kill_traffic(port);
1013 }
1014 }
1015 /* let the last holder of this object
1016 * cause it to be cleaned up */
1017 mutex_unlock(&serial->disc_mutex);
1018 usb_serial_put(serial);
1019 dev_info(dev, "device disconnected\n");
1020 }
1021
1022 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1023 {
1024 struct usb_serial *serial = usb_get_intfdata(intf);
1025 struct usb_serial_port *port;
1026 int i, r = 0;
1027
1028 for (i = 0; i < serial->num_ports; ++i) {
1029 port = serial->port[i];
1030 if (port)
1031 kill_traffic(port);
1032 }
1033
1034 if (serial->type->suspend)
1035 r = serial->type->suspend(serial, message);
1036
1037 return r;
1038 }
1039 EXPORT_SYMBOL(usb_serial_suspend);
1040
1041 int usb_serial_resume(struct usb_interface *intf)
1042 {
1043 struct usb_serial *serial = usb_get_intfdata(intf);
1044
1045 if (serial->type->resume)
1046 return serial->type->resume(serial);
1047 return 0;
1048 }
1049 EXPORT_SYMBOL(usb_serial_resume);
1050
1051 static const struct tty_operations serial_ops = {
1052 .open = serial_open,
1053 .close = serial_close,
1054 .write = serial_write,
1055 .write_room = serial_write_room,
1056 .ioctl = serial_ioctl,
1057 .set_termios = serial_set_termios,
1058 .throttle = serial_throttle,
1059 .unthrottle = serial_unthrottle,
1060 .break_ctl = serial_break,
1061 .chars_in_buffer = serial_chars_in_buffer,
1062 .read_proc = serial_read_proc,
1063 .tiocmget = serial_tiocmget,
1064 .tiocmset = serial_tiocmset,
1065 };
1066
1067 struct tty_driver *usb_serial_tty_driver;
1068
1069 static int __init usb_serial_init(void)
1070 {
1071 int i;
1072 int result;
1073
1074 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1075 if (!usb_serial_tty_driver)
1076 return -ENOMEM;
1077
1078 /* Initialize our global data */
1079 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1080 serial_table[i] = NULL;
1081 }
1082
1083 result = bus_register(&usb_serial_bus_type);
1084 if (result) {
1085 err("%s - registering bus driver failed", __func__);
1086 goto exit_bus;
1087 }
1088
1089 usb_serial_tty_driver->owner = THIS_MODULE;
1090 usb_serial_tty_driver->driver_name = "usbserial";
1091 usb_serial_tty_driver->name = "ttyUSB";
1092 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1093 usb_serial_tty_driver->minor_start = 0;
1094 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1095 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1096 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1097 usb_serial_tty_driver->init_termios = tty_std_termios;
1098 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1099 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1100 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1101 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1102 result = tty_register_driver(usb_serial_tty_driver);
1103 if (result) {
1104 err("%s - tty_register_driver failed", __func__);
1105 goto exit_reg_driver;
1106 }
1107
1108 /* register the USB driver */
1109 result = usb_register(&usb_serial_driver);
1110 if (result < 0) {
1111 err("%s - usb_register failed", __func__);
1112 goto exit_tty;
1113 }
1114
1115 /* register the generic driver, if we should */
1116 result = usb_serial_generic_register(debug);
1117 if (result < 0) {
1118 err("%s - registering generic driver failed", __func__);
1119 goto exit_generic;
1120 }
1121
1122 info(DRIVER_DESC);
1123
1124 return result;
1125
1126 exit_generic:
1127 usb_deregister(&usb_serial_driver);
1128
1129 exit_tty:
1130 tty_unregister_driver(usb_serial_tty_driver);
1131
1132 exit_reg_driver:
1133 bus_unregister(&usb_serial_bus_type);
1134
1135 exit_bus:
1136 err ("%s - returning with error %d", __func__, result);
1137 put_tty_driver(usb_serial_tty_driver);
1138 return result;
1139 }
1140
1141
1142 static void __exit usb_serial_exit(void)
1143 {
1144 usb_serial_console_exit();
1145
1146 usb_serial_generic_deregister();
1147
1148 usb_deregister(&usb_serial_driver);
1149 tty_unregister_driver(usb_serial_tty_driver);
1150 put_tty_driver(usb_serial_tty_driver);
1151 bus_unregister(&usb_serial_bus_type);
1152 }
1153
1154
1155 module_init(usb_serial_init);
1156 module_exit(usb_serial_exit);
1157
1158 #define set_to_generic_if_null(type, function) \
1159 do { \
1160 if (!type->function) { \
1161 type->function = usb_serial_generic_##function; \
1162 dbg("Had to override the " #function \
1163 " usb serial operation with the generic one.");\
1164 } \
1165 } while (0)
1166
1167 static void fixup_generic(struct usb_serial_driver *device)
1168 {
1169 set_to_generic_if_null(device, open);
1170 set_to_generic_if_null(device, write);
1171 set_to_generic_if_null(device, close);
1172 set_to_generic_if_null(device, write_room);
1173 set_to_generic_if_null(device, chars_in_buffer);
1174 set_to_generic_if_null(device, read_bulk_callback);
1175 set_to_generic_if_null(device, write_bulk_callback);
1176 set_to_generic_if_null(device, shutdown);
1177 set_to_generic_if_null(device, resume);
1178 }
1179
1180 int usb_serial_register(struct usb_serial_driver *driver) /* must be called with BKL held */
1181 {
1182 int retval;
1183
1184 fixup_generic(driver);
1185
1186 if (!driver->description)
1187 driver->description = driver->driver.name;
1188
1189 /* Add this device to our list of devices */
1190 list_add(&driver->driver_list, &usb_serial_driver_list);
1191
1192 retval = usb_serial_bus_register(driver);
1193 if (retval) {
1194 err("problem %d when registering driver %s", retval, driver->description);
1195 list_del(&driver->driver_list);
1196 }
1197 else
1198 info("USB Serial support registered for %s", driver->description);
1199
1200 return retval;
1201 }
1202
1203
1204 void usb_serial_deregister(struct usb_serial_driver *device) /* must be called with BKL held */
1205 {
1206 info("USB Serial deregistering driver %s", device->description);
1207 list_del(&device->driver_list);
1208 usb_serial_bus_deregister(device);
1209 }
1210
1211
1212
1213 /* If the usb-serial core is built into the core, the usb-serial drivers
1214 need these symbols to load properly as modules. */
1215 EXPORT_SYMBOL_GPL(usb_serial_register);
1216 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1217 EXPORT_SYMBOL_GPL(usb_serial_probe);
1218 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1219 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
1220
1221
1222 /* Module information */
1223 MODULE_AUTHOR( DRIVER_AUTHOR );
1224 MODULE_DESCRIPTION( DRIVER_DESC );
1225 MODULE_LICENSE("GPL");
1226
1227 module_param(debug, bool, S_IRUGO | S_IWUSR);
1228 MODULE_PARM_DESC(debug, "Debug enabled or not");
Mirror for ia64_pv_ops.git