drivers/tty/serial/8250/8250_fintek.c

   1 /*
   2  *  Probe for F81216A LPC to 4 UART
   3  *
   4  *  Copyright (C) 2014-2016 Ricardo Ribalda, Qtechnology A/S
   5  *
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License.
  10  */
  11 #include <linux/module.h>
  12 #include <linux/pci.h>
  13 #include <linux/pnp.h>
  14 #include <linux/kernel.h>
  15 #include <linux/serial_core.h>
  16 #include <linux/irq.h>
  17 #include  "8250.h"
  18
  19 #define ADDR_PORT 0
  20 #define DATA_PORT 1
  21 #define EXIT_KEY 0xAA
  22 #define CHIP_ID1  0x20
  23 #define CHIP_ID2  0x21
  24 #define CHIP_ID_F81865 0x0407
  25 #define CHIP_ID_F81866 0x1010
  26 #define CHIP_ID_F81216AD 0x1602
  27 #define CHIP_ID_F81216H 0x0501
  28 #define CHIP_ID_F81216 0x0802
  29 #define VENDOR_ID1 0x23
  30 #define VENDOR_ID1_VAL 0x19
  31 #define VENDOR_ID2 0x24
  32 #define VENDOR_ID2_VAL 0x34
  33 #define IO_ADDR1 0x61
  34 #define IO_ADDR2 0x60
  35 #define LDN 0x7
  36
  37 #define FINTEK_IRQ_MODE 0x70
  38 #define IRQ_SHARE       BIT(4)
  39 #define IRQ_MODE_MASK   (BIT(6) | BIT(5))
  40 #define IRQ_LEVEL_LOW   0
  41 #define IRQ_EDGE_HIGH   BIT(5)
  42
  43 #define RS485  0xF0
  44 #define RTS_INVERT BIT(5)
  45 #define RS485_URA BIT(4)
  46 #define RXW4C_IRA BIT(3)
  47 #define TXW4C_IRA BIT(2)
  48
  49 #define FIFO_CTRL               0xF6
  50 #define FIFO_MODE_MASK          (BIT(1) | BIT(0))
  51 #define FIFO_MODE_128           (BIT(1) | BIT(0))
  52 #define RXFTHR_MODE_MASK        (BIT(5) | BIT(4))
  53 #define RXFTHR_MODE_4X          BIT(5)
  54
  55 #define F81216_LDN_LOW  0x0
  56 #define F81216_LDN_HIGH 0x4
  57
  58 /*
  59  * F81866 registers
  60  *
  61  * The IRQ setting mode of F81866 is not the same with F81216 series.
  62  *      Level/Low: IRQ_MODE0:0, IRQ_MODE1:0
  63  *      Edge/High: IRQ_MODE0:1, IRQ_MODE1:0
  64  *
  65  * Clock speeds for UART (register F2h)
  66  * 00: 1.8432MHz.
  67  * 01: 18.432MHz.
  68  * 10: 24MHz.
  69  * 11: 14.769MHz.
  70  */
  71 #define F81866_IRQ_MODE         0xf0
  72 #define F81866_IRQ_SHARE        BIT(0)
  73 #define F81866_IRQ_MODE0        BIT(1)
  74
  75 #define F81866_FIFO_CTRL        FIFO_CTRL
  76 #define F81866_IRQ_MODE1        BIT(3)
  77
  78 #define F81866_LDN_LOW          0x10
  79 #define F81866_LDN_HIGH         0x16
  80
  81 #define F81866_UART_CLK 0xF2
  82 #define F81866_UART_CLK_MASK (BIT(1) | BIT(0))
  83 #define F81866_UART_CLK_1_8432MHZ 0
  84 #define F81866_UART_CLK_14_769MHZ (BIT(1) | BIT(0))
  85 #define F81866_UART_CLK_18_432MHZ BIT(0)
  86 #define F81866_UART_CLK_24MHZ BIT(1)
  87
  88 struct fintek_8250 {
  89         u16 pid;
  90         u16 base_port;
  91         u8 index;
  92         u8 key;
  93 };
  94
  95 static u8 sio_read_reg(struct fintek_8250 *pdata, u8 reg)
  96 {
  97         outb(reg, pdata->base_port + ADDR_PORT);
  98         return inb(pdata->base_port + DATA_PORT);
  99 }
 100
 101 static void sio_write_reg(struct fintek_8250 *pdata, u8 reg, u8 data)
 102 {
 103         outb(reg, pdata->base_port + ADDR_PORT);
 104         outb(data, pdata->base_port + DATA_PORT);
 105 }
 106
 107 static void sio_write_mask_reg(struct fintek_8250 *pdata, u8 reg, u8 mask,
 108                                u8 data)
 109 {
 110         u8 tmp;
 111
 112         tmp = (sio_read_reg(pdata, reg) & ~mask) | (mask & data);
 113         sio_write_reg(pdata, reg, tmp);
 114 }
 115
 116 static int fintek_8250_enter_key(u16 base_port, u8 key)
 117 {
 118         if (!request_muxed_region(base_port, 2, "8250_fintek"))
 119                 return -EBUSY;
 120
 121         /* Force to deactive all SuperIO in this base_port */
 122         outb(EXIT_KEY, base_port + ADDR_PORT);
 123
 124         outb(key, base_port + ADDR_PORT);
 125         outb(key, base_port + ADDR_PORT);
 126         return 0;
 127 }
 128
 129 static void fintek_8250_exit_key(u16 base_port)
 130 {
 131
 132         outb(EXIT_KEY, base_port + ADDR_PORT);
 133         release_region(base_port + ADDR_PORT, 2);
 134 }
 135
 136 static int fintek_8250_check_id(struct fintek_8250 *pdata)
 137 {
 138         u16 chip;
 139
 140         if (sio_read_reg(pdata, VENDOR_ID1) != VENDOR_ID1_VAL)
 141                 return -ENODEV;
 142
 143         if (sio_read_reg(pdata, VENDOR_ID2) != VENDOR_ID2_VAL)
 144                 return -ENODEV;
 145
 146         chip = sio_read_reg(pdata, CHIP_ID1);
 147         chip |= sio_read_reg(pdata, CHIP_ID2) << 8;
 148
 149         switch (chip) {
 150         case CHIP_ID_F81865:
 151         case CHIP_ID_F81866:
 152         case CHIP_ID_F81216AD:
 153         case CHIP_ID_F81216H:
 154         case CHIP_ID_F81216:
 155                 break;
 156         default:
 157                 return -ENODEV;
 158         }
 159
 160         pdata->pid = chip;
 161         return 0;
 162 }
 163
 164 static int fintek_8250_get_ldn_range(struct fintek_8250 *pdata, int *min,
 165                                      int *max)
 166 {
 167         switch (pdata->pid) {
 168         case CHIP_ID_F81865:
 169         case CHIP_ID_F81866:
 170                 *min = F81866_LDN_LOW;
 171                 *max = F81866_LDN_HIGH;
 172                 return 0;
 173
 174         case CHIP_ID_F81216AD:
 175         case CHIP_ID_F81216H:
 176         case CHIP_ID_F81216:
 177                 *min = F81216_LDN_LOW;
 178                 *max = F81216_LDN_HIGH;
 179                 return 0;
 180         }
 181
 182         return -ENODEV;
 183 }
 184
 185 static int fintek_8250_rs485_config(struct uart_port *port,
 186                               struct serial_rs485 *rs485)
 187 {
 188         uint8_t config = 0;
 189         struct fintek_8250 *pdata = port->private_data;
 190
 191         if (!pdata)
 192                 return -EINVAL;
 193
 194         if (rs485->flags & SER_RS485_ENABLED)
 195                 memset(rs485->padding, 0, sizeof(rs485->padding));
 196         else
 197                 memset(rs485, 0, sizeof(*rs485));
 198
 199         rs485->flags &= SER_RS485_ENABLED | SER_RS485_RTS_ON_SEND |
 200                         SER_RS485_RTS_AFTER_SEND;
 201
 202         if (rs485->delay_rts_before_send) {
 203                 rs485->delay_rts_before_send = 1;
 204                 config |= TXW4C_IRA;
 205         }
 206
 207         if (rs485->delay_rts_after_send) {
 208                 rs485->delay_rts_after_send = 1;
 209                 config |= RXW4C_IRA;
 210         }
 211
 212         if ((!!(rs485->flags & SER_RS485_RTS_ON_SEND)) ==
 213                         (!!(rs485->flags & SER_RS485_RTS_AFTER_SEND)))
 214                 rs485->flags &= ~SER_RS485_ENABLED;
 215         else
 216                 config |= RS485_URA;
 217
 218         if (rs485->flags & SER_RS485_RTS_ON_SEND)
 219                 config |= RTS_INVERT;
 220
 221         if (fintek_8250_enter_key(pdata->base_port, pdata->key))
 222                 return -EBUSY;
 223
 224         sio_write_reg(pdata, LDN, pdata->index);
 225         sio_write_reg(pdata, RS485, config);
 226         fintek_8250_exit_key(pdata->base_port);
 227
 228         port->rs485 = *rs485;
 229
 230         return 0;
 231 }
 232
 233 static void fintek_8250_set_irq_mode(struct fintek_8250 *pdata, bool is_level)
 234 {
 235         sio_write_reg(pdata, LDN, pdata->index);
 236
 237         switch (pdata->pid) {
 238         case CHIP_ID_F81866:
 239                 sio_write_mask_reg(pdata, F81866_FIFO_CTRL, F81866_IRQ_MODE1,
 240                                    0);
 241                 /* fall through */
 242         case CHIP_ID_F81865:
 243                 sio_write_mask_reg(pdata, F81866_IRQ_MODE, F81866_IRQ_SHARE,
 244                                    F81866_IRQ_SHARE);
 245                 sio_write_mask_reg(pdata, F81866_IRQ_MODE, F81866_IRQ_MODE0,
 246                                    is_level ? 0 : F81866_IRQ_MODE0);
 247                 break;
 248
 249         case CHIP_ID_F81216AD:
 250         case CHIP_ID_F81216H:
 251         case CHIP_ID_F81216:
 252                 sio_write_mask_reg(pdata, FINTEK_IRQ_MODE, IRQ_SHARE,
 253                                    IRQ_SHARE);
 254                 sio_write_mask_reg(pdata, FINTEK_IRQ_MODE, IRQ_MODE_MASK,
 255                                    is_level ? IRQ_LEVEL_LOW : IRQ_EDGE_HIGH);
 256                 break;
 257         }
 258 }
 259
 260 static void fintek_8250_set_max_fifo(struct fintek_8250 *pdata)
 261 {
 262         switch (pdata->pid) {
 263         case CHIP_ID_F81216H: /* 128Bytes FIFO */
 264         case CHIP_ID_F81866:
 265                 sio_write_mask_reg(pdata, FIFO_CTRL,
 266                                    FIFO_MODE_MASK | RXFTHR_MODE_MASK,
 267                                    FIFO_MODE_128 | RXFTHR_MODE_4X);
 268                 break;
 269
 270         default: /* Default 16Bytes FIFO */
 271                 break;
 272         }
 273 }
 274
 275 static void fintek_8250_goto_highspeed(struct uart_8250_port *uart,
 276                               struct fintek_8250 *pdata)
 277 {
 278         sio_write_reg(pdata, LDN, pdata->index);
 279
 280         switch (pdata->pid) {
 281         case CHIP_ID_F81866: /* set uart clock for high speed serial mode */
 282                 sio_write_mask_reg(pdata, F81866_UART_CLK,
 283                         F81866_UART_CLK_MASK,
 284                         F81866_UART_CLK_14_769MHZ);
 285
 286                         uart->port.uartclk = 921600 * 16;
 287                 break;
 288         default: /* leave clock speed untouched */
 289                 break;
 290         }
 291 }
 292
 293 static int probe_setup_port(struct fintek_8250 *pdata,
 294                                         struct uart_8250_port *uart)
 295 {
 296         static const u16 addr[] = {0x4e, 0x2e};
 297         static const u8 keys[] = {0x77, 0xa0, 0x87, 0x67};
 298         struct irq_data *irq_data;
 299         bool level_mode = false;
 300         int i, j, k, min, max;
 301
 302         for (i = 0; i < ARRAY_SIZE(addr); i++) {
 303                 for (j = 0; j < ARRAY_SIZE(keys); j++) {
 304                         pdata->base_port = addr[i];
 305                         pdata->key = keys[j];
 306
 307                         if (fintek_8250_enter_key(addr[i], keys[j]))
 308                                 continue;
 309                         if (fintek_8250_check_id(pdata) ||
 310                             fintek_8250_get_ldn_range(pdata, &min, &max)) {
 311                                 fintek_8250_exit_key(addr[i]);
 312                                 continue;
 313                         }
 314
 315                         for (k = min; k < max; k++) {
 316                                 u16 aux;
 317
 318                                 sio_write_reg(pdata, LDN, k);
 319                                 aux = sio_read_reg(pdata, IO_ADDR1);
 320                                 aux |= sio_read_reg(pdata, IO_ADDR2) << 8;
 321                                 if (aux != uart->port.iobase)
 322                                         continue;
 323
 324                                 pdata->index = k;
 325
 326                                 irq_data = irq_get_irq_data(uart->port.irq);
 327                                 if (irq_data)
 328                                         level_mode =
 329                                                 irqd_is_level_type(irq_data);
 330
 331                                 fintek_8250_set_irq_mode(pdata, level_mode);
 332                                 fintek_8250_set_max_fifo(pdata);
 333                                 fintek_8250_goto_highspeed(uart, pdata);
 334
 335                                 fintek_8250_exit_key(addr[i]);
 336
 337                                 return 0;
 338                         }
 339
 340                         fintek_8250_exit_key(addr[i]);
 341                 }
 342         }
 343
 344         return -ENODEV;
 345 }
 346
 347 static void fintek_8250_set_rs485_handler(struct uart_8250_port *uart)
 348 {
 349         struct fintek_8250 *pdata = uart->port.private_data;
 350
 351         switch (pdata->pid) {
 352         case CHIP_ID_F81216AD:
 353         case CHIP_ID_F81216H:
 354         case CHIP_ID_F81866:
 355         case CHIP_ID_F81865:
 356                 uart->port.rs485_config = fintek_8250_rs485_config;
 357                 break;
 358
 359         default: /* No RS485 Auto direction functional */
 360                 break;
 361         }
 362 }
 363
 364 int fintek_8250_probe(struct uart_8250_port *uart)
 365 {
 366         struct fintek_8250 *pdata;
 367         struct fintek_8250 probe_data;
 368
 369         if (probe_setup_port(&probe_data, uart))
 370                 return -ENODEV;
 371
 372         pdata = devm_kzalloc(uart->port.dev, sizeof(*pdata), GFP_KERNEL);
 373         if (!pdata)
 374                 return -ENOMEM;
 375
 376         memcpy(pdata, &probe_data, sizeof(probe_data));
 377         uart->port.private_data = pdata;
 378         fintek_8250_set_rs485_handler(uart);
 379
 380         return 0;
 381 }