drivers/tty/serial/etraxfs-uart.c

   1 #include <linux/module.h>
   2 #include <linux/init.h>
   3 #include <linux/console.h>
   4 #include <linux/platform_device.h>
   5 #include <linux/serial_core.h>
   6 #include <linux/tty_flip.h>
   7 #include <linux/of.h>
   8 #include <linux/gpio.h>
   9 #include <linux/of_irq.h>
  10 #include <linux/of_address.h>
  11 #include <hwregs/ser_defs.h>
  12
  13 #define DRV_NAME "etraxfs-uart"
  14 #define UART_NR CONFIG_ETRAX_SERIAL_PORTS
  15
  16 #define MODIFY_REG(instance, reg, var)                          \
  17         do {                                                    \
  18                 if (REG_RD_INT(ser, instance, reg) !=           \
  19                     REG_TYPE_CONV(int, reg_ser_##reg, var))     \
  20                         REG_WR(ser, instance, reg, var);        \
  21         } while (0)
  22
  23 struct uart_cris_port {
  24         struct uart_port port;
  25
  26         int initialized;
  27         int irq;
  28
  29         void __iomem *regi_ser;
  30
  31         struct gpio_desc *dtr_pin;
  32         struct gpio_desc *dsr_pin;
  33         struct gpio_desc *ri_pin;
  34         struct gpio_desc *cd_pin;
  35
  36         int write_ongoing;
  37 };
  38
  39 static struct uart_driver etraxfs_uart_driver;
  40 static struct uart_port *console_port;
  41 static int console_baud = 115200;
  42 static struct uart_cris_port *etraxfs_uart_ports[UART_NR];
  43
  44 static void cris_serial_port_init(struct uart_port *port, int line);
  45 static void etraxfs_uart_stop_rx(struct uart_port *port);
  46 static inline void etraxfs_uart_start_tx_bottom(struct uart_port *port);
  47
  48 #ifdef CONFIG_SERIAL_ETRAXFS_CONSOLE
  49 static void
  50 cris_console_write(struct console *co, const char *s, unsigned int count)
  51 {
  52         struct uart_cris_port *up;
  53         int i;
  54         reg_ser_r_stat_din stat;
  55         reg_ser_rw_tr_dma_en tr_dma_en, old;
  56
  57         up = etraxfs_uart_ports[co->index];
  58
  59         if (!up)
  60                 return;
  61
  62         /* Switch to manual mode. */
  63         tr_dma_en = old = REG_RD(ser, up->regi_ser, rw_tr_dma_en);
  64         if (tr_dma_en.en == regk_ser_yes) {
  65                 tr_dma_en.en = regk_ser_no;
  66                 REG_WR(ser, up->regi_ser, rw_tr_dma_en, tr_dma_en);
  67         }
  68
  69         /* Send data. */
  70         for (i = 0; i < count; i++) {
  71                 /* LF -> CRLF */
  72                 if (s[i] == '\n') {
  73                         do {
  74                                 stat = REG_RD(ser, up->regi_ser, r_stat_din);
  75                         } while (!stat.tr_rdy);
  76                         REG_WR_INT(ser, up->regi_ser, rw_dout, '\r');
  77                 }
  78                 /* Wait until transmitter is ready and send. */
  79                 do {
  80                         stat = REG_RD(ser, up->regi_ser, r_stat_din);
  81                 } while (!stat.tr_rdy);
  82                 REG_WR_INT(ser, up->regi_ser, rw_dout, s[i]);
  83         }
  84
  85         /* Restore mode. */
  86         if (tr_dma_en.en != old.en)
  87                 REG_WR(ser, up->regi_ser, rw_tr_dma_en, old);
  88 }
  89
  90 static int __init
  91 cris_console_setup(struct console *co, char *options)
  92 {
  93         struct uart_port *port;
  94         int baud = 115200;
  95         int bits = 8;
  96         int parity = 'n';
  97         int flow = 'n';
  98
  99         if (co->index < 0 || co->index >= UART_NR)
 100                 co->index = 0;
 101         port = &etraxfs_uart_ports[co->index]->port;
 102         console_port = port;
 103
 104         co->flags |= CON_CONSDEV;
 105
 106         if (options)
 107                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 108         console_baud = baud;
 109         cris_serial_port_init(port, co->index);
 110         uart_set_options(port, co, baud, parity, bits, flow);
 111
 112         return 0;
 113 }
 114
 115 static struct console cris_console = {
 116         .name = "ttyS",
 117         .write = cris_console_write,
 118         .device = uart_console_device,
 119         .setup = cris_console_setup,
 120         .flags = CON_PRINTBUFFER,
 121         .index = -1,
 122         .data = &etraxfs_uart_driver,
 123 };
 124 #endif /* CONFIG_SERIAL_ETRAXFS_CONSOLE */
 125
 126 static struct uart_driver etraxfs_uart_driver = {
 127         .owner = THIS_MODULE,
 128         .driver_name = "serial",
 129         .dev_name = "ttyS",
 130         .major = TTY_MAJOR,
 131         .minor = 64,
 132         .nr = UART_NR,
 133 #ifdef CONFIG_SERIAL_ETRAXFS_CONSOLE
 134         .cons = &cris_console,
 135 #endif /* CONFIG_SERIAL_ETRAXFS_CONSOLE */
 136 };
 137
 138 static inline int crisv32_serial_get_rts(struct uart_cris_port *up)
 139 {
 140         void __iomem *regi_ser = up->regi_ser;
 141         /*
 142          * Return what the user has controlled rts to or
 143          * what the pin is? (if auto_rts is used it differs during tx)
 144          */
 145         reg_ser_r_stat_din rstat = REG_RD(ser, regi_ser, r_stat_din);
 146
 147         return !(rstat.rts_n == regk_ser_active);
 148 }
 149
 150 /*
 151  * A set = 0 means 3.3V on the pin, bitvalue: 0=active, 1=inactive
 152  *                                            0=0V    , 1=3.3V
 153  */
 154 static inline void crisv32_serial_set_rts(struct uart_cris_port *up,
 155                                           int set, int force)
 156 {
 157         void __iomem *regi_ser = up->regi_ser;
 158
 159         unsigned long flags;
 160         reg_ser_rw_rec_ctrl rec_ctrl;
 161
 162         local_irq_save(flags);
 163         rec_ctrl = REG_RD(ser, regi_ser, rw_rec_ctrl);
 164
 165         if (set)
 166                 rec_ctrl.rts_n = regk_ser_active;
 167         else
 168                 rec_ctrl.rts_n = regk_ser_inactive;
 169         REG_WR(ser, regi_ser, rw_rec_ctrl, rec_ctrl);
 170         local_irq_restore(flags);
 171 }
 172
 173 static inline int crisv32_serial_get_cts(struct uart_cris_port *up)
 174 {
 175         void __iomem *regi_ser = up->regi_ser;
 176         reg_ser_r_stat_din rstat = REG_RD(ser, regi_ser, r_stat_din);
 177
 178         return (rstat.cts_n == regk_ser_active);
 179 }
 180
 181 /*
 182  * Send a single character for XON/XOFF purposes.  We do it in this separate
 183  * function instead of the alternative support port.x_char, in the ...start_tx
 184  * function, so we don't mix up this case with possibly enabling transmission
 185  * of queued-up data (in case that's disabled after *receiving* an XOFF or
 186  * negative CTS).  This function is used for both DMA and non-DMA case; see HW
 187  * docs specifically blessing sending characters manually when DMA for
 188  * transmission is enabled and running.  We may be asked to transmit despite
 189  * the transmitter being disabled by a ..._stop_tx call so we need to enable
 190  * it temporarily but restore the state afterwards.
 191  */
 192 static void etraxfs_uart_send_xchar(struct uart_port *port, char ch)
 193 {
 194         struct uart_cris_port *up = (struct uart_cris_port *)port;
 195         reg_ser_rw_dout dout = { .data = ch };
 196         reg_ser_rw_ack_intr ack_intr = { .tr_rdy = regk_ser_yes };
 197         reg_ser_r_stat_din rstat;
 198         reg_ser_rw_tr_ctrl prev_tr_ctrl, tr_ctrl;
 199         void __iomem *regi_ser = up->regi_ser;
 200         unsigned long flags;
 201
 202         /*
 203          * Wait for tr_rdy in case a character is already being output.  Make
 204          * sure we have integrity between the register reads and the writes
 205          * below, but don't busy-wait with interrupts off and the port lock
 206          * taken.
 207          */
 208         spin_lock_irqsave(&port->lock, flags);
 209         do {
 210                 spin_unlock_irqrestore(&port->lock, flags);
 211                 spin_lock_irqsave(&port->lock, flags);
 212                 prev_tr_ctrl = tr_ctrl = REG_RD(ser, regi_ser, rw_tr_ctrl);
 213                 rstat = REG_RD(ser, regi_ser, r_stat_din);
 214         } while (!rstat.tr_rdy);
 215
 216         /*
 217          * Ack an interrupt if one was just issued for the previous character
 218          * that was output.  This is required for non-DMA as the interrupt is
 219          * used as the only indicator that the transmitter is ready and it
 220          * isn't while this x_char is being transmitted.
 221          */
 222         REG_WR(ser, regi_ser, rw_ack_intr, ack_intr);
 223
 224         /* Enable the transmitter in case it was disabled. */
 225         tr_ctrl.stop = 0;
 226         REG_WR(ser, regi_ser, rw_tr_ctrl, tr_ctrl);
 227
 228         /*
 229          * Finally, send the blessed character; nothing should stop it now,
 230          * except for an xoff-detected state, which we'll handle below.
 231          */
 232         REG_WR(ser, regi_ser, rw_dout, dout);
 233         up->port.icount.tx++;
 234
 235         /* There might be an xoff state to clear. */
 236         rstat = REG_RD(ser, up->regi_ser, r_stat_din);
 237
 238         /*
 239          * Clear any xoff state that *may* have been there to
 240          * inhibit transmission of the character.
 241          */
 242         if (rstat.xoff_detect) {
 243                 reg_ser_rw_xoff_clr xoff_clr = { .clr = 1 };
 244                 reg_ser_rw_tr_dma_en tr_dma_en;
 245
 246                 REG_WR(ser, regi_ser, rw_xoff_clr, xoff_clr);
 247                 tr_dma_en = REG_RD(ser, regi_ser, rw_tr_dma_en);
 248
 249                 /*
 250                  * If we had an xoff state but cleared it, instead sneak in a
 251                  * disabled state for the transmitter, after the character we
 252                  * sent.  Thus we keep the port disabled, just as if the xoff
 253                  * state was still in effect (or actually, as if stop_tx had
 254                  * been called, as we stop DMA too).
 255                  */
 256                 prev_tr_ctrl.stop = 1;
 257
 258                 tr_dma_en.en = 0;
 259                 REG_WR(ser, regi_ser, rw_tr_dma_en, tr_dma_en);
 260         }
 261
 262         /* Restore "previous" enabled/disabled state of the transmitter. */
 263         REG_WR(ser, regi_ser, rw_tr_ctrl, prev_tr_ctrl);
 264
 265         spin_unlock_irqrestore(&port->lock, flags);
 266 }
 267
 268 /*
 269  * Do not spin_lock_irqsave or disable interrupts by other means here; it's
 270  * already done by the caller.
 271  */
 272 static void etraxfs_uart_start_tx(struct uart_port *port)
 273 {
 274         struct uart_cris_port *up = (struct uart_cris_port *)port;
 275
 276         /* we have already done below if a write is ongoing */
 277         if (up->write_ongoing)
 278                 return;
 279
 280         /* Signal that write is ongoing */
 281         up->write_ongoing = 1;
 282
 283         etraxfs_uart_start_tx_bottom(port);
 284 }
 285
 286 static inline void etraxfs_uart_start_tx_bottom(struct uart_port *port)
 287 {
 288         struct uart_cris_port *up = (struct uart_cris_port *)port;
 289         void __iomem *regi_ser = up->regi_ser;
 290         reg_ser_rw_tr_ctrl tr_ctrl;
 291         reg_ser_rw_intr_mask intr_mask;
 292
 293         tr_ctrl = REG_RD(ser, regi_ser, rw_tr_ctrl);
 294         tr_ctrl.stop = regk_ser_no;
 295         REG_WR(ser, regi_ser, rw_tr_ctrl, tr_ctrl);
 296         intr_mask = REG_RD(ser, regi_ser, rw_intr_mask);
 297         intr_mask.tr_rdy = regk_ser_yes;
 298         REG_WR(ser, regi_ser, rw_intr_mask, intr_mask);
 299 }
 300
 301 /*
 302  * This function handles both the DMA and non-DMA case by ordering the
 303  * transmitter to stop of after the current character.  We don't need to wait
 304  * for any such character to be completely transmitted; we do that where it
 305  * matters, like in etraxfs_uart_set_termios.  Don't busy-wait here; see
 306  * Documentation/serial/driver: this function is called within
 307  * spin_lock_irq{,save} and thus separate ones would be disastrous (when SMP).
 308  * There's no documented need to set the txd pin to any particular value;
 309  * break setting is controlled solely by etraxfs_uart_break_ctl.
 310  */
 311 static void etraxfs_uart_stop_tx(struct uart_port *port)
 312 {
 313         struct uart_cris_port *up = (struct uart_cris_port *)port;
 314         void __iomem *regi_ser = up->regi_ser;
 315         reg_ser_rw_tr_ctrl tr_ctrl;
 316         reg_ser_rw_intr_mask intr_mask;
 317         reg_ser_rw_tr_dma_en tr_dma_en = {0};
 318         reg_ser_rw_xoff_clr xoff_clr = {0};
 319
 320         /*
 321          * For the non-DMA case, we'd get a tr_rdy interrupt that we're not
 322          * interested in as we're not transmitting any characters.  For the
 323          * DMA case, that interrupt is already turned off, but no reason to
 324          * waste code on conditionals here.
 325          */
 326         intr_mask = REG_RD(ser, regi_ser, rw_intr_mask);
 327         intr_mask.tr_rdy = regk_ser_no;
 328         REG_WR(ser, regi_ser, rw_intr_mask, intr_mask);
 329
 330         tr_ctrl = REG_RD(ser, regi_ser, rw_tr_ctrl);
 331         tr_ctrl.stop = 1;
 332         REG_WR(ser, regi_ser, rw_tr_ctrl, tr_ctrl);
 333
 334         /*
 335          * Always clear possible hardware xoff-detected state here, no need to
 336          * unnecessary consider mctrl settings and when they change.  We clear
 337          * it here rather than in start_tx: both functions are called as the
 338          * effect of XOFF processing, but start_tx is also called when upper
 339          * levels tell the driver that there are more characters to send, so
 340          * avoid adding code there.
 341          */
 342         xoff_clr.clr = 1;
 343         REG_WR(ser, regi_ser, rw_xoff_clr, xoff_clr);
 344
 345         /*
 346          * Disable transmitter DMA, so that if we're in XON/XOFF, we can send
 347          * those single characters without also giving go-ahead for queued up
 348          * DMA data.
 349          */
 350         tr_dma_en.en = 0;
 351         REG_WR(ser, regi_ser, rw_tr_dma_en, tr_dma_en);
 352
 353         /*
 354          * Make sure that write_ongoing is reset when stopping tx.
 355          */
 356         up->write_ongoing = 0;
 357 }
 358
 359 static void etraxfs_uart_stop_rx(struct uart_port *port)
 360 {
 361         struct uart_cris_port *up = (struct uart_cris_port *)port;
 362         void __iomem *regi_ser = up->regi_ser;
 363         reg_ser_rw_rec_ctrl rec_ctrl = REG_RD(ser, regi_ser, rw_rec_ctrl);
 364
 365         rec_ctrl.en = regk_ser_no;
 366         REG_WR(ser, regi_ser, rw_rec_ctrl, rec_ctrl);
 367 }
 368
 369 static unsigned int etraxfs_uart_tx_empty(struct uart_port *port)
 370 {
 371         struct uart_cris_port *up = (struct uart_cris_port *)port;
 372         unsigned long flags;
 373         unsigned int ret;
 374         reg_ser_r_stat_din rstat = {0};
 375
 376         spin_lock_irqsave(&up->port.lock, flags);
 377
 378         rstat = REG_RD(ser, up->regi_ser, r_stat_din);
 379         ret = rstat.tr_empty ? TIOCSER_TEMT : 0;
 380
 381         spin_unlock_irqrestore(&up->port.lock, flags);
 382         return ret;
 383 }
 384 static unsigned int etraxfs_uart_get_mctrl(struct uart_port *port)
 385 {
 386         struct uart_cris_port *up = (struct uart_cris_port *)port;
 387         unsigned int ret;
 388
 389         ret = 0;
 390         if (crisv32_serial_get_rts(up))
 391                 ret |= TIOCM_RTS;
 392         /* DTR is active low */
 393         if (up->dtr_pin && !gpiod_get_raw_value(up->dtr_pin))
 394                 ret |= TIOCM_DTR;
 395         /* CD is active low */
 396         if (up->cd_pin && !gpiod_get_raw_value(up->cd_pin))
 397                 ret |= TIOCM_CD;
 398         /* RI is active low */
 399         if (up->ri_pin && !gpiod_get_raw_value(up->ri_pin))
 400                 ret |= TIOCM_RI;
 401         /* DSR is active low */
 402         if (up->dsr_pin && !gpiod_get_raw_value(up->dsr_pin))
 403                 ret |= TIOCM_DSR;
 404         if (crisv32_serial_get_cts(up))
 405                 ret |= TIOCM_CTS;
 406         return ret;
 407 }
 408
 409 static void etraxfs_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
 410 {
 411         struct uart_cris_port *up = (struct uart_cris_port *)port;
 412
 413         crisv32_serial_set_rts(up, mctrl & TIOCM_RTS ? 1 : 0, 0);
 414         /* DTR is active low */
 415         if (up->dtr_pin)
 416                 gpiod_set_raw_value(up->dtr_pin, mctrl & TIOCM_DTR ? 0 : 1);
 417         /* RI is active low */
 418         if (up->ri_pin)
 419                 gpiod_set_raw_value(up->ri_pin, mctrl & TIOCM_RNG ? 0 : 1);
 420         /* CD is active low */
 421         if (up->cd_pin)
 422                 gpiod_set_raw_value(up->cd_pin, mctrl & TIOCM_CD ? 0 : 1);
 423 }
 424
 425 static void etraxfs_uart_break_ctl(struct uart_port *port, int break_state)
 426 {
 427         struct uart_cris_port *up = (struct uart_cris_port *)port;
 428         unsigned long flags;
 429         reg_ser_rw_tr_ctrl tr_ctrl;
 430         reg_ser_rw_tr_dma_en tr_dma_en;
 431         reg_ser_rw_intr_mask intr_mask;
 432
 433         spin_lock_irqsave(&up->port.lock, flags);
 434         tr_ctrl = REG_RD(ser, up->regi_ser, rw_tr_ctrl);
 435         tr_dma_en = REG_RD(ser, up->regi_ser, rw_tr_dma_en);
 436         intr_mask = REG_RD(ser, up->regi_ser, rw_intr_mask);
 437
 438         if (break_state != 0) { /* Send break */
 439                 /*
 440                  * We need to disable DMA (if used) or tr_rdy interrupts if no
 441                  * DMA.  No need to make this conditional on use of DMA;
 442                  * disabling will be a no-op for the other mode.
 443                  */
 444                 intr_mask.tr_rdy = regk_ser_no;
 445                 tr_dma_en.en = 0;
 446
 447                 /*
 448                  * Stop transmission and set the txd pin to 0 after the
 449                  * current character.  The txd setting will take effect after
 450                  * any current transmission has completed.
 451                  */
 452                 tr_ctrl.stop = 1;
 453                 tr_ctrl.txd = 0;
 454         } else {
 455                 /* Re-enable the serial interrupt. */
 456                 intr_mask.tr_rdy = regk_ser_yes;
 457
 458                 tr_ctrl.stop = 0;
 459                 tr_ctrl.txd = 1;
 460         }
 461         REG_WR(ser, up->regi_ser, rw_tr_ctrl, tr_ctrl);
 462         REG_WR(ser, up->regi_ser, rw_tr_dma_en, tr_dma_en);
 463         REG_WR(ser, up->regi_ser, rw_intr_mask, intr_mask);
 464
 465         spin_unlock_irqrestore(&up->port.lock, flags);
 466 }
 467
 468 static void
 469 transmit_chars_no_dma(struct uart_cris_port *up)
 470 {
 471         int max_count;
 472         struct circ_buf *xmit = &up->port.state->xmit;
 473
 474         void __iomem *regi_ser = up->regi_ser;
 475         reg_ser_r_stat_din rstat;
 476         reg_ser_rw_ack_intr ack_intr = { .tr_rdy = regk_ser_yes };
 477
 478         if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
 479                 /* No more to send, so disable the interrupt. */
 480                 reg_ser_rw_intr_mask intr_mask;
 481
 482                 intr_mask = REG_RD(ser, regi_ser, rw_intr_mask);
 483                 intr_mask.tr_rdy = 0;
 484                 intr_mask.tr_empty = 0;
 485                 REG_WR(ser, regi_ser, rw_intr_mask, intr_mask);
 486                 up->write_ongoing = 0;
 487                 return;
 488         }
 489
 490         /* If the serport is fast, we send up to max_count bytes before
 491            exiting the loop.  */
 492         max_count = 64;
 493         do {
 494                 reg_ser_rw_dout dout = { .data = xmit->buf[xmit->tail] };
 495
 496                 REG_WR(ser, regi_ser, rw_dout, dout);
 497                 REG_WR(ser, regi_ser, rw_ack_intr, ack_intr);
 498                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE-1);
 499                 up->port.icount.tx++;
 500                 if (xmit->head == xmit->tail)
 501                         break;
 502                 rstat = REG_RD(ser, regi_ser, r_stat_din);
 503         } while ((--max_count > 0) && rstat.tr_rdy);
 504
 505         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 506                 uart_write_wakeup(&up->port);
 507 }
 508
 509 static void receive_chars_no_dma(struct uart_cris_port *up)
 510 {
 511         reg_ser_rs_stat_din stat_din;
 512         reg_ser_r_stat_din rstat;
 513         struct tty_port *port;
 514         struct uart_icount *icount;
 515         int max_count = 16;
 516         char flag;
 517         reg_ser_rw_ack_intr ack_intr = { 0 };
 518
 519         rstat = REG_RD(ser, up->regi_ser, r_stat_din);
 520         icount = &up->port.icount;
 521         port = &up->port.state->port;
 522
 523         do {
 524                 stat_din = REG_RD(ser, up->regi_ser, rs_stat_din);
 525
 526                 flag = TTY_NORMAL;
 527                 ack_intr.dav = 1;
 528                 REG_WR(ser, up->regi_ser, rw_ack_intr, ack_intr);
 529                 icount->rx++;
 530
 531                 if (stat_din.framing_err | stat_din.par_err | stat_din.orun) {
 532                         if (stat_din.data == 0x00 &&
 533                             stat_din.framing_err) {
 534                                 /* Most likely a break. */
 535                                 flag = TTY_BREAK;
 536                                 icount->brk++;
 537                         } else if (stat_din.par_err) {
 538                                 flag = TTY_PARITY;
 539                                 icount->parity++;
 540                         } else if (stat_din.orun) {
 541                                 flag = TTY_OVERRUN;
 542                                 icount->overrun++;
 543                         } else if (stat_din.framing_err) {
 544                                 flag = TTY_FRAME;
 545                                 icount->frame++;
 546                         }
 547                 }
 548
 549                 /*
 550                  * If this becomes important, we probably *could* handle this
 551                  * gracefully by keeping track of the unhandled character.
 552                  */
 553                 if (!tty_insert_flip_char(port, stat_din.data, flag))
 554                         panic("%s: No tty buffer space", __func__);
 555                 rstat = REG_RD(ser, up->regi_ser, r_stat_din);
 556         } while (rstat.dav && (max_count-- > 0));
 557         spin_unlock(&up->port.lock);
 558         tty_flip_buffer_push(port);
 559         spin_lock(&up->port.lock);
 560 }
 561
 562 static irqreturn_t
 563 ser_interrupt(int irq, void *dev_id)
 564 {
 565         struct uart_cris_port *up = (struct uart_cris_port *)dev_id;
 566         void __iomem *regi_ser;
 567         int handled = 0;
 568
 569         spin_lock(&up->port.lock);
 570
 571         regi_ser = up->regi_ser;
 572
 573         if (regi_ser) {
 574                 reg_ser_r_masked_intr masked_intr;
 575
 576                 masked_intr = REG_RD(ser, regi_ser, r_masked_intr);
 577                 /*
 578                  * Check what interrupts are active before taking
 579                  * actions. If DMA is used the interrupt shouldn't
 580                  * be enabled.
 581                  */
 582                 if (masked_intr.dav) {
 583                         receive_chars_no_dma(up);
 584                         handled = 1;
 585                 }
 586
 587                 if (masked_intr.tr_rdy) {
 588                         transmit_chars_no_dma(up);
 589                         handled = 1;
 590                 }
 591         }
 592         spin_unlock(&up->port.lock);
 593         return IRQ_RETVAL(handled);
 594 }
 595
 596 #ifdef CONFIG_CONSOLE_POLL
 597 static int etraxfs_uart_get_poll_char(struct uart_port *port)
 598 {
 599         reg_ser_rs_stat_din stat;
 600         reg_ser_rw_ack_intr ack_intr = { 0 };
 601         struct uart_cris_port *up = (struct uart_cris_port *)port;
 602
 603         do {
 604                 stat = REG_RD(ser, up->regi_ser, rs_stat_din);
 605         } while (!stat.dav);
 606
 607         /* Ack the data_avail interrupt. */
 608         ack_intr.dav = 1;
 609         REG_WR(ser, up->regi_ser, rw_ack_intr, ack_intr);
 610
 611         return stat.data;
 612 }
 613
 614 static void etraxfs_uart_put_poll_char(struct uart_port *port,
 615                                         unsigned char c)
 616 {
 617         reg_ser_r_stat_din stat;
 618         struct uart_cris_port *up = (struct uart_cris_port *)port;
 619
 620         do {
 621                 stat = REG_RD(ser, up->regi_ser, r_stat_din);
 622         } while (!stat.tr_rdy);
 623         REG_WR_INT(ser, up->regi_ser, rw_dout, c);
 624 }
 625 #endif /* CONFIG_CONSOLE_POLL */
 626
 627 static int etraxfs_uart_startup(struct uart_port *port)
 628 {
 629         struct uart_cris_port *up = (struct uart_cris_port *)port;
 630         unsigned long flags;
 631         reg_ser_rw_intr_mask ser_intr_mask = {0};
 632
 633         ser_intr_mask.dav = regk_ser_yes;
 634
 635         if (request_irq(etraxfs_uart_ports[port->line]->irq, ser_interrupt,
 636                         0, DRV_NAME, etraxfs_uart_ports[port->line]))
 637                 panic("irq ser%d", port->line);
 638
 639         spin_lock_irqsave(&up->port.lock, flags);
 640
 641         REG_WR(ser, up->regi_ser, rw_intr_mask, ser_intr_mask);
 642
 643         etraxfs_uart_set_mctrl(&up->port, up->port.mctrl);
 644
 645         spin_unlock_irqrestore(&up->port.lock, flags);
 646
 647         return 0;
 648 }
 649
 650 static void etraxfs_uart_shutdown(struct uart_port *port)
 651 {
 652         struct uart_cris_port *up = (struct uart_cris_port *)port;
 653         unsigned long flags;
 654
 655         spin_lock_irqsave(&up->port.lock, flags);
 656
 657         etraxfs_uart_stop_tx(port);
 658         etraxfs_uart_stop_rx(port);
 659
 660         free_irq(etraxfs_uart_ports[port->line]->irq,
 661                  etraxfs_uart_ports[port->line]);
 662
 663         etraxfs_uart_set_mctrl(&up->port, up->port.mctrl);
 664
 665         spin_unlock_irqrestore(&up->port.lock, flags);
 666
 667 }
 668
 669 static void
 670 etraxfs_uart_set_termios(struct uart_port *port, struct ktermios *termios,
 671                          struct ktermios *old)
 672 {
 673         struct uart_cris_port *up = (struct uart_cris_port *)port;
 674         unsigned long flags;
 675         reg_ser_rw_xoff xoff;
 676         reg_ser_rw_xoff_clr xoff_clr = {0};
 677         reg_ser_rw_tr_ctrl tx_ctrl = {0};
 678         reg_ser_rw_tr_dma_en tx_dma_en = {0};
 679         reg_ser_rw_rec_ctrl rx_ctrl = {0};
 680         reg_ser_rw_tr_baud_div tx_baud_div = {0};
 681         reg_ser_rw_rec_baud_div rx_baud_div = {0};
 682         int baud;
 683
 684         if (old &&
 685             termios->c_cflag == old->c_cflag &&
 686             termios->c_iflag == old->c_iflag)
 687                 return;
 688
 689         /* Tx: 8 bit, no/even parity, 1 stop bit, no cts. */
 690         tx_ctrl.base_freq = regk_ser_f29_493;
 691         tx_ctrl.en = 0;
 692         tx_ctrl.stop = 0;
 693         tx_ctrl.auto_rts = regk_ser_no;
 694         tx_ctrl.txd = 1;
 695         tx_ctrl.auto_cts = 0;
 696         /* Rx: 8 bit, no/even parity. */
 697         rx_ctrl.dma_err = regk_ser_stop;
 698         rx_ctrl.sampling = regk_ser_majority;
 699         rx_ctrl.timeout = 1;
 700
 701         rx_ctrl.rts_n = regk_ser_inactive;
 702
 703         /* Common for tx and rx: 8N1. */
 704         tx_ctrl.data_bits = regk_ser_bits8;
 705         rx_ctrl.data_bits = regk_ser_bits8;
 706         tx_ctrl.par = regk_ser_even;
 707         rx_ctrl.par = regk_ser_even;
 708         tx_ctrl.par_en = regk_ser_no;
 709         rx_ctrl.par_en = regk_ser_no;
 710
 711         tx_ctrl.stop_bits = regk_ser_bits1;
 712
 713         /*
 714          * Change baud-rate and write it to the hardware.
 715          *
 716          * baud_clock = base_freq / (divisor*8)
 717          * divisor = base_freq / (baud_clock * 8)
 718          * base_freq is either:
 719          * off, ext, 29.493MHz, 32.000 MHz, 32.768 MHz or 100 MHz
 720          * 20.493MHz is used for standard baudrates
 721          */
 722
 723         /*
 724          * For the console port we keep the original baudrate here.  Not very
 725          * beautiful.
 726          */
 727         if ((port != console_port) || old)
 728                 baud = uart_get_baud_rate(port, termios, old, 0,
 729                                           port->uartclk / 8);
 730         else
 731                 baud = console_baud;
 732
 733         tx_baud_div.div = 29493000 / (8 * baud);
 734         /* Rx uses same as tx. */
 735         rx_baud_div.div = tx_baud_div.div;
 736         rx_ctrl.base_freq = tx_ctrl.base_freq;
 737
 738         if ((termios->c_cflag & CSIZE) == CS7) {
 739                 /* Set 7 bit mode. */
 740                 tx_ctrl.data_bits = regk_ser_bits7;
 741                 rx_ctrl.data_bits = regk_ser_bits7;
 742         }
 743
 744         if (termios->c_cflag & CSTOPB) {
 745                 /* Set 2 stop bit mode. */
 746                 tx_ctrl.stop_bits = regk_ser_bits2;
 747         }
 748
 749         if (termios->c_cflag & PARENB) {
 750                 /* Enable parity. */
 751                 tx_ctrl.par_en = regk_ser_yes;
 752                 rx_ctrl.par_en = regk_ser_yes;
 753         }
 754
 755         if (termios->c_cflag & CMSPAR) {
 756                 if (termios->c_cflag & PARODD) {
 757                         /* Set mark parity if PARODD and CMSPAR. */
 758                         tx_ctrl.par = regk_ser_mark;
 759                         rx_ctrl.par = regk_ser_mark;
 760                 } else {
 761                         tx_ctrl.par = regk_ser_space;
 762                         rx_ctrl.par = regk_ser_space;
 763                 }
 764         } else {
 765                 if (termios->c_cflag & PARODD) {
 766                         /* Set odd parity. */
 767                        tx_ctrl.par = regk_ser_odd;
 768                        rx_ctrl.par = regk_ser_odd;
 769                 }
 770         }
 771
 772         if (termios->c_cflag & CRTSCTS) {
 773                 /* Enable automatic CTS handling. */
 774                 tx_ctrl.auto_cts = regk_ser_yes;
 775         }
 776
 777         /* Make sure the tx and rx are enabled. */
 778         tx_ctrl.en = regk_ser_yes;
 779         rx_ctrl.en = regk_ser_yes;
 780
 781         spin_lock_irqsave(&port->lock, flags);
 782
 783         tx_dma_en.en = 0;
 784         REG_WR(ser, up->regi_ser, rw_tr_dma_en, tx_dma_en);
 785
 786         /* Actually write the control regs (if modified) to the hardware. */
 787         uart_update_timeout(port, termios->c_cflag, port->uartclk/8);
 788         MODIFY_REG(up->regi_ser, rw_rec_baud_div, rx_baud_div);
 789         MODIFY_REG(up->regi_ser, rw_rec_ctrl, rx_ctrl);
 790
 791         MODIFY_REG(up->regi_ser, rw_tr_baud_div, tx_baud_div);
 792         MODIFY_REG(up->regi_ser, rw_tr_ctrl, tx_ctrl);
 793
 794         tx_dma_en.en = 0;
 795         REG_WR(ser, up->regi_ser, rw_tr_dma_en, tx_dma_en);
 796
 797         xoff = REG_RD(ser, up->regi_ser, rw_xoff);
 798
 799         if (up->port.state && up->port.state->port.tty &&
 800             (up->port.state->port.tty->termios.c_iflag & IXON)) {
 801                 xoff.chr = STOP_CHAR(up->port.state->port.tty);
 802                 xoff.automatic = regk_ser_yes;
 803         } else
 804                 xoff.automatic = regk_ser_no;
 805
 806         MODIFY_REG(up->regi_ser, rw_xoff, xoff);
 807
 808         /*
 809          * Make sure we don't start in an automatically shut-off state due to
 810          * a previous early exit.
 811          */
 812         xoff_clr.clr = 1;
 813         REG_WR(ser, up->regi_ser, rw_xoff_clr, xoff_clr);
 814
 815         etraxfs_uart_set_mctrl(&up->port, up->port.mctrl);
 816         spin_unlock_irqrestore(&up->port.lock, flags);
 817 }
 818
 819 static const char *
 820 etraxfs_uart_type(struct uart_port *port)
 821 {
 822         return "CRISv32";
 823 }
 824
 825 static void etraxfs_uart_release_port(struct uart_port *port)
 826 {
 827 }
 828
 829 static int etraxfs_uart_request_port(struct uart_port *port)
 830 {
 831         return 0;
 832 }
 833
 834 static void etraxfs_uart_config_port(struct uart_port *port, int flags)
 835 {
 836         struct uart_cris_port *up = (struct uart_cris_port *)port;
 837
 838         up->port.type = PORT_CRIS;
 839 }
 840
 841 static const struct uart_ops etraxfs_uart_pops = {
 842         .tx_empty = etraxfs_uart_tx_empty,
 843         .set_mctrl = etraxfs_uart_set_mctrl,
 844         .get_mctrl = etraxfs_uart_get_mctrl,
 845         .stop_tx = etraxfs_uart_stop_tx,
 846         .start_tx = etraxfs_uart_start_tx,
 847         .send_xchar = etraxfs_uart_send_xchar,
 848         .stop_rx = etraxfs_uart_stop_rx,
 849         .break_ctl = etraxfs_uart_break_ctl,
 850         .startup = etraxfs_uart_startup,
 851         .shutdown = etraxfs_uart_shutdown,
 852         .set_termios = etraxfs_uart_set_termios,
 853         .type = etraxfs_uart_type,
 854         .release_port = etraxfs_uart_release_port,
 855         .request_port = etraxfs_uart_request_port,
 856         .config_port = etraxfs_uart_config_port,
 857 #ifdef CONFIG_CONSOLE_POLL
 858         .poll_get_char = etraxfs_uart_get_poll_char,
 859         .poll_put_char = etraxfs_uart_put_poll_char,
 860 #endif
 861 };
 862
 863 static void cris_serial_port_init(struct uart_port *port, int line)
 864 {
 865         struct uart_cris_port *up = (struct uart_cris_port *)port;
 866
 867         if (up->initialized)
 868                 return;
 869         up->initialized = 1;
 870         port->line = line;
 871         spin_lock_init(&port->lock);
 872         port->ops = &etraxfs_uart_pops;
 873         port->irq = up->irq;
 874         port->iobase = (unsigned long) up->regi_ser;
 875         port->uartclk = 29493000;
 876
 877         /*
 878          * We can't fit any more than 255 here (unsigned char), though
 879          * actually UART_XMIT_SIZE characters could be pending output.
 880          * At time of this writing, the definition of "fifosize" is here the
 881          * amount of characters that can be pending output after a start_tx call
 882          * until tx_empty returns 1: see serial_core.c:uart_wait_until_sent.
 883          * This matters for timeout calculations unfortunately, but keeping
 884          * larger amounts at the DMA wouldn't win much so let's just play nice.
 885          */
 886         port->fifosize = 255;
 887         port->flags = UPF_BOOT_AUTOCONF;
 888 }
 889
 890 static int etraxfs_uart_probe(struct platform_device *pdev)
 891 {
 892         struct device_node *np = pdev->dev.of_node;
 893         struct uart_cris_port *up;
 894         int dev_id;
 895
 896         if (!np)
 897                 return -ENODEV;
 898
 899         dev_id = of_alias_get_id(np, "serial");
 900         if (dev_id < 0)
 901                 dev_id = 0;
 902
 903         if (dev_id >= UART_NR)
 904                 return -EINVAL;
 905
 906         if (etraxfs_uart_ports[dev_id])
 907                 return -EBUSY;
 908
 909         up = devm_kzalloc(&pdev->dev, sizeof(struct uart_cris_port),
 910                           GFP_KERNEL);
 911         if (!up)
 912                 return -ENOMEM;
 913
 914         up->irq = irq_of_parse_and_map(np, 0);
 915         up->regi_ser = of_iomap(np, 0);
 916         up->dtr_pin = devm_gpiod_get_optional(&pdev->dev, "dtr");
 917         up->dsr_pin = devm_gpiod_get_optional(&pdev->dev, "dsr");
 918         up->ri_pin = devm_gpiod_get_optional(&pdev->dev, "ri");
 919         up->cd_pin = devm_gpiod_get_optional(&pdev->dev, "cd");
 920         up->port.dev = &pdev->dev;
 921         cris_serial_port_init(&up->port, dev_id);
 922
 923         etraxfs_uart_ports[dev_id] = up;
 924         platform_set_drvdata(pdev, &up->port);
 925         uart_add_one_port(&etraxfs_uart_driver, &up->port);
 926
 927         return 0;
 928 }
 929
 930 static int etraxfs_uart_remove(struct platform_device *pdev)
 931 {
 932         struct uart_port *port;
 933
 934         port = platform_get_drvdata(pdev);
 935         uart_remove_one_port(&etraxfs_uart_driver, port);
 936         etraxfs_uart_ports[port->line] = NULL;
 937
 938         return 0;
 939 }
 940
 941 static const struct of_device_id etraxfs_uart_dt_ids[] = {
 942         { .compatible = "axis,etraxfs-uart" },
 943         { /* sentinel */ }
 944 };
 945
 946 MODULE_DEVICE_TABLE(of, etraxfs_uart_dt_ids);
 947
 948 static struct platform_driver etraxfs_uart_platform_driver = {
 949         .driver = {
 950                 .name   = DRV_NAME,
 951                 .of_match_table = of_match_ptr(etraxfs_uart_dt_ids),
 952         },
 953         .probe          = etraxfs_uart_probe,
 954         .remove         = etraxfs_uart_remove,
 955 };
 956
 957 static int __init etraxfs_uart_init(void)
 958 {
 959         int ret;
 960
 961         ret = uart_register_driver(&etraxfs_uart_driver);
 962         if (ret)
 963                 return ret;
 964
 965         ret = platform_driver_register(&etraxfs_uart_platform_driver);
 966         if (ret)
 967                 uart_unregister_driver(&etraxfs_uart_driver);
 968
 969         return ret;
 970 }
 971
 972 static void __exit etraxfs_uart_exit(void)
 973 {
 974         platform_driver_unregister(&etraxfs_uart_platform_driver);
 975         uart_unregister_driver(&etraxfs_uart_driver);
 976 }
 977
 978 module_init(etraxfs_uart_init);
 979 module_exit(etraxfs_uart_exit);