ofdisk.c revision 1.46
1 /* $NetBSD: ofdisk.c,v 1.46 2014/07/25 08:02:20 dholland Exp $ */ 2 3 /* 4 * Copyright (C) 1995, 1996 Wolfgang Solfrank. 5 * Copyright (C) 1995, 1996 TooLs GmbH. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by TooLs GmbH. 19 * 4. The name of TooLs GmbH may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 27 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 28 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 29 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 30 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 31 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: ofdisk.c,v 1.46 2014/07/25 08:02:20 dholland Exp $"); 36 37 #include <sys/param.h> 38 #include <sys/buf.h> 39 #include <sys/device.h> 40 #include <sys/conf.h> 41 #include <sys/disklabel.h> 42 #include <sys/disk.h> 43 #include <sys/fcntl.h> 44 #include <sys/ioctl.h> 45 #include <sys/stat.h> 46 #include <sys/systm.h> 47 #include <sys/proc.h> 48 49 #include <dev/ofw/openfirm.h> 50 51 struct ofdisk_softc { 52 device_t sc_dev; 53 int sc_phandle; 54 int sc_unit; 55 int sc_flags; 56 struct disk sc_dk; 57 int sc_ihandle; 58 u_long max_transfer; 59 }; 60 61 /* sc_flags */ 62 #define OFDF_ISFLOPPY 0x01 /* we are a floppy drive */ 63 64 #define OFDISK_FLOPPY_P(of) ((of)->sc_flags & OFDF_ISFLOPPY) 65 66 static int ofdisk_match (device_t, cfdata_t, void *); 67 static void ofdisk_attach (device_t, device_t, void *); 68 69 CFATTACH_DECL_NEW(ofdisk, sizeof(struct ofdisk_softc), 70 ofdisk_match, ofdisk_attach, NULL, NULL); 71 72 extern struct cfdriver ofdisk_cd; 73 74 dev_type_open(ofdisk_open); 75 dev_type_close(ofdisk_close); 76 dev_type_read(ofdisk_read); 77 dev_type_write(ofdisk_write); 78 dev_type_ioctl(ofdisk_ioctl); 79 dev_type_strategy(ofdisk_strategy); 80 dev_type_dump(ofdisk_dump); 81 dev_type_size(ofdisk_size); 82 83 const struct bdevsw ofdisk_bdevsw = { 84 .d_open = ofdisk_open, 85 .d_close = ofdisk_close, 86 .d_strategy = ofdisk_strategy, 87 .d_ioctl = ofdisk_ioctl, 88 .d_dump = ofdisk_dump, 89 .d_psize = ofdisk_size, 90 .d_discard = nodiscard, 91 .d_flag = D_DISK 92 }; 93 94 const struct cdevsw ofdisk_cdevsw = { 95 .d_open = ofdisk_open, 96 .d_close = ofdisk_close, 97 .d_read = ofdisk_read, 98 .d_write = ofdisk_write, 99 .d_ioctl = ofdisk_ioctl, 100 .d_stop = nostop, 101 .d_tty = notty, 102 .d_poll = nopoll, 103 .d_mmap = nommap, 104 .d_kqfilter = nokqfilter, 105 .d_flag = D_DISK 106 }; 107 108 static void ofminphys(struct buf *); 109 110 struct dkdriver ofdisk_dkdriver = { ofdisk_strategy, ofminphys }; 111 112 void ofdisk_getdefaultlabel (struct ofdisk_softc *, struct disklabel *); 113 void ofdisk_getdisklabel (dev_t); 114 115 static int 116 ofdisk_match(device_t parent, cfdata_t match, void *aux) 117 { 118 struct ofbus_attach_args *oba = aux; 119 char type[8]; 120 int l; 121 122 if (strcmp(oba->oba_busname, "ofw")) 123 return (0); 124 if ((l = OF_getprop(oba->oba_phandle, "device_type", type, 125 sizeof type - 1)) < 0) 126 return 0; 127 if (l >= sizeof type) 128 return 0; 129 type[l] = 0; 130 return !strcmp(type, "block"); 131 } 132 133 static void 134 ofdisk_attach(device_t parent, device_t self, void *aux) 135 { 136 struct ofdisk_softc *of = device_private(self); 137 struct ofbus_attach_args *oba = aux; 138 char child[64]; 139 int l; 140 141 of->sc_dev = self; 142 if ((l = OF_getprop(oba->oba_phandle, "name", child, 143 sizeof child - 1)) < 0) 144 panic("device without name?"); 145 if (l >= sizeof child) 146 l = sizeof child - 1; 147 child[l] = 0; 148 149 of->sc_flags = 0; 150 of->sc_phandle = oba->oba_phandle; 151 of->sc_unit = oba->oba_unit; 152 of->sc_ihandle = 0; 153 disk_init(&of->sc_dk, device_xname(of->sc_dev), &ofdisk_dkdriver); 154 disk_attach(&of->sc_dk); 155 printf("\n"); 156 157 if (strcmp(child, "floppy") == 0) 158 of->sc_flags |= OFDF_ISFLOPPY; 159 else { 160 /* Discover wedges on this disk. */ 161 dkwedge_discover(&of->sc_dk); 162 } 163 } 164 165 int 166 ofdisk_open(dev_t dev, int flags, int fmt, struct lwp *lwp) 167 { 168 struct ofdisk_softc *of; 169 char path[256]; 170 int error, l, part; 171 172 of = device_lookup_private(&ofdisk_cd, DISKUNIT(dev)); 173 if (of == NULL) 174 return ENXIO; 175 176 part = DISKPART(dev); 177 178 mutex_enter(&of->sc_dk.dk_openlock); 179 180 /* 181 * If there are wedges, and this is not RAW_PART, then we 182 * need to fail. 183 */ 184 if (of->sc_dk.dk_nwedges != 0 && part != RAW_PART) { 185 error = EBUSY; 186 goto bad1; 187 } 188 189 if (!of->sc_ihandle) { 190 if ((l = OF_package_to_path(of->sc_phandle, path, 191 sizeof path - 3)) < 0 || 192 l >= sizeof path - 3) { 193 error = ENXIO; 194 goto bad1; 195 } 196 path[l] = 0; 197 198 /* 199 * XXX This is for the benefit of SCSI/IDE disks that don't 200 * XXX have all their childs in the device tree. 201 * XXX YES, I DO THINK THIS IS A BUG IN OPENFIRMWARE!!! 202 * XXX And yes, this is a very gross hack! 203 * XXX See also ofscsi.c 204 */ 205 if (!strcmp(path + l - 4, "disk")) { 206 path[l++] = '@'; 207 path[l++] = '0' + of->sc_unit; 208 path[l] = 0; 209 } 210 211 strlcat(path, ":0", sizeof(path)); 212 213 if ((of->sc_ihandle = OF_open(path)) == -1) { 214 error = ENXIO; 215 goto bad1; 216 } 217 218 /* 219 * Try to get characteristics of the disk. 220 */ 221 of->max_transfer = OF_call_method_1("max-transfer", 222 of->sc_ihandle, 0); 223 if (of->max_transfer > MAXPHYS) 224 of->max_transfer = MAXPHYS; 225 226 ofdisk_getdisklabel(dev); 227 } 228 229 switch (fmt) { 230 case S_IFCHR: 231 of->sc_dk.dk_copenmask |= 1 << part; 232 break; 233 case S_IFBLK: 234 of->sc_dk.dk_bopenmask |= 1 << part; 235 break; 236 } 237 of->sc_dk.dk_openmask = 238 of->sc_dk.dk_copenmask | of->sc_dk.dk_bopenmask; 239 240 241 error = 0; 242 bad1: 243 mutex_exit(&of->sc_dk.dk_openlock); 244 return (error); 245 } 246 247 int 248 ofdisk_close(dev_t dev, int flags, int fmt, struct lwp *l) 249 { 250 struct ofdisk_softc *of = 251 device_lookup_private(&ofdisk_cd, DISKUNIT(dev)); 252 253 mutex_enter(&of->sc_dk.dk_openlock); 254 255 switch (fmt) { 256 case S_IFCHR: 257 of->sc_dk.dk_copenmask &= ~(1 << DISKPART(dev)); 258 break; 259 case S_IFBLK: 260 of->sc_dk.dk_bopenmask &= ~(1 << DISKPART(dev)); 261 break; 262 } 263 of->sc_dk.dk_openmask = of->sc_dk.dk_copenmask | of->sc_dk.dk_bopenmask; 264 265 #ifdef FIRMWORKSBUGS 266 /* 267 * This is a hack to get the firmware to flush its buffers. 268 */ 269 OF_seek(of->sc_ihandle, 0); 270 #endif 271 if (!of->sc_dk.dk_openmask) { 272 OF_close(of->sc_ihandle); 273 of->sc_ihandle = 0; 274 } 275 276 mutex_exit(&of->sc_dk.dk_openlock); 277 return 0; 278 } 279 280 void 281 ofdisk_strategy(struct buf *bp) 282 { 283 struct ofdisk_softc *of = 284 device_lookup_private(&ofdisk_cd, DISKUNIT(bp->b_dev)); 285 struct partition *p; 286 u_quad_t off; 287 int read; 288 int (*OF_io)(int, void *, int); 289 daddr_t blkno = bp->b_blkno; 290 291 bp->b_resid = 0; 292 if (bp->b_bcount == 0) 293 goto done; 294 295 OF_io = bp->b_flags & B_READ ? OF_read : 296 (int(*)(int, void*, int))OF_write; 297 298 if (DISKPART(bp->b_dev) != RAW_PART) { 299 if (bounds_check_with_label(&of->sc_dk, bp, 0) <= 0) { 300 bp->b_resid = bp->b_bcount; 301 goto done; 302 } 303 p = &of->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)]; 304 blkno = bp->b_blkno + p->p_offset; 305 } 306 307 disk_busy(&of->sc_dk); 308 309 off = (u_quad_t)blkno * DEV_BSIZE; 310 read = -1; 311 do { 312 if (OF_seek(of->sc_ihandle, off) < 0) 313 break; 314 read = OF_io(of->sc_ihandle, bp->b_data, bp->b_bcount); 315 } while (read == -2); 316 317 if (read < 0) { 318 bp->b_error = EIO; 319 bp->b_resid = bp->b_bcount; 320 } else 321 bp->b_resid = bp->b_bcount - read; 322 323 disk_unbusy(&of->sc_dk, bp->b_bcount - bp->b_resid, 324 (bp->b_flags & B_READ)); 325 326 done: 327 biodone(bp); 328 } 329 330 static void 331 ofminphys(struct buf *bp) 332 { 333 struct ofdisk_softc *of = 334 device_lookup_private(&ofdisk_cd, DISKUNIT(bp->b_dev)); 335 336 if (bp->b_bcount > of->max_transfer) 337 bp->b_bcount = of->max_transfer; 338 } 339 340 int 341 ofdisk_read(dev_t dev, struct uio *uio, int flags) 342 { 343 return physio(ofdisk_strategy, NULL, dev, B_READ, ofminphys, uio); 344 } 345 346 int 347 ofdisk_write(dev_t dev, struct uio *uio, int flags) 348 { 349 return physio(ofdisk_strategy, NULL, dev, B_WRITE, ofminphys, uio); 350 } 351 352 int 353 ofdisk_ioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 354 { 355 struct ofdisk_softc *of = 356 device_lookup_private(&ofdisk_cd, DISKUNIT(dev)); 357 int error; 358 #ifdef __HAVE_OLD_DISKLABEL 359 struct disklabel newlabel; 360 #endif 361 362 switch (cmd) { 363 case DIOCGDINFO: 364 *(struct disklabel *)data = *of->sc_dk.dk_label; 365 return 0; 366 #ifdef __HAVE_OLD_DISKLABEL 367 case ODIOCGDINFO: 368 newlabel = *of->sc_dk.dk_label; 369 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 370 return ENOTTY; 371 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 372 return 0; 373 #endif 374 375 case DIOCGPART: 376 ((struct partinfo *)data)->disklab = of->sc_dk.dk_label; 377 ((struct partinfo *)data)->part = 378 &of->sc_dk.dk_label->d_partitions[DISKPART(dev)]; 379 return 0; 380 381 case DIOCWDINFO: 382 case DIOCSDINFO: 383 #ifdef __HAVE_OLD_DISKLABEL 384 case ODIOCWDINFO: 385 case ODIOCSDINFO: 386 #endif 387 { 388 struct disklabel *lp; 389 390 #ifdef __HAVE_OLD_DISKLABEL 391 if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) { 392 memset(&newlabel, 0, sizeof newlabel); 393 memcpy(&newlabel, data, sizeof (struct olddisklabel)); 394 lp = &newlabel; 395 } else 396 #endif 397 lp = (struct disklabel *)data; 398 399 if ((flag & FWRITE) == 0) 400 return EBADF; 401 402 mutex_enter(&of->sc_dk.dk_openlock); 403 404 error = setdisklabel(of->sc_dk.dk_label, 405 lp, /*of->sc_dk.dk_openmask */0, 406 of->sc_dk.dk_cpulabel); 407 if (error == 0 && cmd == DIOCWDINFO 408 #ifdef __HAVE_OLD_DISKLABEL 409 || xfer == ODIOCWDINFO 410 #endif 411 ) 412 error = writedisklabel(MAKEDISKDEV(major(dev), 413 DISKUNIT(dev), RAW_PART), ofdisk_strategy, 414 of->sc_dk.dk_label, of->sc_dk.dk_cpulabel); 415 416 mutex_exit(&of->sc_dk.dk_openlock); 417 418 return error; 419 } 420 421 case DIOCGDEFLABEL: 422 ofdisk_getdefaultlabel(of, (struct disklabel *)data); 423 return 0; 424 #ifdef __HAVE_OLD_DISKLABEL 425 case DIOCGDEFLABEL: 426 ofdisk_getdefaultlabel(of, &newlabel); 427 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 428 return ENOTTY; 429 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 430 return 0; 431 #endif 432 433 case DIOCAWEDGE: 434 { 435 struct dkwedge_info *dkw = (void *) data; 436 437 if (OFDISK_FLOPPY_P(of)) 438 return (ENOTTY); 439 440 if ((flag & FWRITE) == 0) 441 return (EBADF); 442 443 /* If the ioctl happens here, the parent is us. */ 444 strlcpy(dkw->dkw_parent, device_xname(of->sc_dev), 445 sizeof(dkw->dkw_parent)); 446 return (dkwedge_add(dkw)); 447 } 448 449 case DIOCDWEDGE: 450 { 451 struct dkwedge_info *dkw = (void *) data; 452 453 if (OFDISK_FLOPPY_P(of)) 454 return (ENOTTY); 455 456 if ((flag & FWRITE) == 0) 457 return (EBADF); 458 459 /* If the ioctl happens here, the parent is us. */ 460 strlcpy(dkw->dkw_parent, device_xname(of->sc_dev), 461 sizeof(dkw->dkw_parent)); 462 return (dkwedge_del(dkw)); 463 } 464 465 case DIOCLWEDGES: 466 { 467 struct dkwedge_list *dkwl = (void *) data; 468 469 if (OFDISK_FLOPPY_P(of)) 470 return (ENOTTY); 471 472 return (dkwedge_list(&of->sc_dk, dkwl, l)); 473 } 474 475 default: 476 return ENOTTY; 477 } 478 } 479 480 int 481 ofdisk_dump(dev_t dev, daddr_t blkno, void *va, size_t size) 482 { 483 return EINVAL; 484 } 485 486 int 487 ofdisk_size(dev_t dev) 488 { 489 struct ofdisk_softc *of; 490 struct disklabel *lp; 491 int size, part, omask; 492 493 of = device_lookup_private(&ofdisk_cd, DISKUNIT(dev)); 494 if (of == NULL) 495 return ENXIO; 496 497 part = DISKPART(dev); 498 omask = of->sc_dk.dk_openmask & (1 << part); 499 lp = of->sc_dk.dk_label; 500 501 if (omask == 0 && ofdisk_open(dev, 0, S_IFBLK, curlwp) != 0) 502 return -1; 503 504 if (lp->d_partitions[part].p_fstype != FS_SWAP) 505 size = -1; 506 else 507 size = lp->d_partitions[part].p_size * 508 (lp->d_secsize / DEV_BSIZE); 509 510 if (omask == 0 && ofdisk_close(dev, 0, S_IFBLK, curlwp) != 0) 511 return -1; 512 513 return size; 514 } 515 516 void 517 ofdisk_getdefaultlabel(struct ofdisk_softc *of, struct disklabel *lp) 518 { 519 520 memset(lp, 0, sizeof *lp); 521 522 /* 523 * XXX Firmware bug? Asking for block size gives a 524 * XXX ridiculous number! So we use what the boot program 525 * XXX uses. 526 */ 527 lp->d_secsize = DEV_BSIZE; 528 529 lp->d_secperunit = OF_call_method_1("#blocks", 530 of->sc_ihandle, 0); 531 if (lp->d_secperunit == (u_int32_t)-1) 532 lp->d_secperunit = 0x7fffffff; 533 534 lp->d_secpercyl = 1; 535 lp->d_nsectors = 1; 536 lp->d_ntracks = 1; 537 lp->d_ncylinders = lp->d_secperunit; 538 539 lp->d_partitions[RAW_PART].p_offset = 0; 540 lp->d_partitions[RAW_PART].p_size = lp->d_secperunit; 541 lp->d_npartitions = RAW_PART + 1; 542 543 lp->d_magic = DISKMAGIC; 544 lp->d_magic2 = DISKMAGIC; 545 lp->d_checksum = dkcksum(lp); 546 } 547 548 void 549 ofdisk_getdisklabel(dev_t dev) 550 { 551 int unit = DISKUNIT(dev); 552 struct ofdisk_softc *of = 553 device_lookup_private(&ofdisk_cd, unit); 554 struct disklabel *lp = of->sc_dk.dk_label; 555 const char *errmes; 556 int l; 557 558 ofdisk_getdefaultlabel(of, lp); 559 560 /* 561 * Don't read the disklabel on a floppy; simply 562 * assign all partitions the same size/offset as 563 * RAW_PART. (This is essentially what the ISA 564 * floppy driver does, but we don't deal with 565 * density stuff.) 566 */ 567 if (OFDISK_FLOPPY_P(of)) { 568 lp->d_npartitions = MAXPARTITIONS; 569 for (l = 0; l < lp->d_npartitions; l++) { 570 if (l == RAW_PART) 571 continue; 572 /* struct copy */ 573 lp->d_partitions[l] = 574 lp->d_partitions[RAW_PART]; 575 } 576 lp->d_checksum = dkcksum(lp); 577 } else { 578 errmes = readdisklabel(MAKEDISKDEV(major(dev), 579 unit, RAW_PART), ofdisk_strategy, lp, 580 of->sc_dk.dk_cpulabel); 581 if (errmes != NULL) 582 printf("%s: %s\n", device_xname(of->sc_dev), errmes); 583 } 584 } 585
Indexes created Mon Sep 22 10:09:38 GMT 2025