Lines Matching defs:wd
1 /* $NetBSD: wd.c,v 1.470 2024/09/22 17:31:43 uwe Exp $ */
57 __KERNEL_RCSID(0, "$NetBSD: wd.c,v 1.470 2024/09/22 17:31:43 uwe 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;
320 mutex_init(&wd->sc_lock, MUTEX_DEFAULT, IPL_BIO);
322 SLIST_INIT(&wd->sc_bslist);
323 cv_init(&wd->sc_bslist_cv, "wdbadsect");
325 wd->atabus = adev->adev_bustype;
326 wd->inflight = 0;
327 wd->drvp = adev->adev_drv_data;
329 wd->drvp->drv_openings = 1;
330 wd->drvp->drv_done = wddone;
331 wd->drvp->drv_softc = dksc->sc_dev; /* done in atabusconfig_thread()
334 SLIST_INIT(&wd->sc_retry_list);
335 SLIST_INIT(&wd->sc_requeue_list);
336 callout_init(&wd->sc_retry_callout, 0); /* XXX MPSAFE */
337 callout_init(&wd->sc_requeue_callout, 0); /* XXX MPSAFE */
338 callout_init(&wd->sc_restart_diskqueue, 0); /* XXX MPSAFE */
344 if (wd_get_params(wd, &wd->sc_params) != 0) {
349 for (blank = 0, p = wd->sc_params.atap_model, q = tbuf, i = 0;
350 i < sizeof(wd->sc_params.atap_model); i++) {
365 wd->sc_typename = kmem_asprintf("%s", tbuf);
366 aprint_normal_dev(self, "<%s>\n", wd->sc_typename);
370 wd->sc_quirks = wdq->wdq_quirks;
372 if (wd->sc_quirks != 0) {
374 snprintb(sbuf, sizeof(sbuf), WD_QUIRK_FMT, wd->sc_quirks);
377 if (wd->sc_quirks & WD_QUIRK_SPLIT_MOD15_WRITE) {
382 if ((wd->sc_params.atap_multi & 0xff) > 1) {
383 wd->drvp->multi = wd->sc_params.atap_multi & 0xff;
385 wd->drvp->multi = 1;
389 wd->drvp->multi);
392 if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0)
393 wd->sc_flags |= WDF_LBA48;
396 if ((wd->sc_params.atap_capabilities1 & WDC_CAP_LBA) != 0)
397 wd->sc_flags |= WDF_LBA;
400 if (wd->sc_params.atap_ataversion != 0xffff &&
401 wd->sc_params.atap_ataversion >= WDC_VER_ATA4)
402 wd->sc_flags |= WDF_LBA;
405 if ((wd->sc_flags & WDF_LBA48) != 0) {
407 wd->sc_capacity =
408 ((uint64_t) wd->sc_params.atap_max_lba[3] << 48) |
409 ((uint64_t) wd->sc_params.atap_max_lba[2] << 32) |
410 ((uint64_t) wd->sc_params.atap_max_lba[1] << 16) |
411 ((uint64_t) wd->sc_params.atap_max_lba[0] << 0);
412 wd->sc_capacity28 =
413 (wd->sc_params.atap_capacity[1] << 16) |
414 wd->sc_params.atap_capacity[0];
418 if (wd->sc_capacity28 > 0xfffffff)
419 wd->sc_capacity28 = 0xfffffff;
420 } else if ((wd->sc_flags & WDF_LBA) != 0) {
422 wd->sc_capacity28 =
423 (wd->sc_params.atap_capacity[1] << 16) |
424 wd->sc_params.atap_capacity[0];
428 if (wd->sc_capacity28 > 0xfffffff)
429 wd->sc_capacity28 = 0xfffffff;
430 wd->sc_capacity = wd->sc_capacity28;
433 wd->sc_capacity =
434 wd->sc_params.atap_cylinders *
435 wd->sc_params.atap_heads *
436 wd->sc_params.atap_sectors;
442 if (wd->sc_capacity < 0xfffffff)
443 wd->sc_capacity28 = wd->sc_capacity;
445 wd->sc_capacity28 = 0xfffffff;
447 if ((wd->sc_params.atap_secsz & ATA_SECSZ_VALID_MASK) == ATA_SECSZ_VALID
448 && ((wd->sc_params.atap_secsz & ATA_SECSZ_LLS) != 0)) {
449 wd->sc_blksize = 2ULL *
450 ((uint32_t)((wd->sc_params.atap_lls_secsz[1] << 16) |
451 wd->sc_params.atap_lls_secsz[0]));
453 wd->sc_blksize = 512;
455 wd->sc_sectoralign.dsa_firstaligned = 0;
456 wd->sc_sectoralign.dsa_alignment = 1;
457 if ((wd->sc_params.atap_secsz & ATA_SECSZ_VALID_MASK) == ATA_SECSZ_VALID
458 && ((wd->sc_params.atap_secsz & ATA_SECSZ_LPS) != 0)) {
459 wd->sc_sectoralign.dsa_alignment = 1 <<
460 (wd->sc_params.atap_secsz & ATA_SECSZ_LPS_SZMSK);
461 if ((wd->sc_params.atap_logical_align & ATA_LA_VALID_MASK) ==
463 wd->sc_sectoralign.dsa_firstaligned =
464 (wd->sc_sectoralign.dsa_alignment -
465 (wd->sc_params.atap_logical_align &
469 wd->sc_capacity512 = (wd->sc_capacity * wd->sc_blksize) / DEV_BSIZE;
470 format_bytes(pbuf, sizeof(pbuf), wd->sc_capacity * wd->sc_blksize);
474 (wd->sc_flags & WDF_LBA) ? (int)(wd->sc_capacity /
475 (wd->sc_params.atap_heads * wd->sc_params.atap_sectors)) :
476 wd->sc_params.atap_cylinders,
477 wd->sc_params.atap_heads, wd->sc_params.atap_sectors,
478 wd->sc_blksize, (unsigned long long)wd->sc_capacity);
479 if (wd->sc_sectoralign.dsa_alignment != 1) {
481 wd->sc_sectoralign.dsa_alignment * wd->sc_blksize);
482 if (wd->sc_sectoralign.dsa_firstaligned != 0) {
484 (intmax_t)wd->sc_sectoralign.dsa_firstaligned);
491 device_xname(self), wd->sc_params.atap_dmatiming_mimi,
492 wd->sc_params.atap_dmatiming_recom), DEBUG_PROBE);
494 if (wd->sc_blksize <= 0 || !powerof2(wd->sc_blksize) ||
495 wd->sc_blksize < DEV_BSIZE || wd->sc_blksize > MAXPHYS) {
497 "might not actually work\n", wd->sc_blksize);
500 if (strcmp(wd->sc_params.atap_model, "ST506") == 0)
515 wd_set_geometry(wd);
520 wd->drvp->lp = dksc->sc_dkdev.dk_label;
528 wd_sysctl_attach(wd);
550 struct wd_softc *wd = device_private(self);
551 struct dk_softc *dksc = &wd->sc_dksc;
571 mutex_enter(&wd->sc_lock);
572 wd->atabus->ata_killpending(wd->drvp);
574 callout_halt(&wd->sc_retry_callout, &wd->sc_lock);
575 callout_destroy(&wd->sc_retry_callout);
576 callout_halt(&wd->sc_requeue_callout, &wd->sc_lock);
577 callout_destroy(&wd->sc_requeue_callout);
578 callout_halt(&wd->sc_restart_diskqueue, &wd->sc_lock);
579 callout_destroy(&wd->sc_restart_diskqueue);
581 mutex_exit(&wd->sc_lock);
589 wd_standby(wd, AT_POLL);
599 while (!SLIST_EMPTY(&wd->sc_bslist)) {
600 struct disk_badsectors *dbs = SLIST_FIRST(&wd->sc_bslist);
601 SLIST_REMOVE_HEAD(&wd->sc_bslist, dbs_next);
604 wd->sc_bscount = 0;
606 if (wd->sc_typename != NULL) {
607 kmem_free(wd->sc_typename, strlen(wd->sc_typename) + 1);
608 wd->sc_typename = NULL;
613 wd_sysctl_detach(wd);
616 KASSERT(SLIST_EMPTY(&wd->sc_bslist));
617 cv_destroy(&wd->sc_bslist_cv);
620 mutex_destroy(&wd->sc_lock);
622 wd->drvp->drive_type = ATA_DRIVET_NONE; /* no drive any more here */
623 wd->drvp->drive_flags = 0;
635 struct wd_softc *wd =
637 struct dk_softc *dksc = &wd->sc_dksc;
645 if ((wd->sc_flags & WDF_LOADED) == 0 ||
657 if (__predict_false(!SLIST_EMPTY(&wd->sc_bslist))) {
669 maxblk = blkno + (bp->b_bcount / wd->sc_blksize) - 1;
671 mutex_enter(&wd->sc_lock);
672 SLIST_FOREACH(dbs, &wd->sc_bslist, dbs_next)
676 mutex_exit(&wd->sc_lock);
679 mutex_exit(&wd->sc_lock);
693 wdstart1(struct wd_softc *wd, struct buf *bp, struct ata_xfer *xfer)
695 struct dk_softc *dksc = &wd->sc_dksc;
700 KASSERT(mutex_owned(&wd->sc_lock));
729 if (BUF_ISREAD(bp) && xfer->c_retries == 0 && wd->drv_chaos_freq > 0 &&
730 (++wd->drv_chaos_cnt % wd->drv_chaos_freq) == 0) {
733 xfer->c_bio.blkno = 7777777 + wd->sc_capacity;
755 if (wd->sc_flags & WDF_LBA48 &&
757 wd->sc_capacity28) ||
770 if (WD_USE_NCQ(wd) && (xfer->c_retries < WDIORETRIES_SINGLE ||
775 if (WD_USE_NCQ_PRIO(wd) &&
780 if (wd->sc_flags & WDF_LBA)
786 wd->sc_flags |= WDF_DIRTY;
790 KASSERT((wd->sc_flags & WDF_LBA48) != 0);
798 wd->inflight++;
799 mutex_exit(&wd->sc_lock);
802 wd->atabus->ata_bio(wd->drvp, xfer);
804 mutex_enter(&wd->sc_lock);
810 struct wd_softc *wd = device_private(dev);
812 struct dk_softc *dksc = &wd->sc_dksc;
819 mutex_enter(&wd->sc_lock);
821 chp = wd->drvp->chnl_softc;
827 openings = uimin(openings, wd->drvp->drv_openings);
829 if (wd->inflight >= openings) {
859 if (!callout_pending(&wd->sc_restart_diskqueue)) {
860 callout_reset(&wd->sc_restart_diskqueue, ticks,
864 mutex_exit(&wd->sc_lock);
868 wdstart1(wd, bp, xfer);
870 mutex_exit(&wd->sc_lock);
882 struct wd_softc *wd = device_private(self);
883 struct dk_softc *dksc = &wd->sc_dksc;
897 struct wd_softc *wd = device_private(self);
898 struct dk_softc *dksc = &wd->sc_dksc;
908 ata_free_xfer(wd->drvp->chnl_softc, xfer);
942 ata_channel_lock(wd->drvp->chnl_softc);
943 ata_thread_run(wd->drvp->chnl_softc, wflags,
944 ATACH_TH_DRIVE_RESET, wd->drvp->drive);
945 ata_channel_unlock(wd->drvp->chnl_softc);
948 mutex_enter(&wd->sc_lock);
950 diskerr(bp, "wd", errmsg, LOG_PRINTF,
958 wdperror(wd, xfer);
965 SLIST_INSERT_HEAD(&wd->sc_requeue_list, xfer,
967 callout_reset(&wd->sc_requeue_callout,
968 1, wdbiorequeue, wd);
970 SLIST_INSERT_HEAD(&wd->sc_retry_list, xfer,
972 callout_reset(&wd->sc_retry_callout,
973 RECOVERYTIME, wdbioretry, wd);
976 mutex_exit(&wd->sc_lock);
980 mutex_exit(&wd->sc_lock);
990 ((wd->drvp->ata_vers >= 4 && xfer->c_bio.r_error & 64) ||
991 (wd->drvp->ata_vers < 4 && xfer->c_bio.r_error & 192))) {
1003 (bp->b_bcount /wd->sc_blksize) - 1;
1006 mutex_enter(&wd->sc_lock);
1007 SLIST_INSERT_HEAD(&wd->sc_bslist, dbs, dbs_next);
1008 wd->sc_bscount++;
1009 mutex_exit(&wd->sc_lock);
1047 ata_free_xfer(wd->drvp->chnl_softc, xfer);
1049 mutex_enter(&wd->sc_lock);
1050 wd->inflight--;
1051 mutex_exit(&wd->sc_lock);
1059 struct wd_softc *wd = v;
1062 ATADEBUG_PRINT(("%s %s\n", __func__, wd->sc_dksc.sc_xname),
1065 mutex_enter(&wd->sc_lock);
1066 while ((xfer = SLIST_FIRST(&wd->sc_retry_list))) {
1067 SLIST_REMOVE_HEAD(&wd->sc_retry_list, c_retrychain);
1068 wdstart1(wd, xfer->c_bio.bp, xfer);
1070 mutex_exit(&wd->sc_lock);
1076 struct wd_softc *wd = v;
1079 ATADEBUG_PRINT(("%s %s\n", __func__, wd->sc_dksc.sc_xname),
1082 mutex_enter(&wd->sc_lock);
1083 while ((xfer = SLIST_FIRST(&wd->sc_requeue_list))) {
1084 SLIST_REMOVE_HEAD(&wd->sc_requeue_list, c_retrychain);
1085 wdstart1(wd, xfer->c_bio.bp, xfer);
1087 mutex_exit(&wd->sc_lock);
1093 const struct wd_softc * const wd =
1102 if (wd->sc_flags & WDF_LBA48)
1107 if (bp->b_bcount > (wd->sc_blksize * maxsectors))
1108 bp->b_bcount = (wd->sc_blksize * maxsectors);
1147 struct wd_softc *wd;
1153 wd = device_lookup_private(&wd_cd, unit);
1154 if (wd == NULL)
1156 dksc = &wd->sc_dksc;
1163 if (wd->sc_capacity == 0)
1170 if ((wd->sc_flags & (WDF_OPEN | WDF_LOADED)) == WDF_OPEN) {
1186 struct wd_softc *wd = device_private(self);
1187 struct dk_softc *dksc = &wd->sc_dksc;
1190 error = wd->atabus->ata_addref(wd->drvp);
1194 if ((wd->sc_flags & WDF_LOADED) == 0) {
1198 param_error = wd_get_params(wd, &wd->sc_params);
1204 wd_set_geometry(wd);
1205 wd->sc_flags |= WDF_LOADED;
1208 wd->sc_flags |= WDF_OPEN;
1212 wd->atabus->ata_delref(wd->drvp);
1217 * Caller must hold wd->sc_dk.dk_openlock.
1222 struct wd_softc *wd = device_private(self);
1224 KASSERTMSG(bufq_peek(wd->sc_dksc.sc_bufq) == NULL, "bufq not empty");
1226 if (wd->sc_flags & WDF_DIRTY)
1227 wd_flushcache(wd, AT_WAIT);
1229 wd->atabus->ata_delref(wd->drvp);
1230 wd->sc_flags &= ~WDF_OPEN;
1238 struct wd_softc *wd;
1243 wd = device_lookup_private(&wd_cd, unit);
1244 dksc = &wd->sc_dksc;
1250 wdperror(const struct wd_softc *wd, struct ata_xfer *xfer)
1265 const struct dk_softc *dksc = &wd->sc_dksc;
1267 struct ata_drive_datas *drvp = wd->drvp;
1292 struct wd_softc *wd =
1294 struct dk_softc *dksc = &wd->sc_dksc;
1298 if ((wd->sc_flags & WDF_LOADED) == 0)
1308 bad144intern(wd);
1321 missing = wd->sc_bscount;
1337 mutex_enter(&wd->sc_lock);
1338 wd->sc_bslist_inuse++;
1339 SLIST_FOREACH(dbs, &wd->sc_bslist, dbs_next) {
1352 mutex_exit(&wd->sc_lock);
1354 mutex_enter(&wd->sc_lock);
1361 if (--wd->sc_bslist_inuse == 0)
1362 cv_broadcast(&wd->sc_bslist_cv);
1363 mutex_exit(&wd->sc_lock);
1379 mutex_enter(&wd->sc_lock);
1380 while (wd->sc_bslist_inuse) {
1381 error = cv_wait_sig(&wd->sc_bslist_cv, &wd->sc_lock);
1383 mutex_exit(&wd->sc_lock);
1387 while (!SLIST_EMPTY(&wd->sc_bslist)) {
1389 SLIST_FIRST(&wd->sc_bslist);
1390 SLIST_REMOVE_HEAD(&wd->sc_bslist, dbs_next);
1391 mutex_exit(&wd->sc_lock);
1393 mutex_enter(&wd->sc_lock);
1395 mutex_exit(&wd->sc_lock);
1396 wd->sc_bscount = 0;
1418 fop->df_startblk * wd->sc_dk.dk_label->d_secsize;
1429 return wd_getcache(wd, (int *)addr);
1432 return wd_setcache(wd, *(int *)addr);
1435 return wd_flushcache(wd, AT_WAIT);
1449 wi = wi_get(wd);
1501 *dsa = wd->sc_sectoralign;
1530 struct wd_softc *wd = device_private(dev);
1536 if (!(wd->sc_params.atap_ata_major & WDC_VER_ATA7)
1537 || !(wd->sc_params.support_dsm & ATA_SUPPORT_DSM_TRIM)) {
1542 maxatonce = 0xffff; /*wd->sc_params.max_dsm_blocks*/
1546 if ((wd->sc_flags & WDF_LOADED) == 0)
1550 bno = (pos + wd->sc_blksize - 1) / wd->sc_blksize;
1551 size = ((pos + len) / wd->sc_blksize) - bno;
1559 result = wd_trim(wd, bno + done, amount);
1571 struct wd_softc *wd;
1576 wd = device_lookup_private(&wd_cd, unit);
1577 dksc = &wd->sc_dksc;
1595 struct wd_softc *wd;
1602 wd = device_lookup_private(&wd_cd, unit);
1603 if (wd == NULL)
1605 dksc = &wd->sc_dksc;
1619 struct wd_softc *wd;
1629 wd = device_lookup_private(&wd_cd, unit);
1630 if (wd == NULL)
1632 dksc = &wd->sc_dksc;
1640 struct wd_softc *wd = device_private(dev);
1641 struct dk_softc *dksc = &wd->sc_dksc;
1643 struct ata_xfer *xfer = &wd->dump_xfer;
1649 ata_channel_lock(wd->drvp->chnl_softc);
1651 ata_thread_run(wd->drvp->chnl_softc, AT_POLL,
1652 ATACH_TH_DRIVE_RESET, wd->drvp->drive);
1654 wd->drvp->state = RESET;
1655 ata_channel_unlock(wd->drvp->chnl_softc);
1663 if (wd->sc_flags & WDF_LBA48 &&
1664 (xfer->c_bio.blkno + nblk) > wd->sc_capacity28)
1666 if (wd->sc_flags & WDF_LBA)
1672 wd->atabus->ata_bio(wd->drvp, xfer);
1689 wdperror(wd, xfer);
1705 printf("wd%d: dump addr 0x%x, cylin %d, head %d, sector %d\n",
1719 bad144intern(struct wd_softc *wd)
1721 struct dk_softc *dksc = &wd->sc_dksc;
1731 wd->drvp->badsect[i] =
1737 wd->drvp->badsect[i] = -1;
1742 wd_set_geometry(struct wd_softc *wd)
1744 struct dk_softc *dksc = &wd->sc_dksc;
1749 dg->dg_secperunit = wd->sc_capacity;
1750 dg->dg_secsize = wd->sc_blksize;
1751 dg->dg_nsectors = wd->sc_params.atap_sectors;
1752 dg->dg_ntracks = wd->sc_params.atap_heads;
1753 if ((wd->sc_flags & WDF_LBA) == 0)
1754 dg->dg_ncylinders = wd->sc_params.atap_cylinders;
1756 disk_set_info(dksc->sc_dev, &dksc->sc_dkdev, wd->sc_typename);
1760 wd_get_params(struct wd_softc *wd, struct ataparams *params)
1763 struct ata_channel *chp = wd->drvp->chnl_softc;
1767 switch (wd->atabus->ata_get_params(wd->drvp, flags, params)) {
1774 (*wd->atabus->ata_reset_drive)(wd->drvp, flags, NULL);
1779 if (wd->drvp->drive_type != ATA_DRIVET_OLD)
1794 wd->drvp->ata_vers = -1; /* Mark it as pre-ATA */
1805 wd_getcache(struct wd_softc *wd, int *bitsp)
1809 if (wd_get_params(wd, ¶ms) != 0)
1821 if (WD_USE_NCQ(wd) || (wd->drvp->drive_flags & ATA_DRIVE_WFUA))
1851 wd_setcache(struct wd_softc *wd, int bits)
1853 struct dk_softc *dksc = &wd->sc_dksc;
1858 if (wd_get_params(wd, ¶ms) != 0)
1870 xfer = ata_get_xfer(wd->drvp->chnl_softc, true);
1882 wd->atabus->ata_exec_command(wd->drvp, xfer);
1883 ata_wait_cmd(wd->drvp->chnl_softc, xfer);
1886 ata_free_xfer(wd->drvp->chnl_softc, xfer);
1891 wd_standby(struct wd_softc *wd, int flags)
1893 struct dk_softc *dksc = &wd->sc_dksc;
1898 xfer = ata_get_xfer(wd->drvp->chnl_softc, true);
1906 wd->atabus->ata_exec_command(wd->drvp, xfer);
1907 ata_wait_cmd(wd->drvp->chnl_softc, xfer);
1910 ata_free_xfer(wd->drvp->chnl_softc, xfer);
1915 wd_flushcache(struct wd_softc *wd, int flags)
1917 struct dk_softc *dksc = &wd->sc_dksc;
1925 if (wd->drvp->ata_vers < 4 &&
1926 ((wd->sc_params.atap_cmd_set2 & WDC_CMD2_FC) == 0 ||
1927 wd->sc_params.atap_cmd_set2 == 0xffff))
1930 xfer = ata_get_xfer(wd->drvp->chnl_softc, true);
1932 if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0 &&
1933 (wd->sc_params.atap_cmd2_en & ATA_CMD2_FCE) != 0) {
1943 wd->atabus->ata_exec_command(wd->drvp, xfer);
1944 ata_wait_cmd(wd->drvp->chnl_softc, xfer);
1947 wd->sc_flags &= ~WDF_DIRTY;
1948 ata_free_xfer(wd->drvp->chnl_softc, xfer);
1956 wd_trim(struct wd_softc *wd, daddr_t bno, long size)
1958 struct dk_softc *dksc = &wd->sc_dksc;
1963 xfer = ata_get_xfer(wd->drvp->chnl_softc, true);
1993 wd->atabus->ata_exec_command(wd->drvp, xfer);
1994 ata_wait_cmd(wd->drvp->chnl_softc, xfer);
1998 ata_free_xfer(wd->drvp->chnl_softc, xfer);
2005 struct wd_softc *wd = device_private(dev);
2008 if (wd->atabus->ata_addref(wd->drvp))
2011 wd_flushcache(wd, AT_POLL);
2013 wd_standby(wd, AT_POLL);
2022 wi_get(struct wd_softc *wd)
2027 wi->wi_softc = wd;
2090 * - In either case, wdioctlstrategy() calls wd->atabus->ata_exec_command()
2122 printf("physio split wd ioctl request... cannot proceed\n");
2209 wd_sysctl_attach(struct wd_softc *wd)
2211 struct dk_softc *dksc = &wd->sc_dksc;
2216 if (sysctl_createv(&wd->nodelog, 0, NULL, &node,
2218 SYSCTL_DESCR("wd driver settings"),
2227 wd->drv_ncq = true;
2228 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL,
2231 NULL, 0, &wd->drv_ncq, 0,
2240 wd->drv_ncq_prio = false;
2241 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL,
2244 NULL, 0, &wd->drv_ncq_prio, 0,
2254 wd->drv_chaos_freq = 0;
2255 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL,
2258 NULL, 0, &wd->drv_chaos_freq, 0,
2267 wd->drv_chaos_cnt = 0;
2268 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL,
2271 NULL, 0, &wd->drv_chaos_cnt, 0,
2284 wd_sysctl_detach(struct wd_softc *wd)
2286 sysctl_teardown(&wd->nodelog);
2295 struct wd_softc *wd;
2300 wd = device_lookup_private(&wd_cd, unit);
2301 if (wd == NULL)
2303 dksc = &wd->sc_dksc;
2305 dksc->sc_xname, wd->sc_flags, bufq_peek(dksc->sc_bufq));
2307 atachannel_debug(wd->drvp->chnl_softc);