Diff markup
1 /* 1 /*
2 * KLSI KL5KUSB105 chip RS232 converter driver 2 * KLSI KL5KUSB105 chip RS232 converter driver
3 * 3 *
4 * Copyright (C) 2001 Utz-Uwe Haus <haus@uuh 4 * Copyright (C) 2001 Utz-Uwe Haus <haus@uuhaus.de>
5 * 5 *
6 * This program is free software; you can re 6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Pub 7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either vers 8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version. 9 * (at your option) any later version.
10 * 10 *
11 * All information about the device was acquir 11 * All information about the device was acquired using SniffUSB ans snoopUSB
12 * on Windows98. 12 * on Windows98.
13 * It was written out of frustration with the 13 * It was written out of frustration with the PalmConnect USB Serial adapter
14 * sold by Palm Inc. 14 * sold by Palm Inc.
15 * Neither Palm, nor their contractor (MCCI) o 15 * Neither Palm, nor their contractor (MCCI) or their supplier (KLSI) provided
16 * information that was not already available. 16 * information that was not already available.
17 * 17 *
18 * It seems that KLSI bought some silicon-desi !! 18 * It seems that KLSI bought some silicon-design information from ScanLogic,
19 * whose SL11R processor is at the core of the 19 * whose SL11R processor is at the core of the KL5KUSB chipset from KLSI.
20 * KLSI has firmware available for their devic 20 * KLSI has firmware available for their devices; it is probable that the
21 * firmware differs from that used by KLSI in 21 * firmware differs from that used by KLSI in their products. If you have an
22 * original KLSI device and can provide some i !! 22 * original KLSI device and can provide some information on it, I would be
23 * most interested in adding support for it he !! 23 * most interested in adding support for it here. If you have any information
24 * on the protocol used (or find errors in my 24 * on the protocol used (or find errors in my reverse-engineered stuff), please
25 * let me know. 25 * let me know.
26 * 26 *
27 * The code was only tested with a PalmConnect 27 * The code was only tested with a PalmConnect USB adapter; if you
28 * are adventurous, try it with any KLSI-based 28 * are adventurous, try it with any KLSI-based device and let me know how it
29 * breaks so that I can fix it! 29 * breaks so that I can fix it!
30 */ 30 */
31 31
32 /* TODO: 32 /* TODO:
33 * check modem line signals 33 * check modem line signals
34 * implement handshaking or decide that w 34 * implement handshaking or decide that we do not support it
35 */ 35 */
36 36
37 /* History: 37 /* History:
38 * 0.3a - implemented pools of write URBs 38 * 0.3a - implemented pools of write URBs
39 * 0.3 - alpha version for public testing 39 * 0.3 - alpha version for public testing
40 * 0.2 - TIOCMGET works, so autopilot(1) ca 40 * 0.2 - TIOCMGET works, so autopilot(1) can be used!
41 * 0.1 - can be used to to pilot-xfer -p /d 41 * 0.1 - can be used to to pilot-xfer -p /dev/ttyUSB0 -l
42 * 42 *
43 * The driver skeleton is mainly based on mc !! 43 * The driver skeleton is mainly based on mct_u232.c and various other
44 * pieces of code shamelessly copied from th 44 * pieces of code shamelessly copied from the drivers/usb/serial/ directory.
45 */ 45 */
46 46
47 47
>> 48 #include <linux/config.h>
48 #include <linux/kernel.h> 49 #include <linux/kernel.h>
49 #include <linux/errno.h> 50 #include <linux/errno.h>
50 #include <linux/init.h> 51 #include <linux/init.h>
51 #include <linux/slab.h> 52 #include <linux/slab.h>
52 #include <linux/tty.h> 53 #include <linux/tty.h>
53 #include <linux/tty_driver.h> 54 #include <linux/tty_driver.h>
54 #include <linux/tty_flip.h> 55 #include <linux/tty_flip.h>
55 #include <linux/module.h> 56 #include <linux/module.h>
56 #include <linux/uaccess.h> !! 57 #include <asm/uaccess.h>
57 #include <asm/unaligned.h> <<
58 #include <linux/usb.h> 58 #include <linux/usb.h>
59 #include <linux/usb/serial.h> !! 59 #include "usb-serial.h"
60 #include "kl5kusb105.h" 60 #include "kl5kusb105.h"
61 61
62 static int debug; 62 static int debug;
63 63
64 /* 64 /*
65 * Version Information 65 * Version Information
66 */ 66 */
67 #define DRIVER_VERSION "v0.3a" 67 #define DRIVER_VERSION "v0.3a"
68 #define DRIVER_AUTHOR "Utz-Uwe Haus <haus@uuha 68 #define DRIVER_AUTHOR "Utz-Uwe Haus <haus@uuhaus.de>"
69 #define DRIVER_DESC "KLSI KL5KUSB105 chipset U 69 #define DRIVER_DESC "KLSI KL5KUSB105 chipset USB->Serial Converter driver"
70 70
71 71
72 /* 72 /*
73 * Function prototypes 73 * Function prototypes
74 */ 74 */
75 static int klsi_105_startup(struct usb_serial !! 75 static int klsi_105_startup (struct usb_serial *serial);
76 static void klsi_105_disconnect(struct usb_ser !! 76 static void klsi_105_shutdown (struct usb_serial *serial);
77 static void klsi_105_release(struct usb_serial !! 77 static int klsi_105_open (struct usb_serial_port *port,
78 static int klsi_105_open(struct tty_struct *t !! 78 struct file *filp);
79 struct usb_serial_port !! 79 static void klsi_105_close (struct usb_serial_port *port,
80 static void klsi_105_close(struct usb_serial_p !! 80 struct file *filp);
81 static int klsi_105_write(struct tty_struct * !! 81 static int klsi_105_write (struct usb_serial_port *port,
82 struct usb_serial_port *port, const un !! 82 const unsigned char *buf,
83 static void klsi_105_write_bulk_callback(struc !! 83 int count);
84 static int klsi_105_chars_in_buffer(struct tt !! 84 static void klsi_105_write_bulk_callback (struct urb *urb, struct pt_regs *regs);
85 static int klsi_105_write_room(struct tty_str !! 85 static int klsi_105_chars_in_buffer (struct usb_serial_port *port);
86 static void klsi_105_read_bulk_callback(struct !! 86 static int klsi_105_write_room (struct usb_serial_port *port);
87 static void klsi_105_set_termios(struct tty_st !! 87
88 struct usb_serial_port !! 88 static void klsi_105_read_bulk_callback (struct urb *urb, struct pt_regs *regs);
89 static void klsi_105_throttle(struct tty_struc !! 89 static void klsi_105_set_termios (struct usb_serial_port *port,
90 static void klsi_105_unthrottle(struct tty_str !! 90 struct termios * old);
91 static int klsi_105_tiocmget(struct tty_struc !! 91 static int klsi_105_ioctl (struct usb_serial_port *port,
92 static int klsi_105_tiocmset(struct tty_struc !! 92 struct file * file,
93 unsigned int set, unsi !! 93 unsigned int cmd,
>> 94 unsigned long arg);
>> 95 static void klsi_105_throttle (struct usb_serial_port *port);
>> 96 static void klsi_105_unthrottle (struct usb_serial_port *port);
>> 97 /*
>> 98 static void klsi_105_break_ctl (struct usb_serial_port *port,
>> 99 int break_state );
>> 100 */
>> 101 static int klsi_105_tiocmget (struct usb_serial_port *port,
>> 102 struct file *file);
>> 103 static int klsi_105_tiocmset (struct usb_serial_port *port,
>> 104 struct file *file, unsigned int set,
>> 105 unsigned int clear);
94 106
95 /* 107 /*
96 * All of the device info needed for the KLSI 108 * All of the device info needed for the KLSI converters.
97 */ 109 */
98 static struct usb_device_id id_table [] = { 110 static struct usb_device_id id_table [] = {
99 { USB_DEVICE(PALMCONNECT_VID, PALMCONN 111 { USB_DEVICE(PALMCONNECT_VID, PALMCONNECT_PID) },
100 { USB_DEVICE(KLSI_VID, KLSI_KL5KUSB105 112 { USB_DEVICE(KLSI_VID, KLSI_KL5KUSB105D_PID) },
101 { } /* Terminating entry * 113 { } /* Terminating entry */
102 }; 114 };
103 115
104 MODULE_DEVICE_TABLE(usb, id_table); !! 116 MODULE_DEVICE_TABLE (usb, id_table);
105 117
106 static struct usb_driver kl5kusb105d_driver = 118 static struct usb_driver kl5kusb105d_driver = {
>> 119 .owner = THIS_MODULE,
107 .name = "kl5kusb105d", 120 .name = "kl5kusb105d",
108 .probe = usb_serial_probe, 121 .probe = usb_serial_probe,
109 .disconnect = usb_serial_disconnect, 122 .disconnect = usb_serial_disconnect,
110 .id_table = id_table, 123 .id_table = id_table,
111 .no_dynamic_id = 1, <<
112 }; 124 };
113 125
114 static struct usb_serial_driver kl5kusb105d_de !! 126 static struct usb_serial_device_type kl5kusb105d_device = {
115 .driver = { !! 127 .owner = THIS_MODULE,
116 .owner = THIS_MODULE, !! 128 .name = "KL5KUSB105D / PalmConnect",
117 .name = "kl5kusb105d", !! 129 .short_name = "kl5kusb105d",
118 }, <<
119 .description = "KL5KUSB105D / Pa <<
120 .usb_driver = &kl5kusb105d_driv <<
121 .id_table = id_table, 130 .id_table = id_table,
>> 131 .num_interrupt_in = 1,
>> 132 .num_bulk_in = 1,
>> 133 .num_bulk_out = 1,
122 .num_ports = 1, 134 .num_ports = 1,
123 .open = klsi_105_open, 135 .open = klsi_105_open,
124 .close = klsi_105_close, 136 .close = klsi_105_close,
125 .write = klsi_105_write, 137 .write = klsi_105_write,
126 .write_bulk_callback = klsi_105_write_ 138 .write_bulk_callback = klsi_105_write_bulk_callback,
127 .chars_in_buffer = klsi_105_chars_in 139 .chars_in_buffer = klsi_105_chars_in_buffer,
128 .write_room = klsi_105_write_ro 140 .write_room = klsi_105_write_room,
129 .read_bulk_callback = klsi_105_read_bu !! 141 .read_bulk_callback =klsi_105_read_bulk_callback,
>> 142 .ioctl = klsi_105_ioctl,
130 .set_termios = klsi_105_set_term 143 .set_termios = klsi_105_set_termios,
131 /*.break_ctl = klsi_105_break_ct 144 /*.break_ctl = klsi_105_break_ctl,*/
132 .tiocmget = klsi_105_tiocmget 145 .tiocmget = klsi_105_tiocmget,
133 .tiocmset = klsi_105_tiocmset 146 .tiocmset = klsi_105_tiocmset,
134 .attach = klsi_105_startup, 147 .attach = klsi_105_startup,
135 .disconnect = klsi_105_disconne !! 148 .shutdown = klsi_105_shutdown,
136 .release = klsi_105_release, <<
137 .throttle = klsi_105_throttle 149 .throttle = klsi_105_throttle,
138 .unthrottle = klsi_105_unthrott 150 .unthrottle = klsi_105_unthrottle,
139 }; 151 };
140 152
141 struct klsi_105_port_settings { 153 struct klsi_105_port_settings {
142 __u8 pktlen; /* always 5, i 154 __u8 pktlen; /* always 5, it seems */
143 __u8 baudrate; 155 __u8 baudrate;
144 __u8 databits; 156 __u8 databits;
145 __u8 unknown1; 157 __u8 unknown1;
146 __u8 unknown2; 158 __u8 unknown2;
147 } __attribute__ ((packed)); 159 } __attribute__ ((packed));
148 160
149 /* we implement a pool of NUM_URBS urbs per us 161 /* we implement a pool of NUM_URBS urbs per usb_serial */
150 #define NUM_URBS 1 162 #define NUM_URBS 1
151 #define URB_TRANSFER_BUFFER_SIZE 64 163 #define URB_TRANSFER_BUFFER_SIZE 64
152 struct klsi_105_private { 164 struct klsi_105_private {
153 struct klsi_105_port_settings cfg; 165 struct klsi_105_port_settings cfg;
154 struct ktermios termio !! 166 struct termios termios;
155 unsigned long line_s 167 unsigned long line_state; /* modem line settings */
156 /* write pool */ 168 /* write pool */
157 struct urb *write !! 169 struct urb * write_urb_pool[NUM_URBS];
158 spinlock_t lock; 170 spinlock_t lock;
159 unsigned long bytes_ 171 unsigned long bytes_in;
160 unsigned long bytes_ 172 unsigned long bytes_out;
161 }; 173 };
162 174
163 175
164 /* 176 /*
165 * Handle vendor specific USB requests 177 * Handle vendor specific USB requests
166 */ 178 */
167 179
168 180
169 #define KLSI_TIMEOUT 5000 /* default urb t !! 181 #define KLSI_TIMEOUT (HZ * 5 ) /* default urb timeout */
170 182
171 static int klsi_105_chg_port_settings(struct u 183 static int klsi_105_chg_port_settings(struct usb_serial_port *port,
172 struct k 184 struct klsi_105_port_settings *settings)
173 { 185 {
174 int rc; 186 int rc;
175 187
176 rc = usb_control_msg(port->serial->dev !! 188 rc = usb_control_msg(port->serial->dev,
177 usb_sndctrlpipe(port-> !! 189 usb_sndctrlpipe(port->serial->dev, 0),
178 KL5KUSB105A_SIO_SET_DA !! 190 KL5KUSB105A_SIO_SET_DATA,
179 USB_TYPE_VENDOR | USB_ !! 191 USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_INTERFACE,
180 0, /* value */ !! 192 0, /* value */
181 0, /* index */ !! 193 0, /* index */
182 settings, !! 194 settings,
183 sizeof(struct klsi_105 !! 195 sizeof(struct klsi_105_port_settings),
184 KLSI_TIMEOUT); !! 196 KLSI_TIMEOUT);
185 if (rc < 0) 197 if (rc < 0)
186 dev_err(&port->dev, !! 198 err("Change port settings failed (error = %d)", rc);
187 "Change port settings !! 199 info("%s - %d byte block, baudrate %x, databits %d, u1 %d, u2 %d",
188 dev_info(&port->serial->dev->dev, !! 200 __FUNCTION__,
189 "%d byte block, baudrate %x, !! 201 settings->pktlen,
190 settings->pktlen, settings->b !! 202 settings->baudrate, settings->databits,
191 settings->unknown1, settings- !! 203 settings->unknown1, settings->unknown2);
192 return rc; !! 204 return rc;
193 } /* klsi_105_chg_port_settings */ 205 } /* klsi_105_chg_port_settings */
194 206
195 /* translate a 16-bit status value from the de 207 /* translate a 16-bit status value from the device to linux's TIO bits */
196 static unsigned long klsi_105_status2linestate 208 static unsigned long klsi_105_status2linestate(const __u16 status)
197 { 209 {
198 unsigned long res = 0; 210 unsigned long res = 0;
199 211
200 res = ((status & KL5KUSB105A_DSR) ? 212 res = ((status & KL5KUSB105A_DSR) ? TIOCM_DSR : 0)
201 | ((status & KL5KUSB105A_CTS) ? 213 | ((status & KL5KUSB105A_CTS) ? TIOCM_CTS : 0)
202 ; 214 ;
203 215
204 return res; 216 return res;
205 } 217 }
206 /* !! 218 /*
207 * Read line control via vendor command and re 219 * Read line control via vendor command and return result through
208 * *line_state_p !! 220 * *line_state_p
209 */ 221 */
210 /* It seems that the status buffer has always 222 /* It seems that the status buffer has always only 2 bytes length */
211 #define KLSI_STATUSBUF_LEN 2 223 #define KLSI_STATUSBUF_LEN 2
212 static int klsi_105_get_line_state(struct usb_ 224 static int klsi_105_get_line_state(struct usb_serial_port *port,
213 unsigned lo 225 unsigned long *line_state_p)
214 { 226 {
215 int rc; 227 int rc;
216 __u8 status_buf[KLSI_STATUSBUF_LEN] = !! 228 __u8 status_buf[KLSI_STATUSBUF_LEN] = { -1,-1};
217 __u16 status; 229 __u16 status;
218 230
219 dev_info(&port->serial->dev->dev, "sen !! 231 info("%s - sending SIO Poll request", __FUNCTION__);
220 rc = usb_control_msg(port->serial->dev !! 232 rc = usb_control_msg(port->serial->dev,
221 usb_rcvctrlpipe(p 233 usb_rcvctrlpipe(port->serial->dev, 0),
222 KL5KUSB105A_SIO_P 234 KL5KUSB105A_SIO_POLL,
223 USB_TYPE_VENDOR | !! 235 USB_TYPE_VENDOR | USB_DIR_IN,
224 0, /* value */ 236 0, /* value */
225 0, /* index */ 237 0, /* index */
226 status_buf, KLSI_ 238 status_buf, KLSI_STATUSBUF_LEN,
227 10000 !! 239 10*HZ
228 ); 240 );
229 if (rc < 0) 241 if (rc < 0)
230 dev_err(&port->dev, "Reading l !! 242 err("Reading line status failed (error = %d)", rc);
231 rc); <<
232 else { 243 else {
233 status = get_unaligned_le16(st !! 244 status = status_buf[0] + (status_buf[1]<<8);
234 245
235 dev_info(&port->serial->dev->d !! 246 info("%s - read status %x %x", __FUNCTION__,
236 status_buf[0], status !! 247 status_buf[0], status_buf[1]);
237 248
238 *line_state_p = klsi_105_statu 249 *line_state_p = klsi_105_status2linestate(status);
239 } 250 }
240 return rc; !! 251
>> 252 return rc;
241 } 253 }
242 254
243 255
244 /* 256 /*
245 * Driver's tty interface functions 257 * Driver's tty interface functions
246 */ 258 */
247 259
248 static int klsi_105_startup(struct usb_serial !! 260 static int klsi_105_startup (struct usb_serial *serial)
249 { 261 {
250 struct klsi_105_private *priv; 262 struct klsi_105_private *priv;
251 int i, j; !! 263 int i;
252 264
253 /* check if we support the product id 265 /* check if we support the product id (see keyspan.c)
254 * FIXME 266 * FIXME
255 */ 267 */
256 268
257 /* allocate the private data structure 269 /* allocate the private data structure */
258 for (i = 0; i < serial->num_ports; i++ !! 270 for (i=0; i<serial->num_ports; i++) {
>> 271 int j;
259 priv = kmalloc(sizeof(struct k 272 priv = kmalloc(sizeof(struct klsi_105_private),
260 273 GFP_KERNEL);
261 if (!priv) { 274 if (!priv) {
262 dbg("%skmalloc for kls !! 275 dbg("%skmalloc for klsi_105_private failed.", __FUNCTION__);
263 i--; !! 276 return -ENOMEM;
264 goto err_cleanup; <<
265 } 277 }
266 /* set initial values for cont 278 /* set initial values for control structures */
267 priv->cfg.pktlen = 5; 279 priv->cfg.pktlen = 5;
268 priv->cfg.baudrate = kl5kusb1 280 priv->cfg.baudrate = kl5kusb105a_sio_b9600;
269 priv->cfg.databits = kl5kusb1 281 priv->cfg.databits = kl5kusb105a_dtb_8;
270 priv->cfg.unknown1 = 0; 282 priv->cfg.unknown1 = 0;
271 priv->cfg.unknown2 = 1; 283 priv->cfg.unknown2 = 1;
272 284
273 priv->line_state = 0; 285 priv->line_state = 0;
274 286
275 priv->bytes_in = 0; 287 priv->bytes_in = 0;
276 priv->bytes_out = 0; 288 priv->bytes_out = 0;
277 usb_set_serial_port_data(seria 289 usb_set_serial_port_data(serial->port[i], priv);
278 290
279 spin_lock_init(&priv->lock); !! 291 spin_lock_init (&priv->lock);
280 for (j = 0; j < NUM_URBS; j++) !! 292 for (j=0; j<NUM_URBS; j++) {
281 struct urb *urb = usb_ !! 293 struct urb* urb = usb_alloc_urb(0, GFP_KERNEL);
282 294
283 priv->write_urb_pool[j 295 priv->write_urb_pool[j] = urb;
284 if (urb == NULL) { 296 if (urb == NULL) {
285 dev_err(&seria !! 297 err("No more urbs???");
286 goto err_clean !! 298 continue;
287 } 299 }
288 300
289 urb->transfer_buffer = !! 301 urb->transfer_buffer = NULL;
290 kmalloc(URB_TR !! 302 urb->transfer_buffer = kmalloc (URB_TRANSFER_BUFFER_SIZE,
>> 303 GFP_KERNEL);
291 if (!urb->transfer_buf 304 if (!urb->transfer_buffer) {
292 dev_err(&seria !! 305 err("%s - out of memory for urb buffers.", __FUNCTION__);
293 "%s - !! 306 continue;
294 __func <<
295 goto err_clean <<
296 } 307 }
297 } 308 }
298 309
299 /* priv->termios is left unini 310 /* priv->termios is left uninitalized until port opening */
300 init_waitqueue_head(&serial->p 311 init_waitqueue_head(&serial->port[i]->write_wait);
301 } 312 }
302 !! 313
303 return 0; !! 314 return (0);
304 <<
305 err_cleanup: <<
306 for (; i >= 0; i--) { <<
307 priv = usb_get_serial_port_dat <<
308 for (j = 0; j < NUM_URBS; j++) <<
309 if (priv->write_urb_po <<
310 kfree(priv->wr <<
311 usb_free_urb(p <<
312 } <<
313 } <<
314 usb_set_serial_port_data(seria <<
315 } <<
316 return -ENOMEM; <<
317 } /* klsi_105_startup */ 315 } /* klsi_105_startup */
318 316
319 317
320 static void klsi_105_disconnect(struct usb_ser !! 318 static void klsi_105_shutdown (struct usb_serial *serial)
321 { 319 {
322 int i; 320 int i;
323 !! 321
324 dbg("%s", __func__); !! 322 dbg("%s", __FUNCTION__);
325 323
326 /* stop reads and writes on all ports 324 /* stop reads and writes on all ports */
327 for (i = 0; i < serial->num_ports; ++i !! 325 for (i=0; i < serial->num_ports; ++i) {
328 struct klsi_105_private *priv !! 326 struct klsi_105_private *priv = usb_get_serial_port_data(serial->port[i]);
329 usb_get_serial !! 327 unsigned long flags;
330 328
331 if (priv) { 329 if (priv) {
332 /* kill our write urb 330 /* kill our write urb pool */
333 int j; 331 int j;
334 struct urb **write_urb 332 struct urb **write_urbs = priv->write_urb_pool;
>> 333 spin_lock_irqsave(&priv->lock,flags);
335 334
336 for (j = 0; j < NUM_UR 335 for (j = 0; j < NUM_URBS; j++) {
337 if (write_urbs 336 if (write_urbs[j]) {
338 usb_ki !! 337 /* FIXME - uncomment the following
339 usb_fr !! 338 * usb_kill_urb call when the host
>> 339 * controllers get fixed to set
>> 340 * urb->dev = NULL after the urb is
>> 341 * finished. Otherwise this call
>> 342 * oopses. */
>> 343 /* usb_kill_urb(write_urbs[j]); */
>> 344 if (write_urbs[j]->transfer_buffer)
>> 345 kfree(write_urbs[j]->transfer_buffer);
>> 346 usb_free_urb (write_urbs[j]);
340 } 347 }
341 } 348 }
342 } <<
343 } <<
344 } /* klsi_105_disconnect */ <<
345 <<
346 <<
347 static void klsi_105_release(struct usb_serial <<
348 { <<
349 int i; <<
350 <<
351 dbg("%s", __func__); <<
352 349
353 for (i = 0; i < serial->num_ports; ++i !! 350 spin_unlock_irqrestore (&priv->lock, flags);
354 struct klsi_105_private *priv <<
355 usb_get_serial <<
356 351
357 kfree(priv); !! 352 kfree(priv);
>> 353 usb_set_serial_port_data(serial->port[i], NULL);
>> 354 }
358 } 355 }
359 } /* klsi_105_release */ !! 356 } /* klsi_105_shutdown */
360 357
361 static int klsi_105_open(struct tty_struct *t !! 358 static int klsi_105_open (struct usb_serial_port *port, struct file *filp)
362 struct usb_serial_port <<
363 { 359 {
364 struct klsi_105_private *priv = usb_ge 360 struct klsi_105_private *priv = usb_get_serial_port_data(port);
365 int retval = 0; 361 int retval = 0;
366 int rc; 362 int rc;
367 int i; 363 int i;
368 unsigned long line_state; 364 unsigned long line_state;
369 struct klsi_105_port_settings cfg; 365 struct klsi_105_port_settings cfg;
370 unsigned long flags; 366 unsigned long flags;
371 367
372 dbg("%s port %d", __func__, port->numb !! 368 dbg("%s port %d", __FUNCTION__, port->number);
373 369
374 /* force low_latency on so that our tt 370 /* force low_latency on so that our tty_push actually forces
375 * the data through 371 * the data through
376 * tty->low_latency = 1; */ !! 372 * port->tty->low_latency = 1; */
377 373
378 /* Do a defined restart: 374 /* Do a defined restart:
379 * Set up sane default baud rate and s 375 * Set up sane default baud rate and send the 'READ_ON'
380 * vendor command. !! 376 * vendor command.
381 * FIXME: set modem line control (how? 377 * FIXME: set modem line control (how?)
382 * Then read the modem line control an 378 * Then read the modem line control and store values in
383 * priv->line_state. 379 * priv->line_state.
384 */ 380 */
385 cfg.pktlen = 5; 381 cfg.pktlen = 5;
386 cfg.baudrate = kl5kusb105a_sio_b9600; 382 cfg.baudrate = kl5kusb105a_sio_b9600;
387 cfg.databits = kl5kusb105a_dtb_8; 383 cfg.databits = kl5kusb105a_dtb_8;
388 cfg.unknown1 = 0; 384 cfg.unknown1 = 0;
389 cfg.unknown2 = 1; 385 cfg.unknown2 = 1;
390 klsi_105_chg_port_settings(port, &cfg) 386 klsi_105_chg_port_settings(port, &cfg);
391 !! 387
392 /* set up termios structure */ 388 /* set up termios structure */
393 spin_lock_irqsave(&priv->lock, flags); !! 389 spin_lock_irqsave (&priv->lock, flags);
394 priv->termios.c_iflag = tty->termios-> !! 390 priv->termios.c_iflag = port->tty->termios->c_iflag;
395 priv->termios.c_oflag = tty->termios-> !! 391 priv->termios.c_oflag = port->tty->termios->c_oflag;
396 priv->termios.c_cflag = tty->termios-> !! 392 priv->termios.c_cflag = port->tty->termios->c_cflag;
397 priv->termios.c_lflag = tty->termios-> !! 393 priv->termios.c_lflag = port->tty->termios->c_lflag;
398 for (i = 0; i < NCCS; i++) !! 394 for (i=0; i<NCCS; i++)
399 priv->termios.c_cc[i] = tty->t !! 395 priv->termios.c_cc[i] = port->tty->termios->c_cc[i];
400 priv->cfg.pktlen = cfg.pktlen; 396 priv->cfg.pktlen = cfg.pktlen;
401 priv->cfg.baudrate = cfg.baudrate; 397 priv->cfg.baudrate = cfg.baudrate;
402 priv->cfg.databits = cfg.databits; 398 priv->cfg.databits = cfg.databits;
403 priv->cfg.unknown1 = cfg.unknown1; 399 priv->cfg.unknown1 = cfg.unknown1;
404 priv->cfg.unknown2 = cfg.unknown2; 400 priv->cfg.unknown2 = cfg.unknown2;
405 spin_unlock_irqrestore(&priv->lock, fl !! 401 spin_unlock_irqrestore (&priv->lock, flags);
406 402
407 /* READ_ON and urb submission */ 403 /* READ_ON and urb submission */
408 usb_fill_bulk_urb(port->read_urb, port !! 404 usb_fill_bulk_urb(port->read_urb, port->serial->dev,
409 usb_rcvbulkpipe(port->se 405 usb_rcvbulkpipe(port->serial->dev,
410 port->bu 406 port->bulk_in_endpointAddress),
411 port->read_urb->transfer 407 port->read_urb->transfer_buffer,
412 port->read_urb->transfer 408 port->read_urb->transfer_buffer_length,
413 klsi_105_read_bulk_callb 409 klsi_105_read_bulk_callback,
414 port); 410 port);
415 411
416 rc = usb_submit_urb(port->read_urb, GF 412 rc = usb_submit_urb(port->read_urb, GFP_KERNEL);
417 if (rc) { 413 if (rc) {
418 dev_err(&port->dev, "%s - fail !! 414 err("%s - failed submitting read urb, error %d", __FUNCTION__, rc);
419 "error %d\n", __func__ <<
420 retval = rc; 415 retval = rc;
421 goto exit; 416 goto exit;
422 } 417 }
423 418
424 rc = usb_control_msg(port->serial->dev 419 rc = usb_control_msg(port->serial->dev,
425 usb_sndctrlpipe(p !! 420 usb_sndctrlpipe(port->serial->dev,0),
426 KL5KUSB105A_SIO_C 421 KL5KUSB105A_SIO_CONFIGURE,
427 USB_TYPE_VENDOR|U 422 USB_TYPE_VENDOR|USB_DIR_OUT|USB_RECIP_INTERFACE,
428 KL5KUSB105A_SIO_C 423 KL5KUSB105A_SIO_CONFIGURE_READ_ON,
429 0, /* index */ 424 0, /* index */
430 NULL, 425 NULL,
431 0, 426 0,
432 KLSI_TIMEOUT); 427 KLSI_TIMEOUT);
433 if (rc < 0) { 428 if (rc < 0) {
434 dev_err(&port->dev, "Enabling !! 429 err("Enabling read failed (error = %d)", rc);
435 retval = rc; 430 retval = rc;
436 } else !! 431 } else
437 dbg("%s - enabled reading", __ !! 432 dbg("%s - enabled reading", __FUNCTION__);
438 433
439 rc = klsi_105_get_line_state(port, &li 434 rc = klsi_105_get_line_state(port, &line_state);
440 if (rc >= 0) { 435 if (rc >= 0) {
441 spin_lock_irqsave(&priv->lock, !! 436 spin_lock_irqsave (&priv->lock, flags);
442 priv->line_state = line_state; 437 priv->line_state = line_state;
443 spin_unlock_irqrestore(&priv-> !! 438 spin_unlock_irqrestore (&priv->lock, flags);
444 dbg("%s - read line state 0x%l !! 439 dbg("%s - read line state 0x%lx", __FUNCTION__, line_state);
445 retval = 0; 440 retval = 0;
446 } else 441 } else
447 retval = rc; 442 retval = rc;
448 443
449 exit: 444 exit:
450 return retval; 445 return retval;
451 } /* klsi_105_open */ 446 } /* klsi_105_open */
452 447
453 448
454 static void klsi_105_close(struct usb_serial_p !! 449 static void klsi_105_close (struct usb_serial_port *port, struct file *filp)
455 { 450 {
456 struct klsi_105_private *priv = usb_ge 451 struct klsi_105_private *priv = usb_get_serial_port_data(port);
457 int rc; 452 int rc;
458 453
459 dbg("%s port %d", __func__, port->numb !! 454 dbg("%s port %d", __FUNCTION__, port->number);
460 455
461 mutex_lock(&port->serial->disc_mutex); !! 456 /* send READ_OFF */
462 if (!port->serial->disconnected) { !! 457 rc = usb_control_msg (port->serial->dev,
463 /* send READ_OFF */ !! 458 usb_sndctrlpipe(port->serial->dev, 0),
464 rc = usb_control_msg(port->ser !! 459 KL5KUSB105A_SIO_CONFIGURE,
465 usb_sndct !! 460 USB_TYPE_VENDOR | USB_DIR_OUT,
466 KL5KUSB10 !! 461 KL5KUSB105A_SIO_CONFIGURE_READ_OFF,
467 USB_TYPE_ !! 462 0, /* index */
468 KL5KUSB10 !! 463 NULL, 0,
469 0, /* ind !! 464 KLSI_TIMEOUT);
470 NULL, 0, !! 465 if (rc < 0)
471 KLSI_TIME !! 466 err("Disabling read failed (error = %d)", rc);
472 if (rc < 0) <<
473 dev_err(&port->dev, <<
474 "Disabling rea <<
475 } <<
476 mutex_unlock(&port->serial->disc_mutex <<
477 467
478 /* shutdown our bulk reads and writes 468 /* shutdown our bulk reads and writes */
479 usb_kill_urb(port->write_urb); 469 usb_kill_urb(port->write_urb);
480 usb_kill_urb(port->read_urb); 470 usb_kill_urb(port->read_urb);
481 /* unlink our write pool */ 471 /* unlink our write pool */
482 /* FIXME */ 472 /* FIXME */
483 /* wgg - do I need this? I think so. * 473 /* wgg - do I need this? I think so. */
484 usb_kill_urb(port->interrupt_in_urb); 474 usb_kill_urb(port->interrupt_in_urb);
485 dev_info(&port->serial->dev->dev, !! 475 info("kl5kusb105 port stats: %ld bytes in, %ld bytes out", priv->bytes_in, priv->bytes_out);
486 "port stats: %ld bytes in, %l <<
487 priv->bytes_in, priv->bytes_o <<
488 } /* klsi_105_close */ 476 } /* klsi_105_close */
489 477
490 478
491 /* We need to write a complete 64-byte data bl 479 /* We need to write a complete 64-byte data block and encode the
492 * number actually sent in the first double-by !! 480 * number actually sent in the first double-byte, LSB-order. That
493 * leaves at most 62 bytes of payload. 481 * leaves at most 62 bytes of payload.
494 */ 482 */
495 #define KLSI_105_DATA_OFFSET 2 /* in the 483 #define KLSI_105_DATA_OFFSET 2 /* in the bulk urb data block */
496 484
497 485
498 static int klsi_105_write(struct tty_struct *t !! 486 static int klsi_105_write (struct usb_serial_port *port,
499 struct usb_serial_port *port, const un !! 487 const unsigned char *buf, int count)
500 { 488 {
501 struct klsi_105_private *priv = usb_ge 489 struct klsi_105_private *priv = usb_get_serial_port_data(port);
502 int result, size; 490 int result, size;
503 int bytes_sent = 0; !! 491 int bytes_sent=0;
504 492
505 dbg("%s - port %d", __func__, port->nu !! 493 dbg("%s - port %d", __FUNCTION__, port->number);
506 494
507 while (count > 0) { 495 while (count > 0) {
508 /* try to find a free urb (wri 496 /* try to find a free urb (write 0 bytes if none) */
509 struct urb *urb = NULL; 497 struct urb *urb = NULL;
510 unsigned long flags; 498 unsigned long flags;
511 int i; 499 int i;
512 /* since the pool is per-port !! 500 /* since the pool is per-port we might not need the spin lock !? */
513 the spin lock !? */ !! 501 spin_lock_irqsave (&priv->lock, flags);
514 spin_lock_irqsave(&priv->lock, !! 502 for (i=0; i<NUM_URBS; i++) {
515 for (i = 0; i < NUM_URBS; i++) <<
516 if (priv->write_urb_po 503 if (priv->write_urb_pool[i]->status != -EINPROGRESS) {
517 urb = priv->wr 504 urb = priv->write_urb_pool[i];
518 dbg("%s - usin !! 505 dbg("%s - using pool URB %d", __FUNCTION__, i);
519 break; 506 break;
520 } 507 }
521 } 508 }
522 spin_unlock_irqrestore(&priv-> !! 509 spin_unlock_irqrestore (&priv->lock, flags);
523 510
524 if (urb == NULL) { !! 511 if (urb==NULL) {
525 dbg("%s - no more free !! 512 dbg("%s - no more free urbs", __FUNCTION__);
526 goto exit; 513 goto exit;
527 } 514 }
528 515
529 if (urb->transfer_buffer == NU 516 if (urb->transfer_buffer == NULL) {
530 urb->transfer_buffer = !! 517 urb->transfer_buffer = kmalloc (URB_TRANSFER_BUFFER_SIZE, GFP_ATOMIC);
531 kmalloc(URB_TR <<
532 if (urb->transfer_buff 518 if (urb->transfer_buffer == NULL) {
533 dev_err(&port- !! 519 err("%s - no more kernel memory...", __FUNCTION__);
534 "%s - <<
535 __func <<
536 goto exit; 520 goto exit;
537 } 521 }
538 } 522 }
539 523
540 size = min(count, port->bulk_o !! 524 size = min (count, port->bulk_out_size - KLSI_105_DATA_OFFSET);
541 size = min(size, URB_TRANSFER_ !! 525 size = min (size, URB_TRANSFER_BUFFER_SIZE - KLSI_105_DATA_OFFSET);
542 <<
543 526
544 memcpy(urb->transfer_buffer + !! 527 memcpy (urb->transfer_buffer + KLSI_105_DATA_OFFSET, buf, size);
545 528
546 /* write payload size into tra 529 /* write payload size into transfer buffer */
547 ((__u8 *)urb->transfer_buffer) 530 ((__u8 *)urb->transfer_buffer)[0] = (__u8) (size & 0xFF);
548 ((__u8 *)urb->transfer_buffer) 531 ((__u8 *)urb->transfer_buffer)[1] = (__u8) ((size & 0xFF00)>>8);
549 532
550 /* set up our urb */ 533 /* set up our urb */
551 usb_fill_bulk_urb(urb, port->s 534 usb_fill_bulk_urb(urb, port->serial->dev,
552 usb_sndbulkpipe( 535 usb_sndbulkpipe(port->serial->dev,
553 536 port->bulk_out_endpointAddress),
554 urb->transfer_bu 537 urb->transfer_buffer,
555 URB_TRANSFER_BUF 538 URB_TRANSFER_BUFFER_SIZE,
556 klsi_105_write_b 539 klsi_105_write_bulk_callback,
557 port); 540 port);
558 541
559 /* send the data out the bulk 542 /* send the data out the bulk port */
560 result = usb_submit_urb(urb, G 543 result = usb_submit_urb(urb, GFP_ATOMIC);
561 if (result) { 544 if (result) {
562 dev_err(&port->dev, !! 545 err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
563 "%s - failed s <<
564 __func__, resu <<
565 goto exit; 546 goto exit;
566 } 547 }
567 buf += size; 548 buf += size;
568 bytes_sent += size; 549 bytes_sent += size;
569 count -= size; 550 count -= size;
570 } 551 }
571 exit: 552 exit:
572 /* lockless, but it's for debug info o 553 /* lockless, but it's for debug info only... */
573 priv->bytes_out += bytes_sent; !! 554 priv->bytes_out+=bytes_sent;
574 555
575 return bytes_sent; /* that's how 556 return bytes_sent; /* that's how much we wrote */
576 } /* klsi_105_write */ 557 } /* klsi_105_write */
577 558
578 static void klsi_105_write_bulk_callback(struc !! 559 static void klsi_105_write_bulk_callback ( struct urb *urb, struct pt_regs *regs)
579 { 560 {
580 struct usb_serial_port *port = urb->co !! 561 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
581 int status = urb->status; <<
582 <<
583 dbg("%s - port %d", __func__, port->nu <<
584 562
585 if (status) { !! 563 dbg("%s - port %d", __FUNCTION__, port->number);
586 dbg("%s - nonzero write bulk s !! 564
587 status); !! 565 if (urb->status) {
>> 566 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__,
>> 567 urb->status);
588 return; 568 return;
589 } 569 }
590 570
591 usb_serial_port_softint(port); !! 571 /* from generic_write_bulk_callback */
>> 572 schedule_work(&port->work);
592 } /* klsi_105_write_bulk_completion_callback * 573 } /* klsi_105_write_bulk_completion_callback */
593 574
594 575
595 /* return number of characters currently in th 576 /* return number of characters currently in the writing process */
596 static int klsi_105_chars_in_buffer(struct tty !! 577 static int klsi_105_chars_in_buffer (struct usb_serial_port *port)
597 { 578 {
598 struct usb_serial_port *port = tty->dr <<
599 int chars = 0; 579 int chars = 0;
600 int i; 580 int i;
601 unsigned long flags; 581 unsigned long flags;
602 struct klsi_105_private *priv = usb_ge 582 struct klsi_105_private *priv = usb_get_serial_port_data(port);
603 583
604 spin_lock_irqsave(&priv->lock, flags); !! 584 spin_lock_irqsave (&priv->lock, flags);
605 585
606 for (i = 0; i < NUM_URBS; ++i) { 586 for (i = 0; i < NUM_URBS; ++i) {
607 if (priv->write_urb_pool[i]->s !! 587 if (priv->write_urb_pool[i]->status == -EINPROGRESS) {
608 chars += URB_TRANSFER_ 588 chars += URB_TRANSFER_BUFFER_SIZE;
>> 589 }
609 } 590 }
610 591
611 spin_unlock_irqrestore(&priv->lock, fl !! 592 spin_unlock_irqrestore (&priv->lock, flags);
612 593
613 dbg("%s - returns %d", __func__, chars !! 594 dbg("%s - returns %d", __FUNCTION__, chars);
614 return chars; !! 595 return (chars);
615 } 596 }
616 597
617 static int klsi_105_write_room(struct tty_stru !! 598 static int klsi_105_write_room (struct usb_serial_port *port)
618 { 599 {
619 struct usb_serial_port *port = tty->dr <<
620 unsigned long flags; 600 unsigned long flags;
621 int i; 601 int i;
622 int room = 0; 602 int room = 0;
623 struct klsi_105_private *priv = usb_ge 603 struct klsi_105_private *priv = usb_get_serial_port_data(port);
624 604
625 spin_lock_irqsave(&priv->lock, flags); !! 605 spin_lock_irqsave (&priv->lock, flags);
626 for (i = 0; i < NUM_URBS; ++i) { 606 for (i = 0; i < NUM_URBS; ++i) {
627 if (priv->write_urb_pool[i]->s !! 607 if (priv->write_urb_pool[i]->status != -EINPROGRESS) {
628 room += URB_TRANSFER_B 608 room += URB_TRANSFER_BUFFER_SIZE;
>> 609 }
629 } 610 }
630 611
631 spin_unlock_irqrestore(&priv->lock, fl !! 612 spin_unlock_irqrestore (&priv->lock, flags);
632 613
633 dbg("%s - returns %d", __func__, room) !! 614 dbg("%s - returns %d", __FUNCTION__, room);
634 return room; !! 615 return (room);
635 } 616 }
636 617
637 618
638 619
639 static void klsi_105_read_bulk_callback(struct !! 620 static void klsi_105_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
640 { 621 {
641 struct usb_serial_port *port = urb->co !! 622 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
642 struct klsi_105_private *priv = usb_ge 623 struct klsi_105_private *priv = usb_get_serial_port_data(port);
643 struct tty_struct *tty; 624 struct tty_struct *tty;
644 unsigned char *data = urb->transfer_bu 625 unsigned char *data = urb->transfer_buffer;
645 int rc; 626 int rc;
646 int status = urb->status; <<
647 627
648 dbg("%s - port %d", __func__, port->nu !! 628 dbg("%s - port %d", __FUNCTION__, port->number);
649 629
650 /* The urb might have been killed. */ 630 /* The urb might have been killed. */
651 if (status) { !! 631 if (urb->status) {
652 dbg("%s - nonzero read bulk st !! 632 dbg("%s - nonzero read bulk status received: %d", __FUNCTION__,
653 status); !! 633 urb->status);
654 return; !! 634 return;
655 } !! 635 }
656 !! 636
657 /* The data received is again preceded 637 /* The data received is again preceded by a length double-byte in LSB-
658 * first order (see klsi_105_write() ) 638 * first order (see klsi_105_write() )
659 */ 639 */
660 if (urb->actual_length == 0) { 640 if (urb->actual_length == 0) {
661 /* empty urbs seem to happen, 641 /* empty urbs seem to happen, we ignore them */
662 /* dbg("%s - emtpy URB", __fun !! 642 /* dbg("%s - emtpy URB", __FUNCTION__); */
663 ; 643 ;
664 } else if (urb->actual_length <= 2) { 644 } else if (urb->actual_length <= 2) {
665 dbg("%s - size %d URB not unde !! 645 dbg("%s - size %d URB not understood", __FUNCTION__,
666 urb->actual_length); 646 urb->actual_length);
667 usb_serial_debug_data(debug, & !! 647 usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
668 urb->act 648 urb->actual_length, data);
669 } else { 649 } else {
>> 650 int i;
670 int bytes_sent = ((__u8 *) dat 651 int bytes_sent = ((__u8 *) data)[0] +
671 ((unsigned in 652 ((unsigned int) ((__u8 *) data)[1] << 8);
672 tty = tty_port_tty_get(&port-> !! 653 tty = port->tty;
673 /* we should immediately resub 654 /* we should immediately resubmit the URB, before attempting
674 * to pass the data on to the 655 * to pass the data on to the tty layer. But that needs locking
675 * against re-entry an then mi 656 * against re-entry an then mixed-up data because of
676 * intermixed tty_flip_buffer_ 657 * intermixed tty_flip_buffer_push()s
677 * FIXME 658 * FIXME
678 */ !! 659 */
679 usb_serial_debug_data(debug, & !! 660 usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
680 urb->act 661 urb->actual_length, data);
681 662
682 if (bytes_sent + 2 > urb->actu 663 if (bytes_sent + 2 > urb->actual_length) {
683 dbg("%s - trying to re 664 dbg("%s - trying to read more data than available"
684 " (%d vs. %d)", __ !! 665 " (%d vs. %d)", __FUNCTION__,
685 bytes_sent+2, urb- 666 bytes_sent+2, urb->actual_length);
686 /* cap at implied limi 667 /* cap at implied limit */
687 bytes_sent = urb->actu 668 bytes_sent = urb->actual_length - 2;
688 } 669 }
689 670
690 tty_buffer_request_room(tty, b !! 671 for (i = 2; i < 2+bytes_sent; i++) {
691 tty_insert_flip_string(tty, da !! 672 /* if we insert more than TTY_FLIPBUF_SIZE characters,
>> 673 * we drop them. */
>> 674 if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
>> 675 tty_flip_buffer_push(tty);
>> 676 }
>> 677 /* this doesn't actually push the data through unless
>> 678 * tty->low_latency is set */
>> 679 tty_insert_flip_char(tty, ((__u8*) data)[i], 0);
>> 680 }
692 tty_flip_buffer_push(tty); 681 tty_flip_buffer_push(tty);
693 tty_kref_put(tty); <<
694 682
695 /* again lockless, but debug i 683 /* again lockless, but debug info only */
696 priv->bytes_in += bytes_sent; 684 priv->bytes_in += bytes_sent;
697 } 685 }
698 /* Continue trying to always read */ 686 /* Continue trying to always read */
699 usb_fill_bulk_urb(port->read_urb, port !! 687 usb_fill_bulk_urb(port->read_urb, port->serial->dev,
700 usb_rcvbulkpipe(port->se 688 usb_rcvbulkpipe(port->serial->dev,
701 port->bu 689 port->bulk_in_endpointAddress),
702 port->read_urb->transfer 690 port->read_urb->transfer_buffer,
703 port->read_urb->transfer 691 port->read_urb->transfer_buffer_length,
704 klsi_105_read_bulk_callb 692 klsi_105_read_bulk_callback,
705 port); 693 port);
706 rc = usb_submit_urb(port->read_urb, GF 694 rc = usb_submit_urb(port->read_urb, GFP_ATOMIC);
707 if (rc) 695 if (rc)
708 dev_err(&port->dev, !! 696 err("%s - failed resubmitting read urb, error %d", __FUNCTION__, rc);
709 "%s - failed resubmitt <<
710 __func__, rc); <<
711 } /* klsi_105_read_bulk_callback */ 697 } /* klsi_105_read_bulk_callback */
712 698
713 699
714 static void klsi_105_set_termios(struct tty_st !! 700 static void klsi_105_set_termios (struct usb_serial_port *port,
715 struct usb_se !! 701 struct termios *old_termios)
716 struct ktermi <<
717 { 702 {
718 struct klsi_105_private *priv = usb_ge 703 struct klsi_105_private *priv = usb_get_serial_port_data(port);
719 unsigned int iflag = tty->termios->c_i !! 704 unsigned int iflag = port->tty->termios->c_iflag;
720 unsigned int old_iflag = old_termios-> 705 unsigned int old_iflag = old_termios->c_iflag;
721 unsigned int cflag = tty->termios->c_c !! 706 unsigned int cflag = port->tty->termios->c_cflag;
722 unsigned int old_cflag = old_termios-> 707 unsigned int old_cflag = old_termios->c_cflag;
723 struct klsi_105_port_settings cfg; 708 struct klsi_105_port_settings cfg;
724 unsigned long flags; 709 unsigned long flags;
725 speed_t baud; !! 710
726 <<
727 /* lock while we are modifying the set 711 /* lock while we are modifying the settings */
728 spin_lock_irqsave(&priv->lock, flags); !! 712 spin_lock_irqsave (&priv->lock, flags);
729 !! 713
730 /* 714 /*
731 * Update baud rate 715 * Update baud rate
732 */ 716 */
733 baud = tty_get_baud_rate(tty); !! 717 if( (cflag & CBAUD) != (old_cflag & CBAUD) ) {
734 !! 718 /* reassert DTR and (maybe) RTS on transition from B0 */
735 if ((cflag & CBAUD) != (old_cflag & CB !! 719 if( (old_cflag & CBAUD) == B0 ) {
736 /* reassert DTR and (maybe) RT !! 720 dbg("%s: baud was B0", __FUNCTION__);
737 if ((old_cflag & CBAUD) == B0) <<
738 dbg("%s: baud was B0", <<
739 #if 0 721 #if 0
740 priv->control_state |= 722 priv->control_state |= TIOCM_DTR;
741 /* don't set RTS if us 723 /* don't set RTS if using hardware flow control */
742 if (!(old_cflag & CRTS !! 724 if (!(old_cflag & CRTSCTS)) {
743 priv->control_ 725 priv->control_state |= TIOCM_RTS;
>> 726 }
744 mct_u232_set_modem_ctr 727 mct_u232_set_modem_ctrl(serial, priv->control_state);
745 #endif 728 #endif
746 } 729 }
747 } !! 730
748 switch (baud) { !! 731 switch(cflag & CBAUD) {
749 case 0: /* handled below */ !! 732 case B0: /* handled below */
750 break; !! 733 break;
751 case 1200: !! 734 case B1200: priv->cfg.baudrate = kl5kusb105a_sio_b1200;
752 priv->cfg.baudrate = kl5kusb10 !! 735 break;
753 break; !! 736 case B2400: priv->cfg.baudrate = kl5kusb105a_sio_b2400;
754 case 2400: !! 737 break;
755 priv->cfg.baudrate = kl5kusb10 !! 738 case B4800: priv->cfg.baudrate = kl5kusb105a_sio_b4800;
756 break; !! 739 break;
757 case 4800: !! 740 case B9600: priv->cfg.baudrate = kl5kusb105a_sio_b9600;
758 priv->cfg.baudrate = kl5kusb10 !! 741 break;
759 break; !! 742 case B19200: priv->cfg.baudrate = kl5kusb105a_sio_b19200;
760 case 9600: !! 743 break;
761 priv->cfg.baudrate = kl5kusb10 !! 744 case B38400: priv->cfg.baudrate = kl5kusb105a_sio_b38400;
762 break; !! 745 break;
763 case 19200: !! 746 case B57600: priv->cfg.baudrate = kl5kusb105a_sio_b57600;
764 priv->cfg.baudrate = kl5kusb10 !! 747 break;
765 break; !! 748 case B115200: priv->cfg.baudrate = kl5kusb105a_sio_b115200;
766 case 38400: !! 749 break;
767 priv->cfg.baudrate = kl5kusb10 !! 750 default:
768 break; !! 751 err("KLSI USB->Serial converter:"
769 case 57600: !! 752 " unsupported baudrate request, using default"
770 priv->cfg.baudrate = kl5kusb10 !! 753 " of 9600");
771 break; <<
772 case 115200: <<
773 priv->cfg.baudrate = kl5kusb10 <<
774 break; <<
775 default: <<
776 dbg("KLSI USB->Serial converte <<
777 " unsupported baudrate req <<
778 priv->cfg.baudrate = k 754 priv->cfg.baudrate = kl5kusb105a_sio_b9600;
779 baud = 9600; !! 755 break;
780 break; !! 756 }
781 } !! 757 if ((cflag & CBAUD) == B0 ) {
782 if ((cflag & CBAUD) == B0) { !! 758 dbg("%s: baud is B0", __FUNCTION__);
783 dbg("%s: baud is B0", __func__ !! 759 /* Drop RTS and DTR */
784 /* Drop RTS and DTR */ !! 760 /* maybe this should be simulated by sending read
785 /* maybe this should be simula !! 761 * disable and read enable messages?
786 * disable and read enable mes !! 762 */
787 */ !! 763 ;
788 ; <<
789 #if 0 764 #if 0
790 priv->control_state &= ~(TIOCM !! 765 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
791 mct_u232_set_modem_ctrl(serial !! 766 mct_u232_set_modem_ctrl(serial, priv->control_state);
792 #endif 767 #endif
>> 768 }
793 } 769 }
794 tty_encode_baud_rate(tty, baud, baud); <<
795 770
796 if ((cflag & CSIZE) != (old_cflag & CS 771 if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
797 /* set the number of data bits 772 /* set the number of data bits */
798 switch (cflag & CSIZE) { 773 switch (cflag & CSIZE) {
799 case CS5: 774 case CS5:
800 dbg("%s - 5 bits/byte !! 775 dbg("%s - 5 bits/byte not supported", __FUNCTION__);
801 spin_unlock_irqrestore !! 776 spin_unlock_irqrestore (&priv->lock, flags);
802 return ; 777 return ;
803 case CS6: 778 case CS6:
804 dbg("%s - 6 bits/byte !! 779 dbg("%s - 6 bits/byte not supported", __FUNCTION__);
805 spin_unlock_irqrestore !! 780 spin_unlock_irqrestore (&priv->lock, flags);
806 return ; 781 return ;
807 case CS7: 782 case CS7:
808 priv->cfg.databits = k 783 priv->cfg.databits = kl5kusb105a_dtb_7;
809 break; 784 break;
810 case CS8: 785 case CS8:
811 priv->cfg.databits = k 786 priv->cfg.databits = kl5kusb105a_dtb_8;
812 break; 787 break;
813 default: 788 default:
814 dev_err(&port->dev, !! 789 err("CSIZE was not CS5-CS8, using default of 8");
815 "CSIZE was not <<
816 priv->cfg.databits = k 790 priv->cfg.databits = kl5kusb105a_dtb_8;
817 break; 791 break;
818 } 792 }
819 } 793 }
820 794
821 /* 795 /*
822 * Update line control register (LCR) 796 * Update line control register (LCR)
823 */ 797 */
824 if ((cflag & (PARENB|PARODD)) != (old_ 798 if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))
825 || (cflag & CSTOPB) != (old_cflag !! 799 || (cflag & CSTOPB) != (old_cflag & CSTOPB) ) {
826 /* Not currently supported */ !! 800
827 tty->termios->c_cflag &= ~(PAR <<
828 #if 0 801 #if 0
829 priv->last_lcr = 0; 802 priv->last_lcr = 0;
830 803
831 /* set the parity */ 804 /* set the parity */
832 if (cflag & PARENB) 805 if (cflag & PARENB)
833 priv->last_lcr |= (cfl 806 priv->last_lcr |= (cflag & PARODD) ?
834 MCT_U232_PARIT 807 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
835 else 808 else
836 priv->last_lcr |= MCT_ 809 priv->last_lcr |= MCT_U232_PARITY_NONE;
837 810
838 /* set the number of stop bits 811 /* set the number of stop bits */
839 priv->last_lcr |= (cflag & CST 812 priv->last_lcr |= (cflag & CSTOPB) ?
840 MCT_U232_STOP_BITS_2 : 813 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
841 814
842 mct_u232_set_line_ctrl(serial, 815 mct_u232_set_line_ctrl(serial, priv->last_lcr);
843 #endif 816 #endif
844 ; 817 ;
845 } 818 }
>> 819
846 /* 820 /*
847 * Set flow control: well, I do not re 821 * Set flow control: well, I do not really now how to handle DTR/RTS.
848 * Just do what we have seen with Snif 822 * Just do what we have seen with SniffUSB on Win98.
849 */ 823 */
850 if ((iflag & IXOFF) != (old_iflag & IX !! 824 if( (iflag & IXOFF) != (old_iflag & IXOFF)
851 || (iflag & IXON) != (old_iflag & 825 || (iflag & IXON) != (old_iflag & IXON)
852 || (cflag & CRTSCTS) != (old_cfla !! 826 || (cflag & CRTSCTS) != (old_cflag & CRTSCTS) ) {
853 /* Not currently supported */ !! 827
854 tty->termios->c_cflag &= ~CRTS <<
855 /* Drop DTR/RTS if no flow con 828 /* Drop DTR/RTS if no flow control otherwise assert */
856 #if 0 829 #if 0
857 if ((iflag & IXOFF) || (iflag !! 830 if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS) )
858 priv->control_state |= 831 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
859 else 832 else
860 priv->control_state &= 833 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
861 mct_u232_set_modem_ctrl(serial 834 mct_u232_set_modem_ctrl(serial, priv->control_state);
862 #endif 835 #endif
863 ; 836 ;
864 } 837 }
865 memcpy(&cfg, &priv->cfg, sizeof(cfg)); !! 838 memcpy (&cfg, &priv->cfg, sizeof(cfg));
866 spin_unlock_irqrestore(&priv->lock, fl !! 839 spin_unlock_irqrestore (&priv->lock, flags);
867 !! 840
868 /* now commit changes to device */ 841 /* now commit changes to device */
869 klsi_105_chg_port_settings(port, &cfg) 842 klsi_105_chg_port_settings(port, &cfg);
870 } /* klsi_105_set_termios */ 843 } /* klsi_105_set_termios */
871 844
872 845
873 #if 0 846 #if 0
874 static void mct_u232_break_ctl(struct tty_stru !! 847 static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
875 { 848 {
876 struct usb_serial_port *port = tty->dr <<
877 struct usb_serial *serial = port->seri 849 struct usb_serial *serial = port->serial;
878 struct mct_u232_private *priv = !! 850 struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
879 (struct mct_u2 <<
880 unsigned char lcr = priv->last_lcr; 851 unsigned char lcr = priv->last_lcr;
881 852
882 dbg("%sstate=%d", __func__, break_stat !! 853 dbg("%sstate=%d", __FUNCTION__, break_state);
883 854
884 /* LOCKING */ <<
885 if (break_state) 855 if (break_state)
886 lcr |= MCT_U232_SET_BREAK; 856 lcr |= MCT_U232_SET_BREAK;
887 857
888 mct_u232_set_line_ctrl(serial, lcr); 858 mct_u232_set_line_ctrl(serial, lcr);
889 } /* mct_u232_break_ctl */ 859 } /* mct_u232_break_ctl */
890 #endif 860 #endif
891 861
892 static int klsi_105_tiocmget(struct tty_struct !! 862 static int klsi_105_tiocmget (struct usb_serial_port *port, struct file *file)
893 { 863 {
894 struct usb_serial_port *port = tty->dr <<
895 struct klsi_105_private *priv = usb_ge 864 struct klsi_105_private *priv = usb_get_serial_port_data(port);
896 unsigned long flags; 865 unsigned long flags;
897 int rc; 866 int rc;
898 unsigned long line_state; 867 unsigned long line_state;
899 dbg("%s - request, just guessing", __f !! 868 dbg("%s - request, just guessing", __FUNCTION__);
900 869
901 rc = klsi_105_get_line_state(port, &li 870 rc = klsi_105_get_line_state(port, &line_state);
902 if (rc < 0) { 871 if (rc < 0) {
903 dev_err(&port->dev, !! 872 err("Reading line control failed (error = %d)", rc);
904 "Reading line control <<
905 /* better return value? EAGAIN 873 /* better return value? EAGAIN? */
906 return rc; 874 return rc;
907 } 875 }
908 876
909 spin_lock_irqsave(&priv->lock, flags); !! 877 spin_lock_irqsave (&priv->lock, flags);
910 priv->line_state = line_state; 878 priv->line_state = line_state;
911 spin_unlock_irqrestore(&priv->lock, fl !! 879 spin_unlock_irqrestore (&priv->lock, flags);
912 dbg("%s - read line state 0x%lx", __fu !! 880 dbg("%s - read line state 0x%lx", __FUNCTION__, line_state);
913 return (int)line_state; 881 return (int)line_state;
914 } 882 }
915 883
916 static int klsi_105_tiocmset(struct tty_struct !! 884 static int klsi_105_tiocmset (struct usb_serial_port *port, struct file *file,
917 unsigned int set, !! 885 unsigned int set, unsigned int clear)
918 { 886 {
919 int retval = -EINVAL; 887 int retval = -EINVAL;
920 !! 888
921 dbg("%s", __func__); !! 889 dbg("%s", __FUNCTION__);
922 890
923 /* if this ever gets implemented, it should be 891 /* if this ever gets implemented, it should be done something like this:
924 struct usb_serial *serial = port->seri 892 struct usb_serial *serial = port->serial;
925 struct klsi_105_private *priv = usb_ge 893 struct klsi_105_private *priv = usb_get_serial_port_data(port);
926 unsigned long flags; 894 unsigned long flags;
927 int control; 895 int control;
928 896
929 spin_lock_irqsave (&priv->lock, flags) 897 spin_lock_irqsave (&priv->lock, flags);
930 if (set & TIOCM_RTS) 898 if (set & TIOCM_RTS)
931 priv->control_state |= TIOCM_R 899 priv->control_state |= TIOCM_RTS;
932 if (set & TIOCM_DTR) 900 if (set & TIOCM_DTR)
933 priv->control_state |= TIOCM_D 901 priv->control_state |= TIOCM_DTR;
934 if (clear & TIOCM_RTS) 902 if (clear & TIOCM_RTS)
935 priv->control_state &= ~TIOCM_ 903 priv->control_state &= ~TIOCM_RTS;
936 if (clear & TIOCM_DTR) 904 if (clear & TIOCM_DTR)
937 priv->control_state &= ~TIOCM_ 905 priv->control_state &= ~TIOCM_DTR;
938 control = priv->control_state; 906 control = priv->control_state;
939 spin_unlock_irqrestore (&priv->lock, f 907 spin_unlock_irqrestore (&priv->lock, flags);
940 retval = mct_u232_set_modem_ctrl(seria 908 retval = mct_u232_set_modem_ctrl(serial, control);
941 */ 909 */
942 return retval; 910 return retval;
943 } 911 }
>> 912
>> 913 static int klsi_105_ioctl (struct usb_serial_port *port, struct file * file,
>> 914 unsigned int cmd, unsigned long arg)
>> 915 {
>> 916 struct klsi_105_private *priv = usb_get_serial_port_data(port);
>> 917 void __user *user_arg = (void __user *)arg;
>> 918
>> 919 dbg("%scmd=0x%x", __FUNCTION__, cmd);
>> 920
>> 921 /* Based on code from acm.c and others */
>> 922 switch (cmd) {
>> 923 case TIOCMIWAIT:
>> 924 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
>> 925 /* TODO */
>> 926 dbg("%s - TIOCMIWAIT not handled", __FUNCTION__);
>> 927 return -ENOIOCTLCMD;
>> 928
>> 929 case TIOCGICOUNT:
>> 930 /* return count of modemline transitions */
>> 931 /* TODO */
>> 932 dbg("%s - TIOCGICOUNT not handled", __FUNCTION__);
>> 933 return -ENOIOCTLCMD;
>> 934 case TCGETS: {
>> 935 /* return current info to caller */
>> 936 int retval;
>> 937
>> 938 dbg("%s - TCGETS data faked/incomplete", __FUNCTION__);
>> 939
>> 940 retval = verify_area(VERIFY_WRITE, user_arg,
>> 941 sizeof(struct termios));
>> 942 if (retval)
>> 943 return retval;
>> 944
>> 945 if (kernel_termios_to_user_termios((struct termios __user *)arg,
>> 946 &priv->termios))
>> 947 return -EFAULT;
>> 948 return(0);
>> 949 }
>> 950 case TCSETS: {
>> 951 /* set port termios to the one given by the user */
>> 952 int retval;
>> 953
>> 954 dbg("%s - TCSETS not handled", __FUNCTION__);
>> 955
>> 956 retval = verify_area(VERIFY_READ, user_arg,
>> 957 sizeof(struct termios));
>> 958 if (retval)
>> 959 return retval;
>> 960
>> 961 if (user_termios_to_kernel_termios(&priv->termios,
>> 962 (struct termios __user *)arg))
>> 963 return -EFAULT;
>> 964 klsi_105_set_termios(port, &priv->termios);
>> 965 return(0);
>> 966 }
>> 967 case TCSETSW: {
>> 968 /* set port termios and try to wait for completion of last
>> 969 * write operation */
>> 970 /* We guess here. If there are not too many write urbs
>> 971 * outstanding, we lie. */
>> 972 /* what is the right way to wait here? schedule() ? */
>> 973 /*
>> 974 while (klsi_105_chars_in_buffer(port) > (NUM_URBS / 4 ) * URB_TRANSFER_BUFFER_SIZE)
>> 975 schedule();
>> 976 */
>> 977 return -ENOIOCTLCMD;
>> 978 }
>> 979 default:
>> 980 dbg("%s: arg not supported - 0x%04x", __FUNCTION__,cmd);
>> 981 return(-ENOIOCTLCMD);
>> 982 break;
>> 983 }
>> 984 return 0;
>> 985 } /* klsi_105_ioctl */
944 986
945 static void klsi_105_throttle(struct tty_struc !! 987 static void klsi_105_throttle (struct usb_serial_port *port)
946 { 988 {
947 struct usb_serial_port *port = tty->dr !! 989 dbg("%s - port %d", __FUNCTION__, port->number);
948 dbg("%s - port %d", __func__, port->nu <<
949 usb_kill_urb(port->read_urb); 990 usb_kill_urb(port->read_urb);
950 } 991 }
951 992
952 static void klsi_105_unthrottle(struct tty_str !! 993 static void klsi_105_unthrottle (struct usb_serial_port *port)
953 { 994 {
954 struct usb_serial_port *port = tty->dr <<
955 int result; 995 int result;
956 996
957 dbg("%s - port %d", __func__, port->nu !! 997 dbg("%s - port %d", __FUNCTION__, port->number);
958 998
959 port->read_urb->dev = port->serial->de 999 port->read_urb->dev = port->serial->dev;
960 result = usb_submit_urb(port->read_urb 1000 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
961 if (result) 1001 if (result)
962 dev_err(&port->dev, !! 1002 err("%s - failed submitting read urb, error %d", __FUNCTION__,
963 "%s - failed submittin !! 1003 result);
964 __func__, result); <<
965 } 1004 }
966 1005
967 1006
968 1007
969 static int __init klsi_105_init(void) !! 1008 static int __init klsi_105_init (void)
970 { 1009 {
971 int retval; 1010 int retval;
972 retval = usb_serial_register(&kl5kusb1 1011 retval = usb_serial_register(&kl5kusb105d_device);
973 if (retval) 1012 if (retval)
974 goto failed_usb_serial_registe 1013 goto failed_usb_serial_register;
975 retval = usb_register(&kl5kusb105d_dri 1014 retval = usb_register(&kl5kusb105d_driver);
976 if (retval) 1015 if (retval)
977 goto failed_usb_register; 1016 goto failed_usb_register;
978 1017
979 printk(KERN_INFO KBUILD_MODNAME ": " D !! 1018 info(DRIVER_DESC " " DRIVER_VERSION);
980 DRIVER_DESC "\n"); <<
981 return 0; 1019 return 0;
982 failed_usb_register: 1020 failed_usb_register:
983 usb_serial_deregister(&kl5kusb105d_dev 1021 usb_serial_deregister(&kl5kusb105d_device);
984 failed_usb_serial_register: 1022 failed_usb_serial_register:
985 return retval; 1023 return retval;
986 } 1024 }
987 1025
988 1026
989 static void __exit klsi_105_exit(void) !! 1027 static void __exit klsi_105_exit (void)
990 { 1028 {
991 usb_deregister(&kl5kusb105d_driver); !! 1029 usb_deregister (&kl5kusb105d_driver);
992 usb_serial_deregister(&kl5kusb105d_dev !! 1030 usb_serial_deregister (&kl5kusb105d_device);
993 } 1031 }
994 1032
995 1033
996 module_init(klsi_105_init); !! 1034 module_init (klsi_105_init);
997 module_exit(klsi_105_exit); !! 1035 module_exit (klsi_105_exit);
998 1036
999 MODULE_AUTHOR(DRIVER_AUTHOR); !! 1037 MODULE_AUTHOR( DRIVER_AUTHOR );
1000 MODULE_DESCRIPTION(DRIVER_DESC); !! 1038 MODULE_DESCRIPTION( DRIVER_DESC );
1001 MODULE_LICENSE("GPL"); !! 1039 MODULE_LICENSE("GPL");
1002 1040
1003 1041
1004 module_param(debug, bool, S_IRUGO | S_IWUSR); 1042 module_param(debug, bool, S_IRUGO | S_IWUSR);
1005 MODULE_PARM_DESC(debug, "enable extensive deb 1043 MODULE_PARM_DESC(debug, "enable extensive debugging messages");
1006 1044
1007 /* vim: set sts=8 ts=8 sw=8: */ 1045 /* vim: set sts=8 ts=8 sw=8: */
1008 1046
|
This page was automatically generated by the
LXR engine.
|