ark3116.c 11.5 KB
Newer Older
1
/*
2 3 4
 * Copyright (C) 2006
 *   Simon Schulz (ark3116_driver <at> auctionant.de)
 *
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 * ark3116
 * - implements a driver for the arkmicro ark3116 chipset (vendor=0x6547,
 *   productid=0x0232) (used in a datacable called KQ-U8A)
 *
 * - based on code by krisfx -> thanks !!
 *   (see http://www.linuxquestions.org/questions/showthread.php?p=2184457#post2184457)
 *
 *  - based on logs created by usbsnoopy
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/tty.h>
#include <linux/module.h>
#include <linux/usb.h>
25
#include <linux/usb/serial.h>
26
#include <linux/serial.h>
Alan Cox's avatar
Alan Cox committed
27
#include <linux/uaccess.h>
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


static int debug;

static struct usb_device_id id_table [] = {
	{ USB_DEVICE(0x6547, 0x0232) },
	{ },
};
MODULE_DEVICE_TABLE(usb, id_table);

static inline void ARK3116_SND(struct usb_serial *serial, int seq,
			       __u8 request, __u8 requesttype,
			       __u16 value, __u16 index)
{
	int result;
	result = usb_control_msg(serial->dev,
44
				 usb_sndctrlpipe(serial->dev, 0),
45
				 request, requesttype, value, index,
46 47
				 NULL, 0x00, 1000);
	dbg("%03d > ok", seq);
48 49 50 51 52 53 54 55 56
}

static inline void ARK3116_RCV(struct usb_serial *serial, int seq,
			       __u8 request, __u8 requesttype,
			       __u16 value, __u16 index, __u8 expected,
			       char *buf)
{
	int result;
	result = usb_control_msg(serial->dev,
57 58 59
				 usb_rcvctrlpipe(serial->dev, 0),
				 request, requesttype, value, index,
				 buf, 0x0000001, 1000);
60
	if (result)
61 62
		dbg("%03d < %d bytes [0x%02X]", seq, result,
		    ((unsigned char *)buf)[0]);
63 64 65 66 67 68 69 70 71
	else
		dbg("%03d < 0 bytes", seq);
}

static inline void ARK3116_RCV_QUIET(struct usb_serial *serial,
				     __u8 request, __u8 requesttype,
				     __u16 value, __u16 index, char *buf)
{
	usb_control_msg(serial->dev,
72
			usb_rcvctrlpipe(serial->dev, 0),
73 74 75 76 77 78 79 80 81 82
			request, requesttype, value, index,
			buf, 0x0000001, 1000);
}

static int ark3116_attach(struct usb_serial *serial)
{
	char *buf;

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf) {
83
		dbg("error kmalloc -> out of mem?");
Alan Cox's avatar
Alan Cox committed
84
		return -ENOMEM;
85 86 87
	}

	/* 3 */
88 89 90 91
	ARK3116_SND(serial, 3, 0xFE, 0x40, 0x0008, 0x0002);
	ARK3116_SND(serial, 4, 0xFE, 0x40, 0x0008, 0x0001);
	ARK3116_SND(serial, 5, 0xFE, 0x40, 0x0000, 0x0008);
	ARK3116_SND(serial, 6, 0xFE, 0x40, 0x0000, 0x000B);
92 93

	/* <-- seq7 */
