?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.16.11
[linux/fpc-iii.git] / drivers / usb / serial / keyspan.c
blobd34779fe4a8d046e616cdb2e32c3258cda0c218f
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 Keyspan USB to Serial Converter driver
4
5 (C) Copyright (C) 2000-2001 Hugh Blemings <hugh@blemings.org>
6 (C) Copyright (C) 2002 Greg Kroah-Hartman <greg@kroah.com>
7
8 See http://blemings.org/hugh/keyspan.html for more information.
9
10 Code in this driver inspired by and in a number of places taken
11 from Brian Warner's original Keyspan-PDA driver.
12
13 This driver has been put together with the support of Innosys, Inc.
14 and Keyspan, Inc the manufacturers of the Keyspan USB-serial products.
15 Thanks Guys :)
16
17 Thanks to Paulus for miscellaneous tidy ups, some largish chunks
18 of much nicer and/or completely new code and (perhaps most uniquely)
19 having the patience to sit down and explain why and where he'd changed
20 stuff.
21
22 Tip 'o the hat to IBM (and previously Linuxcare :) for supporting
23 staff in their work on open source projects.
24 */
25
26
27 #include <linux/kernel.h>
28 #include <linux/jiffies.h>
29 #include <linux/errno.h>
30 #include <linux/slab.h>
31 #include <linux/tty.h>
32 #include <linux/tty_driver.h>
33 #include <linux/tty_flip.h>
34 #include <linux/module.h>
35 #include <linux/spinlock.h>
36 #include <linux/uaccess.h>
37 #include <linux/usb.h>
38 #include <linux/usb/serial.h>
39 #include <linux/usb/ezusb.h>
40
41 #define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu"
42 #define DRIVER_DESC "Keyspan USB to Serial Converter Driver"
43
44 /* Function prototypes for Keyspan serial converter */
45 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port);
46 static void keyspan_close(struct usb_serial_port *port);
47 static void keyspan_dtr_rts(struct usb_serial_port *port, int on);
48 static int keyspan_startup(struct usb_serial *serial);
49 static void keyspan_disconnect(struct usb_serial *serial);
50 static void keyspan_release(struct usb_serial *serial);
51 static int keyspan_port_probe(struct usb_serial_port *port);
52 static int keyspan_port_remove(struct usb_serial_port *port);
53 static int keyspan_write_room(struct tty_struct *tty);
54 static int keyspan_write(struct tty_struct *tty, struct usb_serial_port *port,
55 const unsigned char *buf, int count);
56 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port);
57 static void keyspan_set_termios(struct tty_struct *tty,
58 struct usb_serial_port *port,
59 struct ktermios *old);
60 static void keyspan_break_ctl(struct tty_struct *tty, int break_state);
61 static int keyspan_tiocmget(struct tty_struct *tty);
62 static int keyspan_tiocmset(struct tty_struct *tty, unsigned int set,
63 unsigned int clear);
64 static int keyspan_fake_startup(struct usb_serial *serial);
65
66 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
67 u32 baud_rate, u32 baudclk,
68 u8 *rate_hi, u8 *rate_low,
69 u8 *prescaler, int portnum);
70 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
71 u32 baud_rate, u32 baudclk,
72 u8 *rate_hi, u8 *rate_low,
73 u8 *prescaler, int portnum);
74 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
75 u32 baud_rate, u32 baudclk,
76 u8 *rate_hi, u8 *rate_low,
77 u8 *prescaler, int portnum);
78 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
79 u32 baud_rate, u32 baudclk,
80 u8 *rate_hi, u8 *rate_low,
81 u8 *prescaler, int portnum);
82
83 static int keyspan_usa28_send_setup(struct usb_serial *serial,
84 struct usb_serial_port *port,
85 int reset_port);
86 static int keyspan_usa26_send_setup(struct usb_serial *serial,
87 struct usb_serial_port *port,
88 int reset_port);
89 static int keyspan_usa49_send_setup(struct usb_serial *serial,
90 struct usb_serial_port *port,
91 int reset_port);
92 static int keyspan_usa90_send_setup(struct usb_serial *serial,
93 struct usb_serial_port *port,
94 int reset_port);
95 static int keyspan_usa67_send_setup(struct usb_serial *serial,
96 struct usb_serial_port *port,
97 int reset_port);
98
99 /* Values used for baud rate calculation - device specific */
100 #define KEYSPAN_INVALID_BAUD_RATE (-1)
101 #define KEYSPAN_BAUD_RATE_OK (0)
102 #define KEYSPAN_USA18X_BAUDCLK (12000000L) /* a guess */
103 #define KEYSPAN_USA19_BAUDCLK (12000000L)
104 #define KEYSPAN_USA19W_BAUDCLK (24000000L)
105 #define KEYSPAN_USA19HS_BAUDCLK (14769231L)
106 #define KEYSPAN_USA28_BAUDCLK (1843200L)
107 #define KEYSPAN_USA28X_BAUDCLK (12000000L)
108 #define KEYSPAN_USA49W_BAUDCLK (48000000L)
109
110 /* Some constants used to characterise each device. */
111 #define KEYSPAN_MAX_NUM_PORTS (4)
112 #define KEYSPAN_MAX_FLIPS (2)
113
114 /*
115 * Device info for the Keyspan serial converter, used by the overall
116 * usb-serial probe function.
117 */
118 #define KEYSPAN_VENDOR_ID (0x06cd)
119
120 /* Product IDs for the products supported, pre-renumeration */
121 #define keyspan_usa18x_pre_product_id 0x0105
122 #define keyspan_usa19_pre_product_id 0x0103
123 #define keyspan_usa19qi_pre_product_id 0x010b
124 #define keyspan_mpr_pre_product_id 0x011b
125 #define keyspan_usa19qw_pre_product_id 0x0118
126 #define keyspan_usa19w_pre_product_id 0x0106
127 #define keyspan_usa28_pre_product_id 0x0101
128 #define keyspan_usa28x_pre_product_id 0x0102
129 #define keyspan_usa28xa_pre_product_id 0x0114
130 #define keyspan_usa28xb_pre_product_id 0x0113
131 #define keyspan_usa49w_pre_product_id 0x0109
132 #define keyspan_usa49wlc_pre_product_id 0x011a
133
134 /*
135 * Product IDs post-renumeration. Note that the 28x and 28xb have the same
136 * id's post-renumeration but behave identically so it's not an issue. As
137 * such, the 28xb is not listed in any of the device tables.
138 */
139 #define keyspan_usa18x_product_id 0x0112
140 #define keyspan_usa19_product_id 0x0107
141 #define keyspan_usa19qi_product_id 0x010c
142 #define keyspan_usa19hs_product_id 0x0121
143 #define keyspan_mpr_product_id 0x011c
144 #define keyspan_usa19qw_product_id 0x0119
145 #define keyspan_usa19w_product_id 0x0108
146 #define keyspan_usa28_product_id 0x010f
147 #define keyspan_usa28x_product_id 0x0110
148 #define keyspan_usa28xa_product_id 0x0115
149 #define keyspan_usa28xb_product_id 0x0110
150 #define keyspan_usa28xg_product_id 0x0135
151 #define keyspan_usa49w_product_id 0x010a
152 #define keyspan_usa49wlc_product_id 0x012a
153 #define keyspan_usa49wg_product_id 0x0131
154
155 struct keyspan_device_details {
156 /* product ID value */
157 int product_id;
158
159 enum {msg_usa26, msg_usa28, msg_usa49, msg_usa90, msg_usa67} msg_format;
160
161 /* Number of physical ports */
162 int num_ports;
163
164 /* 1 if endpoint flipping used on input, 0 if not */
165 int indat_endp_flip;
166
167 /* 1 if endpoint flipping used on output, 0 if not */
168 int outdat_endp_flip;
169
170 /*
171 * Table mapping input data endpoint IDs to physical port
172 * number and flip if used
173 */
174 int indat_endpoints[KEYSPAN_MAX_NUM_PORTS];
175
176 /* Same for output endpoints */
177 int outdat_endpoints[KEYSPAN_MAX_NUM_PORTS];
178
179 /* Input acknowledge endpoints */
180 int inack_endpoints[KEYSPAN_MAX_NUM_PORTS];
181
182 /* Output control endpoints */
183 int outcont_endpoints[KEYSPAN_MAX_NUM_PORTS];
184
185 /* Endpoint used for input status */
186 int instat_endpoint;
187
188 /* Endpoint used for input data 49WG only */
189 int indat_endpoint;
190
191 /* Endpoint used for global control functions */
192 int glocont_endpoint;
193
194 int (*calculate_baud_rate)(struct usb_serial_port *port,
195 u32 baud_rate, u32 baudclk,
196 u8 *rate_hi, u8 *rate_low, u8 *prescaler,
197 int portnum);
198 u32 baudclk;
199 };
200
201 /*
202 * Now for each device type we setup the device detail structure with the
203 * appropriate information (provided in Keyspan's documentation)
204 */
205
206 static const struct keyspan_device_details usa18x_device_details = {
207 .product_id = keyspan_usa18x_product_id,
208 .msg_format = msg_usa26,
209 .num_ports = 1,
210 .indat_endp_flip = 0,
211 .outdat_endp_flip = 1,
212 .indat_endpoints = {0x81},
213 .outdat_endpoints = {0x01},
214 .inack_endpoints = {0x85},
215 .outcont_endpoints = {0x05},
216 .instat_endpoint = 0x87,
217 .indat_endpoint = -1,
218 .glocont_endpoint = 0x07,
219 .calculate_baud_rate = keyspan_usa19w_calc_baud,
220 .baudclk = KEYSPAN_USA18X_BAUDCLK,
221 };
222
223 static const struct keyspan_device_details usa19_device_details = {
224 .product_id = keyspan_usa19_product_id,
225 .msg_format = msg_usa28,
226 .num_ports = 1,
227 .indat_endp_flip = 1,
228 .outdat_endp_flip = 1,
229 .indat_endpoints = {0x81},
230 .outdat_endpoints = {0x01},
231 .inack_endpoints = {0x83},
232 .outcont_endpoints = {0x03},
233 .instat_endpoint = 0x84,
234 .indat_endpoint = -1,
235 .glocont_endpoint = -1,
236 .calculate_baud_rate = keyspan_usa19_calc_baud,
237 .baudclk = KEYSPAN_USA19_BAUDCLK,
238 };
239
240 static const struct keyspan_device_details usa19qi_device_details = {
241 .product_id = keyspan_usa19qi_product_id,
242 .msg_format = msg_usa28,
243 .num_ports = 1,
244 .indat_endp_flip = 1,
245 .outdat_endp_flip = 1,
246 .indat_endpoints = {0x81},
247 .outdat_endpoints = {0x01},
248 .inack_endpoints = {0x83},
249 .outcont_endpoints = {0x03},
250 .instat_endpoint = 0x84,
251 .indat_endpoint = -1,
252 .glocont_endpoint = -1,
253 .calculate_baud_rate = keyspan_usa28_calc_baud,
254 .baudclk = KEYSPAN_USA19_BAUDCLK,
255 };
256
257 static const struct keyspan_device_details mpr_device_details = {
258 .product_id = keyspan_mpr_product_id,
259 .msg_format = msg_usa28,
260 .num_ports = 1,
261 .indat_endp_flip = 1,
262 .outdat_endp_flip = 1,
263 .indat_endpoints = {0x81},
264 .outdat_endpoints = {0x01},
265 .inack_endpoints = {0x83},
266 .outcont_endpoints = {0x03},
267 .instat_endpoint = 0x84,
268 .indat_endpoint = -1,
269 .glocont_endpoint = -1,
270 .calculate_baud_rate = keyspan_usa28_calc_baud,
271 .baudclk = KEYSPAN_USA19_BAUDCLK,
272 };
273
274 static const struct keyspan_device_details usa19qw_device_details = {
275 .product_id = keyspan_usa19qw_product_id,
276 .msg_format = msg_usa26,
277 .num_ports = 1,
278 .indat_endp_flip = 0,
279 .outdat_endp_flip = 1,
280 .indat_endpoints = {0x81},
281 .outdat_endpoints = {0x01},
282 .inack_endpoints = {0x85},
283 .outcont_endpoints = {0x05},
284 .instat_endpoint = 0x87,
285 .indat_endpoint = -1,
286 .glocont_endpoint = 0x07,
287 .calculate_baud_rate = keyspan_usa19w_calc_baud,
288 .baudclk = KEYSPAN_USA19W_BAUDCLK,
289 };
290
291 static const struct keyspan_device_details usa19w_device_details = {
292 .product_id = keyspan_usa19w_product_id,
293 .msg_format = msg_usa26,
294 .num_ports = 1,
295 .indat_endp_flip = 0,
296 .outdat_endp_flip = 1,
297 .indat_endpoints = {0x81},
298 .outdat_endpoints = {0x01},
299 .inack_endpoints = {0x85},
300 .outcont_endpoints = {0x05},
301 .instat_endpoint = 0x87,
302 .indat_endpoint = -1,
303 .glocont_endpoint = 0x07,
304 .calculate_baud_rate = keyspan_usa19w_calc_baud,
305 .baudclk = KEYSPAN_USA19W_BAUDCLK,
306 };
307
308 static const struct keyspan_device_details usa19hs_device_details = {
309 .product_id = keyspan_usa19hs_product_id,
310 .msg_format = msg_usa90,
311 .num_ports = 1,
312 .indat_endp_flip = 0,
313 .outdat_endp_flip = 0,
314 .indat_endpoints = {0x81},
315 .outdat_endpoints = {0x01},
316 .inack_endpoints = {-1},
317 .outcont_endpoints = {0x02},
318 .instat_endpoint = 0x82,
319 .indat_endpoint = -1,
320 .glocont_endpoint = -1,
321 .calculate_baud_rate = keyspan_usa19hs_calc_baud,
322 .baudclk = KEYSPAN_USA19HS_BAUDCLK,
323 };
324
325 static const struct keyspan_device_details usa28_device_details = {
326 .product_id = keyspan_usa28_product_id,
327 .msg_format = msg_usa28,
328 .num_ports = 2,
329 .indat_endp_flip = 1,
330 .outdat_endp_flip = 1,
331 .indat_endpoints = {0x81, 0x83},
332 .outdat_endpoints = {0x01, 0x03},
333 .inack_endpoints = {0x85, 0x86},
334 .outcont_endpoints = {0x05, 0x06},
335 .instat_endpoint = 0x87,
336 .indat_endpoint = -1,
337 .glocont_endpoint = 0x07,
338 .calculate_baud_rate = keyspan_usa28_calc_baud,
339 .baudclk = KEYSPAN_USA28_BAUDCLK,
340 };
341
342 static const struct keyspan_device_details usa28x_device_details = {
343 .product_id = keyspan_usa28x_product_id,
344 .msg_format = msg_usa26,
345 .num_ports = 2,
346 .indat_endp_flip = 0,
347 .outdat_endp_flip = 1,
348 .indat_endpoints = {0x81, 0x83},
349 .outdat_endpoints = {0x01, 0x03},
350 .inack_endpoints = {0x85, 0x86},
351 .outcont_endpoints = {0x05, 0x06},
352 .instat_endpoint = 0x87,
353 .indat_endpoint = -1,
354 .glocont_endpoint = 0x07,
355 .calculate_baud_rate = keyspan_usa19w_calc_baud,
356 .baudclk = KEYSPAN_USA28X_BAUDCLK,
357 };
358
359 static const struct keyspan_device_details usa28xa_device_details = {
360 .product_id = keyspan_usa28xa_product_id,
361 .msg_format = msg_usa26,
362 .num_ports = 2,
363 .indat_endp_flip = 0,
364 .outdat_endp_flip = 1,
365 .indat_endpoints = {0x81, 0x83},
366 .outdat_endpoints = {0x01, 0x03},
367 .inack_endpoints = {0x85, 0x86},
368 .outcont_endpoints = {0x05, 0x06},
369 .instat_endpoint = 0x87,
370 .indat_endpoint = -1,
371 .glocont_endpoint = 0x07,
372 .calculate_baud_rate = keyspan_usa19w_calc_baud,
373 .baudclk = KEYSPAN_USA28X_BAUDCLK,
374 };
375
376 static const struct keyspan_device_details usa28xg_device_details = {
377 .product_id = keyspan_usa28xg_product_id,
378 .msg_format = msg_usa67,
379 .num_ports = 2,
380 .indat_endp_flip = 0,
381 .outdat_endp_flip = 0,
382 .indat_endpoints = {0x84, 0x88},
383 .outdat_endpoints = {0x02, 0x06},
384 .inack_endpoints = {-1, -1},
385 .outcont_endpoints = {-1, -1},
386 .instat_endpoint = 0x81,
387 .indat_endpoint = -1,
388 .glocont_endpoint = 0x01,
389 .calculate_baud_rate = keyspan_usa19w_calc_baud,
390 .baudclk = KEYSPAN_USA28X_BAUDCLK,
391 };
392 /*
393 * We don't need a separate entry for the usa28xb as it appears as a 28x
394 * anyway.
395 */
396
397 static const struct keyspan_device_details usa49w_device_details = {
398 .product_id = keyspan_usa49w_product_id,
399 .msg_format = msg_usa49,
400 .num_ports = 4,
401 .indat_endp_flip = 0,
402 .outdat_endp_flip = 0,
403 .indat_endpoints = {0x81, 0x82, 0x83, 0x84},
404 .outdat_endpoints = {0x01, 0x02, 0x03, 0x04},
405 .inack_endpoints = {-1, -1, -1, -1},
406 .outcont_endpoints = {-1, -1, -1, -1},
407 .instat_endpoint = 0x87,
408 .indat_endpoint = -1,
409 .glocont_endpoint = 0x07,
410 .calculate_baud_rate = keyspan_usa19w_calc_baud,
411 .baudclk = KEYSPAN_USA49W_BAUDCLK,
412 };
413
414 static const struct keyspan_device_details usa49wlc_device_details = {
415 .product_id = keyspan_usa49wlc_product_id,
416 .msg_format = msg_usa49,
417 .num_ports = 4,
418 .indat_endp_flip = 0,
419 .outdat_endp_flip = 0,
420 .indat_endpoints = {0x81, 0x82, 0x83, 0x84},
421 .outdat_endpoints = {0x01, 0x02, 0x03, 0x04},
422 .inack_endpoints = {-1, -1, -1, -1},
423 .outcont_endpoints = {-1, -1, -1, -1},
424 .instat_endpoint = 0x87,
425 .indat_endpoint = -1,
426 .glocont_endpoint = 0x07,
427 .calculate_baud_rate = keyspan_usa19w_calc_baud,
428 .baudclk = KEYSPAN_USA19W_BAUDCLK,
429 };
430
431 static const struct keyspan_device_details usa49wg_device_details = {
432 .product_id = keyspan_usa49wg_product_id,
433 .msg_format = msg_usa49,
434 .num_ports = 4,
435 .indat_endp_flip = 0,
436 .outdat_endp_flip = 0,
437 .indat_endpoints = {-1, -1, -1, -1}, /* single 'global' data in EP */
438 .outdat_endpoints = {0x01, 0x02, 0x04, 0x06},
439 .inack_endpoints = {-1, -1, -1, -1},
440 .outcont_endpoints = {-1, -1, -1, -1},
441 .instat_endpoint = 0x81,
442 .indat_endpoint = 0x88,
443 .glocont_endpoint = 0x00, /* uses control EP */
444 .calculate_baud_rate = keyspan_usa19w_calc_baud,
445 .baudclk = KEYSPAN_USA19W_BAUDCLK,
446 };
447
448 static const struct keyspan_device_details *keyspan_devices[] = {
449 &usa18x_device_details,
450 &usa19_device_details,
451 &usa19qi_device_details,
452 &mpr_device_details,
453 &usa19qw_device_details,
454 &usa19w_device_details,
455 &usa19hs_device_details,
456 &usa28_device_details,
457 &usa28x_device_details,
458 &usa28xa_device_details,
459 &usa28xg_device_details,
460 /* 28xb not required as it renumerates as a 28x */
461 &usa49w_device_details,
462 &usa49wlc_device_details,
463 &usa49wg_device_details,
464 NULL,
465 };
466
467 static const struct usb_device_id keyspan_ids_combined[] = {
468 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_pre_product_id) },
469 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_pre_product_id) },
470 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_pre_product_id) },
471 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_pre_product_id) },
472 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_pre_product_id) },
473 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_pre_product_id) },
474 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_pre_product_id) },
475 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_pre_product_id) },
476 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_pre_product_id) },
477 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xb_pre_product_id) },
478 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_pre_product_id) },
479 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_pre_product_id) },
480 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_product_id) },
481 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_product_id) },
482 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_product_id) },
483 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_product_id) },
484 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_product_id) },
485 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19hs_product_id) },
486 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_product_id) },
487 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) },
488 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) },
489 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) },
490 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xg_product_id) },
491 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_product_id)},
492 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_product_id)},
493 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wg_product_id)},
494 { } /* Terminating entry */
495 };
496
497 MODULE_DEVICE_TABLE(usb, keyspan_ids_combined);
498
499 /* usb_device_id table for the pre-firmware download keyspan devices */
500 static const struct usb_device_id keyspan_pre_ids[] = {
501 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_pre_product_id) },
502 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_pre_product_id) },
503 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_pre_product_id) },
504 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_pre_product_id) },
505 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_pre_product_id) },
506 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_pre_product_id) },
507 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_pre_product_id) },
508 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_pre_product_id) },
509 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_pre_product_id) },
510 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xb_pre_product_id) },
511 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_pre_product_id) },
512 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_pre_product_id) },
513 { } /* Terminating entry */
514 };
515
516 static const struct usb_device_id keyspan_1port_ids[] = {
517 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_product_id) },
518 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_product_id) },
519 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_product_id) },
520 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_product_id) },
521 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_product_id) },
522 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19hs_product_id) },
523 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_product_id) },
524 { } /* Terminating entry */
525 };
526
527 static const struct usb_device_id keyspan_2port_ids[] = {
528 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) },
529 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) },
530 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) },
531 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xg_product_id) },
532 { } /* Terminating entry */
533 };
534
535 static const struct usb_device_id keyspan_4port_ids[] = {
536 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_product_id) },
537 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_product_id)},
538 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wg_product_id)},
539 { } /* Terminating entry */
540 };
541
542 #define INSTAT_BUFLEN 32
543 #define GLOCONT_BUFLEN 64
544 #define INDAT49W_BUFLEN 512
545 #define IN_BUFLEN 64
546 #define OUT_BUFLEN 64
547 #define INACK_BUFLEN 1
548 #define OUTCONT_BUFLEN 64
549
550 /* Per device and per port private data */
551 struct keyspan_serial_private {
552 const struct keyspan_device_details *device_details;
553
554 struct urb *instat_urb;
555 char *instat_buf;
556
557 /* added to support 49wg, where data from all 4 ports comes in
558 on 1 EP and high-speed supported */
559 struct urb *indat_urb;
560 char *indat_buf;
561
562 /* XXX this one probably will need a lock */
563 struct urb *glocont_urb;
564 char *glocont_buf;
565 char *ctrl_buf; /* for EP0 control message */
566 };
567
568 struct keyspan_port_private {
569 /* Keep track of which input & output endpoints to use */
570 int in_flip;
571 int out_flip;
572
573 /* Keep duplicate of device details in each port
574 structure as well - simplifies some of the
575 callback functions etc. */
576 const struct keyspan_device_details *device_details;
577
578 /* Input endpoints and buffer for this port */
579 struct urb *in_urbs[2];
580 char *in_buffer[2];
581 /* Output endpoints and buffer for this port */
582 struct urb *out_urbs[2];
583 char *out_buffer[2];
584
585 /* Input ack endpoint */
586 struct urb *inack_urb;
587 char *inack_buffer;
588
589 /* Output control endpoint */
590 struct urb *outcont_urb;
591 char *outcont_buffer;
592
593 /* Settings for the port */
594 int baud;
595 int old_baud;
596 unsigned int cflag;
597 unsigned int old_cflag;
598 enum {flow_none, flow_cts, flow_xon} flow_control;
599 int rts_state; /* Handshaking pins (outputs) */
600 int dtr_state;
601 int cts_state; /* Handshaking pins (inputs) */
602 int dsr_state;
603 int dcd_state;
604 int ri_state;
605 int break_on;
606
607 unsigned long tx_start_time[2];
608 int resend_cont; /* need to resend control packet */
609 };
610
611 /* Include Keyspan message headers. All current Keyspan Adapters
612 make use of one of five message formats which are referred
613 to as USA-26, USA-28, USA-49, USA-90, USA-67 by Keyspan and
614 within this driver. */
615 #include "keyspan_usa26msg.h"
616 #include "keyspan_usa28msg.h"
617 #include "keyspan_usa49msg.h"
618 #include "keyspan_usa90msg.h"
619 #include "keyspan_usa67msg.h"
620
621
622 static void keyspan_break_ctl(struct tty_struct *tty, int break_state)
623 {
624 struct usb_serial_port *port = tty->driver_data;
625 struct keyspan_port_private *p_priv;
626
627 p_priv = usb_get_serial_port_data(port);
628
629 if (break_state == -1)
630 p_priv->break_on = 1;
631 else
632 p_priv->break_on = 0;
633
634 keyspan_send_setup(port, 0);
635 }
636
637
638 static void keyspan_set_termios(struct tty_struct *tty,
639 struct usb_serial_port *port, struct ktermios *old_termios)
640 {
641 int baud_rate, device_port;
642 struct keyspan_port_private *p_priv;
643 const struct keyspan_device_details *d_details;
644 unsigned int cflag;
645
646 p_priv = usb_get_serial_port_data(port);
647 d_details = p_priv->device_details;
648 cflag = tty->termios.c_cflag;
649 device_port = port->port_number;
650
651 /* Baud rate calculation takes baud rate as an integer
652 so other rates can be generated if desired. */
653 baud_rate = tty_get_baud_rate(tty);
654 /* If no match or invalid, don't change */
655 if (d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
656 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
657 /* FIXME - more to do here to ensure rate changes cleanly */
658 /* FIXME - calculate exact rate from divisor ? */
659 p_priv->baud = baud_rate;
660 } else
661 baud_rate = tty_termios_baud_rate(old_termios);
662
663 tty_encode_baud_rate(tty, baud_rate, baud_rate);
664 /* set CTS/RTS handshake etc. */
665 p_priv->cflag = cflag;
666 p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
667
668 /* Mark/Space not supported */
669 tty->termios.c_cflag &= ~CMSPAR;
670
671 keyspan_send_setup(port, 0);
672 }
673
674 static int keyspan_tiocmget(struct tty_struct *tty)
675 {
676 struct usb_serial_port *port = tty->driver_data;
677 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
678 unsigned int value;
679
680 value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
681 ((p_priv->dtr_state) ? TIOCM_DTR : 0) |
682 ((p_priv->cts_state) ? TIOCM_CTS : 0) |
683 ((p_priv->dsr_state) ? TIOCM_DSR : 0) |
684 ((p_priv->dcd_state) ? TIOCM_CAR : 0) |
685 ((p_priv->ri_state) ? TIOCM_RNG : 0);
686
687 return value;
688 }
689
690 static int keyspan_tiocmset(struct tty_struct *tty,
691 unsigned int set, unsigned int clear)
692 {
693 struct usb_serial_port *port = tty->driver_data;
694 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
695
696 if (set & TIOCM_RTS)
697 p_priv->rts_state = 1;
698 if (set & TIOCM_DTR)
699 p_priv->dtr_state = 1;
700 if (clear & TIOCM_RTS)
701 p_priv->rts_state = 0;
702 if (clear & TIOCM_DTR)
703 p_priv->dtr_state = 0;
704 keyspan_send_setup(port, 0);
705 return 0;
706 }
707
708 /* Write function is similar for the four protocols used
709 with only a minor change for usa90 (usa19hs) required */
710 static int keyspan_write(struct tty_struct *tty,
711 struct usb_serial_port *port, const unsigned char *buf, int count)
712 {
713 struct keyspan_port_private *p_priv;
714 const struct keyspan_device_details *d_details;
715 int flip;
716 int left, todo;
717 struct urb *this_urb;
718 int err, maxDataLen, dataOffset;
719
720 p_priv = usb_get_serial_port_data(port);
721 d_details = p_priv->device_details;
722
723 if (d_details->msg_format == msg_usa90) {
724 maxDataLen = 64;
725 dataOffset = 0;
726 } else {
727 maxDataLen = 63;
728 dataOffset = 1;
729 }
730
731 dev_dbg(&port->dev, "%s - %d chars, flip=%d\n", __func__, count,
732 p_priv->out_flip);
733
734 for (left = count; left > 0; left -= todo) {
735 todo = left;
736 if (todo > maxDataLen)
737 todo = maxDataLen;
738
739 flip = p_priv->out_flip;
740
741 /* Check we have a valid urb/endpoint before we use it... */
742 this_urb = p_priv->out_urbs[flip];
743 if (this_urb == NULL) {
744 /* no bulk out, so return 0 bytes written */
745 dev_dbg(&port->dev, "%s - no output urb :(\n", __func__);
746 return count;
747 }
748
749 dev_dbg(&port->dev, "%s - endpoint %x flip %d\n",
750 __func__, usb_pipeendpoint(this_urb->pipe), flip);
751
752 if (this_urb->status == -EINPROGRESS) {
753 if (time_before(jiffies,
754 p_priv->tx_start_time[flip] + 10 * HZ))
755 break;
756 usb_unlink_urb(this_urb);
757 break;
758 }
759
760 /* First byte in buffer is "last flag" (except for usa19hx)
761 - unused so for now so set to zero */
762 ((char *)this_urb->transfer_buffer)[0] = 0;
763
764 memcpy(this_urb->transfer_buffer + dataOffset, buf, todo);
765 buf += todo;
766
767 /* send the data out the bulk port */
768 this_urb->transfer_buffer_length = todo + dataOffset;
769
770 err = usb_submit_urb(this_urb, GFP_ATOMIC);
771 if (err != 0)
772 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed (%d)\n", err);
773 p_priv->tx_start_time[flip] = jiffies;
774
775 /* Flip for next time if usa26 or usa28 interface
776 (not used on usa49) */
777 p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip;
778 }
779
780 return count - left;
781 }
782
783 static void usa26_indat_callback(struct urb *urb)
784 {
785 int i, err;
786 int endpoint;
787 struct usb_serial_port *port;
788 unsigned char *data = urb->transfer_buffer;
789 int status = urb->status;
790
791 endpoint = usb_pipeendpoint(urb->pipe);
792
793 if (status) {
794 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
795 __func__, status, endpoint);
796 return;
797 }
798
799 port = urb->context;
800 if (urb->actual_length) {
801 /* 0x80 bit is error flag */
802 if ((data[0] & 0x80) == 0) {
803 /* no errors on individual bytes, only
804 possible overrun err */
805 if (data[0] & RXERROR_OVERRUN) {
806 tty_insert_flip_char(&port->port, 0,
807 TTY_OVERRUN);
808 }
809 for (i = 1; i < urb->actual_length ; ++i)
810 tty_insert_flip_char(&port->port, data[i],
811 TTY_NORMAL);
812 } else {
813 /* some bytes had errors, every byte has status */
814 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
815 for (i = 0; i + 1 < urb->actual_length; i += 2) {
816 int stat = data[i];
817 int flag = TTY_NORMAL;
818
819 if (stat & RXERROR_OVERRUN) {
820 tty_insert_flip_char(&port->port, 0,
821 TTY_OVERRUN);
822 }
823 /* XXX should handle break (0x10) */
824 if (stat & RXERROR_PARITY)
825 flag = TTY_PARITY;
826 else if (stat & RXERROR_FRAMING)
827 flag = TTY_FRAME;
828
829 tty_insert_flip_char(&port->port, data[i+1],
830 flag);
831 }
832 }
833 tty_flip_buffer_push(&port->port);
834 }
835
836 /* Resubmit urb so we continue receiving */
837 err = usb_submit_urb(urb, GFP_ATOMIC);
838 if (err != 0)
839 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
840 }
841
842 /* Outdat handling is common for all devices */
843 static void usa2x_outdat_callback(struct urb *urb)
844 {
845 struct usb_serial_port *port;
846 struct keyspan_port_private *p_priv;
847
848 port = urb->context;
849 p_priv = usb_get_serial_port_data(port);
850 dev_dbg(&port->dev, "%s - urb %d\n", __func__, urb == p_priv->out_urbs[1]);
851
852 usb_serial_port_softint(port);
853 }
854
855 static void usa26_inack_callback(struct urb *urb)
856 {
857 }
858
859 static void usa26_outcont_callback(struct urb *urb)
860 {
861 struct usb_serial_port *port;
862 struct keyspan_port_private *p_priv;
863
864 port = urb->context;
865 p_priv = usb_get_serial_port_data(port);
866
867 if (p_priv->resend_cont) {
868 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
869 keyspan_usa26_send_setup(port->serial, port,
870 p_priv->resend_cont - 1);
871 }
872 }
873
874 static void usa26_instat_callback(struct urb *urb)
875 {
876 unsigned char *data = urb->transfer_buffer;
877 struct keyspan_usa26_portStatusMessage *msg;
878 struct usb_serial *serial;
879 struct usb_serial_port *port;
880 struct keyspan_port_private *p_priv;
881 int old_dcd_state, err;
882 int status = urb->status;
883
884 serial = urb->context;
885
886 if (status) {
887 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
888 __func__, status);
889 return;
890 }
891 if (urb->actual_length != 9) {
892 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
893 goto exit;
894 }
895
896 msg = (struct keyspan_usa26_portStatusMessage *)data;
897
898 /* Check port number from message and retrieve private data */
899 if (msg->port >= serial->num_ports) {
900 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
901 goto exit;
902 }
903 port = serial->port[msg->port];
904 p_priv = usb_get_serial_port_data(port);
905 if (!p_priv)
906 goto resubmit;
907
908 /* Update handshaking pin state information */
909 old_dcd_state = p_priv->dcd_state;
910 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
911 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
912 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
913 p_priv->ri_state = ((msg->ri) ? 1 : 0);
914
915 if (old_dcd_state != p_priv->dcd_state)
916 tty_port_tty_hangup(&port->port, true);
917 resubmit:
918 /* Resubmit urb so we continue receiving */
919 err = usb_submit_urb(urb, GFP_ATOMIC);
920 if (err != 0)
921 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
922 exit: ;
923 }
924
925 static void usa26_glocont_callback(struct urb *urb)
926 {
927 }
928
929
930 static void usa28_indat_callback(struct urb *urb)
931 {
932 int err;
933 struct usb_serial_port *port;
934 unsigned char *data;
935 struct keyspan_port_private *p_priv;
936 int status = urb->status;
937
938 port = urb->context;
939 p_priv = usb_get_serial_port_data(port);
940 data = urb->transfer_buffer;
941
942 if (urb != p_priv->in_urbs[p_priv->in_flip])
943 return;
944
945 do {
946 if (status) {
947 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
948 __func__, status, usb_pipeendpoint(urb->pipe));
949 return;
950 }
951
952 port = urb->context;
953 p_priv = usb_get_serial_port_data(port);
954 data = urb->transfer_buffer;
955
956 if (urb->actual_length) {
957 tty_insert_flip_string(&port->port, data,
958 urb->actual_length);
959 tty_flip_buffer_push(&port->port);
960 }
961
962 /* Resubmit urb so we continue receiving */
963 err = usb_submit_urb(urb, GFP_ATOMIC);
964 if (err != 0)
965 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n",
966 __func__, err);
967 p_priv->in_flip ^= 1;
968
969 urb = p_priv->in_urbs[p_priv->in_flip];
970 } while (urb->status != -EINPROGRESS);
971 }
972
973 static void usa28_inack_callback(struct urb *urb)
974 {
975 }
976
977 static void usa28_outcont_callback(struct urb *urb)
978 {
979 struct usb_serial_port *port;
980 struct keyspan_port_private *p_priv;
981
982 port = urb->context;
983 p_priv = usb_get_serial_port_data(port);
984
985 if (p_priv->resend_cont) {
986 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
987 keyspan_usa28_send_setup(port->serial, port,
988 p_priv->resend_cont - 1);
989 }
990 }
991
992 static void usa28_instat_callback(struct urb *urb)
993 {
994 int err;
995 unsigned char *data = urb->transfer_buffer;
996 struct keyspan_usa28_portStatusMessage *msg;
997 struct usb_serial *serial;
998 struct usb_serial_port *port;
999 struct keyspan_port_private *p_priv;
1000 int old_dcd_state;
1001 int status = urb->status;
1002
1003 serial = urb->context;
1004
1005 if (status) {
1006 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1007 __func__, status);
1008 return;
1009 }
1010
1011 if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
1012 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
1013 goto exit;
1014 }
1015
1016 msg = (struct keyspan_usa28_portStatusMessage *)data;
1017
1018 /* Check port number from message and retrieve private data */
1019 if (msg->port >= serial->num_ports) {
1020 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
1021 goto exit;
1022 }
1023 port = serial->port[msg->port];
1024 p_priv = usb_get_serial_port_data(port);
1025 if (!p_priv)
1026 goto resubmit;
1027
1028 /* Update handshaking pin state information */
1029 old_dcd_state = p_priv->dcd_state;
1030 p_priv->cts_state = ((msg->cts) ? 1 : 0);
1031 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1032 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1033 p_priv->ri_state = ((msg->ri) ? 1 : 0);
1034
1035 if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1036 tty_port_tty_hangup(&port->port, true);
1037 resubmit:
1038 /* Resubmit urb so we continue receiving */
1039 err = usb_submit_urb(urb, GFP_ATOMIC);
1040 if (err != 0)
1041 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1042 exit: ;
1043 }
1044
1045 static void usa28_glocont_callback(struct urb *urb)
1046 {
1047 }
1048
1049
1050 static void usa49_glocont_callback(struct urb *urb)
1051 {
1052 struct usb_serial *serial;
1053 struct usb_serial_port *port;
1054 struct keyspan_port_private *p_priv;
1055 int i;
1056
1057 serial = urb->context;
1058 for (i = 0; i < serial->num_ports; ++i) {
1059 port = serial->port[i];
1060 p_priv = usb_get_serial_port_data(port);
1061
1062 if (p_priv->resend_cont) {
1063 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
1064 keyspan_usa49_send_setup(serial, port,
1065 p_priv->resend_cont - 1);
1066 break;
1067 }
1068 }
1069 }
1070
1071 /* This is actually called glostat in the Keyspan
1072 doco */
1073 static void usa49_instat_callback(struct urb *urb)
1074 {
1075 int err;
1076 unsigned char *data = urb->transfer_buffer;
1077 struct keyspan_usa49_portStatusMessage *msg;
1078 struct usb_serial *serial;
1079 struct usb_serial_port *port;
1080 struct keyspan_port_private *p_priv;
1081 int old_dcd_state;
1082 int status = urb->status;
1083
1084 serial = urb->context;
1085
1086 if (status) {
1087 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1088 __func__, status);
1089 return;
1090 }
1091
1092 if (urb->actual_length !=
1093 sizeof(struct keyspan_usa49_portStatusMessage)) {
1094 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
1095 goto exit;
1096 }
1097
1098 msg = (struct keyspan_usa49_portStatusMessage *)data;
1099
1100 /* Check port number from message and retrieve private data */
1101 if (msg->portNumber >= serial->num_ports) {
1102 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
1103 __func__, msg->portNumber);
1104 goto exit;
1105 }
1106 port = serial->port[msg->portNumber];
1107 p_priv = usb_get_serial_port_data(port);
1108 if (!p_priv)
1109 goto resubmit;
1110
1111 /* Update handshaking pin state information */
1112 old_dcd_state = p_priv->dcd_state;
1113 p_priv->cts_state = ((msg->cts) ? 1 : 0);
1114 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1115 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1116 p_priv->ri_state = ((msg->ri) ? 1 : 0);
1117
1118 if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1119 tty_port_tty_hangup(&port->port, true);
1120 resubmit:
1121 /* Resubmit urb so we continue receiving */
1122 err = usb_submit_urb(urb, GFP_ATOMIC);
1123 if (err != 0)
1124 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1125 exit: ;
1126 }
1127
1128 static void usa49_inack_callback(struct urb *urb)
1129 {
1130 }
1131
1132 static void usa49_indat_callback(struct urb *urb)
1133 {
1134 int i, err;
1135 int endpoint;
1136 struct usb_serial_port *port;
1137 unsigned char *data = urb->transfer_buffer;
1138 int status = urb->status;
1139
1140 endpoint = usb_pipeendpoint(urb->pipe);
1141
1142 if (status) {
1143 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
1144 __func__, status, endpoint);
1145 return;
1146 }
1147
1148 port = urb->context;
1149 if (urb->actual_length) {
1150 /* 0x80 bit is error flag */
1151 if ((data[0] & 0x80) == 0) {
1152 /* no error on any byte */
1153 tty_insert_flip_string(&port->port, data + 1,
1154 urb->actual_length - 1);
1155 } else {
1156 /* some bytes had errors, every byte has status */
1157 for (i = 0; i + 1 < urb->actual_length; i += 2) {
1158 int stat = data[i];
1159 int flag = TTY_NORMAL;
1160
1161 if (stat & RXERROR_OVERRUN) {
1162 tty_insert_flip_char(&port->port, 0,
1163 TTY_OVERRUN);
1164 }
1165 /* XXX should handle break (0x10) */
1166 if (stat & RXERROR_PARITY)
1167 flag = TTY_PARITY;
1168 else if (stat & RXERROR_FRAMING)
1169 flag = TTY_FRAME;
1170
1171 tty_insert_flip_char(&port->port, data[i+1],
1172 flag);
1173 }
1174 }
1175 tty_flip_buffer_push(&port->port);
1176 }
1177
1178 /* Resubmit urb so we continue receiving */
1179 err = usb_submit_urb(urb, GFP_ATOMIC);
1180 if (err != 0)
1181 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1182 }
1183
1184 static void usa49wg_indat_callback(struct urb *urb)
1185 {
1186 int i, len, x, err;
1187 struct usb_serial *serial;
1188 struct usb_serial_port *port;
1189 unsigned char *data = urb->transfer_buffer;
1190 int status = urb->status;
1191
1192 serial = urb->context;
1193
1194 if (status) {
1195 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1196 __func__, status);
1197 return;
1198 }
1199
1200 /* inbound data is in the form P#, len, status, data */
1201 i = 0;
1202 len = 0;
1203
1204 while (i < urb->actual_length) {
1205
1206 /* Check port number from message */
1207 if (data[i] >= serial->num_ports) {
1208 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
1209 __func__, data[i]);
1210 return;
1211 }
1212 port = serial->port[data[i++]];
1213 len = data[i++];
1214
1215 /* 0x80 bit is error flag */
1216 if ((data[i] & 0x80) == 0) {
1217 /* no error on any byte */
1218 i++;
1219 for (x = 1; x < len && i < urb->actual_length; ++x)
1220 tty_insert_flip_char(&port->port,
1221 data[i++], 0);
1222 } else {
1223 /*
1224 * some bytes had errors, every byte has status
1225 */
1226 for (x = 0; x + 1 < len &&
1227 i + 1 < urb->actual_length; x += 2) {
1228 int stat = data[i];
1229 int flag = TTY_NORMAL;
1230
1231 if (stat & RXERROR_OVERRUN) {
1232 tty_insert_flip_char(&port->port, 0,
1233 TTY_OVERRUN);
1234 }
1235 /* XXX should handle break (0x10) */
1236 if (stat & RXERROR_PARITY)
1237 flag = TTY_PARITY;
1238 else if (stat & RXERROR_FRAMING)
1239 flag = TTY_FRAME;
1240
1241 tty_insert_flip_char(&port->port, data[i+1],
1242 flag);
1243 i += 2;
1244 }
1245 }
1246 tty_flip_buffer_push(&port->port);
1247 }
1248
1249 /* Resubmit urb so we continue receiving */
1250 err = usb_submit_urb(urb, GFP_ATOMIC);
1251 if (err != 0)
1252 dev_dbg(&urb->dev->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1253 }
1254
1255 /* not used, usa-49 doesn't have per-port control endpoints */
1256 static void usa49_outcont_callback(struct urb *urb)
1257 {
1258 }
1259
1260 static void usa90_indat_callback(struct urb *urb)
1261 {
1262 int i, err;
1263 int endpoint;
1264 struct usb_serial_port *port;
1265 struct keyspan_port_private *p_priv;
1266 unsigned char *data = urb->transfer_buffer;
1267 int status = urb->status;
1268
1269 endpoint = usb_pipeendpoint(urb->pipe);
1270
1271 if (status) {
1272 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n",
1273 __func__, status, endpoint);
1274 return;
1275 }
1276
1277 port = urb->context;
1278 p_priv = usb_get_serial_port_data(port);
1279
1280 if (urb->actual_length) {
1281 /* if current mode is DMA, looks like usa28 format
1282 otherwise looks like usa26 data format */
1283
1284 if (p_priv->baud > 57600)
1285 tty_insert_flip_string(&port->port, data,
1286 urb->actual_length);
1287 else {
1288 /* 0x80 bit is error flag */
1289 if ((data[0] & 0x80) == 0) {
1290 /* no errors on individual bytes, only
1291 possible overrun err*/
1292 if (data[0] & RXERROR_OVERRUN) {
1293 tty_insert_flip_char(&port->port, 0,
1294 TTY_OVERRUN);
1295 }
1296 for (i = 1; i < urb->actual_length ; ++i)
1297 tty_insert_flip_char(&port->port,
1298 data[i], TTY_NORMAL);
1299 } else {
1300 /* some bytes had errors, every byte has status */
1301 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
1302 for (i = 0; i + 1 < urb->actual_length; i += 2) {
1303 int stat = data[i];
1304 int flag = TTY_NORMAL;
1305
1306 if (stat & RXERROR_OVERRUN) {
1307 tty_insert_flip_char(
1308 &port->port, 0,
1309 TTY_OVERRUN);
1310 }
1311 /* XXX should handle break (0x10) */
1312 if (stat & RXERROR_PARITY)
1313 flag = TTY_PARITY;
1314 else if (stat & RXERROR_FRAMING)
1315 flag = TTY_FRAME;
1316
1317 tty_insert_flip_char(&port->port,
1318 data[i+1], flag);
1319 }
1320 }
1321 }
1322 tty_flip_buffer_push(&port->port);
1323 }
1324
1325 /* Resubmit urb so we continue receiving */
1326 err = usb_submit_urb(urb, GFP_ATOMIC);
1327 if (err != 0)
1328 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1329 }
1330
1331
1332 static void usa90_instat_callback(struct urb *urb)
1333 {
1334 unsigned char *data = urb->transfer_buffer;
1335 struct keyspan_usa90_portStatusMessage *msg;
1336 struct usb_serial *serial;
1337 struct usb_serial_port *port;
1338 struct keyspan_port_private *p_priv;
1339 int old_dcd_state, err;
1340 int status = urb->status;
1341
1342 serial = urb->context;
1343
1344 if (status) {
1345 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1346 __func__, status);
1347 return;
1348 }
1349 if (urb->actual_length < 14) {
1350 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
1351 goto exit;
1352 }
1353
1354 msg = (struct keyspan_usa90_portStatusMessage *)data;
1355
1356 /* Now do something useful with the data */
1357
1358 port = serial->port[0];
1359 p_priv = usb_get_serial_port_data(port);
1360 if (!p_priv)
1361 goto resubmit;
1362
1363 /* Update handshaking pin state information */
1364 old_dcd_state = p_priv->dcd_state;
1365 p_priv->cts_state = ((msg->cts) ? 1 : 0);
1366 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1367 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1368 p_priv->ri_state = ((msg->ri) ? 1 : 0);
1369
1370 if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1371 tty_port_tty_hangup(&port->port, true);
1372 resubmit:
1373 /* Resubmit urb so we continue receiving */
1374 err = usb_submit_urb(urb, GFP_ATOMIC);
1375 if (err != 0)
1376 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1377 exit:
1378 ;
1379 }
1380
1381 static void usa90_outcont_callback(struct urb *urb)
1382 {
1383 struct usb_serial_port *port;
1384 struct keyspan_port_private *p_priv;
1385
1386 port = urb->context;
1387 p_priv = usb_get_serial_port_data(port);
1388
1389 if (p_priv->resend_cont) {
1390 dev_dbg(&urb->dev->dev, "%s - sending setup\n", __func__);
1391 keyspan_usa90_send_setup(port->serial, port,
1392 p_priv->resend_cont - 1);
1393 }
1394 }
1395
1396 /* Status messages from the 28xg */
1397 static void usa67_instat_callback(struct urb *urb)
1398 {
1399 int err;
1400 unsigned char *data = urb->transfer_buffer;
1401 struct keyspan_usa67_portStatusMessage *msg;
1402 struct usb_serial *serial;
1403 struct usb_serial_port *port;
1404 struct keyspan_port_private *p_priv;
1405 int old_dcd_state;
1406 int status = urb->status;
1407
1408 serial = urb->context;
1409
1410 if (status) {
1411 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n",
1412 __func__, status);
1413 return;
1414 }
1415
1416 if (urb->actual_length !=
1417 sizeof(struct keyspan_usa67_portStatusMessage)) {
1418 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
1419 return;
1420 }
1421
1422
1423 /* Now do something useful with the data */
1424 msg = (struct keyspan_usa67_portStatusMessage *)data;
1425
1426 /* Check port number from message and retrieve private data */
1427 if (msg->port >= serial->num_ports) {
1428 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
1429 return;
1430 }
1431
1432 port = serial->port[msg->port];
1433 p_priv = usb_get_serial_port_data(port);
1434 if (!p_priv)
1435 goto resubmit;
1436
1437 /* Update handshaking pin state information */
1438 old_dcd_state = p_priv->dcd_state;
1439 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
1440 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
1441
1442 if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
1443 tty_port_tty_hangup(&port->port, true);
1444 resubmit:
1445 /* Resubmit urb so we continue receiving */
1446 err = usb_submit_urb(urb, GFP_ATOMIC);
1447 if (err != 0)
1448 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
1449 }
1450
1451 static void usa67_glocont_callback(struct urb *urb)
1452 {
1453 struct usb_serial *serial;
1454 struct usb_serial_port *port;
1455 struct keyspan_port_private *p_priv;
1456 int i;
1457
1458 serial = urb->context;
1459 for (i = 0; i < serial->num_ports; ++i) {
1460 port = serial->port[i];
1461 p_priv = usb_get_serial_port_data(port);
1462
1463 if (p_priv->resend_cont) {
1464 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
1465 keyspan_usa67_send_setup(serial, port,
1466 p_priv->resend_cont - 1);
1467 break;
1468 }
1469 }
1470 }
1471
1472 static int keyspan_write_room(struct tty_struct *tty)
1473 {
1474 struct usb_serial_port *port = tty->driver_data;
1475 struct keyspan_port_private *p_priv;
1476 const struct keyspan_device_details *d_details;
1477 int flip;
1478 int data_len;
1479 struct urb *this_urb;
1480
1481 p_priv = usb_get_serial_port_data(port);
1482 d_details = p_priv->device_details;
1483
1484 /* FIXME: locking */
1485 if (d_details->msg_format == msg_usa90)
1486 data_len = 64;
1487 else
1488 data_len = 63;
1489
1490 flip = p_priv->out_flip;
1491
1492 /* Check both endpoints to see if any are available. */
1493 this_urb = p_priv->out_urbs[flip];
1494 if (this_urb != NULL) {
1495 if (this_urb->status != -EINPROGRESS)
1496 return data_len;
1497 flip = (flip + 1) & d_details->outdat_endp_flip;
1498 this_urb = p_priv->out_urbs[flip];
1499 if (this_urb != NULL) {
1500 if (this_urb->status != -EINPROGRESS)
1501 return data_len;
1502 }
1503 }
1504 return 0;
1505 }
1506
1507
1508 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
1509 {
1510 struct keyspan_port_private *p_priv;
1511 const struct keyspan_device_details *d_details;
1512 int i, err;
1513 int baud_rate, device_port;
1514 struct urb *urb;
1515 unsigned int cflag = 0;
1516
1517 p_priv = usb_get_serial_port_data(port);
1518 d_details = p_priv->device_details;
1519
1520 /* Set some sane defaults */
1521 p_priv->rts_state = 1;
1522 p_priv->dtr_state = 1;
1523 p_priv->baud = 9600;
1524
1525 /* force baud and lcr to be set on open */
1526 p_priv->old_baud = 0;
1527 p_priv->old_cflag = 0;
1528
1529 p_priv->out_flip = 0;
1530 p_priv->in_flip = 0;
1531
1532 /* Reset low level data toggle and start reading from endpoints */
1533 for (i = 0; i < 2; i++) {
1534 urb = p_priv->in_urbs[i];
1535 if (urb == NULL)
1536 continue;
1537
1538 /* make sure endpoint data toggle is synchronized
1539 with the device */
1540 usb_clear_halt(urb->dev, urb->pipe);
1541 err = usb_submit_urb(urb, GFP_KERNEL);
1542 if (err != 0)
1543 dev_dbg(&port->dev, "%s - submit urb %d failed (%d)\n", __func__, i, err);
1544 }
1545
1546 /* Reset low level data toggle on out endpoints */
1547 for (i = 0; i < 2; i++) {
1548 urb = p_priv->out_urbs[i];
1549 if (urb == NULL)
1550 continue;
1551 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
1552 usb_pipeout(urb->pipe), 0); */
1553 }
1554
1555 /* get the terminal config for the setup message now so we don't
1556 * need to send 2 of them */
1557
1558 device_port = port->port_number;
1559 if (tty) {
1560 cflag = tty->termios.c_cflag;
1561 /* Baud rate calculation takes baud rate as an integer
1562 so other rates can be generated if desired. */
1563 baud_rate = tty_get_baud_rate(tty);
1564 /* If no match or invalid, leave as default */
1565 if (baud_rate >= 0
1566 && d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
1567 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
1568 p_priv->baud = baud_rate;
1569 }
1570 }
1571 /* set CTS/RTS handshake etc. */
1572 p_priv->cflag = cflag;
1573 p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
1574
1575 keyspan_send_setup(port, 1);
1576 /* mdelay(100); */
1577 /* keyspan_set_termios(port, NULL); */
1578
1579 return 0;
1580 }
1581
1582 static void keyspan_dtr_rts(struct usb_serial_port *port, int on)
1583 {
1584 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
1585
1586 p_priv->rts_state = on;
1587 p_priv->dtr_state = on;
1588 keyspan_send_setup(port, 0);
1589 }
1590
1591 static void keyspan_close(struct usb_serial_port *port)
1592 {
1593 int i;
1594 struct keyspan_port_private *p_priv;
1595
1596 p_priv = usb_get_serial_port_data(port);
1597
1598 p_priv->rts_state = 0;
1599 p_priv->dtr_state = 0;
1600
1601 keyspan_send_setup(port, 2);
1602 /* pilot-xfer seems to work best with this delay */
1603 mdelay(100);
1604
1605 p_priv->out_flip = 0;
1606 p_priv->in_flip = 0;
1607
1608 usb_kill_urb(p_priv->inack_urb);
1609 for (i = 0; i < 2; i++) {
1610 usb_kill_urb(p_priv->in_urbs[i]);
1611 usb_kill_urb(p_priv->out_urbs[i]);
1612 }
1613 }
1614
1615 /* download the firmware to a pre-renumeration device */
1616 static int keyspan_fake_startup(struct usb_serial *serial)
1617 {
1618 char *fw_name;
1619
1620 dev_dbg(&serial->dev->dev, "Keyspan startup version %04x product %04x\n",
1621 le16_to_cpu(serial->dev->descriptor.bcdDevice),
1622 le16_to_cpu(serial->dev->descriptor.idProduct));
1623
1624 if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000)
1625 != 0x8000) {
1626 dev_dbg(&serial->dev->dev, "Firmware already loaded. Quitting.\n");
1627 return 1;
1628 }
1629
1630 /* Select firmware image on the basis of idProduct */
1631 switch (le16_to_cpu(serial->dev->descriptor.idProduct)) {
1632 case keyspan_usa28_pre_product_id:
1633 fw_name = "keyspan/usa28.fw";
1634 break;
1635
1636 case keyspan_usa28x_pre_product_id:
1637 fw_name = "keyspan/usa28x.fw";
1638 break;
1639
1640 case keyspan_usa28xa_pre_product_id:
1641 fw_name = "keyspan/usa28xa.fw";
1642 break;
1643
1644 case keyspan_usa28xb_pre_product_id:
1645 fw_name = "keyspan/usa28xb.fw";
1646 break;
1647
1648 case keyspan_usa19_pre_product_id:
1649 fw_name = "keyspan/usa19.fw";
1650 break;
1651
1652 case keyspan_usa19qi_pre_product_id:
1653 fw_name = "keyspan/usa19qi.fw";
1654 break;
1655
1656 case keyspan_mpr_pre_product_id:
1657 fw_name = "keyspan/mpr.fw";
1658 break;
1659
1660 case keyspan_usa19qw_pre_product_id:
1661 fw_name = "keyspan/usa19qw.fw";
1662 break;
1663
1664 case keyspan_usa18x_pre_product_id:
1665 fw_name = "keyspan/usa18x.fw";
1666 break;
1667
1668 case keyspan_usa19w_pre_product_id:
1669 fw_name = "keyspan/usa19w.fw";
1670 break;
1671
1672 case keyspan_usa49w_pre_product_id:
1673 fw_name = "keyspan/usa49w.fw";
1674 break;
1675
1676 case keyspan_usa49wlc_pre_product_id:
1677 fw_name = "keyspan/usa49wlc.fw";
1678 break;
1679
1680 default:
1681 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n",
1682 le16_to_cpu(serial->dev->descriptor.idProduct));
1683 return 1;
1684 }
1685
1686 dev_dbg(&serial->dev->dev, "Uploading Keyspan %s firmware.\n", fw_name);
1687
1688 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
1689 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
1690 fw_name);
1691 return -ENOENT;
1692 }
1693
1694 /* after downloading firmware Renumeration will occur in a
1695 moment and the new device will bind to the real driver */
1696
1697 /* we don't want this device to have a driver assigned to it. */
1698 return 1;
1699 }
1700
1701 /* Helper functions used by keyspan_setup_urbs */
1702 static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial,
1703 int endpoint)
1704 {
1705 struct usb_host_interface *iface_desc;
1706 struct usb_endpoint_descriptor *ep;
1707 int i;
1708
1709 iface_desc = serial->interface->cur_altsetting;
1710 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1711 ep = &iface_desc->endpoint[i].desc;
1712 if (ep->bEndpointAddress == endpoint)
1713 return ep;
1714 }
1715 dev_warn(&serial->interface->dev, "found no endpoint descriptor for endpoint %x\n",
1716 endpoint);
1717 return NULL;
1718 }
1719
1720 static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
1721 int dir, void *ctx, char *buf, int len,
1722 void (*callback)(struct urb *))
1723 {
1724 struct urb *urb;
1725 struct usb_endpoint_descriptor const *ep_desc;
1726 char const *ep_type_name;
1727
1728 if (endpoint == -1)
1729 return NULL; /* endpoint not needed */
1730
1731 dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %x\n",
1732 __func__, endpoint);
1733 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
1734 if (!urb)
1735 return NULL;
1736
1737 if (endpoint == 0) {
1738 /* control EP filled in when used */
1739 return urb;
1740 }
1741
1742 ep_desc = find_ep(serial, endpoint);
1743 if (!ep_desc) {
1744 /* leak the urb, something's wrong and the callers don't care */
1745 return urb;
1746 }
1747 if (usb_endpoint_xfer_int(ep_desc)) {
1748 ep_type_name = "INT";
1749 usb_fill_int_urb(urb, serial->dev,
1750 usb_sndintpipe(serial->dev, endpoint) | dir,
1751 buf, len, callback, ctx,
1752 ep_desc->bInterval);
1753 } else if (usb_endpoint_xfer_bulk(ep_desc)) {
1754 ep_type_name = "BULK";
1755 usb_fill_bulk_urb(urb, serial->dev,
1756 usb_sndbulkpipe(serial->dev, endpoint) | dir,
1757 buf, len, callback, ctx);
1758 } else {
1759 dev_warn(&serial->interface->dev,
1760 "unsupported endpoint type %x\n",
1761 usb_endpoint_type(ep_desc));
1762 usb_free_urb(urb);
1763 return NULL;
1764 }
1765
1766 dev_dbg(&serial->interface->dev, "%s - using urb %p for %s endpoint %x\n",
1767 __func__, urb, ep_type_name, endpoint);
1768 return urb;
1769 }
1770
1771 static struct callbacks {
1772 void (*instat_callback)(struct urb *);
1773 void (*glocont_callback)(struct urb *);
1774 void (*indat_callback)(struct urb *);
1775 void (*outdat_callback)(struct urb *);
1776 void (*inack_callback)(struct urb *);
1777 void (*outcont_callback)(struct urb *);
1778 } keyspan_callbacks[] = {
1779 {
1780 /* msg_usa26 callbacks */
1781 .instat_callback = usa26_instat_callback,
1782 .glocont_callback = usa26_glocont_callback,
1783 .indat_callback = usa26_indat_callback,
1784 .outdat_callback = usa2x_outdat_callback,
1785 .inack_callback = usa26_inack_callback,
1786 .outcont_callback = usa26_outcont_callback,
1787 }, {
1788 /* msg_usa28 callbacks */
1789 .instat_callback = usa28_instat_callback,
1790 .glocont_callback = usa28_glocont_callback,
1791 .indat_callback = usa28_indat_callback,
1792 .outdat_callback = usa2x_outdat_callback,
1793 .inack_callback = usa28_inack_callback,
1794 .outcont_callback = usa28_outcont_callback,
1795 }, {
1796 /* msg_usa49 callbacks */
1797 .instat_callback = usa49_instat_callback,
1798 .glocont_callback = usa49_glocont_callback,
1799 .indat_callback = usa49_indat_callback,
1800 .outdat_callback = usa2x_outdat_callback,
1801 .inack_callback = usa49_inack_callback,
1802 .outcont_callback = usa49_outcont_callback,
1803 }, {
1804 /* msg_usa90 callbacks */
1805 .instat_callback = usa90_instat_callback,
1806 .glocont_callback = usa28_glocont_callback,
1807 .indat_callback = usa90_indat_callback,
1808 .outdat_callback = usa2x_outdat_callback,
1809 .inack_callback = usa28_inack_callback,
1810 .outcont_callback = usa90_outcont_callback,
1811 }, {
1812 /* msg_usa67 callbacks */
1813 .instat_callback = usa67_instat_callback,
1814 .glocont_callback = usa67_glocont_callback,
1815 .indat_callback = usa26_indat_callback,
1816 .outdat_callback = usa2x_outdat_callback,
1817 .inack_callback = usa26_inack_callback,
1818 .outcont_callback = usa26_outcont_callback,
1819 }
1820 };
1821
1822 /* Generic setup urbs function that uses
1823 data in device_details */
1824 static void keyspan_setup_urbs(struct usb_serial *serial)
1825 {
1826 struct keyspan_serial_private *s_priv;
1827 const struct keyspan_device_details *d_details;
1828 struct callbacks *cback;
1829
1830 s_priv = usb_get_serial_data(serial);
1831 d_details = s_priv->device_details;
1832
1833 /* Setup values for the various callback routines */
1834 cback = &keyspan_callbacks[d_details->msg_format];
1835
1836 /* Allocate and set up urbs for each one that is in use,
1837 starting with instat endpoints */
1838 s_priv->instat_urb = keyspan_setup_urb
1839 (serial, d_details->instat_endpoint, USB_DIR_IN,
1840 serial, s_priv->instat_buf, INSTAT_BUFLEN,
1841 cback->instat_callback);
1842
1843 s_priv->indat_urb = keyspan_setup_urb
1844 (serial, d_details->indat_endpoint, USB_DIR_IN,
1845 serial, s_priv->indat_buf, INDAT49W_BUFLEN,
1846 usa49wg_indat_callback);
1847
1848 s_priv->glocont_urb = keyspan_setup_urb
1849 (serial, d_details->glocont_endpoint, USB_DIR_OUT,
1850 serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
1851 cback->glocont_callback);
1852 }
1853
1854 /* usa19 function doesn't require prescaler */
1855 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
1856 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1857 u8 *rate_low, u8 *prescaler, int portnum)
1858 {
1859 u32 b16, /* baud rate times 16 (actual rate used internally) */
1860 div, /* divisor */
1861 cnt; /* inverse of divisor (programmed into 8051) */
1862
1863 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1864
1865 /* prevent divide by zero... */
1866 b16 = baud_rate * 16L;
1867 if (b16 == 0)
1868 return KEYSPAN_INVALID_BAUD_RATE;
1869 /* Any "standard" rate over 57k6 is marginal on the USA-19
1870 as we run out of divisor resolution. */
1871 if (baud_rate > 57600)
1872 return KEYSPAN_INVALID_BAUD_RATE;
1873
1874 /* calculate the divisor and the counter (its inverse) */
1875 div = baudclk / b16;
1876 if (div == 0)
1877 return KEYSPAN_INVALID_BAUD_RATE;
1878 else
1879 cnt = 0 - div;
1880
1881 if (div > 0xffff)
1882 return KEYSPAN_INVALID_BAUD_RATE;
1883
1884 /* return the counter values if non-null */
1885 if (rate_low)
1886 *rate_low = (u8) (cnt & 0xff);
1887 if (rate_hi)
1888 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1889 if (rate_low && rate_hi)
1890 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1891 __func__, baud_rate, *rate_hi, *rate_low);
1892 return KEYSPAN_BAUD_RATE_OK;
1893 }
1894
1895 /* usa19hs function doesn't require prescaler */
1896 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
1897 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1898 u8 *rate_low, u8 *prescaler, int portnum)
1899 {
1900 u32 b16, /* baud rate times 16 (actual rate used internally) */
1901 div; /* divisor */
1902
1903 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1904
1905 /* prevent divide by zero... */
1906 b16 = baud_rate * 16L;
1907 if (b16 == 0)
1908 return KEYSPAN_INVALID_BAUD_RATE;
1909
1910 /* calculate the divisor */
1911 div = baudclk / b16;
1912 if (div == 0)
1913 return KEYSPAN_INVALID_BAUD_RATE;
1914
1915 if (div > 0xffff)
1916 return KEYSPAN_INVALID_BAUD_RATE;
1917
1918 /* return the counter values if non-null */
1919 if (rate_low)
1920 *rate_low = (u8) (div & 0xff);
1921
1922 if (rate_hi)
1923 *rate_hi = (u8) ((div >> 8) & 0xff);
1924
1925 if (rate_low && rate_hi)
1926 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1927 __func__, baud_rate, *rate_hi, *rate_low);
1928
1929 return KEYSPAN_BAUD_RATE_OK;
1930 }
1931
1932 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
1933 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1934 u8 *rate_low, u8 *prescaler, int portnum)
1935 {
1936 u32 b16, /* baud rate times 16 (actual rate used internally) */
1937 clk, /* clock with 13/8 prescaler */
1938 div, /* divisor using 13/8 prescaler */
1939 res, /* resulting baud rate using 13/8 prescaler */
1940 diff, /* error using 13/8 prescaler */
1941 smallest_diff;
1942 u8 best_prescaler;
1943 int i;
1944
1945 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1946
1947 /* prevent divide by zero */
1948 b16 = baud_rate * 16L;
1949 if (b16 == 0)
1950 return KEYSPAN_INVALID_BAUD_RATE;
1951
1952 /* Calculate prescaler by trying them all and looking
1953 for best fit */
1954
1955 /* start with largest possible difference */
1956 smallest_diff = 0xffffffff;
1957
1958 /* 0 is an invalid prescaler, used as a flag */
1959 best_prescaler = 0;
1960
1961 for (i = 8; i <= 0xff; ++i) {
1962 clk = (baudclk * 8) / (u32) i;
1963
1964 div = clk / b16;
1965 if (div == 0)
1966 continue;
1967
1968 res = clk / div;
1969 diff = (res > b16) ? (res-b16) : (b16-res);
1970
1971 if (diff < smallest_diff) {
1972 best_prescaler = i;
1973 smallest_diff = diff;
1974 }
1975 }
1976
1977 if (best_prescaler == 0)
1978 return KEYSPAN_INVALID_BAUD_RATE;
1979
1980 clk = (baudclk * 8) / (u32) best_prescaler;
1981 div = clk / b16;
1982
1983 /* return the divisor and prescaler if non-null */
1984 if (rate_low)
1985 *rate_low = (u8) (div & 0xff);
1986 if (rate_hi)
1987 *rate_hi = (u8) ((div >> 8) & 0xff);
1988 if (prescaler) {
1989 *prescaler = best_prescaler;
1990 /* dev_dbg(&port->dev, "%s - %d %d\n", __func__, *prescaler, div); */
1991 }
1992 return KEYSPAN_BAUD_RATE_OK;
1993 }
1994
1995 /* USA-28 supports different maximum baud rates on each port */
1996 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
1997 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1998 u8 *rate_low, u8 *prescaler, int portnum)
1999 {
2000 u32 b16, /* baud rate times 16 (actual rate used internally) */
2001 div, /* divisor */
2002 cnt; /* inverse of divisor (programmed into 8051) */
2003
2004 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
2005
2006 /* prevent divide by zero */
2007 b16 = baud_rate * 16L;
2008 if (b16 == 0)
2009 return KEYSPAN_INVALID_BAUD_RATE;
2010
2011 /* calculate the divisor and the counter (its inverse) */
2012 div = KEYSPAN_USA28_BAUDCLK / b16;
2013 if (div == 0)
2014 return KEYSPAN_INVALID_BAUD_RATE;
2015 else
2016 cnt = 0 - div;
2017
2018 /* check for out of range, based on portnum,
2019 and return result */
2020 if (portnum == 0) {
2021 if (div > 0xffff)
2022 return KEYSPAN_INVALID_BAUD_RATE;
2023 } else {
2024 if (portnum == 1) {
2025 if (div > 0xff)
2026 return KEYSPAN_INVALID_BAUD_RATE;
2027 } else
2028 return KEYSPAN_INVALID_BAUD_RATE;
2029 }
2030
2031 /* return the counter values if not NULL
2032 (port 1 will ignore retHi) */
2033 if (rate_low)
2034 *rate_low = (u8) (cnt & 0xff);
2035 if (rate_hi)
2036 *rate_hi = (u8) ((cnt >> 8) & 0xff);
2037 dev_dbg(&port->dev, "%s - %d OK.\n", __func__, baud_rate);
2038 return KEYSPAN_BAUD_RATE_OK;
2039 }
2040
2041 static int keyspan_usa26_send_setup(struct usb_serial *serial,
2042 struct usb_serial_port *port,
2043 int reset_port)
2044 {
2045 struct keyspan_usa26_portControlMessage msg;
2046 struct keyspan_serial_private *s_priv;
2047 struct keyspan_port_private *p_priv;
2048 const struct keyspan_device_details *d_details;
2049 struct urb *this_urb;
2050 int device_port, err;
2051
2052 dev_dbg(&port->dev, "%s reset=%d\n", __func__, reset_port);
2053
2054 s_priv = usb_get_serial_data(serial);
2055 p_priv = usb_get_serial_port_data(port);
2056 d_details = s_priv->device_details;
2057 device_port = port->port_number;
2058
2059 this_urb = p_priv->outcont_urb;
2060
2061 /* Make sure we have an urb then send the message */
2062 if (this_urb == NULL) {
2063 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2064 return -1;
2065 }
2066
2067 dev_dbg(&port->dev, "%s - endpoint %x\n",
2068 __func__, usb_pipeendpoint(this_urb->pipe));
2069
2070 /* Save reset port val for resend.
2071 Don't overwrite resend for open/close condition. */
2072 if ((reset_port + 1) > p_priv->resend_cont)
2073 p_priv->resend_cont = reset_port + 1;
2074 if (this_urb->status == -EINPROGRESS) {
2075 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2076 mdelay(5);
2077 return -1;
2078 }
2079
2080 memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage));
2081
2082 /* Only set baud rate if it's changed */
2083 if (p_priv->old_baud != p_priv->baud) {
2084 p_priv->old_baud = p_priv->baud;
2085 msg.setClocking = 0xff;
2086 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2087 &msg.baudHi, &msg.baudLo, &msg.prescaler,
2088 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2089 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2090 __func__, p_priv->baud);
2091 msg.baudLo = 0;
2092 msg.baudHi = 125; /* Values for 9600 baud */
2093 msg.prescaler = 10;
2094 }
2095 msg.setPrescaler = 0xff;
2096 }
2097
2098 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2099 switch (p_priv->cflag & CSIZE) {
2100 case CS5:
2101 msg.lcr |= USA_DATABITS_5;
2102 break;
2103 case CS6:
2104 msg.lcr |= USA_DATABITS_6;
2105 break;
2106 case CS7:
2107 msg.lcr |= USA_DATABITS_7;
2108 break;
2109 case CS8:
2110 msg.lcr |= USA_DATABITS_8;
2111 break;
2112 }
2113 if (p_priv->cflag & PARENB) {
2114 /* note USA_PARITY_NONE == 0 */
2115 msg.lcr |= (p_priv->cflag & PARODD) ?
2116 USA_PARITY_ODD : USA_PARITY_EVEN;
2117 }
2118 msg.setLcr = 0xff;
2119
2120 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2121 msg.xonFlowControl = 0;
2122 msg.setFlowControl = 0xff;
2123 msg.forwardingLength = 16;
2124 msg.xonChar = 17;
2125 msg.xoffChar = 19;
2126
2127 /* Opening port */
2128 if (reset_port == 1) {
2129 msg._txOn = 1;
2130 msg._txOff = 0;
2131 msg.txFlush = 0;
2132 msg.txBreak = 0;
2133 msg.rxOn = 1;
2134 msg.rxOff = 0;
2135 msg.rxFlush = 1;
2136 msg.rxForward = 0;
2137 msg.returnStatus = 0;
2138 msg.resetDataToggle = 0xff;
2139 }
2140
2141 /* Closing port */
2142 else if (reset_port == 2) {
2143 msg._txOn = 0;
2144 msg._txOff = 1;
2145 msg.txFlush = 0;
2146 msg.txBreak = 0;
2147 msg.rxOn = 0;
2148 msg.rxOff = 1;
2149 msg.rxFlush = 1;
2150 msg.rxForward = 0;
2151 msg.returnStatus = 0;
2152 msg.resetDataToggle = 0;
2153 }
2154
2155 /* Sending intermediate configs */
2156 else {
2157 msg._txOn = (!p_priv->break_on);
2158 msg._txOff = 0;
2159 msg.txFlush = 0;
2160 msg.txBreak = (p_priv->break_on);
2161 msg.rxOn = 0;
2162 msg.rxOff = 0;
2163 msg.rxFlush = 0;
2164 msg.rxForward = 0;
2165 msg.returnStatus = 0;
2166 msg.resetDataToggle = 0x0;
2167 }
2168
2169 /* Do handshaking outputs */
2170 msg.setTxTriState_setRts = 0xff;
2171 msg.txTriState_rts = p_priv->rts_state;
2172
2173 msg.setHskoa_setDtr = 0xff;
2174 msg.hskoa_dtr = p_priv->dtr_state;
2175
2176 p_priv->resend_cont = 0;
2177 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2178
2179 /* send the data out the device on control endpoint */
2180 this_urb->transfer_buffer_length = sizeof(msg);
2181
2182 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2183 if (err != 0)
2184 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2185 return 0;
2186 }
2187
2188 static int keyspan_usa28_send_setup(struct usb_serial *serial,
2189 struct usb_serial_port *port,
2190 int reset_port)
2191 {
2192 struct keyspan_usa28_portControlMessage msg;
2193 struct keyspan_serial_private *s_priv;
2194 struct keyspan_port_private *p_priv;
2195 const struct keyspan_device_details *d_details;
2196 struct urb *this_urb;
2197 int device_port, err;
2198
2199 s_priv = usb_get_serial_data(serial);
2200 p_priv = usb_get_serial_port_data(port);
2201 d_details = s_priv->device_details;
2202 device_port = port->port_number;
2203
2204 /* only do something if we have a bulk out endpoint */
2205 this_urb = p_priv->outcont_urb;
2206 if (this_urb == NULL) {
2207 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2208 return -1;
2209 }
2210
2211 /* Save reset port val for resend.
2212 Don't overwrite resend for open/close condition. */
2213 if ((reset_port + 1) > p_priv->resend_cont)
2214 p_priv->resend_cont = reset_port + 1;
2215 if (this_urb->status == -EINPROGRESS) {
2216 dev_dbg(&port->dev, "%s already writing\n", __func__);
2217 mdelay(5);
2218 return -1;
2219 }
2220
2221 memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage));
2222
2223 msg.setBaudRate = 1;
2224 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2225 &msg.baudHi, &msg.baudLo, NULL,
2226 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2227 dev_dbg(&port->dev, "%s - Invalid baud rate requested %d.\n",
2228 __func__, p_priv->baud);
2229 msg.baudLo = 0xff;
2230 msg.baudHi = 0xb2; /* Values for 9600 baud */
2231 }
2232
2233 /* If parity is enabled, we must calculate it ourselves. */
2234 msg.parity = 0; /* XXX for now */
2235
2236 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2237 msg.xonFlowControl = 0;
2238
2239 /* Do handshaking outputs, DTR is inverted relative to RTS */
2240 msg.rts = p_priv->rts_state;
2241 msg.dtr = p_priv->dtr_state;
2242
2243 msg.forwardingLength = 16;
2244 msg.forwardMs = 10;
2245 msg.breakThreshold = 45;
2246 msg.xonChar = 17;
2247 msg.xoffChar = 19;
2248
2249 /*msg.returnStatus = 1;
2250 msg.resetDataToggle = 0xff;*/
2251 /* Opening port */
2252 if (reset_port == 1) {
2253 msg._txOn = 1;
2254 msg._txOff = 0;
2255 msg.txFlush = 0;
2256 msg.txForceXoff = 0;
2257 msg.txBreak = 0;
2258 msg.rxOn = 1;
2259 msg.rxOff = 0;
2260 msg.rxFlush = 1;
2261 msg.rxForward = 0;
2262 msg.returnStatus = 0;
2263 msg.resetDataToggle = 0xff;
2264 }
2265 /* Closing port */
2266 else if (reset_port == 2) {
2267 msg._txOn = 0;
2268 msg._txOff = 1;
2269 msg.txFlush = 0;
2270 msg.txForceXoff = 0;
2271 msg.txBreak = 0;
2272 msg.rxOn = 0;
2273 msg.rxOff = 1;
2274 msg.rxFlush = 1;
2275 msg.rxForward = 0;
2276 msg.returnStatus = 0;
2277 msg.resetDataToggle = 0;
2278 }
2279 /* Sending intermediate configs */
2280 else {
2281 msg._txOn = (!p_priv->break_on);
2282 msg._txOff = 0;
2283 msg.txFlush = 0;
2284 msg.txForceXoff = 0;
2285 msg.txBreak = (p_priv->break_on);
2286 msg.rxOn = 0;
2287 msg.rxOff = 0;
2288 msg.rxFlush = 0;
2289 msg.rxForward = 0;
2290 msg.returnStatus = 0;
2291 msg.resetDataToggle = 0x0;
2292 }
2293
2294 p_priv->resend_cont = 0;
2295 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2296
2297 /* send the data out the device on control endpoint */
2298 this_urb->transfer_buffer_length = sizeof(msg);
2299
2300 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2301 if (err != 0)
2302 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed\n", __func__);
2303
2304 return 0;
2305 }
2306
2307 static int keyspan_usa49_send_setup(struct usb_serial *serial,
2308 struct usb_serial_port *port,
2309 int reset_port)
2310 {
2311 struct keyspan_usa49_portControlMessage msg;
2312 struct usb_ctrlrequest *dr = NULL;
2313 struct keyspan_serial_private *s_priv;
2314 struct keyspan_port_private *p_priv;
2315 const struct keyspan_device_details *d_details;
2316 struct urb *this_urb;
2317 int err, device_port;
2318
2319 s_priv = usb_get_serial_data(serial);
2320 p_priv = usb_get_serial_port_data(port);
2321 d_details = s_priv->device_details;
2322
2323 this_urb = s_priv->glocont_urb;
2324
2325 /* Work out which port within the device is being setup */
2326 device_port = port->port_number;
2327
2328 /* Make sure we have an urb then send the message */
2329 if (this_urb == NULL) {
2330 dev_dbg(&port->dev, "%s - oops no urb for port.\n", __func__);
2331 return -1;
2332 }
2333
2334 dev_dbg(&port->dev, "%s - endpoint %x (%d)\n",
2335 __func__, usb_pipeendpoint(this_urb->pipe), device_port);
2336
2337 /* Save reset port val for resend.
2338 Don't overwrite resend for open/close condition. */
2339 if ((reset_port + 1) > p_priv->resend_cont)
2340 p_priv->resend_cont = reset_port + 1;
2341
2342 if (this_urb->status == -EINPROGRESS) {
2343 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2344 mdelay(5);
2345 return -1;
2346 }
2347
2348 memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage));
2349
2350 msg.portNumber = device_port;
2351
2352 /* Only set baud rate if it's changed */
2353 if (p_priv->old_baud != p_priv->baud) {
2354 p_priv->old_baud = p_priv->baud;
2355 msg.setClocking = 0xff;
2356 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2357 &msg.baudHi, &msg.baudLo, &msg.prescaler,
2358 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2359 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2360 __func__, p_priv->baud);
2361 msg.baudLo = 0;
2362 msg.baudHi = 125; /* Values for 9600 baud */
2363 msg.prescaler = 10;
2364 }
2365 /* msg.setPrescaler = 0xff; */
2366 }
2367
2368 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2369 switch (p_priv->cflag & CSIZE) {
2370 case CS5:
2371 msg.lcr |= USA_DATABITS_5;
2372 break;
2373 case CS6:
2374 msg.lcr |= USA_DATABITS_6;
2375 break;
2376 case CS7:
2377 msg.lcr |= USA_DATABITS_7;
2378 break;
2379 case CS8:
2380 msg.lcr |= USA_DATABITS_8;
2381 break;
2382 }
2383 if (p_priv->cflag & PARENB) {
2384 /* note USA_PARITY_NONE == 0 */
2385 msg.lcr |= (p_priv->cflag & PARODD) ?
2386 USA_PARITY_ODD : USA_PARITY_EVEN;
2387 }
2388 msg.setLcr = 0xff;
2389
2390 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2391 msg.xonFlowControl = 0;
2392 msg.setFlowControl = 0xff;
2393
2394 msg.forwardingLength = 16;
2395 msg.xonChar = 17;
2396 msg.xoffChar = 19;
2397
2398 /* Opening port */
2399 if (reset_port == 1) {
2400 msg._txOn = 1;
2401 msg._txOff = 0;
2402 msg.txFlush = 0;
2403 msg.txBreak = 0;
2404 msg.rxOn = 1;
2405 msg.rxOff = 0;
2406 msg.rxFlush = 1;
2407 msg.rxForward = 0;
2408 msg.returnStatus = 0;
2409 msg.resetDataToggle = 0xff;
2410 msg.enablePort = 1;
2411 msg.disablePort = 0;
2412 }
2413 /* Closing port */
2414 else if (reset_port == 2) {
2415 msg._txOn = 0;
2416 msg._txOff = 1;
2417 msg.txFlush = 0;
2418 msg.txBreak = 0;
2419 msg.rxOn = 0;
2420 msg.rxOff = 1;
2421 msg.rxFlush = 1;
2422 msg.rxForward = 0;
2423 msg.returnStatus = 0;
2424 msg.resetDataToggle = 0;
2425 msg.enablePort = 0;
2426 msg.disablePort = 1;
2427 }
2428 /* Sending intermediate configs */
2429 else {
2430 msg._txOn = (!p_priv->break_on);
2431 msg._txOff = 0;
2432 msg.txFlush = 0;
2433 msg.txBreak = (p_priv->break_on);
2434 msg.rxOn = 0;
2435 msg.rxOff = 0;
2436 msg.rxFlush = 0;
2437 msg.rxForward = 0;
2438 msg.returnStatus = 0;
2439 msg.resetDataToggle = 0x0;
2440 msg.enablePort = 0;
2441 msg.disablePort = 0;
2442 }
2443
2444 /* Do handshaking outputs */
2445 msg.setRts = 0xff;
2446 msg.rts = p_priv->rts_state;
2447
2448 msg.setDtr = 0xff;
2449 msg.dtr = p_priv->dtr_state;
2450
2451 p_priv->resend_cont = 0;
2452
2453 /* if the device is a 49wg, we send control message on usb
2454 control EP 0 */
2455
2456 if (d_details->product_id == keyspan_usa49wg_product_id) {
2457 dr = (void *)(s_priv->ctrl_buf);
2458 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT;
2459 dr->bRequest = 0xB0; /* 49wg control message */
2460 dr->wValue = 0;
2461 dr->wIndex = 0;
2462 dr->wLength = cpu_to_le16(sizeof(msg));
2463
2464 memcpy(s_priv->glocont_buf, &msg, sizeof(msg));
2465
2466 usb_fill_control_urb(this_urb, serial->dev,
2467 usb_sndctrlpipe(serial->dev, 0),
2468 (unsigned char *)dr, s_priv->glocont_buf,
2469 sizeof(msg), usa49_glocont_callback, serial);
2470
2471 } else {
2472 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2473
2474 /* send the data out the device on control endpoint */
2475 this_urb->transfer_buffer_length = sizeof(msg);
2476 }
2477 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2478 if (err != 0)
2479 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2480
2481 return 0;
2482 }
2483
2484 static int keyspan_usa90_send_setup(struct usb_serial *serial,
2485 struct usb_serial_port *port,
2486 int reset_port)
2487 {
2488 struct keyspan_usa90_portControlMessage msg;
2489 struct keyspan_serial_private *s_priv;
2490 struct keyspan_port_private *p_priv;
2491 const struct keyspan_device_details *d_details;
2492 struct urb *this_urb;
2493 int err;
2494 u8 prescaler;
2495
2496 s_priv = usb_get_serial_data(serial);
2497 p_priv = usb_get_serial_port_data(port);
2498 d_details = s_priv->device_details;
2499
2500 /* only do something if we have a bulk out endpoint */
2501 this_urb = p_priv->outcont_urb;
2502 if (this_urb == NULL) {
2503 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2504 return -1;
2505 }
2506
2507 /* Save reset port val for resend.
2508 Don't overwrite resend for open/close condition. */
2509 if ((reset_port + 1) > p_priv->resend_cont)
2510 p_priv->resend_cont = reset_port + 1;
2511 if (this_urb->status == -EINPROGRESS) {
2512 dev_dbg(&port->dev, "%s already writing\n", __func__);
2513 mdelay(5);
2514 return -1;
2515 }
2516
2517 memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage));
2518
2519 /* Only set baud rate if it's changed */
2520 if (p_priv->old_baud != p_priv->baud) {
2521 p_priv->old_baud = p_priv->baud;
2522 msg.setClocking = 0x01;
2523 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2524 &msg.baudHi, &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
2525 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2526 __func__, p_priv->baud);
2527 p_priv->baud = 9600;
2528 d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2529 &msg.baudHi, &msg.baudLo, &prescaler, 0);
2530 }
2531 msg.setRxMode = 1;
2532 msg.setTxMode = 1;
2533 }
2534
2535 /* modes must always be correctly specified */
2536 if (p_priv->baud > 57600) {
2537 msg.rxMode = RXMODE_DMA;
2538 msg.txMode = TXMODE_DMA;
2539 } else {
2540 msg.rxMode = RXMODE_BYHAND;
2541 msg.txMode = TXMODE_BYHAND;
2542 }
2543
2544 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2545 switch (p_priv->cflag & CSIZE) {
2546 case CS5:
2547 msg.lcr |= USA_DATABITS_5;
2548 break;
2549 case CS6:
2550 msg.lcr |= USA_DATABITS_6;
2551 break;
2552 case CS7:
2553 msg.lcr |= USA_DATABITS_7;
2554 break;
2555 case CS8:
2556 msg.lcr |= USA_DATABITS_8;
2557 break;
2558 }
2559 if (p_priv->cflag & PARENB) {
2560 /* note USA_PARITY_NONE == 0 */
2561 msg.lcr |= (p_priv->cflag & PARODD) ?
2562 USA_PARITY_ODD : USA_PARITY_EVEN;
2563 }
2564 if (p_priv->old_cflag != p_priv->cflag) {
2565 p_priv->old_cflag = p_priv->cflag;
2566 msg.setLcr = 0x01;
2567 }
2568
2569 if (p_priv->flow_control == flow_cts)
2570 msg.txFlowControl = TXFLOW_CTS;
2571 msg.setTxFlowControl = 0x01;
2572 msg.setRxFlowControl = 0x01;
2573
2574 msg.rxForwardingLength = 16;
2575 msg.rxForwardingTimeout = 16;
2576 msg.txAckSetting = 0;
2577 msg.xonChar = 17;
2578 msg.xoffChar = 19;
2579
2580 /* Opening port */
2581 if (reset_port == 1) {
2582 msg.portEnabled = 1;
2583 msg.rxFlush = 1;
2584 msg.txBreak = (p_priv->break_on);
2585 }
2586 /* Closing port */
2587 else if (reset_port == 2)
2588 msg.portEnabled = 0;
2589 /* Sending intermediate configs */
2590 else {
2591 msg.portEnabled = 1;
2592 msg.txBreak = (p_priv->break_on);
2593 }
2594
2595 /* Do handshaking outputs */
2596 msg.setRts = 0x01;
2597 msg.rts = p_priv->rts_state;
2598
2599 msg.setDtr = 0x01;
2600 msg.dtr = p_priv->dtr_state;
2601
2602 p_priv->resend_cont = 0;
2603 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2604
2605 /* send the data out the device on control endpoint */
2606 this_urb->transfer_buffer_length = sizeof(msg);
2607
2608 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2609 if (err != 0)
2610 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2611 return 0;
2612 }
2613
2614 static int keyspan_usa67_send_setup(struct usb_serial *serial,
2615 struct usb_serial_port *port,
2616 int reset_port)
2617 {
2618 struct keyspan_usa67_portControlMessage msg;
2619 struct keyspan_serial_private *s_priv;
2620 struct keyspan_port_private *p_priv;
2621 const struct keyspan_device_details *d_details;
2622 struct urb *this_urb;
2623 int err, device_port;
2624
2625 s_priv = usb_get_serial_data(serial);
2626 p_priv = usb_get_serial_port_data(port);
2627 d_details = s_priv->device_details;
2628
2629 this_urb = s_priv->glocont_urb;
2630
2631 /* Work out which port within the device is being setup */
2632 device_port = port->port_number;
2633
2634 /* Make sure we have an urb then send the message */
2635 if (this_urb == NULL) {
2636 dev_dbg(&port->dev, "%s - oops no urb for port.\n", __func__);
2637 return -1;
2638 }
2639
2640 /* Save reset port val for resend.
2641 Don't overwrite resend for open/close condition. */
2642 if ((reset_port + 1) > p_priv->resend_cont)
2643 p_priv->resend_cont = reset_port + 1;
2644 if (this_urb->status == -EINPROGRESS) {
2645 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2646 mdelay(5);
2647 return -1;
2648 }
2649
2650 memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage));
2651
2652 msg.port = device_port;
2653
2654 /* Only set baud rate if it's changed */
2655 if (p_priv->old_baud != p_priv->baud) {
2656 p_priv->old_baud = p_priv->baud;
2657 msg.setClocking = 0xff;
2658 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2659 &msg.baudHi, &msg.baudLo, &msg.prescaler,
2660 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2661 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2662 __func__, p_priv->baud);
2663 msg.baudLo = 0;
2664 msg.baudHi = 125; /* Values for 9600 baud */
2665 msg.prescaler = 10;
2666 }
2667 msg.setPrescaler = 0xff;
2668 }
2669
2670 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2671 switch (p_priv->cflag & CSIZE) {
2672 case CS5:
2673 msg.lcr |= USA_DATABITS_5;
2674 break;
2675 case CS6:
2676 msg.lcr |= USA_DATABITS_6;
2677 break;
2678 case CS7:
2679 msg.lcr |= USA_DATABITS_7;
2680 break;
2681 case CS8:
2682 msg.lcr |= USA_DATABITS_8;
2683 break;
2684 }
2685 if (p_priv->cflag & PARENB) {
2686 /* note USA_PARITY_NONE == 0 */
2687 msg.lcr |= (p_priv->cflag & PARODD) ?
2688 USA_PARITY_ODD : USA_PARITY_EVEN;
2689 }
2690 msg.setLcr = 0xff;
2691
2692 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2693 msg.xonFlowControl = 0;
2694 msg.setFlowControl = 0xff;
2695 msg.forwardingLength = 16;
2696 msg.xonChar = 17;
2697 msg.xoffChar = 19;
2698
2699 if (reset_port == 1) {
2700 /* Opening port */
2701 msg._txOn = 1;
2702 msg._txOff = 0;
2703 msg.txFlush = 0;
2704 msg.txBreak = 0;
2705 msg.rxOn = 1;
2706 msg.rxOff = 0;
2707 msg.rxFlush = 1;
2708 msg.rxForward = 0;
2709 msg.returnStatus = 0;
2710 msg.resetDataToggle = 0xff;
2711 } else if (reset_port == 2) {
2712 /* Closing port */
2713 msg._txOn = 0;
2714 msg._txOff = 1;
2715 msg.txFlush = 0;
2716 msg.txBreak = 0;
2717 msg.rxOn = 0;
2718 msg.rxOff = 1;
2719 msg.rxFlush = 1;
2720 msg.rxForward = 0;
2721 msg.returnStatus = 0;
2722 msg.resetDataToggle = 0;
2723 } else {
2724 /* Sending intermediate configs */
2725 msg._txOn = (!p_priv->break_on);
2726 msg._txOff = 0;
2727 msg.txFlush = 0;
2728 msg.txBreak = (p_priv->break_on);
2729 msg.rxOn = 0;
2730 msg.rxOff = 0;
2731 msg.rxFlush = 0;
2732 msg.rxForward = 0;
2733 msg.returnStatus = 0;
2734 msg.resetDataToggle = 0x0;
2735 }
2736
2737 /* Do handshaking outputs */
2738 msg.setTxTriState_setRts = 0xff;
2739 msg.txTriState_rts = p_priv->rts_state;
2740
2741 msg.setHskoa_setDtr = 0xff;
2742 msg.hskoa_dtr = p_priv->dtr_state;
2743
2744 p_priv->resend_cont = 0;
2745
2746 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2747
2748 /* send the data out the device on control endpoint */
2749 this_urb->transfer_buffer_length = sizeof(msg);
2750
2751 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2752 if (err != 0)
2753 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2754 return 0;
2755 }
2756
2757 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
2758 {
2759 struct usb_serial *serial = port->serial;
2760 struct keyspan_serial_private *s_priv;
2761 const struct keyspan_device_details *d_details;
2762
2763 s_priv = usb_get_serial_data(serial);
2764 d_details = s_priv->device_details;
2765
2766 switch (d_details->msg_format) {
2767 case msg_usa26:
2768 keyspan_usa26_send_setup(serial, port, reset_port);
2769 break;
2770 case msg_usa28:
2771 keyspan_usa28_send_setup(serial, port, reset_port);
2772 break;
2773 case msg_usa49:
2774 keyspan_usa49_send_setup(serial, port, reset_port);
2775 break;
2776 case msg_usa90:
2777 keyspan_usa90_send_setup(serial, port, reset_port);
2778 break;
2779 case msg_usa67:
2780 keyspan_usa67_send_setup(serial, port, reset_port);
2781 break;
2782 }
2783 }
2784
2785
2786 /* Gets called by the "real" driver (ie once firmware is loaded
2787 and renumeration has taken place. */
2788 static int keyspan_startup(struct usb_serial *serial)
2789 {
2790 int i, err;
2791 struct keyspan_serial_private *s_priv;
2792 const struct keyspan_device_details *d_details;
2793
2794 for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
2795 if (d_details->product_id ==
2796 le16_to_cpu(serial->dev->descriptor.idProduct))
2797 break;
2798 if (d_details == NULL) {
2799 dev_err(&serial->dev->dev, "%s - unknown product id %x\n",
2800 __func__, le16_to_cpu(serial->dev->descriptor.idProduct));
2801 return -ENODEV;
2802 }
2803
2804 /* Setup private data for serial driver */
2805 s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
2806 if (!s_priv)
2807 return -ENOMEM;
2808
2809 s_priv->instat_buf = kzalloc(INSTAT_BUFLEN, GFP_KERNEL);
2810 if (!s_priv->instat_buf)
2811 goto err_instat_buf;
2812
2813 s_priv->indat_buf = kzalloc(INDAT49W_BUFLEN, GFP_KERNEL);
2814 if (!s_priv->indat_buf)
2815 goto err_indat_buf;
2816
2817 s_priv->glocont_buf = kzalloc(GLOCONT_BUFLEN, GFP_KERNEL);
2818 if (!s_priv->glocont_buf)
2819 goto err_glocont_buf;
2820
2821 s_priv->ctrl_buf = kzalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
2822 if (!s_priv->ctrl_buf)
2823 goto err_ctrl_buf;
2824
2825 s_priv->device_details = d_details;
2826 usb_set_serial_data(serial, s_priv);
2827
2828 keyspan_setup_urbs(serial);
2829
2830 if (s_priv->instat_urb != NULL) {
2831 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
2832 if (err != 0)
2833 dev_dbg(&serial->dev->dev, "%s - submit instat urb failed %d\n", __func__, err);
2834 }
2835 if (s_priv->indat_urb != NULL) {
2836 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
2837 if (err != 0)
2838 dev_dbg(&serial->dev->dev, "%s - submit indat urb failed %d\n", __func__, err);
2839 }
2840
2841 return 0;
2842
2843 err_ctrl_buf:
2844 kfree(s_priv->glocont_buf);
2845 err_glocont_buf:
2846 kfree(s_priv->indat_buf);
2847 err_indat_buf:
2848 kfree(s_priv->instat_buf);
2849 err_instat_buf:
2850 kfree(s_priv);
2851
2852 return -ENOMEM;
2853 }
2854
2855 static void keyspan_disconnect(struct usb_serial *serial)
2856 {
2857 struct keyspan_serial_private *s_priv;
2858
2859 s_priv = usb_get_serial_data(serial);
2860
2861 usb_kill_urb(s_priv->instat_urb);
2862 usb_kill_urb(s_priv->glocont_urb);
2863 usb_kill_urb(s_priv->indat_urb);
2864 }
2865
2866 static void keyspan_release(struct usb_serial *serial)
2867 {
2868 struct keyspan_serial_private *s_priv;
2869
2870 s_priv = usb_get_serial_data(serial);
2871
2872 /* Make sure to unlink the URBs submitted in attach. */
2873 usb_kill_urb(s_priv->instat_urb);
2874 usb_kill_urb(s_priv->indat_urb);
2875
2876 usb_free_urb(s_priv->instat_urb);
2877 usb_free_urb(s_priv->indat_urb);
2878 usb_free_urb(s_priv->glocont_urb);
2879
2880 kfree(s_priv->ctrl_buf);
2881 kfree(s_priv->glocont_buf);
2882 kfree(s_priv->indat_buf);
2883 kfree(s_priv->instat_buf);
2884
2885 kfree(s_priv);
2886 }
2887
2888 static int keyspan_port_probe(struct usb_serial_port *port)
2889 {
2890 struct usb_serial *serial = port->serial;
2891 struct keyspan_serial_private *s_priv;
2892 struct keyspan_port_private *p_priv;
2893 const struct keyspan_device_details *d_details;
2894 struct callbacks *cback;
2895 int endp;
2896 int port_num;
2897 int i;
2898
2899 s_priv = usb_get_serial_data(serial);
2900 d_details = s_priv->device_details;
2901
2902 p_priv = kzalloc(sizeof(*p_priv), GFP_KERNEL);
2903 if (!p_priv)
2904 return -ENOMEM;
2905
2906 for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i) {
2907 p_priv->in_buffer[i] = kzalloc(IN_BUFLEN, GFP_KERNEL);
2908 if (!p_priv->in_buffer[i])
2909 goto err_in_buffer;
2910 }
2911
2912 for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i) {
2913 p_priv->out_buffer[i] = kzalloc(OUT_BUFLEN, GFP_KERNEL);
2914 if (!p_priv->out_buffer[i])
2915 goto err_out_buffer;
2916 }
2917
2918 p_priv->inack_buffer = kzalloc(INACK_BUFLEN, GFP_KERNEL);
2919 if (!p_priv->inack_buffer)
2920 goto err_inack_buffer;
2921
2922 p_priv->outcont_buffer = kzalloc(OUTCONT_BUFLEN, GFP_KERNEL);
2923 if (!p_priv->outcont_buffer)
2924 goto err_outcont_buffer;
2925
2926 p_priv->device_details = d_details;
2927
2928 /* Setup values for the various callback routines */
2929 cback = &keyspan_callbacks[d_details->msg_format];
2930
2931 port_num = port->port_number;
2932
2933 /* Do indat endpoints first, once for each flip */
2934 endp = d_details->indat_endpoints[port_num];
2935 for (i = 0; i <= d_details->indat_endp_flip; ++i, ++endp) {
2936 p_priv->in_urbs[i] = keyspan_setup_urb(serial, endp,
2937 USB_DIR_IN, port,
2938 p_priv->in_buffer[i],
2939 IN_BUFLEN,
2940 cback->indat_callback);
2941 }
2942 /* outdat endpoints also have flip */
2943 endp = d_details->outdat_endpoints[port_num];
2944 for (i = 0; i <= d_details->outdat_endp_flip; ++i, ++endp) {
2945 p_priv->out_urbs[i] = keyspan_setup_urb(serial, endp,
2946 USB_DIR_OUT, port,
2947 p_priv->out_buffer[i],
2948 OUT_BUFLEN,
2949 cback->outdat_callback);
2950 }
2951 /* inack endpoint */
2952 p_priv->inack_urb = keyspan_setup_urb(serial,
2953 d_details->inack_endpoints[port_num],
2954 USB_DIR_IN, port,
2955 p_priv->inack_buffer,
2956 INACK_BUFLEN,
2957 cback->inack_callback);
2958 /* outcont endpoint */
2959 p_priv->outcont_urb = keyspan_setup_urb(serial,
2960 d_details->outcont_endpoints[port_num],
2961 USB_DIR_OUT, port,
2962 p_priv->outcont_buffer,
2963 OUTCONT_BUFLEN,
2964 cback->outcont_callback);
2965
2966 usb_set_serial_port_data(port, p_priv);
2967
2968 return 0;
2969
2970 err_outcont_buffer:
2971 kfree(p_priv->inack_buffer);
2972 err_inack_buffer:
2973 for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
2974 kfree(p_priv->out_buffer[i]);
2975 err_out_buffer:
2976 for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
2977 kfree(p_priv->in_buffer[i]);
2978 err_in_buffer:
2979 kfree(p_priv);
2980
2981 return -ENOMEM;
2982 }
2983
2984 static int keyspan_port_remove(struct usb_serial_port *port)
2985 {
2986 struct keyspan_port_private *p_priv;
2987 int i;
2988
2989 p_priv = usb_get_serial_port_data(port);
2990
2991 usb_kill_urb(p_priv->inack_urb);
2992 usb_kill_urb(p_priv->outcont_urb);
2993 for (i = 0; i < 2; i++) {
2994 usb_kill_urb(p_priv->in_urbs[i]);
2995 usb_kill_urb(p_priv->out_urbs[i]);
2996 }
2997
2998 usb_free_urb(p_priv->inack_urb);
2999 usb_free_urb(p_priv->outcont_urb);
3000 for (i = 0; i < 2; i++) {
3001 usb_free_urb(p_priv->in_urbs[i]);
3002 usb_free_urb(p_priv->out_urbs[i]);
3003 }
3004
3005 kfree(p_priv->outcont_buffer);
3006 kfree(p_priv->inack_buffer);
3007 for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
3008 kfree(p_priv->out_buffer[i]);
3009 for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
3010 kfree(p_priv->in_buffer[i]);
3011
3012 kfree(p_priv);
3013
3014 return 0;
3015 }
3016
3017 /* Structs for the devices, pre and post renumeration. */
3018 static struct usb_serial_driver keyspan_pre_device = {
3019 .driver = {
3020 .owner = THIS_MODULE,
3021 .name = "keyspan_no_firm",
3022 },
3023 .description = "Keyspan - (without firmware)",
3024 .id_table = keyspan_pre_ids,
3025 .num_ports = 1,
3026 .attach = keyspan_fake_startup,
3027 };
3028
3029 static struct usb_serial_driver keyspan_1port_device = {
3030 .driver = {
3031 .owner = THIS_MODULE,
3032 .name = "keyspan_1",
3033 },
3034 .description = "Keyspan 1 port adapter",
3035 .id_table = keyspan_1port_ids,
3036 .num_ports = 1,
3037 .open = keyspan_open,
3038 .close = keyspan_close,
3039 .dtr_rts = keyspan_dtr_rts,
3040 .write = keyspan_write,
3041 .write_room = keyspan_write_room,
3042 .set_termios = keyspan_set_termios,
3043 .break_ctl = keyspan_break_ctl,
3044 .tiocmget = keyspan_tiocmget,
3045 .tiocmset = keyspan_tiocmset,
3046 .attach = keyspan_startup,
3047 .disconnect = keyspan_disconnect,
3048 .release = keyspan_release,
3049 .port_probe = keyspan_port_probe,
3050 .port_remove = keyspan_port_remove,
3051 };
3052
3053 static struct usb_serial_driver keyspan_2port_device = {
3054 .driver = {
3055 .owner = THIS_MODULE,
3056 .name = "keyspan_2",
3057 },
3058 .description = "Keyspan 2 port adapter",
3059 .id_table = keyspan_2port_ids,
3060 .num_ports = 2,
3061 .open = keyspan_open,
3062 .close = keyspan_close,
3063 .dtr_rts = keyspan_dtr_rts,
3064 .write = keyspan_write,
3065 .write_room = keyspan_write_room,
3066 .set_termios = keyspan_set_termios,
3067 .break_ctl = keyspan_break_ctl,
3068 .tiocmget = keyspan_tiocmget,
3069 .tiocmset = keyspan_tiocmset,
3070 .attach = keyspan_startup,
3071 .disconnect = keyspan_disconnect,
3072 .release = keyspan_release,
3073 .port_probe = keyspan_port_probe,
3074 .port_remove = keyspan_port_remove,
3075 };
3076
3077 static struct usb_serial_driver keyspan_4port_device = {
3078 .driver = {
3079 .owner = THIS_MODULE,
3080 .name = "keyspan_4",
3081 },
3082 .description = "Keyspan 4 port adapter",
3083 .id_table = keyspan_4port_ids,
3084 .num_ports = 4,
3085 .open = keyspan_open,
3086 .close = keyspan_close,
3087 .dtr_rts = keyspan_dtr_rts,
3088 .write = keyspan_write,
3089 .write_room = keyspan_write_room,
3090 .set_termios = keyspan_set_termios,
3091 .break_ctl = keyspan_break_ctl,
3092 .tiocmget = keyspan_tiocmget,
3093 .tiocmset = keyspan_tiocmset,
3094 .attach = keyspan_startup,
3095 .disconnect = keyspan_disconnect,
3096 .release = keyspan_release,
3097 .port_probe = keyspan_port_probe,
3098 .port_remove = keyspan_port_remove,
3099 };
3100
3101 static struct usb_serial_driver * const serial_drivers[] = {
3102 &keyspan_pre_device, &keyspan_1port_device,
3103 &keyspan_2port_device, &keyspan_4port_device, NULL
3104 };
3105
3106 module_usb_serial_driver(serial_drivers, keyspan_ids_combined);
3107
3108 MODULE_AUTHOR(DRIVER_AUTHOR);
3109 MODULE_DESCRIPTION(DRIVER_DESC);
3110 MODULE_LICENSE("GPL");
3111
3112 MODULE_FIRMWARE("keyspan/usa28.fw");
3113 MODULE_FIRMWARE("keyspan/usa28x.fw");
3114 MODULE_FIRMWARE("keyspan/usa28xa.fw");
3115 MODULE_FIRMWARE("keyspan/usa28xb.fw");
3116 MODULE_FIRMWARE("keyspan/usa19.fw");
3117 MODULE_FIRMWARE("keyspan/usa19qi.fw");
3118 MODULE_FIRMWARE("keyspan/mpr.fw");
3119 MODULE_FIRMWARE("keyspan/usa19qw.fw");
3120 MODULE_FIRMWARE("keyspan/usa18x.fw");
3121 MODULE_FIRMWARE("keyspan/usa19w.fw");
3122 MODULE_FIRMWARE("keyspan/usa49w.fw");
3123 MODULE_FIRMWARE("keyspan/usa49wlc.fw");
Linux with added FPC-III support