Changeset 32992


Ignore:
Timestamp:
2012-08-04T21:46:25+02:00 (6 years ago)
Author:
hauke
Message:

brcm47xx: use libgpio instaed of implementing the gpio interface ourself.

Location:
trunk
Files:
3 added
4 deleted
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/broadcom-diag/src/diag.c

    r30610 r32992  
    157157                /* Enables GPIO 3 that controls HDD and led power on ASUS WL-700gE */ 
    158158                printk(MODULE_NAME ": Spinning up HDD and enabling leds\n"); 
    159                 gpio_outen(pin, pin); 
    160                 gpio_control(pin, 0); 
    161                 gpio_out(pin, pin); 
     159                bcm47xx_gpio_outen(pin, pin); 
     160                bcm47xx_gpio_control(pin, 0); 
     161                bcm47xx_gpio_out(pin, pin); 
    162162 
    163163                /* Wait 5s, so the HDD can spin up */ 
     
    169169                /* unset pin 6 (+12V) */ 
    170170                int pin = 1 << 6; 
    171                 gpio_outen(pin, pin); 
    172                 gpio_control(pin, 0); 
    173                 gpio_out(pin, pin); 
     171                bcm47xx_gpio_outen(pin, pin); 
     172                bcm47xx_gpio_control(pin, 0); 
     173                bcm47xx_gpio_out(pin, pin); 
    174174                /* unset pin 1 (turn off red led, blue will light alone if +5V comes up) */ 
    175175                pin = 1 << 1; 
    176                 gpio_outen(pin, pin); 
    177                 gpio_control(pin, 0); 
    178                 gpio_out(pin, pin); 
     176                bcm47xx_gpio_outen(pin, pin); 
     177                bcm47xx_gpio_control(pin, 0); 
     178                bcm47xx_gpio_out(pin, pin); 
    179179                /* unset pin 3 (+5V) and wait 5 seconds (harddisk spin up) */ 
    180180                bcm4780_init(); 
     
    185185 
    186186        /* FIXME: switch comes up, but port mappings/vlans not right */ 
    187         gpio_outen(pin, pin); 
    188         gpio_control(pin, 0); 
    189         gpio_out(pin, pin); 
     187        bcm47xx_gpio_outen(pin, pin); 
     188        bcm47xx_gpio_control(pin, 0); 
     189        bcm47xx_gpio_out(pin, pin); 
    190190} 
    191191 
     
    12841284} 
    12851285 
     1286static inline void ssb_maskset32(struct ssb_device *dev, 
     1287                                  u16 offset, u32 mask, u32 set) 
     1288{ 
     1289        ssb_write32(dev, offset, (ssb_read32(dev, offset) & mask) | set); 
     1290} 
     1291 
     1292static void gpio_set_irqenable(int enabled, irqreturn_t (*handler)(int, void *)) 
     1293{ 
     1294        int irq; 
     1295 
     1296        irq = gpio_to_irq(0); 
     1297        if (irq == -EINVAL) return; 
     1298         
     1299        if (enabled) { 
     1300                if (request_irq(irq, handler, IRQF_SHARED | IRQF_SAMPLE_RANDOM, "gpio", handler)) 
     1301                        return; 
     1302        } else { 
     1303                free_irq(irq, handler); 
     1304        } 
     1305 
     1306        switch (bcm47xx_bus_type) { 
     1307#ifdef CONFIG_BCM47XX_SSB 
     1308        case BCM47XX_BUS_TYPE_SSB: 
     1309                if (bcm47xx_bus.ssb.chipco.dev) 
     1310                        ssb_maskset32(bcm47xx_bus.ssb.chipco.dev, SSB_CHIPCO_IRQMASK, ~SSB_CHIPCO_IRQ_GPIO, (enabled ? SSB_CHIPCO_IRQ_GPIO : 0)); 
     1311                break; 
     1312#endif 
     1313#ifdef CONFIG_BCM47XX_BCMA 
     1314        case BCM47XX_BUS_TYPE_BCMA: 
     1315                if (bcm47xx_bus.bcma.bus.drv_cc.core) 
     1316                        bcma_maskset32(bcm47xx_bus.bcma.bus.drv_cc.core, BCMA_CC_IRQMASK, ~BCMA_CC_IRQ_GPIO, (enabled ? BCMA_CC_IRQ_GPIO : 0)); 
     1317                break; 
     1318#endif 
     1319        } 
     1320} 
     1321 
    12861322static void register_buttons(struct button_t *b) 
    12871323{ 
     
    12911327        platform.button_mask &= ~gpiomask; 
    12921328 
    1293         gpio_outen(platform.button_mask, 0); 
    1294         gpio_control(platform.button_mask, 0); 
    1295         platform.button_polarity = gpio_in() & platform.button_mask; 
    1296         gpio_intpolarity(platform.button_mask, platform.button_polarity); 
    1297         gpio_setintmask(platform.button_mask, platform.button_mask); 
     1329        bcm47xx_gpio_outen(platform.button_mask, 0); 
     1330        bcm47xx_gpio_control(platform.button_mask, 0); 
     1331        platform.button_polarity = bcm47xx_gpio_in(~0) & platform.button_mask; 
     1332        bcm47xx_gpio_polarity(platform.button_mask, platform.button_polarity); 
     1333        bcm47xx_gpio_intmask(platform.button_mask, platform.button_mask); 
    12981334 
    12991335        gpio_set_irqenable(1, button_handler); 
     
    13021338static void unregister_buttons(struct button_t *b) 
    13031339{ 
    1304         gpio_setintmask(platform.button_mask, 0); 
     1340        bcm47xx_gpio_intmask(platform.button_mask, 0); 
    13051341 
    13061342        gpio_set_irqenable(0, button_handler); 
     
    13621398        u32 in, changed; 
    13631399 
    1364         in = gpio_in() & platform.button_mask; 
    1365         gpio_intpolarity(platform.button_mask, in); 
     1400        in = bcm47xx_gpio_in(~0) & platform.button_mask; 
     1401        bcm47xx_gpio_polarity(platform.button_mask, in); 
    13661402        changed = platform.button_polarity ^ in; 
    13671403        platform.button_polarity = in; 
    13681404 
    1369         changed &= ~gpio_outen(0, 0); 
     1405        changed &= ~bcm47xx_gpio_outen(0, 0); 
    13701406 
    13711407        for (b = platform.buttons; b->name; b++) { 
     
    14231459        } 
    14241460 
    1425         gpio_outen(mask, oe_mask); 
    1426         gpio_control(mask, 0); 
    1427         gpio_out(mask, val); 
    1428         gpio_setintmask(mask, 0); 
     1461        bcm47xx_gpio_outen(mask, oe_mask); 
     1462        bcm47xx_gpio_control(mask, 0); 
     1463        bcm47xx_gpio_out(mask, val); 
     1464        bcm47xx_gpio_intmask(mask, 0); 
    14291465} 
    14301466 
     
    14391475static void set_led_extif(struct led_t *led) 
    14401476{ 
    1441         gpio_set_extif(led->gpio, led->state); 
     1477        volatile u8 *addr = (volatile u8 *) KSEG1ADDR(EXTIF_UART) + (led->gpio & ~GPIO_TYPE_MASK); 
     1478        if (led->state) 
     1479                *addr = 0xFF; 
     1480        else 
     1481                *addr; 
    14421482} 
    14431483 
     
    14611501        mask &= ~gpiomask; 
    14621502        if (mask) { 
    1463                 u32 val = ~gpio_in(); 
    1464  
    1465                 gpio_outen(mask, mask); 
    1466                 gpio_control(mask, 0); 
    1467                 gpio_out(mask, val); 
     1503                u32 val = ~bcm47xx_gpio_in(~0); 
     1504 
     1505                bcm47xx_gpio_outen(mask, mask); 
     1506                bcm47xx_gpio_control(mask, 0); 
     1507                bcm47xx_gpio_out(mask, val); 
    14681508        } 
    14691509        if (mask || extif_blink) { 
     
    14921532                                                len = sprintf(page, "%d\n", led->state); 
    14931533                                        } else { 
    1494                                                 u32 in = (gpio_in() & led->gpio ? 1 : 0); 
     1534                                                u32 in = (bcm47xx_gpio_in(~0) & led->gpio ? 1 : 0); 
    14951535                                                u8 p = (led->polarity == NORMAL ? 0 : 1); 
    14961536                                                len = sprintf(page, "%d\n", ((in ^ p) ? 1 : 0)); 
     
    15561596                                                set_led_extif(led); 
    15571597                                        } else { 
    1558                                                 gpio_outen(led->gpio, led->gpio); 
    1559                                                 gpio_control(led->gpio, 0); 
    1560                                                 gpio_out(led->gpio, ((p ^ (page[0] == '1')) ? led->gpio : 0)); 
     1598                                                bcm47xx_gpio_outen(led->gpio, led->gpio); 
     1599                                                bcm47xx_gpio_control(led->gpio, 0); 
     1600                                                bcm47xx_gpio_out(led->gpio, ((p ^ (page[0] == '1')) ? led->gpio : 0)); 
    15611601                                        } 
    15621602                                } 
  • trunk/package/broadcom-diag/src/gpio.h

    r31506 r32992  
    77#include <bcm47xx.h> 
    88 
    9 static inline u32 gpio_in(void) 
    10 { 
    11         switch (bcm47xx_bus_type) { 
    12 #ifdef CONFIG_BCM47XX_SSB 
    13         case BCM47XX_BUS_TYPE_SSB: 
    14                 return ssb_gpio_in(&bcm47xx_bus.ssb, ~0); 
    15 #endif 
    16 #ifdef CONFIG_BCM47XX_BCMA 
    17         case BCM47XX_BUS_TYPE_BCMA: 
    18                 return bcma_chipco_gpio_in(&bcm47xx_bus.bcma.bus.drv_cc, ~0); 
    19 #endif 
    20         } 
    21         return -EINVAL; 
    22 } 
    23  
    24 static inline u32 gpio_out(u32 mask, u32 value) 
    25 { 
    26         switch (bcm47xx_bus_type) { 
    27 #ifdef CONFIG_BCM47XX_SSB 
    28         case BCM47XX_BUS_TYPE_SSB: 
    29                 return ssb_gpio_out(&bcm47xx_bus.ssb, mask, value); 
    30 #endif 
    31 #ifdef CONFIG_BCM47XX_BCMA 
    32         case BCM47XX_BUS_TYPE_BCMA: 
    33                 return bcma_chipco_gpio_out(&bcm47xx_bus.bcma.bus.drv_cc, mask, value); 
    34 #endif 
    35         } 
    36         return -EINVAL; 
    37 } 
    38  
    39 static inline u32 gpio_outen(u32 mask, u32 value) 
    40 { 
    41         switch (bcm47xx_bus_type) { 
    42 #ifdef CONFIG_BCM47XX_SSB 
    43         case BCM47XX_BUS_TYPE_SSB: 
    44                 ssb_gpio_outen(&bcm47xx_bus.ssb, mask, value); 
    45                 return 0; 
    46 #endif 
    47 #ifdef CONFIG_BCM47XX_BCMA 
    48         case BCM47XX_BUS_TYPE_BCMA: 
    49                 bcma_chipco_gpio_outen(&bcm47xx_bus.bcma.bus.drv_cc, mask, value); 
    50                 return 0; 
    51 #endif 
    52         } 
    53         return -EINVAL; 
    54 } 
    55  
    56 static inline u32 gpio_control(u32 mask, u32 value) 
    57 { 
    58         switch (bcm47xx_bus_type) { 
    59 #ifdef CONFIG_BCM47XX_SSB 
    60         case BCM47XX_BUS_TYPE_SSB: 
    61                 return ssb_gpio_control(&bcm47xx_bus.ssb, mask, value); 
    62 #endif 
    63 #ifdef CONFIG_BCM47XX_BCMA 
    64         case BCM47XX_BUS_TYPE_BCMA: 
    65                 return bcma_chipco_gpio_control(&bcm47xx_bus.bcma.bus.drv_cc, mask, value); 
    66 #endif 
    67         } 
    68         return -EINVAL; 
    69 } 
    70  
    71 static inline u32 gpio_setintmask(u32 mask, u32 value) 
    72 { 
    73         switch (bcm47xx_bus_type) { 
    74 #ifdef CONFIG_BCM47XX_SSB 
    75         case BCM47XX_BUS_TYPE_SSB: 
    76                 return ssb_gpio_intmask(&bcm47xx_bus.ssb, mask, value); 
    77 #endif 
    78 #ifdef CONFIG_BCM47XX_BCMA 
    79         case BCM47XX_BUS_TYPE_BCMA: 
    80                 return bcma_chipco_gpio_intmask(&bcm47xx_bus.bcma.bus.drv_cc, mask, value); 
    81 #endif 
    82         } 
    83         return -EINVAL; 
    84 } 
    85  
    86 static inline u32 gpio_intpolarity(u32 mask, u32 value) 
    87 { 
    88         switch (bcm47xx_bus_type) { 
    89 #ifdef CONFIG_BCM47XX_SSB 
    90         case BCM47XX_BUS_TYPE_SSB: 
    91                 return ssb_gpio_polarity(&bcm47xx_bus.ssb, mask, value); 
    92 #endif 
    93 #ifdef CONFIG_BCM47XX_BCMA 
    94         case BCM47XX_BUS_TYPE_BCMA: 
    95                 return bcma_chipco_gpio_polarity(&bcm47xx_bus.bcma.bus.drv_cc, mask, value); 
    96 #endif 
    97         } 
    98         return -EINVAL; 
    99 } 
    100  
    101 #ifdef CONFIG_BCM47XX_SSB 
    102 static inline u32 __ssb_write32_masked(struct ssb_device *dev, u16 offset, 
    103                                        u32 mask, u32 value) 
    104 { 
    105         value &= mask; 
    106         value |= ssb_read32(dev, offset) & ~mask; 
    107         ssb_write32(dev, offset, value); 
    108         return value; 
    109 } 
    110 #endif 
    111  
    112 #ifdef CONFIG_BCM47XX_BCMA 
    113 static inline u32 __bcma_write32_masked(struct bcma_device *dev, u16 offset, 
    114                                        u32 mask, u32 value) 
    115 { 
    116         value &= mask; 
    117         value |= bcma_read32(dev, offset) & ~mask; 
    118         bcma_write32(dev, offset, value); 
    119         return value; 
    120 } 
    121 #endif 
    122  
    123 static void gpio_set_irqenable(int enabled, irqreturn_t (*handler)(int, void *)) 
    124 { 
    125         int irq; 
    126  
    127         irq = gpio_to_irq(0); 
    128         if (irq == -EINVAL) return; 
    129          
    130         if (enabled) { 
    131                 if (request_irq(irq, handler, IRQF_SHARED | IRQF_SAMPLE_RANDOM, "gpio", handler)) 
    132                         return; 
    133         } else { 
    134                 free_irq(irq, handler); 
    135         } 
    136  
    137         switch (bcm47xx_bus_type) { 
    138 #ifdef CONFIG_BCM47XX_SSB 
    139         case BCM47XX_BUS_TYPE_SSB: 
    140                 if (bcm47xx_bus.ssb.chipco.dev) 
    141                         __ssb_write32_masked(bcm47xx_bus.ssb.chipco.dev, SSB_CHIPCO_IRQMASK, SSB_CHIPCO_IRQ_GPIO, (enabled ? SSB_CHIPCO_IRQ_GPIO : 0)); 
    142                 break; 
    143 #endif 
    144 #ifdef CONFIG_BCM47XX_BCMA 
    145         case BCM47XX_BUS_TYPE_BCMA: 
    146                 if (bcm47xx_bus.bcma.bus.drv_cc.core) 
    147                         __bcma_write32_masked(bcm47xx_bus.bcma.bus.drv_cc.core, BCMA_CC_IRQMASK, BCMA_CC_IRQ_GPIO, (enabled ? BCMA_CC_IRQ_GPIO : 0)); 
    148                 break; 
    149 #endif 
    150         } 
    151 } 
    152  
    1539#define EXTIF_ADDR 0x1f000000 
    15410#define EXTIF_UART (EXTIF_ADDR + 0x00800000) 
     
    15814#define GPIO_TYPE_MASK          (0xf << 24) 
    15915 
    160 static inline void gpio_set_extif(int gpio, int value) 
    161 { 
    162         volatile u8 *addr = (volatile u8 *) KSEG1ADDR(EXTIF_UART) + (gpio & ~GPIO_TYPE_MASK); 
    163         if (value) 
    164                 *addr = 0xFF; 
    165         else 
    166                 *addr; 
    167 } 
    168  
    16916#endif /* __DIAG_GPIO_H */ 
  • trunk/package/switch/src/gpio.h

    r27904 r32992  
    1010 
    1111#ifdef CONFIG_BCM47XX 
    12 #include "gpio-bcm947xx.h" 
     12#include <linux/gpio.h> 
    1313#else 
    1414#warning "Unsupported configuration." 
    1515 
    16 #define gpio_in()                       (-1U) 
    17 #define gpio_out(mask, value)           (-1U) 
    18 #define gpio_outen(mask, value)         (-1U) 
    19 #define gpio_control(mask, value)       (-1U) 
    20 #define gpio_intmask(mask, value)       (-1U) 
    21 #define gpio_intpolarity(mask, value)   (-1U) 
     16#define bcm47xx_gpio_in(mask)                   (-1U) 
     17#define bcm47xx_gpio_out(mask, value)           (-1U) 
     18#define bcm47xx_gpio_outen(mask, value)         (-1U) 
     19#define bcm47xx_gpio_control(mask, value)       (-1U) 
     20#define bcm47xx_gpio_intmask(mask, value)       (-1U) 
     21#define bcm47xx_gpio_polarity(mask, value)      (-1U) 
    2222 
    2323#endif 
  • trunk/package/switch/src/switch-adm.c

    r29936 r32992  
    105105        __u8 mask; 
    106106 
    107         gpio_out(eecs, (cs ? eecs : 0)); 
     107        bcm47xx_gpio_out(eecs, (cs ? eecs : 0)); 
    108108        udelay(EECK_EDGE_TIME); 
    109109 
     
    113113                for (mask = 0x80; mask && bits > 0; mask >>= 1, bits --) { 
    114114                        /* Clock low */ 
    115                         gpio_out(eesk, 0); 
     115                        bcm47xx_gpio_out(eesk, 0); 
    116116                        udelay(EECK_EDGE_TIME); 
    117117 
    118118                        /* Output on rising edge */ 
    119                         gpio_out(eedi, ((mask & buf[i]) ? eedi : 0)); 
     119                        bcm47xx_gpio_out(eedi, ((mask & buf[i]) ? eedi : 0)); 
    120120                        udelay(EEDI_SETUP_TIME); 
    121121 
    122122                        /* Clock high */ 
    123                         gpio_out(eesk, eesk); 
     123                        bcm47xx_gpio_out(eesk, eesk); 
    124124                        udelay(EECK_EDGE_TIME); 
    125125                } 
     
    127127 
    128128        /* Clock low */ 
    129         gpio_out(eesk, 0); 
     129        bcm47xx_gpio_out(eesk, 0); 
    130130        udelay(EECK_EDGE_TIME); 
    131131 
    132132        if (cs) 
    133                 gpio_out(eecs, 0); 
     133                bcm47xx_gpio_out(eecs, 0); 
    134134} 
    135135 
     
    140140        __u8 mask; 
    141141 
    142         gpio_out(eecs, (cs ? eecs : 0)); 
     142        bcm47xx_gpio_out(eecs, (cs ? eecs : 0)); 
    143143        udelay(EECK_EDGE_TIME); 
    144144 
     
    152152 
    153153                        /* Clock low */ 
    154                         gpio_out(eesk, 0); 
     154                        bcm47xx_gpio_out(eesk, 0); 
    155155                        udelay(EECK_EDGE_TIME); 
    156156 
    157157                        /* Input on rising edge */ 
    158                         gp = gpio_in(); 
     158                        gp = bcm47xx_gpio_in(~0); 
    159159                        if (gp & eedi) 
    160160                                byte |= mask; 
    161161 
    162162                        /* Clock high */ 
    163                         gpio_out(eesk, eesk); 
     163                        bcm47xx_gpio_out(eesk, eesk); 
    164164                        udelay(EECK_EDGE_TIME); 
    165165                } 
     
    169169 
    170170        /* Clock low */ 
    171         gpio_out(eesk, 0); 
     171        bcm47xx_gpio_out(eesk, 0); 
    172172        udelay(EECK_EDGE_TIME); 
    173173 
    174174        if (cs) 
    175                 gpio_out(eecs, 0); 
     175                bcm47xx_gpio_out(eecs, 0); 
    176176} 
    177177 
     
    181181{ 
    182182        /* Prepare GPIO output value */ 
    183         gpio_out(pins, val); 
     183        bcm47xx_gpio_out(pins, val); 
    184184 
    185185        /* Enable GPIO outputs */ 
    186         gpio_outen(pins, pins); 
     186        bcm47xx_gpio_outen(pins, pins); 
    187187        udelay(EECK_EDGE_TIME); 
    188188} 
     
    193193{ 
    194194        /* Disable GPIO outputs */ 
    195         gpio_outen(pins, 0); 
     195        bcm47xx_gpio_outen(pins, 0); 
    196196        udelay(EECK_EDGE_TIME); 
    197197} 
     
    204204        for (i = 0; i < clocks; i++) { 
    205205                /* Clock high */ 
    206                 gpio_out(eesk, eesk); 
     206                bcm47xx_gpio_out(eesk, eesk); 
    207207                udelay(EECK_EDGE_TIME); 
    208208 
    209209                /* Clock low */ 
    210                 gpio_out(eesk, 0); 
     210                bcm47xx_gpio_out(eesk, 0); 
    211211                udelay(EECK_EDGE_TIME); 
    212212        } 
  • trunk/target/linux/brcm47xx/config-3.3

    r32880 r32992  
    22CONFIG_ARCH_DISCARD_MEMBLOCK=y 
    33CONFIG_ARCH_HIBERNATION_POSSIBLE=y 
     4CONFIG_ARCH_REQUIRE_GPIOLIB=y 
    45CONFIG_ARCH_SUSPEND_POSSIBLE=y 
    56# CONFIG_ARPD is not set 
     
    1617CONFIG_BCMA_DEBUG=y 
    1718CONFIG_BCMA_DRIVER_GMAC_CMN=y 
     19CONFIG_BCMA_DRIVER_GPIO=y 
    1820CONFIG_BCMA_DRIVER_MIPS=y 
    1921CONFIG_BCMA_DRIVER_PCI_HOSTMODE=y 
     
    5153CONFIG_GENERIC_IRQ_SHOW=y 
    5254CONFIG_GENERIC_PCI_IOMAP=y 
     55# CONFIG_GENERIC_PWM is not set 
     56CONFIG_GPIOLIB=y 
    5357CONFIG_HARDWARE_WATCHPOINTS=y 
    5458CONFIG_HAS_DMA=y 
  • trunk/target/linux/brcm47xx/patches-3.3/812-disable_wgt634u_crap.patch

    r32845 r32992  
    88--- a/arch/mips/bcm47xx/wgt634u.c 
    99+++ /dev/null 
    10 @@ -1,170 +0,0 @@ 
     10@@ -1,177 +0,0 @@ 
    1111-/* 
    1212- * This file is subject to the terms and conditions of the GNU General Public 
     
    144144-        */ 
    145145-       u8 *et0mac; 
     146-       int err; 
    146147- 
    147148-       if (bcm47xx_bus_type != BCM47XX_BUS_TYPE_SSB) 
     
    156157- 
    157158-               printk(KERN_INFO "WGT634U machine detected.\n"); 
     159- 
     160-               err = gpio_request(WGT634U_GPIO_RESET, "reset-buton"); 
     161-               if (err) { 
     162-                       printk(KERN_INFO "Can not register gpio fir reset button\n"); 
     163-                       return 0; 
     164-               } 
    158165- 
    159166-               if (!request_irq(gpio_to_irq(WGT634U_GPIO_RESET), 
Note: See TracChangeset for help on using the changeset viewer.