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