1/* $NetBSD: gpioow.c,v 1.20 2023/05/10 00:09:31 riastradh Exp $ */ 2/* $OpenBSD: gpioow.c,v 1.1 2006/03/04 16:27:03 grange Exp $ */ 3 4/* 5 * Copyright (c) 2006 Alexander Yurchenko <grange@openbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20#include <sys/cdefs.h> 21__KERNEL_RCSID(0, "$NetBSD: gpioow.c,v 1.20 2023/05/10 00:09:31 riastradh Exp $"); 22 23/* 24 * 1-Wire bus bit-banging through GPIO pin. 25 */ 26 27#include <sys/param.h> 28#include <sys/systm.h> 29#include <sys/device.h> 30#include <sys/gpio.h> 31#include <sys/module.h> 32 33#include <dev/gpio/gpiovar.h> 34 35#include <dev/onewire/onewirevar.h> 36 37#include "ioconf.h" 38 39#define GPIOOW_NPINS 1 40#define GPIOOW_PIN_DATA 0 41 42struct gpioow_softc { 43 void * sc_gpio; 44 struct gpio_pinmap sc_map; 45 int _map[GPIOOW_NPINS]; 46 47 struct onewire_bus sc_ow_bus; 48 device_t sc_ow_dev; 49 50 int sc_data; 51 int sc_dying; 52}; 53 54static int gpioow_match(device_t, cfdata_t, void *); 55static void gpioow_attach(device_t, device_t, void *); 56static int gpioow_detach(device_t, int); 57static int gpioow_activate(device_t, enum devact); 58 59static int gpioow_ow_reset(void *); 60static int gpioow_ow_read_bit(void *); 61static void gpioow_ow_write_bit(void *, int); 62 63static void gpioow_bb_rx(void *); 64static void gpioow_bb_tx(void *); 65static int gpioow_bb_get(void *); 66static void gpioow_bb_set(void *, int); 67 68CFATTACH_DECL_NEW(gpioow, sizeof(struct gpioow_softc), 69 gpioow_match, gpioow_attach, gpioow_detach, gpioow_activate); 70 71static const struct onewire_bbops gpioow_bbops = { 72 gpioow_bb_rx, 73 gpioow_bb_tx, 74 gpioow_bb_get, 75 gpioow_bb_set 76}; 77 78static int 79gpioow_match(device_t parent, cfdata_t cf, void *aux) 80{ 81 struct gpio_attach_args *ga = aux; 82 83 if (strcmp(ga->ga_dvname, cf->cf_name)) 84 return 0; 85 86 if (ga->ga_offset == -1) 87 return 0; 88 89 /* Check that we have enough pins */ 90 if (gpio_npins(ga->ga_mask) != GPIOOW_NPINS) { 91 aprint_debug("%s: invalid pin mask 0x%02x\n", cf->cf_name, 92 ga->ga_mask); 93 return 0; 94 } 95 return 1; 96} 97 98static void 99gpioow_attach(device_t parent, device_t self, void *aux) 100{ 101 struct gpioow_softc *sc = device_private(self); 102 struct gpio_attach_args *ga = aux; 103 struct onewirebus_attach_args oba; 104 int caps; 105 106 /* Map pins */ 107 sc->sc_gpio = ga->ga_gpio; 108 sc->sc_map.pm_map = sc->_map; 109 if (gpio_pin_map(sc->sc_gpio, ga->ga_offset, ga->ga_mask, 110 &sc->sc_map)) { 111 aprint_error(": can't map pins\n"); 112 goto finish; 113 } 114 115 /* Configure data pin */ 116 caps = gpio_pin_caps(sc->sc_gpio, &sc->sc_map, GPIOOW_PIN_DATA); 117 if (!(caps & GPIO_PIN_OUTPUT)) { 118 aprint_error(": data pin is unable to drive output\n"); 119 gpio_pin_unmap(sc->sc_gpio, &sc->sc_map); 120 goto finish; 121 } 122 if (!(caps & GPIO_PIN_INPUT)) { 123 aprint_error(": data pin is unable to read input\n"); 124 gpio_pin_unmap(sc->sc_gpio, &sc->sc_map); 125 goto finish; 126 } 127 aprint_normal(": DATA[%d]", sc->sc_map.pm_map[GPIOOW_PIN_DATA]); 128 sc->sc_data = GPIO_PIN_OUTPUT; 129 if (caps & GPIO_PIN_OPENDRAIN) { 130 aprint_normal(" open-drain"); 131 sc->sc_data |= GPIO_PIN_OPENDRAIN; 132 } else if ((caps & GPIO_PIN_PUSHPULL) && (caps & GPIO_PIN_TRISTATE)) { 133 aprint_normal(" push-pull tri-state"); 134 sc->sc_data |= GPIO_PIN_PUSHPULL; 135 } 136 if (caps & GPIO_PIN_PULLUP) { 137 aprint_normal(" pull-up"); 138 sc->sc_data |= GPIO_PIN_PULLUP; 139 } 140 gpio_pin_ctl(sc->sc_gpio, &sc->sc_map, GPIOOW_PIN_DATA, sc->sc_data); 141 142 aprint_normal("\n"); 143 144 /* Attach 1-Wire bus */ 145 sc->sc_ow_bus.bus_cookie = sc; 146 sc->sc_ow_bus.bus_reset = gpioow_ow_reset; 147 sc->sc_ow_bus.bus_read_bit = gpioow_ow_read_bit; 148 sc->sc_ow_bus.bus_write_bit = gpioow_ow_write_bit; 149 150 memset(&oba, 0, sizeof(oba)); 151 oba.oba_bus = &sc->sc_ow_bus; 152 sc->sc_ow_dev = config_found(self, &oba, onewirebus_print, CFARGS_NONE); 153 154 if (!pmf_device_register(self, NULL, NULL)) 155 aprint_error("%s: could not establish power handler\n", 156 device_xname(self)); 157finish: 158 return; 159} 160 161static int 162gpioow_detach(device_t self, int flags) 163{ 164 struct gpioow_softc *sc = device_private(self); 165 int error; 166 167 error = config_detach_children(self, flags); 168 if (error) 169 return error; 170 171 gpio_pin_unmap(sc->sc_gpio, &sc->sc_map); 172 pmf_device_deregister(self); 173 return 0; 174} 175 176static int 177gpioow_activate(device_t self, enum devact act) 178{ 179 struct gpioow_softc *sc = device_private(self); 180 181 switch (act) { 182 case DVACT_DEACTIVATE: 183 sc->sc_dying = 1; 184 return 0; 185 default: 186 return EOPNOTSUPP; 187 } 188} 189 190static int 191gpioow_ow_reset(void *arg) 192{ 193 return (onewire_bb_reset(&gpioow_bbops, arg)); 194} 195 196static int 197gpioow_ow_read_bit(void *arg) 198{ 199 return (onewire_bb_read_bit(&gpioow_bbops, arg)); 200} 201 202static void 203gpioow_ow_write_bit(void *arg, int value) 204{ 205 onewire_bb_write_bit(&gpioow_bbops, arg, value); 206} 207 208static void 209gpioow_bb_rx(void *arg) 210{ 211 struct gpioow_softc *sc = arg; 212 int data = sc->sc_data; 213 214 data &= ~(GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_TRISTATE); 215 data |= GPIO_PIN_INPUT; 216 if (data & GPIO_PIN_PUSHPULL) 217 data |= GPIO_PIN_TRISTATE; 218 if (sc->sc_data != data) { 219 sc->sc_data = data; 220 gpio_pin_ctl(sc->sc_gpio, &sc->sc_map, GPIOOW_PIN_DATA, 221 sc->sc_data); 222 } 223} 224 225static void 226gpioow_bb_tx(void *arg) 227{ 228 struct gpioow_softc *sc = arg; 229 int data = sc->sc_data; 230 231 data &= ~(GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_TRISTATE); 232 data |= GPIO_PIN_OUTPUT; 233 if (sc->sc_data != data) { 234 sc->sc_data = data; 235 gpio_pin_ctl(sc->sc_gpio, &sc->sc_map, GPIOOW_PIN_DATA, 236 sc->sc_data); 237 } 238} 239 240static int 241gpioow_bb_get(void *arg) 242{ 243 struct gpioow_softc *sc = arg; 244 245 return (gpio_pin_read(sc->sc_gpio, &sc->sc_map, GPIOOW_PIN_DATA) == 246 GPIO_PIN_HIGH ? 1 : 0); 247} 248 249static void 250gpioow_bb_set(void *arg, int value) 251{ 252 struct gpioow_softc *sc = arg; 253 254 gpio_pin_write(sc->sc_gpio, &sc->sc_map, GPIOOW_PIN_DATA, 255 value ? GPIO_PIN_HIGH : GPIO_PIN_LOW); 256} 257 258MODULE(MODULE_CLASS_DRIVER, gpioow, "gpio,onewire"); 259 260#ifdef _MODULE 261#include "ioconf.c" 262#endif 263 264static int 265gpioow_modcmd(modcmd_t cmd, void *opaque) 266{ 267 int error; 268 269 error = 0; 270 switch (cmd) { 271 case MODULE_CMD_INIT: 272#ifdef _MODULE 273 error = config_init_component(cfdriver_ioconf_gpioow, 274 cfattach_ioconf_gpioow, cfdata_ioconf_gpioow); 275 if (error) 276 aprint_error("%s: unable to init component\n", 277 gpioow_cd.cd_name); 278#endif 279 break; 280 case MODULE_CMD_FINI: 281#ifdef _MODULE 282 config_fini_component(cfdriver_ioconf_gpioow, 283 cfattach_ioconf_gpioow, cfdata_ioconf_gpioow); 284#endif 285 break; 286 default: 287 error = ENOTTY; 288 } 289 return error; 290} 291