wd.c revision 1.392 1 1.392 tls /* $NetBSD: wd.c,v 1.392 2012/02/02 19:43:02 tls 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 *
15 1.181 bouyer * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 1.181 bouyer * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 1.181 bouyer * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 1.259 dsl * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 1.181 bouyer * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 1.181 bouyer * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 1.181 bouyer * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 1.181 bouyer * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 1.181 bouyer * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 1.181 bouyer * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 1.181 bouyer */
26 1.100 cgd
27 1.178 mycroft /*-
28 1.280 mycroft * Copyright (c) 1998, 2003, 2004 The NetBSD Foundation, Inc.
29 1.178 mycroft * All rights reserved.
30 1.119 mycroft *
31 1.178 mycroft * This code is derived from software contributed to The NetBSD Foundation
32 1.178 mycroft * by Charles M. Hannum and by Onno van der Linden.
33 1.168 cgd *
34 1.113 mycroft * Redistribution and use in source and binary forms, with or without
35 1.113 mycroft * modification, are permitted provided that the following conditions
36 1.113 mycroft * are met:
37 1.113 mycroft * 1. Redistributions of source code must retain the above copyright
38 1.113 mycroft * notice, this list of conditions and the following disclaimer.
39 1.113 mycroft * 2. Redistributions in binary form must reproduce the above copyright
40 1.113 mycroft * notice, this list of conditions and the following disclaimer in the
41 1.113 mycroft * documentation and/or other materials provided with the distribution.
42 1.113 mycroft *
43 1.178 mycroft * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
44 1.178 mycroft * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
45 1.178 mycroft * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
46 1.178 mycroft * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
47 1.178 mycroft * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
48 1.178 mycroft * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
49 1.178 mycroft * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
50 1.178 mycroft * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
51 1.178 mycroft * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
52 1.178 mycroft * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
53 1.178 mycroft * POSSIBILITY OF SUCH DAMAGE.
54 1.1 cgd */
55 1.215 lukem
56 1.215 lukem #include <sys/cdefs.h>
57 1.392 tls __KERNEL_RCSID(0, "$NetBSD: wd.c,v 1.392 2012/02/02 19:43:02 tls Exp $");
58 1.1 cgd
59 1.338 dyoung #include "opt_ata.h"
60 1.181 bouyer
61 1.29 mycroft #include <sys/param.h>
62 1.29 mycroft #include <sys/systm.h>
63 1.43 mycroft #include <sys/kernel.h>
64 1.29 mycroft #include <sys/conf.h>
65 1.29 mycroft #include <sys/file.h>
66 1.29 mycroft #include <sys/stat.h>
67 1.29 mycroft #include <sys/ioctl.h>
68 1.29 mycroft #include <sys/buf.h>
69 1.296 yamt #include <sys/bufq.h>
70 1.29 mycroft #include <sys/uio.h>
71 1.29 mycroft #include <sys/malloc.h>
72 1.64 mycroft #include <sys/device.h>
73 1.94 mycroft #include <sys/disklabel.h>
74 1.94 mycroft #include <sys/disk.h>
75 1.29 mycroft #include <sys/syslog.h>
76 1.149 christos #include <sys/proc.h>
77 1.354 joerg #include <sys/reboot.h>
78 1.196 enami #include <sys/vnode.h>
79 1.165 explorer #include <sys/rnd.h>
80 1.29 mycroft
81 1.347 ad #include <sys/intr.h>
82 1.347 ad #include <sys/bus.h>
83 1.237 thorpej
84 1.181 bouyer #include <dev/ata/atareg.h>
85 1.181 bouyer #include <dev/ata/atavar.h>
86 1.181 bouyer #include <dev/ata/wdvar.h>
87 1.181 bouyer #include <dev/ic/wdcreg.h>
88 1.186 kenh #include <sys/ataio.h>
89 1.163 bouyer #include "locators.h"
90 1.1 cgd
91 1.330 thorpej #include <prop/proplib.h>
92 1.330 thorpej
93 1.189 bouyer #define WDIORETRIES_SINGLE 4 /* number of retries before single-sector */
94 1.181 bouyer #define WDIORETRIES 5 /* number of retries before giving up */
95 1.181 bouyer #define RECOVERYTIME hz/2 /* time to wait before retrying a cmd */
96 1.23 deraadt
97 1.181 bouyer #define WDUNIT(dev) DISKUNIT(dev)
98 1.181 bouyer #define WDPART(dev) DISKPART(dev)
99 1.196 enami #define WDMINOR(unit, part) DISKMINOR(unit, part)
100 1.92 cgd #define MAKEWDDEV(maj, unit, part) MAKEDISKDEV(maj, unit, part)
101 1.92 cgd
102 1.92 cgd #define WDLABELDEV(dev) (MAKEWDDEV(major(dev), WDUNIT(dev), RAW_PART))
103 1.1 cgd
104 1.181 bouyer #define DEBUG_INTR 0x01
105 1.181 bouyer #define DEBUG_XFERS 0x02
106 1.181 bouyer #define DEBUG_STATUS 0x04
107 1.181 bouyer #define DEBUG_FUNCS 0x08
108 1.181 bouyer #define DEBUG_PROBE 0x10
109 1.289 thorpej #ifdef ATADEBUG
110 1.298 perry int wdcdebug_wd_mask = 0x0;
111 1.289 thorpej #define ATADEBUG_PRINT(args, level) \
112 1.181 bouyer if (wdcdebug_wd_mask & (level)) \
113 1.181 bouyer printf args
114 1.163 bouyer #else
115 1.289 thorpej #define ATADEBUG_PRINT(args, level)
116 1.163 bouyer #endif
117 1.181 bouyer
118 1.373 cegger int wdprobe(device_t, cfdata_t, void *);
119 1.373 cegger void wdattach(device_t, device_t, void *);
120 1.373 cegger int wddetach(device_t, int);
121 1.259 dsl int wdprint(void *, char *);
122 1.259 dsl void wdperror(const struct wd_softc *);
123 1.102 mycroft
124 1.388 jakllsch static void wdminphys(struct buf *);
125 1.388 jakllsch
126 1.376 dyoung static int wdlastclose(device_t);
127 1.384 dyoung static bool wd_suspend(device_t, const pmf_qual_t *);
128 1.353 jmcneill static int wd_standby(struct wd_softc *, int);
129 1.351 jmcneill
130 1.371 dyoung CFATTACH_DECL3_NEW(wd, sizeof(struct wd_softc),
131 1.375 dyoung wdprobe, wdattach, wddetach, NULL, NULL, NULL, DVF_DETACH_SHUTDOWN);
132 1.147 thorpej
133 1.167 thorpej extern struct cfdriver wd_cd;
134 1.108 mycroft
135 1.225 gehenna dev_type_open(wdopen);
136 1.225 gehenna dev_type_close(wdclose);
137 1.225 gehenna dev_type_read(wdread);
138 1.225 gehenna dev_type_write(wdwrite);
139 1.225 gehenna dev_type_ioctl(wdioctl);
140 1.225 gehenna dev_type_strategy(wdstrategy);
141 1.225 gehenna dev_type_dump(wddump);
142 1.225 gehenna dev_type_size(wdsize);
143 1.225 gehenna
144 1.225 gehenna const struct bdevsw wd_bdevsw = {
145 1.225 gehenna wdopen, wdclose, wdstrategy, wdioctl, wddump, wdsize, D_DISK
146 1.225 gehenna };
147 1.225 gehenna
148 1.225 gehenna const struct cdevsw wd_cdevsw = {
149 1.225 gehenna wdopen, wdclose, wdread, wdwrite, wdioctl,
150 1.231 jdolecek nostop, notty, nopoll, nommap, nokqfilter, D_DISK
151 1.225 gehenna };
152 1.225 gehenna
153 1.185 kenh /*
154 1.185 kenh * Glue necessary to hook WDCIOCCOMMAND into physio
155 1.185 kenh */
156 1.185 kenh
157 1.185 kenh struct wd_ioctl {
158 1.185 kenh LIST_ENTRY(wd_ioctl) wi_list;
159 1.185 kenh struct buf wi_bp;
160 1.185 kenh struct uio wi_uio;
161 1.185 kenh struct iovec wi_iov;
162 1.186 kenh atareq_t wi_atareq;
163 1.185 kenh struct wd_softc *wi_softc;
164 1.185 kenh };
165 1.185 kenh
166 1.185 kenh LIST_HEAD(, wd_ioctl) wi_head;
167 1.185 kenh
168 1.259 dsl struct wd_ioctl *wi_find(struct buf *);
169 1.259 dsl void wi_free(struct wd_ioctl *);
170 1.259 dsl struct wd_ioctl *wi_get(void);
171 1.259 dsl void wdioctlstrategy(struct buf *);
172 1.259 dsl
173 1.259 dsl void wdgetdefaultlabel(struct wd_softc *, struct disklabel *);
174 1.259 dsl void wdgetdisklabel(struct wd_softc *);
175 1.259 dsl void wdstart(void *);
176 1.382 pooka void wdstart1(struct wd_softc*, struct buf *);
177 1.259 dsl void wdrestart(void *);
178 1.272 thorpej void wddone(void *);
179 1.259 dsl int wd_get_params(struct wd_softc *, u_int8_t, struct ataparams *);
180 1.276 bouyer int wd_flushcache(struct wd_softc *, int);
181 1.357 drochner bool wd_shutdown(device_t, int);
182 1.108 mycroft
183 1.259 dsl int wd_getcache(struct wd_softc *, int *);
184 1.259 dsl int wd_setcache(struct wd_softc *, int);
185 1.248 bouyer
186 1.388 jakllsch struct dkdriver wddkdriver = { wdstrategy, wdminphys };
187 1.65 mycroft
188 1.170 leo #ifdef HAS_BAD144_HANDLING
189 1.259 dsl static void bad144intern(struct wd_softc *);
190 1.170 leo #endif
191 1.1 cgd
192 1.239 thorpej #define WD_QUIRK_SPLIT_MOD15_WRITE 0x0001 /* must split certain writes */
193 1.239 thorpej
194 1.327 lukem #define WD_QUIRK_FMT "\20\1SPLIT_MOD15_WRITE\2FORCE_LBA48"
195 1.327 lukem
196 1.239 thorpej /*
197 1.239 thorpej * Quirk table for IDE drives. Put more-specific matches first, since
198 1.389 jakllsch * a simple globing routine is used for matching.
199 1.239 thorpej */
200 1.239 thorpej static const struct wd_quirk {
201 1.239 thorpej const char *wdq_match; /* inquiry pattern to match */
202 1.239 thorpej int wdq_quirks; /* drive quirks */
203 1.239 thorpej } wd_quirk_table[] = {
204 1.239 thorpej /*
205 1.239 thorpej * Some Seagate S-ATA drives have a PHY which can get confused
206 1.239 thorpej * with the way data is packetized by some S-ATA controllers.
207 1.239 thorpej *
208 1.246 mason * The work-around is to split in two any write transfer whose
209 1.239 thorpej * sector count % 15 == 1 (assuming 512 byte sectors).
210 1.239 thorpej *
211 1.239 thorpej * XXX This is an incomplete list. There are at least a couple
212 1.239 thorpej * XXX more model numbers. If you have trouble with such transfers
213 1.239 thorpej * XXX (8K is the most common) on Seagate S-ATA drives, please
214 1.269 keihan * XXX notify thorpej (at) NetBSD.org.
215 1.389 jakllsch *
216 1.389 jakllsch * The ST360015AS has not yet been confirmed to have this
217 1.389 jakllsch * issue, however, it is the only other drive in the
218 1.389 jakllsch * Seagate Barracuda Serial ATA V family.
219 1.389 jakllsch *
220 1.239 thorpej */
221 1.239 thorpej { "ST3120023AS",
222 1.247 explorer WD_QUIRK_SPLIT_MOD15_WRITE },
223 1.247 explorer { "ST380023AS",
224 1.239 thorpej WD_QUIRK_SPLIT_MOD15_WRITE },
225 1.389 jakllsch { "ST360015AS",
226 1.389 jakllsch WD_QUIRK_SPLIT_MOD15_WRITE },
227 1.239 thorpej { NULL,
228 1.239 thorpej 0 }
229 1.239 thorpej };
230 1.239 thorpej
231 1.239 thorpej static const struct wd_quirk *
232 1.239 thorpej wd_lookup_quirks(const char *name)
233 1.239 thorpej {
234 1.239 thorpej const struct wd_quirk *wdq;
235 1.239 thorpej const char *estr;
236 1.239 thorpej
237 1.239 thorpej for (wdq = wd_quirk_table; wdq->wdq_match != NULL; wdq++) {
238 1.239 thorpej /*
239 1.239 thorpej * We only want exact matches (which include matches
240 1.239 thorpej * against globbing characters).
241 1.239 thorpej */
242 1.239 thorpej if (pmatch(name, wdq->wdq_match, &estr) == 2)
243 1.239 thorpej return (wdq);
244 1.239 thorpej }
245 1.239 thorpej return (NULL);
246 1.239 thorpej }
247 1.239 thorpej
248 1.1 cgd int
249 1.373 cegger wdprobe(device_t parent, cfdata_t match, void *aux)
250 1.1 cgd {
251 1.216 bouyer struct ata_device *adev = aux;
252 1.167 thorpej
253 1.216 bouyer if (adev == NULL)
254 1.181 bouyer return 0;
255 1.216 bouyer if (adev->adev_bustype->bustype_type != SCSIPI_BUSTYPE_ATA)
256 1.64 mycroft return 0;
257 1.181 bouyer
258 1.263 bouyer if (match->cf_loc[ATA_HLCF_DRIVE] != ATA_HLCF_DRIVE_DEFAULT &&
259 1.263 bouyer match->cf_loc[ATA_HLCF_DRIVE] != adev->adev_drv_data->drive)
260 1.74 mycroft return 0;
261 1.74 mycroft return 1;
262 1.74 mycroft }
263 1.64 mycroft
264 1.74 mycroft void
265 1.373 cegger wdattach(device_t parent, device_t self, void *aux)
266 1.74 mycroft {
267 1.360 cube struct wd_softc *wd = device_private(self);
268 1.216 bouyer struct ata_device *adev= aux;
269 1.74 mycroft int i, blank;
270 1.301 christos char tbuf[41], pbuf[9], c, *p, *q;
271 1.239 thorpej const struct wd_quirk *wdq;
272 1.350 itohy
273 1.360 cube wd->sc_dev = self;
274 1.360 cube
275 1.289 thorpej ATADEBUG_PRINT(("wdattach\n"), DEBUG_FUNCS | DEBUG_PROBE);
276 1.340 ad callout_init(&wd->sc_restart_ch, 0);
277 1.312 yamt bufq_alloc(&wd->sc_q, BUFQ_DISK_DEFAULT_STRAT, BUFQ_SORT_RAWBLOCK);
278 1.292 drochner #ifdef WD_SOFTBADSECT
279 1.241 darrenr SLIST_INIT(&wd->sc_bslist);
280 1.292 drochner #endif
281 1.217 bouyer wd->atabus = adev->adev_bustype;
282 1.216 bouyer wd->openings = adev->adev_openings;
283 1.235 simonb wd->drvp = adev->adev_drv_data;
284 1.270 thorpej
285 1.270 thorpej wd->drvp->drv_done = wddone;
286 1.360 cube wd->drvp->drv_softc = wd->sc_dev;
287 1.181 bouyer
288 1.253 thorpej aprint_naive("\n");
289 1.386 enami aprint_normal("\n");
290 1.253 thorpej
291 1.181 bouyer /* read our drive info */
292 1.261 mycroft if (wd_get_params(wd, AT_WAIT, &wd->sc_params) != 0) {
293 1.386 enami aprint_error_dev(self, "IDENTIFY failed\n");
294 1.181 bouyer return;
295 1.181 bouyer }
296 1.163 bouyer
297 1.301 christos for (blank = 0, p = wd->sc_params.atap_model, q = tbuf, i = 0;
298 1.181 bouyer i < sizeof(wd->sc_params.atap_model); i++) {
299 1.135 mycroft c = *p++;
300 1.135 mycroft if (c == '\0')
301 1.135 mycroft break;
302 1.135 mycroft if (c != ' ') {
303 1.135 mycroft if (blank) {
304 1.135 mycroft *q++ = ' ';
305 1.135 mycroft blank = 0;
306 1.135 mycroft }
307 1.135 mycroft *q++ = c;
308 1.135 mycroft } else
309 1.135 mycroft blank = 1;
310 1.195 enami }
311 1.135 mycroft *q++ = '\0';
312 1.135 mycroft
313 1.386 enami aprint_normal_dev(self, "<%s>\n", tbuf);
314 1.113 mycroft
315 1.301 christos wdq = wd_lookup_quirks(tbuf);
316 1.239 thorpej if (wdq != NULL)
317 1.239 thorpej wd->sc_quirks = wdq->wdq_quirks;
318 1.239 thorpej
319 1.327 lukem if (wd->sc_quirks != 0) {
320 1.327 lukem char sbuf[sizeof(WD_QUIRK_FMT) + 64];
321 1.366 christos snprintb(sbuf, sizeof(sbuf), WD_QUIRK_FMT, wd->sc_quirks);
322 1.360 cube aprint_normal_dev(self, "quirks %s\n", sbuf);
323 1.327 lukem }
324 1.327 lukem
325 1.181 bouyer if ((wd->sc_params.atap_multi & 0xff) > 1) {
326 1.181 bouyer wd->sc_multi = wd->sc_params.atap_multi & 0xff;
327 1.113 mycroft } else {
328 1.181 bouyer wd->sc_multi = 1;
329 1.113 mycroft }
330 1.113 mycroft
331 1.360 cube aprint_verbose_dev(self, "drive supports %d-sector PIO transfers,",
332 1.360 cube wd->sc_multi);
333 1.172 mycroft
334 1.220 christos /* 48-bit LBA addressing */
335 1.268 yamt if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0)
336 1.220 christos wd->sc_flags |= WDF_LBA48;
337 1.220 christos
338 1.172 mycroft /* Prior to ATA-4, LBA was optional. */
339 1.181 bouyer if ((wd->sc_params.atap_capabilities1 & WDC_CAP_LBA) != 0)
340 1.181 bouyer wd->sc_flags |= WDF_LBA;
341 1.174 mycroft #if 0
342 1.172 mycroft /* ATA-4 requires LBA. */
343 1.181 bouyer if (wd->sc_params.atap_ataversion != 0xffff &&
344 1.181 bouyer wd->sc_params.atap_ataversion >= WDC_VER_ATA4)
345 1.181 bouyer wd->sc_flags |= WDF_LBA;
346 1.174 mycroft #endif
347 1.172 mycroft
348 1.220 christos if ((wd->sc_flags & WDF_LBA48) != 0) {
349 1.336 ad aprint_verbose(" LBA48 addressing\n");
350 1.220 christos wd->sc_capacity =
351 1.378 jakllsch ((u_int64_t) wd->sc_params.atap_max_lba[3] << 48) |
352 1.378 jakllsch ((u_int64_t) wd->sc_params.atap_max_lba[2] << 32) |
353 1.378 jakllsch ((u_int64_t) wd->sc_params.atap_max_lba[1] << 16) |
354 1.378 jakllsch ((u_int64_t) wd->sc_params.atap_max_lba[0] << 0);
355 1.380 bouyer wd->sc_capacity28 =
356 1.380 bouyer (wd->sc_params.atap_capacity[1] << 16) |
357 1.380 bouyer wd->sc_params.atap_capacity[0];
358 1.220 christos } else if ((wd->sc_flags & WDF_LBA) != 0) {
359 1.336 ad aprint_verbose(" LBA addressing\n");
360 1.380 bouyer wd->sc_capacity28 = wd->sc_capacity =
361 1.380 bouyer (wd->sc_params.atap_capacity[1] << 16) |
362 1.181 bouyer wd->sc_params.atap_capacity[0];
363 1.172 mycroft } else {
364 1.336 ad aprint_verbose(" chs addressing\n");
365 1.380 bouyer wd->sc_capacity28 = wd->sc_capacity =
366 1.181 bouyer wd->sc_params.atap_cylinders *
367 1.181 bouyer wd->sc_params.atap_heads *
368 1.181 bouyer wd->sc_params.atap_sectors;
369 1.172 mycroft }
370 1.240 fvdl format_bytes(pbuf, sizeof(pbuf), wd->sc_capacity * DEV_BSIZE);
371 1.360 cube aprint_normal_dev(self, "%s, %d cyl, %d head, %d sec, "
372 1.240 fvdl "%d bytes/sect x %llu sectors\n",
373 1.360 cube pbuf,
374 1.260 bouyer (wd->sc_flags & WDF_LBA) ? (int)(wd->sc_capacity /
375 1.260 bouyer (wd->sc_params.atap_heads * wd->sc_params.atap_sectors)) :
376 1.260 bouyer wd->sc_params.atap_cylinders,
377 1.201 enami wd->sc_params.atap_heads, wd->sc_params.atap_sectors,
378 1.240 fvdl DEV_BSIZE, (unsigned long long)wd->sc_capacity);
379 1.201 enami
380 1.289 thorpej ATADEBUG_PRINT(("%s: atap_dmatiming_mimi=%d, atap_dmatiming_recom=%d\n",
381 1.360 cube device_xname(self), wd->sc_params.atap_dmatiming_mimi,
382 1.181 bouyer wd->sc_params.atap_dmatiming_recom), DEBUG_PROBE);
383 1.181 bouyer /*
384 1.181 bouyer * Initialize and attach the disk structure.
385 1.181 bouyer */
386 1.332 thorpej /* we fill in dk_info later */
387 1.360 cube disk_init(&wd->sc_dk, device_xname(wd->sc_dev), &wddkdriver);
388 1.181 bouyer disk_attach(&wd->sc_dk);
389 1.181 bouyer wd->sc_wdc_bio.lp = wd->sc_dk.dk_label;
390 1.360 cube rnd_attach_source(&wd->rnd_source, device_xname(wd->sc_dev),
391 1.193 explorer RND_TYPE_DISK, 0);
392 1.294 thorpej
393 1.294 thorpej /* Discover wedges on this disk. */
394 1.294 thorpej dkwedge_discover(&wd->sc_dk);
395 1.351 jmcneill
396 1.357 drochner if (!pmf_device_register1(self, wd_suspend, NULL, wd_shutdown))
397 1.351 jmcneill aprint_error_dev(self, "couldn't establish power handler\n");
398 1.351 jmcneill }
399 1.351 jmcneill
400 1.351 jmcneill static bool
401 1.384 dyoung wd_suspend(device_t dv, const pmf_qual_t *qual)
402 1.351 jmcneill {
403 1.351 jmcneill struct wd_softc *sc = device_private(dv);
404 1.351 jmcneill
405 1.356 drochner wd_flushcache(sc, AT_WAIT);
406 1.356 drochner wd_standby(sc, AT_WAIT);
407 1.351 jmcneill return true;
408 1.196 enami }
409 1.196 enami
410 1.196 enami int
411 1.373 cegger wddetach(device_t self, int flags)
412 1.196 enami {
413 1.360 cube struct wd_softc *sc = device_private(self);
414 1.374 dyoung int bmaj, cmaj, i, mn, rc, s;
415 1.374 dyoung
416 1.377 dyoung if ((rc = disk_begindetach(&sc->sc_dk, wdlastclose, self, flags)) != 0)
417 1.374 dyoung return rc;
418 1.196 enami
419 1.196 enami /* locate the major number */
420 1.225 gehenna bmaj = bdevsw_lookup_major(&wd_bdevsw);
421 1.225 gehenna cmaj = cdevsw_lookup_major(&wd_cdevsw);
422 1.196 enami
423 1.286 mycroft /* Nuke the vnodes for any open instances. */
424 1.286 mycroft for (i = 0; i < MAXPARTITIONS; i++) {
425 1.321 thorpej mn = WDMINOR(device_unit(self), i);
426 1.286 mycroft vdevgone(bmaj, mn, mn, VBLK);
427 1.286 mycroft vdevgone(cmaj, mn, mn, VCHR);
428 1.286 mycroft }
429 1.286 mycroft
430 1.294 thorpej /* Delete all of our wedges. */
431 1.294 thorpej dkwedge_delall(&sc->sc_dk);
432 1.294 thorpej
433 1.196 enami s = splbio();
434 1.196 enami
435 1.259 dsl /* Kill off any queued buffers. */
436 1.312 yamt bufq_drain(sc->sc_q);
437 1.224 hannken
438 1.312 yamt bufq_free(sc->sc_q);
439 1.285 bouyer sc->atabus->ata_killpending(sc->drvp);
440 1.196 enami
441 1.196 enami splx(s);
442 1.196 enami
443 1.196 enami /* Detach disk. */
444 1.196 enami disk_detach(&sc->sc_dk);
445 1.362 plunky disk_destroy(&sc->sc_dk);
446 1.196 enami
447 1.292 drochner #ifdef WD_SOFTBADSECT
448 1.282 bouyer /* Clean out the bad sector list */
449 1.282 bouyer while (!SLIST_EMPTY(&sc->sc_bslist)) {
450 1.282 bouyer void *head = SLIST_FIRST(&sc->sc_bslist);
451 1.282 bouyer SLIST_REMOVE_HEAD(&sc->sc_bslist, dbs_next);
452 1.282 bouyer free(head, M_TEMP);
453 1.282 bouyer }
454 1.282 bouyer sc->sc_bscount = 0;
455 1.292 drochner #endif
456 1.282 bouyer
457 1.351 jmcneill pmf_device_deregister(self);
458 1.196 enami
459 1.196 enami /* Unhook the entropy source. */
460 1.196 enami rnd_detach_source(&sc->rnd_source);
461 1.196 enami
462 1.364 dyoung callout_destroy(&sc->sc_restart_ch);
463 1.364 dyoung
464 1.284 bouyer sc->drvp->drive_flags = 0; /* no drive any more here */
465 1.283 bouyer
466 1.196 enami return (0);
467 1.1 cgd }
468 1.1 cgd
469 1.64 mycroft /*
470 1.135 mycroft * Read/write routine for a buffer. Validates the arguments and schedules the
471 1.135 mycroft * transfer. Does not wait for the transfer to complete.
472 1.1 cgd */
473 1.64 mycroft void
474 1.259 dsl wdstrategy(struct buf *bp)
475 1.1 cgd {
476 1.360 cube struct wd_softc *wd =
477 1.363 tsutsui device_lookup_private(&wd_cd, WDUNIT(bp->b_dev));
478 1.202 thorpej struct disklabel *lp = wd->sc_dk.dk_label;
479 1.202 thorpej daddr_t blkno;
480 1.37 mycroft int s;
481 1.202 thorpej
482 1.360 cube ATADEBUG_PRINT(("wdstrategy (%s)\n", device_xname(wd->sc_dev)),
483 1.182 bouyer DEBUG_XFERS);
484 1.259 dsl
485 1.135 mycroft /* Valid request? */
486 1.135 mycroft if (bp->b_blkno < 0 ||
487 1.202 thorpej (bp->b_bcount % lp->d_secsize) != 0 ||
488 1.202 thorpej (bp->b_bcount / lp->d_secsize) >= (1 << NBBY)) {
489 1.1 cgd bp->b_error = EINVAL;
490 1.342 ad goto done;
491 1.1 cgd }
492 1.259 dsl
493 1.375 dyoung /* If device invalidated (e.g. media change, door open,
494 1.385 dyoung * device detachment), then error.
495 1.375 dyoung */
496 1.385 dyoung if ((wd->sc_flags & WDF_LOADED) == 0 ||
497 1.385 dyoung !device_is_enabled(wd->sc_dev)) {
498 1.135 mycroft bp->b_error = EIO;
499 1.342 ad goto done;
500 1.135 mycroft }
501 1.135 mycroft
502 1.93 mycroft /* If it's a null transfer, return immediately. */
503 1.93 mycroft if (bp->b_bcount == 0)
504 1.93 mycroft goto done;
505 1.93 mycroft
506 1.128 mycroft /*
507 1.128 mycroft * Do bounds checking, adjust transfer. if error, process.
508 1.128 mycroft * If end of partition, just return.
509 1.128 mycroft */
510 1.240 fvdl if (WDPART(bp->b_dev) == RAW_PART) {
511 1.240 fvdl if (bounds_check_with_mediasize(bp, DEV_BSIZE,
512 1.240 fvdl wd->sc_capacity) <= 0)
513 1.240 fvdl goto done;
514 1.240 fvdl } else {
515 1.252 thorpej if (bounds_check_with_label(&wd->sc_dk, bp,
516 1.240 fvdl (wd->sc_flags & (WDF_WLABEL|WDF_LABELLING)) != 0) <= 0)
517 1.240 fvdl goto done;
518 1.240 fvdl }
519 1.202 thorpej
520 1.202 thorpej /*
521 1.202 thorpej * Now convert the block number to absolute and put it in
522 1.202 thorpej * terms of the device's logical block size.
523 1.202 thorpej */
524 1.202 thorpej if (lp->d_secsize >= DEV_BSIZE)
525 1.202 thorpej blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);
526 1.202 thorpej else
527 1.202 thorpej blkno = bp->b_blkno * (DEV_BSIZE / lp->d_secsize);
528 1.202 thorpej
529 1.202 thorpej if (WDPART(bp->b_dev) != RAW_PART)
530 1.202 thorpej blkno += lp->d_partitions[WDPART(bp->b_dev)].p_offset;
531 1.202 thorpej
532 1.202 thorpej bp->b_rawblkno = blkno;
533 1.202 thorpej
534 1.292 drochner #ifdef WD_SOFTBADSECT
535 1.241 darrenr /*
536 1.241 darrenr * If the transfer about to be attempted contains only a block that
537 1.241 darrenr * is known to be bad then return an error for the transfer without
538 1.241 darrenr * even attempting to start a transfer up under the premis that we
539 1.241 darrenr * will just end up doing more retries for a transfer that will end
540 1.241 darrenr * up failing again.
541 1.241 darrenr * XXX:SMP - mutex required to protect with DIOCBSFLUSH
542 1.241 darrenr */
543 1.241 darrenr if (__predict_false(!SLIST_EMPTY(&wd->sc_bslist))) {
544 1.241 darrenr struct disk_badsectors *dbs;
545 1.278 mycroft daddr_t maxblk = blkno + (bp->b_bcount >> DEV_BSHIFT) - 1;
546 1.241 darrenr
547 1.241 darrenr SLIST_FOREACH(dbs, &wd->sc_bslist, dbs_next)
548 1.243 darrenr if ((dbs->dbs_min <= blkno && blkno <= dbs->dbs_max) ||
549 1.245 darrenr (dbs->dbs_min <= maxblk && maxblk <= dbs->dbs_max)){
550 1.245 darrenr bp->b_error = EIO;
551 1.343 taca goto done;
552 1.245 darrenr }
553 1.241 darrenr }
554 1.292 drochner #endif
555 1.241 darrenr
556 1.64 mycroft /* Queue transfer on drive, activate drive and controller if idle. */
557 1.1 cgd s = splbio();
558 1.367 yamt bufq_put(wd->sc_q, bp);
559 1.163 bouyer wdstart(wd);
560 1.1 cgd splx(s);
561 1.64 mycroft return;
562 1.1 cgd done:
563 1.64 mycroft /* Toss transfer; we're done early. */
564 1.135 mycroft bp->b_resid = bp->b_bcount;
565 1.1 cgd biodone(bp);
566 1.1 cgd }
567 1.1 cgd
568 1.1 cgd /*
569 1.135 mycroft * Queue a drive for I/O.
570 1.1 cgd */
571 1.108 mycroft void
572 1.259 dsl wdstart(void *arg)
573 1.1 cgd {
574 1.163 bouyer struct wd_softc *wd = arg;
575 1.200 thorpej struct buf *bp = NULL;
576 1.163 bouyer
577 1.360 cube ATADEBUG_PRINT(("wdstart %s\n", device_xname(wd->sc_dev)),
578 1.182 bouyer DEBUG_XFERS);
579 1.385 dyoung
580 1.385 dyoung if (!device_is_active(wd->sc_dev))
581 1.385 dyoung return;
582 1.385 dyoung
583 1.181 bouyer while (wd->openings > 0) {
584 1.163 bouyer
585 1.163 bouyer /* Is there a buf for us ? */
586 1.367 yamt if ((bp = bufq_get(wd->sc_q)) == NULL)
587 1.200 thorpej return;
588 1.259 dsl
589 1.259 dsl /*
590 1.163 bouyer * Make the command. First lock the device
591 1.163 bouyer */
592 1.181 bouyer wd->openings--;
593 1.181 bouyer
594 1.181 bouyer wd->retries = 0;
595 1.382 pooka wdstart1(wd, bp);
596 1.181 bouyer }
597 1.181 bouyer }
598 1.181 bouyer
599 1.239 thorpej static void
600 1.239 thorpej wd_split_mod15_write(struct buf *bp)
601 1.239 thorpej {
602 1.239 thorpej struct buf *obp = bp->b_private;
603 1.360 cube struct wd_softc *sc =
604 1.363 tsutsui device_lookup_private(&wd_cd, DISKUNIT(obp->b_dev));
605 1.383 bouyer int s;
606 1.239 thorpej
607 1.342 ad if (__predict_false(bp->b_error != 0)) {
608 1.239 thorpej /*
609 1.239 thorpej * Propagate the error. If this was the first half of
610 1.239 thorpej * the original transfer, make sure to account for that
611 1.239 thorpej * in the residual.
612 1.239 thorpej */
613 1.239 thorpej if (bp->b_data == obp->b_data)
614 1.239 thorpej bp->b_resid += bp->b_bcount;
615 1.239 thorpej goto done;
616 1.239 thorpej }
617 1.239 thorpej
618 1.239 thorpej /*
619 1.239 thorpej * If this was the second half of the transfer, we're all done!
620 1.239 thorpej */
621 1.239 thorpej if (bp->b_data != obp->b_data)
622 1.239 thorpej goto done;
623 1.239 thorpej
624 1.239 thorpej /*
625 1.239 thorpej * Advance the pointer to the second half and issue that command
626 1.239 thorpej * using the same opening.
627 1.239 thorpej */
628 1.355 ad bp->b_flags = obp->b_flags;
629 1.355 ad bp->b_oflags = obp->b_oflags;
630 1.355 ad bp->b_cflags = obp->b_cflags;
631 1.337 christos bp->b_data = (char *)bp->b_data + bp->b_bcount;
632 1.239 thorpej bp->b_blkno += (bp->b_bcount / 512);
633 1.239 thorpej bp->b_rawblkno += (bp->b_bcount / 512);
634 1.383 bouyer s = splbio();
635 1.382 pooka wdstart1(sc, bp);
636 1.383 bouyer splx(s);
637 1.239 thorpej return;
638 1.239 thorpej
639 1.239 thorpej done:
640 1.239 thorpej obp->b_error = bp->b_error;
641 1.239 thorpej obp->b_resid = bp->b_resid;
642 1.383 bouyer s = splbio();
643 1.316 yamt putiobuf(bp);
644 1.239 thorpej biodone(obp);
645 1.239 thorpej sc->openings++;
646 1.383 bouyer splx(s);
647 1.239 thorpej /* wddone() will call wdstart() */
648 1.239 thorpej }
649 1.239 thorpej
650 1.181 bouyer void
651 1.382 pooka wdstart1(struct wd_softc *wd, struct buf *bp)
652 1.181 bouyer {
653 1.202 thorpej
654 1.239 thorpej /*
655 1.239 thorpej * Deal with the "split mod15 write" quirk. We just divide the
656 1.239 thorpej * transfer in two, doing the first half and then then second half
657 1.239 thorpej * with the same command opening.
658 1.239 thorpej *
659 1.239 thorpej * Note we MUST do this here, because we can't let insertion
660 1.239 thorpej * into the bufq cause the transfers to be re-merged.
661 1.239 thorpej */
662 1.239 thorpej if (__predict_false((wd->sc_quirks & WD_QUIRK_SPLIT_MOD15_WRITE) != 0 &&
663 1.239 thorpej (bp->b_flags & B_READ) == 0 &&
664 1.239 thorpej bp->b_bcount > 512 &&
665 1.239 thorpej ((bp->b_bcount / 512) % 15) == 1)) {
666 1.239 thorpej struct buf *nbp;
667 1.239 thorpej
668 1.239 thorpej /* already at splbio */
669 1.355 ad nbp = getiobuf(NULL, false);
670 1.239 thorpej if (__predict_false(nbp == NULL)) {
671 1.239 thorpej /* No memory -- fail the iop. */
672 1.239 thorpej bp->b_error = ENOMEM;
673 1.239 thorpej bp->b_resid = bp->b_bcount;
674 1.239 thorpej biodone(bp);
675 1.239 thorpej wd->openings++;
676 1.239 thorpej return;
677 1.239 thorpej }
678 1.239 thorpej
679 1.239 thorpej nbp->b_error = 0;
680 1.239 thorpej nbp->b_proc = bp->b_proc;
681 1.239 thorpej nbp->b_dev = bp->b_dev;
682 1.239 thorpej
683 1.239 thorpej nbp->b_bcount = bp->b_bcount / 2;
684 1.239 thorpej nbp->b_bufsize = bp->b_bcount / 2;
685 1.239 thorpej nbp->b_data = bp->b_data;
686 1.239 thorpej
687 1.239 thorpej nbp->b_blkno = bp->b_blkno;
688 1.239 thorpej nbp->b_rawblkno = bp->b_rawblkno;
689 1.239 thorpej
690 1.355 ad nbp->b_flags = bp->b_flags;
691 1.355 ad nbp->b_oflags = bp->b_oflags;
692 1.355 ad nbp->b_cflags = bp->b_cflags;
693 1.239 thorpej nbp->b_iodone = wd_split_mod15_write;
694 1.239 thorpej
695 1.239 thorpej /* Put ptr to orig buf in b_private and use new buf */
696 1.239 thorpej nbp->b_private = bp;
697 1.273 yamt
698 1.273 yamt BIO_COPYPRIO(nbp, bp);
699 1.273 yamt
700 1.239 thorpej bp = nbp;
701 1.239 thorpej }
702 1.239 thorpej
703 1.202 thorpej wd->sc_wdc_bio.blkno = bp->b_rawblkno;
704 1.380 bouyer wd->sc_wdc_bio.bcount = bp->b_bcount;
705 1.380 bouyer wd->sc_wdc_bio.databuf = bp->b_data;
706 1.181 bouyer wd->sc_wdc_bio.blkdone =0;
707 1.387 jakllsch KASSERT(bp == wd->sc_bp || wd->sc_bp == NULL);
708 1.181 bouyer wd->sc_bp = bp;
709 1.181 bouyer /*
710 1.181 bouyer * If we're retrying, retry in single-sector mode. This will give us
711 1.181 bouyer * the sector number of the problem, and will eventually allow the
712 1.184 bouyer * transfer to succeed.
713 1.181 bouyer */
714 1.279 mycroft if (wd->retries >= WDIORETRIES_SINGLE)
715 1.181 bouyer wd->sc_wdc_bio.flags = ATA_SINGLE;
716 1.181 bouyer else
717 1.181 bouyer wd->sc_wdc_bio.flags = 0;
718 1.295 bouyer if (wd->sc_flags & WDF_LBA48 &&
719 1.380 bouyer (wd->sc_wdc_bio.blkno +
720 1.380 bouyer wd->sc_wdc_bio.bcount / wd->sc_dk.dk_label->d_secsize) >
721 1.380 bouyer wd->sc_capacity28)
722 1.220 christos wd->sc_wdc_bio.flags |= ATA_LBA48;
723 1.181 bouyer if (wd->sc_flags & WDF_LBA)
724 1.181 bouyer wd->sc_wdc_bio.flags |= ATA_LBA;
725 1.181 bouyer if (bp->b_flags & B_READ)
726 1.181 bouyer wd->sc_wdc_bio.flags |= ATA_READ;
727 1.181 bouyer /* Instrumentation. */
728 1.181 bouyer disk_busy(&wd->sc_dk);
729 1.217 bouyer switch (wd->atabus->ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
730 1.288 thorpej case ATACMD_TRY_AGAIN:
731 1.203 thorpej callout_reset(&wd->sc_restart_ch, hz, wdrestart, wd);
732 1.181 bouyer break;
733 1.288 thorpej case ATACMD_QUEUED:
734 1.288 thorpej case ATACMD_COMPLETE:
735 1.181 bouyer break;
736 1.181 bouyer default:
737 1.382 pooka panic("wdstart1: bad return code from ata_bio()");
738 1.181 bouyer }
739 1.181 bouyer }
740 1.181 bouyer
741 1.181 bouyer void
742 1.259 dsl wddone(void *v)
743 1.181 bouyer {
744 1.360 cube struct wd_softc *wd = device_private(v);
745 1.181 bouyer struct buf *bp = wd->sc_bp;
746 1.221 yamt const char *errmsg;
747 1.221 yamt int do_perror = 0;
748 1.349 itohy
749 1.360 cube ATADEBUG_PRINT(("wddone %s\n", device_xname(wd->sc_dev)),
750 1.182 bouyer DEBUG_XFERS);
751 1.214 bjh21 if (bp == NULL)
752 1.214 bjh21 return;
753 1.181 bouyer bp->b_resid = wd->sc_wdc_bio.bcount;
754 1.181 bouyer switch (wd->sc_wdc_bio.error) {
755 1.181 bouyer case ERR_DMA:
756 1.221 yamt errmsg = "DMA error";
757 1.181 bouyer goto retry;
758 1.181 bouyer case ERR_DF:
759 1.221 yamt errmsg = "device fault";
760 1.181 bouyer goto retry;
761 1.181 bouyer case TIMEOUT:
762 1.221 yamt errmsg = "device timeout";
763 1.181 bouyer goto retry;
764 1.281 bouyer case ERR_RESET:
765 1.281 bouyer errmsg = "channel reset";
766 1.281 bouyer goto retry2;
767 1.181 bouyer case ERROR:
768 1.181 bouyer /* Don't care about media change bits */
769 1.181 bouyer if (wd->sc_wdc_bio.r_error != 0 &&
770 1.181 bouyer (wd->sc_wdc_bio.r_error & ~(WDCE_MC | WDCE_MCR)) == 0)
771 1.181 bouyer goto noerror;
772 1.221 yamt errmsg = "error";
773 1.221 yamt do_perror = 1;
774 1.181 bouyer retry: /* Just reset and retry. Can we do more ? */
775 1.293 bouyer (*wd->atabus->ata_reset_drive)(wd->drvp, AT_RST_NOCMD);
776 1.281 bouyer retry2:
777 1.221 yamt diskerr(bp, "wd", errmsg, LOG_PRINTF,
778 1.181 bouyer wd->sc_wdc_bio.blkdone, wd->sc_dk.dk_label);
779 1.221 yamt if (wd->retries < WDIORETRIES)
780 1.345 bouyer printf(", retrying");
781 1.345 bouyer printf("\n");
782 1.221 yamt if (do_perror)
783 1.221 yamt wdperror(wd);
784 1.221 yamt if (wd->retries < WDIORETRIES) {
785 1.221 yamt wd->retries++;
786 1.203 thorpej callout_reset(&wd->sc_restart_ch, RECOVERYTIME,
787 1.203 thorpej wdrestart, wd);
788 1.181 bouyer return;
789 1.181 bouyer }
790 1.241 darrenr
791 1.292 drochner #ifdef WD_SOFTBADSECT
792 1.241 darrenr /*
793 1.241 darrenr * Not all errors indicate a failed block but those that do,
794 1.241 darrenr * put the block on the bad-block list for the device. Only
795 1.241 darrenr * do this for reads because the drive should do it for writes,
796 1.241 darrenr * itself, according to Manuel.
797 1.241 darrenr */
798 1.242 dogcow if ((bp->b_flags & B_READ) &&
799 1.241 darrenr ((wd->drvp->ata_vers >= 4 && wd->sc_wdc_bio.r_error & 64) ||
800 1.242 dogcow (wd->drvp->ata_vers < 4 && wd->sc_wdc_bio.r_error & 192))) {
801 1.241 darrenr struct disk_badsectors *dbs;
802 1.241 darrenr
803 1.241 darrenr dbs = malloc(sizeof *dbs, M_TEMP, M_WAITOK);
804 1.241 darrenr dbs->dbs_min = bp->b_rawblkno;
805 1.278 mycroft dbs->dbs_max = dbs->dbs_min + (bp->b_bcount >> DEV_BSHIFT) - 1;
806 1.241 darrenr microtime(&dbs->dbs_failedat);
807 1.241 darrenr SLIST_INSERT_HEAD(&wd->sc_bslist, dbs, dbs_next);
808 1.243 darrenr wd->sc_bscount++;
809 1.241 darrenr }
810 1.292 drochner #endif
811 1.181 bouyer bp->b_error = EIO;
812 1.181 bouyer break;
813 1.181 bouyer case NOERROR:
814 1.181 bouyer noerror: if ((wd->sc_wdc_bio.flags & ATA_CORR) || wd->retries > 0)
815 1.360 cube aprint_error_dev(wd->sc_dev,
816 1.360 cube "soft error (corrected)\n");
817 1.197 enami break;
818 1.197 enami case ERR_NODEV:
819 1.197 enami bp->b_error = EIO;
820 1.197 enami break;
821 1.64 mycroft }
822 1.232 mrg disk_unbusy(&wd->sc_dk, (bp->b_bcount - bp->b_resid),
823 1.232 mrg (bp->b_flags & B_READ));
824 1.181 bouyer rnd_add_uint32(&wd->rnd_source, bp->b_blkno);
825 1.239 thorpej /* XXX Yuck, but we don't want to increment openings in this case */
826 1.355 ad if (__predict_false(bp->b_iodone == wd_split_mod15_write))
827 1.239 thorpej biodone(bp);
828 1.239 thorpej else {
829 1.239 thorpej biodone(bp);
830 1.239 thorpej wd->openings++;
831 1.239 thorpej }
832 1.387 jakllsch KASSERT(wd->sc_bp != NULL);
833 1.387 jakllsch wd->sc_bp = NULL;
834 1.181 bouyer wdstart(wd);
835 1.181 bouyer }
836 1.181 bouyer
837 1.181 bouyer void
838 1.259 dsl wdrestart(void *v)
839 1.181 bouyer {
840 1.181 bouyer struct wd_softc *wd = v;
841 1.181 bouyer struct buf *bp = wd->sc_bp;
842 1.181 bouyer int s;
843 1.350 itohy
844 1.360 cube ATADEBUG_PRINT(("wdrestart %s\n", device_xname(wd->sc_dev)),
845 1.182 bouyer DEBUG_XFERS);
846 1.181 bouyer s = splbio();
847 1.382 pooka wdstart1(v, bp);
848 1.181 bouyer splx(s);
849 1.141 mycroft }
850 1.141 mycroft
851 1.388 jakllsch static void
852 1.388 jakllsch wdminphys(struct buf *bp)
853 1.388 jakllsch {
854 1.388 jakllsch
855 1.388 jakllsch if (bp->b_bcount > (512 * 128)) {
856 1.388 jakllsch bp->b_bcount = (512 * 128);
857 1.388 jakllsch }
858 1.388 jakllsch minphys(bp);
859 1.388 jakllsch }
860 1.388 jakllsch
861 1.141 mycroft int
862 1.335 christos wdread(dev_t dev, struct uio *uio, int flags)
863 1.141 mycroft {
864 1.141 mycroft
865 1.289 thorpej ATADEBUG_PRINT(("wdread\n"), DEBUG_XFERS);
866 1.388 jakllsch return (physio(wdstrategy, NULL, dev, B_READ, wdminphys, uio));
867 1.141 mycroft }
868 1.141 mycroft
869 1.141 mycroft int
870 1.335 christos wdwrite(dev_t dev, struct uio *uio, int flags)
871 1.141 mycroft {
872 1.141 mycroft
873 1.289 thorpej ATADEBUG_PRINT(("wdwrite\n"), DEBUG_XFERS);
874 1.388 jakllsch return (physio(wdstrategy, NULL, dev, B_WRITE, wdminphys, uio));
875 1.64 mycroft }
876 1.64 mycroft
877 1.1 cgd int
878 1.335 christos wdopen(dev_t dev, int flag, int fmt, struct lwp *l)
879 1.1 cgd {
880 1.135 mycroft struct wd_softc *wd;
881 1.208 thorpej int part, error;
882 1.163 bouyer
883 1.289 thorpej ATADEBUG_PRINT(("wdopen\n"), DEBUG_FUNCS);
884 1.363 tsutsui wd = device_lookup_private(&wd_cd, WDUNIT(dev));
885 1.158 pk if (wd == NULL)
886 1.208 thorpej return (ENXIO);
887 1.187 thorpej
888 1.360 cube if (! device_is_active(wd->sc_dev))
889 1.283 bouyer return (ENODEV);
890 1.283 bouyer
891 1.294 thorpej part = WDPART(dev);
892 1.294 thorpej
893 1.341 ad mutex_enter(&wd->sc_dk.dk_openlock);
894 1.294 thorpej
895 1.294 thorpej /*
896 1.294 thorpej * If there are wedges, and this is not RAW_PART, then we
897 1.294 thorpej * need to fail.
898 1.294 thorpej */
899 1.294 thorpej if (wd->sc_dk.dk_nwedges != 0 && part != RAW_PART) {
900 1.294 thorpej error = EBUSY;
901 1.294 thorpej goto bad1;
902 1.294 thorpej }
903 1.294 thorpej
904 1.187 thorpej /*
905 1.187 thorpej * If this is the first open of this device, add a reference
906 1.187 thorpej * to the adapter.
907 1.187 thorpej */
908 1.187 thorpej if (wd->sc_dk.dk_openmask == 0 &&
909 1.217 bouyer (error = wd->atabus->ata_addref(wd->drvp)) != 0)
910 1.294 thorpej goto bad1;
911 1.3 deraadt
912 1.109 mycroft if (wd->sc_dk.dk_openmask != 0) {
913 1.109 mycroft /*
914 1.109 mycroft * If any partition is open, but the disk has been invalidated,
915 1.109 mycroft * disallow further opens.
916 1.109 mycroft */
917 1.181 bouyer if ((wd->sc_flags & WDF_LOADED) == 0) {
918 1.136 mycroft error = EIO;
919 1.294 thorpej goto bad2;
920 1.136 mycroft }
921 1.109 mycroft } else {
922 1.181 bouyer if ((wd->sc_flags & WDF_LOADED) == 0) {
923 1.181 bouyer wd->sc_flags |= WDF_LOADED;
924 1.108 mycroft
925 1.108 mycroft /* Load the physical device parameters. */
926 1.183 bouyer wd_get_params(wd, AT_WAIT, &wd->sc_params);
927 1.108 mycroft
928 1.108 mycroft /* Load the partition info if not already loaded. */
929 1.108 mycroft wdgetdisklabel(wd);
930 1.108 mycroft }
931 1.135 mycroft }
932 1.108 mycroft
933 1.109 mycroft /* Check that the partition exists. */
934 1.93 mycroft if (part != RAW_PART &&
935 1.144 thorpej (part >= wd->sc_dk.dk_label->d_npartitions ||
936 1.144 thorpej wd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
937 1.93 mycroft error = ENXIO;
938 1.294 thorpej goto bad2;
939 1.93 mycroft }
940 1.259 dsl
941 1.64 mycroft /* Insure only one open at a time. */
942 1.3 deraadt switch (fmt) {
943 1.3 deraadt case S_IFCHR:
944 1.94 mycroft wd->sc_dk.dk_copenmask |= (1 << part);
945 1.3 deraadt break;
946 1.3 deraadt case S_IFBLK:
947 1.94 mycroft wd->sc_dk.dk_bopenmask |= (1 << part);
948 1.3 deraadt break;
949 1.3 deraadt }
950 1.181 bouyer wd->sc_dk.dk_openmask =
951 1.181 bouyer wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
952 1.60 mycroft
953 1.341 ad mutex_exit(&wd->sc_dk.dk_openlock);
954 1.37 mycroft return 0;
955 1.93 mycroft
956 1.294 thorpej bad2:
957 1.187 thorpej if (wd->sc_dk.dk_openmask == 0)
958 1.217 bouyer wd->atabus->ata_delref(wd->drvp);
959 1.294 thorpej bad1:
960 1.341 ad mutex_exit(&wd->sc_dk.dk_openlock);
961 1.93 mycroft return error;
962 1.1 cgd }
963 1.1 cgd
964 1.374 dyoung /*
965 1.374 dyoung * Caller must hold wd->sc_dk.dk_openlock.
966 1.374 dyoung */
967 1.376 dyoung static int
968 1.376 dyoung wdlastclose(device_t self)
969 1.374 dyoung {
970 1.376 dyoung struct wd_softc *wd = device_private(self);
971 1.376 dyoung
972 1.374 dyoung wd_flushcache(wd, AT_WAIT);
973 1.374 dyoung
974 1.374 dyoung if (! (wd->sc_flags & WDF_KLABEL))
975 1.374 dyoung wd->sc_flags &= ~WDF_LOADED;
976 1.374 dyoung
977 1.374 dyoung wd->atabus->ata_delref(wd->drvp);
978 1.376 dyoung
979 1.376 dyoung return 0;
980 1.374 dyoung }
981 1.374 dyoung
982 1.135 mycroft int
983 1.335 christos wdclose(dev_t dev, int flag, int fmt, struct lwp *l)
984 1.135 mycroft {
985 1.360 cube struct wd_softc *wd =
986 1.363 tsutsui device_lookup_private(&wd_cd, WDUNIT(dev));
987 1.135 mycroft int part = WDPART(dev);
988 1.259 dsl
989 1.289 thorpej ATADEBUG_PRINT(("wdclose\n"), DEBUG_FUNCS);
990 1.294 thorpej
991 1.341 ad mutex_enter(&wd->sc_dk.dk_openlock);
992 1.135 mycroft
993 1.135 mycroft switch (fmt) {
994 1.135 mycroft case S_IFCHR:
995 1.135 mycroft wd->sc_dk.dk_copenmask &= ~(1 << part);
996 1.135 mycroft break;
997 1.135 mycroft case S_IFBLK:
998 1.135 mycroft wd->sc_dk.dk_bopenmask &= ~(1 << part);
999 1.135 mycroft break;
1000 1.135 mycroft }
1001 1.181 bouyer wd->sc_dk.dk_openmask =
1002 1.181 bouyer wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
1003 1.135 mycroft
1004 1.374 dyoung if (wd->sc_dk.dk_openmask == 0)
1005 1.376 dyoung wdlastclose(wd->sc_dev);
1006 1.135 mycroft
1007 1.341 ad mutex_exit(&wd->sc_dk.dk_openlock);
1008 1.135 mycroft return 0;
1009 1.135 mycroft }
1010 1.135 mycroft
1011 1.108 mycroft void
1012 1.259 dsl wdgetdefaultlabel(struct wd_softc *wd, struct disklabel *lp)
1013 1.108 mycroft {
1014 1.163 bouyer
1015 1.289 thorpej ATADEBUG_PRINT(("wdgetdefaultlabel\n"), DEBUG_FUNCS);
1016 1.181 bouyer memset(lp, 0, sizeof(struct disklabel));
1017 1.108 mycroft
1018 1.142 mycroft lp->d_secsize = DEV_BSIZE;
1019 1.181 bouyer lp->d_ntracks = wd->sc_params.atap_heads;
1020 1.181 bouyer lp->d_nsectors = wd->sc_params.atap_sectors;
1021 1.260 bouyer lp->d_ncylinders = (wd->sc_flags & WDF_LBA) ? wd->sc_capacity /
1022 1.260 bouyer (wd->sc_params.atap_heads * wd->sc_params.atap_sectors) :
1023 1.260 bouyer wd->sc_params.atap_cylinders;
1024 1.142 mycroft lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
1025 1.108 mycroft
1026 1.198 leo if (strcmp(wd->sc_params.atap_model, "ST506") == 0)
1027 1.181 bouyer lp->d_type = DTYPE_ST506;
1028 1.198 leo else
1029 1.181 bouyer lp->d_type = DTYPE_ESDI;
1030 1.198 leo
1031 1.181 bouyer strncpy(lp->d_typename, wd->sc_params.atap_model, 16);
1032 1.180 drochner strncpy(lp->d_packname, "fictitious", 16);
1033 1.240 fvdl if (wd->sc_capacity > UINT32_MAX)
1034 1.240 fvdl lp->d_secperunit = UINT32_MAX;
1035 1.240 fvdl else
1036 1.240 fvdl lp->d_secperunit = wd->sc_capacity;
1037 1.142 mycroft lp->d_rpm = 3600;
1038 1.142 mycroft lp->d_interleave = 1;
1039 1.142 mycroft lp->d_flags = 0;
1040 1.142 mycroft
1041 1.142 mycroft lp->d_partitions[RAW_PART].p_offset = 0;
1042 1.142 mycroft lp->d_partitions[RAW_PART].p_size =
1043 1.259 dsl lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
1044 1.142 mycroft lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
1045 1.142 mycroft lp->d_npartitions = RAW_PART + 1;
1046 1.142 mycroft
1047 1.142 mycroft lp->d_magic = DISKMAGIC;
1048 1.142 mycroft lp->d_magic2 = DISKMAGIC;
1049 1.142 mycroft lp->d_checksum = dkcksum(lp);
1050 1.164 thorpej }
1051 1.164 thorpej
1052 1.164 thorpej /*
1053 1.164 thorpej * Fabricate a default disk label, and try to read the correct one.
1054 1.164 thorpej */
1055 1.164 thorpej void
1056 1.259 dsl wdgetdisklabel(struct wd_softc *wd)
1057 1.164 thorpej {
1058 1.164 thorpej struct disklabel *lp = wd->sc_dk.dk_label;
1059 1.251 dsl const char *errstring;
1060 1.291 thorpej int s;
1061 1.164 thorpej
1062 1.289 thorpej ATADEBUG_PRINT(("wdgetdisklabel\n"), DEBUG_FUNCS);
1063 1.164 thorpej
1064 1.181 bouyer memset(wd->sc_dk.dk_cpulabel, 0, sizeof(struct cpu_disklabel));
1065 1.164 thorpej
1066 1.164 thorpej wdgetdefaultlabel(wd, lp);
1067 1.108 mycroft
1068 1.181 bouyer wd->sc_badsect[0] = -1;
1069 1.113 mycroft
1070 1.291 thorpej if (wd->drvp->state > RESET) {
1071 1.291 thorpej s = splbio();
1072 1.183 bouyer wd->drvp->drive_flags |= DRIVE_RESET;
1073 1.291 thorpej splx(s);
1074 1.291 thorpej }
1075 1.360 cube errstring = readdisklabel(MAKEWDDEV(0, device_unit(wd->sc_dev),
1076 1.321 thorpej RAW_PART), wdstrategy, lp,
1077 1.321 thorpej wd->sc_dk.dk_cpulabel);
1078 1.108 mycroft if (errstring) {
1079 1.108 mycroft /*
1080 1.108 mycroft * This probably happened because the drive's default
1081 1.108 mycroft * geometry doesn't match the DOS geometry. We
1082 1.108 mycroft * assume the DOS geometry is now in the label and try
1083 1.108 mycroft * again. XXX This is a kluge.
1084 1.108 mycroft */
1085 1.291 thorpej if (wd->drvp->state > RESET) {
1086 1.291 thorpej s = splbio();
1087 1.183 bouyer wd->drvp->drive_flags |= DRIVE_RESET;
1088 1.291 thorpej splx(s);
1089 1.291 thorpej }
1090 1.360 cube errstring = readdisklabel(MAKEWDDEV(0, device_unit(wd->sc_dev),
1091 1.181 bouyer RAW_PART), wdstrategy, lp, wd->sc_dk.dk_cpulabel);
1092 1.108 mycroft }
1093 1.108 mycroft if (errstring) {
1094 1.360 cube aprint_error_dev(wd->sc_dev, "%s\n", errstring);
1095 1.108 mycroft return;
1096 1.108 mycroft }
1097 1.108 mycroft
1098 1.291 thorpej if (wd->drvp->state > RESET) {
1099 1.291 thorpej s = splbio();
1100 1.183 bouyer wd->drvp->drive_flags |= DRIVE_RESET;
1101 1.291 thorpej splx(s);
1102 1.291 thorpej }
1103 1.170 leo #ifdef HAS_BAD144_HANDLING
1104 1.142 mycroft if ((lp->d_flags & D_BADSECT) != 0)
1105 1.108 mycroft bad144intern(wd);
1106 1.170 leo #endif
1107 1.108 mycroft }
1108 1.108 mycroft
1109 1.217 bouyer void
1110 1.259 dsl wdperror(const struct wd_softc *wd)
1111 1.217 bouyer {
1112 1.221 yamt static const char *const errstr0_3[] = {"address mark not found",
1113 1.217 bouyer "track 0 not found", "aborted command", "media change requested",
1114 1.217 bouyer "id not found", "media changed", "uncorrectable data error",
1115 1.217 bouyer "bad block detected"};
1116 1.221 yamt static const char *const errstr4_5[] = {
1117 1.221 yamt "obsolete (address mark not found)",
1118 1.217 bouyer "no media/write protected", "aborted command",
1119 1.217 bouyer "media change requested", "id not found", "media changed",
1120 1.217 bouyer "uncorrectable data error", "interface CRC error"};
1121 1.259 dsl const char *const *errstr;
1122 1.217 bouyer int i;
1123 1.301 christos const char *sep = "";
1124 1.217 bouyer
1125 1.360 cube const char *devname = device_xname(wd->sc_dev);
1126 1.221 yamt struct ata_drive_datas *drvp = wd->drvp;
1127 1.221 yamt int errno = wd->sc_wdc_bio.r_error;
1128 1.221 yamt
1129 1.217 bouyer if (drvp->ata_vers >= 4)
1130 1.217 bouyer errstr = errstr4_5;
1131 1.217 bouyer else
1132 1.217 bouyer errstr = errstr0_3;
1133 1.217 bouyer
1134 1.221 yamt printf("%s: (", devname);
1135 1.221 yamt
1136 1.217 bouyer if (errno == 0)
1137 1.221 yamt printf("error not notified");
1138 1.217 bouyer
1139 1.217 bouyer for (i = 0; i < 8; i++) {
1140 1.217 bouyer if (errno & (1 << i)) {
1141 1.221 yamt printf("%s%s", sep, errstr[i]);
1142 1.217 bouyer sep = ", ";
1143 1.217 bouyer }
1144 1.217 bouyer }
1145 1.221 yamt printf(")\n");
1146 1.217 bouyer }
1147 1.217 bouyer
1148 1.1 cgd int
1149 1.337 christos wdioctl(dev_t dev, u_long xfer, void *addr, int flag, struct lwp *l)
1150 1.1 cgd {
1151 1.360 cube struct wd_softc *wd =
1152 1.363 tsutsui device_lookup_private(&wd_cd, WDUNIT(dev));
1153 1.291 thorpej int error = 0, s;
1154 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1155 1.233 fvdl struct disklabel *newlabel = NULL;
1156 1.211 fvdl #endif
1157 1.163 bouyer
1158 1.289 thorpej ATADEBUG_PRINT(("wdioctl\n"), DEBUG_FUNCS);
1159 1.163 bouyer
1160 1.181 bouyer if ((wd->sc_flags & WDF_LOADED) == 0)
1161 1.108 mycroft return EIO;
1162 1.108 mycroft
1163 1.332 thorpej error = disk_ioctl(&wd->sc_dk, xfer, addr, flag, l);
1164 1.332 thorpej if (error != EPASSTHROUGH)
1165 1.332 thorpej return (error);
1166 1.332 thorpej
1167 1.163 bouyer switch (xfer) {
1168 1.170 leo #ifdef HAS_BAD144_HANDLING
1169 1.1 cgd case DIOCSBAD:
1170 1.3 deraadt if ((flag & FWRITE) == 0)
1171 1.54 mycroft return EBADF;
1172 1.144 thorpej wd->sc_dk.dk_cpulabel->bad = *(struct dkbad *)addr;
1173 1.144 thorpej wd->sc_dk.dk_label->d_flags |= D_BADSECT;
1174 1.64 mycroft bad144intern(wd);
1175 1.54 mycroft return 0;
1176 1.170 leo #endif
1177 1.292 drochner #ifdef WD_SOFTBADSECT
1178 1.241 darrenr case DIOCBSLIST :
1179 1.241 darrenr {
1180 1.243 darrenr u_int32_t count, missing, skip;
1181 1.243 darrenr struct disk_badsecinfo dbsi;
1182 1.241 darrenr struct disk_badsectors *dbs;
1183 1.241 darrenr size_t available;
1184 1.344 jnemeth uint8_t *laddr;
1185 1.241 darrenr
1186 1.243 darrenr dbsi = *(struct disk_badsecinfo *)addr;
1187 1.243 darrenr missing = wd->sc_bscount;
1188 1.241 darrenr count = 0;
1189 1.243 darrenr available = dbsi.dbsi_bufsize;
1190 1.243 darrenr skip = dbsi.dbsi_skip;
1191 1.344 jnemeth laddr = (uint8_t *)dbsi.dbsi_buffer;
1192 1.243 darrenr
1193 1.243 darrenr /*
1194 1.243 darrenr * We start this loop with the expectation that all of the
1195 1.243 darrenr * entries will be missed and decrement this counter each
1196 1.243 darrenr * time we either skip over one (already copied out) or
1197 1.243 darrenr * we actually copy it back to user space. The structs
1198 1.243 darrenr * holding the bad sector information are copied directly
1199 1.243 darrenr * back to user space whilst the summary is returned via
1200 1.243 darrenr * the struct passed in via the ioctl.
1201 1.243 darrenr */
1202 1.241 darrenr SLIST_FOREACH(dbs, &wd->sc_bslist, dbs_next) {
1203 1.243 darrenr if (skip > 0) {
1204 1.243 darrenr missing--;
1205 1.243 darrenr skip--;
1206 1.243 darrenr continue;
1207 1.243 darrenr }
1208 1.243 darrenr if (available < sizeof(*dbs))
1209 1.241 darrenr break;
1210 1.243 darrenr available -= sizeof(*dbs);
1211 1.241 darrenr copyout(dbs, laddr, sizeof(*dbs));
1212 1.241 darrenr laddr += sizeof(*dbs);
1213 1.243 darrenr missing--;
1214 1.241 darrenr count++;
1215 1.241 darrenr }
1216 1.243 darrenr dbsi.dbsi_left = missing;
1217 1.243 darrenr dbsi.dbsi_copied = count;
1218 1.243 darrenr *(struct disk_badsecinfo *)addr = dbsi;
1219 1.241 darrenr return 0;
1220 1.241 darrenr }
1221 1.241 darrenr
1222 1.241 darrenr case DIOCBSFLUSH :
1223 1.241 darrenr /* Clean out the bad sector list */
1224 1.241 darrenr while (!SLIST_EMPTY(&wd->sc_bslist)) {
1225 1.241 darrenr void *head = SLIST_FIRST(&wd->sc_bslist);
1226 1.241 darrenr SLIST_REMOVE_HEAD(&wd->sc_bslist, dbs_next);
1227 1.241 darrenr free(head, M_TEMP);
1228 1.241 darrenr }
1229 1.243 darrenr wd->sc_bscount = 0;
1230 1.241 darrenr return 0;
1231 1.292 drochner #endif
1232 1.1 cgd case DIOCGDINFO:
1233 1.144 thorpej *(struct disklabel *)addr = *(wd->sc_dk.dk_label);
1234 1.54 mycroft return 0;
1235 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1236 1.211 fvdl case ODIOCGDINFO:
1237 1.233 fvdl newlabel = malloc(sizeof *newlabel, M_TEMP, M_WAITOK);
1238 1.233 fvdl if (newlabel == NULL)
1239 1.233 fvdl return EIO;
1240 1.234 fvdl *newlabel = *(wd->sc_dk.dk_label);
1241 1.233 fvdl if (newlabel->d_npartitions <= OLDMAXPARTITIONS)
1242 1.234 fvdl memcpy(addr, newlabel, sizeof (struct olddisklabel));
1243 1.233 fvdl else
1244 1.233 fvdl error = ENOTTY;
1245 1.233 fvdl free(newlabel, M_TEMP);
1246 1.233 fvdl return error;
1247 1.211 fvdl #endif
1248 1.211 fvdl
1249 1.3 deraadt case DIOCGPART:
1250 1.144 thorpej ((struct partinfo *)addr)->disklab = wd->sc_dk.dk_label;
1251 1.3 deraadt ((struct partinfo *)addr)->part =
1252 1.144 thorpej &wd->sc_dk.dk_label->d_partitions[WDPART(dev)];
1253 1.54 mycroft return 0;
1254 1.259 dsl
1255 1.132 mycroft case DIOCWDINFO:
1256 1.3 deraadt case DIOCSDINFO:
1257 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1258 1.211 fvdl case ODIOCWDINFO:
1259 1.211 fvdl case ODIOCSDINFO:
1260 1.211 fvdl #endif
1261 1.211 fvdl {
1262 1.211 fvdl struct disklabel *lp;
1263 1.211 fvdl
1264 1.233 fvdl if ((flag & FWRITE) == 0)
1265 1.233 fvdl return EBADF;
1266 1.233 fvdl
1267 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1268 1.211 fvdl if (xfer == ODIOCSDINFO || xfer == ODIOCWDINFO) {
1269 1.390 joerg newlabel = malloc(sizeof *newlabel, M_TEMP,
1270 1.390 joerg M_WAITOK | M_ZERO);
1271 1.233 fvdl if (newlabel == NULL)
1272 1.233 fvdl return EIO;
1273 1.233 fvdl memcpy(newlabel, addr, sizeof (struct olddisklabel));
1274 1.233 fvdl lp = newlabel;
1275 1.211 fvdl } else
1276 1.211 fvdl #endif
1277 1.211 fvdl lp = (struct disklabel *)addr;
1278 1.211 fvdl
1279 1.341 ad mutex_enter(&wd->sc_dk.dk_openlock);
1280 1.181 bouyer wd->sc_flags |= WDF_LABELLING;
1281 1.132 mycroft
1282 1.144 thorpej error = setdisklabel(wd->sc_dk.dk_label,
1283 1.211 fvdl lp, /*wd->sc_dk.dk_openmask : */0,
1284 1.144 thorpej wd->sc_dk.dk_cpulabel);
1285 1.3 deraadt if (error == 0) {
1286 1.291 thorpej if (wd->drvp->state > RESET) {
1287 1.291 thorpej s = splbio();
1288 1.183 bouyer wd->drvp->drive_flags |= DRIVE_RESET;
1289 1.291 thorpej splx(s);
1290 1.291 thorpej }
1291 1.211 fvdl if (xfer == DIOCWDINFO
1292 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1293 1.211 fvdl || xfer == ODIOCWDINFO
1294 1.211 fvdl #endif
1295 1.211 fvdl )
1296 1.132 mycroft error = writedisklabel(WDLABELDEV(dev),
1297 1.144 thorpej wdstrategy, wd->sc_dk.dk_label,
1298 1.144 thorpej wd->sc_dk.dk_cpulabel);
1299 1.1 cgd }
1300 1.132 mycroft
1301 1.181 bouyer wd->sc_flags &= ~WDF_LABELLING;
1302 1.341 ad mutex_exit(&wd->sc_dk.dk_openlock);
1303 1.233 fvdl #ifdef __HAVE_OLD_DISKLABEL
1304 1.233 fvdl if (newlabel != NULL)
1305 1.233 fvdl free(newlabel, M_TEMP);
1306 1.233 fvdl #endif
1307 1.54 mycroft return error;
1308 1.211 fvdl }
1309 1.199 leo
1310 1.199 leo case DIOCKLABEL:
1311 1.199 leo if (*(int *)addr)
1312 1.199 leo wd->sc_flags |= WDF_KLABEL;
1313 1.199 leo else
1314 1.199 leo wd->sc_flags &= ~WDF_KLABEL;
1315 1.199 leo return 0;
1316 1.259 dsl
1317 1.44 mycroft case DIOCWLABEL:
1318 1.3 deraadt if ((flag & FWRITE) == 0)
1319 1.54 mycroft return EBADF;
1320 1.93 mycroft if (*(int *)addr)
1321 1.181 bouyer wd->sc_flags |= WDF_WLABEL;
1322 1.93 mycroft else
1323 1.181 bouyer wd->sc_flags &= ~WDF_WLABEL;
1324 1.54 mycroft return 0;
1325 1.164 thorpej
1326 1.164 thorpej case DIOCGDEFLABEL:
1327 1.164 thorpej wdgetdefaultlabel(wd, (struct disklabel *)addr);
1328 1.164 thorpej return 0;
1329 1.211 fvdl #ifdef __HAVE_OLD_DISKLABEL
1330 1.211 fvdl case ODIOCGDEFLABEL:
1331 1.233 fvdl newlabel = malloc(sizeof *newlabel, M_TEMP, M_WAITOK);
1332 1.233 fvdl if (newlabel == NULL)
1333 1.233 fvdl return EIO;
1334 1.233 fvdl wdgetdefaultlabel(wd, newlabel);
1335 1.233 fvdl if (newlabel->d_npartitions <= OLDMAXPARTITIONS)
1336 1.233 fvdl memcpy(addr, &newlabel, sizeof (struct olddisklabel));
1337 1.233 fvdl else
1338 1.233 fvdl error = ENOTTY;
1339 1.233 fvdl free(newlabel, M_TEMP);
1340 1.233 fvdl return error;
1341 1.211 fvdl #endif
1342 1.164 thorpej
1343 1.1 cgd #ifdef notyet
1344 1.1 cgd case DIOCWFORMAT:
1345 1.1 cgd if ((flag & FWRITE) == 0)
1346 1.54 mycroft return EBADF;
1347 1.181 bouyer {
1348 1.54 mycroft register struct format_op *fop;
1349 1.54 mycroft struct iovec aiov;
1350 1.54 mycroft struct uio auio;
1351 1.259 dsl
1352 1.54 mycroft fop = (struct format_op *)addr;
1353 1.54 mycroft aiov.iov_base = fop->df_buf;
1354 1.54 mycroft aiov.iov_len = fop->df_count;
1355 1.54 mycroft auio.uio_iov = &aiov;
1356 1.54 mycroft auio.uio_iovcnt = 1;
1357 1.54 mycroft auio.uio_resid = fop->df_count;
1358 1.54 mycroft auio.uio_offset =
1359 1.181 bouyer fop->df_startblk * wd->sc_dk.dk_label->d_secsize;
1360 1.320 yamt auio.uio_vmspace = l->l_proc->p_vmspace;
1361 1.388 jakllsch error = physio(wdformat, NULL, dev, B_WRITE, wdminphys,
1362 1.64 mycroft &auio);
1363 1.54 mycroft fop->df_count -= auio.uio_resid;
1364 1.64 mycroft fop->df_reg[0] = wdc->sc_status;
1365 1.64 mycroft fop->df_reg[1] = wdc->sc_error;
1366 1.54 mycroft return error;
1367 1.181 bouyer }
1368 1.1 cgd #endif
1369 1.248 bouyer case DIOCGCACHE:
1370 1.248 bouyer return wd_getcache(wd, (int *)addr);
1371 1.248 bouyer
1372 1.248 bouyer case DIOCSCACHE:
1373 1.248 bouyer return wd_setcache(wd, *(int *)addr);
1374 1.185 kenh
1375 1.276 bouyer case DIOCCACHESYNC:
1376 1.276 bouyer return wd_flushcache(wd, AT_WAIT);
1377 1.276 bouyer
1378 1.186 kenh case ATAIOCCOMMAND:
1379 1.185 kenh /*
1380 1.185 kenh * Make sure this command is (relatively) safe first
1381 1.185 kenh */
1382 1.186 kenh if ((((atareq_t *) addr)->flags & ATACMD_READ) == 0 &&
1383 1.185 kenh (flag & FWRITE) == 0)
1384 1.185 kenh return (EBADF);
1385 1.185 kenh {
1386 1.185 kenh struct wd_ioctl *wi;
1387 1.186 kenh atareq_t *atareq = (atareq_t *) addr;
1388 1.301 christos int error1;
1389 1.185 kenh
1390 1.185 kenh wi = wi_get();
1391 1.185 kenh wi->wi_softc = wd;
1392 1.186 kenh wi->wi_atareq = *atareq;
1393 1.185 kenh
1394 1.186 kenh if (atareq->datalen && atareq->flags &
1395 1.186 kenh (ATACMD_READ | ATACMD_WRITE)) {
1396 1.339 dsl void *tbuf;
1397 1.339 dsl if (atareq->datalen < DEV_BSIZE
1398 1.339 dsl && atareq->command == WDCC_IDENTIFY) {
1399 1.339 dsl tbuf = malloc(DEV_BSIZE, M_TEMP, M_WAITOK);
1400 1.339 dsl wi->wi_iov.iov_base = tbuf;
1401 1.339 dsl wi->wi_iov.iov_len = DEV_BSIZE;
1402 1.339 dsl UIO_SETUP_SYSSPACE(&wi->wi_uio);
1403 1.339 dsl } else {
1404 1.339 dsl tbuf = NULL;
1405 1.339 dsl wi->wi_iov.iov_base = atareq->databuf;
1406 1.339 dsl wi->wi_iov.iov_len = atareq->datalen;
1407 1.339 dsl wi->wi_uio.uio_vmspace = l->l_proc->p_vmspace;
1408 1.339 dsl }
1409 1.185 kenh wi->wi_uio.uio_iov = &wi->wi_iov;
1410 1.185 kenh wi->wi_uio.uio_iovcnt = 1;
1411 1.186 kenh wi->wi_uio.uio_resid = atareq->datalen;
1412 1.185 kenh wi->wi_uio.uio_offset = 0;
1413 1.185 kenh wi->wi_uio.uio_rw =
1414 1.186 kenh (atareq->flags & ATACMD_READ) ? B_READ : B_WRITE;
1415 1.301 christos error1 = physio(wdioctlstrategy, &wi->wi_bp, dev,
1416 1.186 kenh (atareq->flags & ATACMD_READ) ? B_READ : B_WRITE,
1417 1.388 jakllsch wdminphys, &wi->wi_uio);
1418 1.339 dsl if (tbuf != NULL && error1 == 0) {
1419 1.339 dsl error1 = copyout(tbuf, atareq->databuf,
1420 1.339 dsl atareq->datalen);
1421 1.339 dsl free(tbuf, M_TEMP);
1422 1.339 dsl }
1423 1.185 kenh } else {
1424 1.185 kenh /* No need to call physio if we don't have any
1425 1.185 kenh user data */
1426 1.185 kenh wi->wi_bp.b_flags = 0;
1427 1.185 kenh wi->wi_bp.b_data = 0;
1428 1.185 kenh wi->wi_bp.b_bcount = 0;
1429 1.185 kenh wi->wi_bp.b_dev = 0;
1430 1.314 christos wi->wi_bp.b_proc = l->l_proc;
1431 1.185 kenh wdioctlstrategy(&wi->wi_bp);
1432 1.301 christos error1 = wi->wi_bp.b_error;
1433 1.185 kenh }
1434 1.186 kenh *atareq = wi->wi_atareq;
1435 1.185 kenh wi_free(wi);
1436 1.301 christos return(error1);
1437 1.185 kenh }
1438 1.185 kenh
1439 1.294 thorpej case DIOCAWEDGE:
1440 1.294 thorpej {
1441 1.294 thorpej struct dkwedge_info *dkw = (void *) addr;
1442 1.294 thorpej
1443 1.294 thorpej if ((flag & FWRITE) == 0)
1444 1.294 thorpej return (EBADF);
1445 1.294 thorpej
1446 1.294 thorpej /* If the ioctl happens here, the parent is us. */
1447 1.360 cube strcpy(dkw->dkw_parent, device_xname(wd->sc_dev));
1448 1.294 thorpej return (dkwedge_add(dkw));
1449 1.294 thorpej }
1450 1.294 thorpej
1451 1.294 thorpej case DIOCDWEDGE:
1452 1.294 thorpej {
1453 1.294 thorpej struct dkwedge_info *dkw = (void *) addr;
1454 1.294 thorpej
1455 1.294 thorpej if ((flag & FWRITE) == 0)
1456 1.294 thorpej return (EBADF);
1457 1.294 thorpej
1458 1.294 thorpej /* If the ioctl happens here, the parent is us. */
1459 1.360 cube strcpy(dkw->dkw_parent, device_xname(wd->sc_dev));
1460 1.294 thorpej return (dkwedge_del(dkw));
1461 1.294 thorpej }
1462 1.294 thorpej
1463 1.294 thorpej case DIOCLWEDGES:
1464 1.294 thorpej {
1465 1.294 thorpej struct dkwedge_list *dkwl = (void *) addr;
1466 1.294 thorpej
1467 1.314 christos return (dkwedge_list(&wd->sc_dk, dkwl, l));
1468 1.294 thorpej }
1469 1.294 thorpej
1470 1.315 yamt case DIOCGSTRATEGY:
1471 1.315 yamt {
1472 1.315 yamt struct disk_strategy *dks = (void *)addr;
1473 1.315 yamt
1474 1.315 yamt s = splbio();
1475 1.315 yamt strlcpy(dks->dks_name, bufq_getstrategyname(wd->sc_q),
1476 1.315 yamt sizeof(dks->dks_name));
1477 1.315 yamt splx(s);
1478 1.315 yamt dks->dks_paramlen = 0;
1479 1.315 yamt
1480 1.315 yamt return 0;
1481 1.315 yamt }
1482 1.315 yamt
1483 1.315 yamt case DIOCSSTRATEGY:
1484 1.315 yamt {
1485 1.315 yamt struct disk_strategy *dks = (void *)addr;
1486 1.315 yamt struct bufq_state *new;
1487 1.315 yamt struct bufq_state *old;
1488 1.315 yamt
1489 1.315 yamt if ((flag & FWRITE) == 0) {
1490 1.315 yamt return EBADF;
1491 1.315 yamt }
1492 1.315 yamt if (dks->dks_param != NULL) {
1493 1.315 yamt return EINVAL;
1494 1.315 yamt }
1495 1.315 yamt dks->dks_name[sizeof(dks->dks_name) - 1] = 0; /* ensure term */
1496 1.315 yamt error = bufq_alloc(&new, dks->dks_name,
1497 1.315 yamt BUFQ_EXACT|BUFQ_SORT_RAWBLOCK);
1498 1.315 yamt if (error) {
1499 1.315 yamt return error;
1500 1.315 yamt }
1501 1.315 yamt s = splbio();
1502 1.315 yamt old = wd->sc_q;
1503 1.315 yamt bufq_move(new, old);
1504 1.315 yamt wd->sc_q = new;
1505 1.315 yamt splx(s);
1506 1.315 yamt bufq_free(old);
1507 1.315 yamt
1508 1.315 yamt return 0;
1509 1.315 yamt }
1510 1.315 yamt
1511 1.1 cgd default:
1512 1.54 mycroft return ENOTTY;
1513 1.1 cgd }
1514 1.54 mycroft
1515 1.54 mycroft #ifdef DIAGNOSTIC
1516 1.54 mycroft panic("wdioctl: impossible");
1517 1.54 mycroft #endif
1518 1.1 cgd }
1519 1.1 cgd
1520 1.44 mycroft #ifdef B_FORMAT
1521 1.1 cgd int
1522 1.1 cgd wdformat(struct buf *bp)
1523 1.1 cgd {
1524 1.44 mycroft
1525 1.1 cgd bp->b_flags |= B_FORMAT;
1526 1.37 mycroft return wdstrategy(bp);
1527 1.1 cgd }
1528 1.1 cgd #endif
1529 1.1 cgd
1530 1.1 cgd int
1531 1.259 dsl wdsize(dev_t dev)
1532 1.1 cgd {
1533 1.64 mycroft struct wd_softc *wd;
1534 1.208 thorpej int part, omask;
1535 1.108 mycroft int size;
1536 1.163 bouyer
1537 1.289 thorpej ATADEBUG_PRINT(("wdsize\n"), DEBUG_FUNCS);
1538 1.163 bouyer
1539 1.363 tsutsui wd = device_lookup_private(&wd_cd, WDUNIT(dev));
1540 1.158 pk if (wd == NULL)
1541 1.158 pk return (-1);
1542 1.158 pk
1543 1.158 pk part = WDPART(dev);
1544 1.158 pk omask = wd->sc_dk.dk_openmask & (1 << part);
1545 1.158 pk
1546 1.158 pk if (omask == 0 && wdopen(dev, 0, S_IFBLK, NULL) != 0)
1547 1.158 pk return (-1);
1548 1.144 thorpej if (wd->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
1549 1.108 mycroft size = -1;
1550 1.108 mycroft else
1551 1.160 thorpej size = wd->sc_dk.dk_label->d_partitions[part].p_size *
1552 1.181 bouyer (wd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
1553 1.158 pk if (omask == 0 && wdclose(dev, 0, S_IFBLK, NULL) != 0)
1554 1.158 pk return (-1);
1555 1.158 pk return (size);
1556 1.1 cgd }
1557 1.1 cgd
1558 1.140 cgd /* #define WD_DUMP_NOT_TRUSTED if you just want to watch */
1559 1.181 bouyer static int wddoingadump = 0;
1560 1.181 bouyer static int wddumprecalibrated = 0;
1561 1.140 cgd
1562 1.64 mycroft /*
1563 1.64 mycroft * Dump core after a system crash.
1564 1.64 mycroft */
1565 1.1 cgd int
1566 1.337 christos wddump(dev_t dev, daddr_t blkno, void *va, size_t size)
1567 1.140 cgd {
1568 1.140 cgd struct wd_softc *wd; /* disk unit to do the I/O */
1569 1.181 bouyer struct disklabel *lp; /* disk's disklabel */
1570 1.208 thorpej int part, err;
1571 1.181 bouyer int nblks; /* total number of sectors left to write */
1572 1.140 cgd
1573 1.140 cgd /* Check if recursive dump; if so, punt. */
1574 1.116 mycroft if (wddoingadump)
1575 1.116 mycroft return EFAULT;
1576 1.142 mycroft wddoingadump = 1;
1577 1.140 cgd
1578 1.363 tsutsui wd = device_lookup_private(&wd_cd, WDUNIT(dev));
1579 1.208 thorpej if (wd == NULL)
1580 1.208 thorpej return (ENXIO);
1581 1.60 mycroft
1582 1.140 cgd part = WDPART(dev);
1583 1.140 cgd
1584 1.181 bouyer /* Convert to disk sectors. Request must be a multiple of size. */
1585 1.144 thorpej lp = wd->sc_dk.dk_label;
1586 1.142 mycroft if ((size % lp->d_secsize) != 0)
1587 1.140 cgd return EFAULT;
1588 1.142 mycroft nblks = size / lp->d_secsize;
1589 1.142 mycroft blkno = blkno / (lp->d_secsize / DEV_BSIZE);
1590 1.116 mycroft
1591 1.64 mycroft /* Check transfer bounds against partition size. */
1592 1.142 mycroft if ((blkno < 0) || ((blkno + nblks) > lp->d_partitions[part].p_size))
1593 1.259 dsl return EINVAL;
1594 1.140 cgd
1595 1.140 cgd /* Offset block number to start of partition. */
1596 1.142 mycroft blkno += lp->d_partitions[part].p_offset;
1597 1.60 mycroft
1598 1.140 cgd /* Recalibrate, if first dump transfer. */
1599 1.140 cgd if (wddumprecalibrated == 0) {
1600 1.140 cgd wddumprecalibrated = 1;
1601 1.290 thorpej (*wd->atabus->ata_reset_drive)(wd->drvp,
1602 1.290 thorpej AT_POLL | AT_RST_EMERG);
1603 1.205 bouyer wd->drvp->state = RESET;
1604 1.63 mycroft }
1605 1.259 dsl
1606 1.308 bouyer wd->sc_bp = NULL;
1607 1.308 bouyer wd->sc_wdc_bio.blkno = blkno;
1608 1.308 bouyer wd->sc_wdc_bio.flags = ATA_POLL;
1609 1.308 bouyer if (wd->sc_flags & WDF_LBA48 &&
1610 1.380 bouyer (wd->sc_wdc_bio.blkno + nblks) > wd->sc_capacity28)
1611 1.308 bouyer wd->sc_wdc_bio.flags |= ATA_LBA48;
1612 1.308 bouyer if (wd->sc_flags & WDF_LBA)
1613 1.308 bouyer wd->sc_wdc_bio.flags |= ATA_LBA;
1614 1.308 bouyer wd->sc_wdc_bio.bcount = nblks * lp->d_secsize;
1615 1.308 bouyer wd->sc_wdc_bio.databuf = va;
1616 1.181 bouyer #ifndef WD_DUMP_NOT_TRUSTED
1617 1.365 christos switch (err = wd->atabus->ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
1618 1.308 bouyer case ATACMD_TRY_AGAIN:
1619 1.308 bouyer panic("wddump: try again");
1620 1.308 bouyer break;
1621 1.308 bouyer case ATACMD_QUEUED:
1622 1.308 bouyer panic("wddump: polled command has been queued");
1623 1.308 bouyer break;
1624 1.308 bouyer case ATACMD_COMPLETE:
1625 1.308 bouyer break;
1626 1.365 christos default:
1627 1.365 christos panic("wddump: unknown atacmd code %d", err);
1628 1.308 bouyer }
1629 1.365 christos switch(err = wd->sc_wdc_bio.error) {
1630 1.308 bouyer case TIMEOUT:
1631 1.308 bouyer printf("wddump: device timed out");
1632 1.308 bouyer err = EIO;
1633 1.308 bouyer break;
1634 1.308 bouyer case ERR_DF:
1635 1.308 bouyer printf("wddump: drive fault");
1636 1.308 bouyer err = EIO;
1637 1.308 bouyer break;
1638 1.308 bouyer case ERR_DMA:
1639 1.308 bouyer printf("wddump: DMA error");
1640 1.308 bouyer err = EIO;
1641 1.308 bouyer break;
1642 1.308 bouyer case ERROR:
1643 1.308 bouyer printf("wddump: ");
1644 1.308 bouyer wdperror(wd);
1645 1.308 bouyer err = EIO;
1646 1.308 bouyer break;
1647 1.308 bouyer case NOERROR:
1648 1.308 bouyer err = 0;
1649 1.308 bouyer break;
1650 1.308 bouyer default:
1651 1.365 christos panic("wddump: unknown error type %d", err);
1652 1.308 bouyer }
1653 1.308 bouyer if (err != 0) {
1654 1.308 bouyer printf("\n");
1655 1.308 bouyer return err;
1656 1.308 bouyer }
1657 1.140 cgd #else /* WD_DUMP_NOT_TRUSTED */
1658 1.308 bouyer /* Let's just talk about this first... */
1659 1.308 bouyer printf("wd%d: dump addr 0x%x, cylin %d, head %d, sector %d\n",
1660 1.308 bouyer unit, va, cylin, head, sector);
1661 1.308 bouyer delay(500 * 1000); /* half a second */
1662 1.140 cgd #endif
1663 1.1 cgd
1664 1.140 cgd wddoingadump = 0;
1665 1.140 cgd return 0;
1666 1.140 cgd }
1667 1.3 deraadt
1668 1.170 leo #ifdef HAS_BAD144_HANDLING
1669 1.3 deraadt /*
1670 1.3 deraadt * Internalize the bad sector table.
1671 1.3 deraadt */
1672 1.3 deraadt void
1673 1.259 dsl bad144intern(struct wd_softc *wd)
1674 1.3 deraadt {
1675 1.144 thorpej struct dkbad *bt = &wd->sc_dk.dk_cpulabel->bad;
1676 1.144 thorpej struct disklabel *lp = wd->sc_dk.dk_label;
1677 1.98 mycroft int i = 0;
1678 1.55 mycroft
1679 1.289 thorpej ATADEBUG_PRINT(("bad144intern\n"), DEBUG_XFERS);
1680 1.163 bouyer
1681 1.170 leo for (; i < NBT_BAD; i++) {
1682 1.98 mycroft if (bt->bt_bad[i].bt_cyl == 0xffff)
1683 1.55 mycroft break;
1684 1.181 bouyer wd->sc_badsect[i] =
1685 1.98 mycroft bt->bt_bad[i].bt_cyl * lp->d_secpercyl +
1686 1.98 mycroft (bt->bt_bad[i].bt_trksec >> 8) * lp->d_nsectors +
1687 1.98 mycroft (bt->bt_bad[i].bt_trksec & 0xff);
1688 1.3 deraadt }
1689 1.170 leo for (; i < NBT_BAD+1; i++)
1690 1.181 bouyer wd->sc_badsect[i] = -1;
1691 1.64 mycroft }
1692 1.170 leo #endif
1693 1.64 mycroft
1694 1.330 thorpej static void
1695 1.335 christos wd_params_to_properties(struct wd_softc *wd, struct ataparams *params)
1696 1.330 thorpej {
1697 1.332 thorpej prop_dictionary_t disk_info, odisk_info, geom;
1698 1.333 thorpej const char *cp;
1699 1.330 thorpej
1700 1.330 thorpej disk_info = prop_dictionary_create();
1701 1.330 thorpej
1702 1.330 thorpej if (strcmp(wd->sc_params.atap_model, "ST506") == 0)
1703 1.333 thorpej cp = "ST506";
1704 1.330 thorpej else {
1705 1.330 thorpej /* XXX Should have a case for ATA here, too. */
1706 1.333 thorpej cp = "ESDI";
1707 1.330 thorpej }
1708 1.333 thorpej prop_dictionary_set_cstring_nocopy(disk_info, "type", cp);
1709 1.330 thorpej
1710 1.330 thorpej geom = prop_dictionary_create();
1711 1.330 thorpej
1712 1.333 thorpej prop_dictionary_set_uint64(geom, "sectors-per-unit", wd->sc_capacity);
1713 1.333 thorpej
1714 1.333 thorpej prop_dictionary_set_uint32(geom, "sector-size",
1715 1.333 thorpej DEV_BSIZE /* XXX 512? */);
1716 1.333 thorpej
1717 1.333 thorpej prop_dictionary_set_uint16(geom, "sectors-per-track",
1718 1.333 thorpej wd->sc_params.atap_sectors);
1719 1.333 thorpej
1720 1.333 thorpej prop_dictionary_set_uint16(geom, "tracks-per-cylinder",
1721 1.333 thorpej wd->sc_params.atap_heads);
1722 1.333 thorpej
1723 1.333 thorpej if (wd->sc_flags & WDF_LBA)
1724 1.333 thorpej prop_dictionary_set_uint64(geom, "cylinders-per-unit",
1725 1.333 thorpej wd->sc_capacity /
1726 1.333 thorpej (wd->sc_params.atap_heads *
1727 1.333 thorpej wd->sc_params.atap_sectors));
1728 1.333 thorpej else
1729 1.333 thorpej prop_dictionary_set_uint16(geom, "cylinders-per-unit",
1730 1.333 thorpej wd->sc_params.atap_cylinders);
1731 1.330 thorpej
1732 1.330 thorpej prop_dictionary_set(disk_info, "geometry", geom);
1733 1.330 thorpej prop_object_release(geom);
1734 1.330 thorpej
1735 1.360 cube prop_dictionary_set(device_properties(wd->sc_dev),
1736 1.330 thorpej "disk-info", disk_info);
1737 1.332 thorpej
1738 1.332 thorpej /*
1739 1.332 thorpej * Don't release disk_info here; we keep a reference to it.
1740 1.332 thorpej * disk_detach() will release it when we go away.
1741 1.332 thorpej */
1742 1.332 thorpej
1743 1.332 thorpej odisk_info = wd->sc_dk.dk_info;
1744 1.332 thorpej wd->sc_dk.dk_info = disk_info;
1745 1.332 thorpej if (odisk_info)
1746 1.332 thorpej prop_object_release(odisk_info);
1747 1.330 thorpej }
1748 1.330 thorpej
1749 1.181 bouyer int
1750 1.259 dsl wd_get_params(struct wd_softc *wd, u_int8_t flags, struct ataparams *params)
1751 1.63 mycroft {
1752 1.350 itohy
1753 1.217 bouyer switch (wd->atabus->ata_get_params(wd->drvp, flags, params)) {
1754 1.181 bouyer case CMD_AGAIN:
1755 1.181 bouyer return 1;
1756 1.181 bouyer case CMD_ERR:
1757 1.181 bouyer /*
1758 1.181 bouyer * We `know' there's a drive here; just assume it's old.
1759 1.181 bouyer * This geometry is only used to read the MBR and print a
1760 1.181 bouyer * (false) attach message.
1761 1.181 bouyer */
1762 1.181 bouyer strncpy(params->atap_model, "ST506",
1763 1.181 bouyer sizeof params->atap_model);
1764 1.181 bouyer params->atap_config = ATA_CFG_FIXED;
1765 1.181 bouyer params->atap_cylinders = 1024;
1766 1.181 bouyer params->atap_heads = 8;
1767 1.181 bouyer params->atap_sectors = 17;
1768 1.181 bouyer params->atap_multi = 1;
1769 1.181 bouyer params->atap_capabilities1 = params->atap_capabilities2 = 0;
1770 1.190 bouyer wd->drvp->ata_vers = -1; /* Mark it as pre-ATA */
1771 1.330 thorpej /* FALLTHROUGH */
1772 1.181 bouyer case CMD_OK:
1773 1.330 thorpej wd_params_to_properties(wd, params);
1774 1.181 bouyer return 0;
1775 1.181 bouyer default:
1776 1.181 bouyer panic("wd_get_params: bad return code from ata_get_params");
1777 1.181 bouyer /* NOTREACHED */
1778 1.181 bouyer }
1779 1.248 bouyer }
1780 1.248 bouyer
1781 1.248 bouyer int
1782 1.259 dsl wd_getcache(struct wd_softc *wd, int *bitsp)
1783 1.248 bouyer {
1784 1.248 bouyer struct ataparams params;
1785 1.248 bouyer
1786 1.248 bouyer if (wd_get_params(wd, AT_WAIT, ¶ms) != 0)
1787 1.248 bouyer return EIO;
1788 1.248 bouyer if (params.atap_cmd_set1 == 0x0000 ||
1789 1.248 bouyer params.atap_cmd_set1 == 0xffff ||
1790 1.248 bouyer (params.atap_cmd_set1 & WDC_CMD1_CACHE) == 0) {
1791 1.248 bouyer *bitsp = 0;
1792 1.248 bouyer return 0;
1793 1.248 bouyer }
1794 1.248 bouyer *bitsp = DKCACHE_WCHANGE | DKCACHE_READ;
1795 1.248 bouyer if (params.atap_cmd1_en & WDC_CMD1_CACHE)
1796 1.248 bouyer *bitsp |= DKCACHE_WRITE;
1797 1.248 bouyer
1798 1.248 bouyer return 0;
1799 1.248 bouyer }
1800 1.248 bouyer
1801 1.286 mycroft const char at_errbits[] = "\20\10ERROR\11TIMEOU\12DF";
1802 1.286 mycroft
1803 1.248 bouyer int
1804 1.259 dsl wd_setcache(struct wd_softc *wd, int bits)
1805 1.248 bouyer {
1806 1.248 bouyer struct ataparams params;
1807 1.287 thorpej struct ata_command ata_c;
1808 1.248 bouyer
1809 1.248 bouyer if (wd_get_params(wd, AT_WAIT, ¶ms) != 0)
1810 1.248 bouyer return EIO;
1811 1.248 bouyer
1812 1.248 bouyer if (params.atap_cmd_set1 == 0x0000 ||
1813 1.250 bouyer params.atap_cmd_set1 == 0xffff ||
1814 1.248 bouyer (params.atap_cmd_set1 & WDC_CMD1_CACHE) == 0)
1815 1.248 bouyer return EOPNOTSUPP;
1816 1.248 bouyer
1817 1.249 bouyer if ((bits & DKCACHE_READ) == 0 ||
1818 1.249 bouyer (bits & DKCACHE_SAVE) != 0)
1819 1.248 bouyer return EOPNOTSUPP;
1820 1.248 bouyer
1821 1.287 thorpej memset(&ata_c, 0, sizeof(struct ata_command));
1822 1.287 thorpej ata_c.r_command = SET_FEATURES;
1823 1.287 thorpej ata_c.r_st_bmask = 0;
1824 1.287 thorpej ata_c.r_st_pmask = 0;
1825 1.287 thorpej ata_c.timeout = 30000; /* 30s timeout */
1826 1.287 thorpej ata_c.flags = AT_WAIT;
1827 1.248 bouyer if (bits & DKCACHE_WRITE)
1828 1.287 thorpej ata_c.r_features = WDSF_WRITE_CACHE_EN;
1829 1.248 bouyer else
1830 1.287 thorpej ata_c.r_features = WDSF_WRITE_CACHE_DS;
1831 1.288 thorpej if (wd->atabus->ata_exec_command(wd->drvp, &ata_c) != ATACMD_COMPLETE) {
1832 1.360 cube aprint_error_dev(wd->sc_dev,
1833 1.360 cube "wd_setcache command not complete\n");
1834 1.248 bouyer return EIO;
1835 1.248 bouyer }
1836 1.287 thorpej if (ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
1837 1.286 mycroft char sbuf[sizeof(at_errbits) + 64];
1838 1.366 christos snprintb(sbuf, sizeof(sbuf), at_errbits, ata_c.flags);
1839 1.360 cube aprint_error_dev(wd->sc_dev, "wd_setcache: status=%s\n", sbuf);
1840 1.286 mycroft return EIO;
1841 1.286 mycroft }
1842 1.286 mycroft return 0;
1843 1.286 mycroft }
1844 1.286 mycroft
1845 1.351 jmcneill static int
1846 1.286 mycroft wd_standby(struct wd_softc *wd, int flags)
1847 1.286 mycroft {
1848 1.287 thorpej struct ata_command ata_c;
1849 1.286 mycroft
1850 1.287 thorpej memset(&ata_c, 0, sizeof(struct ata_command));
1851 1.287 thorpej ata_c.r_command = WDCC_STANDBY_IMMED;
1852 1.287 thorpej ata_c.r_st_bmask = WDCS_DRDY;
1853 1.287 thorpej ata_c.r_st_pmask = WDCS_DRDY;
1854 1.287 thorpej ata_c.flags = flags;
1855 1.287 thorpej ata_c.timeout = 30000; /* 30s timeout */
1856 1.288 thorpej if (wd->atabus->ata_exec_command(wd->drvp, &ata_c) != ATACMD_COMPLETE) {
1857 1.360 cube aprint_error_dev(wd->sc_dev,
1858 1.351 jmcneill "standby immediate command didn't complete\n");
1859 1.286 mycroft return EIO;
1860 1.286 mycroft }
1861 1.287 thorpej if (ata_c.flags & AT_ERROR) {
1862 1.287 thorpej if (ata_c.r_error == WDCE_ABRT) /* command not supported */
1863 1.286 mycroft return ENODEV;
1864 1.286 mycroft }
1865 1.287 thorpej if (ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
1866 1.286 mycroft char sbuf[sizeof(at_errbits) + 64];
1867 1.366 christos snprintb(sbuf, sizeof(sbuf), at_errbits, ata_c.flags);
1868 1.360 cube aprint_error_dev(wd->sc_dev, "wd_standby: status=%s\n", sbuf);
1869 1.248 bouyer return EIO;
1870 1.248 bouyer }
1871 1.248 bouyer return 0;
1872 1.190 bouyer }
1873 1.190 bouyer
1874 1.276 bouyer int
1875 1.259 dsl wd_flushcache(struct wd_softc *wd, int flags)
1876 1.190 bouyer {
1877 1.287 thorpej struct ata_command ata_c;
1878 1.190 bouyer
1879 1.297 bouyer /*
1880 1.297 bouyer * WDCC_FLUSHCACHE is here since ATA-4, but some drives report
1881 1.297 bouyer * only ATA-2 and still support it.
1882 1.297 bouyer */
1883 1.297 bouyer if (wd->drvp->ata_vers < 4 &&
1884 1.297 bouyer ((wd->sc_params.atap_cmd_set2 & WDC_CMD2_FC) == 0 ||
1885 1.297 bouyer wd->sc_params.atap_cmd_set2 == 0xffff))
1886 1.276 bouyer return ENODEV;
1887 1.287 thorpej memset(&ata_c, 0, sizeof(struct ata_command));
1888 1.275 bouyer if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0 &&
1889 1.275 bouyer (wd->sc_params.atap_cmd2_en & ATA_CMD2_FCE) != 0)
1890 1.287 thorpej ata_c.r_command = WDCC_FLUSHCACHE_EXT;
1891 1.275 bouyer else
1892 1.287 thorpej ata_c.r_command = WDCC_FLUSHCACHE;
1893 1.287 thorpej ata_c.r_st_bmask = WDCS_DRDY;
1894 1.287 thorpej ata_c.r_st_pmask = WDCS_DRDY;
1895 1.287 thorpej ata_c.flags = flags;
1896 1.287 thorpej ata_c.timeout = 30000; /* 30s timeout */
1897 1.288 thorpej if (wd->atabus->ata_exec_command(wd->drvp, &ata_c) != ATACMD_COMPLETE) {
1898 1.360 cube aprint_error_dev(wd->sc_dev,
1899 1.360 cube "flush cache command didn't complete\n");
1900 1.276 bouyer return EIO;
1901 1.190 bouyer }
1902 1.287 thorpej if (ata_c.flags & AT_ERROR) {
1903 1.287 thorpej if (ata_c.r_error == WDCE_ABRT) /* command not supported */
1904 1.276 bouyer return ENODEV;
1905 1.190 bouyer }
1906 1.287 thorpej if (ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
1907 1.286 mycroft char sbuf[sizeof(at_errbits) + 64];
1908 1.366 christos snprintb(sbuf, sizeof(sbuf), at_errbits, ata_c.flags);
1909 1.360 cube aprint_error_dev(wd->sc_dev, "wd_flushcache: status=%s\n",
1910 1.286 mycroft sbuf);
1911 1.276 bouyer return EIO;
1912 1.190 bouyer }
1913 1.276 bouyer return 0;
1914 1.190 bouyer }
1915 1.190 bouyer
1916 1.357 drochner bool
1917 1.357 drochner wd_shutdown(device_t dev, int how)
1918 1.356 drochner {
1919 1.368 drochner struct wd_softc *wd = device_private(dev);
1920 1.368 drochner
1921 1.368 drochner /* the adapter needs to be enabled */
1922 1.368 drochner if (wd->atabus->ata_addref(wd->drvp))
1923 1.368 drochner return true; /* no need to complain */
1924 1.356 drochner
1925 1.356 drochner wd_flushcache(wd, AT_POLL);
1926 1.357 drochner if ((how & RB_POWERDOWN) == RB_POWERDOWN)
1927 1.356 drochner wd_standby(wd, AT_POLL);
1928 1.357 drochner return true;
1929 1.356 drochner }
1930 1.356 drochner
1931 1.185 kenh /*
1932 1.185 kenh * Allocate space for a ioctl queue structure. Mostly taken from
1933 1.185 kenh * scsipi_ioctl.c
1934 1.185 kenh */
1935 1.185 kenh struct wd_ioctl *
1936 1.259 dsl wi_get(void)
1937 1.185 kenh {
1938 1.185 kenh struct wd_ioctl *wi;
1939 1.185 kenh int s;
1940 1.185 kenh
1941 1.219 tsutsui wi = malloc(sizeof(struct wd_ioctl), M_TEMP, M_WAITOK|M_ZERO);
1942 1.355 ad buf_init(&wi->wi_bp);
1943 1.185 kenh s = splbio();
1944 1.185 kenh LIST_INSERT_HEAD(&wi_head, wi, wi_list);
1945 1.185 kenh splx(s);
1946 1.185 kenh return (wi);
1947 1.185 kenh }
1948 1.185 kenh
1949 1.185 kenh /*
1950 1.185 kenh * Free an ioctl structure and remove it from our list
1951 1.185 kenh */
1952 1.185 kenh
1953 1.185 kenh void
1954 1.259 dsl wi_free(struct wd_ioctl *wi)
1955 1.185 kenh {
1956 1.185 kenh int s;
1957 1.185 kenh
1958 1.185 kenh s = splbio();
1959 1.185 kenh LIST_REMOVE(wi, wi_list);
1960 1.185 kenh splx(s);
1961 1.355 ad buf_destroy(&wi->wi_bp);
1962 1.185 kenh free(wi, M_TEMP);
1963 1.185 kenh }
1964 1.185 kenh
1965 1.185 kenh /*
1966 1.185 kenh * Find a wd_ioctl structure based on the struct buf.
1967 1.185 kenh */
1968 1.185 kenh
1969 1.185 kenh struct wd_ioctl *
1970 1.259 dsl wi_find(struct buf *bp)
1971 1.185 kenh {
1972 1.185 kenh struct wd_ioctl *wi;
1973 1.185 kenh int s;
1974 1.185 kenh
1975 1.185 kenh s = splbio();
1976 1.185 kenh for (wi = wi_head.lh_first; wi != 0; wi = wi->wi_list.le_next)
1977 1.185 kenh if (bp == &wi->wi_bp)
1978 1.185 kenh break;
1979 1.185 kenh splx(s);
1980 1.185 kenh return (wi);
1981 1.185 kenh }
1982 1.185 kenh
1983 1.185 kenh /*
1984 1.185 kenh * Ioctl pseudo strategy routine
1985 1.185 kenh *
1986 1.185 kenh * This is mostly stolen from scsipi_ioctl.c:scsistrategy(). What
1987 1.185 kenh * happens here is:
1988 1.185 kenh *
1989 1.185 kenh * - wdioctl() queues a wd_ioctl structure.
1990 1.185 kenh *
1991 1.185 kenh * - wdioctl() calls physio/wdioctlstrategy based on whether or not
1992 1.185 kenh * user space I/O is required. If physio() is called, physio() eventually
1993 1.185 kenh * calls wdioctlstrategy().
1994 1.185 kenh *
1995 1.217 bouyer * - In either case, wdioctlstrategy() calls wd->atabus->ata_exec_command()
1996 1.185 kenh * to perform the actual command
1997 1.185 kenh *
1998 1.185 kenh * The reason for the use of the pseudo strategy routine is because
1999 1.185 kenh * when doing I/O to/from user space, physio _really_ wants to be in
2000 1.185 kenh * the loop. We could put the entire buffer into the ioctl request
2001 1.185 kenh * structure, but that won't scale if we want to do things like download
2002 1.185 kenh * microcode.
2003 1.185 kenh */
2004 1.185 kenh
2005 1.185 kenh void
2006 1.259 dsl wdioctlstrategy(struct buf *bp)
2007 1.185 kenh {
2008 1.185 kenh struct wd_ioctl *wi;
2009 1.287 thorpej struct ata_command ata_c;
2010 1.185 kenh int error = 0;
2011 1.185 kenh
2012 1.185 kenh wi = wi_find(bp);
2013 1.185 kenh if (wi == NULL) {
2014 1.313 martin printf("wdioctlstrategy: "
2015 1.313 martin "No matching ioctl request found in queue\n");
2016 1.185 kenh error = EINVAL;
2017 1.355 ad goto bad;
2018 1.185 kenh }
2019 1.185 kenh
2020 1.287 thorpej memset(&ata_c, 0, sizeof(ata_c));
2021 1.185 kenh
2022 1.185 kenh /*
2023 1.185 kenh * Abort if physio broke up the transfer
2024 1.185 kenh */
2025 1.185 kenh
2026 1.186 kenh if (bp->b_bcount != wi->wi_atareq.datalen) {
2027 1.185 kenh printf("physio split wd ioctl request... cannot proceed\n");
2028 1.185 kenh error = EIO;
2029 1.355 ad goto bad;
2030 1.185 kenh }
2031 1.185 kenh
2032 1.185 kenh /*
2033 1.185 kenh * Abort if we didn't get a buffer size that was a multiple of
2034 1.185 kenh * our sector size (or was larger than NBBY)
2035 1.185 kenh */
2036 1.185 kenh
2037 1.185 kenh if ((bp->b_bcount % wi->wi_softc->sc_dk.dk_label->d_secsize) != 0 ||
2038 1.185 kenh (bp->b_bcount / wi->wi_softc->sc_dk.dk_label->d_secsize) >=
2039 1.185 kenh (1 << NBBY)) {
2040 1.185 kenh error = EINVAL;
2041 1.355 ad goto bad;
2042 1.185 kenh }
2043 1.185 kenh
2044 1.185 kenh /*
2045 1.185 kenh * Make sure a timeout was supplied in the ioctl request
2046 1.185 kenh */
2047 1.185 kenh
2048 1.186 kenh if (wi->wi_atareq.timeout == 0) {
2049 1.185 kenh error = EINVAL;
2050 1.355 ad goto bad;
2051 1.185 kenh }
2052 1.185 kenh
2053 1.186 kenh if (wi->wi_atareq.flags & ATACMD_READ)
2054 1.287 thorpej ata_c.flags |= AT_READ;
2055 1.186 kenh else if (wi->wi_atareq.flags & ATACMD_WRITE)
2056 1.287 thorpej ata_c.flags |= AT_WRITE;
2057 1.185 kenh
2058 1.188 kenh if (wi->wi_atareq.flags & ATACMD_READREG)
2059 1.287 thorpej ata_c.flags |= AT_READREG;
2060 1.188 kenh
2061 1.391 jakllsch if ((wi->wi_atareq.flags & ATACMD_LBA) != 0)
2062 1.391 jakllsch ata_c.flags |= AT_LBA;
2063 1.391 jakllsch
2064 1.287 thorpej ata_c.flags |= AT_WAIT;
2065 1.185 kenh
2066 1.287 thorpej ata_c.timeout = wi->wi_atareq.timeout;
2067 1.287 thorpej ata_c.r_command = wi->wi_atareq.command;
2068 1.391 jakllsch ata_c.r_lba = ((wi->wi_atareq.head & 0x0f) << 24) |
2069 1.391 jakllsch (wi->wi_atareq.cylinder << 8) |
2070 1.391 jakllsch wi->wi_atareq.sec_num;
2071 1.287 thorpej ata_c.r_count = wi->wi_atareq.sec_count;
2072 1.287 thorpej ata_c.r_features = wi->wi_atareq.features;
2073 1.287 thorpej ata_c.r_st_bmask = WDCS_DRDY;
2074 1.287 thorpej ata_c.r_st_pmask = WDCS_DRDY;
2075 1.287 thorpej ata_c.data = wi->wi_bp.b_data;
2076 1.287 thorpej ata_c.bcount = wi->wi_bp.b_bcount;
2077 1.185 kenh
2078 1.287 thorpej if (wi->wi_softc->atabus->ata_exec_command(wi->wi_softc->drvp, &ata_c)
2079 1.288 thorpej != ATACMD_COMPLETE) {
2080 1.186 kenh wi->wi_atareq.retsts = ATACMD_ERROR;
2081 1.355 ad goto bad;
2082 1.185 kenh }
2083 1.185 kenh
2084 1.287 thorpej if (ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
2085 1.287 thorpej if (ata_c.flags & AT_ERROR) {
2086 1.186 kenh wi->wi_atareq.retsts = ATACMD_ERROR;
2087 1.287 thorpej wi->wi_atareq.error = ata_c.r_error;
2088 1.287 thorpej } else if (ata_c.flags & AT_DF)
2089 1.186 kenh wi->wi_atareq.retsts = ATACMD_DF;
2090 1.185 kenh else
2091 1.186 kenh wi->wi_atareq.retsts = ATACMD_TIMEOUT;
2092 1.188 kenh } else {
2093 1.186 kenh wi->wi_atareq.retsts = ATACMD_OK;
2094 1.188 kenh if (wi->wi_atareq.flags & ATACMD_READREG) {
2095 1.391 jakllsch wi->wi_atareq.command = ata_c.r_status;
2096 1.391 jakllsch wi->wi_atareq.features = ata_c.r_error;
2097 1.287 thorpej wi->wi_atareq.sec_count = ata_c.r_count;
2098 1.391 jakllsch wi->wi_atareq.sec_num = ata_c.r_lba & 0xff;
2099 1.391 jakllsch wi->wi_atareq.head = (ata_c.r_device & 0xf0) |
2100 1.391 jakllsch ((ata_c.r_lba >> 24) & 0x0f);
2101 1.391 jakllsch wi->wi_atareq.cylinder = (ata_c.r_lba >> 8) & 0xffff;
2102 1.287 thorpej wi->wi_atareq.error = ata_c.r_error;
2103 1.188 kenh }
2104 1.188 kenh }
2105 1.185 kenh
2106 1.355 ad bp->b_error = 0;
2107 1.355 ad biodone(bp);
2108 1.355 ad return;
2109 1.355 ad bad:
2110 1.185 kenh bp->b_error = error;
2111 1.185 kenh biodone(bp);
2112 1.21 deraadt }
2113