1/*-
2 * Copyright (c) 1990 The Regents of the University of California.
3 * All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Don Ahn.
7 *
8 * Libretto PCMCIA floppy support by David Horwitt (dhorwitt@ucsd.edu)
9 * aided by the Linux floppy driver modifications from David Bateman
10 * (dbateman@eng.uts.edu.au).
11 *
12 * Copyright (c) 1993, 1994 by
13 * jc@irbs.UUCP (John Capo)
14 * vak@zebub.msk.su (Serge Vakulenko)
15 * ache@astral.msk.su (Andrew A. Chernov)
16 *
17 * Copyright (c) 1993, 1994, 1995 by
18 * joerg_wunsch@uriah.sax.de (Joerg Wunsch)
19 * dufault@hda.com (Peter Dufault)
20 *
21 * Copyright (c) 2001 Joerg Wunsch,
22 * joerg_wunsch@uriah.heep.sax.de (Joerg Wunsch)
23 *
24 * Redistribution and use in source and binary forms, with or without
25 * modification, are permitted provided that the following conditions
26 * are met:
27 * 1. Redistributions of source code must retain the above copyright
28 * notice, this list of conditions and the following disclaimer.
29 * 2. Redistributions in binary form must reproduce the above copyright
30 * notice, this list of conditions and the following disclaimer in the
31 * documentation and/or other materials provided with the distribution.
32 * 3. All advertising materials mentioning features or use of this software
33 * must display the following acknowledgement:
34 * This product includes software developed by the University of
35 * California, Berkeley and its contributors.
36 * 4. Neither the name of the University nor the names of its contributors
37 * may be used to endorse or promote products derived from this software
38 * without specific prior written permission.
39 *
40 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50 * SUCH DAMAGE.
51 *
52 * from: @(#)fd.c 7.4 (Berkeley) 5/25/91
| 1/*-
2 * Copyright (c) 1990 The Regents of the University of California.
3 * All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Don Ahn.
7 *
8 * Libretto PCMCIA floppy support by David Horwitt (dhorwitt@ucsd.edu)
9 * aided by the Linux floppy driver modifications from David Bateman
10 * (dbateman@eng.uts.edu.au).
11 *
12 * Copyright (c) 1993, 1994 by
13 * jc@irbs.UUCP (John Capo)
14 * vak@zebub.msk.su (Serge Vakulenko)
15 * ache@astral.msk.su (Andrew A. Chernov)
16 *
17 * Copyright (c) 1993, 1994, 1995 by
18 * joerg_wunsch@uriah.sax.de (Joerg Wunsch)
19 * dufault@hda.com (Peter Dufault)
20 *
21 * Copyright (c) 2001 Joerg Wunsch,
22 * joerg_wunsch@uriah.heep.sax.de (Joerg Wunsch)
23 *
24 * Redistribution and use in source and binary forms, with or without
25 * modification, are permitted provided that the following conditions
26 * are met:
27 * 1. Redistributions of source code must retain the above copyright
28 * notice, this list of conditions and the following disclaimer.
29 * 2. Redistributions in binary form must reproduce the above copyright
30 * notice, this list of conditions and the following disclaimer in the
31 * documentation and/or other materials provided with the distribution.
32 * 3. All advertising materials mentioning features or use of this software
33 * must display the following acknowledgement:
34 * This product includes software developed by the University of
35 * California, Berkeley and its contributors.
36 * 4. Neither the name of the University nor the names of its contributors
37 * may be used to endorse or promote products derived from this software
38 * without specific prior written permission.
39 *
40 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50 * SUCH DAMAGE.
51 *
52 * from: @(#)fd.c 7.4 (Berkeley) 5/25/91
|
53 * $FreeBSD: head/sys/pc98/cbus/fdc.c 132210 2004-07-15 15:00:02Z nyan $
| 53 * $FreeBSD: head/sys/pc98/cbus/fdc.c 132286 2004-07-17 10:07:19Z nyan $
|
54 */
55
56#include "opt_fdc.h"
57
58#include <sys/param.h>
59#include <sys/bio.h>
60#include <sys/bus.h>
61#include <sys/devicestat.h>
62#include <sys/disk.h>
63#include <sys/fcntl.h>
64#include <sys/fdcio.h>
65#include <sys/filio.h>
66#include <sys/kernel.h>
67#include <sys/lock.h>
68#include <sys/malloc.h>
69#include <sys/module.h>
70#include <sys/mutex.h>
71#include <sys/proc.h>
72#include <sys/rman.h>
73#include <sys/systm.h>
74
75#include <machine/bus.h>
76#include <machine/clock.h>
77#include <machine/stdarg.h>
78
79#ifdef PC98
80#include <isa/isavar.h>
81#include <pc98/pc98/pc98.h>
82#include <pc98/pc98/pc98_machdep.h>
83#include <pc98/pc98/epsonio.h>
84#include <pc98/pc98/fdreg.h>
85#include <pc98/pc98/fdcvar.h>
86#else
87#include <isa/isavar.h>
88#include <isa/isareg.h>
89#include <dev/fdc/fdcreg.h>
90#include <dev/fdc/fdcvar.h>
91#include <isa/rtc.h>
92#endif
93
94#define FDBIO_FORMAT BIO_CMD2
95
96/* configuration flags for fdc */
97#define FDC_NO_FIFO (1 << 2) /* do not enable FIFO */
98
99/*
100 * Stop retrying after this many DMA overruns. Since each retry takes
101 * one revolution, with 300 rpm., 25 retries take approximately 5
102 * seconds which the read attempt will block in case the DMA overrun
103 * is persistent.
104 */
105#define FDC_DMAOV_MAX 25
106
107/*
108 * Timeout value for the PIO loops to wait until the FDC main status
109 * register matches our expectations (request for master, direction
110 * bit). This is supposed to be a number of microseconds, although
111 * timing might actually not be very accurate.
112 *
113 * Timeouts of 100 msec are believed to be required for some broken
114 * (old) hardware.
115 */
116#define FDSTS_TIMEOUT 100000
117
118/*
119 * Number of subdevices that can be used for different density types.
120 */
121#ifdef PC98
122#define NUMDENS 12
123#else
124#define NUMDENS 16
125#endif
126
127#define FDBIO_RDSECTID BIO_CMD1
128
129/*
130 * List of native drive densities. Order must match enum fd_drivetype
131 * in <sys/fdcio.h>. Upon attaching the drive, each of the
132 * programmable subdevices is initialized with the native density
133 * definition.
134 */
135#ifdef PC98
136static struct fd_type fd_native_types[] =
137{
138{ 0 }, /* FDT_NONE */
139{ 0 }, /* FDT_360K */
140{ 15,2,0xFF,0x1B,80,2400,0,2,0x54,1,0,0 }, /* FDT_12M */
141{ 0 }, /* FDT_720K */
142{ 18,2,0xFF,0x1B,80,2880,2,2,0x54,1,0,0 }, /* FDT_144M */
143{ 0 }, /* FDT_288M */
144};
145
146static struct fd_type fd_searchlist_12m[] = {
147{ 15,2,0xFF,0x1B,80,2400,0,2,0x54,1,0,FL_MFM }, /* 1.2M */
148#if 0
149{ 10,2,0xFF,0x10,82,1640,1,2,0x30,1,0,FL_MFM }, /* 820K */
150{ 10,2,0xFF,0x10,80,1600,1,2,0x30,1,0,FL_MFM }, /* 800K */
151#endif
152{ 9,2,0xFF,0x20,80,1440,1,2,0x50,1,0,FL_MFM }, /* 720K */
153{ 9,2,0xFF,0x20,40, 720,1,2,0x50,1,0,FL_MFM|FL_2STEP },/* 360K */
154{ 8,2,0xFF,0x2A,80,1280,1,2,0x50,1,0,FL_MFM }, /* 640K */
155{ 8,3,0xFF,0x35,77,1232,0,2,0x74,1,0,FL_MFM }, /* 1.23M 1024/sec */
156#if 0
157{ 8,3,0xFF,0x35,80,1280,0,2,0x74,1,0,FL_MFM }, /* 1.28M 1024/sec */
158#endif
159};
160static struct fd_type fd_searchlist_144m[] = {
161#if 0
162{ 21,2,0xFF,0x04,82,3444,2,2,0x0C,2,0,FL_MFM }, /* 1.72M in 3mode */
163{ 18,2,0xFF,0x1B,82,2952,2,2,0x54,1,0,FL_MFM }, /* 1.48M in 3mode */
164#endif
165{ 18,2,0xFF,0x1B,80,2880,2,2,0x54,1,0,FL_MFM }, /* 1.44M in 3mode */
166{ 15,2,0xFF,0x1B,80,2400,0,2,0x54,1,0,FL_MFM }, /* 1.2M */
167#if 0
168{ 10,2,0xFF,0x10,82,1640,1,2,0x30,1,0,FL_MFM }, /* 820K */
169{ 10,2,0xFF,0x10,80,1600,1,2,0x30,1,0,FL_MFM }, /* 800K */
170#endif
171{ 9,2,0xFF,0x20,80,1440,1,2,0x50,1,0,FL_MFM }, /* 720K */
172{ 9,2,0xFF,0x20,40, 720,1,2,0x50,1,0,FL_MFM|FL_2STEP },/* 360K */
173{ 8,2,0xFF,0x2A,80,1280,1,2,0x50,1,0,FL_MFM }, /* 640K */
174{ 8,3,0xFF,0x35,77,1232,0,2,0x74,1,0,FL_MFM }, /* 1.23M 1024/sec */
175#if 0
176{ 8,3,0xFF,0x35,80,1280,0,2,0x74,1,0,FL_MFM }, /* 1.28M 1024/sec */
177{ 9,3,0xFF,0x35,82,1476,0,2,0x47,1,0,FL_MFM }, /* 1.48M 1024/sec 9sec */
178{ 10,3,0xFF,0x1B,82,1640,2,2,0x54,1,0,FL_MFM }, /* 1.64M in 3mode - Reserve */
179#endif
180};
181#else /* PC98 */
182static struct fd_type fd_native_types[] =
183{
184{ 0 }, /* FDT_NONE */
185{ 9,2,0xFF,0x2A,40, 720,FDC_250KBPS,2,0x50,1,0,FL_MFM }, /* FDT_360K */
186{ 15,2,0xFF,0x1B,80,2400,FDC_500KBPS,2,0x54,1,0,FL_MFM }, /* FDT_12M */
187{ 9,2,0xFF,0x20,80,1440,FDC_250KBPS,2,0x50,1,0,FL_MFM }, /* FDT_720K */
188{ 18,2,0xFF,0x1B,80,2880,FDC_500KBPS,2,0x6C,1,0,FL_MFM }, /* FDT_144M */
189#if 0 /* we currently don't handle 2.88 MB */
190{ 36,2,0xFF,0x1B,80,5760,FDC_1MBPS, 2,0x4C,1,1,FL_MFM|FL_PERPND } /*FDT_288M*/
191#else
192{ 18,2,0xFF,0x1B,80,2880,FDC_500KBPS,2,0x6C,1,0,FL_MFM }, /* FDT_144M */
193#endif
194};
195
196/*
197 * 360 KB 5.25" and 720 KB 3.5" drives don't have automatic density
198 * selection, they just start out with their native density (or lose).
199 * So 1.2 MB 5.25", 1.44 MB 3.5", and 2.88 MB 3.5" drives have their
200 * respective lists of densities to search for.
201 */
202static struct fd_type fd_searchlist_12m[] = {
203{ 15,2,0xFF,0x1B,80,2400,FDC_500KBPS,2,0x54,1,0,FL_MFM }, /* 1.2M */
204{ 9,2,0xFF,0x23,40, 720,FDC_300KBPS,2,0x50,1,0,FL_MFM|FL_2STEP }, /* 360K */
205{ 9,2,0xFF,0x20,80,1440,FDC_300KBPS,2,0x50,1,0,FL_MFM }, /* 720K */
206};
207
208static struct fd_type fd_searchlist_144m[] = {
209{ 18,2,0xFF,0x1B,80,2880,FDC_500KBPS,2,0x6C,1,0,FL_MFM }, /* 1.44M */
210{ 9,2,0xFF,0x20,80,1440,FDC_250KBPS,2,0x50,1,0,FL_MFM }, /* 720K */
211};
212
213/* We search for 1.44M first since this is the most common case. */
214static struct fd_type fd_searchlist_288m[] = {
215{ 18,2,0xFF,0x1B,80,2880,FDC_500KBPS,2,0x6C,1,0,FL_MFM }, /* 1.44M */
216#if 0
217{ 36,2,0xFF,0x1B,80,5760,FDC_1MBPS, 2,0x4C,1,1,FL_MFM|FL_PERPND } /* 2.88M */
218#endif
219{ 9,2,0xFF,0x20,80,1440,FDC_250KBPS,2,0x50,1,0,FL_MFM }, /* 720K */
220};
221#endif /* PC98 */
222
223#define MAX_SEC_SIZE (128 << 3)
224#define MAX_CYLINDER 85 /* some people really stress their drives
225 * up to cyl 82 */
226#define MAX_HEAD 1
227
228devclass_t fdc_devclass;
229
230/*
231 * Per drive structure (softc).
232 */
233struct fd_data {
234 struct fdc_data *fdc; /* pointer to controller structure */
235 int fdsu; /* this units number on this controller */
236 enum fd_drivetype type; /* drive type */
237 struct fd_type *ft; /* pointer to current type descriptor */
238 struct fd_type fts[NUMDENS]; /* type descriptors */
239 int flags;
240#define FD_OPEN 0x01 /* it's open */
241#define FD_NONBLOCK 0x02 /* O_NONBLOCK set */
242#define FD_ACTIVE 0x04 /* it's active */
243#define FD_MOTOR 0x08 /* motor should be on */
244#define FD_MOTOR_WAIT 0x10 /* motor coming up */
245#define FD_UA 0x20 /* force unit attention */
246 int skip;
247 int hddrv;
248#define FD_NO_TRACK -2
249 int track; /* where we think the head is */
250 int options; /* user configurable options, see fdcio.h */
251 struct callout_handle toffhandle;
252 struct callout_handle tohandle;
253 struct devstat *device_stats;
254 struct cdev *masterdev;
255 device_t dev;
256 fdu_t fdu;
257#ifdef PC98
258 int pc98_trans;
259#endif
260};
261
262struct fdc_ivars {
263 int fdunit;
264 int fdtype;
265};
266
267static devclass_t fd_devclass;
268
269/* configuration flags for fd */
270#define FD_TYPEMASK 0x0f /* drive type, matches enum
271 * fd_drivetype; on i386 machines, if
272 * given as 0, use RTC type for fd0
273 * and fd1 */
274#define FD_DTYPE(flags) ((flags) & FD_TYPEMASK)
275#define FD_NO_CHLINE 0x10 /* drive does not support changeline
276 * aka. unit attention */
277#define FD_NO_PROBE 0x20 /* don't probe drive (seek test), just
278 * assume it is there */
279
280#ifdef EPSON_NRDISK
281typedef unsigned int nrd_t;
282
283#define P_NRD_ADDRH 0xc24
284#define P_NRD_ADDRM 0xc22
285#define P_NRD_ADDRL 0xc20
286#define P_NRD_CHECK 0xc20
287#define P_NRD_DATA 0xc26
288#define P_NRD_LED 0xc36
289#define B_NRD_CHK 0x80
290#define B_NRD_LED 0x40
291#define A_NRD_INFO 0x2
292#define A_NRD_BASE 0x400
293#define NRD_STATUS 0x0
294#define NRD_ST0_HD 0x04
295
296static fdu_t nrdu=-1;
297static int nrdsec=0;
298static nrd_t nrdblkn=0;
299static nrd_t nrdaddr=0x0;
300
301#define nrd_check_ready() ({ \
302 (epson_inb(P_NRD_CHECK) & B_NRD_CHK) ? 0 : 1; \
303 })
304#define nrd_LED_on() epson_outb(P_NRD_LED, B_NRD_LED)
305#define nrd_LED_off() epson_outb(P_NRD_LED, ~B_NRD_LED)
306#define nrd_trac() ((int)(nrd_info(nrdaddr) & 0xff))
307#define nrd_head() ((int)((nrd_info(nrdaddr) >> 8) & 0xff))
308#define nrd_sec() ((int)(nrd_info(nrdaddr + 2) & 0xff))
309#define nrd_secsize() ((int)((nrd_info(A_NRD_INFO) >> 8) & 0xff))
310#define nrd_addrset(p) nrd_addr((nrd_t)((nrd_t)p+A_NRD_BASE))
311
312static inline void
313nrd_addr(addr)
314 nrd_t addr;
315{
316 epson_outb(P_NRD_ADDRH, (u_char)((addr >> 16) & 0x1f));
317 epson_outb(P_NRD_ADDRM, (u_char)((addr >> 8) & 0xff));
318 epson_outb(P_NRD_ADDRL, (u_char)(addr & 0xff));
319}
320
321static inline u_short
322nrd_info(addr)
323 nrd_t addr;
324{
325 nrd_addr(addr);
326 return (epson_inw(P_NRD_DATA));
327}
328#endif /* EPSON_NRDISK */
329
330/*
331 * Throughout this file the following conventions will be used:
332 *
333 * fd is a pointer to the fd_data struct for the drive in question
334 * fdc is a pointer to the fdc_data struct for the controller
335 * fdu is the floppy drive unit number
336 * fdcu is the floppy controller unit number
337 * fdsu is the floppy drive unit number on that controller. (sub-unit)
338 */
339
340/*
341 * Function declarations, same (chaotic) order as they appear in the
342 * file. Re-ordering is too late now, it would only obfuscate the
343 * diffs against old and offspring versions (like the PC98 one).
344 *
345 * Anyone adding functions here, please keep this sequence the same
346 * as below -- makes locating a particular function in the body much
347 * easier.
348 */
349static u_int8_t fdsts_rd(fdc_p);
350static void fddata_wr(fdc_p, u_int8_t);
351static u_int8_t fddata_rd(fdc_p);
352static int fdc_err(struct fdc_data *, const char *);
353static int enable_fifo(fdc_p fdc);
354static int fd_sense_drive_status(fdc_p, int *);
355static int fd_sense_int(fdc_p, int *, int *);
356static int fd_read_status(fdc_p);
| 54 */
55
56#include "opt_fdc.h"
57
58#include <sys/param.h>
59#include <sys/bio.h>
60#include <sys/bus.h>
61#include <sys/devicestat.h>
62#include <sys/disk.h>
63#include <sys/fcntl.h>
64#include <sys/fdcio.h>
65#include <sys/filio.h>
66#include <sys/kernel.h>
67#include <sys/lock.h>
68#include <sys/malloc.h>
69#include <sys/module.h>
70#include <sys/mutex.h>
71#include <sys/proc.h>
72#include <sys/rman.h>
73#include <sys/systm.h>
74
75#include <machine/bus.h>
76#include <machine/clock.h>
77#include <machine/stdarg.h>
78
79#ifdef PC98
80#include <isa/isavar.h>
81#include <pc98/pc98/pc98.h>
82#include <pc98/pc98/pc98_machdep.h>
83#include <pc98/pc98/epsonio.h>
84#include <pc98/pc98/fdreg.h>
85#include <pc98/pc98/fdcvar.h>
86#else
87#include <isa/isavar.h>
88#include <isa/isareg.h>
89#include <dev/fdc/fdcreg.h>
90#include <dev/fdc/fdcvar.h>
91#include <isa/rtc.h>
92#endif
93
94#define FDBIO_FORMAT BIO_CMD2
95
96/* configuration flags for fdc */
97#define FDC_NO_FIFO (1 << 2) /* do not enable FIFO */
98
99/*
100 * Stop retrying after this many DMA overruns. Since each retry takes
101 * one revolution, with 300 rpm., 25 retries take approximately 5
102 * seconds which the read attempt will block in case the DMA overrun
103 * is persistent.
104 */
105#define FDC_DMAOV_MAX 25
106
107/*
108 * Timeout value for the PIO loops to wait until the FDC main status
109 * register matches our expectations (request for master, direction
110 * bit). This is supposed to be a number of microseconds, although
111 * timing might actually not be very accurate.
112 *
113 * Timeouts of 100 msec are believed to be required for some broken
114 * (old) hardware.
115 */
116#define FDSTS_TIMEOUT 100000
117
118/*
119 * Number of subdevices that can be used for different density types.
120 */
121#ifdef PC98
122#define NUMDENS 12
123#else
124#define NUMDENS 16
125#endif
126
127#define FDBIO_RDSECTID BIO_CMD1
128
129/*
130 * List of native drive densities. Order must match enum fd_drivetype
131 * in <sys/fdcio.h>. Upon attaching the drive, each of the
132 * programmable subdevices is initialized with the native density
133 * definition.
134 */
135#ifdef PC98
136static struct fd_type fd_native_types[] =
137{
138{ 0 }, /* FDT_NONE */
139{ 0 }, /* FDT_360K */
140{ 15,2,0xFF,0x1B,80,2400,0,2,0x54,1,0,0 }, /* FDT_12M */
141{ 0 }, /* FDT_720K */
142{ 18,2,0xFF,0x1B,80,2880,2,2,0x54,1,0,0 }, /* FDT_144M */
143{ 0 }, /* FDT_288M */
144};
145
146static struct fd_type fd_searchlist_12m[] = {
147{ 15,2,0xFF,0x1B,80,2400,0,2,0x54,1,0,FL_MFM }, /* 1.2M */
148#if 0
149{ 10,2,0xFF,0x10,82,1640,1,2,0x30,1,0,FL_MFM }, /* 820K */
150{ 10,2,0xFF,0x10,80,1600,1,2,0x30,1,0,FL_MFM }, /* 800K */
151#endif
152{ 9,2,0xFF,0x20,80,1440,1,2,0x50,1,0,FL_MFM }, /* 720K */
153{ 9,2,0xFF,0x20,40, 720,1,2,0x50,1,0,FL_MFM|FL_2STEP },/* 360K */
154{ 8,2,0xFF,0x2A,80,1280,1,2,0x50,1,0,FL_MFM }, /* 640K */
155{ 8,3,0xFF,0x35,77,1232,0,2,0x74,1,0,FL_MFM }, /* 1.23M 1024/sec */
156#if 0
157{ 8,3,0xFF,0x35,80,1280,0,2,0x74,1,0,FL_MFM }, /* 1.28M 1024/sec */
158#endif
159};
160static struct fd_type fd_searchlist_144m[] = {
161#if 0
162{ 21,2,0xFF,0x04,82,3444,2,2,0x0C,2,0,FL_MFM }, /* 1.72M in 3mode */
163{ 18,2,0xFF,0x1B,82,2952,2,2,0x54,1,0,FL_MFM }, /* 1.48M in 3mode */
164#endif
165{ 18,2,0xFF,0x1B,80,2880,2,2,0x54,1,0,FL_MFM }, /* 1.44M in 3mode */
166{ 15,2,0xFF,0x1B,80,2400,0,2,0x54,1,0,FL_MFM }, /* 1.2M */
167#if 0
168{ 10,2,0xFF,0x10,82,1640,1,2,0x30,1,0,FL_MFM }, /* 820K */
169{ 10,2,0xFF,0x10,80,1600,1,2,0x30,1,0,FL_MFM }, /* 800K */
170#endif
171{ 9,2,0xFF,0x20,80,1440,1,2,0x50,1,0,FL_MFM }, /* 720K */
172{ 9,2,0xFF,0x20,40, 720,1,2,0x50,1,0,FL_MFM|FL_2STEP },/* 360K */
173{ 8,2,0xFF,0x2A,80,1280,1,2,0x50,1,0,FL_MFM }, /* 640K */
174{ 8,3,0xFF,0x35,77,1232,0,2,0x74,1,0,FL_MFM }, /* 1.23M 1024/sec */
175#if 0
176{ 8,3,0xFF,0x35,80,1280,0,2,0x74,1,0,FL_MFM }, /* 1.28M 1024/sec */
177{ 9,3,0xFF,0x35,82,1476,0,2,0x47,1,0,FL_MFM }, /* 1.48M 1024/sec 9sec */
178{ 10,3,0xFF,0x1B,82,1640,2,2,0x54,1,0,FL_MFM }, /* 1.64M in 3mode - Reserve */
179#endif
180};
181#else /* PC98 */
182static struct fd_type fd_native_types[] =
183{
184{ 0 }, /* FDT_NONE */
185{ 9,2,0xFF,0x2A,40, 720,FDC_250KBPS,2,0x50,1,0,FL_MFM }, /* FDT_360K */
186{ 15,2,0xFF,0x1B,80,2400,FDC_500KBPS,2,0x54,1,0,FL_MFM }, /* FDT_12M */
187{ 9,2,0xFF,0x20,80,1440,FDC_250KBPS,2,0x50,1,0,FL_MFM }, /* FDT_720K */
188{ 18,2,0xFF,0x1B,80,2880,FDC_500KBPS,2,0x6C,1,0,FL_MFM }, /* FDT_144M */
189#if 0 /* we currently don't handle 2.88 MB */
190{ 36,2,0xFF,0x1B,80,5760,FDC_1MBPS, 2,0x4C,1,1,FL_MFM|FL_PERPND } /*FDT_288M*/
191#else
192{ 18,2,0xFF,0x1B,80,2880,FDC_500KBPS,2,0x6C,1,0,FL_MFM }, /* FDT_144M */
193#endif
194};
195
196/*
197 * 360 KB 5.25" and 720 KB 3.5" drives don't have automatic density
198 * selection, they just start out with their native density (or lose).
199 * So 1.2 MB 5.25", 1.44 MB 3.5", and 2.88 MB 3.5" drives have their
200 * respective lists of densities to search for.
201 */
202static struct fd_type fd_searchlist_12m[] = {
203{ 15,2,0xFF,0x1B,80,2400,FDC_500KBPS,2,0x54,1,0,FL_MFM }, /* 1.2M */
204{ 9,2,0xFF,0x23,40, 720,FDC_300KBPS,2,0x50,1,0,FL_MFM|FL_2STEP }, /* 360K */
205{ 9,2,0xFF,0x20,80,1440,FDC_300KBPS,2,0x50,1,0,FL_MFM }, /* 720K */
206};
207
208static struct fd_type fd_searchlist_144m[] = {
209{ 18,2,0xFF,0x1B,80,2880,FDC_500KBPS,2,0x6C,1,0,FL_MFM }, /* 1.44M */
210{ 9,2,0xFF,0x20,80,1440,FDC_250KBPS,2,0x50,1,0,FL_MFM }, /* 720K */
211};
212
213/* We search for 1.44M first since this is the most common case. */
214static struct fd_type fd_searchlist_288m[] = {
215{ 18,2,0xFF,0x1B,80,2880,FDC_500KBPS,2,0x6C,1,0,FL_MFM }, /* 1.44M */
216#if 0
217{ 36,2,0xFF,0x1B,80,5760,FDC_1MBPS, 2,0x4C,1,1,FL_MFM|FL_PERPND } /* 2.88M */
218#endif
219{ 9,2,0xFF,0x20,80,1440,FDC_250KBPS,2,0x50,1,0,FL_MFM }, /* 720K */
220};
221#endif /* PC98 */
222
223#define MAX_SEC_SIZE (128 << 3)
224#define MAX_CYLINDER 85 /* some people really stress their drives
225 * up to cyl 82 */
226#define MAX_HEAD 1
227
228devclass_t fdc_devclass;
229
230/*
231 * Per drive structure (softc).
232 */
233struct fd_data {
234 struct fdc_data *fdc; /* pointer to controller structure */
235 int fdsu; /* this units number on this controller */
236 enum fd_drivetype type; /* drive type */
237 struct fd_type *ft; /* pointer to current type descriptor */
238 struct fd_type fts[NUMDENS]; /* type descriptors */
239 int flags;
240#define FD_OPEN 0x01 /* it's open */
241#define FD_NONBLOCK 0x02 /* O_NONBLOCK set */
242#define FD_ACTIVE 0x04 /* it's active */
243#define FD_MOTOR 0x08 /* motor should be on */
244#define FD_MOTOR_WAIT 0x10 /* motor coming up */
245#define FD_UA 0x20 /* force unit attention */
246 int skip;
247 int hddrv;
248#define FD_NO_TRACK -2
249 int track; /* where we think the head is */
250 int options; /* user configurable options, see fdcio.h */
251 struct callout_handle toffhandle;
252 struct callout_handle tohandle;
253 struct devstat *device_stats;
254 struct cdev *masterdev;
255 device_t dev;
256 fdu_t fdu;
257#ifdef PC98
258 int pc98_trans;
259#endif
260};
261
262struct fdc_ivars {
263 int fdunit;
264 int fdtype;
265};
266
267static devclass_t fd_devclass;
268
269/* configuration flags for fd */
270#define FD_TYPEMASK 0x0f /* drive type, matches enum
271 * fd_drivetype; on i386 machines, if
272 * given as 0, use RTC type for fd0
273 * and fd1 */
274#define FD_DTYPE(flags) ((flags) & FD_TYPEMASK)
275#define FD_NO_CHLINE 0x10 /* drive does not support changeline
276 * aka. unit attention */
277#define FD_NO_PROBE 0x20 /* don't probe drive (seek test), just
278 * assume it is there */
279
280#ifdef EPSON_NRDISK
281typedef unsigned int nrd_t;
282
283#define P_NRD_ADDRH 0xc24
284#define P_NRD_ADDRM 0xc22
285#define P_NRD_ADDRL 0xc20
286#define P_NRD_CHECK 0xc20
287#define P_NRD_DATA 0xc26
288#define P_NRD_LED 0xc36
289#define B_NRD_CHK 0x80
290#define B_NRD_LED 0x40
291#define A_NRD_INFO 0x2
292#define A_NRD_BASE 0x400
293#define NRD_STATUS 0x0
294#define NRD_ST0_HD 0x04
295
296static fdu_t nrdu=-1;
297static int nrdsec=0;
298static nrd_t nrdblkn=0;
299static nrd_t nrdaddr=0x0;
300
301#define nrd_check_ready() ({ \
302 (epson_inb(P_NRD_CHECK) & B_NRD_CHK) ? 0 : 1; \
303 })
304#define nrd_LED_on() epson_outb(P_NRD_LED, B_NRD_LED)
305#define nrd_LED_off() epson_outb(P_NRD_LED, ~B_NRD_LED)
306#define nrd_trac() ((int)(nrd_info(nrdaddr) & 0xff))
307#define nrd_head() ((int)((nrd_info(nrdaddr) >> 8) & 0xff))
308#define nrd_sec() ((int)(nrd_info(nrdaddr + 2) & 0xff))
309#define nrd_secsize() ((int)((nrd_info(A_NRD_INFO) >> 8) & 0xff))
310#define nrd_addrset(p) nrd_addr((nrd_t)((nrd_t)p+A_NRD_BASE))
311
312static inline void
313nrd_addr(addr)
314 nrd_t addr;
315{
316 epson_outb(P_NRD_ADDRH, (u_char)((addr >> 16) & 0x1f));
317 epson_outb(P_NRD_ADDRM, (u_char)((addr >> 8) & 0xff));
318 epson_outb(P_NRD_ADDRL, (u_char)(addr & 0xff));
319}
320
321static inline u_short
322nrd_info(addr)
323 nrd_t addr;
324{
325 nrd_addr(addr);
326 return (epson_inw(P_NRD_DATA));
327}
328#endif /* EPSON_NRDISK */
329
330/*
331 * Throughout this file the following conventions will be used:
332 *
333 * fd is a pointer to the fd_data struct for the drive in question
334 * fdc is a pointer to the fdc_data struct for the controller
335 * fdu is the floppy drive unit number
336 * fdcu is the floppy controller unit number
337 * fdsu is the floppy drive unit number on that controller. (sub-unit)
338 */
339
340/*
341 * Function declarations, same (chaotic) order as they appear in the
342 * file. Re-ordering is too late now, it would only obfuscate the
343 * diffs against old and offspring versions (like the PC98 one).
344 *
345 * Anyone adding functions here, please keep this sequence the same
346 * as below -- makes locating a particular function in the body much
347 * easier.
348 */
349static u_int8_t fdsts_rd(fdc_p);
350static void fddata_wr(fdc_p, u_int8_t);
351static u_int8_t fddata_rd(fdc_p);
352static int fdc_err(struct fdc_data *, const char *);
353static int enable_fifo(fdc_p fdc);
354static int fd_sense_drive_status(fdc_p, int *);
355static int fd_sense_int(fdc_p, int *, int *);
356static int fd_read_status(fdc_p);
|
357static void fdc_add_child(device_t, const char *, int);
| |
358static int fd_probe(device_t);
359static int fd_attach(device_t);
360static int fd_detach(device_t);
361static void set_motor(struct fdc_data *, int, int);
362# define TURNON 1
363# define TURNOFF 0
364static timeout_t fd_turnoff;
365static timeout_t fd_motor_on;
366static void fd_turnon(struct fd_data *);
367static void fdc_reset(fdc_p);
368static int fd_in(struct fdc_data *, int *);
369static int out_fdc(struct fdc_data *, int);
370/*
371 * The open function is named fdopen() to avoid confusion with fdopen()
372 * in fd(4). The difference is now only meaningful for debuggers.
373 */
374static d_open_t fdopen;
375static d_close_t fdclose;
376static d_strategy_t fdstrategy;
377static void fdstart(struct fdc_data *);
378static timeout_t fd_iotimeout;
379static timeout_t fd_pseudointr;
380static driver_intr_t fdc_intr;
381static int fdcpio(fdc_p, long, caddr_t, u_int);
382static int fdautoselect(struct cdev *);
383static int fdstate(struct fdc_data *);
384static int retrier(struct fdc_data *);
385static void fdbiodone(struct bio *);
386static int fdmisccmd(struct cdev *, u_int, void *);
387static d_ioctl_t fdioctl;
388
389static int fifo_threshold = 8; /* XXX: should be accessible via sysctl */
390
391#ifdef FDC_DEBUG
392/* CAUTION: fd_debug causes huge amounts of logging output */
393static int volatile fd_debug = 0;
394#define TRACE0(arg) do { if (fd_debug) printf(arg); } while (0)
395#define TRACE1(arg1, arg2) do { if (fd_debug) printf(arg1, arg2); } while (0)
396#else /* FDC_DEBUG */
397#define TRACE0(arg) do { } while (0)
398#define TRACE1(arg1, arg2) do { } while (0)
399#endif /* FDC_DEBUG */
400
401/*
402 * Bus space handling (access to low-level IO).
403 */
404#ifndef PC98
405void
406fdout_wr(fdc_p fdc, u_int8_t v)
407{
408 bus_space_write_1(fdc->portt, fdc->porth, FDOUT+fdc->port_off, v);
409}
410#endif
411
412static u_int8_t
413fdsts_rd(fdc_p fdc)
414{
415 return bus_space_read_1(fdc->portt, fdc->porth, FDSTS+fdc->port_off);
416}
417
418static void
419fddata_wr(fdc_p fdc, u_int8_t v)
420{
421 bus_space_write_1(fdc->portt, fdc->porth, FDDATA+fdc->port_off, v);
422}
423
424static u_int8_t
425fddata_rd(fdc_p fdc)
426{
427 return bus_space_read_1(fdc->portt, fdc->porth, FDDATA+fdc->port_off);
428}
429
430#ifdef PC98
431static void
432fdctl_wr(fdc_p fdc, u_int8_t v)
433{
434 bus_space_write_1(fdc->portt, fdc->porth, FDCTL, v);
435}
436#endif
437
438#ifndef PC98
439static u_int8_t
440fdin_rd(fdc_p fdc)
441{
442 return bus_space_read_1(fdc->portt, fdc->porth, FDIN);
443}
444#endif /* PC98 */
445
446static struct cdevsw fd_cdevsw = {
447 .d_version = D_VERSION,
448 .d_open = fdopen,
449 .d_close = fdclose,
450 .d_read = physread,
451 .d_write = physwrite,
452 .d_ioctl = fdioctl,
453 .d_strategy = fdstrategy,
454 .d_name = "fd",
455 .d_flags = D_DISK | D_NEEDGIANT,
456};
457
458/*
459 * Auxiliary functions. Well, some only. Others are scattered
460 * throughout the entire file.
461 */
462static int
463fdc_err(struct fdc_data *fdc, const char *s)
464{
465 fdc->fdc_errs++;
466 if (s) {
467 if (fdc->fdc_errs < FDC_ERRMAX)
468 device_printf(fdc->fdc_dev, "%s", s);
469 else if (fdc->fdc_errs == FDC_ERRMAX)
470 device_printf(fdc->fdc_dev, "too many errors, not "
471 "logging any more\n");
472 }
473
474 return FD_FAILED;
475}
476
477/*
478 * fd_cmd: Send a command to the chip. Takes a varargs with this structure:
479 * Unit number,
480 * # of output bytes, output bytes as ints ...,
481 * # of input bytes, input bytes as ints ...
482 */
483int
484fd_cmd(struct fdc_data *fdc, int n_out, ...)
485{
486 u_char cmd;
487 int n_in;
488 int n;
489 va_list ap;
490
491 va_start(ap, n_out);
492 cmd = (u_char)(va_arg(ap, int));
493 va_end(ap);
494 va_start(ap, n_out);
495 for (n = 0; n < n_out; n++)
496 {
497 if (out_fdc(fdc, va_arg(ap, int)) < 0)
498 {
499 char msg[50];
500 snprintf(msg, sizeof(msg),
501 "cmd %x failed at out byte %d of %d\n",
502 cmd, n + 1, n_out);
503 return fdc_err(fdc, msg);
504 }
505 }
506 n_in = va_arg(ap, int);
507 for (n = 0; n < n_in; n++)
508 {
509 int *ptr = va_arg(ap, int *);
510 if (fd_in(fdc, ptr) < 0)
511 {
512 char msg[50];
513 snprintf(msg, sizeof(msg),
514 "cmd %02x failed at in byte %d of %d\n",
515 cmd, n + 1, n_in);
516 return fdc_err(fdc, msg);
517 }
518 }
519
520 return 0;
521}
522
523static int
524enable_fifo(fdc_p fdc)
525{
526 int i, j;
527
528 if ((fdc->flags & FDC_HAS_FIFO) == 0) {
529
530 /*
531 * Cannot use fd_cmd the normal way here, since
532 * this might be an invalid command. Thus we send the
533 * first byte, and check for an early turn of data directon.
534 */
535
536 if (out_fdc(fdc, I8207X_CONFIGURE) < 0)
537 return fdc_err(fdc, "Enable FIFO failed\n");
538
539 /* If command is invalid, return */
540 j = FDSTS_TIMEOUT;
541 while ((i = fdsts_rd(fdc) & (NE7_DIO | NE7_RQM))
542 != NE7_RQM && j-- > 0) {
543 if (i == (NE7_DIO | NE7_RQM)) {
544 fdc_reset(fdc);
545 return FD_FAILED;
546 }
547 DELAY(1);
548 }
549 if (j<0 ||
550 fd_cmd(fdc, 3,
551 0, (fifo_threshold - 1) & 0xf, 0, 0) < 0) {
552 fdc_reset(fdc);
553 return fdc_err(fdc, "Enable FIFO failed\n");
554 }
555 fdc->flags |= FDC_HAS_FIFO;
556 return 0;
557 }
558 if (fd_cmd(fdc, 4,
559 I8207X_CONFIGURE, 0, (fifo_threshold - 1) & 0xf, 0, 0) < 0)
560 return fdc_err(fdc, "Re-enable FIFO failed\n");
561 return 0;
562}
563
564static int
565fd_sense_drive_status(fdc_p fdc, int *st3p)
566{
567 int st3;
568
569 if (fd_cmd(fdc, 2, NE7CMD_SENSED, fdc->fdu, 1, &st3))
570 {
571 return fdc_err(fdc, "Sense Drive Status failed\n");
572 }
573 if (st3p)
574 *st3p = st3;
575
576 return 0;
577}
578
579static int
580fd_sense_int(fdc_p fdc, int *st0p, int *cylp)
581{
582 int cyl, st0, ret;
583
584#ifdef EPSON_NRDISK
585 if (fdc->fdu == nrdu) {
586 if (fdc->fd->track >= 0) nrdaddr = (fdc->fd->track + 1) * 8;
587 else nrdaddr = 0x0;
588 *st0p = nrd_head() ? NRD_ST0_HD : NRD_STATUS;
589 *cylp = nrd_trac();
590 }
591 else {
592#endif /* EPSON_NRDISK */
593 ret = fd_cmd(fdc, 1, NE7CMD_SENSEI, 1, &st0);
594 if (ret) {
595 (void)fdc_err(fdc,
596 "sense intr err reading stat reg 0\n");
597 return ret;
598 }
599
600 if (st0p)
601 *st0p = st0;
602
603 if ((st0 & NE7_ST0_IC) == NE7_ST0_IC_IV) {
604 /*
605 * There doesn't seem to have been an interrupt.
606 */
607 return FD_NOT_VALID;
608 }
609
610 if (fd_in(fdc, &cyl) < 0) {
611 return fdc_err(fdc, "can't get cyl num\n");
612 }
613
614 if (cylp)
615 *cylp = cyl;
616
617#ifdef EPSON_NRDISK
618 }
619#endif /* EPSON_NRDISK */
620 return 0;
621}
622
623
624static int
625fd_read_status(fdc_p fdc)
626{
627 int i, ret;
628
629 for (i = ret = 0; i < 7; i++) {
630 /*
631 * XXX types are poorly chosen. Only bytes can be read
632 * from the hardware, but fdc->status[] wants u_ints and
633 * fd_in() gives ints.
634 */
635 int status;
636
637#ifdef EPSON_NRDISK
638 if (fdc->fdu == nrdu) {
639 switch (i) {
640 case 0: fdc->status[i] = nrd_head()
641 ? NRD_ST0_HD : NRD_STATUS; break;
642 case 1: fdc->status[i] = NRD_STATUS; break;
643 case 2: fdc->status[i] = NRD_STATUS; break;
644 case 3: fdc->status[i] = nrd_trac(); break;
645 case 4: fdc->status[i] = nrd_head(); break;
646 case 5: fdc->status[i] = nrdsec; break;
647 case 6: fdc->status[i] = nrd_secsize(); break;
648 }
649 ret = 0;
650 }
651 else {
652#endif /* EPSON_NRDISK */
653 ret = fd_in(fdc, &status);
654 fdc->status[i] = status;
655 if (ret != 0)
656 break;
657#ifdef EPSON_NRDISK
658 }
659#endif /* EPSON_NRDISK */
660 }
661
662 if (ret == 0)
663 fdc->flags |= FDC_STAT_VALID;
664 else
665 fdc->flags &= ~FDC_STAT_VALID;
666
667 return ret;
668}
669
670#ifdef PC98
671static int pc98_trans = 0; /* 0 : HD , 1 : DD , 2 : 1.44 */
672static int pc98_trans_prev = -1;
673
674static void set_density(fdc_p fdc)
675{
676 /* always motor on */
677 bus_space_write_1(fdc->sc_fdsiot, fdc->sc_fdsioh, 0,
678 (pc98_trans != 1 ? FDP_FDDEXC : 0) | FDP_PORTEXC);
679 DELAY(100);
680 fdctl_wr(fdc, FDC_RST | FDC_DMAE);
681 /* in the case of note W, always inhibit 100ms timer */
682}
683
684static int pc98_fd_check_ready(fdu_t fdu)
685{
686 fd_p fd = devclass_get_softc(fd_devclass, fdu);
687 struct fdc_data *fdc = fd->fdc;
688 int retry = 0, status;
689
690#ifdef EPSON_NRDISK
691 if (fdu == nrdu) {
692 if (nrd_check_ready()) return 0;
693 else return -1;
694 }
695#endif
696 while (retry++ < 30000) {
697 set_motor(fdc, fd->fdsu, TURNON);
698 out_fdc(fdc, NE7CMD_SENSED); /* Sense Drive Status */
699 DELAY(100);
700 out_fdc(fdc, fdu); /* Drive number */
701 DELAY(100);
702 if ((fd_in(fdc, &status) == 0) && (status & NE7_ST3_RD)) {
703 fdctl_wr(fdc, FDC_DMAE | FDC_MTON);
704 DELAY(10);
705 return 0;
706 }
707 }
708 return -1;
709}
710
711static void pc98_fd_check_type(struct fd_data *fd)
712{
713 struct fdc_data *fdc;
714
715 if (fd->type != FDT_NONE || fd->fdu < 0 || fd->fdu > 3)
716 return;
717
718 fdc = fd->fdc;
719
720 /* Look up what the BIOS thinks we have. */
721 if (!((PC98_SYSTEM_PARAMETER(0x55c) >> fd->fdu) & 0x01)) {
722 fd->type = FDT_NONE;
723 return;
724 }
725 if ((PC98_SYSTEM_PARAMETER(0x5ae) >> fd->fdu) & 0x01) {
726 /* Check 3mode I/F */
727 fd->pc98_trans = 0;
728 bus_space_write_1(fdc->sc_fdemsiot, fdc->sc_fdemsioh, 0,
729 (fd->fdu << 5) | 0x10);
730 if (!(bus_space_read_1(fdc->sc_fdemsiot, fdc->sc_fdemsioh, 0) &
731 0x01)) {
732 fd->type = FDT_144M;
733 return;
734 }
735 device_printf(fd->dev,
736 "Warning: can't control 3mode I/F, fallback to 2mode.\n");
737 }
738
739 fd->type = FDT_12M;
740
741 switch (epson_machine_id) {
742 case 0x20:
743 case 0x27:
744 if ((PC98_SYSTEM_PARAMETER(0x488) >> fd->fdu) & 0x01) {
745#ifdef EPSON_NRDISK
746 if (nrd_check_ready()) {
747 nrd_LED_on();
748 nrdu = fd->fdu;
749 } else
750#endif
751 fd->type = FDT_NONE;
752 }
753 break;
754 }
755}
756#endif /* PC98 */
757
758void
759fdc_release_resources(struct fdc_data *fdc)
760{
761 device_t dev;
762
763 dev = fdc->fdc_dev;
| 357static int fd_probe(device_t);
358static int fd_attach(device_t);
359static int fd_detach(device_t);
360static void set_motor(struct fdc_data *, int, int);
361# define TURNON 1
362# define TURNOFF 0
363static timeout_t fd_turnoff;
364static timeout_t fd_motor_on;
365static void fd_turnon(struct fd_data *);
366static void fdc_reset(fdc_p);
367static int fd_in(struct fdc_data *, int *);
368static int out_fdc(struct fdc_data *, int);
369/*
370 * The open function is named fdopen() to avoid confusion with fdopen()
371 * in fd(4). The difference is now only meaningful for debuggers.
372 */
373static d_open_t fdopen;
374static d_close_t fdclose;
375static d_strategy_t fdstrategy;
376static void fdstart(struct fdc_data *);
377static timeout_t fd_iotimeout;
378static timeout_t fd_pseudointr;
379static driver_intr_t fdc_intr;
380static int fdcpio(fdc_p, long, caddr_t, u_int);
381static int fdautoselect(struct cdev *);
382static int fdstate(struct fdc_data *);
383static int retrier(struct fdc_data *);
384static void fdbiodone(struct bio *);
385static int fdmisccmd(struct cdev *, u_int, void *);
386static d_ioctl_t fdioctl;
387
388static int fifo_threshold = 8; /* XXX: should be accessible via sysctl */
389
390#ifdef FDC_DEBUG
391/* CAUTION: fd_debug causes huge amounts of logging output */
392static int volatile fd_debug = 0;
393#define TRACE0(arg) do { if (fd_debug) printf(arg); } while (0)
394#define TRACE1(arg1, arg2) do { if (fd_debug) printf(arg1, arg2); } while (0)
395#else /* FDC_DEBUG */
396#define TRACE0(arg) do { } while (0)
397#define TRACE1(arg1, arg2) do { } while (0)
398#endif /* FDC_DEBUG */
399
400/*
401 * Bus space handling (access to low-level IO).
402 */
403#ifndef PC98
404void
405fdout_wr(fdc_p fdc, u_int8_t v)
406{
407 bus_space_write_1(fdc->portt, fdc->porth, FDOUT+fdc->port_off, v);
408}
409#endif
410
411static u_int8_t
412fdsts_rd(fdc_p fdc)
413{
414 return bus_space_read_1(fdc->portt, fdc->porth, FDSTS+fdc->port_off);
415}
416
417static void
418fddata_wr(fdc_p fdc, u_int8_t v)
419{
420 bus_space_write_1(fdc->portt, fdc->porth, FDDATA+fdc->port_off, v);
421}
422
423static u_int8_t
424fddata_rd(fdc_p fdc)
425{
426 return bus_space_read_1(fdc->portt, fdc->porth, FDDATA+fdc->port_off);
427}
428
429#ifdef PC98
430static void
431fdctl_wr(fdc_p fdc, u_int8_t v)
432{
433 bus_space_write_1(fdc->portt, fdc->porth, FDCTL, v);
434}
435#endif
436
437#ifndef PC98
438static u_int8_t
439fdin_rd(fdc_p fdc)
440{
441 return bus_space_read_1(fdc->portt, fdc->porth, FDIN);
442}
443#endif /* PC98 */
444
445static struct cdevsw fd_cdevsw = {
446 .d_version = D_VERSION,
447 .d_open = fdopen,
448 .d_close = fdclose,
449 .d_read = physread,
450 .d_write = physwrite,
451 .d_ioctl = fdioctl,
452 .d_strategy = fdstrategy,
453 .d_name = "fd",
454 .d_flags = D_DISK | D_NEEDGIANT,
455};
456
457/*
458 * Auxiliary functions. Well, some only. Others are scattered
459 * throughout the entire file.
460 */
461static int
462fdc_err(struct fdc_data *fdc, const char *s)
463{
464 fdc->fdc_errs++;
465 if (s) {
466 if (fdc->fdc_errs < FDC_ERRMAX)
467 device_printf(fdc->fdc_dev, "%s", s);
468 else if (fdc->fdc_errs == FDC_ERRMAX)
469 device_printf(fdc->fdc_dev, "too many errors, not "
470 "logging any more\n");
471 }
472
473 return FD_FAILED;
474}
475
476/*
477 * fd_cmd: Send a command to the chip. Takes a varargs with this structure:
478 * Unit number,
479 * # of output bytes, output bytes as ints ...,
480 * # of input bytes, input bytes as ints ...
481 */
482int
483fd_cmd(struct fdc_data *fdc, int n_out, ...)
484{
485 u_char cmd;
486 int n_in;
487 int n;
488 va_list ap;
489
490 va_start(ap, n_out);
491 cmd = (u_char)(va_arg(ap, int));
492 va_end(ap);
493 va_start(ap, n_out);
494 for (n = 0; n < n_out; n++)
495 {
496 if (out_fdc(fdc, va_arg(ap, int)) < 0)
497 {
498 char msg[50];
499 snprintf(msg, sizeof(msg),
500 "cmd %x failed at out byte %d of %d\n",
501 cmd, n + 1, n_out);
502 return fdc_err(fdc, msg);
503 }
504 }
505 n_in = va_arg(ap, int);
506 for (n = 0; n < n_in; n++)
507 {
508 int *ptr = va_arg(ap, int *);
509 if (fd_in(fdc, ptr) < 0)
510 {
511 char msg[50];
512 snprintf(msg, sizeof(msg),
513 "cmd %02x failed at in byte %d of %d\n",
514 cmd, n + 1, n_in);
515 return fdc_err(fdc, msg);
516 }
517 }
518
519 return 0;
520}
521
522static int
523enable_fifo(fdc_p fdc)
524{
525 int i, j;
526
527 if ((fdc->flags & FDC_HAS_FIFO) == 0) {
528
529 /*
530 * Cannot use fd_cmd the normal way here, since
531 * this might be an invalid command. Thus we send the
532 * first byte, and check for an early turn of data directon.
533 */
534
535 if (out_fdc(fdc, I8207X_CONFIGURE) < 0)
536 return fdc_err(fdc, "Enable FIFO failed\n");
537
538 /* If command is invalid, return */
539 j = FDSTS_TIMEOUT;
540 while ((i = fdsts_rd(fdc) & (NE7_DIO | NE7_RQM))
541 != NE7_RQM && j-- > 0) {
542 if (i == (NE7_DIO | NE7_RQM)) {
543 fdc_reset(fdc);
544 return FD_FAILED;
545 }
546 DELAY(1);
547 }
548 if (j<0 ||
549 fd_cmd(fdc, 3,
550 0, (fifo_threshold - 1) & 0xf, 0, 0) < 0) {
551 fdc_reset(fdc);
552 return fdc_err(fdc, "Enable FIFO failed\n");
553 }
554 fdc->flags |= FDC_HAS_FIFO;
555 return 0;
556 }
557 if (fd_cmd(fdc, 4,
558 I8207X_CONFIGURE, 0, (fifo_threshold - 1) & 0xf, 0, 0) < 0)
559 return fdc_err(fdc, "Re-enable FIFO failed\n");
560 return 0;
561}
562
563static int
564fd_sense_drive_status(fdc_p fdc, int *st3p)
565{
566 int st3;
567
568 if (fd_cmd(fdc, 2, NE7CMD_SENSED, fdc->fdu, 1, &st3))
569 {
570 return fdc_err(fdc, "Sense Drive Status failed\n");
571 }
572 if (st3p)
573 *st3p = st3;
574
575 return 0;
576}
577
578static int
579fd_sense_int(fdc_p fdc, int *st0p, int *cylp)
580{
581 int cyl, st0, ret;
582
583#ifdef EPSON_NRDISK
584 if (fdc->fdu == nrdu) {
585 if (fdc->fd->track >= 0) nrdaddr = (fdc->fd->track + 1) * 8;
586 else nrdaddr = 0x0;
587 *st0p = nrd_head() ? NRD_ST0_HD : NRD_STATUS;
588 *cylp = nrd_trac();
589 }
590 else {
591#endif /* EPSON_NRDISK */
592 ret = fd_cmd(fdc, 1, NE7CMD_SENSEI, 1, &st0);
593 if (ret) {
594 (void)fdc_err(fdc,
595 "sense intr err reading stat reg 0\n");
596 return ret;
597 }
598
599 if (st0p)
600 *st0p = st0;
601
602 if ((st0 & NE7_ST0_IC) == NE7_ST0_IC_IV) {
603 /*
604 * There doesn't seem to have been an interrupt.
605 */
606 return FD_NOT_VALID;
607 }
608
609 if (fd_in(fdc, &cyl) < 0) {
610 return fdc_err(fdc, "can't get cyl num\n");
611 }
612
613 if (cylp)
614 *cylp = cyl;
615
616#ifdef EPSON_NRDISK
617 }
618#endif /* EPSON_NRDISK */
619 return 0;
620}
621
622
623static int
624fd_read_status(fdc_p fdc)
625{
626 int i, ret;
627
628 for (i = ret = 0; i < 7; i++) {
629 /*
630 * XXX types are poorly chosen. Only bytes can be read
631 * from the hardware, but fdc->status[] wants u_ints and
632 * fd_in() gives ints.
633 */
634 int status;
635
636#ifdef EPSON_NRDISK
637 if (fdc->fdu == nrdu) {
638 switch (i) {
639 case 0: fdc->status[i] = nrd_head()
640 ? NRD_ST0_HD : NRD_STATUS; break;
641 case 1: fdc->status[i] = NRD_STATUS; break;
642 case 2: fdc->status[i] = NRD_STATUS; break;
643 case 3: fdc->status[i] = nrd_trac(); break;
644 case 4: fdc->status[i] = nrd_head(); break;
645 case 5: fdc->status[i] = nrdsec; break;
646 case 6: fdc->status[i] = nrd_secsize(); break;
647 }
648 ret = 0;
649 }
650 else {
651#endif /* EPSON_NRDISK */
652 ret = fd_in(fdc, &status);
653 fdc->status[i] = status;
654 if (ret != 0)
655 break;
656#ifdef EPSON_NRDISK
657 }
658#endif /* EPSON_NRDISK */
659 }
660
661 if (ret == 0)
662 fdc->flags |= FDC_STAT_VALID;
663 else
664 fdc->flags &= ~FDC_STAT_VALID;
665
666 return ret;
667}
668
669#ifdef PC98
670static int pc98_trans = 0; /* 0 : HD , 1 : DD , 2 : 1.44 */
671static int pc98_trans_prev = -1;
672
673static void set_density(fdc_p fdc)
674{
675 /* always motor on */
676 bus_space_write_1(fdc->sc_fdsiot, fdc->sc_fdsioh, 0,
677 (pc98_trans != 1 ? FDP_FDDEXC : 0) | FDP_PORTEXC);
678 DELAY(100);
679 fdctl_wr(fdc, FDC_RST | FDC_DMAE);
680 /* in the case of note W, always inhibit 100ms timer */
681}
682
683static int pc98_fd_check_ready(fdu_t fdu)
684{
685 fd_p fd = devclass_get_softc(fd_devclass, fdu);
686 struct fdc_data *fdc = fd->fdc;
687 int retry = 0, status;
688
689#ifdef EPSON_NRDISK
690 if (fdu == nrdu) {
691 if (nrd_check_ready()) return 0;
692 else return -1;
693 }
694#endif
695 while (retry++ < 30000) {
696 set_motor(fdc, fd->fdsu, TURNON);
697 out_fdc(fdc, NE7CMD_SENSED); /* Sense Drive Status */
698 DELAY(100);
699 out_fdc(fdc, fdu); /* Drive number */
700 DELAY(100);
701 if ((fd_in(fdc, &status) == 0) && (status & NE7_ST3_RD)) {
702 fdctl_wr(fdc, FDC_DMAE | FDC_MTON);
703 DELAY(10);
704 return 0;
705 }
706 }
707 return -1;
708}
709
710static void pc98_fd_check_type(struct fd_data *fd)
711{
712 struct fdc_data *fdc;
713
714 if (fd->type != FDT_NONE || fd->fdu < 0 || fd->fdu > 3)
715 return;
716
717 fdc = fd->fdc;
718
719 /* Look up what the BIOS thinks we have. */
720 if (!((PC98_SYSTEM_PARAMETER(0x55c) >> fd->fdu) & 0x01)) {
721 fd->type = FDT_NONE;
722 return;
723 }
724 if ((PC98_SYSTEM_PARAMETER(0x5ae) >> fd->fdu) & 0x01) {
725 /* Check 3mode I/F */
726 fd->pc98_trans = 0;
727 bus_space_write_1(fdc->sc_fdemsiot, fdc->sc_fdemsioh, 0,
728 (fd->fdu << 5) | 0x10);
729 if (!(bus_space_read_1(fdc->sc_fdemsiot, fdc->sc_fdemsioh, 0) &
730 0x01)) {
731 fd->type = FDT_144M;
732 return;
733 }
734 device_printf(fd->dev,
735 "Warning: can't control 3mode I/F, fallback to 2mode.\n");
736 }
737
738 fd->type = FDT_12M;
739
740 switch (epson_machine_id) {
741 case 0x20:
742 case 0x27:
743 if ((PC98_SYSTEM_PARAMETER(0x488) >> fd->fdu) & 0x01) {
744#ifdef EPSON_NRDISK
745 if (nrd_check_ready()) {
746 nrd_LED_on();
747 nrdu = fd->fdu;
748 } else
749#endif
750 fd->type = FDT_NONE;
751 }
752 break;
753 }
754}
755#endif /* PC98 */
756
757void
758fdc_release_resources(struct fdc_data *fdc)
759{
760 device_t dev;
761
762 dev = fdc->fdc_dev;
|
| 763 if (fdc->fdc_intr) {
764 BUS_TEARDOWN_INTR(device_get_parent(dev), dev, fdc->res_irq,
765 fdc->fdc_intr);
766 fdc->fdc_intr = NULL;
767 }
|
764 if (fdc->res_irq != 0) {
765 bus_deactivate_resource(dev, SYS_RES_IRQ, fdc->rid_irq,
766 fdc->res_irq);
767 bus_release_resource(dev, SYS_RES_IRQ, fdc->rid_irq,
768 fdc->res_irq);
| 768 if (fdc->res_irq != 0) {
769 bus_deactivate_resource(dev, SYS_RES_IRQ, fdc->rid_irq,
770 fdc->res_irq);
771 bus_release_resource(dev, SYS_RES_IRQ, fdc->rid_irq,
772 fdc->res_irq);
|
| 773 fdc->res_irq = NULL;
|
769 }
770#ifndef PC98
771 if (fdc->res_ctl != 0) {
772 bus_deactivate_resource(dev, SYS_RES_IOPORT, fdc->rid_ctl,
773 fdc->res_ctl);
774 bus_release_resource(dev, SYS_RES_IOPORT, fdc->rid_ctl,
775 fdc->res_ctl);
| 774 }
775#ifndef PC98
776 if (fdc->res_ctl != 0) {
777 bus_deactivate_resource(dev, SYS_RES_IOPORT, fdc->rid_ctl,
778 fdc->res_ctl);
779 bus_release_resource(dev, SYS_RES_IOPORT, fdc->rid_ctl,
780 fdc->res_ctl);
|
| 781 fdc->res_ctl = NULL;
|
776 }
777#endif
778#ifdef PC98
779 if (fdc->res_fdsio != 0) {
780 bus_deactivate_resource(dev, SYS_RES_IOPORT, 3,
781 fdc->res_fdsio);
782 bus_release_resource(dev, SYS_RES_IOPORT, 3, fdc->res_fdsio);
| 782 }
783#endif
784#ifdef PC98
785 if (fdc->res_fdsio != 0) {
786 bus_deactivate_resource(dev, SYS_RES_IOPORT, 3,
787 fdc->res_fdsio);
788 bus_release_resource(dev, SYS_RES_IOPORT, 3, fdc->res_fdsio);
|
| 789 fdc->res_fdsio = NULL;
|
783 }
784 if (fdc->res_fdemsio != 0) {
785 bus_deactivate_resource(dev, SYS_RES_IOPORT, 4,
786 fdc->res_fdemsio);
787 bus_release_resource(dev, SYS_RES_IOPORT, 4, fdc->res_fdemsio);
| 790 }
791 if (fdc->res_fdemsio != 0) {
792 bus_deactivate_resource(dev, SYS_RES_IOPORT, 4,
793 fdc->res_fdemsio);
794 bus_release_resource(dev, SYS_RES_IOPORT, 4, fdc->res_fdemsio);
|
| 795 fdc->res_fdemsio = NULL;
|
788 }
789#endif
790 if (fdc->res_ioport != 0) {
791 bus_deactivate_resource(dev, SYS_RES_IOPORT, fdc->rid_ioport,
792 fdc->res_ioport);
793 bus_release_resource(dev, SYS_RES_IOPORT, fdc->rid_ioport,
794 fdc->res_ioport);
| 796 }
797#endif
798 if (fdc->res_ioport != 0) {
799 bus_deactivate_resource(dev, SYS_RES_IOPORT, fdc->rid_ioport,
800 fdc->res_ioport);
801 bus_release_resource(dev, SYS_RES_IOPORT, fdc->rid_ioport,
802 fdc->res_ioport);
|
| 803 fdc->res_ioport = NULL;
|
795 }
796 if (fdc->res_drq != 0) {
797 bus_deactivate_resource(dev, SYS_RES_DRQ, fdc->rid_drq,
798 fdc->res_drq);
799 bus_release_resource(dev, SYS_RES_DRQ, fdc->rid_drq,
800 fdc->res_drq);
| 804 }
805 if (fdc->res_drq != 0) {
806 bus_deactivate_resource(dev, SYS_RES_DRQ, fdc->rid_drq,
807 fdc->res_drq);
808 bus_release_resource(dev, SYS_RES_DRQ, fdc->rid_drq,
809 fdc->res_drq);
|
| 810 fdc->res_drq = NULL;
|
801 }
802}
803
804/*
805 * Configuration/initialization stuff, per controller.
806 */
807
808int
809fdc_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
810{
811 struct fdc_ivars *ivars = device_get_ivars(child);
812
813 switch (which) {
814 case FDC_IVAR_FDUNIT:
815 *result = ivars->fdunit;
816 break;
817 case FDC_IVAR_FDTYPE:
818 *result = ivars->fdtype;
819 break;
820 default:
821 return (ENOENT);
822 }
823 return (0);
824}
825
826int
827fdc_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
828{
829 struct fdc_ivars *ivars = device_get_ivars(child);
830
831 switch (which) {
832 case FDC_IVAR_FDUNIT:
833 ivars->fdunit = value;
834 break;
835 case FDC_IVAR_FDTYPE:
836 ivars->fdtype = value;
837 break;
838 default:
839 return (ENOENT);
840 }
841 return (0);
842}
843
844int
845fdc_initial_reset(struct fdc_data *fdc)
846{
847#ifdef PC98
848 /* see if it can handle a command */
849 if (fd_cmd(fdc, 3, NE7CMD_SPECIFY, NE7_SPEC_1(4, 240),
850 NE7_SPEC_2(2, 0), 0))
851 return (ENXIO);
852#else
853 /* First, reset the floppy controller. */
854 fdout_wr(fdc, 0);
855 DELAY(100);
856 fdout_wr(fdc, FDO_FRST);
857
858 /* Then, see if it can handle a command. */
859 if (fd_cmd(fdc, 3, NE7CMD_SPECIFY, NE7_SPEC_1(3, 240),
860 NE7_SPEC_2(2, 0), 0))
861 return (ENXIO);
862#endif
863 return (0);
864}
865
866int
867fdc_detach(device_t dev)
868{
869 struct fdc_data *fdc;
870 int error;
871
872 fdc = device_get_softc(dev);
873
874 /* have our children detached first */
875 if ((error = bus_generic_detach(dev)))
876 return (error);
877
878#ifdef PC98
879 /* reset controller, turn motor off */
880 fdc_reset(fdc);
881#else
882 /* reset controller, turn motor off */
883 fdout_wr(fdc, 0);
884#endif
885
| 811 }
812}
813
814/*
815 * Configuration/initialization stuff, per controller.
816 */
817
818int
819fdc_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
820{
821 struct fdc_ivars *ivars = device_get_ivars(child);
822
823 switch (which) {
824 case FDC_IVAR_FDUNIT:
825 *result = ivars->fdunit;
826 break;
827 case FDC_IVAR_FDTYPE:
828 *result = ivars->fdtype;
829 break;
830 default:
831 return (ENOENT);
832 }
833 return (0);
834}
835
836int
837fdc_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
838{
839 struct fdc_ivars *ivars = device_get_ivars(child);
840
841 switch (which) {
842 case FDC_IVAR_FDUNIT:
843 ivars->fdunit = value;
844 break;
845 case FDC_IVAR_FDTYPE:
846 ivars->fdtype = value;
847 break;
848 default:
849 return (ENOENT);
850 }
851 return (0);
852}
853
854int
855fdc_initial_reset(struct fdc_data *fdc)
856{
857#ifdef PC98
858 /* see if it can handle a command */
859 if (fd_cmd(fdc, 3, NE7CMD_SPECIFY, NE7_SPEC_1(4, 240),
860 NE7_SPEC_2(2, 0), 0))
861 return (ENXIO);
862#else
863 /* First, reset the floppy controller. */
864 fdout_wr(fdc, 0);
865 DELAY(100);
866 fdout_wr(fdc, FDO_FRST);
867
868 /* Then, see if it can handle a command. */
869 if (fd_cmd(fdc, 3, NE7CMD_SPECIFY, NE7_SPEC_1(3, 240),
870 NE7_SPEC_2(2, 0), 0))
871 return (ENXIO);
872#endif
873 return (0);
874}
875
876int
877fdc_detach(device_t dev)
878{
879 struct fdc_data *fdc;
880 int error;
881
882 fdc = device_get_softc(dev);
883
884 /* have our children detached first */
885 if ((error = bus_generic_detach(dev)))
886 return (error);
887
888#ifdef PC98
889 /* reset controller, turn motor off */
890 fdc_reset(fdc);
891#else
892 /* reset controller, turn motor off */
893 fdout_wr(fdc, 0);
894#endif
895
|
886 if ((fdc->flags & FDC_ATTACHED) == 0) {
887 device_printf(dev, "already unloaded\n");
888 return (0);
889 }
890 fdc->flags &= ~FDC_ATTACHED;
891
892 BUS_TEARDOWN_INTR(device_get_parent(dev), dev, fdc->res_irq,
893 fdc->fdc_intr);
| |
894 fdc_release_resources(fdc);
895 return (0);
896}
897
898/*
899 * Add a child device to the fdc controller. It will then be probed etc.
900 */
| 896 fdc_release_resources(fdc);
897 return (0);
898}
899
900/*
901 * Add a child device to the fdc controller. It will then be probed etc.
902 */
|
901static void
| 903device_t
|
902fdc_add_child(device_t dev, const char *name, int unit)
903{
| 904fdc_add_child(device_t dev, const char *name, int unit)
905{
|
904 int fdu, flags;
| 906 int flags;
|
905 struct fdc_ivars *ivar;
906 device_t child;
907
908 ivar = malloc(sizeof *ivar, M_DEVBUF /* XXX */, M_NOWAIT | M_ZERO);
909 if (ivar == NULL)
| 907 struct fdc_ivars *ivar;
908 device_t child;
909
910 ivar = malloc(sizeof *ivar, M_DEVBUF /* XXX */, M_NOWAIT | M_ZERO);
911 if (ivar == NULL)
|
910 return;
| 912 return (NULL);
|
911 child = device_add_child(dev, name, unit);
912 if (child == NULL) {
913 free(ivar, M_DEVBUF);
| 913 child = device_add_child(dev, name, unit);
914 if (child == NULL) {
915 free(ivar, M_DEVBUF);
|
914 return;
| 916 return (NULL);
|
915 }
916 device_set_ivars(child, ivar);
| 917 }
918 device_set_ivars(child, ivar);
|
917 if (resource_int_value(name, unit, "drive", &fdu) != 0)
918 fdu = 0;
919 fdc_set_fdunit(child, fdu);
920 fdc_set_fdtype(child, FDT_NONE);
| 919 ivar->fdunit = unit;
920 ivar->fdtype = FDT_NONE;
|
921 if (resource_int_value(name, unit, "flags", &flags) == 0)
922 device_set_flags(child, flags);
923 if (resource_disabled(name, unit))
924 device_disable(child);
| 921 if (resource_int_value(name, unit, "flags", &flags) == 0)
922 device_set_flags(child, flags);
923 if (resource_disabled(name, unit))
924 device_disable(child);
|
| 925 return (child);
|
925}
926
927int
928fdc_attach(device_t dev)
929{
930 struct fdc_data *fdc;
| 926}
927
928int
929fdc_attach(device_t dev)
930{
931 struct fdc_data *fdc;
|
931 const char *name, *dname;
932 int i, dunit, error;
| 932 int error;
|
933
934 fdc = device_get_softc(dev);
935 fdc->fdc_dev = dev;
936 error = BUS_SETUP_INTR(device_get_parent(dev), dev, fdc->res_irq,
937 INTR_TYPE_BIO | INTR_ENTROPY, fdc_intr, fdc,
938 &fdc->fdc_intr);
939 if (error) {
940 device_printf(dev, "cannot setup interrupt\n");
941 return error;
942 }
943 fdc->fdcu = device_get_unit(dev);
| 933
934 fdc = device_get_softc(dev);
935 fdc->fdc_dev = dev;
936 error = BUS_SETUP_INTR(device_get_parent(dev), dev, fdc->res_irq,
937 INTR_TYPE_BIO | INTR_ENTROPY, fdc_intr, fdc,
938 &fdc->fdc_intr);
939 if (error) {
940 device_printf(dev, "cannot setup interrupt\n");
941 return error;
942 }
943 fdc->fdcu = device_get_unit(dev);
|
944 fdc->flags |= FDC_ATTACHED | FDC_NEEDS_RESET;
| 944 fdc->flags |= FDC_NEEDS_RESET;
|
945
946 fdc->state = DEVIDLE;
947
948#ifdef PC98
949 /* reset controller, turn motor off, clear fdout mirror reg */
950 fdc_reset(fdc);
951#else
952 /* reset controller, turn motor off, clear fdout mirror reg */
953 fdout_wr(fdc, fdc->fdout = 0);
954#endif
955 bioq_init(&fdc->head);
956
| 945
946 fdc->state = DEVIDLE;
947
948#ifdef PC98
949 /* reset controller, turn motor off, clear fdout mirror reg */
950 fdc_reset(fdc);
951#else
952 /* reset controller, turn motor off, clear fdout mirror reg */
953 fdout_wr(fdc, fdc->fdout = 0);
954#endif
955 bioq_init(&fdc->head);
956
|
| 957 return (0);
958}
959
960int
961fdc_hints_probe(device_t dev)
962{
963 const char *name, *dname;
964 int i, error, dunit;
965
|
957 /*
958 * Probe and attach any children. We should probably detect
959 * devices from the BIOS unless overridden.
960 */
961 name = device_get_nameunit(dev);
962 i = 0;
| 966 /*
967 * Probe and attach any children. We should probably detect
968 * devices from the BIOS unless overridden.
969 */
970 name = device_get_nameunit(dev);
971 i = 0;
|
963 while ((resource_find_match(&i, &dname, &dunit, "at", name)) == 0)
| 972 while ((resource_find_match(&i, &dname, &dunit, "at", name)) == 0) {
973 resource_int_value(dname, dunit, "drive", &dunit);
|
964 fdc_add_child(dev, dname, dunit);
| 974 fdc_add_child(dev, dname, dunit);
|
| 975 }
|
965
966 if ((error = bus_generic_attach(dev)) != 0)
967 return (error);
| 976
977 if ((error = bus_generic_attach(dev)) != 0)
978 return (error);
|
968
| |
969 return (0);
970}
971
972int
973fdc_print_child(device_t me, device_t child)
974{
975 int retval = 0, flags;
976
977 retval += bus_print_child_header(me, child);
978 retval += printf(" on %s drive %d", device_get_nameunit(me),
979 fdc_get_fdunit(child));
980 if ((flags = device_get_flags(me)) != 0)
981 retval += printf(" flags %#x", flags);
982 retval += printf("\n");
983
984 return (retval);
985}
986
987/*
988 * Configuration/initialization, per drive.
989 */
990static int
991fd_probe(device_t dev)
992{
993 int i;
994#ifndef PC98
995 u_int st0, st3;
996#endif
997 struct fd_data *fd;
998 struct fdc_data *fdc;
999 fdsu_t fdsu;
1000 int flags, type;
1001
1002 fdsu = fdc_get_fdunit(dev);
1003 fd = device_get_softc(dev);
1004 fdc = device_get_softc(device_get_parent(dev));
1005 flags = device_get_flags(dev);
1006
1007 fd->dev = dev;
1008 fd->fdc = fdc;
1009 fd->fdsu = fdsu;
1010 fd->fdu = device_get_unit(dev);
1011
| 979 return (0);
980}
981
982int
983fdc_print_child(device_t me, device_t child)
984{
985 int retval = 0, flags;
986
987 retval += bus_print_child_header(me, child);
988 retval += printf(" on %s drive %d", device_get_nameunit(me),
989 fdc_get_fdunit(child));
990 if ((flags = device_get_flags(me)) != 0)
991 retval += printf(" flags %#x", flags);
992 retval += printf("\n");
993
994 return (retval);
995}
996
997/*
998 * Configuration/initialization, per drive.
999 */
1000static int
1001fd_probe(device_t dev)
1002{
1003 int i;
1004#ifndef PC98
1005 u_int st0, st3;
1006#endif
1007 struct fd_data *fd;
1008 struct fdc_data *fdc;
1009 fdsu_t fdsu;
1010 int flags, type;
1011
1012 fdsu = fdc_get_fdunit(dev);
1013 fd = device_get_softc(dev);
1014 fdc = device_get_softc(device_get_parent(dev));
1015 flags = device_get_flags(dev);
1016
1017 fd->dev = dev;
1018 fd->fdc = fdc;
1019 fd->fdsu = fdsu;
1020 fd->fdu = device_get_unit(dev);
1021
|
1012 type = FD_DTYPE(flags);
1013
| |
1014 /* Auto-probe if fdinfo is present, but always allow override. */
| 1022 /* Auto-probe if fdinfo is present, but always allow override. */
|
| 1023 type = FD_DTYPE(flags);
|
1015 if (type == FDT_NONE && (type = fdc_get_fdtype(dev)) != FDT_NONE) {
1016 fd->type = type;
1017 goto done;
1018 } else {
1019 /* make sure fdautoselect() will be called */
1020 fd->flags = FD_UA;
1021 fd->type = type;
1022 }
1023
1024#ifdef PC98
1025 pc98_fd_check_type(fd);
1026#else
1027/*
1028 * XXX I think using __i386__ is wrong here since we actually want to probe
1029 * for the machine type, not the CPU type (so non-PC arch's like the PC98 will
1030 * fail the probe). However, for whatever reason, testing for _MACHINE_ARCH
1031 * == i386 breaks the test on FreeBSD/Alpha.
1032 */
1033#ifdef __i386__
1034 if (fd->type == FDT_NONE && (fd->fdu == 0 || fd->fdu == 1)) {
1035 /* Look up what the BIOS thinks we have. */
1036 if (fd->fdu == 0) {
1037 if ((fdc->flags & FDC_ISPCMCIA))
1038 /*
1039 * Somewhat special. No need to force the
1040 * user to set device flags, since the Y-E
1041 * Data PCMCIA floppy is always a 1.44 MB
1042 * device.
1043 */
1044 fd->type = FDT_144M;
1045 else
1046 fd->type = (rtcin(RTC_FDISKETTE) & 0xf0) >> 4;
1047 } else {
1048 fd->type = rtcin(RTC_FDISKETTE) & 0x0f;
1049 }
1050 if (fd->type == FDT_288M_1)
1051 fd->type = FDT_288M;
1052 }
1053#endif /* __i386__ */
1054#endif /* PC98 */
1055
1056 /* is there a unit? */
1057 if (fd->type == FDT_NONE)
1058 return (ENXIO);
1059
1060#ifndef PC98
1061 /* select it */
1062 set_motor(fdc, fdsu, TURNON);
1063 fdc_reset(fdc); /* XXX reset, then unreset, etc. */
1064 DELAY(1000000); /* 1 sec */
1065
1066 if ((flags & FD_NO_PROBE) == 0) {
1067 /* If we're at track 0 first seek inwards. */
1068 if ((fd_sense_drive_status(fdc, &st3) == 0) &&
1069 (st3 & NE7_ST3_T0)) {
1070 /* Seek some steps... */
1071 if (fd_cmd(fdc, 3, NE7CMD_SEEK, fdsu, 10, 0) == 0) {
1072 /* ...wait a moment... */
1073 DELAY(300000);
1074 /* make ctrlr happy: */
1075 fd_sense_int(fdc, 0, 0);
1076 }
1077 }
1078
1079 for (i = 0; i < 2; i++) {
1080 /*
1081 * we must recalibrate twice, just in case the
1082 * heads have been beyond cylinder 76, since
1083 * most FDCs still barf when attempting to
1084 * recalibrate more than 77 steps
1085 */
1086 /* go back to 0: */
1087 if (fd_cmd(fdc, 2, NE7CMD_RECAL, fdsu, 0) == 0) {
1088 /* a second being enough for full stroke seek*/
1089 DELAY(i == 0 ? 1000000 : 300000);
1090
1091 /* anything responding? */
1092 if (fd_sense_int(fdc, &st0, 0) == 0 &&
1093 (st0 & NE7_ST0_EC) == 0)
1094 break; /* already probed succesfully */
1095 }
1096 }
1097 }
1098
1099 set_motor(fdc, fdsu, TURNOFF);
1100
1101 if ((flags & FD_NO_PROBE) == 0 &&
1102 (st0 & NE7_ST0_EC) != 0) /* no track 0 -> no drive present */
1103 return (ENXIO);
1104#endif /* PC98 */
1105
1106done:
1107#ifndef PC98
| 1024 if (type == FDT_NONE && (type = fdc_get_fdtype(dev)) != FDT_NONE) {
1025 fd->type = type;
1026 goto done;
1027 } else {
1028 /* make sure fdautoselect() will be called */
1029 fd->flags = FD_UA;
1030 fd->type = type;
1031 }
1032
1033#ifdef PC98
1034 pc98_fd_check_type(fd);
1035#else
1036/*
1037 * XXX I think using __i386__ is wrong here since we actually want to probe
1038 * for the machine type, not the CPU type (so non-PC arch's like the PC98 will
1039 * fail the probe). However, for whatever reason, testing for _MACHINE_ARCH
1040 * == i386 breaks the test on FreeBSD/Alpha.
1041 */
1042#ifdef __i386__
1043 if (fd->type == FDT_NONE && (fd->fdu == 0 || fd->fdu == 1)) {
1044 /* Look up what the BIOS thinks we have. */
1045 if (fd->fdu == 0) {
1046 if ((fdc->flags & FDC_ISPCMCIA))
1047 /*
1048 * Somewhat special. No need to force the
1049 * user to set device flags, since the Y-E
1050 * Data PCMCIA floppy is always a 1.44 MB
1051 * device.
1052 */
1053 fd->type = FDT_144M;
1054 else
1055 fd->type = (rtcin(RTC_FDISKETTE) & 0xf0) >> 4;
1056 } else {
1057 fd->type = rtcin(RTC_FDISKETTE) & 0x0f;
1058 }
1059 if (fd->type == FDT_288M_1)
1060 fd->type = FDT_288M;
1061 }
1062#endif /* __i386__ */
1063#endif /* PC98 */
1064
1065 /* is there a unit? */
1066 if (fd->type == FDT_NONE)
1067 return (ENXIO);
1068
1069#ifndef PC98
1070 /* select it */
1071 set_motor(fdc, fdsu, TURNON);
1072 fdc_reset(fdc); /* XXX reset, then unreset, etc. */
1073 DELAY(1000000); /* 1 sec */
1074
1075 if ((flags & FD_NO_PROBE) == 0) {
1076 /* If we're at track 0 first seek inwards. */
1077 if ((fd_sense_drive_status(fdc, &st3) == 0) &&
1078 (st3 & NE7_ST3_T0)) {
1079 /* Seek some steps... */
1080 if (fd_cmd(fdc, 3, NE7CMD_SEEK, fdsu, 10, 0) == 0) {
1081 /* ...wait a moment... */
1082 DELAY(300000);
1083 /* make ctrlr happy: */
1084 fd_sense_int(fdc, 0, 0);
1085 }
1086 }
1087
1088 for (i = 0; i < 2; i++) {
1089 /*
1090 * we must recalibrate twice, just in case the
1091 * heads have been beyond cylinder 76, since
1092 * most FDCs still barf when attempting to
1093 * recalibrate more than 77 steps
1094 */
1095 /* go back to 0: */
1096 if (fd_cmd(fdc, 2, NE7CMD_RECAL, fdsu, 0) == 0) {
1097 /* a second being enough for full stroke seek*/
1098 DELAY(i == 0 ? 1000000 : 300000);
1099
1100 /* anything responding? */
1101 if (fd_sense_int(fdc, &st0, 0) == 0 &&
1102 (st0 & NE7_ST0_EC) == 0)
1103 break; /* already probed succesfully */
1104 }
1105 }
1106 }
1107
1108 set_motor(fdc, fdsu, TURNOFF);
1109
1110 if ((flags & FD_NO_PROBE) == 0 &&
1111 (st0 & NE7_ST0_EC) != 0) /* no track 0 -> no drive present */
1112 return (ENXIO);
1113#endif /* PC98 */
1114
1115done:
1116#ifndef PC98
|
1108 /* This doesn't work before the first reset. Or set_motor?? */
| 1117 /* This doesn't work before the first reset. */
|
1109 if ((fdc->flags & FDC_HAS_FIFO) == 0 &&
1110 fdc->fdct == FDC_ENHANCED &&
1111 (device_get_flags(fdc->fdc_dev) & FDC_NO_FIFO) == 0 &&
1112 enable_fifo(fdc) == 0) {
1113 device_printf(device_get_parent(dev),
1114 "FIFO enabled, %d bytes threshold\n", fifo_threshold);
1115 }
1116#endif /* PC98 */
1117
1118#ifdef PC98
1119 switch (fd->type) {
1120 case FDT_144M:
1121 device_set_desc(dev, "1.44M FDD");
1122 break;
1123 case FDT_12M:
1124#ifdef EPSON_NRDISK
1125 if (fd->fdu == nrdu) {
1126 device_set_desc(dev, "EPSON RAM DRIVE");
1127 nrd_LED_off();
1128 } else
1129 device_set_desc(dev, "1M/640K FDD");
1130#else
1131 device_set_desc(dev, "1M/640K FDD");
1132#endif
1133 break;
1134 default:
1135 return (ENXIO);
1136 }
1137#else
1138 switch (fd->type) {
1139 case FDT_12M:
1140 device_set_desc(dev, "1200-KB 5.25\" drive");
1141 break;
1142 case FDT_144M:
1143 device_set_desc(dev, "1440-KB 3.5\" drive");
1144 break;
1145 case FDT_288M:
1146 device_set_desc(dev, "2880-KB 3.5\" drive (in 1440-KB mode)");
1147 break;
1148 case FDT_360K:
1149 device_set_desc(dev, "360-KB 5.25\" drive");
1150 break;
1151 case FDT_720K:
1152 device_set_desc(dev, "720-KB 3.5\" drive");
1153 break;
1154 default:
1155 return (ENXIO);
1156 }
1157#endif
1158 fd->track = FD_NO_TRACK;
1159 fd->fdc = fdc;
1160 fd->fdsu = fdsu;
1161 fd->options = 0;
1162#ifdef PC98
1163 fd->pc98_trans = 0;
1164#endif
1165 callout_handle_init(&fd->toffhandle);
1166 callout_handle_init(&fd->tohandle);
1167
1168 /* initialize densities for subdevices */
1169#ifdef PC98
1170 for (i = 0; i < NUMDENS; i++)
1171 memcpy(fd->fts + i, fd_searchlist_144m + i,
1172 sizeof(struct fd_type));
1173#else
1174 for (i = 0; i < NUMDENS; i++)
1175 memcpy(fd->fts + i, fd_native_types + fd->type,
1176 sizeof(struct fd_type));
1177#endif
1178 return (0);
1179}
1180
1181static int
1182fd_attach(device_t dev)
1183{
1184 struct fd_data *fd;
1185
1186 fd = device_get_softc(dev);
1187 fd->masterdev = make_dev(&fd_cdevsw, fd->fdu,
1188 UID_ROOT, GID_OPERATOR, 0640, "fd%d", fd->fdu);
1189 fd->masterdev->si_drv1 = fd;
1190 fd->device_stats = devstat_new_entry(device_get_name(dev),
1191 device_get_unit(dev), 0, DEVSTAT_NO_ORDERED_TAGS,
1192 DEVSTAT_TYPE_FLOPPY | DEVSTAT_TYPE_IF_OTHER,
1193 DEVSTAT_PRIORITY_FD);
1194 return (0);
1195}
1196
1197static int
1198fd_detach(device_t dev)
1199{
1200 struct fd_data *fd;
1201
1202 fd = device_get_softc(dev);
1203 untimeout(fd_turnoff, fd, fd->toffhandle);
1204 devstat_remove_entry(fd->device_stats);
1205 destroy_dev(fd->masterdev);
1206
1207 return (0);
1208}
1209
1210static device_method_t fd_methods[] = {
1211 /* Device interface */
1212 DEVMETHOD(device_probe, fd_probe),
1213 DEVMETHOD(device_attach, fd_attach),
1214 DEVMETHOD(device_detach, fd_detach),
1215 DEVMETHOD(device_shutdown, bus_generic_shutdown),
1216 DEVMETHOD(device_suspend, bus_generic_suspend), /* XXX */
1217 DEVMETHOD(device_resume, bus_generic_resume), /* XXX */
1218
1219 { 0, 0 }
1220};
1221
1222static driver_t fd_driver = {
1223 "fd",
1224 fd_methods,
1225 sizeof(struct fd_data)
1226};
1227
1228DRIVER_MODULE(fd, fdc, fd_driver, fd_devclass, 0, 0);
1229
1230/*
1231 * More auxiliary functions.
1232 */
1233/*
1234 * Motor control stuff.
1235 * Remember to not deselect the drive we're working on.
1236 */
1237static void
1238set_motor(struct fdc_data *fdc, int fdsu, int turnon)
1239{
1240#ifdef PC98
1241 bus_space_write_1(fdc->sc_fdsiot, fdc->sc_fdsioh, 0,
1242 (pc98_trans != 1 ? FDP_FDDEXC : 0) | FDP_PORTEXC);
1243 DELAY(10);
1244 fdctl_wr(fdc, FDC_DMAE | FDC_MTON);
1245#else
1246 int fdout;
1247
1248 fdout = fdc->fdout;
1249 if (turnon) {
1250 fdout &= ~FDO_FDSEL;
1251 fdout |= (FDO_MOEN0 << fdsu) | FDO_FDMAEN | FDO_FRST | fdsu;
1252 } else
1253 fdout &= ~(FDO_MOEN0 << fdsu);
1254 fdc->fdout = fdout;
1255 fdout_wr(fdc, fdout);
1256 TRACE1("[0x%x->FDOUT]", fdout);
1257#endif
1258}
1259
1260static void
1261fd_turnoff(void *xfd)
1262{
1263 int s;
1264 fd_p fd = xfd;
1265
1266 TRACE1("[fd%d: turnoff]", fd->fdu);
1267
1268 s = splbio();
1269 /*
1270 * Don't turn off the motor yet if the drive is active.
1271 *
1272 * If we got here, this could only mean we missed an interrupt.
1273 * This can e. g. happen on the Y-E Date PCMCIA floppy controller
1274 * after a controller reset. Just schedule a pseudo-interrupt
1275 * so the state machine gets re-entered.
1276 */
1277 if (fd->fdc->state != DEVIDLE && fd->fdc->fdu == fd->fdu) {
1278 fdc_intr(fd->fdc);
1279 splx(s);
1280 return;
1281 }
1282
1283 fd->flags &= ~FD_MOTOR;
1284 set_motor(fd->fdc, fd->fdsu, TURNOFF);
1285 splx(s);
1286}
1287
1288static void
1289fd_motor_on(void *xfd)
1290{
1291 int s;
1292 fd_p fd = xfd;
1293
1294 s = splbio();
1295 fd->flags &= ~FD_MOTOR_WAIT;
1296 if((fd->fdc->fd == fd) && (fd->fdc->state == MOTORWAIT))
1297 {
1298 fdc_intr(fd->fdc);
1299 }
1300 splx(s);
1301}
1302
1303static void
1304fd_turnon(fd_p fd)
1305{
1306 if(!(fd->flags & FD_MOTOR))
1307 {
1308 fd->flags |= (FD_MOTOR + FD_MOTOR_WAIT);
1309 set_motor(fd->fdc, fd->fdsu, TURNON);
1310 timeout(fd_motor_on, fd, hz); /* in 1 sec its ok */
1311 }
1312}
1313
1314static void
1315fdc_reset(fdc_p fdc)
1316{
1317 /* Try a reset, keep motor on */
1318#ifdef PC98
1319 set_density(fdc);
1320 if (pc98_machine_type & M_EPSON_PC98)
1321 fdctl_wr(fdc, FDC_RST | FDC_RDY | FDC_DD | FDC_MTON);
1322 else
1323 fdctl_wr(fdc, FDC_RST | FDC_RDY | FDC_DMAE | FDC_MTON);
1324 DELAY(200);
1325 fdctl_wr(fdc, FDC_DMAE | FDC_MTON);
1326 DELAY(10);
1327#else
1328 fdout_wr(fdc, fdc->fdout & ~(FDO_FRST|FDO_FDMAEN));
1329 TRACE1("[0x%x->FDOUT]", fdc->fdout & ~(FDO_FRST|FDO_FDMAEN));
1330 DELAY(100);
1331 /* enable FDC, but defer interrupts a moment */
1332 fdout_wr(fdc, fdc->fdout & ~FDO_FDMAEN);
1333 TRACE1("[0x%x->FDOUT]", fdc->fdout & ~FDO_FDMAEN);
1334 DELAY(100);
1335 fdout_wr(fdc, fdc->fdout);
1336 TRACE1("[0x%x->FDOUT]", fdc->fdout);
1337#endif
1338
1339 /* XXX after a reset, silently believe the FDC will accept commands */
1340#ifdef PC98
1341 (void)fd_cmd(fdc, 3, NE7CMD_SPECIFY,
1342 NE7_SPEC_1(4, 240), NE7_SPEC_2(2, 0),
1343 0);
1344#else
1345 (void)fd_cmd(fdc, 3, NE7CMD_SPECIFY,
1346 NE7_SPEC_1(3, 240), NE7_SPEC_2(2, 0),
1347 0);
1348#endif
1349 if (fdc->flags & FDC_HAS_FIFO)
1350 (void) enable_fifo(fdc);
1351}
1352
1353/*
1354 * FDC IO functions, take care of the main status register, timeout
1355 * in case the desired status bits are never set.
1356 *
1357 * These PIO loops initially start out with short delays between
1358 * each iteration in the expectation that the required condition
1359 * is usually met quickly, so it can be handled immediately. After
1360 * about 1 ms, stepping is increased to achieve a better timing
1361 * accuracy in the calls to DELAY().
1362 */
1363static int
1364fd_in(struct fdc_data *fdc, int *ptr)
1365{
1366 int i, j, step;
1367
1368 for (j = 0, step = 1;
1369 (i = fdsts_rd(fdc) & (NE7_DIO|NE7_RQM)) != (NE7_DIO|NE7_RQM) &&
1370 j < FDSTS_TIMEOUT;
1371 j += step) {
1372 if (i == NE7_RQM)
1373 return (fdc_err(fdc, "ready for output in input\n"));
1374 if (j == 1000)
1375 step = 1000;
1376 DELAY(step);
1377 }
1378 if (j >= FDSTS_TIMEOUT)
1379 return (fdc_err(fdc, bootverbose? "input ready timeout\n": 0));
1380#ifdef FDC_DEBUG
1381 i = fddata_rd(fdc);
1382 TRACE1("[FDDATA->0x%x]", (unsigned char)i);
1383 *ptr = i;
1384 return (0);
1385#else /* !FDC_DEBUG */
1386 i = fddata_rd(fdc);
1387 if (ptr)
1388 *ptr = i;
1389 return (0);
1390#endif /* FDC_DEBUG */
1391}
1392
1393static int
1394out_fdc(struct fdc_data *fdc, int x)
1395{
1396 int i, j, step;
1397
1398 for (j = 0, step = 1;
1399 (i = fdsts_rd(fdc) & (NE7_DIO|NE7_RQM)) != NE7_RQM &&
1400 j < FDSTS_TIMEOUT;
1401 j += step) {
1402 if (i == (NE7_DIO|NE7_RQM))
1403 return (fdc_err(fdc, "ready for input in output\n"));
1404 if (j == 1000)
1405 step = 1000;
1406 DELAY(step);
1407 }
1408 if (j >= FDSTS_TIMEOUT)
1409 return (fdc_err(fdc, bootverbose? "output ready timeout\n": 0));
1410
1411 /* Send the command and return */
1412 fddata_wr(fdc, x);
1413 TRACE1("[0x%x->FDDATA]", x);
1414 return (0);
1415}
1416
1417/*
1418 * Block device driver interface functions (interspersed with even more
1419 * auxiliary functions).
1420 */
1421static int
1422fdopen(struct cdev *dev, int flags, int mode, struct thread *td)
1423{
1424 fd_p fd;
1425 fdc_p fdc;
1426#ifdef PC98
1427 fdu_t fdu;
1428#endif
1429 int rv, unitattn, dflags;
1430
1431 fd = dev->si_drv1;
1432 if (fd == NULL)
1433 return (ENXIO);
1434 fdc = fd->fdc;
1435 if ((fdc == NULL) || (fd->type == FDT_NONE))
1436 return (ENXIO);
1437#ifdef PC98
1438 fdu = fd->fdu;
1439#endif
1440 dflags = device_get_flags(fd->dev);
1441 /*
1442 * This is a bit bogus. It's still possible that e. g. a
1443 * descriptor gets inherited to a child, but then it's at
1444 * least for the same subdevice. By checking FD_OPEN here, we
1445 * can ensure that a device isn't attempted to be opened with
1446 * different densities at the same time where the second open
1447 * could clobber the settings from the first one.
1448 */
1449 if (fd->flags & FD_OPEN)
1450 return (EBUSY);
1451
1452#ifdef PC98
1453 if (pc98_fd_check_ready(fdu) == -1)
1454 return(EIO);
1455#endif
1456
1457 if (flags & FNONBLOCK) {
1458 /*
1459 * Unfortunately, physio(9) discards its ioflag
1460 * argument, thus preventing us from seeing the
1461 * IO_NDELAY bit. So we need to keep track
1462 * ourselves.
1463 */
1464 fd->flags |= FD_NONBLOCK;
1465 fd->ft = 0;
1466 } else {
1467 /*
1468 * Figure out a unit attention condition.
1469 *
1470 * If UA has been forced, proceed.
1471 *
1472 * If the drive has no changeline support,
1473 * or if the drive parameters have been lost
1474 * due to previous non-blocking access,
1475 * assume a forced UA condition.
1476 *
1477 * If motor is off, turn it on for a moment
1478 * and select our drive, in order to read the
1479 * UA hardware signal.
1480 *
1481 * If motor is on, and our drive is currently
1482 * selected, just read the hardware bit.
1483 *
1484 * If motor is on, but active for another
1485 * drive on that controller, we are lost. We
1486 * cannot risk to deselect the other drive, so
1487 * we just assume a forced UA condition to be
1488 * on the safe side.
1489 */
1490 unitattn = 0;
1491 if ((dflags & FD_NO_CHLINE) != 0 ||
1492 (fd->flags & FD_UA) != 0 ||
1493 fd->ft == 0) {
1494 unitattn = 1;
1495 fd->flags &= ~FD_UA;
1496#ifndef PC98
1497 } else if (fdc->fdout & (FDO_MOEN0 | FDO_MOEN1 |
1498 FDO_MOEN2 | FDO_MOEN3)) {
1499 if ((fdc->fdout & FDO_FDSEL) == fd->fdsu)
1500 unitattn = fdin_rd(fdc) & FDI_DCHG;
1501 else
1502 unitattn = 1;
1503 } else {
1504 set_motor(fdc, fd->fdsu, TURNON);
1505 unitattn = fdin_rd(fdc) & FDI_DCHG;
1506 set_motor(fdc, fd->fdsu, TURNOFF);
1507#endif /* PC98 */
1508 }
1509 if (unitattn && (rv = fdautoselect(dev)) != 0)
1510 return (rv);
1511 }
1512 fd->flags |= FD_OPEN;
1513
1514 if ((fdc->flags & FDC_NODMA) == 0) {
1515 if (fdc->dmacnt++ == 0) {
1516 isa_dma_acquire(fdc->dmachan);
1517 isa_dmainit(fdc->dmachan, MAX_SEC_SIZE);
1518 }
1519 }
1520
1521 /*
1522 * Clearing the DMA overrun counter at open time is a bit messy.
1523 * Since we're only managing one counter per controller, opening
1524 * the second drive could mess it up. Anyway, if the DMA overrun
1525 * condition is really persistent, it will eventually time out
1526 * still. OTOH, clearing it here will ensure we'll at least start
1527 * trying again after a previous (maybe even long ago) failure.
1528 * Also, this is merely a stop-gap measure only that should not
1529 * happen during normal operation, so we can tolerate it to be a
1530 * bit sloppy about this.
1531 */
1532 fdc->dma_overruns = 0;
1533
1534 return 0;
1535}
1536
1537static int
1538fdclose(struct cdev *dev, int flags, int mode, struct thread *td)
1539{
1540 struct fd_data *fd;
1541 fdc_p fdc;
1542
1543 fd = dev->si_drv1;
1544 fdc = fd->fdc;
1545 fd->flags &= ~(FD_OPEN | FD_NONBLOCK);
1546 fd->options &= ~(FDOPT_NORETRY | FDOPT_NOERRLOG | FDOPT_NOERROR);
1547
1548 if ((fdc->flags & FDC_NODMA) == 0)
1549 if (--fdc->dmacnt == 0)
1550 isa_dma_release(fdc->dmachan);
1551
1552 return (0);
1553}
1554
1555static void
1556fdstrategy(struct bio *bp)
1557{
1558 long blknum, nblocks;
1559 int s;
1560 fdu_t fdu;
1561 fdc_p fdc;
1562 fd_p fd;
1563 size_t fdblk;
1564
1565 fd = bp->bio_dev->si_drv1;
1566 fdu = fd->fdu;
1567 fdc = fd->fdc;
1568 bp->bio_resid = bp->bio_bcount;
1569 if (fd->type == FDT_NONE || fd->ft == 0) {
1570 if (fd->type != FDT_NONE && (fd->flags & FD_NONBLOCK))
1571 bp->bio_error = EAGAIN;
1572 else
1573 bp->bio_error = ENXIO;
1574 bp->bio_flags |= BIO_ERROR;
1575 goto bad;
1576 }
1577 fdblk = 128 << (fd->ft->secsize);
1578 if (bp->bio_cmd != FDBIO_FORMAT && bp->bio_cmd != FDBIO_RDSECTID) {
1579 if (fd->flags & FD_NONBLOCK) {
1580 bp->bio_error = EAGAIN;
1581 bp->bio_flags |= BIO_ERROR;
1582 goto bad;
1583 }
1584 if (bp->bio_offset < 0) {
1585 printf(
1586 "fd%d: fdstrat: bad request offset = %ju, bcount = %ld\n",
1587 fdu, (intmax_t)bp->bio_offset, bp->bio_bcount);
1588 bp->bio_error = EINVAL;
1589 bp->bio_flags |= BIO_ERROR;
1590 goto bad;
1591 }
1592 if ((bp->bio_bcount % fdblk) != 0) {
1593 bp->bio_error = EINVAL;
1594 bp->bio_flags |= BIO_ERROR;
1595 goto bad;
1596 }
1597 }
1598
1599 /*
1600 * Set up block calculations.
1601 */
1602#ifndef PC98
1603 if (bp->bio_offset >= ((off_t)128 << fd->ft->secsize) * fd->ft->size) {
1604 bp->bio_error = EINVAL;
1605 bp->bio_flags |= BIO_ERROR;
1606 goto bad;
1607 }
1608#endif
1609 blknum = bp->bio_offset / fdblk;
1610 nblocks = fd->ft->size;
1611 if (blknum + bp->bio_bcount / fdblk > nblocks) {
1612 if (blknum >= nblocks) {
1613 if (bp->bio_cmd != BIO_READ) {
1614 bp->bio_error = ENOSPC;
1615 bp->bio_flags |= BIO_ERROR;
1616 }
1617 goto bad; /* not always bad, but EOF */
1618 }
1619 bp->bio_bcount = (nblocks - blknum) * fdblk;
1620 }
1621 bp->bio_pblkno = blknum;
1622 s = splbio();
1623 bioq_disksort(&fdc->head, bp);
1624 untimeout(fd_turnoff, fd, fd->toffhandle); /* a good idea */
1625 devstat_start_transaction_bio(fd->device_stats, bp);
1626 device_busy(fd->dev);
1627 fdstart(fdc);
1628 splx(s);
1629 return;
1630
1631bad:
1632 biodone(bp);
1633}
1634
1635/*
1636 * fdstart
1637 *
1638 * We have just queued something. If the controller is not busy
1639 * then simulate the case where it has just finished a command
1640 * So that it (the interrupt routine) looks on the queue for more
1641 * work to do and picks up what we just added.
1642 *
1643 * If the controller is already busy, we need do nothing, as it
1644 * will pick up our work when the present work completes.
1645 */
1646static void
1647fdstart(struct fdc_data *fdc)
1648{
1649 int s;
1650
1651 s = splbio();
1652 if(fdc->state == DEVIDLE)
1653 {
1654 fdc_intr(fdc);
1655 }
1656 splx(s);
1657}
1658
1659static void
1660fd_iotimeout(void *xfdc)
1661{
1662 fdc_p fdc;
1663 int s;
1664
1665 fdc = xfdc;
1666 TRACE1("fd%d[fd_iotimeout()]", fdc->fdu);
1667
1668 /*
1669 * Due to IBM's brain-dead design, the FDC has a faked ready
1670 * signal, hardwired to ready == true. Thus, any command
1671 * issued if there's no diskette in the drive will _never_
1672 * complete, and must be aborted by resetting the FDC.
1673 * Many thanks, Big Blue!
1674 * The FDC must not be reset directly, since that would
1675 * interfere with the state machine. Instead, pretend that
1676 * the command completed but was invalid. The state machine
1677 * will reset the FDC and retry once.
1678 */
1679 s = splbio();
1680 fdc->status[0] = NE7_ST0_IC_IV;
1681 fdc->flags &= ~FDC_STAT_VALID;
1682 fdc->state = IOTIMEDOUT;
1683 fdc_intr(fdc);
1684 splx(s);
1685}
1686
1687/* Just ensure it has the right spl. */
1688static void
1689fd_pseudointr(void *xfdc)
1690{
1691 int s;
1692
1693 s = splbio();
1694 fdc_intr(xfdc);
1695 splx(s);
1696}
1697
1698/*
1699 * fdc_intr
1700 *
1701 * Keep calling the state machine until it returns a 0.
1702 * Always called at splbio.
1703 */
1704static void
1705fdc_intr(void *xfdc)
1706{
1707 fdc_p fdc = xfdc;
1708 while(fdstate(fdc))
1709 ;
1710}
1711
1712/*
1713 * Magic pseudo-DMA initialization for YE FDC. Sets count and
1714 * direction.
1715 */
1716#define SET_BCDR(fdc,wr,cnt,port) \
1717 bus_space_write_1(fdc->portt, fdc->porth, fdc->port_off + port, \
1718 ((cnt)-1) & 0xff); \
1719 bus_space_write_1(fdc->portt, fdc->porth, fdc->port_off + port + 1, \
1720 ((wr ? 0x80 : 0) | ((((cnt)-1) >> 8) & 0x7f)));
1721
1722/*
1723 * fdcpio(): perform programmed IO read/write for YE PCMCIA floppy.
1724 */
1725static int
1726fdcpio(fdc_p fdc, long flags, caddr_t addr, u_int count)
1727{
1728 u_char *cptr = (u_char *)addr;
1729
1730 if (flags == BIO_READ) {
1731 if (fdc->state != PIOREAD) {
1732 fdc->state = PIOREAD;
1733 return(0);
1734 }
1735 SET_BCDR(fdc, 0, count, 0);
1736 bus_space_read_multi_1(fdc->portt, fdc->porth, fdc->port_off +
1737 FDC_YE_DATAPORT, cptr, count);
1738 } else {
1739 bus_space_write_multi_1(fdc->portt, fdc->porth, fdc->port_off +
1740 FDC_YE_DATAPORT, cptr, count);
1741 SET_BCDR(fdc, 0, count, 0);
1742 }
1743 return(1);
1744}
1745
1746/*
1747 * Try figuring out the density of the media present in our device.
1748 */
1749static int
1750fdautoselect(struct cdev *dev)
1751{
1752 fd_p fd;
1753 struct fd_type *fdtp;
1754 struct fdc_readid id;
1755 int i, n, oopts, rv;
1756
1757 fd = dev->si_drv1;
1758
1759 switch (fd->type) {
1760 default:
1761 return (ENXIO);
1762
1763#ifndef PC98
1764 case FDT_360K:
1765 case FDT_720K:
1766 /* no autoselection on those drives */
1767 fd->ft = fd_native_types + fd->type;
1768 return (0);
1769#endif
1770
1771 case FDT_12M:
1772 fdtp = fd_searchlist_12m;
1773 n = sizeof fd_searchlist_12m / sizeof(struct fd_type);
1774 break;
1775
1776 case FDT_144M:
1777 fdtp = fd_searchlist_144m;
1778 n = sizeof fd_searchlist_144m / sizeof(struct fd_type);
1779 break;
1780
1781#ifndef PC98
1782 case FDT_288M:
1783 fdtp = fd_searchlist_288m;
1784 n = sizeof fd_searchlist_288m / sizeof(struct fd_type);
1785 break;
1786#endif
1787 }
1788
1789 /*
1790 * Try reading sector ID fields, first at cylinder 0, head 0,
1791 * then at cylinder 2, head N. We don't probe cylinder 1,
1792 * since for 5.25in DD media in a HD drive, there are no data
1793 * to read (2 step pulses per media cylinder required). For
1794 * two-sided media, the second probe always goes to head 1, so
1795 * we can tell them apart from single-sided media. As a
1796 * side-effect this means that single-sided media should be
1797 * mentioned in the search list after two-sided media of an
1798 * otherwise identical density. Media with a different number
1799 * of sectors per track but otherwise identical parameters
1800 * cannot be distinguished at all.
1801 *
1802 * If we successfully read an ID field on both cylinders where
1803 * the recorded values match our expectation, we are done.
1804 * Otherwise, we try the next density entry from the table.
1805 *
1806 * Stepping to cylinder 2 has the side-effect of clearing the
1807 * unit attention bit.
1808 */
1809 oopts = fd->options;
1810 fd->options |= FDOPT_NOERRLOG | FDOPT_NORETRY;
1811 for (i = 0; i < n; i++, fdtp++) {
1812 fd->ft = fdtp;
1813
1814 id.cyl = id.head = 0;
1815 rv = fdmisccmd(dev, FDBIO_RDSECTID, &id);
1816 if (rv != 0)
1817 continue;
1818 if (id.cyl != 0 || id.head != 0 ||
1819 id.secshift != fdtp->secsize)
1820 continue;
1821 id.cyl = 2;
1822 id.head = fd->ft->heads - 1;
1823 rv = fdmisccmd(dev, FDBIO_RDSECTID, &id);
1824 if (id.cyl != 2 || id.head != fdtp->heads - 1 ||
1825 id.secshift != fdtp->secsize)
1826 continue;
1827 if (rv == 0)
1828 break;
1829 }
1830
1831 fd->options = oopts;
1832 if (i == n) {
1833 if (bootverbose)
1834 device_printf(fd->dev, "autoselection failed\n");
1835 fd->ft = 0;
1836 return (EIO);
1837 } else {
1838 if (bootverbose)
1839 device_printf(fd->dev, "autoselected %d KB medium\n",
1840#ifdef PC98
1841 (128 << (fd->ft->secsize)) *
1842 fd->ft->size / 1024);
1843#else
1844 fd->ft->size / 2);
1845#endif
1846 return (0);
1847 }
1848}
1849
1850
1851/*
1852 * The controller state machine.
1853 *
1854 * If it returns a non zero value, it should be called again immediately.
1855 */
1856static int
1857fdstate(fdc_p fdc)
1858{
1859 struct fdc_readid *idp;
1860 int read, format, rdsectid, cylinder, head, i, sec = 0, sectrac;
1861 int st0, cyl, st3, idf, ne7cmd, mfm, steptrac;
1862 unsigned long blknum;
1863 fdu_t fdu = fdc->fdu;
1864 fd_p fd;
1865 register struct bio *bp;
1866 struct fd_formb *finfo = NULL;
1867 size_t fdblk;
1868
1869 bp = fdc->bp;
1870 if (bp == NULL) {
1871 bp = bioq_first(&fdc->head);
1872 if (bp != NULL) {
1873 bioq_remove(&fdc->head, bp);
1874 fdc->bp = bp;
1875 }
1876 }
1877 if (bp == NULL) {
1878 /*
1879 * Nothing left for this controller to do,
1880 * force into the IDLE state.
1881 */
1882 fdc->state = DEVIDLE;
1883 if (fdc->fd) {
1884 device_printf(fdc->fdc_dev,
1885 "unexpected valid fd pointer\n");
1886 fdc->fd = (fd_p) 0;
1887 fdc->fdu = -1;
1888 }
1889 TRACE1("[fdc%d IDLE]", fdc->fdcu);
1890 return (0);
1891 }
1892 fd = bp->bio_dev->si_drv1;
1893 fdu = fd->fdu;
1894 fdblk = 128 << fd->ft->secsize;
1895 if (fdc->fd && (fd != fdc->fd))
1896 device_printf(fd->dev, "confused fd pointers\n");
1897 read = bp->bio_cmd == BIO_READ;
1898 mfm = (fd->ft->flags & FL_MFM)? NE7CMD_MFM: 0;
1899 steptrac = (fd->ft->flags & FL_2STEP)? 2: 1;
1900 if (read)
1901 idf = ISADMA_READ;
1902 else
1903 idf = ISADMA_WRITE;
1904 format = bp->bio_cmd == FDBIO_FORMAT;
1905 rdsectid = bp->bio_cmd == FDBIO_RDSECTID;
1906 if (format)
1907 finfo = (struct fd_formb *)bp->bio_data;
1908 TRACE1("fd%d", fdu);
1909 TRACE1("[%s]", fdstates[fdc->state]);
1910 TRACE1("(0x%x)", fd->flags);
1911 untimeout(fd_turnoff, fd, fd->toffhandle);
1912 fd->toffhandle = timeout(fd_turnoff, fd, 4 * hz);
1913 switch (fdc->state)
1914 {
1915 case DEVIDLE:
1916 case FINDWORK: /* we have found new work */
1917 fdc->retry = 0;
1918 fd->skip = 0;
1919 fdc->fd = fd;
1920 fdc->fdu = fdu;
1921#ifdef PC98
1922 pc98_trans = fd->ft->trans;
1923 if (pc98_trans_prev != pc98_trans) {
1924 int i;
1925 set_density(fdc);
1926 for (i = 0; i < 10; i++) {
1927 outb(0x5f, 0);
1928 outb(0x5f, 0);
1929 }
1930 pc98_trans_prev = pc98_trans;
1931 }
1932 if (pc98_trans != fd->pc98_trans) {
1933 if (fd->type == FDT_144M) {
1934 bus_space_write_1(fdc->sc_fdemsiot,
1935 fdc->sc_fdemsioh,
1936 0,
1937 (fdu << 5) | 0x10 |
1938 (pc98_trans >> 1));
1939 outb(0x5f, 0);
1940 outb(0x5f, 0);
1941 }
1942 fd->pc98_trans = pc98_trans;
1943 }
1944#else
1945 fdc->fdctl_wr(fdc, fd->ft->trans);
1946#endif
1947 TRACE1("[0x%x->FDCTL]", fd->ft->trans);
1948 /*
1949 * If the next drive has a motor startup pending, then
1950 * it will start up in its own good time.
1951 */
1952 if(fd->flags & FD_MOTOR_WAIT) {
1953 fdc->state = MOTORWAIT;
1954 return (0); /* will return later */
1955 }
1956 /*
1957 * Maybe if it's not starting, it SHOULD be starting.
1958 */
1959#ifdef EPSON_NRDISK
1960 if (fdu != nrdu) {
1961 if (!(fd->flags & FD_MOTOR))
1962 {
1963 fdc->state = MOTORWAIT;
1964 fd_turnon(fdu);
1965 return(0);
1966 }
1967 else /* at least make sure we are selected */
1968 {
1969 set_motor(fdcu, fd->fdsu, TURNON);
1970 }
1971 }
1972#else /* !EPSON_NRDISK */
1973 if (!(fd->flags & FD_MOTOR))
1974 {
1975 fdc->state = MOTORWAIT;
1976 fd_turnon(fd);
1977 return (0); /* will return later */
1978 }
1979 else /* at least make sure we are selected */
1980 {
1981 set_motor(fdc, fd->fdsu, TURNON);
1982 }
1983#endif
1984 if (fdc->flags & FDC_NEEDS_RESET) {
1985 fdc->state = RESETCTLR;
1986 fdc->flags &= ~FDC_NEEDS_RESET;
1987 } else
1988 fdc->state = DOSEEK;
1989 return (1); /* will return immediately */
1990
1991 case DOSEEK:
1992 blknum = bp->bio_pblkno + fd->skip / fdblk;
1993 cylinder = blknum / (fd->ft->sectrac * fd->ft->heads);
1994 if (cylinder == fd->track)
1995 {
1996 fdc->state = SEEKCOMPLETE;
1997 return (1); /* will return immediately */
1998 }
1999#ifdef PC98
2000 pc98_fd_check_ready(fdu);
2001#endif
2002 if (fd_cmd(fdc, 3, NE7CMD_SEEK,
2003 fd->fdsu, cylinder * steptrac, 0))
2004 {
2005 /*
2006 * Seek command not accepted, looks like
2007 * the FDC went off to the Saints...
2008 */
2009 fdc->retry = 6; /* try a reset */
2010 return(retrier(fdc));
2011 }
2012 fd->track = FD_NO_TRACK;
2013 fdc->state = SEEKWAIT;
2014 return(0); /* will return later */
2015
2016 case SEEKWAIT:
2017 /* allow heads to settle */
2018 timeout(fd_pseudointr, fdc, hz / 16);
2019 fdc->state = SEEKCOMPLETE;
2020 return(0); /* will return later */
2021
2022 case SEEKCOMPLETE : /* seek done, start DMA */
2023 blknum = bp->bio_pblkno + fd->skip / fdblk;
2024 cylinder = blknum / (fd->ft->sectrac * fd->ft->heads);
2025
2026 /* Make sure seek really happened. */
2027 if(fd->track == FD_NO_TRACK) {
2028 int descyl = cylinder * steptrac;
2029 do {
2030 /*
2031 * This might be a "ready changed" interrupt,
2032 * which cannot really happen since the
2033 * RDY pin is hardwired to + 5 volts. This
2034 * generally indicates a "bouncing" intr
2035 * line, so do one of the following:
2036 *
2037 * When running on an enhanced FDC that is
2038 * known to not go stuck after responding
2039 * with INVALID, fetch all interrupt states
2040 * until seeing either an INVALID or a
2041 * real interrupt condition.
2042 *
2043 * When running on a dumb old NE765, give
2044 * up immediately. The controller will
2045 * provide up to four dummy RC interrupt
2046 * conditions right after reset (for the
2047 * corresponding four drives), so this is
2048 * our only chance to get notice that it
2049 * was not the FDC that caused the interrupt.
2050 */
2051 if (fd_sense_int(fdc, &st0, &cyl)
2052 == FD_NOT_VALID)
2053 return (0); /* will return later */
2054 if(fdc->fdct == FDC_NE765
2055 && (st0 & NE7_ST0_IC) == NE7_ST0_IC_RC)
2056 return (0); /* hope for a real intr */
2057 } while ((st0 & NE7_ST0_IC) == NE7_ST0_IC_RC);
2058
2059 if (0 == descyl) {
2060 int failed = 0;
2061 /*
2062 * seek to cyl 0 requested; make sure we are
2063 * really there
2064 */
2065 if (fd_sense_drive_status(fdc, &st3))
2066 failed = 1;
2067#ifdef EPSON_NRDISK
2068 if (fdu == nrdu) st3 = NE7_ST3_T0;
2069#endif /* EPSON_NRDISK */
2070 if ((st3 & NE7_ST3_T0) == 0) {
2071 printf(
2072 "fd%d: Seek to cyl 0, but not really there (ST3 = %b)\n",
2073 fdu, st3, NE7_ST3BITS);
2074 failed = 1;
2075 }
2076
2077 if (failed) {
2078 if(fdc->retry < 3)
2079 fdc->retry = 3;
2080 return (retrier(fdc));
2081 }
2082 }
2083#ifdef EPSON_NRDISK
2084 if (fdu == nrdu) cyl = descyl;
2085#endif
2086
2087 if (cyl != descyl) {
2088 printf(
2089 "fd%d: Seek to cyl %d failed; am at cyl %d (ST0 = 0x%x)\n",
2090 fdu, descyl, cyl, st0);
2091 if (fdc->retry < 3)
2092 fdc->retry = 3;
2093 return (retrier(fdc));
2094 }
2095 }
2096
2097 fd->track = cylinder;
2098 if (format)
2099 fd->skip = (char *)&(finfo->fd_formb_cylno(0))
2100 - (char *)finfo;
2101#ifdef EPSON_NRDISK
2102 if (fdu != nrdu) {
2103#endif /* EPSON_NRDISK */
2104 if (!rdsectid && !(fdc->flags & FDC_NODMA))
2105 isa_dmastart(idf, bp->bio_data+fd->skip,
2106 format ? bp->bio_bcount : fdblk, fdc->dmachan);
2107 blknum = bp->bio_pblkno + fd->skip / fdblk;
2108 sectrac = fd->ft->sectrac;
2109 sec = blknum % (sectrac * fd->ft->heads);
2110 head = sec / sectrac;
2111 sec = sec % sectrac + 1;
2112 if (head != 0 && fd->ft->offset_side2 != 0)
2113 sec += fd->ft->offset_side2;
2114 fd->hddrv = ((head&1)<<2)+fdu;
2115
2116 if(format || !(read || rdsectid))
2117 {
2118 /* make sure the drive is writable */
2119 if(fd_sense_drive_status(fdc, &st3) != 0)
2120 {
2121 /* stuck controller? */
2122 if (!(fdc->flags & FDC_NODMA))
2123 isa_dmadone(idf,
2124 bp->bio_data + fd->skip,
2125 format ? bp->bio_bcount : fdblk,
2126 fdc->dmachan);
2127 fdc->retry = 6; /* reset the beast */
2128 return (retrier(fdc));
2129 }
2130 if(st3 & NE7_ST3_WP)
2131 {
2132 /*
2133 * XXX YES! this is ugly.
2134 * in order to force the current operation
2135 * to fail, we will have to fake an FDC
2136 * error - all error handling is done
2137 * by the retrier()
2138 */
2139 fdc->status[0] = NE7_ST0_IC_AT;
2140 fdc->status[1] = NE7_ST1_NW;
2141 fdc->status[2] = 0;
2142 fdc->status[3] = fd->track;
2143 fdc->status[4] = head;
2144 fdc->status[5] = sec;
2145 fdc->retry = 8; /* break out immediately */
2146 fdc->state = IOTIMEDOUT; /* not really... */
2147 return (1); /* will return immediately */
2148 }
2149 }
2150
2151 if (format) {
2152 ne7cmd = NE7CMD_FORMAT | mfm;
2153 if (fdc->flags & FDC_NODMA) {
2154 /*
2155 * This seems to be necessary for
2156 * whatever obscure reason; if we omit
2157 * it, we end up filling the sector ID
2158 * fields of the newly formatted track
2159 * entirely with garbage, causing
2160 * `wrong cylinder' errors all over
2161 * the place when trying to read them
2162 * back.
2163 *
2164 * Umpf.
2165 */
2166 SET_BCDR(fdc, 1, bp->bio_bcount, 0);
2167
2168 (void)fdcpio(fdc,bp->bio_cmd,
2169 bp->bio_data+fd->skip,
2170 bp->bio_bcount);
2171
2172 }
2173 /* formatting */
2174 if(fd_cmd(fdc, 6, ne7cmd, head << 2 | fdu,
2175 finfo->fd_formb_secshift,
2176 finfo->fd_formb_nsecs,
2177 finfo->fd_formb_gaplen,
2178 finfo->fd_formb_fillbyte, 0)) {
2179 /* controller fell over */
2180 if (!(fdc->flags & FDC_NODMA))
2181 isa_dmadone(idf,
2182 bp->bio_data + fd->skip,
2183 format ? bp->bio_bcount : fdblk,
2184 fdc->dmachan);
2185 fdc->retry = 6;
2186 return (retrier(fdc));
2187 }
2188 } else if (rdsectid) {
2189 ne7cmd = NE7CMD_READID | mfm;
2190 if (fd_cmd(fdc, 2, ne7cmd, head << 2 | fdu, 0)) {
2191 /* controller jamming */
2192 fdc->retry = 6;
2193 return (retrier(fdc));
2194 }
2195 } else {
2196 /* read or write operation */
2197 ne7cmd = (read ? NE7CMD_READ | NE7CMD_SK : NE7CMD_WRITE) | mfm;
2198 if (fdc->flags & FDC_NODMA) {
2199 /*
2200 * This seems to be necessary even when
2201 * reading data.
2202 */
2203 SET_BCDR(fdc, 1, fdblk, 0);
2204
2205 /*
2206 * Perform the write pseudo-DMA before
2207 * the WRITE command is sent.
2208 */
2209 if (!read)
2210 (void)fdcpio(fdc,bp->bio_cmd,
2211 bp->bio_data+fd->skip,
2212 fdblk);
2213 }
2214 if (fd_cmd(fdc, 9,
2215 ne7cmd,
2216 head << 2 | fdu, /* head & unit */
2217 fd->track, /* track */
2218 head,
2219 sec, /* sector + 1 */
2220 fd->ft->secsize, /* sector size */
2221 sectrac, /* sectors/track */
2222 fd->ft->gap, /* gap size */
2223 fd->ft->datalen, /* data length */
2224 0)) {
2225 /* the beast is sleeping again */
2226 if (!(fdc->flags & FDC_NODMA))
2227 isa_dmadone(idf,
2228 bp->bio_data + fd->skip,
2229 format ? bp->bio_bcount : fdblk,
2230 fdc->dmachan);
2231 fdc->retry = 6;
2232 return (retrier(fdc));
2233 }
2234 }
2235 if (!rdsectid && (fdc->flags & FDC_NODMA))
2236 /*
2237 * If this is a read, then simply await interrupt
2238 * before performing PIO.
2239 */
2240 if (read && !fdcpio(fdc,bp->bio_cmd,
2241 bp->bio_data+fd->skip,fdblk)) {
2242 fd->tohandle = timeout(fd_iotimeout, fdc, hz);
2243 return(0); /* will return later */
2244 }
2245
2246 /*
2247 * Write (or format) operation will fall through and
2248 * await completion interrupt.
2249 */
2250 fdc->state = IOCOMPLETE;
2251 fd->tohandle = timeout(fd_iotimeout, fdc, hz);
2252 return (0); /* will return later */
2253#ifdef EPSON_NRDISK
2254 }
2255 else {
2256 nrdblkn = (nrd_t)((unsigned long)bp->b_blkno*DEV_BSIZE/fdblk
2257 + fd->skip/fdblk);
2258 nrd_LED_on();
2259 nrd_addrset(fdblk * nrdblkn);
2260 while (!nrd_check_ready()) DELAY(1);
2261 if (read) epson_insw(P_NRD_DATA,
2262 bp->bio_data + fd->skip,
2263 fdblk / sizeof(short));
2264 else epson_outsw(P_NRD_DATA,
2265 bp->bio_data + fd->skip,
2266 (format ? bp->bio_bcount : fdblk)
2267 / sizeof(short));
2268
2269 blknum = (unsigned long)bp->b_blkno*DEV_BSIZE/fdblk
2270 + fd->skip/fdblk;
2271 sectrac = fd->ft->sectrac;
2272 sec = blknum % (sectrac * fd->ft->heads);
2273 head = sec / sectrac;
2274 sec = sec % sectrac + 1;
2275 fd->hddrv = ((head&1)<<2)+fdu;
2276
2277 if (nrdsec++ >= nrd_sec())
2278 nrdaddr = (nrd_t)(fd->track * 8 + head * 4);
2279 nrdsec = sec;
2280 fdc->state = IOCOMPLETE;
2281 }
2282#endif
2283
2284 case PIOREAD:
2285 /*
2286 * Actually perform the PIO read. The IOCOMPLETE case
2287 * removes the timeout for us.
2288 */
2289 (void)fdcpio(fdc,bp->bio_cmd,bp->bio_data+fd->skip,fdblk);
2290 fdc->state = IOCOMPLETE;
2291 /* FALLTHROUGH */
2292 case IOCOMPLETE: /* IO done, post-analyze */
2293#ifdef EPSON_NRDISK
2294 if (fdu != nrdu)
2295 untimeout(fd_iotimeout, fdc, fd->tohandle);
2296#else
2297 untimeout(fd_iotimeout, fdc, fd->tohandle);
2298#endif
2299
2300 if (fd_read_status(fdc)) {
2301 if (!rdsectid && !(fdc->flags & FDC_NODMA))
2302 isa_dmadone(idf, bp->bio_data + fd->skip,
2303 format ? bp->bio_bcount : fdblk,
2304 fdc->dmachan);
2305 if (fdc->retry < 6)
2306 fdc->retry = 6; /* force a reset */
2307 return (retrier(fdc));
2308 }
2309
2310 fdc->state = IOTIMEDOUT;
2311
2312 /* FALLTHROUGH */
2313 case IOTIMEDOUT:
2314#ifdef EPSON_NRDISK
2315 if (fdu != nrdu) {
2316#endif /* EPSON_NRDISK */
2317 if (!rdsectid && !(fdc->flags & FDC_NODMA))
2318 isa_dmadone(idf, bp->bio_data + fd->skip,
2319 format ? bp->bio_bcount : fdblk, fdc->dmachan);
2320#ifdef EPSON_NRDISK
2321 }
2322 else nrd_LED_off();
2323#endif /* EPSON_NRDISK */
2324 if (fdc->status[0] & NE7_ST0_IC) {
2325 if ((fdc->status[0] & NE7_ST0_IC) == NE7_ST0_IC_AT
2326 && fdc->status[1] & NE7_ST1_OR) {
2327 /*
2328 * DMA overrun. Someone hogged the bus and
2329 * didn't release it in time for the next
2330 * FDC transfer.
2331 *
2332 * We normally restart this without bumping
2333 * the retry counter. However, in case
2334 * something is seriously messed up (like
2335 * broken hardware), we rather limit the
2336 * number of retries so the IO operation
2337 * doesn't block indefinately.
2338 */
2339 if (fdc->dma_overruns++ < FDC_DMAOV_MAX) {
2340 fdc->state = SEEKCOMPLETE;
2341 return (1);/* will return immediately */
2342 } /* else fall through */
2343 }
2344 if((fdc->status[0] & NE7_ST0_IC) == NE7_ST0_IC_IV
2345 && fdc->retry < 6)
2346 fdc->retry = 6; /* force a reset */
2347 else if((fdc->status[0] & NE7_ST0_IC) == NE7_ST0_IC_AT
2348 && fdc->status[2] & NE7_ST2_WC
2349 && fdc->retry < 3)
2350 fdc->retry = 3; /* force recalibrate */
2351 return (retrier(fdc));
2352 }
2353 /* All OK */
2354 if (rdsectid) {
2355 /* copy out ID field contents */
2356 idp = (struct fdc_readid *)bp->bio_data;
2357 idp->cyl = fdc->status[3];
2358 idp->head = fdc->status[4];
2359 idp->sec = fdc->status[5];
2360 idp->secshift = fdc->status[6];
2361 }
2362 /* Operation successful, retry DMA overruns again next time. */
2363 fdc->dma_overruns = 0;
2364 fd->skip += fdblk;
2365 if (!rdsectid && !format && fd->skip < bp->bio_bcount) {
2366 /* set up next transfer */
2367 fdc->state = DOSEEK;
2368 } else {
2369 /* ALL DONE */
2370 fd->skip = 0;
2371 bp->bio_resid = 0;
2372 fdc->bp = NULL;
2373 device_unbusy(fd->dev);
2374 biofinish(bp, fd->device_stats, 0);
2375 fdc->fd = (fd_p) 0;
2376 fdc->fdu = -1;
2377 fdc->state = FINDWORK;
2378 }
2379 return (1); /* will return immediately */
2380
2381 case RESETCTLR:
2382 fdc_reset(fdc);
2383 fdc->retry++;
2384 fdc->state = RESETCOMPLETE;
2385 return (0); /* will return later */
2386
2387 case RESETCOMPLETE:
2388 /*
2389 * Discard all the results from the reset so that they
2390 * can't cause an unexpected interrupt later.
2391 */
2392 for (i = 0; i < 4; i++)
2393 (void)fd_sense_int(fdc, &st0, &cyl);
2394 fdc->state = STARTRECAL;
2395 /* FALLTHROUGH */
2396 case STARTRECAL:
2397#ifdef PC98
2398 pc98_fd_check_ready(fdu);
2399#endif
2400 if(fd_cmd(fdc, 2, NE7CMD_RECAL, fdu, 0)) {
2401 /* arrgl */
2402 fdc->retry = 6;
2403 return (retrier(fdc));
2404 }
2405 fdc->state = RECALWAIT;
2406 return (0); /* will return later */
2407
2408 case RECALWAIT:
2409 /* allow heads to settle */
2410 timeout(fd_pseudointr, fdc, hz / 8);
2411 fdc->state = RECALCOMPLETE;
2412 return (0); /* will return later */
2413
2414 case RECALCOMPLETE:
2415 do {
2416 /*
2417 * See SEEKCOMPLETE for a comment on this:
2418 */
2419 if (fd_sense_int(fdc, &st0, &cyl) == FD_NOT_VALID)
2420 return (0); /* will return later */
2421 if(fdc->fdct == FDC_NE765
2422 && (st0 & NE7_ST0_IC) == NE7_ST0_IC_RC)
2423 return (0); /* hope for a real intr */
2424 } while ((st0 & NE7_ST0_IC) == NE7_ST0_IC_RC);
2425#ifdef EPSON_NRDISK
2426 if (fdu == nrdu) {
2427 st0 = NE7_ST0_IC_NT;
2428 cyl = 0;
2429 }
2430#endif
2431 if ((st0 & NE7_ST0_IC) != NE7_ST0_IC_NT || cyl != 0)
2432 {
2433 if(fdc->retry > 3)
2434 /*
2435 * A recalibrate from beyond cylinder 77
2436 * will "fail" due to the FDC limitations;
2437 * since people used to complain much about
2438 * the failure message, try not logging
2439 * this one if it seems to be the first
2440 * time in a line.
2441 */
2442 printf("fd%d: recal failed ST0 %b cyl %d\n",
2443 fdu, st0, NE7_ST0BITS, cyl);
2444 if(fdc->retry < 3) fdc->retry = 3;
2445 return (retrier(fdc));
2446 }
2447 fd->track = 0;
2448 /* Seek (probably) necessary */
2449 fdc->state = DOSEEK;
2450 return (1); /* will return immediately */
2451
2452 case MOTORWAIT:
2453 if(fd->flags & FD_MOTOR_WAIT)
2454 {
2455 return (0); /* time's not up yet */
2456 }
2457 if (fdc->flags & FDC_NEEDS_RESET) {
2458 fdc->state = RESETCTLR;
2459 fdc->flags &= ~FDC_NEEDS_RESET;
2460 } else
2461 fdc->state = DOSEEK;
2462 return (1); /* will return immediately */
2463
2464 default:
2465 device_printf(fdc->fdc_dev, "unexpected FD int->");
2466 if (fd_read_status(fdc) == 0)
2467 printf("FDC status :%x %x %x %x %x %x %x ",
2468 fdc->status[0],
2469 fdc->status[1],
2470 fdc->status[2],
2471 fdc->status[3],
2472 fdc->status[4],
2473 fdc->status[5],
2474 fdc->status[6] );
2475 else
2476 printf("No status available ");
2477 if (fd_sense_int(fdc, &st0, &cyl) != 0)
2478 {
2479 printf("[controller is dead now]\n");
2480 return (0); /* will return later */
2481 }
2482 printf("ST0 = %x, PCN = %x\n", st0, cyl);
2483 return (0); /* will return later */
2484 }
2485 /* noone should ever get here */
2486}
2487
2488static int
2489retrier(struct fdc_data *fdc)
2490{
2491 struct bio *bp;
2492 struct fd_data *fd;
2493 int fdu;
2494
2495 bp = fdc->bp;
2496
2497 /* XXX shouldn't this be cached somewhere? */
2498 fd = bp->bio_dev->si_drv1;
2499 fdu = fd->fdu;
2500 if (fd->options & FDOPT_NORETRY)
2501 goto fail;
2502
2503 switch (fdc->retry) {
2504 case 0: case 1: case 2:
2505 fdc->state = SEEKCOMPLETE;
2506 break;
2507 case 3: case 4: case 5:
2508 fdc->state = STARTRECAL;
2509 break;
2510 case 6:
2511 fdc->state = RESETCTLR;
2512 break;
2513 case 7:
2514 break;
2515 default:
2516 fail:
2517 if ((fd->options & FDOPT_NOERRLOG) == 0) {
2518 disk_err(bp, "hard error",
2519 fdc->fd->skip / DEV_BSIZE, 0);
2520 if (fdc->flags & FDC_STAT_VALID) {
2521 printf(
2522 " (ST0 %b ST1 %b ST2 %b cyl %u hd %u sec %u)\n",
2523 fdc->status[0], NE7_ST0BITS,
2524 fdc->status[1], NE7_ST1BITS,
2525 fdc->status[2], NE7_ST2BITS,
2526 fdc->status[3], fdc->status[4],
2527 fdc->status[5]);
2528 }
2529 else
2530 printf(" (No status)\n");
2531 }
2532 if ((fd->options & FDOPT_NOERROR) == 0) {
2533 bp->bio_flags |= BIO_ERROR;
2534 bp->bio_error = EIO;
2535 bp->bio_resid = bp->bio_bcount - fdc->fd->skip;
2536 } else
2537 bp->bio_resid = 0;
2538 fdc->bp = NULL;
2539 fdc->fd->skip = 0;
2540 device_unbusy(fd->dev);
2541 biofinish(bp, fdc->fd->device_stats, 0);
2542 fdc->state = FINDWORK;
2543 fdc->flags |= FDC_NEEDS_RESET;
2544 fdc->fd = (fd_p) 0;
2545 fdc->fdu = -1;
2546 return (1);
2547 }
2548 fdc->retry++;
2549 return (1);
2550}
2551
2552static void
2553fdbiodone(struct bio *bp)
2554{
2555 wakeup(bp);
2556}
2557
2558static int
2559fdmisccmd(struct cdev *dev, u_int cmd, void *data)
2560{
2561 fdu_t fdu;
2562 fd_p fd;
2563 struct bio *bp;
2564 struct fd_formb *finfo;
2565 struct fdc_readid *idfield;
2566 size_t fdblk;
2567 int error;
2568
2569 fd = dev->si_drv1;
2570 fdu = fd->fdu;
2571 fdblk = 128 << fd->ft->secsize;
2572 finfo = (struct fd_formb *)data;
2573 idfield = (struct fdc_readid *)data;
2574
2575 bp = malloc(sizeof(struct bio), M_TEMP, M_WAITOK | M_ZERO);
2576
2577 /*
2578 * Set up a bio request for fdstrategy(). bio_offset is faked
2579 * so that fdstrategy() will seek to the the requested
2580 * cylinder, and use the desired head.
2581 */
2582 bp->bio_cmd = cmd;
2583 if (cmd == FDBIO_FORMAT) {
2584 bp->bio_offset =
2585 (finfo->cyl * (fd->ft->sectrac * fd->ft->heads) +
2586 finfo->head * fd->ft->sectrac) * fdblk;
2587 bp->bio_bcount = sizeof(struct fd_idfield_data) *
2588 finfo->fd_formb_nsecs;
2589 } else if (cmd == FDBIO_RDSECTID) {
2590 bp->bio_offset =
2591 (idfield->cyl * (fd->ft->sectrac * fd->ft->heads) +
2592 idfield->head * fd->ft->sectrac) * fdblk;
2593 bp->bio_bcount = sizeof(struct fdc_readid);
2594 } else
2595 panic("wrong cmd in fdmisccmd()");
2596 bp->bio_data = data;
2597 bp->bio_dev = dev;
2598 bp->bio_done = fdbiodone;
2599 bp->bio_flags = 0;
2600
2601 /* Now run the command. */
2602 fdstrategy(bp);
2603 error = biowait(bp, "fdcmd");
2604
2605 free(bp, M_TEMP);
2606 return (error);
2607}
2608
2609static int
2610fdioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
2611{
2612 fdu_t fdu;
2613 fd_p fd;
2614 struct fdc_status *fsp;
2615 struct fdc_readid *rid;
2616 int error;
2617
2618 fd = dev->si_drv1;
2619 fdu = fd->fdu;
2620
2621#ifdef PC98
2622 pc98_fd_check_ready(fdu);
2623#endif
2624
2625 /*
2626 * First, handle everything that could be done with
2627 * FD_NONBLOCK still being set.
2628 */
2629 switch (cmd) {
2630
2631 case DIOCGMEDIASIZE:
2632 if (fd->ft == 0)
2633 return ((fd->flags & FD_NONBLOCK) ? EAGAIN : ENXIO);
2634 *(off_t *)addr = (128 << (fd->ft->secsize)) * fd->ft->size;
2635 return (0);
2636
2637 case DIOCGSECTORSIZE:
2638 if (fd->ft == 0)
2639 return ((fd->flags & FD_NONBLOCK) ? EAGAIN : ENXIO);
2640 *(u_int *)addr = 128 << (fd->ft->secsize);
2641 return (0);
2642
2643 case FIONBIO:
2644 if (*(int *)addr != 0)
2645 fd->flags |= FD_NONBLOCK;
2646 else {
2647 if (fd->ft == 0) {
2648 /*
2649 * No drive type has been selected yet,
2650 * cannot turn FNONBLOCK off.
2651 */
2652 return (EINVAL);
2653 }
2654 fd->flags &= ~FD_NONBLOCK;
2655 }
2656 return (0);
2657
2658 case FIOASYNC:
2659 /* keep the generic fcntl() code happy */
2660 return (0);
2661
2662 case FD_GTYPE: /* get drive type */
2663 if (fd->ft == 0)
2664 /* no type known yet, return the native type */
2665 *(struct fd_type *)addr = fd_native_types[fd->type];
2666 else
2667 *(struct fd_type *)addr = *fd->ft;
2668 return (0);
2669
2670 case FD_STYPE: /* set drive type */
2671 /*
2672 * Allow setting drive type temporarily iff
2673 * currently unset. Used for fdformat so any
2674 * user can set it, and then start formatting.
2675 */
2676 if (fd->ft)
2677 return (EINVAL); /* already set */
2678 fd->fts[0] = *(struct fd_type *)addr;
2679 fd->ft = &fd->fts[0];
2680 fd->flags |= FD_UA;
2681 return (0);
2682
2683 case FD_GOPTS: /* get drive options */
2684 *(int *)addr = fd->options + FDOPT_AUTOSEL;
2685 return (0);
2686
2687 case FD_SOPTS: /* set drive options */
2688 fd->options = *(int *)addr & ~FDOPT_AUTOSEL;
2689 return (0);
2690
2691#ifdef FDC_DEBUG
2692 case FD_DEBUG:
2693 if ((fd_debug != 0) != (*(int *)addr != 0)) {
2694 fd_debug = (*(int *)addr != 0);
2695 printf("fd%d: debugging turned %s\n",
2696 fd->fdu, fd_debug ? "on" : "off");
2697 }
2698 return (0);
2699#endif
2700
2701 case FD_CLRERR:
2702 if (suser(td) != 0)
2703 return (EPERM);
2704 fd->fdc->fdc_errs = 0;
2705 return (0);
2706
2707 case FD_GSTAT:
2708 fsp = (struct fdc_status *)addr;
2709 if ((fd->fdc->flags & FDC_STAT_VALID) == 0)
2710 return (EINVAL);
2711 memcpy(fsp->status, fd->fdc->status, 7 * sizeof(u_int));
2712 return (0);
2713
2714 case FD_GDTYPE:
2715 *(enum fd_drivetype *)addr = fd->type;
2716 return (0);
2717 }
2718
2719 /*
2720 * Now handle everything else. Make sure we have a valid
2721 * drive type.
2722 */
2723 if (fd->flags & FD_NONBLOCK)
2724 return (EAGAIN);
2725 if (fd->ft == 0)
2726 return (ENXIO);
2727 error = 0;
2728
2729 switch (cmd) {
2730
2731 case FD_FORM:
2732 if ((flag & FWRITE) == 0)
2733 return (EBADF); /* must be opened for writing */
2734 if (((struct fd_formb *)addr)->format_version !=
2735 FD_FORMAT_VERSION)
2736 return (EINVAL); /* wrong version of formatting prog */
2737 error = fdmisccmd(dev, FDBIO_FORMAT, addr);
2738 break;
2739
2740 case FD_GTYPE: /* get drive type */
2741 *(struct fd_type *)addr = *fd->ft;
2742 break;
2743
2744 case FD_STYPE: /* set drive type */
2745 /* this is considered harmful; only allow for superuser */
2746 if (suser(td) != 0)
2747 return (EPERM);
2748 *fd->ft = *(struct fd_type *)addr;
2749 break;
2750
2751 case FD_GOPTS: /* get drive options */
2752 *(int *)addr = fd->options;
2753 break;
2754
2755 case FD_SOPTS: /* set drive options */
2756 fd->options = *(int *)addr;
2757 break;
2758
2759#ifdef FDC_DEBUG
2760 case FD_DEBUG:
2761 if ((fd_debug != 0) != (*(int *)addr != 0)) {
2762 fd_debug = (*(int *)addr != 0);
2763 printf("fd%d: debugging turned %s\n",
2764 fd->fdu, fd_debug ? "on" : "off");
2765 }
2766 break;
2767#endif
2768
2769 case FD_CLRERR:
2770 if (suser(td) != 0)
2771 return (EPERM);
2772 fd->fdc->fdc_errs = 0;
2773 break;
2774
2775 case FD_GSTAT:
2776 fsp = (struct fdc_status *)addr;
2777 if ((fd->fdc->flags & FDC_STAT_VALID) == 0)
2778 return (EINVAL);
2779 memcpy(fsp->status, fd->fdc->status, 7 * sizeof(u_int));
2780 break;
2781
2782 case FD_READID:
2783 rid = (struct fdc_readid *)addr;
2784 if (rid->cyl > MAX_CYLINDER || rid->head > MAX_HEAD)
2785 return (EINVAL);
2786 error = fdmisccmd(dev, FDBIO_RDSECTID, addr);
2787 break;
2788
2789 default:
2790 error = ENOTTY;
2791 break;
2792 }
2793 return (error);
2794}
| 1118 if ((fdc->flags & FDC_HAS_FIFO) == 0 &&
1119 fdc->fdct == FDC_ENHANCED &&
1120 (device_get_flags(fdc->fdc_dev) & FDC_NO_FIFO) == 0 &&
1121 enable_fifo(fdc) == 0) {
1122 device_printf(device_get_parent(dev),
1123 "FIFO enabled, %d bytes threshold\n", fifo_threshold);
1124 }
1125#endif /* PC98 */
1126
1127#ifdef PC98
1128 switch (fd->type) {
1129 case FDT_144M:
1130 device_set_desc(dev, "1.44M FDD");
1131 break;
1132 case FDT_12M:
1133#ifdef EPSON_NRDISK
1134 if (fd->fdu == nrdu) {
1135 device_set_desc(dev, "EPSON RAM DRIVE");
1136 nrd_LED_off();
1137 } else
1138 device_set_desc(dev, "1M/640K FDD");
1139#else
1140 device_set_desc(dev, "1M/640K FDD");
1141#endif
1142 break;
1143 default:
1144 return (ENXIO);
1145 }
1146#else
1147 switch (fd->type) {
1148 case FDT_12M:
1149 device_set_desc(dev, "1200-KB 5.25\" drive");
1150 break;
1151 case FDT_144M:
1152 device_set_desc(dev, "1440-KB 3.5\" drive");
1153 break;
1154 case FDT_288M:
1155 device_set_desc(dev, "2880-KB 3.5\" drive (in 1440-KB mode)");
1156 break;
1157 case FDT_360K:
1158 device_set_desc(dev, "360-KB 5.25\" drive");
1159 break;
1160 case FDT_720K:
1161 device_set_desc(dev, "720-KB 3.5\" drive");
1162 break;
1163 default:
1164 return (ENXIO);
1165 }
1166#endif
1167 fd->track = FD_NO_TRACK;
1168 fd->fdc = fdc;
1169 fd->fdsu = fdsu;
1170 fd->options = 0;
1171#ifdef PC98
1172 fd->pc98_trans = 0;
1173#endif
1174 callout_handle_init(&fd->toffhandle);
1175 callout_handle_init(&fd->tohandle);
1176
1177 /* initialize densities for subdevices */
1178#ifdef PC98
1179 for (i = 0; i < NUMDENS; i++)
1180 memcpy(fd->fts + i, fd_searchlist_144m + i,
1181 sizeof(struct fd_type));
1182#else
1183 for (i = 0; i < NUMDENS; i++)
1184 memcpy(fd->fts + i, fd_native_types + fd->type,
1185 sizeof(struct fd_type));
1186#endif
1187 return (0);
1188}
1189
1190static int
1191fd_attach(device_t dev)
1192{
1193 struct fd_data *fd;
1194
1195 fd = device_get_softc(dev);
1196 fd->masterdev = make_dev(&fd_cdevsw, fd->fdu,
1197 UID_ROOT, GID_OPERATOR, 0640, "fd%d", fd->fdu);
1198 fd->masterdev->si_drv1 = fd;
1199 fd->device_stats = devstat_new_entry(device_get_name(dev),
1200 device_get_unit(dev), 0, DEVSTAT_NO_ORDERED_TAGS,
1201 DEVSTAT_TYPE_FLOPPY | DEVSTAT_TYPE_IF_OTHER,
1202 DEVSTAT_PRIORITY_FD);
1203 return (0);
1204}
1205
1206static int
1207fd_detach(device_t dev)
1208{
1209 struct fd_data *fd;
1210
1211 fd = device_get_softc(dev);
1212 untimeout(fd_turnoff, fd, fd->toffhandle);
1213 devstat_remove_entry(fd->device_stats);
1214 destroy_dev(fd->masterdev);
1215
1216 return (0);
1217}
1218
1219static device_method_t fd_methods[] = {
1220 /* Device interface */
1221 DEVMETHOD(device_probe, fd_probe),
1222 DEVMETHOD(device_attach, fd_attach),
1223 DEVMETHOD(device_detach, fd_detach),
1224 DEVMETHOD(device_shutdown, bus_generic_shutdown),
1225 DEVMETHOD(device_suspend, bus_generic_suspend), /* XXX */
1226 DEVMETHOD(device_resume, bus_generic_resume), /* XXX */
1227
1228 { 0, 0 }
1229};
1230
1231static driver_t fd_driver = {
1232 "fd",
1233 fd_methods,
1234 sizeof(struct fd_data)
1235};
1236
1237DRIVER_MODULE(fd, fdc, fd_driver, fd_devclass, 0, 0);
1238
1239/*
1240 * More auxiliary functions.
1241 */
1242/*
1243 * Motor control stuff.
1244 * Remember to not deselect the drive we're working on.
1245 */
1246static void
1247set_motor(struct fdc_data *fdc, int fdsu, int turnon)
1248{
1249#ifdef PC98
1250 bus_space_write_1(fdc->sc_fdsiot, fdc->sc_fdsioh, 0,
1251 (pc98_trans != 1 ? FDP_FDDEXC : 0) | FDP_PORTEXC);
1252 DELAY(10);
1253 fdctl_wr(fdc, FDC_DMAE | FDC_MTON);
1254#else
1255 int fdout;
1256
1257 fdout = fdc->fdout;
1258 if (turnon) {
1259 fdout &= ~FDO_FDSEL;
1260 fdout |= (FDO_MOEN0 << fdsu) | FDO_FDMAEN | FDO_FRST | fdsu;
1261 } else
1262 fdout &= ~(FDO_MOEN0 << fdsu);
1263 fdc->fdout = fdout;
1264 fdout_wr(fdc, fdout);
1265 TRACE1("[0x%x->FDOUT]", fdout);
1266#endif
1267}
1268
1269static void
1270fd_turnoff(void *xfd)
1271{
1272 int s;
1273 fd_p fd = xfd;
1274
1275 TRACE1("[fd%d: turnoff]", fd->fdu);
1276
1277 s = splbio();
1278 /*
1279 * Don't turn off the motor yet if the drive is active.
1280 *
1281 * If we got here, this could only mean we missed an interrupt.
1282 * This can e. g. happen on the Y-E Date PCMCIA floppy controller
1283 * after a controller reset. Just schedule a pseudo-interrupt
1284 * so the state machine gets re-entered.
1285 */
1286 if (fd->fdc->state != DEVIDLE && fd->fdc->fdu == fd->fdu) {
1287 fdc_intr(fd->fdc);
1288 splx(s);
1289 return;
1290 }
1291
1292 fd->flags &= ~FD_MOTOR;
1293 set_motor(fd->fdc, fd->fdsu, TURNOFF);
1294 splx(s);
1295}
1296
1297static void
1298fd_motor_on(void *xfd)
1299{
1300 int s;
1301 fd_p fd = xfd;
1302
1303 s = splbio();
1304 fd->flags &= ~FD_MOTOR_WAIT;
1305 if((fd->fdc->fd == fd) && (fd->fdc->state == MOTORWAIT))
1306 {
1307 fdc_intr(fd->fdc);
1308 }
1309 splx(s);
1310}
1311
1312static void
1313fd_turnon(fd_p fd)
1314{
1315 if(!(fd->flags & FD_MOTOR))
1316 {
1317 fd->flags |= (FD_MOTOR + FD_MOTOR_WAIT);
1318 set_motor(fd->fdc, fd->fdsu, TURNON);
1319 timeout(fd_motor_on, fd, hz); /* in 1 sec its ok */
1320 }
1321}
1322
1323static void
1324fdc_reset(fdc_p fdc)
1325{
1326 /* Try a reset, keep motor on */
1327#ifdef PC98
1328 set_density(fdc);
1329 if (pc98_machine_type & M_EPSON_PC98)
1330 fdctl_wr(fdc, FDC_RST | FDC_RDY | FDC_DD | FDC_MTON);
1331 else
1332 fdctl_wr(fdc, FDC_RST | FDC_RDY | FDC_DMAE | FDC_MTON);
1333 DELAY(200);
1334 fdctl_wr(fdc, FDC_DMAE | FDC_MTON);
1335 DELAY(10);
1336#else
1337 fdout_wr(fdc, fdc->fdout & ~(FDO_FRST|FDO_FDMAEN));
1338 TRACE1("[0x%x->FDOUT]", fdc->fdout & ~(FDO_FRST|FDO_FDMAEN));
1339 DELAY(100);
1340 /* enable FDC, but defer interrupts a moment */
1341 fdout_wr(fdc, fdc->fdout & ~FDO_FDMAEN);
1342 TRACE1("[0x%x->FDOUT]", fdc->fdout & ~FDO_FDMAEN);
1343 DELAY(100);
1344 fdout_wr(fdc, fdc->fdout);
1345 TRACE1("[0x%x->FDOUT]", fdc->fdout);
1346#endif
1347
1348 /* XXX after a reset, silently believe the FDC will accept commands */
1349#ifdef PC98
1350 (void)fd_cmd(fdc, 3, NE7CMD_SPECIFY,
1351 NE7_SPEC_1(4, 240), NE7_SPEC_2(2, 0),
1352 0);
1353#else
1354 (void)fd_cmd(fdc, 3, NE7CMD_SPECIFY,
1355 NE7_SPEC_1(3, 240), NE7_SPEC_2(2, 0),
1356 0);
1357#endif
1358 if (fdc->flags & FDC_HAS_FIFO)
1359 (void) enable_fifo(fdc);
1360}
1361
1362/*
1363 * FDC IO functions, take care of the main status register, timeout
1364 * in case the desired status bits are never set.
1365 *
1366 * These PIO loops initially start out with short delays between
1367 * each iteration in the expectation that the required condition
1368 * is usually met quickly, so it can be handled immediately. After
1369 * about 1 ms, stepping is increased to achieve a better timing
1370 * accuracy in the calls to DELAY().
1371 */
1372static int
1373fd_in(struct fdc_data *fdc, int *ptr)
1374{
1375 int i, j, step;
1376
1377 for (j = 0, step = 1;
1378 (i = fdsts_rd(fdc) & (NE7_DIO|NE7_RQM)) != (NE7_DIO|NE7_RQM) &&
1379 j < FDSTS_TIMEOUT;
1380 j += step) {
1381 if (i == NE7_RQM)
1382 return (fdc_err(fdc, "ready for output in input\n"));
1383 if (j == 1000)
1384 step = 1000;
1385 DELAY(step);
1386 }
1387 if (j >= FDSTS_TIMEOUT)
1388 return (fdc_err(fdc, bootverbose? "input ready timeout\n": 0));
1389#ifdef FDC_DEBUG
1390 i = fddata_rd(fdc);
1391 TRACE1("[FDDATA->0x%x]", (unsigned char)i);
1392 *ptr = i;
1393 return (0);
1394#else /* !FDC_DEBUG */
1395 i = fddata_rd(fdc);
1396 if (ptr)
1397 *ptr = i;
1398 return (0);
1399#endif /* FDC_DEBUG */
1400}
1401
1402static int
1403out_fdc(struct fdc_data *fdc, int x)
1404{
1405 int i, j, step;
1406
1407 for (j = 0, step = 1;
1408 (i = fdsts_rd(fdc) & (NE7_DIO|NE7_RQM)) != NE7_RQM &&
1409 j < FDSTS_TIMEOUT;
1410 j += step) {
1411 if (i == (NE7_DIO|NE7_RQM))
1412 return (fdc_err(fdc, "ready for input in output\n"));
1413 if (j == 1000)
1414 step = 1000;
1415 DELAY(step);
1416 }
1417 if (j >= FDSTS_TIMEOUT)
1418 return (fdc_err(fdc, bootverbose? "output ready timeout\n": 0));
1419
1420 /* Send the command and return */
1421 fddata_wr(fdc, x);
1422 TRACE1("[0x%x->FDDATA]", x);
1423 return (0);
1424}
1425
1426/*
1427 * Block device driver interface functions (interspersed with even more
1428 * auxiliary functions).
1429 */
1430static int
1431fdopen(struct cdev *dev, int flags, int mode, struct thread *td)
1432{
1433 fd_p fd;
1434 fdc_p fdc;
1435#ifdef PC98
1436 fdu_t fdu;
1437#endif
1438 int rv, unitattn, dflags;
1439
1440 fd = dev->si_drv1;
1441 if (fd == NULL)
1442 return (ENXIO);
1443 fdc = fd->fdc;
1444 if ((fdc == NULL) || (fd->type == FDT_NONE))
1445 return (ENXIO);
1446#ifdef PC98
1447 fdu = fd->fdu;
1448#endif
1449 dflags = device_get_flags(fd->dev);
1450 /*
1451 * This is a bit bogus. It's still possible that e. g. a
1452 * descriptor gets inherited to a child, but then it's at
1453 * least for the same subdevice. By checking FD_OPEN here, we
1454 * can ensure that a device isn't attempted to be opened with
1455 * different densities at the same time where the second open
1456 * could clobber the settings from the first one.
1457 */
1458 if (fd->flags & FD_OPEN)
1459 return (EBUSY);
1460
1461#ifdef PC98
1462 if (pc98_fd_check_ready(fdu) == -1)
1463 return(EIO);
1464#endif
1465
1466 if (flags & FNONBLOCK) {
1467 /*
1468 * Unfortunately, physio(9) discards its ioflag
1469 * argument, thus preventing us from seeing the
1470 * IO_NDELAY bit. So we need to keep track
1471 * ourselves.
1472 */
1473 fd->flags |= FD_NONBLOCK;
1474 fd->ft = 0;
1475 } else {
1476 /*
1477 * Figure out a unit attention condition.
1478 *
1479 * If UA has been forced, proceed.
1480 *
1481 * If the drive has no changeline support,
1482 * or if the drive parameters have been lost
1483 * due to previous non-blocking access,
1484 * assume a forced UA condition.
1485 *
1486 * If motor is off, turn it on for a moment
1487 * and select our drive, in order to read the
1488 * UA hardware signal.
1489 *
1490 * If motor is on, and our drive is currently
1491 * selected, just read the hardware bit.
1492 *
1493 * If motor is on, but active for another
1494 * drive on that controller, we are lost. We
1495 * cannot risk to deselect the other drive, so
1496 * we just assume a forced UA condition to be
1497 * on the safe side.
1498 */
1499 unitattn = 0;
1500 if ((dflags & FD_NO_CHLINE) != 0 ||
1501 (fd->flags & FD_UA) != 0 ||
1502 fd->ft == 0) {
1503 unitattn = 1;
1504 fd->flags &= ~FD_UA;
1505#ifndef PC98
1506 } else if (fdc->fdout & (FDO_MOEN0 | FDO_MOEN1 |
1507 FDO_MOEN2 | FDO_MOEN3)) {
1508 if ((fdc->fdout & FDO_FDSEL) == fd->fdsu)
1509 unitattn = fdin_rd(fdc) & FDI_DCHG;
1510 else
1511 unitattn = 1;
1512 } else {
1513 set_motor(fdc, fd->fdsu, TURNON);
1514 unitattn = fdin_rd(fdc) & FDI_DCHG;
1515 set_motor(fdc, fd->fdsu, TURNOFF);
1516#endif /* PC98 */
1517 }
1518 if (unitattn && (rv = fdautoselect(dev)) != 0)
1519 return (rv);
1520 }
1521 fd->flags |= FD_OPEN;
1522
1523 if ((fdc->flags & FDC_NODMA) == 0) {
1524 if (fdc->dmacnt++ == 0) {
1525 isa_dma_acquire(fdc->dmachan);
1526 isa_dmainit(fdc->dmachan, MAX_SEC_SIZE);
1527 }
1528 }
1529
1530 /*
1531 * Clearing the DMA overrun counter at open time is a bit messy.
1532 * Since we're only managing one counter per controller, opening
1533 * the second drive could mess it up. Anyway, if the DMA overrun
1534 * condition is really persistent, it will eventually time out
1535 * still. OTOH, clearing it here will ensure we'll at least start
1536 * trying again after a previous (maybe even long ago) failure.
1537 * Also, this is merely a stop-gap measure only that should not
1538 * happen during normal operation, so we can tolerate it to be a
1539 * bit sloppy about this.
1540 */
1541 fdc->dma_overruns = 0;
1542
1543 return 0;
1544}
1545
1546static int
1547fdclose(struct cdev *dev, int flags, int mode, struct thread *td)
1548{
1549 struct fd_data *fd;
1550 fdc_p fdc;
1551
1552 fd = dev->si_drv1;
1553 fdc = fd->fdc;
1554 fd->flags &= ~(FD_OPEN | FD_NONBLOCK);
1555 fd->options &= ~(FDOPT_NORETRY | FDOPT_NOERRLOG | FDOPT_NOERROR);
1556
1557 if ((fdc->flags & FDC_NODMA) == 0)
1558 if (--fdc->dmacnt == 0)
1559 isa_dma_release(fdc->dmachan);
1560
1561 return (0);
1562}
1563
1564static void
1565fdstrategy(struct bio *bp)
1566{
1567 long blknum, nblocks;
1568 int s;
1569 fdu_t fdu;
1570 fdc_p fdc;
1571 fd_p fd;
1572 size_t fdblk;
1573
1574 fd = bp->bio_dev->si_drv1;
1575 fdu = fd->fdu;
1576 fdc = fd->fdc;
1577 bp->bio_resid = bp->bio_bcount;
1578 if (fd->type == FDT_NONE || fd->ft == 0) {
1579 if (fd->type != FDT_NONE && (fd->flags & FD_NONBLOCK))
1580 bp->bio_error = EAGAIN;
1581 else
1582 bp->bio_error = ENXIO;
1583 bp->bio_flags |= BIO_ERROR;
1584 goto bad;
1585 }
1586 fdblk = 128 << (fd->ft->secsize);
1587 if (bp->bio_cmd != FDBIO_FORMAT && bp->bio_cmd != FDBIO_RDSECTID) {
1588 if (fd->flags & FD_NONBLOCK) {
1589 bp->bio_error = EAGAIN;
1590 bp->bio_flags |= BIO_ERROR;
1591 goto bad;
1592 }
1593 if (bp->bio_offset < 0) {
1594 printf(
1595 "fd%d: fdstrat: bad request offset = %ju, bcount = %ld\n",
1596 fdu, (intmax_t)bp->bio_offset, bp->bio_bcount);
1597 bp->bio_error = EINVAL;
1598 bp->bio_flags |= BIO_ERROR;
1599 goto bad;
1600 }
1601 if ((bp->bio_bcount % fdblk) != 0) {
1602 bp->bio_error = EINVAL;
1603 bp->bio_flags |= BIO_ERROR;
1604 goto bad;
1605 }
1606 }
1607
1608 /*
1609 * Set up block calculations.
1610 */
1611#ifndef PC98
1612 if (bp->bio_offset >= ((off_t)128 << fd->ft->secsize) * fd->ft->size) {
1613 bp->bio_error = EINVAL;
1614 bp->bio_flags |= BIO_ERROR;
1615 goto bad;
1616 }
1617#endif
1618 blknum = bp->bio_offset / fdblk;
1619 nblocks = fd->ft->size;
1620 if (blknum + bp->bio_bcount / fdblk > nblocks) {
1621 if (blknum >= nblocks) {
1622 if (bp->bio_cmd != BIO_READ) {
1623 bp->bio_error = ENOSPC;
1624 bp->bio_flags |= BIO_ERROR;
1625 }
1626 goto bad; /* not always bad, but EOF */
1627 }
1628 bp->bio_bcount = (nblocks - blknum) * fdblk;
1629 }
1630 bp->bio_pblkno = blknum;
1631 s = splbio();
1632 bioq_disksort(&fdc->head, bp);
1633 untimeout(fd_turnoff, fd, fd->toffhandle); /* a good idea */
1634 devstat_start_transaction_bio(fd->device_stats, bp);
1635 device_busy(fd->dev);
1636 fdstart(fdc);
1637 splx(s);
1638 return;
1639
1640bad:
1641 biodone(bp);
1642}
1643
1644/*
1645 * fdstart
1646 *
1647 * We have just queued something. If the controller is not busy
1648 * then simulate the case where it has just finished a command
1649 * So that it (the interrupt routine) looks on the queue for more
1650 * work to do and picks up what we just added.
1651 *
1652 * If the controller is already busy, we need do nothing, as it
1653 * will pick up our work when the present work completes.
1654 */
1655static void
1656fdstart(struct fdc_data *fdc)
1657{
1658 int s;
1659
1660 s = splbio();
1661 if(fdc->state == DEVIDLE)
1662 {
1663 fdc_intr(fdc);
1664 }
1665 splx(s);
1666}
1667
1668static void
1669fd_iotimeout(void *xfdc)
1670{
1671 fdc_p fdc;
1672 int s;
1673
1674 fdc = xfdc;
1675 TRACE1("fd%d[fd_iotimeout()]", fdc->fdu);
1676
1677 /*
1678 * Due to IBM's brain-dead design, the FDC has a faked ready
1679 * signal, hardwired to ready == true. Thus, any command
1680 * issued if there's no diskette in the drive will _never_
1681 * complete, and must be aborted by resetting the FDC.
1682 * Many thanks, Big Blue!
1683 * The FDC must not be reset directly, since that would
1684 * interfere with the state machine. Instead, pretend that
1685 * the command completed but was invalid. The state machine
1686 * will reset the FDC and retry once.
1687 */
1688 s = splbio();
1689 fdc->status[0] = NE7_ST0_IC_IV;
1690 fdc->flags &= ~FDC_STAT_VALID;
1691 fdc->state = IOTIMEDOUT;
1692 fdc_intr(fdc);
1693 splx(s);
1694}
1695
1696/* Just ensure it has the right spl. */
1697static void
1698fd_pseudointr(void *xfdc)
1699{
1700 int s;
1701
1702 s = splbio();
1703 fdc_intr(xfdc);
1704 splx(s);
1705}
1706
1707/*
1708 * fdc_intr
1709 *
1710 * Keep calling the state machine until it returns a 0.
1711 * Always called at splbio.
1712 */
1713static void
1714fdc_intr(void *xfdc)
1715{
1716 fdc_p fdc = xfdc;
1717 while(fdstate(fdc))
1718 ;
1719}
1720
1721/*
1722 * Magic pseudo-DMA initialization for YE FDC. Sets count and
1723 * direction.
1724 */
1725#define SET_BCDR(fdc,wr,cnt,port) \
1726 bus_space_write_1(fdc->portt, fdc->porth, fdc->port_off + port, \
1727 ((cnt)-1) & 0xff); \
1728 bus_space_write_1(fdc->portt, fdc->porth, fdc->port_off + port + 1, \
1729 ((wr ? 0x80 : 0) | ((((cnt)-1) >> 8) & 0x7f)));
1730
1731/*
1732 * fdcpio(): perform programmed IO read/write for YE PCMCIA floppy.
1733 */
1734static int
1735fdcpio(fdc_p fdc, long flags, caddr_t addr, u_int count)
1736{
1737 u_char *cptr = (u_char *)addr;
1738
1739 if (flags == BIO_READ) {
1740 if (fdc->state != PIOREAD) {
1741 fdc->state = PIOREAD;
1742 return(0);
1743 }
1744 SET_BCDR(fdc, 0, count, 0);
1745 bus_space_read_multi_1(fdc->portt, fdc->porth, fdc->port_off +
1746 FDC_YE_DATAPORT, cptr, count);
1747 } else {
1748 bus_space_write_multi_1(fdc->portt, fdc->porth, fdc->port_off +
1749 FDC_YE_DATAPORT, cptr, count);
1750 SET_BCDR(fdc, 0, count, 0);
1751 }
1752 return(1);
1753}
1754
1755/*
1756 * Try figuring out the density of the media present in our device.
1757 */
1758static int
1759fdautoselect(struct cdev *dev)
1760{
1761 fd_p fd;
1762 struct fd_type *fdtp;
1763 struct fdc_readid id;
1764 int i, n, oopts, rv;
1765
1766 fd = dev->si_drv1;
1767
1768 switch (fd->type) {
1769 default:
1770 return (ENXIO);
1771
1772#ifndef PC98
1773 case FDT_360K:
1774 case FDT_720K:
1775 /* no autoselection on those drives */
1776 fd->ft = fd_native_types + fd->type;
1777 return (0);
1778#endif
1779
1780 case FDT_12M:
1781 fdtp = fd_searchlist_12m;
1782 n = sizeof fd_searchlist_12m / sizeof(struct fd_type);
1783 break;
1784
1785 case FDT_144M:
1786 fdtp = fd_searchlist_144m;
1787 n = sizeof fd_searchlist_144m / sizeof(struct fd_type);
1788 break;
1789
1790#ifndef PC98
1791 case FDT_288M:
1792 fdtp = fd_searchlist_288m;
1793 n = sizeof fd_searchlist_288m / sizeof(struct fd_type);
1794 break;
1795#endif
1796 }
1797
1798 /*
1799 * Try reading sector ID fields, first at cylinder 0, head 0,
1800 * then at cylinder 2, head N. We don't probe cylinder 1,
1801 * since for 5.25in DD media in a HD drive, there are no data
1802 * to read (2 step pulses per media cylinder required). For
1803 * two-sided media, the second probe always goes to head 1, so
1804 * we can tell them apart from single-sided media. As a
1805 * side-effect this means that single-sided media should be
1806 * mentioned in the search list after two-sided media of an
1807 * otherwise identical density. Media with a different number
1808 * of sectors per track but otherwise identical parameters
1809 * cannot be distinguished at all.
1810 *
1811 * If we successfully read an ID field on both cylinders where
1812 * the recorded values match our expectation, we are done.
1813 * Otherwise, we try the next density entry from the table.
1814 *
1815 * Stepping to cylinder 2 has the side-effect of clearing the
1816 * unit attention bit.
1817 */
1818 oopts = fd->options;
1819 fd->options |= FDOPT_NOERRLOG | FDOPT_NORETRY;
1820 for (i = 0; i < n; i++, fdtp++) {
1821 fd->ft = fdtp;
1822
1823 id.cyl = id.head = 0;
1824 rv = fdmisccmd(dev, FDBIO_RDSECTID, &id);
1825 if (rv != 0)
1826 continue;
1827 if (id.cyl != 0 || id.head != 0 ||
1828 id.secshift != fdtp->secsize)
1829 continue;
1830 id.cyl = 2;
1831 id.head = fd->ft->heads - 1;
1832 rv = fdmisccmd(dev, FDBIO_RDSECTID, &id);
1833 if (id.cyl != 2 || id.head != fdtp->heads - 1 ||
1834 id.secshift != fdtp->secsize)
1835 continue;
1836 if (rv == 0)
1837 break;
1838 }
1839
1840 fd->options = oopts;
1841 if (i == n) {
1842 if (bootverbose)
1843 device_printf(fd->dev, "autoselection failed\n");
1844 fd->ft = 0;
1845 return (EIO);
1846 } else {
1847 if (bootverbose)
1848 device_printf(fd->dev, "autoselected %d KB medium\n",
1849#ifdef PC98
1850 (128 << (fd->ft->secsize)) *
1851 fd->ft->size / 1024);
1852#else
1853 fd->ft->size / 2);
1854#endif
1855 return (0);
1856 }
1857}
1858
1859
1860/*
1861 * The controller state machine.
1862 *
1863 * If it returns a non zero value, it should be called again immediately.
1864 */
1865static int
1866fdstate(fdc_p fdc)
1867{
1868 struct fdc_readid *idp;
1869 int read, format, rdsectid, cylinder, head, i, sec = 0, sectrac;
1870 int st0, cyl, st3, idf, ne7cmd, mfm, steptrac;
1871 unsigned long blknum;
1872 fdu_t fdu = fdc->fdu;
1873 fd_p fd;
1874 register struct bio *bp;
1875 struct fd_formb *finfo = NULL;
1876 size_t fdblk;
1877
1878 bp = fdc->bp;
1879 if (bp == NULL) {
1880 bp = bioq_first(&fdc->head);
1881 if (bp != NULL) {
1882 bioq_remove(&fdc->head, bp);
1883 fdc->bp = bp;
1884 }
1885 }
1886 if (bp == NULL) {
1887 /*
1888 * Nothing left for this controller to do,
1889 * force into the IDLE state.
1890 */
1891 fdc->state = DEVIDLE;
1892 if (fdc->fd) {
1893 device_printf(fdc->fdc_dev,
1894 "unexpected valid fd pointer\n");
1895 fdc->fd = (fd_p) 0;
1896 fdc->fdu = -1;
1897 }
1898 TRACE1("[fdc%d IDLE]", fdc->fdcu);
1899 return (0);
1900 }
1901 fd = bp->bio_dev->si_drv1;
1902 fdu = fd->fdu;
1903 fdblk = 128 << fd->ft->secsize;
1904 if (fdc->fd && (fd != fdc->fd))
1905 device_printf(fd->dev, "confused fd pointers\n");
1906 read = bp->bio_cmd == BIO_READ;
1907 mfm = (fd->ft->flags & FL_MFM)? NE7CMD_MFM: 0;
1908 steptrac = (fd->ft->flags & FL_2STEP)? 2: 1;
1909 if (read)
1910 idf = ISADMA_READ;
1911 else
1912 idf = ISADMA_WRITE;
1913 format = bp->bio_cmd == FDBIO_FORMAT;
1914 rdsectid = bp->bio_cmd == FDBIO_RDSECTID;
1915 if (format)
1916 finfo = (struct fd_formb *)bp->bio_data;
1917 TRACE1("fd%d", fdu);
1918 TRACE1("[%s]", fdstates[fdc->state]);
1919 TRACE1("(0x%x)", fd->flags);
1920 untimeout(fd_turnoff, fd, fd->toffhandle);
1921 fd->toffhandle = timeout(fd_turnoff, fd, 4 * hz);
1922 switch (fdc->state)
1923 {
1924 case DEVIDLE:
1925 case FINDWORK: /* we have found new work */
1926 fdc->retry = 0;
1927 fd->skip = 0;
1928 fdc->fd = fd;
1929 fdc->fdu = fdu;
1930#ifdef PC98
1931 pc98_trans = fd->ft->trans;
1932 if (pc98_trans_prev != pc98_trans) {
1933 int i;
1934 set_density(fdc);
1935 for (i = 0; i < 10; i++) {
1936 outb(0x5f, 0);
1937 outb(0x5f, 0);
1938 }
1939 pc98_trans_prev = pc98_trans;
1940 }
1941 if (pc98_trans != fd->pc98_trans) {
1942 if (fd->type == FDT_144M) {
1943 bus_space_write_1(fdc->sc_fdemsiot,
1944 fdc->sc_fdemsioh,
1945 0,
1946 (fdu << 5) | 0x10 |
1947 (pc98_trans >> 1));
1948 outb(0x5f, 0);
1949 outb(0x5f, 0);
1950 }
1951 fd->pc98_trans = pc98_trans;
1952 }
1953#else
1954 fdc->fdctl_wr(fdc, fd->ft->trans);
1955#endif
1956 TRACE1("[0x%x->FDCTL]", fd->ft->trans);
1957 /*
1958 * If the next drive has a motor startup pending, then
1959 * it will start up in its own good time.
1960 */
1961 if(fd->flags & FD_MOTOR_WAIT) {
1962 fdc->state = MOTORWAIT;
1963 return (0); /* will return later */
1964 }
1965 /*
1966 * Maybe if it's not starting, it SHOULD be starting.
1967 */
1968#ifdef EPSON_NRDISK
1969 if (fdu != nrdu) {
1970 if (!(fd->flags & FD_MOTOR))
1971 {
1972 fdc->state = MOTORWAIT;
1973 fd_turnon(fdu);
1974 return(0);
1975 }
1976 else /* at least make sure we are selected */
1977 {
1978 set_motor(fdcu, fd->fdsu, TURNON);
1979 }
1980 }
1981#else /* !EPSON_NRDISK */
1982 if (!(fd->flags & FD_MOTOR))
1983 {
1984 fdc->state = MOTORWAIT;
1985 fd_turnon(fd);
1986 return (0); /* will return later */
1987 }
1988 else /* at least make sure we are selected */
1989 {
1990 set_motor(fdc, fd->fdsu, TURNON);
1991 }
1992#endif
1993 if (fdc->flags & FDC_NEEDS_RESET) {
1994 fdc->state = RESETCTLR;
1995 fdc->flags &= ~FDC_NEEDS_RESET;
1996 } else
1997 fdc->state = DOSEEK;
1998 return (1); /* will return immediately */
1999
2000 case DOSEEK:
2001 blknum = bp->bio_pblkno + fd->skip / fdblk;
2002 cylinder = blknum / (fd->ft->sectrac * fd->ft->heads);
2003 if (cylinder == fd->track)
2004 {
2005 fdc->state = SEEKCOMPLETE;
2006 return (1); /* will return immediately */
2007 }
2008#ifdef PC98
2009 pc98_fd_check_ready(fdu);
2010#endif
2011 if (fd_cmd(fdc, 3, NE7CMD_SEEK,
2012 fd->fdsu, cylinder * steptrac, 0))
2013 {
2014 /*
2015 * Seek command not accepted, looks like
2016 * the FDC went off to the Saints...
2017 */
2018 fdc->retry = 6; /* try a reset */
2019 return(retrier(fdc));
2020 }
2021 fd->track = FD_NO_TRACK;
2022 fdc->state = SEEKWAIT;
2023 return(0); /* will return later */
2024
2025 case SEEKWAIT:
2026 /* allow heads to settle */
2027 timeout(fd_pseudointr, fdc, hz / 16);
2028 fdc->state = SEEKCOMPLETE;
2029 return(0); /* will return later */
2030
2031 case SEEKCOMPLETE : /* seek done, start DMA */
2032 blknum = bp->bio_pblkno + fd->skip / fdblk;
2033 cylinder = blknum / (fd->ft->sectrac * fd->ft->heads);
2034
2035 /* Make sure seek really happened. */
2036 if(fd->track == FD_NO_TRACK) {
2037 int descyl = cylinder * steptrac;
2038 do {
2039 /*
2040 * This might be a "ready changed" interrupt,
2041 * which cannot really happen since the
2042 * RDY pin is hardwired to + 5 volts. This
2043 * generally indicates a "bouncing" intr
2044 * line, so do one of the following:
2045 *
2046 * When running on an enhanced FDC that is
2047 * known to not go stuck after responding
2048 * with INVALID, fetch all interrupt states
2049 * until seeing either an INVALID or a
2050 * real interrupt condition.
2051 *
2052 * When running on a dumb old NE765, give
2053 * up immediately. The controller will
2054 * provide up to four dummy RC interrupt
2055 * conditions right after reset (for the
2056 * corresponding four drives), so this is
2057 * our only chance to get notice that it
2058 * was not the FDC that caused the interrupt.
2059 */
2060 if (fd_sense_int(fdc, &st0, &cyl)
2061 == FD_NOT_VALID)
2062 return (0); /* will return later */
2063 if(fdc->fdct == FDC_NE765
2064 && (st0 & NE7_ST0_IC) == NE7_ST0_IC_RC)
2065 return (0); /* hope for a real intr */
2066 } while ((st0 & NE7_ST0_IC) == NE7_ST0_IC_RC);
2067
2068 if (0 == descyl) {
2069 int failed = 0;
2070 /*
2071 * seek to cyl 0 requested; make sure we are
2072 * really there
2073 */
2074 if (fd_sense_drive_status(fdc, &st3))
2075 failed = 1;
2076#ifdef EPSON_NRDISK
2077 if (fdu == nrdu) st3 = NE7_ST3_T0;
2078#endif /* EPSON_NRDISK */
2079 if ((st3 & NE7_ST3_T0) == 0) {
2080 printf(
2081 "fd%d: Seek to cyl 0, but not really there (ST3 = %b)\n",
2082 fdu, st3, NE7_ST3BITS);
2083 failed = 1;
2084 }
2085
2086 if (failed) {
2087 if(fdc->retry < 3)
2088 fdc->retry = 3;
2089 return (retrier(fdc));
2090 }
2091 }
2092#ifdef EPSON_NRDISK
2093 if (fdu == nrdu) cyl = descyl;
2094#endif
2095
2096 if (cyl != descyl) {
2097 printf(
2098 "fd%d: Seek to cyl %d failed; am at cyl %d (ST0 = 0x%x)\n",
2099 fdu, descyl, cyl, st0);
2100 if (fdc->retry < 3)
2101 fdc->retry = 3;
2102 return (retrier(fdc));
2103 }
2104 }
2105
2106 fd->track = cylinder;
2107 if (format)
2108 fd->skip = (char *)&(finfo->fd_formb_cylno(0))
2109 - (char *)finfo;
2110#ifdef EPSON_NRDISK
2111 if (fdu != nrdu) {
2112#endif /* EPSON_NRDISK */
2113 if (!rdsectid && !(fdc->flags & FDC_NODMA))
2114 isa_dmastart(idf, bp->bio_data+fd->skip,
2115 format ? bp->bio_bcount : fdblk, fdc->dmachan);
2116 blknum = bp->bio_pblkno + fd->skip / fdblk;
2117 sectrac = fd->ft->sectrac;
2118 sec = blknum % (sectrac * fd->ft->heads);
2119 head = sec / sectrac;
2120 sec = sec % sectrac + 1;
2121 if (head != 0 && fd->ft->offset_side2 != 0)
2122 sec += fd->ft->offset_side2;
2123 fd->hddrv = ((head&1)<<2)+fdu;
2124
2125 if(format || !(read || rdsectid))
2126 {
2127 /* make sure the drive is writable */
2128 if(fd_sense_drive_status(fdc, &st3) != 0)
2129 {
2130 /* stuck controller? */
2131 if (!(fdc->flags & FDC_NODMA))
2132 isa_dmadone(idf,
2133 bp->bio_data + fd->skip,
2134 format ? bp->bio_bcount : fdblk,
2135 fdc->dmachan);
2136 fdc->retry = 6; /* reset the beast */
2137 return (retrier(fdc));
2138 }
2139 if(st3 & NE7_ST3_WP)
2140 {
2141 /*
2142 * XXX YES! this is ugly.
2143 * in order to force the current operation
2144 * to fail, we will have to fake an FDC
2145 * error - all error handling is done
2146 * by the retrier()
2147 */
2148 fdc->status[0] = NE7_ST0_IC_AT;
2149 fdc->status[1] = NE7_ST1_NW;
2150 fdc->status[2] = 0;
2151 fdc->status[3] = fd->track;
2152 fdc->status[4] = head;
2153 fdc->status[5] = sec;
2154 fdc->retry = 8; /* break out immediately */
2155 fdc->state = IOTIMEDOUT; /* not really... */
2156 return (1); /* will return immediately */
2157 }
2158 }
2159
2160 if (format) {
2161 ne7cmd = NE7CMD_FORMAT | mfm;
2162 if (fdc->flags & FDC_NODMA) {
2163 /*
2164 * This seems to be necessary for
2165 * whatever obscure reason; if we omit
2166 * it, we end up filling the sector ID
2167 * fields of the newly formatted track
2168 * entirely with garbage, causing
2169 * `wrong cylinder' errors all over
2170 * the place when trying to read them
2171 * back.
2172 *
2173 * Umpf.
2174 */
2175 SET_BCDR(fdc, 1, bp->bio_bcount, 0);
2176
2177 (void)fdcpio(fdc,bp->bio_cmd,
2178 bp->bio_data+fd->skip,
2179 bp->bio_bcount);
2180
2181 }
2182 /* formatting */
2183 if(fd_cmd(fdc, 6, ne7cmd, head << 2 | fdu,
2184 finfo->fd_formb_secshift,
2185 finfo->fd_formb_nsecs,
2186 finfo->fd_formb_gaplen,
2187 finfo->fd_formb_fillbyte, 0)) {
2188 /* controller fell over */
2189 if (!(fdc->flags & FDC_NODMA))
2190 isa_dmadone(idf,
2191 bp->bio_data + fd->skip,
2192 format ? bp->bio_bcount : fdblk,
2193 fdc->dmachan);
2194 fdc->retry = 6;
2195 return (retrier(fdc));
2196 }
2197 } else if (rdsectid) {
2198 ne7cmd = NE7CMD_READID | mfm;
2199 if (fd_cmd(fdc, 2, ne7cmd, head << 2 | fdu, 0)) {
2200 /* controller jamming */
2201 fdc->retry = 6;
2202 return (retrier(fdc));
2203 }
2204 } else {
2205 /* read or write operation */
2206 ne7cmd = (read ? NE7CMD_READ | NE7CMD_SK : NE7CMD_WRITE) | mfm;
2207 if (fdc->flags & FDC_NODMA) {
2208 /*
2209 * This seems to be necessary even when
2210 * reading data.
2211 */
2212 SET_BCDR(fdc, 1, fdblk, 0);
2213
2214 /*
2215 * Perform the write pseudo-DMA before
2216 * the WRITE command is sent.
2217 */
2218 if (!read)
2219 (void)fdcpio(fdc,bp->bio_cmd,
2220 bp->bio_data+fd->skip,
2221 fdblk);
2222 }
2223 if (fd_cmd(fdc, 9,
2224 ne7cmd,
2225 head << 2 | fdu, /* head & unit */
2226 fd->track, /* track */
2227 head,
2228 sec, /* sector + 1 */
2229 fd->ft->secsize, /* sector size */
2230 sectrac, /* sectors/track */
2231 fd->ft->gap, /* gap size */
2232 fd->ft->datalen, /* data length */
2233 0)) {
2234 /* the beast is sleeping again */
2235 if (!(fdc->flags & FDC_NODMA))
2236 isa_dmadone(idf,
2237 bp->bio_data + fd->skip,
2238 format ? bp->bio_bcount : fdblk,
2239 fdc->dmachan);
2240 fdc->retry = 6;
2241 return (retrier(fdc));
2242 }
2243 }
2244 if (!rdsectid && (fdc->flags & FDC_NODMA))
2245 /*
2246 * If this is a read, then simply await interrupt
2247 * before performing PIO.
2248 */
2249 if (read && !fdcpio(fdc,bp->bio_cmd,
2250 bp->bio_data+fd->skip,fdblk)) {
2251 fd->tohandle = timeout(fd_iotimeout, fdc, hz);
2252 return(0); /* will return later */
2253 }
2254
2255 /*
2256 * Write (or format) operation will fall through and
2257 * await completion interrupt.
2258 */
2259 fdc->state = IOCOMPLETE;
2260 fd->tohandle = timeout(fd_iotimeout, fdc, hz);
2261 return (0); /* will return later */
2262#ifdef EPSON_NRDISK
2263 }
2264 else {
2265 nrdblkn = (nrd_t)((unsigned long)bp->b_blkno*DEV_BSIZE/fdblk
2266 + fd->skip/fdblk);
2267 nrd_LED_on();
2268 nrd_addrset(fdblk * nrdblkn);
2269 while (!nrd_check_ready()) DELAY(1);
2270 if (read) epson_insw(P_NRD_DATA,
2271 bp->bio_data + fd->skip,
2272 fdblk / sizeof(short));
2273 else epson_outsw(P_NRD_DATA,
2274 bp->bio_data + fd->skip,
2275 (format ? bp->bio_bcount : fdblk)
2276 / sizeof(short));
2277
2278 blknum = (unsigned long)bp->b_blkno*DEV_BSIZE/fdblk
2279 + fd->skip/fdblk;
2280 sectrac = fd->ft->sectrac;
2281 sec = blknum % (sectrac * fd->ft->heads);
2282 head = sec / sectrac;
2283 sec = sec % sectrac + 1;
2284 fd->hddrv = ((head&1)<<2)+fdu;
2285
2286 if (nrdsec++ >= nrd_sec())
2287 nrdaddr = (nrd_t)(fd->track * 8 + head * 4);
2288 nrdsec = sec;
2289 fdc->state = IOCOMPLETE;
2290 }
2291#endif
2292
2293 case PIOREAD:
2294 /*
2295 * Actually perform the PIO read. The IOCOMPLETE case
2296 * removes the timeout for us.
2297 */
2298 (void)fdcpio(fdc,bp->bio_cmd,bp->bio_data+fd->skip,fdblk);
2299 fdc->state = IOCOMPLETE;
2300 /* FALLTHROUGH */
2301 case IOCOMPLETE: /* IO done, post-analyze */
2302#ifdef EPSON_NRDISK
2303 if (fdu != nrdu)
2304 untimeout(fd_iotimeout, fdc, fd->tohandle);
2305#else
2306 untimeout(fd_iotimeout, fdc, fd->tohandle);
2307#endif
2308
2309 if (fd_read_status(fdc)) {
2310 if (!rdsectid && !(fdc->flags & FDC_NODMA))
2311 isa_dmadone(idf, bp->bio_data + fd->skip,
2312 format ? bp->bio_bcount : fdblk,
2313 fdc->dmachan);
2314 if (fdc->retry < 6)
2315 fdc->retry = 6; /* force a reset */
2316 return (retrier(fdc));
2317 }
2318
2319 fdc->state = IOTIMEDOUT;
2320
2321 /* FALLTHROUGH */
2322 case IOTIMEDOUT:
2323#ifdef EPSON_NRDISK
2324 if (fdu != nrdu) {
2325#endif /* EPSON_NRDISK */
2326 if (!rdsectid && !(fdc->flags & FDC_NODMA))
2327 isa_dmadone(idf, bp->bio_data + fd->skip,
2328 format ? bp->bio_bcount : fdblk, fdc->dmachan);
2329#ifdef EPSON_NRDISK
2330 }
2331 else nrd_LED_off();
2332#endif /* EPSON_NRDISK */
2333 if (fdc->status[0] & NE7_ST0_IC) {
2334 if ((fdc->status[0] & NE7_ST0_IC) == NE7_ST0_IC_AT
2335 && fdc->status[1] & NE7_ST1_OR) {
2336 /*
2337 * DMA overrun. Someone hogged the bus and
2338 * didn't release it in time for the next
2339 * FDC transfer.
2340 *
2341 * We normally restart this without bumping
2342 * the retry counter. However, in case
2343 * something is seriously messed up (like
2344 * broken hardware), we rather limit the
2345 * number of retries so the IO operation
2346 * doesn't block indefinately.
2347 */
2348 if (fdc->dma_overruns++ < FDC_DMAOV_MAX) {
2349 fdc->state = SEEKCOMPLETE;
2350 return (1);/* will return immediately */
2351 } /* else fall through */
2352 }
2353 if((fdc->status[0] & NE7_ST0_IC) == NE7_ST0_IC_IV
2354 && fdc->retry < 6)
2355 fdc->retry = 6; /* force a reset */
2356 else if((fdc->status[0] & NE7_ST0_IC) == NE7_ST0_IC_AT
2357 && fdc->status[2] & NE7_ST2_WC
2358 && fdc->retry < 3)
2359 fdc->retry = 3; /* force recalibrate */
2360 return (retrier(fdc));
2361 }
2362 /* All OK */
2363 if (rdsectid) {
2364 /* copy out ID field contents */
2365 idp = (struct fdc_readid *)bp->bio_data;
2366 idp->cyl = fdc->status[3];
2367 idp->head = fdc->status[4];
2368 idp->sec = fdc->status[5];
2369 idp->secshift = fdc->status[6];
2370 }
2371 /* Operation successful, retry DMA overruns again next time. */
2372 fdc->dma_overruns = 0;
2373 fd->skip += fdblk;
2374 if (!rdsectid && !format && fd->skip < bp->bio_bcount) {
2375 /* set up next transfer */
2376 fdc->state = DOSEEK;
2377 } else {
2378 /* ALL DONE */
2379 fd->skip = 0;
2380 bp->bio_resid = 0;
2381 fdc->bp = NULL;
2382 device_unbusy(fd->dev);
2383 biofinish(bp, fd->device_stats, 0);
2384 fdc->fd = (fd_p) 0;
2385 fdc->fdu = -1;
2386 fdc->state = FINDWORK;
2387 }
2388 return (1); /* will return immediately */
2389
2390 case RESETCTLR:
2391 fdc_reset(fdc);
2392 fdc->retry++;
2393 fdc->state = RESETCOMPLETE;
2394 return (0); /* will return later */
2395
2396 case RESETCOMPLETE:
2397 /*
2398 * Discard all the results from the reset so that they
2399 * can't cause an unexpected interrupt later.
2400 */
2401 for (i = 0; i < 4; i++)
2402 (void)fd_sense_int(fdc, &st0, &cyl);
2403 fdc->state = STARTRECAL;
2404 /* FALLTHROUGH */
2405 case STARTRECAL:
2406#ifdef PC98
2407 pc98_fd_check_ready(fdu);
2408#endif
2409 if(fd_cmd(fdc, 2, NE7CMD_RECAL, fdu, 0)) {
2410 /* arrgl */
2411 fdc->retry = 6;
2412 return (retrier(fdc));
2413 }
2414 fdc->state = RECALWAIT;
2415 return (0); /* will return later */
2416
2417 case RECALWAIT:
2418 /* allow heads to settle */
2419 timeout(fd_pseudointr, fdc, hz / 8);
2420 fdc->state = RECALCOMPLETE;
2421 return (0); /* will return later */
2422
2423 case RECALCOMPLETE:
2424 do {
2425 /*
2426 * See SEEKCOMPLETE for a comment on this:
2427 */
2428 if (fd_sense_int(fdc, &st0, &cyl) == FD_NOT_VALID)
2429 return (0); /* will return later */
2430 if(fdc->fdct == FDC_NE765
2431 && (st0 & NE7_ST0_IC) == NE7_ST0_IC_RC)
2432 return (0); /* hope for a real intr */
2433 } while ((st0 & NE7_ST0_IC) == NE7_ST0_IC_RC);
2434#ifdef EPSON_NRDISK
2435 if (fdu == nrdu) {
2436 st0 = NE7_ST0_IC_NT;
2437 cyl = 0;
2438 }
2439#endif
2440 if ((st0 & NE7_ST0_IC) != NE7_ST0_IC_NT || cyl != 0)
2441 {
2442 if(fdc->retry > 3)
2443 /*
2444 * A recalibrate from beyond cylinder 77
2445 * will "fail" due to the FDC limitations;
2446 * since people used to complain much about
2447 * the failure message, try not logging
2448 * this one if it seems to be the first
2449 * time in a line.
2450 */
2451 printf("fd%d: recal failed ST0 %b cyl %d\n",
2452 fdu, st0, NE7_ST0BITS, cyl);
2453 if(fdc->retry < 3) fdc->retry = 3;
2454 return (retrier(fdc));
2455 }
2456 fd->track = 0;
2457 /* Seek (probably) necessary */
2458 fdc->state = DOSEEK;
2459 return (1); /* will return immediately */
2460
2461 case MOTORWAIT:
2462 if(fd->flags & FD_MOTOR_WAIT)
2463 {
2464 return (0); /* time's not up yet */
2465 }
2466 if (fdc->flags & FDC_NEEDS_RESET) {
2467 fdc->state = RESETCTLR;
2468 fdc->flags &= ~FDC_NEEDS_RESET;
2469 } else
2470 fdc->state = DOSEEK;
2471 return (1); /* will return immediately */
2472
2473 default:
2474 device_printf(fdc->fdc_dev, "unexpected FD int->");
2475 if (fd_read_status(fdc) == 0)
2476 printf("FDC status :%x %x %x %x %x %x %x ",
2477 fdc->status[0],
2478 fdc->status[1],
2479 fdc->status[2],
2480 fdc->status[3],
2481 fdc->status[4],
2482 fdc->status[5],
2483 fdc->status[6] );
2484 else
2485 printf("No status available ");
2486 if (fd_sense_int(fdc, &st0, &cyl) != 0)
2487 {
2488 printf("[controller is dead now]\n");
2489 return (0); /* will return later */
2490 }
2491 printf("ST0 = %x, PCN = %x\n", st0, cyl);
2492 return (0); /* will return later */
2493 }
2494 /* noone should ever get here */
2495}
2496
2497static int
2498retrier(struct fdc_data *fdc)
2499{
2500 struct bio *bp;
2501 struct fd_data *fd;
2502 int fdu;
2503
2504 bp = fdc->bp;
2505
2506 /* XXX shouldn't this be cached somewhere? */
2507 fd = bp->bio_dev->si_drv1;
2508 fdu = fd->fdu;
2509 if (fd->options & FDOPT_NORETRY)
2510 goto fail;
2511
2512 switch (fdc->retry) {
2513 case 0: case 1: case 2:
2514 fdc->state = SEEKCOMPLETE;
2515 break;
2516 case 3: case 4: case 5:
2517 fdc->state = STARTRECAL;
2518 break;
2519 case 6:
2520 fdc->state = RESETCTLR;
2521 break;
2522 case 7:
2523 break;
2524 default:
2525 fail:
2526 if ((fd->options & FDOPT_NOERRLOG) == 0) {
2527 disk_err(bp, "hard error",
2528 fdc->fd->skip / DEV_BSIZE, 0);
2529 if (fdc->flags & FDC_STAT_VALID) {
2530 printf(
2531 " (ST0 %b ST1 %b ST2 %b cyl %u hd %u sec %u)\n",
2532 fdc->status[0], NE7_ST0BITS,
2533 fdc->status[1], NE7_ST1BITS,
2534 fdc->status[2], NE7_ST2BITS,
2535 fdc->status[3], fdc->status[4],
2536 fdc->status[5]);
2537 }
2538 else
2539 printf(" (No status)\n");
2540 }
2541 if ((fd->options & FDOPT_NOERROR) == 0) {
2542 bp->bio_flags |= BIO_ERROR;
2543 bp->bio_error = EIO;
2544 bp->bio_resid = bp->bio_bcount - fdc->fd->skip;
2545 } else
2546 bp->bio_resid = 0;
2547 fdc->bp = NULL;
2548 fdc->fd->skip = 0;
2549 device_unbusy(fd->dev);
2550 biofinish(bp, fdc->fd->device_stats, 0);
2551 fdc->state = FINDWORK;
2552 fdc->flags |= FDC_NEEDS_RESET;
2553 fdc->fd = (fd_p) 0;
2554 fdc->fdu = -1;
2555 return (1);
2556 }
2557 fdc->retry++;
2558 return (1);
2559}
2560
2561static void
2562fdbiodone(struct bio *bp)
2563{
2564 wakeup(bp);
2565}
2566
2567static int
2568fdmisccmd(struct cdev *dev, u_int cmd, void *data)
2569{
2570 fdu_t fdu;
2571 fd_p fd;
2572 struct bio *bp;
2573 struct fd_formb *finfo;
2574 struct fdc_readid *idfield;
2575 size_t fdblk;
2576 int error;
2577
2578 fd = dev->si_drv1;
2579 fdu = fd->fdu;
2580 fdblk = 128 << fd->ft->secsize;
2581 finfo = (struct fd_formb *)data;
2582 idfield = (struct fdc_readid *)data;
2583
2584 bp = malloc(sizeof(struct bio), M_TEMP, M_WAITOK | M_ZERO);
2585
2586 /*
2587 * Set up a bio request for fdstrategy(). bio_offset is faked
2588 * so that fdstrategy() will seek to the the requested
2589 * cylinder, and use the desired head.
2590 */
2591 bp->bio_cmd = cmd;
2592 if (cmd == FDBIO_FORMAT) {
2593 bp->bio_offset =
2594 (finfo->cyl * (fd->ft->sectrac * fd->ft->heads) +
2595 finfo->head * fd->ft->sectrac) * fdblk;
2596 bp->bio_bcount = sizeof(struct fd_idfield_data) *
2597 finfo->fd_formb_nsecs;
2598 } else if (cmd == FDBIO_RDSECTID) {
2599 bp->bio_offset =
2600 (idfield->cyl * (fd->ft->sectrac * fd->ft->heads) +
2601 idfield->head * fd->ft->sectrac) * fdblk;
2602 bp->bio_bcount = sizeof(struct fdc_readid);
2603 } else
2604 panic("wrong cmd in fdmisccmd()");
2605 bp->bio_data = data;
2606 bp->bio_dev = dev;
2607 bp->bio_done = fdbiodone;
2608 bp->bio_flags = 0;
2609
2610 /* Now run the command. */
2611 fdstrategy(bp);
2612 error = biowait(bp, "fdcmd");
2613
2614 free(bp, M_TEMP);
2615 return (error);
2616}
2617
2618static int
2619fdioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
2620{
2621 fdu_t fdu;
2622 fd_p fd;
2623 struct fdc_status *fsp;
2624 struct fdc_readid *rid;
2625 int error;
2626
2627 fd = dev->si_drv1;
2628 fdu = fd->fdu;
2629
2630#ifdef PC98
2631 pc98_fd_check_ready(fdu);
2632#endif
2633
2634 /*
2635 * First, handle everything that could be done with
2636 * FD_NONBLOCK still being set.
2637 */
2638 switch (cmd) {
2639
2640 case DIOCGMEDIASIZE:
2641 if (fd->ft == 0)
2642 return ((fd->flags & FD_NONBLOCK) ? EAGAIN : ENXIO);
2643 *(off_t *)addr = (128 << (fd->ft->secsize)) * fd->ft->size;
2644 return (0);
2645
2646 case DIOCGSECTORSIZE:
2647 if (fd->ft == 0)
2648 return ((fd->flags & FD_NONBLOCK) ? EAGAIN : ENXIO);
2649 *(u_int *)addr = 128 << (fd->ft->secsize);
2650 return (0);
2651
2652 case FIONBIO:
2653 if (*(int *)addr != 0)
2654 fd->flags |= FD_NONBLOCK;
2655 else {
2656 if (fd->ft == 0) {
2657 /*
2658 * No drive type has been selected yet,
2659 * cannot turn FNONBLOCK off.
2660 */
2661 return (EINVAL);
2662 }
2663 fd->flags &= ~FD_NONBLOCK;
2664 }
2665 return (0);
2666
2667 case FIOASYNC:
2668 /* keep the generic fcntl() code happy */
2669 return (0);
2670
2671 case FD_GTYPE: /* get drive type */
2672 if (fd->ft == 0)
2673 /* no type known yet, return the native type */
2674 *(struct fd_type *)addr = fd_native_types[fd->type];
2675 else
2676 *(struct fd_type *)addr = *fd->ft;
2677 return (0);
2678
2679 case FD_STYPE: /* set drive type */
2680 /*
2681 * Allow setting drive type temporarily iff
2682 * currently unset. Used for fdformat so any
2683 * user can set it, and then start formatting.
2684 */
2685 if (fd->ft)
2686 return (EINVAL); /* already set */
2687 fd->fts[0] = *(struct fd_type *)addr;
2688 fd->ft = &fd->fts[0];
2689 fd->flags |= FD_UA;
2690 return (0);
2691
2692 case FD_GOPTS: /* get drive options */
2693 *(int *)addr = fd->options + FDOPT_AUTOSEL;
2694 return (0);
2695
2696 case FD_SOPTS: /* set drive options */
2697 fd->options = *(int *)addr & ~FDOPT_AUTOSEL;
2698 return (0);
2699
2700#ifdef FDC_DEBUG
2701 case FD_DEBUG:
2702 if ((fd_debug != 0) != (*(int *)addr != 0)) {
2703 fd_debug = (*(int *)addr != 0);
2704 printf("fd%d: debugging turned %s\n",
2705 fd->fdu, fd_debug ? "on" : "off");
2706 }
2707 return (0);
2708#endif
2709
2710 case FD_CLRERR:
2711 if (suser(td) != 0)
2712 return (EPERM);
2713 fd->fdc->fdc_errs = 0;
2714 return (0);
2715
2716 case FD_GSTAT:
2717 fsp = (struct fdc_status *)addr;
2718 if ((fd->fdc->flags & FDC_STAT_VALID) == 0)
2719 return (EINVAL);
2720 memcpy(fsp->status, fd->fdc->status, 7 * sizeof(u_int));
2721 return (0);
2722
2723 case FD_GDTYPE:
2724 *(enum fd_drivetype *)addr = fd->type;
2725 return (0);
2726 }
2727
2728 /*
2729 * Now handle everything else. Make sure we have a valid
2730 * drive type.
2731 */
2732 if (fd->flags & FD_NONBLOCK)
2733 return (EAGAIN);
2734 if (fd->ft == 0)
2735 return (ENXIO);
2736 error = 0;
2737
2738 switch (cmd) {
2739
2740 case FD_FORM:
2741 if ((flag & FWRITE) == 0)
2742 return (EBADF); /* must be opened for writing */
2743 if (((struct fd_formb *)addr)->format_version !=
2744 FD_FORMAT_VERSION)
2745 return (EINVAL); /* wrong version of formatting prog */
2746 error = fdmisccmd(dev, FDBIO_FORMAT, addr);
2747 break;
2748
2749 case FD_GTYPE: /* get drive type */
2750 *(struct fd_type *)addr = *fd->ft;
2751 break;
2752
2753 case FD_STYPE: /* set drive type */
2754 /* this is considered harmful; only allow for superuser */
2755 if (suser(td) != 0)
2756 return (EPERM);
2757 *fd->ft = *(struct fd_type *)addr;
2758 break;
2759
2760 case FD_GOPTS: /* get drive options */
2761 *(int *)addr = fd->options;
2762 break;
2763
2764 case FD_SOPTS: /* set drive options */
2765 fd->options = *(int *)addr;
2766 break;
2767
2768#ifdef FDC_DEBUG
2769 case FD_DEBUG:
2770 if ((fd_debug != 0) != (*(int *)addr != 0)) {
2771 fd_debug = (*(int *)addr != 0);
2772 printf("fd%d: debugging turned %s\n",
2773 fd->fdu, fd_debug ? "on" : "off");
2774 }
2775 break;
2776#endif
2777
2778 case FD_CLRERR:
2779 if (suser(td) != 0)
2780 return (EPERM);
2781 fd->fdc->fdc_errs = 0;
2782 break;
2783
2784 case FD_GSTAT:
2785 fsp = (struct fdc_status *)addr;
2786 if ((fd->fdc->flags & FDC_STAT_VALID) == 0)
2787 return (EINVAL);
2788 memcpy(fsp->status, fd->fdc->status, 7 * sizeof(u_int));
2789 break;
2790
2791 case FD_READID:
2792 rid = (struct fdc_readid *)addr;
2793 if (rid->cyl > MAX_CYLINDER || rid->head > MAX_HEAD)
2794 return (EINVAL);
2795 error = fdmisccmd(dev, FDBIO_RDSECTID, addr);
2796 break;
2797
2798 default:
2799 error = ENOTTY;
2800 break;
2801 }
2802 return (error);
2803}
|