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