1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 27 /* 28 * Floppy Disk driver 29 */ 30 31 /* 32 * Set CMOS feature: 33 * CMOS_CONF_MEM: CMOS memory contains configuration info 34 */ 35 #define CMOS_CONF_MEM 36 37 #include <sys/types.h> 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/buf.h> 41 #include <sys/file.h> 42 #include <sys/open.h> 43 #include <sys/ioctl.h> 44 #include <sys/uio.h> 45 #include <sys/conf.h> 46 #include <sys/stat.h> 47 #include <sys/autoconf.h> 48 #include <sys/vtoc.h> 49 #include <sys/dkio.h> 50 #include <sys/ddi.h> 51 #include <sys/sunddi.h> 52 #include <sys/kstat.h> 53 #include <sys/kmem.h> 54 #include <sys/ddidmareq.h> 55 #include <sys/fdio.h> 56 #include <sys/fdc.h> 57 #include <sys/fd_debug.h> 58 #include <sys/fdmedia.h> 59 #include <sys/debug.h> 60 #include <sys/modctl.h> 61 62 /* 63 * Local Function Prototypes 64 */ 65 static int fd_unit_is_open(struct fdisk *); 66 static int fdgetlabel(struct fcu_obj *, int); 67 static void fdstart(struct fcu_obj *); 68 static int fd_build_label_vtoc(struct fcu_obj *, struct fdisk *, 69 struct vtoc *, struct dk_label *); 70 static void fd_build_user_vtoc(struct fcu_obj *, struct fdisk *, 71 struct vtoc *); 72 static int fd_rawioctl(struct fcu_obj *, int, caddr_t, int); 73 static void fd_media_watch(void *); 74 75 static int fd_open(dev_t *, int, int, cred_t *); 76 static int fd_close(dev_t, int, int, cred_t *); 77 static int fd_strategy(struct buf *); 78 static int fd_read(dev_t, struct uio *, cred_t *); 79 static int fd_write(dev_t, struct uio *, cred_t *); 80 static int fd_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 81 static int fd_prop_op(dev_t, dev_info_t *, ddi_prop_op_t, int, char *, 82 caddr_t, int *); 83 static int fd_check_media(dev_t dev, enum dkio_state state); 84 static int fd_get_media_info(struct fcu_obj *fjp, caddr_t buf, int flag); 85 86 static struct cb_ops fd_cb_ops = { 87 fd_open, /* open */ 88 fd_close, /* close */ 89 fd_strategy, /* strategy */ 90 nodev, /* print */ 91 nodev, /* dump */ 92 fd_read, /* read */ 93 fd_write, /* write */ 94 fd_ioctl, /* ioctl */ 95 nodev, /* devmap */ 96 nodev, /* mmap */ 97 nodev, /* segmap */ 98 nochpoll, /* poll */ 99 fd_prop_op, /* cb_prop_op */ 100 0, /* streamtab */ 101 D_NEW | D_MP /* Driver compatibility flag */ 102 }; 103 104 static int fd_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 105 static int fd_probe(dev_info_t *); 106 static int fd_attach(dev_info_t *, ddi_attach_cmd_t); 107 static int fd_detach(dev_info_t *, ddi_detach_cmd_t); 108 109 static struct dev_ops fd_ops = { 110 DEVO_REV, /* devo_rev, */ 111 0, /* refcnt */ 112 fd_getinfo, /* getinfo */ 113 nulldev, /* identify */ 114 fd_probe, /* probe */ 115 fd_attach, /* attach */ 116 fd_detach, /* detach */ 117 nodev, /* reset */ 118 &fd_cb_ops, /* driver operations */ 119 (struct bus_ops *)0, /* bus operations */ 120 NULL, /* power */ 121 ddi_quiesce_not_supported, /* devo_quiesce */ 122 }; 123 124 125 /* 126 * static data 127 */ 128 static void *fd_state_head; /* opaque handle top of state structs */ 129 static int fd_check_media_time = 5000000; /* 5 second state check */ 130 131 /* 132 * error handling 133 * 134 * for debugging, 135 * set fderrlevel to 1 136 * set fderrmask to 224 or 644 137 */ 138 #ifdef DEBUG 139 static uint_t fderrmask = FDEM_ALL; 140 #endif 141 static int fderrlevel = 5; 142 143 #define KIOSP KSTAT_IO_PTR(fdp->d_iostat) 144 145 static struct driver_minor_data { 146 char *name; 147 int minor; 148 int type; 149 } fd_minor [] = { 150 { "a", 0, S_IFBLK}, 151 { "b", 1, S_IFBLK}, 152 { "c", 2, S_IFBLK}, 153 { "a,raw", 0, S_IFCHR}, 154 { "b,raw", 1, S_IFCHR}, 155 { "c,raw", 2, S_IFCHR}, 156 {0} 157 }; 158 159 static struct modldrv modldrv = { 160 &mod_driverops, /* Type of module. This one is a driver */ 161 "Floppy Disk driver", /* Name of the module. */ 162 &fd_ops, /* driver ops */ 163 }; 164 165 static struct modlinkage modlinkage = { 166 MODREV_1, (void *)&modldrv, NULL 167 }; 168 169 170 int 171 _init(void) 172 { 173 int retval; 174 175 if ((retval = ddi_soft_state_init(&fd_state_head, 176 sizeof (struct fdisk) + sizeof (struct fd_drive) + 177 sizeof (struct fd_char) + sizeof (struct fdattr), 0)) != 0) 178 return (retval); 179 180 if ((retval = mod_install(&modlinkage)) != 0) 181 ddi_soft_state_fini(&fd_state_head); 182 return (retval); 183 } 184 185 int 186 _fini(void) 187 { 188 int retval; 189 190 if ((retval = mod_remove(&modlinkage)) != 0) 191 return (retval); 192 ddi_soft_state_fini(&fd_state_head); 193 return (retval); 194 } 195 196 int 197 _info(struct modinfo *modinfop) 198 { 199 return (mod_info(&modlinkage, modinfop)); 200 } 201 202 203 static int 204 fd_getdrive(dev_t dev, struct fcu_obj **fjpp, struct fdisk **fdpp) 205 { 206 if (fdpp) { 207 *fdpp = ddi_get_soft_state(fd_state_head, DRIVE(dev)); 208 if (*fdpp && fjpp) { 209 *fjpp = (*fdpp)->d_obj; 210 if (*fjpp) 211 return ((*fjpp)->fj_unit); 212 } 213 } 214 return (-1); 215 } 216 217 /*ARGSUSED*/ 218 static int 219 fd_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result) 220 { 221 dev_t dev = (dev_t)arg; 222 struct fcu_obj *fjp = NULL; 223 struct fdisk *fdp = NULL; 224 int rval; 225 226 switch (cmd) { 227 case DDI_INFO_DEVT2DEVINFO: 228 (void) fd_getdrive(dev, &fjp, &fdp); 229 /* 230 * Ignoring return value because success is checked by 231 * verifying fjp and fdp and returned unit value is not used. 232 */ 233 if (fjp && fdp) { 234 *result = fjp->fj_dip; 235 rval = DDI_SUCCESS; 236 } else 237 rval = DDI_FAILURE; 238 break; 239 case DDI_INFO_DEVT2INSTANCE: 240 *result = (void *)(uintptr_t)DRIVE(dev); 241 rval = DDI_SUCCESS; 242 break; 243 default: 244 rval = DDI_FAILURE; 245 } 246 return (rval); 247 } 248 249 #ifdef CMOS_CONF_MEM 250 #define CMOS_ADDR 0x70 251 #define CMOS_DATA 0x71 252 #define CMOS_FDRV 0x10 253 #endif /* CMOS_CONF_MEM */ 254 255 static int 256 fd_probe(dev_info_t *dip) 257 { 258 #ifdef CMOS_CONF_MEM 259 int cmos; 260 int drive_type; 261 #endif /* CMOS_CONF_MEM */ 262 int debug[2]; 263 int drive_size; 264 int len; 265 int unit_num; 266 char density[8]; 267 268 len = sizeof (debug); 269 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF, 270 DDI_PROP_DONTPASS, "debug", (caddr_t)debug, &len) == 271 DDI_PROP_SUCCESS) { 272 fderrlevel = debug[0]; 273 #ifdef DEBUG 274 fderrmask = (uint_t)debug[1]; 275 #endif 276 } 277 len = sizeof (unit_num); 278 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF, 279 DDI_PROP_DONTPASS, "unit", (caddr_t)&unit_num, &len) != 280 DDI_PROP_SUCCESS) { 281 FDERRPRINT(FDEP_L3, FDEM_ATTA, 282 (CE_WARN, "fd_probe failed: dip %p", (void *)dip)); 283 return (DDI_PROBE_FAILURE); 284 } 285 286 #ifdef CMOS_CONF_MEM 287 /* get the cmos memory values quick and dirty */ 288 outb(CMOS_ADDR, CMOS_FDRV); 289 cmos = drive_type = (int)inb(CMOS_DATA); 290 #endif /* CMOS_CONF_MEM */ 291 292 switch (unit_num) { 293 #ifdef CMOS_CONF_MEM 294 case 0: 295 drive_type = drive_type >> 4; 296 /* FALLTHROUGH */ 297 case 1: 298 if (cmos && (drive_type & 0x0F)) { 299 break; 300 } 301 /* 302 * Some enhanced floppy-disk controller adaptor cards 303 * require NO drives defined in the CMOS configuration 304 * memory. 305 * So fall through 306 */ 307 #endif /* CMOS_CONF_MEM */ 308 default: /* need to check conf file */ 309 len = sizeof (density); 310 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF, 311 DDI_PROP_DONTPASS, "density", (caddr_t)&density, &len) != 312 DDI_PROP_SUCCESS) { 313 FDERRPRINT(FDEP_L3, FDEM_ATTA, 314 (CE_WARN, 315 "fd_probe failed density: dip %p unit %d", 316 (void *)dip, unit_num)); 317 return (DDI_PROBE_FAILURE); 318 } 319 len = sizeof (drive_size); 320 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF, 321 DDI_PROP_DONTPASS, "size", (caddr_t)&drive_size, &len) != 322 DDI_PROP_SUCCESS) { 323 FDERRPRINT(FDEP_L3, FDEM_ATTA, 324 (CE_WARN, "fd_probe failed size: dip %p unit %d", 325 (void *)dip, unit_num)); 326 return (DDI_PROBE_FAILURE); 327 } 328 } 329 FDERRPRINT(FDEP_L3, FDEM_ATTA, 330 (CE_WARN, "fd_probe dip %p unit %d", (void *)dip, unit_num)); 331 return (DDI_PROBE_SUCCESS); 332 } 333 334 335 /* ARGSUSED */ 336 static int 337 fd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 338 { 339 struct fcu_obj *fjp; 340 struct fdisk *fdp; 341 struct driver_minor_data *dmdp; 342 int mode_3D; 343 int drive_num, drive_size, drive_type; 344 #ifdef CMOS_CONF_MEM 345 int cmos; 346 #endif /* CMOS_CONF_MEM */ 347 int len, sig_minor; 348 int unit_num; 349 char density[8]; 350 char name[MAXNAMELEN]; 351 352 switch (cmd) { 353 case DDI_ATTACH: 354 len = sizeof (unit_num); 355 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF, 356 DDI_PROP_DONTPASS, "unit", (caddr_t)&unit_num, &len) != 357 DDI_PROP_SUCCESS) { 358 FDERRPRINT(FDEP_L3, FDEM_ATTA, 359 (CE_WARN, "fd_attach failed: dip %p", (void *)dip)); 360 return (DDI_FAILURE); 361 } 362 363 #ifdef CMOS_CONF_MEM 364 outb(CMOS_ADDR, CMOS_FDRV); 365 cmos = drive_type = (int)inb(CMOS_DATA); 366 #endif /* CMOS_CONF_MEM */ 367 368 switch (unit_num) { 369 #ifdef CMOS_CONF_MEM 370 case 0: 371 drive_type = drive_type >> 4; 372 /* FALLTHROUGH */ 373 case 1: 374 drive_type = drive_type & 0x0F; 375 if (cmos) 376 break; 377 /* 378 * Some enhanced floppy-disk controller adaptor cards 379 * require NO drives defined in the CMOS configuration 380 * memory. 381 * So fall through 382 */ 383 #endif /* CMOS_CONF_MEM */ 384 default: /* need to check .conf file */ 385 drive_type = 0; 386 len = sizeof (density); 387 if (ddi_prop_op(DDI_DEV_T_ANY, dip, 388 PROP_LEN_AND_VAL_BUF, DDI_PROP_DONTPASS, "density", 389 (caddr_t)&density, &len) != DDI_PROP_SUCCESS) 390 density[0] = '\0'; 391 len = sizeof (drive_size); 392 if (ddi_prop_op(DDI_DEV_T_ANY, dip, 393 PROP_LEN_AND_VAL_BUF, DDI_PROP_DONTPASS, "size", 394 (caddr_t)&drive_size, &len) != DDI_PROP_SUCCESS) 395 drive_size = 0; 396 if (strcmp(density, "DSDD") == 0) { 397 if (drive_size == 5) 398 drive_type = 1; 399 else if (drive_size == 3) 400 drive_type = 3; 401 } else if (strcmp(density, "DSHD") == 0) { 402 if (drive_size == 5) 403 drive_type = 2; 404 else if (drive_size == 3) 405 drive_type = 4; 406 } else if (strcmp(density, "DSED") == 0 && 407 drive_size == 3) { 408 drive_type = 6; 409 } 410 break; 411 } 412 if (drive_type == 0) { 413 FDERRPRINT(FDEP_L3, FDEM_ATTA, 414 (CE_WARN, "fd_attach failed type: dip %p unit %d", 415 (void *)dip, unit_num)); 416 return (DDI_FAILURE); 417 } 418 419 drive_num = ddi_get_instance(dip); 420 if (ddi_soft_state_zalloc(fd_state_head, drive_num) != 0) 421 return (DDI_FAILURE); 422 fdp = ddi_get_soft_state(fd_state_head, drive_num); 423 fjp = fdp->d_obj = ddi_get_driver_private(dip); 424 425 mutex_init(&fjp->fj_lock, NULL, MUTEX_DRIVER, *fjp->fj_iblock); 426 sema_init(&fdp->d_ocsem, 1, NULL, SEMA_DRIVER, NULL); 427 428 fjp->fj_drive = (struct fd_drive *)(fdp + 1); 429 fjp->fj_chars = (struct fd_char *)(fjp->fj_drive + 1); 430 fjp->fj_attr = (struct fdattr *)(fjp->fj_chars + 1); 431 432 /* 433 * set default floppy drive characteristics & geometry 434 */ 435 switch (drive_type) { /* assume doubled sided */ 436 case 2: /* 5.25 high density */ 437 *fjp->fj_drive = dfd_525HD; 438 fdp->d_media = 1<<FMT_5H | 1<<FMT_5D9 | 1<<FMT_5D8 | 439 1<<FMT_5D4 | 1<<FMT_5D16; 440 fdp->d_deffdtype = fdp->d_curfdtype = FMT_5H; 441 break; 442 case 4: /* 3.5 high density */ 443 *fjp->fj_drive = dfd_350HD; 444 fdp->d_media = 1<<FMT_3H | 1<<FMT_3I | 1<<FMT_3D; 445 len = sizeof (mode_3D); 446 if (ddi_prop_op(DDI_DEV_T_ANY, dip, 447 PROP_LEN_AND_VAL_BUF, DDI_PROP_DONTPASS, "mode_3D", 448 (caddr_t)&mode_3D, &len) != DDI_PROP_SUCCESS) 449 mode_3D = 0; 450 if (mode_3D && (fjp->fj_fdc->c_flags & FCFLG_3DMODE)) 451 /* 452 * 3D mode should be enabled only if a dual- 453 * speed 3.5" high-density drive and a 454 * supported floppy controller are installed. 455 */ 456 fdp->d_media |= 1 << FMT_3M; 457 fdp->d_deffdtype = fdp->d_curfdtype = FMT_3H; 458 break; 459 case 1: /* 5.25 double density */ 460 *fjp->fj_drive = dfd_525DD; 461 fdp->d_media = 1<<FMT_5D9 | 1<<FMT_5D8 | 1<<FMT_5D4 | 462 1<<FMT_5D16; 463 fdp->d_deffdtype = fdp->d_curfdtype = FMT_5D9; 464 break; 465 case 3: /* 3.5 double density */ 466 *fjp->fj_drive = dfd_350HD; 467 fdp->d_media = 1<<FMT_3D; 468 fdp->d_deffdtype = fdp->d_curfdtype = FMT_3D; 469 break; 470 case 5: /* 3.5 extended density */ 471 case 6: 472 case 7: 473 *fjp->fj_drive = dfd_350ED; 474 fdp->d_media = 1<<FMT_3E | 1<<FMT_3H | 1<<FMT_3I | 475 1<<FMT_3D; 476 fdp->d_deffdtype = fdp->d_curfdtype = FMT_3E; 477 break; 478 case 0: /* no drive defined */ 479 default: 480 goto no_attach; 481 } 482 *fjp->fj_chars = *defchar[fdp->d_deffdtype]; 483 *fjp->fj_attr = fdtypes[fdp->d_deffdtype]; 484 bcopy(fdparts[fdp->d_deffdtype], fdp->d_part, 485 sizeof (struct partition) * NDKMAP); 486 fjp->fj_rotspd = fdtypes[fdp->d_deffdtype].fda_rotatespd; 487 488 sig_minor = drive_num << 3; 489 for (dmdp = fd_minor; dmdp->name != NULL; dmdp++) { 490 if (ddi_create_minor_node(dip, dmdp->name, dmdp->type, 491 sig_minor | dmdp->minor, DDI_NT_FD, NULL) 492 == DDI_FAILURE) { 493 ddi_remove_minor_node(dip, NULL); 494 goto no_attach; 495 } 496 } 497 498 FDERRPRINT(FDEP_L3, FDEM_ATTA, 499 (CE_WARN, "fd_attach: dip %p unit %d", 500 (void *)dip, unit_num)); 501 (void) sprintf(name, "fd%d", drive_num); 502 fdp->d_iostat = kstat_create("fd", drive_num, name, "disk", 503 KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT); 504 if (fdp->d_iostat) { 505 fdp->d_iostat->ks_lock = &fjp->fj_lock; 506 kstat_install(fdp->d_iostat); 507 } 508 509 fjp->fj_data = (caddr_t)fdp; 510 fjp->fj_flags |= FUNIT_DRVATCH; 511 512 /* 513 * Add a zero-length attribute to tell the world we support 514 * kernel ioctls (for layered drivers) 515 */ 516 (void) ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP, 517 DDI_KERNEL_IOCTL, NULL, 0); 518 519 /* 520 * We want to get suspend/resume events, so that we can 521 * refuse to suspend when pcfs is mounted. 522 */ 523 (void) ddi_prop_update_string(DDI_DEV_T_NONE, dip, 524 "pm-hardware-state", "needs-suspend-resume"); 525 526 /* 527 * Ignoring return value because, for passed arguments, only 528 * DDI_SUCCESS is returned. 529 */ 530 ddi_report_dev(dip); 531 return (DDI_SUCCESS); 532 533 case DDI_RESUME: 534 /* nothing for us to do */ 535 return (DDI_SUCCESS); 536 537 default: 538 return (DDI_FAILURE); 539 } 540 no_attach: 541 fjp->fj_drive = NULL; 542 fjp->fj_chars = NULL; 543 fjp->fj_attr = NULL; 544 mutex_destroy(&fjp->fj_lock); 545 sema_destroy(&fdp->d_ocsem); 546 ddi_soft_state_free(fd_state_head, drive_num); 547 FDERRPRINT(FDEP_L3, FDEM_ATTA, 548 (CE_WARN, "fd_attach failed: dip %p unit %d", 549 (void *)dip, unit_num)); 550 return (DDI_FAILURE); 551 } 552 553 554 /* ARGSUSED */ 555 static int 556 fd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 557 { 558 struct fcu_obj *fjp; 559 struct fdisk *fdp; 560 int drive_num; 561 int rval = DDI_SUCCESS; 562 563 FDERRPRINT(FDEP_L3, FDEM_ATTA, (CE_WARN, "fd_detach dip %p", 564 (void *)dip)); 565 566 drive_num = ddi_get_instance(dip); 567 if (!(fdp = ddi_get_soft_state(fd_state_head, drive_num))) 568 return (rval); 569 570 switch (cmd) { 571 case DDI_DETACH: 572 if (fd_unit_is_open(fdp)) { 573 rval = DDI_FAILURE; 574 break; 575 } 576 kstat_delete(fdp->d_iostat); 577 fdp->d_iostat = NULL; 578 fjp = (struct fcu_obj *)fdp->d_obj; 579 fjp->fj_flags &= ~FUNIT_DRVATCH; 580 fjp->fj_data = NULL; 581 fjp->fj_drive = NULL; 582 fjp->fj_chars = NULL; 583 fjp->fj_attr = NULL; 584 ddi_prop_remove_all(dip); 585 mutex_destroy(&fjp->fj_lock); 586 sema_destroy(&fdp->d_ocsem); 587 ddi_soft_state_free(fd_state_head, drive_num); 588 break; 589 590 case DDI_SUSPEND: 591 /* 592 * Bad, bad, bad things will happen if someone 593 * *changes* the disk in the drive while it is mounted 594 * and the system is suspended. We have no way to 595 * detect that. (Undetected filesystem corruption. 596 * Its akin to changing the boot disk while the system 597 * is suspended. Don't do it!) 598 * 599 * So we refuse to suspend if there is a mounted filesystem. 600 * (We guess this by looking for a block open. Character 601 * opens are fine.) This limits some of the usability of 602 * suspend/resume, but it certainly avoids this 603 * potential filesytem corruption from pilot error. 604 * Given the decreasing popularity of floppy media, we 605 * don't see this as much of a limitation. 606 */ 607 if (fdp->d_regopen[OTYP_BLK]) { 608 cmn_err(CE_NOTE, 609 "Unable to suspend while floppy is in use."); 610 rval = DDI_FAILURE; 611 } 612 break; 613 614 default: 615 rval = DDI_FAILURE; 616 break; 617 } 618 return (rval); 619 } 620 621 622 static int 623 fd_part_is_open(struct fdisk *fdp, int part) 624 { 625 int i; 626 627 for (i = 0; i < (OTYPCNT - 1); i++) 628 if (fdp->d_regopen[i] & (1 << part)) 629 return (1); 630 return (0); 631 } 632 633 static int 634 fd_unit_is_open(struct fdisk *fdp) 635 { 636 int i; 637 638 for (i = 0; i < NDKMAP; i++) 639 if (fdp->d_lyropen[i]) 640 return (1); 641 for (i = 0; i < (OTYPCNT - 1); i++) 642 if (fdp->d_regopen[i]) 643 return (1); 644 return (0); 645 } 646 647 /*ARGSUSED*/ 648 static int 649 fd_open(dev_t *devp, int flag, int otyp, cred_t *cred_p) 650 { 651 struct fcu_obj *fjp = NULL; 652 struct fdisk *fdp = NULL; 653 struct partition *pp; 654 dev_t dev; 655 int part, unit; 656 int part_is_open; 657 int rval; 658 uint_t pbit; 659 660 dev = *devp; 661 unit = fd_getdrive(dev, &fjp, &fdp); 662 if (!fjp || !fdp) 663 return (ENXIO); 664 part = PARTITION(dev); 665 pbit = 1 << part; 666 pp = &fdp->d_part[part]; 667 668 /* 669 * Serialize opens/closes 670 */ 671 sema_p(&fdp->d_ocsem); 672 FDERRPRINT(FDEP_L1, FDEM_OPEN, 673 (CE_CONT, "fd_open: fd%d part %d flag %x otype %x\n", DRIVE(dev), 674 part, flag, otyp)); 675 676 /* 677 * Check for previous exclusive open, or trying to exclusive open 678 * An "exclusive open" on any partition is not guaranteed to 679 * protect against opens on another partition that overlaps it. 680 */ 681 if (otyp == OTYP_LYR) { 682 part_is_open = (fdp->d_lyropen[part] != 0); 683 } else { 684 part_is_open = fd_part_is_open(fdp, part); 685 } 686 if ((fdp->d_exclmask & pbit) || ((flag & FEXCL) && part_is_open)) { 687 FDERRPRINT(FDEP_L0, FDEM_OPEN, (CE_CONT, 688 "fd_open: exclparts %lx openparts %lx lyrcnt %lx pbit %x\n", 689 fdp->d_exclmask, fdp->d_regopen[otyp], fdp->d_lyropen[part], 690 pbit)); 691 sema_v(&fdp->d_ocsem); 692 return (EBUSY); 693 } 694 695 /* 696 * Ensure that drive is recalibrated on first open of new diskette. 697 */ 698 fjp->fj_ops->fco_select(fjp, unit, 1); 699 if (fjp->fj_ops->fco_getchng(fjp, unit) != 0) { 700 if (fjp->fj_ops->fco_rcseek(fjp, unit, -1, 0)) { 701 FDERRPRINT(FDEP_L2, FDEM_OPEN, 702 (CE_NOTE, "fd_open fd%d: not ready", DRIVE(dev))); 703 fjp->fj_ops->fco_select(fjp, unit, 0); 704 sema_v(&fdp->d_ocsem); 705 return (ENXIO); 706 } 707 fjp->fj_flags &= ~(FUNIT_LABELOK | FUNIT_UNLABELED); 708 } 709 if (flag & (FNDELAY | FNONBLOCK)) { 710 /* don't attempt access, just return successfully */ 711 fjp->fj_ops->fco_select(fjp, unit, 0); 712 goto out; 713 } 714 715 /* 716 * auto-sense the density/format of the diskette 717 */ 718 rval = fdgetlabel(fjp, unit); 719 fjp->fj_ops->fco_select(fjp, unit, 0); 720 if (rval) { 721 /* didn't find label (couldn't read anything) */ 722 FDERRPRINT(FDEP_L2, FDEM_OPEN, 723 (CE_NOTE, "fd%d: drive not ready", DRIVE(dev))); 724 sema_v(&fdp->d_ocsem); 725 return (EIO); 726 } 727 /* check partition */ 728 if (pp->p_size == 0) { 729 sema_v(&fdp->d_ocsem); 730 return (ENXIO); 731 } 732 /* 733 * if opening for writing, check write protect on diskette 734 */ 735 if ((flag & FWRITE) && (fdp->d_obj->fj_flags & FUNIT_WPROT)) { 736 sema_v(&fdp->d_ocsem); 737 return (EROFS); 738 } 739 740 out: 741 /* 742 * mark open as having succeeded 743 */ 744 if (flag & FEXCL) 745 fdp->d_exclmask |= pbit; 746 if (otyp == OTYP_LYR) 747 fdp->d_lyropen[part]++; 748 else 749 fdp->d_regopen[otyp] |= 1 << part; 750 751 sema_v(&fdp->d_ocsem); 752 return (0); 753 } 754 755 /* 756 * fdgetlabel - read the SunOS label off the diskette 757 * if it can read a valid label it does so, else it will use a 758 * default. If it can`t read the diskette - that is an error. 759 * 760 * RETURNS: 0 for ok - meaning that it could at least read the device, 761 * !0 for error XXX TBD NYD error codes 762 */ 763 static int 764 fdgetlabel(struct fcu_obj *fjp, int unit) 765 { 766 struct dk_label *label; 767 struct fdisk *fdp; 768 char *newlabel; 769 short *sp; 770 short count; 771 short xsum; 772 int tries, try_this; 773 uint_t nexttype; 774 int rval; 775 short oldlvl; 776 int i; 777 778 FDERRPRINT(FDEP_L0, FDEM_GETL, 779 (CE_CONT, "fdgetlabel fd unit %d\n", unit)); 780 fdp = (struct fdisk *)fjp->fj_data; 781 fjp->fj_flags &= ~(FUNIT_UNLABELED); 782 783 /* 784 * get some space to play with the label 785 */ 786 label = kmem_zalloc(sizeof (struct dk_label), KM_SLEEP); 787 FDERRPRINT(FDEP_L0, FDEM_GETL, (CE_CONT, 788 "fdgetlabel fd unit %d kmem_zalloc: ptr = %p, size = %lx\n", 789 unit, (void *)label, (size_t)sizeof (struct dk_label))); 790 791 /* 792 * read block 0 (0/0/1) to find the label 793 * (disk is potentially not present or unformatted) 794 */ 795 /* noerrprint since this is a private cmd */ 796 oldlvl = fderrlevel; 797 fderrlevel = FDEP_LMAX; 798 /* 799 * try different characteristics (ie densities) 800 * 801 * if fdp->d_curfdtype is -1 then the current characteristics 802 * were set by ioctl and need to try it as well as everything 803 * in the table 804 */ 805 nexttype = fdp->d_deffdtype; 806 try_this = 1; /* always try the current characteristics */ 807 808 for (tries = nfdtypes; tries; tries--) { 809 if (try_this) { 810 fjp->fj_flags &= ~FUNIT_CHAROK; 811 812 /* try reading last sector of cyl 1, head 0 */ 813 if (!(rval = fjp->fj_ops->fco_rw(fjp, unit, 814 FDREAD, 1, 0, fjp->fj_chars->fdc_secptrack, 815 (caddr_t)label, 816 sizeof (struct dk_label))) && 817 /* and last sector plus 1 of cylinder 1 */ 818 fjp->fj_ops->fco_rw(fjp, unit, FDREAD, 1, 819 0, fjp->fj_chars->fdc_secptrack + 1, 820 (caddr_t)label, 821 sizeof (struct dk_label)) && 822 /* and label sector on cylinder 0 */ 823 !(rval = fjp->fj_ops->fco_rw(fjp, unit, 824 FDREAD, 0, 0, 1, (caddr_t)label, 825 sizeof (struct dk_label)))) 826 break; 827 if (rval == ENXIO) 828 break; 829 } 830 /* 831 * try the next entry in the characteristics tbl 832 */ 833 fdp->d_curfdtype = (signed char)nexttype; 834 nexttype = (nexttype + 1) % nfdtypes; 835 if ((1 << fdp->d_curfdtype) & fdp->d_media) { 836 *fjp->fj_chars = *defchar[fdp->d_curfdtype]; 837 *fjp->fj_attr = fdtypes[fdp->d_curfdtype]; 838 bcopy(fdparts[fdp->d_curfdtype], fdp->d_part, 839 sizeof (struct partition) * NDKMAP); 840 /* 841 * check for a double_density diskette 842 * in a high_density 5.25" drive 843 */ 844 if (fjp->fj_chars->fdc_transfer_rate == 250 && 845 fjp->fj_rotspd > fjp->fj_attr->fda_rotatespd) { 846 /* 847 * yes - adjust transfer rate since we don't 848 * know if we have a 5.25" dual-speed drive 849 */ 850 fjp->fj_attr->fda_rotatespd = 360; 851 fjp->fj_chars->fdc_transfer_rate = 300; 852 fjp->fj_chars->fdc_medium = 5; 853 } 854 if ((2 * fjp->fj_chars->fdc_ncyl) == 855 defchar[fdp->d_deffdtype]->fdc_ncyl) { 856 /* yes - adjust steps per cylinder */ 857 fjp->fj_chars->fdc_steps = 2; 858 } else 859 fjp->fj_chars->fdc_steps = 1; 860 try_this = 1; 861 } else 862 try_this = 0; 863 } 864 fderrlevel = oldlvl; /* print errors again */ 865 866 if (rval) { 867 fdp->d_curfdtype = fdp->d_deffdtype; 868 goto out; /* couldn't read anything */ 869 } 870 871 FDERRPRINT(FDEP_L0, FDEM_GETL, 872 (CE_CONT, 873 "fdgetlabel fd unit=%d ncyl=%d nsct=%d step=%d rpm=%d intlv=%d\n", 874 unit, fjp->fj_chars->fdc_ncyl, fjp->fj_chars->fdc_secptrack, 875 fjp->fj_chars->fdc_steps, fjp->fj_attr->fda_rotatespd, 876 fjp->fj_attr->fda_intrlv)); 877 878 /* 879 * _something_ was read - look for unixtype label 880 */ 881 if (label->dkl_magic != DKL_MAGIC || 882 label->dkl_vtoc.v_sanity != VTOC_SANE) { 883 /* not a label - no magic number */ 884 goto nolabel; /* no errors, but no label */ 885 } 886 887 count = sizeof (struct dk_label) / sizeof (short); 888 sp = (short *)label; 889 xsum = 0; 890 while (count--) 891 xsum ^= *sp++; /* should add up to 0 */ 892 if (xsum) { 893 /* not a label - checksum didn't compute */ 894 goto nolabel; /* no errors, but no label */ 895 } 896 897 /* 898 * the SunOS label overrides current diskette characteristics 899 */ 900 fjp->fj_chars->fdc_ncyl = label->dkl_pcyl; 901 fjp->fj_chars->fdc_nhead = label->dkl_nhead; 902 fjp->fj_chars->fdc_secptrack = (label->dkl_nsect * DEV_BSIZE) / 903 fjp->fj_chars->fdc_sec_size; 904 if (defchar[fdp->d_deffdtype]->fdc_ncyl == 2 * fjp->fj_chars->fdc_ncyl) 905 fjp->fj_chars->fdc_steps = 2; 906 else 907 fjp->fj_chars->fdc_steps = 1; 908 909 fjp->fj_attr->fda_rotatespd = label->dkl_rpm; 910 fjp->fj_attr->fda_intrlv = label->dkl_intrlv; 911 912 fdp->d_vtoc_version = label->dkl_vtoc.v_version; 913 bcopy(label->dkl_vtoc.v_volume, fdp->d_vtoc_volume, LEN_DKL_VVOL); 914 bcopy(label->dkl_vtoc.v_asciilabel, 915 fdp->d_vtoc_asciilabel, LEN_DKL_ASCII); 916 /* 917 * logical partitions 918 */ 919 for (i = 0; i < NDKMAP; i++) { 920 fdp->d_part[i].p_tag = label->dkl_vtoc.v_part[i].p_tag; 921 fdp->d_part[i].p_flag = label->dkl_vtoc.v_part[i].p_flag; 922 fdp->d_part[i].p_start = label->dkl_vtoc.v_part[i].p_start; 923 fdp->d_part[i].p_size = label->dkl_vtoc.v_part[i].p_size; 924 925 fdp->d_vtoc_timestamp[i] = label->dkl_vtoc.timestamp[i]; 926 } 927 928 fjp->fj_flags |= FUNIT_LABELOK; 929 goto out; 930 931 nolabel: 932 /* 933 * if not found, fill in label info from default (mark default used) 934 */ 935 if (fdp->d_media & (1<<FMT_3D)) 936 newlabel = deflabel_35; 937 else /* if (fdp->d_media & (1<<FMT_5D9)) */ 938 newlabel = deflabel_525; 939 bzero(fdp->d_vtoc_volume, LEN_DKL_VVOL); 940 (void) sprintf(fdp->d_vtoc_asciilabel, newlabel, 941 fjp->fj_chars->fdc_ncyl, fjp->fj_chars->fdc_nhead, 942 fjp->fj_chars->fdc_secptrack); 943 fjp->fj_flags |= FUNIT_UNLABELED; 944 945 out: 946 kmem_free(label, sizeof (struct dk_label)); 947 return (rval); 948 } 949 950 951 /*ARGSUSED*/ 952 static int 953 fd_close(dev_t dev, int flag, int otyp, cred_t *cred_p) 954 { 955 struct fcu_obj *fjp = NULL; 956 struct fdisk *fdp = NULL; 957 int part, part_is_closed; 958 959 #ifdef DEBUG 960 int unit; 961 #define DEBUG_ASSIGN unit= 962 #else 963 #define DEBUG_ASSIGN (void) 964 #endif 965 966 DEBUG_ASSIGN fd_getdrive(dev, &fjp, &fdp); 967 /* 968 * Ignoring return in non DEBUG mode because success is checked by 969 * verifying fjp and fdp and returned unit value is not used. 970 */ 971 if (!fjp || !fdp) 972 return (ENXIO); 973 part = PARTITION(dev); 974 975 sema_p(&fdp->d_ocsem); 976 FDERRPRINT(FDEP_L1, FDEM_CLOS, 977 (CE_CONT, "fd_close: fd unit %d part %d otype %x\n", 978 unit, part, otyp)); 979 980 if (otyp == OTYP_LYR) { 981 if (fdp->d_lyropen[part]) 982 fdp->d_lyropen[part]--; 983 part_is_closed = (fdp->d_lyropen[part] == 0); 984 } else { 985 fdp->d_regopen[otyp] &= ~(1<<part); 986 part_is_closed = 1; 987 } 988 if (part_is_closed) { 989 if (part == 2 && fdp->d_exclmask&(1<<part)) 990 fdp->d_exclmask = 0; 991 else 992 fdp->d_exclmask &= ~(1<<part); 993 FDERRPRINT(FDEP_L0, FDEM_CLOS, 994 (CE_CONT, 995 "fd_close: exclparts %lx openparts %lx lyrcnt %lx\n", 996 fdp->d_exclmask, fdp->d_regopen[otyp], 997 fdp->d_lyropen[part])); 998 999 if (fd_unit_is_open(fdp) == 0) 1000 fdp->d_obj->fj_flags &= ~FUNIT_CHANGED; 1001 } 1002 sema_v(&fdp->d_ocsem); 1003 return (0); 1004 } 1005 1006 /* ARGSUSED */ 1007 static int 1008 fd_read(dev_t dev, struct uio *uio, cred_t *cred_p) 1009 { 1010 return (physio(fd_strategy, NULL, dev, B_READ, minphys, uio)); 1011 } 1012 1013 /* ARGSUSED */ 1014 static int 1015 fd_write(dev_t dev, struct uio *uio, cred_t *cred_p) 1016 { 1017 return (physio(fd_strategy, NULL, dev, B_WRITE, minphys, uio)); 1018 } 1019 1020 /* 1021 * fd_strategy 1022 * checks operation, hangs buf struct off fdcntlr, calls fdstart 1023 * if not already busy. Note that if we call start, then the operation 1024 * will already be done on return (start sleeps). 1025 */ 1026 static int 1027 fd_strategy(struct buf *bp) 1028 { 1029 struct fcu_obj *fjp; 1030 struct fdisk *fdp; 1031 struct partition *pp; 1032 1033 FDERRPRINT(FDEP_L1, FDEM_STRA, 1034 (CE_CONT, "fd_strategy: bp = 0x%p, dev = 0x%lx\n", 1035 (void *)bp, bp->b_edev)); 1036 1037 (void) fd_getdrive(bp->b_edev, &fjp, &fdp); 1038 1039 /* 1040 * Ignoring return because device exist. 1041 * Returned unit value is not used. 1042 */ 1043 pp = &fdp->d_part[PARTITION(bp->b_edev)]; 1044 1045 if (fjp->fj_chars->fdc_sec_size > NBPSCTR && (bp->b_blkno & 1)) { 1046 FDERRPRINT(FDEP_L3, FDEM_STRA, 1047 (CE_WARN, "fd%d: block %ld is not start of sector!", 1048 DRIVE(bp->b_edev), (long)bp->b_blkno)); 1049 bp->b_error = EINVAL; 1050 goto bad; 1051 } 1052 1053 if ((bp->b_blkno > pp->p_size)) { 1054 FDERRPRINT(FDEP_L3, FDEM_STRA, 1055 (CE_WARN, "fd%d: block %ld is past the end! (nblk=%ld)", 1056 DRIVE(bp->b_edev), (long)bp->b_blkno, pp->p_size)); 1057 bp->b_error = ENOSPC; 1058 goto bad; 1059 } 1060 1061 /* if at end of file, skip out now */ 1062 if (bp->b_blkno == pp->p_size) { 1063 if ((bp->b_flags & B_READ) == 0) { 1064 /* a write needs to get an error! */ 1065 bp->b_error = ENOSPC; 1066 goto bad; 1067 } 1068 bp->b_resid = bp->b_bcount; 1069 biodone(bp); 1070 return (0); 1071 } 1072 1073 /* if operation not a multiple of sector size, is error! */ 1074 if (bp->b_bcount % fjp->fj_chars->fdc_sec_size) { 1075 FDERRPRINT(FDEP_L3, FDEM_STRA, 1076 (CE_WARN, "fd%d: count %ld must be a multiple of %d", 1077 DRIVE(bp->b_edev), bp->b_bcount, 1078 fjp->fj_chars->fdc_sec_size)); 1079 bp->b_error = EINVAL; 1080 goto bad; 1081 } 1082 1083 /* 1084 * Put the buf request in the drive's queue, FIFO. 1085 */ 1086 bp->av_forw = 0; 1087 mutex_enter(&fjp->fj_lock); 1088 if (fdp->d_iostat) 1089 kstat_waitq_enter(KIOSP); 1090 if (fdp->d_actf) 1091 fdp->d_actl->av_forw = bp; 1092 else 1093 fdp->d_actf = bp; 1094 fdp->d_actl = bp; 1095 if (!(fjp->fj_flags & FUNIT_BUSY)) { 1096 fdstart(fjp); 1097 } 1098 mutex_exit(&fjp->fj_lock); 1099 return (0); 1100 1101 bad: 1102 bp->b_resid = bp->b_bcount; 1103 bp->b_flags |= B_ERROR; 1104 biodone(bp); 1105 return (0); 1106 } 1107 1108 /* 1109 * fdstart 1110 * called from fd_strategy() or from fdXXXX() to setup and 1111 * start operations of read or write only (using buf structs). 1112 * Because the chip doesn't handle crossing cylinder boundaries on 1113 * the fly, this takes care of those boundary conditions. Note that 1114 * it sleeps until the operation is done *within fdstart* - so that 1115 * when fdstart returns, the operation is already done. 1116 */ 1117 static void 1118 fdstart(struct fcu_obj *fjp) 1119 { 1120 struct buf *bp; 1121 struct fdisk *fdp = (struct fdisk *)fjp->fj_data; 1122 struct fd_char *chp; 1123 struct partition *pp; 1124 uint_t ptend; 1125 uint_t bincyl; /* (the number of the desired) block in cyl. */ 1126 uint_t blk, len, tlen; 1127 uint_t secpcyl; /* number of sectors per cylinder */ 1128 int cyl, head, sect; 1129 int sctrshft, unit; 1130 caddr_t addr; 1131 1132 ASSERT(MUTEX_HELD(&fjp->fj_lock)); 1133 fjp->fj_flags |= FUNIT_BUSY; 1134 1135 while ((bp = fdp->d_actf) != NULL) { 1136 fdp->d_actf = bp->av_forw; 1137 fdp->d_current = bp; 1138 if (fdp->d_iostat) { 1139 kstat_waitq_to_runq(KIOSP); 1140 } 1141 mutex_exit(&fjp->fj_lock); 1142 1143 FDERRPRINT(FDEP_L0, FDEM_STRT, 1144 (CE_CONT, "fdstart: bp=0x%p blkno=0x%lx bcount=0x%lx\n", 1145 (void *)bp, (long)bp->b_blkno, bp->b_bcount)); 1146 bp->b_flags &= ~B_ERROR; 1147 bp->b_error = 0; 1148 bp->b_resid = bp->b_bcount; /* init resid */ 1149 1150 ASSERT(DRIVE(bp->b_edev) == ddi_get_instance(fjp->fj_dip)); 1151 unit = fjp->fj_unit; 1152 fjp->fj_ops->fco_select(fjp, unit, 1); 1153 1154 bp_mapin(bp); /* map in buffers */ 1155 1156 pp = &fdp->d_part[PARTITION(bp->b_edev)]; 1157 /* starting blk adjusted for the partition */ 1158 blk = bp->b_blkno + pp->p_start; 1159 ptend = pp->p_start + pp->p_size; /* end of the partition */ 1160 1161 chp = fjp->fj_chars; 1162 secpcyl = chp->fdc_nhead * chp->fdc_secptrack; 1163 switch (chp->fdc_sec_size) { 1164 /* convert logical block numbers to sector numbers */ 1165 case 1024: 1166 sctrshft = SCTRSHFT + 1; 1167 blk >>= 1; 1168 ptend >>= 1; 1169 break; 1170 default: 1171 case NBPSCTR: 1172 sctrshft = SCTRSHFT; 1173 break; 1174 case 256: 1175 sctrshft = SCTRSHFT - 1; 1176 blk <<= 1; 1177 ptend <<= 1; 1178 break; 1179 } 1180 1181 /* 1182 * If off the end, limit to actual amount that 1183 * can be transferred. 1184 */ 1185 if ((blk + (bp->b_bcount >> sctrshft)) > ptend) 1186 /* to end of partition */ 1187 len = (ptend - blk) << sctrshft; 1188 else 1189 len = bp->b_bcount; 1190 addr = bp->b_un.b_addr; /* data buffer address */ 1191 1192 /* 1193 * now we have the real start blk, addr and len for xfer op 1194 */ 1195 while (len != 0) { 1196 /* start cyl of req */ 1197 cyl = blk / secpcyl; 1198 bincyl = blk % secpcyl; 1199 /* start head of req */ 1200 head = bincyl / chp->fdc_secptrack; 1201 /* start sector of req */ 1202 sect = (bincyl % chp->fdc_secptrack) + 1; 1203 /* 1204 * If the desired block and length will go beyond the 1205 * cylinder end, then limit it to the cylinder end. 1206 */ 1207 if (bp->b_flags & B_READ) { 1208 if (len > ((secpcyl - bincyl) << sctrshft)) 1209 tlen = (secpcyl - bincyl) << sctrshft; 1210 else 1211 tlen = len; 1212 } else { 1213 if (len > 1214 ((chp->fdc_secptrack - sect + 1) << 1215 sctrshft)) 1216 tlen = 1217 (chp->fdc_secptrack - sect + 1) << 1218 sctrshft; 1219 else 1220 tlen = len; 1221 } 1222 1223 FDERRPRINT(FDEP_L0, FDEM_STRT, (CE_CONT, 1224 " blk 0x%x addr 0x%p len 0x%x " 1225 "cyl %d head %d sec %d\n resid 0x%lx, tlen %d\n", 1226 blk, (void *)addr, len, cyl, head, sect, 1227 bp->b_resid, tlen)); 1228 1229 /* 1230 * (try to) do the operation - failure returns an errno 1231 */ 1232 bp->b_error = fjp->fj_ops->fco_rw(fjp, unit, 1233 bp->b_flags & B_READ, cyl, head, sect, addr, tlen); 1234 if (bp->b_error != 0) { 1235 FDERRPRINT(FDEP_L3, FDEM_STRT, (CE_WARN, 1236 "fdstart: bad exec of bp: 0x%p, err=%d", 1237 (void *)bp, bp->b_error)); 1238 bp->b_flags |= B_ERROR; 1239 break; 1240 } 1241 blk += tlen >> sctrshft; 1242 len -= tlen; 1243 addr += tlen; 1244 bp->b_resid -= tlen; 1245 } 1246 FDERRPRINT(FDEP_L0, FDEM_STRT, 1247 (CE_CONT, "fdstart done: b_resid %lu, b_count %lu\n", 1248 bp->b_resid, bp->b_bcount)); 1249 if (fdp->d_iostat) { 1250 if (bp->b_flags & B_READ) { 1251 KIOSP->reads++; 1252 KIOSP->nread += (bp->b_bcount - bp->b_resid); 1253 } else { 1254 KIOSP->writes++; 1255 KIOSP->nwritten += (bp->b_bcount - bp->b_resid); 1256 } 1257 kstat_runq_exit(KIOSP); 1258 } 1259 bp_mapout(bp); 1260 biodone(bp); 1261 1262 fjp->fj_ops->fco_select(fjp, unit, 0); 1263 mutex_enter(&fjp->fj_lock); 1264 fdp->d_current = 0; 1265 } 1266 fjp->fj_flags ^= FUNIT_BUSY; 1267 } 1268 1269 /* ARGSUSED */ 1270 static int 1271 fd_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p, 1272 int *rval_p) 1273 { 1274 union { 1275 struct dk_cinfo dki; 1276 struct dk_geom dkg; 1277 struct dk_allmap dka; 1278 struct fd_char fdchar; 1279 struct fd_drive drvchar; 1280 int temp; 1281 } cpy; 1282 struct vtoc vtoc; 1283 struct fcu_obj *fjp = NULL; 1284 struct fdisk *fdp = NULL; 1285 struct dk_map *dmp; 1286 struct dk_label *label; 1287 int nblks, part, unit; 1288 int rval = 0; 1289 enum dkio_state state; 1290 1291 unit = fd_getdrive(dev, &fjp, &fdp); 1292 if (!fjp || !fdp) 1293 return (ENXIO); 1294 1295 FDERRPRINT(FDEP_L1, FDEM_IOCT, 1296 (CE_CONT, "fd_ioctl fd unit %d: cmd %x, arg %lx\n", 1297 unit, cmd, arg)); 1298 1299 switch (cmd) { 1300 case DKIOCINFO: 1301 fjp->fj_ops->fco_dkinfo(fjp, &cpy.dki); 1302 cpy.dki.dki_cnum = FDCTLR(fjp->fj_unit); 1303 cpy.dki.dki_unit = FDUNIT(fjp->fj_unit); 1304 cpy.dki.dki_partition = PARTITION(dev); 1305 if (ddi_copyout(&cpy.dki, (void *)arg, sizeof (cpy.dki), flag)) 1306 rval = EFAULT; 1307 break; 1308 1309 case DKIOCG_PHYGEOM: 1310 case DKIOCG_VIRTGEOM: 1311 cpy.dkg.dkg_nsect = fjp->fj_chars->fdc_secptrack; 1312 goto get_geom; 1313 case DKIOCGGEOM: 1314 if (fjp->fj_flags & FUNIT_LABELOK) 1315 cpy.dkg.dkg_nsect = (fjp->fj_chars->fdc_secptrack * 1316 fjp->fj_chars->fdc_sec_size) / DEV_BSIZE; 1317 else 1318 cpy.dkg.dkg_nsect = fjp->fj_chars->fdc_secptrack; 1319 get_geom: 1320 cpy.dkg.dkg_pcyl = fjp->fj_chars->fdc_ncyl; 1321 cpy.dkg.dkg_ncyl = fjp->fj_chars->fdc_ncyl; 1322 cpy.dkg.dkg_nhead = fjp->fj_chars->fdc_nhead; 1323 cpy.dkg.dkg_intrlv = fjp->fj_attr->fda_intrlv; 1324 cpy.dkg.dkg_rpm = fjp->fj_attr->fda_rotatespd; 1325 cpy.dkg.dkg_read_reinstruct = 1326 (int)(cpy.dkg.dkg_nsect * cpy.dkg.dkg_rpm * 4) / 60000; 1327 cpy.dkg.dkg_write_reinstruct = cpy.dkg.dkg_read_reinstruct; 1328 if (ddi_copyout(&cpy.dkg, (void *)arg, sizeof (cpy.dkg), flag)) 1329 rval = EFAULT; 1330 break; 1331 1332 case DKIOCSGEOM: 1333 if (ddi_copyin((void *)arg, &cpy.dkg, 1334 sizeof (struct dk_geom), flag)) { 1335 rval = EFAULT; 1336 break; 1337 } 1338 mutex_enter(&fjp->fj_lock); 1339 fjp->fj_chars->fdc_ncyl = cpy.dkg.dkg_ncyl; 1340 fjp->fj_chars->fdc_nhead = cpy.dkg.dkg_nhead; 1341 fjp->fj_chars->fdc_secptrack = cpy.dkg.dkg_nsect; 1342 fjp->fj_attr->fda_intrlv = cpy.dkg.dkg_intrlv; 1343 fjp->fj_attr->fda_rotatespd = cpy.dkg.dkg_rpm; 1344 fdp->d_curfdtype = -1; 1345 mutex_exit(&fjp->fj_lock); 1346 break; 1347 1348 /* 1349 * return the map of all logical partitions 1350 */ 1351 case DKIOCGAPART: 1352 /* 1353 * Note the conversion from starting sector number 1354 * to starting cylinder number. 1355 * Return error if division results in a remainder. 1356 */ 1357 nblks = fjp->fj_chars->fdc_nhead * fjp->fj_chars->fdc_secptrack; 1358 1359 #ifdef _MULTI_DATAMODEL 1360 switch (ddi_model_convert_from(flag & FMODELS)) { 1361 case DDI_MODEL_ILP32: 1362 { 1363 struct dk_allmap32 dka32; 1364 1365 for (part = 0; part < NDKMAP; part++) { 1366 if ((fdp->d_part[part].p_start % nblks) != 0) 1367 return (EINVAL); 1368 dka32.dka_map[part].dkl_cylno = 1369 fdp->d_part[part].p_start / nblks; 1370 dka32.dka_map[part].dkl_nblk = 1371 fdp->d_part[part].p_size; 1372 } 1373 1374 if (ddi_copyout(&dka32, (void *)arg, 1375 sizeof (struct dk_allmap32), flag)) 1376 rval = EFAULT; 1377 1378 break; 1379 } 1380 case DDI_MODEL_NONE: 1381 1382 #endif /* _MULTI_DATAMODEL */ 1383 1384 dmp = (struct dk_map *)&cpy.dka; 1385 for (part = 0; part < NDKMAP; part++) { 1386 if ((fdp->d_part[part].p_start % nblks) != 0) 1387 return (EINVAL); 1388 dmp->dkl_cylno = 1389 fdp->d_part[part].p_start / nblks; 1390 dmp->dkl_nblk = fdp->d_part[part].p_size; 1391 dmp++; 1392 } 1393 1394 if (ddi_copyout(&cpy.dka, (void *)arg, 1395 sizeof (struct dk_allmap), flag)) 1396 rval = EFAULT; 1397 #ifdef _MULTI_DATAMODEL 1398 break; 1399 1400 } 1401 #endif /* _MULTI_DATAMODEL */ 1402 1403 break; 1404 1405 /* 1406 * Set the map of all logical partitions 1407 */ 1408 case DKIOCSAPART: 1409 1410 #ifdef _MULTI_DATAMODEL 1411 switch (ddi_model_convert_from(flag & FMODELS)) { 1412 case DDI_MODEL_ILP32: 1413 { 1414 struct dk_allmap32 dka32; 1415 1416 if (ddi_copyin((void *)arg, &dka32, 1417 sizeof (dka32), flag)) { 1418 rval = EFAULT; 1419 break; 1420 } 1421 for (part = 0; part < NDKMAP; part++) { 1422 cpy.dka.dka_map[part].dkl_cylno = 1423 dka32.dka_map[part].dkl_cylno; 1424 cpy.dka.dka_map[part].dkl_nblk = 1425 dka32.dka_map[part].dkl_nblk; 1426 } 1427 break; 1428 } 1429 case DDI_MODEL_NONE: 1430 1431 #endif /* _MULTI_DATAMODEL */ 1432 if (ddi_copyin((void *)arg, &cpy.dka, sizeof (cpy.dka), flag)) 1433 rval = EFAULT; 1434 #ifdef _MULTI_DATAMODEL 1435 1436 break; 1437 } 1438 #endif /* _MULTI_DATAMODEL */ 1439 1440 if (rval != 0) 1441 break; 1442 1443 dmp = (struct dk_map *)&cpy.dka; 1444 nblks = fjp->fj_chars->fdc_nhead * 1445 fjp->fj_chars->fdc_secptrack; 1446 mutex_enter(&fjp->fj_lock); 1447 /* 1448 * Note the conversion from starting cylinder number 1449 * to starting sector number. 1450 */ 1451 for (part = 0; part < NDKMAP; part++) { 1452 fdp->d_part[part].p_start = dmp->dkl_cylno * 1453 nblks; 1454 fdp->d_part[part].p_size = dmp->dkl_nblk; 1455 dmp++; 1456 } 1457 mutex_exit(&fjp->fj_lock); 1458 1459 break; 1460 1461 case DKIOCGVTOC: 1462 mutex_enter(&fjp->fj_lock); 1463 1464 /* 1465 * Exit if the diskette has no label. 1466 * Also, get the label to make sure the correct one is 1467 * being used since the diskette may have changed 1468 */ 1469 fjp->fj_ops->fco_select(fjp, unit, 1); 1470 rval = fdgetlabel(fjp, unit); 1471 fjp->fj_ops->fco_select(fjp, unit, 0); 1472 if (rval) { 1473 mutex_exit(&fjp->fj_lock); 1474 rval = EINVAL; 1475 break; 1476 } 1477 1478 fd_build_user_vtoc(fjp, fdp, &vtoc); 1479 mutex_exit(&fjp->fj_lock); 1480 1481 #ifdef _MULTI_DATAMODEL 1482 switch (ddi_model_convert_from(flag & FMODELS)) { 1483 case DDI_MODEL_ILP32: 1484 { 1485 struct vtoc32 vtoc32; 1486 1487 vtoctovtoc32(vtoc, vtoc32); 1488 1489 if (ddi_copyout(&vtoc32, (void *)arg, 1490 sizeof (vtoc32), flag)) 1491 rval = EFAULT; 1492 1493 break; 1494 } 1495 case DDI_MODEL_NONE: 1496 1497 #endif /* _MULTI_DATAMODEL */ 1498 if (ddi_copyout(&vtoc, (void *)arg, 1499 sizeof (vtoc), flag)) 1500 rval = EFAULT; 1501 #ifdef _MULTI_DATAMODEL 1502 break; 1503 } 1504 #endif /* _MULTI_DATAMODEL */ 1505 1506 break; 1507 1508 case DKIOCSVTOC: 1509 1510 #ifdef _MULTI_DATAMODEL 1511 switch (ddi_model_convert_from(flag & FMODELS)) { 1512 case DDI_MODEL_ILP32: 1513 { 1514 struct vtoc32 vtoc32; 1515 1516 if (ddi_copyin((void *)arg, &vtoc32, 1517 sizeof (vtoc32), flag)) { 1518 rval = EFAULT; 1519 break; 1520 } 1521 1522 vtoc32tovtoc(vtoc32, vtoc); 1523 1524 break; 1525 } 1526 case DDI_MODEL_NONE: 1527 1528 #endif /* _MULTI_DATAMODEL */ 1529 if (ddi_copyin((void *)arg, &vtoc, sizeof (vtoc), flag)) 1530 rval = EFAULT; 1531 #ifdef _MULTI_DATAMODEL 1532 break; 1533 } 1534 #endif /* _MULTI_DATAMODEL */ 1535 1536 if (rval != 0) 1537 break; 1538 1539 1540 label = kmem_zalloc(sizeof (struct dk_label), KM_SLEEP); 1541 1542 mutex_enter(&fjp->fj_lock); 1543 1544 if ((rval = fd_build_label_vtoc(fjp, fdp, &vtoc, label)) == 0) { 1545 fjp->fj_ops->fco_select(fjp, unit, 1); 1546 rval = fjp->fj_ops->fco_rw(fjp, unit, FDWRITE, 1547 0, 0, 1, (caddr_t)label, sizeof (struct dk_label)); 1548 fjp->fj_ops->fco_select(fjp, unit, 0); 1549 } 1550 mutex_exit(&fjp->fj_lock); 1551 kmem_free(label, sizeof (struct dk_label)); 1552 break; 1553 1554 case DKIOCSTATE: 1555 FDERRPRINT(FDEP_L1, FDEM_IOCT, 1556 (CE_CONT, "fd_ioctl fd unit %d: DKIOCSTATE\n", unit)); 1557 1558 if (ddi_copyin((void *)arg, &state, sizeof (int), flag)) { 1559 rval = EFAULT; 1560 break; 1561 } 1562 1563 rval = fd_check_media(dev, state); 1564 1565 if (ddi_copyout(&fdp->d_media_state, (void *)arg, 1566 sizeof (int), flag)) 1567 rval = EFAULT; 1568 break; 1569 1570 case FDIOGCHAR: 1571 if (ddi_copyout(fjp->fj_chars, (void *)arg, 1572 sizeof (struct fd_char), flag)) 1573 rval = EFAULT; 1574 break; 1575 1576 case FDIOSCHAR: 1577 if (ddi_copyin((void *)arg, &cpy.fdchar, 1578 sizeof (struct fd_char), flag)) { 1579 rval = EFAULT; 1580 break; 1581 } 1582 switch (cpy.fdchar.fdc_transfer_rate) { 1583 case 417: 1584 if ((fdp->d_media & (1 << FMT_3M)) == 0) { 1585 cmn_err(CE_CONT, 1586 "fdioschar:Medium density not supported\n"); 1587 rval = EINVAL; 1588 break; 1589 } 1590 mutex_enter(&fjp->fj_lock); 1591 fjp->fj_attr->fda_rotatespd = 360; 1592 mutex_exit(&fjp->fj_lock); 1593 /* cpy.fdchar.fdc_transfer_rate = 500; */ 1594 /* FALLTHROUGH */ 1595 case 1000: 1596 case 500: 1597 case 300: 1598 case 250: 1599 mutex_enter(&fjp->fj_lock); 1600 *(fjp->fj_chars) = cpy.fdchar; 1601 fdp->d_curfdtype = -1; 1602 fjp->fj_flags &= ~FUNIT_CHAROK; 1603 mutex_exit(&fjp->fj_lock); 1604 1605 break; 1606 1607 default: 1608 FDERRPRINT(FDEP_L4, FDEM_IOCT, 1609 (CE_WARN, "fd_ioctl fd unit %d: FDIOSCHAR odd " 1610 "xfer rate %dkbs", 1611 unit, cpy.fdchar.fdc_transfer_rate)); 1612 rval = EINVAL; 1613 break; 1614 } 1615 break; 1616 1617 /* 1618 * set all characteristics and geometry to the defaults 1619 */ 1620 case FDDEFGEOCHAR: 1621 mutex_enter(&fjp->fj_lock); 1622 fdp->d_curfdtype = fdp->d_deffdtype; 1623 *fjp->fj_chars = *defchar[fdp->d_curfdtype]; 1624 *fjp->fj_attr = fdtypes[fdp->d_curfdtype]; 1625 bcopy(fdparts[fdp->d_curfdtype], 1626 fdp->d_part, sizeof (struct partition) * NDKMAP); 1627 fjp->fj_flags &= ~FUNIT_CHAROK; 1628 mutex_exit(&fjp->fj_lock); 1629 break; 1630 1631 case FDEJECT: /* eject disk */ 1632 case DKIOCEJECT: 1633 fjp->fj_flags &= ~(FUNIT_LABELOK | FUNIT_UNLABELED); 1634 rval = ENOSYS; 1635 break; 1636 1637 case FDGETCHANGE: /* disk changed */ 1638 if (ddi_copyin((void *)arg, &cpy.temp, sizeof (int), flag)) { 1639 rval = EFAULT; 1640 break; 1641 } 1642 mutex_enter(&fjp->fj_lock); 1643 fjp->fj_ops->fco_select(fjp, unit, 1); 1644 1645 if (fjp->fj_flags & FUNIT_CHANGED) 1646 cpy.temp |= FDGC_HISTORY; 1647 else 1648 cpy.temp &= ~FDGC_HISTORY; 1649 fjp->fj_flags &= ~FUNIT_CHANGED; 1650 1651 if (fjp->fj_ops->fco_getchng(fjp, unit)) { 1652 cpy.temp |= FDGC_DETECTED; 1653 fjp->fj_ops->fco_resetchng(fjp, unit); 1654 /* 1655 * check diskette again only if it was removed 1656 */ 1657 if (fjp->fj_ops->fco_getchng(fjp, unit)) { 1658 /* 1659 * no diskette is present 1660 */ 1661 cpy.temp |= FDGC_CURRENT; 1662 if (fjp->fj_flags & FUNIT_CHGDET) 1663 /* 1664 * again no diskette; not a new change 1665 */ 1666 cpy.temp ^= FDGC_DETECTED; 1667 else 1668 fjp->fj_flags |= FUNIT_CHGDET; 1669 } else { 1670 /* 1671 * a new diskette is present 1672 */ 1673 cpy.temp &= ~FDGC_CURRENT; 1674 fjp->fj_flags &= ~FUNIT_CHGDET; 1675 } 1676 } else { 1677 cpy.temp &= ~(FDGC_DETECTED | FDGC_CURRENT); 1678 fjp->fj_flags &= ~FUNIT_CHGDET; 1679 } 1680 /* 1681 * also get state of write protection 1682 */ 1683 if (fjp->fj_flags & FUNIT_WPROT) { 1684 cpy.temp |= FDGC_CURWPROT; 1685 } else { 1686 cpy.temp &= ~FDGC_CURWPROT; 1687 } 1688 fjp->fj_ops->fco_select(fjp, unit, 0); 1689 mutex_exit(&fjp->fj_lock); 1690 1691 if (ddi_copyout(&cpy.temp, (void *)arg, sizeof (int), flag)) 1692 rval = EFAULT; 1693 break; 1694 1695 case FDGETDRIVECHAR: 1696 if (ddi_copyout(fjp->fj_drive, (void *)arg, 1697 sizeof (struct fd_drive), flag)) 1698 rval = EFAULT; 1699 break; 1700 1701 case FDSETDRIVECHAR: 1702 if (ddi_copyin((void *)arg, &cpy.drvchar, 1703 sizeof (struct fd_drive), flag)) { 1704 rval = EFAULT; 1705 break; 1706 } 1707 mutex_enter(&fjp->fj_lock); 1708 *(fjp->fj_drive) = cpy.drvchar; 1709 fdp->d_curfdtype = -1; 1710 fjp->fj_flags &= ~FUNIT_CHAROK; 1711 mutex_exit(&fjp->fj_lock); 1712 break; 1713 1714 case DKIOCREMOVABLE: { 1715 int i = 1; 1716 1717 /* no brainer: floppies are always removable */ 1718 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag)) { 1719 rval = EFAULT; 1720 } 1721 break; 1722 } 1723 1724 case DKIOCGMEDIAINFO: 1725 rval = fd_get_media_info(fjp, (caddr_t)arg, flag); 1726 break; 1727 1728 case FDIOCMD: 1729 { 1730 struct fd_cmd fc; 1731 int cyl, head, spc, spt; 1732 1733 #ifdef _MULTI_DATAMODEL 1734 switch (ddi_model_convert_from(flag & FMODELS)) { 1735 case DDI_MODEL_ILP32: 1736 { 1737 struct fd_cmd32 fc32; 1738 1739 if (ddi_copyin((void *)arg, &fc32, 1740 sizeof (fc32), flag)) { 1741 rval = EFAULT; 1742 break; 1743 } 1744 1745 fc.fdc_cmd = fc32.fdc_cmd; 1746 fc.fdc_flags = fc32.fdc_flags; 1747 fc.fdc_blkno = fc32.fdc_blkno; 1748 fc.fdc_secnt = fc32.fdc_secnt; 1749 fc.fdc_bufaddr = (caddr_t)(uintptr_t)fc32.fdc_bufaddr; 1750 fc.fdc_buflen = fc32.fdc_buflen; 1751 1752 break; 1753 } 1754 case DDI_MODEL_NONE: 1755 1756 #endif /* _MULTI_DATAMODEL */ 1757 1758 if (ddi_copyin((void *)arg, &fc, sizeof (fc), flag)) { 1759 rval = EFAULT; 1760 break; 1761 } 1762 #ifdef _MULTI_DATAMODEL 1763 break; 1764 } 1765 #endif /* _MULTI_DATAMODEL */ 1766 1767 if (rval != 0) 1768 break; 1769 1770 if (fc.fdc_cmd == FDCMD_READ || fc.fdc_cmd == FDCMD_WRITE) { 1771 auto struct iovec aiov; 1772 auto struct uio auio; 1773 struct uio *uio = &auio; 1774 1775 spc = (fc.fdc_cmd == FDCMD_READ)? B_READ: B_WRITE; 1776 1777 bzero(&auio, sizeof (struct uio)); 1778 bzero(&aiov, sizeof (struct iovec)); 1779 aiov.iov_base = fc.fdc_bufaddr; 1780 aiov.iov_len = (uint_t)fc.fdc_secnt * 1781 fjp->fj_chars->fdc_sec_size; 1782 uio->uio_iov = &aiov; 1783 1784 uio->uio_iovcnt = 1; 1785 uio->uio_resid = aiov.iov_len; 1786 uio->uio_segflg = UIO_USERSPACE; 1787 1788 rval = physio(fd_strategy, (struct buf *)0, dev, 1789 spc, minphys, uio); 1790 break; 1791 } else if (fc.fdc_cmd == FDCMD_FORMAT_TRACK) { 1792 spt = fjp->fj_chars->fdc_secptrack; /* sec/trk */ 1793 spc = fjp->fj_chars->fdc_nhead * spt; /* sec/cyl */ 1794 cyl = fc.fdc_blkno / spc; 1795 head = (fc.fdc_blkno % spc) / spt; 1796 if ((cyl | head) == 0) 1797 fjp->fj_flags &= 1798 ~(FUNIT_LABELOK | FUNIT_UNLABELED); 1799 1800 FDERRPRINT(FDEP_L0, FDEM_FORM, 1801 (CE_CONT, "fd_format cyl %d, hd %d\n", cyl, head)); 1802 fjp->fj_ops->fco_select(fjp, unit, 1); 1803 rval = fjp->fj_ops->fco_format(fjp, unit, cyl, head, 1804 (int)fc.fdc_flags); 1805 fjp->fj_ops->fco_select(fjp, unit, 0); 1806 1807 break; 1808 } 1809 FDERRPRINT(FDEP_L4, FDEM_IOCT, 1810 (CE_WARN, "fd_ioctl fd unit %d: FDIOCSCMD not yet complete", 1811 unit)); 1812 rval = EINVAL; 1813 break; 1814 } 1815 1816 case FDRAW: 1817 rval = fd_rawioctl(fjp, unit, (caddr_t)arg, flag); 1818 break; 1819 1820 default: 1821 FDERRPRINT(FDEP_L4, FDEM_IOCT, 1822 (CE_WARN, "fd_ioctl fd unit %d: invalid ioctl 0x%x", 1823 unit, cmd)); 1824 rval = ENOTTY; 1825 break; 1826 } 1827 return (rval); 1828 } 1829 1830 static void 1831 fd_build_user_vtoc(struct fcu_obj *fjp, struct fdisk *fdp, struct vtoc *vtocp) 1832 { 1833 struct partition *vpart; 1834 int i; 1835 int xblk; 1836 1837 /* 1838 * Return vtoc structure fields in the provided VTOC area, addressed 1839 * by *vtocp. 1840 * 1841 */ 1842 bzero(vtocp, sizeof (struct vtoc)); 1843 1844 bcopy(fdp->d_vtoc_bootinfo, 1845 vtocp->v_bootinfo, sizeof (vtocp->v_bootinfo)); 1846 1847 vtocp->v_sanity = VTOC_SANE; 1848 vtocp->v_version = fdp->d_vtoc_version; 1849 bcopy(fdp->d_vtoc_volume, vtocp->v_volume, LEN_DKL_VVOL); 1850 if (fjp->fj_flags & FUNIT_LABELOK) { 1851 vtocp->v_sectorsz = DEV_BSIZE; 1852 xblk = 1; 1853 } else { 1854 vtocp->v_sectorsz = fjp->fj_chars->fdc_sec_size; 1855 xblk = vtocp->v_sectorsz / DEV_BSIZE; 1856 } 1857 vtocp->v_nparts = 3; /* <= NDKMAP; */ 1858 1859 /* 1860 * Copy partitioning information. 1861 */ 1862 bcopy(fdp->d_part, vtocp->v_part, sizeof (struct partition) * NDKMAP); 1863 for (i = NDKMAP, vpart = vtocp->v_part; i && (xblk > 1); i--, vpart++) { 1864 /* correct partition info if sector size > 512 bytes */ 1865 vpart->p_start /= xblk; 1866 vpart->p_size /= xblk; 1867 } 1868 1869 bcopy(fdp->d_vtoc_timestamp, 1870 vtocp->timestamp, sizeof (fdp->d_vtoc_timestamp)); 1871 bcopy(fdp->d_vtoc_asciilabel, vtocp->v_asciilabel, LEN_DKL_ASCII); 1872 } 1873 1874 1875 static int 1876 fd_build_label_vtoc(struct fcu_obj *fjp, struct fdisk *fdp, struct vtoc *vtocp, 1877 struct dk_label *labelp) 1878 { 1879 struct partition *vpart; 1880 int i; 1881 int nblks; 1882 int ncyl; 1883 ushort_t sum, *sp; 1884 1885 1886 /* 1887 * Sanity-check the vtoc 1888 */ 1889 if (vtocp->v_sanity != VTOC_SANE || 1890 vtocp->v_nparts > NDKMAP || vtocp->v_nparts <= 0) { 1891 FDERRPRINT(FDEP_L3, FDEM_IOCT, 1892 (CE_WARN, "fd_build_label: sanity check on vtoc failed")); 1893 return (EINVAL); 1894 } 1895 1896 /* 1897 * before copying the vtoc, the partition information in it should be 1898 * checked against the information the driver already has on the 1899 * diskette. 1900 */ 1901 1902 nblks = (fjp->fj_chars->fdc_nhead * fjp->fj_chars->fdc_secptrack * 1903 fjp->fj_chars->fdc_sec_size) / DEV_BSIZE; 1904 if (nblks == 0 || fjp->fj_chars->fdc_ncyl == 0) 1905 return (EFAULT); 1906 vpart = vtocp->v_part; 1907 1908 /* 1909 * Check the partition information in the vtoc. The starting sectors 1910 * must lie along cylinder boundaries. (NDKMAP entries are checked 1911 * to ensure that the unused entries are set to 0 if vtoc->v_nparts 1912 * is less than NDKMAP) 1913 */ 1914 for (i = NDKMAP; i; i--) { 1915 if ((vpart->p_start % nblks) != 0) { 1916 return (EINVAL); 1917 } 1918 ncyl = vpart->p_start / nblks; 1919 ncyl += vpart->p_size / nblks; 1920 if ((vpart->p_size % nblks) != 0) 1921 ncyl++; 1922 if (ncyl > (long)fjp->fj_chars->fdc_ncyl) { 1923 return (EINVAL); 1924 } 1925 vpart++; 1926 } 1927 1928 1929 bcopy(vtocp->v_bootinfo, fdp->d_vtoc_bootinfo, 1930 sizeof (vtocp->v_bootinfo)); 1931 fdp->d_vtoc_version = vtocp->v_version; 1932 bcopy(vtocp->v_volume, fdp->d_vtoc_volume, LEN_DKL_VVOL); 1933 1934 /* 1935 * Copy partitioning information. 1936 */ 1937 bcopy(vtocp->v_part, fdp->d_part, sizeof (struct partition) * NDKMAP); 1938 bcopy(vtocp->timestamp, fdp->d_vtoc_timestamp, 1939 sizeof (fdp->d_vtoc_timestamp)); 1940 bcopy(vtocp->v_asciilabel, fdp->d_vtoc_asciilabel, LEN_DKL_ASCII); 1941 1942 /* 1943 * construct the diskette label in supplied buffer 1944 */ 1945 1946 /* Put appropriate vtoc structure fields into the disk label */ 1947 labelp->dkl_vtoc.v_bootinfo[0] = (uint32_t)vtocp->v_bootinfo[0]; 1948 labelp->dkl_vtoc.v_bootinfo[1] = (uint32_t)vtocp->v_bootinfo[1]; 1949 labelp->dkl_vtoc.v_bootinfo[2] = (uint32_t)vtocp->v_bootinfo[2]; 1950 1951 labelp->dkl_vtoc.v_sanity = vtocp->v_sanity; 1952 labelp->dkl_vtoc.v_version = vtocp->v_version; 1953 1954 bcopy(vtocp->v_volume, labelp->dkl_vtoc.v_volume, LEN_DKL_VVOL); 1955 1956 labelp->dkl_vtoc.v_nparts = vtocp->v_nparts; 1957 1958 bcopy(vtocp->v_reserved, labelp->dkl_vtoc.v_reserved, 1959 sizeof (labelp->dkl_vtoc.v_reserved)); 1960 1961 for (i = 0; i < (int)vtocp->v_nparts; i++) { 1962 labelp->dkl_vtoc.v_part[i].p_tag = vtocp->v_part[i].p_tag; 1963 labelp->dkl_vtoc.v_part[i].p_flag = vtocp->v_part[i].p_flag; 1964 labelp->dkl_vtoc.v_part[i].p_start = vtocp->v_part[i].p_start; 1965 labelp->dkl_vtoc.v_part[i].p_size = vtocp->v_part[i].p_size; 1966 } 1967 1968 for (i = 0; i < NDKMAP; i++) { 1969 labelp->dkl_vtoc.v_timestamp[i] = vtocp->timestamp[i]; 1970 } 1971 bcopy(vtocp->v_asciilabel, labelp->dkl_asciilabel, LEN_DKL_ASCII); 1972 1973 1974 labelp->dkl_pcyl = fjp->fj_chars->fdc_ncyl; 1975 labelp->dkl_ncyl = fjp->fj_chars->fdc_ncyl; 1976 labelp->dkl_nhead = fjp->fj_chars->fdc_nhead; 1977 /* 1978 * The fdc_secptrack field of the fd_char structure is the number 1979 * of sectors per track where the sectors are fdc_sec_size. 1980 * The dkl_nsect field of the dk_label structure is the number of 1981 * DEV_BSIZE (512) byte sectors per track. 1982 */ 1983 labelp->dkl_nsect = (fjp->fj_chars->fdc_secptrack * 1984 fjp->fj_chars->fdc_sec_size) / DEV_BSIZE; 1985 labelp->dkl_intrlv = fjp->fj_attr->fda_intrlv; 1986 labelp->dkl_rpm = fjp->fj_attr->fda_rotatespd; 1987 labelp->dkl_read_reinstruct = 1988 (int)(labelp->dkl_nsect * labelp->dkl_rpm * 4) / 60000; 1989 labelp->dkl_write_reinstruct = labelp->dkl_read_reinstruct; 1990 1991 labelp->dkl_magic = DKL_MAGIC; 1992 1993 sum = 0; 1994 labelp->dkl_cksum = 0; 1995 sp = (ushort_t *)labelp; 1996 while (sp < &(labelp->dkl_cksum)) { 1997 sum ^= *sp++; 1998 } 1999 labelp->dkl_cksum = sum; 2000 2001 return (0); 2002 } 2003 2004 static int 2005 fd_rawioctl(struct fcu_obj *fjp, int unit, caddr_t arg, int mode) 2006 { 2007 struct fd_raw fdr; 2008 char *arg_result = NULL; 2009 int flag = B_READ; 2010 int rval = 0; 2011 caddr_t uaddr; 2012 uint_t ucount; 2013 2014 FDERRPRINT(FDEP_L1, FDEM_RAWI, 2015 (CE_CONT, "fd_rawioctl: cmd[0]=0x%x\n", fdr.fdr_cmd[0])); 2016 2017 if (fjp->fj_chars->fdc_medium != 3 && fjp->fj_chars->fdc_medium != 5) { 2018 cmn_err(CE_CONT, "fd_rawioctl: Medium density not supported\n"); 2019 return (ENXIO); 2020 } 2021 2022 #ifdef _MULTI_DATAMODEL 2023 switch (ddi_model_convert_from(mode & FMODELS)) { 2024 case DDI_MODEL_ILP32: 2025 { 2026 struct fd_raw32 fdr32; 2027 2028 if (ddi_copyin(arg, &fdr32, sizeof (fdr32), mode)) 2029 return (EFAULT); 2030 2031 bcopy(fdr32.fdr_cmd, fdr.fdr_cmd, sizeof (fdr.fdr_cmd)); 2032 fdr.fdr_cnum = fdr32.fdr_cnum; 2033 fdr.fdr_nbytes = fdr32.fdr_nbytes; 2034 fdr.fdr_addr = (caddr_t)(uintptr_t)fdr32.fdr_addr; 2035 arg_result = ((struct fd_raw32 *)arg)->fdr_result; 2036 2037 break; 2038 } 2039 case DDI_MODEL_NONE: 2040 #endif /* ! _MULTI_DATAMODEL */ 2041 2042 if (ddi_copyin(arg, &fdr, sizeof (fdr), mode)) 2043 return (EFAULT); 2044 2045 arg_result = ((struct fd_raw *)arg)->fdr_result; 2046 2047 #ifdef _MULTI_DATAMODEL 2048 break; 2049 } 2050 #endif /* _MULTI_DATAMODEL */ 2051 2052 2053 2054 /* 2055 * copy user address & nbytes from raw_req so that we can 2056 * put kernel address in req structure 2057 */ 2058 uaddr = fdr.fdr_addr; 2059 ucount = (uint_t)fdr.fdr_nbytes; 2060 unit &= 3; 2061 2062 switch (fdr.fdr_cmd[0] & 0x0f) { 2063 2064 case FDRAW_FORMAT: 2065 ucount += 16; 2066 fdr.fdr_addr = kmem_zalloc(ucount, KM_SLEEP); 2067 if (ddi_copyin(uaddr, fdr.fdr_addr, 2068 (size_t)fdr.fdr_nbytes, mode)) { 2069 kmem_free(fdr.fdr_addr, ucount); 2070 return (EFAULT); 2071 } 2072 if ((*fdr.fdr_addr | fdr.fdr_addr[1]) == 0) 2073 fjp->fj_flags &= ~(FUNIT_LABELOK | FUNIT_UNLABELED); 2074 flag = B_WRITE; 2075 fdr.fdr_cmd[1] = (fdr.fdr_cmd[1] & ~3) | unit; 2076 break; 2077 2078 case FDRAW_WRCMD: 2079 case FDRAW_WRITEDEL: 2080 flag = B_WRITE; 2081 /* FALLTHROUGH */ 2082 case FDRAW_RDCMD: 2083 case FDRAW_READDEL: 2084 case FDRAW_READTRACK: 2085 if (ucount) { 2086 /* 2087 * In SunOS 4.X, we used to as_fault things in. 2088 * We really cannot do this in 5.0/SVr4. Unless 2089 * someone really believes that speed is of the 2090 * essence here, it is just much simpler to do 2091 * this in kernel space and use copyin/copyout. 2092 */ 2093 fdr.fdr_addr = kmem_alloc((size_t)ucount, KM_SLEEP); 2094 if (flag == B_WRITE) { 2095 if (ddi_copyin(uaddr, fdr.fdr_addr, ucount, 2096 mode)) { 2097 kmem_free(fdr.fdr_addr, ucount); 2098 return (EFAULT); 2099 } 2100 } 2101 } else 2102 return (EINVAL); 2103 fdr.fdr_cmd[1] = (fdr.fdr_cmd[1] & ~3) | unit; 2104 break; 2105 2106 case FDRAW_READID: 2107 case FDRAW_REZERO: 2108 case FDRAW_SEEK: 2109 case FDRAW_SENSE_DRV: 2110 ucount = 0; 2111 fdr.fdr_cmd[1] = (fdr.fdr_cmd[1] & ~3) | unit; 2112 break; 2113 2114 case FDRAW_SPECIFY: 2115 fdr.fdr_cmd[2] &= 0xfe; /* keep NoDMA bit clear */ 2116 /* FALLTHROUGH */ 2117 case FDRAW_SENSE_INT: 2118 ucount = 0; 2119 break; 2120 2121 default: 2122 return (EINVAL); 2123 } 2124 2125 /* 2126 * Note that we ignore any error returns from controller 2127 * This is the way the driver has been, and it may be 2128 * that the raw ioctl senders simply don't want to 2129 * see any errors returned in this fashion. 2130 */ 2131 2132 fjp->fj_ops->fco_select(fjp, unit, 1); 2133 rval = fjp->fj_ops->fco_rwioctl(fjp, unit, (caddr_t)&fdr); 2134 2135 if (ucount && flag == B_READ && rval == 0) { 2136 if (ddi_copyout(fdr.fdr_addr, uaddr, ucount, mode)) { 2137 rval = EFAULT; 2138 } 2139 } 2140 if (ddi_copyout(fdr.fdr_result, arg_result, sizeof (fdr.fdr_cmd), mode)) 2141 rval = EFAULT; 2142 2143 fjp->fj_ops->fco_select(fjp, unit, 0); 2144 if (ucount) 2145 kmem_free(fdr.fdr_addr, ucount); 2146 2147 return (rval); 2148 } 2149 2150 /* 2151 * property operation routine. return the number of blocks for the partition 2152 * in question or forward the request to the property facilities. 2153 */ 2154 static int 2155 fd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags, 2156 char *name, caddr_t valuep, int *lengthp) 2157 { 2158 struct fcu_obj *fjp = NULL; 2159 struct fdisk *fdp = NULL; 2160 uint64_t nblocks64; 2161 2162 FDERRPRINT(FDEP_L1, FDEM_PROP, 2163 (CE_CONT, "fd_prop_op: dip %p %s\n", (void *)dip, name)); 2164 2165 /* 2166 * Our dynamic properties are all device specific and size oriented. 2167 * Requests issued under conditions where size is valid are passed 2168 * to ddi_prop_op_nblocks with the size information, otherwise the 2169 * request is passed to ddi_prop_op. 2170 */ 2171 if (dev == DDI_DEV_T_ANY) { 2172 pass: return (ddi_prop_op(dev, dip, prop_op, mod_flags, 2173 name, valuep, lengthp)); 2174 } else { 2175 /* 2176 * Ignoring return value because success is checked by 2177 * verifying fjp and fdp and returned unit value is not used. 2178 */ 2179 (void) fd_getdrive(dev, &fjp, &fdp); 2180 if (!fjp || !fdp) 2181 goto pass; 2182 2183 /* get nblocks value */ 2184 nblocks64 = (ulong_t)fdp->d_part[PARTITION(dev)].p_size; 2185 2186 return (ddi_prop_op_nblocks(dev, dip, prop_op, mod_flags, 2187 name, valuep, lengthp, nblocks64)); 2188 } 2189 } 2190 2191 static void 2192 fd_media_watch(void *arg) 2193 { 2194 struct fcu_obj *fjp; 2195 struct fdisk *fdp; 2196 2197 #ifdef DEBUG 2198 int unit; 2199 #define DEBUG_ASSIGN unit= 2200 #else 2201 #define DEBUG_ASSIGN (void) 2202 #endif 2203 DEBUG_ASSIGN fd_getdrive((dev_t)arg, &fjp, &fdp); 2204 /* 2205 * Ignoring return in non DEBUG mode because device exist. 2206 * Returned unit value is not used. 2207 */ 2208 2209 FDERRPRINT(FDEP_L0, FDEM_IOCT, 2210 (CE_CONT, "fd_media_watch unit %d\n", unit)); 2211 2212 /* 2213 * fd_get_media_state() cannot be called from this timeout function 2214 * because the floppy drive has to be selected first, and that could 2215 * force this function to sleep (while waiting for the select 2216 * semaphore). 2217 * Instead, just wakeup up driver. 2218 */ 2219 mutex_enter(&fjp->fj_lock); 2220 cv_broadcast(&fdp->d_statecv); 2221 mutex_exit(&fjp->fj_lock); 2222 } 2223 2224 enum dkio_state 2225 fd_get_media_state(struct fcu_obj *fjp, int unit) 2226 { 2227 enum dkio_state state; 2228 2229 if (fjp->fj_ops->fco_getchng(fjp, unit)) { 2230 /* recheck disk only if DSKCHG "high" */ 2231 fjp->fj_ops->fco_resetchng(fjp, unit); 2232 if (fjp->fj_ops->fco_getchng(fjp, unit)) { 2233 if (fjp->fj_flags & FUNIT_CHGDET) { 2234 /* 2235 * again no diskette; not a new change 2236 */ 2237 state = DKIO_NONE; 2238 } else { 2239 /* 2240 * a new change; diskette was ejected 2241 */ 2242 fjp->fj_flags |= FUNIT_CHGDET; 2243 state = DKIO_EJECTED; 2244 } 2245 } else { 2246 fjp->fj_flags &= ~FUNIT_CHGDET; 2247 state = DKIO_INSERTED; 2248 } 2249 } else { 2250 fjp->fj_flags &= ~FUNIT_CHGDET; 2251 state = DKIO_INSERTED; 2252 } 2253 FDERRPRINT(FDEP_L0, FDEM_IOCT, 2254 (CE_CONT, "fd_get_media_state unit %d: state %x\n", unit, state)); 2255 return (state); 2256 } 2257 2258 static int 2259 fd_check_media(dev_t dev, enum dkio_state state) 2260 { 2261 struct fcu_obj *fjp; 2262 struct fdisk *fdp; 2263 int unit; 2264 int err; 2265 2266 unit = fd_getdrive(dev, &fjp, &fdp); 2267 2268 mutex_enter(&fjp->fj_lock); 2269 2270 fjp->fj_ops->fco_select(fjp, unit, 1); 2271 fdp->d_media_state = fd_get_media_state(fjp, unit); 2272 fdp->d_media_timeout = drv_usectohz(fd_check_media_time); 2273 2274 while (fdp->d_media_state == state) { 2275 /* release the controller and drive */ 2276 fjp->fj_ops->fco_select(fjp, unit, 0); 2277 2278 /* turn on timer */ 2279 fdp->d_media_timeout_id = timeout(fd_media_watch, 2280 (void *)dev, fdp->d_media_timeout); 2281 2282 if (cv_wait_sig(&fdp->d_statecv, &fjp->fj_lock) == 0) { 2283 fdp->d_media_timeout = 0; 2284 mutex_exit(&fjp->fj_lock); 2285 return (EINTR); 2286 } 2287 fjp->fj_ops->fco_select(fjp, unit, 1); 2288 fdp->d_media_state = fd_get_media_state(fjp, unit); 2289 } 2290 2291 if (fdp->d_media_state == DKIO_INSERTED) { 2292 err = fdgetlabel(fjp, unit); 2293 if (err) { 2294 fjp->fj_ops->fco_select(fjp, unit, 0); 2295 mutex_exit(&fjp->fj_lock); 2296 return (EIO); 2297 } 2298 } 2299 fjp->fj_ops->fco_select(fjp, unit, 0); 2300 mutex_exit(&fjp->fj_lock); 2301 return (0); 2302 } 2303 2304 /* 2305 * fd_get_media_info : 2306 * Collects medium information for 2307 * DKIOCGMEDIAINFO ioctl. 2308 */ 2309 2310 static int 2311 fd_get_media_info(struct fcu_obj *fjp, caddr_t buf, int flag) 2312 { 2313 struct dk_minfo media_info; 2314 int err = 0; 2315 2316 media_info.dki_media_type = DK_FLOPPY; 2317 media_info.dki_lbsize = fjp->fj_chars->fdc_sec_size; 2318 media_info.dki_capacity = fjp->fj_chars->fdc_ncyl * 2319 fjp->fj_chars->fdc_secptrack * fjp->fj_chars->fdc_nhead; 2320 2321 if (ddi_copyout(&media_info, buf, sizeof (struct dk_minfo), flag)) 2322 err = EFAULT; 2323 return (err); 2324 } 2325
Indexes created Thu Nov 26 09:50:34 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.