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