drivers/pinctrl/pinctrl_stm32.c

   1 #include <common.h>
   2 #include <dm.h>
   3 #include <hwspinlock.h>
   4 #include <malloc.h>
   5 #include <asm/arch/gpio.h>
   6 #include <asm/gpio.h>
   7 #include <asm/io.h>
   8 #include <dm/device_compat.h>
   9 #include <dm/lists.h>
  10 #include <dm/pinctrl.h>
  11 #include <linux/err.h>
  12
  13 DECLARE_GLOBAL_DATA_PTR;
  14
  15 #define MAX_PINS_ONE_IP                 70
  16 #define MODE_BITS_MASK                  3
  17 #define OSPEED_MASK                     3
  18 #define PUPD_MASK                       3
  19 #define OTYPE_MSK                       1
  20 #define AFR_MASK                        0xF
  21
  22 struct stm32_pinctrl_priv {
  23         struct hwspinlock hws;
  24         int pinctrl_ngpios;
  25         struct list_head gpio_dev;
  26 };
  27
  28 struct stm32_gpio_bank {
  29         struct udevice *gpio_dev;
  30         struct list_head list;
  31 };
  32
  33 #ifndef CONFIG_SPL_BUILD
  34
  35 static char pin_name[PINNAME_SIZE];
  36 #define PINMUX_MODE_COUNT               5
  37 static const char * const pinmux_mode[PINMUX_MODE_COUNT] = {
  38         "gpio input",
  39         "gpio output",
  40         "analog",
  41         "unknown",
  42         "alt function",
  43 };
  44
  45 static int stm32_pinctrl_get_af(struct udevice *dev, unsigned int offset)
  46 {
  47         struct stm32_gpio_priv *priv = dev_get_priv(dev);
  48         struct stm32_gpio_regs *regs = priv->regs;
  49         u32 af;
  50         u32 alt_shift = (offset % 8) * 4;
  51         u32 alt_index =  offset / 8;
  52
  53         af = (readl(&regs->afr[alt_index]) &
  54               GENMASK(alt_shift + 3, alt_shift)) >> alt_shift;
  55
  56         return af;
  57 }
  58
  59 static int stm32_populate_gpio_dev_list(struct udevice *dev)
  60 {
  61         struct stm32_pinctrl_priv *priv = dev_get_priv(dev);
  62         struct udevice *gpio_dev;
  63         struct udevice *child;
  64         struct stm32_gpio_bank *gpio_bank;
  65         int ret;
  66
  67         /*
  68          * parse pin-controller sub-nodes (ie gpio bank nodes) and fill
  69          * a list with all gpio device reference which belongs to the
  70          * current pin-controller. This list is used to find pin_name and
  71          * pin muxing
  72          */
  73         list_for_each_entry(child, &dev->child_head, sibling_node) {
  74                 ret = uclass_get_device_by_name(UCLASS_GPIO, child->name,
  75                                                 &gpio_dev);
  76                 if (ret < 0)
  77                         continue;
  78
  79                 gpio_bank = malloc(sizeof(*gpio_bank));
  80                 if (!gpio_bank) {
  81                         dev_err(dev, "Not enough memory\n");
  82                         return -ENOMEM;
  83                 }
  84
  85                 gpio_bank->gpio_dev = gpio_dev;
  86                 list_add_tail(&gpio_bank->list, &priv->gpio_dev);
  87         }
  88
  89         return 0;
  90 }
  91
  92 static int stm32_pinctrl_get_pins_count(struct udevice *dev)
  93 {
  94         struct stm32_pinctrl_priv *priv = dev_get_priv(dev);
  95         struct gpio_dev_priv *uc_priv;
  96         struct stm32_gpio_bank *gpio_bank;
  97
  98         /*
  99          * if get_pins_count has already been executed once on this
 100          * pin-controller, no need to run it again
 101          */
 102         if (priv->pinctrl_ngpios)
 103                 return priv->pinctrl_ngpios;
 104
 105         if (list_empty(&priv->gpio_dev))
 106                 stm32_populate_gpio_dev_list(dev);
 107         /*
 108          * walk through all banks to retrieve the pin-controller
 109          * pins number
 110          */
 111         list_for_each_entry(gpio_bank, &priv->gpio_dev, list) {
 112                 uc_priv = dev_get_uclass_priv(gpio_bank->gpio_dev);
 113
 114                 priv->pinctrl_ngpios += uc_priv->gpio_count;
 115         }
 116
 117         return priv->pinctrl_ngpios;
 118 }
 119
 120 static struct udevice *stm32_pinctrl_get_gpio_dev(struct udevice *dev,
 121                                                   unsigned int selector,
 122                                                   unsigned int *idx)
 123 {
 124         struct stm32_pinctrl_priv *priv = dev_get_priv(dev);
 125         struct stm32_gpio_bank *gpio_bank;
 126         struct gpio_dev_priv *uc_priv;
 127         int pin_count = 0;
 128
 129         if (list_empty(&priv->gpio_dev))
 130                 stm32_populate_gpio_dev_list(dev);
 131
 132         /* look up for the bank which owns the requested pin */
 133         list_for_each_entry(gpio_bank, &priv->gpio_dev, list) {
 134                 uc_priv = dev_get_uclass_priv(gpio_bank->gpio_dev);
 135
 136                 if (selector < (pin_count + uc_priv->gpio_count)) {
 137                         /*
 138                          * we found the bank, convert pin selector to
 139                          * gpio bank index
 140                          */
 141                         *idx = stm32_offset_to_index(gpio_bank->gpio_dev,
 142                                                      selector - pin_count);
 143                         if (IS_ERR_VALUE(*idx))
 144                                 return NULL;
 145
 146                         return gpio_bank->gpio_dev;
 147                 }
 148                 pin_count += uc_priv->gpio_count;
 149         }
 150
 151         return NULL;
 152 }
 153
 154 static const char *stm32_pinctrl_get_pin_name(struct udevice *dev,
 155                                               unsigned int selector)
 156 {
 157         struct gpio_dev_priv *uc_priv;
 158         struct udevice *gpio_dev;
 159         unsigned int gpio_idx;
 160
 161         /* look up for the bank which owns the requested pin */
 162         gpio_dev = stm32_pinctrl_get_gpio_dev(dev, selector, &gpio_idx);
 163         if (!gpio_dev) {
 164                 snprintf(pin_name, PINNAME_SIZE, "Error");
 165         } else {
 166                 uc_priv = dev_get_uclass_priv(gpio_dev);
 167
 168                 snprintf(pin_name, PINNAME_SIZE, "%s%d",
 169                          uc_priv->bank_name,
 170                          gpio_idx);
 171         }
 172
 173         return pin_name;
 174 }
 175
 176 static int stm32_pinctrl_get_pin_muxing(struct udevice *dev,
 177                                         unsigned int selector,
 178                                         char *buf,
 179                                         int size)
 180 {
 181         struct udevice *gpio_dev;
 182         const char *label;
 183         int mode;
 184         int af_num;
 185         unsigned int gpio_idx;
 186
 187         /* look up for the bank which owns the requested pin */
 188         gpio_dev = stm32_pinctrl_get_gpio_dev(dev, selector, &gpio_idx);
 189
 190         if (!gpio_dev)
 191                 return -ENODEV;
 192
 193         mode = gpio_get_raw_function(gpio_dev, gpio_idx, &label);
 194
 195         dev_dbg(dev, "selector = %d gpio_idx = %d mode = %d\n",
 196                 selector, gpio_idx, mode);
 197
 198
 199         switch (mode) {
 200         case GPIOF_UNKNOWN:
 201                 /* should never happen */
 202                 return -EINVAL;
 203         case GPIOF_UNUSED:
 204                 snprintf(buf, size, "%s", pinmux_mode[mode]);
 205                 break;
 206         case GPIOF_FUNC:
 207                 af_num = stm32_pinctrl_get_af(gpio_dev, gpio_idx);
 208                 snprintf(buf, size, "%s %d", pinmux_mode[mode], af_num);
 209                 break;
 210         case GPIOF_OUTPUT:
 211         case GPIOF_INPUT:
 212                 snprintf(buf, size, "%s %s",
 213                          pinmux_mode[mode], label ? label : "");
 214                 break;
 215         }
 216
 217         return 0;
 218 }
 219
 220 #endif
 221
 222 static int stm32_pinctrl_probe(struct udevice *dev)
 223 {
 224         struct stm32_pinctrl_priv *priv = dev_get_priv(dev);
 225         int ret;
 226
 227         INIT_LIST_HEAD(&priv->gpio_dev);
 228
 229         /* hwspinlock property is optional, just log the error */
 230         ret = hwspinlock_get_by_index(dev, 0, &priv->hws);
 231         if (ret)
 232                 debug("%s: hwspinlock_get_by_index may have failed (%d)\n",
 233                       __func__, ret);
 234
 235         return 0;
 236 }
 237
 238 static int stm32_gpio_config(struct gpio_desc *desc,
 239                              const struct stm32_gpio_ctl *ctl)
 240 {
 241         struct stm32_gpio_priv *priv = dev_get_priv(desc->dev);
 242         struct stm32_gpio_regs *regs = priv->regs;
 243         struct stm32_pinctrl_priv *ctrl_priv;
 244         int ret;
 245         u32 index;
 246
 247         if (!ctl || ctl->af > 15 || ctl->mode > 3 || ctl->otype > 1 ||
 248             ctl->pupd > 2 || ctl->speed > 3)
 249                 return -EINVAL;
 250
 251         ctrl_priv = dev_get_priv(dev_get_parent(desc->dev));
 252         ret = hwspinlock_lock_timeout(&ctrl_priv->hws, 10);
 253         if (ret == -ETIME) {
 254                 dev_err(desc->dev, "HWSpinlock timeout\n");
 255                 return ret;
 256         }
 257
 258         index = (desc->offset & 0x07) * 4;
 259         clrsetbits_le32(&regs->afr[desc->offset >> 3], AFR_MASK << index,
 260                         ctl->af << index);
 261
 262         index = desc->offset * 2;
 263         clrsetbits_le32(&regs->moder, MODE_BITS_MASK << index,
 264                         ctl->mode << index);
 265         clrsetbits_le32(&regs->ospeedr, OSPEED_MASK << index,
 266                         ctl->speed << index);
 267         clrsetbits_le32(&regs->pupdr, PUPD_MASK << index, ctl->pupd << index);
 268
 269         index = desc->offset;
 270         clrsetbits_le32(&regs->otyper, OTYPE_MSK << index, ctl->otype << index);
 271
 272         hwspinlock_unlock(&ctrl_priv->hws);
 273
 274         return 0;
 275 }
 276
 277 static int prep_gpio_dsc(struct stm32_gpio_dsc *gpio_dsc, u32 port_pin)
 278 {
 279         gpio_dsc->port = (port_pin & 0x1F000) >> 12;
 280         gpio_dsc->pin = (port_pin & 0x0F00) >> 8;
 281         debug("%s: GPIO:port= %d, pin= %d\n", __func__, gpio_dsc->port,
 282               gpio_dsc->pin);
 283
 284         return 0;
 285 }
 286
 287 static int prep_gpio_ctl(struct stm32_gpio_ctl *gpio_ctl, u32 gpio_fn, int node)
 288 {
 289         gpio_fn &= 0x00FF;
 290         gpio_ctl->af = 0;
 291
 292         switch (gpio_fn) {
 293         case 0:
 294                 gpio_ctl->mode = STM32_GPIO_MODE_IN;
 295                 break;
 296         case 1 ... 16:
 297                 gpio_ctl->mode = STM32_GPIO_MODE_AF;
 298                 gpio_ctl->af = gpio_fn - 1;
 299                 break;
 300         case 17:
 301                 gpio_ctl->mode = STM32_GPIO_MODE_AN;
 302                 break;
 303         default:
 304                 gpio_ctl->mode = STM32_GPIO_MODE_OUT;
 305                 break;
 306         }
 307
 308         gpio_ctl->speed = fdtdec_get_int(gd->fdt_blob, node, "slew-rate", 0);
 309
 310         if (fdtdec_get_bool(gd->fdt_blob, node, "drive-open-drain"))
 311                 gpio_ctl->otype = STM32_GPIO_OTYPE_OD;
 312         else
 313                 gpio_ctl->otype = STM32_GPIO_OTYPE_PP;
 314
 315         if (fdtdec_get_bool(gd->fdt_blob, node, "bias-pull-up"))
 316                 gpio_ctl->pupd = STM32_GPIO_PUPD_UP;
 317         else if (fdtdec_get_bool(gd->fdt_blob, node, "bias-pull-down"))
 318                 gpio_ctl->pupd = STM32_GPIO_PUPD_DOWN;
 319         else
 320                 gpio_ctl->pupd = STM32_GPIO_PUPD_NO;
 321
 322         debug("%s: gpio fn= %d, slew-rate= %x, op type= %x, pull-upd is = %x\n",
 323               __func__,  gpio_fn, gpio_ctl->speed, gpio_ctl->otype,
 324              gpio_ctl->pupd);
 325
 326         return 0;
 327 }
 328
 329 static int stm32_pinctrl_config(int offset)
 330 {
 331         u32 pin_mux[MAX_PINS_ONE_IP];
 332         int rv, len;
 333
 334         /*
 335          * check for "pinmux" property in each subnode (e.g. pins1 and pins2 for
 336          * usart1) of pin controller phandle "pinctrl-0"
 337          * */
 338         fdt_for_each_subnode(offset, gd->fdt_blob, offset) {
 339                 struct stm32_gpio_dsc gpio_dsc;
 340                 struct stm32_gpio_ctl gpio_ctl;
 341                 int i;
 342
 343                 len = fdtdec_get_int_array_count(gd->fdt_blob, offset,
 344                                                  "pinmux", pin_mux,
 345                                                  ARRAY_SIZE(pin_mux));
 346                 debug("%s: no of pinmux entries= %d\n", __func__, len);
 347                 if (len < 0)
 348                         return -EINVAL;
 349                 for (i = 0; i < len; i++) {
 350                         struct gpio_desc desc;
 351
 352                         debug("%s: pinmux = %x\n", __func__, *(pin_mux + i));
 353                         prep_gpio_dsc(&gpio_dsc, *(pin_mux + i));
 354                         prep_gpio_ctl(&gpio_ctl, *(pin_mux + i), offset);
 355                         rv = uclass_get_device_by_seq(UCLASS_GPIO,
 356                                                       gpio_dsc.port,
 357                                                       &desc.dev);
 358                         if (rv)
 359                                 return rv;
 360                         desc.offset = gpio_dsc.pin;
 361                         rv = stm32_gpio_config(&desc, &gpio_ctl);
 362                         debug("%s: rv = %d\n\n", __func__, rv);
 363                         if (rv)
 364                                 return rv;
 365                 }
 366         }
 367
 368         return 0;
 369 }
 370
 371 static int stm32_pinctrl_bind(struct udevice *dev)
 372 {
 373         ofnode node;
 374         const char *name;
 375         int ret;
 376
 377         dev_for_each_subnode(node, dev) {
 378                 debug("%s: bind %s\n", __func__, ofnode_get_name(node));
 379
 380                 ofnode_get_property(node, "gpio-controller", &ret);
 381                 if (ret < 0)
 382                         continue;
 383                 /* Get the name of each gpio node */
 384                 name = ofnode_get_name(node);
 385                 if (!name)
 386                         return -EINVAL;
 387
 388                 /* Bind each gpio node */
 389                 ret = device_bind_driver_to_node(dev, "gpio_stm32",
 390                                                  name, node, NULL);
 391                 if (ret)
 392                         return ret;
 393
 394                 debug("%s: bind %s\n", __func__, name);
 395         }
 396
 397         return 0;
 398 }
 399
 400 #if CONFIG_IS_ENABLED(PINCTRL_FULL)
 401 static int stm32_pinctrl_set_state(struct udevice *dev, struct udevice *config)
 402 {
 403         return stm32_pinctrl_config(dev_of_offset(config));
 404 }
 405 #else /* PINCTRL_FULL */
 406 static int stm32_pinctrl_set_state_simple(struct udevice *dev,
 407                                           struct udevice *periph)
 408 {
 409         const void *fdt = gd->fdt_blob;
 410         const fdt32_t *list;
 411         uint32_t phandle;
 412         int config_node;
 413         int size, i, ret;
 414
 415         list = fdt_getprop(fdt, dev_of_offset(periph), "pinctrl-0", &size);
 416         if (!list)
 417                 return -EINVAL;
 418
 419         debug("%s: periph->name = %s\n", __func__, periph->name);
 420
 421         size /= sizeof(*list);
 422         for (i = 0; i < size; i++) {
 423                 phandle = fdt32_to_cpu(*list++);
 424
 425                 config_node = fdt_node_offset_by_phandle(fdt, phandle);
 426                 if (config_node < 0) {
 427                         pr_err("prop pinctrl-0 index %d invalid phandle\n", i);
 428                         return -EINVAL;
 429                 }
 430
 431                 ret = stm32_pinctrl_config(config_node);
 432                 if (ret)
 433                         return ret;
 434         }
 435
 436         return 0;
 437 }
 438 #endif /* PINCTRL_FULL */
 439
 440 static struct pinctrl_ops stm32_pinctrl_ops = {
 441 #if CONFIG_IS_ENABLED(PINCTRL_FULL)
 442         .set_state              = stm32_pinctrl_set_state,
 443 #else /* PINCTRL_FULL */
 444         .set_state_simple       = stm32_pinctrl_set_state_simple,
 445 #endif /* PINCTRL_FULL */
 446 #ifndef CONFIG_SPL_BUILD
 447         .get_pin_name           = stm32_pinctrl_get_pin_name,
 448         .get_pins_count         = stm32_pinctrl_get_pins_count,
 449         .get_pin_muxing         = stm32_pinctrl_get_pin_muxing,
 450 #endif
 451 };
 452
 453 static const struct udevice_id stm32_pinctrl_ids[] = {
 454         { .compatible = "st,stm32f429-pinctrl" },
 455         { .compatible = "st,stm32f469-pinctrl" },
 456         { .compatible = "st,stm32f746-pinctrl" },
 457         { .compatible = "st,stm32f769-pinctrl" },
 458         { .compatible = "st,stm32h743-pinctrl" },
 459         { .compatible = "st,stm32mp157-pinctrl" },
 460         { .compatible = "st,stm32mp157-z-pinctrl" },
 461         { }
 462 };
 463
 464 U_BOOT_DRIVER(pinctrl_stm32) = {
 465         .name                   = "pinctrl_stm32",
 466         .id                     = UCLASS_PINCTRL,
 467         .of_match               = stm32_pinctrl_ids,
 468         .ops                    = &stm32_pinctrl_ops,
 469         .bind                   = stm32_pinctrl_bind,
 470         .probe                  = stm32_pinctrl_probe,
 471         .priv_auto_alloc_size   = sizeof(struct stm32_pinctrl_priv),
 472 };