94 95 96 97 98
	ARK3116_RCV(serial,  7, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
	ARK3116_SND(serial,  8, 0xFE, 0x40, 0x0080, 0x0003);
	ARK3116_SND(serial,  9, 0xFE, 0x40, 0x001A, 0x0000);
	ARK3116_SND(serial, 10, 0xFE, 0x40, 0x0000, 0x0001);
	ARK3116_SND(serial, 11, 0xFE, 0x40, 0x0000, 0x0003);
99 100

	/* <-- seq12 */
101 102
	ARK3116_RCV(serial, 12, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
	ARK3116_SND(serial, 13, 0xFE, 0x40, 0x0000, 0x0004);
103 104

	/* 14 */
105 106
	ARK3116_RCV(serial, 14, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
	ARK3116_SND(serial, 15, 0xFE, 0x40, 0x0000, 0x0004);
107 108

	/* 16 */
109
	ARK3116_RCV(serial, 16, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
110
	/* --> seq17 */
111
	ARK3116_SND(serial, 17, 0xFE, 0x40, 0x0001, 0x0004);
112 113

	/* <-- seq18 */
114
	ARK3116_RCV(serial, 18, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf);
115 116

	/* --> seq19 */
117
	ARK3116_SND(serial, 19, 0xFE, 0x40, 0x0003, 0x0004);
118 119

	/* <-- seq20 */
120 121 122 123 124 125 126 127 128 129 130 131 132
	/* seems like serial port status info (RTS, CTS, ...) */
	/* returns modem control line status?! */
	ARK3116_RCV(serial, 20, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);

	/* set 9600 baud & do some init?! */
	ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003);
	ARK3116_SND(serial, 148, 0xFE, 0x40, 0x0038, 0x0000);
	ARK3116_SND(serial, 149, 0xFE, 0x40, 0x0001, 0x0001);
	ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003);
	ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
	ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
	ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
	ARK3116_SND(serial, 154, 0xFE, 0x40, 0x0003, 0x0003);
133 134

	kfree(buf);
135
	return 0;
Alan Cox's avatar
Alan Cox committed
136
}
137

Alan Cox's avatar
Alan Cox committed
138 139 140 141 142 143 144 145
static void ark3116_init_termios(struct tty_struct *tty)
{
	struct ktermios *termios = tty->termios;
	*termios = tty_std_termios;
	termios->c_cflag = B9600 | CS8
				      | CREAD | HUPCL | CLOCAL;
	termios->c_ispeed = 9600;
	termios->c_ospeed = 9600;
146 147
}

Alan Cox's avatar
Alan Cox committed
148 149
static void ark3116_set_termios(struct tty_struct *tty,
				struct usb_serial_port *port,
Alan Cox's avatar
Alan Cox committed
150
				struct ktermios *old_termios)
151 152
{
	struct usb_serial *serial = port->serial;
Alan Cox's avatar
Alan Cox committed
153
	struct ktermios *termios = tty->termios;
154
	unsigned int cflag = termios->c_cflag;
155 156 157 158 159 160 161
	int baud;
	int ark3116_baud;
	char *buf;
	char config;

	config = 0;

162
	dbg("%s - port %d", __func__, port->number);
163 164


165 166
	cflag = termios->c_cflag;
	termios->c_cflag &= ~(CMSPAR|CRTSCTS);
167 168 169 170

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf) {
		dbg("error kmalloc");
Alan Cox's avatar
Alan Cox committed
171
		*termios = *old_termios;
172 173 174 175
		return;
	}

	/* set data bit count (8/7/6/5) */
176 177
	if (cflag & CSIZE) {
		switch (cflag & CSIZE) {
178 179 180 181 182 183 184 185 186 187 188 189 190
		case CS5:
			config |= 0x00;
			dbg("setting CS5");
			break;
		case CS6:
			config |= 0x01;
			dbg("setting CS6");
			break;
		case CS7:
			config |= 0x02;
			dbg("setting CS7");
			break;
		default:
191
			dbg("CSIZE was set but not CS5-CS8, using CS8!");
192
			/* fall through */
193 194 195 196 197 198 199
		case CS8:
			config |= 0x03;
			dbg("setting CS8");
			break;
		}
	}

200 201
	/* set parity (NONE/EVEN/ODD) */
	if (cflag & PARENB) {
202 203 204 205 206 207 208 209 210 211 212
		if (cflag & PARODD) {
			config |= 0x08;
			dbg("setting parity to ODD");
		} else {
			config |= 0x18;
			dbg("setting parity to EVEN");
		}
	} else {
		dbg("setting parity to NONE");
	}

213
	/* set stop bit (1/2) */
214 215
	if (cflag & CSTOPB) {
		config |= 0x04;
216
		dbg("setting 2 stop bits");
217
	} else {
218
		dbg("setting 1 stop bit");
219 220
	}

221
	/* set baudrate */
Alan Cox's avatar
Alan Cox committed
222
	baud = tty_get_baud_rate(tty);
223 224

	switch (baud) {
Alan Cox's avatar
Alan Cox committed
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
	case 75:
	case 150:
	case 300:
	case 600:
	case 1200:
	case 1800:
	case 2400:
	case 4800:
	case 9600:
	case 19200:
	case 38400:
	case 57600:
	case 115200:
	case 230400:
	case 460800:
		/* Report the resulting rate back to the caller */
Alan Cox's avatar
Alan Cox committed
241
		tty_encode_baud_rate(tty, baud, baud);
Alan Cox's avatar
Alan Cox committed
242 243 244
		break;
	/* set 9600 as default (if given baudrate is invalid for example) */
	default:
Alan Cox's avatar
Alan Cox committed
245
		tty_encode_baud_rate(tty, 9600, 9600);
Alan Cox's avatar
Alan Cox committed
246 247
	case 0:
		baud = 9600;
248 249 250 251
	}

	/*
	 * found by try'n'error, be careful, maybe there are other options
252
	 * for multiplicator etc! (3.5 for example)
253 254 255
	 */
	if (baud == 460800)
		/* strange, for 460800 the formula is wrong
256
		 * if using round() then 9600baud is wrong) */
257 258 259 260 261
		ark3116_baud = 7;
	else
		ark3116_baud = 3000000 / baud;

	/* ? */
262 263
	ARK3116_RCV(serial, 0, 0xFE, 0xC0, 0x0000, 0x0003, 0x03, buf);

264 265
	/* offset = buf[0]; */
	/* offset = 0x03; */
266
	/* dbg("using 0x%04X as target for 0x0003:", 0x0080 + offset); */
267 268

	/* set baudrate */
269 270 271 272 273 274 275
	dbg("setting baudrate to %d (->reg=%d)", baud, ark3116_baud);
	ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003);
	ARK3116_SND(serial, 148, 0xFE, 0x40,
			    (ark3116_baud & 0x00FF), 0x0000);
	ARK3116_SND(serial, 149, 0xFE, 0x40,
			    (ark3116_baud & 0xFF00) >> 8, 0x0001);
	ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003);
