Lines Matching defs:wd
1 /* $NetBSD: wd.c,v 1.474 2025/04/13 14:00:59 jakllsch Exp $ */
57 __KERNEL_RCSID(0, "$NetBSD: wd.c,v 1.474 2025/04/13 14:00:59 jakllsch Exp $");
132 CFATTACH_DECL3_NEW(wd, sizeof(struct wd_softc),
309 struct wd_softc *wd = device_private(self);
310 struct dk_softc *dksc = &wd->sc_dksc;
321 mutex_init(&wd->sc_lock, MUTEX_DEFAULT, IPL_BIO);
323 SLIST_INIT(&wd->sc_bslist);
324 cv_init(&wd->sc_bslist_cv, "wdbadsect");
326 wd->atabus = adev->adev_bustype;
327 wd->inflight = 0;
328 wd->drvp = adev->adev_drv_data;
330 wd->drvp->drv_openings = 1;
331 wd->drvp->drv_done = wddone;
332 wd->drvp->drv_softc = dksc->sc_dev; /* done in atabusconfig_thread()
335 SLIST_INIT(&wd->sc_retry_list);
336 SLIST_INIT(&wd->sc_requeue_list);
337 callout_init(&wd->sc_retry_callout, 0); /* XXX MPSAFE */
338 callout_init(&wd->sc_requeue_callout, 0); /* XXX MPSAFE */
339 callout_init(&wd->sc_restart_diskqueue, 0); /* XXX MPSAFE */
345 if (wd_get_params(wd, &wd->sc_params) != 0) {
350 for (blank = 0, p = wd->sc_params.atap_model, q = tbuf, i = 0;
351 i < sizeof(wd->sc_params.atap_model); i++) {
366 wd->sc_typename = kmem_asprintf("%s", tbuf);
367 aprint_normal_dev(self, "<%s>\n", wd->sc_typename);
371 wd->sc_quirks = wdq->wdq_quirks;
373 if (wd->sc_quirks != 0) {
375 snprintb(sbuf, sizeof(sbuf), WD_QUIRK_FMT, wd->sc_quirks);
378 if (wd->sc_quirks & WD_QUIRK_SPLIT_MOD15_WRITE) {
383 if ((wd->sc_params.atap_multi & 0xff) > 1) {
384 wd->drvp->multi = wd->sc_params.atap_multi & 0xff;
386 wd->drvp->multi = 1;
390 wd->drvp->multi);
393 if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0)
394 wd->sc_flags |= WDF_LBA48;
397 if ((wd->sc_params.atap_capabilities1 & WDC_CAP_LBA) != 0)
398 wd->sc_flags |= WDF_LBA;
401 if (wd->sc_params.atap_ataversion != 0xffff &&
402 wd->sc_params.atap_ataversion >= WDC_VER_ATA4)
403 wd->sc_flags |= WDF_LBA;
406 if ((wd->sc_flags & WDF_LBA48) != 0) {
408 wd->sc_capacity =
409 ((uint64_t) wd->sc_params.atap_max_lba[3] << 48) |
410 ((uint64_t) wd->sc_params.atap_max_lba[2] << 32) |
411 ((uint64_t) wd->sc_params.atap_max_lba[1] << 16) |
412 ((uint64_t) wd->sc_params.atap_max_lba[0] << 0);
413 wd->sc_capacity28 =
414 (wd->sc_params.atap_capacity[1] << 16) |
415 wd->sc_params.atap_capacity[0];
419 if (wd->sc_capacity28 > 0xfffffff)
420 wd->sc_capacity28 = 0xfffffff;
421 } else if ((wd->sc_flags & WDF_LBA) != 0) {
423 wd->sc_capacity28 =
424 (wd->sc_params.atap_capacity[1] << 16) |
425 wd->sc_params.atap_capacity[0];
429 if (wd->sc_capacity28 > 0xfffffff)
430 wd->sc_capacity28 = 0xfffffff;
431 wd->sc_capacity = wd->sc_capacity28;
434 wd->sc_capacity =
435 wd->sc_params.atap_cylinders *
436 wd->sc_params.atap_heads *
437 wd->sc_params.atap_sectors;
443 if (wd->sc_capacity < 0xfffffff)
444 wd->sc_capacity28 = wd->sc_capacity;
446 wd->sc_capacity28 = 0xfffffff;
448 if ((wd->sc_params.atap_secsz & ATA_SECSZ_VALID_MASK) == ATA_SECSZ_VALID
449 && ((wd->sc_params.atap_secsz & ATA_SECSZ_LLS) != 0)) {
450 wd->sc_blksize = 2ULL *
451 ((uint32_t)((wd->sc_params.atap_lls_secsz[1] << 16) |
452 wd->sc_params.atap_lls_secsz[0]));
454 wd->sc_blksize = 512;
456 if ((wd->sc_params.atap_secsz & ATA_SECSZ_VALID_MASK) == ATA_SECSZ_VALID
457 && ((wd->sc_params.atap_secsz & ATA_SECSZ_LPS) != 0)) {
459 (wd->sc_params.atap_secsz & ATA_SECSZ_LPS_SZMSK);
460 if ((wd->sc_params.atap_logical_align & ATA_LA_VALID_MASK) ==
463 wd->sc_params.atap_logical_align & ATA_LA_MASK;
466 wd->sc_capacity512 = (wd->sc_capacity * wd->sc_blksize) / DEV_BSIZE;
467 format_bytes(pbuf, sizeof(pbuf), wd->sc_capacity * wd->sc_blksize);
471 (wd->sc_flags & WDF_LBA) ? (int)(wd->sc_capacity /
472 (wd->sc_params.atap_heads * wd->sc_params.atap_sectors)) :
473 wd->sc_params.atap_cylinders,
474 wd->sc_params.atap_heads, wd->sc_params.atap_sectors,
475 wd->sc_blksize, (unsigned long long)wd->sc_capacity);
478 alignment * wd->sc_blksize);
488 device_xname(self), wd->sc_params.atap_dmatiming_mimi,
489 wd->sc_params.atap_dmatiming_recom), DEBUG_PROBE);
491 if (wd->sc_blksize <= 0 || !powerof2(wd->sc_blksize) ||
492 wd->sc_blksize < DEV_BSIZE || wd->sc_blksize > MAXPHYS) {
494 "might not actually work\n", wd->sc_blksize);
497 if (strcmp(wd->sc_params.atap_model, "ST506") == 0)
512 wd_set_geometry(wd);
517 wd->drvp->lp = dksc->sc_dkdev.dk_label;
525 wd_sysctl_attach(wd);
547 struct wd_softc *wd = device_private(self);
548 struct dk_softc *dksc = &wd->sc_dksc;
568 mutex_enter(&wd->sc_lock);
569 wd->atabus->ata_killpending(wd->drvp);
571 callout_halt(&wd->sc_retry_callout, &wd->sc_lock);
572 callout_destroy(&wd->sc_retry_callout);
573 callout_halt(&wd->sc_requeue_callout, &wd->sc_lock);
574 callout_destroy(&wd->sc_requeue_callout);
575 callout_halt(&wd->sc_restart_diskqueue, &wd->sc_lock);
576 callout_destroy(&wd->sc_restart_diskqueue);
578 mutex_exit(&wd->sc_lock);
586 wd_standby(wd, AT_POLL);
596 while (!SLIST_EMPTY(&wd->sc_bslist)) {
597 struct disk_badsectors *dbs = SLIST_FIRST(&wd->sc_bslist);
598 SLIST_REMOVE_HEAD(&wd->sc_bslist, dbs_next);
601 wd->sc_bscount = 0;
603 if (wd->sc_typename != NULL) {
604 kmem_free(wd->sc_typename, strlen(wd->sc_typename) + 1);
605 wd->sc_typename = NULL;
610 wd_sysctl_detach(wd);
613 KASSERT(SLIST_EMPTY(&wd->sc_bslist));
614 cv_destroy(&wd->sc_bslist_cv);
617 mutex_destroy(&wd->sc_lock);
619 wd->drvp->drive_type = ATA_DRIVET_NONE; /* no drive any more here */
620 wd->drvp->drive_flags = 0;
632 struct wd_softc *wd =
634 struct dk_softc *dksc = &wd->sc_dksc;
642 if ((wd->sc_flags & WDF_LOADED) == 0 ||
654 if (__predict_false(!SLIST_EMPTY(&wd->sc_bslist))) {
666 maxblk = blkno + (bp->b_bcount / wd->sc_blksize) - 1;
668 mutex_enter(&wd->sc_lock);
669 SLIST_FOREACH(dbs, &wd->sc_bslist, dbs_next)
673 mutex_exit(&wd->sc_lock);
676 mutex_exit(&wd->sc_lock);
690 wdstart1(struct wd_softc *wd, struct buf *bp, struct ata_xfer *xfer)
692 struct dk_softc *dksc = &wd->sc_dksc;
697 KASSERT(mutex_owned(&wd->sc_lock));
726 if (BUF_ISREAD(bp) && xfer->c_retries == 0 && wd->drv_chaos_freq > 0 &&
727 (++wd->drv_chaos_cnt % wd->drv_chaos_freq) == 0) {
730 xfer->c_bio.blkno = 7777777 + wd->sc_capacity;
752 if (wd->sc_flags & WDF_LBA48 &&
754 wd->sc_capacity28) ||
767 if (WD_USE_NCQ(wd) && (xfer->c_retries < WDIORETRIES_SINGLE ||
772 if (WD_USE_NCQ_PRIO(wd) &&
777 if (wd->sc_flags & WDF_LBA)
783 wd->sc_flags |= WDF_DIRTY;
787 KASSERT((wd->sc_flags & WDF_LBA48) != 0);
795 wd->inflight++;
796 mutex_exit(&wd->sc_lock);
799 wd->atabus->ata_bio(wd->drvp, xfer);
801 mutex_enter(&wd->sc_lock);
807 struct wd_softc *wd = device_private(dev);
809 struct dk_softc *dksc = &wd->sc_dksc;
816 mutex_enter(&wd->sc_lock);
818 chp = wd->drvp->chnl_softc;
824 openings = uimin(openings, wd->drvp->drv_openings);
826 if (wd->inflight >= openings) {
856 if (!callout_pending(&wd->sc_restart_diskqueue)) {
857 callout_reset(&wd->sc_restart_diskqueue, ticks,
861 mutex_exit(&wd->sc_lock);
865 wdstart1(wd, bp, xfer);
867 mutex_exit(&wd->sc_lock);
879 struct wd_softc *wd = device_private(self);
880 struct dk_softc *dksc = &wd->sc_dksc;
894 struct wd_softc *wd = device_private(self);
895 struct dk_softc *dksc = &wd->sc_dksc;
905 ata_free_xfer(wd->drvp->chnl_softc, xfer);
939 ata_channel_lock(wd->drvp->chnl_softc);
940 ata_thread_run(wd->drvp->chnl_softc, wflags,
941 ATACH_TH_DRIVE_RESET, wd->drvp->drive);
942 ata_channel_unlock(wd->drvp->chnl_softc);
945 mutex_enter(&wd->sc_lock);
947 diskerr(bp, "wd", errmsg, LOG_PRINTF,
955 wdperror(wd, xfer);
962 SLIST_INSERT_HEAD(&wd->sc_requeue_list, xfer,
964 callout_reset(&wd->sc_requeue_callout,
965 1, wdbiorequeue, wd);
967 SLIST_INSERT_HEAD(&wd->sc_retry_list, xfer,
969 callout_reset(&wd->sc_retry_callout,
970 RECOVERYTIME, wdbioretry, wd);
973 mutex_exit(&wd->sc_lock);
977 mutex_exit(&wd->sc_lock);
987 ((wd->drvp->ata_vers >= 4 && xfer->c_bio.r_error & 64) ||
988 (wd->drvp->ata_vers < 4 && xfer->c_bio.r_error & 192))) {
1000 (bp->b_bcount /wd->sc_blksize) - 1;
1003 mutex_enter(&wd->sc_lock);
1004 SLIST_INSERT_HEAD(&wd->sc_bslist, dbs, dbs_next);
1005 wd->sc_bscount++;
1006 mutex_exit(&wd->sc_lock);
1044 ata_free_xfer(wd->drvp->chnl_softc, xfer);
1046 mutex_enter(&wd->sc_lock);
1047 wd->inflight--;
1048 mutex_exit(&wd->sc_lock);
1056 struct wd_softc *wd = v;
1059 ATADEBUG_PRINT(("%s %s\n", __func__, wd->sc_dksc.sc_xname),
1062 mutex_enter(&wd->sc_lock);
1063 while ((xfer = SLIST_FIRST(&wd->sc_retry_list))) {
1064 SLIST_REMOVE_HEAD(&wd->sc_retry_list, c_retrychain);
1065 wdstart1(wd, xfer->c_bio.bp, xfer);
1067 mutex_exit(&wd->sc_lock);
1073 struct wd_softc *wd = v;
1076 ATADEBUG_PRINT(("%s %s\n", __func__, wd->sc_dksc.sc_xname),
1079 mutex_enter(&wd->sc_lock);
1080 while ((xfer = SLIST_FIRST(&wd->sc_requeue_list))) {
1081 SLIST_REMOVE_HEAD(&wd->sc_requeue_list, c_retrychain);
1082 wdstart1(wd, xfer->c_bio.bp, xfer);
1084 mutex_exit(&wd->sc_lock);
1090 const struct wd_softc * const wd =
1099 if (wd->sc_flags & WDF_LBA48)
1104 if (bp->b_bcount > (wd->sc_blksize * maxsectors))
1105 bp->b_bcount = (wd->sc_blksize * maxsectors);
1144 struct wd_softc *wd;
1150 wd = device_lookup_private(&wd_cd, unit);
1151 if (wd == NULL)
1153 dksc = &wd->sc_dksc;
1160 if (wd->sc_capacity == 0)
1167 if ((wd->sc_flags & (WDF_OPEN | WDF_LOADED)) == WDF_OPEN) {
1183 struct wd_softc *wd = device_private(self);
1184 struct dk_softc *dksc = &wd->sc_dksc;
1187 error = wd->atabus->ata_addref(wd->drvp);
1191 if ((wd->sc_flags & WDF_LOADED) == 0) {
1195 param_error = wd_get_params(wd, &wd->sc_params);
1201 wd_set_geometry(wd);
1202 wd->sc_flags |= WDF_LOADED;
1205 wd->sc_flags |= WDF_OPEN;
1209 wd->atabus->ata_delref(wd->drvp);
1214 * Caller must hold wd->sc_dk.dk_openlock.
1219 struct wd_softc *wd = device_private(self);
1221 KASSERTMSG(bufq_peek(wd->sc_dksc.sc_bufq) == NULL, "bufq not empty");
1223 if (wd->sc_flags & WDF_DIRTY)
1224 wd_flushcache(wd, AT_WAIT);
1226 wd->atabus->ata_delref(wd->drvp);
1227 wd->sc_flags &= ~WDF_OPEN;
1235 struct wd_softc *wd;
1240 wd = device_lookup_private(&wd_cd, unit);
1241 dksc = &wd->sc_dksc;
1247 wdperror(const struct wd_softc *wd, struct ata_xfer *xfer)
1262 const struct dk_softc *dksc = &wd->sc_dksc;
1264 struct ata_drive_datas *drvp = wd->drvp;
1289 struct wd_softc *wd =
1291 struct dk_softc *dksc = &wd->sc_dksc;
1295 if ((wd->sc_flags & WDF_LOADED) == 0)
1305 bad144intern(wd);
1318 missing = wd->sc_bscount;
1334 mutex_enter(&wd->sc_lock);
1335 wd->sc_bslist_inuse++;
1336 SLIST_FOREACH(dbs, &wd->sc_bslist, dbs_next) {
1349 mutex_exit(&wd->sc_lock);
1351 mutex_enter(&wd->sc_lock);
1358 if (--wd->sc_bslist_inuse == 0)
1359 cv_broadcast(&wd->sc_bslist_cv);
1360 mutex_exit(&wd->sc_lock);
1376 mutex_enter(&wd->sc_lock);
1377 while (wd->sc_bslist_inuse) {
1378 error = cv_wait_sig(&wd->sc_bslist_cv, &wd->sc_lock);
1380 mutex_exit(&wd->sc_lock);
1384 while (!SLIST_EMPTY(&wd->sc_bslist)) {
1386 SLIST_FIRST(&wd->sc_bslist);
1387 SLIST_REMOVE_HEAD(&wd->sc_bslist, dbs_next);
1388 mutex_exit(&wd->sc_lock);
1390 mutex_enter(&wd->sc_lock);
1392 mutex_exit(&wd->sc_lock);
1393 wd->sc_bscount = 0;
1415 fop->df_startblk * wd->sc_dk.dk_label->d_secsize;
1426 return wd_getcache(wd, (int *)addr);
1429 return wd_setcache(wd, *(int *)addr);
1432 return wd_flushcache(wd, AT_WAIT);
1446 wi = wi_get(wd);
1506 struct wd_softc *wd = device_private(dev);
1512 if (!(wd->sc_params.atap_ata_major & WDC_VER_ATA7)
1513 || !(wd->sc_params.support_dsm & ATA_SUPPORT_DSM_TRIM)) {
1518 maxatonce = 0xffff; /*wd->sc_params.max_dsm_blocks*/
1522 if ((wd->sc_flags & WDF_LOADED) == 0)
1526 bno = (pos + wd->sc_blksize - 1) / wd->sc_blksize;
1527 size = ((pos + len) / wd->sc_blksize) - bno;
1535 result = wd_trim(wd, bno + done, amount);
1547 struct wd_softc *wd;
1552 wd = device_lookup_private(&wd_cd, unit);
1553 dksc = &wd->sc_dksc;
1571 struct wd_softc *wd;
1578 wd = device_lookup_private(&wd_cd, unit);
1579 if (wd == NULL)
1581 dksc = &wd->sc_dksc;
1595 struct wd_softc *wd;
1605 wd = device_lookup_private(&wd_cd, unit);
1606 if (wd == NULL)
1608 dksc = &wd->sc_dksc;
1616 struct wd_softc *wd = device_private(dev);
1617 struct dk_softc *dksc = &wd->sc_dksc;
1619 struct ata_xfer *xfer = &wd->dump_xfer;
1625 ata_channel_lock(wd->drvp->chnl_softc);
1627 ata_thread_run(wd->drvp->chnl_softc, AT_POLL,
1628 ATACH_TH_DRIVE_RESET, wd->drvp->drive);
1630 wd->drvp->state = RESET;
1631 ata_channel_unlock(wd->drvp->chnl_softc);
1639 if (wd->sc_flags & WDF_LBA48 &&
1640 (xfer->c_bio.blkno + nblk) > wd->sc_capacity28)
1642 if (wd->sc_flags & WDF_LBA)
1648 wd->atabus->ata_bio(wd->drvp, xfer);
1665 wdperror(wd, xfer);
1681 printf("wd%d: dump addr 0x%x, cylin %d, head %d, sector %d\n",
1695 bad144intern(struct wd_softc *wd)
1697 struct dk_softc *dksc = &wd->sc_dksc;
1707 wd->drvp->badsect[i] =
1713 wd->drvp->badsect[i] = -1;
1718 wd_set_geometry(struct wd_softc *wd)
1720 struct dk_softc *dksc = &wd->sc_dksc;
1725 dg->dg_secperunit = wd->sc_capacity;
1726 dg->dg_secsize = wd->sc_blksize;
1727 dg->dg_nsectors = wd->sc_params.atap_sectors;
1728 dg->dg_ntracks = wd->sc_params.atap_heads;
1729 if ((wd->sc_flags & WDF_LBA) == 0)
1730 dg->dg_ncylinders = wd->sc_params.atap_cylinders;
1731 if ((wd->sc_params.atap_secsz & ATA_SECSZ_VALID_MASK) == ATA_SECSZ_VALID
1732 && ((wd->sc_params.atap_secsz & ATA_SECSZ_LPS) != 0)) {
1733 dg->dg_physsecsize = wd->sc_blksize << (wd->sc_params.atap_secsz &
1735 if ((wd->sc_params.atap_logical_align & ATA_LA_VALID_MASK) ==
1737 dg->dg_alignedsec = (wd->sc_params.atap_logical_align &
1738 ATA_LA_MASK) & ((1u << (wd->sc_params.atap_secsz &
1743 disk_set_info(dksc->sc_dev, &dksc->sc_dkdev, wd->sc_typename);
1747 wd_get_params(struct wd_softc *wd, struct ataparams *params)
1750 struct ata_channel *chp = wd->drvp->chnl_softc;
1754 switch (wd->atabus->ata_get_params(wd->drvp, flags, params)) {
1761 (*wd->atabus->ata_reset_drive)(wd->drvp, flags, NULL);
1766 if (wd->drvp->drive_type != ATA_DRIVET_OLD)
1781 wd->drvp->ata_vers = -1; /* Mark it as pre-ATA */
1792 wd_getcache(struct wd_softc *wd, int *bitsp)
1796 if (wd_get_params(wd, ¶ms) != 0)
1808 if (WD_USE_NCQ(wd) || (wd->drvp->drive_flags & ATA_DRIVE_WFUA))
1838 wd_setcache(struct wd_softc *wd, int bits)
1840 struct dk_softc *dksc = &wd->sc_dksc;
1845 if (wd_get_params(wd, ¶ms) != 0)
1857 xfer = ata_get_xfer(wd->drvp->chnl_softc, true);
1869 wd->atabus->ata_exec_command(wd->drvp, xfer);
1870 ata_wait_cmd(wd->drvp->chnl_softc, xfer);
1873 ata_free_xfer(wd->drvp->chnl_softc, xfer);
1878 wd_standby(struct wd_softc *wd, int flags)
1880 struct dk_softc *dksc = &wd->sc_dksc;
1885 xfer = ata_get_xfer(wd->drvp->chnl_softc, true);
1893 wd->atabus->ata_exec_command(wd->drvp, xfer);
1894 ata_wait_cmd(wd->drvp->chnl_softc, xfer);
1897 ata_free_xfer(wd->drvp->chnl_softc, xfer);
1902 wd_flushcache(struct wd_softc *wd, int flags)
1904 struct dk_softc *dksc = &wd->sc_dksc;
1912 if (wd->drvp->ata_vers < 4 &&
1913 ((wd->sc_params.atap_cmd_set2 & WDC_CMD2_FC) == 0 ||
1914 wd->sc_params.atap_cmd_set2 == 0xffff))
1917 xfer = ata_get_xfer(wd->drvp->chnl_softc, true);
1919 if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0 &&
1920 (wd->sc_params.atap_cmd2_en & ATA_CMD2_FCE) != 0) {
1930 wd->atabus->ata_exec_command(wd->drvp, xfer);
1931 ata_wait_cmd(wd->drvp->chnl_softc, xfer);
1934 wd->sc_flags &= ~WDF_DIRTY;
1935 ata_free_xfer(wd->drvp->chnl_softc, xfer);
1943 wd_trim(struct wd_softc *wd, daddr_t bno, long size)
1945 struct dk_softc *dksc = &wd->sc_dksc;
1950 xfer = ata_get_xfer(wd->drvp->chnl_softc, true);
1980 wd->atabus->ata_exec_command(wd->drvp, xfer);
1981 ata_wait_cmd(wd->drvp->chnl_softc, xfer);
1985 ata_free_xfer(wd->drvp->chnl_softc, xfer);
1992 struct wd_softc *wd = device_private(dev);
1995 if (wd->atabus->ata_addref(wd->drvp))
1998 wd_flushcache(wd, AT_POLL);
2000 wd_standby(wd, AT_POLL);
2009 wi_get(struct wd_softc *wd)
2014 wi->wi_softc = wd;
2077 * - In either case, wdioctlstrategy() calls wd->atabus->ata_exec_command()
2109 printf("physio split wd ioctl request... cannot proceed\n");
2196 wd_sysctl_attach(struct wd_softc *wd)
2198 struct dk_softc *dksc = &wd->sc_dksc;
2203 if (sysctl_createv(&wd->nodelog, 0, NULL, &node,
2205 SYSCTL_DESCR("wd driver settings"),
2214 wd->drv_ncq = true;
2215 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL,
2218 NULL, 0, &wd->drv_ncq, 0,
2227 wd->drv_ncq_prio = false;
2228 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL,
2231 NULL, 0, &wd->drv_ncq_prio, 0,
2241 wd->drv_chaos_freq = 0;
2242 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL,
2245 NULL, 0, &wd->drv_chaos_freq, 0,
2254 wd->drv_chaos_cnt = 0;
2255 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL,
2258 NULL, 0, &wd->drv_chaos_cnt, 0,
2271 wd_sysctl_detach(struct wd_softc *wd)
2273 sysctl_teardown(&wd->nodelog);
2282 struct wd_softc *wd;
2287 wd = device_lookup_private(&wd_cd, unit);
2288 if (wd == NULL)
2290 dksc = &wd->sc_dksc;
2292 dksc->sc_xname, wd->sc_flags, bufq_peek(dksc->sc_bufq));
2294 atachannel_debug(wd->drvp->chnl_softc);
Indexes created Thu Oct 02 10:09:58 GMT 2025