drivers/gpio/sandbox.c

   1 /*
   2  * Copyright (c) 2011 The Chromium OS Authors.
   3  * SPDX-License-Identifier:     GPL-2.0+
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <fdtdec.h>
   9 #include <malloc.h>
  10 #include <asm/gpio.h>
  11
  12 DECLARE_GLOBAL_DATA_PTR;
  13
  14 /* Flags for each GPIO */
  15 #define GPIOF_OUTPUT    (1 << 0)        /* Currently set as an output */
  16 #define GPIOF_HIGH      (1 << 1)        /* Currently set high */
  17
  18 struct gpio_state {
  19         const char *label;      /* label given by requester */
  20         u8 flags;               /* flags (GPIOF_...) */
  21 };
  22
  23 /* Access routines for GPIO state */
  24 static u8 *get_gpio_flags(struct udevice *dev, unsigned offset)
  25 {
  26         struct gpio_dev_priv *uc_priv = dev->uclass_priv;
  27         struct gpio_state *state = dev_get_priv(dev);
  28
  29         if (offset >= uc_priv->gpio_count) {
  30                 static u8 invalid_flags;
  31                 printf("sandbox_gpio: error: invalid gpio %u\n", offset);
  32                 return &invalid_flags;
  33         }
  34
  35         return &state[offset].flags;
  36 }
  37
  38 static int get_gpio_flag(struct udevice *dev, unsigned offset, int flag)
  39 {
  40         return (*get_gpio_flags(dev, offset) & flag) != 0;
  41 }
  42
  43 static int set_gpio_flag(struct udevice *dev, unsigned offset, int flag,
  44                          int value)
  45 {
  46         u8 *gpio = get_gpio_flags(dev, offset);
  47
  48         if (value)
  49                 *gpio |= flag;
  50         else
  51                 *gpio &= ~flag;
  52
  53         return 0;
  54 }
  55
  56 /*
  57  * Back-channel sandbox-internal-only access to GPIO state
  58  */
  59
  60 int sandbox_gpio_get_value(struct udevice *dev, unsigned offset)
  61 {
  62         if (get_gpio_flag(dev, offset, GPIOF_OUTPUT))
  63                 debug("sandbox_gpio: get_value on output gpio %u\n", offset);
  64         return get_gpio_flag(dev, offset, GPIOF_HIGH);
  65 }
  66
  67 int sandbox_gpio_set_value(struct udevice *dev, unsigned offset, int value)
  68 {
  69         return set_gpio_flag(dev, offset, GPIOF_HIGH, value);
  70 }
  71
  72 int sandbox_gpio_get_direction(struct udevice *dev, unsigned offset)
  73 {
  74         return get_gpio_flag(dev, offset, GPIOF_OUTPUT);
  75 }
  76
  77 int sandbox_gpio_set_direction(struct udevice *dev, unsigned offset, int output)
  78 {
  79         return set_gpio_flag(dev, offset, GPIOF_OUTPUT, output);
  80 }
  81
  82 /*
  83  * These functions implement the public interface within U-Boot
  84  */
  85
  86 /* set GPIO port 'offset' as an input */
  87 static int sb_gpio_direction_input(struct udevice *dev, unsigned offset)
  88 {
  89         debug("%s: offset:%u\n", __func__, offset);
  90
  91         return sandbox_gpio_set_direction(dev, offset, 0);
  92 }
  93
  94 /* set GPIO port 'offset' as an output, with polarity 'value' */
  95 static int sb_gpio_direction_output(struct udevice *dev, unsigned offset,
  96                                     int value)
  97 {
  98         debug("%s: offset:%u, value = %d\n", __func__, offset, value);
  99
 100         return sandbox_gpio_set_direction(dev, offset, 1) |
 101                 sandbox_gpio_set_value(dev, offset, value);
 102 }
 103
 104 /* read GPIO IN value of port 'offset' */
 105 static int sb_gpio_get_value(struct udevice *dev, unsigned offset)
 106 {
 107         debug("%s: offset:%u\n", __func__, offset);
 108
 109         return sandbox_gpio_get_value(dev, offset);
 110 }
 111
 112 /* write GPIO OUT value to port 'offset' */
 113 static int sb_gpio_set_value(struct udevice *dev, unsigned offset, int value)
 114 {
 115         debug("%s: offset:%u, value = %d\n", __func__, offset, value);
 116
 117         if (!sandbox_gpio_get_direction(dev, offset)) {
 118                 printf("sandbox_gpio: error: set_value on input gpio %u\n",
 119                        offset);
 120                 return -1;
 121         }
 122
 123         return sandbox_gpio_set_value(dev, offset, value);
 124 }
 125
 126 static int sb_gpio_get_function(struct udevice *dev, unsigned offset)
 127 {
 128         if (get_gpio_flag(dev, offset, GPIOF_OUTPUT))
 129                 return GPIOF_OUTPUT;
 130         return GPIOF_INPUT;
 131 }
 132
 133 static const struct dm_gpio_ops gpio_sandbox_ops = {
 134         .direction_input        = sb_gpio_direction_input,
 135         .direction_output       = sb_gpio_direction_output,
 136         .get_value              = sb_gpio_get_value,
 137         .set_value              = sb_gpio_set_value,
 138         .get_function           = sb_gpio_get_function,
 139 };
 140
 141 static int sandbox_gpio_ofdata_to_platdata(struct udevice *dev)
 142 {
 143         struct gpio_dev_priv *uc_priv = dev->uclass_priv;
 144
 145         uc_priv->gpio_count = fdtdec_get_int(gd->fdt_blob, dev->of_offset,
 146                                              "num-gpios", 0);
 147         uc_priv->bank_name = fdt_getprop(gd->fdt_blob, dev->of_offset,
 148                                          "gpio-bank-name", NULL);
 149
 150         return 0;
 151 }
 152
 153 static int gpio_sandbox_probe(struct udevice *dev)
 154 {
 155         struct gpio_dev_priv *uc_priv = dev->uclass_priv;
 156
 157         if (dev->of_offset == -1) {
 158                 /* Tell the uclass how many GPIOs we have */
 159                 uc_priv->gpio_count = CONFIG_SANDBOX_GPIO_COUNT;
 160         }
 161
 162         dev->priv = calloc(sizeof(struct gpio_state), uc_priv->gpio_count);
 163
 164         return 0;
 165 }
 166
 167 static int gpio_sandbox_remove(struct udevice *dev)
 168 {
 169         free(dev->priv);
 170
 171         return 0;
 172 }
 173
 174 static const struct udevice_id sandbox_gpio_ids[] = {
 175         { .compatible = "sandbox,gpio" },
 176         { }
 177 };
 178
 179 U_BOOT_DRIVER(gpio_sandbox) = {
 180         .name   = "gpio_sandbox",
 181         .id     = UCLASS_GPIO,
 182         .of_match = sandbox_gpio_ids,
 183         .ofdata_to_platdata = sandbox_gpio_ofdata_to_platdata,
 184         .probe  = gpio_sandbox_probe,
 185         .remove = gpio_sandbox_remove,
 186         .ops    = &gpio_sandbox_ops,
 187 };