1 /* $NetBSD: fd.c,v 1.96 2023/06/24 05:31:04 msaitoh Exp $ */
2
3 /*
4 * Copyright (c) 1995 Leo Weppelman.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 /*
29 * This file contains a driver for the Floppy Disk Controller (FDC)
30 * on the Atari TT. It uses the WD 1772 chip, modified for steprates.
31 *
32 * The ST floppy disk controller shares the access to the DMA circuitry
33 * with other devices. For this reason the floppy disk controller makes
34 * use of some special DMA accessing code.
35 *
36 * Interrupts from the FDC are in fact DMA interrupts which get their
37 * first level handling in 'dma.c' . If the floppy driver is currently
38 * using DMA the interrupt is signalled to 'fdcint'.
39 *
40 * TODO:
41 * - Test it with 2 drives (I don't have them)
42 * - Test it with an HD-drive (Don't have that either)
43 * - Finish ioctl's
44 */
45
46 #include <sys/cdefs.h>
47 __KERNEL_RCSID(0, "$NetBSD: fd.c,v 1.96 2023/06/24 05:31:04 msaitoh Exp $");
48
49 #include <sys/param.h>
50 #include <sys/systm.h>
51 #include <sys/callout.h>
52 #include <sys/kernel.h>
53 #include <sys/malloc.h>
54 #include <sys/buf.h>
55 #include <sys/bufq.h>
56 #include <sys/proc.h>
57 #include <sys/device.h>
58 #include <sys/ioctl.h>
59 #include <sys/fcntl.h>
60 #include <sys/conf.h>
61 #include <sys/disklabel.h>
62 #include <sys/disk.h>
63 #include <sys/dkbad.h>
64 #include <atari/atari/device.h>
65 #include <atari/atari/stalloc.h>
66 #include <machine/disklabel.h>
67 #include <machine/iomap.h>
68 #include <machine/mfp.h>
69 #include <machine/dma.h>
70 #include <machine/video.h>
71 #include <machine/cpu.h>
72 #include <atari/dev/ym2149reg.h>
73 #include <atari/dev/fdreg.h>
74
75 #include "ioconf.h"
76
77 /*
78 * Be verbose for debugging
79 */
80 /*#define FLP_DEBUG 1 */
81
82 #define FDC_MAX_DMA_AD 0x1000000 /* No DMA possible beyond */
83
84 /* Parameters for the disk drive. */
85 #define SECTOR_SIZE 512 /* physical sector size in bytes */
86 #define NR_DRIVES 2 /* maximum number of drives */
87 #define NR_TYPES 3 /* number of diskette/drive combinations*/
88 #define MAX_ERRORS 10 /* how often to try rd/wt before quitting*/
89 #define STEP_DELAY 6000 /* 6ms (6000us) delay after stepping */
90
91
92 #define INV_TRK 32000 /* Should fit in unsigned short */
93 #define INV_PART NR_TYPES
94
95 /*
96 * Driver states
97 */
98 #define FLP_IDLE 0x00 /* floppy is idle */
99 #define FLP_MON 0x01 /* idle with motor on */
100 #define FLP_STAT 0x02 /* determine floppy status */
101 #define FLP_XFER 0x04 /* read/write data from floppy */
102
103 /*
104 * Timer delay's
105 */
106 #define FLP_MONDELAY (3 * hz) /* motor-on delay */
107 #define FLP_XFERDELAY (2 * hz) /* timeout on transfer */
108
109 /*
110 * The density codes
111 */
112 #define FLP_DD 0 /* Double density */
113 #define FLP_HD 1 /* High density */
114
115
116 #define b_block b_resid /* FIXME: this is not the place */
117
118 /*
119 * Global data for all physical floppy devices
120 */
121 static short selected = 0; /* drive/head currently selected*/
122 static short motoron = 0; /* motor is spinning */
123 static short nopens = 0; /* Number of opens executed */
124
125 static short fd_state = FLP_IDLE; /* Current driver state */
126 static int lock_stat = 0; /* DMA locking status */
127 static short fd_cmd = 0; /* command being executed */
128 static const char *fd_error = NULL; /* error from fd_xfer_ok() */
129
130 /*
131 * Private per device data
132 */
133 struct fd_softc {
134 device_t sc_dev; /* generic device info */
135 struct disk dkdev; /* generic disk info */
136 struct bufq_state *bufq; /* queue of buf's */
137 struct callout sc_motor_ch;
138 int unit; /* unit for atari controlling hw*/
139 int nheads; /* number of heads in use */
140 int nsectors; /* number of sectors/track */
141 int density; /* density code */
142 int nblocks; /* number of blocks on disk */
143 int curtrk; /* track head positioned on */
144 short flags; /* misc flags */
145 short part; /* Current open partition */
146 int sector; /* logical sector for I/O */
147 uint8_t *io_data; /* KVA for data transfer */
148 int io_bytes; /* bytes left for I/O */
149 int io_dir; /* B_READ/B_WRITE */
150 int errcnt; /* current error count */
151 uint8_t *bounceb; /* Bounce buffer */
152
153 };
154
155 /*
156 * Flags in fd_softc:
157 */
158 #define FLPF_NOTRESP 0x001 /* Unit not responding */
159 #define FLPF_ISOPEN 0x002 /* Unit is open */
160 #define FLPF_SPARE 0x004 /* Not used */
161 #define FLPF_HAVELAB 0x008 /* We have a valid label */
162 #define FLPF_BOUNCE 0x010 /* Now using the bounce buffer */
163 #define FLPF_WRTPROT 0x020 /* Unit is write-protected */
164 #define FLPF_EMPTY 0x040 /* Unit is empty */
165 #define FLPF_INOPEN 0x080 /* Currently being opened */
166 #define FLPF_GETSTAT 0x100 /* Getting unit status */
167
168 struct fd_types {
169 int nheads; /* Heads in use */
170 int nsectors; /* sectors per track */
171 int nblocks; /* number of blocks */
172 int density; /* density code */
173 const char *descr; /* type description */
174 } fdtypes[NR_TYPES] = {
175 { 1, 9, 720 , FLP_DD , "360KB" }, /* 360 Kb */
176 { 2, 9, 1440 , FLP_DD , "720KB" }, /* 720 Kb */
177 { 2, 18, 2880 , FLP_HD , "1.44MB" }, /* 1.44 Mb */
178 };
179
180 #define FLP_TYPE_360 0 /* XXX: Please keep these in */
181 #define FLP_TYPE_720 1 /* sync with the numbering in */
182 #define FLP_TYPE_144 2 /* 'fdtypes' right above! */
183
184 /*
185 * This is set only once at attach time. The value is determined by reading
186 * the configuration switches and is one of the FLP_TYPE_*'s.
187 * This is similar to the way Atari handles the _FLP cookie.
188 */
189 static short def_type = 0; /* Reflects config-switches */
190
191 #define FLP_DEFTYPE 1 /* 720Kb, reasonable default */
192 #define FLP_TYPE(dev) ( DISKPART(dev) == 0 ? def_type : DISKPART(dev) - 1 )
193
194 typedef void (*FPV)(void *);
195
196 static dev_type_open(fdopen);
197 static dev_type_close(fdclose);
198 static dev_type_read(fdread);
199 static dev_type_write(fdwrite);
200 static dev_type_ioctl(fdioctl);
201 static dev_type_strategy(fdstrategy);
202
203 /*
204 * Private drive functions....
205 */
206 static void fdstart(struct fd_softc *);
207 static void fddone(struct fd_softc *);
208 static void fdstatus(struct fd_softc *);
209 static void fd_xfer(struct fd_softc *);
210 static void fdcint(struct fd_softc *);
211 static int fd_xfer_ok(struct fd_softc *);
212 static void fdmotoroff(struct fd_softc *);
213 static void fdminphys(struct buf *);
214 static void fdtestdrv(struct fd_softc *);
215 static void fdgetdefaultlabel(struct fd_softc *, struct disklabel *,
216 int);
217 static int fdgetdisklabel(struct fd_softc *, dev_t);
218 static int fdselect(int, int, int);
219 static void fddeselect(void);
220 static void fdmoff(struct fd_softc *);
221
222 static u_short rd_cfg_switch(void);
223
224 static inline uint8_t read_fdreg(u_short);
225 static inline void write_fdreg(u_short, u_short);
226 static inline uint8_t read_dmastat(void);
227
228 static inline
read_fdreg(u_short regno)229 uint8_t read_fdreg(u_short regno)
230 {
231
232 DMA->dma_mode = regno;
233 return DMA->dma_data;
234 }
235
236 static inline
write_fdreg(u_short regno,u_short val)237 void write_fdreg(u_short regno, u_short val)
238 {
239
240 DMA->dma_mode = regno;
241 DMA->dma_data = val;
242 }
243
244 static inline
read_dmastat(void)245 uint8_t read_dmastat(void)
246 {
247
248 DMA->dma_mode = FDC_CS | DMA_SCREG;
249 return DMA->dma_stat;
250 }
251
252 /*
253 * Config switch stuff. Used only for the floppy type for now. That's
254 * why it's here...
255 * XXX: If needed in more places, it should be moved to its own include file.
256 * Note: This location _must_ be read as an u_short. Failure to do so
257 * will return garbage!
258 */
259 static u_short
rd_cfg_switch(void)260 rd_cfg_switch(void)
261 {
262
263 return *(volatile u_short *)AD_CFG_SWITCH;
264 }
265
266 /*
267 * Switch definitions.
268 * Note: ON reads as a zero bit!
269 */
270 #define CFG_SWITCH_NOHD 0x4000
271
272 /*
273 * Autoconfig stuff....
274 */
275 static int fdcmatch(device_t, cfdata_t, void *);
276 static int fdcprint(void *, const char *);
277 static void fdcattach(device_t, device_t, void *);
278
279 CFATTACH_DECL_NEW(fdc, 0,
280 fdcmatch, fdcattach, NULL, NULL);
281
282 const struct bdevsw fd_bdevsw = {
283 .d_open = fdopen,
284 .d_close = fdclose,
285 .d_strategy = fdstrategy,
286 .d_ioctl = fdioctl,
287 .d_dump = nodump,
288 .d_psize = nosize,
289 .d_discard = nodiscard,
290 .d_flag = D_DISK
291 };
292
293 const struct cdevsw fd_cdevsw = {
294 .d_open = fdopen,
295 .d_close = fdclose,
296 .d_read = fdread,
297 .d_write = fdwrite,
298 .d_ioctl = fdioctl,
299 .d_stop = nostop,
300 .d_tty = notty,
301 .d_poll = nopoll,
302 .d_mmap = nommap,
303 .d_kqfilter = nokqfilter,
304 .d_discard = nodiscard,
305 .d_flag = D_DISK
306 };
307
308 static int
fdcmatch(device_t parent,cfdata_t match,void * aux)309 fdcmatch(device_t parent, cfdata_t match, void *aux)
310 {
311 static int fdc_matched = 0;
312
313 /* Match only once */
314 if (strcmp("fdc", aux) || fdc_matched)
315 return 0;
316 fdc_matched = 1;
317 return 1;
318 }
319
320 static void
fdcattach(device_t parent,device_t self,void * aux)321 fdcattach(device_t parent, device_t self, void *aux)
322 {
323 struct fd_softc fdsoftc;
324 int i, nfound, first_found;
325
326 nfound = first_found = 0;
327 aprint_normal("\n");
328 fddeselect();
329 for (i = 0; i < NR_DRIVES; i++) {
330
331 /*
332 * Test if unit is present
333 */
334 fdsoftc.unit = i;
335 fdsoftc.flags = 0;
336 st_dmagrab((dma_farg)fdcint, (dma_farg)fdtestdrv, &fdsoftc,
337 &lock_stat, 0, NULL);
338 st_dmafree(&fdsoftc, &lock_stat);
339
340 if ((fdsoftc.flags & FLPF_NOTRESP) == 0) {
341 if (nfound == 0)
342 first_found = i;
343 nfound++;
344 config_found(self, (void *)i, fdcprint, CFARGS_NONE);
345 }
346 }
347
348 if (nfound != 0) {
349 struct fd_softc *fdsc =
350 device_lookup_private(&fd_cd, first_found);
351
352 /*
353 * Make sure motor will be turned of when a floppy is
354 * inserted in the first selected drive.
355 */
356 fdselect(first_found, 0, FLP_DD);
357 fd_state = FLP_MON;
358 callout_reset(&fdsc->sc_motor_ch, 0, (FPV)fdmotoroff, fdsc);
359
360 /*
361 * enable disk related interrupts
362 */
363 MFP->mf_ierb |= IB_DINT;
364 MFP->mf_iprb = (uint8_t)~IB_DINT;
365 MFP->mf_imrb |= IB_DINT;
366 }
367 }
368
369 static int
fdcprint(void * aux,const char * pnp)370 fdcprint(void *aux, const char *pnp)
371 {
372
373 if (pnp != NULL)
374 aprint_normal("fd%d at %s:", (int)aux, pnp);
375
376 return UNCONF;
377 }
378
379 static int fdmatch(device_t, cfdata_t, void *);
380 static void fdattach(device_t, device_t, void *);
381
382 struct dkdriver fddkdriver = {
383 .d_strategy = fdstrategy
384 };
385
386 CFATTACH_DECL_NEW(fd, sizeof(struct fd_softc),
387 fdmatch, fdattach, NULL, NULL);
388
389 static int
fdmatch(device_t parent,cfdata_t match,void * aux)390 fdmatch(device_t parent, cfdata_t match, void *aux)
391 {
392
393 return 1;
394 }
395
396 static void
fdattach(device_t parent,device_t self,void * aux)397 fdattach(device_t parent, device_t self, void *aux)
398 {
399 struct fd_softc *sc;
400 struct fd_types *type;
401 u_short swtch;
402
403 sc = device_private(self);
404 sc->sc_dev = self;
405
406 callout_init(&sc->sc_motor_ch, 0);
407
408 /*
409 * Find out if an Ajax chip might be installed. Set the default
410 * floppy type accordingly.
411 */
412 swtch = rd_cfg_switch();
413 def_type = (swtch & CFG_SWITCH_NOHD) ? FLP_TYPE_720 : FLP_TYPE_144;
414 type = &fdtypes[def_type];
415
416 aprint_normal(": %s %d cyl, %d head, %d sec\n", type->descr,
417 type->nblocks / (type->nsectors * type->nheads), type->nheads,
418 type->nsectors);
419
420 /*
421 * Initialize and attach the disk structure.
422 */
423 disk_init(&sc->dkdev, device_xname(sc->sc_dev), &fddkdriver);
424 disk_attach(&sc->dkdev);
425 }
426
427 static int
fdioctl(dev_t dev,u_long cmd,void * addr,int flag,struct lwp * l)428 fdioctl(dev_t dev, u_long cmd, void * addr, int flag, struct lwp *l)
429 {
430 struct fd_softc *sc;
431 int error;
432
433 sc = device_lookup_private(&fd_cd, DISKUNIT(dev));
434
435 if ((sc->flags & FLPF_HAVELAB) == 0)
436 return EBADF;
437
438 error = disk_ioctl(&sc->dkdev, RAW_PART, cmd, addr, flag, l);
439 if (error != EPASSTHROUGH)
440 return error;
441
442 switch (cmd) {
443 case DIOCSBAD:
444 return EINVAL;
445 #ifdef notyet /* XXX LWP */
446 case DIOCSRETRIES:
447 case DIOCSSTEP:
448 case DIOCSDINFO:
449 case DIOCWDINFO:
450 case DIOCWLABEL:
451 break;
452 #endif /* notyet */
453 case DIOCGDEFLABEL:
454 fdgetdefaultlabel(sc, (struct disklabel *)addr, RAW_PART);
455 return 0;
456 }
457 return ENOTTY;
458 }
459
460 /*
461 * Open the device. If this is the first open on both the floppy devices,
462 * initialize the controller.
463 * Note that partition info on the floppy device is used to distinguise
464 * between 780Kb and 360Kb floppy's.
465 * partition 0: 360Kb
466 * partition 1: 780Kb
467 */
468 static int
fdopen(dev_t dev,int flags,int devtype,struct lwp * l)469 fdopen(dev_t dev, int flags, int devtype, struct lwp *l)
470 {
471 struct fd_softc *sc;
472 int s;
473
474 #ifdef FLP_DEBUG
475 printf("fdopen dev=0x%x\n", dev);
476 #endif
477
478 if (FLP_TYPE(dev) >= NR_TYPES)
479 return ENXIO;
480
481 if ((sc = device_lookup_private(&fd_cd, DISKUNIT(dev))) == NULL)
482 return ENXIO;
483
484 /*
485 * If no floppy currently open, reset the controller and select
486 * floppy type.
487 */
488 if (nopens == 0) {
489
490 #ifdef FLP_DEBUG
491 printf("fdopen device not yet open\n");
492 #endif
493 nopens++;
494 write_fdreg(FDC_CS, IRUPT);
495 delay(40);
496 }
497
498 /*
499 * Sleep while other process is opening the device
500 */
501 s = splbio();
502 while (sc->flags & FLPF_INOPEN)
503 tsleep((void *)sc, PRIBIO, "fdopen", 0);
504 splx(s);
505
506 if ((sc->flags & FLPF_ISOPEN) == 0) {
507 /*
508 * Initialise some driver values.
509 */
510 int type;
511 void *addr;
512
513 type = FLP_TYPE(dev);
514
515 bufq_alloc(&sc->bufq, "disksort", BUFQ_SORT_RAWBLOCK);
516 sc->unit = DISKUNIT(dev);
517 sc->part = RAW_PART;
518 sc->nheads = fdtypes[type].nheads;
519 sc->nsectors = fdtypes[type].nsectors;
520 sc->nblocks = fdtypes[type].nblocks;
521 sc->density = fdtypes[type].density;
522 sc->curtrk = INV_TRK;
523 sc->sector = 0;
524 sc->errcnt = 0;
525 sc->bounceb = alloc_stmem(SECTOR_SIZE, &addr);
526 if (sc->bounceb == NULL)
527 return ENOMEM; /* XXX */
528
529 /*
530 * Go get write protect + loaded status
531 */
532 sc->flags |= FLPF_INOPEN|FLPF_GETSTAT;
533 s = splbio();
534 st_dmagrab((dma_farg)fdcint, (dma_farg)fdstatus, sc,
535 &lock_stat, 0, NULL);
536 while ((sc->flags & FLPF_GETSTAT) != 0)
537 tsleep((void *)sc, PRIBIO, "fdopen", 0);
538 splx(s);
539 wakeup((void *)sc);
540
541 if ((sc->flags & FLPF_WRTPROT) != 0 &&
542 (flags & FWRITE) != 0) {
543 sc->flags = 0;
544 return EPERM;
545 }
546 if ((sc->flags & FLPF_EMPTY) != 0) {
547 sc->flags = 0;
548 return ENXIO;
549 }
550 sc->flags &= ~(FLPF_INOPEN|FLPF_GETSTAT);
551 sc->flags |= FLPF_ISOPEN;
552 } else {
553 /*
554 * Multiply opens are granted when accessing the same type of
555 * floppy (eq. the same partition).
556 */
557 if (sc->density != fdtypes[DISKPART(dev)].density)
558 return ENXIO; /* XXX temporarily out of business */
559 }
560 fdgetdisklabel(sc, dev);
561 #ifdef FLP_DEBUG
562 printf("fdopen open succeeded on type %d\n", sc->part);
563 #endif
564 return 0;
565 }
566
567 static int
fdclose(dev_t dev,int flags,int devtype,struct lwp * l)568 fdclose(dev_t dev, int flags, int devtype, struct lwp *l)
569 {
570 struct fd_softc *sc;
571
572 sc = device_lookup_private(&fd_cd, DISKUNIT(dev));
573 free_stmem(sc->bounceb);
574 sc->flags = 0;
575 nopens--;
576
577 #ifdef FLP_DEBUG
578 printf("Closed floppy device -- nopens: %d\n", nopens);
579 #endif
580 return 0;
581 }
582
583 static void
fdstrategy(struct buf * bp)584 fdstrategy(struct buf *bp)
585 {
586 struct fd_softc *sc;
587 struct disklabel *lp;
588 int s, sz;
589
590 sc = device_lookup_private(&fd_cd, DISKUNIT(bp->b_dev));
591
592 #ifdef FLP_DEBUG
593 printf("fdstrategy: %p, b_bcount: %ld\n", bp, bp->b_bcount);
594 #endif
595
596 /*
597 * check for valid partition and bounds
598 */
599 lp = sc->dkdev.dk_label;
600 if ((sc->flags & FLPF_HAVELAB) == 0) {
601 bp->b_error = EIO;
602 goto done;
603 }
604 if (bp->b_blkno < 0 || (bp->b_bcount % SECTOR_SIZE) != 0) {
605 bp->b_error = EINVAL;
606 goto done;
607 }
608 if (bp->b_bcount == 0)
609 goto done;
610
611 sz = howmany(bp->b_bcount, SECTOR_SIZE);
612
613 if (bp->b_blkno + sz > sc->nblocks) {
614 sz = sc->nblocks - bp->b_blkno;
615 if (sz == 0) /* Exactly at EndOfDisk */
616 goto done;
617 if (sz < 0) { /* Past EndOfDisk */
618 bp->b_error = EINVAL;
619 goto done;
620 }
621 /* Truncate it */
622 if (bp->b_flags & B_RAW)
623 bp->b_bcount = sz << DEV_BSHIFT;
624 else
625 bp->b_bcount = sz * lp->d_secsize;
626 }
627
628 /* No partition translation. */
629 bp->b_rawblkno = bp->b_blkno;
630
631 /*
632 * queue the buf and kick the low level code
633 */
634 s = splbio();
635 bufq_put(sc->bufq, bp); /* XXX disksort_cylinder */
636 if (!lock_stat) {
637 if (fd_state & FLP_MON)
638 callout_stop(&sc->sc_motor_ch);
639 fd_state = FLP_IDLE;
640 st_dmagrab((dma_farg)fdcint, (dma_farg)fdstart, sc,
641 &lock_stat, 0, NULL);
642 }
643 splx(s);
644
645 return;
646 done:
647 bp->b_resid = bp->b_bcount;
648 biodone(bp);
649 }
650
651 static int
fdread(dev_t dev,struct uio * uio,int flags)652 fdread(dev_t dev, struct uio *uio, int flags)
653 {
654
655 return physio(fdstrategy, NULL, dev, B_READ, fdminphys, uio);
656 }
657
658 static int
fdwrite(dev_t dev,struct uio * uio,int flags)659 fdwrite(dev_t dev, struct uio *uio, int flags)
660 {
661
662 return physio(fdstrategy, NULL, dev, B_WRITE, fdminphys, uio);
663 }
664
665 /*
666 * Called through DMA-dispatcher, get status.
667 */
668 static void
fdstatus(struct fd_softc * sc)669 fdstatus(struct fd_softc *sc)
670 {
671
672 #ifdef FLP_DEBUG
673 printf("fdstatus\n");
674 #endif
675 sc->errcnt = 0;
676 fd_state = FLP_STAT;
677 fd_xfer(sc);
678 }
679
680 /*
681 * Called through the DMA-dispatcher. So we know we are the only ones
682 * messing with the floppy-controller.
683 * Initialize some fields in the fdsoftc for the state-machine and get
684 * it going.
685 */
686 static void
fdstart(struct fd_softc * sc)687 fdstart(struct fd_softc *sc)
688 {
689 struct buf *bp;
690
691 bp = bufq_peek(sc->bufq);
692 sc->sector = bp->b_blkno; /* Start sector for I/O */
693 sc->io_data = bp->b_data; /* KVA base for I/O */
694 sc->io_bytes = bp->b_bcount; /* Transfer size in bytes */
695 sc->io_dir = bp->b_flags & B_READ;/* Direction of transfer */
696 sc->errcnt = 0; /* No errors yet */
697 fd_state = FLP_XFER; /* Yes, we're going to transfer */
698
699 /* Instrumentation. */
700 disk_busy(&sc->dkdev);
701
702 fd_xfer(sc);
703 }
704
705 /*
706 * The current transaction is finished (for good or bad). Let go of
707 * the DMA-resources. Call biodone() to finish the transaction.
708 * Find a new transaction to work on.
709 */
710 static void
fddone(register struct fd_softc * sc)711 fddone(register struct fd_softc *sc)
712 {
713 struct buf *bp;
714 struct fd_softc *sc1;
715 int i, s;
716
717 /*
718 * Give others a chance to use the DMA.
719 */
720 st_dmafree(sc, &lock_stat);
721
722
723 if (fd_state != FLP_STAT) {
724 /*
725 * Finish current transaction.
726 */
727 s = splbio();
728 bp = bufq_get(sc->bufq);
729 if (bp == NULL)
730 panic("fddone");
731 splx(s);
732
733 #ifdef FLP_DEBUG
734 printf("fddone: unit: %d, buf: %p, resid: %d\n",sc->unit, bp,
735 sc->io_bytes);
736 #endif
737 bp->b_resid = sc->io_bytes;
738
739 disk_unbusy(&sc->dkdev, (bp->b_bcount - bp->b_resid),
740 (bp->b_flags & B_READ));
741
742 biodone(bp);
743 }
744 fd_state = FLP_MON;
745
746 if (lock_stat)
747 return; /* XXX Is this possible? */
748
749 /*
750 * Find a new transaction on round-robin basis.
751 */
752 for (i = sc->unit + 1;; i++) {
753 if (i >= fd_cd.cd_ndevs)
754 i = 0;
755 if ((sc1 = device_lookup_private(&fd_cd, i)) == NULL)
756 continue;
757 if (bufq_peek(sc1->bufq) != NULL)
758 break;
759 if (i == sc->unit) {
760 callout_reset(&sc->sc_motor_ch, FLP_MONDELAY,
761 (FPV)fdmotoroff, sc);
762 #ifdef FLP_DEBUG
763 printf("fddone: Nothing to do\n");
764 #endif
765 return; /* No work */
766 }
767 }
768 fd_state = FLP_IDLE;
769 #ifdef FLP_DEBUG
770 printf("fddone: Staring job on unit %d\n", sc1->unit);
771 #endif
772 st_dmagrab((dma_farg)fdcint, (dma_farg)fdstart, sc1, &lock_stat, 0,
773 NULL);
774 }
775
776 static int
fdselect(int drive,int head,int dense)777 fdselect(int drive, int head, int dense)
778 {
779 int i, spinning;
780
781 #ifdef FLP_DEBUG
782 printf("fdselect: drive=%d, head=%d, dense=%d\n", drive, head, dense);
783 #endif
784 i = ((drive == 1) ? PA_FLOP1 : PA_FLOP0) | head;
785 spinning = motoron;
786 motoron = 1;
787
788 switch (dense) {
789 case FLP_DD:
790 DMA->dma_drvmode = 0;
791 break;
792 case FLP_HD:
793 DMA->dma_drvmode = (FDC_HDSET|FDC_HDSIG);
794 break;
795 default:
796 panic("fdselect: unknown density code");
797 }
798 if (i != selected) {
799 selected = i;
800 ym2149_fd_select((i ^ PA_FDSEL));
801 }
802 return spinning;
803 }
804
805 static void
fddeselect(void)806 fddeselect(void)
807 {
808
809 ym2149_fd_select(PA_FDSEL);
810 motoron = selected = 0;
811 DMA->dma_drvmode = 0;
812 }
813
814 /****************************************************************************
815 * The following functions assume to be running as a result of a *
816 * disk-interrupt (e.q. spl = splbio). *
817 * They form the finit-state machine, the actual driver. *
818 * *
819 * fdstart()/ --> fd_xfer() -> activate hardware *
820 * fdopen() ^ *
821 * | *
822 * +-- not ready -<------------+ *
823 * | *
824 * fdmotoroff()/ --> fdcint() -> fd_xfer_ok() ---+ *
825 * h/w interrupt | *
826 * \|/ *
827 * finished ---> fdone() *
828 * *
829 ****************************************************************************/
830 static void
fd_xfer(struct fd_softc * sc)831 fd_xfer(struct fd_softc *sc)
832 {
833 int head;
834 int track, sector, hbit;
835 paddr_t phys_addr;
836
837 head = track = 0;
838 switch (fd_state) {
839 case FLP_XFER:
840 /*
841 * Calculate head/track values
842 */
843 track = sc->sector / sc->nsectors;
844 head = track % sc->nheads;
845 track = track / sc->nheads;
846 #ifdef FLP_DEBUG
847 printf("fd_xfer: sector:%d,head:%d,track:%d\n",
848 sc->sector, head, track);
849 #endif
850 break;
851
852 case FLP_STAT:
853 /*
854 * FLP_STAT only wants to recalibrate
855 */
856 sc->curtrk = INV_TRK;
857 break;
858 default:
859 panic("fd_xfer: wrong state (0x%x)", fd_state);
860 }
861
862 /*
863 * Select the drive.
864 */
865 hbit = fdselect(sc->unit, head, sc->density) ? HBIT : 0;
866
867 if (sc->curtrk == INV_TRK) {
868 /*
869 * Recalibrate, since we lost track of head positioning.
870 * The floppy disk controller has no way of determining its
871 * absolute arm position (track). Instead, it steps the
872 * arm a track at a time and keeps track of where it
873 * thinks it is (in software). However, after a SEEK, the
874 * hardware reads information from the diskette telling
875 * where the arm actually is. If the arm is in the wrong place,
876 * a recalibration is done, which forces the arm to track 0.
877 * This way the controller can get back into sync with reality.
878 */
879 fd_cmd = RESTORE;
880 write_fdreg(FDC_CS, RESTORE|VBIT|hbit);
881 callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY,
882 (FPV)fdmotoroff, sc);
883
884 #ifdef FLP_DEBUG
885 printf("fd_xfer:Recalibrating drive %d\n", sc->unit);
886 #endif
887 return;
888 }
889
890 write_fdreg(FDC_TR, sc->curtrk);
891
892 /*
893 * Issue a SEEK command on the indicated drive unless the arm is
894 * already positioned on the correct track.
895 */
896 if (track != sc->curtrk) {
897 sc->curtrk = track; /* be optimistic */
898 write_fdreg(FDC_DR, track);
899 write_fdreg(FDC_CS, SEEK|RATE6|VBIT|hbit);
900 callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY,
901 (FPV)fdmotoroff, sc);
902 fd_cmd = SEEK;
903 #ifdef FLP_DEBUG
904 printf("fd_xfer:Seek to track %d on drive %d\n",
905 track, sc->unit);
906 #endif
907 return;
908 }
909
910 /*
911 * The drive is now on the proper track. Read or write 1 block.
912 */
913 sector = sc->sector % sc->nsectors;
914 sector++; /* start numbering at 1 */
915
916 write_fdreg(FDC_SR, sector);
917
918 phys_addr = (paddr_t)kvtop(sc->io_data);
919 if (phys_addr >= FDC_MAX_DMA_AD) {
920 /*
921 * We _must_ bounce this address
922 */
923 phys_addr = (paddr_t)kvtop(sc->bounceb);
924 if (sc->io_dir == B_WRITE)
925 memcpy(sc->bounceb, sc->io_data, SECTOR_SIZE);
926 sc->flags |= FLPF_BOUNCE;
927 }
928 st_dmaaddr_set((void *)phys_addr); /* DMA address setup */
929
930 #ifdef FLP_DEBUG
931 printf("fd_xfer:Start io (io_addr:%lx)\n", (u_long)kvtop(sc->io_data));
932 #endif
933
934 if (sc->io_dir == B_READ) {
935 /* Issue the command */
936 st_dmacomm(DMA_FDC | DMA_SCREG, 1);
937 write_fdreg(FDC_CS, F_READ|hbit);
938 fd_cmd = F_READ;
939 } else {
940 /* Issue the command */
941 st_dmacomm(DMA_WRBIT | DMA_FDC | DMA_SCREG, 1);
942 write_fdreg(DMA_WRBIT | FDC_CS, F_WRITE|hbit|EBIT|PBIT);
943 fd_cmd = F_WRITE;
944 }
945 callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY, (FPV)fdmotoroff, sc);
946 }
947
948 /* return values of fd_xfer_ok(): */
949 #define X_OK 0
950 #define X_AGAIN 1
951 #define X_ERROR 2
952 #define X_FAIL 3
953
954 /*
955 * Hardware interrupt function.
956 */
957 static void
fdcint(struct fd_softc * sc)958 fdcint(struct fd_softc *sc)
959 {
960 struct buf *bp;
961
962 #ifdef FLP_DEBUG
963 printf("fdcint: unit = %d\n", sc->unit);
964 #endif
965
966 /*
967 * Cancel timeout (we made it, didn't we)
968 */
969 callout_stop(&sc->sc_motor_ch);
970
971 switch (fd_xfer_ok(sc)) {
972 case X_ERROR:
973 if (++sc->errcnt < MAX_ERRORS) {
974 /*
975 * Command failed but still retries left.
976 */
977 break;
978 }
979 /* FALL THROUGH */
980 case X_FAIL:
981 /*
982 * Non recoverable error. Fall back to motor-on
983 * idle-state.
984 */
985 if (fd_error != NULL) {
986 printf("Floppy error: %s\n", fd_error);
987 fd_error = NULL;
988 }
989
990 if (fd_state == FLP_STAT) {
991 sc->flags |= FLPF_EMPTY;
992 sc->flags &= ~FLPF_GETSTAT;
993 wakeup((void *)sc);
994 fddone(sc);
995 return;
996 }
997
998 bp = bufq_peek(sc->bufq);
999
1000 bp->b_error = EIO;
1001 fd_state = FLP_MON;
1002
1003 break;
1004 case X_AGAIN:
1005 /*
1006 * Start next part of state machine.
1007 */
1008 break;
1009 case X_OK:
1010 /*
1011 * Command ok and finished. Reset error-counter.
1012 * If there are no more bytes to transfer fall back
1013 * to motor-on idle state.
1014 */
1015 sc->errcnt = 0;
1016
1017 if (fd_state == FLP_STAT) {
1018 sc->flags &= ~FLPF_GETSTAT;
1019 wakeup((void *)sc);
1020 fddone(sc);
1021 return;
1022 }
1023
1024 if ((sc->flags & FLPF_BOUNCE) != 0 &&
1025 sc->io_dir == B_READ)
1026 memcpy(sc->io_data, sc->bounceb, SECTOR_SIZE);
1027 sc->flags &= ~FLPF_BOUNCE;
1028
1029 sc->sector++;
1030 sc->io_data += SECTOR_SIZE;
1031 sc->io_bytes -= SECTOR_SIZE;
1032 if (sc->io_bytes <= 0)
1033 fd_state = FLP_MON;
1034 }
1035 if (fd_state == FLP_MON)
1036 fddone(sc);
1037 else
1038 fd_xfer(sc);
1039 }
1040
1041 /*
1042 * Determine status of last command. Should only be called through
1043 * 'fdcint()'.
1044 * Returns:
1045 * X_ERROR : Error on command; might succeed next time.
1046 * X_FAIL : Error on command; will never succeed.
1047 * X_AGAIN : Part of a command succeeded, call 'fd_xfer()' to complete.
1048 * X_OK : Command succeeded and is complete.
1049 *
1050 * This function only affects sc->curtrk.
1051 */
1052 static int
fd_xfer_ok(register struct fd_softc * sc)1053 fd_xfer_ok(register struct fd_softc *sc)
1054 {
1055 int status;
1056
1057 #ifdef FLP_DEBUG
1058 printf("fd_xfer_ok: cmd: 0x%x, state: 0x%x\n", fd_cmd, fd_state);
1059 #endif
1060 switch (fd_cmd) {
1061 case IRUPT:
1062 /*
1063 * Timeout. Force a recalibrate before we try again.
1064 */
1065 status = read_fdreg(FDC_CS);
1066
1067 fd_error = "Timeout";
1068 sc->curtrk = INV_TRK;
1069 return X_ERROR;
1070 case F_READ:
1071 /*
1072 * Test for DMA error
1073 */
1074 status = read_dmastat();
1075 if ((status & DMAOK) == 0) {
1076 fd_error = "DMA error";
1077 return X_ERROR;
1078 }
1079 /*
1080 * Get controller status and check for errors.
1081 */
1082 status = read_fdreg(FDC_CS);
1083 if ((status & (RNF | CRCERR | LD_T00)) != 0) {
1084 fd_error = "Read error";
1085 if ((status & RNF) != 0)
1086 sc->curtrk = INV_TRK;
1087 return X_ERROR;
1088 }
1089 break;
1090 case F_WRITE:
1091 /*
1092 * Test for DMA error
1093 */
1094 status = read_dmastat();
1095 if ((status & DMAOK) == 0) {
1096 fd_error = "DMA error";
1097 return X_ERROR;
1098 }
1099 /*
1100 * Get controller status and check for errors.
1101 */
1102 status = read_fdreg(FDC_CS);
1103 if ((status & WRI_PRO) != 0) {
1104 fd_error = "Write protected";
1105 return X_FAIL;
1106 }
1107 if ((status & (RNF | CRCERR | LD_T00)) != 0) {
1108 fd_error = "Write error";
1109 sc->curtrk = INV_TRK;
1110 return X_ERROR;
1111 }
1112 break;
1113 case SEEK:
1114 status = read_fdreg(FDC_CS);
1115 if ((status & (RNF | CRCERR)) != 0) {
1116 fd_error = "Seek error";
1117 sc->curtrk = INV_TRK;
1118 return X_ERROR;
1119 }
1120 return X_AGAIN;
1121 case RESTORE:
1122 /*
1123 * Determine if the recalibration succeeded.
1124 */
1125 status = read_fdreg(FDC_CS);
1126 if ((status & RNF) != 0) {
1127 fd_error = "Recalibrate error";
1128 /* reset controller */
1129 write_fdreg(FDC_CS, IRUPT);
1130 sc->curtrk = INV_TRK;
1131 return X_ERROR;
1132 }
1133 sc->curtrk = 0;
1134 if (fd_state == FLP_STAT) {
1135 if ((status & WRI_PRO) != 0)
1136 sc->flags |= FLPF_WRTPROT;
1137 break;
1138 }
1139 return X_AGAIN;
1140 default:
1141 fd_error = "Driver error: fd_xfer_ok : Unknown state";
1142 return X_FAIL;
1143 }
1144 return X_OK;
1145 }
1146
1147 /*
1148 * All timeouts will call this function.
1149 */
1150 static void
fdmotoroff(struct fd_softc * sc)1151 fdmotoroff(struct fd_softc *sc)
1152 {
1153 int s;
1154
1155 /*
1156 * Get at harware interrupt level
1157 */
1158 s = splbio();
1159
1160 #if FLP_DEBUG
1161 printf("fdmotoroff, state = 0x%x\n", fd_state);
1162 #endif
1163
1164 switch (fd_state) {
1165 case FLP_STAT:
1166 case FLP_XFER:
1167 /*
1168 * Timeout during a transfer; cancel transaction
1169 * set command to 'IRUPT'.
1170 * A drive-interrupt is simulated to trigger the state
1171 * machine.
1172 */
1173 /*
1174 * Cancel current transaction
1175 */
1176 fd_cmd = IRUPT;
1177 write_fdreg(FDC_CS, IRUPT);
1178 delay(20);
1179 (void)read_fdreg(FDC_CS);
1180 write_fdreg(FDC_CS, RESTORE);
1181 break;
1182
1183 case FLP_MON:
1184 /*
1185 * Turn motor off.
1186 */
1187 if (selected) {
1188 int tmp;
1189
1190 st_dmagrab((dma_farg)fdcint, (dma_farg)fdmoff, sc,
1191 &tmp, 0, NULL);
1192 } else
1193 fd_state = FLP_IDLE;
1194 break;
1195 }
1196 splx(s);
1197 }
1198
1199 /*
1200 * min byte count to whats left of the track in question
1201 */
1202 static void
fdminphys(struct buf * bp)1203 fdminphys(struct buf *bp)
1204 {
1205 struct fd_softc *sc;
1206 int sec, toff, tsz;
1207
1208 if ((sc = device_lookup_private(&fd_cd, DISKUNIT(bp->b_dev))) == NULL)
1209 panic("fdminphys: couldn't get softc");
1210
1211 sec = bp->b_blkno % (sc->nsectors * sc->nheads);
1212 toff = sec * SECTOR_SIZE;
1213 tsz = sc->nsectors * sc->nheads * SECTOR_SIZE;
1214
1215 #ifdef FLP_DEBUG
1216 printf("fdminphys: before %ld", bp->b_bcount);
1217 #endif
1218
1219 bp->b_bcount = uimin(bp->b_bcount, tsz - toff);
1220
1221 #ifdef FLP_DEBUG
1222 printf(" after %ld\n", bp->b_bcount);
1223 #endif
1224
1225 minphys(bp);
1226 }
1227
1228 /*
1229 * Called from fdmotoroff to turn the motor actually off....
1230 * This can't be done in fdmotoroff itself, because exclusive access to the
1231 * DMA controller is needed to read the FDC-status register. The function
1232 * 'fdmoff()' always runs as the result of a 'dmagrab()'.
1233 * We need to test the status-register because we want to be sure that the
1234 * drive motor is really off before deselecting the drive. The FDC only
1235 * turns off the drive motor after having seen 10 index-pulses. You only
1236 * get index-pulses when a drive is selected....This means that if the
1237 * drive is deselected when the motor is still spinning, it will continue
1238 * to spin _even_ when you insert a floppy later on...
1239 */
1240 static void
fdmoff(struct fd_softc * fdsoftc)1241 fdmoff(struct fd_softc *fdsoftc)
1242 {
1243 int tmp;
1244
1245 if ((fd_state == FLP_MON) && selected) {
1246 tmp = read_fdreg(FDC_CS);
1247 if ((tmp & MOTORON) == 0) {
1248 fddeselect();
1249 fd_state = FLP_IDLE;
1250 } else
1251 callout_reset(&fdsoftc->sc_motor_ch, 10 * FLP_MONDELAY,
1252 (FPV)fdmotoroff, fdsoftc);
1253 }
1254 st_dmafree(fdsoftc, &tmp);
1255 }
1256
1257 /*
1258 * Used to find out which drives are actually connected. We do this by issuing
1259 * is 'RESTORE' command and check if the 'track-0' bit is set. This also works
1260 * if the drive is present but no floppy is inserted.
1261 */
1262 static void
fdtestdrv(struct fd_softc * fdsoftc)1263 fdtestdrv(struct fd_softc *fdsoftc)
1264 {
1265 int status;
1266
1267 /*
1268 * Select the right unit and head.
1269 */
1270 fdselect(fdsoftc->unit, 0, FLP_DD);
1271
1272 write_fdreg(FDC_CS, RESTORE|HBIT);
1273
1274 /*
1275 * Wait for about 2 seconds.
1276 */
1277 delay(2000000);
1278
1279 status = read_fdreg(FDC_CS);
1280 if ((status & (RNF|BUSY)) != 0) {
1281 write_fdreg(FDC_CS, IRUPT); /* reset controller */
1282 delay(40);
1283 }
1284
1285 if ((status & LD_T00) == 0)
1286 fdsoftc->flags |= FLPF_NOTRESP;
1287
1288 fddeselect();
1289 }
1290
1291 static void
fdgetdefaultlabel(struct fd_softc * sc,struct disklabel * lp,int part)1292 fdgetdefaultlabel(struct fd_softc *sc, struct disklabel *lp, int part)
1293 {
1294
1295 memset(lp, 0, sizeof(struct disklabel));
1296
1297 lp->d_secsize = SECTOR_SIZE;
1298 lp->d_ntracks = sc->nheads;
1299 lp->d_nsectors = sc->nsectors;
1300 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
1301 lp->d_ncylinders = sc->nblocks / lp->d_secpercyl;
1302 lp->d_secperunit = sc->nblocks;
1303
1304 lp->d_type = DKTYPE_FLOPPY;
1305 lp->d_rpm = 300; /* good guess I suppose. */
1306 lp->d_interleave = 1; /* FIXME: is this OK? */
1307 lp->d_bbsize = 0;
1308 lp->d_sbsize = 0;
1309 lp->d_npartitions = part + 1;
1310 lp->d_trkseek = STEP_DELAY;
1311 lp->d_magic = DISKMAGIC;
1312 lp->d_magic2 = DISKMAGIC;
1313 lp->d_checksum = dkcksum(lp);
1314 lp->d_partitions[part].p_size = lp->d_secperunit;
1315 lp->d_partitions[part].p_fstype = FS_UNUSED;
1316 lp->d_partitions[part].p_fsize = 1024;
1317 lp->d_partitions[part].p_frag = 8;
1318 }
1319
1320 /*
1321 * Build disk label. For now we only create a label from what we know
1322 * from 'sc'.
1323 */
1324 static int
fdgetdisklabel(struct fd_softc * sc,dev_t dev)1325 fdgetdisklabel(struct fd_softc *sc, dev_t dev)
1326 {
1327 struct disklabel *lp;
1328 int part;
1329
1330 /*
1331 * If we already got one, get out.
1332 */
1333 if ((sc->flags & FLPF_HAVELAB) != 0)
1334 return 0;
1335
1336 #ifdef FLP_DEBUG
1337 printf("fdgetdisklabel()\n");
1338 #endif
1339
1340 part = RAW_PART;
1341 lp = sc->dkdev.dk_label;
1342 fdgetdefaultlabel(sc, lp, part);
1343 sc->flags |= FLPF_HAVELAB;
1344
1345 return 0;
1346 }
1347