keyspan.c source code [linux/drivers/usb/serial/keyspan.c]

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

source code of linux/drivers/usb/serial/keyspan.c