buf, 0x0000001, 1000);
}
+static inline int calc_divisor(int bps)
+{
+ /* Original ark3116 made some exceptions in rounding here
+ * because windows did the same. Assume that is not really
+ * necessary.
+ * Crystal is 12MHz, probably because of USB, but we divide by 4?
+ */
+ return (12000000 + 2*bps) / (4*bps);
+}
+
static int ark3116_attach(struct usb_serial *serial)
{
- char *buf;
+ struct usb_serial_port *port = serial->port[0];
+ struct ark3116_private *priv;
+
+ /* make sure we have our end-points */
+ if ((serial->num_bulk_in == 0) ||
+ (serial->num_bulk_out == 0) ||
+ (serial->num_interrupt_in == 0)) {
+ dev_err(&serial->dev->dev,
+ "%s - missing endpoint - "
+ "bulk in: %d, bulk out: %d, int in %d\n",
+ KBUILD_MODNAME,
+ serial->num_bulk_in,
+ serial->num_bulk_out,
+ serial->num_interrupt_in);
+ return -EINVAL;
+ }
- buf = kmalloc(1, GFP_KERNEL);
- if (!buf) {
- dbg("error kmalloc -> out of mem?");
+ priv = kzalloc(sizeof(struct ark3116_private),
+ GFP_KERNEL);
+ if (!priv)
return -ENOMEM;
- }
- if (is_irda(serial))
- dbg("IrDA mode");
+ init_waitqueue_head(&priv->delta_msr_wait);
+ mutex_init(&priv->hw_lock);
+ spin_lock_init(&priv->status_lock);
+
+ priv->irda = is_irda(serial);
+
+ usb_set_serial_port_data(port, priv);
- /* 3 */
- 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, is_irda(serial) ? 0x0001 : 0x0000,
- 0x000B);
+ /* setup the hardware */
+ ark3116_write_reg(serial, UART_IER, 0);
+ /* disable DMA */
+ ark3116_write_reg(serial, UART_FCR, 0);
+ /* handshake control */
+ priv->hcr = 0;
+ ark3116_write_reg(serial, 0x8 , 0);
+ /* modem control */
+ priv->mcr = 0;
+ ark3116_write_reg(serial, UART_MCR, 0);
- if (is_irda(serial)) {
- ARK3116_SND(serial, 1001, 0xFE, 0x40, 0x0000, 0x000C);
- ARK3116_SND(serial, 1002, 0xFE, 0x40, 0x0041, 0x000D);
- ARK3116_SND(serial, 1003, 0xFE, 0x40, 0x0001, 0x000A);
+ if (!(priv->irda)) {
+ ark3116_write_reg(serial, 0xb , 0);
+ } else {
+ ark3116_write_reg(serial, 0xb , 1);
+ ark3116_write_reg(serial, 0xc , 0);
+ ark3116_write_reg(serial, 0xd , 0x41);
+ ark3116_write_reg(serial, 0xa , 1);
}
- /* <-- seq7 */
- 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);
-
- /* <-- seq12 */
- ARK3116_RCV(serial, 12, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
- ARK3116_SND(serial, 13, 0xFE, 0x40, 0x0000, 0x0004);
-
- /* 14 */
- ARK3116_RCV(serial, 14, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
- ARK3116_SND(serial, 15, 0xFE, 0x40, 0x0000, 0x0004);
-
- /* 16 */
- ARK3116_RCV(serial, 16, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
- /* --> seq17 */
- ARK3116_SND(serial, 17, 0xFE, 0x40, 0x0001, 0x0004);
-
- /* <-- seq18 */
- ARK3116_RCV(serial, 18, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf);
-
- /* --> seq19 */
- ARK3116_SND(serial, 19, 0xFE, 0x40, 0x0003, 0x0004);
-
- /* <-- seq20 */
- /* 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);
- if (is_irda(serial))
- ARK3116_SND(serial, 1004, 0xFE, 0x40, 0x0000, 0x0009);
- 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);
+ /* setup baudrate */
+ ark3116_write_reg(serial, UART_LCR, UART_LCR_DLAB);
- kfree(buf);
+ /* setup for 9600 8N1 */
+ priv->quot = calc_divisor(9600);
+ ark3116_write_reg(serial, UART_DLL, priv->quot & 0xff);
+ ark3116_write_reg(serial, UART_DLM, (priv->quot>>8) & 0xff);
+
+ priv->lcr = UART_LCR_WLEN8;
+ ark3116_write_reg(serial, UART_LCR, UART_LCR_WLEN8);
+
+ ark3116_write_reg(serial, 0xe, 0);
+
+ if (priv->irda)
+ ark3116_write_reg(serial, 0x9, 0);
+
+ dev_info(&serial->dev->dev,
+ "%s using %s mode\n",
+ KBUILD_MODNAME,
+ priv->irda ? "IrDA" : "RS232");
return 0;
}
+static void ark3116_release(struct usb_serial *serial)
+{
+ struct usb_serial_port *port = serial->port[0];
+ struct ark3116_private *priv = usb_get_serial_port_data(port);
+
+ /* device is closed, so URBs and DMA should be down */
+
+ usb_set_serial_port_data(port, NULL);
+
+ mutex_destroy(&priv->hw_lock);
+
+ kfree(priv);
+}
+
static void ark3116_init_termios(struct tty_struct *tty)
{
struct ktermios *termios = tty->termios;
struct ktermios *old_termios)
{
struct usb_serial *serial = port->serial;
+ struct ark3116_private *priv = usb_get_serial_port_data(port);
struct ktermios *termios = tty->termios;
unsigned int cflag = termios->c_cflag;
- int baud;
- int ark3116_baud;
- char *buf;
- char config;
-
- config = 0;
+ int bps = tty_get_baud_rate(tty);
+ int quot;
+ __u8 lcr, hcr, eval;
+
+ /* set data bit count */
+ switch (cflag & CSIZE) {
+ case CS5:
+ lcr = UART_LCR_WLEN5;
+ break;
+ case CS6:
+ lcr = UART_LCR_WLEN6;
+ break;
+ case CS7:
+ lcr = UART_LCR_WLEN7;
+ break;
+ default:
+ case CS8:
+ lcr = UART_LCR_WLEN8;
+ break;
+ }
+ if (cflag & CSTOPB)
+ lcr |= UART_LCR_STOP;
+ if (cflag & PARENB)
+ lcr |= UART_LCR_PARITY;
+ if (!(cflag & PARODD))
+ lcr |= UART_LCR_EPAR;
+#ifdef CMSPAR
+ if (cflag & CMSPAR)
+ lcr |= UART_LCR_SPAR;
+#endif
+ /* handshake control */
+ hcr = (cflag & CRTSCTS) ? 0x03 : 0x00;
+
+ /* calc baudrate */
+ dbg("%s - setting bps to %d", __func__, bps);
+ eval = 0;
+ switch (bps) {
+ case 0:
+ quot = calc_divisor(9600);
+ break;
+ default:
+ if ((bps < 75) || (bps > 3000000))
+ bps = 9600;
+ quot = calc_divisor(bps);
+ break;
+ case 460800:
+ eval = 1;
+ quot = calc_divisor(bps);
+ break;
+ case 921600:
+ eval = 2;
+ quot = calc_divisor(bps);
+ break;
+ }
- dbg("%s - port %d", __func__, port->number);
+ /* Update state: synchronize */
+ mutex_lock(&priv->hw_lock);
+ /* keep old LCR_SBC bit */
+ lcr |= (priv->lcr & UART_LCR_SBC);
- cflag = termios->c_cflag;
- termios->c_cflag &= ~(CMSPAR|CRTSCTS);
+ dbg("%s - setting hcr:0x%02x,lcr:0x%02x,quot:%d",
+ __func__, hcr, lcr, quot);
- buf = kmalloc(1, GFP_KERNEL);
- if (!buf) {
- dbg("error kmalloc");
- *termios = *old_termios;
- return;
+ /* handshake control */
+ if (priv->hcr != hcr) {
+ priv->hcr = hcr;
+ ark3116_write_reg(serial, 0x8, hcr);
}
- /* set data bit count (8/7/6/5) */
- if (cflag & CSIZE) {
- switch (cflag & CSIZE) {
- 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:
- dbg("CSIZE was set but not CS5-CS8, using CS8!");
- /* fall through */
- case CS8:
- config |= 0x03;
- dbg("setting CS8");
- break;
- }
+ /* baudrate */
+ if (priv->quot != quot) {
+ priv->quot = quot;
+ priv->lcr = lcr; /* need to write lcr anyway */
+
+ /* disable DMA since transmit/receive is
+ * shadowed by UART_DLL
+ */
+ ark3116_write_reg(serial, UART_FCR, 0);
+
+ ark3116_write_reg(serial, UART_LCR,
+ lcr|UART_LCR_DLAB);
+ ark3116_write_reg(serial, UART_DLL, quot & 0xff);
+ ark3116_write_reg(serial, UART_DLM, (quot>>8) & 0xff);
+
+ /* restore lcr */
+ ark3116_write_reg(serial, UART_LCR, lcr);
+ /* magic baudrate thingy: not sure what it does,
+ * but windows does this as well.
+ */
+ ark3116_write_reg(serial, 0xe, eval);
+
+ /* enable DMA */
+ ark3116_write_reg(serial, UART_FCR, UART_FCR_DMA_SELECT);
+ } else if (priv->lcr != lcr) {
+ priv->lcr = lcr;
+ ark3116_write_reg(serial, UART_LCR, lcr);
}
- /* set parity (NONE/EVEN/ODD) */
- if (cflag & PARENB) {
- if (cflag & PARODD) {
- config |= 0x08;
- dbg("setting parity to ODD");
- } else {
- config |= 0x18;
- dbg("setting parity to EVEN");
- }
- } else {
- dbg("setting parity to NONE");
- }
+ mutex_unlock(&priv->hw_lock);
- /* set stop bit (1/2) */
- if (cflag & CSTOPB) {
- config |= 0x04;
- dbg("setting 2 stop bits");
- } else {
- dbg("setting 1 stop bit");
+ /* check for software flow control */
+ if (I_IXOFF(tty) || I_IXON(tty)) {
+ dev_warn(&serial->dev->dev,
+ "%s: don't know how to do software flow control\n",
+ KBUILD_MODNAME);
}
- /* set baudrate */
- baud = tty_get_baud_rate(tty);
-
- switch (baud) {
- 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 */
- tty_encode_baud_rate(tty, baud, baud);
- break;
- /* set 9600 as default (if given baudrate is invalid for example) */
- default:
- tty_encode_baud_rate(tty, 9600, 9600);
- case 0:
- baud = 9600;
- }
-
- /*
- * found by try'n'error, be careful, maybe there are other options
- * for multiplicator etc! (3.5 for example)
- */
- if (baud == 460800)
- /* strange, for 460800 the formula is wrong
- * if using round() then 9600baud is wrong) */
- ark3116_baud = 7;
- else
- ark3116_baud = 3000000 / baud;
-
- /* ? */
- ARK3116_RCV(serial, 0, 0xFE, 0xC0, 0x0000, 0x0003, 0x03, buf);
-
- /* offset = buf[0]; */
- /* offset = 0x03; */
- /* dbg("using 0x%04X as target for 0x0003:", 0x0080 + offset); */
-
- /* set baudrate */
- 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);
-
- /* ? */
- ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
- ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
-
- /* set data bit count, stop bit count & parity: */
- dbg("updating bit count, stop bit or parity (cfg=0x%02X)", config);
- ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
- ARK3116_SND(serial, 154, 0xFE, 0x40, config, 0x0003);
+ /* Don't rewrite B0 */
+ if (tty_termios_baud_rate(termios))
+ tty_termios_encode_baud_rate(termios, bps, bps);
+}
- if (cflag & CRTSCTS)
- dbg("CRTSCTS not supported by chipset?!");
+static void ark3116_close(struct usb_serial_port *port)
+{
+ struct usb_serial *serial = port->serial;
- /* TEST ARK3116_SND(154, 0xFE, 0x40, 0xFFFF, 0x0006); */
+ if (serial->dev) {
+ /* disable DMA */
+ ark3116_write_reg(serial, UART_FCR, 0);
- kfree(buf);
+ /* deactivate interrupts */
+ ark3116_write_reg(serial, UART_IER, 0);
- return;
+ /* shutdown any bulk reads that might be going on */
+ if (serial->num_bulk_out)
+ usb_kill_urb(port->write_urb);
+ if (serial->num_bulk_in)
+ usb_kill_urb(port->read_urb);
+ if (serial->num_interrupt_in)
+ usb_kill_urb(port->interrupt_in_urb);
+ }
}
static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
{
- struct ktermios tmp_termios;
+ struct ark3116_private *priv = usb_get_serial_port_data(port);
struct usb_serial *serial = port->serial;
- char *buf;
- int result = 0;
-
- dbg("%s - port %d", __func__, port->number);
+ unsigned char *buf;
+ int result;
buf = kmalloc(1, GFP_KERNEL);
- if (!buf) {
- dbg("error kmalloc -> out of mem?");
+ if (buf == NULL)
return -ENOMEM;
- }
result = usb_serial_generic_open(tty, port);
- if (result)
+ if (result) {
+ dbg("%s - usb_serial_generic_open failed: %d",
+ __func__, result);
goto err_out;
+ }
- /* open */
- ARK3116_RCV(serial, 111, 0xFE, 0xC0, 0x0000, 0x0003, 0x02, buf);
-
- 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);
-
- ARK3116_RCV(serial, 116, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
- ARK3116_SND(serial, 117, 0xFE, 0x40, 0x0002, 0x0004);
-
- ARK3116_RCV(serial, 118, 0xFE, 0xC0, 0x0000, 0x0004, 0x02, buf);
- ARK3116_SND(serial, 119, 0xFE, 0x40, 0x0000, 0x0004);
-
- ARK3116_RCV(serial, 120, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
+ /* setup termios */
+ if (tty)
+ ark3116_set_termios(tty, port, NULL);
- ARK3116_SND(serial, 121, 0xFE, 0x40, 0x0001, 0x0004);
+ /* remove any data still left: also clears error state */
+ ark3116_read_reg(serial, UART_RX, buf);
- ARK3116_RCV(serial, 122, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf);
+ /* read modem status */
+ priv->msr = ark3116_read_reg(serial, UART_MSR, buf);
+ /* read line status */
+ priv->lsr = ark3116_read_reg(serial, UART_LSR, buf);
- ARK3116_SND(serial, 123, 0xFE, 0x40, 0x0003, 0x0004);
+ result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
+ if (result) {
+ dev_err(&port->dev, "submit irq_in urb failed %d\n",
+ result);
+ ark3116_close(port);
+ goto err_out;
+ }
- /* returns different values (control lines?!) */
- ARK3116_RCV(serial, 124, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);
+ /* activate interrupts */
+ ark3116_write_reg(port->serial, UART_IER, UART_IER_MSI|UART_IER_RLSI);
- /* initialise termios */
- if (tty)
- ark3116_set_termios(tty, port, &tmp_termios);
+ /* enable DMA */
+ ark3116_write_reg(port->serial, UART_FCR, UART_FCR_DMA_SELECT);
err_out:
kfree(buf);
-
return result;
}
unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
+ struct ark3116_private *priv = usb_get_serial_port_data(port);
struct serial_struct serstruct;
void __user *user_arg = (void __user *)arg;
if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
return -EFAULT;
return 0;
- default:
- dbg("%s cmd 0x%04x not supported", __func__, cmd);
+ case TIOCMIWAIT:
+ for (;;) {
+ struct async_icount prev = priv->icount;
+ interruptible_sleep_on(&priv->delta_msr_wait);
+ /* see if a signal did it */
+ if (signal_pending(current))
+ return -ERESTARTSYS;
+ if ((prev.rng == priv->icount.rng) &&
+ (prev.dsr == priv->icount.dsr) &&
+ (prev.dcd == priv->icount.dcd) &&
+ (prev.cts == priv->icount.cts))
+ return -EIO;
+ if ((arg & TIOCM_RNG &&
+ (prev.rng != priv->icount.rng)) ||
+ (arg & TIOCM_DSR &&
+ (prev.dsr != priv->icount.dsr)) ||
+ (arg & TIOCM_CD &&
+ (prev.dcd != priv->icount.dcd)) ||
+ (arg & TIOCM_CTS &&
+ (prev.cts != priv->icount.cts)))
+ return 0;
+ }
break;
+ case TIOCGICOUNT: {
+ struct serial_icounter_struct icount;
+ struct async_icount cnow = priv->icount;
+ memset(&icount, 0, sizeof(icount));
+ icount.cts = cnow.cts;
+ icount.dsr = cnow.dsr;
+ icount.rng = cnow.rng;
+ icount.dcd = cnow.dcd;
+ icount.rx = cnow.rx;
+ icount.tx = cnow.tx;
+ icount.frame = cnow.frame;
+ icount.overrun = cnow.overrun;
+ icount.parity = cnow.parity;
+ icount.brk = cnow.brk;
+ icount.buf_overrun = cnow.buf_overrun;
+ if (copy_to_user(user_arg, &icount, sizeof(icount)))
+ return -EFAULT;
+ return 0;
+ }
}
return -ENOIOCTLCMD;
.usb_driver = &ark3116_driver,
.num_ports = 1,
.attach = ark3116_attach,
+ .release = ark3116_release,
.set_termios = ark3116_set_termios,
.init_termios = ark3116_init_termios,
.ioctl = ark3116_ioctl,
.tiocmget = ark3116_tiocmget,
.open = ark3116_open,
+ .close = ark3116_close,
};
static int __init ark3116_init(void)
projects / GitHub / exynos8895 / android_kernel_samsung_universal8895.git / commitdiff