drivers/gpio/da8xx_gpio.c

   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 <[email protected]>
   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
  24 static 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)
  33 static 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 */
 164 static 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
 315 int 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
 332 int 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
 347 static 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
 353 static 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
 360 static 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
 370 static int _gpio_get_dir(struct davinci_gpio *bank, unsigned int gpio)
 371 {
 372         return in_le32(&bank->dir) & (1U << GPIO_BIT(gpio));
 373 }
 374
 375 static 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
 385 void 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
 402 int 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
 410 int 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
 418 int 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
 426 int 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
 436 static 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
 452 static 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
 463 static 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
 472 static 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
 479 static 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
 489 static 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
 502 static 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
 514 static 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
 523 static 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
 537 static 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
 544 static 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
 565 U_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