drivers/pinctrl/pinctrl-sti.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Pinctrl driver for STMicroelectronics STi SoCs
   4  *
   5  * Copyright (C) 2017, STMicroelectronics - All Rights Reserved
   6  * Author(s): Patrice Chotard, <patrice.chotard@st.com> for STMicroelectronics.
   7  */
   8
   9 #include <common.h>
  10 #include <bitfield.h>
  11 #include <dm.h>
  12 #include <errno.h>
  13 #include <regmap.h>
  14 #include <syscon.h>
  15 #include <asm/io.h>
  16 #include <dm/pinctrl.h>
  17
  18 DECLARE_GLOBAL_DATA_PTR;
  19
  20 #define MAX_STI_PINCONF_ENTRIES         7
  21 /* Output enable */
  22 #define OE                      (1 << 27)
  23 /* Pull Up */
  24 #define PU                      (1 << 26)
  25 /* Open Drain */
  26 #define OD                      (1 << 25)
  27
  28 /* User-frendly defines for Pin Direction */
  29                 /* oe = 0, pu = 0, od = 0 */
  30 #define IN                      (0)
  31                 /* oe = 0, pu = 1, od = 0 */
  32 #define IN_PU                   (PU)
  33                 /* oe = 1, pu = 0, od = 0 */
  34 #define OUT                     (OE)
  35                 /* oe = 1, pu = 1, od = 0 */
  36 #define OUT_PU                  (OE | PU)
  37                 /* oe = 1, pu = 0, od = 1 */
  38 #define BIDIR                   (OE | OD)
  39                 /* oe = 1, pu = 1, od = 1 */
  40 #define BIDIR_PU                (OE | PU | OD)
  41
  42 struct sti_pinctrl_platdata {
  43         struct regmap *regmap;
  44 };
  45
  46 struct sti_pin_desc {
  47         unsigned char bank;
  48         unsigned char pin;
  49         unsigned char alt;
  50         int dir;
  51 };
  52
  53 /*
  54  * PIO alternative Function selector
  55  */
  56 void sti_alternate_select(struct udevice *dev, struct sti_pin_desc *pin_desc)
  57 {
  58         struct sti_pinctrl_platdata *plat = dev_get_platdata(dev);
  59         unsigned long sysconf, *sysconfreg;
  60         int alt = pin_desc->alt;
  61         int bank = pin_desc->bank;
  62         int pin = pin_desc->pin;
  63
  64         sysconfreg = (unsigned long *)plat->regmap->ranges[0].start;
  65
  66         switch (bank) {
  67         case 0 ... 5:           /* in "SBC Bank" */
  68                 sysconfreg += bank;
  69                 break;
  70         case 10 ... 20:         /* in "FRONT Bank" */
  71                 sysconfreg += bank - 10;
  72                 break;
  73         case 30 ... 35:         /* in "REAR Bank" */
  74                 sysconfreg += bank - 30;
  75                 break;
  76         case 40 ... 42:         /* in "FLASH Bank" */
  77                 sysconfreg += bank - 40;
  78                 break;
  79         default:
  80                 BUG();
  81                 return;
  82         }
  83
  84         sysconf = readl(sysconfreg);
  85         sysconf = bitfield_replace(sysconf, pin * 4, 3, alt);
  86         writel(sysconf, sysconfreg);
  87 }
  88
  89 /* pin configuration */
  90 void sti_pin_configure(struct udevice *dev, struct sti_pin_desc *pin_desc)
  91 {
  92         struct sti_pinctrl_platdata *plat = dev_get_platdata(dev);
  93         int bit;
  94         int oe = 0, pu = 0, od = 0;
  95         unsigned long *sysconfreg;
  96         int bank = pin_desc->bank;
  97
  98         sysconfreg = (unsigned long *)plat->regmap->ranges[0].start + 40;
  99
 100         /*
 101          * NOTE: The PIO configuration for the PIO pins in the
 102          * "FLASH Bank" are different from all the other banks!
 103          * Specifically, the output-enable pin control register
 104          * (SYS_CFG_3040) and the pull-up pin control register
 105          * (SYS_CFG_3050), are both classed as being "reserved".
 106          * Hence, we do not write to these registers to configure
 107          * the OE and PU features for PIOs in this bank. However,
 108          * the open-drain pin control register (SYS_CFG_3060)
 109          * follows the style of the other banks, and so we can
 110          * treat that register normally.
 111          *
 112          * Being pedantic, we should configure the PU and PD features
 113          * in the "FLASH Bank" explicitly instead using the four
 114          * SYS_CFG registers: 3080, 3081, 3085, and 3086. However, this
 115          * would necessitate passing in the alternate function number
 116          * to this function, and adding some horrible complexity here.
 117          * Alternatively, we could just perform 4 32-bit "pokes" to
 118          * these four SYS_CFG registers early in the initialization.
 119          * In practice, these four SYS_CFG registers are correct
 120          * after a reset, and U-Boot does not need to change them, so
 121          * we (cheat and) rely on these registers being correct.
 122          * WARNING: Please be aware of this (pragmatic) behaviour!
 123          */
 124         int flashss = 0;        /* bool: PIO in the Flash Sub-System ? */
 125
 126         switch (pin_desc->dir) {
 127         case IN:
 128                 oe = 0; pu = 0; od = 0;
 129                 break;
 130         case IN_PU:
 131                 oe = 0; pu = 1; od = 0;
 132                 break;
 133         case OUT:
 134                 oe = 1; pu = 0; od = 0;
 135                 break;
 136         case BIDIR:
 137                 oe = 1; pu = 0; od = 1;
 138                 break;
 139         case BIDIR_PU:
 140                 oe = 1; pu = 1; od = 1;
 141                 break;
 142
 143         default:
 144                 pr_err("%s invalid direction value: 0x%x\n",
 145                       __func__, pin_desc->dir);
 146                 BUG();
 147                 break;
 148         }
 149
 150         switch (bank) {
 151         case 0 ... 5:           /* in "SBC Bank" */
 152                 sysconfreg += bank / 4;
 153                 break;
 154         case 10 ... 20:         /* in "FRONT Bank" */
 155                 bank -= 10;
 156                 sysconfreg += bank / 4;
 157                 break;
 158         case 30 ... 35:         /* in "REAR Bank" */
 159                 bank -= 30;
 160                 sysconfreg += bank / 4;
 161                 break;
 162         case 40 ... 42:         /* in "FLASH Bank" */
 163                 bank -= 40;
 164                 sysconfreg += bank / 4;
 165                 flashss = 1;    /* pin is in the Flash Sub-System */
 166                 break;
 167         default:
 168                 BUG();
 169                 return;
 170         }
 171
 172         bit = ((bank * 8) + pin_desc->pin) % 32;
 173
 174         /*
 175          * set the "Output Enable" pin control
 176          * but, do nothing if in the flashSS
 177          */
 178         if (!flashss) {
 179                 if (oe)
 180                         generic_set_bit(bit, sysconfreg);
 181                 else
 182                         generic_clear_bit(bit, sysconfreg);
 183         }
 184
 185         sysconfreg += 10;       /* skip to next set of syscfg registers */
 186
 187         /*
 188          * set the "Pull Up" pin control
 189          * but, do nothing if in the FlashSS
 190          */
 191
 192         if (!flashss) {
 193                 if (pu)
 194                         generic_set_bit(bit, sysconfreg);
 195                 else
 196                         generic_clear_bit(bit, sysconfreg);
 197         }
 198
 199         sysconfreg += 10;       /* skip to next set of syscfg registers */
 200
 201         /* set the "Open Drain Enable" pin control */
 202         if (od)
 203                 generic_set_bit(bit, sysconfreg);
 204         else
 205                 generic_clear_bit(bit, sysconfreg);
 206 }
 207
 208
 209 static int sti_pinctrl_set_state(struct udevice *dev, struct udevice *config)
 210 {
 211         struct fdtdec_phandle_args args;
 212         const void *blob = gd->fdt_blob;
 213         const char *prop_name;
 214         int node = dev_of_offset(config);
 215         int property_offset, prop_len;
 216         int pinconf_node, ret, count;
 217         const char *bank_name;
 218         u32 cells[MAX_STI_PINCONF_ENTRIES];
 219
 220         struct sti_pin_desc pin_desc;
 221
 222         /* go to next node "st,pins" which contains the pins configuration */
 223         pinconf_node = fdt_subnode_offset(blob, node, "st,pins");
 224
 225         /*
 226          * parse each pins configuration which looks like :
 227          *      pin_name = <bank_phandle pin_nb alt dir rt_type rt_delay rt_clk>
 228          */
 229
 230         fdt_for_each_property_offset(property_offset, blob, pinconf_node) {
 231                 fdt_getprop_by_offset(blob, property_offset, &prop_name,
 232                                       &prop_len);
 233
 234                 /* extract the bank of the pin description */
 235                 ret = fdtdec_parse_phandle_with_args(blob, pinconf_node,
 236                                                      prop_name, "#gpio-cells",
 237                                                      0, 0, &args);
 238                 if (ret < 0) {
 239                         pr_err("Can't get the gpio bank phandle: %d\n", ret);
 240                         return ret;
 241                 }
 242
 243                 bank_name = fdt_getprop(blob, args.node, "st,bank-name",
 244                                         &count);
 245                 if (count < 0) {
 246                         pr_err("Can't find bank-name property %d\n", count);
 247                         return -EINVAL;
 248                 }
 249
 250                 pin_desc.bank = trailing_strtoln(bank_name, NULL);
 251
 252                 count = fdtdec_get_int_array_count(blob, pinconf_node,
 253                                                    prop_name, cells,
 254                                                    ARRAY_SIZE(cells));
 255                 if (count < 0) {
 256                         pr_err("Bad pin configuration array %d\n", count);
 257                         return -EINVAL;
 258                 }
 259
 260                 if (count > MAX_STI_PINCONF_ENTRIES) {
 261                         pr_err("Unsupported pinconf array count %d\n", count);
 262                         return -EINVAL;
 263                 }
 264
 265                 pin_desc.pin = cells[1];
 266                 pin_desc.alt = cells[2];
 267                 pin_desc.dir = cells[3];
 268
 269                 sti_alternate_select(dev, &pin_desc);
 270                 sti_pin_configure(dev, &pin_desc);
 271         };
 272
 273         return 0;
 274 }
 275
 276 static int sti_pinctrl_probe(struct udevice *dev)
 277 {
 278         struct sti_pinctrl_platdata *plat = dev_get_platdata(dev);
 279         struct udevice *syscon;
 280         int err;
 281
 282         /* get corresponding syscon phandle */
 283         err = uclass_get_device_by_phandle(UCLASS_SYSCON, dev,
 284                                            "st,syscfg", &syscon);
 285         if (err) {
 286                 pr_err("unable to find syscon device\n");
 287                 return err;
 288         }
 289
 290         plat->regmap = syscon_get_regmap(syscon);
 291         if (!plat->regmap) {
 292                 pr_err("unable to find regmap\n");
 293                 return -ENODEV;
 294         }
 295
 296         return 0;
 297 }
 298
 299 static const struct udevice_id sti_pinctrl_ids[] = {
 300         { .compatible = "st,stih407-sbc-pinctrl" },
 301         { .compatible = "st,stih407-front-pinctrl" },
 302         { .compatible = "st,stih407-rear-pinctrl" },
 303         { .compatible = "st,stih407-flash-pinctrl" },
 304         { }
 305 };
 306
 307 const struct pinctrl_ops sti_pinctrl_ops = {
 308         .set_state = sti_pinctrl_set_state,
 309 };
 310
 311 U_BOOT_DRIVER(pinctrl_sti) = {
 312         .name = "pinctrl_sti",
 313         .id = UCLASS_PINCTRL,
 314         .of_match = sti_pinctrl_ids,
 315         .ops = &sti_pinctrl_ops,
 316         .probe = sti_pinctrl_probe,
 317         .platdata_auto_alloc_size = sizeof(struct sti_pinctrl_platdata),
 318         .ops = &sti_pinctrl_ops,
 319 };