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