]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * USB Serial Converter Generic functions | |
3 | * | |
4 | * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com) | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public License version | |
8 | * 2 as published by the Free Software Foundation. | |
9 | * | |
10 | */ | |
11 | ||
1da177e4 LT |
12 | #include <linux/kernel.h> |
13 | #include <linux/errno.h> | |
14 | #include <linux/slab.h> | |
15 | #include <linux/tty.h> | |
16 | #include <linux/tty_flip.h> | |
17 | #include <linux/module.h> | |
18 | #include <linux/moduleparam.h> | |
19 | #include <linux/usb.h> | |
a969888c | 20 | #include <linux/usb/serial.h> |
ae64387a | 21 | #include <linux/uaccess.h> |
1da177e4 | 22 | |
d9b1b787 | 23 | |
1da177e4 LT |
24 | static int debug; |
25 | ||
26 | #ifdef CONFIG_USB_SERIAL_GENERIC | |
b46d60fc DB |
27 | |
28 | static int generic_probe(struct usb_interface *interface, | |
29 | const struct usb_device_id *id); | |
30 | ||
1da177e4 LT |
31 | static __u16 vendor = 0x05f9; |
32 | static __u16 product = 0xffff; | |
33 | ||
34 | module_param(vendor, ushort, 0); | |
35 | MODULE_PARM_DESC(vendor, "User specified USB idVendor"); | |
36 | ||
37 | module_param(product, ushort, 0); | |
38 | MODULE_PARM_DESC(product, "User specified USB idProduct"); | |
39 | ||
40 | static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */ | |
41 | ||
d9b1b787 JH |
42 | /* we want to look at all devices, as the vendor/product id can change |
43 | * depending on the command line argument */ | |
44 | static struct usb_device_id generic_serial_ids[] = { | |
45 | {.driver_info = 42}, | |
46 | {} | |
47 | }; | |
48 | ||
49 | static struct usb_driver generic_driver = { | |
50 | .name = "usbserial_generic", | |
51 | .probe = generic_probe, | |
52 | .disconnect = usb_serial_disconnect, | |
53 | .id_table = generic_serial_ids, | |
54 | .no_dynamic_id = 1, | |
55 | }; | |
56 | ||
1da177e4 | 57 | /* All of the device info needed for the Generic Serial Converter */ |
ea65370d | 58 | struct usb_serial_driver usb_serial_generic_device = { |
18fcac35 GKH |
59 | .driver = { |
60 | .owner = THIS_MODULE, | |
269bda1c | 61 | .name = "generic", |
18fcac35 | 62 | }, |
1da177e4 | 63 | .id_table = generic_device_ids, |
d9b1b787 | 64 | .usb_driver = &generic_driver, |
1da177e4 LT |
65 | .num_ports = 1, |
66 | .shutdown = usb_serial_generic_shutdown, | |
253ca923 JR |
67 | .throttle = usb_serial_generic_throttle, |
68 | .unthrottle = usb_serial_generic_unthrottle, | |
ec22559e | 69 | .resume = usb_serial_generic_resume, |
1da177e4 LT |
70 | }; |
71 | ||
1da177e4 LT |
72 | static int generic_probe(struct usb_interface *interface, |
73 | const struct usb_device_id *id) | |
74 | { | |
75 | const struct usb_device_id *id_pattern; | |
76 | ||
77 | id_pattern = usb_match_id(interface, generic_device_ids); | |
78 | if (id_pattern != NULL) | |
79 | return usb_serial_probe(interface, id); | |
80 | return -ENODEV; | |
81 | } | |
1da177e4 LT |
82 | #endif |
83 | ||
ae64387a | 84 | int usb_serial_generic_register(int _debug) |
1da177e4 LT |
85 | { |
86 | int retval = 0; | |
87 | ||
88 | debug = _debug; | |
89 | #ifdef CONFIG_USB_SERIAL_GENERIC | |
90 | generic_device_ids[0].idVendor = vendor; | |
91 | generic_device_ids[0].idProduct = product; | |
ae64387a AC |
92 | generic_device_ids[0].match_flags = |
93 | USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT; | |
1da177e4 LT |
94 | |
95 | /* register our generic driver with ourselves */ | |
ae64387a | 96 | retval = usb_serial_register(&usb_serial_generic_device); |
1da177e4 LT |
97 | if (retval) |
98 | goto exit; | |
99 | retval = usb_register(&generic_driver); | |
100 | if (retval) | |
101 | usb_serial_deregister(&usb_serial_generic_device); | |
102 | exit: | |
103 | #endif | |
104 | return retval; | |
105 | } | |
106 | ||
ae64387a | 107 | void usb_serial_generic_deregister(void) |
1da177e4 LT |
108 | { |
109 | #ifdef CONFIG_USB_SERIAL_GENERIC | |
110 | /* remove our generic driver */ | |
111 | usb_deregister(&generic_driver); | |
ae64387a | 112 | usb_serial_deregister(&usb_serial_generic_device); |
1da177e4 LT |
113 | #endif |
114 | } | |
115 | ||
95da310e AC |
116 | int usb_serial_generic_open(struct tty_struct *tty, |
117 | struct usb_serial_port *port, struct file *filp) | |
1da177e4 LT |
118 | { |
119 | struct usb_serial *serial = port->serial; | |
120 | int result = 0; | |
253ca923 | 121 | unsigned long flags; |
1da177e4 | 122 | |
441b62c1 | 123 | dbg("%s - port %d", __func__, port->number); |
1da177e4 | 124 | |
ae64387a AC |
125 | /* force low_latency on so that our tty_push actually forces the data |
126 | through, otherwise it is scheduled, and with high data rates (like | |
127 | with OHCI) data can get lost. */ | |
95da310e AC |
128 | if (tty) |
129 | tty->low_latency = 1; | |
1da177e4 | 130 | |
253ca923 JR |
131 | /* clear the throttle flags */ |
132 | spin_lock_irqsave(&port->lock, flags); | |
133 | port->throttled = 0; | |
134 | port->throttle_req = 0; | |
135 | spin_unlock_irqrestore(&port->lock, flags); | |
136 | ||
137 | /* if we have a bulk endpoint, start reading from it */ | |
1da177e4 LT |
138 | if (serial->num_bulk_in) { |
139 | /* Start reading from the device */ | |
ae64387a AC |
140 | usb_fill_bulk_urb(port->read_urb, serial->dev, |
141 | usb_rcvbulkpipe(serial->dev, | |
142 | port->bulk_in_endpointAddress), | |
1da177e4 LT |
143 | port->read_urb->transfer_buffer, |
144 | port->read_urb->transfer_buffer_length, | |
145 | ((serial->type->read_bulk_callback) ? | |
146 | serial->type->read_bulk_callback : | |
147 | usb_serial_generic_read_bulk_callback), | |
148 | port); | |
149 | result = usb_submit_urb(port->read_urb, GFP_KERNEL); | |
150 | if (result) | |
ae64387a AC |
151 | dev_err(&port->dev, |
152 | "%s - failed resubmitting read urb, error %d\n", | |
153 | __func__, result); | |
1da177e4 LT |
154 | } |
155 | ||
156 | return result; | |
157 | } | |
815ddc99 | 158 | EXPORT_SYMBOL_GPL(usb_serial_generic_open); |
1da177e4 | 159 | |
95da310e | 160 | static void generic_cleanup(struct usb_serial_port *port) |
1da177e4 LT |
161 | { |
162 | struct usb_serial *serial = port->serial; | |
163 | ||
441b62c1 | 164 | dbg("%s - port %d", __func__, port->number); |
1da177e4 LT |
165 | |
166 | if (serial->dev) { | |
167 | /* shutdown any bulk reads that might be going on */ | |
168 | if (serial->num_bulk_out) | |
169 | usb_kill_urb(port->write_urb); | |
170 | if (serial->num_bulk_in) | |
171 | usb_kill_urb(port->read_urb); | |
172 | } | |
173 | } | |
174 | ||
ec22559e ON |
175 | int usb_serial_generic_resume(struct usb_serial *serial) |
176 | { | |
177 | struct usb_serial_port *port; | |
178 | int i, c = 0, r; | |
179 | ||
f0fbd5b9 SS |
180 | #ifdef CONFIG_PM |
181 | /* | |
182 | * If this is an autoresume, don't submit URBs. | |
183 | * They will be submitted in the open function instead. | |
184 | */ | |
185 | if (serial->dev->auto_pm) | |
186 | return 0; | |
187 | #endif | |
ec22559e ON |
188 | for (i = 0; i < serial->num_ports; i++) { |
189 | port = serial->port[i]; | |
95da310e | 190 | if (port->port.count && port->read_urb) { |
ec22559e ON |
191 | r = usb_submit_urb(port->read_urb, GFP_NOIO); |
192 | if (r < 0) | |
193 | c++; | |
194 | } | |
195 | } | |
196 | ||
197 | return c ? -EIO : 0; | |
198 | } | |
199 | ||
95da310e | 200 | void usb_serial_generic_close(struct tty_struct *tty, |
ae64387a | 201 | struct usb_serial_port *port, struct file *filp) |
1da177e4 | 202 | { |
441b62c1 | 203 | dbg("%s - port %d", __func__, port->number); |
ae64387a | 204 | generic_cleanup(port); |
1da177e4 LT |
205 | } |
206 | ||
95da310e AC |
207 | int usb_serial_generic_write(struct tty_struct *tty, |
208 | struct usb_serial_port *port, const unsigned char *buf, int count) | |
1da177e4 LT |
209 | { |
210 | struct usb_serial *serial = port->serial; | |
211 | int result; | |
212 | unsigned char *data; | |
213 | ||
441b62c1 | 214 | dbg("%s - port %d", __func__, port->number); |
1da177e4 LT |
215 | |
216 | if (count == 0) { | |
441b62c1 | 217 | dbg("%s - write request of 0 bytes", __func__); |
ae64387a | 218 | return 0; |
1da177e4 LT |
219 | } |
220 | ||
221 | /* only do something if we have a bulk out endpoint */ | |
222 | if (serial->num_bulk_out) { | |
acd2a847 JK |
223 | unsigned long flags; |
224 | spin_lock_irqsave(&port->lock, flags); | |
507ca9bc | 225 | if (port->write_urb_busy) { |
acd2a847 | 226 | spin_unlock_irqrestore(&port->lock, flags); |
441b62c1 | 227 | dbg("%s - already writing", __func__); |
507ca9bc | 228 | return 0; |
1da177e4 | 229 | } |
507ca9bc | 230 | port->write_urb_busy = 1; |
acd2a847 | 231 | spin_unlock_irqrestore(&port->lock, flags); |
1da177e4 | 232 | |
ae64387a AC |
233 | count = (count > port->bulk_out_size) ? |
234 | port->bulk_out_size : count; | |
1da177e4 | 235 | |
ae64387a | 236 | memcpy(port->write_urb->transfer_buffer, buf, count); |
1da177e4 | 237 | data = port->write_urb->transfer_buffer; |
441b62c1 | 238 | usb_serial_debug_data(debug, &port->dev, __func__, count, data); |
1da177e4 LT |
239 | |
240 | /* set up our urb */ | |
ae64387a AC |
241 | usb_fill_bulk_urb(port->write_urb, serial->dev, |
242 | usb_sndbulkpipe(serial->dev, | |
243 | port->bulk_out_endpointAddress), | |
1da177e4 | 244 | port->write_urb->transfer_buffer, count, |
ae64387a | 245 | ((serial->type->write_bulk_callback) ? |
1da177e4 | 246 | serial->type->write_bulk_callback : |
ae64387a AC |
247 | usb_serial_generic_write_bulk_callback), |
248 | port); | |
1da177e4 LT |
249 | |
250 | /* send the data out the bulk port */ | |
507ca9bc | 251 | port->write_urb_busy = 1; |
1da177e4 | 252 | result = usb_submit_urb(port->write_urb, GFP_ATOMIC); |
507ca9bc | 253 | if (result) { |
ae64387a AC |
254 | dev_err(&port->dev, |
255 | "%s - failed submitting write urb, error %d\n", | |
256 | __func__, result); | |
257 | /* don't have to grab the lock here, as we will | |
258 | retry if != 0 */ | |
507ca9bc GKH |
259 | port->write_urb_busy = 0; |
260 | } else | |
1da177e4 LT |
261 | result = count; |
262 | ||
263 | return result; | |
264 | } | |
265 | ||
266 | /* no bulk out, so return 0 bytes written */ | |
507ca9bc | 267 | return 0; |
1da177e4 LT |
268 | } |
269 | ||
ae64387a | 270 | int usb_serial_generic_write_room(struct tty_struct *tty) |
1da177e4 | 271 | { |
95da310e | 272 | struct usb_serial_port *port = tty->driver_data; |
1da177e4 LT |
273 | struct usb_serial *serial = port->serial; |
274 | int room = 0; | |
275 | ||
441b62c1 | 276 | dbg("%s - port %d", __func__, port->number); |
507ca9bc | 277 | |
a5b6f60c | 278 | /* FIXME: Locking */ |
1da177e4 | 279 | if (serial->num_bulk_out) { |
7a3ca7d2 | 280 | if (!(port->write_urb_busy)) |
1da177e4 LT |
281 | room = port->bulk_out_size; |
282 | } | |
283 | ||
441b62c1 | 284 | dbg("%s - returns %d", __func__, room); |
a5b6f60c | 285 | return room; |
1da177e4 LT |
286 | } |
287 | ||
95da310e | 288 | int usb_serial_generic_chars_in_buffer(struct tty_struct *tty) |
1da177e4 | 289 | { |
95da310e | 290 | struct usb_serial_port *port = tty->driver_data; |
1da177e4 LT |
291 | struct usb_serial *serial = port->serial; |
292 | int chars = 0; | |
293 | ||
441b62c1 | 294 | dbg("%s - port %d", __func__, port->number); |
1da177e4 | 295 | |
a5b6f60c | 296 | /* FIXME: Locking */ |
1da177e4 | 297 | if (serial->num_bulk_out) { |
507ca9bc | 298 | if (port->write_urb_busy) |
1da177e4 LT |
299 | chars = port->write_urb->transfer_buffer_length; |
300 | } | |
301 | ||
441b62c1 | 302 | dbg("%s - returns %d", __func__, chars); |
95da310e | 303 | return chars; |
1da177e4 LT |
304 | } |
305 | ||
1abdeeb1 ON |
306 | |
307 | static void resubmit_read_urb(struct usb_serial_port *port, gfp_t mem_flags) | |
1da177e4 | 308 | { |
253ca923 | 309 | struct urb *urb = port->read_urb; |
1abdeeb1 | 310 | struct usb_serial *serial = port->serial; |
1da177e4 LT |
311 | int result; |
312 | ||
253ca923 | 313 | /* Continue reading from device */ |
ae64387a AC |
314 | usb_fill_bulk_urb(urb, serial->dev, |
315 | usb_rcvbulkpipe(serial->dev, | |
316 | port->bulk_in_endpointAddress), | |
1abdeeb1 ON |
317 | urb->transfer_buffer, |
318 | urb->transfer_buffer_length, | |
ae64387a AC |
319 | ((serial->type->read_bulk_callback) ? |
320 | serial->type->read_bulk_callback : | |
1da177e4 | 321 | usb_serial_generic_read_bulk_callback), port); |
1abdeeb1 | 322 | result = usb_submit_urb(urb, mem_flags); |
1da177e4 | 323 | if (result) |
ae64387a AC |
324 | dev_err(&port->dev, |
325 | "%s - failed resubmitting read urb, error %d\n", | |
326 | __func__, result); | |
1da177e4 | 327 | } |
253ca923 | 328 | |
1abdeeb1 | 329 | /* Push data to tty layer and resubmit the bulk read URB */ |
95da310e | 330 | static void flush_and_resubmit_read_urb(struct usb_serial_port *port) |
1abdeeb1 ON |
331 | { |
332 | struct urb *urb = port->read_urb; | |
4a90f09b | 333 | struct tty_struct *tty = tty_port_tty_get(&port->port); |
1abdeeb1 ON |
334 | int room; |
335 | ||
336 | /* Push data to tty */ | |
337 | if (tty && urb->actual_length) { | |
338 | room = tty_buffer_request_room(tty, urb->actual_length); | |
339 | if (room) { | |
340 | tty_insert_flip_string(tty, urb->transfer_buffer, room); | |
b507cc97 | 341 | tty_flip_buffer_push(tty); |
1abdeeb1 ON |
342 | } |
343 | } | |
4a90f09b | 344 | tty_kref_put(tty); |
1abdeeb1 ON |
345 | |
346 | resubmit_read_urb(port, GFP_ATOMIC); | |
347 | } | |
348 | ||
95da310e | 349 | void usb_serial_generic_read_bulk_callback(struct urb *urb) |
253ca923 | 350 | { |
cdc97792 | 351 | struct usb_serial_port *port = urb->context; |
253ca923 | 352 | unsigned char *data = urb->transfer_buffer; |
fbd27225 | 353 | int status = urb->status; |
bfaeafcf | 354 | unsigned long flags; |
253ca923 | 355 | |
441b62c1 | 356 | dbg("%s - port %d", __func__, port->number); |
253ca923 | 357 | |
fbd27225 GKH |
358 | if (unlikely(status != 0)) { |
359 | dbg("%s - nonzero read bulk status received: %d", | |
441b62c1 | 360 | __func__, status); |
253ca923 JR |
361 | return; |
362 | } | |
363 | ||
ae64387a AC |
364 | usb_serial_debug_data(debug, &port->dev, __func__, |
365 | urb->actual_length, data); | |
253ca923 JR |
366 | |
367 | /* Throttle the device if requested by tty */ | |
bfaeafcf | 368 | spin_lock_irqsave(&port->lock, flags); |
ae64387a AC |
369 | port->throttled = port->throttle_req; |
370 | if (!port->throttled) { | |
b507cc97 | 371 | spin_unlock_irqrestore(&port->lock, flags); |
1abdeeb1 | 372 | flush_and_resubmit_read_urb(port); |
ae64387a | 373 | } else |
b507cc97 | 374 | spin_unlock_irqrestore(&port->lock, flags); |
253ca923 | 375 | } |
166ffccf | 376 | EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback); |
1da177e4 | 377 | |
95da310e | 378 | void usb_serial_generic_write_bulk_callback(struct urb *urb) |
1da177e4 | 379 | { |
cdc97792 | 380 | struct usb_serial_port *port = urb->context; |
fbd27225 | 381 | int status = urb->status; |
1da177e4 | 382 | |
441b62c1 | 383 | dbg("%s - port %d", __func__, port->number); |
1da177e4 | 384 | |
507ca9bc | 385 | port->write_urb_busy = 0; |
fbd27225 GKH |
386 | if (status) { |
387 | dbg("%s - nonzero write bulk status received: %d", | |
441b62c1 | 388 | __func__, status); |
1da177e4 LT |
389 | return; |
390 | } | |
cf2c7481 | 391 | usb_serial_port_softint(port); |
1da177e4 | 392 | } |
bb833986 | 393 | EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback); |
1da177e4 | 394 | |
95da310e | 395 | void usb_serial_generic_throttle(struct tty_struct *tty) |
253ca923 | 396 | { |
95da310e | 397 | struct usb_serial_port *port = tty->driver_data; |
253ca923 JR |
398 | unsigned long flags; |
399 | ||
441b62c1 | 400 | dbg("%s - port %d", __func__, port->number); |
253ca923 JR |
401 | |
402 | /* Set the throttle request flag. It will be picked up | |
403 | * by usb_serial_generic_read_bulk_callback(). */ | |
404 | spin_lock_irqsave(&port->lock, flags); | |
405 | port->throttle_req = 1; | |
406 | spin_unlock_irqrestore(&port->lock, flags); | |
407 | } | |
408 | ||
95da310e | 409 | void usb_serial_generic_unthrottle(struct tty_struct *tty) |
253ca923 | 410 | { |
95da310e | 411 | struct usb_serial_port *port = tty->driver_data; |
253ca923 JR |
412 | int was_throttled; |
413 | unsigned long flags; | |
414 | ||
441b62c1 | 415 | dbg("%s - port %d", __func__, port->number); |
253ca923 JR |
416 | |
417 | /* Clear the throttle flags */ | |
418 | spin_lock_irqsave(&port->lock, flags); | |
419 | was_throttled = port->throttled; | |
420 | port->throttled = port->throttle_req = 0; | |
421 | spin_unlock_irqrestore(&port->lock, flags); | |
422 | ||
423 | if (was_throttled) { | |
1abdeeb1 ON |
424 | /* Resume reading from device */ |
425 | resubmit_read_urb(port, GFP_KERNEL); | |
253ca923 JR |
426 | } |
427 | } | |
428 | ||
ae64387a | 429 | void usb_serial_generic_shutdown(struct usb_serial *serial) |
1da177e4 LT |
430 | { |
431 | int i; | |
432 | ||
441b62c1 | 433 | dbg("%s", __func__); |
1da177e4 LT |
434 | |
435 | /* stop reads and writes on all ports */ | |
ae64387a | 436 | for (i = 0; i < serial->num_ports; ++i) |
1da177e4 | 437 | generic_cleanup(serial->port[i]); |
1da177e4 LT |
438 | } |
439 |