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 #include <dt-bindings/gpio/gpio.h> 12 13 DECLARE_GLOBAL_DATA_PTR; 14 15 /* Flags for each GPIO */ 16 #define GPIOF_OUTPUT (1 << 0) /* Currently set as an output */ 17 #define GPIOF_HIGH (1 << 1) /* Currently set high */ 18 #define GPIOF_ODR (1 << 2) /* Currently set to open drain mode */ 19 20 struct gpio_state { 21 const char *label; /* label given by requester */ 22 u8 flags; /* flags (GPIOF_...) */ 23 }; 24 25 /* Access routines for GPIO state */ 26 static u8 *get_gpio_flags(struct udevice *dev, unsigned offset) 27 { 28 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev); 29 struct gpio_state *state = dev_get_priv(dev); 30 31 if (offset >= uc_priv->gpio_count) { 32 static u8 invalid_flags; 33 printf("sandbox_gpio: error: invalid gpio %u\n", offset); 34 return &invalid_flags; 35 } 36 37 return &state[offset].flags; 38 } 39 40 static int get_gpio_flag(struct udevice *dev, unsigned offset, int flag) 41 { 42 return (*get_gpio_flags(dev, offset) & flag) != 0; 43 } 44 45 static int set_gpio_flag(struct udevice *dev, unsigned offset, int flag, 46 int value) 47 { 48 u8 *gpio = get_gpio_flags(dev, offset); 49 50 if (value) 51 *gpio |= flag; 52 else 53 *gpio &= ~flag; 54 55 return 0; 56 } 57 58 /* 59 * Back-channel sandbox-internal-only access to GPIO state 60 */ 61 62 int sandbox_gpio_get_value(struct udevice *dev, unsigned offset) 63 { 64 if (get_gpio_flag(dev, offset, GPIOF_OUTPUT)) 65 debug("sandbox_gpio: get_value on output gpio %u\n", offset); 66 return get_gpio_flag(dev, offset, GPIOF_HIGH); 67 } 68 69 int sandbox_gpio_set_value(struct udevice *dev, unsigned offset, int value) 70 { 71 return set_gpio_flag(dev, offset, GPIOF_HIGH, value); 72 } 73 74 int sandbox_gpio_get_open_drain(struct udevice *dev, unsigned offset) 75 { 76 return get_gpio_flag(dev, offset, GPIOF_ODR); 77 } 78 79 int sandbox_gpio_set_open_drain(struct udevice *dev, unsigned offset, int value) 80 { 81 return set_gpio_flag(dev, offset, GPIOF_ODR, value); 82 } 83 84 int sandbox_gpio_get_direction(struct udevice *dev, unsigned offset) 85 { 86 return get_gpio_flag(dev, offset, GPIOF_OUTPUT); 87 } 88 89 int sandbox_gpio_set_direction(struct udevice *dev, unsigned offset, int output) 90 { 91 return set_gpio_flag(dev, offset, GPIOF_OUTPUT, output); 92 } 93 94 /* 95 * These functions implement the public interface within U-Boot 96 */ 97 98 /* set GPIO port 'offset' as an input */ 99 static int sb_gpio_direction_input(struct udevice *dev, unsigned offset) 100 { 101 debug("%s: offset:%u\n", __func__, offset); 102 103 return sandbox_gpio_set_direction(dev, offset, 0); 104 } 105 106 /* set GPIO port 'offset' as an output, with polarity 'value' */ 107 static int sb_gpio_direction_output(struct udevice *dev, unsigned offset, 108 int value) 109 { 110 debug("%s: offset:%u, value = %d\n", __func__, offset, value); 111 112 return sandbox_gpio_set_direction(dev, offset, 1) | 113 sandbox_gpio_set_value(dev, offset, value); 114 } 115 116 /* read GPIO IN value of port 'offset' */ 117 static int sb_gpio_get_value(struct udevice *dev, unsigned offset) 118 { 119 debug("%s: offset:%u\n", __func__, offset); 120 121 return sandbox_gpio_get_value(dev, offset); 122 } 123 124 /* write GPIO OUT value to port 'offset' */ 125 static int sb_gpio_set_value(struct udevice *dev, unsigned offset, int value) 126 { 127 debug("%s: offset:%u, value = %d\n", __func__, offset, value); 128 129 if (!sandbox_gpio_get_direction(dev, offset)) { 130 printf("sandbox_gpio: error: set_value on input gpio %u\n", 131 offset); 132 return -1; 133 } 134 135 return sandbox_gpio_set_value(dev, offset, value); 136 } 137 138 /* read GPIO ODR value of port 'offset' */ 139 static int sb_gpio_get_open_drain(struct udevice *dev, unsigned offset) 140 { 141 debug("%s: offset:%u\n", __func__, offset); 142 143 return sandbox_gpio_get_open_drain(dev, offset); 144 } 145 146 /* write GPIO ODR value to port 'offset' */ 147 static int sb_gpio_set_open_drain(struct udevice *dev, unsigned offset, int value) 148 { 149 debug("%s: offset:%u, value = %d\n", __func__, offset, value); 150 151 if (!sandbox_gpio_get_direction(dev, offset)) { 152 printf("sandbox_gpio: error: set_open_drain on input gpio %u\n", 153 offset); 154 return -1; 155 } 156 157 return sandbox_gpio_set_open_drain(dev, offset, value); 158 } 159 160 static int sb_gpio_get_function(struct udevice *dev, unsigned offset) 161 { 162 if (get_gpio_flag(dev, offset, GPIOF_OUTPUT)) 163 return GPIOF_OUTPUT; 164 return GPIOF_INPUT; 165 } 166 167 static int sb_gpio_xlate(struct udevice *dev, struct gpio_desc *desc, 168 struct fdtdec_phandle_args *args) 169 { 170 desc->offset = args->args[0]; 171 if (args->args_count < 2) 172 return 0; 173 if (args->args[1] & GPIO_ACTIVE_LOW) 174 desc->flags |= GPIOD_ACTIVE_LOW; 175 if (args->args[1] & 2) 176 desc->flags |= GPIOD_IS_IN; 177 if (args->args[1] & 4) 178 desc->flags |= GPIOD_IS_OUT; 179 if (args->args[1] & 8) 180 desc->flags |= GPIOD_IS_OUT_ACTIVE; 181 182 return 0; 183 } 184 185 static const struct dm_gpio_ops gpio_sandbox_ops = { 186 .direction_input = sb_gpio_direction_input, 187 .direction_output = sb_gpio_direction_output, 188 .get_value = sb_gpio_get_value, 189 .set_value = sb_gpio_set_value, 190 .get_open_drain = sb_gpio_get_open_drain, 191 .set_open_drain = sb_gpio_set_open_drain, 192 .get_function = sb_gpio_get_function, 193 .xlate = sb_gpio_xlate, 194 }; 195 196 static int sandbox_gpio_ofdata_to_platdata(struct udevice *dev) 197 { 198 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev); 199 200 uc_priv->gpio_count = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev), 201 "num-gpios", 0); 202 uc_priv->bank_name = fdt_getprop(gd->fdt_blob, dev_of_offset(dev), 203 "gpio-bank-name", NULL); 204 205 return 0; 206 } 207 208 static int gpio_sandbox_probe(struct udevice *dev) 209 { 210 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev); 211 212 if (dev_of_offset(dev) == -1) { 213 /* Tell the uclass how many GPIOs we have */ 214 uc_priv->gpio_count = CONFIG_SANDBOX_GPIO_COUNT; 215 } 216 217 dev->priv = calloc(sizeof(struct gpio_state), uc_priv->gpio_count); 218 219 return 0; 220 } 221 222 static int gpio_sandbox_remove(struct udevice *dev) 223 { 224 free(dev->priv); 225 226 return 0; 227 } 228 229 static const struct udevice_id sandbox_gpio_ids[] = { 230 { .compatible = "sandbox,gpio" }, 231 { } 232 }; 233 234 U_BOOT_DRIVER(gpio_sandbox) = { 235 .name = "gpio_sandbox", 236 .id = UCLASS_GPIO, 237 .of_match = sandbox_gpio_ids, 238 .ofdata_to_platdata = sandbox_gpio_ofdata_to_platdata, 239 .probe = gpio_sandbox_probe, 240 .remove = gpio_sandbox_remove, 241 .ops = &gpio_sandbox_ops, 242 }; 243