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