drivers/tty/serial/m32r_sio.c

   1 /*
   2  *  m32r_sio.c
   3  *
   4  *  Driver for M32R serial ports
   5  *
   6  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
   7  *  Based on drivers/serial/8250.c.
   8  *
   9  *  Copyright (C) 2001  Russell King.
  10  *  Copyright (C) 2004  Hirokazu Takata <takata at linux-m32r.org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  */
  17
  18 /*
  19  * A note about mapbase / membase
  20  *
  21  *  mapbase is the physical address of the IO port.  Currently, we don't
  22  *  support this very well, and it may well be dropped from this driver
  23  *  in future.  As such, mapbase should be NULL.
  24  *
  25  *  membase is an 'ioremapped' cookie.  This is compatible with the old
  26  *  serial.c driver, and is currently the preferred form.
  27  */
  28
  29 #if defined(CONFIG_SERIAL_M32R_SIO_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  30 #define SUPPORT_SYSRQ
  31 #endif
  32
  33 #include <linux/module.h>
  34 #include <linux/tty.h>
  35 #include <linux/tty_flip.h>
  36 #include <linux/ioport.h>
  37 #include <linux/init.h>
  38 #include <linux/console.h>
  39 #include <linux/sysrq.h>
  40 #include <linux/serial.h>
  41 #include <linux/delay.h>
  42
  43 #include <asm/m32r.h>
  44 #include <asm/io.h>
  45 #include <asm/irq.h>
  46
  47 #define BAUD_RATE       115200
  48
  49 #include <linux/serial_core.h>
  50 #include "m32r_sio.h"
  51 #include "m32r_sio_reg.h"
  52
  53 /*
  54  * Debugging.
  55  */
  56 #if 0
  57 #define DEBUG_AUTOCONF(fmt...)  printk(fmt)
  58 #else
  59 #define DEBUG_AUTOCONF(fmt...)  do { } while (0)
  60 #endif
  61
  62 #if 0
  63 #define DEBUG_INTR(fmt...)      printk(fmt)
  64 #else
  65 #define DEBUG_INTR(fmt...)      do { } while (0)
  66 #endif
  67
  68 #define PASS_LIMIT      256
  69
  70 #define BASE_BAUD       115200
  71
  72 /* Standard COM flags */
  73 #define STD_COM_FLAGS (UPF_BOOT_AUTOCONF | UPF_SKIP_TEST)
  74
  75 /*
  76  * SERIAL_PORT_DFNS tells us about built-in ports that have no
  77  * standard enumeration mechanism.   Platforms that can find all
  78  * serial ports via mechanisms like ACPI or PCI need not supply it.
  79  */
  80 #if defined(CONFIG_PLAT_USRV)
  81
  82 #define SERIAL_PORT_DFNS                                                \
  83        /* UART  CLK     PORT   IRQ            FLAGS */                  \
  84         { 0, BASE_BAUD, 0x3F8, PLD_IRQ_UART0, STD_COM_FLAGS }, /* ttyS0 */ \
  85         { 0, BASE_BAUD, 0x2F8, PLD_IRQ_UART1, STD_COM_FLAGS }, /* ttyS1 */
  86
  87 #else /* !CONFIG_PLAT_USRV */
  88
  89 #if defined(CONFIG_SERIAL_M32R_PLDSIO)
  90 #define SERIAL_PORT_DFNS                                                \
  91         { 0, BASE_BAUD, ((unsigned long)PLD_ESIO0CR), PLD_IRQ_SIO0_RCV, \
  92           STD_COM_FLAGS }, /* ttyS0 */
  93 #else
  94 #define SERIAL_PORT_DFNS                                                \
  95         { 0, BASE_BAUD, M32R_SIO_OFFSET, M32R_IRQ_SIO0_R,               \
  96           STD_COM_FLAGS }, /* ttyS0 */
  97 #endif
  98
  99 #endif /* !CONFIG_PLAT_USRV */
 100
 101 static struct old_serial_port old_serial_port[] = {
 102         SERIAL_PORT_DFNS
 103 };
 104
 105 #define UART_NR ARRAY_SIZE(old_serial_port)
 106
 107 struct uart_sio_port {
 108         struct uart_port        port;
 109         struct timer_list       timer;          /* "no irq" timer */
 110         struct list_head        list;           /* ports on this IRQ */
 111         unsigned short          rev;
 112         unsigned char           acr;
 113         unsigned char           ier;
 114         unsigned char           lcr;
 115         unsigned char           mcr_mask;       /* mask of user bits */
 116         unsigned char           mcr_force;      /* mask of forced bits */
 117         unsigned char           lsr_break_flag;
 118
 119         /*
 120          * We provide a per-port pm hook.
 121          */
 122         void                    (*pm)(struct uart_port *port,
 123                                       unsigned int state, unsigned int old);
 124 };
 125
 126 struct irq_info {
 127         spinlock_t              lock;
 128         struct list_head        *head;
 129 };
 130
 131 static struct irq_info irq_lists[NR_IRQS];
 132
 133 #ifdef CONFIG_SERIAL_M32R_PLDSIO
 134
 135 #define __sio_in(x) inw((unsigned long)(x))
 136 #define __sio_out(v,x) outw((v),(unsigned long)(x))
 137
 138 static inline void sio_set_baud_rate(unsigned long baud)
 139 {
 140         unsigned short sbaud;
 141         sbaud = (boot_cpu_data.bus_clock / (baud * 4))-1;
 142         __sio_out(sbaud, PLD_ESIO0BAUR);
 143 }
 144
 145 static void sio_reset(void)
 146 {
 147         unsigned short tmp;
 148
 149         tmp = __sio_in(PLD_ESIO0RXB);
 150         tmp = __sio_in(PLD_ESIO0RXB);
 151         tmp = __sio_in(PLD_ESIO0CR);
 152         sio_set_baud_rate(BAUD_RATE);
 153         __sio_out(0x0300, PLD_ESIO0CR);
 154         __sio_out(0x0003, PLD_ESIO0CR);
 155 }
 156
 157 static void sio_init(void)
 158 {
 159         unsigned short tmp;
 160
 161         tmp = __sio_in(PLD_ESIO0RXB);
 162         tmp = __sio_in(PLD_ESIO0RXB);
 163         tmp = __sio_in(PLD_ESIO0CR);
 164         __sio_out(0x0300, PLD_ESIO0CR);
 165         __sio_out(0x0003, PLD_ESIO0CR);
 166 }
 167
 168 static void sio_error(int *status)
 169 {
 170         printk("SIO0 error[%04x]\n", *status);
 171         do {
 172                 sio_init();
 173         } while ((*status = __sio_in(PLD_ESIO0CR)) != 3);
 174 }
 175
 176 #else /* not CONFIG_SERIAL_M32R_PLDSIO */
 177
 178 #define __sio_in(x) inl(x)
 179 #define __sio_out(v,x) outl((v),(x))
 180
 181 static inline void sio_set_baud_rate(unsigned long baud)
 182 {
 183         unsigned long i, j;
 184
 185         i = boot_cpu_data.bus_clock / (baud * 16);
 186         j = (boot_cpu_data.bus_clock - (i * baud * 16)) / baud;
 187         i -= 1;
 188         j = (j + 1) >> 1;
 189
 190         __sio_out(i, M32R_SIO0_BAUR_PORTL);
 191         __sio_out(j, M32R_SIO0_RBAUR_PORTL);
 192 }
 193
 194 static void sio_reset(void)
 195 {
 196         __sio_out(0x00000300, M32R_SIO0_CR_PORTL);      /* init status */
 197         __sio_out(0x00000800, M32R_SIO0_MOD1_PORTL);    /* 8bit        */
 198         __sio_out(0x00000080, M32R_SIO0_MOD0_PORTL);    /* 1stop non   */
 199         sio_set_baud_rate(BAUD_RATE);
 200         __sio_out(0x00000000, M32R_SIO0_TRCR_PORTL);
 201         __sio_out(0x00000003, M32R_SIO0_CR_PORTL);      /* RXCEN */
 202 }
 203
 204 static void sio_init(void)
 205 {
 206         unsigned int tmp;
 207
 208         tmp = __sio_in(M32R_SIO0_RXB_PORTL);
 209         tmp = __sio_in(M32R_SIO0_RXB_PORTL);
 210         tmp = __sio_in(M32R_SIO0_STS_PORTL);
 211         __sio_out(0x00000003, M32R_SIO0_CR_PORTL);
 212 }
 213
 214 static void sio_error(int *status)
 215 {
 216         printk("SIO0 error[%04x]\n", *status);
 217         do {
 218                 sio_init();
 219         } while ((*status = __sio_in(M32R_SIO0_CR_PORTL)) != 3);
 220 }
 221
 222 #endif /* CONFIG_SERIAL_M32R_PLDSIO */
 223
 224 static unsigned int sio_in(struct uart_sio_port *up, int offset)
 225 {
 226         return __sio_in(up->port.iobase + offset);
 227 }
 228
 229 static void sio_out(struct uart_sio_port *up, int offset, int value)
 230 {
 231         __sio_out(value, up->port.iobase + offset);
 232 }
 233
 234 static unsigned int serial_in(struct uart_sio_port *up, int offset)
 235 {
 236         if (!offset)
 237                 return 0;
 238
 239         return __sio_in(offset);
 240 }
 241
 242 static void serial_out(struct uart_sio_port *up, int offset, int value)
 243 {
 244         if (!offset)
 245                 return;
 246
 247         __sio_out(value, offset);
 248 }
 249
 250 static void m32r_sio_stop_tx(struct uart_port *port)
 251 {
 252         struct uart_sio_port *up = (struct uart_sio_port *)port;
 253
 254         if (up->ier & UART_IER_THRI) {
 255                 up->ier &= ~UART_IER_THRI;
 256                 serial_out(up, UART_IER, up->ier);
 257         }
 258 }
 259
 260 static void m32r_sio_start_tx(struct uart_port *port)
 261 {
 262 #ifdef CONFIG_SERIAL_M32R_PLDSIO
 263         struct uart_sio_port *up = (struct uart_sio_port *)port;
 264         struct circ_buf *xmit = &up->port.state->xmit;
 265
 266         if (!(up->ier & UART_IER_THRI)) {
 267                 up->ier |= UART_IER_THRI;
 268                 serial_out(up, UART_IER, up->ier);
 269                 if (!uart_circ_empty(xmit)) {
 270                         serial_out(up, UART_TX, xmit->buf[xmit->tail]);
 271                         xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 272                         up->port.icount.tx++;
 273                 }
 274         }
 275         while((serial_in(up, UART_LSR) & UART_EMPTY) != UART_EMPTY);
 276 #else
 277         struct uart_sio_port *up = (struct uart_sio_port *)port;
 278
 279         if (!(up->ier & UART_IER_THRI)) {
 280                 up->ier |= UART_IER_THRI;
 281                 serial_out(up, UART_IER, up->ier);
 282         }
 283 #endif
 284 }
 285
 286 static void m32r_sio_stop_rx(struct uart_port *port)
 287 {
 288         struct uart_sio_port *up = (struct uart_sio_port *)port;
 289
 290         up->ier &= ~UART_IER_RLSI;
 291         up->port.read_status_mask &= ~UART_LSR_DR;
 292         serial_out(up, UART_IER, up->ier);
 293 }
 294
 295 static void m32r_sio_enable_ms(struct uart_port *port)
 296 {
 297         struct uart_sio_port *up = (struct uart_sio_port *)port;
 298
 299         up->ier |= UART_IER_MSI;
 300         serial_out(up, UART_IER, up->ier);
 301 }
 302
 303 static void receive_chars(struct uart_sio_port *up, int *status)
 304 {
 305         struct tty_port *port = &up->port.state->port;
 306         unsigned char ch;
 307         unsigned char flag;
 308         int max_count = 256;
 309
 310         do {
 311                 ch = sio_in(up, SIORXB);
 312                 flag = TTY_NORMAL;
 313                 up->port.icount.rx++;
 314
 315                 if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
 316                                        UART_LSR_FE | UART_LSR_OE))) {
 317                         /*
 318                          * For statistics only
 319                          */
 320                         if (*status & UART_LSR_BI) {
 321                                 *status &= ~(UART_LSR_FE | UART_LSR_PE);
 322                                 up->port.icount.brk++;
 323                                 /*
 324                                  * We do the SysRQ and SAK checking
 325                                  * here because otherwise the break
 326                                  * may get masked by ignore_status_mask
 327                                  * or read_status_mask.
 328                                  */
 329                                 if (uart_handle_break(&up->port))
 330                                         goto ignore_char;
 331                         } else if (*status & UART_LSR_PE)
 332                                 up->port.icount.parity++;
 333                         else if (*status & UART_LSR_FE)
 334                                 up->port.icount.frame++;
 335                         if (*status & UART_LSR_OE)
 336                                 up->port.icount.overrun++;
 337
 338                         /*
 339                          * Mask off conditions which should be ingored.
 340                          */
 341                         *status &= up->port.read_status_mask;
 342
 343                         if (up->port.line == up->port.cons->index) {
 344                                 /* Recover the break flag from console xmit */
 345                                 *status |= up->lsr_break_flag;
 346                                 up->lsr_break_flag = 0;
 347                         }
 348
 349                         if (*status & UART_LSR_BI) {
 350                                 DEBUG_INTR("handling break....");
 351                                 flag = TTY_BREAK;
 352                         } else if (*status & UART_LSR_PE)
 353                                 flag = TTY_PARITY;
 354                         else if (*status & UART_LSR_FE)
 355                                 flag = TTY_FRAME;
 356                 }
 357                 if (uart_handle_sysrq_char(&up->port, ch))
 358                         goto ignore_char;
 359                 if ((*status & up->port.ignore_status_mask) == 0)
 360                         tty_insert_flip_char(port, ch, flag);
 361
 362                 if (*status & UART_LSR_OE) {
 363                         /*
 364                          * Overrun is special, since it's reported
 365                          * immediately, and doesn't affect the current
 366                          * character.
 367                          */
 368                         tty_insert_flip_char(port, 0, TTY_OVERRUN);
 369                 }
 370         ignore_char:
 371                 *status = serial_in(up, UART_LSR);
 372         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
 373
 374         spin_unlock(&up->port.lock);
 375         tty_flip_buffer_push(port);
 376         spin_lock(&up->port.lock);
 377 }
 378
 379 static void transmit_chars(struct uart_sio_port *up)
 380 {
 381         struct circ_buf *xmit = &up->port.state->xmit;
 382         int count;
 383
 384         if (up->port.x_char) {
 385 #ifndef CONFIG_SERIAL_M32R_PLDSIO       /* XXX */
 386                 serial_out(up, UART_TX, up->port.x_char);
 387 #endif
 388                 up->port.icount.tx++;
 389                 up->port.x_char = 0;
 390                 return;
 391         }
 392         if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
 393                 m32r_sio_stop_tx(&up->port);
 394                 return;
 395         }
 396
 397         count = up->port.fifosize;
 398         do {
 399                 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
 400                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 401                 up->port.icount.tx++;
 402                 if (uart_circ_empty(xmit))
 403                         break;
 404                 while (!(serial_in(up, UART_LSR) & UART_LSR_THRE));
 405
 406         } while (--count > 0);
 407
 408         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 409                 uart_write_wakeup(&up->port);
 410
 411         DEBUG_INTR("THRE...");
 412
 413         if (uart_circ_empty(xmit))
 414                 m32r_sio_stop_tx(&up->port);
 415 }
 416
 417 /*
 418  * This handles the interrupt from one port.
 419  */
 420 static inline void m32r_sio_handle_port(struct uart_sio_port *up,
 421         unsigned int status)
 422 {
 423         DEBUG_INTR("status = %x...", status);
 424
 425         if (status & 0x04)
 426                 receive_chars(up, &status);
 427         if (status & 0x01)
 428                 transmit_chars(up);
 429 }
 430
 431 /*
 432  * This is the serial driver's interrupt routine.
 433  *
 434  * Arjan thinks the old way was overly complex, so it got simplified.
 435  * Alan disagrees, saying that need the complexity to handle the weird
 436  * nature of ISA shared interrupts.  (This is a special exception.)
 437  *
 438  * In order to handle ISA shared interrupts properly, we need to check
 439  * that all ports have been serviced, and therefore the ISA interrupt
 440  * line has been de-asserted.
 441  *
 442  * This means we need to loop through all ports. checking that they
 443  * don't have an interrupt pending.
 444  */
 445 static irqreturn_t m32r_sio_interrupt(int irq, void *dev_id)
 446 {
 447         struct irq_info *i = dev_id;
 448         struct list_head *l, *end = NULL;
 449         int pass_counter = 0;
 450
 451         DEBUG_INTR("m32r_sio_interrupt(%d)...", irq);
 452
 453 #ifdef CONFIG_SERIAL_M32R_PLDSIO
 454 //      if (irq == PLD_IRQ_SIO0_SND)
 455 //              irq = PLD_IRQ_SIO0_RCV;
 456 #else
 457         if (irq == M32R_IRQ_SIO0_S)
 458                 irq = M32R_IRQ_SIO0_R;
 459 #endif
 460
 461         spin_lock(&i->lock);
 462
 463         l = i->head;
 464         do {
 465                 struct uart_sio_port *up;
 466                 unsigned int sts;
 467
 468                 up = list_entry(l, struct uart_sio_port, list);
 469
 470                 sts = sio_in(up, SIOSTS);
 471                 if (sts & 0x5) {
 472                         spin_lock(&up->port.lock);
 473                         m32r_sio_handle_port(up, sts);
 474                         spin_unlock(&up->port.lock);
 475
 476                         end = NULL;
 477                 } else if (end == NULL)
 478                         end = l;
 479
 480                 l = l->next;
 481
 482                 if (l == i->head && pass_counter++ > PASS_LIMIT) {
 483                         if (sts & 0xe0)
 484                                 sio_error(&sts);
 485                         break;
 486                 }
 487         } while (l != end);
 488
 489         spin_unlock(&i->lock);
 490
 491         DEBUG_INTR("end.\n");
 492
 493         return IRQ_HANDLED;
 494 }
 495
 496 /*
 497  * To support ISA shared interrupts, we need to have one interrupt
 498  * handler that ensures that the IRQ line has been deasserted
 499  * before returning.  Failing to do this will result in the IRQ
 500  * line being stuck active, and, since ISA irqs are edge triggered,
 501  * no more IRQs will be seen.
 502  */
 503 static void serial_do_unlink(struct irq_info *i, struct uart_sio_port *up)
 504 {
 505         spin_lock_irq(&i->lock);
 506
 507         if (!list_empty(i->head)) {
 508                 if (i->head == &up->list)
 509                         i->head = i->head->next;
 510                 list_del(&up->list);
 511         } else {
 512                 BUG_ON(i->head != &up->list);
 513                 i->head = NULL;
 514         }
 515
 516         spin_unlock_irq(&i->lock);
 517 }
 518
 519 static int serial_link_irq_chain(struct uart_sio_port *up)
 520 {
 521         struct irq_info *i = irq_lists + up->port.irq;
 522         int ret, irq_flags = 0;
 523
 524         spin_lock_irq(&i->lock);
 525
 526         if (i->head) {
 527                 list_add(&up->list, i->head);
 528                 spin_unlock_irq(&i->lock);
 529
 530                 ret = 0;
 531         } else {
 532                 INIT_LIST_HEAD(&up->list);
 533                 i->head = &up->list;
 534                 spin_unlock_irq(&i->lock);
 535
 536                 ret = request_irq(up->port.irq, m32r_sio_interrupt,
 537                                   irq_flags, "SIO0-RX", i);
 538                 ret |= request_irq(up->port.irq + 1, m32r_sio_interrupt,
 539                                   irq_flags, "SIO0-TX", i);
 540                 if (ret < 0)
 541                         serial_do_unlink(i, up);
 542         }
 543
 544         return ret;
 545 }
 546
 547 static void serial_unlink_irq_chain(struct uart_sio_port *up)
 548 {
 549         struct irq_info *i = irq_lists + up->port.irq;
 550
 551         BUG_ON(i->head == NULL);
 552
 553         if (list_empty(i->head)) {
 554                 free_irq(up->port.irq, i);
 555                 free_irq(up->port.irq + 1, i);
 556         }
 557
 558         serial_do_unlink(i, up);
 559 }
 560
 561 /*
 562  * This function is used to handle ports that do not have an interrupt.
 563  */
 564 static void m32r_sio_timeout(unsigned long data)
 565 {
 566         struct uart_sio_port *up = (struct uart_sio_port *)data;
 567         unsigned int timeout;
 568         unsigned int sts;
 569
 570         sts = sio_in(up, SIOSTS);
 571         if (sts & 0x5) {
 572                 spin_lock(&up->port.lock);
 573                 m32r_sio_handle_port(up, sts);
 574                 spin_unlock(&up->port.lock);
 575         }
 576
 577         timeout = up->port.timeout;
 578         timeout = timeout > 6 ? (timeout / 2 - 2) : 1;
 579         mod_timer(&up->timer, jiffies + timeout);
 580 }
 581
 582 static unsigned int m32r_sio_tx_empty(struct uart_port *port)
 583 {
 584         struct uart_sio_port *up = (struct uart_sio_port *)port;
 585         unsigned long flags;
 586         unsigned int ret;
 587
 588         spin_lock_irqsave(&up->port.lock, flags);
 589         ret = serial_in(up, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
 590         spin_unlock_irqrestore(&up->port.lock, flags);
 591
 592         return ret;
 593 }
 594
 595 static unsigned int m32r_sio_get_mctrl(struct uart_port *port)
 596 {
 597         return 0;
 598 }
 599
 600 static void m32r_sio_set_mctrl(struct uart_port *port, unsigned int mctrl)
 601 {
 602
 603 }
 604
 605 static void m32r_sio_break_ctl(struct uart_port *port, int break_state)
 606 {
 607
 608 }
 609
 610 static int m32r_sio_startup(struct uart_port *port)
 611 {
 612         struct uart_sio_port *up = (struct uart_sio_port *)port;
 613         int retval;
 614
 615         sio_init();
 616
 617         /*
 618          * If the "interrupt" for this port doesn't correspond with any
 619          * hardware interrupt, we use a timer-based system.  The original
 620          * driver used to do this with IRQ0.
 621          */
 622         if (!up->port.irq) {
 623                 unsigned int timeout = up->port.timeout;
 624
 625                 timeout = timeout > 6 ? (timeout / 2 - 2) : 1;
 626
 627                 up->timer.data = (unsigned long)up;
 628                 mod_timer(&up->timer, jiffies + timeout);
 629         } else {
 630                 retval = serial_link_irq_chain(up);
 631                 if (retval)
 632                         return retval;
 633         }
 634
 635         /*
 636          * Finally, enable interrupts.  Note: Modem status interrupts
 637          * are set via set_termios(), which will be occurring imminently
 638          * anyway, so we don't enable them here.
 639          * - M32R_SIO: 0x0c
 640          * - M32R_PLDSIO: 0x04
 641          */
 642         up->ier = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
 643         sio_out(up, SIOTRCR, up->ier);
 644
 645         /*
 646          * And clear the interrupt registers again for luck.
 647          */
 648         sio_reset();
 649
 650         return 0;
 651 }
 652
 653 static void m32r_sio_shutdown(struct uart_port *port)
 654 {
 655         struct uart_sio_port *up = (struct uart_sio_port *)port;
 656
 657         /*
 658          * Disable interrupts from this port
 659          */
 660         up->ier = 0;
 661         sio_out(up, SIOTRCR, 0);
 662
 663         /*
 664          * Disable break condition and FIFOs
 665          */
 666
 667         sio_init();
 668
 669         if (!up->port.irq)
 670                 del_timer_sync(&up->timer);
 671         else
 672                 serial_unlink_irq_chain(up);
 673 }
 674
 675 static unsigned int m32r_sio_get_divisor(struct uart_port *port,
 676         unsigned int baud)
 677 {
 678         return uart_get_divisor(port, baud);
 679 }
 680
 681 static void m32r_sio_set_termios(struct uart_port *port,
 682         struct ktermios *termios, struct ktermios *old)
 683 {
 684         struct uart_sio_port *up = (struct uart_sio_port *)port;
 685         unsigned char cval = 0;
 686         unsigned long flags;
 687         unsigned int baud, quot;
 688
 689         switch (termios->c_cflag & CSIZE) {
 690         case CS5:
 691                 cval = UART_LCR_WLEN5;
 692                 break;
 693         case CS6:
 694                 cval = UART_LCR_WLEN6;
 695                 break;
 696         case CS7:
 697                 cval = UART_LCR_WLEN7;
 698                 break;
 699         default:
 700         case CS8:
 701                 cval = UART_LCR_WLEN8;
 702                 break;
 703         }
 704
 705         if (termios->c_cflag & CSTOPB)
 706                 cval |= UART_LCR_STOP;
 707         if (termios->c_cflag & PARENB)
 708                 cval |= UART_LCR_PARITY;
 709         if (!(termios->c_cflag & PARODD))
 710                 cval |= UART_LCR_EPAR;
 711 #ifdef CMSPAR
 712         if (termios->c_cflag & CMSPAR)
 713                 cval |= UART_LCR_SPAR;
 714 #endif
 715
 716         /*
 717          * Ask the core to calculate the divisor for us.
 718          */
 719 #ifdef CONFIG_SERIAL_M32R_PLDSIO
 720         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/4);
 721 #else
 722         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
 723 #endif
 724         quot = m32r_sio_get_divisor(port, baud);
 725
 726         /*
 727          * Ok, we're now changing the port state.  Do it with
 728          * interrupts disabled.
 729          */
 730         spin_lock_irqsave(&up->port.lock, flags);
 731
 732         sio_set_baud_rate(baud);
 733
 734         /*
 735          * Update the per-port timeout.
 736          */
 737         uart_update_timeout(port, termios->c_cflag, baud);
 738
 739         up->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
 740         if (termios->c_iflag & INPCK)
 741                 up->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE;
 742         if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
 743                 up->port.read_status_mask |= UART_LSR_BI;
 744
 745         /*
 746          * Characteres to ignore
 747          */
 748         up->port.ignore_status_mask = 0;
 749         if (termios->c_iflag & IGNPAR)
 750                 up->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
 751         if (termios->c_iflag & IGNBRK) {
 752                 up->port.ignore_status_mask |= UART_LSR_BI;
 753                 /*
 754                  * If we're ignoring parity and break indicators,
 755                  * ignore overruns too (for real raw support).
 756                  */
 757                 if (termios->c_iflag & IGNPAR)
 758                         up->port.ignore_status_mask |= UART_LSR_OE;
 759         }
 760
 761         /*
 762          * ignore all characters if CREAD is not set
 763          */
 764         if ((termios->c_cflag & CREAD) == 0)
 765                 up->port.ignore_status_mask |= UART_LSR_DR;
 766
 767         /*
 768          * CTS flow control flag and modem status interrupts
 769          */
 770         up->ier &= ~UART_IER_MSI;
 771         if (UART_ENABLE_MS(&up->port, termios->c_cflag))
 772                 up->ier |= UART_IER_MSI;
 773
 774         serial_out(up, UART_IER, up->ier);
 775
 776         up->lcr = cval;                                 /* Save LCR */
 777         spin_unlock_irqrestore(&up->port.lock, flags);
 778 }
 779
 780 static void m32r_sio_pm(struct uart_port *port, unsigned int state,
 781         unsigned int oldstate)
 782 {
 783         struct uart_sio_port *up = (struct uart_sio_port *)port;
 784
 785         if (up->pm)
 786                 up->pm(port, state, oldstate);
 787 }
 788
 789 /*
 790  * Resource handling.  This is complicated by the fact that resources
 791  * depend on the port type.  Maybe we should be claiming the standard
 792  * 8250 ports, and then trying to get other resources as necessary?
 793  */
 794 static int
 795 m32r_sio_request_std_resource(struct uart_sio_port *up, struct resource **res)
 796 {
 797         unsigned int size = 8 << up->port.regshift;
 798 #ifndef CONFIG_SERIAL_M32R_PLDSIO
 799         unsigned long start;
 800 #endif
 801         int ret = 0;
 802
 803         switch (up->port.iotype) {
 804         case UPIO_MEM:
 805                 if (up->port.mapbase) {
 806 #ifdef CONFIG_SERIAL_M32R_PLDSIO
 807                         *res = request_mem_region(up->port.mapbase, size, "serial");
 808 #else
 809                         start = up->port.mapbase;
 810                         *res = request_mem_region(start, size, "serial");
 811 #endif
 812                         if (!*res)
 813                                 ret = -EBUSY;
 814                 }
 815                 break;
 816
 817         case UPIO_PORT:
 818                 *res = request_region(up->port.iobase, size, "serial");
 819                 if (!*res)
 820                         ret = -EBUSY;
 821                 break;
 822         }
 823         return ret;
 824 }
 825
 826 static void m32r_sio_release_port(struct uart_port *port)
 827 {
 828         struct uart_sio_port *up = (struct uart_sio_port *)port;
 829         unsigned long start, offset = 0, size = 0;
 830
 831         size <<= up->port.regshift;
 832
 833         switch (up->port.iotype) {
 834         case UPIO_MEM:
 835                 if (up->port.mapbase) {
 836                         /*
 837                          * Unmap the area.
 838                          */
 839                         iounmap(up->port.membase);
 840                         up->port.membase = NULL;
 841
 842                         start = up->port.mapbase;
 843
 844                         if (size)
 845                                 release_mem_region(start + offset, size);
 846                         release_mem_region(start, 8 << up->port.regshift);
 847                 }
 848                 break;
 849
 850         case UPIO_PORT:
 851                 start = up->port.iobase;
 852
 853                 if (size)
 854                         release_region(start + offset, size);
 855                 release_region(start + offset, 8 << up->port.regshift);
 856                 break;
 857
 858         default:
 859                 break;
 860         }
 861 }
 862
 863 static int m32r_sio_request_port(struct uart_port *port)
 864 {
 865         struct uart_sio_port *up = (struct uart_sio_port *)port;
 866         struct resource *res = NULL;
 867         int ret = 0;
 868
 869         ret = m32r_sio_request_std_resource(up, &res);
 870
 871         /*
 872          * If we have a mapbase, then request that as well.
 873          */
 874         if (ret == 0 && up->port.flags & UPF_IOREMAP) {
 875                 int size = resource_size(res);
 876
 877                 up->port.membase = ioremap(up->port.mapbase, size);
 878                 if (!up->port.membase)
 879                         ret = -ENOMEM;
 880         }
 881
 882         if (ret < 0) {
 883                 if (res)
 884                         release_resource(res);
 885         }
 886
 887         return ret;
 888 }
 889
 890 static void m32r_sio_config_port(struct uart_port *port, int unused)
 891 {
 892         struct uart_sio_port *up = (struct uart_sio_port *)port;
 893         unsigned long flags;
 894
 895         spin_lock_irqsave(&up->port.lock, flags);
 896
 897         up->port.fifosize = 1;
 898
 899         spin_unlock_irqrestore(&up->port.lock, flags);
 900 }
 901
 902 static int
 903 m32r_sio_verify_port(struct uart_port *port, struct serial_struct *ser)
 904 {
 905         if (ser->irq >= nr_irqs || ser->irq < 0 || ser->baud_base < 9600)
 906                 return -EINVAL;
 907         return 0;
 908 }
 909
 910 static struct uart_ops m32r_sio_pops = {
 911         .tx_empty       = m32r_sio_tx_empty,
 912         .set_mctrl      = m32r_sio_set_mctrl,
 913         .get_mctrl      = m32r_sio_get_mctrl,
 914         .stop_tx        = m32r_sio_stop_tx,
 915         .start_tx       = m32r_sio_start_tx,
 916         .stop_rx        = m32r_sio_stop_rx,
 917         .enable_ms      = m32r_sio_enable_ms,
 918         .break_ctl      = m32r_sio_break_ctl,
 919         .startup        = m32r_sio_startup,
 920         .shutdown       = m32r_sio_shutdown,
 921         .set_termios    = m32r_sio_set_termios,
 922         .pm             = m32r_sio_pm,
 923         .release_port   = m32r_sio_release_port,
 924         .request_port   = m32r_sio_request_port,
 925         .config_port    = m32r_sio_config_port,
 926         .verify_port    = m32r_sio_verify_port,
 927 };
 928
 929 static struct uart_sio_port m32r_sio_ports[UART_NR];
 930
 931 static void __init m32r_sio_init_ports(void)
 932 {
 933         struct uart_sio_port *up;
 934         static int first = 1;
 935         int i;
 936
 937         if (!first)
 938                 return;
 939         first = 0;
 940
 941         for (i = 0, up = m32r_sio_ports; i < ARRAY_SIZE(old_serial_port);
 942              i++, up++) {
 943                 up->port.iobase   = old_serial_port[i].port;
 944                 up->port.irq      = irq_canonicalize(old_serial_port[i].irq);
 945                 up->port.uartclk  = old_serial_port[i].baud_base * 16;
 946                 up->port.flags    = old_serial_port[i].flags;
 947                 up->port.membase  = old_serial_port[i].iomem_base;
 948                 up->port.iotype   = old_serial_port[i].io_type;
 949                 up->port.regshift = old_serial_port[i].iomem_reg_shift;
 950                 up->port.ops      = &m32r_sio_pops;
 951         }
 952 }
 953
 954 static void __init m32r_sio_register_ports(struct uart_driver *drv)
 955 {
 956         int i;
 957
 958         m32r_sio_init_ports();
 959
 960         for (i = 0; i < UART_NR; i++) {
 961                 struct uart_sio_port *up = &m32r_sio_ports[i];
 962
 963                 up->port.line = i;
 964                 up->port.ops = &m32r_sio_pops;
 965                 init_timer(&up->timer);
 966                 up->timer.function = m32r_sio_timeout;
 967
 968                 up->mcr_mask = ~0;
 969                 up->mcr_force = 0;
 970
 971                 uart_add_one_port(drv, &up->port);
 972         }
 973 }
 974
 975 #ifdef CONFIG_SERIAL_M32R_SIO_CONSOLE
 976
 977 /*
 978  *      Wait for transmitter & holding register to empty
 979  */
 980 static inline void wait_for_xmitr(struct uart_sio_port *up)
 981 {
 982         unsigned int status, tmout = 10000;
 983
 984         /* Wait up to 10ms for the character(s) to be sent. */
 985         do {
 986                 status = sio_in(up, SIOSTS);
 987
 988                 if (--tmout == 0)
 989                         break;
 990                 udelay(1);
 991         } while ((status & UART_EMPTY) != UART_EMPTY);
 992
 993         /* Wait up to 1s for flow control if necessary */
 994         if (up->port.flags & UPF_CONS_FLOW) {
 995                 tmout = 1000000;
 996                 while (--tmout)
 997                         udelay(1);
 998         }
 999 }
