sys/dev/disk/nata/ata-raid.c

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