| 1 | // SPDX-License-Identifier: GPL-2.0+ |
| 2 | /* |
| 3 | * OF helpers for the GPIO API |
| 4 | * |
| 5 | * Copyright (c) 2007-2008 MontaVista Software, Inc. |
| 6 | * |
| 7 | * Author: Anton Vorontsov <avorontsov@ru.mvista.com> |
| 8 | */ |
| 9 | |
| 10 | #include <linux/device.h> |
| 11 | #include <linux/err.h> |
| 12 | #include <linux/errno.h> |
| 13 | #include <linux/module.h> |
| 14 | #include <linux/io.h> |
| 15 | #include <linux/gpio/consumer.h> |
| 16 | #include <linux/of.h> |
| 17 | #include <linux/of_address.h> |
| 18 | #include <linux/of_gpio.h> |
| 19 | #include <linux/pinctrl/pinctrl.h> |
| 20 | #include <linux/slab.h> |
| 21 | #include <linux/gpio/machine.h> |
| 22 | |
| 23 | #include "gpiolib.h" |
| 24 | |
| 25 | static int of_gpiochip_match_node_and_xlate(struct gpio_chip *chip, void *data) |
| 26 | { |
| 27 | struct of_phandle_args *gpiospec = data; |
| 28 | |
| 29 | return chip->gpiodev->dev.of_node == gpiospec->np && |
| 30 | chip->of_xlate && |
| 31 | chip->of_xlate(chip, gpiospec, NULL) >= 0; |
| 32 | } |
| 33 | |
| 34 | static struct gpio_chip *of_find_gpiochip_by_xlate( |
| 35 | struct of_phandle_args *gpiospec) |
| 36 | { |
| 37 | return gpiochip_find(gpiospec, of_gpiochip_match_node_and_xlate); |
| 38 | } |
| 39 | |
| 40 | static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip, |
| 41 | struct of_phandle_args *gpiospec, |
| 42 | enum of_gpio_flags *flags) |
| 43 | { |
| 44 | int ret; |
| 45 | |
| 46 | if (chip->of_gpio_n_cells != gpiospec->args_count) |
| 47 | return ERR_PTR(-EINVAL); |
| 48 | |
| 49 | ret = chip->of_xlate(chip, gpiospec, flags); |
| 50 | if (ret < 0) |
| 51 | return ERR_PTR(ret); |
| 52 | |
| 53 | return gpiochip_get_desc(chip, ret); |
| 54 | } |
| 55 | |
| 56 | static void of_gpio_flags_quirks(struct device_node *np, |
| 57 | const char *propname, |
| 58 | enum of_gpio_flags *flags, |
| 59 | int index) |
| 60 | { |
| 61 | /* |
| 62 | * Handle MMC "cd-inverted" and "wp-inverted" semantics. |
| 63 | */ |
| 64 | if (IS_ENABLED(CONFIG_MMC)) { |
| 65 | /* |
| 66 | * Active low is the default according to the |
| 67 | * SDHCI specification and the device tree |
| 68 | * bindings. However the code in the current |
| 69 | * kernel was written such that the phandle |
| 70 | * flags were always respected, and "cd-inverted" |
| 71 | * would invert the flag from the device phandle. |
| 72 | */ |
| 73 | if (!strcmp(propname, "cd-gpios")) { |
| 74 | if (of_property_read_bool(np, "cd-inverted")) |
| 75 | *flags ^= OF_GPIO_ACTIVE_LOW; |
| 76 | } |
| 77 | if (!strcmp(propname, "wp-gpios")) { |
| 78 | if (of_property_read_bool(np, "wp-inverted")) |
| 79 | *flags ^= OF_GPIO_ACTIVE_LOW; |
| 80 | } |
| 81 | } |
| 82 | /* |
| 83 | * Some GPIO fixed regulator quirks. |
| 84 | * Note that active low is the default. |
| 85 | */ |
| 86 | if (IS_ENABLED(CONFIG_REGULATOR) && |
| 87 | (of_device_is_compatible(np, "regulator-fixed") || |
| 88 | of_device_is_compatible(np, "reg-fixed-voltage") || |
| 89 | (of_device_is_compatible(np, "regulator-gpio") && |
| 90 | !(strcmp(propname, "enable-gpio") && |
| 91 | strcmp(propname, "enable-gpios"))))) { |
| 92 | /* |
| 93 | * The regulator GPIO handles are specified such that the |
| 94 | * presence or absence of "enable-active-high" solely controls |
| 95 | * the polarity of the GPIO line. Any phandle flags must |
| 96 | * be actively ignored. |
| 97 | */ |
| 98 | if (*flags & OF_GPIO_ACTIVE_LOW) { |
| 99 | pr_warn("%s GPIO handle specifies active low - ignored\n", |
| 100 | of_node_full_name(np)); |
| 101 | *flags &= ~OF_GPIO_ACTIVE_LOW; |
| 102 | } |
| 103 | if (!of_property_read_bool(np, "enable-active-high")) |
| 104 | *flags |= OF_GPIO_ACTIVE_LOW; |
| 105 | } |
| 106 | /* |
| 107 | * Legacy open drain handling for fixed voltage regulators. |
| 108 | */ |
| 109 | if (IS_ENABLED(CONFIG_REGULATOR) && |
| 110 | of_device_is_compatible(np, "reg-fixed-voltage") && |
| 111 | of_property_read_bool(np, "gpio-open-drain")) { |
| 112 | *flags |= (OF_GPIO_SINGLE_ENDED | OF_GPIO_OPEN_DRAIN); |
| 113 | pr_info("%s uses legacy open drain flag - update the DTS if you can\n", |
| 114 | of_node_full_name(np)); |
| 115 | } |
| 116 | |
| 117 | /* |
| 118 | * Legacy handling of SPI active high chip select. If we have a |
| 119 | * property named "cs-gpios" we need to inspect the child node |
| 120 | * to determine if the flags should have inverted semantics. |
| 121 | */ |
| 122 | if (IS_ENABLED(CONFIG_SPI_MASTER) && |
| 123 | of_property_read_bool(np, "cs-gpios") && |
| 124 | !strcmp(propname, "cs-gpios")) { |
| 125 | struct device_node *child; |
| 126 | u32 cs; |
| 127 | int ret; |
| 128 | |
| 129 | for_each_child_of_node(np, child) { |
| 130 | ret = of_property_read_u32(child, "reg", &cs); |
| 131 | if (ret) |
| 132 | continue; |
| 133 | if (cs == index) { |
| 134 | /* |
| 135 | * SPI children have active low chip selects |
| 136 | * by default. This can be specified negatively |
| 137 | * by just omitting "spi-cs-high" in the |
| 138 | * device node, or actively by tagging on |
| 139 | * GPIO_ACTIVE_LOW as flag in the device |
| 140 | * tree. If the line is simultaneously |
| 141 | * tagged as active low in the device tree |
| 142 | * and has the "spi-cs-high" set, we get a |
| 143 | * conflict and the "spi-cs-high" flag will |
| 144 | * take precedence. |
| 145 | */ |
| 146 | if (of_property_read_bool(child, "spi-cs-high")) { |
| 147 | if (*flags & OF_GPIO_ACTIVE_LOW) { |
| 148 | pr_warn("%s GPIO handle specifies active low - ignored\n", |
| 149 | of_node_full_name(child)); |
| 150 | *flags &= ~OF_GPIO_ACTIVE_LOW; |
| 151 | } |
| 152 | } else { |
| 153 | if (!(*flags & OF_GPIO_ACTIVE_LOW)) |
| 154 | pr_info("%s enforce active low on chipselect handle\n", |
| 155 | of_node_full_name(child)); |
| 156 | *flags |= OF_GPIO_ACTIVE_LOW; |
| 157 | } |
| 158 | break; |
| 159 | } |
| 160 | } |
| 161 | } |
| 162 | } |
| 163 | |
| 164 | /** |
| 165 | * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API |
| 166 | * @np: device node to get GPIO from |
| 167 | * @propname: property name containing gpio specifier(s) |
| 168 | * @index: index of the GPIO |
| 169 | * @flags: a flags pointer to fill in |
| 170 | * |
| 171 | * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno |
| 172 | * value on the error condition. If @flags is not NULL the function also fills |
| 173 | * in flags for the GPIO. |
| 174 | */ |
| 175 | struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np, |
| 176 | const char *propname, int index, enum of_gpio_flags *flags) |
| 177 | { |
| 178 | struct of_phandle_args gpiospec; |
| 179 | struct gpio_chip *chip; |
| 180 | struct gpio_desc *desc; |
| 181 | int ret; |
| 182 | |
| 183 | ret = of_parse_phandle_with_args_map(np, propname, "gpio", index, |
| 184 | &gpiospec); |
| 185 | if (ret) { |
| 186 | pr_debug("%s: can't parse '%s' property of node '%pOF[%d]'\n", |
| 187 | __func__, propname, np, index); |
| 188 | return ERR_PTR(ret); |
| 189 | } |
| 190 | |
| 191 | chip = of_find_gpiochip_by_xlate(&gpiospec); |
| 192 | if (!chip) { |
| 193 | desc = ERR_PTR(-EPROBE_DEFER); |
| 194 | goto out; |
| 195 | } |
| 196 | |
| 197 | desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, flags); |
| 198 | if (IS_ERR(desc)) |
| 199 | goto out; |
| 200 | |
| 201 | if (flags) |
| 202 | of_gpio_flags_quirks(np, propname, flags, index); |
| 203 | |
| 204 | pr_debug("%s: parsed '%s' property of node '%pOF[%d]' - status (%d)\n", |
| 205 | __func__, propname, np, index, |
| 206 | PTR_ERR_OR_ZERO(desc)); |
| 207 | |
| 208 | out: |
| 209 | of_node_put(gpiospec.np); |
| 210 | |
| 211 | return desc; |
| 212 | } |
| 213 | |
| 214 | int of_get_named_gpio_flags(struct device_node *np, const char *list_name, |
| 215 | int index, enum of_gpio_flags *flags) |
| 216 | { |
| 217 | struct gpio_desc *desc; |
| 218 | |
| 219 | desc = of_get_named_gpiod_flags(np, list_name, index, flags); |
| 220 | |
| 221 | if (IS_ERR(desc)) |
| 222 | return PTR_ERR(desc); |
| 223 | else |
| 224 | return desc_to_gpio(desc); |
| 225 | } |
| 226 | EXPORT_SYMBOL(of_get_named_gpio_flags); |
| 227 | |
| 228 | /* |
| 229 | * The SPI GPIO bindings happened before we managed to establish that GPIO |
| 230 | * properties should be named "foo-gpios" so we have this special kludge for |
| 231 | * them. |
| 232 | */ |
| 233 | static struct gpio_desc *of_find_spi_gpio(struct device *dev, const char *con_id, |
| 234 | enum of_gpio_flags *of_flags) |
| 235 | { |
| 236 | char prop_name[32]; /* 32 is max size of property name */ |
| 237 | struct device_node *np = dev->of_node; |
| 238 | struct gpio_desc *desc; |
| 239 | |
| 240 | /* |
| 241 | * Hopefully the compiler stubs the rest of the function if this |
| 242 | * is false. |
| 243 | */ |
| 244 | if (!IS_ENABLED(CONFIG_SPI_MASTER)) |
| 245 | return ERR_PTR(-ENOENT); |
| 246 | |
| 247 | /* Allow this specifically for "spi-gpio" devices */ |
| 248 | if (!of_device_is_compatible(np, "spi-gpio") || !con_id) |
| 249 | return ERR_PTR(-ENOENT); |
| 250 | |
| 251 | /* Will be "gpio-sck", "gpio-mosi" or "gpio-miso" */ |
| 252 | snprintf(prop_name, sizeof(prop_name), "%s-%s", "gpio", con_id); |
| 253 | |
| 254 | desc = of_get_named_gpiod_flags(np, prop_name, 0, of_flags); |
| 255 | return desc; |
| 256 | } |
| 257 | |
| 258 | /* |
| 259 | * Some regulator bindings happened before we managed to establish that GPIO |
| 260 | * properties should be named "foo-gpios" so we have this special kludge for |
| 261 | * them. |
| 262 | */ |
| 263 | static struct gpio_desc *of_find_regulator_gpio(struct device *dev, const char *con_id, |
| 264 | enum of_gpio_flags *of_flags) |
| 265 | { |
| 266 | /* These are the connection IDs we accept as legacy GPIO phandles */ |
| 267 | const char *whitelist[] = { |
| 268 | "wlf,ldoena", /* Arizona */ |
| 269 | "wlf,ldo1ena", /* WM8994 */ |
| 270 | "wlf,ldo2ena", /* WM8994 */ |
| 271 | }; |
| 272 | struct device_node *np = dev->of_node; |
| 273 | struct gpio_desc *desc; |
| 274 | int i; |
| 275 | |
| 276 | if (!IS_ENABLED(CONFIG_REGULATOR)) |
| 277 | return ERR_PTR(-ENOENT); |
| 278 | |
| 279 | if (!con_id) |
| 280 | return ERR_PTR(-ENOENT); |
| 281 | |
| 282 | i = match_string(whitelist, ARRAY_SIZE(whitelist), con_id); |
| 283 | if (i < 0) |
| 284 | return ERR_PTR(-ENOENT); |
| 285 | |
| 286 | desc = of_get_named_gpiod_flags(np, con_id, 0, of_flags); |
| 287 | return desc; |
| 288 | } |
| 289 | |
| 290 | struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id, |
| 291 | unsigned int idx, |
| 292 | enum gpio_lookup_flags *flags) |
| 293 | { |
| 294 | char prop_name[32]; /* 32 is max size of property name */ |
| 295 | enum of_gpio_flags of_flags; |
| 296 | struct gpio_desc *desc; |
| 297 | unsigned int i; |
| 298 | |
| 299 | /* Try GPIO property "foo-gpios" and "foo-gpio" */ |
| 300 | for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { |
| 301 | if (con_id) |
| 302 | snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id, |
| 303 | gpio_suffixes[i]); |
| 304 | else |
| 305 | snprintf(prop_name, sizeof(prop_name), "%s", |
| 306 | gpio_suffixes[i]); |
| 307 | |
| 308 | desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx, |
| 309 | &of_flags); |
| 310 | /* |
| 311 | * -EPROBE_DEFER in our case means that we found a |
| 312 | * valid GPIO property, but no controller has been |
| 313 | * registered so far. |
| 314 | * |
| 315 | * This means we don't need to look any further for |
| 316 | * alternate name conventions, and we should really |
| 317 | * preserve the return code for our user to be able to |
| 318 | * retry probing later. |
| 319 | */ |
| 320 | if (IS_ERR(desc) && PTR_ERR(desc) == -EPROBE_DEFER) |
| 321 | return desc; |
| 322 | |
| 323 | if (!IS_ERR(desc) || (PTR_ERR(desc) != -ENOENT)) |
| 324 | break; |
| 325 | } |
| 326 | |
| 327 | /* Special handling for SPI GPIOs if used */ |
| 328 | if (IS_ERR(desc)) |
| 329 | desc = of_find_spi_gpio(dev, con_id, &of_flags); |
| 330 | |
| 331 | /* Special handling for regulator GPIOs if used */ |
| 332 | if (IS_ERR(desc) && PTR_ERR(desc) != -EPROBE_DEFER) |
| 333 | desc = of_find_regulator_gpio(dev, con_id, &of_flags); |
| 334 | |
| 335 | if (IS_ERR(desc)) |
| 336 | return desc; |
| 337 | |
| 338 | if (of_flags & OF_GPIO_ACTIVE_LOW) |
| 339 | *flags |= GPIO_ACTIVE_LOW; |
| 340 | |
| 341 | if (of_flags & OF_GPIO_SINGLE_ENDED) { |
| 342 | if (of_flags & OF_GPIO_OPEN_DRAIN) |
| 343 | *flags |= GPIO_OPEN_DRAIN; |
| 344 | else |
| 345 | *flags |= GPIO_OPEN_SOURCE; |
| 346 | } |
| 347 | |
| 348 | if (of_flags & OF_GPIO_TRANSITORY) |
| 349 | *flags |= GPIO_TRANSITORY; |
| 350 | |
| 351 | if (of_flags & OF_GPIO_PULL_UP) |
| 352 | *flags |= GPIO_PULL_UP; |
| 353 | if (of_flags & OF_GPIO_PULL_DOWN) |
| 354 | *flags |= GPIO_PULL_DOWN; |
| 355 | |
| 356 | return desc; |
| 357 | } |
| 358 | |
| 359 | /** |
| 360 | * of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API |
| 361 | * @np: device node to get GPIO from |
| 362 | * @chip: GPIO chip whose hog is parsed |
| 363 | * @idx: Index of the GPIO to parse |
| 364 | * @name: GPIO line name |
| 365 | * @lflags: gpio_lookup_flags - returned from of_find_gpio() or |
| 366 | * of_parse_own_gpio() |
| 367 | * @dflags: gpiod_flags - optional GPIO initialization flags |
| 368 | * |
| 369 | * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno |
| 370 | * value on the error condition. |
| 371 | */ |
| 372 | static struct gpio_desc *of_parse_own_gpio(struct device_node *np, |
| 373 | struct gpio_chip *chip, |
| 374 | unsigned int idx, const char **name, |
| 375 | enum gpio_lookup_flags *lflags, |
| 376 | enum gpiod_flags *dflags) |
| 377 | { |
| 378 | struct device_node *chip_np; |
| 379 | enum of_gpio_flags xlate_flags; |
| 380 | struct of_phandle_args gpiospec; |
| 381 | struct gpio_desc *desc; |
| 382 | unsigned int i; |
| 383 | u32 tmp; |
| 384 | int ret; |
| 385 | |
| 386 | chip_np = chip->of_node; |
| 387 | if (!chip_np) |
| 388 | return ERR_PTR(-EINVAL); |
| 389 | |
| 390 | xlate_flags = 0; |
| 391 | *lflags = 0; |
| 392 | *dflags = 0; |
| 393 | |
| 394 | ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp); |
| 395 | if (ret) |
| 396 | return ERR_PTR(ret); |
| 397 | |
| 398 | gpiospec.np = chip_np; |
| 399 | gpiospec.args_count = tmp; |
| 400 | |
| 401 | for (i = 0; i < tmp; i++) { |
| 402 | ret = of_property_read_u32_index(np, "gpios", idx * tmp + i, |
| 403 | &gpiospec.args[i]); |
| 404 | if (ret) |
| 405 | return ERR_PTR(ret); |
| 406 | } |
| 407 | |
| 408 | desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, &xlate_flags); |
| 409 | if (IS_ERR(desc)) |
| 410 | return desc; |
| 411 | |
| 412 | if (xlate_flags & OF_GPIO_ACTIVE_LOW) |
| 413 | *lflags |= GPIO_ACTIVE_LOW; |
| 414 | if (xlate_flags & OF_GPIO_TRANSITORY) |
| 415 | *lflags |= GPIO_TRANSITORY; |
| 416 | |
| 417 | if (of_property_read_bool(np, "input")) |
| 418 | *dflags |= GPIOD_IN; |
| 419 | else if (of_property_read_bool(np, "output-low")) |
| 420 | *dflags |= GPIOD_OUT_LOW; |
| 421 | else if (of_property_read_bool(np, "output-high")) |
| 422 | *dflags |= GPIOD_OUT_HIGH; |
| 423 | else { |
| 424 | pr_warn("GPIO line %d (%pOFn): no hogging state specified, bailing out\n", |
| 425 | desc_to_gpio(desc), np); |
| 426 | return ERR_PTR(-EINVAL); |
| 427 | } |
| 428 | |
| 429 | if (name && of_property_read_string(np, "line-name", name)) |
| 430 | *name = np->name; |
| 431 | |
| 432 | return desc; |
| 433 | } |
| 434 | |
| 435 | /** |
| 436 | * of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions |
| 437 | * @chip: gpio chip to act on |
| 438 | * |
| 439 | * This is only used by of_gpiochip_add to request/set GPIO initial |
| 440 | * configuration. |
| 441 | * It returns error if it fails otherwise 0 on success. |
| 442 | */ |
| 443 | static int of_gpiochip_scan_gpios(struct gpio_chip *chip) |
| 444 | { |
| 445 | struct gpio_desc *desc = NULL; |
| 446 | struct device_node *np; |
| 447 | const char *name; |
| 448 | enum gpio_lookup_flags lflags; |
| 449 | enum gpiod_flags dflags; |
| 450 | unsigned int i; |
| 451 | int ret; |
| 452 | |
| 453 | for_each_available_child_of_node(chip->of_node, np) { |
| 454 | if (!of_property_read_bool(np, "gpio-hog")) |
| 455 | continue; |
| 456 | |
| 457 | for (i = 0;; i++) { |
| 458 | desc = of_parse_own_gpio(np, chip, i, &name, &lflags, |
| 459 | &dflags); |
| 460 | if (IS_ERR(desc)) |
| 461 | break; |
| 462 | |
| 463 | ret = gpiod_hog(desc, name, lflags, dflags); |
| 464 | if (ret < 0) { |
| 465 | of_node_put(np); |
| 466 | return ret; |
| 467 | } |
| 468 | } |
| 469 | } |
| 470 | |
| 471 | return 0; |
| 472 | } |
| 473 | |
| 474 | /** |
| 475 | * of_gpio_simple_xlate - translate gpiospec to the GPIO number and flags |
| 476 | * @gc: pointer to the gpio_chip structure |
| 477 | * @gpiospec: GPIO specifier as found in the device tree |
| 478 | * @flags: a flags pointer to fill in |
| 479 | * |
| 480 | * This is simple translation function, suitable for the most 1:1 mapped |
| 481 | * GPIO chips. This function performs only one sanity check: whether GPIO |
| 482 | * is less than ngpios (that is specified in the gpio_chip). |
| 483 | */ |
| 484 | int of_gpio_simple_xlate(struct gpio_chip *gc, |
| 485 | const struct of_phandle_args *gpiospec, u32 *flags) |
| 486 | { |
| 487 | /* |
| 488 | * We're discouraging gpio_cells < 2, since that way you'll have to |
| 489 | * write your own xlate function (that will have to retrieve the GPIO |
| 490 | * number and the flags from a single gpio cell -- this is possible, |
| 491 | * but not recommended). |
| 492 | */ |
| 493 | if (gc->of_gpio_n_cells < 2) { |
| 494 | WARN_ON(1); |
| 495 | return -EINVAL; |
| 496 | } |
| 497 | |
| 498 | if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells)) |
| 499 | return -EINVAL; |
| 500 | |
| 501 | if (gpiospec->args[0] >= gc->ngpio) |
| 502 | return -EINVAL; |
| 503 | |
| 504 | if (flags) |
| 505 | *flags = gpiospec->args[1]; |
| 506 | |
| 507 | return gpiospec->args[0]; |
| 508 | } |
| 509 | EXPORT_SYMBOL(of_gpio_simple_xlate); |
| 510 | |
| 511 | /** |
| 512 | * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank) |
| 513 | * @np: device node of the GPIO chip |
| 514 | * @mm_gc: pointer to the of_mm_gpio_chip allocated structure |
| 515 | * @data: driver data to store in the struct gpio_chip |
| 516 | * |
| 517 | * To use this function you should allocate and fill mm_gc with: |
| 518 | * |
| 519 | * 1) In the gpio_chip structure: |
| 520 | * - all the callbacks |
| 521 | * - of_gpio_n_cells |
| 522 | * - of_xlate callback (optional) |
| 523 | * |
| 524 | * 3) In the of_mm_gpio_chip structure: |
| 525 | * - save_regs callback (optional) |
| 526 | * |
| 527 | * If succeeded, this function will map bank's memory and will |
| 528 | * do all necessary work for you. Then you'll able to use .regs |
| 529 | * to manage GPIOs from the callbacks. |
| 530 | */ |
| 531 | int of_mm_gpiochip_add_data(struct device_node *np, |
| 532 | struct of_mm_gpio_chip *mm_gc, |
| 533 | void *data) |
| 534 | { |
| 535 | int ret = -ENOMEM; |
| 536 | struct gpio_chip *gc = &mm_gc->gc; |
| 537 | |
| 538 | gc->label = kasprintf(GFP_KERNEL, "%pOF", np); |
| 539 | if (!gc->label) |
| 540 | goto err0; |
| 541 | |
| 542 | mm_gc->regs = of_iomap(np, 0); |
| 543 | if (!mm_gc->regs) |
| 544 | goto err1; |
| 545 | |
| 546 | gc->base = -1; |
| 547 | |
| 548 | if (mm_gc->save_regs) |
| 549 | mm_gc->save_regs(mm_gc); |
| 550 | |
| 551 | mm_gc->gc.of_node = np; |
| 552 | |
| 553 | ret = gpiochip_add_data(gc, data); |
| 554 | if (ret) |
| 555 | goto err2; |
| 556 | |
| 557 | return 0; |
| 558 | err2: |
| 559 | iounmap(mm_gc->regs); |
| 560 | err1: |
| 561 | kfree(gc->label); |
| 562 | err0: |
| 563 | pr_err("%pOF: GPIO chip registration failed with status %d\n", np, ret); |
| 564 | return ret; |
| 565 | } |
| 566 | EXPORT_SYMBOL(of_mm_gpiochip_add_data); |
| 567 | |
| 568 | /** |
| 569 | * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank) |
| 570 | * @mm_gc: pointer to the of_mm_gpio_chip allocated structure |
| 571 | */ |
| 572 | void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc) |
| 573 | { |
| 574 | struct gpio_chip *gc = &mm_gc->gc; |
| 575 | |
| 576 | if (!mm_gc) |
| 577 | return; |
| 578 | |
| 579 | gpiochip_remove(gc); |
| 580 | iounmap(mm_gc->regs); |
| 581 | kfree(gc->label); |
| 582 | } |
| 583 | EXPORT_SYMBOL(of_mm_gpiochip_remove); |
| 584 | |
| 585 | static void of_gpiochip_init_valid_mask(struct gpio_chip *chip) |
| 586 | { |
| 587 | int len, i; |
| 588 | u32 start, count; |
| 589 | struct device_node *np = chip->of_node; |
| 590 | |
| 591 | len = of_property_count_u32_elems(np, "gpio-reserved-ranges"); |
| 592 | if (len < 0 || len % 2 != 0) |
| 593 | return; |
| 594 | |
| 595 | for (i = 0; i < len; i += 2) { |
| 596 | of_property_read_u32_index(np, "gpio-reserved-ranges", |
| 597 | i, &start); |
| 598 | of_property_read_u32_index(np, "gpio-reserved-ranges", |
| 599 | i + 1, &count); |
| 600 | if (start >= chip->ngpio || start + count >= chip->ngpio) |
| 601 | continue; |
| 602 | |
| 603 | bitmap_clear(chip->valid_mask, start, count); |
| 604 | } |
| 605 | }; |
| 606 | |
| 607 | #ifdef CONFIG_PINCTRL |
| 608 | static int of_gpiochip_add_pin_range(struct gpio_chip *chip) |
| 609 | { |
| 610 | struct device_node *np = chip->of_node; |
| 611 | struct of_phandle_args pinspec; |
| 612 | struct pinctrl_dev *pctldev; |
| 613 | int index = 0, ret; |
| 614 | const char *name; |
| 615 | static const char group_names_propname[] = "gpio-ranges-group-names"; |
| 616 | struct property *group_names; |
| 617 | |
| 618 | if (!np) |
| 619 | return 0; |
| 620 | |
| 621 | group_names = of_find_property(np, group_names_propname, NULL); |
| 622 | |
| 623 | for (;; index++) { |
| 624 | ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3, |
| 625 | index, &pinspec); |
| 626 | if (ret) |
| 627 | break; |
| 628 | |
| 629 | pctldev = of_pinctrl_get(pinspec.np); |
| 630 | of_node_put(pinspec.np); |
| 631 | if (!pctldev) |
| 632 | return -EPROBE_DEFER; |
| 633 | |
| 634 | if (pinspec.args[2]) { |
| 635 | if (group_names) { |
| 636 | of_property_read_string_index(np, |
| 637 | group_names_propname, |
| 638 | index, &name); |
| 639 | if (strlen(name)) { |
| 640 | pr_err("%pOF: Group name of numeric GPIO ranges must be the empty string.\n", |
| 641 | np); |
| 642 | break; |
| 643 | } |
| 644 | } |
| 645 | /* npins != 0: linear range */ |
| 646 | ret = gpiochip_add_pin_range(chip, |
| 647 | pinctrl_dev_get_devname(pctldev), |
| 648 | pinspec.args[0], |
| 649 | pinspec.args[1], |
| 650 | pinspec.args[2]); |
| 651 | if (ret) |
| 652 | return ret; |
| 653 | } else { |
| 654 | /* npins == 0: special range */ |
| 655 | if (pinspec.args[1]) { |
| 656 | pr_err("%pOF: Illegal gpio-range format.\n", |
| 657 | np); |
| 658 | break; |
| 659 | } |
| 660 | |
| 661 | if (!group_names) { |
| 662 | pr_err("%pOF: GPIO group range requested but no %s property.\n", |
| 663 | np, group_names_propname); |
| 664 | break; |
| 665 | } |
| 666 | |
| 667 | ret = of_property_read_string_index(np, |
| 668 | group_names_propname, |
| 669 | index, &name); |
| 670 | if (ret) |
| 671 | break; |
| 672 | |
| 673 | if (!strlen(name)) { |
| 674 | pr_err("%pOF: Group name of GPIO group range cannot be the empty string.\n", |
| 675 | np); |
| 676 | break; |
| 677 | } |
| 678 | |
| 679 | ret = gpiochip_add_pingroup_range(chip, pctldev, |
| 680 | pinspec.args[0], name); |
| 681 | if (ret) |
| 682 | return ret; |
| 683 | } |
| 684 | } |
| 685 | |
| 686 | return 0; |
| 687 | } |
| 688 | |
| 689 | #else |
| 690 | static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; } |
| 691 | #endif |
| 692 | |
| 693 | int of_gpiochip_add(struct gpio_chip *chip) |
| 694 | { |
| 695 | int status; |
| 696 | |
| 697 | if (!chip->of_node) |
| 698 | return 0; |
| 699 | |
| 700 | if (!chip->of_xlate) { |
| 701 | chip->of_gpio_n_cells = 2; |
| 702 | chip->of_xlate = of_gpio_simple_xlate; |
| 703 | } |
| 704 | |
| 705 | if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS) |
| 706 | return -EINVAL; |
| 707 | |
| 708 | of_gpiochip_init_valid_mask(chip); |
| 709 | |
| 710 | status = of_gpiochip_add_pin_range(chip); |
| 711 | if (status) |
| 712 | return status; |
| 713 | |
| 714 | /* If the chip defines names itself, these take precedence */ |
| 715 | if (!chip->names) |
| 716 | devprop_gpiochip_set_names(chip, |
| 717 | of_fwnode_handle(chip->of_node)); |
| 718 | |
| 719 | of_node_get(chip->of_node); |
| 720 | |
| 721 | status = of_gpiochip_scan_gpios(chip); |
| 722 | if (status) { |
| 723 | of_node_put(chip->of_node); |
| 724 | gpiochip_remove_pin_ranges(chip); |
| 725 | } |
| 726 | |
| 727 | return status; |
| 728 | } |
| 729 | |
| 730 | void of_gpiochip_remove(struct gpio_chip *chip) |
| 731 | { |
| 732 | gpiochip_remove_pin_ranges(chip); |
| 733 | of_node_put(chip->of_node); |
| 734 | } |