1 /* 2 * Copyright (c) 2013 Google, Inc 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <common.h> 8 #include <dm.h> 9 #include <errno.h> 10 #include <fdtdec.h> 11 #include <malloc.h> 12 #include <asm/gpio.h> 13 #include <linux/ctype.h> 14 15 /** 16 * gpio_to_device() - Convert global GPIO number to device, number 17 * 18 * Convert the GPIO number to an entry in the list of GPIOs 19 * or GPIO blocks registered with the GPIO controller. Returns 20 * entry on success, NULL on error. 21 * 22 * @gpio: The numeric representation of the GPIO 23 * @desc: Returns description (desc->flags will always be 0) 24 * @return 0 if found, -ENOENT if not found 25 */ 26 static int gpio_to_device(unsigned int gpio, struct gpio_desc *desc) 27 { 28 struct gpio_dev_priv *uc_priv; 29 struct udevice *dev; 30 int ret; 31 32 for (ret = uclass_first_device(UCLASS_GPIO, &dev); 33 dev; 34 ret = uclass_next_device(&dev)) { 35 uc_priv = dev->uclass_priv; 36 if (gpio >= uc_priv->gpio_base && 37 gpio < uc_priv->gpio_base + uc_priv->gpio_count) { 38 desc->dev = dev; 39 desc->offset = gpio - uc_priv->gpio_base; 40 desc->flags = 0; 41 return 0; 42 } 43 } 44 45 /* No such GPIO */ 46 return ret ? ret : -ENOENT; 47 } 48 49 int gpio_lookup_name(const char *name, struct udevice **devp, 50 unsigned int *offsetp, unsigned int *gpiop) 51 { 52 struct gpio_dev_priv *uc_priv = NULL; 53 struct udevice *dev; 54 ulong offset; 55 int numeric; 56 int ret; 57 58 if (devp) 59 *devp = NULL; 60 numeric = isdigit(*name) ? simple_strtoul(name, NULL, 10) : -1; 61 for (ret = uclass_first_device(UCLASS_GPIO, &dev); 62 dev; 63 ret = uclass_next_device(&dev)) { 64 int len; 65 66 uc_priv = dev->uclass_priv; 67 if (numeric != -1) { 68 offset = numeric - uc_priv->gpio_base; 69 /* Allow GPIOs to be numbered from 0 */ 70 if (offset >= 0 && offset < uc_priv->gpio_count) 71 break; 72 } 73 74 len = uc_priv->bank_name ? strlen(uc_priv->bank_name) : 0; 75 76 if (!strncasecmp(name, uc_priv->bank_name, len)) { 77 if (!strict_strtoul(name + len, 10, &offset)) 78 break; 79 } 80 } 81 82 if (!dev) 83 return ret ? ret : -EINVAL; 84 85 if (devp) 86 *devp = dev; 87 if (offsetp) 88 *offsetp = offset; 89 if (gpiop) 90 *gpiop = uc_priv->gpio_base + offset; 91 92 return 0; 93 } 94 95 int gpio_find_and_xlate(struct gpio_desc *desc, 96 struct fdtdec_phandle_args *args) 97 { 98 struct dm_gpio_ops *ops = gpio_get_ops(desc->dev); 99 100 /* Use the first argument as the offset by default */ 101 if (args->args_count > 0) 102 desc->offset = args->args[0]; 103 else 104 desc->offset = -1; 105 desc->flags = 0; 106 107 return ops->xlate ? ops->xlate(desc->dev, desc, args) : 0; 108 } 109 110 static int dm_gpio_request(struct gpio_desc *desc, const char *label) 111 { 112 struct udevice *dev = desc->dev; 113 struct gpio_dev_priv *uc_priv; 114 char *str; 115 int ret; 116 117 uc_priv = dev->uclass_priv; 118 if (uc_priv->name[desc->offset]) 119 return -EBUSY; 120 str = strdup(label); 121 if (!str) 122 return -ENOMEM; 123 if (gpio_get_ops(dev)->request) { 124 ret = gpio_get_ops(dev)->request(dev, desc->offset, label); 125 if (ret) { 126 free(str); 127 return ret; 128 } 129 } 130 uc_priv->name[desc->offset] = str; 131 132 return 0; 133 } 134 135 /** 136 * gpio_request() - [COMPAT] Request GPIO 137 * gpio: GPIO number 138 * label: Name for the requested GPIO 139 * 140 * The label is copied and allocated so the caller does not need to keep 141 * the pointer around. 142 * 143 * This function implements the API that's compatible with current 144 * GPIO API used in U-Boot. The request is forwarded to particular 145 * GPIO driver. Returns 0 on success, negative value on error. 146 */ 147 int gpio_request(unsigned gpio, const char *label) 148 { 149 struct gpio_desc desc; 150 int ret; 151 152 ret = gpio_to_device(gpio, &desc); 153 if (ret) 154 return ret; 155 156 return dm_gpio_request(&desc, label); 157 } 158 159 /** 160 * gpio_requestf() - [COMPAT] Request GPIO 161 * @gpio: GPIO number 162 * @fmt: Format string for the requested GPIO 163 * @...: Arguments for the printf() format string 164 * 165 * This function implements the API that's compatible with current 166 * GPIO API used in U-Boot. The request is forwarded to particular 167 * GPIO driver. Returns 0 on success, negative value on error. 168 */ 169 int gpio_requestf(unsigned gpio, const char *fmt, ...) 170 { 171 va_list args; 172 char buf[40]; 173 174 va_start(args, fmt); 175 vscnprintf(buf, sizeof(buf), fmt, args); 176 va_end(args); 177 return gpio_request(gpio, buf); 178 } 179 180 int _dm_gpio_free(struct udevice *dev, uint offset) 181 { 182 struct gpio_dev_priv *uc_priv; 183 int ret; 184 185 uc_priv = dev->uclass_priv; 186 if (!uc_priv->name[offset]) 187 return -ENXIO; 188 if (gpio_get_ops(dev)->free) { 189 ret = gpio_get_ops(dev)->free(dev, offset); 190 if (ret) 191 return ret; 192 } 193 194 free(uc_priv->name[offset]); 195 uc_priv->name[offset] = NULL; 196 197 return 0; 198 } 199 200 /** 201 * gpio_free() - [COMPAT] Relinquish GPIO 202 * gpio: GPIO number 203 * 204 * This function implements the API that's compatible with current 205 * GPIO API used in U-Boot. The request is forwarded to particular 206 * GPIO driver. Returns 0 on success, negative value on error. 207 */ 208 int gpio_free(unsigned gpio) 209 { 210 struct gpio_desc desc; 211 int ret; 212 213 ret = gpio_to_device(gpio, &desc); 214 if (ret) 215 return ret; 216 217 return _dm_gpio_free(desc.dev, desc.offset); 218 } 219 220 static int check_reserved(struct gpio_desc *desc, const char *func) 221 { 222 struct gpio_dev_priv *uc_priv = desc->dev->uclass_priv; 223 224 if (!uc_priv->name[desc->offset]) { 225 printf("%s: %s: error: gpio %s%d not reserved\n", 226 desc->dev->name, func, 227 uc_priv->bank_name ? uc_priv->bank_name : "", 228 desc->offset); 229 return -EBUSY; 230 } 231 232 return 0; 233 } 234 235 /** 236 * gpio_direction_input() - [COMPAT] Set GPIO direction to input 237 * gpio: GPIO number 238 * 239 * This function implements the API that's compatible with current 240 * GPIO API used in U-Boot. The request is forwarded to particular 241 * GPIO driver. Returns 0 on success, negative value on error. 242 */ 243 int gpio_direction_input(unsigned gpio) 244 { 245 struct gpio_desc desc; 246 int ret; 247 248 ret = gpio_to_device(gpio, &desc); 249 if (ret) 250 return ret; 251 ret = check_reserved(&desc, "dir_input"); 252 if (ret) 253 return ret; 254 255 return gpio_get_ops(desc.dev)->direction_input(desc.dev, desc.offset); 256 } 257 258 /** 259 * gpio_direction_output() - [COMPAT] Set GPIO direction to output and set value 260 * gpio: GPIO number 261 * value: Logical value to be set on the GPIO pin 262 * 263 * This function implements the API that's compatible with current 264 * GPIO API used in U-Boot. The request is forwarded to particular 265 * GPIO driver. Returns 0 on success, negative value on error. 266 */ 267 int gpio_direction_output(unsigned gpio, int value) 268 { 269 struct gpio_desc desc; 270 int ret; 271 272 ret = gpio_to_device(gpio, &desc); 273 if (ret) 274 return ret; 275 ret = check_reserved(&desc, "dir_output"); 276 if (ret) 277 return ret; 278 279 return gpio_get_ops(desc.dev)->direction_output(desc.dev, 280 desc.offset, value); 281 } 282 283 int dm_gpio_get_value(struct gpio_desc *desc) 284 { 285 int value; 286 int ret; 287 288 ret = check_reserved(desc, "get_value"); 289 if (ret) 290 return ret; 291 292 value = gpio_get_ops(desc->dev)->get_value(desc->dev, desc->offset); 293 294 return desc->flags & GPIOD_ACTIVE_LOW ? !value : value; 295 } 296 297 int dm_gpio_set_value(struct gpio_desc *desc, int value) 298 { 299 int ret; 300 301 ret = check_reserved(desc, "set_value"); 302 if (ret) 303 return ret; 304 305 if (desc->flags & GPIOD_ACTIVE_LOW) 306 value = !value; 307 gpio_get_ops(desc->dev)->set_value(desc->dev, desc->offset, value); 308 return 0; 309 } 310 311 int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags) 312 { 313 struct udevice *dev = desc->dev; 314 struct dm_gpio_ops *ops = gpio_get_ops(dev); 315 int ret; 316 317 ret = check_reserved(desc, "set_dir"); 318 if (ret) 319 return ret; 320 321 if (flags & GPIOD_IS_OUT) { 322 int value = flags & GPIOD_IS_OUT_ACTIVE ? 1 : 0; 323 324 if (flags & GPIOD_ACTIVE_LOW) 325 value = !value; 326 ret = ops->direction_output(dev, desc->offset, value); 327 } else if (flags & GPIOD_IS_IN) { 328 ret = ops->direction_input(dev, desc->offset); 329 } 330 if (ret) 331 return ret; 332 /* 333 * Update desc->flags here, so that GPIO_ACTIVE_LOW is honoured in 334 * futures 335 */ 336 desc->flags = flags; 337 338 return 0; 339 } 340 341 int dm_gpio_set_dir(struct gpio_desc *desc) 342 { 343 return dm_gpio_set_dir_flags(desc, desc->flags); 344 } 345 346 /** 347 * gpio_get_value() - [COMPAT] Sample GPIO pin and return it's value 348 * gpio: GPIO number 349 * 350 * This function implements the API that's compatible with current 351 * GPIO API used in U-Boot. The request is forwarded to particular 352 * GPIO driver. Returns the value of the GPIO pin, or negative value 353 * on error. 354 */ 355 int gpio_get_value(unsigned gpio) 356 { 357 int ret; 358 359 struct gpio_desc desc; 360 361 ret = gpio_to_device(gpio, &desc); 362 if (ret) 363 return ret; 364 return dm_gpio_get_value(&desc); 365 } 366 367 /** 368 * gpio_set_value() - [COMPAT] Configure logical value on GPIO pin 369 * gpio: GPIO number 370 * value: Logical value to be set on the GPIO pin. 371 * 372 * This function implements the API that's compatible with current 373 * GPIO API used in U-Boot. The request is forwarded to particular 374 * GPIO driver. Returns 0 on success, negative value on error. 375 */ 376 int gpio_set_value(unsigned gpio, int value) 377 { 378 struct gpio_desc desc; 379 int ret; 380 381 ret = gpio_to_device(gpio, &desc); 382 if (ret) 383 return ret; 384 return dm_gpio_set_value(&desc, value); 385 } 386 387 const char *gpio_get_bank_info(struct udevice *dev, int *bit_count) 388 { 389 struct gpio_dev_priv *priv; 390 391 /* Must be called on an active device */ 392 priv = dev->uclass_priv; 393 assert(priv); 394 395 *bit_count = priv->gpio_count; 396 return priv->bank_name; 397 } 398 399 static const char * const gpio_function[GPIOF_COUNT] = { 400 "input", 401 "output", 402 "unused", 403 "unknown", 404 "func", 405 }; 406 407 int get_function(struct udevice *dev, int offset, bool skip_unused, 408 const char **namep) 409 { 410 struct gpio_dev_priv *uc_priv = dev->uclass_priv; 411 struct dm_gpio_ops *ops = gpio_get_ops(dev); 412 413 BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function)); 414 if (!device_active(dev)) 415 return -ENODEV; 416 if (offset < 0 || offset >= uc_priv->gpio_count) 417 return -EINVAL; 418 if (namep) 419 *namep = uc_priv->name[offset]; 420 if (skip_unused && !uc_priv->name[offset]) 421 return GPIOF_UNUSED; 422 if (ops->get_function) { 423 int ret; 424 425 ret = ops->get_function(dev, offset); 426 if (ret < 0) 427 return ret; 428 if (ret >= ARRAY_SIZE(gpio_function)) 429 return -ENODATA; 430 return ret; 431 } 432 433 return GPIOF_UNKNOWN; 434 } 435 436 int gpio_get_function(struct udevice *dev, int offset, const char **namep) 437 { 438 return get_function(dev, offset, true, namep); 439 } 440 441 int gpio_get_raw_function(struct udevice *dev, int offset, const char **namep) 442 { 443 return get_function(dev, offset, false, namep); 444 } 445 446 int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize) 447 { 448 struct dm_gpio_ops *ops = gpio_get_ops(dev); 449 struct gpio_dev_priv *priv; 450 char *str = buf; 451 int func; 452 int ret; 453 int len; 454 455 BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function)); 456 457 *buf = 0; 458 priv = dev->uclass_priv; 459 ret = gpio_get_raw_function(dev, offset, NULL); 460 if (ret < 0) 461 return ret; 462 func = ret; 463 len = snprintf(str, buffsize, "%s%d: %s", 464 priv->bank_name ? priv->bank_name : "", 465 offset, gpio_function[func]); 466 if (func == GPIOF_INPUT || func == GPIOF_OUTPUT || 467 func == GPIOF_UNUSED) { 468 const char *label; 469 bool used; 470 471 ret = ops->get_value(dev, offset); 472 if (ret < 0) 473 return ret; 474 used = gpio_get_function(dev, offset, &label) != GPIOF_UNUSED; 475 snprintf(str + len, buffsize - len, ": %d [%c]%s%s", 476 ret, 477 used ? 'x' : ' ', 478 used ? " " : "", 479 label ? label : ""); 480 } 481 482 return 0; 483 } 484 485 /* 486 * get a number comprised of multiple GPIO values. gpio_num_array points to 487 * the array of gpio pin numbers to scan, terminated by -1. 488 */ 489 unsigned gpio_get_values_as_int(const int *gpio_num_array) 490 { 491 int gpio; 492 unsigned bitmask = 1; 493 unsigned vector = 0; 494 495 while (bitmask && 496 ((gpio = *gpio_num_array++) != -1)) { 497 if (gpio_get_value(gpio)) 498 vector |= bitmask; 499 bitmask <<= 1; 500 } 501 return vector; 502 } 503 504 /* We need to renumber the GPIOs when any driver is probed/removed */ 505 static int gpio_renumber(struct udevice *removed_dev) 506 { 507 struct gpio_dev_priv *uc_priv; 508 struct udevice *dev; 509 struct uclass *uc; 510 unsigned base; 511 int ret; 512 513 ret = uclass_get(UCLASS_GPIO, &uc); 514 if (ret) 515 return ret; 516 517 /* Ensure that we have a base for each bank */ 518 base = 0; 519 uclass_foreach_dev(dev, uc) { 520 if (device_active(dev) && dev != removed_dev) { 521 uc_priv = dev->uclass_priv; 522 uc_priv->gpio_base = base; 523 base += uc_priv->gpio_count; 524 } 525 } 526 527 return 0; 528 } 529 530 static int gpio_post_probe(struct udevice *dev) 531 { 532 struct gpio_dev_priv *uc_priv = dev->uclass_priv; 533 534 uc_priv->name = calloc(uc_priv->gpio_count, sizeof(char *)); 535 if (!uc_priv->name) 536 return -ENOMEM; 537 538 return gpio_renumber(NULL); 539 } 540 541 static int gpio_pre_remove(struct udevice *dev) 542 { 543 struct gpio_dev_priv *uc_priv = dev->uclass_priv; 544 int i; 545 546 for (i = 0; i < uc_priv->gpio_count; i++) { 547 if (uc_priv->name[i]) 548 free(uc_priv->name[i]); 549 } 550 free(uc_priv->name); 551 552 return gpio_renumber(dev); 553 } 554 555 UCLASS_DRIVER(gpio) = { 556 .id = UCLASS_GPIO, 557 .name = "gpio", 558 .post_probe = gpio_post_probe, 559 .pre_remove = gpio_pre_remove, 560 .per_device_auto_alloc_size = sizeof(struct gpio_dev_priv), 561 }; 562