pcagpio.c revision 1.11
1 /* $NetBSD: pcagpio.c,v 1.11 2021/06/21 03:12:54 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 2020 Michael Lorenz 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /* 30 * a driver for Philips Semiconductor PCA9555 GPIO controllers 31 */ 32 33 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: pcagpio.c,v 1.11 2021/06/21 03:12:54 christos Exp $"); 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/device.h> 39 #ifdef PCAGPIO_DEBUG 40 #include <sys/kernel.h> 41 #endif 42 #include <sys/conf.h> 43 #include <sys/bus.h> 44 45 #include <dev/i2c/i2cvar.h> 46 #include <dev/led.h> 47 48 #ifdef PCAGPIO_DEBUG 49 #define DPRINTF printf 50 #else 51 #define DPRINTF if (0) printf 52 #endif 53 54 /* commands */ 55 #define PCAGPIO_INPUT 0x00 /* line status */ 56 #define PCAGPIO_OUTPUT 0x01 /* output status */ 57 #define PCAGPIO_REVERT 0x02 /* revert input if set */ 58 #define PCAGPIO_CONFIG 0x03 /* input if set, output if not */ 59 60 static int pcagpio_match(device_t, cfdata_t, void *); 61 static void pcagpio_attach(device_t, device_t, void *); 62 static int pcagpio_detach(device_t, int); 63 #ifdef PCAGPIO_DEBUG 64 static void pcagpio_timeout(void *); 65 #endif 66 67 /* we can only pass one cookie to led_attach() but we need several values... */ 68 struct pcagpio_led { 69 void *cookie; 70 struct led_device *led; 71 uint32_t mask, v_on, v_off; 72 }; 73 74 struct pcagpio_softc { 75 device_t sc_dev; 76 i2c_tag_t sc_i2c; 77 i2c_addr_t sc_addr; 78 79 int sc_is_16bit; 80 uint32_t sc_state; 81 struct pcagpio_led sc_leds[16]; 82 int sc_nleds; 83 84 #ifdef PCAGPIO_DEBUG 85 uint32_t sc_dir, sc_in; 86 callout_t sc_timer; 87 #endif 88 }; 89 90 91 static void pcagpio_writereg(struct pcagpio_softc *, int, uint32_t); 92 static uint32_t pcagpio_readreg(struct pcagpio_softc *, int); 93 static void pcagpio_attach_led( 94 struct pcagpio_softc *, char *, int, int, int); 95 static int pcagpio_get(void *); 96 static void pcagpio_set(void *, int); 97 98 CFATTACH_DECL_NEW(pcagpio, sizeof(struct pcagpio_softc), 99 pcagpio_match, pcagpio_attach, pcagpio_detach, NULL); 100 101 static const struct device_compatible_entry compat_data[] = { 102 { .compat = "i2c-pca9555", .value = 1 }, 103 { .compat = "pca9555", .value = 1 }, 104 { .compat = "i2c-pca9556", .value = 0 }, 105 { .compat = "pca9556", .value = 0 }, 106 DEVICE_COMPAT_EOL 107 }; 108 109 static int 110 pcagpio_match(device_t parent, cfdata_t match, void *aux) 111 { 112 struct i2c_attach_args *ia = aux; 113 int match_result; 114 115 if (iic_use_direct_match(ia, match, compat_data, &match_result)) 116 return match_result; 117 118 return 0; 119 } 120 121 #ifdef PCAGPIO_DEBUG 122 static void 123 printdir(char* name, uint32_t val, uint32_t mask, char letter) 124 { 125 char flags[17], bits[17]; 126 uint32_t bit = 0x8000; 127 int i; 128 129 val &= mask; 130 for (i = 0; i < 16; i++) { 131 flags[i] = (mask & bit) ? letter : '-'; 132 bits[i] = (val & bit) ? 'X' : ' '; 133 bit = bit >> 1; 134 } 135 flags[16] = 0; 136 bits[16] = 0; 137 printf("%s: dir: %s\n", name, flags); 138 printf("%s: lvl: %s\n", name, bits); 139 } 140 #endif 141 142 static void 143 pcagpio_attach(device_t parent, device_t self, void *aux) 144 { 145 struct pcagpio_softc *sc = device_private(self); 146 struct i2c_attach_args *ia = aux; 147 const struct device_compatible_entry *dce; 148 prop_dictionary_t dict = device_properties(self); 149 prop_array_t pins; 150 prop_dictionary_t pin; 151 152 sc->sc_dev = self; 153 sc->sc_i2c = ia->ia_tag; 154 sc->sc_addr = ia->ia_addr; 155 sc->sc_nleds = 0; 156 157 aprint_naive("\n"); 158 sc->sc_is_16bit = 0; 159 if ((dce = iic_compatible_lookup(ia, compat_data)) != NULL) 160 sc->sc_is_16bit = dce->value; 161 162 aprint_normal(": %s\n", sc->sc_is_16bit ? "PCA9555" : "PCA9556"); 163 164 sc->sc_state = pcagpio_readreg(sc, PCAGPIO_OUTPUT); 165 166 #ifdef PCAGPIO_DEBUG 167 uint32_t in, out; 168 sc->sc_dir = pcagpio_readreg(sc, PCAGPIO_CONFIG); 169 sc->sc_in = pcagpio_readreg(sc, PCAGPIO_INPUT); 170 in = sc-> sc_in; 171 out = sc->sc_state; 172 173 out &= ~sc->sc_dir; 174 in &= sc->sc_dir; 175 176 printdir(sc->sc_dev->dv_xname, in, sc->sc_dir, 'I'); 177 printdir(sc->sc_dev->dv_xname, out, ~sc->sc_dir, 'O'); 178 179 callout_init(&sc->sc_timer, CALLOUT_MPSAFE); 180 callout_reset(&sc->sc_timer, hz*20, pcagpio_timeout, sc); 181 182 #endif 183 184 pins = prop_dictionary_get(dict, "pins"); 185 if (pins != NULL) { 186 int i, num, def; 187 char name[32]; 188 const char *spptr, *nptr; 189 bool ok = TRUE, act; 190 191 for (i = 0; i < prop_array_count(pins); i++) { 192 nptr = NULL; 193 pin = prop_array_get(pins, i); 194 ok &= prop_dictionary_get_string(pin, "name", 195 &nptr); 196 ok &= prop_dictionary_get_uint32(pin, "pin", &num); 197 ok &= prop_dictionary_get_bool( pin, "active_high", 198 &act); 199 /* optional default state */ 200 def = -1; 201 prop_dictionary_get_int32(pin, "default_state", &def); 202 if (!ok) 203 continue; 204 /* Extract pin type from the name */ 205 spptr = strstr(nptr, " "); 206 if (spptr == NULL) 207 continue; 208 spptr += 1; 209 strncpy(name, spptr, 31); 210 if (!strncmp(nptr, "LED ", 4)) 211 pcagpio_attach_led(sc, name, num, act, def); 212 } 213 } 214 } 215 216 static int 217 pcagpio_detach(device_t self, int flags) 218 { 219 struct pcagpio_softc *sc = device_private(self); 220 int i; 221 222 for (i = 0; i < sc->sc_nleds; i++) 223 led_detach(sc->sc_leds[i].led); 224 225 #ifdef PCAGPIO_DEBUG 226 callout_halt(&sc->sc_timer, NULL); 227 callout_destroy(&sc->sc_timer); 228 #endif 229 230 return 0; 231 } 232 233 #ifdef PCAGPIO_DEBUG 234 static void 235 pcagpio_timeout(void *v) 236 { 237 struct pcagpio_softc *sc = v; 238 uint32_t out, dir, in, o_out, o_in; 239 240 out = pcagpio_readreg(sc, PCAGPIO_OUTPUT); 241 dir = pcagpio_readreg(sc, PCAGPIO_CONFIG); 242 in = pcagpio_readreg(sc, PCAGPIO_INPUT); 243 if (out != sc->sc_state || dir != sc->sc_dir || in != sc->sc_in) { 244 aprint_normal_dev(sc->sc_dev, "status change\n"); 245 o_out = sc->sc_state; 246 o_in = sc->sc_in; 247 o_out &= ~sc->sc_dir; 248 o_in &= sc->sc_dir; 249 printdir(sc->sc_dev->dv_xname, o_in, sc->sc_dir, 'I'); 250 printdir(sc->sc_dev->dv_xname, o_out, ~sc->sc_dir, 'O'); 251 sc->sc_state = out; 252 sc->sc_dir = dir; 253 sc->sc_in = in; 254 out &= ~sc->sc_dir; 255 in &= sc->sc_dir; 256 printdir(sc->sc_dev->dv_xname, in, sc->sc_dir, 'I'); 257 printdir(sc->sc_dev->dv_xname, out, ~sc->sc_dir, 'O'); 258 } 259 callout_reset(&sc->sc_timer, hz*60, pcagpio_timeout, sc); 260 } 261 #endif 262 263 static void 264 pcagpio_writereg(struct pcagpio_softc *sc, int reg, uint32_t val) 265 { 266 uint8_t cmd; 267 268 iic_acquire_bus(sc->sc_i2c, 0); 269 if (sc->sc_is_16bit) { 270 uint16_t creg; 271 cmd = reg << 1; 272 creg = htole16(val); 273 iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, 274 sc->sc_addr, &cmd, 1, &creg, 2, 0); 275 } else { 276 uint8_t creg; 277 cmd = reg; 278 creg = (uint8_t)val; 279 iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, 280 sc->sc_addr, &cmd, 1, &creg, 1, 0); 281 } 282 if (reg == PCAGPIO_OUTPUT) sc->sc_state = val; 283 iic_release_bus(sc->sc_i2c, 0); 284 } 285 286 static uint32_t pcagpio_readreg(struct pcagpio_softc *sc, int reg) 287 { 288 uint8_t cmd; 289 uint32_t ret; 290 291 iic_acquire_bus(sc->sc_i2c, 0); 292 if (sc->sc_is_16bit) { 293 uint16_t creg; 294 cmd = reg << 1; 295 iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP, 296 sc->sc_addr, &cmd, 1, &creg, 2, 0); 297 ret = le16toh(creg); 298 } else { 299 uint8_t creg; 300 cmd = reg; 301 iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP, 302 sc->sc_addr, &cmd, 1, &creg, 1, 0); 303 ret = creg; 304 } 305 iic_release_bus(sc->sc_i2c, 0); 306 return ret; 307 } 308 309 static void 310 pcagpio_attach_led(struct pcagpio_softc *sc, char *n, int pin, int act, int def) 311 { 312 struct pcagpio_led *l; 313 314 l = &sc->sc_leds[sc->sc_nleds]; 315 l->cookie = sc; 316 l->mask = 1 << pin; 317 l->v_on = act ? l->mask : 0; 318 l->v_off = act ? 0 : l->mask; 319 l->led = led_attach(n, l, pcagpio_get, pcagpio_set); 320 if (def != -1) pcagpio_set(l, def); 321 DPRINTF("%s: %04x %04x %04x def %d\n", 322 __func__, l->mask, l->v_on, l->v_off, def); 323 sc->sc_nleds++; 324 } 325 326 static int 327 pcagpio_get(void *cookie) 328 { 329 struct pcagpio_led *l = cookie; 330 struct pcagpio_softc *sc = l->cookie; 331 332 return ((sc->sc_state & l->mask) == l->v_on); 333 } 334 335 static void 336 pcagpio_set(void *cookie, int val) 337 { 338 struct pcagpio_led *l = cookie; 339 struct pcagpio_softc *sc = l->cookie; 340 uint32_t newstate; 341 342 newstate = sc->sc_state & ~l->mask; 343 newstate |= val ? l->v_on : l->v_off; 344 DPRINTF("%s: %04x -> %04x, %04x %04x %04x\n", __func__, 345 sc->sc_state, newstate, l->mask, l->v_on, l->v_off); 346 if (newstate != sc->sc_state) 347 pcagpio_writereg(sc, PCAGPIO_OUTPUT, newstate); 348 } 349
Indexes created Tue Sep 30 20:09:53 GMT 2025