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/io.h> |
14 | #include <linux/module.h> |
15 | #include <linux/of.h> |
16 | #include <linux/of_address.h> |
17 | #include <linux/of_gpio.h> |
18 | #include <linux/pinctrl/pinctrl.h> |
19 | #include <linux/slab.h> |
20 | #include <linux/string.h> |
21 | |
22 | #include <linux/gpio/consumer.h> |
23 | #include <linux/gpio/machine.h> |
24 | |
25 | #include "gpiolib.h" |
26 | #include "gpiolib-of.h" |
27 | |
28 | /* |
29 | * This is Linux-specific flags. By default controllers' and Linux' mapping |
30 | * match, but GPIO controllers are free to translate their own flags to |
31 | * Linux-specific in their .xlate callback. Though, 1:1 mapping is recommended. |
32 | */ |
33 | enum of_gpio_flags { |
34 | OF_GPIO_ACTIVE_LOW = 0x1, |
35 | OF_GPIO_SINGLE_ENDED = 0x2, |
36 | OF_GPIO_OPEN_DRAIN = 0x4, |
37 | OF_GPIO_TRANSITORY = 0x8, |
38 | OF_GPIO_PULL_UP = 0x10, |
39 | OF_GPIO_PULL_DOWN = 0x20, |
40 | OF_GPIO_PULL_DISABLE = 0x40, |
41 | }; |
42 | |
43 | /** |
44 | * of_gpio_named_count() - Count GPIOs for a device |
45 | * @np: device node to count GPIOs for |
46 | * @propname: property name containing gpio specifier(s) |
47 | * |
48 | * The function returns the count of GPIOs specified for a node. |
49 | * Note that the empty GPIO specifiers count too. Returns either |
50 | * Number of gpios defined in property, |
51 | * -EINVAL for an incorrectly formed gpios property, or |
52 | * -ENOENT for a missing gpios property |
53 | * |
54 | * Example: |
55 | * gpios = <0 |
56 | * &gpio1 1 2 |
57 | * 0 |
58 | * &gpio2 3 4>; |
59 | * |
60 | * The above example defines four GPIOs, two of which are not specified. |
61 | * This function will return '4' |
62 | */ |
63 | static int of_gpio_named_count(const struct device_node *np, |
64 | const char *propname) |
65 | { |
66 | return of_count_phandle_with_args(np, list_name: propname, cells_name: "#gpio-cells" ); |
67 | } |
68 | |
69 | /** |
70 | * of_gpio_spi_cs_get_count() - special GPIO counting for SPI |
71 | * @np: Consuming device node |
72 | * @con_id: Function within the GPIO consumer |
73 | * |
74 | * Some elder GPIO controllers need special quirks. Currently we handle |
75 | * the Freescale and PPC GPIO controller with bindings that doesn't use the |
76 | * established "cs-gpios" for chip selects but instead rely on |
77 | * "gpios" for the chip select lines. If we detect this, we redirect |
78 | * the counting of "cs-gpios" to count "gpios" transparent to the |
79 | * driver. |
80 | */ |
81 | static int of_gpio_spi_cs_get_count(const struct device_node *np, |
82 | const char *con_id) |
83 | { |
84 | if (!IS_ENABLED(CONFIG_SPI_MASTER)) |
85 | return 0; |
86 | if (!con_id || strcmp(con_id, "cs" )) |
87 | return 0; |
88 | if (!of_device_is_compatible(device: np, "fsl,spi" ) && |
89 | !of_device_is_compatible(device: np, "aeroflexgaisler,spictrl" ) && |
90 | !of_device_is_compatible(device: np, "ibm,ppc4xx-spi" )) |
91 | return 0; |
92 | return of_gpio_named_count(np, propname: "gpios" ); |
93 | } |
94 | |
95 | int of_gpio_count(const struct fwnode_handle *fwnode, const char *con_id) |
96 | { |
97 | const struct device_node *np = to_of_node(fwnode); |
98 | int ret; |
99 | char propname[32]; |
100 | unsigned int i; |
101 | |
102 | ret = of_gpio_spi_cs_get_count(np, con_id); |
103 | if (ret > 0) |
104 | return ret; |
105 | |
106 | for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { |
107 | if (con_id) |
108 | snprintf(buf: propname, size: sizeof(propname), fmt: "%s-%s" , |
109 | con_id, gpio_suffixes[i]); |
110 | else |
111 | snprintf(buf: propname, size: sizeof(propname), fmt: "%s" , |
112 | gpio_suffixes[i]); |
113 | |
114 | ret = of_gpio_named_count(np, propname); |
115 | if (ret > 0) |
116 | break; |
117 | } |
118 | return ret ? ret : -ENOENT; |
119 | } |
120 | |
121 | static int of_gpiochip_match_node_and_xlate(struct gpio_chip *chip, |
122 | const void *data) |
123 | { |
124 | const struct of_phandle_args *gpiospec = data; |
125 | |
126 | return device_match_of_node(dev: &chip->gpiodev->dev, np: gpiospec->np) && |
127 | chip->of_xlate && |
128 | chip->of_xlate(chip, gpiospec, NULL) >= 0; |
129 | } |
130 | |
131 | static struct gpio_device * |
132 | of_find_gpio_device_by_xlate(const struct of_phandle_args *gpiospec) |
133 | { |
134 | return gpio_device_find(data: gpiospec, match: of_gpiochip_match_node_and_xlate); |
135 | } |
136 | |
137 | static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip, |
138 | struct of_phandle_args *gpiospec, |
139 | enum of_gpio_flags *flags) |
140 | { |
141 | int ret; |
142 | |
143 | if (chip->of_gpio_n_cells != gpiospec->args_count) |
144 | return ERR_PTR(error: -EINVAL); |
145 | |
146 | ret = chip->of_xlate(chip, gpiospec, flags); |
147 | if (ret < 0) |
148 | return ERR_PTR(error: ret); |
149 | |
150 | return gpiochip_get_desc(gc: chip, hwnum: ret); |
151 | } |
152 | |
153 | /* |
154 | * Overrides stated polarity of a gpio line and warns when there is a |
155 | * discrepancy. |
156 | */ |
157 | static void of_gpio_quirk_polarity(const struct device_node *np, |
158 | bool active_high, |
159 | enum of_gpio_flags *flags) |
160 | { |
161 | if (active_high) { |
162 | if (*flags & OF_GPIO_ACTIVE_LOW) { |
163 | pr_warn("%s GPIO handle specifies active low - ignored\n" , |
164 | of_node_full_name(np)); |
165 | *flags &= ~OF_GPIO_ACTIVE_LOW; |
166 | } |
167 | } else { |
168 | if (!(*flags & OF_GPIO_ACTIVE_LOW)) |
169 | pr_info("%s enforce active low on GPIO handle\n" , |
170 | of_node_full_name(np)); |
171 | *flags |= OF_GPIO_ACTIVE_LOW; |
172 | } |
173 | } |
174 | |
175 | /* |
176 | * This quirk does static polarity overrides in cases where existing |
177 | * DTS specified incorrect polarity. |
178 | */ |
179 | static void of_gpio_try_fixup_polarity(const struct device_node *np, |
180 | const char *propname, |
181 | enum of_gpio_flags *flags) |
182 | { |
183 | static const struct { |
184 | const char *compatible; |
185 | const char *propname; |
186 | bool active_high; |
187 | } gpios[] = { |
188 | #if IS_ENABLED(CONFIG_LCD_HX8357) |
189 | /* |
190 | * Himax LCD controllers used incorrectly named |
191 | * "gpios-reset" property and also specified wrong |
192 | * polarity. |
193 | */ |
194 | { "himax,hx8357" , "gpios-reset" , false }, |
195 | { "himax,hx8369" , "gpios-reset" , false }, |
196 | /* |
197 | * The rb-gpios semantics was undocumented and qi,lb60 (along with |
198 | * the ingenic driver) got it wrong. The active state encodes the |
199 | * NAND ready state, which is high level. Since there's no signal |
200 | * inverter on this board, it should be active-high. Let's fix that |
201 | * here for older DTs so we can re-use the generic nand_gpio_waitrdy() |
202 | * helper, and be consistent with what other drivers do. |
203 | */ |
204 | { "qi,lb60" , "rb-gpios" , true }, |
205 | #endif |
206 | }; |
207 | unsigned int i; |
208 | |
209 | for (i = 0; i < ARRAY_SIZE(gpios); i++) { |
210 | if (of_device_is_compatible(device: np, gpios[i].compatible) && |
211 | !strcmp(propname, gpios[i].propname)) { |
212 | of_gpio_quirk_polarity(np, active_high: gpios[i].active_high, flags); |
213 | break; |
214 | } |
215 | } |
216 | } |
217 | |
218 | static void of_gpio_set_polarity_by_property(const struct device_node *np, |
219 | const char *propname, |
220 | enum of_gpio_flags *flags) |
221 | { |
222 | const struct device_node *np_compat = np; |
223 | const struct device_node *np_propname = np; |
224 | static const struct { |
225 | const char *compatible; |
226 | const char *gpio_propname; |
227 | const char *polarity_propname; |
228 | } gpios[] = { |
229 | #if IS_ENABLED(CONFIG_FEC) |
230 | /* Freescale Fast Ethernet Controller */ |
231 | { "fsl,imx25-fec" , "phy-reset-gpios" , "phy-reset-active-high" }, |
232 | { "fsl,imx27-fec" , "phy-reset-gpios" , "phy-reset-active-high" }, |
233 | { "fsl,imx28-fec" , "phy-reset-gpios" , "phy-reset-active-high" }, |
234 | { "fsl,imx6q-fec" , "phy-reset-gpios" , "phy-reset-active-high" }, |
235 | { "fsl,mvf600-fec" , "phy-reset-gpios" , "phy-reset-active-high" }, |
236 | { "fsl,imx6sx-fec" , "phy-reset-gpios" , "phy-reset-active-high" }, |
237 | { "fsl,imx6ul-fec" , "phy-reset-gpios" , "phy-reset-active-high" }, |
238 | { "fsl,imx8mq-fec" , "phy-reset-gpios" , "phy-reset-active-high" }, |
239 | { "fsl,imx8qm-fec" , "phy-reset-gpios" , "phy-reset-active-high" }, |
240 | { "fsl,s32v234-fec" , "phy-reset-gpios" , "phy-reset-active-high" }, |
241 | #endif |
242 | #if IS_ENABLED(CONFIG_PCI_IMX6) |
243 | { "fsl,imx6q-pcie" , "reset-gpio" , "reset-gpio-active-high" }, |
244 | { "fsl,imx6sx-pcie" , "reset-gpio" , "reset-gpio-active-high" }, |
245 | { "fsl,imx6qp-pcie" , "reset-gpio" , "reset-gpio-active-high" }, |
246 | { "fsl,imx7d-pcie" , "reset-gpio" , "reset-gpio-active-high" }, |
247 | { "fsl,imx8mq-pcie" , "reset-gpio" , "reset-gpio-active-high" }, |
248 | { "fsl,imx8mm-pcie" , "reset-gpio" , "reset-gpio-active-high" }, |
249 | { "fsl,imx8mp-pcie" , "reset-gpio" , "reset-gpio-active-high" }, |
250 | #endif |
251 | |
252 | /* |
253 | * The regulator GPIO handles are specified such that the |
254 | * presence or absence of "enable-active-high" solely controls |
255 | * the polarity of the GPIO line. Any phandle flags must |
256 | * be actively ignored. |
257 | */ |
258 | #if IS_ENABLED(CONFIG_REGULATOR_FIXED_VOLTAGE) |
259 | { "regulator-fixed" , "gpios" , "enable-active-high" }, |
260 | { "regulator-fixed" , "gpio" , "enable-active-high" }, |
261 | { "reg-fixed-voltage" , "gpios" , "enable-active-high" }, |
262 | { "reg-fixed-voltage" , "gpio" , "enable-active-high" }, |
263 | #endif |
264 | #if IS_ENABLED(CONFIG_REGULATOR_GPIO) |
265 | { "regulator-gpio" , "enable-gpio" , "enable-active-high" }, |
266 | { "regulator-gpio" , "enable-gpios" , "enable-active-high" }, |
267 | #endif |
268 | #if IS_ENABLED(CONFIG_MMC_ATMELMCI) |
269 | { "atmel,hsmci" , "cd-gpios" , "cd-inverted" }, |
270 | #endif |
271 | }; |
272 | unsigned int i; |
273 | bool active_high; |
274 | |
275 | #if IS_ENABLED(CONFIG_MMC_ATMELMCI) |
276 | /* |
277 | * The Atmel HSMCI has compatible property in the parent node and |
278 | * gpio property in a child node |
279 | */ |
280 | if (of_device_is_compatible(np->parent, "atmel,hsmci" )) { |
281 | np_compat = np->parent; |
282 | np_propname = np; |
283 | } |
284 | #endif |
285 | |
286 | for (i = 0; i < ARRAY_SIZE(gpios); i++) { |
287 | if (of_device_is_compatible(device: np_compat, gpios[i].compatible) && |
288 | !strcmp(propname, gpios[i].gpio_propname)) { |
289 | active_high = of_property_read_bool(np: np_propname, |
290 | propname: gpios[i].polarity_propname); |
291 | of_gpio_quirk_polarity(np, active_high, flags); |
292 | break; |
293 | } |
294 | } |
295 | } |
296 | |
297 | static void of_gpio_flags_quirks(const struct device_node *np, |
298 | const char *propname, |
299 | enum of_gpio_flags *flags, |
300 | int index) |
301 | { |
302 | of_gpio_try_fixup_polarity(np, propname, flags); |
303 | of_gpio_set_polarity_by_property(np, propname, flags); |
304 | |
305 | /* |
306 | * Legacy open drain handling for fixed voltage regulators. |
307 | */ |
308 | if (IS_ENABLED(CONFIG_REGULATOR) && |
309 | of_device_is_compatible(device: np, "reg-fixed-voltage" ) && |
310 | of_property_read_bool(np, propname: "gpio-open-drain" )) { |
311 | *flags |= (OF_GPIO_SINGLE_ENDED | OF_GPIO_OPEN_DRAIN); |
312 | pr_info("%s uses legacy open drain flag - update the DTS if you can\n" , |
313 | of_node_full_name(np)); |
314 | } |
315 | |
316 | /* |
317 | * Legacy handling of SPI active high chip select. If we have a |
318 | * property named "cs-gpios" we need to inspect the child node |
319 | * to determine if the flags should have inverted semantics. |
320 | */ |
321 | if (IS_ENABLED(CONFIG_SPI_MASTER) && !strcmp(propname, "cs-gpios" ) && |
322 | of_property_read_bool(np, propname: "cs-gpios" )) { |
323 | struct device_node *child; |
324 | u32 cs; |
325 | int ret; |
326 | |
327 | for_each_child_of_node(np, child) { |
328 | ret = of_property_read_u32(np: child, propname: "reg" , out_value: &cs); |
329 | if (ret) |
330 | continue; |
331 | if (cs == index) { |
332 | /* |
333 | * SPI children have active low chip selects |
334 | * by default. This can be specified negatively |
335 | * by just omitting "spi-cs-high" in the |
336 | * device node, or actively by tagging on |
337 | * GPIO_ACTIVE_LOW as flag in the device |
338 | * tree. If the line is simultaneously |
339 | * tagged as active low in the device tree |
340 | * and has the "spi-cs-high" set, we get a |
341 | * conflict and the "spi-cs-high" flag will |
342 | * take precedence. |
343 | */ |
344 | bool active_high = of_property_read_bool(np: child, |
345 | propname: "spi-cs-high" ); |
346 | of_gpio_quirk_polarity(np: child, active_high, |
347 | flags); |
348 | of_node_put(node: child); |
349 | break; |
350 | } |
351 | } |
352 | } |
353 | |
354 | /* Legacy handling of stmmac's active-low PHY reset line */ |
355 | if (IS_ENABLED(CONFIG_STMMAC_ETH) && |
356 | !strcmp(propname, "snps,reset-gpio" ) && |
357 | of_property_read_bool(np, propname: "snps,reset-active-low" )) |
358 | *flags |= OF_GPIO_ACTIVE_LOW; |
359 | } |
360 | |
361 | /** |
362 | * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API |
363 | * @np: device node to get GPIO from |
364 | * @propname: property name containing gpio specifier(s) |
365 | * @index: index of the GPIO |
366 | * @flags: a flags pointer to fill in |
367 | * |
368 | * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno |
369 | * value on the error condition. If @flags is not NULL the function also fills |
370 | * in flags for the GPIO. |
371 | */ |
372 | static struct gpio_desc *of_get_named_gpiod_flags(const struct device_node *np, |
373 | const char *propname, int index, enum of_gpio_flags *flags) |
374 | { |
375 | struct of_phandle_args gpiospec; |
376 | struct gpio_desc *desc; |
377 | int ret; |
378 | |
379 | ret = of_parse_phandle_with_args_map(np, list_name: propname, stem_name: "gpio" , index, |
380 | out_args: &gpiospec); |
381 | if (ret) { |
382 | pr_debug("%s: can't parse '%s' property of node '%pOF[%d]'\n" , |
383 | __func__, propname, np, index); |
384 | return ERR_PTR(error: ret); |
385 | } |
386 | |
387 | struct gpio_device *gdev __free(gpio_device_put) = |
388 | of_find_gpio_device_by_xlate(gpiospec: &gpiospec); |
389 | if (!gdev) { |
390 | desc = ERR_PTR(error: -EPROBE_DEFER); |
391 | goto out; |
392 | } |
393 | |
394 | desc = of_xlate_and_get_gpiod_flags(chip: gpio_device_get_chip(gdev), |
395 | gpiospec: &gpiospec, flags); |
396 | if (IS_ERR(ptr: desc)) |
397 | goto out; |
398 | |
399 | if (flags) |
400 | of_gpio_flags_quirks(np, propname, flags, index); |
401 | |
402 | pr_debug("%s: parsed '%s' property of node '%pOF[%d]' - status (%d)\n" , |
403 | __func__, propname, np, index, |
404 | PTR_ERR_OR_ZERO(desc)); |
405 | |
406 | out: |
407 | of_node_put(node: gpiospec.np); |
408 | |
409 | return desc; |
410 | } |
411 | |
412 | /** |
413 | * of_get_named_gpio() - Get a GPIO number to use with GPIO API |
414 | * @np: device node to get GPIO from |
415 | * @propname: Name of property containing gpio specifier(s) |
416 | * @index: index of the GPIO |
417 | * |
418 | * **DEPRECATED** This function is deprecated and must not be used in new code. |
419 | * |
420 | * Returns GPIO number to use with Linux generic GPIO API, or one of the errno |
421 | * value on the error condition. |
422 | */ |
423 | int of_get_named_gpio(const struct device_node *np, const char *propname, |
424 | int index) |
425 | { |
426 | struct gpio_desc *desc; |
427 | |
428 | desc = of_get_named_gpiod_flags(np, propname, index, NULL); |
429 | |
430 | if (IS_ERR(ptr: desc)) |
431 | return PTR_ERR(ptr: desc); |
432 | else |
433 | return desc_to_gpio(desc); |
434 | } |
435 | EXPORT_SYMBOL_GPL(of_get_named_gpio); |
436 | |
437 | /* Converts gpio_lookup_flags into bitmask of GPIO_* values */ |
438 | static unsigned long of_convert_gpio_flags(enum of_gpio_flags flags) |
439 | { |
440 | unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT; |
441 | |
442 | if (flags & OF_GPIO_ACTIVE_LOW) |
443 | lflags |= GPIO_ACTIVE_LOW; |
444 | |
445 | if (flags & OF_GPIO_SINGLE_ENDED) { |
446 | if (flags & OF_GPIO_OPEN_DRAIN) |
447 | lflags |= GPIO_OPEN_DRAIN; |
448 | else |
449 | lflags |= GPIO_OPEN_SOURCE; |
450 | } |
451 | |
452 | if (flags & OF_GPIO_TRANSITORY) |
453 | lflags |= GPIO_TRANSITORY; |
454 | |
455 | if (flags & OF_GPIO_PULL_UP) |
456 | lflags |= GPIO_PULL_UP; |
457 | |
458 | if (flags & OF_GPIO_PULL_DOWN) |
459 | lflags |= GPIO_PULL_DOWN; |
460 | |
461 | if (flags & OF_GPIO_PULL_DISABLE) |
462 | lflags |= GPIO_PULL_DISABLE; |
463 | |
464 | return lflags; |
465 | } |
466 | |
467 | static struct gpio_desc *of_find_gpio_rename(struct device_node *np, |
468 | const char *con_id, |
469 | unsigned int idx, |
470 | enum of_gpio_flags *of_flags) |
471 | { |
472 | static const struct of_rename_gpio { |
473 | const char *con_id; |
474 | const char *legacy_id; /* NULL - same as con_id */ |
475 | /* |
476 | * Compatible string can be set to NULL in case where |
477 | * matching to a particular compatible is not practical, |
478 | * but it should only be done for gpio names that have |
479 | * vendor prefix to reduce risk of false positives. |
480 | * Addition of such entries is strongly discouraged. |
481 | */ |
482 | const char *compatible; |
483 | } gpios[] = { |
484 | #if IS_ENABLED(CONFIG_LCD_HX8357) |
485 | /* Himax LCD controllers used "gpios-reset" */ |
486 | { "reset" , "gpios-reset" , "himax,hx8357" }, |
487 | { "reset" , "gpios-reset" , "himax,hx8369" }, |
488 | #endif |
489 | #if IS_ENABLED(CONFIG_MFD_ARIZONA) |
490 | { "wlf,reset" , NULL, NULL }, |
491 | #endif |
492 | #if IS_ENABLED(CONFIG_RTC_DRV_MOXART) |
493 | { "rtc-data" , "gpio-rtc-data" , "moxa,moxart-rtc" }, |
494 | { "rtc-sclk" , "gpio-rtc-sclk" , "moxa,moxart-rtc" }, |
495 | { "rtc-reset" , "gpio-rtc-reset" , "moxa,moxart-rtc" }, |
496 | #endif |
497 | #if IS_ENABLED(CONFIG_NFC_MRVL_I2C) |
498 | { "reset" , "reset-n-io" , "marvell,nfc-i2c" }, |
499 | #endif |
500 | #if IS_ENABLED(CONFIG_NFC_MRVL_SPI) |
501 | { "reset" , "reset-n-io" , "marvell,nfc-spi" }, |
502 | #endif |
503 | #if IS_ENABLED(CONFIG_NFC_MRVL_UART) |
504 | { "reset" , "reset-n-io" , "marvell,nfc-uart" }, |
505 | { "reset" , "reset-n-io" , "mrvl,nfc-uart" }, |
506 | #endif |
507 | #if !IS_ENABLED(CONFIG_PCI_LANTIQ) |
508 | /* MIPS Lantiq PCI */ |
509 | { "reset" , "gpios-reset" , "lantiq,pci-xway" }, |
510 | #endif |
511 | |
512 | /* |
513 | * Some regulator bindings happened before we managed to |
514 | * establish that GPIO properties should be named |
515 | * "foo-gpios" so we have this special kludge for them. |
516 | */ |
517 | #if IS_ENABLED(CONFIG_REGULATOR_ARIZONA_LDO1) |
518 | { "wlf,ldoena" , NULL, NULL }, /* Arizona */ |
519 | #endif |
520 | #if IS_ENABLED(CONFIG_REGULATOR_WM8994) |
521 | { "wlf,ldo1ena" , NULL, NULL }, /* WM8994 */ |
522 | { "wlf,ldo2ena" , NULL, NULL }, /* WM8994 */ |
523 | #endif |
524 | |
525 | #if IS_ENABLED(CONFIG_SND_SOC_CS42L56) |
526 | { "reset" , "cirrus,gpio-nreset" , "cirrus,cs42l56" }, |
527 | #endif |
528 | #if IS_ENABLED(CONFIG_SND_SOC_MT2701_CS42448) |
529 | { "i2s1-in-sel-gpio1" , NULL, "mediatek,mt2701-cs42448-machine" }, |
530 | { "i2s1-in-sel-gpio2" , NULL, "mediatek,mt2701-cs42448-machine" }, |
531 | #endif |
532 | #if IS_ENABLED(CONFIG_SND_SOC_TLV320AIC3X) |
533 | { "reset" , "gpio-reset" , "ti,tlv320aic3x" }, |
534 | { "reset" , "gpio-reset" , "ti,tlv320aic33" }, |
535 | { "reset" , "gpio-reset" , "ti,tlv320aic3007" }, |
536 | { "reset" , "gpio-reset" , "ti,tlv320aic3104" }, |
537 | { "reset" , "gpio-reset" , "ti,tlv320aic3106" }, |
538 | #endif |
539 | #if IS_ENABLED(CONFIG_SPI_GPIO) |
540 | /* |
541 | * The SPI GPIO bindings happened before we managed to |
542 | * establish that GPIO properties should be named |
543 | * "foo-gpios" so we have this special kludge for them. |
544 | */ |
545 | { "miso" , "gpio-miso" , "spi-gpio" }, |
546 | { "mosi" , "gpio-mosi" , "spi-gpio" }, |
547 | { "sck" , "gpio-sck" , "spi-gpio" }, |
548 | #endif |
549 | |
550 | /* |
551 | * The old Freescale bindings use simply "gpios" as name |
552 | * for the chip select lines rather than "cs-gpios" like |
553 | * all other SPI hardware. Allow this specifically for |
554 | * Freescale and PPC devices. |
555 | */ |
556 | #if IS_ENABLED(CONFIG_SPI_FSL_SPI) |
557 | { "cs" , "gpios" , "fsl,spi" }, |
558 | { "cs" , "gpios" , "aeroflexgaisler,spictrl" }, |
559 | #endif |
560 | #if IS_ENABLED(CONFIG_SPI_PPC4xx) |
561 | { "cs" , "gpios" , "ibm,ppc4xx-spi" }, |
562 | #endif |
563 | |
564 | #if IS_ENABLED(CONFIG_TYPEC_FUSB302) |
565 | /* |
566 | * Fairchild FUSB302 host is using undocumented "fcs,int_n" |
567 | * property without the compulsory "-gpios" suffix. |
568 | */ |
569 | { "fcs,int_n" , NULL, "fcs,fusb302" }, |
570 | #endif |
571 | }; |
572 | struct gpio_desc *desc; |
573 | const char *legacy_id; |
574 | unsigned int i; |
575 | |
576 | if (!con_id) |
577 | return ERR_PTR(error: -ENOENT); |
578 | |
579 | for (i = 0; i < ARRAY_SIZE(gpios); i++) { |
580 | if (strcmp(con_id, gpios[i].con_id)) |
581 | continue; |
582 | |
583 | if (gpios[i].compatible && |
584 | !of_device_is_compatible(device: np, gpios[i].compatible)) |
585 | continue; |
586 | |
587 | legacy_id = gpios[i].legacy_id ?: gpios[i].con_id; |
588 | desc = of_get_named_gpiod_flags(np, propname: legacy_id, index: idx, flags: of_flags); |
589 | if (!gpiod_not_found(desc)) { |
590 | pr_info("%s uses legacy gpio name '%s' instead of '%s-gpios'\n" , |
591 | of_node_full_name(np), legacy_id, con_id); |
592 | return desc; |
593 | } |
594 | } |
595 | |
596 | return ERR_PTR(error: -ENOENT); |
597 | } |
598 | |
599 | static struct gpio_desc *of_find_mt2701_gpio(struct device_node *np, |
600 | const char *con_id, |
601 | unsigned int idx, |
602 | enum of_gpio_flags *of_flags) |
603 | { |
604 | struct gpio_desc *desc; |
605 | const char *legacy_id; |
606 | |
607 | if (!IS_ENABLED(CONFIG_SND_SOC_MT2701_CS42448)) |
608 | return ERR_PTR(error: -ENOENT); |
609 | |
610 | if (!of_device_is_compatible(device: np, "mediatek,mt2701-cs42448-machine" )) |
611 | return ERR_PTR(error: -ENOENT); |
612 | |
613 | if (!con_id || strcmp(con_id, "i2s1-in-sel" )) |
614 | return ERR_PTR(error: -ENOENT); |
615 | |
616 | if (idx == 0) |
617 | legacy_id = "i2s1-in-sel-gpio1" ; |
618 | else if (idx == 1) |
619 | legacy_id = "i2s1-in-sel-gpio2" ; |
620 | else |
621 | return ERR_PTR(error: -ENOENT); |
622 | |
623 | desc = of_get_named_gpiod_flags(np, propname: legacy_id, index: 0, flags: of_flags); |
624 | if (!gpiod_not_found(desc)) |
625 | pr_info("%s is using legacy gpio name '%s' instead of '%s-gpios'\n" , |
626 | of_node_full_name(np), legacy_id, con_id); |
627 | |
628 | return desc; |
629 | } |
630 | |
631 | /* |
632 | * Trigger sources are special, they allow us to use any GPIO as a LED trigger |
633 | * and have the name "trigger-sources" no matter which kind of phandle it is |
634 | * pointing to, whether to a GPIO, a USB host, a network PHY etc. So in this case |
635 | * we allow looking something up that is not named "foo-gpios". |
636 | */ |
637 | static struct gpio_desc *of_find_trigger_gpio(struct device_node *np, |
638 | const char *con_id, |
639 | unsigned int idx, |
640 | enum of_gpio_flags *of_flags) |
641 | { |
642 | struct gpio_desc *desc; |
643 | |
644 | if (!IS_ENABLED(CONFIG_LEDS_TRIGGER_GPIO)) |
645 | return ERR_PTR(error: -ENOENT); |
646 | |
647 | if (!con_id || strcmp(con_id, "trigger-sources" )) |
648 | return ERR_PTR(error: -ENOENT); |
649 | |
650 | desc = of_get_named_gpiod_flags(np, propname: con_id, index: idx, flags: of_flags); |
651 | if (!gpiod_not_found(desc)) |
652 | pr_debug("%s is used as a trigger\n" , of_node_full_name(np)); |
653 | |
654 | return desc; |
655 | } |
656 | |
657 | |
658 | typedef struct gpio_desc *(*of_find_gpio_quirk)(struct device_node *np, |
659 | const char *con_id, |
660 | unsigned int idx, |
661 | enum of_gpio_flags *of_flags); |
662 | static const of_find_gpio_quirk of_find_gpio_quirks[] = { |
663 | of_find_gpio_rename, |
664 | of_find_mt2701_gpio, |
665 | of_find_trigger_gpio, |
666 | NULL |
667 | }; |
668 | |
669 | struct gpio_desc *of_find_gpio(struct device_node *np, const char *con_id, |
670 | unsigned int idx, unsigned long *flags) |
671 | { |
672 | char prop_name[32]; /* 32 is max size of property name */ |
673 | enum of_gpio_flags of_flags; |
674 | const of_find_gpio_quirk *q; |
675 | struct gpio_desc *desc; |
676 | unsigned int i; |
677 | |
678 | /* Try GPIO property "foo-gpios" and "foo-gpio" */ |
679 | for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { |
680 | if (con_id) |
681 | snprintf(buf: prop_name, size: sizeof(prop_name), fmt: "%s-%s" , con_id, |
682 | gpio_suffixes[i]); |
683 | else |
684 | snprintf(buf: prop_name, size: sizeof(prop_name), fmt: "%s" , |
685 | gpio_suffixes[i]); |
686 | |
687 | desc = of_get_named_gpiod_flags(np, propname: prop_name, index: idx, flags: &of_flags); |
688 | |
689 | if (!gpiod_not_found(desc)) |
690 | break; |
691 | } |
692 | |
693 | /* Properly named GPIO was not found, try workarounds */ |
694 | for (q = of_find_gpio_quirks; gpiod_not_found(desc) && *q; q++) |
695 | desc = (*q)(np, con_id, idx, &of_flags); |
696 | |
697 | if (IS_ERR(ptr: desc)) |
698 | return desc; |
699 | |
700 | *flags = of_convert_gpio_flags(flags: of_flags); |
701 | |
702 | return desc; |
703 | } |
704 | |
705 | /** |
706 | * of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API |
707 | * @np: device node to get GPIO from |
708 | * @chip: GPIO chip whose hog is parsed |
709 | * @idx: Index of the GPIO to parse |
710 | * @name: GPIO line name |
711 | * @lflags: bitmask of gpio_lookup_flags GPIO_* values - returned from |
712 | * of_find_gpio() or of_parse_own_gpio() |
713 | * @dflags: gpiod_flags - optional GPIO initialization flags |
714 | * |
715 | * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno |
716 | * value on the error condition. |
717 | */ |
718 | static struct gpio_desc *of_parse_own_gpio(struct device_node *np, |
719 | struct gpio_chip *chip, |
720 | unsigned int idx, const char **name, |
721 | unsigned long *lflags, |
722 | enum gpiod_flags *dflags) |
723 | { |
724 | struct device_node *chip_np; |
725 | enum of_gpio_flags xlate_flags; |
726 | struct of_phandle_args gpiospec; |
727 | struct gpio_desc *desc; |
728 | unsigned int i; |
729 | u32 tmp; |
730 | int ret; |
731 | |
732 | chip_np = dev_of_node(dev: &chip->gpiodev->dev); |
733 | if (!chip_np) |
734 | return ERR_PTR(error: -EINVAL); |
735 | |
736 | xlate_flags = 0; |
737 | *lflags = GPIO_LOOKUP_FLAGS_DEFAULT; |
738 | *dflags = GPIOD_ASIS; |
739 | |
740 | ret = of_property_read_u32(np: chip_np, propname: "#gpio-cells" , out_value: &tmp); |
741 | if (ret) |
742 | return ERR_PTR(error: ret); |
743 | |
744 | gpiospec.np = chip_np; |
745 | gpiospec.args_count = tmp; |
746 | |
747 | for (i = 0; i < tmp; i++) { |
748 | ret = of_property_read_u32_index(np, propname: "gpios" , index: idx * tmp + i, |
749 | out_value: &gpiospec.args[i]); |
750 | if (ret) |
751 | return ERR_PTR(error: ret); |
752 | } |
753 | |
754 | desc = of_xlate_and_get_gpiod_flags(chip, gpiospec: &gpiospec, flags: &xlate_flags); |
755 | if (IS_ERR(ptr: desc)) |
756 | return desc; |
757 | |
758 | *lflags = of_convert_gpio_flags(flags: xlate_flags); |
759 | |
760 | if (of_property_read_bool(np, propname: "input" )) |
761 | *dflags |= GPIOD_IN; |
762 | else if (of_property_read_bool(np, propname: "output-low" )) |
763 | *dflags |= GPIOD_OUT_LOW; |
764 | else if (of_property_read_bool(np, propname: "output-high" )) |
765 | *dflags |= GPIOD_OUT_HIGH; |
766 | else { |
767 | pr_warn("GPIO line %d (%pOFn): no hogging state specified, bailing out\n" , |
768 | desc_to_gpio(desc), np); |
769 | return ERR_PTR(error: -EINVAL); |
770 | } |
771 | |
772 | if (name && of_property_read_string(np, propname: "line-name" , out_string: name)) |
773 | *name = np->name; |
774 | |
775 | return desc; |
776 | } |
777 | |
778 | /** |
779 | * of_gpiochip_add_hog - Add all hogs in a hog device node |
780 | * @chip: gpio chip to act on |
781 | * @hog: device node describing the hogs |
782 | * |
783 | * Returns error if it fails otherwise 0 on success. |
784 | */ |
785 | static int of_gpiochip_add_hog(struct gpio_chip *chip, struct device_node *hog) |
786 | { |
787 | enum gpiod_flags dflags; |
788 | struct gpio_desc *desc; |
789 | unsigned long lflags; |
790 | const char *name; |
791 | unsigned int i; |
792 | int ret; |
793 | |
794 | for (i = 0;; i++) { |
795 | desc = of_parse_own_gpio(np: hog, chip, idx: i, name: &name, lflags: &lflags, dflags: &dflags); |
796 | if (IS_ERR(ptr: desc)) |
797 | break; |
798 | |
799 | ret = gpiod_hog(desc, name, lflags, dflags); |
800 | if (ret < 0) |
801 | return ret; |
802 | |
803 | #ifdef CONFIG_OF_DYNAMIC |
804 | WRITE_ONCE(desc->hog, hog); |
805 | #endif |
806 | } |
807 | |
808 | return 0; |
809 | } |
810 | |
811 | /** |
812 | * of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions |
813 | * @chip: gpio chip to act on |
814 | * |
815 | * This is only used by of_gpiochip_add to request/set GPIO initial |
816 | * configuration. |
817 | * It returns error if it fails otherwise 0 on success. |
818 | */ |
819 | static int of_gpiochip_scan_gpios(struct gpio_chip *chip) |
820 | { |
821 | struct device_node *np; |
822 | int ret; |
823 | |
824 | for_each_available_child_of_node(dev_of_node(&chip->gpiodev->dev), np) { |
825 | if (!of_property_read_bool(np, propname: "gpio-hog" )) |
826 | continue; |
827 | |
828 | ret = of_gpiochip_add_hog(chip, hog: np); |
829 | if (ret < 0) { |
830 | of_node_put(node: np); |
831 | return ret; |
832 | } |
833 | |
834 | of_node_set_flag(n: np, OF_POPULATED); |
835 | } |
836 | |
837 | return 0; |
838 | } |
839 | |
840 | #ifdef CONFIG_OF_DYNAMIC |
841 | /** |
842 | * of_gpiochip_remove_hog - Remove all hogs in a hog device node |
843 | * @chip: gpio chip to act on |
844 | * @hog: device node describing the hogs |
845 | */ |
846 | static void of_gpiochip_remove_hog(struct gpio_chip *chip, |
847 | struct device_node *hog) |
848 | { |
849 | struct gpio_desc *desc; |
850 | |
851 | for_each_gpio_desc_with_flag(chip, desc, FLAG_IS_HOGGED) |
852 | if (READ_ONCE(desc->hog) == hog) |
853 | gpiochip_free_own_desc(desc); |
854 | } |
855 | |
856 | static int of_gpiochip_match_node(struct gpio_chip *chip, const void *data) |
857 | { |
858 | return device_match_of_node(dev: &chip->gpiodev->dev, np: data); |
859 | } |
860 | |
861 | static struct gpio_device *of_find_gpio_device_by_node(struct device_node *np) |
862 | { |
863 | return gpio_device_find(data: np, match: of_gpiochip_match_node); |
864 | } |
865 | |
866 | static int of_gpio_notify(struct notifier_block *nb, unsigned long action, |
867 | void *arg) |
868 | { |
869 | struct gpio_device *gdev __free(gpio_device_put) = NULL; |
870 | struct of_reconfig_data *rd = arg; |
871 | int ret; |
872 | |
873 | /* |
874 | * This only supports adding and removing complete gpio-hog nodes. |
875 | * Modifying an existing gpio-hog node is not supported (except for |
876 | * changing its "status" property, which is treated the same as |
877 | * addition/removal). |
878 | */ |
879 | switch (of_reconfig_get_state_change(action, arg)) { |
880 | case OF_RECONFIG_CHANGE_ADD: |
881 | if (!of_property_read_bool(np: rd->dn, propname: "gpio-hog" )) |
882 | return NOTIFY_DONE; /* not for us */ |
883 | |
884 | if (of_node_test_and_set_flag(n: rd->dn, OF_POPULATED)) |
885 | return NOTIFY_DONE; |
886 | |
887 | gdev = of_find_gpio_device_by_node(np: rd->dn->parent); |
888 | if (!gdev) |
889 | return NOTIFY_DONE; /* not for us */ |
890 | |
891 | ret = of_gpiochip_add_hog(chip: gpio_device_get_chip(gdev), hog: rd->dn); |
892 | if (ret < 0) { |
893 | pr_err("%s: failed to add hogs for %pOF\n" , __func__, |
894 | rd->dn); |
895 | of_node_clear_flag(n: rd->dn, OF_POPULATED); |
896 | return notifier_from_errno(err: ret); |
897 | } |
898 | return NOTIFY_OK; |
899 | |
900 | case OF_RECONFIG_CHANGE_REMOVE: |
901 | if (!of_node_check_flag(n: rd->dn, OF_POPULATED)) |
902 | return NOTIFY_DONE; /* already depopulated */ |
903 | |
904 | gdev = of_find_gpio_device_by_node(np: rd->dn->parent); |
905 | if (!gdev) |
906 | return NOTIFY_DONE; /* not for us */ |
907 | |
908 | of_gpiochip_remove_hog(chip: gpio_device_get_chip(gdev), hog: rd->dn); |
909 | of_node_clear_flag(n: rd->dn, OF_POPULATED); |
910 | return NOTIFY_OK; |
911 | } |
912 | |
913 | return NOTIFY_DONE; |
914 | } |
915 | |
916 | struct notifier_block gpio_of_notifier = { |
917 | .notifier_call = of_gpio_notify, |
918 | }; |
919 | #endif /* CONFIG_OF_DYNAMIC */ |
920 | |
921 | /** |
922 | * of_gpio_simple_xlate - translate gpiospec to the GPIO number and flags |
923 | * @gc: pointer to the gpio_chip structure |
924 | * @gpiospec: GPIO specifier as found in the device tree |
925 | * @flags: a flags pointer to fill in |
926 | * |
927 | * This is simple translation function, suitable for the most 1:1 mapped |
928 | * GPIO chips. This function performs only one sanity check: whether GPIO |
929 | * is less than ngpios (that is specified in the gpio_chip). |
930 | */ |
931 | static int of_gpio_simple_xlate(struct gpio_chip *gc, |
932 | const struct of_phandle_args *gpiospec, |
933 | u32 *flags) |
934 | { |
935 | /* |
936 | * We're discouraging gpio_cells < 2, since that way you'll have to |
937 | * write your own xlate function (that will have to retrieve the GPIO |
938 | * number and the flags from a single gpio cell -- this is possible, |
939 | * but not recommended). |
940 | */ |
941 | if (gc->of_gpio_n_cells < 2) { |
942 | WARN_ON(1); |
943 | return -EINVAL; |
944 | } |
945 | |
946 | if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells)) |
947 | return -EINVAL; |
948 | |
949 | if (gpiospec->args[0] >= gc->ngpio) |
950 | return -EINVAL; |
951 | |
952 | if (flags) |
953 | *flags = gpiospec->args[1]; |
954 | |
955 | return gpiospec->args[0]; |
956 | } |
957 | |
958 | #if IS_ENABLED(CONFIG_OF_GPIO_MM_GPIOCHIP) |
959 | #include <linux/gpio/legacy-of-mm-gpiochip.h> |
960 | /** |
961 | * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank) |
962 | * @np: device node of the GPIO chip |
963 | * @mm_gc: pointer to the of_mm_gpio_chip allocated structure |
964 | * @data: driver data to store in the struct gpio_chip |
965 | * |
966 | * To use this function you should allocate and fill mm_gc with: |
967 | * |
968 | * 1) In the gpio_chip structure: |
969 | * - all the callbacks |
970 | * - of_gpio_n_cells |
971 | * - of_xlate callback (optional) |
972 | * |
973 | * 3) In the of_mm_gpio_chip structure: |
974 | * - save_regs callback (optional) |
975 | * |
976 | * If succeeded, this function will map bank's memory and will |
977 | * do all necessary work for you. Then you'll able to use .regs |
978 | * to manage GPIOs from the callbacks. |
979 | */ |
980 | int of_mm_gpiochip_add_data(struct device_node *np, |
981 | struct of_mm_gpio_chip *mm_gc, |
982 | void *data) |
983 | { |
984 | int ret = -ENOMEM; |
985 | struct gpio_chip *gc = &mm_gc->gc; |
986 | |
987 | gc->label = kasprintf(GFP_KERNEL, fmt: "%pOF" , np); |
988 | if (!gc->label) |
989 | goto err0; |
990 | |
991 | mm_gc->regs = of_iomap(node: np, index: 0); |
992 | if (!mm_gc->regs) |
993 | goto err1; |
994 | |
995 | gc->base = -1; |
996 | |
997 | if (mm_gc->save_regs) |
998 | mm_gc->save_regs(mm_gc); |
999 | |
1000 | fwnode_handle_put(fwnode: mm_gc->gc.fwnode); |
1001 | mm_gc->gc.fwnode = fwnode_handle_get(of_fwnode_handle(np)); |
1002 | |
1003 | ret = gpiochip_add_data(gc, data); |
1004 | if (ret) |
1005 | goto err2; |
1006 | |
1007 | return 0; |
1008 | err2: |
1009 | of_node_put(node: np); |
1010 | iounmap(addr: mm_gc->regs); |
1011 | err1: |
1012 | kfree(objp: gc->label); |
1013 | err0: |
1014 | pr_err("%pOF: GPIO chip registration failed with status %d\n" , np, ret); |
1015 | return ret; |
1016 | } |
1017 | EXPORT_SYMBOL_GPL(of_mm_gpiochip_add_data); |
1018 | |
1019 | /** |
1020 | * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank) |
1021 | * @mm_gc: pointer to the of_mm_gpio_chip allocated structure |
1022 | */ |
1023 | void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc) |
1024 | { |
1025 | struct gpio_chip *gc = &mm_gc->gc; |
1026 | |
1027 | gpiochip_remove(gc); |
1028 | iounmap(addr: mm_gc->regs); |
1029 | kfree(objp: gc->label); |
1030 | } |
1031 | EXPORT_SYMBOL_GPL(of_mm_gpiochip_remove); |
1032 | #endif |
1033 | |
1034 | #ifdef CONFIG_PINCTRL |
1035 | static int of_gpiochip_add_pin_range(struct gpio_chip *chip) |
1036 | { |
1037 | struct of_phandle_args pinspec; |
1038 | struct pinctrl_dev *pctldev; |
1039 | struct device_node *np; |
1040 | int index = 0, ret; |
1041 | const char *name; |
1042 | static const char group_names_propname[] = "gpio-ranges-group-names" ; |
1043 | struct property *group_names; |
1044 | |
1045 | np = dev_of_node(dev: &chip->gpiodev->dev); |
1046 | if (!np) |
1047 | return 0; |
1048 | |
1049 | group_names = of_find_property(np, name: group_names_propname, NULL); |
1050 | |
1051 | for (;; index++) { |
1052 | ret = of_parse_phandle_with_fixed_args(np, list_name: "gpio-ranges" , cell_count: 3, |
1053 | index, out_args: &pinspec); |
1054 | if (ret) |
1055 | break; |
1056 | |
1057 | pctldev = of_pinctrl_get(np: pinspec.np); |
1058 | of_node_put(node: pinspec.np); |
1059 | if (!pctldev) |
1060 | return -EPROBE_DEFER; |
1061 | |
1062 | if (pinspec.args[2]) { |
1063 | if (group_names) { |
1064 | of_property_read_string_index(np, |
1065 | propname: group_names_propname, |
1066 | index, output: &name); |
1067 | if (strlen(name)) { |
1068 | pr_err("%pOF: Group name of numeric GPIO ranges must be the empty string.\n" , |
1069 | np); |
1070 | break; |
1071 | } |
1072 | } |
1073 | /* npins != 0: linear range */ |
1074 | ret = gpiochip_add_pin_range(gc: chip, |
1075 | pinctl_name: pinctrl_dev_get_devname(pctldev), |
1076 | gpio_offset: pinspec.args[0], |
1077 | pin_offset: pinspec.args[1], |
1078 | npins: pinspec.args[2]); |
1079 | if (ret) |
1080 | return ret; |
1081 | } else { |
1082 | /* npins == 0: special range */ |
1083 | if (pinspec.args[1]) { |
1084 | pr_err("%pOF: Illegal gpio-range format.\n" , |
1085 | np); |
1086 | break; |
1087 | } |
1088 | |
1089 | if (!group_names) { |
1090 | pr_err("%pOF: GPIO group range requested but no %s property.\n" , |
1091 | np, group_names_propname); |
1092 | break; |
1093 | } |
1094 | |
1095 | ret = of_property_read_string_index(np, |
1096 | propname: group_names_propname, |
1097 | index, output: &name); |
1098 | if (ret) |
1099 | break; |
1100 | |
1101 | if (!strlen(name)) { |
1102 | pr_err("%pOF: Group name of GPIO group range cannot be the empty string.\n" , |
1103 | np); |
1104 | break; |
1105 | } |
1106 | |
1107 | ret = gpiochip_add_pingroup_range(gc: chip, pctldev, |
1108 | gpio_offset: pinspec.args[0], pin_group: name); |
1109 | if (ret) |
1110 | return ret; |
1111 | } |
1112 | } |
1113 | |
1114 | return 0; |
1115 | } |
1116 | |
1117 | #else |
1118 | static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; } |
1119 | #endif |
1120 | |
1121 | int of_gpiochip_add(struct gpio_chip *chip) |
1122 | { |
1123 | struct device_node *np; |
1124 | int ret; |
1125 | |
1126 | np = dev_of_node(dev: &chip->gpiodev->dev); |
1127 | if (!np) |
1128 | return 0; |
1129 | |
1130 | if (!chip->of_xlate) { |
1131 | chip->of_gpio_n_cells = 2; |
1132 | chip->of_xlate = of_gpio_simple_xlate; |
1133 | } |
1134 | |
1135 | if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS) |
1136 | return -EINVAL; |
1137 | |
1138 | ret = of_gpiochip_add_pin_range(chip); |
1139 | if (ret) |
1140 | return ret; |
1141 | |
1142 | of_node_get(node: np); |
1143 | |
1144 | ret = of_gpiochip_scan_gpios(chip); |
1145 | if (ret) |
1146 | of_node_put(node: np); |
1147 | |
1148 | return ret; |
1149 | } |
1150 | |
1151 | void of_gpiochip_remove(struct gpio_chip *chip) |
1152 | { |
1153 | of_node_put(node: dev_of_node(dev: &chip->gpiodev->dev)); |
1154 | } |
1155 | |