1 /* $NetBSD: dsk.c,v 1.19 2022/04/30 03:52:41 rin Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Tohru Nishimura. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * assumptions; 34 * - up to 4 IDE/SATA drives. 35 * - a single (master) drive in each IDE channel. 36 * - all drives are up and spinning. 37 */ 38 39 #include <sys/types.h> 40 41 #include <lib/libsa/stand.h> 42 #include <lib/libsa/ufs.h> 43 44 #include <sys/disklabel.h> 45 #include <sys/bootblock.h> 46 #include <sys/param.h> 47 48 #include <dev/raidframe/raidframevar.h> 49 50 #include <machine/bootinfo.h> 51 52 #include "globals.h" 53 54 /* 55 * - no vtophys() translation, vaddr_t == paddr_t. 56 */ 57 #define CSR_READ_4(r) in32rb(r) 58 #define CSR_WRITE_4(r,v) out32rb(r,v) 59 #define CSR_READ_1(r) in8(r) 60 #define CSR_WRITE_1(r,v) out8(r,v) 61 62 struct dskdv { 63 char *name; 64 int (*match)(unsigned, void *); 65 void *(*init)(unsigned, void *); 66 }; 67 68 static struct dskdv ldskdv[] = { 69 { "pciide", pciide_match, pciide_init }, 70 { "siisata", siisata_match, siisata_init }, 71 }; 72 static int ndskdv = sizeof(ldskdv)/sizeof(ldskdv[0]); 73 74 static void disk_scan(void *); 75 static int probe_drive(struct dkdev_ata *, int); 76 static void drive_ident(struct disk *, char *); 77 static char *mkident(char *, int); 78 static void set_xfermode(struct dkdev_ata *, int); 79 static void decode_dlabel(struct disk *, char *); 80 static struct disklabel *search_dmagic(char *); 81 static int lba_read(struct disk *, int64_t, int, void *); 82 static void issue48(struct dvata_chan *, int64_t, int); 83 static void issue28(struct dvata_chan *, int64_t, int); 84 static struct disk *lookup_disk(int); 85 86 static struct disk ldisk[MAX_UNITS]; 87 88 int 89 dskdv_init(void *self) 90 { 91 struct pcidev *pci = self; 92 struct dskdv *dv; 93 unsigned tag; 94 int n; 95 96 tag = pci->bdf; 97 for (n = 0; n < ndskdv; n++) { 98 dv = &ldskdv[n]; 99 if ((*dv->match)(tag, NULL) > 0) 100 goto found; 101 } 102 return 0; 103 found: 104 pci->drv = (*dv->init)(tag, NULL); 105 if (pci->drv == NULL) 106 return 0; 107 disk_scan(pci->drv); 108 return 1; 109 } 110 111 static void 112 disk_scan(void *drv) 113 { 114 struct dkdev_ata *l = drv; 115 struct disk *d; 116 static int ndrive = 0; 117 int n; 118 119 for (n = 0; n < 4 && ndrive < MAX_UNITS; n++) { 120 if (l->presense[n] == 0) 121 continue; 122 if (probe_drive(l, n) == 0) { 123 l->presense[n] = 0; 124 continue; 125 } 126 d = &ldisk[ndrive]; 127 d->dvops = l; 128 d->unitchan = n; 129 d->unittag = ndrive; 130 snprintf(d->xname, sizeof(d->xname), "wd%d", d->unittag); 131 set_xfermode(l, n); 132 drive_ident(d, l->iobuf); 133 decode_dlabel(d, l->iobuf); 134 ndrive += 1; 135 } 136 } 137 138 int 139 spinwait_unbusy(struct dkdev_ata *l, int n, int milli, const char **err) 140 { 141 struct dvata_chan *chan = &l->chan[n]; 142 int sts; 143 const char *msg; 144 145 /* 146 * For best compatibility it is recommended to wait 400ns and 147 * read the alternate status byte four times before the status 148 * is valid. 149 */ 150 delay(1); 151 (void)CSR_READ_1(chan->alt); 152 (void)CSR_READ_1(chan->alt); 153 (void)CSR_READ_1(chan->alt); 154 (void)CSR_READ_1(chan->alt); 155 156 sts = CSR_READ_1(chan->cmd + _STS); 157 while (milli-- > 0 158 && sts != 0xff 159 && (sts & (ATA_STS_BUSY|ATA_STS_DRDY)) != ATA_STS_DRDY) { 160 delay(1000); 161 sts = CSR_READ_1(chan->cmd + _STS); 162 } 163 164 msg = NULL; 165 if (sts == 0xff) 166 msg = "returned 0xff"; 167 else if (sts & ATA_STS_ERR) 168 msg = "returned ERR"; 169 else if (sts & ATA_STS_BUSY) 170 msg = "remains BUSY"; 171 else if ((sts & ATA_STS_DRDY) == 0) 172 msg = "no DRDY"; 173 174 if (err != NULL) 175 *err = msg; 176 return msg == NULL; 177 } 178 179 int 180 perform_atareset(struct dkdev_ata *l, int n) 181 { 182 struct dvata_chan *chan = &l->chan[n]; 183 184 CSR_WRITE_1(chan->ctl, ATA_DREQ); 185 delay(10); 186 CSR_WRITE_1(chan->ctl, ATA_SRST|ATA_DREQ); 187 delay(10); 188 CSR_WRITE_1(chan->ctl, ATA_DREQ); 189 190 return spinwait_unbusy(l, n, 1000, NULL); 191 } 192 193 /* clear idle and standby timers to spin up the drive */ 194 void 195 wakeup_drive(struct dkdev_ata *l, int n) 196 { 197 struct dvata_chan *chan = &l->chan[n]; 198 199 CSR_WRITE_1(chan->cmd + _NSECT, 0); 200 CSR_WRITE_1(chan->cmd + _CMD, ATA_CMD_IDLE); 201 (void)CSR_READ_1(chan->alt); 202 delay(10 * 1000); 203 CSR_WRITE_1(chan->cmd + _NSECT, 0); 204 CSR_WRITE_1(chan->cmd + _CMD, ATA_CMD_STANDBY); 205 (void)CSR_READ_1(chan->alt); 206 delay(10 * 1000); 207 } 208 209 int 210 atachkpwr(struct dkdev_ata *l, int n) 211 { 212 struct dvata_chan *chan = &l->chan[n]; 213 214 CSR_WRITE_1(chan->cmd + _CMD, ATA_CMD_CHKPWR); 215 (void)CSR_READ_1(chan->alt); 216 delay(10 * 1000); 217 return CSR_READ_1(chan->cmd + _NSECT); 218 } 219 220 static int 221 probe_drive(struct dkdev_ata *l, int n) 222 { 223 struct dvata_chan *chan = &l->chan[n]; 224 uint16_t *p; 225 int i; 226 227 CSR_WRITE_1(chan->cmd + _CMD, ATA_CMD_IDENT); 228 (void)CSR_READ_1(chan->alt); 229 delay(10 * 1000); 230 if (spinwait_unbusy(l, n, 1000, NULL) == 0) 231 return 0; 232 233 p = (uint16_t *)l->iobuf; 234 for (i = 0; i < 512; i += 2) { 235 /* need to have bswap16 */ 236 *p++ = iole16toh(chan->cmd + _DAT); 237 } 238 (void)CSR_READ_1(chan->cmd + _STS); 239 return 1; 240 } 241 242 static void 243 drive_ident(struct disk *d, char *ident) 244 { 245 uint16_t *p; 246 uint64_t huge; 247 248 p = (uint16_t *)ident; 249 DPRINTF(("[49]%04x [82]%04x [83]%04x [84]%04x " 250 "[85]%04x [86]%04x [87]%04x [88]%04x\n", 251 p[49], p[82], p[83], p[84], 252 p[85], p[86], p[87], p[88])); 253 huge = 0; 254 printf("%s: ", d->xname); 255 printf("<%s> ", mkident((char *)ident + 54, 40)); 256 if (p[49] & (1 << 8)) 257 printf("DMA "); 258 if (p[49] & (1 << 9)) { 259 printf("LBA "); 260 huge = p[60] | (p[61] << 16); 261 } 262 if ((p[83] & 0xc000) == 0x4000 && (p[83] & (1 << 10))) { 263 printf("LBA48 "); 264 huge = p[100] | (p[101] << 16); 265 huge |= (uint64_t)p[102] << 32; 266 huge |= (uint64_t)p[103] << 48; 267 } 268 huge >>= (1 + 10); 269 printf("%d MB\n", (int)huge); 270 271 memcpy(d->ident, ident, sizeof(d->ident)); 272 d->nsect = huge; 273 d->lba_read = lba_read; 274 } 275 276 static char * 277 mkident(char *src, int len) 278 { 279 static char local[40]; 280 char *dst, *end, *last; 281 282 if (len > sizeof(local)) 283 len = sizeof(local); 284 dst = last = local; 285 end = src + len - 1; 286 287 /* reserve space for '\0' */ 288 if (len < 2) 289 goto out; 290 /* skip leading white space */ 291 while (*src != '\0' && src < end && *src == ' ') 292 ++src; 293 /* copy string, omitting trailing white space */ 294 while (*src != '\0' && src < end) { 295 *dst++ = *src; 296 if (*src++ != ' ') 297 last = dst; 298 } 299 out: 300 *last = '\0'; 301 return local; 302 } 303 304 static void 305 decode_dlabel(struct disk *d, char *iobuf) 306 { 307 struct mbr_partition *mp, *bsdp; 308 struct disklabel *dlp; 309 struct partition *pp; 310 int i, first, rf_offset; 311 312 bsdp = NULL; 313 (*d->lba_read)(d, 0, 1, iobuf); 314 if (bswap16(*(uint16_t *)(iobuf + MBR_MAGIC_OFFSET)) != MBR_MAGIC) 315 goto skip; 316 mp = (struct mbr_partition *)(iobuf + MBR_PART_OFFSET); 317 for (i = 0; i < MBR_PART_COUNT; i++, mp++) { 318 if (mp->mbrp_type == MBR_PTYPE_NETBSD) { 319 bsdp = mp; 320 break; 321 } 322 } 323 skip: 324 rf_offset = 0; 325 first = (bsdp) ? bswap32(bsdp->mbrp_start) : 0; 326 (*d->lba_read)(d, first + LABELSECTOR, 1, iobuf); 327 dlp = search_dmagic(iobuf); 328 if (dlp == NULL) 329 goto notfound; 330 if (dlp->d_partitions[0].p_fstype == FS_RAID) { 331 printf("%s%c: raid\n", d->xname, 0 + 'a'); 332 snprintf(d->xname, sizeof(d->xname), "raid."); 333 rf_offset 334 = dlp->d_partitions[0].p_offset + RF_PROTECTED_SECTORS; 335 (*d->lba_read)(d, rf_offset + LABELSECTOR, 1, iobuf); 336 dlp = search_dmagic(iobuf); 337 if (dlp == NULL) 338 goto notfound; 339 } 340 for (i = 0; i < dlp->d_npartitions; i += 1) { 341 const char *type; 342 pp = &dlp->d_partitions[i]; 343 pp->p_offset += rf_offset; 344 type = NULL; 345 switch (pp->p_fstype) { 346 case FS_SWAP: 347 type = "swap"; 348 break; 349 case FS_BSDFFS: 350 type = "ffs"; 351 break; 352 case FS_EX2FS: 353 type = "ext2fs"; 354 break; 355 } 356 if (type != NULL) 357 printf("%s%c: %s\t(%u)\n", d->xname, i + 'a', type, 358 pp->p_offset); 359 } 360 d->dlabel = allocaligned(sizeof(struct disklabel), 4); 361 memcpy(d->dlabel, dlp, sizeof(struct disklabel)); 362 return; 363 notfound: 364 d->dlabel = NULL; 365 printf("%s: no disklabel\n", d->xname); 366 return; 367 } 368 369 struct disklabel * 370 search_dmagic(char *dp) 371 { 372 int i; 373 struct disklabel *dlp; 374 375 for (i = 0; i < 512 - sizeof(struct disklabel); i += 4, dp += 4) { 376 dlp = (struct disklabel *)dp; 377 if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC) 378 return dlp; 379 } 380 return NULL; 381 } 382 383 static void 384 set_xfermode(struct dkdev_ata *l, int n) 385 { 386 struct dvata_chan *chan = &l->chan[n]; 387 388 CSR_WRITE_1(chan->cmd + _FEA, ATA_XFER); 389 CSR_WRITE_1(chan->cmd + _NSECT, XFER_PIO0); 390 CSR_WRITE_1(chan->cmd + _DEV, ATA_DEV_OBS); /* ??? */ 391 CSR_WRITE_1(chan->cmd + _CMD, ATA_CMD_SETF); 392 393 spinwait_unbusy(l, n, 1000, NULL); 394 } 395 396 static int 397 lba_read(struct disk *d, int64_t bno, int bcnt, void *buf) 398 { 399 struct dkdev_ata *l; 400 struct dvata_chan *chan; 401 void (*issue)(struct dvata_chan *, int64_t, int); 402 int n, rdcnt, i, k; 403 uint16_t *p; 404 const char *err; 405 int error; 406 407 l = d->dvops; 408 n = d->unitchan; 409 p = (uint16_t *)buf; 410 chan = &l->chan[n]; 411 error = 0; 412 for ( ; bcnt > 0; bno += rdcnt, bcnt -= rdcnt) { 413 issue = (bno < (1ULL<<28)) ? issue28 : issue48; 414 rdcnt = (bcnt > 255) ? 255 : bcnt; 415 (*issue)(chan, bno, rdcnt); 416 for (k = 0; k < rdcnt; k++) { 417 if (spinwait_unbusy(l, n, 1000, &err) == 0) { 418 printf("%s blk %u %s\n", 419 d->xname, (unsigned)bno, err); 420 error = EIO; 421 break; 422 } 423 for (i = 0; i < 512; i += 2) { 424 /* arrives in native order */ 425 *p++ = *(uint16_t *)(chan->cmd + _DAT); 426 } 427 /* clear irq if any */ 428 (void)CSR_READ_1(chan->cmd + _STS); 429 } 430 } 431 return error; 432 } 433 434 static void 435 issue48(struct dvata_chan *chan, int64_t bno, int nblk) 436 { 437 438 CSR_WRITE_1(chan->cmd + _NSECT, 0); /* always less than 256 */ 439 CSR_WRITE_1(chan->cmd + _LBAL, (bno >> 24) & 0xff); 440 CSR_WRITE_1(chan->cmd + _LBAM, (bno >> 32) & 0xff); 441 CSR_WRITE_1(chan->cmd + _LBAH, (bno >> 40) & 0xff); 442 CSR_WRITE_1(chan->cmd + _NSECT, nblk); 443 CSR_WRITE_1(chan->cmd + _LBAL, (bno >> 0) & 0xff); 444 CSR_WRITE_1(chan->cmd + _LBAM, (bno >> 8) & 0xff); 445 CSR_WRITE_1(chan->cmd + _LBAH, (bno >> 16) & 0xff); 446 CSR_WRITE_1(chan->cmd + _DEV, ATA_DEV_LBA); 447 CSR_WRITE_1(chan->cmd + _CMD, ATA_CMD_READ_EXT); 448 } 449 450 static void 451 issue28(struct dvata_chan *chan, int64_t bno, int nblk) 452 { 453 454 CSR_WRITE_1(chan->cmd + _NSECT, nblk); 455 CSR_WRITE_1(chan->cmd + _LBAL, (bno >> 0) & 0xff); 456 CSR_WRITE_1(chan->cmd + _LBAM, (bno >> 8) & 0xff); 457 CSR_WRITE_1(chan->cmd + _LBAH, (bno >> 16) & 0xff); 458 CSR_WRITE_1(chan->cmd + _DEV, ((bno >> 24) & 0xf) | ATA_DEV_LBA); 459 CSR_WRITE_1(chan->cmd + _CMD, ATA_CMD_READ); 460 } 461 462 static struct disk * 463 lookup_disk(int unit) 464 { 465 466 return (unit >= 0 && unit < MAX_UNITS) ? &ldisk[unit] : NULL; 467 } 468 469 int 470 dlabel_valid(int unit) 471 { 472 struct disk *dsk; 473 474 dsk = lookup_disk(unit); 475 if (dsk == NULL) 476 return 0; 477 return dsk->dlabel != NULL; 478 } 479 480 int 481 dsk_open(struct open_file *f, ...) 482 { 483 va_list ap; 484 int unit, part; 485 const char *name; 486 struct disk *d; 487 struct disklabel *dlp; 488 struct fs_ops *fs; 489 int error; 490 extern struct btinfo_bootpath bi_path; 491 extern struct btinfo_rootdevice bi_rdev; 492 extern struct fs_ops fs_ffsv2, fs_ffsv1; 493 494 va_start(ap, f); 495 unit = va_arg(ap, int); 496 part = va_arg(ap, int); 497 name = va_arg(ap, const char *); 498 va_end(ap); 499 500 if ((d = lookup_disk(unit)) == NULL) 501 return ENXIO; 502 if ((dlp = d->dlabel) == NULL || part >= dlp->d_npartitions) 503 return ENXIO; 504 d->part = part; 505 f->f_devdata = d; 506 507 snprintf(bi_path.bootpath, sizeof(bi_path.bootpath), "%s", name); 508 if (dlp->d_partitions[part].p_fstype == FS_BSDFFS) { 509 if ((error = ffsv2_open(name, f)) == 0) { 510 fs = &fs_ffsv2; 511 goto found; 512 } 513 if (error == EINVAL && (error = ffsv1_open(name, f)) == 0) { 514 fs = &fs_ffsv1; 515 goto found; 516 } 517 return error; 518 } 519 return ENXIO; 520 found: 521 d->fsops = fs; 522 f->f_devdata = d; 523 524 /* build btinfo to identify disk device */ 525 snprintf(bi_rdev.devname, sizeof(bi_rdev.devname), "wd"); 526 bi_rdev.cookie = (d->unittag << 8) | d->part; 527 return 0; 528 } 529 530 int 531 dsk_close(struct open_file *f) 532 { 533 struct disk *d = f->f_devdata; 534 struct fs_ops *fs = d->fsops; 535 536 (*fs->close)(f); 537 d->fsops = NULL; 538 f->f_devdata = NULL; 539 return 0; 540 } 541 542 int 543 dsk_strategy(void *devdata, int rw, daddr_t dblk, size_t size, 544 void *p, size_t *rsize) 545 { 546 struct disk *d = devdata; 547 struct disklabel *dlp; 548 int64_t bno; 549 550 if (size == 0) 551 return 0; 552 if (rw != F_READ) 553 return EOPNOTSUPP; 554 555 bno = dblk; 556 if ((dlp = d->dlabel) != NULL) 557 bno += dlp->d_partitions[d->part].p_offset; 558 (*d->lba_read)(d, bno, size / 512, p); 559 if (rsize != NULL) 560 *rsize = size; 561 return 0; 562 } 563 564 struct fs_ops * 565 dsk_fsops(struct open_file *f) 566 { 567 struct disk *d = f->f_devdata; 568 569 return d->fsops; 570 } 571
Indexes created Sat Sep 20 22:09:52 GMT 2025