wd.c revision 1.460.2.1
1 /* $NetBSD: wd.c,v 1.460.2.1 2020/04/20 11:29:03 bouyer Exp $ */ 2 3 /* 4 * Copyright (c) 1998, 2001 Manuel Bouyer. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 /*- 28 * Copyright (c) 1998, 2003, 2004 The NetBSD Foundation, Inc. 29 * All rights reserved. 30 * 31 * This code is derived from software contributed to The NetBSD Foundation 32 * by Charles M. Hannum and by Onno van der Linden. 33 * 34 * Redistribution and use in source and binary forms, with or without 35 * modification, are permitted provided that the following conditions 36 * are met: 37 * 1. Redistributions of source code must retain the above copyright 38 * notice, this list of conditions and the following disclaimer. 39 * 2. Redistributions in binary form must reproduce the above copyright 40 * notice, this list of conditions and the following disclaimer in the 41 * documentation and/or other materials provided with the distribution. 42 * 43 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 44 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 45 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 46 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 47 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 48 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 49 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 50 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 51 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 52 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 53 * POSSIBILITY OF SUCH DAMAGE. 54 */ 55 56 #include <sys/cdefs.h> 57 __KERNEL_RCSID(0, "$NetBSD: wd.c,v 1.460.2.1 2020/04/20 11:29:03 bouyer Exp $"); 58 59 #include "opt_ata.h" 60 #include "opt_wd.h" 61 62 #include <sys/param.h> 63 #include <sys/systm.h> 64 #include <sys/kernel.h> 65 #include <sys/conf.h> 66 #include <sys/file.h> 67 #include <sys/stat.h> 68 #include <sys/ioctl.h> 69 #include <sys/buf.h> 70 #include <sys/bufq.h> 71 #include <sys/uio.h> 72 #include <sys/device.h> 73 #include <sys/disklabel.h> 74 #include <sys/disk.h> 75 #include <sys/syslog.h> 76 #include <sys/proc.h> 77 #include <sys/reboot.h> 78 #include <sys/vnode.h> 79 #include <sys/rndsource.h> 80 81 #include <sys/intr.h> 82 #include <sys/bus.h> 83 84 #include <dev/ata/atareg.h> 85 #include <dev/ata/atavar.h> 86 #include <dev/ata/wdvar.h> 87 #include <dev/ic/wdcreg.h> 88 #include <sys/ataio.h> 89 #include "locators.h" 90 91 #include <prop/proplib.h> 92 93 #define WDIORETRIES_SINGLE 4 /* number of retries for single-sector */ 94 #define WDIORETRIES 5 /* number of retries before giving up */ 95 #define RECOVERYTIME hz/2 /* time to wait before retrying a cmd */ 96 97 #define WDUNIT(dev) DISKUNIT(dev) 98 #define WDPART(dev) DISKPART(dev) 99 #define WDMINOR(unit, part) DISKMINOR(unit, part) 100 #define MAKEWDDEV(maj, unit, part) MAKEDISKDEV(maj, unit, part) 101 102 #define WDLABELDEV(dev) (MAKEWDDEV(major(dev), WDUNIT(dev), RAW_PART)) 103 104 #define DEBUG_FUNCS 0x08 105 #define DEBUG_PROBE 0x10 106 #define DEBUG_DETACH 0x20 107 #define DEBUG_XFERS 0x40 108 #ifdef ATADEBUG 109 #ifndef ATADEBUG_WD_MASK 110 #define ATADEBUG_WD_MASK 0x0 111 #endif 112 int wdcdebug_wd_mask = ATADEBUG_WD_MASK; 113 #define ATADEBUG_PRINT(args, level) \ 114 if (wdcdebug_wd_mask & (level)) \ 115 printf args 116 #else 117 #define ATADEBUG_PRINT(args, level) 118 #endif 119 120 static int wdprobe(device_t, cfdata_t, void *); 121 static void wdattach(device_t, device_t, void *); 122 static int wddetach(device_t, int); 123 static void wdperror(const struct wd_softc *, struct ata_xfer *); 124 125 static void wdminphys(struct buf *); 126 127 static int wd_firstopen(device_t, dev_t, int, int); 128 static int wd_lastclose(device_t); 129 static bool wd_suspend(device_t, const pmf_qual_t *); 130 static int wd_standby(struct wd_softc *, int); 131 132 CFATTACH_DECL3_NEW(wd, sizeof(struct wd_softc), 133 wdprobe, wdattach, wddetach, NULL, NULL, NULL, DVF_DETACH_SHUTDOWN); 134 135 extern struct cfdriver wd_cd; 136 137 static dev_type_open(wdopen); 138 static dev_type_close(wdclose); 139 static dev_type_read(wdread); 140 static dev_type_write(wdwrite); 141 static dev_type_ioctl(wdioctl); 142 static dev_type_strategy(wdstrategy); 143 static dev_type_dump(wddump); 144 static dev_type_size(wdsize); 145 static dev_type_discard(wddiscard); 146 147 const struct bdevsw wd_bdevsw = { 148 .d_open = wdopen, 149 .d_close = wdclose, 150 .d_strategy = wdstrategy, 151 .d_ioctl = wdioctl, 152 .d_dump = wddump, 153 .d_psize = wdsize, 154 .d_discard = wddiscard, 155 .d_flag = D_DISK 156 }; 157 158 const struct cdevsw wd_cdevsw = { 159 .d_open = wdopen, 160 .d_close = wdclose, 161 .d_read = wdread, 162 .d_write = wdwrite, 163 .d_ioctl = wdioctl, 164 .d_stop = nostop, 165 .d_tty = notty, 166 .d_poll = nopoll, 167 .d_mmap = nommap, 168 .d_kqfilter = nokqfilter, 169 .d_discard = wddiscard, 170 .d_flag = D_DISK 171 }; 172 173 /* #define WD_DUMP_NOT_TRUSTED if you just want to watch */ 174 static int wddoingadump = 0; 175 static int wddumprecalibrated = 0; 176 177 /* 178 * Glue necessary to hook WDCIOCCOMMAND into physio 179 */ 180 181 struct wd_ioctl { 182 LIST_ENTRY(wd_ioctl) wi_list; 183 struct buf wi_bp; 184 struct uio wi_uio; 185 struct iovec wi_iov; 186 atareq_t wi_atareq; 187 struct wd_softc *wi_softc; 188 }; 189 190 static struct wd_ioctl *wi_find(struct buf *); 191 static void wi_free(struct wd_ioctl *); 192 static struct wd_ioctl *wi_get(struct wd_softc *); 193 static void wdioctlstrategy(struct buf *); 194 195 static void wdrestart(void *); 196 static void wdstart1(struct wd_softc *, struct buf *, struct ata_xfer *); 197 static int wd_diskstart(device_t, struct buf *); 198 static int wd_dumpblocks(device_t, void *, daddr_t, int); 199 static void wd_iosize(device_t, int *); 200 static int wd_discard(device_t, off_t, off_t); 201 static void wdbioretry(void *); 202 static void wdbiorequeue(void *); 203 static void wddone(device_t, struct ata_xfer *); 204 static int wd_get_params(struct wd_softc *, struct ataparams *); 205 static void wd_set_geometry(struct wd_softc *); 206 static int wd_flushcache(struct wd_softc *, int, bool); 207 static int wd_trim(struct wd_softc *, daddr_t, long); 208 static bool wd_shutdown(device_t, int); 209 210 static int wd_getcache(struct wd_softc *, int *); 211 static int wd_setcache(struct wd_softc *, int); 212 213 static void wd_sysctl_attach(struct wd_softc *); 214 static void wd_sysctl_detach(struct wd_softc *); 215 216 static const struct dkdriver wddkdriver = { 217 .d_open = wdopen, 218 .d_close = wdclose, 219 .d_strategy = wdstrategy, 220 .d_minphys = wdminphys, 221 .d_diskstart = wd_diskstart, 222 .d_dumpblocks = wd_dumpblocks, 223 .d_iosize = wd_iosize, 224 .d_firstopen = wd_firstopen, 225 .d_lastclose = wd_lastclose, 226 .d_discard = wd_discard 227 }; 228 229 #ifdef HAS_BAD144_HANDLING 230 static void bad144intern(struct wd_softc *); 231 #endif 232 233 #define WD_QUIRK_SPLIT_MOD15_WRITE 0x0001 /* must split certain writes */ 234 235 #define WD_QUIRK_FMT "\20\1SPLIT_MOD15_WRITE" 236 237 /* 238 * Quirk table for IDE drives. Put more-specific matches first, since 239 * a simple globing routine is used for matching. 240 */ 241 static const struct wd_quirk { 242 const char *wdq_match; /* inquiry pattern to match */ 243 int wdq_quirks; /* drive quirks */ 244 } wd_quirk_table[] = { 245 /* 246 * Some Seagate S-ATA drives have a PHY which can get confused 247 * with the way data is packetized by some S-ATA controllers. 248 * 249 * The work-around is to split in two any write transfer whose 250 * sector count % 15 == 1 (assuming 512 byte sectors). 251 * 252 * XXX This is an incomplete list. There are at least a couple 253 * XXX more model numbers. If you have trouble with such transfers 254 * XXX (8K is the most common) on Seagate S-ATA drives, please 255 * XXX notify thorpej (at) NetBSD.org. 256 * 257 * The ST360015AS has not yet been confirmed to have this 258 * issue, however, it is the only other drive in the 259 * Seagate Barracuda Serial ATA V family. 260 * 261 */ 262 { "ST3120023AS", WD_QUIRK_SPLIT_MOD15_WRITE }, 263 { "ST380023AS", WD_QUIRK_SPLIT_MOD15_WRITE }, 264 { "ST360015AS", WD_QUIRK_SPLIT_MOD15_WRITE }, 265 { NULL, 266 0 } 267 }; 268 269 static const struct wd_quirk * 270 wd_lookup_quirks(const char *name) 271 { 272 const struct wd_quirk *wdq; 273 const char *estr; 274 275 for (wdq = wd_quirk_table; wdq->wdq_match != NULL; wdq++) { 276 /* 277 * We only want exact matches (which include matches 278 * against globbing characters). 279 */ 280 if (pmatch(name, wdq->wdq_match, &estr) == 2) 281 return (wdq); 282 } 283 return (NULL); 284 } 285 286 static int 287 wdprobe(device_t parent, cfdata_t match, void *aux) 288 { 289 struct ata_device *adev = aux; 290 291 if (adev == NULL) 292 return 0; 293 if (adev->adev_bustype->bustype_type != SCSIPI_BUSTYPE_ATA) 294 return 0; 295 296 if (match->cf_loc[ATA_HLCF_DRIVE] != ATA_HLCF_DRIVE_DEFAULT && 297 match->cf_loc[ATA_HLCF_DRIVE] != adev->adev_drv_data->drive) 298 return 0; 299 return 1; 300 } 301 302 static void 303 wdattach(device_t parent, device_t self, void *aux) 304 { 305 struct wd_softc *wd = device_private(self); 306 struct dk_softc *dksc = &wd->sc_dksc; 307 struct ata_device *adev= aux; 308 int i, blank; 309 char tbuf[41],pbuf[9], c, *p, *q; 310 const struct wd_quirk *wdq; 311 int dtype = DKTYPE_UNKNOWN; 312 313 dksc->sc_dev = self; 314 315 ATADEBUG_PRINT(("wdattach\n"), DEBUG_FUNCS | DEBUG_PROBE); 316 mutex_init(&wd->sc_lock, MUTEX_DEFAULT, IPL_BIO); 317 #ifdef WD_SOFTBADSECT 318 SLIST_INIT(&wd->sc_bslist); 319 #endif 320 wd->atabus = adev->adev_bustype; 321 wd->inflight = 0; 322 wd->drvp = adev->adev_drv_data; 323 324 wd->drvp->drv_openings = 1; 325 wd->drvp->drv_done = wddone; 326 wd->drvp->drv_softc = dksc->sc_dev; /* done in atabusconfig_thread() 327 but too late */ 328 329 SLIST_INIT(&wd->sc_retry_list); 330 SLIST_INIT(&wd->sc_requeue_list); 331 callout_init(&wd->sc_retry_callout, 0); /* XXX MPSAFE */ 332 callout_init(&wd->sc_requeue_callout, 0); /* XXX MPSAFE */ 333 callout_init(&wd->sc_restart_diskqueue, 0); /* XXX MPSAFE */ 334 335 aprint_naive("\n"); 336 aprint_normal("\n"); 337 338 /* read our drive info */ 339 if (wd_get_params(wd, &wd->sc_params) != 0) { 340 aprint_error_dev(self, "IDENTIFY failed\n"); 341 goto out; 342 } 343 344 for (blank = 0, p = wd->sc_params.atap_model, q = tbuf, i = 0; 345 i < sizeof(wd->sc_params.atap_model); i++) { 346 c = *p++; 347 if (c == '\0') 348 break; 349 if (c != ' ') { 350 if (blank) { 351 *q++ = ' '; 352 blank = 0; 353 } 354 *q++ = c; 355 } else 356 blank = 1; 357 } 358 *q++ = '\0'; 359 360 wd->sc_typename = kmem_asprintf("%s", tbuf); 361 aprint_normal_dev(self, "<%s>\n", wd->sc_typename); 362 363 wdq = wd_lookup_quirks(tbuf); 364 if (wdq != NULL) 365 wd->sc_quirks = wdq->wdq_quirks; 366 367 if (wd->sc_quirks != 0) { 368 char sbuf[sizeof(WD_QUIRK_FMT) + 64]; 369 snprintb(sbuf, sizeof(sbuf), WD_QUIRK_FMT, wd->sc_quirks); 370 aprint_normal_dev(self, "quirks %s\n", sbuf); 371 372 if (wd->sc_quirks & WD_QUIRK_SPLIT_MOD15_WRITE) { 373 aprint_error_dev(self, "drive corrupts write transfers with certain controllers, consider replacing\n"); 374 } 375 } 376 377 if ((wd->sc_params.atap_multi & 0xff) > 1) { 378 wd->drvp->multi = wd->sc_params.atap_multi & 0xff; 379 } else { 380 wd->drvp->multi = 1; 381 } 382 383 aprint_verbose_dev(self, "drive supports %d-sector PIO transfers,", 384 wd->drvp->multi); 385 386 /* 48-bit LBA addressing */ 387 if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0) 388 wd->sc_flags |= WDF_LBA48; 389 390 /* Prior to ATA-4, LBA was optional. */ 391 if ((wd->sc_params.atap_capabilities1 & WDC_CAP_LBA) != 0) 392 wd->sc_flags |= WDF_LBA; 393 #if 0 394 /* ATA-4 requires LBA. */ 395 if (wd->sc_params.atap_ataversion != 0xffff && 396 wd->sc_params.atap_ataversion >= WDC_VER_ATA4) 397 wd->sc_flags |= WDF_LBA; 398 #endif 399 400 if ((wd->sc_flags & WDF_LBA48) != 0) { 401 aprint_verbose(" LBA48 addressing\n"); 402 wd->sc_capacity = 403 ((uint64_t) wd->sc_params.atap_max_lba[3] << 48) | 404 ((uint64_t) wd->sc_params.atap_max_lba[2] << 32) | 405 ((uint64_t) wd->sc_params.atap_max_lba[1] << 16) | 406 ((uint64_t) wd->sc_params.atap_max_lba[0] << 0); 407 wd->sc_capacity28 = 408 (wd->sc_params.atap_capacity[1] << 16) | 409 wd->sc_params.atap_capacity[0]; 410 } else if ((wd->sc_flags & WDF_LBA) != 0) { 411 aprint_verbose(" LBA addressing\n"); 412 wd->sc_capacity28 = wd->sc_capacity = 413 (wd->sc_params.atap_capacity[1] << 16) | 414 wd->sc_params.atap_capacity[0]; 415 } else { 416 aprint_verbose(" chs addressing\n"); 417 wd->sc_capacity28 = wd->sc_capacity = 418 wd->sc_params.atap_cylinders * 419 wd->sc_params.atap_heads * 420 wd->sc_params.atap_sectors; 421 } 422 if ((wd->sc_params.atap_secsz & ATA_SECSZ_VALID_MASK) == ATA_SECSZ_VALID 423 && ((wd->sc_params.atap_secsz & ATA_SECSZ_LLS) != 0)) { 424 wd->sc_blksize = 2ULL * 425 ((uint32_t)((wd->sc_params.atap_lls_secsz[1] << 16) | 426 wd->sc_params.atap_lls_secsz[0])); 427 } else { 428 wd->sc_blksize = 512; 429 } 430 wd->sc_sectoralign.dsa_firstaligned = 0; 431 wd->sc_sectoralign.dsa_alignment = 1; 432 if ((wd->sc_params.atap_secsz & ATA_SECSZ_VALID_MASK) == ATA_SECSZ_VALID 433 && ((wd->sc_params.atap_secsz & ATA_SECSZ_LPS) != 0)) { 434 wd->sc_sectoralign.dsa_alignment = 1 << 435 (wd->sc_params.atap_secsz & ATA_SECSZ_LPS_SZMSK); 436 if ((wd->sc_params.atap_logical_align & ATA_LA_VALID_MASK) == 437 ATA_LA_VALID) { 438 wd->sc_sectoralign.dsa_firstaligned = 439 (wd->sc_sectoralign.dsa_alignment - 440 (wd->sc_params.atap_logical_align & 441 ATA_LA_MASK)); 442 } 443 } 444 wd->sc_capacity512 = (wd->sc_capacity * wd->sc_blksize) / DEV_BSIZE; 445 format_bytes(pbuf, sizeof(pbuf), wd->sc_capacity * wd->sc_blksize); 446 aprint_normal_dev(self, "%s, %d cyl, %d head, %d sec, " 447 "%d bytes/sect x %llu sectors", 448 pbuf, 449 (wd->sc_flags & WDF_LBA) ? (int)(wd->sc_capacity / 450 (wd->sc_params.atap_heads * wd->sc_params.atap_sectors)) : 451 wd->sc_params.atap_cylinders, 452 wd->sc_params.atap_heads, wd->sc_params.atap_sectors, 453 wd->sc_blksize, (unsigned long long)wd->sc_capacity); 454 if (wd->sc_sectoralign.dsa_alignment != 1) { 455 aprint_normal(" (%d bytes/physsect", 456 wd->sc_sectoralign.dsa_alignment & wd->sc_blksize); 457 if (wd->sc_sectoralign.dsa_firstaligned != 0) { 458 aprint_normal("; first aligned sector: %jd", 459 (intmax_t)wd->sc_sectoralign.dsa_firstaligned); 460 } 461 aprint_normal(")"); 462 } 463 aprint_normal("\n"); 464 465 ATADEBUG_PRINT(("%s: atap_dmatiming_mimi=%d, atap_dmatiming_recom=%d\n", 466 device_xname(self), wd->sc_params.atap_dmatiming_mimi, 467 wd->sc_params.atap_dmatiming_recom), DEBUG_PROBE); 468 469 if (wd->sc_blksize <= 0 || !powerof2(wd->sc_blksize) || 470 wd->sc_blksize < DEV_BSIZE || wd->sc_blksize > MAXPHYS) { 471 aprint_normal_dev(self, "WARNING: block size %u " 472 "might not actually work\n", wd->sc_blksize); 473 } 474 475 if (strcmp(wd->sc_params.atap_model, "ST506") == 0) 476 dtype = DKTYPE_ST506; 477 else 478 dtype = DKTYPE_ESDI; 479 480 out: 481 /* 482 * Initialize and attach the disk structure. 483 */ 484 dk_init(dksc, self, dtype); 485 disk_init(&dksc->sc_dkdev, dksc->sc_xname, &wddkdriver); 486 487 /* Attach dk and disk subsystems */ 488 dk_attach(dksc); 489 disk_attach(&dksc->sc_dkdev); 490 wd_set_geometry(wd); 491 492 bufq_alloc(&dksc->sc_bufq, BUFQ_DISK_DEFAULT_STRAT, BUFQ_SORT_RAWBLOCK); 493 494 /* reference to label structure, used by ata code */ 495 wd->drvp->lp = dksc->sc_dkdev.dk_label; 496 497 /* Discover wedges on this disk. */ 498 dkwedge_discover(&dksc->sc_dkdev); 499 500 if (!pmf_device_register1(self, wd_suspend, NULL, wd_shutdown)) 501 aprint_error_dev(self, "couldn't establish power handler\n"); 502 503 wd_sysctl_attach(wd); 504 } 505 506 static bool 507 wd_suspend(device_t dv, const pmf_qual_t *qual) 508 { 509 struct wd_softc *sc = device_private(dv); 510 511 /* the adapter needs to be enabled */ 512 if (sc->atabus->ata_addref(sc->drvp)) 513 return true; /* no need to complain */ 514 515 wd_flushcache(sc, AT_WAIT, false); 516 wd_standby(sc, AT_WAIT); 517 518 sc->atabus->ata_delref(sc->drvp); 519 return true; 520 } 521 522 static int 523 wddetach(device_t self, int flags) 524 { 525 struct wd_softc *wd = device_private(self); 526 struct dk_softc *dksc = &wd->sc_dksc; 527 int bmaj, cmaj, i, mn, rc; 528 529 if ((rc = disk_begindetach(&dksc->sc_dkdev, wd_lastclose, self, flags)) != 0) 530 return rc; 531 532 /* locate the major number */ 533 bmaj = bdevsw_lookup_major(&wd_bdevsw); 534 cmaj = cdevsw_lookup_major(&wd_cdevsw); 535 536 /* Nuke the vnodes for any open instances. */ 537 for (i = 0; i < MAXPARTITIONS; i++) { 538 mn = WDMINOR(device_unit(self), i); 539 vdevgone(bmaj, mn, mn, VBLK); 540 vdevgone(cmaj, mn, mn, VCHR); 541 } 542 543 dk_drain(dksc); 544 545 /* Kill off any pending commands. */ 546 mutex_enter(&wd->sc_lock); 547 wd->atabus->ata_killpending(wd->drvp); 548 549 callout_halt(&wd->sc_retry_callout, &wd->sc_lock); 550 callout_destroy(&wd->sc_retry_callout); 551 callout_halt(&wd->sc_requeue_callout, &wd->sc_lock); 552 callout_destroy(&wd->sc_requeue_callout); 553 callout_halt(&wd->sc_restart_diskqueue, &wd->sc_lock); 554 callout_destroy(&wd->sc_restart_diskqueue); 555 556 mutex_exit(&wd->sc_lock); 557 558 bufq_free(dksc->sc_bufq); 559 560 /* Delete all of our wedges. */ 561 dkwedge_delall(&dksc->sc_dkdev); 562 563 if (flags & DETACH_POWEROFF) 564 wd_standby(wd, AT_POLL); 565 566 /* Detach from the disk list. */ 567 disk_detach(&dksc->sc_dkdev); 568 disk_destroy(&dksc->sc_dkdev); 569 570 dk_detach(dksc); 571 572 #ifdef WD_SOFTBADSECT 573 /* Clean out the bad sector list */ 574 while (!SLIST_EMPTY(&wd->sc_bslist)) { 575 struct disk_badsectors *dbs = SLIST_FIRST(&wd->sc_bslist); 576 SLIST_REMOVE_HEAD(&wd->sc_bslist, dbs_next); 577 kmem_free(dbs, sizeof(*dbs)); 578 } 579 wd->sc_bscount = 0; 580 #endif 581 if (wd->sc_typename != NULL) { 582 kmem_free(wd->sc_typename, strlen(wd->sc_typename) + 1); 583 wd->sc_typename = NULL; 584 } 585 586 pmf_device_deregister(self); 587 588 wd_sysctl_detach(wd); 589 590 mutex_destroy(&wd->sc_lock); 591 592 wd->drvp->drive_type = ATA_DRIVET_NONE; /* no drive any more here */ 593 wd->drvp->drive_flags = 0; 594 595 return (0); 596 } 597 598 /* 599 * Read/write routine for a buffer. Validates the arguments and schedules the 600 * transfer. Does not wait for the transfer to complete. 601 */ 602 static void 603 wdstrategy(struct buf *bp) 604 { 605 struct wd_softc *wd = 606 device_lookup_private(&wd_cd, WDUNIT(bp->b_dev)); 607 struct dk_softc *dksc = &wd->sc_dksc; 608 609 ATADEBUG_PRINT(("wdstrategy (%s)\n", dksc->sc_xname), 610 DEBUG_XFERS); 611 612 /* If device invalidated (e.g. media change, door open, 613 * device detachment), then error. 614 */ 615 if ((wd->sc_flags & WDF_LOADED) == 0 || 616 !device_is_enabled(dksc->sc_dev)) 617 goto err; 618 619 #ifdef WD_SOFTBADSECT 620 /* 621 * If the transfer about to be attempted contains only a block that 622 * is known to be bad then return an error for the transfer without 623 * even attempting to start a transfer up under the premis that we 624 * will just end up doing more retries for a transfer that will end 625 * up failing again. 626 */ 627 if (__predict_false(!SLIST_EMPTY(&wd->sc_bslist))) { 628 struct disklabel *lp = dksc->sc_dkdev.dk_label; 629 struct disk_badsectors *dbs; 630 daddr_t blkno, maxblk; 631 632 /* convert the block number to absolute */ 633 if (lp->d_secsize >= DEV_BSIZE) 634 blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE); 635 else 636 blkno = bp->b_blkno * (DEV_BSIZE / lp->d_secsize); 637 if (WDPART(bp->b_dev) != RAW_PART) 638 blkno += lp->d_partitions[WDPART(bp->b_dev)].p_offset; 639 maxblk = blkno + (bp->b_bcount / wd->sc_blksize) - 1; 640 641 mutex_enter(&wd->sc_lock); 642 SLIST_FOREACH(dbs, &wd->sc_bslist, dbs_next) 643 if ((dbs->dbs_min <= bp->b_rawblkno && 644 bp->b_rawblkno <= dbs->dbs_max) || 645 (dbs->dbs_min <= maxblk && maxblk <= dbs->dbs_max)){ 646 mutex_exit(&wd->sc_lock); 647 goto err; 648 } 649 mutex_exit(&wd->sc_lock); 650 } 651 #endif 652 653 dk_strategy(dksc, bp); 654 return; 655 656 err: 657 bp->b_error = EIO; 658 bp->b_resid = bp->b_bcount; 659 biodone(bp); 660 } 661 662 static void 663 wdstart1(struct wd_softc *wd, struct buf *bp, struct ata_xfer *xfer) 664 { 665 struct dk_softc *dksc = &wd->sc_dksc; 666 667 KASSERT(bp == xfer->c_bio.bp || xfer->c_bio.bp == NULL); 668 KASSERT((xfer->c_flags & (C_WAITACT|C_FREE)) == 0); 669 KASSERT(mutex_owned(&wd->sc_lock)); 670 671 /* Reset state, so that retries don't use stale info */ 672 if (__predict_false(xfer->c_retries > 0)) { 673 xfer->c_flags = 0; 674 memset(&xfer->c_bio, 0, sizeof(xfer->c_bio)); 675 } 676 677 xfer->c_bio.blkno = bp->b_rawblkno; 678 xfer->c_bio.bcount = bp->b_bcount; 679 xfer->c_bio.databuf = bp->b_data; 680 xfer->c_bio.blkdone = 0; 681 xfer->c_bio.bp = bp; 682 683 #ifdef WD_CHAOS_MONKEY 684 /* 685 * Override blkno to be over device capacity to trigger error, 686 * but only if it's read, to avoid trashing disk contents should 687 * the command be clipped, or otherwise misinterpreted, by the 688 * driver or controller. 689 */ 690 if (BUF_ISREAD(bp) && xfer->c_retries == 0 && wd->drv_chaos_freq > 0 && 691 (++wd->drv_chaos_cnt % wd->drv_chaos_freq) == 0) { 692 device_printf(dksc->sc_dev, "%s: chaos xfer %"PRIxPTR"\n", 693 __func__, (intptr_t)xfer & PAGE_MASK); 694 xfer->c_bio.blkno = 7777777 + wd->sc_capacity; 695 xfer->c_flags |= C_CHAOS; 696 } 697 #endif 698 699 /* 700 * If we're retrying, retry in single-sector mode. This will give us 701 * the sector number of the problem, and will eventually allow the 702 * transfer to succeed. If FUA is requested, we can't actually 703 * do this, as ATA_SINGLE is usually executed as PIO transfer by drivers 704 * which support it, and that isn't compatible with NCQ/FUA. 705 */ 706 if (xfer->c_retries >= WDIORETRIES_SINGLE && 707 (bp->b_flags & B_MEDIA_FUA) == 0) 708 xfer->c_bio.flags = ATA_SINGLE; 709 else 710 xfer->c_bio.flags = 0; 711 712 /* 713 * request LBA48 transfers when supported by the controller 714 * and needed by transfer offset or size. 715 */ 716 if (wd->sc_flags & WDF_LBA48 && 717 (((xfer->c_bio.blkno + 718 xfer->c_bio.bcount / dksc->sc_dkdev.dk_geom.dg_secsize) > 719 wd->sc_capacity28) || 720 ((xfer->c_bio.bcount / dksc->sc_dkdev.dk_geom.dg_secsize) > 128))) 721 xfer->c_bio.flags |= ATA_LBA48; 722 723 /* 724 * If NCQ was negotiated, always use it for the first several attempts. 725 * Since device cancels all outstanding requests on error, downgrade 726 * to non-NCQ on retry, so that the retried transfer would not cause 727 * cascade failure for the other transfers if it fails again. 728 * If FUA was requested, we can't downgrade, as that would violate 729 * the semantics - FUA would not be honored. In that case, continue 730 * retrying with NCQ. 731 */ 732 if (WD_USE_NCQ(wd) && (xfer->c_retries < WDIORETRIES_SINGLE || 733 (bp->b_flags & B_MEDIA_FUA) != 0)) { 734 xfer->c_bio.flags |= ATA_LBA48; 735 xfer->c_flags |= C_NCQ; 736 737 if (WD_USE_NCQ_PRIO(wd) && 738 BIO_GETPRIO(bp) == BPRIO_TIMECRITICAL) 739 xfer->c_bio.flags |= ATA_PRIO_HIGH; 740 } 741 742 if (wd->sc_flags & WDF_LBA) 743 xfer->c_bio.flags |= ATA_LBA; 744 if (bp->b_flags & B_READ) { 745 xfer->c_bio.flags |= ATA_READ; 746 } else { 747 /* it's a write */ 748 wd->sc_flags |= WDF_DIRTY; 749 } 750 if (bp->b_flags & B_MEDIA_FUA) { 751 /* If not using NCQ, the command WRITE DMA FUA EXT is LBA48 */ 752 KASSERT((wd->sc_flags & WDF_LBA48) != 0); 753 if ((xfer->c_flags & C_NCQ) == 0) 754 xfer->c_bio.flags |= ATA_LBA48; 755 756 xfer->c_bio.flags |= ATA_FUA; 757 } 758 759 if (xfer->c_retries == 0) 760 wd->inflight++; 761 mutex_exit(&wd->sc_lock); 762 763 /* Queue the xfer */ 764 wd->atabus->ata_bio(wd->drvp, xfer); 765 766 mutex_enter(&wd->sc_lock); 767 } 768 769 static int 770 wd_diskstart(device_t dev, struct buf *bp) 771 { 772 struct wd_softc *wd = device_private(dev); 773 #ifdef ATADEBUG 774 struct dk_softc *dksc = &wd->sc_dksc; 775 #endif 776 struct ata_xfer *xfer; 777 struct ata_channel *chp; 778 unsigned openings; 779 int ticks; 780 781 mutex_enter(&wd->sc_lock); 782 783 chp = wd->drvp->chnl_softc; 784 785 ata_channel_lock(chp); 786 openings = ata_queue_openings(chp); 787 ata_channel_unlock(chp); 788 789 openings = uimin(openings, wd->drvp->drv_openings); 790 791 if (wd->inflight >= openings) { 792 /* 793 * pretend we run out of memory when the queue is full, 794 * so that the operation is retried after a minimal 795 * delay. 796 */ 797 xfer = NULL; 798 ticks = 1; 799 } else { 800 /* 801 * If there is no available memory, retry later. This 802 * happens very rarely and only under memory pressure, 803 * so wait relatively long before retry. 804 */ 805 xfer = ata_get_xfer(chp, false); 806 ticks = hz/2; 807 } 808 809 if (xfer == NULL) { 810 ATADEBUG_PRINT(("wd_diskstart %s no xfer\n", 811 dksc->sc_xname), DEBUG_XFERS); 812 813 /* 814 * The disk queue is pushed automatically when an I/O 815 * operation finishes or another one is queued. We 816 * need this extra timeout because an ATA channel 817 * might be shared by more than one disk queue and 818 * all queues need to be restarted when another slot 819 * becomes available. 820 */ 821 if (!callout_pending(&wd->sc_restart_diskqueue)) { 822 callout_reset(&wd->sc_restart_diskqueue, ticks, 823 wdrestart, dev); 824 } 825 826 mutex_exit(&wd->sc_lock); 827 return EAGAIN; 828 } 829 830 wdstart1(wd, bp, xfer); 831 832 mutex_exit(&wd->sc_lock); 833 834 return 0; 835 } 836 837 /* 838 * Queue a drive for I/O. 839 */ 840 static void 841 wdrestart(void *x) 842 { 843 device_t self = x; 844 struct wd_softc *wd = device_private(self); 845 struct dk_softc *dksc = &wd->sc_dksc; 846 847 ATADEBUG_PRINT(("wdstart %s\n", dksc->sc_xname), 848 DEBUG_XFERS); 849 850 if (!device_is_active(dksc->sc_dev)) 851 return; 852 853 dk_start(dksc, NULL); 854 } 855 856 static void 857 wddone(device_t self, struct ata_xfer *xfer) 858 { 859 struct wd_softc *wd = device_private(self); 860 struct dk_softc *dksc = &wd->sc_dksc; 861 const char *errmsg; 862 int do_perror = 0; 863 struct buf *bp; 864 865 ATADEBUG_PRINT(("wddone %s\n", dksc->sc_xname), 866 DEBUG_XFERS); 867 868 if (__predict_false(wddoingadump)) { 869 /* just drop it to the floor */ 870 ata_free_xfer(wd->drvp->chnl_softc, xfer); 871 return; 872 } 873 874 bp = xfer->c_bio.bp; 875 KASSERT(bp != NULL); 876 877 bp->b_resid = xfer->c_bio.bcount; 878 switch (xfer->c_bio.error) { 879 case ERR_DMA: 880 errmsg = "DMA error"; 881 goto retry; 882 case ERR_DF: 883 errmsg = "device fault"; 884 goto retry; 885 case TIMEOUT: 886 errmsg = "device timeout"; 887 goto retry; 888 case REQUEUE: 889 errmsg = "requeue"; 890 goto retry2; 891 case ERR_RESET: 892 errmsg = "channel reset"; 893 goto retry2; 894 case ERROR: 895 /* Don't care about media change bits */ 896 if (xfer->c_bio.r_error != 0 && 897 (xfer->c_bio.r_error & ~(WDCE_MC | WDCE_MCR)) == 0) 898 goto noerror; 899 errmsg = "error"; 900 do_perror = 1; 901 retry: /* Just reset and retry. Can we do more ? */ 902 if ((xfer->c_flags & C_RECOVERED) == 0) { 903 int wflags = (xfer->c_flags & C_POLL) ? AT_POLL : 0; 904 ata_channel_lock(wd->drvp->chnl_softc); 905 ata_thread_run(wd->drvp->chnl_softc, wflags, 906 ATACH_TH_DRIVE_RESET, wd->drvp->drive); 907 ata_channel_unlock(wd->drvp->chnl_softc); 908 } 909 retry2: 910 mutex_enter(&wd->sc_lock); 911 912 diskerr(bp, "wd", errmsg, LOG_PRINTF, 913 xfer->c_bio.blkdone, dksc->sc_dkdev.dk_label); 914 if (xfer->c_retries < WDIORETRIES) 915 printf(", xfer %"PRIxPTR", retry %d", 916 (intptr_t)xfer & PAGE_MASK, 917 xfer->c_retries); 918 printf("\n"); 919 if (do_perror) 920 wdperror(wd, xfer); 921 922 if (xfer->c_retries < WDIORETRIES) { 923 xfer->c_retries++; 924 925 /* Rerun ASAP if just requeued */ 926 if (xfer->c_bio.error == REQUEUE) { 927 SLIST_INSERT_HEAD(&wd->sc_requeue_list, xfer, 928 c_retrychain); 929 callout_reset(&wd->sc_requeue_callout, 930 1, wdbiorequeue, wd); 931 } else { 932 SLIST_INSERT_HEAD(&wd->sc_retry_list, xfer, 933 c_retrychain); 934 callout_reset(&wd->sc_retry_callout, 935 RECOVERYTIME, wdbioretry, wd); 936 } 937 938 mutex_exit(&wd->sc_lock); 939 return; 940 } 941 942 mutex_exit(&wd->sc_lock); 943 944 #ifdef WD_SOFTBADSECT 945 /* 946 * Not all errors indicate a failed block but those that do, 947 * put the block on the bad-block list for the device. Only 948 * do this for reads because the drive should do it for writes, 949 * itself, according to Manuel. 950 */ 951 if ((bp->b_flags & B_READ) && 952 ((wd->drvp->ata_vers >= 4 && xfer->c_bio.r_error & 64) || 953 (wd->drvp->ata_vers < 4 && xfer->c_bio.r_error & 192))) { 954 struct disk_badsectors *dbs; 955 956 dbs = kmem_zalloc(sizeof *dbs, KM_NOSLEEP); 957 if (dbs == NULL) { 958 aprint_error_dev(dksc->sc_dev, 959 "failed to add bad block to list\n"); 960 goto out; 961 } 962 963 dbs->dbs_min = bp->b_rawblkno; 964 dbs->dbs_max = dbs->dbs_min + 965 (bp->b_bcount /wd->sc_blksize) - 1; 966 microtime(&dbs->dbs_failedat); 967 968 mutex_enter(&wd->sc_lock); 969 SLIST_INSERT_HEAD(&wd->sc_bslist, dbs, dbs_next); 970 wd->sc_bscount++; 971 mutex_exit(&wd->sc_lock); 972 } 973 out: 974 #endif 975 bp->b_error = EIO; 976 break; 977 case NOERROR: 978 #ifdef WD_CHAOS_MONKEY 979 /* 980 * For example Parallels AHCI emulation doesn't actually 981 * return error for the invalid I/O, so just re-run 982 * the request and do not panic. 983 */ 984 if (__predict_false(xfer->c_flags & C_CHAOS)) { 985 xfer->c_bio.error = REQUEUE; 986 errmsg = "chaos noerror"; 987 goto retry2; 988 } 989 #endif 990 991 noerror: if ((xfer->c_bio.flags & ATA_CORR) || xfer->c_retries > 0) 992 device_printf(dksc->sc_dev, 993 "soft error (corrected) xfer %"PRIxPTR"\n", 994 (intptr_t)xfer & PAGE_MASK); 995 break; 996 case ERR_NODEV: 997 bp->b_error = EIO; 998 break; 999 } 1000 if (__predict_false(bp->b_error != 0) && bp->b_resid == 0) { 1001 /* 1002 * the disk or controller sometimes report a complete 1003 * xfer, when there has been an error. This is wrong, 1004 * assume nothing got transferred in this case 1005 */ 1006 bp->b_resid = bp->b_bcount; 1007 } 1008 1009 ata_free_xfer(wd->drvp->chnl_softc, xfer); 1010 1011 mutex_enter(&wd->sc_lock); 1012 wd->inflight--; 1013 mutex_exit(&wd->sc_lock); 1014 dk_done(dksc, bp); 1015 dk_start(dksc, NULL); 1016 } 1017 1018 static void 1019 wdbioretry(void *v) 1020 { 1021 struct wd_softc *wd = v; 1022 struct ata_xfer *xfer; 1023 1024 ATADEBUG_PRINT(("%s %s\n", __func__, wd->sc_dksc.sc_xname), 1025 DEBUG_XFERS); 1026 1027 mutex_enter(&wd->sc_lock); 1028 while ((xfer = SLIST_FIRST(&wd->sc_retry_list))) { 1029 SLIST_REMOVE_HEAD(&wd->sc_retry_list, c_retrychain); 1030 wdstart1(wd, xfer->c_bio.bp, xfer); 1031 } 1032 mutex_exit(&wd->sc_lock); 1033 } 1034 1035 static void 1036 wdbiorequeue(void *v) 1037 { 1038 struct wd_softc *wd = v; 1039 struct ata_xfer *xfer; 1040 1041 ATADEBUG_PRINT(("%s %s\n", __func__, wd->sc_dksc.sc_xname), 1042 DEBUG_XFERS); 1043 1044 mutex_enter(&wd->sc_lock); 1045 while ((xfer = SLIST_FIRST(&wd->sc_requeue_list))) { 1046 SLIST_REMOVE_HEAD(&wd->sc_requeue_list, c_retrychain); 1047 wdstart1(wd, xfer->c_bio.bp, xfer); 1048 } 1049 mutex_exit(&wd->sc_lock); 1050 } 1051 1052 static void 1053 wdminphys(struct buf *bp) 1054 { 1055 const struct wd_softc * const wd = 1056 device_lookup_private(&wd_cd, WDUNIT(bp->b_dev)); 1057 int maxsectors; 1058 1059 /* 1060 * The limit is actually 65536 for LBA48 and 256 for non-LBA48, 1061 * but that requires to set the count for the ATA command 1062 * to 0, which is somewhat error prone, so better stay safe. 1063 */ 1064 if (wd->sc_flags & WDF_LBA48) 1065 maxsectors = 65535; 1066 else 1067 maxsectors = 128; 1068 1069 if (bp->b_bcount > (wd->sc_blksize * maxsectors)) 1070 bp->b_bcount = (wd->sc_blksize * maxsectors); 1071 1072 minphys(bp); 1073 } 1074 1075 static void 1076 wd_iosize(device_t dev, int *count) 1077 { 1078 struct buf B; 1079 int bmaj; 1080 1081 bmaj = bdevsw_lookup_major(&wd_bdevsw); 1082 B.b_dev = MAKEWDDEV(bmaj,device_unit(dev),RAW_PART); 1083 B.b_bcount = *count; 1084 1085 wdminphys(&B); 1086 1087 *count = B.b_bcount; 1088 } 1089 1090 static int 1091 wdread(dev_t dev, struct uio *uio, int flags) 1092 { 1093 1094 ATADEBUG_PRINT(("wdread\n"), DEBUG_XFERS); 1095 return (physio(wdstrategy, NULL, dev, B_READ, wdminphys, uio)); 1096 } 1097 1098 static int 1099 wdwrite(dev_t dev, struct uio *uio, int flags) 1100 { 1101 1102 ATADEBUG_PRINT(("wdwrite\n"), DEBUG_XFERS); 1103 return (physio(wdstrategy, NULL, dev, B_WRITE, wdminphys, uio)); 1104 } 1105 1106 static int 1107 wdopen(dev_t dev, int flag, int fmt, struct lwp *l) 1108 { 1109 struct wd_softc *wd; 1110 struct dk_softc *dksc; 1111 int unit, part, error; 1112 1113 ATADEBUG_PRINT(("wdopen\n"), DEBUG_FUNCS); 1114 unit = WDUNIT(dev); 1115 wd = device_lookup_private(&wd_cd, unit); 1116 if (wd == NULL) 1117 return (ENXIO); 1118 dksc = &wd->sc_dksc; 1119 1120 if (! device_is_active(dksc->sc_dev)) 1121 return (ENODEV); 1122 1123 part = WDPART(dev); 1124 1125 if (wd->sc_capacity == 0) 1126 return (ENODEV); 1127 1128 /* 1129 * If any partition is open, but the disk has been invalidated, 1130 * disallow further opens. 1131 */ 1132 if ((wd->sc_flags & (WDF_OPEN | WDF_LOADED)) == WDF_OPEN) { 1133 if (part != RAW_PART || fmt != S_IFCHR) 1134 return EIO; 1135 } 1136 1137 error = dk_open(dksc, dev, flag, fmt, l); 1138 1139 return error; 1140 } 1141 1142 /* 1143 * Serialized by caller 1144 */ 1145 static int 1146 wd_firstopen(device_t self, dev_t dev, int flag, int fmt) 1147 { 1148 struct wd_softc *wd = device_private(self); 1149 struct dk_softc *dksc = &wd->sc_dksc; 1150 int error; 1151 1152 error = wd->atabus->ata_addref(wd->drvp); 1153 if (error) 1154 return error; 1155 1156 if ((wd->sc_flags & WDF_LOADED) == 0) { 1157 int param_error; 1158 1159 /* Load the physical device parameters. */ 1160 param_error = wd_get_params(wd, &wd->sc_params); 1161 if (param_error != 0) { 1162 aprint_error_dev(dksc->sc_dev, "IDENTIFY failed\n"); 1163 error = EIO; 1164 goto bad; 1165 } 1166 wd_set_geometry(wd); 1167 wd->sc_flags |= WDF_LOADED; 1168 } 1169 1170 wd->sc_flags |= WDF_OPEN; 1171 return 0; 1172 1173 bad: 1174 wd->atabus->ata_delref(wd->drvp); 1175 return error; 1176 } 1177 1178 /* 1179 * Caller must hold wd->sc_dk.dk_openlock. 1180 */ 1181 static int 1182 wd_lastclose(device_t self) 1183 { 1184 struct wd_softc *wd = device_private(self); 1185 1186 KASSERTMSG(bufq_peek(wd->sc_dksc.sc_bufq) == NULL, "bufq not empty"); 1187 1188 if (wd->sc_flags & WDF_DIRTY) 1189 wd_flushcache(wd, AT_WAIT, false); 1190 1191 wd->atabus->ata_delref(wd->drvp); 1192 wd->sc_flags &= ~WDF_OPEN; 1193 1194 return 0; 1195 } 1196 1197 static int 1198 wdclose(dev_t dev, int flag, int fmt, struct lwp *l) 1199 { 1200 struct wd_softc *wd; 1201 struct dk_softc *dksc; 1202 int unit; 1203 1204 unit = WDUNIT(dev); 1205 wd = device_lookup_private(&wd_cd, unit); 1206 dksc = &wd->sc_dksc; 1207 1208 return dk_close(dksc, dev, flag, fmt, l); 1209 } 1210 1211 void 1212 wdperror(const struct wd_softc *wd, struct ata_xfer *xfer) 1213 { 1214 static const char *const errstr0_3[] = {"address mark not found", 1215 "track 0 not found", "aborted command", "media change requested", 1216 "id not found", "media changed", "uncorrectable data error", 1217 "bad block detected"}; 1218 static const char *const errstr4_5[] = { 1219 "obsolete (address mark not found)", 1220 "no media/write protected", "aborted command", 1221 "media change requested", "id not found", "media changed", 1222 "uncorrectable data error", "interface CRC error"}; 1223 const char *const *errstr; 1224 int i; 1225 const char *sep = ""; 1226 1227 const struct dk_softc *dksc = &wd->sc_dksc; 1228 const char *devname = dksc->sc_xname; 1229 struct ata_drive_datas *drvp = wd->drvp; 1230 int errno = xfer->c_bio.r_error; 1231 1232 if (drvp->ata_vers >= 4) 1233 errstr = errstr4_5; 1234 else 1235 errstr = errstr0_3; 1236 1237 printf("%s: (", devname); 1238 1239 if (errno == 0) 1240 printf("error not notified"); 1241 1242 for (i = 0; i < 8; i++) { 1243 if (errno & (1 << i)) { 1244 printf("%s%s", sep, errstr[i]); 1245 sep = ", "; 1246 } 1247 } 1248 printf(")\n"); 1249 } 1250 1251 int 1252 wdioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l) 1253 { 1254 struct wd_softc *wd = 1255 device_lookup_private(&wd_cd, WDUNIT(dev)); 1256 struct dk_softc *dksc = &wd->sc_dksc; 1257 1258 ATADEBUG_PRINT(("wdioctl\n"), DEBUG_FUNCS); 1259 1260 if ((wd->sc_flags & WDF_LOADED) == 0) 1261 return EIO; 1262 1263 switch (cmd) { 1264 #ifdef HAS_BAD144_HANDLING 1265 case DIOCSBAD: 1266 if ((flag & FWRITE) == 0) 1267 return EBADF; 1268 dksc->sc_dkdev.dk_cpulabel->bad = *(struct dkbad *)addr; 1269 dksc->sc_dkdev.dk_label->d_flags |= D_BADSECT; 1270 bad144intern(wd); 1271 return 0; 1272 #endif 1273 #ifdef WD_SOFTBADSECT 1274 case DIOCBSLIST : 1275 { 1276 uint32_t count, missing, skip; 1277 struct disk_badsecinfo dbsi; 1278 struct disk_badsectors *dbs; 1279 size_t available; 1280 uint8_t *laddr; 1281 1282 dbsi = *(struct disk_badsecinfo *)addr; 1283 missing = wd->sc_bscount; 1284 count = 0; 1285 available = dbsi.dbsi_bufsize; 1286 skip = dbsi.dbsi_skip; 1287 laddr = (uint8_t *)dbsi.dbsi_buffer; 1288 1289 /* 1290 * We start this loop with the expectation that all of the 1291 * entries will be missed and decrement this counter each 1292 * time we either skip over one (already copied out) or 1293 * we actually copy it back to user space. The structs 1294 * holding the bad sector information are copied directly 1295 * back to user space whilst the summary is returned via 1296 * the struct passed in via the ioctl. 1297 */ 1298 mutex_enter(&wd->sc_lock); 1299 SLIST_FOREACH(dbs, &wd->sc_bslist, dbs_next) { 1300 if (skip > 0) { 1301 missing--; 1302 skip--; 1303 continue; 1304 } 1305 if (available < sizeof(*dbs)) 1306 break; 1307 available -= sizeof(*dbs); 1308 copyout(dbs, laddr, sizeof(*dbs)); 1309 laddr += sizeof(*dbs); 1310 missing--; 1311 count++; 1312 } 1313 mutex_exit(&wd->sc_lock); 1314 dbsi.dbsi_left = missing; 1315 dbsi.dbsi_copied = count; 1316 *(struct disk_badsecinfo *)addr = dbsi; 1317 return 0; 1318 } 1319 1320 case DIOCBSFLUSH : 1321 /* Clean out the bad sector list */ 1322 mutex_enter(&wd->sc_lock); 1323 while (!SLIST_EMPTY(&wd->sc_bslist)) { 1324 struct disk_badsectors *dbs = 1325 SLIST_FIRST(&wd->sc_bslist); 1326 SLIST_REMOVE_HEAD(&wd->sc_bslist, dbs_next); 1327 kmem_free(dbs, sizeof(*dbs)); 1328 } 1329 mutex_exit(&wd->sc_lock); 1330 wd->sc_bscount = 0; 1331 return 0; 1332 #endif 1333 1334 #ifdef notyet 1335 case DIOCWFORMAT: 1336 if ((flag & FWRITE) == 0) 1337 return EBADF; 1338 { 1339 register struct format_op *fop; 1340 struct iovec aiov; 1341 struct uio auio; 1342 int error1; 1343 1344 fop = (struct format_op *)addr; 1345 aiov.iov_base = fop->df_buf; 1346 aiov.iov_len = fop->df_count; 1347 auio.uio_iov = &aiov; 1348 auio.uio_iovcnt = 1; 1349 auio.uio_resid = fop->df_count; 1350 auio.uio_offset = 1351 fop->df_startblk * wd->sc_dk.dk_label->d_secsize; 1352 auio.uio_vmspace = l->l_proc->p_vmspace; 1353 error1 = physio(wdformat, NULL, dev, B_WRITE, wdminphys, 1354 &auio); 1355 fop->df_count -= auio.uio_resid; 1356 fop->df_reg[0] = wdc->sc_status; 1357 fop->df_reg[1] = wdc->sc_error; 1358 return error1; 1359 } 1360 #endif 1361 case DIOCGCACHE: 1362 return wd_getcache(wd, (int *)addr); 1363 1364 case DIOCSCACHE: 1365 return wd_setcache(wd, *(int *)addr); 1366 1367 case DIOCCACHESYNC: 1368 return wd_flushcache(wd, AT_WAIT, true); 1369 1370 case ATAIOCCOMMAND: 1371 /* 1372 * Make sure this command is (relatively) safe first 1373 */ 1374 if ((((atareq_t *) addr)->flags & ATACMD_READ) == 0 && 1375 (flag & FWRITE) == 0) 1376 return (EBADF); 1377 { 1378 struct wd_ioctl *wi; 1379 atareq_t *atareq = (atareq_t *) addr; 1380 int error1; 1381 1382 wi = wi_get(wd); 1383 wi->wi_atareq = *atareq; 1384 1385 if (atareq->datalen && atareq->flags & 1386 (ATACMD_READ | ATACMD_WRITE)) { 1387 void *tbuf; 1388 if (atareq->datalen < DEV_BSIZE 1389 && atareq->command == WDCC_IDENTIFY) { 1390 tbuf = kmem_zalloc(DEV_BSIZE, KM_SLEEP); 1391 wi->wi_iov.iov_base = tbuf; 1392 wi->wi_iov.iov_len = DEV_BSIZE; 1393 UIO_SETUP_SYSSPACE(&wi->wi_uio); 1394 } else { 1395 tbuf = NULL; 1396 wi->wi_iov.iov_base = atareq->databuf; 1397 wi->wi_iov.iov_len = atareq->datalen; 1398 wi->wi_uio.uio_vmspace = l->l_proc->p_vmspace; 1399 } 1400 wi->wi_uio.uio_iov = &wi->wi_iov; 1401 wi->wi_uio.uio_iovcnt = 1; 1402 wi->wi_uio.uio_resid = atareq->datalen; 1403 wi->wi_uio.uio_offset = 0; 1404 wi->wi_uio.uio_rw = 1405 (atareq->flags & ATACMD_READ) ? B_READ : B_WRITE; 1406 error1 = physio(wdioctlstrategy, &wi->wi_bp, dev, 1407 (atareq->flags & ATACMD_READ) ? B_READ : B_WRITE, 1408 wdminphys, &wi->wi_uio); 1409 if (tbuf != NULL && error1 == 0) { 1410 error1 = copyout(tbuf, atareq->databuf, 1411 atareq->datalen); 1412 kmem_free(tbuf, DEV_BSIZE); 1413 } 1414 } else { 1415 /* No need to call physio if we don't have any 1416 user data */ 1417 wi->wi_bp.b_flags = 0; 1418 wi->wi_bp.b_data = 0; 1419 wi->wi_bp.b_bcount = 0; 1420 wi->wi_bp.b_dev = dev; 1421 wi->wi_bp.b_proc = l->l_proc; 1422 wdioctlstrategy(&wi->wi_bp); 1423 error1 = wi->wi_bp.b_error; 1424 } 1425 *atareq = wi->wi_atareq; 1426 wi_free(wi); 1427 return(error1); 1428 } 1429 1430 case DIOCGSECTORALIGN: { 1431 struct disk_sectoralign *dsa = addr; 1432 int part = WDPART(dev); 1433 1434 *dsa = wd->sc_sectoralign; 1435 if (part != RAW_PART) { 1436 struct disklabel *lp = dksc->sc_dkdev.dk_label; 1437 daddr_t offset = lp->d_partitions[part].p_offset; 1438 uint32_t r = offset % dsa->dsa_alignment; 1439 1440 if (r < dsa->dsa_firstaligned) 1441 dsa->dsa_firstaligned = dsa->dsa_firstaligned 1442 - r; 1443 else 1444 dsa->dsa_firstaligned = (dsa->dsa_firstaligned 1445 + dsa->dsa_alignment) - r; 1446 } 1447 1448 return 0; 1449 } 1450 1451 default: 1452 return dk_ioctl(dksc, dev, cmd, addr, flag, l); 1453 } 1454 1455 #ifdef DIAGNOSTIC 1456 panic("wdioctl: impossible"); 1457 #endif 1458 } 1459 1460 static int 1461 wd_discard(device_t dev, off_t pos, off_t len) 1462 { 1463 struct wd_softc *wd = device_private(dev); 1464 daddr_t bno; 1465 long size, done; 1466 long maxatonce, amount; 1467 int result; 1468 1469 if (!(wd->sc_params.atap_ata_major & WDC_VER_ATA7) 1470 || !(wd->sc_params.support_dsm & ATA_SUPPORT_DSM_TRIM)) { 1471 /* not supported; ignore request */ 1472 ATADEBUG_PRINT(("wddiscard (unsupported)\n"), DEBUG_FUNCS); 1473 return 0; 1474 } 1475 maxatonce = 0xffff; /*wd->sc_params.max_dsm_blocks*/ 1476 1477 ATADEBUG_PRINT(("wddiscard\n"), DEBUG_FUNCS); 1478 1479 if ((wd->sc_flags & WDF_LOADED) == 0) 1480 return EIO; 1481 1482 /* round the start up and the end down */ 1483 bno = (pos + wd->sc_blksize - 1) / wd->sc_blksize; 1484 size = ((pos + len) / wd->sc_blksize) - bno; 1485 1486 done = 0; 1487 while (done < size) { 1488 amount = size - done; 1489 if (amount > maxatonce) { 1490 amount = maxatonce; 1491 } 1492 result = wd_trim(wd, bno + done, amount); 1493 if (result) { 1494 return result; 1495 } 1496 done += amount; 1497 } 1498 return 0; 1499 } 1500 1501 static int 1502 wddiscard(dev_t dev, off_t pos, off_t len) 1503 { 1504 struct wd_softc *wd; 1505 struct dk_softc *dksc; 1506 int unit; 1507 1508 unit = WDUNIT(dev); 1509 wd = device_lookup_private(&wd_cd, unit); 1510 dksc = &wd->sc_dksc; 1511 1512 return dk_discard(dksc, dev, pos, len); 1513 } 1514 1515 #ifdef B_FORMAT 1516 int 1517 wdformat(struct buf *bp) 1518 { 1519 1520 bp->b_flags |= B_FORMAT; 1521 return wdstrategy(bp); 1522 } 1523 #endif 1524 1525 int 1526 wdsize(dev_t dev) 1527 { 1528 struct wd_softc *wd; 1529 struct dk_softc *dksc; 1530 int unit; 1531 1532 ATADEBUG_PRINT(("wdsize\n"), DEBUG_FUNCS); 1533 1534 unit = WDUNIT(dev); 1535 wd = device_lookup_private(&wd_cd, unit); 1536 if (wd == NULL) 1537 return (-1); 1538 dksc = &wd->sc_dksc; 1539 1540 if (!device_is_active(dksc->sc_dev)) 1541 return (-1); 1542 1543 return dk_size(dksc, dev); 1544 } 1545 1546 /* 1547 * Dump core after a system crash. 1548 */ 1549 static int 1550 wddump(dev_t dev, daddr_t blkno, void *va, size_t size) 1551 { 1552 struct wd_softc *wd; 1553 struct dk_softc *dksc; 1554 int unit; 1555 1556 /* Check if recursive dump; if so, punt. */ 1557 if (wddoingadump) 1558 return EFAULT; 1559 wddoingadump = 1; 1560 1561 unit = WDUNIT(dev); 1562 wd = device_lookup_private(&wd_cd, unit); 1563 if (wd == NULL) 1564 return (ENXIO); 1565 dksc = &wd->sc_dksc; 1566 1567 return dk_dump(dksc, dev, blkno, va, size, 0); 1568 } 1569 1570 static int 1571 wd_dumpblocks(device_t dev, void *va, daddr_t blkno, int nblk) 1572 { 1573 struct wd_softc *wd = device_private(dev); 1574 struct dk_softc *dksc = &wd->sc_dksc; 1575 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom; 1576 struct ata_xfer *xfer = &wd->dump_xfer; 1577 int err; 1578 1579 /* Recalibrate, if first dump transfer. */ 1580 if (wddumprecalibrated == 0) { 1581 wddumprecalibrated = 1; 1582 ata_channel_lock(wd->drvp->chnl_softc); 1583 /* This will directly execute the reset due to AT_POLL */ 1584 ata_thread_run(wd->drvp->chnl_softc, AT_POLL, 1585 ATACH_TH_DRIVE_RESET, wd->drvp->drive); 1586 1587 wd->drvp->state = RESET; 1588 ata_channel_unlock(wd->drvp->chnl_softc); 1589 } 1590 1591 memset(xfer, 0, sizeof(*xfer)); 1592 xfer->c_flags |= C_PRIVATE_ALLOC | C_SKIP_QUEUE; 1593 1594 xfer->c_bio.blkno = blkno; 1595 xfer->c_bio.flags = ATA_POLL; 1596 if (wd->sc_flags & WDF_LBA48 && 1597 (xfer->c_bio.blkno + nblk) > wd->sc_capacity28) 1598 xfer->c_bio.flags |= ATA_LBA48; 1599 if (wd->sc_flags & WDF_LBA) 1600 xfer->c_bio.flags |= ATA_LBA; 1601 xfer->c_bio.bcount = nblk * dg->dg_secsize; 1602 xfer->c_bio.databuf = va; 1603 #ifndef WD_DUMP_NOT_TRUSTED 1604 /* This will poll until the bio is complete */ 1605 wd->atabus->ata_bio(wd->drvp, xfer); 1606 1607 switch(err = xfer->c_bio.error) { 1608 case TIMEOUT: 1609 printf("wddump: device timed out"); 1610 err = EIO; 1611 break; 1612 case ERR_DF: 1613 printf("wddump: drive fault"); 1614 err = EIO; 1615 break; 1616 case ERR_DMA: 1617 printf("wddump: DMA error"); 1618 err = EIO; 1619 break; 1620 case ERROR: 1621 printf("wddump: "); 1622 wdperror(wd, xfer); 1623 err = EIO; 1624 break; 1625 case NOERROR: 1626 err = 0; 1627 break; 1628 default: 1629 panic("wddump: unknown error type %x", err); 1630 } 1631 1632 if (err != 0) { 1633 printf("\n"); 1634 return err; 1635 } 1636 #else /* WD_DUMP_NOT_TRUSTED */ 1637 /* Let's just talk about this first... */ 1638 printf("wd%d: dump addr 0x%x, cylin %d, head %d, sector %d\n", 1639 unit, va, cylin, head, sector); 1640 delay(500 * 1000); /* half a second */ 1641 #endif 1642 1643 wddoingadump = 0; 1644 return 0; 1645 } 1646 1647 #ifdef HAS_BAD144_HANDLING 1648 /* 1649 * Internalize the bad sector table. 1650 */ 1651 void 1652 bad144intern(struct wd_softc *wd) 1653 { 1654 struct dk_softc *dksc = &wd->sc_dksc; 1655 struct dkbad *bt = &dksc->sc_dkdev.dk_cpulabel->bad; 1656 struct disklabel *lp = dksc->sc_dkdev.dk_label; 1657 int i = 0; 1658 1659 ATADEBUG_PRINT(("bad144intern\n"), DEBUG_XFERS); 1660 1661 for (; i < NBT_BAD; i++) { 1662 if (bt->bt_bad[i].bt_cyl == 0xffff) 1663 break; 1664 wd->drvp->badsect[i] = 1665 bt->bt_bad[i].bt_cyl * lp->d_secpercyl + 1666 (bt->bt_bad[i].bt_trksec >> 8) * lp->d_nsectors + 1667 (bt->bt_bad[i].bt_trksec & 0xff); 1668 } 1669 for (; i < NBT_BAD+1; i++) 1670 wd->drvp->badsect[i] = -1; 1671 } 1672 #endif 1673 1674 static void 1675 wd_set_geometry(struct wd_softc *wd) 1676 { 1677 struct dk_softc *dksc = &wd->sc_dksc; 1678 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom; 1679 1680 memset(dg, 0, sizeof(*dg)); 1681 1682 dg->dg_secperunit = wd->sc_capacity; 1683 dg->dg_secsize = wd->sc_blksize; 1684 dg->dg_nsectors = wd->sc_params.atap_sectors; 1685 dg->dg_ntracks = wd->sc_params.atap_heads; 1686 if ((wd->sc_flags & WDF_LBA) == 0) 1687 dg->dg_ncylinders = wd->sc_params.atap_cylinders; 1688 1689 disk_set_info(dksc->sc_dev, &dksc->sc_dkdev, wd->sc_typename); 1690 } 1691 1692 int 1693 wd_get_params(struct wd_softc *wd, struct ataparams *params) 1694 { 1695 int retry = 0; 1696 struct ata_channel *chp = wd->drvp->chnl_softc; 1697 const int flags = AT_WAIT; 1698 1699 again: 1700 switch (wd->atabus->ata_get_params(wd->drvp, flags, params)) { 1701 case CMD_AGAIN: 1702 return 1; 1703 case CMD_ERR: 1704 if (retry == 0) { 1705 retry++; 1706 ata_channel_lock(chp); 1707 (*wd->atabus->ata_reset_drive)(wd->drvp, flags, NULL); 1708 ata_channel_unlock(chp); 1709 goto again; 1710 } 1711 1712 if (wd->drvp->drive_type != ATA_DRIVET_OLD) 1713 return 1; 1714 /* 1715 * We `know' there's a drive here; just assume it's old. 1716 * This geometry is only used to read the MBR and print a 1717 * (false) attach message. 1718 */ 1719 strncpy(params->atap_model, "ST506", 1720 sizeof params->atap_model); 1721 params->atap_config = ATA_CFG_FIXED; 1722 params->atap_cylinders = 1024; 1723 params->atap_heads = 8; 1724 params->atap_sectors = 17; 1725 params->atap_multi = 1; 1726 params->atap_capabilities1 = params->atap_capabilities2 = 0; 1727 wd->drvp->ata_vers = -1; /* Mark it as pre-ATA */ 1728 /* FALLTHROUGH */ 1729 case CMD_OK: 1730 return 0; 1731 default: 1732 panic("wd_get_params: bad return code from ata_get_params"); 1733 /* NOTREACHED */ 1734 } 1735 } 1736 1737 int 1738 wd_getcache(struct wd_softc *wd, int *bitsp) 1739 { 1740 struct ataparams params; 1741 1742 if (wd_get_params(wd, ¶ms) != 0) 1743 return EIO; 1744 if (params.atap_cmd_set1 == 0x0000 || 1745 params.atap_cmd_set1 == 0xffff || 1746 (params.atap_cmd_set1 & WDC_CMD1_CACHE) == 0) { 1747 *bitsp = 0; 1748 return 0; 1749 } 1750 *bitsp = DKCACHE_WCHANGE | DKCACHE_READ; 1751 if (params.atap_cmd1_en & WDC_CMD1_CACHE) 1752 *bitsp |= DKCACHE_WRITE; 1753 1754 if (WD_USE_NCQ(wd) || (wd->drvp->drive_flags & ATA_DRIVE_WFUA)) 1755 *bitsp |= DKCACHE_FUA; 1756 1757 return 0; 1758 } 1759 1760 const char at_errbits[] = "\20\10ERROR\11TIMEOU\12DF"; 1761 1762 int 1763 wd_setcache(struct wd_softc *wd, int bits) 1764 { 1765 struct dk_softc *dksc = &wd->sc_dksc; 1766 struct ataparams params; 1767 struct ata_xfer *xfer; 1768 int error; 1769 1770 if (wd_get_params(wd, ¶ms) != 0) 1771 return EIO; 1772 1773 if (params.atap_cmd_set1 == 0x0000 || 1774 params.atap_cmd_set1 == 0xffff || 1775 (params.atap_cmd_set1 & WDC_CMD1_CACHE) == 0) 1776 return EOPNOTSUPP; 1777 1778 if ((bits & DKCACHE_READ) == 0 || 1779 (bits & DKCACHE_SAVE) != 0) 1780 return EOPNOTSUPP; 1781 1782 xfer = ata_get_xfer(wd->drvp->chnl_softc, true); 1783 1784 xfer->c_ata_c.r_command = SET_FEATURES; 1785 xfer->c_ata_c.r_st_bmask = 0; 1786 xfer->c_ata_c.r_st_pmask = 0; 1787 xfer->c_ata_c.timeout = 30000; /* 30s timeout */ 1788 xfer->c_ata_c.flags = AT_WAIT; 1789 if (bits & DKCACHE_WRITE) 1790 xfer->c_ata_c.r_features = WDSF_WRITE_CACHE_EN; 1791 else 1792 xfer->c_ata_c.r_features = WDSF_WRITE_CACHE_DS; 1793 1794 wd->atabus->ata_exec_command(wd->drvp, xfer); 1795 ata_wait_cmd(wd->drvp->chnl_softc, xfer); 1796 1797 if (xfer->c_ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) { 1798 char sbuf[sizeof(at_errbits) + 64]; 1799 snprintb(sbuf, sizeof(sbuf), at_errbits, xfer->c_ata_c.flags); 1800 aprint_error_dev(dksc->sc_dev, "wd_setcache: status=%s\n", sbuf); 1801 error = EIO; 1802 goto out; 1803 } 1804 1805 error = 0; 1806 1807 out: 1808 ata_free_xfer(wd->drvp->chnl_softc, xfer); 1809 return error; 1810 } 1811 1812 static int 1813 wd_standby(struct wd_softc *wd, int flags) 1814 { 1815 struct dk_softc *dksc = &wd->sc_dksc; 1816 struct ata_xfer *xfer; 1817 int error; 1818 1819 aprint_debug_dev(dksc->sc_dev, "standby immediate\n"); 1820 xfer = ata_get_xfer(wd->drvp->chnl_softc, true); 1821 1822 xfer->c_ata_c.r_command = WDCC_STANDBY_IMMED; 1823 xfer->c_ata_c.r_st_bmask = WDCS_DRDY; 1824 xfer->c_ata_c.r_st_pmask = WDCS_DRDY; 1825 xfer->c_ata_c.flags = flags; 1826 xfer->c_ata_c.timeout = 30000; /* 30s timeout */ 1827 1828 wd->atabus->ata_exec_command(wd->drvp, xfer); 1829 ata_wait_cmd(wd->drvp->chnl_softc, xfer); 1830 1831 if (xfer->c_ata_c.flags & AT_ERROR) { 1832 if (xfer->c_ata_c.r_error == WDCE_ABRT) { 1833 /* command not supported */ 1834 aprint_debug_dev(dksc->sc_dev, 1835 "standby immediate not supported\n"); 1836 error = ENODEV; 1837 goto out; 1838 } 1839 } 1840 if (xfer->c_ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) { 1841 char sbuf[sizeof(at_errbits) + 64]; 1842 snprintb(sbuf, sizeof(sbuf), at_errbits, xfer->c_ata_c.flags); 1843 aprint_error_dev(dksc->sc_dev, "wd_standby: status=%s\n", sbuf); 1844 error = EIO; 1845 goto out; 1846 } 1847 error = 0; 1848 1849 out: 1850 ata_free_xfer(wd->drvp->chnl_softc, xfer); 1851 return error; 1852 } 1853 1854 int 1855 wd_flushcache(struct wd_softc *wd, int flags, bool start_self) 1856 { 1857 struct dk_softc *dksc = &wd->sc_dksc; 1858 struct ata_xfer *xfer; 1859 int error; 1860 1861 /* 1862 * WDCC_FLUSHCACHE is here since ATA-4, but some drives report 1863 * only ATA-2 and still support it. 1864 */ 1865 if (wd->drvp->ata_vers < 4 && 1866 ((wd->sc_params.atap_cmd_set2 & WDC_CMD2_FC) == 0 || 1867 wd->sc_params.atap_cmd_set2 == 0xffff)) 1868 return ENODEV; 1869 1870 xfer = ata_get_xfer(wd->drvp->chnl_softc, true); 1871 1872 if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0 && 1873 (wd->sc_params.atap_cmd2_en & ATA_CMD2_FCE) != 0) { 1874 xfer->c_ata_c.r_command = WDCC_FLUSHCACHE_EXT; 1875 flags |= AT_LBA48; 1876 } else 1877 xfer->c_ata_c.r_command = WDCC_FLUSHCACHE; 1878 xfer->c_ata_c.r_st_bmask = WDCS_DRDY; 1879 xfer->c_ata_c.r_st_pmask = WDCS_DRDY; 1880 xfer->c_ata_c.flags = flags | AT_READREG; 1881 xfer->c_ata_c.timeout = 300000; /* 5m timeout */ 1882 1883 wd->atabus->ata_exec_command(wd->drvp, xfer); 1884 ata_wait_cmd(wd->drvp->chnl_softc, xfer); 1885 1886 if (xfer->c_ata_c.flags & AT_ERROR) { 1887 if (xfer->c_ata_c.r_error == WDCE_ABRT) { 1888 /* command not supported */ 1889 error = ENODEV; 1890 goto out_xfer; 1891 } 1892 } 1893 if (xfer->c_ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) { 1894 char sbuf[sizeof(at_errbits) + 64]; 1895 snprintb(sbuf, sizeof(sbuf), at_errbits, xfer->c_ata_c.flags); 1896 aprint_error_dev(dksc->sc_dev, "wd_flushcache: status=%s\n", 1897 sbuf); 1898 error = EIO; 1899 goto out_xfer; 1900 } 1901 wd->sc_flags &= ~WDF_DIRTY; 1902 error = 0; 1903 1904 out_xfer: 1905 ata_free_xfer(wd->drvp->chnl_softc, xfer); 1906 return error; 1907 } 1908 1909 /* 1910 * Execute TRIM command, assumes sleep context. 1911 */ 1912 static int 1913 wd_trim(struct wd_softc *wd, daddr_t bno, long size) 1914 { 1915 struct dk_softc *dksc = &wd->sc_dksc; 1916 struct ata_xfer *xfer; 1917 int error; 1918 unsigned char *req; 1919 1920 xfer = ata_get_xfer(wd->drvp->chnl_softc, true); 1921 1922 req = kmem_zalloc(512, KM_SLEEP); 1923 req[0] = bno & 0xff; 1924 req[1] = (bno >> 8) & 0xff; 1925 req[2] = (bno >> 16) & 0xff; 1926 req[3] = (bno >> 24) & 0xff; 1927 req[4] = (bno >> 32) & 0xff; 1928 req[5] = (bno >> 40) & 0xff; 1929 req[6] = size & 0xff; 1930 req[7] = (size >> 8) & 0xff; 1931 1932 /* 1933 * XXX We could possibly use NCQ TRIM, which supports executing 1934 * this command concurrently. It would need some investigation, some 1935 * early or not so early disk firmware caused data loss with NCQ TRIM. 1936 * atastart() et.al would need to be adjusted to allow and support 1937 * running several non-I/O ATA commands in parallel. 1938 */ 1939 1940 xfer->c_ata_c.r_command = ATA_DATA_SET_MANAGEMENT; 1941 xfer->c_ata_c.r_count = 1; 1942 xfer->c_ata_c.r_features = ATA_SUPPORT_DSM_TRIM; 1943 xfer->c_ata_c.r_st_bmask = WDCS_DRDY; 1944 xfer->c_ata_c.r_st_pmask = WDCS_DRDY; 1945 xfer->c_ata_c.timeout = 30000; /* 30s timeout */ 1946 xfer->c_ata_c.data = req; 1947 xfer->c_ata_c.bcount = 512; 1948 xfer->c_ata_c.flags |= AT_WRITE | AT_WAIT; 1949 1950 wd->atabus->ata_exec_command(wd->drvp, xfer); 1951 ata_wait_cmd(wd->drvp->chnl_softc, xfer); 1952 1953 kmem_free(req, 512); 1954 if (xfer->c_ata_c.flags & AT_ERROR) { 1955 if (xfer->c_ata_c.r_error == WDCE_ABRT) { 1956 /* command not supported */ 1957 error = ENODEV; 1958 goto out; 1959 } 1960 } 1961 if (xfer->c_ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) { 1962 char sbuf[sizeof(at_errbits) + 64]; 1963 snprintb(sbuf, sizeof(sbuf), at_errbits, xfer->c_ata_c.flags); 1964 aprint_error_dev(dksc->sc_dev, "wd_trim: status=%s\n", 1965 sbuf); 1966 error = EIO; 1967 goto out; 1968 } 1969 error = 0; 1970 1971 out: 1972 ata_free_xfer(wd->drvp->chnl_softc, xfer); 1973 return error; 1974 } 1975 1976 bool 1977 wd_shutdown(device_t dev, int how) 1978 { 1979 struct wd_softc *wd = device_private(dev); 1980 1981 /* the adapter needs to be enabled */ 1982 if (wd->atabus->ata_addref(wd->drvp)) 1983 return true; /* no need to complain */ 1984 1985 wd_flushcache(wd, AT_POLL, false); 1986 if ((how & RB_POWERDOWN) == RB_POWERDOWN) 1987 wd_standby(wd, AT_POLL); 1988 return true; 1989 } 1990 1991 /* 1992 * Allocate space for a ioctl queue structure. Mostly taken from 1993 * scsipi_ioctl.c 1994 */ 1995 struct wd_ioctl * 1996 wi_get(struct wd_softc *wd) 1997 { 1998 struct wd_ioctl *wi; 1999 2000 wi = kmem_zalloc(sizeof(struct wd_ioctl), KM_SLEEP); 2001 wi->wi_softc = wd; 2002 buf_init(&wi->wi_bp); 2003 2004 return (wi); 2005 } 2006 2007 /* 2008 * Free an ioctl structure and remove it from our list 2009 */ 2010 2011 void 2012 wi_free(struct wd_ioctl *wi) 2013 { 2014 buf_destroy(&wi->wi_bp); 2015 kmem_free(wi, sizeof(*wi)); 2016 } 2017 2018 /* 2019 * Find a wd_ioctl structure based on the struct buf. 2020 */ 2021 2022 struct wd_ioctl * 2023 wi_find(struct buf *bp) 2024 { 2025 return container_of(bp, struct wd_ioctl, wi_bp); 2026 } 2027 2028 static uint 2029 wi_sector_size(const struct wd_ioctl * const wi) 2030 { 2031 switch (wi->wi_atareq.command) { 2032 case WDCC_READ: 2033 case WDCC_WRITE: 2034 case WDCC_READMULTI: 2035 case WDCC_WRITEMULTI: 2036 case WDCC_READDMA: 2037 case WDCC_WRITEDMA: 2038 case WDCC_READ_EXT: 2039 case WDCC_WRITE_EXT: 2040 case WDCC_READMULTI_EXT: 2041 case WDCC_WRITEMULTI_EXT: 2042 case WDCC_READDMA_EXT: 2043 case WDCC_WRITEDMA_EXT: 2044 case WDCC_READ_FPDMA_QUEUED: 2045 case WDCC_WRITE_FPDMA_QUEUED: 2046 return wi->wi_softc->sc_blksize; 2047 default: 2048 return 512; 2049 } 2050 } 2051 2052 /* 2053 * Ioctl pseudo strategy routine 2054 * 2055 * This is mostly stolen from scsipi_ioctl.c:scsistrategy(). What 2056 * happens here is: 2057 * 2058 * - wdioctl() queues a wd_ioctl structure. 2059 * 2060 * - wdioctl() calls physio/wdioctlstrategy based on whether or not 2061 * user space I/O is required. If physio() is called, physio() eventually 2062 * calls wdioctlstrategy(). 2063 * 2064 * - In either case, wdioctlstrategy() calls wd->atabus->ata_exec_command() 2065 * to perform the actual command 2066 * 2067 * The reason for the use of the pseudo strategy routine is because 2068 * when doing I/O to/from user space, physio _really_ wants to be in 2069 * the loop. We could put the entire buffer into the ioctl request 2070 * structure, but that won't scale if we want to do things like download 2071 * microcode. 2072 */ 2073 2074 void 2075 wdioctlstrategy(struct buf *bp) 2076 { 2077 struct wd_ioctl *wi; 2078 struct ata_xfer *xfer; 2079 int error = 0; 2080 2081 wi = wi_find(bp); 2082 if (wi == NULL) { 2083 printf("wdioctlstrategy: " 2084 "No matching ioctl request found in queue\n"); 2085 error = EINVAL; 2086 goto out2; 2087 } 2088 2089 xfer = ata_get_xfer(wi->wi_softc->drvp->chnl_softc, true); 2090 2091 /* 2092 * Abort if physio broke up the transfer 2093 */ 2094 2095 if (bp->b_bcount != wi->wi_atareq.datalen) { 2096 printf("physio split wd ioctl request... cannot proceed\n"); 2097 error = EIO; 2098 goto out; 2099 } 2100 2101 /* 2102 * Abort if we didn't get a buffer size that was a multiple of 2103 * our sector size (or overflows CHS/LBA28 sector count) 2104 */ 2105 2106 if ((bp->b_bcount % wi_sector_size(wi)) != 0 || 2107 (bp->b_bcount / wi_sector_size(wi)) >= 2108 (1 << NBBY)) { 2109 error = EINVAL; 2110 goto out; 2111 } 2112 2113 /* 2114 * Make sure a timeout was supplied in the ioctl request 2115 */ 2116 2117 if (wi->wi_atareq.timeout == 0) { 2118 error = EINVAL; 2119 goto out; 2120 } 2121 2122 if (wi->wi_atareq.flags & ATACMD_READ) 2123 xfer->c_ata_c.flags |= AT_READ; 2124 else if (wi->wi_atareq.flags & ATACMD_WRITE) 2125 xfer->c_ata_c.flags |= AT_WRITE; 2126 2127 if (wi->wi_atareq.flags & ATACMD_READREG) 2128 xfer->c_ata_c.flags |= AT_READREG; 2129 2130 if ((wi->wi_atareq.flags & ATACMD_LBA) != 0) 2131 xfer->c_ata_c.flags |= AT_LBA; 2132 2133 xfer->c_ata_c.flags |= AT_WAIT; 2134 2135 xfer->c_ata_c.timeout = wi->wi_atareq.timeout; 2136 xfer->c_ata_c.r_command = wi->wi_atareq.command; 2137 xfer->c_ata_c.r_lba = ((wi->wi_atareq.head & 0x0f) << 24) | 2138 (wi->wi_atareq.cylinder << 8) | 2139 wi->wi_atareq.sec_num; 2140 xfer->c_ata_c.r_count = wi->wi_atareq.sec_count; 2141 xfer->c_ata_c.r_features = wi->wi_atareq.features; 2142 xfer->c_ata_c.r_st_bmask = WDCS_DRDY; 2143 xfer->c_ata_c.r_st_pmask = WDCS_DRDY; 2144 xfer->c_ata_c.data = wi->wi_bp.b_data; 2145 xfer->c_ata_c.bcount = wi->wi_bp.b_bcount; 2146 2147 wi->wi_softc->atabus->ata_exec_command(wi->wi_softc->drvp, xfer); 2148 ata_wait_cmd(wi->wi_softc->drvp->chnl_softc, xfer); 2149 2150 if (xfer->c_ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) { 2151 if (xfer->c_ata_c.flags & AT_ERROR) { 2152 wi->wi_atareq.retsts = ATACMD_ERROR; 2153 wi->wi_atareq.error = xfer->c_ata_c.r_error; 2154 } else if (xfer->c_ata_c.flags & AT_DF) 2155 wi->wi_atareq.retsts = ATACMD_DF; 2156 else 2157 wi->wi_atareq.retsts = ATACMD_TIMEOUT; 2158 } else { 2159 wi->wi_atareq.retsts = ATACMD_OK; 2160 if (wi->wi_atareq.flags & ATACMD_READREG) { 2161 wi->wi_atareq.command = xfer->c_ata_c.r_status; 2162 wi->wi_atareq.features = xfer->c_ata_c.r_error; 2163 wi->wi_atareq.sec_count = xfer->c_ata_c.r_count; 2164 wi->wi_atareq.sec_num = xfer->c_ata_c.r_lba & 0xff; 2165 wi->wi_atareq.head = (xfer->c_ata_c.r_device & 0xf0) | 2166 ((xfer->c_ata_c.r_lba >> 24) & 0x0f); 2167 wi->wi_atareq.cylinder = 2168 (xfer->c_ata_c.r_lba >> 8) & 0xffff; 2169 wi->wi_atareq.error = xfer->c_ata_c.r_error; 2170 } 2171 } 2172 2173 out: 2174 ata_free_xfer(wi->wi_softc->drvp->chnl_softc, xfer); 2175 out2: 2176 bp->b_error = error; 2177 if (error) 2178 bp->b_resid = bp->b_bcount; 2179 biodone(bp); 2180 } 2181 2182 static void 2183 wd_sysctl_attach(struct wd_softc *wd) 2184 { 2185 struct dk_softc *dksc = &wd->sc_dksc; 2186 const struct sysctlnode *node; 2187 int error; 2188 2189 /* sysctl set-up */ 2190 if (sysctl_createv(&wd->nodelog, 0, NULL, &node, 2191 0, CTLTYPE_NODE, dksc->sc_xname, 2192 SYSCTL_DESCR("wd driver settings"), 2193 NULL, 0, NULL, 0, 2194 CTL_HW, CTL_CREATE, CTL_EOL) != 0) { 2195 aprint_error_dev(dksc->sc_dev, 2196 "could not create %s.%s sysctl node\n", 2197 "hw", dksc->sc_xname); 2198 return; 2199 } 2200 2201 wd->drv_ncq = true; 2202 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL, 2203 CTLFLAG_READWRITE, CTLTYPE_BOOL, "use_ncq", 2204 SYSCTL_DESCR("use NCQ if supported"), 2205 NULL, 0, &wd->drv_ncq, 0, 2206 CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL)) 2207 != 0) { 2208 aprint_error_dev(dksc->sc_dev, 2209 "could not create %s.%s.use_ncq sysctl - error %d\n", 2210 "hw", dksc->sc_xname, error); 2211 return; 2212 } 2213 2214 wd->drv_ncq_prio = false; 2215 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL, 2216 CTLFLAG_READWRITE, CTLTYPE_BOOL, "use_ncq_prio", 2217 SYSCTL_DESCR("use NCQ PRIORITY if supported"), 2218 NULL, 0, &wd->drv_ncq_prio, 0, 2219 CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL)) 2220 != 0) { 2221 aprint_error_dev(dksc->sc_dev, 2222 "could not create %s.%s.use_ncq_prio sysctl - error %d\n", 2223 "hw", dksc->sc_xname, error); 2224 return; 2225 } 2226 2227 #ifdef WD_CHAOS_MONKEY 2228 wd->drv_chaos_freq = 0; 2229 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL, 2230 CTLFLAG_READWRITE, CTLTYPE_INT, "chaos_freq", 2231 SYSCTL_DESCR("simulated bio read error rate"), 2232 NULL, 0, &wd->drv_chaos_freq, 0, 2233 CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL)) 2234 != 0) { 2235 aprint_error_dev(dksc->sc_dev, 2236 "could not create %s.%s.chaos_freq sysctl - error %d\n", 2237 "hw", dksc->sc_xname, error); 2238 return; 2239 } 2240 2241 wd->drv_chaos_cnt = 0; 2242 if ((error = sysctl_createv(&wd->nodelog, 0, NULL, NULL, 2243 CTLFLAG_READONLY, CTLTYPE_INT, "chaos_cnt", 2244 SYSCTL_DESCR("number of processed bio reads"), 2245 NULL, 0, &wd->drv_chaos_cnt, 0, 2246 CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL)) 2247 != 0) { 2248 aprint_error_dev(dksc->sc_dev, 2249 "could not create %s.%s.chaos_cnt sysctl - error %d\n", 2250 "hw", dksc->sc_xname, error); 2251 return; 2252 } 2253 #endif 2254 2255 } 2256 2257 static void 2258 wd_sysctl_detach(struct wd_softc *wd) 2259 { 2260 sysctl_teardown(&wd->nodelog); 2261 } 2262 2263 #ifdef ATADEBUG 2264 int wddebug(void); 2265 2266 int 2267 wddebug(void) 2268 { 2269 struct wd_softc *wd; 2270 struct dk_softc *dksc; 2271 int unit; 2272 2273 for (unit = 0; unit <= 3; unit++) { 2274 wd = device_lookup_private(&wd_cd, unit); 2275 if (wd == NULL) 2276 continue; 2277 dksc = &wd->sc_dksc; 2278 printf("%s fl %x bufq %p:\n", 2279 dksc->sc_xname, wd->sc_flags, bufq_peek(dksc->sc_bufq)); 2280 2281 atachannel_debug(wd->drvp->chnl_softc); 2282 } 2283 return 0; 2284 } 2285 #endif /* ATADEBUG */ 2286
Indexes created Mon Oct 20 11:09:49 GMT 2025