Ignore:
Timestamp:
2011-06-19T15:17:51+02:00 (5 years ago)
Author:
juhosg
Message:

ar71xx: cleanup AR933X UART driver

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ar71xx/files/drivers/serial/ar933x_uart.c

    r27166 r27222  
    11/* 
    2  *  linux/drivers/serial/hornet_serial.c 
     2 *  Atheros AR933X SoC built-in UART driver 
    33 * 
    4  *  Driver for hornet serial ports 
     4 *  Copyright (C) 2011 Gabor Juhos <juhosg@openwrt.org> 
    55 * 
    66 *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o. 
    77 * 
    8  *  Copyright (C) 2010 Ryan Hsu. 
    9  * 
    10  * This program is free software; you can redistribute it and/or modify 
    11  * it under the terms of the GNU General Public License as published by 
    12  * the Free Software Foundation; either version 2 of the License, or 
    13  * (at your option) any later version. 
    14  * 
    15  *  $Id$ 
    16  * 
    17  * A note about mapbase / membase 
    18  * 
    19  *  mapbase is the physical address of the IO port. 
    20  *  membase is an 'ioremapped' cookie. 
     8 *  This program is free software; you can redistribute it and/or modify it 
     9 *  under the terms of the GNU General Public License version 2 as published 
     10 *  by the Free Software Foundation. 
    2111 */ 
    2212 
    2313#include <linux/module.h> 
    24 #include <linux/moduleparam.h> 
    2514#include <linux/ioport.h> 
    2615#include <linux/init.h> 
     
    3120#include <linux/tty.h> 
    3221#include <linux/tty_flip.h> 
    33 #include <linux/serial_reg.h> 
    3422#include <linux/serial_core.h> 
    3523#include <linux/serial.h> 
    36 #include <linux/serial_8250.h> 
    37 #include <linux/nmi.h> 
    38 #include <linux/mutex.h> 
    3924#include <linux/slab.h> 
     25#include <linux/io.h> 
     26#include <linux/irq.h> 
    4027 
    4128#include <asm/mach-ar71xx/ar933x_uart.h> 
    4229#include <asm/mach-ar71xx/ar933x_uart_platform.h> 
    4330 
    44 #include <asm/io.h> 
    45 #include <asm/irq.h> 
    46  
    47 #include "8250.h" 
    48 #define ar7240_reg_rmw_clear(_reg, _val)        do {} while (0) 
    49  
    5031#define DRIVER_NAME "ar933x-uart" 
    5132 
    52 #define AR933X_UART_REGS_SIZE   20 
    53 #define AR933X_UART_FIFO_SIZE   16 
    54  
    55 /* 
    56  * uncomment below to enable WAR for EV81847. 
    57  */ 
    58 //#define AR933X_EV81847_WAR 
     33#define AR933X_DUMMY_STATUS_RD  0x01 
    5934 
    6035static struct uart_driver ar933x_uart_driver; 
    61  
    62 /* 
    63  * Debugging. 
    64  */ 
    65 #if 0 
    66 #define DEBUG_AUTOCONF(fmt...)  printk(fmt) 
    67 #else 
    68 #define DEBUG_AUTOCONF(fmt...)  do { } while (0) 
    69 #endif 
    70  
    71 #if 0 
    72 #define DEBUG_INTR(fmt...)      printk(fmt) 
    73 #else 
    74 #define DEBUG_INTR(fmt...)      do { } while (0) 
    75 #endif 
    76  
    77 /* 
    78  * We default to IRQ0 for the "no irq" hack.   Some 
    79  * machine types want others as well - they're free 
    80  * to redefine this in their header file. 
    81  */ 
    82 #define is_real_interrupt(irq)  ((irq) != 0) 
    83  
    84 #include <asm/serial.h> 
    8536 
    8637struct ar933x_uart_port { 
    8738        struct uart_port        port; 
    88         struct timer_list       timer;          /* "no irq" timer */ 
    89         unsigned char           acr; 
    90         unsigned char           ier; 
    91         unsigned char           lcr; 
    92         unsigned char           mcr; 
     39        unsigned int            ier;    /* shadow Interrupt Enable Register */ 
    9340}; 
    94  
    95 static inline int ar933x_ev81847_war(void) 
    96 { 
    97 #if defined(AR933X_EV81847_WAR) 
    98         return 1; 
    99 #else 
    100         return 0; 
    101 #endif 
    102 } 
    10341 
    10442static inline unsigned int ar933x_uart_read(struct ar933x_uart_port *up, 
     
    14381static inline void ar933x_uart_start_tx_interrupt(struct ar933x_uart_port *up) 
    14482{ 
    145         ar933x_uart_rmw_set(up, AR933X_UART_INT_EN_REG, 
    146                             AR933X_UART_INT_TX_EMPTY); 
     83        up->ier |= AR933X_UART_INT_TX_EMPTY; 
     84        ar933x_uart_write(up, AR933X_UART_INT_EN_REG, up->ier); 
    14785} 
    14886 
    14987static inline void ar933x_uart_stop_tx_interrupt(struct ar933x_uart_port *up) 
    15088{ 
    151         if (up->ier & UART_IER_THRI) { 
    152                 up->ier &= ~UART_IER_THRI; 
    153  
    154                 /* FIXME: why this uses RXVALIDINTEN? */ 
    155                 ar933x_uart_rmw_clear(up, AR933X_UART_INT_EN_REG, 
    156                                       AR933X_UART_INT_RX_VALID); 
    157         } 
     89        up->ier &= ~AR933X_UART_INT_TX_EMPTY; 
     90        ar933x_uart_write(up, AR933X_UART_INT_EN_REG,up->ier); 
     91} 
     92 
     93static inline void ar933x_uart_putc(struct ar933x_uart_port *up, int ch) 
     94{ 
     95        unsigned int rdata; 
     96 
     97        rdata = ch & AR933X_UART_DATA_TX_RX_MASK; 
     98        rdata |= AR933X_UART_DATA_TX_CSR; 
     99        ar933x_uart_write(up, AR933X_UART_DATA_REG, rdata); 
    158100} 
    159101 
     
    198140        struct ar933x_uart_port *up = (struct ar933x_uart_port *) port; 
    199141 
    200         up->ier &= ~UART_IER_RLSI; 
    201         up->port.read_status_mask &= ~UART_LSR_DR; 
    202  
    203         ar933x_uart_rmw_clear(up, AR933X_UART_INT_EN_REG, 
    204                               AR933X_UART_INT_RX_VALID); 
     142        up->ier &= ~AR933X_UART_INT_RX_VALID; 
     143        ar933x_uart_write(up, AR933X_UART_INT_EN_REG, up->ier); 
    205144} 
    206145 
     
    209148        struct ar933x_uart_port *up = (struct ar933x_uart_port *) port; 
    210149        unsigned long flags; 
    211         unsigned long rdata; 
    212150 
    213151        spin_lock_irqsave(&up->port.lock, flags); 
    214  
    215152        if (break_state == -1) 
    216                 up->lcr |= UART_LCR_SBC; 
     153                ar933x_uart_rmw_set(up, AR933X_UART_CS_REG, 
     154                                    AR933X_UART_CS_TX_BREAK); 
    217155        else 
    218                 up->lcr &= ~UART_LCR_SBC; 
    219  
    220         rdata = ar933x_uart_read(up, AR933X_UART_CS_REG); 
    221         if (up->lcr & UART_LCR_SBC) 
    222                 rdata |= AR933X_UART_CS_TX_BREAK; 
    223         else 
    224                 rdata &= ~AR933X_UART_CS_TX_BREAK; 
    225  
    226         ar933x_uart_write(up, AR933X_UART_CS_REG, rdata); 
    227  
     156                ar933x_uart_rmw_clear(up, AR933X_UART_CS_REG, 
     157                                      AR933X_UART_CS_TX_BREAK); 
    228158        spin_unlock_irqrestore(&up->port.lock, flags); 
    229159} 
     
    233163} 
    234164 
    235 static inline unsigned int ar933x_uart_get_divisor(struct uart_port *port, 
    236                                                    unsigned int baud) 
    237 { 
    238         return (port->uartclk / (16 * baud)) - 1; 
    239 } 
    240  
    241165static void ar933x_uart_set_termios(struct uart_port *port, 
    242                                     struct ktermios *termios, 
     166                                    struct ktermios *new, 
    243167                                    struct ktermios *old) 
    244168{ 
    245169        struct ar933x_uart_port *up = (struct ar933x_uart_port *) port; 
    246         unsigned char cval; 
     170        unsigned int cs; 
    247171        unsigned long flags; 
    248         unsigned int baud, quot; 
    249  
    250         switch (termios->c_cflag & CSIZE) { 
    251         case CS5: 
    252                 cval = UART_LCR_WLEN5; 
    253                 break; 
    254         case CS6: 
    255                 cval = UART_LCR_WLEN6; 
    256                 break; 
    257         case CS7: 
    258                 cval = UART_LCR_WLEN7; 
    259                 break; 
    260         default: 
    261         case CS8: 
    262                 cval = UART_LCR_WLEN8; 
    263                 break; 
     172        unsigned int baud, scale; 
     173 
     174        /* Only CS8 is supported */ 
     175        new->c_cflag &= ~CSIZE; 
     176        new->c_cflag |= CS8; 
     177 
     178        /* Only one stop bit is supported */ 
     179        new->c_cflag &= ~CSTOPB; 
     180 
     181        cs = 0; 
     182        if (new->c_cflag & PARENB) { 
     183                if (!(new->c_cflag & PARODD)) 
     184                        cs |= AR933X_UART_CS_PARITY_EVEN; 
     185                else 
     186                        cs |= AR933X_UART_CS_PARITY_ODD; 
     187        } else { 
     188                cs |= AR933X_UART_CS_PARITY_NONE; 
    264189        } 
    265190 
    266         if (termios->c_cflag & CSTOPB) 
    267                 cval |= UART_LCR_STOP; 
    268         if (termios->c_cflag & PARENB) 
    269                 cval |= UART_LCR_PARITY; 
    270         if (!(termios->c_cflag & PARODD)) 
    271                 cval |= UART_LCR_EPAR; 
    272 #ifdef CMSPAR 
    273         if (termios->c_cflag & CMSPAR) 
    274                 cval |= UART_LCR_SPAR; 
    275 #endif 
     191        /* Mark/space parity is not supported */ 
     192        new->c_cflag &= ~CMSPAR; 
     193 
     194        baud = uart_get_baud_rate(port, new, old, 0, port->uartclk / 16); 
     195        scale = (port->uartclk / (16 * baud)) - 1; 
    276196 
    277197        /* 
    278          * Ask the core to calculate the divisor for us. 
    279          */ 
    280         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16); 
    281         quot = ar933x_uart_get_divisor(port, baud); 
    282  
    283 #if 0 
    284         if (up->capabilities & UART_CAP_FIFO && up->port.fifosize > 1) { 
    285                 if (baud < 2400) 
    286                         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1; 
    287                 else 
    288                         fcr = uart_config[up->port.type].fcr; 
    289         } 
    290  
    291         /* 
    292          * MCR-based auto flow control.  When AFE is enabled, RTS will be 
    293          * deasserted when the receive FIFO contains more characters than 
    294          * the trigger, or the MCR RTS bit is cleared.  In the case where 
    295          * the remote UART is not using CTS auto flow control, we must 
    296          * have sufficient FIFO entries for the latency of the remote 
    297          * UART to respond.  IOW, at least 32 bytes of FIFO. 
    298          */ 
    299         if (up->capabilities & UART_CAP_AFE && up->port.fifosize >= 32) { 
    300                 up->mcr &= ~UART_MCR_AFE; 
    301                 if (termios->c_cflag & CRTSCTS) 
    302                         up->mcr |= UART_MCR_AFE; 
    303         } 
    304 #endif 
    305  
    306         /* 
    307          * Ok, we're now changing the port state.  Do it with 
     198         * Ok, we're now changing the port state. Do it with 
    308199         * interrupts disabled. 
    309200         */ 
    310201        spin_lock_irqsave(&up->port.lock, flags); 
    311202 
    312         /* 
    313          * Update the per-port timeout. 
    314          */ 
    315         uart_update_timeout(port, termios->c_cflag, baud); 
    316  
    317         up->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR; 
    318         if (termios->c_iflag & INPCK) 
    319                 up->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE; 
    320         if (termios->c_iflag & (BRKINT | PARMRK)) 
    321                 up->port.read_status_mask |= UART_LSR_BI; 
    322  
    323         /* 
    324          * Characteres to ignore 
    325          */ 
     203        /* Update the per-port timeout. */ 
     204        uart_update_timeout(port, new->c_cflag, baud); 
     205 
    326206        up->port.ignore_status_mask = 0; 
    327         if (termios->c_iflag & IGNPAR) 
    328                 up->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE; 
    329         if (termios->c_iflag & IGNBRK) { 
    330                 up->port.ignore_status_mask |= UART_LSR_BI; 
    331                 /* 
    332                  * If we're ignoring parity and break indicators, 
    333                  * ignore overruns too (for real raw support). 
    334                  */ 
    335                 if (termios->c_iflag & IGNPAR) 
    336                         up->port.ignore_status_mask |= UART_LSR_OE; 
    337         } 
    338  
    339         /* 
    340          * ignore all characters if CREAD is not set 
    341          */ 
    342         if ((termios->c_cflag & CREAD) == 0) 
    343                 up->port.ignore_status_mask |= UART_LSR_DR; 
    344  
    345         /* 
    346          * CTS flow control flag and modem status interrupts 
    347          */ 
    348         up->ier &= ~UART_IER_MSI; 
    349         if (UART_ENABLE_MS(&up->port, termios->c_cflag)) 
    350                 up->ier |= UART_IER_MSI; 
    351  
     207 
     208        /* ignore all characters if CREAD is not set */ 
     209        if ((new->c_cflag & CREAD) == 0) 
     210                up->port.ignore_status_mask |= AR933X_DUMMY_STATUS_RD; 
     211 
     212        ar933x_uart_write(up, AR933X_UART_CLOCK_REG, 
     213                          scale << AR933X_UART_CLOCK_SCALE_S | 8192); 
     214 
     215        /* setup configuration register */ 
     216        ar933x_uart_rmw(up, AR933X_UART_CS_REG, AR933X_UART_CS_PARITY_M, cs); 
     217 
     218        /* enable host interrupt */ 
    352219        ar933x_uart_rmw_set(up, AR933X_UART_CS_REG, 
    353220                            AR933X_UART_CS_HOST_INT_EN); 
    354221 
    355         /* Save LCR */ 
    356         up->lcr = cval; 
    357  
    358         ar933x_uart_set_mctrl(&up->port, up->port.mctrl); 
    359222        spin_unlock_irqrestore(&up->port.lock, flags); 
    360 } 
    361  
    362 static void ar933x_uart_rx_chars(struct ar933x_uart_port *up, int *status) 
     223 
     224        if (tty_termios_baud_rate(new)) 
     225                tty_termios_encode_baud_rate(new, baud, baud); 
     226} 
     227 
     228static void ar933x_uart_rx_chars(struct ar933x_uart_port *up) 
    363229{ 
    364230        struct tty_struct *tty = up->port.state->port.tty; 
    365         unsigned int lsr = *status; 
    366         unsigned char ch; 
    367231        int max_count = 256; 
    368         char flag; 
    369232 
    370233        do { 
    371                 ch = lsr & AR933X_UART_DATA_TX_RX_MASK; 
    372  
    373                 flag = TTY_NORMAL; 
     234                unsigned int rdata; 
     235                unsigned char ch; 
     236 
     237                rdata = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
     238                if ((rdata & AR933X_UART_DATA_RX_CSR) == 0) 
     239                        break; 
     240 
     241                /* remove the character from the FIFO */ 
     242                ar933x_uart_write(up, AR933X_UART_DATA_REG, 
     243                                  AR933X_UART_DATA_RX_CSR); 
     244 
    374245                up->port.icount.rx++; 
    375  
    376                 lsr = AR933X_UART_DATA_RX_CSR; 
    377                 ar933x_uart_write(up, AR933X_UART_DATA_REG, lsr); 
    378  
    379                 if (unlikely(lsr & (UART_LSR_BI | UART_LSR_PE | 
    380                                     UART_LSR_FE | UART_LSR_OE))) { 
    381                         /* 
    382                          * For statistics only 
    383                          */ 
    384                         if (lsr & UART_LSR_BI) { 
    385                                 lsr &= ~(UART_LSR_FE | UART_LSR_PE); 
    386                                 up->port.icount.brk++; 
    387                                 /* 
    388                                  * We do the SysRQ and SAK checking 
    389                                  * here because otherwise the break 
    390                                  * may get masked by ignore_status_mask 
    391                                  * or read_status_mask. 
    392                                  */ 
    393                                 if (uart_handle_break(&up->port)) 
    394                                         goto ignore_char; 
    395                         } else if (lsr & UART_LSR_PE) 
    396                                 up->port.icount.parity++; 
    397                         else if (lsr & UART_LSR_FE) 
    398                                 up->port.icount.frame++; 
    399                         if (lsr & UART_LSR_OE) 
    400                                 up->port.icount.overrun++; 
    401  
    402                         /* 
    403                          * Mask off conditions which should be ignored. 
    404                          */ 
    405                         lsr &= up->port.read_status_mask; 
    406  
    407                         if (lsr & UART_LSR_BI) { 
    408                                 DEBUG_INTR("handling break...."); 
    409                                 flag = TTY_BREAK; 
    410                         } else if (lsr & UART_LSR_PE) 
    411                                 flag = TTY_PARITY; 
    412                         else if (lsr & UART_LSR_FE) 
    413                                 flag = TTY_FRAME; 
    414                 } 
     246                ch = rdata & AR933X_UART_DATA_TX_RX_MASK; 
    415247 
    416248                if (uart_handle_sysrq_char(&up->port, ch)) 
    417                         goto ignore_char; 
    418  
    419                 uart_insert_char(&up->port, lsr, UART_LSR_OE, ch, flag); 
    420  
    421 ignore_char: 
    422                 lsr = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
    423         } while ((lsr & AR933X_UART_DATA_RX_CSR) && (max_count-- > 0)); 
    424  
    425         spin_unlock(&up->port.lock); 
     249                        continue; 
     250 
     251                if ((up->port.ignore_status_mask & AR933X_DUMMY_STATUS_RD) == 0) 
     252                        tty_insert_flip_char(tty, ch, TTY_NORMAL); 
     253        } while (max_count-- > 0); 
     254 
    426255        tty_flip_buffer_push(tty); 
    427         spin_lock(&up->port.lock); 
    428  
    429         *status = lsr; 
    430256} 
    431257 
     
    434260        struct circ_buf *xmit = &up->port.state->xmit; 
    435261        int count; 
    436         unsigned int rdata; 
    437  
    438         rdata = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
    439         if ((rdata & AR933X_UART_DATA_TX_CSR) == 0) { 
    440                 ar933x_uart_start_tx_interrupt(up); 
     262 
     263        if (uart_tx_stopped(&up->port)) 
    441264                return; 
    442         } 
    443  
    444         if (up->port.x_char) { 
    445                 rdata = up->port.x_char & AR933X_UART_DATA_TX_RX_MASK; 
    446                 rdata |= AR933X_UART_DATA_TX_CSR; 
    447                 ar933x_uart_write(up, AR933X_UART_DATA_REG, rdata); 
    448                 up->port.icount.tx++; 
    449                 up->port.x_char = 0; 
    450                 ar933x_uart_start_tx_interrupt(up); 
    451                 return; 
    452         } 
    453  
    454         if (uart_tx_stopped(&up->port)) { 
    455                 ar933x_uart_stop_tx(&up->port); 
    456                 return; 
    457         } 
    458  
    459         if (uart_circ_empty(xmit)) { 
    460                 ar933x_uart_stop_tx_interrupt(up); 
    461                 return; 
    462         } 
    463  
    464         count = up->port.fifosize / 4; 
     265 
     266        count = up->port.fifosize; 
    465267        do { 
     268                unsigned int rdata; 
     269 
    466270                rdata = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
    467                 if ((rdata & AR933X_UART_DATA_TX_CSR) == 0) { 
    468                         ar933x_uart_start_tx_interrupt(up); 
    469                         return; 
     271                if ((rdata & AR933X_UART_DATA_TX_CSR) == 0) 
     272                        break; 
     273 
     274                if (up->port.x_char) { 
     275                        ar933x_uart_putc(up, up->port.x_char); 
     276                        up->port.icount.tx++; 
     277                        up->port.x_char = 0; 
     278                        continue; 
    470279                } 
    471280 
    472                 rdata = xmit->buf[xmit->tail] & AR933X_UART_DATA_TX_RX_MASK; 
    473                 rdata |= AR933X_UART_DATA_TX_CSR; 
    474                 ar933x_uart_write(up, AR933X_UART_DATA_REG, rdata); 
     281                if (uart_circ_empty(xmit)) 
     282                        break; 
     283 
     284                ar933x_uart_putc(up, xmit->buf[xmit->tail]); 
    475285 
    476286                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); 
    477287                up->port.icount.tx++; 
    478                 if (uart_circ_empty(xmit)) 
    479                         break; 
    480288        } while (--count > 0); 
    481289 
    482         rdata = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
    483         if ((rdata & AR933X_UART_DATA_TX_CSR) == 0) { 
     290        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 
     291                uart_write_wakeup(&up->port); 
     292 
     293        if (!uart_circ_empty(xmit)) 
    484294                ar933x_uart_start_tx_interrupt(up); 
    485                 return; 
     295} 
     296 
     297static irqreturn_t ar933x_uart_interrupt(int irq, void *dev_id) 
     298{ 
     299        struct ar933x_uart_port *up = dev_id; 
     300        unsigned int status; 
     301 
     302        status = ar933x_uart_read(up, AR933X_UART_CS_REG); 
     303        if ((status & AR933X_UART_CS_HOST_INT) == 0) 
     304                return IRQ_NONE; 
     305 
     306        spin_lock(&up->port.lock); 
     307 
     308        status = ar933x_uart_read(up, AR933X_UART_INT_REG); 
     309        status &= ar933x_uart_read(up, AR933X_UART_INT_EN_REG); 
     310 
     311        if (status & AR933X_UART_INT_RX_VALID) { 
     312                ar933x_uart_write(up, AR933X_UART_INT_REG, 
     313                                  AR933X_UART_INT_RX_VALID); 
     314                ar933x_uart_rx_chars(up); 
    486315        } 
    487316 
    488         /* Re-enable TX Empty Interrupt to transmit pending chars */ 
    489         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) { 
    490                 uart_write_wakeup(&up->port); 
    491                 ar933x_uart_start_tx_interrupt(up); 
    492         } 
    493  
    494         DEBUG_INTR("THRE..."); 
    495  
    496         if (uart_circ_empty(xmit)) 
    497                 ar933x_uart_stop_tx_interrupt(up); 
    498         else 
    499                 ar933x_uart_start_tx_interrupt(up); 
    500 } 
    501  
    502 /*! Hornet's interrupt status is not read clear, so that we have to... 
    503  * a. read out the interrupt status 
    504  * b. clear the interrupt mask to reset the interrupt status 
    505  * c. enable the interrupt to reactivate interrupt 
    506  * 
    507  * Disable and clear the interrupt status 
    508  */ 
    509 static inline void ar933x_uart_clear_int(struct ar933x_uart_port *up) 
    510 { 
    511 #define BIT3 (0x1>>3) 
    512  
    513         /* 1. clear MISC interrupt mask */ 
    514         //ar7240_reg_rmw_clear(AR7240_MISC_INT_MASK, BIT3); 
    515  
    516         /* 2. clear uartcs hostinten mask, bit13 */ 
    517         ar933x_uart_rmw_clear(up, AR933X_UART_CS_REG, 
    518                               AR933X_UART_CS_HOST_INT_EN); 
    519  
    520         /* 3. clear rx uartint */ 
    521         ar933x_uart_write(up, AR933X_UART_INT_REG, AR933X_UART_INT_RX_VALID); 
    522  
    523         /* 4. clear misc interrupt status  */ 
    524         ar7240_reg_rmw_clear(AR7240_MISC_INT_STATUS, BIT3); 
    525  
    526         /* 5. clear rx uartinten*/ 
    527         ar933x_uart_rmw_clear(up, AR933X_UART_INT_EN_REG, 
    528                               AR933X_UART_INT_RX_VALID); 
    529  
    530         /* 6. enable rx int*/ 
    531         ar933x_uart_rmw_set(up, AR933X_UART_INT_EN_REG, 
    532                             AR933X_UART_INT_RX_VALID); 
    533  
    534         /* 7. set uartcs hostinten mask */ 
    535         ar933x_uart_rmw_set(up, AR933X_UART_CS_REG, 
    536                             AR933X_UART_CS_HOST_INT_EN); 
    537  
    538         /* 8. set misc int mask */ 
    539         //ar7240_reg_wr(AR7240_MISC_INT_MASK, BIT3); 
    540 } 
    541  
    542 static inline void ar933x_uart_handle_port(struct ar933x_uart_port *up) 
    543 { 
    544         unsigned int status; 
    545         unsigned int int_status; 
    546         unsigned int en_status; 
    547         unsigned long flags; 
    548  
    549         status = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
    550         int_status = ar933x_uart_read(up, AR933X_UART_INT_REG); 
    551         en_status = ar933x_uart_read(up, AR933X_UART_INT_EN_REG); 
    552  
    553         spin_lock_irqsave(&up->port.lock, flags); 
    554  
    555         if( (int_status & en_status) & AR933X_UART_INT_RX_VALID ) 
    556                 ar933x_uart_rx_chars(up, &status); 
    557  
    558         if (((int_status & en_status) & AR933X_UART_INT_TX_EMPTY)) { 
    559                 /* clear TX empty interrupts */ 
     317        if (status & AR933X_UART_INT_TX_EMPTY) { 
    560318                ar933x_uart_write(up, AR933X_UART_INT_REG, 
    561319                                  AR933X_UART_INT_TX_EMPTY); 
    562  
    563                 /* disable TX empty interrupts */ 
    564                 ar933x_uart_rmw_clear(up, AR933X_UART_INT_EN_REG, 
    565                                       AR933X_UART_INT_TX_EMPTY); 
    566  
    567                 if (!uart_circ_empty(&up->port.state->xmit)) 
    568                         ar933x_uart_tx_chars(up); 
     320                ar933x_uart_stop_tx_interrupt(up); 
     321                ar933x_uart_tx_chars(up); 
    569322        } 
    570323 
    571         spin_unlock_irqrestore(&up->port.lock, flags); 
    572 } 
    573  
    574 static irqreturn_t ar933x_uart_interrupt(int irq, void *dev_id) 
    575 { 
    576         struct ar933x_uart_port *up; 
    577         unsigned int iir; 
    578  
    579         up = (struct ar933x_uart_port *) dev_id; 
    580  
    581         iir = ar933x_uart_read(up, AR933X_UART_CS_REG); 
    582         if ((iir & AR933X_UART_CS_HOST_INT) == 0) 
    583                 return IRQ_NONE; 
    584  
    585         DEBUG_INTR("ar933x_uart_interrupt(%d)...", irq); 
    586  
    587         spin_lock(&up->port.lock); 
    588         ar933x_uart_handle_port(up); 
    589         ar933x_uart_clear_int(up); 
    590324        spin_unlock(&up->port.lock); 
    591325 
    592         DEBUG_INTR("end.\n"); 
    593  
    594326        return IRQ_HANDLED; 
    595 } 
    596  
    597 static void ar933x_uart_timer(unsigned long data) 
    598 { 
    599         struct uart_port *port = (void *)data; 
    600         struct ar933x_uart_port *up = (struct ar933x_uart_port *) port; 
    601         unsigned int iir; 
    602  
    603         if (ar933x_ev81847_war()) { 
    604                 struct circ_buf *xmit = &up->port.state->xmit; 
    605                 unsigned long flags; 
    606  
    607                 if (!uart_circ_empty(xmit)) { 
    608                         spin_lock_irqsave(&up->port.lock, flags); 
    609                         ar933x_uart_tx_chars(up); 
    610                         spin_unlock_irqrestore(&up->port.lock, flags); 
    611                 } 
    612         } else { 
    613                 iir = ar933x_uart_read(up, AR933X_UART_CS_REG); 
    614                 if (iir & AR933X_UART_CS_HOST_INT) { 
    615                         spin_lock(&up->port.lock); 
    616                         ar933x_uart_handle_port(up); 
    617                         spin_unlock(&up->port.lock); 
    618                 } 
    619         } 
    620  
    621         mod_timer(&up->timer, jiffies + uart_poll_timeout(port)); 
    622327} 
    623328 
     
    633338                return ret; 
    634339 
    635         up->mcr = 0; 
    636  
    637         /* 
    638          * Clear the interrupt registers. 
    639          */ 
    640         ar933x_uart_read(up, AR933X_UART_CS_REG); 
    641         ar933x_uart_read(up, AR933X_UART_INT_REG); 
    642  
    643         if (!is_real_interrupt(up->port.irq) || ar933x_ev81847_war()) { 
    644                 setup_timer(&up->timer, ar933x_uart_timer, (unsigned long)port); 
    645                 mod_timer(&up->timer, jiffies + uart_poll_timeout(port)); 
    646                 return 0; 
    647         } 
    648  
    649340        spin_lock_irqsave(&up->port.lock, flags); 
    650341 
    651         /* 
    652          * Enable host interrupts 
    653          */ 
     342        /* Enable HOST interrupts */ 
    654343        ar933x_uart_rmw_set(up, AR933X_UART_CS_REG, 
    655344                            AR933X_UART_CS_HOST_INT_EN); 
    656345 
    657         /* 
    658          * Enable RX interrupts 
    659          */ 
    660         up->ier = UART_IER_RLSI | UART_IER_RDI; 
    661         ar933x_uart_write(up, AR933X_UART_INT_EN_REG, 
    662                           AR933X_UART_INT_RX_VALID); 
    663  
    664         /* 
    665          * And clear the interrupt registers again for luck. 
    666          */ 
    667         ar933x_uart_read(up, AR933X_UART_INT_REG); 
     346        /* Enable RX interrupts */ 
     347        up->ier = AR933X_UART_INT_RX_VALID; 
     348        ar933x_uart_write(up, AR933X_UART_INT_EN_REG, up->ier); 
    668349 
    669350        spin_unlock_irqrestore(&up->port.lock, flags); 
     
    675356{ 
    676357        struct ar933x_uart_port *up = (struct ar933x_uart_port *) port; 
    677         unsigned long flags; 
    678  
    679         /* 
    680          * Disable all interrupts from this port 
    681          */ 
     358 
     359        /* Disable all interrupts */ 
    682360        up->ier = 0; 
    683         ar933x_uart_write(up, AR933X_UART_INT_EN_REG, 0); 
    684  
    685         spin_lock_irqsave(&up->port.lock, flags); 
    686         up->port.mctrl &= ~TIOCM_OUT2; 
    687         ar933x_uart_set_mctrl(&up->port, up->port.mctrl); 
    688         spin_unlock_irqrestore(&up->port.lock, flags); 
    689  
    690         /* 
    691          * Disable break condition 
    692          */ 
     361        ar933x_uart_write(up, AR933X_UART_INT_EN_REG, up->ier); 
     362 
     363        /* Disable break condition */ 
    693364        ar933x_uart_rmw_clear(up, AR933X_UART_CS_REG, 
    694365                              AR933X_UART_CS_TX_BREAK); 
    695366 
    696         if (!is_real_interrupt(up->port.irq) || 
    697             ar933x_ev81847_war()) 
    698                 del_timer_sync(&up->timer); 
    699  
    700367        free_irq(up->port.irq, up); 
    701368} 
     
    719386static void ar933x_uart_config_port(struct uart_port *port, int flags) 
    720387{ 
    721         struct ar933x_uart_port *up = (struct ar933x_uart_port *) port; 
    722  
    723         port->type = PORT_AR933X; 
    724  
    725         /* Clear mask, so no surprise interrupts. */ 
    726         ar933x_uart_read(up, AR933X_UART_CS_REG); 
    727         /* Clear interrupts status register */ 
    728         ar933x_uart_read(up, AR933X_UART_INT_REG); 
     388        if (flags & UART_CONFIG_TYPE) 
     389                port->type = PORT_AR933X; 
    729390} 
    730391 
     
    732393                                   struct serial_struct *ser) 
    733394{ 
    734         return -EINVAL; 
     395        if (ser->type != PORT_UNKNOWN && 
     396            ser->type != PORT_AR933X) 
     397                return -EINVAL; 
     398 
     399        if (ser->irq < 0 || ser->irq >= NR_IRQS) 
     400                return -EINVAL; 
     401 
     402        if (ser->baud_base < 28800) 
     403                return -EINVAL; 
     404 
     405        return 0; 
    735406} 
    736407 
     
    775446{ 
    776447        struct ar933x_uart_port *up = (struct ar933x_uart_port *) port; 
    777         unsigned int rdata; 
    778448 
    779449        ar933x_uart_wait_xmitr(up); 
    780  
    781         rdata = ch & AR933X_UART_DATA_TX_RX_MASK; 
    782         rdata |= AR933X_UART_DATA_TX_CSR; 
    783         ar933x_uart_write(up, AR933X_UART_DATA_REG, rdata); 
     450        ar933x_uart_putc(up, ch); 
    784451} 
    785452 
     
    789456        struct ar933x_uart_port *up = ar933x_console_ports[co->index]; 
    790457        unsigned long flags; 
    791         unsigned int ier; 
     458        unsigned int int_en; 
    792459        int locked = 1; 
    793460 
    794461        local_irq_save(flags); 
    795462 
    796         if (up->port.sysrq) { 
     463        if (up->port.sysrq) 
    797464                locked = 0; 
    798         } else if (oops_in_progress) { 
     465        else if (oops_in_progress) 
    799466                locked = spin_trylock(&up->port.lock); 
    800         } else 
     467        else 
    801468                spin_lock(&up->port.lock); 
    802469 
     
    804471         * First save the IER then disable the interrupts 
    805472         */ 
    806         ier = ar933x_uart_read(up, AR933X_UART_INT_EN_REG); 
     473        int_en = ar933x_uart_read(up, AR933X_UART_INT_EN_REG); 
    807474        ar933x_uart_write(up, AR933X_UART_INT_EN_REG, 0); 
    808475 
     
    814481         */ 
    815482        ar933x_uart_wait_xmitr(up); 
    816  
    817         ar933x_uart_write(up, AR933X_UART_INT_EN_REG, ier); 
     483        ar933x_uart_write(up, AR933X_UART_INT_EN_REG, int_en); 
     484 
    818485        ar933x_uart_write(up, AR933X_UART_INT_REG, AR933X_UART_INT_ALLINTS); 
    819486 
     
    855522}; 
    856523 
    857 static int __init ar933x_uart_console_init(void) 
    858 { 
    859         register_console(&ar933x_uart_console); 
    860         return 0; 
    861 } 
    862 console_initcall(ar933x_uart_console_init); 
    863  
    864524static void ar933x_uart_add_console_port(struct ar933x_uart_port *up) 
    865525{ 
     
    1016676MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>"); 
    1017677MODULE_LICENSE("GPL v2"); 
    1018 MODULE_ALIAS("platform:" DRV_NAME); 
     678MODULE_ALIAS("platform:" DRIVER_NAME); 
Note: See TracChangeset for help on using the changeset viewer.