git.oblomov.eu Git - linux-2.6/blob - drivers/serial/bfin_5xx.c

   1 /*
   2  * Blackfin On-Chip Serial Driver
   3  *
   4  * Copyright 2006-2008 Analog Devices Inc.
   5  *
   6  * Enter bugs at http://blackfin.uclinux.org/
   7  *
   8  * Licensed under the GPL-2 or later.
   9  */
  10
  11 #if defined(CONFIG_SERIAL_BFIN_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  12 #define SUPPORT_SYSRQ
  13 #endif
  14
  15 #include <linux/module.h>
  16 #include <linux/ioport.h>
  17 #include <linux/init.h>
  18 #include <linux/console.h>
  19 #include <linux/sysrq.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/tty.h>
  22 #include <linux/tty_flip.h>
  23 #include <linux/serial_core.h>
  24
  25 #ifdef CONFIG_KGDB_UART
  26 #include <linux/kgdb.h>
  27 #include <asm/irq_regs.h>
  28 #endif
  29
  30 #include <asm/gpio.h>
  31 #include <mach/bfin_serial_5xx.h>
  32
  33 #ifdef CONFIG_SERIAL_BFIN_DMA
  34 #include <linux/dma-mapping.h>
  35 #include <asm/io.h>
  36 #include <asm/irq.h>
  37 #include <asm/cacheflush.h>
  38 #endif
  39
  40 /* UART name and device definitions */
  41 #define BFIN_SERIAL_NAME        "ttyBF"
  42 #define BFIN_SERIAL_MAJOR       204
  43 #define BFIN_SERIAL_MINOR       64
  44
  45 static struct bfin_serial_port bfin_serial_ports[BFIN_UART_NR_PORTS];
  46 static int nr_active_ports = ARRAY_SIZE(bfin_serial_resource);
  47
  48 /*
  49  * Setup for console. Argument comes from the menuconfig
  50  */
  51 #define DMA_RX_XCOUNT           512
  52 #define DMA_RX_YCOUNT           (PAGE_SIZE / DMA_RX_XCOUNT)
  53
  54 #define DMA_RX_FLUSH_JIFFIES    (HZ / 50)
  55 #define CTS_CHECK_JIFFIES       (HZ / 50)
  56
  57 #ifdef CONFIG_SERIAL_BFIN_DMA
  58 static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart);
  59 #else
  60 static void bfin_serial_tx_chars(struct bfin_serial_port *uart);
  61 #endif
  62
  63 static void bfin_serial_mctrl_check(struct bfin_serial_port *uart);
  64
  65 /*
  66  * interrupts are disabled on entry
  67  */
  68 static void bfin_serial_stop_tx(struct uart_port *port)
  69 {
  70         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
  71         struct circ_buf *xmit = &uart->port.info->xmit;
  72
  73         while (!(UART_GET_LSR(uart) & TEMT))
  74                 cpu_relax();
  75
  76 #ifdef CONFIG_SERIAL_BFIN_DMA
  77         disable_dma(uart->tx_dma_channel);
  78         xmit->tail = (xmit->tail + uart->tx_count) & (UART_XMIT_SIZE - 1);
  79         uart->port.icount.tx += uart->tx_count;
  80         uart->tx_count = 0;
  81         uart->tx_done = 1;
  82 #else
  83 #ifdef CONFIG_BF54x
  84         /* Clear TFI bit */
  85         UART_PUT_LSR(uart, TFI);
  86 #endif
  87         UART_CLEAR_IER(uart, ETBEI);
  88 #endif
  89 }
  90
  91 /*
  92  * port is locked and interrupts are disabled
  93  */
  94 static void bfin_serial_start_tx(struct uart_port *port)
  95 {
  96         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
  97
  98 #ifdef CONFIG_SERIAL_BFIN_DMA
  99         if (uart->tx_done)
 100                 bfin_serial_dma_tx_chars(uart);
 101 #else
 102         UART_SET_IER(uart, ETBEI);
 103         bfin_serial_tx_chars(uart);
 104 #endif
 105 }
 106
 107 /*
 108  * Interrupts are enabled
 109  */
 110 static void bfin_serial_stop_rx(struct uart_port *port)
 111 {
 112         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 113 #ifdef CONFIG_KGDB_UART
 114         if (uart->port.line != CONFIG_KGDB_UART_PORT)
 115 #endif
 116         UART_CLEAR_IER(uart, ERBFI);
 117 }
 118
 119 /*
 120  * Set the modem control timer to fire immediately.
 121  */
 122 static void bfin_serial_enable_ms(struct uart_port *port)
 123 {
 124 }
 125
 126 #ifdef CONFIG_KGDB_UART
 127 static int kgdb_entry_state;
 128
 129 void kgdb_put_debug_char(int chr)
 130 {
 131         struct bfin_serial_port *uart;
 132
 133         if (CONFIG_KGDB_UART_PORT < 0
 134                 || CONFIG_KGDB_UART_PORT >= BFIN_UART_NR_PORTS)
 135                 uart = &bfin_serial_ports[0];
 136         else
 137                 uart = &bfin_serial_ports[CONFIG_KGDB_UART_PORT];
 138
 139         while (!(UART_GET_LSR(uart) & THRE)) {
 140                 SSYNC();
 141         }
 142
 143         UART_CLEAR_DLAB(uart);
 144         UART_PUT_CHAR(uart, (unsigned char)chr);
 145         SSYNC();
 146 }
 147
 148 int kgdb_get_debug_char(void)
 149 {
 150         struct bfin_serial_port *uart;
 151         unsigned char chr;
 152
 153         if (CONFIG_KGDB_UART_PORT < 0
 154                 || CONFIG_KGDB_UART_PORT >= BFIN_UART_NR_PORTS)
 155                 uart = &bfin_serial_ports[0];
 156         else
 157                 uart = &bfin_serial_ports[CONFIG_KGDB_UART_PORT];
 158
 159         while(!(UART_GET_LSR(uart) & DR)) {
 160                 SSYNC();
 161         }
 162         UART_CLEAR_DLAB(uart);
 163         chr = UART_GET_CHAR(uart);
 164         SSYNC();
 165
 166         return chr;
 167 }
 168 #endif
 169
 170 #if ANOMALY_05000363 && defined(CONFIG_SERIAL_BFIN_PIO)
 171 # define UART_GET_ANOMALY_THRESHOLD(uart)    ((uart)->anomaly_threshold)
 172 # define UART_SET_ANOMALY_THRESHOLD(uart, v) ((uart)->anomaly_threshold = (v))
 173 #else
 174 # define UART_GET_ANOMALY_THRESHOLD(uart)    0
 175 # define UART_SET_ANOMALY_THRESHOLD(uart, v)
 176 #endif
 177
 178 #ifdef CONFIG_SERIAL_BFIN_PIO
 179 static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
 180 {
 181         struct tty_struct *tty = uart->port.info->port.tty;
 182         unsigned int status, ch, flg;
 183         static struct timeval anomaly_start = { .tv_sec = 0 };
 184
 185         status = UART_GET_LSR(uart);
 186         UART_CLEAR_LSR(uart);
 187
 188         ch = UART_GET_CHAR(uart);
 189         uart->port.icount.rx++;
 190
 191 #ifdef CONFIG_KGDB_UART
 192         if (uart->port.line == CONFIG_KGDB_UART_PORT) {
 193                 struct pt_regs *regs = get_irq_regs();
 194                 if (uart->port.cons->index == CONFIG_KGDB_UART_PORT && ch == 0x1) { /* Ctrl + A */
 195                         kgdb_breakkey_pressed(regs);
 196                         return;
 197                 } else if (kgdb_entry_state == 0 && ch == '$') {/* connection from KGDB */
 198                         kgdb_entry_state = 1;
 199                 } else if (kgdb_entry_state == 1 && ch == 'q') {
 200                         kgdb_entry_state = 0;
 201                         kgdb_breakkey_pressed(regs);
 202                         return;
 203                 } else if (ch == 0x3) {/* Ctrl + C */
 204                         kgdb_entry_state = 0;
 205                         kgdb_breakkey_pressed(regs);
 206                         return;
 207                 } else {
 208                         kgdb_entry_state = 0;
 209                 }
 210         }
 211 #endif
 212
 213         if (ANOMALY_05000363) {
 214                 /* The BF533 (and BF561) family of processors have a nice anomaly
 215                  * where they continuously generate characters for a "single" break.
 216                  * We have to basically ignore this flood until the "next" valid
 217                  * character comes across.  Due to the nature of the flood, it is
 218                  * not possible to reliably catch bytes that are sent too quickly
 219                  * after this break.  So application code talking to the Blackfin
 220                  * which sends a break signal must allow at least 1.5 character
 221                  * times after the end of the break for things to stabilize.  This
 222                  * timeout was picked as it must absolutely be larger than 1
 223                  * character time +/- some percent.  So 1.5 sounds good.  All other
 224                  * Blackfin families operate properly.  Woo.
 225                  */
 226                 if (anomaly_start.tv_sec) {
 227                         struct timeval curr;
 228                         suseconds_t usecs;
 229
 230                         if ((~ch & (~ch + 1)) & 0xff)
 231                                 goto known_good_char;
 232
 233                         do_gettimeofday(&curr);
 234                         if (curr.tv_sec - anomaly_start.tv_sec > 1)
 235                                 goto known_good_char;
 236
 237                         usecs = 0;
 238                         if (curr.tv_sec != anomaly_start.tv_sec)
 239                                 usecs += USEC_PER_SEC;
 240                         usecs += curr.tv_usec - anomaly_start.tv_usec;
 241
 242                         if (usecs > UART_GET_ANOMALY_THRESHOLD(uart))
 243                                 goto known_good_char;
 244
 245                         if (ch)
 246                                 anomaly_start.tv_sec = 0;
 247                         else
 248                                 anomaly_start = curr;
 249
 250                         return;
 251
 252  known_good_char:
 253                         anomaly_start.tv_sec = 0;
 254                 }
 255         }
 256
 257         if (status & BI) {
 258                 if (ANOMALY_05000363)
 259                         if (bfin_revid() < 5)
 260                                 do_gettimeofday(&anomaly_start);
 261                 uart->port.icount.brk++;
 262                 if (uart_handle_break(&uart->port))
 263                         goto ignore_char;
 264                 status &= ~(PE | FE);
 265         }
 266         if (status & PE)
 267                 uart->port.icount.parity++;
 268         if (status & OE)
 269                 uart->port.icount.overrun++;
 270         if (status & FE)
 271                 uart->port.icount.frame++;
 272
 273         status &= uart->port.read_status_mask;
 274
 275         if (status & BI)
 276                 flg = TTY_BREAK;
 277         else if (status & PE)
 278                 flg = TTY_PARITY;
 279         else if (status & FE)
 280                 flg = TTY_FRAME;
 281         else
 282                 flg = TTY_NORMAL;
 283
 284         if (uart_handle_sysrq_char(&uart->port, ch))
 285                 goto ignore_char;
 286
 287         uart_insert_char(&uart->port, status, OE, ch, flg);
 288
 289  ignore_char:
 290         tty_flip_buffer_push(tty);
 291 }
 292
 293 static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
 294 {
 295         struct circ_buf *xmit = &uart->port.info->xmit;
 296
 297         /*
 298          * Check the modem control lines before
 299          * transmitting anything.
 300          */
 301         bfin_serial_mctrl_check(uart);
 302
 303         if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
 304                 bfin_serial_stop_tx(&uart->port);
 305                 return;
 306         }
 307
 308         if (uart->port.x_char) {
 309                 UART_PUT_CHAR(uart, uart->port.x_char);
 310                 uart->port.icount.tx++;
 311                 uart->port.x_char = 0;
 312         }
 313
 314         while ((UART_GET_LSR(uart) & THRE) && xmit->tail != xmit->head) {
 315                 UART_PUT_CHAR(uart, xmit->buf[xmit->tail]);
 316                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 317                 uart->port.icount.tx++;
 318                 SSYNC();
 319         }
 320
 321         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 322                 uart_write_wakeup(&uart->port);
 323
 324         if (uart_circ_empty(xmit))
 325                 bfin_serial_stop_tx(&uart->port);
 326 }
 327
 328 static irqreturn_t bfin_serial_rx_int(int irq, void *dev_id)
 329 {
 330         struct bfin_serial_port *uart = dev_id;
 331
 332         spin_lock(&uart->port.lock);
 333         while (UART_GET_LSR(uart) & DR)
 334                 bfin_serial_rx_chars(uart);
 335         spin_unlock(&uart->port.lock);
 336
 337         return IRQ_HANDLED;
 338 }
 339
 340 static irqreturn_t bfin_serial_tx_int(int irq, void *dev_id)
 341 {
 342         struct bfin_serial_port *uart = dev_id;
 343
 344         spin_lock(&uart->port.lock);
 345         if (UART_GET_LSR(uart) & THRE)
 346                 bfin_serial_tx_chars(uart);
 347         spin_unlock(&uart->port.lock);
 348
 349         return IRQ_HANDLED;
 350 }
 351 #endif
 352
 353 #ifdef CONFIG_SERIAL_BFIN_DMA
 354 static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
 355 {
 356         struct circ_buf *xmit = &uart->port.info->xmit;
 357
 358         uart->tx_done = 0;
 359
 360         /*
 361          * Check the modem control lines before
 362          * transmitting anything.
 363          */
 364         bfin_serial_mctrl_check(uart);
 365
 366         if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
 367                 uart->tx_count = 0;
 368                 uart->tx_done = 1;
 369                 return;
 370         }
 371
 372         if (uart->port.x_char) {
 373                 UART_PUT_CHAR(uart, uart->port.x_char);
 374                 uart->port.icount.tx++;
 375                 uart->port.x_char = 0;
 376         }
 377
 378         uart->tx_count = CIRC_CNT(xmit->head, xmit->tail, UART_XMIT_SIZE);
 379         if (uart->tx_count > (UART_XMIT_SIZE - xmit->tail))
 380                 uart->tx_count = UART_XMIT_SIZE - xmit->tail;
 381         blackfin_dcache_flush_range((unsigned long)(xmit->buf+xmit->tail),
 382                                         (unsigned long)(xmit->buf+xmit->tail+uart->tx_count));
 383         set_dma_config(uart->tx_dma_channel,
 384                 set_bfin_dma_config(DIR_READ, DMA_FLOW_STOP,
 385                         INTR_ON_BUF,
 386                         DIMENSION_LINEAR,
 387                         DATA_SIZE_8,
 388                         DMA_SYNC_RESTART));
 389         set_dma_start_addr(uart->tx_dma_channel, (unsigned long)(xmit->buf+xmit->tail));
 390         set_dma_x_count(uart->tx_dma_channel, uart->tx_count);
 391         set_dma_x_modify(uart->tx_dma_channel, 1);
 392         enable_dma(uart->tx_dma_channel);
 393
 394         UART_SET_IER(uart, ETBEI);
 395 }
 396
 397 static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
 398 {
 399         struct tty_struct *tty = uart->port.info->port.tty;
 400         int i, flg, status;
 401
 402         status = UART_GET_LSR(uart);
 403         UART_CLEAR_LSR(uart);
 404
 405         uart->port.icount.rx +=
 406                 CIRC_CNT(uart->rx_dma_buf.head, uart->rx_dma_buf.tail,
 407                 UART_XMIT_SIZE);
 408
 409         if (status & BI) {
 410                 uart->port.icount.brk++;
 411                 if (uart_handle_break(&uart->port))
 412                         goto dma_ignore_char;
 413                 status &= ~(PE | FE);
 414         }
 415         if (status & PE)
 416                 uart->port.icount.parity++;
 417         if (status & OE)
 418                 uart->port.icount.overrun++;
 419         if (status & FE)
 420                 uart->port.icount.frame++;
 421
 422         status &= uart->port.read_status_mask;
 423
 424         if (status & BI)
 425                 flg = TTY_BREAK;
 426         else if (status & PE)
 427                 flg = TTY_PARITY;
 428         else if (status & FE)
 429                 flg = TTY_FRAME;
 430         else
 431                 flg = TTY_NORMAL;
 432
 433         for (i = uart->rx_dma_buf.tail; i != uart->rx_dma_buf.head; i++) {
 434                 if (i >= UART_XMIT_SIZE)
 435                         i = 0;
 436                 if (!uart_handle_sysrq_char(&uart->port, uart->rx_dma_buf.buf[i]))
 437                         uart_insert_char(&uart->port, status, OE,
 438                                 uart->rx_dma_buf.buf[i], flg);
 439         }
 440
 441  dma_ignore_char:
 442         tty_flip_buffer_push(tty);
 443 }
 444
 445 void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
 446 {
 447         int x_pos, pos;
 448
 449         uart->rx_dma_nrows = get_dma_curr_ycount(uart->rx_dma_channel);
 450         x_pos = get_dma_curr_xcount(uart->rx_dma_channel);
 451         uart->rx_dma_nrows = DMA_RX_YCOUNT - uart->rx_dma_nrows;
 452         if (uart->rx_dma_nrows == DMA_RX_YCOUNT)
 453                 uart->rx_dma_nrows = 0;
 454         x_pos = DMA_RX_XCOUNT - x_pos;
 455         if (x_pos == DMA_RX_XCOUNT)
 456                 x_pos = 0;
 457
 458         pos = uart->rx_dma_nrows * DMA_RX_XCOUNT + x_pos;
 459         if (pos != uart->rx_dma_buf.tail) {
 460                 uart->rx_dma_buf.head = pos;
 461                 bfin_serial_dma_rx_chars(uart);
 462                 uart->rx_dma_buf.tail = uart->rx_dma_buf.head;
 463         }
 464
 465         mod_timer(&(uart->rx_dma_timer), jiffies + DMA_RX_FLUSH_JIFFIES);
 466 }
 467
 468 static irqreturn_t bfin_serial_dma_tx_int(int irq, void *dev_id)
 469 {
 470         struct bfin_serial_port *uart = dev_id;
 471         struct circ_buf *xmit = &uart->port.info->xmit;
 472
 473         spin_lock(&uart->port.lock);
 474         if (!(get_dma_curr_irqstat(uart->tx_dma_channel)&DMA_RUN)) {
 475                 disable_dma(uart->tx_dma_channel);
 476                 clear_dma_irqstat(uart->tx_dma_channel);
 477                 UART_CLEAR_IER(uart, ETBEI);
 478                 xmit->tail = (xmit->tail + uart->tx_count) & (UART_XMIT_SIZE - 1);
 479                 uart->port.icount.tx += uart->tx_count;
 480
 481                 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 482                         uart_write_wakeup(&uart->port);
 483
 484                 bfin_serial_dma_tx_chars(uart);
 485         }
 486
 487         spin_unlock(&uart->port.lock);
 488         return IRQ_HANDLED;
 489 }
 490
 491 static irqreturn_t bfin_serial_dma_rx_int(int irq, void *dev_id)
 492 {
 493         struct bfin_serial_port *uart = dev_id;
 494         unsigned short irqstat;
 495
 496         spin_lock(&uart->port.lock);
 497         irqstat = get_dma_curr_irqstat(uart->rx_dma_channel);
 498         clear_dma_irqstat(uart->rx_dma_channel);
 499         spin_unlock(&uart->port.lock);
 500
 501         mod_timer(&(uart->rx_dma_timer), jiffies);
 502
 503         return IRQ_HANDLED;
 504 }
 505 #endif
 506
 507 /*
 508  * Return TIOCSER_TEMT when transmitter is not busy.
 509  */
 510 static unsigned int bfin_serial_tx_empty(struct uart_port *port)
 511 {
 512         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 513         unsigned short lsr;
 514
 515         lsr = UART_GET_LSR(uart);
 516         if (lsr & TEMT)
 517                 return TIOCSER_TEMT;
 518         else
 519                 return 0;
 520 }
 521
 522 static unsigned int bfin_serial_get_mctrl(struct uart_port *port)
 523 {
 524 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
 525         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 526         if (uart->cts_pin < 0)
 527                 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
 528
 529         if (UART_GET_CTS(uart))
 530                 return TIOCM_DSR | TIOCM_CAR;
 531         else
 532 #endif
 533                 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
 534 }
 535
 536 static void bfin_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
 537 {
 538 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
 539         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 540         if (uart->rts_pin < 0)
 541                 return;
 542
 543         if (mctrl & TIOCM_RTS)
 544                 UART_CLEAR_RTS(uart);
 545         else
 546                 UART_SET_RTS(uart);
 547 #endif
 548 }
 549
 550 /*
 551  * Handle any change of modem status signal since we were last called.
 552  */
 553 static void bfin_serial_mctrl_check(struct bfin_serial_port *uart)
 554 {
 555 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
 556         unsigned int status;
 557         struct uart_info *info = uart->port.info;
 558         struct tty_struct *tty = info->port.tty;
 559
 560         status = bfin_serial_get_mctrl(&uart->port);
 561         uart_handle_cts_change(&uart->port, status & TIOCM_CTS);
 562         if (!(status & TIOCM_CTS)) {
 563                 tty->hw_stopped = 1;
 564                 uart->cts_timer.data = (unsigned long)(uart);
 565                 uart->cts_timer.function = (void *)bfin_serial_mctrl_check;
 566                 uart->cts_timer.expires = jiffies + CTS_CHECK_JIFFIES;
 567                 add_timer(&(uart->cts_timer));
 568         } else {
 569                 tty->hw_stopped = 0;
 570         }
 571 #endif
 572 }
 573
 574 /*
 575  * Interrupts are always disabled.
 576  */
 577 static void bfin_serial_break_ctl(struct uart_port *port, int break_state)
 578 {
 579         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 580         u16 lcr = UART_GET_LCR(uart);
 581         if (break_state)
 582                 lcr |= SB;
 583         else
 584                 lcr &= ~SB;
 585         UART_PUT_LCR(uart, lcr);
 586         SSYNC();
 587 }
 588
 589 static int bfin_serial_startup(struct uart_port *port)
 590 {
 591         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 592
 593 #ifdef CONFIG_SERIAL_BFIN_DMA
 594         dma_addr_t dma_handle;
 595
 596         if (request_dma(uart->rx_dma_channel, "BFIN_UART_RX") < 0) {
 597                 printk(KERN_NOTICE "Unable to attach Blackfin UART RX DMA channel\n");
 598                 return -EBUSY;
 599         }
 600
 601         if (request_dma(uart->tx_dma_channel, "BFIN_UART_TX") < 0) {
 602                 printk(KERN_NOTICE "Unable to attach Blackfin UART TX DMA channel\n");
 603                 free_dma(uart->rx_dma_channel);
 604                 return -EBUSY;
 605         }
 606
 607         set_dma_callback(uart->rx_dma_channel, bfin_serial_dma_rx_int, uart);
 608         set_dma_callback(uart->tx_dma_channel, bfin_serial_dma_tx_int, uart);
 609
 610         uart->rx_dma_buf.buf = (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE, &dma_handle, GFP_DMA);
 611         uart->rx_dma_buf.head = 0;
 612         uart->rx_dma_buf.tail = 0;
 613         uart->rx_dma_nrows = 0;
 614
 615         set_dma_config(uart->rx_dma_channel,
 616                 set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO,
 617                                 INTR_ON_ROW, DIMENSION_2D,
 618                                 DATA_SIZE_8,
 619                                 DMA_SYNC_RESTART));
 620         set_dma_x_count(uart->rx_dma_channel, DMA_RX_XCOUNT);
 621         set_dma_x_modify(uart->rx_dma_channel, 1);
 622         set_dma_y_count(uart->rx_dma_channel, DMA_RX_YCOUNT);
 623         set_dma_y_modify(uart->rx_dma_channel, 1);
 624         set_dma_start_addr(uart->rx_dma_channel, (unsigned long)uart->rx_dma_buf.buf);
 625         enable_dma(uart->rx_dma_channel);
 626
 627         uart->rx_dma_timer.data = (unsigned long)(uart);
 628         uart->rx_dma_timer.function = (void *)bfin_serial_rx_dma_timeout;
 629         uart->rx_dma_timer.expires = jiffies + DMA_RX_FLUSH_JIFFIES;
 630         add_timer(&(uart->rx_dma_timer));
 631 #else
 632         if (request_irq(uart->port.irq, bfin_serial_rx_int, IRQF_DISABLED,
 633              "BFIN_UART_RX", uart)) {
 634 # ifdef CONFIG_KGDB_UART
 635                 if (uart->port.line != CONFIG_KGDB_UART_PORT) {
 636 # endif
 637                 printk(KERN_NOTICE "Unable to attach BlackFin UART RX interrupt\n");
 638                 return -EBUSY;
 639 # ifdef CONFIG_KGDB_UART
 640                 }
 641 # endif
 642         }
 643
 644         if (request_irq
 645             (uart->port.irq+1, bfin_serial_tx_int, IRQF_DISABLED,
 646              "BFIN_UART_TX", uart)) {
 647                 printk(KERN_NOTICE "Unable to attach BlackFin UART TX interrupt\n");
 648                 free_irq(uart->port.irq, uart);
 649                 return -EBUSY;
 650         }
 651 #endif
 652         UART_SET_IER(uart, ERBFI);
 653         return 0;
 654 }
 655
 656 static void bfin_serial_shutdown(struct uart_port *port)
 657 {
 658         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 659
 660 #ifdef CONFIG_SERIAL_BFIN_DMA
 661         disable_dma(uart->tx_dma_channel);
 662         free_dma(uart->tx_dma_channel);
 663         disable_dma(uart->rx_dma_channel);
 664         free_dma(uart->rx_dma_channel);
 665         del_timer(&(uart->rx_dma_timer));
 666         dma_free_coherent(NULL, PAGE_SIZE, uart->rx_dma_buf.buf, 0);
 667 #else
 668 #ifdef  CONFIG_KGDB_UART
 669         if (uart->port.line != CONFIG_KGDB_UART_PORT)
 670 #endif
 671         free_irq(uart->port.irq, uart);
 672         free_irq(uart->port.irq+1, uart);
 673 #endif
 674 }
 675
 676 static void
 677 bfin_serial_set_termios(struct uart_port *port, struct ktermios *termios,
 678                    struct ktermios *old)
 679 {
 680         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 681         unsigned long flags;
 682         unsigned int baud, quot;
 683         unsigned short val, ier, lcr = 0;
 684
 685         switch (termios->c_cflag & CSIZE) {
 686         case CS8:
 687                 lcr = WLS(8);
 688                 break;
 689         case CS7:
 690                 lcr = WLS(7);
 691                 break;
 692         case CS6:
 693                 lcr = WLS(6);
 694                 break;
 695         case CS5:
 696                 lcr = WLS(5);
 697                 break;
 698         default:
 699                 printk(KERN_ERR "%s: word lengh not supported\n",
 700                         __func__);
 701         }
 702
 703         if (termios->c_cflag & CSTOPB)
 704                 lcr |= STB;
 705         if (termios->c_cflag & PARENB)
 706                 lcr |= PEN;
 707         if (!(termios->c_cflag & PARODD))
 708                 lcr |= EPS;
 709         if (termios->c_cflag & CMSPAR)
 710                 lcr |= STP;
 711
 712         port->read_status_mask = OE;
 713         if (termios->c_iflag & INPCK)
 714                 port->read_status_mask |= (FE | PE);
 715         if (termios->c_iflag & (BRKINT | PARMRK))
 716                 port->read_status_mask |= BI;
 717
 718         /*
 719          * Characters to ignore
 720          */
 721         port->ignore_status_mask = 0;
 722         if (termios->c_iflag & IGNPAR)
 723                 port->ignore_status_mask |= FE | PE;
 724         if (termios->c_iflag & IGNBRK) {
 725                 port->ignore_status_mask |= BI;
 726                 /*
 727                  * If we're ignoring parity and break indicators,
 728                  * ignore overruns too (for real raw support).
 729                  */
 730                 if (termios->c_iflag & IGNPAR)
 731                         port->ignore_status_mask |= OE;
 732         }
 733
 734         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
 735         quot = uart_get_divisor(port, baud);
 736         spin_lock_irqsave(&uart->port.lock, flags);
 737
 738         UART_SET_ANOMALY_THRESHOLD(uart, USEC_PER_SEC / baud * 15);
 739
 740         /* Disable UART */
 741         ier = UART_GET_IER(uart);
 742         UART_DISABLE_INTS(uart);
 743
 744         /* Set DLAB in LCR to Access DLL and DLH */
 745         UART_SET_DLAB(uart);
 746
 747         UART_PUT_DLL(uart, quot & 0xFF);
 748         UART_PUT_DLH(uart, (quot >> 8) & 0xFF);
 749         SSYNC();
 750
 751         /* Clear DLAB in LCR to Access THR RBR IER */
 752         UART_CLEAR_DLAB(uart);
 753
 754         UART_PUT_LCR(uart, lcr);
 755
 756         /* Enable UART */
 757         UART_ENABLE_INTS(uart, ier);
 758
 759         val = UART_GET_GCTL(uart);
 760         val |= UCEN;
 761         UART_PUT_GCTL(uart, val);
 762
 763         spin_unlock_irqrestore(&uart->port.lock, flags);
 764 }
 765
 766 static const char *bfin_serial_type(struct uart_port *port)
 767 {
 768         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 769
 770         return uart->port.type == PORT_BFIN ? "BFIN-UART" : NULL;
 771 }
 772
 773 /*
 774  * Release the memory region(s) being used by 'port'.
 775  */
 776 static void bfin_serial_release_port(struct uart_port *port)
 777 {
 778 }
 779
 780 /*
 781  * Request the memory region(s) being used by 'port'.
 782  */
 783 static int bfin_serial_request_port(struct uart_port *port)
 784 {
 785         return 0;
 786 }
 787
 788 /*
 789  * Configure/autoconfigure the port.
 790  */
 791 static void bfin_serial_config_port(struct uart_port *port, int flags)
 792 {
 793         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 794
 795         if (flags & UART_CONFIG_TYPE &&
 796             bfin_serial_request_port(&uart->port) == 0)
 797                 uart->port.type = PORT_BFIN;
 798 }
 799
 800 /*
 801  * Verify the new serial_struct (for TIOCSSERIAL).
 802  * The only change we allow are to the flags and type, and
 803  * even then only between PORT_BFIN and PORT_UNKNOWN
 804  */
 805 static int
 806 bfin_serial_verify_port(struct uart_port *port, struct serial_struct *ser)
 807 {
 808         return 0;
 809 }
 810
 811 /*
 812  * Enable the IrDA function if tty->ldisc.num is N_IRDA.
 813  * In other cases, disable IrDA function.
 814  */
 815 static void bfin_serial_set_ldisc(struct uart_port *port)
 816 {
 817         int line = port->line;
 818         unsigned short val;
 819
 820         if (line >= port->info->port.tty->driver->num)
 821                 return;
 822
 823         switch (port->info->port.tty->termios->c_line) {
 824         case N_IRDA:
 825                 val = UART_GET_GCTL(&bfin_serial_ports[line]);
 826                 val |= (IREN | RPOLC);
 827                 UART_PUT_GCTL(&bfin_serial_ports[line], val);
 828                 break;
 829         default:
 830                 val = UART_GET_GCTL(&bfin_serial_ports[line]);
 831                 val &= ~(IREN | RPOLC);
 832                 UART_PUT_GCTL(&bfin_serial_ports[line], val);
 833         }
 834 }
 835
 836 static struct uart_ops bfin_serial_pops = {
 837         .tx_empty       = bfin_serial_tx_empty,
 838         .set_mctrl      = bfin_serial_set_mctrl,
 839         .get_mctrl      = bfin_serial_get_mctrl,
 840         .stop_tx        = bfin_serial_stop_tx,
 841         .start_tx       = bfin_serial_start_tx,
 842         .stop_rx        = bfin_serial_stop_rx,
 843         .enable_ms      = bfin_serial_enable_ms,
 844         .break_ctl      = bfin_serial_break_ctl,
 845         .startup        = bfin_serial_startup,
 846         .shutdown       = bfin_serial_shutdown,
 847         .set_termios    = bfin_serial_set_termios,
 848         .set_ldisc      = bfin_serial_set_ldisc,
 849         .type           = bfin_serial_type,
 850         .release_port   = bfin_serial_release_port,
 851         .request_port   = bfin_serial_request_port,
 852         .config_port    = bfin_serial_config_port,
 853         .verify_port    = bfin_serial_verify_port,
 854 };
 855
 856 static void __init bfin_serial_init_ports(void)
 857 {
 858         static int first = 1;
 859         int i;
 860
 861         if (!first)
 862                 return;
 863         first = 0;
 864
 865         for (i = 0; i < nr_active_ports; i++) {
 866                 bfin_serial_ports[i].port.uartclk   = get_sclk();
 867                 bfin_serial_ports[i].port.ops       = &bfin_serial_pops;
 868                 bfin_serial_ports[i].port.line      = i;
 869                 bfin_serial_ports[i].port.iotype    = UPIO_MEM;
 870                 bfin_serial_ports[i].port.membase   =
 871                         (void __iomem *)bfin_serial_resource[i].uart_base_addr;
 872                 bfin_serial_ports[i].port.mapbase   =
 873                         bfin_serial_resource[i].uart_base_addr;
 874                 bfin_serial_ports[i].port.irq       =
 875                         bfin_serial_resource[i].uart_irq;
 876                 bfin_serial_ports[i].port.flags     = UPF_BOOT_AUTOCONF;
 877 #ifdef CONFIG_SERIAL_BFIN_DMA
 878                 bfin_serial_ports[i].tx_done        = 1;
 879                 bfin_serial_ports[i].tx_count       = 0;
 880                 bfin_serial_ports[i].tx_dma_channel =
 881                         bfin_serial_resource[i].uart_tx_dma_channel;
 882                 bfin_serial_ports[i].rx_dma_channel =
 883                         bfin_serial_resource[i].uart_rx_dma_channel;
 884                 init_timer(&(bfin_serial_ports[i].rx_dma_timer));
 885 #endif
 886 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
 887                 init_timer(&(bfin_serial_ports[i].cts_timer));
 888                 bfin_serial_ports[i].cts_pin        =
 889                         bfin_serial_resource[i].uart_cts_pin;
 890                 bfin_serial_ports[i].rts_pin        =
 891                         bfin_serial_resource[i].uart_rts_pin;
 892 #endif
 893                 bfin_serial_hw_init(&bfin_serial_ports[i]);
 894         }
 895
 896 }
 897
 898 #ifdef CONFIG_SERIAL_BFIN_CONSOLE
 899 /*
 900  * If the port was already initialised (eg, by a boot loader),
 901  * try to determine the current setup.
 902  */
 903 static void __init
 904 bfin_serial_console_get_options(struct bfin_serial_port *uart, int *baud,
 905                            int *parity, int *bits)
 906 {
 907         unsigned short status;
 908
 909         status = UART_GET_IER(uart) & (ERBFI | ETBEI);
 910         if (status == (ERBFI | ETBEI)) {
 911                 /* ok, the port was enabled */
 912                 u16 lcr, dlh, dll;
 913
 914                 lcr = UART_GET_LCR(uart);
 915
 916                 *parity = 'n';
 917                 if (lcr & PEN) {
 918                         if (lcr & EPS)
 919                                 *parity = 'e';
 920                         else
 921                                 *parity = 'o';
 922                 }
 923                 switch (lcr & 0x03) {
 924                         case 0: *bits = 5; break;
 925                         case 1: *bits = 6; break;
 926                         case 2: *bits = 7; break;
 927                         case 3: *bits = 8; break;
 928                 }
 929                 /* Set DLAB in LCR to Access DLL and DLH */
 930                 UART_SET_DLAB(uart);
 931
 932                 dll = UART_GET_DLL(uart);
 933                 dlh = UART_GET_DLH(uart);
 934
 935                 /* Clear DLAB in LCR to Access THR RBR IER */
 936                 UART_CLEAR_DLAB(uart);
 937
 938                 *baud = get_sclk() / (16*(dll | dlh << 8));
 939         }
 940         pr_debug("%s:baud = %d, parity = %c, bits= %d\n", __func__, *baud, *parity, *bits);
 941 }
 942 #endif
 943
 944 #if defined(CONFIG_SERIAL_BFIN_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
 945 static struct uart_driver bfin_serial_reg;
 946
 947 static int __init
 948 bfin_serial_console_setup(struct console *co, char *options)
 949 {
 950         struct bfin_serial_port *uart;
 951 # ifdef CONFIG_SERIAL_BFIN_CONSOLE
 952         int baud = 57600;
 953         int bits = 8;
 954         int parity = 'n';
 955 #  ifdef CONFIG_SERIAL_BFIN_CTSRTS
 956         int flow = 'r';
 957 #  else
 958         int flow = 'n';
 959 #  endif
 960 # endif
 961
 962         /*
 963          * Check whether an invalid uart number has been specified, and
 964          * if so, search for the first available port that does have
 965          * console support.
 966          */
 967         if (co->index == -1 || co->index >= nr_active_ports)
 968                 co->index = 0;
 969         uart = &bfin_serial_ports[co->index];
 970
 971 # ifdef CONFIG_SERIAL_BFIN_CONSOLE
 972         if (options)
 973                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 974         else
 975                 bfin_serial_console_get_options(uart, &baud, &parity, &bits);
 976
 977         return uart_set_options(&uart->port, co, baud, parity, bits, flow);
 978 # else
 979         return 0;
 980 # endif
 981 }
 982 #endif /* defined (CONFIG_SERIAL_BFIN_CONSOLE) ||
 983                                  defined (CONFIG_EARLY_PRINTK) */
 984
 985 #ifdef CONFIG_SERIAL_BFIN_CONSOLE
 986 static void bfin_serial_console_putchar(struct uart_port *port, int ch)
 987 {
 988         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 989         while (!(UART_GET_LSR(uart) & THRE))
 990                 barrier();
 991         UART_PUT_CHAR(uart, ch);
 992         SSYNC();
 993 }
 994
 995 /*
 996  * Interrupts are disabled on entering
 997  */
 998 static void
 999 bfin_serial_console_write(struct console *co, const char *s, unsigned int count)
