projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] USB Serial: rename usb_serial_device_type to usb_serial_driver
[deliverable/linux.git] / drivers / usb / serial / cp2101.c
CommitLineData
1da177e4
LT		 1/*
2 * Silicon Laboratories CP2101/CP2102 USB to RS232 serial adaptor driver
3 *
4 * Copyright (C) 2005 Craig Shelley (craig@microtron.org.uk)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License version
8 * 2 as published by the Free Software Foundation.
9 *
39a66b8d
CS		 10 * Support to set flow control line levels using TIOCMGET and TIOCMSET
11 * thanks to Karl Hiramoto karl@hiramoto.org. RTSCTS hardware flow
12 * control thanks to Munir Nassar nassarmu@real-time.com
13 *
14 * Outstanding Issues:
15 * Buffers are not flushed when the port is opened.
16 * Multiple calls to write() may fail with "Resource temporarily unavailable"
17 *
1da177e4
LT		 18 */
19
20#include <linux/config.h>
21#include <linux/kernel.h>
22#include <linux/errno.h>
23#include <linux/slab.h>
24#include <linux/tty.h>
25#include <linux/tty_flip.h>
26#include <linux/module.h>
27#include <linux/moduleparam.h>
28#include <linux/usb.h>
29#include <asm/uaccess.h>
30#include "usb-serial.h"
31
32/*
33 * Version Information
34 */
198b9517 35#define DRIVER_VERSION "v0.05"
1da177e4
LT		 36#define DRIVER_DESC "Silicon Labs CP2101/CP2102 RS232 serial adaptor driver"
37
38/*
39 * Function Prototypes
40 */
41static int cp2101_open(struct usb_serial_port*, struct file*);
42static void cp2101_cleanup(struct usb_serial_port*);
43static void cp2101_close(struct usb_serial_port*, struct file*);
44static void cp2101_get_termios(struct usb_serial_port*);
45static void cp2101_set_termios(struct usb_serial_port*, struct termios*);
39a66b8d
CS		 46static int cp2101_tiocmget (struct usb_serial_port *, struct file *);
47static int cp2101_tiocmset (struct usb_serial_port *, struct file *,
48 unsigned int, unsigned int);
1da177e4
LT		 49static void cp2101_break_ctl(struct usb_serial_port*, int);
50static int cp2101_startup (struct usb_serial *);
51static void cp2101_shutdown(struct usb_serial*);
52
53
54static int debug;
55
56static struct usb_device_id id_table [] = {
198b9517 57 { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
39a66b8d
CS		 58 { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
59 { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
198b9517
CS		 60 { USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
61 { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
39a66b8d
CS		 62 { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
63 { } /* Terminating Entry */
1da177e4
LT		 64};
65
66MODULE_DEVICE_TABLE (usb, id_table);
67
68static struct usb_driver cp2101_driver = {
69 .owner = THIS_MODULE,
70 .name = "CP2101",
71 .probe = usb_serial_probe,
72 .disconnect = usb_serial_disconnect,
73 .id_table = id_table,
74};
75
ea65370d 76static struct usb_serial_driver cp2101_device = {
1da177e4
LT		 77 .owner = THIS_MODULE,
78 .name = "CP2101",
79 .id_table = id_table,
80 .num_interrupt_in = 0,
81 .num_bulk_in = 0,
82 .num_bulk_out = 0,
83 .num_ports = 1,
84 .open = cp2101_open,
85 .close = cp2101_close,
86 .break_ctl = cp2101_break_ctl,
87 .set_termios = cp2101_set_termios,
39a66b8d
CS		 88 .tiocmget = cp2101_tiocmget,
89 .tiocmset = cp2101_tiocmset,
1da177e4
LT		 90 .attach = cp2101_startup,
91 .shutdown = cp2101_shutdown,
92};
93
39a66b8d 94/* Config request types */
1da177e4
LT		 95#define REQTYPE_HOST_TO_DEVICE 0x41
96#define REQTYPE_DEVICE_TO_HOST 0xc1
97
39a66b8d
CS		 98/* Config SET requests. To GET, add 1 to the request number */
99#define CP2101_UART 0x00 /* Enable / Disable */
100#define CP2101_BAUDRATE 0x01 /* (BAUD_RATE_GEN_FREQ / baudrate) */
101#define CP2101_BITS 0x03 /* 0x(0)(databits)(parity)(stopbits) */
102#define CP2101_BREAK 0x05 /* On / Off */
103#define CP2101_CONTROL 0x07 /* Flow control line states */
104#define CP2101_MODEMCTL 0x13 /* Modem controls */
105#define CP2101_CONFIG_6 0x19 /* 6 bytes of config data ??? */
1da177e4 106
39a66b8d 107/* CP2101_UART */
1da177e4
LT		 108#define UART_ENABLE 0x0001
109#define UART_DISABLE 0x0000
110
39a66b8d 111/* CP2101_BAUDRATE */
1da177e4
LT		 112#define BAUD_RATE_GEN_FREQ 0x384000
113
39a66b8d 114/* CP2101_BITS */
1da177e4 115#define BITS_DATA_MASK 0X0f00
39a66b8d 116#define BITS_DATA_5 0X0500
1da177e4
LT		 117#define BITS_DATA_6 0X0600
118#define BITS_DATA_7 0X0700
119#define BITS_DATA_8 0X0800
120#define BITS_DATA_9 0X0900
121
122#define BITS_PARITY_MASK 0x00f0
123#define BITS_PARITY_NONE 0x0000
124#define BITS_PARITY_ODD 0x0010
125#define BITS_PARITY_EVEN 0x0020
126#define BITS_PARITY_MARK 0x0030
127#define BITS_PARITY_SPACE 0x0040
128
129#define BITS_STOP_MASK 0x000f
130#define BITS_STOP_1 0x0000
131#define BITS_STOP_1_5 0x0001
132#define BITS_STOP_2 0x0002
39a66b8d
CS		 133
134/* CP2101_BREAK */
1da177e4
LT		 135#define BREAK_ON 0x0000
136#define BREAK_OFF 0x0001
137
39a66b8d
CS		 138/* CP2101_CONTROL */
139#define CONTROL_DTR 0x0001
140#define CONTROL_RTS 0x0002
141#define CONTROL_CTS 0x0010
142#define CONTROL_DSR 0x0020
143#define CONTROL_RING 0x0040
144#define CONTROL_DCD 0x0080
145#define CONTROL_WRITE_DTR 0x0100
146#define CONTROL_WRITE_RTS 0x0200
1da177e4 147
39a66b8d
CS		 148/*
149 * cp2101_get_config
150 * Reads from the CP2101 configuration registers
151 * 'size' is specified in bytes.
152 * 'data' is a pointer to a pre-allocated array of integers large
153 * enough to hold 'size' bytes (with 4 bytes to each integer)
154 */
155static int cp2101_get_config(struct usb_serial_port* port, u8 request,
156 unsigned int *data, int size)
1da177e4
LT		 157{
158 struct usb_serial *serial = port->serial;
39a66b8d
CS		 159 u32 *buf;
160 int result, i, length;
161
162 /* Number of integers required to contain the array */
163 length = (((size - 1) | 3) + 1)/4;
164
165 buf = kmalloc (length * sizeof(u32), GFP_KERNEL);
166 memset(buf, 0, length * sizeof(u32));
167
168 if (!buf) {
169 dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
170 return -ENOMEM;
171 }
1da177e4 172
39a66b8d 173 /* For get requests, the request number must be incremented */
1da177e4
LT		 174 request++;
175
39a66b8d 176 /* Issue the request, attempting to read 'size' bytes */
1da177e4
LT		 177 result = usb_control_msg (serial->dev,usb_rcvctrlpipe (serial->dev, 0),
178 request, REQTYPE_DEVICE_TO_HOST, 0x0000,
39a66b8d 179 0, buf, size, 300);
1da177e4 180
39a66b8d
CS		 181 /* Convert data into an array of integers */
182 for (i=0; i<length; i++)
183 data[i] = le32_to_cpu(buf[i]);
1da177e4 184
39a66b8d 185 kfree(buf);
1da177e4 186
39a66b8d
CS		 187 if (result != size) {
188 dev_err(&port->dev, "%s - Unable to send config request, "
189 "request=0x%x size=%d result=%d\n",
190 __FUNCTION__, request, size, result);
191 return -EPROTO;
192 }
1da177e4 193
39a66b8d 194 return 0;
1da177e4
LT		 195}
196
39a66b8d
CS		 197/*
198 * cp2101_set_config
199 * Writes to the CP2101 configuration registers
200 * Values less than 16 bits wide are sent directly
201 * 'size' is specified in bytes.
202 */
203static int cp2101_set_config(struct usb_serial_port* port, u8 request,
204 unsigned int *data, int size)
1da177e4
LT		 205{
206 struct usb_serial *serial = port->serial;
39a66b8d
CS		 207 u32 *buf;
208 int result, i, length;
1da177e4 209
39a66b8d
CS		 210 /* Number of integers required to contain the array */
211 length = (((size - 1) | 3) + 1)/4;
212
213 buf = kmalloc(length * sizeof(u32), GFP_KERNEL);
214 if (!buf) {
215 dev_err(&port->dev, "%s - out of memory.\n",
216 __FUNCTION__);
217 return -ENOMEM;
218 }
219
220 /* Array of integers into bytes */
221 for (i = 0; i < length; i++)
222 buf[i] = cpu_to_le32(data[i]);
223
224 if (size > 2) {
225 result = usb_control_msg (serial->dev,
226 usb_sndctrlpipe(serial->dev, 0),
227 request, REQTYPE_HOST_TO_DEVICE, 0x0000,
228 0, buf, size, 300);
229 } else {
230 result = usb_control_msg (serial->dev,
231 usb_sndctrlpipe(serial->dev, 0),
232 request, REQTYPE_HOST_TO_DEVICE, data[0],
233 0, NULL, 0, 300);
1da177e4
LT		 234 }
235
39a66b8d
CS		 236 kfree(buf);
237
238 if ((size > 2 && result != size) || result < 0) {
239 dev_err(&port->dev, "%s - Unable to send request, "
240 "request=0x%x size=%d result=%d\n",
241 __FUNCTION__, request, size, result);
242 return -EPROTO;
243 }
1da177e4 244
39a66b8d
CS		 245 /* Single data value */
246 result = usb_control_msg (serial->dev,
247 usb_sndctrlpipe(serial->dev, 0),
248 request, REQTYPE_HOST_TO_DEVICE, data[0],
249 0, NULL, 0, 300);
1da177e4
LT		 250 return 0;
251}
252
39a66b8d
CS		 253/*
254 * cp2101_set_config_single
255 * Convenience function for calling cp2101_set_config on single data values
256 * without requiring an integer pointer
257 */
258static inline int cp2101_set_config_single(struct usb_serial_port* port,
259 u8 request, unsigned int data)
260{
261 return cp2101_set_config(port, request, &data, 2);
262}
263
1da177e4
LT		 264static int cp2101_open (struct usb_serial_port *port, struct file *filp)
265{
266 struct usb_serial *serial = port->serial;
267 int result;
268
269 dbg("%s - port %d", __FUNCTION__, port->number);
270
39a66b8d 271 if (cp2101_set_config_single(port, CP2101_UART, UART_ENABLE)) {
1da177e4
LT		 272 dev_err(&port->dev, "%s - Unable to enable UART\n",
273 __FUNCTION__);
274 return -EPROTO;
275 }
276
277 /* Start reading from the device */
278 usb_fill_bulk_urb (port->read_urb, serial->dev,
279 usb_rcvbulkpipe(serial->dev,
280 port->bulk_in_endpointAddress),
281 port->read_urb->transfer_buffer,
282 port->read_urb->transfer_buffer_length,
283 serial->type->read_bulk_callback,
284 port);
285 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
286 if (result) {
287 dev_err(&port->dev, "%s - failed resubmitting read urb, "
288 "error %d\n", __FUNCTION__, result);
289 return result;
290 }
291
39a66b8d 292 /* Configure the termios structure */
1da177e4
LT		 293 cp2101_get_termios(port);
294
39a66b8d
CS		 295 /* Set the DTR and RTS pins low */
296 cp2101_tiocmset(port, NULL, TIOCM_DTR | TIOCM_RTS, 0);
297
1da177e4
LT		 298 return 0;
299}
300
301static void cp2101_cleanup (struct usb_serial_port *port)
302{
303 struct usb_serial *serial = port->serial;
304
305 dbg("%s - port %d", __FUNCTION__, port->number);
306
307 if (serial->dev) {
308 /* shutdown any bulk reads that might be going on */
309 if (serial->num_bulk_out)
310 usb_kill_urb(port->write_urb);
311 if (serial->num_bulk_in)
312 usb_kill_urb(port->read_urb);
313 }
314}
315
316static void cp2101_close (struct usb_serial_port *port, struct file * filp)
317{
318 dbg("%s - port %d", __FUNCTION__, port->number);
319
320 /* shutdown our urbs */
321 dbg("%s - shutting down urbs", __FUNCTION__);
322 usb_kill_urb(port->write_urb);
323 usb_kill_urb(port->read_urb);
324
39a66b8d 325 cp2101_set_config_single(port, CP2101_UART, UART_DISABLE);
1da177e4
LT		 326}
327
39a66b8d
CS		 328/*
329 * cp2101_get_termios
330 * Reads the baud rate, data bits, parity, stop bits and flow control mode
331 * from the device, corrects any unsupported values, and configures the
332 * termios structure to reflect the state of the device
333 */
1da177e4
LT		 334static void cp2101_get_termios (struct usb_serial_port *port)
335{
39a66b8d 336 unsigned int cflag, modem_ctl[4];
1da177e4
LT		 337 int baud;
338 int bits;
339
340 dbg("%s - port %d", __FUNCTION__, port->number);
341
342 if ((!port->tty) || (!port->tty->termios)) {
343 dbg("%s - no tty structures", __FUNCTION__);
344 return;
345 }
346 cflag = port->tty->termios->c_cflag;
347
39a66b8d
CS		 348 cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2);
349 /* Convert to baudrate */
1da177e4
LT		 350 if (baud)
351 baud = BAUD_RATE_GEN_FREQ / baud;
352
353 dbg("%s - baud rate = %d", __FUNCTION__, baud);
354 cflag &= ~CBAUD;
355 switch (baud) {
39a66b8d
CS		 356 /*
357 * The baud rates which are commented out below
1da177e4
LT		 358 * appear to be supported by the device
359 * but are non-standard
360 */
361 case 600: cflag |= B600; break;
362 case 1200: cflag |= B1200; break;
363 case 1800: cflag |= B1800; break;
364 case 2400: cflag |= B2400; break;
365 case 4800: cflag |= B4800; break;
366 /*case 7200: cflag |= B7200; break;*/
367 case 9600: cflag |= B9600; break;
368 /*case 14400: cflag |= B14400; break;*/
369 case 19200: cflag |= B19200; break;
370 /*case 28800: cflag |= B28800; break;*/
371 case 38400: cflag |= B38400; break;
372 /*case 55854: cflag |= B55054; break;*/
373 case 57600: cflag |= B57600; break;
374 case 115200: cflag |= B115200; break;
375 /*case 127117: cflag |= B127117; break;*/
376 case 230400: cflag |= B230400; break;
377 case 460800: cflag |= B460800; break;
378 case 921600: cflag |= B921600; break;
379 /*case 3686400: cflag |= B3686400; break;*/
380 default:
381 dbg("%s - Baud rate is not supported, "
382 "using 9600 baud", __FUNCTION__);
383 cflag |= B9600;
39a66b8d 384 cp2101_set_config_single(port, CP2101_BAUDRATE,
1da177e4
LT		 385 (BAUD_RATE_GEN_FREQ/9600));
386 break;
387 }
388
39a66b8d 389 cp2101_get_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 390 cflag &= ~CSIZE;
391 switch(bits & BITS_DATA_MASK) {
39a66b8d
CS		 392 case BITS_DATA_5:
393 dbg("%s - data bits = 5", __FUNCTION__);
394 cflag |= CS5;
395 break;
1da177e4
LT		 396 case BITS_DATA_6:
397 dbg("%s - data bits = 6", __FUNCTION__);
398 cflag |= CS6;
399 break;
400 case BITS_DATA_7:
401 dbg("%s - data bits = 7", __FUNCTION__);
402 cflag |= CS7;
403 break;
404 case BITS_DATA_8:
405 dbg("%s - data bits = 8", __FUNCTION__);
406 cflag |= CS8;
407 break;
408 case BITS_DATA_9:
409 dbg("%s - data bits = 9 (not supported, "
410 "using 8 data bits)", __FUNCTION__);
411 cflag |= CS8;
412 bits &= ~BITS_DATA_MASK;
413 bits |= BITS_DATA_8;
39a66b8d 414 cp2101_set_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 415 break;
416 default:
417 dbg("%s - Unknown number of data bits, "
418 "using 8", __FUNCTION__);
419 cflag |= CS8;
420 bits &= ~BITS_DATA_MASK;
421 bits |= BITS_DATA_8;
39a66b8d 422 cp2101_set_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 423 break;
424 }
425
426 switch(bits & BITS_PARITY_MASK) {
427 case BITS_PARITY_NONE:
428 dbg("%s - parity = NONE", __FUNCTION__);
429 cflag &= ~PARENB;
430 break;
431 case BITS_PARITY_ODD:
432 dbg("%s - parity = ODD", __FUNCTION__);
433 cflag |= (PARENB|PARODD);
434 break;
435 case BITS_PARITY_EVEN:
436 dbg("%s - parity = EVEN", __FUNCTION__);
437 cflag &= ~PARODD;
438 cflag |= PARENB;
439 break;
440 case BITS_PARITY_MARK:
441 dbg("%s - parity = MARK (not supported, "
442 "disabling parity)", __FUNCTION__);
443 cflag &= ~PARENB;
444 bits &= ~BITS_PARITY_MASK;
39a66b8d 445 cp2101_set_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 446 break;
447 case BITS_PARITY_SPACE:
448 dbg("%s - parity = SPACE (not supported, "
449 "disabling parity)", __FUNCTION__);
450 cflag &= ~PARENB;
451 bits &= ~BITS_PARITY_MASK;
39a66b8d 452 cp2101_set_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 453 break;
454 default:
455 dbg("%s - Unknown parity mode, "
456 "disabling parity", __FUNCTION__);
457 cflag &= ~PARENB;
458 bits &= ~BITS_PARITY_MASK;
39a66b8d 459 cp2101_set_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 460 break;
461 }
462
463 cflag &= ~CSTOPB;
464 switch(bits & BITS_STOP_MASK) {
465 case BITS_STOP_1:
466 dbg("%s - stop bits = 1", __FUNCTION__);
467 break;
468 case BITS_STOP_1_5:
469 dbg("%s - stop bits = 1.5 (not supported, "
39a66b8d 470 "using 1 stop bit)", __FUNCTION__);
1da177e4 471 bits &= ~BITS_STOP_MASK;
39a66b8d 472 cp2101_set_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 473 break;
474 case BITS_STOP_2:
475 dbg("%s - stop bits = 2", __FUNCTION__);
476 cflag |= CSTOPB;
477 break;
478 default:
479 dbg("%s - Unknown number of stop bits, "
480 "using 1 stop bit", __FUNCTION__);
481 bits &= ~BITS_STOP_MASK;
39a66b8d 482 cp2101_set_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 483 break;
484 }
485
39a66b8d
CS		 486 cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
487 if (modem_ctl[0] & 0x0008) {
488 dbg("%s - flow control = CRTSCTS", __FUNCTION__);
489 cflag |= CRTSCTS;
490 } else {
491 dbg("%s - flow control = NONE", __FUNCTION__);
492 cflag &= ~CRTSCTS;
493 }
494
1da177e4
LT		 495 port->tty->termios->c_cflag = cflag;
496}
497
498static void cp2101_set_termios (struct usb_serial_port *port,
499 struct termios *old_termios)
500{
501 unsigned int cflag, old_cflag=0;
39a66b8d
CS		 502 int baud=0, bits;
503 unsigned int modem_ctl[4];
1da177e4
LT		 504
505 dbg("%s - port %d", __FUNCTION__, port->number);
506
507 if ((!port->tty) || (!port->tty->termios)) {
508 dbg("%s - no tty structures", __FUNCTION__);
509 return;
510 }
511 cflag = port->tty->termios->c_cflag;
512
39a66b8d 513 /* Check that they really want us to change something */
1da177e4
LT		 514 if (old_termios) {
515 if ((cflag == old_termios->c_cflag) &&
516 (RELEVANT_IFLAG(port->tty->termios->c_iflag)
517 == RELEVANT_IFLAG(old_termios->c_iflag))) {
518 dbg("%s - nothing to change...", __FUNCTION__);
519 return;
520 }
521
522 old_cflag = old_termios->c_cflag;
523 }
524
525 /* If the baud rate is to be updated*/
526 if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
527 switch (cflag & CBAUD) {
39a66b8d
CS		 528 /*
529 * The baud rates which are commented out below
1da177e4
LT		 530 * appear to be supported by the device
531 * but are non-standard
532 */
533 case B0: baud = 0; break;
534 case B600: baud = 600; break;
535 case B1200: baud = 1200; break;
536 case B1800: baud = 1800; break;
537 case B2400: baud = 2400; break;
538 case B4800: baud = 4800; break;
539 /*case B7200: baud = 7200; break;*/
540 case B9600: baud = 9600; break;
541 /*ase B14400: baud = 14400; break;*/
542 case B19200: baud = 19200; break;
543 /*case B28800: baud = 28800; break;*/
544 case B38400: baud = 38400; break;
545 /*case B55854: baud = 55054; break;*/
546 case B57600: baud = 57600; break;
547 case B115200: baud = 115200; break;
548 /*case B127117: baud = 127117; break;*/
549 case B230400: baud = 230400; break;
550 case B460800: baud = 460800; break;
551 case B921600: baud = 921600; break;
552 /*case B3686400: baud = 3686400; break;*/
553 default:
554 dev_err(&port->dev, "cp2101 driver does not "
555 "support the baudrate requested\n");
556 break;
557 }
558
559 if (baud) {
560 dbg("%s - Setting baud rate to %d baud", __FUNCTION__,
561 baud);
39a66b8d 562 if (cp2101_set_config_single(port, CP2101_BAUDRATE,
1da177e4
LT		 563 (BAUD_RATE_GEN_FREQ / baud)))
564 dev_err(&port->dev, "Baud rate requested not "
565 "supported by device\n");
566 }
567 }
568
39a66b8d 569 /* If the number of data bits is to be updated */
1da177e4 570 if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
39a66b8d 571 cp2101_get_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 572 bits &= ~BITS_DATA_MASK;
573 switch (cflag & CSIZE) {
39a66b8d
CS		 574 case CS5:
575 bits |= BITS_DATA_5;
576 dbg("%s - data bits = 5", __FUNCTION__);
577 break;
1da177e4
LT		 578 case CS6:
579 bits |= BITS_DATA_6;
580 dbg("%s - data bits = 6", __FUNCTION__);
581 break;
582 case CS7:
583 bits |= BITS_DATA_7;
584 dbg("%s - data bits = 7", __FUNCTION__);
585 break;
586 case CS8:
587 bits |= BITS_DATA_8;
588 dbg("%s - data bits = 8", __FUNCTION__);
589 break;
590 /*case CS9:
591 bits |= BITS_DATA_9;
592 dbg("%s - data bits = 9", __FUNCTION__);
593 break;*/
594 default:
595 dev_err(&port->dev, "cp2101 driver does not "
596 "support the number of bits requested,"
597 " using 8 bit mode\n");
598 bits |= BITS_DATA_8;
599 break;
600 }
39a66b8d 601 if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
1da177e4
LT		 602 dev_err(&port->dev, "Number of data bits requested "
603 "not supported by device\n");
604 }
605
606 if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))) {
39a66b8d 607 cp2101_get_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 608 bits &= ~BITS_PARITY_MASK;
609 if (cflag & PARENB) {
610 if (cflag & PARODD) {
611 bits |= BITS_PARITY_ODD;
612 dbg("%s - parity = ODD", __FUNCTION__);
613 } else {
614 bits |= BITS_PARITY_EVEN;
615 dbg("%s - parity = EVEN", __FUNCTION__);
616 }
617 }
39a66b8d 618 if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
1da177e4
LT		 619 dev_err(&port->dev, "Parity mode not supported "
620 "by device\n");
621 }
622
623 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
39a66b8d 624 cp2101_get_config(port, CP2101_BITS, &bits, 2);
1da177e4
LT		 625 bits &= ~BITS_STOP_MASK;
626 if (cflag & CSTOPB) {
627 bits |= BITS_STOP_2;
628 dbg("%s - stop bits = 2", __FUNCTION__);
629 } else {
630 bits |= BITS_STOP_1;
631 dbg("%s - stop bits = 1", __FUNCTION__);
632 }
39a66b8d 633 if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
1da177e4
LT		 634 dev_err(&port->dev, "Number of stop bits requested "
635 "not supported by device\n");
636 }
39a66b8d
CS		 637
638 if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
639 cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
640 dbg("%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
641 __FUNCTION__, modem_ctl[0], modem_ctl[1],
642 modem_ctl[2], modem_ctl[3]);
643
644 if (cflag & CRTSCTS) {
645 modem_ctl[0] &= ~0x7B;
646 modem_ctl[0] |= 0x09;
647 modem_ctl[1] = 0x80;
648 dbg("%s - flow control = CRTSCTS", __FUNCTION__);
649 } else {
650 modem_ctl[0] &= ~0x7B;
651 modem_ctl[0] |= 0x01;
652 modem_ctl[1] |= 0x40;
653 dbg("%s - flow control = NONE", __FUNCTION__);
654 }
655
656 dbg("%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
657 __FUNCTION__, modem_ctl[0], modem_ctl[1],
658 modem_ctl[2], modem_ctl[3]);
659 cp2101_set_config(port, CP2101_MODEMCTL, modem_ctl, 16);
660 }
661
662}
663
664static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
665 unsigned int set, unsigned int clear)
666{
667 int control = 0;
668
669 dbg("%s - port %d", __FUNCTION__, port->number);
670
671 if (set & TIOCM_RTS) {
672 control |= CONTROL_RTS;
673 control |= CONTROL_WRITE_RTS;
674 }
675 if (set & TIOCM_DTR) {
676 control |= CONTROL_DTR;
677 control |= CONTROL_WRITE_DTR;
678 }
679 if (clear & TIOCM_RTS) {
680 control &= ~CONTROL_RTS;
681 control |= CONTROL_WRITE_RTS;
682 }
683 if (clear & TIOCM_DTR) {
684 control &= ~CONTROL_DTR;
685 control |= CONTROL_WRITE_DTR;
686 }
687
688 dbg("%s - control = 0x%.4x", __FUNCTION__, control);
689
690 return cp2101_set_config(port, CP2101_CONTROL, &control, 2);
691
692}
693
694static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
695{
696 int control, result;
697
698 dbg("%s - port %d", __FUNCTION__, port->number);
699
700 cp2101_get_config(port, CP2101_CONTROL, &control, 1);
701
702 result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0)
703 |((control & CONTROL_RTS) ? TIOCM_RTS : 0)
704 |((control & CONTROL_CTS) ? TIOCM_CTS : 0)
705 |((control & CONTROL_DSR) ? TIOCM_DSR : 0)
706 |((control & CONTROL_RING)? TIOCM_RI : 0)
707 |((control & CONTROL_DCD) ? TIOCM_CD : 0);
708
709 dbg("%s - control = 0x%.2x", __FUNCTION__, control);
710
711 return result;
1da177e4
LT		 712}
713
714static void cp2101_break_ctl (struct usb_serial_port *port, int break_state)
715{
39a66b8d 716 int state;
1da177e4
LT		 717
718 dbg("%s - port %d", __FUNCTION__, port->number);
719 if (break_state == 0)
720 state = BREAK_OFF;
721 else
722 state = BREAK_ON;
723 dbg("%s - turning break %s", __FUNCTION__,
724 state==BREAK_OFF ? "off" : "on");
39a66b8d 725 cp2101_set_config(port, CP2101_BREAK, &state, 2);
1da177e4
LT		 726}
727
728static int cp2101_startup (struct usb_serial *serial)
729{
39a66b8d 730 /* CP2101 buffers behave strangely unless device is reset */
1da177e4
LT		 731 usb_reset_device(serial->dev);
732 return 0;
733}
734
735static void cp2101_shutdown (struct usb_serial *serial)
736{
737 int i;
738
739 dbg("%s", __FUNCTION__);
740
39a66b8d 741 /* Stop reads and writes on all ports */
1da177e4
LT		 742 for (i=0; i < serial->num_ports; ++i) {
743 cp2101_cleanup(serial->port[i]);
744 }
745}
746
747static int __init cp2101_init (void)
748{
749 int retval;
750
751 retval = usb_serial_register(&cp2101_device);
752 if (retval)
39a66b8d 753 return retval; /* Failed to register */
1da177e4
LT		 754
755 retval = usb_register(&cp2101_driver);
756 if (retval) {
39a66b8d 757 /* Failed to register */
1da177e4
LT		 758 usb_serial_deregister(&cp2101_device);
759 return retval;
760 }
761
39a66b8d 762 /* Success */
1da177e4
LT		 763 info(DRIVER_DESC " " DRIVER_VERSION);
764 return 0;
765}
766
767static void __exit cp2101_exit (void)
768{
769 usb_deregister (&cp2101_driver);
770 usb_serial_deregister (&cp2101_device);
771}
772
773module_init(cp2101_init);
774module_exit(cp2101_exit);
775
776MODULE_DESCRIPTION(DRIVER_DESC);
777MODULE_VERSION(DRIVER_VERSION);
778MODULE_LICENSE("GPL");
779
780module_param(debug, bool, S_IRUGO | S_IWUSR);
781MODULE_PARM_DESC(debug, "Enable verbose debugging messages");
Linux kernel - Deliverables
This page took 0.190874 seconds and 5 git commands to generate.