sys/dev/raid/amr/amr_disk.c

   1 /*-
   2  * Copyright (c) 1999 Jonathan Lemon
   3  * Copyright (c) 1999, 2000 Michael Smith
   4  * Copyright (c) 2000 BSDi
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * Copyright (c) 2002 Eric Moore
  29  * Copyright (c) 2002 LSI Logic Corporation
  30  * All rights reserved.
  31  *
  32  * Redistribution and use in source and binary forms, with or without
  33  * modification, are permitted provided that the following conditions
  34  * are met:
  35  * 1. Redistributions of source code must retain the above copyright
  36  *    notice, this list of conditions and the following disclaimer.
  37  * 2. Redistributions in binary form must reproduce the above copyright
  38  *    notice, this list of conditions and the following disclaimer in the
  39  *    documentation and/or other materials provided with the distribution.
  40  * 3. The party using or redistributing the source code and binary forms
  41  *    agrees to the disclaimer below and the terms and conditions set forth
  42  *    herein.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  45  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  46  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  47  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  48  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  49  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  50  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  51  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  52  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  53  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  54  * SUCH DAMAGE.
  55  *
  56  * $FreeBSD: src/sys/dev/amr/amr_disk.c,v 1.5.2.5 2002/12/20 15:12:04 emoore Exp $
  57  * $DragonFly: src/sys/dev/raid/amr/amr_disk.c,v 1.11 2006/07/28 02:17:37 dillon Exp $
  58  */
  59
  60 /*
  61  * Disk driver for AMI MegaRaid controllers
  62  */
  63
  64 #include <sys/param.h>
  65 #include <sys/systm.h>
  66 #include <sys/kernel.h>
  67
  68 #include "amr_compat.h"
  69 #include <sys/bus.h>
  70 #include <sys/conf.h>
  71 #include <sys/devicestat.h>
  72 #include <sys/disk.h>
  73
  74 #include <vm/vm.h>
  75 #include <vm/pmap.h>
  76
  77 #include <machine/bus.h>
  78 #include <machine/md_var.h>
  79 #include <sys/rman.h>
  80
  81 #include "amrio.h"
  82 #include "amrreg.h"
  83 #include "amrvar.h"
  84 #include "amr_tables.h"
  85
  86 /* prototypes */
  87 static int amrd_probe(device_t dev);
  88 static int amrd_attach(device_t dev);
  89 static int amrd_detach(device_t dev);
  90
  91 static  d_open_t        amrd_open;
  92 static  d_close_t       amrd_close;
  93 static  d_strategy_t    amrd_strategy;
  94 static  d_ioctl_t       amrd_ioctl;
  95 static  d_dump_t        amrd_dump;
  96
  97 #define AMRD_CDEV_MAJOR 133
  98
  99 static struct dev_ops amrd_ops = {
 100         { "amrd", AMRD_CDEV_MAJOR, D_DISK },
 101         .d_open = amrd_open,
 102         .d_close = amrd_close,
 103         .d_read = physread,
 104         .d_write = physwrite,
 105         .d_ioctl = amrd_ioctl,
 106         .d_strategy = amrd_strategy,
 107         .d_dump = amrd_dump
 108 };
 109
 110 static devclass_t       amrd_devclass;
 111
 112 static device_method_t amrd_methods[] = {
 113     DEVMETHOD(device_probe,     amrd_probe),
 114     DEVMETHOD(device_attach,    amrd_attach),
 115     DEVMETHOD(device_detach,    amrd_detach),
 116     { 0, 0 }
 117 };
 118
 119 static driver_t amrd_driver = {
 120     "amrd",
 121     amrd_methods,
 122     sizeof(struct amrd_softc)
 123 };
 124
 125 DRIVER_MODULE(amrd, amr, amrd_driver, amrd_devclass, 0, 0);
 126
 127 static int
 128 amrd_open(struct dev_open_args *ap)
 129 {
 130     dev_t dev = ap->a_head.a_dev;
 131     struct amrd_softc   *sc = (struct amrd_softc *)dev->si_drv1;
 132 #if defined(__DragonFly__) || __FreeBSD_version < 500000                /* old buf style */
 133     struct disklabel    *label;
 134 #endif
 135
 136     debug_called(1);
 137
 138     if (sc == NULL)
 139         return (ENXIO);
 140
 141     /* controller not active? */
 142     if (sc->amrd_controller->amr_state & AMR_STATE_SHUTDOWN)
 143         return(ENXIO);
 144
 145 #if defined(__DragonFly__) || __FreeBSD_version < 500000                /* old buf style */
 146     label = &sc->amrd_disk.d_label;
 147     bzero(label, sizeof(*label));
 148     label->d_type       = DTYPE_SCSI;
 149     label->d_secsize    = AMR_BLKSIZE;
 150     label->d_nsectors   = sc->amrd_drive->al_sectors;
 151     label->d_ntracks    = sc->amrd_drive->al_heads;
 152     label->d_ncylinders = sc->amrd_drive->al_cylinders;
 153     label->d_secpercyl  = sc->amrd_drive->al_sectors * sc->amrd_drive->al_heads;
 154     label->d_secperunit = sc->amrd_drive->al_size;
 155 #else
 156     sc->amrd_disk.d_sectorsize = AMR_BLKSIZE;
 157     sc->amrd_disk.d_mediasize = (off_t)sc->amrd_drive->al_size * AMR_BLKSIZE;
 158     sc->amrd_disk.d_fwsectors = sc->amrd_drive->al_sectors;
 159     sc->amrd_disk.d_fwheads = sc->amrd_drive->al_heads;
 160 #endif
 161
 162     sc->amrd_flags |= AMRD_OPEN;
 163     return (0);
 164 }
 165
 166 static int
 167 amrd_close(struct dev_close_args *ap)
 168 {
 169     dev_t dev = ap->a_head.a_dev;
 170     struct amrd_softc   *sc = (struct amrd_softc *)dev->si_drv1;
 171
 172     debug_called(1);
 173
 174     if (sc == NULL)
 175         return (ENXIO);
 176     sc->amrd_flags &= ~AMRD_OPEN;
 177     return (0);
 178 }
 179
 180 static int
 181 amrd_ioctl(struct dev_ioctl_args *ap)
 182 {
 183     return (ENOTTY);
 184 }
 185
 186
 187 /********************************************************************************
 188  * System crashdump support
 189  */
 190 int
 191 amrd_dump(struct dev_dump_args *ap)
 192 {
 193     dev_t dev = ap->a_head.a_dev;
 194     struct amrd_softc   *amrd_sc = (struct amrd_softc *)dev->si_drv1;
 195     struct amr_softc    *amr_sc;
 196     vm_paddr_t          addr = 0;
 197     long                blkcnt;
 198     int                 dumppages = MAXDUMPPGS;
 199     int                 error = 0;
 200     int                 driveno;
 201     int                 i;
 202
 203     debug_called(1);
 204
 205     amr_sc  = (struct amr_softc *)amrd_sc->amrd_controller;
 206
 207     if (!amrd_sc || !amr_sc)
 208         return(ENXIO);
 209
 210     blkcnt = howmany(PAGE_SIZE, ap->a_secsize);
 211
 212     driveno = amrd_sc->amrd_drive - amr_sc->amr_drive;
 213
 214     while (ap->a_count > 0) {
 215         caddr_t va = NULL;
 216
 217         if ((ap->a_count / blkcnt) < dumppages)
 218             dumppages = ap->a_count / blkcnt;
 219
 220         for (i = 0; i < dumppages; ++i) {
 221             vm_paddr_t a = addr + (i * PAGE_SIZE);
 222             if (is_physical_memory(a))
 223                 va = pmap_kenter_temporary(trunc_page(a), i);
 224             else
 225                 va = pmap_kenter_temporary(trunc_page(0), i);
 226         }
 227
 228         if ((error = amr_dump_blocks(amr_sc, driveno, ap->a_blkno, (void *)va,
 229                                       (PAGE_SIZE * dumppages) / AMR_BLKSIZE)) != 0)
 230                 return(error);
 231
 232         if (dumpstatus(addr, (off_t)ap->a_count * DEV_BSIZE) < 0)
 233             return(EINTR);
 234
 235         ap->a_blkno += blkcnt * dumppages;
 236         ap->a_count -= blkcnt * dumppages;
 237         addr += PAGE_SIZE * dumppages;
 238     }
 239     return (0);
 240 }
 241 /*
 242  * Read/write routine for a buffer.  Finds the proper unit, range checks
 243  * arguments, and schedules the transfer.  Does not wait for the transfer
 244  * to complete.  Multi-page transfers are supported.  All I/O requests must
 245  * be a multiple of a sector in length.
 246  */
 247 static int
 248 amrd_strategy(struct dev_strategy_args *ap)
 249 {
 250     dev_t dev = ap->a_head.a_dev;
 251     struct bio *bio = ap->a_bio;
 252     struct buf *bp = bio->bio_buf;
 253     struct amrd_softc *sc = (struct amrd_softc *)dev->si_drv1;
 254
 255     /* bogus disk? */
 256     if (sc == NULL) {
 257         bp->b_error = EINVAL;
 258         goto bad;
 259     }
 260     bio->bio_driver_info = sc;
 261
 262     devstat_start_transaction(&sc->amrd_stats);
 263     amr_submit_bio(sc->amrd_controller, bio);
 264     return(0);
 265
 266  bad:
 267     bp->b_flags |= B_ERROR;
 268
 269     /*
 270      * Correctly set the buf to indicate a completed transfer
 271      */
 272     bp->b_resid = bp->b_bcount;
 273     biodone(bio);
 274     return(0);
 275 }
 276
 277 void
 278 amrd_intr(struct bio *bio)
 279 {
 280     struct buf *bp = bio->bio_buf;
 281
 282     debug_called(2);
 283
 284     if (bp->b_flags & B_ERROR) {
 285         bp->b_error = EIO;
 286         debug(1, "i/o error\n");
 287     } else {
 288         bp->b_resid = 0;
 289     }
 290     biodone(bio);
 291 }
 292
 293 static int
 294 amrd_probe(device_t dev)
 295 {
 296
 297     debug_called(1);
 298
 299     device_set_desc(dev, "LSILogic MegaRAID logical drive");
 300     return (0);
 301 }
 302
 303 static int
 304 amrd_attach(device_t dev)
 305 {
 306     struct amrd_softc   *sc = (struct amrd_softc *)device_get_softc(dev);
 307     device_t            parent;
 308
 309     debug_called(1);
 310
 311     parent = device_get_parent(dev);
 312     sc->amrd_controller = (struct amr_softc *)device_get_softc(parent);
 313     sc->amrd_unit = device_get_unit(dev);
 314     sc->amrd_drive = device_get_ivars(dev);
 315     sc->amrd_dev = dev;
 316
 317     device_printf(dev, "%uMB (%u sectors) RAID %d (%s)\n",
 318                   sc->amrd_drive->al_size / ((1024 * 1024) / AMR_BLKSIZE),
 319                   sc->amrd_drive->al_size, sc->amrd_drive->al_properties & AMR_DRV_RAID_MASK,
 320                   amr_describe_code(amr_table_drvstate, AMR_DRV_CURSTATE(sc->amrd_drive->al_state)));
 321
 322     devstat_add_entry(&sc->amrd_stats, "amrd", sc->amrd_unit, AMR_BLKSIZE,
 323                       DEVSTAT_NO_ORDERED_TAGS,
 324                       DEVSTAT_TYPE_STORARRAY | DEVSTAT_TYPE_IF_OTHER,
 325                       DEVSTAT_PRIORITY_ARRAY);
 326
 327     sc->amrd_dev_t = disk_create(sc->amrd_unit, &sc->amrd_disk, 0, &amrd_ops);
 328     sc->amrd_dev_t->si_drv1 = sc;
 329
 330     /* set maximum I/O size to match the maximum s/g size */
 331     sc->amrd_dev_t->si_iosize_max = (AMR_NSEG - 1) * PAGE_SIZE;
 332
 333     return (0);
 334 }
 335
 336 static int
 337 amrd_detach(device_t dev)
 338 {
 339     struct amrd_softc *sc = (struct amrd_softc *)device_get_softc(dev);
 340
 341     debug_called(1);
 342
 343     if (sc->amrd_flags & AMRD_OPEN)
 344         return(EBUSY);
 345
 346     devstat_remove_entry(&sc->amrd_stats);
 347     disk_destroy(&sc->amrd_disk);
 348     return(0);
 349 }
 350