1 /*- 2 * Copyright (c) 2015 M. Warner Losh <imp@FreeBSD.org> 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice unmodified, this list of conditions, and the following 9 * disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26 #include <sys/cdefs.h> 27 __FBSDID("$FreeBSD$"); 28 29 #include <sys/param.h> 30 #include <sys/systm.h> 31 #include <sys/kernel.h> 32 33 #include <sys/bus.h> 34 #include <sys/errno.h> 35 #include <sys/libkern.h> 36 #include <sys/lock.h> 37 #include <sys/malloc.h> 38 #include <sys/module.h> 39 #include <sys/mutex.h> 40 #include <sys/sysctl.h> 41 42 #include <dev/ow/ow.h> 43 #include <dev/ow/owll.h> 44 #include <dev/ow/own.h> 45 46 /* 47 * lldev - link level device 48 * ndev - network / transport device (this module) 49 * pdev - presentation device (children of this module) 50 */ 51 52 typedef int ow_enum_fn(device_t, device_t); 53 typedef int ow_found_fn(device_t, romid_t); 54 55 struct ow_softc 56 { 57 device_t dev; /* Newbus driver back pointer */ 58 struct mtx mtx; /* bus mutex */ 59 device_t owner; /* bus owner, if != NULL */ 60 }; 61 62 struct ow_devinfo 63 { 64 romid_t romid; 65 }; 66 67 static int ow_acquire_bus(device_t ndev, device_t pdev, int how); 68 static void ow_release_bus(device_t ndev, device_t pdev); 69 70 #define OW_LOCK(_sc) mtx_lock(&(_sc)->mtx) 71 #define OW_UNLOCK(_sc) mtx_unlock(&(_sc)->mtx) 72 #define OW_LOCK_DESTROY(_sc) mtx_destroy(&_sc->mtx) 73 #define OW_ASSERT_LOCKED(_sc) mtx_assert(&_sc->mtx, MA_OWNED) 74 #define OW_ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->mtx, MA_NOTOWNED) 75 76 static MALLOC_DEFINE(M_OW, "ow", "House keeping data for 1wire bus"); 77 78 static const struct ow_timing timing_regular_min = { 79 .t_slot = 60, 80 .t_low0 = 60, 81 .t_low1 = 1, 82 .t_release = 0, 83 .t_rec = 1, 84 .t_rdv = 15, /* fixed */ 85 .t_rstl = 480, 86 .t_rsth = 480, 87 .t_pdl = 60, 88 .t_pdh = 15, 89 .t_lowr = 1, 90 }; 91 92 static const struct ow_timing timing_regular_max = { 93 .t_slot = 120, 94 .t_low0 = 120, 95 .t_low1 = 15, 96 .t_release = 45, 97 .t_rec = 960, /* infinity */ 98 .t_rdv = 15, /* fixed */ 99 .t_rstl = 960, /* infinity */ 100 .t_rsth = 960, /* infinity */ 101 .t_pdl = 240, /* 60us to 240us */ 102 .t_pdh = 60, /* 15us to 60us */ 103 .t_lowr = 15, /* 1us */ 104 }; 105 106 static struct ow_timing timing_regular = { 107 .t_slot = 60, /* 60 <= t < 120 */ 108 .t_low0 = 60, /* 60 <= t < t_slot < 120 */ 109 .t_low1 = 1, /* 1 <= t < 15 */ 110 .t_release = 45, /* 0 <= t < 45 */ 111 .t_rec = 15, /* 1 <= t < inf */ 112 .t_rdv = 15, /* t == 15 */ 113 .t_rstl = 480, /* 480 <= t < inf */ 114 .t_rsth = 480, /* 480 <= t < inf */ 115 .t_pdl = 60, /* 60 <= t < 240 */ 116 .t_pdh = 60, /* 15 <= t < 60 */ 117 .t_lowr = 1, /* 1 <= t < 15 */ 118 }; 119 120 /* NB: Untested */ 121 static const struct ow_timing timing_overdrive_min = { 122 .t_slot = 6, 123 .t_low0 = 6, 124 .t_low1 = 1, 125 .t_release = 0, 126 .t_rec = 1, 127 .t_rdv = 2, /* fixed */ 128 .t_rstl = 48, 129 .t_rsth = 48, 130 .t_pdl = 8, 131 .t_pdh = 2, 132 .t_lowr = 1, 133 }; 134 135 static const struct ow_timing timing_overdrive_max = { 136 .t_slot = 16, 137 .t_low0 = 16, 138 .t_low1 = 2, 139 .t_release = 4, 140 .t_rec = 960, /* infinity */ 141 .t_rdv = 2, /* fixed */ 142 .t_rstl = 80, 143 .t_rsth = 960, /* infinity */ 144 .t_pdl = 24, 145 .t_pdh = 6, 146 .t_lowr = 2, 147 }; 148 149 static struct ow_timing timing_overdrive = { 150 .t_slot = 11, /* 6 <= t < 16 */ 151 .t_low0 = 6, /* 6 <= t < t_slot < 16 */ 152 .t_low1 = 1, /* 1 <= t < 2 */ 153 .t_release = 4, /* 0 <= t < 4 */ 154 .t_rec = 1, /* 1 <= t < inf */ 155 .t_rdv = 2, /* t == 2 */ 156 .t_rstl = 48, /* 48 <= t < 80 */ 157 .t_rsth = 48, /* 48 <= t < inf */ 158 .t_pdl = 8, /* 8 <= t < 24 */ 159 .t_pdh = 2, /* 2 <= t < 6 */ 160 .t_lowr = 1, /* 1 <= t < 2 */ 161 }; 162 163 SYSCTL_NODE(_hw, OID_AUTO, ow, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 164 "1-Wire protocol"); 165 SYSCTL_NODE(_hw_ow, OID_AUTO, regular, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 166 "Regular mode timings"); 167 SYSCTL_NODE(_hw_ow, OID_AUTO, overdrive, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 168 "Overdrive mode timings"); 169 170 #define _OW_TIMING_SYSCTL(mode, param) \ 171 static int \ 172 sysctl_ow_timing_ ## mode ## _ ## param(SYSCTL_HANDLER_ARGS) \ 173 { \ 174 int val = timing_ ## mode.param; \ 175 int err; \ 176 err = sysctl_handle_int(oidp, &val, 0, req); \ 177 if (err != 0 || req->newptr == NULL) \ 178 return (err); \ 179 if (val < timing_ ## mode ## _min.param) \ 180 return (EINVAL); \ 181 else if (val >= timing_ ## mode ## _max.param) \ 182 return (EINVAL); \ 183 timing_ ## mode.param = val; \ 184 return (0); \ 185 } \ 186 SYSCTL_PROC(_hw_ow_ ## mode, OID_AUTO, param, \ 187 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int), \ 188 sysctl_ow_timing_ ## mode ## _ ## param, "I", \ 189 "1-Wire timing parameter in microseconds (-1 resets to default)") 190 191 #define OW_TIMING_SYSCTL(param) \ 192 _OW_TIMING_SYSCTL(regular, param); \ 193 _OW_TIMING_SYSCTL(overdrive, param) 194 195 OW_TIMING_SYSCTL(t_slot); 196 OW_TIMING_SYSCTL(t_low0); 197 OW_TIMING_SYSCTL(t_low1); 198 OW_TIMING_SYSCTL(t_release); 199 OW_TIMING_SYSCTL(t_rec); 200 OW_TIMING_SYSCTL(t_rdv); 201 OW_TIMING_SYSCTL(t_rstl); 202 OW_TIMING_SYSCTL(t_rsth); 203 OW_TIMING_SYSCTL(t_pdl); 204 OW_TIMING_SYSCTL(t_pdh); 205 OW_TIMING_SYSCTL(t_lowr); 206 207 #undef _OW_TIMING_SYSCTL 208 #undef OW_TIMING_SYSCTL 209 210 static void 211 ow_send_byte(device_t lldev, struct ow_timing *t, uint8_t byte) 212 { 213 int i; 214 215 for (i = 0; i < 8; i++) 216 if (byte & (1 << i)) 217 OWLL_WRITE_ONE(lldev, t); 218 else 219 OWLL_WRITE_ZERO(lldev, t); 220 } 221 222 static void 223 ow_read_byte(device_t lldev, struct ow_timing *t, uint8_t *bytep) 224 { 225 int i; 226 uint8_t byte = 0; 227 int bit; 228 229 for (i = 0; i < 8; i++) { 230 OWLL_READ_DATA(lldev, t, &bit); 231 byte |= bit << i; 232 } 233 *bytep = byte; 234 } 235 236 static int 237 ow_send_command(device_t ndev, device_t pdev, struct ow_cmd *cmd) 238 { 239 int present, i, bit, tries; 240 device_t lldev; 241 struct ow_timing *t; 242 243 lldev = device_get_parent(ndev); 244 245 /* 246 * Retry the reset a couple of times before giving up. 247 */ 248 tries = 4; 249 do { 250 OWLL_RESET_AND_PRESENCE(lldev, &timing_regular, &present); 251 if (present == 1) 252 device_printf(ndev, "Reset said no device on bus?.\n"); 253 } while (present == 1 && tries-- > 0); 254 if (present == 1) { 255 device_printf(ndev, "Reset said the device wasn't there.\n"); 256 return ENOENT; /* No devices acked the RESET */ 257 } 258 if (present == -1) { 259 device_printf(ndev, "Reset discovered bus wired wrong.\n"); 260 return ENOENT; 261 } 262 263 for (i = 0; i < cmd->rom_len; i++) 264 ow_send_byte(lldev, &timing_regular, cmd->rom_cmd[i]); 265 for (i = 0; i < cmd->rom_read_len; i++) 266 ow_read_byte(lldev, &timing_regular, cmd->rom_read + i); 267 if (cmd->xpt_len) { 268 /* 269 * Per AN937, the reset pulse and ROM level are always 270 * done with the regular timings. Certain ROM commands 271 * put the device into overdrive mode for the remainder 272 * of the data transfer, which is why we have to pass the 273 * timings here. Commands that need to be handled like this 274 * are expected to be flagged by the client. 275 */ 276 t = (cmd->flags & OW_FLAG_OVERDRIVE) ? 277 &timing_overdrive : &timing_regular; 278 for (i = 0; i < cmd->xpt_len; i++) 279 ow_send_byte(lldev, t, cmd->xpt_cmd[i]); 280 if (cmd->flags & OW_FLAG_READ_BIT) { 281 memset(cmd->xpt_read, 0, (cmd->xpt_read_len + 7) / 8); 282 for (i = 0; i < cmd->xpt_read_len; i++) { 283 OWLL_READ_DATA(lldev, t, &bit); 284 cmd->xpt_read[i / 8] |= bit << (i % 8); 285 } 286 } else { 287 for (i = 0; i < cmd->xpt_read_len; i++) 288 ow_read_byte(lldev, t, cmd->xpt_read + i); 289 } 290 } 291 return 0; 292 } 293 294 static int 295 ow_search_rom(device_t lldev, device_t dev) 296 { 297 struct ow_cmd cmd; 298 299 memset(&cmd, 0, sizeof(cmd)); 300 cmd.rom_cmd[0] = SEARCH_ROM; 301 cmd.rom_len = 1; 302 return ow_send_command(lldev, dev, &cmd); 303 } 304 305 #if 0 306 static int 307 ow_alarm_search(device_t lldev, device_t dev) 308 { 309 struct ow_cmd cmd; 310 311 memset(&cmd, 0, sizeof(cmd)); 312 cmd.rom_cmd[0] = ALARM_SEARCH; 313 cmd.rom_len = 1; 314 return ow_send_command(lldev, dev, &cmd); 315 } 316 #endif 317 318 static int 319 ow_add_child(device_t dev, romid_t romid) 320 { 321 struct ow_devinfo *di; 322 device_t child; 323 324 di = malloc(sizeof(*di), M_OW, M_WAITOK); 325 di->romid = romid; 326 child = device_add_child(dev, NULL, -1); 327 if (child == NULL) { 328 free(di, M_OW); 329 return ENOMEM; 330 } 331 device_set_ivars(child, di); 332 return (0); 333 } 334 335 static device_t 336 ow_child_by_romid(device_t dev, romid_t romid) 337 { 338 device_t *children, retval, child; 339 int nkid, i; 340 struct ow_devinfo *di; 341 342 if (device_get_children(dev, &children, &nkid) != 0) 343 return (NULL); 344 retval = NULL; 345 for (i = 0; i < nkid; i++) { 346 child = children[i]; 347 di = device_get_ivars(child); 348 if (di->romid == romid) { 349 retval = child; 350 break; 351 } 352 } 353 free(children, M_TEMP); 354 355 return (retval); 356 } 357 358 /* 359 * CRC generator table -- taken from AN937 DOW CRC LOOKUP FUNCTION Table 2 360 */ 361 const uint8_t ow_crc_table[] = { 362 0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65, 363 157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220, 364 35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98, 365 190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255, 366 70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7, 367 219, 133,103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154, 368 101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36, 369 248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185, 370 140,210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113,147, 205, 371 17, 79, 173, 243, 112, 46, 204, 146, 211,141, 111, 49, 178, 236, 14, 80, 372 175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82,176, 238, 373 50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115, 374 202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139, 375 87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22, 376 233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168, 377 116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53 378 }; 379 380 /* 381 * Converted from DO_CRC page 131 ANN937 382 */ 383 static uint8_t 384 ow_crc(device_t ndev, device_t pdev, uint8_t *buffer, size_t len) 385 { 386 uint8_t crc = 0; 387 int i; 388 389 for (i = 0; i < len; i++) 390 crc = ow_crc_table[crc ^ buffer[i]]; 391 return crc; 392 } 393 394 static int 395 ow_check_crc(romid_t romid) 396 { 397 return ow_crc(NULL, NULL, (uint8_t *)&romid, sizeof(romid)) == 0; 398 } 399 400 static int 401 ow_device_found(device_t dev, romid_t romid) 402 { 403 404 /* XXX Move this up into enumerate? */ 405 /* 406 * All valid ROM IDs have a valid CRC. Check that first. 407 */ 408 if (!ow_check_crc(romid)) { 409 device_printf(dev, "Device romid %8D failed CRC.\n", 410 &romid, ":"); 411 return EINVAL; 412 } 413 414 /* 415 * If we've seen this child before, don't add a new one for it. 416 */ 417 if (ow_child_by_romid(dev, romid) != NULL) 418 return 0; 419 420 return ow_add_child(dev, romid); 421 } 422 423 static int 424 ow_enumerate(device_t dev, ow_enum_fn *enumfp, ow_found_fn *foundfp) 425 { 426 device_t lldev = device_get_parent(dev); 427 int first, second, i, dir, prior, last, err, retries; 428 uint64_t probed, last_mask; 429 int sanity = 10; 430 431 prior = -1; 432 last_mask = 0; 433 retries = 0; 434 last = -2; 435 err = ow_acquire_bus(dev, dev, OWN_DONTWAIT); 436 if (err != 0) 437 return err; 438 while (last != -1) { 439 if (sanity-- < 0) { 440 printf("Reached the sanity limit\n"); 441 return EIO; 442 } 443 again: 444 probed = 0; 445 last = -1; 446 447 /* 448 * See AN397 section 5.II.C.3 for the algorithm (though a bit 449 * poorly stated). The search command forces each device to 450 * send ROM ID bits one at a time (first the bit, then the 451 * complement) the master (us) sends back a bit. If the 452 * device's bit doesn't match what we send back, that device 453 * stops sending bits back. So each time through we remember 454 * where we made the last decision (always 0). If there's a 455 * conflict there this time (and there will be in the absence 456 * of a hardware failure) we go with 1. This way, we prune the 457 * devices on the bus and wind up with a unique ROM. We know 458 * we're done when we detect no new conflicts. The same 459 * algorithm is used for devices in alarm state as well. 460 * 461 * In addition, experience has shown that sometimes devices 462 * stop responding in the middle of enumeration, so try this 463 * step again a few times when that happens. It is unclear if 464 * this is due to a nosiy electrical environment or some odd 465 * timing issue. 466 */ 467 468 /* 469 * The enumeration command should be successfully sent, if not, 470 * we have big issues on the bus so punt. Lower layers report 471 * any unusual errors, so we don't need to here. 472 */ 473 err = enumfp(dev, dev); 474 if (err != 0) 475 return (err); 476 477 for (i = 0; i < 64; i++) { 478 OWLL_READ_DATA(lldev, &timing_regular, &first); 479 OWLL_READ_DATA(lldev, &timing_regular, &second); 480 switch (first | second << 1) { 481 case 0: /* Conflict */ 482 if (i < prior) 483 dir = (last_mask >> i) & 1; 484 else 485 dir = i == prior; 486 487 if (dir == 0) 488 last = i; 489 break; 490 case 1: /* 1 then 0 -> 1 for all */ 491 dir = 1; 492 break; 493 case 2: /* 0 then 1 -> 0 for all */ 494 dir = 0; 495 break; 496 case 3: 497 /* 498 * No device responded. This is unexpected, but 499 * experience has shown that on some platforms 500 * we miss a timing window, or otherwise have 501 * an issue. Start this step over. Since we've 502 * not updated prior yet, we can just jump to 503 * the top of the loop for a re-do of this step. 504 */ 505 printf("oops, starting over\n"); 506 if (++retries > 5) 507 return (EIO); 508 goto again; 509 default: /* NOTREACHED */ 510 __assert_unreachable(); 511 } 512 if (dir) { 513 OWLL_WRITE_ONE(lldev, &timing_regular); 514 probed |= 1ull << i; 515 } else { 516 OWLL_WRITE_ZERO(lldev, &timing_regular); 517 } 518 } 519 retries = 0; 520 foundfp(dev, probed); 521 last_mask = probed; 522 prior = last; 523 } 524 ow_release_bus(dev, dev); 525 526 return (0); 527 } 528 529 static int 530 ow_probe(device_t dev) 531 { 532 533 device_set_desc(dev, "1 Wire Bus"); 534 return (BUS_PROBE_GENERIC); 535 } 536 537 static int 538 ow_attach(device_t ndev) 539 { 540 struct ow_softc *sc; 541 542 /* 543 * Find all the devices on the bus. We don't probe / attach them in the 544 * enumeration phase. We do this because we want to allow the probe / 545 * attach routines of the child drivers to have as full an access to the 546 * bus as possible. While we reset things before the next step of the 547 * search (so it would likely be OK to allow access by the clients to 548 * the bus), it is more conservative to find them all, then to do the 549 * attach of the devices. This also allows the child devices to have 550 * more knowledge of the bus. We also ignore errors from the enumeration 551 * because they might happen after we've found a few devices. 552 */ 553 sc = device_get_softc(ndev); 554 sc->dev = ndev; 555 mtx_init(&sc->mtx, device_get_nameunit(sc->dev), "ow", MTX_DEF); 556 ow_enumerate(ndev, ow_search_rom, ow_device_found); 557 return bus_generic_attach(ndev); 558 } 559 560 static int 561 ow_detach(device_t ndev) 562 { 563 device_t *children, child; 564 int nkid, i; 565 struct ow_devinfo *di; 566 struct ow_softc *sc; 567 568 sc = device_get_softc(ndev); 569 /* 570 * detach all the children first. This is blocking until any threads 571 * have stopped, etc. 572 */ 573 bus_generic_detach(ndev); 574 575 /* 576 * We delete all the children, and free up the ivars 577 */ 578 if (device_get_children(ndev, &children, &nkid) != 0) 579 return ENOMEM; 580 for (i = 0; i < nkid; i++) { 581 child = children[i]; 582 di = device_get_ivars(child); 583 free(di, M_OW); 584 device_delete_child(ndev, child); 585 } 586 free(children, M_TEMP); 587 588 OW_LOCK_DESTROY(sc); 589 return 0; 590 } 591 592 /* 593 * Not sure this is really needed. I'm having trouble figuring out what 594 * location means in the context of the one wire bus. 595 */ 596 static int 597 ow_child_location_str(device_t dev, device_t child, char *buf, 598 size_t buflen) 599 { 600 601 *buf = '\0'; 602 return (0); 603 } 604 605 static int 606 ow_child_pnpinfo_str(device_t dev, device_t child, char *buf, 607 size_t buflen) 608 { 609 struct ow_devinfo *di; 610 611 di = device_get_ivars(child); 612 snprintf(buf, buflen, "romid=%8D", &di->romid, ":"); 613 return (0); 614 } 615 616 static int 617 ow_read_ivar(device_t dev, device_t child, int which, uintptr_t *result) 618 { 619 struct ow_devinfo *di; 620 romid_t **ptr; 621 622 di = device_get_ivars(child); 623 switch (which) { 624 case OW_IVAR_FAMILY: 625 *result = di->romid & 0xff; 626 break; 627 case OW_IVAR_ROMID: 628 ptr = (romid_t **)result; 629 *ptr = &di->romid; 630 break; 631 default: 632 return EINVAL; 633 } 634 635 return 0; 636 } 637 638 static int 639 ow_write_ivar(device_t dev, device_t child, int which, uintptr_t value) 640 { 641 642 return EINVAL; 643 } 644 645 static int 646 ow_print_child(device_t ndev, device_t pdev) 647 { 648 int retval = 0; 649 struct ow_devinfo *di; 650 651 di = device_get_ivars(pdev); 652 653 retval += bus_print_child_header(ndev, pdev); 654 retval += printf(" romid %8D", &di->romid, ":"); 655 retval += bus_print_child_footer(ndev, pdev); 656 657 return retval; 658 } 659 660 static void 661 ow_probe_nomatch(device_t ndev, device_t pdev) 662 { 663 struct ow_devinfo *di; 664 665 di = device_get_ivars(pdev); 666 device_printf(ndev, "romid %8D: no driver\n", &di->romid, ":"); 667 } 668 669 static int 670 ow_acquire_bus(device_t ndev, device_t pdev, int how) 671 { 672 struct ow_softc *sc; 673 674 sc = device_get_softc(ndev); 675 OW_ASSERT_UNLOCKED(sc); 676 OW_LOCK(sc); 677 if (sc->owner != NULL) { 678 if (sc->owner == pdev) 679 panic("%s: %s recursively acquiring the bus.\n", 680 device_get_nameunit(ndev), 681 device_get_nameunit(pdev)); 682 if (how == OWN_DONTWAIT) { 683 OW_UNLOCK(sc); 684 return EWOULDBLOCK; 685 } 686 while (sc->owner != NULL) 687 mtx_sleep(sc, &sc->mtx, 0, "owbuswait", 0); 688 } 689 sc->owner = pdev; 690 OW_UNLOCK(sc); 691 692 return 0; 693 } 694 695 static void 696 ow_release_bus(device_t ndev, device_t pdev) 697 { 698 struct ow_softc *sc; 699 700 sc = device_get_softc(ndev); 701 OW_ASSERT_UNLOCKED(sc); 702 OW_LOCK(sc); 703 if (sc->owner == NULL) 704 panic("%s: %s releasing unowned bus.", device_get_nameunit(ndev), 705 device_get_nameunit(pdev)); 706 if (sc->owner != pdev) 707 panic("%s: %s don't own the bus. %s does. game over.", 708 device_get_nameunit(ndev), device_get_nameunit(pdev), 709 device_get_nameunit(sc->owner)); 710 sc->owner = NULL; 711 wakeup(sc); 712 OW_UNLOCK(sc); 713 } 714 715 devclass_t ow_devclass; 716 717 static device_method_t ow_methods[] = { 718 /* Device interface */ 719 DEVMETHOD(device_probe, ow_probe), 720 DEVMETHOD(device_attach, ow_attach), 721 DEVMETHOD(device_detach, ow_detach), 722 723 /* Bus interface */ 724 DEVMETHOD(bus_child_pnpinfo_str, ow_child_pnpinfo_str), 725 DEVMETHOD(bus_child_location_str, ow_child_location_str), 726 DEVMETHOD(bus_read_ivar, ow_read_ivar), 727 DEVMETHOD(bus_write_ivar, ow_write_ivar), 728 DEVMETHOD(bus_print_child, ow_print_child), 729 DEVMETHOD(bus_probe_nomatch, ow_probe_nomatch), 730 731 /* One Wire Network/Transport layer interface */ 732 DEVMETHOD(own_send_command, ow_send_command), 733 DEVMETHOD(own_acquire_bus, ow_acquire_bus), 734 DEVMETHOD(own_release_bus, ow_release_bus), 735 DEVMETHOD(own_crc, ow_crc), 736 { 0, 0 } 737 }; 738 739 static driver_t ow_driver = { 740 "ow", 741 ow_methods, 742 sizeof(struct ow_softc), 743 }; 744 745 DRIVER_MODULE(ow, owc, ow_driver, ow_devclass, 0, 0); 746 MODULE_VERSION(ow, 1); 747