1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2015 Masahiro Yamada <yamada.masahiro@socionext.com> 4 */ 5 6 #include <common.h> 7 #include <linux/libfdt.h> 8 #include <linux/err.h> 9 #include <linux/list.h> 10 #include <dm.h> 11 #include <dm/lists.h> 12 #include <dm/pinctrl.h> 13 #include <dm/util.h> 14 #include <dm/of_access.h> 15 16 DECLARE_GLOBAL_DATA_PTR; 17 18 int pinctrl_decode_pin_config(const void *blob, int node) 19 { 20 int flags = 0; 21 22 if (fdtdec_get_bool(blob, node, "bias-pull-up")) 23 flags |= 1 << PIN_CONFIG_BIAS_PULL_UP; 24 else if (fdtdec_get_bool(blob, node, "bias-pull-down")) 25 flags |= 1 << PIN_CONFIG_BIAS_PULL_DOWN; 26 27 return flags; 28 } 29 30 #if CONFIG_IS_ENABLED(PINCTRL_FULL) 31 /** 32 * pinctrl_config_one() - apply pinctrl settings for a single node 33 * 34 * @config: pin configuration node 35 * @return: 0 on success, or negative error code on failure 36 */ 37 static int pinctrl_config_one(struct udevice *config) 38 { 39 struct udevice *pctldev; 40 const struct pinctrl_ops *ops; 41 42 pctldev = config; 43 for (;;) { 44 pctldev = dev_get_parent(pctldev); 45 if (!pctldev) { 46 dev_err(config, "could not find pctldev\n"); 47 return -EINVAL; 48 } 49 if (pctldev->uclass->uc_drv->id == UCLASS_PINCTRL) 50 break; 51 } 52 53 ops = pinctrl_get_ops(pctldev); 54 return ops->set_state(pctldev, config); 55 } 56 57 /** 58 * pinctrl_select_state_full() - full implementation of pinctrl_select_state 59 * 60 * @dev: peripheral device 61 * @statename: state name, like "default" 62 * @return: 0 on success, or negative error code on failure 63 */ 64 static int pinctrl_select_state_full(struct udevice *dev, const char *statename) 65 { 66 char propname[32]; /* long enough */ 67 const fdt32_t *list; 68 uint32_t phandle; 69 struct udevice *config; 70 int state, size, i, ret; 71 72 state = dev_read_stringlist_search(dev, "pinctrl-names", statename); 73 if (state < 0) { 74 char *end; 75 /* 76 * If statename is not found in "pinctrl-names", 77 * assume statename is just the integer state ID. 78 */ 79 state = simple_strtoul(statename, &end, 10); 80 if (*end) 81 return -EINVAL; 82 } 83 84 snprintf(propname, sizeof(propname), "pinctrl-%d", state); 85 list = dev_read_prop(dev, propname, &size); 86 if (!list) 87 return -EINVAL; 88 89 size /= sizeof(*list); 90 for (i = 0; i < size; i++) { 91 phandle = fdt32_to_cpu(*list++); 92 ret = uclass_get_device_by_phandle_id(UCLASS_PINCONFIG, phandle, 93 &config); 94 if (ret) 95 return ret; 96 97 ret = pinctrl_config_one(config); 98 if (ret) 99 return ret; 100 } 101 102 return 0; 103 } 104 105 /** 106 * pinconfig_post_bind() - post binding for PINCONFIG uclass 107 * Recursively bind its children as pinconfig devices. 108 * 109 * @dev: pinconfig device 110 * @return: 0 on success, or negative error code on failure 111 */ 112 static int pinconfig_post_bind(struct udevice *dev) 113 { 114 bool pre_reloc_only = !(gd->flags & GD_FLG_RELOC); 115 const char *name; 116 ofnode node; 117 int ret; 118 119 dev_for_each_subnode(node, dev) { 120 if (pre_reloc_only && 121 !ofnode_pre_reloc(node)) 122 continue; 123 /* 124 * If this node has "compatible" property, this is not 125 * a pin configuration node, but a normal device. skip. 126 */ 127 ofnode_get_property(node, "compatible", &ret); 128 if (ret >= 0) 129 continue; 130 131 if (ret != -FDT_ERR_NOTFOUND) 132 return ret; 133 134 name = ofnode_get_name(node); 135 if (!name) 136 return -EINVAL; 137 ret = device_bind_driver_to_node(dev, "pinconfig", name, 138 node, NULL); 139 if (ret) 140 return ret; 141 } 142 143 return 0; 144 } 145 146 UCLASS_DRIVER(pinconfig) = { 147 .id = UCLASS_PINCONFIG, 148 .post_bind = pinconfig_post_bind, 149 .name = "pinconfig", 150 }; 151 152 U_BOOT_DRIVER(pinconfig_generic) = { 153 .name = "pinconfig", 154 .id = UCLASS_PINCONFIG, 155 }; 156 157 #else 158 static int pinctrl_select_state_full(struct udevice *dev, const char *statename) 159 { 160 return -ENODEV; 161 } 162 163 static int pinconfig_post_bind(struct udevice *dev) 164 { 165 return 0; 166 } 167 #endif 168 169 /** 170 * pinctrl_select_state_simple() - simple implementation of pinctrl_select_state 171 * 172 * @dev: peripheral device 173 * @return: 0 on success, or negative error code on failure 174 */ 175 static int pinctrl_select_state_simple(struct udevice *dev) 176 { 177 struct udevice *pctldev; 178 struct pinctrl_ops *ops; 179 int ret; 180 181 /* 182 * For simplicity, assume the first device of PINCTRL uclass 183 * is the correct one. This is most likely OK as there is 184 * usually only one pinctrl device on the system. 185 */ 186 ret = uclass_get_device(UCLASS_PINCTRL, 0, &pctldev); 187 if (ret) 188 return ret; 189 190 ops = pinctrl_get_ops(pctldev); 191 if (!ops->set_state_simple) { 192 dev_dbg(dev, "set_state_simple op missing\n"); 193 return -ENOSYS; 194 } 195 196 return ops->set_state_simple(pctldev, dev); 197 } 198 199 int pinctrl_select_state(struct udevice *dev, const char *statename) 200 { 201 /* 202 * Try full-implemented pinctrl first. 203 * If it fails or is not implemented, try simple one. 204 */ 205 if (pinctrl_select_state_full(dev, statename)) 206 return pinctrl_select_state_simple(dev); 207 208 return 0; 209 } 210 211 int pinctrl_request(struct udevice *dev, int func, int flags) 212 { 213 struct pinctrl_ops *ops = pinctrl_get_ops(dev); 214 215 if (!ops->request) 216 return -ENOSYS; 217 218 return ops->request(dev, func, flags); 219 } 220 221 int pinctrl_request_noflags(struct udevice *dev, int func) 222 { 223 return pinctrl_request(dev, func, 0); 224 } 225 226 int pinctrl_get_periph_id(struct udevice *dev, struct udevice *periph) 227 { 228 struct pinctrl_ops *ops = pinctrl_get_ops(dev); 229 230 if (!ops->get_periph_id) 231 return -ENOSYS; 232 233 return ops->get_periph_id(dev, periph); 234 } 235 236 int pinctrl_get_gpio_mux(struct udevice *dev, int banknum, int index) 237 { 238 struct pinctrl_ops *ops = pinctrl_get_ops(dev); 239 240 if (!ops->get_gpio_mux) 241 return -ENOSYS; 242 243 return ops->get_gpio_mux(dev, banknum, index); 244 } 245 246 /** 247 * pinconfig_post_bind() - post binding for PINCTRL uclass 248 * Recursively bind child nodes as pinconfig devices in case of full pinctrl. 249 * 250 * @dev: pinctrl device 251 * @return: 0 on success, or negative error code on failure 252 */ 253 static int pinctrl_post_bind(struct udevice *dev) 254 { 255 const struct pinctrl_ops *ops = pinctrl_get_ops(dev); 256 257 if (!ops) { 258 dev_dbg(dev, "ops is not set. Do not bind.\n"); 259 return -EINVAL; 260 } 261 262 /* 263 * If set_state callback is set, we assume this pinctrl driver is the 264 * full implementation. In this case, its child nodes should be bound 265 * so that peripheral devices can easily search in parent devices 266 * during later DT-parsing. 267 */ 268 if (ops->set_state) 269 return pinconfig_post_bind(dev); 270 271 return 0; 272 } 273 274 UCLASS_DRIVER(pinctrl) = { 275 .id = UCLASS_PINCTRL, 276 .post_bind = pinctrl_post_bind, 277 .flags = DM_UC_FLAG_SEQ_ALIAS, 278 .name = "pinctrl", 279 }; 280