Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Fintek F81232 USB to serial adaptor driver
0004  * Fintek F81532A/534A/535/536 USB to 2/4/8/12 serial adaptor driver
0005  *
0006  * Copyright (C) 2012 Greg Kroah-Hartman (gregkh@linuxfoundation.org)
0007  * Copyright (C) 2012 Linux Foundation
0008  */
0009 
0010 #include <linux/kernel.h>
0011 #include <linux/errno.h>
0012 #include <linux/slab.h>
0013 #include <linux/tty.h>
0014 #include <linux/tty_driver.h>
0015 #include <linux/tty_flip.h>
0016 #include <linux/serial.h>
0017 #include <linux/module.h>
0018 #include <linux/moduleparam.h>
0019 #include <linux/mutex.h>
0020 #include <linux/uaccess.h>
0021 #include <linux/usb.h>
0022 #include <linux/usb/serial.h>
0023 #include <linux/serial_reg.h>
0024 
0025 #define F81232_ID       \
0026     { USB_DEVICE(0x1934, 0x0706) }  /* 1 port UART device */
0027 
0028 #define F81534A_SERIES_ID   \
0029     { USB_DEVICE(0x2c42, 0x1602) }, /* In-Box 2 port UART device */ \
0030     { USB_DEVICE(0x2c42, 0x1604) }, /* In-Box 4 port UART device */ \
0031     { USB_DEVICE(0x2c42, 0x1605) }, /* In-Box 8 port UART device */ \
0032     { USB_DEVICE(0x2c42, 0x1606) }, /* In-Box 12 port UART device */ \
0033     { USB_DEVICE(0x2c42, 0x1608) }, /* Non-Flash type */ \
0034     { USB_DEVICE(0x2c42, 0x1632) }, /* 2 port UART device */ \
0035     { USB_DEVICE(0x2c42, 0x1634) }, /* 4 port UART device */ \
0036     { USB_DEVICE(0x2c42, 0x1635) }, /* 8 port UART device */ \
0037     { USB_DEVICE(0x2c42, 0x1636) }  /* 12 port UART device */
0038 
0039 #define F81534A_CTRL_ID     \
0040     { USB_DEVICE(0x2c42, 0x16f8) }  /* Global control device */
0041 
0042 static const struct usb_device_id f81232_id_table[] = {
0043     F81232_ID,
0044     { }                 /* Terminating entry */
0045 };
0046 
0047 static const struct usb_device_id f81534a_id_table[] = {
0048     F81534A_SERIES_ID,
0049     { }                 /* Terminating entry */
0050 };
0051 
0052 static const struct usb_device_id f81534a_ctrl_id_table[] = {
0053     F81534A_CTRL_ID,
0054     { }                 /* Terminating entry */
0055 };
0056 
0057 static const struct usb_device_id combined_id_table[] = {
0058     F81232_ID,
0059     F81534A_SERIES_ID,
0060     F81534A_CTRL_ID,
0061     { }                 /* Terminating entry */
0062 };
0063 MODULE_DEVICE_TABLE(usb, combined_id_table);
0064 
0065 /* Maximum baudrate for F81232 */
0066 #define F81232_MAX_BAUDRATE     1500000
0067 #define F81232_DEF_BAUDRATE     9600
0068 
0069 /* USB Control EP parameter */
0070 #define F81232_REGISTER_REQUEST     0xa0
0071 #define F81232_GET_REGISTER     0xc0
0072 #define F81232_SET_REGISTER     0x40
0073 #define F81534A_ACCESS_REG_RETRY    2
0074 
0075 #define SERIAL_BASE_ADDRESS     0x0120
0076 #define RECEIVE_BUFFER_REGISTER     (0x00 + SERIAL_BASE_ADDRESS)
0077 #define INTERRUPT_ENABLE_REGISTER   (0x01 + SERIAL_BASE_ADDRESS)
0078 #define FIFO_CONTROL_REGISTER       (0x02 + SERIAL_BASE_ADDRESS)
0079 #define LINE_CONTROL_REGISTER       (0x03 + SERIAL_BASE_ADDRESS)
0080 #define MODEM_CONTROL_REGISTER      (0x04 + SERIAL_BASE_ADDRESS)
0081 #define LINE_STATUS_REGISTER        (0x05 + SERIAL_BASE_ADDRESS)
0082 #define MODEM_STATUS_REGISTER       (0x06 + SERIAL_BASE_ADDRESS)
0083 
0084 /*
0085  * F81232 Clock registers (106h)
0086  *
0087  * Bit1-0:  Clock source selector
0088  *          00: 1.846MHz.
0089  *          01: 18.46MHz.
0090  *          10: 24MHz.
0091  *          11: 14.77MHz.
0092  */
0093 #define F81232_CLK_REGISTER     0x106
0094 #define F81232_CLK_1_846_MHZ        0
0095 #define F81232_CLK_18_46_MHZ        BIT(0)
0096 #define F81232_CLK_24_MHZ       BIT(1)
0097 #define F81232_CLK_14_77_MHZ        (BIT(1) | BIT(0))
0098 #define F81232_CLK_MASK         GENMASK(1, 0)
0099 
0100 #define F81534A_MODE_REG        0x107
0101 #define F81534A_TRIGGER_MASK        GENMASK(3, 2)
0102 #define F81534A_TRIGGER_MULTIPLE_4X BIT(3)
0103 #define F81534A_FIFO_128BYTE        (BIT(1) | BIT(0))
0104 
0105 /* Serial port self GPIO control, 2bytes [control&output data][input data] */
0106 #define F81534A_GPIO_REG        0x10e
0107 #define F81534A_GPIO_MODE2_DIR      BIT(6) /* 1: input, 0: output */
0108 #define F81534A_GPIO_MODE1_DIR      BIT(5)
0109 #define F81534A_GPIO_MODE0_DIR      BIT(4)
0110 #define F81534A_GPIO_MODE2_OUTPUT   BIT(2)
0111 #define F81534A_GPIO_MODE1_OUTPUT   BIT(1)
0112 #define F81534A_GPIO_MODE0_OUTPUT   BIT(0)
0113 
0114 #define F81534A_CTRL_CMD_ENABLE_PORT    0x116
0115 
0116 struct f81232_private {
0117     struct mutex lock;
0118     u8 modem_control;
0119     u8 modem_status;
0120     u8 shadow_lcr;
0121     speed_t baud_base;
0122     struct work_struct lsr_work;
0123     struct work_struct interrupt_work;
0124     struct usb_serial_port *port;
0125 };
0126 
0127 static u32 const baudrate_table[] = { 115200, 921600, 1152000, 1500000 };
0128 static u8 const clock_table[] = { F81232_CLK_1_846_MHZ, F81232_CLK_14_77_MHZ,
0129                 F81232_CLK_18_46_MHZ, F81232_CLK_24_MHZ };
0130 
0131 static int calc_baud_divisor(speed_t baudrate, speed_t clockrate)
0132 {
0133     if (!baudrate)
0134         return 0;
0135 
0136     return DIV_ROUND_CLOSEST(clockrate, baudrate);
0137 }
0138 
0139 static int f81232_get_register(struct usb_serial_port *port, u16 reg, u8 *val)
0140 {
0141     int status;
0142     struct usb_device *dev = port->serial->dev;
0143 
0144     status = usb_control_msg_recv(dev,
0145                       0,
0146                       F81232_REGISTER_REQUEST,
0147                       F81232_GET_REGISTER,
0148                       reg,
0149                       0,
0150                       val,
0151                       sizeof(*val),
0152                       USB_CTRL_GET_TIMEOUT,
0153                       GFP_KERNEL);
0154     if (status) {
0155         dev_err(&port->dev, "%s failed status: %d\n", __func__, status);
0156         status = usb_translate_errors(status);
0157     }
0158 
0159     return status;
0160 }
0161 
0162 static int f81232_set_register(struct usb_serial_port *port, u16 reg, u8 val)
0163 {
0164     int status;
0165     struct usb_device *dev = port->serial->dev;
0166 
0167     status = usb_control_msg_send(dev,
0168                       0,
0169                       F81232_REGISTER_REQUEST,
0170                       F81232_SET_REGISTER,
0171                       reg,
0172                       0,
0173                       &val,
0174                       sizeof(val),
0175                       USB_CTRL_SET_TIMEOUT,
0176                       GFP_KERNEL);
0177     if (status) {
0178         dev_err(&port->dev, "%s failed status: %d\n", __func__, status);
0179         status = usb_translate_errors(status);
0180     }
0181 
0182     return status;
0183 }
0184 
0185 static int f81232_set_mask_register(struct usb_serial_port *port, u16 reg,
0186                     u8 mask, u8 val)
0187 {
0188     int status;
0189     u8 tmp;
0190 
0191     status = f81232_get_register(port, reg, &tmp);
0192     if (status)
0193         return status;
0194 
0195     tmp = (tmp & ~mask) | (val & mask);
0196 
0197     return f81232_set_register(port, reg, tmp);
0198 }
0199 
0200 static void f81232_read_msr(struct usb_serial_port *port)
0201 {
0202     int status;
0203     u8 current_msr;
0204     struct tty_struct *tty;
0205     struct f81232_private *priv = usb_get_serial_port_data(port);
0206 
0207     mutex_lock(&priv->lock);
0208     status = f81232_get_register(port, MODEM_STATUS_REGISTER,
0209             &current_msr);
0210     if (status) {
0211         dev_err(&port->dev, "%s fail, status: %d\n", __func__, status);
0212         mutex_unlock(&priv->lock);
0213         return;
0214     }
0215 
0216     if (!(current_msr & UART_MSR_ANY_DELTA)) {
0217         mutex_unlock(&priv->lock);
0218         return;
0219     }
0220 
0221     priv->modem_status = current_msr;
0222 
0223     if (current_msr & UART_MSR_DCTS)
0224         port->icount.cts++;
0225     if (current_msr & UART_MSR_DDSR)
0226         port->icount.dsr++;
0227     if (current_msr & UART_MSR_TERI)
0228         port->icount.rng++;
0229     if (current_msr & UART_MSR_DDCD) {
0230         port->icount.dcd++;
0231         tty = tty_port_tty_get(&port->port);
0232         if (tty) {
0233             usb_serial_handle_dcd_change(port, tty,
0234                     current_msr & UART_MSR_DCD);
0235 
0236             tty_kref_put(tty);
0237         }
0238     }
0239 
0240     wake_up_interruptible(&port->port.delta_msr_wait);
0241     mutex_unlock(&priv->lock);
0242 }
0243 
0244 static int f81232_set_mctrl(struct usb_serial_port *port,
0245                        unsigned int set, unsigned int clear)
0246 {
0247     u8 val;
0248     int status;
0249     struct f81232_private *priv = usb_get_serial_port_data(port);
0250 
0251     if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0)
0252         return 0;   /* no change */
0253 
0254     /* 'set' takes precedence over 'clear' */
0255     clear &= ~set;
0256 
0257     /* force enable interrupt with OUT2 */
0258     mutex_lock(&priv->lock);
0259     val = UART_MCR_OUT2 | priv->modem_control;
0260 
0261     if (clear & TIOCM_DTR)
0262         val &= ~UART_MCR_DTR;
0263 
0264     if (clear & TIOCM_RTS)
0265         val &= ~UART_MCR_RTS;
0266 
0267     if (set & TIOCM_DTR)
0268         val |= UART_MCR_DTR;
0269 
0270     if (set & TIOCM_RTS)
0271         val |= UART_MCR_RTS;
0272 
0273     dev_dbg(&port->dev, "%s new:%02x old:%02x\n", __func__,
0274             val, priv->modem_control);
0275 
0276     status = f81232_set_register(port, MODEM_CONTROL_REGISTER, val);
0277     if (status) {
0278         dev_err(&port->dev, "%s set MCR status < 0\n", __func__);
0279         mutex_unlock(&priv->lock);
0280         return status;
0281     }
0282 
0283     priv->modem_control = val;
0284     mutex_unlock(&priv->lock);
0285 
0286     return 0;
0287 }
0288 
0289 static void f81232_update_line_status(struct usb_serial_port *port,
0290                       unsigned char *data,
0291                       size_t actual_length)
0292 {
0293     struct f81232_private *priv = usb_get_serial_port_data(port);
0294 
0295     if (!actual_length)
0296         return;
0297 
0298     switch (data[0] & 0x07) {
0299     case 0x00: /* msr change */
0300         dev_dbg(&port->dev, "IIR: MSR Change: %02x\n", data[0]);
0301         schedule_work(&priv->interrupt_work);
0302         break;
0303     case 0x02: /* tx-empty */
0304         break;
0305     case 0x04: /* rx data available */
0306         break;
0307     case 0x06: /* lsr change */
0308         /* we can forget it. the LSR will read from bulk-in */
0309         dev_dbg(&port->dev, "IIR: LSR Change: %02x\n", data[0]);
0310         break;
0311     }
0312 }
0313 
0314 static void f81232_read_int_callback(struct urb *urb)
0315 {
0316     struct usb_serial_port *port =  urb->context;
0317     unsigned char *data = urb->transfer_buffer;
0318     unsigned int actual_length = urb->actual_length;
0319     int status = urb->status;
0320     int retval;
0321 
0322     switch (status) {
0323     case 0:
0324         /* success */
0325         break;
0326     case -ECONNRESET:
0327     case -ENOENT:
0328     case -ESHUTDOWN:
0329         /* this urb is terminated, clean up */
0330         dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
0331             __func__, status);
0332         return;
0333     default:
0334         dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
0335             __func__, status);
0336         goto exit;
0337     }
0338 
0339     usb_serial_debug_data(&port->dev, __func__,
0340                   urb->actual_length, urb->transfer_buffer);
0341 
0342     f81232_update_line_status(port, data, actual_length);
0343 
0344 exit:
0345     retval = usb_submit_urb(urb, GFP_ATOMIC);
0346     if (retval)
0347         dev_err(&urb->dev->dev,
0348             "%s - usb_submit_urb failed with result %d\n",
0349             __func__, retval);
0350 }
0351 
0352 static char f81232_handle_lsr(struct usb_serial_port *port, u8 lsr)
0353 {
0354     struct f81232_private *priv = usb_get_serial_port_data(port);
0355     char tty_flag = TTY_NORMAL;
0356 
0357     if (!(lsr & UART_LSR_BRK_ERROR_BITS))
0358         return tty_flag;
0359 
0360     if (lsr & UART_LSR_BI) {
0361         tty_flag = TTY_BREAK;
0362         port->icount.brk++;
0363         usb_serial_handle_break(port);
0364     } else if (lsr & UART_LSR_PE) {
0365         tty_flag = TTY_PARITY;
0366         port->icount.parity++;
0367     } else if (lsr & UART_LSR_FE) {
0368         tty_flag = TTY_FRAME;
0369         port->icount.frame++;
0370     }
0371 
0372     if (lsr & UART_LSR_OE) {
0373         port->icount.overrun++;
0374         schedule_work(&priv->lsr_work);
0375         tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
0376     }
0377 
0378     return tty_flag;
0379 }
0380 
0381 static void f81232_process_read_urb(struct urb *urb)
0382 {
0383     struct usb_serial_port *port = urb->context;
0384     unsigned char *data = urb->transfer_buffer;
0385     char tty_flag;
0386     unsigned int i;
0387     u8 lsr;
0388 
0389     /*
0390      * When opening the port we get a 1-byte packet with the current LSR,
0391      * which we discard.
0392      */
0393     if ((urb->actual_length < 2) || (urb->actual_length % 2))
0394         return;
0395 
0396     /* bulk-in data: [LSR(1Byte)+DATA(1Byte)][LSR(1Byte)+DATA(1Byte)]... */
0397 
0398     for (i = 0; i < urb->actual_length; i += 2) {
0399         lsr = data[i];
0400         tty_flag = f81232_handle_lsr(port, lsr);
0401 
0402         if (port->sysrq) {
0403             if (usb_serial_handle_sysrq_char(port, data[i + 1]))
0404                 continue;
0405         }
0406 
0407         tty_insert_flip_char(&port->port, data[i + 1], tty_flag);
0408     }
0409 
0410     tty_flip_buffer_push(&port->port);
0411 }
0412 
0413 static void f81534a_process_read_urb(struct urb *urb)
0414 {
0415     struct usb_serial_port *port = urb->context;
0416     unsigned char *data = urb->transfer_buffer;
0417     char tty_flag;
0418     unsigned int i;
0419     u8 lsr;
0420     u8 len;
0421 
0422     if (urb->actual_length < 3) {
0423         dev_err(&port->dev, "short message received: %d\n",
0424                 urb->actual_length);
0425         return;
0426     }
0427 
0428     len = data[0];
0429     if (len != urb->actual_length) {
0430         dev_err(&port->dev, "malformed message received: %d (%d)\n",
0431                 urb->actual_length, len);
0432         return;
0433     }
0434 
0435     /* bulk-in data: [LEN][Data.....][LSR] */
0436     lsr = data[len - 1];
0437     tty_flag = f81232_handle_lsr(port, lsr);
0438 
0439     if (port->sysrq) {
0440         for (i = 1; i < len - 1; ++i) {
0441             if (!usb_serial_handle_sysrq_char(port, data[i])) {
0442                 tty_insert_flip_char(&port->port, data[i],
0443                         tty_flag);
0444             }
0445         }
0446     } else {
0447         tty_insert_flip_string_fixed_flag(&port->port, &data[1],
0448                             tty_flag, len - 2);
0449     }
0450 
0451     tty_flip_buffer_push(&port->port);
0452 }
0453 
0454 static void f81232_break_ctl(struct tty_struct *tty, int break_state)
0455 {
0456     struct usb_serial_port *port = tty->driver_data;
0457     struct f81232_private *priv = usb_get_serial_port_data(port);
0458     int status;
0459 
0460     mutex_lock(&priv->lock);
0461 
0462     if (break_state)
0463         priv->shadow_lcr |= UART_LCR_SBC;
0464     else
0465         priv->shadow_lcr &= ~UART_LCR_SBC;
0466 
0467     status = f81232_set_register(port, LINE_CONTROL_REGISTER,
0468                     priv->shadow_lcr);
0469     if (status)
0470         dev_err(&port->dev, "set break failed: %d\n", status);
0471 
0472     mutex_unlock(&priv->lock);
0473 }
0474 
0475 static int f81232_find_clk(speed_t baudrate)
0476 {
0477     int idx;
0478 
0479     for (idx = 0; idx < ARRAY_SIZE(baudrate_table); ++idx) {
0480         if (baudrate <= baudrate_table[idx] &&
0481                 baudrate_table[idx] % baudrate == 0)
0482             return idx;
0483     }
0484 
0485     return -EINVAL;
0486 }
0487 
0488 static void f81232_set_baudrate(struct tty_struct *tty,
0489                 struct usb_serial_port *port, speed_t baudrate,
0490                 speed_t old_baudrate)
0491 {
0492     struct f81232_private *priv = usb_get_serial_port_data(port);
0493     u8 lcr;
0494     int divisor;
0495     int status = 0;
0496     int i;
0497     int idx;
0498     speed_t baud_list[] = { baudrate, old_baudrate, F81232_DEF_BAUDRATE };
0499 
0500     for (i = 0; i < ARRAY_SIZE(baud_list); ++i) {
0501         idx = f81232_find_clk(baud_list[i]);
0502         if (idx >= 0) {
0503             baudrate = baud_list[i];
0504             tty_encode_baud_rate(tty, baudrate, baudrate);
0505             break;
0506         }
0507     }
0508 
0509     if (idx < 0)
0510         return;
0511 
0512     priv->baud_base = baudrate_table[idx];
0513     divisor = calc_baud_divisor(baudrate, priv->baud_base);
0514 
0515     status = f81232_set_mask_register(port, F81232_CLK_REGISTER,
0516             F81232_CLK_MASK, clock_table[idx]);
0517     if (status) {
0518         dev_err(&port->dev, "%s failed to set CLK_REG: %d\n",
0519             __func__, status);
0520         return;
0521     }
0522 
0523     status = f81232_get_register(port, LINE_CONTROL_REGISTER,
0524              &lcr); /* get LCR */
0525     if (status) {
0526         dev_err(&port->dev, "%s failed to get LCR: %d\n",
0527             __func__, status);
0528         return;
0529     }
0530 
0531     status = f81232_set_register(port, LINE_CONTROL_REGISTER,
0532              lcr | UART_LCR_DLAB); /* Enable DLAB */
0533     if (status) {
0534         dev_err(&port->dev, "%s failed to set DLAB: %d\n",
0535             __func__, status);
0536         return;
0537     }
0538 
0539     status = f81232_set_register(port, RECEIVE_BUFFER_REGISTER,
0540              divisor & 0x00ff); /* low */
0541     if (status) {
0542         dev_err(&port->dev, "%s failed to set baudrate MSB: %d\n",
0543             __func__, status);
0544         goto reapply_lcr;
0545     }
0546 
0547     status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER,
0548              (divisor & 0xff00) >> 8); /* high */
0549     if (status) {
0550         dev_err(&port->dev, "%s failed to set baudrate LSB: %d\n",
0551             __func__, status);
0552     }
0553 
0554 reapply_lcr:
0555     status = f81232_set_register(port, LINE_CONTROL_REGISTER,
0556             lcr & ~UART_LCR_DLAB);
0557     if (status) {
0558         dev_err(&port->dev, "%s failed to set DLAB: %d\n",
0559             __func__, status);
0560     }
0561 }
0562 
0563 static int f81232_port_enable(struct usb_serial_port *port)
0564 {
0565     u8 val;
0566     int status;
0567 
0568     /* fifo on, trigger8, clear TX/RX*/
0569     val = UART_FCR_TRIGGER_8 | UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR |
0570             UART_FCR_CLEAR_XMIT;
0571 
0572     status = f81232_set_register(port, FIFO_CONTROL_REGISTER, val);
0573     if (status) {
0574         dev_err(&port->dev, "%s failed to set FCR: %d\n",
0575             __func__, status);
0576         return status;
0577     }
0578 
0579     /* MSR Interrupt only, LSR will read from Bulk-in odd byte */
0580     status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER,
0581             UART_IER_MSI);
0582     if (status) {
0583         dev_err(&port->dev, "%s failed to set IER: %d\n",
0584             __func__, status);
0585         return status;
0586     }
0587 
0588     return 0;
0589 }
0590 
0591 static int f81232_port_disable(struct usb_serial_port *port)
0592 {
0593     int status;
0594 
0595     status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER, 0);
0596     if (status) {
0597         dev_err(&port->dev, "%s failed to set IER: %d\n",
0598             __func__, status);
0599         return status;
0600     }
0601 
0602     return 0;
0603 }
0604 
0605 static void f81232_set_termios(struct tty_struct *tty,
0606         struct usb_serial_port *port, struct ktermios *old_termios)
0607 {
0608     struct f81232_private *priv = usb_get_serial_port_data(port);
0609     u8 new_lcr = 0;
0610     int status = 0;
0611     speed_t baudrate;
0612     speed_t old_baud;
0613 
0614     /* Don't change anything if nothing has changed */
0615     if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
0616         return;
0617 
0618     if (C_BAUD(tty) == B0)
0619         f81232_set_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS);
0620     else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
0621         f81232_set_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0);
0622 
0623     baudrate = tty_get_baud_rate(tty);
0624     if (baudrate > 0) {
0625         if (old_termios)
0626             old_baud = tty_termios_baud_rate(old_termios);
0627         else
0628             old_baud = F81232_DEF_BAUDRATE;
0629 
0630         f81232_set_baudrate(tty, port, baudrate, old_baud);
0631     }
0632 
0633     if (C_PARENB(tty)) {
0634         new_lcr |= UART_LCR_PARITY;
0635 
0636         if (!C_PARODD(tty))
0637             new_lcr |= UART_LCR_EPAR;
0638 
0639         if (C_CMSPAR(tty))
0640             new_lcr |= UART_LCR_SPAR;
0641     }
0642 
0643     if (C_CSTOPB(tty))
0644         new_lcr |= UART_LCR_STOP;
0645 
0646     new_lcr |= UART_LCR_WLEN(tty_get_char_size(tty->termios.c_cflag));
0647 
0648     mutex_lock(&priv->lock);
0649 
0650     new_lcr |= (priv->shadow_lcr & UART_LCR_SBC);
0651     status = f81232_set_register(port, LINE_CONTROL_REGISTER, new_lcr);
0652     if (status) {
0653         dev_err(&port->dev, "%s failed to set LCR: %d\n",
0654             __func__, status);
0655     }
0656 
0657     priv->shadow_lcr = new_lcr;
0658 
0659     mutex_unlock(&priv->lock);
0660 }
0661 
0662 static int f81232_tiocmget(struct tty_struct *tty)
0663 {
0664     int r;
0665     struct usb_serial_port *port = tty->driver_data;
0666     struct f81232_private *port_priv = usb_get_serial_port_data(port);
0667     u8 mcr, msr;
0668 
0669     /* force get current MSR changed state */
0670     f81232_read_msr(port);
0671 
0672     mutex_lock(&port_priv->lock);
0673     mcr = port_priv->modem_control;
0674     msr = port_priv->modem_status;
0675     mutex_unlock(&port_priv->lock);
0676 
0677     r = (mcr & UART_MCR_DTR ? TIOCM_DTR : 0) |
0678         (mcr & UART_MCR_RTS ? TIOCM_RTS : 0) |
0679         (msr & UART_MSR_CTS ? TIOCM_CTS : 0) |
0680         (msr & UART_MSR_DCD ? TIOCM_CAR : 0) |
0681         (msr & UART_MSR_RI ? TIOCM_RI : 0) |
0682         (msr & UART_MSR_DSR ? TIOCM_DSR : 0);
0683 
0684     return r;
0685 }
0686 
0687 static int f81232_tiocmset(struct tty_struct *tty,
0688             unsigned int set, unsigned int clear)
0689 {
0690     struct usb_serial_port *port = tty->driver_data;
0691 
0692     return f81232_set_mctrl(port, set, clear);
0693 }
0694 
0695 static int f81232_open(struct tty_struct *tty, struct usb_serial_port *port)
0696 {
0697     int result;
0698 
0699     result = f81232_port_enable(port);
0700     if (result)
0701         return result;
0702 
0703     /* Setup termios */
0704     if (tty)
0705         f81232_set_termios(tty, port, NULL);
0706 
0707     result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
0708     if (result) {
0709         dev_err(&port->dev, "%s - failed submitting interrupt urb,"
0710             " error %d\n", __func__, result);
0711         return result;
0712     }
0713 
0714     result = usb_serial_generic_open(tty, port);
0715     if (result) {
0716         usb_kill_urb(port->interrupt_in_urb);
0717         return result;
0718     }
0719 
0720     return 0;
0721 }
0722 
0723 static int f81534a_open(struct tty_struct *tty, struct usb_serial_port *port)
0724 {
0725     int status;
0726     u8 mask;
0727     u8 val;
0728 
0729     val = F81534A_TRIGGER_MULTIPLE_4X | F81534A_FIFO_128BYTE;
0730     mask = F81534A_TRIGGER_MASK | F81534A_FIFO_128BYTE;
0731 
0732     status = f81232_set_mask_register(port, F81534A_MODE_REG, mask, val);
0733     if (status) {
0734         dev_err(&port->dev, "failed to set MODE_REG: %d\n", status);
0735         return status;
0736     }
0737 
0738     return f81232_open(tty, port);
0739 }
0740 
0741 static void f81232_close(struct usb_serial_port *port)
0742 {
0743     struct f81232_private *port_priv = usb_get_serial_port_data(port);
0744 
0745     f81232_port_disable(port);
0746     usb_serial_generic_close(port);
0747     usb_kill_urb(port->interrupt_in_urb);
0748     flush_work(&port_priv->interrupt_work);
0749     flush_work(&port_priv->lsr_work);
0750 }
0751 
0752 static void f81232_dtr_rts(struct usb_serial_port *port, int on)
0753 {
0754     if (on)
0755         f81232_set_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0);
0756     else
0757         f81232_set_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS);
0758 }
0759 
0760 static bool f81232_tx_empty(struct usb_serial_port *port)
0761 {
0762     int status;
0763     u8 tmp;
0764 
0765     status = f81232_get_register(port, LINE_STATUS_REGISTER, &tmp);
0766     if (!status) {
0767         if ((tmp & UART_LSR_TEMT) != UART_LSR_TEMT)
0768             return false;
0769     }
0770 
0771     return true;
0772 }
0773 
0774 static int f81232_carrier_raised(struct usb_serial_port *port)
0775 {
0776     u8 msr;
0777     struct f81232_private *priv = usb_get_serial_port_data(port);
0778 
0779     mutex_lock(&priv->lock);
0780     msr = priv->modem_status;
0781     mutex_unlock(&priv->lock);
0782 
0783     if (msr & UART_MSR_DCD)
0784         return 1;
0785     return 0;
0786 }
0787 
0788 static void f81232_get_serial(struct tty_struct *tty, struct serial_struct *ss)
0789 {
0790     struct usb_serial_port *port = tty->driver_data;
0791     struct f81232_private *priv = usb_get_serial_port_data(port);
0792 
0793     ss->baud_base = priv->baud_base;
0794 }
0795 
0796 static void  f81232_interrupt_work(struct work_struct *work)
0797 {
0798     struct f81232_private *priv =
0799         container_of(work, struct f81232_private, interrupt_work);
0800 
0801     f81232_read_msr(priv->port);
0802 }
0803 
0804 static void f81232_lsr_worker(struct work_struct *work)
0805 {
0806     struct f81232_private *priv;
0807     struct usb_serial_port *port;
0808     int status;
0809     u8 tmp;
0810 
0811     priv = container_of(work, struct f81232_private, lsr_work);
0812     port = priv->port;
0813 
0814     status = f81232_get_register(port, LINE_STATUS_REGISTER, &tmp);
0815     if (status)
0816         dev_warn(&port->dev, "read LSR failed: %d\n", status);
0817 }
0818 
0819 static int f81534a_ctrl_set_register(struct usb_interface *intf, u16 reg,
0820                     u16 size, void *val)
0821 {
0822     struct usb_device *dev = interface_to_usbdev(intf);
0823     int retry = F81534A_ACCESS_REG_RETRY;
0824     int status;
0825 
0826     while (retry--) {
0827         status = usb_control_msg_send(dev,
0828                           0,
0829                           F81232_REGISTER_REQUEST,
0830                           F81232_SET_REGISTER,
0831                           reg,
0832                           0,
0833                           val,
0834                           size,
0835                           USB_CTRL_SET_TIMEOUT,
0836                           GFP_KERNEL);
0837         if (status) {
0838             status = usb_translate_errors(status);
0839             if (status == -EIO)
0840                 continue;
0841         }
0842 
0843         break;
0844     }
0845 
0846     if (status) {
0847         dev_err(&intf->dev, "failed to set register 0x%x: %d\n",
0848                 reg, status);
0849     }
0850 
0851     return status;
0852 }
0853 
0854 static int f81534a_ctrl_enable_all_ports(struct usb_interface *intf, bool en)
0855 {
0856     unsigned char enable[2] = {0};
0857     int status;
0858 
0859     /*
0860      * Enable all available serial ports, define as following:
0861      * bit 15   : Reset behavior (when HUB got soft reset)
0862      *          0: maintain all serial port enabled state.
0863      *          1: disable all serial port.
0864      * bit 0~11 : Serial port enable bit.
0865      */
0866     if (en) {
0867         enable[0] = 0xff;
0868         enable[1] = 0x8f;
0869     }
0870 
0871     status = f81534a_ctrl_set_register(intf, F81534A_CTRL_CMD_ENABLE_PORT,
0872             sizeof(enable), enable);
0873     if (status)
0874         dev_err(&intf->dev, "failed to enable ports: %d\n", status);
0875 
0876     return status;
0877 }
0878 
0879 static int f81534a_ctrl_probe(struct usb_interface *intf,
0880                 const struct usb_device_id *id)
0881 {
0882     return f81534a_ctrl_enable_all_ports(intf, true);
0883 }
0884 
0885 static void f81534a_ctrl_disconnect(struct usb_interface *intf)
0886 {
0887     f81534a_ctrl_enable_all_ports(intf, false);
0888 }
0889 
0890 static int f81534a_ctrl_resume(struct usb_interface *intf)
0891 {
0892     return f81534a_ctrl_enable_all_ports(intf, true);
0893 }
0894 
0895 static int f81232_port_probe(struct usb_serial_port *port)
0896 {
0897     struct f81232_private *priv;
0898 
0899     priv = devm_kzalloc(&port->dev, sizeof(*priv), GFP_KERNEL);
0900     if (!priv)
0901         return -ENOMEM;
0902 
0903     mutex_init(&priv->lock);
0904     INIT_WORK(&priv->interrupt_work,  f81232_interrupt_work);
0905     INIT_WORK(&priv->lsr_work, f81232_lsr_worker);
0906 
0907     usb_set_serial_port_data(port, priv);
0908 
0909     priv->port = port;
0910 
0911     return 0;
0912 }
0913 
0914 static int f81534a_port_probe(struct usb_serial_port *port)
0915 {
0916     int status;
0917 
0918     /* tri-state with pull-high, default RS232 Mode */
0919     status = f81232_set_register(port, F81534A_GPIO_REG,
0920                     F81534A_GPIO_MODE2_DIR);
0921     if (status)
0922         return status;
0923 
0924     return f81232_port_probe(port);
0925 }
0926 
0927 static int f81232_suspend(struct usb_serial *serial, pm_message_t message)
0928 {
0929     struct usb_serial_port *port = serial->port[0];
0930     struct f81232_private *port_priv = usb_get_serial_port_data(port);
0931     int i;
0932 
0933     for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
0934         usb_kill_urb(port->read_urbs[i]);
0935 
0936     usb_kill_urb(port->interrupt_in_urb);
0937 
0938     if (port_priv) {
0939         flush_work(&port_priv->interrupt_work);
0940         flush_work(&port_priv->lsr_work);
0941     }
0942 
0943     return 0;
0944 }
0945 
0946 static int f81232_resume(struct usb_serial *serial)
0947 {
0948     struct usb_serial_port *port = serial->port[0];
0949     int result;
0950 
0951     if (tty_port_initialized(&port->port)) {
0952         result = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
0953         if (result) {
0954             dev_err(&port->dev, "submit interrupt urb failed: %d\n",
0955                     result);
0956             return result;
0957         }
0958     }
0959 
0960     return usb_serial_generic_resume(serial);
0961 }
0962 
0963 static struct usb_serial_driver f81232_device = {
0964     .driver = {
0965         .owner =    THIS_MODULE,
0966         .name =     "f81232",
0967     },
0968     .id_table =     f81232_id_table,
0969     .num_ports =        1,
0970     .bulk_in_size =     256,
0971     .bulk_out_size =    256,
0972     .open =         f81232_open,
0973     .close =        f81232_close,
0974     .dtr_rts =      f81232_dtr_rts,
0975     .carrier_raised =   f81232_carrier_raised,
0976     .get_serial =       f81232_get_serial,
0977     .break_ctl =        f81232_break_ctl,
0978     .set_termios =      f81232_set_termios,
0979     .tiocmget =     f81232_tiocmget,
0980     .tiocmset =     f81232_tiocmset,
0981     .tiocmiwait =       usb_serial_generic_tiocmiwait,
0982     .tx_empty =     f81232_tx_empty,
0983     .process_read_urb = f81232_process_read_urb,
0984     .read_int_callback =    f81232_read_int_callback,
0985     .port_probe =       f81232_port_probe,
0986     .suspend =      f81232_suspend,
0987     .resume =       f81232_resume,
0988 };
0989 
0990 static struct usb_serial_driver f81534a_device = {
0991     .driver = {
0992         .owner =    THIS_MODULE,
0993         .name =     "f81534a",
0994     },
0995     .id_table =     f81534a_id_table,
0996     .num_ports =        1,
0997     .open =         f81534a_open,
0998     .close =        f81232_close,
0999     .dtr_rts =      f81232_dtr_rts,
1000     .carrier_raised =   f81232_carrier_raised,
1001     .get_serial =       f81232_get_serial,
1002     .break_ctl =        f81232_break_ctl,
1003     .set_termios =      f81232_set_termios,
1004     .tiocmget =     f81232_tiocmget,
1005     .tiocmset =     f81232_tiocmset,
1006     .tiocmiwait =       usb_serial_generic_tiocmiwait,
1007     .tx_empty =     f81232_tx_empty,
1008     .process_read_urb = f81534a_process_read_urb,
1009     .read_int_callback =    f81232_read_int_callback,
1010     .port_probe =       f81534a_port_probe,
1011     .suspend =      f81232_suspend,
1012     .resume =       f81232_resume,
1013 };
1014 
1015 static struct usb_serial_driver * const serial_drivers[] = {
1016     &f81232_device,
1017     &f81534a_device,
1018     NULL,
1019 };
1020 
1021 static struct usb_driver f81534a_ctrl_driver = {
1022     .name =     "f81534a_ctrl",
1023     .id_table = f81534a_ctrl_id_table,
1024     .probe =    f81534a_ctrl_probe,
1025     .disconnect =   f81534a_ctrl_disconnect,
1026     .resume =   f81534a_ctrl_resume,
1027 };
1028 
1029 static int __init f81232_init(void)
1030 {
1031     int status;
1032 
1033     status = usb_register_driver(&f81534a_ctrl_driver, THIS_MODULE,
1034             KBUILD_MODNAME);
1035     if (status)
1036         return status;
1037 
1038     status = usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME,
1039             combined_id_table);
1040     if (status) {
1041         usb_deregister(&f81534a_ctrl_driver);
1042         return status;
1043     }
1044 
1045     return 0;
1046 }
1047 
1048 static void __exit f81232_exit(void)
1049 {
1050     usb_serial_deregister_drivers(serial_drivers);
1051     usb_deregister(&f81534a_ctrl_driver);
1052 }
1053 
1054 module_init(f81232_init);
1055 module_exit(f81232_exit);
1056 
1057 MODULE_DESCRIPTION("Fintek F81232/532A/534A/535/536 USB to serial driver");
1058 MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@linuxfoundation.org>");
1059 MODULE_AUTHOR("Peter Hong <peter_hong@fintek.com.tw>");
1060 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!