sys/dev/aacraid/aacraid_cam.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2002-2010 Adaptec, Inc.
   5  * Copyright (c) 2010-2012 PMC-Sierra, Inc.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 /*
  34  * CAM front-end for communicating with non-DASD devices
  35  */
  36
  37 #include "opt_aacraid.h"
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/kernel.h>
  42 #include <sys/sysctl.h>
  43 #include <sys/lock.h>
  44 #include <sys/malloc.h>
  45 #include <sys/module.h>
  46 #include <sys/mutex.h>
  47
  48 #include <cam/cam.h>
  49 #include <cam/cam_ccb.h>
  50 #include <cam/cam_debug.h>
  51 #include <cam/cam_periph.h>
  52 #include <cam/cam_sim.h>
  53 #include <cam/cam_xpt_sim.h>
  54 #include <cam/scsi/scsi_all.h>
  55 #include <cam/scsi/scsi_message.h>
  56
  57 #include <sys/bus.h>
  58 #include <sys/conf.h>
  59 #include <sys/disk.h>
  60
  61 #include <machine/md_var.h>
  62 #include <machine/bus.h>
  63 #include <sys/rman.h>
  64
  65 #include <vm/vm.h>
  66 #include <vm/pmap.h>
  67
  68 #include <dev/aacraid/aacraid_reg.h>
  69 #include <sys/aac_ioctl.h>
  70 #include <dev/aacraid/aacraid_debug.h>
  71 #include <dev/aacraid/aacraid_var.h>
  72
  73 #ifndef CAM_NEW_TRAN_CODE
  74 #define CAM_NEW_TRAN_CODE       1
  75 #endif
  76
  77 #ifndef SVPD_SUPPORTED_PAGE_LIST
  78 struct scsi_vpd_supported_page_list
  79 {
  80         u_int8_t device;
  81         u_int8_t page_code;
  82 #define SVPD_SUPPORTED_PAGE_LIST 0x00
  83         u_int8_t reserved;
  84         u_int8_t length;        /* number of VPD entries */
  85 #define SVPD_SUPPORTED_PAGES_SIZE       251
  86         u_int8_t list[SVPD_SUPPORTED_PAGES_SIZE];
  87 };
  88 #endif
  89
  90 /************************** Version Compatibility *************************/
  91 #define aac_sim_alloc                           cam_sim_alloc
  92
  93 struct aac_cam {
  94         device_t                dev;
  95         struct aac_sim          *inf;
  96         struct cam_sim          *sim;
  97         struct cam_path         *path;
  98 };
  99
 100 static int aac_cam_probe(device_t dev);
 101 static int aac_cam_attach(device_t dev);
 102 static int aac_cam_detach(device_t dev);
 103 static void aac_cam_action(struct cam_sim *, union ccb *);
 104 static void aac_cam_poll(struct cam_sim *);
 105 static void aac_cam_complete(struct aac_command *);
 106 static void aac_container_complete(struct aac_command *);
 107 static void aac_cam_rescan(struct aac_softc *sc, uint32_t channel,
 108         uint32_t target_id);
 109 static void aac_set_scsi_error(struct aac_softc *sc, union ccb *ccb,
 110         u_int8_t status, u_int8_t key, u_int8_t asc, u_int8_t ascq);
 111 static int aac_load_map_command_sg(struct aac_softc *, struct aac_command *);
 112 static u_int64_t aac_eval_blockno(u_int8_t *);
 113 static void aac_container_rw_command(struct cam_sim *, union ccb *, u_int8_t *);
 114 static void aac_container_special_command(struct cam_sim *, union ccb *,
 115         u_int8_t *);
 116 static void aac_passthrough_command(struct cam_sim *, union ccb *);
 117
 118 static u_int32_t aac_cam_reset_bus(struct cam_sim *, union ccb *);
 119 static u_int32_t aac_cam_abort_ccb(struct cam_sim *, union ccb *);
 120 static u_int32_t aac_cam_term_io(struct cam_sim *, union ccb *);
 121
 122 static devclass_t       aacraid_pass_devclass;
 123
 124 static device_method_t  aacraid_pass_methods[] = {
 125         DEVMETHOD(device_probe,         aac_cam_probe),
 126         DEVMETHOD(device_attach,        aac_cam_attach),
 127         DEVMETHOD(device_detach,        aac_cam_detach),
 128         { 0, 0 }
 129 };
 130
 131 static driver_t aacraid_pass_driver = {
 132         "aacraidp",
 133         aacraid_pass_methods,
 134         sizeof(struct aac_cam)
 135 };
 136
 137 DRIVER_MODULE(aacraidp, aacraid, aacraid_pass_driver, aacraid_pass_devclass, 0, 0);
 138 MODULE_DEPEND(aacraidp, cam, 1, 1, 1);
 139
 140 MALLOC_DEFINE(M_AACRAIDCAM, "aacraidcam", "AACRAID CAM info");
 141
 142 static void
 143 aac_set_scsi_error(struct aac_softc *sc, union ccb *ccb, u_int8_t status,
 144         u_int8_t key, u_int8_t asc, u_int8_t ascq)
 145 {
 146         struct scsi_sense_data_fixed *sense =
 147                 (struct scsi_sense_data_fixed *)&ccb->csio.sense_data;
 148
 149         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "Error %d!", status);
 150
 151         ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR;
 152         ccb->csio.scsi_status = status;
 153         if (status == SCSI_STATUS_CHECK_COND) {
 154                 ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
 155                 bzero(&ccb->csio.sense_data, ccb->csio.sense_len);
 156                 ccb->csio.sense_data.error_code =
 157                         SSD_CURRENT_ERROR | SSD_ERRCODE_VALID;
 158                 sense->flags = key;
 159                 if (ccb->csio.sense_len >= 14) {
 160                         sense->extra_len = 6;
 161                         sense->add_sense_code = asc;
 162                         sense->add_sense_code_qual = ascq;
 163                 }
 164         }
 165 }
 166
 167 static void
 168 aac_cam_rescan(struct aac_softc *sc, uint32_t channel, uint32_t target_id)
 169 {
 170         union ccb *ccb;
 171         struct aac_sim *sim;
 172         struct aac_cam *camsc;
 173
 174         if (target_id == AAC_CAM_TARGET_WILDCARD)
 175                 target_id = CAM_TARGET_WILDCARD;
 176
 177         TAILQ_FOREACH(sim, &sc->aac_sim_tqh, sim_link) {
 178                 camsc = sim->aac_cam;
 179                 if (camsc == NULL || camsc->inf == NULL ||
 180                     camsc->inf->BusNumber != channel)
 181                         continue;
 182
 183                 ccb = xpt_alloc_ccb_nowait();
 184                 if (ccb == NULL) {
 185                         device_printf(sc->aac_dev,
 186                             "Cannot allocate ccb for bus rescan.\n");
 187                         return;
 188                 }
 189
 190                 if (xpt_create_path(&ccb->ccb_h.path, xpt_periph,
 191                     cam_sim_path(camsc->sim),
 192                     target_id, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
 193                         xpt_free_ccb(ccb);
 194                         device_printf(sc->aac_dev,
 195                             "Cannot create path for bus rescan.\n");
 196                         return;
 197                 }
 198                 xpt_rescan(ccb);
 199                 break;
 200         }
 201 }
 202
 203 static void
 204 aac_cam_event(struct aac_softc *sc, struct aac_event *event, void *arg)
 205 {
 206         union ccb *ccb;
 207         struct aac_cam *camsc;
 208
 209         switch (event->ev_type) {
 210         case AAC_EVENT_CMFREE:
 211                 ccb = arg;
 212                 camsc = ccb->ccb_h.sim_priv.entries[0].ptr;
 213                 free(event, M_AACRAIDCAM);
 214                 xpt_release_simq(camsc->sim, 1);
 215                 ccb->ccb_h.status = CAM_REQUEUE_REQ;
 216                 xpt_done(ccb);
 217                 break;
 218         default:
 219                 device_printf(sc->aac_dev, "unknown event %d in aac_cam\n",
 220                     event->ev_type);
 221                 break;
 222         }
 223
 224         return;
 225 }
 226
 227 static int
 228 aac_cam_probe(device_t dev)
 229 {
 230         struct aac_cam *camsc;
 231
 232         camsc = (struct aac_cam *)device_get_softc(dev);
 233         if (!camsc->inf)
 234                 return (0);
 235         fwprintf(camsc->inf->aac_sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 236         return (0);
 237 }
 238
 239 static int
 240 aac_cam_detach(device_t dev)
 241 {
 242         struct aac_softc *sc;
 243         struct aac_cam *camsc;
 244
 245         camsc = (struct aac_cam *)device_get_softc(dev);
 246         if (!camsc->inf)
 247                 return (0);
 248         sc = camsc->inf->aac_sc;
 249         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 250         camsc->inf->aac_cam = NULL;
 251
 252         mtx_lock(&sc->aac_io_lock);
 253
 254         xpt_async(AC_LOST_DEVICE, camsc->path, NULL);
 255         xpt_free_path(camsc->path);
 256         xpt_bus_deregister(cam_sim_path(camsc->sim));
 257         cam_sim_free(camsc->sim, /*free_devq*/TRUE);
 258
 259         sc->cam_rescan_cb = NULL;
 260
 261         mtx_unlock(&sc->aac_io_lock);
 262
 263         return (0);
 264 }
 265
 266 /*
 267  * Register the driver as a CAM SIM
 268  */
 269 static int
 270 aac_cam_attach(device_t dev)
 271 {
 272         struct cam_devq *devq;
 273         struct cam_sim *sim;
 274         struct cam_path *path;
 275         struct aac_cam *camsc;
 276         struct aac_sim *inf;
 277
 278         camsc = (struct aac_cam *)device_get_softc(dev);
 279         inf = (struct aac_sim *)device_get_ivars(dev);
 280         if (!inf)
 281                 return (EIO);
 282         fwprintf(inf->aac_sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 283         camsc->inf = inf;
 284         camsc->inf->aac_cam = camsc;
 285
 286         devq = cam_simq_alloc(inf->TargetsPerBus);
 287         if (devq == NULL)
 288                 return (EIO);
 289
 290         sim = aac_sim_alloc(aac_cam_action, aac_cam_poll, "aacraidp", camsc,
 291             device_get_unit(dev), &inf->aac_sc->aac_io_lock, 1, 1, devq);
 292         if (sim == NULL) {
 293                 cam_simq_free(devq);
 294                 return (EIO);
 295         }
 296
 297         /* Since every bus has it's own sim, every bus 'appears' as bus 0 */
 298         mtx_lock(&inf->aac_sc->aac_io_lock);
 299         if (aac_xpt_bus_register(sim, dev, 0) != CAM_SUCCESS) {
 300                 cam_sim_free(sim, TRUE);
 301                 mtx_unlock(&inf->aac_sc->aac_io_lock);
 302                 return (EIO);
 303         }
 304
 305         if (xpt_create_path(&path, NULL, cam_sim_path(sim),
 306             CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
 307                 xpt_bus_deregister(cam_sim_path(sim));
 308                 cam_sim_free(sim, TRUE);
 309                 mtx_unlock(&inf->aac_sc->aac_io_lock);
 310                 return (EIO);
 311         }
 312
 313         inf->aac_sc->cam_rescan_cb = aac_cam_rescan;
 314         mtx_unlock(&inf->aac_sc->aac_io_lock);
 315
 316         camsc->sim = sim;
 317         camsc->path = path;
 318
 319         return (0);
 320 }
 321
 322 static u_int64_t
 323 aac_eval_blockno(u_int8_t *cmdp)
 324 {
 325         u_int64_t blockno;
 326
 327         switch (cmdp[0]) {
 328         case READ_6:
 329         case WRITE_6:
 330                 blockno = scsi_3btoul(((struct scsi_rw_6 *)cmdp)->addr);
 331                 break;
 332         case READ_10:
 333         case WRITE_10:
 334                 blockno = scsi_4btoul(((struct scsi_rw_10 *)cmdp)->addr);
 335                 break;
 336         case READ_12:
 337         case WRITE_12:
 338                 blockno = scsi_4btoul(((struct scsi_rw_12 *)cmdp)->addr);
 339                 break;
 340         case READ_16:
 341         case WRITE_16:
 342                 blockno = scsi_8btou64(((struct scsi_rw_16 *)cmdp)->addr);
 343                 break;
 344         default:
 345                 blockno = 0;
 346                 break;
 347         }
 348         return(blockno);
 349 }
 350
 351 static void
 352 aac_container_rw_command(struct cam_sim *sim, union ccb *ccb, u_int8_t *cmdp)
 353 {
 354         struct  aac_cam *camsc;
 355         struct  aac_softc *sc;
 356         struct  aac_command *cm;
 357         struct  aac_fib *fib;
 358         u_int64_t blockno;
 359
 360         camsc = (struct aac_cam *)cam_sim_softc(sim);
 361         sc = camsc->inf->aac_sc;
 362         mtx_assert(&sc->aac_io_lock, MA_OWNED);
 363
 364         if (aacraid_alloc_command(sc, &cm)) {
 365                 struct aac_event *event;
 366
 367                 xpt_freeze_simq(sim, 1);
 368                 ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
 369                 ccb->ccb_h.sim_priv.entries[0].ptr = camsc;
 370                 event = malloc(sizeof(struct aac_event), M_AACRAIDCAM,
 371                     M_NOWAIT | M_ZERO);
 372                 if (event == NULL) {
 373                         device_printf(sc->aac_dev,
 374                             "Warning, out of memory for event\n");
 375                         return;
 376                 }
 377                 event->ev_callback = aac_cam_event;
 378                 event->ev_arg = ccb;
 379                 event->ev_type = AAC_EVENT_CMFREE;
 380                 aacraid_add_event(sc, event);
 381                 return;
 382         }
 383
 384         fib = cm->cm_fib;
 385         switch (ccb->ccb_h.flags & CAM_DIR_MASK) {
 386         case CAM_DIR_IN:
 387                 cm->cm_flags |= AAC_CMD_DATAIN;
 388                 break;
 389         case CAM_DIR_OUT:
 390                 cm->cm_flags |= AAC_CMD_DATAOUT;
 391                 break;
 392         case CAM_DIR_NONE:
 393                 break;
 394         default:
 395                 cm->cm_flags |= AAC_CMD_DATAIN | AAC_CMD_DATAOUT;
 396                 break;
 397         }
 398
 399         blockno = aac_eval_blockno(cmdp);
 400
 401         cm->cm_complete = aac_container_complete;
 402         cm->cm_ccb = ccb;
 403         cm->cm_timestamp = time_uptime;
 404         cm->cm_data = (void *)ccb->csio.data_ptr;
 405         cm->cm_datalen = ccb->csio.dxfer_len;
 406
 407         fib->Header.Size = sizeof(struct aac_fib_header);
 408         fib->Header.XferState =
 409                 AAC_FIBSTATE_HOSTOWNED   |
 410                 AAC_FIBSTATE_INITIALISED |
 411                 AAC_FIBSTATE_EMPTY       |
 412                 AAC_FIBSTATE_FROMHOST    |
 413                 AAC_FIBSTATE_REXPECTED   |
 414                 AAC_FIBSTATE_NORM        |
 415                 AAC_FIBSTATE_ASYNC       |
 416                 AAC_FIBSTATE_FAST_RESPONSE;
 417
 418         if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE2) {
 419                 struct aac_raw_io2 *raw;
 420                 raw = (struct aac_raw_io2 *)&fib->data[0];
 421                 bzero(raw, sizeof(struct aac_raw_io2));
 422                 fib->Header.Command = RawIo2;
 423                 raw->strtBlkLow = (u_int32_t)blockno;
 424                 raw->strtBlkHigh = (u_int32_t)(blockno >> 32);
 425                 raw->byteCnt = cm->cm_datalen;
 426                 raw->ldNum = ccb->ccb_h.target_id;
 427                 fib->Header.Size += sizeof(struct aac_raw_io2);
 428                 cm->cm_sgtable = (struct aac_sg_table *)raw->sge;
 429                 if (cm->cm_flags & AAC_CMD_DATAIN)
 430                         raw->flags = RIO2_IO_TYPE_READ | RIO2_SG_FORMAT_IEEE1212;
 431                 else
 432                         raw->flags = RIO2_IO_TYPE_WRITE | RIO2_SG_FORMAT_IEEE1212;
 433         } else if (sc->flags & AAC_FLAGS_RAW_IO) {
 434                 struct aac_raw_io *raw;
 435                 raw = (struct aac_raw_io *)&fib->data[0];
 436                 bzero(raw, sizeof(struct aac_raw_io));
 437                 fib->Header.Command = RawIo;
 438                 raw->BlockNumber = blockno;
 439                 raw->ByteCount = cm->cm_datalen;
 440                 raw->ContainerId = ccb->ccb_h.target_id;
 441                 fib->Header.Size += sizeof(struct aac_raw_io);
 442                 cm->cm_sgtable = (struct aac_sg_table *)
 443                         &raw->SgMapRaw;
 444                 if (cm->cm_flags & AAC_CMD_DATAIN)
 445                         raw->Flags = 1;
 446         } else if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
 447                 fib->Header.Command = ContainerCommand;
 448                 if (cm->cm_flags & AAC_CMD_DATAIN) {
 449                         struct aac_blockread *br;
 450                         br = (struct aac_blockread *)&fib->data[0];
 451                         br->Command = VM_CtBlockRead;
 452                         br->ContainerId = ccb->ccb_h.target_id;
 453                         br->BlockNumber = blockno;
 454                         br->ByteCount = cm->cm_datalen;
 455                         fib->Header.Size += sizeof(struct aac_blockread);
 456                         cm->cm_sgtable = &br->SgMap;
 457                 } else {
 458                         struct aac_blockwrite *bw;
 459                         bw = (struct aac_blockwrite *)&fib->data[0];
 460                         bw->Command = VM_CtBlockWrite;
 461                         bw->ContainerId = ccb->ccb_h.target_id;
 462                         bw->BlockNumber = blockno;
 463                         bw->ByteCount = cm->cm_datalen;
 464                         bw->Stable = CUNSTABLE;
 465                         fib->Header.Size += sizeof(struct aac_blockwrite);
 466                         cm->cm_sgtable = &bw->SgMap;
 467                 }
 468         } else {
 469                 fib->Header.Command = ContainerCommand64;
 470                 if (cm->cm_flags & AAC_CMD_DATAIN) {
 471                         struct aac_blockread64 *br;
 472                         br = (struct aac_blockread64 *)&fib->data[0];
 473                         br->Command = VM_CtHostRead64;
 474                         br->ContainerId = ccb->ccb_h.target_id;
 475                         br->SectorCount = cm->cm_datalen/AAC_BLOCK_SIZE;
 476                         br->BlockNumber = blockno;
 477                         br->Pad = 0;
 478                         br->Flags = 0;
 479                         fib->Header.Size += sizeof(struct aac_blockread64);
 480                         cm->cm_sgtable = (struct aac_sg_table *)&br->SgMap64;
 481                 } else {
 482                         struct aac_blockwrite64 *bw;
 483                         bw = (struct aac_blockwrite64 *)&fib->data[0];
 484                         bw->Command = VM_CtHostWrite64;
 485                         bw->ContainerId = ccb->ccb_h.target_id;
 486                         bw->SectorCount = cm->cm_datalen/AAC_BLOCK_SIZE;
 487                         bw->BlockNumber = blockno;
 488                         bw->Pad = 0;
 489                         bw->Flags = 0;
 490                         fib->Header.Size += sizeof(struct aac_blockwrite64);
 491                         cm->cm_sgtable = (struct aac_sg_table *)&bw->SgMap64;
 492                 }
 493         }
 494         aac_enqueue_ready(cm);
 495         aacraid_startio(cm->cm_sc);
 496 }
 497
 498 static void
 499 aac_container_special_command(struct cam_sim *sim, union ccb *ccb,
 500         u_int8_t *cmdp)
 501 {
 502         struct  aac_cam *camsc;
 503         struct  aac_softc *sc;
 504         struct  aac_container *co;
 505
 506         camsc = (struct aac_cam *)cam_sim_softc(sim);
 507         sc = camsc->inf->aac_sc;
 508         mtx_assert(&sc->aac_io_lock, MA_OWNED);
 509
 510         TAILQ_FOREACH(co, &sc->aac_container_tqh, co_link) {
 511                 fwprintf(sc, HBA_FLAGS_DBG_ERROR_B, "found container %d search for %d", co->co_mntobj.ObjectId, ccb->ccb_h.target_id);
 512                 if (co->co_mntobj.ObjectId == ccb->ccb_h.target_id)
 513                         break;
 514         }
 515         if (co == NULL || ccb->ccb_h.target_lun != 0) {
 516                 fwprintf(sc, HBA_FLAGS_DBG_ERROR_B,
 517                         "Container not present: cmd 0x%x id %d lun %d len %d",
 518                         *cmdp, ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 519                         ccb->csio.dxfer_len);
 520                 ccb->ccb_h.status = CAM_DEV_NOT_THERE;
 521                 xpt_done(ccb);
 522                 return;
 523         }
 524
 525         if (ccb->csio.dxfer_len)
 526                 bzero(ccb->csio.data_ptr, ccb->csio.dxfer_len);
 527
 528         switch (*cmdp) {
 529         case INQUIRY:
 530         {
 531                 struct scsi_inquiry *inq = (struct scsi_inquiry *)cmdp;
 532
 533                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B,
 534                 "Container INQUIRY id %d lun %d len %d VPD 0x%x Page 0x%x",
 535                         ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 536                         ccb->csio.dxfer_len, inq->byte2, inq->page_code);
 537                 if (!(inq->byte2 & SI_EVPD)) {
 538                         struct scsi_inquiry_data *p =
 539                                 (struct scsi_inquiry_data *)ccb->csio.data_ptr;
 540                         if (inq->page_code != 0) {
 541                                 aac_set_scsi_error(sc, ccb,
 542                                         SCSI_STATUS_CHECK_COND,
 543                                         SSD_KEY_ILLEGAL_REQUEST, 0x24, 0x00);
 544                                 xpt_done(ccb);
 545                                 return;
 546                         }
 547                         p->device = T_DIRECT;
 548                         p->version = SCSI_REV_SPC2;
 549                         p->response_format = 2;
 550                         if (ccb->csio.dxfer_len >= 36) {
 551                                 p->additional_length = 31;
 552                                 p->flags = SID_WBus16|SID_Sync|SID_CmdQue;
 553                                 /* OEM Vendor defines */
 554                                 strncpy(p->vendor, "Adaptec ", sizeof(p->vendor));
 555                                 strncpy(p->product, "Array           ",
 556                                     sizeof(p->product));
 557                                 strncpy(p->revision, "V1.0",
 558                                     sizeof(p->revision));
 559                         }
 560                 } else {
 561                         if (inq->page_code == SVPD_SUPPORTED_PAGE_LIST) {
 562                                 struct scsi_vpd_supported_page_list *p =
 563                                         (struct scsi_vpd_supported_page_list *)
 564                                         ccb->csio.data_ptr;
 565                                 p->device = T_DIRECT;
 566                                 p->page_code = SVPD_SUPPORTED_PAGE_LIST;
 567                                 p->length = 2;
 568                                 p->list[0] = SVPD_SUPPORTED_PAGE_LIST;
 569                                 p->list[1] = SVPD_UNIT_SERIAL_NUMBER;
 570                         } else if (inq->page_code == SVPD_UNIT_SERIAL_NUMBER) {
 571                                 struct scsi_vpd_unit_serial_number *p =
 572                                         (struct scsi_vpd_unit_serial_number *)
 573                                         ccb->csio.data_ptr;
 574                                 p->device = T_DIRECT;
 575                                 p->page_code = SVPD_UNIT_SERIAL_NUMBER;
 576                                 p->length = sprintf((char *)p->serial_num,
 577                                         "%08X%02X", co->co_uid,
 578                                         ccb->ccb_h.target_id);
 579                         } else {
 580                                 aac_set_scsi_error(sc, ccb,
 581                                         SCSI_STATUS_CHECK_COND,
 582                                         SSD_KEY_ILLEGAL_REQUEST, 0x24, 0x00);
 583                                 xpt_done(ccb);
 584                                 return;
 585                         }
 586                 }
 587                 ccb->ccb_h.status = CAM_REQ_CMP;
 588                 break;
 589         }
 590
 591         case REPORT_LUNS:
 592                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B,
 593                 "Container REPORT_LUNS id %d lun %d len %d",
 594                 ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 595                 ccb->csio.dxfer_len);
 596                 ccb->ccb_h.status = CAM_REQ_CMP;
 597                 break;
 598
 599         case START_STOP:
 600         {
 601                 struct scsi_start_stop_unit *ss =
 602                         (struct scsi_start_stop_unit *)cmdp;
 603                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B,
 604                 "Container START_STOP id %d lun %d len %d",
 605                 ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 606                 ccb->csio.dxfer_len);
 607                 if (sc->aac_support_opt2 & AAC_SUPPORTED_POWER_MANAGEMENT) {
 608                         struct aac_command *cm;
 609                         struct aac_fib *fib;
 610                         struct aac_cnt_config *ccfg;
 611
 612                         if (aacraid_alloc_command(sc, &cm)) {
 613                                 struct aac_event *event;
 614
 615                                 xpt_freeze_simq(sim, 1);
 616                                 ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
 617                                 ccb->ccb_h.sim_priv.entries[0].ptr = camsc;
 618                                 event = malloc(sizeof(struct aac_event), M_AACRAIDCAM,
 619                                         M_NOWAIT | M_ZERO);
 620                                 if (event == NULL) {
 621                                         device_printf(sc->aac_dev,
 622                                                 "Warning, out of memory for event\n");
 623                                         return;
 624                                 }
 625                                 event->ev_callback = aac_cam_event;
 626                                 event->ev_arg = ccb;
 627                                 event->ev_type = AAC_EVENT_CMFREE;
 628                                 aacraid_add_event(sc, event);
 629                                 return;
 630                         }
 631
 632                         fib = cm->cm_fib;
 633                         cm->cm_timestamp = time_uptime;
 634                         cm->cm_datalen = 0;
 635
 636                         fib->Header.Size =
 637                                 sizeof(struct aac_fib_header) + sizeof(struct aac_cnt_config);
 638                         fib->Header.XferState =
 639                                 AAC_FIBSTATE_HOSTOWNED   |
 640                                 AAC_FIBSTATE_INITIALISED |
 641                                 AAC_FIBSTATE_EMPTY       |
 642                                 AAC_FIBSTATE_FROMHOST    |
 643                                 AAC_FIBSTATE_REXPECTED   |
 644                                 AAC_FIBSTATE_NORM        |
 645                                 AAC_FIBSTATE_ASYNC       |
 646                                 AAC_FIBSTATE_FAST_RESPONSE;
 647                         fib->Header.Command = ContainerCommand;
 648
 649                         /* Start unit */
 650                         ccfg = (struct aac_cnt_config *)&fib->data[0];
 651                         bzero(ccfg, sizeof (*ccfg) - CT_PACKET_SIZE);
 652                         ccfg->Command = VM_ContainerConfig;
 653                         ccfg->CTCommand.command = CT_PM_DRIVER_SUPPORT;
 654                         ccfg->CTCommand.param[0] = (ss->how & SSS_START ?
 655                                 AAC_PM_DRIVERSUP_START_UNIT :
 656                                 AAC_PM_DRIVERSUP_STOP_UNIT);
 657                         ccfg->CTCommand.param[1] = co->co_mntobj.ObjectId;
 658                         ccfg->CTCommand.param[2] = 0;   /* 1 - immediate */
 659
 660                         if (aacraid_wait_command(cm) != 0 ||
 661                                 *(u_int32_t *)&fib->data[0] != 0) {
 662                                 printf("Power Management: Error start/stop container %d\n",
 663                                 co->co_mntobj.ObjectId);
 664                         }
 665                         aacraid_release_command(cm);
 666                 }
 667                 ccb->ccb_h.status = CAM_REQ_CMP;
 668                 break;
 669         }
 670
 671         case TEST_UNIT_READY:
 672                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B,
 673                 "Container TEST_UNIT_READY id %d lun %d len %d",
 674                 ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 675                 ccb->csio.dxfer_len);
 676                 ccb->ccb_h.status = CAM_REQ_CMP;
 677                 break;
 678
 679         case REQUEST_SENSE:
 680                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B,
 681                 "Container REQUEST_SENSE id %d lun %d len %d",
 682                 ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 683                 ccb->csio.dxfer_len);
 684                 ccb->ccb_h.status = CAM_REQ_CMP;
 685                 break;
 686
 687         case READ_CAPACITY:
 688         {
 689                 struct scsi_read_capacity_data *p =
 690                         (struct scsi_read_capacity_data *)ccb->csio.data_ptr;
 691                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B,
 692                 "Container READ_CAPACITY id %d lun %d len %d",
 693                 ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 694                 ccb->csio.dxfer_len);
 695                 scsi_ulto4b(co->co_mntobj.ObjExtension.BlockDevice.BlockSize, p->length);
 696                 /* check if greater than 2TB */
 697                 if (co->co_mntobj.CapacityHigh) {
 698                         if (sc->flags & AAC_FLAGS_LBA_64BIT)
 699                                 scsi_ulto4b(0xffffffff, p->addr);
 700                 } else {
 701                         scsi_ulto4b(co->co_mntobj.Capacity-1, p->addr);
 702                 }
 703                 ccb->ccb_h.status = CAM_REQ_CMP;
 704                 break;
 705         }
 706
 707         case SERVICE_ACTION_IN:
 708         {
 709                 struct scsi_read_capacity_data_long *p =
 710                         (struct scsi_read_capacity_data_long *)
 711                         ccb->csio.data_ptr;
 712                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B,
 713                 "Container SERVICE_ACTION_IN id %d lun %d len %d",
 714                 ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 715                 ccb->csio.dxfer_len);
 716                 if (((struct scsi_read_capacity_16 *)cmdp)->service_action !=
 717                         SRC16_SERVICE_ACTION) {
 718                         aac_set_scsi_error(sc, ccb, SCSI_STATUS_CHECK_COND,
 719                                 SSD_KEY_ILLEGAL_REQUEST, 0x24, 0x00);
 720                         xpt_done(ccb);
 721                         return;
 722                 }
 723                 scsi_ulto4b(co->co_mntobj.ObjExtension.BlockDevice.BlockSize, p->length);
 724                 scsi_ulto4b(co->co_mntobj.CapacityHigh, p->addr);
 725                 scsi_ulto4b(co->co_mntobj.Capacity-1, &p->addr[4]);
 726
 727                 if (ccb->csio.dxfer_len >= 14) {
 728                         u_int32_t mapping = co->co_mntobj.ObjExtension.BlockDevice.bdLgclPhysMap;
 729                         p->prot_lbppbe = 0;
 730                         while (mapping > 1) {
 731                                 mapping >>= 1;
 732                                 p->prot_lbppbe++;
 733                         }
 734                         p->prot_lbppbe &= 0x0f;
 735                 }
 736
 737                 ccb->ccb_h.status = CAM_REQ_CMP;
 738                 break;
 739         }
 740
 741         case MODE_SENSE_6:
 742         {
 743                 struct scsi_mode_sense_6 *msp =(struct scsi_mode_sense_6 *)cmdp;
 744                 struct ms6_data {
 745                         struct scsi_mode_hdr_6 hd;
 746                         struct scsi_mode_block_descr bd;
 747                         char pages;
 748                 } *p = (struct ms6_data *)ccb->csio.data_ptr;
 749                 char *pagep;
 750                 int return_all_pages = FALSE;
 751
 752                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B,
 753                 "Container MODE_SENSE id %d lun %d len %d page %d",
 754                 ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 755                 ccb->csio.dxfer_len, msp->page);
 756                 p->hd.datalen = sizeof(struct scsi_mode_hdr_6) - 1;
 757                 if (co->co_mntobj.ContentState & AAC_FSCS_READONLY)
 758                         p->hd.dev_specific = 0x80;      /* WP */
 759                 p->hd.dev_specific |= 0x10;     /* DPOFUA */
 760                 if (msp->byte2 & SMS_DBD) {
 761                         p->hd.block_descr_len = 0;
 762                 } else {
 763                         p->hd.block_descr_len =
 764                                 sizeof(struct scsi_mode_block_descr);
 765                         p->hd.datalen += p->hd.block_descr_len;
 766                         scsi_ulto3b(co->co_mntobj.ObjExtension.BlockDevice.BlockSize, p->bd.block_len);
 767                         if (co->co_mntobj.Capacity > 0xffffff ||
 768                                 co->co_mntobj.CapacityHigh) {
 769                                 p->bd.num_blocks[0] = 0xff;
 770                                 p->bd.num_blocks[1] = 0xff;
 771                                 p->bd.num_blocks[2] = 0xff;
 772                         } else {
 773                                 p->bd.num_blocks[0] = (u_int8_t)
 774                                         (co->co_mntobj.Capacity >> 16);
 775                                 p->bd.num_blocks[1] = (u_int8_t)
 776                                         (co->co_mntobj.Capacity >> 8);
 777                                 p->bd.num_blocks[2] = (u_int8_t)
 778                                         (co->co_mntobj.Capacity);
 779                         }
 780                 }
 781                 pagep = &p->pages;
 782                 switch (msp->page & SMS_PAGE_CODE) {
 783                 case SMS_ALL_PAGES_PAGE:
 784                         return_all_pages = TRUE;
 785                 case SMS_CONTROL_MODE_PAGE:
 786                 {
 787                         struct scsi_control_page *cp =
 788                                 (struct scsi_control_page *)pagep;
 789
 790                         if (ccb->csio.dxfer_len <= p->hd.datalen + 8) {
 791                                 aac_set_scsi_error(sc, ccb,
 792                                         SCSI_STATUS_CHECK_COND,
 793                                         SSD_KEY_ILLEGAL_REQUEST, 0x24, 0x00);
 794                                 xpt_done(ccb);
 795                                 return;
 796                         }
 797                         cp->page_code = SMS_CONTROL_MODE_PAGE;
 798                         cp->page_length = 6;
 799                         p->hd.datalen += 8;
 800                         pagep += 8;
 801                         if (!return_all_pages)
 802                                 break;
 803                 }
 804                 case SMS_VENDOR_SPECIFIC_PAGE:
 805                         break;
 806                 default:
 807                         aac_set_scsi_error(sc, ccb, SCSI_STATUS_CHECK_COND,
 808                                 SSD_KEY_ILLEGAL_REQUEST, 0x24, 0x00);
 809                         xpt_done(ccb);
 810                         return;
 811                 }
 812                 ccb->ccb_h.status = CAM_REQ_CMP;
 813                 break;
 814         }
 815
 816         case SYNCHRONIZE_CACHE:
 817                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B,
 818                 "Container SYNCHRONIZE_CACHE id %d lun %d len %d",
 819                 ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 820                 ccb->csio.dxfer_len);
 821                 ccb->ccb_h.status = CAM_REQ_CMP;
 822                 break;
 823
 824         default:
 825                 fwprintf(sc, HBA_FLAGS_DBG_ERROR_B,
 826                 "Container unsupp. cmd 0x%x id %d lun %d len %d",
 827                 *cmdp, ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 828                 ccb->csio.dxfer_len);
 829                 ccb->ccb_h.status = CAM_REQ_CMP; /*CAM_REQ_INVALID*/
 830                 break;
 831         }
 832         xpt_done(ccb);
 833 }
 834
 835 static void
 836 aac_passthrough_command(struct cam_sim *sim, union ccb *ccb)
 837 {
 838         struct  aac_cam *camsc;
 839         struct  aac_softc *sc;
 840         struct  aac_command *cm;
 841         struct  aac_fib *fib;
 842         struct  aac_srb *srb;
 843
 844         camsc = (struct aac_cam *)cam_sim_softc(sim);
 845         sc = camsc->inf->aac_sc;
 846         mtx_assert(&sc->aac_io_lock, MA_OWNED);
 847
 848         if (aacraid_alloc_command(sc, &cm)) {
 849                 struct aac_event *event;
 850
 851                 xpt_freeze_simq(sim, 1);
 852                 ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
 853                 ccb->ccb_h.sim_priv.entries[0].ptr = camsc;
 854                 event = malloc(sizeof(struct aac_event), M_AACRAIDCAM,
 855                     M_NOWAIT | M_ZERO);
 856                 if (event == NULL) {
 857                         device_printf(sc->aac_dev,
 858                             "Warning, out of memory for event\n");
 859                         return;
 860                 }
 861                 event->ev_callback = aac_cam_event;
 862                 event->ev_arg = ccb;
 863                 event->ev_type = AAC_EVENT_CMFREE;
 864                 aacraid_add_event(sc, event);
 865                 return;
 866         }
 867
 868         fib = cm->cm_fib;
 869         switch (ccb->ccb_h.flags & CAM_DIR_MASK) {
 870         case CAM_DIR_IN:
 871                 cm->cm_flags |= AAC_CMD_DATAIN;
 872                 break;
 873         case CAM_DIR_OUT:
 874                 cm->cm_flags |= AAC_CMD_DATAOUT;
 875                 break;
 876         case CAM_DIR_NONE:
 877                 break;
 878         default:
 879                 cm->cm_flags |= AAC_CMD_DATAIN | AAC_CMD_DATAOUT;
 880                 break;
 881         }
 882
 883         srb = (struct aac_srb *)&fib->data[0];
 884         srb->function = AAC_SRB_FUNC_EXECUTE_SCSI;
 885         if (cm->cm_flags & (AAC_CMD_DATAIN|AAC_CMD_DATAOUT))
 886                 srb->flags = AAC_SRB_FLAGS_UNSPECIFIED_DIRECTION;
 887         if (cm->cm_flags & AAC_CMD_DATAIN)
 888                 srb->flags = AAC_SRB_FLAGS_DATA_IN;
 889         else if (cm->cm_flags & AAC_CMD_DATAOUT)
 890                 srb->flags = AAC_SRB_FLAGS_DATA_OUT;
 891         else
 892                 srb->flags = AAC_SRB_FLAGS_NO_DATA_XFER;
 893
 894         /*
 895          * Copy the CDB into the SRB.  It's only 6-16 bytes,
 896          * so a copy is not too expensive.
 897          */
 898         srb->cdb_len = ccb->csio.cdb_len;
 899         if (ccb->ccb_h.flags & CAM_CDB_POINTER)
 900                 bcopy(ccb->csio.cdb_io.cdb_ptr, (u_int8_t *)&srb->cdb[0],
 901                         srb->cdb_len);
 902         else
 903                 bcopy(ccb->csio.cdb_io.cdb_bytes, (u_int8_t *)&srb->cdb[0],
 904                         srb->cdb_len);
 905
 906         /* Set command */
 907         fib->Header.Command = (sc->flags & AAC_FLAGS_SG_64BIT) ?
 908                 ScsiPortCommandU64 : ScsiPortCommand;
 909         fib->Header.Size = sizeof(struct aac_fib_header) +
 910                         sizeof(struct aac_srb);
 911
 912         /* Map the s/g list */
 913         cm->cm_sgtable = &srb->sg_map;
 914         if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
 915                 /*
 916                  * Arrange things so that the S/G
 917                  * map will get set up automagically
 918                  */
 919                 cm->cm_data = (void *)ccb->csio.data_ptr;
 920                 cm->cm_datalen = ccb->csio.dxfer_len;
 921                 srb->data_len = ccb->csio.dxfer_len;
 922         } else {
 923                 cm->cm_data = NULL;
 924                 cm->cm_datalen = 0;
 925                 srb->data_len = 0;
 926         }
 927
 928         srb->bus = camsc->inf->BusNumber - 1; /* Bus no. rel. to the card */
 929         srb->target = ccb->ccb_h.target_id;
 930         srb->lun = ccb->ccb_h.target_lun;
 931         srb->timeout = ccb->ccb_h.timeout;      /* XXX */
 932         srb->retry_limit = 0;
 933
 934         cm->cm_complete = aac_cam_complete;
 935         cm->cm_ccb = ccb;
 936         cm->cm_timestamp = time_uptime;
 937
 938         fib->Header.XferState =
 939                         AAC_FIBSTATE_HOSTOWNED  |
 940                         AAC_FIBSTATE_INITIALISED        |
 941                         AAC_FIBSTATE_FROMHOST   |
 942                         AAC_FIBSTATE_REXPECTED  |
 943                         AAC_FIBSTATE_NORM       |
 944                         AAC_FIBSTATE_ASYNC       |
 945                         AAC_FIBSTATE_FAST_RESPONSE;
 946
 947         aac_enqueue_ready(cm);
 948         aacraid_startio(cm->cm_sc);
 949 }
 950
 951 static void
 952 aac_cam_action(struct cam_sim *sim, union ccb *ccb)
 953 {
 954         struct  aac_cam *camsc;
 955         struct  aac_softc *sc;
 956
 957         camsc = (struct aac_cam *)cam_sim_softc(sim);
 958         sc = camsc->inf->aac_sc;
 959         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 960         mtx_assert(&sc->aac_io_lock, MA_OWNED);
 961
 962         /* Synchronous ops, and ops that don't require communication with the
 963          * controller */
 964         switch(ccb->ccb_h.func_code) {
 965         case XPT_SCSI_IO:
 966                 /* This is handled down below */
 967                 break;
 968         case XPT_CALC_GEOMETRY:
 969         {
 970                 struct ccb_calc_geometry *ccg;
 971                 u_int32_t size_mb;
 972                 u_int32_t secs_per_cylinder;
 973
 974                 ccg = &ccb->ccg;
 975                 size_mb = ccg->volume_size /
 976                     ((1024L * 1024L) / ccg->block_size);
 977                 if (size_mb >= (2 * 1024)) {            /* 2GB */
 978                         ccg->heads = 255;
 979                         ccg->secs_per_track = 63;
 980                 } else if (size_mb >= (1 * 1024)) {     /* 1GB */
 981                         ccg->heads = 128;
 982                         ccg->secs_per_track = 32;
 983                 } else {
 984                         ccg->heads = 64;
 985                         ccg->secs_per_track = 32;
 986                 }
 987                 secs_per_cylinder = ccg->heads * ccg->secs_per_track;
 988                 ccg->cylinders = ccg->volume_size / secs_per_cylinder;
 989
 990                 ccb->ccb_h.status = CAM_REQ_CMP;
 991                 xpt_done(ccb);
 992                 return;
 993         }
 994         case XPT_PATH_INQ:
 995         {
 996                 struct ccb_pathinq *cpi = &ccb->cpi;
 997
 998                 cpi->version_num = 1;
 999                 cpi->target_sprt = 0;
1000                 cpi->hba_eng_cnt = 0;
1001                 cpi->max_target = camsc->inf->TargetsPerBus - 1;
1002                 cpi->max_lun = 7;       /* Per the controller spec */
1003                 cpi->initiator_id = camsc->inf->InitiatorBusId;
1004                 cpi->bus_id = camsc->inf->BusNumber;
1005                 cpi->maxio = sc->aac_max_sectors << 9;
1006
1007                 /*
1008                  * Resetting via the passthrough or parallel bus scan
1009                  * causes problems.
1010                  */
1011                 cpi->hba_misc = PIM_NOBUSRESET;
1012                 cpi->hba_inquiry = PI_TAG_ABLE;
1013                 cpi->base_transfer_speed = 300000;
1014 #ifdef CAM_NEW_TRAN_CODE
1015                 cpi->hba_misc |= PIM_SEQSCAN;
1016                 cpi->protocol = PROTO_SCSI;
1017                 cpi->transport = XPORT_SAS;
1018                 cpi->transport_version = 0;
1019                 cpi->protocol_version = SCSI_REV_SPC2;
1020 #endif
1021                 strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
1022                 strlcpy(cpi->hba_vid, "PMC-Sierra", HBA_IDLEN);
1023                 strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
1024                 cpi->unit_number = cam_sim_unit(sim);
1025                 ccb->ccb_h.status = CAM_REQ_CMP;
1026                 xpt_done(ccb);
1027                 return;
1028         }
1029         case XPT_GET_TRAN_SETTINGS:
1030         {
1031 #ifdef CAM_NEW_TRAN_CODE
1032                 struct ccb_trans_settings_scsi *scsi =
1033                         &ccb->cts.proto_specific.scsi;
1034                 struct ccb_trans_settings_spi *spi =
1035                         &ccb->cts.xport_specific.spi;
1036                 ccb->cts.protocol = PROTO_SCSI;
1037                 ccb->cts.protocol_version = SCSI_REV_SPC2;
1038                 ccb->cts.transport = XPORT_SAS;
1039                 ccb->cts.transport_version = 0;
1040                 scsi->valid = CTS_SCSI_VALID_TQ;
1041                 scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
1042                 spi->valid |= CTS_SPI_VALID_DISC;
1043                 spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
1044 #else
1045                 ccb->cts.flags = ~(CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB);
1046                 ccb->cts.valid = CCB_TRANS_DISC_VALID | CCB_TRANS_TQ_VALID;
1047 #endif
1048                 ccb->ccb_h.status = CAM_REQ_CMP;
1049                 xpt_done(ccb);
1050                 return;
1051         }
1052         case XPT_SET_TRAN_SETTINGS:
1053                 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
1054                 xpt_done(ccb);
1055                 return;
1056         case XPT_RESET_BUS:
1057                 if (!(sc->flags & AAC_FLAGS_CAM_NORESET) &&
1058                         camsc->inf->BusType != CONTAINER_BUS) {
1059                         ccb->ccb_h.status = aac_cam_reset_bus(sim, ccb);
1060                 } else {
1061                         ccb->ccb_h.status = CAM_REQ_CMP;
1062                 }
1063                 xpt_done(ccb);
1064                 return;
1065         case XPT_RESET_DEV:
1066                 ccb->ccb_h.status = CAM_REQ_CMP;
1067                 xpt_done(ccb);
1068                 return;
1069         case XPT_ABORT:
1070                 ccb->ccb_h.status = aac_cam_abort_ccb(sim, ccb);
1071                 xpt_done(ccb);
1072                 return;
1073         case XPT_TERM_IO:
1074                 ccb->ccb_h.status = aac_cam_term_io(sim, ccb);
1075                 xpt_done(ccb);
1076                 return;
1077         default:
1078                 device_printf(sc->aac_dev, "Unsupported command 0x%x\n",
1079                     ccb->ccb_h.func_code);
1080                 ccb->ccb_h.status = CAM_PROVIDE_FAIL;
1081                 xpt_done(ccb);
1082                 return;
1083         }
1084
1085         /* Async ops that require communcation with the controller */
1086         if (camsc->inf->BusType == CONTAINER_BUS) {
1087                 u_int8_t *cmdp;
1088
1089                 if (ccb->ccb_h.flags & CAM_CDB_POINTER)
1090                         cmdp = ccb->csio.cdb_io.cdb_ptr;
1091                 else
1092                         cmdp = &ccb->csio.cdb_io.cdb_bytes[0];
1093
1094                 if (*cmdp==READ_6 || *cmdp==WRITE_6 || *cmdp==READ_10 ||
1095                         *cmdp==WRITE_10 || *cmdp==READ_12 || *cmdp==WRITE_12 ||
1096                         *cmdp==READ_16 || *cmdp==WRITE_16)
1097                         aac_container_rw_command(sim, ccb, cmdp);
1098                 else
1099                         aac_container_special_command(sim, ccb, cmdp);
1100         } else {
1101                 aac_passthrough_command(sim, ccb);
1102         }
1103 }
1104
1105 static void
1106 aac_cam_poll(struct cam_sim *sim)
1107 {
1108         /*
1109          * Pinging the interrupt routine isn't very safe, nor is it
1110          * really necessary.  Do nothing.
1111          */
1112 }
1113
1114 static void
1115 aac_container_complete(struct aac_command *cm)
1116 {
1117         union   ccb *ccb;
1118         u_int32_t status;
1119
1120         fwprintf(cm->cm_sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1121         ccb = cm->cm_ccb;
1122         status = ((u_int32_t *)cm->cm_fib->data)[0];
1123
1124         if (cm->cm_flags & AAC_CMD_RESET) {
1125                 ccb->ccb_h.status = CAM_SCSI_BUS_RESET;
1126         } else if (status == ST_OK) {
1127                 ccb->ccb_h.status = CAM_REQ_CMP;
1128         } else if (status == ST_NOT_READY) {
1129                 ccb->ccb_h.status = CAM_BUSY;
1130         } else {
1131                 ccb->ccb_h.status = CAM_REQ_CMP_ERR;
1132         }
1133
1134         aacraid_release_command(cm);
1135         xpt_done(ccb);
1136 }
1137
1138 static void
1139 aac_cam_complete(struct aac_command *cm)
1140 {
1141         union   ccb *ccb;
1142         struct  aac_srb_response *srbr;
1143         struct  aac_softc *sc;
1144
1145         sc = cm->cm_sc;
1146         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1147         ccb = cm->cm_ccb;
1148         srbr = (struct aac_srb_response *)&cm->cm_fib->data[0];
1149
1150         if (cm->cm_flags & AAC_CMD_FASTRESP) {
1151                 /* fast response */
1152                 srbr->srb_status = CAM_REQ_CMP;
1153                 srbr->scsi_status = SCSI_STATUS_OK;
1154                 srbr->sense_len = 0;
1155         }
1156
1157         if (cm->cm_flags & AAC_CMD_RESET) {
1158                 ccb->ccb_h.status = CAM_SCSI_BUS_RESET;
1159         } else if (srbr->fib_status != 0) {
1160                 device_printf(sc->aac_dev, "Passthru FIB failed!\n");
1161                 ccb->ccb_h.status = CAM_REQ_ABORTED;
1162         } else {
1163                 /*
1164                  * The SRB error codes just happen to match the CAM error
1165                  * codes.  How convenient!
1166                  */
1167                 ccb->ccb_h.status = srbr->srb_status;
1168
1169                 /* Take care of SCSI_IO ops. */
1170                 if (ccb->ccb_h.func_code == XPT_SCSI_IO) {
1171                         u_int8_t command, device;
1172
1173                         ccb->csio.scsi_status = srbr->scsi_status;
1174
1175                         /* Take care of autosense */
1176                         if (srbr->sense_len) {
1177                                 int sense_len, scsi_sense_len;
1178
1179                                 scsi_sense_len = sizeof(struct scsi_sense_data);
1180                                 bzero(&ccb->csio.sense_data, scsi_sense_len);
1181                                 sense_len = (srbr->sense_len >
1182                                     scsi_sense_len) ? scsi_sense_len :
1183                                     srbr->sense_len;
1184                                 bcopy(&srbr->sense[0], &ccb->csio.sense_data,
1185                                     srbr->sense_len);
1186                                 ccb->csio.sense_len = sense_len;
1187                                 ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
1188                                 // scsi_sense_print(&ccb->csio);
1189                         }
1190
1191                         /* If this is an inquiry command, fake things out */
1192                         if (ccb->ccb_h.flags & CAM_CDB_POINTER)
1193                                 command = ccb->csio.cdb_io.cdb_ptr[0];
1194                         else
1195                                 command = ccb->csio.cdb_io.cdb_bytes[0];
1196
1197                         if (command == INQUIRY) {
1198                                 if (ccb->ccb_h.status == CAM_REQ_CMP) {
1199                                   device = ccb->csio.data_ptr[0] & 0x1f;
1200                                   /*
1201                                    * We want DASD and PROC devices to only be
1202                                    * visible through the pass device.
1203                                    */
1204                                   if ((device == T_DIRECT &&
1205                                     !(sc->aac_feature_bits & AAC_SUPPL_SUPPORTED_JBOD)) ||
1206                                     (device == T_PROCESSOR))
1207                                     ccb->csio.data_ptr[0] =
1208                                         ((device & 0xe0) | T_NODEVICE);
1209
1210                                   /* handle phys. components of a log. drive */
1211                                   if (ccb->csio.data_ptr[0] & 0x20) {
1212                                         if (sc->hint_flags & 8) {
1213                                           /* expose phys. device (daXX) */
1214                                           ccb->csio.data_ptr[0] &= 0xdf;
1215                                         } else {
1216                                           /* phys. device only visible through pass device (passXX) */
1217                                           ccb->csio.data_ptr[0] |= 0x10;
1218                                         }
1219                                   }
1220                                 } else if (ccb->ccb_h.status == CAM_SEL_TIMEOUT &&
1221                                   ccb->ccb_h.target_lun != 0) {
1222                                   /* fix for INQUIRYs on Lun>0 */
1223                                   ccb->ccb_h.status = CAM_DEV_NOT_THERE;
1224                                 }
1225                         }
1226                 }
1227         }
1228
1229         aacraid_release_command(cm);
1230         xpt_done(ccb);
1231 }
1232
1233 static u_int32_t
1234 aac_cam_reset_bus(struct cam_sim *sim, union ccb *ccb)
1235 {
1236         struct aac_command *cm;
1237         struct aac_fib *fib;
1238         struct aac_softc *sc;
1239         struct aac_cam *camsc;
1240         struct aac_vmioctl *vmi;
1241         struct aac_resetbus *rbc;
1242         u_int32_t rval;
1243
1244         camsc = (struct aac_cam *)cam_sim_softc(sim);
1245         sc = camsc->inf->aac_sc;
1246
1247         if (sc == NULL) {
1248                 printf("aac: Null sc?\n");
1249                 return (CAM_REQ_ABORTED);
1250         }
1251
1252         if (aacraid_alloc_command(sc, &cm)) {
1253                 struct aac_event *event;
1254
1255                 xpt_freeze_simq(sim, 1);
1256                 ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
1257                 ccb->ccb_h.sim_priv.entries[0].ptr = camsc;
1258                 event = malloc(sizeof(struct aac_event), M_AACRAIDCAM,
1259                         M_NOWAIT | M_ZERO);
1260                 if (event == NULL) {
1261                         device_printf(sc->aac_dev,
1262                                 "Warning, out of memory for event\n");
1263                         return (CAM_REQ_ABORTED);
1264                 }
1265                 event->ev_callback = aac_cam_event;
1266                 event->ev_arg = ccb;
1267                 event->ev_type = AAC_EVENT_CMFREE;
1268                 aacraid_add_event(sc, event);
1269                 return (CAM_REQ_ABORTED);
1270         }
1271
1272         fib = cm->cm_fib;
1273         cm->cm_timestamp = time_uptime;
1274         cm->cm_datalen = 0;
1275
1276         fib->Header.Size =
1277                 sizeof(struct aac_fib_header) + sizeof(struct aac_vmioctl);
1278         fib->Header.XferState =
1279                 AAC_FIBSTATE_HOSTOWNED   |
1280                 AAC_FIBSTATE_INITIALISED |
1281                 AAC_FIBSTATE_EMPTY       |
1282                 AAC_FIBSTATE_FROMHOST    |
1283                 AAC_FIBSTATE_REXPECTED   |
1284                 AAC_FIBSTATE_NORM        |
1285                 AAC_FIBSTATE_ASYNC       |
1286                 AAC_FIBSTATE_FAST_RESPONSE;
1287         fib->Header.Command = ContainerCommand;
1288
1289         vmi = (struct aac_vmioctl *)&fib->data[0];
1290         bzero(vmi, sizeof(struct aac_vmioctl));
1291
1292         vmi->Command = VM_Ioctl;
1293         vmi->ObjType = FT_DRIVE;
1294         vmi->MethId = sc->scsi_method_id;
1295         vmi->ObjId = 0;
1296         vmi->IoctlCmd = ResetBus;
1297
1298         rbc = (struct aac_resetbus *)&vmi->IoctlBuf[0];
1299         rbc->BusNumber = camsc->inf->BusNumber - 1;
1300
1301         if (aacraid_wait_command(cm) != 0) {
1302                 device_printf(sc->aac_dev,"Error sending ResetBus command\n");
1303                 rval = CAM_REQ_ABORTED;
1304         } else {
1305                 rval = CAM_REQ_CMP;
1306         }
1307         aacraid_release_command(cm);
1308         return (rval);
1309 }
1310
1311 static u_int32_t
1312 aac_cam_abort_ccb(struct cam_sim *sim, union ccb *ccb)
1313 {
1314         return (CAM_UA_ABORT);
1315 }
1316
1317 static u_int32_t
1318 aac_cam_term_io(struct cam_sim *sim, union ccb *ccb)
1319 {
1320         return (CAM_UA_TERMIO);
1321 }
1322
1323 static int
1324 aac_load_map_command_sg(struct aac_softc *sc, struct aac_command *cm)
1325 {
1326         int error;
1327
1328         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1329         error = bus_dmamap_load(sc->aac_buffer_dmat,
1330                                 cm->cm_datamap, cm->cm_data, cm->cm_datalen,
1331                                 aacraid_map_command_sg, cm, 0);
1332         if (error == EINPROGRESS) {
1333                 fwprintf(sc, HBA_FLAGS_DBG_INIT_B, "freezing queue\n");
1334                 sc->flags |= AAC_QUEUE_FRZN;
1335                 error = 0;
1336         } else if (error != 0) {
1337                 panic("aac_load_map_command_sg: unexpected error %d from "
1338                         "busdma", error);
1339         }
1340         return(error);
1341 }
1342
1343 /*
1344  * Start as much queued I/O as possible on the controller
1345  */
1346 void
1347 aacraid_startio(struct aac_softc *sc)
1348 {
1349         struct aac_command *cm;
1350
1351         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1352
1353         for (;;) {
1354                 if (sc->aac_state & AAC_STATE_RESET) {
1355                         fwprintf(sc, HBA_FLAGS_DBG_ERROR_B, "AAC_STATE_RESET");
1356                         break;
1357                 }
1358                 /*
1359                  * This flag might be set if the card is out of resources.
1360                  * Checking it here prevents an infinite loop of deferrals.
1361                  */
1362                 if (sc->flags & AAC_QUEUE_FRZN) {
1363                         fwprintf(sc, HBA_FLAGS_DBG_ERROR_B, "AAC_QUEUE_FRZN");
1364                         break;
1365                 }
1366
1367                 /*
1368                  * Try to get a command that's been put off for lack of
1369                  * resources
1370                  */
1371                 if ((sc->flags & AAC_FLAGS_SYNC_MODE) && sc->aac_sync_cm)
1372                         break;
1373                 cm = aac_dequeue_ready(sc);
1374
1375                 /* nothing to do? */
1376                 if (cm == NULL)
1377                         break;
1378
1379                 /* don't map more than once */
1380                 if (cm->cm_flags & AAC_CMD_MAPPED)
1381                         panic("aac: command %p already mapped", cm);
1382
1383                 /*
1384                  * Set up the command to go to the controller.  If there are no
1385                  * data buffers associated with the command then it can bypass
1386                  * busdma.
1387                  */
1388                 if (cm->cm_datalen)
1389                         aac_load_map_command_sg(sc, cm);
1390                 else
1391                         aacraid_map_command_sg(cm, NULL, 0, 0);
1392         }
1393 }