1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2016 - Beniamino Galvani <b.galvani@gmail.com> 4 */ 5 6 #include <common.h> 7 #include <dm.h> 8 #include <dm/device-internal.h> 9 #include <dm/lists.h> 10 #include <dm/pinctrl.h> 11 #include <fdt_support.h> 12 #include <linux/err.h> 13 #include <linux/io.h> 14 #include <linux/sizes.h> 15 #include <asm/gpio.h> 16 17 #include "pinctrl-meson.h" 18 19 DECLARE_GLOBAL_DATA_PTR; 20 21 static const char *meson_pinctrl_dummy_name = "_dummy"; 22 23 int meson_pinctrl_get_groups_count(struct udevice *dev) 24 { 25 struct meson_pinctrl *priv = dev_get_priv(dev); 26 27 return priv->data->num_groups; 28 } 29 30 const char *meson_pinctrl_get_group_name(struct udevice *dev, 31 unsigned int selector) 32 { 33 struct meson_pinctrl *priv = dev_get_priv(dev); 34 35 if (!priv->data->groups[selector].name) 36 return meson_pinctrl_dummy_name; 37 38 return priv->data->groups[selector].name; 39 } 40 41 int meson_pinmux_get_functions_count(struct udevice *dev) 42 { 43 struct meson_pinctrl *priv = dev_get_priv(dev); 44 45 return priv->data->num_funcs; 46 } 47 48 const char *meson_pinmux_get_function_name(struct udevice *dev, 49 unsigned int selector) 50 { 51 struct meson_pinctrl *priv = dev_get_priv(dev); 52 53 return priv->data->funcs[selector].name; 54 } 55 56 static int meson_gpio_calc_reg_and_bit(struct udevice *dev, unsigned int offset, 57 enum meson_reg_type reg_type, 58 unsigned int *reg, unsigned int *bit) 59 { 60 struct meson_pinctrl *priv = dev_get_priv(dev->parent); 61 struct meson_bank *bank = NULL; 62 struct meson_reg_desc *desc; 63 unsigned int pin; 64 int i; 65 66 pin = priv->data->pin_base + offset; 67 68 for (i = 0; i < priv->data->num_banks; i++) { 69 if (pin >= priv->data->banks[i].first && 70 pin <= priv->data->banks[i].last) { 71 bank = &priv->data->banks[i]; 72 break; 73 } 74 } 75 76 if (!bank) 77 return -EINVAL; 78 79 desc = &bank->regs[reg_type]; 80 *reg = desc->reg * 4; 81 *bit = desc->bit + pin - bank->first; 82 83 return 0; 84 } 85 86 int meson_gpio_get(struct udevice *dev, unsigned int offset) 87 { 88 struct meson_pinctrl *priv = dev_get_priv(dev->parent); 89 unsigned int reg, bit; 90 int ret; 91 92 ret = meson_gpio_calc_reg_and_bit(dev, offset, REG_IN, ®, &bit); 93 if (ret) 94 return ret; 95 96 return !!(readl(priv->reg_gpio + reg) & BIT(bit)); 97 } 98 99 int meson_gpio_set(struct udevice *dev, unsigned int offset, int value) 100 { 101 struct meson_pinctrl *priv = dev_get_priv(dev->parent); 102 unsigned int reg, bit; 103 int ret; 104 105 ret = meson_gpio_calc_reg_and_bit(dev, offset, REG_OUT, ®, &bit); 106 if (ret) 107 return ret; 108 109 clrsetbits_le32(priv->reg_gpio + reg, BIT(bit), value ? BIT(bit) : 0); 110 111 return 0; 112 } 113 114 int meson_gpio_get_direction(struct udevice *dev, unsigned int offset) 115 { 116 struct meson_pinctrl *priv = dev_get_priv(dev->parent); 117 unsigned int reg, bit, val; 118 int ret; 119 120 ret = meson_gpio_calc_reg_and_bit(dev, offset, REG_DIR, ®, &bit); 121 if (ret) 122 return ret; 123 124 val = readl(priv->reg_gpio + reg); 125 126 return (val & BIT(bit)) ? GPIOF_INPUT : GPIOF_OUTPUT; 127 } 128 129 int meson_gpio_direction_input(struct udevice *dev, unsigned int offset) 130 { 131 struct meson_pinctrl *priv = dev_get_priv(dev->parent); 132 unsigned int reg, bit; 133 int ret; 134 135 ret = meson_gpio_calc_reg_and_bit(dev, offset, REG_DIR, ®, &bit); 136 if (ret) 137 return ret; 138 139 clrsetbits_le32(priv->reg_gpio + reg, BIT(bit), 1); 140 141 return 0; 142 } 143 144 int meson_gpio_direction_output(struct udevice *dev, 145 unsigned int offset, int value) 146 { 147 struct meson_pinctrl *priv = dev_get_priv(dev->parent); 148 unsigned int reg, bit; 149 int ret; 150 151 ret = meson_gpio_calc_reg_and_bit(dev, offset, REG_DIR, ®, &bit); 152 if (ret) 153 return ret; 154 155 clrsetbits_le32(priv->reg_gpio + reg, BIT(bit), 0); 156 157 ret = meson_gpio_calc_reg_and_bit(dev, offset, REG_OUT, ®, &bit); 158 if (ret) 159 return ret; 160 161 clrsetbits_le32(priv->reg_gpio + reg, BIT(bit), value ? BIT(bit) : 0); 162 163 return 0; 164 } 165 166 int meson_gpio_probe(struct udevice *dev) 167 { 168 struct meson_pinctrl *priv = dev_get_priv(dev->parent); 169 struct gpio_dev_priv *uc_priv; 170 171 uc_priv = dev_get_uclass_priv(dev); 172 uc_priv->bank_name = priv->data->name; 173 uc_priv->gpio_count = priv->data->num_pins; 174 175 return 0; 176 } 177 178 static fdt_addr_t parse_address(int offset, const char *name, int na, int ns) 179 { 180 int index, len = 0; 181 const fdt32_t *reg; 182 183 index = fdt_stringlist_search(gd->fdt_blob, offset, "reg-names", name); 184 if (index < 0) 185 return FDT_ADDR_T_NONE; 186 187 reg = fdt_getprop(gd->fdt_blob, offset, "reg", &len); 188 if (!reg || (len <= (index * sizeof(fdt32_t) * (na + ns)))) 189 return FDT_ADDR_T_NONE; 190 191 reg += index * (na + ns); 192 193 return fdt_translate_address((void *)gd->fdt_blob, offset, reg); 194 } 195 196 int meson_pinctrl_probe(struct udevice *dev) 197 { 198 struct meson_pinctrl *priv = dev_get_priv(dev); 199 struct uclass_driver *drv; 200 struct udevice *gpio_dev; 201 fdt_addr_t addr; 202 int node, gpio = -1, len; 203 int na, ns; 204 char *name; 205 206 na = fdt_address_cells(gd->fdt_blob, dev_of_offset(dev->parent)); 207 if (na < 1) { 208 debug("bad #address-cells\n"); 209 return -EINVAL; 210 } 211 212 ns = fdt_size_cells(gd->fdt_blob, dev_of_offset(dev->parent)); 213 if (ns < 1) { 214 debug("bad #size-cells\n"); 215 return -EINVAL; 216 } 217 218 fdt_for_each_subnode(node, gd->fdt_blob, dev_of_offset(dev)) { 219 if (fdt_getprop(gd->fdt_blob, node, "gpio-controller", &len)) { 220 gpio = node; 221 break; 222 } 223 } 224 225 if (!gpio) { 226 debug("gpio node not found\n"); 227 return -EINVAL; 228 } 229 230 addr = parse_address(gpio, "mux", na, ns); 231 if (addr == FDT_ADDR_T_NONE) { 232 debug("mux address not found\n"); 233 return -EINVAL; 234 } 235 priv->reg_mux = (void __iomem *)addr; 236 237 addr = parse_address(gpio, "gpio", na, ns); 238 if (addr == FDT_ADDR_T_NONE) { 239 debug("gpio address not found\n"); 240 return -EINVAL; 241 } 242 priv->reg_gpio = (void __iomem *)addr; 243 priv->data = (struct meson_pinctrl_data *)dev_get_driver_data(dev); 244 245 /* Lookup GPIO driver */ 246 drv = lists_uclass_lookup(UCLASS_GPIO); 247 if (!drv) { 248 puts("Cannot find GPIO driver\n"); 249 return -ENOENT; 250 } 251 252 name = calloc(1, 32); 253 sprintf(name, "meson-gpio"); 254 255 /* Create child device UCLASS_GPIO and bind it */ 256 device_bind(dev, priv->data->gpio_driver, name, NULL, gpio, &gpio_dev); 257 dev_set_of_offset(gpio_dev, gpio); 258 259 return 0; 260 } 261