?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel/nata: Misc cleanup in non chipset codes.
[dragonfly.git] / sys / dev / disk / nata / ata-raid.c
blob4ddb80b6b4a1826c47e953493a88c23789fb2f9c
1 /*-
2 * Copyright (c) 2000 - 2008 Søren Schmidt <sos@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer,
10 * without modification, immediately at the beginning of the file.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 * $FreeBSD: src/sys/dev/ata/ata-raid.c,v 1.120 2006/04/15 10:27:41 maxim Exp $
27 */
28
29 #include "opt_ata.h"
30
31 #include <sys/param.h>
32 #include <sys/bio.h>
33 #include <sys/buf.h>
34 #include <sys/buf2.h>
35 #include <sys/bus.h>
36 #include <sys/conf.h>
37 #include <sys/device.h>
38 #include <sys/devicestat.h>
39 #include <sys/disk.h>
40 #include <sys/endian.h>
41 #include <sys/libkern.h>
42 #include <sys/malloc.h>
43 #include <sys/lock.h>
44 #include <sys/module.h>
45 #include <sys/nata.h>
46 #include <sys/systm.h>
47
48 #include <vm/pmap.h>
49
50 #include <machine/md_var.h>
51
52 #include <bus/pci/pcivar.h>
53
54 #include "ata-all.h"
55 #include "ata-disk.h"
56 #include "ata-raid.h"
57 #include "ata-pci.h"
58 #include "ata_if.h"
59
60 /* local implementation, to trigger a warning */
61 static inline void
62 biofinish(struct bio *bp, struct bio *x __unused, int error)
63 {
64 struct buf *bbp = bp->bio_buf;
65
66 bbp->b_flags |= B_ERROR;
67 bbp->b_error = error;
68 biodone(bp);
69 }
70
71 /* device structure */
72 static d_strategy_t ata_raid_strategy;
73 static d_dump_t ata_raid_dump;
74 static struct dev_ops ar_ops = {
75 { "ar", 0, D_DISK },
76 .d_open = nullopen,
77 .d_close = nullclose,
78 .d_read = physread,
79 .d_write = physwrite,
80 .d_strategy = ata_raid_strategy,
81 .d_dump = ata_raid_dump,
82 };
83
84 /* prototypes */
85 static void ata_raid_done(struct ata_request *request);
86 static void ata_raid_config_changed(struct ar_softc *rdp, int writeback);
87 static int ata_raid_status(struct ata_ioc_raid_status *status);
88 static int ata_raid_create(struct ata_ioc_raid_config *config);
89 static int ata_raid_delete(int array);
90 static int ata_raid_addspare(struct ata_ioc_raid_config *config);
91 static int ata_raid_rebuild(int array);
92 static int ata_raid_read_metadata(device_t subdisk);
93 static int ata_raid_write_metadata(struct ar_softc *rdp);
94 static int ata_raid_wipe_metadata(struct ar_softc *rdp);
95 static int ata_raid_adaptec_read_meta(device_t dev, struct ar_softc **raidp);
96 static int ata_raid_hptv2_read_meta(device_t dev, struct ar_softc **raidp);
97 static int ata_raid_hptv2_write_meta(struct ar_softc *rdp);
98 static int ata_raid_hptv3_read_meta(device_t dev, struct ar_softc **raidp);
99 static int ata_raid_intel_read_meta(device_t dev, struct ar_softc **raidp);
100 static int ata_raid_intel_write_meta(struct ar_softc *rdp);
101 static int ata_raid_ite_read_meta(device_t dev, struct ar_softc **raidp);
102 static int ata_raid_jmicron_read_meta(device_t dev, struct ar_softc **raidp);
103 static int ata_raid_jmicron_write_meta(struct ar_softc *rdp);
104 static int ata_raid_lsiv2_read_meta(device_t dev, struct ar_softc **raidp);
105 static int ata_raid_lsiv3_read_meta(device_t dev, struct ar_softc **raidp);
106 static int ata_raid_nvidia_read_meta(device_t dev, struct ar_softc **raidp);
107 static int ata_raid_promise_read_meta(device_t dev, struct ar_softc **raidp, int native);
108 static int ata_raid_promise_write_meta(struct ar_softc *rdp);
109 static int ata_raid_sii_read_meta(device_t dev, struct ar_softc **raidp);
110 static int ata_raid_sis_read_meta(device_t dev, struct ar_softc **raidp);
111 static int ata_raid_sis_write_meta(struct ar_softc *rdp);
112 static int ata_raid_via_read_meta(device_t dev, struct ar_softc **raidp);
113 static int ata_raid_via_write_meta(struct ar_softc *rdp);
114 static struct ata_request *ata_raid_init_request(struct ar_softc *rdp, struct bio *bio);
115 static int ata_raid_send_request(struct ata_request *request);
116 static int ata_raid_rw(device_t dev, u_int64_t lba, void *data, u_int bcount, int flags);
117 static char * ata_raid_format(struct ar_softc *rdp);
118 static char * ata_raid_type(struct ar_softc *rdp);
119 static char * ata_raid_flags(struct ar_softc *rdp);
120
121 /* debugging only */
122 static void ata_raid_print_meta(struct ar_softc *meta);
123 static void ata_raid_adaptec_print_meta(struct adaptec_raid_conf *meta);
124 static void ata_raid_hptv2_print_meta(struct hptv2_raid_conf *meta);
125 static void ata_raid_hptv3_print_meta(struct hptv3_raid_conf *meta);
126 static void ata_raid_intel_print_meta(struct intel_raid_conf *meta);
127 static void ata_raid_ite_print_meta(struct ite_raid_conf *meta);
128 static void ata_raid_jmicron_print_meta(struct jmicron_raid_conf *meta);
129 static void ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf *meta);
130 static void ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf *meta);
131 static void ata_raid_nvidia_print_meta(struct nvidia_raid_conf *meta);
132 static void ata_raid_promise_print_meta(struct promise_raid_conf *meta);
133 static void ata_raid_sii_print_meta(struct sii_raid_conf *meta);
134 static void ata_raid_sis_print_meta(struct sis_raid_conf *meta);
135 static void ata_raid_via_print_meta(struct via_raid_conf *meta);
136
137 /* internal vars */
138 static struct ar_softc *ata_raid_arrays[MAX_ARRAYS];
139 static MALLOC_DEFINE(M_AR, "ar_driver", "ATA PseudoRAID driver");
140 static devclass_t ata_raid_sub_devclass;
141 static int testing = 0;
142
143 static void
144 ata_raid_attach(struct ar_softc *rdp, int writeback)
145 {
146 struct disk_info info;
147 cdev_t cdev;
148 char buffer[32];
149 int disk;
150
151 lockinit(&rdp->lock, "ataraidattach", 0, 0);
152 ata_raid_config_changed(rdp, writeback);
153
154 /* sanitize arrays total_size % (width * interleave) == 0 */
155 if (rdp->type == AR_T_RAID0 || rdp->type == AR_T_RAID01 ||
156 rdp->type == AR_T_RAID5) {
157 rdp->total_sectors = (rdp->total_sectors/(rdp->interleave*rdp->width))*
158 (rdp->interleave * rdp->width);
159 ksprintf(buffer, " (stripe %d KB)",
160 (rdp->interleave * DEV_BSIZE) / 1024);
161 }
162 else
163 buffer[0] = '\0';
164
165 devstat_add_entry(&rdp->devstat, "ar", rdp->lun,
166 DEV_BSIZE, DEVSTAT_NO_ORDERED_TAGS,
167 DEVSTAT_TYPE_STORARRAY | DEVSTAT_TYPE_IF_OTHER,
168 DEVSTAT_PRIORITY_ARRAY);
169
170 cdev = disk_create(rdp->lun, &rdp->disk, &ar_ops);
171 cdev->si_drv1 = rdp;
172 cdev->si_iosize_max = 128 * DEV_BSIZE;
173 rdp->cdev = cdev;
174
175 bzero(&info, sizeof(info));
176 info.d_media_blksize = DEV_BSIZE; /* mandatory */
177 info.d_media_blocks = rdp->total_sectors;
178
179 info.d_secpertrack = rdp->sectors; /* optional */
180 info.d_nheads = rdp->heads;
181 info.d_ncylinders = rdp->total_sectors/(rdp->heads*rdp->sectors);
182 info.d_secpercyl = rdp->sectors * rdp->heads;
183
184 kprintf("ar%d: %juMB <%s %s%s> status: %s\n", rdp->lun,
185 rdp->total_sectors / ((1024L * 1024L) / DEV_BSIZE),
186 ata_raid_format(rdp), ata_raid_type(rdp),
187 buffer, ata_raid_flags(rdp));
188
189 if (testing || bootverbose)
190 kprintf("ar%d: %ju sectors [%dC/%dH/%dS] <%s> subdisks defined as:\n",
191 rdp->lun, rdp->total_sectors,
192 rdp->cylinders, rdp->heads, rdp->sectors, rdp->name);
193
194 for (disk = 0; disk < rdp->total_disks; disk++) {
195 kprintf("ar%d: disk%d ", rdp->lun, disk);
196 if (rdp->disks[disk].dev) {
197 if (rdp->disks[disk].flags & AR_DF_PRESENT) {
198 /* status of this disk in the array */
199 if (rdp->disks[disk].flags & AR_DF_ONLINE)
200 kprintf("READY ");
201 else if (rdp->disks[disk].flags & AR_DF_SPARE)
202 kprintf("SPARE ");
203 else
204 kprintf("FREE ");
205
206 /* what type of disk is this in the array */
207 switch (rdp->type) {
208 case AR_T_RAID1:
209 case AR_T_RAID01:
210 if (disk < rdp->width)
211 kprintf("(master) ");
212 else
213 kprintf("(mirror) ");
214 }
215
216 /* which physical disk is used */
217 kprintf("using %s at ata%d-%s\n",
218 device_get_nameunit(rdp->disks[disk].dev),
219 device_get_unit(device_get_parent(rdp->disks[disk].dev)),
220 (((struct ata_device *)
221 device_get_softc(rdp->disks[disk].dev))->unit ==
222 ATA_MASTER) ? "master" : "slave");
223 }
224 else if (rdp->disks[disk].flags & AR_DF_ASSIGNED)
225 kprintf("DOWN\n");
226 else
227 kprintf("INVALID no RAID config on this subdisk\n");
228 }
229 else
230 kprintf("DOWN no device found for this subdisk\n");
231 }
232
233 disk_setdiskinfo(&rdp->disk, &info);
234 }
235
236 /*
237 * ATA PseudoRAID ioctl function. Note that this does not need to be adjusted
238 * to the dev_ops way, because it's just chained from the generic ata ioctl.
239 */
240 static int
241 ata_raid_ioctl(u_long cmd, caddr_t data)
242 {
243 struct ata_ioc_raid_status *status = (struct ata_ioc_raid_status *)data;
244 struct ata_ioc_raid_config *config = (struct ata_ioc_raid_config *)data;
245 int *lun = (int *)data;
246 int error = EOPNOTSUPP;
247
248 switch (cmd) {
249 case IOCATARAIDSTATUS:
250 error = ata_raid_status(status);
251 break;
252
253 case IOCATARAIDCREATE:
254 error = ata_raid_create(config);
255 break;
256
257 case IOCATARAIDDELETE:
258 error = ata_raid_delete(*lun);
259 break;
260
261 case IOCATARAIDADDSPARE:
262 error = ata_raid_addspare(config);
263 break;
264
265 case IOCATARAIDREBUILD:
266 error = ata_raid_rebuild(*lun);
267 break;
268 }
269 return error;
270 }
271
272 static int
273 ata_raid_flush(struct ar_softc *rdp, struct bio *bp)
274 {
275 struct ata_request *request;
276 device_t dev;
277 int disk;
278
279 bp->bio_driver_info = NULL;
280
281 for (disk = 0; disk < rdp->total_disks; disk++) {
282 if ((dev = rdp->disks[disk].dev) != NULL)
283 bp->bio_driver_info = (void *)((intptr_t)bp->bio_driver_info + 1);
284 }
285 for (disk = 0; disk < rdp->total_disks; disk++) {
286 if ((dev = rdp->disks[disk].dev) == NULL)
287 continue;
288 if (!(request = ata_raid_init_request(rdp, bp)))
289 return ENOMEM;
290 request->dev = dev;
291 request->u.ata.command = ATA_FLUSHCACHE;
292 request->u.ata.lba = 0;
293 request->u.ata.count = 0;
294 request->u.ata.feature = 0;
295 request->timeout = 1; /* ATA_DEFAULT_TIMEOUT */
296 request->retries = 0;
297 request->flags |= ATA_R_ORDERED | ATA_R_DIRECT;
298 ata_queue_request(request);
299 }
300 return 0;
301 }
302
303 /*
304 * XXX TGEN there are a lot of offset -> block number conversions going on
305 * here, which is suboptimal.
306 */
307 static int
308 ata_raid_strategy(struct dev_strategy_args *ap)
309 {
310 struct ar_softc *rdp = ap->a_head.a_dev->si_drv1;
311 struct bio *bp = ap->a_bio;
312 struct buf *bbp = bp->bio_buf;
313 struct ata_request *request;
314 caddr_t data;
315 u_int64_t blkno, lba, blk = 0;
316 int count, chunk, drv, par = 0, change = 0;
317
318 if (bbp->b_cmd == BUF_CMD_FLUSH) {
319 int error;
320
321 error = ata_raid_flush(rdp, bp);
322 if (error != 0)
323 biofinish(bp, NULL, error);
324 return(0);
325 }
326
327 if (!(rdp->status & AR_S_READY) ||
328 (bbp->b_cmd != BUF_CMD_READ && bbp->b_cmd != BUF_CMD_WRITE)) {
329 biofinish(bp, NULL, EIO);
330 return(0);
331 }
332
333 bbp->b_resid = bbp->b_bcount;
334 for (count = howmany(bbp->b_bcount, DEV_BSIZE),
335 /* bio_offset is byte granularity, convert */
336 blkno = (u_int64_t)(bp->bio_offset >> DEV_BSHIFT),
337 data = bbp->b_data;
338 count > 0;
339 count -= chunk, blkno += chunk, data += (chunk * DEV_BSIZE)) {
340
341 switch (rdp->type) {
342 case AR_T_RAID1:
343 drv = 0;
344 lba = blkno;
345 chunk = count;
346 break;
347
348 case AR_T_JBOD:
349 case AR_T_SPAN:
350 drv = 0;
351 lba = blkno;
352 while (lba >= rdp->disks[drv].sectors)
353 lba -= rdp->disks[drv++].sectors;
354 chunk = min(rdp->disks[drv].sectors - lba, count);
355 break;
356
357 case AR_T_RAID0:
358 case AR_T_RAID01:
359 chunk = blkno % rdp->interleave;
360 drv = (blkno / rdp->interleave) % rdp->width;
361 lba = (((blkno/rdp->interleave)/rdp->width)*rdp->interleave)+chunk;
362 chunk = min(count, rdp->interleave - chunk);
363 break;
364
365 case AR_T_RAID5:
366 drv = (blkno / rdp->interleave) % (rdp->width - 1);
367 par = rdp->width - 1 -
368 (blkno / (rdp->interleave * (rdp->width - 1))) % rdp->width;
369 if (drv >= par)
370 drv++;
371 lba = ((blkno/rdp->interleave)/(rdp->width-1))*(rdp->interleave) +
372 ((blkno%(rdp->interleave*(rdp->width-1)))%rdp->interleave);
373 chunk = min(count, rdp->interleave - (lba % rdp->interleave));
374 break;
375
376 default:
377 kprintf("ar%d: unknown array type in ata_raid_strategy\n", rdp->lun);
378 biofinish(bp, NULL, EIO);
379 return(0);
380 }
381
382 /* offset on all but "first on HPTv2" */
383 if (!(drv == 0 && rdp->format == AR_F_HPTV2_RAID))
384 lba += rdp->offset_sectors;
385
386 if (!(request = ata_raid_init_request(rdp, bp))) {
387 biofinish(bp, NULL, EIO);
388 return(0);
389 }
390 request->data = data;
391 request->bytecount = chunk * DEV_BSIZE;
392 request->u.ata.lba = lba;
393 request->u.ata.count = request->bytecount / DEV_BSIZE;
394
395 devstat_start_transaction(&rdp->devstat);
396 switch (rdp->type) {
397 case AR_T_JBOD:
398 case AR_T_SPAN:
399 case AR_T_RAID0:
400 if (((rdp->disks[drv].flags & (AR_DF_PRESENT|AR_DF_ONLINE)) ==
401 (AR_DF_PRESENT|AR_DF_ONLINE) && !rdp->disks[drv].dev)) {
402 rdp->disks[drv].flags &= ~AR_DF_ONLINE;
403 ata_raid_config_changed(rdp, 1);
404 ata_free_request(request);
405 biofinish(bp, NULL, EIO);
406 return(0);
407 }
408 request->this = drv;
409 request->dev = rdp->disks[request->this].dev;
410 ata_raid_send_request(request);
411 break;
412
413 case AR_T_RAID1:
414 case AR_T_RAID01:
415 if ((rdp->disks[drv].flags &
416 (AR_DF_PRESENT|AR_DF_ONLINE))==(AR_DF_PRESENT|AR_DF_ONLINE) &&
417 !rdp->disks[drv].dev) {
418 rdp->disks[drv].flags &= ~AR_DF_ONLINE;
419 change = 1;
420 }
421 if ((rdp->disks[drv + rdp->width].flags &
422 (AR_DF_PRESENT|AR_DF_ONLINE))==(AR_DF_PRESENT|AR_DF_ONLINE) &&
423 !rdp->disks[drv + rdp->width].dev) {
424 rdp->disks[drv + rdp->width].flags &= ~AR_DF_ONLINE;
425 change = 1;
426 }
427 if (change)
428 ata_raid_config_changed(rdp, 1);
429 if (!(rdp->status & AR_S_READY)) {
430 ata_free_request(request);
431 biofinish(bp, NULL, EIO);
432 return(0);
433 }
434
435 if (rdp->status & AR_S_REBUILDING)
436 blk = ((lba / rdp->interleave) * rdp->width) * rdp->interleave +
437 (rdp->interleave * (drv % rdp->width)) +
438 lba % rdp->interleave;
439
440 if (bbp->b_cmd == BUF_CMD_READ) {
441 int src_online =
442 (rdp->disks[drv].flags & AR_DF_ONLINE);
443 int mir_online =
444 (rdp->disks[drv+rdp->width].flags & AR_DF_ONLINE);
445
446 /* if mirror gone or close to last access on source */
447 if (!mir_online ||
448 ((src_online) &&
449 ((u_int64_t)(bp->bio_offset >> DEV_BSHIFT)) >=
450 (rdp->disks[drv].last_lba - AR_PROXIMITY) &&
451 ((u_int64_t)(bp->bio_offset >> DEV_BSHIFT)) <=
452 (rdp->disks[drv].last_lba + AR_PROXIMITY))) {
453 rdp->toggle = 0;
454 }
455 /* if source gone or close to last access on mirror */
456 else if (!src_online ||
457 ((mir_online) &&
458 ((u_int64_t)(bp->bio_offset >> DEV_BSHIFT)) >=
459 (rdp->disks[drv+rdp->width].last_lba-AR_PROXIMITY) &&
460 ((u_int64_t)(bp->bio_offset >> DEV_BSHIFT)) <=
461 (rdp->disks[drv+rdp->width].last_lba+AR_PROXIMITY))) {
462 drv += rdp->width;
463 rdp->toggle = 1;
464 }
465 /* not close to any previous access, toggle */
466 else {
467 if (rdp->toggle)
468 rdp->toggle = 0;
469 else {
470 drv += rdp->width;
471 rdp->toggle = 1;
472 }
473 }
474
475 if ((rdp->status & AR_S_REBUILDING) &&
476 (blk <= rdp->rebuild_lba) &&
477 ((blk + chunk) > rdp->rebuild_lba)) {
478 struct ata_composite *composite;
479 struct ata_request *rebuild;
480 int this;
481
482 /* figure out what part to rebuild */
483 if (drv < rdp->width)
484 this = drv + rdp->width;
485 else
486 this = drv - rdp->width;
487
488 /* do we have a spare to rebuild on ? */
489 if (rdp->disks[this].flags & AR_DF_SPARE) {
490 if ((composite = ata_alloc_composite())) {
491 if ((rebuild = ata_alloc_request())) {
492 rdp->rebuild_lba = blk + chunk;
493 bcopy(request, rebuild,
494 sizeof(struct ata_request));
495 rebuild->this = this;
496 rebuild->dev = rdp->disks[this].dev;
497 rebuild->flags &= ~ATA_R_READ;
498 rebuild->flags |= ATA_R_WRITE;
499 lockinit(&composite->lock, "ardfspare", 0, 0);
500 composite->residual = request->bytecount;
501 composite->rd_needed |= (1 << drv);
502 composite->wr_depend |= (1 << drv);
503 composite->wr_needed |= (1 << this);
504 composite->request[drv] = request;
505 composite->request[this] = rebuild;
506 request->composite = composite;
507 rebuild->composite = composite;
508 ata_raid_send_request(rebuild);
509 }
510 else {
511 ata_free_composite(composite);
512 kprintf("DOH! ata_alloc_request failed!\n");
513 }
514 }
515 else {
516 kprintf("DOH! ata_alloc_composite failed!\n");
517 }
518 }
519 else if (rdp->disks[this].flags & AR_DF_ONLINE) {
520 /*
521 * if we got here we are a chunk of a RAID01 that
522 * does not need a rebuild, but we need to increment
523 * the rebuild_lba address to get the rebuild to
524 * move to the next chunk correctly
525 */
526 rdp->rebuild_lba = blk + chunk;
527 }
528 else
529 kprintf("DOH! we didn't find the rebuild part\n");
530 }
531 }
532 if (bbp->b_cmd == BUF_CMD_WRITE) {
533 if ((rdp->disks[drv+rdp->width].flags & AR_DF_ONLINE) ||
534 ((rdp->status & AR_S_REBUILDING) &&
535 (rdp->disks[drv+rdp->width].flags & AR_DF_SPARE) &&
536 ((blk < rdp->rebuild_lba) ||
537 ((blk <= rdp->rebuild_lba) &&
538 ((blk + chunk) > rdp->rebuild_lba))))) {
539 if ((rdp->disks[drv].flags & AR_DF_ONLINE) ||
540 ((rdp->status & AR_S_REBUILDING) &&
541 (rdp->disks[drv].flags & AR_DF_SPARE) &&
542 ((blk < rdp->rebuild_lba) ||
543 ((blk <= rdp->rebuild_lba) &&
544 ((blk + chunk) > rdp->rebuild_lba))))) {
545 struct ata_request *mirror;
546 struct ata_composite *composite;
547 int this = drv + rdp->width;
548
549 if ((composite = ata_alloc_composite())) {
550 if ((mirror = ata_alloc_request())) {
551 if ((blk <= rdp->rebuild_lba) &&
552 ((blk + chunk) > rdp->rebuild_lba))
553 rdp->rebuild_lba = blk + chunk;
554 bcopy(request, mirror,
555 sizeof(struct ata_request));
556 mirror->this = this;
557 mirror->dev = rdp->disks[this].dev;
558 lockinit(&composite->lock, "ardfonline", 0, 0);
559 composite->residual = request->bytecount;
560 composite->wr_needed |= (1 << drv);
561 composite->wr_needed |= (1 << this);
562 composite->request[drv] = request;
563 composite->request[this] = mirror;
564 request->composite = composite;
565 mirror->composite = composite;
566 ata_raid_send_request(mirror);
567 rdp->disks[this].last_lba =
568 (u_int64_t)(bp->bio_offset >> DEV_BSHIFT) +
569 chunk;
570 }
571 else {
572 ata_free_composite(composite);
573 kprintf("DOH! ata_alloc_request failed!\n");
574 }
575 }
576 else {
577 kprintf("DOH! ata_alloc_composite failed!\n");
578 }
579 }
580 else
581 drv += rdp->width;
582 }
583 }
584 request->this = drv;
585 request->dev = rdp->disks[request->this].dev;
586 ata_raid_send_request(request);
587 rdp->disks[request->this].last_lba =
588 ((u_int64_t)(bp->bio_offset) >> DEV_BSHIFT) + chunk;
589 break;
590
591 case AR_T_RAID5:
592 if (((rdp->disks[drv].flags & (AR_DF_PRESENT|AR_DF_ONLINE)) ==
593 (AR_DF_PRESENT|AR_DF_ONLINE) && !rdp->disks[drv].dev)) {
594 rdp->disks[drv].flags &= ~AR_DF_ONLINE;
595 change = 1;
596 }
597 if (((rdp->disks[par].flags & (AR_DF_PRESENT|AR_DF_ONLINE)) ==
598 (AR_DF_PRESENT|AR_DF_ONLINE) && !rdp->disks[par].dev)) {
599 rdp->disks[par].flags &= ~AR_DF_ONLINE;
600 change = 1;
601 }
602 if (change)
603 ata_raid_config_changed(rdp, 1);
604 if (!(rdp->status & AR_S_READY)) {
605 ata_free_request(request);
606 biofinish(bp, NULL, EIO);
607 return(0);
608 }
609 if (rdp->status & AR_S_DEGRADED) {
610 /* do the XOR game if possible */
611 }
612 else {
613 request->this = drv;
614 request->dev = rdp->disks[request->this].dev;
615 if (bbp->b_cmd == BUF_CMD_READ) {
616 ata_raid_send_request(request);
617 }
618 if (bbp->b_cmd == BUF_CMD_WRITE) {
619 ata_raid_send_request(request);
620 /*
621 * ensure that read-modify-write to each disk is atomic.
622 * couple of copies of request
623 * read old data data from drv
624 * write new data to drv
625 * read smth-smth data from pairs
626 * write old data xor smth-smth data xor data to pairs
627 */
628 }
629 }
630 break;
631
632 default:
633 kprintf("ar%d: unknown array type in ata_raid_strategy\n", rdp->lun);
634 }
635 }
636
637 return(0);
638 }
639
640 static void
641 ata_raid_done(struct ata_request *request)
642 {
643 struct ar_softc *rdp = request->driver;
644 struct ata_composite *composite = NULL;
645 struct bio *bp = request->bio;
646 struct buf *bbp = bp->bio_buf;
647 int i, mirror, finished = 0;
648
649 if (bbp->b_cmd == BUF_CMD_FLUSH) {
650 if (bbp->b_error == 0)
651 bbp->b_error = request->result;
652 ata_free_request(request);
653 bp->bio_driver_info = (void *)((intptr_t)bp->bio_driver_info - 1);
654 if ((intptr_t)bp->bio_driver_info == 0) {
655 if (bbp->b_error)
656 bbp->b_flags |= B_ERROR;
657 biodone(bp);
658 }
659 return;
660 }
661
662 switch (rdp->type) {
663 case AR_T_JBOD:
664 case AR_T_SPAN:
665 case AR_T_RAID0:
666 if (request->result) {
667 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
668 ata_raid_config_changed(rdp, 1);
669 bbp->b_error = request->result;
670 finished = 1;
671 }
672 else {
673 bbp->b_resid -= request->donecount;
674 if (!bbp->b_resid)
675 finished = 1;
676 }
677 break;
678
679 case AR_T_RAID1:
680 case AR_T_RAID01:
681 if (request->this < rdp->width)
682 mirror = request->this + rdp->width;
683 else
684 mirror = request->this - rdp->width;
685 if (request->result) {
686 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
687 ata_raid_config_changed(rdp, 1);
688 }
689 if (rdp->status & AR_S_READY) {
690 u_int64_t blk = 0;
691
692 if (rdp->status & AR_S_REBUILDING)
693 blk = ((request->u.ata.lba / rdp->interleave) * rdp->width) *
694 rdp->interleave + (rdp->interleave *
695 (request->this % rdp->width)) +
696 request->u.ata.lba % rdp->interleave;
697
698 if (bbp->b_cmd == BUF_CMD_READ) {
699
700 /* is this a rebuild composite */
701 if ((composite = request->composite)) {
702 lockmgr(&composite->lock, LK_EXCLUSIVE);
703
704 /* handle the read part of a rebuild composite */
705 if (request->flags & ATA_R_READ) {
706
707 /* if read failed array is now broken */
708 if (request->result) {
709 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
710 ata_raid_config_changed(rdp, 1);
711 bbp->b_error = request->result;
712 rdp->rebuild_lba = blk;
713 finished = 1;
714 }
715
716 /* good data, update how far we've gotten */
717 else {
718 bbp->b_resid -= request->donecount;
719 composite->residual -= request->donecount;
720 if (!composite->residual) {
721 if (composite->wr_done & (1 << mirror))
722 finished = 1;
723 }
724 }
725 }
726
727 /* handle the write part of a rebuild composite */
728 else if (request->flags & ATA_R_WRITE) {
729 if (composite->rd_done & (1 << mirror)) {
730 if (request->result) {
731 kprintf("DOH! rebuild failed\n"); /* XXX SOS */
732 rdp->rebuild_lba = blk;
733 }
734 if (!composite->residual)
735 finished = 1;
736 }
737 }
738 lockmgr(&composite->lock, LK_RELEASE);
739 }
740
741 /* if read failed retry on the mirror */
742 else if (request->result) {
743 request->dev = rdp->disks[mirror].dev;
744 request->flags &= ~ATA_R_TIMEOUT;
745 ata_raid_send_request(request);
746 return;
747 }
748
749 /* we have good data */
750 else {
751 bbp->b_resid -= request->donecount;
752 if (!bbp->b_resid)
753 finished = 1;
754 }
755 }
756 else if (bbp->b_cmd == BUF_CMD_WRITE) {
757 /* do we have a mirror or rebuild to deal with ? */
758 if ((composite = request->composite)) {
759 lockmgr(&composite->lock, LK_EXCLUSIVE);
760 if (composite->wr_done & (1 << mirror)) {
761 if (request->result) {
762 if (composite->request[mirror]->result) {
763 kprintf("DOH! all disks failed and got here\n");
764 bbp->b_error = EIO;
765 }
766 if (rdp->status & AR_S_REBUILDING) {
767 rdp->rebuild_lba = blk;
768 kprintf("DOH! rebuild failed\n"); /* XXX SOS */
769 }
770 bbp->b_resid -=
771 composite->request[mirror]->donecount;
772 composite->residual -=
773 composite->request[mirror]->donecount;
774 }
775 else {
776 bbp->b_resid -= request->donecount;
777 composite->residual -= request->donecount;
778 }
779 if (!composite->residual)
780 finished = 1;
781 }
782 lockmgr(&composite->lock, LK_RELEASE);
783 }
784 /* no mirror we are done */
785 else {
786 bbp->b_resid -= request->donecount;
787 if (!bbp->b_resid)
788 finished = 1;
789 }
790 }
791 }
792 else {
793 /* XXX TGEN bbp->b_flags |= B_ERROR; */
794 bbp->b_error = request->result;
795 biodone(bp);
796 }
797 break;
798
799 case AR_T_RAID5:
800 if (request->result) {
801 rdp->disks[request->this].flags &= ~AR_DF_ONLINE;
802 ata_raid_config_changed(rdp, 1);
803 if (rdp->status & AR_S_READY) {
804 if (bbp->b_cmd == BUF_CMD_READ) {
805 /* do the XOR game to recover data */
806 }
807 if (bbp->b_cmd == BUF_CMD_WRITE) {
808 /* if the parity failed we're OK sortof */
809 /* otherwise wee need to do the XOR long dance */
810 }
811 finished = 1;
812 }
813 else {
814 /* XXX TGEN bbp->b_flags |= B_ERROR; */
815 bbp->b_error = request->result;
816 biodone(bp);
817 }
818 }
819 else {
820 /* did we have an XOR game going ?? */
821 bbp->b_resid -= request->donecount;
822 if (!bbp->b_resid)
823 finished = 1;
824 }
825 break;
826
827 default:
828 kprintf("ar%d: unknown array type in ata_raid_done\n", rdp->lun);
829 }
830
831 if (finished) {
832 if ((rdp->status & AR_S_REBUILDING) &&
833 rdp->rebuild_lba >= rdp->total_sectors) {
834 int disk;
835
836 for (disk = 0; disk < rdp->total_disks; disk++) {
837 if ((rdp->disks[disk].flags &
838 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE)) ==
839 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE)) {
840 rdp->disks[disk].flags &= ~AR_DF_SPARE;
841 rdp->disks[disk].flags |= AR_DF_ONLINE;
842 }
843 }
844 rdp->status &= ~AR_S_REBUILDING;
845 ata_raid_config_changed(rdp, 1);
846 }
847 devstat_end_transaction_buf(&rdp->devstat, bbp);
848 if (!bbp->b_resid)
849 biodone(bp);
850 }
851
852 if (composite) {
853 if (finished) {
854 /* we are done with this composite, free all resources */
855 for (i = 0; i < 32; i++) {
856 if (composite->rd_needed & (1 << i) ||
857 composite->wr_needed & (1 << i)) {
858 ata_free_request(composite->request[i]);
859 }
860 }
861 lockuninit(&composite->lock);
862 ata_free_composite(composite);
863 }
864 }
865 else
866 ata_free_request(request);
867 }
868
869 static int
870 ata_raid_dump(struct dev_dump_args *ap)
871 {
872 struct ar_softc *rdp = ap->a_head.a_dev->si_drv1;
873 struct buf dbuf;
874 int error = 0;
875 int disk;
876
877 if (ap->a_length == 0) {
878 /* flush subdisk buffers to media */
879 for (disk = 0, error = 0; disk < rdp->total_disks; disk++) {
880 if (rdp->disks[disk].dev) {
881 error |= ata_controlcmd(rdp->disks[disk].dev,
882 ATA_FLUSHCACHE, 0, 0, 0);
883 }
884 }
885 return (error ? EIO : 0);
886 }
887
888 bzero(&dbuf, sizeof(struct buf));
889 initbufbio(&dbuf);
890 BUF_LOCK(&dbuf, LK_EXCLUSIVE);
891 /* bio_offset is byte granularity, convert block granularity a_blkno */
892 dbuf.b_bio1.bio_offset = ap->a_offset;
893 dbuf.b_bio1.bio_caller_info1.ptr = (void *)rdp;
894 dbuf.b_bio1.bio_flags |= BIO_SYNC;
895 dbuf.b_bio1.bio_done = biodone_sync;
896 dbuf.b_bcount = ap->a_length;
897 dbuf.b_data = ap->a_virtual;
898 dbuf.b_cmd = BUF_CMD_WRITE;
899 dev_dstrategy(rdp->cdev, &dbuf.b_bio1);
900 /* wait for completion, unlock the buffer, check status */
901 if (biowait(&dbuf.b_bio1, "dumpw")) {
902 BUF_UNLOCK(&dbuf);
903 return(dbuf.b_error ? dbuf.b_error : EIO);
904 }
905 BUF_UNLOCK(&dbuf);
906 uninitbufbio(&dbuf);
907
908 return 0;
909 }
910
911 static void
912 ata_raid_config_changed(struct ar_softc *rdp, int writeback)
913 {
914 int disk, count, status;
915
916 lockmgr(&rdp->lock, LK_EXCLUSIVE);
917
918 /* set default all working mode */
919 status = rdp->status;
920 rdp->status &= ~AR_S_DEGRADED;
921 rdp->status |= AR_S_READY;
922
923 /* make sure all lost drives are accounted for */
924 for (disk = 0; disk < rdp->total_disks; disk++) {
925 if (!(rdp->disks[disk].flags & AR_DF_PRESENT))
926 rdp->disks[disk].flags &= ~AR_DF_ONLINE;
927 }
928
929 /* depending on RAID type figure out our health status */
930 switch (rdp->type) {
931 case AR_T_JBOD:
932 case AR_T_SPAN:
933 case AR_T_RAID0:
934 for (disk = 0; disk < rdp->total_disks; disk++)
935 if (!(rdp->disks[disk].flags & AR_DF_ONLINE))
936 rdp->status &= ~AR_S_READY;
937 break;
938
939 case AR_T_RAID1:
940 case AR_T_RAID01:
941 for (disk = 0; disk < rdp->width; disk++) {
942 if (!(rdp->disks[disk].flags & AR_DF_ONLINE) &&
943 !(rdp->disks[disk + rdp->width].flags & AR_DF_ONLINE)) {
944 rdp->status &= ~AR_S_READY;
945 }
946 else if (((rdp->disks[disk].flags & AR_DF_ONLINE) &&
947 !(rdp->disks[disk + rdp->width].flags & AR_DF_ONLINE)) ||
948 (!(rdp->disks[disk].flags & AR_DF_ONLINE) &&
949 (rdp->disks [disk + rdp->width].flags & AR_DF_ONLINE))) {
950 rdp->status |= AR_S_DEGRADED;
951 }
952 }
953 break;
954
955 case AR_T_RAID5:
956 for (count = 0, disk = 0; disk < rdp->total_disks; disk++) {
957 if (!(rdp->disks[disk].flags & AR_DF_ONLINE))
958 count++;
959 }
960 if (count) {
961 if (count > 1)
962 rdp->status &= ~AR_S_READY;
963 else
964 rdp->status |= AR_S_DEGRADED;
965 }
966 break;
967 default:
968 rdp->status &= ~AR_S_READY;
969 }
970
971 /*
972 * Note that when the array breaks so comes up broken we
973 * force a write of the array config to the remaining
974 * drives so that the generation will be incremented past
975 * those of the missing or failed drives (in all cases).
976 */
977 if (rdp->status != status) {
978
979 /* raid status has changed, update metadata */
980 writeback = 1;
981
982 /* announce we have trouble ahead */
983 if (!(rdp->status & AR_S_READY)) {
984 kprintf("ar%d: FAILURE - %s array broken\n",
985 rdp->lun, ata_raid_type(rdp));
986 }
987 else if (rdp->status & AR_S_DEGRADED) {
988 if (rdp->type & (AR_T_RAID1 | AR_T_RAID01))
989 kprintf("ar%d: WARNING - mirror", rdp->lun);
990 else
991 kprintf("ar%d: WARNING - parity", rdp->lun);
992 kprintf(" protection lost. %s array in DEGRADED mode\n",
993 ata_raid_type(rdp));
994 }
995 }
996 lockmgr(&rdp->lock, LK_RELEASE);
997 if (writeback)
998 ata_raid_write_metadata(rdp);
999
1000 }
1001
1002 static int
1003 ata_raid_status(struct ata_ioc_raid_status *status)
1004 {
1005 struct ar_softc *rdp;
1006 int i;
1007
1008 if (!(rdp = ata_raid_arrays[status->lun]))
1009 return ENXIO;
1010
1011 status->type = rdp->type;
1012 status->total_disks = rdp->total_disks;
1013 for (i = 0; i < rdp->total_disks; i++ ) {
1014 status->disks[i].state = 0;
1015 if ((rdp->disks[i].flags & AR_DF_PRESENT) && rdp->disks[i].dev) {
1016 status->disks[i].lun = device_get_unit(rdp->disks[i].dev);
1017 if (rdp->disks[i].flags & AR_DF_PRESENT)
1018 status->disks[i].state |= AR_DISK_PRESENT;
1019 if (rdp->disks[i].flags & AR_DF_ONLINE)
1020 status->disks[i].state |= AR_DISK_ONLINE;
1021 if (rdp->disks[i].flags & AR_DF_SPARE)
1022 status->disks[i].state |= AR_DISK_SPARE;
1023 } else
1024 status->disks[i].lun = -1;
1025 }
1026 status->interleave = rdp->interleave;
1027 status->status = rdp->status;
1028 status->progress = 100 * rdp->rebuild_lba / rdp->total_sectors;
1029 return 0;
1030 }
1031
1032 static int
1033 ata_raid_create(struct ata_ioc_raid_config *config)
1034 {
1035 struct ar_softc *rdp;
1036 device_t subdisk;
1037 int array, disk;
1038 int ctlr = 0, total_disks = 0;
1039 u_int disk_size = 0;
1040
1041 for (array = 0; array < MAX_ARRAYS; array++) {
1042 if (!ata_raid_arrays[array])
1043 break;
1044 }
1045 if (array >= MAX_ARRAYS)
1046 return ENOSPC;
1047
1048 rdp = (struct ar_softc*)kmalloc(sizeof(struct ar_softc), M_AR,
1049 M_WAITOK | M_ZERO);
1050
1051 for (disk = 0; disk < config->total_disks; disk++) {
1052 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
1053 config->disks[disk]))) {
1054 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
1055
1056 /* is device already assigned to another array ? */
1057 if (ars->raid[rdp->volume]) {
1058 config->disks[disk] = -1;
1059 kfree(rdp, M_AR);
1060 return EBUSY;
1061 }
1062 rdp->disks[disk].dev = device_get_parent(subdisk);
1063
1064 switch (pci_get_vendor(GRANDPARENT(rdp->disks[disk].dev))) {
1065 case ATA_HIGHPOINT_ID:
1066 /*
1067 * we need some way to decide if it should be v2 or v3
1068 * for now just use v2 since the v3 BIOS knows how to
1069 * handle that as well.
1070 */
1071 ctlr = AR_F_HPTV2_RAID;
1072 rdp->disks[disk].sectors = HPTV3_LBA(rdp->disks[disk].dev);
1073 break;
1074
1075 case ATA_INTEL_ID:
1076 ctlr = AR_F_INTEL_RAID;
1077 rdp->disks[disk].sectors = INTEL_LBA(rdp->disks[disk].dev);
1078 break;
1079
1080 case ATA_ITE_ID:
1081 ctlr = AR_F_ITE_RAID;
1082 rdp->disks[disk].sectors = ITE_LBA(rdp->disks[disk].dev);
1083 break;
1084
1085 case ATA_JMICRON_ID:
1086 ctlr = AR_F_JMICRON_RAID;
1087 rdp->disks[disk].sectors = JMICRON_LBA(rdp->disks[disk].dev);
1088 break;
1089
1090 case 0: /* XXX SOS cover up for bug in our PCI code */
1091 case ATA_PROMISE_ID:
1092 ctlr = AR_F_PROMISE_RAID;
1093 rdp->disks[disk].sectors = PROMISE_LBA(rdp->disks[disk].dev);
1094 break;
1095
1096 case ATA_SIS_ID:
1097 ctlr = AR_F_SIS_RAID;
1098 rdp->disks[disk].sectors = SIS_LBA(rdp->disks[disk].dev);
1099 break;
1100
1101 case ATA_ATI_ID:
1102 case ATA_VIA_ID:
1103 ctlr = AR_F_VIA_RAID;
1104 rdp->disks[disk].sectors = VIA_LBA(rdp->disks[disk].dev);
1105 break;
1106
1107 default:
1108 /* XXX SOS
1109 * right, so here we are, we have an ATA chip and we want
1110 * to create a RAID and store the metadata.
1111 * we need to find a way to tell what kind of metadata this
1112 * hardware's BIOS might be using (good ideas are welcomed)
1113 * for now we just use our own native FreeBSD format.
1114 * the only way to get support for the BIOS format is to
1115 * setup the RAID from there, in that case we pickup the
1116 * metadata format from the disks (if we support it).
1117 */
1118 kprintf("WARNING!! - not able to determine metadata format\n"
1119 "WARNING!! - Using FreeBSD PseudoRAID metadata\n"
1120 "If that is not what you want, use the BIOS to "
1121 "create the array\n");
1122 ctlr = AR_F_FREEBSD_RAID;
1123 rdp->disks[disk].sectors = PROMISE_LBA(rdp->disks[disk].dev);
1124 break;
1125 }
1126
1127 /* we need all disks to be of the same format */
1128 if ((rdp->format & AR_F_FORMAT_MASK) &&
1129 (rdp->format & AR_F_FORMAT_MASK) != (ctlr & AR_F_FORMAT_MASK)) {
1130 kfree(rdp, M_AR);
1131 return EXDEV;
1132 }
1133 else
1134 rdp->format = ctlr;
1135
1136 /* use the smallest disk of the lots size */
1137 /* gigabyte boundry ??? XXX SOS */
1138 if (disk_size)
1139 disk_size = min(rdp->disks[disk].sectors, disk_size);
1140 else
1141 disk_size = rdp->disks[disk].sectors;
1142 rdp->disks[disk].flags =
1143 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
1144
1145 total_disks++;
1146 }
1147 else {
1148 config->disks[disk] = -1;
1149 kfree(rdp, M_AR);
1150 return ENXIO;
1151 }
1152 }
1153
1154 if (total_disks != config->total_disks) {
1155 kfree(rdp, M_AR);
1156 return ENODEV;
1157 }
1158
1159 switch (config->type) {
1160 case AR_T_JBOD:
1161 case AR_T_SPAN:
1162 case AR_T_RAID0:
1163 break;
1164
1165 case AR_T_RAID1:
1166 if (total_disks != 2) {
1167 kfree(rdp, M_AR);
1168 return EPERM;
1169 }
1170 break;
1171
1172 case AR_T_RAID01:
1173 if (total_disks % 2 != 0) {
1174 kfree(rdp, M_AR);
1175 return EPERM;
1176 }
1177 break;
1178
1179 case AR_T_RAID5:
1180 if (total_disks < 3) {
1181 kfree(rdp, M_AR);
1182 return EPERM;
1183 }
1184 break;
1185
1186 default:
1187 kfree(rdp, M_AR);
1188 return EOPNOTSUPP;
1189 }
1190 rdp->type = config->type;
1191 rdp->lun = array;
1192 if (rdp->type == AR_T_RAID0 || rdp->type == AR_T_RAID01 ||
1193 rdp->type == AR_T_RAID5) {
1194 int bit = 0;
1195
1196 while (config->interleave >>= 1)
1197 bit++;
1198 rdp->interleave = 1 << bit;
1199 }
1200 rdp->offset_sectors = 0;
1201
1202 /* values that depend on metadata format */
1203 switch (rdp->format) {
1204 case AR_F_ADAPTEC_RAID:
1205 rdp->interleave = min(max(32, rdp->interleave), 128); /*+*/
1206 break;
1207
1208 case AR_F_HPTV2_RAID:
1209 rdp->interleave = min(max(8, rdp->interleave), 128); /*+*/
1210 rdp->offset_sectors = HPTV2_LBA(x) + 1;
1211 break;
1212
1213 case AR_F_HPTV3_RAID:
1214 rdp->interleave = min(max(32, rdp->interleave), 4096); /*+*/
1215 break;
1216
1217 case AR_F_INTEL_RAID:
1218 rdp->interleave = min(max(8, rdp->interleave), 256); /*+*/
1219 break;
1220
1221 case AR_F_ITE_RAID:
1222 rdp->interleave = min(max(2, rdp->interleave), 128); /*+*/
1223 break;
1224
1225 case AR_F_JMICRON_RAID:
1226 rdp->interleave = min(max(8, rdp->interleave), 256); /*+*/
1227 break;
1228
1229 case AR_F_LSIV2_RAID:
1230 rdp->interleave = min(max(2, rdp->interleave), 4096);
1231 break;
1232
1233 case AR_F_LSIV3_RAID:
1234 rdp->interleave = min(max(2, rdp->interleave), 256);
1235 break;
1236
1237 case AR_F_PROMISE_RAID:
1238 rdp->interleave = min(max(2, rdp->interleave), 2048); /*+*/
1239 break;
1240
1241 case AR_F_SII_RAID:
1242 rdp->interleave = min(max(8, rdp->interleave), 256); /*+*/
1243 break;
1244
1245 case AR_F_SIS_RAID:
1246 rdp->interleave = min(max(32, rdp->interleave), 512); /*+*/
1247 break;
1248
1249 case AR_F_VIA_RAID:
1250 rdp->interleave = min(max(8, rdp->interleave), 128); /*+*/
1251 break;
1252 }
1253
1254 rdp->total_disks = total_disks;
1255 rdp->width = total_disks / (rdp->type & (AR_RAID1 | AR_T_RAID01) ? 2 : 1);
1256 rdp->total_sectors =
1257 (uint64_t)disk_size * (rdp->width - (rdp->type == AR_RAID5));
1258 rdp->heads = 255;
1259 rdp->sectors = 63;
1260 rdp->cylinders = rdp->total_sectors / (255 * 63);
1261 rdp->rebuild_lba = 0;
1262 rdp->status |= AR_S_READY;
1263
1264 /* we are committed to this array, grap the subdisks */
1265 for (disk = 0; disk < config->total_disks; disk++) {
1266 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
1267 config->disks[disk]))) {
1268 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
1269
1270 ars->raid[rdp->volume] = rdp;
1271 ars->disk_number[rdp->volume] = disk;
1272 }
1273 }
1274 ata_raid_attach(rdp, 1);
1275 ata_raid_arrays[array] = rdp;
1276 config->lun = array;
1277 return 0;
1278 }
1279
1280 static int
1281 ata_raid_delete(int array)
1282 {
1283 struct ar_softc *rdp;
1284 device_t subdisk;
1285 int disk;
1286
1287 if (!(rdp = ata_raid_arrays[array]))
1288 return ENXIO;
1289
1290 rdp->status &= ~AR_S_READY;
1291 disk_destroy(&rdp->disk);
1292 devstat_remove_entry(&rdp->devstat);
1293
1294 for (disk = 0; disk < rdp->total_disks; disk++) {
1295 if ((rdp->disks[disk].flags & AR_DF_PRESENT) && rdp->disks[disk].dev) {
1296 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
1297 device_get_unit(rdp->disks[disk].dev)))) {
1298 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
1299
1300 if (ars->raid[rdp->volume] != rdp) /* XXX SOS */
1301 device_printf(subdisk, "DOH! this disk doesn't belong\n");
1302 if (ars->disk_number[rdp->volume] != disk) /* XXX SOS */
1303 device_printf(subdisk, "DOH! this disk number is wrong\n");
1304 ars->raid[rdp->volume] = NULL;
1305 ars->disk_number[rdp->volume] = -1;
1306 }
1307 rdp->disks[disk].flags = 0;
1308 }
1309 }
1310 ata_raid_wipe_metadata(rdp);
1311 ata_raid_arrays[array] = NULL;
1312 kfree(rdp, M_AR);
1313 return 0;
1314 }
1315
1316 static int
1317 ata_raid_addspare(struct ata_ioc_raid_config *config)
1318 {
1319 struct ar_softc *rdp;
1320 device_t subdisk;
1321 int disk;
1322
1323 if (!(rdp = ata_raid_arrays[config->lun]))
1324 return ENXIO;
1325 if (!(rdp->status & AR_S_DEGRADED) || !(rdp->status & AR_S_READY))
1326 return ENXIO;
1327 if (rdp->status & AR_S_REBUILDING)
1328 return EBUSY;
1329 switch (rdp->type) {
1330 case AR_T_RAID1:
1331 case AR_T_RAID01:
1332 case AR_T_RAID5:
1333 for (disk = 0; disk < rdp->total_disks; disk++ ) {
1334
1335 if (((rdp->disks[disk].flags & (AR_DF_PRESENT | AR_DF_ONLINE)) ==
1336 (AR_DF_PRESENT | AR_DF_ONLINE)) && rdp->disks[disk].dev)
1337 continue;
1338
1339 if ((subdisk = devclass_get_device(ata_raid_sub_devclass,
1340 config->disks[0] ))) {
1341 struct ata_raid_subdisk *ars = device_get_softc(subdisk);
1342
1343 if (ars->raid[rdp->volume])
1344 return EBUSY;
1345
1346 /* XXX SOS validate size etc etc */
1347 ars->raid[rdp->volume] = rdp;
1348 ars->disk_number[rdp->volume] = disk;
1349 rdp->disks[disk].dev = device_get_parent(subdisk);
1350 rdp->disks[disk].flags =
1351 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE);
1352
1353 device_printf(rdp->disks[disk].dev,
1354 "inserted into ar%d disk%d as spare\n",
1355 rdp->lun, disk);
1356 ata_raid_config_changed(rdp, 1);
1357 return 0;
1358 }
1359 }
1360 return ENXIO;
1361
1362 default:
1363 return EPERM;
1364 }
1365 }
1366
1367 static int
1368 ata_raid_rebuild(int array)
1369 {
1370 struct ar_softc *rdp;
1371 int disk, count;
1372
1373 if (!(rdp = ata_raid_arrays[array]))
1374 return ENXIO;
1375 /* XXX SOS we should lock the rdp softc here */
1376 if (!(rdp->status & AR_S_DEGRADED) || !(rdp->status & AR_S_READY))
1377 return ENXIO;
1378 if (rdp->status & AR_S_REBUILDING)
1379 return EBUSY;
1380
1381 switch (rdp->type) {
1382 case AR_T_RAID1:
1383 case AR_T_RAID01:
1384 case AR_T_RAID5:
1385 for (count = 0, disk = 0; disk < rdp->total_disks; disk++ ) {
1386 if (((rdp->disks[disk].flags &
1387 (AR_DF_PRESENT|AR_DF_ASSIGNED|AR_DF_ONLINE|AR_DF_SPARE)) ==
1388 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_SPARE)) &&
1389 rdp->disks[disk].dev) {
1390 count++;
1391 }
1392 }
1393
1394 if (count) {
1395 rdp->rebuild_lba = 0;
1396 rdp->status |= AR_S_REBUILDING;
1397 return 0;
1398 }
1399 return EIO;
1400
1401 default:
1402 return EPERM;
1403 }
1404 }
1405
1406 static int
1407 ata_raid_read_metadata(device_t subdisk)
1408 {
1409 devclass_t pci_devclass = devclass_find("pci");
1410 devclass_t atapci_devclass = devclass_find("atapci");
1411 devclass_t devclass=device_get_devclass(GRANDPARENT(GRANDPARENT(subdisk)));
1412
1413 /* prioritize vendor native metadata layout if possible */
1414 if (devclass == pci_devclass || devclass == atapci_devclass) {
1415 switch (pci_get_vendor(GRANDPARENT(device_get_parent(subdisk)))) {
1416 case ATA_HIGHPOINT_ID:
1417 if (ata_raid_hptv3_read_meta(subdisk, ata_raid_arrays))
1418 return 0;
1419 if (ata_raid_hptv2_read_meta(subdisk, ata_raid_arrays))
1420 return 0;
1421 break;
1422
1423 case ATA_INTEL_ID:
1424 if (ata_raid_intel_read_meta(subdisk, ata_raid_arrays))
1425 return 0;
1426 break;
1427
1428 case ATA_ITE_ID:
1429 if (ata_raid_ite_read_meta(subdisk, ata_raid_arrays))
1430 return 0;
1431 break;
1432
1433 case ATA_JMICRON_ID:
1434 if (ata_raid_jmicron_read_meta(subdisk, ata_raid_arrays))
1435 return 0;
1436 break;
1437
1438 case ATA_NVIDIA_ID:
1439 if (ata_raid_nvidia_read_meta(subdisk, ata_raid_arrays))
1440 return 0;
1441 break;
1442
1443 case 0: /* XXX SOS cover up for bug in our PCI code */
1444 case ATA_PROMISE_ID:
1445 if (ata_raid_promise_read_meta(subdisk, ata_raid_arrays, 0))
1446 return 0;
1447 break;
1448
1449 case ATA_ATI_ID:
1450 case ATA_SILICON_IMAGE_ID:
1451 if (ata_raid_sii_read_meta(subdisk, ata_raid_arrays))
1452 return 0;
1453 break;
1454
1455 case ATA_SIS_ID:
1456 if (ata_raid_sis_read_meta(subdisk, ata_raid_arrays))
1457 return 0;
1458 break;
1459
1460 case ATA_VIA_ID:
1461 if (ata_raid_via_read_meta(subdisk, ata_raid_arrays))
1462 return 0;
1463 break;
1464 }
1465 }
1466
1467 /* handle controllers that have multiple layout possibilities */
1468 /* NOTE: the order of these are not insignificant */
1469
1470 /* Adaptec HostRAID */
1471 if (ata_raid_adaptec_read_meta(subdisk, ata_raid_arrays))
1472 return 0;
1473
1474 /* LSILogic v3 and v2 */
1475 if (ata_raid_lsiv3_read_meta(subdisk, ata_raid_arrays))
1476 return 0;
1477 if (ata_raid_lsiv2_read_meta(subdisk, ata_raid_arrays))
1478 return 0;
1479
1480 /* if none of the above matched, try FreeBSD native format */
1481 return ata_raid_promise_read_meta(subdisk, ata_raid_arrays, 1);
1482 }
1483
1484 static int
1485 ata_raid_write_metadata(struct ar_softc *rdp)
1486 {
1487 switch (rdp->format) {
1488 case AR_F_FREEBSD_RAID:
1489 case AR_F_PROMISE_RAID:
1490 return ata_raid_promise_write_meta(rdp);
1491
1492 case AR_F_HPTV3_RAID:
1493 case AR_F_HPTV2_RAID:
1494 /*
1495 * always write HPT v2 metadata, the v3 BIOS knows it as well.
1496 * this is handy since we cannot know what version BIOS is on there
1497 */
1498 return ata_raid_hptv2_write_meta(rdp);
1499
1500 case AR_F_INTEL_RAID:
1501 return ata_raid_intel_write_meta(rdp);
1502
1503 case AR_F_JMICRON_RAID:
1504 return ata_raid_jmicron_write_meta(rdp);
1505
1506 case AR_F_SIS_RAID:
1507 return ata_raid_sis_write_meta(rdp);
1508
1509 case AR_F_VIA_RAID:
1510 return ata_raid_via_write_meta(rdp);
1511 #if 0
1512 case AR_F_HPTV3_RAID:
1513 return ata_raid_hptv3_write_meta(rdp);
1514
1515 case AR_F_ADAPTEC_RAID:
1516 return ata_raid_adaptec_write_meta(rdp);
1517
1518 case AR_F_ITE_RAID:
1519 return ata_raid_ite_write_meta(rdp);
1520
1521 case AR_F_LSIV2_RAID:
1522 return ata_raid_lsiv2_write_meta(rdp);
1523
1524 case AR_F_LSIV3_RAID:
1525 return ata_raid_lsiv3_write_meta(rdp);
1526
1527 case AR_F_NVIDIA_RAID:
1528 return ata_raid_nvidia_write_meta(rdp);
1529
1530 case AR_F_SII_RAID:
1531 return ata_raid_sii_write_meta(rdp);
1532
1533 #endif
1534 default:
1535 kprintf("ar%d: writing of %s metadata is NOT supported yet\n",
1536 rdp->lun, ata_raid_format(rdp));
1537 }
1538 return -1;
1539 }
1540
1541 static int
1542 ata_raid_wipe_metadata(struct ar_softc *rdp)
1543 {
1544 int disk, error = 0;
1545 u_int64_t lba;
1546 u_int32_t size;
1547 u_int8_t *meta;
1548
1549 for (disk = 0; disk < rdp->total_disks; disk++) {
1550 if (rdp->disks[disk].dev) {
1551 switch (rdp->format) {
1552 case AR_F_ADAPTEC_RAID:
1553 lba = ADP_LBA(rdp->disks[disk].dev);
1554 size = sizeof(struct adaptec_raid_conf);
1555 break;
1556
1557 case AR_F_HPTV2_RAID:
1558 lba = HPTV2_LBA(rdp->disks[disk].dev);
1559 size = sizeof(struct hptv2_raid_conf);
1560 break;
1561
1562 case AR_F_HPTV3_RAID:
1563 lba = HPTV3_LBA(rdp->disks[disk].dev);
1564 size = sizeof(struct hptv3_raid_conf);
1565 break;
1566
1567 case AR_F_INTEL_RAID:
1568 lba = INTEL_LBA(rdp->disks[disk].dev);
1569 size = 3 * 512; /* XXX SOS */
1570 break;
1571
1572 case AR_F_ITE_RAID:
1573 lba = ITE_LBA(rdp->disks[disk].dev);
1574 size = sizeof(struct ite_raid_conf);
1575 break;
1576
1577 case AR_F_JMICRON_RAID:
1578 lba = JMICRON_LBA(rdp->disks[disk].dev);
1579 size = sizeof(struct jmicron_raid_conf);
1580 break;
1581
1582 case AR_F_LSIV2_RAID:
1583 lba = LSIV2_LBA(rdp->disks[disk].dev);
1584 size = sizeof(struct lsiv2_raid_conf);
1585 break;
1586
1587 case AR_F_LSIV3_RAID:
1588 lba = LSIV3_LBA(rdp->disks[disk].dev);
1589 size = sizeof(struct lsiv3_raid_conf);
1590 break;
1591
1592 case AR_F_NVIDIA_RAID:
1593 lba = NVIDIA_LBA(rdp->disks[disk].dev);
1594 size = sizeof(struct nvidia_raid_conf);
1595 break;
1596
1597 case AR_F_FREEBSD_RAID:
1598 case AR_F_PROMISE_RAID:
1599 lba = PROMISE_LBA(rdp->disks[disk].dev);
1600 size = sizeof(struct promise_raid_conf);
1601 break;
1602
1603 case AR_F_SII_RAID:
1604 lba = SII_LBA(rdp->disks[disk].dev);
1605 size = sizeof(struct sii_raid_conf);
1606 break;
1607
1608 case AR_F_SIS_RAID:
1609 lba = SIS_LBA(rdp->disks[disk].dev);
1610 size = sizeof(struct sis_raid_conf);
1611 break;
1612
1613 case AR_F_VIA_RAID:
1614 lba = VIA_LBA(rdp->disks[disk].dev);
1615 size = sizeof(struct via_raid_conf);
1616 break;
1617
1618 default:
1619 kprintf("ar%d: wiping of %s metadata is NOT supported yet\n",
1620 rdp->lun, ata_raid_format(rdp));
1621 return ENXIO;
1622 }
1623 meta = kmalloc(size, M_AR, M_WAITOK | M_ZERO);
1624 if (ata_raid_rw(rdp->disks[disk].dev, lba, meta, size,
1625 ATA_R_WRITE | ATA_R_DIRECT)) {
1626 device_printf(rdp->disks[disk].dev, "wipe metadata failed\n");
1627 error = EIO;
1628 }
1629 kfree(meta, M_AR);
1630 }
1631 }
1632 return error;
1633 }
1634
1635 /* Adaptec HostRAID Metadata */
1636 static int
1637 ata_raid_adaptec_read_meta(device_t dev, struct ar_softc **raidp)
1638 {
1639 struct ata_raid_subdisk *ars = device_get_softc(dev);
1640 device_t parent = device_get_parent(dev);
1641 struct adaptec_raid_conf *meta;
1642 struct ar_softc *raid;
1643 int array, disk, retval = 0;
1644
1645 meta = (struct adaptec_raid_conf *)
1646 kmalloc(sizeof(struct adaptec_raid_conf), M_AR, M_WAITOK | M_ZERO);
1647
1648 if (ata_raid_rw(parent, ADP_LBA(parent),
1649 meta, sizeof(struct adaptec_raid_conf), ATA_R_READ)) {
1650 if (testing || bootverbose)
1651 device_printf(parent, "Adaptec read metadata failed\n");
1652 goto adaptec_out;
1653 }
1654
1655 /* check if this is a Adaptec RAID struct */
1656 if (meta->magic_0 != ADP_MAGIC_0 || meta->magic_3 != ADP_MAGIC_3) {
1657 if (testing || bootverbose)
1658 device_printf(parent, "Adaptec check1 failed\n");
1659 goto adaptec_out;
1660 }
1661
1662 if (testing || bootverbose)
1663 ata_raid_adaptec_print_meta(meta);
1664
1665 /* now convert Adaptec metadata into our generic form */
1666 for (array = 0; array < MAX_ARRAYS; array++) {
1667 if (!raidp[array]) {
1668 raidp[array] =
1669 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
1670 M_WAITOK | M_ZERO);
1671 }
1672 raid = raidp[array];
1673 if (raid->format && (raid->format != AR_F_ADAPTEC_RAID))
1674 continue;
1675
1676 if (raid->magic_0 && raid->magic_0 != meta->configs[0].magic_0)
1677 continue;
1678
1679 if (!meta->generation || be32toh(meta->generation) > raid->generation) {
1680 switch (meta->configs[0].type) {
1681 case ADP_T_RAID0:
1682 raid->magic_0 = meta->configs[0].magic_0;
1683 raid->type = AR_T_RAID0;
1684 raid->interleave = 1 << (meta->configs[0].stripe_shift >> 1);
1685 raid->width = be16toh(meta->configs[0].total_disks);
1686 break;
1687
1688 case ADP_T_RAID1:
1689 raid->magic_0 = meta->configs[0].magic_0;
1690 raid->type = AR_T_RAID1;
1691 raid->width = be16toh(meta->configs[0].total_disks) / 2;
1692 break;
1693
1694 default:
1695 device_printf(parent, "Adaptec unknown RAID type 0x%02x\n",
1696 meta->configs[0].type);
1697 kfree(raidp[array], M_AR);
1698 raidp[array] = NULL;
1699 goto adaptec_out;
1700 }
1701
1702 raid->format = AR_F_ADAPTEC_RAID;
1703 raid->generation = be32toh(meta->generation);
1704 raid->total_disks = be16toh(meta->configs[0].total_disks);
1705 raid->total_sectors = be32toh(meta->configs[0].sectors);
1706 raid->heads = 255;
1707 raid->sectors = 63;
1708 raid->cylinders = raid->total_sectors / (63 * 255);
1709 raid->offset_sectors = 0;
1710 raid->rebuild_lba = 0;
1711 raid->lun = array;
1712 strncpy(raid->name, meta->configs[0].name,
1713 min(sizeof(raid->name), sizeof(meta->configs[0].name)));
1714
1715 /* clear out any old info */
1716 if (raid->generation) {
1717 for (disk = 0; disk < raid->total_disks; disk++) {
1718 raid->disks[disk].dev = NULL;
1719 raid->disks[disk].flags = 0;
1720 }
1721 }
1722 }
1723 if (be32toh(meta->generation) >= raid->generation) {
1724 struct ata_device *atadev = device_get_softc(parent);
1725 struct ata_channel *ch = device_get_softc(GRANDPARENT(dev));
1726 int disk_number = (ch->unit << !(ch->flags & ATA_NO_SLAVE)) +
1727 ATA_DEV(atadev->unit);
1728
1729 raid->disks[disk_number].dev = parent;
1730 raid->disks[disk_number].sectors =
1731 be32toh(meta->configs[disk_number + 1].sectors);
1732 raid->disks[disk_number].flags =
1733 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
1734 ars->raid[raid->volume] = raid;
1735 ars->disk_number[raid->volume] = disk_number;
1736 retval = 1;
1737 }
1738 break;
1739 }
1740
1741 adaptec_out:
1742 kfree(meta, M_AR);
1743 return retval;
1744 }
1745
1746 /* Highpoint V2 RocketRAID Metadata */
1747 static int
1748 ata_raid_hptv2_read_meta(device_t dev, struct ar_softc **raidp)
1749 {
1750 struct ata_raid_subdisk *ars = device_get_softc(dev);
1751 device_t parent = device_get_parent(dev);
1752 struct hptv2_raid_conf *meta;
1753 struct ar_softc *raid = NULL;
1754 int array, disk_number = 0, retval = 0;
1755
1756 meta = (struct hptv2_raid_conf *)kmalloc(sizeof(struct hptv2_raid_conf),
1757 M_AR, M_WAITOK | M_ZERO);
1758
1759 if (ata_raid_rw(parent, HPTV2_LBA(parent),
1760 meta, sizeof(struct hptv2_raid_conf), ATA_R_READ)) {
1761 if (testing || bootverbose)
1762 device_printf(parent, "HighPoint (v2) read metadata failed\n");
1763 goto hptv2_out;
1764 }
1765
1766 /* check if this is a HighPoint v2 RAID struct */
1767 if (meta->magic != HPTV2_MAGIC_OK && meta->magic != HPTV2_MAGIC_BAD) {
1768 if (testing || bootverbose)
1769 device_printf(parent, "HighPoint (v2) check1 failed\n");
1770 goto hptv2_out;
1771 }
1772
1773 /* is this disk defined, or an old leftover/spare ? */
1774 if (!meta->magic_0) {
1775 if (testing || bootverbose)
1776 device_printf(parent, "HighPoint (v2) check2 failed\n");
1777 goto hptv2_out;
1778 }
1779
1780 if (testing || bootverbose)
1781 ata_raid_hptv2_print_meta(meta);
1782
1783 /* now convert HighPoint (v2) metadata into our generic form */
1784 for (array = 0; array < MAX_ARRAYS; array++) {
1785 if (!raidp[array]) {
1786 raidp[array] =
1787 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
1788 M_WAITOK | M_ZERO);
1789 }
1790 raid = raidp[array];
1791 if (raid->format && (raid->format != AR_F_HPTV2_RAID))
1792 continue;
1793
1794 switch (meta->type) {
1795 case HPTV2_T_RAID0:
1796 if ((meta->order & (HPTV2_O_RAID0|HPTV2_O_OK)) ==
1797 (HPTV2_O_RAID0|HPTV2_O_OK))
1798 goto highpoint_raid1;
1799 if (meta->order & (HPTV2_O_RAID0 | HPTV2_O_RAID1))
1800 goto highpoint_raid01;
1801 if (raid->magic_0 && raid->magic_0 != meta->magic_0)
1802 continue;
1803 raid->magic_0 = meta->magic_0;
1804 raid->type = AR_T_RAID0;
1805 raid->interleave = 1 << meta->stripe_shift;
1806 disk_number = meta->disk_number;
1807 if (!(meta->order & HPTV2_O_OK))
1808 meta->magic = 0; /* mark bad */
1809 break;
1810
1811 case HPTV2_T_RAID1:
1812 highpoint_raid1:
1813 if (raid->magic_0 && raid->magic_0 != meta->magic_0)
1814 continue;
1815 raid->magic_0 = meta->magic_0;
1816 raid->type = AR_T_RAID1;
1817 disk_number = (meta->disk_number > 0);
1818 break;
1819
1820 case HPTV2_T_RAID01_RAID0:
1821 highpoint_raid01:
1822 if (meta->order & HPTV2_O_RAID0) {
1823 if ((raid->magic_0 && raid->magic_0 != meta->magic_0) ||
1824 (raid->magic_1 && raid->magic_1 != meta->magic_1))
1825 continue;
1826 raid->magic_0 = meta->magic_0;
1827 raid->magic_1 = meta->magic_1;
1828 raid->type = AR_T_RAID01;
1829 raid->interleave = 1 << meta->stripe_shift;
1830 disk_number = meta->disk_number;
1831 }
1832 else {
1833 if (raid->magic_1 && raid->magic_1 != meta->magic_1)
1834 continue;
1835 raid->magic_1 = meta->magic_1;
1836 raid->type = AR_T_RAID01;
1837 raid->interleave = 1 << meta->stripe_shift;
1838 disk_number = meta->disk_number + meta->array_width;
1839 if (!(meta->order & HPTV2_O_RAID1))
1840 meta->magic = 0; /* mark bad */
1841 }
1842 break;
1843
1844 case HPTV2_T_SPAN:
1845 if (raid->magic_0 && raid->magic_0 != meta->magic_0)
1846 continue;
1847 raid->magic_0 = meta->magic_0;
1848 raid->type = AR_T_SPAN;
1849 disk_number = meta->disk_number;
1850 break;
1851
1852 default:
1853 device_printf(parent, "Highpoint (v2) unknown RAID type 0x%02x\n",
1854 meta->type);
1855 kfree(raidp[array], M_AR);
1856 raidp[array] = NULL;
1857 goto hptv2_out;
1858 }
1859
1860 raid->format |= AR_F_HPTV2_RAID;
1861 raid->disks[disk_number].dev = parent;
1862 raid->disks[disk_number].flags = (AR_DF_PRESENT | AR_DF_ASSIGNED);
1863 raid->lun = array;
1864 strncpy(raid->name, meta->name_1,
1865 min(sizeof(raid->name), sizeof(meta->name_1)));
1866 if (meta->magic == HPTV2_MAGIC_OK) {
1867 raid->disks[disk_number].flags |= AR_DF_ONLINE;
1868 raid->width = meta->array_width;
1869 raid->total_sectors = meta->total_sectors;
1870 raid->heads = 255;
1871 raid->sectors = 63;
1872 raid->cylinders = raid->total_sectors / (63 * 255);
1873 raid->offset_sectors = HPTV2_LBA(parent) + 1;
1874 raid->rebuild_lba = meta->rebuild_lba;
1875 raid->disks[disk_number].sectors =
1876 raid->total_sectors / raid->width;
1877 }
1878 else
1879 raid->disks[disk_number].flags &= ~AR_DF_ONLINE;
1880
1881 if ((raid->type & AR_T_RAID0) && (raid->total_disks < raid->width))
1882 raid->total_disks = raid->width;
1883 if (disk_number >= raid->total_disks)
1884 raid->total_disks = disk_number + 1;
1885 ars->raid[raid->volume] = raid;
1886 ars->disk_number[raid->volume] = disk_number;
1887 retval = 1;
1888 break;
1889 }
1890
1891 hptv2_out:
1892 kfree(meta, M_AR);
1893 return retval;
1894 }
1895
1896 static int
1897 ata_raid_hptv2_write_meta(struct ar_softc *rdp)
1898 {
1899 struct hptv2_raid_conf *meta;
1900 struct timeval timestamp;
1901 int disk, error = 0;
1902
1903 meta = (struct hptv2_raid_conf *)kmalloc(sizeof(struct hptv2_raid_conf),
1904 M_AR, M_WAITOK | M_ZERO);
1905
1906 microtime(&timestamp);
1907 rdp->magic_0 = timestamp.tv_sec + 2;
1908 rdp->magic_1 = timestamp.tv_sec;
1909
1910 for (disk = 0; disk < rdp->total_disks; disk++) {
1911 if ((rdp->disks[disk].flags & (AR_DF_PRESENT | AR_DF_ONLINE)) ==
1912 (AR_DF_PRESENT | AR_DF_ONLINE))
1913 meta->magic = HPTV2_MAGIC_OK;
1914 if (rdp->disks[disk].flags & AR_DF_ASSIGNED) {
1915 meta->magic_0 = rdp->magic_0;
1916 if (strlen(rdp->name))
1917 strncpy(meta->name_1, rdp->name, sizeof(meta->name_1));
1918 else
1919 strcpy(meta->name_1, "FreeBSD");
1920 }
1921 meta->disk_number = disk;
1922
1923 switch (rdp->type) {
1924 case AR_T_RAID0:
1925 meta->type = HPTV2_T_RAID0;
1926 strcpy(meta->name_2, "RAID 0");
1927 if (rdp->disks[disk].flags & AR_DF_ONLINE)
1928 meta->order = HPTV2_O_OK;
1929 break;
1930
1931 case AR_T_RAID1:
1932 meta->type = HPTV2_T_RAID0;
1933 strcpy(meta->name_2, "RAID 1");
1934 meta->disk_number = (disk < rdp->width) ? disk : disk + 5;
1935 meta->order = HPTV2_O_RAID0 | HPTV2_O_OK;
1936 break;
1937
1938 case AR_T_RAID01:
1939 meta->type = HPTV2_T_RAID01_RAID0;
1940 strcpy(meta->name_2, "RAID 0+1");
1941 if (rdp->disks[disk].flags & AR_DF_ONLINE) {
1942 if (disk < rdp->width) {
1943 meta->order = (HPTV2_O_RAID0 | HPTV2_O_RAID1);
1944 meta->magic_0 = rdp->magic_0 - 1;
1945 }
1946 else {
1947 meta->order = HPTV2_O_RAID1;
1948 meta->disk_number -= rdp->width;
1949 }
1950 }
1951 else
1952 meta->magic_0 = rdp->magic_0 - 1;
1953 meta->magic_1 = rdp->magic_1;
1954 break;
1955
1956 case AR_T_SPAN:
1957 meta->type = HPTV2_T_SPAN;
1958 strcpy(meta->name_2, "SPAN");
1959 break;
1960 default:
1961 kfree(meta, M_AR);
1962 return ENODEV;
1963 }
1964
1965 meta->array_width = rdp->width;
1966 meta->stripe_shift = (rdp->width > 1) ? (ffs(rdp->interleave)-1) : 0;
1967 meta->total_sectors = rdp->total_sectors;
1968 meta->rebuild_lba = rdp->rebuild_lba;
1969 if (testing || bootverbose)
1970 ata_raid_hptv2_print_meta(meta);
1971 if (rdp->disks[disk].dev) {
1972 if (ata_raid_rw(rdp->disks[disk].dev,
1973 HPTV2_LBA(rdp->disks[disk].dev), meta,
1974 sizeof(struct promise_raid_conf),
1975 ATA_R_WRITE | ATA_R_DIRECT)) {
1976 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
1977 error = EIO;
1978 }
1979 }
1980 }
1981 kfree(meta, M_AR);
1982 return error;
1983 }
1984
1985 /* Highpoint V3 RocketRAID Metadata */
1986 static int
1987 ata_raid_hptv3_read_meta(device_t dev, struct ar_softc **raidp)
1988 {
1989 struct ata_raid_subdisk *ars = device_get_softc(dev);
1990 device_t parent = device_get_parent(dev);
1991 struct hptv3_raid_conf *meta;
1992 struct ar_softc *raid = NULL;
1993 int array, disk_number, retval = 0;
1994
1995 meta = (struct hptv3_raid_conf *)kmalloc(sizeof(struct hptv3_raid_conf),
1996 M_AR, M_WAITOK | M_ZERO);
1997
1998 if (ata_raid_rw(parent, HPTV3_LBA(parent),
1999 meta, sizeof(struct hptv3_raid_conf), ATA_R_READ)) {
2000 if (testing || bootverbose)
2001 device_printf(parent, "HighPoint (v3) read metadata failed\n");
2002 goto hptv3_out;
2003 }
2004
2005 /* check if this is a HighPoint v3 RAID struct */
2006 if (meta->magic != HPTV3_MAGIC) {
2007 if (testing || bootverbose)
2008 device_printf(parent, "HighPoint (v3) check1 failed\n");
2009 goto hptv3_out;
2010 }
2011
2012 /* check if there are any config_entries */
2013 if (meta->config_entries < 1) {
2014 if (testing || bootverbose)
2015 device_printf(parent, "HighPoint (v3) check2 failed\n");
2016 goto hptv3_out;
2017 }
2018
2019 if (testing || bootverbose)
2020 ata_raid_hptv3_print_meta(meta);
2021
2022 /* now convert HighPoint (v3) metadata into our generic form */
2023 for (array = 0; array < MAX_ARRAYS; array++) {
2024 if (!raidp[array]) {
2025 raidp[array] =
2026 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
2027 M_WAITOK | M_ZERO);
2028 }
2029 raid = raidp[array];
2030 if (raid->format && (raid->format != AR_F_HPTV3_RAID))
2031 continue;
2032
2033 if ((raid->format & AR_F_HPTV3_RAID) && raid->magic_0 != meta->magic_0)
2034 continue;
2035
2036 switch (meta->configs[0].type) {
2037 case HPTV3_T_RAID0:
2038 raid->type = AR_T_RAID0;
2039 raid->width = meta->configs[0].total_disks;
2040 disk_number = meta->configs[0].disk_number;
2041 break;
2042
2043 case HPTV3_T_RAID1:
2044 raid->type = AR_T_RAID1;
2045 raid->width = meta->configs[0].total_disks / 2;
2046 disk_number = meta->configs[0].disk_number;
2047 break;
2048
2049 case HPTV3_T_RAID5:
2050 raid->type = AR_T_RAID5;
2051 raid->width = meta->configs[0].total_disks;
2052 disk_number = meta->configs[0].disk_number;
2053 break;
2054
2055 case HPTV3_T_SPAN:
2056 raid->type = AR_T_SPAN;
2057 raid->width = meta->configs[0].total_disks;
2058 disk_number = meta->configs[0].disk_number;
2059 break;
2060
2061 default:
2062 device_printf(parent, "Highpoint (v3) unknown RAID type 0x%02x\n",
2063 meta->configs[0].type);
2064 kfree(raidp[array], M_AR);
2065 raidp[array] = NULL;
2066 goto hptv3_out;
2067 }
2068 if (meta->config_entries == 2) {
2069 switch (meta->configs[1].type) {
2070 case HPTV3_T_RAID1:
2071 if (raid->type == AR_T_RAID0) {
2072 raid->type = AR_T_RAID01;
2073 disk_number = meta->configs[1].disk_number +
2074 (meta->configs[0].disk_number << 1);
2075 break;
2076 }
2077 default:
2078 device_printf(parent, "Highpoint (v3) unknown level 2 0x%02x\n",
2079 meta->configs[1].type);
2080 kfree(raidp[array], M_AR);
2081 raidp[array] = NULL;
2082 goto hptv3_out;
2083 }
2084 }
2085
2086 raid->magic_0 = meta->magic_0;
2087 raid->format = AR_F_HPTV3_RAID;
2088 raid->generation = meta->timestamp;
2089 raid->interleave = 1 << meta->configs[0].stripe_shift;
2090 raid->total_disks = meta->configs[0].total_disks +
2091 meta->configs[1].total_disks;
2092 raid->total_sectors = meta->configs[0].total_sectors +
2093 ((u_int64_t)meta->configs_high[0].total_sectors << 32);
2094 raid->heads = 255;
2095 raid->sectors = 63;
2096 raid->cylinders = raid->total_sectors / (63 * 255);
2097 raid->offset_sectors = 0;
2098 raid->rebuild_lba = meta->configs[0].rebuild_lba +
2099 ((u_int64_t)meta->configs_high[0].rebuild_lba << 32);
2100 raid->lun = array;
2101 strncpy(raid->name, meta->name,
2102 min(sizeof(raid->name), sizeof(meta->name)));
2103 raid->disks[disk_number].sectors = raid->total_sectors /
2104 (raid->type == AR_T_RAID5 ? raid->width - 1 : raid->width);
2105 raid->disks[disk_number].dev = parent;
2106 raid->disks[disk_number].flags =
2107 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
2108 ars->raid[raid->volume] = raid;
2109 ars->disk_number[raid->volume] = disk_number;
2110 retval = 1;
2111 break;
2112 }
2113
2114 hptv3_out:
2115 kfree(meta, M_AR);
2116 return retval;
2117 }
2118
2119 /* Intel MatrixRAID Metadata */
2120 static int
2121 ata_raid_intel_read_meta(device_t dev, struct ar_softc **raidp)
2122 {
2123 struct ata_raid_subdisk *ars = device_get_softc(dev);
2124 device_t parent = device_get_parent(dev);
2125 struct intel_raid_conf *meta;
2126 struct intel_raid_mapping *map;
2127 struct ar_softc *raid = NULL;
2128 u_int32_t checksum, *ptr;
2129 int array, count, disk, volume = 1, retval = 0;
2130 char *tmp;
2131
2132 meta = (struct intel_raid_conf *)kmalloc(1536, M_AR, M_WAITOK | M_ZERO);
2133
2134 if (ata_raid_rw(parent, INTEL_LBA(parent), meta, 1024, ATA_R_READ)) {
2135 if (testing || bootverbose)
2136 device_printf(parent, "Intel read metadata failed\n");
2137 goto intel_out;
2138 }
2139 tmp = (char *)meta;
2140 bcopy(tmp, tmp+1024, 512);
2141 bcopy(tmp+512, tmp, 1024);
2142 bzero(tmp+1024, 512);
2143
2144 /* check if this is a Intel RAID struct */
2145 if (strncmp(meta->intel_id, INTEL_MAGIC, strlen(INTEL_MAGIC))) {
2146 if (testing || bootverbose)
2147 device_printf(parent, "Intel check1 failed\n");
2148 goto intel_out;
2149 }
2150
2151 for (checksum = 0, ptr = (u_int32_t *)meta, count = 0;
2152 count < (meta->config_size / sizeof(u_int32_t)); count++) {
2153 checksum += *ptr++;
2154 }
2155 checksum -= meta->checksum;
2156 if (checksum != meta->checksum) {
2157 if (testing || bootverbose)
2158 device_printf(parent, "Intel check2 failed\n");
2159 goto intel_out;
2160 }
2161
2162 if (testing || bootverbose)
2163 ata_raid_intel_print_meta(meta);
2164
2165 map = (struct intel_raid_mapping *)&meta->disk[meta->total_disks];
2166
2167 /* now convert Intel metadata into our generic form */
2168 for (array = 0; array < MAX_ARRAYS; array++) {
2169 if (!raidp[array]) {
2170 raidp[array] =
2171 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
2172 M_WAITOK | M_ZERO);
2173 }
2174 raid = raidp[array];
2175 if (raid->format && (raid->format != AR_F_INTEL_RAID))
2176 continue;
2177
2178 if ((raid->format & AR_F_INTEL_RAID) &&
2179 (raid->magic_0 != meta->config_id))
2180 continue;
2181
2182 /*
2183 * update our knowledge about the array config based on generation
2184 * NOTE: there can be multiple volumes on a disk set
2185 */
2186 if (!meta->generation || meta->generation > raid->generation) {
2187 switch (map->type) {
2188 case INTEL_T_RAID0:
2189 raid->type = AR_T_RAID0;
2190 raid->width = map->total_disks;
2191 break;
2192
2193 case INTEL_T_RAID1:
2194 if (map->total_disks == 4)
2195 raid->type = AR_T_RAID01;
2196 else
2197 raid->type = AR_T_RAID1;
2198 raid->width = map->total_disks / 2;
2199 break;
2200
2201 case INTEL_T_RAID5:
2202 raid->type = AR_T_RAID5;
2203 raid->width = map->total_disks;
2204 break;
2205
2206 default:
2207 device_printf(parent, "Intel unknown RAID type 0x%02x\n",
2208 map->type);
2209 kfree(raidp[array], M_AR);
2210 raidp[array] = NULL;
2211 goto intel_out;
2212 }
2213
2214 switch (map->status) {
2215 case INTEL_S_READY:
2216 raid->status = AR_S_READY;
2217 break;
2218 case INTEL_S_DEGRADED:
2219 raid->status |= AR_S_DEGRADED;
2220 break;
2221 case INTEL_S_DISABLED:
2222 case INTEL_S_FAILURE:
2223 raid->status = 0;
2224 }
2225
2226 raid->magic_0 = meta->config_id;
2227 raid->format = AR_F_INTEL_RAID;
2228 raid->generation = meta->generation;
2229 raid->interleave = map->stripe_sectors;
2230 raid->total_disks = map->total_disks;
2231 raid->total_sectors = map->total_sectors;
2232 raid->heads = 255;
2233 raid->sectors = 63;
2234 raid->cylinders = raid->total_sectors / (63 * 255);
2235 raid->offset_sectors = map->offset;
2236 raid->rebuild_lba = 0;
2237 raid->lun = array;
2238 raid->volume = volume - 1;
2239 strncpy(raid->name, map->name,
2240 min(sizeof(raid->name), sizeof(map->name)));
2241
2242 /* clear out any old info */
2243 for (disk = 0; disk < raid->total_disks; disk++) {
2244 u_int disk_idx = map->disk_idx[disk] & 0xffff;
2245
2246 raid->disks[disk].dev = NULL;
2247 bcopy(meta->disk[disk_idx].serial,
2248 raid->disks[disk].serial,
2249 sizeof(raid->disks[disk].serial));
2250 raid->disks[disk].sectors =
2251 meta->disk[disk_idx].sectors;
2252 raid->disks[disk].flags = 0;
2253 if (meta->disk[disk_idx].flags & INTEL_F_ONLINE)
2254 raid->disks[disk].flags |= AR_DF_ONLINE;
2255 if (meta->disk[disk_idx].flags & INTEL_F_ASSIGNED)
2256 raid->disks[disk].flags |= AR_DF_ASSIGNED;
2257 if (meta->disk[disk_idx].flags & INTEL_F_SPARE) {
2258 raid->disks[disk].flags &= ~(AR_DF_ONLINE | AR_DF_ASSIGNED);
2259 raid->disks[disk].flags |= AR_DF_SPARE;
2260 }
2261 if (meta->disk[disk_idx].flags & INTEL_F_DOWN)
2262 raid->disks[disk].flags &= ~AR_DF_ONLINE;
2263 }
2264 }
2265 if (meta->generation >= raid->generation) {
2266 for (disk = 0; disk < raid->total_disks; disk++) {
2267 struct ata_device *atadev = device_get_softc(parent);
2268 int len;
2269
2270 for (len = 0; len < sizeof(atadev->param.serial); len++) {
2271 if (atadev->param.serial[len] < 0x20)
2272 break;
2273 }
2274 len = (len > sizeof(raid->disks[disk].serial)) ?
2275 len - sizeof(raid->disks[disk].serial) : 0;
2276 if (!strncmp(raid->disks[disk].serial, atadev->param.serial + len,
2277 sizeof(raid->disks[disk].serial))) {
2278 raid->disks[disk].dev = parent;
2279 raid->disks[disk].flags |= (AR_DF_PRESENT | AR_DF_ONLINE);
2280 ars->raid[raid->volume] = raid;
2281 ars->disk_number[raid->volume] = disk;
2282 retval = 1;
2283 }
2284 }
2285 }
2286 else
2287 goto intel_out;
2288
2289 if (retval) {
2290 if (volume < meta->total_volumes) {
2291 map = (struct intel_raid_mapping *)
2292 &map->disk_idx[map->total_disks];
2293 volume++;
2294 retval = 0;
2295 continue;
2296 }
2297 break;
2298 }
2299 else {
2300 kfree(raidp[array], M_AR);
2301 raidp[array] = NULL;
2302 if (volume == 2)
2303 retval = 1;
2304 }
2305 }
2306
2307 intel_out:
2308 kfree(meta, M_AR);
2309 return retval;
2310 }
2311
2312 static int
2313 ata_raid_intel_write_meta(struct ar_softc *rdp)
2314 {
2315 struct intel_raid_conf *meta;
2316 struct intel_raid_mapping *map;
2317 struct timeval timestamp;
2318 u_int32_t checksum, *ptr;
2319 int count, disk, error = 0;
2320 char *tmp;
2321
2322 meta = (struct intel_raid_conf *)kmalloc(1536, M_AR, M_WAITOK | M_ZERO);
2323
2324 rdp->generation++;
2325
2326 /* Generate a new config_id if none exists */
2327 if (!rdp->magic_0) {
2328 microtime(&timestamp);
2329 rdp->magic_0 = timestamp.tv_sec ^ timestamp.tv_usec;
2330 }
2331
2332 bcopy(INTEL_MAGIC, meta->intel_id, sizeof(meta->intel_id));
2333 bcopy(INTEL_VERSION_1100, meta->version, sizeof(meta->version));
2334 meta->config_id = rdp->magic_0;
2335 meta->generation = rdp->generation;
2336 meta->total_disks = rdp->total_disks;
2337 meta->total_volumes = 1; /* XXX SOS */
2338 for (disk = 0; disk < rdp->total_disks; disk++) {
2339 if (rdp->disks[disk].dev) {
2340 struct ata_channel *ch =
2341 device_get_softc(device_get_parent(rdp->disks[disk].dev));
2342 struct ata_device *atadev =
2343 device_get_softc(rdp->disks[disk].dev);
2344 int len;
2345
2346 for (len = 0; len < sizeof(atadev->param.serial); len++) {
2347 if (atadev->param.serial[len] < 0x20)
2348 break;
2349 }
2350 len = (len > sizeof(rdp->disks[disk].serial)) ?
2351 len - sizeof(rdp->disks[disk].serial) : 0;
2352 bcopy(atadev->param.serial + len, meta->disk[disk].serial,
2353 sizeof(rdp->disks[disk].serial));
2354 meta->disk[disk].sectors = rdp->disks[disk].sectors;
2355 meta->disk[disk].id = (ch->unit << 16) | ATA_DEV(atadev->unit);
2356 }
2357 else
2358 meta->disk[disk].sectors = rdp->total_sectors / rdp->width;
2359 meta->disk[disk].flags = 0;
2360 if (rdp->disks[disk].flags & AR_DF_SPARE)
2361 meta->disk[disk].flags |= INTEL_F_SPARE;
2362 else {
2363 if (rdp->disks[disk].flags & AR_DF_ONLINE)
2364 meta->disk[disk].flags |= INTEL_F_ONLINE;
2365 else
2366 meta->disk[disk].flags |= INTEL_F_DOWN;
2367 if (rdp->disks[disk].flags & AR_DF_ASSIGNED)
2368 meta->disk[disk].flags |= INTEL_F_ASSIGNED;
2369 }
2370 }
2371 map = (struct intel_raid_mapping *)&meta->disk[meta->total_disks];
2372
2373 bcopy(rdp->name, map->name, sizeof(rdp->name));
2374 map->total_sectors = rdp->total_sectors;
2375 map->state = 12; /* XXX SOS */
2376 map->offset = rdp->offset_sectors;
2377 map->stripe_count = rdp->total_sectors / (rdp->interleave*rdp->total_disks);
2378 map->stripe_sectors = rdp->interleave;
2379 map->disk_sectors = rdp->total_sectors / rdp->width;
2380 map->status = INTEL_S_READY; /* XXX SOS */
2381 switch (rdp->type) {
2382 case AR_T_RAID0:
2383 map->type = INTEL_T_RAID0;
2384 break;
2385 case AR_T_RAID1:
2386 map->type = INTEL_T_RAID1;
2387 break;
2388 case AR_T_RAID01:
2389 map->type = INTEL_T_RAID1;
2390 break;
2391 case AR_T_RAID5:
2392 map->type = INTEL_T_RAID5;
2393 break;
2394 default:
2395 kfree(meta, M_AR);
2396 return ENODEV;
2397 }
2398 map->total_disks = rdp->total_disks;
2399 map->magic[0] = 0x02;
2400 map->magic[1] = 0xff;
2401 map->magic[2] = 0x01;
2402 for (disk = 0; disk < rdp->total_disks; disk++)
2403 map->disk_idx[disk] = disk;
2404
2405 meta->config_size = (char *)&map->disk_idx[disk] - (char *)meta;
2406 for (checksum = 0, ptr = (u_int32_t *)meta, count = 0;
2407 count < (meta->config_size / sizeof(u_int32_t)); count++) {
2408 checksum += *ptr++;
2409 }
2410 meta->checksum = checksum;
2411
2412 if (testing || bootverbose)
2413 ata_raid_intel_print_meta(meta);
2414
2415 tmp = (char *)meta;
2416 bcopy(tmp, tmp+1024, 512);
2417 bcopy(tmp+512, tmp, 1024);
2418 bzero(tmp+1024, 512);
2419
2420 for (disk = 0; disk < rdp->total_disks; disk++) {
2421 if (rdp->disks[disk].dev) {
2422 if (ata_raid_rw(rdp->disks[disk].dev,
2423 INTEL_LBA(rdp->disks[disk].dev),
2424 meta, 1024, ATA_R_WRITE | ATA_R_DIRECT)) {
2425 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
2426 error = EIO;
2427 }
2428 }
2429 }
2430 kfree(meta, M_AR);
2431 return error;
2432 }
2433
2434
2435 /* Integrated Technology Express Metadata */
2436 static int
2437 ata_raid_ite_read_meta(device_t dev, struct ar_softc **raidp)
2438 {
2439 struct ata_raid_subdisk *ars = device_get_softc(dev);
2440 device_t parent = device_get_parent(dev);
2441 struct ite_raid_conf *meta;
2442 struct ar_softc *raid = NULL;
2443 int array, disk_number, count, retval = 0;
2444 u_int16_t *ptr;
2445
2446 meta = (struct ite_raid_conf *)kmalloc(sizeof(struct ite_raid_conf), M_AR,
2447 M_WAITOK | M_ZERO);
2448
2449 if (ata_raid_rw(parent, ITE_LBA(parent),
2450 meta, sizeof(struct ite_raid_conf), ATA_R_READ)) {
2451 if (testing || bootverbose)
2452 device_printf(parent, "ITE read metadata failed\n");
2453 goto ite_out;
2454 }
2455
2456 /* check if this is a ITE RAID struct */
2457 for (ptr = (u_int16_t *)meta->ite_id, count = 0;
2458 count < sizeof(meta->ite_id)/sizeof(uint16_t); count++)
2459 ptr[count] = be16toh(ptr[count]);
2460
2461 if (strncmp(meta->ite_id, ITE_MAGIC, strlen(ITE_MAGIC))) {
2462 if (testing || bootverbose)
2463 device_printf(parent, "ITE check1 failed\n");
2464 goto ite_out;
2465 }
2466
2467 if (testing || bootverbose)
2468 ata_raid_ite_print_meta(meta);
2469
2470 /* now convert ITE metadata into our generic form */
2471 for (array = 0; array < MAX_ARRAYS; array++) {
2472 if ((raid = raidp[array])) {
2473 if (raid->format != AR_F_ITE_RAID)
2474 continue;
2475 if (raid->magic_0 != *((u_int64_t *)meta->timestamp_0))
2476 continue;
2477 }
2478
2479 /* if we dont have a disks timestamp the RAID is invalidated */
2480 if (*((u_int64_t *)meta->timestamp_1) == 0)
2481 goto ite_out;
2482
2483 if (!raid) {
2484 raidp[array] = (struct ar_softc *)kmalloc(sizeof(struct ar_softc),
2485 M_AR, M_WAITOK | M_ZERO);
2486 }
2487
2488 switch (meta->type) {
2489 case ITE_T_RAID0:
2490 raid->type = AR_T_RAID0;
2491 raid->width = meta->array_width;
2492 raid->total_disks = meta->array_width;
2493 disk_number = meta->disk_number;
2494 break;
2495
2496 case ITE_T_RAID1:
2497 raid->type = AR_T_RAID1;
2498 raid->width = 1;
2499 raid->total_disks = 2;
2500 disk_number = meta->disk_number;
2501 break;
2502
2503 case ITE_T_RAID01:
2504 raid->type = AR_T_RAID01;
2505 raid->width = meta->array_width;
2506 raid->total_disks = 4;
2507 disk_number = ((meta->disk_number & 0x02) >> 1) |
2508 ((meta->disk_number & 0x01) << 1);
2509 break;
2510
2511 case ITE_T_SPAN:
2512 raid->type = AR_T_SPAN;
2513 raid->width = 1;
2514 raid->total_disks = meta->array_width;
2515 disk_number = meta->disk_number;
2516 break;
2517
2518 default:
2519 device_printf(parent, "ITE unknown RAID type 0x%02x\n", meta->type);
2520 kfree(raidp[array], M_AR);
2521 raidp[array] = NULL;
2522 goto ite_out;
2523 }
2524
2525 raid->magic_0 = *((u_int64_t *)meta->timestamp_0);
2526 raid->format = AR_F_ITE_RAID;
2527 raid->generation = 0;
2528 raid->interleave = meta->stripe_sectors;
2529 raid->total_sectors = meta->total_sectors;
2530 raid->heads = 255;
2531 raid->sectors = 63;
2532 raid->cylinders = raid->total_sectors / (63 * 255);
2533 raid->offset_sectors = 0;
2534 raid->rebuild_lba = 0;
2535 raid->lun = array;
2536
2537 raid->disks[disk_number].dev = parent;
2538 raid->disks[disk_number].sectors = raid->total_sectors / raid->width;
2539 raid->disks[disk_number].flags =
2540 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
2541 ars->raid[raid->volume] = raid;
2542 ars->disk_number[raid->volume] = disk_number;
2543 retval = 1;
2544 break;
2545 }
2546 ite_out:
2547 kfree(meta, M_AR);
2548 return retval;
2549 }
2550
2551 /* JMicron Technology Corp Metadata */
2552 static int
2553 ata_raid_jmicron_read_meta(device_t dev, struct ar_softc **raidp)
2554 {
2555 struct ata_raid_subdisk *ars = device_get_softc(dev);
2556 device_t parent = device_get_parent(dev);
2557 struct jmicron_raid_conf *meta;
2558 struct ar_softc *raid = NULL;
2559 u_int16_t checksum, *ptr;
2560 u_int64_t disk_size;
2561 int count, array, disk, total_disks, retval = 0;
2562
2563 meta = (struct jmicron_raid_conf *)
2564 kmalloc(sizeof(struct jmicron_raid_conf), M_AR, M_WAITOK | M_ZERO);
2565
2566 if (ata_raid_rw(parent, JMICRON_LBA(parent),
2567 meta, sizeof(struct jmicron_raid_conf), ATA_R_READ)) {
2568 if (testing || bootverbose)
2569 device_printf(parent,
2570 "JMicron read metadata failed\n");
2571 }
2572
2573 /* check for JMicron signature */
2574 if (strncmp(meta->signature, JMICRON_MAGIC, 2)) {
2575 if (testing || bootverbose)
2576 device_printf(parent, "JMicron check1 failed\n");
2577 goto jmicron_out;
2578 }
2579
2580 /* calculate checksum and compare for valid */
2581 for (checksum = 0, ptr = (u_int16_t *)meta, count = 0; count < 64; count++)
2582 checksum += *ptr++;
2583 if (checksum) {
2584 if (testing || bootverbose)
2585 device_printf(parent, "JMicron check2 failed\n");
2586 goto jmicron_out;
2587 }
2588
2589 if (testing || bootverbose)
2590 ata_raid_jmicron_print_meta(meta);
2591
2592 /* now convert JMicron meta into our generic form */
2593 for (array = 0; array < MAX_ARRAYS; array++) {
2594 jmicron_next:
2595 if (!raidp[array]) {
2596 raidp[array] =
2597 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
2598 M_WAITOK | M_ZERO);
2599 }
2600 raid = raidp[array];
2601 if (raid->format && (raid->format != AR_F_JMICRON_RAID))
2602 continue;
2603
2604 for (total_disks = 0, disk = 0; disk < JM_MAX_DISKS; disk++) {
2605 if (meta->disks[disk]) {
2606 if (raid->format == AR_F_JMICRON_RAID) {
2607 if (bcmp(&meta->disks[disk],
2608 raid->disks[disk].serial, sizeof(u_int32_t))) {
2609 array++;
2610 goto jmicron_next;
2611 }
2612 }
2613 else
2614 bcopy(&meta->disks[disk],
2615 raid->disks[disk].serial, sizeof(u_int32_t));
2616 total_disks++;
2617 }
2618 }
2619 /* handle spares XXX SOS */
2620
2621 switch (meta->type) {
2622 case JM_T_RAID0:
2623 raid->type = AR_T_RAID0;
2624 raid->width = total_disks;
2625 break;
2626
2627 case JM_T_RAID1:
2628 raid->type = AR_T_RAID1;
2629 raid->width = 1;
2630 break;
2631
2632 case JM_T_RAID01:
2633 raid->type = AR_T_RAID01;
2634 raid->width = total_disks / 2;
2635 break;
2636
2637 case JM_T_RAID5:
2638 raid->type = AR_T_RAID5;
2639 raid->width = total_disks;
2640 break;
2641
2642 case JM_T_JBOD:
2643 raid->type = AR_T_SPAN;
2644 raid->width = 1;
2645 break;
2646
2647 default:
2648 device_printf(parent,
2649 "JMicron unknown RAID type 0x%02x\n", meta->type);
2650 kfree(raidp[array], M_AR);
2651 raidp[array] = NULL;
2652 goto jmicron_out;
2653 }
2654 disk_size = (meta->disk_sectors_high << 16) + meta->disk_sectors_low;
2655 raid->format = AR_F_JMICRON_RAID;
2656 strncpy(raid->name, meta->name, sizeof(meta->name));
2657 raid->generation = 0;
2658 raid->interleave = 2 << meta->stripe_shift;
2659 raid->total_disks = total_disks;
2660 raid->total_sectors = disk_size * (raid->width-(raid->type==AR_RAID5));
2661 raid->heads = 255;
2662 raid->sectors = 63;
2663 raid->cylinders = raid->total_sectors / (63 * 255);
2664 raid->offset_sectors = meta->offset * 16;
2665 raid->rebuild_lba = 0;
2666 raid->lun = array;
2667
2668 for (disk = 0; disk < raid->total_disks; disk++) {
2669 if (meta->disks[disk] == meta->disk_id) {
2670 raid->disks[disk].dev = parent;
2671 raid->disks[disk].sectors = disk_size;
2672 raid->disks[disk].flags =
2673 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
2674 ars->raid[raid->volume] = raid;
2675 ars->disk_number[raid->volume] = disk;
2676 retval = 1;
2677 break;
2678 }
2679 }
2680 break;
2681 }
2682 jmicron_out:
2683 kfree(meta, M_AR);
2684 return retval;
2685 }
2686
2687 static int
2688 ata_raid_jmicron_write_meta(struct ar_softc *rdp)
2689 {
2690 struct jmicron_raid_conf *meta;
2691 u_int64_t disk_sectors;
2692 int disk, error = 0;
2693
2694 meta = (struct jmicron_raid_conf *)
2695 kmalloc(sizeof(struct jmicron_raid_conf), M_AR, M_WAITOK | M_ZERO);
2696
2697 rdp->generation++;
2698 switch (rdp->type) {
2699 case AR_T_JBOD:
2700 meta->type = JM_T_JBOD;
2701 break;
2702
2703 case AR_T_RAID0:
2704 meta->type = JM_T_RAID0;
2705 break;
2706
2707 case AR_T_RAID1:
2708 meta->type = JM_T_RAID1;
2709 break;
2710
2711 case AR_T_RAID5:
2712 meta->type = JM_T_RAID5;
2713 break;
2714
2715 case AR_T_RAID01:
2716 meta->type = JM_T_RAID01;
2717 break;
2718
2719 default:
2720 kfree(meta, M_AR);
2721 return ENODEV;
2722 }
2723 bcopy(JMICRON_MAGIC, meta->signature, sizeof(JMICRON_MAGIC));
2724 meta->version = JMICRON_VERSION;
2725 meta->offset = rdp->offset_sectors / 16;
2726 disk_sectors = rdp->total_sectors / (rdp->width - (rdp->type == AR_RAID5));
2727 meta->disk_sectors_low = disk_sectors & 0xffff;
2728 meta->disk_sectors_high = disk_sectors >> 16;
2729 strncpy(meta->name, rdp->name, sizeof(meta->name));
2730 meta->stripe_shift = ffs(rdp->interleave) - 2;
2731
2732 for (disk = 0; disk < rdp->total_disks && disk < JM_MAX_DISKS; disk++) {
2733 if (rdp->disks[disk].serial[0])
2734 bcopy(rdp->disks[disk].serial,&meta->disks[disk],sizeof(u_int32_t));
2735 else
2736 meta->disks[disk] = (u_int32_t)(uintptr_t)rdp->disks[disk].dev;
2737 }
2738
2739 for (disk = 0; disk < rdp->total_disks; disk++) {
2740 if (rdp->disks[disk].dev) {
2741 u_int16_t checksum = 0, *ptr;
2742 int count;
2743
2744 meta->disk_id = meta->disks[disk];
2745 meta->checksum = 0;
2746 for (ptr = (u_int16_t *)meta, count = 0; count < 64; count++)
2747 checksum += *ptr++;
2748 meta->checksum -= checksum;
2749
2750 if (testing || bootverbose)
2751 ata_raid_jmicron_print_meta(meta);
2752
2753 if (ata_raid_rw(rdp->disks[disk].dev,
2754 JMICRON_LBA(rdp->disks[disk].dev),
2755 meta, sizeof(struct jmicron_raid_conf),
2756 ATA_R_WRITE | ATA_R_DIRECT)) {
2757 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
2758 error = EIO;
2759 }
2760 }
2761 }
2762 /* handle spares XXX SOS */
2763
2764 kfree(meta, M_AR);
2765 return error;
2766 }
2767
2768 /* LSILogic V2 MegaRAID Metadata */
2769 static int
2770 ata_raid_lsiv2_read_meta(device_t dev, struct ar_softc **raidp)
2771 {
2772 struct ata_raid_subdisk *ars = device_get_softc(dev);
2773 device_t parent = device_get_parent(dev);
2774 struct lsiv2_raid_conf *meta;
2775 struct ar_softc *raid = NULL;
2776 int array, retval = 0;
2777
2778 meta = (struct lsiv2_raid_conf *)kmalloc(sizeof(struct lsiv2_raid_conf),
2779 M_AR, M_WAITOK | M_ZERO);
2780
2781 if (ata_raid_rw(parent, LSIV2_LBA(parent),
2782 meta, sizeof(struct lsiv2_raid_conf), ATA_R_READ)) {
2783 if (testing || bootverbose)
2784 device_printf(parent, "LSI (v2) read metadata failed\n");
2785 goto lsiv2_out;
2786 }
2787
2788 /* check if this is a LSI RAID struct */
2789 if (strncmp(meta->lsi_id, LSIV2_MAGIC, strlen(LSIV2_MAGIC))) {
2790 if (testing || bootverbose)
2791 device_printf(parent, "LSI (v2) check1 failed\n");
2792 goto lsiv2_out;
2793 }
2794
2795 if (testing || bootverbose)
2796 ata_raid_lsiv2_print_meta(meta);
2797
2798 /* now convert LSI (v2) config meta into our generic form */
2799 for (array = 0; array < MAX_ARRAYS; array++) {
2800 int raid_entry, conf_entry;
2801
2802 if (!raidp[array + meta->raid_number]) {
2803 raidp[array + meta->raid_number] =
2804 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
2805 M_WAITOK | M_ZERO);
2806 }
2807 raid = raidp[array + meta->raid_number];
2808 if (raid->format && (raid->format != AR_F_LSIV2_RAID))
2809 continue;
2810
2811 if (raid->magic_0 &&
2812 ((raid->magic_0 != meta->timestamp) ||
2813 (raid->magic_1 != meta->raid_number)))
2814 continue;
2815
2816 array += meta->raid_number;
2817
2818 raid_entry = meta->raid_number;
2819 conf_entry = (meta->configs[raid_entry].raid.config_offset >> 4) +
2820 meta->disk_number - 1;
2821
2822 switch (meta->configs[raid_entry].raid.type) {
2823 case LSIV2_T_RAID0:
2824 raid->magic_0 = meta->timestamp;
2825 raid->magic_1 = meta->raid_number;
2826 raid->type = AR_T_RAID0;
2827 raid->interleave = meta->configs[raid_entry].raid.stripe_sectors;
2828 raid->width = meta->configs[raid_entry].raid.array_width;
2829 break;
2830
2831 case LSIV2_T_RAID1:
2832 raid->magic_0 = meta->timestamp;
2833 raid->magic_1 = meta->raid_number;
2834 raid->type = AR_T_RAID1;
2835 raid->width = meta->configs[raid_entry].raid.array_width;
2836 break;
2837
2838 case LSIV2_T_RAID0 | LSIV2_T_RAID1:
2839 raid->magic_0 = meta->timestamp;
2840 raid->magic_1 = meta->raid_number;
2841 raid->type = AR_T_RAID01;
2842 raid->interleave = meta->configs[raid_entry].raid.stripe_sectors;
2843 raid->width = meta->configs[raid_entry].raid.array_width;
2844 break;
2845
2846 default:
2847 device_printf(parent, "LSI v2 unknown RAID type 0x%02x\n",
2848 meta->configs[raid_entry].raid.type);
2849 kfree(raidp[array], M_AR);
2850 raidp[array] = NULL;
2851 goto lsiv2_out;
2852 }
2853
2854 raid->format = AR_F_LSIV2_RAID;
2855 raid->generation = 0;
2856 raid->total_disks = meta->configs[raid_entry].raid.disk_count;
2857 raid->total_sectors = meta->configs[raid_entry].raid.total_sectors;
2858 raid->heads = 255;
2859 raid->sectors = 63;
2860 raid->cylinders = raid->total_sectors / (63 * 255);
2861 raid->offset_sectors = 0;
2862 raid->rebuild_lba = 0;
2863 raid->lun = array;
2864
2865 if (meta->configs[conf_entry].disk.device != LSIV2_D_NONE) {
2866 raid->disks[meta->disk_number].dev = parent;
2867 raid->disks[meta->disk_number].sectors =
2868 meta->configs[conf_entry].disk.disk_sectors;
2869 raid->disks[meta->disk_number].flags =
2870 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
2871 ars->raid[raid->volume] = raid;
2872 ars->disk_number[raid->volume] = meta->disk_number;
2873 retval = 1;
2874 }
2875 else
2876 raid->disks[meta->disk_number].flags &= ~AR_DF_ONLINE;
2877
2878 break;
2879 }
2880
2881 lsiv2_out:
2882 kfree(meta, M_AR);
2883 return retval;
2884 }
2885
2886 /* LSILogic V3 MegaRAID Metadata */
2887 static int
2888 ata_raid_lsiv3_read_meta(device_t dev, struct ar_softc **raidp)
2889 {
2890 struct ata_raid_subdisk *ars = device_get_softc(dev);
2891 device_t parent = device_get_parent(dev);
2892 struct lsiv3_raid_conf *meta;
2893 struct ar_softc *raid = NULL;
2894 u_int8_t checksum, *ptr;
2895 int array, entry, count, disk_number, retval = 0;
2896
2897 meta = (struct lsiv3_raid_conf *)kmalloc(sizeof(struct lsiv3_raid_conf),
2898 M_AR, M_WAITOK | M_ZERO);
2899
2900 if (ata_raid_rw(parent, LSIV3_LBA(parent),
2901 meta, sizeof(struct lsiv3_raid_conf), ATA_R_READ)) {
2902 if (testing || bootverbose)
2903 device_printf(parent, "LSI (v3) read metadata failed\n");
2904 goto lsiv3_out;
2905 }
2906
2907 /* check if this is a LSI RAID struct */
2908 if (strncmp(meta->lsi_id, LSIV3_MAGIC, strlen(LSIV3_MAGIC))) {
2909 if (testing || bootverbose)
2910 device_printf(parent, "LSI (v3) check1 failed\n");
2911 goto lsiv3_out;
2912 }
2913
2914 /* check if the checksum is OK */
2915 for (checksum = 0, ptr = meta->lsi_id, count = 0; count < 512; count++)
2916 checksum += *ptr++;
2917 if (checksum) {
2918 if (testing || bootverbose)
2919 device_printf(parent, "LSI (v3) check2 failed\n");
2920 goto lsiv3_out;
2921 }
2922
2923 if (testing || bootverbose)
2924 ata_raid_lsiv3_print_meta(meta);
2925
2926 /* now convert LSI (v3) config meta into our generic form */
2927 for (array = 0, entry = 0; array < MAX_ARRAYS && entry < 8;) {
2928 if (!raidp[array]) {
2929 raidp[array] =
2930 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
2931 M_WAITOK | M_ZERO);
2932 }
2933 raid = raidp[array];
2934 if (raid->format && (raid->format != AR_F_LSIV3_RAID)) {
2935 array++;
2936 continue;
2937 }
2938
2939 if ((raid->format == AR_F_LSIV3_RAID) &&
2940 (raid->magic_0 != meta->timestamp)) {
2941 array++;
2942 continue;
2943 }
2944
2945 switch (meta->raid[entry].total_disks) {
2946 case 0:
2947 entry++;
2948 continue;
2949 case 1:
2950 if (meta->raid[entry].device == meta->device) {
2951 disk_number = 0;
2952 break;
2953 }
2954 if (raid->format)
2955 array++;
2956 entry++;
2957 continue;
2958 case 2:
2959 disk_number = (meta->device & (LSIV3_D_DEVICE|LSIV3_D_CHANNEL))?1:0;
2960 break;
2961 default:
2962 device_printf(parent, "lsiv3 > 2 disk support untested!!\n");
2963 disk_number = (meta->device & LSIV3_D_DEVICE ? 1 : 0) +
2964 (meta->device & LSIV3_D_CHANNEL ? 2 : 0);
2965 break;
2966 }
2967
2968 switch (meta->raid[entry].type) {
2969 case LSIV3_T_RAID0:
2970 raid->type = AR_T_RAID0;
2971 raid->width = meta->raid[entry].total_disks;
2972 break;
2973
2974 case LSIV3_T_RAID1:
2975 raid->type = AR_T_RAID1;
2976 raid->width = meta->raid[entry].array_width;
2977 break;
2978
2979 default:
2980 device_printf(parent, "LSI v3 unknown RAID type 0x%02x\n",
2981 meta->raid[entry].type);
2982 kfree(raidp[array], M_AR);
2983 raidp[array] = NULL;
2984 entry++;
2985 continue;
2986 }
2987
2988 raid->magic_0 = meta->timestamp;
2989 raid->format = AR_F_LSIV3_RAID;
2990 raid->generation = 0;
2991 raid->interleave = meta->raid[entry].stripe_pages * 8;
2992 raid->total_disks = meta->raid[entry].total_disks;
2993 raid->total_sectors = raid->width * meta->raid[entry].sectors;
2994 raid->heads = 255;
2995 raid->sectors = 63;
2996 raid->cylinders = raid->total_sectors / (63 * 255);
2997 raid->offset_sectors = meta->raid[entry].offset;
2998 raid->rebuild_lba = 0;
2999 raid->lun = array;
3000
3001 raid->disks[disk_number].dev = parent;
3002 raid->disks[disk_number].sectors = raid->total_sectors / raid->width;
3003 raid->disks[disk_number].flags =
3004 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
3005 ars->raid[raid->volume] = raid;
3006 ars->disk_number[raid->volume] = disk_number;
3007 retval = 1;
3008 entry++;
3009 array++;
3010 }
3011
3012 lsiv3_out:
3013 kfree(meta, M_AR);
3014 return retval;
3015 }
3016
3017 /* nVidia MediaShield Metadata */
3018 static int
3019 ata_raid_nvidia_read_meta(device_t dev, struct ar_softc **raidp)
3020 {
3021 struct ata_raid_subdisk *ars = device_get_softc(dev);
3022 device_t parent = device_get_parent(dev);
3023 struct nvidia_raid_conf *meta;
3024 struct ar_softc *raid = NULL;
3025 u_int32_t checksum, *ptr;
3026 int array, count, retval = 0;
3027
3028 meta = (struct nvidia_raid_conf *)kmalloc(sizeof(struct nvidia_raid_conf),
3029 M_AR, M_WAITOK | M_ZERO);
3030
3031 if (ata_raid_rw(parent, NVIDIA_LBA(parent),
3032 meta, sizeof(struct nvidia_raid_conf), ATA_R_READ)) {
3033 if (testing || bootverbose)
3034 device_printf(parent, "nVidia read metadata failed\n");
3035 goto nvidia_out;
3036 }
3037
3038 /* check if this is a nVidia RAID struct */
3039 if (strncmp(meta->nvidia_id, NV_MAGIC, strlen(NV_MAGIC))) {
3040 if (testing || bootverbose)
3041 device_printf(parent, "nVidia check1 failed\n");
3042 goto nvidia_out;
3043 }
3044
3045 /* check if the checksum is OK */
3046 for (checksum = 0, ptr = (u_int32_t*)meta, count = 0;
3047 count < meta->config_size; count++)
3048 checksum += *ptr++;
3049 if (checksum) {
3050 if (testing || bootverbose)
3051 device_printf(parent, "nVidia check2 failed\n");
3052 goto nvidia_out;
3053 }
3054
3055 if (testing || bootverbose)
3056 ata_raid_nvidia_print_meta(meta);
3057
3058 /* now convert nVidia meta into our generic form */
3059 for (array = 0; array < MAX_ARRAYS; array++) {
3060 if (!raidp[array]) {
3061 raidp[array] =
3062 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
3063 M_WAITOK | M_ZERO);
3064 }
3065 raid = raidp[array];
3066 if (raid->format && (raid->format != AR_F_NVIDIA_RAID))
3067 continue;
3068
3069 if (raid->format == AR_F_NVIDIA_RAID &&
3070 ((raid->magic_0 != meta->magic_1) ||
3071 (raid->magic_1 != meta->magic_2))) {
3072 continue;
3073 }
3074
3075 switch (meta->type) {
3076 case NV_T_SPAN:
3077 raid->type = AR_T_SPAN;
3078 break;
3079
3080 case NV_T_RAID0:
3081 raid->type = AR_T_RAID0;
3082 break;
3083
3084 case NV_T_RAID1:
3085 raid->type = AR_T_RAID1;
3086 break;
3087
3088 case NV_T_RAID5:
3089 raid->type = AR_T_RAID5;
3090 break;
3091
3092 case NV_T_RAID01:
3093 raid->type = AR_T_RAID01;
3094 break;
3095
3096 default:
3097 device_printf(parent, "nVidia unknown RAID type 0x%02x\n",
3098 meta->type);
3099 kfree(raidp[array], M_AR);
3100 raidp[array] = NULL;
3101 goto nvidia_out;
3102 }
3103 raid->magic_0 = meta->magic_1;
3104 raid->magic_1 = meta->magic_2;
3105 raid->format = AR_F_NVIDIA_RAID;
3106 raid->generation = 0;
3107 raid->interleave = meta->stripe_sectors;
3108 raid->width = meta->array_width;
3109 raid->total_disks = meta->total_disks;
3110 raid->total_sectors = meta->total_sectors;
3111 raid->heads = 255;
3112 raid->sectors = 63;
3113 raid->cylinders = raid->total_sectors / (63 * 255);
3114 raid->offset_sectors = 0;
3115 raid->rebuild_lba = meta->rebuild_lba;
3116 raid->lun = array;
3117 raid->status = AR_S_READY;
3118 if (meta->status & NV_S_DEGRADED)
3119 raid->status |= AR_S_DEGRADED;
3120
3121 raid->disks[meta->disk_number].dev = parent;
3122 raid->disks[meta->disk_number].sectors =
3123 raid->total_sectors / raid->width;
3124 raid->disks[meta->disk_number].flags =
3125 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE);
3126 ars->raid[raid->volume] = raid;
3127 ars->disk_number[raid->volume] = meta->disk_number;
3128 retval = 1;
3129 break;
3130 }
3131
3132 nvidia_out:
3133 kfree(meta, M_AR);
3134 return retval;
3135 }
3136
3137 /* Promise FastTrak Metadata */
3138 static int
3139 ata_raid_promise_read_meta(device_t dev, struct ar_softc **raidp, int native)
3140 {
3141 struct ata_raid_subdisk *ars = device_get_softc(dev);
3142 device_t parent = device_get_parent(dev);
3143 struct promise_raid_conf *meta;
3144 struct ar_softc *raid;
3145 u_int32_t checksum, *ptr;
3146 int array, count, disk, disksum = 0, retval = 0;
3147
3148 meta = (struct promise_raid_conf *)
3149 kmalloc(sizeof(struct promise_raid_conf), M_AR, M_WAITOK | M_ZERO);
3150
3151 if (ata_raid_rw(parent, PROMISE_LBA(parent),
3152 meta, sizeof(struct promise_raid_conf), ATA_R_READ)) {
3153 if (testing || bootverbose)
3154 device_printf(parent, "%s read metadata failed\n",
3155 native ? "FreeBSD" : "Promise");
3156 goto promise_out;
3157 }
3158
3159 /* check the signature */
3160 if (native) {
3161 if (strncmp(meta->promise_id, ATA_MAGIC, strlen(ATA_MAGIC))) {
3162 if (testing || bootverbose)
3163 device_printf(parent, "FreeBSD check1 failed\n");
3164 goto promise_out;
3165 }
3166 }
3167 else {
3168 if (strncmp(meta->promise_id, PR_MAGIC, strlen(PR_MAGIC))) {
3169 if (testing || bootverbose)
3170 device_printf(parent, "Promise check1 failed\n");
3171 goto promise_out;
3172 }
3173 }
3174
3175 /* check if the checksum is OK */
3176 for (checksum = 0, ptr = (u_int32_t *)meta, count = 0; count < 511; count++)
3177 checksum += *ptr++;
3178 if (checksum != *ptr) {
3179 if (testing || bootverbose)
3180 device_printf(parent, "%s check2 failed\n",
3181 native ? "FreeBSD" : "Promise");
3182 goto promise_out;
3183 }
3184
3185 /* check on disk integrity status */
3186 if (meta->raid.integrity != PR_I_VALID) {
3187 if (testing || bootverbose)
3188 device_printf(parent, "%s check3 failed\n",
3189 native ? "FreeBSD" : "Promise");
3190 goto promise_out;
3191 }
3192
3193 if (testing || bootverbose)
3194 ata_raid_promise_print_meta(meta);
3195
3196 /* now convert Promise metadata into our generic form */
3197 for (array = 0; array < MAX_ARRAYS; array++) {
3198 if (!raidp[array]) {
3199 raidp[array] =
3200 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
3201 M_WAITOK | M_ZERO);
3202 }
3203 raid = raidp[array];
3204 if (raid->format &&
3205 (raid->format != (native ? AR_F_FREEBSD_RAID : AR_F_PROMISE_RAID)))
3206 continue;
3207
3208 if ((raid->format == (native ? AR_F_FREEBSD_RAID : AR_F_PROMISE_RAID))&&
3209 !(meta->raid.magic_1 == (raid->magic_1)))
3210 continue;
3211
3212 /* update our knowledge about the array config based on generation */
3213 if (!meta->raid.generation || meta->raid.generation > raid->generation){
3214 switch (meta->raid.type) {
3215 case PR_T_SPAN:
3216 raid->type = AR_T_SPAN;
3217 break;
3218
3219 case PR_T_JBOD:
3220 raid->type = AR_T_JBOD;
3221 break;
3222
3223 case PR_T_RAID0:
3224 raid->type = AR_T_RAID0;
3225 break;
3226
3227 case PR_T_RAID1:
3228 raid->type = AR_T_RAID1;
3229 if (meta->raid.array_width > 1)
3230 raid->type = AR_T_RAID01;
3231 break;
3232
3233 case PR_T_RAID5:
3234 raid->type = AR_T_RAID5;
3235 break;
3236
3237 default:
3238 device_printf(parent, "%s unknown RAID type 0x%02x\n",
3239 native ? "FreeBSD" : "Promise", meta->raid.type);
3240 kfree(raidp[array], M_AR);
3241 raidp[array] = NULL;
3242 goto promise_out;
3243 }
3244 raid->magic_1 = meta->raid.magic_1;
3245 raid->format = (native ? AR_F_FREEBSD_RAID : AR_F_PROMISE_RAID);
3246 raid->generation = meta->raid.generation;
3247 raid->interleave = 1 << meta->raid.stripe_shift;
3248 raid->width = meta->raid.array_width;
3249 raid->total_disks = meta->raid.total_disks;
3250 raid->heads = meta->raid.heads + 1;
3251 raid->sectors = meta->raid.sectors;
3252 raid->cylinders = meta->raid.cylinders + 1;
3253 raid->total_sectors = meta->raid.total_sectors;
3254 raid->offset_sectors = 0;
3255 raid->rebuild_lba = meta->raid.rebuild_lba;
3256 raid->lun = array;
3257 if ((meta->raid.status &
3258 (PR_S_VALID | PR_S_ONLINE | PR_S_INITED | PR_S_READY)) ==
3259 (PR_S_VALID | PR_S_ONLINE | PR_S_INITED | PR_S_READY)) {
3260 raid->status |= AR_S_READY;
3261 if (meta->raid.status & PR_S_DEGRADED)
3262 raid->status |= AR_S_DEGRADED;
3263 }
3264 else
3265 raid->status &= ~AR_S_READY;
3266
3267 /* convert disk flags to our internal types */
3268 for (disk = 0; disk < meta->raid.total_disks; disk++) {
3269 raid->disks[disk].dev = NULL;
3270 raid->disks[disk].flags = 0;
3271 *((u_int64_t *)(raid->disks[disk].serial)) =
3272 meta->raid.disk[disk].magic_0;
3273 disksum += meta->raid.disk[disk].flags;
3274 if (meta->raid.disk[disk].flags & PR_F_ONLINE)
3275 raid->disks[disk].flags |= AR_DF_ONLINE;
3276 if (meta->raid.disk[disk].flags & PR_F_ASSIGNED)
3277 raid->disks[disk].flags |= AR_DF_ASSIGNED;
3278 if (meta->raid.disk[disk].flags & PR_F_SPARE) {
3279 raid->disks[disk].flags &= ~(AR_DF_ONLINE | AR_DF_ASSIGNED);
3280 raid->disks[disk].flags |= AR_DF_SPARE;
3281 }
3282 if (meta->raid.disk[disk].flags & (PR_F_REDIR | PR_F_DOWN))
3283 raid->disks[disk].flags &= ~AR_DF_ONLINE;
3284 }
3285 if (!disksum) {
3286 device_printf(parent, "%s subdisks has no flags\n",
3287 native ? "FreeBSD" : "Promise");
3288 kfree(raidp[array], M_AR);
3289 raidp[array] = NULL;
3290 goto promise_out;
3291 }
3292 }
3293 if (meta->raid.generation >= raid->generation) {
3294 int disk_number = meta->raid.disk_number;
3295
3296 if (raid->disks[disk_number].flags && (meta->magic_0 ==
3297 *((u_int64_t *)(raid->disks[disk_number].serial)))) {
3298 raid->disks[disk_number].dev = parent;
3299 raid->disks[disk_number].flags |= AR_DF_PRESENT;
3300 raid->disks[disk_number].sectors = meta->raid.disk_sectors;
3301 if ((raid->disks[disk_number].flags &
3302 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE)) ==
3303 (AR_DF_PRESENT | AR_DF_ASSIGNED | AR_DF_ONLINE)) {
3304 ars->raid[raid->volume] = raid;
3305 ars->disk_number[raid->volume] = disk_number;
3306 retval = 1;
3307 }
3308 }
3309 }
3310 break;
3311 }
3312
3313 promise_out:
3314 kfree(meta, M_AR);
3315 return retval;
3316 }
3317
3318 static int
3319 ata_raid_promise_write_meta(struct ar_softc *rdp)
3320 {
3321 struct promise_raid_conf *meta;
3322 struct timeval timestamp;
3323 u_int32_t *ckptr;
3324 int count, disk, drive, error = 0;
3325
3326 meta = (struct promise_raid_conf *)
3327 kmalloc(sizeof(struct promise_raid_conf), M_AR, M_WAITOK);
3328
3329 rdp->generation++;
3330 microtime(&timestamp);
3331
3332 for (disk = 0; disk < rdp->total_disks; disk++) {
3333 for (count = 0; count < sizeof(struct promise_raid_conf); count++)
3334 *(((u_int8_t *)meta) + count) = 255 - (count % 256);
3335 meta->dummy_0 = 0x00020000;
3336 meta->raid.disk_number = disk;
3337
3338 if (rdp->disks[disk].dev) {
3339 struct ata_device *atadev = device_get_softc(rdp->disks[disk].dev);
3340 struct ata_channel *ch =
3341 device_get_softc(device_get_parent(rdp->disks[disk].dev));
3342
3343 meta->raid.channel = ch->unit;
3344 meta->raid.device = ATA_DEV(atadev->unit);
3345 meta->raid.disk_sectors = rdp->disks[disk].sectors;
3346 meta->raid.disk_offset = rdp->offset_sectors;
3347 }
3348 else {
3349 meta->raid.channel = 0;
3350 meta->raid.device = 0;
3351 meta->raid.disk_sectors = 0;
3352 meta->raid.disk_offset = 0;
3353 }
3354 meta->magic_0 = PR_MAGIC0(meta->raid) | timestamp.tv_sec;
3355 meta->magic_1 = timestamp.tv_sec >> 16;
3356 meta->magic_2 = timestamp.tv_sec;
3357 meta->raid.integrity = PR_I_VALID;
3358 meta->raid.magic_0 = meta->magic_0;
3359 meta->raid.rebuild_lba = rdp->rebuild_lba;
3360 meta->raid.generation = rdp->generation;
3361
3362 if (rdp->status & AR_S_READY) {
3363 meta->raid.flags = (PR_F_VALID | PR_F_ASSIGNED | PR_F_ONLINE);
3364 meta->raid.status =
3365 (PR_S_VALID | PR_S_ONLINE | PR_S_INITED | PR_S_READY);
3366 if (rdp->status & AR_S_DEGRADED)
3367 meta->raid.status |= PR_S_DEGRADED;
3368 else
3369 meta->raid.status |= PR_S_FUNCTIONAL;
3370 }
3371 else {
3372 meta->raid.flags = PR_F_DOWN;
3373 meta->raid.status = 0;
3374 }
3375
3376 switch (rdp->type) {
3377 case AR_T_RAID0:
3378 meta->raid.type = PR_T_RAID0;
3379 break;
3380 case AR_T_RAID1:
3381 meta->raid.type = PR_T_RAID1;
3382 break;
3383 case AR_T_RAID01:
3384 meta->raid.type = PR_T_RAID1;
3385 break;
3386 case AR_T_RAID5:
3387 meta->raid.type = PR_T_RAID5;
3388 break;
3389 case AR_T_SPAN:
3390 meta->raid.type = PR_T_SPAN;
3391 break;
3392 case AR_T_JBOD:
3393 meta->raid.type = PR_T_JBOD;
3394 break;
3395 default:
3396 kfree(meta, M_AR);
3397 return ENODEV;
3398 }
3399
3400 meta->raid.total_disks = rdp->total_disks;
3401 meta->raid.stripe_shift = ffs(rdp->interleave) - 1;
3402 meta->raid.array_width = rdp->width;
3403 meta->raid.array_number = rdp->lun;
3404 meta->raid.total_sectors = rdp->total_sectors;
3405 meta->raid.cylinders = rdp->cylinders - 1;
3406 meta->raid.heads = rdp->heads - 1;
3407 meta->raid.sectors = rdp->sectors;
3408 meta->raid.magic_1 = (u_int64_t)meta->magic_2<<16 | meta->magic_1;
3409
3410 bzero(&meta->raid.disk, 8 * 12);
3411 for (drive = 0; drive < rdp->total_disks; drive++) {
3412 meta->raid.disk[drive].flags = 0;
3413 if (rdp->disks[drive].flags & AR_DF_PRESENT)
3414 meta->raid.disk[drive].flags |= PR_F_VALID;
3415 if (rdp->disks[drive].flags & AR_DF_ASSIGNED)
3416 meta->raid.disk[drive].flags |= PR_F_ASSIGNED;
3417 if (rdp->disks[drive].flags & AR_DF_ONLINE)
3418 meta->raid.disk[drive].flags |= PR_F_ONLINE;
3419 else
3420 if (rdp->disks[drive].flags & AR_DF_PRESENT)
3421 meta->raid.disk[drive].flags = (PR_F_REDIR | PR_F_DOWN);
3422 if (rdp->disks[drive].flags & AR_DF_SPARE)
3423 meta->raid.disk[drive].flags |= PR_F_SPARE;
3424 meta->raid.disk[drive].dummy_0 = 0x0;
3425 if (rdp->disks[drive].dev) {
3426 struct ata_channel *ch =
3427 device_get_softc(device_get_parent(rdp->disks[drive].dev));
3428 struct ata_device *atadev =
3429 device_get_softc(rdp->disks[drive].dev);
3430
3431 meta->raid.disk[drive].channel = ch->unit;
3432 meta->raid.disk[drive].device = ATA_DEV(atadev->unit);
3433 }
3434 meta->raid.disk[drive].magic_0 =
3435 PR_MAGIC0(meta->raid.disk[drive]) | timestamp.tv_sec;
3436 }
3437
3438 if (rdp->disks[disk].dev) {
3439 if ((rdp->disks[disk].flags & (AR_DF_PRESENT | AR_DF_ONLINE)) ==
3440 (AR_DF_PRESENT | AR_DF_ONLINE)) {
3441 if (rdp->format == AR_F_FREEBSD_RAID)
3442 bcopy(ATA_MAGIC, meta->promise_id, sizeof(ATA_MAGIC));
3443 else
3444 bcopy(PR_MAGIC, meta->promise_id, sizeof(PR_MAGIC));
3445 }
3446 else
3447 bzero(meta->promise_id, sizeof(meta->promise_id));
3448 meta->checksum = 0;
3449 for (ckptr = (int32_t *)meta, count = 0; count < 511; count++)
3450 meta->checksum += *ckptr++;
3451 if (testing || bootverbose)
3452 ata_raid_promise_print_meta(meta);
3453 if (ata_raid_rw(rdp->disks[disk].dev,
3454 PROMISE_LBA(rdp->disks[disk].dev),
3455 meta, sizeof(struct promise_raid_conf),
3456 ATA_R_WRITE | ATA_R_DIRECT)) {
3457 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
3458 error = EIO;
3459 }
3460 }
3461 }
3462 kfree(meta, M_AR);
3463 return error;
3464 }
3465
3466 /* Silicon Image Medley Metadata */
3467 static int
3468 ata_raid_sii_read_meta(device_t dev, struct ar_softc **raidp)
3469 {
3470 struct ata_raid_subdisk *ars = device_get_softc(dev);
3471 device_t parent = device_get_parent(dev);
3472 struct sii_raid_conf *meta;
3473 struct ar_softc *raid = NULL;
3474 u_int16_t checksum, *ptr;
3475 int array, count, disk, retval = 0;
3476
3477 meta = (struct sii_raid_conf *)kmalloc(sizeof(struct sii_raid_conf), M_AR,
3478 M_WAITOK | M_ZERO);
3479
3480 if (ata_raid_rw(parent, SII_LBA(parent),
3481 meta, sizeof(struct sii_raid_conf), ATA_R_READ)) {
3482 if (testing || bootverbose)
3483 device_printf(parent, "Silicon Image read metadata failed\n");
3484 goto sii_out;
3485 }
3486
3487 /* check if this is a Silicon Image (Medley) RAID struct */
3488 for (checksum = 0, ptr = (u_int16_t *)meta, count = 0; count < 160; count++)
3489 checksum += *ptr++;
3490 if (checksum) {
3491 if (testing || bootverbose)
3492 device_printf(parent, "Silicon Image check1 failed\n");
3493 goto sii_out;
3494 }
3495
3496 for (checksum = 0, ptr = (u_int16_t *)meta, count = 0; count < 256; count++)
3497 checksum += *ptr++;
3498 if (checksum != meta->checksum_1) {
3499 if (testing || bootverbose)
3500 device_printf(parent, "Silicon Image check2 failed\n");
3501 goto sii_out;
3502 }
3503
3504 /* check verison */
3505 if (meta->version_major != 0x0002 ||
3506 (meta->version_minor != 0x0000 && meta->version_minor != 0x0001)) {
3507 if (testing || bootverbose)
3508 device_printf(parent, "Silicon Image check3 failed\n");
3509 goto sii_out;
3510 }
3511
3512 if (testing || bootverbose)
3513 ata_raid_sii_print_meta(meta);
3514
3515 /* now convert Silicon Image meta into our generic form */
3516 for (array = 0; array < MAX_ARRAYS; array++) {
3517 if (!raidp[array]) {
3518 raidp[array] =
3519 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
3520 M_WAITOK | M_ZERO);
3521 }
3522 raid = raidp[array];
3523 if (raid->format && (raid->format != AR_F_SII_RAID))
3524 continue;
3525
3526 if (raid->format == AR_F_SII_RAID &&
3527 (raid->magic_0 != *((u_int64_t *)meta->timestamp))) {
3528 continue;
3529 }
3530
3531 /* update our knowledge about the array config based on generation */
3532 if (!meta->generation || meta->generation > raid->generation) {
3533 switch (meta->type) {
3534 case SII_T_RAID0:
3535 raid->type = AR_T_RAID0;
3536 break;
3537
3538 case SII_T_RAID1:
3539 raid->type = AR_T_RAID1;
3540 break;
3541
3542 case SII_T_RAID01:
3543 raid->type = AR_T_RAID01;
3544 break;
3545
3546 case SII_T_SPARE:
3547 device_printf(parent, "Silicon Image SPARE disk\n");
3548 kfree(raidp[array], M_AR);
3549 raidp[array] = NULL;
3550 goto sii_out;
3551
3552 default:
3553 device_printf(parent,"Silicon Image unknown RAID type 0x%02x\n",
3554 meta->type);
3555 kfree(raidp[array], M_AR);
3556 raidp[array] = NULL;
3557 goto sii_out;
3558 }
3559 raid->magic_0 = *((u_int64_t *)meta->timestamp);
3560 raid->format = AR_F_SII_RAID;
3561 raid->generation = meta->generation;
3562 raid->interleave = meta->stripe_sectors;
3563 raid->width = (meta->raid0_disks != 0xff) ? meta->raid0_disks : 1;
3564 raid->total_disks =
3565 ((meta->raid0_disks != 0xff) ? meta->raid0_disks : 0) +
3566 ((meta->raid1_disks != 0xff) ? meta->raid1_disks : 0);
3567 raid->total_sectors = meta->total_sectors;
3568 raid->heads = 255;
3569 raid->sectors = 63;
3570 raid->cylinders = raid->total_sectors / (63 * 255);
3571 raid->offset_sectors = 0;
3572 raid->rebuild_lba = meta->rebuild_lba;
3573 raid->lun = array;
3574 strncpy(raid->name, meta->name,
3575 min(sizeof(raid->name), sizeof(meta->name)));
3576
3577 /* clear out any old info */
3578 if (raid->generation) {
3579 for (disk = 0; disk < raid->total_disks; disk++) {
3580 raid->disks[disk].dev = NULL;
3581 raid->disks[disk].flags = 0;
3582 }
3583 }
3584 }
3585 if (meta->generation >= raid->generation) {
3586 /* XXX SOS add check for the right physical disk by serial# */
3587 if (meta->status & SII_S_READY) {
3588 int disk_number = (raid->type == AR_T_RAID01) ?
3589 meta->raid1_ident + (meta->raid0_ident << 1) :
3590 meta->disk_number;
3591
3592 raid->disks[disk_number].dev = parent;
3593 raid->disks[disk_number].sectors =
3594 raid->total_sectors / raid->width;
3595 raid->disks[disk_number].flags =
3596 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
3597 ars->raid[raid->volume] = raid;
3598 ars->disk_number[raid->volume] = disk_number;
3599 retval = 1;
3600 }
3601 }
3602 break;
3603 }
3604
3605 sii_out:
3606 kfree(meta, M_AR);
3607 return retval;
3608 }
3609
3610 /* Silicon Integrated Systems Metadata */
3611 static int
3612 ata_raid_sis_read_meta(device_t dev, struct ar_softc **raidp)
3613 {
3614 struct ata_raid_subdisk *ars = device_get_softc(dev);
3615 device_t parent = device_get_parent(dev);
3616 struct sis_raid_conf *meta;
3617 struct ar_softc *raid = NULL;
3618 int array, disk_number, drive, retval = 0;
3619
3620 meta = (struct sis_raid_conf *)kmalloc(sizeof(struct sis_raid_conf), M_AR,
3621 M_WAITOK | M_ZERO);
3622
3623 if (ata_raid_rw(parent, SIS_LBA(parent),
3624 meta, sizeof(struct sis_raid_conf), ATA_R_READ)) {
3625 if (testing || bootverbose)
3626 device_printf(parent,
3627 "Silicon Integrated Systems read metadata failed\n");
3628 }
3629
3630 /* check for SiS magic */
3631 if (meta->magic != SIS_MAGIC) {
3632 if (testing || bootverbose)
3633 device_printf(parent,
3634 "Silicon Integrated Systems check1 failed\n");
3635 goto sis_out;
3636 }
3637
3638 if (testing || bootverbose)
3639 ata_raid_sis_print_meta(meta);
3640
3641 /* now convert SiS meta into our generic form */
3642 for (array = 0; array < MAX_ARRAYS; array++) {
3643 if (!raidp[array]) {
3644 raidp[array] =
3645 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
3646 M_WAITOK | M_ZERO);
3647 }
3648
3649 raid = raidp[array];
3650 if (raid->format && (raid->format != AR_F_SIS_RAID))
3651 continue;
3652
3653 if ((raid->format == AR_F_SIS_RAID) &&
3654 ((raid->magic_0 != meta->controller_pci_id) ||
3655 (raid->magic_1 != meta->timestamp))) {
3656 continue;
3657 }
3658
3659 switch (meta->type_total_disks & SIS_T_MASK) {
3660 case SIS_T_JBOD:
3661 raid->type = AR_T_JBOD;
3662 raid->width = (meta->type_total_disks & SIS_D_MASK);
3663 raid->total_sectors += SIS_LBA(parent);
3664 break;
3665
3666 case SIS_T_RAID0:
3667 raid->type = AR_T_RAID0;
3668 raid->width = (meta->type_total_disks & SIS_D_MASK);
3669 if (!raid->total_sectors ||
3670 (raid->total_sectors > (raid->width * SIS_LBA(parent))))
3671 raid->total_sectors = raid->width * SIS_LBA(parent);
3672 break;
3673
3674 case SIS_T_RAID1:
3675 raid->type = AR_T_RAID1;
3676 raid->width = 1;
3677 if (!raid->total_sectors || (raid->total_sectors > SIS_LBA(parent)))
3678 raid->total_sectors = SIS_LBA(parent);
3679 break;
3680
3681 default:
3682 device_printf(parent, "Silicon Integrated Systems "
3683 "unknown RAID type 0x%08x\n", meta->magic);
3684 kfree(raidp[array], M_AR);
3685 raidp[array] = NULL;
3686 goto sis_out;
3687 }
3688 raid->magic_0 = meta->controller_pci_id;
3689 raid->magic_1 = meta->timestamp;
3690 raid->format = AR_F_SIS_RAID;
3691 raid->generation = 0;
3692 raid->interleave = meta->stripe_sectors;
3693 raid->total_disks = (meta->type_total_disks & SIS_D_MASK);
3694 raid->heads = 255;
3695 raid->sectors = 63;
3696 raid->cylinders = raid->total_sectors / (63 * 255);
3697 raid->offset_sectors = 0;
3698 raid->rebuild_lba = 0;
3699 raid->lun = array;
3700 /* XXX SOS if total_disks > 2 this doesn't float */
3701 if (((meta->disks & SIS_D_MASTER) >> 4) == meta->disk_number)
3702 disk_number = 0;
3703 else
3704 disk_number = 1;
3705
3706 for (drive = 0; drive < raid->total_disks; drive++) {
3707 raid->disks[drive].sectors = raid->total_sectors/raid->width;
3708 if (drive == disk_number) {
3709 raid->disks[disk_number].dev = parent;
3710 raid->disks[disk_number].flags =
3711 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
3712 ars->raid[raid->volume] = raid;
3713 ars->disk_number[raid->volume] = disk_number;
3714 }
3715 }
3716 retval = 1;
3717 break;
3718 }
3719
3720 sis_out:
3721 kfree(meta, M_AR);
3722 return retval;
3723 }
3724
3725 static int
3726 ata_raid_sis_write_meta(struct ar_softc *rdp)
3727 {
3728 struct sis_raid_conf *meta;
3729 struct timeval timestamp;
3730 int disk, error = 0;
3731
3732 meta = (struct sis_raid_conf *)kmalloc(sizeof(struct sis_raid_conf), M_AR,
3733 M_WAITOK | M_ZERO);
3734
3735 rdp->generation++;
3736 microtime(&timestamp);
3737
3738 meta->magic = SIS_MAGIC;
3739 /* XXX SOS if total_disks > 2 this doesn't float */
3740 for (disk = 0; disk < rdp->total_disks; disk++) {
3741 if (rdp->disks[disk].dev) {
3742 struct ata_channel *ch =
3743 device_get_softc(device_get_parent(rdp->disks[disk].dev));
3744 struct ata_device *atadev = device_get_softc(rdp->disks[disk].dev);
3745 int disk_number = 1 + ATA_DEV(atadev->unit) + (ch->unit << 1);
3746
3747 meta->disks |= disk_number << ((1 - disk) << 2);
3748 }
3749 }
3750 switch (rdp->type) {
3751 case AR_T_JBOD:
3752 meta->type_total_disks = SIS_T_JBOD;
3753 break;
3754
3755 case AR_T_RAID0:
3756 meta->type_total_disks = SIS_T_RAID0;
3757 break;
3758
3759 case AR_T_RAID1:
3760 meta->type_total_disks = SIS_T_RAID1;
3761 break;
3762
3763 default:
3764 kfree(meta, M_AR);
3765 return ENODEV;
3766 }
3767 meta->type_total_disks |= (rdp->total_disks & SIS_D_MASK);
3768 meta->stripe_sectors = rdp->interleave;
3769 meta->timestamp = timestamp.tv_sec;
3770
3771 for (disk = 0; disk < rdp->total_disks; disk++) {
3772 if (rdp->disks[disk].dev) {
3773 struct ata_channel *ch =
3774 device_get_softc(device_get_parent(rdp->disks[disk].dev));
3775 struct ata_device *atadev = device_get_softc(rdp->disks[disk].dev);
3776
3777 meta->controller_pci_id =
3778 (pci_get_vendor(GRANDPARENT(rdp->disks[disk].dev)) << 16) |
3779 pci_get_device(GRANDPARENT(rdp->disks[disk].dev));
3780 bcopy(atadev->param.model, meta->model, sizeof(meta->model));
3781
3782 /* XXX SOS if total_disks > 2 this may not float */
3783 meta->disk_number = 1 + ATA_DEV(atadev->unit) + (ch->unit << 1);
3784
3785 if (testing || bootverbose)
3786 ata_raid_sis_print_meta(meta);
3787
3788 if (ata_raid_rw(rdp->disks[disk].dev,
3789 SIS_LBA(rdp->disks[disk].dev),
3790 meta, sizeof(struct sis_raid_conf),
3791 ATA_R_WRITE | ATA_R_DIRECT)) {
3792 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
3793 error = EIO;
3794 }
3795 }
3796 }
3797 kfree(meta, M_AR);
3798 return error;
3799 }
3800
3801 /* VIA Tech V-RAID Metadata */
3802 static int
3803 ata_raid_via_read_meta(device_t dev, struct ar_softc **raidp)
3804 {
3805 struct ata_raid_subdisk *ars = device_get_softc(dev);
3806 device_t parent = device_get_parent(dev);
3807 struct via_raid_conf *meta;
3808 struct ar_softc *raid = NULL;
3809 u_int8_t checksum, *ptr;
3810 int array, count, disk, retval = 0;
3811
3812 meta = (struct via_raid_conf *)kmalloc(sizeof(struct via_raid_conf), M_AR,
3813 M_WAITOK | M_ZERO);
3814
3815 if (ata_raid_rw(parent, VIA_LBA(parent),
3816 meta, sizeof(struct via_raid_conf), ATA_R_READ)) {
3817 if (testing || bootverbose)
3818 device_printf(parent, "VIA read metadata failed\n");
3819 goto via_out;
3820 }
3821
3822 /* check if this is a VIA RAID struct */
3823 if (meta->magic != VIA_MAGIC) {
3824 if (testing || bootverbose)
3825 device_printf(parent, "VIA check1 failed\n");
3826 goto via_out;
3827 }
3828
3829 /* calculate checksum and compare for valid */
3830 for (checksum = 0, ptr = (u_int8_t *)meta, count = 0; count < 50; count++)
3831 checksum += *ptr++;
3832 if (checksum != meta->checksum) {
3833 if (testing || bootverbose)
3834 device_printf(parent, "VIA check2 failed\n");
3835 goto via_out;
3836 }
3837
3838 if (testing || bootverbose)
3839 ata_raid_via_print_meta(meta);
3840
3841 /* now convert VIA meta into our generic form */
3842 for (array = 0; array < MAX_ARRAYS; array++) {
3843 if (!raidp[array]) {
3844 raidp[array] =
3845 (struct ar_softc *)kmalloc(sizeof(struct ar_softc), M_AR,
3846 M_WAITOK | M_ZERO);
3847 }
3848 raid = raidp[array];
3849 if (raid->format && (raid->format != AR_F_VIA_RAID))
3850 continue;
3851
3852 if (raid->format == AR_F_VIA_RAID && (raid->magic_0 != meta->disks[0]))
3853 continue;
3854
3855 switch (meta->type & VIA_T_MASK) {
3856 case VIA_T_RAID0:
3857 raid->type = AR_T_RAID0;
3858 raid->width = meta->stripe_layout & VIA_L_DISKS;
3859 if (!raid->total_sectors ||
3860 (raid->total_sectors > (raid->width * meta->disk_sectors)))
3861 raid->total_sectors = raid->width * meta->disk_sectors;
3862 break;
3863
3864 case VIA_T_RAID1:
3865 raid->type = AR_T_RAID1;
3866 raid->width = 1;
3867 raid->total_sectors = meta->disk_sectors;
3868 break;
3869
3870 case VIA_T_RAID01:
3871 raid->type = AR_T_RAID01;
3872 raid->width = meta->stripe_layout & VIA_L_DISKS;
3873 if (!raid->total_sectors ||
3874 (raid->total_sectors > (raid->width * meta->disk_sectors)))
3875 raid->total_sectors = raid->width * meta->disk_sectors;
3876 break;
3877
3878 case VIA_T_RAID5:
3879 raid->type = AR_T_RAID5;
3880 raid->width = meta->stripe_layout & VIA_L_DISKS;
3881 if (!raid->total_sectors ||
3882 (raid->total_sectors > ((raid->width - 1)*meta->disk_sectors)))
3883 raid->total_sectors = (raid->width - 1) * meta->disk_sectors;
3884 break;
3885
3886 case VIA_T_SPAN:
3887 raid->type = AR_T_SPAN;
3888 raid->width = 1;
3889 raid->total_sectors += meta->disk_sectors;
3890 break;
3891
3892 default:
3893 device_printf(parent,"VIA unknown RAID type 0x%02x\n", meta->type);
3894 kfree(raidp[array], M_AR);
3895 raidp[array] = NULL;
3896 goto via_out;
3897 }
3898 raid->magic_0 = meta->disks[0];
3899 raid->format = AR_F_VIA_RAID;
3900 raid->generation = 0;
3901 raid->interleave =
3902 0x08 << ((meta->stripe_layout & VIA_L_MASK) >> VIA_L_SHIFT);
3903 for (count = 0, disk = 0; disk < 8; disk++)
3904 if (meta->disks[disk])
3905 count++;
3906 raid->total_disks = count;
3907 raid->heads = 255;
3908 raid->sectors = 63;
3909 raid->cylinders = raid->total_sectors / (63 * 255);
3910 raid->offset_sectors = 0;
3911 raid->rebuild_lba = 0;
3912 raid->lun = array;
3913
3914 for (disk = 0; disk < raid->total_disks; disk++) {
3915 if (meta->disks[disk] == meta->disk_id) {
3916 raid->disks[disk].dev = parent;
3917 bcopy(&meta->disk_id, raid->disks[disk].serial,
3918 sizeof(u_int32_t));
3919 raid->disks[disk].sectors = meta->disk_sectors;
3920 raid->disks[disk].flags =
3921 (AR_DF_ONLINE | AR_DF_PRESENT | AR_DF_ASSIGNED);
3922 ars->raid[raid->volume] = raid;
3923 ars->disk_number[raid->volume] = disk;
3924 retval = 1;
3925 break;
3926 }
3927 }
3928 break;
3929 }
3930
3931 via_out:
3932 kfree(meta, M_AR);
3933 return retval;
3934 }
3935
3936 static int
3937 ata_raid_via_write_meta(struct ar_softc *rdp)
3938 {
3939 struct via_raid_conf *meta;
3940 int disk, error = 0;
3941
3942 meta = (struct via_raid_conf *)kmalloc(sizeof(struct via_raid_conf), M_AR,
3943 M_WAITOK | M_ZERO);
3944
3945 rdp->generation++;
3946
3947 meta->magic = VIA_MAGIC;
3948 meta->dummy_0 = 0x02;
3949 switch (rdp->type) {
3950 case AR_T_SPAN:
3951 meta->type = VIA_T_SPAN;
3952 meta->stripe_layout = (rdp->total_disks & VIA_L_DISKS);
3953 break;
3954
3955 case AR_T_RAID0:
3956 meta->type = VIA_T_RAID0;
3957 meta->stripe_layout = ((rdp->interleave >> 1) & VIA_L_MASK);
3958 meta->stripe_layout |= (rdp->total_disks & VIA_L_DISKS);
3959 break;
3960
3961 case AR_T_RAID1:
3962 meta->type = VIA_T_RAID1;
3963 meta->stripe_layout = (rdp->total_disks & VIA_L_DISKS);
3964 break;
3965
3966 case AR_T_RAID5:
3967 meta->type = VIA_T_RAID5;
3968 meta->stripe_layout = ((rdp->interleave >> 1) & VIA_L_MASK);
3969 meta->stripe_layout |= (rdp->total_disks & VIA_L_DISKS);
3970 break;
3971
3972 case AR_T_RAID01:
3973 meta->type = VIA_T_RAID01;
3974 meta->stripe_layout = ((rdp->interleave >> 1) & VIA_L_MASK);
3975 meta->stripe_layout |= (rdp->width & VIA_L_DISKS);
3976 break;
3977
3978 default:
3979 kfree(meta, M_AR);
3980 return ENODEV;
3981 }
3982 meta->type |= VIA_T_BOOTABLE; /* XXX SOS */
3983 meta->disk_sectors =
3984 rdp->total_sectors / (rdp->width - (rdp->type == AR_RAID5));
3985 for (disk = 0; disk < rdp->total_disks; disk++)
3986 meta->disks[disk] = (u_int32_t)(uintptr_t)rdp->disks[disk].dev;
3987
3988 for (disk = 0; disk < rdp->total_disks; disk++) {
3989 if (rdp->disks[disk].dev) {
3990 u_int8_t *ptr;
3991 int count;
3992
3993 meta->disk_index = disk * sizeof(u_int32_t);
3994 if (rdp->type == AR_T_RAID01)
3995 meta->disk_index = ((meta->disk_index & 0x08) << 2) |
3996 (meta->disk_index & ~0x08);
3997 meta->disk_id = meta->disks[disk];
3998 meta->checksum = 0;
3999 for (ptr = (u_int8_t *)meta, count = 0; count < 50; count++)
4000 meta->checksum += *ptr++;
4001
4002 if (testing || bootverbose)
4003 ata_raid_via_print_meta(meta);
4004
4005 if (ata_raid_rw(rdp->disks[disk].dev,
4006 VIA_LBA(rdp->disks[disk].dev),
4007 meta, sizeof(struct via_raid_conf),
4008 ATA_R_WRITE | ATA_R_DIRECT)) {
4009 device_printf(rdp->disks[disk].dev, "write metadata failed\n");
4010 error = EIO;
4011 }
4012 }
4013 }
4014 kfree(meta, M_AR);
4015 return error;
4016 }
4017
4018 static struct ata_request *
4019 ata_raid_init_request(struct ar_softc *rdp, struct bio *bio)
4020 {
4021 struct ata_request *request;
4022
4023 if (!(request = ata_alloc_request())) {
4024 kprintf("FAILURE - out of memory in ata_raid_init_request\n");
4025 return NULL;
4026 }
4027 request->timeout = ATA_DEFAULT_TIMEOUT;
4028 request->retries = 2;
4029 request->callback = ata_raid_done;
4030 request->driver = rdp;
4031 request->bio = bio;
4032 switch (request->bio->bio_buf->b_cmd) {
4033 case BUF_CMD_READ:
4034 request->flags = ATA_R_READ;
4035 break;
4036 case BUF_CMD_WRITE:
4037 request->flags = ATA_R_WRITE;
4038 break;
4039 case BUF_CMD_FLUSH:
4040 request->flags = ATA_R_CONTROL;
4041 break;
4042 default:
4043 kprintf("ar%d: FAILURE - unknown BUF operation\n", rdp->lun);
4044 ata_free_request(request);
4045 return(NULL);
4046 }
4047 return request;
4048 }
4049
4050 static int
4051 ata_raid_send_request(struct ata_request *request)
4052 {
4053 struct ata_device *atadev = device_get_softc(request->dev);
4054
4055 request->transfersize = min(request->bytecount, atadev->max_iosize);
4056 if (request->flags & ATA_R_READ) {
4057 if (atadev->mode >= ATA_DMA) {
4058 request->flags |= ATA_R_DMA;
4059 request->u.ata.command = ATA_READ_DMA;
4060 }
4061 else if (atadev->max_iosize > DEV_BSIZE)
4062 request->u.ata.command = ATA_READ_MUL;
4063 else
4064 request->u.ata.command = ATA_READ;
4065 }
4066 else if (request->flags & ATA_R_WRITE) {
4067 if (atadev->mode >= ATA_DMA) {
4068 request->flags |= ATA_R_DMA;
4069 request->u.ata.command = ATA_WRITE_DMA;
4070 }
4071 else if (atadev->max_iosize > DEV_BSIZE)
4072 request->u.ata.command = ATA_WRITE_MUL;
4073 else
4074 request->u.ata.command = ATA_WRITE;
4075 }
4076 else {
4077 device_printf(request->dev, "FAILURE - unknown IO operation\n");
4078 ata_free_request(request);
4079 return EIO;
4080 }
4081 request->flags |= (ATA_R_ORDERED | ATA_R_THREAD);
4082 ata_queue_request(request);
4083 return 0;
4084 }
4085
4086 static int
4087 ata_raid_rw(device_t dev, u_int64_t lba, void *data, u_int bcount, int flags)
4088 {
4089 struct ata_device *atadev = device_get_softc(dev);
4090 struct ata_request *request;
4091 int error;
4092
4093 if (bcount % DEV_BSIZE) {
4094 device_printf(dev, "FAILURE - transfers must be modulo sectorsize\n");
4095 return ENOMEM;
4096 }
4097
4098 if (!(request = ata_alloc_request())) {
4099 device_printf(dev, "FAILURE - out of memory in ata_raid_rw\n");
4100 return ENOMEM;
4101 }
4102
4103 /* setup request */
4104 request->dev = dev;
4105 request->timeout = ATA_DEFAULT_TIMEOUT;
4106 request->retries = 0;
4107 request->data = data;
4108 request->bytecount = bcount;
4109 request->transfersize = DEV_BSIZE;
4110 request->u.ata.lba = lba;
4111 request->u.ata.count = request->bytecount / DEV_BSIZE;
4112 request->flags = flags;
4113
4114 if (flags & ATA_R_READ) {
4115 if (atadev->mode >= ATA_DMA) {
4116 request->u.ata.command = ATA_READ_DMA;
4117 request->flags |= ATA_R_DMA;
4118 }
4119 else
4120 request->u.ata.command = ATA_READ;
4121 ata_queue_request(request);
4122 }
4123 else if (flags & ATA_R_WRITE) {
4124 if (atadev->mode >= ATA_DMA) {
4125 request->u.ata.command = ATA_WRITE_DMA;
4126 request->flags |= ATA_R_DMA;
4127 }
4128 else
4129 request->u.ata.command = ATA_WRITE;
4130 ata_queue_request(request);
4131 }
4132 else {
4133 device_printf(dev, "FAILURE - unknown IO operation\n");
4134 request->result = EIO;
4135 }
4136 error = request->result;
4137 ata_free_request(request);
4138 return error;
4139 }
4140
4141 /*
4142 * module handeling
4143 */
4144 static int
4145 ata_raid_subdisk_probe(device_t dev)
4146 {
4147 device_quiet(dev);
4148 return 0;
4149 }
4150
4151 static int
4152 ata_raid_subdisk_attach(device_t dev)
4153 {
4154 struct ata_raid_subdisk *ars = device_get_softc(dev);
4155 int volume;
4156
4157 for (volume = 0; volume < MAX_VOLUMES; volume++) {
4158 ars->raid[volume] = NULL;
4159 ars->disk_number[volume] = -1;
4160 }
4161 ata_raid_read_metadata(dev);
4162 return 0;
4163 }
4164
4165 static int
4166 ata_raid_subdisk_detach(device_t dev)
4167 {
4168 struct ata_raid_subdisk *ars = device_get_softc(dev);
4169 int volume;
4170
4171 for (volume = 0; volume < MAX_VOLUMES; volume++) {
4172 if (ars->raid[volume]) {
4173 ars->raid[volume]->disks[ars->disk_number[volume]].flags &=
4174 ~(AR_DF_PRESENT | AR_DF_ONLINE);
4175 ars->raid[volume]->disks[ars->disk_number[volume]].dev = NULL;
4176 #if 0
4177 if (mtx_initialized(&ars->raid[volume]->lock))
4178 #endif
4179 ata_raid_config_changed(ars->raid[volume], 1);
4180 ars->raid[volume] = NULL;
4181 ars->disk_number[volume] = -1;
4182 }
4183 }
4184 return 0;
4185 }
4186
4187 static device_method_t ata_raid_sub_methods[] = {
4188 /* device interface */
4189 DEVMETHOD(device_probe, ata_raid_subdisk_probe),
4190 DEVMETHOD(device_attach, ata_raid_subdisk_attach),
4191 DEVMETHOD(device_detach, ata_raid_subdisk_detach),
4192 DEVMETHOD_END
4193 };
4194
4195 static driver_t ata_raid_sub_driver = {
4196 "subdisk",
4197 ata_raid_sub_methods,
4198 sizeof(struct ata_raid_subdisk)
4199 };
4200
4201 DRIVER_MODULE(subdisk, ad, ata_raid_sub_driver, ata_raid_sub_devclass, NULL, NULL);
4202
4203 static int
4204 ata_raid_module_event_handler(module_t mod, int what, void *arg)
4205 {
4206 int i;
4207
4208 switch (what) {
4209 case MOD_LOAD:
4210 if (testing || bootverbose)
4211 kprintf("ATA PseudoRAID loaded\n");
4212 #if 0
4213 /* setup table to hold metadata for all ATA PseudoRAID arrays */
4214 ata_raid_arrays = kmalloc(sizeof(struct ar_soft *) * MAX_ARRAYS,
4215 M_AR, M_WAITOK | M_ZERO);
4216 #endif
4217 /* attach found PseudoRAID arrays */
4218 for (i = 0; i < MAX_ARRAYS; i++) {
4219 struct ar_softc *rdp = ata_raid_arrays[i];
4220
4221 if (!rdp || !rdp->format)
4222 continue;
4223 if (testing || bootverbose)
4224 ata_raid_print_meta(rdp);
4225 ata_raid_attach(rdp, 0);
4226 }
4227 ata_raid_ioctl_func = ata_raid_ioctl;
4228 return 0;
4229
4230 case MOD_UNLOAD:
4231 /* detach found PseudoRAID arrays */
4232 for (i = 0; i < MAX_ARRAYS; i++) {
4233 struct ar_softc *rdp = ata_raid_arrays[i];
4234
4235 if (!rdp || !rdp->status)
4236 continue;
4237 #if 0
4238 if (mtx_initialized(&rdp->lock))
4239 lockuninit(&rdp->lock);
4240 #endif
4241 disk_destroy(&rdp->disk);
4242 }
4243 if (testing || bootverbose)
4244 kprintf("ATA PseudoRAID unloaded\n");
4245 #if 0
4246 kfree(ata_raid_arrays, M_AR);
4247 #endif
4248 ata_raid_ioctl_func = NULL;
4249 return 0;
4250
4251 default:
4252 return EOPNOTSUPP;
4253 }
4254 }
4255
4256 static moduledata_t ata_raid_moduledata =
4257 { "ataraid", ata_raid_module_event_handler, NULL };
4258 DECLARE_MODULE(ata, ata_raid_moduledata, SI_SUB_RAID, SI_ORDER_FIRST);
4259 MODULE_VERSION(ataraid, 1);
4260 MODULE_DEPEND(ataraid, ata, 1, 1, 1);
4261 MODULE_DEPEND(ataraid, ad, 1, 1, 1);
4262
4263 static char *
4264 ata_raid_format(struct ar_softc *rdp)
4265 {
4266 switch (rdp->format) {
4267 case AR_F_FREEBSD_RAID: return "FreeBSD PseudoRAID";
4268 case AR_F_ADAPTEC_RAID: return "Adaptec HostRAID";
4269 case AR_F_HPTV2_RAID: return "HighPoint v2 RocketRAID";
4270 case AR_F_HPTV3_RAID: return "HighPoint v3 RocketRAID";
4271 case AR_F_INTEL_RAID: return "Intel MatrixRAID";
4272 case AR_F_ITE_RAID: return "Integrated Technology Express";
4273 case AR_F_JMICRON_RAID: return "JMicron Technology Corp";
4274 case AR_F_LSIV2_RAID: return "LSILogic v2 MegaRAID";
4275 case AR_F_LSIV3_RAID: return "LSILogic v3 MegaRAID";
4276 case AR_F_NVIDIA_RAID: return "nVidia MediaShield";
4277 case AR_F_PROMISE_RAID: return "Promise Fasttrak";
4278 case AR_F_SII_RAID: return "Silicon Image Medley";
4279 case AR_F_SIS_RAID: return "Silicon Integrated Systems";
4280 case AR_F_VIA_RAID: return "VIA Tech V-RAID";
4281 default: return "UNKNOWN";
4282 }
4283 }
4284
4285 static char *
4286 ata_raid_type(struct ar_softc *rdp)
4287 {
4288 switch (rdp->type) {
4289 case AR_T_JBOD: return "JBOD";
4290 case AR_T_SPAN: return "SPAN";
4291 case AR_T_RAID0: return "RAID0";
4292 case AR_T_RAID1: return "RAID1";
4293 case AR_T_RAID3: return "RAID3";
4294 case AR_T_RAID4: return "RAID4";
4295 case AR_T_RAID5: return "RAID5";
4296 case AR_T_RAID01: return "RAID0+1";
4297 default: return "UNKNOWN";
4298 }
4299 }
4300
4301 static char *
4302 ata_raid_flags(struct ar_softc *rdp)
4303 {
4304 switch (rdp->status & (AR_S_READY | AR_S_DEGRADED | AR_S_REBUILDING)) {
4305 case AR_S_READY: return "READY";
4306 case AR_S_READY | AR_S_DEGRADED: return "DEGRADED";
4307 case AR_S_READY | AR_S_REBUILDING:
4308 case AR_S_READY | AR_S_DEGRADED | AR_S_REBUILDING: return "REBUILDING";
4309 default: return "BROKEN";
4310 }
4311 }
4312
4313 /* debugging gunk */
4314 static void
4315 ata_raid_print_meta(struct ar_softc *raid)
4316 {
4317 int i;
4318
4319 kprintf("********** ATA PseudoRAID ar%d Metadata **********\n", raid->lun);
4320 kprintf("=================================================\n");
4321 kprintf("format %s\n", ata_raid_format(raid));
4322 kprintf("type %s\n", ata_raid_type(raid));
4323 kprintf("flags 0x%02x %b\n", raid->status, raid->status,
4324 "\20\3REBUILDING\2DEGRADED\1READY\n");
4325 kprintf("magic_0 0x%016jx\n", raid->magic_0);
4326 kprintf("magic_1 0x%016jx\n",raid->magic_1);
4327 kprintf("generation %u\n", raid->generation);
4328 kprintf("total_sectors %ju\n", raid->total_sectors);
4329 kprintf("offset_sectors %ju\n", raid->offset_sectors);
4330 kprintf("heads %u\n", raid->heads);
4331 kprintf("sectors %u\n", raid->sectors);
4332 kprintf("cylinders %u\n", raid->cylinders);
4333 kprintf("width %u\n", raid->width);
4334 kprintf("interleave %u\n", raid->interleave);
4335 kprintf("total_disks %u\n", raid->total_disks);
4336 for (i = 0; i < raid->total_disks; i++) {
4337 kprintf(" disk %d: flags = 0x%02x %b\n", i, raid->disks[i].flags,
4338 raid->disks[i].flags, "\20\4ONLINE\3SPARE\2ASSIGNED\1PRESENT\n");
4339 if (raid->disks[i].dev) {
4340 kprintf(" ");
4341 device_printf(raid->disks[i].dev, " sectors %jd\n",
4342 raid->disks[i].sectors);
4343 }
4344 }
4345 kprintf("=================================================\n");
4346 }
4347
4348 static char *
4349 ata_raid_adaptec_type(int type)
4350 {
4351 static char buffer[16];
4352
4353 switch (type) {
4354 case ADP_T_RAID0: return "RAID0";
4355 case ADP_T_RAID1: return "RAID1";
4356 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4357 return buffer;
4358 }
4359 }
4360
4361 static void
4362 ata_raid_adaptec_print_meta(struct adaptec_raid_conf *meta)
4363 {
4364 int i;
4365
4366 kprintf("********* ATA Adaptec HostRAID Metadata *********\n");
4367 kprintf("magic_0 <0x%08x>\n", be32toh(meta->magic_0));
4368 kprintf("generation 0x%08x\n", be32toh(meta->generation));
4369 kprintf("dummy_0 0x%04x\n", be16toh(meta->dummy_0));
4370 kprintf("total_configs %u\n", be16toh(meta->total_configs));
4371 kprintf("dummy_1 0x%04x\n", be16toh(meta->dummy_1));
4372 kprintf("checksum 0x%04x\n", be16toh(meta->checksum));
4373 kprintf("dummy_2 0x%08x\n", be32toh(meta->dummy_2));
4374 kprintf("dummy_3 0x%08x\n", be32toh(meta->dummy_3));
4375 kprintf("flags 0x%08x\n", be32toh(meta->flags));
4376 kprintf("timestamp 0x%08x\n", be32toh(meta->timestamp));
4377 kprintf("dummy_4 0x%08x 0x%08x 0x%08x 0x%08x\n",
4378 be32toh(meta->dummy_4[0]), be32toh(meta->dummy_4[1]),
4379 be32toh(meta->dummy_4[2]), be32toh(meta->dummy_4[3]));
4380 kprintf("dummy_5 0x%08x 0x%08x 0x%08x 0x%08x\n",
4381 be32toh(meta->dummy_5[0]), be32toh(meta->dummy_5[1]),
4382 be32toh(meta->dummy_5[2]), be32toh(meta->dummy_5[3]));
4383
4384 for (i = 0; i < be16toh(meta->total_configs); i++) {
4385 kprintf(" %d total_disks %u\n", i,
4386 be16toh(meta->configs[i].disk_number));
4387 kprintf(" %d generation %u\n", i,
4388 be16toh(meta->configs[i].generation));
4389 kprintf(" %d magic_0 0x%08x\n", i,
4390 be32toh(meta->configs[i].magic_0));
4391 kprintf(" %d dummy_0 0x%02x\n", i, meta->configs[i].dummy_0);
4392 kprintf(" %d type %s\n", i,
4393 ata_raid_adaptec_type(meta->configs[i].type));
4394 kprintf(" %d dummy_1 0x%02x\n", i, meta->configs[i].dummy_1);
4395 kprintf(" %d flags %d\n", i,
4396 be32toh(meta->configs[i].flags));
4397 kprintf(" %d dummy_2 0x%02x\n", i, meta->configs[i].dummy_2);
4398 kprintf(" %d dummy_3 0x%02x\n", i, meta->configs[i].dummy_3);
4399 kprintf(" %d dummy_4 0x%02x\n", i, meta->configs[i].dummy_4);
4400 kprintf(" %d dummy_5 0x%02x\n", i, meta->configs[i].dummy_5);
4401 kprintf(" %d disk_number %u\n", i,
4402 be32toh(meta->configs[i].disk_number));
4403 kprintf(" %d dummy_6 0x%08x\n", i,
4404 be32toh(meta->configs[i].dummy_6));
4405 kprintf(" %d sectors %u\n", i,
4406 be32toh(meta->configs[i].sectors));
4407 kprintf(" %d stripe_shift %u\n", i,
4408 be16toh(meta->configs[i].stripe_shift));
4409 kprintf(" %d dummy_7 0x%08x\n", i,
4410 be32toh(meta->configs[i].dummy_7));
4411 kprintf(" %d dummy_8 0x%08x 0x%08x 0x%08x 0x%08x\n", i,
4412 be32toh(meta->configs[i].dummy_8[0]),
4413 be32toh(meta->configs[i].dummy_8[1]),
4414 be32toh(meta->configs[i].dummy_8[2]),
4415 be32toh(meta->configs[i].dummy_8[3]));
4416 kprintf(" %d name <%s>\n", i, meta->configs[i].name);
4417 }
4418 kprintf("magic_1 <0x%08x>\n", be32toh(meta->magic_1));
4419 kprintf("magic_2 <0x%08x>\n", be32toh(meta->magic_2));
4420 kprintf("magic_3 <0x%08x>\n", be32toh(meta->magic_3));
4421 kprintf("magic_4 <0x%08x>\n", be32toh(meta->magic_4));
4422 kprintf("=================================================\n");
4423 }
4424
4425 static char *
4426 ata_raid_hptv2_type(int type)
4427 {
4428 static char buffer[16];
4429
4430 switch (type) {
4431 case HPTV2_T_RAID0: return "RAID0";
4432 case HPTV2_T_RAID1: return "RAID1";
4433 case HPTV2_T_RAID01_RAID0: return "RAID01_RAID0";
4434 case HPTV2_T_SPAN: return "SPAN";
4435 case HPTV2_T_RAID_3: return "RAID3";
4436 case HPTV2_T_RAID_5: return "RAID5";
4437 case HPTV2_T_JBOD: return "JBOD";
4438 case HPTV2_T_RAID01_RAID1: return "RAID01_RAID1";
4439 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4440 return buffer;
4441 }
4442 }
4443
4444 static void
4445 ata_raid_hptv2_print_meta(struct hptv2_raid_conf *meta)
4446 {
4447 int i;
4448
4449 kprintf("****** ATA Highpoint V2 RocketRAID Metadata *****\n");
4450 kprintf("magic 0x%08x\n", meta->magic);
4451 kprintf("magic_0 0x%08x\n", meta->magic_0);
4452 kprintf("magic_1 0x%08x\n", meta->magic_1);
4453 kprintf("order 0x%08x\n", meta->order);
4454 kprintf("array_width %u\n", meta->array_width);
4455 kprintf("stripe_shift %u\n", meta->stripe_shift);
4456 kprintf("type %s\n", ata_raid_hptv2_type(meta->type));
4457 kprintf("disk_number %u\n", meta->disk_number);
4458 kprintf("total_sectors %u\n", meta->total_sectors);
4459 kprintf("disk_mode 0x%08x\n", meta->disk_mode);
4460 kprintf("boot_mode 0x%08x\n", meta->boot_mode);
4461 kprintf("boot_disk 0x%02x\n", meta->boot_disk);
4462 kprintf("boot_protect 0x%02x\n", meta->boot_protect);
4463 kprintf("log_entries 0x%02x\n", meta->error_log_entries);
4464 kprintf("log_index 0x%02x\n", meta->error_log_index);
4465 if (meta->error_log_entries) {
4466 kprintf(" timestamp reason disk status sectors lba\n");
4467 for (i = meta->error_log_index;
4468 i < meta->error_log_index + meta->error_log_entries; i++)
4469 kprintf(" 0x%08x 0x%02x 0x%02x 0x%02x 0x%02x 0x%08x\n",
4470 meta->errorlog[i%32].timestamp,
4471 meta->errorlog[i%32].reason,
4472 meta->errorlog[i%32].disk, meta->errorlog[i%32].status,
4473 meta->errorlog[i%32].sectors, meta->errorlog[i%32].lba);
4474 }
4475 kprintf("rebuild_lba 0x%08x\n", meta->rebuild_lba);
4476 kprintf("dummy_1 0x%02x\n", meta->dummy_1);
4477 kprintf("name_1 <%.15s>\n", meta->name_1);
4478 kprintf("dummy_2 0x%02x\n", meta->dummy_2);
4479 kprintf("name_2 <%.15s>\n", meta->name_2);
4480 kprintf("=================================================\n");
4481 }
4482
4483 static char *
4484 ata_raid_hptv3_type(int type)
4485 {
4486 static char buffer[16];
4487
4488 switch (type) {
4489 case HPTV3_T_SPARE: return "SPARE";
4490 case HPTV3_T_JBOD: return "JBOD";
4491 case HPTV3_T_SPAN: return "SPAN";
4492 case HPTV3_T_RAID0: return "RAID0";
4493 case HPTV3_T_RAID1: return "RAID1";
4494 case HPTV3_T_RAID3: return "RAID3";
4495 case HPTV3_T_RAID5: return "RAID5";
4496 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4497 return buffer;
4498 }
4499 }
4500
4501 static void
4502 ata_raid_hptv3_print_meta(struct hptv3_raid_conf *meta)
4503 {
4504 int i;
4505
4506 kprintf("****** ATA Highpoint V3 RocketRAID Metadata *****\n");
4507 kprintf("magic 0x%08x\n", meta->magic);
4508 kprintf("magic_0 0x%08x\n", meta->magic_0);
4509 kprintf("checksum_0 0x%02x\n", meta->checksum_0);
4510 kprintf("mode 0x%02x\n", meta->mode);
4511 kprintf("user_mode 0x%02x\n", meta->user_mode);
4512 kprintf("config_entries 0x%02x\n", meta->config_entries);
4513 for (i = 0; i < meta->config_entries; i++) {
4514 kprintf("config %d:\n", i);
4515 kprintf(" total_sectors %ju\n",
4516 meta->configs[0].total_sectors +
4517 ((u_int64_t)meta->configs_high[0].total_sectors << 32));
4518 kprintf(" type %s\n",
4519 ata_raid_hptv3_type(meta->configs[i].type));
4520 kprintf(" total_disks %u\n", meta->configs[i].total_disks);
4521 kprintf(" disk_number %u\n", meta->configs[i].disk_number);
4522 kprintf(" stripe_shift %u\n", meta->configs[i].stripe_shift);
4523 kprintf(" status %b\n", meta->configs[i].status,
4524 "\20\2RAID5\1NEED_REBUILD\n");
4525 kprintf(" critical_disks %u\n", meta->configs[i].critical_disks);
4526 kprintf(" rebuild_lba %ju\n",
4527 meta->configs_high[0].rebuild_lba +
4528 ((u_int64_t)meta->configs_high[0].rebuild_lba << 32));
4529 }
4530 kprintf("name <%.16s>\n", meta->name);
4531 kprintf("timestamp 0x%08x\n", meta->timestamp);
4532 kprintf("description <%.16s>\n", meta->description);
4533 kprintf("creator <%.16s>\n", meta->creator);
4534 kprintf("checksum_1 0x%02x\n", meta->checksum_1);
4535 kprintf("dummy_0 0x%02x\n", meta->dummy_0);
4536 kprintf("dummy_1 0x%02x\n", meta->dummy_1);
4537 kprintf("flags %b\n", meta->flags,
4538 "\20\4RCACHE\3WCACHE\2NCQ\1TCQ\n");
4539 kprintf("=================================================\n");
4540 }
4541
4542 static char *
4543 ata_raid_intel_type(int type)
4544 {
4545 static char buffer[16];
4546
4547 switch (type) {
4548 case INTEL_T_RAID0: return "RAID0";
4549 case INTEL_T_RAID1: return "RAID1";
4550 case INTEL_T_RAID5: return "RAID5";
4551 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4552 return buffer;
4553 }
4554 }
4555
4556 static void
4557 ata_raid_intel_print_meta(struct intel_raid_conf *meta)
4558 {
4559 struct intel_raid_mapping *map;
4560 int i, j;
4561
4562 kprintf("********* ATA Intel MatrixRAID Metadata *********\n");
4563 kprintf("intel_id <%.24s>\n", meta->intel_id);
4564 kprintf("version <%.6s>\n", meta->version);
4565 kprintf("checksum 0x%08x\n", meta->checksum);
4566 kprintf("config_size 0x%08x\n", meta->config_size);
4567 kprintf("config_id 0x%08x\n", meta->config_id);
4568 kprintf("generation 0x%08x\n", meta->generation);
4569 kprintf("total_disks %u\n", meta->total_disks);
4570 kprintf("total_volumes %u\n", meta->total_volumes);
4571 kprintf("DISK# serial disk_sectors disk_id flags\n");
4572 for (i = 0; i < meta->total_disks; i++ ) {
4573 kprintf(" %d <%.16s> %u 0x%08x 0x%08x\n", i,
4574 meta->disk[i].serial, meta->disk[i].sectors,
4575 meta->disk[i].id, meta->disk[i].flags);
4576 }
4577 map = (struct intel_raid_mapping *)&meta->disk[meta->total_disks];
4578 for (j = 0; j < meta->total_volumes; j++) {
4579 kprintf("name %.16s\n", map->name);
4580 kprintf("total_sectors %ju\n", map->total_sectors);
4581 kprintf("state %u\n", map->state);
4582 kprintf("reserved %u\n", map->reserved);
4583 kprintf("offset %u\n", map->offset);
4584 kprintf("disk_sectors %u\n", map->disk_sectors);
4585 kprintf("stripe_count %u\n", map->stripe_count);
4586 kprintf("stripe_sectors %u\n", map->stripe_sectors);
4587 kprintf("status %u\n", map->status);
4588 kprintf("type %s\n", ata_raid_intel_type(map->type));
4589 kprintf("total_disks %u\n", map->total_disks);
4590 kprintf("magic[0] 0x%02x\n", map->magic[0]);
4591 kprintf("magic[1] 0x%02x\n", map->magic[1]);
4592 kprintf("magic[2] 0x%02x\n", map->magic[2]);
4593 for (i = 0; i < map->total_disks; i++ ) {
4594 kprintf(" disk %d at disk_idx 0x%08x\n", i, map->disk_idx[i]);
4595 }
4596 map = (struct intel_raid_mapping *)&map->disk_idx[map->total_disks];
4597 }
4598 kprintf("=================================================\n");
4599 }
4600
4601 static char *
4602 ata_raid_ite_type(int type)
4603 {
4604 static char buffer[16];
4605
4606 switch (type) {
4607 case ITE_T_RAID0: return "RAID0";
4608 case ITE_T_RAID1: return "RAID1";
4609 case ITE_T_RAID01: return "RAID0+1";
4610 case ITE_T_SPAN: return "SPAN";
4611 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4612 return buffer;
4613 }
4614 }
4615
4616 static void
4617 ata_raid_ite_print_meta(struct ite_raid_conf *meta)
4618 {
4619 kprintf("*** ATA Integrated Technology Express Metadata **\n");
4620 kprintf("ite_id <%.40s>\n", meta->ite_id);
4621 kprintf("timestamp_0 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4622 *((u_int16_t *)meta->timestamp_0), meta->timestamp_0[2],
4623 meta->timestamp_0[3], meta->timestamp_0[5], meta->timestamp_0[4],
4624 meta->timestamp_0[7], meta->timestamp_0[6]);
4625 kprintf("total_sectors %jd\n", meta->total_sectors);
4626 kprintf("type %s\n", ata_raid_ite_type(meta->type));
4627 kprintf("stripe_1kblocks %u\n", meta->stripe_1kblocks);
4628 kprintf("timestamp_1 %04x/%02x/%02x %02x:%02x:%02x.%02x\n",
4629 *((u_int16_t *)meta->timestamp_1), meta->timestamp_1[2],
4630 meta->timestamp_1[3], meta->timestamp_1[5], meta->timestamp_1[4],
4631 meta->timestamp_1[7], meta->timestamp_1[6]);
4632 kprintf("stripe_sectors %u\n", meta->stripe_sectors);
4633 kprintf("array_width %u\n", meta->array_width);
4634 kprintf("disk_number %u\n", meta->disk_number);
4635 kprintf("disk_sectors %u\n", meta->disk_sectors);
4636 kprintf("=================================================\n");
4637 }
4638
4639 static char *
4640 ata_raid_jmicron_type(int type)
4641 {
4642 static char buffer[16];
4643
4644 switch (type) {
4645 case JM_T_RAID0: return "RAID0";
4646 case JM_T_RAID1: return "RAID1";
4647 case JM_T_RAID01: return "RAID0+1";
4648 case JM_T_JBOD: return "JBOD";
4649 case JM_T_RAID5: return "RAID5";
4650 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4651 return buffer;
4652 }
4653 }
4654
4655 static void
4656 ata_raid_jmicron_print_meta(struct jmicron_raid_conf *meta)
4657 {
4658 int i;
4659
4660 kprintf("***** ATA JMicron Technology Corp Metadata ******\n");
4661 kprintf("signature %.2s\n", meta->signature);
4662 kprintf("version 0x%04x\n", meta->version);
4663 kprintf("checksum 0x%04x\n", meta->checksum);
4664 kprintf("disk_id 0x%08x\n", meta->disk_id);
4665 kprintf("offset 0x%08x\n", meta->offset);
4666 kprintf("disk_sectors_low 0x%08x\n", meta->disk_sectors_low);
4667 kprintf("disk_sectors_high 0x%08x\n", meta->disk_sectors_high);
4668 kprintf("name %.16s\n", meta->name);
4669 kprintf("type %s\n", ata_raid_jmicron_type(meta->type));
4670 kprintf("stripe_shift %d\n", meta->stripe_shift);
4671 kprintf("flags 0x%04x\n", meta->flags);
4672 kprintf("spare:\n");
4673 for (i=0; i < 2 && meta->spare[i]; i++)
4674 kprintf(" %d 0x%08x\n", i, meta->spare[i]);
4675 kprintf("disks:\n");
4676 for (i=0; i < 8 && meta->disks[i]; i++)
4677 kprintf(" %d 0x%08x\n", i, meta->disks[i]);
4678 kprintf("=================================================\n");
4679 }
4680
4681 static char *
4682 ata_raid_lsiv2_type(int type)
4683 {
4684 static char buffer[16];
4685
4686 switch (type) {
4687 case LSIV2_T_RAID0: return "RAID0";
4688 case LSIV2_T_RAID1: return "RAID1";
4689 case LSIV2_T_SPARE: return "SPARE";
4690 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4691 return buffer;
4692 }
4693 }
4694
4695 static void
4696 ata_raid_lsiv2_print_meta(struct lsiv2_raid_conf *meta)
4697 {
4698 int i;
4699
4700 kprintf("******* ATA LSILogic V2 MegaRAID Metadata *******\n");
4701 kprintf("lsi_id <%s>\n", meta->lsi_id);
4702 kprintf("dummy_0 0x%02x\n", meta->dummy_0);
4703 kprintf("flags 0x%02x\n", meta->flags);
4704 kprintf("version 0x%04x\n", meta->version);
4705 kprintf("config_entries 0x%02x\n", meta->config_entries);
4706 kprintf("raid_count 0x%02x\n", meta->raid_count);
4707 kprintf("total_disks 0x%02x\n", meta->total_disks);
4708 kprintf("dummy_1 0x%02x\n", meta->dummy_1);
4709 kprintf("dummy_2 0x%04x\n", meta->dummy_2);
4710 for (i = 0; i < meta->config_entries; i++) {
4711 kprintf(" type %s\n",
4712 ata_raid_lsiv2_type(meta->configs[i].raid.type));
4713 kprintf(" dummy_0 %02x\n", meta->configs[i].raid.dummy_0);
4714 kprintf(" stripe_sectors %u\n",
4715 meta->configs[i].raid.stripe_sectors);
4716 kprintf(" array_width %u\n",
4717 meta->configs[i].raid.array_width);
4718 kprintf(" disk_count %u\n", meta->configs[i].raid.disk_count);
4719 kprintf(" config_offset %u\n",
4720 meta->configs[i].raid.config_offset);
4721 kprintf(" dummy_1 %u\n", meta->configs[i].raid.dummy_1);
4722 kprintf(" flags %02x\n", meta->configs[i].raid.flags);
4723 kprintf(" total_sectors %u\n",
4724 meta->configs[i].raid.total_sectors);
4725 }
4726 kprintf("disk_number 0x%02x\n", meta->disk_number);
4727 kprintf("raid_number 0x%02x\n", meta->raid_number);
4728 kprintf("timestamp 0x%08x\n", meta->timestamp);
4729 kprintf("=================================================\n");
4730 }
4731
4732 static char *
4733 ata_raid_lsiv3_type(int type)
4734 {
4735 static char buffer[16];
4736
4737 switch (type) {
4738 case LSIV3_T_RAID0: return "RAID0";
4739 case LSIV3_T_RAID1: return "RAID1";
4740 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4741 return buffer;
4742 }
4743 }
4744
4745 static void
4746 ata_raid_lsiv3_print_meta(struct lsiv3_raid_conf *meta)
4747 {
4748 int i;
4749
4750 kprintf("******* ATA LSILogic V3 MegaRAID Metadata *******\n");
4751 kprintf("lsi_id <%.6s>\n", meta->lsi_id);
4752 kprintf("dummy_0 0x%04x\n", meta->dummy_0);
4753 kprintf("version 0x%04x\n", meta->version);
4754 kprintf("dummy_0 0x%04x\n", meta->dummy_1);
4755 kprintf("RAID configs:\n");
4756 for (i = 0; i < 8; i++) {
4757 if (meta->raid[i].total_disks) {
4758 kprintf("%02d stripe_pages %u\n", i,
4759 meta->raid[i].stripe_pages);
4760 kprintf("%02d type %s\n", i,
4761 ata_raid_lsiv3_type(meta->raid[i].type));
4762 kprintf("%02d total_disks %u\n", i,
4763 meta->raid[i].total_disks);
4764 kprintf("%02d array_width %u\n", i,
4765 meta->raid[i].array_width);
4766 kprintf("%02d sectors %u\n", i, meta->raid[i].sectors);
4767 kprintf("%02d offset %u\n", i, meta->raid[i].offset);
4768 kprintf("%02d device 0x%02x\n", i,
4769 meta->raid[i].device);
4770 }
4771 }
4772 kprintf("DISK configs:\n");
4773 for (i = 0; i < 6; i++) {
4774 if (meta->disk[i].disk_sectors) {
4775 kprintf("%02d disk_sectors %u\n", i,
4776 meta->disk[i].disk_sectors);
4777 kprintf("%02d flags 0x%02x\n", i, meta->disk[i].flags);
4778 }
4779 }
4780 kprintf("device 0x%02x\n", meta->device);
4781 kprintf("timestamp 0x%08x\n", meta->timestamp);
4782 kprintf("checksum_1 0x%02x\n", meta->checksum_1);
4783 kprintf("=================================================\n");
4784 }
4785
4786 static char *
4787 ata_raid_nvidia_type(int type)
4788 {
4789 static char buffer[16];
4790
4791 switch (type) {
4792 case NV_T_SPAN: return "SPAN";
4793 case NV_T_RAID0: return "RAID0";
4794 case NV_T_RAID1: return "RAID1";
4795 case NV_T_RAID3: return "RAID3";
4796 case NV_T_RAID5: return "RAID5";
4797 case NV_T_RAID01: return "RAID0+1";
4798 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4799 return buffer;
4800 }
4801 }
4802
4803 static void
4804 ata_raid_nvidia_print_meta(struct nvidia_raid_conf *meta)
4805 {
4806 kprintf("******** ATA nVidia MediaShield Metadata ********\n");
4807 kprintf("nvidia_id <%.8s>\n", meta->nvidia_id);
4808 kprintf("config_size %u\n", meta->config_size);
4809 kprintf("checksum 0x%08x\n", meta->checksum);
4810 kprintf("version 0x%04x\n", meta->version);
4811 kprintf("disk_number %u\n", meta->disk_number);
4812 kprintf("dummy_0 0x%02x\n", meta->dummy_0);
4813 kprintf("total_sectors %u\n", meta->total_sectors);
4814 kprintf("sectors_size %u\n", meta->sector_size);
4815 kprintf("serial %.16s\n", meta->serial);
4816 kprintf("revision %.4s\n", meta->revision);
4817 kprintf("dummy_1 0x%08x\n", meta->dummy_1);
4818 kprintf("magic_0 0x%08x\n", meta->magic_0);
4819 kprintf("magic_1 0x%016jx\n", meta->magic_1);
4820 kprintf("magic_2 0x%016jx\n", meta->magic_2);
4821 kprintf("flags 0x%02x\n", meta->flags);
4822 kprintf("array_width %u\n", meta->array_width);
4823 kprintf("total_disks %u\n", meta->total_disks);
4824 kprintf("dummy_2 0x%02x\n", meta->dummy_2);
4825 kprintf("type %s\n", ata_raid_nvidia_type(meta->type));
4826 kprintf("dummy_3 0x%04x\n", meta->dummy_3);
4827 kprintf("stripe_sectors %u\n", meta->stripe_sectors);
4828 kprintf("stripe_bytes %u\n", meta->stripe_bytes);
4829 kprintf("stripe_shift %u\n", meta->stripe_shift);
4830 kprintf("stripe_mask 0x%08x\n", meta->stripe_mask);
4831 kprintf("stripe_sizesectors %u\n", meta->stripe_sizesectors);
4832 kprintf("stripe_sizebytes %u\n", meta->stripe_sizebytes);
4833 kprintf("rebuild_lba %u\n", meta->rebuild_lba);
4834 kprintf("dummy_4 0x%08x\n", meta->dummy_4);
4835 kprintf("dummy_5 0x%08x\n", meta->dummy_5);
4836 kprintf("status 0x%08x\n", meta->status);
4837 kprintf("=================================================\n");
4838 }
4839
4840 static char *
4841 ata_raid_promise_type(int type)
4842 {
4843 static char buffer[16];
4844
4845 switch (type) {
4846 case PR_T_RAID0: return "RAID0";
4847 case PR_T_RAID1: return "RAID1";
4848 case PR_T_RAID3: return "RAID3";
4849 case PR_T_RAID5: return "RAID5";
4850 case PR_T_SPAN: return "SPAN";
4851 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4852 return buffer;
4853 }
4854 }
4855
4856 static void
4857 ata_raid_promise_print_meta(struct promise_raid_conf *meta)
4858 {
4859 int i;
4860
4861 kprintf("********* ATA Promise FastTrak Metadata *********\n");
4862 kprintf("promise_id <%s>\n", meta->promise_id);
4863 kprintf("dummy_0 0x%08x\n", meta->dummy_0);
4864 kprintf("magic_0 0x%016jx\n", meta->magic_0);
4865 kprintf("magic_1 0x%04x\n", meta->magic_1);
4866 kprintf("magic_2 0x%08x\n", meta->magic_2);
4867 kprintf("integrity 0x%08x %b\n", meta->raid.integrity,
4868 meta->raid.integrity, "\20\10VALID\n" );
4869 kprintf("flags 0x%02x %b\n",
4870 meta->raid.flags, meta->raid.flags,
4871 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4872 "\3ASSIGNED\2ONLINE\1VALID\n");
4873 kprintf("disk_number %d\n", meta->raid.disk_number);
4874 kprintf("channel 0x%02x\n", meta->raid.channel);
4875 kprintf("device 0x%02x\n", meta->raid.device);
4876 kprintf("magic_0 0x%016jx\n", meta->raid.magic_0);
4877 kprintf("disk_offset %u\n", meta->raid.disk_offset);
4878 kprintf("disk_sectors %u\n", meta->raid.disk_sectors);
4879 kprintf("rebuild_lba 0x%08x\n", meta->raid.rebuild_lba);
4880 kprintf("generation 0x%04x\n", meta->raid.generation);
4881 kprintf("status 0x%02x %b\n",
4882 meta->raid.status, meta->raid.status,
4883 "\20\6MARKED\5DEGRADED\4READY\3INITED\2ONLINE\1VALID\n");
4884 kprintf("type %s\n", ata_raid_promise_type(meta->raid.type));
4885 kprintf("total_disks %u\n", meta->raid.total_disks);
4886 kprintf("stripe_shift %u\n", meta->raid.stripe_shift);
4887 kprintf("array_width %u\n", meta->raid.array_width);
4888 kprintf("array_number %u\n", meta->raid.array_number);
4889 kprintf("total_sectors %u\n", meta->raid.total_sectors);
4890 kprintf("cylinders %u\n", meta->raid.cylinders);
4891 kprintf("heads %u\n", meta->raid.heads);
4892 kprintf("sectors %u\n", meta->raid.sectors);
4893 kprintf("magic_1 0x%016jx\n", meta->raid.magic_1);
4894 kprintf("DISK# flags dummy_0 channel device magic_0\n");
4895 for (i = 0; i < 8; i++) {
4896 kprintf(" %d %b 0x%02x 0x%02x 0x%02x ",
4897 i, meta->raid.disk[i].flags,
4898 "\20\10READY\7DOWN\6REDIR\5DUPLICATE\4SPARE"
4899 "\3ASSIGNED\2ONLINE\1VALID\n", meta->raid.disk[i].dummy_0,
4900 meta->raid.disk[i].channel, meta->raid.disk[i].device);
4901 kprintf("0x%016jx\n", meta->raid.disk[i].magic_0);
4902 }
4903 kprintf("checksum 0x%08x\n", meta->checksum);
4904 kprintf("=================================================\n");
4905 }
4906
4907 static char *
4908 ata_raid_sii_type(int type)
4909 {
4910 static char buffer[16];
4911
4912 switch (type) {
4913 case SII_T_RAID0: return "RAID0";
4914 case SII_T_RAID1: return "RAID1";
4915 case SII_T_RAID01: return "RAID0+1";
4916 case SII_T_SPARE: return "SPARE";
4917 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4918 return buffer;
4919 }
4920 }
4921
4922 static void
4923 ata_raid_sii_print_meta(struct sii_raid_conf *meta)
4924 {
4925 kprintf("******* ATA Silicon Image Medley Metadata *******\n");
4926 kprintf("total_sectors %ju\n", meta->total_sectors);
4927 kprintf("dummy_0 0x%04x\n", meta->dummy_0);
4928 kprintf("dummy_1 0x%04x\n", meta->dummy_1);
4929 kprintf("controller_pci_id 0x%08x\n", meta->controller_pci_id);
4930 kprintf("version_minor 0x%04x\n", meta->version_minor);
4931 kprintf("version_major 0x%04x\n", meta->version_major);
4932 kprintf("timestamp 20%02x/%02x/%02x %02x:%02x:%02x\n",
4933 meta->timestamp[5], meta->timestamp[4], meta->timestamp[3],
4934 meta->timestamp[2], meta->timestamp[1], meta->timestamp[0]);
4935 kprintf("stripe_sectors %u\n", meta->stripe_sectors);
4936 kprintf("dummy_2 0x%04x\n", meta->dummy_2);
4937 kprintf("disk_number %u\n", meta->disk_number);
4938 kprintf("type %s\n", ata_raid_sii_type(meta->type));
4939 kprintf("raid0_disks %u\n", meta->raid0_disks);
4940 kprintf("raid0_ident %u\n", meta->raid0_ident);
4941 kprintf("raid1_disks %u\n", meta->raid1_disks);
4942 kprintf("raid1_ident %u\n", meta->raid1_ident);
4943 kprintf("rebuild_lba %ju\n", meta->rebuild_lba);
4944 kprintf("generation 0x%08x\n", meta->generation);
4945 kprintf("status 0x%02x %b\n",
4946 meta->status, meta->status,
4947 "\20\1READY\n");
4948 kprintf("base_raid1_position %02x\n", meta->base_raid1_position);
4949 kprintf("base_raid0_position %02x\n", meta->base_raid0_position);
4950 kprintf("position %02x\n", meta->position);
4951 kprintf("dummy_3 %04x\n", meta->dummy_3);
4952 kprintf("name <%.16s>\n", meta->name);
4953 kprintf("checksum_0 0x%04x\n", meta->checksum_0);
4954 kprintf("checksum_1 0x%04x\n", meta->checksum_1);
4955 kprintf("=================================================\n");
4956 }
4957
4958 static char *
4959 ata_raid_sis_type(int type)
4960 {
4961 static char buffer[16];
4962
4963 switch (type) {
4964 case SIS_T_JBOD: return "JBOD";
4965 case SIS_T_RAID0: return "RAID0";
4966 case SIS_T_RAID1: return "RAID1";
4967 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
4968 return buffer;
4969 }
4970 }
4971
4972 static void
4973 ata_raid_sis_print_meta(struct sis_raid_conf *meta)
4974 {
4975 kprintf("**** ATA Silicon Integrated Systems Metadata ****\n");
4976 kprintf("magic 0x%04x\n", meta->magic);
4977 kprintf("disks 0x%02x\n", meta->disks);
4978 kprintf("type %s\n",
4979 ata_raid_sis_type(meta->type_total_disks & SIS_T_MASK));
4980 kprintf("total_disks %u\n", meta->type_total_disks & SIS_D_MASK);
4981 kprintf("dummy_0 0x%08x\n", meta->dummy_0);
4982 kprintf("controller_pci_id 0x%08x\n", meta->controller_pci_id);
4983 kprintf("stripe_sectors %u\n", meta->stripe_sectors);
4984 kprintf("dummy_1 0x%04x\n", meta->dummy_1);
4985 kprintf("timestamp 0x%08x\n", meta->timestamp);
4986 kprintf("model %.40s\n", meta->model);
4987 kprintf("disk_number %u\n", meta->disk_number);
4988 kprintf("dummy_2 0x%02x 0x%02x 0x%02x\n",
4989 meta->dummy_2[0], meta->dummy_2[1], meta->dummy_2[2]);
4990 kprintf("=================================================\n");
4991 }
4992
4993 static char *
4994 ata_raid_via_type(int type)
4995 {
4996 static char buffer[16];
4997
4998 switch (type) {
4999 case VIA_T_RAID0: return "RAID0";
5000 case VIA_T_RAID1: return "RAID1";
5001 case VIA_T_RAID5: return "RAID5";
5002 case VIA_T_RAID01: return "RAID0+1";
5003 case VIA_T_SPAN: return "SPAN";
5004 default: ksprintf(buffer, "UNKNOWN 0x%02x", type);
5005 return buffer;
5006 }
5007 }
5008
5009 static void
5010 ata_raid_via_print_meta(struct via_raid_conf *meta)
5011 {
5012 int i;
5013
5014 kprintf("*************** ATA VIA Metadata ****************\n");
5015 kprintf("magic 0x%02x\n", meta->magic);
5016 kprintf("dummy_0 0x%02x\n", meta->dummy_0);
5017 kprintf("type %s\n",
5018 ata_raid_via_type(meta->type & VIA_T_MASK));
5019 kprintf("bootable %d\n", meta->type & VIA_T_BOOTABLE);
5020 kprintf("unknown %d\n", meta->type & VIA_T_UNKNOWN);
5021 kprintf("disk_index 0x%02x\n", meta->disk_index);
5022 kprintf("stripe_layout 0x%02x\n", meta->stripe_layout);
5023 kprintf(" stripe_disks %d\n", meta->stripe_layout & VIA_L_DISKS);
5024 kprintf(" stripe_sectors %d\n",
5025 0x08 << ((meta->stripe_layout & VIA_L_MASK) >> VIA_L_SHIFT));
5026 kprintf("disk_sectors %ju\n", meta->disk_sectors);
5027 kprintf("disk_id 0x%08x\n", meta->disk_id);
5028 kprintf("DISK# disk_id\n");
5029 for (i = 0; i < 8; i++) {
5030 if (meta->disks[i])
5031 kprintf(" %d 0x%08x\n", i, meta->disks[i]);
5032 }
5033 kprintf("checksum 0x%02x\n", meta->checksum);
5034 kprintf("=================================================\n");
5035 }
DragonFly BSD