sd.c revision 1.141 1 1.141 bouyer /* $NetBSD: sd.c,v 1.141 1999/01/29 11:17:59 bouyer Exp $ */
2 1.33 cgd
3 1.134 mycroft /*-
4 1.134 mycroft * Copyright (c) 1998 The NetBSD Foundation, Inc.
5 1.134 mycroft * All rights reserved.
6 1.134 mycroft *
7 1.134 mycroft * This code is derived from software contributed to The NetBSD Foundation
8 1.134 mycroft * by Charles M. Hannum.
9 1.25 mycroft *
10 1.25 mycroft * Redistribution and use in source and binary forms, with or without
11 1.25 mycroft * modification, are permitted provided that the following conditions
12 1.25 mycroft * are met:
13 1.25 mycroft * 1. Redistributions of source code must retain the above copyright
14 1.25 mycroft * notice, this list of conditions and the following disclaimer.
15 1.25 mycroft * 2. Redistributions in binary form must reproduce the above copyright
16 1.25 mycroft * notice, this list of conditions and the following disclaimer in the
17 1.25 mycroft * documentation and/or other materials provided with the distribution.
18 1.25 mycroft * 3. All advertising materials mentioning features or use of this software
19 1.25 mycroft * must display the following acknowledgement:
20 1.134 mycroft * This product includes software developed by the NetBSD
21 1.134 mycroft * Foundation, Inc. and its contributors.
22 1.134 mycroft * 4. Neither the name of The NetBSD Foundation nor the names of its
23 1.134 mycroft * contributors may be used to endorse or promote products derived
24 1.134 mycroft * from this software without specific prior written permission.
25 1.25 mycroft *
26 1.134 mycroft * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 1.134 mycroft * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 1.134 mycroft * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 1.134 mycroft * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 1.134 mycroft * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 1.134 mycroft * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 1.134 mycroft * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 1.134 mycroft * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 1.134 mycroft * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 1.134 mycroft * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 1.134 mycroft * POSSIBILITY OF SUCH DAMAGE.
37 1.25 mycroft */
38 1.25 mycroft
39 1.75 mycroft /*
40 1.25 mycroft * Originally written by Julian Elischer (julian (at) dialix.oz.au)
41 1.8 deraadt * for TRW Financial Systems for use under the MACH(2.5) operating system.
42 1.1 cgd *
43 1.1 cgd * TRW Financial Systems, in accordance with their agreement with Carnegie
44 1.1 cgd * Mellon University, makes this software available to CMU to distribute
45 1.1 cgd * or use in any manner that they see fit as long as this message is kept with
46 1.1 cgd * the software. For this reason TFS also grants any other persons or
47 1.1 cgd * organisations permission to use or modify this software.
48 1.1 cgd *
49 1.1 cgd * TFS supplies this software to be publicly redistributed
50 1.1 cgd * on the understanding that TFS is not responsible for the correct
51 1.1 cgd * functioning of this software in any circumstances.
52 1.9 cgd *
53 1.25 mycroft * Ported to run under 386BSD by Julian Elischer (julian (at) dialix.oz.au) Sept 1992
54 1.1 cgd */
55 1.1 cgd
56 1.128 mjacob #include "opt_scsi.h"
57 1.121 explorer #include "rnd.h"
58 1.121 explorer
59 1.19 mycroft #include <sys/types.h>
60 1.19 mycroft #include <sys/param.h>
61 1.19 mycroft #include <sys/systm.h>
62 1.54 mycroft #include <sys/kernel.h>
63 1.19 mycroft #include <sys/file.h>
64 1.19 mycroft #include <sys/stat.h>
65 1.19 mycroft #include <sys/ioctl.h>
66 1.140 bouyer #include <sys/scsiio.h>
67 1.19 mycroft #include <sys/buf.h>
68 1.19 mycroft #include <sys/uio.h>
69 1.19 mycroft #include <sys/malloc.h>
70 1.19 mycroft #include <sys/errno.h>
71 1.25 mycroft #include <sys/device.h>
72 1.19 mycroft #include <sys/disklabel.h>
73 1.25 mycroft #include <sys/disk.h>
74 1.87 christos #include <sys/proc.h>
75 1.95 christos #include <sys/conf.h>
76 1.121 explorer #if NRND > 0
77 1.120 explorer #include <sys/rnd.h>
78 1.121 explorer #endif
79 1.19 mycroft
80 1.116 bouyer #include <dev/scsipi/scsipi_all.h>
81 1.116 bouyer #include <dev/scsipi/scsi_all.h>
82 1.124 cgd #include <dev/scsipi/scsipi_disk.h>
83 1.116 bouyer #include <dev/scsipi/scsi_disk.h>
84 1.116 bouyer #include <dev/scsipi/scsiconf.h>
85 1.124 cgd #include <dev/scsipi/sdvar.h>
86 1.124 cgd
87 1.124 cgd #include "sd.h" /* NSD_SCSIBUS and NSD_ATAPIBUS come from here */
88 1.1 cgd
89 1.117 mjacob #ifndef SDOUTSTANDING
90 1.93 mycroft #define SDOUTSTANDING 4
91 1.117 mjacob #endif
92 1.1 cgd
93 1.36 cgd #define SDUNIT(dev) DISKUNIT(dev)
94 1.36 cgd #define SDPART(dev) DISKPART(dev)
95 1.36 cgd #define MAKESDDEV(maj, unit, part) MAKEDISKDEV(maj, unit, part)
96 1.36 cgd
97 1.36 cgd #define SDLABELDEV(dev) (MAKESDDEV(major(dev), SDUNIT(dev), RAW_PART))
98 1.1 cgd
99 1.87 christos int sdlock __P((struct sd_softc *));
100 1.87 christos void sdunlock __P((struct sd_softc *));
101 1.87 christos void sdminphys __P((struct buf *));
102 1.119 thorpej void sdgetdefaultlabel __P((struct sd_softc *, struct disklabel *));
103 1.87 christos void sdgetdisklabel __P((struct sd_softc *));
104 1.87 christos void sdstart __P((void *));
105 1.116 bouyer void sddone __P((struct scsipi_xfer *));
106 1.132 thorpej void sd_shutdown __P((void *));
107 1.87 christos int sd_reassign_blocks __P((struct sd_softc *, u_long));
108 1.127 mjacob int sd_interpret_sense __P((struct scsipi_xfer *));
109 1.89 thorpej
110 1.123 thorpej extern struct cfdriver sd_cd;
111 1.25 mycroft
112 1.25 mycroft struct dkdriver sddkdriver = { sdstrategy };
113 1.25 mycroft
114 1.116 bouyer struct scsipi_device sd_switch = {
115 1.127 mjacob sd_interpret_sense, /* check our error handler first */
116 1.25 mycroft sdstart, /* have a queue, served by this */
117 1.25 mycroft NULL, /* have no async handler */
118 1.84 thorpej sddone, /* deal with stats at interrupt time */
119 1.25 mycroft };
120 1.1 cgd
121 1.3 deraadt /*
122 1.3 deraadt * The routine called by the low level scsi routine when it discovers
123 1.25 mycroft * a device suitable for this driver.
124 1.3 deraadt */
125 1.25 mycroft void
126 1.124 cgd sdattach(parent, sd, sc_link, ops)
127 1.124 cgd struct device *parent;
128 1.124 cgd struct sd_softc *sd;
129 1.124 cgd struct scsipi_link *sc_link;
130 1.124 cgd const struct sd_ops *ops;
131 1.1 cgd {
132 1.124 cgd int error, result;
133 1.25 mycroft struct disk_parms *dp = &sd->params;
134 1.25 mycroft
135 1.25 mycroft SC_DEBUG(sc_link, SDEV_DB2, ("sdattach: "));
136 1.25 mycroft
137 1.25 mycroft /*
138 1.25 mycroft * Store information needed to contact our base driver
139 1.25 mycroft */
140 1.25 mycroft sd->sc_link = sc_link;
141 1.124 cgd sd->sc_ops = ops;
142 1.25 mycroft sc_link->device = &sd_switch;
143 1.46 mycroft sc_link->device_softc = sd;
144 1.51 mycroft if (sc_link->openings > SDOUTSTANDING)
145 1.51 mycroft sc_link->openings = SDOUTSTANDING;
146 1.3 deraadt
147 1.81 thorpej /*
148 1.84 thorpej * Initialize and attach the disk structure.
149 1.81 thorpej */
150 1.84 thorpej sd->sc_dk.dk_driver = &sddkdriver;
151 1.84 thorpej sd->sc_dk.dk_name = sd->sc_dev.dv_xname;
152 1.84 thorpej disk_attach(&sd->sc_dk);
153 1.94 mycroft
154 1.94 mycroft #if !defined(i386)
155 1.94 mycroft dk_establish(&sd->sc_dk, &sd->sc_dev); /* XXX */
156 1.94 mycroft #endif
157 1.81 thorpej
158 1.3 deraadt /*
159 1.3 deraadt * Use the subdriver to request information regarding
160 1.3 deraadt * the drive. We cannot use interrupts yet, so the
161 1.3 deraadt * request must specify this.
162 1.3 deraadt */
163 1.104 christos printf("\n");
164 1.105 matthias
165 1.139 bouyer error = scsipi_start(sd->sc_link, SSS_START,
166 1.139 bouyer SCSI_AUTOCONF | SCSI_IGNORE_ILLEGAL_REQUEST |
167 1.139 bouyer SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT);
168 1.105 matthias
169 1.124 cgd if (error)
170 1.124 cgd result = SDGP_RESULT_OFFLINE;
171 1.51 mycroft else
172 1.124 cgd result = (*sd->sc_ops->sdo_get_parms)(sd, &sd->params,
173 1.124 cgd SCSI_AUTOCONF);
174 1.124 cgd printf("%s: ", sd->sc_dev.dv_xname);
175 1.124 cgd switch (result) {
176 1.124 cgd case SDGP_RESULT_OK:
177 1.124 cgd printf("%ldMB, %ld cyl, %ld head, %ld sec, %ld bytes/sect x %ld sectors",
178 1.51 mycroft dp->disksize / (1048576 / dp->blksize), dp->cyls,
179 1.114 phil dp->heads, dp->sectors, dp->blksize, dp->disksize);
180 1.124 cgd break;
181 1.124 cgd
182 1.124 cgd case SDGP_RESULT_OFFLINE:
183 1.124 cgd printf("drive offline");
184 1.124 cgd break;
185 1.124 cgd
186 1.124 cgd case SDGP_RESULT_UNFORMATTED:
187 1.124 cgd printf("unformatted media");
188 1.124 cgd break;
189 1.124 cgd
190 1.124 cgd #ifdef DIAGNOSTIC
191 1.124 cgd default:
192 1.124 cgd panic("sdattach: unknown result from get_parms");
193 1.124 cgd break;
194 1.124 cgd #endif
195 1.124 cgd }
196 1.124 cgd printf("\n");
197 1.120 explorer
198 1.132 thorpej /*
199 1.132 thorpej * Establish a shutdown hook so that we can ensure that
200 1.132 thorpej * our data has actually made it onto the platter at
201 1.132 thorpej * shutdown time. Note that this relies on the fact
202 1.132 thorpej * that the shutdown hook code puts us at the head of
203 1.132 thorpej * the list (thus guaranteeing that our hook runs before
204 1.132 thorpej * our ancestors').
205 1.132 thorpej */
206 1.132 thorpej if ((sd->sc_sdhook =
207 1.132 thorpej shutdownhook_establish(sd_shutdown, sd)) == NULL)
208 1.132 thorpej printf("%s: WARNING: unable to establish shutdown hook\n",
209 1.132 thorpej sd->sc_dev.dv_xname);
210 1.132 thorpej
211 1.121 explorer #if NRND > 0
212 1.120 explorer /*
213 1.120 explorer * attach the device into the random source list
214 1.120 explorer */
215 1.120 explorer rnd_attach_source(&sd->rnd_source, sd->sc_dev.dv_xname, RND_TYPE_DISK);
216 1.121 explorer #endif
217 1.1 cgd }
218 1.1 cgd
219 1.65 mycroft /*
220 1.65 mycroft * Wait interruptibly for an exclusive lock.
221 1.65 mycroft *
222 1.65 mycroft * XXX
223 1.65 mycroft * Several drivers do this; it should be abstracted and made MP-safe.
224 1.65 mycroft */
225 1.61 mycroft int
226 1.65 mycroft sdlock(sd)
227 1.61 mycroft struct sd_softc *sd;
228 1.61 mycroft {
229 1.61 mycroft int error;
230 1.61 mycroft
231 1.61 mycroft while ((sd->flags & SDF_LOCKED) != 0) {
232 1.61 mycroft sd->flags |= SDF_WANTED;
233 1.61 mycroft if ((error = tsleep(sd, PRIBIO | PCATCH, "sdlck", 0)) != 0)
234 1.118 enami return (error);
235 1.61 mycroft }
236 1.65 mycroft sd->flags |= SDF_LOCKED;
237 1.118 enami return (0);
238 1.61 mycroft }
239 1.61 mycroft
240 1.65 mycroft /*
241 1.65 mycroft * Unlock and wake up any waiters.
242 1.65 mycroft */
243 1.61 mycroft void
244 1.61 mycroft sdunlock(sd)
245 1.61 mycroft struct sd_softc *sd;
246 1.61 mycroft {
247 1.61 mycroft
248 1.61 mycroft sd->flags &= ~SDF_LOCKED;
249 1.61 mycroft if ((sd->flags & SDF_WANTED) != 0) {
250 1.61 mycroft sd->flags &= ~SDF_WANTED;
251 1.61 mycroft wakeup(sd);
252 1.61 mycroft }
253 1.61 mycroft }
254 1.61 mycroft
255 1.3 deraadt /*
256 1.25 mycroft * open the device. Make sure the partition info is a up-to-date as can be.
257 1.3 deraadt */
258 1.3 deraadt int
259 1.87 christos sdopen(dev, flag, fmt, p)
260 1.25 mycroft dev_t dev;
261 1.37 mycroft int flag, fmt;
262 1.87 christos struct proc *p;
263 1.1 cgd {
264 1.51 mycroft struct sd_softc *sd;
265 1.116 bouyer struct scsipi_link *sc_link;
266 1.65 mycroft int unit, part;
267 1.65 mycroft int error;
268 1.1 cgd
269 1.25 mycroft unit = SDUNIT(dev);
270 1.89 thorpej if (unit >= sd_cd.cd_ndevs)
271 1.118 enami return (ENXIO);
272 1.89 thorpej sd = sd_cd.cd_devs[unit];
273 1.112 pk if (sd == NULL)
274 1.118 enami return (ENXIO);
275 1.3 deraadt
276 1.25 mycroft sc_link = sd->sc_link;
277 1.140 bouyer part = SDPART(dev);
278 1.25 mycroft
279 1.25 mycroft SC_DEBUG(sc_link, SDEV_DB1,
280 1.98 christos ("sdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit,
281 1.140 bouyer sd_cd.cd_ndevs, part));
282 1.3 deraadt
283 1.137 thorpej /*
284 1.137 thorpej * If this is the first open of this device, add a reference
285 1.137 thorpej * to the adapter.
286 1.137 thorpej */
287 1.137 thorpej if (sd->sc_dk.dk_openmask == 0 &&
288 1.137 thorpej (error = scsipi_adapter_addref(sc_link)) != 0)
289 1.137 thorpej return (error);
290 1.137 thorpej
291 1.87 christos if ((error = sdlock(sd)) != 0)
292 1.137 thorpej goto bad4;
293 1.45 mycroft
294 1.140 bouyer if ((sc_link->flags & SDEV_OPEN) != 0) {
295 1.47 mycroft /*
296 1.47 mycroft * If any partition is open, but the disk has been invalidated,
297 1.140 bouyer * disallow further opens of non-raw partition
298 1.47 mycroft */
299 1.140 bouyer if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0 &&
300 1.141 bouyer (part != RAW_PART || fmt != S_IFCHR)) {
301 1.66 mycroft error = EIO;
302 1.66 mycroft goto bad3;
303 1.66 mycroft }
304 1.47 mycroft } else {
305 1.55 mycroft /* Check that it is still responding and ok. */
306 1.116 bouyer error = scsipi_test_unit_ready(sc_link,
307 1.118 enami SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE |
308 1.118 enami SCSI_IGNORE_NOT_READY);
309 1.87 christos if (error)
310 1.57 mycroft goto bad3;
311 1.57 mycroft
312 1.140 bouyer /*
313 1.140 bouyer * Start the pack spinning if necessary. Always allow the
314 1.140 bouyer * raw parition to be opened, for raw IOCTLs. Data transfers
315 1.140 bouyer * will check for SDEV_MEDIA_LOADED.
316 1.140 bouyer */
317 1.139 bouyer error = scsipi_start(sc_link, SSS_START,
318 1.139 bouyer SCSI_IGNORE_ILLEGAL_REQUEST |
319 1.139 bouyer SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT);
320 1.140 bouyer if (error) {
321 1.141 bouyer if (part != RAW_PART || fmt != S_IFCHR)
322 1.140 bouyer goto bad3;
323 1.140 bouyer else
324 1.140 bouyer goto out;
325 1.140 bouyer }
326 1.57 mycroft
327 1.57 mycroft sc_link->flags |= SDEV_OPEN;
328 1.48 mycroft
329 1.45 mycroft /* Lock the pack in. */
330 1.116 bouyer error = scsipi_prevent(sc_link, PR_PREVENT,
331 1.118 enami SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
332 1.87 christos if (error)
333 1.55 mycroft goto bad;
334 1.54 mycroft
335 1.45 mycroft if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
336 1.45 mycroft sc_link->flags |= SDEV_MEDIA_LOADED;
337 1.3 deraadt
338 1.124 cgd /*
339 1.124 cgd * Load the physical device parameters.
340 1.124 cgd *
341 1.124 cgd * Note that if media is present but unformatted,
342 1.124 cgd * we allow the open (so that it can be formatted!).
343 1.124 cgd * The drive should refuse real I/O, if the media is
344 1.124 cgd * unformatted.
345 1.124 cgd */
346 1.124 cgd if ((*sd->sc_ops->sdo_get_parms)(sd, &sd->params,
347 1.124 cgd 0) == SDGP_RESULT_OFFLINE) {
348 1.45 mycroft error = ENXIO;
349 1.45 mycroft goto bad2;
350 1.45 mycroft }
351 1.45 mycroft SC_DEBUG(sc_link, SDEV_DB3, ("Params loaded "));
352 1.45 mycroft
353 1.45 mycroft /* Load the partition info if not already loaded. */
354 1.45 mycroft sdgetdisklabel(sd);
355 1.45 mycroft SC_DEBUG(sc_link, SDEV_DB3, ("Disklabel loaded "));
356 1.45 mycroft }
357 1.65 mycroft }
358 1.25 mycroft
359 1.47 mycroft /* Check that the partition exists. */
360 1.37 mycroft if (part != RAW_PART &&
361 1.84 thorpej (part >= sd->sc_dk.dk_label->d_npartitions ||
362 1.84 thorpej sd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
363 1.25 mycroft error = ENXIO;
364 1.25 mycroft goto bad;
365 1.1 cgd }
366 1.3 deraadt
367 1.140 bouyer out: /* Insure only one open at a time. */
368 1.37 mycroft switch (fmt) {
369 1.37 mycroft case S_IFCHR:
370 1.40 mycroft sd->sc_dk.dk_copenmask |= (1 << part);
371 1.37 mycroft break;
372 1.37 mycroft case S_IFBLK:
373 1.40 mycroft sd->sc_dk.dk_bopenmask |= (1 << part);
374 1.37 mycroft break;
375 1.1 cgd }
376 1.118 enami sd->sc_dk.dk_openmask =
377 1.118 enami sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
378 1.37 mycroft
379 1.25 mycroft SC_DEBUG(sc_link, SDEV_DB3, ("open complete\n"));
380 1.65 mycroft sdunlock(sd);
381 1.118 enami return (0);
382 1.1 cgd
383 1.45 mycroft bad2:
384 1.45 mycroft sc_link->flags &= ~SDEV_MEDIA_LOADED;
385 1.45 mycroft
386 1.25 mycroft bad:
387 1.40 mycroft if (sd->sc_dk.dk_openmask == 0) {
388 1.116 bouyer scsipi_prevent(sc_link, PR_ALLOW,
389 1.55 mycroft SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
390 1.25 mycroft sc_link->flags &= ~SDEV_OPEN;
391 1.65 mycroft }
392 1.45 mycroft
393 1.57 mycroft bad3:
394 1.65 mycroft sdunlock(sd);
395 1.137 thorpej bad4:
396 1.137 thorpej if (sd->sc_dk.dk_openmask == 0)
397 1.137 thorpej scsipi_adapter_delref(sc_link);
398 1.118 enami return (error);
399 1.1 cgd }
400 1.1 cgd
401 1.3 deraadt /*
402 1.25 mycroft * close the device.. only called if we are the LAST occurence of an open
403 1.25 mycroft * device. Convenient now but usually a pain.
404 1.3 deraadt */
405 1.87 christos int
406 1.87 christos sdclose(dev, flag, fmt, p)
407 1.25 mycroft dev_t dev;
408 1.37 mycroft int flag, fmt;
409 1.87 christos struct proc *p;
410 1.1 cgd {
411 1.89 thorpej struct sd_softc *sd = sd_cd.cd_devs[SDUNIT(dev)];
412 1.37 mycroft int part = SDPART(dev);
413 1.65 mycroft int error;
414 1.65 mycroft
415 1.87 christos if ((error = sdlock(sd)) != 0)
416 1.118 enami return (error);
417 1.37 mycroft
418 1.37 mycroft switch (fmt) {
419 1.37 mycroft case S_IFCHR:
420 1.40 mycroft sd->sc_dk.dk_copenmask &= ~(1 << part);
421 1.37 mycroft break;
422 1.37 mycroft case S_IFBLK:
423 1.40 mycroft sd->sc_dk.dk_bopenmask &= ~(1 << part);
424 1.37 mycroft break;
425 1.37 mycroft }
426 1.118 enami sd->sc_dk.dk_openmask =
427 1.118 enami sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
428 1.25 mycroft
429 1.40 mycroft if (sd->sc_dk.dk_openmask == 0) {
430 1.132 thorpej /*
431 1.132 thorpej * If the disk cache needs flushing, and the disk supports
432 1.132 thorpej * it, do it now.
433 1.132 thorpej */
434 1.132 thorpej if ((sd->flags & SDF_DIRTY) != 0 &&
435 1.132 thorpej sd->sc_ops->sdo_flush != NULL)
436 1.132 thorpej (*sd->sc_ops->sdo_flush)(sd, 0);
437 1.132 thorpej
438 1.138 thorpej scsipi_wait_drain(sd->sc_link);
439 1.47 mycroft
440 1.116 bouyer scsipi_prevent(sd->sc_link, PR_ALLOW,
441 1.51 mycroft SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY);
442 1.140 bouyer sd->sc_link->flags &= ~SDEV_OPEN;
443 1.138 thorpej
444 1.138 thorpej scsipi_wait_drain(sd->sc_link);
445 1.137 thorpej
446 1.137 thorpej scsipi_adapter_delref(sd->sc_link);
447 1.1 cgd }
448 1.47 mycroft
449 1.65 mycroft sdunlock(sd);
450 1.118 enami return (0);
451 1.1 cgd }
452 1.1 cgd
453 1.3 deraadt /*
454 1.25 mycroft * Actually translate the requested transfer into one the physical driver
455 1.25 mycroft * can understand. The transfer is described by a buf and will include
456 1.3 deraadt * only one physical transfer.
457 1.3 deraadt */
458 1.75 mycroft void
459 1.25 mycroft sdstrategy(bp)
460 1.25 mycroft struct buf *bp;
461 1.1 cgd {
462 1.89 thorpej struct sd_softc *sd = sd_cd.cd_devs[SDUNIT(bp->b_dev)];
463 1.77 mycroft int s;
464 1.1 cgd
465 1.25 mycroft SC_DEBUG(sd->sc_link, SDEV_DB2, ("sdstrategy "));
466 1.25 mycroft SC_DEBUG(sd->sc_link, SDEV_DB1,
467 1.97 christos ("%ld bytes @ blk %d\n", bp->b_bcount, bp->b_blkno));
468 1.80 mycroft /*
469 1.140 bouyer * If the device has been made invalid, error out
470 1.80 mycroft */
471 1.140 bouyer if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
472 1.141 bouyer if (sd->sc_link->flags & SDEV_OPEN)
473 1.141 bouyer bp->b_error = EIO;
474 1.141 bouyer else
475 1.141 bouyer bp->b_error = ENODEV;
476 1.80 mycroft goto bad;
477 1.80 mycroft }
478 1.25 mycroft /*
479 1.140 bouyer * The transfer must be a whole number of blocks.
480 1.25 mycroft */
481 1.140 bouyer if ((bp->b_bcount % sd->sc_dk.dk_label->d_secsize) != 0) {
482 1.140 bouyer bp->b_error = EINVAL;
483 1.1 cgd goto bad;
484 1.1 cgd }
485 1.25 mycroft /*
486 1.25 mycroft * If it's a null transfer, return immediatly
487 1.25 mycroft */
488 1.1 cgd if (bp->b_bcount == 0)
489 1.1 cgd goto done;
490 1.52 mycroft
491 1.3 deraadt /*
492 1.52 mycroft * Do bounds checking, adjust transfer. if error, process.
493 1.52 mycroft * If end of partition, just return.
494 1.3 deraadt */
495 1.68 mycroft if (SDPART(bp->b_dev) != RAW_PART &&
496 1.84 thorpej bounds_check_with_label(bp, sd->sc_dk.dk_label,
497 1.61 mycroft (sd->flags & (SDF_WLABEL|SDF_LABELLING)) != 0) <= 0)
498 1.52 mycroft goto done;
499 1.37 mycroft
500 1.77 mycroft s = splbio();
501 1.1 cgd
502 1.25 mycroft /*
503 1.25 mycroft * Place it in the queue of disk activities for this disk
504 1.25 mycroft */
505 1.37 mycroft disksort(&sd->buf_queue, bp);
506 1.1 cgd
507 1.3 deraadt /*
508 1.3 deraadt * Tell the device to get going on the transfer if it's
509 1.3 deraadt * not doing anything, otherwise just wait for completion
510 1.3 deraadt */
511 1.46 mycroft sdstart(sd);
512 1.1 cgd
513 1.77 mycroft splx(s);
514 1.1 cgd return;
515 1.25 mycroft
516 1.1 cgd bad:
517 1.1 cgd bp->b_flags |= B_ERROR;
518 1.1 cgd done:
519 1.25 mycroft /*
520 1.25 mycroft * Correctly set the buf to indicate a completed xfer
521 1.25 mycroft */
522 1.25 mycroft bp->b_resid = bp->b_bcount;
523 1.1 cgd biodone(bp);
524 1.1 cgd }
525 1.1 cgd
526 1.3 deraadt /*
527 1.3 deraadt * sdstart looks to see if there is a buf waiting for the device
528 1.3 deraadt * and that the device is not already busy. If both are true,
529 1.25 mycroft * It dequeues the buf and creates a scsi command to perform the
530 1.116 bouyer * transfer in the buf. The transfer request will call scsipi_done
531 1.3 deraadt * on completion, which will in turn call this routine again
532 1.3 deraadt * so that the next queued transfer is performed.
533 1.3 deraadt * The bufs are queued by the strategy routine (sdstrategy)
534 1.25 mycroft *
535 1.3 deraadt * This routine is also called after other non-queued requests
536 1.3 deraadt * have been made of the scsi driver, to ensure that the queue
537 1.3 deraadt * continues to be drained.
538 1.25 mycroft *
539 1.3 deraadt * must be called at the correct (highish) spl level
540 1.116 bouyer * sdstart() is called at splbio from sdstrategy and scsipi_done
541 1.3 deraadt */
542 1.87 christos void
543 1.87 christos sdstart(v)
544 1.87 christos register void *v;
545 1.3 deraadt {
546 1.87 christos register struct sd_softc *sd = v;
547 1.116 bouyer register struct scsipi_link *sc_link = sd->sc_link;
548 1.118 enami struct disklabel *lp = sd->sc_dk.dk_label;
549 1.25 mycroft struct buf *bp = 0;
550 1.25 mycroft struct buf *dp;
551 1.116 bouyer struct scsipi_rw_big cmd_big;
552 1.124 cgd #if NSD_SCSIBUS > 0
553 1.81 thorpej struct scsi_rw cmd_small;
554 1.124 cgd #endif
555 1.116 bouyer struct scsipi_generic *cmdp;
556 1.99 thorpej int blkno, nblks, cmdlen, error;
557 1.3 deraadt struct partition *p;
558 1.3 deraadt
559 1.25 mycroft SC_DEBUG(sc_link, SDEV_DB2, ("sdstart "));
560 1.3 deraadt /*
561 1.25 mycroft * Check if the device has room for another command
562 1.3 deraadt */
563 1.51 mycroft while (sc_link->openings > 0) {
564 1.25 mycroft /*
565 1.75 mycroft * there is excess capacity, but a special waits
566 1.25 mycroft * It'll need the adapter as soon as we clear out of the
567 1.25 mycroft * way and let it run (user level wait).
568 1.25 mycroft */
569 1.25 mycroft if (sc_link->flags & SDEV_WAITING) {
570 1.25 mycroft sc_link->flags &= ~SDEV_WAITING;
571 1.25 mycroft wakeup((caddr_t)sc_link);
572 1.25 mycroft return;
573 1.25 mycroft }
574 1.1 cgd
575 1.25 mycroft /*
576 1.25 mycroft * See if there is a buf with work for us to do..
577 1.25 mycroft */
578 1.25 mycroft dp = &sd->buf_queue;
579 1.25 mycroft if ((bp = dp->b_actf) == NULL) /* yes, an assign */
580 1.25 mycroft return;
581 1.22 mycroft dp->b_actf = bp->b_actf;
582 1.3 deraadt
583 1.25 mycroft /*
584 1.25 mycroft * If the device has become invalid, abort all the
585 1.25 mycroft * reads and writes until all files have been closed and
586 1.51 mycroft * re-opened
587 1.25 mycroft */
588 1.61 mycroft if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
589 1.32 chopps bp->b_error = EIO;
590 1.32 chopps bp->b_flags |= B_ERROR;
591 1.109 thorpej bp->b_resid = bp->b_bcount;
592 1.32 chopps biodone(bp);
593 1.32 chopps continue;
594 1.25 mycroft }
595 1.1 cgd
596 1.25 mycroft /*
597 1.75 mycroft * We have a buf, now we should make a command
598 1.25 mycroft *
599 1.61 mycroft * First, translate the block to absolute and put it in terms
600 1.61 mycroft * of the logical blocksize of the device.
601 1.25 mycroft */
602 1.118 enami blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);
603 1.25 mycroft if (SDPART(bp->b_dev) != RAW_PART) {
604 1.118 enami p = &lp->d_partitions[SDPART(bp->b_dev)];
605 1.118 enami blkno += p->p_offset;
606 1.25 mycroft }
607 1.118 enami nblks = howmany(bp->b_bcount, lp->d_secsize);
608 1.3 deraadt
609 1.124 cgd #if NSD_SCSIBUS > 0
610 1.25 mycroft /*
611 1.81 thorpej * Fill out the scsi command. If the transfer will
612 1.81 thorpej * fit in a "small" cdb, use it.
613 1.25 mycroft */
614 1.81 thorpej if (((blkno & 0x1fffff) == blkno) &&
615 1.124 cgd ((nblks & 0xff) == nblks) && sc_link->type == BUS_SCSI) {
616 1.81 thorpej /*
617 1.81 thorpej * We can fit in a small cdb.
618 1.81 thorpej */
619 1.81 thorpej bzero(&cmd_small, sizeof(cmd_small));
620 1.81 thorpej cmd_small.opcode = (bp->b_flags & B_READ) ?
621 1.116 bouyer SCSI_READ_COMMAND : SCSI_WRITE_COMMAND;
622 1.91 mycroft _lto3b(blkno, cmd_small.addr);
623 1.81 thorpej cmd_small.length = nblks & 0xff;
624 1.81 thorpej cmdlen = sizeof(cmd_small);
625 1.116 bouyer cmdp = (struct scsipi_generic *)&cmd_small;
626 1.124 cgd } else
627 1.124 cgd #endif
628 1.124 cgd {
629 1.81 thorpej /*
630 1.81 thorpej * Need a large cdb.
631 1.81 thorpej */
632 1.81 thorpej bzero(&cmd_big, sizeof(cmd_big));
633 1.81 thorpej cmd_big.opcode = (bp->b_flags & B_READ) ?
634 1.81 thorpej READ_BIG : WRITE_BIG;
635 1.91 mycroft _lto4b(blkno, cmd_big.addr);
636 1.91 mycroft _lto2b(nblks, cmd_big.length);
637 1.81 thorpej cmdlen = sizeof(cmd_big);
638 1.116 bouyer cmdp = (struct scsipi_generic *)&cmd_big;
639 1.81 thorpej }
640 1.1 cgd
641 1.84 thorpej /* Instrumentation. */
642 1.84 thorpej disk_busy(&sd->sc_dk);
643 1.84 thorpej
644 1.25 mycroft /*
645 1.132 thorpej * Mark the disk dirty so that the cache will be
646 1.132 thorpej * flushed on close.
647 1.132 thorpej */
648 1.135 thorpej if ((bp->b_flags & B_READ) == 0)
649 1.135 thorpej sd->flags |= SDF_DIRTY;
650 1.132 thorpej
651 1.132 thorpej /*
652 1.25 mycroft * Call the routine that chats with the adapter.
653 1.25 mycroft * Note: we cannot sleep as we may be an interrupt
654 1.25 mycroft */
655 1.122 thorpej error = scsipi_command(sc_link, cmdp, cmdlen,
656 1.81 thorpej (u_char *)bp->b_data, bp->b_bcount,
657 1.108 thorpej SDRETRIES, 60000, bp, SCSI_NOSLEEP |
658 1.99 thorpej ((bp->b_flags & B_READ) ? SCSI_DATA_IN : SCSI_DATA_OUT));
659 1.129 thorpej if (error) {
660 1.130 thorpej disk_unbusy(&sd->sc_dk, 0);
661 1.104 christos printf("%s: not queued, error %d\n",
662 1.99 thorpej sd->sc_dev.dv_xname, error);
663 1.129 thorpej }
664 1.25 mycroft }
665 1.72 mycroft }
666 1.72 mycroft
667 1.111 mycroft void
668 1.111 mycroft sddone(xs)
669 1.116 bouyer struct scsipi_xfer *xs;
670 1.84 thorpej {
671 1.84 thorpej struct sd_softc *sd = xs->sc_link->device_softc;
672 1.84 thorpej
673 1.132 thorpej if (sd->flags & SDF_FLUSHING) {
674 1.132 thorpej /* Flush completed, no longer dirty. */
675 1.132 thorpej sd->flags &= ~(SDF_FLUSHING|SDF_DIRTY);
676 1.132 thorpej }
677 1.132 thorpej
678 1.120 explorer if (xs->bp != NULL) {
679 1.111 mycroft disk_unbusy(&sd->sc_dk, xs->bp->b_bcount - xs->bp->b_resid);
680 1.121 explorer #if NRND > 0
681 1.120 explorer rnd_add_uint32(&sd->rnd_source, xs->bp->b_blkno);
682 1.121 explorer #endif
683 1.120 explorer }
684 1.84 thorpej }
685 1.84 thorpej
686 1.81 thorpej void
687 1.81 thorpej sdminphys(bp)
688 1.81 thorpej struct buf *bp;
689 1.81 thorpej {
690 1.89 thorpej struct sd_softc *sd = sd_cd.cd_devs[SDUNIT(bp->b_dev)];
691 1.81 thorpej long max;
692 1.81 thorpej
693 1.81 thorpej /*
694 1.81 thorpej * If the device is ancient, we want to make sure that
695 1.81 thorpej * the transfer fits into a 6-byte cdb.
696 1.82 thorpej *
697 1.82 thorpej * XXX Note that the SCSI-I spec says that 256-block transfers
698 1.82 thorpej * are allowed in a 6-byte read/write, and are specified
699 1.82 thorpej * by settng the "length" to 0. However, we're conservative
700 1.82 thorpej * here, allowing only 255-block transfers in case an
701 1.82 thorpej * ancient device gets confused by length == 0. A length of 0
702 1.82 thorpej * in a 10-byte read/write actually means 0 blocks.
703 1.81 thorpej */
704 1.81 thorpej if (sd->flags & SDF_ANCIENT) {
705 1.84 thorpej max = sd->sc_dk.dk_label->d_secsize * 0xff;
706 1.81 thorpej
707 1.81 thorpej if (bp->b_bcount > max)
708 1.81 thorpej bp->b_bcount = max;
709 1.81 thorpej }
710 1.81 thorpej
711 1.116 bouyer (*sd->sc_link->adapter->scsipi_minphys)(bp);
712 1.81 thorpej }
713 1.81 thorpej
714 1.72 mycroft int
715 1.87 christos sdread(dev, uio, ioflag)
716 1.72 mycroft dev_t dev;
717 1.72 mycroft struct uio *uio;
718 1.87 christos int ioflag;
719 1.72 mycroft {
720 1.72 mycroft
721 1.81 thorpej return (physio(sdstrategy, NULL, dev, B_READ, sdminphys, uio));
722 1.72 mycroft }
723 1.72 mycroft
724 1.72 mycroft int
725 1.87 christos sdwrite(dev, uio, ioflag)
726 1.72 mycroft dev_t dev;
727 1.72 mycroft struct uio *uio;
728 1.87 christos int ioflag;
729 1.72 mycroft {
730 1.72 mycroft
731 1.81 thorpej return (physio(sdstrategy, NULL, dev, B_WRITE, sdminphys, uio));
732 1.1 cgd }
733 1.3 deraadt
734 1.3 deraadt /*
735 1.3 deraadt * Perform special action on behalf of the user
736 1.3 deraadt * Knows about the internals of this device
737 1.3 deraadt */
738 1.75 mycroft int
739 1.51 mycroft sdioctl(dev, cmd, addr, flag, p)
740 1.25 mycroft dev_t dev;
741 1.43 cgd u_long cmd;
742 1.25 mycroft caddr_t addr;
743 1.25 mycroft int flag;
744 1.51 mycroft struct proc *p;
745 1.1 cgd {
746 1.89 thorpej struct sd_softc *sd = sd_cd.cd_devs[SDUNIT(dev)];
747 1.45 mycroft int error;
748 1.1 cgd
749 1.61 mycroft SC_DEBUG(sd->sc_link, SDEV_DB2, ("sdioctl 0x%lx ", cmd));
750 1.61 mycroft
751 1.25 mycroft /*
752 1.140 bouyer * If the device is not valid, some IOCTLs can still be
753 1.140 bouyer * handled on the raw partition. Check this here.
754 1.25 mycroft */
755 1.140 bouyer if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
756 1.140 bouyer switch (cmd) {
757 1.140 bouyer case DIOCWLABEL:
758 1.140 bouyer case DIOCLOCK:
759 1.140 bouyer case DIOCEJECT:
760 1.140 bouyer case SCIOCIDENTIFY:
761 1.140 bouyer case OSCIOCIDENTIFY:
762 1.140 bouyer case SCIOCCOMMAND:
763 1.140 bouyer case SCIOCDEBUG:
764 1.140 bouyer if (SDPART(dev) == RAW_PART)
765 1.140 bouyer break;
766 1.140 bouyer /* FALLTHROUGH */
767 1.140 bouyer default:
768 1.141 bouyer if ((sd->sc_link->flags & SDEV_OPEN) == 0)
769 1.141 bouyer return (ENODEV);
770 1.141 bouyer else
771 1.141 bouyer return (EIO);
772 1.140 bouyer }
773 1.140 bouyer }
774 1.45 mycroft
775 1.25 mycroft switch (cmd) {
776 1.1 cgd case DIOCGDINFO:
777 1.84 thorpej *(struct disklabel *)addr = *(sd->sc_dk.dk_label);
778 1.118 enami return (0);
779 1.25 mycroft
780 1.3 deraadt case DIOCGPART:
781 1.84 thorpej ((struct partinfo *)addr)->disklab = sd->sc_dk.dk_label;
782 1.37 mycroft ((struct partinfo *)addr)->part =
783 1.84 thorpej &sd->sc_dk.dk_label->d_partitions[SDPART(dev)];
784 1.118 enami return (0);
785 1.25 mycroft
786 1.61 mycroft case DIOCWDINFO:
787 1.3 deraadt case DIOCSDINFO:
788 1.3 deraadt if ((flag & FWRITE) == 0)
789 1.118 enami return (EBADF);
790 1.61 mycroft
791 1.87 christos if ((error = sdlock(sd)) != 0)
792 1.118 enami return (error);
793 1.65 mycroft sd->flags |= SDF_LABELLING;
794 1.61 mycroft
795 1.84 thorpej error = setdisklabel(sd->sc_dk.dk_label,
796 1.52 mycroft (struct disklabel *)addr, /*sd->sc_dk.dk_openmask : */0,
797 1.84 thorpej sd->sc_dk.dk_cpulabel);
798 1.62 mycroft if (error == 0) {
799 1.62 mycroft if (cmd == DIOCWDINFO)
800 1.62 mycroft error = writedisklabel(SDLABELDEV(dev),
801 1.84 thorpej sdstrategy, sd->sc_dk.dk_label,
802 1.84 thorpej sd->sc_dk.dk_cpulabel);
803 1.62 mycroft }
804 1.61 mycroft
805 1.61 mycroft sd->flags &= ~SDF_LABELLING;
806 1.61 mycroft sdunlock(sd);
807 1.118 enami return (error);
808 1.25 mycroft
809 1.3 deraadt case DIOCWLABEL:
810 1.3 deraadt if ((flag & FWRITE) == 0)
811 1.118 enami return (EBADF);
812 1.37 mycroft if (*(int *)addr)
813 1.37 mycroft sd->flags |= SDF_WLABEL;
814 1.37 mycroft else
815 1.37 mycroft sd->flags &= ~SDF_WLABEL;
816 1.118 enami return (0);
817 1.86 thorpej
818 1.86 thorpej case DIOCLOCK:
819 1.118 enami return (scsipi_prevent(sd->sc_link,
820 1.118 enami (*(int *)addr) ? PR_PREVENT : PR_ALLOW, 0));
821 1.86 thorpej
822 1.86 thorpej case DIOCEJECT:
823 1.90 pk return ((sd->sc_link->flags & SDEV_REMOVABLE) == 0 ? ENOTTY :
824 1.116 bouyer scsipi_start(sd->sc_link, SSS_STOP|SSS_LOEJ, 0));
825 1.25 mycroft
826 1.119 thorpej case DIOCGDEFLABEL:
827 1.119 thorpej sdgetdefaultlabel(sd, (struct disklabel *)addr);
828 1.119 thorpej return (0);
829 1.119 thorpej
830 1.1 cgd default:
831 1.45 mycroft if (SDPART(dev) != RAW_PART)
832 1.118 enami return (ENOTTY);
833 1.118 enami return (scsipi_do_ioctl(sd->sc_link, dev, cmd, addr, flag, p));
834 1.25 mycroft }
835 1.45 mycroft
836 1.25 mycroft #ifdef DIAGNOSTIC
837 1.25 mycroft panic("sdioctl: impossible");
838 1.25 mycroft #endif
839 1.1 cgd }
840 1.1 cgd
841 1.75 mycroft void
842 1.119 thorpej sdgetdefaultlabel(sd, lp)
843 1.51 mycroft struct sd_softc *sd;
844 1.119 thorpej struct disklabel *lp;
845 1.1 cgd {
846 1.1 cgd
847 1.74 mycroft bzero(lp, sizeof(struct disklabel));
848 1.25 mycroft
849 1.74 mycroft lp->d_secsize = sd->params.blksize;
850 1.74 mycroft lp->d_ntracks = sd->params.heads;
851 1.74 mycroft lp->d_nsectors = sd->params.sectors;
852 1.74 mycroft lp->d_ncylinders = sd->params.cyls;
853 1.74 mycroft lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
854 1.1 cgd
855 1.131 drochner switch (sd->sc_link->type) {
856 1.131 drochner #if NSD_SCSIBUS > 0
857 1.131 drochner case BUS_SCSI:
858 1.131 drochner lp->d_type = DTYPE_SCSI;
859 1.131 drochner break;
860 1.131 drochner #endif
861 1.131 drochner #if NSD_ATAPIBUS > 0
862 1.131 drochner case BUS_ATAPI:
863 1.131 drochner lp->d_type = DTYPE_ATAPI;
864 1.131 drochner break;
865 1.131 drochner #endif
866 1.131 drochner }
867 1.131 drochner strncpy(lp->d_typename, sd->name, 16);
868 1.74 mycroft strncpy(lp->d_packname, "fictitious", 16);
869 1.74 mycroft lp->d_secperunit = sd->params.disksize;
870 1.124 cgd lp->d_rpm = sd->params.rot_rate;
871 1.74 mycroft lp->d_interleave = 1;
872 1.74 mycroft lp->d_flags = 0;
873 1.74 mycroft
874 1.74 mycroft lp->d_partitions[RAW_PART].p_offset = 0;
875 1.74 mycroft lp->d_partitions[RAW_PART].p_size =
876 1.74 mycroft lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
877 1.74 mycroft lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
878 1.74 mycroft lp->d_npartitions = RAW_PART + 1;
879 1.74 mycroft
880 1.74 mycroft lp->d_magic = DISKMAGIC;
881 1.74 mycroft lp->d_magic2 = DISKMAGIC;
882 1.74 mycroft lp->d_checksum = dkcksum(lp);
883 1.119 thorpej }
884 1.119 thorpej
885 1.119 thorpej
886 1.119 thorpej /*
887 1.119 thorpej * Load the label information on the named device
888 1.119 thorpej */
889 1.119 thorpej void
890 1.119 thorpej sdgetdisklabel(sd)
891 1.119 thorpej struct sd_softc *sd;
892 1.119 thorpej {
893 1.119 thorpej struct disklabel *lp = sd->sc_dk.dk_label;
894 1.119 thorpej char *errstring;
895 1.119 thorpej
896 1.119 thorpej bzero(sd->sc_dk.dk_cpulabel, sizeof(struct cpu_disklabel));
897 1.119 thorpej
898 1.119 thorpej sdgetdefaultlabel(sd, lp);
899 1.119 thorpej
900 1.119 thorpej if (lp->d_secpercyl == 0) {
901 1.119 thorpej lp->d_secpercyl = 100;
902 1.119 thorpej /* as long as it's not 0 - readdisklabel divides by it (?) */
903 1.119 thorpej }
904 1.45 mycroft
905 1.25 mycroft /*
906 1.25 mycroft * Call the generic disklabel extraction routine
907 1.25 mycroft */
908 1.87 christos errstring = readdisklabel(MAKESDDEV(0, sd->sc_dev.dv_unit, RAW_PART),
909 1.118 enami sdstrategy, lp, sd->sc_dk.dk_cpulabel);
910 1.87 christos if (errstring) {
911 1.104 christos printf("%s: %s\n", sd->sc_dev.dv_xname, errstring);
912 1.45 mycroft return;
913 1.1 cgd }
914 1.132 thorpej }
915 1.132 thorpej
916 1.132 thorpej void
917 1.132 thorpej sd_shutdown(arg)
918 1.132 thorpej void *arg;
919 1.132 thorpej {
920 1.132 thorpej struct sd_softc *sd = arg;
921 1.132 thorpej
922 1.132 thorpej /*
923 1.132 thorpej * If the disk cache needs to be flushed, and the disk supports
924 1.132 thorpej * it, flush it. We're cold at this point, so we poll for
925 1.132 thorpej * completion.
926 1.132 thorpej */
927 1.132 thorpej if ((sd->flags & SDF_DIRTY) != 0 && sd->sc_ops->sdo_flush != NULL)
928 1.132 thorpej (*sd->sc_ops->sdo_flush)(sd, SCSI_AUTOCONF);
929 1.1 cgd }
930 1.1 cgd
931 1.3 deraadt /*
932 1.3 deraadt * Tell the device to map out a defective block
933 1.3 deraadt */
934 1.75 mycroft int
935 1.91 mycroft sd_reassign_blocks(sd, blkno)
936 1.51 mycroft struct sd_softc *sd;
937 1.91 mycroft u_long blkno;
938 1.1 cgd {
939 1.116 bouyer struct scsi_reassign_blocks scsipi_cmd;
940 1.3 deraadt struct scsi_reassign_blocks_data rbdata;
941 1.1 cgd
942 1.116 bouyer bzero(&scsipi_cmd, sizeof(scsipi_cmd));
943 1.1 cgd bzero(&rbdata, sizeof(rbdata));
944 1.116 bouyer scsipi_cmd.opcode = SCSI_REASSIGN_BLOCKS;
945 1.1 cgd
946 1.91 mycroft _lto2b(sizeof(rbdata.defect_descriptor[0]), rbdata.length);
947 1.91 mycroft _lto4b(blkno, rbdata.defect_descriptor[0].dlbaddr);
948 1.1 cgd
949 1.122 thorpej return (scsipi_command(sd->sc_link,
950 1.118 enami (struct scsipi_generic *)&scsipi_cmd, sizeof(scsipi_cmd),
951 1.118 enami (u_char *)&rbdata, sizeof(rbdata), SDRETRIES, 5000, NULL,
952 1.118 enami SCSI_DATA_OUT));
953 1.1 cgd }
954 1.127 mjacob
955 1.127 mjacob /*
956 1.127 mjacob * Check Errors
957 1.127 mjacob */
958 1.127 mjacob int
959 1.127 mjacob sd_interpret_sense(xs)
960 1.127 mjacob struct scsipi_xfer *xs;
961 1.127 mjacob {
962 1.127 mjacob struct scsipi_link *sc_link = xs->sc_link;
963 1.127 mjacob struct scsipi_sense_data *sense = &xs->sense.scsi_sense;
964 1.127 mjacob struct sd_softc *sd = sc_link->device_softc;
965 1.127 mjacob int retval = SCSIRET_CONTINUE;
966 1.127 mjacob
967 1.127 mjacob /*
968 1.127 mjacob * If the device is not open yet, let the generic code handle it.
969 1.127 mjacob */
970 1.140 bouyer if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
971 1.127 mjacob return (retval);
972 1.127 mjacob }
973 1.127 mjacob
974 1.127 mjacob /*
975 1.127 mjacob * If it isn't a extended or extended/deferred error, let
976 1.127 mjacob * the generic code handle it.
977 1.127 mjacob */
978 1.127 mjacob if ((sense->error_code & SSD_ERRCODE) != 0x70 &&
979 1.127 mjacob (sense->error_code & SSD_ERRCODE) != 0x71) { /* DEFFERRED */
980 1.127 mjacob return (retval);
981 1.127 mjacob }
982 1.127 mjacob
983 1.127 mjacob if ((sense->flags & SSD_KEY) == SKEY_NOT_READY &&
984 1.127 mjacob sense->add_sense_code == 0x4) {
985 1.127 mjacob if (sense->add_sense_code_qual == 0x01) {
986 1.127 mjacob printf("%s: ..is spinning up...waiting\n",
987 1.127 mjacob sd->sc_dev.dv_xname);
988 1.127 mjacob /*
989 1.127 mjacob * I really need a sdrestart function I can call here.
990 1.127 mjacob */
991 1.127 mjacob delay(1000000 * 5); /* 5 seconds */
992 1.127 mjacob retval = SCSIRET_RETRY;
993 1.127 mjacob } else if ((sense->add_sense_code_qual == 0x2) &&
994 1.127 mjacob (sd->sc_link->quirks & SDEV_NOSTARTUNIT) == 0) {
995 1.127 mjacob if (sd->sc_link->flags & SDEV_REMOVABLE) {
996 1.127 mjacob printf("%s: removable disk stopped- not "
997 1.127 mjacob "restarting\n", sd->sc_dev.dv_xname);
998 1.127 mjacob retval = EIO;
999 1.127 mjacob } else {
1000 1.127 mjacob printf("%s: respinning up disk\n",
1001 1.127 mjacob sd->sc_dev.dv_xname);
1002 1.127 mjacob retval = scsipi_start(sd->sc_link, SSS_START,
1003 1.133 thorpej SCSI_URGENT | SCSI_NOSLEEP);
1004 1.127 mjacob if (retval != 0) {
1005 1.127 mjacob printf("%s: respin of disk failed-%d\n",
1006 1.127 mjacob sd->sc_dev.dv_xname, retval);
1007 1.127 mjacob retval = EIO;
1008 1.127 mjacob } else {
1009 1.127 mjacob retval = SCSIRET_RETRY;
1010 1.127 mjacob }
1011 1.127 mjacob }
1012 1.127 mjacob }
1013 1.127 mjacob }
1014 1.127 mjacob return (retval);
1015 1.127 mjacob }
1016 1.127 mjacob
1017 1.1 cgd
1018 1.3 deraadt int
1019 1.45 mycroft sdsize(dev)
1020 1.45 mycroft dev_t dev;
1021 1.1 cgd {
1022 1.51 mycroft struct sd_softc *sd;
1023 1.112 pk int part, unit, omask;
1024 1.45 mycroft int size;
1025 1.1 cgd
1026 1.112 pk unit = SDUNIT(dev);
1027 1.112 pk if (unit >= sd_cd.cd_ndevs)
1028 1.112 pk return (-1);
1029 1.112 pk sd = sd_cd.cd_devs[unit];
1030 1.112 pk if (sd == NULL)
1031 1.112 pk return (-1);
1032 1.112 pk
1033 1.45 mycroft part = SDPART(dev);
1034 1.112 pk omask = sd->sc_dk.dk_openmask & (1 << part);
1035 1.112 pk
1036 1.112 pk if (omask == 0 && sdopen(dev, 0, S_IFBLK, NULL) != 0)
1037 1.112 pk return (-1);
1038 1.140 bouyer if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0)
1039 1.140 bouyer size = -1;
1040 1.140 bouyer else if (sd->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
1041 1.45 mycroft size = -1;
1042 1.45 mycroft else
1043 1.113 thorpej size = sd->sc_dk.dk_label->d_partitions[part].p_size *
1044 1.113 thorpej (sd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
1045 1.112 pk if (omask == 0 && sdclose(dev, 0, S_IFBLK, NULL) != 0)
1046 1.112 pk return (-1);
1047 1.112 pk return (size);
1048 1.3 deraadt }
1049 1.3 deraadt
1050 1.71 cgd #ifndef __BDEVSW_DUMP_OLD_TYPE
1051 1.71 cgd /* #define SD_DUMP_NOT_TRUSTED if you just want to watch */
1052 1.116 bouyer static struct scsipi_xfer sx;
1053 1.71 cgd static int sddoingadump;
1054 1.3 deraadt
1055 1.3 deraadt /*
1056 1.25 mycroft * dump all of physical memory into the partition specified, starting
1057 1.25 mycroft * at offset 'dumplo' into the partition.
1058 1.3 deraadt */
1059 1.3 deraadt int
1060 1.71 cgd sddump(dev, blkno, va, size)
1061 1.71 cgd dev_t dev;
1062 1.71 cgd daddr_t blkno;
1063 1.71 cgd caddr_t va;
1064 1.71 cgd size_t size;
1065 1.71 cgd {
1066 1.71 cgd struct sd_softc *sd; /* disk unit to do the I/O */
1067 1.71 cgd struct disklabel *lp; /* disk's disklabel */
1068 1.71 cgd int unit, part;
1069 1.71 cgd int sectorsize; /* size of a disk sector */
1070 1.71 cgd int nsects; /* number of sectors in partition */
1071 1.71 cgd int sectoff; /* sector offset of partition */
1072 1.71 cgd int totwrt; /* total number of sectors left to write */
1073 1.71 cgd int nwrt; /* current number of sectors to write */
1074 1.116 bouyer struct scsipi_rw_big cmd; /* write command */
1075 1.116 bouyer struct scsipi_xfer *xs; /* ... convenience */
1076 1.25 mycroft int retval;
1077 1.25 mycroft
1078 1.71 cgd /* Check if recursive dump; if so, punt. */
1079 1.71 cgd if (sddoingadump)
1080 1.118 enami return (EFAULT);
1081 1.71 cgd
1082 1.71 cgd /* Mark as active early. */
1083 1.71 cgd sddoingadump = 1;
1084 1.1 cgd
1085 1.71 cgd unit = SDUNIT(dev); /* Decompose unit & partition. */
1086 1.71 cgd part = SDPART(dev);
1087 1.1 cgd
1088 1.71 cgd /* Check for acceptable drive number. */
1089 1.89 thorpej if (unit >= sd_cd.cd_ndevs || (sd = sd_cd.cd_devs[unit]) == NULL)
1090 1.118 enami return (ENXIO);
1091 1.3 deraadt
1092 1.71 cgd /* Make sure it was initialized. */
1093 1.90 pk if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) != SDEV_MEDIA_LOADED)
1094 1.118 enami return (ENXIO);
1095 1.25 mycroft
1096 1.71 cgd /* Convert to disk sectors. Request must be a multiple of size. */
1097 1.84 thorpej lp = sd->sc_dk.dk_label;
1098 1.71 cgd sectorsize = lp->d_secsize;
1099 1.71 cgd if ((size % sectorsize) != 0)
1100 1.118 enami return (EFAULT);
1101 1.71 cgd totwrt = size / sectorsize;
1102 1.71 cgd blkno = dbtob(blkno) / sectorsize; /* blkno in DEV_BSIZE units */
1103 1.25 mycroft
1104 1.71 cgd nsects = lp->d_partitions[part].p_size;
1105 1.71 cgd sectoff = lp->d_partitions[part].p_offset;
1106 1.25 mycroft
1107 1.71 cgd /* Check transfer bounds against partition size. */
1108 1.71 cgd if ((blkno < 0) || ((blkno + totwrt) > nsects))
1109 1.118 enami return (EINVAL);
1110 1.25 mycroft
1111 1.71 cgd /* Offset block number to start of partition. */
1112 1.71 cgd blkno += sectoff;
1113 1.71 cgd
1114 1.71 cgd xs = &sx;
1115 1.3 deraadt
1116 1.71 cgd while (totwrt > 0) {
1117 1.71 cgd nwrt = totwrt; /* XXX */
1118 1.71 cgd #ifndef SD_DUMP_NOT_TRUSTED
1119 1.25 mycroft /*
1120 1.25 mycroft * Fill out the scsi command
1121 1.25 mycroft */
1122 1.25 mycroft bzero(&cmd, sizeof(cmd));
1123 1.51 mycroft cmd.opcode = WRITE_BIG;
1124 1.91 mycroft _lto4b(blkno, cmd.addr);
1125 1.91 mycroft _lto2b(nwrt, cmd.length);
1126 1.25 mycroft /*
1127 1.116 bouyer * Fill out the scsipi_xfer structure
1128 1.25 mycroft * Note: we cannot sleep as we may be an interrupt
1129 1.122 thorpej * don't use scsipi_command() as it may want to wait
1130 1.122 thorpej * for an xs.
1131 1.25 mycroft */
1132 1.25 mycroft bzero(xs, sizeof(sx));
1133 1.79 pk xs->flags |= SCSI_AUTOCONF | INUSE | SCSI_DATA_OUT;
1134 1.25 mycroft xs->sc_link = sd->sc_link;
1135 1.25 mycroft xs->retries = SDRETRIES;
1136 1.25 mycroft xs->timeout = 10000; /* 10000 millisecs for a disk ! */
1137 1.116 bouyer xs->cmd = (struct scsipi_generic *)&cmd;
1138 1.25 mycroft xs->cmdlen = sizeof(cmd);
1139 1.71 cgd xs->resid = nwrt * sectorsize;
1140 1.25 mycroft xs->error = XS_NOERROR;
1141 1.25 mycroft xs->bp = 0;
1142 1.71 cgd xs->data = va;
1143 1.71 cgd xs->datalen = nwrt * sectorsize;
1144 1.1 cgd
1145 1.25 mycroft /*
1146 1.25 mycroft * Pass all this info to the scsi driver.
1147 1.25 mycroft */
1148 1.122 thorpej retval = scsipi_command_direct(xs);
1149 1.51 mycroft if (retval != COMPLETE)
1150 1.118 enami return (ENXIO);
1151 1.71 cgd #else /* SD_DUMP_NOT_TRUSTED */
1152 1.71 cgd /* Let's just talk about this first... */
1153 1.104 christos printf("sd%d: dump addr 0x%x, blk %d\n", unit, va, blkno);
1154 1.71 cgd delay(500 * 1000); /* half a second */
1155 1.71 cgd #endif /* SD_DUMP_NOT_TRUSTED */
1156 1.25 mycroft
1157 1.25 mycroft /* update block count */
1158 1.71 cgd totwrt -= nwrt;
1159 1.71 cgd blkno += nwrt;
1160 1.71 cgd va += sectorsize * nwrt;
1161 1.25 mycroft }
1162 1.71 cgd sddoingadump = 0;
1163 1.118 enami return (0);
1164 1.1 cgd }
1165 1.71 cgd #else /* __BDEVSW_DUMP_NEW_TYPE */
1166 1.25 mycroft int
1167 1.71 cgd sddump(dev, blkno, va, size)
1168 1.71 cgd dev_t dev;
1169 1.71 cgd daddr_t blkno;
1170 1.71 cgd caddr_t va;
1171 1.71 cgd size_t size;
1172 1.1 cgd {
1173 1.71 cgd
1174 1.71 cgd /* Not implemented. */
1175 1.118 enami return (ENXIO);
1176 1.1 cgd }
1177 1.71 cgd #endif /* __BDEVSW_DUMP_NEW_TYPE */
1178