Changeset 29123


Ignore:
Timestamp:
2011-11-14T18:43:11+01:00 (6 years ago)
Author:
juhosg
Message:

ar71xx: add AR71XX_ prefix to GPIO_REG_* defines

Location:
trunk/target/linux/ar71xx/files
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ar71xx/files/arch/mips/ar71xx/gpio.c

    r28974 r29123  
    3131 
    3232        if (value) 
    33                 __raw_writel(1 << gpio, base + GPIO_REG_SET); 
     33                __raw_writel(1 << gpio, base + AR71XX_GPIO_REG_SET); 
    3434        else 
    35                 __raw_writel(1 << gpio, base + GPIO_REG_CLEAR); 
     35                __raw_writel(1 << gpio, base + AR71XX_GPIO_REG_CLEAR); 
    3636} 
    3737EXPORT_SYMBOL(__ar71xx_gpio_set_value); 
     
    3939int __ar71xx_gpio_get_value(unsigned gpio) 
    4040{ 
    41         return (__raw_readl(ar71xx_gpio_base + GPIO_REG_IN) >> gpio) & 1; 
     41        return (__raw_readl(ar71xx_gpio_base + AR71XX_GPIO_REG_IN) >> gpio) & 1; 
    4242} 
    4343EXPORT_SYMBOL(__ar71xx_gpio_get_value); 
     
    6262        spin_lock_irqsave(&ar71xx_gpio_lock, flags); 
    6363 
    64         __raw_writel(__raw_readl(base + GPIO_REG_OE) & ~(1 << offset), 
    65                      base + GPIO_REG_OE); 
     64        __raw_writel(__raw_readl(base + AR71XX_GPIO_REG_OE) & ~(1 << offset), 
     65                     base + AR71XX_GPIO_REG_OE); 
    6666 
    6767        spin_unlock_irqrestore(&ar71xx_gpio_lock, flags); 
     
    7979 
    8080        if (value) 
    81                 __raw_writel(1 << offset, base + GPIO_REG_SET); 
     81                __raw_writel(1 << offset, base + AR71XX_GPIO_REG_SET); 
    8282        else 
    83                 __raw_writel(1 << offset, base + GPIO_REG_CLEAR); 
    84  
    85         __raw_writel(__raw_readl(base + GPIO_REG_OE) | (1 << offset), 
    86                      base + GPIO_REG_OE); 
     83                __raw_writel(1 << offset, base + AR71XX_GPIO_REG_CLEAR); 
     84 
     85        __raw_writel(__raw_readl(base + AR71XX_GPIO_REG_OE) | (1 << offset), 
     86                     base + AR71XX_GPIO_REG_OE); 
    8787 
    8888        spin_unlock_irqrestore(&ar71xx_gpio_lock, flags); 
     
    9999        spin_lock_irqsave(&ar71xx_gpio_lock, flags); 
    100100 
    101         __raw_writel(__raw_readl(base + GPIO_REG_OE) | (1 << offset), 
    102                      base + GPIO_REG_OE); 
     101        __raw_writel(__raw_readl(base + AR71XX_GPIO_REG_OE) | (1 << offset), 
     102                     base + AR71XX_GPIO_REG_OE); 
    103103 
    104104        spin_unlock_irqrestore(&ar71xx_gpio_lock, flags); 
     
    116116 
    117117        if (value) 
    118                 __raw_writel(1 << offset, base + GPIO_REG_SET); 
     118                __raw_writel(1 << offset, base + AR71XX_GPIO_REG_SET); 
    119119        else 
    120                 __raw_writel(1 << offset, base + GPIO_REG_CLEAR); 
    121  
    122         __raw_writel(__raw_readl(base + GPIO_REG_OE) & ~(1 << offset), 
    123                      base + GPIO_REG_OE); 
     120                __raw_writel(1 << offset, base + AR71XX_GPIO_REG_CLEAR); 
     121 
     122        __raw_writel(__raw_readl(base + AR71XX_GPIO_REG_OE) & ~(1 << offset), 
     123                     base + AR71XX_GPIO_REG_OE); 
    124124 
    125125        spin_unlock_irqrestore(&ar71xx_gpio_lock, flags); 
     
    145145        spin_lock_irqsave(&ar71xx_gpio_lock, flags); 
    146146 
    147         __raw_writel(__raw_readl(base + GPIO_REG_FUNC) | mask, 
    148                      base + GPIO_REG_FUNC); 
     147        __raw_writel(__raw_readl(base + AR71XX_GPIO_REG_FUNC) | mask, 
     148                     base + AR71XX_GPIO_REG_FUNC); 
    149149        /* flush write */ 
    150         (void) __raw_readl(base + GPIO_REG_FUNC); 
     150        (void) __raw_readl(base + AR71XX_GPIO_REG_FUNC); 
    151151 
    152152        spin_unlock_irqrestore(&ar71xx_gpio_lock, flags); 
     
    160160        spin_lock_irqsave(&ar71xx_gpio_lock, flags); 
    161161 
    162         __raw_writel(__raw_readl(base + GPIO_REG_FUNC) & ~mask, 
    163                      base + GPIO_REG_FUNC); 
     162        __raw_writel(__raw_readl(base + AR71XX_GPIO_REG_FUNC) & ~mask, 
     163                     base + AR71XX_GPIO_REG_FUNC); 
    164164        /* flush write */ 
    165         (void) __raw_readl(base + GPIO_REG_FUNC); 
     165        (void) __raw_readl(base + AR71XX_GPIO_REG_FUNC); 
    166166 
    167167        spin_unlock_irqrestore(&ar71xx_gpio_lock, flags); 
     
    175175        spin_lock_irqsave(&ar71xx_gpio_lock, flags); 
    176176 
    177         __raw_writel((__raw_readl(base + GPIO_REG_FUNC) & ~clear) | set, 
    178                      base + GPIO_REG_FUNC); 
     177        __raw_writel((__raw_readl(base + AR71XX_GPIO_REG_FUNC) & ~clear) | set, 
     178                     base + AR71XX_GPIO_REG_FUNC); 
    179179        /* flush write */ 
    180         (void) __raw_readl(base + GPIO_REG_FUNC); 
     180        (void) __raw_readl(base + AR71XX_GPIO_REG_FUNC); 
    181181 
    182182        spin_unlock_irqrestore(&ar71xx_gpio_lock, flags); 
  • trunk/target/linux/ar71xx/files/arch/mips/ar71xx/irq.c

    r29108 r29123  
    2929        u32 pending; 
    3030 
    31         pending = __raw_readl(base + GPIO_REG_INT_PENDING) & 
    32                   __raw_readl(base + GPIO_REG_INT_ENABLE); 
     31        pending = __raw_readl(base + AR71XX_GPIO_REG_INT_PENDING) & 
     32                  __raw_readl(base + AR71XX_GPIO_REG_INT_ENABLE); 
    3333 
    3434        if (pending) 
     
    4444        u32 t; 
    4545 
    46         t = __raw_readl(base + GPIO_REG_INT_ENABLE); 
    47         __raw_writel(t | (1 << irq), base + GPIO_REG_INT_ENABLE); 
     46        t = __raw_readl(base + AR71XX_GPIO_REG_INT_ENABLE); 
     47        __raw_writel(t | (1 << irq), base + AR71XX_GPIO_REG_INT_ENABLE); 
    4848 
    4949        /* flush write */ 
    50         (void) __raw_readl(base + GPIO_REG_INT_ENABLE); 
     50        (void) __raw_readl(base + AR71XX_GPIO_REG_INT_ENABLE); 
    5151} 
    5252 
     
    5757        u32 t; 
    5858 
    59         t = __raw_readl(base + GPIO_REG_INT_ENABLE); 
    60         __raw_writel(t & ~(1 << irq), base + GPIO_REG_INT_ENABLE); 
     59        t = __raw_readl(base + AR71XX_GPIO_REG_INT_ENABLE); 
     60        __raw_writel(t & ~(1 << irq), base + AR71XX_GPIO_REG_INT_ENABLE); 
    6161 
    6262        /* flush write */ 
    63         (void) __raw_readl(base + GPIO_REG_INT_ENABLE); 
     63        (void) __raw_readl(base + AR71XX_GPIO_REG_INT_ENABLE); 
    6464} 
    6565 
     
    8383        int i; 
    8484 
    85         __raw_writel(0, base + GPIO_REG_INT_ENABLE); 
    86         __raw_writel(0, base + GPIO_REG_INT_PENDING); 
     85        __raw_writel(0, base + AR71XX_GPIO_REG_INT_ENABLE); 
     86        __raw_writel(0, base + AR71XX_GPIO_REG_INT_PENDING); 
    8787 
    8888        /* setup type of all GPIO interrupts to level sensitive */ 
    89         __raw_writel(GPIO_INT_ALL, base + GPIO_REG_INT_TYPE); 
     89        __raw_writel(GPIO_INT_ALL, base + AR71XX_GPIO_REG_INT_TYPE); 
    9090 
    9191        /* setup polarity of all GPIO interrupts to active high */ 
    92         __raw_writel(GPIO_INT_ALL, base + GPIO_REG_INT_POLARITY); 
     92        __raw_writel(GPIO_INT_ALL, base + AR71XX_GPIO_REG_INT_POLARITY); 
    9393 
    9494        for (i = AR71XX_GPIO_IRQ_BASE; 
  • trunk/target/linux/ar71xx/files/arch/mips/ar71xx/mach-rb750.c

    r29103 r29123  
    8282 
    8383        if (latch_oe == 0) 
    84                 latch_oe = __raw_readl(ar71xx_gpio_base + GPIO_REG_OE); 
     84                latch_oe = __raw_readl(ar71xx_gpio_base + AR71XX_GPIO_REG_OE); 
    8585 
    8686        if (likely(latch_set & RB750_LVC573_LE)) { 
    8787                void __iomem *base = ar71xx_gpio_base; 
    8888 
    89                 t = __raw_readl(base + GPIO_REG_OE); 
     89                t = __raw_readl(base + AR71XX_GPIO_REG_OE); 
    9090                t |= mask_clr | latch_oe | mask_set; 
    9191 
    92                 __raw_writel(t, base + GPIO_REG_OE); 
    93                 __raw_writel(latch_clr, base + GPIO_REG_CLEAR); 
    94                 __raw_writel(latch_set, base + GPIO_REG_SET); 
     92                __raw_writel(t, base + AR71XX_GPIO_REG_OE); 
     93                __raw_writel(latch_clr, base + AR71XX_GPIO_REG_CLEAR); 
     94                __raw_writel(latch_set, base + AR71XX_GPIO_REG_SET); 
    9595        } else if (mask_clr & RB750_LVC573_LE) { 
    9696                void __iomem *base = ar71xx_gpio_base; 
    9797 
    98                 latch_oe = __raw_readl(base + GPIO_REG_OE); 
    99                 __raw_writel(RB750_LVC573_LE, base + GPIO_REG_CLEAR); 
     98                latch_oe = __raw_readl(base + AR71XX_GPIO_REG_OE); 
     99                __raw_writel(RB750_LVC573_LE, base + AR71XX_GPIO_REG_CLEAR); 
    100100                /* flush write */ 
    101                 __raw_readl(base + GPIO_REG_CLEAR); 
     101                __raw_readl(base + AR71XX_GPIO_REG_CLEAR); 
    102102        } 
    103103 
  • trunk/target/linux/ar71xx/files/arch/mips/include/asm/mach-ar71xx/ar71xx.h

    r29109 r29123  
    419419 * GPIO block 
    420420 */ 
    421 #define GPIO_REG_OE             0x00 
    422 #define GPIO_REG_IN             0x04 
    423 #define GPIO_REG_OUT            0x08 
    424 #define GPIO_REG_SET            0x0c 
    425 #define GPIO_REG_CLEAR          0x10 
    426 #define GPIO_REG_INT_MODE       0x14 
    427 #define GPIO_REG_INT_TYPE       0x18 
    428 #define GPIO_REG_INT_POLARITY   0x1c 
    429 #define GPIO_REG_INT_PENDING    0x20 
    430 #define GPIO_REG_INT_ENABLE     0x24 
    431 #define GPIO_REG_FUNC           0x28 
     421#define AR71XX_GPIO_REG_OE              0x00 
     422#define AR71XX_GPIO_REG_IN              0x04 
     423#define AR71XX_GPIO_REG_OUT             0x08 
     424#define AR71XX_GPIO_REG_SET             0x0c 
     425#define AR71XX_GPIO_REG_CLEAR           0x10 
     426#define AR71XX_GPIO_REG_INT_MODE        0x14 
     427#define AR71XX_GPIO_REG_INT_TYPE        0x18 
     428#define AR71XX_GPIO_REG_INT_POLARITY    0x1c 
     429#define AR71XX_GPIO_REG_INT_PENDING     0x20 
     430#define AR71XX_GPIO_REG_INT_ENABLE      0x24 
     431#define AR71XX_GPIO_REG_FUNC            0x28 
    432432 
    433433#define AR71XX_GPIO_FUNC_STEREO_EN      BIT(17) 
  • trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb750_nand.c

    r29122 r29123  
    7676        void __iomem *base = ar71xx_gpio_base; 
    7777        u32 out; 
     78        u32 t; 
    7879        unsigned i; 
    7980 
    8081        /* set data lines to output mode */ 
    81         __raw_writel(__raw_readl(base + GPIO_REG_OE) | RB750_NAND_DATA_BITS, 
    82                      base + GPIO_REG_OE); 
    83  
    84         out = __raw_readl(base + GPIO_REG_OUT); 
     82        t = __raw_readl(base + AR71XX_GPIO_REG_OE); 
     83        __raw_writel(t | RB750_NAND_DATA_BITS, base + AR71XX_GPIO_REG_OE); 
     84 
     85        out = __raw_readl(base + AR71XX_GPIO_REG_OUT); 
    8586        out &= ~(RB750_NAND_DATA_BITS | RB750_NAND_NWE); 
    8687        for (i = 0; i != len; i++) { 
     
    9091                data <<= RB750_NAND_DATA_SHIFT; 
    9192                data |= out; 
    92                 __raw_writel(data, base + GPIO_REG_OUT); 
    93  
    94                 __raw_writel(data | RB750_NAND_NWE, base + GPIO_REG_OUT); 
    95                 /* flush write */ 
    96                 __raw_readl(base + GPIO_REG_OUT); 
     93                __raw_writel(data, base + AR71XX_GPIO_REG_OUT); 
     94 
     95                __raw_writel(data | RB750_NAND_NWE, base + AR71XX_GPIO_REG_OUT); 
     96                /* flush write */ 
     97                __raw_readl(base + AR71XX_GPIO_REG_OUT); 
    9798        } 
    9899 
    99100        /* set data lines to input mode */ 
    100         __raw_writel(__raw_readl(base + GPIO_REG_OE) & ~RB750_NAND_DATA_BITS, 
    101                      base + GPIO_REG_OE); 
     101        t = __raw_readl(base + AR71XX_GPIO_REG_OE); 
     102        __raw_writel(t & ~RB750_NAND_DATA_BITS, base + AR71XX_GPIO_REG_OE); 
    102103        /* flush write */ 
    103         __raw_readl(base + GPIO_REG_OE); 
     104        __raw_readl(base + AR71XX_GPIO_REG_OE); 
    104105} 
    105106 
     
    114115 
    115116                /* activate RE line */ 
    116                 __raw_writel(RB750_NAND_NRE, base + GPIO_REG_CLEAR); 
    117                 /* flush write */ 
    118                 __raw_readl(base + GPIO_REG_CLEAR); 
     117                __raw_writel(RB750_NAND_NRE, base + AR71XX_GPIO_REG_CLEAR); 
     118                /* flush write */ 
     119                __raw_readl(base + AR71XX_GPIO_REG_CLEAR); 
    119120 
    120121                /* read input lines */ 
    121                 data = __raw_readl(base + GPIO_REG_IN) >> RB750_NAND_DATA_SHIFT; 
     122                data = __raw_readl(base + AR71XX_GPIO_REG_IN) >> 
     123                       RB750_NAND_DATA_SHIFT; 
    122124 
    123125                /* deactivate RE line */ 
    124                 __raw_writel(RB750_NAND_NRE, base + GPIO_REG_SET); 
     126                __raw_writel(RB750_NAND_NRE, base + AR71XX_GPIO_REG_SET); 
    125127 
    126128                if (read_buf) 
     
    137139        void __iomem *base = ar71xx_gpio_base; 
    138140        u32 func; 
    139  
    140         func = __raw_readl(base + GPIO_REG_FUNC); 
     141        u32 t; 
     142 
     143        func = __raw_readl(base + AR71XX_GPIO_REG_FUNC); 
    141144        if (chip >= 0) { 
    142145                /* disable latch */ 
     
    148151 
    149152                /* set input mode for data lines */ 
    150                 __raw_writel(__raw_readl(base + GPIO_REG_OE) & 
    151                             ~RB750_NAND_INPUT_BITS, 
    152                              base + GPIO_REG_OE); 
     153                t = __raw_readl(base + AR71XX_GPIO_REG_OE); 
     154                __raw_writel(t & ~RB750_NAND_INPUT_BITS, 
     155                             base + AR71XX_GPIO_REG_OE); 
    153156 
    154157                /* deactivate RE and WE lines */ 
    155158                __raw_writel(RB750_NAND_NRE | RB750_NAND_NWE, 
    156                              base + GPIO_REG_SET); 
    157                 /* flush write */ 
    158                 (void) __raw_readl(base + GPIO_REG_SET); 
     159                             base + AR71XX_GPIO_REG_SET); 
     160                /* flush write */ 
     161                (void) __raw_readl(base + AR71XX_GPIO_REG_SET); 
    159162 
    160163                /* activate CE line */ 
    161                 __raw_writel(RB750_NAND_NCE, base + GPIO_REG_CLEAR); 
     164                __raw_writel(RB750_NAND_NCE, base + AR71XX_GPIO_REG_CLEAR); 
    162165        } else { 
    163166                /* deactivate CE line */ 
    164                 __raw_writel(RB750_NAND_NCE, base + GPIO_REG_SET); 
    165                 /* flush write */ 
    166                 (void) __raw_readl(base + GPIO_REG_SET); 
    167  
    168                 __raw_writel(__raw_readl(base + GPIO_REG_OE) | 
    169                             RB750_NAND_IO0 | RB750_NAND_RDY, 
    170                              base + GPIO_REG_OE); 
     167                __raw_writel(RB750_NAND_NCE, base + AR71XX_GPIO_REG_SET); 
     168                /* flush write */ 
     169                (void) __raw_readl(base + AR71XX_GPIO_REG_SET); 
     170 
     171                t = __raw_readl(base + AR71XX_GPIO_REG_OE); 
     172                __raw_writel(t | RB750_NAND_IO0 | RB750_NAND_RDY, 
     173                             base + AR71XX_GPIO_REG_OE); 
    171174 
    172175                /* restore alternate functions */ 
     
    183186        void __iomem *base = ar71xx_gpio_base; 
    184187 
    185         return !!(__raw_readl(base + GPIO_REG_IN) & RB750_NAND_RDY); 
     188        return !!(__raw_readl(base + AR71XX_GPIO_REG_IN) & RB750_NAND_RDY); 
    186189} 
    187190 
     
    193196                u32 t; 
    194197 
    195                 t = __raw_readl(base + GPIO_REG_OUT); 
     198                t = __raw_readl(base + AR71XX_GPIO_REG_OUT); 
    196199 
    197200                t &= ~(RB750_NAND_CLE | RB750_NAND_ALE); 
     
    199202                t |= (ctrl & NAND_ALE) ? RB750_NAND_ALE : 0; 
    200203 
    201                 __raw_writel(t, base + GPIO_REG_OUT); 
    202                 /* flush write */ 
    203                 __raw_readl(base + GPIO_REG_OUT); 
     204                __raw_writel(t, base + AR71XX_GPIO_REG_OUT); 
     205                /* flush write */ 
     206                __raw_readl(base + AR71XX_GPIO_REG_OUT); 
    204207        } 
    205208 
     
    236239        void __iomem *base = ar71xx_gpio_base; 
    237240        u32 out; 
    238  
    239         out = __raw_readl(base + GPIO_REG_OUT); 
     241        u32 t; 
     242 
     243        out = __raw_readl(base + AR71XX_GPIO_REG_OUT); 
    240244 
    241245        /* setup output levels */ 
    242246        __raw_writel(RB750_NAND_NCE | RB750_NAND_NRE | RB750_NAND_NWE, 
    243                      base + GPIO_REG_SET); 
     247                     base + AR71XX_GPIO_REG_SET); 
    244248 
    245249        __raw_writel(RB750_NAND_ALE | RB750_NAND_CLE, 
    246                      base + GPIO_REG_CLEAR); 
     250                     base + AR71XX_GPIO_REG_CLEAR); 
    247251 
    248252        /* setup input lines */ 
    249         __raw_writel(__raw_readl(base + GPIO_REG_OE) & ~(RB750_NAND_INPUT_BITS), 
    250                      base + GPIO_REG_OE); 
     253        t = __raw_readl(base + AR71XX_GPIO_REG_OE); 
     254        __raw_writel(t & ~(RB750_NAND_INPUT_BITS), base + AR71XX_GPIO_REG_OE); 
    251255 
    252256        /* setup output lines */ 
    253         __raw_writel(__raw_readl(base + GPIO_REG_OE) | RB750_NAND_OUTPUT_BITS, 
    254                      base + GPIO_REG_OE); 
     257        t = __raw_readl(base + AR71XX_GPIO_REG_OE); 
     258        __raw_writel(t | RB750_NAND_OUTPUT_BITS, base + AR71XX_GPIO_REG_OE); 
    255259 
    256260        rb750_latch_change(~out & RB750_NAND_IO0, out & RB750_NAND_IO0); 
Note: See TracChangeset for help on using the changeset viewer.