1000
1001 static void m32r_sio_console_putchar(struct uart_port *port, int ch)
1002 {
1003         struct uart_sio_port *up = (struct uart_sio_port *)port;
1004
1005         wait_for_xmitr(up);
1006         sio_out(up, SIOTXB, ch);
1007 }
1008
1009 /*
1010  *      Print a string to the serial port trying not to disturb
1011  *      any possible real use of the port...
1012  *
1013  *      The console_lock must be held when we get here.
1014  */
1015 static void m32r_sio_console_write(struct console *co, const char *s,
1016         unsigned int count)
1017 {
1018         struct uart_sio_port *up = &m32r_sio_ports[co->index];
1019         unsigned int ier;
1020
1021         /*
1022          *      First save the UER then disable the interrupts
1023          */
1024         ier = sio_in(up, SIOTRCR);
1025         sio_out(up, SIOTRCR, 0);
1026
1027         uart_console_write(&up->port, s, count, m32r_sio_console_putchar);
1028
1029         /*
1030          *      Finally, wait for transmitter to become empty
1031          *      and restore the IER
1032          */
1033         wait_for_xmitr(up);
1034         sio_out(up, SIOTRCR, ier);
1035 }
1036
1037 static int __init m32r_sio_console_setup(struct console *co, char *options)
1038 {
1039         struct uart_port *port;
1040         int baud = 9600;
1041         int bits = 8;
1042         int parity = 'n';
1043         int flow = 'n';
1044
1045         /*
1046          * Check whether an invalid uart number has been specified, and
1047          * if so, search for the first available port that does have
1048          * console support.
1049          */
1050         if (co->index >= UART_NR)
1051                 co->index = 0;
1052         port = &m32r_sio_ports[co->index].port;
1053
1054         /*
1055          * Temporary fix.
1056          */
1057         spin_lock_init(&port->lock);
1058
1059         if (options)
1060                 uart_parse_options(options, &baud, &parity, &bits, &flow);
1061
1062         return uart_set_options(port, co, baud, parity, bits, flow);
1063 }
1064
1065 static struct uart_driver m32r_sio_reg;
1066 static struct console m32r_sio_console = {
1067         .name           = "ttyS",
1068         .write          = m32r_sio_console_write,
1069         .device         = uart_console_device,
1070         .setup          = m32r_sio_console_setup,
1071         .flags          = CON_PRINTBUFFER,
1072         .index          = -1,
1073         .data           = &m32r_sio_reg,
1074 };
1075
1076 static int __init m32r_sio_console_init(void)
1077 {
1078         sio_reset();
1079         sio_init();
1080         m32r_sio_init_ports();
1081         register_console(&m32r_sio_console);
1082         return 0;
1083 }
1084 console_initcall(m32r_sio_console_init);
1085
1086 #define M32R_SIO_CONSOLE        &m32r_sio_console
1087 #else
1088 #define M32R_SIO_CONSOLE        NULL
1089 #endif
1090
1091 static struct uart_driver m32r_sio_reg = {
1092         .owner                  = THIS_MODULE,
1093         .driver_name            = "sio",
1094         .dev_name               = "ttyS",
1095         .major                  = TTY_MAJOR,
1096         .minor                  = 64,
1097         .nr                     = UART_NR,
1098         .cons                   = M32R_SIO_CONSOLE,
1099 };
1100
1101 /**
1102  *      m32r_sio_suspend_port - suspend one serial port
1103  *      @line: serial line number
1104  *
1105  *      Suspend one serial port.
1106  */
1107 void m32r_sio_suspend_port(int line)
1108 {
1109         uart_suspend_port(&m32r_sio_reg, &m32r_sio_ports[line].port);
1110 }
1111
1112 /**
1113  *      m32r_sio_resume_port - resume one serial port
1114  *      @line: serial line number
1115  *
1116  *      Resume one serial port.
1117  */
1118 void m32r_sio_resume_port(int line)
1119 {
1120         uart_resume_port(&m32r_sio_reg, &m32r_sio_ports[line].port);
1121 }
1122
1123 static int __init m32r_sio_init(void)
1124 {
1125         int ret, i;
1126
1127         printk(KERN_INFO "Serial: M32R SIO driver\n");
1128
1129         for (i = 0; i < nr_irqs; i++)
1130                 spin_lock_init(&irq_lists[i].lock);
1131
1132         ret = uart_register_driver(&m32r_sio_reg);
1133         if (ret >= 0)
1134                 m32r_sio_register_ports(&m32r_sio_reg);
1135
1136         return ret;
1137 }
1138
1139 static void __exit m32r_sio_exit(void)
1140 {
1141         int i;
1142
1143         for (i = 0; i < UART_NR; i++)
1144                 uart_remove_one_port(&m32r_sio_reg, &m32r_sio_ports[i].port);
1145
1146         uart_unregister_driver(&m32r_sio_reg);
1147 }
1148
1149 module_init(m32r_sio_init);
1150 module_exit(m32r_sio_exit);
1151
1152 EXPORT_SYMBOL(m32r_sio_suspend_port);
1153 EXPORT_SYMBOL(m32r_sio_resume_port);
1154
1155 MODULE_LICENSE("GPL");
1156 MODULE_DESCRIPTION("Generic M32R SIO serial driver");