276 277

	/* ? */
278 279
	ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
	ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
280 281 282

	/* set data bit count, stop bit count & parity: */
	dbg("updating bit count, stop bit or parity (cfg=0x%02X)", config);
283 284
	ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
	ARK3116_SND(serial, 154, 0xFE, 0x40, config, 0x0003);
285 286

	if (cflag & CRTSCTS)
287
		dbg("CRTSCTS not supported by chipset?!");
288

289
	/* TEST ARK3116_SND(154, 0xFE, 0x40, 0xFFFF, 0x0006); */
290 291

	kfree(buf);
292

293 294 295
	return;
}

296
static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
297
{
Alan Cox's avatar
Alan Cox committed
298
	struct ktermios tmp_termios;
299 300 301 302
	struct usb_serial *serial = port->serial;
	char *buf;
	int result = 0;

303
	dbg("%s - port %d", __func__, port->number);
304 305 306

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf) {
307
		dbg("error kmalloc -> out of mem?");
308 309 310
		return -ENOMEM;
	}

311
	result = usb_serial_generic_open(tty, port);
312
	if (result)
Oliver Neukum's avatar
Oliver Neukum committed
313
		goto err_out;
314 315

	/* open */
316
	ARK3116_RCV(serial, 111, 0xFE, 0xC0, 0x0000, 0x0003, 0x02, buf);
317

318 319 320 321
	ARK3116_SND(serial, 112, 0xFE, 0x40, 0x0082, 0x0003);
	ARK3116_SND(serial, 113, 0xFE, 0x40, 0x001A, 0x0000);
	ARK3116_SND(serial, 114, 0xFE, 0x40, 0x0000, 0x0001);
	ARK3116_SND(serial, 115, 0xFE, 0x40, 0x0002, 0x0003);
322

