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