target/linux/adm5120/files/arch/mips/adm5120/gpio.c

   1 /*
   2  *  $Id$
   3  *
   4  *  ADM5120 GPIO support
   5  *
   6  *  Copyright (C) 2007 OpenWrt.org
   7  *  Copyright (C) 2007 Gabor Juhos <juhosg at openwrt.org>
   8  *
   9  *  This program is free software; you can redistribute it and/or
  10  *  modify it under the terms of the GNU General Public License
  11  *  as published by the Free Software Foundation; either version 2
  12  *  of the License, or (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the
  21  *  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  *  Boston, MA  02110-1301, USA.
  23  *
  24  */
  25
  26 #include <linux/autoconf.h>
  27 #include <linux/init.h>
  28 #include <linux/types.h>
  29 #include <linux/module.h>
  30 #include <linux/delay.h>
  31 #include <linux/platform_device.h>
  32 #include <linux/io.h>
  33
  34 #include <asm/addrspace.h>
  35 #include <asm/gpio.h>
  36
  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)
  45
  46 struct adm5120_gpio_line {
  47         u32 flags;
  48         const char *label;
  49 };
  50
  51 #define GPIO_FLAG_VALID         0x01
  52 #define GPIO_FLAG_USED          0x02
  53
  54 struct led_desc {
  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 */
  58 };
  59
  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 \
  64         }
  65
  66 static struct led_desc led_table[15] = {
  67         LED_DESC(0, 0), LED_DESC(0, 1), LED_DESC(0, 2),
  68         LED_DESC(1, 0), LED_DESC(1, 1), LED_DESC(1, 2),
  69         LED_DESC(2, 0), LED_DESC(2, 1), LED_DESC(2, 2),
  70         LED_DESC(3, 0), LED_DESC(3, 1), LED_DESC(3, 2),
  71         LED_DESC(4, 0), LED_DESC(4, 1), LED_DESC(4, 2)
  72 };
  73
  74 static struct adm5120_gpio_line adm5120_gpio_map[ADM5120_GPIO_COUNT] = {
  75         [ADM5120_GPIO_PIN0] = {.flags = GPIO_FLAG_VALID},
  76         [ADM5120_GPIO_PIN1] = {.flags = GPIO_FLAG_VALID},
  77         [ADM5120_GPIO_PIN2] = {.flags = GPIO_FLAG_VALID},
  78         [ADM5120_GPIO_PIN3] = {.flags = GPIO_FLAG_VALID},
  79         [ADM5120_GPIO_PIN4] = {.flags = GPIO_FLAG_VALID},
  80         [ADM5120_GPIO_PIN5] = {.flags = GPIO_FLAG_VALID},
  81         [ADM5120_GPIO_PIN6] = {.flags = GPIO_FLAG_VALID},
  82         [ADM5120_GPIO_PIN7] = {.flags = GPIO_FLAG_VALID},
  83         [ADM5120_GPIO_P0L0] = {.flags = GPIO_FLAG_VALID},
  84         [ADM5120_GPIO_P0L1] = {.flags = GPIO_FLAG_VALID},
  85         [ADM5120_GPIO_P0L2] = {.flags = GPIO_FLAG_VALID},
  86         [ADM5120_GPIO_P1L0] = {.flags = GPIO_FLAG_VALID},
  87         [ADM5120_GPIO_P1L1] = {.flags = GPIO_FLAG_VALID},
  88         [ADM5120_GPIO_P1L2] = {.flags = GPIO_FLAG_VALID},
  89         [ADM5120_GPIO_P2L0] = {.flags = GPIO_FLAG_VALID},
  90         [ADM5120_GPIO_P2L1] = {.flags = GPIO_FLAG_VALID},
  91         [ADM5120_GPIO_P2L2] = {.flags = GPIO_FLAG_VALID},
  92         [ADM5120_GPIO_P3L0] = {.flags = GPIO_FLAG_VALID},
  93         [ADM5120_GPIO_P3L1] = {.flags = GPIO_FLAG_VALID},
  94         [ADM5120_GPIO_P3L2] = {.flags = GPIO_FLAG_VALID},
  95         [ADM5120_GPIO_P4L0] = {.flags = GPIO_FLAG_VALID},
  96         [ADM5120_GPIO_P4L1] = {.flags = GPIO_FLAG_VALID},
  97         [ADM5120_GPIO_P4L2] = {.flags = GPIO_FLAG_VALID}
  98 };
  99
 100 #define gpio_is_invalid(g) ((g) > ADM5120_GPIO_MAX || \
 101                 ((adm5120_gpio_map[(g)].flags & GPIO_FLAG_VALID) == 0))
 102
 103 #define gpio_is_used(g) ((adm5120_gpio_map[(g)].flags & GPIO_FLAG_USED) != 0)
 104
 105 /*
 106  * Helpers for GPIO lines in GPIO_CONF0 register
 107  */
 108 #define PIN_IM(p)       ((1 << GPIO_CONF0_IM_SHIFT) << p)
 109 #define PIN_IV(p)       ((1 << GPIO_CONF0_IV_SHIFT) << p)
 110 #define PIN_OE(p)       ((1 << GPIO_CONF0_OE_SHIFT) << p)
 111 #define PIN_OV(p)       ((1 << GPIO_CONF0_OV_SHIFT) << p)
 112
 113 static inline int pins_direction_input(unsigned pin)
 114 {
 115         void __iomem **reg;
 116         u32 t;
 117
 118         reg = GPIO_REG(SWITCH_REG_GPIO_CONF0);
 119
 120         t = GPIO_READ(reg);
 121         t &= ~(PIN_OE(pin));
 122         t |= PIN_IM(pin);
 123         GPIO_WRITE(t, reg);
 124
 125         return 0;
 126 }
 127
 128 static inline int pins_direction_output(unsigned pin, int value)
 129 {
 130         void __iomem **reg;
 131         u32 t;
 132
 133         reg = GPIO_REG(SWITCH_REG_GPIO_CONF0);
 134
 135         t = GPIO_READ(reg);
 136         t &= ~(PIN_IM(pin) | PIN_OV(pin));
 137         t |= PIN_OE(pin);
 138
 139         if (value)
 140                 t |= PIN_OV(pin);
 141
 142         GPIO_WRITE(t, reg);
 143
 144         return 0;
 145 }
 146
 147 static inline int pins_get_value(unsigned pin)
 148 {
 149         void __iomem **reg;
 150         u32 t;
 151
 152         reg = GPIO_REG(SWITCH_REG_GPIO_CONF0);
 153
 154         t = GPIO_READ(reg);
 155         if ((t & PIN_IM(pin)) != 0)
 156                 t &= PIN_IV(pin);
 157         else
 158                 t &= PIN_OV(pin);
 159
 160         return (t) ? 1 : 0;
 161 }
 162
 163 static inline void pins_set_value(unsigned pin, int value)
 164 {
 165         void __iomem **reg;
 166         u32 t;
 167
 168         reg = GPIO_REG(SWITCH_REG_GPIO_CONF0);
 169
 170         t = GPIO_READ(reg);
 171         if (value == 0)
 172                 t &= ~(PIN_OV(pin));
 173         else
 174                 t |= PIN_OV(pin);
 175
 176         GPIO_WRITE(t, reg);
 177 }
 178
 179 /*
 180  * Helpers for GPIO lines in PORTx_LED registers
 181  */
 182 static inline int leds_direction_input(unsigned led)
 183 {
 184         void __iomem **reg;
 185         u32 t;
 186
 187         reg = led_table[led].reg;
 188         t = GPIO_READ(reg);
 189         t &= ~(LED_MODE_MASK << led_table[led].mode_shift);
 190         GPIO_WRITE(t, reg);
 191
 192         return 0;
 193 }
 194
 195 static inline int leds_direction_output(unsigned led, int value)
 196 {
 197         void __iomem **reg;
 198         u32 t, s;
 199
 200         reg = led_table[led].reg;
 201         s = led_table[led].mode_shift;
 202
 203         t = GPIO_READ(reg);
 204         t &= ~(LED_MODE_MASK << s);
 205
 206         switch (value) {
 207         case ADM5120_GPIO_LOW:
 208                 t |= (LED_MODE_OUT_LOW << s);
 209                 break;
 210         case ADM5120_GPIO_FLASH:
 211         case ADM5120_GPIO_LINK:
 212         case ADM5120_GPIO_SPEED:
 213         case ADM5120_GPIO_DUPLEX:
 214         case ADM5120_GPIO_ACT:
 215         case ADM5120_GPIO_COLL:
 216         case ADM5120_GPIO_LINK_ACT:
 217         case ADM5120_GPIO_DUPLEX_COLL:
 218         case ADM5120_GPIO_10M_ACT:
 219         case ADM5120_GPIO_100M_ACT:
 220                 t |= ((value & LED_MODE_MASK) << s);
 221                 break;
 222         default:
 223                 t |= (LED_MODE_OUT_HIGH << s);
 224                 break;
 225         }
 226
 227         GPIO_WRITE(t, reg);
 228
 229         return 0;
 230 }
 231
 232 static inline int leds_get_value(unsigned led)
 233 {
 234         void __iomem **reg;
 235         u32 t, m;
 236
 237         reg = led_table[led].reg;
 238
 239         t = GPIO_READ(reg);
 240         m = (t >> led_table[led].mode_shift) & LED_MODE_MASK;
 241         if (m == LED_MODE_INPUT)
 242                 return (t >> led_table[led].iv_shift) & 1;
 243
 244         if (m == LED_MODE_OUT_LOW)
 245                 return 0;
 246
 247         return 1;
 248 }
 249
 250 /*
 251  * Main GPIO support routines
 252  */
 253 int adm5120_gpio_direction_input(unsigned gpio)
 254 {
 255         if (gpio_is_invalid(gpio))
 256                 return -EINVAL;
 257
 258         if (gpio < ADM5120_GPIO_P0L0)
 259                 return pins_direction_input(gpio);
 260
 261         gpio -= ADM5120_GPIO_P0L0;
 262         return leds_direction_input(gpio);
 263 }
 264 EXPORT_SYMBOL(adm5120_gpio_direction_input);
 265
 266 int adm5120_gpio_direction_output(unsigned gpio, int value)
 267 {
 268         if (gpio_is_invalid(gpio))
 269                 return -EINVAL;
 270
 271         if (gpio < ADM5120_GPIO_P0L0)
 272                 return pins_direction_output(gpio, value);
 273
 274         gpio -= ADM5120_GPIO_P0L0;
 275         return leds_direction_output(gpio, value);
 276 }
 277 EXPORT_SYMBOL(adm5120_gpio_direction_output);
 278
 279 int adm5120_gpio_get_value(unsigned gpio)
 280 {
 281         if (gpio < ADM5120_GPIO_P0L0)
 282                 return pins_get_value(gpio);
 283
 284         gpio -= ADM5120_GPIO_P0L0;
 285         return leds_get_value(gpio);
 286 }
 287 EXPORT_SYMBOL(adm5120_gpio_get_value);
 288
 289 void adm5120_gpio_set_value(unsigned gpio, int value)
 290 {
 291         if (gpio < ADM5120_GPIO_P0L0) {
 292                 pins_set_value(gpio, value);
 293                 return;
 294         }
 295
 296         gpio -= ADM5120_GPIO_P0L0;
 297         leds_direction_output(gpio, value);
 298 }
 299 EXPORT_SYMBOL(adm5120_gpio_set_value);
 300
 301 int adm5120_gpio_request(unsigned gpio, const char *label)
 302 {
 303         if (gpio_is_invalid(gpio))
 304                 return -EINVAL;
 305
 306         if (gpio_is_used(gpio))
 307                 return -EBUSY;
 308
 309         adm5120_gpio_map[gpio].flags |= GPIO_FLAG_USED;
 310         adm5120_gpio_map[gpio].label = label;
 311
 312         return 0;
 313 }
 314 EXPORT_SYMBOL(adm5120_gpio_request);
 315
 316 void adm5120_gpio_free(unsigned gpio)
 317 {
 318         if (gpio_is_invalid(gpio))
 319                 return;
 320
 321         adm5120_gpio_map[gpio].flags &= ~GPIO_FLAG_USED;
 322         adm5120_gpio_map[gpio].label = NULL;
 323 }
 324 EXPORT_SYMBOL(adm5120_gpio_free);
 325
 326 int adm5120_gpio_to_irq(unsigned gpio)
 327 {
 328         /* FIXME: not yet implemented */
 329         return -EINVAL;
 330 }
 331 EXPORT_SYMBOL(adm5120_gpio_to_irq);
 332
 333 int adm5120_irq_to_gpio(unsigned irq)
 334 {
 335         /* FIXME: not yet implemented */
 336         return -EINVAL;
 337 }
 338 EXPORT_SYMBOL(adm5120_irq_to_gpio);
 339
 340 static int __init adm5120_gpio_init(void)
 341 {
 342         int i;
 343
 344         if (adm5120_package_pqfp()) {
 345                 /* GPIO pins 4-7 are unavailable in ADM5120P */
 346                 for (i = ADM5120_GPIO_PIN4; i <= ADM5120_GPIO_PIN7; i++)
 347                         adm5120_gpio_map[i].flags &= ~GPIO_FLAG_VALID;
 348         }
 349
 350         return 0;
 351 }
 352
 353 pure_initcall(adm5120_gpio_init);