1 /* 2 * (C) Copyright 2016 Texas Instruments Incorporated, <www.ti.com> 3 * Jean-Jacques Hiblot <jjhiblot@ti.com> 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <errno.h> 10 #include <dm.h> 11 #include <power/pmic.h> 12 #include <power/regulator.h> 13 #include <regmap.h> 14 #include <syscon.h> 15 #include <linux/bitops.h> 16 #include <linux/ioport.h> 17 #include <dm/read.h> 18 19 struct pbias_reg_info { 20 u32 enable; 21 u32 enable_mask; 22 u32 disable_val; 23 u32 vmode; 24 unsigned int enable_time; 25 char *name; 26 }; 27 28 struct pbias_priv { 29 struct regmap *regmap; 30 int offset; 31 }; 32 33 static const struct pmic_child_info pmic_children_info[] = { 34 { .prefix = "pbias", .driver = "pbias_regulator"}, 35 { }, 36 }; 37 38 static int pbias_write(struct udevice *dev, uint reg, const uint8_t *buff, 39 int len) 40 { 41 struct pbias_priv *priv = dev_get_priv(dev); 42 u32 val = *(u32 *)buff; 43 44 if (len != 4) 45 return -EINVAL; 46 47 return regmap_write(priv->regmap, priv->offset, val); 48 } 49 50 static int pbias_read(struct udevice *dev, uint reg, uint8_t *buff, int len) 51 { 52 struct pbias_priv *priv = dev_get_priv(dev); 53 54 if (len != 4) 55 return -EINVAL; 56 57 return regmap_read(priv->regmap, priv->offset, (u32 *)buff); 58 } 59 60 static int pbias_ofdata_to_platdata(struct udevice *dev) 61 { 62 struct pbias_priv *priv = dev_get_priv(dev); 63 struct udevice *syscon; 64 struct regmap *regmap; 65 struct resource res; 66 int err; 67 68 err = uclass_get_device_by_phandle(UCLASS_SYSCON, dev, 69 "syscon", &syscon); 70 if (err) { 71 pr_err("%s: unable to find syscon device (%d)\n", __func__, 72 err); 73 return err; 74 } 75 76 regmap = syscon_get_regmap(syscon); 77 if (IS_ERR(regmap)) { 78 pr_err("%s: unable to find regmap (%ld)\n", __func__, 79 PTR_ERR(regmap)); 80 return PTR_ERR(regmap); 81 } 82 priv->regmap = regmap; 83 84 err = dev_read_resource(dev, 0, &res); 85 if (err) { 86 pr_err("%s: unable to find offset (%d)\n", __func__, err); 87 return err; 88 } 89 priv->offset = res.start; 90 91 return 0; 92 } 93 94 static int pbias_bind(struct udevice *dev) 95 { 96 int children; 97 98 children = pmic_bind_children(dev, dev->node, pmic_children_info); 99 if (!children) 100 debug("%s: %s - no child found\n", __func__, dev->name); 101 102 return 0; 103 } 104 105 static struct dm_pmic_ops pbias_ops = { 106 .read = pbias_read, 107 .write = pbias_write, 108 }; 109 110 static const struct udevice_id pbias_ids[] = { 111 { .compatible = "ti,pbias-dra7" }, 112 { } 113 }; 114 115 U_BOOT_DRIVER(pbias_pmic) = { 116 .name = "pbias_pmic", 117 .id = UCLASS_PMIC, 118 .of_match = pbias_ids, 119 .bind = pbias_bind, 120 .ops = &pbias_ops, 121 .ofdata_to_platdata = pbias_ofdata_to_platdata, 122 .priv_auto_alloc_size = sizeof(struct pbias_priv), 123 }; 124 125 static const struct pbias_reg_info pbias_mmc_omap2430 = { 126 .enable = BIT(1), 127 .enable_mask = BIT(1), 128 .vmode = BIT(0), 129 .disable_val = 0, 130 .enable_time = 100, 131 .name = "pbias_mmc_omap2430" 132 }; 133 134 static const struct pbias_reg_info pbias_sim_omap3 = { 135 .enable = BIT(9), 136 .enable_mask = BIT(9), 137 .vmode = BIT(8), 138 .enable_time = 100, 139 .name = "pbias_sim_omap3" 140 }; 141 142 static const struct pbias_reg_info pbias_mmc_omap4 = { 143 .enable = BIT(26) | BIT(22), 144 .enable_mask = BIT(26) | BIT(25) | BIT(22), 145 .disable_val = BIT(25), 146 .vmode = BIT(21), 147 .enable_time = 100, 148 .name = "pbias_mmc_omap4" 149 }; 150 151 static const struct pbias_reg_info pbias_mmc_omap5 = { 152 .enable = BIT(27) | BIT(26), 153 .enable_mask = BIT(27) | BIT(25) | BIT(26), 154 .disable_val = BIT(25), 155 .vmode = BIT(21), 156 .enable_time = 100, 157 .name = "pbias_mmc_omap5" 158 }; 159 160 static const struct pbias_reg_info *pbias_reg_infos[] = { 161 &pbias_mmc_omap5, 162 &pbias_mmc_omap4, 163 &pbias_sim_omap3, 164 &pbias_mmc_omap2430, 165 NULL 166 }; 167 168 static int pbias_regulator_probe(struct udevice *dev) 169 { 170 const struct pbias_reg_info **p = pbias_reg_infos; 171 struct dm_regulator_uclass_platdata *uc_pdata; 172 173 uc_pdata = dev_get_uclass_platdata(dev); 174 175 while (*p) { 176 int rc; 177 178 rc = dev_read_stringlist_search(dev, "regulator-name", 179 (*p)->name); 180 if (rc >= 0) { 181 debug("found regulator %s\n", (*p)->name); 182 break; 183 } else if (rc != -ENODATA) { 184 return rc; 185 } 186 p++; 187 } 188 if (!*p) { 189 int i = 0; 190 const char *s; 191 192 debug("regulator "); 193 while (dev_read_string_index(dev, "regulator-name", i++, &s) >= 0) 194 debug("%s'%s' ", (i > 1) ? ", " : "", s); 195 debug("%s not supported\n", (i > 2) ? "are" : "is"); 196 return -EINVAL; 197 } 198 199 uc_pdata->type = REGULATOR_TYPE_OTHER; 200 dev->priv = (void *)*p; 201 202 return 0; 203 } 204 205 static int pbias_regulator_get_value(struct udevice *dev) 206 { 207 const struct pbias_reg_info *p = dev_get_priv(dev); 208 int rc; 209 u32 reg; 210 211 rc = pmic_read(dev->parent, 0, (uint8_t *)®, sizeof(reg)); 212 if (rc) 213 return rc; 214 215 debug("%s voltage id %s\n", p->name, 216 (reg & p->vmode) ? "3.0v" : "1.8v"); 217 return (reg & p->vmode) ? 3000000 : 1800000; 218 } 219 220 static int pbias_regulator_set_value(struct udevice *dev, int uV) 221 { 222 const struct pbias_reg_info *p = dev_get_priv(dev); 223 int rc; 224 u32 reg; 225 226 rc = pmic_read(dev->parent, 0, (uint8_t *)®, sizeof(reg)); 227 if (rc) 228 return rc; 229 230 if (uV == 3000000) 231 reg |= p->vmode; 232 else if (uV == 1800000) 233 reg &= ~p->vmode; 234 else 235 return -EINVAL; 236 237 debug("Setting %s voltage to %s\n", p->name, 238 (reg & p->vmode) ? "3.0v" : "1.8v"); 239 240 return pmic_write(dev->parent, 0, (uint8_t *)®, sizeof(reg)); 241 } 242 243 static int pbias_regulator_get_enable(struct udevice *dev) 244 { 245 const struct pbias_reg_info *p = dev_get_priv(dev); 246 int rc; 247 u32 reg; 248 249 rc = pmic_read(dev->parent, 0, (uint8_t *)®, sizeof(reg)); 250 if (rc) 251 return rc; 252 253 debug("%s id %s\n", p->name, 254 (reg & p->enable_mask) == (p->disable_val) ? "on" : "off"); 255 256 return (reg & p->enable_mask) == (p->disable_val); 257 } 258 259 static int pbias_regulator_set_enable(struct udevice *dev, bool enable) 260 { 261 const struct pbias_reg_info *p = dev_get_priv(dev); 262 int rc; 263 u32 reg; 264 265 debug("Turning %s %s\n", enable ? "on" : "off", p->name); 266 267 rc = pmic_read(dev->parent, 0, (uint8_t *)®, sizeof(reg)); 268 if (rc) 269 return rc; 270 271 reg &= ~p->enable_mask; 272 if (enable) 273 reg |= p->enable; 274 else 275 reg |= p->disable_val; 276 277 rc = pmic_write(dev->parent, 0, (uint8_t *)®, sizeof(reg)); 278 if (rc) 279 return rc; 280 281 if (enable) 282 udelay(p->enable_time); 283 284 return 0; 285 } 286 287 static const struct dm_regulator_ops pbias_regulator_ops = { 288 .get_value = pbias_regulator_get_value, 289 .set_value = pbias_regulator_set_value, 290 .get_enable = pbias_regulator_get_enable, 291 .set_enable = pbias_regulator_set_enable, 292 }; 293 294 U_BOOT_DRIVER(pbias_regulator) = { 295 .name = "pbias_regulator", 296 .id = UCLASS_REGULATOR, 297 .ops = &pbias_regulator_ops, 298 .probe = pbias_regulator_probe, 299 }; 300