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