Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 */ | |
350 | static 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 | ||
364 | static int debug; | |
365 | static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */ | |
366 | static LIST_HEAD(usb_serial_driver_list); | |
367 | ||
368 | struct 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 | ||
377 | static 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 | ||
408 | static 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 | ||
422 | static 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 | *****************************************************************************/ | |
479 | static 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 | ||
524 | bailout_module_put: | |
525 | module_put(serial->type->owner); | |
526 | bailout_kref_put: | |
527 | kref_put(&serial->kref, destroy_serial); | |
528 | port->open_count = 0; | |
529 | return retval; | |
530 | } | |
531 | ||
532 | static 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 | ||
562 | static 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 | ||
577 | exit: | |
578 | return retval; | |
579 | } | |
580 | ||
581 | static 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 | ||
596 | exit: | |
597 | return retval; | |
598 | } | |
599 | ||
600 | static 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 | ||
615 | exit: | |
616 | return retval; | |
617 | } | |
618 | ||
619 | static 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 | ||
635 | static 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 | ||
651 | static 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 | ||
669 | exit: | |
670 | return retval; | |
671 | } | |
672 | ||
673 | static 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 | ||
689 | static 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 | ||
705 | static 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; | |
743 | done: | |
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 | ||
750 | static 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 | ||
764 | exit: | |
765 | return -EINVAL; | |
766 | } | |
767 | ||
768 | static 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 | ||
783 | exit: | |
784 | return -EINVAL; | |
785 | } | |
786 | ||
787 | void 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 | ||
804 | static 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 | ||
824 | static 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 | ||
844 | static 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 | ||
863 | int 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; | |
507ca9bc | 1050 | spin_lock_init(&port->lock); |
1da177e4 LT |
1051 | INIT_WORK(&port->work, usb_serial_port_softint, port); |
1052 | serial->port[i] = port; | |
1053 | } | |
1054 | ||
1055 | /* set up the endpoint information */ | |
1056 | for (i = 0; i < num_bulk_in; ++i) { | |
1057 | endpoint = bulk_in_endpoint[i]; | |
1058 | port = serial->port[i]; | |
1059 | port->read_urb = usb_alloc_urb (0, GFP_KERNEL); | |
1060 | if (!port->read_urb) { | |
1061 | dev_err(&interface->dev, "No free urbs available\n"); | |
1062 | goto probe_error; | |
1063 | } | |
1064 | buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); | |
1065 | port->bulk_in_size = buffer_size; | |
1066 | port->bulk_in_endpointAddress = endpoint->bEndpointAddress; | |
1067 | port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL); | |
1068 | if (!port->bulk_in_buffer) { | |
1069 | dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n"); | |
1070 | goto probe_error; | |
1071 | } | |
1072 | usb_fill_bulk_urb (port->read_urb, dev, | |
1073 | usb_rcvbulkpipe (dev, | |
1074 | endpoint->bEndpointAddress), | |
1075 | port->bulk_in_buffer, buffer_size, | |
1076 | serial->type->read_bulk_callback, | |
1077 | port); | |
1078 | } | |
1079 | ||
1080 | for (i = 0; i < num_bulk_out; ++i) { | |
1081 | endpoint = bulk_out_endpoint[i]; | |
1082 | port = serial->port[i]; | |
1083 | port->write_urb = usb_alloc_urb(0, GFP_KERNEL); | |
1084 | if (!port->write_urb) { | |
1085 | dev_err(&interface->dev, "No free urbs available\n"); | |
1086 | goto probe_error; | |
1087 | } | |
1088 | buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); | |
1089 | port->bulk_out_size = buffer_size; | |
1090 | port->bulk_out_endpointAddress = endpoint->bEndpointAddress; | |
1091 | port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL); | |
1092 | if (!port->bulk_out_buffer) { | |
1093 | dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n"); | |
1094 | goto probe_error; | |
1095 | } | |
1096 | usb_fill_bulk_urb (port->write_urb, dev, | |
1097 | usb_sndbulkpipe (dev, | |
1098 | endpoint->bEndpointAddress), | |
1099 | port->bulk_out_buffer, buffer_size, | |
1100 | serial->type->write_bulk_callback, | |
1101 | port); | |
1102 | } | |
1103 | ||
1104 | if (serial->type->read_int_callback) { | |
1105 | for (i = 0; i < num_interrupt_in; ++i) { | |
1106 | endpoint = interrupt_in_endpoint[i]; | |
1107 | port = serial->port[i]; | |
1108 | port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL); | |
1109 | if (!port->interrupt_in_urb) { | |
1110 | dev_err(&interface->dev, "No free urbs available\n"); | |
1111 | goto probe_error; | |
1112 | } | |
1113 | buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); | |
1114 | port->interrupt_in_endpointAddress = endpoint->bEndpointAddress; | |
1115 | port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL); | |
1116 | if (!port->interrupt_in_buffer) { | |
1117 | dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n"); | |
1118 | goto probe_error; | |
1119 | } | |
1120 | usb_fill_int_urb (port->interrupt_in_urb, dev, | |
1121 | usb_rcvintpipe (dev, | |
1122 | endpoint->bEndpointAddress), | |
1123 | port->interrupt_in_buffer, buffer_size, | |
1124 | serial->type->read_int_callback, port, | |
1125 | endpoint->bInterval); | |
1126 | } | |
1127 | } else if (num_interrupt_in) { | |
1128 | dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined"); | |
1129 | } | |
1130 | ||
1131 | if (serial->type->write_int_callback) { | |
1132 | for (i = 0; i < num_interrupt_out; ++i) { | |
1133 | endpoint = interrupt_out_endpoint[i]; | |
1134 | port = serial->port[i]; | |
1135 | port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL); | |
1136 | if (!port->interrupt_out_urb) { | |
1137 | dev_err(&interface->dev, "No free urbs available\n"); | |
1138 | goto probe_error; | |
1139 | } | |
1140 | buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); | |
1141 | port->interrupt_out_size = buffer_size; | |
1142 | port->interrupt_out_endpointAddress = endpoint->bEndpointAddress; | |
1143 | port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL); | |
1144 | if (!port->interrupt_out_buffer) { | |
1145 | dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n"); | |
1146 | goto probe_error; | |
1147 | } | |
1148 | usb_fill_int_urb (port->interrupt_out_urb, dev, | |
1149 | usb_sndintpipe (dev, | |
1150 | endpoint->bEndpointAddress), | |
1151 | port->interrupt_out_buffer, buffer_size, | |
1152 | serial->type->write_int_callback, port, | |
1153 | endpoint->bInterval); | |
1154 | } | |
1155 | } else if (num_interrupt_out) { | |
1156 | dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined"); | |
1157 | } | |
1158 | ||
1159 | /* if this device type has an attach function, call it */ | |
1160 | if (type->attach) { | |
1161 | if (!try_module_get(type->owner)) { | |
1162 | dev_err(&interface->dev, "module get failed, exiting\n"); | |
1163 | goto probe_error; | |
1164 | } | |
1165 | retval = type->attach (serial); | |
1166 | module_put(type->owner); | |
1167 | if (retval < 0) | |
1168 | goto probe_error; | |
1169 | if (retval > 0) { | |
1170 | /* quietly accept this device, but don't bind to a serial port | |
1171 | * as it's about to disappear */ | |
1172 | goto exit; | |
1173 | } | |
1174 | } | |
1175 | ||
1176 | /* register all of the individual ports with the driver core */ | |
1177 | for (i = 0; i < num_ports; ++i) { | |
1178 | port = serial->port[i]; | |
1179 | port->dev.parent = &interface->dev; | |
1180 | port->dev.driver = NULL; | |
1181 | port->dev.bus = &usb_serial_bus_type; | |
1182 | port->dev.release = &port_release; | |
1183 | ||
1184 | snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number); | |
1185 | dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id); | |
1186 | device_register (&port->dev); | |
1187 | } | |
1188 | ||
1189 | usb_serial_console_init (debug, minor); | |
1190 | ||
1191 | exit: | |
1192 | /* success */ | |
1193 | usb_set_intfdata (interface, serial); | |
1194 | return 0; | |
1195 | ||
1196 | probe_error: | |
1197 | for (i = 0; i < num_bulk_in; ++i) { | |
1198 | port = serial->port[i]; | |
1199 | if (!port) | |
1200 | continue; | |
1201 | if (port->read_urb) | |
1202 | usb_free_urb (port->read_urb); | |
1203 | kfree(port->bulk_in_buffer); | |
1204 | } | |
1205 | for (i = 0; i < num_bulk_out; ++i) { | |
1206 | port = serial->port[i]; | |
1207 | if (!port) | |
1208 | continue; | |
1209 | if (port->write_urb) | |
1210 | usb_free_urb (port->write_urb); | |
1211 | kfree(port->bulk_out_buffer); | |
1212 | } | |
1213 | for (i = 0; i < num_interrupt_in; ++i) { | |
1214 | port = serial->port[i]; | |
1215 | if (!port) | |
1216 | continue; | |
1217 | if (port->interrupt_in_urb) | |
1218 | usb_free_urb (port->interrupt_in_urb); | |
1219 | kfree(port->interrupt_in_buffer); | |
1220 | } | |
1221 | for (i = 0; i < num_interrupt_out; ++i) { | |
1222 | port = serial->port[i]; | |
1223 | if (!port) | |
1224 | continue; | |
1225 | if (port->interrupt_out_urb) | |
1226 | usb_free_urb (port->interrupt_out_urb); | |
1227 | kfree(port->interrupt_out_buffer); | |
1228 | } | |
1229 | ||
1230 | /* return the minor range that this device had */ | |
1231 | return_serial (serial); | |
1232 | ||
1233 | /* free up any memory that we allocated */ | |
1234 | for (i = 0; i < serial->num_port_pointers; ++i) | |
1235 | kfree(serial->port[i]); | |
1236 | kfree (serial); | |
1237 | return -EIO; | |
1238 | } | |
1239 | ||
1240 | void usb_serial_disconnect(struct usb_interface *interface) | |
1241 | { | |
1242 | int i; | |
1243 | struct usb_serial *serial = usb_get_intfdata (interface); | |
1244 | struct device *dev = &interface->dev; | |
1245 | struct usb_serial_port *port; | |
1246 | ||
1247 | dbg ("%s", __FUNCTION__); | |
1248 | ||
1249 | usb_set_intfdata (interface, NULL); | |
1250 | if (serial) { | |
1251 | for (i = 0; i < serial->num_ports; ++i) { | |
1252 | port = serial->port[i]; | |
1253 | if (port && port->tty) | |
1254 | tty_hangup(port->tty); | |
1255 | } | |
1256 | /* let the last holder of this object | |
1257 | * cause it to be cleaned up */ | |
1258 | kref_put(&serial->kref, destroy_serial); | |
1259 | } | |
1260 | dev_info(dev, "device disconnected\n"); | |
1261 | } | |
1262 | ||
1263 | static struct tty_operations serial_ops = { | |
1264 | .open = serial_open, | |
1265 | .close = serial_close, | |
1266 | .write = serial_write, | |
1267 | .write_room = serial_write_room, | |
1268 | .ioctl = serial_ioctl, | |
1269 | .set_termios = serial_set_termios, | |
1270 | .throttle = serial_throttle, | |
1271 | .unthrottle = serial_unthrottle, | |
1272 | .break_ctl = serial_break, | |
1273 | .chars_in_buffer = serial_chars_in_buffer, | |
1274 | .read_proc = serial_read_proc, | |
1275 | .tiocmget = serial_tiocmget, | |
1276 | .tiocmset = serial_tiocmset, | |
1277 | }; | |
1278 | ||
1279 | struct tty_driver *usb_serial_tty_driver; | |
1280 | ||
1281 | static int __init usb_serial_init(void) | |
1282 | { | |
1283 | int i; | |
1284 | int result; | |
1285 | ||
1286 | usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS); | |
1287 | if (!usb_serial_tty_driver) | |
1288 | return -ENOMEM; | |
1289 | ||
1290 | /* Initialize our global data */ | |
1291 | for (i = 0; i < SERIAL_TTY_MINORS; ++i) { | |
1292 | serial_table[i] = NULL; | |
1293 | } | |
1294 | ||
1295 | result = bus_register(&usb_serial_bus_type); | |
1296 | if (result) { | |
1297 | err("%s - registering bus driver failed", __FUNCTION__); | |
1298 | goto exit_bus; | |
1299 | } | |
1300 | ||
1da177e4 LT |
1301 | usb_serial_tty_driver->owner = THIS_MODULE; |
1302 | usb_serial_tty_driver->driver_name = "usbserial"; | |
1303 | usb_serial_tty_driver->devfs_name = "usb/tts/"; | |
1304 | usb_serial_tty_driver->name = "ttyUSB"; | |
1305 | usb_serial_tty_driver->major = SERIAL_TTY_MAJOR; | |
1306 | usb_serial_tty_driver->minor_start = 0; | |
1307 | usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; | |
1308 | usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL; | |
1309 | usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS; | |
1310 | usb_serial_tty_driver->init_termios = tty_std_termios; | |
1311 | usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; | |
1312 | tty_set_operations(usb_serial_tty_driver, &serial_ops); | |
1313 | result = tty_register_driver(usb_serial_tty_driver); | |
1314 | if (result) { | |
1315 | err("%s - tty_register_driver failed", __FUNCTION__); | |
1316 | goto exit_reg_driver; | |
1317 | } | |
1318 | ||
1319 | /* register the USB driver */ | |
1320 | result = usb_register(&usb_serial_driver); | |
1321 | if (result < 0) { | |
1322 | err("%s - usb_register failed", __FUNCTION__); | |
1323 | goto exit_tty; | |
1324 | } | |
1325 | ||
06299db3 GKH |
1326 | /* register the generic driver, if we should */ |
1327 | result = usb_serial_generic_register(debug); | |
1328 | if (result < 0) { | |
1329 | err("%s - registering generic driver failed", __FUNCTION__); | |
1330 | goto exit_generic; | |
1331 | } | |
1332 | ||
1da177e4 LT |
1333 | info(DRIVER_DESC " " DRIVER_VERSION); |
1334 | ||
1335 | return result; | |
1336 | ||
06299db3 GKH |
1337 | exit_generic: |
1338 | usb_deregister(&usb_serial_driver); | |
1339 | ||
1da177e4 LT |
1340 | exit_tty: |
1341 | tty_unregister_driver(usb_serial_tty_driver); | |
1342 | ||
1343 | exit_reg_driver: | |
1da177e4 LT |
1344 | bus_unregister(&usb_serial_bus_type); |
1345 | ||
1346 | exit_bus: | |
1347 | err ("%s - returning with error %d", __FUNCTION__, result); | |
1348 | put_tty_driver(usb_serial_tty_driver); | |
1349 | return result; | |
1350 | } | |
1351 | ||
1352 | ||
1353 | static void __exit usb_serial_exit(void) | |
1354 | { | |
1355 | usb_serial_console_exit(); | |
1356 | ||
1357 | usb_serial_generic_deregister(); | |
1358 | ||
1359 | usb_deregister(&usb_serial_driver); | |
1360 | tty_unregister_driver(usb_serial_tty_driver); | |
1361 | put_tty_driver(usb_serial_tty_driver); | |
1362 | bus_unregister(&usb_serial_bus_type); | |
1363 | } | |
1364 | ||
1365 | ||
1366 | module_init(usb_serial_init); | |
1367 | module_exit(usb_serial_exit); | |
1368 | ||
1369 | #define set_to_generic_if_null(type, function) \ | |
1370 | do { \ | |
1371 | if (!type->function) { \ | |
1372 | type->function = usb_serial_generic_##function; \ | |
1373 | dbg("Had to override the " #function \ | |
1374 | " usb serial operation with the generic one.");\ | |
1375 | } \ | |
1376 | } while (0) | |
1377 | ||
1378 | static void fixup_generic(struct usb_serial_device_type *device) | |
1379 | { | |
1380 | set_to_generic_if_null(device, open); | |
1381 | set_to_generic_if_null(device, write); | |
1382 | set_to_generic_if_null(device, close); | |
1383 | set_to_generic_if_null(device, write_room); | |
1384 | set_to_generic_if_null(device, chars_in_buffer); | |
1385 | set_to_generic_if_null(device, read_bulk_callback); | |
1386 | set_to_generic_if_null(device, write_bulk_callback); | |
1387 | set_to_generic_if_null(device, shutdown); | |
1388 | } | |
1389 | ||
1390 | int usb_serial_register(struct usb_serial_device_type *new_device) | |
1391 | { | |
1392 | int retval; | |
1393 | ||
1394 | fixup_generic(new_device); | |
1395 | ||
1396 | /* Add this device to our list of devices */ | |
1397 | list_add(&new_device->driver_list, &usb_serial_driver_list); | |
1398 | ||
1399 | retval = usb_serial_bus_register(new_device); | |
1400 | if (retval) { | |
1401 | err("problem %d when registering driver %s", retval, new_device->name); | |
1402 | list_del(&new_device->driver_list); | |
1403 | } | |
1404 | else | |
1405 | info("USB Serial support registered for %s", new_device->name); | |
1406 | ||
1407 | return retval; | |
1408 | } | |
1409 | ||
1410 | ||
1411 | void usb_serial_deregister(struct usb_serial_device_type *device) | |
1412 | { | |
1413 | info("USB Serial deregistering driver %s", device->name); | |
1414 | list_del(&device->driver_list); | |
1415 | usb_serial_bus_deregister(device); | |
1416 | } | |
1417 | ||
1418 | ||
1419 | ||
1420 | /* If the usb-serial core is built into the core, the usb-serial drivers | |
1421 | need these symbols to load properly as modules. */ | |
1422 | EXPORT_SYMBOL_GPL(usb_serial_register); | |
1423 | EXPORT_SYMBOL_GPL(usb_serial_deregister); | |
1424 | EXPORT_SYMBOL_GPL(usb_serial_probe); | |
1425 | EXPORT_SYMBOL_GPL(usb_serial_disconnect); | |
1426 | EXPORT_SYMBOL_GPL(usb_serial_port_softint); | |
1427 | ||
1428 | ||
1429 | /* Module information */ | |
1430 | MODULE_AUTHOR( DRIVER_AUTHOR ); | |
1431 | MODULE_DESCRIPTION( DRIVER_DESC ); | |
1432 | MODULE_VERSION( DRIVER_VERSION ); | |
1433 | MODULE_LICENSE("GPL"); | |
1434 | ||
1435 | module_param(debug, bool, S_IRUGO | S_IWUSR); | |
1436 | MODULE_PARM_DESC(debug, "Debug enabled or not"); |