1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * Copyright (C) 2009 by Bart Hartgers (bart.hartgers+ark3116@gmail.com) |
4 | * Original version: |
5 | * Copyright (C) 2006 |
6 | * Simon Schulz (ark3116_driver <at> auctionant.de) |
7 | * |
8 | * ark3116 |
9 | * - implements a driver for the arkmicro ark3116 chipset (vendor=0x6547, |
10 | * productid=0x0232) (used in a datacable called KQ-U8A) |
11 | * |
12 | * Supports full modem status lines, break, hardware flow control. Does not |
13 | * support software flow control, since I do not know how to enable it in hw. |
14 | * |
15 | * This driver is a essentially new implementation. I initially dug |
16 | * into the old ark3116.c driver and suddenly realized the ark3116 is |
17 | * a 16450 with a USB interface glued to it. See comments at the |
18 | * bottom of this file. |
19 | */ |
20 | |
21 | #include <linux/kernel.h> |
22 | #include <linux/ioctl.h> |
23 | #include <linux/tty.h> |
24 | #include <linux/slab.h> |
25 | #include <linux/tty_flip.h> |
26 | #include <linux/module.h> |
27 | #include <linux/usb.h> |
28 | #include <linux/usb/serial.h> |
29 | #include <linux/serial.h> |
30 | #include <linux/serial_reg.h> |
31 | #include <linux/uaccess.h> |
32 | #include <linux/mutex.h> |
33 | #include <linux/spinlock.h> |
34 | |
35 | #define DRIVER_AUTHOR "Bart Hartgers <bart.hartgers+ark3116@gmail.com>" |
36 | #define DRIVER_DESC "USB ARK3116 serial/IrDA driver" |
37 | #define DRIVER_DEV_DESC "ARK3116 RS232/IrDA" |
38 | #define DRIVER_NAME "ark3116" |
39 | |
40 | /* usb timeout of 1 second */ |
41 | #define ARK_TIMEOUT 1000 |
42 | |
43 | static const struct usb_device_id id_table[] = { |
44 | { USB_DEVICE(0x6547, 0x0232) }, |
45 | { USB_DEVICE(0x18ec, 0x3118) }, /* USB to IrDA adapter */ |
46 | { }, |
47 | }; |
48 | MODULE_DEVICE_TABLE(usb, id_table); |
49 | |
50 | static int is_irda(struct usb_serial *serial) |
51 | { |
52 | struct usb_device *dev = serial->dev; |
53 | if (le16_to_cpu(dev->descriptor.idVendor) == 0x18ec && |
54 | le16_to_cpu(dev->descriptor.idProduct) == 0x3118) |
55 | return 1; |
56 | return 0; |
57 | } |
58 | |
59 | struct ark3116_private { |
60 | int irda; /* 1 for irda device */ |
61 | |
62 | /* protects hw register updates */ |
63 | struct mutex hw_lock; |
64 | |
65 | int quot; /* baudrate divisor */ |
66 | __u32 lcr; /* line control register value */ |
67 | __u32 hcr; /* handshake control register (0x8) |
68 | * value */ |
69 | __u32 mcr; /* modem control register value */ |
70 | |
71 | /* protects the status values below */ |
72 | spinlock_t status_lock; |
73 | __u32 msr; /* modem status register value */ |
74 | __u32 lsr; /* line status register value */ |
75 | }; |
76 | |
77 | static int ark3116_write_reg(struct usb_serial *serial, |
78 | unsigned reg, __u8 val) |
79 | { |
80 | int result; |
81 | /* 0xfe 0x40 are magic values taken from original driver */ |
82 | result = usb_control_msg(dev: serial->dev, |
83 | usb_sndctrlpipe(serial->dev, 0), |
84 | request: 0xfe, requesttype: 0x40, value: val, index: reg, |
85 | NULL, size: 0, ARK_TIMEOUT); |
86 | if (result) |
87 | return result; |
88 | |
89 | return 0; |
90 | } |
91 | |
92 | static int ark3116_read_reg(struct usb_serial *serial, |
93 | unsigned reg, unsigned char *buf) |
94 | { |
95 | int result; |
96 | /* 0xfe 0xc0 are magic values taken from original driver */ |
97 | result = usb_control_msg(dev: serial->dev, |
98 | usb_rcvctrlpipe(serial->dev, 0), |
99 | request: 0xfe, requesttype: 0xc0, value: 0, index: reg, |
100 | data: buf, size: 1, ARK_TIMEOUT); |
101 | if (result < 1) { |
102 | dev_err(&serial->interface->dev, |
103 | "failed to read register %u: %d\n" , |
104 | reg, result); |
105 | if (result >= 0) |
106 | result = -EIO; |
107 | |
108 | return result; |
109 | } |
110 | |
111 | return 0; |
112 | } |
113 | |
114 | static inline int calc_divisor(int bps) |
115 | { |
116 | /* Original ark3116 made some exceptions in rounding here |
117 | * because windows did the same. Assume that is not really |
118 | * necessary. |
119 | * Crystal is 12MHz, probably because of USB, but we divide by 4? |
120 | */ |
121 | return (12000000 + 2*bps) / (4*bps); |
122 | } |
123 | |
124 | static int ark3116_port_probe(struct usb_serial_port *port) |
125 | { |
126 | struct usb_serial *serial = port->serial; |
127 | struct ark3116_private *priv; |
128 | |
129 | priv = kzalloc(size: sizeof(*priv), GFP_KERNEL); |
130 | if (!priv) |
131 | return -ENOMEM; |
132 | |
133 | mutex_init(&priv->hw_lock); |
134 | spin_lock_init(&priv->status_lock); |
135 | |
136 | priv->irda = is_irda(serial); |
137 | |
138 | usb_set_serial_port_data(port, data: priv); |
139 | |
140 | /* setup the hardware */ |
141 | ark3116_write_reg(serial, UART_IER, val: 0); |
142 | /* disable DMA */ |
143 | ark3116_write_reg(serial, UART_FCR, val: 0); |
144 | /* handshake control */ |
145 | priv->hcr = 0; |
146 | ark3116_write_reg(serial, reg: 0x8 , val: 0); |
147 | /* modem control */ |
148 | priv->mcr = 0; |
149 | ark3116_write_reg(serial, UART_MCR, val: 0); |
150 | |
151 | if (!(priv->irda)) { |
152 | ark3116_write_reg(serial, reg: 0xb , val: 0); |
153 | } else { |
154 | ark3116_write_reg(serial, reg: 0xb , val: 1); |
155 | ark3116_write_reg(serial, reg: 0xc , val: 0); |
156 | ark3116_write_reg(serial, reg: 0xd , val: 0x41); |
157 | ark3116_write_reg(serial, reg: 0xa , val: 1); |
158 | } |
159 | |
160 | /* setup baudrate */ |
161 | ark3116_write_reg(serial, UART_LCR, UART_LCR_DLAB); |
162 | |
163 | /* setup for 9600 8N1 */ |
164 | priv->quot = calc_divisor(bps: 9600); |
165 | ark3116_write_reg(serial, UART_DLL, val: priv->quot & 0xff); |
166 | ark3116_write_reg(serial, UART_DLM, val: (priv->quot>>8) & 0xff); |
167 | |
168 | priv->lcr = UART_LCR_WLEN8; |
169 | ark3116_write_reg(serial, UART_LCR, UART_LCR_WLEN8); |
170 | |
171 | ark3116_write_reg(serial, reg: 0xe, val: 0); |
172 | |
173 | if (priv->irda) |
174 | ark3116_write_reg(serial, reg: 0x9, val: 0); |
175 | |
176 | dev_info(&port->dev, "using %s mode\n" , priv->irda ? "IrDA" : "RS232" ); |
177 | |
178 | return 0; |
179 | } |
180 | |
181 | static void ark3116_port_remove(struct usb_serial_port *port) |
182 | { |
183 | struct ark3116_private *priv = usb_get_serial_port_data(port); |
184 | |
185 | /* device is closed, so URBs and DMA should be down */ |
186 | mutex_destroy(lock: &priv->hw_lock); |
187 | kfree(objp: priv); |
188 | } |
189 | |
190 | static void ark3116_set_termios(struct tty_struct *tty, |
191 | struct usb_serial_port *port, |
192 | const struct ktermios *old_termios) |
193 | { |
194 | struct usb_serial *serial = port->serial; |
195 | struct ark3116_private *priv = usb_get_serial_port_data(port); |
196 | struct ktermios *termios = &tty->termios; |
197 | unsigned int cflag = termios->c_cflag; |
198 | int bps = tty_get_baud_rate(tty); |
199 | int quot; |
200 | __u8 lcr, hcr, eval; |
201 | |
202 | /* set data bit count */ |
203 | lcr = UART_LCR_WLEN(tty_get_char_size(cflag)); |
204 | |
205 | if (cflag & CSTOPB) |
206 | lcr |= UART_LCR_STOP; |
207 | if (cflag & PARENB) |
208 | lcr |= UART_LCR_PARITY; |
209 | if (!(cflag & PARODD)) |
210 | lcr |= UART_LCR_EPAR; |
211 | if (cflag & CMSPAR) |
212 | lcr |= UART_LCR_SPAR; |
213 | |
214 | /* handshake control */ |
215 | hcr = (cflag & CRTSCTS) ? 0x03 : 0x00; |
216 | |
217 | /* calc baudrate */ |
218 | dev_dbg(&port->dev, "%s - setting bps to %d\n" , __func__, bps); |
219 | eval = 0; |
220 | switch (bps) { |
221 | case 0: |
222 | quot = calc_divisor(bps: 9600); |
223 | break; |
224 | default: |
225 | if ((bps < 75) || (bps > 3000000)) |
226 | bps = 9600; |
227 | quot = calc_divisor(bps); |
228 | break; |
229 | case 460800: |
230 | eval = 1; |
231 | quot = calc_divisor(bps); |
232 | break; |
233 | case 921600: |
234 | eval = 2; |
235 | quot = calc_divisor(bps); |
236 | break; |
237 | } |
238 | |
239 | /* Update state: synchronize */ |
240 | mutex_lock(&priv->hw_lock); |
241 | |
242 | /* keep old LCR_SBC bit */ |
243 | lcr |= (priv->lcr & UART_LCR_SBC); |
244 | |
245 | dev_dbg(&port->dev, "%s - setting hcr:0x%02x,lcr:0x%02x,quot:%d\n" , |
246 | __func__, hcr, lcr, quot); |
247 | |
248 | /* handshake control */ |
249 | if (priv->hcr != hcr) { |
250 | priv->hcr = hcr; |
251 | ark3116_write_reg(serial, reg: 0x8, val: hcr); |
252 | } |
253 | |
254 | /* baudrate */ |
255 | if (priv->quot != quot) { |
256 | priv->quot = quot; |
257 | priv->lcr = lcr; /* need to write lcr anyway */ |
258 | |
259 | /* disable DMA since transmit/receive is |
260 | * shadowed by UART_DLL |
261 | */ |
262 | ark3116_write_reg(serial, UART_FCR, val: 0); |
263 | |
264 | ark3116_write_reg(serial, UART_LCR, |
265 | val: lcr|UART_LCR_DLAB); |
266 | ark3116_write_reg(serial, UART_DLL, val: quot & 0xff); |
267 | ark3116_write_reg(serial, UART_DLM, val: (quot>>8) & 0xff); |
268 | |
269 | /* restore lcr */ |
270 | ark3116_write_reg(serial, UART_LCR, val: lcr); |
271 | /* magic baudrate thingy: not sure what it does, |
272 | * but windows does this as well. |
273 | */ |
274 | ark3116_write_reg(serial, reg: 0xe, val: eval); |
275 | |
276 | /* enable DMA */ |
277 | ark3116_write_reg(serial, UART_FCR, UART_FCR_DMA_SELECT); |
278 | } else if (priv->lcr != lcr) { |
279 | priv->lcr = lcr; |
280 | ark3116_write_reg(serial, UART_LCR, val: lcr); |
281 | } |
282 | |
283 | mutex_unlock(lock: &priv->hw_lock); |
284 | |
285 | /* check for software flow control */ |
286 | if (I_IXOFF(tty) || I_IXON(tty)) { |
287 | dev_warn(&port->dev, |
288 | "software flow control not implemented\n" ); |
289 | } |
290 | |
291 | /* Don't rewrite B0 */ |
292 | if (tty_termios_baud_rate(termios)) |
293 | tty_termios_encode_baud_rate(termios, ibaud: bps, obaud: bps); |
294 | } |
295 | |
296 | static void ark3116_close(struct usb_serial_port *port) |
297 | { |
298 | struct usb_serial *serial = port->serial; |
299 | |
300 | /* disable DMA */ |
301 | ark3116_write_reg(serial, UART_FCR, val: 0); |
302 | |
303 | /* deactivate interrupts */ |
304 | ark3116_write_reg(serial, UART_IER, val: 0); |
305 | |
306 | usb_serial_generic_close(port); |
307 | |
308 | usb_kill_urb(urb: port->interrupt_in_urb); |
309 | } |
310 | |
311 | static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port) |
312 | { |
313 | struct ark3116_private *priv = usb_get_serial_port_data(port); |
314 | struct usb_serial *serial = port->serial; |
315 | unsigned char *buf; |
316 | int result; |
317 | |
318 | buf = kmalloc(size: 1, GFP_KERNEL); |
319 | if (buf == NULL) |
320 | return -ENOMEM; |
321 | |
322 | result = usb_serial_generic_open(tty, port); |
323 | if (result) { |
324 | dev_dbg(&port->dev, |
325 | "%s - usb_serial_generic_open failed: %d\n" , |
326 | __func__, result); |
327 | goto err_free; |
328 | } |
329 | |
330 | /* remove any data still left: also clears error state */ |
331 | ark3116_read_reg(serial, UART_RX, buf); |
332 | |
333 | /* read modem status */ |
334 | result = ark3116_read_reg(serial, UART_MSR, buf); |
335 | if (result) |
336 | goto err_close; |
337 | priv->msr = *buf; |
338 | |
339 | /* read line status */ |
340 | result = ark3116_read_reg(serial, UART_LSR, buf); |
341 | if (result) |
342 | goto err_close; |
343 | priv->lsr = *buf; |
344 | |
345 | result = usb_submit_urb(urb: port->interrupt_in_urb, GFP_KERNEL); |
346 | if (result) { |
347 | dev_err(&port->dev, "submit irq_in urb failed %d\n" , |
348 | result); |
349 | goto err_close; |
350 | } |
351 | |
352 | /* activate interrupts */ |
353 | ark3116_write_reg(serial: port->serial, UART_IER, UART_IER_MSI|UART_IER_RLSI); |
354 | |
355 | /* enable DMA */ |
356 | ark3116_write_reg(serial: port->serial, UART_FCR, UART_FCR_DMA_SELECT); |
357 | |
358 | /* setup termios */ |
359 | if (tty) |
360 | ark3116_set_termios(tty, port, NULL); |
361 | |
362 | kfree(objp: buf); |
363 | |
364 | return 0; |
365 | |
366 | err_close: |
367 | usb_serial_generic_close(port); |
368 | err_free: |
369 | kfree(objp: buf); |
370 | |
371 | return result; |
372 | } |
373 | |
374 | static int ark3116_tiocmget(struct tty_struct *tty) |
375 | { |
376 | struct usb_serial_port *port = tty->driver_data; |
377 | struct ark3116_private *priv = usb_get_serial_port_data(port); |
378 | __u32 status; |
379 | __u32 ctrl; |
380 | unsigned long flags; |
381 | |
382 | mutex_lock(&priv->hw_lock); |
383 | ctrl = priv->mcr; |
384 | mutex_unlock(lock: &priv->hw_lock); |
385 | |
386 | spin_lock_irqsave(&priv->status_lock, flags); |
387 | status = priv->msr; |
388 | spin_unlock_irqrestore(lock: &priv->status_lock, flags); |
389 | |
390 | return (status & UART_MSR_DSR ? TIOCM_DSR : 0) | |
391 | (status & UART_MSR_CTS ? TIOCM_CTS : 0) | |
392 | (status & UART_MSR_RI ? TIOCM_RI : 0) | |
393 | (status & UART_MSR_DCD ? TIOCM_CD : 0) | |
394 | (ctrl & UART_MCR_DTR ? TIOCM_DTR : 0) | |
395 | (ctrl & UART_MCR_RTS ? TIOCM_RTS : 0) | |
396 | (ctrl & UART_MCR_OUT1 ? TIOCM_OUT1 : 0) | |
397 | (ctrl & UART_MCR_OUT2 ? TIOCM_OUT2 : 0); |
398 | } |
399 | |
400 | static int ark3116_tiocmset(struct tty_struct *tty, |
401 | unsigned set, unsigned clr) |
402 | { |
403 | struct usb_serial_port *port = tty->driver_data; |
404 | struct ark3116_private *priv = usb_get_serial_port_data(port); |
405 | |
406 | /* we need to take the mutex here, to make sure that the value |
407 | * in priv->mcr is actually the one that is in the hardware |
408 | */ |
409 | |
410 | mutex_lock(&priv->hw_lock); |
411 | |
412 | if (set & TIOCM_RTS) |
413 | priv->mcr |= UART_MCR_RTS; |
414 | if (set & TIOCM_DTR) |
415 | priv->mcr |= UART_MCR_DTR; |
416 | if (set & TIOCM_OUT1) |
417 | priv->mcr |= UART_MCR_OUT1; |
418 | if (set & TIOCM_OUT2) |
419 | priv->mcr |= UART_MCR_OUT2; |
420 | if (clr & TIOCM_RTS) |
421 | priv->mcr &= ~UART_MCR_RTS; |
422 | if (clr & TIOCM_DTR) |
423 | priv->mcr &= ~UART_MCR_DTR; |
424 | if (clr & TIOCM_OUT1) |
425 | priv->mcr &= ~UART_MCR_OUT1; |
426 | if (clr & TIOCM_OUT2) |
427 | priv->mcr &= ~UART_MCR_OUT2; |
428 | |
429 | ark3116_write_reg(serial: port->serial, UART_MCR, val: priv->mcr); |
430 | |
431 | mutex_unlock(lock: &priv->hw_lock); |
432 | |
433 | return 0; |
434 | } |
435 | |
436 | static int ark3116_break_ctl(struct tty_struct *tty, int break_state) |
437 | { |
438 | struct usb_serial_port *port = tty->driver_data; |
439 | struct ark3116_private *priv = usb_get_serial_port_data(port); |
440 | int ret; |
441 | |
442 | /* LCR is also used for other things: protect access */ |
443 | mutex_lock(&priv->hw_lock); |
444 | |
445 | if (break_state) |
446 | priv->lcr |= UART_LCR_SBC; |
447 | else |
448 | priv->lcr &= ~UART_LCR_SBC; |
449 | |
450 | ret = ark3116_write_reg(serial: port->serial, UART_LCR, val: priv->lcr); |
451 | |
452 | mutex_unlock(lock: &priv->hw_lock); |
453 | |
454 | return ret; |
455 | } |
456 | |
457 | static void ark3116_update_msr(struct usb_serial_port *port, __u8 msr) |
458 | { |
459 | struct ark3116_private *priv = usb_get_serial_port_data(port); |
460 | unsigned long flags; |
461 | |
462 | spin_lock_irqsave(&priv->status_lock, flags); |
463 | priv->msr = msr; |
464 | spin_unlock_irqrestore(lock: &priv->status_lock, flags); |
465 | |
466 | if (msr & UART_MSR_ANY_DELTA) { |
467 | /* update input line counters */ |
468 | if (msr & UART_MSR_DCTS) |
469 | port->icount.cts++; |
470 | if (msr & UART_MSR_DDSR) |
471 | port->icount.dsr++; |
472 | if (msr & UART_MSR_DDCD) |
473 | port->icount.dcd++; |
474 | if (msr & UART_MSR_TERI) |
475 | port->icount.rng++; |
476 | wake_up_interruptible(&port->port.delta_msr_wait); |
477 | } |
478 | } |
479 | |
480 | static void ark3116_update_lsr(struct usb_serial_port *port, __u8 lsr) |
481 | { |
482 | struct ark3116_private *priv = usb_get_serial_port_data(port); |
483 | unsigned long flags; |
484 | |
485 | spin_lock_irqsave(&priv->status_lock, flags); |
486 | /* combine bits */ |
487 | priv->lsr |= lsr; |
488 | spin_unlock_irqrestore(lock: &priv->status_lock, flags); |
489 | |
490 | if (lsr&UART_LSR_BRK_ERROR_BITS) { |
491 | if (lsr & UART_LSR_BI) |
492 | port->icount.brk++; |
493 | if (lsr & UART_LSR_FE) |
494 | port->icount.frame++; |
495 | if (lsr & UART_LSR_PE) |
496 | port->icount.parity++; |
497 | if (lsr & UART_LSR_OE) |
498 | port->icount.overrun++; |
499 | } |
500 | } |
501 | |
502 | static void ark3116_read_int_callback(struct urb *urb) |
503 | { |
504 | struct usb_serial_port *port = urb->context; |
505 | int status = urb->status; |
506 | const __u8 *data = urb->transfer_buffer; |
507 | int result; |
508 | |
509 | switch (status) { |
510 | case -ECONNRESET: |
511 | case -ENOENT: |
512 | case -ESHUTDOWN: |
513 | /* this urb is terminated, clean up */ |
514 | dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n" , |
515 | __func__, status); |
516 | return; |
517 | default: |
518 | dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n" , |
519 | __func__, status); |
520 | break; |
521 | case 0: /* success */ |
522 | /* discovered this by trail and error... */ |
523 | if ((urb->actual_length == 4) && (data[0] == 0xe8)) { |
524 | const __u8 id = data[1]&UART_IIR_ID; |
525 | dev_dbg(&port->dev, "%s: iir=%02x\n" , __func__, data[1]); |
526 | if (id == UART_IIR_MSI) { |
527 | dev_dbg(&port->dev, "%s: msr=%02x\n" , |
528 | __func__, data[3]); |
529 | ark3116_update_msr(port, msr: data[3]); |
530 | break; |
531 | } else if (id == UART_IIR_RLSI) { |
532 | dev_dbg(&port->dev, "%s: lsr=%02x\n" , |
533 | __func__, data[2]); |
534 | ark3116_update_lsr(port, lsr: data[2]); |
535 | break; |
536 | } |
537 | } |
538 | /* |
539 | * Not sure what this data meant... |
540 | */ |
541 | usb_serial_debug_data(dev: &port->dev, function: __func__, |
542 | size: urb->actual_length, |
543 | data: urb->transfer_buffer); |
544 | break; |
545 | } |
546 | |
547 | result = usb_submit_urb(urb, GFP_ATOMIC); |
548 | if (result) |
549 | dev_err(&port->dev, "failed to resubmit interrupt urb: %d\n" , |
550 | result); |
551 | } |
552 | |
553 | |
554 | /* Data comes in via the bulk (data) URB, errors/interrupts via the int URB. |
555 | * This means that we cannot be sure which data byte has an associated error |
556 | * condition, so we report an error for all data in the next bulk read. |
557 | * |
558 | * Actually, there might even be a window between the bulk data leaving the |
559 | * ark and reading/resetting the lsr in the read_bulk_callback where an |
560 | * interrupt for the next data block could come in. |
561 | * Without somekind of ordering on the ark, we would have to report the |
562 | * error for the next block of data as well... |
563 | * For now, let's pretend this can't happen. |
564 | */ |
565 | static void ark3116_process_read_urb(struct urb *urb) |
566 | { |
567 | struct usb_serial_port *port = urb->context; |
568 | struct ark3116_private *priv = usb_get_serial_port_data(port); |
569 | unsigned char *data = urb->transfer_buffer; |
570 | char tty_flag = TTY_NORMAL; |
571 | unsigned long flags; |
572 | __u32 lsr; |
573 | |
574 | /* update line status */ |
575 | spin_lock_irqsave(&priv->status_lock, flags); |
576 | lsr = priv->lsr; |
577 | priv->lsr &= ~UART_LSR_BRK_ERROR_BITS; |
578 | spin_unlock_irqrestore(lock: &priv->status_lock, flags); |
579 | |
580 | if (!urb->actual_length) |
581 | return; |
582 | |
583 | if (lsr & UART_LSR_BRK_ERROR_BITS) { |
584 | if (lsr & UART_LSR_BI) |
585 | tty_flag = TTY_BREAK; |
586 | else if (lsr & UART_LSR_PE) |
587 | tty_flag = TTY_PARITY; |
588 | else if (lsr & UART_LSR_FE) |
589 | tty_flag = TTY_FRAME; |
590 | |
591 | /* overrun is special, not associated with a char */ |
592 | if (lsr & UART_LSR_OE) |
593 | tty_insert_flip_char(port: &port->port, ch: 0, TTY_OVERRUN); |
594 | } |
595 | tty_insert_flip_string_fixed_flag(port: &port->port, chars: data, flag: tty_flag, |
596 | size: urb->actual_length); |
597 | tty_flip_buffer_push(port: &port->port); |
598 | } |
599 | |
600 | static struct usb_serial_driver ark3116_device = { |
601 | .driver = { |
602 | .owner = THIS_MODULE, |
603 | .name = "ark3116" , |
604 | }, |
605 | .id_table = id_table, |
606 | .num_ports = 1, |
607 | .num_bulk_in = 1, |
608 | .num_bulk_out = 1, |
609 | .num_interrupt_in = 1, |
610 | .port_probe = ark3116_port_probe, |
611 | .port_remove = ark3116_port_remove, |
612 | .set_termios = ark3116_set_termios, |
613 | .tiocmget = ark3116_tiocmget, |
614 | .tiocmset = ark3116_tiocmset, |
615 | .tiocmiwait = usb_serial_generic_tiocmiwait, |
616 | .get_icount = usb_serial_generic_get_icount, |
617 | .open = ark3116_open, |
618 | .close = ark3116_close, |
619 | .break_ctl = ark3116_break_ctl, |
620 | .read_int_callback = ark3116_read_int_callback, |
621 | .process_read_urb = ark3116_process_read_urb, |
622 | }; |
623 | |
624 | static struct usb_serial_driver * const serial_drivers[] = { |
625 | &ark3116_device, NULL |
626 | }; |
627 | |
628 | module_usb_serial_driver(serial_drivers, id_table); |
629 | |
630 | MODULE_LICENSE("GPL" ); |
631 | |
632 | MODULE_AUTHOR(DRIVER_AUTHOR); |
633 | MODULE_DESCRIPTION(DRIVER_DESC); |
634 | |
635 | /* |
636 | * The following describes what I learned from studying the old |
637 | * ark3116.c driver, disassembling the windows driver, and some lucky |
638 | * guesses. Since I do not have any datasheet or other |
639 | * documentation, inaccuracies are almost guaranteed. |
640 | * |
641 | * Some specs for the ARK3116 can be found here: |
642 | * http://web.archive.org/web/20060318000438/ |
643 | * www.arkmicro.com/en/products/view.php?id=10 |
644 | * On that page, 2 GPIO pins are mentioned: I assume these are the |
645 | * OUT1 and OUT2 pins of the UART, so I added support for those |
646 | * through the MCR. Since the pins are not available on my hardware, |
647 | * I could not verify this. |
648 | * Also, it states there is "on-chip hardware flow control". I have |
649 | * discovered how to enable that. Unfortunately, I do not know how to |
650 | * enable XON/XOFF (software) flow control, which would need support |
651 | * from the chip as well to work. Because of the wording on the web |
652 | * page there is a real possibility the chip simply does not support |
653 | * software flow control. |
654 | * |
655 | * I got my ark3116 as part of a mobile phone adapter cable. On the |
656 | * PCB, the following numbered contacts are present: |
657 | * |
658 | * 1:- +5V |
659 | * 2:o DTR |
660 | * 3:i RX |
661 | * 4:i DCD |
662 | * 5:o RTS |
663 | * 6:o TX |
664 | * 7:i RI |
665 | * 8:i DSR |
666 | * 10:- 0V |
667 | * 11:i CTS |
668 | * |
669 | * On my chip, all signals seem to be 3.3V, but 5V tolerant. But that |
670 | * may be different for the one you have ;-). |
671 | * |
672 | * The windows driver limits the registers to 0-F, so I assume there |
673 | * are actually 16 present on the device. |
674 | * |
675 | * On an UART interrupt, 4 bytes of data come in on the interrupt |
676 | * endpoint. The bytes are 0xe8 IIR LSR MSR. |
677 | * |
678 | * The baudrate seems to be generated from the 12MHz crystal, using |
679 | * 4-times subsampling. So quot=12e6/(4*baud). Also see description |
680 | * of register E. |
681 | * |
682 | * Registers 0-7: |
683 | * These seem to be the same as for a regular 16450. The FCR is set |
684 | * to UART_FCR_DMA_SELECT (0x8), I guess to enable transfers between |
685 | * the UART and the USB bridge/DMA engine. |
686 | * |
687 | * Register 8: |
688 | * By trial and error, I found out that bit 0 enables hardware CTS, |
689 | * stopping TX when CTS is +5V. Bit 1 does the same for RTS, making |
690 | * RTS +5V when the 3116 cannot transfer the data to the USB bus |
691 | * (verified by disabling the reading URB). Note that as far as I can |
692 | * tell, the windows driver does NOT use this, so there might be some |
693 | * hardware bug or something. |
694 | * |
695 | * According to a patch provided here |
696 | * https://lore.kernel.org/lkml/200907261419.50702.linux@rainbow-software.org |
697 | * the ARK3116 can also be used as an IrDA dongle. Since I do not have |
698 | * such a thing, I could not investigate that aspect. However, I can |
699 | * speculate ;-). |
700 | * |
701 | * - IrDA encodes data differently than RS232. Most likely, one of |
702 | * the bits in registers 9..E enables the IR ENDEC (encoder/decoder). |
703 | * - Depending on the IR transceiver, the input and output need to be |
704 | * inverted, so there are probably bits for that as well. |
705 | * - IrDA is half-duplex, so there should be a bit for selecting that. |
706 | * |
707 | * This still leaves at least two registers unaccounted for. Perhaps |
708 | * The chip can do XON/XOFF or CRC in HW? |
709 | * |
710 | * Register 9: |
711 | * Set to 0x00 for IrDA, when the baudrate is initialised. |
712 | * |
713 | * Register A: |
714 | * Set to 0x01 for IrDA, at init. |
715 | * |
716 | * Register B: |
717 | * Set to 0x01 for IrDA, 0x00 for RS232, at init. |
718 | * |
719 | * Register C: |
720 | * Set to 00 for IrDA, at init. |
721 | * |
722 | * Register D: |
723 | * Set to 0x41 for IrDA, at init. |
724 | * |
725 | * Register E: |
726 | * Somekind of baudrate override. The windows driver seems to set |
727 | * this to 0x00 for normal baudrates, 0x01 for 460800, 0x02 for 921600. |
728 | * Since 460800 and 921600 cannot be obtained by dividing 3MHz by an integer, |
729 | * it could be somekind of subdivisor thingy. |
730 | * However,it does not seem to do anything: selecting 921600 (divisor 3, |
731 | * reg E=2), still gets 1 MHz. I also checked if registers 9, C or F would |
732 | * work, but they don't. |
733 | * |
734 | * Register F: unknown |
735 | */ |
736 | |