ofdisk.c revision 1.45
1 /* $NetBSD: ofdisk.c,v 1.45 2014/03/16 05:20:28 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.45 2014/03/16 05:20:28 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_flag = D_DISK 91 }; 92 93 const struct cdevsw ofdisk_cdevsw = { 94 .d_open = ofdisk_open, 95 .d_close = ofdisk_close, 96 .d_read = ofdisk_read, 97 .d_write = ofdisk_write, 98 .d_ioctl = ofdisk_ioctl, 99 .d_stop = nostop, 100 .d_tty = notty, 101 .d_poll = nopoll, 102 .d_mmap = nommap, 103 .d_kqfilter = nokqfilter, 104 .d_flag = D_DISK 105 }; 106 107 static void ofminphys(struct buf *); 108 109 struct dkdriver ofdisk_dkdriver = { ofdisk_strategy, ofminphys }; 110 111 void ofdisk_getdefaultlabel (struct ofdisk_softc *, struct disklabel *); 112 void ofdisk_getdisklabel (dev_t); 113 114 static int 115 ofdisk_match(device_t parent, cfdata_t match, void *aux) 116 { 117 struct ofbus_attach_args *oba = aux; 118 char type[8]; 119 int l; 120 121 if (strcmp(oba->oba_busname, "ofw")) 122 return (0); 123 if ((l = OF_getprop(oba->oba_phandle, "device_type", type, 124 sizeof type - 1)) < 0) 125 return 0; 126 if (l >= sizeof type) 127 return 0; 128 type[l] = 0; 129 return !strcmp(type, "block"); 130 } 131 132 static void 133 ofdisk_attach(device_t parent, device_t self, void *aux) 134 { 135 struct ofdisk_softc *of = device_private(self); 136 struct ofbus_attach_args *oba = aux; 137 char child[64]; 138 int l; 139 140 of->sc_dev = self; 141 if ((l = OF_getprop(oba->oba_phandle, "name", child, 142 sizeof child - 1)) < 0) 143 panic("device without name?"); 144 if (l >= sizeof child) 145 l = sizeof child - 1; 146 child[l] = 0; 147 148 of->sc_flags = 0; 149 of->sc_phandle = oba->oba_phandle; 150 of->sc_unit = oba->oba_unit; 151 of->sc_ihandle = 0; 152 disk_init(&of->sc_dk, device_xname(of->sc_dev), &ofdisk_dkdriver); 153 disk_attach(&of->sc_dk); 154 printf("\n"); 155 156 if (strcmp(child, "floppy") == 0) 157 of->sc_flags |= OFDF_ISFLOPPY; 158 else { 159 /* Discover wedges on this disk. */ 160 dkwedge_discover(&of->sc_dk); 161 } 162 } 163 164 int 165 ofdisk_open(dev_t dev, int flags, int fmt, struct lwp *lwp) 166 { 167 struct ofdisk_softc *of; 168 char path[256]; 169 int error, l, part; 170 171 of = device_lookup_private(&ofdisk_cd, DISKUNIT(dev)); 172 if (of == NULL) 173 return ENXIO; 174 175 part = DISKPART(dev); 176 177 mutex_enter(&of->sc_dk.dk_openlock); 178 179 /* 180 * If there are wedges, and this is not RAW_PART, then we 181 * need to fail. 182 */ 183 if (of->sc_dk.dk_nwedges != 0 && part != RAW_PART) { 184 error = EBUSY; 185 goto bad1; 186 } 187 188 if (!of->sc_ihandle) { 189 if ((l = OF_package_to_path(of->sc_phandle, path, 190 sizeof path - 3)) < 0 || 191 l >= sizeof path - 3) { 192 error = ENXIO; 193 goto bad1; 194 } 195 path[l] = 0; 196 197 /* 198 * XXX This is for the benefit of SCSI/IDE disks that don't 199 * XXX have all their childs in the device tree. 200 * XXX YES, I DO THINK THIS IS A BUG IN OPENFIRMWARE!!! 201 * XXX And yes, this is a very gross hack! 202 * XXX See also ofscsi.c 203 */ 204 if (!strcmp(path + l - 4, "disk")) { 205 path[l++] = '@'; 206 path[l++] = '0' + of->sc_unit; 207 path[l] = 0; 208 } 209 210 strlcat(path, ":0", sizeof(path)); 211 212 if ((of->sc_ihandle = OF_open(path)) == -1) { 213 error = ENXIO; 214 goto bad1; 215 } 216 217 /* 218 * Try to get characteristics of the disk. 219 */ 220 of->max_transfer = OF_call_method_1("max-transfer", 221 of->sc_ihandle, 0); 222 if (of->max_transfer > MAXPHYS) 223 of->max_transfer = MAXPHYS; 224 225 ofdisk_getdisklabel(dev); 226 } 227 228 switch (fmt) { 229 case S_IFCHR: 230 of->sc_dk.dk_copenmask |= 1 << part; 231 break; 232 case S_IFBLK: 233 of->sc_dk.dk_bopenmask |= 1 << part; 234 break; 235 } 236 of->sc_dk.dk_openmask = 237 of->sc_dk.dk_copenmask | of->sc_dk.dk_bopenmask; 238 239 240 error = 0; 241 bad1: 242 mutex_exit(&of->sc_dk.dk_openlock); 243 return (error); 244 } 245 246 int 247 ofdisk_close(dev_t dev, int flags, int fmt, struct lwp *l) 248 { 249 struct ofdisk_softc *of = 250 device_lookup_private(&ofdisk_cd, DISKUNIT(dev)); 251 252 mutex_enter(&of->sc_dk.dk_openlock); 253 254 switch (fmt) { 255 case S_IFCHR: 256 of->sc_dk.dk_copenmask &= ~(1 << DISKPART(dev)); 257 break; 258 case S_IFBLK: 259 of->sc_dk.dk_bopenmask &= ~(1 << DISKPART(dev)); 260 break; 261 } 262 of->sc_dk.dk_openmask = of->sc_dk.dk_copenmask | of->sc_dk.dk_bopenmask; 263 264 #ifdef FIRMWORKSBUGS 265 /* 266 * This is a hack to get the firmware to flush its buffers. 267 */ 268 OF_seek(of->sc_ihandle, 0); 269 #endif 270 if (!of->sc_dk.dk_openmask) { 271 OF_close(of->sc_ihandle); 272 of->sc_ihandle = 0; 273 } 274 275 mutex_exit(&of->sc_dk.dk_openlock); 276 return 0; 277 } 278 279 void 280 ofdisk_strategy(struct buf *bp) 281 { 282 struct ofdisk_softc *of = 283 device_lookup_private(&ofdisk_cd, DISKUNIT(bp->b_dev)); 284 struct partition *p; 285 u_quad_t off; 286 int read; 287 int (*OF_io)(int, void *, int); 288 daddr_t blkno = bp->b_blkno; 289 290 bp->b_resid = 0; 291 if (bp->b_bcount == 0) 292 goto done; 293 294 OF_io = bp->b_flags & B_READ ? OF_read : 295 (int(*)(int, void*, int))OF_write; 296 297 if (DISKPART(bp->b_dev) != RAW_PART) { 298 if (bounds_check_with_label(&of->sc_dk, bp, 0) <= 0) { 299 bp->b_resid = bp->b_bcount; 300 goto done; 301 } 302 p = &of->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)]; 303 blkno = bp->b_blkno + p->p_offset; 304 } 305 306 disk_busy(&of->sc_dk); 307 308 off = (u_quad_t)blkno * DEV_BSIZE; 309 read = -1; 310 do { 311 if (OF_seek(of->sc_ihandle, off) < 0) 312 break; 313 read = OF_io(of->sc_ihandle, bp->b_data, bp->b_bcount); 314 } while (read == -2); 315 316 if (read < 0) { 317 bp->b_error = EIO; 318 bp->b_resid = bp->b_bcount; 319 } else 320 bp->b_resid = bp->b_bcount - read; 321 322 disk_unbusy(&of->sc_dk, bp->b_bcount - bp->b_resid, 323 (bp->b_flags & B_READ)); 324 325 done: 326 biodone(bp); 327 } 328 329 static void 330 ofminphys(struct buf *bp) 331 { 332 struct ofdisk_softc *of = 333 device_lookup_private(&ofdisk_cd, DISKUNIT(bp->b_dev)); 334 335 if (bp->b_bcount > of->max_transfer) 336 bp->b_bcount = of->max_transfer; 337 } 338 339 int 340 ofdisk_read(dev_t dev, struct uio *uio, int flags) 341 { 342 return physio(ofdisk_strategy, NULL, dev, B_READ, ofminphys, uio); 343 } 344 345 int 346 ofdisk_write(dev_t dev, struct uio *uio, int flags) 347 { 348 return physio(ofdisk_strategy, NULL, dev, B_WRITE, ofminphys, uio); 349 } 350 351 int 352 ofdisk_ioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 353 { 354 struct ofdisk_softc *of = 355 device_lookup_private(&ofdisk_cd, DISKUNIT(dev)); 356 int error; 357 #ifdef __HAVE_OLD_DISKLABEL 358 struct disklabel newlabel; 359 #endif 360 361 switch (cmd) { 362 case DIOCGDINFO: 363 *(struct disklabel *)data = *of->sc_dk.dk_label; 364 return 0; 365 #ifdef __HAVE_OLD_DISKLABEL 366 case ODIOCGDINFO: 367 newlabel = *of->sc_dk.dk_label; 368 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 369 return ENOTTY; 370 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 371 return 0; 372 #endif 373 374 case DIOCGPART: 375 ((struct partinfo *)data)->disklab = of->sc_dk.dk_label; 376 ((struct partinfo *)data)->part = 377 &of->sc_dk.dk_label->d_partitions[DISKPART(dev)]; 378 return 0; 379 380 case DIOCWDINFO: 381 case DIOCSDINFO: 382 #ifdef __HAVE_OLD_DISKLABEL 383 case ODIOCWDINFO: 384 case ODIOCSDINFO: 385 #endif 386 { 387 struct disklabel *lp; 388 389 #ifdef __HAVE_OLD_DISKLABEL 390 if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) { 391 memset(&newlabel, 0, sizeof newlabel); 392 memcpy(&newlabel, data, sizeof (struct olddisklabel)); 393 lp = &newlabel; 394 } else 395 #endif 396 lp = (struct disklabel *)data; 397 398 if ((flag & FWRITE) == 0) 399 return EBADF; 400 401 mutex_enter(&of->sc_dk.dk_openlock); 402 403 error = setdisklabel(of->sc_dk.dk_label, 404 lp, /*of->sc_dk.dk_openmask */0, 405 of->sc_dk.dk_cpulabel); 406 if (error == 0 && cmd == DIOCWDINFO 407 #ifdef __HAVE_OLD_DISKLABEL 408 || xfer == ODIOCWDINFO 409 #endif 410 ) 411 error = writedisklabel(MAKEDISKDEV(major(dev), 412 DISKUNIT(dev), RAW_PART), ofdisk_strategy, 413 of->sc_dk.dk_label, of->sc_dk.dk_cpulabel); 414 415 mutex_exit(&of->sc_dk.dk_openlock); 416 417 return error; 418 } 419 420 case DIOCGDEFLABEL: 421 ofdisk_getdefaultlabel(of, (struct disklabel *)data); 422 return 0; 423 #ifdef __HAVE_OLD_DISKLABEL 424 case DIOCGDEFLABEL: 425 ofdisk_getdefaultlabel(of, &newlabel); 426 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 427 return ENOTTY; 428 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 429 return 0; 430 #endif 431 432 case DIOCAWEDGE: 433 { 434 struct dkwedge_info *dkw = (void *) data; 435 436 if (OFDISK_FLOPPY_P(of)) 437 return (ENOTTY); 438 439 if ((flag & FWRITE) == 0) 440 return (EBADF); 441 442 /* If the ioctl happens here, the parent is us. */ 443 strlcpy(dkw->dkw_parent, device_xname(of->sc_dev), 444 sizeof(dkw->dkw_parent)); 445 return (dkwedge_add(dkw)); 446 } 447 448 case DIOCDWEDGE: 449 { 450 struct dkwedge_info *dkw = (void *) data; 451 452 if (OFDISK_FLOPPY_P(of)) 453 return (ENOTTY); 454 455 if ((flag & FWRITE) == 0) 456 return (EBADF); 457 458 /* If the ioctl happens here, the parent is us. */ 459 strlcpy(dkw->dkw_parent, device_xname(of->sc_dev), 460 sizeof(dkw->dkw_parent)); 461 return (dkwedge_del(dkw)); 462 } 463 464 case DIOCLWEDGES: 465 { 466 struct dkwedge_list *dkwl = (void *) data; 467 468 if (OFDISK_FLOPPY_P(of)) 469 return (ENOTTY); 470 471 return (dkwedge_list(&of->sc_dk, dkwl, l)); 472 } 473 474 default: 475 return ENOTTY; 476 } 477 } 478 479 int 480 ofdisk_dump(dev_t dev, daddr_t blkno, void *va, size_t size) 481 { 482 return EINVAL; 483 } 484 485 int 486 ofdisk_size(dev_t dev) 487 { 488 struct ofdisk_softc *of; 489 struct disklabel *lp; 490 int size, part, omask; 491 492 of = device_lookup_private(&ofdisk_cd, DISKUNIT(dev)); 493 if (of == NULL) 494 return ENXIO; 495 496 part = DISKPART(dev); 497 omask = of->sc_dk.dk_openmask & (1 << part); 498 lp = of->sc_dk.dk_label; 499 500 if (omask == 0 && ofdisk_open(dev, 0, S_IFBLK, curlwp) != 0) 501 return -1; 502 503 if (lp->d_partitions[part].p_fstype != FS_SWAP) 504 size = -1; 505 else 506 size = lp->d_partitions[part].p_size * 507 (lp->d_secsize / DEV_BSIZE); 508 509 if (omask == 0 && ofdisk_close(dev, 0, S_IFBLK, curlwp) != 0) 510 return -1; 511 512 return size; 513 } 514 515 void 516 ofdisk_getdefaultlabel(struct ofdisk_softc *of, struct disklabel *lp) 517 { 518 519 memset(lp, 0, sizeof *lp); 520 521 /* 522 * XXX Firmware bug? Asking for block size gives a 523 * XXX ridiculous number! So we use what the boot program 524 * XXX uses. 525 */ 526 lp->d_secsize = DEV_BSIZE; 527 528 lp->d_secperunit = OF_call_method_1("#blocks", 529 of->sc_ihandle, 0); 530 if (lp->d_secperunit == (u_int32_t)-1) 531 lp->d_secperunit = 0x7fffffff; 532 533 lp->d_secpercyl = 1; 534 lp->d_nsectors = 1; 535 lp->d_ntracks = 1; 536 lp->d_ncylinders = lp->d_secperunit; 537 538 lp->d_partitions[RAW_PART].p_offset = 0; 539 lp->d_partitions[RAW_PART].p_size = lp->d_secperunit; 540 lp->d_npartitions = RAW_PART + 1; 541 542 lp->d_magic = DISKMAGIC; 543 lp->d_magic2 = DISKMAGIC; 544 lp->d_checksum = dkcksum(lp); 545 } 546 547 void 548 ofdisk_getdisklabel(dev_t dev) 549 { 550 int unit = DISKUNIT(dev); 551 struct ofdisk_softc *of = 552 device_lookup_private(&ofdisk_cd, unit); 553 struct disklabel *lp = of->sc_dk.dk_label; 554 const char *errmes; 555 int l; 556 557 ofdisk_getdefaultlabel(of, lp); 558 559 /* 560 * Don't read the disklabel on a floppy; simply 561 * assign all partitions the same size/offset as 562 * RAW_PART. (This is essentially what the ISA 563 * floppy driver does, but we don't deal with 564 * density stuff.) 565 */ 566 if (OFDISK_FLOPPY_P(of)) { 567 lp->d_npartitions = MAXPARTITIONS; 568 for (l = 0; l < lp->d_npartitions; l++) { 569 if (l == RAW_PART) 570 continue; 571 /* struct copy */ 572 lp->d_partitions[l] = 573 lp->d_partitions[RAW_PART]; 574 } 575 lp->d_checksum = dkcksum(lp); 576 } else { 577 errmes = readdisklabel(MAKEDISKDEV(major(dev), 578 unit, RAW_PART), ofdisk_strategy, lp, 579 of->sc_dk.dk_cpulabel); 580 if (errmes != NULL) 581 printf("%s: %s\n", device_xname(of->sc_dev), errmes); 582 } 583 } 584
Indexes created Tue Sep 23 07:09:52 GMT 2025