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