Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * usb-serial driver for Quatech SSU-100
0004  *
0005  * based on ftdi_sio.c and the original serqt_usb.c from Quatech
0006  *
0007  */
0008 
0009 #include <linux/errno.h>
0010 #include <linux/slab.h>
0011 #include <linux/tty.h>
0012 #include <linux/tty_driver.h>
0013 #include <linux/tty_flip.h>
0014 #include <linux/module.h>
0015 #include <linux/serial.h>
0016 #include <linux/usb.h>
0017 #include <linux/usb/serial.h>
0018 #include <linux/serial_reg.h>
0019 #include <linux/uaccess.h>
0020 
0021 #define QT_OPEN_CLOSE_CHANNEL       0xca
0022 #define QT_SET_GET_DEVICE           0xc2
0023 #define QT_SET_GET_REGISTER         0xc0
0024 #define QT_GET_SET_PREBUF_TRIG_LVL  0xcc
0025 #define QT_SET_ATF                  0xcd
0026 #define QT_GET_SET_UART             0xc1
0027 #define QT_TRANSFER_IN              0xc0
0028 #define QT_HW_FLOW_CONTROL_MASK     0xc5
0029 #define QT_SW_FLOW_CONTROL_MASK     0xc6
0030 
0031 #define  SERIAL_MSR_MASK            0xf0
0032 
0033 #define  SERIAL_CRTSCTS ((UART_MCR_RTS << 8) | UART_MSR_CTS)
0034 
0035 #define  SERIAL_EVEN_PARITY         (UART_LCR_PARITY | UART_LCR_EPAR)
0036 
0037 #define  MAX_BAUD_RATE              460800
0038 
0039 #define ATC_DISABLED                0x00
0040 #define DUPMODE_BITS        0xc0
0041 #define RR_BITS             0x03
0042 #define LOOPMODE_BITS       0x41
0043 #define RS232_MODE          0x00
0044 #define RTSCTS_TO_CONNECTOR 0x40
0045 #define CLKS_X4             0x02
0046 #define FULLPWRBIT          0x00000080
0047 #define NEXT_BOARD_POWER_BIT        0x00000004
0048 
0049 #define DRIVER_DESC "Quatech SSU-100 USB to Serial Driver"
0050 
0051 #define USB_VENDOR_ID_QUATECH   0x061d  /* Quatech VID */
0052 #define QUATECH_SSU100  0xC020  /* SSU100 */
0053 
0054 static const struct usb_device_id id_table[] = {
0055     {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU100)},
0056     {}          /* Terminating entry */
0057 };
0058 MODULE_DEVICE_TABLE(usb, id_table);
0059 
0060 struct ssu100_port_private {
0061     spinlock_t status_lock;
0062     u8 shadowLSR;
0063     u8 shadowMSR;
0064 };
0065 
0066 static inline int ssu100_control_msg(struct usb_device *dev,
0067                      u8 request, u16 data, u16 index)
0068 {
0069     return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
0070                    request, 0x40, data, index,
0071                    NULL, 0, 300);
0072 }
0073 
0074 static inline int ssu100_setdevice(struct usb_device *dev, u8 *data)
0075 {
0076     u16 x = ((u16)(data[1] << 8) | (u16)(data[0]));
0077 
0078     return ssu100_control_msg(dev, QT_SET_GET_DEVICE, x, 0);
0079 }
0080 
0081 
0082 static inline int ssu100_getdevice(struct usb_device *dev, u8 *data)
0083 {
0084     int ret;
0085 
0086     ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
0087                   QT_SET_GET_DEVICE, 0xc0, 0, 0,
0088                   data, 3, 300);
0089     if (ret < 3) {
0090         if (ret >= 0)
0091             ret = -EIO;
0092     }
0093 
0094     return ret;
0095 }
0096 
0097 static inline int ssu100_getregister(struct usb_device *dev,
0098                      unsigned short uart,
0099                      unsigned short reg,
0100                      u8 *data)
0101 {
0102     int ret;
0103 
0104     ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
0105                   QT_SET_GET_REGISTER, 0xc0, reg,
0106                   uart, data, sizeof(*data), 300);
0107     if (ret < (int)sizeof(*data)) {
0108         if (ret >= 0)
0109             ret = -EIO;
0110     }
0111 
0112     return ret;
0113 }
0114 
0115 
0116 static inline int ssu100_setregister(struct usb_device *dev,
0117                      unsigned short uart,
0118                      unsigned short reg,
0119                      u16 data)
0120 {
0121     u16 value = (data << 8) | reg;
0122 
0123     return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
0124                    QT_SET_GET_REGISTER, 0x40, value, uart,
0125                    NULL, 0, 300);
0126 
0127 }
0128 
0129 #define set_mctrl(dev, set)     update_mctrl((dev), (set), 0)
0130 #define clear_mctrl(dev, clear) update_mctrl((dev), 0, (clear))
0131 
0132 /* these do not deal with device that have more than 1 port */
0133 static inline int update_mctrl(struct usb_device *dev, unsigned int set,
0134                    unsigned int clear)
0135 {
0136     unsigned urb_value;
0137     int result;
0138 
0139     if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
0140         dev_dbg(&dev->dev, "%s - DTR|RTS not being set|cleared\n", __func__);
0141         return 0;   /* no change */
0142     }
0143 
0144     clear &= ~set;  /* 'set' takes precedence over 'clear' */
0145     urb_value = 0;
0146     if (set & TIOCM_DTR)
0147         urb_value |= UART_MCR_DTR;
0148     if (set & TIOCM_RTS)
0149         urb_value |= UART_MCR_RTS;
0150 
0151     result = ssu100_setregister(dev, 0, UART_MCR, urb_value);
0152     if (result < 0)
0153         dev_dbg(&dev->dev, "%s Error from MODEM_CTRL urb\n", __func__);
0154 
0155     return result;
0156 }
0157 
0158 static int ssu100_initdevice(struct usb_device *dev)
0159 {
0160     u8 *data;
0161     int result = 0;
0162 
0163     data = kzalloc(3, GFP_KERNEL);
0164     if (!data)
0165         return -ENOMEM;
0166 
0167     result = ssu100_getdevice(dev, data);
0168     if (result < 0) {
0169         dev_dbg(&dev->dev, "%s - get_device failed %i\n", __func__, result);
0170         goto out;
0171     }
0172 
0173     data[1] &= ~FULLPWRBIT;
0174 
0175     result = ssu100_setdevice(dev, data);
0176     if (result < 0) {
0177         dev_dbg(&dev->dev, "%s - setdevice failed %i\n", __func__, result);
0178         goto out;
0179     }
0180 
0181     result = ssu100_control_msg(dev, QT_GET_SET_PREBUF_TRIG_LVL, 128, 0);
0182     if (result < 0) {
0183         dev_dbg(&dev->dev, "%s - set prebuffer level failed %i\n", __func__, result);
0184         goto out;
0185     }
0186 
0187     result = ssu100_control_msg(dev, QT_SET_ATF, ATC_DISABLED, 0);
0188     if (result < 0) {
0189         dev_dbg(&dev->dev, "%s - set ATFprebuffer level failed %i\n", __func__, result);
0190         goto out;
0191     }
0192 
0193     result = ssu100_getdevice(dev, data);
0194     if (result < 0) {
0195         dev_dbg(&dev->dev, "%s - get_device failed %i\n", __func__, result);
0196         goto out;
0197     }
0198 
0199     data[0] &= ~(RR_BITS | DUPMODE_BITS);
0200     data[0] |= CLKS_X4;
0201     data[1] &= ~(LOOPMODE_BITS);
0202     data[1] |= RS232_MODE;
0203 
0204     result = ssu100_setdevice(dev, data);
0205     if (result < 0) {
0206         dev_dbg(&dev->dev, "%s - setdevice failed %i\n", __func__, result);
0207         goto out;
0208     }
0209 
0210 out:    kfree(data);
0211     return result;
0212 
0213 }
0214 
0215 
0216 static void ssu100_set_termios(struct tty_struct *tty,
0217                    struct usb_serial_port *port,
0218                    struct ktermios *old_termios)
0219 {
0220     struct usb_device *dev = port->serial->dev;
0221     struct ktermios *termios = &tty->termios;
0222     u16 baud, divisor, remainder;
0223     unsigned int cflag = termios->c_cflag;
0224     u16 urb_value = 0; /* will hold the new flags */
0225     int result;
0226 
0227     if (cflag & PARENB) {
0228         if (cflag & PARODD)
0229             urb_value |= UART_LCR_PARITY;
0230         else
0231             urb_value |= SERIAL_EVEN_PARITY;
0232     }
0233 
0234     urb_value |= UART_LCR_WLEN(tty_get_char_size(cflag));
0235 
0236     baud = tty_get_baud_rate(tty);
0237     if (!baud)
0238         baud = 9600;
0239 
0240     dev_dbg(&port->dev, "%s - got baud = %d\n", __func__, baud);
0241 
0242 
0243     divisor = MAX_BAUD_RATE / baud;
0244     remainder = MAX_BAUD_RATE % baud;
0245     if (((remainder * 2) >= baud) && (baud != 110))
0246         divisor++;
0247 
0248     urb_value = urb_value << 8;
0249 
0250     result = ssu100_control_msg(dev, QT_GET_SET_UART, divisor, urb_value);
0251     if (result < 0)
0252         dev_dbg(&port->dev, "%s - set uart failed\n", __func__);
0253 
0254     if (cflag & CRTSCTS)
0255         result = ssu100_control_msg(dev, QT_HW_FLOW_CONTROL_MASK,
0256                         SERIAL_CRTSCTS, 0);
0257     else
0258         result = ssu100_control_msg(dev, QT_HW_FLOW_CONTROL_MASK,
0259                         0, 0);
0260     if (result < 0)
0261         dev_dbg(&port->dev, "%s - set HW flow control failed\n", __func__);
0262 
0263     if (I_IXOFF(tty) || I_IXON(tty)) {
0264         u16 x = ((u16)(START_CHAR(tty) << 8) | (u16)(STOP_CHAR(tty)));
0265 
0266         result = ssu100_control_msg(dev, QT_SW_FLOW_CONTROL_MASK,
0267                         x, 0);
0268     } else
0269         result = ssu100_control_msg(dev, QT_SW_FLOW_CONTROL_MASK,
0270                         0, 0);
0271 
0272     if (result < 0)
0273         dev_dbg(&port->dev, "%s - set SW flow control failed\n", __func__);
0274 
0275 }
0276 
0277 
0278 static int ssu100_open(struct tty_struct *tty, struct usb_serial_port *port)
0279 {
0280     struct usb_device *dev = port->serial->dev;
0281     struct ssu100_port_private *priv = usb_get_serial_port_data(port);
0282     u8 *data;
0283     int result;
0284     unsigned long flags;
0285 
0286     data = kzalloc(2, GFP_KERNEL);
0287     if (!data)
0288         return -ENOMEM;
0289 
0290     result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
0291                  QT_OPEN_CLOSE_CHANNEL,
0292                  QT_TRANSFER_IN, 0x01,
0293                  0, data, 2, 300);
0294     if (result < 2) {
0295         dev_dbg(&port->dev, "%s - open failed %i\n", __func__, result);
0296         if (result >= 0)
0297             result = -EIO;
0298         kfree(data);
0299         return result;
0300     }
0301 
0302     spin_lock_irqsave(&priv->status_lock, flags);
0303     priv->shadowLSR = data[0];
0304     priv->shadowMSR = data[1];
0305     spin_unlock_irqrestore(&priv->status_lock, flags);
0306 
0307     kfree(data);
0308 
0309 /* set to 9600 */
0310     result = ssu100_control_msg(dev, QT_GET_SET_UART, 0x30, 0x0300);
0311     if (result < 0)
0312         dev_dbg(&port->dev, "%s - set uart failed\n", __func__);
0313 
0314     if (tty)
0315         ssu100_set_termios(tty, port, &tty->termios);
0316 
0317     return usb_serial_generic_open(tty, port);
0318 }
0319 
0320 static int ssu100_attach(struct usb_serial *serial)
0321 {
0322     return ssu100_initdevice(serial->dev);
0323 }
0324 
0325 static int ssu100_port_probe(struct usb_serial_port *port)
0326 {
0327     struct ssu100_port_private *priv;
0328 
0329     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
0330     if (!priv)
0331         return -ENOMEM;
0332 
0333     spin_lock_init(&priv->status_lock);
0334 
0335     usb_set_serial_port_data(port, priv);
0336 
0337     return 0;
0338 }
0339 
0340 static void ssu100_port_remove(struct usb_serial_port *port)
0341 {
0342     struct ssu100_port_private *priv;
0343 
0344     priv = usb_get_serial_port_data(port);
0345     kfree(priv);
0346 }
0347 
0348 static int ssu100_tiocmget(struct tty_struct *tty)
0349 {
0350     struct usb_serial_port *port = tty->driver_data;
0351     struct usb_device *dev = port->serial->dev;
0352     u8 *d;
0353     int r;
0354 
0355     d = kzalloc(2, GFP_KERNEL);
0356     if (!d)
0357         return -ENOMEM;
0358 
0359     r = ssu100_getregister(dev, 0, UART_MCR, d);
0360     if (r < 0)
0361         goto mget_out;
0362 
0363     r = ssu100_getregister(dev, 0, UART_MSR, d+1);
0364     if (r < 0)
0365         goto mget_out;
0366 
0367     r = (d[0] & UART_MCR_DTR ? TIOCM_DTR : 0) |
0368         (d[0] & UART_MCR_RTS ? TIOCM_RTS : 0) |
0369         (d[1] & UART_MSR_CTS ? TIOCM_CTS : 0) |
0370         (d[1] & UART_MSR_DCD ? TIOCM_CAR : 0) |
0371         (d[1] & UART_MSR_RI ? TIOCM_RI : 0) |
0372         (d[1] & UART_MSR_DSR ? TIOCM_DSR : 0);
0373 
0374 mget_out:
0375     kfree(d);
0376     return r;
0377 }
0378 
0379 static int ssu100_tiocmset(struct tty_struct *tty,
0380                unsigned int set, unsigned int clear)
0381 {
0382     struct usb_serial_port *port = tty->driver_data;
0383     struct usb_device *dev = port->serial->dev;
0384 
0385     return update_mctrl(dev, set, clear);
0386 }
0387 
0388 static void ssu100_dtr_rts(struct usb_serial_port *port, int on)
0389 {
0390     struct usb_device *dev = port->serial->dev;
0391 
0392     /* Disable flow control */
0393     if (!on) {
0394         if (ssu100_setregister(dev, 0, UART_MCR, 0) < 0)
0395             dev_err(&port->dev, "error from flowcontrol urb\n");
0396     }
0397     /* drop RTS and DTR */
0398     if (on)
0399         set_mctrl(dev, TIOCM_DTR | TIOCM_RTS);
0400     else
0401         clear_mctrl(dev, TIOCM_DTR | TIOCM_RTS);
0402 }
0403 
0404 static void ssu100_update_msr(struct usb_serial_port *port, u8 msr)
0405 {
0406     struct ssu100_port_private *priv = usb_get_serial_port_data(port);
0407     unsigned long flags;
0408 
0409     spin_lock_irqsave(&priv->status_lock, flags);
0410     priv->shadowMSR = msr;
0411     spin_unlock_irqrestore(&priv->status_lock, flags);
0412 
0413     if (msr & UART_MSR_ANY_DELTA) {
0414         /* update input line counters */
0415         if (msr & UART_MSR_DCTS)
0416             port->icount.cts++;
0417         if (msr & UART_MSR_DDSR)
0418             port->icount.dsr++;
0419         if (msr & UART_MSR_DDCD)
0420             port->icount.dcd++;
0421         if (msr & UART_MSR_TERI)
0422             port->icount.rng++;
0423         wake_up_interruptible(&port->port.delta_msr_wait);
0424     }
0425 }
0426 
0427 static void ssu100_update_lsr(struct usb_serial_port *port, u8 lsr,
0428                   char *tty_flag)
0429 {
0430     struct ssu100_port_private *priv = usb_get_serial_port_data(port);
0431     unsigned long flags;
0432 
0433     spin_lock_irqsave(&priv->status_lock, flags);
0434     priv->shadowLSR = lsr;
0435     spin_unlock_irqrestore(&priv->status_lock, flags);
0436 
0437     *tty_flag = TTY_NORMAL;
0438     if (lsr & UART_LSR_BRK_ERROR_BITS) {
0439         /* we always want to update icount, but we only want to
0440          * update tty_flag for one case */
0441         if (lsr & UART_LSR_BI) {
0442             port->icount.brk++;
0443             *tty_flag = TTY_BREAK;
0444             usb_serial_handle_break(port);
0445         }
0446         if (lsr & UART_LSR_PE) {
0447             port->icount.parity++;
0448             if (*tty_flag == TTY_NORMAL)
0449                 *tty_flag = TTY_PARITY;
0450         }
0451         if (lsr & UART_LSR_FE) {
0452             port->icount.frame++;
0453             if (*tty_flag == TTY_NORMAL)
0454                 *tty_flag = TTY_FRAME;
0455         }
0456         if (lsr & UART_LSR_OE) {
0457             port->icount.overrun++;
0458             tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
0459         }
0460     }
0461 
0462 }
0463 
0464 static void ssu100_process_read_urb(struct urb *urb)
0465 {
0466     struct usb_serial_port *port = urb->context;
0467     char *packet = urb->transfer_buffer;
0468     char flag = TTY_NORMAL;
0469     u32 len = urb->actual_length;
0470     int i;
0471     char *ch;
0472 
0473     if ((len >= 4) &&
0474         (packet[0] == 0x1b) && (packet[1] == 0x1b) &&
0475         ((packet[2] == 0x00) || (packet[2] == 0x01))) {
0476         if (packet[2] == 0x00)
0477             ssu100_update_lsr(port, packet[3], &flag);
0478         if (packet[2] == 0x01)
0479             ssu100_update_msr(port, packet[3]);
0480 
0481         len -= 4;
0482         ch = packet + 4;
0483     } else
0484         ch = packet;
0485 
0486     if (!len)
0487         return; /* status only */
0488 
0489     if (port->sysrq) {
0490         for (i = 0; i < len; i++, ch++) {
0491             if (!usb_serial_handle_sysrq_char(port, *ch))
0492                 tty_insert_flip_char(&port->port, *ch, flag);
0493         }
0494     } else {
0495         tty_insert_flip_string_fixed_flag(&port->port, ch, flag, len);
0496     }
0497 
0498     tty_flip_buffer_push(&port->port);
0499 }
0500 
0501 static struct usb_serial_driver ssu100_device = {
0502     .driver = {
0503         .owner = THIS_MODULE,
0504         .name = "ssu100",
0505     },
0506     .description         = DRIVER_DESC,
0507     .id_table        = id_table,
0508     .num_ports       = 1,
0509     .open            = ssu100_open,
0510     .attach              = ssu100_attach,
0511     .port_probe          = ssu100_port_probe,
0512     .port_remove         = ssu100_port_remove,
0513     .dtr_rts             = ssu100_dtr_rts,
0514     .process_read_urb    = ssu100_process_read_urb,
0515     .tiocmget            = ssu100_tiocmget,
0516     .tiocmset            = ssu100_tiocmset,
0517     .tiocmiwait          = usb_serial_generic_tiocmiwait,
0518     .get_icount      = usb_serial_generic_get_icount,
0519     .set_termios         = ssu100_set_termios,
0520 };
0521 
0522 static struct usb_serial_driver * const serial_drivers[] = {
0523     &ssu100_device, NULL
0524 };
0525 
0526 module_usb_serial_driver(serial_drivers, id_table);
0527 
0528 MODULE_DESCRIPTION(DRIVER_DESC);
0529 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!