1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2012 Henrik Nordstrom <henrik@henriknordstrom.net> 4 * 5 * Based on earlier arch/arm/cpu/armv7/sunxi/gpio.c: 6 * 7 * (C) Copyright 2007-2011 8 * Allwinner Technology Co., Ltd. <www.allwinnertech.com> 9 * Tom Cubie <tangliang@allwinnertech.com> 10 */ 11 12 #include <common.h> 13 #include <dm.h> 14 #include <errno.h> 15 #include <fdtdec.h> 16 #include <malloc.h> 17 #include <asm/arch/gpio.h> 18 #include <asm/io.h> 19 #include <asm/gpio.h> 20 #include <dm/device-internal.h> 21 #include <dt-bindings/gpio/gpio.h> 22 23 #define SUNXI_GPIOS_PER_BANK SUNXI_GPIO_A_NR 24 25 struct sunxi_gpio_platdata { 26 struct sunxi_gpio *regs; 27 const char *bank_name; /* Name of bank, e.g. "B" */ 28 int gpio_count; 29 }; 30 31 #ifndef CONFIG_DM_GPIO 32 static int sunxi_gpio_output(u32 pin, u32 val) 33 { 34 u32 dat; 35 u32 bank = GPIO_BANK(pin); 36 u32 num = GPIO_NUM(pin); 37 struct sunxi_gpio *pio = BANK_TO_GPIO(bank); 38 39 dat = readl(&pio->dat); 40 if (val) 41 dat |= 0x1 << num; 42 else 43 dat &= ~(0x1 << num); 44 45 writel(dat, &pio->dat); 46 47 return 0; 48 } 49 50 static int sunxi_gpio_input(u32 pin) 51 { 52 u32 dat; 53 u32 bank = GPIO_BANK(pin); 54 u32 num = GPIO_NUM(pin); 55 struct sunxi_gpio *pio = BANK_TO_GPIO(bank); 56 57 dat = readl(&pio->dat); 58 dat >>= num; 59 60 return dat & 0x1; 61 } 62 63 int gpio_request(unsigned gpio, const char *label) 64 { 65 return 0; 66 } 67 68 int gpio_free(unsigned gpio) 69 { 70 return 0; 71 } 72 73 int gpio_direction_input(unsigned gpio) 74 { 75 sunxi_gpio_set_cfgpin(gpio, SUNXI_GPIO_INPUT); 76 77 return 0; 78 } 79 80 int gpio_direction_output(unsigned gpio, int value) 81 { 82 sunxi_gpio_set_cfgpin(gpio, SUNXI_GPIO_OUTPUT); 83 84 return sunxi_gpio_output(gpio, value); 85 } 86 87 int gpio_get_value(unsigned gpio) 88 { 89 return sunxi_gpio_input(gpio); 90 } 91 92 int gpio_set_value(unsigned gpio, int value) 93 { 94 return sunxi_gpio_output(gpio, value); 95 } 96 97 int sunxi_name_to_gpio(const char *name) 98 { 99 int group = 0; 100 int groupsize = 9 * 32; 101 long pin; 102 char *eptr; 103 104 if (*name == 'P' || *name == 'p') 105 name++; 106 if (*name >= 'A') { 107 group = *name - (*name > 'a' ? 'a' : 'A'); 108 groupsize = 32; 109 name++; 110 } 111 112 pin = simple_strtol(name, &eptr, 10); 113 if (!*name || *eptr) 114 return -1; 115 if (pin < 0 || pin > groupsize || group >= 9) 116 return -1; 117 return group * 32 + pin; 118 } 119 #endif 120 121 int sunxi_name_to_gpio_bank(const char *name) 122 { 123 int group = 0; 124 125 if (*name == 'P' || *name == 'p') 126 name++; 127 if (*name >= 'A') { 128 group = *name - (*name > 'a' ? 'a' : 'A'); 129 return group; 130 } 131 132 return -1; 133 } 134 135 #ifdef CONFIG_DM_GPIO 136 /* TODO(sjg@chromium.org): Remove this function and use device tree */ 137 int sunxi_name_to_gpio(const char *name) 138 { 139 unsigned int gpio; 140 int ret; 141 #if !defined CONFIG_SPL_BUILD && defined CONFIG_AXP_GPIO 142 char lookup[8]; 143 144 if (strcasecmp(name, "AXP0-VBUS-DETECT") == 0) { 145 sprintf(lookup, SUNXI_GPIO_AXP0_PREFIX "%d", 146 SUNXI_GPIO_AXP0_VBUS_DETECT); 147 name = lookup; 148 } else if (strcasecmp(name, "AXP0-VBUS-ENABLE") == 0) { 149 sprintf(lookup, SUNXI_GPIO_AXP0_PREFIX "%d", 150 SUNXI_GPIO_AXP0_VBUS_ENABLE); 151 name = lookup; 152 } 153 #endif 154 ret = gpio_lookup_name(name, NULL, NULL, &gpio); 155 156 return ret ? ret : gpio; 157 } 158 159 static int sunxi_gpio_direction_input(struct udevice *dev, unsigned offset) 160 { 161 struct sunxi_gpio_platdata *plat = dev_get_platdata(dev); 162 163 sunxi_gpio_set_cfgbank(plat->regs, offset, SUNXI_GPIO_INPUT); 164 165 return 0; 166 } 167 168 static int sunxi_gpio_direction_output(struct udevice *dev, unsigned offset, 169 int value) 170 { 171 struct sunxi_gpio_platdata *plat = dev_get_platdata(dev); 172 u32 num = GPIO_NUM(offset); 173 174 sunxi_gpio_set_cfgbank(plat->regs, offset, SUNXI_GPIO_OUTPUT); 175 clrsetbits_le32(&plat->regs->dat, 1 << num, value ? (1 << num) : 0); 176 177 return 0; 178 } 179 180 static int sunxi_gpio_get_value(struct udevice *dev, unsigned offset) 181 { 182 struct sunxi_gpio_platdata *plat = dev_get_platdata(dev); 183 u32 num = GPIO_NUM(offset); 184 unsigned dat; 185 186 dat = readl(&plat->regs->dat); 187 dat >>= num; 188 189 return dat & 0x1; 190 } 191 192 static int sunxi_gpio_set_value(struct udevice *dev, unsigned offset, 193 int value) 194 { 195 struct sunxi_gpio_platdata *plat = dev_get_platdata(dev); 196 u32 num = GPIO_NUM(offset); 197 198 clrsetbits_le32(&plat->regs->dat, 1 << num, value ? (1 << num) : 0); 199 return 0; 200 } 201 202 static int sunxi_gpio_get_function(struct udevice *dev, unsigned offset) 203 { 204 struct sunxi_gpio_platdata *plat = dev_get_platdata(dev); 205 int func; 206 207 func = sunxi_gpio_get_cfgbank(plat->regs, offset); 208 if (func == SUNXI_GPIO_OUTPUT) 209 return GPIOF_OUTPUT; 210 else if (func == SUNXI_GPIO_INPUT) 211 return GPIOF_INPUT; 212 else 213 return GPIOF_FUNC; 214 } 215 216 static int sunxi_gpio_xlate(struct udevice *dev, struct gpio_desc *desc, 217 struct ofnode_phandle_args *args) 218 { 219 int ret; 220 221 ret = device_get_child(dev, args->args[0], &desc->dev); 222 if (ret) 223 return ret; 224 desc->offset = args->args[1]; 225 desc->flags = args->args[2] & GPIO_ACTIVE_LOW ? GPIOD_ACTIVE_LOW : 0; 226 227 return 0; 228 } 229 230 static const struct dm_gpio_ops gpio_sunxi_ops = { 231 .direction_input = sunxi_gpio_direction_input, 232 .direction_output = sunxi_gpio_direction_output, 233 .get_value = sunxi_gpio_get_value, 234 .set_value = sunxi_gpio_set_value, 235 .get_function = sunxi_gpio_get_function, 236 .xlate = sunxi_gpio_xlate, 237 }; 238 239 /** 240 * Returns the name of a GPIO bank 241 * 242 * GPIO banks are named A, B, C, ... 243 * 244 * @bank: Bank number (0, 1..n-1) 245 * @return allocated string containing the name 246 */ 247 static char *gpio_bank_name(int bank) 248 { 249 char *name; 250 251 name = malloc(3); 252 if (name) { 253 name[0] = 'P'; 254 name[1] = 'A' + bank; 255 name[2] = '\0'; 256 } 257 258 return name; 259 } 260 261 static int gpio_sunxi_probe(struct udevice *dev) 262 { 263 struct sunxi_gpio_platdata *plat = dev_get_platdata(dev); 264 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev); 265 266 /* Tell the uclass how many GPIOs we have */ 267 if (plat) { 268 uc_priv->gpio_count = plat->gpio_count; 269 uc_priv->bank_name = plat->bank_name; 270 } 271 272 return 0; 273 } 274 275 struct sunxi_gpio_soc_data { 276 int start; 277 int no_banks; 278 }; 279 280 /** 281 * We have a top-level GPIO device with no actual GPIOs. It has a child 282 * device for each Sunxi bank. 283 */ 284 static int gpio_sunxi_bind(struct udevice *parent) 285 { 286 struct sunxi_gpio_soc_data *soc_data = 287 (struct sunxi_gpio_soc_data *)dev_get_driver_data(parent); 288 struct sunxi_gpio_platdata *plat = parent->platdata; 289 struct sunxi_gpio_reg *ctlr; 290 int bank, ret; 291 292 /* If this is a child device, there is nothing to do here */ 293 if (plat) 294 return 0; 295 296 ctlr = (struct sunxi_gpio_reg *)devfdt_get_addr(parent); 297 for (bank = 0; bank < soc_data->no_banks; bank++) { 298 struct sunxi_gpio_platdata *plat; 299 struct udevice *dev; 300 301 plat = calloc(1, sizeof(*plat)); 302 if (!plat) 303 return -ENOMEM; 304 plat->regs = &ctlr->gpio_bank[bank]; 305 plat->bank_name = gpio_bank_name(soc_data->start + bank); 306 plat->gpio_count = SUNXI_GPIOS_PER_BANK; 307 308 ret = device_bind(parent, parent->driver, 309 plat->bank_name, plat, -1, &dev); 310 if (ret) 311 return ret; 312 dev_set_of_offset(dev, dev_of_offset(parent)); 313 } 314 315 return 0; 316 } 317 318 static const struct sunxi_gpio_soc_data soc_data_a_all = { 319 .start = 0, 320 .no_banks = SUNXI_GPIO_BANKS, 321 }; 322 323 static const struct sunxi_gpio_soc_data soc_data_l_1 = { 324 .start = 'L' - 'A', 325 .no_banks = 1, 326 }; 327 328 static const struct sunxi_gpio_soc_data soc_data_l_2 = { 329 .start = 'L' - 'A', 330 .no_banks = 2, 331 }; 332 333 static const struct sunxi_gpio_soc_data soc_data_l_3 = { 334 .start = 'L' - 'A', 335 .no_banks = 3, 336 }; 337 338 #define ID(_compat_, _soc_data_) \ 339 { .compatible = _compat_, .data = (ulong)&soc_data_##_soc_data_ } 340 341 static const struct udevice_id sunxi_gpio_ids[] = { 342 ID("allwinner,sun4i-a10-pinctrl", a_all), 343 ID("allwinner,sun5i-a10s-pinctrl", a_all), 344 ID("allwinner,sun5i-a13-pinctrl", a_all), 345 ID("allwinner,sun50i-h5-pinctrl", a_all), 346 ID("allwinner,sun6i-a31-pinctrl", a_all), 347 ID("allwinner,sun6i-a31s-pinctrl", a_all), 348 ID("allwinner,sun7i-a20-pinctrl", a_all), 349 ID("allwinner,sun8i-a23-pinctrl", a_all), 350 ID("allwinner,sun8i-a33-pinctrl", a_all), 351 ID("allwinner,sun8i-a83t-pinctrl", a_all), 352 ID("allwinner,sun8i-h3-pinctrl", a_all), 353 ID("allwinner,sun8i-r40-pinctrl", a_all), 354 ID("allwinner,sun8i-v3s-pinctrl", a_all), 355 ID("allwinner,sun9i-a80-pinctrl", a_all), 356 ID("allwinner,sun50i-a64-pinctrl", a_all), 357 ID("allwinner,sun6i-a31-r-pinctrl", l_2), 358 ID("allwinner,sun8i-a23-r-pinctrl", l_1), 359 ID("allwinner,sun8i-a83t-r-pinctrl", l_1), 360 ID("allwinner,sun8i-h3-r-pinctrl", l_1), 361 ID("allwinner,sun9i-a80-r-pinctrl", l_3), 362 ID("allwinner,sun50i-a64-r-pinctrl", l_1), 363 { } 364 }; 365 366 U_BOOT_DRIVER(gpio_sunxi) = { 367 .name = "gpio_sunxi", 368 .id = UCLASS_GPIO, 369 .ops = &gpio_sunxi_ops, 370 .of_match = sunxi_gpio_ids, 371 .bind = gpio_sunxi_bind, 372 .probe = gpio_sunxi_probe, 373 }; 374 #endif 375