drivers/usb/serial/upd78f0730.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Renesas Electronics uPD78F0730 USB to serial converter driver
   4  *
   5  * Copyright (C) 2014,2016 Maksim Salau <maksim.salau@gmail.com>
   6  *
   7  * Protocol of the adaptor is described in the application note U19660EJ1V0AN00
   8  * μPD78F0730 8-bit Single-Chip Microcontroller
   9  * USB-to-Serial Conversion Software
  10  * <https://www.renesas.com/en-eu/doc/DocumentServer/026/U19660EJ1V0AN00.pdf>
  11  *
  12  * The adaptor functionality is limited to the following:
  13  * - data bits: 7 or 8
  14  * - stop bits: 1 or 2
  15  * - parity: even, odd or none
  16  * - flow control: none
  17  * - baud rates: 0, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 153600
  18  * - signals: DTR, RTS and BREAK
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/slab.h>
  23 #include <linux/tty.h>
  24 #include <linux/usb.h>
  25 #include <linux/usb/serial.h>
  26
  27 #define DRIVER_DESC "Renesas uPD78F0730 USB to serial converter driver"
  28
  29 #define DRIVER_AUTHOR "Maksim Salau <maksim.salau@gmail.com>"
  30
  31 static const struct usb_device_id id_table[] = {
  32         { USB_DEVICE(0x0409, 0x0063) }, /* V850ESJX3-STICK */
  33         { USB_DEVICE(0x045B, 0x0212) }, /* YRPBRL78G13, YRPBRL78G14 */
  34         { USB_DEVICE(0x064B, 0x7825) }, /* Analog Devices EVAL-ADXL362Z-DB */
  35         {}
  36 };
  37
  38 MODULE_DEVICE_TABLE(usb, id_table);
  39
  40 /*
  41  * Each adaptor is associated with a private structure, that holds the current
  42  * state of control signals (DTR, RTS and BREAK).
  43  */
  44 struct upd78f0730_port_private {
  45         struct mutex    lock;           /* mutex to protect line_signals */
  46         u8              line_signals;
  47 };
  48
  49 /* Op-codes of control commands */
  50 #define UPD78F0730_CMD_LINE_CONTROL     0x00
  51 #define UPD78F0730_CMD_SET_DTR_RTS      0x01
  52 #define UPD78F0730_CMD_SET_XON_XOFF_CHR 0x02
  53 #define UPD78F0730_CMD_OPEN_CLOSE       0x03
  54 #define UPD78F0730_CMD_SET_ERR_CHR      0x04
  55
  56 /* Data sizes in UPD78F0730_CMD_LINE_CONTROL command */
  57 #define UPD78F0730_DATA_SIZE_7_BITS     0x00
  58 #define UPD78F0730_DATA_SIZE_8_BITS     0x01
  59 #define UPD78F0730_DATA_SIZE_MASK       0x01
  60
  61 /* Stop-bit modes in UPD78F0730_CMD_LINE_CONTROL command */
  62 #define UPD78F0730_STOP_BIT_1_BIT       0x00
  63 #define UPD78F0730_STOP_BIT_2_BIT       0x02
  64 #define UPD78F0730_STOP_BIT_MASK        0x02
  65
  66 /* Parity modes in UPD78F0730_CMD_LINE_CONTROL command */
  67 #define UPD78F0730_PARITY_NONE  0x00
  68 #define UPD78F0730_PARITY_EVEN  0x04
  69 #define UPD78F0730_PARITY_ODD   0x08
  70 #define UPD78F0730_PARITY_MASK  0x0C
  71
  72 /* Flow control modes in UPD78F0730_CMD_LINE_CONTROL command */
  73 #define UPD78F0730_FLOW_CONTROL_NONE    0x00
  74 #define UPD78F0730_FLOW_CONTROL_HW      0x10
  75 #define UPD78F0730_FLOW_CONTROL_SW      0x20
  76 #define UPD78F0730_FLOW_CONTROL_MASK    0x30
  77
  78 /* Control signal bits in UPD78F0730_CMD_SET_DTR_RTS command */
  79 #define UPD78F0730_RTS          0x01
  80 #define UPD78F0730_DTR          0x02
  81 #define UPD78F0730_BREAK        0x04
  82
  83 /* Port modes in UPD78F0730_CMD_OPEN_CLOSE command */
  84 #define UPD78F0730_PORT_CLOSE   0x00
  85 #define UPD78F0730_PORT_OPEN    0x01
  86
  87 /* Error character substitution modes in UPD78F0730_CMD_SET_ERR_CHR command */
  88 #define UPD78F0730_ERR_CHR_DISABLED     0x00
  89 #define UPD78F0730_ERR_CHR_ENABLED      0x01
  90
  91 /*
  92  * Declaration of command structures
  93  */
  94
  95 /* UPD78F0730_CMD_LINE_CONTROL command */
  96 struct upd78f0730_line_control {
  97         u8      opcode;
  98         __le32  baud_rate;
  99         u8      params;
 100 } __packed;
 101
 102 /* UPD78F0730_CMD_SET_DTR_RTS command */
 103 struct upd78f0730_set_dtr_rts {
 104         u8 opcode;
 105         u8 params;
 106 };
 107
 108 /* UPD78F0730_CMD_SET_XON_OFF_CHR command */
 109 struct upd78f0730_set_xon_xoff_chr {
 110         u8 opcode;
 111         u8 xon;
 112         u8 xoff;
 113 };
 114
 115 /* UPD78F0730_CMD_OPEN_CLOSE command */
 116 struct upd78f0730_open_close {
 117         u8 opcode;
 118         u8 state;
 119 };
 120
 121 /* UPD78F0730_CMD_SET_ERR_CHR command */
 122 struct upd78f0730_set_err_chr {
 123         u8 opcode;
 124         u8 state;
 125         u8 err_char;
 126 };
 127
 128 static int upd78f0730_send_ctl(struct usb_serial_port *port,
 129                         const void *data, int size)
 130 {
 131         struct usb_device *usbdev = port->serial->dev;
 132         void *buf;
 133         int res;
 134
 135         if (size <= 0 || !data)
 136                 return -EINVAL;
 137
 138         buf = kmemdup(data, size, GFP_KERNEL);
 139         if (!buf)
 140                 return -ENOMEM;
 141
 142         res = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x00,
 143                         USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 144                         0x0000, 0x0000, buf, size, USB_CTRL_SET_TIMEOUT);
 145
 146         kfree(buf);
 147
 148         if (res != size) {
 149                 struct device *dev = &port->dev;
 150
 151                 dev_err(dev, "failed to send control request %02x: %d\n",
 152                         *(u8 *)data, res);
 153                 /* The maximum expected length of a transfer is 6 bytes */
 154                 if (res >= 0)
 155                         res = -EIO;
 156
 157                 return res;
 158         }
 159
 160         return 0;
 161 }
 162
 163 static int upd78f0730_port_probe(struct usb_serial_port *port)
 164 {
 165         struct upd78f0730_port_private *private;
 166
 167         private = kzalloc(sizeof(*private), GFP_KERNEL);
 168         if (!private)
 169                 return -ENOMEM;
 170
 171         mutex_init(&private->lock);
 172         usb_set_serial_port_data(port, private);
 173
 174         return 0;
 175 }
 176
 177 static int upd78f0730_port_remove(struct usb_serial_port *port)
 178 {
 179         struct upd78f0730_port_private *private;
 180
 181         private = usb_get_serial_port_data(port);
 182         mutex_destroy(&private->lock);
 183         kfree(private);
 184
 185         return 0;
 186 }
 187
 188 static int upd78f0730_tiocmget(struct tty_struct *tty)
 189 {
 190         struct device *dev = tty->dev;
 191         struct upd78f0730_port_private *private;
 192         struct usb_serial_port *port = tty->driver_data;
 193         int signals;
 194         int res;
 195
 196         private = usb_get_serial_port_data(port);
 197
 198         mutex_lock(&private->lock);
 199         signals = private->line_signals;
 200         mutex_unlock(&private->lock);
 201
 202         res = ((signals & UPD78F0730_DTR) ? TIOCM_DTR : 0) |
 203                 ((signals & UPD78F0730_RTS) ? TIOCM_RTS : 0);
 204
 205         dev_dbg(dev, "%s - res = %x\n", __func__, res);
 206
 207         return res;
 208 }
 209
 210 static int upd78f0730_tiocmset(struct tty_struct *tty,
 211                         unsigned int set, unsigned int clear)
 212 {
 213         struct device *dev = tty->dev;
 214         struct usb_serial_port *port = tty->driver_data;
 215         struct upd78f0730_port_private *private;
 216         struct upd78f0730_set_dtr_rts request;
 217         int res;
 218
 219         private = usb_get_serial_port_data(port);
 220
 221         mutex_lock(&private->lock);
 222         if (set & TIOCM_DTR) {
 223                 private->line_signals |= UPD78F0730_DTR;
 224                 dev_dbg(dev, "%s - set DTR\n", __func__);
 225         }
 226         if (set & TIOCM_RTS) {
 227                 private->line_signals |= UPD78F0730_RTS;
 228                 dev_dbg(dev, "%s - set RTS\n", __func__);
 229         }
 230         if (clear & TIOCM_DTR) {
 231                 private->line_signals &= ~UPD78F0730_DTR;
 232                 dev_dbg(dev, "%s - clear DTR\n", __func__);
 233         }
 234         if (clear & TIOCM_RTS) {
 235                 private->line_signals &= ~UPD78F0730_RTS;
 236                 dev_dbg(dev, "%s - clear RTS\n", __func__);
 237         }
 238         request.opcode = UPD78F0730_CMD_SET_DTR_RTS;
 239         request.params = private->line_signals;
 240
 241         res = upd78f0730_send_ctl(port, &request, sizeof(request));
 242         mutex_unlock(&private->lock);
 243
 244         return res;
 245 }
 246
 247 static void upd78f0730_break_ctl(struct tty_struct *tty, int break_state)
 248 {
 249         struct device *dev = tty->dev;
 250         struct upd78f0730_port_private *private;
 251         struct usb_serial_port *port = tty->driver_data;
 252         struct upd78f0730_set_dtr_rts request;
 253
 254         private = usb_get_serial_port_data(port);
 255
 256         mutex_lock(&private->lock);
 257         if (break_state) {
 258                 private->line_signals |= UPD78F0730_BREAK;
 259                 dev_dbg(dev, "%s - set BREAK\n", __func__);
 260         } else {
 261                 private->line_signals &= ~UPD78F0730_BREAK;
 262                 dev_dbg(dev, "%s - clear BREAK\n", __func__);
 263         }
 264         request.opcode = UPD78F0730_CMD_SET_DTR_RTS;
 265         request.params = private->line_signals;
 266
 267         upd78f0730_send_ctl(port, &request, sizeof(request));
 268         mutex_unlock(&private->lock);
 269 }
 270
 271 static void upd78f0730_dtr_rts(struct usb_serial_port *port, int on)
 272 {
 273         struct tty_struct *tty = port->port.tty;
 274         unsigned int set = 0;
 275         unsigned int clear = 0;
 276
 277         if (on)
 278                 set = TIOCM_DTR | TIOCM_RTS;
 279         else
 280                 clear = TIOCM_DTR | TIOCM_RTS;
 281
 282         upd78f0730_tiocmset(tty, set, clear);
 283 }
 284
 285 static speed_t upd78f0730_get_baud_rate(struct tty_struct *tty)
 286 {
 287         const speed_t baud_rate = tty_get_baud_rate(tty);
 288         static const speed_t supported[] = {
 289                 0, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 153600
 290         };
 291         int i;
 292
 293         for (i = ARRAY_SIZE(supported) - 1; i >= 0; i--) {
 294                 if (baud_rate == supported[i])
 295                         return baud_rate;
 296         }
 297
 298         /* If the baud rate is not supported, switch to the default one */
 299         tty_encode_baud_rate(tty, 9600, 9600);
 300
 301         return tty_get_baud_rate(tty);
 302 }
 303
 304 static void upd78f0730_set_termios(struct tty_struct *tty,
 305                                 struct usb_serial_port *port,
 306                                 struct ktermios *old_termios)
 307 {
 308         struct device *dev = &port->dev;
 309         struct upd78f0730_line_control request;
 310         speed_t baud_rate;
 311
 312         if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
 313                 return;
 314
 315         if (C_BAUD(tty) == B0)
 316                 upd78f0730_dtr_rts(port, 0);
 317         else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
 318                 upd78f0730_dtr_rts(port, 1);
 319
 320         baud_rate = upd78f0730_get_baud_rate(tty);
 321         request.opcode = UPD78F0730_CMD_LINE_CONTROL;
 322         request.baud_rate = cpu_to_le32(baud_rate);
 323         request.params = 0;
 324         dev_dbg(dev, "%s - baud rate = %d\n", __func__, baud_rate);
 325
 326         switch (C_CSIZE(tty)) {
 327         case CS7:
 328                 request.params |= UPD78F0730_DATA_SIZE_7_BITS;
 329                 dev_dbg(dev, "%s - 7 data bits\n", __func__);
 330                 break;
 331         default:
 332                 tty->termios.c_cflag &= ~CSIZE;
 333                 tty->termios.c_cflag |= CS8;
 334                 dev_warn(dev, "data size is not supported, using 8 bits\n");
 335                 fallthrough;
 336         case CS8:
 337                 request.params |= UPD78F0730_DATA_SIZE_8_BITS;
 338                 dev_dbg(dev, "%s - 8 data bits\n", __func__);
 339                 break;
 340         }
 341
 342         if (C_PARENB(tty)) {
 343                 if (C_PARODD(tty)) {
 344                         request.params |= UPD78F0730_PARITY_ODD;
 345                         dev_dbg(dev, "%s - odd parity\n", __func__);
 346                 } else {
 347                         request.params |= UPD78F0730_PARITY_EVEN;
 348                         dev_dbg(dev, "%s - even parity\n", __func__);
 349                 }
 350
 351                 if (C_CMSPAR(tty)) {
 352                         tty->termios.c_cflag &= ~CMSPAR;
 353                         dev_warn(dev, "MARK/SPACE parity is not supported\n");
 354                 }
 355         } else {
 356                 request.params |= UPD78F0730_PARITY_NONE;
 357                 dev_dbg(dev, "%s - no parity\n", __func__);
 358         }
 359
 360         if (C_CSTOPB(tty)) {
 361                 request.params |= UPD78F0730_STOP_BIT_2_BIT;
 362                 dev_dbg(dev, "%s - 2 stop bits\n", __func__);
 363         } else {
 364                 request.params |= UPD78F0730_STOP_BIT_1_BIT;
 365                 dev_dbg(dev, "%s - 1 stop bit\n", __func__);
 366         }
 367
 368         if (C_CRTSCTS(tty)) {
 369                 tty->termios.c_cflag &= ~CRTSCTS;
 370                 dev_warn(dev, "RTSCTS flow control is not supported\n");
 371         }
 372         if (I_IXOFF(tty) || I_IXON(tty)) {
 373                 tty->termios.c_iflag &= ~(IXOFF | IXON);
 374                 dev_warn(dev, "XON/XOFF flow control is not supported\n");
 375         }
 376         request.params |= UPD78F0730_FLOW_CONTROL_NONE;
 377         dev_dbg(dev, "%s - no flow control\n", __func__);
 378
 379         upd78f0730_send_ctl(port, &request, sizeof(request));
 380 }
 381
 382 static int upd78f0730_open(struct tty_struct *tty, struct usb_serial_port *port)
 383 {
 384         static const struct upd78f0730_open_close request = {
 385                 .opcode = UPD78F0730_CMD_OPEN_CLOSE,
 386                 .state = UPD78F0730_PORT_OPEN
 387         };
 388         int res;
 389
 390         res = upd78f0730_send_ctl(port, &request, sizeof(request));
 391         if (res)
 392                 return res;
 393
 394         if (tty)
 395                 upd78f0730_set_termios(tty, port, NULL);
 396
 397         return usb_serial_generic_open(tty, port);
 398 }
 399
 400 static void upd78f0730_close(struct usb_serial_port *port)
 401 {
 402         static const struct upd78f0730_open_close request = {
 403                 .opcode = UPD78F0730_CMD_OPEN_CLOSE,
 404                 .state = UPD78F0730_PORT_CLOSE
 405         };
 406
 407         usb_serial_generic_close(port);
 408         upd78f0730_send_ctl(port, &request, sizeof(request));
 409 }
 410
 411 static struct usb_serial_driver upd78f0730_device = {
 412         .driver  = {
 413                 .owner  = THIS_MODULE,
 414                 .name   = "upd78f0730",
 415         },
 416         .id_table       = id_table,
 417         .num_ports      = 1,
 418         .port_probe     = upd78f0730_port_probe,
 419         .port_remove    = upd78f0730_port_remove,
 420         .open           = upd78f0730_open,
 421         .close          = upd78f0730_close,
 422         .set_termios    = upd78f0730_set_termios,
 423         .tiocmget       = upd78f0730_tiocmget,
 424         .tiocmset       = upd78f0730_tiocmset,
 425         .dtr_rts        = upd78f0730_dtr_rts,
 426         .break_ctl      = upd78f0730_break_ctl,
 427 };
 428
 429 static struct usb_serial_driver * const serial_drivers[] = {
 430         &upd78f0730_device,
 431         NULL
 432 };
 433
 434 module_usb_serial_driver(serial_drivers, id_table);
 435
 436 MODULE_DESCRIPTION(DRIVER_DESC);
 437 MODULE_AUTHOR(DRIVER_AUTHOR);
 438 MODULE_LICENSE("GPL v2");