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.
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.
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]
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
33 * CMOS_CONF_MEM: CMOS memory contains configuration info
37 #include <sys/types.h>
38 #include <sys/param.h>
39 #include <sys/systm.h>
43 #include <sys/ioctl.h>
47 #include <sys/autoconf.h>
51 #include <sys/sunddi.h>
52 #include <sys/kstat.h>
54 #include <sys/ddidmareq.h>
57 #include <sys/fd_debug.h>
58 #include <sys/fdmedia.h>
59 #include <sys/debug.h>
60 #include <sys/modctl.h>
63 * Local Function Prototypes
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
*,
72 static int fd_rawioctl(struct fcu_obj
*, int, caddr_t
, int);
73 static void fd_media_watch(void *);
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 *,
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
);
86 static struct cb_ops fd_cb_ops
= {
89 fd_strategy
, /* strategy */
99 fd_prop_op
, /* cb_prop_op */
101 D_NEW
| D_MP
/* Driver compatibility flag */
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
);
109 static struct dev_ops fd_ops
= {
110 DEVO_REV
, /* devo_rev, */
112 fd_getinfo
, /* getinfo */
113 nulldev
, /* identify */
114 fd_probe
, /* probe */
115 fd_attach
, /* attach */
116 fd_detach
, /* detach */
118 &fd_cb_ops
, /* driver operations */
119 (struct bus_ops
*)0, /* bus operations */
121 ddi_quiesce_not_supported
, /* devo_quiesce */
128 static void *fd_state_head
; /* opaque handle top of state structs */
129 static int fd_check_media_time
= 5000000; /* 5 second state check */
135 * set fderrlevel to 1
136 * set fderrmask to 224 or 644
139 static uint_t fderrmask
= FDEM_ALL
;
141 static int fderrlevel
= 5;
143 #define KIOSP KSTAT_IO_PTR(fdp->d_iostat)
145 static struct driver_minor_data
{
153 { "a,raw", 0, S_IFCHR
},
154 { "b,raw", 1, S_IFCHR
},
155 { "c,raw", 2, S_IFCHR
},
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 */
165 static struct modlinkage modlinkage
= {
166 MODREV_1
, (void *)&modldrv
, NULL
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)
180 if ((retval
= mod_install(&modlinkage
)) != 0)
181 ddi_soft_state_fini(&fd_state_head
);
190 if ((retval
= mod_remove(&modlinkage
)) != 0)
192 ddi_soft_state_fini(&fd_state_head
);
197 _info(struct modinfo
*modinfop
)
199 return (mod_info(&modlinkage
, modinfop
));
204 fd_getdrive(dev_t dev
, struct fcu_obj
**fjpp
, struct fdisk
**fdpp
)
207 *fdpp
= ddi_get_soft_state(fd_state_head
, DRIVE(dev
));
209 *fjpp
= (*fdpp
)->d_obj
;
211 return ((*fjpp
)->fj_unit
);
219 fd_getinfo(dev_info_t
*dip
, ddi_info_cmd_t cmd
, void *arg
, void **result
)
221 dev_t dev
= (dev_t
)arg
;
222 struct fcu_obj
*fjp
= NULL
;
223 struct fdisk
*fdp
= NULL
;
227 case DDI_INFO_DEVT2DEVINFO
:
228 (void) fd_getdrive(dev
, &fjp
, &fdp
);
230 * Ignoring return value because success is checked by
231 * verifying fjp and fdp and returned unit value is not used.
234 *result
= fjp
->fj_dip
;
239 case DDI_INFO_DEVT2INSTANCE
:
240 *result
= (void *)(uintptr_t)DRIVE(dev
);
250 #define CMOS_ADDR 0x70
251 #define CMOS_DATA 0x71
252 #define CMOS_FDRV 0x10
253 #endif /* CMOS_CONF_MEM */
256 fd_probe(dev_info_t
*dip
)
261 #endif /* CMOS_CONF_MEM */
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
) ==
272 fderrlevel
= debug
[0];
274 fderrmask
= (uint_t
)debug
[1];
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
) !=
281 FDERRPRINT(FDEP_L3
, FDEM_ATTA
,
282 (CE_WARN
, "fd_probe failed: dip %p", (void *)dip
));
283 return (DDI_PROBE_FAILURE
);
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 */
295 drive_type
= drive_type
>> 4;
298 if (cmos
&& (drive_type
& 0x0F)) {
302 * Some enhanced floppy-disk controller adaptor cards
303 * require NO drives defined in the CMOS configuration
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
) !=
313 FDERRPRINT(FDEP_L3
, FDEM_ATTA
,
315 "fd_probe failed density: dip %p unit %d",
316 (void *)dip
, unit_num
));
317 return (DDI_PROBE_FAILURE
);
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
) !=
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
);
329 FDERRPRINT(FDEP_L3
, FDEM_ATTA
,
330 (CE_WARN
, "fd_probe dip %p unit %d", (void *)dip
, unit_num
));
331 return (DDI_PROBE_SUCCESS
);
337 fd_attach(dev_info_t
*dip
, ddi_attach_cmd_t cmd
)
341 struct driver_minor_data
*dmdp
;
343 int drive_num
, drive_size
, drive_type
;
346 #endif /* CMOS_CONF_MEM */
350 char name
[MAXNAMELEN
];
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
) !=
358 FDERRPRINT(FDEP_L3
, FDEM_ATTA
,
359 (CE_WARN
, "fd_attach failed: dip %p", (void *)dip
));
360 return (DDI_FAILURE
);
364 outb(CMOS_ADDR
, CMOS_FDRV
);
365 cmos
= drive_type
= (int)inb(CMOS_DATA
);
366 #endif /* CMOS_CONF_MEM */
371 drive_type
= drive_type
>> 4;
374 drive_type
= drive_type
& 0x0F;
378 * Some enhanced floppy-disk controller adaptor cards
379 * require NO drives defined in the CMOS configuration
383 #endif /* CMOS_CONF_MEM */
384 default: /* need to check .conf file */
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
)
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
)
396 if (strcmp(density
, "DSDD") == 0) {
399 else if (drive_size
== 3)
401 } else if (strcmp(density
, "DSHD") == 0) {
404 else if (drive_size
== 3)
406 } else if (strcmp(density
, "DSED") == 0 &&
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
);
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
);
425 mutex_init(&fjp
->fj_lock
, NULL
, MUTEX_DRIVER
, *fjp
->fj_iblock
);
426 sema_init(&fdp
->d_ocsem
, 1, NULL
, SEMA_DRIVER
, NULL
);
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);
433 * set default floppy drive characteristics & geometry
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
;
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
)
450 if (mode_3D
&& (fjp
->fj_fdc
->c_flags
& FCFLG_3DMODE
))
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.
456 fdp
->d_media
|= 1 << FMT_3M
;
457 fdp
->d_deffdtype
= fdp
->d_curfdtype
= FMT_3H
;
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
|
463 fdp
->d_deffdtype
= fdp
->d_curfdtype
= FMT_5D9
;
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
;
470 case 5: /* 3.5 extended density */
473 *fjp
->fj_drive
= dfd_350ED
;
474 fdp
->d_media
= 1<<FMT_3E
| 1<<FMT_3H
| 1<<FMT_3I
|
476 fdp
->d_deffdtype
= fdp
->d_curfdtype
= FMT_3E
;
478 case 0: /* no drive defined */
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
;
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
)
493 ddi_remove_minor_node(dip
, NULL
);
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
);
505 fdp
->d_iostat
->ks_lock
= &fjp
->fj_lock
;
506 kstat_install(fdp
->d_iostat
);
509 fjp
->fj_data
= (caddr_t
)fdp
;
510 fjp
->fj_flags
|= FUNIT_DRVATCH
;
513 * Add a zero-length attribute to tell the world we support
514 * kernel ioctls (for layered drivers)
516 (void) ddi_prop_create(DDI_DEV_T_NONE
, dip
, DDI_PROP_CANSLEEP
,
517 DDI_KERNEL_IOCTL
, NULL
, 0);
520 * We want to get suspend/resume events, so that we can
521 * refuse to suspend when pcfs is mounted.
523 (void) ddi_prop_update_string(DDI_DEV_T_NONE
, dip
,
524 "pm-hardware-state", "needs-suspend-resume");
527 * Ignoring return value because, for passed arguments, only
528 * DDI_SUCCESS is returned.
531 return (DDI_SUCCESS
);
534 /* nothing for us to do */
535 return (DDI_SUCCESS
);
538 return (DDI_FAILURE
);
541 fjp
->fj_drive
= NULL
;
542 fjp
->fj_chars
= 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
);
556 fd_detach(dev_info_t
*dip
, ddi_detach_cmd_t cmd
)
561 int rval
= DDI_SUCCESS
;
563 FDERRPRINT(FDEP_L3
, FDEM_ATTA
, (CE_WARN
, "fd_detach dip %p",
566 drive_num
= ddi_get_instance(dip
);
567 if (!(fdp
= ddi_get_soft_state(fd_state_head
, drive_num
)))
572 if (fd_unit_is_open(fdp
)) {
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
;
581 fjp
->fj_drive
= NULL
;
582 fjp
->fj_chars
= 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
);
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!)
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.
607 if (fdp
->d_regopen
[OTYP_BLK
]) {
609 "Unable to suspend while floppy is in use.");
623 fd_part_is_open(struct fdisk
*fdp
, int part
)
627 for (i
= 0; i
< (OTYPCNT
- 1); i
++)
628 if (fdp
->d_regopen
[i
] & (1 << part
))
634 fd_unit_is_open(struct fdisk
*fdp
)
638 for (i
= 0; i
< NDKMAP
; i
++)
639 if (fdp
->d_lyropen
[i
])
641 for (i
= 0; i
< (OTYPCNT
- 1); i
++)
642 if (fdp
->d_regopen
[i
])
649 fd_open(dev_t
*devp
, int flag
, int otyp
, cred_t
*cred_p
)
651 struct fcu_obj
*fjp
= NULL
;
652 struct fdisk
*fdp
= NULL
;
653 struct partition
*pp
;
661 unit
= fd_getdrive(dev
, &fjp
, &fdp
);
664 part
= PARTITION(dev
);
666 pp
= &fdp
->d_part
[part
];
669 * Serialize opens/closes
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
),
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.
681 if (otyp
== OTYP_LYR
) {
682 part_is_open
= (fdp
->d_lyropen
[part
] != 0);
684 part_is_open
= fd_part_is_open(fdp
, part
);
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
],
691 sema_v(&fdp
->d_ocsem
);
696 * Ensure that drive is recalibrated on first open of new diskette.
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
);
707 fjp
->fj_flags
&= ~(FUNIT_LABELOK
| FUNIT_UNLABELED
);
709 if (flag
& (FNDELAY
| FNONBLOCK
)) {
710 /* don't attempt access, just return successfully */
711 fjp
->fj_ops
->fco_select(fjp
, unit
, 0);
716 * auto-sense the density/format of the diskette
718 rval
= fdgetlabel(fjp
, unit
);
719 fjp
->fj_ops
->fco_select(fjp
, unit
, 0);
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
);
727 /* check partition */
728 if (pp
->p_size
== 0) {
729 sema_v(&fdp
->d_ocsem
);
733 * if opening for writing, check write protect on diskette
735 if ((flag
& FWRITE
) && (fdp
->d_obj
->fj_flags
& FUNIT_WPROT
)) {
736 sema_v(&fdp
->d_ocsem
);
742 * mark open as having succeeded
745 fdp
->d_exclmask
|= pbit
;
746 if (otyp
== OTYP_LYR
)
747 fdp
->d_lyropen
[part
]++;
749 fdp
->d_regopen
[otyp
] |= 1 << part
;
751 sema_v(&fdp
->d_ocsem
);
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.
760 * RETURNS: 0 for ok - meaning that it could at least read the device,
761 * !0 for error XXX TBD NYD error codes
764 fdgetlabel(struct fcu_obj
*fjp
, int unit
)
766 struct dk_label
*label
;
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
);
784 * get some space to play with the label
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
)));
792 * read block 0 (0/0/1) to find the label
793 * (disk is potentially not present or unformatted)
795 /* noerrprint since this is a private cmd */
797 fderrlevel
= FDEP_LMAX
;
799 * try different characteristics (ie densities)
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
805 nexttype
= fdp
->d_deffdtype
;
806 try_this
= 1; /* always try the current characteristics */
808 for (tries
= nfdtypes
; tries
; tries
--) {
810 fjp
->fj_flags
&= ~FUNIT_CHAROK
;
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
,
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,
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
))))
831 * try the next entry in the characteristics tbl
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
);
841 * check for a double_density diskette
842 * in a high_density 5.25" drive
844 if (fjp
->fj_chars
->fdc_transfer_rate
== 250 &&
845 fjp
->fj_rotspd
> fjp
->fj_attr
->fda_rotatespd
) {
847 * yes - adjust transfer rate since we don't
848 * know if we have a 5.25" dual-speed drive
850 fjp
->fj_attr
->fda_rotatespd
= 360;
851 fjp
->fj_chars
->fdc_transfer_rate
= 300;
852 fjp
->fj_chars
->fdc_medium
= 5;
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;
859 fjp
->fj_chars
->fdc_steps
= 1;
864 fderrlevel
= oldlvl
; /* print errors again */
867 fdp
->d_curfdtype
= fdp
->d_deffdtype
;
868 goto out
; /* couldn't read anything */
871 FDERRPRINT(FDEP_L0
, FDEM_GETL
,
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
));
879 * _something_ was read - look for unixtype label
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 */
887 count
= sizeof (struct dk_label
) / sizeof (short);
891 xsum
^= *sp
++; /* should add up to 0 */
893 /* not a label - checksum didn't compute */
894 goto nolabel
; /* no errors, but no label */
898 * the SunOS label overrides current diskette characteristics
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;
907 fjp
->fj_chars
->fdc_steps
= 1;
909 fjp
->fj_attr
->fda_rotatespd
= label
->dkl_rpm
;
910 fjp
->fj_attr
->fda_intrlv
= label
->dkl_intrlv
;
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
);
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
;
925 fdp
->d_vtoc_timestamp
[i
] = label
->dkl_vtoc
.timestamp
[i
];
928 fjp
->fj_flags
|= FUNIT_LABELOK
;
933 * if not found, fill in label info from default (mark default used)
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
;
946 kmem_free(label
, sizeof (struct dk_label
));
953 fd_close(dev_t dev
, int flag
, int otyp
, cred_t
*cred_p
)
955 struct fcu_obj
*fjp
= NULL
;
956 struct fdisk
*fdp
= NULL
;
957 int part
, part_is_closed
;
961 #define DEBUG_ASSIGN unit=
963 #define DEBUG_ASSIGN (void)
966 DEBUG_ASSIGN
fd_getdrive(dev
, &fjp
, &fdp
);
968 * Ignoring return in non DEBUG mode because success is checked by
969 * verifying fjp and fdp and returned unit value is not used.
973 part
= PARTITION(dev
);
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",
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);
985 fdp
->d_regopen
[otyp
] &= ~(1<<part
);
988 if (part_is_closed
) {
989 if (part
== 2 && fdp
->d_exclmask
&(1<<part
))
992 fdp
->d_exclmask
&= ~(1<<part
);
993 FDERRPRINT(FDEP_L0
, FDEM_CLOS
,
995 "fd_close: exclparts %lx openparts %lx lyrcnt %lx\n",
996 fdp
->d_exclmask
, fdp
->d_regopen
[otyp
],
997 fdp
->d_lyropen
[part
]));
999 if (fd_unit_is_open(fdp
) == 0)
1000 fdp
->d_obj
->fj_flags
&= ~FUNIT_CHANGED
;
1002 sema_v(&fdp
->d_ocsem
);
1008 fd_read(dev_t dev
, struct uio
*uio
, cred_t
*cred_p
)
1010 return (physio(fd_strategy
, NULL
, dev
, B_READ
, minphys
, uio
));
1015 fd_write(dev_t dev
, struct uio
*uio
, cred_t
*cred_p
)
1017 return (physio(fd_strategy
, NULL
, dev
, B_WRITE
, minphys
, uio
));
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).
1027 fd_strategy(struct buf
*bp
)
1029 struct fcu_obj
*fjp
;
1031 struct partition
*pp
;
1033 FDERRPRINT(FDEP_L1
, FDEM_STRA
,
1034 (CE_CONT
, "fd_strategy: bp = 0x%p, dev = 0x%lx\n",
1035 (void *)bp
, bp
->b_edev
));
1037 (void) fd_getdrive(bp
->b_edev
, &fjp
, &fdp
);
1040 * Ignoring return because device exist.
1041 * Returned unit value is not used.
1043 pp
= &fdp
->d_part
[PARTITION(bp
->b_edev
)];
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
;
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
;
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
;
1068 bp
->b_resid
= bp
->b_bcount
;
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
;
1084 * Put the buf request in the drive's queue, FIFO.
1087 mutex_enter(&fjp
->fj_lock
);
1089 kstat_waitq_enter(KIOSP
);
1091 fdp
->d_actl
->av_forw
= bp
;
1095 if (!(fjp
->fj_flags
& FUNIT_BUSY
)) {
1098 mutex_exit(&fjp
->fj_lock
);
1102 bp
->b_resid
= bp
->b_bcount
;
1103 bp
->b_flags
|= B_ERROR
;
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.
1118 fdstart(struct fcu_obj
*fjp
)
1121 struct fdisk
*fdp
= (struct fdisk
*)fjp
->fj_data
;
1122 struct fd_char
*chp
;
1123 struct partition
*pp
;
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
;
1132 ASSERT(MUTEX_HELD(&fjp
->fj_lock
));
1133 fjp
->fj_flags
|= FUNIT_BUSY
;
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
);
1141 mutex_exit(&fjp
->fj_lock
);
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
;
1148 bp
->b_resid
= bp
->b_bcount
; /* init resid */
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);
1154 bp_mapin(bp
); /* map in buffers */
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 */
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 */
1166 sctrshft
= SCTRSHFT
+ 1;
1172 sctrshft
= SCTRSHFT
;
1175 sctrshft
= SCTRSHFT
- 1;
1182 * If off the end, limit to actual amount that
1183 * can be transferred.
1185 if ((blk
+ (bp
->b_bcount
>> sctrshft
)) > ptend
)
1186 /* to end of partition */
1187 len
= (ptend
- blk
) << sctrshft
;
1190 addr
= bp
->b_un
.b_addr
; /* data buffer address */
1193 * now we have the real start blk, addr and len for xfer op
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;
1204 * If the desired block and length will go beyond the
1205 * cylinder end, then limit it to the cylinder end.
1207 if (bp
->b_flags
& B_READ
) {
1208 if (len
> ((secpcyl
- bincyl
) << sctrshft
))
1209 tlen
= (secpcyl
- bincyl
) << sctrshft
;
1214 ((chp
->fdc_secptrack
- sect
+ 1) <<
1217 (chp
->fdc_secptrack
- sect
+ 1) <<
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
));
1230 * (try to) do the operation - failure returns an errno
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
;
1241 blk
+= tlen
>> sctrshft
;
1244 bp
->b_resid
-= tlen
;
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
) {
1252 KIOSP
->nread
+= (bp
->b_bcount
- bp
->b_resid
);
1255 KIOSP
->nwritten
+= (bp
->b_bcount
- bp
->b_resid
);
1257 kstat_runq_exit(KIOSP
);
1262 fjp
->fj_ops
->fco_select(fjp
, unit
, 0);
1263 mutex_enter(&fjp
->fj_lock
);
1266 fjp
->fj_flags
^= FUNIT_BUSY
;
1271 fd_ioctl(dev_t dev
, int cmd
, intptr_t arg
, int flag
, cred_t
*cred_p
,
1275 struct dk_cinfo dki
;
1277 struct dk_allmap dka
;
1278 struct fd_char fdchar
;
1279 struct fd_drive drvchar
;
1283 struct fcu_obj
*fjp
= NULL
;
1284 struct fdisk
*fdp
= NULL
;
1286 struct dk_label
*label
;
1287 int nblks
, part
, unit
;
1289 enum dkio_state state
;
1291 unit
= fd_getdrive(dev
, &fjp
, &fdp
);
1295 FDERRPRINT(FDEP_L1
, FDEM_IOCT
,
1296 (CE_CONT
, "fd_ioctl fd unit %d: cmd %x, arg %lx\n",
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
))
1309 case DKIOCG_PHYGEOM
:
1310 case DKIOCG_VIRTGEOM
:
1311 cpy
.dkg
.dkg_nsect
= fjp
->fj_chars
->fdc_secptrack
;
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
;
1318 cpy
.dkg
.dkg_nsect
= fjp
->fj_chars
->fdc_secptrack
;
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
))
1333 if (ddi_copyin((void *)arg
, &cpy
.dkg
,
1334 sizeof (struct dk_geom
), flag
)) {
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
);
1349 * return the map of all logical partitions
1353 * Note the conversion from starting sector number
1354 * to starting cylinder number.
1355 * Return error if division results in a remainder.
1357 nblks
= fjp
->fj_chars
->fdc_nhead
* fjp
->fj_chars
->fdc_secptrack
;
1359 #ifdef _MULTI_DATAMODEL
1360 switch (ddi_model_convert_from(flag
& FMODELS
)) {
1361 case DDI_MODEL_ILP32
:
1363 struct dk_allmap32 dka32
;
1365 for (part
= 0; part
< NDKMAP
; part
++) {
1366 if ((fdp
->d_part
[part
].p_start
% nblks
) != 0)
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
;
1374 if (ddi_copyout(&dka32
, (void *)arg
,
1375 sizeof (struct dk_allmap32
), flag
))
1380 case DDI_MODEL_NONE
:
1382 #endif /* _MULTI_DATAMODEL */
1384 dmp
= (struct dk_map
*)&cpy
.dka
;
1385 for (part
= 0; part
< NDKMAP
; part
++) {
1386 if ((fdp
->d_part
[part
].p_start
% nblks
) != 0)
1389 fdp
->d_part
[part
].p_start
/ nblks
;
1390 dmp
->dkl_nblk
= fdp
->d_part
[part
].p_size
;
1394 if (ddi_copyout(&cpy
.dka
, (void *)arg
,
1395 sizeof (struct dk_allmap
), flag
))
1397 #ifdef _MULTI_DATAMODEL
1401 #endif /* _MULTI_DATAMODEL */
1406 * Set the map of all logical partitions
1410 #ifdef _MULTI_DATAMODEL
1411 switch (ddi_model_convert_from(flag
& FMODELS
)) {
1412 case DDI_MODEL_ILP32
:
1414 struct dk_allmap32 dka32
;
1416 if (ddi_copyin((void *)arg
, &dka32
,
1417 sizeof (dka32
), flag
)) {
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
;
1429 case DDI_MODEL_NONE
:
1431 #endif /* _MULTI_DATAMODEL */
1432 if (ddi_copyin((void *)arg
, &cpy
.dka
, sizeof (cpy
.dka
), flag
))
1434 #ifdef _MULTI_DATAMODEL
1438 #endif /* _MULTI_DATAMODEL */
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
);
1448 * Note the conversion from starting cylinder number
1449 * to starting sector number.
1451 for (part
= 0; part
< NDKMAP
; part
++) {
1452 fdp
->d_part
[part
].p_start
= dmp
->dkl_cylno
*
1454 fdp
->d_part
[part
].p_size
= dmp
->dkl_nblk
;
1457 mutex_exit(&fjp
->fj_lock
);
1462 mutex_enter(&fjp
->fj_lock
);
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
1469 fjp
->fj_ops
->fco_select(fjp
, unit
, 1);
1470 rval
= fdgetlabel(fjp
, unit
);
1471 fjp
->fj_ops
->fco_select(fjp
, unit
, 0);
1473 mutex_exit(&fjp
->fj_lock
);
1478 fd_build_user_vtoc(fjp
, fdp
, &vtoc
);
1479 mutex_exit(&fjp
->fj_lock
);
1481 #ifdef _MULTI_DATAMODEL
1482 switch (ddi_model_convert_from(flag
& FMODELS
)) {
1483 case DDI_MODEL_ILP32
:
1485 struct vtoc32 vtoc32
;
1487 vtoctovtoc32(vtoc
, vtoc32
);
1489 if (ddi_copyout(&vtoc32
, (void *)arg
,
1490 sizeof (vtoc32
), flag
))
1495 case DDI_MODEL_NONE
:
1497 #endif /* _MULTI_DATAMODEL */
1498 if (ddi_copyout(&vtoc
, (void *)arg
,
1499 sizeof (vtoc
), flag
))
1501 #ifdef _MULTI_DATAMODEL
1504 #endif /* _MULTI_DATAMODEL */
1510 #ifdef _MULTI_DATAMODEL
1511 switch (ddi_model_convert_from(flag
& FMODELS
)) {
1512 case DDI_MODEL_ILP32
:
1514 struct vtoc32 vtoc32
;
1516 if (ddi_copyin((void *)arg
, &vtoc32
,
1517 sizeof (vtoc32
), flag
)) {
1522 vtoc32tovtoc(vtoc32
, vtoc
);
1526 case DDI_MODEL_NONE
:
1528 #endif /* _MULTI_DATAMODEL */
1529 if (ddi_copyin((void *)arg
, &vtoc
, sizeof (vtoc
), flag
))
1531 #ifdef _MULTI_DATAMODEL
1534 #endif /* _MULTI_DATAMODEL */
1540 label
= kmem_zalloc(sizeof (struct dk_label
), KM_SLEEP
);
1542 mutex_enter(&fjp
->fj_lock
);
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);
1550 mutex_exit(&fjp
->fj_lock
);
1551 kmem_free(label
, sizeof (struct dk_label
));
1555 FDERRPRINT(FDEP_L1
, FDEM_IOCT
,
1556 (CE_CONT
, "fd_ioctl fd unit %d: DKIOCSTATE\n", unit
));
1558 if (ddi_copyin((void *)arg
, &state
, sizeof (int), flag
)) {
1563 rval
= fd_check_media(dev
, state
);
1565 if (ddi_copyout(&fdp
->d_media_state
, (void *)arg
,
1566 sizeof (int), flag
))
1571 if (ddi_copyout(fjp
->fj_chars
, (void *)arg
,
1572 sizeof (struct fd_char
), flag
))
1577 if (ddi_copyin((void *)arg
, &cpy
.fdchar
,
1578 sizeof (struct fd_char
), flag
)) {
1582 switch (cpy
.fdchar
.fdc_transfer_rate
) {
1584 if ((fdp
->d_media
& (1 << FMT_3M
)) == 0) {
1586 "fdioschar:Medium density not supported\n");
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; */
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
);
1608 FDERRPRINT(FDEP_L4
, FDEM_IOCT
,
1609 (CE_WARN
, "fd_ioctl fd unit %d: FDIOSCHAR odd "
1611 unit
, cpy
.fdchar
.fdc_transfer_rate
));
1618 * set all characteristics and geometry to the defaults
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
);
1631 case FDEJECT
: /* eject disk */
1633 fjp
->fj_flags
&= ~(FUNIT_LABELOK
| FUNIT_UNLABELED
);
1637 case FDGETCHANGE
: /* disk changed */
1638 if (ddi_copyin((void *)arg
, &cpy
.temp
, sizeof (int), flag
)) {
1642 mutex_enter(&fjp
->fj_lock
);
1643 fjp
->fj_ops
->fco_select(fjp
, unit
, 1);
1645 if (fjp
->fj_flags
& FUNIT_CHANGED
)
1646 cpy
.temp
|= FDGC_HISTORY
;
1648 cpy
.temp
&= ~FDGC_HISTORY
;
1649 fjp
->fj_flags
&= ~FUNIT_CHANGED
;
1651 if (fjp
->fj_ops
->fco_getchng(fjp
, unit
)) {
1652 cpy
.temp
|= FDGC_DETECTED
;
1653 fjp
->fj_ops
->fco_resetchng(fjp
, unit
);
1655 * check diskette again only if it was removed
1657 if (fjp
->fj_ops
->fco_getchng(fjp
, unit
)) {
1659 * no diskette is present
1661 cpy
.temp
|= FDGC_CURRENT
;
1662 if (fjp
->fj_flags
& FUNIT_CHGDET
)
1664 * again no diskette; not a new change
1666 cpy
.temp
^= FDGC_DETECTED
;
1668 fjp
->fj_flags
|= FUNIT_CHGDET
;
1671 * a new diskette is present
1673 cpy
.temp
&= ~FDGC_CURRENT
;
1674 fjp
->fj_flags
&= ~FUNIT_CHGDET
;
1677 cpy
.temp
&= ~(FDGC_DETECTED
| FDGC_CURRENT
);
1678 fjp
->fj_flags
&= ~FUNIT_CHGDET
;
1681 * also get state of write protection
1683 if (fjp
->fj_flags
& FUNIT_WPROT
) {
1684 cpy
.temp
|= FDGC_CURWPROT
;
1686 cpy
.temp
&= ~FDGC_CURWPROT
;
1688 fjp
->fj_ops
->fco_select(fjp
, unit
, 0);
1689 mutex_exit(&fjp
->fj_lock
);
1691 if (ddi_copyout(&cpy
.temp
, (void *)arg
, sizeof (int), flag
))
1695 case FDGETDRIVECHAR
:
1696 if (ddi_copyout(fjp
->fj_drive
, (void *)arg
,
1697 sizeof (struct fd_drive
), flag
))
1701 case FDSETDRIVECHAR
:
1702 if (ddi_copyin((void *)arg
, &cpy
.drvchar
,
1703 sizeof (struct fd_drive
), flag
)) {
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
);
1714 case DKIOCREMOVABLE
: {
1717 /* no brainer: floppies are always removable */
1718 if (ddi_copyout(&i
, (void *)arg
, sizeof (int), flag
)) {
1724 case DKIOCGMEDIAINFO
:
1725 rval
= fd_get_media_info(fjp
, (caddr_t
)arg
, flag
);
1731 int cyl
, head
, spc
, spt
;
1733 #ifdef _MULTI_DATAMODEL
1734 switch (ddi_model_convert_from(flag
& FMODELS
)) {
1735 case DDI_MODEL_ILP32
:
1737 struct fd_cmd32 fc32
;
1739 if (ddi_copyin((void *)arg
, &fc32
,
1740 sizeof (fc32
), flag
)) {
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
;
1754 case DDI_MODEL_NONE
:
1756 #endif /* _MULTI_DATAMODEL */
1758 if (ddi_copyin((void *)arg
, &fc
, sizeof (fc
), flag
)) {
1762 #ifdef _MULTI_DATAMODEL
1765 #endif /* _MULTI_DATAMODEL */
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
;
1775 spc
= (fc
.fdc_cmd
== FDCMD_READ
)? B_READ
: B_WRITE
;
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
;
1784 uio
->uio_iovcnt
= 1;
1785 uio
->uio_resid
= aiov
.iov_len
;
1786 uio
->uio_segflg
= UIO_USERSPACE
;
1788 rval
= physio(fd_strategy
, (struct buf
*)0, dev
,
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)
1798 ~(FUNIT_LABELOK
| FUNIT_UNLABELED
);
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
,
1805 fjp
->fj_ops
->fco_select(fjp
, unit
, 0);
1809 FDERRPRINT(FDEP_L4
, FDEM_IOCT
,
1810 (CE_WARN
, "fd_ioctl fd unit %d: FDIOCSCMD not yet complete",
1817 rval
= fd_rawioctl(fjp
, unit
, (caddr_t
)arg
, flag
);
1821 FDERRPRINT(FDEP_L4
, FDEM_IOCT
,
1822 (CE_WARN
, "fd_ioctl fd unit %d: invalid ioctl 0x%x",
1831 fd_build_user_vtoc(struct fcu_obj
*fjp
, struct fdisk
*fdp
, struct vtoc
*vtocp
)
1833 struct partition
*vpart
;
1838 * Return vtoc structure fields in the provided VTOC area, addressed
1842 bzero(vtocp
, sizeof (struct vtoc
));
1844 bcopy(fdp
->d_vtoc_bootinfo
,
1845 vtocp
->v_bootinfo
, sizeof (vtocp
->v_bootinfo
));
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
;
1854 vtocp
->v_sectorsz
= fjp
->fj_chars
->fdc_sec_size
;
1855 xblk
= vtocp
->v_sectorsz
/ DEV_BSIZE
;
1857 vtocp
->v_nparts
= 3; /* <= NDKMAP; */
1860 * Copy partitioning information.
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
;
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
);
1876 fd_build_label_vtoc(struct fcu_obj
*fjp
, struct fdisk
*fdp
, struct vtoc
*vtocp
,
1877 struct dk_label
*labelp
)
1879 struct partition
*vpart
;
1887 * Sanity-check the vtoc
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"));
1897 * before copying the vtoc, the partition information in it should be
1898 * checked against the information the driver already has on the
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)
1906 vpart
= vtocp
->v_part
;
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)
1914 for (i
= NDKMAP
; i
; i
--) {
1915 if ((vpart
->p_start
% nblks
) != 0) {
1918 ncyl
= vpart
->p_start
/ nblks
;
1919 ncyl
+= vpart
->p_size
/ nblks
;
1920 if ((vpart
->p_size
% nblks
) != 0)
1922 if (ncyl
> (long)fjp
->fj_chars
->fdc_ncyl
) {
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
);
1935 * Copy partitioning information.
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
);
1943 * construct the diskette label in supplied buffer
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];
1951 labelp
->dkl_vtoc
.v_sanity
= vtocp
->v_sanity
;
1952 labelp
->dkl_vtoc
.v_version
= vtocp
->v_version
;
1954 bcopy(vtocp
->v_volume
, labelp
->dkl_vtoc
.v_volume
, LEN_DKL_VVOL
);
1956 labelp
->dkl_vtoc
.v_nparts
= vtocp
->v_nparts
;
1958 bcopy(vtocp
->v_reserved
, labelp
->dkl_vtoc
.v_reserved
,
1959 sizeof (labelp
->dkl_vtoc
.v_reserved
));
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
;
1968 for (i
= 0; i
< NDKMAP
; i
++) {
1969 labelp
->dkl_vtoc
.v_timestamp
[i
] = vtocp
->timestamp
[i
];
1971 bcopy(vtocp
->v_asciilabel
, labelp
->dkl_asciilabel
, LEN_DKL_ASCII
);
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
;
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.
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
;
1991 labelp
->dkl_magic
= DKL_MAGIC
;
1994 labelp
->dkl_cksum
= 0;
1995 sp
= (ushort_t
*)labelp
;
1996 while (sp
< &(labelp
->dkl_cksum
)) {
1999 labelp
->dkl_cksum
= sum
;
2005 fd_rawioctl(struct fcu_obj
*fjp
, int unit
, caddr_t arg
, int mode
)
2008 char *arg_result
= NULL
;
2014 FDERRPRINT(FDEP_L1
, FDEM_RAWI
,
2015 (CE_CONT
, "fd_rawioctl: cmd[0]=0x%x\n", fdr
.fdr_cmd
[0]));
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");
2022 #ifdef _MULTI_DATAMODEL
2023 switch (ddi_model_convert_from(mode
& FMODELS
)) {
2024 case DDI_MODEL_ILP32
:
2026 struct fd_raw32 fdr32
;
2028 if (ddi_copyin(arg
, &fdr32
, sizeof (fdr32
), mode
))
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
;
2039 case DDI_MODEL_NONE
:
2040 #endif /* ! _MULTI_DATAMODEL */
2042 if (ddi_copyin(arg
, &fdr
, sizeof (fdr
), mode
))
2045 arg_result
= ((struct fd_raw
*)arg
)->fdr_result
;
2047 #ifdef _MULTI_DATAMODEL
2050 #endif /* _MULTI_DATAMODEL */
2055 * copy user address & nbytes from raw_req so that we can
2056 * put kernel address in req structure
2058 uaddr
= fdr
.fdr_addr
;
2059 ucount
= (uint_t
)fdr
.fdr_nbytes
;
2062 switch (fdr
.fdr_cmd
[0] & 0x0f) {
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
);
2072 if ((*fdr
.fdr_addr
| fdr
.fdr_addr
[1]) == 0)
2073 fjp
->fj_flags
&= ~(FUNIT_LABELOK
| FUNIT_UNLABELED
);
2075 fdr
.fdr_cmd
[1] = (fdr
.fdr_cmd
[1] & ~3) | unit
;
2079 case FDRAW_WRITEDEL
:
2084 case FDRAW_READTRACK
:
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.
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
,
2097 kmem_free(fdr
.fdr_addr
, ucount
);
2103 fdr
.fdr_cmd
[1] = (fdr
.fdr_cmd
[1] & ~3) | unit
;
2109 case FDRAW_SENSE_DRV
:
2111 fdr
.fdr_cmd
[1] = (fdr
.fdr_cmd
[1] & ~3) | unit
;
2115 fdr
.fdr_cmd
[2] &= 0xfe; /* keep NoDMA bit clear */
2117 case FDRAW_SENSE_INT
:
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.
2132 fjp
->fj_ops
->fco_select(fjp
, unit
, 1);
2133 rval
= fjp
->fj_ops
->fco_rwioctl(fjp
, unit
, (caddr_t
)&fdr
);
2135 if (ucount
&& flag
== B_READ
&& rval
== 0) {
2136 if (ddi_copyout(fdr
.fdr_addr
, uaddr
, ucount
, mode
)) {
2140 if (ddi_copyout(fdr
.fdr_result
, arg_result
, sizeof (fdr
.fdr_cmd
), mode
))
2143 fjp
->fj_ops
->fco_select(fjp
, unit
, 0);
2145 kmem_free(fdr
.fdr_addr
, ucount
);
2151 * property operation routine. return the number of blocks for the partition
2152 * in question or forward the request to the property facilities.
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
)
2158 struct fcu_obj
*fjp
= NULL
;
2159 struct fdisk
*fdp
= NULL
;
2162 FDERRPRINT(FDEP_L1
, FDEM_PROP
,
2163 (CE_CONT
, "fd_prop_op: dip %p %s\n", (void *)dip
, name
));
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.
2171 if (dev
== DDI_DEV_T_ANY
) {
2172 pass
: return (ddi_prop_op(dev
, dip
, prop_op
, mod_flags
,
2173 name
, valuep
, lengthp
));
2176 * Ignoring return value because success is checked by
2177 * verifying fjp and fdp and returned unit value is not used.
2179 (void) fd_getdrive(dev
, &fjp
, &fdp
);
2183 /* get nblocks value */
2184 nblocks64
= (ulong_t
)fdp
->d_part
[PARTITION(dev
)].p_size
;
2186 return (ddi_prop_op_nblocks(dev
, dip
, prop_op
, mod_flags
,
2187 name
, valuep
, lengthp
, nblocks64
));
2192 fd_media_watch(void *arg
)
2194 struct fcu_obj
*fjp
;
2199 #define DEBUG_ASSIGN unit=
2201 #define DEBUG_ASSIGN (void)
2203 DEBUG_ASSIGN
fd_getdrive((dev_t
)arg
, &fjp
, &fdp
);
2205 * Ignoring return in non DEBUG mode because device exist.
2206 * Returned unit value is not used.
2209 FDERRPRINT(FDEP_L0
, FDEM_IOCT
,
2210 (CE_CONT
, "fd_media_watch unit %d\n", unit
));
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
2217 * Instead, just wakeup up driver.
2219 mutex_enter(&fjp
->fj_lock
);
2220 cv_broadcast(&fdp
->d_statecv
);
2221 mutex_exit(&fjp
->fj_lock
);
2225 fd_get_media_state(struct fcu_obj
*fjp
, int unit
)
2227 enum dkio_state state
;
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
) {
2235 * again no diskette; not a new change
2240 * a new change; diskette was ejected
2242 fjp
->fj_flags
|= FUNIT_CHGDET
;
2243 state
= DKIO_EJECTED
;
2246 fjp
->fj_flags
&= ~FUNIT_CHGDET
;
2247 state
= DKIO_INSERTED
;
2250 fjp
->fj_flags
&= ~FUNIT_CHGDET
;
2251 state
= DKIO_INSERTED
;
2253 FDERRPRINT(FDEP_L0
, FDEM_IOCT
,
2254 (CE_CONT
, "fd_get_media_state unit %d: state %x\n", unit
, state
));
2259 fd_check_media(dev_t dev
, enum dkio_state state
)
2261 struct fcu_obj
*fjp
;
2266 unit
= fd_getdrive(dev
, &fjp
, &fdp
);
2268 mutex_enter(&fjp
->fj_lock
);
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
);
2274 while (fdp
->d_media_state
== state
) {
2275 /* release the controller and drive */
2276 fjp
->fj_ops
->fco_select(fjp
, unit
, 0);
2279 fdp
->d_media_timeout_id
= timeout(fd_media_watch
,
2280 (void *)dev
, fdp
->d_media_timeout
);
2282 if (cv_wait_sig(&fdp
->d_statecv
, &fjp
->fj_lock
) == 0) {
2283 fdp
->d_media_timeout
= 0;
2284 mutex_exit(&fjp
->fj_lock
);
2287 fjp
->fj_ops
->fco_select(fjp
, unit
, 1);
2288 fdp
->d_media_state
= fd_get_media_state(fjp
, unit
);
2291 if (fdp
->d_media_state
== DKIO_INSERTED
) {
2292 err
= fdgetlabel(fjp
, unit
);
2294 fjp
->fj_ops
->fco_select(fjp
, unit
, 0);
2295 mutex_exit(&fjp
->fj_lock
);
2299 fjp
->fj_ops
->fco_select(fjp
, unit
, 0);
2300 mutex_exit(&fjp
->fj_lock
);
2305 * fd_get_media_info :
2306 * Collects medium information for
2307 * DKIOCGMEDIAINFO ioctl.
2311 fd_get_media_info(struct fcu_obj
*fjp
, caddr_t buf
, int flag
)
2313 struct dk_minfo media_info
;
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
;
2321 if (ddi_copyout(&media_info
, buf
, sizeof (struct dk_minfo
), flag
))