drivers/usb/serial/xr_serial.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * MaxLinear/Exar USB to Serial driver
   4  *
   5  * Copyright (c) 2020 Manivannan Sadhasivam <[email protected]>
   6  * Copyright (c) 2021 Johan Hovold <[email protected]>
   7  *
   8  * Based on the initial driver written by Patong Yang:
   9  *
  10  *   https://lore.kernel.org/r/20180404070634.nhspvmxcjwfgjkcv@advantechmxl-desktop
  11  *
  12  *   Copyright (c) 2018 Patong Yang <[email protected]>
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/slab.h>
  18 #include <linux/tty.h>
  19 #include <linux/usb.h>
  20 #include <linux/usb/cdc.h>
  21 #include <linux/usb/serial.h>
  22
  23 struct xr_txrx_clk_mask {
  24         u16 tx;
  25         u16 rx0;
  26         u16 rx1;
  27 };
  28
  29 #define XR_INT_OSC_HZ                   48000000U
  30 #define XR21V141X_MIN_SPEED             46U
  31 #define XR21V141X_MAX_SPEED             XR_INT_OSC_HZ
  32
  33 /* XR21V141X register blocks */
  34 #define XR21V141X_UART_REG_BLOCK        0
  35 #define XR21V141X_UM_REG_BLOCK          4
  36 #define XR21V141X_UART_CUSTOM_BLOCK     0x66
  37
  38 /* XR21V141X UART registers */
  39 #define XR21V141X_CLOCK_DIVISOR_0       0x04
  40 #define XR21V141X_CLOCK_DIVISOR_1       0x05
  41 #define XR21V141X_CLOCK_DIVISOR_2       0x06
  42 #define XR21V141X_TX_CLOCK_MASK_0       0x07
  43 #define XR21V141X_TX_CLOCK_MASK_1       0x08
  44 #define XR21V141X_RX_CLOCK_MASK_0       0x09
  45 #define XR21V141X_RX_CLOCK_MASK_1       0x0a
  46 #define XR21V141X_REG_FORMAT            0x0b
  47
  48 /* XR21V141X UART Manager registers */
  49 #define XR21V141X_UM_FIFO_ENABLE_REG    0x10
  50 #define XR21V141X_UM_ENABLE_TX_FIFO     0x01
  51 #define XR21V141X_UM_ENABLE_RX_FIFO     0x02
  52
  53 #define XR21V141X_UM_RX_FIFO_RESET      0x18
  54 #define XR21V141X_UM_TX_FIFO_RESET      0x1c
  55
  56 #define XR_UART_ENABLE_TX               0x1
  57 #define XR_UART_ENABLE_RX               0x2
  58
  59 #define XR_GPIO_RI                      BIT(0)
  60 #define XR_GPIO_CD                      BIT(1)
  61 #define XR_GPIO_DSR                     BIT(2)
  62 #define XR_GPIO_DTR                     BIT(3)
  63 #define XR_GPIO_CTS                     BIT(4)
  64 #define XR_GPIO_RTS                     BIT(5)
  65 #define XR_GPIO_CLK                     BIT(6)
  66 #define XR_GPIO_XEN                     BIT(7)
  67 #define XR_GPIO_TXT                     BIT(8)
  68 #define XR_GPIO_RXT                     BIT(9)
  69
  70 #define XR_UART_DATA_MASK               GENMASK(3, 0)
  71 #define XR_UART_DATA_7                  0x7
  72 #define XR_UART_DATA_8                  0x8
  73
  74 #define XR_UART_PARITY_MASK             GENMASK(6, 4)
  75 #define XR_UART_PARITY_SHIFT            4
  76 #define XR_UART_PARITY_NONE             (0x0 << XR_UART_PARITY_SHIFT)
  77 #define XR_UART_PARITY_ODD              (0x1 << XR_UART_PARITY_SHIFT)
  78 #define XR_UART_PARITY_EVEN             (0x2 << XR_UART_PARITY_SHIFT)
  79 #define XR_UART_PARITY_MARK             (0x3 << XR_UART_PARITY_SHIFT)
  80 #define XR_UART_PARITY_SPACE            (0x4 << XR_UART_PARITY_SHIFT)
  81
  82 #define XR_UART_STOP_MASK               BIT(7)
  83 #define XR_UART_STOP_SHIFT              7
  84 #define XR_UART_STOP_1                  (0x0 << XR_UART_STOP_SHIFT)
  85 #define XR_UART_STOP_2                  (0x1 << XR_UART_STOP_SHIFT)
  86
  87 #define XR_UART_FLOW_MODE_NONE          0x0
  88 #define XR_UART_FLOW_MODE_HW            0x1
  89 #define XR_UART_FLOW_MODE_SW            0x2
  90
  91 #define XR_GPIO_MODE_SEL_MASK           GENMASK(2, 0)
  92 #define XR_GPIO_MODE_SEL_RTS_CTS        0x1
  93 #define XR_GPIO_MODE_SEL_DTR_DSR        0x2
  94 #define XR_GPIO_MODE_SEL_RS485          0x3
  95 #define XR_GPIO_MODE_SEL_RS485_ADDR     0x4
  96 #define XR_GPIO_MODE_TX_TOGGLE          0x100
  97 #define XR_GPIO_MODE_RX_TOGGLE          0x200
  98
  99 #define XR_FIFO_RESET                   0x1
 100
 101 #define XR_CUSTOM_DRIVER_ACTIVE         0x1
 102
 103 static int xr21v141x_uart_enable(struct usb_serial_port *port);
 104 static int xr21v141x_uart_disable(struct usb_serial_port *port);
 105 static int xr21v141x_fifo_reset(struct usb_serial_port *port);
 106 static void xr21v141x_set_line_settings(struct tty_struct *tty,
 107                                         struct usb_serial_port *port,
 108                                         const struct ktermios *old_termios);
 109
 110 struct xr_type {
 111         int reg_width;
 112         u8 reg_recipient;
 113         u8 set_reg;
 114         u8 get_reg;
 115
 116         u16 uart_enable;
 117         u16 flow_control;
 118         u16 xon_char;
 119         u16 xoff_char;
 120         u16 tx_break;
 121         u16 gpio_mode;
 122         u16 gpio_direction;
 123         u16 gpio_set;
 124         u16 gpio_clear;
 125         u16 gpio_status;
 126         u16 tx_fifo_reset;
 127         u16 rx_fifo_reset;
 128         u16 custom_driver;
 129
 130         bool have_5_6_bit_mode;
 131         bool have_xmit_toggle;
 132
 133         int (*enable)(struct usb_serial_port *port);
 134         int (*disable)(struct usb_serial_port *port);
 135         int (*fifo_reset)(struct usb_serial_port *port);
 136         void (*set_line_settings)(struct tty_struct *tty,
 137                                   struct usb_serial_port *port,
 138                                   const struct ktermios *old_termios);
 139 };
 140
 141 enum xr_type_id {
 142         XR21V141X,
 143         XR21B142X,
 144         XR21B1411,
 145         XR2280X,
 146         XR_TYPE_COUNT,
 147 };
 148
 149 static const struct xr_type xr_types[] = {
 150         [XR21V141X] = {
 151                 .reg_width      = 8,
 152                 .reg_recipient  = USB_RECIP_DEVICE,
 153                 .set_reg        = 0x00,
 154                 .get_reg        = 0x01,
 155
 156                 .uart_enable    = 0x03,
 157                 .flow_control   = 0x0c,
 158                 .xon_char       = 0x10,
 159                 .xoff_char      = 0x11,
 160                 .tx_break       = 0x14,
 161                 .gpio_mode      = 0x1a,
 162                 .gpio_direction = 0x1b,
 163                 .gpio_set       = 0x1d,
 164                 .gpio_clear     = 0x1e,
 165                 .gpio_status    = 0x1f,
 166
 167                 .enable                 = xr21v141x_uart_enable,
 168                 .disable                = xr21v141x_uart_disable,
 169                 .fifo_reset             = xr21v141x_fifo_reset,
 170                 .set_line_settings      = xr21v141x_set_line_settings,
 171         },
 172         [XR21B142X] = {
 173                 .reg_width      = 16,
 174                 .reg_recipient  = USB_RECIP_INTERFACE,
 175                 .set_reg        = 0x00,
 176                 .get_reg        = 0x00,
 177
 178                 .uart_enable    = 0x00,
 179                 .flow_control   = 0x06,
 180                 .xon_char       = 0x07,
 181                 .xoff_char      = 0x08,
 182                 .tx_break       = 0x0a,
 183                 .gpio_mode      = 0x0c,
 184                 .gpio_direction = 0x0d,
 185                 .gpio_set       = 0x0e,
 186                 .gpio_clear     = 0x0f,
 187                 .gpio_status    = 0x10,
 188                 .tx_fifo_reset  = 0x40,
 189                 .rx_fifo_reset  = 0x43,
 190                 .custom_driver  = 0x60,
 191
 192                 .have_5_6_bit_mode      = true,
 193                 .have_xmit_toggle       = true,
 194         },
 195         [XR21B1411] = {
 196                 .reg_width      = 12,
 197                 .reg_recipient  = USB_RECIP_DEVICE,
 198                 .set_reg        = 0x00,
 199                 .get_reg        = 0x01,
 200
 201                 .uart_enable    = 0xc00,
 202                 .flow_control   = 0xc06,
 203                 .xon_char       = 0xc07,
 204                 .xoff_char      = 0xc08,
 205                 .tx_break       = 0xc0a,
 206                 .gpio_mode      = 0xc0c,
 207                 .gpio_direction = 0xc0d,
 208                 .gpio_set       = 0xc0e,
 209                 .gpio_clear     = 0xc0f,
 210                 .gpio_status    = 0xc10,
 211                 .tx_fifo_reset  = 0xc80,
 212                 .rx_fifo_reset  = 0xcc0,
 213                 .custom_driver  = 0x20d,
 214         },
 215         [XR2280X] = {
 216                 .reg_width      = 16,
 217                 .reg_recipient  = USB_RECIP_DEVICE,
 218                 .set_reg        = 0x05,
 219                 .get_reg        = 0x05,
 220
 221                 .uart_enable    = 0x40,
 222                 .flow_control   = 0x46,
 223                 .xon_char       = 0x47,
 224                 .xoff_char      = 0x48,
 225                 .tx_break       = 0x4a,
 226                 .gpio_mode      = 0x4c,
 227                 .gpio_direction = 0x4d,
 228                 .gpio_set       = 0x4e,
 229                 .gpio_clear     = 0x4f,
 230                 .gpio_status    = 0x50,
 231                 .tx_fifo_reset  = 0x60,
 232                 .rx_fifo_reset  = 0x63,
 233                 .custom_driver  = 0x81,
 234         },
 235 };
 236
 237 struct xr_data {
 238         const struct xr_type *type;
 239         u8 channel;                     /* zero-based index or interface number */
 240 };
 241
 242 static int xr_set_reg(struct usb_serial_port *port, u8 channel, u16 reg, u16 val)
 243 {
 244         struct xr_data *data = usb_get_serial_port_data(port);
 245         const struct xr_type *type = data->type;
 246         struct usb_serial *serial = port->serial;
 247         int ret;
 248
 249         ret = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 250                         type->set_reg,
 251                         USB_DIR_OUT | USB_TYPE_VENDOR | type->reg_recipient,
 252                         val, (channel << 8) | reg, NULL, 0,
 253                         USB_CTRL_SET_TIMEOUT);
 254         if (ret < 0) {
 255                 dev_err(&port->dev, "Failed to set reg 0x%02x: %d\n", reg, ret);
 256                 return ret;
 257         }
 258
 259         return 0;
 260 }
 261
 262 static int xr_get_reg(struct usb_serial_port *port, u8 channel, u16 reg, u16 *val)
 263 {
 264         struct xr_data *data = usb_get_serial_port_data(port);
 265         const struct xr_type *type = data->type;
 266         struct usb_serial *serial = port->serial;
 267         u8 *dmabuf;
 268         int ret, len;
 269
 270         if (type->reg_width == 8)
 271                 len = 1;
 272         else
 273                 len = 2;
 274
 275         dmabuf = kmalloc(len, GFP_KERNEL);
 276         if (!dmabuf)
 277                 return -ENOMEM;
 278
 279         ret = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 280                         type->get_reg,
 281                         USB_DIR_IN | USB_TYPE_VENDOR | type->reg_recipient,
 282                         0, (channel << 8) | reg, dmabuf, len,
 283                         USB_CTRL_GET_TIMEOUT);
 284         if (ret == len) {
 285                 if (len == 2)
 286                         *val = le16_to_cpup((__le16 *)dmabuf);
 287                 else
 288                         *val = *dmabuf;
 289                 ret = 0;
 290         } else {
 291                 dev_err(&port->dev, "Failed to get reg 0x%02x: %d\n", reg, ret);
 292                 if (ret >= 0)
 293                         ret = -EIO;
 294         }
 295
 296         kfree(dmabuf);
 297
 298         return ret;
 299 }
 300
 301 static int xr_set_reg_uart(struct usb_serial_port *port, u16 reg, u16 val)
 302 {
 303         struct xr_data *data = usb_get_serial_port_data(port);
 304
 305         return xr_set_reg(port, data->channel, reg, val);
 306 }
 307
 308 static int xr_get_reg_uart(struct usb_serial_port *port, u16 reg, u16 *val)
 309 {
 310         struct xr_data *data = usb_get_serial_port_data(port);
 311
 312         return xr_get_reg(port, data->channel, reg, val);
 313 }
 314
 315 static int xr_set_reg_um(struct usb_serial_port *port, u8 reg_base, u8 val)
 316 {
 317         struct xr_data *data = usb_get_serial_port_data(port);
 318         u8 reg;
 319
 320         reg = reg_base + data->channel;
 321
 322         return xr_set_reg(port, XR21V141X_UM_REG_BLOCK, reg, val);
 323 }
 324
 325 static int __xr_uart_enable(struct usb_serial_port *port)
 326 {
 327         struct xr_data *data = usb_get_serial_port_data(port);
 328
 329         return xr_set_reg_uart(port, data->type->uart_enable,
 330                         XR_UART_ENABLE_TX | XR_UART_ENABLE_RX);
 331 }
 332
 333 static int __xr_uart_disable(struct usb_serial_port *port)
 334 {
 335         struct xr_data *data = usb_get_serial_port_data(port);
 336
 337         return xr_set_reg_uart(port, data->type->uart_enable, 0);
 338 }
 339
 340 /*
 341  * According to datasheet, below is the recommended sequence for enabling UART
 342  * module in XR21V141X:
 343  *
 344  * Enable Tx FIFO
 345  * Enable Tx and Rx
 346  * Enable Rx FIFO
 347  */
 348 static int xr21v141x_uart_enable(struct usb_serial_port *port)
 349 {
 350         int ret;
 351
 352         ret = xr_set_reg_um(port, XR21V141X_UM_FIFO_ENABLE_REG,
 353                             XR21V141X_UM_ENABLE_TX_FIFO);
 354         if (ret)
 355                 return ret;
 356
 357         ret = __xr_uart_enable(port);
 358         if (ret)
 359                 return ret;
 360
 361         ret = xr_set_reg_um(port, XR21V141X_UM_FIFO_ENABLE_REG,
 362                             XR21V141X_UM_ENABLE_TX_FIFO | XR21V141X_UM_ENABLE_RX_FIFO);
 363         if (ret)
 364                 __xr_uart_disable(port);
 365
 366         return ret;
 367 }
 368
 369 static int xr21v141x_uart_disable(struct usb_serial_port *port)
 370 {
 371         int ret;
 372
 373         ret = __xr_uart_disable(port);
 374         if (ret)
 375                 return ret;
 376
 377         ret = xr_set_reg_um(port, XR21V141X_UM_FIFO_ENABLE_REG, 0);
 378
 379         return ret;
 380 }
 381
 382 static int xr_uart_enable(struct usb_serial_port *port)
 383 {
 384         struct xr_data *data = usb_get_serial_port_data(port);
 385
 386         if (data->type->enable)
 387                 return data->type->enable(port);
 388
 389         return __xr_uart_enable(port);
 390 }
 391
 392 static int xr_uart_disable(struct usb_serial_port *port)
 393 {
 394         struct xr_data *data = usb_get_serial_port_data(port);
 395
 396         if (data->type->disable)
 397                 return data->type->disable(port);
 398
 399         return __xr_uart_disable(port);
 400 }
 401
 402 static int xr21v141x_fifo_reset(struct usb_serial_port *port)
 403 {
 404         int ret;
 405
 406         ret = xr_set_reg_um(port, XR21V141X_UM_TX_FIFO_RESET, XR_FIFO_RESET);
 407         if (ret)
 408                 return ret;
 409
 410         ret = xr_set_reg_um(port, XR21V141X_UM_RX_FIFO_RESET, XR_FIFO_RESET);
 411         if (ret)
 412                 return ret;
 413
 414         return 0;
 415 }
 416
 417 static int xr_fifo_reset(struct usb_serial_port *port)
 418 {
 419         struct xr_data *data = usb_get_serial_port_data(port);
 420         int ret;
 421
 422         if (data->type->fifo_reset)
 423                 return data->type->fifo_reset(port);
 424
 425         ret = xr_set_reg_uart(port, data->type->tx_fifo_reset, XR_FIFO_RESET);
 426         if (ret)
 427                 return ret;
 428
 429         ret = xr_set_reg_uart(port, data->type->rx_fifo_reset, XR_FIFO_RESET);
 430         if (ret)
 431                 return ret;
 432
 433         return 0;
 434 }
 435
 436 static int xr_tiocmget(struct tty_struct *tty)
 437 {
 438         struct usb_serial_port *port = tty->driver_data;
 439         struct xr_data *data = usb_get_serial_port_data(port);
 440         u16 status;
 441         int ret;
 442
 443         ret = xr_get_reg_uart(port, data->type->gpio_status, &status);
 444         if (ret)
 445                 return ret;
 446
 447         /*
 448          * Modem control pins are active low, so reading '0' means it is active
 449          * and '1' means not active.
 450          */
 451         ret = ((status & XR_GPIO_DTR) ? 0 : TIOCM_DTR) |
 452               ((status & XR_GPIO_RTS) ? 0 : TIOCM_RTS) |
 453               ((status & XR_GPIO_CTS) ? 0 : TIOCM_CTS) |
 454               ((status & XR_GPIO_DSR) ? 0 : TIOCM_DSR) |
 455               ((status & XR_GPIO_RI) ? 0 : TIOCM_RI) |
 456               ((status & XR_GPIO_CD) ? 0 : TIOCM_CD);
 457
 458         return ret;
 459 }
 460
 461 static int xr_tiocmset_port(struct usb_serial_port *port,
 462                             unsigned int set, unsigned int clear)
 463 {
 464         struct xr_data *data = usb_get_serial_port_data(port);
 465         const struct xr_type *type = data->type;
 466         u16 gpio_set = 0;
 467         u16 gpio_clr = 0;
 468         int ret = 0;
 469
 470         /* Modem control pins are active low, so set & clr are swapped */
 471         if (set & TIOCM_RTS)
 472                 gpio_clr |= XR_GPIO_RTS;
 473         if (set & TIOCM_DTR)
 474                 gpio_clr |= XR_GPIO_DTR;
 475         if (clear & TIOCM_RTS)
 476                 gpio_set |= XR_GPIO_RTS;
 477         if (clear & TIOCM_DTR)
 478                 gpio_set |= XR_GPIO_DTR;
 479
 480         /* Writing '0' to gpio_{set/clr} bits has no effect, so no need to do */
 481         if (gpio_clr)
 482                 ret = xr_set_reg_uart(port, type->gpio_clear, gpio_clr);
 483
 484         if (gpio_set)
 485                 ret = xr_set_reg_uart(port, type->gpio_set, gpio_set);
 486
 487         return ret;
 488 }
 489
 490 static int xr_tiocmset(struct tty_struct *tty,
 491                        unsigned int set, unsigned int clear)
 492 {
 493         struct usb_serial_port *port = tty->driver_data;
 494
 495         return xr_tiocmset_port(port, set, clear);
 496 }
 497
 498 static void xr_dtr_rts(struct usb_serial_port *port, int on)
 499 {
 500         if (on)
 501                 xr_tiocmset_port(port, TIOCM_DTR | TIOCM_RTS, 0);
 502         else
 503                 xr_tiocmset_port(port, 0, TIOCM_DTR | TIOCM_RTS);
 504 }
 505
 506 static void xr_break_ctl(struct tty_struct *tty, int break_state)
 507 {
 508         struct usb_serial_port *port = tty->driver_data;
 509         struct xr_data *data = usb_get_serial_port_data(port);
 510         const struct xr_type *type = data->type;
 511         u16 state;
 512
 513         if (break_state == 0)
 514                 state = 0;
 515         else
 516                 state = GENMASK(type->reg_width - 1, 0);
 517
 518         dev_dbg(&port->dev, "Turning break %s\n", state == 0 ? "off" : "on");
 519
 520         xr_set_reg_uart(port, type->tx_break, state);
 521 }
 522
 523 /* Tx and Rx clock mask values obtained from section 3.3.4 of datasheet */
 524 static const struct xr_txrx_clk_mask xr21v141x_txrx_clk_masks[] = {
 525         { 0x000, 0x000, 0x000 },
 526         { 0x000, 0x000, 0x000 },
 527         { 0x100, 0x000, 0x100 },
 528         { 0x020, 0x400, 0x020 },
 529         { 0x010, 0x100, 0x010 },
 530         { 0x208, 0x040, 0x208 },
 531         { 0x104, 0x820, 0x108 },
 532         { 0x844, 0x210, 0x884 },
 533         { 0x444, 0x110, 0x444 },
 534         { 0x122, 0x888, 0x224 },
 535         { 0x912, 0x448, 0x924 },
 536         { 0x492, 0x248, 0x492 },
 537         { 0x252, 0x928, 0x292 },
 538         { 0x94a, 0x4a4, 0xa52 },
 539         { 0x52a, 0xaa4, 0x54a },
 540         { 0xaaa, 0x954, 0x4aa },
 541         { 0xaaa, 0x554, 0xaaa },
 542         { 0x555, 0xad4, 0x5aa },
 543         { 0xb55, 0xab4, 0x55a },
 544         { 0x6b5, 0x5ac, 0xb56 },
 545         { 0x5b5, 0xd6c, 0x6d6 },
 546         { 0xb6d, 0xb6a, 0xdb6 },
 547         { 0x76d, 0x6da, 0xbb6 },
 548         { 0xedd, 0xdda, 0x76e },
 549         { 0xddd, 0xbba, 0xeee },
 550         { 0x7bb, 0xf7a, 0xdde },
 551         { 0xf7b, 0xef6, 0x7de },
 552         { 0xdf7, 0xbf6, 0xf7e },
 553         { 0x7f7, 0xfee, 0xefe },
 554         { 0xfdf, 0xfbe, 0x7fe },
 555         { 0xf7f, 0xefe, 0xffe },
 556         { 0xfff, 0xffe, 0xffd },
 557 };
 558
 559 static int xr21v141x_set_baudrate(struct tty_struct *tty, struct usb_serial_port *port)
 560 {
 561         u32 divisor, baud, idx;
 562         u16 tx_mask, rx_mask;
 563         int ret;
 564
 565         baud = tty->termios.c_ospeed;
 566         if (!baud)
 567                 return 0;
 568
 569         baud = clamp(baud, XR21V141X_MIN_SPEED, XR21V141X_MAX_SPEED);
 570         divisor = XR_INT_OSC_HZ / baud;
 571         idx = ((32 * XR_INT_OSC_HZ) / baud) & 0x1f;
 572         tx_mask = xr21v141x_txrx_clk_masks[idx].tx;
 573
 574         if (divisor & 0x01)
 575                 rx_mask = xr21v141x_txrx_clk_masks[idx].rx1;
 576         else
 577                 rx_mask = xr21v141x_txrx_clk_masks[idx].rx0;
 578
 579         dev_dbg(&port->dev, "Setting baud rate: %u\n", baud);
 580         /*
 581          * XR21V141X uses fractional baud rate generator with 48MHz internal
 582          * oscillator and 19-bit programmable divisor. So theoretically it can
 583          * generate most commonly used baud rates with high accuracy.
 584          */
 585         ret = xr_set_reg_uart(port, XR21V141X_CLOCK_DIVISOR_0,
 586                               divisor & 0xff);
 587         if (ret)
 588                 return ret;
 589
 590         ret = xr_set_reg_uart(port, XR21V141X_CLOCK_DIVISOR_1,
 591                               (divisor >>  8) & 0xff);
 592         if (ret)
 593                 return ret;
 594
 595         ret = xr_set_reg_uart(port, XR21V141X_CLOCK_DIVISOR_2,
 596                               (divisor >> 16) & 0xff);
 597         if (ret)
 598                 return ret;
 599
 600         ret = xr_set_reg_uart(port, XR21V141X_TX_CLOCK_MASK_0,
 601                               tx_mask & 0xff);
 602         if (ret)
 603                 return ret;
 604
 605         ret = xr_set_reg_uart(port, XR21V141X_TX_CLOCK_MASK_1,
 606                               (tx_mask >>  8) & 0xff);
 607         if (ret)
 608                 return ret;
 609
 610         ret = xr_set_reg_uart(port, XR21V141X_RX_CLOCK_MASK_0,
 611                               rx_mask & 0xff);
 612         if (ret)
 613                 return ret;
 614
 615         ret = xr_set_reg_uart(port, XR21V141X_RX_CLOCK_MASK_1,
 616                               (rx_mask >>  8) & 0xff);
 617         if (ret)
 618                 return ret;
 619
 620         tty_encode_baud_rate(tty, baud, baud);
 621
 622         return 0;
 623 }
 624
 625 static void xr_set_flow_mode(struct tty_struct *tty,
 626                              struct usb_serial_port *port,
 627                              const struct ktermios *old_termios)
 628 {
 629         struct xr_data *data = usb_get_serial_port_data(port);
 630         const struct xr_type *type = data->type;
 631         u16 flow, gpio_mode;
 632         int ret;
 633
 634         ret = xr_get_reg_uart(port, type->gpio_mode, &gpio_mode);
 635         if (ret)
 636                 return;
 637
 638         /*
 639          * According to the datasheets, the UART needs to be disabled while
 640          * writing to the FLOW_CONTROL register (XR21V141X), or any register
 641          * but GPIO_SET, GPIO_CLEAR, TX_BREAK and ERROR_STATUS (XR21B142X).
 642          */
 643         xr_uart_disable(port);
 644
 645         /* Set GPIO mode for controlling the pins manually by default. */
 646         gpio_mode &= ~XR_GPIO_MODE_SEL_MASK;
 647
 648         if (C_CRTSCTS(tty) && C_BAUD(tty) != B0) {
 649                 dev_dbg(&port->dev, "Enabling hardware flow ctrl\n");
 650                 gpio_mode |= XR_GPIO_MODE_SEL_RTS_CTS;
 651                 flow = XR_UART_FLOW_MODE_HW;
 652         } else if (I_IXON(tty)) {
 653                 u8 start_char = START_CHAR(tty);
 654                 u8 stop_char = STOP_CHAR(tty);
 655
 656                 dev_dbg(&port->dev, "Enabling sw flow ctrl\n");
 657                 flow = XR_UART_FLOW_MODE_SW;
 658
 659                 xr_set_reg_uart(port, type->xon_char, start_char);
 660                 xr_set_reg_uart(port, type->xoff_char, stop_char);
 661         } else {
 662                 dev_dbg(&port->dev, "Disabling flow ctrl\n");
 663                 flow = XR_UART_FLOW_MODE_NONE;
 664         }
 665
 666         xr_set_reg_uart(port, type->flow_control, flow);
 667         xr_set_reg_uart(port, type->gpio_mode, gpio_mode);
 668
 669         xr_uart_enable(port);
 670
 671         if (C_BAUD(tty) == B0)
 672                 xr_dtr_rts(port, 0);
 673         else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
 674                 xr_dtr_rts(port, 1);
 675 }
 676
 677 static void xr21v141x_set_line_settings(struct tty_struct *tty,
 678                                         struct usb_serial_port *port,
 679                                         const struct ktermios *old_termios)
 680 {
 681         struct ktermios *termios = &tty->termios;
 682         u8 bits = 0;
 683         int ret;
 684
 685         if (!old_termios || (tty->termios.c_ospeed != old_termios->c_ospeed))
 686                 xr21v141x_set_baudrate(tty, port);
 687
 688         switch (C_CSIZE(tty)) {
 689         case CS5:
 690         case CS6:
 691                 /* CS5 and CS6 are not supported, so just restore old setting */
 692                 termios->c_cflag &= ~CSIZE;
 693                 if (old_termios)
 694                         termios->c_cflag |= old_termios->c_cflag & CSIZE;
 695                 else
 696                         termios->c_cflag |= CS8;
 697
 698                 if (C_CSIZE(tty) == CS7)
 699                         bits |= XR_UART_DATA_7;
 700                 else
 701                         bits |= XR_UART_DATA_8;
 702                 break;
 703         case CS7:
 704                 bits |= XR_UART_DATA_7;
 705                 break;
 706         case CS8:
 707         default:
 708                 bits |= XR_UART_DATA_8;
 709                 break;
 710         }
 711
 712         if (C_PARENB(tty)) {
 713                 if (C_CMSPAR(tty)) {
 714                         if (C_PARODD(tty))
 715                                 bits |= XR_UART_PARITY_MARK;
 716                         else
 717                                 bits |= XR_UART_PARITY_SPACE;
 718                 } else {
 719                         if (C_PARODD(tty))
 720                                 bits |= XR_UART_PARITY_ODD;
 721                         else
 722                                 bits |= XR_UART_PARITY_EVEN;
 723                 }
 724         }
 725
 726         if (C_CSTOPB(tty))
 727                 bits |= XR_UART_STOP_2;
 728         else
 729                 bits |= XR_UART_STOP_1;
 730
 731         ret = xr_set_reg_uart(port, XR21V141X_REG_FORMAT, bits);
 732         if (ret)
 733                 return;
 734 }
 735
 736 static void xr_cdc_set_line_coding(struct tty_struct *tty,
 737                                    struct usb_serial_port *port,
 738                                    const struct ktermios *old_termios)
 739 {
 740         struct xr_data *data = usb_get_serial_port_data(port);
 741         struct usb_host_interface *alt = port->serial->interface->cur_altsetting;
 742         struct usb_device *udev = port->serial->dev;
 743         struct usb_cdc_line_coding *lc;
 744         int ret;
 745
 746         lc = kzalloc(sizeof(*lc), GFP_KERNEL);
 747         if (!lc)
 748                 return;
 749
 750         if (tty->termios.c_ospeed)
 751                 lc->dwDTERate = cpu_to_le32(tty->termios.c_ospeed);
 752         else if (old_termios)
 753                 lc->dwDTERate = cpu_to_le32(old_termios->c_ospeed);
 754         else
 755                 lc->dwDTERate = cpu_to_le32(9600);
 756
 757         if (C_CSTOPB(tty))
 758                 lc->bCharFormat = USB_CDC_2_STOP_BITS;
 759         else
 760                 lc->bCharFormat = USB_CDC_1_STOP_BITS;
 761
 762         if (C_PARENB(tty)) {
 763                 if (C_CMSPAR(tty)) {
 764                         if (C_PARODD(tty))
 765                                 lc->bParityType = USB_CDC_MARK_PARITY;
 766                         else
 767                                 lc->bParityType = USB_CDC_SPACE_PARITY;
 768                 } else {
 769                         if (C_PARODD(tty))
 770                                 lc->bParityType = USB_CDC_ODD_PARITY;
 771                         else
 772                                 lc->bParityType = USB_CDC_EVEN_PARITY;
 773                 }
 774         } else {
 775                 lc->bParityType = USB_CDC_NO_PARITY;
 776         }
 777
 778         if (!data->type->have_5_6_bit_mode &&
 779                         (C_CSIZE(tty) == CS5 || C_CSIZE(tty) == CS6)) {
 780                 tty->termios.c_cflag &= ~CSIZE;
 781                 if (old_termios)
 782                         tty->termios.c_cflag |= old_termios->c_cflag & CSIZE;
 783                 else
 784                         tty->termios.c_cflag |= CS8;
 785         }
 786
 787         switch (C_CSIZE(tty)) {
 788         case CS5:
 789                 lc->bDataBits = 5;
 790                 break;
 791         case CS6:
 792                 lc->bDataBits = 6;
 793                 break;
 794         case CS7:
 795                 lc->bDataBits = 7;
 796                 break;
 797         case CS8:
 798         default:
 799                 lc->bDataBits = 8;
 800                 break;
 801         }
 802
 803         ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 804                         USB_CDC_REQ_SET_LINE_CODING,
 805                         USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 806                         0, alt->desc.bInterfaceNumber,
 807                         lc, sizeof(*lc), USB_CTRL_SET_TIMEOUT);
 808         if (ret < 0)
 809                 dev_err(&port->dev, "Failed to set line coding: %d\n", ret);
 810
 811         kfree(lc);
 812 }
 813
 814 static void xr_set_termios(struct tty_struct *tty,
 815                            struct usb_serial_port *port,
 816                            const struct ktermios *old_termios)
 817 {
 818         struct xr_data *data = usb_get_serial_port_data(port);
 819
 820         /*
 821          * XR21V141X does not have a CUSTOM_DRIVER flag and always enters CDC
 822          * mode upon receiving CDC requests.
 823          */
 824         if (data->type->set_line_settings)
 825                 data->type->set_line_settings(tty, port, old_termios);
 826         else
 827                 xr_cdc_set_line_coding(tty, port, old_termios);
 828
 829         xr_set_flow_mode(tty, port, old_termios);
 830 }
 831
 832 static int xr_open(struct tty_struct *tty, struct usb_serial_port *port)
 833 {
 834         int ret;
 835
 836         ret = xr_fifo_reset(port);
 837         if (ret)
 838                 return ret;
 839
 840         ret = xr_uart_enable(port);
 841         if (ret) {
 842                 dev_err(&port->dev, "Failed to enable UART\n");
 843                 return ret;
 844         }
 845
 846         /* Setup termios */
 847         if (tty)
 848                 xr_set_termios(tty, port, NULL);
 849
 850         ret = usb_serial_generic_open(tty, port);
 851         if (ret) {
 852                 xr_uart_disable(port);
 853                 return ret;
 854         }
 855
 856         return 0;
 857 }
 858
 859 static void xr_close(struct usb_serial_port *port)
 860 {
 861         usb_serial_generic_close(port);
 862
 863         xr_uart_disable(port);
 864 }
 865
 866 static int xr_probe(struct usb_serial *serial, const struct usb_device_id *id)
 867 {
 868         struct usb_interface *control = serial->interface;
 869         struct usb_host_interface *alt = control->cur_altsetting;
 870         struct usb_cdc_parsed_header hdrs;
 871         struct usb_cdc_union_desc *desc;
 872         struct usb_interface *data;
 873         int ret;
 874
 875         ret = cdc_parse_cdc_header(&hdrs, control, alt->extra, alt->extralen);
 876         if (ret < 0)
 877                 return -ENODEV;
 878
 879         desc = hdrs.usb_cdc_union_desc;
 880         if (!desc)
 881                 return -ENODEV;
 882
 883         data = usb_ifnum_to_if(serial->dev, desc->bSlaveInterface0);
 884         if (!data)
 885                 return -ENODEV;
 886
 887         ret = usb_serial_claim_interface(serial, data);
 888         if (ret)
 889                 return ret;
 890
 891         usb_set_serial_data(serial, (void *)id->driver_info);
 892
 893         return 0;
 894 }
 895
 896 static int xr_gpio_init(struct usb_serial_port *port, const struct xr_type *type)
 897 {
 898         u16 mask, mode;
 899         int ret;
 900
 901         /*
 902          * Configure all pins as GPIO except for Receive and Transmit Toggle.
 903          */
 904         mode = 0;
 905         if (type->have_xmit_toggle)
 906                 mode |= XR_GPIO_MODE_RX_TOGGLE | XR_GPIO_MODE_TX_TOGGLE;
 907
 908         ret = xr_set_reg_uart(port, type->gpio_mode, mode);
 909         if (ret)
 910                 return ret;
 911
 912         /*
 913          * Configure DTR and RTS as outputs and make sure they are deasserted
 914          * (active low), and configure RI, CD, DSR and CTS as inputs.
 915          */
 916         mask = XR_GPIO_DTR | XR_GPIO_RTS;
 917         ret = xr_set_reg_uart(port, type->gpio_direction, mask);
 918         if (ret)
 919                 return ret;
 920
 921         ret = xr_set_reg_uart(port, type->gpio_set, mask);
 922         if (ret)
 923                 return ret;
 924
 925         return 0;
 926 }
 927
 928 static int xr_port_probe(struct usb_serial_port *port)
 929 {
 930         struct usb_interface_descriptor *desc;
 931         const struct xr_type *type;
 932         struct xr_data *data;
 933         enum xr_type_id type_id;
 934         int ret;
 935
 936         type_id = (int)(unsigned long)usb_get_serial_data(port->serial);
 937         type = &xr_types[type_id];
 938
 939         data = kzalloc(sizeof(*data), GFP_KERNEL);
 940         if (!data)
 941                 return -ENOMEM;
 942
 943         data->type = type;
 944
 945         desc = &port->serial->interface->cur_altsetting->desc;
 946         if (type_id == XR21V141X)
 947                 data->channel = desc->bInterfaceNumber / 2;
 948         else
 949                 data->channel = desc->bInterfaceNumber;
 950
 951         usb_set_serial_port_data(port, data);
 952
 953         if (type->custom_driver) {
 954                 ret = xr_set_reg_uart(port, type->custom_driver,
 955                                 XR_CUSTOM_DRIVER_ACTIVE);
 956                 if (ret)
 957                         goto err_free;
 958         }
 959
 960         ret = xr_gpio_init(port, type);
 961         if (ret)
 962                 goto err_free;
 963
 964         return 0;
 965
 966 err_free:
 967         kfree(data);
 968
 969         return ret;
 970 }
 971
 972 static void xr_port_remove(struct usb_serial_port *port)
 973 {
 974         struct xr_data *data = usb_get_serial_port_data(port);
 975
 976         kfree(data);
 977 }
 978
 979 #define XR_DEVICE(vid, pid, type)                                       \
 980         USB_DEVICE_INTERFACE_CLASS((vid), (pid), USB_CLASS_COMM),       \
 981         .driver_info = (type)
 982
 983 static const struct usb_device_id id_table[] = {
 984         { XR_DEVICE(0x04e2, 0x1400, XR2280X) },
 985         { XR_DEVICE(0x04e2, 0x1401, XR2280X) },
 986         { XR_DEVICE(0x04e2, 0x1402, XR2280X) },
 987         { XR_DEVICE(0x04e2, 0x1403, XR2280X) },
 988         { XR_DEVICE(0x04e2, 0x1410, XR21V141X) },
 989         { XR_DEVICE(0x04e2, 0x1411, XR21B1411) },
 990         { XR_DEVICE(0x04e2, 0x1412, XR21V141X) },
 991         { XR_DEVICE(0x04e2, 0x1414, XR21V141X) },
 992         { XR_DEVICE(0x04e2, 0x1420, XR21B142X) },
 993         { XR_DEVICE(0x04e2, 0x1422, XR21B142X) },
 994         { XR_DEVICE(0x04e2, 0x1424, XR21B142X) },
 995         { }
 996 };
 997 MODULE_DEVICE_TABLE(usb, id_table);
 998
 999 static struct usb_serial_driver xr_device = {
1000         .driver = {
1001                 .owner = THIS_MODULE,
1002                 .name = "xr_serial",
1003         },
1004         .id_table               = id_table,
1005         .num_ports              = 1,
1006         .probe                  = xr_probe,
1007         .port_probe             = xr_port_probe,
1008         .port_remove            = xr_port_remove,
1009         .open                   = xr_open,
1010         .close                  = xr_close,
1011         .break_ctl              = xr_break_ctl,
1012         .set_termios            = xr_set_termios,
1013         .tiocmget               = xr_tiocmget,
1014         .tiocmset               = xr_tiocmset,
1015         .dtr_rts                = xr_dtr_rts
1016 };
1017
1018 static struct usb_serial_driver * const serial_drivers[] = {
1019         &xr_device, NULL
1020 };
1021
1022 module_usb_serial_driver(serial_drivers, id_table);
1023
1024 MODULE_AUTHOR("Manivannan Sadhasivam <[email protected]>");
1025 MODULE_DESCRIPTION("MaxLinear/Exar USB to Serial driver");
1026 MODULE_LICENSE("GPL");