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

   1 /*
   2  * (C) Copyright 2016
   3  * Mario Six, Guntermann & Drunck GmbH, six@gdsys.de
   4  *
   5  * based on arch/powerpc/include/asm/mpc85xx_gpio.h, which is
   6  *
   7  * Copyright 2010 eXMeritus, A Boeing Company
   8  *
   9  * SPDX-License-Identifier:     GPL-2.0+
  10  */
  11
  12 #include <common.h>
  13 #include <dm.h>
  14 #include <asm/gpio.h>
  15 #include <mapmem.h>
  16
  17 DECLARE_GLOBAL_DATA_PTR;
  18
  19 struct ccsr_gpio {
  20         u32     gpdir;
  21         u32     gpodr;
  22         u32     gpdat;
  23         u32     gpier;
  24         u32     gpimr;
  25         u32     gpicr;
  26 };
  27
  28 struct mpc8xxx_gpio_data {
  29         /* The bank's register base in memory */
  30         struct ccsr_gpio __iomem *base;
  31         /* The address of the registers; used to identify the bank */
  32         ulong addr;
  33         /* The GPIO count of the bank */
  34         uint gpio_count;
  35         /* The GPDAT register cannot be used to determine the value of output
  36          * pins on MPC8572/MPC8536, so we shadow it and use the shadowed value
  37          * for output pins
  38          */
  39         u32 dat_shadow;
  40 };
  41
  42 inline u32 gpio_mask(uint gpio)
  43 {
  44         return (1U << (31 - (gpio)));
  45 }
  46
  47 static inline u32 mpc8xxx_gpio_get_val(struct ccsr_gpio *base, u32 mask)
  48 {
  49         return in_be32(&base->gpdat) & mask;
  50 }
  51
  52 static inline u32 mpc8xxx_gpio_get_dir(struct ccsr_gpio *base, u32 mask)
  53 {
  54         return in_be32(&base->gpdir) & mask;
  55 }
  56
  57 static inline void mpc8xxx_gpio_set_in(struct ccsr_gpio *base, u32 gpios)
  58 {
  59         clrbits_be32(&base->gpdat, gpios);
  60         /* GPDIR register 0 -> input */
  61         clrbits_be32(&base->gpdir, gpios);
  62 }
  63
  64 static inline void mpc8xxx_gpio_set_low(struct ccsr_gpio *base, u32 gpios)
  65 {
  66         clrbits_be32(&base->gpdat, gpios);
  67         /* GPDIR register 1 -> output */
  68         setbits_be32(&base->gpdir, gpios);
  69 }
  70
  71 static inline void mpc8xxx_gpio_set_high(struct ccsr_gpio *base, u32 gpios)
  72 {
  73         setbits_be32(&base->gpdat, gpios);
  74         /* GPDIR register 1 -> output */
  75         setbits_be32(&base->gpdir, gpios);
  76 }
  77
  78 static inline int mpc8xxx_gpio_open_drain_val(struct ccsr_gpio *base, u32 mask)
  79 {
  80         return in_be32(&base->gpodr) & mask;
  81 }
  82
  83 static inline void mpc8xxx_gpio_open_drain_on(struct ccsr_gpio *base, u32
  84                                               gpios)
  85 {
  86         /* GPODR register 1 -> open drain on */
  87         setbits_be32(&base->gpodr, gpios);
  88 }
  89
  90 static inline void mpc8xxx_gpio_open_drain_off(struct ccsr_gpio *base,
  91                                                u32 gpios)
  92 {
  93         /* GPODR register 0 -> open drain off (actively driven) */
  94         clrbits_be32(&base->gpodr, gpios);
  95 }
  96
  97 static int mpc8xxx_gpio_direction_input(struct udevice *dev, uint gpio)
  98 {
  99         struct mpc8xxx_gpio_data *data = dev_get_priv(dev);
 100
 101         mpc8xxx_gpio_set_in(data->base, gpio_mask(gpio));
 102         return 0;
 103 }
 104
 105 static int mpc8xxx_gpio_set_value(struct udevice *dev, uint gpio, int value)
 106 {
 107         struct mpc8xxx_gpio_data *data = dev_get_priv(dev);
 108
 109         if (value) {
 110                 data->dat_shadow |= gpio_mask(gpio);
 111                 mpc8xxx_gpio_set_high(data->base, gpio_mask(gpio));
 112         } else {
 113                 data->dat_shadow &= ~gpio_mask(gpio);
 114                 mpc8xxx_gpio_set_low(data->base, gpio_mask(gpio));
 115         }
 116         return 0;
 117 }
 118
 119 static int mpc8xxx_gpio_direction_output(struct udevice *dev, uint gpio,
 120                                          int value)
 121 {
 122         return mpc8xxx_gpio_set_value(dev, gpio, value);
 123 }
 124
 125 static int mpc8xxx_gpio_get_value(struct udevice *dev, uint gpio)
 126 {
 127         struct mpc8xxx_gpio_data *data = dev_get_priv(dev);
 128
 129         if (!!mpc8xxx_gpio_get_dir(data->base, gpio_mask(gpio))) {
 130                 /* Output -> use shadowed value */
 131                 return !!(data->dat_shadow & gpio_mask(gpio));
 132         }
 133
 134         /* Input -> read value from GPDAT register */
 135         return !!mpc8xxx_gpio_get_val(data->base, gpio_mask(gpio));
 136 }
 137
 138 static int mpc8xxx_gpio_get_open_drain(struct udevice *dev, uint gpio)
 139 {
 140         struct mpc8xxx_gpio_data *data = dev_get_priv(dev);
 141
 142         return !!mpc8xxx_gpio_open_drain_val(data->base, gpio_mask(gpio));
 143 }
 144
 145 static int mpc8xxx_gpio_set_open_drain(struct udevice *dev, uint gpio,
 146                                        int value)
 147 {
 148         struct mpc8xxx_gpio_data *data = dev_get_priv(dev);
 149
 150         if (value)
 151                 mpc8xxx_gpio_open_drain_on(data->base, gpio_mask(gpio));
 152         else
 153                 mpc8xxx_gpio_open_drain_off(data->base, gpio_mask(gpio));
 154
 155         return 0;
 156 }
 157
 158 static int mpc8xxx_gpio_get_function(struct udevice *dev, uint gpio)
 159 {
 160         struct mpc8xxx_gpio_data *data = dev_get_priv(dev);
 161         int dir;
 162
 163         dir = !!mpc8xxx_gpio_get_dir(data->base, gpio_mask(gpio));
 164         return dir ? GPIOF_OUTPUT : GPIOF_INPUT;
 165 }
 166
 167 #if CONFIG_IS_ENABLED(OF_CONTROL)
 168 static int mpc8xxx_gpio_ofdata_to_platdata(struct udevice *dev)
 169 {
 170         struct mpc8xxx_gpio_plat *plat = dev_get_platdata(dev);
 171         fdt_addr_t addr;
 172         fdt_size_t size;
 173
 174         addr = fdtdec_get_addr_size_auto_noparent(gd->fdt_blob,
 175                                                   dev_of_offset(dev),
 176                                                   "reg", 0, &size, false);
 177         plat->addr = addr;
 178         plat->size = size;
 179         plat->ngpios = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev),
 180                                       "ngpios", 32);
 181
 182         return 0;
 183 }
 184 #endif
 185
 186 static int mpc8xxx_gpio_platdata_to_priv(struct udevice *dev)
 187 {
 188         struct mpc8xxx_gpio_data *priv = dev_get_priv(dev);
 189         struct mpc8xxx_gpio_plat *plat = dev_get_platdata(dev);
 190         unsigned long size = plat->size;
 191
 192         if (size == 0)
 193                 size = 0x100;
 194
 195         priv->addr = plat->addr;
 196         priv->base = map_sysmem(CONFIG_SYS_IMMR + plat->addr, size);
 197
 198         if (!priv->base)
 199                 return -ENOMEM;
 200
 201         priv->gpio_count = plat->ngpios;
 202         priv->dat_shadow = 0;
 203
 204         priv->type = driver_data;
 205
 206         return 0;
 207 }
 208
 209 static int mpc8xxx_gpio_probe(struct udevice *dev)
 210 {
 211         struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
 212         struct mpc8xxx_gpio_data *data = dev_get_priv(dev);
 213         char name[32], *str;
 214
 215         mpc8xxx_gpio_platdata_to_priv(dev);
 216
 217         snprintf(name, sizeof(name), "MPC@%lx_", data->addr);
 218         str = strdup(name);
 219
 220         if (!str)
 221                 return -ENOMEM;
 222
 223         uc_priv->bank_name = str;
 224         uc_priv->gpio_count = data->gpio_count;
 225
 226         return 0;
 227 }
 228
 229 static const struct dm_gpio_ops gpio_mpc8xxx_ops = {
 230         .direction_input        = mpc8xxx_gpio_direction_input,
 231         .direction_output       = mpc8xxx_gpio_direction_output,
 232         .get_value              = mpc8xxx_gpio_get_value,
 233         .set_value              = mpc8xxx_gpio_set_value,
 234         .get_open_drain         = mpc8xxx_gpio_get_open_drain,
 235         .set_open_drain         = mpc8xxx_gpio_set_open_drain,
 236         .get_function           = mpc8xxx_gpio_get_function,
 237 };
 238
 239 static const struct udevice_id mpc8xxx_gpio_ids[] = {
 240         { .compatible = "fsl,pq3-gpio" },
 241         { /* sentinel */ }
 242 };
 243
 244 U_BOOT_DRIVER(gpio_mpc8xxx) = {
 245         .name   = "gpio_mpc8xxx",
 246         .id     = UCLASS_GPIO,
 247         .ops    = &gpio_mpc8xxx_ops,
 248 #if CONFIG_IS_ENABLED(OF_CONTROL)
 249         .ofdata_to_platdata = mpc8xxx_gpio_ofdata_to_platdata,
 250         .platdata_auto_alloc_size = sizeof(struct mpc8xxx_gpio_plat),
 251         .of_match = mpc8xxx_gpio_ids,
 252 #endif
 253         .probe  = mpc8xxx_gpio_probe,
 254         .priv_auto_alloc_size = sizeof(struct mpc8xxx_gpio_data),
 255 };