1 /* $NetBSD: onewire.c,v 1.22 2021/08/07 16:19:14 thorpej Exp $ */ 2 /* $OpenBSD: onewire.c,v 1.1 2006/03/04 16:27:03 grange Exp $ */ 3 4 /*- 5 * Copyright (c) 2019 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Andrew Doran. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * Copyright (c) 2006 Alexander Yurchenko <grange (at) openbsd.org> 35 * 36 * Permission to use, copy, modify, and distribute this software for any 37 * purpose with or without fee is hereby granted, provided that the above 38 * copyright notice and this permission notice appear in all copies. 39 * 40 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 41 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 42 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 43 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 44 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 45 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 46 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 47 */ 48 49 #include <sys/cdefs.h> 50 __KERNEL_RCSID(0, "$NetBSD: onewire.c,v 1.22 2021/08/07 16:19:14 thorpej Exp $"); 51 52 /* 53 * 1-Wire bus driver. 54 */ 55 56 #include <sys/param.h> 57 #include <sys/systm.h> 58 #include <sys/conf.h> 59 #include <sys/device.h> 60 #include <sys/kernel.h> 61 #include <sys/kthread.h> 62 #include <sys/kmem.h> 63 #include <sys/proc.h> 64 #include <sys/queue.h> 65 #include <sys/module.h> 66 67 #ifdef _KERNEL_OPT 68 #include "opt_onewire.h" 69 #endif 70 71 #include <dev/onewire/onewirereg.h> 72 #include <dev/onewire/onewirevar.h> 73 74 #ifdef ONEWIRE_DEBUG 75 #define DPRINTF(x) printf x 76 #else 77 #define DPRINTF(x) 78 #endif 79 80 int onewire_maxdevs = 8; 81 int onewire_scantime = 10; /* was 3 seconds - too often */ 82 83 struct onewire_softc { 84 device_t sc_dev; 85 struct onewire_bus * sc_bus; 86 kmutex_t sc_lock; 87 kcondvar_t sc_scancv; 88 struct lwp * sc_thread; 89 TAILQ_HEAD(, onewire_device) sc_devs; 90 int sc_dying; 91 }; 92 93 struct onewire_device { 94 TAILQ_ENTRY(onewire_device) d_list; 95 device_t d_dev; 96 u_int64_t d_rom; 97 bool d_present; 98 }; 99 100 static int onewire_match(device_t, cfdata_t, void *); 101 static void onewire_attach(device_t, device_t, void *); 102 static int onewire_detach(device_t, int); 103 static int onewire_activate(device_t, enum devact); 104 int onewire_print(void *, const char *); 105 106 static void onewire_thread(void *); 107 static void onewire_scan(struct onewire_softc *); 108 109 CFATTACH_DECL_NEW(onewire, sizeof(struct onewire_softc), 110 onewire_match, onewire_attach, onewire_detach, onewire_activate); 111 112 extern struct cfdriver onewire_cd; 113 114 static int 115 onewire_match(device_t parent, cfdata_t cf, void *aux) 116 { 117 return 1; 118 } 119 120 static void 121 onewire_attach(device_t parent, device_t self, void *aux) 122 { 123 struct onewire_softc *sc = device_private(self); 124 struct onewirebus_attach_args *oba = aux; 125 126 sc->sc_dev = self; 127 sc->sc_bus = oba->oba_bus; 128 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE); 129 cv_init(&sc->sc_scancv, "owscan"); 130 TAILQ_INIT(&sc->sc_devs); 131 132 aprint_normal("\n"); 133 134 if (kthread_create(PRI_NONE, KTHREAD_MUSTJOIN | KTHREAD_MPSAFE, NULL, 135 onewire_thread, sc, &sc->sc_thread, "%s", device_xname(self)) != 0) { 136 aprint_error_dev(self, "can't create kernel thread\n"); 137 /* Normally the kthread destroys these. */ 138 mutex_destroy(&sc->sc_lock); 139 cv_destroy(&sc->sc_scancv); 140 } 141 } 142 143 static int 144 onewire_detach(device_t self, int flags) 145 { 146 struct onewire_softc *sc = device_private(self); 147 int rv; 148 149 if (sc->sc_thread != NULL) { 150 mutex_enter(&sc->sc_lock); 151 sc->sc_dying = 1; 152 cv_broadcast(&sc->sc_scancv); 153 mutex_exit(&sc->sc_lock); 154 /* Must no longer touch sc_lock nor sc_scancv. */ 155 kthread_join(sc->sc_thread); 156 } 157 158 //rv = config_detach_children(self, flags); 159 rv = 0; /* XXX riz */ 160 161 return rv; 162 } 163 164 static int 165 onewire_activate(device_t self, enum devact act) 166 { 167 struct onewire_softc *sc = device_private(self); 168 169 switch (act) { 170 case DVACT_DEACTIVATE: 171 sc->sc_dying = 1; 172 return 0; 173 default: 174 return EOPNOTSUPP; 175 } 176 } 177 178 int 179 onewire_print(void *aux, const char *pnp) 180 { 181 struct onewire_attach_args *oa = aux; 182 const char *famname; 183 184 if (pnp == NULL) 185 aprint_normal(" "); 186 187 famname = onewire_famname(ONEWIRE_ROM_FAMILY_TYPE(oa->oa_rom)); 188 if (famname == NULL) 189 aprint_normal("family 0x%02x", 190 (uint)ONEWIRE_ROM_FAMILY_TYPE(oa->oa_rom)); 191 else 192 aprint_normal("\"%s\"", famname); 193 aprint_normal(" sn %012" PRIx64, ONEWIRE_ROM_SN(oa->oa_rom)); 194 195 if (pnp != NULL) 196 aprint_normal(" at %s", pnp); 197 198 return UNCONF; 199 } 200 201 int 202 onewirebus_print(void *aux, const char *pnp) 203 { 204 if (pnp != NULL) 205 aprint_normal("onewire at %s", pnp); 206 207 return UNCONF; 208 } 209 210 void 211 onewire_lock(void *arg) 212 { 213 struct onewire_softc *sc = arg; 214 215 mutex_enter(&sc->sc_lock); 216 } 217 218 void 219 onewire_unlock(void *arg) 220 { 221 struct onewire_softc *sc = arg; 222 223 mutex_exit(&sc->sc_lock); 224 } 225 226 int 227 onewire_reset(void *arg) 228 { 229 struct onewire_softc *sc = arg; 230 struct onewire_bus *bus = sc->sc_bus; 231 232 KASSERT(mutex_owned(&sc->sc_lock)); 233 234 return bus->bus_reset(bus->bus_cookie); 235 } 236 237 int 238 onewire_read_bit(void *arg) 239 { 240 struct onewire_softc *sc = arg; 241 struct onewire_bus *bus = sc->sc_bus; 242 243 KASSERT(mutex_owned(&sc->sc_lock)); 244 245 return bus->bus_read_bit(bus->bus_cookie); 246 } 247 248 void 249 onewire_write_bit(void *arg, int value) 250 { 251 struct onewire_softc *sc = arg; 252 struct onewire_bus *bus = sc->sc_bus; 253 254 KASSERT(mutex_owned(&sc->sc_lock)); 255 256 bus->bus_write_bit(bus->bus_cookie, value); 257 } 258 259 int 260 onewire_read_byte(void *arg) 261 { 262 struct onewire_softc *sc = arg; 263 struct onewire_bus *bus = sc->sc_bus; 264 uint8_t value = 0; 265 int i; 266 267 KASSERT(mutex_owned(&sc->sc_lock)); 268 269 if (bus->bus_read_byte != NULL) 270 return bus->bus_read_byte(bus->bus_cookie); 271 272 for (i = 0; i < 8; i++) 273 value |= (bus->bus_read_bit(bus->bus_cookie) << i); 274 275 return value; 276 } 277 278 void 279 onewire_write_byte(void *arg, int value) 280 { 281 struct onewire_softc *sc = arg; 282 struct onewire_bus *bus = sc->sc_bus; 283 int i; 284 285 KASSERT(mutex_owned(&sc->sc_lock)); 286 287 if (bus->bus_write_byte != NULL) 288 return bus->bus_write_byte(bus->bus_cookie, value); 289 290 for (i = 0; i < 8; i++) 291 bus->bus_write_bit(bus->bus_cookie, (value >> i) & 0x1); 292 } 293 294 int 295 onewire_triplet(void *arg, int dir) 296 { 297 struct onewire_softc *sc = arg; 298 struct onewire_bus *bus = sc->sc_bus; 299 int rv; 300 301 KASSERT(mutex_owned(&sc->sc_lock)); 302 303 if (bus->bus_triplet != NULL) 304 return bus->bus_triplet(bus->bus_cookie, dir); 305 306 rv = bus->bus_read_bit(bus->bus_cookie); 307 rv <<= 1; 308 rv |= bus->bus_read_bit(bus->bus_cookie); 309 310 switch (rv) { 311 case 0x0: 312 bus->bus_write_bit(bus->bus_cookie, dir); 313 break; 314 case 0x1: 315 bus->bus_write_bit(bus->bus_cookie, 0); 316 break; 317 default: 318 bus->bus_write_bit(bus->bus_cookie, 1); 319 } 320 321 return rv; 322 } 323 324 void 325 onewire_read_block(void *arg, void *buf, int len) 326 { 327 struct onewire_softc *sc = arg; 328 uint8_t *p = buf; 329 330 KASSERT(mutex_owned(&sc->sc_lock)); 331 332 while (len--) 333 *p++ = onewire_read_byte(sc); 334 } 335 336 void 337 onewire_write_block(void *arg, const void *buf, int len) 338 { 339 struct onewire_softc *sc = arg; 340 const uint8_t *p = buf; 341 342 KASSERT(mutex_owned(&sc->sc_lock)); 343 344 while (len--) 345 onewire_write_byte(sc, *p++); 346 } 347 348 void 349 onewire_matchrom(void *arg, u_int64_t rom) 350 { 351 struct onewire_softc *sc = arg; 352 int i; 353 354 KASSERT(mutex_owned(&sc->sc_lock)); 355 356 onewire_write_byte(sc, ONEWIRE_CMD_MATCH_ROM); 357 for (i = 0; i < 8; i++) 358 onewire_write_byte(sc, (rom >> (i * 8)) & 0xff); 359 } 360 361 static void 362 onewire_thread(void *arg) 363 { 364 struct onewire_softc *sc = arg; 365 int unit, dly; 366 367 /* 368 * There can be many onewire busses, potentially funneled through 369 * few GPIO controllers. To avoid a thundering herd of kthreads and 370 * resulting contention for the GPIO controller, spread the probes 371 * out across an 8 second window. The kthreads could converge later 372 * due to timing effects. 373 */ 374 unit = device_unit(sc->sc_dev); 375 dly = (unit & 0x07) * hz + ((unit >> 3) * hz >> 3) + 1; 376 (void)kpause("owdly", false, dly, NULL); 377 378 mutex_enter(&sc->sc_lock); 379 while (!sc->sc_dying) { 380 onewire_scan(sc); 381 (void)cv_timedwait(&sc->sc_scancv, &sc->sc_lock, 382 onewire_scantime * hz); 383 } 384 mutex_exit(&sc->sc_lock); 385 386 /* Caller has set sc_dying and will no longer touch these. */ 387 cv_destroy(&sc->sc_scancv); 388 mutex_destroy(&sc->sc_lock); 389 kthread_exit(0); 390 } 391 392 static void 393 onewire_scan(struct onewire_softc *sc) 394 { 395 struct onewire_device *d, *next, *nd; 396 struct onewire_attach_args oa; 397 int search = 1, count = 0, present; 398 int dir, rv; 399 uint64_t mask, rom = 0, lastrom; 400 uint8_t data[8]; 401 int i, i0 = -1, lastd = -1; 402 403 TAILQ_FOREACH(d, &sc->sc_devs, d_list) { 404 d->d_present = false; 405 KASSERT(d->d_dev != NULL); 406 } 407 408 KASSERT(mutex_owned(&sc->sc_lock)); 409 KASSERT(curlwp == sc->sc_thread); 410 411 while (search && count++ < onewire_maxdevs) { 412 /* 413 * Reset the bus, allowing for one retry if reset fails. If 414 * there's no presence pulse don't search for any devices. 415 */ 416 if (onewire_reset(sc) != 0) { 417 DPRINTF(("%s: scan: no presence pulse\n", 418 device_xname(sc->sc_dev))); 419 if (onewire_reset(sc) != 0) { 420 DPRINTF(("%s: scan: retry failed\n", 421 device_xname(sc->sc_dev))); 422 break; 423 } 424 } 425 426 /* 427 * Start new search. Go through the previous path to 428 * the point we made a decision last time and make an 429 * opposite decision. If we didn't make any decision 430 * stop searching. 431 */ 432 search = 0; 433 lastrom = rom; 434 rom = 0; 435 onewire_write_byte(sc, ONEWIRE_CMD_SEARCH_ROM); 436 for (i = 0,i0 = -1; i < 64; i++) { 437 dir = (lastrom >> i) & 0x1; 438 if (i == lastd) 439 dir = 1; 440 else if (i > lastd) 441 dir = 0; 442 rv = onewire_triplet(sc, dir); 443 switch (rv) { 444 case 0x0: 445 if (i != lastd) { 446 if (dir == 0) 447 i0 = i; 448 search = 1; 449 } 450 mask = dir; 451 break; 452 case 0x1: 453 mask = 0; 454 break; 455 case 0x2: 456 mask = 1; 457 break; 458 default: 459 DPRINTF(("%s: scan: triplet error 0x%x, " 460 "step %d\n", 461 device_xname(sc->sc_dev), rv, i)); 462 return; 463 } 464 rom |= (mask << i); 465 } 466 lastd = i0; 467 468 /* 469 * Yield processor, but continue to hold the lock 470 * so that scan is not interrupted. 471 */ 472 (void)kpause("owscan", false, 1, NULL); 473 474 if (rom == 0) 475 continue; 476 477 /* 478 * The last byte of the ROM code contains a CRC calculated 479 * from the first 7 bytes. Re-calculate it to make sure 480 * we found a valid device. 481 */ 482 for (i = 0; i < 8; i++) 483 data[i] = (rom >> (i * 8)) & 0xff; 484 if (onewire_crc(data, 7) != data[7]) 485 continue; 486 487 /* 488 * Go through the list of attached devices to see if we 489 * found a new one. 490 */ 491 present = 0; 492 TAILQ_FOREACH(d, &sc->sc_devs, d_list) { 493 if (d->d_rom == rom) { 494 d->d_present = true; 495 present = 1; 496 break; 497 } 498 } 499 if (!present) { 500 nd = kmem_alloc(sizeof(*nd), KM_SLEEP); 501 nd->d_dev = NULL; 502 nd->d_rom = rom; 503 nd->d_present = true; 504 TAILQ_INSERT_TAIL(&sc->sc_devs, nd, d_list); 505 } 506 } 507 508 /* 509 * Detach disappeared devices, and attach new devices. Drop the 510 * lock when doing this in order to prevent lock order reversal 511 * against sysmon. This is safe because nothing other than this 512 * kthread modifies our device list. 513 */ 514 for (d = TAILQ_FIRST(&sc->sc_devs); d != NULL; d = next) { 515 next = TAILQ_NEXT(d, d_list); 516 if (!d->d_present) { 517 mutex_exit(&sc->sc_lock); 518 519 KERNEL_LOCK(1, NULL); /* XXXSMP */ 520 config_detach(d->d_dev, DETACH_FORCE); 521 d->d_dev = NULL; 522 KERNEL_UNLOCK_ONE(NULL); /* XXXSMP */ 523 524 mutex_enter(&sc->sc_lock); 525 } else if (d->d_dev == NULL) { 526 memset(&oa, 0, sizeof(oa)); 527 oa.oa_onewire = sc; 528 oa.oa_rom = d->d_rom; 529 mutex_exit(&sc->sc_lock); 530 531 KERNEL_LOCK(1, NULL); /* XXXSMP */ 532 d->d_dev = config_found(sc->sc_dev, &oa, onewire_print, 533 CFARGS_NONE); 534 KERNEL_UNLOCK_ONE(NULL); /* XXXSMP */ 535 536 mutex_enter(&sc->sc_lock); 537 } 538 if (d->d_dev == NULL) { 539 TAILQ_REMOVE(&sc->sc_devs, d, d_list); 540 kmem_free(d, sizeof(*d)); 541 } 542 } 543 } 544 545 MODULE(MODULE_CLASS_DRIVER, onewire, NULL); 546 547 #ifdef _MODULE 548 #include "ioconf.c" 549 #endif 550 551 static int 552 onewire_modcmd(modcmd_t cmd, void *opaque) 553 { 554 int error; 555 556 error = 0; 557 switch (cmd) { 558 case MODULE_CMD_INIT: 559 #ifdef _MODULE 560 error = config_init_component(cfdriver_ioconf_onewire, 561 cfattach_ioconf_onewire, cfdata_ioconf_onewire); 562 if (error) 563 aprint_error("%s: unable to init component\n", 564 onewire_cd.cd_name); 565 #endif 566 break; 567 case MODULE_CMD_FINI: 568 #ifdef _MODULE 569 config_fini_component(cfdriver_ioconf_onewire, 570 cfattach_ioconf_onewire, cfdata_ioconf_onewire); 571 #endif 572 break; 573 default: 574 error = ENOTTY; 575 } 576 return error; 577 } 578
Indexes created Sat Sep 20 22:09:52 GMT 2025