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