Changeset 11578


Ignore:
Timestamp:
2008-06-26T01:05:50+02:00 (8 years ago)
Author:
blogic
Message:

cleanup ifxmips and add support for both ttyS

Location:
trunk/target/linux/ifxmips/files
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ifxmips/files/arch/mips/ifxmips/prom.c

    r11570 r11578  
    2727unsigned int prom_cp1_size = 0; 
    2828 
     29static inline u32 
     30asc_r32(unsigned long r) 
     31{ 
     32        return ifxmips_r32((u32*)(IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_BASE_DIFF + r)); 
     33} 
     34 
     35static inline void 
     36asc_w32(u32 v, unsigned long r) 
     37{ 
     38        ifxmips_w32(v, (u32*)(IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_BASE_DIFF + r)); 
     39} 
     40 
    2941void 
    3042prom_free_prom_memory(void) 
     
    3547prom_putchar(char c) 
    3648{ 
    37         while((ifxmips_r32(IFXMIPS_ASC1_FSTAT) & ASCFSTAT_TXFFLMASK) >> ASCFSTAT_TXFFLOFF); 
     49        unsigned long flags; 
     50 
     51        local_irq_save(flags); 
     52        while((asc_r32(IFXMIPS_ASC_FSTAT) & ASCFSTAT_TXFFLMASK) >> ASCFSTAT_TXFFLOFF); 
    3853 
    3954        if(c == '\n') 
    40                 ifxmips_w32('\r', IFXMIPS_ASC1_TBUF); 
    41         ifxmips_w32(c, IFXMIPS_ASC1_TBUF); 
     55                asc_w32('\r', IFXMIPS_ASC_TBUF); 
     56        asc_w32(c, IFXMIPS_ASC_TBUF); 
     57        local_irq_restore(flags); 
    4258} 
    4359 
  • trunk/target/linux/ifxmips/files/drivers/char/ifxmips_led.c

    r11396 r11578  
    148148                tmp->cdev.brightness_set = ifxmips_ledapi_set; 
    149149                tmp->cdev.name = kmalloc(sizeof("ifxmips:led:00"), GFP_KERNEL); 
    150                 sprintf(tmp->cdev.name, "ifxmips:led:%02d", i); 
     150                sprintf((char*)tmp->cdev.name, "ifxmips:led:%02d", i); 
    151151                tmp->cdev.default_trigger = NULL; 
    152152                tmp->bit = i; 
  • trunk/target/linux/ifxmips/files/drivers/serial/ifxmips_asc.c

    r11570 r11578  
    11/* 
    2  *  Driver for IFXMIPSASC serial ports 
    3  * 
    42 *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o. 
    53 * 
     
    6159static void ifxmipsasc_tx_chars(struct uart_port *port); 
    6260extern void prom_printf(const char * fmt, ...); 
    63 static struct uart_port ifxmipsasc_port; 
     61static struct uart_port ifxmipsasc_port[2]; 
    6462static struct uart_driver ifxmipsasc_reg; 
    6563static unsigned int uartclk = 0; 
     
    6765 
    6866static void 
    69 ifxmipsasc_stop_tx (struct uart_port *port) 
    70 { 
    71         /* fifo underrun shuts up after firing once */ 
     67ifxmipsasc_stop_tx(struct uart_port *port) 
     68{ 
    7269        return; 
    7370} 
    7471 
    7572static void 
    76 ifxmipsasc_start_tx (struct uart_port *port) 
     73ifxmipsasc_start_tx(struct uart_port *port) 
    7774{ 
    7875        unsigned long flags; 
    79  
    8076        local_irq_save(flags); 
    8177        ifxmipsasc_tx_chars(port); 
    8278        local_irq_restore(flags); 
    83  
    8479        return; 
    8580} 
    8681 
    8782static void 
    88 ifxmipsasc_stop_rx (struct uart_port *port) 
    89 { 
    90         /* clear the RX enable bit */ 
    91         ifxmips_w32(ASCWHBSTATE_CLRREN, IFXMIPS_ASC1_WHBSTATE); 
    92 } 
    93  
    94 static void 
    95 ifxmipsasc_enable_ms (struct uart_port *port) 
    96 { 
    97         /* no modem signals */ 
    98         return; 
    99 } 
    100  
    101 static void 
    102 ifxmipsasc_rx_chars (struct uart_port *port) 
     83ifxmipsasc_stop_rx(struct uart_port *port) 
     84{ 
     85        ifxmips_w32(ASCWHBSTATE_CLRREN, port->membase + IFXMIPS_ASC_WHBSTATE); 
     86} 
     87 
     88static void 
     89ifxmipsasc_enable_ms(struct uart_port *port) 
     90{ 
     91} 
     92 
     93static void 
     94ifxmipsasc_rx_chars(struct uart_port *port) 
    10395{ 
    10496        struct tty_struct *tty = port->info->tty; 
    10597        unsigned int ch = 0, rsr = 0, fifocnt; 
    10698 
    107         fifocnt = ifxmips_r32(IFXMIPS_ASC1_FSTAT) & ASCFSTAT_RXFFLMASK; 
    108         while (fifocnt--) 
     99        fifocnt = ifxmips_r32(port->membase + IFXMIPS_ASC_FSTAT) & ASCFSTAT_RXFFLMASK; 
     100        while(fifocnt--) 
    109101        { 
    110102                u8 flag = TTY_NORMAL; 
    111                 ch = ifxmips_r32(IFXMIPS_ASC1_RBUF); 
    112                 rsr = (ifxmips_r32(IFXMIPS_ASC1_STATE) & ASCSTATE_ANY) | UART_DUMMY_UER_RX; 
     103                ch = ifxmips_r32(port->membase + IFXMIPS_ASC_RBUF); 
     104                rsr = (ifxmips_r32(port->membase + IFXMIPS_ASC_STATE) & ASCSTATE_ANY) | UART_DUMMY_UER_RX; 
    113105                tty_flip_buffer_push(tty); 
    114106                port->icount.rx++; 
     
    118110                 * out of the main execution path 
    119111                 */ 
    120                 if (rsr & ASCSTATE_ANY) { 
    121                         if (rsr & ASCSTATE_PE) { 
     112                if(rsr & ASCSTATE_ANY) 
     113                { 
     114                        if(rsr & ASCSTATE_PE) 
     115                        { 
    122116                                port->icount.parity++; 
    123                                 ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_WHBSTATE) | ASCWHBSTATE_CLRPE, IFXMIPS_ASC1_WHBSTATE); 
    124                         } else if (rsr & ASCSTATE_FE) { 
     117                                ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_WHBSTATE) | ASCWHBSTATE_CLRPE, port->membase + IFXMIPS_ASC_WHBSTATE); 
     118                        } else if(rsr & ASCSTATE_FE) 
     119                        { 
    125120                                port->icount.frame++; 
    126                                 ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_WHBSTATE) | ASCWHBSTATE_CLRFE, IFXMIPS_ASC1_WHBSTATE); 
     121                                ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_WHBSTATE) | ASCWHBSTATE_CLRFE, port->membase + IFXMIPS_ASC_WHBSTATE); 
    127122                        } 
    128                         if (rsr & ASCSTATE_ROE) { 
     123                        if(rsr & ASCSTATE_ROE) 
     124                        { 
    129125                                port->icount.overrun++; 
    130                                 ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_WHBSTATE) | ASCWHBSTATE_CLRROE, IFXMIPS_ASC1_WHBSTATE); 
     126                                ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_WHBSTATE) | ASCWHBSTATE_CLRROE, port->membase + IFXMIPS_ASC_WHBSTATE); 
    131127                        } 
    132128 
    133129                        rsr &= port->read_status_mask; 
    134130 
    135                         if (rsr & ASCSTATE_PE) 
     131                        if(rsr & ASCSTATE_PE) 
    136132                                flag = TTY_PARITY; 
    137                         else if (rsr & ASCSTATE_FE) 
     133                        else if(rsr & ASCSTATE_FE) 
    138134                                flag = TTY_FRAME; 
    139135                } 
    140136 
    141                 if ((rsr & port->ignore_status_mask) == 0) 
     137                if((rsr & port->ignore_status_mask) == 0) 
    142138                        tty_insert_flip_char(tty, ch, flag); 
    143139 
    144                 if (rsr & ASCSTATE_ROE) 
     140                if(rsr & ASCSTATE_ROE) 
    145141                        /* 
    146142                         * Overrun is special, since it's reported 
     
    150146                        tty_insert_flip_char(tty, 0, TTY_OVERRUN); 
    151147        } 
    152         if (ch != 0) 
     148        if(ch != 0) 
    153149                tty_flip_buffer_push(tty); 
    154  
    155150        return; 
    156151} 
     
    158153 
    159154static void 
    160 ifxmipsasc_tx_chars (struct uart_port *port) 
     155ifxmipsasc_tx_chars(struct uart_port *port) 
    161156{ 
    162157        struct circ_buf *xmit = &port->info->xmit; 
    163158 
    164         if (uart_tx_stopped(port)) { 
     159        if(uart_tx_stopped(port)) 
     160        { 
    165161                ifxmipsasc_stop_tx(port); 
    166162                return; 
    167163        } 
    168164 
    169         while(((ifxmips_r32(IFXMIPS_ASC1_FSTAT) & ASCFSTAT_TXFFLMASK) 
     165        while(((ifxmips_r32(port->membase + IFXMIPS_ASC_FSTAT) & ASCFSTAT_TXFFLMASK) 
    170166                                >> ASCFSTAT_TXFFLOFF) != IFXMIPSASC_TXFIFO_FULL) 
    171167        { 
    172                 if (port->x_char) { 
    173                         ifxmips_w32(port->x_char, IFXMIPS_ASC1_TBUF); 
     168                if(port->x_char) 
     169                { 
     170                        ifxmips_w32(port->x_char, port->membase + IFXMIPS_ASC_TBUF); 
    174171                        port->icount.tx++; 
    175172                        port->x_char = 0; 
     
    177174                } 
    178175 
    179                 if (uart_circ_empty(xmit)) 
     176                if(uart_circ_empty(xmit)) 
    180177                        break; 
    181178 
    182                 ifxmips_w32(port->info->xmit.buf[port->info->xmit.tail], IFXMIPS_ASC1_TBUF); 
     179                ifxmips_w32(port->info->xmit.buf[port->info->xmit.tail], port->membase + IFXMIPS_ASC_TBUF); 
    183180                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); 
    184181                port->icount.tx++; 
    185182        } 
    186183 
    187         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 
     184        if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 
    188185                uart_write_wakeup(port); 
    189186} 
    190187 
    191188static irqreturn_t 
    192 ifxmipsasc_tx_int (int irq, void *port) 
    193 { 
    194         ifxmips_w32(ASC_IRNCR_TIR, IFXMIPS_ASC1_IRNCR); 
     189ifxmipsasc_tx_int(int irq, void *_port) 
     190{ 
     191        struct uart_port *port = (struct uart_port*) _port; 
     192        ifxmips_w32(ASC_IRNCR_TIR, port->membase + IFXMIPS_ASC_IRNCR); 
    195193        ifxmipsasc_start_tx(port); 
    196194        ifxmips_mask_and_ack_irq(irq); 
    197  
    198195        return IRQ_HANDLED; 
    199196} 
    200197 
    201198static irqreturn_t 
    202 ifxmipsasc_er_int (int irq, void *port) 
    203 { 
     199ifxmipsasc_er_int(int irq, void *_port) 
     200{ 
     201        struct uart_port *port = (struct uart_port*) _port; 
    204202        /* clear any pending interrupts */ 
    205         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_WHBSTATE) | ASCWHBSTATE_CLRPE | 
    206                         ASCWHBSTATE_CLRFE | ASCWHBSTATE_CLRROE, IFXMIPS_ASC1_WHBSTATE); 
    207  
     203        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_WHBSTATE) | ASCWHBSTATE_CLRPE | 
     204                        ASCWHBSTATE_CLRFE | ASCWHBSTATE_CLRROE, port->membase + IFXMIPS_ASC_WHBSTATE); 
    208205        return IRQ_HANDLED; 
    209206} 
    210207 
    211208static irqreturn_t 
    212 ifxmipsasc_rx_int (int irq, void *port) 
    213 { 
    214         ifxmips_w32(ASC_IRNCR_RIR, IFXMIPS_ASC1_IRNCR); 
    215         ifxmipsasc_rx_chars((struct uart_port *) port); 
     209ifxmipsasc_rx_int(int irq, void *_port) 
     210{ 
     211        struct uart_port *port = (struct uart_port*)_port; 
     212        ifxmips_w32(ASC_IRNCR_RIR, port->membase + IFXMIPS_ASC_IRNCR); 
     213        ifxmipsasc_rx_chars((struct uart_port*)port); 
    216214        ifxmips_mask_and_ack_irq(irq); 
    217  
    218215        return IRQ_HANDLED; 
    219216} 
    220217 
    221218static unsigned int 
    222 ifxmipsasc_tx_empty (struct uart_port *port) 
     219ifxmipsasc_tx_empty(struct uart_port *port) 
    223220{ 
    224221        int status; 
    225  
    226         status = ifxmips_r32(IFXMIPS_ASC1_FSTAT) & ASCFSTAT_TXFFLMASK; 
    227  
     222        status = ifxmips_r32(port->membase + IFXMIPS_ASC_FSTAT) & ASCFSTAT_TXFFLMASK; 
    228223        return status ? 0 : TIOCSER_TEMT; 
    229224} 
    230225 
    231226static unsigned int 
    232 ifxmipsasc_get_mctrl (struct uart_port *port) 
     227ifxmipsasc_get_mctrl(struct uart_port *port) 
    233228{ 
    234229        return TIOCM_CTS | TIOCM_CAR | TIOCM_DSR; 
     
    236231 
    237232static void 
    238 ifxmipsasc_set_mctrl (struct uart_port *port, u_int mctrl) 
    239 { 
    240         return; 
    241 } 
    242  
    243 static void 
    244 ifxmipsasc_break_ctl (struct uart_port *port, int break_state) 
    245 { 
    246         return; 
    247 } 
    248  
    249 static void 
    250 ifxmipsasc1_hw_init (void) 
    251 { 
    252         /* this setup was probably already done in ROM/u-boot  but we do it again*/ 
    253         /* TODO: GPIO pins are multifunction */ 
    254         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_CLC) & ~IFXMIPS_ASC1_CLC_DISS, IFXMIPS_ASC1_CLC); 
    255         ifxmips_w32((ifxmips_r32(IFXMIPS_ASC1_CLC) & ~ASCCLC_RMCMASK) | (1 << ASCCLC_RMCOFFSET), IFXMIPS_ASC1_CLC); 
    256         ifxmips_w32(0, IFXMIPS_ASC1_PISEL); 
    257         ifxmips_w32(((IFXMIPSASC_TXFIFO_FL << ASCTXFCON_TXFITLOFF) & 
    258                 ASCTXFCON_TXFITLMASK) | ASCTXFCON_TXFEN | ASCTXFCON_TXFFLU, IFXMIPS_ASC1_TXFCON); 
    259         ifxmips_w32(((IFXMIPSASC_RXFIFO_FL << ASCRXFCON_RXFITLOFF) & 
    260                 ASCRXFCON_RXFITLMASK) | ASCRXFCON_RXFEN | ASCRXFCON_RXFFLU, IFXMIPS_ASC1_RXFCON); 
    261         wmb (); 
    262  
    263         /*framing, overrun, enable */ 
    264         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_CON) | ASCCON_M_8ASYNC | ASCCON_FEN | ASCCON_TOEN | ASCCON_ROEN, 
    265                 IFXMIPS_ASC1_CON); 
     233ifxmipsasc_set_mctrl(struct uart_port *port, u_int mctrl) 
     234{ 
     235} 
     236 
     237static void 
     238ifxmipsasc_break_ctl(struct uart_port *port, int break_state) 
     239{ 
    266240} 
    267241 
    268242static int 
    269 ifxmipsasc_startup (struct uart_port *port) 
     243ifxmipsasc_startup(struct uart_port *port) 
    270244{ 
    271245        unsigned long flags; 
    272246        int retval; 
    273247 
    274         /* this assumes: CON.BRS = CON.FDE = 0 */ 
    275         if (uartclk == 0) 
     248        if(uartclk == 0) 
    276249                uartclk = ifxmips_get_fpi_hz(); 
    277250 
    278         ifxmipsasc_port.uartclk = uartclk; 
    279  
    280         ifxmipsasc1_hw_init(); 
     251        port->uartclk = uartclk; 
     252 
     253        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_CLC) & ~IFXMIPS_ASC_CLC_DISS, port->membase + IFXMIPS_ASC_CLC); 
     254        ifxmips_w32(((ifxmips_r32(port->membase + IFXMIPS_ASC_CLC) & ~ASCCLC_RMCMASK)) | (1 << ASCCLC_RMCOFFSET), port->membase + IFXMIPS_ASC_CLC); 
     255        ifxmips_w32(0, port->membase + IFXMIPS_ASC_PISEL); 
     256        ifxmips_w32(((IFXMIPSASC_TXFIFO_FL << ASCTXFCON_TXFITLOFF) & ASCTXFCON_TXFITLMASK) | ASCTXFCON_TXFEN | ASCTXFCON_TXFFLU, port->membase + IFXMIPS_ASC_TXFCON); 
     257        ifxmips_w32(((IFXMIPSASC_RXFIFO_FL << ASCRXFCON_RXFITLOFF) & ASCRXFCON_RXFITLMASK) | ASCRXFCON_RXFEN | ASCRXFCON_RXFFLU, port->membase + IFXMIPS_ASC_RXFCON); 
     258        wmb (); 
     259        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_CON) | ASCCON_M_8ASYNC | ASCCON_FEN | ASCCON_TOEN | ASCCON_ROEN, port->membase + IFXMIPS_ASC_CON); 
    281260 
    282261        local_irq_save(flags); 
    283262 
    284         retval = request_irq(IFXMIPSASC1_RIR, ifxmipsasc_rx_int, IRQF_DISABLED, "asc_rx", port); 
    285         if (retval){ 
     263        retval = request_irq(port->irq, ifxmipsasc_rx_int, IRQF_DISABLED, "asc_rx", port); 
     264        if(retval) 
     265        { 
    286266                printk("failed to request ifxmipsasc_rx_int\n"); 
    287267                return retval; 
    288268        } 
    289269 
    290         retval = request_irq(IFXMIPSASC1_TIR, ifxmipsasc_tx_int, IRQF_DISABLED, "asc_tx", port); 
    291         if (retval){ 
     270        retval = request_irq(port->irq + 2, ifxmipsasc_tx_int, IRQF_DISABLED, "asc_tx", port); 
     271        if(retval) 
     272        { 
    292273                printk("failed to request ifxmipsasc_tx_int\n"); 
    293274                goto err1; 
    294275        } 
    295276 
    296         retval = request_irq(IFXMIPSASC1_EIR, ifxmipsasc_er_int, IRQF_DISABLED, "asc_er", port); 
    297         if (retval){ 
     277        retval = request_irq(port->irq + 3, ifxmipsasc_er_int, IRQF_DISABLED, "asc_er", port); 
     278        if(retval) 
     279        { 
    298280                printk("failed to request ifxmipsasc_er_int\n"); 
    299281                goto err2; 
    300282        } 
    301283 
    302         ifxmips_w32(ASC_IRNREN_RX_BUF | ASC_IRNREN_TX_BUF | ASC_IRNREN_ERR | ASC_IRNREN_TX, 
    303                 IFXMIPS_ASC1_IRNREN); 
     284        ifxmips_w32(ASC_IRNREN_RX_BUF | ASC_IRNREN_TX_BUF | ASC_IRNREN_ERR | ASC_IRNREN_TX, port->membase + IFXMIPS_ASC_IRNREN); 
    304285 
    305286        local_irq_restore(flags); 
    306  
    307287        return 0; 
    308288 
    309289err2: 
    310         free_irq(IFXMIPSASC1_TIR, port); 
    311  
     290        free_irq(port->irq + 2, port); 
    312291err1: 
    313         free_irq(IFXMIPSASC1_RIR, port); 
     292        free_irq(port->irq, port); 
    314293        local_irq_restore(flags); 
    315  
    316294        return retval; 
    317295} 
    318296 
    319297static void 
    320 ifxmipsasc_shutdown (struct uart_port *port) 
    321 { 
    322         free_irq(IFXMIPSASC1_RIR, port); 
    323         free_irq(IFXMIPSASC1_TIR, port); 
    324         free_irq(IFXMIPSASC1_EIR, port); 
    325         /* 
    326          * disable the baudrate generator to disable the ASC 
    327          */ 
    328         ifxmips_w32(0, IFXMIPS_ASC1_CON); 
    329  
    330         /* flush and then disable the fifos */ 
    331         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_RXFCON) | ASCRXFCON_RXFFLU, IFXMIPS_ASC1_RXFCON); 
    332         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_RXFCON) & ~ASCRXFCON_RXFEN, IFXMIPS_ASC1_RXFCON); 
    333         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_TXFCON) | ASCTXFCON_TXFFLU, IFXMIPS_ASC1_TXFCON); 
    334         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_TXFCON) & ~ASCTXFCON_TXFEN, IFXMIPS_ASC1_TXFCON); 
     298ifxmipsasc_shutdown(struct uart_port *port) 
     299{ 
     300        free_irq(port->irq, port); 
     301        free_irq(port->irq + 2, port); 
     302        free_irq(port->irq + 3, port); 
     303 
     304        ifxmips_w32(0, port->membase + IFXMIPS_ASC_CON); 
     305        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_RXFCON) | ASCRXFCON_RXFFLU, port->membase + IFXMIPS_ASC_RXFCON); 
     306        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_RXFCON) & ~ASCRXFCON_RXFEN, port->membase + IFXMIPS_ASC_RXFCON); 
     307        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_TXFCON) | ASCTXFCON_TXFFLU, port->membase + IFXMIPS_ASC_TXFCON); 
     308        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_TXFCON) & ~ASCTXFCON_TXFEN, port->membase + IFXMIPS_ASC_TXFCON); 
    335309} 
    336310 
     
    347321        iflag = new->c_iflag; 
    348322 
    349         /* byte size and parity */ 
    350         switch (cflag & CSIZE) { 
     323        switch(cflag & CSIZE) 
     324        { 
    351325        case CS7: 
    352326                con = ASCCON_M_7ASYNC; 
     
    360334        } 
    361335 
    362         if (cflag & CSTOPB) 
     336        if(cflag & CSTOPB) 
    363337                con |= ASCCON_STP; 
    364338 
    365         if (cflag & PARENB) { 
    366                 if (!(cflag & PARODD)) 
     339        if(cflag & PARENB) 
     340        { 
     341                if(!(cflag & PARODD)) 
    367342                        con &= ~ASCCON_ODD; 
    368343                else 
     
    371346 
    372347        port->read_status_mask = ASCSTATE_ROE; 
    373         if (iflag & INPCK) 
     348        if(iflag & INPCK) 
    374349                port->read_status_mask |= ASCSTATE_FE | ASCSTATE_PE; 
    375350 
    376351        port->ignore_status_mask = 0; 
    377         if (iflag & IGNPAR) 
     352        if(iflag & IGNPAR) 
    378353                port->ignore_status_mask |= ASCSTATE_FE | ASCSTATE_PE; 
    379354 
    380         if (iflag & IGNBRK) { 
     355        if(iflag & IGNBRK) 
     356        { 
    381357                /* 
    382358                 * If we're ignoring parity and break indicators, 
    383359                 * ignore overruns too (for real raw support). 
    384360                 */ 
    385                 if (iflag & IGNPAR) 
     361                if(iflag & IGNPAR) 
    386362                        port->ignore_status_mask |= ASCSTATE_ROE; 
    387363        } 
    388364 
    389         if ((cflag & CREAD) == 0) 
     365        if((cflag & CREAD) == 0) 
    390366                port->ignore_status_mask |= UART_DUMMY_UER_RX; 
    391367 
     
    396372 
    397373        /* set up CON */ 
    398         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_CON) | con, IFXMIPS_ASC1_CON); 
     374        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_CON) | con, port->membase + IFXMIPS_ASC_CON); 
    399375 
    400376        /* Set baud rate - take a divider of 2 into account */ 
     
    404380 
    405381        /* disable the baudrate generator */ 
    406         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_CON) & ~ASCCON_R, IFXMIPS_ASC1_CON); 
     382        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_CON) & ~ASCCON_R, port->membase + IFXMIPS_ASC_CON); 
    407383 
    408384        /* make sure the fractional divider is off */ 
    409         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_CON) & ~ASCCON_FDE, IFXMIPS_ASC1_CON); 
     385        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_CON) & ~ASCCON_FDE, port->membase + IFXMIPS_ASC_CON); 
    410386 
    411387        /* set up to use divisor of 2 */ 
    412         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_CON) & ~ASCCON_BRS, IFXMIPS_ASC1_CON); 
     388        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_CON) & ~ASCCON_BRS, port->membase + IFXMIPS_ASC_CON); 
    413389 
    414390        /* now we can write the new baudrate into the register */ 
    415         ifxmips_w32(quot, IFXMIPS_ASC1_BG); 
     391        ifxmips_w32(quot, port->membase + IFXMIPS_ASC_BG); 
    416392 
    417393        /* turn the baudrate generator back on */ 
    418         ifxmips_w32(ifxmips_r32(IFXMIPS_ASC1_CON) | ASCCON_R, IFXMIPS_ASC1_CON); 
     394        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_CON) | ASCCON_R, port->membase + IFXMIPS_ASC_CON); 
    419395 
    420396        /* enable rx */ 
    421         ifxmips_w32(ASCWHBSTATE_SETREN, IFXMIPS_ASC1_WHBSTATE); 
     397        ifxmips_w32(ASCWHBSTATE_SETREN, port->membase + IFXMIPS_ASC_WHBSTATE); 
    422398 
    423399        local_irq_restore(flags); 
     
    425401 
    426402static const char* 
    427 ifxmipsasc_type (struct uart_port *port) 
     403ifxmipsasc_type(struct uart_port *port) 
    428404{ 
    429405        return port->type == PORT_IFXMIPSASC ? "IFXMIPSASC" : NULL; 
     
    431407 
    432408static void 
    433 ifxmipsasc_release_port (struct uart_port *port) 
    434 { 
    435         return; 
     409ifxmipsasc_release_port(struct uart_port *port) 
     410{ 
    436411} 
    437412 
    438413static int 
    439 ifxmipsasc_request_port (struct uart_port *port) 
     414ifxmipsasc_request_port(struct uart_port *port) 
    440415{ 
    441416        return 0; 
     
    443418 
    444419static void 
    445 ifxmipsasc_config_port (struct uart_port *port, int flags) 
    446 { 
    447         if (flags & UART_CONFIG_TYPE) { 
     420ifxmipsasc_config_port(struct uart_port *port, int flags) 
     421{ 
     422        if(flags & UART_CONFIG_TYPE) 
     423        { 
    448424                port->type = PORT_IFXMIPSASC; 
    449425                ifxmipsasc_request_port(port); 
     
    452428 
    453429static int 
    454 ifxmipsasc_verify_port (struct uart_port *port, struct serial_struct *ser) 
     430ifxmipsasc_verify_port(struct uart_port *port, struct serial_struct *ser) 
    455431{ 
    456432        int ret = 0; 
    457         if (ser->type != PORT_UNKNOWN && ser->type != PORT_IFXMIPSASC) 
     433        if(ser->type != PORT_UNKNOWN && ser->type != PORT_IFXMIPSASC) 
    458434                ret = -EINVAL; 
    459         if (ser->irq < 0 || ser->irq >= NR_IRQS) 
     435        if(ser->irq < 0 || ser->irq >= NR_IRQS) 
    460436                ret = -EINVAL; 
    461         if (ser->baud_base < 9600) 
     437        if(ser->baud_base < 9600) 
    462438                ret = -EINVAL; 
    463439        return ret; 
    464440} 
    465441 
    466 static struct uart_ops ifxmipsasc_pops = { 
     442static struct uart_ops ifxmipsasc_pops = 
     443{ 
    467444        .tx_empty =             ifxmipsasc_tx_empty, 
    468445        .set_mctrl =    ifxmipsasc_set_mctrl, 
     
    483460}; 
    484461 
    485 static struct uart_port ifxmipsasc_port = { 
    486                 membase:        (void *)IFXMIPS_ASC1_BASE_ADDR, 
    487                 mapbase:        IFXMIPS_ASC1_BASE_ADDR, 
    488                 iotype:         SERIAL_IO_MEM, 
    489                 irq:            IFXMIPSASC1_RIR, 
    490                 uartclk:        0, 
    491                 fifosize:       16, 
    492                 unused:         {IFXMIPSASC1_TIR, IFXMIPSASC1_EIR}, 
    493                 type:           PORT_IFXMIPSASC, 
    494                 ops:            &ifxmipsasc_pops, 
    495                 flags:          ASYNC_BOOT_AUTOCONF, 
     462static struct uart_port ifxmipsasc_port[2] = 
     463{ 
     464        { 
     465                membase:                (void *)IFXMIPS_ASC_BASE_ADDR, 
     466                mapbase:                IFXMIPS_ASC_BASE_ADDR, 
     467                iotype:                 SERIAL_IO_MEM, 
     468                irq:                    IFXMIPSASC_RIR(0), 
     469                uartclk:                0, 
     470                fifosize:               16, 
     471                type:                   PORT_IFXMIPSASC, 
     472                ops:                    &ifxmipsasc_pops, 
     473                flags:                  ASYNC_BOOT_AUTOCONF, 
     474        }, { 
     475                membase:                (void *)(IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_BASE_DIFF), 
     476                mapbase:                IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_BASE_DIFF, 
     477                iotype:                 SERIAL_IO_MEM, 
     478                irq:                    IFXMIPSASC_RIR(1), 
     479                uartclk:                0, 
     480                fifosize:               16, 
     481                type:                   PORT_IFXMIPSASC, 
     482                ops:                    &ifxmipsasc_pops, 
     483                flags:                  ASYNC_BOOT_AUTOCONF, 
     484        } 
    496485}; 
    497486 
    498487static void 
    499 ifxmipsasc_console_write (struct console *co, const char *s, u_int count) 
     488ifxmipsasc_console_write(struct console *co, const char *s, u_int count) 
    500489{ 
    501490        int i, fifocnt; 
     
    503492 
    504493        local_irq_save(flags); 
    505         for (i = 0; i < count; i++) 
     494        for(i = 0; i < count; i++) 
    506495        { 
    507496                /* wait until the FIFO is not full */ 
    508497                do 
    509498                { 
    510                         fifocnt = (ifxmips_r32(IFXMIPS_ASC1_FSTAT) & ASCFSTAT_TXFFLMASK) 
     499                        fifocnt = (ifxmips_r32((u32*)(IFXMIPS_ASC_BASE_ADDR + (co->index * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_FSTAT)) & ASCFSTAT_TXFFLMASK) 
    511500                                        >> ASCFSTAT_TXFFLOFF; 
    512                 } while (fifocnt == IFXMIPSASC_TXFIFO_FULL); 
    513  
    514                 if (s[i] == '\0') 
     501                }while(fifocnt == IFXMIPSASC_TXFIFO_FULL); 
     502 
     503                if(s[i] == '\0') 
     504                        break; 
     505 
     506                if(s[i] == '\n') 
    515507                { 
    516                         break; 
    517                 } 
    518  
    519                 if (s[i] == '\n') 
    520                 { 
    521                         ifxmips_w32('\r', IFXMIPS_ASC1_TBUF); 
     508                        ifxmips_w32('\r', (u32*)(IFXMIPS_ASC_BASE_ADDR + (co->index * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_TBUF)); 
    522509                        do 
    523510                        { 
    524                                 fifocnt = (ifxmips_r32(IFXMIPS_ASC1_FSTAT) & ASCFSTAT_TXFFLMASK) 
     511                                fifocnt = (ifxmips_r32((u32*)(IFXMIPS_ASC_BASE_ADDR + (co->index * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_FSTAT)) & ASCFSTAT_TXFFLMASK) 
    525512                                        >> ASCFSTAT_TXFFLOFF; 
    526                         } while (fifocnt == IFXMIPSASC_TXFIFO_FULL); 
     513                        } while(fifocnt == IFXMIPSASC_TXFIFO_FULL); 
    527514                } 
    528                 ifxmips_w32(s[i], IFXMIPS_ASC1_TBUF); 
     515                ifxmips_w32(s[i], (u32*)(IFXMIPS_ASC_BASE_ADDR + (co->index * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_TBUF)); 
    529516        } 
    530517 
     
    533520 
    534521static int __init 
    535 ifxmipsasc_console_setup (struct console *co, char *options) 
     522ifxmipsasc_console_setup(struct console *co, char *options) 
    536523{ 
    537524        struct uart_port *port; 
     
    541528        int flow = 'n'; 
    542529 
    543         if (uartclk == 0) 
     530        if(uartclk == 0) 
    544531                uartclk = ifxmips_get_fpi_hz(); 
    545532        co->index = 0; 
    546         port = &ifxmipsasc_port; 
    547         ifxmipsasc_port.uartclk = uartclk; 
    548         ifxmipsasc_port.type = PORT_IFXMIPSASC; 
    549  
    550         if (options){ 
     533        port = &ifxmipsasc_port[co->index]; 
     534        ifxmipsasc_port[co->index].uartclk = uartclk; 
     535        ifxmipsasc_port[co->index].type = PORT_IFXMIPSASC; 
     536 
     537        if(options) 
    551538                uart_parse_options(options, &baud, &parity, &bits, &flow); 
    552         } 
    553539 
    554540        return uart_set_options(port, co, baud, parity, bits, flow); 
    555541} 
    556542 
    557 static struct uart_driver ifxmipsasc_reg; 
    558 static struct console ifxmipsasc_console = { 
    559         name:           "ttyS", 
    560         write:          ifxmipsasc_console_write, 
    561         device:         uart_console_device, 
    562         setup:          ifxmipsasc_console_setup, 
    563         flags:          CON_PRINTBUFFER, 
    564         index:          -1, 
    565         data:           &ifxmipsasc_reg, 
     543static struct console ifxmipsasc_console[2] = 
     544{ 
     545        { 
     546                name:           "ttyS", 
     547                write:          ifxmipsasc_console_write, 
     548                device:         uart_console_device, 
     549                setup:          ifxmipsasc_console_setup, 
     550                flags:          CON_PRINTBUFFER, 
     551                index:          0, 
     552                data:           &ifxmipsasc_reg, 
     553        }, { 
     554                name:           "ttyS", 
     555                write:          ifxmipsasc_console_write, 
     556                device:         uart_console_device, 
     557                setup:          ifxmipsasc_console_setup, 
     558                flags:          CON_PRINTBUFFER, 
     559                index:          1, 
     560                data:           &ifxmipsasc_reg, 
     561        } 
    566562}; 
    567563 
    568564static int __init 
    569 ifxmipsasc_console_init (void) 
    570 { 
    571         register_console(&ifxmipsasc_console); 
     565ifxmipsasc_console_init(void) 
     566{ 
     567        register_console(&ifxmipsasc_console[0]); 
     568        register_console(&ifxmipsasc_console[1]); 
    572569        return 0; 
    573570} 
    574571console_initcall(ifxmipsasc_console_init); 
    575572 
    576 static struct uart_driver ifxmipsasc_reg = { 
     573static struct uart_driver ifxmipsasc_reg = 
     574{ 
    577575        .owner =                        THIS_MODULE, 
    578576        .driver_name =          "serial", 
     
    580578        .major =                        TTY_MAJOR, 
    581579        .minor =                        64, 
    582         .nr =                           1, 
    583         .cons =                         &ifxmipsasc_console, 
     580        .nr =                           2, 
     581        .cons =                         ifxmipsasc_console, 
    584582}; 
    585583 
    586584static int __init 
    587 ifxmipsasc_init (void) 
     585ifxmipsasc_init(void) 
    588586{ 
    589587        unsigned char res; 
    590588 
    591589        uart_register_driver(&ifxmipsasc_reg); 
    592         res = uart_add_one_port(&ifxmipsasc_reg, &ifxmipsasc_port); 
     590        res = uart_add_one_port(&ifxmipsasc_reg, &ifxmipsasc_port[0]); 
     591        res = uart_add_one_port(&ifxmipsasc_reg, &ifxmipsasc_port[1]); 
    593592 
    594593        return res; 
     
    596595 
    597596static void __exit 
    598 ifxmipsasc_exit (void) 
     597ifxmipsasc_exit(void) 
    599598{ 
    600599        uart_unregister_driver(&ifxmipsasc_reg); 
  • trunk/target/linux/ifxmips/files/include/asm-mips/ifxmips/ifxmips.h

    r11558 r11578  
    3939/*------------ ASC1 */ 
    4040 
    41 #define IFXMIPS_ASC1_BASE_ADDR  (KSEG1 + 0x1E100C00) 
    42  
    43 /* FIFO status register */ 
    44 #define IFXMIPS_ASC1_FSTAT              ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0048)) 
    45 #define ASCFSTAT_TXFFLMASK              0x3F00 
    46 #define ASCFSTAT_TXFFLOFF               8 
    47  
    48 /* ASC1 transmit buffer */ 
    49 #define IFXMIPS_ASC1_TBUF               ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0020)) 
    50  
    51 /* channel operating modes */ 
     41#define IFXMIPS_ASC_BASE_ADDR   (KSEG1 + 0x1E100400) 
     42#define IFXMIPS_ASC_BASE_DIFF   (0x1E100C00 - 0x1E100400) 
     43 
     44#define IFXMIPS_ASC_FSTAT               0x0048 
     45#define IFXMIPS_ASC_TBUF                0x0020 
     46#define IFXMIPS_ASC_WHBSTATE    0x0018 
     47#define IFXMIPS_ASC_RBUF                0x0024 
     48#define IFXMIPS_ASC_STATE               0x0014 
     49#define IFXMIPS_ASC_IRNCR               0x00F8 
     50#define IFXMIPS_ASC_CLC                 0x0000 
     51#define IFXMIPS_ASC_PISEL               0x0004 
     52#define IFXMIPS_ASC_TXFCON              0x0044 
     53#define IFXMIPS_ASC_RXFCON              0x0040 
     54#define IFXMIPS_ASC_CON                 0x0010 
     55#define IFXMIPS_ASC_BG                  0x0050 
     56#define IFXMIPS_ASC_IRNREN              0x00F4 
     57 
     58#define IFXMIPS_ASC_CLC_DISS    0x2 
     59#define ASC_IRNREN_RX_BUF               0x8 
     60#define ASC_IRNREN_TX_BUF               0x4 
     61#define ASC_IRNREN_ERR                  0x2 
     62#define ASC_IRNREN_TX                   0x1 
     63#define ASC_IRNCR_TIR                   0x4 
     64#define ASC_IRNCR_RIR                   0x2 
     65#define ASC_IRNCR_EIR                   0x4 
    5266#define ASCOPT_CSIZE                    0x3 
    5367#define ASCOPT_CS7                              0x1 
     
    5771#define ASCOPT_PARODD                   0x0 
    5872#define ASCOPT_CREAD                    0x20 
    59  
    60 /* hardware modified control register */ 
    61 #define IFXMIPS_ASC1_WHBSTATE   ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0018)) 
    62  
    63 /* receive buffer register */ 
    64 #define IFXMIPS_ASC1_RBUF               ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0024)) 
    65  
    66 /* status register */ 
    67 #define IFXMIPS_ASC1_STATE              ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0014)) 
    68  
    69 /* interrupt control */ 
    70 #define IFXMIPS_ASC1_IRNCR              ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x00F8)) 
    71  
    72 #define ASC_IRNCR_TIR                   0x4 
    73 #define ASC_IRNCR_RIR                   0x2 
    74 #define ASC_IRNCR_EIR                   0x4 
    75  
    76 /* clock control */ 
    77 #define IFXMIPS_ASC1_CLC                        ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0000)) 
    78  
    79 #define IFXMIPS_ASC1_CLC_DISS   0x2 
    80  
    81 /* port input select register */ 
    82 #define IFXMIPS_ASC1_PISEL              ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0004)) 
    83  
    84 /* tx fifo */ 
    85 #define IFXMIPS_ASC1_TXFCON             ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0044)) 
    86  
    87 /* rx fifo */ 
    88 #define IFXMIPS_ASC1_RXFCON             ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0040)) 
    89  
    90 /* control */ 
    91 #define IFXMIPS_ASC1_CON                ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0010)) 
    92  
    93 /* timer reload */ 
    94 #define IFXMIPS_ASC1_BG                 ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x0050)) 
    95  
    96 /* int enable */ 
    97 #define IFXMIPS_ASC1_IRNREN             ((u32*)(IFXMIPS_ASC1_BASE_ADDR + 0x00F4)) 
    98  
    99 #define ASC_IRNREN_RX_BUF               0x8 
    100 #define ASC_IRNREN_TX_BUF               0x4 
    101 #define ASC_IRNREN_ERR                  0x2 
    102 #define ASC_IRNREN_TX                   0x1 
     73#define ASCFSTAT_TXFFLMASK              0x3F00 
     74#define ASCFSTAT_TXFFLOFF               8 
     75 
    10376 
    10477 
  • trunk/target/linux/ifxmips/files/include/asm-mips/ifxmips/ifxmips_irq.h

    r11570 r11578  
    2929#define INT_NUM_IM_OFFSET               (INT_NUM_IM1_IRL0 - INT_NUM_IM0_IRL0) 
    3030 
    31 #define IFXMIPSASC1_TIR                 (INT_NUM_IM3_IRL0 + 7) 
    32 #define IFXMIPSASC1_RIR                 (INT_NUM_IM3_IRL0 + 9) 
    33 #define IFXMIPSASC1_EIR                 (INT_NUM_IM3_IRL0 + 10) 
     31#define IFXMIPSASC_TIR(x)               (INT_NUM_IM3_IRL0 + (x * 7)) 
     32#define IFXMIPSASC_RIR(x)               (INT_NUM_IM3_IRL0 + (x * 7) + 2) 
     33#define IFXMIPSASC_EIR(x)               (INT_NUM_IM3_IRL0 + (x * 7) + 3) 
    3434 
    3535#define IFXMIPS_SSC_TIR                 (INT_NUM_IM0_IRL0 + 15) 
  • trunk/target/linux/ifxmips/files/include/asm-mips/ifxmips/ifxmips_prom.h

    r11558 r11578  
    2121#define _IFXPROM_H__ 
    2222 
    23 void prom_printf(const char * fmt, ...); 
    24 u32 *prom_get_cp1_base(void); 
    25 u32 prom_get_cp1_size(void); 
     23extern void prom_printf(const char * fmt, ...); 
     24extern u32 *prom_get_cp1_base(void); 
     25extern u32 prom_get_cp1_size(void); 
    2626 
    2727#endif 
  • trunk/target/linux/ifxmips/files/include/asm-mips/ifxmips/ifxmips_wdt.h

    r11573 r11578  
    1616 *   Copyright (C) 2005 infineon 
    1717 *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>  
     18 * 
    1819 */ 
    1920 
  • trunk/target/linux/ifxmips/files/include/asm-mips/mach-ifxmips/gpio.h

    r11573 r11578  
    11/* 
     2 *   include/asm-mips/mach-ifxmips/gpio.h  
     3 * 
    24 *   This program is free software; you can redistribute it and/or modify 
    35 *   it under the terms of the GNU General Public License as published by 
     
    1517 * 
    1618 *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>  
     19 * 
    1720 */ 
     21 
    1822 
    1923#ifndef _IFXMIPS_GPIO_H_ 
     
    2327#include <asm/ifxmips/ifxmips_gpio.h> 
    2428 
    25 static inline int 
    26 gpio_direction_input(unsigned gpio) 
    27 { 
     29static inline int gpio_direction_input(unsigned gpio) { 
    2830        ifxmips_port_set_dir_in(0, gpio); 
    2931        return 0; 
    3032} 
    3133 
    32 static inline int 
    33 gpio_direction_output(unsigned gpio, int value) 
    34 { 
     34static inline int gpio_direction_output(unsigned gpio, int value) { 
    3535        ifxmips_port_set_dir_out(0, gpio); 
    3636        return 0; 
    3737} 
    3838 
    39 static inline int 
    40 gpio_get_value(unsigned gpio) 
    41 { 
     39static inline int gpio_get_value(unsigned gpio) { 
    4240        ifxmips_port_get_input(0, gpio); 
    4341        return 0; 
    4442} 
    4543 
    46 static inline void 
    47 gpio_set_value(unsigned gpio, int value) 
    48 { 
     44static inline void gpio_set_value(unsigned gpio, int value) { 
    4945        ifxmips_port_set_output(0, gpio); 
    5046} 
    5147 
    52 static inline int 
    53 gpio_request(unsigned gpio, const char *label) 
    54 { 
     48static inline int gpio_request(unsigned gpio, const char *label) { 
    5549        return 0; 
    5650} 
    5751 
    58 static inline void 
    59 gpio_free(unsigned gpio) 
    60 { 
     52static inline void gpio_free(unsigned gpio) { 
    6153} 
    6254 
    63 static inline int 
    64 gpio_to_irq(unsigned gpio) 
    65 { 
     55static inline int gpio_to_irq(unsigned gpio) { 
    6656        return 0; 
    6757} 
    6858 
    69 static inline int 
    70 irq_to_gpio(unsigned irq) 
    71 { 
     59static inline int irq_to_gpio(unsigned irq) { 
    7260        return 0; 
    7361} 
    7462 
    75 static inline int 
    76 gpio_cansleep(unsigned gpio) 
    77 { 
     63static inline int gpio_cansleep(unsigned gpio) { 
    7864        return 0; 
    7965} 
    8066 
    81 static inline int 
    82 gpio_get_value_cansleep(unsigned gpio) 
    83 { 
     67static inline int gpio_get_value_cansleep(unsigned gpio) { 
    8468        might_sleep(); 
    8569        return gpio_get_value(gpio); 
    8670} 
    8771 
    88 static inline void 
    89 gpio_set_value_cansleep(unsigned gpio, int value) 
    90 { 
     72static inline void gpio_set_value_cansleep(unsigned gpio, int value) { 
    9173        might_sleep(); 
    9274        gpio_set_value(gpio, value); 
    9375} 
     76 
    9477#endif 
     78 
  • trunk/target/linux/ifxmips/files/include/asm-mips/mach-ifxmips/irq.h

    r11573 r11578  
    11/* 
     2 *   include/asm-mips/mach-ifxmips/irq.h  
     3 * 
    24 *   This program is free software; you can redistribute it and/or modify 
    35 *   it under the terms of the GNU General Public License as published by 
     
    1517 * 
    1618 *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>  
     19 * 
    1720 */ 
    1821 
  • trunk/target/linux/ifxmips/files/include/asm-mips/mach-ifxmips/war.h

    r11573 r11578  
    11/* 
    2  *   This program is free software; you can redistribute it and/or modify 
    3  *   it under the terms of the GNU General Public License as published by 
    4  *   the Free Software Foundation; either version 2 of the License, or 
    5  *   (at your option) any later version. 
     2 * This file is subject to the terms and conditions of the GNU General Public 
     3 * License.  See the file "COPYING" in the main directory of this archive 
     4 * for more details. 
    65 * 
    7  *   This program is distributed in the hope that it will be useful, 
    8  *   but WITHOUT ANY WARRANTY; without even the implied warranty of 
    9  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    10  *   GNU General Public License for more details. 
    11  * 
    12  *   You should have received a copy of the GNU General Public License 
    13  *   along with this program; if not, write to the Free Software 
    14  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. 
    15  * 
    16  *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>  
    176 */ 
    18  
    197#ifndef __ASM_MIPS_MACH_IFXMIPS_WAR_H 
    208#define __ASM_MIPS_MACH_IFXMIPS_WAR_H 
Note: See TracChangeset for help on using the changeset viewer.