1 /* $OpenBSD: rkpmic.c,v 1.5 2018/04/07 22:35:27 kettenis Exp $ */ 2 /* 3 * Copyright (c) 2017 Mark Kettenis <kettenis@openbsd.org> 4 * 5 * Permission to use, copy, modify, and distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18 #include <sys/param.h> 19 #include <sys/systm.h> 20 #include <sys/device.h> 21 #include <sys/malloc.h> 22 23 #include <dev/ofw/openfirm.h> 24 #include <dev/ofw/ofw_regulator.h> 25 #include <dev/ofw/fdt.h> 26 27 #include <dev/i2c/i2cvar.h> 28 29 #include <dev/clock_subr.h> 30 31 extern todr_chip_handle_t todr_handle; 32 33 #define RK808_SECONDS 0x00 34 #define RK808_MINUTES 0x01 35 #define RK808_HOURS 0x02 36 #define RK808_DAYS 0x03 37 #define RK808_MONTHS 0x04 38 #define RK808_YEARS 0x05 39 #define RK808_WEEKS 0x06 40 #define RK808_RTC_CTRL 0x10 41 #define RK808_RTC_CTRL_STOP_RTC 0x01 42 #define RK808_RTC_STATUS 0x11 43 #define RK808_RTC_STATUS_POWER_UP 0x80 44 45 #define RK808_NRTC_REGS 7 46 47 struct rkpmic_regdata { 48 const char *name; 49 uint8_t reg, mask; 50 uint32_t base, delta; 51 }; 52 53 struct rkpmic_regdata rk805_regdata[] = { 54 { "DCDC_REG1", 0x2f, 0x3f, 712500, 12500 }, 55 { "DCDC_REG2", 0x33, 0x3f, 712500, 12500 }, 56 { "DCDC_REG4", 0x38, 0x1f, 800000, 100000 }, 57 { "LDO_REG1", 0x3b, 0x1f, 800000, 100000 }, 58 { "LDO_REG2", 0x3d, 0x1f, 800000, 100000 }, 59 { "LDO_REG3", 0x3f, 0x1f, 800000, 100000 }, 60 { } 61 }; 62 63 struct rkpmic_regdata rk808_regdata[] = { 64 { "DCDC_REG1", 0x2f, 0x3f, 712500, 12500 }, 65 { "DCDC_REG2", 0x33, 0x3f, 712500, 12500 }, 66 { "DCDC_REG4", 0x38, 0x0f, 1800000, 100000 }, 67 { "LDO_REG1", 0x3b, 0x1f, 1800000, 100000 }, 68 { "LDO_REG2", 0x3d, 0x1f, 1800000, 100000 }, 69 { "LDO_REG3", 0x3f, 0x0f, 800000, 100000 }, 70 { "LDO_REG4", 0x41, 0x1f, 1800000, 100000 }, 71 { "LDO_REG5", 0x43, 0x1f, 1800000, 100000 }, 72 { "LDO_REG6", 0x45, 0x1f, 800000, 100000 }, 73 { "LDO_REG7", 0x47, 0x1f, 800000, 100000 }, 74 { "LDO_REG8", 0x49, 0x1f, 1800000, 100000 }, 75 { } 76 }; 77 78 struct rkpmic_softc { 79 struct device sc_dev; 80 i2c_tag_t sc_tag; 81 i2c_addr_t sc_addr; 82 83 struct todr_chip_handle sc_todr; 84 struct rkpmic_regdata *sc_regdata; 85 }; 86 87 int rkpmic_match(struct device *, void *, void *); 88 void rkpmic_attach(struct device *, struct device *, void *); 89 90 struct cfattach rkpmic_ca = { 91 sizeof(struct rkpmic_softc), rkpmic_match, rkpmic_attach 92 }; 93 94 struct cfdriver rkpmic_cd = { 95 NULL, "rkpmic", DV_DULL 96 }; 97 98 void rkpmic_attach_regulator(struct rkpmic_softc *, int); 99 uint8_t rkpmic_reg_read(struct rkpmic_softc *, int); 100 void rkpmic_reg_write(struct rkpmic_softc *, int, uint8_t); 101 int rkpmic_clock_read(struct rkpmic_softc *, struct clock_ymdhms *); 102 int rkpmic_clock_write(struct rkpmic_softc *, struct clock_ymdhms *); 103 int rkpmic_gettime(struct todr_chip_handle *, struct timeval *); 104 int rkpmic_settime(struct todr_chip_handle *, struct timeval *); 105 106 int 107 rkpmic_match(struct device *parent, void *match, void *aux) 108 { 109 struct i2c_attach_args *ia = aux; 110 int node = *(int *)ia->ia_cookie; 111 112 return (OF_is_compatible(node, "rockchip,rk805") || 113 OF_is_compatible(node, "rockchip,rk808")); 114 } 115 116 void 117 rkpmic_attach(struct device *parent, struct device *self, void *aux) 118 { 119 struct rkpmic_softc *sc = (struct rkpmic_softc *)self; 120 struct i2c_attach_args *ia = aux; 121 int node = *(int *)ia->ia_cookie; 122 const char *chip; 123 124 sc->sc_tag = ia->ia_tag; 125 sc->sc_addr = ia->ia_addr; 126 127 sc->sc_todr.cookie = sc; 128 sc->sc_todr.todr_gettime = rkpmic_gettime; 129 sc->sc_todr.todr_settime = rkpmic_settime; 130 if (todr_handle == NULL) 131 todr_handle = &sc->sc_todr; 132 133 if (OF_is_compatible(node, "rockchip,rk805")) { 134 chip = "RK805"; 135 sc->sc_regdata = rk805_regdata; 136 } else { 137 chip = "RK808"; 138 sc->sc_regdata = rk808_regdata; 139 } 140 printf(": %s\n", chip); 141 142 node = OF_getnodebyname(node, "regulators"); 143 if (node == 0) 144 return; 145 for (node = OF_child(node); node; node = OF_peer(node)) 146 rkpmic_attach_regulator(sc, node); 147 } 148 149 struct rkpmic_regulator { 150 struct rkpmic_softc *rr_sc; 151 152 uint8_t rr_reg, rr_mask; 153 uint32_t rr_base, rr_delta; 154 155 struct regulator_device rr_rd; 156 }; 157 158 uint32_t rkpmic_get_voltage(void *); 159 160 void 161 rkpmic_attach_regulator(struct rkpmic_softc *sc, int node) 162 { 163 struct rkpmic_regulator *rr; 164 char name[32]; 165 int i; 166 167 name[0] = 0; 168 OF_getprop(node, "name", name, sizeof(name)); 169 name[sizeof(name) - 1] = 0; 170 for (i = 0; sc->sc_regdata[i].name; i++) { 171 if (strcmp(sc->sc_regdata[i].name, name) == 0) 172 break; 173 } 174 if (sc->sc_regdata[i].name == NULL) 175 return; 176 177 rr = malloc(sizeof(*rr), M_DEVBUF, M_WAITOK | M_ZERO); 178 rr->rr_sc = sc; 179 180 rr->rr_reg = sc->sc_regdata[i].reg; 181 rr->rr_mask = sc->sc_regdata[i].mask; 182 rr->rr_base = sc->sc_regdata[i].base; 183 rr->rr_delta = sc->sc_regdata[i].delta; 184 185 rr->rr_rd.rd_node = node; 186 rr->rr_rd.rd_cookie = rr; 187 rr->rr_rd.rd_get_voltage = rkpmic_get_voltage; 188 regulator_register(&rr->rr_rd); 189 } 190 191 uint32_t 192 rkpmic_get_voltage(void *cookie) 193 { 194 struct rkpmic_regulator *rr = cookie; 195 uint8_t value; 196 197 value = rkpmic_reg_read(rr->rr_sc, rr->rr_reg); 198 return rr->rr_base + (value & rr->rr_mask) * rr->rr_delta; 199 } 200 201 int 202 rkpmic_gettime(struct todr_chip_handle *handle, struct timeval *tv) 203 { 204 struct rkpmic_softc *sc = handle->cookie; 205 struct clock_ymdhms dt; 206 time_t secs; 207 int error; 208 209 error = rkpmic_clock_read(sc, &dt); 210 if (error) 211 return error; 212 213 if (dt.dt_sec > 59 || dt.dt_min > 59 || dt.dt_hour > 23 || 214 dt.dt_day > 31 || dt.dt_day == 0 || 215 dt.dt_mon > 12 || dt.dt_mon == 0 || 216 dt.dt_year < POSIX_BASE_YEAR) 217 return EINVAL; 218 219 /* 220 * The RTC thinks November has 31 days. Match what Linux does 221 * and undo the damage by considering the calenders to be in 222 * sync on January 1st 2016. 223 */ 224 secs = clock_ymdhms_to_secs(&dt); 225 secs += (dt.dt_year - 2016 + (dt.dt_mon == 12 ? 1 : 0)) * 86400; 226 227 tv->tv_sec = secs; 228 tv->tv_usec = 0; 229 return 0; 230 } 231 232 int 233 rkpmic_settime(struct todr_chip_handle *handle, struct timeval *tv) 234 { 235 struct rkpmic_softc *sc = handle->cookie; 236 struct clock_ymdhms dt; 237 time_t secs; 238 239 /* 240 * Take care of the November 31st braindamage here as well. 241 * Don't try to be clever, just do the conversion in two 242 * steps, first taking care of November 31 in previous years, 243 * and then taking care of days in December of the current 244 * year. Decmber 1st turns into November 31st! 245 */ 246 secs = tv->tv_sec; 247 clock_secs_to_ymdhms(secs, &dt); 248 secs -= (dt.dt_year - 2016) * 86400; 249 clock_secs_to_ymdhms(secs, &dt); 250 if (dt.dt_mon == 12) { 251 dt.dt_day--; 252 if (dt.dt_day == 0) { 253 dt.dt_mon = 11; 254 dt.dt_day = 31; 255 } 256 } 257 258 return rkpmic_clock_write(sc, &dt); 259 } 260 261 uint8_t 262 rkpmic_reg_read(struct rkpmic_softc *sc, int reg) 263 { 264 uint8_t cmd = reg; 265 uint8_t val; 266 int error; 267 268 iic_acquire_bus(sc->sc_tag, I2C_F_POLL); 269 error = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, 270 &cmd, sizeof cmd, &val, sizeof val, I2C_F_POLL); 271 iic_release_bus(sc->sc_tag, I2C_F_POLL); 272 273 if (error) { 274 printf("%s: can't read register 0x%02x\n", 275 sc->sc_dev.dv_xname, reg); 276 val = 0xff; 277 } 278 279 return val; 280 } 281 282 void 283 rkpmic_reg_write(struct rkpmic_softc *sc, int reg, uint8_t val) 284 { 285 uint8_t cmd = reg; 286 int error; 287 288 iic_acquire_bus(sc->sc_tag, I2C_F_POLL); 289 error = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_addr, 290 &cmd, sizeof cmd, &val, sizeof val, I2C_F_POLL); 291 iic_release_bus(sc->sc_tag, I2C_F_POLL); 292 293 if (error) { 294 printf("%s: can't write register 0x%02x\n", 295 sc->sc_dev.dv_xname, reg); 296 } 297 } 298 299 int 300 rkpmic_clock_read(struct rkpmic_softc *sc, struct clock_ymdhms *dt) 301 { 302 uint8_t regs[RK808_NRTC_REGS]; 303 uint8_t cmd = RK808_SECONDS; 304 uint8_t status; 305 int error; 306 307 iic_acquire_bus(sc->sc_tag, I2C_F_POLL); 308 error = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, 309 &cmd, sizeof(cmd), regs, RK808_NRTC_REGS, I2C_F_POLL); 310 iic_release_bus(sc->sc_tag, I2C_F_POLL); 311 312 if (error) { 313 printf("%s: can't read RTC\n", sc->sc_dev.dv_xname); 314 return error; 315 } 316 317 /* 318 * Convert the RK808's register values into something useable. 319 */ 320 dt->dt_sec = FROMBCD(regs[0]); 321 dt->dt_min = FROMBCD(regs[1]); 322 dt->dt_hour = FROMBCD(regs[2]); 323 dt->dt_day = FROMBCD(regs[3]); 324 dt->dt_mon = FROMBCD(regs[4]); 325 dt->dt_year = FROMBCD(regs[5]) + 2000; 326 327 /* Consider the time to be invalid if the POWER_UP bit is set. */ 328 status = rkpmic_reg_read(sc, RK808_RTC_STATUS); 329 if (status & RK808_RTC_STATUS_POWER_UP) 330 return EINVAL; 331 332 return 0; 333 } 334 335 int 336 rkpmic_clock_write(struct rkpmic_softc *sc, struct clock_ymdhms *dt) 337 { 338 uint8_t regs[RK808_NRTC_REGS]; 339 uint8_t cmd = RK808_SECONDS; 340 int error; 341 342 /* 343 * Convert our time representation into something the RK808 344 * can understand. 345 */ 346 regs[0] = TOBCD(dt->dt_sec); 347 regs[1] = TOBCD(dt->dt_min); 348 regs[2] = TOBCD(dt->dt_hour); 349 regs[3] = TOBCD(dt->dt_day); 350 regs[4] = TOBCD(dt->dt_mon); 351 regs[5] = TOBCD(dt->dt_year - 2000); 352 regs[6] = TOBCD(dt->dt_wday); 353 354 /* Stop RTC such that we can write to it. */ 355 rkpmic_reg_write(sc, RK808_RTC_CTRL, RK808_RTC_CTRL_STOP_RTC); 356 357 iic_acquire_bus(sc->sc_tag, I2C_F_POLL); 358 error = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_addr, 359 &cmd, sizeof(cmd), regs, RK808_NRTC_REGS, I2C_F_POLL); 360 iic_release_bus(sc->sc_tag, I2C_F_POLL); 361 362 /* Restart RTC. */ 363 rkpmic_reg_write(sc, RK808_RTC_CTRL, 0); 364 365 if (error) { 366 printf("%s: can't write RTC\n", sc->sc_dev.dv_xname); 367 return error; 368 } 369 370 /* Clear POWER_UP bit to indicate the time is now valid. */ 371 rkpmic_reg_write(sc, RK808_RTC_STATUS, RK808_RTC_STATUS_POWER_UP); 372 373 return 0; 374 } 375