Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 1 | /* |
| 2 | * spcp8x5 USB to serial adaptor driver |
| 3 | * |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 4 | * Copyright (C) 2010 Johan Hovold (jhovold@gmail.com) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 5 | * Copyright (C) 2006 Linxb (xubin.lin@worldplus.com.cn) |
| 6 | * Copyright (C) 2006 S1 Corp. |
| 7 | * |
| 8 | * Original driver for 2.6.10 pl2303 driver by |
| 9 | * Greg Kroah-Hartman (greg@kroah.com) |
| 10 | * Changes for 2.6.20 by Harald Klein <hari@vt100.at> |
| 11 | * |
| 12 | * This program is free software; you can redistribute it and/or modify |
| 13 | * it under the terms of the GNU General Public License as published by |
| 14 | * the Free Software Foundation; either version 2 of the License, or |
| 15 | * (at your option) any later version. |
| 16 | * |
| 17 | * |
| 18 | */ |
| 19 | #include <linux/kernel.h> |
| 20 | #include <linux/errno.h> |
| 21 | #include <linux/init.h> |
| 22 | #include <linux/slab.h> |
| 23 | #include <linux/tty.h> |
| 24 | #include <linux/tty_driver.h> |
| 25 | #include <linux/tty_flip.h> |
| 26 | #include <linux/module.h> |
| 27 | #include <linux/spinlock.h> |
| 28 | #include <linux/usb.h> |
| 29 | #include <linux/usb/serial.h> |
| 30 | |
| 31 | |
| 32 | /* Version Information */ |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 33 | #define DRIVER_VERSION "v0.10" |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 34 | #define DRIVER_DESC "SPCP8x5 USB to serial adaptor driver" |
| 35 | |
Rusty Russell | 90ab5ee | 2012-01-13 09:32:20 +1030 | [diff] [blame] | 36 | static bool debug; |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 37 | |
| 38 | #define SPCP8x5_007_VID 0x04FC |
| 39 | #define SPCP8x5_007_PID 0x0201 |
| 40 | #define SPCP8x5_008_VID 0x04fc |
| 41 | #define SPCP8x5_008_PID 0x0235 |
| 42 | #define SPCP8x5_PHILIPS_VID 0x0471 |
| 43 | #define SPCP8x5_PHILIPS_PID 0x081e |
| 44 | #define SPCP8x5_INTERMATIC_VID 0x04FC |
| 45 | #define SPCP8x5_INTERMATIC_PID 0x0204 |
| 46 | #define SPCP8x5_835_VID 0x04fc |
| 47 | #define SPCP8x5_835_PID 0x0231 |
| 48 | |
Németh Márton | 7d40d7e | 2010-01-10 15:34:24 +0100 | [diff] [blame] | 49 | static const struct usb_device_id id_table[] = { |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 50 | { USB_DEVICE(SPCP8x5_PHILIPS_VID , SPCP8x5_PHILIPS_PID)}, |
| 51 | { USB_DEVICE(SPCP8x5_INTERMATIC_VID, SPCP8x5_INTERMATIC_PID)}, |
| 52 | { USB_DEVICE(SPCP8x5_835_VID, SPCP8x5_835_PID)}, |
| 53 | { USB_DEVICE(SPCP8x5_008_VID, SPCP8x5_008_PID)}, |
| 54 | { USB_DEVICE(SPCP8x5_007_VID, SPCP8x5_007_PID)}, |
| 55 | { } /* Terminating entry */ |
| 56 | }; |
| 57 | MODULE_DEVICE_TABLE(usb, id_table); |
| 58 | |
| 59 | struct spcp8x5_usb_ctrl_arg { |
| 60 | u8 type; |
| 61 | u8 cmd; |
| 62 | u8 cmd_type; |
| 63 | u16 value; |
| 64 | u16 index; |
| 65 | u16 length; |
| 66 | }; |
| 67 | |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 68 | |
| 69 | /* spcp8x5 spec register define */ |
| 70 | #define MCR_CONTROL_LINE_RTS 0x02 |
| 71 | #define MCR_CONTROL_LINE_DTR 0x01 |
| 72 | #define MCR_DTR 0x01 |
| 73 | #define MCR_RTS 0x02 |
| 74 | |
| 75 | #define MSR_STATUS_LINE_DCD 0x80 |
| 76 | #define MSR_STATUS_LINE_RI 0x40 |
| 77 | #define MSR_STATUS_LINE_DSR 0x20 |
| 78 | #define MSR_STATUS_LINE_CTS 0x10 |
| 79 | |
| 80 | /* verdor command here , we should define myself */ |
| 81 | #define SET_DEFAULT 0x40 |
| 82 | #define SET_DEFAULT_TYPE 0x20 |
| 83 | |
| 84 | #define SET_UART_FORMAT 0x40 |
| 85 | #define SET_UART_FORMAT_TYPE 0x21 |
| 86 | #define SET_UART_FORMAT_SIZE_5 0x00 |
| 87 | #define SET_UART_FORMAT_SIZE_6 0x01 |
| 88 | #define SET_UART_FORMAT_SIZE_7 0x02 |
| 89 | #define SET_UART_FORMAT_SIZE_8 0x03 |
| 90 | #define SET_UART_FORMAT_STOP_1 0x00 |
| 91 | #define SET_UART_FORMAT_STOP_2 0x04 |
| 92 | #define SET_UART_FORMAT_PAR_NONE 0x00 |
| 93 | #define SET_UART_FORMAT_PAR_ODD 0x10 |
| 94 | #define SET_UART_FORMAT_PAR_EVEN 0x30 |
| 95 | #define SET_UART_FORMAT_PAR_MASK 0xD0 |
| 96 | #define SET_UART_FORMAT_PAR_SPACE 0x90 |
| 97 | |
| 98 | #define GET_UART_STATUS_TYPE 0xc0 |
| 99 | #define GET_UART_STATUS 0x22 |
| 100 | #define GET_UART_STATUS_MSR 0x06 |
| 101 | |
| 102 | #define SET_UART_STATUS 0x40 |
| 103 | #define SET_UART_STATUS_TYPE 0x23 |
| 104 | #define SET_UART_STATUS_MCR 0x0004 |
| 105 | #define SET_UART_STATUS_MCR_DTR 0x01 |
| 106 | #define SET_UART_STATUS_MCR_RTS 0x02 |
| 107 | #define SET_UART_STATUS_MCR_LOOP 0x10 |
| 108 | |
| 109 | #define SET_WORKING_MODE 0x40 |
| 110 | #define SET_WORKING_MODE_TYPE 0x24 |
| 111 | #define SET_WORKING_MODE_U2C 0x00 |
| 112 | #define SET_WORKING_MODE_RS485 0x01 |
| 113 | #define SET_WORKING_MODE_PDMA 0x02 |
| 114 | #define SET_WORKING_MODE_SPP 0x03 |
| 115 | |
| 116 | #define SET_FLOWCTL_CHAR 0x40 |
| 117 | #define SET_FLOWCTL_CHAR_TYPE 0x25 |
| 118 | |
| 119 | #define GET_VERSION 0xc0 |
| 120 | #define GET_VERSION_TYPE 0x26 |
| 121 | |
| 122 | #define SET_REGISTER 0x40 |
| 123 | #define SET_REGISTER_TYPE 0x27 |
| 124 | |
| 125 | #define GET_REGISTER 0xc0 |
| 126 | #define GET_REGISTER_TYPE 0x28 |
| 127 | |
| 128 | #define SET_RAM 0x40 |
| 129 | #define SET_RAM_TYPE 0x31 |
| 130 | |
| 131 | #define GET_RAM 0xc0 |
| 132 | #define GET_RAM_TYPE 0x32 |
| 133 | |
| 134 | /* how come ??? */ |
| 135 | #define UART_STATE 0x08 |
Libor Pechacek | d14fc1a | 2011-01-14 14:30:21 +0100 | [diff] [blame] | 136 | #define UART_STATE_TRANSIENT_MASK 0x75 |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 137 | #define UART_DCD 0x01 |
| 138 | #define UART_DSR 0x02 |
| 139 | #define UART_BREAK_ERROR 0x04 |
| 140 | #define UART_RING 0x08 |
| 141 | #define UART_FRAME_ERROR 0x10 |
| 142 | #define UART_PARITY_ERROR 0x20 |
| 143 | #define UART_OVERRUN_ERROR 0x40 |
| 144 | #define UART_CTS 0x80 |
| 145 | |
| 146 | enum spcp8x5_type { |
| 147 | SPCP825_007_TYPE, |
| 148 | SPCP825_008_TYPE, |
| 149 | SPCP825_PHILIP_TYPE, |
| 150 | SPCP825_INTERMATIC_TYPE, |
| 151 | SPCP835_TYPE, |
| 152 | }; |
| 153 | |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 154 | struct spcp8x5_private { |
| 155 | spinlock_t lock; |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 156 | enum spcp8x5_type type; |
| 157 | wait_queue_head_t delta_msr_wait; |
| 158 | u8 line_control; |
| 159 | u8 line_status; |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 160 | }; |
| 161 | |
| 162 | /* desc : when device plug in,this function would be called. |
| 163 | * thanks to usb_serial subsystem,then do almost every things for us. And what |
| 164 | * we should do just alloc the buffer */ |
| 165 | static int spcp8x5_startup(struct usb_serial *serial) |
| 166 | { |
| 167 | struct spcp8x5_private *priv; |
| 168 | int i; |
| 169 | enum spcp8x5_type type = SPCP825_007_TYPE; |
Al Viro | fd05e72 | 2008-04-28 07:00:16 +0100 | [diff] [blame] | 170 | u16 product = le16_to_cpu(serial->dev->descriptor.idProduct); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 171 | |
Al Viro | fd05e72 | 2008-04-28 07:00:16 +0100 | [diff] [blame] | 172 | if (product == 0x0201) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 173 | type = SPCP825_007_TYPE; |
Al Viro | fd05e72 | 2008-04-28 07:00:16 +0100 | [diff] [blame] | 174 | else if (product == 0x0231) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 175 | type = SPCP835_TYPE; |
Al Viro | fd05e72 | 2008-04-28 07:00:16 +0100 | [diff] [blame] | 176 | else if (product == 0x0235) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 177 | type = SPCP825_008_TYPE; |
Al Viro | fd05e72 | 2008-04-28 07:00:16 +0100 | [diff] [blame] | 178 | else if (product == 0x0204) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 179 | type = SPCP825_INTERMATIC_TYPE; |
Al Viro | fd05e72 | 2008-04-28 07:00:16 +0100 | [diff] [blame] | 180 | else if (product == 0x0471 && |
| 181 | serial->dev->descriptor.idVendor == cpu_to_le16(0x081e)) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 182 | type = SPCP825_PHILIP_TYPE; |
| 183 | dev_dbg(&serial->dev->dev, "device type = %d\n", (int)type); |
| 184 | |
| 185 | for (i = 0; i < serial->num_ports; ++i) { |
| 186 | priv = kzalloc(sizeof(struct spcp8x5_private), GFP_KERNEL); |
| 187 | if (!priv) |
| 188 | goto cleanup; |
| 189 | |
| 190 | spin_lock_init(&priv->lock); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 191 | init_waitqueue_head(&priv->delta_msr_wait); |
| 192 | priv->type = type; |
| 193 | usb_set_serial_port_data(serial->port[i] , priv); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 194 | } |
| 195 | |
| 196 | return 0; |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 197 | cleanup: |
| 198 | for (--i; i >= 0; --i) { |
| 199 | priv = usb_get_serial_port_data(serial->port[i]); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 200 | kfree(priv); |
| 201 | usb_set_serial_port_data(serial->port[i] , NULL); |
| 202 | } |
| 203 | return -ENOMEM; |
| 204 | } |
| 205 | |
| 206 | /* call when the device plug out. free all the memory alloced by probe */ |
Alan Stern | f9c99bb | 2009-06-02 11:53:55 -0400 | [diff] [blame] | 207 | static void spcp8x5_release(struct usb_serial *serial) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 208 | { |
| 209 | int i; |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 210 | |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 211 | for (i = 0; i < serial->num_ports; i++) |
| 212 | kfree(usb_get_serial_port_data(serial->port[i])); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 213 | } |
| 214 | |
| 215 | /* set the modem control line of the device. |
| 216 | * NOTE spcp825-007 not supported this */ |
| 217 | static int spcp8x5_set_ctrlLine(struct usb_device *dev, u8 value, |
| 218 | enum spcp8x5_type type) |
| 219 | { |
| 220 | int retval; |
| 221 | u8 mcr = 0 ; |
| 222 | |
| 223 | if (type == SPCP825_007_TYPE) |
| 224 | return -EPERM; |
| 225 | |
| 226 | mcr = (unsigned short)value; |
| 227 | retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), |
| 228 | SET_UART_STATUS_TYPE, SET_UART_STATUS, |
| 229 | mcr, 0x04, NULL, 0, 100); |
| 230 | if (retval != 0) |
| 231 | dev_dbg(&dev->dev, "usb_control_msg return %#x\n", retval); |
| 232 | return retval; |
| 233 | } |
| 234 | |
| 235 | /* get the modem status register of the device |
| 236 | * NOTE spcp825-007 not supported this */ |
| 237 | static int spcp8x5_get_msr(struct usb_device *dev, u8 *status, |
| 238 | enum spcp8x5_type type) |
| 239 | { |
| 240 | u8 *status_buffer; |
| 241 | int ret; |
| 242 | |
| 243 | /* I return Permited not support here but seem inval device |
| 244 | * is more fix */ |
| 245 | if (type == SPCP825_007_TYPE) |
| 246 | return -EPERM; |
| 247 | if (status == NULL) |
| 248 | return -EINVAL; |
| 249 | |
| 250 | status_buffer = kmalloc(1, GFP_KERNEL); |
| 251 | if (!status_buffer) |
| 252 | return -ENOMEM; |
| 253 | status_buffer[0] = status[0]; |
| 254 | |
| 255 | ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), |
| 256 | GET_UART_STATUS, GET_UART_STATUS_TYPE, |
| 257 | 0, GET_UART_STATUS_MSR, status_buffer, 1, 100); |
| 258 | if (ret < 0) |
| 259 | dev_dbg(&dev->dev, "Get MSR = 0x%p failed (error = %d)", |
| 260 | status_buffer, ret); |
| 261 | |
| 262 | dev_dbg(&dev->dev, "0xc0:0x22:0:6 %d - 0x%p ", ret, status_buffer); |
| 263 | status[0] = status_buffer[0]; |
| 264 | kfree(status_buffer); |
| 265 | |
| 266 | return ret; |
| 267 | } |
| 268 | |
| 269 | /* select the work mode. |
| 270 | * NOTE this function not supported by spcp825-007 */ |
| 271 | static void spcp8x5_set_workMode(struct usb_device *dev, u16 value, |
| 272 | u16 index, enum spcp8x5_type type) |
| 273 | { |
| 274 | int ret; |
| 275 | |
| 276 | /* I return Permited not support here but seem inval device |
| 277 | * is more fix */ |
| 278 | if (type == SPCP825_007_TYPE) |
| 279 | return; |
| 280 | |
| 281 | ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), |
| 282 | SET_WORKING_MODE_TYPE, SET_WORKING_MODE, |
| 283 | value, index, NULL, 0, 100); |
| 284 | dev_dbg(&dev->dev, "value = %#x , index = %#x\n", value, index); |
| 285 | if (ret < 0) |
| 286 | dev_dbg(&dev->dev, |
| 287 | "RTSCTS usb_control_msg(enable flowctrl) = %d\n", ret); |
| 288 | } |
| 289 | |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 290 | static int spcp8x5_carrier_raised(struct usb_serial_port *port) |
| 291 | { |
| 292 | struct spcp8x5_private *priv = usb_get_serial_port_data(port); |
| 293 | if (priv->line_status & MSR_STATUS_LINE_DCD) |
| 294 | return 1; |
| 295 | return 0; |
| 296 | } |
| 297 | |
| 298 | static void spcp8x5_dtr_rts(struct usb_serial_port *port, int on) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 299 | { |
| 300 | struct spcp8x5_private *priv = usb_get_serial_port_data(port); |
| 301 | unsigned long flags; |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 302 | u8 control; |
| 303 | |
| 304 | spin_lock_irqsave(&priv->lock, flags); |
| 305 | if (on) |
| 306 | priv->line_control = MCR_CONTROL_LINE_DTR |
| 307 | | MCR_CONTROL_LINE_RTS; |
| 308 | else |
| 309 | priv->line_control &= ~ (MCR_CONTROL_LINE_DTR |
| 310 | | MCR_CONTROL_LINE_RTS); |
| 311 | control = priv->line_control; |
| 312 | spin_unlock_irqrestore(&priv->lock, flags); |
| 313 | spcp8x5_set_ctrlLine(port->serial->dev, control , priv->type); |
| 314 | } |
| 315 | |
Alan Cox | fe1ae7f | 2009-09-19 13:13:33 -0700 | [diff] [blame] | 316 | static void spcp8x5_init_termios(struct tty_struct *tty) |
| 317 | { |
| 318 | /* for the 1st time call this function */ |
| 319 | *(tty->termios) = tty_std_termios; |
| 320 | tty->termios->c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL; |
| 321 | tty->termios->c_ispeed = 115200; |
| 322 | tty->termios->c_ospeed = 115200; |
| 323 | } |
| 324 | |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 325 | /* set the serial param for transfer. we should check if we really need to |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 326 | * transfer. if we set flow control we should do this too. */ |
| 327 | static void spcp8x5_set_termios(struct tty_struct *tty, |
| 328 | struct usb_serial_port *port, struct ktermios *old_termios) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 329 | { |
| 330 | struct usb_serial *serial = port->serial; |
| 331 | struct spcp8x5_private *priv = usb_get_serial_port_data(port); |
| 332 | unsigned long flags; |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 333 | unsigned int cflag = tty->termios->c_cflag; |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 334 | unsigned int old_cflag = old_termios->c_cflag; |
| 335 | unsigned short uartdata; |
| 336 | unsigned char buf[2] = {0, 0}; |
| 337 | int baud; |
| 338 | int i; |
| 339 | u8 control; |
| 340 | |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 341 | |
| 342 | /* check that they really want us to change something */ |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 343 | if (!tty_termios_hw_change(tty->termios, old_termios)) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 344 | return; |
| 345 | |
| 346 | /* set DTR/RTS active */ |
| 347 | spin_lock_irqsave(&priv->lock, flags); |
| 348 | control = priv->line_control; |
| 349 | if ((old_cflag & CBAUD) == B0) { |
| 350 | priv->line_control |= MCR_DTR; |
| 351 | if (!(old_cflag & CRTSCTS)) |
| 352 | priv->line_control |= MCR_RTS; |
| 353 | } |
| 354 | if (control != priv->line_control) { |
| 355 | control = priv->line_control; |
| 356 | spin_unlock_irqrestore(&priv->lock, flags); |
| 357 | spcp8x5_set_ctrlLine(serial->dev, control , priv->type); |
| 358 | } else { |
| 359 | spin_unlock_irqrestore(&priv->lock, flags); |
| 360 | } |
| 361 | |
| 362 | /* Set Baud Rate */ |
Joe Perches | a419aef | 2009-08-18 11:18:35 -0700 | [diff] [blame] | 363 | baud = tty_get_baud_rate(tty); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 364 | switch (baud) { |
| 365 | case 300: buf[0] = 0x00; break; |
| 366 | case 600: buf[0] = 0x01; break; |
| 367 | case 1200: buf[0] = 0x02; break; |
| 368 | case 2400: buf[0] = 0x03; break; |
| 369 | case 4800: buf[0] = 0x04; break; |
| 370 | case 9600: buf[0] = 0x05; break; |
| 371 | case 19200: buf[0] = 0x07; break; |
| 372 | case 38400: buf[0] = 0x09; break; |
| 373 | case 57600: buf[0] = 0x0a; break; |
| 374 | case 115200: buf[0] = 0x0b; break; |
| 375 | case 230400: buf[0] = 0x0c; break; |
| 376 | case 460800: buf[0] = 0x0d; break; |
| 377 | case 921600: buf[0] = 0x0e; break; |
| 378 | /* case 1200000: buf[0] = 0x0f; break; */ |
| 379 | /* case 2400000: buf[0] = 0x10; break; */ |
| 380 | case 3000000: buf[0] = 0x11; break; |
| 381 | /* case 6000000: buf[0] = 0x12; break; */ |
| 382 | case 0: |
| 383 | case 1000000: |
| 384 | buf[0] = 0x0b; break; |
| 385 | default: |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 386 | dev_err(&port->dev, "spcp825 driver does not support the " |
| 387 | "baudrate requested, using default of 9600.\n"); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | /* Set Data Length : 00:5bit, 01:6bit, 10:7bit, 11:8bit */ |
| 391 | if (cflag & CSIZE) { |
| 392 | switch (cflag & CSIZE) { |
| 393 | case CS5: |
| 394 | buf[1] |= SET_UART_FORMAT_SIZE_5; |
| 395 | break; |
| 396 | case CS6: |
| 397 | buf[1] |= SET_UART_FORMAT_SIZE_6; |
| 398 | break; |
| 399 | case CS7: |
| 400 | buf[1] |= SET_UART_FORMAT_SIZE_7; |
| 401 | break; |
| 402 | default: |
| 403 | case CS8: |
| 404 | buf[1] |= SET_UART_FORMAT_SIZE_8; |
| 405 | break; |
| 406 | } |
| 407 | } |
| 408 | |
| 409 | /* Set Stop bit2 : 0:1bit 1:2bit */ |
| 410 | buf[1] |= (cflag & CSTOPB) ? SET_UART_FORMAT_STOP_2 : |
| 411 | SET_UART_FORMAT_STOP_1; |
| 412 | |
| 413 | /* Set Parity bit3-4 01:Odd 11:Even */ |
| 414 | if (cflag & PARENB) { |
| 415 | buf[1] |= (cflag & PARODD) ? |
| 416 | SET_UART_FORMAT_PAR_ODD : SET_UART_FORMAT_PAR_EVEN ; |
| 417 | } else |
| 418 | buf[1] |= SET_UART_FORMAT_PAR_NONE; |
| 419 | |
| 420 | uartdata = buf[0] | buf[1]<<8; |
| 421 | |
| 422 | i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 423 | SET_UART_FORMAT_TYPE, SET_UART_FORMAT, |
| 424 | uartdata, 0, NULL, 0, 100); |
| 425 | if (i < 0) |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 426 | dev_err(&port->dev, "Set UART format %#x failed (error = %d)\n", |
| 427 | uartdata, i); |
Greg Kroah-Hartman | fe2baf8 | 2012-05-15 16:27:30 -0700 | [diff] [blame] | 428 | dev_dbg(&port->dev, "0x21:0x40:0:0 %d\n", i); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 429 | |
| 430 | if (cflag & CRTSCTS) { |
| 431 | /* enable hardware flow control */ |
| 432 | spcp8x5_set_workMode(serial->dev, 0x000a, |
| 433 | SET_WORKING_MODE_U2C, priv->type); |
| 434 | } |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 435 | } |
| 436 | |
| 437 | /* open the serial port. do some usb system call. set termios and get the line |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 438 | * status of the device. */ |
Alan Cox | a509a7e | 2009-09-19 13:13:26 -0700 | [diff] [blame] | 439 | static int spcp8x5_open(struct tty_struct *tty, struct usb_serial_port *port) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 440 | { |
| 441 | struct ktermios tmp_termios; |
| 442 | struct usb_serial *serial = port->serial; |
| 443 | struct spcp8x5_private *priv = usb_get_serial_port_data(port); |
| 444 | int ret; |
| 445 | unsigned long flags; |
| 446 | u8 status = 0x30; |
| 447 | /* status 0x30 means DSR and CTS = 1 other CDC RI and delta = 0 */ |
| 448 | |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 449 | usb_clear_halt(serial->dev, port->write_urb->pipe); |
| 450 | usb_clear_halt(serial->dev, port->read_urb->pipe); |
| 451 | |
| 452 | ret = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 453 | 0x09, 0x00, |
| 454 | 0x01, 0x00, NULL, 0x00, 100); |
| 455 | if (ret) |
| 456 | return ret; |
| 457 | |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 458 | spcp8x5_set_ctrlLine(serial->dev, priv->line_control , priv->type); |
| 459 | |
| 460 | /* Setup termios */ |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 461 | if (tty) |
| 462 | spcp8x5_set_termios(tty, port, &tmp_termios); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 463 | |
| 464 | spcp8x5_get_msr(serial->dev, &status, priv->type); |
| 465 | |
| 466 | /* may be we should update uart status here but now we did not do */ |
| 467 | spin_lock_irqsave(&priv->lock, flags); |
| 468 | priv->line_status = status & 0xf0 ; |
| 469 | spin_unlock_irqrestore(&priv->lock, flags); |
| 470 | |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 471 | port->port.drain_delay = 256; |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 472 | |
| 473 | return usb_serial_generic_open(tty, port); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 474 | } |
| 475 | |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 476 | static void spcp8x5_process_read_urb(struct urb *urb) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 477 | { |
| 478 | struct usb_serial_port *port = urb->context; |
| 479 | struct spcp8x5_private *priv = usb_get_serial_port_data(port); |
| 480 | struct tty_struct *tty; |
| 481 | unsigned char *data = urb->transfer_buffer; |
| 482 | unsigned long flags; |
Greg Kroah-Hartman | 50de36f | 2008-12-10 16:00:30 -0800 | [diff] [blame] | 483 | u8 status; |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 484 | char tty_flag; |
| 485 | |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 486 | /* get tty_flag from status */ |
| 487 | tty_flag = TTY_NORMAL; |
| 488 | |
| 489 | spin_lock_irqsave(&priv->lock, flags); |
| 490 | status = priv->line_status; |
| 491 | priv->line_status &= ~UART_STATE_TRANSIENT_MASK; |
| 492 | spin_unlock_irqrestore(&priv->lock, flags); |
| 493 | /* wake up the wait for termios */ |
| 494 | wake_up_interruptible(&priv->delta_msr_wait); |
| 495 | |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 496 | if (!urb->actual_length) |
| 497 | return; |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 498 | |
Alan Cox | 4a90f09 | 2008-10-13 10:39:46 +0100 | [diff] [blame] | 499 | tty = tty_port_tty_get(&port->port); |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 500 | if (!tty) |
| 501 | return; |
| 502 | |
| 503 | if (status & UART_STATE_TRANSIENT_MASK) { |
| 504 | /* break takes precedence over parity, which takes precedence |
| 505 | * over framing errors */ |
| 506 | if (status & UART_BREAK_ERROR) |
| 507 | tty_flag = TTY_BREAK; |
| 508 | else if (status & UART_PARITY_ERROR) |
| 509 | tty_flag = TTY_PARITY; |
| 510 | else if (status & UART_FRAME_ERROR) |
| 511 | tty_flag = TTY_FRAME; |
| 512 | dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag); |
| 513 | |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 514 | /* overrun is special, not associated with a char */ |
| 515 | if (status & UART_OVERRUN_ERROR) |
| 516 | tty_insert_flip_char(tty, 0, TTY_OVERRUN); |
Libor Pechacek | d14fc1a | 2011-01-14 14:30:21 +0100 | [diff] [blame] | 517 | |
| 518 | if (status & UART_DCD) |
| 519 | usb_serial_handle_dcd_change(port, tty, |
| 520 | priv->line_status & MSR_STATUS_LINE_DCD); |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 521 | } |
| 522 | |
| 523 | tty_insert_flip_string_fixed_flag(tty, data, tty_flag, |
Johan Hovold | 70ced22 | 2010-05-07 19:46:56 +0200 | [diff] [blame] | 524 | urb->actual_length); |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 525 | tty_flip_buffer_push(tty); |
Alan Cox | 4a90f09 | 2008-10-13 10:39:46 +0100 | [diff] [blame] | 526 | tty_kref_put(tty); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 527 | } |
| 528 | |
| 529 | static int spcp8x5_wait_modem_info(struct usb_serial_port *port, |
| 530 | unsigned int arg) |
| 531 | { |
| 532 | struct spcp8x5_private *priv = usb_get_serial_port_data(port); |
| 533 | unsigned long flags; |
| 534 | unsigned int prevstatus; |
| 535 | unsigned int status; |
| 536 | unsigned int changed; |
| 537 | |
| 538 | spin_lock_irqsave(&priv->lock, flags); |
| 539 | prevstatus = priv->line_status; |
| 540 | spin_unlock_irqrestore(&priv->lock, flags); |
| 541 | |
| 542 | while (1) { |
| 543 | /* wake up in bulk read */ |
| 544 | interruptible_sleep_on(&priv->delta_msr_wait); |
| 545 | |
| 546 | /* see if a signal did it */ |
| 547 | if (signal_pending(current)) |
| 548 | return -ERESTARTSYS; |
| 549 | |
| 550 | spin_lock_irqsave(&priv->lock, flags); |
| 551 | status = priv->line_status; |
| 552 | spin_unlock_irqrestore(&priv->lock, flags); |
| 553 | |
| 554 | changed = prevstatus^status; |
| 555 | |
| 556 | if (((arg & TIOCM_RNG) && (changed & MSR_STATUS_LINE_RI)) || |
| 557 | ((arg & TIOCM_DSR) && (changed & MSR_STATUS_LINE_DSR)) || |
| 558 | ((arg & TIOCM_CD) && (changed & MSR_STATUS_LINE_DCD)) || |
| 559 | ((arg & TIOCM_CTS) && (changed & MSR_STATUS_LINE_CTS))) |
| 560 | return 0; |
| 561 | |
| 562 | prevstatus = status; |
| 563 | } |
| 564 | /* NOTREACHED */ |
| 565 | return 0; |
| 566 | } |
| 567 | |
Alan Cox | 00a0d0d | 2011-02-14 16:27:06 +0000 | [diff] [blame] | 568 | static int spcp8x5_ioctl(struct tty_struct *tty, |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 569 | unsigned int cmd, unsigned long arg) |
| 570 | { |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 571 | struct usb_serial_port *port = tty->driver_data; |
Greg Kroah-Hartman | fe2baf8 | 2012-05-15 16:27:30 -0700 | [diff] [blame] | 572 | |
| 573 | dev_dbg(&port->dev, "%s (%d) cmd = 0x%04x\n", __func__, |
| 574 | port->number, cmd); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 575 | |
| 576 | switch (cmd) { |
| 577 | case TIOCMIWAIT: |
Greg Kroah-Hartman | fe2baf8 | 2012-05-15 16:27:30 -0700 | [diff] [blame] | 578 | dev_dbg(&port->dev, "%s (%d) TIOCMIWAIT\n", __func__, |
| 579 | port->number); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 580 | return spcp8x5_wait_modem_info(port, arg); |
| 581 | |
| 582 | default: |
Greg Kroah-Hartman | fe2baf8 | 2012-05-15 16:27:30 -0700 | [diff] [blame] | 583 | dev_dbg(&port->dev, "%s not supported = 0x%04x", __func__, |
| 584 | cmd); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 585 | break; |
| 586 | } |
| 587 | |
| 588 | return -ENOIOCTLCMD; |
| 589 | } |
| 590 | |
Alan Cox | 20b9d17 | 2011-02-14 16:26:50 +0000 | [diff] [blame] | 591 | static int spcp8x5_tiocmset(struct tty_struct *tty, |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 592 | unsigned int set, unsigned int clear) |
| 593 | { |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 594 | struct usb_serial_port *port = tty->driver_data; |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 595 | struct spcp8x5_private *priv = usb_get_serial_port_data(port); |
| 596 | unsigned long flags; |
| 597 | u8 control; |
| 598 | |
| 599 | spin_lock_irqsave(&priv->lock, flags); |
| 600 | if (set & TIOCM_RTS) |
| 601 | priv->line_control |= MCR_RTS; |
| 602 | if (set & TIOCM_DTR) |
| 603 | priv->line_control |= MCR_DTR; |
| 604 | if (clear & TIOCM_RTS) |
| 605 | priv->line_control &= ~MCR_RTS; |
| 606 | if (clear & TIOCM_DTR) |
| 607 | priv->line_control &= ~MCR_DTR; |
| 608 | control = priv->line_control; |
| 609 | spin_unlock_irqrestore(&priv->lock, flags); |
| 610 | |
| 611 | return spcp8x5_set_ctrlLine(port->serial->dev, control , priv->type); |
| 612 | } |
| 613 | |
Alan Cox | 60b33c1 | 2011-02-14 16:26:14 +0000 | [diff] [blame] | 614 | static int spcp8x5_tiocmget(struct tty_struct *tty) |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 615 | { |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 616 | struct usb_serial_port *port = tty->driver_data; |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 617 | struct spcp8x5_private *priv = usb_get_serial_port_data(port); |
| 618 | unsigned long flags; |
| 619 | unsigned int mcr; |
| 620 | unsigned int status; |
| 621 | unsigned int result; |
| 622 | |
| 623 | spin_lock_irqsave(&priv->lock, flags); |
| 624 | mcr = priv->line_control; |
| 625 | status = priv->line_status; |
| 626 | spin_unlock_irqrestore(&priv->lock, flags); |
| 627 | |
| 628 | result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) |
| 629 | | ((mcr & MCR_RTS) ? TIOCM_RTS : 0) |
| 630 | | ((status & MSR_STATUS_LINE_CTS) ? TIOCM_CTS : 0) |
| 631 | | ((status & MSR_STATUS_LINE_DSR) ? TIOCM_DSR : 0) |
| 632 | | ((status & MSR_STATUS_LINE_RI) ? TIOCM_RI : 0) |
| 633 | | ((status & MSR_STATUS_LINE_DCD) ? TIOCM_CD : 0); |
| 634 | |
| 635 | return result; |
| 636 | } |
| 637 | |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 638 | /* All of the device info needed for the spcp8x5 SIO serial converter */ |
| 639 | static struct usb_serial_driver spcp8x5_device = { |
| 640 | .driver = { |
| 641 | .owner = THIS_MODULE, |
| 642 | .name = "SPCP8x5", |
| 643 | }, |
| 644 | .id_table = id_table, |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 645 | .num_ports = 1, |
| 646 | .open = spcp8x5_open, |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 647 | .dtr_rts = spcp8x5_dtr_rts, |
| 648 | .carrier_raised = spcp8x5_carrier_raised, |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 649 | .set_termios = spcp8x5_set_termios, |
Alan Cox | fe1ae7f | 2009-09-19 13:13:33 -0700 | [diff] [blame] | 650 | .init_termios = spcp8x5_init_termios, |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 651 | .ioctl = spcp8x5_ioctl, |
| 652 | .tiocmget = spcp8x5_tiocmget, |
| 653 | .tiocmset = spcp8x5_tiocmset, |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 654 | .attach = spcp8x5_startup, |
Alan Stern | f9c99bb | 2009-06-02 11:53:55 -0400 | [diff] [blame] | 655 | .release = spcp8x5_release, |
Johan Hovold | fa993ca | 2010-05-15 17:53:47 +0200 | [diff] [blame] | 656 | .process_read_urb = spcp8x5_process_read_urb, |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 657 | }; |
| 658 | |
Alan Stern | d860322 | 2012-02-23 14:57:25 -0500 | [diff] [blame] | 659 | static struct usb_serial_driver * const serial_drivers[] = { |
| 660 | &spcp8x5_device, NULL |
| 661 | }; |
| 662 | |
Greg Kroah-Hartman | 68e2411 | 2012-05-08 15:46:14 -0700 | [diff] [blame] | 663 | module_usb_serial_driver(serial_drivers, id_table); |
Greg Kroah-Hartman | 619a6f1 | 2008-02-07 23:59:03 +0100 | [diff] [blame] | 664 | |
| 665 | MODULE_DESCRIPTION(DRIVER_DESC); |
| 666 | MODULE_VERSION(DRIVER_VERSION); |
| 667 | MODULE_LICENSE("GPL"); |
| 668 | |
| 669 | module_param(debug, bool, S_IRUGO | S_IWUSR); |
| 670 | MODULE_PARM_DESC(debug, "Debug enabled or not"); |