git.sur5r.net Git - u-boot/blob - drivers/gpio/omap_gpio.c

   1 /*
   2  * Copyright (c) 2009 Wind River Systems, Inc.
   3  * Tom Rix <Tom.Rix@windriver.com>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0
   6  *
   7  * This work is derived from the linux 2.6.27 kernel source
   8  * To fetch, use the kernel repository
   9  * git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git
  10  * Use the v2.6.27 tag.
  11  *
  12  * Below is the original's header including its copyright
  13  *
  14  *  linux/arch/arm/plat-omap/gpio.c
  15  *
  16  * Support functions for OMAP GPIO
  17  *
  18  * Copyright (C) 2003-2005 Nokia Corporation
  19  * Written by Juha Yrjölä <juha.yrjola@nokia.com>
  20  */
  21 #include <common.h>
  22 #include <dm.h>
  23 #include <fdtdec.h>
  24 #include <asm/gpio.h>
  25 #include <asm/io.h>
  26 #include <linux/errno.h>
  27 #include <malloc.h>
  28
  29 DECLARE_GLOBAL_DATA_PTR;
  30
  31 #define OMAP_GPIO_DIR_OUT       0
  32 #define OMAP_GPIO_DIR_IN        1
  33
  34 #ifdef CONFIG_DM_GPIO
  35
  36 #define GPIO_PER_BANK                   32
  37
  38 struct gpio_bank {
  39         /* TODO(sjg@chromium.org): Can we use a struct here? */
  40         void *base;     /* address of registers in physical memory */
  41 };
  42
  43 #endif
  44
  45 static inline int get_gpio_index(int gpio)
  46 {
  47         return gpio & 0x1f;
  48 }
  49
  50 int gpio_is_valid(int gpio)
  51 {
  52         return (gpio >= 0) && (gpio < OMAP_MAX_GPIO);
  53 }
  54
  55 static void _set_gpio_direction(const struct gpio_bank *bank, int gpio,
  56                                 int is_input)
  57 {
  58         void *reg = bank->base;
  59         u32 l;
  60
  61         reg += OMAP_GPIO_OE;
  62
  63         l = __raw_readl(reg);
  64         if (is_input)
  65                 l |= 1 << gpio;
  66         else
  67                 l &= ~(1 << gpio);
  68         __raw_writel(l, reg);
  69 }
  70
  71 /**
  72  * Get the direction of the GPIO by reading the GPIO_OE register
  73  * corresponding to the specified bank.
  74  */
  75 static int _get_gpio_direction(const struct gpio_bank *bank, int gpio)
  76 {
  77         void *reg = bank->base;
  78         u32 v;
  79
  80         reg += OMAP_GPIO_OE;
  81
  82         v = __raw_readl(reg);
  83
  84         if (v & (1 << gpio))
  85                 return OMAP_GPIO_DIR_IN;
  86         else
  87                 return OMAP_GPIO_DIR_OUT;
  88 }
  89
  90 static void _set_gpio_dataout(const struct gpio_bank *bank, int gpio,
  91                                 int enable)
  92 {
  93         void *reg = bank->base;
  94         u32 l = 0;
  95
  96         if (enable)
  97                 reg += OMAP_GPIO_SETDATAOUT;
  98         else
  99                 reg += OMAP_GPIO_CLEARDATAOUT;
 100
 101         l = 1 << gpio;
 102         __raw_writel(l, reg);
 103 }
 104
 105 static int _get_gpio_value(const struct gpio_bank *bank, int gpio)
 106 {
 107         void *reg = bank->base;
 108         int input;
 109
 110         input = _get_gpio_direction(bank, gpio);
 111         switch (input) {
 112         case OMAP_GPIO_DIR_IN:
 113                 reg += OMAP_GPIO_DATAIN;
 114                 break;
 115         case OMAP_GPIO_DIR_OUT:
 116                 reg += OMAP_GPIO_DATAOUT;
 117                 break;
 118         default:
 119                 return -1;
 120         }
 121
 122         return (__raw_readl(reg) & (1 << gpio)) != 0;
 123 }
 124
 125 #ifndef CONFIG_DM_GPIO
 126
 127 static inline const struct gpio_bank *get_gpio_bank(int gpio)
 128 {
 129         return &omap_gpio_bank[gpio >> 5];
 130 }
 131
 132 static int check_gpio(int gpio)
 133 {
 134         if (!gpio_is_valid(gpio)) {
 135                 printf("ERROR : check_gpio: invalid GPIO %d\n", gpio);
 136                 return -1;
 137         }
 138         return 0;
 139 }
 140
 141 /**
 142  * Set value of the specified gpio
 143  */
 144 int gpio_set_value(unsigned gpio, int value)
 145 {
 146         const struct gpio_bank *bank;
 147
 148         if (check_gpio(gpio) < 0)
 149                 return -1;
 150         bank = get_gpio_bank(gpio);
 151         _set_gpio_dataout(bank, get_gpio_index(gpio), value);
 152
 153         return 0;
 154 }
 155
 156 /**
 157  * Get value of the specified gpio
 158  */
 159 int gpio_get_value(unsigned gpio)
 160 {
 161         const struct gpio_bank *bank;
 162
 163         if (check_gpio(gpio) < 0)
 164                 return -1;
 165         bank = get_gpio_bank(gpio);
 166
 167         return _get_gpio_value(bank, get_gpio_index(gpio));
 168 }
 169
 170 /**
 171  * Set gpio direction as input
 172  */
 173 int gpio_direction_input(unsigned gpio)
 174 {
 175         const struct gpio_bank *bank;
 176
 177         if (check_gpio(gpio) < 0)
 178                 return -1;
 179
 180         bank = get_gpio_bank(gpio);
 181         _set_gpio_direction(bank, get_gpio_index(gpio), 1);
 182
 183         return 0;
 184 }
 185
 186 /**
 187  * Set gpio direction as output
 188  */
 189 int gpio_direction_output(unsigned gpio, int value)
 190 {
 191         const struct gpio_bank *bank;
 192
 193         if (check_gpio(gpio) < 0)
 194                 return -1;
 195
 196         bank = get_gpio_bank(gpio);
 197         _set_gpio_dataout(bank, get_gpio_index(gpio), value);
 198         _set_gpio_direction(bank, get_gpio_index(gpio), 0);
 199
 200         return 0;
 201 }
 202
 203 /**
 204  * Request a gpio before using it.
 205  *
 206  * NOTE: Argument 'label' is unused.
 207  */
 208 int gpio_request(unsigned gpio, const char *label)
 209 {
 210         if (check_gpio(gpio) < 0)
 211                 return -1;
 212
 213         return 0;
 214 }
 215
 216 /**
 217  * Reset and free the gpio after using it.
 218  */
 219 int gpio_free(unsigned gpio)
 220 {
 221         return 0;
 222 }
 223
 224 #else /* new driver model interface CONFIG_DM_GPIO */
 225
 226 /* set GPIO pin 'gpio' as an input */
 227 static int omap_gpio_direction_input(struct udevice *dev, unsigned offset)
 228 {
 229         struct gpio_bank *bank = dev_get_priv(dev);
 230
 231         /* Configure GPIO direction as input. */
 232         _set_gpio_direction(bank, offset, 1);
 233
 234         return 0;
 235 }
 236
 237 /* set GPIO pin 'gpio' as an output, with polarity 'value' */
 238 static int omap_gpio_direction_output(struct udevice *dev, unsigned offset,
 239                                        int value)
 240 {
 241         struct gpio_bank *bank = dev_get_priv(dev);
 242
 243         _set_gpio_dataout(bank, offset, value);
 244         _set_gpio_direction(bank, offset, 0);
 245
 246         return 0;
 247 }
 248
 249 /* read GPIO IN value of pin 'gpio' */
 250 static int omap_gpio_get_value(struct udevice *dev, unsigned offset)
 251 {
 252         struct gpio_bank *bank = dev_get_priv(dev);
 253
 254         return _get_gpio_value(bank, offset);
 255 }
 256
 257 /* write GPIO OUT value to pin 'gpio' */
 258 static int omap_gpio_set_value(struct udevice *dev, unsigned offset,
 259                                  int value)
 260 {
 261         struct gpio_bank *bank = dev_get_priv(dev);
 262
 263         _set_gpio_dataout(bank, offset, value);
 264
 265         return 0;
 266 }
 267
 268 static int omap_gpio_get_function(struct udevice *dev, unsigned offset)
 269 {
 270         struct gpio_bank *bank = dev_get_priv(dev);
 271
 272         /* GPIOF_FUNC is not implemented yet */
 273         if (_get_gpio_direction(bank, offset) == OMAP_GPIO_DIR_OUT)
 274                 return GPIOF_OUTPUT;
 275         else
 276                 return GPIOF_INPUT;
 277 }
 278
 279 static const struct dm_gpio_ops gpio_omap_ops = {
 280         .direction_input        = omap_gpio_direction_input,
 281         .direction_output       = omap_gpio_direction_output,
 282         .get_value              = omap_gpio_get_value,
 283         .set_value              = omap_gpio_set_value,
 284         .get_function           = omap_gpio_get_function,
 285 };
 286
 287 static int omap_gpio_probe(struct udevice *dev)
 288 {
 289         struct gpio_bank *bank = dev_get_priv(dev);
 290         struct omap_gpio_platdata *plat = dev_get_platdata(dev);
 291         struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
 292
 293         uc_priv->bank_name = plat->port_name;
 294         uc_priv->gpio_count = GPIO_PER_BANK;
 295         bank->base = (void *)plat->base;
 296
 297         return 0;
 298 }
 299
 300 static int omap_gpio_bind(struct udevice *dev)
 301 {
 302         struct omap_gpio_platdata *plat = dev_get_platdata(dev);
 303         fdt_addr_t base_addr;
 304
 305         if (plat)
 306                 return 0;
 307
 308         base_addr = devfdt_get_addr(dev);
 309         if (base_addr == FDT_ADDR_T_NONE)
 310                 return -EINVAL;
 311
 312         /*
 313         * TODO:
 314         * When every board is converted to driver model and DT is
 315         * supported, this can be done by auto-alloc feature, but
 316         * not using calloc to alloc memory for platdata.
 317         *
 318         * For example am33xx_gpio uses platform data rather than device tree.
 319         *
 320         * NOTE: DO NOT COPY this code if you are using device tree.
 321         */
 322         plat = calloc(1, sizeof(*plat));
 323         if (!plat)
 324                 return -ENOMEM;
 325
 326         plat->base = base_addr;
 327         plat->port_name = fdt_get_name(gd->fdt_blob, dev_of_offset(dev), NULL);
 328         dev->platdata = plat;
 329
 330         return 0;
 331 }
 332
 333 static const struct udevice_id omap_gpio_ids[] = {
 334         { .compatible = "ti,omap3-gpio" },
 335         { .compatible = "ti,omap4-gpio" },
 336         { .compatible = "ti,am4372-gpio" },
 337         { }
 338 };
 339
 340 U_BOOT_DRIVER(gpio_omap) = {
 341         .name   = "gpio_omap",
 342         .id     = UCLASS_GPIO,
 343         .ops    = &gpio_omap_ops,
 344         .of_match = omap_gpio_ids,
 345         .bind   = omap_gpio_bind,
 346         .probe  = omap_gpio_probe,
 347         .priv_auto_alloc_size = sizeof(struct gpio_bank),
 348 };
 349
 350 #endif /* CONFIG_DM_GPIO */