323 324
	ARK3116_RCV(serial, 116, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
	ARK3116_SND(serial, 117, 0xFE, 0x40, 0x0002, 0x0004);
325

326 327
	ARK3116_RCV(serial, 118, 0xFE, 0xC0, 0x0000, 0x0004, 0x02, buf);
	ARK3116_SND(serial, 119, 0xFE, 0x40, 0x0000, 0x0004);
328

329
	ARK3116_RCV(serial, 120, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
330

331
	ARK3116_SND(serial, 121, 0xFE, 0x40, 0x0001, 0x0004);
332

333
	ARK3116_RCV(serial, 122, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf);
334

335
	ARK3116_SND(serial, 123, 0xFE, 0x40, 0x0003, 0x0004);
336

337 338
	/* returns different values (control lines?!) */
	ARK3116_RCV(serial, 124, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);
339

340
	/* initialise termios */
Alan Cox's avatar
Alan Cox committed
341 342
	if (tty)
		ark3116_set_termios(tty, port, &tmp_termios);
343

Oliver Neukum's avatar
Oliver Neukum committed
344
err_out:
345 346 347 348 349
	kfree(buf);

	return result;
}

Alan Cox's avatar
Alan Cox committed
350
static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
351 352
			 unsigned int cmd, unsigned long arg)
{
Alan Cox's avatar
Alan Cox committed
353
	struct usb_serial_port *port = tty->driver_data;
354 355 356 357 358 359
	struct serial_struct serstruct;
	void __user *user_arg = (void __user *)arg;

	switch (cmd) {
	case TIOCGSERIAL:
		/* XXX: Some of these values are probably wrong. */
Alan Cox's avatar
Alan Cox committed
360
		memset(&serstruct, 0, sizeof(serstruct));
361 362 363 364 365 366
		serstruct.type = PORT_16654;
		serstruct.line = port->serial->minor;
		serstruct.port = port->number;
		serstruct.custom_divisor = 0;
		serstruct.baud_base = 460800;

Alan Cox's avatar
Alan Cox committed
367
		if (copy_to_user(user_arg, &serstruct, sizeof(serstruct)))
368 369 370 371
			return -EFAULT;

		return 0;
	case TIOCSSERIAL:
Alan Cox's avatar
Alan Cox committed
372
		if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
373 374 375
			return -EFAULT;
		return 0;
	default:
376
		dbg("%s cmd 0x%04x not supported", __func__, cmd);
377 378 379
		break;
	}

380 381 382
	return -ENOIOCTLCMD;
}

Alan Cox's avatar
Alan Cox committed
383
static int ark3116_tiocmget(struct tty_struct *tty, struct file *file)
384
{
Alan Cox's avatar
Alan Cox committed
385
	struct usb_serial_port *port = tty->driver_data;
386 387 388 389
	struct usb_serial *serial = port->serial;
	char *buf;
	char temp;

390
	/* seems like serial port status info (RTS, CTS, ...) is stored
391 392 393 394 395 396 397 398 399 400 401
	 * in reg(?) 0x0006
	 * pcb connection point 11 = GND -> sets bit4 of response
	 * pcb connection point  7 = GND -> sets bit6 of response
	 */

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf) {
		dbg("error kmalloc");
		return -ENOMEM;
	}

402 403
	/* read register */
	ARK3116_RCV_QUIET(serial, 0xFE, 0xC0, 0x0000, 0x0006, buf);
404 405 406
	temp = buf[0];
	kfree(buf);

407 408
	/* i do not really know if bit4=CTS and bit6=DSR... just a
	 * quick guess!
409
	 */
410 411
	return (temp & (1<<4) ? TIOCM_CTS : 0)
	       | (temp & (1<<6) ? TIOCM_DSR : 0);
412 413 414 415 416 417 418
}

static struct usb_driver ark3116_driver = {
	.name =		"ark3116",
	.probe =	usb_serial_probe,
	.disconnect =	usb_serial_disconnect,
	.id_table =	id_table,
419
	.no_dynamic_id =	1,
420 421 422 423 424 425 426 427
};

static struct usb_serial_driver ark3116_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"ark3116",
	},
	.id_table =		id_table,
428
	.usb_driver =		&ark3116_driver,
429 430 431
	.num_ports =		1,
	.attach =		ark3116_attach,
	.set_termios =		ark3116_set_termios,
Alan Cox's avatar
Alan Cox committed
432
	.init_termios =		ark3116_init_termios,
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
	.ioctl =		ark3116_ioctl,
	.tiocmget =		ark3116_tiocmget,
	.open =			ark3116_open,
};

static int __init ark3116_init(void)
{
	int retval;

	retval = usb_serial_register(&ark3116_device);
	if (retval)
		return retval;
	retval = usb_register(&ark3116_driver);
	if (retval)
		usb_serial_deregister(&ark3116_device);
	return retval;
}

static void __exit ark3116_exit(void)
{
	usb_deregister(&ark3116_driver);
	usb_serial_deregister(&ark3116_device);
}

module_init(ark3116_init);
module_exit(ark3116_exit);
MODULE_LICENSE("GPL");

module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled or not");