wd.c revision 1.220.10.3 1 1.220.10.3 grant /* $NetBSD: wd.c,v 1.220.10.3 2003/06/30 02:57:01 grant Exp $ */
2 1.181 bouyer
3 1.181 bouyer /*
4 1.218 bouyer * Copyright (c) 1998, 2001 Manuel Bouyer. All rights reserved.
5 1.181 bouyer *
6 1.181 bouyer * Redistribution and use in source and binary forms, with or without
7 1.181 bouyer * modification, are permitted provided that the following conditions
8 1.181 bouyer * are met:
9 1.181 bouyer * 1. Redistributions of source code must retain the above copyright
10 1.181 bouyer * notice, this list of conditions and the following disclaimer.
11 1.181 bouyer * 2. Redistributions in binary form must reproduce the above copyright
12 1.181 bouyer * notice, this list of conditions and the following disclaimer in the
13 1.181 bouyer * documentation and/or other materials provided with the distribution.
14 1.181 bouyer * 3. All advertising materials mentioning features or use of this software
15 1.181 bouyer * must display the following acknowledgement:
16 1.181 bouyer * This product includes software developed by Manuel Bouyer.
17 1.181 bouyer * 4. The name of the author may not be used to endorse or promote products
18 1.181 bouyer * derived from this software without specific prior written permission.
19 1.181 bouyer *
20 1.181 bouyer * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 1.181 bouyer * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 1.181 bouyer * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 1.204 bouyer * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 1.181 bouyer * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 1.181 bouyer * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 1.181 bouyer * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 1.181 bouyer * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 1.181 bouyer * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 1.181 bouyer * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 1.181 bouyer */
31 1.100 cgd
32 1.178 mycroft /*-
33 1.178 mycroft * Copyright (c) 1998 The NetBSD Foundation, Inc.
34 1.178 mycroft * All rights reserved.
35 1.119 mycroft *
36 1.178 mycroft * This code is derived from software contributed to The NetBSD Foundation
37 1.178 mycroft * by Charles M. Hannum and by Onno van der Linden.
38 1.168 cgd *
39 1.113 mycroft * Redistribution and use in source and binary forms, with or without
40 1.113 mycroft * modification, are permitted provided that the following conditions
41 1.113 mycroft * are met:
42 1.113 mycroft * 1. Redistributions of source code must retain the above copyright
43 1.113 mycroft * notice, this list of conditions and the following disclaimer.
44 1.113 mycroft * 2. Redistributions in binary form must reproduce the above copyright
45 1.113 mycroft * notice, this list of conditions and the following disclaimer in the
46 1.113 mycroft * documentation and/or other materials provided with the distribution.
47 1.113 mycroft * 3. All advertising materials mentioning features or use of this software
48 1.113 mycroft * must display the following acknowledgement:
49 1.178 mycroft * This product includes software developed by the NetBSD
50 1.178 mycroft * Foundation, Inc. and its contributors.
51 1.178 mycroft * 4. Neither the name of The NetBSD Foundation nor the names of its
52 1.178 mycroft * contributors may be used to endorse or promote products derived
53 1.178 mycroft * from this software without specific prior written permission.
54 1.113 mycroft *
55 1.178 mycroft * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
56 1.178 mycroft * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
57 1.178 mycroft * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
58 1.178 mycroft * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
59 1.178 mycroft * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
60 1.178 mycroft * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
61 1.178 mycroft * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
62 1.178 mycroft * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
63 1.178 mycroft * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
64 1.178 mycroft * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
65 1.178 mycroft * POSSIBILITY OF SUCH DAMAGE.
66 1.1 cgd */
67 1.215 lukem
68 1.215 lukem #include <sys/cdefs.h>
69 1.220.10.3 grant __KERNEL_RCSID(0, "$NetBSD: wd.c,v 1.220.10.3 2003/06/30 02:57:01 grant Exp $");
70 1.1 cgd
71 1.192 hubertf #ifndef WDCDEBUG
72 1.181 bouyer #define WDCDEBUG
73 1.192 hubertf #endif /* WDCDEBUG */
74 1.181 bouyer
75 1.166 explorer #include "rnd.h"
76 1.166 explorer
77 1.29 mycroft #include <sys/param.h>
78 1.29 mycroft #include <sys/systm.h>
79 1.43 mycroft #include <sys/kernel.h>
80 1.29 mycroft #include <sys/conf.h>
81 1.29 mycroft #include <sys/file.h>
82 1.29 mycroft #include <sys/stat.h>
83 1.29 mycroft #include <sys/ioctl.h>
84 1.29 mycroft #include <sys/buf.h>
85 1.29 mycroft #include <sys/uio.h>
86 1.29 mycroft #include <sys/malloc.h>
87 1.64 mycroft #include <sys/device.h>
88 1.94 mycroft #include <sys/disklabel.h>
89 1.94 mycroft #include <sys/disk.h>
90 1.29 mycroft #include <sys/syslog.h>
91 1.149 christos #include <sys/proc.h>
92 1.196 enami #include <sys/vnode.h>
93 1.166 explorer #if NRND > 0
94 1.165 explorer #include <sys/rnd.h>
95 1.166 explorer #endif
96 1.29 mycroft
97 1.150 mycroft #include <machine/intr.h>
98 1.168 cgd #include <machine/bus.h>
99 1.29 mycroft
100 1.181 bouyer #include <dev/ata/atareg.h>
101 1.181 bouyer #include <dev/ata/atavar.h>
102 1.181 bouyer #include <dev/ata/wdvar.h>
103 1.181 bouyer #include <dev/ic/wdcreg.h>
104 1.186 kenh #include <sys/ataio.h>
105 1.163 bouyer #include "locators.h"
106 1.1 cgd
107 1.98 mycroft #define WAITTIME (4 * hz) /* time to wait for a completion */
108 1.189 bouyer #define WDIORETRIES_SINGLE 4 /* number of retries before single-sector */
109 1.181 bouyer #define WDIORETRIES 5 /* number of retries before giving up */
110 1.181 bouyer #define RECOVERYTIME hz/2 /* time to wait before retrying a cmd */
111 1.23 deraadt
112 1.181 bouyer #define WDUNIT(dev) DISKUNIT(dev)
113 1.181 bouyer #define WDPART(dev) DISKPART(dev)
114 1.196 enami #define WDMINOR(unit, part) DISKMINOR(unit, part)
115 1.92 cgd #define MAKEWDDEV(maj, unit, part) MAKEDISKDEV(maj, unit, part)
116 1.92 cgd
117 1.92 cgd #define WDLABELDEV(dev) (MAKEWDDEV(major(dev), WDUNIT(dev), RAW_PART))
118 1.1 cgd
119 1.181 bouyer #define DEBUG_INTR 0x01
120 1.181 bouyer #define DEBUG_XFERS 0x02
121 1.181 bouyer #define DEBUG_STATUS 0x04
122 1.181 bouyer #define DEBUG_FUNCS 0x08
123 1.181 bouyer #define DEBUG_PROBE 0x10
124 1.181 bouyer #ifdef WDCDEBUG
125 1.181 bouyer extern int wdcdebug_wd_mask; /* init'ed in ata_wdc.c */
126 1.181 bouyer #define WDCDEBUG_PRINT(args, level) \
127 1.181 bouyer if (wdcdebug_wd_mask & (level)) \
128 1.181 bouyer printf args
129 1.163 bouyer #else
130 1.181 bouyer #define WDCDEBUG_PRINT(args, level)
131 1.163 bouyer #endif
132 1.163 bouyer
133 1.64 mycroft struct wd_softc {
134 1.181 bouyer /* General disk infos */
135 1.64 mycroft struct device sc_dev;
136 1.144 thorpej struct disk sc_dk;
137 1.200 thorpej struct buf_queue sc_q;
138 1.203 thorpej struct callout sc_restart_ch;
139 1.181 bouyer /* IDE disk soft states */
140 1.184 bouyer struct ata_bio sc_wdc_bio; /* current transfer */
141 1.181 bouyer struct buf *sc_bp; /* buf being transfered */
142 1.181 bouyer void *wdc_softc; /* pointer to our parent */
143 1.181 bouyer struct ata_drive_datas *drvp; /* Our controller's infos */
144 1.217 bouyer const struct ata_bustype *atabus;
145 1.181 bouyer int openings;
146 1.181 bouyer struct ataparams sc_params;/* drive characteistics found */
147 1.181 bouyer int sc_flags;
148 1.220 christos #define WDF_LOCKED 0x001
149 1.220 christos #define WDF_WANTED 0x002
150 1.220 christos #define WDF_WLABEL 0x004 /* label is writable */
151 1.220 christos #define WDF_LABELLING 0x008 /* writing label */
152 1.181 bouyer /*
153 1.181 bouyer * XXX Nothing resets this yet, but disk change sensing will when ATA-4 is
154 1.181 bouyer * more fully implemented.
155 1.181 bouyer */
156 1.220 christos #define WDF_LOADED 0x010 /* parameters loaded */
157 1.220 christos #define WDF_WAIT 0x020 /* waiting for resources */
158 1.220 christos #define WDF_LBA 0x040 /* using LBA mode */
159 1.220 christos #define WDF_KLABEL 0x080 /* retain label after 'full' close */
160 1.220 christos #define WDF_LBA48 0x100 /* using 48-bit LBA mode */
161 1.181 bouyer int sc_capacity;
162 1.181 bouyer int cyl; /* actual drive parameters */
163 1.181 bouyer int heads;
164 1.181 bouyer int sectors;
165 1.181 bouyer int retries; /* number of xfer retry */
166 1.196 enami
167 1.196 enami void *sc_sdhook; /* our shutdown hook */
168 1.196 enami
169 1.166 explorer #if NRND > 0
170 1.165 explorer rndsource_element_t rnd_source;
171 1.166 explorer #endif
172 1.74 mycroft };
173 1.64 mycroft
174 1.181 bouyer #define sc_drive sc_wdc_bio.drive
175 1.181 bouyer #define sc_mode sc_wdc_bio.mode
176 1.181 bouyer #define sc_multi sc_wdc_bio.multi
177 1.181 bouyer #define sc_badsect sc_wdc_bio.badsect
178 1.181 bouyer
179 1.168 cgd int wdprobe __P((struct device *, struct cfdata *, void *));
180 1.163 bouyer void wdattach __P((struct device *, struct device *, void *));
181 1.196 enami int wddetach __P((struct device *, int));
182 1.196 enami int wdactivate __P((struct device *, enum devact));
183 1.181 bouyer int wdprint __P((void *, char *));
184 1.220.10.1 lukem void wdperror __P((const struct wd_softc *));
185 1.102 mycroft
186 1.147 thorpej struct cfattach wd_ca = {
187 1.196 enami sizeof(struct wd_softc), wdprobe, wdattach, wddetach, wdactivate
188 1.147 thorpej };
189 1.147 thorpej
190 1.167 thorpej extern struct cfdriver wd_cd;
191 1.108 mycroft
192 1.185 kenh /*
193 1.185 kenh * Glue necessary to hook WDCIOCCOMMAND into physio
194 1.185 kenh */
195 1.185 kenh
196 1.185 kenh struct wd_ioctl {
197 1.185 kenh LIST_ENTRY(wd_ioctl) wi_list;
198 1.185 kenh struct buf wi_bp;
199 1.185 kenh struct uio wi_uio;
200 1.185 kenh struct iovec wi_iov;
201 1.186 kenh atareq_t wi_atareq;
202 1.185 kenh struct wd_softc *wi_softc;
203 1.185 kenh };
204 1.185 kenh
205 1.185 kenh LIST_HEAD(, wd_ioctl) wi_head;
206 1.185 kenh
207 1.185 kenh struct wd_ioctl *wi_find __P((struct buf *));
208 1.185 kenh void wi_free __P((struct wd_ioctl *));
209 1.185 kenh struct wd_ioctl *wi_get __P((void));
210 1.185 kenh void wdioctlstrategy __P((struct buf *));
211 1.185 kenh
212 1.181 bouyer void wdgetdefaultlabel __P((struct wd_softc *, struct disklabel *));
213 1.181 bouyer void wdgetdisklabel __P((struct wd_softc *));
214 1.181 bouyer void wdstrategy __P((struct buf *));
215 1.181 bouyer void wdstart __P((void *));
216 1.181 bouyer void __wdstart __P((struct wd_softc*, struct buf *));
217 1.181 bouyer void wdrestart __P((void*));
218 1.181 bouyer int wd_get_params __P((struct wd_softc *, u_int8_t, struct ataparams *));
219 1.190 bouyer void wd_flushcache __P((struct wd_softc *, int));
220 1.190 bouyer void wd_shutdown __P((void*));
221 1.220.10.3 grant int wd_getcache __P((struct wd_softc *, int *));
222 1.220.10.3 grant int wd_setcache __P((struct wd_softc *, int));
223 1.108 mycroft
224 1.102 mycroft struct dkdriver wddkdriver = { wdstrategy };
225 1.65 mycroft
226 1.149 christos /* XXX: these should go elsewhere */
227 1.149 christos cdev_decl(wd);
228 1.149 christos bdev_decl(wd);
229 1.149 christos
230 1.170 leo #ifdef HAS_BAD144_HANDLING
231 1.64 mycroft static void bad144intern __P((struct wd_softc *));
232 1.170 leo #endif
233 1.181 bouyer int wdlock __P((struct wd_softc *));
234 1.181 bouyer void wdunlock __P((struct wd_softc *));
235 1.1 cgd
236 1.1 cgd int
237 1.163 bouyer wdprobe(parent, match, aux)
238 1.102 mycroft struct device *parent;
239 1.168 cgd struct cfdata *match;
240 1.168 cgd
241 1.168 cgd void *aux;
242 1.1 cgd {
243 1.216 bouyer struct ata_device *adev = aux;
244 1.167 thorpej
245 1.216 bouyer if (adev == NULL)
246 1.181 bouyer return 0;
247 1.216 bouyer if (adev->adev_bustype->bustype_type != SCSIPI_BUSTYPE_ATA)
248 1.64 mycroft return 0;
249 1.181 bouyer
250 1.181 bouyer if (match->cf_loc[ATACF_CHANNEL] != ATACF_CHANNEL_DEFAULT &&
251 1.216 bouyer match->cf_loc[ATACF_CHANNEL] != adev->adev_channel)
252 1.105 mycroft return 0;
253 1.105 mycroft
254 1.168 cgd if (match->cf_loc[ATACF_DRIVE] != ATACF_DRIVE_DEFAULT &&
255 1.216 bouyer match->cf_loc[ATACF_DRIVE] != adev->adev_drv_data->drive)
256 1.74 mycroft return 0;
257 1.74 mycroft return 1;
258 1.74 mycroft }
259 1.64 mycroft
260 1.74 mycroft void
261 1.74 mycroft wdattach(parent, self, aux)
262 1.74 mycroft struct device *parent, *self;
263 1.74 mycroft void *aux;
264 1.74 mycroft {
265 1.74 mycroft struct wd_softc *wd = (void *)self;
266 1.216 bouyer struct ata_device *adev= aux;
267 1.74 mycroft int i, blank;
268 1.201 enami char buf[41], pbuf[9], c, *p, *q;
269 1.181 bouyer WDCDEBUG_PRINT(("wdattach\n"), DEBUG_FUNCS | DEBUG_PROBE);
270 1.56 mycroft
271 1.203 thorpej callout_init(&wd->sc_restart_ch);
272 1.200 thorpej BUFQ_INIT(&wd->sc_q);
273 1.200 thorpej
274 1.217 bouyer wd->atabus = adev->adev_bustype;
275 1.216 bouyer wd->openings = adev->adev_openings;
276 1.216 bouyer wd->drvp = adev->adev_drv_data;;
277 1.181 bouyer wd->wdc_softc = parent;
278 1.181 bouyer /* give back our softc to our caller */
279 1.181 bouyer wd->drvp->drv_softc = &wd->sc_dev;
280 1.181 bouyer
281 1.181 bouyer /* read our drive info */
282 1.181 bouyer if (wd_get_params(wd, AT_POLL, &wd->sc_params) != 0) {
283 1.181 bouyer printf("%s: IDENTIFY failed\n", wd->sc_dev.dv_xname);
284 1.181 bouyer return;
285 1.181 bouyer }
286 1.163 bouyer
287 1.181 bouyer for (blank = 0, p = wd->sc_params.atap_model, q = buf, i = 0;
288 1.181 bouyer i < sizeof(wd->sc_params.atap_model); i++) {
289 1.135 mycroft c = *p++;
290 1.135 mycroft if (c == '\0')
291 1.135 mycroft break;
292 1.135 mycroft if (c != ' ') {
293 1.135 mycroft if (blank) {
294 1.135 mycroft *q++ = ' ';
295 1.135 mycroft blank = 0;
296 1.135 mycroft }
297 1.135 mycroft *q++ = c;
298 1.135 mycroft } else
299 1.135 mycroft blank = 1;
300 1.195 enami }
301 1.135 mycroft *q++ = '\0';
302 1.135 mycroft
303 1.172 mycroft printf(": <%s>\n", buf);
304 1.113 mycroft
305 1.181 bouyer if ((wd->sc_params.atap_multi & 0xff) > 1) {
306 1.181 bouyer wd->sc_multi = wd->sc_params.atap_multi & 0xff;
307 1.113 mycroft } else {
308 1.181 bouyer wd->sc_multi = 1;
309 1.113 mycroft }
310 1.113 mycroft
311 1.210 lukem printf("%s: drive supports %d-sector PIO transfers,",
312 1.184 bouyer wd->sc_dev.dv_xname, wd->sc_multi);
313 1.172 mycroft
314 1.220 christos /* 48-bit LBA addressing */
315 1.220 christos if ((wd->sc_params.atap_cmd2_en & WDC_CAP_LBA48) != 0)
316 1.220 christos wd->sc_flags |= WDF_LBA48;
317 1.220 christos
318 1.172 mycroft /* Prior to ATA-4, LBA was optional. */
319 1.181 bouyer if ((wd->sc_params.atap_capabilities1 & WDC_CAP_LBA) != 0)
320 1.181 bouyer wd->sc_flags |= WDF_LBA;
321 1.174 mycroft #if 0
322 1.172 mycroft /* ATA-4 requires LBA. */
323 1.181 bouyer if (wd->sc_params.atap_ataversion != 0xffff &&
324 1.181 bouyer wd->sc_params.atap_ataversion >= WDC_VER_ATA4)
325 1.181 bouyer wd->sc_flags |= WDF_LBA;
326 1.174 mycroft #endif
327 1.172 mycroft
328 1.220 christos if ((wd->sc_flags & WDF_LBA48) != 0) {
329 1.220 christos printf(" LBA48 addressing\n");
330 1.220 christos wd->sc_capacity =
331 1.220 christos ((u_int64_t) wd->sc_params.__reserved6[11] << 48) |
332 1.220 christos ((u_int64_t) wd->sc_params.__reserved6[10] << 32) |
333 1.220 christos ((u_int64_t) wd->sc_params.__reserved6[9] << 16) |
334 1.220 christos ((u_int64_t) wd->sc_params.__reserved6[8] << 0);
335 1.220 christos } else if ((wd->sc_flags & WDF_LBA) != 0) {
336 1.210 lukem printf(" LBA addressing\n");
337 1.181 bouyer wd->sc_capacity =
338 1.181 bouyer (wd->sc_params.atap_capacity[1] << 16) |
339 1.181 bouyer wd->sc_params.atap_capacity[0];
340 1.172 mycroft } else {
341 1.184 bouyer printf(" chs addressing\n");
342 1.181 bouyer wd->sc_capacity =
343 1.181 bouyer wd->sc_params.atap_cylinders *
344 1.181 bouyer wd->sc_params.atap_heads *
345 1.181 bouyer wd->sc_params.atap_sectors;
346 1.172 mycroft }
347 1.201 enami format_bytes(pbuf, sizeof(pbuf),
348 1.201 enami (u_int64_t)wd->sc_capacity * DEV_BSIZE);
349 1.201 enami printf("%s: %s, %d cyl, %d head, %d sec, "
350 1.201 enami "%d bytes/sect x %d sectors\n",
351 1.201 enami self->dv_xname, pbuf, wd->sc_params.atap_cylinders,
352 1.201 enami wd->sc_params.atap_heads, wd->sc_params.atap_sectors,
353 1.201 enami DEV_BSIZE, wd->sc_capacity);
354 1.201 enami
355 1.181 bouyer WDCDEBUG_PRINT(("%s: atap_dmatiming_mimi=%d, atap_dmatiming_recom=%d\n",
356 1.181 bouyer self->dv_xname, wd->sc_params.atap_dmatiming_mimi,
357 1.181 bouyer wd->sc_params.atap_dmatiming_recom), DEBUG_PROBE);
358 1.181 bouyer /*
359 1.181 bouyer * Initialize and attach the disk structure.
360 1.181 bouyer */
361 1.181 bouyer wd->sc_dk.dk_driver = &wddkdriver;
362 1.181 bouyer wd->sc_dk.dk_name = wd->sc_dev.dv_xname;
363 1.181 bouyer disk_attach(&wd->sc_dk);
364 1.181 bouyer wd->sc_wdc_bio.lp = wd->sc_dk.dk_label;
365 1.196 enami wd->sc_sdhook = shutdownhook_establish(wd_shutdown, wd);
366 1.196 enami if (wd->sc_sdhook == NULL)
367 1.190 bouyer printf("%s: WARNING: unable to establish shutdown hook\n",
368 1.190 bouyer wd->sc_dev.dv_xname);
369 1.166 explorer #if NRND > 0
370 1.193 explorer rnd_attach_source(&wd->rnd_source, wd->sc_dev.dv_xname,
371 1.193 explorer RND_TYPE_DISK, 0);
372 1.166 explorer #endif
373 1.196 enami }
374 1.196 enami
375 1.196 enami int
376 1.196 enami wdactivate(self, act)
377 1.196 enami struct device *self;
378 1.196 enami enum devact act;
379 1.196 enami {
380 1.196 enami int rv = 0;
381 1.196 enami
382 1.196 enami switch (act) {
383 1.196 enami case DVACT_ACTIVATE:
384 1.196 enami rv = EOPNOTSUPP;
385 1.196 enami break;
386 1.196 enami
387 1.196 enami case DVACT_DEACTIVATE:
388 1.196 enami /*
389 1.196 enami * Nothing to do; we key off the device's DVF_ACTIVATE.
390 1.196 enami */
391 1.196 enami break;
392 1.196 enami }
393 1.196 enami return (rv);
394 1.196 enami }
395 1.196 enami
396 1.196 enami int
397 1.196 enami wddetach(self, flags)
398 1.196 enami struct device *self;
399 1.196 enami int flags;
400 1.196 enami {
401 1.196 enami struct wd_softc *sc = (struct wd_softc *)self;
402 1.196 enami struct buf *bp;
403 1.213 drochner int s, bmaj, cmaj, i, mn;
404 1.196 enami
405 1.196 enami /* locate the major number */
406 1.196 enami for (bmaj = 0; bmaj < nblkdev; bmaj++)
407 1.196 enami if (bdevsw[bmaj].d_open == wdopen)
408 1.196 enami break;
409 1.196 enami for (cmaj = 0; cmaj < nchrdev; cmaj++)
410 1.196 enami if (cdevsw[cmaj].d_open == wdopen)
411 1.196 enami break;
412 1.196 enami
413 1.196 enami s = splbio();
414 1.196 enami
415 1.196 enami /* Kill off any queued buffers. */
416 1.200 thorpej while ((bp = BUFQ_FIRST(&sc->sc_q)) != NULL) {
417 1.200 thorpej BUFQ_REMOVE(&sc->sc_q, bp);
418 1.196 enami bp->b_error = EIO;
419 1.196 enami bp->b_flags |= B_ERROR;
420 1.196 enami bp->b_resid = bp->b_bcount;
421 1.196 enami biodone(bp);
422 1.196 enami }
423 1.196 enami
424 1.196 enami splx(s);
425 1.196 enami
426 1.196 enami /* Nuke the vnodes for any open instances. */
427 1.213 drochner for (i = 0; i < MAXPARTITIONS; i++) {
428 1.213 drochner mn = WDMINOR(self->dv_unit, i);
429 1.213 drochner vdevgone(bmaj, mn, mn, VBLK);
430 1.213 drochner vdevgone(cmaj, mn, mn, VCHR);
431 1.213 drochner }
432 1.196 enami
433 1.196 enami /* Detach disk. */
434 1.196 enami disk_detach(&sc->sc_dk);
435 1.196 enami
436 1.196 enami /* Get rid of the shutdown hook. */
437 1.196 enami if (sc->sc_sdhook != NULL)
438 1.196 enami shutdownhook_disestablish(sc->sc_sdhook);
439 1.196 enami
440 1.196 enami #if NRND > 0
441 1.196 enami /* Unhook the entropy source. */
442 1.196 enami rnd_detach_source(&sc->rnd_source);
443 1.196 enami #endif
444 1.196 enami
445 1.196 enami return (0);
446 1.1 cgd }
447 1.1 cgd
448 1.64 mycroft /*
449 1.135 mycroft * Read/write routine for a buffer. Validates the arguments and schedules the
450 1.135 mycroft * transfer. Does not wait for the transfer to complete.
451 1.1 cgd */
452 1.64 mycroft void
453 1.55 mycroft wdstrategy(bp)
454 1.55 mycroft struct buf *bp;
455 1.1 cgd {
456 1.209 thorpej struct wd_softc *wd = device_lookup(&wd_cd, WDUNIT(bp->b_dev));
457 1.202 thorpej struct disklabel *lp = wd->sc_dk.dk_label;
458 1.202 thorpej daddr_t blkno;
459 1.37 mycroft int s;
460 1.202 thorpej
461 1.181 bouyer WDCDEBUG_PRINT(("wdstrategy (%s)\n", wd->sc_dev.dv_xname),
462 1.182 bouyer DEBUG_XFERS);
463 1.181 bouyer
464 1.135 mycroft /* Valid request? */
465 1.135 mycroft if (bp->b_blkno < 0 ||
466 1.202 thorpej (bp->b_bcount % lp->d_secsize) != 0 ||
467 1.202 thorpej (bp->b_bcount / lp->d_secsize) >= (1 << NBBY)) {
468 1.1 cgd bp->b_error = EINVAL;
469 1.93 mycroft goto bad;
470 1.1 cgd }
471 1.181 bouyer
472 1.135 mycroft /* If device invalidated (e.g. media change, door open), error. */
473 1.181 bouyer if ((wd->sc_flags & WDF_LOADED) == 0) {
474 1.135 mycroft bp->b_error = EIO;
475 1.135 mycroft goto bad;
476 1.135 mycroft }
477 1.135 mycroft
478 1.93 mycroft /* If it's a null transfer, return immediately. */
479 1.93 mycroft if (bp->b_bcount == 0)
480 1.93 mycroft goto done;
481 1.93 mycroft
482 1.128 mycroft /*
483 1.128 mycroft * Do bounds checking, adjust transfer. if error, process.
484 1.128 mycroft * If end of partition, just return.
485 1.128 mycroft */
486 1.138 mycroft if (WDPART(bp->b_dev) != RAW_PART &&
487 1.144 thorpej bounds_check_with_label(bp, wd->sc_dk.dk_label,
488 1.181 bouyer (wd->sc_flags & (WDF_WLABEL|WDF_LABELLING)) != 0) <= 0)
489 1.128 mycroft goto done;
490 1.202 thorpej
491 1.202 thorpej /*
492 1.202 thorpej * Now convert the block number to absolute and put it in
493 1.202 thorpej * terms of the device's logical block size.
494 1.202 thorpej */
495 1.202 thorpej if (lp->d_secsize >= DEV_BSIZE)
496 1.202 thorpej blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);
497 1.202 thorpej else
498 1.202 thorpej blkno = bp->b_blkno * (DEV_BSIZE / lp->d_secsize);
499 1.202 thorpej
500 1.202 thorpej if (WDPART(bp->b_dev) != RAW_PART)
501 1.202 thorpej blkno += lp->d_partitions[WDPART(bp->b_dev)].p_offset;
502 1.202 thorpej
503 1.202 thorpej bp->b_rawblkno = blkno;
504 1.202 thorpej
505 1.64 mycroft /* Queue transfer on drive, activate drive and controller if idle. */
506 1.1 cgd s = splbio();
507 1.200 thorpej disksort_blkno(&wd->sc_q, bp);
508 1.163 bouyer wdstart(wd);
509 1.1 cgd splx(s);
510 1.64 mycroft return;
511 1.93 mycroft bad:
512 1.93 mycroft bp->b_flags |= B_ERROR;
513 1.1 cgd done:
514 1.64 mycroft /* Toss transfer; we're done early. */
515 1.135 mycroft bp->b_resid = bp->b_bcount;
516 1.1 cgd biodone(bp);
517 1.1 cgd }
518 1.1 cgd
519 1.1 cgd /*
520 1.135 mycroft * Queue a drive for I/O.
521 1.1 cgd */
522 1.108 mycroft void
523 1.163 bouyer wdstart(arg)
524 1.163 bouyer void *arg;
525 1.1 cgd {
526 1.163 bouyer struct wd_softc *wd = arg;
527 1.200 thorpej struct buf *bp = NULL;
528 1.163 bouyer
529 1.181 bouyer WDCDEBUG_PRINT(("wdstart %s\n", wd->sc_dev.dv_xname),
530 1.182 bouyer DEBUG_XFERS);
531 1.181 bouyer while (wd->openings > 0) {
532 1.163 bouyer
533 1.163 bouyer /* Is there a buf for us ? */
534 1.200 thorpej if ((bp = BUFQ_FIRST(&wd->sc_q)) == NULL)
535 1.200 thorpej return;
536 1.200 thorpej BUFQ_REMOVE(&wd->sc_q, bp);
537 1.181 bouyer
538 1.163 bouyer /*
539 1.163 bouyer * Make the command. First lock the device
540 1.163 bouyer */
541 1.181 bouyer wd->openings--;
542 1.181 bouyer
543 1.181 bouyer wd->retries = 0;
544 1.181 bouyer __wdstart(wd, bp);
545 1.181 bouyer }
546 1.181 bouyer }
547 1.181 bouyer
548 1.181 bouyer void
549 1.181 bouyer __wdstart(wd, bp)
550 1.181 bouyer struct wd_softc *wd;
551 1.181 bouyer struct buf *bp;
552 1.181 bouyer {
553 1.202 thorpej
554 1.202 thorpej wd->sc_wdc_bio.blkno = bp->b_rawblkno;
555 1.181 bouyer wd->sc_wdc_bio.blkdone =0;
556 1.181 bouyer wd->sc_bp = bp;
557 1.181 bouyer /*
558 1.181 bouyer * If we're retrying, retry in single-sector mode. This will give us
559 1.181 bouyer * the sector number of the problem, and will eventually allow the
560 1.184 bouyer * transfer to succeed.
561 1.181 bouyer */
562 1.189 bouyer if (wd->sc_multi == 1 || wd->retries >= WDIORETRIES_SINGLE)
563 1.181 bouyer wd->sc_wdc_bio.flags = ATA_SINGLE;
564 1.181 bouyer else
565 1.181 bouyer wd->sc_wdc_bio.flags = 0;
566 1.220 christos if (wd->sc_flags & WDF_LBA48)
567 1.220 christos wd->sc_wdc_bio.flags |= ATA_LBA48;
568 1.181 bouyer if (wd->sc_flags & WDF_LBA)
569 1.181 bouyer wd->sc_wdc_bio.flags |= ATA_LBA;
570 1.181 bouyer if (bp->b_flags & B_READ)
571 1.181 bouyer wd->sc_wdc_bio.flags |= ATA_READ;
572 1.181 bouyer wd->sc_wdc_bio.bcount = bp->b_bcount;
573 1.181 bouyer wd->sc_wdc_bio.databuf = bp->b_data;
574 1.181 bouyer /* Instrumentation. */
575 1.181 bouyer disk_busy(&wd->sc_dk);
576 1.217 bouyer switch (wd->atabus->ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
577 1.181 bouyer case WDC_TRY_AGAIN:
578 1.203 thorpej callout_reset(&wd->sc_restart_ch, hz, wdrestart, wd);
579 1.181 bouyer break;
580 1.181 bouyer case WDC_QUEUED:
581 1.181 bouyer case WDC_COMPLETE:
582 1.181 bouyer break;
583 1.181 bouyer default:
584 1.217 bouyer panic("__wdstart: bad return code from ata_bio()");
585 1.181 bouyer }
586 1.181 bouyer }
587 1.181 bouyer
588 1.181 bouyer void
589 1.181 bouyer wddone(v)
590 1.181 bouyer void *v;
591 1.181 bouyer {
592 1.181 bouyer struct wd_softc *wd = v;
593 1.181 bouyer struct buf *bp = wd->sc_bp;
594 1.220.10.1 lukem const char *errmsg;
595 1.220.10.1 lukem int do_perror = 0;
596 1.181 bouyer WDCDEBUG_PRINT(("wddone %s\n", wd->sc_dev.dv_xname),
597 1.182 bouyer DEBUG_XFERS);
598 1.181 bouyer
599 1.214 bjh21 if (bp == NULL)
600 1.214 bjh21 return;
601 1.181 bouyer bp->b_resid = wd->sc_wdc_bio.bcount;
602 1.181 bouyer switch (wd->sc_wdc_bio.error) {
603 1.181 bouyer case ERR_DMA:
604 1.220.10.1 lukem errmsg = "DMA error";
605 1.181 bouyer goto retry;
606 1.181 bouyer case ERR_DF:
607 1.220.10.1 lukem errmsg = "device fault";
608 1.181 bouyer goto retry;
609 1.181 bouyer case TIMEOUT:
610 1.220.10.1 lukem errmsg = "device timeout";
611 1.181 bouyer goto retry;
612 1.181 bouyer case ERROR:
613 1.181 bouyer /* Don't care about media change bits */
614 1.181 bouyer if (wd->sc_wdc_bio.r_error != 0 &&
615 1.181 bouyer (wd->sc_wdc_bio.r_error & ~(WDCE_MC | WDCE_MCR)) == 0)
616 1.181 bouyer goto noerror;
617 1.220.10.1 lukem errmsg = "error";
618 1.220.10.1 lukem do_perror = 1;
619 1.181 bouyer retry: /* Just reset and retry. Can we do more ? */
620 1.217 bouyer wd->atabus->ata_reset_channel(wd->drvp);
621 1.220.10.1 lukem diskerr(bp, "wd", errmsg, LOG_PRINTF,
622 1.181 bouyer wd->sc_wdc_bio.blkdone, wd->sc_dk.dk_label);
623 1.220.10.1 lukem if (wd->retries < WDIORETRIES)
624 1.181 bouyer printf(", retrying\n");
625 1.220.10.1 lukem if (do_perror)
626 1.220.10.1 lukem wdperror(wd);
627 1.220.10.1 lukem if (wd->retries < WDIORETRIES) {
628 1.220.10.1 lukem wd->retries++;
629 1.203 thorpej callout_reset(&wd->sc_restart_ch, RECOVERYTIME,
630 1.203 thorpej wdrestart, wd);
631 1.181 bouyer return;
632 1.181 bouyer }
633 1.181 bouyer printf("\n");
634 1.181 bouyer bp->b_flags |= B_ERROR;
635 1.181 bouyer bp->b_error = EIO;
636 1.181 bouyer break;
637 1.181 bouyer case NOERROR:
638 1.181 bouyer noerror: if ((wd->sc_wdc_bio.flags & ATA_CORR) || wd->retries > 0)
639 1.181 bouyer printf("%s: soft error (corrected)\n",
640 1.181 bouyer wd->sc_dev.dv_xname);
641 1.197 enami break;
642 1.197 enami case ERR_NODEV:
643 1.197 enami bp->b_flags |= B_ERROR;
644 1.197 enami bp->b_error = EIO;
645 1.197 enami break;
646 1.64 mycroft }
647 1.181 bouyer disk_unbusy(&wd->sc_dk, (bp->b_bcount - bp->b_resid));
648 1.181 bouyer #if NRND > 0
649 1.181 bouyer rnd_add_uint32(&wd->rnd_source, bp->b_blkno);
650 1.181 bouyer #endif
651 1.181 bouyer biodone(bp);
652 1.181 bouyer wd->openings++;
653 1.181 bouyer wdstart(wd);
654 1.181 bouyer }
655 1.181 bouyer
656 1.181 bouyer void
657 1.181 bouyer wdrestart(v)
658 1.181 bouyer void *v;
659 1.181 bouyer {
660 1.181 bouyer struct wd_softc *wd = v;
661 1.181 bouyer struct buf *bp = wd->sc_bp;
662 1.181 bouyer int s;
663 1.181 bouyer WDCDEBUG_PRINT(("wdrestart %s\n", wd->sc_dev.dv_xname),
664 1.182 bouyer DEBUG_XFERS);
665 1.181 bouyer
666 1.181 bouyer s = splbio();
667 1.181 bouyer __wdstart(v, bp);
668 1.181 bouyer splx(s);
669 1.141 mycroft }
670 1.141 mycroft
671 1.141 mycroft int
672 1.149 christos wdread(dev, uio, flags)
673 1.141 mycroft dev_t dev;
674 1.141 mycroft struct uio *uio;
675 1.149 christos int flags;
676 1.141 mycroft {
677 1.141 mycroft
678 1.182 bouyer WDCDEBUG_PRINT(("wdread\n"), DEBUG_XFERS);
679 1.141 mycroft return (physio(wdstrategy, NULL, dev, B_READ, minphys, uio));
680 1.141 mycroft }
681 1.141 mycroft
682 1.141 mycroft int
683 1.149 christos wdwrite(dev, uio, flags)
684 1.141 mycroft dev_t dev;
685 1.141 mycroft struct uio *uio;
686 1.149 christos int flags;
687 1.141 mycroft {
688 1.141 mycroft
689 1.182 bouyer WDCDEBUG_PRINT(("wdwrite\n"), DEBUG_XFERS);
690 1.141 mycroft return (physio(wdstrategy, NULL, dev, B_WRITE, minphys, uio));
691 1.64 mycroft }
692 1.64 mycroft
693 1.1 cgd /*
694 1.135 mycroft * Wait interruptibly for an exclusive lock.
695 1.135 mycroft *
696 1.135 mycroft * XXX
697 1.135 mycroft * Several drivers do this; it should be abstracted and made MP-safe.
698 1.135 mycroft */
699 1.132 mycroft int
700 1.181 bouyer wdlock(wd)
701 1.181 bouyer struct wd_softc *wd;
702 1.132 mycroft {
703 1.132 mycroft int error;
704 1.163 bouyer int s;
705 1.163 bouyer
706 1.181 bouyer WDCDEBUG_PRINT(("wdlock\n"), DEBUG_FUNCS);
707 1.132 mycroft
708 1.163 bouyer s = splbio();
709 1.163 bouyer
710 1.181 bouyer while ((wd->sc_flags & WDF_LOCKED) != 0) {
711 1.181 bouyer wd->sc_flags |= WDF_WANTED;
712 1.181 bouyer if ((error = tsleep(wd, PRIBIO | PCATCH,
713 1.163 bouyer "wdlck", 0)) != 0) {
714 1.163 bouyer splx(s);
715 1.132 mycroft return error;
716 1.163 bouyer }
717 1.132 mycroft }
718 1.181 bouyer wd->sc_flags |= WDF_LOCKED;
719 1.163 bouyer splx(s);
720 1.132 mycroft return 0;
721 1.132 mycroft }
722 1.132 mycroft
723 1.135 mycroft /*
724 1.135 mycroft * Unlock and wake up any waiters.
725 1.135 mycroft */
726 1.132 mycroft void
727 1.181 bouyer wdunlock(wd)
728 1.181 bouyer struct wd_softc *wd;
729 1.132 mycroft {
730 1.132 mycroft
731 1.181 bouyer WDCDEBUG_PRINT(("wdunlock\n"), DEBUG_FUNCS);
732 1.163 bouyer
733 1.181 bouyer wd->sc_flags &= ~WDF_LOCKED;
734 1.181 bouyer if ((wd->sc_flags & WDF_WANTED) != 0) {
735 1.181 bouyer wd->sc_flags &= ~WDF_WANTED;
736 1.181 bouyer wakeup(wd);
737 1.132 mycroft }
738 1.132 mycroft }
739 1.132 mycroft
740 1.1 cgd int
741 1.149 christos wdopen(dev, flag, fmt, p)
742 1.55 mycroft dev_t dev;
743 1.93 mycroft int flag, fmt;
744 1.149 christos struct proc *p;
745 1.1 cgd {
746 1.135 mycroft struct wd_softc *wd;
747 1.208 thorpej int part, error;
748 1.163 bouyer
749 1.181 bouyer WDCDEBUG_PRINT(("wdopen\n"), DEBUG_FUNCS);
750 1.208 thorpej wd = device_lookup(&wd_cd, WDUNIT(dev));
751 1.158 pk if (wd == NULL)
752 1.208 thorpej return (ENXIO);
753 1.187 thorpej
754 1.187 thorpej /*
755 1.187 thorpej * If this is the first open of this device, add a reference
756 1.187 thorpej * to the adapter.
757 1.187 thorpej */
758 1.187 thorpej if (wd->sc_dk.dk_openmask == 0 &&
759 1.217 bouyer (error = wd->atabus->ata_addref(wd->drvp)) != 0)
760 1.187 thorpej return (error);
761 1.187 thorpej
762 1.181 bouyer if ((error = wdlock(wd)) != 0)
763 1.187 thorpej goto bad4;
764 1.3 deraadt
765 1.109 mycroft if (wd->sc_dk.dk_openmask != 0) {
766 1.109 mycroft /*
767 1.109 mycroft * If any partition is open, but the disk has been invalidated,
768 1.109 mycroft * disallow further opens.
769 1.109 mycroft */
770 1.181 bouyer if ((wd->sc_flags & WDF_LOADED) == 0) {
771 1.136 mycroft error = EIO;
772 1.136 mycroft goto bad3;
773 1.136 mycroft }
774 1.109 mycroft } else {
775 1.181 bouyer if ((wd->sc_flags & WDF_LOADED) == 0) {
776 1.181 bouyer wd->sc_flags |= WDF_LOADED;
777 1.108 mycroft
778 1.108 mycroft /* Load the physical device parameters. */
779 1.183 bouyer wd_get_params(wd, AT_WAIT, &wd->sc_params);
780 1.108 mycroft
781 1.108 mycroft /* Load the partition info if not already loaded. */
782 1.108 mycroft wdgetdisklabel(wd);
783 1.108 mycroft }
784 1.135 mycroft }
785 1.108 mycroft
786 1.135 mycroft part = WDPART(dev);
787 1.108 mycroft
788 1.109 mycroft /* Check that the partition exists. */
789 1.93 mycroft if (part != RAW_PART &&
790 1.144 thorpej (part >= wd->sc_dk.dk_label->d_npartitions ||
791 1.144 thorpej wd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
792 1.93 mycroft error = ENXIO;
793 1.93 mycroft goto bad;
794 1.93 mycroft }
795 1.181 bouyer
796 1.64 mycroft /* Insure only one open at a time. */
797 1.3 deraadt switch (fmt) {
798 1.3 deraadt case S_IFCHR:
799 1.94 mycroft wd->sc_dk.dk_copenmask |= (1 << part);
800 1.3 deraadt break;
801 1.3 deraadt case S_IFBLK:
802 1.94 mycroft wd->sc_dk.dk_bopenmask |= (1 << part);
803 1.3 deraadt break;
804 1.3 deraadt }
805 1.181 bouyer wd->sc_dk.dk_openmask =
806 1.181 bouyer wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
807 1.60 mycroft
808 1.181 bouyer wdunlock(wd);
809 1.37 mycroft return 0;
810 1.93 mycroft
811 1.93 mycroft bad:
812 1.118 mycroft if (wd->sc_dk.dk_openmask == 0) {
813 1.108 mycroft }
814 1.108 mycroft
815 1.136 mycroft bad3:
816 1.181 bouyer wdunlock(wd);
817 1.187 thorpej bad4:
818 1.187 thorpej if (wd->sc_dk.dk_openmask == 0)
819 1.217 bouyer wd->atabus->ata_delref(wd->drvp);
820 1.93 mycroft return error;
821 1.1 cgd }
822 1.1 cgd
823 1.135 mycroft int
824 1.149 christos wdclose(dev, flag, fmt, p)
825 1.135 mycroft dev_t dev;
826 1.135 mycroft int flag, fmt;
827 1.149 christos struct proc *p;
828 1.135 mycroft {
829 1.209 thorpej struct wd_softc *wd = device_lookup(&wd_cd, WDUNIT(dev));
830 1.135 mycroft int part = WDPART(dev);
831 1.135 mycroft int error;
832 1.181 bouyer
833 1.181 bouyer WDCDEBUG_PRINT(("wdclose\n"), DEBUG_FUNCS);
834 1.181 bouyer if ((error = wdlock(wd)) != 0)
835 1.135 mycroft return error;
836 1.135 mycroft
837 1.135 mycroft switch (fmt) {
838 1.135 mycroft case S_IFCHR:
839 1.135 mycroft wd->sc_dk.dk_copenmask &= ~(1 << part);
840 1.135 mycroft break;
841 1.135 mycroft case S_IFBLK:
842 1.135 mycroft wd->sc_dk.dk_bopenmask &= ~(1 << part);
843 1.135 mycroft break;
844 1.135 mycroft }
845 1.181 bouyer wd->sc_dk.dk_openmask =
846 1.181 bouyer wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
847 1.135 mycroft
848 1.135 mycroft if (wd->sc_dk.dk_openmask == 0) {
849 1.194 bouyer wd_flushcache(wd, AT_WAIT);
850 1.135 mycroft /* XXXX Must wait for I/O to complete! */
851 1.187 thorpej
852 1.199 leo if (! (wd->sc_flags & WDF_KLABEL))
853 1.199 leo wd->sc_flags &= ~WDF_LOADED;
854 1.199 leo
855 1.217 bouyer wd->atabus->ata_delref(wd->drvp);
856 1.135 mycroft }
857 1.135 mycroft
858 1.181 bouyer wdunlock(wd);
859 1.135 mycroft return 0;
860 1.135 mycroft }
861 1.135 mycroft
862 1.108 mycroft void
863 1.164 thorpej wdgetdefaultlabel(wd, lp)
864 1.108 mycroft struct wd_softc *wd;
865 1.164 thorpej struct disklabel *lp;
866 1.108 mycroft {
867 1.163 bouyer
868 1.181 bouyer WDCDEBUG_PRINT(("wdgetdefaultlabel\n"), DEBUG_FUNCS);
869 1.181 bouyer memset(lp, 0, sizeof(struct disklabel));
870 1.108 mycroft
871 1.142 mycroft lp->d_secsize = DEV_BSIZE;
872 1.181 bouyer lp->d_ntracks = wd->sc_params.atap_heads;
873 1.181 bouyer lp->d_nsectors = wd->sc_params.atap_sectors;
874 1.181 bouyer lp->d_ncylinders = wd->sc_params.atap_cylinders;
875 1.142 mycroft lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
876 1.108 mycroft
877 1.198 leo if (strcmp(wd->sc_params.atap_model, "ST506") == 0)
878 1.181 bouyer lp->d_type = DTYPE_ST506;
879 1.198 leo else
880 1.181 bouyer lp->d_type = DTYPE_ESDI;
881 1.198 leo
882 1.181 bouyer strncpy(lp->d_typename, wd->sc_params.atap_model, 16);
883 1.180 drochner strncpy(lp->d_packname, "fictitious", 16);
884 1.181 bouyer lp->d_secperunit = wd->sc_capacity;
885 1.142 mycroft lp->d_rpm = 3600;
886 1.142 mycroft lp->d_interleave = 1;
887 1.142 mycroft lp->d_flags = 0;
888 1.142 mycroft
889 1.142 mycroft lp->d_partitions[RAW_PART].p_offset = 0;
890 1.142 mycroft lp->d_partitions[RAW_PART].p_size =
891 1.181 bouyer lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
892 1.142 mycroft lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
893 1.142 mycroft lp->d_npartitions = RAW_PART + 1;
894 1.142 mycroft
895 1.142 mycroft lp->d_magic = DISKMAGIC;
896 1.142 mycroft lp->d_magic2 = DISKMAGIC;
897 1.142 mycroft lp->d_checksum = dkcksum(lp);
898 1.164 thorpej }
899 1.164 thorpej
900 1.164 thorpej /*
901 1.164 thorpej * Fabricate a default disk label, and try to read the correct one.
902 1.164 thorpej */
903 1.164 thorpej void
904 1.164 thorpej wdgetdisklabel(wd)
905 1.164 thorpej struct wd_softc *wd;
906 1.164 thorpej {
907 1.164 thorpej struct disklabel *lp = wd->sc_dk.dk_label;
908 1.164 thorpej char *errstring;
909 1.164 thorpej
910 1.181 bouyer WDCDEBUG_PRINT(("wdgetdisklabel\n"), DEBUG_FUNCS);
911 1.164 thorpej
912 1.181 bouyer memset(wd->sc_dk.dk_cpulabel, 0, sizeof(struct cpu_disklabel));
913 1.164 thorpej
914 1.164 thorpej wdgetdefaultlabel(wd, lp);
915 1.108 mycroft
916 1.181 bouyer wd->sc_badsect[0] = -1;
917 1.113 mycroft
918 1.181 bouyer if (wd->drvp->state > RECAL)
919 1.183 bouyer wd->drvp->drive_flags |= DRIVE_RESET;
920 1.108 mycroft errstring = readdisklabel(MAKEWDDEV(0, wd->sc_dev.dv_unit, RAW_PART),
921 1.144 thorpej wdstrategy, lp, wd->sc_dk.dk_cpulabel);
922 1.108 mycroft if (errstring) {
923 1.108 mycroft /*
924 1.108 mycroft * This probably happened because the drive's default
925 1.108 mycroft * geometry doesn't match the DOS geometry. We
926 1.108 mycroft * assume the DOS geometry is now in the label and try
927 1.108 mycroft * again. XXX This is a kluge.
928 1.108 mycroft */
929 1.181 bouyer if (wd->drvp->state > RECAL)
930 1.183 bouyer wd->drvp->drive_flags |= DRIVE_RESET;
931 1.181 bouyer errstring = readdisklabel(MAKEWDDEV(0, wd->sc_dev.dv_unit,
932 1.181 bouyer RAW_PART), wdstrategy, lp, wd->sc_dk.dk_cpulabel);
933 1.108 mycroft }
934 1.108 mycroft if (errstring) {
935 1.153 christos printf("%s: %s\n", wd->sc_dev.dv_xname, errstring);
936 1.108 mycroft return;
937 1.108 mycroft }
938 1.108 mycroft
939 1.181 bouyer if (wd->drvp->state > RECAL)
940 1.183 bouyer wd->drvp->drive_flags |= DRIVE_RESET;
941 1.170 leo #ifdef HAS_BAD144_HANDLING
942 1.142 mycroft if ((lp->d_flags & D_BADSECT) != 0)
943 1.108 mycroft bad144intern(wd);
944 1.170 leo #endif
945 1.108 mycroft }
946 1.108 mycroft
947 1.217 bouyer void
948 1.220.10.1 lukem wdperror(wd)
949 1.220.10.1 lukem const struct wd_softc *wd;
950 1.217 bouyer {
951 1.220.10.1 lukem static const char *const errstr0_3[] = {"address mark not found",
952 1.217 bouyer "track 0 not found", "aborted command", "media change requested",
953 1.217 bouyer "id not found", "media changed", "uncorrectable data error",
954 1.217 bouyer "bad block detected"};
955 1.220.10.1 lukem static const char *const errstr4_5[] = {
956 1.220.10.1 lukem "obsolete (address mark not found)",
957 1.217 bouyer "no media/write protected", "aborted command",
958 1.217 bouyer "media change requested", "id not found", "media changed",
959 1.217 bouyer "uncorrectable data error", "interface CRC error"};
960 1.220.10.1 lukem const char *const *errstr;
961 1.217 bouyer int i;
962 1.217 bouyer char *sep = "";
963 1.217 bouyer
964 1.220.10.1 lukem const char *devname = wd->sc_dev.dv_xname;
965 1.220.10.1 lukem struct ata_drive_datas *drvp = wd->drvp;
966 1.220.10.1 lukem int errno = wd->sc_wdc_bio.r_error;
967 1.220.10.1 lukem
968 1.217 bouyer if (drvp->ata_vers >= 4)
969 1.217 bouyer errstr = errstr4_5;
970 1.217 bouyer else
971 1.217 bouyer errstr = errstr0_3;
972 1.217 bouyer
973 1.220.10.1 lukem printf("%s: (", devname);
974 1.220.10.1 lukem
975 1.217 bouyer if (errno == 0)
976 1.220.10.1 lukem printf("error not notified");
977 1.217 bouyer
978 1.217 bouyer for (i = 0; i < 8; i++) {
979 1.217 bouyer if (errno & (1 << i)) {
980 1.220.10.1 lukem printf("%s%s", sep, errstr[i]);
981 1.217 bouyer sep = ", ";
982 1.217 bouyer }
983 1.217 bouyer }
984 1.220.10.1 lukem printf(")\n");
985 1.217 bouyer }
986 1.217 bouyer
987 1.1 cgd int
988 1.163 bouyer wdioctl(dev, xfer, addr, flag, p)
989 1.55 mycroft dev_t dev;
990 1.163 bouyer u_long xfer;
991 1.55 mycroft caddr_t addr;
992 1.55 mycroft int flag;
993 1.55 mycroft struct proc *p;
994 1.1 cgd {
995 1.209 thorpej struct wd_softc *wd = device_lookup(&wd_cd, WDUNIT(dev));
996 1.54 mycroft int error;
997 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
998 1.211 fvdl struct disklabel newlabel;
999 1.211 fvdl #endif
1000 1.163 bouyer
1001 1.181 bouyer WDCDEBUG_PRINT(("wdioctl\n"), DEBUG_FUNCS);
1002 1.163 bouyer
1003 1.181 bouyer if ((wd->sc_flags & WDF_LOADED) == 0)
1004 1.108 mycroft return EIO;
1005 1.108 mycroft
1006 1.163 bouyer switch (xfer) {
1007 1.170 leo #ifdef HAS_BAD144_HANDLING
1008 1.1 cgd case DIOCSBAD:
1009 1.3 deraadt if ((flag & FWRITE) == 0)
1010 1.54 mycroft return EBADF;
1011 1.144 thorpej wd->sc_dk.dk_cpulabel->bad = *(struct dkbad *)addr;
1012 1.144 thorpej wd->sc_dk.dk_label->d_flags |= D_BADSECT;
1013 1.64 mycroft bad144intern(wd);
1014 1.54 mycroft return 0;
1015 1.170 leo #endif
1016 1.1 cgd
1017 1.1 cgd case DIOCGDINFO:
1018 1.144 thorpej *(struct disklabel *)addr = *(wd->sc_dk.dk_label);
1019 1.54 mycroft return 0;
1020 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1021 1.211 fvdl case ODIOCGDINFO:
1022 1.211 fvdl newlabel = *(wd->sc_dk.dk_label);
1023 1.211 fvdl if (newlabel.d_npartitions > OLDMAXPARTITIONS)
1024 1.212 fvdl return ENOTTY;
1025 1.211 fvdl memcpy(addr, &newlabel, sizeof (struct olddisklabel));
1026 1.211 fvdl return 0;
1027 1.211 fvdl #endif
1028 1.211 fvdl
1029 1.3 deraadt case DIOCGPART:
1030 1.144 thorpej ((struct partinfo *)addr)->disklab = wd->sc_dk.dk_label;
1031 1.3 deraadt ((struct partinfo *)addr)->part =
1032 1.144 thorpej &wd->sc_dk.dk_label->d_partitions[WDPART(dev)];
1033 1.54 mycroft return 0;
1034 1.3 deraadt
1035 1.132 mycroft case DIOCWDINFO:
1036 1.3 deraadt case DIOCSDINFO:
1037 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1038 1.211 fvdl case ODIOCWDINFO:
1039 1.211 fvdl case ODIOCSDINFO:
1040 1.211 fvdl #endif
1041 1.211 fvdl {
1042 1.211 fvdl struct disklabel *lp;
1043 1.211 fvdl
1044 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1045 1.211 fvdl if (xfer == ODIOCSDINFO || xfer == ODIOCWDINFO) {
1046 1.211 fvdl memset(&newlabel, 0, sizeof newlabel);
1047 1.211 fvdl memcpy(&newlabel, addr, sizeof (struct olddisklabel));
1048 1.211 fvdl lp = &newlabel;
1049 1.211 fvdl } else
1050 1.211 fvdl #endif
1051 1.211 fvdl lp = (struct disklabel *)addr;
1052 1.211 fvdl
1053 1.3 deraadt if ((flag & FWRITE) == 0)
1054 1.54 mycroft return EBADF;
1055 1.132 mycroft
1056 1.181 bouyer if ((error = wdlock(wd)) != 0)
1057 1.132 mycroft return error;
1058 1.181 bouyer wd->sc_flags |= WDF_LABELLING;
1059 1.132 mycroft
1060 1.144 thorpej error = setdisklabel(wd->sc_dk.dk_label,
1061 1.211 fvdl lp, /*wd->sc_dk.dk_openmask : */0,
1062 1.144 thorpej wd->sc_dk.dk_cpulabel);
1063 1.3 deraadt if (error == 0) {
1064 1.181 bouyer if (wd->drvp->state > RECAL)
1065 1.183 bouyer wd->drvp->drive_flags |= DRIVE_RESET;
1066 1.211 fvdl if (xfer == DIOCWDINFO
1067 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1068 1.211 fvdl || xfer == ODIOCWDINFO
1069 1.211 fvdl #endif
1070 1.211 fvdl )
1071 1.132 mycroft error = writedisklabel(WDLABELDEV(dev),
1072 1.144 thorpej wdstrategy, wd->sc_dk.dk_label,
1073 1.144 thorpej wd->sc_dk.dk_cpulabel);
1074 1.1 cgd }
1075 1.132 mycroft
1076 1.181 bouyer wd->sc_flags &= ~WDF_LABELLING;
1077 1.181 bouyer wdunlock(wd);
1078 1.54 mycroft return error;
1079 1.211 fvdl }
1080 1.199 leo
1081 1.199 leo case DIOCKLABEL:
1082 1.199 leo if (*(int *)addr)
1083 1.199 leo wd->sc_flags |= WDF_KLABEL;
1084 1.199 leo else
1085 1.199 leo wd->sc_flags &= ~WDF_KLABEL;
1086 1.199 leo return 0;
1087 1.3 deraadt
1088 1.44 mycroft case DIOCWLABEL:
1089 1.3 deraadt if ((flag & FWRITE) == 0)
1090 1.54 mycroft return EBADF;
1091 1.93 mycroft if (*(int *)addr)
1092 1.181 bouyer wd->sc_flags |= WDF_WLABEL;
1093 1.93 mycroft else
1094 1.181 bouyer wd->sc_flags &= ~WDF_WLABEL;
1095 1.54 mycroft return 0;
1096 1.164 thorpej
1097 1.164 thorpej case DIOCGDEFLABEL:
1098 1.164 thorpej wdgetdefaultlabel(wd, (struct disklabel *)addr);
1099 1.164 thorpej return 0;
1100 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1101 1.211 fvdl case ODIOCGDEFLABEL:
1102 1.211 fvdl wdgetdefaultlabel(wd, &newlabel);
1103 1.211 fvdl if (newlabel.d_npartitions > OLDMAXPARTITIONS)
1104 1.212 fvdl return ENOTTY;
1105 1.211 fvdl memcpy(addr, &newlabel, sizeof (struct olddisklabel));
1106 1.211 fvdl return 0;
1107 1.211 fvdl #endif
1108 1.164 thorpej
1109 1.1 cgd #ifdef notyet
1110 1.1 cgd case DIOCWFORMAT:
1111 1.1 cgd if ((flag & FWRITE) == 0)
1112 1.54 mycroft return EBADF;
1113 1.181 bouyer {
1114 1.54 mycroft register struct format_op *fop;
1115 1.54 mycroft struct iovec aiov;
1116 1.54 mycroft struct uio auio;
1117 1.181 bouyer
1118 1.54 mycroft fop = (struct format_op *)addr;
1119 1.54 mycroft aiov.iov_base = fop->df_buf;
1120 1.54 mycroft aiov.iov_len = fop->df_count;
1121 1.54 mycroft auio.uio_iov = &aiov;
1122 1.54 mycroft auio.uio_iovcnt = 1;
1123 1.54 mycroft auio.uio_resid = fop->df_count;
1124 1.54 mycroft auio.uio_segflg = 0;
1125 1.54 mycroft auio.uio_offset =
1126 1.181 bouyer fop->df_startblk * wd->sc_dk.dk_label->d_secsize;
1127 1.83 pk auio.uio_procp = p;
1128 1.64 mycroft error = physio(wdformat, NULL, dev, B_WRITE, minphys,
1129 1.64 mycroft &auio);
1130 1.54 mycroft fop->df_count -= auio.uio_resid;
1131 1.64 mycroft fop->df_reg[0] = wdc->sc_status;
1132 1.64 mycroft fop->df_reg[1] = wdc->sc_error;
1133 1.54 mycroft return error;
1134 1.181 bouyer }
1135 1.1 cgd #endif
1136 1.220.10.3 grant case DIOCGCACHE:
1137 1.220.10.3 grant return wd_getcache(wd, (int *)addr);
1138 1.220.10.3 grant
1139 1.220.10.3 grant case DIOCSCACHE:
1140 1.220.10.3 grant return wd_setcache(wd, *(int *)addr);
1141 1.185 kenh
1142 1.186 kenh case ATAIOCCOMMAND:
1143 1.185 kenh /*
1144 1.185 kenh * Make sure this command is (relatively) safe first
1145 1.185 kenh */
1146 1.186 kenh if ((((atareq_t *) addr)->flags & ATACMD_READ) == 0 &&
1147 1.185 kenh (flag & FWRITE) == 0)
1148 1.185 kenh return (EBADF);
1149 1.185 kenh {
1150 1.185 kenh struct wd_ioctl *wi;
1151 1.186 kenh atareq_t *atareq = (atareq_t *) addr;
1152 1.185 kenh int error;
1153 1.185 kenh
1154 1.185 kenh wi = wi_get();
1155 1.185 kenh wi->wi_softc = wd;
1156 1.186 kenh wi->wi_atareq = *atareq;
1157 1.185 kenh
1158 1.186 kenh if (atareq->datalen && atareq->flags &
1159 1.186 kenh (ATACMD_READ | ATACMD_WRITE)) {
1160 1.186 kenh wi->wi_iov.iov_base = atareq->databuf;
1161 1.186 kenh wi->wi_iov.iov_len = atareq->datalen;
1162 1.185 kenh wi->wi_uio.uio_iov = &wi->wi_iov;
1163 1.185 kenh wi->wi_uio.uio_iovcnt = 1;
1164 1.186 kenh wi->wi_uio.uio_resid = atareq->datalen;
1165 1.185 kenh wi->wi_uio.uio_offset = 0;
1166 1.185 kenh wi->wi_uio.uio_segflg = UIO_USERSPACE;
1167 1.185 kenh wi->wi_uio.uio_rw =
1168 1.186 kenh (atareq->flags & ATACMD_READ) ? B_READ : B_WRITE;
1169 1.185 kenh wi->wi_uio.uio_procp = p;
1170 1.185 kenh error = physio(wdioctlstrategy, &wi->wi_bp, dev,
1171 1.186 kenh (atareq->flags & ATACMD_READ) ? B_READ : B_WRITE,
1172 1.185 kenh minphys, &wi->wi_uio);
1173 1.185 kenh } else {
1174 1.185 kenh /* No need to call physio if we don't have any
1175 1.185 kenh user data */
1176 1.185 kenh wi->wi_bp.b_flags = 0;
1177 1.185 kenh wi->wi_bp.b_data = 0;
1178 1.185 kenh wi->wi_bp.b_bcount = 0;
1179 1.185 kenh wi->wi_bp.b_dev = 0;
1180 1.185 kenh wi->wi_bp.b_proc = p;
1181 1.185 kenh wdioctlstrategy(&wi->wi_bp);
1182 1.185 kenh error = wi->wi_bp.b_error;
1183 1.185 kenh }
1184 1.186 kenh *atareq = wi->wi_atareq;
1185 1.185 kenh wi_free(wi);
1186 1.185 kenh return(error);
1187 1.185 kenh }
1188 1.185 kenh
1189 1.1 cgd default:
1190 1.54 mycroft return ENOTTY;
1191 1.1 cgd }
1192 1.54 mycroft
1193 1.54 mycroft #ifdef DIAGNOSTIC
1194 1.54 mycroft panic("wdioctl: impossible");
1195 1.54 mycroft #endif
1196 1.1 cgd }
1197 1.1 cgd
1198 1.44 mycroft #ifdef B_FORMAT
1199 1.1 cgd int
1200 1.1 cgd wdformat(struct buf *bp)
1201 1.1 cgd {
1202 1.44 mycroft
1203 1.1 cgd bp->b_flags |= B_FORMAT;
1204 1.37 mycroft return wdstrategy(bp);
1205 1.1 cgd }
1206 1.1 cgd #endif
1207 1.1 cgd
1208 1.1 cgd int
1209 1.55 mycroft wdsize(dev)
1210 1.55 mycroft dev_t dev;
1211 1.1 cgd {
1212 1.64 mycroft struct wd_softc *wd;
1213 1.208 thorpej int part, omask;
1214 1.108 mycroft int size;
1215 1.163 bouyer
1216 1.181 bouyer WDCDEBUG_PRINT(("wdsize\n"), DEBUG_FUNCS);
1217 1.163 bouyer
1218 1.208 thorpej wd = device_lookup(&wd_cd, WDUNIT(dev));
1219 1.158 pk if (wd == NULL)
1220 1.158 pk return (-1);
1221 1.158 pk
1222 1.158 pk part = WDPART(dev);
1223 1.158 pk omask = wd->sc_dk.dk_openmask & (1 << part);
1224 1.158 pk
1225 1.158 pk if (omask == 0 && wdopen(dev, 0, S_IFBLK, NULL) != 0)
1226 1.158 pk return (-1);
1227 1.144 thorpej if (wd->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
1228 1.108 mycroft size = -1;
1229 1.108 mycroft else
1230 1.160 thorpej size = wd->sc_dk.dk_label->d_partitions[part].p_size *
1231 1.181 bouyer (wd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
1232 1.158 pk if (omask == 0 && wdclose(dev, 0, S_IFBLK, NULL) != 0)
1233 1.158 pk return (-1);
1234 1.158 pk return (size);
1235 1.1 cgd }
1236 1.1 cgd
1237 1.140 cgd /* #define WD_DUMP_NOT_TRUSTED if you just want to watch */
1238 1.181 bouyer static int wddoingadump = 0;
1239 1.181 bouyer static int wddumprecalibrated = 0;
1240 1.181 bouyer static int wddumpmulti = 1;
1241 1.140 cgd
1242 1.64 mycroft /*
1243 1.64 mycroft * Dump core after a system crash.
1244 1.64 mycroft */
1245 1.1 cgd int
1246 1.140 cgd wddump(dev, blkno, va, size)
1247 1.181 bouyer dev_t dev;
1248 1.181 bouyer daddr_t blkno;
1249 1.181 bouyer caddr_t va;
1250 1.181 bouyer size_t size;
1251 1.140 cgd {
1252 1.140 cgd struct wd_softc *wd; /* disk unit to do the I/O */
1253 1.181 bouyer struct disklabel *lp; /* disk's disklabel */
1254 1.208 thorpej int part, err;
1255 1.181 bouyer int nblks; /* total number of sectors left to write */
1256 1.140 cgd
1257 1.140 cgd /* Check if recursive dump; if so, punt. */
1258 1.116 mycroft if (wddoingadump)
1259 1.116 mycroft return EFAULT;
1260 1.142 mycroft wddoingadump = 1;
1261 1.140 cgd
1262 1.208 thorpej wd = device_lookup(&wd_cd, WDUNIT(dev));
1263 1.208 thorpej if (wd == NULL)
1264 1.208 thorpej return (ENXIO);
1265 1.60 mycroft
1266 1.140 cgd part = WDPART(dev);
1267 1.140 cgd
1268 1.140 cgd /* Make sure it was initialized. */
1269 1.181 bouyer if (wd->drvp->state < READY)
1270 1.37 mycroft return ENXIO;
1271 1.140 cgd
1272 1.181 bouyer /* Convert to disk sectors. Request must be a multiple of size. */
1273 1.144 thorpej lp = wd->sc_dk.dk_label;
1274 1.142 mycroft if ((size % lp->d_secsize) != 0)
1275 1.140 cgd return EFAULT;
1276 1.142 mycroft nblks = size / lp->d_secsize;
1277 1.142 mycroft blkno = blkno / (lp->d_secsize / DEV_BSIZE);
1278 1.116 mycroft
1279 1.64 mycroft /* Check transfer bounds against partition size. */
1280 1.142 mycroft if ((blkno < 0) || ((blkno + nblks) > lp->d_partitions[part].p_size))
1281 1.140 cgd return EINVAL;
1282 1.140 cgd
1283 1.140 cgd /* Offset block number to start of partition. */
1284 1.142 mycroft blkno += lp->d_partitions[part].p_offset;
1285 1.60 mycroft
1286 1.140 cgd /* Recalibrate, if first dump transfer. */
1287 1.140 cgd if (wddumprecalibrated == 0) {
1288 1.181 bouyer wddumpmulti = wd->sc_multi;
1289 1.140 cgd wddumprecalibrated = 1;
1290 1.205 bouyer wd->drvp->state = RESET;
1291 1.63 mycroft }
1292 1.181 bouyer
1293 1.142 mycroft while (nblks > 0) {
1294 1.181 bouyer again:
1295 1.214 bjh21 wd->sc_bp = NULL;
1296 1.181 bouyer wd->sc_wdc_bio.blkno = blkno;
1297 1.181 bouyer wd->sc_wdc_bio.flags = ATA_POLL;
1298 1.181 bouyer if (wddumpmulti == 1)
1299 1.181 bouyer wd->sc_wdc_bio.flags |= ATA_SINGLE;
1300 1.220 christos if (wd->sc_flags & WDF_LBA48)
1301 1.220 christos wd->sc_wdc_bio.flags |= ATA_LBA48;
1302 1.181 bouyer if (wd->sc_flags & WDF_LBA)
1303 1.181 bouyer wd->sc_wdc_bio.flags |= ATA_LBA;
1304 1.181 bouyer wd->sc_wdc_bio.bcount =
1305 1.181 bouyer min(nblks, wddumpmulti) * lp->d_secsize;
1306 1.181 bouyer wd->sc_wdc_bio.databuf = va;
1307 1.181 bouyer #ifndef WD_DUMP_NOT_TRUSTED
1308 1.217 bouyer switch (wd->atabus->ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
1309 1.181 bouyer case WDC_TRY_AGAIN:
1310 1.181 bouyer panic("wddump: try again");
1311 1.181 bouyer break;
1312 1.181 bouyer case WDC_QUEUED:
1313 1.181 bouyer panic("wddump: polled command has been queued");
1314 1.181 bouyer break;
1315 1.181 bouyer case WDC_COMPLETE:
1316 1.181 bouyer break;
1317 1.116 mycroft }
1318 1.181 bouyer switch(wd->sc_wdc_bio.error) {
1319 1.181 bouyer case TIMEOUT:
1320 1.181 bouyer printf("wddump: device timed out");
1321 1.181 bouyer err = EIO;
1322 1.181 bouyer break;
1323 1.181 bouyer case ERR_DF:
1324 1.181 bouyer printf("wddump: drive fault");
1325 1.181 bouyer err = EIO;
1326 1.181 bouyer break;
1327 1.181 bouyer case ERR_DMA:
1328 1.181 bouyer printf("wddump: DMA error");
1329 1.181 bouyer err = EIO;
1330 1.181 bouyer break;
1331 1.181 bouyer case ERROR:
1332 1.220.10.1 lukem printf("wddump: ");
1333 1.220.10.2 lukem wdperror(wd);
1334 1.181 bouyer err = EIO;
1335 1.181 bouyer break;
1336 1.181 bouyer case NOERROR:
1337 1.181 bouyer err = 0;
1338 1.181 bouyer break;
1339 1.181 bouyer default:
1340 1.181 bouyer panic("wddump: unknown error type");
1341 1.3 deraadt }
1342 1.181 bouyer if (err != 0) {
1343 1.181 bouyer if (wddumpmulti != 1) {
1344 1.181 bouyer wddumpmulti = 1; /* retry in single-sector */
1345 1.181 bouyer printf(", retrying\n");
1346 1.181 bouyer goto again;
1347 1.181 bouyer }
1348 1.181 bouyer printf("\n");
1349 1.181 bouyer return err;
1350 1.63 mycroft }
1351 1.140 cgd #else /* WD_DUMP_NOT_TRUSTED */
1352 1.140 cgd /* Let's just talk about this first... */
1353 1.153 christos printf("wd%d: dump addr 0x%x, cylin %d, head %d, sector %d\n",
1354 1.140 cgd unit, va, cylin, head, sector);
1355 1.140 cgd delay(500 * 1000); /* half a second */
1356 1.140 cgd #endif
1357 1.1 cgd
1358 1.140 cgd /* update block count */
1359 1.181 bouyer nblks -= min(nblks, wddumpmulti);
1360 1.181 bouyer blkno += min(nblks, wddumpmulti);
1361 1.181 bouyer va += min(nblks, wddumpmulti) * lp->d_secsize;
1362 1.1 cgd }
1363 1.142 mycroft
1364 1.140 cgd wddoingadump = 0;
1365 1.140 cgd return 0;
1366 1.140 cgd }
1367 1.3 deraadt
1368 1.170 leo #ifdef HAS_BAD144_HANDLING
1369 1.3 deraadt /*
1370 1.3 deraadt * Internalize the bad sector table.
1371 1.3 deraadt */
1372 1.3 deraadt void
1373 1.64 mycroft bad144intern(wd)
1374 1.64 mycroft struct wd_softc *wd;
1375 1.3 deraadt {
1376 1.144 thorpej struct dkbad *bt = &wd->sc_dk.dk_cpulabel->bad;
1377 1.144 thorpej struct disklabel *lp = wd->sc_dk.dk_label;
1378 1.98 mycroft int i = 0;
1379 1.55 mycroft
1380 1.182 bouyer WDCDEBUG_PRINT(("bad144intern\n"), DEBUG_XFERS);
1381 1.163 bouyer
1382 1.170 leo for (; i < NBT_BAD; i++) {
1383 1.98 mycroft if (bt->bt_bad[i].bt_cyl == 0xffff)
1384 1.55 mycroft break;
1385 1.181 bouyer wd->sc_badsect[i] =
1386 1.98 mycroft bt->bt_bad[i].bt_cyl * lp->d_secpercyl +
1387 1.98 mycroft (bt->bt_bad[i].bt_trksec >> 8) * lp->d_nsectors +
1388 1.98 mycroft (bt->bt_bad[i].bt_trksec & 0xff);
1389 1.3 deraadt }
1390 1.170 leo for (; i < NBT_BAD+1; i++)
1391 1.181 bouyer wd->sc_badsect[i] = -1;
1392 1.64 mycroft }
1393 1.170 leo #endif
1394 1.64 mycroft
1395 1.181 bouyer int
1396 1.181 bouyer wd_get_params(wd, flags, params)
1397 1.181 bouyer struct wd_softc *wd;
1398 1.181 bouyer u_int8_t flags;
1399 1.181 bouyer struct ataparams *params;
1400 1.63 mycroft {
1401 1.217 bouyer switch (wd->atabus->ata_get_params(wd->drvp, flags, params)) {
1402 1.181 bouyer case CMD_AGAIN:
1403 1.181 bouyer return 1;
1404 1.181 bouyer case CMD_ERR:
1405 1.181 bouyer /*
1406 1.181 bouyer * We `know' there's a drive here; just assume it's old.
1407 1.181 bouyer * This geometry is only used to read the MBR and print a
1408 1.181 bouyer * (false) attach message.
1409 1.181 bouyer */
1410 1.181 bouyer strncpy(params->atap_model, "ST506",
1411 1.181 bouyer sizeof params->atap_model);
1412 1.181 bouyer params->atap_config = ATA_CFG_FIXED;
1413 1.181 bouyer params->atap_cylinders = 1024;
1414 1.181 bouyer params->atap_heads = 8;
1415 1.181 bouyer params->atap_sectors = 17;
1416 1.181 bouyer params->atap_multi = 1;
1417 1.181 bouyer params->atap_capabilities1 = params->atap_capabilities2 = 0;
1418 1.190 bouyer wd->drvp->ata_vers = -1; /* Mark it as pre-ATA */
1419 1.181 bouyer return 0;
1420 1.181 bouyer case CMD_OK:
1421 1.181 bouyer return 0;
1422 1.181 bouyer default:
1423 1.181 bouyer panic("wd_get_params: bad return code from ata_get_params");
1424 1.181 bouyer /* NOTREACHED */
1425 1.181 bouyer }
1426 1.220.10.3 grant }
1427 1.220.10.3 grant
1428 1.220.10.3 grant int
1429 1.220.10.3 grant wd_getcache(wd, bitsp)
1430 1.220.10.3 grant struct wd_softc *wd;
1431 1.220.10.3 grant int *bitsp;
1432 1.220.10.3 grant {
1433 1.220.10.3 grant struct ataparams params;
1434 1.220.10.3 grant
1435 1.220.10.3 grant if (wd_get_params(wd, AT_WAIT, ¶ms) != 0)
1436 1.220.10.3 grant return EIO;
1437 1.220.10.3 grant if (params.atap_cmd_set1 == 0x0000 ||
1438 1.220.10.3 grant params.atap_cmd_set1 == 0xffff ||
1439 1.220.10.3 grant (params.atap_cmd_set1 & WDC_CMD1_CACHE) == 0) {
1440 1.220.10.3 grant *bitsp = 0;
1441 1.220.10.3 grant return 0;
1442 1.220.10.3 grant }
1443 1.220.10.3 grant *bitsp = DKCACHE_WCHANGE | DKCACHE_READ;
1444 1.220.10.3 grant if (params.atap_cmd1_en & WDC_CMD1_CACHE)
1445 1.220.10.3 grant *bitsp |= DKCACHE_WRITE;
1446 1.220.10.3 grant
1447 1.220.10.3 grant return 0;
1448 1.220.10.3 grant }
1449 1.220.10.3 grant
1450 1.220.10.3 grant int
1451 1.220.10.3 grant wd_setcache(wd, bits)
1452 1.220.10.3 grant struct wd_softc *wd;
1453 1.220.10.3 grant int bits;
1454 1.220.10.3 grant {
1455 1.220.10.3 grant struct ataparams params;
1456 1.220.10.3 grant struct wdc_command wdc_c;
1457 1.220.10.3 grant
1458 1.220.10.3 grant if (wd_get_params(wd, AT_WAIT, ¶ms) != 0)
1459 1.220.10.3 grant return EIO;
1460 1.220.10.3 grant
1461 1.220.10.3 grant if (params.atap_cmd_set1 == 0x0000 ||
1462 1.220.10.3 grant params.atap_cmd_set1 == 0xffff ||
1463 1.220.10.3 grant (params.atap_cmd_set1 & WDC_CMD1_CACHE) == 0)
1464 1.220.10.3 grant return EOPNOTSUPP;
1465 1.220.10.3 grant
1466 1.220.10.3 grant if ((bits & DKCACHE_READ) == 0 ||
1467 1.220.10.3 grant (bits & DKCACHE_SAVE) != 0)
1468 1.220.10.3 grant return EOPNOTSUPP;
1469 1.220.10.3 grant
1470 1.220.10.3 grant memset(&wdc_c, 0, sizeof(struct wdc_command));
1471 1.220.10.3 grant wdc_c.r_command = SET_FEATURES;
1472 1.220.10.3 grant wdc_c.r_st_bmask = 0;
1473 1.220.10.3 grant wdc_c.r_st_pmask = 0;
1474 1.220.10.3 grant wdc_c.timeout = 30000; /* 30s timeout */
1475 1.220.10.3 grant wdc_c.flags = AT_WAIT;
1476 1.220.10.3 grant if (bits & DKCACHE_WRITE)
1477 1.220.10.3 grant wdc_c.r_precomp = WDSF_WRITE_CACHE_EN;
1478 1.220.10.3 grant else
1479 1.220.10.3 grant wdc_c.r_precomp = WDSF_WRITE_CACHE_DS;
1480 1.220.10.3 grant if (wd->atabus->ata_exec_command(wd->drvp, &wdc_c) != WDC_COMPLETE) {
1481 1.220.10.3 grant printf("%s: wd_setcache command not complete\n",
1482 1.220.10.3 grant wd->sc_dev.dv_xname);
1483 1.220.10.3 grant return EIO;
1484 1.220.10.3 grant }
1485 1.220.10.3 grant if (wdc_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
1486 1.220.10.3 grant printf("%s: wd_setcache command error 0x%x\n",
1487 1.220.10.3 grant wd->sc_dev.dv_xname, wdc_c.flags);
1488 1.220.10.3 grant return EIO;
1489 1.220.10.3 grant }
1490 1.220.10.3 grant if (wdc_c.flags & ERR_NODEV)
1491 1.220.10.3 grant return ENODEV;
1492 1.220.10.3 grant return 0;
1493 1.190 bouyer }
1494 1.190 bouyer
1495 1.190 bouyer void
1496 1.190 bouyer wd_flushcache(wd, flags)
1497 1.190 bouyer struct wd_softc *wd;
1498 1.190 bouyer int flags;
1499 1.190 bouyer {
1500 1.190 bouyer struct wdc_command wdc_c;
1501 1.190 bouyer
1502 1.190 bouyer if (wd->drvp->ata_vers < 4) /* WDCC_FLUSHCACHE is here since ATA-4 */
1503 1.190 bouyer return;
1504 1.190 bouyer memset(&wdc_c, 0, sizeof(struct wdc_command));
1505 1.190 bouyer wdc_c.r_command = WDCC_FLUSHCACHE;
1506 1.190 bouyer wdc_c.r_st_bmask = WDCS_DRDY;
1507 1.190 bouyer wdc_c.r_st_pmask = WDCS_DRDY;
1508 1.194 bouyer wdc_c.flags = flags;
1509 1.190 bouyer wdc_c.timeout = 30000; /* 30s timeout */
1510 1.217 bouyer if (wd->atabus->ata_exec_command(wd->drvp, &wdc_c) != WDC_COMPLETE) {
1511 1.190 bouyer printf("%s: flush cache command didn't complete\n",
1512 1.190 bouyer wd->sc_dev.dv_xname);
1513 1.190 bouyer }
1514 1.190 bouyer if (wdc_c.flags & AT_TIMEOU) {
1515 1.190 bouyer printf("%s: flush cache command timeout\n",
1516 1.190 bouyer wd->sc_dev.dv_xname);
1517 1.190 bouyer }
1518 1.190 bouyer if (wdc_c.flags & AT_DF) {
1519 1.190 bouyer printf("%s: flush cache command: drive fault\n",
1520 1.190 bouyer wd->sc_dev.dv_xname);
1521 1.190 bouyer }
1522 1.190 bouyer /*
1523 1.190 bouyer * Ignore error register, it shouldn't report anything else
1524 1.190 bouyer * than COMMAND ABORTED, which means the device doesn't support
1525 1.190 bouyer * flush cache
1526 1.190 bouyer */
1527 1.190 bouyer }
1528 1.190 bouyer
1529 1.190 bouyer void
1530 1.190 bouyer wd_shutdown(arg)
1531 1.190 bouyer void *arg;
1532 1.190 bouyer {
1533 1.190 bouyer struct wd_softc *wd = arg;
1534 1.194 bouyer wd_flushcache(wd, AT_POLL);
1535 1.185 kenh }
1536 1.185 kenh
1537 1.185 kenh /*
1538 1.185 kenh * Allocate space for a ioctl queue structure. Mostly taken from
1539 1.185 kenh * scsipi_ioctl.c
1540 1.185 kenh */
1541 1.185 kenh struct wd_ioctl *
1542 1.185 kenh wi_get()
1543 1.185 kenh {
1544 1.185 kenh struct wd_ioctl *wi;
1545 1.185 kenh int s;
1546 1.185 kenh
1547 1.219 tsutsui wi = malloc(sizeof(struct wd_ioctl), M_TEMP, M_WAITOK|M_ZERO);
1548 1.185 kenh s = splbio();
1549 1.185 kenh LIST_INSERT_HEAD(&wi_head, wi, wi_list);
1550 1.185 kenh splx(s);
1551 1.185 kenh return (wi);
1552 1.185 kenh }
1553 1.185 kenh
1554 1.185 kenh /*
1555 1.185 kenh * Free an ioctl structure and remove it from our list
1556 1.185 kenh */
1557 1.185 kenh
1558 1.185 kenh void
1559 1.185 kenh wi_free(wi)
1560 1.185 kenh struct wd_ioctl *wi;
1561 1.185 kenh {
1562 1.185 kenh int s;
1563 1.185 kenh
1564 1.185 kenh s = splbio();
1565 1.185 kenh LIST_REMOVE(wi, wi_list);
1566 1.185 kenh splx(s);
1567 1.185 kenh free(wi, M_TEMP);
1568 1.185 kenh }
1569 1.185 kenh
1570 1.185 kenh /*
1571 1.185 kenh * Find a wd_ioctl structure based on the struct buf.
1572 1.185 kenh */
1573 1.185 kenh
1574 1.185 kenh struct wd_ioctl *
1575 1.185 kenh wi_find(bp)
1576 1.185 kenh struct buf *bp;
1577 1.185 kenh {
1578 1.185 kenh struct wd_ioctl *wi;
1579 1.185 kenh int s;
1580 1.185 kenh
1581 1.185 kenh s = splbio();
1582 1.185 kenh for (wi = wi_head.lh_first; wi != 0; wi = wi->wi_list.le_next)
1583 1.185 kenh if (bp == &wi->wi_bp)
1584 1.185 kenh break;
1585 1.185 kenh splx(s);
1586 1.185 kenh return (wi);
1587 1.185 kenh }
1588 1.185 kenh
1589 1.185 kenh /*
1590 1.185 kenh * Ioctl pseudo strategy routine
1591 1.185 kenh *
1592 1.185 kenh * This is mostly stolen from scsipi_ioctl.c:scsistrategy(). What
1593 1.185 kenh * happens here is:
1594 1.185 kenh *
1595 1.185 kenh * - wdioctl() queues a wd_ioctl structure.
1596 1.185 kenh *
1597 1.185 kenh * - wdioctl() calls physio/wdioctlstrategy based on whether or not
1598 1.185 kenh * user space I/O is required. If physio() is called, physio() eventually
1599 1.185 kenh * calls wdioctlstrategy().
1600 1.185 kenh *
1601 1.217 bouyer * - In either case, wdioctlstrategy() calls wd->atabus->ata_exec_command()
1602 1.185 kenh * to perform the actual command
1603 1.185 kenh *
1604 1.185 kenh * The reason for the use of the pseudo strategy routine is because
1605 1.185 kenh * when doing I/O to/from user space, physio _really_ wants to be in
1606 1.185 kenh * the loop. We could put the entire buffer into the ioctl request
1607 1.185 kenh * structure, but that won't scale if we want to do things like download
1608 1.185 kenh * microcode.
1609 1.185 kenh */
1610 1.185 kenh
1611 1.185 kenh void
1612 1.185 kenh wdioctlstrategy(bp)
1613 1.185 kenh struct buf *bp;
1614 1.185 kenh {
1615 1.185 kenh struct wd_ioctl *wi;
1616 1.185 kenh struct wdc_command wdc_c;
1617 1.185 kenh int error = 0;
1618 1.185 kenh
1619 1.185 kenh wi = wi_find(bp);
1620 1.185 kenh if (wi == NULL) {
1621 1.185 kenh printf("user_strat: No ioctl\n");
1622 1.185 kenh error = EINVAL;
1623 1.185 kenh goto bad;
1624 1.185 kenh }
1625 1.185 kenh
1626 1.185 kenh memset(&wdc_c, 0, sizeof(wdc_c));
1627 1.185 kenh
1628 1.185 kenh /*
1629 1.185 kenh * Abort if physio broke up the transfer
1630 1.185 kenh */
1631 1.185 kenh
1632 1.186 kenh if (bp->b_bcount != wi->wi_atareq.datalen) {
1633 1.185 kenh printf("physio split wd ioctl request... cannot proceed\n");
1634 1.185 kenh error = EIO;
1635 1.185 kenh goto bad;
1636 1.185 kenh }
1637 1.185 kenh
1638 1.185 kenh /*
1639 1.185 kenh * Abort if we didn't get a buffer size that was a multiple of
1640 1.185 kenh * our sector size (or was larger than NBBY)
1641 1.185 kenh */
1642 1.185 kenh
1643 1.185 kenh if ((bp->b_bcount % wi->wi_softc->sc_dk.dk_label->d_secsize) != 0 ||
1644 1.185 kenh (bp->b_bcount / wi->wi_softc->sc_dk.dk_label->d_secsize) >=
1645 1.185 kenh (1 << NBBY)) {
1646 1.185 kenh error = EINVAL;
1647 1.185 kenh goto bad;
1648 1.185 kenh }
1649 1.185 kenh
1650 1.185 kenh /*
1651 1.185 kenh * Make sure a timeout was supplied in the ioctl request
1652 1.185 kenh */
1653 1.185 kenh
1654 1.186 kenh if (wi->wi_atareq.timeout == 0) {
1655 1.185 kenh error = EINVAL;
1656 1.185 kenh goto bad;
1657 1.185 kenh }
1658 1.185 kenh
1659 1.186 kenh if (wi->wi_atareq.flags & ATACMD_READ)
1660 1.185 kenh wdc_c.flags |= AT_READ;
1661 1.186 kenh else if (wi->wi_atareq.flags & ATACMD_WRITE)
1662 1.185 kenh wdc_c.flags |= AT_WRITE;
1663 1.185 kenh
1664 1.188 kenh if (wi->wi_atareq.flags & ATACMD_READREG)
1665 1.188 kenh wdc_c.flags |= AT_READREG;
1666 1.188 kenh
1667 1.185 kenh wdc_c.flags |= AT_WAIT;
1668 1.185 kenh
1669 1.186 kenh wdc_c.timeout = wi->wi_atareq.timeout;
1670 1.186 kenh wdc_c.r_command = wi->wi_atareq.command;
1671 1.186 kenh wdc_c.r_head = wi->wi_atareq.head & 0x0f;
1672 1.186 kenh wdc_c.r_cyl = wi->wi_atareq.cylinder;
1673 1.186 kenh wdc_c.r_sector = wi->wi_atareq.sec_num;
1674 1.186 kenh wdc_c.r_count = wi->wi_atareq.sec_count;
1675 1.186 kenh wdc_c.r_precomp = wi->wi_atareq.features;
1676 1.185 kenh wdc_c.r_st_bmask = WDCS_DRDY;
1677 1.185 kenh wdc_c.r_st_pmask = WDCS_DRDY;
1678 1.185 kenh wdc_c.data = wi->wi_bp.b_data;
1679 1.185 kenh wdc_c.bcount = wi->wi_bp.b_bcount;
1680 1.185 kenh
1681 1.217 bouyer if (wi->wi_softc->atabus->ata_exec_command(wi->wi_softc->drvp, &wdc_c)
1682 1.217 bouyer != WDC_COMPLETE) {
1683 1.186 kenh wi->wi_atareq.retsts = ATACMD_ERROR;
1684 1.185 kenh goto bad;
1685 1.185 kenh }
1686 1.185 kenh
1687 1.185 kenh if (wdc_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
1688 1.185 kenh if (wdc_c.flags & AT_ERROR) {
1689 1.186 kenh wi->wi_atareq.retsts = ATACMD_ERROR;
1690 1.186 kenh wi->wi_atareq.error = wdc_c.r_error;
1691 1.185 kenh } else if (wdc_c.flags & AT_DF)
1692 1.186 kenh wi->wi_atareq.retsts = ATACMD_DF;
1693 1.185 kenh else
1694 1.186 kenh wi->wi_atareq.retsts = ATACMD_TIMEOUT;
1695 1.188 kenh } else {
1696 1.186 kenh wi->wi_atareq.retsts = ATACMD_OK;
1697 1.188 kenh if (wi->wi_atareq.flags & ATACMD_READREG) {
1698 1.188 kenh wi->wi_atareq.head = wdc_c.r_head ;
1699 1.188 kenh wi->wi_atareq.cylinder = wdc_c.r_cyl;
1700 1.188 kenh wi->wi_atareq.sec_num = wdc_c.r_sector;
1701 1.188 kenh wi->wi_atareq.sec_count = wdc_c.r_count;
1702 1.188 kenh wi->wi_atareq.features = wdc_c.r_precomp;
1703 1.188 kenh wi->wi_atareq.error = wdc_c.r_error;
1704 1.188 kenh }
1705 1.188 kenh }
1706 1.185 kenh
1707 1.185 kenh bp->b_error = 0;
1708 1.185 kenh biodone(bp);
1709 1.185 kenh return;
1710 1.185 kenh bad:
1711 1.185 kenh bp->b_flags |= B_ERROR;
1712 1.185 kenh bp->b_error = error;
1713 1.185 kenh biodone(bp);
1714 1.21 deraadt }
1715