source: trunk/target/linux/adm5120/patches-2.6.38/200-amba_pl010_hacks.patch @ 26647

Last change on this file since 26647 was 26647, checked in by acoul, 5 years ago

linux/adm5120: add 2.6.38 preliminary support

File size: 12.7 KB
  • drivers/tty/serial/amba-pl010.c

    a b  
    5151 
    5252#include <asm/io.h> 
    5353 
    54 #define UART_NR         8 
    55  
    5654#define SERIAL_AMBA_MAJOR       204 
    5755#define SERIAL_AMBA_MINOR       16 
    58 #define SERIAL_AMBA_NR          UART_NR 
     56#define SERIAL_AMBA_NR          CONFIG_SERIAL_AMBA_PL010_NUMPORTS 
     57#define SERIAL_AMBA_NAME        CONFIG_SERIAL_AMBA_PL010_PORTNAME 
    5958 
    6059#define AMBA_ISR_PASS_LIMIT     256 
    6160 
    static void pl010_stop_tx(struct uart_po 
    8180        struct uart_amba_port *uap = (struct uart_amba_port *)port; 
    8281        unsigned int cr; 
    8382 
    84         cr = readb(uap->port.membase + UART010_CR); 
     83        cr = __raw_readl(uap->port.membase + UART010_CR); 
    8584        cr &= ~UART010_CR_TIE; 
    86         writel(cr, uap->port.membase + UART010_CR); 
     85        __raw_writel(cr, uap->port.membase + UART010_CR); 
    8786} 
    8887 
    8988static void pl010_start_tx(struct uart_port *port) 
    static void pl010_start_tx(struct uart_p 
    9190        struct uart_amba_port *uap = (struct uart_amba_port *)port; 
    9291        unsigned int cr; 
    9392 
    94         cr = readb(uap->port.membase + UART010_CR); 
     93        cr = __raw_readl(uap->port.membase + UART010_CR); 
    9594        cr |= UART010_CR_TIE; 
    96         writel(cr, uap->port.membase + UART010_CR); 
     95        __raw_writel(cr, uap->port.membase + UART010_CR); 
    9796} 
    9897 
    9998static void pl010_stop_rx(struct uart_port *port) 
    static void pl010_stop_rx(struct uart_po 
    101100        struct uart_amba_port *uap = (struct uart_amba_port *)port; 
    102101        unsigned int cr; 
    103102 
    104         cr = readb(uap->port.membase + UART010_CR); 
     103        cr = __raw_readl(uap->port.membase + UART010_CR); 
    105104        cr &= ~(UART010_CR_RIE | UART010_CR_RTIE); 
    106         writel(cr, uap->port.membase + UART010_CR); 
     105        __raw_writel(cr, uap->port.membase + UART010_CR); 
    107106} 
    108107 
    109108static void pl010_enable_ms(struct uart_port *port) 
    static void pl010_enable_ms(struct uart_ 
    111110        struct uart_amba_port *uap = (struct uart_amba_port *)port; 
    112111        unsigned int cr; 
    113112 
    114         cr = readb(uap->port.membase + UART010_CR); 
     113        cr = __raw_readl(uap->port.membase + UART010_CR); 
    115114        cr |= UART010_CR_MSIE; 
    116         writel(cr, uap->port.membase + UART010_CR); 
     115        __raw_writel(cr, uap->port.membase + UART010_CR); 
    117116} 
    118117 
    119118static void pl010_rx_chars(struct uart_amba_port *uap) 
    static void pl010_rx_chars(struct uart_a 
    121120        struct tty_struct *tty = uap->port.state->port.tty; 
    122121        unsigned int status, ch, flag, rsr, max_count = 256; 
    123122 
    124         status = readb(uap->port.membase + UART01x_FR); 
     123        status = __raw_readl(uap->port.membase + UART01x_FR); 
    125124        while (UART_RX_DATA(status) && max_count--) { 
    126                 ch = readb(uap->port.membase + UART01x_DR); 
     125                ch = __raw_readl(uap->port.membase + UART01x_DR); 
    127126                flag = TTY_NORMAL; 
    128127 
    129128                uap->port.icount.rx++; 
    static void pl010_rx_chars(struct uart_a 
    132131                 * Note that the error handling code is 
    133132                 * out of the main execution path 
    134133                 */ 
    135                 rsr = readb(uap->port.membase + UART01x_RSR) | UART_DUMMY_RSR_RX; 
     134                rsr = __raw_readl(uap->port.membase + UART01x_RSR) | UART_DUMMY_RSR_RX; 
    136135                if (unlikely(rsr & UART01x_RSR_ANY)) { 
    137                         writel(0, uap->port.membase + UART01x_ECR); 
     136                        __raw_writel(0, uap->port.membase + UART01x_ECR); 
    138137 
    139138                        if (rsr & UART01x_RSR_BE) { 
    140139                                rsr &= ~(UART01x_RSR_FE | UART01x_RSR_PE); 
    static void pl010_rx_chars(struct uart_a 
    164163                uart_insert_char(&uap->port, rsr, UART01x_RSR_OE, ch, flag); 
    165164 
    166165        ignore_char: 
    167                 status = readb(uap->port.membase + UART01x_FR); 
     166                status = __raw_readl(uap->port.membase + UART01x_FR); 
    168167        } 
    169168        spin_unlock(&uap->port.lock); 
    170169        tty_flip_buffer_push(tty); 
    static void pl010_tx_chars(struct uart_a 
    177176        int count; 
    178177 
    179178        if (uap->port.x_char) { 
    180                 writel(uap->port.x_char, uap->port.membase + UART01x_DR); 
     179                __raw_writel(uap->port.x_char, uap->port.membase + UART01x_DR); 
    181180                uap->port.icount.tx++; 
    182181                uap->port.x_char = 0; 
    183182                return; 
    static void pl010_tx_chars(struct uart_a 
    189188 
    190189        count = uap->port.fifosize >> 1; 
    191190        do { 
    192                 writel(xmit->buf[xmit->tail], uap->port.membase + UART01x_DR); 
     191                __raw_writel(xmit->buf[xmit->tail], uap->port.membase + UART01x_DR); 
    193192                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); 
    194193                uap->port.icount.tx++; 
    195194                if (uart_circ_empty(xmit)) 
    static void pl010_modem_status(struct ua 
    207206{ 
    208207        unsigned int status, delta; 
    209208 
    210         writel(0, uap->port.membase + UART010_ICR); 
     209        __raw_writel(0, uap->port.membase + UART010_ICR); 
    211210 
    212         status = readb(uap->port.membase + UART01x_FR) & UART01x_FR_MODEM_ANY; 
     211        status = __raw_readl(uap->port.membase + UART01x_FR) & UART01x_FR_MODEM_ANY; 
    213212 
    214213        delta = status ^ uap->old_status; 
    215214        uap->old_status = status; 
    static irqreturn_t pl010_int(int irq, vo 
    237236 
    238237        spin_lock(&uap->port.lock); 
    239238 
    240         status = readb(uap->port.membase + UART010_IIR); 
     239        status = __raw_readl(uap->port.membase + UART010_IIR); 
    241240        if (status) { 
    242241                do { 
    243242                        if (status & (UART010_IIR_RTIS | UART010_IIR_RIS)) 
    static irqreturn_t pl010_int(int irq, vo 
    250249                        if (pass_counter-- == 0) 
    251250                                break; 
    252251 
    253                         status = readb(uap->port.membase + UART010_IIR); 
     252                        status = __raw_readl(uap->port.membase + UART010_IIR); 
    254253                } while (status & (UART010_IIR_RTIS | UART010_IIR_RIS | 
    255254                                   UART010_IIR_TIS)); 
    256255                handled = 1; 
    static irqreturn_t pl010_int(int irq, vo 
    264263static unsigned int pl010_tx_empty(struct uart_port *port) 
    265264{ 
    266265        struct uart_amba_port *uap = (struct uart_amba_port *)port; 
    267         unsigned int status = readb(uap->port.membase + UART01x_FR); 
     266        unsigned int status = __raw_readl(uap->port.membase + UART01x_FR); 
    268267        return status & UART01x_FR_BUSY ? 0 : TIOCSER_TEMT; 
    269268} 
    270269 
    static unsigned int pl010_get_mctrl(stru 
    274273        unsigned int result = 0; 
    275274        unsigned int status; 
    276275 
    277         status = readb(uap->port.membase + UART01x_FR); 
     276        status = __raw_readl(uap->port.membase + UART01x_FR); 
    278277        if (status & UART01x_FR_DCD) 
    279278                result |= TIOCM_CAR; 
    280279        if (status & UART01x_FR_DSR) 
    static void pl010_break_ctl(struct uart_ 
    300299        unsigned int lcr_h; 
    301300 
    302301        spin_lock_irqsave(&uap->port.lock, flags); 
    303         lcr_h = readb(uap->port.membase + UART010_LCRH); 
     302        lcr_h = __raw_readl(uap->port.membase + UART010_LCRH); 
    304303        if (break_state == -1) 
    305304                lcr_h |= UART01x_LCRH_BRK; 
    306305        else 
    307306                lcr_h &= ~UART01x_LCRH_BRK; 
    308         writel(lcr_h, uap->port.membase + UART010_LCRH); 
     307        __raw_writel(lcr_h, uap->port.membase + UART010_LCRH); 
    309308        spin_unlock_irqrestore(&uap->port.lock, flags); 
    310309} 
    311310 
    static int pl010_startup(struct uart_por 
    333332        /* 
    334333         * initialise the old status of the modem signals 
    335334         */ 
    336         uap->old_status = readb(uap->port.membase + UART01x_FR) & UART01x_FR_MODEM_ANY; 
     335        uap->old_status = __raw_readl(uap->port.membase + UART01x_FR) & UART01x_FR_MODEM_ANY; 
    337336 
    338337        /* 
    339338         * Finally, enable interrupts 
    340339         */ 
    341         writel(UART01x_CR_UARTEN | UART010_CR_RIE | UART010_CR_RTIE, 
     340        __raw_writel(UART01x_CR_UARTEN | UART010_CR_RIE | UART010_CR_RTIE, 
    342341               uap->port.membase + UART010_CR); 
    343342 
    344343        return 0; 
    static void pl010_shutdown(struct uart_p 
    361360        /* 
    362361         * disable all interrupts, disable the port 
    363362         */ 
    364         writel(0, uap->port.membase + UART010_CR); 
     363        __raw_writel(0, uap->port.membase + UART010_CR); 
    365364 
    366365        /* disable break condition and fifos */ 
    367         writel(readb(uap->port.membase + UART010_LCRH) & 
     366        __raw_writel(__raw_readl(uap->port.membase + UART010_LCRH) & 
    368367                ~(UART01x_LCRH_BRK | UART01x_LCRH_FEN), 
    369368               uap->port.membase + UART010_LCRH); 
    370369 
    pl010_set_termios(struct uart_port *port 
    386385        /* 
    387386         * Ask the core to calculate the divisor for us. 
    388387         */ 
    389         baud = uart_get_baud_rate(port, termios, old, 0, uap->port.uartclk/16);  
     388        baud = uart_get_baud_rate(port, termios, old, 0, uap->port.uartclk/16); 
    390389        quot = uart_get_divisor(port, baud); 
    391390 
    392391        switch (termios->c_cflag & CSIZE) { 
    pl010_set_termios(struct uart_port *port 
    449448                uap->port.ignore_status_mask |= UART_DUMMY_RSR_RX; 
    450449 
    451450        /* first, disable everything */ 
    452         old_cr = readb(uap->port.membase + UART010_CR) & ~UART010_CR_MSIE; 
     451        old_cr = __raw_readl(uap->port.membase + UART010_CR) & ~UART010_CR_MSIE; 
    453452 
    454453        if (UART_ENABLE_MS(port, termios->c_cflag)) 
    455454                old_cr |= UART010_CR_MSIE; 
    456455 
    457         writel(0, uap->port.membase + UART010_CR); 
     456        __raw_writel(0, uap->port.membase + UART010_CR); 
    458457 
    459458        /* Set baud rate */ 
    460459        quot -= 1; 
    461         writel((quot & 0xf00) >> 8, uap->port.membase + UART010_LCRM); 
    462         writel(quot & 0xff, uap->port.membase + UART010_LCRL); 
     460        __raw_writel((quot & 0xf00) >> 8, uap->port.membase + UART010_LCRM); 
     461        __raw_writel(quot & 0xff, uap->port.membase + UART010_LCRL); 
    463462 
    464463        /* 
    465464         * ----------v----------v----------v----------v----- 
    466465         * NOTE: MUST BE WRITTEN AFTER UARTLCR_M & UARTLCR_L 
    467466         * ----------^----------^----------^----------^----- 
    468467         */ 
    469         writel(lcr_h, uap->port.membase + UART010_LCRH); 
    470         writel(old_cr, uap->port.membase + UART010_CR); 
     468        __raw_writel(lcr_h, uap->port.membase + UART010_LCRH); 
     469        __raw_writel(old_cr, uap->port.membase + UART010_CR); 
    471470 
    472471        spin_unlock_irqrestore(&uap->port.lock, flags); 
    473472} 
    static struct uart_ops amba_pl010_pops = 
    549548        .verify_port    = pl010_verify_port, 
    550549}; 
    551550 
    552 static struct uart_amba_port *amba_ports[UART_NR]; 
     551static struct uart_amba_port *amba_ports[SERIAL_AMBA_NR]; 
    553552 
    554553#ifdef CONFIG_SERIAL_AMBA_PL010_CONSOLE 
    555554 
    static void pl010_console_putchar(struct 
    559558        unsigned int status; 
    560559 
    561560        do { 
    562                 status = readb(uap->port.membase + UART01x_FR); 
     561                status = __raw_readl(uap->port.membase + UART01x_FR); 
    563562                barrier(); 
    564563        } while (!UART_TX_READY(status)); 
    565         writel(ch, uap->port.membase + UART01x_DR); 
     564        __raw_writel(ch, uap->port.membase + UART01x_DR); 
    566565} 
    567566 
    568567static void 
    pl010_console_write(struct console *co,  
    576575        /* 
    577576         *      First save the CR then disable the interrupts 
    578577         */ 
    579         old_cr = readb(uap->port.membase + UART010_CR); 
    580         writel(UART01x_CR_UARTEN, uap->port.membase + UART010_CR); 
     578        old_cr = __raw_readl(uap->port.membase + UART010_CR); 
     579        __raw_writel(UART01x_CR_UARTEN, uap->port.membase + UART010_CR); 
    581580 
    582581        uart_console_write(&uap->port, s, count, pl010_console_putchar); 
    583582 
    pl010_console_write(struct console *co,  
    586585         *      and restore the TCR 
    587586         */ 
    588587        do { 
    589                 status = readb(uap->port.membase + UART01x_FR); 
     588                status = __raw_readl(uap->port.membase + UART01x_FR); 
    590589                barrier(); 
    591590        } while (status & UART01x_FR_BUSY); 
    592         writel(old_cr, uap->port.membase + UART010_CR); 
     591        __raw_writel(old_cr, uap->port.membase + UART010_CR); 
    593592 
    594593        clk_disable(uap->clk); 
    595594} 
    static void __init 
    598597pl010_console_get_options(struct uart_amba_port *uap, int *baud, 
    599598                             int *parity, int *bits) 
    600599{ 
    601         if (readb(uap->port.membase + UART010_CR) & UART01x_CR_UARTEN) { 
     600        if (__raw_readl(uap->port.membase + UART010_CR) & UART01x_CR_UARTEN) { 
    602601                unsigned int lcr_h, quot; 
    603                 lcr_h = readb(uap->port.membase + UART010_LCRH); 
     602                lcr_h = __raw_readl(uap->port.membase + UART010_LCRH); 
    604603 
    605604                *parity = 'n'; 
    606605                if (lcr_h & UART01x_LCRH_PEN) { 
    pl010_console_get_options(struct uart_am 
    615614                else 
    616615                        *bits = 8; 
    617616 
    618                 quot = readb(uap->port.membase + UART010_LCRL) | 
    619                        readb(uap->port.membase + UART010_LCRM) << 8; 
     617                quot = __raw_readl(uap->port.membase + UART010_LCRL) | 
     618                       __raw_readl(uap->port.membase + UART010_LCRM) << 8; 
    620619                *baud = uap->port.uartclk / (16 * (quot + 1)); 
    621620        } 
    622621} 
    static int __init pl010_console_setup(st 
    634633         * if so, search for the first available port that does have 
    635634         * console support. 
    636635         */ 
    637         if (co->index >= UART_NR) 
     636        if (co->index >= SERIAL_AMBA_NR) 
    638637                co->index = 0; 
    639638        uap = amba_ports[co->index]; 
    640639        if (!uap) 
    static int __init pl010_console_setup(st 
    652651 
    653652static struct uart_driver amba_reg; 
    654653static struct console amba_console = { 
    655         .name           = "ttyAM", 
     654        .name           = SERIAL_AMBA_NAME, 
    656655        .write          = pl010_console_write, 
    657656        .device         = uart_console_device, 
    658657        .setup          = pl010_console_setup, 
    static struct console amba_console = { 
    668667 
    669668static struct uart_driver amba_reg = { 
    670669        .owner                  = THIS_MODULE, 
    671         .driver_name            = "ttyAM", 
    672         .dev_name               = "ttyAM", 
     670        .driver_name            = SERIAL_AMBA_NAME, 
     671        .dev_name               = SERIAL_AMBA_NAME, 
    673672        .major                  = SERIAL_AMBA_MAJOR, 
    674673        .minor                  = SERIAL_AMBA_MINOR, 
    675         .nr                     = UART_NR, 
     674        .nr                     = SERIAL_AMBA_NR, 
    676675        .cons                   = AMBA_CONSOLE, 
    677676}; 
    678677 
  • drivers/tty/serial/Kconfig

    a b config SERIAL_AMBA_PL010 
    276276        help 
    277277          This selects the ARM(R) AMBA(R) PrimeCell PL010 UART.  If you have 
    278278          an Integrator/AP or Integrator/PP2 platform, or if you have a 
    279           Cirrus Logic EP93xx CPU, say Y or M here. 
     279          Cirrus Logic EP93xx CPU or an Infineon ADM5120 SOC, say Y or M here. 
    280280 
    281281          If unsure, say N. 
    282282 
     283config SERIAL_AMBA_PL010_NUMPORTS 
     284        int "Maximum number of AMBA PL010 serial ports" 
     285        depends on SERIAL_AMBA_PL010 
     286        default "8" 
     287        ---help--- 
     288          Set this to the number of serial ports you want the AMBA PL010 driver 
     289          to support. 
     290 
     291config SERIAL_AMBA_PL010_PORTNAME 
     292        string "Name of the AMBA PL010 serial ports" 
     293        depends on SERIAL_AMBA_PL010 
     294        default "ttyAM" 
     295        ---help--- 
     296          ::: To be written ::: 
     297 
    283298config SERIAL_AMBA_PL010_CONSOLE 
    284299        bool "Support for console on AMBA serial port" 
    285300        depends on SERIAL_AMBA_PL010=y 
Note: See TracBrowser for help on using the repository browser.