Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | * |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 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 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | */ |
| 19 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/kernel.h> |
| 21 | #include <linux/errno.h> |
| 22 | #include <linux/slab.h> |
| 23 | #include <linux/tty.h> |
| 24 | #include <linux/tty_flip.h> |
| 25 | #include <linux/module.h> |
| 26 | #include <linux/moduleparam.h> |
| 27 | #include <linux/usb.h> |
| 28 | #include <asm/uaccess.h> |
Greg Kroah-Hartman | a969888 | 2006-07-11 21:22:58 -0700 | [diff] [blame] | 29 | #include <linux/usb/serial.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | |
| 31 | /* |
| 32 | * Version Information |
| 33 | */ |
Craig Shelley | 59224f5 | 2006-03-11 11:29:02 +0000 | [diff] [blame] | 34 | #define DRIVER_VERSION "v0.07" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | #define DRIVER_DESC "Silicon Labs CP2101/CP2102 RS232 serial adaptor driver" |
| 36 | |
| 37 | /* |
| 38 | * Function Prototypes |
| 39 | */ |
| 40 | static int cp2101_open(struct usb_serial_port*, struct file*); |
| 41 | static void cp2101_cleanup(struct usb_serial_port*); |
| 42 | static void cp2101_close(struct usb_serial_port*, struct file*); |
| 43 | static void cp2101_get_termios(struct usb_serial_port*); |
Alan Cox | 606d099 | 2006-12-08 02:38:45 -0800 | [diff] [blame] | 44 | static void cp2101_set_termios(struct usb_serial_port*, struct ktermios*); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 45 | static int cp2101_tiocmget (struct usb_serial_port *, struct file *); |
| 46 | static int cp2101_tiocmset (struct usb_serial_port *, struct file *, |
| 47 | unsigned int, unsigned int); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | static void cp2101_break_ctl(struct usb_serial_port*, int); |
| 49 | static int cp2101_startup (struct usb_serial *); |
| 50 | static void cp2101_shutdown(struct usb_serial*); |
| 51 | |
| 52 | |
| 53 | static int debug; |
| 54 | |
| 55 | static struct usb_device_id id_table [] = { |
Craig Shelley | 59fba74 | 2008-04-12 16:15:54 +0100 | [diff] [blame] | 56 | { USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */ |
Edouard Lafargue | 1f4f714 | 2007-09-25 10:15:36 +0200 | [diff] [blame] | 57 | { USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */ |
Craig Shelley | 198b951 | 2005-08-28 09:51:15 +0100 | [diff] [blame] | 58 | { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */ |
Martin Kusserow | 014840e | 2007-12-21 12:02:17 +0100 | [diff] [blame] | 59 | { USB_DEVICE(0x0FCF, 0x1004) }, /* Dynastream ANT2USB */ |
Craig Shelley | 59fba74 | 2008-04-12 16:15:54 +0100 | [diff] [blame] | 60 | { USB_DEVICE(0x0FCF, 0x1006) }, /* Dynastream ANT development board */ |
Craig Shelley | 198b951 | 2005-08-28 09:51:15 +0100 | [diff] [blame] | 61 | { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */ |
Craig Shelley | e988fc8 | 2006-01-20 00:06:19 +0000 | [diff] [blame] | 62 | { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */ |
| 63 | { USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */ |
Craig Shelley | 5de8b3a | 2008-01-03 12:45:59 +0000 | [diff] [blame] | 64 | { USB_DEVICE(0x10C4, 0x800A) }, /* SPORTident BSM7-D-USB main station */ |
Craig Shelley | 59224f5 | 2006-03-11 11:29:02 +0000 | [diff] [blame] | 65 | { USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */ |
Craig Shelley | 92f5cae2 | 2007-04-20 14:37:17 +0100 | [diff] [blame] | 66 | { USB_DEVICE(0x10C4, 0x8053) }, /* Enfora EDG1228 */ |
Vitja Makarov | 212a4b4 | 2006-05-31 00:40:06 +0400 | [diff] [blame] | 67 | { USB_DEVICE(0x10C4, 0x8066) }, /* Argussoft In-System Programmer */ |
Craig Shelley | e988fc8 | 2006-01-20 00:06:19 +0000 | [diff] [blame] | 68 | { USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */ |
| 69 | { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */ |
Craig Shelley | 92f5cae2 | 2007-04-20 14:37:17 +0100 | [diff] [blame] | 70 | { USB_DEVICE(0x10C4, 0x80DD) }, /* Tracient RFID */ |
Craig Shelley | e988fc8 | 2006-01-20 00:06:19 +0000 | [diff] [blame] | 71 | { USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */ |
| 72 | { USB_DEVICE(0x10C4, 0x813D) }, /* Burnside Telecom Deskmobile */ |
Jon K Hellan | fc4bd64 | 2007-02-28 23:04:33 +0100 | [diff] [blame] | 73 | { USB_DEVICE(0x10C4, 0x814A) }, /* West Mountain Radio RIGblaster P&P */ |
| 74 | { USB_DEVICE(0x10C4, 0x814B) }, /* West Mountain Radio RIGtalk */ |
Craig Shelley | e988fc8 | 2006-01-20 00:06:19 +0000 | [diff] [blame] | 75 | { USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */ |
Bernhard Beck | 96623697 | 2008-05-11 09:23:13 -0700 | [diff] [blame] | 76 | { USB_DEVICE(0x10C4, 0x81A6) }, /* ThinkOptics WavIt */ |
Craig Shelley | 59fba74 | 2008-04-12 16:15:54 +0100 | [diff] [blame] | 77 | { USB_DEVICE(0x10C4, 0x81AC) }, /* MSD Dash Hawk */ |
Bjorn Schneider | 78001e3 | 2006-10-28 12:42:04 +0200 | [diff] [blame] | 78 | { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */ |
| 79 | { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */ |
Jeff Long | 8be27c2 | 2007-11-28 11:02:09 -0500 | [diff] [blame] | 80 | { USB_DEVICE(0x10C4, 0x81E7) }, /* Aerocomm Radio */ |
Bjorn Schneider | 78001e3 | 2006-10-28 12:42:04 +0200 | [diff] [blame] | 81 | { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */ |
Florian Fainelli | e889868 | 2008-03-25 17:32:16 +0100 | [diff] [blame] | 82 | { USB_DEVICE(0x10c4, 0x8293) }, /* Telegesys ETRX2USB */ |
Craig Shelley | e988fc8 | 2006-01-20 00:06:19 +0000 | [diff] [blame] | 83 | { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */ |
Craig Shelley | 61926b9 | 2006-10-12 22:09:56 +0100 | [diff] [blame] | 84 | { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */ |
Craig Shelley | 5de8b3a | 2008-01-03 12:45:59 +0000 | [diff] [blame] | 85 | { USB_DEVICE(0x10C4, 0xF001) }, /* Elan Digital Systems USBscope50 */ |
| 86 | { USB_DEVICE(0x10C4, 0xF002) }, /* Elan Digital Systems USBwave12 */ |
| 87 | { USB_DEVICE(0x10C4, 0xF003) }, /* Elan Digital Systems USBpulse100 */ |
| 88 | { USB_DEVICE(0x10C4, 0xF004) }, /* Elan Digital Systems USBcount50 */ |
Pozsar Balazs | ebaf494 | 2007-02-16 12:47:49 +0100 | [diff] [blame] | 89 | { USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */ |
Johannes Hoelzl | e05998d | 2006-12-02 16:54:27 +0100 | [diff] [blame] | 90 | { USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */ |
Craig Shelley | 5de8b3a | 2008-01-03 12:45:59 +0000 | [diff] [blame] | 91 | { USB_DEVICE(0x166A, 0x0303) }, /* Clipsal 5500PCU C-Bus USB interface */ |
Josef Balatka | b0ce84d | 2005-11-17 09:47:24 -0800 | [diff] [blame] | 92 | { USB_DEVICE(0x16D6, 0x0001) }, /* Jablotron serial interface */ |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 93 | { } /* Terminating Entry */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | }; |
| 95 | |
| 96 | MODULE_DEVICE_TABLE (usb, id_table); |
| 97 | |
| 98 | static struct usb_driver cp2101_driver = { |
Greg Kroah-Hartman | 269bda1 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 99 | .name = "cp2101", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | .probe = usb_serial_probe, |
| 101 | .disconnect = usb_serial_disconnect, |
| 102 | .id_table = id_table, |
Greg Kroah-Hartman | ba9dc65 | 2005-11-16 13:41:28 -0800 | [diff] [blame] | 103 | .no_dynamic_id = 1, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | }; |
| 105 | |
Greg Kroah-Hartman | ea65370 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 106 | static struct usb_serial_driver cp2101_device = { |
Greg Kroah-Hartman | 18fcac3 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 107 | .driver = { |
| 108 | .owner = THIS_MODULE, |
Greg Kroah-Hartman | 269bda1 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 109 | .name = "cp2101", |
Greg Kroah-Hartman | 18fcac3 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 110 | }, |
Johannes Hölzl | d9b1b78 | 2006-12-17 21:50:24 +0100 | [diff] [blame] | 111 | .usb_driver = &cp2101_driver, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | .id_table = id_table, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | .num_ports = 1, |
| 114 | .open = cp2101_open, |
| 115 | .close = cp2101_close, |
| 116 | .break_ctl = cp2101_break_ctl, |
| 117 | .set_termios = cp2101_set_termios, |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 118 | .tiocmget = cp2101_tiocmget, |
| 119 | .tiocmset = cp2101_tiocmset, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | .attach = cp2101_startup, |
| 121 | .shutdown = cp2101_shutdown, |
| 122 | }; |
| 123 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 124 | /* Config request types */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | #define REQTYPE_HOST_TO_DEVICE 0x41 |
| 126 | #define REQTYPE_DEVICE_TO_HOST 0xc1 |
| 127 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 128 | /* Config SET requests. To GET, add 1 to the request number */ |
| 129 | #define CP2101_UART 0x00 /* Enable / Disable */ |
| 130 | #define CP2101_BAUDRATE 0x01 /* (BAUD_RATE_GEN_FREQ / baudrate) */ |
| 131 | #define CP2101_BITS 0x03 /* 0x(0)(databits)(parity)(stopbits) */ |
| 132 | #define CP2101_BREAK 0x05 /* On / Off */ |
| 133 | #define CP2101_CONTROL 0x07 /* Flow control line states */ |
| 134 | #define CP2101_MODEMCTL 0x13 /* Modem controls */ |
| 135 | #define CP2101_CONFIG_6 0x19 /* 6 bytes of config data ??? */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 137 | /* CP2101_UART */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | #define UART_ENABLE 0x0001 |
| 139 | #define UART_DISABLE 0x0000 |
| 140 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 141 | /* CP2101_BAUDRATE */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | #define BAUD_RATE_GEN_FREQ 0x384000 |
| 143 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 144 | /* CP2101_BITS */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | #define BITS_DATA_MASK 0X0f00 |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 146 | #define BITS_DATA_5 0X0500 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | #define BITS_DATA_6 0X0600 |
| 148 | #define BITS_DATA_7 0X0700 |
| 149 | #define BITS_DATA_8 0X0800 |
| 150 | #define BITS_DATA_9 0X0900 |
| 151 | |
| 152 | #define BITS_PARITY_MASK 0x00f0 |
| 153 | #define BITS_PARITY_NONE 0x0000 |
| 154 | #define BITS_PARITY_ODD 0x0010 |
| 155 | #define BITS_PARITY_EVEN 0x0020 |
| 156 | #define BITS_PARITY_MARK 0x0030 |
| 157 | #define BITS_PARITY_SPACE 0x0040 |
| 158 | |
| 159 | #define BITS_STOP_MASK 0x000f |
| 160 | #define BITS_STOP_1 0x0000 |
| 161 | #define BITS_STOP_1_5 0x0001 |
| 162 | #define BITS_STOP_2 0x0002 |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 163 | |
| 164 | /* CP2101_BREAK */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | #define BREAK_ON 0x0000 |
| 166 | #define BREAK_OFF 0x0001 |
| 167 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 168 | /* CP2101_CONTROL */ |
| 169 | #define CONTROL_DTR 0x0001 |
| 170 | #define CONTROL_RTS 0x0002 |
| 171 | #define CONTROL_CTS 0x0010 |
| 172 | #define CONTROL_DSR 0x0020 |
| 173 | #define CONTROL_RING 0x0040 |
| 174 | #define CONTROL_DCD 0x0080 |
| 175 | #define CONTROL_WRITE_DTR 0x0100 |
| 176 | #define CONTROL_WRITE_RTS 0x0200 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 178 | /* |
| 179 | * cp2101_get_config |
| 180 | * Reads from the CP2101 configuration registers |
| 181 | * 'size' is specified in bytes. |
| 182 | * 'data' is a pointer to a pre-allocated array of integers large |
| 183 | * enough to hold 'size' bytes (with 4 bytes to each integer) |
| 184 | */ |
| 185 | static int cp2101_get_config(struct usb_serial_port* port, u8 request, |
| 186 | unsigned int *data, int size) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 187 | { |
| 188 | struct usb_serial *serial = port->serial; |
Al Viro | 53ebb3b | 2007-02-09 16:39:55 +0000 | [diff] [blame] | 189 | __le32 *buf; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 190 | int result, i, length; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 191 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 192 | /* Number of integers required to contain the array */ |
| 193 | length = (((size - 1) | 3) + 1)/4; |
| 194 | |
Al Viro | 53ebb3b | 2007-02-09 16:39:55 +0000 | [diff] [blame] | 195 | buf = kcalloc(length, sizeof(__le32), GFP_KERNEL); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 196 | if (!buf) { |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 197 | dev_err(&port->dev, "%s - out of memory.\n", __func__); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 198 | return -ENOMEM; |
| 199 | } |
| 200 | |
| 201 | /* For get requests, the request number must be incremented */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | request++; |
| 203 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 204 | /* Issue the request, attempting to read 'size' bytes */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | result = usb_control_msg (serial->dev,usb_rcvctrlpipe (serial->dev, 0), |
| 206 | request, REQTYPE_DEVICE_TO_HOST, 0x0000, |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 207 | 0, buf, size, 300); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 209 | /* Convert data into an array of integers */ |
| 210 | for (i=0; i<length; i++) |
| 211 | data[i] = le32_to_cpu(buf[i]); |
| 212 | |
| 213 | kfree(buf); |
| 214 | |
| 215 | if (result != size) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | dev_err(&port->dev, "%s - Unable to send config request, " |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 217 | "request=0x%x size=%d result=%d\n", |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 218 | __func__, request, size, result); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 219 | return -EPROTO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | } |
| 221 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 222 | return 0; |
| 223 | } |
| 224 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 225 | /* |
| 226 | * cp2101_set_config |
| 227 | * Writes to the CP2101 configuration registers |
| 228 | * Values less than 16 bits wide are sent directly |
| 229 | * 'size' is specified in bytes. |
| 230 | */ |
| 231 | static int cp2101_set_config(struct usb_serial_port* port, u8 request, |
| 232 | unsigned int *data, int size) |
| 233 | { |
| 234 | struct usb_serial *serial = port->serial; |
Al Viro | 53ebb3b | 2007-02-09 16:39:55 +0000 | [diff] [blame] | 235 | __le32 *buf; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 236 | int result, i, length; |
| 237 | |
| 238 | /* Number of integers required to contain the array */ |
| 239 | length = (((size - 1) | 3) + 1)/4; |
| 240 | |
Al Viro | 53ebb3b | 2007-02-09 16:39:55 +0000 | [diff] [blame] | 241 | buf = kmalloc(length * sizeof(__le32), GFP_KERNEL); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 242 | if (!buf) { |
| 243 | dev_err(&port->dev, "%s - out of memory.\n", |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 244 | __func__); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 245 | return -ENOMEM; |
| 246 | } |
| 247 | |
| 248 | /* Array of integers into bytes */ |
| 249 | for (i = 0; i < length; i++) |
| 250 | buf[i] = cpu_to_le32(data[i]); |
| 251 | |
| 252 | if (size > 2) { |
| 253 | result = usb_control_msg (serial->dev, |
| 254 | usb_sndctrlpipe(serial->dev, 0), |
| 255 | request, REQTYPE_HOST_TO_DEVICE, 0x0000, |
| 256 | 0, buf, size, 300); |
| 257 | } else { |
| 258 | result = usb_control_msg (serial->dev, |
| 259 | usb_sndctrlpipe(serial->dev, 0), |
| 260 | request, REQTYPE_HOST_TO_DEVICE, data[0], |
| 261 | 0, NULL, 0, 300); |
| 262 | } |
| 263 | |
| 264 | kfree(buf); |
| 265 | |
| 266 | if ((size > 2 && result != size) || result < 0) { |
| 267 | dev_err(&port->dev, "%s - Unable to send request, " |
| 268 | "request=0x%x size=%d result=%d\n", |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 269 | __func__, request, size, result); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 270 | return -EPROTO; |
| 271 | } |
| 272 | |
| 273 | /* Single data value */ |
| 274 | result = usb_control_msg (serial->dev, |
| 275 | usb_sndctrlpipe(serial->dev, 0), |
| 276 | request, REQTYPE_HOST_TO_DEVICE, data[0], |
| 277 | 0, NULL, 0, 300); |
| 278 | return 0; |
| 279 | } |
| 280 | |
| 281 | /* |
| 282 | * cp2101_set_config_single |
| 283 | * Convenience function for calling cp2101_set_config on single data values |
| 284 | * without requiring an integer pointer |
| 285 | */ |
| 286 | static inline int cp2101_set_config_single(struct usb_serial_port* port, |
| 287 | u8 request, unsigned int data) |
| 288 | { |
| 289 | return cp2101_set_config(port, request, &data, 2); |
| 290 | } |
| 291 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | static int cp2101_open (struct usb_serial_port *port, struct file *filp) |
| 293 | { |
| 294 | struct usb_serial *serial = port->serial; |
| 295 | int result; |
| 296 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 297 | dbg("%s - port %d", __func__, port->number); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 298 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 299 | if (cp2101_set_config_single(port, CP2101_UART, UART_ENABLE)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | dev_err(&port->dev, "%s - Unable to enable UART\n", |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 301 | __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 302 | return -EPROTO; |
| 303 | } |
| 304 | |
| 305 | /* Start reading from the device */ |
| 306 | usb_fill_bulk_urb (port->read_urb, serial->dev, |
| 307 | usb_rcvbulkpipe(serial->dev, |
| 308 | port->bulk_in_endpointAddress), |
| 309 | port->read_urb->transfer_buffer, |
| 310 | port->read_urb->transfer_buffer_length, |
| 311 | serial->type->read_bulk_callback, |
| 312 | port); |
| 313 | result = usb_submit_urb(port->read_urb, GFP_KERNEL); |
| 314 | if (result) { |
| 315 | dev_err(&port->dev, "%s - failed resubmitting read urb, " |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 316 | "error %d\n", __func__, result); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | return result; |
| 318 | } |
| 319 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 320 | /* Configure the termios structure */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | cp2101_get_termios(port); |
| 322 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 323 | /* Set the DTR and RTS pins low */ |
| 324 | cp2101_tiocmset(port, NULL, TIOCM_DTR | TIOCM_RTS, 0); |
| 325 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | return 0; |
| 327 | } |
| 328 | |
| 329 | static void cp2101_cleanup (struct usb_serial_port *port) |
| 330 | { |
| 331 | struct usb_serial *serial = port->serial; |
| 332 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 333 | dbg("%s - port %d", __func__, port->number); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 334 | |
| 335 | if (serial->dev) { |
| 336 | /* shutdown any bulk reads that might be going on */ |
| 337 | if (serial->num_bulk_out) |
| 338 | usb_kill_urb(port->write_urb); |
| 339 | if (serial->num_bulk_in) |
| 340 | usb_kill_urb(port->read_urb); |
| 341 | } |
| 342 | } |
| 343 | |
| 344 | static void cp2101_close (struct usb_serial_port *port, struct file * filp) |
| 345 | { |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 346 | dbg("%s - port %d", __func__, port->number); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 347 | |
| 348 | /* shutdown our urbs */ |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 349 | dbg("%s - shutting down urbs", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 350 | usb_kill_urb(port->write_urb); |
| 351 | usb_kill_urb(port->read_urb); |
| 352 | |
Oliver Neukum | 95bef01 | 2008-01-22 13:56:18 +0100 | [diff] [blame] | 353 | mutex_lock(&port->serial->disc_mutex); |
| 354 | if (!port->serial->disconnected) |
| 355 | cp2101_set_config_single(port, CP2101_UART, UART_DISABLE); |
| 356 | mutex_unlock(&port->serial->disc_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 357 | } |
| 358 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 359 | /* |
| 360 | * cp2101_get_termios |
| 361 | * Reads the baud rate, data bits, parity, stop bits and flow control mode |
| 362 | * from the device, corrects any unsupported values, and configures the |
| 363 | * termios structure to reflect the state of the device |
| 364 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 365 | static void cp2101_get_termios (struct usb_serial_port *port) |
| 366 | { |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 367 | unsigned int cflag, modem_ctl[4]; |
Harvey Harrison | b2bdd1f | 2008-05-30 10:29:55 -0700 | [diff] [blame^] | 368 | unsigned int baud; |
| 369 | unsigned int bits; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 370 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 371 | dbg("%s - port %d", __func__, port->number); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | |
Alan Cox | 01e96d2 | 2007-07-26 18:54:12 +0100 | [diff] [blame] | 373 | if (!port->tty || !port->tty->termios) { |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 374 | dbg("%s - no tty structures", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | return; |
| 376 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 377 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 378 | cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2); |
| 379 | /* Convert to baudrate */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 380 | if (baud) |
| 381 | baud = BAUD_RATE_GEN_FREQ / baud; |
| 382 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 383 | dbg("%s - baud rate = %d", __func__, baud); |
Alan Cox | 9ab0f20 | 2007-10-18 01:24:24 -0700 | [diff] [blame] | 384 | |
| 385 | tty_encode_baud_rate(port->tty, baud, baud); |
| 386 | cflag = port->tty->termios->c_cflag; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 388 | cp2101_get_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | cflag &= ~CSIZE; |
| 390 | switch(bits & BITS_DATA_MASK) { |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 391 | case BITS_DATA_5: |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 392 | dbg("%s - data bits = 5", __func__); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 393 | cflag |= CS5; |
| 394 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 395 | case BITS_DATA_6: |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 396 | dbg("%s - data bits = 6", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | cflag |= CS6; |
| 398 | break; |
| 399 | case BITS_DATA_7: |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 400 | dbg("%s - data bits = 7", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 401 | cflag |= CS7; |
| 402 | break; |
| 403 | case BITS_DATA_8: |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 404 | dbg("%s - data bits = 8", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 405 | cflag |= CS8; |
| 406 | break; |
| 407 | case BITS_DATA_9: |
| 408 | dbg("%s - data bits = 9 (not supported, " |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 409 | "using 8 data bits)", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 410 | cflag |= CS8; |
| 411 | bits &= ~BITS_DATA_MASK; |
| 412 | bits |= BITS_DATA_8; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 413 | cp2101_set_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 414 | break; |
| 415 | default: |
| 416 | dbg("%s - Unknown number of data bits, " |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 417 | "using 8", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 418 | cflag |= CS8; |
| 419 | bits &= ~BITS_DATA_MASK; |
| 420 | bits |= BITS_DATA_8; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 421 | cp2101_set_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 422 | break; |
| 423 | } |
| 424 | |
| 425 | switch(bits & BITS_PARITY_MASK) { |
| 426 | case BITS_PARITY_NONE: |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 427 | dbg("%s - parity = NONE", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 428 | cflag &= ~PARENB; |
| 429 | break; |
| 430 | case BITS_PARITY_ODD: |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 431 | dbg("%s - parity = ODD", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 432 | cflag |= (PARENB|PARODD); |
| 433 | break; |
| 434 | case BITS_PARITY_EVEN: |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 435 | dbg("%s - parity = EVEN", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 436 | cflag &= ~PARODD; |
| 437 | cflag |= PARENB; |
| 438 | break; |
| 439 | case BITS_PARITY_MARK: |
| 440 | dbg("%s - parity = MARK (not supported, " |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 441 | "disabling parity)", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 442 | cflag &= ~PARENB; |
| 443 | bits &= ~BITS_PARITY_MASK; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 444 | cp2101_set_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 445 | break; |
| 446 | case BITS_PARITY_SPACE: |
| 447 | dbg("%s - parity = SPACE (not supported, " |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 448 | "disabling parity)", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 449 | cflag &= ~PARENB; |
| 450 | bits &= ~BITS_PARITY_MASK; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 451 | cp2101_set_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 452 | break; |
| 453 | default: |
| 454 | dbg("%s - Unknown parity mode, " |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 455 | "disabling parity", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 456 | cflag &= ~PARENB; |
| 457 | bits &= ~BITS_PARITY_MASK; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 458 | cp2101_set_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 459 | break; |
| 460 | } |
| 461 | |
| 462 | cflag &= ~CSTOPB; |
| 463 | switch(bits & BITS_STOP_MASK) { |
| 464 | case BITS_STOP_1: |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 465 | dbg("%s - stop bits = 1", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 466 | break; |
| 467 | case BITS_STOP_1_5: |
| 468 | dbg("%s - stop bits = 1.5 (not supported, " |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 469 | "using 1 stop bit)", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 470 | bits &= ~BITS_STOP_MASK; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 471 | cp2101_set_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 472 | break; |
| 473 | case BITS_STOP_2: |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 474 | dbg("%s - stop bits = 2", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 475 | cflag |= CSTOPB; |
| 476 | break; |
| 477 | default: |
| 478 | dbg("%s - Unknown number of stop bits, " |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 479 | "using 1 stop bit", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 480 | bits &= ~BITS_STOP_MASK; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 481 | cp2101_set_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 482 | break; |
| 483 | } |
| 484 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 485 | cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16); |
| 486 | if (modem_ctl[0] & 0x0008) { |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 487 | dbg("%s - flow control = CRTSCTS", __func__); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 488 | cflag |= CRTSCTS; |
| 489 | } else { |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 490 | dbg("%s - flow control = NONE", __func__); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 491 | cflag &= ~CRTSCTS; |
| 492 | } |
| 493 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 494 | port->tty->termios->c_cflag = cflag; |
| 495 | } |
| 496 | |
| 497 | static void cp2101_set_termios (struct usb_serial_port *port, |
Alan Cox | 606d099 | 2006-12-08 02:38:45 -0800 | [diff] [blame] | 498 | struct ktermios *old_termios) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 499 | { |
Alan Cox | 9ab0f20 | 2007-10-18 01:24:24 -0700 | [diff] [blame] | 500 | unsigned int cflag, old_cflag; |
Harvey Harrison | b2bdd1f | 2008-05-30 10:29:55 -0700 | [diff] [blame^] | 501 | unsigned int baud = 0, bits; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 502 | unsigned int modem_ctl[4]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 503 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 504 | dbg("%s - port %d", __func__, port->number); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 505 | |
Alan Cox | c4e4156 | 2007-08-22 23:06:48 +0100 | [diff] [blame] | 506 | if (!port->tty || !port->tty->termios) { |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 507 | dbg("%s - no tty structures", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 508 | return; |
| 509 | } |
Alan Cox | 9ab0f20 | 2007-10-18 01:24:24 -0700 | [diff] [blame] | 510 | port->tty->termios->c_cflag &= ~CMSPAR; |
| 511 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 512 | cflag = port->tty->termios->c_cflag; |
Alan Cox | 01e96d2 | 2007-07-26 18:54:12 +0100 | [diff] [blame] | 513 | old_cflag = old_termios->c_cflag; |
| 514 | baud = tty_get_baud_rate(port->tty); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 515 | |
| 516 | /* If the baud rate is to be updated*/ |
Alan Cox | 01e96d2 | 2007-07-26 18:54:12 +0100 | [diff] [blame] | 517 | if (baud != tty_termios_baud_rate(old_termios)) { |
| 518 | switch (baud) { |
| 519 | case 0: |
| 520 | case 600: |
| 521 | case 1200: |
| 522 | case 1800: |
| 523 | case 2400: |
| 524 | case 4800: |
| 525 | case 7200: |
| 526 | case 9600: |
| 527 | case 14400: |
| 528 | case 19200: |
| 529 | case 28800: |
| 530 | case 38400: |
| 531 | case 55854: |
| 532 | case 57600: |
| 533 | case 115200: |
| 534 | case 127117: |
| 535 | case 230400: |
| 536 | case 460800: |
| 537 | case 921600: |
| 538 | case 3686400: |
| 539 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 540 | default: |
Alan Cox | 01e96d2 | 2007-07-26 18:54:12 +0100 | [diff] [blame] | 541 | baud = 9600; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 542 | break; |
| 543 | } |
| 544 | |
| 545 | if (baud) { |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 546 | dbg("%s - Setting baud rate to %d baud", __func__, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 547 | baud); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 548 | if (cp2101_set_config_single(port, CP2101_BAUDRATE, |
Alan Cox | 9ab0f20 | 2007-10-18 01:24:24 -0700 | [diff] [blame] | 549 | (BAUD_RATE_GEN_FREQ / baud))) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 550 | dev_err(&port->dev, "Baud rate requested not " |
| 551 | "supported by device\n"); |
Alan Cox | 9ab0f20 | 2007-10-18 01:24:24 -0700 | [diff] [blame] | 552 | baud = tty_termios_baud_rate(old_termios); |
| 553 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 554 | } |
| 555 | } |
Alan Cox | 9ab0f20 | 2007-10-18 01:24:24 -0700 | [diff] [blame] | 556 | /* Report back the resulting baud rate */ |
| 557 | tty_encode_baud_rate(port->tty, baud, baud); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 558 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 559 | /* If the number of data bits is to be updated */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 560 | if ((cflag & CSIZE) != (old_cflag & CSIZE)) { |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 561 | cp2101_get_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 562 | bits &= ~BITS_DATA_MASK; |
| 563 | switch (cflag & CSIZE) { |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 564 | case CS5: |
| 565 | bits |= BITS_DATA_5; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 566 | dbg("%s - data bits = 5", __func__); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 567 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 568 | case CS6: |
| 569 | bits |= BITS_DATA_6; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 570 | dbg("%s - data bits = 6", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 571 | break; |
| 572 | case CS7: |
| 573 | bits |= BITS_DATA_7; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 574 | dbg("%s - data bits = 7", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 575 | break; |
| 576 | case CS8: |
| 577 | bits |= BITS_DATA_8; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 578 | dbg("%s - data bits = 8", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 579 | break; |
| 580 | /*case CS9: |
| 581 | bits |= BITS_DATA_9; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 582 | dbg("%s - data bits = 9", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 583 | break;*/ |
| 584 | default: |
| 585 | dev_err(&port->dev, "cp2101 driver does not " |
| 586 | "support the number of bits requested," |
| 587 | " using 8 bit mode\n"); |
| 588 | bits |= BITS_DATA_8; |
| 589 | break; |
| 590 | } |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 591 | if (cp2101_set_config(port, CP2101_BITS, &bits, 2)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 592 | dev_err(&port->dev, "Number of data bits requested " |
| 593 | "not supported by device\n"); |
| 594 | } |
| 595 | |
| 596 | if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))) { |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 597 | cp2101_get_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 598 | bits &= ~BITS_PARITY_MASK; |
| 599 | if (cflag & PARENB) { |
| 600 | if (cflag & PARODD) { |
| 601 | bits |= BITS_PARITY_ODD; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 602 | dbg("%s - parity = ODD", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 603 | } else { |
| 604 | bits |= BITS_PARITY_EVEN; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 605 | dbg("%s - parity = EVEN", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 606 | } |
| 607 | } |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 608 | if (cp2101_set_config(port, CP2101_BITS, &bits, 2)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 609 | dev_err(&port->dev, "Parity mode not supported " |
| 610 | "by device\n"); |
| 611 | } |
| 612 | |
| 613 | if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) { |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 614 | cp2101_get_config(port, CP2101_BITS, &bits, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 615 | bits &= ~BITS_STOP_MASK; |
| 616 | if (cflag & CSTOPB) { |
| 617 | bits |= BITS_STOP_2; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 618 | dbg("%s - stop bits = 2", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 619 | } else { |
| 620 | bits |= BITS_STOP_1; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 621 | dbg("%s - stop bits = 1", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 622 | } |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 623 | if (cp2101_set_config(port, CP2101_BITS, &bits, 2)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 624 | dev_err(&port->dev, "Number of stop bits requested " |
| 625 | "not supported by device\n"); |
| 626 | } |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 627 | |
| 628 | if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) { |
| 629 | cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16); |
| 630 | dbg("%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x", |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 631 | __func__, modem_ctl[0], modem_ctl[1], |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 632 | modem_ctl[2], modem_ctl[3]); |
| 633 | |
| 634 | if (cflag & CRTSCTS) { |
| 635 | modem_ctl[0] &= ~0x7B; |
| 636 | modem_ctl[0] |= 0x09; |
| 637 | modem_ctl[1] = 0x80; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 638 | dbg("%s - flow control = CRTSCTS", __func__); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 639 | } else { |
| 640 | modem_ctl[0] &= ~0x7B; |
| 641 | modem_ctl[0] |= 0x01; |
| 642 | modem_ctl[1] |= 0x40; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 643 | dbg("%s - flow control = NONE", __func__); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 644 | } |
| 645 | |
| 646 | dbg("%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x", |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 647 | __func__, modem_ctl[0], modem_ctl[1], |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 648 | modem_ctl[2], modem_ctl[3]); |
| 649 | cp2101_set_config(port, CP2101_MODEMCTL, modem_ctl, 16); |
| 650 | } |
| 651 | |
| 652 | } |
| 653 | |
| 654 | static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file, |
| 655 | unsigned int set, unsigned int clear) |
| 656 | { |
Harvey Harrison | b2bdd1f | 2008-05-30 10:29:55 -0700 | [diff] [blame^] | 657 | unsigned int control = 0; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 658 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 659 | dbg("%s - port %d", __func__, port->number); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 660 | |
| 661 | if (set & TIOCM_RTS) { |
| 662 | control |= CONTROL_RTS; |
| 663 | control |= CONTROL_WRITE_RTS; |
| 664 | } |
| 665 | if (set & TIOCM_DTR) { |
| 666 | control |= CONTROL_DTR; |
| 667 | control |= CONTROL_WRITE_DTR; |
| 668 | } |
| 669 | if (clear & TIOCM_RTS) { |
| 670 | control &= ~CONTROL_RTS; |
| 671 | control |= CONTROL_WRITE_RTS; |
| 672 | } |
| 673 | if (clear & TIOCM_DTR) { |
| 674 | control &= ~CONTROL_DTR; |
| 675 | control |= CONTROL_WRITE_DTR; |
| 676 | } |
| 677 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 678 | dbg("%s - control = 0x%.4x", __func__, control); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 679 | |
| 680 | return cp2101_set_config(port, CP2101_CONTROL, &control, 2); |
| 681 | |
| 682 | } |
| 683 | |
| 684 | static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file) |
| 685 | { |
Harvey Harrison | b2bdd1f | 2008-05-30 10:29:55 -0700 | [diff] [blame^] | 686 | unsigned int control; |
| 687 | int result; |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 688 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 689 | dbg("%s - port %d", __func__, port->number); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 690 | |
| 691 | cp2101_get_config(port, CP2101_CONTROL, &control, 1); |
| 692 | |
| 693 | result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0) |
| 694 | |((control & CONTROL_RTS) ? TIOCM_RTS : 0) |
| 695 | |((control & CONTROL_CTS) ? TIOCM_CTS : 0) |
| 696 | |((control & CONTROL_DSR) ? TIOCM_DSR : 0) |
| 697 | |((control & CONTROL_RING)? TIOCM_RI : 0) |
| 698 | |((control & CONTROL_DCD) ? TIOCM_CD : 0); |
| 699 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 700 | dbg("%s - control = 0x%.2x", __func__, control); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 701 | |
| 702 | return result; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 703 | } |
| 704 | |
| 705 | static void cp2101_break_ctl (struct usb_serial_port *port, int break_state) |
| 706 | { |
Harvey Harrison | b2bdd1f | 2008-05-30 10:29:55 -0700 | [diff] [blame^] | 707 | unsigned int state; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 708 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 709 | dbg("%s - port %d", __func__, port->number); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 710 | if (break_state == 0) |
| 711 | state = BREAK_OFF; |
| 712 | else |
| 713 | state = BREAK_ON; |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 714 | dbg("%s - turning break %s", __func__, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 715 | state==BREAK_OFF ? "off" : "on"); |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 716 | cp2101_set_config(port, CP2101_BREAK, &state, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 717 | } |
| 718 | |
| 719 | static int cp2101_startup (struct usb_serial *serial) |
| 720 | { |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 721 | /* CP2101 buffers behave strangely unless device is reset */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 722 | usb_reset_device(serial->dev); |
| 723 | return 0; |
| 724 | } |
| 725 | |
| 726 | static void cp2101_shutdown (struct usb_serial *serial) |
| 727 | { |
| 728 | int i; |
| 729 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 730 | dbg("%s", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 731 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 732 | /* Stop reads and writes on all ports */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 733 | for (i=0; i < serial->num_ports; ++i) { |
| 734 | cp2101_cleanup(serial->port[i]); |
| 735 | } |
| 736 | } |
| 737 | |
| 738 | static int __init cp2101_init (void) |
| 739 | { |
| 740 | int retval; |
| 741 | |
| 742 | retval = usb_serial_register(&cp2101_device); |
| 743 | if (retval) |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 744 | return retval; /* Failed to register */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 745 | |
| 746 | retval = usb_register(&cp2101_driver); |
| 747 | if (retval) { |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 748 | /* Failed to register */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 749 | usb_serial_deregister(&cp2101_device); |
| 750 | return retval; |
| 751 | } |
| 752 | |
Craig Shelley | 39a66b8 | 2005-05-27 00:09:56 +0100 | [diff] [blame] | 753 | /* Success */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 754 | info(DRIVER_DESC " " DRIVER_VERSION); |
| 755 | return 0; |
| 756 | } |
| 757 | |
| 758 | static void __exit cp2101_exit (void) |
| 759 | { |
| 760 | usb_deregister (&cp2101_driver); |
| 761 | usb_serial_deregister (&cp2101_device); |
| 762 | } |
| 763 | |
| 764 | module_init(cp2101_init); |
| 765 | module_exit(cp2101_exit); |
| 766 | |
| 767 | MODULE_DESCRIPTION(DRIVER_DESC); |
| 768 | MODULE_VERSION(DRIVER_VERSION); |
| 769 | MODULE_LICENSE("GPL"); |
| 770 | |
| 771 | module_param(debug, bool, S_IRUGO | S_IWUSR); |
| 772 | MODULE_PARM_DESC(debug, "Enable verbose debugging messages"); |