1 /* 2 * Copyright (C) 2006 3 * Simon Schulz (ark3116_driver <at> auctionant.de) 4 * 5 * ark3116 6 * - implements a driver for the arkmicro ark3116 chipset (vendor=0x6547, 7 * productid=0x0232) (used in a datacable called KQ-U8A) 8 * 9 * - based on code by krisfx -> thanks !! 10 * (see http://www.linuxquestions.org/questions/showthread.php?p=2184457#post2184457) 11 * 12 * - based on logs created by usbsnoopy 13 * 14 * This program is free software; you can redistribute it and/or modify it 15 * under the terms of the GNU General Public License as published by the 16 * Free Software Foundation; either version 2 of the License, or (at your 17 * option) any later version. 18 */ 19 20 #include <linux/kernel.h> 21 #include <linux/init.h> 22 #include <linux/tty.h> 23 #include <linux/module.h> 24 #include <linux/usb.h> 25 #include <linux/usb/serial.h> 26 #include <linux/serial.h> 27 #include <asm/uaccess.h> 28 29 30 static int debug; 31 32 static struct usb_device_id id_table [] = { 33 { USB_DEVICE(0x6547, 0x0232) }, 34 { }, 35 }; 36 MODULE_DEVICE_TABLE(usb, id_table); 37 38 struct ark3116_private { 39 spinlock_t lock; 40 u8 termios_initialized; 41 }; 42 43 static inline void ARK3116_SND(struct usb_serial *serial, int seq, 44 __u8 request, __u8 requesttype, 45 __u16 value, __u16 index) 46 { 47 int result; 48 result = usb_control_msg(serial->dev, 49 usb_sndctrlpipe(serial->dev, 0), 50 request, requesttype, value, index, 51 NULL, 0x00, 1000); 52 dbg("%03d > ok", seq); 53 } 54 55 static inline void ARK3116_RCV(struct usb_serial *serial, int seq, 56 __u8 request, __u8 requesttype, 57 __u16 value, __u16 index, __u8 expected, 58 char *buf) 59 { 60 int result; 61 result = usb_control_msg(serial->dev, 62 usb_rcvctrlpipe(serial->dev, 0), 63 request, requesttype, value, index, 64 buf, 0x0000001, 1000); 65 if (result) 66 dbg("%03d < %d bytes [0x%02X]", seq, result, buf[0]); 67 else 68 dbg("%03d < 0 bytes", seq); 69 } 70 71 static inline void ARK3116_RCV_QUIET(struct usb_serial *serial, 72 __u8 request, __u8 requesttype, 73 __u16 value, __u16 index, char *buf) 74 { 75 usb_control_msg(serial->dev, 76 usb_rcvctrlpipe(serial->dev, 0), 77 request, requesttype, value, index, 78 buf, 0x0000001, 1000); 79 } 80 81 static int ark3116_attach(struct usb_serial *serial) 82 { 83 char *buf; 84 struct ark3116_private *priv; 85 int i; 86 87 for (i = 0; i < serial->num_ports; ++i) { 88 priv = kzalloc(sizeof(struct ark3116_private), GFP_KERNEL); 89 if (!priv) 90 goto cleanup; 91 spin_lock_init(&priv->lock); 92 93 usb_set_serial_port_data(serial->port[i], priv); 94 } 95 96 buf = kmalloc(1, GFP_KERNEL); 97 if (!buf) { 98 dbg("error kmalloc -> out of mem?"); 99 goto cleanup; 100 } 101 102 /* 3 */ 103 ARK3116_SND(serial, 3, 0xFE, 0x40, 0x0008, 0x0002); 104 ARK3116_SND(serial, 4, 0xFE, 0x40, 0x0008, 0x0001); 105 ARK3116_SND(serial, 5, 0xFE, 0x40, 0x0000, 0x0008); 106 ARK3116_SND(serial, 6, 0xFE, 0x40, 0x0000, 0x000B); 107 108 /* <-- seq7 */ 109 ARK3116_RCV(serial, 7, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf); 110 ARK3116_SND(serial, 8, 0xFE, 0x40, 0x0080, 0x0003); 111 ARK3116_SND(serial, 9, 0xFE, 0x40, 0x001A, 0x0000); 112 ARK3116_SND(serial, 10, 0xFE, 0x40, 0x0000, 0x0001); 113 ARK3116_SND(serial, 11, 0xFE, 0x40, 0x0000, 0x0003); 114 115 /* <-- seq12 */ 116 ARK3116_RCV(serial, 12, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf); 117 ARK3116_SND(serial, 13, 0xFE, 0x40, 0x0000, 0x0004); 118 119 /* 14 */ 120 ARK3116_RCV(serial, 14, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf); 121 ARK3116_SND(serial, 15, 0xFE, 0x40, 0x0000, 0x0004); 122 123 /* 16 */ 124 ARK3116_RCV(serial, 16, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf); 125 /* --> seq17 */ 126 ARK3116_SND(serial, 17, 0xFE, 0x40, 0x0001, 0x0004); 127 128 /* <-- seq18 */ 129 ARK3116_RCV(serial, 18, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf); 130 131 /* --> seq19 */ 132 ARK3116_SND(serial, 19, 0xFE, 0x40, 0x0003, 0x0004); 133 134 /* <-- seq20 */ 135 /* seems like serial port status info (RTS, CTS, ...) */ 136 /* returns modem control line status?! */ 137 ARK3116_RCV(serial, 20, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf); 138 139 /* set 9600 baud & do some init?! */ 140 ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003); 141 ARK3116_SND(serial, 148, 0xFE, 0x40, 0x0038, 0x0000); 142 ARK3116_SND(serial, 149, 0xFE, 0x40, 0x0001, 0x0001); 143 ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003); 144 ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf); 145 ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003); 146 ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf); 147 ARK3116_SND(serial, 154, 0xFE, 0x40, 0x0003, 0x0003); 148 149 kfree(buf); 150 return 0; 151 152 cleanup: 153 for (--i; i >= 0; --i) 154 usb_set_serial_port_data(serial->port[i], NULL); 155 return -ENOMEM; 156 } 157 158 static void ark3116_set_termios(struct usb_serial_port *port, 159 struct ktermios *old_termios) 160 { 161 struct usb_serial *serial = port->serial; 162 struct ark3116_private *priv = usb_get_serial_port_data(port); 163 unsigned int cflag = port->tty->termios->c_cflag; 164 unsigned long flags; 165 int baud; 166 int ark3116_baud; 167 char *buf; 168 char config; 169 170 config = 0; 171 172 dbg("%s - port %d", __FUNCTION__, port->number); 173 174 if ((!port->tty) || (!port->tty->termios)) { 175 dbg("%s - no tty structures", __FUNCTION__); 176 return; 177 } 178 179 spin_lock_irqsave(&priv->lock, flags); 180 if (!priv->termios_initialized) { 181 *(port->tty->termios) = tty_std_termios; 182 port->tty->termios->c_cflag = B9600 | CS8 183 | CREAD | HUPCL | CLOCAL; 184 priv->termios_initialized = 1; 185 } 186 spin_unlock_irqrestore(&priv->lock, flags); 187 188 cflag = port->tty->termios->c_cflag; 189 190 /* check that they really want us to change something: */ 191 if (old_termios) { 192 if ((cflag == old_termios->c_cflag) && 193 (RELEVANT_IFLAG(port->tty->termios->c_iflag) == 194 RELEVANT_IFLAG(old_termios->c_iflag))) { 195 dbg("%s - nothing to change...", __FUNCTION__); 196 return; 197 } 198 } 199 200 buf = kmalloc(1, GFP_KERNEL); 201 if (!buf) { 202 dbg("error kmalloc"); 203 return; 204 } 205 206 /* set data bit count (8/7/6/5) */ 207 if (cflag & CSIZE) { 208 switch (cflag & CSIZE) { 209 case CS5: 210 config |= 0x00; 211 dbg("setting CS5"); 212 break; 213 case CS6: 214 config |= 0x01; 215 dbg("setting CS6"); 216 break; 217 case CS7: 218 config |= 0x02; 219 dbg("setting CS7"); 220 break; 221 default: 222 err("CSIZE was set but not CS5-CS8, using CS8!"); 223 /* fall through */ 224 case CS8: 225 config |= 0x03; 226 dbg("setting CS8"); 227 break; 228 } 229 } 230 231 /* set parity (NONE/EVEN/ODD) */ 232 if (cflag & PARENB) { 233 if (cflag & PARODD) { 234 config |= 0x08; 235 dbg("setting parity to ODD"); 236 } else { 237 config |= 0x18; 238 dbg("setting parity to EVEN"); 239 } 240 } else { 241 dbg("setting parity to NONE"); 242 } 243 244 /* set stop bit (1/2) */ 245 if (cflag & CSTOPB) { 246 config |= 0x04; 247 dbg("setting 2 stop bits"); 248 } else { 249 dbg("setting 1 stop bit"); 250 } 251 252 /* set baudrate */ 253 baud = 0; 254 switch (cflag & CBAUD) { 255 case B0: 256 err("can't set 0 baud, using 9600 instead"); 257 break; 258 case B75: baud = 75; break; 259 case B150: baud = 150; break; 260 case B300: baud = 300; break; 261 case B600: baud = 600; break; 262 case B1200: baud = 1200; break; 263 case B1800: baud = 1800; break; 264 case B2400: baud = 2400; break; 265 case B4800: baud = 4800; break; 266 case B9600: baud = 9600; break; 267 case B19200: baud = 19200; break; 268 case B38400: baud = 38400; break; 269 case B57600: baud = 57600; break; 270 case B115200: baud = 115200; break; 271 case B230400: baud = 230400; break; 272 case B460800: baud = 460800; break; 273 default: 274 dbg("does not support the baudrate requested (fix it)"); 275 break; 276 } 277 278 /* set 9600 as default (if given baudrate is invalid for example) */ 279 if (baud == 0) 280 baud = 9600; 281 282 /* 283 * found by try'n'error, be careful, maybe there are other options 284 * for multiplicator etc! 285 */ 286 if (baud == 460800) 287 /* strange, for 460800 the formula is wrong 288 * if using round() then 9600baud is wrong) */ 289 ark3116_baud = 7; 290 else 291 ark3116_baud = 3000000 / baud; 292 293 /* ? */ 294 ARK3116_RCV(serial, 0, 0xFE, 0xC0, 0x0000, 0x0003, 0x03, buf); 295 296 /* offset = buf[0]; */ 297 /* offset = 0x03; */ 298 /* dbg("using 0x%04X as target for 0x0003:", 0x0080 + offset); */ 299 300 /* set baudrate */ 301 dbg("setting baudrate to %d (->reg=%d)", baud, ark3116_baud); 302 ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003); 303 ARK3116_SND(serial, 148, 0xFE, 0x40, 304 (ark3116_baud & 0x00FF), 0x0000); 305 ARK3116_SND(serial, 149, 0xFE, 0x40, 306 (ark3116_baud & 0xFF00) >> 8, 0x0001); 307 ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003); 308 309 /* ? */ 310 ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf); 311 ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003); 312 313 /* set data bit count, stop bit count & parity: */ 314 dbg("updating bit count, stop bit or parity (cfg=0x%02X)", config); 315 ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf); 316 ARK3116_SND(serial, 154, 0xFE, 0x40, config, 0x0003); 317 318 if (cflag & CRTSCTS) 319 dbg("CRTSCTS not supported by chipset?!"); 320 321 /* TEST ARK3116_SND(154, 0xFE, 0x40, 0xFFFF, 0x0006); */ 322 323 kfree(buf); 324 return; 325 } 326 327 static int ark3116_open(struct usb_serial_port *port, struct file *filp) 328 { 329 struct ktermios tmp_termios; 330 struct usb_serial *serial = port->serial; 331 char *buf; 332 int result = 0; 333 334 dbg("%s - port %d", __FUNCTION__, port->number); 335 336 buf = kmalloc(1, GFP_KERNEL); 337 if (!buf) { 338 dbg("error kmalloc -> out of mem?"); 339 return -ENOMEM; 340 } 341 342 result = usb_serial_generic_open(port, filp); 343 if (result) 344 return result; 345 346 /* open */ 347 ARK3116_RCV(serial, 111, 0xFE, 0xC0, 0x0000, 0x0003, 0x02, buf); 348 349 ARK3116_SND(serial, 112, 0xFE, 0x40, 0x0082, 0x0003); 350 ARK3116_SND(serial, 113, 0xFE, 0x40, 0x001A, 0x0000); 351 ARK3116_SND(serial, 114, 0xFE, 0x40, 0x0000, 0x0001); 352 ARK3116_SND(serial, 115, 0xFE, 0x40, 0x0002, 0x0003); 353 354 ARK3116_RCV(serial, 116, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf); 355 ARK3116_SND(serial, 117, 0xFE, 0x40, 0x0002, 0x0004); 356 357 ARK3116_RCV(serial, 118, 0xFE, 0xC0, 0x0000, 0x0004, 0x02, buf); 358 ARK3116_SND(serial, 119, 0xFE, 0x40, 0x0000, 0x0004); 359 360 ARK3116_RCV(serial, 120, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf); 361 362 ARK3116_SND(serial, 121, 0xFE, 0x40, 0x0001, 0x0004); 363 364 ARK3116_RCV(serial, 122, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf); 365 366 ARK3116_SND(serial, 123, 0xFE, 0x40, 0x0003, 0x0004); 367 368 /* returns different values (control lines?!) */ 369 ARK3116_RCV(serial, 124, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf); 370 371 /* initialise termios */ 372 if (port->tty) 373 ark3116_set_termios(port, &tmp_termios); 374 375 kfree(buf); 376 377 return result; 378 } 379 380 static int ark3116_ioctl(struct usb_serial_port *port, struct file *file, 381 unsigned int cmd, unsigned long arg) 382 { 383 struct serial_struct serstruct; 384 void __user *user_arg = (void __user *)arg; 385 386 switch (cmd) { 387 case TIOCGSERIAL: 388 /* XXX: Some of these values are probably wrong. */ 389 memset(&serstruct, 0, sizeof (serstruct)); 390 serstruct.type = PORT_16654; 391 serstruct.line = port->serial->minor; 392 serstruct.port = port->number; 393 serstruct.custom_divisor = 0; 394 serstruct.baud_base = 460800; 395 396 if (copy_to_user(user_arg, &serstruct, sizeof (serstruct))) 397 return -EFAULT; 398 399 return 0; 400 case TIOCSSERIAL: 401 if (copy_from_user(&serstruct, user_arg, sizeof (serstruct))) 402 return -EFAULT; 403 return 0; 404 default: 405 dbg("%s cmd 0x%04x not supported", __FUNCTION__, cmd); 406 break; 407 } 408 409 return -ENOIOCTLCMD; 410 } 411 412 static int ark3116_tiocmget(struct usb_serial_port *port, struct file *file) 413 { 414 struct usb_serial *serial = port->serial; 415 char *buf; 416 char temp; 417 418 /* seems like serial port status info (RTS, CTS, ...) is stored 419 * in reg(?) 0x0006 420 * pcb connection point 11 = GND -> sets bit4 of response 421 * pcb connection point 7 = GND -> sets bit6 of response 422 */ 423 424 buf = kmalloc(1, GFP_KERNEL); 425 if (!buf) { 426 dbg("error kmalloc"); 427 return -ENOMEM; 428 } 429 430 /* read register */ 431 ARK3116_RCV_QUIET(serial, 0xFE, 0xC0, 0x0000, 0x0006, buf); 432 temp = buf[0]; 433 kfree(buf); 434 435 /* i do not really know if bit4=CTS and bit6=DSR... just a 436 * quick guess! 437 */ 438 return (temp & (1<<4) ? TIOCM_CTS : 0) 439 | (temp & (1<<6) ? TIOCM_DSR : 0); 440 } 441 442 static struct usb_driver ark3116_driver = { 443 .name = "ark3116", 444 .probe = usb_serial_probe, 445 .disconnect = usb_serial_disconnect, 446 .id_table = id_table, 447 .no_dynamic_id = 1, 448 }; 449 450 static struct usb_serial_driver ark3116_device = { 451 .driver = { 452 .owner = THIS_MODULE, 453 .name = "ark3116", 454 }, 455 .id_table = id_table, 456 .usb_driver = &ark3116_driver, 457 .num_interrupt_in = 1, 458 .num_bulk_in = 1, 459 .num_bulk_out = 1, 460 .num_ports = 1, 461 .attach = ark3116_attach, 462 .set_termios = ark3116_set_termios, 463 .ioctl = ark3116_ioctl, 464 .tiocmget = ark3116_tiocmget, 465 .open = ark3116_open, 466 }; 467 468 static int __init ark3116_init(void) 469 { 470 int retval; 471 472 retval = usb_serial_register(&ark3116_device); 473 if (retval) 474 return retval; 475 retval = usb_register(&ark3116_driver); 476 if (retval) 477 usb_serial_deregister(&ark3116_device); 478 return retval; 479 } 480 481 static void __exit ark3116_exit(void) 482 { 483 usb_deregister(&ark3116_driver); 484 usb_serial_deregister(&ark3116_device); 485 } 486 487 module_init(ark3116_init); 488 module_exit(ark3116_exit); 489 MODULE_LICENSE("GPL"); 490 491 module_param(debug, bool, S_IRUGO | S_IWUSR); 492 MODULE_PARM_DESC(debug, "Debug enabled or not"); 493 494