Changeset 13660


Ignore:
Timestamp:
2008-12-16T15:07:55+01:00 (9 years ago)
Author:
thl
Message:

[ifxmips] cleanup sources and prepare for 2.6.27

Location:
trunk/target/linux/ifxmips
Files:
12 added
1 deleted
23 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ifxmips/Makefile

    r13295 r13660  
    1313SUBTARGETS:=generic nfs 
    1414LINUX_VERSION:=2.6.26.8 
     15#LINUX_VERSION:=2.6.27.9 
    1516 
    1617include $(INCLUDE_DIR)/target.mk 
  • trunk/target/linux/ifxmips/config-2.6.26

    r13492 r13660  
    2323# CONFIG_CPU_LOONGSON2 is not set 
    2424CONFIG_CPU_MIPS32=y 
    25 CONFIG_CPU_MIPS32_R1=y 
    26 # CONFIG_CPU_MIPS32_R2 is not set 
     25# CONFIG_CPU_MIPS32_R1 is not set 
     26CONFIG_CPU_MIPS32_R2=y 
    2727# CONFIG_CPU_MIPS64_R1 is not set 
    2828# CONFIG_CPU_MIPS64_R2 is not set 
    29 CONFIG_CPU_MIPSR1=y 
     29CONFIG_CPU_MIPSR2=y 
    3030# CONFIG_CPU_NEVADA is not set 
    3131# CONFIG_CPU_R10000 is not set 
     
    114114# CONFIG_MIPS_SEAD is not set 
    115115# CONFIG_MIPS_SIM is not set 
     116# CONFIG_MIPS_VPE_LOADER is not set 
    116117CONFIG_MTD=y 
    117118# CONFIG_MTD_ABSENT is not set 
     
    167168# CONFIG_NET_VENDOR_3COM is not set 
    168169# CONFIG_NO_IOPORT is not set 
    169 # CONFIG_OCF_OCF is not set 
    170170CONFIG_PAGEFLAGS_EXTENDED=y 
    171171# CONFIG_PAGE_SIZE_16KB is not set 
     
    181181# CONFIG_PNX8550_JBS is not set 
    182182# CONFIG_PNX8550_STB810 is not set 
     183# CONFIG_PROM_EMU is not set 
    183184# CONFIG_R6040 is not set 
    184185CONFIG_RFKILL_LEDS=y 
     
    209210CONFIG_SYSVIPC_SYSCTL=y 
    210211CONFIG_SYS_HAS_CPU_MIPS32_R1=y 
     212CONFIG_SYS_HAS_CPU_MIPS32_R2=y 
    211213CONFIG_SYS_HAS_EARLY_PRINTK=y 
    212214CONFIG_SYS_SUPPORTS_32BIT_KERNEL=y 
    213215CONFIG_SYS_SUPPORTS_ARBIT_HZ=y 
    214216CONFIG_SYS_SUPPORTS_BIG_ENDIAN=y 
     217CONFIG_SYS_SUPPORTS_MULTITHREADING=y 
    215218# CONFIG_TC35815 is not set 
    216219# CONFIG_TICK_ONESHOT is not set 
  • trunk/target/linux/ifxmips/files/arch/mips/ifxmips/board.c

    r13296 r13660  
    7171}; 
    7272 
    73 spinlock_t ebu_lock = SPIN_LOCK_UNLOCKED; 
     73DEFINE_SPINLOCK(ebu_lock); 
    7474EXPORT_SYMBOL_GPL(ebu_lock); 
    7575 
     
    246246#define IS_HEX(x) \ 
    247247        (((x >= '0' && x <= '9') || (x >= 'a' && x <= 'f') \ 
    248                 || (x >= 'A' && x <= 'F'))?(1):(0)) 
     248                || (x >= 'A' && x <= 'F')) ? (1) : (0)) 
    249249        int i; 
    250250        str = strchr(str, '='); 
     
    355355        ifxmips_led_data.leds = board->ifxmips_leds; 
    356356 
    357         printk(KERN_INFO "%s:%s[%d]adding %d devs\n", 
    358                 __FILE__, __func__, __LINE__, board->num_devs); 
     357        printk(KERN_INFO "%s: adding %d devs\n", 
     358                __func__, board->num_devs); 
    359359 
    360360        ifxmips_gpio.resource = &board->reset_resource; 
  • trunk/target/linux/ifxmips/files/arch/mips/ifxmips/clock.c

    r11673 r13660  
    1515 * 
    1616 *   Copyright (C) 2007 Xu Liang, infineon 
    17  *   Copyright (C) 2008 John Crispin <blogic@openwrt.org>  
     17 *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
    1818 */ 
    1919 
     
    2525#include <linux/miscdevice.h> 
    2626#include <linux/init.h> 
    27 #include <asm/uaccess.h> 
    28 #include <asm/unistd.h> 
     27#include <linux/uaccess.h> 
     28#include <linux/unistd.h> 
    2929#include <asm/irq.h> 
    3030#include <asm/div64.h> 
     
    205205void cgu_setup_pci_clk(int external_clock) 
    206206{ 
    207         //set clock to 33Mhz  
     207        //set clock to 33Mhz 
    208208        ifxmips_w32(ifxmips_r32(IFXMIPS_CGU_IFCCR) & ~0xf00000, IFXMIPS_CGU_IFCCR); 
    209209        ifxmips_w32(ifxmips_r32(IFXMIPS_CGU_IFCCR) | 0x800000, IFXMIPS_CGU_IFCCR); 
  • trunk/target/linux/ifxmips/files/arch/mips/ifxmips/dma-core.c

    r11570 r13660  
    1616#include <linux/interrupt.h> 
    1717#include <linux/delay.h> 
    18 #include <asm/uaccess.h> 
     18#include <linux/uaccess.h> 
    1919#include <linux/errno.h> 
    20 #include <asm/io.h> 
     20#include <linux/io.h> 
    2121 
    2222#include <asm/ifxmips/ifxmips.h> 
     
    3333#define DMA_POLL_COUNTER    4   /*fix me, set the correct counter value here! */ 
    3434 
    35 extern void ifxmips_mask_and_ack_irq (unsigned int irq_nr); 
    36 extern void ifxmips_enable_irq (unsigned int irq_nr); 
    37 extern void ifxmips_disable_irq (unsigned int irq_nr); 
     35extern void ifxmips_mask_and_ack_irq(unsigned int irq_nr); 
     36extern void ifxmips_enable_irq(unsigned int irq_nr); 
     37extern void ifxmips_disable_irq(unsigned int irq_nr); 
    3838 
    3939u64 *g_desc_list; 
     
    4141_dma_channel_info dma_chan[MAX_DMA_CHANNEL_NUM]; 
    4242 
    43 char global_device_name[MAX_DMA_DEVICE_NUM][20] = 
    44         { {"PPE"}, {"DEU"}, {"SPI"}, {"SDIO"}, {"MCTRL0"}, {"MCTRL1"} }; 
     43static const char *global_device_name[MAX_DMA_DEVICE_NUM] = 
     44        { "PPE", "DEU", "SPI", "SDIO", "MCTRL0", "MCTRL1" }; 
    4545 
    4646_dma_chan_map default_dma_map[MAX_DMA_CHANNEL_NUM] = { 
     
    6868 
    6969_dma_chan_map *chan_map = default_dma_map; 
    70 volatile u32 g_ifxmips_dma_int_status = 0; 
    71 volatile int g_ifxmips_dma_in_process = 0;/*0=not in process,1=in process*/ 
    72  
    73 void do_dma_tasklet (unsigned long); 
    74 DECLARE_TASKLET (dma_tasklet, do_dma_tasklet, 0); 
    75  
    76 u8* 
    77 common_buffer_alloc (int len, int *byte_offset, void **opt) 
    78 { 
    79         u8 *buffer = (u8 *) kmalloc (len * sizeof (u8), GFP_KERNEL); 
     70volatile u32 g_ifxmips_dma_int_status; 
     71volatile int g_ifxmips_dma_in_process; /* 0=not in process, 1=in process */ 
     72 
     73void do_dma_tasklet(unsigned long); 
     74DECLARE_TASKLET(dma_tasklet, do_dma_tasklet, 0); 
     75 
     76u8 *common_buffer_alloc(int len, int *byte_offset, void **opt) 
     77{ 
     78        u8 *buffer = kmalloc(len * sizeof(u8), GFP_KERNEL); 
    8079 
    8180        *byte_offset = 0; 
     
    8483} 
    8584 
    86 void 
    87 common_buffer_free (u8 *dataptr, void *opt) 
    88 { 
    89         if (dataptr) 
    90                 kfree(dataptr); 
    91 } 
    92  
    93 void 
    94 enable_ch_irq (_dma_channel_info *pCh) 
     85void common_buffer_free(u8 *dataptr, void *opt) 
     86{ 
     87        kfree(dataptr); 
     88} 
     89 
     90void enable_ch_irq(_dma_channel_info *pCh) 
    9591{ 
    9692        int chan_no = (int)(pCh - dma_chan); 
    97         int flag; 
     93        unsigned long flag; 
    9894 
    9995        local_irq_save(flag); 
     
    105101} 
    106102 
    107 void 
    108 disable_ch_irq (_dma_channel_info *pCh) 
    109 { 
    110         int flag; 
     103void disable_ch_irq(_dma_channel_info *pCh) 
     104{ 
     105        unsigned long flag; 
    111106        int chan_no = (int) (pCh - dma_chan); 
    112107 
     
    120115} 
    121116 
    122 void 
    123 open_chan (_dma_channel_info *pCh) 
    124 { 
    125         int flag; 
     117void open_chan(_dma_channel_info *pCh) 
     118{ 
     119        unsigned long flag; 
    126120        int chan_no = (int)(pCh - dma_chan); 
    127121 
     
    129123        ifxmips_w32(chan_no, IFXMIPS_DMA_CS); 
    130124        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CCTRL) | 1, IFXMIPS_DMA_CCTRL); 
    131         if(pCh->dir == IFXMIPS_DMA_RX) 
     125        if (pCh->dir == IFXMIPS_DMA_RX) 
    132126                enable_ch_irq(pCh); 
    133127        local_irq_restore(flag); 
    134128} 
    135129 
    136 void 
    137 close_chan(_dma_channel_info *pCh) 
    138 { 
    139         int flag; 
     130void close_chan(_dma_channel_info *pCh) 
     131{ 
     132        unsigned long flag; 
    140133        int chan_no = (int) (pCh - dma_chan); 
    141134 
     
    147140} 
    148141 
    149 void 
    150 reset_chan (_dma_channel_info *pCh) 
     142void reset_chan(_dma_channel_info *pCh) 
    151143{ 
    152144        int chan_no = (int) (pCh - dma_chan); 
     
    156148} 
    157149 
    158 void 
    159 rx_chan_intr_handler (int chan_no) 
     150void rx_chan_intr_handler(int chan_no) 
    160151{ 
    161152        _dma_device_info *pDev = (_dma_device_info *)dma_chan[chan_no].dma_dev; 
     
    163154        struct rx_desc *rx_desc_p; 
    164155        int tmp; 
    165         int flag; 
     156        unsigned long flag; 
    166157 
    167158        /*handle command complete interrupt */ 
    168         rx_desc_p = (struct rx_desc*)pCh->desc_base + pCh->curr_desc; 
     159        rx_desc_p = (struct rx_desc *)pCh->desc_base + pCh->curr_desc; 
    169160        if (rx_desc_p->status.field.OWN == CPU_OWN 
    170161            && rx_desc_p->status.field.C 
    171162            && rx_desc_p->status.field.data_length < 1536){ 
    172                 /*Every thing is correct, then we inform the upper layer */ 
     163                /* Every thing is correct, then we inform the upper layer */ 
    173164                pDev->current_rx_chan = pCh->rel_chan_no; 
    174                 if(pDev->intr_handler) 
     165                if (pDev->intr_handler) 
    175166                        pDev->intr_handler(pDev, RCV_INT); 
    176167                pCh->weight--; 
     
    187178} 
    188179 
    189 inline void 
    190 tx_chan_intr_handler (int chan_no) 
    191 { 
    192         _dma_device_info *pDev = (_dma_device_info*)dma_chan[chan_no].dma_dev; 
     180inline void tx_chan_intr_handler(int chan_no) 
     181{ 
     182        _dma_device_info *pDev = (_dma_device_info *)dma_chan[chan_no].dma_dev; 
    193183        _dma_channel_info *pCh = &dma_chan[chan_no]; 
    194     int tmp; 
    195     int flag; 
    196  
    197     local_irq_save(flag); 
    198     tmp = ifxmips_r32(IFXMIPS_DMA_CS); 
    199     ifxmips_w32(chan_no, IFXMIPS_DMA_CS); 
    200     ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CIS) | 0x7e, IFXMIPS_DMA_CIS); 
    201     ifxmips_w32(tmp, IFXMIPS_DMA_CS); 
    202     g_ifxmips_dma_int_status &= ~(1 << chan_no); 
    203     local_irq_restore(flag); 
     184        int tmp; 
     185        unsigned long flag; 
     186 
     187        local_irq_save(flag); 
     188        tmp = ifxmips_r32(IFXMIPS_DMA_CS); 
     189        ifxmips_w32(chan_no, IFXMIPS_DMA_CS); 
     190        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CIS) | 0x7e, IFXMIPS_DMA_CIS); 
     191        ifxmips_w32(tmp, IFXMIPS_DMA_CS); 
     192        g_ifxmips_dma_int_status &= ~(1 << chan_no); 
     193        local_irq_restore(flag); 
    204194        pDev->current_tx_chan = pCh->rel_chan_no; 
    205195        if (pDev->intr_handler) 
     
    207197} 
    208198 
    209 void 
    210 do_dma_tasklet (unsigned long unused) 
     199void do_dma_tasklet(unsigned long unused) 
    211200{ 
    212201        int i; 
     
    214203        int budget = DMA_INT_BUDGET; 
    215204        int weight = 0; 
    216     int flag; 
    217  
    218         while (g_ifxmips_dma_int_status) 
    219         { 
    220                 if (budget-- < 0) 
    221                 { 
     205        unsigned long flag; 
     206 
     207        while (g_ifxmips_dma_int_status) { 
     208                if (budget-- < 0) { 
    222209                        tasklet_schedule(&dma_tasklet); 
    223210                        return; 
     
    225212                chan_no = -1; 
    226213                weight = 0; 
    227                 for (i = 0; i < MAX_DMA_CHANNEL_NUM; i++) 
    228                 { 
    229                         if ((g_ifxmips_dma_int_status & (1 << i)) && dma_chan[i].weight > 0) 
    230                         { 
    231                                 if (dma_chan[i].weight > weight) 
    232                                 { 
     214                for (i = 0; i < MAX_DMA_CHANNEL_NUM; i++) { 
     215                        if ((g_ifxmips_dma_int_status & (1 << i)) && dma_chan[i].weight > 0) { 
     216                                if (dma_chan[i].weight > weight) { 
    233217                                        chan_no = i; 
    234                     weight = dma_chan[chan_no].weight; 
    235                 } 
     218                                        weight = dma_chan[chan_no].weight; 
     219                                } 
    236220                        } 
    237221                } 
    238222 
    239                 if (chan_no >= 0) 
    240                 { 
     223                if (chan_no >= 0) { 
    241224                        if (chan_map[chan_no].dir == IFXMIPS_DMA_RX) 
    242225                                rx_chan_intr_handler(chan_no); 
     
    245228                } else { 
    246229                        for (i = 0; i < MAX_DMA_CHANNEL_NUM; i++) 
    247                         { 
    248230                                dma_chan[i].weight = dma_chan[i].default_weight; 
    249                         } 
    250                 } 
    251         } 
    252  
    253     local_irq_save(flag); 
     231                } 
     232        } 
     233 
     234        local_irq_save(flag); 
    254235        g_ifxmips_dma_in_process = 0; 
    255     if (g_ifxmips_dma_int_status) 
    256         { 
    257         g_ifxmips_dma_in_process = 1; 
    258         tasklet_schedule(&dma_tasklet); 
    259     } 
    260     local_irq_restore(flag); 
    261 } 
    262  
    263 irqreturn_t 
    264 dma_interrupt (int irq, void *dev_id) 
     236        if (g_ifxmips_dma_int_status) { 
     237                g_ifxmips_dma_in_process = 1; 
     238                tasklet_schedule(&dma_tasklet); 
     239        } 
     240        local_irq_restore(flag); 
     241} 
     242 
     243irqreturn_t dma_interrupt(int irq, void *dev_id) 
    265244{ 
    266245        _dma_channel_info *pCh; 
     
    268247        int tmp; 
    269248 
    270         pCh = (_dma_channel_info*)dev_id; 
     249        pCh = (_dma_channel_info *)dev_id; 
    271250        chan_no = (int)(pCh - dma_chan); 
    272251        if (chan_no < 0 || chan_no > 19) 
     
    279258        ifxmips_mask_and_ack_irq(irq); 
    280259 
    281     if (!g_ifxmips_dma_in_process) 
    282         { 
    283         g_ifxmips_dma_in_process = 1; 
    284         tasklet_schedule(&dma_tasklet); 
    285     } 
     260        if (!g_ifxmips_dma_in_process) { 
     261                g_ifxmips_dma_in_process = 1; 
     262                tasklet_schedule(&dma_tasklet); 
     263        } 
    286264 
    287265        return IRQ_HANDLED; 
    288266} 
    289267 
    290 _dma_device_info* 
    291 dma_device_reserve (char *dev_name) 
     268_dma_device_info *dma_device_reserve(char *dev_name) 
    292269{ 
    293270        int i; 
    294271 
    295         for (i = 0; i < MAX_DMA_DEVICE_NUM; i++) 
    296         { 
    297                 if (strcmp(dev_name, dma_devs[i].device_name) == 0) 
    298                 { 
     272        for (i = 0; i < MAX_DMA_DEVICE_NUM; i++) { 
     273                if (strcmp(dev_name, dma_devs[i].device_name) == 0) { 
    299274                        if (dma_devs[i].reserved) 
    300275                                return NULL; 
     
    306281        return &dma_devs[i]; 
    307282} 
    308  
    309 void 
    310 dma_device_release (_dma_device_info *dev) 
     283EXPORT_SYMBOL(dma_device_reserve); 
     284 
     285void dma_device_release(_dma_device_info *dev) 
    311286{ 
    312287        dev->reserved = 0; 
    313288} 
    314  
    315 void 
    316 dma_device_register(_dma_device_info *dev) 
     289EXPORT_SYMBOL(dma_device_release); 
     290 
     291void dma_device_register(_dma_device_info *dev) 
    317292{ 
    318293        int i, j; 
     
    320295        u8 *buffer; 
    321296        int byte_offset; 
    322         int flag; 
     297        unsigned long flag; 
    323298        _dma_device_info *pDev; 
    324299        _dma_channel_info *pCh; 
     
    326301        struct tx_desc *tx_desc_p; 
    327302 
    328         for (i = 0; i < dev->max_tx_chan_num; i++) 
    329         { 
     303        for (i = 0; i < dev->max_tx_chan_num; i++) { 
    330304                pCh = dev->tx_chan[i]; 
    331                 if (pCh->control == IFXMIPS_DMA_CH_ON) 
    332                 { 
     305                if (pCh->control == IFXMIPS_DMA_CH_ON) { 
    333306                        chan_no = (int)(pCh - dma_chan); 
    334                         for (j = 0; j < pCh->desc_len; j++) 
    335                         { 
    336                                 tx_desc_p = (struct tx_desc*)pCh->desc_base + j; 
     307                        for (j = 0; j < pCh->desc_len; j++) { 
     308                                tx_desc_p = (struct tx_desc *)pCh->desc_base + j; 
    337309                                memset(tx_desc_p, 0, sizeof(struct tx_desc)); 
    338310                        } 
    339311                        local_irq_save(flag); 
    340312                        ifxmips_w32(chan_no, IFXMIPS_DMA_CS); 
    341                         /*check if the descriptor length is changed */ 
     313                        /* check if the descriptor length is changed */ 
    342314                        if (ifxmips_r32(IFXMIPS_DMA_CDLEN) != pCh->desc_len) 
    343315                                ifxmips_w32(pCh->desc_len, IFXMIPS_DMA_CDLEN); 
     
    345317                        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CCTRL) & ~1, IFXMIPS_DMA_CCTRL); 
    346318                        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CCTRL) | 2, IFXMIPS_DMA_CCTRL); 
    347                         while (ifxmips_r32(IFXMIPS_DMA_CCTRL) & 2){}; 
     319                        while (ifxmips_r32(IFXMIPS_DMA_CCTRL) & 2) 
     320                                ; 
    348321                        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_IRNEN) | (1 << chan_no), IFXMIPS_DMA_IRNEN); 
    349                         ifxmips_w32(0x30100, IFXMIPS_DMA_CCTRL);        /*reset and enable channel,enable channel later */ 
     322                        ifxmips_w32(0x30100, IFXMIPS_DMA_CCTRL); /* reset and enable channel,enable channel later */ 
    350323                        local_irq_restore(flag); 
    351324                } 
    352325        } 
    353326 
    354         for (i = 0; i < dev->max_rx_chan_num; i++) 
    355         { 
     327        for (i = 0; i < dev->max_rx_chan_num; i++) { 
    356328                pCh = dev->rx_chan[i]; 
    357                 if (pCh->control == IFXMIPS_DMA_CH_ON) 
    358                 { 
     329                if (pCh->control == IFXMIPS_DMA_CH_ON) { 
    359330                        chan_no = (int)(pCh - dma_chan); 
    360331 
    361                         for (j = 0; j < pCh->desc_len; j++) 
    362                         { 
    363                                 rx_desc_p = (struct rx_desc*)pCh->desc_base + j; 
    364                                 pDev = (_dma_device_info*)(pCh->dma_dev); 
    365                                 buffer = pDev->buffer_alloc(pCh->packet_size, &byte_offset, (void*)&(pCh->opt[j])); 
     332                        for (j = 0; j < pCh->desc_len; j++) { 
     333                                rx_desc_p = (struct rx_desc *)pCh->desc_base + j; 
     334                                pDev = (_dma_device_info *)(pCh->dma_dev); 
     335                                buffer = pDev->buffer_alloc(pCh->packet_size, &byte_offset, (void *)&(pCh->opt[j])); 
    366336                                if (!buffer) 
    367337                                        break; 
     
    378348                        local_irq_save(flag); 
    379349                        ifxmips_w32(chan_no, IFXMIPS_DMA_CS); 
    380                         /*check if the descriptor length is changed */ 
     350                        /* check if the descriptor length is changed */ 
    381351                        if (ifxmips_r32(IFXMIPS_DMA_CDLEN) != pCh->desc_len) 
    382352                                ifxmips_w32(pCh->desc_len, IFXMIPS_DMA_CDLEN); 
    383353                        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CCTRL) & ~1, IFXMIPS_DMA_CCTRL); 
    384354                        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CCTRL) | 2, IFXMIPS_DMA_CCTRL); 
    385                         while (ifxmips_r32(IFXMIPS_DMA_CCTRL) & 2){}; 
    386                         ifxmips_w32(0x0a, IFXMIPS_DMA_CIE);     /*fix me, should enable all the interrupts here? */ 
     355                        while (ifxmips_r32(IFXMIPS_DMA_CCTRL) & 2) 
     356                                ; 
     357                        ifxmips_w32(0x0a, IFXMIPS_DMA_CIE); /* fix me, should enable all the interrupts here? */ 
    387358                        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_IRNEN) | (1 << chan_no), IFXMIPS_DMA_IRNEN); 
    388359                        ifxmips_w32(0x30000, IFXMIPS_DMA_CCTRL); 
     
    392363        } 
    393364} 
    394  
    395 void 
    396 dma_device_unregister (_dma_device_info *dev) 
     365EXPORT_SYMBOL(dma_device_register); 
     366 
     367void dma_device_unregister(_dma_device_info *dev) 
    397368{ 
    398369        int i, j; 
     
    401372        struct rx_desc *rx_desc_p; 
    402373        struct tx_desc *tx_desc_p; 
    403         int flag; 
    404  
    405         for (i = 0; i < dev->max_tx_chan_num; i++) 
    406         { 
     374        unsigned long flag; 
     375 
     376        for (i = 0; i < dev->max_tx_chan_num; i++) { 
    407377                pCh = dev->tx_chan[i]; 
    408                 if (pCh->control == IFXMIPS_DMA_CH_ON) 
    409                 { 
     378                if (pCh->control == IFXMIPS_DMA_CH_ON) { 
    410379                        chan_no = (int)(dev->tx_chan[i] - dma_chan); 
    411                         local_irq_save (flag); 
     380                        local_irq_save(flag); 
    412381                        ifxmips_w32(chan_no, IFXMIPS_DMA_CS); 
    413382                        pCh->curr_desc = 0; 
    414383                        pCh->prev_desc = 0; 
    415384                        pCh->control = IFXMIPS_DMA_CH_OFF; 
    416                         ifxmips_w32(0, IFXMIPS_DMA_CIE);        /*fix me, should disable all the interrupts here? */ 
    417                         ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_IRNEN) & ~(1 << chan_no), IFXMIPS_DMA_IRNEN);       /*disable interrupts */ 
     385                        ifxmips_w32(0, IFXMIPS_DMA_CIE); /* fix me, should disable all the interrupts here? */ 
     386                        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_IRNEN) & ~(1 << chan_no), IFXMIPS_DMA_IRNEN); /* disable interrupts */ 
    418387                        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CCTRL) & ~1, IFXMIPS_DMA_CCTRL); 
    419                         while (ifxmips_r32(IFXMIPS_DMA_CCTRL) & 1) {}; 
    420                         local_irq_restore (flag); 
    421  
    422                         for (j = 0; j < pCh->desc_len; j++) 
    423                         { 
    424                                 tx_desc_p = (struct tx_desc*)pCh->desc_base + j; 
     388                        while (ifxmips_r32(IFXMIPS_DMA_CCTRL) & 1) 
     389                                ; 
     390                        local_irq_restore(flag); 
     391 
     392                        for (j = 0; j < pCh->desc_len; j++) { 
     393                                tx_desc_p = (struct tx_desc *)pCh->desc_base + j; 
    425394                                if ((tx_desc_p->status.field.OWN == CPU_OWN && tx_desc_p->status.field.C) 
    426                                                 || (tx_desc_p->status.field.OWN == DMA_OWN && tx_desc_p->status.field.data_length > 0)) 
    427                                 { 
    428                                         dev->buffer_free ((u8 *) __va (tx_desc_p->Data_Pointer), (void*)pCh->opt[j]); 
     395                                                || (tx_desc_p->status.field.OWN == DMA_OWN && tx_desc_p->status.field.data_length > 0)) { 
     396                                        dev->buffer_free((u8 *) __va(tx_desc_p->Data_Pointer), (void *)pCh->opt[j]); 
    429397                                } 
    430398                                tx_desc_p->status.field.OWN = CPU_OWN; 
    431                                 memset (tx_desc_p, 0, sizeof (struct tx_desc)); 
     399                                memset(tx_desc_p, 0, sizeof(struct tx_desc)); 
    432400                        } 
    433                         //TODO should free buffer that is not transferred by dma 
    434                 } 
    435         } 
    436  
    437         for (i = 0; i < dev->max_rx_chan_num; i++) 
    438         { 
     401                        /* TODO should free buffer that is not transferred by dma */ 
     402                } 
     403        } 
     404 
     405        for (i = 0; i < dev->max_rx_chan_num; i++) { 
    439406                pCh = dev->rx_chan[i]; 
    440407                chan_no = (int)(dev->rx_chan[i] - dma_chan); 
     
    448415 
    449416                ifxmips_w32(chan_no, IFXMIPS_DMA_CS); 
    450                 ifxmips_w32(0, IFXMIPS_DMA_CIE); /*fix me, should disable all the interrupts here? */ 
    451                 ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_IRNEN) & ~(1 << chan_no), IFXMIPS_DMA_IRNEN);       /*disable interrupts */ 
     417                ifxmips_w32(0, IFXMIPS_DMA_CIE); /* fix me, should disable all the interrupts here? */ 
     418                ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_IRNEN) & ~(1 << chan_no), IFXMIPS_DMA_IRNEN); /* disable interrupts */ 
    452419                ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CCTRL) & ~1, IFXMIPS_DMA_CCTRL); 
    453                 while (ifxmips_r32(IFXMIPS_DMA_CCTRL) & 1) {}; 
    454  
    455                 local_irq_restore (flag); 
    456                 for (j = 0; j < pCh->desc_len; j++) 
    457                 { 
     420                while (ifxmips_r32(IFXMIPS_DMA_CCTRL) & 1) 
     421                        ; 
     422 
     423                local_irq_restore(flag); 
     424                for (j = 0; j < pCh->desc_len; j++) { 
    458425                        rx_desc_p = (struct rx_desc *) pCh->desc_base + j; 
    459                         if ((rx_desc_p->status.field.OWN == CPU_OWN  
     426                        if ((rx_desc_p->status.field.OWN == CPU_OWN 
    460427                             && rx_desc_p->status.field.C) 
    461428                            || (rx_desc_p->status.field.OWN == DMA_OWN 
    462429                                && rx_desc_p->status.field.data_length > 0)) { 
    463                                 dev->buffer_free ((u8 *) 
    464                                                   __va (rx_desc_p-> 
    465                                                         Data_Pointer), 
    466                                                   (void *) pCh->opt[j]); 
     430                                dev->buffer_free((u8 *) 
     431                                                 __va(rx_desc_p->Data_Pointer), 
     432                                                 (void *) pCh->opt[j]); 
    467433                        } 
    468434                } 
    469435        } 
    470436} 
    471  
    472 int 
    473 dma_device_read (struct dma_device_info *dma_dev, u8 ** dataptr, void **opt) 
     437EXPORT_SYMBOL(dma_device_unregister); 
     438 
     439int dma_device_read(struct dma_device_info *dma_dev, u8 **dataptr, void **opt) 
    474440{ 
    475441        u8 *buf; 
     
    480446        struct rx_desc *rx_desc_p; 
    481447 
    482         /*get the rx data first */ 
     448        /* get the rx data first */ 
    483449        rx_desc_p = (struct rx_desc *) pCh->desc_base + pCh->curr_desc; 
    484450        if (!(rx_desc_p->status.field.OWN == CPU_OWN && rx_desc_p->status.field.C)) 
    485         { 
    486451                return 0; 
    487         } 
    488  
    489         buf = (u8 *) __va (rx_desc_p->Data_Pointer); 
    490         *(u32*)dataptr = (u32)buf; 
     452 
     453        buf = (u8 *) __va(rx_desc_p->Data_Pointer); 
     454        *(u32 *)dataptr = (u32)buf; 
    491455        len = rx_desc_p->status.field.data_length; 
    492456 
    493457        if (opt) 
    494         { 
    495                 *(int*)opt = (int)pCh->opt[pCh->curr_desc]; 
    496         } 
    497  
    498         /*replace with a new allocated buffer */ 
     458                *(int *)opt = (int)pCh->opt[pCh->curr_desc]; 
     459 
     460        /* replace with a new allocated buffer */ 
    499461        buf = dma_dev->buffer_alloc(pCh->packet_size, &byte_offset, &p); 
    500462 
    501         if (buf) 
    502         { 
    503                 dma_cache_inv ((unsigned long) buf, 
    504                 pCh->packet_size); 
     463        if (buf) { 
     464                dma_cache_inv((unsigned long) buf, pCh->packet_size); 
    505465                pCh->opt[pCh->curr_desc] = p; 
    506                 wmb (); 
    507  
    508                 rx_desc_p->Data_Pointer = (u32) CPHYSADDR ((u32) buf); 
     466                wmb(); 
     467 
     468                rx_desc_p->Data_Pointer = (u32) CPHYSADDR((u32) buf); 
    509469                rx_desc_p->status.word = (DMA_OWN << 31) | ((byte_offset) << 23) | pCh->packet_size; 
    510                 wmb (); 
     470                wmb(); 
    511471        } else { 
    512472                *(u32 *) dataptr = 0; 
     
    516476        } 
    517477 
    518         /*increase the curr_desc pointer */ 
     478        /* increase the curr_desc pointer */ 
    519479        pCh->curr_desc++; 
    520480        if (pCh->curr_desc == pCh->desc_len) 
     
    523483        return len; 
    524484} 
    525  
    526 int 
    527 dma_device_write (struct dma_device_info *dma_dev, u8 * dataptr, int len, void *opt) 
    528 { 
    529         int flag; 
     485EXPORT_SYMBOL(dma_device_read); 
     486 
     487int dma_device_write(struct dma_device_info *dma_dev, u8 *dataptr, int len, void *opt) 
     488{ 
     489        unsigned long flag; 
    530490        u32 tmp, byte_offset; 
    531491        _dma_channel_info *pCh; 
    532492        int chan_no; 
    533493        struct tx_desc *tx_desc_p; 
    534         local_irq_save (flag); 
     494        local_irq_save(flag); 
    535495 
    536496        pCh = dma_dev->tx_chan[dma_dev->current_tx_chan]; 
    537497        chan_no = (int)(pCh - (_dma_channel_info *) dma_chan); 
    538498 
    539         tx_desc_p = (struct tx_desc*)pCh->desc_base + pCh->prev_desc; 
    540         while (tx_desc_p->status.field.OWN == CPU_OWN && tx_desc_p->status.field.C) 
    541         { 
    542                 dma_dev->buffer_free((u8 *) __va (tx_desc_p->Data_Pointer), pCh->opt[pCh->prev_desc]); 
    543                 memset(tx_desc_p, 0, sizeof (struct tx_desc)); 
     499        tx_desc_p = (struct tx_desc *)pCh->desc_base + pCh->prev_desc; 
     500        while (tx_desc_p->status.field.OWN == CPU_OWN && tx_desc_p->status.field.C) { 
     501                dma_dev->buffer_free((u8 *) __va(tx_desc_p->Data_Pointer), pCh->opt[pCh->prev_desc]); 
     502                memset(tx_desc_p, 0, sizeof(struct tx_desc)); 
    544503                pCh->prev_desc = (pCh->prev_desc + 1) % (pCh->desc_len); 
    545                 tx_desc_p = (struct tx_desc*)pCh->desc_base + pCh->prev_desc; 
    546         } 
    547         tx_desc_p = (struct tx_desc*)pCh->desc_base + pCh->curr_desc; 
    548         /*Check whether this descriptor is available */ 
    549         if (tx_desc_p->status.field.OWN == DMA_OWN || tx_desc_p->status.field.C) 
    550         { 
    551                 /*if not , the tell the upper layer device */ 
     504                tx_desc_p = (struct tx_desc *)pCh->desc_base + pCh->prev_desc; 
     505        } 
     506        tx_desc_p = (struct tx_desc *)pCh->desc_base + pCh->curr_desc; 
     507        /* Check whether this descriptor is available */ 
     508        if (tx_desc_p->status.field.OWN == DMA_OWN || tx_desc_p->status.field.C) { 
     509                /* if not, the tell the upper layer device */ 
    552510                dma_dev->intr_handler (dma_dev, TX_BUF_FULL_INT); 
    553511                local_irq_restore(flag); 
    554                 printk (KERN_INFO "%s %d: failed to write!\n", __func__, __LINE__); 
     512                printk(KERN_INFO "%s %d: failed to write!\n", __func__, __LINE__); 
    555513 
    556514                return 0; 
    557515        } 
    558516        pCh->opt[pCh->curr_desc] = opt; 
    559         /*byte offset----to adjust the starting address of the data buffer, should be multiple of the burst length. */ 
    560         byte_offset = ((u32) CPHYSADDR ((u32) dataptr)) % ((dma_dev->tx_burst_len) * 4); 
    561         dma_cache_wback ((unsigned long) dataptr, len); 
    562         wmb (); 
    563         tx_desc_p->Data_Pointer = (u32) CPHYSADDR ((u32) dataptr) - byte_offset; 
    564         wmb (); 
     517        /* byte offset----to adjust the starting address of the data buffer, should be multiple of the burst length. */ 
     518        byte_offset = ((u32) CPHYSADDR((u32) dataptr)) % ((dma_dev->tx_burst_len) * 4); 
     519        dma_cache_wback((unsigned long) dataptr, len); 
     520        wmb(); 
     521        tx_desc_p->Data_Pointer = (u32) CPHYSADDR((u32) dataptr) - byte_offset; 
     522        wmb(); 
    565523        tx_desc_p->status.word = (DMA_OWN << 31) | DMA_DESC_SOP_SET | DMA_DESC_EOP_SET | ((byte_offset) << 23) | len; 
    566         wmb (); 
     524        wmb(); 
    567525 
    568526        pCh->curr_desc++; 
     
    572530        /*Check whether this descriptor is available */ 
    573531        tx_desc_p = (struct tx_desc *) pCh->desc_base + pCh->curr_desc; 
    574         if (tx_desc_p->status.field.OWN == DMA_OWN) 
    575         { 
     532        if (tx_desc_p->status.field.OWN == DMA_OWN) { 
    576533                /*if not , the tell the upper layer device */ 
    577534                dma_dev->intr_handler (dma_dev, TX_BUF_FULL_INT); 
     
    582539 
    583540        if (!(tmp & 1)) 
    584                 pCh->open (pCh); 
    585  
    586         local_irq_restore (flag); 
     541                pCh->open(pCh); 
     542 
     543        local_irq_restore(flag); 
    587544 
    588545        return len; 
    589546} 
    590  
    591 int 
    592 map_dma_chan(_dma_chan_map *map) 
     547EXPORT_SYMBOL(dma_device_write); 
     548 
     549int map_dma_chan(_dma_chan_map *map) 
    593550{ 
    594551        int i, j; 
     
    596553 
    597554        for (i = 0; i < MAX_DMA_DEVICE_NUM; i++) 
    598         { 
    599555                strcpy(dma_devs[i].device_name, global_device_name[i]); 
    600         } 
    601  
    602         for (i = 0; i < MAX_DMA_CHANNEL_NUM; i++) 
    603         { 
     556 
     557        for (i = 0; i < MAX_DMA_CHANNEL_NUM; i++) { 
    604558                dma_chan[i].irq = map[i].irq; 
    605                 result = request_irq(dma_chan[i].irq, dma_interrupt, IRQF_DISABLED, "dma-core", (void*)&dma_chan[i]); 
    606                 if (result) 
    607                 { 
    608                         printk("error, cannot get dma_irq!\n"); 
     559                result = request_irq(dma_chan[i].irq, dma_interrupt, IRQF_DISABLED, map[i].dev_name, (void *)&dma_chan[i]); 
     560                if (result) { 
     561                        printk(KERN_WARNING "error, cannot get dma_irq!\n"); 
    609562                        free_irq(dma_chan[i].irq, (void *) &dma_interrupt); 
    610563 
     
    613566        } 
    614567 
    615         for (i = 0; i < MAX_DMA_DEVICE_NUM; i++) 
    616         { 
     568        for (i = 0; i < MAX_DMA_DEVICE_NUM; i++) { 
    617569                dma_devs[i].num_tx_chan = 0;    /*set default tx channel number to be one */ 
    618570                dma_devs[i].num_rx_chan = 0;    /*set default rx channel number to be one */ 
     
    624576                dma_devs[i].tx_burst_len = 4; 
    625577                dma_devs[i].rx_burst_len = 4; 
    626                 if (i == 0) 
    627                 { 
     578                if (i == 0) { 
    628579                        ifxmips_w32(0, IFXMIPS_DMA_PS); 
    629580                        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_PCTRL) | ((0xf << 8) | (1 << 6)), IFXMIPS_DMA_PCTRL);       /*enable dma drop */ 
    630581                } 
    631582 
    632                 if (i == 1) 
    633                 { 
     583                if (i == 1) { 
    634584                        ifxmips_w32(1, IFXMIPS_DMA_PS); 
    635585                        ifxmips_w32(0x14, IFXMIPS_DMA_PCTRL);   /*deu port setting */ 
    636586                } 
    637587 
    638                 for (j = 0; j < MAX_DMA_CHANNEL_NUM; j++) 
    639                 { 
     588                for (j = 0; j < MAX_DMA_CHANNEL_NUM; j++) { 
    640589                        dma_chan[j].byte_offset = 0; 
    641590                        dma_chan[j].open = &open_chan; 
     
    652601                } 
    653602 
    654                 for (j = 0; j < MAX_DMA_CHANNEL_NUM; j++) 
    655                 { 
    656                         if (strcmp(dma_devs[i].device_name, map[j].dev_name) == 0) 
    657                         { 
    658                                 if (map[j].dir == IFXMIPS_DMA_RX) 
    659                                 { 
     603                for (j = 0; j < MAX_DMA_CHANNEL_NUM; j++) { 
     604                        if (strcmp(dma_devs[i].device_name, map[j].dev_name) == 0) { 
     605                                if (map[j].dir == IFXMIPS_DMA_RX) { 
    660606                                        dma_chan[j].dir = IFXMIPS_DMA_RX; 
    661607                                        dma_devs[i].max_rx_chan_num++; 
    662608                                        dma_devs[i].rx_chan[dma_devs[i].max_rx_chan_num - 1] = &dma_chan[j]; 
    663609                                        dma_devs[i].rx_chan[dma_devs[i].max_rx_chan_num - 1]->pri = map[j].pri; 
    664                                         dma_chan[j].dma_dev = (void*)&dma_devs[i]; 
    665                                 } else if(map[j].dir == IFXMIPS_DMA_TX) 
    666                                 { /*TX direction */ 
     610                                        dma_chan[j].dma_dev = (void *)&dma_devs[i]; 
     611                                } else if (map[j].dir == IFXMIPS_DMA_TX) { 
     612                                        /*TX direction */ 
    667613                                        dma_chan[j].dir = IFXMIPS_DMA_TX; 
    668614                                        dma_devs[i].max_tx_chan_num++; 
    669615                                        dma_devs[i].tx_chan[dma_devs[i].max_tx_chan_num - 1] = &dma_chan[j]; 
    670616                                        dma_devs[i].tx_chan[dma_devs[i].max_tx_chan_num - 1]->pri = map[j].pri; 
    671                                         dma_chan[j].dma_dev = (void*)&dma_devs[i]; 
     617                                        dma_chan[j].dma_dev = (void *)&dma_devs[i]; 
    672618                                } else { 
    673                                         printk ("WRONG DMA MAP!\n"); 
     619                                        printk(KERN_WARNING "WRONG DMA MAP!\n"); 
    674620                                } 
    675621                        } 
     
    680626} 
    681627 
    682 void 
    683 dma_chip_init(void) 
     628void dma_chip_init(void) 
    684629{ 
    685630        int i; 
    686631 
    687         // enable DMA from PMU 
     632        /* enable DMA from PMU */ 
    688633        ifxmips_pmu_enable(IFXMIPS_PMU_PWDCR_DMA); 
    689634 
    690         // reset DMA 
     635        /* reset DMA */ 
    691636        ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CTRL) | 1, IFXMIPS_DMA_CTRL); 
    692637 
    693         // diable all interrupts 
     638        /* disable all interrupts */ 
    694639        ifxmips_w32(0, IFXMIPS_DMA_IRNEN); 
    695640 
    696         for (i = 0; i < MAX_DMA_CHANNEL_NUM; i++) 
    697         { 
     641        for (i = 0; i < MAX_DMA_CHANNEL_NUM; i++) { 
    698642                ifxmips_w32(i, IFXMIPS_DMA_CS); 
    699643                ifxmips_w32(0x2, IFXMIPS_DMA_CCTRL); 
    700644                ifxmips_w32(0x80000040, IFXMIPS_DMA_CPOLL); 
    701645                ifxmips_w32(ifxmips_r32(IFXMIPS_DMA_CCTRL) & ~0x1, IFXMIPS_DMA_CCTRL); 
    702  
    703         } 
    704 } 
    705  
    706 int 
    707 ifxmips_dma_init (void) 
     646        } 
     647} 
     648 
     649int ifxmips_dma_init(void) 
    708650{ 
    709651        int i; 
     
    713655                BUG(); 
    714656 
    715         g_desc_list = (u64*)KSEG1ADDR(__get_free_page(GFP_DMA)); 
    716  
    717         if (g_desc_list == NULL) 
    718         { 
    719                 printk("no memory for desriptor\n"); 
     657        g_desc_list = (u64 *)KSEG1ADDR(__get_free_page(GFP_DMA)); 
     658 
     659        if (g_desc_list == NULL) { 
     660                printk(KERN_WARNING "no memory for desriptor\n"); 
    720661                return -ENOMEM; 
    721662        } 
     
    723664        memset(g_desc_list, 0, PAGE_SIZE); 
    724665 
    725         for (i = 0; i < MAX_DMA_CHANNEL_NUM; i++) 
    726         { 
     666        for (i = 0; i < MAX_DMA_CHANNEL_NUM; i++) { 
    727667                dma_chan[i].desc_base = (u32)g_desc_list + i * IFXMIPS_DMA_DESCRIPTOR_OFFSET * 8; 
    728668                dma_chan[i].curr_desc = 0; 
     
    739679arch_initcall(ifxmips_dma_init); 
    740680 
    741 void 
    742 dma_cleanup(void) 
     681void dma_cleanup(void) 
    743682{ 
    744683        int i; 
     
    746685        free_page(KSEG0ADDR((unsigned long) g_desc_list)); 
    747686        for (i = 0; i < MAX_DMA_CHANNEL_NUM; i++) 
    748                 free_irq(dma_chan[i].irq, (void*)&dma_interrupt); 
    749 } 
    750  
    751 EXPORT_SYMBOL (dma_device_reserve); 
    752 EXPORT_SYMBOL (dma_device_release); 
    753 EXPORT_SYMBOL (dma_device_register); 
    754 EXPORT_SYMBOL (dma_device_unregister); 
    755 EXPORT_SYMBOL (dma_device_read); 
    756 EXPORT_SYMBOL (dma_device_write); 
    757  
    758 MODULE_LICENSE ("GPL"); 
     687                free_irq(dma_chan[i].irq, (void  *)&dma_interrupt); 
     688} 
     689 
     690MODULE_LICENSE("GPL"); 
  • trunk/target/linux/ifxmips/files/arch/mips/ifxmips/gpio.c

    r11673 r13660  
    1717 *   Copyright (C) 2005 Jin-Sze.Sow Comments edited 
    1818 *   Copyright (C) 2006 Huang Xiaogang Modification & verification on Danube chip 
    19  *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>  
     19 *   Copyright (C) 2007 John Crispin <blogic@openwrt.org> 
    2020 */ 
    2121 
     
    3636#include <linux/platform_device.h> 
    3737#include <net/sock.h> 
    38 #include <asm/uaccess.h> 
    39 #include <asm/semaphore.h> 
    40 #include <asm/uaccess.h> 
     38#include <linux/uaccess.h> 
     39#include <linux/semaphore.h> 
    4140#include <asm/ifxmips/ifxmips.h> 
    4241 
  • trunk/target/linux/ifxmips/files/arch/mips/ifxmips/interrupt.c

    r11607 r13660  
    1515 * 
    1616 *   Copyright (C) 2005 Wu Qi Ming infineon 
    17  *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>  
     17 *   Copyright (C) 2007 John Crispin <blogic@openwrt.org> 
    1818 */ 
    1919 
     
    3131#include <asm/irq_cpu.h> 
    3232 
    33 void 
    34 ifxmips_disable_irq(unsigned int irq_nr) 
     33void ifxmips_disable_irq(unsigned int irq_nr) 
    3534{ 
    3635        int i; 
     
    3837 
    3938        irq_nr -= INT_NUM_IRQ0; 
    40         for(i = 0; i <= 4; i++) 
    41         { 
    42                 if(irq_nr < INT_NUM_IM_OFFSET){ 
    43                         ifxmips_w32(ifxmips_r32(ifxmips_ier) & ~(1 << irq_nr ), ifxmips_ier); 
     39        for (i = 0; i <= 4; i++) { 
     40                if (irq_nr < INT_NUM_IM_OFFSET) { 
     41                        ifxmips_w32(ifxmips_r32(ifxmips_ier) & ~(1 << irq_nr), 
     42                                ifxmips_ier); 
    4443                        return; 
    4544                } 
     
    5049EXPORT_SYMBOL(ifxmips_disable_irq); 
    5150 
    52 void 
    53 ifxmips_mask_and_ack_irq(unsigned int irq_nr) 
     51void ifxmips_mask_and_ack_irq(unsigned int irq_nr) 
    5452{ 
    5553        int i; 
     
    5856 
    5957        irq_nr -= INT_NUM_IRQ0; 
    60         for(i = 0; i <= 4; i++) 
    61         { 
    62                 if(irq_nr < INT_NUM_IM_OFFSET) 
    63                 { 
    64                         ifxmips_w32(ifxmips_r32(ifxmips_ier) & ~(1 << irq_nr ), ifxmips_ier); 
    65                         ifxmips_w32((1 << irq_nr ), ifxmips_isr); 
     58        for (i = 0; i <= 4; i++) { 
     59                if (irq_nr < INT_NUM_IM_OFFSET) { 
     60                        ifxmips_w32(ifxmips_r32(ifxmips_ier) & ~(1 << irq_nr), 
     61                                ifxmips_ier); 
     62                        ifxmips_w32((1 << irq_nr), ifxmips_isr); 
    6663                        return; 
    6764                } 
     
    7370EXPORT_SYMBOL(ifxmips_mask_and_ack_irq); 
    7471 
    75 void 
    76 ifxmips_enable_irq(unsigned int irq_nr) 
     72void ifxmips_enable_irq(unsigned int irq_nr) 
    7773{ 
    7874        int i; 
     
    8076 
    8177        irq_nr -= INT_NUM_IRQ0; 
    82         for(i = 0; i <= 4; i++) 
    83         { 
    84                 if(irq_nr < INT_NUM_IM_OFFSET) 
    85                 { 
    86                         ifxmips_w32(ifxmips_r32(ifxmips_ier) | (1 << irq_nr ), ifxmips_ier); 
     78        for (i = 0; i <= 4; i++) { 
     79                if (irq_nr < INT_NUM_IM_OFFSET) { 
     80                        ifxmips_w32(ifxmips_r32(ifxmips_ier) | (1 << irq_nr), 
     81                                ifxmips_ier); 
    8782                        return; 
    8883                } 
     
    9388EXPORT_SYMBOL(ifxmips_enable_irq); 
    9489 
    95 static unsigned int 
    96 ifxmips_startup_irq(unsigned int irq) 
     90static unsigned int ifxmips_startup_irq(unsigned int irq) 
    9791{ 
    9892        ifxmips_enable_irq(irq); 
     
    10094} 
    10195 
    102 static void 
    103 ifxmips_end_irq(unsigned int irq) 
    104 { 
    105         if(!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS))) 
    106                 ifxmips_enable_irq (irq); 
    107 } 
    108  
    109 static struct hw_interrupt_type 
    110 ifxmips_irq_type = { 
     96static void ifxmips_end_irq(unsigned int irq) 
     97{ 
     98        if (!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS))) 
     99                ifxmips_enable_irq(irq); 
     100} 
     101 
     102static struct hw_interrupt_type ifxmips_irq_type = { 
    111103        "IFXMIPS", 
    112104        .startup = ifxmips_startup_irq, 
     
    120112}; 
    121113 
    122 static inline int 
    123 ls1bit32(unsigned long x) 
     114static inline int ls1bit32(unsigned long x) 
    124115{ 
    125116        __asm__ ( 
     
    133124} 
    134125 
    135 void 
    136 ifxmips_hw_irqdispatch(int module) 
     126void ifxmips_hw_irqdispatch(int module) 
    137127{ 
    138128        u32 irq; 
    139129 
    140130        irq = ifxmips_r32(IFXMIPS_ICU_IM0_IOSR + (module * IFXMIPS_ICU_OFFSET)); 
    141         if(irq == 0) 
     131        if (irq == 0) 
    142132                return; 
    143133 
     
    146136        do_IRQ((int)irq + INT_NUM_IM0_IRL0 + (INT_NUM_IM_OFFSET * module)); 
    147137 
    148         if((irq == 22) && (module == 0)){ 
    149                 ifxmips_w32(ifxmips_r32(IFXMIPS_EBU_PCC_ISTAT) | 0x10, IFXMIPS_EBU_PCC_ISTAT); 
    150         } 
    151 } 
    152  
    153 asmlinkage void 
    154 plat_irq_dispatch(void) 
     138        if ((irq == 22) && (module == 0)) 
     139                ifxmips_w32(ifxmips_r32(IFXMIPS_EBU_PCC_ISTAT) | 0x10, 
     140                        IFXMIPS_EBU_PCC_ISTAT); 
     141} 
     142 
     143#ifdef CONFIG_CPU_MIPSR2_IRQ_VI 
     144#define DEFINE_HWx_IRQDISPATCH(x) \ 
     145static void ifxmips_hw ## x ## _irqdispatch(void)\ 
     146{\ 
     147        ifxmips_hw_irqdispatch(x); \ 
     148} 
     149static void ifxmips_hw5_irqdispatch(void) 
     150{ 
     151        do_IRQ(MIPS_CPU_TIMER_IRQ); 
     152} 
     153DEFINE_HWx_IRQDISPATCH(0) 
     154DEFINE_HWx_IRQDISPATCH(1) 
     155DEFINE_HWx_IRQDISPATCH(2) 
     156DEFINE_HWx_IRQDISPATCH(3) 
     157DEFINE_HWx_IRQDISPATCH(4) 
     158/*DEFINE_HWx_IRQDISPATCH(5)*/ 
     159#endif /* #ifdef CONFIG_CPU_MIPSR2_IRQ_VI */ 
     160 
     161asmlinkage void plat_irq_dispatch(void) 
    155162{ 
    156163        unsigned int pending = read_c0_status() & read_c0_cause() & ST0_IM; 
    157164        unsigned int i; 
    158165 
    159         if(pending & CAUSEF_IP7) 
    160         { 
     166        if (pending & CAUSEF_IP7) { 
    161167                do_IRQ(MIPS_CPU_TIMER_IRQ); 
    162168                goto out; 
    163169        } else { 
    164                 for(i = 0; i < 5; i++) 
    165                 { 
    166                         if(pending & (CAUSEF_IP2 << i)) 
    167                         { 
     170                for (i = 0; i < 5; i++) { 
     171                        if (pending & (CAUSEF_IP2 << i)) { 
    168172                                ifxmips_hw_irqdispatch(i); 
    169173                                goto out; 
     
    171175                } 
    172176        } 
    173         printk("Spurious IRQ: CAUSE=0x%08x\n", read_c0_status()); 
     177        printk(KERN_ALERT "Spurious IRQ: CAUSE=0x%08x\n", read_c0_status()); 
    174178 
    175179out: 
     
    177181} 
    178182 
    179 static struct irqaction 
    180 cascade = { 
     183static struct irqaction cascade = { 
    181184        .handler = no_action, 
    182185        .flags = IRQF_DISABLED, 
     
    184187}; 
    185188 
    186 void __init 
    187 arch_init_irq(void) 
    188 { 
    189         int i; 
    190  
    191         for(i = 0; i < 5; i++) 
     189void __init arch_init_irq(void) 
     190{ 
     191        int i; 
     192 
     193        for (i = 0; i < 5; i++) 
    192194                ifxmips_w32(0, IFXMIPS_ICU_IM0_IER + (i * IFXMIPS_ICU_OFFSET)); 
    193195 
    194196        mips_cpu_irq_init(); 
    195197 
    196         for(i = 2; i <= 6; i++) 
     198        for (i = 2; i <= 6; i++) 
    197199                setup_irq(i, &cascade); 
    198200 
    199         for(i = INT_NUM_IRQ0; i <= (INT_NUM_IRQ0 + (5 * INT_NUM_IM_OFFSET)); i++) 
    200                 set_irq_chip_and_handler(i, &ifxmips_irq_type, handle_level_irq); 
    201  
    202         set_c0_status(IE_IRQ0 | IE_IRQ1 | IE_IRQ2 | IE_IRQ3 | IE_IRQ4 | IE_IRQ5); 
    203 } 
     201#ifdef CONFIG_CPU_MIPSR2_IRQ_VI 
     202        if (cpu_has_vint) { 
     203                printk(KERN_INFO "Setting up vectored interrupts\n"); 
     204                set_vi_handler(2, ifxmips_hw0_irqdispatch); 
     205                set_vi_handler(3, ifxmips_hw1_irqdispatch); 
     206                set_vi_handler(4, ifxmips_hw2_irqdispatch); 
     207                set_vi_handler(5, ifxmips_hw3_irqdispatch); 
     208                set_vi_handler(6, ifxmips_hw4_irqdispatch); 
     209                set_vi_handler(7, ifxmips_hw5_irqdispatch); 
     210        } 
     211#endif /* CONFIG_CPU_MIPSR2_IRQ_VI */ 
     212 
     213        for (i = INT_NUM_IRQ0; i <= (INT_NUM_IRQ0 + (5 * INT_NUM_IM_OFFSET)); 
     214                i++) 
     215                set_irq_chip_and_handler(i, &ifxmips_irq_type, 
     216                        handle_level_irq); 
     217 
     218        #if !defined(CONFIG_MIPS_MT_SMP) && !defined(CONFIG_MIPS_MT_SMTC) 
     219        set_c0_status(IE_IRQ0 | IE_IRQ1 | IE_IRQ2 | 
     220                IE_IRQ3 | IE_IRQ4 | IE_IRQ5); 
     221        #else 
     222        set_c0_status(IE_SW0 | IE_SW1 | IE_IRQ0 | IE_IRQ1 | 
     223                IE_IRQ2 | IE_IRQ3 | IE_IRQ4 | IE_IRQ5); 
     224        #endif 
     225} 
     226 
     227void __cpuinit arch_fixup_c0_irqs(void) 
     228{ 
     229        /* FIXME: check for CPUID and only do fix for specific chips/versions */ 
     230        cp0_compare_irq = CP0_LEGACY_COMPARE_IRQ; 
     231        cp0_perfcount_irq = CP0_LEGACY_PERFCNT_IRQ; 
     232} 
  • trunk/target/linux/ifxmips/files/arch/mips/ifxmips/prom.c

    r11673 r13660  
    1515 * 
    1616 *   Copyright (C) 2005 Wu Qi Ming infineon 
    17  *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>  
     17 *   Copyright (C) 2007 John Crispin <blogic@openwrt.org> 
    1818 */ 
    1919 
     
    2424#include <asm/ifxmips/ifxmips.h> 
    2525 
    26 static char buf[1024]; 
     26static char buf[1024]; /* for prom_printf() */ 
     27 
     28/* for voice cpu (MIPS24K) */ 
    2729unsigned int *prom_cp1_base = NULL; 
    2830unsigned int prom_cp1_size = 0; 
     31 
     32/* for Multithreading (APRP) on MIPS34K */ 
     33unsigned long physical_memsize = 0L; 
    2934 
    3035#ifdef IFXMIPS_PROM_ASC0 
     
    3439#endif 
    3540 
    36 static inline u32 
    37 asc_r32(unsigned long r) 
     41static inline u32 asc_r32(unsigned long r) 
    3842{ 
    39         return ifxmips_r32((u32*)(IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_DIFF + r)); 
     43        return ifxmips_r32((u32 *)(IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_DIFF + r)); 
    4044} 
    4145 
    42 static inline void 
    43 asc_w32(u32 v, unsigned long r) 
     46static inline void asc_w32(u32 v, unsigned long r) 
    4447{ 
    45         ifxmips_w32(v, (u32*)(IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_DIFF + r)); 
     48        ifxmips_w32(v, (u32 *)(IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_DIFF + r)); 
    4649} 
    4750 
    48 void 
    49 prom_free_prom_memory(void) 
     51void prom_free_prom_memory(void) 
    5052{ 
    5153} 
    5254 
    53 void 
    54 prom_putchar(char c) 
     55void prom_putchar(char c) 
    5556{ 
    5657        unsigned long flags; 
     
    5960        while((asc_r32(IFXMIPS_ASC_FSTAT) & ASCFSTAT_TXFFLMASK) >> ASCFSTAT_TXFFLOFF); 
    6061 
    61         if(c == '\n') 
     62        if (c == '\n') 
    6263                asc_w32('\r', IFXMIPS_ASC_TBUF); 
    6364        asc_w32(c, IFXMIPS_ASC_TBUF); 
     
    6566} 
    6667 
    67 void 
    68 prom_printf(const char * fmt, ...) 
     68void prom_printf(const char *fmt, ...) 
    6969{ 
    7070        va_list args; 
     
    7777        buf_end = buf + l; 
    7878 
    79         for(p = buf; p < buf_end; p++) 
     79        for (p = buf; p < buf_end; p++) 
    8080                prom_putchar(*p); 
    8181} 
     
    8989unsigned int prom_get_cp1_size(void) 
    9090{ 
    91         return prom_cp1_size; 
     91        /* return size im MB */ 
     92        return prom_cp1_size>>20; 
    9293} 
    9394EXPORT_SYMBOL(prom_get_cp1_size); 
    9495 
    95 void __init 
    96 prom_init(void) 
     96void __init prom_init(void) 
    9797{ 
    9898        int argc = fw_arg0; 
     
    100100        char **envp = (char **) fw_arg2; 
    101101 
    102         int memsize = 16; 
     102        int memsize = 16; /* assume 16M as default */ 
    103103        int i; 
    104104 
    105105        mips_machtype = MACH_INFINEON_IFXMIPS; 
    106106 
    107         argv = (char**)KSEG1ADDR((unsigned long)argv); 
    108         arcs_cmdline[0] = '\0'; 
    109         for(i = 1; i < argc; i++) 
    110         { 
    111                 char *a = (char*)KSEG1ADDR(argv[i]); 
    112                 if(!a) 
    113                         continue; 
    114                 if(strlen(arcs_cmdline) + strlen(a + 1) >= sizeof(arcs_cmdline)) 
    115                         break; 
    116                 strcat(arcs_cmdline, a); 
    117                 strcat(arcs_cmdline, " "); 
     107        if (argc) { 
     108                argv = (char**)KSEG1ADDR((unsigned long)argv); 
     109                arcs_cmdline[0] = '\0'; 
     110                for (i = 1; i < argc; i++) 
     111                { 
     112                        char *a = (char *)KSEG1ADDR(argv[i]); 
     113                        if (!argv[i]) 
     114                                continue; 
     115                        /* for voice cpu on Twinpass/Danube */ 
     116                        if (cpu_data[0].cputype == CPU_24K) 
     117                                if (!strncmp(a, "cp1_size=", 9)) { 
     118                                        prom_cp1_size = memparse(a + 9, &a); 
     119                                        continue; 
     120                                } 
     121                        if (strlen(arcs_cmdline) + strlen(a + 1) >= sizeof(arcs_cmdline)) { 
     122                                prom_printf("cmdline overflow, skipping: %s\n", a); 
     123                                break; 
     124                        } 
     125                        strcat(arcs_cmdline, a); 
     126                        strcat(arcs_cmdline, " "); 
     127                } 
     128                if (!*arcs_cmdline) 
     129                        strcpy(&(arcs_cmdline[0]), 
     130                                "console=ttyS0,115200 rootfstype=squashfs,jffs2 init=/etc/preinit"); 
    118131        } 
    119  
    120132        envp = (char**)KSEG1ADDR((unsigned long)envp); 
    121133        while(*envp) 
    122134        { 
    123                 char *e = (char*)KSEG1ADDR(*envp); 
     135                char *e = (char *)KSEG1ADDR(*envp); 
    124136 
    125                 if(!strncmp(e, "memsize=", 8)) 
     137                if (!strncmp(e, "memsize=", 8)) 
    126138                { 
    127139                        e += 8; 
     
    131143        } 
    132144 
    133         prom_cp1_size = 2; 
    134         memsize -= prom_cp1_size; 
    135         prom_cp1_base = (unsigned int*)(0xA0000000 + (memsize * 1024 * 1024)); 
    136  
    137         prom_printf("Using %dMB Ram and reserving %dMB for cp1\n", memsize, prom_cp1_size); 
    138145        memsize *= 1024 * 1024; 
    139146 
    140         if(!*arcs_cmdline) 
    141                 strcpy(&(arcs_cmdline[0]), 
    142                         "console=ttyS0,115200 rootfstype=squashfs,jffs2 init=/etc/preinit"); 
     147        /* only on Twinpass/Danube a second CPU is used for Voice */ 
     148        if ((cpu_data[0].cputype == CPU_24K) && (prom_cp1_size)) { 
     149                memsize -= prom_cp1_size; 
     150                prom_cp1_base = (unsigned int*)KSEG1ADDR(memsize); 
     151 
     152                prom_printf("Using %dMB Ram and reserving %dMB for cp1\n", 
     153                        memsize>>20, prom_cp1_size>>20); 
     154        } 
    143155 
    144156        add_memory_region(0x00000000, memsize, BOOT_MEM_RAM); 
  • trunk/target/linux/ifxmips/files/arch/mips/ifxmips/reset.c

    r11570 r13660  
    2424#include <asm/ifxmips/ifxmips.h> 
    2525 
    26 static void 
    27 ifxmips_machine_restart(char *command) 
     26static void ifxmips_machine_restart(char *command) 
    2827{ 
    2928        printk(KERN_NOTICE "System restart\n"); 
     
    3433} 
    3534 
    36 static void 
    37 ifxmips_machine_halt(void) 
     35static void ifxmips_machine_halt(void) 
    3836{ 
    3937        printk(KERN_NOTICE "System halted.\n"); 
     
    4240} 
    4341 
    44 static void 
    45 ifxmips_machine_power_off(void) 
     42static void ifxmips_machine_power_off(void) 
    4643{ 
    4744        printk (KERN_NOTICE "Please turn off the power now.\n"); 
     
    5047} 
    5148 
    52 void 
    53 ifxmips_reboot_setup(void) 
     49void ifxmips_reboot_setup(void) 
    5450{ 
    5551        _machine_restart = ifxmips_machine_restart; 
  • trunk/target/linux/ifxmips/files/arch/mips/ifxmips/setup.c

    r11607 r13660  
    1414 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. 
    1515 * 
    16  *   Copyright (C) 2004 peng.liu@infineon.com  
    17  *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>  
     16 *   Copyright (C) 2004 peng.liu@infineon.com 
     17 *   Copyright (C) 2007 John Crispin <blogic@openwrt.org> 
    1818 */ 
    1919 
     
    2222#include <asm/time.h> 
    2323#include <asm/traps.h> 
    24 #include <asm/cpu.h> 
     24#include <linux/cpu.h> 
    2525#include <asm/irq.h> 
    2626#include <asm/bootinfo.h> 
     
    3434static unsigned int r4k_cur; 
    3535 
     36/* required in arch/mips/kernel/kspd.c */ 
     37unsigned long cpu_khz; 
     38 
    3639extern void ifxmips_reboot_setup(void); 
    3740 
    38 unsigned int 
    39 ifxmips_get_cpu_ver(void) 
     41unsigned int ifxmips_get_cpu_ver(void) 
    4042{ 
    4143        return (ifxmips_r32(IFXMIPS_MPS_CHIPID) & 0xF0000000) >> 28; 
     
    4345EXPORT_SYMBOL(ifxmips_get_cpu_ver); 
    4446 
    45 static __inline__ u32 
    46 ifxmips_get_counter_resolution(void) 
     47static inline u32 ifxmips_get_counter_resolution(void) 
    4748{ 
    4849        u32 res; 
     
    5758                : /* no input */ 
    5859                : "memory"); 
    59                 instruction_hazard(); 
    60                 return res; 
     60        instruction_hazard(); 
     61        return res; 
    6162} 
    6263 
    63 void __init 
    64 plat_time_init(void) 
     64void __init plat_time_init(void) 
    6565{ 
    6666        mips_hpt_frequency = ifxmips_get_cpu_hz() / ifxmips_get_counter_resolution(); 
     
    6969 
    7070        ifxmips_pmu_enable(IFXMIPS_PMU_PWDCR_GPT | IFXMIPS_PMU_PWDCR_FPI); 
    71         ifxmips_w32(0x100, IFXMIPS_GPTU_GPT_CLC); // set clock divider to 1 
     71        ifxmips_w32(0x100, IFXMIPS_GPTU_GPT_CLC); /* set clock divider to 1 */ 
     72        cpu_khz = ifxmips_get_cpu_hz(); 
    7273} 
    7374 
    74 void __init 
    75 plat_mem_setup(void) 
     75void __init plat_mem_setup(void) 
    7676{ 
    7777        u32 status; 
    78         prom_printf("This %s has a cpu rev of 0x%X\n", get_system_type(), ifxmips_get_cpu_ver()); 
     78        prom_printf("This %s system has a cpu rev of %d\n", get_system_type(), ifxmips_get_cpu_ver()); 
    7979 
     80        /* make sure to have no "reverse endian" for user mode! */ 
    8081        status = read_c0_status(); 
    8182        status &= (~(1<<25)); 
  • trunk/target/linux/ifxmips/files/arch/mips/ifxmips/timer.c

    r11603 r13660  
    370370                if (TIMER_FLAG_MASK_HANDLE (flag) == TIMER_FLAG_SIGNAL) 
    371371                        timer_dev.timer[timer - FIRST_TIMER].arg1 = 
    372                                 (unsigned long) find_task_by_pid ((int) arg1); 
     372                                (unsigned long) find_task_by_vpid ((int) arg1); 
    373373 
    374374                irnen_reg = 1 << (timer - FIRST_TIMER); 
  • trunk/target/linux/ifxmips/files/drivers/char/ifxmips_eeprom.c

    r9826 r13660  
    1717 *   fundamental conceptual drawbacks there has been changed a lot. 
    1818 * 
    19  *   Based on INCA-IP driver Copyright (c) 2003 Gary Jennejohn <gj@denx.de> 
    20  *   Based on the VxWorks drivers Copyright (c) 2002, Infineon Technologies. 
     19 *   Based on INCA-IP driver Copyright(c) 2003 Gary Jennejohn <gj@denx.de> 
     20 *   Based on the VxWorks drivers Copyright(c) 2002, Infineon Technologies. 
    2121 * 
    22  *   Copyright (C) 2006 infineon 
    23  *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>  
     22 *   Copyright(C) 2006 infineon 
     23 *   Copyright(C) 2007 John Crispin <blogic@openwrt.org> 
    2424 * 
    2525 */ 
     
    4444#include <linux/spinlock.h> 
    4545#include <linux/slab.h> 
    46 #include <asm/system.h> 
    47 #include <asm/io.h> 
    48 #include <asm/irq.h> 
    49 #include <asm/uaccess.h> 
    50 #include <asm/bitops.h> 
     46#include <linux/io.h> 
     47#include <linux/irq.h> 
     48#include <linux/uaccess.h> 
     49#include <linux/bitops.h> 
    5150 
    5251#include <linux/types.h> 
     
    5453#include <linux/version.h> 
    5554 
     55#include <asm/system.h> 
    5656#include <asm/ifxmips/ifxmips.h> 
    5757#include <asm/ifxmips/ifxmips_irq.h> 
     
    6060 
    6161/* allow the user to set the major device number */ 
    62 static int ifxmips_eeprom_maj = 0; 
    63  
    64 extern int ifx_ssc_init (void); 
    65 extern int ifx_ssc_open (struct inode *inode, struct file *filp); 
    66 extern int ifx_ssc_close (struct inode *inode, struct file *filp); 
    67 extern void ifx_ssc_cleanup_module (void); 
    68 extern int ifx_ssc_ioctl (struct inode *inode, struct file *filp, 
     62static int ifxmips_eeprom_maj; 
     63 
     64extern int ifx_ssc_init(void); 
     65extern int ifx_ssc_open(struct inode *inode, struct file *filp); 
     66extern int ifx_ssc_close(struct inode *inode, struct file *filp); 
     67extern void ifx_ssc_cleanup_module(void); 
     68extern int ifx_ssc_ioctl(struct inode *inode, struct file *filp, 
    6969                          unsigned int cmd, unsigned long data); 
    70 extern ssize_t ifx_ssc_kwrite (int port, const char *kbuf, size_t len); 
    71 extern ssize_t ifx_ssc_kread (int port, char *kbuf, size_t len); 
    72  
    73 extern int ifx_ssc_cs_low (unsigned int pin); 
    74 extern int ifx_ssc_cs_high (unsigned int pin); 
    75 extern int ifx_ssc_txrx (char *tx_buf, unsigned int tx_len, char *rx_buf, unsigned int rx_len); 
    76 extern int ifx_ssc_tx (char *tx_buf, unsigned int tx_len); 
    77 extern int ifx_ssc_rx (char *rx_buf, unsigned int rx_len); 
     70extern ssize_t ifx_ssc_kwrite(int port, const char *kbuf, size_t len); 
     71extern ssize_t ifx_ssc_kread(int port, char *kbuf, size_t len); 
     72 
     73extern int ifx_ssc_cs_low(unsigned int pin); 
     74extern int ifx_ssc_cs_high(unsigned int pin); 
     75extern int ifx_ssc_txrx(char *tx_buf, unsigned int tx_len, char *rx_buf, unsigned int rx_len); 
     76extern int ifx_ssc_tx(char *tx_buf, unsigned int tx_len); 
     77extern int ifx_ssc_rx(char *rx_buf, unsigned int rx_len); 
    7878 
    7979#define EEPROM_CS IFX_SSC_WHBGPOSTAT_OUT0_POS 
     
    8989#define EEPROM_SIZE                     512 
    9090 
    91 static int 
    92 eeprom_rdsr (void) 
     91static int eeprom_rdsr(void) 
    9392{ 
    9493        int ret = 0; 
     
    109108} 
    110109 
    111 void 
    112 eeprom_wip_over (void) 
     110void eeprom_wip_over(void) 
    113111{ 
    114112        while (eeprom_rdsr()) 
    115                 printk("waiting for eeprom\n"); 
    116 } 
    117  
    118 static int 
    119 eeprom_wren (void) 
     113                printk(KERN_INFO "waiting for eeprom\n"); 
     114} 
     115 
     116static int eeprom_wren(void) 
    120117{ 
    121118        unsigned char cmd = EEPROM_WREN; 
     
    137134} 
    138135 
    139 static int 
    140 eeprom_wrsr (void) 
     136static int eeprom_wrsr(void) 
    141137{ 
    142138        int ret = 0; 
     
    147143        cmd[1] = 0; 
    148144 
    149         if ((ret = eeprom_wren())) 
    150         { 
    151                 printk ("eeprom_wren fails\n"); 
     145        if ((ret = eeprom_wren())) { 
     146                printk(KERN_ERR "eeprom_wren fails\n"); 
    152147                goto out1; 
    153148        } 
     
    172167 
    173168out: 
    174         local_irq_restore (flag); 
    175         eeprom_wip_over (); 
     169        local_irq_restore(flag); 
     170        eeprom_wip_over(); 
    176171 
    177172out1: 
     
    179174} 
    180175 
    181 static int 
    182 eeprom_read (unsigned int addr, unsigned char *buf, unsigned int len) 
     176static int eeprom_read(unsigned int addr, unsigned char *buf, unsigned int len) 
    183177{ 
    184178        int ret = 0; 
     
    187181        unsigned long flag; 
    188182 
    189         while (1) 
    190         { 
     183        while (1) { 
    191184                eeprom_wip_over(); 
    192185                eff = EEPROM_PAGE_SIZE - (addr % EEPROM_PAGE_SIZE); 
     
    197190                        goto out; 
    198191 
    199                 write_buf[0] = EEPROM_READ | ((unsigned char) ((addr & 0x100) >> 5)); 
     192                write_buf[0] = EEPROM_READ | ((unsigned char)((addr & 0x100) >> 5)); 
    200193                write_buf[1] = (addr & 0xff); 
    201194 
    202                 if ((ret = ifx_ssc_txrx (write_buf, 2, buf, eff)) != eff) 
    203                 { 
    204                         printk("ssc_txrx fails %d\n", ret); 
    205                         ifx_ssc_cs_high (EEPROM_CS); 
     195                ret = ifx_ssc_txrx(write_buf, 2, buf, eff); 
     196                if (ret != eff) { 
     197                        printk(KERN_ERR "ssc_txrx fails %d\n", ret); 
     198                        ifx_ssc_cs_high(EEPROM_CS); 
    206199                        goto out; 
    207200                } 
     
    211204                addr += ret; 
    212205 
    213                 if ((ret = ifx_ssc_cs_high(EEPROM_CS))) 
     206                ret = ifx_ssc_cs_high(EEPROM_CS); 
     207                if (ret) 
    214208                        goto out; 
    215209 
     
    221215 
    222216out: 
    223         local_irq_restore (flag); 
     217        local_irq_restore(flag); 
    224218out2: 
    225219        return ret; 
    226220} 
    227221 
    228 static int 
    229 eeprom_write (unsigned int addr, unsigned char *buf, unsigned int len) 
     222static int eeprom_write(unsigned int addr, unsigned char *buf, unsigned int len) 
    230223{ 
    231224        int ret = 0; 
     
    235228        unsigned char rx_buf[EEPROM_PAGE_SIZE]; 
    236229 
    237         while (1) 
    238         { 
     230        while (1) { 
    239231                eeprom_wip_over(); 
    240232 
    241                 if ((ret = eeprom_wren())) 
    242                 { 
    243                         printk("eeprom_wren fails\n"); 
     233                if ((ret = eeprom_wren())) { 
     234                        printk(KERN_ERR "eeprom_wren fails\n"); 
    244235                        goto out; 
    245236                } 
    246237 
    247                 write_buf[0] = EEPROM_WRITE | ((unsigned char) ((addr & 0x100) >> 5)); 
     238                write_buf[0] = EEPROM_WRITE | ((unsigned char)((addr & 0x100) >> 5)); 
    248239                write_buf[1] = (addr & 0xff); 
    249240 
     
    251242                eff = (eff < len) ? eff : len; 
    252243 
    253                 printk("EEPROM Write:\n"); 
     244                printk(KERN_INFO "EEPROM Write:\n"); 
    254245                for (i = 0; i < eff; i++) { 
    255246                        printk("%2x ", buf[i]); 
     
    262253                        goto out; 
    263254 
    264                 if ((ret = ifx_ssc_tx (write_buf, 2)) < 0) 
    265                 { 
    266                         printk("ssc_tx fails %d\n", ret); 
     255                if ((ret = ifx_ssc_tx(write_buf, 2)) < 0) { 
     256                        printk(KERN_ERR "ssc_tx fails %d\n", ret); 
    267257                        ifx_ssc_cs_high(EEPROM_CS); 
    268258                        goto out; 
    269259                } 
    270260 
    271                 if ((ret = ifx_ssc_tx (buf, eff)) != eff) 
    272                 { 
    273                         printk("ssc_tx fails %d\n", ret); 
     261                if ((ret = ifx_ssc_tx(buf, eff)) != eff) { 
     262                        printk(KERN_ERR "ssc_tx fails %d\n", ret); 
    274263                        ifx_ssc_cs_high(EEPROM_CS); 
    275264                        goto out; 
     
    280269                addr += ret; 
    281270 
    282                 if ((ret = ifx_ssc_cs_high (EEPROM_CS))) 
    283                         goto out; 
    284  
    285                 printk ("<=="); 
     271                if ((ret = ifx_ssc_cs_high(EEPROM_CS))) 
     272                        goto out; 
     273 
     274                printk(KERN_INFO "<=="); 
    286275                eeprom_read((addr - eff), rx_buf, eff); 
    287276                for (i = 0; i < eff; i++) 
    288                 { 
    289                         printk ("[%x]", rx_buf[i]); 
    290                 } 
    291                 printk ("\n"); 
     277                        printk("[%x]", rx_buf[i]); 
     278                printk("\n"); 
    292279 
    293280                if (len <= 0) 
     
    299286} 
    300287 
    301 int 
    302 ifxmips_eeprom_open (struct inode *inode, struct file *filp) 
     288int ifxmips_eeprom_open(struct inode *inode, struct file *filp) 
    303289{ 
    304290        filp->f_pos = 0; 
     
    306292} 
    307293 
    308 int 
    309 ifxmips_eeprom_close (struct inode *inode, struct file *filp) 
     294int ifxmips_eeprom_close(struct inode *inode, struct file *filp) 
    310295{ 
    311296        return 0; 
    312297} 
    313298 
    314 int 
    315 ifxmips_eeprom_ioctl (struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data) 
     299int ifxmips_eeprom_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data) 
    316300{ 
    317301        return 0; 
    318302} 
    319303 
    320 ssize_t 
    321 ifxmips_eeprom_read (char *buf, size_t len, unsigned int addr) 
     304ssize_t ifxmips_eeprom_read(char *buf, size_t len, unsigned int addr) 
    322305{ 
    323306        int ret = 0; 
    324307        unsigned int data; 
    325308 
    326         printk("addr:=%d\n", addr); 
    327         printk("len:=%d\n", len); 
    328  
    329         if ((addr + len) > EEPROM_SIZE) 
    330         { 
    331                 printk("invalid len\n"); 
     309        printk(KERN_INFO "addr:=%d\n", addr); 
     310        printk(KERN_INFO "len:=%d\n", len); 
     311 
     312        if ((addr + len) > EEPROM_SIZE) { 
     313                printk(KERN_ERR "invalid len\n"); 
    332314                addr = 0; 
    333315                len = EEPROM_SIZE / 2; 
    334316        } 
    335317 
    336         if ((ret = ifx_ssc_open((struct inode *) 0, NULL))) 
    337         { 
    338                 printk("ifxmips_eeprom_open fails\n"); 
     318        if ((ret = ifx_ssc_open((struct inode *)0, NULL))) { 
     319                printk(KERN_ERR "ifxmips_ssc_open fails\n"); 
    339320                goto out; 
    340321        } 
     
    342323        data = (unsigned int)IFX_SSC_MODE_RXTX; 
    343324 
    344         if ((ret = ifx_ssc_ioctl((struct inode *) 0, NULL, IFX_SSC_RXTX_MODE_SET, (unsigned long) &data))) 
    345         { 
    346                 printk("set RXTX mode fails\n"); 
    347                 goto out; 
    348         } 
    349  
    350         if ((ret = eeprom_wrsr())) 
    351         { 
    352                 printk("EEPROM reset fails\n"); 
    353                 goto out; 
    354         } 
    355  
    356         if ((ret = eeprom_read(addr, buf, len))) 
    357         { 
    358                 printk("eeprom read fails\n"); 
     325        if ((ret = ifx_ssc_ioctl((struct inode *)0, NULL, IFX_SSC_RXTX_MODE_SET, (unsigned long) &data))) { 
     326                printk(KERN_ERR "set RXTX mode fails\n"); 
     327                goto out; 
     328        } 
     329 
     330        if ((ret = eeprom_wrsr())) { 
     331                printk(KERN_ERR "EEPROM reset fails\n"); 
     332                goto out; 
     333        } 
     334 
     335        if ((ret = eeprom_read(addr, buf, len))) { 
     336                printk(KERN_ERR "eeprom read fails\n"); 
    359337                goto out; 
    360338        } 
    361339 
    362340out: 
    363         if (ifx_ssc_close((struct inode *) 0, NULL)) 
    364                 printk("ifxmips_eeprom_close fails\n"); 
     341        if (ifx_ssc_close((struct inode *)0, NULL)) 
     342                printk(KERN_ERR "ifxmips_ssc_close fails\n"); 
    365343 
    366344        return len; 
     
    368346EXPORT_SYMBOL(ifxmips_eeprom_read); 
    369347 
    370 static ssize_t 
    371 ifxmips_eeprom_fops_read (struct file *filp, char *ubuf, size_t len, loff_t * off) 
     348static ssize_t ifxmips_eeprom_fops_read(struct file *filp, char *ubuf, size_t len, loff_t *off) 
    372349{ 
    373350        int ret = 0; 
    374351        unsigned char ssc_rx_buf[EEPROM_SIZE]; 
    375         long flag; 
     352        unsigned long flag; 
    376353 
    377354        if (*off >= EEPROM_SIZE) 
     
    386363        local_irq_save(flag); 
    387364 
    388         if ((ret = ifxmips_eeprom_read(ssc_rx_buf, len, *off)) < 0) 
    389         { 
    390                 printk("read fails, err=%x\n", ret); 
     365        if ((ret = ifxmips_eeprom_read(ssc_rx_buf, len, *off)) < 0) { 
     366                printk(KERN_ERR "read fails, err=%x\n", ret); 
    391367                local_irq_restore(flag); 
    392368                return ret; 
    393369        } 
    394370 
    395         if (copy_to_user((void*)ubuf, ssc_rx_buf, ret) != 0) 
    396         { 
     371        if (copy_to_user((void *)ubuf, ssc_rx_buf, ret) != 0) { 
    397372                local_irq_restore(flag); 
    398373                ret = -EFAULT; 
     
    405380} 
    406381 
    407 ssize_t 
    408 ifxmips_eeprom_write (char *buf, size_t len, unsigned int addr) 
     382ssize_t ifxmips_eeprom_write(char *buf, size_t len, unsigned int addr) 
    409383{ 
    410384        int ret = 0; 
    411385        unsigned int data; 
    412386 
    413         if ((ret = ifx_ssc_open ((struct inode *) 0, NULL))) 
    414         { 
    415                 printk ("ifxmips_eeprom_open fails\n"); 
     387        if ((ret = ifx_ssc_open((struct inode *)0, NULL))) { 
     388                printk(KERN_ERR "ifxmips_ssc_open fails\n"); 
    416389                goto out; 
    417390        } 
     
    419392        data = (unsigned int) IFX_SSC_MODE_RXTX; 
    420393 
    421         if ((ret = ifx_ssc_ioctl ((struct inode *) 0, NULL, IFX_SSC_RXTX_MODE_SET, (unsigned long) &data))) 
    422         { 
    423                 printk ("set RXTX mode fails\n"); 
    424                 goto out; 
    425         } 
    426  
    427         if ((ret = eeprom_wrsr ())) { 
    428                 printk ("EEPROM reset fails\n"); 
    429                 goto out; 
    430         } 
    431  
    432         if ((ret = eeprom_write (addr, buf, len))) { 
    433                 printk ("eeprom write fails\n"); 
     394        if ((ret = ifx_ssc_ioctl((struct inode *)0, NULL, IFX_SSC_RXTX_MODE_SET, (unsigned long) &data))) { 
     395                printk(KERN_ERR "set RXTX mode fails\n"); 
     396                goto out; 
     397        } 
     398 
     399        if ((ret = eeprom_wrsr())) { 
     400                printk(KERN_ERR "EEPROM reset fails\n"); 
     401                goto out; 
     402        } 
     403 
     404        if ((ret = eeprom_write(addr, buf, len))) { 
     405                printk(KERN_ERR "eeprom write fails\n"); 
    434406                goto out; 
    435407        } 
    436408 
    437409out: 
    438         if (ifx_ssc_close ((struct inode *) 0, NULL)) 
    439                 printk ("ifxmips_eeprom_close fails\n"); 
     410        if (ifx_ssc_close((struct inode *)0, NULL)) 
     411                printk(KERN_ERR "ifxmips_ssc_close fails\n"); 
    440412 
    441413        return ret; 
     
    443415EXPORT_SYMBOL(ifxmips_eeprom_write); 
    444416 
    445 static ssize_t 
    446 ifxmips_eeprom_fops_write (struct file *filp, const char *ubuf, size_t len, loff_t * off) 
     417static ssize_t ifxmips_eeprom_fops_write(struct file *filp, const char *ubuf, size_t len, loff_t *off) 
    447418{ 
    448419        int ret = 0; 
     
    455426                len = EEPROM_SIZE - *off; 
    456427 
    457         if ((ret = copy_from_user (ssc_tx_buf, ubuf, len))) 
     428        if ((ret = copy_from_user(ssc_tx_buf, ubuf, len))) 
    458429                return EFAULT; 
    459430 
    460         ret = ifxmips_eeprom_write (ssc_tx_buf, len, *off); 
     431        ret = ifxmips_eeprom_write(ssc_tx_buf, len, *off); 
    461432 
    462433        if (ret > 0) 
     
    466437} 
    467438 
    468 loff_t 
    469 ifxmips_eeprom_llseek (struct file * filp, loff_t off, int whence) 
     439loff_t ifxmips_eeprom_llseek(struct file *filp, loff_t off, int whence) 
    470440{ 
    471441        loff_t newpos; 
     
    492462 
    493463static struct file_operations ifxmips_eeprom_fops = { 
    494       owner:THIS_MODULE, 
    495       llseek:ifxmips_eeprom_llseek, 
    496       read:ifxmips_eeprom_fops_read, 
    497       write:ifxmips_eeprom_fops_write, 
    498       ioctl:ifxmips_eeprom_ioctl, 
    499       open:ifxmips_eeprom_open, 
    500       release:ifxmips_eeprom_close, 
     464        .owner = THIS_MODULE, 
     465        .llseek = ifxmips_eeprom_llseek, 
     466        .read = ifxmips_eeprom_fops_read, 
     467        .write = ifxmips_eeprom_fops_write, 
     468        .ioctl = ifxmips_eeprom_ioctl, 
     469        .open = ifxmips_eeprom_open, 
     470        .release = ifxmips_eeprom_close, 
    501471}; 
    502472 
    503 int __init 
    504 ifxmips_eeprom_init (void) 
     473int __init ifxmips_eeprom_init(void) 
    505474{ 
    506475        int ret = 0; 
     
    508477        ifxmips_eeprom_maj = register_chrdev(0, "eeprom", &ifxmips_eeprom_fops); 
    509478 
    510         if (ifxmips_eeprom_maj < 0) 
    511         { 
    512                 printk("failed to register eeprom device\n"); 
     479        if (ifxmips_eeprom_maj < 0) { 
     480                printk(KERN_ERR "failed to register eeprom device\n"); 
    513481                ret = -EINVAL; 
    514                  
    515                 goto out; 
    516         } 
    517  
    518         printk("ifxmips_eeprom : /dev/eeprom mayor %d\n", ifxmips_eeprom_maj); 
     482 
     483                goto out; 
     484        } 
     485 
     486        printk(KERN_INFO "ifxmips_eeprom : /dev/eeprom mayor %d\n", ifxmips_eeprom_maj); 
    519487 
    520488out: 
     
    522490} 
    523491 
    524 void __exit 
    525 ifxmips_eeprom_cleanup_module (void) 
    526 { 
    527         /*if (unregister_chrdev (ifxmips_eeprom_maj, "eeprom")) { 
    528                 printk ("Unable to unregister major %d for the EEPROM\n", 
     492void __exit ifxmips_eeprom_cleanup_module(void) 
     493{ 
     494        /*if (unregister_chrdev(ifxmips_eeprom_maj, "eeprom")) { 
     495                printk(KERN_ERR "Unable to unregister major %d for the EEPROM\n", 
    529496                        maj); 
    530497        }*/ 
    531498} 
    532499 
    533 module_exit (ifxmips_eeprom_cleanup_module); 
    534 module_init (ifxmips_eeprom_init); 
    535  
    536 MODULE_LICENSE ("GPL"); 
    537 MODULE_AUTHOR ("Peng Liu"); 
    538 MODULE_DESCRIPTION ("IFAP EEPROM driver"); 
    539 MODULE_SUPPORTED_DEVICE ("ifxmips_eeprom"); 
    540  
    541  
     500module_exit(ifxmips_eeprom_cleanup_module); 
     501module_init(ifxmips_eeprom_init); 
     502 
     503MODULE_LICENSE("GPL"); 
     504MODULE_AUTHOR("Peng Liu"); 
     505MODULE_DESCRIPTION("IFAP EEPROM driver"); 
     506MODULE_SUPPORTED_DEVICE("ifxmips_eeprom"); 
     507 
  • trunk/target/linux/ifxmips/files/drivers/char/ifxmips_ssc.c

    r11570 r13660  
    1414 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. 
    1515 * 
    16  *   Copyright (C) 2006 infineon 
    17  *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>  
     16 *   Copyright(C) 2006 infineon 
     17 *   Copyright(C) 2007 John Crispin <blogic@openwrt.org> 
    1818 * 
    1919 */ 
    2020 
    21 // ### TO DO: general issues: 
    22 //            - power management 
    23 //            - interrupt handling (direct/indirect) 
    24 //            - pin/mux-handling (just overall concept due to project dependency) 
    25 //            - multiple instances capability 
    26 //            - slave functionality 
     21/* 
     22### TO DO: general issues: 
     23        - power management 
     24        - interrupt handling (direct/indirect) 
     25        - pin/mux-handling (just overall concept due to project dependency) 
     26        - multiple instances capability 
     27        - slave functionality 
     28*/ 
    2729 
    2830#include <linux/module.h> 
     
    4345#include <linux/spinlock.h> 
    4446#include <linux/slab.h> 
    45  
    46 #include <asm/system.h> 
    47 #include <asm/io.h> 
    48 #include <asm/irq.h> 
    49 #include <asm/uaccess.h> 
    50 #include <asm/bitops.h> 
     47#include <linux/io.h> 
     48#include <linux/irq.h> 
     49#include <linux/uaccess.h> 
     50#include <linux/bitops.h> 
    5151 
    5252#include <linux/types.h> 
     
    5454#include <linux/version.h> 
    5555 
     56#include <asm/system.h> 
    5657#include <asm/ifxmips/ifxmips.h> 
    5758#include <asm/ifxmips/ifxmips_irq.h> 
     
    6061 
    6162/* allow the user to set the major device number */ 
    62 static int maj = 0; 
     63static int maj; 
    6364 
    6465/* 
     
    7071 
    7172/* other forward declarations */ 
    72 static unsigned int ifx_ssc_get_kernel_clk (struct ifx_ssc_port *info); 
    73 static void tx_int (struct ifx_ssc_port *); 
    74  
    75 extern unsigned int ifxmips_get_fpi_hz (void); 
    76 extern void ifxmips_mask_and_ack_irq (unsigned int irq_nr); 
    77  
    78 static inline unsigned int 
    79 ifx_ssc_get_kernel_clk (struct ifx_ssc_port *info) 
     73static unsigned int ifx_ssc_get_kernel_clk(struct ifx_ssc_port *info); 
     74static void tx_int(struct ifx_ssc_port *); 
     75 
     76extern unsigned int ifxmips_get_fpi_hz(void); 
     77extern void ifxmips_mask_and_ack_irq(unsigned int irq_nr); 
     78 
     79static inline unsigned int ifx_ssc_get_kernel_clk(struct ifx_ssc_port *info) 
    8080{ 
    8181        unsigned int rmc; 
    8282 
    8383        rmc = (ifxmips_r32(IFXMIPS_SSC_CLC) & IFX_CLC_RUN_DIVIDER_MASK) >> IFX_CLC_RUN_DIVIDER_OFFSET; 
    84         if (rmc == 0) 
    85         { 
    86                 printk ("ifx_ssc_get_kernel_clk rmc==0 \n"); 
     84        if (rmc == 0) { 
     85                printk("ifx_ssc_get_kernel_clk rmc==0 \n"); 
    8786                return 0; 
    8887        } 
    89         return ifxmips_get_fpi_hz () / rmc; 
    90 } 
    91  
    92 inline static void 
    93 rx_int (struct ifx_ssc_port *info) 
     88        return ifxmips_get_fpi_hz() / rmc; 
     89} 
     90 
     91static inline void rx_int(struct ifx_ssc_port *info) 
    9492{ 
    9593        int fifo_fill_lev, bytes_in_buf, i; 
     
    10098        fifo_fill_lev = (ifxmips_r32(IFXMIPS_SSC_FSTAT) & IFX_SSC_FSTAT_RECEIVED_WORDS_MASK) >> IFX_SSC_FSTAT_RECEIVED_WORDS_OFFSET; 
    10199        bytes_in_buf = info->rxbuf_end - info->rxbuf_ptr; 
    102         // transfer with 32 bits per entry 
     100        /* transfer with 32 bits per entry */ 
    103101        while ((bytes_in_buf >= 4) && (fifo_fill_lev > 0)) { 
    104                 tmp_ptr = (unsigned long *) info->rxbuf_ptr; 
     102                tmp_ptr = (unsigned long *)info->rxbuf_ptr; 
    105103                *tmp_ptr = ifxmips_r32(IFXMIPS_SSC_RB); 
    106104                info->rxbuf_ptr += 4; 
     
    110108        } 
    111109 
    112         // now do the rest as mentioned in STATE.RXBV 
     110        /* now do the rest as mentioned in STATE.RXBV */ 
    113111        while ((bytes_in_buf > 0) && (fifo_fill_lev > 0)) { 
    114112                rx_valid_cnt = (ifxmips_r32(IFXMIPS_SSC_STATE) & IFX_SSC_STATE_RX_BYTE_VALID_MASK) >> IFX_SSC_STATE_RX_BYTE_VALID_OFFSET; 
     
    121119                tmp_val = ifxmips_r32(IFXMIPS_SSC_RB); 
    122120 
    123                 for (i = 0; i < rx_valid_cnt; i++) 
    124                 { 
     121                for (i = 0; i < rx_valid_cnt; i++) { 
    125122                        *info->rxbuf_ptr = (tmp_val >> (8 * (rx_valid_cnt - i - 1))) & 0xff; 
    126123                        bytes_in_buf--; 
     
    130127        } 
    131128 
    132         // check if transfer is complete 
    133         if (info->rxbuf_ptr >= info->rxbuf_end) 
    134         { 
     129        /* check if transfer is complete */ 
     130        if (info->rxbuf_ptr >= info->rxbuf_end) { 
    135131                disable_irq(IFXMIPS_SSC_RIR); 
    136                 wake_up_interruptible (&info->rwait); 
    137         } else if ((info->opts.modeRxTx == IFX_SSC_MODE_RX) && (ifxmips_r32(IFXMIPS_SSC_RXCNT) == 0)) 
    138         { 
     132                wake_up_interruptible(&info->rwait); 
     133        } else if ((info->opts.modeRxTx == IFX_SSC_MODE_RX) && (ifxmips_r32(IFXMIPS_SSC_RXCNT) == 0)) { 
    139134                if (info->rxbuf_end - info->rxbuf_ptr < IFX_SSC_RXREQ_BLOCK_SIZE) 
    140135                        ifxmips_w32((info->rxbuf_end - info->rxbuf_ptr) << IFX_SSC_RXREQ_RXCOUNT_OFFSET, IFXMIPS_SSC_RXREQ); 
     
    144139} 
    145140 
    146 inline static void 
    147 tx_int (struct ifx_ssc_port *info) 
     141static inline void tx_int(struct ifx_ssc_port *info) 
    148142{ 
    149143 
    150144        int fifo_space, fill, i; 
    151145        fifo_space = ((ifxmips_r32(IFXMIPS_SSC_ID) & IFX_SSC_PERID_TXFS_MASK) >> IFX_SSC_PERID_TXFS_OFFSET) 
    152                 - ((ifxmips_r32(IFXMIPS_SSC_FSTAT) & IFX_SSC_FSTAT_TRANSMIT_WORDS_MASK) >> IFX_SSC_FSTAT_TRANSMIT_WORDS_OFFSET); 
     146                -((ifxmips_r32(IFXMIPS_SSC_FSTAT) & IFX_SSC_FSTAT_TRANSMIT_WORDS_MASK) >> IFX_SSC_FSTAT_TRANSMIT_WORDS_OFFSET); 
    153147 
    154148        if (fifo_space == 0) 
     
    160154                fill = fifo_space * 4; 
    161155 
    162         for (i = 0; i < fill / 4; i++) 
    163         { 
    164                 // at first 32 bit access 
    165                 ifxmips_w32(*(UINT32 *) info->txbuf_ptr, IFXMIPS_SSC_TB); 
     156        for (i = 0; i < fill / 4; i++) { 
     157                /* at first 32 bit access */ 
     158                ifxmips_w32(*(UINT32 *)info->txbuf_ptr, IFXMIPS_SSC_TB); 
    166159                info->txbuf_ptr += 4; 
    167160        } 
     
    170163        info->stats.txBytes += fill & ~0x3; 
    171164        fill &= 0x3; 
    172         if ((fifo_space > 0) & (fill > 1)) 
    173         { 
    174                 // trailing 16 bit access 
    175                 WRITE_PERIPHERAL_REGISTER_16 (*(UINT16 *) info->txbuf_ptr, info->mapbase + IFX_SSC_TB); 
     165        if ((fifo_space > 0) & (fill > 1)) { 
     166                /* trailing 16 bit access */ 
     167                WRITE_PERIPHERAL_REGISTER_16(*(UINT16 *)info->txbuf_ptr, info->mapbase + IFX_SSC_TB); 
    176168                info->txbuf_ptr += 2; 
    177169                info->stats.txBytes += 2; 
     
    180172        } 
    181173 
    182         if ((fifo_space > 0) & (fill > 0)) 
    183         { 
    184                 // trailing 8 bit access 
    185                 WRITE_PERIPHERAL_REGISTER_8 (*(UINT8 *) info->txbuf_ptr, info->mapbase + IFX_SSC_TB); 
     174        if ((fifo_space > 0) & (fill > 0)) { 
     175                /* trailing 8 bit access */ 
     176                WRITE_PERIPHERAL_REGISTER_8(*(UINT8 *)info->txbuf_ptr, info->mapbase + IFX_SSC_TB); 
    186177                info->txbuf_ptr++; 
    187178                info->stats.txBytes++; 
    188179        } 
    189180 
    190         // check if transmission complete 
    191         if (info->txbuf_ptr >= info->txbuf_end) 
    192         { 
     181        /* check if transmission complete */ 
     182        if (info->txbuf_ptr >= info->txbuf_end) { 
    193183                disable_irq(IFXMIPS_SSC_TIR); 
    194                 kfree (info->txbuf); 
     184                kfree(info->txbuf); 
    195185                info->txbuf = NULL; 
    196186        } 
     
    198188} 
    199189 
    200 irqreturn_t 
    201 ifx_ssc_rx_int (int irq, void *dev_id) 
    202 { 
    203         struct ifx_ssc_port *info = (struct ifx_ssc_port *) dev_id; 
    204         rx_int (info); 
     190irqreturn_t ifx_ssc_rx_int(int irq, void *dev_id) 
     191{ 
     192        struct ifx_ssc_port *info = (struct ifx_ssc_port *)dev_id; 
     193        rx_int(info); 
    205194 
    206195        return IRQ_HANDLED; 
    207196} 
    208197 
    209 irqreturn_t 
    210 ifx_ssc_tx_int (int irq, void *dev_id) 
    211 { 
    212         struct ifx_ssc_port *info = (struct ifx_ssc_port *) dev_id; 
    213         tx_int (info); 
     198irqreturn_t ifx_ssc_tx_int(int irq, void *dev_id) 
     199{ 
     200        struct ifx_ssc_port *info = (struct ifx_ssc_port *)dev_id; 
     201        tx_int(info); 
    214202 
    215203        return IRQ_HANDLED; 
    216204} 
    217205 
    218 irqreturn_t 
    219 ifx_ssc_err_int (int irq, void *dev_id) 
    220 { 
    221         struct ifx_ssc_port *info = (struct ifx_ssc_port *) dev_id; 
     206irqreturn_t ifx_ssc_err_int(int irq, void *dev_id) 
     207{ 
     208        struct ifx_ssc_port *info = (struct ifx_ssc_port *)dev_id; 
    222209        unsigned int state; 
    223210        unsigned int write_back = 0; 
    224211        unsigned long flags; 
    225212 
    226         local_irq_save (flags); 
     213        local_irq_save(flags); 
    227214        state = ifxmips_r32(IFXMIPS_SSC_STATE); 
    228215 
     
    255242                ifxmips_w32(write_back, IFXMIPS_SSC_WHBSTATE); 
    256243 
    257         local_irq_restore (flags); 
     244        local_irq_restore(flags); 
    258245 
    259246        return IRQ_HANDLED; 
    260247} 
    261248 
    262 static void 
    263 ifx_ssc_abort (struct ifx_ssc_port *info) 
     249static void ifx_ssc_abort(struct ifx_ssc_port *info) 
    264250{ 
    265251        unsigned long flags; 
    266252        bool enabled; 
    267253 
    268         local_irq_save (flags); 
     254        local_irq_save(flags); 
    269255 
    270256        disable_irq(IFXMIPS_SSC_RIR); 
     
    272258        disable_irq(IFXMIPS_SSC_EIR); 
    273259 
    274         local_irq_restore (flags); 
    275  
    276         // disable SSC (also aborts a receive request!) 
    277         // ### TO DO: Perhaps it's better to abort after the receiption of a  
    278         // complete word. The disable cuts the transmission immediatly and  
    279         // releases the chip selects. This could result in unpredictable  
    280         // behavior of connected external devices! 
     260        local_irq_restore(flags); 
     261 
     262        /* disable SSC(also aborts a receive request!) */ 
     263        /* ### TO DO: Perhaps it's better to abort after the receiption of a 
     264                complete word. The disable cuts the transmission immediatly and 
     265                releases the chip selects. This could result in unpredictable 
     266                behavior of connected external devices! 
     267        */ 
    281268        enabled = (ifxmips_r32(IFXMIPS_SSC_STATE) & IFX_SSC_STATE_IS_ENABLED) != 0; 
    282269        ifxmips_w32(IFX_SSC_WHBSTATE_CLR_ENABLE, IFXMIPS_SSC_WHBSTATE); 
    283270 
    284         // flush fifos 
     271        /* flush fifos */ 
    285272        ifxmips_w32(IFX_SSC_XFCON_FIFO_FLUSH, IFXMIPS_SSC_TXFCON); 
    286273        ifxmips_w32(IFX_SSC_XFCON_FIFO_FLUSH, IFXMIPS_SSC_RXFCON); 
    287274 
    288         // free txbuf 
    289         if (info->txbuf != NULL) 
    290         { 
    291                 kfree (info->txbuf); 
     275        /* free txbuf */ 
     276        if (info->txbuf != NULL) { 
     277                kfree(info->txbuf); 
    292278                info->txbuf = NULL; 
    293279        } 
    294280 
    295         // wakeup read process 
     281        /* wakeup read process */ 
    296282        if (info->rxbuf != NULL) 
    297                 wake_up_interruptible (&info->rwait); 
    298  
    299         // clear pending int's  
     283                wake_up_interruptible(&info->rwait); 
     284 
     285        /* clear pending int's */ 
    300286        ifxmips_mask_and_ack_irq(IFXMIPS_SSC_RIR); 
    301287        ifxmips_mask_and_ack_irq(IFXMIPS_SSC_TIR); 
    302288        ifxmips_mask_and_ack_irq(IFXMIPS_SSC_EIR); 
    303289 
    304         // clear error flags 
     290        /* clear error flags */ 
    305291        ifxmips_w32(IFX_SSC_WHBSTATE_CLR_ALL_ERROR, IFXMIPS_SSC_WHBSTATE); 
    306292 
     
    314300 * exclusive opening of a port and enables interrupts, etc. 
    315301 */ 
    316 int 
    317 ifx_ssc_open (struct inode *inode, struct file *filp) 
     302int ifx_ssc_open(struct inode *inode, struct file *filp) 
    318303{ 
    319304        struct ifx_ssc_port *info; 
     
    321306        int from_kernel = 0; 
    322307 
    323         if ((inode == (struct inode *) 0) || (inode == (struct inode *) 1)) { 
     308        if ((inode == (struct inode *)0) || (inode == (struct inode *)1)) { 
    324309                from_kernel = 1; 
    325310                line = (int) inode; 
    326         } else { 
    327                 line = MINOR (filp->f_dentry->d_inode->i_rdev); 
    328         } 
     311        } else 
     312                line = MINOR(filp->f_dentry->d_inode->i_rdev); 
    329313 
    330314        /* don't open more minor devices than we can support */ 
     
    354338        ifxmips_w32(IFX_SSC_WHBSTATE_CLR_ALL_ERROR, IFXMIPS_SSC_WHBSTATE); 
    355339 
    356         // clear pending interrupts 
     340        /* clear pending interrupts */ 
    357341        ifxmips_mask_and_ack_irq(IFXMIPS_SSC_RIR); 
    358342        ifxmips_mask_and_ack_irq(IFXMIPS_SSC_TIR); 
     
    365349EXPORT_SYMBOL(ifx_ssc_open); 
    366350 
    367 int 
    368 ifx_ssc_close (struct inode *inode, struct file *filp) 
     351int ifx_ssc_close(struct inode *inode, struct file *filp) 
    369352{ 
    370353        struct ifx_ssc_port *info; 
    371354        int idx; 
    372355 
    373         if ((inode == (struct inode *) 0) || (inode == (struct inode *) 1)) 
     356        if ((inode == (struct inode *)0) || (inode == (struct inode *)1)) 
    374357                idx = (int) inode; 
    375358        else 
    376                 idx = MINOR (filp->f_dentry->d_inode->i_rdev); 
     359                idx = MINOR(filp->f_dentry->d_inode->i_rdev); 
    377360 
    378361        if (idx < 0 || idx >= PORT_CNT) 
     
    393376EXPORT_SYMBOL(ifx_ssc_close); 
    394377 
    395 static ssize_t 
    396 ifx_ssc_read_helper_poll (struct ifx_ssc_port *info, char *buf, size_t len, int from_kernel) 
     378static ssize_t ifx_ssc_read_helper_poll(struct ifx_ssc_port *info, char *buf, 
     379        size_t len, int from_kernel) 
    397380{ 
    398381        ssize_t ret_val; 
     
    401384        if (info->opts.modeRxTx == IFX_SSC_MODE_TX) 
    402385                return -EFAULT; 
    403         local_irq_save (flags); 
     386        local_irq_save(flags); 
    404387        info->rxbuf_ptr = info->rxbuf; 
    405388        info->rxbuf_end = info->rxbuf + len; 
    406         local_irq_restore (flags); 
     389        local_irq_restore(flags); 
    407390        /* Vinetic driver always works in IFX_SSC_MODE_RXTX */ 
    408391        /* TXRX in poll mode */ 
    409         while (info->rxbuf_ptr < info->rxbuf_end) 
    410         { 
     392        while (info->rxbuf_ptr < info->rxbuf_end) { 
    411393                if (info->txbuf_ptr < info->txbuf_end) 
    412                         tx_int (info); 
    413  
    414                 rx_int (info); 
     394                        tx_int(info); 
     395 
     396                rx_int(info); 
    415397        }; 
    416398 
     
    420402} 
    421403 
    422 static ssize_t 
    423 ifx_ssc_read_helper (struct ifx_ssc_port *info, char *buf, size_t len, int from_kernel) 
     404static ssize_t ifx_ssc_read_helper(struct ifx_ssc_port *info, char *buf, 
     405        size_t len, int from_kernel) 
    424406{ 
    425407        ssize_t ret_val; 
    426408        unsigned long flags; 
    427         DECLARE_WAITQUEUE (wait, current); 
     409        DECLARE_WAITQUEUE(wait, current); 
    428410 
    429411        if (info->opts.modeRxTx == IFX_SSC_MODE_TX) 
    430412                return -EFAULT; 
    431413 
    432         local_irq_save (flags); 
     414        local_irq_save(flags); 
    433415        info->rxbuf_ptr = info->rxbuf; 
    434416        info->rxbuf_end = info->rxbuf + len; 
    435417 
    436         if (info->opts.modeRxTx == IFX_SSC_MODE_RXTX) 
    437         { 
    438                 if ((info->txbuf == NULL) || (info->txbuf != info->txbuf_ptr) || (info->txbuf_end != len + info->txbuf)) 
    439                 { 
    440                         local_irq_restore (flags); 
    441                         printk ("IFX SSC - %s: write must be called before calling " "read in combined RX/TX!\n", __func__); 
     418        if (info->opts.modeRxTx == IFX_SSC_MODE_RXTX) { 
     419                if ((info->txbuf == NULL) || (info->txbuf != info->txbuf_ptr) || (info->txbuf_end != len + info->txbuf)) { 
     420                        local_irq_restore(flags); 
     421                        printk("IFX SSC - %s: write must be called before calling " "read in combined RX/TX!\n", __func__); 
    442422                        return -EFAULT; 
    443423                } 
    444424 
    445425                local_irq_restore(flags); 
    446                 tx_int (info); 
     426                tx_int(info); 
    447427 
    448428                if (info->txbuf_ptr < info->txbuf_end) 
     
    461441        } 
    462442 
    463         __add_wait_queue (&info->rwait, &wait); 
    464         set_current_state (TASK_INTERRUPTIBLE); 
     443        __add_wait_queue(&info->rwait, &wait); 
     444        set_current_state(TASK_INTERRUPTIBLE); 
    465445 
    466446        do { 
    467                 local_irq_save (flags); 
     447                local_irq_save(flags); 
    468448                if (info->rxbuf_ptr >= info->rxbuf_end) 
    469449                        break; 
    470450 
    471                 local_irq_restore (flags); 
    472  
    473                 if (signal_pending (current)) 
    474                 { 
     451                local_irq_restore(flags); 
     452 
     453                if (signal_pending(current)) { 
    475454                        ret_val = -ERESTARTSYS; 
    476455                        goto out; 
     
    480459 
    481460        ret_val = info->rxbuf_ptr - info->rxbuf; 
    482         local_irq_restore (flags); 
     461        local_irq_restore(flags); 
    483462 
    484463out: 
    485464        current->state = TASK_RUNNING; 
    486         __remove_wait_queue (&info->rwait, &wait); 
    487  
    488         return (ret_val); 
    489 } 
    490  
    491 static ssize_t 
    492 ifx_ssc_write_helper (struct ifx_ssc_port *info, const char *buf, 
    493                       size_t len, int from_kernel) 
     465        __remove_wait_queue(&info->rwait, &wait); 
     466 
     467        return ret_val; 
     468} 
     469 
     470static ssize_t ifx_ssc_write_helper(struct ifx_ssc_port *info, const char *buf, 
     471        size_t len, int from_kernel) 
    494472{ 
    495473        if (info->opts.modeRxTx == IFX_SSC_MODE_RX) 
     
    498476        info->txbuf_ptr = info->txbuf; 
    499477        info->txbuf_end = len + info->txbuf; 
    500         if (info->opts.modeRxTx == IFX_SSC_MODE_TX) 
    501         { 
    502                 tx_int (info); 
     478        if (info->opts.modeRxTx == IFX_SSC_MODE_TX) { 
     479                tx_int(info); 
    503480                if (info->txbuf_ptr < info->txbuf_end) 
    504                 { 
    505481                        enable_irq(IFXMIPS_SSC_TIR); 
    506                 } 
    507482        } 
    508483 
     
    510485} 
    511486 
    512 ssize_t 
    513 ifx_ssc_kread (int port, char *kbuf, size_t len) 
     487ssize_t ifx_ssc_kread(int port, char *kbuf, size_t len) 
    514488{ 
    515489        struct ifx_ssc_port *info; 
     
    524498        info = &isp[port]; 
    525499 
    526         if (info->rxbuf != NULL) 
    527         { 
    528                 printk ("SSC device busy\n"); 
     500        if (info->rxbuf != NULL) { 
     501                printk("SSC device busy\n"); 
    529502                return -EBUSY; 
    530503        } 
    531504 
    532505        info->rxbuf = kbuf; 
    533         if (info->rxbuf == NULL) 
    534         { 
    535                 printk ("SSC device error\n"); 
     506        if (info->rxbuf == NULL) { 
     507                printk("SSC device error\n"); 
    536508                return -EINVAL; 
    537509        } 
    538510 
    539         ret_val = ifx_ssc_read_helper_poll (info, kbuf, len, 1); 
     511        ret_val = ifx_ssc_read_helper_poll(info, kbuf, len, 1); 
    540512        info->rxbuf = NULL; 
    541513 
     
    546518EXPORT_SYMBOL(ifx_ssc_kread); 
    547519 
    548 ssize_t 
    549 ifx_ssc_kwrite (int port, const char *kbuf, size_t len) 
     520ssize_t ifx_ssc_kwrite(int port, const char *kbuf, size_t len) 
    550521{ 
    551522        struct ifx_ssc_port *info; 
     
    560531        info = &isp[port]; 
    561532 
    562         // check if transmission in progress 
     533        /* check if transmission in progress */ 
    563534        if (info->txbuf != NULL) 
    564535                return -EBUSY; 
    565536 
    566         info->txbuf = (char *) kbuf; 
    567  
    568         ret_val = ifx_ssc_write_helper (info, info->txbuf, len, 1); 
     537        info->txbuf = (char *)kbuf; 
     538 
     539        ret_val = ifx_ssc_write_helper(info, info->txbuf, len, 1); 
    569540 
    570541        if (ret_val < 0) 
     
    575546EXPORT_SYMBOL(ifx_ssc_kwrite); 
    576547 
    577 static ssize_t 
    578 ifx_ssc_read (struct file *filp, char *ubuf, size_t len, loff_t * off) 
     548static ssize_t ifx_ssc_read(struct file *filp, char *ubuf, size_t len, loff_t *off) 
    579549{ 
    580550        ssize_t ret_val; 
     
    582552        struct ifx_ssc_port *info; 
    583553 
    584         idx = MINOR (filp->f_dentry->d_inode->i_rdev); 
     554        idx = MINOR(filp->f_dentry->d_inode->i_rdev); 
    585555        info = &isp[idx]; 
    586556 
     
    588558                return -EBUSY; 
    589559 
    590         info->rxbuf = kmalloc (len + 3, GFP_KERNEL); 
     560        info->rxbuf = kmalloc(len + 3, GFP_KERNEL); 
    591561        if (info->rxbuf == NULL) 
    592562                return -ENOMEM; 
    593563 
    594         ret_val = ifx_ssc_read_helper (info, info->rxbuf, len, 0); 
    595         if (copy_to_user ((void *) ubuf, info->rxbuf, ret_val) != 0) 
     564        ret_val = ifx_ssc_read_helper(info, info->rxbuf, len, 0); 
     565        if (copy_to_user((void *)ubuf, info->rxbuf, ret_val) != 0) 
    596566                ret_val = -EFAULT; 
    597567 
    598568        disable_irq(IFXMIPS_SSC_RIR); 
    599569 
    600         kfree (info->rxbuf); 
     570        kfree(info->rxbuf); 
    601571        info->rxbuf = NULL; 
    602572 
    603         return (ret_val); 
    604 } 
    605  
    606 static ssize_t 
    607 ifx_ssc_write (struct file *filp, const char *ubuf, size_t len, loff_t * off) 
     573        return ret_val; 
     574} 
     575 
     576static ssize_t ifx_ssc_write(struct file *filp, const char *ubuf, size_t len, loff_t *off) 
    608577{ 
    609578        int idx; 
     
    612581 
    613582        if (len == 0) 
    614                 return (0); 
    615  
    616         idx = MINOR (filp->f_dentry->d_inode->i_rdev); 
     583                return 0; 
     584 
     585        idx = MINOR(filp->f_dentry->d_inode->i_rdev); 
    617586        info = &isp[idx]; 
    618587 
     
    620589                return -EBUSY; 
    621590 
    622         info->txbuf = kmalloc (len + 3, GFP_KERNEL); 
     591        info->txbuf = kmalloc(len + 3, GFP_KERNEL); 
    623592        if (info->txbuf == NULL) 
    624593                return -ENOMEM; 
    625594 
    626         ret_val = copy_from_user (info->txbuf, ubuf, len); 
     595        ret_val = copy_from_user(info->txbuf, ubuf, len); 
    627596        if (ret_val == 0) 
    628                 ret_val = ifx_ssc_write_helper (info, info->txbuf, len, 0); 
     597                ret_val = ifx_ssc_write_helper(info, info->txbuf, len, 0); 
    629598        else 
    630599                ret_val = -EFAULT; 
    631600 
    632         if (ret_val < 0) 
    633         { 
    634                 kfree (info->txbuf); 
     601        if (ret_val < 0) { 
     602                kfree(info->txbuf); 
    635603                info->txbuf = NULL; 
    636604        } 
    637605 
    638         return (ret_val); 
    639 } 
    640  
    641 static struct ifx_ssc_frm_status * 
    642 ifx_ssc_frm_status_get (struct ifx_ssc_port *info) 
     606        return ret_val; 
     607} 
     608 
     609static struct ifx_ssc_frm_status *ifx_ssc_frm_status_get(struct ifx_ssc_port *info) 
    643610{ 
    644611        unsigned long tmp; 
     
    656623} 
    657624 
    658  
    659 static struct ifx_ssc_frm_opts * 
    660 ifx_ssc_frm_control_get (struct ifx_ssc_port *info) 
     625static struct ifx_ssc_frm_opts *ifx_ssc_frm_control_get(struct ifx_ssc_port *info) 
    661626{ 
    662627        unsigned long tmp; 
     
    673638} 
    674639 
    675 static int 
    676 ifx_ssc_frm_control_set (struct ifx_ssc_port *info) 
     640static int ifx_ssc_frm_control_set(struct ifx_ssc_port *info) 
    677641{ 
    678642        unsigned long tmp; 
     
    686650                return -EINVAL; 
    687651 
    688         // read interrupt bits (they're not changed here) 
     652        /* read interrupt bits(they're not changed here) */ 
    689653        tmp = ifxmips_r32(IFXMIPS_SSC_SFCON) & 
    690654                (IFX_SSC_SFCON_FIR_ENABLE_BEFORE_PAUSE | IFX_SSC_SFCON_FIR_ENABLE_AFTER_PAUSE); 
    691655 
    692         // set all values with respect to it's bit position (for data and pause  
    693         // length set N-1) 
     656        /* set all values with respect to it's bit position(for data and pause 
     657           length set N-1) */ 
    694658        tmp = (info->frm_opts.DataLength - 1) << IFX_SSC_SFCON_DATA_LENGTH_OFFSET; 
    695659        tmp |= (info->frm_opts.PauseLength - 1) << IFX_SSC_SFCON_PAUSE_LENGTH_OFFSET; 
     
    704668} 
    705669 
    706 static int 
    707 ifx_ssc_rxtx_mode_set (struct ifx_ssc_port *info, unsigned int val) 
     670static int ifx_ssc_rxtx_mode_set(struct ifx_ssc_port *info, unsigned int val) 
    708671{ 
    709672        unsigned long tmp; 
     
    723686} 
    724687 
    725 static int 
    726 ifx_ssc_sethwopts (struct ifx_ssc_port *info) 
     688static int ifx_ssc_sethwopts(struct ifx_ssc_port *info) 
    727689{ 
    728690        unsigned long flags, bits; 
     
    755717                bits |= IFX_SSC_CON_CLOCK_FALL; 
    756718 
    757         switch (opts->modeRxTx) 
    758         { 
     719        switch (opts->modeRxTx) { 
    759720        case IFX_SSC_MODE_TX: 
    760721                bits |= IFX_SSC_CON_RX_OFF; 
     
    765726        } 
    766727 
    767         local_irq_save (flags); 
     728        local_irq_save(flags); 
    768729 
    769730        ifxmips_w32(bits, IFXMIPS_SSC_CON); 
    770731        ifxmips_w32((info->opts.gpoCs << IFX_SSC_GPOCON_ISCSB0_POS) | 
    771                                    (info->opts.gpoInv << IFX_SSC_GPOCON_INVOUT0_POS), IFXMIPS_SSC_GPOCON); 
     732                                  (info->opts.gpoInv << IFX_SSC_GPOCON_INVOUT0_POS), IFXMIPS_SSC_GPOCON); 
    772733 
    773734        ifxmips_w32(info->opts.gpoCs << IFX_SSC_WHBGPOSTAT_SETOUT0_POS, IFXMIPS_SSC_WHBGPOSTAT); 
    774735 
    775         //master mode 
     736        /* master mode */ 
    776737        if (opts->masterSelect) 
    777738                ifxmips_w32(IFX_SSC_WHBSTATE_SET_MASTER_SELECT, IFXMIPS_SSC_WHBSTATE); 
     
    779740                ifxmips_w32(IFX_SSC_WHBSTATE_CLR_MASTER_SELECT, IFXMIPS_SSC_WHBSTATE); 
    780741 
    781         // init serial framing 
     742        /* init serial framing */ 
    782743        ifxmips_w32(0, IFXMIPS_SSC_SFCON); 
    783744        /* set up the port pins */ 
    784         //check for general requirements to switch (external) pad/pin characteristics 
     745        /* check for general requirements to switch(external) pad/pin characteristics */ 
    785746        /* TODO: P0.9 SPI_CS4, P0.10 SPI_CS5, P 0.11 SPI_CS6, because of ASC0 */ 
    786747        /* p0.15 SPI_CS1(EEPROM), P0.13 SPI_CS3, */ 
    787         /* Set p0.15 to alternative 01, others to 00 (In/OUT) */ 
     748        /* Set p0.15 to alternative 01, others to 00(In/OUT) */ 
    788749        *(IFXMIPS_GPIO_P0_DIR) = (*IFXMIPS_GPIO_P0_DIR) | (0xA000); 
    789750        *(IFXMIPS_GPIO_P0_ALTSEL0) = (((*IFXMIPS_GPIO_P0_ALTSEL0) | (0x8000)) & (~(0x2000))); 
     
    801762        *IFXMIPS_GPIO_P0_OUT = ((*IFXMIPS_GPIO_P0_OUT) | 0x2000); 
    802763 
    803         local_irq_restore (flags); 
     764        local_irq_restore(flags); 
    804765 
    805766        return 0; 
    806767} 
    807768 
    808 static int 
    809 ifx_ssc_set_baud (struct ifx_ssc_port *info, unsigned int baud) 
     769static int ifx_ssc_set_baud(struct ifx_ssc_port *info, unsigned int baud) 
    810770{ 
    811771        unsigned int ifx_ssc_clock; 
     
    816776 
    817777        ifx_ssc_clock = ifx_ssc_get_kernel_clk(info); 
    818         if (ifx_ssc_clock == 0) 
    819         { 
     778        if (ifx_ssc_clock == 0) { 
    820779                retval = -EINVAL; 
    821780                goto out; 
    822781        } 
    823782 
    824         local_irq_save (flags); 
     783        local_irq_save(flags); 
    825784 
    826785        enabled = (ifxmips_r32(IFXMIPS_SSC_STATE) & IFX_SSC_STATE_IS_ENABLED); 
     
    832791        if (br > 0xffff || ((br == 0) && 
    833792                        ((ifxmips_r32(IFXMIPS_SSC_STATE) & IFX_SSC_STATE_IS_MASTER) == 0))) { 
    834                 local_irq_restore (flags); 
    835                 printk ("%s: invalid baudrate %u\n", __func__, baud); 
     793                local_irq_restore(flags); 
     794                printk("%s: invalid baudrate %u\n", __func__, baud); 
    836795                return -EINVAL; 
    837796        } 
     
    848807} 
    849808 
    850 static int 
    851 ifx_ssc_hwinit (struct ifx_ssc_port *info) 
     809static int ifx_ssc_hwinit(struct ifx_ssc_port *info) 
    852810{ 
    853811        unsigned long flags; 
     
    857815        ifxmips_w32(IFX_SSC_WHBSTATE_CLR_ENABLE, IFXMIPS_SSC_WHBSTATE); 
    858816 
    859         if (ifx_ssc_sethwopts (info) < 0) 
    860         { 
    861                 printk ("%s: setting the hardware options failed\n", __func__); 
     817        if (ifx_ssc_sethwopts(info) < 0) { 
     818                printk("%s: setting the hardware options failed\n", __func__); 
    862819                return -EINVAL; 
    863820        } 
    864821 
    865         if (ifx_ssc_set_baud (info, info->baud) < 0) 
    866         { 
    867                 printk ("%s: setting the baud rate failed\n", __func__); 
     822        if (ifx_ssc_set_baud(info, info->baud) < 0) { 
     823                printk("%s: setting the baud rate failed\n", __func__); 
    868824                return -EINVAL; 
    869825        } 
    870826 
    871         local_irq_save (flags); 
     827        local_irq_save(flags); 
    872828 
    873829        /* TX FIFO */ 
     
    876832        ifxmips_w32((IFX_SSC_DEF_RXFIFO_FL << IFX_SSC_XFCON_ITL_OFFSET) | IFX_SSC_XFCON_FIFO_ENABLE, IFXMIPS_SSC_RXFCON); 
    877833 
    878         local_irq_restore (flags); 
     834        local_irq_restore(flags); 
    879835 
    880836        if (enabled) 
     
    884840} 
    885841 
    886 int 
    887 ifx_ssc_ioctl (struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data) 
     842int ifx_ssc_ioctl(struct inode *inode, struct file *filp, 
     843        unsigned int cmd, unsigned long data) 
    888844{ 
    889845        struct ifx_ssc_port *info; 
     
    893849        int from_kernel = 0; 
    894850 
    895         if ((inode == (struct inode *) 0) || (inode == (struct inode *) 1)) 
    896         { 
     851        if ((inode == (struct inode *)0) || (inode == (struct inode *)1)) { 
    897852                from_kernel = 1; 
    898853                line = (int) inode; 
    899         } else { 
    900                 line = MINOR (filp->f_dentry->d_inode->i_rdev); 
    901         } 
     854        } else 
     855                line = MINOR(filp->f_dentry->d_inode->i_rdev); 
    902856 
    903857        if (line < 0 || line >= PORT_CNT) 
     
    906860        info = &isp[line]; 
    907861 
    908         switch (cmd) 
    909         { 
     862        switch (cmd) { 
    910863        case IFX_SSC_STATS_READ: 
    911864                /* data must be a pointer to a struct ifx_ssc_statistics */ 
    912865                if (from_kernel) 
    913                         memcpy ((void *) data, (void *) &info->stats, 
    914                                 sizeof (struct ifx_ssc_statistics)); 
    915                 else if (copy_to_user ((void *) data, 
    916                                        (void *) &info->stats, 
    917                                        sizeof (struct ifx_ssc_statistics))) 
     866                        memcpy((void *)data, (void *)&info->stats, 
     867                                sizeof(struct ifx_ssc_statistics)); 
     868                else if (copy_to_user((void *)data, 
     869                                      (void *)&info->stats, 
     870                                       sizeof(struct ifx_ssc_statistics))) 
    918871                        ret_val = -EFAULT; 
    919872                break; 
    920873        case IFX_SSC_STATS_RESET: 
    921874                /* just resets the statistics counters */ 
    922                 memset ((void *) &info->stats, 0, 
    923                         sizeof (struct ifx_ssc_statistics)); 
     875                memset((void *)&info->stats, 0, 
     876                        sizeof(struct ifx_ssc_statistics)); 
    924877                break; 
    925878        case IFX_SSC_BAUD_SET: 
     
    927880                /* busy and we shouldn't change things on-the-fly! */ 
    928881                if (!info->txbuf || !info->rxbuf || 
    929                     (ifxmips_r32(IFXMIPS_SSC_STATE) & IFX_SSC_STATE_BUSY)) { 
     882                   (ifxmips_r32(IFXMIPS_SSC_STATE) & IFX_SSC_STATE_BUSY)) { 
    930883                        ret_val = -EBUSY; 
    931884                        break; 
     
    933886                /* misuse flags */ 
    934887                if (from_kernel) 
    935                         flags = *((unsigned long *) data); 
    936                 else if (copy_from_user ((void *) &flags, 
    937                                          (void *) data, sizeof (flags))) { 
     888                        flags = *((unsigned long *)data); 
     889                else if (copy_from_user((void *)&flags, 
     890                                        (void *)data, sizeof(flags))) { 
    938891                        ret_val = -EFAULT; 
    939892                        break; 
     
    943896                        break; 
    944897                } 
    945                 if (ifx_ssc_set_baud (info, flags) < 0) { 
     898                if (ifx_ssc_set_baud(info, flags) < 0) { 
    946899                        ret_val = -EINVAL; 
    947900                        break; 
     
    951904        case IFX_SSC_BAUD_GET: 
    952905                if (from_kernel) 
    953                         *((unsigned int *) data) = info->baud; 
    954                 else if (copy_to_user ((void *) data, 
    955                                        (void *) &info->baud, 
    956                                        sizeof (unsigned long))) 
     906                        *((unsigned int *)data) = info->baud; 
     907                else if (copy_to_user((void *)data, 
     908                                      (void *)&info->baud, 
     909                                       sizeof(unsigned long))) 
    957910                        ret_val = -EFAULT; 
    958911                break; 
    959912        case IFX_SSC_RXTX_MODE_SET: 
    960913                if (from_kernel) 
    961                         tmp = *((unsigned long *) data); 
    962                 else if (copy_from_user ((void *) &tmp, 
    963                                          (void *) data, sizeof (tmp))) { 
     914                        tmp = *((unsigned long *)data); 
     915                else if (copy_from_user((void *)&tmp, 
     916                                        (void *)data, sizeof(tmp))) { 
    964917                        ret_val = -EFAULT; 
    965918                        break; 
    966919                } 
    967                 ret_val = ifx_ssc_rxtx_mode_set (info, tmp); 
     920                ret_val = ifx_ssc_rxtx_mode_set(info, tmp); 
    968921                break; 
    969922        case IFX_SSC_RXTX_MODE_GET: 
     
    971924                        (~(IFX_SSC_CON_RX_OFF | IFX_SSC_CON_TX_OFF)); 
    972925                if (from_kernel) 
    973                         *((unsigned int *) data) = tmp; 
    974                 else if (copy_to_user ((void *) data, 
    975                                        (void *) &tmp, sizeof (tmp))) 
     926                        *((unsigned int *)data) = tmp; 
     927                else if (copy_to_user((void *)data, 
     928                                      (void *)&tmp, sizeof(tmp))) 
    976929                        ret_val = -EFAULT; 
    977930                break; 
    978931 
    979932        case IFX_SSC_ABORT: 
    980                 ifx_ssc_abort (info); 
     933                ifx_ssc_abort(info); 
    981934                break; 
    982935 
    983936        case IFX_SSC_GPO_OUT_SET: 
    984937                if (from_kernel) 
    985                         tmp = *((unsigned long *) data); 
    986                 else if (copy_from_user ((void *) &tmp, 
    987                                          (void *) data, sizeof (tmp))) { 
     938                        tmp = *((unsigned long *)data); 
     939                else if (copy_from_user((void *)&tmp, 
     940                                        (void *)data, sizeof(tmp))) { 
    988941                        ret_val = -EFAULT; 
    989942                        break; 
     
    997950        case IFX_SSC_GPO_OUT_CLR: 
    998951                if (from_kernel) 
    999                         tmp = *((unsigned long *) data); 
    1000                 else if (copy_from_user ((void *) &tmp, (void *) data, sizeof (tmp))) { 
     952                        tmp = *((unsigned long *)data); 
     953                else if (copy_from_user((void *)&tmp, (void *)data, sizeof(tmp))) { 
    1001954                        ret_val = -EFAULT; 
    1002955                        break; 
     
    1004957                if (tmp > IFX_SSC_MAX_GPO_OUT) 
    1005958                        ret_val = -EINVAL; 
    1006                 else { 
     959                else 
    1007960                        ifxmips_w32(1 << (tmp + IFX_SSC_WHBGPOSTAT_CLROUT0_POS), 
    1008961                                 IFXMIPS_SSC_WHBGPOSTAT); 
    1009                 } 
    1010962                break; 
    1011963        case IFX_SSC_GPO_OUT_GET: 
    1012964                tmp = ifxmips_r32(IFXMIPS_SSC_GPOSTAT); 
    1013965                if (from_kernel) 
    1014                         *((unsigned int *) data) = tmp; 
    1015                 else if (copy_to_user ((void *) data, 
    1016                                        (void *) &tmp, sizeof (tmp))) 
     966                        *((unsigned int *)data) = tmp; 
     967                else if (copy_to_user((void *)data, 
     968                                      (void *)&tmp, sizeof(tmp))) 
    1017969                        ret_val = -EFAULT; 
    1018970                break; 
    1019971        case IFX_SSC_FRM_STATUS_GET: 
    1020                 ifx_ssc_frm_status_get (info); 
     972                ifx_ssc_frm_status_get(info); 
    1021973                if (from_kernel) 
    1022                         memcpy ((void *) data, (void *) &info->frm_status, 
    1023                                 sizeof (struct ifx_ssc_frm_status)); 
    1024                 else if (copy_to_user ((void *) data, 
    1025                                        (void *) &info->frm_status, 
    1026                                        sizeof (struct ifx_ssc_frm_status))) 
     974                        memcpy((void *)data, (void *)&info->frm_status, 
     975                                sizeof(struct ifx_ssc_frm_status)); 
     976                else if (copy_to_user((void *)data, 
     977                                      (void *)&info->frm_status, 
     978                                       sizeof(struct ifx_ssc_frm_status))) 
    1027979                        ret_val = -EFAULT; 
    1028980                break; 
    1029981        case IFX_SSC_FRM_CONTROL_GET: 
    1030                 ifx_ssc_frm_control_get (info); 
     982                ifx_ssc_frm_control_get(info); 
    1031983                if (from_kernel) 
    1032                         memcpy ((void *) data, (void *) &info->frm_opts, 
    1033                                 sizeof (struct ifx_ssc_frm_opts)); 
    1034                 else if (copy_to_user ((void *) data, 
    1035                                        (void *) &info->frm_opts, 
    1036                                        sizeof (struct ifx_ssc_frm_opts))) 
     984                        memcpy((void *)data, (void *)&info->frm_opts, 
     985                                sizeof(struct ifx_ssc_frm_opts)); 
     986                else if (copy_to_user((void *)data, 
     987                                      (void *)&info->frm_opts, 
     988                                       sizeof(struct ifx_ssc_frm_opts))) 
    1037989                        ret_val = -EFAULT; 
    1038990                break; 
    1039991        case IFX_SSC_FRM_CONTROL_SET: 
    1040992                if (from_kernel) 
    1041                         memcpy ((void *) &info->frm_opts, (void *) data, 
    1042                                 sizeof (struct ifx_ssc_frm_opts)); 
    1043                 else if (copy_to_user ((void *) &info->frm_opts, 
    1044                                        (void *) data, 
    1045                                        sizeof (struct ifx_ssc_frm_opts))) { 
     993                        memcpy((void *)&info->frm_opts, (void *)data, 
     994                                sizeof(struct ifx_ssc_frm_opts)); 
     995                else if (copy_to_user((void *)&info->frm_opts, 
     996                                      (void *)data, 
     997                                       sizeof(struct ifx_ssc_frm_opts))) { 
    1046998                        ret_val = -EFAULT; 
    1047999                        break; 
    10481000                } 
    1049                 ret_val = ifx_ssc_frm_control_set (info); 
     1001                ret_val = ifx_ssc_frm_control_set(info); 
    10501002                break; 
    10511003        case IFX_SSC_HWOPTS_SET: 
     
    10541006                /* busy and we shouldn't change things on-the-fly! */ 
    10551007                if (!info->txbuf || !info->rxbuf || 
    1056                     (ifxmips_r32(IFXMIPS_SSC_STATE) 
     1008                   (ifxmips_r32(IFXMIPS_SSC_STATE) 
    10571009                     & IFX_SSC_STATE_BUSY)) { 
    10581010                        ret_val = -EBUSY; 
     
    10601012                } 
    10611013                if (from_kernel) 
    1062                         memcpy ((void *) &info->opts, (void *) data, 
    1063                                 sizeof (struct ifx_ssc_hwopts)); 
    1064                 else if (copy_from_user ((void *) &info->opts, 
    1065                                          (void *) data, sizeof(struct ifx_ssc_hwopts))) { 
     1014                        memcpy((void *)&info->opts, (void *)data, 
     1015                                sizeof(struct ifx_ssc_hwopts)); 
     1016                else if (copy_from_user((void *)&info->opts, 
     1017                                        (void *)data, sizeof(struct ifx_ssc_hwopts))) { 
    10661018                        ret_val = -EFAULT; 
    10671019                        break; 
    10681020                } 
    1069                 if (ifx_ssc_hwinit (info) < 0) { 
     1021                if (ifx_ssc_hwinit(info) < 0) 
    10701022                        ret_val = -EIO; 
    1071                 } 
    10721023                break; 
    10731024        case IFX_SSC_HWOPTS_GET: 
    10741025                /* data must be a pointer to a struct ifx_ssc_hwopts */ 
    10751026                if (from_kernel) 
    1076                         memcpy ((void *) data, (void *) &info->opts, 
    1077                                 sizeof (struct ifx_ssc_hwopts)); 
    1078                 else if (copy_to_user ((void *) data, 
    1079                                        (void *) &info->opts, 
    1080                                        sizeof (struct ifx_ssc_hwopts))) 
     1027                        memcpy((void *)data, (void *)&info->opts, 
     1028                                sizeof(struct ifx_ssc_hwopts)); 
     1029                else if (copy_to_user((void *)data, 
     1030                                      (void *)&info->opts, 
     1031                                       sizeof(struct ifx_ssc_hwopts))) 
    10811032                        ret_val = -EFAULT; 
    10821033                break; 
     
    10901041 
    10911042static struct file_operations ifx_ssc_fops = { 
    1092       .owner = THIS_MODULE, 
    1093       .read = ifx_ssc_read, 
    1094       .write = ifx_ssc_write, 
    1095       .ioctl = ifx_ssc_ioctl, 
    1096       .open = ifx_ssc_open, 
    1097       .release = ifx_ssc_close, 
     1043        .owner = THIS_MODULE, 
     1044        .read = ifx_ssc_read, 
     1045        .write = ifx_ssc_write, 
     1046        .ioctl = ifx_ssc_ioctl, 
     1047        .open = ifx_ssc_open, 
     1048        .release = ifx_ssc_close, 
    10981049}; 
    10991050 
    1100 int __init 
    1101 ifx_ssc_init (void) 
     1051int __init ifx_ssc_init(void) 
    11021052{ 
    11031053        struct ifx_ssc_port *info; 
     
    11081058        ret_val = -ENOMEM; 
    11091059        nbytes = PORT_CNT * sizeof(struct ifx_ssc_port); 
    1110         isp = (struct ifx_ssc_port*)kmalloc(nbytes, GFP_KERNEL); 
    1111  
    1112         if (isp == NULL) 
    1113         { 
     1060        isp = kmalloc(nbytes, GFP_KERNEL); 
     1061 
     1062        if (isp == NULL) { 
    11141063                printk("%s: no memory for isp\n", __func__); 
    1115                 return (ret_val); 
     1064                return ret_val; 
    11161065        } 
    11171066        memset(isp, 0, nbytes); 
    11181067 
    11191068        ret_val = -ENXIO; 
    1120         if ((i = register_chrdev (maj, "ssc", &ifx_ssc_fops)) < 0) 
    1121         { 
    1122                 printk ("Unable to register major %d for the Infineon SSC\n", maj); 
    1123                 if (maj == 0) 
    1124                 { 
     1069        i = register_chrdev(maj, "ssc", &ifx_ssc_fops); 
     1070        if (i < 0) { 
     1071                printk("Unable to register major %d for the Infineon SSC\n", maj); 
     1072                if (maj == 0) { 
    11251073                        goto errout; 
    11261074                } else { 
    11271075                        maj = 0; 
    1128                         if ((i = register_chrdev (maj, "ssc", &ifx_ssc_fops)) < 0) 
    1129                         { 
    1130                                 printk ("Unable to register major %d for the Infineon SSC\n", maj); 
     1076                        i = register_chrdev(maj, "ssc", &ifx_ssc_fops); 
     1077                        if (i < 0) { 
     1078                                printk("Unable to register major %d for the Infineon SSC\n", maj); 
    11311079                                goto errout; 
    11321080                        } 
     
    11621110                info->txbuf = NULL; 
    11631111                /* values specific to SSC1 */ 
    1164                 if (i == 0) { 
     1112                if (i == 0) 
    11651113                        info->mapbase = IFXMIPS_SSC_BASE_ADDR; 
    1166                 } 
    11671114 
    11681115                ifxmips_w32(IFX_SSC_DEF_RMC << IFX_CLC_RUN_DIVIDER_OFFSET, IFXMIPS_SSC_CLC); 
    11691116 
    1170                 init_waitqueue_head (&info->rwait); 
    1171  
    1172                 local_irq_save (flags); 
    1173  
    1174                 // init serial framing register 
     1117                init_waitqueue_head(&info->rwait); 
     1118 
     1119                local_irq_save(flags); 
     1120 
     1121                /* init serial framing register */ 
    11751122                ifxmips_w32(IFX_SSC_DEF_SFCON, IFXMIPS_SSC_SFCON); 
    11761123 
    11771124                ret_val = request_irq(IFXMIPS_SSC_TIR, ifx_ssc_tx_int, IRQF_DISABLED, "ifx_ssc_tx", info); 
    1178                 if (ret_val) 
    1179                 { 
     1125                if (ret_val) { 
    11801126                        printk("%s: unable to get irq %d\n", __func__, IFXMIPS_SSC_TIR); 
    11811127                        local_irq_restore(flags); 
     
    11841130 
    11851131                ret_val = request_irq(IFXMIPS_SSC_RIR, ifx_ssc_rx_int, IRQF_DISABLED, "ifx_ssc_rx", info); 
    1186                 if (ret_val) 
    1187                 { 
    1188                         printk ("%s: unable to get irq %d\n", __func__, IFXMIPS_SSC_RIR); 
    1189                         local_irq_restore (flags); 
     1132                if (ret_val) { 
     1133                        printk("%s: unable to get irq %d\n", __func__, IFXMIPS_SSC_RIR); 
     1134                        local_irq_restore(flags); 
    11901135                        goto irqerr; 
    11911136                } 
    11921137 
    11931138                ret_val = request_irq(IFXMIPS_SSC_EIR, ifx_ssc_err_int, IRQF_DISABLED, "ifx_ssc_err", info); 
    1194                 if (ret_val) 
    1195                 { 
    1196                         printk ("%s: unable to get irq %d\n", __func__, IFXMIPS_SSC_EIR); 
    1197                         local_irq_restore (flags); 
     1139                if (ret_val) { 
     1140                        printk("%s: unable to get irq %d\n", __func__, IFXMIPS_SSC_EIR); 
     1141                        local_irq_restore(flags); 
    11981142                        goto irqerr; 
    11991143                } 
    12001144                ifxmips_w32(IFX_SSC_DEF_IRNEN, IFXMIPS_SSC_IRN); 
    12011145 
    1202                 //enable_irq(IFXMIPS_SSC_TIR); 
    1203                 //enable_irq(IFXMIPS_SSC_RIR); 
    1204                 //enable_irq(IFXMIPS_SSC_EIR); 
    1205  
    1206                 local_irq_restore (flags); 
     1146                #if 0 
     1147                enable_irq(IFXMIPS_SSC_TIR); 
     1148                enable_irq(IFXMIPS_SSC_RIR); 
     1149                enable_irq(IFXMIPS_SSC_EIR); 
     1150                #endif 
     1151 
     1152                local_irq_restore(flags); 
    12071153        } 
    12081154 
    12091155        for (i = 0; i < PORT_CNT; i++) { 
    12101156                info = &isp[i]; 
    1211                 if (ifx_ssc_hwinit (info) < 0) 
    1212                 { 
    1213                         printk ("%s: hardware init failed for port %d\n", __func__, i); 
     1157                if (ifx_ssc_hwinit(info) < 0) { 
     1158                        printk("%s: hardware init failed for port %d\n", __func__, i); 
    12141159                        goto irqerr; 
    12151160                } 
     
    12241169        free_irq(IFXMIPS_SSC_EIR, &isp[0]); 
    12251170errout: 
    1226         kfree (isp); 
    1227         return (ret_val); 
    1228 } 
    1229  
    1230 void 
    1231 ifx_ssc_cleanup_module (void) 
     1171        kfree(isp); 
     1172        return ret_val; 
     1173} 
     1174 
     1175void __exit ifx_ssc_cleanup_module(void) 
    12321176{ 
    12331177        int i; 
     
    12391183                free_irq(IFXMIPS_SSC_EIR, &isp[i]); 
    12401184        } 
    1241         kfree (isp); 
     1185        kfree(isp); 
    12421186} 
    12431187 
     
    12451189module_exit(ifx_ssc_cleanup_module); 
    12461190 
    1247  
    1248 inline int 
    1249 ifx_ssc_cs_low (u32 pin) 
     1191inline int ifx_ssc_cs_low(u32 pin) 
    12501192{ 
    12511193        int ret = 0; 
    1252         if ((ret = ifx_ssc_ioctl ((struct inode *) 0, NULL, IFX_SSC_GPO_OUT_CLR, (unsigned long) &pin))) 
    1253                 printk ("clear CS %d fails\n", pin); 
    1254         wmb (); 
     1194        ret = ifx_ssc_ioctl((struct inode *)0, NULL, IFX_SSC_GPO_OUT_CLR, (unsigned long) &pin); 
     1195        if (ret) 
     1196                printk("clear CS %d fails\n", pin); 
     1197        wmb(); 
    12551198 
    12561199        return ret; 
     
    12581201EXPORT_SYMBOL(ifx_ssc_cs_low); 
    12591202 
    1260 inline int 
    1261 ifx_ssc_cs_high (u32 pin) 
     1203inline int ifx_ssc_cs_high(u32 pin) 
    12621204{ 
    12631205        int ret = 0; 
    1264         if ((ret = ifx_ssc_ioctl((struct inode *) 0, NULL, IFX_SSC_GPO_OUT_SET, (unsigned long) &pin))) 
    1265                 printk ("set CS %d fails\n", pin); 
    1266         wmb (); 
     1206        ret = ifx_ssc_ioctl((struct inode *)0, NULL, IFX_SSC_GPO_OUT_SET, (unsigned long) &pin); 
     1207        if (ret) 
     1208                printk("set CS %d fails\n", pin); 
     1209        wmb(); 
    12671210 
    12681211        return ret; 
     
    12701213EXPORT_SYMBOL(ifx_ssc_cs_high); 
    12711214 
    1272 static int 
    1273 ssc_session (char *tx_buf, u32 tx_len, char *rx_buf, u32 rx_len) 
     1215static int ssc_session(char *tx_buf, u32 tx_len, char *rx_buf, u32 rx_len) 
    12741216{ 
    12751217        int ret = 0; 
     
    12811223 
    12821224        if (tx_buf == NULL && tx_len == 0 && rx_buf == NULL && rx_len == 0) { 
    1283                 printk ("invalid parameters\n"); 
     1225                printk("invalid parameters\n"); 
    12841226                ret = -EINVAL; 
    12851227                goto ssc_session_exit; 
    1286         } 
    1287         else if (tx_buf == NULL || tx_len == 0) { 
     1228        } else if (tx_buf == NULL || tx_len == 0) { 
    12881229                if (rx_buf != NULL && rx_len != 0) { 
    12891230                        mode = IFX_SSC_MODE_RX; 
    1290                 } 
    1291                 else { 
    1292                         printk ("invalid parameters\n"); 
     1231                } else { 
     1232                        printk("invalid parameters\n"); 
    12931233                        ret = -EINVAL; 
    12941234                        goto ssc_session_exit; 
    12951235                } 
    1296         } 
    1297         else if (rx_buf == NULL || rx_len == 0) { 
    1298                 if (tx_buf != NULL && tx_len != 0) { 
     1236        } else if (rx_buf == NULL || rx_len == 0) { 
     1237                if (tx_buf != NULL && tx_len != 0) 
    12991238                        mode = IFX_SSC_MODE_TX; 
    1300                 } 
    13011239                else { 
    1302                         printk ("invalid parameters\n"); 
     1240                        printk("invalid parameters\n"); 
    13031241                        ret = -EINVAL; 
    13041242                        goto ssc_session_exit; 
    13051243                } 
    1306         } 
    1307         else { 
     1244        } else 
    13081245                mode = IFX_SSC_MODE_RXTX; 
    1309         } 
    1310  
    1311         if (mode == IFX_SSC_MODE_RXTX) { 
     1246 
     1247        if (mode == IFX_SSC_MODE_RXTX) 
    13121248                eff_size = tx_len + rx_len; 
    1313         } 
    1314         else if (mode == IFX_SSC_MODE_RX) { 
     1249        else if (mode == IFX_SSC_MODE_RX) 
    13151250                eff_size = rx_len; 
    1316         } 
    1317         else { 
     1251        else 
    13181252                eff_size = tx_len; 
    1319         } 
    13201253 
    13211254        //4 bytes alignment,  required by driver 
     
    13231256        //if (in_irq()){ 
    13241257        if (1) { 
    1325                 ssc_tx_buf = 
    1326                         (char *) kmalloc (sizeof (char) * 
    1327                                           ((eff_size + 3) & (~3)), 
     1258                ssc_tx_buf = kmalloc(sizeof(char) * 
     1259                                         ((eff_size + 3) & (~3)), 
    13281260                                          GFP_ATOMIC); 
    1329                 ssc_rx_buf = 
    1330                         (char *) kmalloc (sizeof (char) * 
    1331                                           ((eff_size + 3) & (~3)), 
     1261                ssc_rx_buf = kmalloc(sizeof(char) * 
     1262                                         ((eff_size + 3) & (~3)), 
    13321263                                          GFP_ATOMIC); 
    1333         } 
    1334         else { 
    1335                 ssc_tx_buf = 
    1336                         (char *) kmalloc (sizeof (char) * 
    1337                                           ((eff_size + 3) & (~3)), 
     1264        } else { 
     1265                ssc_tx_buf = kmalloc(sizeof(char) * 
     1266                                         ((eff_size + 3) & (~3)), 
    13381267                                          GFP_KERNEL); 
    1339                 ssc_rx_buf = 
    1340                         (char *) kmalloc (sizeof (char) * 
    1341                                           ((eff_size + 3) & (~3)), 
     1268                ssc_rx_buf = kmalloc(sizeof(char) * 
     1269                                         ((eff_size + 3) & (~3)), 
    13421270                                          GFP_KERNEL); 
    13431271        } 
    13441272        if (ssc_tx_buf == NULL || ssc_rx_buf == NULL) { 
    1345                 printk ("no memory for size of %d\n", eff_size); 
     1273                printk("no memory for size of %d\n", eff_size); 
    13461274                ret = -ENOMEM; 
    13471275                goto ssc_session_exit; 
    13481276        } 
    1349         memset ((void *) ssc_tx_buf, 0, eff_size); 
    1350         memset ((void *) ssc_rx_buf, 0, eff_size); 
    1351  
    1352         if (tx_len > 0) { 
    1353                 memcpy (ssc_tx_buf, tx_buf, tx_len); 
    1354         } 
    1355  
    1356         ret = ifx_ssc_kwrite (0, ssc_tx_buf, eff_size); 
    1357  
    1358         if (ret > 0) { 
    1359                 ssc_tx_buf = NULL;      //should be freed by ifx_ssc_kwrite 
    1360         } 
     1277        memset((void *)ssc_tx_buf, 0, eff_size); 
     1278        memset((void *)ssc_rx_buf, 0, eff_size); 
     1279 
     1280        if (tx_len > 0) 
     1281                memcpy(ssc_tx_buf, tx_buf, tx_len); 
     1282 
     1283        ret = ifx_ssc_kwrite(0, ssc_tx_buf, eff_size); 
     1284 
     1285        if (ret > 0) 
     1286                ssc_tx_buf = NULL;      /* should be freed by ifx_ssc_kwrite */ 
    13611287 
    13621288        if (ret != eff_size) { 
    1363                 printk ("ifx_ssc_write return %d\n", ret); 
     1289                printk("ifx_ssc_write return %d\n", ret); 
    13641290                goto ssc_session_exit; 
    13651291        } 
    1366         ret = ifx_ssc_kread (0, ssc_rx_buf, eff_size); 
     1292        ret = ifx_ssc_kread(0, ssc_rx_buf, eff_size); 
    13671293        if (ret != eff_size) { 
    1368                 printk ("ifx_ssc_read return %d\n", ret); 
     1294                printk("ifx_ssc_read return %d\n", ret); 
    13691295                goto ssc_session_exit; 
    13701296        } 
    13711297 
    1372         memcpy (rx_buf, ssc_rx_buf + tx_len, rx_len); 
    1373  
    1374         if (mode == IFX_SSC_MODE_TX) { 
     1298        memcpy(rx_buf, ssc_rx_buf + tx_len, rx_len); 
     1299 
     1300        if (mode == IFX_SSC_MODE_TX) 
    13751301                ret = tx_len; 
    1376         } 
    1377         else { 
     1302        else 
    13781303                ret = rx_len; 
    1379         } 
    1380       ssc_session_exit: 
    1381  
     1304 
     1305ssc_session_exit: 
    13821306        if (ssc_tx_buf != NULL) 
    1383                 kfree (ssc_tx_buf); 
     1307                kfree(ssc_tx_buf); 
    13841308        if (ssc_rx_buf != NULL) 
    1385                 kfree (ssc_rx_buf); 
    1386  
    1387         if (ret < 0) { 
    1388                 printk ("ssc session fails\n"); 
    1389         } 
     1309                kfree(ssc_rx_buf); 
     1310 
     1311        if (ret < 0) 
     1312                printk("ssc session fails\n"); 
     1313 
    13901314        return ret; 
    13911315} 
    13921316 
    1393 int 
    1394 ifx_ssc_txrx (char *tx_buf, u32 tx_len, char *rx_buf, u32 rx_len) 
     1317int ifx_ssc_txrx(char *tx_buf, u32 tx_len, char *rx_buf, u32 rx_len) 
    13951318{ 
    13961319        return ssc_session(tx_buf, tx_len, rx_buf, rx_len); 
     
    13981321EXPORT_SYMBOL(ifx_ssc_txrx); 
    13991322 
    1400 int 
    1401 ifx_ssc_tx (char *tx_buf, u32 tx_len) 
     1323int ifx_ssc_tx(char *tx_buf, u32 tx_len) 
    14021324{ 
    14031325        return ssc_session(tx_buf, tx_len, NULL, 0); 
     
    14051327EXPORT_SYMBOL(ifx_ssc_tx); 
    14061328 
    1407 int 
    1408 ifx_ssc_rx (char *rx_buf, u32 rx_len) 
     1329int ifx_ssc_rx(char *rx_buf, u32 rx_len) 
    14091330{ 
    14101331        return ssc_session(NULL, 0, rx_buf, rx_len); 
  • trunk/target/linux/ifxmips/files/drivers/leds/leds-ifxmips.c

    r11596 r13660  
    2626#include <linux/init.h> 
    2727#include <linux/platform_device.h> 
    28 #include <asm/uaccess.h> 
    29 #include <asm/unistd.h> 
     28#include <linux/uaccess.h> 
     29#include <linux/unistd.h> 
    3030#include <linux/errno.h> 
     31#include <linux/leds.h> 
     32#include <linux/delay.h> 
     33 
    3134#include <asm/ifxmips/ifxmips.h> 
    3235#include <asm/ifxmips/ifxmips_gpio.h> 
    3336#include <asm/ifxmips/ifxmips_pmu.h> 
    34 #include <linux/leds.h> 
    35 #include <linux/delay.h> 
    3637 
    37 #define DRVNAME                                                 "ifxmips_led" 
     38#define DRVNAME                                 "ifxmips_led" 
    3839 
    3940#define IFXMIPS_LED_CLK_EDGE                    IFXMIPS_LED_FALLING 
    4041//#define IFXMIPS_LED_CLK_EDGE                  IFXMIPS_LED_RISING 
    4142 
    42 #define IFXMIPS_LED_SPEED                               IFXMIPS_LED_8HZ 
     43#define IFXMIPS_LED_SPEED                       IFXMIPS_LED_8HZ 
    4344 
    4445#define IFXMIPS_LED_GPIO_PORT                   0 
    4546 
    46 #define IFXMIPS_MAX_LED                                 24 
     47#define IFXMIPS_MAX_LED                         24 
    4748 
    4849struct ifxmips_led { 
     
    5152}; 
    5253 
    53 void 
    54 ifxmips_led_set (unsigned int led) 
     54void ifxmips_led_set (unsigned int led) 
    5555{ 
    5656        led &= 0xffffff; 
     
    5959EXPORT_SYMBOL(ifxmips_led_set); 
    6060 
    61 void 
    62 ifxmips_led_clear (unsigned int led) 
     61void ifxmips_led_clear (unsigned int led) 
    6362{ 
    6463        led = ~(led & 0xffffff); 
     
    6766EXPORT_SYMBOL(ifxmips_led_clear); 
    6867 
    69 void 
    70 ifxmips_led_blink_set (unsigned int led) 
     68void ifxmips_led_blink_set (unsigned int led) 
    7169{ 
    7270        led &= 0xffffff; 
     
    7573EXPORT_SYMBOL(ifxmips_led_blink_set); 
    7674 
    77 void 
    78 ifxmips_led_blink_clear (unsigned int led) 
     75void ifxmips_led_blink_clear (unsigned int led) 
    7976{ 
    8077        led = ~(led & 0xffffff); 
     
    8380EXPORT_SYMBOL(ifxmips_led_blink_clear); 
    8481 
    85 void 
    86 ifxmips_ledapi_set(struct led_classdev *led_cdev, enum led_brightness value) 
     82void ifxmips_ledapi_set(struct led_classdev *led_cdev, enum led_brightness value) 
    8783{ 
    8884        struct ifxmips_led *led_dev = container_of(led_cdev, struct ifxmips_led, cdev); 
     
    9490} 
    9591 
    96 void 
    97 ifxmips_led_setup_gpio (void) 
     92void ifxmips_led_setup_gpio (void) 
    9893{ 
    9994        int i = 0; 
    10095 
    10196        /* we need to setup pins SH,D,ST (4,5,6) */ 
    102         for (i = 4; i < 7; i++) 
    103         { 
     97        for (i = 4; i < 7; i++) { 
    10498                ifxmips_port_set_altsel0(IFXMIPS_LED_GPIO_PORT, i); 
    10599                ifxmips_port_clear_altsel1(IFXMIPS_LED_GPIO_PORT, i); 
     
    109103} 
    110104 
    111 static int 
    112 ifxmips_led_probe(struct platform_device *dev) 
     105static int ifxmips_led_probe(struct platform_device *dev) 
    113106{ 
    114107        int i = 0; 
     
    143136        ifxmips_pmu_enable(IFXMIPS_PMU_PWDCR_LED); 
    144137 
    145         for(i = 0; i < IFXMIPS_MAX_LED; i++) 
    146         { 
     138        for (i = 0; i < IFXMIPS_MAX_LED; i++) { 
    147139                struct ifxmips_led *tmp = kzalloc(sizeof(struct ifxmips_led), GFP_KERNEL); 
    148140                tmp->cdev.brightness_set = ifxmips_ledapi_set; 
    149141                tmp->cdev.name = kmalloc(sizeof("ifxmips:led:00"), GFP_KERNEL); 
    150                 sprintf((char*)tmp->cdev.name, "ifxmips:led:%02d", i); 
     142                sprintf((char *)tmp->cdev.name, "ifxmips:led:%02d", i); 
    151143                tmp->cdev.default_trigger = NULL; 
    152144                tmp->bit = i; 
     
    157149} 
    158150 
    159 static int 
    160 ifxmips_led_remove(struct platform_device *pdev) 
     151static int ifxmips_led_remove(struct platform_device *pdev) 
    161152{ 
    162153        return 0; 
    163154} 
    164155 
    165 static struct 
    166 platform_driver ifxmips_led_driver = { 
     156static struct platform_driver ifxmips_led_driver = { 
    167157        .probe = ifxmips_led_probe, 
    168158        .remove = ifxmips_led_remove, 
     
    173163}; 
    174164 
    175 int __init 
    176 ifxmips_led_init (void) 
     165int __init ifxmips_led_init (void) 
    177166{ 
    178167        int ret = platform_driver_register(&ifxmips_led_driver); 
     
    183172} 
    184173 
    185 void __exit 
    186 ifxmips_led_exit (void) 
     174void __exit ifxmips_led_exit (void) 
    187175{ 
    188176        platform_driver_unregister(&ifxmips_led_driver); 
  • trunk/target/linux/ifxmips/files/drivers/mtd/maps/ifxmips.c

    r13295 r13660  
    2727#include <linux/mtd/partitions.h> 
    2828#include <linux/mtd/cfi.h> 
     29#include <linux/magic.h> 
     30#include <linux/platform_device.h> 
     31 
    2932#include <asm/ifxmips/ifxmips.h> 
    3033#include <asm/ifxmips/ifxmips_prom.h> 
    3134#include <asm/ifxmips/ifxmips_ebu.h> 
    32 #include <linux/magic.h> 
    33 #include <linux/platform_device.h> 
    3435 
    3536#ifndef CONFIG_MTD_PARTITIONS 
  • trunk/target/linux/ifxmips/files/drivers/net/ifxmips_mii0.c

    r13295 r13660  
    4949static unsigned char mac_addr[MAX_ADDR_LEN]; 
    5050 
    51 void 
    52 ifxmips_write_mdio(u32 phy_addr, u32 phy_reg, u16 phy_data) 
     51void ifxmips_write_mdio(u32 phy_addr, u32 phy_reg, u16 phy_data) 
    5352{ 
    5453        u32 val = MDIO_ACC_REQUEST | 
     
    5756                phy_data; 
    5857 
    59         while(ifxmips_r32(IFXMIPS_PPE32_MDIO_ACC) & MDIO_ACC_REQUEST); 
     58        while (ifxmips_r32(IFXMIPS_PPE32_MDIO_ACC) & MDIO_ACC_REQUEST); 
    6059        ifxmips_w32(val, IFXMIPS_PPE32_MDIO_ACC); 
    6160} 
    6261EXPORT_SYMBOL(ifxmips_write_mdio); 
    6362 
    64 unsigned short 
    65 ifxmips_read_mdio(u32 phy_addr, u32 phy_reg) 
     63unsigned short ifxmips_read_mdio(u32 phy_addr, u32 phy_reg) 
    6664{ 
    6765        u32 val = MDIO_ACC_REQUEST | MDIO_ACC_READ | 
     
    6967                ((phy_reg & MDIO_ACC_REG_MASK) << MDIO_ACC_REG_OFFSET); 
    7068 
    71         while(ifxmips_r32(IFXMIPS_PPE32_MDIO_ACC) & MDIO_ACC_REQUEST); 
     69        while (ifxmips_r32(IFXMIPS_PPE32_MDIO_ACC) & MDIO_ACC_REQUEST) ; 
    7270        ifxmips_w32(val, IFXMIPS_PPE32_MDIO_ACC); 
    73         while(ifxmips_r32(IFXMIPS_PPE32_MDIO_ACC) & MDIO_ACC_REQUEST){}; 
     71        while (ifxmips_r32(IFXMIPS_PPE32_MDIO_ACC) & MDIO_ACC_REQUEST) ; 
    7472        val = ifxmips_r32(IFXMIPS_PPE32_MDIO_ACC) & MDIO_ACC_VAL_MASK; 
    7573        return val; 
     
    7775EXPORT_SYMBOL(ifxmips_read_mdio); 
    7876 
    79 int 
    80 ifxmips_ifxmips_mii_open(struct net_device *dev) 
    81 { 
    82         struct ifxmips_mii_priv* priv = (struct ifxmips_mii_priv*)dev->priv; 
    83         struct dma_device_info* dma_dev = priv->dma_device; 
    84         int i; 
    85  
    86         for (i = 0; i < dma_dev->max_rx_chan_num; i++) 
    87         { 
     77int ifxmips_ifxmips_mii_open(struct net_device *dev) 
     78{ 
     79        struct ifxmips_mii_priv *priv = (struct ifxmips_mii_priv *)dev->priv; 
     80        struct dma_device_info *dma_dev = priv->dma_device; 
     81        int i; 
     82 
     83        for (i = 0; i < dma_dev->max_rx_chan_num; i++) { 
    8884                if ((dma_dev->rx_chan[i])->control == IFXMIPS_DMA_CH_ON) 
    8985                        (dma_dev->rx_chan[i])->open(dma_dev->rx_chan[i]); 
     
    9389} 
    9490 
    95 int 
    96 ifxmips_mii_release(struct net_device *dev){ 
    97         struct ifxmips_mii_priv* priv = (struct ifxmips_mii_priv*)dev->priv; 
    98         struct dma_device_info* dma_dev = priv->dma_device; 
     91int ifxmips_mii_release(struct net_device *dev) 
     92{ 
     93        struct ifxmips_mii_priv *priv = (struct ifxmips_mii_priv *)dev->priv; 
     94        struct dma_device_info *dma_dev = priv->dma_device; 
    9995        int i; 
    10096 
     
    105101} 
    106102 
    107 int 
    108 ifxmips_mii_hw_receive(struct net_device* dev,struct dma_device_info* dma_dev) 
    109 { 
    110         struct ifxmips_mii_priv *priv = (struct ifxmips_mii_priv*)dev->priv; 
    111         unsigned char* buf = NULL; 
     103int ifxmips_mii_hw_receive(struct net_device *dev, struct dma_device_info *dma_dev) 
     104{ 
     105        struct ifxmips_mii_priv *priv = (struct ifxmips_mii_priv *)dev->priv; 
     106        unsigned char *buf = NULL; 
    112107        struct sk_buff *skb = NULL; 
    113108        int len = 0; 
    114109 
    115         len = dma_device_read(dma_dev, &buf, (void**)&skb); 
    116  
    117         if (len >= ETHERNET_PACKET_DMA_BUFFER_SIZE) 
    118         { 
    119                 printk(KERN_INFO "ifxmips_mii0: packet too large %d\n",len); 
     110        len = dma_device_read(dma_dev, &buf, (void **)&skb); 
     111 
     112        if (len >= ETHERNET_PACKET_DMA_BUFFER_SIZE) { 
     113                printk(KERN_INFO "ifxmips_mii0: packet too large %d\n", len); 
    120114                goto ifxmips_mii_hw_receive_err_exit; 
    121115        } 
     
    123117        /* remove CRC */ 
    124118        len -= 4; 
    125         if (skb == NULL) 
    126         { 
     119        if (skb == NULL) { 
    127120                printk(KERN_INFO "ifxmips_mii0: cannot restore pointer\n"); 
    128121                goto ifxmips_mii_hw_receive_err_exit; 
    129122        } 
    130123 
    131         if (len > (skb->end - skb->tail)) 
    132         { 
     124        if (len > (skb->end - skb->tail)) { 
    133125                printk(KERN_INFO "ifxmips_mii0: BUG, len:%d end:%p tail:%p\n", 
    134126                        (len+4), skb->end, skb->tail); 
     
    146138 
    147139ifxmips_mii_hw_receive_err_exit: 
    148         if (len == 0) 
    149         { 
     140        if (len == 0) { 
    150141                if (skb) 
    151142                        dev_kfree_skb_any(skb); 
     
    158149} 
    159150 
    160 int 
    161 ifxmips_mii_hw_tx(char *buf, int len, struct net_device *dev) 
     151int ifxmips_mii_hw_tx(char *buf, int len, struct net_device *dev) 
    162152{ 
    163153        int ret = 0; 
    164154        struct ifxmips_mii_priv *priv = dev->priv; 
    165         struct dma_device_info* dma_dev = priv->dma_device; 
     155        struct dma_device_info *dma_dev = priv->dma_device; 
    166156        ret = dma_device_write(dma_dev, buf, len, priv->skb); 
    167157        return ret; 
    168158} 
    169159 
    170 int 
    171 ifxmips_mii_tx(struct sk_buff *skb, struct net_device *dev) 
     160int ifxmips_mii_tx(struct sk_buff *skb, struct net_device *dev) 
    172161{ 
    173162        int len; 
    174163        char *data; 
    175164        struct ifxmips_mii_priv *priv = dev->priv; 
    176         struct dma_device_info* dma_dev = priv->dma_device; 
     165        struct dma_device_info *dma_dev = priv->dma_device; 
    177166 
    178167        len = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len; 
     
    180169        priv->skb = skb; 
    181170        dev->trans_start = jiffies; 
    182         // TODO we got more than 1 dma channel, so we should do something intelligent 
    183         // here to select one 
     171        /* TODO: we got more than 1 dma channel, 
     172           so we should do something intelligent here to select one */ 
    184173        dma_dev->current_tx_chan = 0; 
    185174 
    186175        wmb(); 
    187176 
    188         if (ifxmips_mii_hw_tx(data, len, dev) != len) 
    189         { 
     177        if (ifxmips_mii_hw_tx(data, len, dev) != len) { 
    190178                dev_kfree_skb_any(skb); 
    191179                priv->stats.tx_errors++; 
     
    193181        } else { 
    194182                priv->stats.tx_packets++; 
    195                 priv->stats.tx_bytes+=len; 
    196         } 
    197  
    198         return 0; 
    199 } 
    200  
    201 void 
    202 ifxmips_mii_tx_timeout(struct net_device *dev) 
    203 { 
    204         int i; 
    205         struct ifxmips_mii_priv* priv = (struct ifxmips_mii_priv*)dev->priv; 
     183                priv->stats.tx_bytes += len; 
     184        } 
     185 
     186        return 0; 
     187} 
     188 
     189void ifxmips_mii_tx_timeout(struct net_device *dev) 
     190{ 
     191        int i; 
     192        struct ifxmips_mii_priv *priv = (struct ifxmips_mii_priv *)dev->priv; 
    206193 
    207194        priv->stats.tx_errors++; 
     
    212199} 
    213200 
    214 int 
    215 dma_intr_handler(struct dma_device_info* dma_dev, int status) 
    216 { 
    217         int i; 
    218  
    219         switch(status) 
    220         { 
     201int dma_intr_handler(struct dma_device_info *dma_dev, int status) 
     202{ 
     203        int i; 
     204 
     205        switch (status) { 
    221206        case RCV_INT: 
    222207                ifxmips_mii_hw_receive(ifxmips_mii0_dev, dma_dev); 
     
    226211                printk(KERN_INFO "ifxmips_mii0: tx buffer full\n"); 
    227212                netif_stop_queue(ifxmips_mii0_dev); 
    228                 for (i = 0; i < dma_dev->max_tx_chan_num; i++) 
    229                 { 
    230                         if ((dma_dev->tx_chan[i])->control==IFXMIPS_DMA_CH_ON) 
     213                for (i = 0; i < dma_dev->max_tx_chan_num; i++) { 
     214                        if ((dma_dev->tx_chan[i])->control == IFXMIPS_DMA_CH_ON) 
    231215                                dma_dev->tx_chan[i]->enable_irq(dma_dev->tx_chan[i]); 
    232216                } 
     
    244228} 
    245229 
    246 unsigned char* 
    247 ifxmips_etop_dma_buffer_alloc(int len, int *byte_offset, void **opt) 
     230unsigned char *ifxmips_etop_dma_buffer_alloc(int len, int *byte_offset, void **opt) 
    248231{ 
    249232        unsigned char *buffer = NULL; 
     
    254237                return NULL; 
    255238 
    256         buffer = (unsigned char*)(skb->data); 
     239        buffer = (unsigned char *)(skb->data); 
    257240        skb_reserve(skb, 2); 
    258         *(int*)opt = (int)skb; 
     241        *(int *)opt = (int)skb; 
    259242        *byte_offset = 2; 
    260243 
     
    262245} 
    263246 
    264 void 
    265 ifxmips_etop_dma_buffer_free(unsigned char *dataptr, void *opt) 
     247void ifxmips_etop_dma_buffer_free(unsigned char *dataptr, void *opt) 
    266248{ 
    267249        struct sk_buff *skb = NULL; 
    268250 
    269         if (opt == NULL) 
    270         { 
     251        if (opt == NULL) { 
    271252                kfree(dataptr); 
    272253        } else { 
    273                 skb = (struct sk_buff*)opt; 
     254                skb = (struct sk_buff *)opt; 
    274255                dev_kfree_skb_any(skb); 
    275256        } 
    276257} 
    277258 
    278 static struct net_device_stats* 
    279 ifxmips_get_stats(struct net_device *dev) 
     259static struct net_device_stats *ifxmips_get_stats(struct net_device *dev) 
    280260{ 
    281261        return (struct net_device_stats *)dev->priv; 
    282262} 
    283263 
    284 static int 
    285 ifxmips_mii_dev_init(struct net_device *dev) 
     264static int ifxmips_mii_dev_init(struct net_device *dev) 
    286265{ 
    287266        int i; 
     
    299278        priv = dev->priv; 
    300279        priv->dma_device = dma_device_reserve("PPE"); 
    301         if (!priv->dma_device){ 
     280        if (!priv->dma_device) { 
    302281                BUG(); 
    303282                return -ENODEV; 
     
    308287        priv->dma_device->max_rx_chan_num = 4; 
    309288 
    310         for (i = 0; i < priv->dma_device->max_rx_chan_num; i++) 
    311         { 
     289        for (i = 0; i < priv->dma_device->max_rx_chan_num; i++) { 
    312290                priv->dma_device->rx_chan[i]->packet_size = ETHERNET_PACKET_DMA_BUFFER_SIZE; 
    313291                priv->dma_device->rx_chan[i]->control = IFXMIPS_DMA_CH_ON; 
     
    323301 
    324302        printk(KERN_INFO "ifxmips_mii0: using mac="); 
    325         for (i = 0; i < 6; i++) 
    326         { 
     303        for (i = 0; i < 6; i++) { 
    327304                dev->dev_addr[i] = mac_addr[i]; 
    328305                printk("%02X%c", dev->dev_addr[i], (i == 5)?('\n'):(':')); 
     
    331308} 
    332309 
    333 static void 
    334 ifxmips_mii_chip_init(int mode) 
     310static void ifxmips_mii_chip_init(int mode) 
    335311{ 
    336312        ifxmips_pmu_enable(IFXMIPS_PMU_PWDCR_DMA); 
     
    346322} 
    347323 
    348 static int 
    349 ifxmips_mii_probe(struct platform_device *dev) 
     324static int ifxmips_mii_probe(struct platform_device *dev) 
    350325{ 
    351326        int result = 0; 
    352         unsigned char *mac = (unsigned char*)dev->dev.platform_data; 
     327        unsigned char *mac = (unsigned char *)dev->dev.platform_data; 
    353328        ifxmips_mii0_dev = alloc_etherdev(sizeof(struct ifxmips_mii_priv)); 
    354329        ifxmips_mii0_dev->init = ifxmips_mii_dev_init; 
     
    357332        ifxmips_mii_chip_init(REV_MII_MODE); 
    358333        result = register_netdev(ifxmips_mii0_dev); 
    359         if (result) 
    360         { 
     334        if (result) { 
    361335                printk(KERN_INFO "ifxmips_mii0: error %i registering device \"%s\"\n", result, ifxmips_mii0_dev->name); 
    362336                goto out; 
     
    369343} 
    370344 
    371 static int 
    372 ifxmips_mii_remove(struct platform_device *dev) 
    373 { 
    374         struct ifxmips_mii_priv *priv = (struct ifxmips_mii_priv*)ifxmips_mii0_dev->priv; 
     345static int ifxmips_mii_remove(struct platform_device *dev) 
     346{ 
     347        struct ifxmips_mii_priv *priv = (struct ifxmips_mii_priv *)ifxmips_mii0_dev->priv; 
    375348 
    376349        printk(KERN_INFO "ifxmips_mii0: ifxmips_mii0 cleanup\n"); 
     
    384357} 
    385358 
    386 static struct 
    387 platform_driver ifxmips_mii_driver = { 
     359static struct platform_driver ifxmips_mii_driver = { 
    388360        .probe = ifxmips_mii_probe, 
    389361        .remove = ifxmips_mii_remove, 
     
    394366}; 
    395367 
    396 int __init 
    397 ifxmips_mii_init(void) 
     368int __init ifxmips_mii_init(void) 
    398369{ 
    399370        int ret = platform_driver_register(&ifxmips_mii_driver); 
     
    403374} 
    404375 
    405 static void __exit 
    406 ifxmips_mii_cleanup(void) 
     376static void __exit ifxmips_mii_cleanup(void) 
    407377{ 
    408378        platform_driver_unregister(&ifxmips_mii_driver); 
     
    415385MODULE_AUTHOR("John Crispin <blogic@openwrt.org>"); 
    416386MODULE_DESCRIPTION("ethernet map driver for IFXMIPS boards"); 
     387 
  • trunk/target/linux/ifxmips/files/drivers/serial/ifxmips_asc.c

    r11673 r13660  
    4343#include <linux/irq.h> 
    4444#include <linux/platform_device.h> 
     45#include <linux/io.h> 
     46#include <linux/uaccess.h> 
     47#include <linux/bitops.h> 
     48 
    4549#include <asm/system.h> 
    46 #include <asm/io.h> 
    47 #include <asm/uaccess.h> 
    48 #include <asm/bitops.h> 
     50 
    4951#include <asm/ifxmips/ifxmips.h> 
    5052#include <asm/ifxmips/ifxmips_irq.h> 
     
    5759 
    5860static void ifxmipsasc_tx_chars(struct uart_port *port); 
    59 extern void prom_printf(const char * fmt, ...); 
     61extern void prom_printf(const char *fmt, ...); 
    6062static struct uart_port ifxmipsasc_port[2]; 
    6163static struct uart_driver ifxmipsasc_reg; 
    6264extern unsigned int ifxmips_get_fpi_hz(void); 
    6365 
    64 static void 
    65 ifxmipsasc_stop_tx(struct uart_port *port) 
     66static void ifxmipsasc_stop_tx(struct uart_port *port) 
    6667{ 
    6768        return; 
    6869} 
    6970 
    70 static void 
    71 ifxmipsasc_start_tx(struct uart_port *port) 
     71static void ifxmipsasc_start_tx(struct uart_port *port) 
    7272{ 
    7373        unsigned long flags; 
     
    7878} 
    7979 
    80 static void 
    81 ifxmipsasc_stop_rx(struct uart_port *port) 
     80static void ifxmipsasc_stop_rx(struct uart_port *port) 
    8281{ 
    8382        ifxmips_w32(ASCWHBSTATE_CLRREN, port->membase + IFXMIPS_ASC_WHBSTATE); 
    8483} 
    8584 
    86 static void 
    87 ifxmipsasc_enable_ms(struct uart_port *port) 
    88 { 
    89 } 
    90  
    91 static void 
    92 ifxmipsasc_rx_chars(struct uart_port *port) 
    93 { 
     85static void ifxmipsasc_enable_ms(struct uart_port *port) 
     86{ 
     87} 
     88 
     89#include <linux/version.h> 
     90 
     91static void ifxmipsasc_rx_chars(struct uart_port *port) 
     92{ 
     93#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 26)) 
     94        struct tty_struct *tty = port->info->port.tty; 
     95#else 
    9496        struct tty_struct *tty = port->info->tty; 
     97#endif 
    9598        unsigned int ch = 0, rsr = 0, fifocnt; 
    9699 
    97100        fifocnt = ifxmips_r32(port->membase + IFXMIPS_ASC_FSTAT) & ASCFSTAT_RXFFLMASK; 
    98         while(fifocnt--) 
    99         { 
     101        while (fifocnt--) { 
    100102                u8 flag = TTY_NORMAL; 
    101103                ch = ifxmips_r32(port->membase + IFXMIPS_ASC_RBUF); 
     
    108110                 * out of the main execution path 
    109111                 */ 
    110                 if(rsr & ASCSTATE_ANY) 
    111                 { 
    112                         if(rsr & ASCSTATE_PE) 
    113                         { 
     112                if (rsr & ASCSTATE_ANY) { 
     113                        if (rsr & ASCSTATE_PE) { 
    114114                                port->icount.parity++; 
    115115                                ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_WHBSTATE) | ASCWHBSTATE_CLRPE, port->membase + IFXMIPS_ASC_WHBSTATE); 
    116                         } else if(rsr & ASCSTATE_FE) 
    117                         { 
     116                        } else if (rsr & ASCSTATE_FE) { 
    118117                                port->icount.frame++; 
    119118                                ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_WHBSTATE) | ASCWHBSTATE_CLRFE, port->membase + IFXMIPS_ASC_WHBSTATE); 
    120119                        } 
    121                         if(rsr & ASCSTATE_ROE) 
    122                         { 
     120                        if (rsr & ASCSTATE_ROE) { 
    123121                                port->icount.overrun++; 
    124122                                ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_WHBSTATE) | ASCWHBSTATE_CLRROE, port->membase + IFXMIPS_ASC_WHBSTATE); 
     
    127125                        rsr &= port->read_status_mask; 
    128126 
    129                         if(rsr & ASCSTATE_PE) 
     127                        if (rsr & ASCSTATE_PE) 
    130128                                flag = TTY_PARITY; 
    131                         else if(rsr & ASCSTATE_FE) 
     129                        else if (rsr & ASCSTATE_FE) 
    132130                                flag = TTY_FRAME; 
    133131                } 
    134132 
    135                 if((rsr & port->ignore_status_mask) == 0) 
     133                if ((rsr & port->ignore_status_mask) == 0) 
    136134                        tty_insert_flip_char(tty, ch, flag); 
    137135 
    138                 if(rsr & ASCSTATE_ROE) 
     136                if (rsr & ASCSTATE_ROE) 
    139137                        /* 
    140138                         * Overrun is special, since it's reported 
     
    144142                        tty_insert_flip_char(tty, 0, TTY_OVERRUN); 
    145143        } 
    146         if(ch != 0) 
     144        if (ch != 0) 
    147145                tty_flip_buffer_push(tty); 
    148146        return; 
     
    150148 
    151149 
    152 static void 
    153 ifxmipsasc_tx_chars(struct uart_port *port) 
     150static void ifxmipsasc_tx_chars(struct uart_port *port) 
    154151{ 
    155152        struct circ_buf *xmit = &port->info->xmit; 
    156         if(uart_tx_stopped(port)) 
    157         { 
     153        if (uart_tx_stopped(port)) { 
    158154                ifxmipsasc_stop_tx(port); 
    159155                return; 
    160156        } 
    161157 
    162         while(((ifxmips_r32(port->membase + IFXMIPS_ASC_FSTAT) & ASCFSTAT_TXFFLMASK) 
    163                                 >> ASCFSTAT_TXFFLOFF) != TXFIFO_FULL) 
    164         { 
    165                 if(port->x_char) 
    166                 { 
     158        while (((ifxmips_r32(port->membase + IFXMIPS_ASC_FSTAT) & ASCFSTAT_TXFFLMASK) 
     159                        >> ASCFSTAT_TXFFLOFF) != TXFIFO_FULL) { 
     160                if (port->x_char) { 
    167161                        ifxmips_w32(port->x_char, port->membase + IFXMIPS_ASC_TBUF); 
    168162                        port->icount.tx++; 
     
    171165                } 
    172166 
    173                 if(uart_circ_empty(xmit)) 
     167                if (uart_circ_empty(xmit)) 
    174168                        break; 
    175169 
     
    179173        } 
    180174 
    181         if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 
     175        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 
    182176                uart_write_wakeup(port); 
    183177} 
    184178 
    185 static irqreturn_t 
    186 ifxmipsasc_tx_int(int irq, void *_port) 
    187 { 
    188         struct uart_port *port = (struct uart_port*) _port; 
     179static irqreturn_t ifxmipsasc_tx_int(int irq, void *_port) 
     180{ 
     181        struct uart_port *port = (struct uart_port *)_port; 
    189182        ifxmips_w32(ASC_IRNCR_TIR, port->membase + IFXMIPS_ASC_IRNCR); 
    190183        ifxmipsasc_start_tx(port); 
     
    193186} 
    194187 
    195 static irqreturn_t 
    196 ifxmipsasc_er_int(int irq, void *_port) 
    197 { 
    198         struct uart_port *port = (struct uart_port*) _port; 
     188static irqreturn_t ifxmipsasc_er_int(int irq, void *_port) 
     189{ 
     190        struct uart_port *port = (struct uart_port *)_port; 
    199191        /* clear any pending interrupts */ 
    200192        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_WHBSTATE) | ASCWHBSTATE_CLRPE | 
     
    203195} 
    204196 
    205 static irqreturn_t 
    206 ifxmipsasc_rx_int(int irq, void *_port) 
    207 { 
    208         struct uart_port *port = (struct uart_port*)_port; 
     197static irqreturn_t ifxmipsasc_rx_int(int irq, void *_port) 
     198{ 
     199        struct uart_port *port = (struct uart_port *)_port; 
    209200        ifxmips_w32(ASC_IRNCR_RIR, port->membase + IFXMIPS_ASC_IRNCR); 
    210         ifxmipsasc_rx_chars((struct uart_port*)port); 
     201        ifxmipsasc_rx_chars((struct uart_port *)port); 
    211202        ifxmips_mask_and_ack_irq(irq); 
    212203        return IRQ_HANDLED; 
    213204} 
    214205 
    215 static unsigned int 
    216 ifxmipsasc_tx_empty(struct uart_port *port) 
     206static unsigned int ifxmipsasc_tx_empty(struct uart_port *port) 
    217207{ 
    218208        int status; 
     
    221211} 
    222212 
    223 static unsigned int 
    224 ifxmipsasc_get_mctrl(struct uart_port *port) 
     213static unsigned int ifxmipsasc_get_mctrl(struct uart_port *port) 
    225214{ 
    226215        return TIOCM_CTS | TIOCM_CAR | TIOCM_DSR; 
    227216} 
    228217 
    229 static void 
    230 ifxmipsasc_set_mctrl(struct uart_port *port, u_int mctrl) 
    231 { 
    232 } 
    233  
    234 static void 
    235 ifxmipsasc_break_ctl(struct uart_port *port, int break_state) 
    236 { 
    237 } 
    238  
    239 static int 
    240 ifxmipsasc_startup(struct uart_port *port) 
     218static void ifxmipsasc_set_mctrl(struct uart_port *port, u_int mctrl) 
     219{ 
     220} 
     221 
     222static void ifxmipsasc_break_ctl(struct uart_port *port, int break_state) 
     223{ 
     224} 
     225 
     226static int ifxmipsasc_startup(struct uart_port *port) 
    241227{ 
    242228        unsigned long flags; 
     
    250236        ifxmips_w32(((TXFIFO_FL << ASCTXFCON_TXFITLOFF) & ASCTXFCON_TXFITLMASK) | ASCTXFCON_TXFEN | ASCTXFCON_TXFFLU, port->membase + IFXMIPS_ASC_TXFCON); 
    251237        ifxmips_w32(((RXFIFO_FL << ASCRXFCON_RXFITLOFF) & ASCRXFCON_RXFITLMASK) | ASCRXFCON_RXFEN | ASCRXFCON_RXFFLU, port->membase + IFXMIPS_ASC_RXFCON); 
    252         wmb (); 
     238        wmb(); 
    253239        ifxmips_w32(ifxmips_r32(port->membase + IFXMIPS_ASC_CON) | ASCCON_M_8ASYNC | ASCCON_FEN | ASCCON_TOEN | ASCCON_ROEN, port->membase + IFXMIPS_ASC_CON); 
    254240 
     
    256242 
    257243        retval = request_irq(port->irq, ifxmipsasc_tx_int, IRQF_DISABLED, "asc_tx", port); 
    258         if(retval) 
    259         { 
    260                 printk("failed to request ifxmipsasc_tx_int\n"); 
     244        if (retval) { 
     245                printk(KERN_ERR "failed to request ifxmipsasc_tx_int\n"); 
    261246                return retval; 
    262247        } 
    263248 
    264249        retval = request_irq(port->irq + 2, ifxmipsasc_rx_int, IRQF_DISABLED, "asc_rx", port); 
    265         if(retval) 
    266         { 
    267                 printk("failed to request ifxmipsasc_rx_int\n"); 
     250        if (retval) { 
     251                printk(KERN_ERR "failed to request ifxmipsasc_rx_int\n"); 
    268252                goto err1; 
    269253        } 
    270254 
    271255        retval = request_irq(port->irq + 3, ifxmipsasc_er_int, IRQF_DISABLED, "asc_er", port); 
    272         if(retval) 
    273         { 
    274                 printk("failed to request ifxmipsasc_er_int\n"); 
     256        if (retval) { 
     257                printk(KERN_ERR "failed to request ifxmipsasc_er_int\n"); 
    275258                goto err2; 
    276259        } 
     
    289272} 
    290273 
    291 static void 
    292 ifxmipsasc_shutdown(struct uart_port *port) 
     274static void ifxmipsasc_shutdown(struct uart_port *port) 
    293275{ 
    294276        free_irq(port->irq, port); 
     
    315297        iflag = new->c_iflag; 
    316298 
    317         switch(cflag & CSIZE) 
    318         { 
     299        switch (cflag & CSIZE) { 
    319300        case CS7: 
    320301                con = ASCCON_M_7ASYNC; 
     
    328309        } 
    329310 
    330         if(cflag & CSTOPB) 
     311        if (cflag & CSTOPB) 
    331312                con |= ASCCON_STP; 
    332313 
    333         if(cflag & PARENB) 
    334         { 
    335                 if(!(cflag & PARODD)) 
     314        if (cflag & PARENB) { 
     315                if (!(cflag & PARODD)) 
    336316                        con &= ~ASCCON_ODD; 
    337317                else 
     
    340320 
    341321        port->read_status_mask = ASCSTATE_ROE; 
    342         if(iflag & INPCK) 
     322        if (iflag & INPCK) 
    343323                port->read_status_mask |= ASCSTATE_FE | ASCSTATE_PE; 
    344324 
    345325        port->ignore_status_mask = 0; 
    346         if(iflag & IGNPAR) 
     326        if (iflag & IGNPAR) 
    347327                port->ignore_status_mask |= ASCSTATE_FE | ASCSTATE_PE; 
    348328 
    349         if(iflag & IGNBRK) 
    350         { 
     329        if (iflag & IGNBRK) { 
    351330                /* 
    352331                 * If we're ignoring parity and break indicators, 
    353332                 * ignore overruns too (for real raw support). 
    354333                 */ 
    355                 if(iflag & IGNPAR) 
     334                if (iflag & IGNPAR) 
    356335                        port->ignore_status_mask |= ASCSTATE_ROE; 
    357336        } 
    358337 
    359         if((cflag & CREAD) == 0) 
     338        if ((cflag & CREAD) == 0) 
    360339                port->ignore_status_mask |= UART_DUMMY_UER_RX; 
    361340 
     
    369348 
    370349        /* Set baud rate - take a divider of 2 into account */ 
    371     baud = uart_get_baud_rate(port, new, old, 0, port->uartclk / 16); 
     350        baud = uart_get_baud_rate(port, new, old, 0, port->uartclk / 16); 
    372351        quot = uart_get_divisor(port, baud); 
    373352        quot = quot / 2 - 1; 
     
    394373} 
    395374 
    396 static const char* 
    397 ifxmipsasc_type(struct uart_port *port) 
    398 { 
    399         if(port->type == PORT_IFXMIPSASC) 
    400         { 
    401                 if(port->membase == (void*)IFXMIPS_ASC_BASE_ADDR) 
     375static const char *ifxmipsasc_type(struct uart_port *port) 
     376{ 
     377        if (port->type == PORT_IFXMIPSASC) { 
     378                if (port->membase == (void *)IFXMIPS_ASC_BASE_ADDR) 
    402379                        return "asc0"; 
    403380                else 
     
    408385} 
    409386 
    410 static void 
    411 ifxmipsasc_release_port(struct uart_port *port) 
    412 { 
    413 } 
    414  
    415 static int 
    416 ifxmipsasc_request_port(struct uart_port *port) 
     387static void ifxmipsasc_release_port(struct uart_port *port) 
     388{ 
     389} 
     390 
     391static int ifxmipsasc_request_port(struct uart_port *port) 
    417392{ 
    418393        return 0; 
    419394} 
    420395 
    421 static void 
    422 ifxmipsasc_config_port(struct uart_port *port, int flags) 
    423 { 
    424         if(flags & UART_CONFIG_TYPE) 
    425         { 
     396static void ifxmipsasc_config_port(struct uart_port *port, int flags) 
     397{ 
     398        if (flags & UART_CONFIG_TYPE) { 
    426399                port->type = PORT_IFXMIPSASC; 
    427400                ifxmipsasc_request_port(port); 
     
    429402} 
    430403 
    431 static int 
    432 ifxmipsasc_verify_port(struct uart_port *port, struct serial_struct *ser) 
     404static int ifxmipsasc_verify_port(struct uart_port *port, struct serial_struct *ser) 
    433405{ 
    434406        int ret = 0; 
    435         if(ser->type != PORT_UNKNOWN && ser->type != PORT_IFXMIPSASC) 
     407        if (ser->type != PORT_UNKNOWN && ser->type != PORT_IFXMIPSASC) 
    436408                ret = -EINVAL; 
    437         if(ser->irq < 0 || ser->irq >= NR_IRQS) 
     409        if (ser->irq < 0 || ser->irq >= NR_IRQS) 
    438410                ret = -EINVAL; 
    439         if(ser->baud_base < 9600) 
     411        if (ser->baud_base < 9600) 
    440412                ret = -EINVAL; 
    441413        return ret; 
    442414} 
    443415 
    444 static struct uart_ops ifxmipsasc_pops = 
    445 { 
    446         .tx_empty =             ifxmipsasc_tx_empty, 
     416static struct uart_ops ifxmipsasc_pops = { 
     417        .tx_empty =     ifxmipsasc_tx_empty, 
    447418        .set_mctrl =    ifxmipsasc_set_mctrl, 
    448419        .get_mctrl =    ifxmipsasc_get_mctrl, 
    449         .stop_tx =              ifxmipsasc_stop_tx, 
    450         .start_tx =             ifxmipsasc_start_tx, 
    451         .stop_rx =              ifxmipsasc_stop_rx, 
     420        .stop_tx =      ifxmipsasc_stop_tx, 
     421        .start_tx =     ifxmipsasc_start_tx, 
     422        .stop_rx =      ifxmipsasc_stop_rx, 
    452423        .enable_ms =    ifxmipsasc_enable_ms, 
    453424        .break_ctl =    ifxmipsasc_break_ctl, 
    454         .startup =              ifxmipsasc_startup, 
    455         .shutdown =             ifxmipsasc_shutdown, 
     425        .startup =      ifxmipsasc_startup, 
     426        .shutdown =     ifxmipsasc_shutdown, 
    456427        .set_termios =  ifxmipsasc_set_termios, 
    457         .type =                 ifxmipsasc_type, 
     428        .type =         ifxmipsasc_type, 
    458429        .release_port = ifxmipsasc_release_port, 
    459430        .request_port = ifxmipsasc_request_port, 
     
    462433}; 
    463434 
    464 static struct uart_port ifxmipsasc_port[2] = 
    465 { 
     435static struct uart_port ifxmipsasc_port[2] = { 
    466436        { 
    467                 membase:                (void *)IFXMIPS_ASC_BASE_ADDR, 
    468                 mapbase:                IFXMIPS_ASC_BASE_ADDR, 
    469                 iotype:                 SERIAL_IO_MEM, 
    470                 irq:                    IFXMIPSASC_TIR(0), 
    471                 uartclk:                0, 
    472                 fifosize:               16, 
    473                 type:                   PORT_IFXMIPSASC, 
    474                 ops:                    &ifxmipsasc_pops, 
    475                 flags:                  ASYNC_BOOT_AUTOCONF, 
    476                 line:                   0 
     437                .membase =              (void *)IFXMIPS_ASC_BASE_ADDR, 
     438                .mapbase =              IFXMIPS_ASC_BASE_ADDR, 
     439                .iotype =               SERIAL_IO_MEM, 
     440                .irq =                  IFXMIPSASC_TIR(0), 
     441                .uartclk =              0, 
     442                .fifosize =             16, 
     443                .type =                 PORT_IFXMIPSASC, 
     444                .ops =                  &ifxmipsasc_pops, 
     445                .flags =                ASYNC_BOOT_AUTOCONF, 
     446                .line =                 0 
    477447        }, { 
    478                 membase:                (void *)(IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_BASE_DIFF), 
    479                 mapbase:                IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_BASE_DIFF, 
    480                 iotype:                 SERIAL_IO_MEM, 
    481                 irq:                    IFXMIPSASC_TIR(1), 
    482                 uartclk:                0, 
    483                 fifosize:               16, 
    484                 type:                   PORT_IFXMIPSASC, 
    485                 ops:                    &ifxmipsasc_pops, 
    486                 flags:                  ASYNC_BOOT_AUTOCONF, 
    487                 line:                   1 
     448                .membase =              (void *)(IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_BASE_DIFF), 
     449                .mapbase =              IFXMIPS_ASC_BASE_ADDR + IFXMIPS_ASC_BASE_DIFF, 
     450                .iotype =               SERIAL_IO_MEM, 
     451                .irq =                  IFXMIPSASC_TIR(1), 
     452                .uartclk =              0, 
     453                .fifosize =             16, 
     454                .type =                 PORT_IFXMIPSASC, 
     455                .ops =                  &ifxmipsasc_pops, 
     456                .flags =                ASYNC_BOOT_AUTOCONF, 
     457                .line =                 1 
    488458        } 
    489459}; 
    490460 
    491 static void 
    492 ifxmipsasc_console_write(struct console *co, const char *s, u_int count) 
     461static void ifxmipsasc_console_write(struct console *co, const char *s, u_int count) 
    493462{ 
    494463        int port = co->index; 
     
    496465        unsigned long flags; 
    497466        local_irq_save(flags); 
    498         for(i = 0; i < count; i++) 
    499         { 
     467        for (i = 0; i < count; i++) { 
    500468                do { 
    501                         fifocnt = (ifxmips_r32((u32*)(IFXMIPS_ASC_BASE_ADDR + (port * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_FSTAT)) & ASCFSTAT_TXFFLMASK) 
    502                                         >> ASCFSTAT_TXFFLOFF; 
    503                 } while(fifocnt == TXFIFO_FULL); 
    504  
    505                 if(s[i] == '\0') 
     469                        fifocnt = (ifxmips_r32((u32 *)(IFXMIPS_ASC_BASE_ADDR + (port * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_FSTAT)) & ASCFSTAT_TXFFLMASK) 
     470                                >> ASCFSTAT_TXFFLOFF; 
     471                } while (fifocnt == TXFIFO_FULL); 
     472 
     473                if (s[i] == '\0') 
    506474                        break; 
    507475 
    508                 if(s[i] == '\n') 
    509                 { 
    510                         ifxmips_w32('\r', (u32*)(IFXMIPS_ASC_BASE_ADDR + (port * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_TBUF)); 
     476                if (s[i] == '\n') { 
     477                        ifxmips_w32('\r', (u32 *)(IFXMIPS_ASC_BASE_ADDR + (port * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_TBUF)); 
    511478                        do { 
    512                                 fifocnt = (ifxmips_r32((u32*)(IFXMIPS_ASC_BASE_ADDR + (port * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_FSTAT)) & ASCFSTAT_TXFFLMASK) 
     479                                fifocnt = (ifxmips_r32((u32 *)(IFXMIPS_ASC_BASE_ADDR + (port * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_FSTAT)) & ASCFSTAT_TXFFLMASK) 
    513480                                        >> ASCFSTAT_TXFFLOFF; 
    514                         } while(fifocnt == TXFIFO_FULL); 
     481                        } while (fifocnt == TXFIFO_FULL); 
    515482                } 
    516                 ifxmips_w32(s[i], (u32*)(IFXMIPS_ASC_BASE_ADDR + (port * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_TBUF)); 
     483                ifxmips_w32(s[i], (u32 *)(IFXMIPS_ASC_BASE_ADDR + (port * IFXMIPS_ASC_BASE_DIFF) + IFXMIPS_ASC_TBUF)); 
    517484        } 
    518485 
     
    520487} 
    521488 
    522 static int __init 
    523 ifxmipsasc_console_setup(struct console *co, char *options) 
     489static int __init ifxmipsasc_console_setup(struct console *co, char *options) 
    524490{ 
    525491        int port = co->index; 
     
    530496        ifxmipsasc_port[port].uartclk = ifxmips_get_fpi_hz(); 
    531497        ifxmipsasc_port[por