1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Software Node helpers for the GPIO API 4 * 5 * Copyright 2022 Google LLC 6 */ 7 8 #define pr_fmt(fmt) "gpiolib: swnode: " fmt 9 10 #include <linux/err.h> 11 #include <linux/errno.h> 12 #include <linux/export.h> 13 #include <linux/init.h> 14 #include <linux/kernel.h> 15 #include <linux/printk.h> 16 #include <linux/property.h> 17 #include <linux/string.h> 18 19 #include <linux/gpio/consumer.h> 20 #include <linux/gpio/driver.h> 21 22 #include "gpiolib.h" 23 #include "gpiolib-swnode.h" 24 25 #define GPIOLIB_SWNODE_UNDEFINED_NAME "swnode-gpio-undefined" 26 27 static struct gpio_device *swnode_get_gpio_device(struct fwnode_handle *fwnode) 28 { 29 const struct software_node *gdev_node; 30 struct gpio_device *gdev; 31 32 gdev_node = to_software_node(fwnode); 33 if (!gdev_node || !gdev_node->name) 34 return ERR_PTR(-EINVAL); 35 36 /* 37 * Check for a special node that identifies undefined GPIOs, this is 38 * primarily used as a key for internal chip selects in SPI bindings. 39 */ 40 if (IS_ENABLED(CONFIG_GPIO_SWNODE_UNDEFINED) && 41 !strcmp(gdev_node->name, GPIOLIB_SWNODE_UNDEFINED_NAME)) 42 return ERR_PTR(-ENOENT); 43 44 gdev = gpio_device_find_by_label(gdev_node->name); 45 return gdev ?: ERR_PTR(-EPROBE_DEFER); 46 } 47 48 static int swnode_gpio_get_reference(const struct fwnode_handle *fwnode, 49 const char *propname, unsigned int idx, 50 struct fwnode_reference_args *args) 51 { 52 /* 53 * We expect all swnode-described GPIOs have GPIO number and 54 * polarity arguments, hence nargs is set to 2. 55 */ 56 return fwnode_property_get_reference_args(fwnode, propname, NULL, 2, idx, args); 57 } 58 59 struct gpio_desc *swnode_find_gpio(struct fwnode_handle *fwnode, 60 const char *con_id, unsigned int idx, 61 unsigned long *flags) 62 { 63 const struct software_node *swnode; 64 struct fwnode_reference_args args; 65 struct gpio_desc *desc; 66 char propname[32]; /* 32 is max size of property name */ 67 int ret; 68 69 swnode = to_software_node(fwnode); 70 if (!swnode) 71 return ERR_PTR(-EINVAL); 72 73 for_each_gpio_property_name(propname, con_id) { 74 ret = swnode_gpio_get_reference(fwnode, propname, idx, &args); 75 if (ret == 0) 76 break; 77 } 78 if (ret) { 79 pr_debug("%s: can't parse '%s' property of node '%pfwP[%d]'\n", 80 __func__, propname, fwnode, idx); 81 return ERR_PTR(ret); 82 } 83 84 struct gpio_device *gdev __free(gpio_device_put) = 85 swnode_get_gpio_device(args.fwnode); 86 fwnode_handle_put(args.fwnode); 87 if (IS_ERR(gdev)) 88 return ERR_CAST(gdev); 89 90 /* 91 * FIXME: The GPIO device reference is put at return but the descriptor 92 * is passed on. Find a proper solution. 93 */ 94 desc = gpio_device_get_desc(gdev, args.args[0]); 95 *flags = args.args[1]; /* We expect native GPIO flags */ 96 97 pr_debug("%s: parsed '%s' property of node '%pfwP[%d]' - status (%d)\n", 98 __func__, propname, fwnode, idx, PTR_ERR_OR_ZERO(desc)); 99 100 return desc; 101 } 102 103 /** 104 * swnode_gpio_count - count the GPIOs associated with a device / function 105 * @fwnode: firmware node of the GPIO consumer, can be %NULL for 106 * system-global GPIOs 107 * @con_id: function within the GPIO consumer 108 * 109 * Returns: 110 * The number of GPIOs associated with a device / function or %-ENOENT, 111 * if no GPIO has been assigned to the requested function. 112 */ 113 int swnode_gpio_count(const struct fwnode_handle *fwnode, const char *con_id) 114 { 115 struct fwnode_reference_args args; 116 char propname[32]; 117 int count; 118 119 /* 120 * This is not very efficient, but GPIO lists usually have only 121 * 1 or 2 entries. 122 */ 123 for_each_gpio_property_name(propname, con_id) { 124 count = 0; 125 while (swnode_gpio_get_reference(fwnode, propname, count, &args) == 0) { 126 fwnode_handle_put(args.fwnode); 127 count++; 128 } 129 if (count) 130 return count; 131 } 132 133 return -ENOENT; 134 } 135 136 #if IS_ENABLED(CONFIG_GPIO_SWNODE_UNDEFINED) 137 /* 138 * A special node that identifies undefined GPIOs, this is primarily used as 139 * a key for internal chip selects in SPI bindings. 140 */ 141 const struct software_node swnode_gpio_undefined = { 142 .name = GPIOLIB_SWNODE_UNDEFINED_NAME, 143 }; 144 EXPORT_SYMBOL_NS_GPL(swnode_gpio_undefined, GPIO_SWNODE); 145 146 static int __init swnode_gpio_init(void) 147 { 148 int ret; 149 150 ret = software_node_register(&swnode_gpio_undefined); 151 if (ret < 0) 152 pr_err("failed to register swnode: %d\n", ret); 153 154 return ret; 155 } 156 subsys_initcall(swnode_gpio_init); 157 158 static void __exit swnode_gpio_cleanup(void) 159 { 160 software_node_unregister(&swnode_gpio_undefined); 161 } 162 __exitcall(swnode_gpio_cleanup); 163 #endif 164