sd.c revision 1.84 1 1.84 thorpej /* $NetBSD: sd.c,v 1.84 1996/01/07 22:04:02 thorpej Exp $ */
2 1.33 cgd
3 1.1 cgd /*
4 1.65 mycroft * Copyright (c) 1994, 1995 Charles M. Hannum. All rights reserved.
5 1.25 mycroft *
6 1.25 mycroft * Redistribution and use in source and binary forms, with or without
7 1.25 mycroft * modification, are permitted provided that the following conditions
8 1.25 mycroft * are met:
9 1.25 mycroft * 1. Redistributions of source code must retain the above copyright
10 1.25 mycroft * notice, this list of conditions and the following disclaimer.
11 1.25 mycroft * 2. Redistributions in binary form must reproduce the above copyright
12 1.25 mycroft * notice, this list of conditions and the following disclaimer in the
13 1.25 mycroft * documentation and/or other materials provided with the distribution.
14 1.25 mycroft * 3. All advertising materials mentioning features or use of this software
15 1.25 mycroft * must display the following acknowledgement:
16 1.65 mycroft * This product includes software developed by Charles M. Hannum.
17 1.25 mycroft * 4. The name of the author may not be used to endorse or promote products
18 1.25 mycroft * derived from this software without specific prior written permission.
19 1.25 mycroft *
20 1.25 mycroft * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 1.25 mycroft * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 1.25 mycroft * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 1.25 mycroft * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 1.25 mycroft * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 1.25 mycroft * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 1.25 mycroft * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 1.25 mycroft * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 1.25 mycroft * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 1.25 mycroft * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 1.25 mycroft */
31 1.25 mycroft
32 1.75 mycroft /*
33 1.25 mycroft * Originally written by Julian Elischer (julian (at) dialix.oz.au)
34 1.8 deraadt * for TRW Financial Systems for use under the MACH(2.5) operating system.
35 1.1 cgd *
36 1.1 cgd * TRW Financial Systems, in accordance with their agreement with Carnegie
37 1.1 cgd * Mellon University, makes this software available to CMU to distribute
38 1.1 cgd * or use in any manner that they see fit as long as this message is kept with
39 1.1 cgd * the software. For this reason TFS also grants any other persons or
40 1.1 cgd * organisations permission to use or modify this software.
41 1.1 cgd *
42 1.1 cgd * TFS supplies this software to be publicly redistributed
43 1.1 cgd * on the understanding that TFS is not responsible for the correct
44 1.1 cgd * functioning of this software in any circumstances.
45 1.9 cgd *
46 1.25 mycroft * Ported to run under 386BSD by Julian Elischer (julian (at) dialix.oz.au) Sept 1992
47 1.1 cgd */
48 1.1 cgd
49 1.19 mycroft #include <sys/types.h>
50 1.19 mycroft #include <sys/param.h>
51 1.19 mycroft #include <sys/systm.h>
52 1.54 mycroft #include <sys/kernel.h>
53 1.19 mycroft #include <sys/conf.h>
54 1.19 mycroft #include <sys/file.h>
55 1.19 mycroft #include <sys/stat.h>
56 1.19 mycroft #include <sys/ioctl.h>
57 1.19 mycroft #include <sys/buf.h>
58 1.19 mycroft #include <sys/uio.h>
59 1.19 mycroft #include <sys/malloc.h>
60 1.19 mycroft #include <sys/errno.h>
61 1.25 mycroft #include <sys/device.h>
62 1.19 mycroft #include <sys/disklabel.h>
63 1.25 mycroft #include <sys/disk.h>
64 1.19 mycroft
65 1.19 mycroft #include <scsi/scsi_all.h>
66 1.19 mycroft #include <scsi/scsi_disk.h>
67 1.19 mycroft #include <scsi/scsiconf.h>
68 1.1 cgd
69 1.1 cgd #define SDOUTSTANDING 2
70 1.25 mycroft #define SDRETRIES 4
71 1.1 cgd
72 1.36 cgd #define SDUNIT(dev) DISKUNIT(dev)
73 1.36 cgd #define SDPART(dev) DISKPART(dev)
74 1.36 cgd #define MAKESDDEV(maj, unit, part) MAKEDISKDEV(maj, unit, part)
75 1.36 cgd
76 1.36 cgd #define SDLABELDEV(dev) (MAKESDDEV(major(dev), SDUNIT(dev), RAW_PART))
77 1.1 cgd
78 1.51 mycroft struct sd_softc {
79 1.25 mycroft struct device sc_dev;
80 1.84 thorpej struct disk sc_dk;
81 1.25 mycroft
82 1.29 mycroft int flags;
83 1.45 mycroft #define SDF_LOCKED 0x01
84 1.45 mycroft #define SDF_WANTED 0x02
85 1.52 mycroft #define SDF_WLABEL 0x04 /* label is writable */
86 1.61 mycroft #define SDF_LABELLING 0x08 /* writing label */
87 1.81 thorpej #define SDF_ANCIENT 0x10 /* disk is ancient; for minphys */
88 1.61 mycroft struct scsi_link *sc_link; /* contains our targ, lun, etc. */
89 1.25 mycroft struct disk_parms {
90 1.61 mycroft u_char heads; /* number of heads */
91 1.61 mycroft u_short cyls; /* number of cylinders */
92 1.61 mycroft u_char sectors; /* number of sectors/track */
93 1.61 mycroft int blksize; /* number of bytes/sector */
94 1.25 mycroft u_long disksize; /* total number sectors */
95 1.25 mycroft } params;
96 1.25 mycroft struct buf buf_queue;
97 1.25 mycroft };
98 1.25 mycroft
99 1.51 mycroft int sdmatch __P((struct device *, void *, void *));
100 1.25 mycroft void sdattach __P((struct device *, struct device *, void *));
101 1.25 mycroft
102 1.25 mycroft struct cfdriver sdcd = {
103 1.51 mycroft NULL, "sd", sdmatch, sdattach, DV_DISK, sizeof(struct sd_softc)
104 1.25 mycroft };
105 1.25 mycroft
106 1.51 mycroft void sdgetdisklabel __P((struct sd_softc *));
107 1.51 mycroft int sd_get_parms __P((struct sd_softc *, int));
108 1.25 mycroft void sdstrategy __P((struct buf *));
109 1.51 mycroft void sdstart __P((struct sd_softc *));
110 1.84 thorpej int sddone __P((struct scsi_xfer *));
111 1.81 thorpej void sdminphys __P((struct buf *));
112 1.25 mycroft
113 1.25 mycroft struct dkdriver sddkdriver = { sdstrategy };
114 1.25 mycroft
115 1.25 mycroft struct scsi_device sd_switch = {
116 1.25 mycroft NULL, /* Use default error handler */
117 1.25 mycroft sdstart, /* have a queue, served by this */
118 1.25 mycroft NULL, /* have no async handler */
119 1.84 thorpej sddone, /* deal with stats at interrupt time */
120 1.25 mycroft };
121 1.1 cgd
122 1.51 mycroft struct scsi_inquiry_pattern sd_patterns[] = {
123 1.51 mycroft {T_DIRECT, T_FIXED,
124 1.51 mycroft "", "", ""},
125 1.51 mycroft {T_DIRECT, T_REMOV,
126 1.51 mycroft "", "", ""},
127 1.60 mycroft {T_OPTICAL, T_FIXED,
128 1.60 mycroft "", "", ""},
129 1.60 mycroft {T_OPTICAL, T_REMOV,
130 1.60 mycroft "", "", ""},
131 1.51 mycroft };
132 1.51 mycroft
133 1.51 mycroft int
134 1.51 mycroft sdmatch(parent, match, aux)
135 1.51 mycroft struct device *parent;
136 1.51 mycroft void *match, *aux;
137 1.51 mycroft {
138 1.51 mycroft struct cfdata *cf = match;
139 1.51 mycroft struct scsibus_attach_args *sa = aux;
140 1.51 mycroft int priority;
141 1.51 mycroft
142 1.51 mycroft (void)scsi_inqmatch(sa->sa_inqbuf,
143 1.51 mycroft (caddr_t)sd_patterns, sizeof(sd_patterns)/sizeof(sd_patterns[0]),
144 1.51 mycroft sizeof(sd_patterns[0]), &priority);
145 1.51 mycroft return (priority);
146 1.51 mycroft }
147 1.51 mycroft
148 1.3 deraadt /*
149 1.3 deraadt * The routine called by the low level scsi routine when it discovers
150 1.25 mycroft * a device suitable for this driver.
151 1.3 deraadt */
152 1.25 mycroft void
153 1.25 mycroft sdattach(parent, self, aux)
154 1.25 mycroft struct device *parent, *self;
155 1.25 mycroft void *aux;
156 1.1 cgd {
157 1.51 mycroft struct sd_softc *sd = (void *)self;
158 1.25 mycroft struct disk_parms *dp = &sd->params;
159 1.51 mycroft struct scsibus_attach_args *sa = aux;
160 1.51 mycroft struct scsi_link *sc_link = sa->sa_sc_link;
161 1.25 mycroft
162 1.25 mycroft SC_DEBUG(sc_link, SDEV_DB2, ("sdattach: "));
163 1.25 mycroft
164 1.25 mycroft /*
165 1.25 mycroft * Store information needed to contact our base driver
166 1.25 mycroft */
167 1.25 mycroft sd->sc_link = sc_link;
168 1.25 mycroft sc_link->device = &sd_switch;
169 1.46 mycroft sc_link->device_softc = sd;
170 1.51 mycroft if (sc_link->openings > SDOUTSTANDING)
171 1.51 mycroft sc_link->openings = SDOUTSTANDING;
172 1.3 deraadt
173 1.81 thorpej /*
174 1.84 thorpej * Initialize and attach the disk structure.
175 1.81 thorpej */
176 1.84 thorpej sd->sc_dk.dk_driver = &sddkdriver;
177 1.84 thorpej sd->sc_dk.dk_name = sd->sc_dev.dv_xname;
178 1.84 thorpej disk_attach(&sd->sc_dk);
179 1.81 thorpej
180 1.25 mycroft sd->sc_dk.dk_driver = &sddkdriver;
181 1.25 mycroft #if !defined(i386) || defined(NEWCONFIG)
182 1.84 thorpej dk_establish(&sd->sc_dk, &sd->sc_dev); /* XXX */
183 1.25 mycroft #endif
184 1.3 deraadt
185 1.3 deraadt /*
186 1.84 thorpej * Note if this device is ancient. This is used in sdminphys().
187 1.84 thorpej */
188 1.84 thorpej if ((sa->sa_inqbuf->version & SID_ANSII) == 0)
189 1.84 thorpej sd->flags |= SDF_ANCIENT;
190 1.84 thorpej
191 1.84 thorpej /*
192 1.3 deraadt * Use the subdriver to request information regarding
193 1.3 deraadt * the drive. We cannot use interrupts yet, so the
194 1.3 deraadt * request must specify this.
195 1.3 deraadt */
196 1.59 mycroft if (scsi_start(sd->sc_link, SSS_START,
197 1.55 mycroft SCSI_AUTOCONF | SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT) ||
198 1.51 mycroft sd_get_parms(sd, SCSI_AUTOCONF) != 0)
199 1.51 mycroft printf(": drive offline\n");
200 1.51 mycroft else
201 1.51 mycroft printf(": %dMB, %d cyl, %d head, %d sec, %d bytes/sec\n",
202 1.51 mycroft dp->disksize / (1048576 / dp->blksize), dp->cyls,
203 1.51 mycroft dp->heads, dp->sectors, dp->blksize);
204 1.1 cgd }
205 1.1 cgd
206 1.65 mycroft /*
207 1.65 mycroft * Wait interruptibly for an exclusive lock.
208 1.65 mycroft *
209 1.65 mycroft * XXX
210 1.65 mycroft * Several drivers do this; it should be abstracted and made MP-safe.
211 1.65 mycroft */
212 1.61 mycroft int
213 1.65 mycroft sdlock(sd)
214 1.61 mycroft struct sd_softc *sd;
215 1.61 mycroft {
216 1.61 mycroft int error;
217 1.61 mycroft
218 1.61 mycroft while ((sd->flags & SDF_LOCKED) != 0) {
219 1.61 mycroft sd->flags |= SDF_WANTED;
220 1.61 mycroft if ((error = tsleep(sd, PRIBIO | PCATCH, "sdlck", 0)) != 0)
221 1.61 mycroft return error;
222 1.61 mycroft }
223 1.65 mycroft sd->flags |= SDF_LOCKED;
224 1.61 mycroft return 0;
225 1.61 mycroft }
226 1.61 mycroft
227 1.65 mycroft /*
228 1.65 mycroft * Unlock and wake up any waiters.
229 1.65 mycroft */
230 1.61 mycroft void
231 1.61 mycroft sdunlock(sd)
232 1.61 mycroft struct sd_softc *sd;
233 1.61 mycroft {
234 1.61 mycroft
235 1.61 mycroft sd->flags &= ~SDF_LOCKED;
236 1.61 mycroft if ((sd->flags & SDF_WANTED) != 0) {
237 1.61 mycroft sd->flags &= ~SDF_WANTED;
238 1.61 mycroft wakeup(sd);
239 1.61 mycroft }
240 1.61 mycroft }
241 1.61 mycroft
242 1.3 deraadt /*
243 1.25 mycroft * open the device. Make sure the partition info is a up-to-date as can be.
244 1.3 deraadt */
245 1.3 deraadt int
246 1.45 mycroft sdopen(dev, flag, fmt)
247 1.25 mycroft dev_t dev;
248 1.37 mycroft int flag, fmt;
249 1.1 cgd {
250 1.51 mycroft struct sd_softc *sd;
251 1.25 mycroft struct scsi_link *sc_link;
252 1.65 mycroft int unit, part;
253 1.65 mycroft int error;
254 1.1 cgd
255 1.25 mycroft unit = SDUNIT(dev);
256 1.25 mycroft if (unit >= sdcd.cd_ndevs)
257 1.3 deraadt return ENXIO;
258 1.25 mycroft sd = sdcd.cd_devs[unit];
259 1.29 mycroft if (!sd)
260 1.3 deraadt return ENXIO;
261 1.3 deraadt
262 1.25 mycroft sc_link = sd->sc_link;
263 1.25 mycroft
264 1.25 mycroft SC_DEBUG(sc_link, SDEV_DB1,
265 1.25 mycroft ("sdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit,
266 1.25 mycroft sdcd.cd_ndevs, part));
267 1.3 deraadt
268 1.65 mycroft if (error = sdlock(sd))
269 1.61 mycroft return error;
270 1.45 mycroft
271 1.47 mycroft if (sd->sc_dk.dk_openmask != 0) {
272 1.47 mycroft /*
273 1.47 mycroft * If any partition is open, but the disk has been invalidated,
274 1.47 mycroft * disallow further opens.
275 1.47 mycroft */
276 1.66 mycroft if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
277 1.66 mycroft error = EIO;
278 1.66 mycroft goto bad3;
279 1.66 mycroft }
280 1.47 mycroft } else {
281 1.55 mycroft /* Check that it is still responding and ok. */
282 1.55 mycroft if (error = scsi_test_unit_ready(sc_link,
283 1.55 mycroft SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE | SCSI_IGNORE_NOT_READY))
284 1.57 mycroft goto bad3;
285 1.57 mycroft
286 1.57 mycroft /* Start the pack spinning if necessary. */
287 1.59 mycroft if (error = scsi_start(sc_link, SSS_START,
288 1.57 mycroft SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT))
289 1.57 mycroft goto bad3;
290 1.57 mycroft
291 1.57 mycroft sc_link->flags |= SDEV_OPEN;
292 1.48 mycroft
293 1.45 mycroft /* Lock the pack in. */
294 1.55 mycroft if (error = scsi_prevent(sc_link, PR_PREVENT,
295 1.55 mycroft SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE))
296 1.55 mycroft goto bad;
297 1.54 mycroft
298 1.45 mycroft if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
299 1.45 mycroft sc_link->flags |= SDEV_MEDIA_LOADED;
300 1.3 deraadt
301 1.45 mycroft /* Load the physical device parameters. */
302 1.45 mycroft if (sd_get_parms(sd, 0) != 0) {
303 1.45 mycroft error = ENXIO;
304 1.45 mycroft goto bad2;
305 1.45 mycroft }
306 1.45 mycroft SC_DEBUG(sc_link, SDEV_DB3, ("Params loaded "));
307 1.45 mycroft
308 1.45 mycroft /* Load the partition info if not already loaded. */
309 1.45 mycroft sdgetdisklabel(sd);
310 1.45 mycroft SC_DEBUG(sc_link, SDEV_DB3, ("Disklabel loaded "));
311 1.45 mycroft }
312 1.65 mycroft }
313 1.25 mycroft
314 1.65 mycroft part = SDPART(dev);
315 1.63 mycroft
316 1.47 mycroft /* Check that the partition exists. */
317 1.37 mycroft if (part != RAW_PART &&
318 1.84 thorpej (part >= sd->sc_dk.dk_label->d_npartitions ||
319 1.84 thorpej sd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
320 1.25 mycroft error = ENXIO;
321 1.25 mycroft goto bad;
322 1.1 cgd }
323 1.3 deraadt
324 1.37 mycroft /* Insure only one open at a time. */
325 1.37 mycroft switch (fmt) {
326 1.37 mycroft case S_IFCHR:
327 1.40 mycroft sd->sc_dk.dk_copenmask |= (1 << part);
328 1.37 mycroft break;
329 1.37 mycroft case S_IFBLK:
330 1.40 mycroft sd->sc_dk.dk_bopenmask |= (1 << part);
331 1.37 mycroft break;
332 1.1 cgd }
333 1.40 mycroft sd->sc_dk.dk_openmask = sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
334 1.37 mycroft
335 1.25 mycroft SC_DEBUG(sc_link, SDEV_DB3, ("open complete\n"));
336 1.65 mycroft sdunlock(sd);
337 1.3 deraadt return 0;
338 1.1 cgd
339 1.45 mycroft bad2:
340 1.45 mycroft sc_link->flags &= ~SDEV_MEDIA_LOADED;
341 1.45 mycroft
342 1.25 mycroft bad:
343 1.40 mycroft if (sd->sc_dk.dk_openmask == 0) {
344 1.51 mycroft scsi_prevent(sc_link, PR_ALLOW,
345 1.55 mycroft SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
346 1.25 mycroft sc_link->flags &= ~SDEV_OPEN;
347 1.65 mycroft }
348 1.45 mycroft
349 1.57 mycroft bad3:
350 1.65 mycroft sdunlock(sd);
351 1.25 mycroft return error;
352 1.1 cgd }
353 1.1 cgd
354 1.3 deraadt /*
355 1.25 mycroft * close the device.. only called if we are the LAST occurence of an open
356 1.25 mycroft * device. Convenient now but usually a pain.
357 1.3 deraadt */
358 1.75 mycroft int
359 1.37 mycroft sdclose(dev, flag, fmt)
360 1.25 mycroft dev_t dev;
361 1.37 mycroft int flag, fmt;
362 1.1 cgd {
363 1.51 mycroft struct sd_softc *sd = sdcd.cd_devs[SDUNIT(dev)];
364 1.37 mycroft int part = SDPART(dev);
365 1.65 mycroft int error;
366 1.65 mycroft
367 1.65 mycroft if (error = sdlock(sd))
368 1.65 mycroft return error;
369 1.37 mycroft
370 1.37 mycroft switch (fmt) {
371 1.37 mycroft case S_IFCHR:
372 1.40 mycroft sd->sc_dk.dk_copenmask &= ~(1 << part);
373 1.37 mycroft break;
374 1.37 mycroft case S_IFBLK:
375 1.40 mycroft sd->sc_dk.dk_bopenmask &= ~(1 << part);
376 1.37 mycroft break;
377 1.37 mycroft }
378 1.40 mycroft sd->sc_dk.dk_openmask = sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
379 1.25 mycroft
380 1.40 mycroft if (sd->sc_dk.dk_openmask == 0) {
381 1.65 mycroft /* XXXX Must wait for I/O to complete! */
382 1.47 mycroft
383 1.51 mycroft scsi_prevent(sd->sc_link, PR_ALLOW,
384 1.51 mycroft SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY);
385 1.25 mycroft sd->sc_link->flags &= ~SDEV_OPEN;
386 1.1 cgd }
387 1.47 mycroft
388 1.65 mycroft sdunlock(sd);
389 1.25 mycroft return 0;
390 1.1 cgd }
391 1.1 cgd
392 1.3 deraadt /*
393 1.25 mycroft * Actually translate the requested transfer into one the physical driver
394 1.25 mycroft * can understand. The transfer is described by a buf and will include
395 1.3 deraadt * only one physical transfer.
396 1.3 deraadt */
397 1.75 mycroft void
398 1.25 mycroft sdstrategy(bp)
399 1.25 mycroft struct buf *bp;
400 1.1 cgd {
401 1.51 mycroft struct sd_softc *sd = sdcd.cd_devs[SDUNIT(bp->b_dev)];
402 1.77 mycroft int s;
403 1.1 cgd
404 1.25 mycroft SC_DEBUG(sd->sc_link, SDEV_DB2, ("sdstrategy "));
405 1.25 mycroft SC_DEBUG(sd->sc_link, SDEV_DB1,
406 1.25 mycroft ("%d bytes @ blk %d\n", bp->b_bcount, bp->b_blkno));
407 1.80 mycroft /*
408 1.80 mycroft * The transfer must be a whole number of blocks.
409 1.80 mycroft */
410 1.84 thorpej if ((bp->b_bcount % sd->sc_dk.dk_label->d_secsize) != 0) {
411 1.80 mycroft bp->b_error = EINVAL;
412 1.80 mycroft goto bad;
413 1.80 mycroft }
414 1.25 mycroft /*
415 1.25 mycroft * If the device has been made invalid, error out
416 1.25 mycroft */
417 1.61 mycroft if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
418 1.1 cgd bp->b_error = EIO;
419 1.1 cgd goto bad;
420 1.1 cgd }
421 1.25 mycroft /*
422 1.25 mycroft * If it's a null transfer, return immediatly
423 1.25 mycroft */
424 1.1 cgd if (bp->b_bcount == 0)
425 1.1 cgd goto done;
426 1.52 mycroft
427 1.3 deraadt /*
428 1.52 mycroft * Do bounds checking, adjust transfer. if error, process.
429 1.52 mycroft * If end of partition, just return.
430 1.3 deraadt */
431 1.68 mycroft if (SDPART(bp->b_dev) != RAW_PART &&
432 1.84 thorpej bounds_check_with_label(bp, sd->sc_dk.dk_label,
433 1.61 mycroft (sd->flags & (SDF_WLABEL|SDF_LABELLING)) != 0) <= 0)
434 1.52 mycroft goto done;
435 1.37 mycroft
436 1.77 mycroft s = splbio();
437 1.1 cgd
438 1.25 mycroft /*
439 1.25 mycroft * Place it in the queue of disk activities for this disk
440 1.25 mycroft */
441 1.37 mycroft disksort(&sd->buf_queue, bp);
442 1.1 cgd
443 1.3 deraadt /*
444 1.3 deraadt * Tell the device to get going on the transfer if it's
445 1.3 deraadt * not doing anything, otherwise just wait for completion
446 1.3 deraadt */
447 1.46 mycroft sdstart(sd);
448 1.1 cgd
449 1.77 mycroft splx(s);
450 1.1 cgd return;
451 1.25 mycroft
452 1.1 cgd bad:
453 1.1 cgd bp->b_flags |= B_ERROR;
454 1.1 cgd done:
455 1.25 mycroft /*
456 1.25 mycroft * Correctly set the buf to indicate a completed xfer
457 1.25 mycroft */
458 1.25 mycroft bp->b_resid = bp->b_bcount;
459 1.1 cgd biodone(bp);
460 1.1 cgd }
461 1.1 cgd
462 1.3 deraadt /*
463 1.3 deraadt * sdstart looks to see if there is a buf waiting for the device
464 1.3 deraadt * and that the device is not already busy. If both are true,
465 1.25 mycroft * It dequeues the buf and creates a scsi command to perform the
466 1.25 mycroft * transfer in the buf. The transfer request will call scsi_done
467 1.3 deraadt * on completion, which will in turn call this routine again
468 1.3 deraadt * so that the next queued transfer is performed.
469 1.3 deraadt * The bufs are queued by the strategy routine (sdstrategy)
470 1.25 mycroft *
471 1.3 deraadt * This routine is also called after other non-queued requests
472 1.3 deraadt * have been made of the scsi driver, to ensure that the queue
473 1.3 deraadt * continues to be drained.
474 1.25 mycroft *
475 1.3 deraadt * must be called at the correct (highish) spl level
476 1.25 mycroft * sdstart() is called at splbio from sdstrategy and scsi_done
477 1.3 deraadt */
478 1.75 mycroft void
479 1.46 mycroft sdstart(sd)
480 1.51 mycroft register struct sd_softc *sd;
481 1.3 deraadt {
482 1.25 mycroft register struct scsi_link *sc_link = sd->sc_link;
483 1.25 mycroft struct buf *bp = 0;
484 1.25 mycroft struct buf *dp;
485 1.81 thorpej struct scsi_rw_big cmd_big;
486 1.81 thorpej struct scsi_rw cmd_small;
487 1.81 thorpej struct scsi_generic *cmdp;
488 1.81 thorpej int blkno, nblks, cmdlen;
489 1.3 deraadt struct partition *p;
490 1.3 deraadt
491 1.25 mycroft SC_DEBUG(sc_link, SDEV_DB2, ("sdstart "));
492 1.3 deraadt /*
493 1.25 mycroft * Check if the device has room for another command
494 1.3 deraadt */
495 1.51 mycroft while (sc_link->openings > 0) {
496 1.25 mycroft /*
497 1.75 mycroft * there is excess capacity, but a special waits
498 1.25 mycroft * It'll need the adapter as soon as we clear out of the
499 1.25 mycroft * way and let it run (user level wait).
500 1.25 mycroft */
501 1.25 mycroft if (sc_link->flags & SDEV_WAITING) {
502 1.25 mycroft sc_link->flags &= ~SDEV_WAITING;
503 1.25 mycroft wakeup((caddr_t)sc_link);
504 1.25 mycroft return;
505 1.25 mycroft }
506 1.1 cgd
507 1.25 mycroft /*
508 1.25 mycroft * See if there is a buf with work for us to do..
509 1.25 mycroft */
510 1.25 mycroft dp = &sd->buf_queue;
511 1.25 mycroft if ((bp = dp->b_actf) == NULL) /* yes, an assign */
512 1.25 mycroft return;
513 1.22 mycroft dp->b_actf = bp->b_actf;
514 1.3 deraadt
515 1.25 mycroft /*
516 1.25 mycroft * If the device has become invalid, abort all the
517 1.25 mycroft * reads and writes until all files have been closed and
518 1.51 mycroft * re-opened
519 1.25 mycroft */
520 1.61 mycroft if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
521 1.32 chopps bp->b_error = EIO;
522 1.32 chopps bp->b_flags |= B_ERROR;
523 1.32 chopps biodone(bp);
524 1.32 chopps continue;
525 1.25 mycroft }
526 1.1 cgd
527 1.25 mycroft /*
528 1.75 mycroft * We have a buf, now we should make a command
529 1.25 mycroft *
530 1.61 mycroft * First, translate the block to absolute and put it in terms
531 1.61 mycroft * of the logical blocksize of the device.
532 1.25 mycroft */
533 1.37 mycroft blkno =
534 1.84 thorpej bp->b_blkno / (sd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
535 1.25 mycroft if (SDPART(bp->b_dev) != RAW_PART) {
536 1.84 thorpej p = &sd->sc_dk.dk_label->d_partitions[SDPART(bp->b_dev)];
537 1.84 thorpej blkno += p->p_offset;
538 1.25 mycroft }
539 1.84 thorpej nblks = howmany(bp->b_bcount, sd->sc_dk.dk_label->d_secsize);
540 1.3 deraadt
541 1.25 mycroft /*
542 1.81 thorpej * Fill out the scsi command. If the transfer will
543 1.81 thorpej * fit in a "small" cdb, use it.
544 1.25 mycroft */
545 1.81 thorpej if (((blkno & 0x1fffff) == blkno) &&
546 1.81 thorpej ((nblks & 0xff) == nblks)) {
547 1.81 thorpej /*
548 1.81 thorpej * We can fit in a small cdb.
549 1.81 thorpej */
550 1.81 thorpej bzero(&cmd_small, sizeof(cmd_small));
551 1.81 thorpej cmd_small.opcode = (bp->b_flags & B_READ) ?
552 1.81 thorpej READ_COMMAND : WRITE_COMMAND;
553 1.81 thorpej cmd_small.addr_2 = (blkno >> 16) & 0x1f;
554 1.81 thorpej cmd_small.addr_1 = (blkno >> 8) & 0xff;
555 1.81 thorpej cmd_small.addr_0 = blkno & 0xff;
556 1.81 thorpej cmd_small.length = nblks & 0xff;
557 1.81 thorpej cmdlen = sizeof(cmd_small);
558 1.81 thorpej cmdp = (struct scsi_generic *)&cmd_small;
559 1.81 thorpej } else {
560 1.81 thorpej /*
561 1.81 thorpej * Need a large cdb.
562 1.81 thorpej */
563 1.81 thorpej bzero(&cmd_big, sizeof(cmd_big));
564 1.81 thorpej cmd_big.opcode = (bp->b_flags & B_READ) ?
565 1.81 thorpej READ_BIG : WRITE_BIG;
566 1.81 thorpej cmd_big.addr_3 = (blkno >> 24) & 0xff;
567 1.81 thorpej cmd_big.addr_2 = (blkno >> 16) & 0xff;
568 1.81 thorpej cmd_big.addr_1 = (blkno >> 8) & 0xff;
569 1.81 thorpej cmd_big.addr_0 = blkno & 0xff;
570 1.81 thorpej cmd_big.length2 = (nblks >> 8) & 0xff;
571 1.81 thorpej cmd_big.length1 = nblks & 0xff;
572 1.81 thorpej cmdlen = sizeof(cmd_big);
573 1.81 thorpej cmdp = (struct scsi_generic *)&cmd_big;
574 1.81 thorpej }
575 1.1 cgd
576 1.84 thorpej /* Instrumentation. */
577 1.84 thorpej disk_busy(&sd->sc_dk);
578 1.84 thorpej
579 1.25 mycroft /*
580 1.25 mycroft * Call the routine that chats with the adapter.
581 1.25 mycroft * Note: we cannot sleep as we may be an interrupt
582 1.25 mycroft */
583 1.81 thorpej if (scsi_scsi_cmd(sc_link, cmdp, cmdlen,
584 1.81 thorpej (u_char *)bp->b_data, bp->b_bcount,
585 1.25 mycroft SDRETRIES, 10000, bp, SCSI_NOSLEEP |
586 1.51 mycroft ((bp->b_flags & B_READ) ? SCSI_DATA_IN : SCSI_DATA_OUT)))
587 1.25 mycroft printf("%s: not queued", sd->sc_dev.dv_xname);
588 1.25 mycroft }
589 1.72 mycroft }
590 1.72 mycroft
591 1.84 thorpej int
592 1.84 thorpej sddone(xs)
593 1.84 thorpej struct scsi_xfer *xs;
594 1.84 thorpej {
595 1.84 thorpej struct sd_softc *sd = xs->sc_link->device_softc;
596 1.84 thorpej
597 1.84 thorpej if (xs->bp != NULL)
598 1.84 thorpej disk_unbusy(&sd->sc_dk, (xs->bp->b_bcount - xs->bp->b_resid));
599 1.84 thorpej
600 1.84 thorpej return (0);
601 1.84 thorpej }
602 1.84 thorpej
603 1.81 thorpej void
604 1.81 thorpej sdminphys(bp)
605 1.81 thorpej struct buf *bp;
606 1.81 thorpej {
607 1.81 thorpej struct sd_softc *sd = sdcd.cd_devs[SDUNIT(bp->b_dev)];
608 1.81 thorpej long max;
609 1.81 thorpej
610 1.81 thorpej /*
611 1.81 thorpej * If the device is ancient, we want to make sure that
612 1.81 thorpej * the transfer fits into a 6-byte cdb.
613 1.82 thorpej *
614 1.82 thorpej * XXX Note that the SCSI-I spec says that 256-block transfers
615 1.82 thorpej * are allowed in a 6-byte read/write, and are specified
616 1.82 thorpej * by settng the "length" to 0. However, we're conservative
617 1.82 thorpej * here, allowing only 255-block transfers in case an
618 1.82 thorpej * ancient device gets confused by length == 0. A length of 0
619 1.82 thorpej * in a 10-byte read/write actually means 0 blocks.
620 1.81 thorpej */
621 1.81 thorpej if (sd->flags & SDF_ANCIENT) {
622 1.84 thorpej max = sd->sc_dk.dk_label->d_secsize * 0xff;
623 1.81 thorpej
624 1.81 thorpej if (bp->b_bcount > max)
625 1.81 thorpej bp->b_bcount = max;
626 1.81 thorpej }
627 1.81 thorpej
628 1.81 thorpej (*sd->sc_link->adapter->scsi_minphys)(bp);
629 1.81 thorpej }
630 1.81 thorpej
631 1.72 mycroft int
632 1.72 mycroft sdread(dev, uio)
633 1.72 mycroft dev_t dev;
634 1.72 mycroft struct uio *uio;
635 1.72 mycroft {
636 1.72 mycroft
637 1.81 thorpej return (physio(sdstrategy, NULL, dev, B_READ, sdminphys, uio));
638 1.72 mycroft }
639 1.72 mycroft
640 1.72 mycroft int
641 1.72 mycroft sdwrite(dev, uio)
642 1.72 mycroft dev_t dev;
643 1.72 mycroft struct uio *uio;
644 1.72 mycroft {
645 1.72 mycroft
646 1.81 thorpej return (physio(sdstrategy, NULL, dev, B_WRITE, sdminphys, uio));
647 1.1 cgd }
648 1.3 deraadt
649 1.3 deraadt /*
650 1.3 deraadt * Perform special action on behalf of the user
651 1.3 deraadt * Knows about the internals of this device
652 1.3 deraadt */
653 1.75 mycroft int
654 1.51 mycroft sdioctl(dev, cmd, addr, flag, p)
655 1.25 mycroft dev_t dev;
656 1.43 cgd u_long cmd;
657 1.25 mycroft caddr_t addr;
658 1.25 mycroft int flag;
659 1.51 mycroft struct proc *p;
660 1.1 cgd {
661 1.51 mycroft struct sd_softc *sd = sdcd.cd_devs[SDUNIT(dev)];
662 1.45 mycroft int error;
663 1.1 cgd
664 1.61 mycroft SC_DEBUG(sd->sc_link, SDEV_DB2, ("sdioctl 0x%lx ", cmd));
665 1.61 mycroft
666 1.25 mycroft /*
667 1.25 mycroft * If the device is not valid.. abandon ship
668 1.25 mycroft */
669 1.61 mycroft if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0)
670 1.3 deraadt return EIO;
671 1.45 mycroft
672 1.25 mycroft switch (cmd) {
673 1.1 cgd case DIOCGDINFO:
674 1.84 thorpej *(struct disklabel *)addr = *(sd->sc_dk.dk_label);
675 1.25 mycroft return 0;
676 1.25 mycroft
677 1.3 deraadt case DIOCGPART:
678 1.84 thorpej ((struct partinfo *)addr)->disklab = sd->sc_dk.dk_label;
679 1.37 mycroft ((struct partinfo *)addr)->part =
680 1.84 thorpej &sd->sc_dk.dk_label->d_partitions[SDPART(dev)];
681 1.25 mycroft return 0;
682 1.25 mycroft
683 1.61 mycroft case DIOCWDINFO:
684 1.3 deraadt case DIOCSDINFO:
685 1.3 deraadt if ((flag & FWRITE) == 0)
686 1.25 mycroft return EBADF;
687 1.61 mycroft
688 1.65 mycroft if (error = sdlock(sd))
689 1.61 mycroft return error;
690 1.65 mycroft sd->flags |= SDF_LABELLING;
691 1.61 mycroft
692 1.84 thorpej error = setdisklabel(sd->sc_dk.dk_label,
693 1.52 mycroft (struct disklabel *)addr, /*sd->sc_dk.dk_openmask : */0,
694 1.84 thorpej sd->sc_dk.dk_cpulabel);
695 1.62 mycroft if (error == 0) {
696 1.62 mycroft if (cmd == DIOCWDINFO)
697 1.62 mycroft error = writedisklabel(SDLABELDEV(dev),
698 1.84 thorpej sdstrategy, sd->sc_dk.dk_label,
699 1.84 thorpej sd->sc_dk.dk_cpulabel);
700 1.62 mycroft }
701 1.61 mycroft
702 1.61 mycroft sd->flags &= ~SDF_LABELLING;
703 1.61 mycroft sdunlock(sd);
704 1.25 mycroft return error;
705 1.25 mycroft
706 1.3 deraadt case DIOCWLABEL:
707 1.3 deraadt if ((flag & FWRITE) == 0)
708 1.25 mycroft return EBADF;
709 1.37 mycroft if (*(int *)addr)
710 1.37 mycroft sd->flags |= SDF_WLABEL;
711 1.37 mycroft else
712 1.37 mycroft sd->flags &= ~SDF_WLABEL;
713 1.25 mycroft return 0;
714 1.25 mycroft
715 1.1 cgd default:
716 1.45 mycroft if (SDPART(dev) != RAW_PART)
717 1.25 mycroft return ENOTTY;
718 1.51 mycroft return scsi_do_ioctl(sd->sc_link, dev, cmd, addr, flag, p);
719 1.25 mycroft }
720 1.45 mycroft
721 1.25 mycroft #ifdef DIAGNOSTIC
722 1.25 mycroft panic("sdioctl: impossible");
723 1.25 mycroft #endif
724 1.1 cgd }
725 1.1 cgd
726 1.3 deraadt /*
727 1.3 deraadt * Load the label information on the named device
728 1.3 deraadt */
729 1.75 mycroft void
730 1.25 mycroft sdgetdisklabel(sd)
731 1.51 mycroft struct sd_softc *sd;
732 1.1 cgd {
733 1.84 thorpej struct disklabel *lp = sd->sc_dk.dk_label;
734 1.1 cgd char *errstring;
735 1.1 cgd
736 1.74 mycroft bzero(lp, sizeof(struct disklabel));
737 1.84 thorpej bzero(sd->sc_dk.dk_cpulabel, sizeof(struct cpu_disklabel));
738 1.25 mycroft
739 1.74 mycroft lp->d_secsize = sd->params.blksize;
740 1.74 mycroft lp->d_ntracks = sd->params.heads;
741 1.74 mycroft lp->d_nsectors = sd->params.sectors;
742 1.74 mycroft lp->d_ncylinders = sd->params.cyls;
743 1.74 mycroft lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
744 1.74 mycroft if (lp->d_secpercyl == 0) {
745 1.74 mycroft lp->d_secpercyl = 100;
746 1.25 mycroft /* as long as it's not 0 - readdisklabel divides by it (?) */
747 1.1 cgd }
748 1.1 cgd
749 1.74 mycroft strncpy(lp->d_typename, "SCSI disk", 16);
750 1.74 mycroft lp->d_type = DTYPE_SCSI;
751 1.74 mycroft strncpy(lp->d_packname, "fictitious", 16);
752 1.74 mycroft lp->d_secperunit = sd->params.disksize;
753 1.74 mycroft lp->d_rpm = 3600;
754 1.74 mycroft lp->d_interleave = 1;
755 1.74 mycroft lp->d_flags = 0;
756 1.74 mycroft
757 1.74 mycroft lp->d_partitions[RAW_PART].p_offset = 0;
758 1.74 mycroft lp->d_partitions[RAW_PART].p_size =
759 1.74 mycroft lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
760 1.74 mycroft lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
761 1.74 mycroft lp->d_npartitions = RAW_PART + 1;
762 1.74 mycroft
763 1.74 mycroft lp->d_magic = DISKMAGIC;
764 1.74 mycroft lp->d_magic2 = DISKMAGIC;
765 1.74 mycroft lp->d_checksum = dkcksum(lp);
766 1.45 mycroft
767 1.25 mycroft /*
768 1.25 mycroft * Call the generic disklabel extraction routine
769 1.25 mycroft */
770 1.36 cgd if (errstring = readdisklabel(MAKESDDEV(0, sd->sc_dev.dv_unit,
771 1.84 thorpej RAW_PART), sdstrategy, lp, sd->sc_dk.dk_cpulabel)) {
772 1.25 mycroft printf("%s: %s\n", sd->sc_dev.dv_xname, errstring);
773 1.45 mycroft return;
774 1.1 cgd }
775 1.1 cgd }
776 1.1 cgd
777 1.3 deraadt /*
778 1.3 deraadt * Find out from the device what it's capacity is
779 1.3 deraadt */
780 1.75 mycroft u_long
781 1.25 mycroft sd_size(sd, flags)
782 1.51 mycroft struct sd_softc *sd;
783 1.25 mycroft int flags;
784 1.1 cgd {
785 1.1 cgd struct scsi_read_cap_data rdcap;
786 1.1 cgd struct scsi_read_capacity scsi_cmd;
787 1.51 mycroft u_long size;
788 1.1 cgd
789 1.3 deraadt /*
790 1.3 deraadt * make up a scsi command and ask the scsi driver to do
791 1.3 deraadt * it for you.
792 1.3 deraadt */
793 1.1 cgd bzero(&scsi_cmd, sizeof(scsi_cmd));
794 1.51 mycroft scsi_cmd.opcode = READ_CAPACITY;
795 1.1 cgd
796 1.3 deraadt /*
797 1.3 deraadt * If the command works, interpret the result as a 4 byte
798 1.3 deraadt * number of blocks
799 1.3 deraadt */
800 1.39 mycroft if (scsi_scsi_cmd(sd->sc_link, (struct scsi_generic *)&scsi_cmd,
801 1.39 mycroft sizeof(scsi_cmd), (u_char *)&rdcap, sizeof(rdcap), SDRETRIES,
802 1.51 mycroft 2000, NULL, flags | SCSI_DATA_IN) != 0)
803 1.3 deraadt return 0;
804 1.45 mycroft
805 1.45 mycroft size = (rdcap.addr_3 << 24) + (rdcap.addr_2 << 16) +
806 1.45 mycroft (rdcap.addr_1 << 8) + rdcap.addr_0 + 1;
807 1.45 mycroft
808 1.3 deraadt return size;
809 1.1 cgd }
810 1.3 deraadt
811 1.3 deraadt /*
812 1.3 deraadt * Tell the device to map out a defective block
813 1.3 deraadt */
814 1.75 mycroft int
815 1.25 mycroft sd_reassign_blocks(sd, block)
816 1.51 mycroft struct sd_softc *sd;
817 1.51 mycroft u_long block;
818 1.1 cgd {
819 1.25 mycroft struct scsi_reassign_blocks scsi_cmd;
820 1.3 deraadt struct scsi_reassign_blocks_data rbdata;
821 1.1 cgd
822 1.1 cgd bzero(&scsi_cmd, sizeof(scsi_cmd));
823 1.1 cgd bzero(&rbdata, sizeof(rbdata));
824 1.51 mycroft scsi_cmd.opcode = REASSIGN_BLOCKS;
825 1.1 cgd
826 1.1 cgd rbdata.length_msb = 0;
827 1.1 cgd rbdata.length_lsb = sizeof(rbdata.defect_descriptor[0]);
828 1.70 cgd rbdata.defect_descriptor[0].dlbaddr_3 = (block >> 24) & 0xff;
829 1.70 cgd rbdata.defect_descriptor[0].dlbaddr_2 = (block >> 16) & 0xff;
830 1.70 cgd rbdata.defect_descriptor[0].dlbaddr_1 = (block >> 8) & 0xff;
831 1.69 mycroft rbdata.defect_descriptor[0].dlbaddr_0 = block & 0xff;
832 1.1 cgd
833 1.39 mycroft return scsi_scsi_cmd(sd->sc_link, (struct scsi_generic *)&scsi_cmd,
834 1.39 mycroft sizeof(scsi_cmd), (u_char *)&rbdata, sizeof(rbdata), SDRETRIES,
835 1.25 mycroft 5000, NULL, SCSI_DATA_OUT);
836 1.1 cgd }
837 1.1 cgd
838 1.1 cgd #define b2tol(a) (((unsigned)(a##_1) << 8) + (unsigned)a##_0 )
839 1.1 cgd
840 1.3 deraadt /*
841 1.25 mycroft * Get the scsi driver to send a full inquiry to the * device and use the
842 1.25 mycroft * results to fill out the disk parameter structure.
843 1.3 deraadt */
844 1.75 mycroft int
845 1.25 mycroft sd_get_parms(sd, flags)
846 1.51 mycroft struct sd_softc *sd;
847 1.25 mycroft int flags;
848 1.1 cgd {
849 1.45 mycroft struct disk_parms *dp = &sd->params;
850 1.25 mycroft struct scsi_mode_sense scsi_cmd;
851 1.3 deraadt struct scsi_mode_sense_data {
852 1.25 mycroft struct scsi_mode_header header;
853 1.51 mycroft struct scsi_blk_desc blk_desc;
854 1.25 mycroft union disk_pages pages;
855 1.3 deraadt } scsi_sense;
856 1.51 mycroft u_long sectors;
857 1.1 cgd
858 1.25 mycroft /*
859 1.25 mycroft * do a "mode sense page 4"
860 1.25 mycroft */
861 1.1 cgd bzero(&scsi_cmd, sizeof(scsi_cmd));
862 1.51 mycroft scsi_cmd.opcode = MODE_SENSE;
863 1.25 mycroft scsi_cmd.page = 4;
864 1.1 cgd scsi_cmd.length = 0x20;
865 1.3 deraadt /*
866 1.3 deraadt * If the command worked, use the results to fill out
867 1.3 deraadt * the parameter structure
868 1.3 deraadt */
869 1.39 mycroft if (scsi_scsi_cmd(sd->sc_link, (struct scsi_generic *)&scsi_cmd,
870 1.39 mycroft sizeof(scsi_cmd), (u_char *)&scsi_sense, sizeof(scsi_sense),
871 1.25 mycroft SDRETRIES, 6000, NULL, flags | SCSI_DATA_IN) != 0) {
872 1.26 mycroft printf("%s: could not mode sense (4)", sd->sc_dev.dv_xname);
873 1.26 mycroft fake_it:
874 1.60 mycroft printf("; using fictitious geometry\n");
875 1.25 mycroft /*
876 1.60 mycroft * use adaptec standard fictitious geometry
877 1.25 mycroft * this depends on which controller (e.g. 1542C is
878 1.25 mycroft * different. but we have to put SOMETHING here..)
879 1.25 mycroft */
880 1.25 mycroft sectors = sd_size(sd, flags);
881 1.45 mycroft dp->heads = 64;
882 1.45 mycroft dp->sectors = 32;
883 1.45 mycroft dp->cyls = sectors / (64 * 32);
884 1.45 mycroft dp->blksize = 512;
885 1.45 mycroft dp->disksize = sectors;
886 1.3 deraadt } else {
887 1.25 mycroft SC_DEBUG(sd->sc_link, SDEV_DB3,
888 1.25 mycroft ("%d cyls, %d heads, %d precomp, %d red_write, %d land_zone\n",
889 1.25 mycroft _3btol(&scsi_sense.pages.rigid_geometry.ncyl_2),
890 1.25 mycroft scsi_sense.pages.rigid_geometry.nheads,
891 1.25 mycroft b2tol(scsi_sense.pages.rigid_geometry.st_cyl_wp),
892 1.25 mycroft b2tol(scsi_sense.pages.rigid_geometry.st_cyl_rwc),
893 1.25 mycroft b2tol(scsi_sense.pages.rigid_geometry.land_zone)));
894 1.1 cgd
895 1.3 deraadt /*
896 1.25 mycroft * KLUDGE!! (for zone recorded disks)
897 1.3 deraadt * give a number of sectors so that sec * trks * cyls
898 1.75 mycroft * is <= disk_size
899 1.25 mycroft * can lead to wasted space! THINK ABOUT THIS !
900 1.3 deraadt */
901 1.45 mycroft dp->heads = scsi_sense.pages.rigid_geometry.nheads;
902 1.45 mycroft dp->cyls =
903 1.25 mycroft _3btol(&scsi_sense.pages.rigid_geometry.ncyl_2);
904 1.45 mycroft dp->blksize = _3btol(scsi_sense.blk_desc.blklen);
905 1.27 mycroft
906 1.53 mycroft if (dp->heads == 0 || dp->cyls == 0) {
907 1.27 mycroft printf("%s: mode sense (4) returned nonsense",
908 1.27 mycroft sd->sc_dev.dv_xname);
909 1.27 mycroft goto fake_it;
910 1.27 mycroft }
911 1.53 mycroft
912 1.53 mycroft if (dp->blksize == 0)
913 1.53 mycroft dp->blksize = 512;
914 1.1 cgd
915 1.25 mycroft sectors = sd_size(sd, flags);
916 1.45 mycroft dp->disksize = sectors;
917 1.45 mycroft sectors /= (dp->heads * dp->cyls);
918 1.45 mycroft dp->sectors = sectors; /* XXX dubious on SCSI */
919 1.1 cgd }
920 1.45 mycroft
921 1.3 deraadt return 0;
922 1.1 cgd }
923 1.1 cgd
924 1.3 deraadt int
925 1.45 mycroft sdsize(dev)
926 1.45 mycroft dev_t dev;
927 1.1 cgd {
928 1.51 mycroft struct sd_softc *sd;
929 1.45 mycroft int part;
930 1.45 mycroft int size;
931 1.1 cgd
932 1.45 mycroft if (sdopen(dev, 0, S_IFBLK) != 0)
933 1.25 mycroft return -1;
934 1.45 mycroft sd = sdcd.cd_devs[SDUNIT(dev)];
935 1.45 mycroft part = SDPART(dev);
936 1.84 thorpej if (sd->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
937 1.45 mycroft size = -1;
938 1.45 mycroft else
939 1.84 thorpej size = sd->sc_dk.dk_label->d_partitions[part].p_size;
940 1.45 mycroft if (sdclose(dev, 0, S_IFBLK) != 0)
941 1.25 mycroft return -1;
942 1.45 mycroft return size;
943 1.3 deraadt }
944 1.3 deraadt
945 1.71 cgd #ifndef __BDEVSW_DUMP_OLD_TYPE
946 1.71 cgd /* #define SD_DUMP_NOT_TRUSTED if you just want to watch */
947 1.25 mycroft static struct scsi_xfer sx;
948 1.71 cgd static int sddoingadump;
949 1.3 deraadt
950 1.3 deraadt /*
951 1.25 mycroft * dump all of physical memory into the partition specified, starting
952 1.25 mycroft * at offset 'dumplo' into the partition.
953 1.3 deraadt */
954 1.3 deraadt int
955 1.71 cgd sddump(dev, blkno, va, size)
956 1.71 cgd dev_t dev;
957 1.71 cgd daddr_t blkno;
958 1.71 cgd caddr_t va;
959 1.71 cgd size_t size;
960 1.71 cgd {
961 1.71 cgd struct sd_softc *sd; /* disk unit to do the I/O */
962 1.71 cgd struct disklabel *lp; /* disk's disklabel */
963 1.71 cgd int unit, part;
964 1.71 cgd int sectorsize; /* size of a disk sector */
965 1.71 cgd int nsects; /* number of sectors in partition */
966 1.71 cgd int sectoff; /* sector offset of partition */
967 1.71 cgd int totwrt; /* total number of sectors left to write */
968 1.71 cgd int nwrt; /* current number of sectors to write */
969 1.71 cgd struct scsi_rw_big cmd; /* write command */
970 1.71 cgd struct scsi_xfer *xs; /* ... convenience */
971 1.25 mycroft int retval;
972 1.25 mycroft
973 1.71 cgd /* Check if recursive dump; if so, punt. */
974 1.71 cgd if (sddoingadump)
975 1.71 cgd return EFAULT;
976 1.71 cgd
977 1.71 cgd /* Mark as active early. */
978 1.71 cgd sddoingadump = 1;
979 1.1 cgd
980 1.71 cgd unit = SDUNIT(dev); /* Decompose unit & partition. */
981 1.71 cgd part = SDPART(dev);
982 1.1 cgd
983 1.71 cgd /* Check for acceptable drive number. */
984 1.71 cgd if (unit >= sdcd.cd_ndevs || (sd = sdcd.cd_devs[unit]) == NULL)
985 1.25 mycroft return ENXIO;
986 1.3 deraadt
987 1.71 cgd /* Make sure it was initialized. */
988 1.25 mycroft if (sd->sc_link->flags & SDEV_MEDIA_LOADED != SDEV_MEDIA_LOADED)
989 1.25 mycroft return ENXIO;
990 1.25 mycroft
991 1.71 cgd /* Convert to disk sectors. Request must be a multiple of size. */
992 1.84 thorpej lp = sd->sc_dk.dk_label;
993 1.71 cgd sectorsize = lp->d_secsize;
994 1.71 cgd if ((size % sectorsize) != 0)
995 1.25 mycroft return EFAULT;
996 1.71 cgd totwrt = size / sectorsize;
997 1.71 cgd blkno = dbtob(blkno) / sectorsize; /* blkno in DEV_BSIZE units */
998 1.25 mycroft
999 1.71 cgd nsects = lp->d_partitions[part].p_size;
1000 1.71 cgd sectoff = lp->d_partitions[part].p_offset;
1001 1.25 mycroft
1002 1.71 cgd /* Check transfer bounds against partition size. */
1003 1.71 cgd if ((blkno < 0) || ((blkno + totwrt) > nsects))
1004 1.25 mycroft return EINVAL;
1005 1.25 mycroft
1006 1.71 cgd /* Offset block number to start of partition. */
1007 1.71 cgd blkno += sectoff;
1008 1.71 cgd
1009 1.71 cgd xs = &sx;
1010 1.3 deraadt
1011 1.71 cgd while (totwrt > 0) {
1012 1.71 cgd nwrt = totwrt; /* XXX */
1013 1.71 cgd #ifndef SD_DUMP_NOT_TRUSTED
1014 1.25 mycroft /*
1015 1.25 mycroft * Fill out the scsi command
1016 1.25 mycroft */
1017 1.25 mycroft bzero(&cmd, sizeof(cmd));
1018 1.51 mycroft cmd.opcode = WRITE_BIG;
1019 1.69 mycroft cmd.addr_3 = (blkno >> 24) & 0xff;
1020 1.69 mycroft cmd.addr_2 = (blkno >> 16) & 0xff;
1021 1.69 mycroft cmd.addr_1 = (blkno >> 8) & 0xff;
1022 1.69 mycroft cmd.addr_0 = blkno & 0xff;
1023 1.71 cgd cmd.length2 = (nwrt >> 8) & 0xff;
1024 1.71 cgd cmd.length1 = nwrt & 0xff;
1025 1.25 mycroft /*
1026 1.25 mycroft * Fill out the scsi_xfer structure
1027 1.25 mycroft * Note: we cannot sleep as we may be an interrupt
1028 1.75 mycroft * don't use scsi_scsi_cmd() as it may want
1029 1.25 mycroft * to wait for an xs.
1030 1.25 mycroft */
1031 1.25 mycroft bzero(xs, sizeof(sx));
1032 1.79 pk xs->flags |= SCSI_AUTOCONF | INUSE | SCSI_DATA_OUT;
1033 1.25 mycroft xs->sc_link = sd->sc_link;
1034 1.25 mycroft xs->retries = SDRETRIES;
1035 1.25 mycroft xs->timeout = 10000; /* 10000 millisecs for a disk ! */
1036 1.39 mycroft xs->cmd = (struct scsi_generic *)&cmd;
1037 1.25 mycroft xs->cmdlen = sizeof(cmd);
1038 1.71 cgd xs->resid = nwrt * sectorsize;
1039 1.25 mycroft xs->error = XS_NOERROR;
1040 1.25 mycroft xs->bp = 0;
1041 1.71 cgd xs->data = va;
1042 1.71 cgd xs->datalen = nwrt * sectorsize;
1043 1.1 cgd
1044 1.25 mycroft /*
1045 1.25 mycroft * Pass all this info to the scsi driver.
1046 1.25 mycroft */
1047 1.25 mycroft retval = (*(sd->sc_link->adapter->scsi_cmd)) (xs);
1048 1.51 mycroft if (retval != COMPLETE)
1049 1.51 mycroft return ENXIO;
1050 1.71 cgd #else /* SD_DUMP_NOT_TRUSTED */
1051 1.71 cgd /* Let's just talk about this first... */
1052 1.71 cgd printf("sd%d: dump addr 0x%x, blk %d\n", unit, va, blkno);
1053 1.71 cgd delay(500 * 1000); /* half a second */
1054 1.71 cgd #endif /* SD_DUMP_NOT_TRUSTED */
1055 1.25 mycroft
1056 1.25 mycroft /* update block count */
1057 1.71 cgd totwrt -= nwrt;
1058 1.71 cgd blkno += nwrt;
1059 1.71 cgd va += sectorsize * nwrt;
1060 1.25 mycroft }
1061 1.71 cgd sddoingadump = 0;
1062 1.25 mycroft return 0;
1063 1.1 cgd }
1064 1.71 cgd #else /* __BDEVSW_DUMP_NEW_TYPE */
1065 1.25 mycroft int
1066 1.71 cgd sddump(dev, blkno, va, size)
1067 1.71 cgd dev_t dev;
1068 1.71 cgd daddr_t blkno;
1069 1.71 cgd caddr_t va;
1070 1.71 cgd size_t size;
1071 1.1 cgd {
1072 1.71 cgd
1073 1.71 cgd /* Not implemented. */
1074 1.71 cgd return ENXIO;
1075 1.1 cgd }
1076 1.71 cgd #endif /* __BDEVSW_DUMP_NEW_TYPE */
1077