1 /* 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2023 Jari Sihvola <jsihv@gmx.com> 5 */ 6 7 #include <sys/cdefs.h> 8 9 #include <sys/param.h> 10 #include <sys/systm.h> 11 #include <sys/bus.h> 12 13 #include <sys/gpio.h> 14 #include <sys/kernel.h> 15 #include <sys/lock.h> 16 #include <sys/module.h> 17 #include <sys/mutex.h> 18 #include <sys/rman.h> 19 20 #include <machine/bus.h> 21 #include <machine/intr.h> 22 #include <machine/resource.h> 23 24 #include <dev/clk/clk.h> 25 #include <dev/gpio/gpiobusvar.h> 26 #include <dev/ofw/ofw_bus.h> 27 #include <dev/ofw/ofw_bus_subr.h> 28 29 #include "gpio_if.h" 30 31 #define GPIO_PINS 64 32 #define GPIO_REGS 2 33 34 #define GP0_DOEN_CFG 0x0 35 #define GP0_DOUT_CFG 0x40 36 #define GPIOEN 0xdc 37 #define GPIOE_0 0x100 38 #define GPIOE_1 0x104 39 #define GPIO_DIN_LOW 0x118 40 #define GPIO_DIN_HIGH 0x11c 41 #define IOMUX_SYSCFG_288 0x120 42 43 #define PAD_INPUT_EN (1 << 0) 44 #define PAD_PULLUP (1 << 3) 45 #define PAD_PULLDOWN (1 << 4) 46 #define PAD_HYST (1 << 6) 47 48 #define ENABLE_MASK 0x3f 49 #define DATA_OUT_MASK 0x7f 50 #define DIROUT_DISABLE 1 51 52 struct jh7110_gpio_softc { 53 device_t dev; 54 device_t busdev; 55 struct mtx mtx; 56 struct resource *res; 57 clk_t clk; 58 }; 59 60 static struct ofw_compat_data compat_data[] = { 61 {"starfive,jh7110-sys-pinctrl", 1}, 62 {NULL, 0} 63 }; 64 65 static struct resource_spec jh7110_gpio_spec[] = { 66 { SYS_RES_MEMORY, 0, RF_ACTIVE }, 67 { -1, 0 } 68 }; 69 70 #define GPIO_RW_OFFSET(_val) (_val & ~3) 71 #define GPIO_SHIFT(_val) ((_val & 3) * 8) 72 #define PAD_OFFSET(_val) (_val * 4) 73 74 #define JH7110_GPIO_LOCK(_sc) mtx_lock(&(_sc)->mtx) 75 #define JH7110_GPIO_UNLOCK(_sc) mtx_unlock(&(_sc)->mtx) 76 77 #define JH7110_GPIO_READ(sc, reg) bus_read_4((sc)->res, (reg)) 78 #define JH7110_GPIO_WRITE(sc, reg, val) bus_write_4((sc)->res, (reg), (val)) 79 80 static device_t 81 jh7110_gpio_get_bus(device_t dev) 82 { 83 struct jh7110_gpio_softc *sc; 84 85 sc = device_get_softc(dev); 86 87 return (sc->busdev); 88 } 89 90 static int 91 jh7110_gpio_pin_max(device_t dev, int *maxpin) 92 { 93 *maxpin = GPIO_PINS - 1; 94 95 return (0); 96 } 97 98 static int 99 jh7110_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val) 100 { 101 struct jh7110_gpio_softc *sc; 102 uint32_t reg; 103 104 sc = device_get_softc(dev); 105 106 if (pin >= GPIO_PINS) 107 return (EINVAL); 108 109 JH7110_GPIO_LOCK(sc); 110 if (pin < GPIO_PINS / GPIO_REGS) { 111 reg = JH7110_GPIO_READ(sc, GPIO_DIN_LOW); 112 *val = (reg >> pin) & 0x1; 113 } else { 114 reg = JH7110_GPIO_READ(sc, GPIO_DIN_HIGH); 115 *val = (reg >> (pin - GPIO_PINS / GPIO_REGS)) & 0x1; 116 } 117 JH7110_GPIO_UNLOCK(sc); 118 119 return (0); 120 } 121 122 static int 123 jh7110_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value) 124 { 125 struct jh7110_gpio_softc *sc; 126 uint32_t reg; 127 128 sc = device_get_softc(dev); 129 130 if (pin >= GPIO_PINS) 131 return (EINVAL); 132 133 JH7110_GPIO_LOCK(sc); 134 reg = JH7110_GPIO_READ(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin)); 135 reg &= ~(DATA_OUT_MASK << GPIO_SHIFT(pin)); 136 if (value) 137 reg |= 0x1 << GPIO_SHIFT(pin); 138 JH7110_GPIO_WRITE(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin), reg); 139 JH7110_GPIO_UNLOCK(sc); 140 141 return (0); 142 } 143 144 static int 145 jh7110_gpio_pin_toggle(device_t dev, uint32_t pin) 146 { 147 struct jh7110_gpio_softc *sc; 148 uint32_t reg; 149 150 sc = device_get_softc(dev); 151 152 if (pin >= GPIO_PINS) 153 return (EINVAL); 154 155 JH7110_GPIO_LOCK(sc); 156 reg = JH7110_GPIO_READ(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin)); 157 if (reg & 0x1 << GPIO_SHIFT(pin)) { 158 reg &= ~(DATA_OUT_MASK << GPIO_SHIFT(pin)); 159 } else { 160 reg &= ~(DATA_OUT_MASK << GPIO_SHIFT(pin)); 161 reg |= 0x1 << GPIO_SHIFT(pin); 162 } 163 JH7110_GPIO_WRITE(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin), reg); 164 JH7110_GPIO_UNLOCK(sc); 165 166 return (0); 167 } 168 169 static int 170 jh7110_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps) 171 { 172 if (pin >= GPIO_PINS) 173 return (EINVAL); 174 175 *caps = (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT); 176 177 return (0); 178 } 179 180 static int 181 jh7110_gpio_pin_getname(device_t dev, uint32_t pin, char *name) 182 { 183 if (pin >= GPIO_PINS) 184 return (EINVAL); 185 186 snprintf(name, GPIOMAXNAME, "GPIO%d", pin); 187 188 return (0); 189 } 190 191 static int 192 jh7110_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags) 193 { 194 struct jh7110_gpio_softc *sc; 195 uint32_t reg; 196 197 sc = device_get_softc(dev); 198 199 if (pin >= GPIO_PINS) 200 return (EINVAL); 201 202 /* Reading the direction */ 203 JH7110_GPIO_LOCK(sc); 204 reg = JH7110_GPIO_READ(sc, GP0_DOEN_CFG + GPIO_RW_OFFSET(pin)); 205 if ((reg & ENABLE_MASK << GPIO_SHIFT(pin)) == 0) 206 *flags |= GPIO_PIN_OUTPUT; 207 else 208 *flags |= GPIO_PIN_INPUT; 209 JH7110_GPIO_UNLOCK(sc); 210 211 return (0); 212 } 213 214 static int 215 jh7110_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags) 216 { 217 struct jh7110_gpio_softc *sc; 218 uint32_t reg; 219 220 sc = device_get_softc(dev); 221 222 if (pin >= GPIO_PINS) 223 return (EINVAL); 224 225 /* Setting the direction, enable or disable output, configuring pads */ 226 227 JH7110_GPIO_LOCK(sc); 228 229 if (flags & GPIO_PIN_INPUT) { 230 reg = JH7110_GPIO_READ(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin)); 231 reg |= (PAD_INPUT_EN | PAD_HYST); 232 JH7110_GPIO_WRITE(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin), reg); 233 } 234 235 reg = JH7110_GPIO_READ(sc, GP0_DOEN_CFG + GPIO_RW_OFFSET(pin)); 236 reg &= ~(ENABLE_MASK << GPIO_SHIFT(pin)); 237 if (flags & GPIO_PIN_INPUT) { 238 reg |= DIROUT_DISABLE << GPIO_SHIFT(pin); 239 } 240 JH7110_GPIO_WRITE(sc, GP0_DOEN_CFG + GPIO_RW_OFFSET(pin), reg); 241 242 if (flags & GPIO_PIN_OUTPUT) { 243 reg = JH7110_GPIO_READ(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin)); 244 reg &= ~(ENABLE_MASK << GPIO_SHIFT(pin)); 245 reg |= 0x1 << GPIO_SHIFT(pin); 246 JH7110_GPIO_WRITE(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin), reg); 247 248 reg = JH7110_GPIO_READ(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin)); 249 reg &= ~(PAD_INPUT_EN | PAD_PULLUP | PAD_PULLDOWN | PAD_HYST); 250 JH7110_GPIO_WRITE(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin), reg); 251 } 252 253 JH7110_GPIO_UNLOCK(sc); 254 255 return (0); 256 } 257 258 static int 259 jh7110_gpio_probe(device_t dev) 260 { 261 if (!ofw_bus_status_okay(dev)) 262 return (ENXIO); 263 264 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0) 265 return (ENXIO); 266 267 device_set_desc(dev, "StarFive JH7110 GPIO controller"); 268 269 return (BUS_PROBE_DEFAULT); 270 } 271 272 static int 273 jh7110_gpio_detach(device_t dev) 274 { 275 struct jh7110_gpio_softc *sc; 276 277 sc = device_get_softc(dev); 278 279 bus_release_resources(dev, jh7110_gpio_spec, &sc->res); 280 if (sc->busdev != NULL) 281 gpiobus_detach_bus(dev); 282 if (sc->clk != NULL) 283 clk_release(sc->clk); 284 mtx_destroy(&sc->mtx); 285 286 return (0); 287 } 288 289 static int 290 jh7110_gpio_attach(device_t dev) 291 { 292 struct jh7110_gpio_softc *sc; 293 294 sc = device_get_softc(dev); 295 sc->dev = dev; 296 297 mtx_init(&sc->mtx, device_get_nameunit(sc->dev), NULL, MTX_DEF); 298 299 if (bus_alloc_resources(dev, jh7110_gpio_spec, &sc->res) != 0) { 300 device_printf(dev, "Could not allocate resources\n"); 301 bus_release_resources(dev, jh7110_gpio_spec, &sc->res); 302 mtx_destroy(&sc->mtx); 303 return (ENXIO); 304 } 305 306 if (clk_get_by_ofw_index(dev, 0, 0, &sc->clk) != 0) { 307 device_printf(dev, "Cannot get clock\n"); 308 jh7110_gpio_detach(dev); 309 return (ENXIO); 310 } 311 312 if (clk_enable(sc->clk) != 0) { 313 device_printf(dev, "Could not enable clock %s\n", 314 clk_get_name(sc->clk)); 315 jh7110_gpio_detach(dev); 316 return (ENXIO); 317 } 318 319 /* Reseting GPIO interrupts */ 320 JH7110_GPIO_WRITE(sc, GPIOE_0, 0); 321 JH7110_GPIO_WRITE(sc, GPIOE_1, 0); 322 JH7110_GPIO_WRITE(sc, GPIOEN, 1); 323 324 sc->busdev = gpiobus_add_bus(dev); 325 if (sc->busdev == NULL) { 326 device_printf(dev, "Cannot attach gpiobus\n"); 327 jh7110_gpio_detach(dev); 328 return (ENXIO); 329 } 330 331 bus_attach_children(dev); 332 return (0); 333 } 334 335 static phandle_t 336 jh7110_gpio_get_node(device_t bus, device_t dev) 337 { 338 return (ofw_bus_get_node(bus)); 339 } 340 341 static device_method_t jh7110_gpio_methods[] = { 342 /* Device interface */ 343 DEVMETHOD(device_probe, jh7110_gpio_probe), 344 DEVMETHOD(device_attach, jh7110_gpio_attach), 345 DEVMETHOD(device_detach, jh7110_gpio_detach), 346 347 /* GPIO protocol */ 348 DEVMETHOD(gpio_get_bus, jh7110_gpio_get_bus), 349 DEVMETHOD(gpio_pin_max, jh7110_gpio_pin_max), 350 DEVMETHOD(gpio_pin_get, jh7110_gpio_pin_get), 351 DEVMETHOD(gpio_pin_set, jh7110_gpio_pin_set), 352 DEVMETHOD(gpio_pin_toggle, jh7110_gpio_pin_toggle), 353 DEVMETHOD(gpio_pin_getflags, jh7110_gpio_pin_getflags), 354 DEVMETHOD(gpio_pin_setflags, jh7110_gpio_pin_setflags), 355 DEVMETHOD(gpio_pin_getcaps, jh7110_gpio_pin_getcaps), 356 DEVMETHOD(gpio_pin_getname, jh7110_gpio_pin_getname), 357 358 /* ofw_bus interface */ 359 DEVMETHOD(ofw_bus_get_node, jh7110_gpio_get_node), 360 361 DEVMETHOD_END 362 }; 363 364 DEFINE_CLASS_0(gpio, jh7110_gpio_driver, jh7110_gpio_methods, 365 sizeof(struct jh7110_gpio_softc)); 366 EARLY_DRIVER_MODULE(jh7110_gpio, simplebus, jh7110_gpio_driver, 0, 0, 367 BUS_PASS_INTERRUPT + BUS_PASS_ORDER_MIDDLE); 368 MODULE_DEPEND(jh7110_gpio, gpiobus, 1, 1, 1); 369