aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/serial/usb-serial.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/usb/serial/usb-serial.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'drivers/usb/serial/usb-serial.c')
-rw-r--r--drivers/usb/serial/usb-serial.c1435
1 files changed, 1435 insertions, 0 deletions
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
new file mode 100644
index 000000000000..4536f63faaea
--- /dev/null
+++ b/drivers/usb/serial/usb-serial.c
@@ -0,0 +1,1435 @@
1/*
2 * USB Serial Converter driver
3 *
4 * Copyright (C) 1999 - 2004 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 * (12/10/2002) gkh
18 * Split the ports off into their own struct device, and added a
19 * usb-serial bus driver.
20 *
21 * (11/19/2002) gkh
22 * removed a few #ifdefs for the generic code and cleaned up the failure
23 * logic in initialization.
24 *
25 * (10/02/2002) gkh
26 * moved the console code to console.c and out of this file.
27 *
28 * (06/05/2002) gkh
29 * moved location of startup() call in serial_probe() until after all
30 * of the port information and endpoints are initialized. This makes
31 * things easier for some drivers.
32 *
33 * (04/10/2002) gkh
34 * added serial_read_proc function which creates a
35 * /proc/tty/driver/usb-serial file.
36 *
37 * (03/27/2002) gkh
38 * Got USB serial console code working properly and merged into the main
39 * version of the tree. Thanks to Randy Dunlap for the initial version
40 * of this code, and for pushing me to finish it up.
41 * The USB serial console works with any usb serial driver device.
42 *
43 * (03/21/2002) gkh
44 * Moved all manipulation of port->open_count into the core. Now the
45 * individual driver's open and close functions are called only when the
46 * first open() and last close() is called. Making the drivers a bit
47 * smaller and simpler.
48 * Fixed a bug if a driver didn't have the owner field set.
49 *
50 * (02/26/2002) gkh
51 * Moved all locking into the main serial_* functions, instead of having
52 * the individual drivers have to grab the port semaphore. This should
53 * reduce races.
54 * Reworked the MOD_INC logic a bit to always increment and decrement, even
55 * if the generic driver is being used.
56 *
57 * (10/10/2001) gkh
58 * usb_serial_disconnect() now sets the serial->dev pointer is to NULL to
59 * help prevent child drivers from accessing the device since it is now
60 * gone.
61 *
62 * (09/13/2001) gkh
63 * Moved generic driver initialize after we have registered with the USB
64 * core. Thanks to Randy Dunlap for pointing this problem out.
65 *
66 * (07/03/2001) gkh
67 * Fixed module paramater size. Thanks to John Brockmeyer for the pointer.
68 * Fixed vendor and product getting defined through the MODULE_PARM macro
69 * if the Generic driver wasn't compiled in.
70 * Fixed problem with generic_shutdown() not being called for drivers that
71 * don't have a shutdown() function.
72 *
73 * (06/06/2001) gkh
74 * added evil hack that is needed for the prolific pl2303 device due to the
75 * crazy way its endpoints are set up.
76 *
77 * (05/30/2001) gkh
78 * switched from using spinlock to a semaphore, which fixes lots of problems.
79 *
80 * (04/08/2001) gb
81 * Identify version on module load.
82 *
83 * 2001_02_05 gkh
84 * Fixed buffer overflows bug with the generic serial driver. Thanks to
85 * Todd Squires <squirest@ct0.com> for fixing this.
86 *
87 * (01/10/2001) gkh
88 * Fixed bug where the generic serial adaptor grabbed _any_ device that was
89 * offered to it.
90 *
91 * (12/12/2000) gkh
92 * Removed MOD_INC and MOD_DEC from poll and disconnect functions, and
93 * moved them to the serial_open and serial_close functions.
94 * Also fixed bug with there not being a MOD_DEC for the generic driver
95 * (thanks to Gary Brubaker for finding this.)
96 *
97 * (11/29/2000) gkh
98 * Small NULL pointer initialization cleanup which saves a bit of disk image
99 *
100 * (11/01/2000) Adam J. Richter
101 * instead of using idVendor/idProduct pairs, usb serial drivers
102 * now identify their hardware interest with usb_device_id tables,
103 * which they usually have anyhow for use with MODULE_DEVICE_TABLE.
104 *
105 * (10/05/2000) gkh
106 * Fixed bug with urb->dev not being set properly, now that the usb
107 * core needs it.
108 *
109 * (09/11/2000) gkh
110 * Removed DEBUG #ifdefs with call to usb_serial_debug_data
111 *
112 * (08/28/2000) gkh
113 * Added port_lock to port structure.
114 * Added locks for SMP safeness to generic driver
115 * Fixed the ability to open a generic device's port more than once.
116 *
117 * (07/23/2000) gkh
118 * Added bulk_out_endpointAddress to port structure.
119 *
120 * (07/19/2000) gkh, pberger, and borchers
121 * Modifications to allow usb-serial drivers to be modules.
122 *
123 * (07/03/2000) gkh
124 * Added more debugging to serial_ioctl call
125 *
126 * (06/25/2000) gkh
127 * Changed generic_write_bulk_callback to not call wake_up_interruptible
128 * directly, but to have port_softint do it at a safer time.
129 *
130 * (06/23/2000) gkh
131 * Cleaned up debugging statements in a quest to find UHCI timeout bug.
132 *
133 * (05/22/2000) gkh
134 * Changed the makefile, enabling the big CONFIG_USB_SERIAL_SOMTHING to be
135 * removed from the individual device source files.
136 *
137 * (05/03/2000) gkh
138 * Added the Digi Acceleport driver from Al Borchers and Peter Berger.
139 *
140 * (05/02/2000) gkh
141 * Changed devfs and tty register code to work properly now. This was based on
142 * the ACM driver changes by Vojtech Pavlik.
143 *
144 * (04/27/2000) Ryan VanderBijl
145 * Put calls to *_paranoia_checks into one function.
146 *
147 * (04/23/2000) gkh
148 * Fixed bug that Randy Dunlap found for Generic devices with no bulk out ports.
149 * Moved when the startup code printed out the devices that are supported.
150 *
151 * (04/19/2000) gkh
152 * Added driver for ZyXEL omni.net lcd plus ISDN TA
153 * Made startup info message specify which drivers were compiled in.
154 *
155 * (04/03/2000) gkh
156 * Changed the probe process to remove the module unload races.
157 * Changed where the tty layer gets initialized to have devfs work nicer.
158 * Added initial devfs support.
159 *
160 * (03/26/2000) gkh
161 * Split driver up into device specific pieces.
162 *
163 * (03/19/2000) gkh
164 * Fixed oops that could happen when device was removed while a program
165 * was talking to the device.
166 * Removed the static urbs and now all urbs are created and destroyed
167 * dynamically.
168 * Reworked the internal interface. Now everything is based on the
169 * usb_serial_port structure instead of the larger usb_serial structure.
170 * This fixes the bug that a multiport device could not have more than
171 * one port open at one time.
172 *
173 * (03/17/2000) gkh
174 * Added config option for debugging messages.
175 * Added patch for keyspan pda from Brian Warner.
176 *
177 * (03/06/2000) gkh
178 * Added the keyspan pda code from Brian Warner <warner@lothar.com>
179 * Moved a bunch of the port specific stuff into its own structure. This
180 * is in anticipation of the true multiport devices (there's a bug if you
181 * try to access more than one port of any multiport device right now)
182 *
183 * (02/21/2000) gkh
184 * Made it so that any serial devices only have to specify which functions
185 * they want to overload from the generic function calls (great,
186 * inheritance in C, in a driver, just what I wanted...)
187 * Added support for set_termios and ioctl function calls. No drivers take
188 * advantage of this yet.
189 * Removed the #ifdef MODULE, now there is no module specific code.
190 * Cleaned up a few comments in usb-serial.h that were wrong (thanks again
191 * to Miles Lott).
192 * Small fix to get_free_serial.
193 *
194 * (02/14/2000) gkh
195 * Removed the Belkin and Peracom functionality from the driver due to
196 * the lack of support from the vendor, and me not wanting people to
197 * accidenatly buy the device, expecting it to work with Linux.
198 * Added read_bulk_callback and write_bulk_callback to the type structure
199 * for the needs of the FTDI and WhiteHEAT driver.
200 * Changed all reverences to FTDI to FTDI_SIO at the request of Bill
201 * Ryder.
202 * Changed the output urb size back to the max endpoint size to make
203 * the ftdi_sio driver have it easier, and due to the fact that it didn't
204 * really increase the speed any.
205 *
206 * (02/11/2000) gkh
207 * Added VISOR_FUNCTION_CONSOLE to the visor startup function. This was a
208 * patch from Miles Lott (milos@insync.net).
209 * Fixed bug with not restoring the minor range that a device grabs, if
210 * the startup function fails (thanks Miles for finding this).
211 *
212 * (02/05/2000) gkh
213 * Added initial framework for the Keyspan PDA serial converter so that
214 * Brian Warner has a place to put his code.
215 * Made the ezusb specific functions generic enough that different
216 * devices can use them (whiteheat and keyspan_pda both need them).
217 * Split out a whole bunch of structure and other stuff to a separate
218 * usb-serial.h file.
219 * Made the Visor connection messages a little more understandable, now
220 * that Miles Lott (milos@insync.net) has gotten the Generic channel to
221 * work. Also made them always show up in the log file.
222 *
223 * (01/25/2000) gkh
224 * Added initial framework for FTDI serial converter so that Bill Ryder
225 * has a place to put his code.
226 * Added the vendor specific info from Handspring. Now we can print out
227 * informational debug messages as well as understand what is happening.
228 *
229 * (01/23/2000) gkh
230 * Fixed problem of crash when trying to open a port that didn't have a
231 * device assigned to it. Made the minor node finding a little smarter,
232 * now it looks to find a continuous space for the new device.
233 *
234 * (01/21/2000) gkh
235 * Fixed bug in visor_startup with patch from Miles Lott (milos@insync.net)
236 * Fixed get_serial_by_minor which was all messed up for multi port
237 * devices. Fixed multi port problem for generic devices. Now the number
238 * of ports is determined by the number of bulk out endpoints for the
239 * generic device.
240 *
241 * (01/19/2000) gkh
242 * Removed lots of cruft that was around from the old (pre urb) driver
243 * interface.
244 * Made the serial_table dynamic. This should save lots of memory when
245 * the number of minor nodes goes up to 256.
246 * Added initial support for devices that have more than one port.
247 * Added more debugging comments for the Visor, and added a needed
248 * set_configuration call.
249 *
250 * (01/17/2000) gkh
251 * Fixed the WhiteHEAT firmware (my processing tool had a bug)
252 * and added new debug loader firmware for it.
253 * Removed the put_char function as it isn't really needed.
254 * Added visor startup commands as found by the Win98 dump.
255 *
256 * (01/13/2000) gkh
257 * Fixed the vendor id for the generic driver to the one I meant it to be.
258 *
259 * (01/12/2000) gkh
260 * Forget the version numbering...that's pretty useless...
261 * Made the driver able to be compiled so that the user can select which
262 * converter they want to use. This allows people who only want the Visor
263 * support to not pay the memory size price of the WhiteHEAT.
264 * Fixed bug where the generic driver (idVendor=0000 and idProduct=0000)
265 * grabbed the root hub. Not good.
266 *
267 * version 0.4.0 (01/10/2000) gkh
268 * Added whiteheat.h containing the firmware for the ConnectTech WhiteHEAT
269 * device. Added startup function to allow firmware to be downloaded to
270 * a device if it needs to be.
271 * Added firmware download logic to the WhiteHEAT device.
272 * Started to add #defines to split up the different drivers for potential
273 * configuration option.
274 *
275 * version 0.3.1 (12/30/99) gkh
276 * Fixed problems with urb for bulk out.
277 * Added initial support for multiple sets of endpoints. This enables
278 * the Handspring Visor to be attached successfully. Only the first
279 * bulk in / bulk out endpoint pair is being used right now.
280 *
281 * version 0.3.0 (12/27/99) gkh
282 * Added initial support for the Handspring Visor based on a patch from
283 * Miles Lott (milos@sneety.insync.net)
284 * Cleaned up the code a bunch and converted over to using urbs only.
285 *
286 * version 0.2.3 (12/21/99) gkh
287 * Added initial support for the Connect Tech WhiteHEAT converter.
288 * Incremented the number of ports in expectation of getting the
289 * WhiteHEAT to work properly (4 ports per connection).
290 * Added notification on insertion and removal of what port the
291 * device is/was connected to (and what kind of device it was).
292 *
293 * version 0.2.2 (12/16/99) gkh
294 * Changed major number to the new allocated number. We're legal now!
295 *
296 * version 0.2.1 (12/14/99) gkh
297 * Fixed bug that happens when device node is opened when there isn't a
298 * device attached to it. Thanks to marek@webdesign.no for noticing this.
299 *
300 * version 0.2.0 (11/10/99) gkh
301 * Split up internals to make it easier to add different types of serial
302 * converters to the code.
303 * Added a "generic" driver that gets it's vendor and product id
304 * from when the module is loaded. Thanks to David E. Nelson (dnelson@jump.net)
305 * for the idea and sample code (from the usb scanner driver.)
306 * Cleared up any licensing questions by releasing it under the GNU GPL.
307 *
308 * version 0.1.2 (10/25/99) gkh
309 * Fixed bug in detecting device.
310 *
311 * version 0.1.1 (10/05/99) gkh
312 * Changed the major number to not conflict with anything else.
313 *
314 * version 0.1 (09/28/99) gkh
315 * Can recognize the two different devices and start up a read from
316 * device when asked to. Writes also work. No control signals yet, this
317 * all is vendor specific data (i.e. no spec), also no control for
318 * different baud rates or other bit settings.
319 * Currently we are using the same devid as the acm driver. This needs
320 * to change.
321 *
322 */
323
324#include <linux/config.h>
325#include <linux/kernel.h>
326#include <linux/errno.h>
327#include <linux/init.h>
328#include <linux/slab.h>
329#include <linux/tty.h>
330#include <linux/tty_driver.h>
331#include <linux/tty_flip.h>
332#include <linux/module.h>
333#include <linux/moduleparam.h>
334#include <linux/spinlock.h>
335#include <linux/list.h>
336#include <linux/smp_lock.h>
337#include <asm/uaccess.h>
338#include <linux/usb.h>
339#include "usb-serial.h"
340#include "pl2303.h"
341
342/*
343 * Version Information
344 */
345#define DRIVER_VERSION "v2.0"
346#define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
347#define DRIVER_DESC "USB Serial Driver core"
348
349/* Driver structure we register with the USB core */
350static struct usb_driver usb_serial_driver = {
351 .owner = THIS_MODULE,
352 .name = "usbserial",
353 .probe = usb_serial_probe,
354 .disconnect = usb_serial_disconnect,
355};
356
357/* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead
358 the MODULE_DEVICE_TABLE declarations in each serial driver
359 cause the "hotplug" program to pull in whatever module is necessary
360 via modprobe, and modprobe will load usbserial because the serial
361 drivers depend on it.
362*/
363
364static int debug;
365static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */
366static LIST_HEAD(usb_serial_driver_list);
367
368struct usb_serial *usb_serial_get_by_index(unsigned index)
369{
370 struct usb_serial *serial = serial_table[index];
371
372 if (serial)
373 kref_get(&serial->kref);
374 return serial;
375}
376
377static struct usb_serial *get_free_serial (struct usb_serial *serial, int num_ports, unsigned int *minor)
378{
379 unsigned int i, j;
380 int good_spot;
381
382 dbg("%s %d", __FUNCTION__, num_ports);
383
384 *minor = 0;
385 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
386 if (serial_table[i])
387 continue;
388
389 good_spot = 1;
390 for (j = 1; j <= num_ports-1; ++j)
391 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
392 good_spot = 0;
393 i += j;
394 break;
395 }
396 if (good_spot == 0)
397 continue;
398
399 *minor = i;
400 dbg("%s - minor base = %d", __FUNCTION__, *minor);
401 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
402 serial_table[i] = serial;
403 return serial;
404 }
405 return NULL;
406}
407
408static void return_serial(struct usb_serial *serial)
409{
410 int i;
411
412 dbg("%s", __FUNCTION__);
413
414 if (serial == NULL)
415 return;
416
417 for (i = 0; i < serial->num_ports; ++i) {
418 serial_table[serial->minor + i] = NULL;
419 }
420}
421
422static void destroy_serial(struct kref *kref)
423{
424 struct usb_serial *serial;
425 struct usb_serial_port *port;
426 int i;
427
428 serial = to_usb_serial(kref);
429
430 dbg ("%s - %s", __FUNCTION__, serial->type->name);
431
432 serial->type->shutdown(serial);
433
434 /* return the minor range that this device had */
435 return_serial(serial);
436
437 for (i = 0; i < serial->num_ports; ++i)
438 serial->port[i]->open_count = 0;
439
440 /* the ports are cleaned up and released in port_release() */
441 for (i = 0; i < serial->num_ports; ++i)
442 if (serial->port[i]->dev.parent != NULL) {
443 device_unregister(&serial->port[i]->dev);
444 serial->port[i] = NULL;
445 }
446
447 /* If this is a "fake" port, we have to clean it up here, as it will
448 * not get cleaned up in port_release() as it was never registered with
449 * the driver core */
450 if (serial->num_ports < serial->num_port_pointers) {
451 for (i = serial->num_ports; i < serial->num_port_pointers; ++i) {
452 port = serial->port[i];
453 if (!port)
454 continue;
455 usb_kill_urb(port->read_urb);
456 usb_free_urb(port->read_urb);
457 usb_kill_urb(port->write_urb);
458 usb_free_urb(port->write_urb);
459 usb_kill_urb(port->interrupt_in_urb);
460 usb_free_urb(port->interrupt_in_urb);
461 usb_kill_urb(port->interrupt_out_urb);
462 usb_free_urb(port->interrupt_out_urb);
463 kfree(port->bulk_in_buffer);
464 kfree(port->bulk_out_buffer);
465 kfree(port->interrupt_in_buffer);
466 kfree(port->interrupt_out_buffer);
467 }
468 }
469
470 usb_put_dev(serial->dev);
471
472 /* free up any memory that we allocated */
473 kfree (serial);
474}
475
476/*****************************************************************************
477 * Driver tty interface functions
478 *****************************************************************************/
479static int serial_open (struct tty_struct *tty, struct file * filp)
480{
481 struct usb_serial *serial;
482 struct usb_serial_port *port;
483 unsigned int portNumber;
484 int retval;
485
486 dbg("%s", __FUNCTION__);
487
488 /* get the serial object associated with this tty pointer */
489 serial = usb_serial_get_by_index(tty->index);
490 if (!serial) {
491 tty->driver_data = NULL;
492 return -ENODEV;
493 }
494
495 portNumber = tty->index - serial->minor;
496 port = serial->port[portNumber];
497
498 ++port->open_count;
499
500 if (port->open_count == 1) {
501
502 /* set up our port structure making the tty driver
503 * remember our port object, and us it */
504 tty->driver_data = port;
505 port->tty = tty;
506
507 /* lock this module before we call it
508 * this may fail, which means we must bail out,
509 * safe because we are called with BKL held */
510 if (!try_module_get(serial->type->owner)) {
511 retval = -ENODEV;
512 goto bailout_kref_put;
513 }
514
515 /* only call the device specific open if this
516 * is the first time the port is opened */
517 retval = serial->type->open(port, filp);
518 if (retval)
519 goto bailout_module_put;
520 }
521
522 return 0;
523
524bailout_module_put:
525 module_put(serial->type->owner);
526bailout_kref_put:
527 kref_put(&serial->kref, destroy_serial);
528 port->open_count = 0;
529 return retval;
530}
531
532static void serial_close(struct tty_struct *tty, struct file * filp)
533{
534 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
535
536 if (!port)
537 return;
538
539 dbg("%s - port %d", __FUNCTION__, port->number);
540
541 if (port->open_count == 0)
542 return;
543
544 --port->open_count;
545 if (port->open_count == 0) {
546 /* only call the device specific close if this
547 * port is being closed by the last owner */
548 port->serial->type->close(port, filp);
549
550 if (port->tty) {
551 if (port->tty->driver_data)
552 port->tty->driver_data = NULL;
553 port->tty = NULL;
554 }
555
556 module_put(port->serial->type->owner);
557 }
558
559 kref_put(&port->serial->kref, destroy_serial);
560}
561
562static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count)
563{
564 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
565 int retval = -EINVAL;
566
567 dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
568
569 if (!port->open_count) {
570 dbg("%s - port not opened", __FUNCTION__);
571 goto exit;
572 }
573
574 /* pass on to the driver specific version of this function */
575 retval = port->serial->type->write(port, buf, count);
576
577exit:
578 return retval;
579}
580
581static int serial_write_room (struct tty_struct *tty)
582{
583 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
584 int retval = -EINVAL;
585
586 dbg("%s - port %d", __FUNCTION__, port->number);
587
588 if (!port->open_count) {
589 dbg("%s - port not open", __FUNCTION__);
590 goto exit;
591 }
592
593 /* pass on to the driver specific version of this function */
594 retval = port->serial->type->write_room(port);
595
596exit:
597 return retval;
598}
599
600static int serial_chars_in_buffer (struct tty_struct *tty)
601{
602 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
603 int retval = -EINVAL;
604
605 dbg("%s = port %d", __FUNCTION__, port->number);
606
607 if (!port->open_count) {
608 dbg("%s - port not open", __FUNCTION__);
609 goto exit;
610 }
611
612 /* pass on to the driver specific version of this function */
613 retval = port->serial->type->chars_in_buffer(port);
614
615exit:
616 return retval;
617}
618
619static void serial_throttle (struct tty_struct * tty)
620{
621 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
622
623 dbg("%s - port %d", __FUNCTION__, port->number);
624
625 if (!port->open_count) {
626 dbg ("%s - port not open", __FUNCTION__);
627 return;
628 }
629
630 /* pass on to the driver specific version of this function */
631 if (port->serial->type->throttle)
632 port->serial->type->throttle(port);
633}
634
635static void serial_unthrottle (struct tty_struct * tty)
636{
637 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
638
639 dbg("%s - port %d", __FUNCTION__, port->number);
640
641 if (!port->open_count) {
642 dbg("%s - port not open", __FUNCTION__);
643 return;
644 }
645
646 /* pass on to the driver specific version of this function */
647 if (port->serial->type->unthrottle)
648 port->serial->type->unthrottle(port);
649}
650
651static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
652{
653 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
654 int retval = -ENODEV;
655
656 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
657
658 if (!port->open_count) {
659 dbg ("%s - port not open", __FUNCTION__);
660 goto exit;
661 }
662
663 /* pass on to the driver specific version of this function if it is available */
664 if (port->serial->type->ioctl)
665 retval = port->serial->type->ioctl(port, file, cmd, arg);
666 else
667 retval = -ENOIOCTLCMD;
668
669exit:
670 return retval;
671}
672
673static void serial_set_termios (struct tty_struct *tty, struct termios * old)
674{
675 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
676
677 dbg("%s - port %d", __FUNCTION__, port->number);
678
679 if (!port->open_count) {
680 dbg("%s - port not open", __FUNCTION__);
681 return;
682 }
683
684 /* pass on to the driver specific version of this function if it is available */
685 if (port->serial->type->set_termios)
686 port->serial->type->set_termios(port, old);
687}
688
689static void serial_break (struct tty_struct *tty, int break_state)
690{
691 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
692
693 dbg("%s - port %d", __FUNCTION__, port->number);
694
695 if (!port->open_count) {
696 dbg("%s - port not open", __FUNCTION__);
697 return;
698 }
699
700 /* pass on to the driver specific version of this function if it is available */
701 if (port->serial->type->break_ctl)
702 port->serial->type->break_ctl(port, break_state);
703}
704
705static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
706{
707 struct usb_serial *serial;
708 int length = 0;
709 int i;
710 off_t begin = 0;
711 char tmp[40];
712
713 dbg("%s", __FUNCTION__);
714 length += sprintf (page, "usbserinfo:1.0 driver:%s\n", DRIVER_VERSION);
715 for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
716 serial = usb_serial_get_by_index(i);
717 if (serial == NULL)
718 continue;
719
720 length += sprintf (page+length, "%d:", i);
721 if (serial->type->owner)
722 length += sprintf (page+length, " module:%s", module_name(serial->type->owner));
723 length += sprintf (page+length, " name:\"%s\"", serial->type->name);
724 length += sprintf (page+length, " vendor:%04x product:%04x",
725 le16_to_cpu(serial->dev->descriptor.idVendor),
726 le16_to_cpu(serial->dev->descriptor.idProduct));
727 length += sprintf (page+length, " num_ports:%d", serial->num_ports);
728 length += sprintf (page+length, " port:%d", i - serial->minor + 1);
729
730 usb_make_path(serial->dev, tmp, sizeof(tmp));
731 length += sprintf (page+length, " path:%s", tmp);
732
733 length += sprintf (page+length, "\n");
734 if ((length + begin) > (off + count))
735 goto done;
736 if ((length + begin) < off) {
737 begin += length;
738 length = 0;
739 }
740 kref_put(&serial->kref, destroy_serial);
741 }
742 *eof = 1;
743done:
744 if (off >= (length + begin))
745 return 0;
746 *start = page + (off-begin);
747 return ((count < begin+length-off) ? count : begin+length-off);
748}
749
750static int serial_tiocmget (struct tty_struct *tty, struct file *file)
751{
752 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
753
754 dbg("%s - port %d", __FUNCTION__, port->number);
755
756 if (!port->open_count) {
757 dbg("%s - port not open", __FUNCTION__);
758 goto exit;
759 }
760
761 if (port->serial->type->tiocmget)
762 return port->serial->type->tiocmget(port, file);
763
764exit:
765 return -EINVAL;
766}
767
768static int serial_tiocmset (struct tty_struct *tty, struct file *file,
769 unsigned int set, unsigned int clear)
770{
771 struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
772
773 dbg("%s - port %d", __FUNCTION__, port->number);
774
775 if (!port->open_count) {
776 dbg("%s - port not open", __FUNCTION__);
777 goto exit;
778 }
779
780 if (port->serial->type->tiocmset)
781 return port->serial->type->tiocmset(port, file, set, clear);
782
783exit:
784 return -EINVAL;
785}
786
787void usb_serial_port_softint(void *private)
788{
789 struct usb_serial_port *port = (struct usb_serial_port *)private;
790 struct tty_struct *tty;
791
792 dbg("%s - port %d", __FUNCTION__, port->number);
793
794 if (!port)
795 return;
796
797 tty = port->tty;
798 if (!tty)
799 return;
800
801 tty_wakeup(tty);
802}
803
804static void port_release(struct device *dev)
805{
806 struct usb_serial_port *port = to_usb_serial_port(dev);
807
808 dbg ("%s - %s", __FUNCTION__, dev->bus_id);
809 usb_kill_urb(port->read_urb);
810 usb_free_urb(port->read_urb);
811 usb_kill_urb(port->write_urb);
812 usb_free_urb(port->write_urb);
813 usb_kill_urb(port->interrupt_in_urb);
814 usb_free_urb(port->interrupt_in_urb);
815 usb_kill_urb(port->interrupt_out_urb);
816 usb_free_urb(port->interrupt_out_urb);
817 kfree(port->bulk_in_buffer);
818 kfree(port->bulk_out_buffer);
819 kfree(port->interrupt_in_buffer);
820 kfree(port->interrupt_out_buffer);
821 kfree(port);
822}
823
824static struct usb_serial * create_serial (struct usb_device *dev,
825 struct usb_interface *interface,
826 struct usb_serial_device_type *type)
827{
828 struct usb_serial *serial;
829
830 serial = kmalloc (sizeof (*serial), GFP_KERNEL);
831 if (!serial) {
832 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
833 return NULL;
834 }
835 memset (serial, 0, sizeof(*serial));
836 serial->dev = usb_get_dev(dev);
837 serial->type = type;
838 serial->interface = interface;
839 kref_init(&serial->kref);
840
841 return serial;
842}
843
844static struct usb_serial_device_type *search_serial_device(struct usb_interface *iface)
845{
846 struct list_head *p;
847 const struct usb_device_id *id;
848 struct usb_serial_device_type *t;
849
850 /* List trough know devices and see if the usb id matches */
851 list_for_each(p, &usb_serial_driver_list) {
852 t = list_entry(p, struct usb_serial_device_type, driver_list);
853 id = usb_match_id(iface, t->id_table);
854 if (id != NULL) {
855 dbg("descriptor matches");
856 return t;
857 }
858 }
859
860 return NULL;
861}
862
863int usb_serial_probe(struct usb_interface *interface,
864 const struct usb_device_id *id)
865{
866 struct usb_device *dev = interface_to_usbdev (interface);
867 struct usb_serial *serial = NULL;
868 struct usb_serial_port *port;
869 struct usb_host_interface *iface_desc;
870 struct usb_endpoint_descriptor *endpoint;
871 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
872 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
873 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
874 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
875 struct usb_serial_device_type *type = NULL;
876 int retval;
877 int minor;
878 int buffer_size;
879 int i;
880 int num_interrupt_in = 0;
881 int num_interrupt_out = 0;
882 int num_bulk_in = 0;
883 int num_bulk_out = 0;
884 int num_ports = 0;
885 int max_endpoints;
886
887 type = search_serial_device(interface);
888 if (!type) {
889 dbg("none matched");
890 return -ENODEV;
891 }
892
893 serial = create_serial (dev, interface, type);
894 if (!serial) {
895 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__);
896 return -ENOMEM;
897 }
898
899 /* if this device type has a probe function, call it */
900 if (type->probe) {
901 const struct usb_device_id *id;
902
903 if (!try_module_get(type->owner)) {
904 dev_err(&interface->dev, "module get failed, exiting\n");
905 kfree (serial);
906 return -EIO;
907 }
908
909 id = usb_match_id(interface, type->id_table);
910 retval = type->probe(serial, id);
911 module_put(type->owner);
912
913 if (retval) {
914 dbg ("sub driver rejected device");
915 kfree (serial);
916 return retval;
917 }
918 }
919
920 /* descriptor matches, let's find the endpoints needed */
921 /* check out the endpoints */
922 iface_desc = interface->cur_altsetting;
923 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
924 endpoint = &iface_desc->endpoint[i].desc;
925
926 if ((endpoint->bEndpointAddress & 0x80) &&
927 ((endpoint->bmAttributes & 3) == 0x02)) {
928 /* we found a bulk in endpoint */
929 dbg("found bulk in on endpoint %d", i);
930 bulk_in_endpoint[num_bulk_in] = endpoint;
931 ++num_bulk_in;
932 }
933
934 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
935 ((endpoint->bmAttributes & 3) == 0x02)) {
936 /* we found a bulk out endpoint */
937 dbg("found bulk out on endpoint %d", i);
938 bulk_out_endpoint[num_bulk_out] = endpoint;
939 ++num_bulk_out;
940 }
941
942 if ((endpoint->bEndpointAddress & 0x80) &&
943 ((endpoint->bmAttributes & 3) == 0x03)) {
944 /* we found a interrupt in endpoint */
945 dbg("found interrupt in on endpoint %d", i);
946 interrupt_in_endpoint[num_interrupt_in] = endpoint;
947 ++num_interrupt_in;
948 }
949
950 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
951 ((endpoint->bmAttributes & 3) == 0x03)) {
952 /* we found an interrupt out endpoint */
953 dbg("found interrupt out on endpoint %d", i);
954 interrupt_out_endpoint[num_interrupt_out] = endpoint;
955 ++num_interrupt_out;
956 }
957 }
958
959#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
960 /* BEGIN HORRIBLE HACK FOR PL2303 */
961 /* this is needed due to the looney way its endpoints are set up */
962 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
963 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
964 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
965 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID))) {
966 if (interface != dev->actconfig->interface[0]) {
967 /* check out the endpoints of the other interface*/
968 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
969 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
970 endpoint = &iface_desc->endpoint[i].desc;
971 if ((endpoint->bEndpointAddress & 0x80) &&
972 ((endpoint->bmAttributes & 3) == 0x03)) {
973 /* we found a interrupt in endpoint */
974 dbg("found interrupt in for Prolific device on separate interface");
975 interrupt_in_endpoint[num_interrupt_in] = endpoint;
976 ++num_interrupt_in;
977 }
978 }
979 }
980
981 /* Now make sure the PL-2303 is configured correctly.
982 * If not, give up now and hope this hack will work
983 * properly during a later invocation of usb_serial_probe
984 */
985 if (num_bulk_in == 0 || num_bulk_out == 0) {
986 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
987 kfree (serial);
988 return -ENODEV;
989 }
990 }
991 /* END HORRIBLE HACK FOR PL2303 */
992#endif
993
994 /* found all that we need */
995 dev_info(&interface->dev, "%s converter detected\n", type->name);
996
997#ifdef CONFIG_USB_SERIAL_GENERIC
998 if (type == &usb_serial_generic_device) {
999 num_ports = num_bulk_out;
1000 if (num_ports == 0) {
1001 dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n");
1002 kfree (serial);
1003 return -EIO;
1004 }
1005 }
1006#endif
1007 if (!num_ports) {
1008 /* if this device type has a calc_num_ports function, call it */
1009 if (type->calc_num_ports) {
1010 if (!try_module_get(type->owner)) {
1011 dev_err(&interface->dev, "module get failed, exiting\n");
1012 kfree (serial);
1013 return -EIO;
1014 }
1015 num_ports = type->calc_num_ports (serial);
1016 module_put(type->owner);
1017 }
1018 if (!num_ports)
1019 num_ports = type->num_ports;
1020 }
1021
1022 if (get_free_serial (serial, num_ports, &minor) == NULL) {
1023 dev_err(&interface->dev, "No more free serial devices\n");
1024 kfree (serial);
1025 return -ENOMEM;
1026 }
1027
1028 serial->minor = minor;
1029 serial->num_ports = num_ports;
1030 serial->num_bulk_in = num_bulk_in;
1031 serial->num_bulk_out = num_bulk_out;
1032 serial->num_interrupt_in = num_interrupt_in;
1033 serial->num_interrupt_out = num_interrupt_out;
1034
1035 /* create our ports, we need as many as the max endpoints */
1036 /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
1037 max_endpoints = max(num_bulk_in, num_bulk_out);
1038 max_endpoints = max(max_endpoints, num_interrupt_in);
1039 max_endpoints = max(max_endpoints, num_interrupt_out);
1040 max_endpoints = max(max_endpoints, (int)serial->num_ports);
1041 serial->num_port_pointers = max_endpoints;
1042 dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
1043 for (i = 0; i < max_endpoints; ++i) {
1044 port = kmalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
1045 if (!port)
1046 goto probe_error;
1047 memset(port, 0x00, sizeof(struct usb_serial_port));
1048 port->number = i + serial->minor;
1049 port->serial = serial;
1050 INIT_WORK(&port->work, usb_serial_port_softint, port);
1051 serial->port[i] = port;
1052 }
1053
1054 /* set up the endpoint information */
1055 for (i = 0; i < num_bulk_in; ++i) {
1056 endpoint = bulk_in_endpoint[i];
1057 port = serial->port[i];
1058 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
1059 if (!port->read_urb) {
1060 dev_err(&interface->dev, "No free urbs available\n");
1061 goto probe_error;
1062 }
1063 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1064 port->bulk_in_size = buffer_size;
1065 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
1066 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
1067 if (!port->bulk_in_buffer) {
1068 dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
1069 goto probe_error;
1070 }
1071 usb_fill_bulk_urb (port->read_urb, dev,
1072 usb_rcvbulkpipe (dev,
1073 endpoint->bEndpointAddress),
1074 port->bulk_in_buffer, buffer_size,
1075 serial->type->read_bulk_callback,
1076 port);
1077 }
1078
1079 for (i = 0; i < num_bulk_out; ++i) {
1080 endpoint = bulk_out_endpoint[i];
1081 port = serial->port[i];
1082 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
1083 if (!port->write_urb) {
1084 dev_err(&interface->dev, "No free urbs available\n");
1085 goto probe_error;
1086 }
1087 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1088 port->bulk_out_size = buffer_size;
1089 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
1090 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
1091 if (!port->bulk_out_buffer) {
1092 dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n");
1093 goto probe_error;
1094 }
1095 usb_fill_bulk_urb (port->write_urb, dev,
1096 usb_sndbulkpipe (dev,
1097 endpoint->bEndpointAddress),
1098 port->bulk_out_buffer, buffer_size,
1099 serial->type->write_bulk_callback,
1100 port);
1101 }
1102
1103 if (serial->type->read_int_callback) {
1104 for (i = 0; i < num_interrupt_in; ++i) {
1105 endpoint = interrupt_in_endpoint[i];
1106 port = serial->port[i];
1107 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
1108 if (!port->interrupt_in_urb) {
1109 dev_err(&interface->dev, "No free urbs available\n");
1110 goto probe_error;
1111 }
1112 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1113 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
1114 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
1115 if (!port->interrupt_in_buffer) {
1116 dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
1117 goto probe_error;
1118 }
1119 usb_fill_int_urb (port->interrupt_in_urb, dev,
1120 usb_rcvintpipe (dev,
1121 endpoint->bEndpointAddress),
1122 port->interrupt_in_buffer, buffer_size,
1123 serial->type->read_int_callback, port,
1124 endpoint->bInterval);
1125 }
1126 } else if (num_interrupt_in) {
1127 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1128 }
1129
1130 if (serial->type->write_int_callback) {
1131 for (i = 0; i < num_interrupt_out; ++i) {
1132 endpoint = interrupt_out_endpoint[i];
1133 port = serial->port[i];
1134 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1135 if (!port->interrupt_out_urb) {
1136 dev_err(&interface->dev, "No free urbs available\n");
1137 goto probe_error;
1138 }
1139 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1140 port->interrupt_out_size = buffer_size;
1141 port->interrupt_out_endpointAddress = endpoint->bEndpointAddress;
1142 port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
1143 if (!port->interrupt_out_buffer) {
1144 dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n");
1145 goto probe_error;
1146 }
1147 usb_fill_int_urb (port->interrupt_out_urb, dev,
1148 usb_sndintpipe (dev,
1149 endpoint->bEndpointAddress),
1150 port->interrupt_out_buffer, buffer_size,
1151 serial->type->write_int_callback, port,
1152 endpoint->bInterval);
1153 }
1154 } else if (num_interrupt_out) {
1155 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1156 }
1157
1158 /* if this device type has an attach function, call it */
1159 if (type->attach) {
1160 if (!try_module_get(type->owner)) {
1161 dev_err(&interface->dev, "module get failed, exiting\n");
1162 goto probe_error;
1163 }
1164 retval = type->attach (serial);
1165 module_put(type->owner);
1166 if (retval < 0)
1167 goto probe_error;
1168 if (retval > 0) {
1169 /* quietly accept this device, but don't bind to a serial port
1170 * as it's about to disappear */
1171 goto exit;
1172 }
1173 }
1174
1175 /* register all of the individual ports with the driver core */
1176 for (i = 0; i < num_ports; ++i) {
1177 port = serial->port[i];
1178 port->dev.parent = &interface->dev;
1179 port->dev.driver = NULL;
1180 port->dev.bus = &usb_serial_bus_type;
1181 port->dev.release = &port_release;
1182
1183 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
1184 dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
1185 device_register (&port->dev);
1186 }
1187
1188 usb_serial_console_init (debug, minor);
1189
1190exit:
1191 /* success */
1192 usb_set_intfdata (interface, serial);
1193 return 0;
1194
1195probe_error:
1196 for (i = 0; i < num_bulk_in; ++i) {
1197 port = serial->port[i];
1198 if (!port)
1199 continue;
1200 if (port->read_urb)
1201 usb_free_urb (port->read_urb);
1202 kfree(port->bulk_in_buffer);
1203 }
1204 for (i = 0; i < num_bulk_out; ++i) {
1205 port = serial->port[i];
1206 if (!port)
1207 continue;
1208 if (port->write_urb)
1209 usb_free_urb (port->write_urb);
1210 kfree(port->bulk_out_buffer);
1211 }
1212 for (i = 0; i < num_interrupt_in; ++i) {
1213 port = serial->port[i];
1214 if (!port)
1215 continue;
1216 if (port->interrupt_in_urb)
1217 usb_free_urb (port->interrupt_in_urb);
1218 kfree(port->interrupt_in_buffer);
1219 }
1220 for (i = 0; i < num_interrupt_out; ++i) {
1221 port = serial->port[i];
1222 if (!port)
1223 continue;
1224 if (port->interrupt_out_urb)
1225 usb_free_urb (port->interrupt_out_urb);
1226 kfree(port->interrupt_out_buffer);
1227 }
1228
1229 /* return the minor range that this device had */
1230 return_serial (serial);
1231
1232 /* free up any memory that we allocated */
1233 for (i = 0; i < serial->num_port_pointers; ++i)
1234 kfree(serial->port[i]);
1235 kfree (serial);
1236 return -EIO;
1237}
1238
1239void usb_serial_disconnect(struct usb_interface *interface)
1240{
1241 int i;
1242 struct usb_serial *serial = usb_get_intfdata (interface);
1243 struct device *dev = &interface->dev;
1244 struct usb_serial_port *port;
1245
1246 dbg ("%s", __FUNCTION__);
1247
1248 usb_set_intfdata (interface, NULL);
1249 if (serial) {
1250 for (i = 0; i < serial->num_ports; ++i) {
1251 port = serial->port[i];
1252 if (port && port->tty)
1253 tty_hangup(port->tty);
1254 }
1255 /* let the last holder of this object
1256 * cause it to be cleaned up */
1257 kref_put(&serial->kref, destroy_serial);
1258 }
1259 dev_info(dev, "device disconnected\n");
1260}
1261
1262static struct tty_operations serial_ops = {
1263 .open = serial_open,
1264 .close = serial_close,
1265 .write = serial_write,
1266 .write_room = serial_write_room,
1267 .ioctl = serial_ioctl,
1268 .set_termios = serial_set_termios,
1269 .throttle = serial_throttle,
1270 .unthrottle = serial_unthrottle,
1271 .break_ctl = serial_break,
1272 .chars_in_buffer = serial_chars_in_buffer,
1273 .read_proc = serial_read_proc,
1274 .tiocmget = serial_tiocmget,
1275 .tiocmset = serial_tiocmset,
1276};
1277
1278struct tty_driver *usb_serial_tty_driver;
1279
1280static int __init usb_serial_init(void)
1281{
1282 int i;
1283 int result;
1284
1285 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1286 if (!usb_serial_tty_driver)
1287 return -ENOMEM;
1288
1289 /* Initialize our global data */
1290 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1291 serial_table[i] = NULL;
1292 }
1293
1294 result = bus_register(&usb_serial_bus_type);
1295 if (result) {
1296 err("%s - registering bus driver failed", __FUNCTION__);
1297 goto exit_bus;
1298 }
1299
1300 /* register the generic driver, if we should */
1301 result = usb_serial_generic_register(debug);
1302 if (result < 0) {
1303 err("%s - registering generic driver failed", __FUNCTION__);
1304 goto exit_generic;
1305 }
1306
1307 usb_serial_tty_driver->owner = THIS_MODULE;
1308 usb_serial_tty_driver->driver_name = "usbserial";
1309 usb_serial_tty_driver->devfs_name = "usb/tts/";
1310 usb_serial_tty_driver->name = "ttyUSB";
1311 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1312 usb_serial_tty_driver->minor_start = 0;
1313 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1314 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1315 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
1316 usb_serial_tty_driver->init_termios = tty_std_termios;
1317 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1318 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1319 result = tty_register_driver(usb_serial_tty_driver);
1320 if (result) {
1321 err("%s - tty_register_driver failed", __FUNCTION__);
1322 goto exit_reg_driver;
1323 }
1324
1325 /* register the USB driver */
1326 result = usb_register(&usb_serial_driver);
1327 if (result < 0) {
1328 err("%s - usb_register failed", __FUNCTION__);
1329 goto exit_tty;
1330 }
1331
1332 info(DRIVER_DESC " " DRIVER_VERSION);
1333
1334 return result;
1335
1336exit_tty:
1337 tty_unregister_driver(usb_serial_tty_driver);
1338
1339exit_reg_driver:
1340 usb_serial_generic_deregister();
1341
1342exit_generic:
1343 bus_unregister(&usb_serial_bus_type);
1344
1345exit_bus:
1346 err ("%s - returning with error %d", __FUNCTION__, result);
1347 put_tty_driver(usb_serial_tty_driver);
1348 return result;
1349}
1350
1351
1352static void __exit usb_serial_exit(void)
1353{
1354 usb_serial_console_exit();
1355
1356 usb_serial_generic_deregister();
1357
1358 usb_deregister(&usb_serial_driver);
1359 tty_unregister_driver(usb_serial_tty_driver);
1360 put_tty_driver(usb_serial_tty_driver);
1361 bus_unregister(&usb_serial_bus_type);
1362}
1363
1364
1365module_init(usb_serial_init);
1366module_exit(usb_serial_exit);
1367
1368#define set_to_generic_if_null(type, function) \
1369 do { \
1370 if (!type->function) { \
1371 type->function = usb_serial_generic_##function; \
1372 dbg("Had to override the " #function \
1373 " usb serial operation with the generic one.");\
1374 } \
1375 } while (0)
1376
1377static void fixup_generic(struct usb_serial_device_type *device)
1378{
1379 set_to_generic_if_null(device, open);
1380 set_to_generic_if_null(device, write);
1381 set_to_generic_if_null(device, close);
1382 set_to_generic_if_null(device, write_room);
1383 set_to_generic_if_null(device, chars_in_buffer);
1384 set_to_generic_if_null(device, read_bulk_callback);
1385 set_to_generic_if_null(device, write_bulk_callback);
1386 set_to_generic_if_null(device, shutdown);
1387}
1388
1389int usb_serial_register(struct usb_serial_device_type *new_device)
1390{
1391 int retval;
1392
1393 fixup_generic(new_device);
1394
1395 /* Add this device to our list of devices */
1396 list_add(&new_device->driver_list, &usb_serial_driver_list);
1397
1398 retval = usb_serial_bus_register(new_device);
1399 if (retval) {
1400 err("problem %d when registering driver %s", retval, new_device->name);
1401 list_del(&new_device->driver_list);
1402 }
1403 else
1404 info("USB Serial support registered for %s", new_device->name);
1405
1406 return retval;
1407}
1408
1409
1410void usb_serial_deregister(struct usb_serial_device_type *device)
1411{
1412 info("USB Serial deregistering driver %s", device->name);
1413 list_del(&device->driver_list);
1414 usb_serial_bus_deregister(device);
1415}
1416
1417
1418
1419/* If the usb-serial core is built into the core, the usb-serial drivers
1420 need these symbols to load properly as modules. */
1421EXPORT_SYMBOL_GPL(usb_serial_register);
1422EXPORT_SYMBOL_GPL(usb_serial_deregister);
1423EXPORT_SYMBOL_GPL(usb_serial_probe);
1424EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1425EXPORT_SYMBOL_GPL(usb_serial_port_softint);
1426
1427
1428/* Module information */
1429MODULE_AUTHOR( DRIVER_AUTHOR );
1430MODULE_DESCRIPTION( DRIVER_DESC );
1431MODULE_VERSION( DRIVER_VERSION );
1432MODULE_LICENSE("GPL");
1433
1434module_param(debug, bool, S_IRUGO | S_IWUSR);
1435MODULE_PARM_DESC(debug, "Debug enabled or not");
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-08 10:58:10 -0500