1000 {
1001         struct bfin_serial_port *uart = &bfin_serial_ports[co->index];
1002         int flags = 0;
1003
1004         spin_lock_irqsave(&uart->port.lock, flags);
1005         uart_console_write(&uart->port, s, count, bfin_serial_console_putchar);
1006         spin_unlock_irqrestore(&uart->port.lock, flags);
1007
1008 }
1009
1010 static struct console bfin_serial_console = {
1011         .name           = BFIN_SERIAL_NAME,
1012         .write          = bfin_serial_console_write,
1013         .device         = uart_console_device,
1014         .setup          = bfin_serial_console_setup,
1015         .flags          = CON_PRINTBUFFER,
1016         .index          = -1,
1017         .data           = &bfin_serial_reg,
1018 };
1019
1020 static int __init bfin_serial_rs_console_init(void)
1021 {
1022         bfin_serial_init_ports();
1023         register_console(&bfin_serial_console);
1024 #ifdef CONFIG_KGDB_UART
1025         kgdb_entry_state = 0;
1026         init_kgdb_uart();
1027 #endif
1028         return 0;
1029 }
1030 console_initcall(bfin_serial_rs_console_init);
1031
1032 #define BFIN_SERIAL_CONSOLE     &bfin_serial_console
1033 #else
1034 #define BFIN_SERIAL_CONSOLE     NULL
1035 #endif /* CONFIG_SERIAL_BFIN_CONSOLE */
1036
1037
1038 #ifdef CONFIG_EARLY_PRINTK
1039 static __init void early_serial_putc(struct uart_port *port, int ch)
1040 {
1041         unsigned timeout = 0xffff;
1042         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
1043
1044         while ((!(UART_GET_LSR(uart) & THRE)) && --timeout)
1045                 cpu_relax();
1046         UART_PUT_CHAR(uart, ch);
1047 }
1048
1049 static __init void early_serial_write(struct console *con, const char *s,
1050                                         unsigned int n)
1051 {
1052         struct bfin_serial_port *uart = &bfin_serial_ports[con->index];
1053         unsigned int i;
1054
1055         for (i = 0; i < n; i++, s++) {
1056                 if (*s == '\n')
1057                         early_serial_putc(&uart->port, '\r');
1058                 early_serial_putc(&uart->port, *s);
1059         }
1060 }
1061
1062 static struct __initdata console bfin_early_serial_console = {
1063         .name = "early_BFuart",
1064         .write = early_serial_write,
1065         .device = uart_console_device,
1066         .flags = CON_PRINTBUFFER,
1067         .setup = bfin_serial_console_setup,
1068         .index = -1,
1069         .data  = &bfin_serial_reg,
1070 };
1071
1072 struct console __init *bfin_earlyserial_init(unsigned int port,
1073                                                 unsigned int cflag)
1074 {
1075         struct bfin_serial_port *uart;
1076         struct ktermios t;
1077
1078         if (port == -1 || port >= nr_active_ports)
1079                 port = 0;
1080         bfin_serial_init_ports();
1081         bfin_early_serial_console.index = port;
1082         uart = &bfin_serial_ports[port];
1083         t.c_cflag = cflag;
1084         t.c_iflag = 0;
1085         t.c_oflag = 0;
1086         t.c_lflag = ICANON;
1087         t.c_line = port;
1088         bfin_serial_set_termios(&uart->port, &t, &t);
1089         return &bfin_early_serial_console;
1090 }
1091
1092 #endif /* CONFIG_SERIAL_BFIN_CONSOLE */
1093
1094 static struct uart_driver bfin_serial_reg = {
1095         .owner                  = THIS_MODULE,
1096         .driver_name            = "bfin-uart",
1097         .dev_name               = BFIN_SERIAL_NAME,
1098         .major                  = BFIN_SERIAL_MAJOR,
1099         .minor                  = BFIN_SERIAL_MINOR,
1100         .nr                     = BFIN_UART_NR_PORTS,
1101         .cons                   = BFIN_SERIAL_CONSOLE,
1102 };
1103
1104 static int bfin_serial_suspend(struct platform_device *dev, pm_message_t state)
1105 {
1106         int i;
1107
1108         for (i = 0; i < nr_active_ports; i++) {
1109                 if (bfin_serial_ports[i].port.dev != &dev->dev)
1110                         continue;
1111                 uart_suspend_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1112         }
1113
1114         return 0;
1115 }
1116
1117 static int bfin_serial_resume(struct platform_device *dev)
1118 {
1119         int i;
1120
1121         for (i = 0; i < nr_active_ports; i++) {
1122                 if (bfin_serial_ports[i].port.dev != &dev->dev)
1123                         continue;
1124                 uart_resume_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1125         }
1126
1127         return 0;
1128 }
1129
1130 static int bfin_serial_probe(struct platform_device *dev)
1131 {
1132         struct resource *res = dev->resource;
1133         int i;
1134
1135         for (i = 0; i < dev->num_resources; i++, res++)
1136                 if (res->flags & IORESOURCE_MEM)
1137                         break;
1138
1139         if (i < dev->num_resources) {
1140                 for (i = 0; i < nr_active_ports; i++, res++) {
1141                         if (bfin_serial_ports[i].port.mapbase != res->start)
1142                                 continue;
1143                         bfin_serial_ports[i].port.dev = &dev->dev;
1144                         uart_add_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1145                 }
1146         }
1147
1148         return 0;
1149 }
1150
1151 static int bfin_serial_remove(struct platform_device *dev)
1152 {
1153         int i;
1154
1155         for (i = 0; i < nr_active_ports; i++) {
1156                 if (bfin_serial_ports[i].port.dev != &dev->dev)
1157                         continue;
1158                 uart_remove_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1159                 bfin_serial_ports[i].port.dev = NULL;
1160 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
1161                 gpio_free(bfin_serial_ports[i].cts_pin);
1162                 gpio_free(bfin_serial_ports[i].rts_pin);
1163 #endif
1164         }
1165
1166         return 0;
1167 }
1168
1169 static struct platform_driver bfin_serial_driver = {
1170         .probe          = bfin_serial_probe,
1171         .remove         = bfin_serial_remove,
1172         .suspend        = bfin_serial_suspend,
1173         .resume         = bfin_serial_resume,
1174         .driver         = {
1175                 .name   = "bfin-uart",
1176                 .owner  = THIS_MODULE,
1177         },
1178 };
1179
1180 static int __init bfin_serial_init(void)
1181 {
1182         int ret;
1183 #ifdef CONFIG_KGDB_UART
1184         struct bfin_serial_port *uart = &bfin_serial_ports[CONFIG_KGDB_UART_PORT];
1185         struct ktermios t;
1186 #endif
1187
1188         pr_info("Serial: Blackfin serial driver\n");
1189
1190         bfin_serial_init_ports();
1191
1192         ret = uart_register_driver(&bfin_serial_reg);
1193         if (ret == 0) {
1194                 ret = platform_driver_register(&bfin_serial_driver);
1195                 if (ret) {
1196                         pr_debug("uart register failed\n");
1197                         uart_unregister_driver(&bfin_serial_reg);
1198                 }
1199         }
1200 #ifdef CONFIG_KGDB_UART
1201         if (uart->port.cons->index != CONFIG_KGDB_UART_PORT) {
1202                 request_irq(uart->port.irq, bfin_serial_rx_int,
1203                         IRQF_DISABLED, "BFIN_UART_RX", uart);
1204                 pr_info("Request irq for kgdb uart port\n");
1205                 UART_SET_IER(uart, ERBFI);
1206                 SSYNC();
1207                 t.c_cflag = CS8|B57600;
1208                 t.c_iflag = 0;
1209                 t.c_oflag = 0;
1210                 t.c_lflag = ICANON;
1211                 t.c_line = CONFIG_KGDB_UART_PORT;
1212                 bfin_serial_set_termios(&uart->port, &t, &t);
1213         }
1214 #endif
1215         return ret;
1216 }
1217
1218 static void __exit bfin_serial_exit(void)
1219 {
1220         platform_driver_unregister(&bfin_serial_driver);
1221         uart_unregister_driver(&bfin_serial_reg);
1222 }
1223
1224 module_init(bfin_serial_init);
1225 module_exit(bfin_serial_exit);
1226
1227 MODULE_AUTHOR("Aubrey.Li <aubrey.li@analog.com>");
1228 MODULE_DESCRIPTION("Blackfin generic serial port driver");
1229 MODULE_LICENSE("GPL");
1230 MODULE_ALIAS_CHARDEV_MAJOR(BFIN_SERIAL_MAJOR);
1231 MODULE_ALIAS("platform:bfin-uart");