Changeset 9263


Ignore:
Timestamp:
2007-10-11T17:09:50+02:00 (10 years ago)
Author:
juhosg
Message:

[adm5120] coding style fixes

Location:
trunk/target/linux/adm5120/files
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/adm5120_info.c

    r8705 r9263  
    2525#include <linux/kernel.h> 
    2626#include <linux/init.h> 
     27#include <linux/io.h> 
    2728 
    28 #include <asm/io.h> 
    2929#include <asm/bootinfo.h> 
    3030#include <asm/addrspace.h> 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/board.c

    r9016 r9263  
    3838#include <adm5120_platform.h> 
    3939 
     40#define PFX     "adm5120: " 
     41 
    4042static LIST_HEAD(adm5120_boards); 
    4143static char adm5120_board_name[ADM5120_BOARD_NAMELEN]; 
     
    7173        board = adm5120_board_find(mips_machtype); 
    7274        if (board == NULL) { 
    73                 printk(KERN_ALERT "adm5120: no board registered for machtype %lu" 
    74                         ", trying generic\n", mips_machtype); 
     75                printk(KERN_ALERT PFX"no board registered for " 
     76                        "machtype %lu, trying generic\n", mips_machtype); 
    7577                board = adm5120_board_find(MACH_ADM5120_GENERIC); 
    7678                if (board == NULL) 
    77                         panic("adm5120: unsupported board\n"); 
     79                        panic(PFX "unsupported board\n"); 
    7880        } 
    7981 
    80         printk(KERN_INFO "adm5120: setting up board '%s'\n", board->name); 
     82        printk(KERN_INFO PFX "setting up board '%s'\n", board->name); 
    8183 
    8284        memcpy(&adm5120_board_name, board->name, ADM5120_BOARD_NAMELEN); 
     
    101103 
    102104        /* register board devices */ 
    103         if (board->num_devices > 0 && board->devices != NULL ) { 
     105        if (board->num_devices > 0 && board->devices != NULL) { 
    104106                err = platform_add_devices(board->devices, board->num_devices); 
    105107                if (err) 
    106                         printk(KERN_ALERT "adm5120: adding board devices failed\n"); 
     108                        printk(KERN_ALERT PFX "adding board devices failed\n"); 
    107109        } 
    108110 
     
    114116{ 
    115117        list_add(&board->list, &adm5120_boards); 
    116         printk(KERN_INFO "adm5120: registered board '%s'\n", board->name); 
     118        printk(KERN_INFO PFX "registered board '%s'\n", board->name); 
    117119} 
    118120 
     
    122124        int i; 
    123125 
    124         for (i=0; i<num; i++) 
     126        for (i = 0; i < num; i++) 
    125127                adm5120_board_register(boards[i]); 
    126128} 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/boards/mikrotik.c

    r9118 r9263  
    5757 
    5858#define RB150_NAND_WRITE(v) \ 
    59         writeb((v),(void __iomem *)KSEG1ADDR(RB150_NAND_BASE)) 
     59        writeb((v), (void __iomem *)KSEG1ADDR(RB150_NAND_BASE)) 
    6060 
    6161/*--------------------------------------------------------------------------*/ 
     
    6767}; 
    6868 
    69 static struct mtd_partition rb1xx_nor_partitions[] = { 
     69static struct mtd_partition rb1xx_nor_parts[] = { 
    7070        { 
    7171                .name   = "booter", 
     
    8080}; 
    8181 
    82 static struct mtd_partition rb1xx_nand_partitions[] = { 
     82static struct mtd_partition rb1xx_nand_parts[] = { 
    8383        { 
    8484                .name   = "kernel", 
     
    103103 */ 
    104104static struct nand_ecclayout rb1xx_nand_ecclayout = { 
    105         .eccbytes       = 6, 
    106         .eccpos         = { 8, 9, 10, 13, 14, 15 }, 
    107         .oobavail       = 9, 
    108         .oobfree        = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } } 
     105        .eccbytes       = 6, 
     106        .eccpos         = { 8, 9, 10, 13, 14, 15 }, 
     107        .oobavail       = 9, 
     108        .oobfree        = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } } 
    109109}; 
    110110 
     
    158158/*--------------------------------------------------------------------------*/ 
    159159 
    160 static int rb150_nand_ready(struct mtd_info *mtd) { 
    161  
     160static int rb150_nand_ready(struct mtd_info *mtd) 
     161{ 
    162162        return gpio_get_value(RB150_GPIO_NAND_READY); 
    163163} 
     
    188188{ 
    189189        /* setup data for flash0 device */ 
    190         adm5120_flash0_data.nr_parts = ARRAY_SIZE(rb1xx_nor_partitions); 
    191         adm5120_flash0_data.parts = rb1xx_nor_partitions; 
     190        adm5120_flash0_data.nr_parts = ARRAY_SIZE(rb1xx_nor_parts); 
     191        adm5120_flash0_data.parts = rb1xx_nor_parts; 
    192192 
    193193        /* setup data for NAND device */ 
    194194        adm5120_nand_data.chip.nr_chips = 1; 
    195         adm5120_nand_data.chip.nr_partitions = ARRAY_SIZE(rb1xx_nand_partitions); 
    196         adm5120_nand_data.chip.partitions = rb1xx_nand_partitions; 
     195        adm5120_nand_data.chip.nr_partitions = ARRAY_SIZE(rb1xx_nand_parts); 
     196        adm5120_nand_data.chip.partitions = rb1xx_nand_parts; 
    197197        adm5120_nand_data.chip.ecclayout = &rb1xx_nand_ecclayout; 
    198198        adm5120_nand_data.chip.chip_delay = RB1XX_NAND_CHIP_DELAY; 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/clock.c

    r8538 r9263  
    3535#include <linux/clk.h> 
    3636 
    37 #include <asm/mach-adm5120/adm5120_defs.h> 
     37#include <adm5120_defs.h> 
    3838 
    3939struct clk { 
     
    4747struct clk *clk_get(struct device *dev, const char *id) 
    4848{ 
    49        if (!strcmp(id, "UARTCLK")) 
    50                return &uart_clk; 
     49        if (!strcmp(id, "UARTCLK")) 
     50                return &uart_clk; 
    5151 
    52        return ERR_PTR(-ENOENT); 
     52        return ERR_PTR(-ENOENT); 
    5353} 
    5454EXPORT_SYMBOL(clk_get); 
     
    5656int clk_enable(struct clk *clk) 
    5757{ 
    58        return 0; 
     58        return 0; 
    5959} 
    6060EXPORT_SYMBOL(clk_enable); 
     
    6767unsigned long clk_get_rate(struct clk *clk) 
    6868{ 
    69        return clk->rate; 
     69        return clk->rate; 
    7070} 
    7171EXPORT_SYMBOL(clk_get_rate); 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/gpio.c

    r8538 r9263  
    3030#include <linux/delay.h> 
    3131#include <linux/platform_device.h> 
     32#include <linux/io.h> 
    3233 
    3334#include <asm/addrspace.h> 
    34 #include <asm/io.h> 
    3535#include <asm/gpio.h> 
    3636 
    37 #include <asm/mach-adm5120/adm5120_defs.h> 
    38 #include <asm/mach-adm5120/adm5120_info.h> 
    39 #include <asm/mach-adm5120/adm5120_switch.h> 
    40  
    41 typedef void __iomem *  gpio_reg_t; 
    42 #define GPIO_READ(r)    readl((r)) 
    43 #define GPIO_WRITE(v,r) writel((v),(r)) 
    44 #define GPIO_REG(r)     (gpio_reg_t)(KSEG1ADDR(ADM5120_SWITCH_BASE)+r) 
     37#include <adm5120_defs.h> 
     38#include <adm5120_info.h> 
     39#include <adm5120_switch.h> 
     40 
     41 
     42#define GPIO_READ(r)            readl((r)) 
     43#define GPIO_WRITE(v, r)        writel((v), (r)) 
     44#define GPIO_REG(r)     (void __iomem *)(KSEG1ADDR(ADM5120_SWITCH_BASE)+r) 
    4545 
    4646struct adm5120_gpio_line { 
     
    5353 
    5454struct led_desc { 
    55         gpio_reg_t reg; /* LED register address */ 
    56         u8 iv_shift;    /* shift amount for input bit */ 
    57         u8 mode_shift;  /* shift amount for mode bits */ 
     55        void __iomem *reg;      /* LED register address */ 
     56        u8 iv_shift;            /* shift amount for input bit */ 
     57        u8 mode_shift;          /* shift amount for mode bits */ 
    5858}; 
    5959 
    60 #define LED_DESC(_port,_led) { \ 
    61                 .reg = GPIO_REG(SWITCH_REG_PORT0_LED+_port*4), \ 
    62                 .iv_shift = LED0_IV_SHIFT+_led, \ 
    63                 .mode_shift = _led*4 \ 
     60#define LED_DESC(p, l) { \ 
     61                .reg = GPIO_REG(SWITCH_REG_PORT0_LED+((p) * 4)), \ 
     62                .iv_shift = LED0_IV_SHIFT + (l), \ 
     63                .mode_shift = (l) * 4 \ 
    6464        } 
    6565 
     
    9898}; 
    9999 
    100 #define gpio_is_invalid(g) ( \ 
    101                 (g) > ADM5120_GPIO_MAX || \ 
    102                 ((adm5120_gpio_map[(g)].flags & GPIO_FLAG_VALID) == 0) \ 
    103         ) 
     100#define gpio_is_invalid(g) ((g) > ADM5120_GPIO_MAX || \ 
     101                ((adm5120_gpio_map[(g)].flags & GPIO_FLAG_VALID) == 0)) 
    104102 
    105103#define gpio_is_used(g) ((adm5120_gpio_map[(g)].flags & GPIO_FLAG_USED) != 0) 
     
    115113static inline int pins_direction_input(unsigned pin) 
    116114{ 
    117         gpio_reg_t *reg; 
     115        void __iomem **reg; 
    118116        u32 t; 
    119117 
     
    123121        t &= ~(PIN_OE(pin)); 
    124122        t |= PIN_IM(pin); 
    125         GPIO_WRITE(t,reg); 
     123        GPIO_WRITE(t, reg); 
    126124 
    127125        return 0; 
     
    130128static inline int pins_direction_output(unsigned pin, int value) 
    131129{ 
    132         gpio_reg_t *reg; 
     130        void __iomem **reg; 
    133131        u32 t; 
    134132 
     
    142140                t |= PIN_OV(pin); 
    143141 
    144         GPIO_WRITE(t,reg); 
     142        GPIO_WRITE(t, reg); 
    145143 
    146144        return 0; 
     
    149147static inline int pins_get_value(unsigned pin) 
    150148{ 
    151         gpio_reg_t *reg; 
     149        void __iomem **reg; 
    152150        u32 t; 
    153151 
     
    165163static inline void pins_set_value(unsigned pin, int value) 
    166164{ 
    167         gpio_reg_t *reg; 
     165        void __iomem **reg; 
    168166        u32 t; 
    169167 
     
    176174                t |= PIN_OV(pin); 
    177175 
    178         GPIO_WRITE(t,reg); 
     176        GPIO_WRITE(t, reg); 
    179177} 
    180178 
     
    184182static inline int leds_direction_input(unsigned led) 
    185183{ 
    186         gpio_reg_t *reg; 
     184        void __iomem **reg; 
    187185        u32 t; 
    188186 
     
    190188        t = GPIO_READ(reg); 
    191189        t &= ~(LED_MODE_MASK << led_table[led].mode_shift); 
    192         GPIO_WRITE(t,reg); 
     190        GPIO_WRITE(t, reg); 
    193191 
    194192        return 0; 
     
    197195static inline int leds_direction_output(unsigned led, int value) 
    198196{ 
    199         gpio_reg_t *reg; 
     197        void __iomem **reg; 
    200198        u32 t, s; 
    201199 
     
    227225        } 
    228226 
    229         GPIO_WRITE(t,reg); 
     227        GPIO_WRITE(t, reg); 
    230228 
    231229        return 0; 
     
    234232static inline int leds_get_value(unsigned led) 
    235233{ 
    236         gpio_reg_t *reg; 
     234        void __iomem **reg; 
    237235        u32 t, m; 
    238236 
     
    264262        return leds_direction_input(gpio); 
    265263} 
     264EXPORT_SYMBOL(adm5120_gpio_direction_input); 
    266265 
    267266int adm5120_gpio_direction_output(unsigned gpio, int value) 
     
    276275        return leds_direction_output(gpio, value); 
    277276} 
     277EXPORT_SYMBOL(adm5120_gpio_direction_output); 
    278278 
    279279int adm5120_gpio_get_value(unsigned gpio) 
     
    285285        return leds_get_value(gpio); 
    286286} 
     287EXPORT_SYMBOL(adm5120_gpio_get_value); 
    287288 
    288289void adm5120_gpio_set_value(unsigned gpio, int value) 
     
    296297        leds_direction_output(gpio, value); 
    297298} 
     299EXPORT_SYMBOL(adm5120_gpio_set_value); 
    298300 
    299301int adm5120_gpio_request(unsigned gpio, const char *label) 
     
    310312        return 0; 
    311313} 
     314EXPORT_SYMBOL(adm5120_gpio_request); 
    312315 
    313316void adm5120_gpio_free(unsigned gpio) 
     
    319322        adm5120_gpio_map[gpio].label = NULL; 
    320323} 
     324EXPORT_SYMBOL(adm5120_gpio_free); 
    321325 
    322326int adm5120_gpio_to_irq(unsigned gpio) 
     
    325329        return -EINVAL; 
    326330} 
     331EXPORT_SYMBOL(adm5120_gpio_to_irq); 
    327332 
    328333int adm5120_irq_to_gpio(unsigned irq) 
     
    331336        return -EINVAL; 
    332337} 
     338EXPORT_SYMBOL(adm5120_irq_to_gpio); 
    333339 
    334340static int __init adm5120_gpio_init(void) 
     
    338344        if (adm5120_package_pqfp()) { 
    339345                /* GPIO pins 4-7 are unavailable in ADM5120P */ 
    340                 for (i=ADM5120_GPIO_PIN4; i<=ADM5120_GPIO_PIN7; i++) 
     346                for (i = ADM5120_GPIO_PIN4; i <= ADM5120_GPIO_PIN7; i++) 
    341347                        adm5120_gpio_map[i].flags &= ~GPIO_FLAG_VALID; 
    342348        } 
     
    346352 
    347353pure_initcall(adm5120_gpio_init); 
    348  
    349 EXPORT_SYMBOL(adm5120_gpio_direction_output); 
    350 EXPORT_SYMBOL(adm5120_gpio_direction_input); 
    351 EXPORT_SYMBOL(adm5120_gpio_get_value); 
    352 EXPORT_SYMBOL(adm5120_gpio_set_value); 
    353 EXPORT_SYMBOL(adm5120_gpio_request); 
    354 EXPORT_SYMBOL(adm5120_gpio_free); 
    355 EXPORT_SYMBOL(adm5120_gpio_to_irq); 
    356 EXPORT_SYMBOL(adm5120_irq_to_gpio); 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/irq.c

    r8701 r9263  
    3030#include <linux/ioport.h> 
    3131 
    32 #include <asm/io.h> 
     32#include <linux/io.h> 
    3333#include <asm/irq.h> 
    3434#include <asm/irq_cpu.h> 
     
    3636#include <asm/bitops.h> 
    3737 
    38 #include <asm/mach-adm5120/adm5120_defs.h> 
    39 #include <asm/mach-adm5120/adm5120_irq.h> 
     38#include <adm5120_defs.h> 
     39#include <adm5120_irq.h> 
    4040 
    4141#define INTC_WRITE(reg, val)    __raw_writel((val), \ 
    4242        (void __iomem *)(KSEG1ADDR(ADM5120_INTC_BASE) + reg)) 
    4343 
    44 #define INTC_READ(reg)          __raw_readl( \ 
     44#define INTC_READ(reg)          __raw_readl(\ 
    4545        (void __iomem *)(KSEG1ADDR(ADM5120_INTC_BASE) + reg)) 
    4646 
     
    169169        INTC_WRITE(INTC_REG_IRQ_SOURCE_SELECT, 0); 
    170170 
    171         for (i = ADM5120_INTC_IRQ_BASE; i <= ADM5120_INTC_IRQ_BASE+INTC_IRQ_LAST; 
     171        for (i = ADM5120_INTC_IRQ_BASE; 
     172                i <= ADM5120_INTC_IRQ_BASE+INTC_IRQ_LAST; 
    172173                i++) { 
    173174                irq_desc[i].status = INTC_IRQ_STATUS; 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/memory.c

    r8728 r9263  
    2525#include <linux/types.h> 
    2626#include <linux/kernel.h> 
     27#include <linux/io.h> 
    2728 
    28 #include <asm/io.h> 
    2929#include <asm/bootinfo.h> 
    3030#include <asm/addrspace.h> 
     
    3535#include <adm5120_mpmc.h> 
    3636 
    37 #if 1 
    38 #  define mem_dbg(f, a...)      printk("mem_detect: " f, ## a) 
     37#ifdef DEBUG 
     38#  define mem_dbg(f, a...)      printk(KERN_INFO "mem_detect: " f, ## a) 
    3939#else 
    4040#  define mem_dbg(f, a...) 
     
    5050        u32 *p1 = (u32 *)addr; 
    5151        u32 *p2 = (u32 *)(addr+offs); 
    52         u32 t,u,v; 
     52        u32 t, u, v; 
    5353 
    5454        /* save original value */ 
     
    129129 
    130130        p = (u8 *)KSEG1ADDR(maxsize+size-4); 
    131         if (mem_check_pattern(p, 0)) { 
     131        if (mem_check_pattern(p, 0)) 
    132132                adm5120_memsize += size; 
    133         } 
    134133 
    135134        if (maxsize != size) { 
     
    155154out: 
    156155        mem_dbg("%dx%uMB memory found\n", (adm5120_memsize == size) ? 1 : 2 , 
    157                 size >>20); 
     156                size>>20); 
    158157} 
    159158 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/prom.c

    r8978 r9263  
    2828#include <linux/string.h> 
    2929#include <linux/mm.h> 
    30  
    31 #include <asm/io.h> 
     30#include <linux/io.h> 
     31 
    3232#include <asm/bootinfo.h> 
    3333#include <asm/addrspace.h> 
     
    5353static struct board_desc common_boards[] __initdata = { 
    5454        /* Cellvision/SparkLAN boards */ 
    55         DEFBOARD("CAS-630",             MACH_ADM5120_CAS630), 
    56         DEFBOARD("CAS-670",             MACH_ADM5120_CAS670), 
    57         DEFBOARD("CAS-771",             MACH_ADM5120_CAS771), 
    58         DEFBOARD("CAS-790",             MACH_ADM5120_CAS790), 
    59         DEFBOARD("CAS-861",             MACH_ADM5120_CAS861), 
     55        DEFBOARD("CAS-630",     MACH_ADM5120_CAS630), 
     56        DEFBOARD("CAS-670",     MACH_ADM5120_CAS670), 
     57        DEFBOARD("CAS-771",     MACH_ADM5120_CAS771), 
     58        DEFBOARD("CAS-790",     MACH_ADM5120_CAS790), 
     59        DEFBOARD("CAS-861",     MACH_ADM5120_CAS861), 
    6060        /* Compex boards */ 
    61         DEFBOARD("WP54G-WRT",           MACH_ADM5120_WP54G_WRT), 
     61        DEFBOARD("WP54G-WRT",   MACH_ADM5120_WP54G_WRT), 
    6262        /* Edimax boards */ 
    63         DEFBOARD("BR-6104K",            MACH_ADM5120_BR6104K), 
    64         DEFBOARD("BR-6104KP",           MACH_ADM5120_BR6104K), 
     63        DEFBOARD("BR-6104K",    MACH_ADM5120_BR6104K), 
     64        DEFBOARD("BR-6104KP",   MACH_ADM5120_BR6104K), 
    6565        /* Infineon boards */ 
    6666        DEFBOARD("EASY 5120P-ATA",      MACH_ADM5120_EASY5120PATA), 
     
    6969        DEFBOARD("EASY 83000",          MACH_ADM5120_EASY83000), 
    7070        /* Mikrotik RouterBOARDs */ 
    71         DEFBOARD("111",                 MACH_ADM5120_RB_111), 
    72         DEFBOARD("112",                 MACH_ADM5120_RB_112), 
    73         DEFBOARD("133",                 MACH_ADM5120_RB_133), 
    74         DEFBOARD("133C",                MACH_ADM5120_RB_133C), 
    75         DEFBOARD("133C3",               MACH_ADM5120_RB_133C), 
    76         DEFBOARD("150",                 MACH_ADM5120_RB_153), /* it's intentional */ 
    77         DEFBOARD("153",                 MACH_ADM5120_RB_153), 
    78         DEFBOARD("192",                 MACH_ADM5120_RB_192), 
    79         DEFBOARD("miniROUTER",          MACH_ADM5120_RB_150), 
     71        DEFBOARD("111",         MACH_ADM5120_RB_111), 
     72        DEFBOARD("112",         MACH_ADM5120_RB_112), 
     73        DEFBOARD("133",         MACH_ADM5120_RB_133), 
     74        DEFBOARD("133C",        MACH_ADM5120_RB_133C), 
     75        DEFBOARD("133C3",       MACH_ADM5120_RB_133C), 
     76        DEFBOARD("150",         MACH_ADM5120_RB_153), /* it's intentional */ 
     77        DEFBOARD("153",         MACH_ADM5120_RB_153), 
     78        DEFBOARD("192",         MACH_ADM5120_RB_192), 
     79        DEFBOARD("miniROUTER",  MACH_ADM5120_RB_150), 
    8080}; 
    8181 
     
    9292                goto out; 
    9393 
    94         for (i=0; i<ARRAY_SIZE(common_boards); i++) { 
     94        for (i = 0; i < ARRAY_SIZE(common_boards); i++) { 
    9595                if (strcmp(common_boards[i].name, name) == 0) { 
    9696                        ret = common_boards[i].mach_type; 
     
    132132        u16             board_id; 
    133133} zynos_boards[] __initdata = { 
    134 #define ZYNOS_BOARD(vi, bi, mt) { .vendor_id = (vi), .board_id = (bi), \ 
    135                 .mach_type = (mt) } 
     134#define ZYNOS_BOARD(vi, bi, mt) \ 
     135        {.vendor_id = (vi), .board_id = (bi), .mach_type = (mt)} 
    136136 
    137137#define ZYXEL_BOARD(bi, mt) ZYNOS_BOARD(ZYNOS_VENDOR_ID_ZYXEL, bi, mt) 
     
    156156 
    157157        ret = MACH_ADM5120_GENERIC; 
    158         for (i=0; i<ARRAY_SIZE(zynos_boards); i++) { 
     158        for (i = 0; i < ARRAY_SIZE(zynos_boards); i++) { 
    159159                if (zynos_boards[i].vendor_id == bootbase_info.vendor_id && 
    160160                        zynos_boards[i].board_id == bootbase_info.board_id) { 
     
    174174        u16     sdid; 
    175175} mylo_boards[]  __initdata = { 
    176 #define MYLO_BOARD(v,d,sv,sd,mt) { .vid = (v), .did = (d), .svid = (sv), \ 
    177         .sdid = (sd), .mach_type = (mt) } 
    178 #define COMPEX_BOARD(d,mt) MYLO_BOARD(VENID_COMPEX,(d),VENID_COMPEX,(d),(mt)) 
     176#define MYLO_BOARD(v, d, sv, sd, mt) \ 
     177        {.vid = (v), .did = (d), .svid = (sv), .sdid = (sd), .mach_type = (mt)} 
     178#define COMPEX_BOARD(d, mt) \ 
     179        MYLO_BOARD(VENID_COMPEX, (d), VENID_COMPEX, (d), (mt)) 
    179180 
    180181        COMPEX_BOARD(DEVID_COMPEX_NP27G, MACH_ADM5120_NP27G), 
     
    194195 
    195196        ret = MACH_ADM5120_GENERIC; 
    196         for (i=0; i<ARRAY_SIZE(mylo_boards); i++) { 
     197        for (i = 0; i < ARRAY_SIZE(mylo_boards); i++) { 
    197198                if (mylo_boards[i].vid == myloader_info.vid && 
    198199                        mylo_boards[i].did == myloader_info.did && 
     
    250251        /* init command line, register a default kernel command line */ 
    251252        cmd = &_image_cmdline + 8; 
    252         if( strlen(cmd) > 0) strcpy( &(arcs_cmdline[0]), cmd); 
    253                 else strcpy(&(arcs_cmdline[0]), CONFIG_CMDLINE); 
     253        if (strlen(cmd) > 0) 
     254                strcpy(arcs_cmdline, cmd); 
     255        else 
     256                strcpy(arcs_cmdline, CONFIG_CMDLINE); 
    254257 
    255258} 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/prom/bootbase.c

    r8538 r9263  
    4242#define BOOTEXT_ADDR_MAX        (BOOTEXT_ADDR_MIN + (2*1024*1024)) 
    4343 
    44 static int bootbase_found = 0; 
     44static int bootbase_found; 
    4545static struct zynos_board_info *board_info; 
    4646 
     
    6969static inline u16 bootbase_get_vendor_id(void) 
    7070{ 
    71 #define CHECK_VENDOR(n) (strnicmp(board_info->vendor,(n),strlen(n)) == 0) 
     71#define CHECK_VENDOR(n) (strnicmp(board_info->vendor, (n), strlen(n)) == 0) 
    7272        unsigned char vendor[ZYNOS_NAME_LEN]; 
    7373        int i; 
    7474 
    75         for (i=0; i<ZYNOS_NAME_LEN; i++) 
    76                 vendor[i]=board_info->vendor[i]; 
     75        for (i = 0; i < ZYNOS_NAME_LEN; i++) 
     76                vendor[i] = board_info->vendor[i]; 
    7777 
    7878        if CHECK_VENDOR(ZYNOS_VENDOR_ZYXEL) 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/prom/cfe.c

    r8538 r9263  
    3838from other bootloaders */ 
    3939 
    40 static int cfe_found = 0; 
     40static int cfe_found; 
    4141 
    4242static u32 cfe_handle; 
     
    5959 
    6060        /* Check for CFE by finding the CFE magic number */ 
    61         if (cfe_seal != CFE_EPTSEAL) { 
    62                 /* We are not booted from CFE */ 
     61        if (cfe_seal != CFE_EPTSEAL) 
    6362                return 0; 
    64         } 
    6563 
    6664        /* cfe_a1_val must be 0, because only one CPU present in the ADM5120 */ 
    67         if (a1 != 0) { 
     65        if (a1 != 0) 
    6866                return 0; 
    69         } 
    7067 
    7168        /* The cfe_handle, and the cfe_entry must be kernel mode addresses */ 
    72         if ((cfe_handle < KSEG0) || (cfe_entry < KSEG0)) { 
     69        if ((cfe_handle < KSEG0) || (cfe_entry < KSEG0)) 
    7370                return 0; 
    74         } 
    7571 
    7672        cfe_found = 1; 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/prom/myloader.c

    r8538 r9263  
    4141#define PART_TABLE_ADDR         KSEG1ADDR(ADM5120_SRAM0_BASE+0x10000) 
    4242 
    43 static int myloader_found = 0; 
     43static int myloader_found; 
    4444 
    4545struct myloader_info myloader_info; 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/prom/routerboot.c

    r8538 r9263  
    3737 
    3838static struct rb_hard_settings rb_hs; 
    39 static int rb_found = 0; 
     39static int rb_found; 
    4040 
    4141static int __init routerboot_load_hs(u8 *buf, u16 buflen) 
    4242{ 
    43         u16 id,len; 
     43        u16 id, len; 
    4444        u8 *mac; 
    45         int i,j; 
     45        int i, j; 
    4646 
    4747        memset(&rb_hs, 0, sizeof(rb_hs)); 
     
    8989                                rb_hs.mac_count = RB_MAX_MAC_COUNT; 
    9090                        mac = buf; 
    91                         for (i=0; i < rb_hs.mac_count; i++) { 
    92                                 for (j=0; j < RB_MAC_SIZE; j++) 
     91                        for (i = 0; i < rb_hs.mac_count; i++) { 
     92                                for (j = 0; j < RB_MAC_SIZE; j++) 
    9393                                        rb_hs.macs[i][j] = mac[j]; 
    9494                                mac += RB_MAC_SIZE; 
     
    112112        struct rb_bios_settings *bs; 
    113113        u8 *base; 
    114         u32 off,len; 
     114        u32 off, len; 
    115115 
    116116        if (rb_found) 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/reset.c

    r8538 r9263  
    3030#include <linux/init.h> 
    3131 
     32#include <linux/irq.h> 
     33#include <linux/io.h> 
     34 
    3235#include <asm/bootinfo.h> 
    3336#include <asm/addrspace.h> 
    3437 
    35 #include <asm/mach-adm5120/adm5120_info.h> 
    36 #include <asm/mach-adm5120/adm5120_defs.h> 
    37 #include <asm/mach-adm5120/adm5120_switch.h> 
    38  
    39 #define ADM5120_SOFTRESET       0x12000004 
     38#include <adm5120_info.h> 
     39#include <adm5120_defs.h> 
     40#include <adm5120_switch.h> 
    4041 
    4142void (*adm5120_board_reset)(void); 
     
    4849                adm5120_board_reset(); 
    4950 
    50         *(u32*)KSEG1ADDR(ADM5120_SOFTRESET)=1; 
     51        SW_WRITE_REG(SOFT_RESET, 1); 
    5152} 
    5253 
    5354void adm5120_halt(void) 
    5455{ 
    55         printk(KERN_NOTICE "\n** You can safely turn off the power\n"); 
    56         while (1); 
     56        local_irq_disable(); 
     57 
     58        printk(KERN_NOTICE "\n** You can safely turn off the power\n"); 
     59        while (1) { 
     60                if (cpu_wait) 
     61                        cpu_wait(); 
     62        }; 
    5763} 
    58  
    59 void adm5120_power_off(void) 
    60 { 
    61         adm5120_halt(); 
    62 } 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/setup.c

    r8538 r9263  
    2828#include <linux/init.h> 
    2929#include <linux/kernel.h> 
     30#include <linux/io.h> 
    3031 
    3132#include <asm/reboot.h> 
    32 #include <asm/io.h> 
    3333#include <asm/time.h> 
    3434 
    35 #include <asm/mach-adm5120/adm5120_info.h> 
    36 #include <asm/mach-adm5120/adm5120_defs.h> 
    37 #include <asm/mach-adm5120/adm5120_switch.h> 
    38 #include <asm/mach-adm5120/adm5120_board.h> 
     35#include <adm5120_info.h> 
     36#include <adm5120_defs.h> 
     37#include <adm5120_switch.h> 
     38#include <adm5120_board.h> 
    3939 
    4040static char *prom_names[ADM5120_PROM_LAST+1] __initdata = { 
     
    4949static void __init adm5120_report(void) 
    5050{ 
    51         printk(KERN_INFO "SoC      : ADM%04X%s revision %d, running at %ldMHz\n", 
     51        printk(KERN_INFO "SoC      : ADM%04X%s revision %d, running " 
     52                "at %ldMHz\n", 
    5253                adm5120_product_code, 
    53                 (adm5120_package == ADM5120_PACKAGE_BGA) ? "" : "P", 
    54                 adm5120_revision, (adm5120_speed / 1000000) 
    55                 ); 
    56         printk(KERN_INFO "Bootdev  : %s flash\n", adm5120_nand_boot ? "NAND":"NOR"); 
     54                adm5120_package_bga() ? "" : "P", 
     55                adm5120_revision, (adm5120_speed / 1000000)); 
     56        printk(KERN_INFO "Bootdev  : %s flash\n", 
     57                adm5120_nand_boot ? "NAND":"NOR"); 
    5758        printk(KERN_INFO "Prom     : %s\n", prom_names[adm5120_prom_type]); 
    5859} 
     
    6869        _machine_restart = adm5120_restart; 
    6970        _machine_halt = adm5120_halt; 
    70         pm_power_off = adm5120_power_off; 
     71        pm_power_off = adm5120_halt; 
    7172 
    7273        set_io_port_base(KSEG1); 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/time.c

    r8538 r9263  
    3838#include <asm/time.h> 
    3939 
    40 #include <asm/mach-adm5120/adm5120_info.h> 
    41 #include <asm/mach-adm5120/adm5120_irq.h> 
     40#include <adm5120_info.h> 
     41#include <adm5120_irq.h> 
    4242 
    4343void __init adm5120_time_init(void) 
  • trunk/target/linux/adm5120/files/arch/mips/pci/pci-adm5120.c

    r9260 r9263  
    2929#include <linux/init.h> 
    3030#include <linux/spinlock.h> 
     31#include <linux/io.h> 
    3132 
    3233#include <linux/pci.h> 
     
    3435#include <linux/pci_regs.h> 
    3536 
    36 #include <asm/io.h> 
    3737#include <asm/delay.h> 
    3838#include <asm/bootinfo.h> 
     
    4646 
    4747#ifdef DEBUG 
    48 #define DBG(f, a...)    printk(KERN_DEBUG f, ## a ) 
     48#define DBG(f, a...)    printk(KERN_DEBUG f, ## a) 
    4949#else 
    5050#define DBG(f, a...)    do {} while (0) 
     
    5555/* -------------------------------------------------------------------------*/ 
    5656 
    57 static unsigned int adm5120_pci_nr_irqs __initdata = 0; 
    58 static struct adm5120_pci_irq *adm5120_pci_irq_map __initdata = NULL; 
     57static unsigned int adm5120_pci_nr_irqs __initdata; 
     58static struct adm5120_pci_irq *adm5120_pci_irq_map __initdata; 
    5959 
    6060static spinlock_t pci_lock = SPIN_LOCK_UNLOCKED; 
     
    9494        spin_lock_irqsave(&pci_lock, flags); 
    9595 
    96         write_cfgaddr(mkaddr(bus,devfn,where)); 
     96        write_cfgaddr(mkaddr(bus, devfn, where)); 
    9797        data = read_cfgdata(); 
    9898 
     
    133133        spin_lock_irqsave(&pci_lock, flags); 
    134134 
    135         write_cfgaddr(mkaddr(bus,devfn,where)); 
     135        write_cfgaddr(mkaddr(bus, devfn, where)); 
    136136        data = read_cfgdata(); 
    137137 
     
    227227        if (irq < 0) { 
    228228                printk(KERN_ALERT "PCI: no irq found for %s pin:%u\n", 
    229                         pci_name(dev), pin); 
     229                        pci_name((struct pci_dev *)dev), pin); 
    230230        } else { 
    231231                printk(KERN_INFO "PCI: mapping irq for %s pin:%u, irq:%d\n", 
    232                         pci_name(dev), pin, irq); 
     232                        pci_name((struct pci_dev *)dev), pin, irq); 
    233233        } 
    234234 
  • trunk/target/linux/adm5120/files/drivers/leds/leds-adm5120.c

    r9261 r9263  
    5555}; 
    5656 
    57 static int led_count = 0; 
     57static int led_count; 
    5858static struct adm5120_leddev *led_devs[NUM_LEDS_MAX]; 
    5959 
     
    6161static struct gpio_led n ## _leds [] __initdata = 
    6262 
    63 #define LED_DATA(n,t,g,al) {                    \ 
    64         .name = (n),                            \ 
    65         .default_trigger = (t),                 \ 
    66         .gpio = (g),                            \ 
    67         .active_low = (al)                      \ 
    68         } 
    69  
    70 #define LED_STD(g,n,t)  LED_DATA((n),(t),(g), 0) 
    71 #define LED_INV(g,n,t)  LED_DATA((n),(t),(g), 1) 
     63#define LED_DATA(n, t, g, a) {  \ 
     64        .name = (n),            \ 
     65        .default_trigger = (t), \ 
     66        .gpio = (g),            \ 
     67        .active_low = (a)       \ 
     68} 
     69 
     70#define LED_STD(g, n, t)        LED_DATA((n), (t), (g), 0) 
     71#define LED_INV(g, n, t)        LED_DATA((n), (t), (g), 1) 
    7272 
    7373/* 
     
    7676#if defined(CONFIG_LEDS_ADM5120_EXPERIMENTAL) 
    7777LED_ARRAY(np27g) { /* FIXME: untested */ 
    78         LED_STD(ADM5120_GPIO_xxxx, "lan1",      NULL ), 
    79         LED_STD(ADM5120_GPIO_xxxx, "lan2",      NULL ), 
    80         LED_STD(ADM5120_GPIO_xxxx, "lan3",      NULL ), 
    81         LED_STD(ADM5120_GPIO_xxxx, "lan4",      NULL ), 
    82         LED_STD(ADM5120_GPIO_xxxx, "wan_cond",  NULL ), 
    83         LED_STD(ADM5120_GPIO_xxxx, "wlan",      NULL ), 
    84         LED_STD(ADM5120_GPIO_xxxx, "wan_act",   NULL ), 
    85         LED_STD(ADM5120_GPIO_xxxx, "usb1",      NULL ), 
    86         LED_STD(ADM5120_GPIO_xxxx, "usb2",      NULL ), 
    87         LED_INV(ADM5120_GPIO_PIN2, "power",     NULL ), 
    88         LED_STD(ADM5120_GPIO_xxxx, "diag",      NULL ), 
     78        LED_STD(ADM5120_GPIO_xxxx, "lan1",      NULL), 
     79        LED_STD(ADM5120_GPIO_xxxx, "lan2",      NULL), 
     80        LED_STD(ADM5120_GPIO_xxxx, "lan3",      NULL), 
     81        LED_STD(ADM5120_GPIO_xxxx, "lan4",      NULL), 
     82        LED_STD(ADM5120_GPIO_xxxx, "wan_cond",  NULL), 
     83        LED_STD(ADM5120_GPIO_xxxx, "wlan",      NULL), 
     84        LED_STD(ADM5120_GPIO_xxxx, "wan_act",   NULL), 
     85        LED_STD(ADM5120_GPIO_xxxx, "usb1",      NULL), 
     86        LED_STD(ADM5120_GPIO_xxxx, "usb2",      NULL), 
     87        LED_INV(ADM5120_GPIO_PIN2, "power",     NULL), 
     88        LED_STD(ADM5120_GPIO_xxxx, "diag",      NULL), 
    8989}; 
    9090#endif 
     
    9292#if defined(CONFIG_LEDS_ADM5120_EXPERIMENTAL) 
    9393LED_ARRAY(np28g) { /* FIXME: untested */ 
    94         LED_STD(ADM5120_GPIO_xxxx, "lan1",      NULL ), 
    95         LED_STD(ADM5120_GPIO_xxxx, "lan2",      NULL ), 
    96         LED_STD(ADM5120_GPIO_xxxx, "lan3",      NULL ), 
    97         LED_STD(ADM5120_GPIO_xxxx, "wan",       NULL ), 
    98         LED_STD(ADM5120_GPIO_xxxx, "wlan",      NULL ), 
    99         LED_STD(ADM5120_GPIO_xxxx, "usb1",      NULL ), 
    100         LED_STD(ADM5120_GPIO_xxxx, "usb2",      NULL ), 
    101         LED_STD(ADM5120_GPIO_xxxx, "usb3",      NULL ), 
    102         LED_STD(ADM5120_GPIO_xxxx, "usb4",      NULL ), 
    103         LED_INV(ADM5120_GPIO_PIN2, "power",     NULL ), 
    104         LED_STD(ADM5120_GPIO_xxxx, "diag",      NULL ), 
     94        LED_STD(ADM5120_GPIO_xxxx, "lan1",      NULL), 
     95        LED_STD(ADM5120_GPIO_xxxx, "lan2",      NULL), 
     96        LED_STD(ADM5120_GPIO_xxxx, "lan3",      NULL), 
     97        LED_STD(ADM5120_GPIO_xxxx, "wan",       NULL), 
     98        LED_STD(ADM5120_GPIO_xxxx, "wlan",      NULL), 
     99        LED_STD(ADM5120_GPIO_xxxx, "usb1",      NULL), 
     100        LED_STD(ADM5120_GPIO_xxxx, "usb2",      NULL), 
     101        LED_STD(ADM5120_GPIO_xxxx, "usb3",      NULL), 
     102        LED_STD(ADM5120_GPIO_xxxx, "usb4",      NULL), 
     103        LED_INV(ADM5120_GPIO_PIN2, "power",     NULL), 
     104        LED_STD(ADM5120_GPIO_xxxx, "diag",      NULL), 
    105105}; 
    106106#endif 
    107107 
    108108LED_ARRAY(wp54g) { 
    109         LED_INV(ADM5120_GPIO_PIN2, "diag",      NULL ), 
    110         LED_INV(ADM5120_GPIO_PIN6, "wlan",      NULL ), 
    111         LED_INV(ADM5120_GPIO_PIN7, "wan",       NULL ), 
    112         LED_INV(ADM5120_GPIO_P0L0, "lan1",      NULL ), 
    113         LED_INV(ADM5120_GPIO_P1L0, "lan2",      NULL ), 
     109        LED_INV(ADM5120_GPIO_PIN2, "diag",      NULL), 
     110        LED_INV(ADM5120_GPIO_PIN6, "wlan",      NULL), 
     111        LED_INV(ADM5120_GPIO_PIN7, "wan",       NULL), 
     112        LED_INV(ADM5120_GPIO_P0L0, "lan1",      NULL), 
     113        LED_INV(ADM5120_GPIO_P1L0, "lan2",      NULL), 
    114114}; 
    115115 
     
    118118 */ 
    119119LED_ARRAY(br6104k) { 
    120         LED_STD(ADM5120_GPIO_PIN0, "power",             NULL ), 
    121         LED_INV(ADM5120_GPIO_P0L1, "wan_speed",         NULL ), 
    122         LED_INV(ADM5120_GPIO_P0L0, "wan_lnkact",        NULL ), 
    123         LED_INV(ADM5120_GPIO_P1L1, "lan1_speed",        NULL ), 
    124         LED_INV(ADM5120_GPIO_P1L0, "lan1_lnkact",       NULL ), 
    125         LED_INV(ADM5120_GPIO_P2L1, "lan2_speed",        NULL ), 
    126         LED_INV(ADM5120_GPIO_P2L0, "lan2_lnkact",       NULL ), 
    127         LED_INV(ADM5120_GPIO_P3L1, "lan3_speed",        NULL ), 
    128         LED_INV(ADM5120_GPIO_P3L0, "lan3_lnkact",       NULL ), 
    129         LED_INV(ADM5120_GPIO_P4L1, "lan4_speed",        NULL ), 
    130         LED_INV(ADM5120_GPIO_P4L0, "lan4_lnkact",       NULL ), 
     120        LED_STD(ADM5120_GPIO_PIN0, "power",             NULL), 
     121        LED_INV(ADM5120_GPIO_P0L1, "wan_speed",         NULL), 
     122        LED_INV(ADM5120_GPIO_P0L0, "wan_lnkact",        NULL), 
     123        LED_INV(ADM5120_GPIO_P1L1, "lan1_speed",        NULL), 
     124        LED_INV(ADM5120_GPIO_P1L0, "lan1_lnkact",       NULL), 
     125        LED_INV(ADM5120_GPIO_P2L1, "lan2_speed",        NULL), 
     126        LED_INV(ADM5120_GPIO_P2L0, "lan2_lnkact",       NULL), 
     127        LED_INV(ADM5120_GPIO_P3L1, "lan3_speed",        NULL), 
     128        LED_INV(ADM5120_GPIO_P3L0, "lan3_lnkact",       NULL), 
     129        LED_INV(ADM5120_GPIO_P4L1, "lan4_speed",        NULL), 
     130        LED_INV(ADM5120_GPIO_P4L0, "lan4_lnkact",       NULL), 
    131131}; 
    132132 
     
    136136#if defined(CONFIG_LEDS_ADM5120_EXPERIMENTAL) 
    137137LED_ARRAY(rb100) { /* FIXME: untested */ 
    138         LED_STD(ADM5120_GPIO_PIN6, "power",     NULL ), 
    139         LED_STD(ADM5120_GPIO_PIN3, "user",      NULL ), 
     138        LED_STD(ADM5120_GPIO_PIN6, "power",     NULL), 
     139        LED_STD(ADM5120_GPIO_PIN3, "user",      NULL), 
    140140}; 
    141141#endif 
    142142 
    143143LED_ARRAY(rb133) { 
    144         LED_STD(ADM5120_GPIO_PIN6, "power",     NULL ), 
    145         LED_STD(ADM5120_GPIO_PIN5, "user",      NULL ), 
     144        LED_STD(ADM5120_GPIO_PIN6, "power",     NULL), 
     145        LED_STD(ADM5120_GPIO_PIN5, "user",      NULL), 
    146146}; 
    147147 
     
    151151#if defined(CONFIG_LEDS_ADM5120_EXPERIMENTAL) 
    152152LED_ARRAY(p334) { /* FIXME: untested */ 
    153         LED_INV(ADM5120_GPIO_xxxx, "power",     NULL ), 
    154         LED_INV(ADM5120_GPIO_xxxx, "lan1",      NULL ), 
    155         LED_INV(ADM5120_GPIO_xxxx, "lan2",      NULL ), 
    156         LED_INV(ADM5120_GPIO_xxxx, "lan3",      NULL ), 
    157         LED_INV(ADM5120_GPIO_xxxx, "lan4",      NULL ), 
    158         LED_INV(ADM5120_GPIO_xxxx, "wan",       NULL ), 
     153        LED_INV(ADM5120_GPIO_xxxx, "power",     NULL), 
     154        LED_INV(ADM5120_GPIO_xxxx, "lan1",      NULL), 
     155        LED_INV(ADM5120_GPIO_xxxx, "lan2",      NULL), 
     156        LED_INV(ADM5120_GPIO_xxxx, "lan3",      NULL), 
     157        LED_INV(ADM5120_GPIO_xxxx, "lan4",      NULL), 
     158        LED_INV(ADM5120_GPIO_xxxx, "wan",       NULL), 
    159159}; 
    160160#endif 
    161161 
    162162LED_ARRAY(p334wt) { 
    163         LED_INV(ADM5120_GPIO_PIN2, "power",     NULL ), 
    164         LED_INV(ADM5120_GPIO_P3L0, "lan1",      NULL ), 
    165         LED_INV(ADM5120_GPIO_P2L0, "lan2",      NULL ), 
    166         LED_INV(ADM5120_GPIO_P1L0, "lan3",      NULL ), 
    167         LED_INV(ADM5120_GPIO_P0L0, "lan4",      NULL ), 
    168         LED_INV(ADM5120_GPIO_P4L0, "wan",       NULL ), 
    169         LED_INV(ADM5120_GPIO_P4L2, "wlan",      NULL ), 
    170         LED_INV(ADM5120_GPIO_P2L2, "otist",     NULL ), 
    171         LED_INV(ADM5120_GPIO_P1L2, "hidden",    NULL ), 
     163        LED_INV(ADM5120_GPIO_PIN2, "power",     NULL), 
     164        LED_INV(ADM5120_GPIO_P3L0, "lan1",      NULL), 
     165        LED_INV(ADM5120_GPIO_P2L0, "lan2",      NULL), 
     166        LED_INV(ADM5120_GPIO_P1L0, "lan3",      NULL), 
     167        LED_INV(ADM5120_GPIO_P0L0, "lan4",      NULL), 
     168        LED_INV(ADM5120_GPIO_P4L0, "wan",       NULL), 
     169        LED_INV(ADM5120_GPIO_P4L2, "wlan",      NULL), 
     170        LED_INV(ADM5120_GPIO_P2L2, "otist",     NULL), 
     171        LED_INV(ADM5120_GPIO_P1L2, "hidden",    NULL), 
    172172}; 
    173173 
    174174#if defined(CONFIG_LEDS_ADM5120_EXPERIMENTAL) 
    175175LED_ARRAY(p335) { /* FIXME: untested */ 
    176         LED_INV(ADM5120_GPIO_PIN2, "power",     NULL ), 
    177         LED_INV(ADM5120_GPIO_P3L0, "lan1",      NULL ), 
    178         LED_INV(ADM5120_GPIO_P2L0, "lan2",      NULL ), 
    179         LED_INV(ADM5120_GPIO_P1L0, "lan3",      NULL ), 
    180         LED_INV(ADM5120_GPIO_P0L0, "lan4",      NULL ), 
    181         LED_INV(ADM5120_GPIO_P4L0, "wan",       NULL ), 
    182         LED_INV(ADM5120_GPIO_P4L2, "wlan",      NULL ), 
    183         LED_INV(ADM5120_GPIO_P2L2, "otist",     NULL ), 
    184         LED_INV(ADM5120_GPIO_xxxx, "usb",       NULL ), 
     176        LED_INV(ADM5120_GPIO_PIN2, "power",     NULL), 
     177        LED_INV(ADM5120_GPIO_P3L0, "lan1",      NULL), 
     178        LED_INV(ADM5120_GPIO_P2L0, "lan2",      NULL), 
     179        LED_INV(ADM5120_GPIO_P1L0, "lan3",      NULL), 
     180        LED_INV(ADM5120_GPIO_P0L0, "lan4",      NULL), 
     181        LED_INV(ADM5120_GPIO_P4L0, "wan",       NULL), 
     182        LED_INV(ADM5120_GPIO_P4L2, "wlan",      NULL), 
     183        LED_INV(ADM5120_GPIO_P2L2, "otist",     NULL), 
     184        LED_INV(ADM5120_GPIO_xxxx, "usb",       NULL), 
    185185}; 
    186186#endif 
     
    191191LED_ARRAY(generic) { 
    192192#if defined(CONFIG_LEDS_ADM5120_DIAG) 
    193         LED_STD(ADM5120_GPIO_PIN0, "gpio0",     NULL ), 
    194         LED_STD(ADM5120_GPIO_PIN1, "gpio1",     NULL ), 
    195         LED_STD(ADM5120_GPIO_PIN2, "gpio2",     NULL ), 
    196         LED_STD(ADM5120_GPIO_PIN3, "gpio3",     NULL ), 
    197         LED_STD(ADM5120_GPIO_PIN4, "gpio4",     NULL ), 
    198         LED_STD(ADM5120_GPIO_PIN5, "gpio5",     NULL ), 
    199         LED_STD(ADM5120_GPIO_PIN6, "gpio6",     NULL ), 
    200         LED_STD(ADM5120_GPIO_PIN7, "gpio7",     NULL ), 
    201         LED_STD(ADM5120_GPIO_P0L0, "port0led0", NULL ), 
    202         LED_STD(ADM5120_GPIO_P0L1, "port0led1", NULL ), 
    203         LED_STD(ADM5120_GPIO_P0L2, "port0led2", NULL ), 
    204         LED_STD(ADM5120_GPIO_P1L0, "port1led0", NULL ), 
    205         LED_STD(ADM5120_GPIO_P1L1, "port1led1", NULL ), 
    206         LED_STD(ADM5120_GPIO_P1L2, "port1led2", NULL ), 
    207         LED_STD(ADM5120_GPIO_P2L0, "port2led0", NULL ), 
    208         LED_STD(ADM5120_GPIO_P2L1, "port2led1", NULL ), 
    209         LED_STD(ADM5120_GPIO_P2L2, "port2led2", NULL ), 
    210         LED_STD(ADM5120_GPIO_P3L0, "port3led0", NULL ), 
    211         LED_STD(ADM5120_GPIO_P3L1, "port3led1", NULL ), 
    212         LED_STD(ADM5120_GPIO_P3L2, "port3led2", NULL ), 
    213         LED_STD(ADM5120_GPIO_P4L0, "port4led0", NULL ), 
    214         LED_STD(ADM5120_GPIO_P4L1, "port4led1", NULL ), 
    215         LED_STD(ADM5120_GPIO_P4L2, "port4led2", NULL ), 
    216 #endif 
    217 }; 
    218  
    219 #define MACH_DATA(m, n) {                               \ 
     193        LED_STD(ADM5120_GPIO_PIN0, "gpio0",     NULL), 
     194        LED_STD(ADM5120_GPIO_PIN1, "gpio1",     NULL), 
     195        LED_STD(ADM5120_GPIO_PIN2, "gpio2",     NULL), 
     196        LED_STD(ADM5120_GPIO_PIN3, "gpio3",     NULL), 
     197        LED_STD(ADM5120_GPIO_PIN4, "gpio4",     NULL), 
     198        LED_STD(ADM5120_GPIO_PIN5, "gpio5",     NULL), 
     199        LED_STD(ADM5120_GPIO_PIN6, "gpio6",     NULL), 
     200        LED_STD(ADM5120_GPIO_PIN7, "gpio7",     NULL), 
     201        LED_STD(ADM5120_GPIO_P0L0, "port0led0", NULL), 
     202        LED_STD(ADM5120_GPIO_P0L1, "port0led1", NULL), 
     203        LED_STD(ADM5120_GPIO_P0L2, "port0led2", NULL), 
     204        LED_STD(ADM5120_GPIO_P1L0, "port1led0", NULL), 
     205        LED_STD(ADM5120_GPIO_P1L1, "port1led1", NULL), 
     206        LED_STD(ADM5120_GPIO_P1L2, "port1led2", NULL), 
     207        LED_STD(ADM5120_GPIO_P2L0, "port2led0", NULL), 
     208        LED_STD(ADM5120_GPIO_P2L1, "port2led1", NULL), 
     209        LED_STD(ADM5120_GPIO_P2L2, "port2led2", NULL), 
     210        LED_STD(ADM5120_GPIO_P3L0, "port3led0", NULL), 
     211        LED_STD(ADM5120_GPIO_P3L1, "port3led1", NULL), 
     212        LED_STD(ADM5120_GPIO_P3L2, "port3led2", NULL), 
     213        LED_STD(ADM5120_GPIO_P4L0, "port4led0", NULL), 
     214        LED_STD(ADM5120_GPIO_P4L1, "port4led1", NULL), 
     215        LED_STD(ADM5120_GPIO_P4L2, "port4led2", NULL), 
     216#endif 
     217}; 
     218 
     219#define MACH_DATA(m, n) {                               \ 
    220220        .machtype       = (m),                          \ 
    221221        .nr_leds        = ARRAY_SIZE(n ## _leds),       \ 
    222         .leds           = n ## _leds                    \ 
     222        .leds           = n ## _leds                    \ 
    223223} 
    224224 
     
    263263        p->pdev.id = id; 
    264264        p->pdev.dev.platform_data = &p->pdata; 
    265         p->pdata.num_leds=1; 
     265        p->pdata.num_leds = 1; 
    266266        p->pdata.leds = &p->led; 
    267267 
    268268        return p; 
    269 } 
    270  
    271 static void 
    272 destroy_leddev(struct adm5120_leddev *leddev) 
    273 { 
    274         if (leddev) 
    275                 kfree(leddev); 
    276269} 
    277270 
     
    283276 
    284277        mach = NULL; 
    285         for (i=0; i<ARRAY_SIZE(machines); i++) { 
     278        for (i = 0; i < ARRAY_SIZE(machines); i++) { 
    286279                if (machines[i].machtype == machtype) { 
    287280                        mach = &machines[i]; 
     
    316309        } 
    317310 
    318         for (i=0; i < mach->nr_leds; i++) { 
     311        for (i = 0; i < mach->nr_leds; i++) { 
    319312                led_devs[i] = create_leddev(i, &mach->leds[i]); 
    320313                if (led_devs[i] == NULL) { 
     
    324317        } 
    325318 
    326         for (i=0; i < mach->nr_leds; i++) { 
     319        for (i = 0; i < mach->nr_leds; i++) { 
    327320                ret = platform_device_register(&led_devs[i]->pdev); 
    328321                if (ret) 
     
    334327 
    335328err_unregister: 
    336         for (i--; i>=0; i--) 
     329        for (i--; i >= 0; i--) 
    337330                platform_device_unregister(&led_devs[i]->pdev); 
    338331 
    339332err_destroy: 
    340         for (i=0; i<led_count; i++) 
    341                 destroy_leddev(led_devs[i]); 
     333        for (i = 0; i < led_count; i++) 
     334                kfree(led_devs[i]); 
    342335err: 
    343336        return ret; 
     
    349342        int i; 
    350343 
    351         for (i=0; i < led_count; i++) { 
     344        for (i = 0; i < led_count; i++) { 
    352345                platform_device_unregister(&led_devs[i]->pdev); 
    353                 destroy_leddev(led_devs[i]); 
     346                kfree(led_devs[i]); 
    354347        } 
    355348} 
  • trunk/target/linux/adm5120/files/drivers/mtd/maps/adm5120-flash.c

    r8707 r9263  
    3333#include <linux/init.h> 
    3434#include <linux/slab.h> 
     35#include <linux/io.h> 
    3536#include <linux/device.h> 
    36  
    3737#include <linux/platform_device.h> 
     38 
    3839#include <linux/mtd/mtd.h> 
    3940#include <linux/mtd/map.h> 
    4041#include <linux/mtd/partitions.h> 
    41  
    42 #include <asm/io.h> 
    4342 
    4443#include <adm5120_defs.h> 
     
    174173        struct adm5120_map_info *amap = map_to_amap(map); 
    175174 
    176         MAP_DBG(map,"writing to ofs %lX\n", ofs); 
     175        MAP_DBG(map, "writing to ofs %lX\n", ofs); 
    177176 
    178177        if (ofs > amap->window_size) 
     
    330329static int adm5120_flash_initparts(struct adm5120_flash_info *info) 
    331330{ 
    332         struct adm5120_flash_platform_data *pdata = info->dev->dev.platform_data; 
     331        struct adm5120_flash_platform_data *pdata; 
    333332        struct map_info *map = &info->amap.map; 
    334333        int num_parsers; 
     
    340339        info->nr_parts = 0; 
    341340 
     341        pdata = info->dev->dev.platform_data; 
    342342        if (pdata == NULL) 
    343343                goto out; 
     
    358358 
    359359        parser[1] = NULL; 
    360         for (i=0; i<num_parsers; i++) { 
     360        for (i = 0; i < num_parsers; i++) { 
    361361                parser[0] = parse_types[i]; 
    362362 
     
    395395        if (info->nr_parts) { 
    396396                del_mtd_partitions(info->mtd); 
    397                 for (i=0; i<MAX_PARSED_PARTS; i++) 
     397                for (i = 0; i < MAX_PARSED_PARTS; i++) 
    398398                        if (info->parts[i] != NULL) 
    399399                                kfree(info->parts[i]); 
     
    497497 
    498498        if (info->nr_parts == 0) { 
    499                 MAP_INFO(map, "no partitions available, registering whole flash\n"); 
     499                MAP_INFO(map, "no partitions available, registering " 
     500                        "whole flash\n"); 
    500501                add_mtd_device(info->mtd); 
    501502        } 
     
    509510 
    510511#ifdef CONFIG_PM 
    511 static int adm5120_flash_suspend(struct platform_device *dev, pm_message_t state) 
     512static int adm5120_flash_suspend(struct platform_device *dev, 
     513                pm_message_t state) 
    512514{ 
    513515        struct adm5120_flash_info *info = platform_get_drvdata(dev); 
  • trunk/target/linux/adm5120/files/drivers/mtd/myloader.c

    r8538 r9263  
    5555        int ret, i; 
    5656        size_t retlen; 
    57         size_t parts_len; 
    5857        char *names; 
    5958        unsigned long offset; 
     
    105104        } 
    106105 
    107         mtd_parts = kzalloc((num_parts*sizeof(*mtd_part) + num_parts*NAME_LEN_MAX), 
    108                         GFP_KERNEL); 
     106        mtd_parts = kzalloc((num_parts * sizeof(*mtd_part) + 
     107                                num_parts * NAME_LEN_MAX), GFP_KERNEL); 
    109108 
    110109        if (!mtd_parts) { 
  • trunk/target/linux/adm5120/files/drivers/mtd/trxsplit.c

    r9085 r9263  
    3939#define TRX_VERSION     1 
    4040#define TRX_MAX_LEN     0x3A0000 
    41 #define TRX_NO_HEADER   1               /* Do not write TRX header */ 
    42 #define TRX_GZ_FILES    0x2     /* Contains up to TRX_MAX_OFFSET individual gzip files */ 
     41#define TRX_NO_HEADER   0x1     /* do not write TRX header */ 
     42#define TRX_GZ_FILES    0x2     /* contains individual gzip files */ 
    4343#define TRX_MAX_OFFSET  3 
    4444#define TRX_MIN_KERNEL_SIZE     256*1024 
    4545 
    4646struct trx_header { 
    47         u32 magic;              /* "HDR0" */ 
    48         u32 len;                /* Length of file including header */ 
    49         u32 crc32;              /* 32-bit CRC from flag_version to end of file */ 
    50         u32 flag_version;       /* 0:15 flags, 16:31 version */ 
    51         u32 offsets[TRX_MAX_OFFSET];    /* Offsets of partitions from start of header */ 
     47        u32 magic;      /* "HDR0" */ 
     48        u32 len;        /* Length of file including header */ 
     49        u32 crc32;      /* 32-bit CRC from flag_version to end of file */ 
     50        u32 flag_version; /* 0:15 flags, 16:31 version */ 
     51        u32 offsets[TRX_MAX_OFFSET]; /* Offsets of partitions */ 
    5252}; 
    5353 
    5454#define BLOCK_LEN_MIN           0x10000 
    5555 
    56 static struct mtd_info *trx_mtd = NULL; 
    57 static unsigned long trx_offset = 0; 
    58 static int trx_nr_parts = 0; 
     56static int trx_nr_parts; 
     57static unsigned long trx_offset; 
     58static struct mtd_info *trx_mtd; 
    5959static struct mtd_partition trx_parts[TRX_MAX_OFFSET]; 
    6060static struct trx_header trx_hdr; 
     
    6767        int err; 
    6868 
    69         err = mtd->read(mtd, offset, sizeof(trx_hdr), &retlen, (void *)&trx_hdr); 
     69        err = mtd->read(mtd, offset, sizeof(trx_hdr), &retlen, 
     70                        (void *)&trx_hdr); 
    7071        if (err) { 
    7172                printk(KERN_ALERT PFX "unable to read from '%s'\n", mtd->name); 
     
    114115 
    115116        err = 0; 
    116         for (offset=0; offset < mtd->size; offset+=blocklen) { 
     117        for (offset = 0; offset < mtd->size; offset += blocklen) { 
    117118                err = trxsplit_checktrx(mtd, offset); 
    118119                if (err == 0) 
     
    135136        int i; 
    136137 
    137         for (i=0; i<TRX_MAX_OFFSET;i++) { 
     138        for (i = 0; i < TRX_MAX_OFFSET; i++) { 
    138139                part = &trx_parts[i]; 
    139140                if (trx_hdr.offsets[i] == 0) 
     
    143144        } 
    144145 
    145         for (i=0; i<trx_nr_parts-1; i++) { 
     146        for (i = 0; i < trx_nr_parts-1; i++) 
    146147                trx_parts[i].size = trx_parts[i+1].offset - trx_parts[i].offset; 
    147         } 
     148 
    148149        trx_parts[i].size = mtd->size - trx_parts[i].offset; 
    149150 
    150         i=0; 
     151        i = 0; 
    151152        part = &trx_parts[i]; 
    152153        if (part->size < TRX_MIN_KERNEL_SIZE) { 
     
    217218 
    218219        if (trx_mtd) { 
    219                 printk(KERN_INFO PFX "creating TRX partitions in '%s' (%d,%d)\n", 
    220                         trx_mtd->name, MTD_BLOCK_MAJOR, trx_mtd->index); 
     220                printk(KERN_INFO PFX "creating TRX partitions in '%s' " 
     221                        "(%d,%d)\n", trx_mtd->name, MTD_BLOCK_MAJOR, 
     222                        trx_mtd->index); 
    221223                trxsplit_create_partitions(trx_mtd); 
    222224        } 
  • trunk/target/linux/adm5120/files/include/asm-mips/mach-adm5120/adm5120_info.h

    r8538 r9263  
    6666extern void adm5120_restart(char *command); 
    6767extern void adm5120_halt(void); 
    68 extern void adm5120_power_off(void); 
    6968 
    7069extern void (*adm5120_board_reset)(void); 
Note: See TracChangeset for help on using the changeset viewer.