1 /* $OpenBSD: fdc.c,v 1.24 2022/04/06 18:59:28 naddy Exp $ */
2 /* $NetBSD: fd.c,v 1.90 1996/05/12 23:12:03 mycroft Exp $ */
3
4 /*-
5 * Copyright (c) 1993, 1994, 1995 Charles Hannum.
6 * Copyright (c) 1990 The Regents of the University of California.
7 * All rights reserved.
8 *
9 * This code is derived from software contributed to Berkeley by
10 * Don Ahn.
11 *
12 * Portions 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 * joerg_wunsch@uriah.sax.de (Joerg Wunsch)
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions
20 * are met:
21 * 1. Redistributions of source code must retain the above copyright
22 * notice, this list of conditions and the following disclaimer.
23 * 2. Redistributions in binary form must reproduce the above copyright
24 * notice, this list of conditions and the following disclaimer in the
25 * documentation and/or other materials provided with the distribution.
26 * 3. Neither the name of the University nor the names of its contributors
27 * may be used to endorse or promote products derived from this software
28 * without specific prior written permission.
29 *
30 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
31 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
34 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
36 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
37 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
38 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
39 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40 * SUCH DAMAGE.
41 *
42 * @(#)fd.c 7.4 (Berkeley) 5/25/91
43 */
44
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/kernel.h>
48 #include <sys/ioctl.h>
49 #include <sys/device.h>
50 #include <sys/disklabel.h>
51 #include <sys/disk.h>
52 #include <sys/buf.h>
53 #include <sys/malloc.h>
54 #include <sys/uio.h>
55 #include <sys/mtio.h>
56 #include <sys/syslog.h>
57 #include <sys/queue.h>
58 #include <sys/timeout.h>
59 #include <sys/kthread.h>
60
61 #include <machine/cpu.h>
62 #include <machine/bus.h>
63 #include <machine/conf.h>
64 #include <machine/intr.h>
65 #include <machine/ioctl_fd.h>
66
67 #include <dev/isa/isavar.h>
68 #include <dev/isa/fdreg.h>
69
70 #if defined(__i386__) || defined(__amd64__) /* XXX */
71 #include <dev/ic/mc146818reg.h> /* for NVRAM access */
72 #include <i386/isa/nvram.h>
73 #endif
74
75 #include <dev/isa/fdlink.h>
76
77 #include "fd.h"
78
79 /* controller driver configuration */
80 int fdcprobe(struct device *, void *, void *);
81 void fdcattach(struct device *, struct device *, void *);
82 void fdcattach_deferred(void *);
83 void fdc_create_kthread(void *);
84
85 const struct cfattach fdc_ca = {
86 sizeof(struct fdc_softc), fdcprobe, fdcattach
87 };
88
89 struct cfdriver fdc_cd = {
90 NULL, "fdc", DV_DULL
91 };
92
93 int fddprint(void *, const char *);
94 int fdcintr(void *);
95
96 int
fdcprobe(struct device * parent,void * match,void * aux)97 fdcprobe(struct device *parent, void *match, void *aux)
98 {
99 register struct isa_attach_args *ia = aux;
100 bus_space_tag_t iot;
101 bus_space_handle_t ioh;
102 bus_space_handle_t ioh_ctl;
103 int rv;
104
105 iot = ia->ia_iot;
106 rv = 0;
107
108 /* Map the i/o space. */
109 if (bus_space_map(iot, ia->ia_iobase, FDC_NPORT, 0, &ioh))
110 return 0;
111 if (bus_space_map(iot, ia->ia_iobase + FDCTL_OFFSET,
112 FDCTL_NPORT, 0, &ioh_ctl))
113 return 0;
114
115 /* reset */
116 bus_space_write_1(iot, ioh, fdout, 0);
117 delay(100);
118 bus_space_write_1(iot, ioh, fdout, FDO_FRST);
119
120 /* see if it can handle a command */
121 if (out_fdc(iot, ioh, NE7CMD_SPECIFY) < 0)
122 goto out;
123 out_fdc(iot, ioh, 0xdf);
124 out_fdc(iot, ioh, 2);
125
126 rv = 1;
127 ia->ia_iosize = FDC_NPORT;
128 ia->ia_msize = 0;
129
130 out:
131 bus_space_unmap(iot, ioh, FDC_NPORT);
132 bus_space_unmap(iot, ioh_ctl, FDCTL_NPORT);
133 return rv;
134 }
135
136 void
fdcattach(struct device * parent,struct device * self,void * aux)137 fdcattach(struct device *parent, struct device *self, void *aux)
138 {
139 struct fdc_softc *fdc = (void *)self;
140 bus_space_tag_t iot;
141 bus_space_handle_t ioh;
142 bus_space_handle_t ioh_ctl;
143 struct isa_attach_args *ia = aux;
144
145 iot = ia->ia_iot;
146
147 /* Re-map the I/O space. */
148 if (bus_space_map(iot, ia->ia_iobase, FDC_NPORT, 0, &ioh) ||
149 bus_space_map(iot, ia->ia_iobase + FDCTL_OFFSET,
150 FDCTL_NPORT, 0, &ioh_ctl))
151 panic("fdcattach: couldn't map I/O ports");
152
153 fdc->sc_iot = iot;
154 fdc->sc_ioh = ioh;
155 fdc->sc_ioh_ctl = ioh_ctl;
156
157 fdc->sc_drq = ia->ia_drq;
158 fdc->sc_state = DEVIDLE;
159 TAILQ_INIT(&fdc->sc_link.fdlink.sc_drives); /* XXX */
160
161 printf("\n");
162
163 fdc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq, IST_EDGE,
164 IPL_BIO, fdcintr, fdc, fdc->sc_dev.dv_xname);
165
166 kthread_create_deferred(fdc_create_kthread, fdc);
167 }
168
169 void
fdc_create_kthread(void * arg)170 fdc_create_kthread(void *arg)
171 {
172 struct fdc_softc *sc = arg;
173 if (kthread_create(fdcattach_deferred, arg, NULL, "fdcattach") != 0) {
174 printf("%s: failed to create kernel thread, disabled\n",
175 sc->sc_dev.dv_xname);
176 }
177 }
178
179 void
fdcattach_deferred(void * arg)180 fdcattach_deferred(void *arg)
181 {
182 struct fdc_softc *fdc = arg;
183 struct fdc_attach_args fa;
184 int type;
185
186 #if defined(__i386__) || defined(__amd64__)
187 /*
188 * The NVRAM info only tells us about the first two disks on the
189 * `primary' floppy controller.
190 */
191 if (fdc->sc_dev.dv_unit == 0)
192 type = mc146818_read(NULL, NVRAM_DISKETTE); /* XXX softc */
193 else
194 #endif
195 type = -1;
196
197 timeout_set(&fdc->fdcpseudointr_to, fdcpseudointr, fdc);
198
199 /* physical limit: four drives per controller. */
200 for (fa.fa_drive = 0; fa.fa_drive < 4; fa.fa_drive++) {
201 fa.fa_flags = 0;
202 fa.fa_type = 0;
203 #if NFD > 0
204 if (type >= 0 && fa.fa_drive < 2)
205 fa.fa_deftype = fd_nvtotype(fdc->sc_dev.dv_xname,
206 type, fa.fa_drive);
207 else
208 #endif
209 fa.fa_deftype = NULL; /* unknown */
210 (void)config_found(&fdc->sc_dev, (void *)&fa, fddprint);
211 }
212 kthread_exit(0);
213 }
214
215 /*
216 * Print the location of a disk/tape drive (called just before attaching the
217 * the drive). If `fdc' is not NULL, the drive was found but was not
218 * in the system config file; print the drive name as well.
219 * Return QUIET (config_find ignores this if the device was configured) to
220 * avoid printing `fdN not configured' messages.
221 */
222 int
fddprint(void * aux,const char * fdc)223 fddprint(void *aux, const char *fdc)
224 {
225 register struct fdc_attach_args *fa = aux;
226
227 if (!fdc)
228 printf(" drive %d", fa->fa_drive);
229 return QUIET;
230 }
231
232 int
fdcresult(struct fdc_softc * fdc)233 fdcresult(struct fdc_softc *fdc)
234 {
235 bus_space_tag_t iot = fdc->sc_iot;
236 bus_space_handle_t ioh = fdc->sc_ioh;
237 u_char i;
238 int j = 100000, n = 0;
239
240 for (; j; j--) {
241 i = bus_space_read_1(iot, ioh, fdsts) &
242 (NE7_DIO | NE7_RQM | NE7_CB);
243 if (i == NE7_RQM)
244 return n;
245 if (i == (NE7_DIO | NE7_RQM | NE7_CB)) {
246 if (n >= sizeof(fdc->sc_status)) {
247 log(LOG_ERR, "fdcresult: overrun\n");
248 return -1;
249 }
250 fdc->sc_status[n++] =
251 bus_space_read_1(iot, ioh, fddata);
252 }
253 delay(10);
254 }
255 return -1;
256 }
257
258 int
out_fdc(bus_space_tag_t iot,bus_space_handle_t ioh,u_char x)259 out_fdc(bus_space_tag_t iot, bus_space_handle_t ioh, u_char x)
260 {
261 int i = 100000;
262
263 while ((bus_space_read_1(iot, ioh, fdsts) & NE7_DIO) && i-- > 0);
264 if (i <= 0)
265 return -1;
266 while ((bus_space_read_1(iot, ioh, fdsts) & NE7_RQM) == 0 && i-- > 0);
267 if (i <= 0)
268 return -1;
269 bus_space_write_1(iot, ioh, fddata, x);
270 return 0;
271 }
272
273 void
fdcstart(struct fdc_softc * fdc)274 fdcstart(struct fdc_softc *fdc)
275 {
276
277 #ifdef DIAGNOSTIC
278 /* only got here if controller's drive queue was inactive; should
279 be in idle state */
280 if (fdc->sc_state != DEVIDLE) {
281 printf("fdcstart: not idle\n");
282 return;
283 }
284 #endif
285 (void) fdcintr(fdc);
286 }
287
288 void
fdcstatus(struct device * dv,int n,char * s)289 fdcstatus(struct device *dv, int n, char *s)
290 {
291 struct fdc_softc *fdc = (void *)dv->dv_parent;
292
293 if (n == 0) {
294 out_fdc(fdc->sc_iot, fdc->sc_ioh, NE7CMD_SENSEI);
295 (void) fdcresult(fdc);
296 n = 2;
297 }
298
299 printf("%s: %s", dv->dv_xname, s);
300
301 switch (n) {
302 case 0:
303 printf("\n");
304 break;
305 case 2:
306 printf(" (st0 %b cyl %d)\n",
307 fdc->sc_status[0], NE7_ST0BITS,
308 fdc->sc_status[1]);
309 break;
310 case 7:
311 printf(" (st0 %b st1 %b st2 %b cyl %d head %d sec %d)\n",
312 fdc->sc_status[0], NE7_ST0BITS,
313 fdc->sc_status[1], NE7_ST1BITS,
314 fdc->sc_status[2], NE7_ST2BITS,
315 fdc->sc_status[3], fdc->sc_status[4], fdc->sc_status[5]);
316 break;
317 #ifdef DIAGNOSTIC
318 default:
319 printf("\nfdcstatus: weird size");
320 break;
321 #endif
322 }
323 }
324
325 void
fdcpseudointr(void * arg)326 fdcpseudointr(void *arg)
327 {
328 int s;
329
330 /* Just ensure it has the right spl. */
331 s = splbio();
332 (void) fdcintr(arg);
333 splx(s);
334 }
335
336 int
fdcintr(void * arg)337 fdcintr(void *arg)
338 {
339 #if NFD > 0
340 struct fdc_softc *fdc = arg;
341 extern int fdintr(struct fdc_softc *);
342
343 /* Will switch on device type, shortly. */
344 return (fdintr(fdc));
345 #else
346 printf("fdcintr: got interrupt, but no devices!\n");
347 return (1);
348 #endif
349 }
350