1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * GPIO driver for TI DaVinci DA8xx SOCs. 4 * 5 * (C) Copyright 2011 Guralp Systems Ltd. 6 * Laurence Withers <lwithers@guralp.com> 7 */ 8 9#include <common.h> 10#include <dm.h> 11#include <fdtdec.h> 12#include <malloc.h> 13#include <asm/io.h> 14#include <asm/global_data.h> 15#include <asm/gpio.h> 16#include <dt-bindings/gpio/gpio.h> 17 18#include "da8xx_gpio.h" 19 20#if !CONFIG_IS_ENABLED(DM_GPIO) 21#include <asm/arch/hardware.h> 22#include <asm/arch/davinci_misc.h> 23 24static struct gpio_registry { 25 int is_registered; 26 char name[GPIO_NAME_SIZE]; 27} gpio_registry[MAX_NUM_GPIOS]; 28 29#if defined(CONFIG_SOC_DA8XX) 30#define pinmux(x) (&davinci_syscfg_regs->pinmux[x]) 31 32#if defined(CONFIG_SOC_DA8XX) && !defined(CONFIG_SOC_DA850) 33static const struct pinmux_config gpio_pinmux[] = { 34 { pinmux(13), 8, 6 }, /* GP0[0] */ 35 { pinmux(13), 8, 7 }, 36 { pinmux(14), 8, 0 }, 37 { pinmux(14), 8, 1 }, 38 { pinmux(14), 8, 2 }, 39 { pinmux(14), 8, 3 }, 40 { pinmux(14), 8, 4 }, 41 { pinmux(14), 8, 5 }, 42 { pinmux(14), 8, 6 }, 43 { pinmux(14), 8, 7 }, 44 { pinmux(15), 8, 0 }, 45 { pinmux(15), 8, 1 }, 46 { pinmux(15), 8, 2 }, 47 { pinmux(15), 8, 3 }, 48 { pinmux(15), 8, 4 }, 49 { pinmux(15), 8, 5 }, 50 { pinmux(15), 8, 6 }, /* GP1[0] */ 51 { pinmux(15), 8, 7 }, 52 { pinmux(16), 8, 0 }, 53 { pinmux(16), 8, 1 }, 54 { pinmux(16), 8, 2 }, 55 { pinmux(16), 8, 3 }, 56 { pinmux(16), 8, 4 }, 57 { pinmux(16), 8, 5 }, 58 { pinmux(16), 8, 6 }, 59 { pinmux(16), 8, 7 }, 60 { pinmux(17), 8, 0 }, 61 { pinmux(17), 8, 1 }, 62 { pinmux(17), 8, 2 }, 63 { pinmux(17), 8, 3 }, 64 { pinmux(17), 8, 4 }, 65 { pinmux(17), 8, 5 }, 66 { pinmux(17), 8, 6 }, /* GP2[0] */ 67 { pinmux(17), 8, 7 }, 68 { pinmux(18), 8, 0 }, 69 { pinmux(18), 8, 1 }, 70 { pinmux(18), 8, 2 }, 71 { pinmux(18), 8, 3 }, 72 { pinmux(18), 8, 4 }, 73 { pinmux(18), 8, 5 }, 74 { pinmux(18), 8, 6 }, 75 { pinmux(18), 8, 7 }, 76 { pinmux(19), 8, 0 }, 77 { pinmux(9), 8, 2 }, 78 { pinmux(9), 8, 3 }, 79 { pinmux(9), 8, 4 }, 80 { pinmux(9), 8, 5 }, 81 { pinmux(9), 8, 6 }, 82 { pinmux(10), 8, 1 }, /* GP3[0] */ 83 { pinmux(10), 8, 2 }, 84 { pinmux(10), 8, 3 }, 85 { pinmux(10), 8, 4 }, 86 { pinmux(10), 8, 5 }, 87 { pinmux(10), 8, 6 }, 88 { pinmux(10), 8, 7 }, 89 { pinmux(11), 8, 0 }, 90 { pinmux(11), 8, 1 }, 91 { pinmux(11), 8, 2 }, 92 { pinmux(11), 8, 3 }, 93 { pinmux(11), 8, 4 }, 94 { pinmux(9), 8, 7 }, 95 { pinmux(2), 8, 6 }, 96 { pinmux(11), 8, 5 }, 97 { pinmux(11), 8, 6 }, 98 { pinmux(12), 8, 4 }, /* GP4[0] */ 99 { pinmux(12), 8, 5 }, 100 { pinmux(12), 8, 6 }, 101 { pinmux(12), 8, 7 }, 102 { pinmux(13), 8, 0 }, 103 { pinmux(13), 8, 1 }, 104 { pinmux(13), 8, 2 }, 105 { pinmux(13), 8, 3 }, 106 { pinmux(13), 8, 4 }, 107 { pinmux(13), 8, 5 }, 108 { pinmux(11), 8, 7 }, 109 { pinmux(12), 8, 0 }, 110 { pinmux(12), 8, 1 }, 111 { pinmux(12), 8, 2 }, 112 { pinmux(12), 8, 3 }, 113 { pinmux(9), 8, 1 }, 114 { pinmux(7), 8, 3 }, /* GP5[0] */ 115 { pinmux(7), 8, 4 }, 116 { pinmux(7), 8, 5 }, 117 { pinmux(7), 8, 6 }, 118 { pinmux(7), 8, 7 }, 119 { pinmux(8), 8, 0 }, 120 { pinmux(8), 8, 1 }, 121 { pinmux(8), 8, 2 }, 122 { pinmux(8), 8, 3 }, 123 { pinmux(8), 8, 4 }, 124 { pinmux(8), 8, 5 }, 125 { pinmux(8), 8, 6 }, 126 { pinmux(8), 8, 7 }, 127 { pinmux(9), 8, 0 }, 128 { pinmux(7), 8, 1 }, 129 { pinmux(7), 8, 2 }, 130 { pinmux(5), 8, 1 }, /* GP6[0] */ 131 { pinmux(5), 8, 2 }, 132 { pinmux(5), 8, 3 }, 133 { pinmux(5), 8, 4 }, 134 { pinmux(5), 8, 5 }, 135 { pinmux(5), 8, 6 }, 136 { pinmux(5), 8, 7 }, 137 { pinmux(6), 8, 0 }, 138 { pinmux(6), 8, 1 }, 139 { pinmux(6), 8, 2 }, 140 { pinmux(6), 8, 3 }, 141 { pinmux(6), 8, 4 }, 142 { pinmux(6), 8, 5 }, 143 { pinmux(6), 8, 6 }, 144 { pinmux(6), 8, 7 }, 145 { pinmux(7), 8, 0 }, 146 { pinmux(1), 8, 0 }, /* GP7[0] */ 147 { pinmux(1), 8, 1 }, 148 { pinmux(1), 8, 2 }, 149 { pinmux(1), 8, 3 }, 150 { pinmux(1), 8, 4 }, 151 { pinmux(1), 8, 5 }, 152 { pinmux(1), 8, 6 }, 153 { pinmux(1), 8, 7 }, 154 { pinmux(2), 8, 0 }, 155 { pinmux(2), 8, 1 }, 156 { pinmux(2), 8, 2 }, 157 { pinmux(2), 8, 3 }, 158 { pinmux(2), 8, 4 }, 159 { pinmux(2), 8, 5 }, 160 { pinmux(0), 1, 0 }, 161 { pinmux(0), 1, 1 }, 162}; 163#else /* CONFIG_SOC_DA8XX && CONFIG_SOC_DA850 */ 164static const struct pinmux_config gpio_pinmux[] = { 165 { pinmux(1), 8, 7 }, /* GP0[0] */ 166 { pinmux(1), 8, 6 }, 167 { pinmux(1), 8, 5 }, 168 { pinmux(1), 8, 4 }, 169 { pinmux(1), 8, 3 }, 170 { pinmux(1), 8, 2 }, 171 { pinmux(1), 8, 1 }, 172 { pinmux(1), 8, 0 }, 173 { pinmux(0), 8, 7 }, 174 { pinmux(0), 8, 6 }, 175 { pinmux(0), 8, 5 }, 176 { pinmux(0), 8, 4 }, 177 { pinmux(0), 8, 3 }, 178 { pinmux(0), 8, 2 }, 179 { pinmux(0), 8, 1 }, 180 { pinmux(0), 8, 0 }, 181 { pinmux(4), 8, 7 }, /* GP1[0] */ 182 { pinmux(4), 8, 6 }, 183 { pinmux(4), 8, 5 }, 184 { pinmux(4), 8, 4 }, 185 { pinmux(4), 8, 3 }, 186 { pinmux(4), 8, 2 }, 187 { pinmux(4), 4, 1 }, 188 { pinmux(4), 4, 0 }, 189 { pinmux(3), 4, 0 }, 190 { pinmux(2), 4, 6 }, 191 { pinmux(2), 4, 5 }, 192 { pinmux(2), 4, 4 }, 193 { pinmux(2), 4, 3 }, 194 { pinmux(2), 4, 2 }, 195 { pinmux(2), 4, 1 }, 196 { pinmux(2), 8, 0 }, 197 { pinmux(6), 8, 7 }, /* GP2[0] */ 198 { pinmux(6), 8, 6 }, 199 { pinmux(6), 8, 5 }, 200 { pinmux(6), 8, 4 }, 201 { pinmux(6), 8, 3 }, 202 { pinmux(6), 8, 2 }, 203 { pinmux(6), 8, 1 }, 204 { pinmux(6), 8, 0 }, 205 { pinmux(5), 8, 7 }, 206 { pinmux(5), 8, 6 }, 207 { pinmux(5), 8, 5 }, 208 { pinmux(5), 8, 4 }, 209 { pinmux(5), 8, 3 }, 210 { pinmux(5), 8, 2 }, 211 { pinmux(5), 8, 1 }, 212 { pinmux(5), 8, 0 }, 213 { pinmux(8), 8, 7 }, /* GP3[0] */ 214 { pinmux(8), 8, 6 }, 215 { pinmux(8), 8, 5 }, 216 { pinmux(8), 8, 4 }, 217 { pinmux(8), 8, 3 }, 218 { pinmux(8), 8, 2 }, 219 { pinmux(8), 8, 1 }, 220 { pinmux(8), 8, 0 }, 221 { pinmux(7), 8, 7 }, 222 { pinmux(7), 8, 6 }, 223 { pinmux(7), 8, 5 }, 224 { pinmux(7), 8, 4 }, 225 { pinmux(7), 8, 3 }, 226 { pinmux(7), 8, 2 }, 227 { pinmux(7), 8, 1 }, 228 { pinmux(7), 8, 0 }, 229 { pinmux(10), 8, 7 }, /* GP4[0] */ 230 { pinmux(10), 8, 6 }, 231 { pinmux(10), 8, 5 }, 232 { pinmux(10), 8, 4 }, 233 { pinmux(10), 8, 3 }, 234 { pinmux(10), 8, 2 }, 235 { pinmux(10), 8, 1 }, 236 { pinmux(10), 8, 0 }, 237 { pinmux(9), 8, 7 }, 238 { pinmux(9), 8, 6 }, 239 { pinmux(9), 8, 5 }, 240 { pinmux(9), 8, 4 }, 241 { pinmux(9), 8, 3 }, 242 { pinmux(9), 8, 2 }, 243 { pinmux(9), 8, 1 }, 244 { pinmux(9), 8, 0 }, 245 { pinmux(12), 8, 7 }, /* GP5[0] */ 246 { pinmux(12), 8, 6 }, 247 { pinmux(12), 8, 5 }, 248 { pinmux(12), 8, 4 }, 249 { pinmux(12), 8, 3 }, 250 { pinmux(12), 8, 2 }, 251 { pinmux(12), 8, 1 }, 252 { pinmux(12), 8, 0 }, 253 { pinmux(11), 8, 7 }, 254 { pinmux(11), 8, 6 }, 255 { pinmux(11), 8, 5 }, 256 { pinmux(11), 8, 4 }, 257 { pinmux(11), 8, 3 }, 258 { pinmux(11), 8, 2 }, 259 { pinmux(11), 8, 1 }, 260 { pinmux(11), 8, 0 }, 261 { pinmux(19), 8, 6 }, /* GP6[0] */ 262 { pinmux(19), 8, 5 }, 263 { pinmux(19), 8, 4 }, 264 { pinmux(19), 8, 3 }, 265 { pinmux(19), 8, 2 }, 266 { pinmux(16), 8, 1 }, 267 { pinmux(14), 8, 1 }, 268 { pinmux(14), 8, 0 }, 269 { pinmux(13), 8, 7 }, 270 { pinmux(13), 8, 6 }, 271 { pinmux(13), 8, 5 }, 272 { pinmux(13), 8, 4 }, 273 { pinmux(13), 8, 3 }, 274 { pinmux(13), 8, 2 }, 275 { pinmux(13), 8, 1 }, 276 { pinmux(13), 8, 0 }, 277 { pinmux(18), 8, 1 }, /* GP7[0] */ 278 { pinmux(18), 8, 0 }, 279 { pinmux(17), 8, 7 }, 280 { pinmux(17), 8, 6 }, 281 { pinmux(17), 8, 5 }, 282 { pinmux(17), 8, 4 }, 283 { pinmux(17), 8, 3 }, 284 { pinmux(17), 8, 2 }, 285 { pinmux(17), 8, 1 }, 286 { pinmux(17), 8, 0 }, 287 { pinmux(16), 8, 7 }, 288 { pinmux(16), 8, 6 }, 289 { pinmux(16), 8, 5 }, 290 { pinmux(16), 8, 4 }, 291 { pinmux(16), 8, 3 }, 292 { pinmux(16), 8, 2 }, 293 { pinmux(19), 8, 0 }, /* GP8[0] */ 294 { pinmux(3), 4, 7 }, 295 { pinmux(3), 4, 6 }, 296 { pinmux(3), 4, 5 }, 297 { pinmux(3), 4, 4 }, 298 { pinmux(3), 4, 3 }, 299 { pinmux(3), 4, 2 }, 300 { pinmux(2), 4, 7 }, 301 { pinmux(19), 8, 1 }, 302 { pinmux(19), 8, 0 }, 303 { pinmux(18), 8, 7 }, 304 { pinmux(18), 8, 6 }, 305 { pinmux(18), 8, 5 }, 306 { pinmux(18), 8, 4 }, 307 { pinmux(18), 8, 3 }, 308 { pinmux(18), 8, 2 }, 309}; 310#endif /* CONFIG_SOC_DA8XX && !CONFIG_SOC_DA850 */ 311#else /* !CONFIG_SOC_DA8XX */ 312#define davinci_configure_pin_mux(a, b) 313#endif /* CONFIG_SOC_DA8XX */ 314 315int gpio_request(unsigned int gpio, const char *label) 316{ 317 if (gpio >= MAX_NUM_GPIOS) 318 return -1; 319 320 if (gpio_registry[gpio].is_registered) 321 return -1; 322 323 gpio_registry[gpio].is_registered = 1; 324 strncpy(gpio_registry[gpio].name, label, GPIO_NAME_SIZE); 325 gpio_registry[gpio].name[GPIO_NAME_SIZE - 1] = 0; 326 327 davinci_configure_pin_mux(&gpio_pinmux[gpio], 1); 328 329 return 0; 330} 331 332int gpio_free(unsigned int gpio) 333{ 334 if (gpio >= MAX_NUM_GPIOS) 335 return -1; 336 337 if (!gpio_registry[gpio].is_registered) 338 return -1; 339 340 gpio_registry[gpio].is_registered = 0; 341 gpio_registry[gpio].name[0] = '\0'; 342 /* Do not configure as input or change pin mux here */ 343 return 0; 344} 345#endif 346 347static int _gpio_direction_input(struct davinci_gpio *bank, unsigned int gpio) 348{ 349 setbits_le32(&bank->dir, 1U << GPIO_BIT(gpio)); 350 return 0; 351} 352 353static int _gpio_get_value(struct davinci_gpio *bank, unsigned int gpio) 354{ 355 unsigned int ip; 356 ip = in_le32(&bank->in_data) & (1U << GPIO_BIT(gpio)); 357 return ip ? 1 : 0; 358} 359 360static int _gpio_set_value(struct davinci_gpio *bank, unsigned int gpio, int value) 361{ 362 if (value) 363 bank->set_data = 1U << GPIO_BIT(gpio); 364 else 365 bank->clr_data = 1U << GPIO_BIT(gpio); 366 367 return 0; 368} 369 370static int _gpio_get_dir(struct davinci_gpio *bank, unsigned int gpio) 371{ 372 return in_le32(&bank->dir) & (1U << GPIO_BIT(gpio)); 373} 374 375static int _gpio_direction_output(struct davinci_gpio *bank, unsigned int gpio, 376 int value) 377{ 378 clrbits_le32(&bank->dir, 1U << GPIO_BIT(gpio)); 379 _gpio_set_value(bank, gpio, value); 380 return 0; 381} 382 383#if !CONFIG_IS_ENABLED(DM_GPIO) 384 385void gpio_info(void) 386{ 387 unsigned int gpio, dir, val; 388 struct davinci_gpio *bank; 389 390 for (gpio = 0; gpio < MAX_NUM_GPIOS; ++gpio) { 391 bank = GPIO_BANK(gpio); 392 dir = _gpio_get_dir(bank, gpio); 393 val = gpio_get_value(gpio); 394 395 printf("% 4d: %s: %d [%c] %s\n", 396 gpio, dir ? " in" : "out", val, 397 gpio_registry[gpio].is_registered ? 'x' : ' ', 398 gpio_registry[gpio].name); 399 } 400} 401 402int gpio_direction_input(unsigned int gpio) 403{ 404 struct davinci_gpio *bank; 405 406 bank = GPIO_BANK(gpio); 407 return _gpio_direction_input(bank, gpio); 408} 409 410int gpio_direction_output(unsigned int gpio, int value) 411{ 412 struct davinci_gpio *bank; 413 414 bank = GPIO_BANK(gpio); 415 return _gpio_direction_output(bank, gpio, value); 416} 417 418int gpio_get_value(unsigned int gpio) 419{ 420 struct davinci_gpio *bank; 421 422 bank = GPIO_BANK(gpio); 423 return _gpio_get_value(bank, gpio); 424} 425 426int gpio_set_value(unsigned int gpio, int value) 427{ 428 struct davinci_gpio *bank; 429 430 bank = GPIO_BANK(gpio); 431 return _gpio_set_value(bank, gpio, value); 432} 433 434#else /* DM_GPIO */ 435 436static struct davinci_gpio *davinci_get_gpio_bank(struct udevice *dev, unsigned int offset) 437{ 438 struct davinci_gpio_bank *bank = dev_get_priv(dev); 439 unsigned long addr; 440 441 /* 442 * The device tree is not broken into banks but the infrastructure is 443 * expecting it this way, so we'll first include the 0x10 offset, then 444 * calculate the bank manually based on the offset. 445 * Casting 'addr' as Unsigned long is needed to make the math work. 446 */ 447 addr = ((unsigned long)(struct davinci_gpio *)bank->base) + 448 0x10 + (0x28 * (offset >> 5)); 449 return (struct davinci_gpio *)addr; 450} 451 452static int davinci_gpio_direction_input(struct udevice *dev, unsigned int offset) 453{ 454 struct davinci_gpio *base = davinci_get_gpio_bank(dev, offset); 455 456 /* 457 * Fetch the address based on GPIO, but only pass the masked low 32-bits 458 */ 459 _gpio_direction_input(base, (offset & 0x1f)); 460 return 0; 461} 462 463static int davinci_gpio_direction_output(struct udevice *dev, unsigned int offset, 464 int value) 465{ 466 struct davinci_gpio *base = davinci_get_gpio_bank(dev, offset); 467 468 _gpio_direction_output(base, (offset & 0x1f), value); 469 return 0; 470} 471 472static int davinci_gpio_get_value(struct udevice *dev, unsigned int offset) 473{ 474 struct davinci_gpio *base = davinci_get_gpio_bank(dev, offset); 475 476 return _gpio_get_value(base, (offset & 0x1f)); 477} 478 479static int davinci_gpio_set_value(struct udevice *dev, unsigned int offset, 480 int value) 481{ 482 struct davinci_gpio *base = davinci_get_gpio_bank(dev, offset); 483 484 _gpio_set_value(base, (offset & 0x1f), value); 485 486 return 0; 487} 488 489static int davinci_gpio_get_function(struct udevice *dev, unsigned int offset) 490{ 491 unsigned int dir; 492 struct davinci_gpio *base = davinci_get_gpio_bank(dev, offset); 493 494 dir = _gpio_get_dir(base, offset); 495 496 if (dir) 497 return GPIOF_INPUT; 498 499 return GPIOF_OUTPUT; 500} 501 502static int davinci_gpio_xlate(struct udevice *dev, struct gpio_desc *desc, 503 struct ofnode_phandle_args *args) 504{ 505 desc->offset = args->args[0]; 506 507 if (args->args[1] & GPIO_ACTIVE_LOW) 508 desc->flags = GPIOD_ACTIVE_LOW; 509 else 510 desc->flags = 0; 511 return 0; 512} 513 514static const struct dm_gpio_ops gpio_davinci_ops = { 515 .direction_input = davinci_gpio_direction_input, 516 .direction_output = davinci_gpio_direction_output, 517 .get_value = davinci_gpio_get_value, 518 .set_value = davinci_gpio_set_value, 519 .get_function = davinci_gpio_get_function, 520 .xlate = davinci_gpio_xlate, 521}; 522 523static int davinci_gpio_probe(struct udevice *dev) 524{ 525 struct davinci_gpio_bank *bank = dev_get_priv(dev); 526 struct davinci_gpio_plat *plat = dev_get_plat(dev); 527 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev); 528 const void *fdt = gd->fdt_blob; 529 int node = dev_of_offset(dev); 530 531 uc_priv->bank_name = plat->port_name; 532 uc_priv->gpio_count = fdtdec_get_int(fdt, node, "ti,ngpio", -1); 533 bank->base = (struct davinci_gpio *)plat->base; 534 return 0; 535} 536 537static const struct udevice_id davinci_gpio_ids[] = { 538 { .compatible = "ti,dm6441-gpio" }, 539 { .compatible = "ti,k2g-gpio" }, 540 { .compatible = "ti,keystone-gpio" }, 541 { } 542}; 543 544static int davinci_gpio_of_to_plat(struct udevice *dev) 545{ 546 struct davinci_gpio_plat *plat = dev_get_plat(dev); 547 fdt_addr_t addr; 548 char name[18], *str; 549 550 addr = dev_read_addr(dev); 551 if (addr == FDT_ADDR_T_NONE) 552 return -EINVAL; 553 554 plat->base = addr; 555 556 sprintf(name, "gpio@%4x_", (unsigned int)plat->base); 557 str = strdup(name); 558 if (!str) 559 return -ENOMEM; 560 plat->port_name = str; 561 562 return 0; 563} 564 565U_BOOT_DRIVER(ti_dm6441_gpio) = { 566 .name = "ti_dm6441_gpio", 567 .id = UCLASS_GPIO, 568 .ops = &gpio_davinci_ops, 569 .of_to_plat = of_match_ptr(davinci_gpio_of_to_plat), 570 .of_match = davinci_gpio_ids, 571 .bind = dm_scan_fdt_dev, 572 .plat_auto = sizeof(struct davinci_gpio_plat), 573 .probe = davinci_gpio_probe, 574 .priv_auto = sizeof(struct davinci_gpio_bank), 575}; 576 577#endif 578