drivers/usb/serial/kl5kusb105.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * KLSI KL5KUSB105 chip RS232 converter driver
   4  *
   5  *   Copyright (C) 2010 Johan Hovold <jhovold@gmail.com>
   6  *   Copyright (C) 2001 Utz-Uwe Haus <haus@uuhaus.de>
   7  *
   8  *   This program is free software; you can redistribute it and/or modify
   9  *   it under the terms of the GNU General Public License as published by
  10  *   the Free Software Foundation; either version 2 of the License, or
  11  *   (at your option) any later version.
  12  *
  13  * All information about the device was acquired using SniffUSB ans snoopUSB
  14  * on Windows98.
  15  * It was written out of frustration with the PalmConnect USB Serial adapter
  16  * sold by Palm Inc.
  17  * Neither Palm, nor their contractor (MCCI) or their supplier (KLSI) provided
  18  * information that was not already available.
  19  *
  20  * It seems that KLSI bought some silicon-design information from ScanLogic,
  21  * whose SL11R processor is at the core of the KL5KUSB chipset from KLSI.
  22  * KLSI has firmware available for their devices; it is probable that the
  23  * firmware differs from that used by KLSI in their products. If you have an
  24  * original KLSI device and can provide some information on it, I would be
  25  * most interested in adding support for it here. If you have any information
  26  * on the protocol used (or find errors in my reverse-engineered stuff), please
  27  * let me know.
  28  *
  29  * The code was only tested with a PalmConnect USB adapter; if you
  30  * are adventurous, try it with any KLSI-based device and let me know how it
  31  * breaks so that I can fix it!
  32  */
  33
  34 /* TODO:
  35  *      check modem line signals
  36  *      implement handshaking or decide that we do not support it
  37  */
  38
  39 #include <linux/kernel.h>
  40 #include <linux/errno.h>
  41 #include <linux/slab.h>
  42 #include <linux/tty.h>
  43 #include <linux/tty_driver.h>
  44 #include <linux/tty_flip.h>
  45 #include <linux/module.h>
  46 #include <linux/uaccess.h>
  47 #include <asm/unaligned.h>
  48 #include <linux/usb.h>
  49 #include <linux/usb/serial.h>
  50 #include "kl5kusb105.h"
  51
  52 #define DRIVER_AUTHOR "Utz-Uwe Haus <haus@uuhaus.de>, Johan Hovold <jhovold@gmail.com>"
  53 #define DRIVER_DESC "KLSI KL5KUSB105 chipset USB->Serial Converter driver"
  54
  55
  56 /*
  57  * Function prototypes
  58  */
  59 static int klsi_105_port_probe(struct usb_serial_port *port);
  60 static int klsi_105_port_remove(struct usb_serial_port *port);
  61 static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port);
  62 static void klsi_105_close(struct usb_serial_port *port);
  63 static void klsi_105_set_termios(struct tty_struct *tty,
  64                         struct usb_serial_port *port, struct ktermios *old);
  65 static int  klsi_105_tiocmget(struct tty_struct *tty);
  66 static void klsi_105_process_read_urb(struct urb *urb);
  67 static int klsi_105_prepare_write_buffer(struct usb_serial_port *port,
  68                                                 void *dest, size_t size);
  69
  70 /*
  71  * All of the device info needed for the KLSI converters.
  72  */
  73 static const struct usb_device_id id_table[] = {
  74         { USB_DEVICE(PALMCONNECT_VID, PALMCONNECT_PID) },
  75         { USB_DEVICE(KLSI_VID, KLSI_KL5KUSB105D_PID) },
  76         { }             /* Terminating entry */
  77 };
  78
  79 MODULE_DEVICE_TABLE(usb, id_table);
  80
  81 static struct usb_serial_driver kl5kusb105d_device = {
  82         .driver = {
  83                 .owner =        THIS_MODULE,
  84                 .name =         "kl5kusb105d",
  85         },
  86         .description =          "KL5KUSB105D / PalmConnect",
  87         .id_table =             id_table,
  88         .num_ports =            1,
  89         .bulk_out_size =        64,
  90         .open =                 klsi_105_open,
  91         .close =                klsi_105_close,
  92         .set_termios =          klsi_105_set_termios,
  93         .tiocmget =             klsi_105_tiocmget,
  94         .port_probe =           klsi_105_port_probe,
  95         .port_remove =          klsi_105_port_remove,
  96         .throttle =             usb_serial_generic_throttle,
  97         .unthrottle =           usb_serial_generic_unthrottle,
  98         .process_read_urb =     klsi_105_process_read_urb,
  99         .prepare_write_buffer = klsi_105_prepare_write_buffer,
 100 };
 101
 102 static struct usb_serial_driver * const serial_drivers[] = {
 103         &kl5kusb105d_device, NULL
 104 };
 105
 106 struct klsi_105_port_settings {
 107         u8      pktlen;         /* always 5, it seems */
 108         u8      baudrate;
 109         u8      databits;
 110         u8      unknown1;
 111         u8      unknown2;
 112 };
 113
 114 struct klsi_105_private {
 115         struct klsi_105_port_settings   cfg;
 116         unsigned long                   line_state; /* modem line settings */
 117         spinlock_t                      lock;
 118 };
 119
 120
 121 /*
 122  * Handle vendor specific USB requests
 123  */
 124
 125
 126 #define KLSI_TIMEOUT     5000 /* default urb timeout */
 127
 128 static int klsi_105_chg_port_settings(struct usb_serial_port *port,
 129                                       struct klsi_105_port_settings *settings)
 130 {
 131         int rc;
 132
 133         rc = usb_control_msg(port->serial->dev,
 134                         usb_sndctrlpipe(port->serial->dev, 0),
 135                         KL5KUSB105A_SIO_SET_DATA,
 136                         USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_INTERFACE,
 137                         0, /* value */
 138                         0, /* index */
 139                         settings,
 140                         sizeof(struct klsi_105_port_settings),
 141                         KLSI_TIMEOUT);
 142         if (rc < 0)
 143                 dev_err(&port->dev,
 144                         "Change port settings failed (error = %d)\n", rc);
 145
 146         dev_dbg(&port->dev,
 147                 "pktlen %u, baudrate 0x%02x, databits %u, u1 %u, u2 %u\n",
 148                 settings->pktlen, settings->baudrate, settings->databits,
 149                 settings->unknown1, settings->unknown2);
 150
 151         return rc;
 152 }
 153
 154 /* translate a 16-bit status value from the device to linux's TIO bits */
 155 static unsigned long klsi_105_status2linestate(const __u16 status)
 156 {
 157         unsigned long res = 0;
 158
 159         res =   ((status & KL5KUSB105A_DSR) ? TIOCM_DSR : 0)
 160               | ((status & KL5KUSB105A_CTS) ? TIOCM_CTS : 0)
 161               ;
 162
 163         return res;
 164 }
 165
 166 /*
 167  * Read line control via vendor command and return result through
 168  * *line_state_p
 169  */
 170 /* It seems that the status buffer has always only 2 bytes length */
 171 #define KLSI_STATUSBUF_LEN      2
 172 static int klsi_105_get_line_state(struct usb_serial_port *port,
 173                                    unsigned long *line_state_p)
 174 {
 175         int rc;
 176         u8 *status_buf;
 177         __u16 status;
 178
 179         status_buf = kmalloc(KLSI_STATUSBUF_LEN, GFP_KERNEL);
 180         if (!status_buf)
 181                 return -ENOMEM;
 182
 183         status_buf[0] = 0xff;
 184         status_buf[1] = 0xff;
 185         rc = usb_control_msg(port->serial->dev,
 186                              usb_rcvctrlpipe(port->serial->dev, 0),
 187                              KL5KUSB105A_SIO_POLL,
 188                              USB_TYPE_VENDOR | USB_DIR_IN,
 189                              0, /* value */
 190                              0, /* index */
 191                              status_buf, KLSI_STATUSBUF_LEN,
 192                              10000
 193                              );
 194         if (rc != KLSI_STATUSBUF_LEN) {
 195                 dev_err(&port->dev, "reading line status failed: %d\n", rc);
 196                 if (rc >= 0)
 197                         rc = -EIO;
 198         } else {
 199                 status = get_unaligned_le16(status_buf);
 200
 201                 dev_dbg(&port->dev, "read status %02x %02x\n",
 202                         status_buf[0], status_buf[1]);
 203
 204                 *line_state_p = klsi_105_status2linestate(status);
 205         }
 206
 207         kfree(status_buf);
 208         return rc;
 209 }
 210
 211
 212 /*
 213  * Driver's tty interface functions
 214  */
 215
 216 static int klsi_105_port_probe(struct usb_serial_port *port)
 217 {
 218         struct klsi_105_private *priv;
 219
 220         priv = kmalloc(sizeof(*priv), GFP_KERNEL);
 221         if (!priv)
 222                 return -ENOMEM;
 223
 224         /* set initial values for control structures */
 225         priv->cfg.pktlen    = 5;
 226         priv->cfg.baudrate  = kl5kusb105a_sio_b9600;
 227         priv->cfg.databits  = kl5kusb105a_dtb_8;
 228         priv->cfg.unknown1  = 0;
 229         priv->cfg.unknown2  = 1;
 230
 231         priv->line_state    = 0;
 232
 233         spin_lock_init(&priv->lock);
 234
 235         usb_set_serial_port_data(port, priv);
 236
 237         return 0;
 238 }
 239
 240 static int klsi_105_port_remove(struct usb_serial_port *port)
 241 {
 242         struct klsi_105_private *priv;
 243
 244         priv = usb_get_serial_port_data(port);
 245         kfree(priv);
 246
 247         return 0;
 248 }
 249
 250 static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
 251 {
 252         struct klsi_105_private *priv = usb_get_serial_port_data(port);
 253         int retval = 0;
 254         int rc;
 255         unsigned long line_state;
 256         struct klsi_105_port_settings *cfg;
 257         unsigned long flags;
 258
 259         /* Do a defined restart:
 260          * Set up sane default baud rate and send the 'READ_ON'
 261          * vendor command.
 262          * FIXME: set modem line control (how?)
 263          * Then read the modem line control and store values in
 264          * priv->line_state.
 265          */
 266         cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
 267         if (!cfg)
 268                 return -ENOMEM;
 269
 270         cfg->pktlen   = 5;
 271         cfg->baudrate = kl5kusb105a_sio_b9600;
 272         cfg->databits = kl5kusb105a_dtb_8;
 273         cfg->unknown1 = 0;
 274         cfg->unknown2 = 1;
 275         klsi_105_chg_port_settings(port, cfg);
 276
 277         spin_lock_irqsave(&priv->lock, flags);
 278         priv->cfg.pktlen   = cfg->pktlen;
 279         priv->cfg.baudrate = cfg->baudrate;
 280         priv->cfg.databits = cfg->databits;
 281         priv->cfg.unknown1 = cfg->unknown1;
 282         priv->cfg.unknown2 = cfg->unknown2;
 283         spin_unlock_irqrestore(&priv->lock, flags);
 284
 285         /* READ_ON and urb submission */
 286         rc = usb_serial_generic_open(tty, port);
 287         if (rc) {
 288                 retval = rc;
 289                 goto err_free_cfg;
 290         }
 291
 292         rc = usb_control_msg(port->serial->dev,
 293                              usb_sndctrlpipe(port->serial->dev, 0),
 294                              KL5KUSB105A_SIO_CONFIGURE,
 295                              USB_TYPE_VENDOR|USB_DIR_OUT|USB_RECIP_INTERFACE,
 296                              KL5KUSB105A_SIO_CONFIGURE_READ_ON,
 297                              0, /* index */
 298                              NULL,
 299                              0,
 300                              KLSI_TIMEOUT);
 301         if (rc < 0) {
 302                 dev_err(&port->dev, "Enabling read failed (error = %d)\n", rc);
 303                 retval = rc;
 304                 goto err_generic_close;
 305         } else
 306                 dev_dbg(&port->dev, "%s - enabled reading\n", __func__);
 307
 308         rc = klsi_105_get_line_state(port, &line_state);
 309         if (rc < 0) {
 310                 retval = rc;
 311                 goto err_disable_read;
 312         }
 313
 314         spin_lock_irqsave(&priv->lock, flags);
 315         priv->line_state = line_state;
 316         spin_unlock_irqrestore(&priv->lock, flags);
 317         dev_dbg(&port->dev, "%s - read line state 0x%lx\n", __func__,
 318                         line_state);
 319
 320         return 0;
 321
 322 err_disable_read:
 323         usb_control_msg(port->serial->dev,
 324                              usb_sndctrlpipe(port->serial->dev, 0),
 325                              KL5KUSB105A_SIO_CONFIGURE,
 326                              USB_TYPE_VENDOR | USB_DIR_OUT,
 327                              KL5KUSB105A_SIO_CONFIGURE_READ_OFF,
 328                              0, /* index */
 329                              NULL, 0,
 330                              KLSI_TIMEOUT);
 331 err_generic_close:
 332         usb_serial_generic_close(port);
 333 err_free_cfg:
 334         kfree(cfg);
 335
 336         return retval;
 337 }
 338
 339 static void klsi_105_close(struct usb_serial_port *port)
 340 {
 341         int rc;
 342
 343         /* send READ_OFF */
 344         rc = usb_control_msg(port->serial->dev,
 345                              usb_sndctrlpipe(port->serial->dev, 0),
 346                              KL5KUSB105A_SIO_CONFIGURE,
 347                              USB_TYPE_VENDOR | USB_DIR_OUT,
 348                              KL5KUSB105A_SIO_CONFIGURE_READ_OFF,
 349                              0, /* index */
 350                              NULL, 0,
 351                              KLSI_TIMEOUT);
 352         if (rc < 0)
 353                 dev_err(&port->dev, "failed to disable read: %d\n", rc);
 354
 355         /* shutdown our bulk reads and writes */
 356         usb_serial_generic_close(port);
 357 }
 358
 359 /* We need to write a complete 64-byte data block and encode the
 360  * number actually sent in the first double-byte, LSB-order. That
 361  * leaves at most 62 bytes of payload.
 362  */
 363 #define KLSI_HDR_LEN            2
 364 static int klsi_105_prepare_write_buffer(struct usb_serial_port *port,
 365                                                 void *dest, size_t size)
 366 {
 367         unsigned char *buf = dest;
 368         int count;
 369
 370         count = kfifo_out_locked(&port->write_fifo, buf + KLSI_HDR_LEN, size,
 371                                                                 &port->lock);
 372         put_unaligned_le16(count, buf);
 373
 374         return count + KLSI_HDR_LEN;
 375 }
 376
 377 /* The data received is preceded by a length double-byte in LSB-first order.
 378  */
 379 static void klsi_105_process_read_urb(struct urb *urb)
 380 {
 381         struct usb_serial_port *port = urb->context;
 382         unsigned char *data = urb->transfer_buffer;
 383         unsigned len;
 384
 385         /* empty urbs seem to happen, we ignore them */
 386         if (!urb->actual_length)
 387                 return;
 388
 389         if (urb->actual_length <= KLSI_HDR_LEN) {
 390                 dev_dbg(&port->dev, "%s - malformed packet\n", __func__);
 391                 return;
 392         }
 393
 394         len = get_unaligned_le16(data);
 395         if (len > urb->actual_length - KLSI_HDR_LEN) {
 396                 dev_dbg(&port->dev, "%s - packet length mismatch\n", __func__);
 397                 len = urb->actual_length - KLSI_HDR_LEN;
 398         }
 399
 400         tty_insert_flip_string(&port->port, data + KLSI_HDR_LEN, len);
 401         tty_flip_buffer_push(&port->port);
 402 }
 403
 404 static void klsi_105_set_termios(struct tty_struct *tty,
 405                                  struct usb_serial_port *port,
 406                                  struct ktermios *old_termios)
 407 {
 408         struct klsi_105_private *priv = usb_get_serial_port_data(port);
 409         struct device *dev = &port->dev;
 410         unsigned int iflag = tty->termios.c_iflag;
 411         unsigned int old_iflag = old_termios->c_iflag;
 412         unsigned int cflag = tty->termios.c_cflag;
 413         unsigned int old_cflag = old_termios->c_cflag;
 414         struct klsi_105_port_settings *cfg;
 415         unsigned long flags;
 416         speed_t baud;
 417
 418         cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
 419         if (!cfg)
 420                 return;
 421
 422         /* lock while we are modifying the settings */
 423         spin_lock_irqsave(&priv->lock, flags);
 424
 425         /*
 426          * Update baud rate
 427          */
 428         baud = tty_get_baud_rate(tty);
 429
 430         switch (baud) {
 431         case 0: /* handled below */
 432                 break;
 433         case 1200:
 434                 priv->cfg.baudrate = kl5kusb105a_sio_b1200;
 435                 break;
 436         case 2400:
 437                 priv->cfg.baudrate = kl5kusb105a_sio_b2400;
 438                 break;
 439         case 4800:
 440                 priv->cfg.baudrate = kl5kusb105a_sio_b4800;
 441                 break;
 442         case 9600:
 443                 priv->cfg.baudrate = kl5kusb105a_sio_b9600;
 444                 break;
 445         case 19200:
 446                 priv->cfg.baudrate = kl5kusb105a_sio_b19200;
 447                 break;
 448         case 38400:
 449                 priv->cfg.baudrate = kl5kusb105a_sio_b38400;
 450                 break;
 451         case 57600:
 452                 priv->cfg.baudrate = kl5kusb105a_sio_b57600;
 453                 break;
 454         case 115200:
 455                 priv->cfg.baudrate = kl5kusb105a_sio_b115200;
 456                 break;
 457         default:
 458                 dev_dbg(dev, "unsupported baudrate, using 9600\n");
 459                 priv->cfg.baudrate = kl5kusb105a_sio_b9600;
 460                 baud = 9600;
 461                 break;
 462         }
 463
 464         /*
 465          * FIXME: implement B0 handling
 466          *
 467          * Maybe this should be simulated by sending read disable and read
 468          * enable messages?
 469          */
 470
 471         tty_encode_baud_rate(tty, baud, baud);
 472
 473         if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
 474                 /* set the number of data bits */
 475                 switch (cflag & CSIZE) {
 476                 case CS5:
 477                         dev_dbg(dev, "%s - 5 bits/byte not supported\n", __func__);
 478                         spin_unlock_irqrestore(&priv->lock, flags);
 479                         goto err;
 480                 case CS6:
 481                         dev_dbg(dev, "%s - 6 bits/byte not supported\n", __func__);
 482                         spin_unlock_irqrestore(&priv->lock, flags);
 483                         goto err;
 484                 case CS7:
 485                         priv->cfg.databits = kl5kusb105a_dtb_7;
 486                         break;
 487                 case CS8:
 488                         priv->cfg.databits = kl5kusb105a_dtb_8;
 489                         break;
 490                 default:
 491                         dev_err(dev, "CSIZE was not CS5-CS8, using default of 8\n");
 492                         priv->cfg.databits = kl5kusb105a_dtb_8;
 493                         break;
 494                 }
 495         }
 496
 497         /*
 498          * Update line control register (LCR)
 499          */
 500         if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))
 501             || (cflag & CSTOPB) != (old_cflag & CSTOPB)) {
 502                 /* Not currently supported */
 503                 tty->termios.c_cflag &= ~(PARENB|PARODD|CSTOPB);
 504         }
 505         /*
 506          * Set flow control: well, I do not really now how to handle DTR/RTS.
 507          * Just do what we have seen with SniffUSB on Win98.
 508          */
 509         if ((iflag & IXOFF) != (old_iflag & IXOFF)
 510             || (iflag & IXON) != (old_iflag & IXON)
 511             ||  (cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
 512                 /* Not currently supported */
 513                 tty->termios.c_cflag &= ~CRTSCTS;
 514         }
 515         memcpy(cfg, &priv->cfg, sizeof(*cfg));
 516         spin_unlock_irqrestore(&priv->lock, flags);
 517
 518         /* now commit changes to device */
 519         klsi_105_chg_port_settings(port, cfg);
 520 err:
 521         kfree(cfg);
 522 }
 523
 524 static int klsi_105_tiocmget(struct tty_struct *tty)
 525 {
 526         struct usb_serial_port *port = tty->driver_data;
 527         struct klsi_105_private *priv = usb_get_serial_port_data(port);
 528         unsigned long flags;
 529         int rc;
 530         unsigned long line_state;
 531
 532         rc = klsi_105_get_line_state(port, &line_state);
 533         if (rc < 0) {
 534                 dev_err(&port->dev,
 535                         "Reading line control failed (error = %d)\n", rc);
 536                 /* better return value? EAGAIN? */
 537                 return rc;
 538         }
 539
 540         spin_lock_irqsave(&priv->lock, flags);
 541         priv->line_state = line_state;
 542         spin_unlock_irqrestore(&priv->lock, flags);
 543         dev_dbg(&port->dev, "%s - read line state 0x%lx\n", __func__, line_state);
 544         return (int)line_state;
 545 }
 546
 547 module_usb_serial_driver(serial_drivers, id_table);
 548
 549 MODULE_AUTHOR(DRIVER_AUTHOR);
 550 MODULE_DESCRIPTION(DRIVER_DESC);
 551 MODULE_LICENSE("GPL");