sys/dev/raid/amr/amr.c

   1 /*-
   2  * Copyright (c) 1999,2000 Michael Smith
   3  * Copyright (c) 2000 BSDi
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  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 AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * Copyright (c) 2002 Eric Moore
  28  * Copyright (c) 2002 LSI Logic Corporation
  29  * All rights reserved.
  30  *
  31  * Redistribution and use in source and binary forms, with or without
  32  * modification, are permitted provided that the following conditions
  33  * are met:
  34  * 1. Redistributions of source code must retain the above copyright
  35  *    notice, this list of conditions and the following disclaimer.
  36  * 2. Redistributions in binary form must reproduce the above copyright
  37  *    notice, this list of conditions and the following disclaimer in the
  38  *    documentation and/or other materials provided with the distribution.
  39  * 3. The party using or redistributing the source code and binary forms
  40  *    agrees to the disclaimer below and the terms and conditions set forth
  41  *    herein.
  42  *
  43  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  53  * SUCH DAMAGE.
  54  *
  55  *      $FreeBSD: src/sys/dev/amr/amr.c,v 1.7.2.13 2003/01/15 13:41:18 emoore Exp $
  56  */
  57
  58 /*
  59  * Driver for the AMI MegaRaid family of controllers.
  60  */
  61
  62 #include <sys/param.h>
  63 #include <sys/systm.h>
  64 #include <sys/malloc.h>
  65 #include <sys/kernel.h>
  66
  67 #include "amr_compat.h"
  68 #include <sys/bus.h>
  69 #include <sys/conf.h>
  70 #include <sys/devicestat.h>
  71 #include <sys/disk.h>
  72 #include <sys/stat.h>
  73 #include <sys/rman.h>
  74
  75 #include <bus/pci/pcireg.h>
  76 #include <bus/pci/pcivar.h>
  77
  78 #include "amrio.h"
  79 #include "amrreg.h"
  80 #include "amrvar.h"
  81 #define AMR_DEFINE_TABLES
  82 #include "amr_tables.h"
  83
  84 static d_open_t         amr_open;
  85 static d_close_t        amr_close;
  86 static d_ioctl_t        amr_ioctl;
  87
  88 static struct dev_ops amr_ops = {
  89         { "amr", 0, 0 },
  90         .d_open =       amr_open,
  91         .d_close =      amr_close,
  92         .d_ioctl =      amr_ioctl
  93 };
  94
  95 /*
  96  * Initialisation, bus interface.
  97  */
  98 static void     amr_startup(void *arg);
  99
 100 /*
 101  * Command wrappers
 102  */
 103 static int      amr_query_controller(struct amr_softc *sc);
 104 static void     *amr_enquiry(struct amr_softc *sc, size_t bufsize,
 105                              u_int8_t cmd, u_int8_t cmdsub, u_int8_t cmdqual);
 106 static void     amr_completeio(struct amr_command *ac);
 107 static int      amr_support_ext_cdb(struct amr_softc *sc);
 108
 109 /*
 110  * Command buffer allocation.
 111  */
 112 static void     amr_alloccmd_cluster(struct amr_softc *sc);
 113 static void     amr_freecmd_cluster(struct amr_command_cluster *acc);
 114
 115 /*
 116  * Command processing.
 117  */
 118 static int      amr_bio_command(struct amr_softc *sc, struct amr_command **acp);
 119 static int      amr_wait_command(struct amr_command *ac);
 120 static int      amr_getslot(struct amr_command *ac);
 121 static void     amr_mapcmd(struct amr_command *ac);
 122 static void     amr_unmapcmd(struct amr_command *ac);
 123 static int      amr_start(struct amr_command *ac);
 124 static void     amr_complete(void *context, int pending);
 125
 126 /*
 127  * Status monitoring
 128  */
 129 static void     amr_periodic(void *data);
 130
 131 /*
 132  * Interface-specific shims
 133  */
 134 static int      amr_quartz_submit_command(struct amr_softc *sc);
 135 static int      amr_quartz_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave);
 136 static int      amr_quartz_poll_command(struct amr_command *ac);
 137
 138 static int      amr_std_submit_command(struct amr_softc *sc);
 139 static int      amr_std_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave);
 140 static int      amr_std_poll_command(struct amr_command *ac);
 141 static void     amr_std_attach_mailbox(struct amr_softc *sc);
 142
 143 #ifdef AMR_BOARD_INIT
 144 static int      amr_quartz_init(struct amr_softc *sc);
 145 static int      amr_std_init(struct amr_softc *sc);
 146 #endif
 147
 148 /*
 149  * Debugging
 150  */
 151 static void     amr_describe_controller(struct amr_softc *sc);
 152 #ifdef AMR_DEBUG
 153 #if 0
 154 static void     amr_printcommand(struct amr_command *ac);
 155 #endif
 156 #endif
 157
 158 DECLARE_DUMMY_MODULE(amr);
 159
 160 /********************************************************************************
 161  ********************************************************************************
 162                                                                       Inline Glue
 163  ********************************************************************************
 164  ********************************************************************************/
 165
 166 /********************************************************************************
 167  ********************************************************************************
 168                                                                 Public Interfaces
 169  ********************************************************************************
 170  ********************************************************************************/
 171
 172 /********************************************************************************
 173  * Initialise the controller and softc.
 174  */
 175 int
 176 amr_attach(struct amr_softc *sc)
 177 {
 178
 179     debug_called(1);
 180
 181     /*
 182      * Initialise per-controller queues.
 183      */
 184     TAILQ_INIT(&sc->amr_completed);
 185     TAILQ_INIT(&sc->amr_freecmds);
 186     TAILQ_INIT(&sc->amr_cmd_clusters);
 187     TAILQ_INIT(&sc->amr_ready);
 188     bioq_init(&sc->amr_bioq);
 189
 190 #if defined(__FreeBSD__) && __FreeBSD_version >= 500005
 191     /*
 192      * Initialise command-completion task.
 193      */
 194     TASK_INIT(&sc->amr_task_complete, 0, amr_complete, sc);
 195 #endif
 196
 197     debug(2, "queue init done");
 198
 199     /*
 200      * Configure for this controller type.
 201      */
 202     if (AMR_IS_QUARTZ(sc)) {
 203         sc->amr_submit_command = amr_quartz_submit_command;
 204         sc->amr_get_work       = amr_quartz_get_work;
 205         sc->amr_poll_command   = amr_quartz_poll_command;
 206     } else {
 207         sc->amr_submit_command = amr_std_submit_command;
 208         sc->amr_get_work       = amr_std_get_work;
 209         sc->amr_poll_command   = amr_std_poll_command;
 210         amr_std_attach_mailbox(sc);
 211     }
 212
 213 #ifdef AMR_BOARD_INIT
 214     if ((AMR_IS_QUARTZ(sc) ? amr_quartz_init(sc) : amr_std_init(sc))))
 215         return(ENXIO);
 216 #endif
 217
 218     /*
 219      * Quiz controller for features and limits.
 220      */
 221     if (amr_query_controller(sc))
 222         return(ENXIO);
 223
 224     debug(2, "controller query complete");
 225
 226     /*
 227      * Attach our 'real' SCSI channels to CAM.
 228      */
 229     if (amr_cam_attach(sc))
 230         return(ENXIO);
 231     debug(2, "CAM attach done");
 232
 233     /*
 234      * Create the control device.
 235      */
 236     sc->amr_dev_t = make_dev(&amr_ops, device_get_unit(sc->amr_dev),
 237                             UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
 238                             "amr%d", device_get_unit(sc->amr_dev));
 239     sc->amr_dev_t->si_drv1 = sc;
 240     reference_dev(sc->amr_dev_t);
 241
 242     /*
 243      * Schedule ourselves to bring the controller up once interrupts are
 244      * available.
 245      */
 246     bzero(&sc->amr_ich, sizeof(struct intr_config_hook));
 247     sc->amr_ich.ich_func = amr_startup;
 248     sc->amr_ich.ich_arg = sc;
 249     sc->amr_ich.ich_desc = "amr";
 250     if (config_intrhook_establish(&sc->amr_ich) != 0) {
 251         device_printf(sc->amr_dev, "can't establish configuration hook\n");
 252         return(ENOMEM);
 253     }
 254
 255     /*
 256      * Print a little information about the controller.
 257      */
 258     amr_describe_controller(sc);
 259
 260     debug(2, "attach complete");
 261     return(0);
 262 }
 263
 264 /********************************************************************************
 265  * Locate disk resources and attach children to them.
 266  */
 267 static void
 268 amr_startup(void *arg)
 269 {
 270     struct amr_softc    *sc = (struct amr_softc *)arg;
 271     struct amr_logdrive *dr;
 272     int                 i, error;
 273
 274     debug_called(1);
 275     callout_init(&sc->amr_timeout);
 276
 277     /* pull ourselves off the intrhook chain */
 278     config_intrhook_disestablish(&sc->amr_ich);
 279
 280     /* get up-to-date drive information */
 281     if (amr_query_controller(sc)) {
 282         device_printf(sc->amr_dev, "can't scan controller for drives\n");
 283         return;
 284     }
 285
 286     /* iterate over available drives */
 287     for (i = 0, dr = &sc->amr_drive[0]; (i < AMR_MAXLD) && (dr->al_size != 0xffffffff); i++, dr++) {
 288         /* are we already attached to this drive? */
 289         if (dr->al_disk == 0) {
 290             /* generate geometry information */
 291             if (dr->al_size > 0x200000) {       /* extended translation? */
 292                 dr->al_heads = 255;
 293                 dr->al_sectors = 63;
 294             } else {
 295                 dr->al_heads = 64;
 296                 dr->al_sectors = 32;
 297             }
 298             dr->al_cylinders = dr->al_size / (dr->al_heads * dr->al_sectors);
 299
 300             dr->al_disk = device_add_child(sc->amr_dev, NULL, -1);
 301             if (dr->al_disk == 0)
 302                 device_printf(sc->amr_dev, "device_add_child failed\n");
 303             device_set_ivars(dr->al_disk, dr);
 304         }
 305     }
 306
 307     if ((error = bus_generic_attach(sc->amr_dev)) != 0)
 308         device_printf(sc->amr_dev, "bus_generic_attach returned %d\n", error);
 309
 310     /* mark controller back up */
 311     sc->amr_state &= ~AMR_STATE_SHUTDOWN;
 312
 313     /* interrupts will be enabled before we do anything more */
 314     sc->amr_state |= AMR_STATE_INTEN;
 315
 316     /*
 317      * Start the timeout routine.
 318      */
 319 /*    callout_reset(&sc->amr_timeout, hz, amr_periodic, sc); */
 320
 321     return;
 322 }
 323
 324 /*******************************************************************************
 325  * Free resources associated with a controller instance
 326  */
 327 void
 328 amr_free(struct amr_softc *sc)
 329 {
 330     struct amr_command_cluster  *acc;
 331
 332     /* detach from CAM */
 333     amr_cam_detach(sc);
 334
 335     /* cancel status timeout */
 336     callout_stop(&sc->amr_timeout);
 337
 338     /* throw away any command buffers */
 339     while ((acc = TAILQ_FIRST(&sc->amr_cmd_clusters)) != NULL) {
 340         TAILQ_REMOVE(&sc->amr_cmd_clusters, acc, acc_link);
 341         amr_freecmd_cluster(acc);
 342     }
 343
 344     /* destroy control device */
 345     if( sc->amr_dev_t != (cdev_t)NULL)
 346             destroy_dev(sc->amr_dev_t);
 347     dev_ops_remove_minor(&amr_ops, device_get_unit(sc->amr_dev));
 348 }
 349
 350 /*******************************************************************************
 351  * Receive a bio structure from a child device and queue it on a particular
 352  * disk resource, then poke the disk resource to start as much work as it can.
 353  */
 354 int
 355 amr_submit_bio(struct amr_softc *sc, struct bio *bio)
 356 {
 357     debug_called(2);
 358
 359     amr_enqueue_bio(sc, bio);
 360     amr_startio(sc);
 361     return(0);
 362 }
 363
 364 /********************************************************************************
 365  * Accept an open operation on the control device.
 366  */
 367 static int
 368 amr_open(struct dev_open_args *ap)
 369 {
 370     cdev_t dev = ap->a_head.a_dev;
 371     int                 unit = minor(dev);
 372     struct amr_softc    *sc = devclass_get_softc(devclass_find("amr"), unit);
 373
 374     debug_called(1);
 375
 376     sc->amr_state |= AMR_STATE_OPEN;
 377     return(0);
 378 }
 379
 380 /********************************************************************************
 381  * Accept the last close on the control device.
 382  */
 383 static int
 384 amr_close(struct dev_close_args *ap)
 385 {
 386     cdev_t dev = ap->a_head.a_dev;
 387     int                 unit = minor(dev);
 388     struct amr_softc    *sc = devclass_get_softc(devclass_find("amr"), unit);
 389
 390     debug_called(1);
 391
 392     sc->amr_state &= ~AMR_STATE_OPEN;
 393     return (0);
 394 }
 395
 396 /********************************************************************************
 397  * Handle controller-specific control operations.
 398  */
 399 static int
 400 amr_ioctl(struct dev_ioctl_args *ap)
 401 {
 402     cdev_t dev = ap->a_head.a_dev;
 403     struct amr_softc            *sc = (struct amr_softc *)dev->si_drv1;
 404     int                         *arg = (int *)ap->a_data;
 405     struct amr_user_ioctl       *au = (struct amr_user_ioctl *)ap->a_data;
 406     struct amr_command          *ac;
 407     struct amr_mailbox_ioctl    *mbi;
 408     struct amr_passthrough      *apt;
 409     void                        *dp;
 410     int                         error;
 411
 412     debug_called(1);
 413
 414     error = 0;
 415     dp = NULL;
 416     apt = NULL;
 417     ac = NULL;
 418     switch(ap->a_cmd) {
 419
 420     case AMR_IO_VERSION:
 421         debug(1, "AMR_IO_VERSION");
 422         *arg = AMR_IO_VERSION_NUMBER;
 423         break;
 424
 425     case AMR_IO_COMMAND:
 426         debug(1, "AMR_IO_COMMAND  0x%x", au->au_cmd[0]);
 427         /* handle inbound data buffer */
 428         if (au->au_length != 0) {
 429             dp = kmalloc(au->au_length, M_DEVBUF, M_WAITOK);
 430             if ((error = copyin(au->au_buffer, dp, au->au_length)) != 0)
 431                 break;
 432             debug(2, "copyin %ld bytes from %p -> %p", au->au_length, au->au_buffer, dp);
 433         }
 434
 435         if ((ac = amr_alloccmd(sc)) == NULL) {
 436             error = ENOMEM;
 437             break;
 438         }
 439
 440         /* handle SCSI passthrough command */
 441         if (au->au_cmd[0] == AMR_CMD_PASS) {
 442             apt = kmalloc(sizeof(*apt), M_DEVBUF, M_WAITOK | M_ZERO);
 443
 444             /* copy cdb */
 445             apt->ap_cdb_length = au->au_cmd[2];
 446             bcopy(&au->au_cmd[3], &apt->ap_cdb[0], apt->ap_cdb_length);
 447
 448             /* build passthrough */
 449             apt->ap_timeout             = au->au_cmd[apt->ap_cdb_length + 3] & 0x07;
 450             apt->ap_ars                 = (au->au_cmd[apt->ap_cdb_length + 3] & 0x08) ? 1 : 0;
 451             apt->ap_islogical           = (au->au_cmd[apt->ap_cdb_length + 3] & 0x80) ? 1 : 0;
 452             apt->ap_logical_drive_no    = au->au_cmd[apt->ap_cdb_length + 4];
 453             apt->ap_channel             = au->au_cmd[apt->ap_cdb_length + 5];
 454             apt->ap_scsi_id             = au->au_cmd[apt->ap_cdb_length + 6];
 455             apt->ap_request_sense_length        = 14;
 456             apt->ap_data_transfer_length = au->au_length;
 457             /* XXX what about the request-sense area? does the caller want it? */
 458
 459             /* build command */
 460             ac->ac_data = apt;
 461             ac->ac_length = sizeof(*apt);
 462             ac->ac_flags |= AMR_CMD_DATAOUT;
 463             ac->ac_ccb_data = dp;
 464             ac->ac_ccb_length = au->au_length;
 465             if (au->au_direction & AMR_IO_READ)
 466                 ac->ac_flags |= AMR_CMD_CCB_DATAIN;
 467             if (au->au_direction & AMR_IO_WRITE)
 468                 ac->ac_flags |= AMR_CMD_CCB_DATAOUT;
 469
 470             ac->ac_mailbox.mb_command = AMR_CMD_PASS;
 471
 472         } else {
 473             /* direct command to controller */
 474             mbi = (struct amr_mailbox_ioctl *)&ac->ac_mailbox;
 475
 476             /* copy pertinent mailbox items */
 477             mbi->mb_command = au->au_cmd[0];
 478             mbi->mb_channel = au->au_cmd[1];
 479             mbi->mb_param = au->au_cmd[2];
 480             mbi->mb_pad[0] = au->au_cmd[3];
 481             mbi->mb_drive = au->au_cmd[4];
 482
 483             /* build the command */
 484             ac->ac_data = dp;
 485             ac->ac_length = au->au_length;
 486             if (au->au_direction & AMR_IO_READ)
 487                 ac->ac_flags |= AMR_CMD_DATAIN;
 488             if (au->au_direction & AMR_IO_WRITE)
 489                 ac->ac_flags |= AMR_CMD_DATAOUT;
 490         }
 491
 492         /* run the command */
 493         if ((error = amr_wait_command(ac)) != 0)
 494             break;
 495
 496         /* copy out data and set status */
 497         if (au->au_length != 0)
 498             error = copyout(dp, au->au_buffer, au->au_length);
 499         debug(2, "copyout %ld bytes from %p -> %p", au->au_length, dp, au->au_buffer);
 500         if (dp != NULL)
 501             debug(2, "%16d", (int)dp);
 502         au->au_status = ac->ac_status;
 503         break;
 504
 505     default:
 506         debug(1, "unknown ioctl 0x%lx", cmd);
 507         error = ENOIOCTL;
 508         break;
 509     }
 510
 511     if (dp != NULL)
 512         kfree(dp, M_DEVBUF);
 513     if (apt != NULL)
 514         kfree(apt, M_DEVBUF);
 515     if (ac != NULL)
 516         amr_releasecmd(ac);
 517     return(error);
 518 }
 519
 520 /********************************************************************************
 521  ********************************************************************************
 522                                                                 Status Monitoring
 523  ********************************************************************************
 524  ********************************************************************************/
 525
 526 /********************************************************************************
 527  * Perform a periodic check of the controller status
 528  */
 529 static void
 530 amr_periodic(void *data)
 531 {
 532     struct amr_softc    *sc = (struct amr_softc *)data;
 533
 534     debug_called(2);
 535
 536     /* XXX perform periodic status checks here */
 537
 538     /* compensate for missed interrupts */
 539     amr_done(sc);
 540
 541     /* reschedule */
 542     callout_reset(&sc->amr_timeout, hz, amr_periodic, sc);
 543 }
 544
 545 /********************************************************************************
 546  ********************************************************************************
 547                                                                  Command Wrappers
 548  ********************************************************************************
 549  ********************************************************************************/
 550
 551 /********************************************************************************
 552  * Interrogate the controller for the operational parameters we require.
 553  */
 554 static int
 555 amr_query_controller(struct amr_softc *sc)
 556 {
 557     struct amr_enquiry3 *aex;
 558     struct amr_prodinfo *ap;
 559     struct amr_enquiry  *ae;
 560     int                 ldrv;
 561
 562     /*
 563      * If we haven't found the real limit yet, let us have a couple of commands in
 564      * order to be able to probe.
 565      */
 566     if (sc->amr_maxio == 0)
 567         sc->amr_maxio = 2;
 568
 569     /*
 570      * Greater than 10 byte cdb support
 571      */
 572     sc->support_ext_cdb = amr_support_ext_cdb(sc);
 573
 574     if(sc->support_ext_cdb) {
 575         debug(2,"supports extended CDBs.");
 576     }
 577
 578     /*
 579      * Try to issue an ENQUIRY3 command
 580      */
 581     if ((aex = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_ENQ3,
 582                            AMR_CONFIG_ENQ3_SOLICITED_FULL)) != NULL) {
 583
 584         /*
 585          * Fetch current state of logical drives.
 586          */
 587         for (ldrv = 0; ldrv < aex->ae_numldrives; ldrv++) {
 588             sc->amr_drive[ldrv].al_size       = aex->ae_drivesize[ldrv];
 589             sc->amr_drive[ldrv].al_state      = aex->ae_drivestate[ldrv];
 590             sc->amr_drive[ldrv].al_properties = aex->ae_driveprop[ldrv];
 591             debug(2, "  drive %d: %d state %x properties %x\n", ldrv, sc->amr_drive[ldrv].al_size,
 592                   sc->amr_drive[ldrv].al_state, sc->amr_drive[ldrv].al_properties);
 593         }
 594         kfree(aex, M_DEVBUF);
 595
 596         /*
 597          * Get product info for channel count.
 598          */
 599         if ((ap = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_PRODUCT_INFO, 0)) == NULL) {
 600             device_printf(sc->amr_dev, "can't obtain product data from controller\n");
 601             return(1);
 602         }
 603         sc->amr_maxdrives = 40;
 604         sc->amr_maxchan = ap->ap_nschan;
 605         sc->amr_maxio = ap->ap_maxio;
 606         sc->amr_type |= AMR_TYPE_40LD;
 607         kfree(ap, M_DEVBUF);
 608
 609     } else {
 610
 611         /* failed, try the 8LD ENQUIRY commands */
 612         if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_EXT_ENQUIRY2, 0, 0)) == NULL) {
 613             if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_ENQUIRY, 0, 0)) == NULL) {
 614                 device_printf(sc->amr_dev, "can't obtain configuration data from controller\n");
 615                 return(1);
 616             }
 617             ae->ae_signature = 0;
 618         }
 619
 620         /*
 621          * Fetch current state of logical drives.
 622          */
 623         for (ldrv = 0; ldrv < ae->ae_ldrv.al_numdrives; ldrv++) {
 624             sc->amr_drive[ldrv].al_size       = ae->ae_ldrv.al_size[ldrv];
 625             sc->amr_drive[ldrv].al_state      = ae->ae_ldrv.al_state[ldrv];
 626             sc->amr_drive[ldrv].al_properties = ae->ae_ldrv.al_properties[ldrv];
 627             debug(2, "  drive %d: %d state %x properties %x\n", ldrv, sc->amr_drive[ldrv].al_size,
 628                   sc->amr_drive[ldrv].al_state, sc->amr_drive[ldrv].al_properties);
 629         }
 630
 631         sc->amr_maxdrives = 8;
 632         sc->amr_maxchan = ae->ae_adapter.aa_channels;
 633         sc->amr_maxio = ae->ae_adapter.aa_maxio;
 634         kfree(ae, M_DEVBUF);
 635     }
 636
 637     /*
 638      * Mark remaining drives as unused.
 639      */
 640     for (; ldrv < AMR_MAXLD; ldrv++)
 641         sc->amr_drive[ldrv].al_size = 0xffffffff;
 642
 643     /*
 644      * Cap the maximum number of outstanding I/Os.  AMI's Linux driver doesn't trust
 645      * the controller's reported value, and lockups have been seen when we do.
 646      */
 647     sc->amr_maxio = imin(sc->amr_maxio, AMR_LIMITCMD);
 648
 649     return(0);
 650 }
 651
 652 /********************************************************************************
 653  * Run a generic enquiry-style command.
 654  */
 655 static void *
 656 amr_enquiry(struct amr_softc *sc, size_t bufsize, u_int8_t cmd, u_int8_t cmdsub, u_int8_t cmdqual)
 657 {
 658     struct amr_command  *ac;
 659     void                *result;
 660     u_int8_t            *mbox;
 661     int                 error;
 662
 663     debug_called(1);
 664
 665     error = 1;
 666     result = NULL;
 667
 668     /* get ourselves a command buffer */
 669     if ((ac = amr_alloccmd(sc)) == NULL)
 670         goto out;
 671     /* allocate the response structure */
 672     result = kmalloc(bufsize, M_DEVBUF, M_INTWAIT);
 673     /* set command flags */
 674     ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
 675
 676     /* point the command at our data */
 677     ac->ac_data = result;
 678     ac->ac_length = bufsize;
 679
 680     /* build the command proper */
 681     mbox = (u_int8_t *)&ac->ac_mailbox;         /* XXX want a real structure for this? */
 682     mbox[0] = cmd;
 683     mbox[2] = cmdsub;
 684     mbox[3] = cmdqual;
 685
 686     /* can't assume that interrupts are going to work here, so play it safe */
 687     if (sc->amr_poll_command(ac))
 688         goto out;
 689     error = ac->ac_status;
 690
 691  out:
 692     if (ac != NULL)
 693         amr_releasecmd(ac);
 694     if ((error != 0) && (result != NULL)) {
 695         kfree(result, M_DEVBUF);
 696         result = NULL;
 697     }
 698     return(result);
 699 }
 700
 701 /********************************************************************************
 702  * Flush the controller's internal cache, return status.
 703  */
 704 int
 705 amr_flush(struct amr_softc *sc)
 706 {
 707     struct amr_command  *ac;
 708     int                 error;
 709
 710     /* get ourselves a command buffer */
 711     error = 1;
 712     if ((ac = amr_alloccmd(sc)) == NULL)
 713         goto out;
 714     /* set command flags */
 715     ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
 716
 717     /* build the command proper */
 718     ac->ac_mailbox.mb_command = AMR_CMD_FLUSH;
 719
 720     /* we have to poll, as the system may be going down or otherwise damaged */
 721     if (sc->amr_poll_command(ac))
 722         goto out;
 723     error = ac->ac_status;
 724
 725  out:
 726     if (ac != NULL)
 727         amr_releasecmd(ac);
 728     return(error);
 729 }
 730
 731 /********************************************************************************
 732  * Detect extented cdb >> greater than 10 byte cdb support
 733  * returns '1' means this support exist
 734  * returns '0' means this support doesn't exist
 735  */
 736 static int
 737 amr_support_ext_cdb(struct amr_softc *sc)
 738 {
 739     struct amr_command  *ac;
 740     u_int8_t            *mbox;
 741     int                 error;
 742
 743     /* get ourselves a command buffer */
 744     error = 0;
 745     if ((ac = amr_alloccmd(sc)) == NULL)
 746         goto out;
 747     /* set command flags */
 748     ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
 749
 750     /* build the command proper */
 751     mbox = (u_int8_t *)&ac->ac_mailbox;         /* XXX want a real structure for this? */
 752     mbox[0] = 0xA4;
 753     mbox[2] = 0x16;
 754
 755
 756     /* we have to poll, as the system may be going down or otherwise damaged */
 757     if (sc->amr_poll_command(ac))
 758         goto out;
 759     if( ac->ac_status == AMR_STATUS_SUCCESS ) {
 760             error = 1;
 761     }
 762
 763 out:
 764     if (ac != NULL)
 765         amr_releasecmd(ac);
 766     return(error);
 767 }
 768
 769 /********************************************************************************
 770  * Try to find I/O work for the controller from one or more of the work queues.
 771  *
 772  * We make the assumption that if the controller is not ready to take a command
 773  * at some given time, it will generate an interrupt at some later time when
 774  * it is.
 775  */
 776 void
 777 amr_startio(struct amr_softc *sc)
 778 {
 779     struct amr_command  *ac;
 780
 781     /* spin until something prevents us from doing any work */
 782     for (;;) {
 783
 784         /* try to get a ready command */
 785         ac = amr_dequeue_ready(sc);
 786
 787         /* if that failed, build a command from a bio */
 788         if (ac == NULL)
 789             (void)amr_bio_command(sc, &ac);
 790
 791         /* if that failed, build a command from a ccb */
 792         if (ac == NULL)
 793             (void)amr_cam_command(sc, &ac);
 794
 795         /* if we don't have anything to do, give up */
 796         if (ac == NULL)
 797             break;
 798
 799         /* try to give the command to the controller; if this fails save it for later and give up */
 800         if (amr_start(ac)) {
 801             debug(2, "controller busy, command deferred");
 802             amr_requeue_ready(ac);      /* XXX schedule retry very soon? */
 803             break;
 804         }
 805     }
 806 }
 807
 808 /********************************************************************************
 809  * Handle completion of an I/O command.
 810  */
 811 static void
 812 amr_completeio(struct amr_command *ac)
 813 {
 814     struct amr_softc    *sc = ac->ac_sc;
 815
 816     if (ac->ac_status != AMR_STATUS_SUCCESS) {  /* could be more verbose here? */
 817         ac->ac_bio->bio_buf->b_error = EIO;
 818         ac->ac_bio->bio_buf->b_flags |= B_ERROR;
 819
 820         device_printf(sc->amr_dev, "I/O error - 0x%x\n", ac->ac_status);
 821 /*      amr_printcommand(ac);*/
 822     }
 823     amrd_intr(ac->ac_bio);
 824     amr_releasecmd(ac);
 825 }
 826
 827 /********************************************************************************
 828  ********************************************************************************
 829                                                                Command Processing
 830  ********************************************************************************
 831  ********************************************************************************/
 832
 833 /********************************************************************************
 834  * Convert a bio off the top of the bio queue into a command.
 835  */
 836 static int
 837 amr_bio_command(struct amr_softc *sc, struct amr_command **acp)
 838 {
 839     struct amr_command  *ac;
 840     struct amrd_softc   *amrd;
 841     struct bio          *bio;
 842     int                 error;
 843     int                 blkcount;
 844     int                 driveno;
 845     int                 cmd;
 846     u_int64_t           lba;
 847
 848     ac = NULL;
 849     error = 0;
 850
 851     /* get a bio to work on */
 852     if ((bio = amr_dequeue_bio(sc)) == NULL)
 853         goto out;
 854
 855     /* get a command */
 856     if ((ac = amr_alloccmd(sc)) == NULL) {
 857         error = ENOMEM;
 858         goto out;
 859     }
 860
 861     /* connect the bio to the command */
 862     ac->ac_complete = amr_completeio;
 863     ac->ac_bio = bio;
 864     ac->ac_data = bio->bio_buf->b_data;
 865     ac->ac_length = bio->bio_buf->b_bcount;
 866
 867     switch (bio->bio_buf->b_cmd) {
 868     case BUF_CMD_READ:
 869         ac->ac_flags |= AMR_CMD_DATAIN;
 870         cmd = AMR_CMD_LREAD;
 871         break;
 872     case BUF_CMD_WRITE:
 873         ac->ac_flags |= AMR_CMD_DATAOUT;
 874         cmd = AMR_CMD_LWRITE;
 875         break;
 876     case BUF_CMD_FLUSH:
 877         ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
 878         cmd = AMR_CMD_FLUSH;
 879         break;
 880     default:
 881         cmd = 0;
 882         break;
 883     }
 884     amrd = (struct amrd_softc *)bio->bio_driver_info;
 885     driveno = amrd->amrd_drive - sc->amr_drive;
 886     blkcount = (bio->bio_buf->b_bcount + AMR_BLKSIZE - 1) / AMR_BLKSIZE;
 887
 888     lba = bio->bio_offset / AMR_BLKSIZE;
 889     KKASSERT(lba < 0x100000000ULL);
 890
 891     ac->ac_mailbox.mb_command = cmd;
 892     ac->ac_mailbox.mb_blkcount = blkcount;
 893     ac->ac_mailbox.mb_lba = lba;
 894     ac->ac_mailbox.mb_drive = driveno;
 895     /* we fill in the s/g related data when the command is mapped */
 896
 897     if ((lba + blkcount) > sc->amr_drive[driveno].al_size)
 898         device_printf(sc->amr_dev, "I/O beyond end of unit (%ju,%d > %lu)\n",
 899                       (uintmax_t)lba, blkcount,
 900                       (u_long)sc->amr_drive[driveno].al_size);
 901
 902 out:
 903     if (error != 0) {
 904         if (ac != NULL)
 905             amr_releasecmd(ac);
 906         if (bio != NULL)                        /* this breaks ordering... */
 907             amr_enqueue_bio(sc, bio);
 908     }
 909     *acp = ac;
 910     return(error);
 911 }
 912
 913 /********************************************************************************
 914  * Take a command, submit it to the controller and sleep until it completes
 915  * or fails.  Interrupts must be enabled, returns nonzero on error.
 916  */
 917 static int
 918 amr_wait_command(struct amr_command *ac)
 919 {
 920     int                 error, count;
 921
 922     debug_called(1);
 923
 924     ac->ac_complete = NULL;
 925     ac->ac_flags |= AMR_CMD_SLEEP;
 926     if ((error = amr_start(ac)) != 0)
 927         return(error);
 928
 929     count = 0;
 930     /* XXX better timeout? */
 931     while ((ac->ac_flags & AMR_CMD_BUSY) && (count < 30)) {
 932         tsleep(ac, PCATCH, "amrwcmd", hz);
 933     }
 934     return(0);
 935 }
 936
 937 /********************************************************************************
 938  * Take a command, submit it to the controller and busy-wait for it to return.
 939  * Returns nonzero on error.  Can be safely called with interrupts enabled.
 940  */
 941 static int
 942 amr_std_poll_command(struct amr_command *ac)
 943 {
 944     struct amr_softc    *sc = ac->ac_sc;
 945     int                 error, count;
 946
 947     debug_called(2);
 948
 949     ac->ac_complete = NULL;
 950     if ((error = amr_start(ac)) != 0)
 951         return(error);
 952
 953     count = 0;
 954     do {
 955         /*
 956          * Poll for completion, although the interrupt handler may beat us to it.
 957          * Note that the timeout here is somewhat arbitrary.
 958          */
 959         amr_done(sc);
 960         DELAY(1000);
 961     } while ((ac->ac_flags & AMR_CMD_BUSY) && (count++ < 1000));
 962     if (!(ac->ac_flags & AMR_CMD_BUSY)) {
 963         error = 0;
 964     } else {
 965         /* XXX the slot is now marked permanently busy */
 966         error = EIO;
 967         device_printf(sc->amr_dev, "polled command timeout\n");
 968     }
 969     return(error);
 970 }
 971
 972 /********************************************************************************
 973  * Take a command, submit it to the controller and busy-wait for it to return.
 974  * Returns nonzero on error.  Can be safely called with interrupts enabled.
 975  */
 976 static int
 977 amr_quartz_poll_command(struct amr_command *ac)
 978 {
 979     struct amr_softc    *sc = ac->ac_sc;
 980     int                 error,count;
 981
 982     debug_called(2);
 983
 984     /* now we have a slot, we can map the command (unmapped in amr_complete) */
 985     amr_mapcmd(ac);
 986
 987     crit_enter();
 988
 989     if (sc->amr_state & AMR_STATE_INTEN) {
 990             count=0;
 991             while (sc->amr_busyslots) {
 992                     tsleep(sc, PCATCH, "amrpoll", hz);
 993                     if(count++>10) {
 994                             break;
 995                     }
 996             }
 997
 998             if(sc->amr_busyslots) {
 999                     device_printf(sc->amr_dev, "adapter is busy\n");
1000                     crit_exit();
1001                     amr_unmapcmd(ac);
1002                     ac->ac_status=0;
1003                     return(1);
1004             }
1005     }
1006
1007     bcopy(&ac->ac_mailbox, (void *)(uintptr_t)(volatile void *)sc->amr_mailbox, AMR_MBOX_CMDSIZE);
1008
1009     /* clear the poll/ack fields in the mailbox */
1010     sc->amr_mailbox->mb_ident = 0xFE;
1011     sc->amr_mailbox->mb_nstatus = 0xFF;
1012     sc->amr_mailbox->mb_status = 0xFF;
1013     sc->amr_mailbox->mb_poll = 0;
1014     sc->amr_mailbox->mb_ack = 0;
1015     sc->amr_mailbox->mb_busy = 1;
1016
1017     AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_SUBMIT);
1018
1019     while(sc->amr_mailbox->mb_nstatus == 0xFF);
1020     while(sc->amr_mailbox->mb_status == 0xFF);
1021     ac->ac_status=sc->amr_mailbox->mb_status;
1022     error = (ac->ac_status !=AMR_STATUS_SUCCESS) ? 1:0;
1023     while(sc->amr_mailbox->mb_poll != 0x77);
1024     sc->amr_mailbox->mb_poll = 0;
1025     sc->amr_mailbox->mb_ack = 0x77;
1026
1027     /* acknowledge that we have the commands */
1028     AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_ACK);
1029     while(AMR_QGET_IDB(sc) & AMR_QIDB_ACK);
1030
1031     crit_exit();
1032
1033     /* unmap the command's data buffer */
1034     amr_unmapcmd(ac);
1035
1036     return(error);
1037 }
1038
1039 /********************************************************************************
1040  * Get a free command slot for a command if it doesn't already have one.
1041  *
1042  * May be safely called multiple times for a given command.
1043  */
1044 static int
1045 amr_getslot(struct amr_command *ac)
1046 {
1047     struct amr_softc    *sc = ac->ac_sc;
1048     int                 slot, limit, error;
1049
1050     debug_called(3);
1051
1052     /* if the command already has a slot, don't try to give it another one */
1053     if (ac->ac_slot != 0)
1054         return(0);
1055
1056     /* enforce slot usage limit */
1057     limit = (ac->ac_flags & AMR_CMD_PRIORITY) ? sc->amr_maxio : sc->amr_maxio - 4;
1058     if (sc->amr_busyslots > limit)
1059         return(EBUSY);
1060
1061     /*
1062      * Allocate a slot.  XXX linear scan is slow
1063      */
1064     error = EBUSY;
1065     crit_enter();
1066     for (slot = 0; slot < sc->amr_maxio; slot++) {
1067         if (sc->amr_busycmd[slot] == NULL) {
1068             sc->amr_busycmd[slot] = ac;
1069             sc->amr_busyslots++;
1070             ac->ac_slot = slot;
1071             error = 0;
1072             break;
1073         }
1074     }
1075     crit_exit();
1076
1077     return(error);
1078 }
1079
1080 /********************************************************************************
1081  * Map/unmap (ac)'s data in the controller's addressable space as required.
1082  *
1083  * These functions may be safely called multiple times on a given command.
1084  */
1085 static void
1086 amr_setup_dmamap(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1087 {
1088     struct amr_command  *ac = (struct amr_command *)arg;
1089     struct amr_softc    *sc = ac->ac_sc;
1090     struct amr_sgentry  *sg;
1091     int                 i;
1092     u_int8_t            *sgc;
1093
1094     debug_called(3);
1095
1096     /* get base address of s/g table */
1097     sg = sc->amr_sgtable + (ac->ac_slot * AMR_NSEG);
1098
1099     /* save data physical address */
1100     ac->ac_dataphys = segs[0].ds_addr;
1101
1102     /* for AMR_CMD_CONFIG the s/g count goes elsewhere */
1103     if (ac->ac_mailbox.mb_command == AMR_CMD_CONFIG) {
1104         sgc = &(((struct amr_mailbox_ioctl *)&ac->ac_mailbox)->mb_param);
1105     } else {
1106         sgc = &ac->ac_mailbox.mb_nsgelem;
1107     }
1108
1109     /* decide whether we need to populate the s/g table */
1110     if (nsegments < 2) {
1111         *sgc = 0;
1112         ac->ac_mailbox.mb_nsgelem = 0;
1113         ac->ac_mailbox.mb_physaddr = ac->ac_dataphys;
1114     } else {
1115         ac->ac_mailbox.mb_nsgelem = nsegments;
1116         *sgc = nsegments;
1117         ac->ac_mailbox.mb_physaddr = sc->amr_sgbusaddr + (ac->ac_slot * AMR_NSEG * sizeof(struct amr_sgentry));
1118         for (i = 0; i < nsegments; i++, sg++) {
1119             sg->sg_addr = segs[i].ds_addr;
1120             sg->sg_count = segs[i].ds_len;
1121         }
1122     }
1123 }
1124
1125 static void
1126 amr_setup_ccbmap(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1127 {
1128     struct amr_command          *ac = (struct amr_command *)arg;
1129     struct amr_softc            *sc = ac->ac_sc;
1130     struct amr_sgentry          *sg;
1131     struct amr_passthrough      *ap = (struct amr_passthrough *)ac->ac_data;
1132     struct amr_ext_passthrough  *aep = (struct amr_ext_passthrough *)ac->ac_data;
1133     int                         i;
1134
1135     /* get base address of s/g table */
1136     sg = sc->amr_sgtable + (ac->ac_slot * AMR_NSEG);
1137
1138     /* decide whether we need to populate the s/g table */
1139     if( ac->ac_mailbox.mb_command == AMR_CMD_EXTPASS ) {
1140         if (nsegments < 2) {
1141             aep->ap_no_sg_elements = 0;
1142             aep->ap_data_transfer_address =  segs[0].ds_addr;
1143         } else {
1144             /* save s/g table information in passthrough */
1145             aep->ap_no_sg_elements = nsegments;
1146             aep->ap_data_transfer_address = sc->amr_sgbusaddr + (ac->ac_slot * AMR_NSEG * sizeof(struct amr_sgentry));
1147             /* populate s/g table (overwrites previous call which mapped the passthrough) */
1148             for (i = 0; i < nsegments; i++, sg++) {
1149                 sg->sg_addr = segs[i].ds_addr;
1150                 sg->sg_count = segs[i].ds_len;
1151                 debug(3, " %d: 0x%x/%d", i, sg->sg_addr, sg->sg_count);
1152             }
1153         }
1154         debug(3, "slot %d  %d segments at 0x%x, passthrough at 0x%x", ac->ac_slot,
1155             aep->ap_no_sg_elements, aep->ap_data_transfer_address, ac->ac_dataphys);
1156     } else {
1157         if (nsegments < 2) {
1158             ap->ap_no_sg_elements = 0;
1159             ap->ap_data_transfer_address =  segs[0].ds_addr;
1160         } else {
1161             /* save s/g table information in passthrough */
1162             ap->ap_no_sg_elements = nsegments;
1163             ap->ap_data_transfer_address = sc->amr_sgbusaddr + (ac->ac_slot * AMR_NSEG * sizeof(struct amr_sgentry));
1164             /* populate s/g table (overwrites previous call which mapped the passthrough) */
1165             for (i = 0; i < nsegments; i++, sg++) {
1166                 sg->sg_addr = segs[i].ds_addr;
1167                 sg->sg_count = segs[i].ds_len;
1168                 debug(3, " %d: 0x%x/%d", i, sg->sg_addr, sg->sg_count);
1169             }
1170         }
1171         debug(3, "slot %d  %d segments at 0x%x, passthrough at 0x%x", ac->ac_slot,
1172             ap->ap_no_sg_elements, ap->ap_data_transfer_address, ac->ac_dataphys);
1173     }
1174 }
1175
1176 static void
1177 amr_mapcmd(struct amr_command *ac)
1178 {
1179     struct amr_softc    *sc = ac->ac_sc;
1180
1181     debug_called(3);
1182
1183     /* if the command involves data at all, and hasn't been mapped */
1184     if (!(ac->ac_flags & AMR_CMD_MAPPED)) {
1185
1186         if (ac->ac_data != NULL) {
1187             /* map the data buffers into bus space and build the s/g list */
1188             bus_dmamap_load(sc->amr_buffer_dmat, ac->ac_dmamap, ac->ac_data, ac->ac_length,
1189                             amr_setup_dmamap, ac, 0);
1190             if (ac->ac_flags & AMR_CMD_DATAIN)
1191                 bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_PREREAD);
1192             if (ac->ac_flags & AMR_CMD_DATAOUT)
1193                 bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_PREWRITE);
1194         }
1195
1196         if (ac->ac_ccb_data != NULL) {
1197             bus_dmamap_load(sc->amr_buffer_dmat, ac->ac_ccb_dmamap, ac->ac_ccb_data, ac->ac_ccb_length,
1198                             amr_setup_ccbmap, ac, 0);
1199             if (ac->ac_flags & AMR_CMD_CCB_DATAIN)
1200                 bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_ccb_dmamap, BUS_DMASYNC_PREREAD);
1201             if (ac->ac_flags & AMR_CMD_CCB_DATAOUT)
1202                 bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_ccb_dmamap, BUS_DMASYNC_PREWRITE);
1203         }
1204         ac->ac_flags |= AMR_CMD_MAPPED;
1205     }
1206 }
1207
1208 static void
1209 amr_unmapcmd(struct amr_command *ac)
1210 {
1211     struct amr_softc    *sc = ac->ac_sc;
1212
1213     debug_called(3);
1214
1215     /* if the command involved data at all and was mapped */
1216     if (ac->ac_flags & AMR_CMD_MAPPED) {
1217
1218         if (ac->ac_data != NULL) {
1219             if (ac->ac_flags & AMR_CMD_DATAIN)
1220                 bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_POSTREAD);
1221             if (ac->ac_flags & AMR_CMD_DATAOUT)
1222                 bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_POSTWRITE);
1223             bus_dmamap_unload(sc->amr_buffer_dmat, ac->ac_dmamap);
1224         }
1225
1226         if (ac->ac_ccb_data != NULL) {
1227             if (ac->ac_flags & AMR_CMD_CCB_DATAIN)
1228                 bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_ccb_dmamap, BUS_DMASYNC_POSTREAD);
1229             if (ac->ac_flags & AMR_CMD_CCB_DATAOUT)
1230                 bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_ccb_dmamap, BUS_DMASYNC_POSTWRITE);
1231             bus_dmamap_unload(sc->amr_buffer_dmat, ac->ac_ccb_dmamap);
1232         }
1233         ac->ac_flags &= ~AMR_CMD_MAPPED;
1234     }
1235 }
1236
1237 /********************************************************************************
1238  * Take a command and give it to the controller, returns 0 if successful, or
1239  * EBUSY if the command should be retried later.
1240  */
1241 static int
1242 amr_start(struct amr_command *ac)
1243 {
1244     struct amr_softc    *sc = ac->ac_sc;
1245     int                 done, i;
1246
1247     debug_called(3);
1248
1249     /* mark command as busy so that polling consumer can tell */
1250     ac->ac_flags |= AMR_CMD_BUSY;
1251
1252     /* get a command slot (freed in amr_done) */
1253     if (amr_getslot(ac))
1254         return(EBUSY);
1255
1256     /* now we have a slot, we can map the command (unmapped in amr_complete) */
1257     amr_mapcmd(ac);
1258
1259     /* mark the new mailbox we are going to copy in as busy */
1260     ac->ac_mailbox.mb_busy = 1;
1261
1262     /* clear the poll/ack fields in the mailbox */
1263     sc->amr_mailbox->mb_poll = 0;
1264     sc->amr_mailbox->mb_ack = 0;
1265
1266     /*
1267      * Save the slot number so that we can locate this command when complete.
1268      * Note that ident = 0 seems to be special, so we don't use it.
1269      */
1270     ac->ac_mailbox.mb_ident = ac->ac_slot + 1;
1271
1272     /*
1273      * Spin waiting for the mailbox, give up after ~1 second.  We expect the
1274      * controller to be able to handle our I/O.
1275      *
1276      * XXX perhaps we should wait for less time, and count on the deferred command
1277      * handling to deal with retries?
1278      */
1279     debug(4, "wait for mailbox");
1280     for (i = 10000, done = 0; (i > 0) && !done; i--) {
1281         crit_enter();
1282
1283         /* is the mailbox free? */
1284         if (sc->amr_mailbox->mb_busy == 0) {
1285             debug(4, "got mailbox");
1286             sc->amr_mailbox64->mb64_segment = 0;
1287             bcopy(&ac->ac_mailbox, (void *)(uintptr_t)(volatile void *)sc->amr_mailbox, AMR_MBOX_CMDSIZE);
1288             done = 1;
1289
1290             /* not free, spin waiting */
1291         } else {
1292             debug(4, "busy flag %x\n", sc->amr_mailbox->mb_busy);
1293             /* this is somewhat ugly */
1294             DELAY(100);
1295         }
1296         crit_exit();
1297     }
1298
1299     /*
1300      * Now give the command to the controller
1301      */
1302     if (done) {
1303         if (sc->amr_submit_command(sc)) {
1304             /* the controller wasn't ready to take the command, forget that we tried to post it */
1305             sc->amr_mailbox->mb_busy = 0;
1306             return(EBUSY);
1307         }
1308         debug(3, "posted command");
1309         return(0);
1310     }
1311
1312     /*
1313      * The controller wouldn't take the command.  Return the command as busy
1314      * so that it is retried later.
1315      */
1316     return(EBUSY);
1317 }
1318
1319 /********************************************************************************
1320  * Extract one or more completed commands from the controller (sc)
1321  *
1322  * Returns nonzero if any commands on the work queue were marked as completed.
1323  */
1324 int
1325 amr_done(struct amr_softc *sc)
1326 {
1327     struct amr_command  *ac;
1328     struct amr_mailbox  mbox;
1329     int                 i, idx, result;
1330
1331     debug_called(3);
1332
1333     /* See if there's anything for us to do */
1334     result = 0;
1335
1336     /* loop collecting completed commands */
1337     for (;;) {
1338         /* poll for a completed command's identifier and status */
1339         if (sc->amr_get_work(sc, &mbox)) {
1340             result = 1;
1341
1342             /* iterate over completed commands in this result */
1343             for (i = 0; i < mbox.mb_nstatus; i++) {
1344                 /* get pointer to busy command */
1345                 idx = mbox.mb_completed[i] - 1;
1346                 ac = sc->amr_busycmd[idx];
1347
1348                 /* really a busy command? */
1349                 if (ac != NULL) {
1350
1351                     /* pull the command from the busy index */
1352                     sc->amr_busycmd[idx] = NULL;
1353                     sc->amr_busyslots--;
1354
1355                     /* save status for later use */
1356                     ac->ac_status = mbox.mb_status;
1357                     amr_enqueue_completed(ac);
1358                     debug(3, "completed command with status %x", mbox.mb_status);
1359                 } else {
1360                     device_printf(sc->amr_dev, "bad slot %d completed\n", idx);
1361                 }
1362             }
1363         } else {
1364             break;      /* no work */
1365         }
1366     }
1367
1368     /* if we've completed any commands, try posting some more */
1369     if (result)
1370         amr_startio(sc);
1371
1372     /* handle completion and timeouts */
1373 #if defined(__FreeBSD__) && __FreeBSD_version >= 500005
1374     if (sc->amr_state & AMR_STATE_INTEN)
1375         taskqueue_enqueue(taskqueue_swi, &sc->amr_task_complete);
1376     else
1377 #endif
1378         amr_complete(sc, 0);
1379
1380     return(result);
1381 }
1382
1383 /********************************************************************************
1384  * Do completion processing on done commands on (sc)
1385  */
1386 static void
1387 amr_complete(void *context, int pending)
1388 {
1389     struct amr_softc    *sc = (struct amr_softc *)context;
1390     struct amr_command  *ac;
1391
1392     debug_called(3);
1393
1394     /* pull completed commands off the queue */
1395     for (;;) {
1396         ac = amr_dequeue_completed(sc);
1397         if (ac == NULL)
1398             break;
1399
1400         /* unmap the command's data buffer */
1401         amr_unmapcmd(ac);
1402
1403         /* unbusy the command */
1404         ac->ac_flags &= ~AMR_CMD_BUSY;
1405
1406         /*
1407          * Is there a completion handler?
1408          */
1409         if (ac->ac_complete != NULL) {
1410             ac->ac_complete(ac);
1411
1412             /*
1413              * Is someone sleeping on this one?
1414              */
1415         } else if (ac->ac_flags & AMR_CMD_SLEEP) {
1416             wakeup(ac);
1417         }
1418
1419         if(!sc->amr_busyslots) {
1420             wakeup(sc);
1421         }
1422     }
1423 }
1424
1425 /********************************************************************************
1426  ********************************************************************************
1427                                                         Command Buffer Management
1428  ********************************************************************************
1429  ********************************************************************************/
1430
1431 /********************************************************************************
1432  * Get a new command buffer.
1433  *
1434  * This may return NULL in low-memory cases.
1435  *
1436  * If possible, we recycle a command buffer that's been used before.
1437  */
1438 struct amr_command *
1439 amr_alloccmd(struct amr_softc *sc)
1440 {
1441     struct amr_command  *ac;
1442
1443     debug_called(3);
1444
1445     ac = amr_dequeue_free(sc);
1446     if (ac == NULL) {
1447         amr_alloccmd_cluster(sc);
1448         ac = amr_dequeue_free(sc);
1449     }
1450     if (ac == NULL)
1451         return(NULL);
1452
1453     /* clear out significant fields */
1454     ac->ac_slot = 0;
1455     ac->ac_status = 0;
1456     bzero(&ac->ac_mailbox, sizeof(struct amr_mailbox));
1457     ac->ac_flags = 0;
1458     ac->ac_bio = NULL;
1459     ac->ac_data = NULL;
1460     ac->ac_ccb_data = NULL;
1461     ac->ac_complete = NULL;
1462     return(ac);
1463 }
1464
1465 /********************************************************************************
1466  * Release a command buffer for recycling.
1467  */
1468 void
1469 amr_releasecmd(struct amr_command *ac)
1470 {
1471     debug_called(3);
1472
1473     amr_enqueue_free(ac);
1474 }
1475
1476 /********************************************************************************
1477  * Allocate a new command cluster and initialise it.
1478  */
1479 static void
1480 amr_alloccmd_cluster(struct amr_softc *sc)
1481 {
1482     struct amr_command_cluster  *acc;
1483     struct amr_command          *ac;
1484     int                         i;
1485
1486     acc = kmalloc(AMR_CMD_CLUSTERSIZE, M_DEVBUF, M_INTWAIT);
1487     crit_enter();
1488     TAILQ_INSERT_TAIL(&sc->amr_cmd_clusters, acc, acc_link);
1489     crit_exit();
1490     for (i = 0; i < AMR_CMD_CLUSTERCOUNT; i++) {
1491         ac = &acc->acc_command[i];
1492         bzero(ac, sizeof(*ac));
1493         ac->ac_sc = sc;
1494         if (!bus_dmamap_create(sc->amr_buffer_dmat, 0, &ac->ac_dmamap) &&
1495             !bus_dmamap_create(sc->amr_buffer_dmat, 0, &ac->ac_ccb_dmamap))
1496             amr_releasecmd(ac);
1497     }
1498 }
1499
1500 /********************************************************************************
1501  * Free a command cluster
1502  */
1503 static void
1504 amr_freecmd_cluster(struct amr_command_cluster *acc)
1505 {
1506     struct amr_softc    *sc = acc->acc_command[0].ac_sc;
1507     int                 i;
1508
1509     for (i = 0; i < AMR_CMD_CLUSTERCOUNT; i++)
1510         bus_dmamap_destroy(sc->amr_buffer_dmat, acc->acc_command[i].ac_dmamap);
1511     kfree(acc, M_DEVBUF);
1512 }
1513
1514 /********************************************************************************
1515  ********************************************************************************
1516                                                          Interface-specific Shims
1517  ********************************************************************************
1518  ********************************************************************************/
1519
1520 /********************************************************************************
1521  * Tell the controller that the mailbox contains a valid command
1522  */
1523 static int
1524 amr_quartz_submit_command(struct amr_softc *sc)
1525 {
1526     debug_called(3);
1527
1528     if (AMR_QGET_IDB(sc) & AMR_QIDB_SUBMIT)
1529         return(EBUSY);
1530     AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_SUBMIT);
1531     return(0);
1532 }
1533
1534 static int
1535 amr_std_submit_command(struct amr_softc *sc)
1536 {
1537     debug_called(3);
1538
1539     if (AMR_SGET_MBSTAT(sc) & AMR_SMBOX_BUSYFLAG)
1540         return(EBUSY);
1541     AMR_SPOST_COMMAND(sc);
1542     return(0);
1543 }
1544
1545 /********************************************************************************
1546  * Claim any work that the controller has completed; acknowledge completion,
1547  * save details of the completion in (mbsave)
1548  */
1549 static int
1550 amr_quartz_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave)
1551 {
1552     int         worked;
1553     u_int32_t   outd;
1554
1555     debug_called(3);
1556
1557     worked = 0;
1558     crit_enter();
1559
1560     /* work waiting for us? */
1561     if ((outd = AMR_QGET_ODB(sc)) == AMR_QODB_READY) {
1562
1563         /* save mailbox, which contains a list of completed commands */
1564         bcopy((void *)(uintptr_t)(volatile void *)sc->amr_mailbox, mbsave, sizeof(*mbsave));
1565
1566         /* acknowledge interrupt */
1567         AMR_QPUT_ODB(sc, AMR_QODB_READY);
1568
1569         /* acknowledge that we have the commands */
1570         AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_ACK);
1571
1572 #ifndef AMR_QUARTZ_GOFASTER
1573         /*
1574          * This waits for the controller to notice that we've taken the
1575          * command from it.  It's very inefficient, and we shouldn't do it,
1576          * but if we remove this code, we stop completing commands under
1577          * load.
1578          *
1579          * Peter J says we shouldn't do this.  The documentation says we
1580          * should.  Who is right?
1581          */
1582         while(AMR_QGET_IDB(sc) & AMR_QIDB_ACK)
1583             ;                           /* XXX aiee! what if it dies? */
1584 #endif
1585
1586         worked = 1;                     /* got some work */
1587     }
1588
1589     crit_exit();
1590     return(worked);
1591 }
1592
1593 static int
1594 amr_std_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave)
1595 {
1596     int         worked;
1597     u_int8_t    istat;
1598
1599     debug_called(3);
1600
1601     worked = 0;
1602     crit_enter();
1603
1604     /* check for valid interrupt status */
1605     istat = AMR_SGET_ISTAT(sc);
1606     if ((istat & AMR_SINTR_VALID) != 0) {
1607         AMR_SPUT_ISTAT(sc, istat);      /* ack interrupt status */
1608
1609         /* save mailbox, which contains a list of completed commands */
1610         bcopy((void *)(uintptr_t)(volatile void *)sc->amr_mailbox, mbsave, sizeof(*mbsave));
1611
1612         AMR_SACK_INTERRUPT(sc);         /* acknowledge we have the mailbox */
1613         worked = 1;
1614     }
1615
1616     crit_exit();
1617     return(worked);
1618 }
1619
1620 /********************************************************************************
1621  * Notify the controller of the mailbox location.
1622  */
1623 static void
1624 amr_std_attach_mailbox(struct amr_softc *sc)
1625 {
1626
1627     /* program the mailbox physical address */
1628     AMR_SBYTE_SET(sc, AMR_SMBOX_0, sc->amr_mailboxphys         & 0xff);
1629     AMR_SBYTE_SET(sc, AMR_SMBOX_1, (sc->amr_mailboxphys >>  8) & 0xff);
1630     AMR_SBYTE_SET(sc, AMR_SMBOX_2, (sc->amr_mailboxphys >> 16) & 0xff);
1631     AMR_SBYTE_SET(sc, AMR_SMBOX_3, (sc->amr_mailboxphys >> 24) & 0xff);
1632     AMR_SBYTE_SET(sc, AMR_SMBOX_ENABLE, AMR_SMBOX_ADDR);
1633
1634     /* clear any outstanding interrupt and enable interrupts proper */
1635     AMR_SACK_INTERRUPT(sc);
1636     AMR_SENABLE_INTR(sc);
1637 }
1638
1639 #ifdef AMR_BOARD_INIT
1640 /********************************************************************************
1641  * Initialise the controller
1642  */
1643 static int
1644 amr_quartz_init(struct amr_softc *sc)
1645 {
1646     int         status, ostatus;
1647
1648     device_printf(sc->amr_dev, "initial init status %x\n", AMR_QGET_INITSTATUS(sc));
1649
1650     AMR_QRESET(sc);
1651
1652     ostatus = 0xff;
1653     while ((status = AMR_QGET_INITSTATUS(sc)) != AMR_QINIT_DONE) {
1654         if (status != ostatus) {
1655             device_printf(sc->amr_dev, "(%x) %s\n", status, amr_describe_code(amr_table_qinit, status));
1656             ostatus = status;
1657         }
1658         switch (status) {
1659         case AMR_QINIT_NOMEM:
1660             return(ENOMEM);
1661
1662         case AMR_QINIT_SCAN:
1663             /* XXX we could print channel/target here */
1664             break;
1665         }
1666     }
1667     return(0);
1668 }
1669
1670 static int
1671 amr_std_init(struct amr_softc *sc)
1672 {
1673     int         status, ostatus;
1674
1675     device_printf(sc->amr_dev, "initial init status %x\n", AMR_SGET_INITSTATUS(sc));
1676
1677     AMR_SRESET(sc);
1678
1679     ostatus = 0xff;
1680     while ((status = AMR_SGET_INITSTATUS(sc)) != AMR_SINIT_DONE) {
1681         if (status != ostatus) {
1682             device_printf(sc->amr_dev, "(%x) %s\n", status, amr_describe_code(amr_table_sinit, status));
1683             ostatus = status;
1684         }
1685         switch (status) {
1686         case AMR_SINIT_NOMEM:
1687             return(ENOMEM);
1688
1689         case AMR_SINIT_INPROG:
1690             /* XXX we could print channel/target here? */
1691             break;
1692         }
1693     }
1694     return(0);
1695 }
1696 #endif
1697
1698 /********************************************************************************
1699  ********************************************************************************
1700                                                                         Debugging
1701  ********************************************************************************
1702  ********************************************************************************/
1703
1704 /********************************************************************************
1705  * Identify the controller and print some information about it.
1706  */
1707 static void
1708 amr_describe_controller(struct amr_softc *sc)
1709 {
1710     struct amr_prodinfo *ap;
1711     struct amr_enquiry  *ae;
1712     char                *prod;
1713
1714     /*
1715      * Try to get 40LD product info, which tells us what the card is labelled as.
1716      */
1717     if ((ap = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_PRODUCT_INFO, 0)) != NULL) {
1718         device_printf(sc->amr_dev, "<LSILogic %.80s> Firmware %.16s, BIOS %.16s, %dMB RAM\n",
1719                       ap->ap_product, ap->ap_firmware, ap->ap_bios,
1720                       ap->ap_memsize);
1721
1722         kfree(ap, M_DEVBUF);
1723         return;
1724     }
1725
1726     /*
1727      * Try 8LD extended ENQUIRY to get controller signature, and use lookup table.
1728      */
1729     if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_EXT_ENQUIRY2, 0, 0)) != NULL) {
1730         prod = amr_describe_code(amr_table_adaptertype, ae->ae_signature);
1731
1732     } else if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_ENQUIRY, 0, 0)) != NULL) {
1733
1734         /*
1735          * Try to work it out based on the PCI signatures.
1736          */
1737         switch (pci_get_device(sc->amr_dev)) {
1738         case 0x9010:
1739             prod = "Series 428";
1740             break;
1741         case 0x9060:
1742             prod = "Series 434";
1743             break;
1744         default:
1745             prod = "unknown controller";
1746             break;
1747         }
1748     } else {
1749         device_printf(sc->amr_dev, "<unsupported controller>\n");
1750         return;
1751     }
1752
1753     /*
1754      * HP NetRaid controllers have a special encoding of the firmware and
1755      * BIOS versions. The AMI version seems to have it as strings whereas
1756      * the HP version does it with a leading uppercase character and two
1757      * binary numbers.
1758      */
1759
1760     if(ae->ae_adapter.aa_firmware[2] >= 'A' &&
1761        ae->ae_adapter.aa_firmware[2] <= 'Z' &&
1762        ae->ae_adapter.aa_firmware[1] <  ' ' &&
1763        ae->ae_adapter.aa_firmware[0] <  ' ' &&
1764        ae->ae_adapter.aa_bios[2] >= 'A'     &&
1765        ae->ae_adapter.aa_bios[2] <= 'Z'     &&
1766        ae->ae_adapter.aa_bios[1] <  ' '     &&
1767        ae->ae_adapter.aa_bios[0] <  ' ') {
1768
1769         /* this looks like we have an HP NetRaid version of the MegaRaid */
1770
1771         if(ae->ae_signature == AMR_SIG_438) {
1772                 /* the AMI 438 is a NetRaid 3si in HP-land */
1773                 prod = "HP NetRaid 3si";
1774         }
1775
1776         device_printf(sc->amr_dev, "<%s> Firmware %c.%02d.%02d, BIOS %c.%02d.%02d, %dMB RAM\n",
1777                       prod, ae->ae_adapter.aa_firmware[2],
1778                       ae->ae_adapter.aa_firmware[1],
1779                       ae->ae_adapter.aa_firmware[0],
1780                       ae->ae_adapter.aa_bios[2],
1781                       ae->ae_adapter.aa_bios[1],
1782                       ae->ae_adapter.aa_bios[0],
1783                       ae->ae_adapter.aa_memorysize);
1784     } else {
1785         device_printf(sc->amr_dev, "<%s> Firmware %.4s, BIOS %.4s, %dMB RAM\n",
1786                       prod, ae->ae_adapter.aa_firmware, ae->ae_adapter.aa_bios,
1787                       ae->ae_adapter.aa_memorysize);
1788     }
1789     kfree(ae, M_DEVBUF);
1790 }
1791
1792 int
1793 amr_dump_blocks(struct amr_softc *sc, int unit, u_int64_t lba, void *data, int blks)
1794 {
1795
1796     struct amr_command  *ac;
1797     int                 error = 1;
1798
1799     debug_called(1);
1800
1801     sc->amr_state &= ~AMR_STATE_INTEN;
1802
1803     /* get ourselves a command buffer */
1804     if ((ac = amr_alloccmd(sc)) == NULL)
1805         goto out;
1806     /* set command flags */
1807     ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
1808
1809     /* point the command at our data */
1810     ac->ac_data = data;
1811     ac->ac_length = blks * AMR_BLKSIZE;
1812
1813     /* build the command proper */
1814     ac->ac_mailbox.mb_command   = AMR_CMD_LWRITE;
1815     ac->ac_mailbox.mb_blkcount  = blks;
1816     ac->ac_mailbox.mb_lba       = lba;
1817     ac->ac_mailbox.mb_drive     = unit;
1818
1819     /* can't assume that interrupts are going to work here, so play it safe */
1820     if (sc->amr_poll_command(ac))
1821         goto out;
1822     error = ac->ac_status;
1823
1824  out:
1825     if (ac != NULL)
1826         amr_releasecmd(ac);
1827
1828     sc->amr_state |= AMR_STATE_INTEN;
1829
1830     return (error);
1831 }
1832
1833
1834 #ifdef AMR_DEBUG
1835 /********************************************************************************
1836  * Print the command (ac) in human-readable format
1837  */
1838 #if 0
1839 static void
1840 amr_printcommand(struct amr_command *ac)
1841 {
1842     struct amr_softc    *sc = ac->ac_sc;
1843     struct amr_sgentry  *sg;
1844     int                 i;
1845
1846     device_printf(sc->amr_dev, "cmd %x  ident %d  drive %d\n",
1847                   ac->ac_mailbox.mb_command, ac->ac_mailbox.mb_ident, ac->ac_mailbox.mb_drive);
1848     device_printf(sc->amr_dev, "blkcount %d  lba %d\n",
1849                   ac->ac_mailbox.mb_blkcount, ac->ac_mailbox.mb_lba);
1850     device_printf(sc->amr_dev, "virtaddr %p  length %lu\n", ac->ac_data, (unsigned long)ac->ac_length);
1851     device_printf(sc->amr_dev, "sg physaddr %08x  nsg %d\n",
1852                   ac->ac_mailbox.mb_physaddr, ac->ac_mailbox.mb_nsgelem);
1853     device_printf(sc->amr_dev, "ccb %p  bio %p\n", ac->ac_ccb_data, ac->ac_bio);
1854
1855     /* get base address of s/g table */
1856     sg = sc->amr_sgtable + (ac->ac_slot * AMR_NSEG);
1857     for (i = 0; i < ac->ac_mailbox.mb_nsgelem; i++, sg++)
1858         device_printf(sc->amr_dev, "  %x/%d\n", sg->sg_addr, sg->sg_count);
1859 }
1860 #endif
1861 #endif