Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * USB IR Dongle driver | |
3 | * | |
4 | * Copyright (C) 2001-2002 Greg Kroah-Hartman (greg@kroah.com) | |
5 | * Copyright (C) 2002 Gary Brubaker (xavyer@ix.netcom.com) | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This driver allows a USB IrDA device to be used as a "dumb" serial device. | |
13 | * This can be useful if you do not have access to a full IrDA stack on the | |
14 | * other side of the connection. If you do have an IrDA stack on both devices, | |
15 | * please use the usb-irda driver, as it contains the proper error checking and | |
16 | * other goodness of a full IrDA stack. | |
17 | * | |
18 | * Portions of this driver were taken from drivers/net/irda/irda-usb.c, which | |
19 | * was written by Roman Weissgaerber <weissg@vienna.at>, Dag Brattli | |
20 | * <dag@brattli.net>, and Jean Tourrilhes <jt@hpl.hp.com> | |
21 | * | |
e0d795e4 FB |
22 | * See Documentation/usb/usb-serial.txt for more information on using this |
23 | * driver | |
24 | * | |
25 | * 2008_Jun_02 Felipe Balbi <me@felipebalbi.com> | |
26 | * Introduced common header to be used also in USB Gadget Framework. | |
27 | * Still needs some other style fixes. | |
1da177e4 | 28 | * |
8eb04cf3 | 29 | * 2007_Jun_21 Alan Cox <alan@lxorguk.ukuu.org.uk> |
a6ea438b AC |
30 | * Minimal cleanups for some of the driver problens and tty layer abuse. |
31 | * Still needs fixing to allow multiple dongles. | |
32 | * | |
1da177e4 LT |
33 | * 2002_Mar_07 greg kh |
34 | * moved some needed structures and #define values from the | |
35 | * net/irda/irda-usb.h file into our file, as we don't want to depend on | |
36 | * that codebase compiling correctly :) | |
37 | * | |
38 | * 2002_Jan_14 gb | |
39 | * Added module parameter to force specific number of XBOFs. | |
40 | * Added ir_xbof_change(). | |
41 | * Reorganized read_bulk_callback error handling. | |
42 | * Switched from FILL_BULK_URB() to usb_fill_bulk_urb(). | |
43 | * | |
44 | * 2001_Nov_08 greg kh | |
45 | * Changed the irda_usb_find_class_desc() function based on comments and | |
46 | * code from Martin Diehl. | |
47 | * | |
48 | * 2001_Nov_01 greg kh | |
49 | * Added support for more IrDA USB devices. | |
50 | * Added support for zero packet. Added buffer override paramater, so | |
51 | * users can transfer larger packets at once if they wish. Both patches | |
52 | * came from Dag Brattli <dag@obexcode.com>. | |
53 | * | |
54 | * 2001_Oct_07 greg kh | |
55 | * initial version released. | |
56 | */ | |
57 | ||
1da177e4 LT |
58 | #include <linux/kernel.h> |
59 | #include <linux/errno.h> | |
60 | #include <linux/init.h> | |
61 | #include <linux/slab.h> | |
62 | #include <linux/tty.h> | |
63 | #include <linux/tty_driver.h> | |
64 | #include <linux/tty_flip.h> | |
65 | #include <linux/module.h> | |
66 | #include <linux/spinlock.h> | |
e0d795e4 | 67 | #include <linux/uaccess.h> |
1da177e4 | 68 | #include <linux/usb.h> |
a969888c | 69 | #include <linux/usb/serial.h> |
e0d795e4 | 70 | #include <linux/usb/irda.h> |
1da177e4 LT |
71 | |
72 | /* | |
73 | * Version Information | |
74 | */ | |
75 | #define DRIVER_VERSION "v0.4" | |
76 | #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>" | |
77 | #define DRIVER_DESC "USB IR Dongle driver" | |
78 | ||
1da177e4 LT |
79 | static int debug; |
80 | ||
81 | /* if overridden by the user, then use their value for the size of the read and | |
82 | * write urbs */ | |
83 | static int buffer_size; | |
e0d795e4 | 84 | |
1da177e4 LT |
85 | /* if overridden by the user, then use the specified number of XBOFs */ |
86 | static int xbof = -1; | |
87 | ||
95da310e | 88 | static int ir_startup (struct usb_serial *serial); |
a509a7e4 | 89 | static int ir_open(struct tty_struct *tty, struct usb_serial_port *port); |
335f8514 | 90 | static void ir_close(struct usb_serial_port *port); |
95da310e AC |
91 | static int ir_write(struct tty_struct *tty, struct usb_serial_port *port, |
92 | const unsigned char *buf, int count); | |
93 | static void ir_write_bulk_callback (struct urb *urb); | |
94 | static void ir_read_bulk_callback (struct urb *urb); | |
95 | static void ir_set_termios(struct tty_struct *tty, | |
96 | struct usb_serial_port *port, struct ktermios *old_termios); | |
1da177e4 | 97 | |
a6ea438b | 98 | /* Not that this lot means you can only have one per system */ |
e0d795e4 FB |
99 | static u8 ir_baud; |
100 | static u8 ir_xbof; | |
101 | static u8 ir_add_bof; | |
1da177e4 | 102 | |
e0d795e4 | 103 | static struct usb_device_id ir_id_table[] = { |
1da177e4 LT |
104 | { USB_DEVICE(0x050f, 0x0180) }, /* KC Technology, KC-180 */ |
105 | { USB_DEVICE(0x08e9, 0x0100) }, /* XTNDAccess */ | |
106 | { USB_DEVICE(0x09c4, 0x0011) }, /* ACTiSys ACT-IR2000U */ | |
e0d795e4 | 107 | { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, USB_SUBCLASS_IRDA, 0) }, |
1da177e4 LT |
108 | { } /* Terminating entry */ |
109 | }; | |
110 | ||
e0d795e4 | 111 | MODULE_DEVICE_TABLE(usb, ir_id_table); |
1da177e4 LT |
112 | |
113 | static struct usb_driver ir_driver = { | |
e0d795e4 FB |
114 | .name = "ir-usb", |
115 | .probe = usb_serial_probe, | |
116 | .disconnect = usb_serial_disconnect, | |
117 | .id_table = ir_id_table, | |
118 | .no_dynamic_id = 1, | |
1da177e4 LT |
119 | }; |
120 | ||
ea65370d | 121 | static struct usb_serial_driver ir_device = { |
e0d795e4 FB |
122 | .driver = { |
123 | .owner = THIS_MODULE, | |
124 | .name = "ir-usb", | |
18fcac35 | 125 | }, |
e0d795e4 FB |
126 | .description = "IR Dongle", |
127 | .usb_driver = &ir_driver, | |
128 | .id_table = ir_id_table, | |
129 | .num_ports = 1, | |
130 | .set_termios = ir_set_termios, | |
131 | .attach = ir_startup, | |
132 | .open = ir_open, | |
133 | .close = ir_close, | |
134 | .write = ir_write, | |
135 | .write_bulk_callback = ir_write_bulk_callback, | |
136 | .read_bulk_callback = ir_read_bulk_callback, | |
1da177e4 LT |
137 | }; |
138 | ||
e0d795e4 | 139 | static inline void irda_usb_dump_class_desc(struct usb_irda_cs_descriptor *desc) |
1da177e4 LT |
140 | { |
141 | dbg("bLength=%x", desc->bLength); | |
142 | dbg("bDescriptorType=%x", desc->bDescriptorType); | |
e0d795e4 | 143 | dbg("bcdSpecRevision=%x", __le16_to_cpu(desc->bcdSpecRevision)); |
1da177e4 LT |
144 | dbg("bmDataSize=%x", desc->bmDataSize); |
145 | dbg("bmWindowSize=%x", desc->bmWindowSize); | |
146 | dbg("bmMinTurnaroundTime=%d", desc->bmMinTurnaroundTime); | |
e0d795e4 | 147 | dbg("wBaudRate=%x", __le16_to_cpu(desc->wBaudRate)); |
1da177e4 LT |
148 | dbg("bmAdditionalBOFs=%x", desc->bmAdditionalBOFs); |
149 | dbg("bIrdaRateSniff=%x", desc->bIrdaRateSniff); | |
150 | dbg("bMaxUnicastList=%x", desc->bMaxUnicastList); | |
151 | } | |
152 | ||
153 | /*------------------------------------------------------------------*/ | |
154 | /* | |
155 | * Function irda_usb_find_class_desc(dev, ifnum) | |
156 | * | |
157 | * Returns instance of IrDA class descriptor, or NULL if not found | |
158 | * | |
159 | * The class descriptor is some extra info that IrDA USB devices will | |
160 | * offer to us, describing their IrDA characteristics. We will use that in | |
161 | * irda_usb_init_qos() | |
162 | * | |
163 | * Based on the same function in drivers/net/irda/irda-usb.c | |
164 | */ | |
e0d795e4 FB |
165 | static struct usb_irda_cs_descriptor * |
166 | irda_usb_find_class_desc(struct usb_device *dev, unsigned int ifnum) | |
1da177e4 | 167 | { |
e0d795e4 | 168 | struct usb_irda_cs_descriptor *desc; |
1da177e4 | 169 | int ret; |
e0d795e4 FB |
170 | |
171 | desc = kzalloc(sizeof(*desc), GFP_KERNEL); | |
172 | if (!desc) | |
1da177e4 | 173 | return NULL; |
e0d795e4 FB |
174 | |
175 | ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), | |
176 | USB_REQ_CS_IRDA_GET_CLASS_DESC, | |
1da177e4 LT |
177 | USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, |
178 | 0, ifnum, desc, sizeof(*desc), 1000); | |
e0d795e4 | 179 | |
441b62c1 | 180 | dbg("%s - ret=%d", __func__, ret); |
1da177e4 LT |
181 | if (ret < sizeof(*desc)) { |
182 | dbg("%s - class descriptor read %s (%d)", | |
441b62c1 | 183 | __func__, |
e0d795e4 | 184 | (ret < 0) ? "failed" : "too short", |
1da177e4 LT |
185 | ret); |
186 | goto error; | |
187 | } | |
e0d795e4 | 188 | if (desc->bDescriptorType != USB_DT_CS_IRDA) { |
441b62c1 | 189 | dbg("%s - bad class descriptor type", __func__); |
1da177e4 LT |
190 | goto error; |
191 | } | |
e0d795e4 | 192 | |
1da177e4 LT |
193 | irda_usb_dump_class_desc(desc); |
194 | return desc; | |
e0d795e4 | 195 | |
1da177e4 LT |
196 | error: |
197 | kfree(desc); | |
198 | return NULL; | |
199 | } | |
200 | ||
201 | ||
202 | static u8 ir_xbof_change(u8 xbof) | |
203 | { | |
204 | u8 result; | |
e0d795e4 | 205 | |
1da177e4 | 206 | /* reference irda-usb.c */ |
e0d795e4 FB |
207 | switch (xbof) { |
208 | case 48: | |
209 | result = 0x10; | |
210 | break; | |
211 | case 28: | |
212 | case 24: | |
213 | result = 0x20; | |
214 | break; | |
215 | default: | |
216 | case 12: | |
217 | result = 0x30; | |
218 | break; | |
219 | case 5: | |
220 | case 6: | |
221 | result = 0x40; | |
222 | break; | |
223 | case 3: | |
224 | result = 0x50; | |
225 | break; | |
226 | case 2: | |
227 | result = 0x60; | |
228 | break; | |
229 | case 1: | |
230 | result = 0x70; | |
231 | break; | |
232 | case 0: | |
233 | result = 0x80; | |
234 | break; | |
1da177e4 | 235 | } |
e0d795e4 | 236 | |
1da177e4 LT |
237 | return(result); |
238 | } | |
239 | ||
240 | ||
e0d795e4 | 241 | static int ir_startup(struct usb_serial *serial) |
1da177e4 | 242 | { |
e0d795e4 | 243 | struct usb_irda_cs_descriptor *irda_desc; |
1da177e4 | 244 | |
e0d795e4 FB |
245 | irda_desc = irda_usb_find_class_desc(serial->dev, 0); |
246 | if (!irda_desc) { | |
247 | dev_err(&serial->dev->dev, | |
248 | "IRDA class descriptor not found, device not bound\n"); | |
1da177e4 LT |
249 | return -ENODEV; |
250 | } | |
251 | ||
e0d795e4 | 252 | dbg("%s - Baud rates supported:%s%s%s%s%s%s%s%s%s", |
441b62c1 | 253 | __func__, |
e0d795e4 FB |
254 | (irda_desc->wBaudRate & USB_IRDA_BR_2400) ? " 2400" : "", |
255 | (irda_desc->wBaudRate & USB_IRDA_BR_9600) ? " 9600" : "", | |
256 | (irda_desc->wBaudRate & USB_IRDA_BR_19200) ? " 19200" : "", | |
257 | (irda_desc->wBaudRate & USB_IRDA_BR_38400) ? " 38400" : "", | |
258 | (irda_desc->wBaudRate & USB_IRDA_BR_57600) ? " 57600" : "", | |
259 | (irda_desc->wBaudRate & USB_IRDA_BR_115200) ? " 115200" : "", | |
260 | (irda_desc->wBaudRate & USB_IRDA_BR_576000) ? " 576000" : "", | |
261 | (irda_desc->wBaudRate & USB_IRDA_BR_1152000) ? " 1152000" : "", | |
262 | (irda_desc->wBaudRate & USB_IRDA_BR_4000000) ? " 4000000" : ""); | |
263 | ||
264 | switch (irda_desc->bmAdditionalBOFs) { | |
265 | case USB_IRDA_AB_48: | |
266 | ir_add_bof = 48; | |
267 | break; | |
268 | case USB_IRDA_AB_24: | |
269 | ir_add_bof = 24; | |
270 | break; | |
271 | case USB_IRDA_AB_12: | |
272 | ir_add_bof = 12; | |
273 | break; | |
274 | case USB_IRDA_AB_6: | |
275 | ir_add_bof = 6; | |
276 | break; | |
277 | case USB_IRDA_AB_3: | |
278 | ir_add_bof = 3; | |
279 | break; | |
280 | case USB_IRDA_AB_2: | |
281 | ir_add_bof = 2; | |
282 | break; | |
283 | case USB_IRDA_AB_1: | |
284 | ir_add_bof = 1; | |
285 | break; | |
286 | case USB_IRDA_AB_0: | |
287 | ir_add_bof = 0; | |
288 | break; | |
289 | default: | |
290 | break; | |
1da177e4 LT |
291 | } |
292 | ||
e0d795e4 | 293 | kfree(irda_desc); |
1da177e4 | 294 | |
e0d795e4 | 295 | return 0; |
1da177e4 LT |
296 | } |
297 | ||
a509a7e4 | 298 | static int ir_open(struct tty_struct *tty, struct usb_serial_port *port) |
1da177e4 LT |
299 | { |
300 | char *buffer; | |
301 | int result = 0; | |
302 | ||
441b62c1 | 303 | dbg("%s - port %d", __func__, port->number); |
1da177e4 LT |
304 | |
305 | if (buffer_size) { | |
306 | /* override the default buffer sizes */ | |
e0d795e4 | 307 | buffer = kmalloc(buffer_size, GFP_KERNEL); |
1da177e4 | 308 | if (!buffer) { |
e0d795e4 | 309 | dev_err(&port->dev, "%s - out of memory.\n", __func__); |
1da177e4 LT |
310 | return -ENOMEM; |
311 | } | |
e0d795e4 | 312 | kfree(port->read_urb->transfer_buffer); |
1da177e4 LT |
313 | port->read_urb->transfer_buffer = buffer; |
314 | port->read_urb->transfer_buffer_length = buffer_size; | |
315 | ||
e0d795e4 | 316 | buffer = kmalloc(buffer_size, GFP_KERNEL); |
1da177e4 | 317 | if (!buffer) { |
e0d795e4 | 318 | dev_err(&port->dev, "%s - out of memory.\n", __func__); |
1da177e4 LT |
319 | return -ENOMEM; |
320 | } | |
e0d795e4 | 321 | kfree(port->write_urb->transfer_buffer); |
1da177e4 LT |
322 | port->write_urb->transfer_buffer = buffer; |
323 | port->write_urb->transfer_buffer_length = buffer_size; | |
324 | port->bulk_out_size = buffer_size; | |
325 | } | |
326 | ||
327 | /* Start reading from the device */ | |
e0d795e4 | 328 | usb_fill_bulk_urb( |
1da177e4 | 329 | port->read_urb, |
e0d795e4 FB |
330 | port->serial->dev, |
331 | usb_rcvbulkpipe(port->serial->dev, | |
332 | port->bulk_in_endpointAddress), | |
1da177e4 LT |
333 | port->read_urb->transfer_buffer, |
334 | port->read_urb->transfer_buffer_length, | |
335 | ir_read_bulk_callback, | |
336 | port); | |
337 | result = usb_submit_urb(port->read_urb, GFP_KERNEL); | |
338 | if (result) | |
e0d795e4 FB |
339 | dev_err(&port->dev, |
340 | "%s - failed submitting read urb, error %d\n", | |
341 | __func__, result); | |
1da177e4 LT |
342 | |
343 | return result; | |
344 | } | |
345 | ||
335f8514 | 346 | static void ir_close(struct usb_serial_port *port) |
1da177e4 | 347 | { |
441b62c1 | 348 | dbg("%s - port %d", __func__, port->number); |
e0d795e4 | 349 | |
1da177e4 LT |
350 | /* shutdown our bulk read */ |
351 | usb_kill_urb(port->read_urb); | |
352 | } | |
353 | ||
95da310e AC |
354 | static int ir_write(struct tty_struct *tty, struct usb_serial_port *port, |
355 | const unsigned char *buf, int count) | |
1da177e4 LT |
356 | { |
357 | unsigned char *transfer_buffer; | |
358 | int result; | |
359 | int transfer_size; | |
360 | ||
441b62c1 | 361 | dbg("%s - port = %d, count = %d", __func__, port->number, count); |
1da177e4 | 362 | |
1da177e4 LT |
363 | if (count == 0) |
364 | return 0; | |
365 | ||
e81ee637 | 366 | spin_lock_bh(&port->lock); |
507ca9bc | 367 | if (port->write_urb_busy) { |
e81ee637 | 368 | spin_unlock_bh(&port->lock); |
441b62c1 | 369 | dbg("%s - already writing", __func__); |
1da177e4 LT |
370 | return 0; |
371 | } | |
507ca9bc | 372 | port->write_urb_busy = 1; |
e81ee637 | 373 | spin_unlock_bh(&port->lock); |
1da177e4 LT |
374 | |
375 | transfer_buffer = port->write_urb->transfer_buffer; | |
376 | transfer_size = min(count, port->bulk_out_size - 1); | |
377 | ||
378 | /* | |
379 | * The first byte of the packet we send to the device contains an | |
e0d795e4 | 380 | * inbound header which indicates an additional number of BOFs and |
1da177e4 LT |
381 | * a baud rate change. |
382 | * | |
383 | * See section 5.4.2.2 of the USB IrDA spec. | |
384 | */ | |
385 | *transfer_buffer = ir_xbof | ir_baud; | |
386 | ++transfer_buffer; | |
387 | ||
e0d795e4 | 388 | memcpy(transfer_buffer, buf, transfer_size); |
1da177e4 | 389 | |
e0d795e4 | 390 | usb_fill_bulk_urb( |
1da177e4 LT |
391 | port->write_urb, |
392 | port->serial->dev, | |
393 | usb_sndbulkpipe(port->serial->dev, | |
394 | port->bulk_out_endpointAddress), | |
395 | port->write_urb->transfer_buffer, | |
396 | transfer_size + 1, | |
397 | ir_write_bulk_callback, | |
398 | port); | |
399 | ||
400 | port->write_urb->transfer_flags = URB_ZERO_PACKET; | |
401 | ||
e0d795e4 | 402 | result = usb_submit_urb(port->write_urb, GFP_ATOMIC); |
507ca9bc GKH |
403 | if (result) { |
404 | port->write_urb_busy = 0; | |
e0d795e4 FB |
405 | dev_err(&port->dev, |
406 | "%s - failed submitting write urb, error %d\n", | |
407 | __func__, result); | |
507ca9bc | 408 | } else |
1da177e4 LT |
409 | result = transfer_size; |
410 | ||
411 | return result; | |
412 | } | |
413 | ||
e0d795e4 | 414 | static void ir_write_bulk_callback(struct urb *urb) |
1da177e4 | 415 | { |
cdc97792 | 416 | struct usb_serial_port *port = urb->context; |
3152b74f | 417 | int status = urb->status; |
1da177e4 | 418 | |
441b62c1 | 419 | dbg("%s - port %d", __func__, port->number); |
507ca9bc GKH |
420 | |
421 | port->write_urb_busy = 0; | |
3152b74f GKH |
422 | if (status) { |
423 | dbg("%s - nonzero write bulk status received: %d", | |
441b62c1 | 424 | __func__, status); |
1da177e4 LT |
425 | return; |
426 | } | |
427 | ||
e0d795e4 | 428 | usb_serial_debug_data( |
1da177e4 LT |
429 | debug, |
430 | &port->dev, | |
441b62c1 | 431 | __func__, |
1da177e4 LT |
432 | urb->actual_length, |
433 | urb->transfer_buffer); | |
434 | ||
cf2c7481 | 435 | usb_serial_port_softint(port); |
1da177e4 LT |
436 | } |
437 | ||
e0d795e4 | 438 | static void ir_read_bulk_callback(struct urb *urb) |
1da177e4 | 439 | { |
cdc97792 | 440 | struct usb_serial_port *port = urb->context; |
1da177e4 LT |
441 | struct tty_struct *tty; |
442 | unsigned char *data = urb->transfer_buffer; | |
443 | int result; | |
3152b74f | 444 | int status = urb->status; |
1da177e4 | 445 | |
441b62c1 | 446 | dbg("%s - port %d", __func__, port->number); |
1da177e4 | 447 | |
95da310e | 448 | if (!port->port.count) { |
441b62c1 | 449 | dbg("%s - port closed.", __func__); |
1da177e4 LT |
450 | return; |
451 | } | |
452 | ||
3152b74f | 453 | switch (status) { |
e0d795e4 | 454 | case 0: /* Successful */ |
e0d795e4 FB |
455 | /* |
456 | * The first byte of the packet we get from the device | |
457 | * contains a busy indicator and baud rate change. | |
458 | * See section 5.4.1.2 of the USB IrDA spec. | |
459 | */ | |
460 | if ((*data & 0x0f) > 0) | |
461 | ir_baud = *data & 0x0f; | |
95da310e AC |
462 | usb_serial_debug_data(debug, &port->dev, __func__, |
463 | urb->actual_length, data); | |
4a90f09b | 464 | tty = tty_port_tty_get(&port->port); |
e0d795e4 | 465 | if (tty_buffer_request_room(tty, urb->actual_length - 1)) { |
95da310e | 466 | tty_insert_flip_string(tty, data+1, urb->actual_length - 1); |
e0d795e4 FB |
467 | tty_flip_buffer_push(tty); |
468 | } | |
4a90f09b | 469 | tty_kref_put(tty); |
1da177e4 | 470 | |
e0d795e4 FB |
471 | /* |
472 | * No break here. | |
473 | * We want to resubmit the urb so we can read | |
474 | * again. | |
475 | */ | |
476 | ||
477 | case -EPROTO: /* taking inspiration from pl2303.c */ | |
95da310e | 478 | /* Continue trying to always read */ |
e0d795e4 FB |
479 | usb_fill_bulk_urb( |
480 | port->read_urb, | |
95da310e | 481 | port->serial->dev, |
e0d795e4 FB |
482 | usb_rcvbulkpipe(port->serial->dev, |
483 | port->bulk_in_endpointAddress), | |
484 | port->read_urb->transfer_buffer, | |
485 | port->read_urb->transfer_buffer_length, | |
486 | ir_read_bulk_callback, | |
487 | port); | |
488 | ||
489 | result = usb_submit_urb(port->read_urb, GFP_ATOMIC); | |
490 | if (result) | |
95da310e | 491 | dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n", |
e0d795e4 | 492 | __func__, result); |
95da310e | 493 | break ; |
e0d795e4 FB |
494 | default: |
495 | dbg("%s - nonzero read bulk status received: %d", | |
95da310e AC |
496 | __func__, status); |
497 | break ; | |
1da177e4 | 498 | } |
1da177e4 LT |
499 | return; |
500 | } | |
501 | ||
95da310e AC |
502 | static void ir_set_termios(struct tty_struct *tty, |
503 | struct usb_serial_port *port, struct ktermios *old_termios) | |
1da177e4 LT |
504 | { |
505 | unsigned char *transfer_buffer; | |
1da177e4 | 506 | int result; |
a6ea438b AC |
507 | speed_t baud; |
508 | int ir_baud; | |
1da177e4 | 509 | |
441b62c1 | 510 | dbg("%s - port %d", __func__, port->number); |
1da177e4 | 511 | |
95da310e | 512 | baud = tty_get_baud_rate(tty); |
a6ea438b AC |
513 | |
514 | /* | |
515 | * FIXME, we should compare the baud request against the | |
516 | * capability stated in the IR header that we got in the | |
517 | * startup function. | |
518 | */ | |
519 | ||
520 | switch (baud) { | |
e0d795e4 FB |
521 | case 2400: |
522 | ir_baud = USB_IRDA_BR_2400; | |
523 | break; | |
524 | case 9600: | |
525 | ir_baud = USB_IRDA_BR_9600; | |
526 | break; | |
527 | case 19200: | |
528 | ir_baud = USB_IRDA_BR_19200; | |
529 | break; | |
530 | case 38400: | |
531 | ir_baud = USB_IRDA_BR_38400; | |
532 | break; | |
533 | case 57600: | |
534 | ir_baud = USB_IRDA_BR_57600; | |
535 | break; | |
536 | case 115200: | |
537 | ir_baud = USB_IRDA_BR_115200; | |
538 | break; | |
539 | case 576000: | |
540 | ir_baud = USB_IRDA_BR_576000; | |
541 | break; | |
542 | case 1152000: | |
543 | ir_baud = USB_IRDA_BR_1152000; | |
544 | break; | |
545 | case 4000000: | |
546 | ir_baud = USB_IRDA_BR_4000000; | |
547 | break; | |
548 | default: | |
549 | ir_baud = USB_IRDA_BR_9600; | |
550 | baud = 9600; | |
1da177e4 LT |
551 | } |
552 | ||
a6ea438b AC |
553 | if (xbof == -1) |
554 | ir_xbof = ir_xbof_change(ir_add_bof); | |
555 | else | |
556 | ir_xbof = ir_xbof_change(xbof) ; | |
1da177e4 | 557 | |
a6ea438b AC |
558 | /* FIXME need to check to see if our write urb is busy right |
559 | * now, or use a urb pool. | |
560 | * | |
561 | * send the baud change out on an "empty" data packet | |
562 | */ | |
563 | transfer_buffer = port->write_urb->transfer_buffer; | |
564 | *transfer_buffer = ir_xbof | ir_baud; | |
1da177e4 | 565 | |
e0d795e4 | 566 | usb_fill_bulk_urb( |
a6ea438b AC |
567 | port->write_urb, |
568 | port->serial->dev, | |
e0d795e4 FB |
569 | usb_sndbulkpipe(port->serial->dev, |
570 | port->bulk_out_endpointAddress), | |
a6ea438b AC |
571 | port->write_urb->transfer_buffer, |
572 | 1, | |
573 | ir_write_bulk_callback, | |
574 | port); | |
575 | ||
576 | port->write_urb->transfer_flags = URB_ZERO_PACKET; | |
577 | ||
e0d795e4 | 578 | result = usb_submit_urb(port->write_urb, GFP_KERNEL); |
a6ea438b | 579 | if (result) |
e0d795e4 FB |
580 | dev_err(&port->dev, |
581 | "%s - failed submitting write urb, error %d\n", | |
582 | __func__, result); | |
560aac22 AC |
583 | |
584 | /* Only speed changes are supported */ | |
95da310e AC |
585 | tty_termios_copy_hw(tty->termios, old_termios); |
586 | tty_encode_baud_rate(tty, baud, baud); | |
1da177e4 LT |
587 | } |
588 | ||
e0d795e4 | 589 | static int __init ir_init(void) |
1da177e4 LT |
590 | { |
591 | int retval; | |
e0d795e4 | 592 | |
1da177e4 LT |
593 | retval = usb_serial_register(&ir_device); |
594 | if (retval) | |
595 | goto failed_usb_serial_register; | |
e0d795e4 | 596 | |
1da177e4 | 597 | retval = usb_register(&ir_driver); |
e0d795e4 | 598 | if (retval) |
1da177e4 | 599 | goto failed_usb_register; |
e0d795e4 | 600 | |
c197a8db GKH |
601 | printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" |
602 | DRIVER_DESC "\n"); | |
e0d795e4 | 603 | |
1da177e4 | 604 | return 0; |
e0d795e4 | 605 | |
1da177e4 LT |
606 | failed_usb_register: |
607 | usb_serial_deregister(&ir_device); | |
e0d795e4 | 608 | |
1da177e4 LT |
609 | failed_usb_serial_register: |
610 | return retval; | |
611 | } | |
612 | ||
e0d795e4 | 613 | static void __exit ir_exit(void) |
1da177e4 | 614 | { |
e0d795e4 FB |
615 | usb_deregister(&ir_driver); |
616 | usb_serial_deregister(&ir_device); | |
1da177e4 LT |
617 | } |
618 | ||
619 | ||
620 | module_init(ir_init); | |
621 | module_exit(ir_exit); | |
622 | ||
623 | MODULE_AUTHOR(DRIVER_AUTHOR); | |
624 | MODULE_DESCRIPTION(DRIVER_DESC); | |
625 | MODULE_LICENSE("GPL"); | |
626 | ||
627 | module_param(debug, bool, S_IRUGO | S_IWUSR); | |
628 | MODULE_PARM_DESC(debug, "Debug enabled or not"); | |
629 | module_param(xbof, int, 0); | |
630 | MODULE_PARM_DESC(xbof, "Force specific number of XBOFs"); | |
631 | module_param(buffer_size, int, 0); | |
632 | MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers"); | |
633 |