1 /*
   2  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
   3  */
   4 
   5 /*
   6  * Copyright 2005-08 Adaptec, Inc.
   7  * Copyright (c) 2005-08 Adaptec Inc., Achim Leubner
   8  * Copyright (c) 2000 Michael Smith
   9  * Copyright (c) 2001 Scott Long
  10  * Copyright (c) 2000 BSDi
  11  * All rights reserved.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34 #include <sys/modctl.h>
  35 #include <sys/conf.h>
  36 #include <sys/cmn_err.h>
  37 #include <sys/ddi.h>
  38 #include <sys/devops.h>
  39 #include <sys/pci.h>
  40 #include <sys/types.h>
  41 #include <sys/ddidmareq.h>
  42 #include <sys/scsi/scsi.h>
  43 #include <sys/ksynch.h>
  44 #include <sys/sunddi.h>
  45 #include <sys/byteorder.h>
  46 #include "aac_regs.h"
  47 #include "aac.h"
  48 
  49 /*
  50  * FMA header files
  51  */
  52 #include <sys/ddifm.h>
  53 #include <sys/fm/protocol.h>
  54 #include <sys/fm/util.h>
  55 #include <sys/fm/io/ddi.h>
  56 
  57 /*
  58  * For minor nodes created by the SCSA framework, minor numbers are
  59  * formed by left-shifting instance by INST_MINOR_SHIFT and OR in a
  60  * number less than 64.
  61  *
  62  * To support cfgadm, need to confirm the SCSA framework by creating
  63  * devctl/scsi and driver specific minor nodes under SCSA format,
  64  * and calling scsi_hba_xxx() functions aacordingly.
  65  */
  66 
  67 #define AAC_MINOR               32
  68 #define INST2AAC(x)             (((x) << INST_MINOR_SHIFT) | AAC_MINOR)
  69 #define AAC_SCSA_MINOR(x)       ((x) & TRAN_MINOR_MASK)
  70 #define AAC_IS_SCSA_NODE(x)     ((x) == DEVCTL_MINOR || (x) == SCSI_MINOR)
  71 
  72 #define SD2TRAN(sd)             ((sd)->sd_address.a_hba_tran)
  73 #define AAC_TRAN2SOFTS(tran) ((struct aac_softstate *)(tran)->tran_hba_private)
  74 #define AAC_DIP2TRAN(dip)       ((scsi_hba_tran_t *)ddi_get_driver_private(dip))
  75 #define AAC_DIP2SOFTS(dip)      (AAC_TRAN2SOFTS(AAC_DIP2TRAN(dip)))
  76 #define SD2AAC(sd)              (AAC_TRAN2SOFTS(SD2TRAN(sd)))
  77 #define AAC_PD(t)               ((t) - AAC_MAX_LD)
  78 #define AAC_DEV(softs, t)       (((t) < AAC_MAX_LD) ? \
  79                                 &(softs)->containers[(t)].dev : \
  80                                 ((t) < AAC_MAX_DEV(softs)) ? \
  81                                 &(softs)->nondasds[AAC_PD(t)].dev : NULL)
  82 #define AAC_DEVCFG_BEGIN(softs, tgt) \
  83                                 aac_devcfg((softs), (tgt), 1)
  84 #define AAC_DEVCFG_END(softs, tgt) \
  85                                 aac_devcfg((softs), (tgt), 0)
  86 #define PKT2AC(pkt)             ((struct aac_cmd *)(pkt)->pkt_ha_private)
  87 #define AAC_BUSYWAIT(cond, timeout /* in millisecond */) { \
  88                 if (!(cond)) { \
  89                         int count = (timeout) * 10; \
  90                         while (count) { \
  91                                 drv_usecwait(100); \
  92                                 if (cond) \
  93                                         break; \
  94                                 count--; \
  95                         } \
  96                         (timeout) = (count + 9) / 10; \
  97                 } \
  98         }
  99 
 100 #define AAC_SENSE_DATA_DESCR_LEN \
 101         (sizeof (struct scsi_descr_sense_hdr) + \
 102         sizeof (struct scsi_information_sense_descr))
 103 #define AAC_ARQ64_LENGTH \
 104         (sizeof (struct scsi_arq_status) + \
 105         AAC_SENSE_DATA_DESCR_LEN - SENSE_LENGTH)
 106 
 107 /* NOTE: GETG4ADDRTL(cdbp) is int32_t */
 108 #define AAC_GETGXADDR(cmdlen, cdbp) \
 109         ((cmdlen == 6) ? GETG0ADDR(cdbp) : \
 110         (cmdlen == 10) ? (uint32_t)GETG1ADDR(cdbp) : \
 111         ((uint64_t)GETG4ADDR(cdbp) << 32) | (uint32_t)GETG4ADDRTL(cdbp))
 112 
 113 #define AAC_CDB_INQUIRY_CMDDT   0x02
 114 #define AAC_CDB_INQUIRY_EVPD    0x01
 115 #define AAC_VPD_PAGE_CODE       1
 116 #define AAC_VPD_PAGE_LENGTH     3
 117 #define AAC_VPD_PAGE_DATA       4
 118 #define AAC_VPD_ID_CODESET      0
 119 #define AAC_VPD_ID_TYPE         1
 120 #define AAC_VPD_ID_LENGTH       3
 121 #define AAC_VPD_ID_DATA         4
 122 
 123 #define AAC_SCSI_RPTLUNS_HEAD_SIZE                      0x08
 124 #define AAC_SCSI_RPTLUNS_ADDR_SIZE                      0x08
 125 #define AAC_SCSI_RPTLUNS_ADDR_MASK                      0xC0
 126 /* 00b - peripheral device addressing method */
 127 #define AAC_SCSI_RPTLUNS_ADDR_PERIPHERAL                0x00
 128 /* 01b - flat space addressing method */
 129 #define AAC_SCSI_RPTLUNS_ADDR_FLAT_SPACE                0x40
 130 /* 10b - logical unit addressing method */
 131 #define AAC_SCSI_RPTLUNS_ADDR_LOGICAL_UNIT              0x80
 132 
 133 /* Return the size of FIB with data part type data_type */
 134 #define AAC_FIB_SIZEOF(data_type) \
 135         (sizeof (struct aac_fib_header) + sizeof (data_type))
 136 /* Return the container size defined in mir */
 137 #define AAC_MIR_SIZE(softs, acc, mir) \
 138         (((softs)->flags & AAC_FLAGS_LBA_64BIT) ? \
 139         (uint64_t)ddi_get32((acc), &(mir)->MntObj.Capacity) + \
 140         ((uint64_t)ddi_get32((acc), &(mir)->MntObj.CapacityHigh) << 32) : \
 141         (uint64_t)ddi_get32((acc), &(mir)->MntObj.Capacity))
 142 
 143 /* The last entry of aac_cards[] is for unknown cards */
 144 #define AAC_UNKNOWN_CARD \
 145         (sizeof (aac_cards) / sizeof (struct aac_card_type) - 1)
 146 #define CARD_IS_UNKNOWN(i)      (i == AAC_UNKNOWN_CARD)
 147 #define BUF_IS_READ(bp)         ((bp)->b_flags & B_READ)
 148 #define AAC_IS_Q_EMPTY(q)       ((q)->q_head == NULL)
 149 #define AAC_CMDQ(acp)           (!((acp)->flags & AAC_CMD_SYNC))
 150 
 151 #define PCI_MEM_GET32(softs, off) \
 152         ddi_get32((softs)->pci_mem_handle, \
 153             (void *)((softs)->pci_mem_base_vaddr + (off)))
 154 #define PCI_MEM_PUT32(softs, off, val) \
 155         ddi_put32((softs)->pci_mem_handle, \
 156             (void *)((softs)->pci_mem_base_vaddr + (off)), \
 157             (uint32_t)(val))
 158 #define PCI_MEM_GET16(softs, off) \
 159         ddi_get16((softs)->pci_mem_handle, \
 160         (void *)((softs)->pci_mem_base_vaddr + (off)))
 161 #define PCI_MEM_PUT16(softs, off, val) \
 162         ddi_put16((softs)->pci_mem_handle, \
 163         (void *)((softs)->pci_mem_base_vaddr + (off)), (uint16_t)(val))
 164 /* Write host data at valp to device mem[off] repeatedly count times */
 165 #define PCI_MEM_REP_PUT8(softs, off, valp, count) \
 166         ddi_rep_put8((softs)->pci_mem_handle, (uint8_t *)(valp), \
 167             (uint8_t *)((softs)->pci_mem_base_vaddr + (off)), \
 168             count, DDI_DEV_AUTOINCR)
 169 /* Read device data at mem[off] to host addr valp repeatedly count times */
 170 #define PCI_MEM_REP_GET8(softs, off, valp, count) \
 171         ddi_rep_get8((softs)->pci_mem_handle, (uint8_t *)(valp), \
 172             (uint8_t *)((softs)->pci_mem_base_vaddr + (off)), \
 173             count, DDI_DEV_AUTOINCR)
 174 #define AAC_GET_FIELD8(acc, d, s, field) \
 175         (d)->field = ddi_get8(acc, (uint8_t *)&(s)->field)
 176 #define AAC_GET_FIELD32(acc, d, s, field) \
 177         (d)->field = ddi_get32(acc, (uint32_t *)&(s)->field)
 178 #define AAC_GET_FIELD64(acc, d, s, field) \
 179         (d)->field = ddi_get64(acc, (uint64_t *)&(s)->field)
 180 #define AAC_REP_GET_FIELD8(acc, d, s, field, r) \
 181         ddi_rep_get8((acc), (uint8_t *)&(d)->field, \
 182             (uint8_t *)&(s)->field, (r), DDI_DEV_AUTOINCR)
 183 #define AAC_REP_GET_FIELD32(acc, d, s, field, r) \
 184         ddi_rep_get32((acc), (uint32_t *)&(d)->field, \
 185             (uint32_t *)&(s)->field, (r), DDI_DEV_AUTOINCR)
 186 
 187 #define AAC_ENABLE_INTR(softs) { \
 188                 if (softs->flags & AAC_FLAGS_NEW_COMM) \
 189                         PCI_MEM_PUT32(softs, AAC_OIMR, ~AAC_DB_INTR_NEW); \
 190                 else \
 191                         PCI_MEM_PUT32(softs, AAC_OIMR, ~AAC_DB_INTR_BITS); \
 192                 softs->state |= AAC_STATE_INTR; \
 193         }
 194 
 195 #define AAC_DISABLE_INTR(softs) { \
 196                 PCI_MEM_PUT32(softs, AAC_OIMR, ~0); \
 197                 softs->state &= ~AAC_STATE_INTR; \
 198         }
 199 #define AAC_STATUS_CLR(softs, mask)     PCI_MEM_PUT32(softs, AAC_ODBR, mask)
 200 #define AAC_STATUS_GET(softs)           PCI_MEM_GET32(softs, AAC_ODBR)
 201 #define AAC_NOTIFY(softs, val)          PCI_MEM_PUT32(softs, AAC_IDBR, val)
 202 #define AAC_OUTB_GET(softs)             PCI_MEM_GET32(softs, AAC_OQUE)
 203 #define AAC_OUTB_SET(softs, val)        PCI_MEM_PUT32(softs, AAC_OQUE, val)
 204 #define AAC_FWSTATUS_GET(softs) \
 205         ((softs)->aac_if.aif_get_fwstatus(softs))
 206 #define AAC_MAILBOX_GET(softs, mb) \
 207         ((softs)->aac_if.aif_get_mailbox((softs), (mb)))
 208 #define AAC_MAILBOX_SET(softs, cmd, arg0, arg1, arg2, arg3) \
 209         ((softs)->aac_if.aif_set_mailbox((softs), (cmd), \
 210             (arg0), (arg1), (arg2), (arg3)))
 211 
 212 #define AAC_MGT_SLOT_NUM        2
 213 #define AAC_THROTTLE_DRAIN      -1
 214 
 215 #define AAC_QUIESCE_TICK        1       /* 1 second */
 216 #define AAC_QUIESCE_TIMEOUT     180     /* 180 seconds */
 217 #define AAC_DEFAULT_TICK        10      /* 10 seconds */
 218 #define AAC_SYNC_TICK           (30*60) /* 30 minutes */
 219 
 220 /* Poll time for aac_do_poll_io() */
 221 #define AAC_POLL_TIME           60      /* 60 seconds */
 222 
 223 /* IOP reset */
 224 #define AAC_IOP_RESET_SUCCEED           0       /* IOP reset succeed */
 225 #define AAC_IOP_RESET_FAILED            -1      /* IOP reset failed */
 226 #define AAC_IOP_RESET_ABNORMAL          -2      /* Reset operation abnormal */
 227 
 228 /*
 229  * Hardware access functions
 230  */
 231 static int aac_rx_get_fwstatus(struct aac_softstate *);
 232 static int aac_rx_get_mailbox(struct aac_softstate *, int);
 233 static void aac_rx_set_mailbox(struct aac_softstate *, uint32_t, uint32_t,
 234     uint32_t, uint32_t, uint32_t);
 235 static int aac_rkt_get_fwstatus(struct aac_softstate *);
 236 static int aac_rkt_get_mailbox(struct aac_softstate *, int);
 237 static void aac_rkt_set_mailbox(struct aac_softstate *, uint32_t, uint32_t,
 238     uint32_t, uint32_t, uint32_t);
 239 
 240 /*
 241  * SCSA function prototypes
 242  */
 243 static int aac_attach(dev_info_t *, ddi_attach_cmd_t);
 244 static int aac_detach(dev_info_t *, ddi_detach_cmd_t);
 245 static int aac_reset(dev_info_t *, ddi_reset_cmd_t);
 246 static int aac_quiesce(dev_info_t *);
 247 static int aac_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
 248 
 249 /*
 250  * Interrupt handler functions
 251  */
 252 static int aac_query_intrs(struct aac_softstate *, int);
 253 static int aac_add_intrs(struct aac_softstate *);
 254 static void aac_remove_intrs(struct aac_softstate *);
 255 static int aac_enable_intrs(struct aac_softstate *);
 256 static int aac_disable_intrs(struct aac_softstate *);
 257 static uint_t aac_intr_old(caddr_t);
 258 static uint_t aac_intr_new(caddr_t);
 259 static uint_t aac_softintr(caddr_t);
 260 
 261 /*
 262  * Internal functions in attach
 263  */
 264 static int aac_check_card_type(struct aac_softstate *);
 265 static int aac_check_firmware(struct aac_softstate *);
 266 static int aac_common_attach(struct aac_softstate *);
 267 static void aac_common_detach(struct aac_softstate *);
 268 static int aac_probe_containers(struct aac_softstate *);
 269 static int aac_alloc_comm_space(struct aac_softstate *);
 270 static int aac_setup_comm_space(struct aac_softstate *);
 271 static void aac_free_comm_space(struct aac_softstate *);
 272 static int aac_hba_setup(struct aac_softstate *);
 273 
 274 /*
 275  * Sync FIB operation functions
 276  */
 277 int aac_sync_mbcommand(struct aac_softstate *, uint32_t, uint32_t,
 278     uint32_t, uint32_t, uint32_t, uint32_t *);
 279 static int aac_sync_fib(struct aac_softstate *, uint16_t, uint16_t);
 280 
 281 /*
 282  * Command queue operation functions
 283  */
 284 static void aac_cmd_initq(struct aac_cmd_queue *);
 285 static void aac_cmd_enqueue(struct aac_cmd_queue *, struct aac_cmd *);
 286 static struct aac_cmd *aac_cmd_dequeue(struct aac_cmd_queue *);
 287 static void aac_cmd_delete(struct aac_cmd_queue *, struct aac_cmd *);
 288 
 289 /*
 290  * FIB queue operation functions
 291  */
 292 static int aac_fib_enqueue(struct aac_softstate *, int, uint32_t, uint32_t);
 293 static int aac_fib_dequeue(struct aac_softstate *, int, int *);
 294 
 295 /*
 296  * Slot operation functions
 297  */
 298 static int aac_create_slots(struct aac_softstate *);
 299 static void aac_destroy_slots(struct aac_softstate *);
 300 static void aac_alloc_fibs(struct aac_softstate *);
 301 static void aac_destroy_fibs(struct aac_softstate *);
 302 static struct aac_slot *aac_get_slot(struct aac_softstate *);
 303 static void aac_release_slot(struct aac_softstate *, struct aac_slot *);
 304 static int aac_alloc_fib(struct aac_softstate *, struct aac_slot *);
 305 static void aac_free_fib(struct aac_slot *);
 306 
 307 /*
 308  * Internal functions
 309  */
 310 static void aac_cmd_fib_header(struct aac_softstate *, struct aac_cmd *,
 311     uint16_t);
 312 static void aac_cmd_fib_rawio(struct aac_softstate *, struct aac_cmd *);
 313 static void aac_cmd_fib_brw64(struct aac_softstate *, struct aac_cmd *);
 314 static void aac_cmd_fib_brw(struct aac_softstate *, struct aac_cmd *);
 315 static void aac_cmd_fib_sync(struct aac_softstate *, struct aac_cmd *);
 316 static void aac_cmd_fib_scsi32(struct aac_softstate *, struct aac_cmd *);
 317 static void aac_cmd_fib_scsi64(struct aac_softstate *, struct aac_cmd *);
 318 static void aac_cmd_fib_startstop(struct aac_softstate *, struct aac_cmd *);
 319 static void aac_start_waiting_io(struct aac_softstate *);
 320 static void aac_drain_comp_q(struct aac_softstate *);
 321 int aac_do_io(struct aac_softstate *, struct aac_cmd *);
 322 static int aac_sync_fib_slot_bind(struct aac_softstate *, struct aac_cmd *);
 323 static void aac_sync_fib_slot_release(struct aac_softstate *, struct aac_cmd *);
 324 static void aac_start_io(struct aac_softstate *, struct aac_cmd *);
 325 static int aac_do_poll_io(struct aac_softstate *, struct aac_cmd *);
 326 static int aac_do_sync_io(struct aac_softstate *, struct aac_cmd *);
 327 static int aac_send_command(struct aac_softstate *, struct aac_slot *);
 328 static void aac_cmd_timeout(struct aac_softstate *, struct aac_cmd *);
 329 static int aac_dma_sync_ac(struct aac_cmd *);
 330 static int aac_shutdown(struct aac_softstate *);
 331 static int aac_reset_adapter(struct aac_softstate *);
 332 static int aac_do_quiesce(struct aac_softstate *softs);
 333 static int aac_do_unquiesce(struct aac_softstate *softs);
 334 static void aac_unhold_bus(struct aac_softstate *, int);
 335 static void aac_set_throttle(struct aac_softstate *, struct aac_device *,
 336     int, int);
 337 
 338 /*
 339  * Adapter Initiated FIB handling function
 340  */
 341 static void aac_save_aif(struct aac_softstate *, ddi_acc_handle_t,
 342     struct aac_fib *, int);
 343 static int aac_handle_aif(struct aac_softstate *, struct aac_aif_command *);
 344 
 345 /*
 346  * Event handling related functions
 347  */
 348 static void aac_timer(void *);
 349 static void aac_event_thread(struct aac_softstate *);
 350 static void aac_event_disp(struct aac_softstate *, int);
 351 
 352 /*
 353  * IOCTL interface related functions
 354  */
 355 static int aac_open(dev_t *, int, int, cred_t *);
 356 static int aac_close(dev_t, int, int, cred_t *);
 357 static int aac_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
 358 extern int aac_do_ioctl(struct aac_softstate *, dev_t, int, intptr_t, int);
 359 
 360 /*
 361  * FMA Prototypes
 362  */
 363 static void aac_fm_init(struct aac_softstate *);
 364 static void aac_fm_fini(struct aac_softstate *);
 365 static int aac_fm_error_cb(dev_info_t *, ddi_fm_error_t *, const void *);
 366 int aac_check_acc_handle(ddi_acc_handle_t);
 367 int aac_check_dma_handle(ddi_dma_handle_t);
 368 void aac_fm_ereport(struct aac_softstate *, char *);
 369 
 370 /*
 371  * Auto enumeration functions
 372  */
 373 static dev_info_t *aac_find_child(struct aac_softstate *, uint16_t, uint8_t);
 374 static int aac_tran_bus_config(dev_info_t *, uint_t, ddi_bus_config_op_t,
 375     void *, dev_info_t **);
 376 static int aac_handle_dr(struct aac_softstate *, int, int, int);
 377 
 378 extern pri_t minclsyspri;
 379 
 380 #ifdef DEBUG
 381 /*
 382  * UART debug output support
 383  */
 384 
 385 #define AAC_PRINT_BUFFER_SIZE           512
 386 #define AAC_PRINT_TIMEOUT               250     /* 1/4 sec. = 250 msec. */
 387 
 388 #define AAC_FW_DBG_STRLEN_OFFSET        0x00
 389 #define AAC_FW_DBG_FLAGS_OFFSET         0x04
 390 #define AAC_FW_DBG_BLED_OFFSET          0x08
 391 
 392 static int aac_get_fw_debug_buffer(struct aac_softstate *);
 393 static void aac_print_scmd(struct aac_softstate *, struct aac_cmd *);
 394 static void aac_print_aif(struct aac_softstate *, struct aac_aif_command *);
 395 
 396 static char aac_prt_buf[AAC_PRINT_BUFFER_SIZE];
 397 static char aac_fmt[] = " %s";
 398 static char aac_fmt_header[] = " %s.%d: %s";
 399 static kmutex_t aac_prt_mutex;
 400 
 401 /*
 402  * Debug flags to be put into the softstate flags field
 403  * when initialized
 404  */
 405 uint32_t aac_debug_flags =
 406 /*    AACDB_FLAGS_KERNEL_PRINT | */
 407 /*    AACDB_FLAGS_FW_PRINT |    */
 408 /*    AACDB_FLAGS_MISC |        */
 409 /*    AACDB_FLAGS_FUNC1 |       */
 410 /*    AACDB_FLAGS_FUNC2 |       */
 411 /*    AACDB_FLAGS_SCMD |        */
 412 /*    AACDB_FLAGS_AIF |         */
 413 /*    AACDB_FLAGS_FIB |         */
 414 /*    AACDB_FLAGS_IOCTL |       */
 415 0;
 416 uint32_t aac_debug_fib_flags =
 417 /*    AACDB_FLAGS_FIB_RW |      */
 418 /*    AACDB_FLAGS_FIB_IOCTL |   */
 419 /*    AACDB_FLAGS_FIB_SRB |     */
 420 /*    AACDB_FLAGS_FIB_SYNC |    */
 421 /*    AACDB_FLAGS_FIB_HEADER |  */
 422 /*    AACDB_FLAGS_FIB_TIMEOUT | */
 423 0;
 424 
 425 #endif /* DEBUG */
 426 
 427 static struct cb_ops aac_cb_ops = {
 428         aac_open,       /* open */
 429         aac_close,      /* close */
 430         nodev,          /* strategy */
 431         nodev,          /* print */
 432         nodev,          /* dump */
 433         nodev,          /* read */
 434         nodev,          /* write */
 435         aac_ioctl,      /* ioctl */
 436         nodev,          /* devmap */
 437         nodev,          /* mmap */
 438         nodev,          /* segmap */
 439         nochpoll,       /* poll */
 440         ddi_prop_op,    /* cb_prop_op */
 441         NULL,           /* streamtab */
 442         D_64BIT | D_NEW | D_MP | D_HOTPLUG,     /* cb_flag */
 443         CB_REV,         /* cb_rev */
 444         nodev,          /* async I/O read entry point */
 445         nodev           /* async I/O write entry point */
 446 };
 447 
 448 static struct dev_ops aac_dev_ops = {
 449         DEVO_REV,
 450         0,
 451         aac_getinfo,
 452         nulldev,
 453         nulldev,
 454         aac_attach,
 455         aac_detach,
 456         aac_reset,
 457         &aac_cb_ops,
 458         NULL,
 459         NULL,
 460         aac_quiesce,
 461 };
 462 
 463 static struct modldrv aac_modldrv = {
 464         &mod_driverops,
 465         "AAC Driver " AAC_DRIVER_VERSION,
 466         &aac_dev_ops,
 467 };
 468 
 469 static struct modlinkage aac_modlinkage = {
 470         MODREV_1,
 471         &aac_modldrv,
 472         NULL
 473 };
 474 
 475 static struct aac_softstate  *aac_softstatep;
 476 
 477 /*
 478  * Supported card list
 479  * ordered in vendor id, subvendor id, subdevice id, and device id
 480  */
 481 static struct aac_card_type aac_cards[] = {
 482         {0x1028, 0x1, 0x1028, 0x1, AAC_HWIF_I960RX,
 483             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG, AAC_TYPE_SCSI,
 484             "Dell", "PERC 3/Di"},
 485         {0x1028, 0x2, 0x1028, 0x2, AAC_HWIF_I960RX,
 486             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG, AAC_TYPE_SCSI,
 487             "Dell", "PERC 3/Di"},
 488         {0x1028, 0x3, 0x1028, 0x3, AAC_HWIF_I960RX,
 489             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG, AAC_TYPE_SCSI,
 490             "Dell", "PERC 3/Si"},
 491         {0x1028, 0x8, 0x1028, 0xcf, AAC_HWIF_I960RX,
 492             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG, AAC_TYPE_SCSI,
 493             "Dell", "PERC 3/Di"},
 494         {0x1028, 0x4, 0x1028, 0xd0, AAC_HWIF_I960RX,
 495             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG, AAC_TYPE_SCSI,
 496             "Dell", "PERC 3/Si"},
 497         {0x1028, 0x2, 0x1028, 0xd1, AAC_HWIF_I960RX,
 498             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG, AAC_TYPE_SCSI,
 499             "Dell", "PERC 3/Di"},
 500         {0x1028, 0x2, 0x1028, 0xd9, AAC_HWIF_I960RX,
 501             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG, AAC_TYPE_SCSI,
 502             "Dell", "PERC 3/Di"},
 503         {0x1028, 0xa, 0x1028, 0x106, AAC_HWIF_I960RX,
 504             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG, AAC_TYPE_SCSI,
 505             "Dell", "PERC 3/Di"},
 506         {0x1028, 0xa, 0x1028, 0x11b, AAC_HWIF_I960RX,
 507             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG, AAC_TYPE_SCSI,
 508             "Dell", "PERC 3/Di"},
 509         {0x1028, 0xa, 0x1028, 0x121, AAC_HWIF_I960RX,
 510             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG, AAC_TYPE_SCSI,
 511             "Dell", "PERC 3/Di"},
 512         {0x9005, 0x285, 0x1028, 0x287, AAC_HWIF_I960RX,
 513             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG | AAC_FLAGS_256FIBS, AAC_TYPE_SCSI,
 514             "Dell", "PERC 320/DC"},
 515         {0x9005, 0x285, 0x1028, 0x291, AAC_HWIF_I960RX,
 516             AAC_FLAGS_17SG, AAC_TYPE_SATA, "Dell", "CERC SR2"},
 517 
 518         {0x9005, 0x285, 0x1014, 0x2f2, AAC_HWIF_I960RX,
 519             0, AAC_TYPE_SCSI, "IBM", "ServeRAID 8i"},
 520         {0x9005, 0x285, 0x1014, 0x34d, AAC_HWIF_I960RX,
 521             0, AAC_TYPE_SAS, "IBM", "ServeRAID 8s"},
 522         {0x9005, 0x286, 0x1014, 0x9580, AAC_HWIF_RKT,
 523             0, AAC_TYPE_SAS, "IBM", "ServeRAID 8k"},
 524 
 525         {0x9005, 0x285, 0x103c, 0x3227, AAC_HWIF_I960RX,
 526             AAC_FLAGS_17SG, AAC_TYPE_SATA, "Adaptec", "2610SA"},
 527         {0x9005, 0x285, 0xe11, 0x295, AAC_HWIF_I960RX,
 528             AAC_FLAGS_17SG, AAC_TYPE_SATA, "Adaptec", "2610SA"},
 529 
 530         {0x9005, 0x285, 0x9005, 0x285, AAC_HWIF_I960RX,
 531             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG | AAC_FLAGS_256FIBS, AAC_TYPE_SCSI,
 532             "Adaptec", "2200S"},
 533         {0x9005, 0x285, 0x9005, 0x286, AAC_HWIF_I960RX,
 534             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG | AAC_FLAGS_256FIBS, AAC_TYPE_SCSI,
 535             "Adaptec", "2120S"},
 536         {0x9005, 0x285, 0x9005, 0x287, AAC_HWIF_I960RX,
 537             AAC_FLAGS_NO4GB | AAC_FLAGS_34SG | AAC_FLAGS_256FIBS, AAC_TYPE_SCSI,
 538             "Adaptec", "2200S"},
 539         {0x9005, 0x285, 0x9005, 0x288, AAC_HWIF_I960RX,
 540             0, AAC_TYPE_SCSI, "Adaptec", "3230S"},
 541         {0x9005, 0x285, 0x9005, 0x289, AAC_HWIF_I960RX,
 542             0, AAC_TYPE_SCSI, "Adaptec", "3240S"},
 543         {0x9005, 0x285, 0x9005, 0x28a, AAC_HWIF_I960RX,
 544             0, AAC_TYPE_SCSI, "Adaptec", "2020ZCR"},
 545         {0x9005, 0x285, 0x9005, 0x28b, AAC_HWIF_I960RX,
 546             0, AAC_TYPE_SCSI, "Adaptec", "2025ZCR"},
 547         {0x9005, 0x286, 0x9005, 0x28c, AAC_HWIF_RKT,
 548             0, AAC_TYPE_SCSI, "Adaptec", "2230S"},
 549         {0x9005, 0x286, 0x9005, 0x28d, AAC_HWIF_RKT,
 550             0, AAC_TYPE_SCSI, "Adaptec", "2130S"},
 551         {0x9005, 0x285, 0x9005, 0x28e, AAC_HWIF_I960RX,
 552             0, AAC_TYPE_SATA, "Adaptec", "2020SA"},
 553         {0x9005, 0x285, 0x9005, 0x28f, AAC_HWIF_I960RX,
 554             0, AAC_TYPE_SATA, "Adaptec", "2025SA"},
 555         {0x9005, 0x285, 0x9005, 0x290, AAC_HWIF_I960RX,
 556             AAC_FLAGS_17SG, AAC_TYPE_SATA, "Adaptec", "2410SA"},
 557         {0x9005, 0x285, 0x9005, 0x292, AAC_HWIF_I960RX,
 558             AAC_FLAGS_17SG, AAC_TYPE_SATA, "Adaptec", "2810SA"},
 559         {0x9005, 0x285, 0x9005, 0x293, AAC_HWIF_I960RX,
 560             AAC_FLAGS_17SG, AAC_TYPE_SATA, "Adaptec", "21610SA"},
 561         {0x9005, 0x285, 0x9005, 0x294, AAC_HWIF_I960RX,
 562             0, AAC_TYPE_SATA, "Adaptec", "2026ZCR"},
 563         {0x9005, 0x285, 0x9005, 0x296, AAC_HWIF_I960RX,
 564             0, AAC_TYPE_SCSI, "Adaptec", "2240S"},
 565         {0x9005, 0x285, 0x9005, 0x297, AAC_HWIF_I960RX,
 566             0, AAC_TYPE_SAS, "Adaptec", "4005SAS"},
 567         {0x9005, 0x285, 0x9005, 0x298, AAC_HWIF_I960RX,
 568             0, AAC_TYPE_SAS, "Adaptec", "RAID 4000"},
 569         {0x9005, 0x285, 0x9005, 0x299, AAC_HWIF_I960RX,
 570             0, AAC_TYPE_SAS, "Adaptec", "4800SAS"},
 571         {0x9005, 0x285, 0x9005, 0x29a, AAC_HWIF_I960RX,
 572             0, AAC_TYPE_SAS, "Adaptec", "4805SAS"},
 573         {0x9005, 0x286, 0x9005, 0x29b, AAC_HWIF_RKT,
 574             0, AAC_TYPE_SATA, "Adaptec", "2820SA"},
 575         {0x9005, 0x286, 0x9005, 0x29c, AAC_HWIF_RKT,
 576             0, AAC_TYPE_SATA, "Adaptec", "2620SA"},
 577         {0x9005, 0x286, 0x9005, 0x29d, AAC_HWIF_RKT,
 578             0, AAC_TYPE_SATA, "Adaptec", "2420SA"},
 579         {0x9005, 0x286, 0x9005, 0x29e, AAC_HWIF_RKT,
 580             0, AAC_TYPE_SATA, "ICP", "9024RO"},
 581         {0x9005, 0x286, 0x9005, 0x29f, AAC_HWIF_RKT,
 582             0, AAC_TYPE_SATA, "ICP", "9014RO"},
 583         {0x9005, 0x286, 0x9005, 0x2a0, AAC_HWIF_RKT,
 584             0, AAC_TYPE_SATA, "ICP", "9047MA"},
 585         {0x9005, 0x286, 0x9005, 0x2a1, AAC_HWIF_RKT,
 586             0, AAC_TYPE_SATA, "ICP", "9087MA"},
 587         {0x9005, 0x285, 0x9005, 0x2a4, AAC_HWIF_I960RX,
 588             0, AAC_TYPE_SAS, "ICP", "9085LI"},
 589         {0x9005, 0x285, 0x9005, 0x2a5, AAC_HWIF_I960RX,
 590             0, AAC_TYPE_SAS, "ICP", "5085BR"},
 591         {0x9005, 0x286, 0x9005, 0x2a6, AAC_HWIF_RKT,
 592             0, AAC_TYPE_SATA, "ICP", "9067MA"},
 593         {0x9005, 0x285, 0x9005, 0x2b5, AAC_HWIF_I960RX,
 594             0, AAC_TYPE_SAS, "Adaptec", "RAID 5445"},
 595         {0x9005, 0x285, 0x9005, 0x2b6, AAC_HWIF_I960RX,
 596             0, AAC_TYPE_SAS, "Adaptec", "RAID 5805"},
 597         {0x9005, 0x285, 0x9005, 0x2b7, AAC_HWIF_I960RX,
 598             0, AAC_TYPE_SAS, "Adaptec", "RAID 5085"},
 599         {0x9005, 0x285, 0x9005, 0x2b8, AAC_HWIF_I960RX,
 600             0, AAC_TYPE_SAS, "ICP", "RAID ICP5445SL"},
 601         {0x9005, 0x285, 0x9005, 0x2b9, AAC_HWIF_I960RX,
 602             0, AAC_TYPE_SAS, "ICP", "RAID ICP5085SL"},
 603         {0x9005, 0x285, 0x9005, 0x2ba, AAC_HWIF_I960RX,
 604             0, AAC_TYPE_SAS, "ICP", "RAID ICP5805SL"},
 605 
 606         {0, 0, 0, 0, AAC_HWIF_UNKNOWN,
 607             0, AAC_TYPE_UNKNOWN, "Unknown", "AAC card"},
 608 };
 609 
 610 /*
 611  * Hardware access functions for i960 based cards
 612  */
 613 static struct aac_interface aac_rx_interface = {
 614         aac_rx_get_fwstatus,
 615         aac_rx_get_mailbox,
 616         aac_rx_set_mailbox
 617 };
 618 
 619 /*
 620  * Hardware access functions for Rocket based cards
 621  */
 622 static struct aac_interface aac_rkt_interface = {
 623         aac_rkt_get_fwstatus,
 624         aac_rkt_get_mailbox,
 625         aac_rkt_set_mailbox
 626 };
 627 
 628 ddi_device_acc_attr_t aac_acc_attr = {
 629         DDI_DEVICE_ATTR_V1,
 630         DDI_STRUCTURE_LE_ACC,
 631         DDI_STRICTORDER_ACC,
 632         DDI_DEFAULT_ACC
 633 };
 634 
 635 static struct {
 636         int     size;
 637         int     notify;
 638 } aac_qinfo[] = {
 639         {AAC_HOST_NORM_CMD_ENTRIES, AAC_DB_COMMAND_NOT_FULL},
 640         {AAC_HOST_HIGH_CMD_ENTRIES, 0},
 641         {AAC_ADAP_NORM_CMD_ENTRIES, AAC_DB_COMMAND_READY},
 642         {AAC_ADAP_HIGH_CMD_ENTRIES, 0},
 643         {AAC_HOST_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_NOT_FULL},
 644         {AAC_HOST_HIGH_RESP_ENTRIES, 0},
 645         {AAC_ADAP_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_READY},
 646         {AAC_ADAP_HIGH_RESP_ENTRIES, 0}
 647 };
 648 
 649 /*
 650  * Default aac dma attributes
 651  */
 652 static ddi_dma_attr_t aac_dma_attr = {
 653         DMA_ATTR_V0,
 654         0,              /* lowest usable address */
 655         0xffffffffull,  /* high DMA address range */
 656         0xffffffffull,  /* DMA counter register */
 657         AAC_DMA_ALIGN,  /* DMA address alignment */
 658         1,              /* DMA burstsizes */
 659         1,              /* min effective DMA size */
 660         0xffffffffull,  /* max DMA xfer size */
 661         0xffffffffull,  /* segment boundary */
 662         1,              /* s/g list length */
 663         AAC_BLK_SIZE,   /* granularity of device */
 664         0               /* DMA transfer flags */
 665 };
 666 
 667 static int aac_tick = AAC_DEFAULT_TICK; /* tick for the internal timer */
 668 static uint32_t aac_timebase = 0;       /* internal timer in seconds */
 669 
 670 /*
 671  * Warlock directives
 672  *
 673  * Different variables with the same types have to be protected by the
 674  * same mutex; otherwise, warlock will complain with "variables don't
 675  * seem to be protected consistently". For example,
 676  * aac_softstate::{q_wait, q_comp} are type of aac_cmd_queue, and protected
 677  * by aac_softstate::{io_lock, q_comp_mutex} respectively. We have to
 678  * declare them as protected explictly at aac_cmd_dequeue().
 679  */
 680 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", scsi_pkt scsi_cdb scsi_status \
 681     scsi_arq_status scsi_descr_sense_hdr scsi_information_sense_descr \
 682     mode_format mode_geometry mode_header aac_cmd))
 683 _NOTE(SCHEME_PROTECTS_DATA("unique per aac_cmd", aac_fib ddi_dma_cookie_t \
 684     aac_sge))
 685 _NOTE(SCHEME_PROTECTS_DATA("unique per aac_fib", aac_blockread aac_blockwrite \
 686     aac_blockread64 aac_raw_io aac_sg_entry aac_sg_entry64 aac_sg_entryraw \
 687     aac_sg_table aac_srb))
 688 _NOTE(SCHEME_PROTECTS_DATA("unique to sync fib and cdb", scsi_inquiry))
 689 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_device scsi_address))
 690 _NOTE(SCHEME_PROTECTS_DATA("unique to scsi_transport", buf))
 691 
 692 int
 693 _init(void)
 694 {
 695         int rval = 0;
 696 
 697 #ifdef DEBUG
 698         mutex_init(&aac_prt_mutex, NULL, MUTEX_DRIVER, NULL);
 699 #endif
 700         DBCALLED(NULL, 1);
 701 
 702         if ((rval = ddi_soft_state_init((void *)&aac_softstatep,
 703             sizeof (struct aac_softstate), 0)) != 0)
 704                 goto error;
 705 
 706         if ((rval = scsi_hba_init(&aac_modlinkage)) != 0) {
 707                 ddi_soft_state_fini((void *)&aac_softstatep);
 708                 goto error;
 709         }
 710 
 711         if ((rval = mod_install(&aac_modlinkage)) != 0) {
 712                 ddi_soft_state_fini((void *)&aac_softstatep);
 713                 scsi_hba_fini(&aac_modlinkage);
 714                 goto error;
 715         }
 716         return (rval);
 717 
 718 error:
 719         AACDB_PRINT(NULL, CE_WARN, "Mod init error!");
 720 #ifdef DEBUG
 721         mutex_destroy(&aac_prt_mutex);
 722 #endif
 723         return (rval);
 724 }
 725 
 726 int
 727 _info(struct modinfo *modinfop)
 728 {
 729         DBCALLED(NULL, 1);
 730         return (mod_info(&aac_modlinkage, modinfop));
 731 }
 732 
 733 /*
 734  * An HBA driver cannot be unload unless you reboot,
 735  * so this function will be of no use.
 736  */
 737 int
 738 _fini(void)
 739 {
 740         int rval;
 741 
 742         DBCALLED(NULL, 1);
 743 
 744         if ((rval = mod_remove(&aac_modlinkage)) != 0)
 745                 goto error;
 746 
 747         scsi_hba_fini(&aac_modlinkage);
 748         ddi_soft_state_fini((void *)&aac_softstatep);
 749 #ifdef DEBUG
 750         mutex_destroy(&aac_prt_mutex);
 751 #endif
 752         return (0);
 753 
 754 error:
 755         AACDB_PRINT(NULL, CE_WARN, "AAC is busy, cannot unload!");
 756         return (rval);
 757 }
 758 
 759 static int
 760 aac_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 761 {
 762         int instance, i;
 763         struct aac_softstate *softs = NULL;
 764         int attach_state = 0;
 765         char *data;
 766 
 767         DBCALLED(NULL, 1);
 768 
 769         switch (cmd) {
 770         case DDI_ATTACH:
 771                 break;
 772         case DDI_RESUME:
 773                 return (DDI_FAILURE);
 774         default:
 775                 return (DDI_FAILURE);
 776         }
 777 
 778         instance = ddi_get_instance(dip);
 779 
 780         /* Get soft state */
 781         if (ddi_soft_state_zalloc(aac_softstatep, instance) != DDI_SUCCESS) {
 782                 AACDB_PRINT(softs, CE_WARN, "Cannot alloc soft state");
 783                 goto error;
 784         }
 785         softs = ddi_get_soft_state(aac_softstatep, instance);
 786         attach_state |= AAC_ATTACH_SOFTSTATE_ALLOCED;
 787 
 788         softs->instance = instance;
 789         softs->devinfo_p = dip;
 790         softs->buf_dma_attr = softs->addr_dma_attr = aac_dma_attr;
 791         softs->addr_dma_attr.dma_attr_granular = 1;
 792         softs->acc_attr = aac_acc_attr;
 793         softs->reg_attr = aac_acc_attr;
 794         softs->card = AAC_UNKNOWN_CARD;
 795 #ifdef DEBUG
 796         softs->debug_flags = aac_debug_flags;
 797         softs->debug_fib_flags = aac_debug_fib_flags;
 798 #endif
 799 
 800         /* Initialize FMA */
 801         aac_fm_init(softs);
 802 
 803         /* Check the card type */
 804         if (aac_check_card_type(softs) == AACERR) {
 805                 AACDB_PRINT(softs, CE_WARN, "Card not supported");
 806                 goto error;
 807         }
 808         /* We have found the right card and everything is OK */
 809         attach_state |= AAC_ATTACH_CARD_DETECTED;
 810 
 811         /* Map PCI mem space */
 812         if (ddi_regs_map_setup(dip, 1,
 813             (caddr_t *)&softs->pci_mem_base_vaddr, 0,
 814             softs->map_size_min, &softs->reg_attr,
 815             &softs->pci_mem_handle) != DDI_SUCCESS)
 816                 goto error;
 817 
 818         softs->map_size = softs->map_size_min;
 819         attach_state |= AAC_ATTACH_PCI_MEM_MAPPED;
 820 
 821         AAC_DISABLE_INTR(softs);
 822 
 823         /* Init mutexes and condvars */
 824         mutex_init(&softs->io_lock, NULL, MUTEX_DRIVER,
 825             DDI_INTR_PRI(softs->intr_pri));
 826         mutex_init(&softs->q_comp_mutex, NULL, MUTEX_DRIVER,
 827             DDI_INTR_PRI(softs->intr_pri));
 828         mutex_init(&softs->time_mutex, NULL, MUTEX_DRIVER,
 829             DDI_INTR_PRI(softs->intr_pri));
 830         mutex_init(&softs->ev_lock, NULL, MUTEX_DRIVER,
 831             DDI_INTR_PRI(softs->intr_pri));
 832         mutex_init(&softs->aifq_mutex, NULL,
 833             MUTEX_DRIVER, DDI_INTR_PRI(softs->intr_pri));
 834         cv_init(&softs->event, NULL, CV_DRIVER, NULL);
 835         cv_init(&softs->sync_fib_cv, NULL, CV_DRIVER, NULL);
 836         cv_init(&softs->drain_cv, NULL, CV_DRIVER, NULL);
 837         cv_init(&softs->event_wait_cv, NULL, CV_DRIVER, NULL);
 838         cv_init(&softs->event_disp_cv, NULL, CV_DRIVER, NULL);
 839         cv_init(&softs->aifq_cv, NULL, CV_DRIVER, NULL);
 840         attach_state |= AAC_ATTACH_KMUTEX_INITED;
 841 
 842         /* Init the cmd queues */
 843         for (i = 0; i < AAC_CMDQ_NUM; i++)
 844                 aac_cmd_initq(&softs->q_wait[i]);
 845         aac_cmd_initq(&softs->q_busy);
 846         aac_cmd_initq(&softs->q_comp);
 847 
 848         /* Check for legacy device naming support */
 849         softs->legacy = 1; /* default to use legacy name */
 850         if ((ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
 851             "legacy-name-enable", &data) == DDI_SUCCESS)) {
 852                 if (strcmp(data, "no") == 0) {
 853                         AACDB_PRINT(softs, CE_NOTE, "legacy-name disabled");
 854                         softs->legacy = 0;
 855                 }
 856                 ddi_prop_free(data);
 857         }
 858 
 859         /*
 860          * Everything has been set up till now,
 861          * we will do some common attach.
 862          */
 863         mutex_enter(&softs->io_lock);
 864         if (aac_common_attach(softs) == AACERR) {
 865                 mutex_exit(&softs->io_lock);
 866                 goto error;
 867         }
 868         mutex_exit(&softs->io_lock);
 869         attach_state |= AAC_ATTACH_COMM_SPACE_SETUP;
 870 
 871         /* Check for buf breakup support */
 872         if ((ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
 873             "breakup-enable", &data) == DDI_SUCCESS)) {
 874                 if (strcmp(data, "yes") == 0) {
 875                         AACDB_PRINT(softs, CE_NOTE, "buf breakup enabled");
 876                         softs->flags |= AAC_FLAGS_BRKUP;
 877                 }
 878                 ddi_prop_free(data);
 879         }
 880         softs->dma_max = softs->buf_dma_attr.dma_attr_maxxfer;
 881         if (softs->flags & AAC_FLAGS_BRKUP) {
 882                 softs->dma_max = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
 883                     DDI_PROP_DONTPASS, "dma-max", softs->dma_max);
 884         }
 885 
 886         if (aac_hba_setup(softs) != AACOK)
 887                 goto error;
 888         attach_state |= AAC_ATTACH_SCSI_TRAN_SETUP;
 889 
 890         /* Create devctl/scsi nodes for cfgadm */
 891         if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
 892             INST2DEVCTL(instance), DDI_NT_SCSI_NEXUS, 0) != DDI_SUCCESS) {
 893                 AACDB_PRINT(softs, CE_WARN, "failed to create devctl node");
 894                 goto error;
 895         }
 896         attach_state |= AAC_ATTACH_CREATE_DEVCTL;
 897 
 898         if (ddi_create_minor_node(dip, "scsi", S_IFCHR, INST2SCSI(instance),
 899             DDI_NT_SCSI_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
 900                 AACDB_PRINT(softs, CE_WARN, "failed to create scsi node");
 901                 goto error;
 902         }
 903         attach_state |= AAC_ATTACH_CREATE_SCSI;
 904 
 905         /* Create aac node for app. to issue ioctls */
 906         if (ddi_create_minor_node(dip, "aac", S_IFCHR, INST2AAC(instance),
 907             DDI_PSEUDO, 0) != DDI_SUCCESS) {
 908                 AACDB_PRINT(softs, CE_WARN, "failed to create aac node");
 909                 goto error;
 910         }
 911 
 912         /* Common attach is OK, so we are attached! */
 913         softs->state |= AAC_STATE_RUN;
 914 
 915         /* Create event thread */
 916         softs->fibctx_p = &softs->aifctx;
 917         if ((softs->event_thread = thread_create(NULL, 0, aac_event_thread,
 918             softs, 0, &p0, TS_RUN, minclsyspri)) == NULL) {
 919                 AACDB_PRINT(softs, CE_WARN, "aif thread create failed");
 920                 softs->state &= ~AAC_STATE_RUN;
 921                 goto error;
 922         }
 923 
 924         aac_unhold_bus(softs, AAC_IOCMD_SYNC | AAC_IOCMD_ASYNC);
 925 
 926         /* Create a thread for command timeout */
 927         softs->timeout_id = timeout(aac_timer, (void *)softs,
 928             (aac_tick * drv_usectohz(1000000)));
 929 
 930         /* Common attach is OK, so we are attached! */
 931         ddi_report_dev(dip);
 932         AACDB_PRINT(softs, CE_NOTE, "aac attached ok");
 933         return (DDI_SUCCESS);
 934 
 935 error:
 936         if (attach_state & AAC_ATTACH_CREATE_SCSI)
 937                 ddi_remove_minor_node(dip, "scsi");
 938         if (attach_state & AAC_ATTACH_CREATE_DEVCTL)
 939                 ddi_remove_minor_node(dip, "devctl");
 940         if (attach_state & AAC_ATTACH_COMM_SPACE_SETUP)
 941                 aac_common_detach(softs);
 942         if (attach_state & AAC_ATTACH_SCSI_TRAN_SETUP) {
 943                 (void) scsi_hba_detach(dip);
 944                 scsi_hba_tran_free(AAC_DIP2TRAN(dip));
 945         }
 946         if (attach_state & AAC_ATTACH_KMUTEX_INITED) {
 947                 mutex_destroy(&softs->io_lock);
 948                 mutex_destroy(&softs->q_comp_mutex);
 949                 mutex_destroy(&softs->time_mutex);
 950                 mutex_destroy(&softs->ev_lock);
 951                 mutex_destroy(&softs->aifq_mutex);
 952                 cv_destroy(&softs->event);
 953                 cv_destroy(&softs->sync_fib_cv);
 954                 cv_destroy(&softs->drain_cv);
 955                 cv_destroy(&softs->event_wait_cv);
 956                 cv_destroy(&softs->event_disp_cv);
 957                 cv_destroy(&softs->aifq_cv);
 958         }
 959         if (attach_state & AAC_ATTACH_PCI_MEM_MAPPED)
 960                 ddi_regs_map_free(&softs->pci_mem_handle);
 961         aac_fm_fini(softs);
 962         if (attach_state & AAC_ATTACH_CARD_DETECTED)
 963                 softs->card = AACERR;
 964         if (attach_state & AAC_ATTACH_SOFTSTATE_ALLOCED)
 965                 ddi_soft_state_free(aac_softstatep, instance);
 966         return (DDI_FAILURE);
 967 }
 968 
 969 static int
 970 aac_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 971 {
 972         scsi_hba_tran_t *tran = AAC_DIP2TRAN(dip);
 973         struct aac_softstate *softs = AAC_TRAN2SOFTS(tran);
 974 
 975         DBCALLED(softs, 1);
 976 
 977         switch (cmd) {
 978         case DDI_DETACH:
 979                 break;
 980         case DDI_SUSPEND:
 981                 return (DDI_FAILURE);
 982         default:
 983                 return (DDI_FAILURE);
 984         }
 985 
 986         mutex_enter(&softs->io_lock);
 987         AAC_DISABLE_INTR(softs);
 988         softs->state = AAC_STATE_STOPPED;
 989 
 990         ddi_remove_minor_node(dip, "aac");
 991         ddi_remove_minor_node(dip, "scsi");
 992         ddi_remove_minor_node(dip, "devctl");
 993         mutex_exit(&softs->io_lock);
 994 
 995         aac_common_detach(softs);
 996 
 997         mutex_enter(&softs->io_lock);
 998         (void) scsi_hba_detach(dip);
 999         scsi_hba_tran_free(tran);
1000         mutex_exit(&softs->io_lock);
1001 
1002         /* Stop timer */
1003         mutex_enter(&softs->time_mutex);
1004         if (softs->timeout_id) {
1005                 timeout_id_t tid = softs->timeout_id;
1006                 softs->timeout_id = 0;
1007 
1008                 mutex_exit(&softs->time_mutex);
1009                 (void) untimeout(tid);
1010                 mutex_enter(&softs->time_mutex);
1011         }
1012         mutex_exit(&softs->time_mutex);
1013 
1014         /* Destroy event thread */
1015         mutex_enter(&softs->ev_lock);
1016         cv_signal(&softs->event_disp_cv);
1017         cv_wait(&softs->event_wait_cv, &softs->ev_lock);
1018         mutex_exit(&softs->ev_lock);
1019 
1020         cv_destroy(&softs->aifq_cv);
1021         cv_destroy(&softs->event_disp_cv);
1022         cv_destroy(&softs->event_wait_cv);
1023         cv_destroy(&softs->drain_cv);
1024         cv_destroy(&softs->sync_fib_cv);
1025         cv_destroy(&softs->event);
1026         mutex_destroy(&softs->aifq_mutex);
1027         mutex_destroy(&softs->ev_lock);
1028         mutex_destroy(&softs->time_mutex);
1029         mutex_destroy(&softs->q_comp_mutex);
1030         mutex_destroy(&softs->io_lock);
1031 
1032         ddi_regs_map_free(&softs->pci_mem_handle);
1033         aac_fm_fini(softs);
1034         softs->hwif = AAC_HWIF_UNKNOWN;
1035         softs->card = AAC_UNKNOWN_CARD;
1036         ddi_soft_state_free(aac_softstatep, ddi_get_instance(dip));
1037 
1038         return (DDI_SUCCESS);
1039 }
1040 
1041 /*ARGSUSED*/
1042 static int
1043 aac_reset(dev_info_t *dip, ddi_reset_cmd_t cmd)
1044 {
1045         struct aac_softstate *softs = AAC_DIP2SOFTS(dip);
1046 
1047         DBCALLED(softs, 1);
1048 
1049         mutex_enter(&softs->io_lock);
1050         AAC_DISABLE_INTR(softs);
1051         (void) aac_shutdown(softs);
1052         mutex_exit(&softs->io_lock);
1053 
1054         return (DDI_SUCCESS);
1055 }
1056 
1057 /*
1058  * quiesce(9E) entry point.
1059  *
1060  * This function is called when the system is single-threaded at high
1061  * PIL with preemption disabled. Therefore, this function must not be
1062  * blocked.
1063  *
1064  * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
1065  * DDI_FAILURE indicates an error condition and should almost never happen.
1066  */
1067 static int
1068 aac_quiesce(dev_info_t *dip)
1069 {
1070         struct aac_softstate *softs = AAC_DIP2SOFTS(dip);
1071 
1072         if (softs == NULL)
1073                 return (DDI_FAILURE);
1074 
1075         _NOTE(ASSUMING_PROTECTED(softs->state))
1076         AAC_DISABLE_INTR(softs);
1077 
1078         return (DDI_SUCCESS);
1079 }
1080 
1081 /* ARGSUSED */
1082 static int
1083 aac_getinfo(dev_info_t *self, ddi_info_cmd_t infocmd, void *arg,
1084     void **result)
1085 {
1086         int error = DDI_SUCCESS;
1087 
1088         switch (infocmd) {
1089         case DDI_INFO_DEVT2INSTANCE:
1090                 *result = (void *)(intptr_t)(MINOR2INST(getminor((dev_t)arg)));
1091                 break;
1092         default:
1093                 error = DDI_FAILURE;
1094         }
1095         return (error);
1096 }
1097 
1098 /*
1099  * Bring the controller down to a dormant state and detach all child devices.
1100  * This function is called before detach or system shutdown.
1101  * Note: we can assume that the q_wait on the controller is empty, as we
1102  * won't allow shutdown if any device is open.
1103  */
1104 static int
1105 aac_shutdown(struct aac_softstate *softs)
1106 {
1107         ddi_acc_handle_t acc;
1108         struct aac_close_command *cc;
1109         int rval;
1110 
1111         (void) aac_sync_fib_slot_bind(softs, &softs->sync_ac);
1112         acc = softs->sync_ac.slotp->fib_acc_handle;
1113 
1114         cc = (struct aac_close_command *)&softs->sync_ac.slotp->fibp->data[0];
1115 
1116         ddi_put32(acc, &cc->Command, VM_CloseAll);
1117         ddi_put32(acc, &cc->ContainerId, 0xfffffffful);
1118 
1119         /* Flush all caches, set FW to write through mode */
1120         rval = aac_sync_fib(softs, ContainerCommand,
1121             AAC_FIB_SIZEOF(struct aac_close_command));
1122         aac_sync_fib_slot_release(softs, &softs->sync_ac);
1123 
1124         AACDB_PRINT(softs, CE_NOTE,
1125             "shutting down aac %s", (rval == AACOK) ? "ok" : "fail");
1126         return (rval);
1127 }
1128 
1129 static uint_t
1130 aac_softintr(caddr_t arg)
1131 {
1132         struct aac_softstate *softs = (void *)arg;
1133 
1134         if (!AAC_IS_Q_EMPTY(&softs->q_comp)) {
1135                 aac_drain_comp_q(softs);
1136         }
1137         return (DDI_INTR_CLAIMED);
1138 }
1139 
1140 /*
1141  * Setup auto sense data for pkt
1142  */
1143 static void
1144 aac_set_arq_data(struct scsi_pkt *pkt, uchar_t key,
1145     uchar_t add_code, uchar_t qual_code, uint64_t info)
1146 {
1147         struct scsi_arq_status *arqstat = (void *)(pkt->pkt_scbp);
1148 
1149         *pkt->pkt_scbp = STATUS_CHECK; /* CHECK CONDITION */
1150         pkt->pkt_state |= STATE_ARQ_DONE;
1151 
1152         *(uint8_t *)&arqstat->sts_rqpkt_status = STATUS_GOOD;
1153         arqstat->sts_rqpkt_reason = CMD_CMPLT;
1154         arqstat->sts_rqpkt_resid = 0;
1155         arqstat->sts_rqpkt_state =
1156             STATE_GOT_BUS |
1157             STATE_GOT_TARGET |
1158             STATE_SENT_CMD |
1159             STATE_XFERRED_DATA;
1160         arqstat->sts_rqpkt_statistics = 0;
1161 
1162         if (info <= 0xfffffffful) {
1163                 arqstat->sts_sensedata.es_valid = 1;
1164                 arqstat->sts_sensedata.es_class = CLASS_EXTENDED_SENSE;
1165                 arqstat->sts_sensedata.es_code = CODE_FMT_FIXED_CURRENT;
1166                 arqstat->sts_sensedata.es_key = key;
1167                 arqstat->sts_sensedata.es_add_code = add_code;
1168                 arqstat->sts_sensedata.es_qual_code = qual_code;
1169 
1170                 arqstat->sts_sensedata.es_info_1 = (info >> 24) & 0xFF;
1171                 arqstat->sts_sensedata.es_info_2 = (info >> 16) & 0xFF;
1172                 arqstat->sts_sensedata.es_info_3 = (info >>  8) & 0xFF;
1173                 arqstat->sts_sensedata.es_info_4 = info & 0xFF;
1174         } else { /* 64-bit LBA */
1175                 struct scsi_descr_sense_hdr *dsp;
1176                 struct scsi_information_sense_descr *isd;
1177 
1178                 dsp = (struct scsi_descr_sense_hdr *)&arqstat->sts_sensedata;
1179                 dsp->ds_class = CLASS_EXTENDED_SENSE;
1180                 dsp->ds_code = CODE_FMT_DESCR_CURRENT;
1181                 dsp->ds_key = key;
1182                 dsp->ds_add_code = add_code;
1183                 dsp->ds_qual_code = qual_code;
1184                 dsp->ds_addl_sense_length =
1185                     sizeof (struct scsi_information_sense_descr);
1186 
1187                 isd = (struct scsi_information_sense_descr *)(dsp+1);
1188                 isd->isd_descr_type = DESCR_INFORMATION;
1189                 isd->isd_valid = 1;
1190                 isd->isd_information[0] = (info >> 56) & 0xFF;
1191                 isd->isd_information[1] = (info >> 48) & 0xFF;
1192                 isd->isd_information[2] = (info >> 40) & 0xFF;
1193                 isd->isd_information[3] = (info >> 32) & 0xFF;
1194                 isd->isd_information[4] = (info >> 24) & 0xFF;
1195                 isd->isd_information[5] = (info >> 16) & 0xFF;
1196                 isd->isd_information[6] = (info >>  8) & 0xFF;
1197                 isd->isd_information[7] = (info) & 0xFF;
1198         }
1199 }
1200 
1201 /*
1202  * Setup auto sense data for HARDWARE ERROR
1203  */
1204 static void
1205 aac_set_arq_data_hwerr(struct aac_cmd *acp)
1206 {
1207         union scsi_cdb *cdbp;
1208         uint64_t err_blkno;
1209 
1210         cdbp = (void *)acp->pkt->pkt_cdbp;
1211         err_blkno = AAC_GETGXADDR(acp->cmdlen, cdbp);
1212         aac_set_arq_data(acp->pkt, KEY_HARDWARE_ERROR, 0x00, 0x00, err_blkno);
1213 }
1214 
1215 /*
1216  * Send a command to the adapter in New Comm. interface
1217  */
1218 static int
1219 aac_send_command(struct aac_softstate *softs, struct aac_slot *slotp)
1220 {
1221         uint32_t index, device;
1222 
1223         index = PCI_MEM_GET32(softs, AAC_IQUE);
1224         if (index == 0xffffffffUL) {
1225                 index = PCI_MEM_GET32(softs, AAC_IQUE);
1226                 if (index == 0xffffffffUL)
1227                         return (AACERR);
1228         }
1229 
1230         device = index;
1231         PCI_MEM_PUT32(softs, device,
1232             (uint32_t)(slotp->fib_phyaddr & 0xfffffffful));
1233         device += 4;
1234         PCI_MEM_PUT32(softs, device, (uint32_t)(slotp->fib_phyaddr >> 32));
1235         device += 4;
1236         PCI_MEM_PUT32(softs, device, slotp->acp->fib_size);
1237         PCI_MEM_PUT32(softs, AAC_IQUE, index);
1238         return (AACOK);
1239 }
1240 
1241 static void
1242 aac_end_io(struct aac_softstate *softs, struct aac_cmd *acp)
1243 {
1244         struct aac_device *dvp = acp->dvp;
1245         int q = AAC_CMDQ(acp);
1246 
1247         if (acp->slotp) { /* outstanding cmd */
1248                 if (!(acp->flags & AAC_CMD_IN_SYNC_SLOT)) {
1249                         aac_release_slot(softs, acp->slotp);
1250                         acp->slotp = NULL;
1251                 }
1252                 if (dvp) {
1253                         dvp->ncmds[q]--;
1254                         if (dvp->throttle[q] == AAC_THROTTLE_DRAIN &&
1255                             dvp->ncmds[q] == 0 && q == AAC_CMDQ_ASYNC)
1256                                 aac_set_throttle(softs, dvp, q,
1257                                     softs->total_slots);
1258                         /*
1259                          * Setup auto sense data for UNIT ATTENTION
1260                          * Each lun should generate a unit attention
1261                          * condition when reset.
1262                          * Phys. drives are treated as logical ones
1263                          * during error recovery.
1264                          */
1265                         if (dvp->type == AAC_DEV_LD) {
1266                                 struct aac_container *ctp =
1267                                     (struct aac_container *)dvp;
1268                                 if (ctp->reset == 0)
1269                                         goto noreset;
1270 
1271                                 AACDB_PRINT(softs, CE_NOTE,
1272                                     "Unit attention: reset");
1273                                 ctp->reset = 0;
1274                                 aac_set_arq_data(acp->pkt, KEY_UNIT_ATTENTION,
1275                                     0x29, 0x02, 0);
1276                         }
1277                 }
1278 noreset:
1279                 softs->bus_ncmds[q]--;
1280                 aac_cmd_delete(&softs->q_busy, acp);
1281         } else { /* cmd in waiting queue */
1282                 aac_cmd_delete(&softs->q_wait[q], acp);
1283         }
1284 
1285         if (!(acp->flags & (AAC_CMD_NO_CB | AAC_CMD_NO_INTR))) { /* async IO */
1286                 mutex_enter(&softs->q_comp_mutex);
1287                 aac_cmd_enqueue(&softs->q_comp, acp);
1288                 mutex_exit(&softs->q_comp_mutex);
1289         } else if (acp->flags & AAC_CMD_NO_CB) { /* sync IO */
1290                 cv_broadcast(&softs->event);
1291         }
1292 }
1293 
1294 static void
1295 aac_handle_io(struct aac_softstate *softs, int index)
1296 {
1297         struct aac_slot *slotp;
1298         struct aac_cmd *acp;
1299         uint32_t fast;
1300 
1301         fast = index & AAC_SENDERADDR_MASK_FAST_RESPONSE;
1302         index >>= 2;
1303 
1304         /* Make sure firmware reported index is valid */
1305         ASSERT(index >= 0 && index < softs->total_slots);
1306         slotp = &softs->io_slot[index];
1307         ASSERT(slotp->index == index);
1308         acp = slotp->acp;
1309 
1310         if (acp == NULL || acp->slotp != slotp) {
1311                 cmn_err(CE_WARN,
1312                     "Firmware error: invalid slot index received from FW");
1313                 return;
1314         }
1315 
1316         acp->flags |= AAC_CMD_CMPLT;
1317         (void) ddi_dma_sync(slotp->fib_dma_handle, 0, 0, DDI_DMA_SYNC_FORCPU);
1318 
1319         if (aac_check_dma_handle(slotp->fib_dma_handle) == DDI_SUCCESS) {
1320                 /*
1321                  * For fast response IO, the firmware do not return any FIB
1322                  * data, so we need to fill in the FIB status and state so that
1323                  * FIB users can handle it correctly.
1324                  */
1325                 if (fast) {
1326                         uint32_t state;
1327 
1328                         state = ddi_get32(slotp->fib_acc_handle,
1329                             &slotp->fibp->Header.XferState);
1330                         /*
1331                          * Update state for CPU not for device, no DMA sync
1332                          * needed
1333                          */
1334                         ddi_put32(slotp->fib_acc_handle,
1335                             &slotp->fibp->Header.XferState,
1336                             state | AAC_FIBSTATE_DONEADAP);
1337                         ddi_put32(slotp->fib_acc_handle,
1338                             (void *)&slotp->fibp->data[0], ST_OK);
1339                 }
1340 
1341                 /* Handle completed ac */
1342                 acp->ac_comp(softs, acp);
1343         } else {
1344                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
1345                 acp->flags |= AAC_CMD_ERR;
1346                 if (acp->pkt) {
1347                         acp->pkt->pkt_reason = CMD_TRAN_ERR;
1348                         acp->pkt->pkt_statistics = 0;
1349                 }
1350         }
1351         aac_end_io(softs, acp);
1352 }
1353 
1354 /*
1355  * Interrupt handler for New Comm. interface
1356  * New Comm. interface use a different mechanism for interrupt. No explict
1357  * message queues, and driver need only accesses the mapped PCI mem space to
1358  * find the completed FIB or AIF.
1359  */
1360 static int
1361 aac_process_intr_new(struct aac_softstate *softs)
1362 {
1363         uint32_t index;
1364 
1365         index = AAC_OUTB_GET(softs);
1366         if (index == 0xfffffffful)
1367                 index = AAC_OUTB_GET(softs);
1368         if (aac_check_acc_handle(softs->pci_mem_handle) != DDI_SUCCESS) {
1369                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
1370                 return (0);
1371         }
1372         if (index != 0xfffffffful) {
1373                 do {
1374                         if ((index & AAC_SENDERADDR_MASK_AIF) == 0) {
1375                                 aac_handle_io(softs, index);
1376                         } else if (index != 0xfffffffeul) {
1377                                 struct aac_fib *fibp;   /* FIB in AIF queue */
1378                                 uint16_t fib_size;
1379 
1380                                 /*
1381                                  * 0xfffffffe means that the controller wants
1382                                  * more work, ignore it for now. Otherwise,
1383                                  * AIF received.
1384                                  */
1385                                 index &= ~2;
1386 
1387                                 fibp = (struct aac_fib *)(softs-> \
1388                                     pci_mem_base_vaddr + index);
1389                                 fib_size = PCI_MEM_GET16(softs, index + \
1390                                     offsetof(struct aac_fib, Header.Size));
1391 
1392                                 aac_save_aif(softs, softs->pci_mem_handle,
1393                                     fibp, fib_size);
1394 
1395                                 /*
1396                                  * AIF memory is owned by the adapter, so let it
1397                                  * know that we are done with it.
1398                                  */
1399                                 AAC_OUTB_SET(softs, index);
1400                                 AAC_STATUS_CLR(softs, AAC_DB_RESPONSE_READY);
1401                         }
1402 
1403                         index = AAC_OUTB_GET(softs);
1404                 } while (index != 0xfffffffful);
1405 
1406                 /*
1407                  * Process waiting cmds before start new ones to
1408                  * ensure first IOs are serviced first.
1409                  */
1410                 aac_start_waiting_io(softs);
1411                 return (AAC_DB_COMMAND_READY);
1412         } else {
1413                 return (0);
1414         }
1415 }
1416 
1417 static uint_t
1418 aac_intr_new(caddr_t arg)
1419 {
1420         struct aac_softstate *softs = (void *)arg;
1421         uint_t rval;
1422 
1423         mutex_enter(&softs->io_lock);
1424         if (aac_process_intr_new(softs))
1425                 rval = DDI_INTR_CLAIMED;
1426         else
1427                 rval = DDI_INTR_UNCLAIMED;
1428         mutex_exit(&softs->io_lock);
1429 
1430         aac_drain_comp_q(softs);
1431         return (rval);
1432 }
1433 
1434 /*
1435  * Interrupt handler for old interface
1436  * Explicit message queues are used to send FIB to and get completed FIB from
1437  * the adapter. Driver and adapter maitain the queues in the producer/consumer
1438  * manner. The driver has to query the queues to find the completed FIB.
1439  */
1440 static int
1441 aac_process_intr_old(struct aac_softstate *softs)
1442 {
1443         uint16_t status;
1444 
1445         status = AAC_STATUS_GET(softs);
1446         if (aac_check_acc_handle(softs->pci_mem_handle) != DDI_SUCCESS) {
1447                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
1448                 return (DDI_INTR_UNCLAIMED);
1449         }
1450         if (status & AAC_DB_RESPONSE_READY) {
1451                 int slot_idx;
1452 
1453                 /* ACK the intr */
1454                 AAC_STATUS_CLR(softs, AAC_DB_RESPONSE_READY);
1455                 (void) AAC_STATUS_GET(softs);
1456                 while (aac_fib_dequeue(softs, AAC_HOST_NORM_RESP_Q,
1457                     &slot_idx) == AACOK)
1458                         aac_handle_io(softs, slot_idx);
1459 
1460                 /*
1461                  * Process waiting cmds before start new ones to
1462                  * ensure first IOs are serviced first.
1463                  */
1464                 aac_start_waiting_io(softs);
1465                 return (AAC_DB_RESPONSE_READY);
1466         } else if (status & AAC_DB_COMMAND_READY) {
1467                 int aif_idx;
1468 
1469                 AAC_STATUS_CLR(softs, AAC_DB_COMMAND_READY);
1470                 (void) AAC_STATUS_GET(softs);
1471                 if (aac_fib_dequeue(softs, AAC_HOST_NORM_CMD_Q, &aif_idx) ==
1472                     AACOK) {
1473                         ddi_acc_handle_t acc = softs->comm_space_acc_handle;
1474                         struct aac_fib *fibp;   /* FIB in communication space */
1475                         uint16_t fib_size;
1476                         uint32_t fib_xfer_state;
1477                         uint32_t addr, size;
1478 
1479                         ASSERT((aif_idx >= 0) && (aif_idx < AAC_ADAPTER_FIBS));
1480 
1481 #define AAC_SYNC_AIF(softs, aif_idx, type) \
1482         { (void) ddi_dma_sync((softs)->comm_space_dma_handle, \
1483             offsetof(struct aac_comm_space, \
1484             adapter_fibs[(aif_idx)]), AAC_FIB_SIZE, \
1485             (type)); }
1486 
1487                         /* Copy AIF from adapter to the empty AIF slot */
1488                         AAC_SYNC_AIF(softs, aif_idx, DDI_DMA_SYNC_FORCPU);
1489                         fibp = &softs->comm_space->adapter_fibs[aif_idx];
1490                         fib_size = ddi_get16(acc, &fibp->Header.Size);
1491 
1492                         aac_save_aif(softs, acc, fibp, fib_size);
1493 
1494                         /* Complete AIF back to adapter with good status */
1495                         fib_xfer_state = LE_32(fibp->Header.XferState);
1496                         if (fib_xfer_state & AAC_FIBSTATE_FROMADAP) {
1497                                 ddi_put32(acc, &fibp->Header.XferState,
1498                                     fib_xfer_state | AAC_FIBSTATE_DONEHOST);
1499                                 ddi_put32(acc, (void *)&fibp->data[0], ST_OK);
1500                                 if (fib_size > AAC_FIB_SIZE)
1501                                         ddi_put16(acc, &fibp->Header.Size,
1502                                             AAC_FIB_SIZE);
1503                                 AAC_SYNC_AIF(softs, aif_idx,
1504                                     DDI_DMA_SYNC_FORDEV);
1505                         }
1506 
1507                         /* Put the AIF response on the response queue */
1508                         addr = ddi_get32(acc,
1509                             &softs->comm_space->adapter_fibs[aif_idx]. \
1510                             Header.SenderFibAddress);
1511                         size = (uint32_t)ddi_get16(acc,
1512                             &softs->comm_space->adapter_fibs[aif_idx]. \
1513                             Header.Size);
1514                         ddi_put32(acc,
1515                             &softs->comm_space->adapter_fibs[aif_idx]. \
1516                             Header.ReceiverFibAddress, addr);
1517                         if (aac_fib_enqueue(softs, AAC_ADAP_NORM_RESP_Q,
1518                             addr, size) == AACERR)
1519                                 cmn_err(CE_NOTE, "!AIF ack failed");
1520                 }
1521                 return (AAC_DB_COMMAND_READY);
1522         } else if (status & AAC_DB_PRINTF_READY) {
1523                 /* ACK the intr */
1524                 AAC_STATUS_CLR(softs, AAC_DB_PRINTF_READY);
1525                 (void) AAC_STATUS_GET(softs);
1526                 (void) ddi_dma_sync(softs->comm_space_dma_handle,
1527                     offsetof(struct aac_comm_space, adapter_print_buf),
1528                     AAC_ADAPTER_PRINT_BUFSIZE, DDI_DMA_SYNC_FORCPU);
1529                 if (aac_check_dma_handle(softs->comm_space_dma_handle) ==
1530                     DDI_SUCCESS)
1531                         cmn_err(CE_NOTE, "MSG From Adapter: %s",
1532                             softs->comm_space->adapter_print_buf);
1533                 else
1534                         ddi_fm_service_impact(softs->devinfo_p,
1535                             DDI_SERVICE_UNAFFECTED);
1536                 AAC_NOTIFY(softs, AAC_DB_PRINTF_READY);
1537                 return (AAC_DB_PRINTF_READY);
1538         } else if (status & AAC_DB_COMMAND_NOT_FULL) {
1539                 /*
1540                  * Without these two condition statements, the OS could hang
1541                  * after a while, especially if there are a lot of AIF's to
1542                  * handle, for instance if a drive is pulled from an array
1543                  * under heavy load.
1544                  */
1545                 AAC_STATUS_CLR(softs, AAC_DB_COMMAND_NOT_FULL);
1546                 return (AAC_DB_COMMAND_NOT_FULL);
1547         } else if (status & AAC_DB_RESPONSE_NOT_FULL) {
1548                 AAC_STATUS_CLR(softs, AAC_DB_COMMAND_NOT_FULL);
1549                 AAC_STATUS_CLR(softs, AAC_DB_RESPONSE_NOT_FULL);
1550                 return (AAC_DB_RESPONSE_NOT_FULL);
1551         } else {
1552                 return (0);
1553         }
1554 }
1555 
1556 static uint_t
1557 aac_intr_old(caddr_t arg)
1558 {
1559         struct aac_softstate *softs = (void *)arg;
1560         int rval;
1561 
1562         mutex_enter(&softs->io_lock);
1563         if (aac_process_intr_old(softs))
1564                 rval = DDI_INTR_CLAIMED;
1565         else
1566                 rval = DDI_INTR_UNCLAIMED;
1567         mutex_exit(&softs->io_lock);
1568 
1569         aac_drain_comp_q(softs);
1570         return (rval);
1571 }
1572 
1573 /*
1574  * Query FIXED or MSI interrupts
1575  */
1576 static int
1577 aac_query_intrs(struct aac_softstate *softs, int intr_type)
1578 {
1579         dev_info_t *dip = softs->devinfo_p;
1580         int avail, actual, count;
1581         int i, flag, ret;
1582 
1583         AACDB_PRINT(softs, CE_NOTE,
1584             "aac_query_intrs:interrupt type 0x%x", intr_type);
1585 
1586         /* Get number of interrupts */
1587         ret = ddi_intr_get_nintrs(dip, intr_type, &count);
1588         if ((ret != DDI_SUCCESS) || (count == 0)) {
1589                 AACDB_PRINT(softs, CE_WARN,
1590                     "ddi_intr_get_nintrs() failed, ret %d count %d",
1591                     ret, count);
1592                 return (DDI_FAILURE);
1593         }
1594 
1595         /* Get number of available interrupts */
1596         ret = ddi_intr_get_navail(dip, intr_type, &avail);
1597         if ((ret != DDI_SUCCESS) || (avail == 0)) {
1598                 AACDB_PRINT(softs, CE_WARN,
1599                     "ddi_intr_get_navail() failed, ret %d avail %d",
1600                     ret, avail);
1601                 return (DDI_FAILURE);
1602         }
1603 
1604         AACDB_PRINT(softs, CE_NOTE,
1605             "ddi_intr_get_nvail returned %d, navail() returned %d",
1606             count, avail);
1607 
1608         /* Allocate an array of interrupt handles */
1609         softs->intr_size = count * sizeof (ddi_intr_handle_t);
1610         softs->htable = kmem_alloc(softs->intr_size, KM_SLEEP);
1611 
1612         if (intr_type == DDI_INTR_TYPE_MSI) {
1613                 count = 1; /* only one vector needed by now */
1614                 flag = DDI_INTR_ALLOC_STRICT;
1615         } else { /* must be DDI_INTR_TYPE_FIXED */
1616                 flag = DDI_INTR_ALLOC_NORMAL;
1617         }
1618 
1619         /* Call ddi_intr_alloc() */
1620         ret = ddi_intr_alloc(dip, softs->htable, intr_type, 0,
1621             count, &actual, flag);
1622 
1623         if ((ret != DDI_SUCCESS) || (actual == 0)) {
1624                 AACDB_PRINT(softs, CE_WARN,
1625                     "ddi_intr_alloc() failed, ret = %d", ret);
1626                 actual = 0;
1627                 goto error;
1628         }
1629 
1630         if (actual < count) {
1631                 AACDB_PRINT(softs, CE_NOTE,
1632                     "Requested: %d, Received: %d", count, actual);
1633                 goto error;
1634         }
1635 
1636         softs->intr_cnt = actual;
1637 
1638         /* Get priority for first msi, assume remaining are all the same */
1639         if ((ret = ddi_intr_get_pri(softs->htable[0],
1640             &softs->intr_pri)) != DDI_SUCCESS) {
1641                 AACDB_PRINT(softs, CE_WARN,
1642                     "ddi_intr_get_pri() failed, ret = %d", ret);
1643                 goto error;
1644         }
1645 
1646         /* Test for high level mutex */
1647         if (softs->intr_pri >= ddi_intr_get_hilevel_pri()) {
1648                 AACDB_PRINT(softs, CE_WARN,
1649                     "aac_query_intrs: Hi level interrupt not supported");
1650                 goto error;
1651         }
1652 
1653         return (DDI_SUCCESS);
1654 
1655 error:
1656         /* Free already allocated intr */
1657         for (i = 0; i < actual; i++)
1658                 (void) ddi_intr_free(softs->htable[i]);
1659 
1660         kmem_free(softs->htable, softs->intr_size);
1661         return (DDI_FAILURE);
1662 }
1663 
1664 
1665 /*
1666  * Register FIXED or MSI interrupts, and enable them
1667  */
1668 static int
1669 aac_add_intrs(struct aac_softstate *softs)
1670 {
1671         int i, ret;
1672         int actual;
1673         ddi_intr_handler_t *aac_intr;
1674 
1675         actual = softs->intr_cnt;
1676         aac_intr = (ddi_intr_handler_t *)((softs->flags & AAC_FLAGS_NEW_COMM) ?
1677             aac_intr_new : aac_intr_old);
1678 
1679         /* Call ddi_intr_add_handler() */
1680         for (i = 0; i < actual; i++) {
1681                 if ((ret = ddi_intr_add_handler(softs->htable[i],
1682                     aac_intr, (caddr_t)softs, NULL)) != DDI_SUCCESS) {
1683                         cmn_err(CE_WARN,
1684                             "ddi_intr_add_handler() failed ret = %d", ret);
1685 
1686                         /* Free already allocated intr */
1687                         for (i = 0; i < actual; i++)
1688                                 (void) ddi_intr_free(softs->htable[i]);
1689 
1690                         kmem_free(softs->htable, softs->intr_size);
1691                         return (DDI_FAILURE);
1692                 }
1693         }
1694 
1695         if ((ret = ddi_intr_get_cap(softs->htable[0], &softs->intr_cap))
1696             != DDI_SUCCESS) {
1697                 cmn_err(CE_WARN, "ddi_intr_get_cap() failed, ret = %d", ret);
1698 
1699                 /* Free already allocated intr */
1700                 for (i = 0; i < actual; i++)
1701                         (void) ddi_intr_free(softs->htable[i]);
1702 
1703                 kmem_free(softs->htable, softs->intr_size);
1704                 return (DDI_FAILURE);
1705         }
1706 
1707         return (DDI_SUCCESS);
1708 }
1709 
1710 /*
1711  * Unregister FIXED or MSI interrupts
1712  */
1713 static void
1714 aac_remove_intrs(struct aac_softstate *softs)
1715 {
1716         int i;
1717 
1718         /* Disable all interrupts */
1719         (void) aac_disable_intrs(softs);
1720         /* Call ddi_intr_remove_handler() */
1721         for (i = 0; i < softs->intr_cnt; i++) {
1722                 (void) ddi_intr_remove_handler(softs->htable[i]);
1723                 (void) ddi_intr_free(softs->htable[i]);
1724         }
1725 
1726         kmem_free(softs->htable, softs->intr_size);
1727 }
1728 
1729 static int
1730 aac_enable_intrs(struct aac_softstate *softs)
1731 {
1732         int rval = AACOK;
1733 
1734         if (softs->intr_cap & DDI_INTR_FLAG_BLOCK) {
1735                 /* for MSI block enable */
1736                 if (ddi_intr_block_enable(softs->htable, softs->intr_cnt) !=
1737                     DDI_SUCCESS)
1738                         rval = AACERR;
1739         } else {
1740                 int i;
1741 
1742                 /* Call ddi_intr_enable() for legacy/MSI non block enable */
1743                 for (i = 0; i < softs->intr_cnt; i++) {
1744                         if (ddi_intr_enable(softs->htable[i]) != DDI_SUCCESS)
1745                                 rval = AACERR;
1746                 }
1747         }
1748         return (rval);
1749 }
1750 
1751 static int
1752 aac_disable_intrs(struct aac_softstate *softs)
1753 {
1754         int rval = AACOK;
1755 
1756         if (softs->intr_cap & DDI_INTR_FLAG_BLOCK) {
1757                 /* Call ddi_intr_block_disable() */
1758                 if (ddi_intr_block_disable(softs->htable, softs->intr_cnt) !=
1759                     DDI_SUCCESS)
1760                         rval = AACERR;
1761         } else {
1762                 int i;
1763 
1764                 for (i = 0; i < softs->intr_cnt; i++) {
1765                         if (ddi_intr_disable(softs->htable[i]) != DDI_SUCCESS)
1766                                 rval = AACERR;
1767                 }
1768         }
1769         return (rval);
1770 }
1771 
1772 /*
1773  * Set pkt_reason and OR in pkt_statistics flag
1774  */
1775 static void
1776 aac_set_pkt_reason(struct aac_softstate *softs, struct aac_cmd *acp,
1777     uchar_t reason, uint_t stat)
1778 {
1779 #ifndef __lock_lint
1780         _NOTE(ARGUNUSED(softs))
1781 #endif
1782         if (acp->pkt->pkt_reason == CMD_CMPLT)
1783                 acp->pkt->pkt_reason = reason;
1784         acp->pkt->pkt_statistics |= stat;
1785 }
1786 
1787 /*
1788  * Handle a finished pkt of soft SCMD
1789  */
1790 static void
1791 aac_soft_callback(struct aac_softstate *softs, struct aac_cmd *acp)
1792 {
1793         ASSERT(acp->pkt);
1794 
1795         acp->flags |= AAC_CMD_CMPLT;
1796 
1797         acp->pkt->pkt_state |= STATE_GOT_BUS | STATE_GOT_TARGET | \
1798             STATE_SENT_CMD | STATE_GOT_STATUS;
1799         if (acp->pkt->pkt_state & STATE_XFERRED_DATA)
1800                 acp->pkt->pkt_resid = 0;
1801 
1802         /* AAC_CMD_NO_INTR means no complete callback */
1803         if (!(acp->flags & AAC_CMD_NO_INTR)) {
1804                 mutex_enter(&softs->q_comp_mutex);
1805                 aac_cmd_enqueue(&softs->q_comp, acp);
1806                 mutex_exit(&softs->q_comp_mutex);
1807                 ddi_trigger_softintr(softs->softint_id);
1808         }
1809 }
1810 
1811 /*
1812  * Handlers for completed IOs, common to aac_intr_new() and aac_intr_old()
1813  */
1814 
1815 /*
1816  * Handle completed logical device IO command
1817  */
1818 /*ARGSUSED*/
1819 static void
1820 aac_ld_complete(struct aac_softstate *softs, struct aac_cmd *acp)
1821 {
1822         struct aac_slot *slotp = acp->slotp;
1823         struct aac_blockread_response *resp;
1824         uint32_t status;
1825 
1826         ASSERT(!(acp->flags & AAC_CMD_SYNC));
1827         ASSERT(!(acp->flags & AAC_CMD_NO_CB));
1828 
1829         acp->pkt->pkt_state |= STATE_GOT_STATUS;
1830 
1831         /*
1832          * block_read/write has a similar response header, use blockread
1833          * response for both.
1834          */
1835         resp = (struct aac_blockread_response *)&slotp->fibp->data[0];
1836         status = ddi_get32(slotp->fib_acc_handle, &resp->Status);
1837         if (status == ST_OK) {
1838                 acp->pkt->pkt_resid = 0;
1839                 acp->pkt->pkt_state |= STATE_XFERRED_DATA;
1840         } else {
1841                 aac_set_arq_data_hwerr(acp);
1842         }
1843 }
1844 
1845 /*
1846  * Handle completed phys. device IO command
1847  */
1848 static void
1849 aac_pd_complete(struct aac_softstate *softs, struct aac_cmd *acp)
1850 {
1851         ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
1852         struct aac_fib *fibp = acp->slotp->fibp;
1853         struct scsi_pkt *pkt = acp->pkt;
1854         struct aac_srb_reply *resp;
1855         uint32_t resp_status;
1856 
1857         ASSERT(!(acp->flags & AAC_CMD_SYNC));
1858         ASSERT(!(acp->flags & AAC_CMD_NO_CB));
1859 
1860         resp = (struct aac_srb_reply *)&fibp->data[0];
1861         resp_status = ddi_get32(acc, &resp->status);
1862 
1863         /* First check FIB status */
1864         if (resp_status == ST_OK) {
1865                 uint32_t scsi_status;
1866                 uint32_t srb_status;
1867                 uint32_t data_xfer_length;
1868 
1869                 scsi_status = ddi_get32(acc, &resp->scsi_status);
1870                 srb_status = ddi_get32(acc, &resp->srb_status);
1871                 data_xfer_length = ddi_get32(acc, &resp->data_xfer_length);
1872 
1873                 *pkt->pkt_scbp = (uint8_t)scsi_status;
1874                 pkt->pkt_state |= STATE_GOT_STATUS;
1875                 if (scsi_status == STATUS_GOOD) {
1876                         uchar_t cmd = ((union scsi_cdb *)(void *)
1877                             (pkt->pkt_cdbp))->scc_cmd;
1878 
1879                         /* Next check SRB status */
1880                         switch (srb_status & 0x3f) {
1881                         case SRB_STATUS_DATA_OVERRUN:
1882                                 AACDB_PRINT(softs, CE_NOTE, "DATA_OVERRUN: " \
1883                                     "scmd=%d, xfer=%d, buflen=%d",
1884                                     (uint32_t)cmd, data_xfer_length,
1885                                     acp->bcount);
1886 
1887                                 switch (cmd) {
1888                                 case SCMD_READ:
1889                                 case SCMD_WRITE:
1890                                 case SCMD_READ_G1:
1891                                 case SCMD_WRITE_G1:
1892                                 case SCMD_READ_G4:
1893                                 case SCMD_WRITE_G4:
1894                                 case SCMD_READ_G5:
1895                                 case SCMD_WRITE_G5:
1896                                         aac_set_pkt_reason(softs, acp,
1897                                             CMD_DATA_OVR, 0);
1898                                         break;
1899                                 }
1900                                 /*FALLTHRU*/
1901                         case SRB_STATUS_ERROR_RECOVERY:
1902                         case SRB_STATUS_PENDING:
1903                         case SRB_STATUS_SUCCESS:
1904                                 /*
1905                                  * pkt_resid should only be calculated if the
1906                                  * status is ERROR_RECOVERY/PENDING/SUCCESS/
1907                                  * OVERRUN/UNDERRUN
1908                                  */
1909                                 if (data_xfer_length) {
1910                                         pkt->pkt_state |= STATE_XFERRED_DATA;
1911                                         pkt->pkt_resid = acp->bcount - \
1912                                             data_xfer_length;
1913                                         ASSERT(pkt->pkt_resid >= 0);
1914                                 }
1915                                 break;
1916                         case SRB_STATUS_ABORTED:
1917                                 AACDB_PRINT(softs, CE_NOTE,
1918                                     "SRB_STATUS_ABORTED, xfer=%d, resid=%d",
1919                                     data_xfer_length, pkt->pkt_resid);
1920                                 aac_set_pkt_reason(softs, acp, CMD_ABORTED,
1921                                     STAT_ABORTED);
1922                                 break;
1923                         case SRB_STATUS_ABORT_FAILED:
1924                                 AACDB_PRINT(softs, CE_NOTE,
1925                                     "SRB_STATUS_ABORT_FAILED, xfer=%d, " \
1926                                     "resid=%d", data_xfer_length,
1927                                     pkt->pkt_resid);
1928                                 aac_set_pkt_reason(softs, acp, CMD_ABORT_FAIL,
1929                                     0);
1930                                 break;
1931                         case SRB_STATUS_PARITY_ERROR:
1932                                 AACDB_PRINT(softs, CE_NOTE,
1933                                     "SRB_STATUS_PARITY_ERROR, xfer=%d, " \
1934                                     "resid=%d", data_xfer_length,
1935                                     pkt->pkt_resid);
1936                                 aac_set_pkt_reason(softs, acp, CMD_PER_FAIL, 0);
1937                                 break;
1938                         case SRB_STATUS_NO_DEVICE:
1939                         case SRB_STATUS_INVALID_PATH_ID:
1940                         case SRB_STATUS_INVALID_TARGET_ID:
1941                         case SRB_STATUS_INVALID_LUN:
1942                         case SRB_STATUS_SELECTION_TIMEOUT:
1943 #ifdef DEBUG
1944                                 if (AAC_DEV_IS_VALID(acp->dvp)) {
1945                                         AACDB_PRINT(softs, CE_NOTE,
1946                                             "SRB_STATUS_NO_DEVICE(%d), " \
1947                                             "xfer=%d, resid=%d ",
1948                                             srb_status & 0x3f,
1949                                             data_xfer_length, pkt->pkt_resid);
1950                                 }
1951 #endif
1952                                 aac_set_pkt_reason(softs, acp, CMD_DEV_GONE, 0);
1953                                 break;
1954                         case SRB_STATUS_COMMAND_TIMEOUT:
1955                         case SRB_STATUS_TIMEOUT:
1956                                 AACDB_PRINT(softs, CE_NOTE,
1957                                     "SRB_STATUS_COMMAND_TIMEOUT, xfer=%d, " \
1958                                     "resid=%d", data_xfer_length,
1959                                     pkt->pkt_resid);
1960                                 aac_set_pkt_reason(softs, acp, CMD_TIMEOUT,
1961                                     STAT_TIMEOUT);
1962                                 break;
1963                         case SRB_STATUS_BUS_RESET:
1964                                 AACDB_PRINT(softs, CE_NOTE,
1965                                     "SRB_STATUS_BUS_RESET, xfer=%d, " \
1966                                     "resid=%d", data_xfer_length,
1967                                     pkt->pkt_resid);
1968                                 aac_set_pkt_reason(softs, acp, CMD_RESET,
1969                                     STAT_BUS_RESET);
1970                                 break;
1971                         default:
1972                                 AACDB_PRINT(softs, CE_NOTE, "srb_status=%d, " \
1973                                     "xfer=%d, resid=%d", srb_status & 0x3f,
1974                                     data_xfer_length, pkt->pkt_resid);
1975                                 aac_set_pkt_reason(softs, acp, CMD_TRAN_ERR, 0);
1976                                 break;
1977                         }
1978                 } else if (scsi_status == STATUS_CHECK) {
1979                         /* CHECK CONDITION */
1980                         struct scsi_arq_status *arqstat =
1981                             (void *)(pkt->pkt_scbp);
1982                         uint32_t sense_data_size;
1983 
1984                         pkt->pkt_state |= STATE_ARQ_DONE;
1985 
1986                         *(uint8_t *)&arqstat->sts_rqpkt_status = STATUS_GOOD;
1987                         arqstat->sts_rqpkt_reason = CMD_CMPLT;
1988                         arqstat->sts_rqpkt_resid = 0;
1989                         arqstat->sts_rqpkt_state =
1990                             STATE_GOT_BUS |
1991                             STATE_GOT_TARGET |
1992                             STATE_SENT_CMD |
1993                             STATE_XFERRED_DATA;
1994                         arqstat->sts_rqpkt_statistics = 0;
1995 
1996                         sense_data_size = ddi_get32(acc,
1997                             &resp->sense_data_size);
1998                         ASSERT(sense_data_size <= AAC_SENSE_BUFFERSIZE);
1999                         AACDB_PRINT(softs, CE_NOTE,
2000                             "CHECK CONDITION: sense len=%d, xfer len=%d",
2001                             sense_data_size, data_xfer_length);
2002 
2003                         if (sense_data_size > SENSE_LENGTH)
2004                                 sense_data_size = SENSE_LENGTH;
2005                         ddi_rep_get8(acc, (uint8_t *)&arqstat->sts_sensedata,
2006                             (uint8_t *)resp->sense_data, sense_data_size,
2007                             DDI_DEV_AUTOINCR);
2008                 } else {
2009                         AACDB_PRINT(softs, CE_WARN, "invaild scsi status: " \
2010                             "scsi_status=%d, srb_status=%d",
2011                             scsi_status, srb_status);
2012                         aac_set_pkt_reason(softs, acp, CMD_TRAN_ERR, 0);
2013                 }
2014         } else {
2015                 AACDB_PRINT(softs, CE_NOTE, "SRB failed: fib status %d",
2016                     resp_status);
2017                 aac_set_pkt_reason(softs, acp, CMD_TRAN_ERR, 0);
2018         }
2019 }
2020 
2021 /*
2022  * Handle completed IOCTL command
2023  */
2024 /*ARGSUSED*/
2025 void
2026 aac_ioctl_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2027 {
2028         struct aac_slot *slotp = acp->slotp;
2029 
2030         /*
2031          * NOTE: Both aac_ioctl_send_fib() and aac_send_raw_srb()
2032          * may wait on softs->event, so use cv_broadcast() instead
2033          * of cv_signal().
2034          */
2035         ASSERT(acp->flags & AAC_CMD_SYNC);
2036         ASSERT(acp->flags & AAC_CMD_NO_CB);
2037 
2038         /* Get the size of the response FIB from its FIB.Header.Size field */
2039         acp->fib_size = ddi_get16(slotp->fib_acc_handle,
2040             &slotp->fibp->Header.Size);
2041 
2042         ASSERT(acp->fib_size <= softs->aac_max_fib_size);
2043         ddi_rep_get8(slotp->fib_acc_handle, (uint8_t *)acp->fibp,
2044             (uint8_t *)slotp->fibp, acp->fib_size, DDI_DEV_AUTOINCR);
2045 }
2046 
2047 /*
2048  * Handle completed sync fib command
2049  */
2050 /*ARGSUSED*/
2051 void
2052 aac_sync_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2053 {
2054 }
2055 
2056 /*
2057  * Handle completed Flush command
2058  */
2059 /*ARGSUSED*/
2060 static void
2061 aac_synccache_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2062 {
2063         struct aac_slot *slotp = acp->slotp;
2064         ddi_acc_handle_t acc = slotp->fib_acc_handle;
2065         struct aac_synchronize_reply *resp;
2066         uint32_t status;
2067 
2068         ASSERT(!(acp->flags & AAC_CMD_SYNC));
2069 
2070         acp->pkt->pkt_state |= STATE_GOT_STATUS;
2071 
2072         resp = (struct aac_synchronize_reply *)&slotp->fibp->data[0];
2073         status = ddi_get32(acc, &resp->Status);
2074         if (status != CT_OK)
2075                 aac_set_arq_data_hwerr(acp);
2076 }
2077 
2078 /*ARGSUSED*/
2079 static void
2080 aac_startstop_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2081 {
2082         struct aac_slot *slotp = acp->slotp;
2083         ddi_acc_handle_t acc = slotp->fib_acc_handle;
2084         struct aac_Container_resp *resp;
2085         uint32_t status;
2086 
2087         ASSERT(!(acp->flags & AAC_CMD_SYNC));
2088 
2089         acp->pkt->pkt_state |= STATE_GOT_STATUS;
2090 
2091         resp = (struct aac_Container_resp *)&slotp->fibp->data[0];
2092         status = ddi_get32(acc, &resp->Status);
2093         if (status != 0) {
2094                 AACDB_PRINT(softs, CE_WARN, "Cannot start/stop a unit");
2095                 aac_set_arq_data_hwerr(acp);
2096         }
2097 }
2098 
2099 /*
2100  * Access PCI space to see if the driver can support the card
2101  */
2102 static int
2103 aac_check_card_type(struct aac_softstate *softs)
2104 {
2105         ddi_acc_handle_t pci_config_handle;
2106         int card_index;
2107         uint32_t pci_cmd;
2108 
2109         /* Map pci configuration space */
2110         if ((pci_config_setup(softs->devinfo_p, &pci_config_handle)) !=
2111             DDI_SUCCESS) {
2112                 AACDB_PRINT(softs, CE_WARN, "Cannot setup pci config space");
2113                 return (AACERR);
2114         }
2115 
2116         softs->vendid = pci_config_get16(pci_config_handle, PCI_CONF_VENID);
2117         softs->devid = pci_config_get16(pci_config_handle, PCI_CONF_DEVID);
2118         softs->subvendid = pci_config_get16(pci_config_handle,
2119             PCI_CONF_SUBVENID);
2120         softs->subsysid = pci_config_get16(pci_config_handle,
2121             PCI_CONF_SUBSYSID);
2122 
2123         card_index = 0;
2124         while (!CARD_IS_UNKNOWN(card_index)) {
2125                 if ((aac_cards[card_index].vendor == softs->vendid) &&
2126                     (aac_cards[card_index].device == softs->devid) &&
2127                     (aac_cards[card_index].subvendor == softs->subvendid) &&
2128                     (aac_cards[card_index].subsys == softs->subsysid)) {
2129                         break;
2130                 }
2131                 card_index++;
2132         }
2133 
2134         softs->card = card_index;
2135         softs->hwif = aac_cards[card_index].hwif;
2136 
2137         /*
2138          * Unknown aac card
2139          * do a generic match based on the VendorID and DeviceID to
2140          * support the new cards in the aac family
2141          */
2142         if (CARD_IS_UNKNOWN(card_index)) {
2143                 if (softs->vendid != 0x9005) {
2144                         AACDB_PRINT(softs, CE_WARN,
2145                             "Unknown vendor 0x%x", softs->vendid);
2146                         goto error;
2147                 }
2148                 switch (softs->devid) {
2149                 case 0x285:
2150                         softs->hwif = AAC_HWIF_I960RX;
2151                         break;
2152                 case 0x286:
2153                         softs->hwif = AAC_HWIF_RKT;
2154                         break;
2155                 default:
2156                         AACDB_PRINT(softs, CE_WARN,
2157                             "Unknown device \"pci9005,%x\"", softs->devid);
2158                         goto error;
2159                 }
2160         }
2161 
2162         /* Set hardware dependent interface */
2163         switch (softs->hwif) {
2164         case AAC_HWIF_I960RX:
2165                 softs->aac_if = aac_rx_interface;
2166                 softs->map_size_min = AAC_MAP_SIZE_MIN_RX;
2167                 break;
2168         case AAC_HWIF_RKT:
2169                 softs->aac_if = aac_rkt_interface;
2170                 softs->map_size_min = AAC_MAP_SIZE_MIN_RKT;
2171                 break;
2172         default:
2173                 AACDB_PRINT(softs, CE_WARN,
2174                     "Unknown hardware interface %d", softs->hwif);
2175                 goto error;
2176         }
2177 
2178         /* Set card names */
2179         (void *)strncpy(softs->vendor_name, aac_cards[card_index].vid,
2180             AAC_VENDOR_LEN);
2181         (void *)strncpy(softs->product_name, aac_cards[card_index].desc,
2182             AAC_PRODUCT_LEN);
2183 
2184         /* Set up quirks */
2185         softs->flags = aac_cards[card_index].quirks;
2186 
2187         /* Force the busmaster enable bit on */
2188         pci_cmd = pci_config_get16(pci_config_handle, PCI_CONF_COMM);
2189         if ((pci_cmd & PCI_COMM_ME) == 0) {
2190                 pci_cmd |= PCI_COMM_ME;
2191                 pci_config_put16(pci_config_handle, PCI_CONF_COMM, pci_cmd);
2192                 pci_cmd = pci_config_get16(pci_config_handle, PCI_CONF_COMM);
2193                 if ((pci_cmd & PCI_COMM_ME) == 0) {
2194                         cmn_err(CE_CONT, "?Cannot enable busmaster bit");
2195                         goto error;
2196                 }
2197         }
2198 
2199         /* Set memory base to map */
2200         softs->pci_mem_base_paddr = 0xfffffff0UL & \
2201             pci_config_get32(pci_config_handle, PCI_CONF_BASE0);
2202 
2203         pci_config_teardown(&pci_config_handle);
2204 
2205         return (AACOK); /* card type detected */
2206 error:
2207         pci_config_teardown(&pci_config_handle);
2208         return (AACERR); /* no matched card found */
2209 }
2210 
2211 /*
2212  * Do the usual interrupt handler setup stuff.
2213  */
2214 static int
2215 aac_register_intrs(struct aac_softstate *softs)
2216 {
2217         dev_info_t *dip;
2218         int intr_types;
2219 
2220         ASSERT(softs->devinfo_p);
2221         dip = softs->devinfo_p;
2222 
2223         /* Get the type of device intrrupts */
2224         if (ddi_intr_get_supported_types(dip, &intr_types) != DDI_SUCCESS) {
2225                 AACDB_PRINT(softs, CE_WARN,
2226                     "ddi_intr_get_supported_types() failed");
2227                 return (AACERR);
2228         }
2229         AACDB_PRINT(softs, CE_NOTE,
2230             "ddi_intr_get_supported_types() ret: 0x%x", intr_types);
2231 
2232         /* Query interrupt, and alloc/init all needed struct */
2233         if (intr_types & DDI_INTR_TYPE_MSI) {
2234                 if (aac_query_intrs(softs, DDI_INTR_TYPE_MSI)
2235                     != DDI_SUCCESS) {
2236                         AACDB_PRINT(softs, CE_WARN,
2237                             "MSI interrupt query failed");
2238                         return (AACERR);
2239                 }
2240                 softs->intr_type = DDI_INTR_TYPE_MSI;
2241         } else if (intr_types & DDI_INTR_TYPE_FIXED) {
2242                 if (aac_query_intrs(softs, DDI_INTR_TYPE_FIXED)
2243                     != DDI_SUCCESS) {
2244                         AACDB_PRINT(softs, CE_WARN,
2245                             "FIXED interrupt query failed");
2246                         return (AACERR);
2247                 }
2248                 softs->intr_type = DDI_INTR_TYPE_FIXED;
2249         } else {
2250                 AACDB_PRINT(softs, CE_WARN,
2251                     "Device cannot suppport both FIXED and MSI interrupts");
2252                 return (AACERR);
2253         }
2254 
2255         /* Connect interrupt handlers */
2256         if (aac_add_intrs(softs) != DDI_SUCCESS) {
2257                 AACDB_PRINT(softs, CE_WARN,
2258                     "Interrupt registration failed, intr type: %s",
2259                     softs->intr_type == DDI_INTR_TYPE_MSI ? "MSI" : "FIXED");
2260                 return (AACERR);
2261         }
2262         (void) aac_enable_intrs(softs);
2263 
2264         if (ddi_add_softintr(dip, DDI_SOFTINT_LOW, &softs->softint_id,
2265             NULL, NULL, aac_softintr, (caddr_t)softs) != DDI_SUCCESS) {
2266                 AACDB_PRINT(softs, CE_WARN,
2267                     "Can not setup soft interrupt handler!");
2268                 aac_remove_intrs(softs);
2269                 return (AACERR);
2270         }
2271 
2272         return (AACOK);
2273 }
2274 
2275 static void
2276 aac_unregister_intrs(struct aac_softstate *softs)
2277 {
2278         aac_remove_intrs(softs);
2279         ddi_remove_softintr(softs->softint_id);
2280 }
2281 
2282 /*
2283  * Check the firmware to determine the features to support and the FIB
2284  * parameters to use.
2285  */
2286 static int
2287 aac_check_firmware(struct aac_softstate *softs)
2288 {
2289         uint32_t options;
2290         uint32_t atu_size;
2291         ddi_acc_handle_t pci_handle;
2292         uint8_t *data;
2293         uint32_t max_fibs;
2294         uint32_t max_fib_size;
2295         uint32_t sg_tablesize;
2296         uint32_t max_sectors;
2297         uint32_t status;
2298 
2299         /* Get supported options */
2300         if ((aac_sync_mbcommand(softs, AAC_MONKER_GETINFO, 0, 0, 0, 0,
2301             &status)) != AACOK) {
2302                 if (status != SRB_STATUS_INVALID_REQUEST) {
2303                         cmn_err(CE_CONT,
2304                             "?Fatal error: request adapter info error");
2305                         return (AACERR);
2306                 }
2307                 options = 0;
2308                 atu_size = 0;
2309         } else {
2310                 options = AAC_MAILBOX_GET(softs, 1);
2311                 atu_size = AAC_MAILBOX_GET(softs, 2);
2312         }
2313 
2314         if (softs->state & AAC_STATE_RESET) {
2315                 if ((softs->support_opt == options) &&
2316                     (softs->atu_size == atu_size))
2317                         return (AACOK);
2318 
2319                 cmn_err(CE_WARN,
2320                     "?Fatal error: firmware changed, system needs reboot");
2321                 return (AACERR);
2322         }
2323 
2324         /*
2325          * The following critical settings are initialized only once during
2326          * driver attachment.
2327          */
2328         softs->support_opt = options;
2329         softs->atu_size = atu_size;
2330 
2331         /* Process supported options */
2332         if ((options & AAC_SUPPORTED_4GB_WINDOW) != 0 &&
2333             (softs->flags & AAC_FLAGS_NO4GB) == 0) {
2334                 AACDB_PRINT(softs, CE_NOTE, "!Enable FIB map 4GB window");
2335                 softs->flags |= AAC_FLAGS_4GB_WINDOW;
2336         } else {
2337                 /*
2338                  * Quirk AAC_FLAGS_NO4GB is for FIB address and thus comm space
2339                  * only. IO is handled by the DMA engine which does not suffer
2340                  * from the ATU window programming workarounds necessary for
2341                  * CPU copy operations.
2342                  */
2343                 softs->addr_dma_attr.dma_attr_addr_lo = 0x2000ull;
2344                 softs->addr_dma_attr.dma_attr_addr_hi = 0x7fffffffull;
2345         }
2346 
2347         if ((options & AAC_SUPPORTED_SGMAP_HOST64) != 0) {
2348                 AACDB_PRINT(softs, CE_NOTE, "!Enable SG map 64-bit address");
2349                 softs->buf_dma_attr.dma_attr_addr_hi = 0xffffffffffffffffull;
2350                 softs->buf_dma_attr.dma_attr_seg = 0xffffffffffffffffull;
2351                 softs->flags |= AAC_FLAGS_SG_64BIT;
2352         }
2353 
2354         if (options & AAC_SUPPORTED_64BIT_ARRAYSIZE) {
2355                 softs->flags |= AAC_FLAGS_ARRAY_64BIT;
2356                 AACDB_PRINT(softs, CE_NOTE, "!Enable 64-bit array size");
2357         }
2358 
2359         if (options & AAC_SUPPORTED_NONDASD) {
2360                 if ((ddi_prop_lookup_string(DDI_DEV_T_ANY, softs->devinfo_p, 0,
2361                     "nondasd-enable", (char **)&data) == DDI_SUCCESS)) {
2362                         if (strcmp((char *)data, "yes") == 0) {
2363                                 AACDB_PRINT(softs, CE_NOTE,
2364                                     "!Enable Non-DASD access");
2365                                 softs->flags |= AAC_FLAGS_NONDASD;
2366                         }
2367                         ddi_prop_free(data);
2368                 }
2369         }
2370 
2371         /* Read preferred settings */
2372         max_fib_size = 0;
2373         if ((aac_sync_mbcommand(softs, AAC_MONKER_GETCOMMPREF,
2374             0, 0, 0, 0, NULL)) == AACOK) {
2375                 options = AAC_MAILBOX_GET(softs, 1);
2376                 max_fib_size = (options & 0xffff);
2377                 max_sectors = (options >> 16) << 1;
2378                 options = AAC_MAILBOX_GET(softs, 2);
2379                 sg_tablesize = (options >> 16);
2380                 options = AAC_MAILBOX_GET(softs, 3);
2381                 max_fibs = (options & 0xffff);
2382         }
2383 
2384         /* Enable new comm. and rawio at the same time */
2385         if ((softs->support_opt & AAC_SUPPORTED_NEW_COMM) &&
2386             (max_fib_size != 0)) {
2387                 /* read out and save PCI MBR */
2388                 if ((atu_size > softs->map_size) &&
2389                     (ddi_regs_map_setup(softs->devinfo_p, 1,
2390                     (caddr_t *)&data, 0, atu_size, &softs->reg_attr,
2391                     &pci_handle) == DDI_SUCCESS)) {
2392                         ddi_regs_map_free(&softs->pci_mem_handle);
2393                         softs->pci_mem_handle = pci_handle;
2394                         softs->pci_mem_base_vaddr = data;
2395                         softs->map_size = atu_size;
2396                 }
2397                 if (atu_size == softs->map_size) {
2398                         softs->flags |= AAC_FLAGS_NEW_COMM;
2399                         AACDB_PRINT(softs, CE_NOTE,
2400                             "!Enable New Comm. interface");
2401                 }
2402         }
2403 
2404         /* Set FIB parameters */
2405         if (softs->flags & AAC_FLAGS_NEW_COMM) {
2406                 softs->aac_max_fibs = max_fibs;
2407                 softs->aac_max_fib_size = max_fib_size;
2408                 softs->aac_max_sectors = max_sectors;
2409                 softs->aac_sg_tablesize = sg_tablesize;
2410 
2411                 softs->flags |= AAC_FLAGS_RAW_IO;
2412                 AACDB_PRINT(softs, CE_NOTE, "!Enable RawIO");
2413         } else {
2414                 softs->aac_max_fibs =
2415                     (softs->flags & AAC_FLAGS_256FIBS) ? 256 : 512;
2416                 softs->aac_max_fib_size = AAC_FIB_SIZE;
2417                 softs->aac_max_sectors = 128;        /* 64K */
2418                 if (softs->flags & AAC_FLAGS_17SG)
2419                         softs->aac_sg_tablesize = 17;
2420                 else if (softs->flags & AAC_FLAGS_34SG)
2421                         softs->aac_sg_tablesize = 34;
2422                 else if (softs->flags & AAC_FLAGS_SG_64BIT)
2423                         softs->aac_sg_tablesize = (AAC_FIB_DATASIZE -
2424                             sizeof (struct aac_blockwrite64) +
2425                             sizeof (struct aac_sg_entry64)) /
2426                             sizeof (struct aac_sg_entry64);
2427                 else
2428                         softs->aac_sg_tablesize = (AAC_FIB_DATASIZE -
2429                             sizeof (struct aac_blockwrite) +
2430                             sizeof (struct aac_sg_entry)) /
2431                             sizeof (struct aac_sg_entry);
2432         }
2433 
2434         if ((softs->flags & AAC_FLAGS_RAW_IO) &&
2435             (softs->flags & AAC_FLAGS_ARRAY_64BIT)) {
2436                 softs->flags |= AAC_FLAGS_LBA_64BIT;
2437                 AACDB_PRINT(softs, CE_NOTE, "!Enable 64-bit array");
2438         }
2439         softs->buf_dma_attr.dma_attr_sgllen = softs->aac_sg_tablesize;
2440         softs->buf_dma_attr.dma_attr_maxxfer = softs->aac_max_sectors << 9;
2441         /*
2442          * 64K maximum segment size in scatter gather list is controlled by
2443          * the NEW_COMM bit in the adapter information. If not set, the card
2444          * can only accept a maximum of 64K. It is not recommended to permit
2445          * more than 128KB of total transfer size to the adapters because
2446          * performance is negatively impacted.
2447          *
2448          * For new comm, segment size equals max xfer size. For old comm,
2449          * we use 64K for both.
2450          */
2451         softs->buf_dma_attr.dma_attr_count_max =
2452             softs->buf_dma_attr.dma_attr_maxxfer - 1;
2453 
2454         /* Setup FIB operations */
2455         if (softs->flags & AAC_FLAGS_RAW_IO)
2456                 softs->aac_cmd_fib = aac_cmd_fib_rawio;
2457         else if (softs->flags & AAC_FLAGS_SG_64BIT)
2458                 softs->aac_cmd_fib = aac_cmd_fib_brw64;
2459         else
2460                 softs->aac_cmd_fib = aac_cmd_fib_brw;
2461         softs->aac_cmd_fib_scsi = (softs->flags & AAC_FLAGS_SG_64BIT) ? \
2462             aac_cmd_fib_scsi64 : aac_cmd_fib_scsi32;
2463 
2464         /* 64-bit LBA needs descriptor format sense data */
2465         softs->slen = sizeof (struct scsi_arq_status);
2466         if ((softs->flags & AAC_FLAGS_LBA_64BIT) &&
2467             softs->slen < AAC_ARQ64_LENGTH)
2468                 softs->slen = AAC_ARQ64_LENGTH;
2469 
2470         AACDB_PRINT(softs, CE_NOTE,
2471             "!max_fibs %d max_fibsize 0x%x max_sectors %d max_sg %d",
2472             softs->aac_max_fibs, softs->aac_max_fib_size,
2473             softs->aac_max_sectors, softs->aac_sg_tablesize);
2474 
2475         return (AACOK);
2476 }
2477 
2478 static void
2479 aac_fsa_rev(struct aac_softstate *softs, struct FsaRev *fsarev0,
2480     struct FsaRev *fsarev1)
2481 {
2482         ddi_acc_handle_t acc = softs->sync_ac.slotp->fib_acc_handle;
2483 
2484         AAC_GET_FIELD8(acc, fsarev1, fsarev0, external.comp.dash);
2485         AAC_GET_FIELD8(acc, fsarev1, fsarev0, external.comp.type);
2486         AAC_GET_FIELD8(acc, fsarev1, fsarev0, external.comp.minor);
2487         AAC_GET_FIELD8(acc, fsarev1, fsarev0, external.comp.major);
2488         AAC_GET_FIELD32(acc, fsarev1, fsarev0, buildNumber);
2489 }
2490 
2491 /*
2492  * The following function comes from Adaptec:
2493  *
2494  * Query adapter information and supplement adapter information
2495  */
2496 static int
2497 aac_get_adapter_info(struct aac_softstate *softs,
2498     struct aac_adapter_info *ainfr, struct aac_supplement_adapter_info *sinfr)
2499 {
2500         struct aac_cmd *acp = &softs->sync_ac;
2501         ddi_acc_handle_t acc;
2502         struct aac_fib *fibp;
2503         struct aac_adapter_info *ainfp;
2504         struct aac_supplement_adapter_info *sinfp;
2505         int rval;
2506 
2507         (void) aac_sync_fib_slot_bind(softs, acp);
2508         acc = acp->slotp->fib_acc_handle;
2509         fibp = acp->slotp->fibp;
2510 
2511         ddi_put8(acc, &fibp->data[0], 0);
2512         if (aac_sync_fib(softs, RequestAdapterInfo,
2513             AAC_FIB_SIZEOF(struct aac_adapter_info)) != AACOK) {
2514                 AACDB_PRINT(softs, CE_WARN, "RequestAdapterInfo failed");
2515                 rval = AACERR;
2516                 goto finish;
2517         }
2518         ainfp = (struct aac_adapter_info *)fibp->data;
2519         if (ainfr) {
2520                 AAC_GET_FIELD32(acc, ainfr, ainfp, SupportedOptions);
2521                 AAC_GET_FIELD32(acc, ainfr, ainfp, PlatformBase);
2522                 AAC_GET_FIELD32(acc, ainfr, ainfp, CpuArchitecture);
2523                 AAC_GET_FIELD32(acc, ainfr, ainfp, CpuVariant);
2524                 AAC_GET_FIELD32(acc, ainfr, ainfp, ClockSpeed);
2525                 AAC_GET_FIELD32(acc, ainfr, ainfp, ExecutionMem);
2526                 AAC_GET_FIELD32(acc, ainfr, ainfp, BufferMem);
2527                 AAC_GET_FIELD32(acc, ainfr, ainfp, TotalMem);
2528                 aac_fsa_rev(softs, &ainfp->KernelRevision,
2529                     &ainfr->KernelRevision);
2530                 aac_fsa_rev(softs, &ainfp->MonitorRevision,
2531                     &ainfr->MonitorRevision);
2532                 aac_fsa_rev(softs, &ainfp->HardwareRevision,
2533                     &ainfr->HardwareRevision);
2534                 aac_fsa_rev(softs, &ainfp->BIOSRevision,
2535                     &ainfr->BIOSRevision);
2536                 AAC_GET_FIELD32(acc, ainfr, ainfp, ClusteringEnabled);
2537                 AAC_GET_FIELD32(acc, ainfr, ainfp, ClusterChannelMask);
2538                 AAC_GET_FIELD64(acc, ainfr, ainfp, SerialNumber);
2539                 AAC_GET_FIELD32(acc, ainfr, ainfp, batteryPlatform);
2540                 AAC_GET_FIELD32(acc, ainfr, ainfp, SupportedOptions);
2541                 AAC_GET_FIELD32(acc, ainfr, ainfp, OemVariant);
2542         }
2543         if (sinfr) {
2544                 if (!(softs->support_opt &
2545                     AAC_SUPPORTED_SUPPLEMENT_ADAPTER_INFO)) {
2546                         AACDB_PRINT(softs, CE_WARN,
2547                             "SupplementAdapterInfo not supported");
2548                         rval = AACERR;
2549                         goto finish;
2550                 }
2551                 ddi_put8(acc, &fibp->data[0], 0);
2552                 if (aac_sync_fib(softs, RequestSupplementAdapterInfo,
2553                     AAC_FIB_SIZEOF(struct aac_supplement_adapter_info))
2554                     != AACOK) {
2555                         AACDB_PRINT(softs, CE_WARN,
2556                             "RequestSupplementAdapterInfo failed");
2557                         rval = AACERR;
2558                         goto finish;
2559                 }
2560                 sinfp = (struct aac_supplement_adapter_info *)fibp->data;
2561                 AAC_REP_GET_FIELD8(acc, sinfr, sinfp, AdapterTypeText[0], 17+1);
2562                 AAC_REP_GET_FIELD8(acc, sinfr, sinfp, Pad[0], 2);
2563                 AAC_GET_FIELD32(acc, sinfr, sinfp, FlashMemoryByteSize);
2564                 AAC_GET_FIELD32(acc, sinfr, sinfp, FlashImageId);
2565                 AAC_GET_FIELD32(acc, sinfr, sinfp, MaxNumberPorts);
2566                 AAC_GET_FIELD32(acc, sinfr, sinfp, Version);
2567                 AAC_GET_FIELD32(acc, sinfr, sinfp, FeatureBits);
2568                 AAC_GET_FIELD8(acc, sinfr, sinfp, SlotNumber);
2569                 AAC_REP_GET_FIELD8(acc, sinfr, sinfp, ReservedPad0[0], 3);
2570                 AAC_REP_GET_FIELD8(acc, sinfr, sinfp, BuildDate[0], 12);
2571                 AAC_GET_FIELD32(acc, sinfr, sinfp, CurrentNumberPorts);
2572                 AAC_REP_GET_FIELD8(acc, sinfr, sinfp, VpdInfo,
2573                     sizeof (struct vpd_info));
2574                 aac_fsa_rev(softs, &sinfp->FlashFirmwareRevision,
2575                     &sinfr->FlashFirmwareRevision);
2576                 AAC_GET_FIELD32(acc, sinfr, sinfp, RaidTypeMorphOptions);
2577                 aac_fsa_rev(softs, &sinfp->FlashFirmwareBootRevision,
2578                     &sinfr->FlashFirmwareBootRevision);
2579                 AAC_REP_GET_FIELD8(acc, sinfr, sinfp, MfgPcbaSerialNo,
2580                     MFG_PCBA_SERIAL_NUMBER_WIDTH);
2581                 AAC_REP_GET_FIELD8(acc, sinfr, sinfp, MfgWWNName[0],
2582                     MFG_WWN_WIDTH);
2583                 AAC_GET_FIELD32(acc, sinfr, sinfp, SupportedOptions2);
2584                 AAC_GET_FIELD32(acc, sinfr, sinfp, ExpansionFlag);
2585                 if (sinfr->ExpansionFlag == 1) {
2586                         AAC_GET_FIELD32(acc, sinfr, sinfp, FeatureBits3);
2587                         AAC_GET_FIELD32(acc, sinfr, sinfp,
2588                             SupportedPerformanceMode);
2589                         AAC_REP_GET_FIELD32(acc, sinfr, sinfp,
2590                             ReservedGrowth[0], 80);
2591                 }
2592         }
2593         rval = AACOK;
2594 finish:
2595         aac_sync_fib_slot_release(softs, acp);
2596         return (rval);
2597 }
2598 
2599 static int
2600 aac_get_bus_info(struct aac_softstate *softs, uint32_t *bus_max,
2601     uint32_t *tgt_max)
2602 {
2603         struct aac_cmd *acp = &softs->sync_ac;
2604         ddi_acc_handle_t acc;
2605         struct aac_fib *fibp;
2606         struct aac_ctcfg *c_cmd;
2607         struct aac_ctcfg_resp *c_resp;
2608         uint32_t scsi_method_id;
2609         struct aac_bus_info *cmd;
2610         struct aac_bus_info_response *resp;
2611         int rval;
2612 
2613         (void) aac_sync_fib_slot_bind(softs, acp);
2614         acc = acp->slotp->fib_acc_handle;
2615         fibp = acp->slotp->fibp;
2616 
2617         /* Detect MethodId */
2618         c_cmd = (struct aac_ctcfg *)&fibp->data[0];
2619         ddi_put32(acc, &c_cmd->Command, VM_ContainerConfig);
2620         ddi_put32(acc, &c_cmd->cmd, CT_GET_SCSI_METHOD);
2621         ddi_put32(acc, &c_cmd->param, 0);
2622         rval = aac_sync_fib(softs, ContainerCommand,
2623             AAC_FIB_SIZEOF(struct aac_ctcfg));
2624         c_resp = (struct aac_ctcfg_resp *)&fibp->data[0];
2625         if (rval != AACOK || ddi_get32(acc, &c_resp->Status) != 0) {
2626                 AACDB_PRINT(softs, CE_WARN,
2627                     "VM_ContainerConfig command fail");
2628                 rval = AACERR;
2629                 goto finish;
2630         }
2631         scsi_method_id = ddi_get32(acc, &c_resp->param);
2632 
2633         /* Detect phys. bus count and max. target id first */
2634         cmd = (struct aac_bus_info *)&fibp->data[0];
2635         ddi_put32(acc, &cmd->Command, VM_Ioctl);
2636         ddi_put32(acc, &cmd->ObjType, FT_DRIVE); /* physical drive */
2637         ddi_put32(acc, &cmd->MethodId, scsi_method_id);
2638         ddi_put32(acc, &cmd->ObjectId, 0);
2639         ddi_put32(acc, &cmd->CtlCmd, GetBusInfo);
2640         /*
2641          * For VM_Ioctl, the firmware uses the Header.Size filled from the
2642          * driver as the size to be returned. Therefore the driver has to use
2643          * sizeof (struct aac_bus_info_response) because it is greater than
2644          * sizeof (struct aac_bus_info).
2645          */
2646         rval = aac_sync_fib(softs, ContainerCommand,
2647             AAC_FIB_SIZEOF(struct aac_bus_info_response));
2648         resp = (struct aac_bus_info_response *)cmd;
2649 
2650         /* Scan all coordinates with INQUIRY */
2651         if ((rval != AACOK) || (ddi_get32(acc, &resp->Status) != 0)) {
2652                 AACDB_PRINT(softs, CE_WARN, "GetBusInfo command fail");
2653                 rval = AACERR;
2654                 goto finish;
2655         }
2656         *bus_max = ddi_get32(acc, &resp->BusCount);
2657         *tgt_max = ddi_get32(acc, &resp->TargetsPerBus);
2658 
2659 finish:
2660         aac_sync_fib_slot_release(softs, acp);
2661         return (AACOK);
2662 }
2663 
2664 /*
2665  * The following function comes from Adaptec:
2666  *
2667  * Routine to be called during initialization of communications with
2668  * the adapter to handle possible adapter configuration issues. When
2669  * the adapter first boots up, it examines attached drives, etc, and
2670  * potentially comes up with a new or revised configuration (relative to
2671  * what's stored in it's NVRAM). Additionally it may discover problems
2672  * that make the current physical configuration unworkable (currently
2673  * applicable only to cluster configuration issues).
2674  *
2675  * If there are no configuration issues or the issues are considered
2676  * trival by the adapter, it will set it's configuration status to
2677  * "FSACT_CONTINUE" and execute the "commit confiuguration" action
2678  * automatically on it's own.
2679  *
2680  * However, if there are non-trivial issues, the adapter will set it's
2681  * internal configuration status to "FSACT_PAUSE" or "FASCT_ABORT"
2682  * and wait for some agent on the host to issue the "\ContainerCommand
2683  * \VM_ContainerConfig\CT_COMMIT_CONFIG" FIB command to cause the
2684  * adapter to commit the new/updated configuration and enable
2685  * un-inhibited operation.  The host agent should first issue the
2686  * "\ContainerCommand\VM_ContainerConfig\CT_GET_CONFIG_STATUS" FIB
2687  * command to obtain information about config issues detected by
2688  * the adapter.
2689  *
2690  * Normally the adapter's PC BIOS will execute on the host following
2691  * adapter poweron and reset and will be responsible for querring the
2692  * adapter with CT_GET_CONFIG_STATUS and issuing the CT_COMMIT_CONFIG
2693  * command if appropriate.
2694  *
2695  * However, with the introduction of IOP reset support, the adapter may
2696  * boot up without the benefit of the adapter's PC BIOS host agent.
2697  * This routine is intended to take care of these issues in situations
2698  * where BIOS doesn't execute following adapter poweron or reset.  The
2699  * CT_COMMIT_CONFIG command is a no-op if it's already been issued, so
2700  * there is no harm in doing this when it's already been done.
2701  */
2702 static int
2703 aac_handle_adapter_config_issues(struct aac_softstate *softs)
2704 {
2705         struct aac_cmd *acp = &softs->sync_ac;
2706         ddi_acc_handle_t acc;
2707         struct aac_fib *fibp;
2708         struct aac_Container *cmd;
2709         struct aac_Container_resp *resp;
2710         struct aac_cf_status_header *cfg_sts_hdr;
2711         uint32_t resp_status;
2712         uint32_t ct_status;
2713         uint32_t cfg_stat_action;
2714         int rval;
2715 
2716         (void) aac_sync_fib_slot_bind(softs, acp);
2717         acc = acp->slotp->fib_acc_handle;
2718         fibp = acp->slotp->fibp;
2719 
2720         /* Get adapter config status */
2721         cmd = (struct aac_Container *)&fibp->data[0];
2722 
2723         bzero(cmd, sizeof (*cmd) - CT_PACKET_SIZE);
2724         ddi_put32(acc, &cmd->Command, VM_ContainerConfig);
2725         ddi_put32(acc, &cmd->CTCommand.command, CT_GET_CONFIG_STATUS);
2726         ddi_put32(acc, &cmd->CTCommand.param[CNT_SIZE],
2727             sizeof (struct aac_cf_status_header));
2728         rval = aac_sync_fib(softs, ContainerCommand,
2729             AAC_FIB_SIZEOF(struct aac_Container));
2730         resp = (struct aac_Container_resp *)cmd;
2731         cfg_sts_hdr = (struct aac_cf_status_header *)resp->CTResponse.data;
2732 
2733         resp_status = ddi_get32(acc, &resp->Status);
2734         ct_status = ddi_get32(acc, &resp->CTResponse.param[0]);
2735         if ((rval == AACOK) && (resp_status == 0) && (ct_status == CT_OK)) {
2736                 cfg_stat_action = ddi_get32(acc, &cfg_sts_hdr->action);
2737 
2738                 /* Commit configuration if it's reasonable to do so. */
2739                 if (cfg_stat_action <= CFACT_PAUSE) {
2740                         bzero(cmd, sizeof (*cmd) - CT_PACKET_SIZE);
2741                         ddi_put32(acc, &cmd->Command, VM_ContainerConfig);
2742                         ddi_put32(acc, &cmd->CTCommand.command,
2743                             CT_COMMIT_CONFIG);
2744                         rval = aac_sync_fib(softs, ContainerCommand,
2745                             AAC_FIB_SIZEOF(struct aac_Container));
2746 
2747                         resp_status = ddi_get32(acc, &resp->Status);
2748                         ct_status = ddi_get32(acc, &resp->CTResponse.param[0]);
2749                         if ((rval == AACOK) && (resp_status == 0) &&
2750                             (ct_status == CT_OK))
2751                                 /* Successful completion */
2752                                 rval = AACMPE_OK;
2753                         else
2754                                 /* Auto-commit aborted due to error(s). */
2755                                 rval = AACMPE_COMMIT_CONFIG;
2756                 } else {
2757                         /*
2758                          * Auto-commit aborted due to adapter indicating
2759                          * configuration issue(s) too dangerous to auto-commit.
2760                          */
2761                         rval = AACMPE_CONFIG_STATUS;
2762                 }
2763         } else {
2764                 cmn_err(CE_WARN, "!Configuration issue, auto-commit aborted");
2765                 rval = AACMPE_CONFIG_STATUS;
2766         }
2767 
2768         aac_sync_fib_slot_release(softs, acp);
2769         return (rval);
2770 }
2771 
2772 /*
2773  * Hardware initialization and resource allocation
2774  */
2775 static int
2776 aac_common_attach(struct aac_softstate *softs)
2777 {
2778         uint32_t status;
2779         int i;
2780         struct aac_supplement_adapter_info sinf;
2781 
2782         DBCALLED(softs, 1);
2783 
2784         /*
2785          * Do a little check here to make sure there aren't any outstanding
2786          * FIBs in the message queue. At this point there should not be and
2787          * if there are they are probably left over from another instance of
2788          * the driver like when the system crashes and the crash dump driver
2789          * gets loaded.
2790          */
2791         while (AAC_OUTB_GET(softs) != 0xfffffffful)
2792                 ;
2793 
2794         /*
2795          * Wait the card to complete booting up before do anything that
2796          * attempts to communicate with it.
2797          */
2798         status = AAC_FWSTATUS_GET(softs);
2799         if (status == AAC_SELF_TEST_FAILED || status == AAC_KERNEL_PANIC)
2800                 goto error;
2801         i = AAC_FWUP_TIMEOUT * 1000; /* set timeout */
2802         AAC_BUSYWAIT(AAC_FWSTATUS_GET(softs) & AAC_KERNEL_UP_AND_RUNNING, i);
2803         if (i == 0) {
2804                 cmn_err(CE_CONT, "?Fatal error: controller not ready");
2805                 aac_fm_ereport(softs, DDI_FM_DEVICE_NO_RESPONSE);
2806                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2807                 goto error;
2808         }
2809 
2810         /* Read and set card supported options and settings */
2811         if (aac_check_firmware(softs) == AACERR) {
2812                 aac_fm_ereport(softs, DDI_FM_DEVICE_NO_RESPONSE);
2813                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2814                 goto error;
2815         }
2816 
2817         /* Add interrupt handlers */
2818         if (aac_register_intrs(softs) == AACERR) {
2819                 cmn_err(CE_CONT,
2820                     "?Fatal error: interrupts register failed");
2821                 goto error;
2822         }
2823 
2824         /* Setup communication space with the card */
2825         if (softs->comm_space_dma_handle == NULL) {
2826                 if (aac_alloc_comm_space(softs) != AACOK)
2827                         goto error;
2828         }
2829         if (aac_setup_comm_space(softs) != AACOK) {
2830                 cmn_err(CE_CONT, "?Setup communication space failed");
2831                 aac_fm_ereport(softs, DDI_FM_DEVICE_NO_RESPONSE);
2832                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2833                 goto error;
2834         }
2835 
2836 #ifdef DEBUG
2837         if (aac_get_fw_debug_buffer(softs) != AACOK)
2838                 cmn_err(CE_CONT, "?firmware UART trace not supported");
2839 #endif
2840 
2841         /* Allocate slots */
2842         if ((softs->total_slots == 0) && (aac_create_slots(softs) != AACOK)) {
2843                 cmn_err(CE_CONT, "?Fatal error: slots allocate failed");
2844                 goto error;
2845         }
2846         AACDB_PRINT(softs, CE_NOTE, "%d slots allocated", softs->total_slots);
2847 
2848         /* Allocate FIBs */
2849         if (softs->total_fibs < softs->total_slots) {
2850                 aac_alloc_fibs(softs);
2851                 if (softs->total_fibs == 0)
2852                         goto error;
2853                 AACDB_PRINT(softs, CE_NOTE, "%d fibs allocated",
2854                     softs->total_fibs);
2855         }
2856 
2857         AAC_STATUS_CLR(softs, ~0); /* Clear out all interrupts */
2858         AAC_ENABLE_INTR(softs); /* Enable the interrupts we can handle */
2859 
2860         if (aac_get_adapter_info(softs, NULL, &sinf) == AACOK) {
2861                 softs->feature_bits = sinf.FeatureBits;
2862                 softs->support_opt2 = sinf.SupportedOptions2;
2863 
2864                 /* Get adapter names */
2865                 if (CARD_IS_UNKNOWN(softs->card)) {
2866                         char *p, *p0, *p1;
2867 
2868                         /*
2869                          * Now find the controller name in supp_adapter_info->
2870                          * AdapterTypeText. Use the first word as the vendor
2871                          * and the other words as the product name.
2872                          */
2873                         AACDB_PRINT(softs, CE_NOTE, "sinf.AdapterTypeText = "
2874                             "\"%s\"", sinf.AdapterTypeText);
2875                         p = sinf.AdapterTypeText;
2876                         p0 = p1 = NULL;
2877                         /* Skip heading spaces */
2878                         while (*p && (*p == ' ' || *p == '\t'))
2879                                 p++;
2880                         p0 = p;
2881                         while (*p && (*p != ' ' && *p != '\t'))
2882                                 p++;
2883                         /* Remove middle spaces */
2884                         while (*p && (*p == ' ' || *p == '\t'))
2885                                 *p++ = 0;
2886                         p1 = p;
2887                         /* Remove trailing spaces */
2888                         p = p1 + strlen(p1) - 1;
2889                         while (p > p1 && (*p == ' ' || *p == '\t'))
2890                                 *p-- = 0;
2891                         if (*p0 && *p1) {
2892                                 (void *)strncpy(softs->vendor_name, p0,
2893                                     AAC_VENDOR_LEN);
2894                                 (void *)strncpy(softs->product_name, p1,
2895                                     AAC_PRODUCT_LEN);
2896                         } else {
2897                                 cmn_err(CE_WARN,
2898                                     "?adapter name mis-formatted\n");
2899                                 if (*p0)
2900                                         (void *)strncpy(softs->product_name,
2901                                             p0, AAC_PRODUCT_LEN);
2902                         }
2903                 }
2904         } else {
2905                 cmn_err(CE_CONT, "?Query adapter information failed");
2906         }
2907 
2908 
2909         cmn_err(CE_NOTE,
2910             "!aac driver %d.%02d.%02d-%d, found card: " \
2911             "%s %s(pci0x%x.%x.%x.%x) at 0x%x",
2912             AAC_DRIVER_MAJOR_VERSION,
2913             AAC_DRIVER_MINOR_VERSION,
2914             AAC_DRIVER_BUGFIX_LEVEL,
2915             AAC_DRIVER_BUILD,
2916             softs->vendor_name, softs->product_name,
2917             softs->vendid, softs->devid, softs->subvendid, softs->subsysid,
2918             softs->pci_mem_base_paddr);
2919 
2920         /* Perform acceptance of adapter-detected config changes if possible */
2921         if (aac_handle_adapter_config_issues(softs) != AACMPE_OK) {
2922                 cmn_err(CE_CONT, "?Handle adapter config issues failed");
2923                 aac_fm_ereport(softs, DDI_FM_DEVICE_NO_RESPONSE);
2924                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2925                 goto error;
2926         }
2927 
2928         /* Setup containers (logical devices) */
2929         if (aac_probe_containers(softs) != AACOK) {
2930                 cmn_err(CE_CONT, "?Fatal error: get container info error");
2931                 goto error;
2932         }
2933 
2934         /* Check for JBOD support. Default disable */
2935         char *data;
2936         if (softs->feature_bits & AAC_FEATURE_SUPPORTED_JBOD) {
2937                 if ((ddi_prop_lookup_string(DDI_DEV_T_ANY, softs->devinfo_p,
2938                     0, "jbod-enable", &data) == DDI_SUCCESS)) {
2939                         if (strcmp(data, "yes") == 0) {
2940                                 AACDB_PRINT(softs, CE_NOTE,
2941                                     "Enable JBOD access");
2942                                 softs->flags |= AAC_FLAGS_JBOD;
2943                         }
2944                         ddi_prop_free(data);
2945                 }
2946         }
2947 
2948         /* Setup phys. devices */
2949         if (softs->flags & (AAC_FLAGS_NONDASD | AAC_FLAGS_JBOD)) {
2950                 uint32_t bus_max, tgt_max;
2951                 uint32_t bus, tgt;
2952                 int index;
2953 
2954                 if (aac_get_bus_info(softs, &bus_max, &tgt_max) != AACOK) {
2955                         cmn_err(CE_CONT, "?Fatal error: get bus info error");
2956                         goto error;
2957                 }
2958                 AACDB_PRINT(softs, CE_NOTE, "bus_max=%d, tgt_max=%d",
2959                     bus_max, tgt_max);
2960                 if (bus_max != softs->bus_max || tgt_max != softs->tgt_max) {
2961                         if (softs->state & AAC_STATE_RESET) {
2962                                 cmn_err(CE_WARN,
2963                                     "?Fatal error: bus map changed");
2964                                 goto error;
2965                         }
2966                         softs->bus_max = bus_max;
2967                         softs->tgt_max = tgt_max;
2968                         if (softs->nondasds) {
2969                                 kmem_free(softs->nondasds, AAC_MAX_PD(softs) * \
2970                                     sizeof (struct aac_nondasd));
2971                         }
2972                         softs->nondasds = kmem_zalloc(AAC_MAX_PD(softs) * \
2973                             sizeof (struct aac_nondasd), KM_SLEEP);
2974 
2975                         index = 0;
2976                         for (bus = 0; bus < softs->bus_max; bus++) {
2977                                 for (tgt = 0; tgt < softs->tgt_max; tgt++) {
2978                                         struct aac_nondasd *dvp =
2979                                             &softs->nondasds[index++];
2980                                         dvp->dev.type = AAC_DEV_PD;
2981                                         dvp->bus = bus;
2982                                         dvp->tid = tgt;
2983                                 }
2984                         }
2985                 }
2986         }
2987 
2988         /* Check dma & acc handles allocated in attach */
2989         if (aac_check_dma_handle(softs->comm_space_dma_handle) != DDI_SUCCESS) {
2990                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2991                 goto error;
2992         }
2993 
2994         if (aac_check_acc_handle(softs->pci_mem_handle) != DDI_SUCCESS) {
2995                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2996                 goto error;
2997         }
2998 
2999         for (i = 0; i < softs->total_slots; i++) {
3000                 if (aac_check_dma_handle(softs->io_slot[i].fib_dma_handle) !=
3001                     DDI_SUCCESS) {
3002                         ddi_fm_service_impact(softs->devinfo_p,
3003                             DDI_SERVICE_LOST);
3004                         goto error;
3005                 }
3006         }
3007 
3008         return (AACOK);
3009 error:
3010         if (softs->state & AAC_STATE_RESET)
3011                 return (AACERR);
3012         if (softs->nondasds) {
3013                 kmem_free(softs->nondasds, AAC_MAX_PD(softs) * \
3014                     sizeof (struct aac_nondasd));
3015                 softs->nondasds = NULL;
3016         }
3017         if (softs->total_fibs > 0)
3018                 aac_destroy_fibs(softs);
3019         if (softs->total_slots > 0)
3020                 aac_destroy_slots(softs);
3021         if (softs->comm_space_dma_handle)
3022                 aac_free_comm_space(softs);
3023         return (AACERR);
3024 }
3025 
3026 /*
3027  * Hardware shutdown and resource release
3028  */
3029 static void
3030 aac_common_detach(struct aac_softstate *softs)
3031 {
3032         DBCALLED(softs, 1);
3033 
3034         aac_unregister_intrs(softs);
3035 
3036         mutex_enter(&softs->io_lock);
3037         (void) aac_shutdown(softs);
3038 
3039         if (softs->nondasds) {
3040                 kmem_free(softs->nondasds, AAC_MAX_PD(softs) * \
3041                     sizeof (struct aac_nondasd));
3042                 softs->nondasds = NULL;
3043         }
3044         aac_destroy_fibs(softs);
3045         aac_destroy_slots(softs);
3046         aac_free_comm_space(softs);
3047         mutex_exit(&softs->io_lock);
3048 }
3049 
3050 /*
3051  * Send a synchronous command to the controller and wait for a result.
3052  * Indicate if the controller completed the command with an error status.
3053  */
3054 int
3055 aac_sync_mbcommand(struct aac_softstate *softs, uint32_t cmd,
3056     uint32_t arg0, uint32_t arg1, uint32_t arg2, uint32_t arg3,
3057     uint32_t *statusp)
3058 {
3059         int timeout;
3060         uint32_t status;
3061 
3062         if (statusp != NULL)
3063                 *statusp = SRB_STATUS_SUCCESS;
3064 
3065         /* Fill in mailbox */
3066         AAC_MAILBOX_SET(softs, cmd, arg0, arg1, arg2, arg3);
3067 
3068         /* Ensure the sync command doorbell flag is cleared */
3069         AAC_STATUS_CLR(softs, AAC_DB_SYNC_COMMAND);
3070 
3071         /* Then set it to signal the adapter */
3072         AAC_NOTIFY(softs, AAC_DB_SYNC_COMMAND);
3073 
3074         /* Spin waiting for the command to complete */
3075         timeout = AAC_IMMEDIATE_TIMEOUT * 1000;
3076         AAC_BUSYWAIT(AAC_STATUS_GET(softs) & AAC_DB_SYNC_COMMAND, timeout);
3077         if (!timeout) {
3078                 AACDB_PRINT(softs, CE_WARN,
3079                     "Sync command timed out after %d seconds (0x%x)!",
3080                     AAC_IMMEDIATE_TIMEOUT, AAC_FWSTATUS_GET(softs));
3081                 return (AACERR);
3082         }
3083 
3084         /* Clear the completion flag */
3085         AAC_STATUS_CLR(softs, AAC_DB_SYNC_COMMAND);
3086 
3087         /* Get the command status */
3088         status = AAC_MAILBOX_GET(softs, 0);
3089         if (statusp != NULL)
3090                 *statusp = status;
3091         if (status != SRB_STATUS_SUCCESS) {
3092                 AACDB_PRINT(softs, CE_WARN,
3093                     "Sync command fail: status = 0x%x", status);
3094                 return (AACERR);
3095         }
3096 
3097         return (AACOK);
3098 }
3099 
3100 /*
3101  * Send a synchronous FIB to the adapter and wait for its completion
3102  */
3103 static int
3104 aac_sync_fib(struct aac_softstate *softs, uint16_t cmd, uint16_t fibsize)
3105 {
3106         struct aac_cmd *acp = &softs->sync_ac;
3107 
3108         acp->flags = AAC_CMD_SYNC | AAC_CMD_IN_SYNC_SLOT;
3109         if (softs->state & AAC_STATE_INTR)
3110                 acp->flags |= AAC_CMD_NO_CB;
3111         else
3112                 acp->flags |= AAC_CMD_NO_INTR;
3113 
3114         acp->ac_comp = aac_sync_complete;
3115         acp->timeout = AAC_SYNC_TIMEOUT;
3116         acp->fib_size = fibsize;
3117 
3118         /*
3119          * Only need to setup sync fib header, caller should have init
3120          * fib data
3121          */
3122         aac_cmd_fib_header(softs, acp, cmd);
3123 
3124         (void) ddi_dma_sync(acp->slotp->fib_dma_handle, 0, fibsize,
3125             DDI_DMA_SYNC_FORDEV);
3126 
3127         aac_start_io(softs, acp);
3128 
3129         if (softs->state & AAC_STATE_INTR)
3130                 return (aac_do_sync_io(softs, acp));
3131         else
3132                 return (aac_do_poll_io(softs, acp));
3133 }
3134 
3135 static void
3136 aac_cmd_initq(struct aac_cmd_queue *q)
3137 {
3138         q->q_head = NULL;
3139         q->q_tail = (struct aac_cmd *)&q->q_head;
3140 }
3141 
3142 /*
3143  * Remove a cmd from the head of q
3144  */
3145 static struct aac_cmd *
3146 aac_cmd_dequeue(struct aac_cmd_queue *q)
3147 {
3148         struct aac_cmd *acp;
3149 
3150         _NOTE(ASSUMING_PROTECTED(*q))
3151 
3152         if ((acp = q->q_head) != NULL) {
3153                 if ((q->q_head = acp->next) != NULL)
3154                         acp->next = NULL;
3155                 else
3156                         q->q_tail = (struct aac_cmd *)&q->q_head;
3157                 acp->prev = NULL;
3158         }
3159         return (acp);
3160 }
3161 
3162 /*
3163  * Add a cmd to the tail of q
3164  */
3165 static void
3166 aac_cmd_enqueue(struct aac_cmd_queue *q, struct aac_cmd *acp)
3167 {
3168         ASSERT(acp->next == NULL);
3169         acp->prev = q->q_tail;
3170         q->q_tail->next = acp;
3171         q->q_tail = acp;
3172 }
3173 
3174 /*
3175  * Remove the cmd ac from q
3176  */
3177 static void
3178 aac_cmd_delete(struct aac_cmd_queue *q, struct aac_cmd *acp)
3179 {
3180         if (acp->prev) {
3181                 if ((acp->prev->next = acp->next) != NULL) {
3182                         acp->next->prev = acp->prev;
3183                         acp->next = NULL;
3184                 } else {
3185                         q->q_tail = acp->prev;
3186                 }
3187                 acp->prev = NULL;
3188         }
3189         /* ac is not in the queue */
3190 }
3191 
3192 /*
3193  * Atomically insert an entry into the nominated queue, returns 0 on success or
3194  * AACERR if the queue is full.
3195  *
3196  * Note: it would be more efficient to defer notifying the controller in
3197  *       the case where we may be inserting several entries in rapid succession,
3198  *       but implementing this usefully may be difficult (it would involve a
3199  *       separate queue/notify interface).
3200  */
3201 static int
3202 aac_fib_enqueue(struct aac_softstate *softs, int queue, uint32_t fib_addr,
3203     uint32_t fib_size)
3204 {
3205         ddi_dma_handle_t dma = softs->comm_space_dma_handle;
3206         ddi_acc_handle_t acc = softs->comm_space_acc_handle;
3207         uint32_t pi, ci;
3208 
3209         DBCALLED(softs, 2);
3210 
3211         ASSERT(queue == AAC_ADAP_NORM_CMD_Q || queue == AAC_ADAP_NORM_RESP_Q);
3212 
3213         /* Get the producer/consumer indices */
3214         (void) ddi_dma_sync(dma, (uintptr_t)softs->qtablep->qt_qindex[queue] - \
3215             (uintptr_t)softs->comm_space, sizeof (uint32_t) * 2,
3216             DDI_DMA_SYNC_FORCPU);
3217         if (aac_check_dma_handle(dma) != DDI_SUCCESS) {
3218                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
3219                 return (AACERR);
3220         }
3221 
3222         pi = ddi_get32(acc,
3223             &softs->qtablep->qt_qindex[queue][AAC_PRODUCER_INDEX]);
3224         ci = ddi_get32(acc,
3225             &softs->qtablep->qt_qindex[queue][AAC_CONSUMER_INDEX]);
3226 
3227         /*
3228          * Wrap the queue first before we check the queue to see
3229          * if it is full
3230          */
3231         if (pi >= aac_qinfo[queue].size)
3232                 pi = 0;
3233 
3234         /* XXX queue full */
3235         if ((pi + 1) == ci)
3236                 return (AACERR);
3237 
3238         /* Fill in queue entry */
3239         ddi_put32(acc, &((softs->qentries[queue] + pi)->aq_fib_size), fib_size);
3240         ddi_put32(acc, &((softs->qentries[queue] + pi)->aq_fib_addr), fib_addr);
3241         (void) ddi_dma_sync(dma, (uintptr_t)(softs->qentries[queue] + pi) - \
3242             (uintptr_t)softs->comm_space, sizeof (struct aac_queue_entry),
3243             DDI_DMA_SYNC_FORDEV);
3244 
3245         /* Update producer index */
3246         ddi_put32(acc, &softs->qtablep->qt_qindex[queue][AAC_PRODUCER_INDEX],
3247             pi + 1);
3248         (void) ddi_dma_sync(dma,
3249             (uintptr_t)&softs->qtablep->qt_qindex[queue][AAC_PRODUCER_INDEX] - \
3250             (uintptr_t)softs->comm_space, sizeof (uint32_t),
3251             DDI_DMA_SYNC_FORDEV);
3252 
3253         if (aac_qinfo[queue].notify != 0)
3254                 AAC_NOTIFY(softs, aac_qinfo[queue].notify);
3255         return (AACOK);
3256 }
3257 
3258 /*
3259  * Atomically remove one entry from the nominated queue, returns 0 on
3260  * success or AACERR if the queue is empty.
3261  */
3262 static int
3263 aac_fib_dequeue(struct aac_softstate *softs, int queue, int *idxp)
3264 {
3265         ddi_acc_handle_t acc = softs->comm_space_acc_handle;
3266         ddi_dma_handle_t dma = softs->comm_space_dma_handle;
3267         uint32_t pi, ci;
3268         int unfull = 0;
3269 
3270         DBCALLED(softs, 2);
3271 
3272         ASSERT(idxp);
3273 
3274         /* Get the producer/consumer indices */
3275         (void) ddi_dma_sync(dma, (uintptr_t)softs->qtablep->qt_qindex[queue] - \
3276             (uintptr_t)softs->comm_space, sizeof (uint32_t) * 2,
3277             DDI_DMA_SYNC_FORCPU);
3278         pi = ddi_get32(acc,
3279             &softs->qtablep->qt_qindex[queue][AAC_PRODUCER_INDEX]);
3280         ci = ddi_get32(acc,
3281             &softs->qtablep->qt_qindex[queue][AAC_CONSUMER_INDEX]);
3282 
3283         /* Check for queue empty */
3284         if (ci == pi)
3285                 return (AACERR);
3286 
3287         if (pi >= aac_qinfo[queue].size)
3288                 pi = 0;
3289 
3290         /* Check for queue full */
3291         if (ci == pi + 1)
3292                 unfull = 1;
3293 
3294         /*
3295          * The controller does not wrap the queue,
3296          * so we have to do it by ourselves
3297          */
3298         if (ci >= aac_qinfo[queue].size)
3299                 ci = 0;
3300 
3301         /* Fetch the entry */
3302         (void) ddi_dma_sync(dma, (uintptr_t)(softs->qentries[queue] + pi) - \
3303             (uintptr_t)softs->comm_space, sizeof (struct aac_queue_entry),
3304             DDI_DMA_SYNC_FORCPU);
3305         if (aac_check_dma_handle(dma) != DDI_SUCCESS) {
3306                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
3307                 return (AACERR);
3308         }
3309 
3310         switch (queue) {
3311         case AAC_HOST_NORM_RESP_Q:
3312         case AAC_HOST_HIGH_RESP_Q:
3313                 *idxp = ddi_get32(acc,
3314                     &(softs->qentries[queue] + ci)->aq_fib_addr);
3315                 break;
3316 
3317         case AAC_HOST_NORM_CMD_Q:
3318         case AAC_HOST_HIGH_CMD_Q:
3319                 *idxp = ddi_get32(acc,
3320                     &(softs->qentries[queue] + ci)->aq_fib_addr) / AAC_FIB_SIZE;
3321                 break;
3322 
3323         default:
3324                 cmn_err(CE_NOTE, "!Invalid queue in aac_fib_dequeue()");
3325                 return (AACERR);
3326         }
3327 
3328         /* Update consumer index */
3329         ddi_put32(acc, &softs->qtablep->qt_qindex[queue][AAC_CONSUMER_INDEX],
3330             ci + 1);
3331         (void) ddi_dma_sync(dma,
3332             (uintptr_t)&softs->qtablep->qt_qindex[queue][AAC_CONSUMER_INDEX] - \
3333             (uintptr_t)softs->comm_space, sizeof (uint32_t),
3334             DDI_DMA_SYNC_FORDEV);
3335 
3336         if (unfull && aac_qinfo[queue].notify != 0)
3337                 AAC_NOTIFY(softs, aac_qinfo[queue].notify);
3338         return (AACOK);
3339 }
3340 
3341 static struct aac_mntinforesp *
3342 aac_get_mntinfo(struct aac_softstate *softs, int cid)
3343 {
3344         ddi_acc_handle_t acc = softs->sync_ac.slotp->fib_acc_handle;
3345         struct aac_fib *fibp = softs->sync_ac.slotp->fibp;
3346         struct aac_mntinfo *mi = (struct aac_mntinfo *)&fibp->data[0];
3347         struct aac_mntinforesp *mir;
3348 
3349         ddi_put32(acc, &mi->Command, /* Use 64-bit LBA if enabled */
3350             (softs->flags & AAC_FLAGS_LBA_64BIT) ?
3351             VM_NameServe64 : VM_NameServe);
3352         ddi_put32(acc, &mi->MntType, FT_FILESYS);
3353         ddi_put32(acc, &mi->MntCount, cid);
3354 
3355         if (aac_sync_fib(softs, ContainerCommand,
3356             AAC_FIB_SIZEOF(struct aac_mntinfo)) == AACERR) {
3357                 AACDB_PRINT(softs, CE_WARN, "Error probe container %d", cid);
3358                 return (NULL);
3359         }
3360 
3361         mir = (struct aac_mntinforesp *)&fibp->data[0];
3362         if (ddi_get32(acc, &mir->Status) == ST_OK)
3363                 return (mir);
3364         return (NULL);
3365 }
3366 
3367 static int
3368 aac_get_container_count(struct aac_softstate *softs, int *count)
3369 {
3370         ddi_acc_handle_t acc;
3371         struct aac_mntinforesp *mir;
3372         int rval;
3373 
3374         (void) aac_sync_fib_slot_bind(softs, &softs->sync_ac);
3375         acc = softs->sync_ac.slotp->fib_acc_handle;
3376 
3377         if ((mir = aac_get_mntinfo(softs, 0)) == NULL) {
3378                 rval = AACERR;
3379                 goto finish;
3380         }
3381         *count = ddi_get32(acc, &mir->MntRespCount);
3382         if (*count > AAC_MAX_LD) {
3383                 AACDB_PRINT(softs, CE_CONT,
3384                     "container count(%d) > AAC_MAX_LD", *count);
3385                 rval = AACERR;
3386                 goto finish;
3387         }
3388         rval = AACOK;
3389 
3390 finish:
3391         aac_sync_fib_slot_release(softs, &softs->sync_ac);
3392         return (rval);
3393 }
3394 
3395 static int
3396 aac_get_container_uid(struct aac_softstate *softs, uint32_t cid, uint32_t *uid)
3397 {
3398         ddi_acc_handle_t acc = softs->sync_ac.slotp->fib_acc_handle;
3399         struct aac_Container *ct = (struct aac_Container *) \
3400             &softs->sync_ac.slotp->fibp->data[0];
3401 
3402         bzero(ct, sizeof (*ct) - CT_PACKET_SIZE);
3403         ddi_put32(acc, &ct->Command, VM_ContainerConfig);
3404         ddi_put32(acc, &ct->CTCommand.command, CT_CID_TO_32BITS_UID);
3405         ddi_put32(acc, &ct->CTCommand.param[0], cid);
3406 
3407         if (aac_sync_fib(softs, ContainerCommand,
3408             AAC_FIB_SIZEOF(struct aac_Container)) == AACERR)
3409                 return (AACERR);
3410         if (ddi_get32(acc, &ct->CTCommand.param[0]) != CT_OK)
3411                 return (AACERR);
3412 
3413         *uid = ddi_get32(acc, &ct->CTCommand.param[1]);
3414         return (AACOK);
3415 }
3416 
3417 /*
3418  * Request information of the container cid
3419  */
3420 static struct aac_mntinforesp *
3421 aac_get_container_info(struct aac_softstate *softs, int cid)
3422 {
3423         ddi_acc_handle_t acc = softs->sync_ac.slotp->fib_acc_handle;
3424         struct aac_mntinforesp *mir;
3425         int rval_uid;
3426         uint32_t uid;
3427 
3428         /* Get container UID first so that it will not overwrite mntinfo */
3429         rval_uid = aac_get_container_uid(softs, cid, &uid);
3430 
3431         /* Get container basic info */
3432         if ((mir = aac_get_mntinfo(softs, cid)) == NULL) {
3433                 AACDB_PRINT(softs, CE_CONT,
3434                     "query container %d info failed", cid);
3435                 return (NULL);
3436         }
3437         if (ddi_get32(acc, &mir->MntObj.VolType) == CT_NONE)
3438                 return (mir);
3439         if (rval_uid != AACOK) {
3440                 AACDB_PRINT(softs, CE_CONT,
3441                     "query container %d uid failed", cid);
3442                 return (NULL);
3443         }
3444 
3445         ddi_put32(acc, &mir->Status, uid);
3446         return (mir);
3447 }
3448 
3449 static enum aac_cfg_event
3450 aac_probe_container(struct aac_softstate *softs, uint32_t cid)
3451 {
3452         enum aac_cfg_event event = AAC_CFG_NULL_NOEXIST;
3453         struct aac_container *dvp = &softs->containers[cid];
3454         struct aac_mntinforesp *mir;
3455         ddi_acc_handle_t acc;
3456 
3457         (void) aac_sync_fib_slot_bind(softs, &softs->sync_ac);
3458         acc = softs->sync_ac.slotp->fib_acc_handle;
3459 
3460         /* Get container basic info */
3461         if ((mir = aac_get_container_info(softs, cid)) == NULL) {
3462                 /* AAC_CFG_NULL_NOEXIST */
3463                 goto finish;
3464         }
3465 
3466         if (ddi_get32(acc, &mir->MntObj.VolType) == CT_NONE) {
3467                 if (AAC_DEV_IS_VALID(&dvp->dev)) {
3468                         AACDB_PRINT(softs, CE_NOTE,
3469                             ">>> Container %d deleted", cid);
3470                         dvp->dev.flags &= ~AAC_DFLAG_VALID;
3471                         event = AAC_CFG_DELETE;
3472                 }
3473                 /* AAC_CFG_NULL_NOEXIST */
3474         } else {
3475                 uint64_t size;
3476                 uint32_t uid;
3477 
3478                 event = AAC_CFG_NULL_EXIST;
3479 
3480                 size = AAC_MIR_SIZE(softs, acc, mir);
3481                 uid = ddi_get32(acc, &mir->Status);
3482                 if (AAC_DEV_IS_VALID(&dvp->dev)) {
3483                         if (dvp->uid != uid) {
3484                                 AACDB_PRINT(softs, CE_WARN,
3485                                     ">>> Container %u uid changed to %d",
3486                                     cid, uid);
3487                                 dvp->uid = uid;
3488                                 event = AAC_CFG_CHANGE;
3489                         }
3490                         if (dvp->size != size) {
3491                                 AACDB_PRINT(softs, CE_NOTE,
3492                                     ">>> Container %u size changed to %"PRIu64,
3493                                     cid, size);
3494                                 dvp->size = size;
3495                                 event = AAC_CFG_CHANGE;
3496                         }
3497                 } else { /* Init new container */
3498                         AACDB_PRINT(softs, CE_NOTE,
3499                             ">>> Container %d added: " \
3500                             "size=0x%x.%08x, type=%d, name=%s",
3501                             cid,
3502                             ddi_get32(acc, &mir->MntObj.CapacityHigh),
3503                             ddi_get32(acc, &mir->MntObj.Capacity),
3504                             ddi_get32(acc, &mir->MntObj.VolType),
3505                             mir->MntObj.FileSystemName);
3506                         dvp->dev.flags |= AAC_DFLAG_VALID;
3507                         dvp->dev.type = AAC_DEV_LD;
3508 
3509                         dvp->cid = cid;
3510                         dvp->uid = uid;
3511                         dvp->size = size;
3512                         dvp->locked = 0;
3513                         dvp->deleted = 0;
3514 
3515                         event = AAC_CFG_ADD;
3516                 }
3517         }
3518 
3519 finish:
3520         aac_sync_fib_slot_release(softs, &softs->sync_ac);
3521         return (event);
3522 }
3523 
3524 /*
3525  * Do a rescan of all the possible containers and update the container list
3526  * with newly online/offline containers, and prepare for autoconfiguration.
3527  */
3528 static int
3529 aac_probe_containers(struct aac_softstate *softs)
3530 {
3531         int i, count, total;
3532 
3533         /* Loop over possible containers */
3534         count = softs->container_count;
3535         if (aac_get_container_count(softs, &count) == AACERR)
3536                 return (AACERR);
3537 
3538         for (i = total = 0; i < count; i++) {
3539                 enum aac_cfg_event event = aac_probe_container(softs, i);
3540                 if ((event != AAC_CFG_NULL_NOEXIST) &&
3541                     (event != AAC_CFG_NULL_EXIST)) {
3542                         (void) aac_handle_dr(softs, i, -1, event);
3543                         total++;
3544                 }
3545         }
3546 
3547         if (count < softs->container_count) {
3548                 struct aac_container *dvp;
3549 
3550                 for (dvp = &softs->containers[count];
3551                     dvp < &softs->containers[softs->container_count]; dvp++) {
3552                         if (!AAC_DEV_IS_VALID(&dvp->dev))
3553                                 continue;
3554                         AACDB_PRINT(softs, CE_NOTE, ">>> Container %d deleted",
3555                             dvp->cid);
3556                         dvp->dev.flags &= ~AAC_DFLAG_VALID;
3557                         (void) aac_handle_dr(softs, dvp->cid, -1,
3558                             AAC_CFG_DELETE);
3559                 }
3560         }
3561 
3562         softs->container_count = count;
3563         AACDB_PRINT(softs, CE_CONT, "?Total %d container(s) found", total);
3564         return (AACOK);
3565 }
3566 
3567 static int
3568 aac_probe_jbod(struct aac_softstate *softs, int tgt, int event)
3569 {
3570         ASSERT(AAC_MAX_LD <= tgt);
3571         ASSERT(tgt < AAC_MAX_DEV(softs));
3572         struct aac_device *dvp;
3573         dvp = AAC_DEV(softs, tgt);
3574 
3575         switch (event) {
3576         case AAC_CFG_ADD:
3577                 AACDB_PRINT(softs, CE_NOTE,
3578                     ">>> Jbod %d added", tgt - AAC_MAX_LD);
3579                 dvp->flags |= AAC_DFLAG_VALID;
3580                 dvp->type = AAC_DEV_PD;
3581                 break;
3582         case AAC_CFG_DELETE:
3583                 AACDB_PRINT(softs, CE_NOTE,
3584                     ">>> Jbod %d deleted", tgt - AAC_MAX_LD);
3585                 dvp->flags &= ~AAC_DFLAG_VALID;
3586                 break;
3587         default:
3588                 return (AACERR);
3589         }
3590         (void) aac_handle_dr(softs, tgt, 0, event);
3591         return (AACOK);
3592 }
3593 
3594 static int
3595 aac_alloc_comm_space(struct aac_softstate *softs)
3596 {
3597         size_t rlen;
3598         ddi_dma_cookie_t cookie;
3599         uint_t cookien;
3600 
3601         /* Allocate DMA for comm. space */
3602         if (ddi_dma_alloc_handle(
3603             softs->devinfo_p,
3604             &softs->addr_dma_attr,
3605             DDI_DMA_SLEEP,
3606             NULL,
3607             &softs->comm_space_dma_handle) != DDI_SUCCESS) {
3608                 AACDB_PRINT(softs, CE_WARN,
3609                     "Cannot alloc dma handle for communication area");
3610                 goto error;
3611         }
3612         if (ddi_dma_mem_alloc(
3613             softs->comm_space_dma_handle,
3614             sizeof (struct aac_comm_space),
3615             &softs->acc_attr,
3616             DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3617             DDI_DMA_SLEEP,
3618             NULL,
3619             (caddr_t *)&softs->comm_space,
3620             &rlen,
3621             &softs->comm_space_acc_handle) != DDI_SUCCESS) {
3622                 AACDB_PRINT(softs, CE_WARN,
3623                     "Cannot alloc mem for communication area");
3624                 goto error;
3625         }
3626         if (ddi_dma_addr_bind_handle(
3627             softs->comm_space_dma_handle,
3628             NULL,
3629             (caddr_t)softs->comm_space,
3630             sizeof (struct aac_comm_space),
3631             DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3632             DDI_DMA_SLEEP,
3633             NULL,
3634             &cookie,
3635             &cookien) != DDI_DMA_MAPPED) {
3636                 AACDB_PRINT(softs, CE_WARN,
3637                     "DMA bind failed for communication area");
3638                 goto error;
3639         }
3640         softs->comm_space_phyaddr = cookie.dmac_address;
3641 
3642         return (AACOK);
3643 error:
3644         if (softs->comm_space_acc_handle) {
3645                 ddi_dma_mem_free(&softs->comm_space_acc_handle);
3646                 softs->comm_space_acc_handle = NULL;
3647         }
3648         if (softs->comm_space_dma_handle) {
3649                 ddi_dma_free_handle(&softs->comm_space_dma_handle);
3650                 softs->comm_space_dma_handle = NULL;
3651         }
3652         return (AACERR);
3653 }
3654 
3655 static void
3656 aac_free_comm_space(struct aac_softstate *softs)
3657 {
3658 
3659         (void) ddi_dma_unbind_handle(softs->comm_space_dma_handle);
3660         ddi_dma_mem_free(&softs->comm_space_acc_handle);
3661         softs->comm_space_acc_handle = NULL;
3662         ddi_dma_free_handle(&softs->comm_space_dma_handle);
3663         softs->comm_space_dma_handle = NULL;
3664         softs->comm_space_phyaddr = NULL;
3665 }
3666 
3667 /*
3668  * Initialize the data structures that are required for the communication
3669  * interface to operate
3670  */
3671 static int
3672 aac_setup_comm_space(struct aac_softstate *softs)
3673 {
3674         ddi_dma_handle_t dma = softs->comm_space_dma_handle;
3675         ddi_acc_handle_t acc = softs->comm_space_acc_handle;
3676         uint32_t comm_space_phyaddr;
3677         struct aac_adapter_init *initp;
3678         int qoffset;
3679 
3680         comm_space_phyaddr = softs->comm_space_phyaddr;
3681 
3682         /* Setup adapter init struct */
3683         initp = &softs->comm_space->init_data;
3684         bzero(initp, sizeof (struct aac_adapter_init));
3685 
3686         ddi_put32(acc, &initp->InitStructRevision, AAC_INIT_STRUCT_REVISION);
3687         ddi_put32(acc, &initp->HostElapsedSeconds, ddi_get_time());
3688 
3689         /* Setup new/old comm. specific data */
3690         if (softs->flags & AAC_FLAGS_RAW_IO) {
3691                 uint32_t init_flags = 0;
3692 
3693                 if (softs->flags & AAC_FLAGS_NEW_COMM)
3694                         init_flags |= AAC_INIT_FLAGS_NEW_COMM_SUPPORTED;
3695                 /* AAC_SUPPORTED_POWER_MANAGEMENT */
3696                 init_flags |= AAC_INIT_FLAGS_DRIVER_SUPPORTS_PM;
3697                 init_flags |= AAC_INIT_FLAGS_DRIVER_USES_UTC_TIME;
3698 
3699                 ddi_put32(acc, &initp->InitStructRevision,
3700                     AAC_INIT_STRUCT_REVISION_4);
3701                 ddi_put32(acc, &initp->InitFlags, init_flags);
3702                 /* Setup the preferred settings */
3703                 ddi_put32(acc, &initp->MaxIoCommands, softs->aac_max_fibs);
3704                 ddi_put32(acc, &initp->MaxIoSize,
3705                     (softs->aac_max_sectors << 9));
3706                 ddi_put32(acc, &initp->MaxFibSize, softs->aac_max_fib_size);
3707         } else {
3708                 /*
3709                  * Tells the adapter about the physical location of various
3710                  * important shared data structures
3711                  */
3712                 ddi_put32(acc, &initp->AdapterFibsPhysicalAddress,
3713                     comm_space_phyaddr + \
3714                     offsetof(struct aac_comm_space, adapter_fibs));
3715                 ddi_put32(acc, &initp->AdapterFibsVirtualAddress, 0);
3716                 ddi_put32(acc, &initp->AdapterFibAlign, AAC_FIB_SIZE);
3717                 ddi_put32(acc, &initp->AdapterFibsSize,
3718                     AAC_ADAPTER_FIBS * AAC_FIB_SIZE);
3719                 ddi_put32(acc, &initp->PrintfBufferAddress,
3720                     comm_space_phyaddr + \
3721                     offsetof(struct aac_comm_space, adapter_print_buf));
3722                 ddi_put32(acc, &initp->PrintfBufferSize,
3723                     AAC_ADAPTER_PRINT_BUFSIZE);
3724                 ddi_put32(acc, &initp->MiniPortRevision,
3725                     AAC_INIT_STRUCT_MINIPORT_REVISION);
3726                 ddi_put32(acc, &initp->HostPhysMemPages, AAC_MAX_PFN);
3727 
3728                 qoffset = (comm_space_phyaddr + \
3729                     offsetof(struct aac_comm_space, qtable)) % \
3730                     AAC_QUEUE_ALIGN;
3731                 if (qoffset)
3732                         qoffset = AAC_QUEUE_ALIGN - qoffset;
3733                 softs->qtablep = (struct aac_queue_table *) \
3734                     ((char *)&softs->comm_space->qtable + qoffset);
3735                 ddi_put32(acc, &initp->CommHeaderAddress, comm_space_phyaddr + \
3736                     offsetof(struct aac_comm_space, qtable) + qoffset);
3737 
3738                 /* Init queue table */
3739                 ddi_put32(acc, &softs->qtablep-> \
3740                     qt_qindex[AAC_HOST_NORM_CMD_Q][AAC_PRODUCER_INDEX],
3741                     AAC_HOST_NORM_CMD_ENTRIES);
3742                 ddi_put32(acc, &softs->qtablep-> \
3743                     qt_qindex[AAC_HOST_NORM_CMD_Q][AAC_CONSUMER_INDEX],
3744                     AAC_HOST_NORM_CMD_ENTRIES);
3745                 ddi_put32(acc, &softs->qtablep-> \
3746                     qt_qindex[AAC_HOST_HIGH_CMD_Q][AAC_PRODUCER_INDEX],
3747                     AAC_HOST_HIGH_CMD_ENTRIES);
3748                 ddi_put32(acc, &softs->qtablep-> \
3749                     qt_qindex[AAC_HOST_HIGH_CMD_Q][AAC_CONSUMER_INDEX],
3750                     AAC_HOST_HIGH_CMD_ENTRIES);
3751                 ddi_put32(acc, &softs->qtablep-> \
3752                     qt_qindex[AAC_ADAP_NORM_CMD_Q][AAC_PRODUCER_INDEX],
3753                     AAC_ADAP_NORM_CMD_ENTRIES);
3754                 ddi_put32(acc, &softs->qtablep-> \
3755                     qt_qindex[AAC_ADAP_NORM_CMD_Q][AAC_CONSUMER_INDEX],
3756                     AAC_ADAP_NORM_CMD_ENTRIES);
3757                 ddi_put32(acc, &softs->qtablep-> \
3758                     qt_qindex[AAC_ADAP_HIGH_CMD_Q][AAC_PRODUCER_INDEX],
3759                     AAC_ADAP_HIGH_CMD_ENTRIES);
3760                 ddi_put32(acc, &softs->qtablep-> \
3761                     qt_qindex[AAC_ADAP_HIGH_CMD_Q][AAC_CONSUMER_INDEX],
3762                     AAC_ADAP_HIGH_CMD_ENTRIES);
3763                 ddi_put32(acc, &softs->qtablep-> \
3764                     qt_qindex[AAC_HOST_NORM_RESP_Q][AAC_PRODUCER_INDEX],
3765                     AAC_HOST_NORM_RESP_ENTRIES);
3766                 ddi_put32(acc, &softs->qtablep-> \
3767                     qt_qindex[AAC_HOST_NORM_RESP_Q][AAC_CONSUMER_INDEX],
3768                     AAC_HOST_NORM_RESP_ENTRIES);
3769                 ddi_put32(acc, &softs->qtablep-> \
3770                     qt_qindex[AAC_HOST_HIGH_RESP_Q][AAC_PRODUCER_INDEX],
3771                     AAC_HOST_HIGH_RESP_ENTRIES);
3772                 ddi_put32(acc, &softs->qtablep-> \
3773                     qt_qindex[AAC_HOST_HIGH_RESP_Q][AAC_CONSUMER_INDEX],
3774                     AAC_HOST_HIGH_RESP_ENTRIES);
3775                 ddi_put32(acc, &softs->qtablep-> \
3776                     qt_qindex[AAC_ADAP_NORM_RESP_Q][AAC_PRODUCER_INDEX],
3777                     AAC_ADAP_NORM_RESP_ENTRIES);
3778                 ddi_put32(acc, &softs->qtablep-> \
3779                     qt_qindex[AAC_ADAP_NORM_RESP_Q][AAC_CONSUMER_INDEX],
3780                     AAC_ADAP_NORM_RESP_ENTRIES);
3781                 ddi_put32(acc, &softs->qtablep-> \
3782                     qt_qindex[AAC_ADAP_HIGH_RESP_Q][AAC_PRODUCER_INDEX],
3783                     AAC_ADAP_HIGH_RESP_ENTRIES);
3784                 ddi_put32(acc, &softs->qtablep-> \
3785                     qt_qindex[AAC_ADAP_HIGH_RESP_Q][AAC_CONSUMER_INDEX],
3786                     AAC_ADAP_HIGH_RESP_ENTRIES);
3787 
3788                 /* Init queue entries */
3789                 softs->qentries[AAC_HOST_NORM_CMD_Q] =
3790                     &softs->qtablep->qt_HostNormCmdQueue[0];
3791                 softs->qentries[AAC_HOST_HIGH_CMD_Q] =
3792                     &softs->qtablep->qt_HostHighCmdQueue[0];
3793                 softs->qentries[AAC_ADAP_NORM_CMD_Q] =
3794                     &softs->qtablep->qt_AdapNormCmdQueue[0];
3795                 softs->qentries[AAC_ADAP_HIGH_CMD_Q] =
3796                     &softs->qtablep->qt_AdapHighCmdQueue[0];
3797                 softs->qentries[AAC_HOST_NORM_RESP_Q] =
3798                     &softs->qtablep->qt_HostNormRespQueue[0];
3799                 softs->qentries[AAC_HOST_HIGH_RESP_Q] =
3800                     &softs->qtablep->qt_HostHighRespQueue[0];
3801                 softs->qentries[AAC_ADAP_NORM_RESP_Q] =
3802                     &softs->qtablep->qt_AdapNormRespQueue[0];
3803                 softs->qentries[AAC_ADAP_HIGH_RESP_Q] =
3804                     &softs->qtablep->qt_AdapHighRespQueue[0];
3805         }
3806         (void) ddi_dma_sync(dma, 0, 0, DDI_DMA_SYNC_FORDEV);
3807 
3808         /* Send init structure to the card */
3809         if (aac_sync_mbcommand(softs, AAC_MONKER_INITSTRUCT,
3810             comm_space_phyaddr + \
3811             offsetof(struct aac_comm_space, init_data),
3812             0, 0, 0, NULL) == AACERR) {
3813                 AACDB_PRINT(softs, CE_WARN,
3814                     "Cannot send init structure to adapter");
3815                 return (AACERR);
3816         }
3817 
3818         return (AACOK);
3819 }
3820 
3821 static uchar_t *
3822 aac_vendor_id(struct aac_softstate *softs, uchar_t *buf)
3823 {
3824         (void) memset(buf, ' ', AAC_VENDOR_LEN);
3825         bcopy(softs->vendor_name, buf, strlen(softs->vendor_name));
3826         return (buf + AAC_VENDOR_LEN);
3827 }
3828 
3829 static uchar_t *
3830 aac_product_id(struct aac_softstate *softs, uchar_t *buf)
3831 {
3832         (void) memset(buf, ' ', AAC_PRODUCT_LEN);
3833         bcopy(softs->product_name, buf, strlen(softs->product_name));
3834         return (buf + AAC_PRODUCT_LEN);
3835 }
3836 
3837 /*
3838  * Construct unit serial number from container uid
3839  */
3840 static uchar_t *
3841 aac_lun_serialno(struct aac_softstate *softs, int tgt, uchar_t *buf)
3842 {
3843         int i, d;
3844         uint32_t uid;
3845 
3846         ASSERT(tgt >= 0 && tgt < AAC_MAX_LD);
3847 
3848         uid = softs->containers[tgt].uid;
3849         for (i = 7; i >= 0; i--) {
3850                 d = uid & 0xf;
3851                 buf[i] = d > 9 ? 'A' + (d - 0xa) : '0' + d;
3852                 uid >>= 4;
3853         }
3854         return (buf + 8);
3855 }
3856 
3857 /*
3858  * SPC-3 7.5 INQUIRY command implementation
3859  */
3860 static void
3861 aac_inquiry(struct aac_softstate *softs, struct scsi_pkt *pkt,
3862     union scsi_cdb *cdbp, struct buf *bp)
3863 {
3864         int tgt = pkt->pkt_address.a_target;
3865         char *b_addr = NULL;
3866         uchar_t page = cdbp->cdb_opaque[2];
3867 
3868         if (cdbp->cdb_opaque[1] & AAC_CDB_INQUIRY_CMDDT) {
3869                 /* Command Support Data is not supported */
3870                 aac_set_arq_data(pkt, KEY_ILLEGAL_REQUEST, 0x24, 0x00, 0);
3871                 return;
3872         }
3873 
3874         if (bp && bp->b_un.b_addr && bp->b_bcount) {
3875                 if (bp->b_flags & (B_PHYS | B_PAGEIO))
3876                         bp_mapin(bp);
3877                 b_addr = bp->b_un.b_addr;
3878         }
3879 
3880         if (cdbp->cdb_opaque[1] & AAC_CDB_INQUIRY_EVPD) {
3881                 uchar_t *vpdp = (uchar_t *)b_addr;
3882                 uchar_t *idp, *sp;
3883 
3884                 /* SPC-3 8.4 Vital product data parameters */
3885                 switch (page) {
3886                 case 0x00:
3887                         /* Supported VPD pages */
3888                         if (vpdp == NULL ||
3889                             bp->b_bcount < (AAC_VPD_PAGE_DATA + 3))
3890                                 return;
3891                         bzero(vpdp, AAC_VPD_PAGE_LENGTH);
3892                         vpdp[AAC_VPD_PAGE_CODE] = 0x00;
3893                         vpdp[AAC_VPD_PAGE_LENGTH] = 3;
3894 
3895                         vpdp[AAC_VPD_PAGE_DATA] = 0x00;
3896                         vpdp[AAC_VPD_PAGE_DATA + 1] = 0x80;
3897                         vpdp[AAC_VPD_PAGE_DATA + 2] = 0x83;
3898 
3899                         pkt->pkt_state |= STATE_XFERRED_DATA;
3900                         break;
3901 
3902                 case 0x80:
3903                         /* Unit serial number page */
3904                         if (vpdp == NULL ||
3905                             bp->b_bcount < (AAC_VPD_PAGE_DATA + 8))
3906                                 return;
3907                         bzero(vpdp, AAC_VPD_PAGE_LENGTH);
3908                         vpdp[AAC_VPD_PAGE_CODE] = 0x80;
3909                         vpdp[AAC_VPD_PAGE_LENGTH] = 8;
3910 
3911                         sp = &vpdp[AAC_VPD_PAGE_DATA];
3912                         (void) aac_lun_serialno(softs, tgt, sp);
3913 
3914                         pkt->pkt_state |= STATE_XFERRED_DATA;
3915                         break;
3916 
3917                 case 0x83:
3918                         /* Device identification page */
3919                         if (vpdp == NULL ||
3920                             bp->b_bcount < (AAC_VPD_PAGE_DATA + 32))
3921                                 return;
3922                         bzero(vpdp, AAC_VPD_PAGE_LENGTH);
3923                         vpdp[AAC_VPD_PAGE_CODE] = 0x83;
3924 
3925                         idp = &vpdp[AAC_VPD_PAGE_DATA];
3926                         bzero(idp, AAC_VPD_ID_LENGTH);
3927                         idp[AAC_VPD_ID_CODESET] = 0x02;
3928                         idp[AAC_VPD_ID_TYPE] = 0x01;
3929 
3930                         /*
3931                          * SPC-3 Table 111 - Identifier type
3932                          * One recommanded method of constructing the remainder
3933                          * of identifier field is to concatenate the product
3934                          * identification field from the standard INQUIRY data
3935                          * field and the product serial number field from the
3936                          * unit serial number page.
3937                          */
3938                         sp = &idp[AAC_VPD_ID_DATA];
3939                         sp = aac_vendor_id(softs, sp);
3940                         sp = aac_product_id(softs, sp);
3941                         sp = aac_lun_serialno(softs, tgt, sp);
3942                         idp[AAC_VPD_ID_LENGTH] = (uintptr_t)sp - \
3943                             (uintptr_t)&idp[AAC_VPD_ID_DATA];
3944 
3945                         vpdp[AAC_VPD_PAGE_LENGTH] = (uintptr_t)sp - \
3946                             (uintptr_t)&vpdp[AAC_VPD_PAGE_DATA];
3947                         pkt->pkt_state |= STATE_XFERRED_DATA;
3948                         break;
3949 
3950                 default:
3951                         aac_set_arq_data(pkt, KEY_ILLEGAL_REQUEST,
3952                             0x24, 0x00, 0);
3953                         break;
3954                 }
3955         } else {
3956                 struct scsi_inquiry *inqp = (struct scsi_inquiry *)b_addr;
3957                 size_t len = sizeof (struct scsi_inquiry);
3958 
3959                 if (page != 0) {
3960                         aac_set_arq_data(pkt, KEY_ILLEGAL_REQUEST,
3961                             0x24, 0x00, 0);
3962                         return;
3963                 }
3964                 if (inqp == NULL || bp->b_bcount < len)
3965                         return;
3966 
3967                 bzero(inqp, len);
3968                 inqp->inq_len = AAC_ADDITIONAL_LEN;
3969                 inqp->inq_ansi = AAC_ANSI_VER;
3970                 inqp->inq_rdf = AAC_RESP_DATA_FORMAT;
3971                 (void) aac_vendor_id(softs, (uchar_t *)inqp->inq_vid);
3972                 (void) aac_product_id(softs, (uchar_t *)inqp->inq_pid);
3973                 bcopy("V1.0", inqp->inq_revision, 4);
3974                 inqp->inq_cmdque = 1; /* enable tagged-queuing */
3975                 /*
3976                  * For "sd-max-xfer-size" property which may impact performance
3977                  * when IO threads increase.
3978                  */
3979                 inqp->inq_wbus32 = 1;
3980 
3981                 pkt->pkt_state |= STATE_XFERRED_DATA;
3982         }
3983 }
3984 
3985 /*
3986  * SPC-3 7.10 MODE SENSE command implementation
3987  */
3988 static void
3989 aac_mode_sense(struct aac_softstate *softs, struct scsi_pkt *pkt,
3990     union scsi_cdb *cdbp, struct buf *bp, int capacity)
3991 {
3992         uchar_t pagecode;
3993         struct mode_header *headerp;
3994         struct mode_header_g1 *g1_headerp;
3995         unsigned int ncyl;
3996         caddr_t sense_data;
3997         caddr_t next_page;
3998         size_t sdata_size;
3999         size_t pages_size;
4000         int unsupport_page = 0;
4001 
4002         ASSERT(cdbp->scc_cmd == SCMD_MODE_SENSE ||
4003             cdbp->scc_cmd == SCMD_MODE_SENSE_G1);
4004 
4005         if (!(bp && bp->b_un.b_addr && bp->b_bcount))
4006                 return;
4007 
4008         if (bp->b_flags & (B_PHYS | B_PAGEIO))
4009                 bp_mapin(bp);
4010         pkt->pkt_state |= STATE_XFERRED_DATA;
4011         pagecode = cdbp->cdb_un.sg.scsi[0] & 0x3F;
4012 
4013         /* calculate the size of needed buffer */
4014         if (cdbp->scc_cmd == SCMD_MODE_SENSE)
4015                 sdata_size = MODE_HEADER_LENGTH;
4016         else /* must be SCMD_MODE_SENSE_G1 */
4017                 sdata_size = MODE_HEADER_LENGTH_G1;
4018 
4019         pages_size = 0;
4020         switch (pagecode) {
4021         case SD_MODE_SENSE_PAGE3_CODE:
4022                 pages_size += sizeof (struct mode_format);
4023                 break;
4024 
4025         case SD_MODE_SENSE_PAGE4_CODE:
4026                 pages_size += sizeof (struct mode_geometry);
4027                 break;
4028 
4029         case MODEPAGE_CTRL_MODE:
4030                 if (softs->flags & AAC_FLAGS_LBA_64BIT) {
4031                         pages_size += sizeof (struct mode_control_scsi3);
4032                 } else {
4033                         unsupport_page = 1;
4034                 }
4035                 break;
4036 
4037         case MODEPAGE_ALLPAGES:
4038                 if (softs->flags & AAC_FLAGS_LBA_64BIT) {
4039                         pages_size += sizeof (struct mode_format) +
4040                             sizeof (struct mode_geometry) +
4041                             sizeof (struct mode_control_scsi3);
4042                 } else {
4043                         pages_size += sizeof (struct mode_format) +
4044                             sizeof (struct mode_geometry);
4045                 }
4046                 break;
4047 
4048         default:
4049                 /* unsupported pages */
4050                 unsupport_page = 1;
4051         }
4052 
4053         /* allocate buffer to fill the send data */
4054         sdata_size += pages_size;
4055         sense_data = kmem_zalloc(sdata_size, KM_SLEEP);
4056 
4057         if (cdbp->scc_cmd == SCMD_MODE_SENSE) {
4058                 headerp = (struct mode_header *)sense_data;
4059                 headerp->length = MODE_HEADER_LENGTH + pages_size -
4060                     sizeof (headerp->length);
4061                 headerp->bdesc_length = 0;
4062                 next_page = sense_data + sizeof (struct mode_header);
4063         } else {
4064                 g1_headerp = (void *)sense_data;
4065                 g1_headerp->length = BE_16(MODE_HEADER_LENGTH_G1 + pages_size -
4066                     sizeof (g1_headerp->length));
4067                 g1_headerp->bdesc_length = 0;
4068                 next_page = sense_data + sizeof (struct mode_header_g1);
4069         }
4070 
4071         if (unsupport_page)
4072                 goto finish;
4073 
4074         if (pagecode == SD_MODE_SENSE_PAGE3_CODE ||
4075             pagecode == MODEPAGE_ALLPAGES) {
4076                 /* SBC-3 7.1.3.3 Format device page */
4077                 struct mode_format *page3p;
4078 
4079                 page3p = (void *)next_page;
4080                 page3p->mode_page.code = SD_MODE_SENSE_PAGE3_CODE;
4081                 page3p->mode_page.length = sizeof (struct mode_format);
4082                 page3p->data_bytes_sect = BE_16(AAC_SECTOR_SIZE);
4083                 page3p->sect_track = BE_16(AAC_SECTORS_PER_TRACK);
4084 
4085                 next_page += sizeof (struct mode_format);
4086         }
4087 
4088         if (pagecode == SD_MODE_SENSE_PAGE4_CODE ||
4089             pagecode == MODEPAGE_ALLPAGES) {
4090                 /* SBC-3 7.1.3.8 Rigid disk device geometry page */
4091                 struct mode_geometry *page4p;
4092 
4093                 page4p = (void *)next_page;
4094                 page4p->mode_page.code = SD_MODE_SENSE_PAGE4_CODE;
4095                 page4p->mode_page.length = sizeof (struct mode_geometry);
4096                 page4p->heads = AAC_NUMBER_OF_HEADS;
4097                 page4p->rpm = BE_16(AAC_ROTATION_SPEED);
4098                 ncyl = capacity / (AAC_NUMBER_OF_HEADS * AAC_SECTORS_PER_TRACK);
4099                 page4p->cyl_lb = ncyl & 0xff;
4100                 page4p->cyl_mb = (ncyl >> 8) & 0xff;
4101                 page4p->cyl_ub = (ncyl >> 16) & 0xff;
4102 
4103                 next_page += sizeof (struct mode_geometry);
4104         }
4105 
4106         if ((pagecode == MODEPAGE_CTRL_MODE || pagecode == MODEPAGE_ALLPAGES) &&
4107             softs->flags & AAC_FLAGS_LBA_64BIT) {
4108                 /* 64-bit LBA need large sense data */
4109                 struct mode_control_scsi3 *mctl;
4110 
4111                 mctl = (void *)next_page;
4112                 mctl->mode_page.code = MODEPAGE_CTRL_MODE;
4113                 mctl->mode_page.length =
4114                     sizeof (struct mode_control_scsi3) -
4115                     sizeof (struct mode_page);
4116                 mctl->d_sense = 1;
4117         }
4118 
4119 finish:
4120         /* copyout the valid data. */
4121         bcopy(sense_data, bp->b_un.b_addr, min(sdata_size, bp->b_bcount));
4122         kmem_free(sense_data, sdata_size);
4123 }
4124 
4125 static int
4126 aac_name_node(dev_info_t *dip, char *name, int len)
4127 {
4128         int tgt, lun;
4129 
4130         tgt = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
4131             DDI_PROP_DONTPASS, "target", -1);
4132         if (tgt == -1)
4133                 return (DDI_FAILURE);
4134         lun = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
4135             DDI_PROP_DONTPASS, "lun", -1);
4136         if (lun == -1)
4137                 return (DDI_FAILURE);
4138 
4139         (void) snprintf(name, len, "%x,%x", tgt, lun);
4140         return (DDI_SUCCESS);
4141 }
4142 
4143 /*ARGSUSED*/
4144 static int
4145 aac_tran_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
4146     scsi_hba_tran_t *tran, struct scsi_device *sd)
4147 {
4148         struct aac_softstate *softs = AAC_TRAN2SOFTS(tran);
4149 #if defined(DEBUG) || defined(__lock_lint)
4150         int ctl = ddi_get_instance(softs->devinfo_p);
4151 #endif
4152         uint16_t tgt = sd->sd_address.a_target;
4153         uint8_t lun = sd->sd_address.a_lun;
4154         struct aac_device *dvp;
4155 
4156         DBCALLED(softs, 2);
4157 
4158         if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
4159                 /*
4160                  * If no persistent node exist, we don't allow .conf node
4161                  * to be created.
4162                  */
4163                 if (aac_find_child(softs, tgt, lun) != NULL) {
4164                         if (ndi_merge_node(tgt_dip, aac_name_node) !=
4165                             DDI_SUCCESS)
4166                                 /* Create this .conf node */
4167                                 return (DDI_SUCCESS);
4168                 }
4169                 return (DDI_FAILURE);
4170         }
4171 
4172         /*
4173          * Only support container/phys. device that has been
4174          * detected and valid
4175          */
4176         mutex_enter(&softs->io_lock);
4177         if (tgt >= AAC_MAX_DEV(softs)) {
4178                 AACDB_PRINT_TRAN(softs,
4179                     "aac_tran_tgt_init: c%dt%dL%d out", ctl, tgt, lun);
4180                 mutex_exit(&softs->io_lock);
4181                 return (DDI_FAILURE);
4182         }
4183 
4184         if (tgt < AAC_MAX_LD) {
4185                 dvp = (struct aac_device *)&softs->containers[tgt];
4186                 if (lun != 0 || !AAC_DEV_IS_VALID(dvp)) {
4187                         AACDB_PRINT_TRAN(softs, "aac_tran_tgt_init: c%dt%dL%d",
4188                             ctl, tgt, lun);
4189                         mutex_exit(&softs->io_lock);
4190                         return (DDI_FAILURE);
4191                 }
4192                 /*
4193                  * Save the tgt_dip for the given target if one doesn't exist
4194                  * already. Dip's for non-existance tgt's will be cleared in
4195                  * tgt_free.
4196                  */
4197                 if (softs->containers[tgt].dev.dip == NULL &&
4198                     strcmp(ddi_driver_name(sd->sd_dev), "sd") == 0)
4199                         softs->containers[tgt].dev.dip = tgt_dip;
4200         } else {
4201                 dvp = (struct aac_device *)&softs->nondasds[AAC_PD(tgt)];
4202                 /*
4203                  * Save the tgt_dip for the given target if one doesn't exist
4204                  * already. Dip's for non-existance tgt's will be cleared in
4205                  * tgt_free.
4206                  */
4207 
4208                 if (softs->nondasds[AAC_PD(tgt)].dev.dip  == NULL &&
4209                     strcmp(ddi_driver_name(sd->sd_dev), "sd") == 0)
4210                         softs->nondasds[AAC_PD(tgt)].dev.dip  = tgt_dip;
4211         }
4212 
4213         if (softs->flags & AAC_FLAGS_BRKUP) {
4214                 if (ndi_prop_update_int(DDI_DEV_T_NONE, tgt_dip,
4215                     "buf_break", 1) != DDI_PROP_SUCCESS) {
4216                         cmn_err(CE_CONT, "unable to create "
4217                             "property for t%dL%d (buf_break)", tgt, lun);
4218                 }
4219         }
4220 
4221         AACDB_PRINT(softs, CE_NOTE,
4222             "aac_tran_tgt_init: c%dt%dL%d ok (%s)", ctl, tgt, lun,
4223             (dvp->type == AAC_DEV_PD) ? "pd" : "ld");
4224         mutex_exit(&softs->io_lock);
4225         return (DDI_SUCCESS);
4226 }
4227 
4228 static void
4229 aac_tran_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
4230     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
4231 {
4232 #ifndef __lock_lint
4233         _NOTE(ARGUNUSED(hba_dip, tgt_dip, hba_tran))
4234 #endif
4235 
4236         struct aac_softstate *softs = SD2AAC(sd);
4237         int tgt = sd->sd_address.a_target;
4238 
4239         mutex_enter(&softs->io_lock);
4240         if (tgt < AAC_MAX_LD) {
4241                 if (softs->containers[tgt].dev.dip == tgt_dip)
4242                         softs->containers[tgt].dev.dip = NULL;
4243         } else {
4244                 if (softs->nondasds[AAC_PD(tgt)].dev.dip == tgt_dip)
4245                         softs->nondasds[AAC_PD(tgt)].dev.dip = NULL;
4246                 softs->nondasds[AAC_PD(tgt)].dev.flags &= ~AAC_DFLAG_VALID;
4247         }
4248         mutex_exit(&softs->io_lock);
4249 }
4250 
4251 /*
4252  * Check if the firmware is Up And Running. If it is in the Kernel Panic
4253  * state, (BlinkLED code + 1) is returned.
4254  *    0 -- firmware up and running
4255  *   -1 -- firmware dead
4256  *   >0 -- firmware kernel panic
4257  */
4258 static int
4259 aac_check_adapter_health(struct aac_softstate *softs)
4260 {
4261         int rval;
4262 
4263         rval = PCI_MEM_GET32(softs, AAC_OMR0);
4264 
4265         if (rval & AAC_KERNEL_UP_AND_RUNNING) {
4266                 rval = 0;
4267         } else if (rval & AAC_KERNEL_PANIC) {
4268                 cmn_err(CE_WARN, "firmware panic");
4269                 rval = ((rval >> 16) & 0xff) + 1; /* avoid 0 as return value */
4270         } else {
4271                 cmn_err(CE_WARN, "firmware dead");
4272                 rval = -1;
4273         }
4274         return (rval);
4275 }
4276 
4277 static void
4278 aac_abort_iocmd(struct aac_softstate *softs, struct aac_cmd *acp,
4279     uchar_t reason)
4280 {
4281         acp->flags |= AAC_CMD_ABORT;
4282 
4283         if (acp->pkt) {
4284                 if (acp->slotp) { /* outstanding cmd */
4285                         acp->pkt->pkt_state |= STATE_GOT_STATUS;
4286                 }
4287 
4288                 switch (reason) {
4289                 case CMD_TIMEOUT:
4290                         AACDB_PRINT(softs, CE_NOTE, "CMD_TIMEOUT: acp=0x%p",
4291                             acp);
4292                         aac_set_pkt_reason(softs, acp, CMD_TIMEOUT,
4293                             STAT_TIMEOUT | STAT_BUS_RESET);
4294                         break;
4295                 case CMD_RESET:
4296                         /* aac support only RESET_ALL */
4297                         AACDB_PRINT(softs, CE_NOTE, "CMD_RESET: acp=0x%p", acp);
4298                         aac_set_pkt_reason(softs, acp, CMD_RESET,
4299                             STAT_BUS_RESET);
4300                         break;
4301                 case CMD_ABORTED:
4302                         AACDB_PRINT(softs, CE_NOTE, "CMD_ABORTED: acp=0x%p",
4303                             acp);
4304                         aac_set_pkt_reason(softs, acp, CMD_ABORTED,
4305                             STAT_ABORTED);
4306                         break;
4307                 }
4308         }
4309         aac_end_io(softs, acp);
4310 }
4311 
4312 /*
4313  * Abort all the pending commands of type iocmd or just the command pkt
4314  * corresponding to pkt
4315  */
4316 static void
4317 aac_abort_iocmds(struct aac_softstate *softs, int iocmd, struct scsi_pkt *pkt,
4318     int reason)
4319 {
4320         struct aac_cmd *ac_arg, *acp;
4321         int i;
4322 
4323         if (pkt == NULL) {
4324                 ac_arg = NULL;
4325         } else {
4326                 ac_arg = PKT2AC(pkt);
4327                 iocmd = (ac_arg->flags & AAC_CMD_SYNC) ?
4328                     AAC_IOCMD_SYNC : AAC_IOCMD_ASYNC;
4329         }
4330 
4331         /*
4332          * a) outstanding commands on the controller
4333          * Note: should abort outstanding commands only after one
4334          * IOP reset has been done.
4335          */
4336         if (iocmd & AAC_IOCMD_OUTSTANDING) {
4337                 struct aac_cmd *acp;
4338 
4339                 for (i = 0; i < AAC_MAX_LD; i++) {
4340                         if (AAC_DEV_IS_VALID(&softs->containers[i].dev))
4341                                 softs->containers[i].reset = 1;
4342                 }
4343                 while ((acp = softs->q_busy.q_head) != NULL)
4344                         aac_abort_iocmd(softs, acp, reason);
4345         }
4346 
4347         /* b) commands in the waiting queues */
4348         for (i = 0; i < AAC_CMDQ_NUM; i++) {
4349                 if (iocmd & (1 << i)) {
4350                         if (ac_arg) {
4351                                 aac_abort_iocmd(softs, ac_arg, reason);
4352                         } else {
4353                                 while ((acp = softs->q_wait[i].q_head) != NULL)
4354                                         aac_abort_iocmd(softs, acp, reason);
4355                         }
4356                 }
4357         }
4358 }
4359 
4360 /*
4361  * The draining thread is shared among quiesce threads. It terminates
4362  * when the adapter is quiesced or stopped by aac_stop_drain().
4363  */
4364 static void
4365 aac_check_drain(void *arg)
4366 {
4367         struct aac_softstate *softs = arg;
4368 
4369         mutex_enter(&softs->io_lock);
4370         if (softs->ndrains) {
4371                 softs->drain_timeid = 0;
4372                 /*
4373                  * If both ASYNC and SYNC bus throttle are held,
4374                  * wake up threads only when both are drained out.
4375                  */
4376                 if ((softs->bus_throttle[AAC_CMDQ_ASYNC] > 0 ||
4377                     softs->bus_ncmds[AAC_CMDQ_ASYNC] == 0) &&
4378                     (softs->bus_throttle[AAC_CMDQ_SYNC] > 0 ||
4379                     softs->bus_ncmds[AAC_CMDQ_SYNC] == 0))
4380                         cv_broadcast(&softs->drain_cv);
4381                 else
4382                         softs->drain_timeid = timeout(aac_check_drain, softs,
4383                             AAC_QUIESCE_TICK * drv_usectohz(1000000));
4384         }
4385         mutex_exit(&softs->io_lock);
4386 }
4387 
4388 /*
4389  * If not draining the outstanding cmds, drain them. Otherwise,
4390  * only update ndrains.
4391  */
4392 static void
4393 aac_start_drain(struct aac_softstate *softs)
4394 {
4395         if (softs->ndrains == 0) {
4396                 ASSERT(softs->drain_timeid == 0);
4397                 softs->drain_timeid = timeout(aac_check_drain, softs,
4398                     AAC_QUIESCE_TICK * drv_usectohz(1000000));
4399         }
4400         softs->ndrains++;
4401 }
4402 
4403 /*
4404  * Stop the draining thread when no other threads use it any longer.
4405  * Side effect: io_lock may be released in the middle.
4406  */
4407 static void
4408 aac_stop_drain(struct aac_softstate *softs)
4409 {
4410         softs->ndrains--;
4411         if (softs->ndrains == 0) {
4412                 if (softs->drain_timeid != 0) {
4413                         timeout_id_t tid = softs->drain_timeid;
4414 
4415                         softs->drain_timeid = 0;
4416                         mutex_exit(&softs->io_lock);
4417                         (void) untimeout(tid);
4418                         mutex_enter(&softs->io_lock);
4419                 }
4420         }
4421 }
4422 
4423 /*
4424  * The following function comes from Adaptec:
4425  *
4426  * Once do an IOP reset, basically the driver have to re-initialize the card
4427  * as if up from a cold boot, and the driver is responsible for any IO that
4428  * is outstanding to the adapter at the time of the IOP RESET. And prepare
4429  * for IOP RESET by making the init code modular with the ability to call it
4430  * from multiple places.
4431  */
4432 static int
4433 aac_reset_adapter(struct aac_softstate *softs)
4434 {
4435         int health;
4436         uint32_t status;
4437         int rval = AAC_IOP_RESET_FAILED;
4438 
4439         DBCALLED(softs, 1);
4440 
4441         ASSERT(softs->state & AAC_STATE_RESET);
4442 
4443         ddi_fm_acc_err_clear(softs->pci_mem_handle, DDI_FME_VER0);
4444         /* Disable interrupt */
4445         AAC_DISABLE_INTR(softs);
4446 
4447         health = aac_check_adapter_health(softs);
4448         if (health == -1) {
4449                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
4450                 goto finish;
4451         }
4452         if (health == 0) /* flush drives if possible */
4453                 (void) aac_shutdown(softs);
4454 
4455         /* Execute IOP reset */
4456         if ((aac_sync_mbcommand(softs, AAC_IOP_RESET, 0, 0, 0, 0,
4457             &status)) != AACOK) {
4458                 ddi_acc_handle_t acc;
4459                 struct aac_fib *fibp;
4460                 struct aac_pause_command *pc;
4461 
4462                 if ((status & 0xf) == 0xf) {
4463                         uint32_t wait_count;
4464 
4465                         /*
4466                          * Sunrise Lake has dual cores and we must drag the
4467                          * other core with us to reset simultaneously. There
4468                          * are 2 bits in the Inbound Reset Control and Status
4469                          * Register (offset 0x38) of the Sunrise Lake to reset
4470                          * the chip without clearing out the PCI configuration
4471                          * info (COMMAND & BARS).
4472                          */
4473                         PCI_MEM_PUT32(softs, AAC_IRCSR, AAC_IRCSR_CORES_RST);
4474 
4475                         /*
4476                          * We need to wait for 5 seconds before accessing the MU
4477                          * again 10000 * 100us = 1000,000us = 1000ms = 1s
4478                          */
4479                         wait_count = 5 * 10000;
4480                         while (wait_count) {
4481                                 drv_usecwait(100); /* delay 100 microseconds */
4482                                 wait_count--;
4483                         }
4484                 } else {
4485                         if (status == SRB_STATUS_INVALID_REQUEST)
4486                                 cmn_err(CE_WARN, "!IOP_RESET not supported");
4487                         else /* probably timeout */
4488                                 cmn_err(CE_WARN, "!IOP_RESET failed");
4489 
4490                         /* Unwind aac_shutdown() */
4491                         (void) aac_sync_fib_slot_bind(softs, &softs->sync_ac);
4492                         acc = softs->sync_ac.slotp->fib_acc_handle;
4493 
4494                         fibp = softs->sync_ac.slotp->fibp;
4495                         pc = (struct aac_pause_command *)&fibp->data[0];
4496 
4497                         bzero(pc, sizeof (*pc));
4498                         ddi_put32(acc, &pc->Command, VM_ContainerConfig);
4499                         ddi_put32(acc, &pc->Type, CT_PAUSE_IO);
4500                         ddi_put32(acc, &pc->Timeout, 1);
4501                         ddi_put32(acc, &pc->Min, 1);
4502                         ddi_put32(acc, &pc->NoRescan, 1);
4503 
4504                         (void) aac_sync_fib(softs, ContainerCommand,
4505                             AAC_FIB_SIZEOF(struct aac_pause_command));
4506                         aac_sync_fib_slot_release(softs, &softs->sync_ac);
4507 
4508                         if (aac_check_adapter_health(softs) != 0)
4509                                 ddi_fm_service_impact(softs->devinfo_p,
4510                                     DDI_SERVICE_LOST);
4511                         else
4512                                 /*
4513                                  * IOP reset not supported or IOP not reseted
4514                                  */
4515                                 rval = AAC_IOP_RESET_ABNORMAL;
4516                         goto finish;
4517                 }
4518         }
4519 
4520         /*
4521          * Re-read and renegotiate the FIB parameters, as one of the actions
4522          * that can result from an IOP reset is the running of a new firmware
4523          * image.
4524          */
4525         if (aac_common_attach(softs) != AACOK)
4526                 goto finish;
4527 
4528         rval = AAC_IOP_RESET_SUCCEED;
4529 
4530 finish:
4531         AAC_ENABLE_INTR(softs);
4532         return (rval);
4533 }
4534 
4535 static void
4536 aac_set_throttle(struct aac_softstate *softs, struct aac_device *dvp, int q,
4537     int throttle)
4538 {
4539         /*
4540          * If the bus is draining/quiesced, no changes to the throttles
4541          * are allowed. All throttles should have been set to 0.
4542          */
4543         if ((softs->state & AAC_STATE_QUIESCED) || softs->ndrains)
4544                 return;
4545         dvp->throttle[q] = throttle;
4546 }
4547 
4548 static void
4549 aac_hold_bus(struct aac_softstate *softs, int iocmds)
4550 {
4551         int i, q;
4552 
4553         /* Hold bus by holding every device on the bus */
4554         for (q = 0; q < AAC_CMDQ_NUM; q++) {
4555                 if (iocmds & (1 << q)) {
4556                         softs->bus_throttle[q] = 0;
4557                         for (i = 0; i < AAC_MAX_LD; i++)
4558                                 aac_set_throttle(softs,
4559                                     &softs->containers[i].dev, q, 0);
4560                         for (i = 0; i < AAC_MAX_PD(softs); i++)
4561                                 aac_set_throttle(softs,
4562                                     &softs->nondasds[i].dev, q, 0);
4563                 }
4564         }
4565 }
4566 
4567 static void
4568 aac_unhold_bus(struct aac_softstate *softs, int iocmds)
4569 {
4570         int i, q, max_throttle;
4571 
4572         for (q = 0; q < AAC_CMDQ_NUM; q++) {
4573                 if (iocmds & (1 << q)) {
4574                         /*
4575                          * Should not unhold AAC_IOCMD_ASYNC bus, if it has been
4576                          * quiesced or being drained by possibly some quiesce
4577                          * threads.
4578                          */
4579                         if (q == AAC_CMDQ_ASYNC && ((softs->state &
4580                             AAC_STATE_QUIESCED) || softs->ndrains))
4581                                 continue;
4582                         if (q == AAC_CMDQ_ASYNC)
4583                                 max_throttle = softs->total_slots -
4584                                     AAC_MGT_SLOT_NUM;
4585                         else
4586                                 max_throttle = softs->total_slots - 1;
4587                         softs->bus_throttle[q] = max_throttle;
4588                         for (i = 0; i < AAC_MAX_LD; i++)
4589                                 aac_set_throttle(softs,
4590                                     &softs->containers[i].dev,
4591                                     q, max_throttle);
4592                         for (i = 0; i < AAC_MAX_PD(softs); i++)
4593                                 aac_set_throttle(softs, &softs->nondasds[i].dev,
4594                                     q, max_throttle);
4595                 }
4596         }
4597 }
4598 
4599 static int
4600 aac_do_reset(struct aac_softstate *softs)
4601 {
4602         int health;
4603         int rval;
4604 
4605         softs->state |= AAC_STATE_RESET;
4606         health = aac_check_adapter_health(softs);
4607 
4608         /*
4609          * Hold off new io commands and wait all outstanding io
4610          * commands to complete.
4611          */
4612         if (health == 0) {
4613                 int sync_cmds = softs->bus_ncmds[AAC_CMDQ_SYNC];
4614                 int async_cmds = softs->bus_ncmds[AAC_CMDQ_ASYNC];
4615 
4616                 if (sync_cmds == 0 && async_cmds == 0) {
4617                         rval = AAC_IOP_RESET_SUCCEED;
4618                         goto finish;
4619                 }
4620                 /*
4621                  * Give the adapter up to AAC_QUIESCE_TIMEOUT more seconds
4622                  * to complete the outstanding io commands
4623                  */
4624                 int timeout = AAC_QUIESCE_TIMEOUT * 1000 * 10;
4625                 int (*intr_handler)(struct aac_softstate *);
4626 
4627                 aac_hold_bus(softs, AAC_IOCMD_SYNC | AAC_IOCMD_ASYNC);
4628                 /*
4629                  * Poll the adapter by ourselves in case interrupt is disabled
4630                  * and to avoid releasing the io_lock.
4631                  */
4632                 intr_handler = (softs->flags & AAC_FLAGS_NEW_COMM) ?
4633                     aac_process_intr_new : aac_process_intr_old;
4634                 while ((softs->bus_ncmds[AAC_CMDQ_SYNC] ||
4635                     softs->bus_ncmds[AAC_CMDQ_ASYNC]) && timeout) {
4636                         drv_usecwait(100);
4637                         (void) intr_handler(softs);
4638                         timeout--;
4639                 }
4640                 aac_unhold_bus(softs, AAC_IOCMD_SYNC | AAC_IOCMD_ASYNC);
4641 
4642                 if (softs->bus_ncmds[AAC_CMDQ_SYNC] == 0 &&
4643                     softs->bus_ncmds[AAC_CMDQ_ASYNC] == 0) {
4644                         /* Cmds drained out */
4645                         rval = AAC_IOP_RESET_SUCCEED;
4646                         goto finish;
4647                 } else if (softs->bus_ncmds[AAC_CMDQ_SYNC] < sync_cmds ||
4648                     softs->bus_ncmds[AAC_CMDQ_ASYNC] < async_cmds) {
4649                         /* Cmds not drained out, adapter overloaded */
4650                         rval = AAC_IOP_RESET_ABNORMAL;
4651                         goto finish;
4652                 }
4653         }
4654 
4655         /*
4656          * If a longer waiting time still can't drain any outstanding io
4657          * commands, do IOP reset.
4658          */
4659         if ((rval = aac_reset_adapter(softs)) == AAC_IOP_RESET_FAILED)
4660                 softs->state |= AAC_STATE_DEAD;
4661 
4662 finish:
4663         softs->state &= ~AAC_STATE_RESET;
4664         return (rval);
4665 }
4666 
4667 static int
4668 aac_tran_reset(struct scsi_address *ap, int level)
4669 {
4670         struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
4671         int rval;
4672 
4673         DBCALLED(softs, 1);
4674 
4675         if (level != RESET_ALL) {
4676                 cmn_err(CE_NOTE, "!reset target/lun not supported");
4677                 return (0);
4678         }
4679 
4680         mutex_enter(&softs->io_lock);
4681         switch (rval = aac_do_reset(softs)) {
4682         case AAC_IOP_RESET_SUCCEED:
4683                 aac_abort_iocmds(softs, AAC_IOCMD_OUTSTANDING | AAC_IOCMD_ASYNC,
4684                     NULL, CMD_RESET);
4685                 aac_start_waiting_io(softs);
4686                 break;
4687         case AAC_IOP_RESET_FAILED:
4688                 /* Abort IOCTL cmds when adapter is dead */
4689                 aac_abort_iocmds(softs, AAC_IOCMD_ALL, NULL, CMD_RESET);
4690                 break;
4691         case AAC_IOP_RESET_ABNORMAL:
4692                 aac_start_waiting_io(softs);
4693         }
4694         mutex_exit(&softs->io_lock);
4695 
4696         aac_drain_comp_q(softs);
4697         return (rval == 0);
4698 }
4699 
4700 static int
4701 aac_tran_abort(struct scsi_address *ap, struct scsi_pkt *pkt)
4702 {
4703         struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
4704 
4705         DBCALLED(softs, 1);
4706 
4707         mutex_enter(&softs->io_lock);
4708         aac_abort_iocmds(softs, 0, pkt, CMD_ABORTED);
4709         mutex_exit(&softs->io_lock);
4710 
4711         aac_drain_comp_q(softs);
4712         return (1);
4713 }
4714 
4715 void
4716 aac_free_dmamap(struct aac_cmd *acp)
4717 {
4718         /* Free dma mapping */
4719         if (acp->flags & AAC_CMD_DMA_VALID) {
4720                 ASSERT(acp->buf_dma_handle);
4721                 (void) ddi_dma_unbind_handle(acp->buf_dma_handle);
4722                 acp->flags &= ~AAC_CMD_DMA_VALID;
4723         }
4724 
4725         if (acp->abp != NULL) { /* free non-aligned buf DMA */
4726                 ASSERT(acp->buf_dma_handle);
4727                 if ((acp->flags & AAC_CMD_BUF_WRITE) == 0 && acp->bp)
4728                         ddi_rep_get8(acp->abh, (uint8_t *)acp->bp->b_un.b_addr,
4729                             (uint8_t *)acp->abp, acp->bp->b_bcount,
4730                             DDI_DEV_AUTOINCR);
4731                 ddi_dma_mem_free(&acp->abh);
4732                 acp->abp = NULL;
4733         }
4734 
4735         if (acp->buf_dma_handle) {
4736                 ddi_dma_free_handle(&acp->buf_dma_handle);
4737                 acp->buf_dma_handle = NULL;
4738         }
4739 }
4740 
4741 static void
4742 aac_unknown_scmd(struct aac_softstate *softs, struct aac_cmd *acp)
4743 {
4744         AACDB_PRINT(softs, CE_CONT, "SCMD 0x%x not supported",
4745             ((union scsi_cdb *)(void *)acp->pkt->pkt_cdbp)->scc_cmd);
4746         aac_free_dmamap(acp);
4747         aac_set_arq_data(acp->pkt, KEY_ILLEGAL_REQUEST, 0x20, 0x00, 0);
4748         aac_soft_callback(softs, acp);
4749 }
4750 
4751 /*
4752  * Handle command to logical device
4753  */
4754 static int
4755 aac_tran_start_ld(struct aac_softstate *softs, struct aac_cmd *acp)
4756 {
4757         struct aac_container *dvp;
4758         struct scsi_pkt *pkt;
4759         union scsi_cdb *cdbp;
4760         struct buf *bp;
4761         int rval;
4762 
4763         dvp = (struct aac_container *)acp->dvp;
4764         pkt = acp->pkt;
4765         cdbp = (void *)pkt->pkt_cdbp;
4766         bp = acp->bp;
4767 
4768         switch (cdbp->scc_cmd) {
4769         case SCMD_INQUIRY: /* inquiry */
4770                 aac_free_dmamap(acp);
4771                 aac_inquiry(softs, pkt, cdbp, bp);
4772                 aac_soft_callback(softs, acp);
4773                 rval = TRAN_ACCEPT;
4774                 break;
4775 
4776         case SCMD_READ_CAPACITY: /* read capacity */
4777                 if (bp && bp->b_un.b_addr && bp->b_bcount) {
4778                         struct scsi_capacity cap;
4779                         uint64_t last_lba;
4780 
4781                         /* check 64-bit LBA */
4782                         last_lba = dvp->size - 1;
4783                         if (last_lba > 0xffffffffull) {
4784                                 cap.capacity = 0xfffffffful;
4785                         } else {
4786                                 cap.capacity = BE_32(last_lba);
4787                         }
4788                         cap.lbasize = BE_32(AAC_SECTOR_SIZE);
4789 
4790                         aac_free_dmamap(acp);
4791                         if (bp->b_flags & (B_PHYS|B_PAGEIO))
4792                                 bp_mapin(bp);
4793                         bcopy(&cap, bp->b_un.b_addr, min(bp->b_bcount, 8));
4794                         pkt->pkt_state |= STATE_XFERRED_DATA;
4795                 }
4796                 aac_soft_callback(softs, acp);
4797                 rval = TRAN_ACCEPT;
4798                 break;
4799 
4800         case SCMD_SVC_ACTION_IN_G4: /* read capacity 16 */
4801                 /* Check if containers need 64-bit LBA support */
4802                 if (cdbp->cdb_opaque[1] == SSVC_ACTION_READ_CAPACITY_G4) {
4803                         if (bp && bp->b_un.b_addr && bp->b_bcount) {
4804                                 struct scsi_capacity_16 cap16;
4805                                 int cap_len = sizeof (struct scsi_capacity_16);
4806 
4807                                 bzero(&cap16, cap_len);
4808                                 cap16.sc_capacity = BE_64(dvp->size - 1);
4809                                 cap16.sc_lbasize = BE_32(AAC_SECTOR_SIZE);
4810 
4811                                 aac_free_dmamap(acp);
4812                                 if (bp->b_flags & (B_PHYS | B_PAGEIO))
4813                                         bp_mapin(bp);
4814                                 bcopy(&cap16, bp->b_un.b_addr,
4815                                     min(bp->b_bcount, cap_len));
4816                                 pkt->pkt_state |= STATE_XFERRED_DATA;
4817                         }
4818                         aac_soft_callback(softs, acp);
4819                 } else {
4820                         aac_unknown_scmd(softs, acp);
4821                 }
4822                 rval = TRAN_ACCEPT;
4823                 break;
4824 
4825         case SCMD_READ_G4: /* read_16 */
4826         case SCMD_WRITE_G4: /* write_16 */
4827                 if (softs->flags & AAC_FLAGS_RAW_IO) {
4828                         /* NOTE: GETG4ADDRTL(cdbp) is int32_t */
4829                         acp->blkno = ((uint64_t) \
4830                             GETG4ADDR(cdbp) << 32) | \
4831                             (uint32_t)GETG4ADDRTL(cdbp);
4832                         goto do_io;
4833                 }
4834                 AACDB_PRINT(softs, CE_WARN, "64-bit LBA not supported");
4835                 aac_unknown_scmd(softs, acp);
4836                 rval = TRAN_ACCEPT;
4837                 break;
4838 
4839         case SCMD_READ: /* read_6 */
4840         case SCMD_WRITE: /* write_6 */
4841                 acp->blkno = GETG0ADDR(cdbp);
4842                 goto do_io;
4843 
4844         case SCMD_READ_G5: /* read_12 */
4845         case SCMD_WRITE_G5: /* write_12 */
4846                 acp->blkno = GETG5ADDR(cdbp);
4847                 goto do_io;
4848 
4849         case SCMD_READ_G1: /* read_10 */
4850         case SCMD_WRITE_G1: /* write_10 */
4851                 acp->blkno = (uint32_t)GETG1ADDR(cdbp);
4852 do_io:
4853                 if (acp->flags & AAC_CMD_DMA_VALID) {
4854                         uint64_t cnt_size = dvp->size;
4855 
4856                         /*
4857                          * If LBA > array size AND rawio, the
4858                          * adapter may hang. So check it before
4859                          * sending.
4860                          * NOTE: (blkno + blkcnt) may overflow
4861                          */
4862                         if ((acp->blkno < cnt_size) &&
4863                             ((acp->blkno + acp->bcount /
4864                             AAC_BLK_SIZE) <= cnt_size)) {
4865                                 rval = aac_do_io(softs, acp);
4866                         } else {
4867                         /*
4868                          * Request exceeds the capacity of disk,
4869                          * set error block number to last LBA
4870                          * + 1.
4871                          */
4872                                 aac_set_arq_data(pkt,
4873                                     KEY_ILLEGAL_REQUEST, 0x21,
4874                                     0x00, cnt_size);
4875                                 aac_soft_callback(softs, acp);
4876                                 rval = TRAN_ACCEPT;
4877                         }
4878                 } else if (acp->bcount == 0) {
4879                         /* For 0 length IO, just return ok */
4880                         aac_soft_callback(softs, acp);
4881                         rval = TRAN_ACCEPT;
4882                 } else {
4883                         rval = TRAN_BADPKT;
4884                 }
4885                 break;
4886 
4887         case SCMD_MODE_SENSE: /* mode_sense_6 */
4888         case SCMD_MODE_SENSE_G1: { /* mode_sense_10 */
4889                 int capacity;
4890 
4891                 aac_free_dmamap(acp);
4892                 if (dvp->size > 0xffffffffull)
4893                         capacity = 0xfffffffful; /* 64-bit LBA */
4894                 else
4895                         capacity = dvp->size;
4896                 aac_mode_sense(softs, pkt, cdbp, bp, capacity);
4897                 aac_soft_callback(softs, acp);
4898                 rval = TRAN_ACCEPT;
4899                 break;
4900         }
4901 
4902         case SCMD_START_STOP:
4903                 if (softs->support_opt2 & AAC_SUPPORTED_POWER_MANAGEMENT) {
4904                         acp->aac_cmd_fib = aac_cmd_fib_startstop;
4905                         acp->ac_comp = aac_startstop_complete;
4906                         rval = aac_do_io(softs, acp);
4907                         break;
4908                 }
4909         /* FALLTHRU */
4910         case SCMD_TEST_UNIT_READY:
4911         case SCMD_REQUEST_SENSE:
4912         case SCMD_FORMAT:
4913                 aac_free_dmamap(acp);
4914                 if (bp && bp->b_un.b_addr && bp->b_bcount) {
4915                         if (acp->flags & AAC_CMD_BUF_READ) {
4916                                 if (bp->b_flags & (B_PHYS|B_PAGEIO))
4917                                         bp_mapin(bp);
4918                                 bzero(bp->b_un.b_addr, bp->b_bcount);
4919                         }
4920                         pkt->pkt_state |= STATE_XFERRED_DATA;
4921                 }
4922                 aac_soft_callback(softs, acp);
4923                 rval = TRAN_ACCEPT;
4924                 break;
4925 
4926         case SCMD_SYNCHRONIZE_CACHE:
4927                 acp->flags |= AAC_CMD_NTAG;
4928                 acp->aac_cmd_fib = aac_cmd_fib_sync;
4929                 acp->ac_comp = aac_synccache_complete;
4930                 rval = aac_do_io(softs, acp);
4931                 break;
4932 
4933         case SCMD_DOORLOCK:
4934                 aac_free_dmamap(acp);
4935                 dvp->locked = (pkt->pkt_cdbp[4] & 0x01) ? 1 : 0;
4936                 aac_soft_callback(softs, acp);
4937                 rval = TRAN_ACCEPT;
4938                 break;
4939 
4940         default: /* unknown command */
4941                 aac_unknown_scmd(softs, acp);
4942                 rval = TRAN_ACCEPT;
4943                 break;
4944         }
4945 
4946         return (rval);
4947 }
4948 
4949 static int
4950 aac_tran_start(struct scsi_address *ap, struct scsi_pkt *pkt)
4951 {
4952         struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
4953         struct aac_cmd *acp = PKT2AC(pkt);
4954         struct aac_device *dvp = acp->dvp;
4955         int rval;
4956 
4957         DBCALLED(softs, 2);
4958 
4959         /*
4960          * Reinitialize some fields of ac and pkt; the packet may
4961          * have been resubmitted
4962          */
4963         acp->flags &= AAC_CMD_CONSISTENT | AAC_CMD_DMA_PARTIAL | \
4964             AAC_CMD_BUF_READ | AAC_CMD_BUF_WRITE | AAC_CMD_DMA_VALID;
4965         acp->timeout = acp->pkt->pkt_time;
4966         if (pkt->pkt_flags & FLAG_NOINTR)
4967                 acp->flags |= AAC_CMD_NO_INTR;
4968 #ifdef DEBUG
4969         acp->fib_flags = AACDB_FLAGS_FIB_SCMD;
4970 #endif
4971         pkt->pkt_reason = CMD_CMPLT;
4972         pkt->pkt_state = 0;
4973         pkt->pkt_statistics = 0;
4974         *pkt->pkt_scbp = STATUS_GOOD; /* clear arq scsi_status */
4975 
4976         if (acp->flags & AAC_CMD_DMA_VALID) {
4977                 pkt->pkt_resid = acp->bcount;
4978                 /* Consistent packets need to be sync'ed first */
4979                 if ((acp->flags & AAC_CMD_CONSISTENT) &&
4980                     (acp->flags & AAC_CMD_BUF_WRITE))
4981                         if (aac_dma_sync_ac(acp) != AACOK) {
4982                                 ddi_fm_service_impact(softs->devinfo_p,
4983                                     DDI_SERVICE_UNAFFECTED);
4984                                 return (TRAN_BADPKT);
4985                         }
4986         } else {
4987                 pkt->pkt_resid = 0;
4988         }
4989 
4990         mutex_enter(&softs->io_lock);
4991         AACDB_PRINT_SCMD(softs, acp);
4992         if ((dvp->flags & (AAC_DFLAG_VALID | AAC_DFLAG_CONFIGURING)) &&
4993             !(softs->state & AAC_STATE_DEAD)) {
4994                 if (dvp->type == AAC_DEV_LD) {
4995                         if (ap->a_lun == 0)
4996                                 rval = aac_tran_start_ld(softs, acp);
4997                         else
4998                                 goto error;
4999                 } else {
5000                         rval = aac_do_io(softs, acp);
5001                 }
5002         } else {
5003 error:
5004 #ifdef DEBUG
5005                 if (!(softs->state & AAC_STATE_DEAD)) {
5006                         AACDB_PRINT_TRAN(softs,
5007                             "Cannot send cmd to target t%dL%d: %s",
5008                             ap->a_target, ap->a_lun,
5009                             "target invalid");
5010                 } else {
5011                         AACDB_PRINT(softs, CE_WARN,
5012                             "Cannot send cmd to target t%dL%d: %s",
5013                             ap->a_target, ap->a_lun,
5014                             "adapter dead");
5015                 }
5016 #endif
5017                 rval = TRAN_FATAL_ERROR;
5018         }
5019         mutex_exit(&softs->io_lock);
5020         return (rval);
5021 }
5022 
5023 static int
5024 aac_tran_getcap(struct scsi_address *ap, char *cap, int whom)
5025 {
5026         struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
5027         struct aac_device *dvp;
5028         int rval;
5029 
5030         DBCALLED(softs, 2);
5031 
5032         /* We don't allow inquiring about capabilities for other targets */
5033         if (cap == NULL || whom == 0) {
5034                 AACDB_PRINT(softs, CE_WARN,
5035                     "GetCap> %s not supported: whom=%d", cap, whom);
5036                 return (-1);
5037         }
5038 
5039         mutex_enter(&softs->io_lock);
5040         dvp = AAC_DEV(softs, ap->a_target);
5041         if (dvp == NULL || !AAC_DEV_IS_VALID(dvp)) {
5042                 mutex_exit(&softs->io_lock);
5043                 AACDB_PRINT_TRAN(softs, "Bad target t%dL%d to getcap",
5044                     ap->a_target, ap->a_lun);
5045                 return (-1);
5046         }
5047 
5048         switch (scsi_hba_lookup_capstr(cap)) {
5049         case SCSI_CAP_ARQ: /* auto request sense */
5050                 rval = 1;
5051                 break;
5052         case SCSI_CAP_UNTAGGED_QING:
5053         case SCSI_CAP_TAGGED_QING:
5054                 rval = 1;
5055                 break;
5056         case SCSI_CAP_DMA_MAX:
5057                 rval = softs->dma_max;
5058                 break;
5059         default:
5060                 rval = -1;
5061                 break;
5062         }
5063         mutex_exit(&softs->io_lock);
5064 
5065         AACDB_PRINT_TRAN(softs, "GetCap> %s t%dL%d: rval=%d",
5066             cap, ap->a_target, ap->a_lun, rval);
5067         return (rval);
5068 }
5069 
5070 /*ARGSUSED*/
5071 static int
5072 aac_tran_setcap(struct scsi_address *ap, char *cap, int value, int whom)
5073 {
5074         struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
5075         struct aac_device *dvp;
5076         int rval;
5077 
5078         DBCALLED(softs, 2);
5079 
5080         /* We don't allow inquiring about capabilities for other targets */
5081         if (cap == NULL || whom == 0) {
5082                 AACDB_PRINT(softs, CE_WARN,
5083                     "SetCap> %s not supported: whom=%d", cap, whom);
5084                 return (-1);
5085         }
5086 
5087         mutex_enter(&softs->io_lock);
5088         dvp = AAC_DEV(softs, ap->a_target);
5089         if (dvp == NULL || !AAC_DEV_IS_VALID(dvp)) {
5090                 mutex_exit(&softs->io_lock);
5091                 AACDB_PRINT_TRAN(softs, "Bad target t%dL%d to setcap",
5092                     ap->a_target, ap->a_lun);
5093                 return (-1);
5094         }
5095 
5096         switch (scsi_hba_lookup_capstr(cap)) {
5097         case SCSI_CAP_ARQ:
5098                 /* Force auto request sense */
5099                 rval = (value == 1) ? 1 : 0;
5100                 break;
5101         case SCSI_CAP_UNTAGGED_QING:
5102         case SCSI_CAP_TAGGED_QING:
5103                 rval = (value == 1) ? 1 : 0;
5104                 break;
5105         default:
5106                 rval = -1;
5107                 break;
5108         }
5109         mutex_exit(&softs->io_lock);
5110 
5111         AACDB_PRINT_TRAN(softs, "SetCap> %s t%dL%d val=%d: rval=%d",
5112             cap, ap->a_target, ap->a_lun, value, rval);
5113         return (rval);
5114 }
5115 
5116 static void
5117 aac_tran_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
5118 {
5119         struct aac_cmd *acp = PKT2AC(pkt);
5120 
5121         DBCALLED(NULL, 2);
5122 
5123         if (acp->sgt) {
5124                 kmem_free(acp->sgt, sizeof (struct aac_sge) * \
5125                     acp->left_cookien);
5126         }
5127         aac_free_dmamap(acp);
5128         ASSERT(acp->slotp == NULL);
5129         scsi_hba_pkt_free(ap, pkt);
5130 }
5131 
5132 int
5133 aac_cmd_dma_alloc(struct aac_softstate *softs, struct aac_cmd *acp,
5134     struct buf *bp, int flags, int (*cb)(), caddr_t arg)
5135 {
5136         int kf = (cb == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
5137         uint_t oldcookiec;
5138         int bioerr;
5139         int rval;
5140 
5141         oldcookiec = acp->left_cookien;
5142 
5143         /* Move window to build s/g map */
5144         if (acp->total_nwin > 0) {
5145                 if (++acp->cur_win < acp->total_nwin) {
5146                         off_t off;
5147                         size_t len;
5148 
5149                         rval = ddi_dma_getwin(acp->buf_dma_handle, acp->cur_win,
5150                             &off, &len, &acp->cookie, &acp->left_cookien);
5151                         if (rval == DDI_SUCCESS)
5152                                 goto get_dma_cookies;
5153                         AACDB_PRINT(softs, CE_WARN,
5154                             "ddi_dma_getwin() fail %d", rval);
5155                         return (AACERR);
5156                 }
5157                 AACDB_PRINT(softs, CE_WARN, "Nothing to transfer");
5158                 return (AACERR);
5159         }
5160 
5161         /* We need to transfer data, so we alloc DMA resources for this pkt */
5162         if (bp && bp->b_bcount != 0 && !(acp->flags & AAC_CMD_DMA_VALID)) {
5163                 uint_t dma_flags = 0;
5164                 struct aac_sge *sge;
5165 
5166                 /*
5167                  * We will still use this point to fake some
5168                  * infomation in tran_start
5169                  */
5170                 acp->bp = bp;
5171 
5172                 /* Set dma flags */
5173                 if (BUF_IS_READ(bp)) {
5174                         dma_flags |= DDI_DMA_READ;
5175                         acp->flags |= AAC_CMD_BUF_READ;
5176                 } else {
5177                         dma_flags |= DDI_DMA_WRITE;
5178                         acp->flags |= AAC_CMD_BUF_WRITE;
5179                 }
5180                 if (flags & PKT_CONSISTENT)
5181                         dma_flags |= DDI_DMA_CONSISTENT;
5182                 if (flags & PKT_DMA_PARTIAL)
5183                         dma_flags |= DDI_DMA_PARTIAL;
5184 
5185                 /* Alloc buf dma handle */
5186                 if (!acp->buf_dma_handle) {
5187                         rval = ddi_dma_alloc_handle(softs->devinfo_p,
5188                             &softs->buf_dma_attr, cb, arg,
5189                             &acp->buf_dma_handle);
5190                         if (rval != DDI_SUCCESS) {
5191                                 AACDB_PRINT(softs, CE_WARN,
5192                                     "Can't allocate DMA handle, errno=%d",
5193                                     rval);
5194                                 goto error_out;
5195                         }
5196                 }
5197 
5198                 /* Bind buf */
5199                 if (((uintptr_t)bp->b_un.b_addr & AAC_DMA_ALIGN_MASK) == 0) {
5200                         rval = ddi_dma_buf_bind_handle(acp->buf_dma_handle,
5201                             bp, dma_flags, cb, arg, &acp->cookie,
5202                             &acp->left_cookien);
5203                 } else {
5204                         size_t bufsz;
5205 
5206                         AACDB_PRINT_TRAN(softs,
5207                             "non-aligned buffer: addr=0x%p, cnt=%lu",
5208                             (void *)bp->b_un.b_addr, bp->b_bcount);
5209                         if (bp->b_flags & (B_PAGEIO|B_PHYS))
5210                                 bp_mapin(bp);
5211 
5212                         rval = ddi_dma_mem_alloc(acp->buf_dma_handle,
5213                             AAC_ROUNDUP(bp->b_bcount, AAC_DMA_ALIGN),
5214                             &softs->acc_attr, DDI_DMA_STREAMING,
5215                             cb, arg, &acp->abp, &bufsz, &acp->abh);
5216 
5217                         if (rval != DDI_SUCCESS) {
5218                                 AACDB_PRINT(softs, CE_NOTE,
5219                                     "Cannot alloc DMA to non-aligned buf");
5220                                 bioerr = 0;
5221                                 goto error_out;
5222                         }
5223 
5224                         if (acp->flags & AAC_CMD_BUF_WRITE)
5225                                 ddi_rep_put8(acp->abh,
5226                                     (uint8_t *)bp->b_un.b_addr,
5227                                     (uint8_t *)acp->abp, bp->b_bcount,
5228                                     DDI_DEV_AUTOINCR);
5229 
5230                         rval = ddi_dma_addr_bind_handle(acp->buf_dma_handle,
5231                             NULL, acp->abp, bufsz, dma_flags, cb, arg,
5232                             &acp->cookie, &acp->left_cookien);
5233                 }
5234 
5235                 switch (rval) {
5236                 case DDI_DMA_PARTIAL_MAP:
5237                         if (ddi_dma_numwin(acp->buf_dma_handle,
5238                             &acp->total_nwin) == DDI_FAILURE) {
5239                                 AACDB_PRINT(softs, CE_WARN,
5240                                     "Cannot get number of DMA windows");
5241                                 bioerr = 0;
5242                                 goto error_out;
5243                         }
5244                         AACDB_PRINT_TRAN(softs, "buf bind, %d seg(s)",
5245                             acp->left_cookien);
5246                         acp->cur_win = 0;
5247                         break;
5248 
5249                 case DDI_DMA_MAPPED:
5250                         AACDB_PRINT_TRAN(softs, "buf bind, %d seg(s)",
5251                             acp->left_cookien);
5252                         acp->cur_win = 0;
5253                         acp->total_nwin = 1;
5254                         break;
5255 
5256                 case DDI_DMA_NORESOURCES:
5257                         bioerr = 0;
5258                         AACDB_PRINT(softs, CE_WARN,
5259                             "Cannot bind buf for DMA: DDI_DMA_NORESOURCES");
5260                         goto error_out;
5261                 case DDI_DMA_BADATTR:
5262                 case DDI_DMA_NOMAPPING:
5263                         bioerr = EFAULT;
5264                         AACDB_PRINT(softs, CE_WARN,
5265                             "Cannot bind buf for DMA: DDI_DMA_NOMAPPING");
5266                         goto error_out;
5267                 case DDI_DMA_TOOBIG:
5268                         bioerr = EINVAL;
5269                         AACDB_PRINT(softs, CE_WARN,
5270                             "Cannot bind buf for DMA: DDI_DMA_TOOBIG(%d)",
5271                             bp->b_bcount);
5272                         goto error_out;
5273                 default:
5274                         bioerr = EINVAL;
5275                         AACDB_PRINT(softs, CE_WARN,
5276                             "Cannot bind buf for DMA: %d", rval);
5277                         goto error_out;
5278                 }
5279                 acp->flags |= AAC_CMD_DMA_VALID;
5280 
5281 get_dma_cookies:
5282                 ASSERT(acp->left_cookien > 0);
5283                 if (acp->left_cookien > softs->aac_sg_tablesize) {
5284                         AACDB_PRINT(softs, CE_NOTE, "large cookiec received %d",
5285                             acp->left_cookien);
5286                         bioerr = EINVAL;
5287                         goto error_out;
5288                 }
5289                 if (oldcookiec != acp->left_cookien && acp->sgt != NULL) {
5290                         kmem_free(acp->sgt, sizeof (struct aac_sge) * \
5291                             oldcookiec);
5292                         acp->sgt = NULL;
5293                 }
5294                 if (acp->sgt == NULL) {
5295                         acp->sgt = kmem_alloc(sizeof (struct aac_sge) * \
5296                             acp->left_cookien, kf);
5297                         if (acp->sgt == NULL) {
5298                                 AACDB_PRINT(softs, CE_WARN,
5299                                     "sgt kmem_alloc fail");
5300                                 bioerr = ENOMEM;
5301                                 goto error_out;
5302                         }
5303                 }
5304 
5305                 sge = &acp->sgt[0];
5306                 sge->bcount = acp->cookie.dmac_size;
5307                 sge->addr.ad64.lo = AAC_LS32(acp->cookie.dmac_laddress);
5308                 sge->addr.ad64.hi = AAC_MS32(acp->cookie.dmac_laddress);
5309                 acp->bcount = acp->cookie.dmac_size;
5310                 for (sge++; sge < &acp->sgt[acp->left_cookien]; sge++) {
5311                         ddi_dma_nextcookie(acp->buf_dma_handle, &acp->cookie);
5312                         sge->bcount = acp->cookie.dmac_size;
5313                         sge->addr.ad64.lo = AAC_LS32(acp->cookie.dmac_laddress);
5314                         sge->addr.ad64.hi = AAC_MS32(acp->cookie.dmac_laddress);
5315                         acp->bcount += acp->cookie.dmac_size;
5316                 }
5317 
5318                 /*
5319                  * Note: The old DMA engine do not correctly handle
5320                  * dma_attr_maxxfer attribute. So we have to ensure
5321                  * it by ourself.
5322                  */
5323                 if (acp->bcount > softs->buf_dma_attr.dma_attr_maxxfer) {
5324                         AACDB_PRINT(softs, CE_NOTE,
5325                             "large xfer size received %d\n", acp->bcount);
5326                         bioerr = EINVAL;
5327                         goto error_out;
5328                 }
5329 
5330                 acp->total_xfer += acp->bcount;
5331 
5332                 if (acp->pkt) {
5333                         /* Return remaining byte count */
5334                         if (acp->total_xfer <= bp->b_bcount) {
5335                                 acp->pkt->pkt_resid = bp->b_bcount - \
5336                                     acp->total_xfer;
5337                         } else {
5338                                 /*
5339                                  * Allocated DMA size is greater than the buf
5340                                  * size of bp. This is caused by devices like
5341                                  * tape. we have extra bytes allocated, but
5342                                  * the packet residual has to stay correct.
5343                                  */
5344                                 acp->pkt->pkt_resid = 0;
5345                         }
5346                         AACDB_PRINT_TRAN(softs,
5347                             "bp=0x%p, xfered=%d/%d, resid=%d",
5348                             (void *)bp->b_un.b_addr, (int)acp->total_xfer,
5349                             (int)bp->b_bcount, (int)acp->pkt->pkt_resid);
5350                 }
5351         }
5352         return (AACOK);
5353 
5354 error_out:
5355         bioerror(bp, bioerr);
5356         return (AACERR);
5357 }
5358 
5359 static struct scsi_pkt *
5360 aac_tran_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
5361     struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
5362     int (*callback)(), caddr_t arg)
5363 {
5364         struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
5365         struct aac_cmd *acp, *new_acp;
5366 
5367         DBCALLED(softs, 2);
5368 
5369         /* Allocate pkt */
5370         if (pkt == NULL) {
5371                 int slen;
5372 
5373                 /* Force auto request sense */
5374                 slen = (statuslen > softs->slen) ? statuslen : softs->slen;
5375                 pkt = scsi_hba_pkt_alloc(softs->devinfo_p, ap, cmdlen,
5376                     slen, tgtlen, sizeof (struct aac_cmd), callback, arg);
5377                 if (pkt == NULL) {
5378                         AACDB_PRINT(softs, CE_WARN, "Alloc scsi pkt failed");
5379                         return (NULL);
5380                 }
5381                 acp = new_acp = PKT2AC(pkt);
5382                 acp->pkt = pkt;
5383                 acp->cmdlen = cmdlen;
5384 
5385                 if (ap->a_target < AAC_MAX_LD) {
5386                         acp->dvp = &softs->containers[ap->a_target].dev;
5387                         acp->aac_cmd_fib = softs->aac_cmd_fib;
5388                         acp->ac_comp = aac_ld_complete;
5389                 } else {
5390                         _NOTE(ASSUMING_PROTECTED(softs->nondasds))
5391 
5392                         acp->dvp = &softs->nondasds[AAC_PD(ap->a_target)].dev;
5393                         acp->aac_cmd_fib = softs->aac_cmd_fib_scsi;
5394                         acp->ac_comp = aac_pd_complete;
5395                 }
5396         } else {
5397                 acp = PKT2AC(pkt);
5398                 new_acp = NULL;
5399         }
5400 
5401         if (aac_cmd_dma_alloc(softs, acp, bp, flags, callback, arg) == AACOK)
5402                 return (pkt);
5403 
5404         if (new_acp)
5405                 aac_tran_destroy_pkt(ap, pkt);
5406         return (NULL);
5407 }
5408 
5409 /*
5410  * tran_sync_pkt(9E) - explicit DMA synchronization
5411  */
5412 /*ARGSUSED*/
5413 static void
5414 aac_tran_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
5415 {
5416         struct aac_cmd *acp = PKT2AC(pkt);
5417 
5418         DBCALLED(NULL, 2);
5419 
5420         if (aac_dma_sync_ac(acp) != AACOK)
5421                 ddi_fm_service_impact(
5422                     (AAC_TRAN2SOFTS(ap->a_hba_tran))->devinfo_p,
5423                     DDI_SERVICE_UNAFFECTED);
5424 }
5425 
5426 /*
5427  * tran_dmafree(9E) - deallocate DMA resources allocated for command
5428  */
5429 /*ARGSUSED*/
5430 static void
5431 aac_tran_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
5432 {
5433         struct aac_cmd *acp = PKT2AC(pkt);
5434 
5435         DBCALLED(NULL, 2);
5436 
5437         aac_free_dmamap(acp);
5438 }
5439 
5440 static int
5441 aac_do_quiesce(struct aac_softstate *softs)
5442 {
5443         aac_hold_bus(softs, AAC_IOCMD_ASYNC);
5444         if (softs->bus_ncmds[AAC_CMDQ_ASYNC]) {
5445                 aac_start_drain(softs);
5446                 do {
5447                         if (cv_wait_sig(&softs->drain_cv,
5448                             &softs->io_lock) == 0) {
5449                                 /* Quiesce has been interrupted */
5450                                 aac_stop_drain(softs);
5451                                 aac_unhold_bus(softs, AAC_IOCMD_ASYNC);
5452                                 aac_start_waiting_io(softs);
5453                                 return (AACERR);
5454                         }
5455                 } while (softs->bus_ncmds[AAC_CMDQ_ASYNC]);
5456                 aac_stop_drain(softs);
5457         }
5458 
5459         softs->state |= AAC_STATE_QUIESCED;
5460         return (AACOK);
5461 }
5462 
5463 static int
5464 aac_tran_quiesce(dev_info_t *dip)
5465 {
5466         struct aac_softstate *softs = AAC_DIP2SOFTS(dip);
5467         int rval;
5468 
5469         DBCALLED(softs, 1);
5470 
5471         mutex_enter(&softs->io_lock);
5472         if (aac_do_quiesce(softs) == AACOK)
5473                 rval = 0;
5474         else
5475                 rval = 1;
5476         mutex_exit(&softs->io_lock);
5477         return (rval);
5478 }
5479 
5480 static int
5481 aac_do_unquiesce(struct aac_softstate *softs)
5482 {
5483         softs->state &= ~AAC_STATE_QUIESCED;
5484         aac_unhold_bus(softs, AAC_IOCMD_ASYNC);
5485 
5486         aac_start_waiting_io(softs);
5487         return (AACOK);
5488 }
5489 
5490 static int
5491 aac_tran_unquiesce(dev_info_t *dip)
5492 {
5493         struct aac_softstate *softs = AAC_DIP2SOFTS(dip);
5494         int rval;
5495 
5496         DBCALLED(softs, 1);
5497 
5498         mutex_enter(&softs->io_lock);
5499         if (aac_do_unquiesce(softs) == AACOK)
5500                 rval = 0;
5501         else
5502                 rval = 1;
5503         mutex_exit(&softs->io_lock);
5504         return (rval);
5505 }
5506 
5507 static int
5508 aac_hba_setup(struct aac_softstate *softs)
5509 {
5510         scsi_hba_tran_t *hba_tran;
5511         int rval;
5512 
5513         hba_tran = scsi_hba_tran_alloc(softs->devinfo_p, SCSI_HBA_CANSLEEP);
5514         if (hba_tran == NULL)
5515                 return (AACERR);
5516         hba_tran->tran_hba_private = softs;
5517         hba_tran->tran_tgt_init = aac_tran_tgt_init;
5518         hba_tran->tran_tgt_free = aac_tran_tgt_free;
5519         hba_tran->tran_tgt_probe = scsi_hba_probe;
5520         hba_tran->tran_start = aac_tran_start;
5521         hba_tran->tran_getcap = aac_tran_getcap;
5522         hba_tran->tran_setcap = aac_tran_setcap;
5523         hba_tran->tran_init_pkt = aac_tran_init_pkt;
5524         hba_tran->tran_destroy_pkt = aac_tran_destroy_pkt;
5525         hba_tran->tran_reset = aac_tran_reset;
5526         hba_tran->tran_abort = aac_tran_abort;
5527         hba_tran->tran_sync_pkt = aac_tran_sync_pkt;
5528         hba_tran->tran_dmafree = aac_tran_dmafree;
5529         hba_tran->tran_quiesce = aac_tran_quiesce;
5530         hba_tran->tran_unquiesce = aac_tran_unquiesce;
5531         hba_tran->tran_bus_config = aac_tran_bus_config;
5532         rval = scsi_hba_attach_setup(softs->devinfo_p, &softs->buf_dma_attr,
5533             hba_tran, 0);
5534         if (rval != DDI_SUCCESS) {
5535                 scsi_hba_tran_free(hba_tran);
5536                 AACDB_PRINT(softs, CE_WARN, "aac_hba_setup failed");
5537                 return (AACERR);
5538         }
5539 
5540         softs->hba_tran = hba_tran;
5541         return (AACOK);
5542 }
5543 
5544 /*
5545  * FIB setup operations
5546  */
5547 
5548 /*
5549  * Init FIB header
5550  */
5551 static void
5552 aac_cmd_fib_header(struct aac_softstate *softs, struct aac_cmd *acp,
5553     uint16_t cmd)
5554 {
5555         struct aac_slot *slotp = acp->slotp;
5556         ddi_acc_handle_t acc = slotp->fib_acc_handle;
5557         struct aac_fib *fibp = slotp->fibp;
5558         uint32_t xfer_state;
5559 
5560         xfer_state =
5561             AAC_FIBSTATE_HOSTOWNED |
5562             AAC_FIBSTATE_INITIALISED |
5563             AAC_FIBSTATE_EMPTY |
5564             AAC_FIBSTATE_FAST_RESPONSE | /* enable fast io */
5565             AAC_FIBSTATE_FROMHOST |
5566             AAC_FIBSTATE_REXPECTED |
5567             AAC_FIBSTATE_NORM;
5568 
5569         if (!(acp->flags & AAC_CMD_SYNC))
5570                 xfer_state |= AAC_FIBSTATE_ASYNC;
5571 
5572         ddi_put32(acc, &fibp->Header.XferState, xfer_state);
5573         ddi_put16(acc, &fibp->Header.Command, cmd);
5574         ddi_put8(acc, &fibp->Header.StructType, AAC_FIBTYPE_TFIB);
5575         ddi_put8(acc, &fibp->Header.Flags, 0); /* don't care */
5576         ddi_put16(acc, &fibp->Header.Size, acp->fib_size);
5577         ddi_put16(acc, &fibp->Header.SenderSize, softs->aac_max_fib_size);
5578         ddi_put32(acc, &fibp->Header.SenderFibAddress, (slotp->index << 2));
5579         ddi_put32(acc, &fibp->Header.ReceiverFibAddress, slotp->fib_phyaddr);
5580         ddi_put32(acc, &fibp->Header.SenderData, 0); /* don't care */
5581 }
5582 
5583 /*
5584  * Init FIB for raw IO command
5585  */
5586 static void
5587 aac_cmd_fib_rawio(struct aac_softstate *softs, struct aac_cmd *acp)
5588 {
5589         ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5590         struct aac_raw_io *io = (struct aac_raw_io *)&acp->slotp->fibp->data[0];
5591         struct aac_sg_entryraw *sgp;
5592         struct aac_sge *sge;
5593 
5594         /* Calculate FIB size */
5595         acp->fib_size = sizeof (struct aac_fib_header) + \
5596             sizeof (struct aac_raw_io) + (acp->left_cookien - 1) * \
5597             sizeof (struct aac_sg_entryraw);
5598 
5599         aac_cmd_fib_header(softs, acp, RawIo);
5600 
5601         ddi_put16(acc, &io->Flags, (acp->flags & AAC_CMD_BUF_READ) ? 1 : 0);
5602         ddi_put16(acc, &io->BpTotal, 0);
5603         ddi_put16(acc, &io->BpComplete, 0);
5604 
5605         ddi_put32(acc, AAC_LO32(&io->BlockNumber), AAC_LS32(acp->blkno));
5606         ddi_put32(acc, AAC_HI32(&io->BlockNumber), AAC_MS32(acp->blkno));
5607         ddi_put16(acc, &io->ContainerId,
5608             ((struct aac_container *)acp->dvp)->cid);
5609 
5610         /* Fill SG table */
5611         ddi_put32(acc, &io->SgMapRaw.SgCount, acp->left_cookien);
5612         ddi_put32(acc, &io->ByteCount, acp->bcount);
5613 
5614         for (sge = &acp->sgt[0], sgp = &io->SgMapRaw.SgEntryRaw[0];
5615             sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5616                 ddi_put32(acc, AAC_LO32(&sgp->SgAddress), sge->addr.ad64.lo);
5617                 ddi_put32(acc, AAC_HI32(&sgp->SgAddress), sge->addr.ad64.hi);
5618                 ddi_put32(acc, &sgp->SgByteCount, sge->bcount);
5619                 sgp->Next = 0;
5620                 sgp->Prev = 0;
5621                 sgp->Flags = 0;
5622         }
5623 }
5624 
5625 /* Init FIB for 64-bit block IO command */
5626 static void
5627 aac_cmd_fib_brw64(struct aac_softstate *softs, struct aac_cmd *acp)
5628 {
5629         ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5630         struct aac_blockread64 *br = (struct aac_blockread64 *) \
5631             &acp->slotp->fibp->data[0];
5632         struct aac_sg_entry64 *sgp;
5633         struct aac_sge *sge;
5634 
5635         acp->fib_size = sizeof (struct aac_fib_header) + \
5636             sizeof (struct aac_blockread64) + (acp->left_cookien - 1) * \
5637             sizeof (struct aac_sg_entry64);
5638 
5639         aac_cmd_fib_header(softs, acp, ContainerCommand64);
5640 
5641         /*
5642          * The definitions for aac_blockread64 and aac_blockwrite64
5643          * are the same.
5644          */
5645         ddi_put32(acc, &br->BlockNumber, (uint32_t)acp->blkno);
5646         ddi_put16(acc, &br->ContainerId,
5647             ((struct aac_container *)acp->dvp)->cid);
5648         ddi_put32(acc, &br->Command, (acp->flags & AAC_CMD_BUF_READ) ?
5649             VM_CtHostRead64 : VM_CtHostWrite64);
5650         ddi_put16(acc, &br->Pad, 0);
5651         ddi_put16(acc, &br->Flags, 0);
5652 
5653         /* Fill SG table */
5654         ddi_put32(acc, &br->SgMap64.SgCount, acp->left_cookien);
5655         ddi_put16(acc, &br->SectorCount, acp->bcount / AAC_BLK_SIZE);
5656 
5657         for (sge = &acp->sgt[0], sgp = &br->SgMap64.SgEntry64[0];
5658             sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5659                 ddi_put32(acc, AAC_LO32(&sgp->SgAddress), sge->addr.ad64.lo);
5660                 ddi_put32(acc, AAC_HI32(&sgp->SgAddress), sge->addr.ad64.hi);
5661                 ddi_put32(acc, &sgp->SgByteCount, sge->bcount);
5662         }
5663 }
5664 
5665 /* Init FIB for block IO command */
5666 static void
5667 aac_cmd_fib_brw(struct aac_softstate *softs, struct aac_cmd *acp)
5668 {
5669         ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5670         struct aac_blockread *br = (struct aac_blockread *) \
5671             &acp->slotp->fibp->data[0];
5672         struct aac_sg_entry *sgp;
5673         struct aac_sge *sge = &acp->sgt[0];
5674 
5675         if (acp->flags & AAC_CMD_BUF_READ) {
5676                 acp->fib_size = sizeof (struct aac_fib_header) + \
5677                     sizeof (struct aac_blockread) + (acp->left_cookien - 1) * \
5678                     sizeof (struct aac_sg_entry);
5679 
5680                 ddi_put32(acc, &br->Command, VM_CtBlockRead);
5681                 ddi_put32(acc, &br->SgMap.SgCount, acp->left_cookien);
5682                 sgp = &br->SgMap.SgEntry[0];
5683         } else {
5684                 struct aac_blockwrite *bw = (struct aac_blockwrite *)br;
5685 
5686                 acp->fib_size = sizeof (struct aac_fib_header) + \
5687                     sizeof (struct aac_blockwrite) + (acp->left_cookien - 1) * \
5688                     sizeof (struct aac_sg_entry);
5689 
5690                 ddi_put32(acc, &bw->Command, VM_CtBlockWrite);
5691                 ddi_put32(acc, &bw->Stable, CUNSTABLE);
5692                 ddi_put32(acc, &bw->SgMap.SgCount, acp->left_cookien);
5693                 sgp = &bw->SgMap.SgEntry[0];
5694         }
5695         aac_cmd_fib_header(softs, acp, ContainerCommand);
5696 
5697         /*
5698          * aac_blockread and aac_blockwrite have the similar
5699          * structure head, so use br for bw here
5700          */
5701         ddi_put32(acc, &br->BlockNumber, (uint32_t)acp->blkno);
5702         ddi_put32(acc, &br->ContainerId,
5703             ((struct aac_container *)acp->dvp)->cid);
5704         ddi_put32(acc, &br->ByteCount, acp->bcount);
5705 
5706         /* Fill SG table */
5707         for (sge = &acp->sgt[0];
5708             sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5709                 ddi_put32(acc, &sgp->SgAddress, sge->addr.ad32);
5710                 ddi_put32(acc, &sgp->SgByteCount, sge->bcount);
5711         }
5712 }
5713 
5714 /*ARGSUSED*/
5715 void
5716 aac_cmd_fib_copy(struct aac_softstate *softs, struct aac_cmd *acp)
5717 {
5718         struct aac_slot *slotp = acp->slotp;
5719         struct aac_fib *fibp = slotp->fibp;
5720         ddi_acc_handle_t acc = slotp->fib_acc_handle;
5721 
5722         ddi_rep_put8(acc, (uint8_t *)acp->fibp, (uint8_t *)fibp,
5723             acp->fib_size,   /* only copy data of needed length */
5724             DDI_DEV_AUTOINCR);
5725         ddi_put32(acc, &fibp->Header.ReceiverFibAddress, slotp->fib_phyaddr);
5726         ddi_put32(acc, &fibp->Header.SenderFibAddress, slotp->index << 2);
5727 }
5728 
5729 static void
5730 aac_cmd_fib_sync(struct aac_softstate *softs, struct aac_cmd *acp)
5731 {
5732         ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5733         struct aac_synchronize_command *sync =
5734             (struct aac_synchronize_command *)&acp->slotp->fibp->data[0];
5735 
5736         acp->fib_size = AAC_FIB_SIZEOF(struct aac_synchronize_command);
5737 
5738         aac_cmd_fib_header(softs, acp, ContainerCommand);
5739         ddi_put32(acc, &sync->Command, VM_ContainerConfig);
5740         ddi_put32(acc, &sync->Type, (uint32_t)CT_FLUSH_CACHE);
5741         ddi_put32(acc, &sync->Cid, ((struct aac_container *)acp->dvp)->cid);
5742         ddi_put32(acc, &sync->Count,
5743             sizeof (((struct aac_synchronize_reply *)0)->Data));
5744 }
5745 
5746 /*
5747  * Start/Stop unit (Power Management)
5748  */
5749 static void
5750 aac_cmd_fib_startstop(struct aac_softstate *softs, struct aac_cmd *acp)
5751 {
5752         ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5753         struct aac_Container *cmd =
5754             (struct aac_Container *)&acp->slotp->fibp->data[0];
5755         union scsi_cdb *cdbp = (void *)acp->pkt->pkt_cdbp;
5756 
5757         acp->fib_size = AAC_FIB_SIZEOF(struct aac_Container);
5758 
5759         aac_cmd_fib_header(softs, acp, ContainerCommand);
5760         bzero(cmd, sizeof (*cmd) - CT_PACKET_SIZE);
5761         ddi_put32(acc, &cmd->Command, VM_ContainerConfig);
5762         ddi_put32(acc, &cmd->CTCommand.command, CT_PM_DRIVER_SUPPORT);
5763         ddi_put32(acc, &cmd->CTCommand.param[0], cdbp->cdb_opaque[4] & 1 ? \
5764             AAC_PM_DRIVERSUP_START_UNIT : AAC_PM_DRIVERSUP_STOP_UNIT);
5765         ddi_put32(acc, &cmd->CTCommand.param[1],
5766             ((struct aac_container *)acp->dvp)->cid);
5767         ddi_put32(acc, &cmd->CTCommand.param[2], cdbp->cdb_opaque[1] & 1);
5768 }
5769 
5770 /*
5771  * Init FIB for pass-through SCMD
5772  */
5773 static void
5774 aac_cmd_fib_srb(struct aac_cmd *acp)
5775 {
5776         ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5777         struct aac_srb *srb = (struct aac_srb *)&acp->slotp->fibp->data[0];
5778         uint8_t *cdb;
5779 
5780         ddi_put32(acc, &srb->function, SRBF_ExecuteScsi);
5781         ddi_put32(acc, &srb->retry_limit, 0);
5782         ddi_put32(acc, &srb->cdb_size, acp->cmdlen);
5783         ddi_put32(acc, &srb->timeout, 0); /* use driver timeout */
5784         if (acp->fibp == NULL) {
5785                 if (acp->flags & AAC_CMD_BUF_READ)
5786                         ddi_put32(acc, &srb->flags, SRB_DataIn);
5787                 else if (acp->flags & AAC_CMD_BUF_WRITE)
5788                         ddi_put32(acc, &srb->flags, SRB_DataOut);
5789                 ddi_put32(acc, &srb->channel,
5790                     ((struct aac_nondasd *)acp->dvp)->bus);
5791                 ddi_put32(acc, &srb->id, ((struct aac_nondasd *)acp->dvp)->tid);
5792                 ddi_put32(acc, &srb->lun, 0);
5793                 cdb = acp->pkt->pkt_cdbp;
5794         } else {
5795                 struct aac_srb *srb0 = (struct aac_srb *)&acp->fibp->data[0];
5796 
5797                 ddi_put32(acc, &srb->flags, srb0->flags);
5798                 ddi_put32(acc, &srb->channel, srb0->channel);
5799                 ddi_put32(acc, &srb->id, srb0->id);
5800                 ddi_put32(acc, &srb->lun, srb0->lun);
5801                 cdb = srb0->cdb;
5802         }
5803         ddi_rep_put8(acc, cdb, srb->cdb, acp->cmdlen, DDI_DEV_AUTOINCR);
5804 }
5805 
5806 static void
5807 aac_cmd_fib_scsi32(struct aac_softstate *softs, struct aac_cmd *acp)
5808 {
5809         ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5810         struct aac_srb *srb = (struct aac_srb *)&acp->slotp->fibp->data[0];
5811         struct aac_sg_entry *sgp;
5812         struct aac_sge *sge;
5813 
5814         acp->fib_size = sizeof (struct aac_fib_header) + \
5815             sizeof (struct aac_srb) - sizeof (struct aac_sg_entry) + \
5816             acp->left_cookien * sizeof (struct aac_sg_entry);
5817 
5818         /* Fill FIB and SRB headers, and copy cdb */
5819         aac_cmd_fib_header(softs, acp, ScsiPortCommand);
5820         aac_cmd_fib_srb(acp);
5821 
5822         /* Fill SG table */
5823         ddi_put32(acc, &srb->sg.SgCount, acp->left_cookien);
5824         ddi_put32(acc, &srb->count, acp->bcount);
5825 
5826         for (sge = &acp->sgt[0], sgp = &srb->sg.SgEntry[0];
5827             sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5828                 ddi_put32(acc, &sgp->SgAddress, sge->addr.ad32);
5829                 ddi_put32(acc, &sgp->SgByteCount, sge->bcount);
5830         }
5831 }
5832 
5833 static void
5834 aac_cmd_fib_scsi64(struct aac_softstate *softs, struct aac_cmd *acp)
5835 {
5836         ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5837         struct aac_srb *srb = (struct aac_srb *)&acp->slotp->fibp->data[0];
5838         struct aac_sg_entry64 *sgp;
5839         struct aac_sge *sge;
5840 
5841         acp->fib_size = sizeof (struct aac_fib_header) + \
5842             sizeof (struct aac_srb) - sizeof (struct aac_sg_entry) + \
5843             acp->left_cookien * sizeof (struct aac_sg_entry64);
5844 
5845         /* Fill FIB and SRB headers, and copy cdb */
5846         aac_cmd_fib_header(softs, acp, ScsiPortCommandU64);
5847         aac_cmd_fib_srb(acp);
5848 
5849         /* Fill SG table */
5850         ddi_put32(acc, &srb->sg.SgCount, acp->left_cookien);
5851         ddi_put32(acc, &srb->count, acp->bcount);
5852 
5853         for (sge = &acp->sgt[0],
5854             sgp = &((struct aac_sg_table64 *)&srb->sg)->SgEntry64[0];
5855             sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5856                 ddi_put32(acc, AAC_LO32(&sgp->SgAddress), sge->addr.ad64.lo);
5857                 ddi_put32(acc, AAC_HI32(&sgp->SgAddress), sge->addr.ad64.hi);
5858                 ddi_put32(acc, &sgp->SgByteCount, sge->bcount);
5859         }
5860 }
5861 
5862 static int
5863 aac_cmd_slot_bind(struct aac_softstate *softs, struct aac_cmd *acp)
5864 {
5865         struct aac_slot *slotp;
5866 
5867         if (slotp = aac_get_slot(softs)) {
5868                 acp->slotp = slotp;
5869                 slotp->acp = acp;
5870                 acp->aac_cmd_fib(softs, acp);
5871                 (void) ddi_dma_sync(slotp->fib_dma_handle, 0, 0,
5872                     DDI_DMA_SYNC_FORDEV);
5873                 return (AACOK);
5874         }
5875         return (AACERR);
5876 }
5877 
5878 static int
5879 aac_bind_io(struct aac_softstate *softs, struct aac_cmd *acp)
5880 {
5881         struct aac_device *dvp = acp->dvp;
5882         int q = AAC_CMDQ(acp);
5883 
5884         if (softs->bus_ncmds[q] < softs->bus_throttle[q]) {
5885                 if (dvp) {
5886                         if (dvp->ncmds[q] < dvp->throttle[q]) {
5887                                 if (!(acp->flags & AAC_CMD_NTAG) ||
5888                                     dvp->ncmds[q] == 0) {
5889                                         return (aac_cmd_slot_bind(softs, acp));
5890                                 }
5891                                 ASSERT(q == AAC_CMDQ_ASYNC);
5892                                 aac_set_throttle(softs, dvp, AAC_CMDQ_ASYNC,
5893                                     AAC_THROTTLE_DRAIN);
5894                         }
5895                 } else {
5896                         return (aac_cmd_slot_bind(softs, acp));
5897                 }
5898         }
5899         return (AACERR);
5900 }
5901 
5902 static int
5903 aac_sync_fib_slot_bind(struct aac_softstate *softs, struct aac_cmd *acp)
5904 {
5905         struct aac_slot *slotp;
5906 
5907         while (softs->sync_ac.slotp)
5908                 cv_wait(&softs->sync_fib_cv, &softs->io_lock);
5909 
5910         if (slotp = aac_get_slot(softs)) {
5911                 ASSERT(acp->slotp == NULL);
5912 
5913                 acp->slotp = slotp;
5914                 slotp->acp = acp;
5915                 return (AACOK);
5916         }
5917         return (AACERR);
5918 }
5919 
5920 static void
5921 aac_sync_fib_slot_release(struct aac_softstate *softs, struct aac_cmd *acp)
5922 {
5923         ASSERT(acp->slotp);
5924 
5925         aac_release_slot(softs, acp->slotp);
5926         acp->slotp->acp = NULL;
5927         acp->slotp = NULL;
5928 
5929         cv_signal(&softs->sync_fib_cv);
5930 }
5931 
5932 static void
5933 aac_start_io(struct aac_softstate *softs, struct aac_cmd *acp)
5934 {
5935         struct aac_slot *slotp = acp->slotp;
5936         int q = AAC_CMDQ(acp);
5937         int rval;
5938 
5939         /* Set ac and pkt */
5940         if (acp->pkt) { /* ac from ioctl has no pkt */
5941                 acp->pkt->pkt_state |=
5942                     STATE_GOT_BUS | STATE_GOT_TARGET | STATE_SENT_CMD;
5943         }
5944         if (acp->timeout) /* 0 indicates no timeout */
5945                 acp->timeout += aac_timebase + aac_tick;
5946 
5947         if (acp->dvp)
5948                 acp->dvp->ncmds[q]++;
5949         softs->bus_ncmds[q]++;
5950         aac_cmd_enqueue(&softs->q_busy, acp);
5951 
5952         AACDB_PRINT_FIB(softs, slotp);
5953 
5954         if (softs->flags & AAC_FLAGS_NEW_COMM) {
5955                 rval = aac_send_command(softs, slotp);
5956         } else {
5957                 /*
5958                  * If fib can not be enqueued, the adapter is in an abnormal
5959                  * state, there will be no interrupt to us.
5960                  */
5961                 rval = aac_fib_enqueue(softs, AAC_ADAP_NORM_CMD_Q,
5962                     slotp->fib_phyaddr, acp->fib_size);
5963         }
5964 
5965         if (aac_check_dma_handle(slotp->fib_dma_handle) != DDI_SUCCESS)
5966                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
5967 
5968         /*
5969          * NOTE: We send command only when slots availabe, so should never
5970          * reach here.
5971          */
5972         if (rval != AACOK) {
5973                 AACDB_PRINT(softs, CE_NOTE, "SCMD send failed");
5974                 if (acp->pkt) {
5975                         acp->pkt->pkt_state &= ~STATE_SENT_CMD;
5976                         aac_set_pkt_reason(softs, acp, CMD_INCOMPLETE, 0);
5977                 }
5978                 aac_end_io(softs, acp);
5979                 if (!(acp->flags & (AAC_CMD_NO_INTR | AAC_CMD_NO_CB)))
5980                         ddi_trigger_softintr(softs->softint_id);
5981         }
5982 }
5983 
5984 static void
5985 aac_start_waitq(struct aac_softstate *softs, struct aac_cmd_queue *q)
5986 {
5987         struct aac_cmd *acp, *next_acp;
5988 
5989         /* Serve as many waiting io's as possible */
5990         for (acp = q->q_head; acp; acp = next_acp) {
5991                 next_acp = acp->next;
5992                 if (aac_bind_io(softs, acp) == AACOK) {
5993                         aac_cmd_delete(q, acp);
5994                         aac_start_io(softs, acp);
5995                 }
5996                 if (softs->free_io_slot_head == NULL)
5997                         break;
5998         }
5999 }
6000 
6001 static void
6002 aac_start_waiting_io(struct aac_softstate *softs)
6003 {
6004         /*
6005          * Sync FIB io is served before async FIB io so that io requests
6006          * sent by interactive userland commands get responded asap.
6007          */
6008         if (softs->q_wait[AAC_CMDQ_SYNC].q_head)
6009                 aac_start_waitq(softs, &softs->q_wait[AAC_CMDQ_SYNC]);
6010         if (softs->q_wait[AAC_CMDQ_ASYNC].q_head)
6011                 aac_start_waitq(softs, &softs->q_wait[AAC_CMDQ_ASYNC]);
6012 }
6013 
6014 static void
6015 aac_drain_comp_q(struct aac_softstate *softs)
6016 {
6017         struct aac_cmd *acp;
6018         struct scsi_pkt *pkt;
6019 
6020         /*CONSTCOND*/
6021         while (1) {
6022                 mutex_enter(&softs->q_comp_mutex);
6023                 acp = aac_cmd_dequeue(&softs->q_comp);
6024                 mutex_exit(&softs->q_comp_mutex);
6025                 if (acp != NULL) {
6026                         ASSERT(acp->pkt != NULL);
6027                         pkt = acp->pkt;
6028 
6029                         if (pkt->pkt_reason == CMD_CMPLT) {
6030                                 /*
6031                                  * Consistent packets need to be sync'ed first
6032                                  */
6033                                 if ((acp->flags & AAC_CMD_CONSISTENT) &&
6034                                     (acp->flags & AAC_CMD_BUF_READ)) {
6035                                         if (aac_dma_sync_ac(acp) != AACOK) {
6036                                                 ddi_fm_service_impact(
6037                                                     softs->devinfo_p,
6038                                                     DDI_SERVICE_UNAFFECTED);
6039                                                 pkt->pkt_reason = CMD_TRAN_ERR;
6040                                                 pkt->pkt_statistics = 0;
6041                                         }
6042                                 }
6043                                 if ((aac_check_acc_handle(softs-> \
6044                                     comm_space_acc_handle) != DDI_SUCCESS) ||
6045                                     (aac_check_acc_handle(softs-> \
6046                                     pci_mem_handle) != DDI_SUCCESS)) {
6047                                         ddi_fm_service_impact(softs->devinfo_p,
6048                                             DDI_SERVICE_UNAFFECTED);
6049                                         ddi_fm_acc_err_clear(softs-> \
6050                                             pci_mem_handle, DDI_FME_VER0);
6051                                         pkt->pkt_reason = CMD_TRAN_ERR;
6052                                         pkt->pkt_statistics = 0;
6053                                 }
6054                                 if (aac_check_dma_handle(softs-> \
6055                                     comm_space_dma_handle) != DDI_SUCCESS) {
6056                                         ddi_fm_service_impact(softs->devinfo_p,
6057                                             DDI_SERVICE_UNAFFECTED);
6058                                         pkt->pkt_reason = CMD_TRAN_ERR;
6059                                         pkt->pkt_statistics = 0;
6060                                 }
6061                         }
6062                         scsi_hba_pkt_comp(pkt);
6063                 } else {
6064                         break;
6065                 }
6066         }
6067 }
6068 
6069 static int
6070 aac_alloc_fib(struct aac_softstate *softs, struct aac_slot *slotp)
6071 {
6072         size_t rlen;
6073         ddi_dma_cookie_t cookie;
6074         uint_t cookien;
6075 
6076         /* Allocate FIB dma resource */
6077         if (ddi_dma_alloc_handle(
6078             softs->devinfo_p,
6079             &softs->addr_dma_attr,
6080             DDI_DMA_SLEEP,
6081             NULL,
6082             &slotp->fib_dma_handle) != DDI_SUCCESS) {
6083                 AACDB_PRINT(softs, CE_WARN,
6084                     "Cannot alloc dma handle for slot fib area");
6085                 goto error;
6086         }
6087         if (ddi_dma_mem_alloc(
6088             slotp->fib_dma_handle,
6089             softs->aac_max_fib_size,
6090             &softs->acc_attr,
6091             DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
6092             DDI_DMA_SLEEP,
6093             NULL,
6094             (caddr_t *)&slotp->fibp,
6095             &rlen,
6096             &slotp->fib_acc_handle) != DDI_SUCCESS) {
6097                 AACDB_PRINT(softs, CE_WARN,
6098                     "Cannot alloc mem for slot fib area");
6099                 goto error;
6100         }
6101         if (ddi_dma_addr_bind_handle(
6102             slotp->fib_dma_handle,
6103             NULL,
6104             (caddr_t)slotp->fibp,
6105             softs->aac_max_fib_size,
6106             DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
6107             DDI_DMA_SLEEP,
6108             NULL,
6109             &cookie,
6110             &cookien) != DDI_DMA_MAPPED) {
6111                 AACDB_PRINT(softs, CE_WARN,
6112                     "dma bind failed for slot fib area");
6113                 goto error;
6114         }
6115 
6116         /* Check dma handles allocated in fib attach */
6117         if (aac_check_dma_handle(slotp->fib_dma_handle) != DDI_SUCCESS) {
6118                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
6119                 goto error;
6120         }
6121 
6122         /* Check acc handles allocated in fib attach */
6123         if (aac_check_acc_handle(slotp->fib_acc_handle) != DDI_SUCCESS) {
6124                 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
6125                 goto error;
6126         }
6127 
6128         slotp->fib_phyaddr = cookie.dmac_laddress;
6129         return (AACOK);
6130 
6131 error:
6132         if (slotp->fib_acc_handle) {
6133                 ddi_dma_mem_free(&slotp->fib_acc_handle);
6134                 slotp->fib_acc_handle = NULL;
6135         }
6136         if (slotp->fib_dma_handle) {
6137                 ddi_dma_free_handle(&slotp->fib_dma_handle);
6138                 slotp->fib_dma_handle = NULL;
6139         }
6140         return (AACERR);
6141 }
6142 
6143 static void
6144 aac_free_fib(struct aac_slot *slotp)
6145 {
6146         (void) ddi_dma_unbind_handle(slotp->fib_dma_handle);
6147         ddi_dma_mem_free(&slotp->fib_acc_handle);
6148         slotp->fib_acc_handle = NULL;
6149         ddi_dma_free_handle(&slotp->fib_dma_handle);
6150         slotp->fib_dma_handle = NULL;
6151         slotp->fib_phyaddr = 0;
6152 }
6153 
6154 static void
6155 aac_alloc_fibs(struct aac_softstate *softs)
6156 {
6157         int i;
6158         struct aac_slot *slotp;
6159 
6160         for (i = 0; i < softs->total_slots &&
6161             softs->total_fibs < softs->total_slots; i++) {
6162                 slotp = &(softs->io_slot[i]);
6163                 if (slotp->fib_phyaddr)
6164                         continue;
6165                 if (aac_alloc_fib(softs, slotp) != AACOK)
6166                         break;
6167 
6168                 /* Insert the slot to the free slot list */
6169                 aac_release_slot(softs, slotp);
6170                 softs->total_fibs++;
6171         }
6172 }
6173 
6174 static void
6175 aac_destroy_fibs(struct aac_softstate *softs)
6176 {
6177         struct aac_slot *slotp;
6178 
6179         while ((slotp = softs->free_io_slot_head) != NULL) {
6180                 ASSERT(slotp->fib_phyaddr);
6181                 softs->free_io_slot_head = slotp->next;
6182                 aac_free_fib(slotp);
6183                 ASSERT(slotp->index == (slotp - softs->io_slot));
6184                 softs->total_fibs--;
6185         }
6186         ASSERT(softs->total_fibs == 0);
6187 }
6188 
6189 static int
6190 aac_create_slots(struct aac_softstate *softs)
6191 {
6192         int i;
6193 
6194         softs->total_slots = softs->aac_max_fibs;
6195         softs->io_slot = kmem_zalloc(sizeof (struct aac_slot) * \
6196             softs->total_slots, KM_SLEEP);
6197         if (softs->io_slot == NULL) {
6198                 AACDB_PRINT(softs, CE_WARN, "Cannot allocate slot");
6199                 return (AACERR);
6200         }
6201         for (i = 0; i < softs->total_slots; i++)
6202                 softs->io_slot[i].index = i;
6203         softs->free_io_slot_head = NULL;
6204         softs->total_fibs = 0;
6205         return (AACOK);
6206 }
6207 
6208 static void
6209 aac_destroy_slots(struct aac_softstate *softs)
6210 {
6211         ASSERT(softs->free_io_slot_head == NULL);
6212 
6213         kmem_free(softs->io_slot, sizeof (struct aac_slot) * \
6214             softs->total_slots);
6215         softs->io_slot = NULL;
6216         softs->total_slots = 0;
6217 }
6218 
6219 struct aac_slot *
6220 aac_get_slot(struct aac_softstate *softs)
6221 {
6222         struct aac_slot *slotp;
6223 
6224         if ((slotp = softs->free_io_slot_head) != NULL) {
6225                 softs->free_io_slot_head = slotp->next;
6226                 slotp->next = NULL;
6227         }
6228         return (slotp);
6229 }
6230 
6231 static void
6232 aac_release_slot(struct aac_softstate *softs, struct aac_slot *slotp)
6233 {
6234         ASSERT((slotp->index >= 0) && (slotp->index < softs->total_slots));
6235         ASSERT(slotp == &softs->io_slot[slotp->index]);
6236 
6237         slotp->acp = NULL;
6238         slotp->next = softs->free_io_slot_head;
6239         softs->free_io_slot_head = slotp;
6240 }
6241 
6242 int
6243 aac_do_io(struct aac_softstate *softs, struct aac_cmd *acp)
6244 {
6245         if (aac_bind_io(softs, acp) == AACOK)
6246                 aac_start_io(softs, acp);
6247         else
6248                 aac_cmd_enqueue(&softs->q_wait[AAC_CMDQ(acp)], acp);
6249 
6250         if (!(acp->flags & (AAC_CMD_NO_CB | AAC_CMD_NO_INTR)))
6251                 return (TRAN_ACCEPT);
6252         /*
6253          * Because sync FIB is always 512 bytes and used for critical
6254          * functions, async FIB is used for poll IO.
6255          */
6256         if (acp->flags & AAC_CMD_NO_INTR) {
6257                 if (aac_do_poll_io(softs, acp) == AACOK)
6258                         return (TRAN_ACCEPT);
6259         } else {
6260                 if (aac_do_sync_io(softs, acp) == AACOK)
6261                         return (TRAN_ACCEPT);
6262         }
6263         return (TRAN_BADPKT);
6264 }
6265 
6266 static int
6267 aac_do_poll_io(struct aac_softstate *softs, struct aac_cmd *acp)
6268 {
6269         int (*intr_handler)(struct aac_softstate *);
6270 
6271         /*
6272          * Interrupt is disabled, we have to poll the adapter by ourselves.
6273          */
6274         intr_handler = (softs->flags & AAC_FLAGS_NEW_COMM) ?
6275             aac_process_intr_new : aac_process_intr_old;
6276         while (!(acp->flags & (AAC_CMD_CMPLT | AAC_CMD_ABORT))) {
6277                 int i = AAC_POLL_TIME * 1000;
6278 
6279                 AAC_BUSYWAIT((intr_handler(softs) != AAC_DB_RESPONSE_READY), i);
6280                 if (i == 0)
6281                         aac_cmd_timeout(softs, acp);
6282         }
6283 
6284         ddi_trigger_softintr(softs->softint_id);
6285 
6286         if ((acp->flags & AAC_CMD_CMPLT) && !(acp->flags & AAC_CMD_ERR))
6287                 return (AACOK);
6288         return (AACERR);
6289 }
6290 
6291 static int
6292 aac_do_sync_io(struct aac_softstate *softs, struct aac_cmd *acp)
6293 {
6294         ASSERT(softs && acp);
6295 
6296         while (!(acp->flags & (AAC_CMD_CMPLT | AAC_CMD_ABORT)))
6297                 cv_wait(&softs->event, &softs->io_lock);
6298 
6299         if (acp->flags & AAC_CMD_CMPLT)
6300                 return (AACOK);
6301         return (AACERR);
6302 }
6303 
6304 static int
6305 aac_dma_sync_ac(struct aac_cmd *acp)
6306 {
6307         if (acp->buf_dma_handle) {
6308                 if (acp->flags & AAC_CMD_BUF_WRITE) {
6309                         if (acp->abp != NULL)
6310                                 ddi_rep_put8(acp->abh,
6311                                     (uint8_t *)acp->bp->b_un.b_addr,
6312                                     (uint8_t *)acp->abp, acp->bp->b_bcount,
6313                                     DDI_DEV_AUTOINCR);
6314                         (void) ddi_dma_sync(acp->buf_dma_handle, 0, 0,
6315                             DDI_DMA_SYNC_FORDEV);
6316                 } else {
6317                         (void) ddi_dma_sync(acp->buf_dma_handle, 0, 0,
6318                             DDI_DMA_SYNC_FORCPU);
6319                         if (aac_check_dma_handle(acp->buf_dma_handle) !=
6320                             DDI_SUCCESS)
6321                                 return (AACERR);
6322                         if (acp->abp != NULL)
6323                                 ddi_rep_get8(acp->abh,
6324                                     (uint8_t *)acp->bp->b_un.b_addr,
6325                                     (uint8_t *)acp->abp, acp->bp->b_bcount,
6326                                     DDI_DEV_AUTOINCR);
6327                 }
6328         }
6329         return (AACOK);
6330 }
6331 
6332 /*
6333  * Copy AIF from adapter to the empty AIF slot and inform AIF threads
6334  */
6335 static void
6336 aac_save_aif(struct aac_softstate *softs, ddi_acc_handle_t acc,
6337     struct aac_fib *fibp0, int fib_size0)
6338 {
6339         struct aac_fib *fibp;   /* FIB in AIF queue */
6340         int fib_size;
6341         uint16_t fib_command;
6342         int current, next;
6343 
6344         /* Ignore non AIF messages */
6345         fib_command = ddi_get16(acc, &fibp0->Header.Command);
6346         if (fib_command != AifRequest) {
6347                 cmn_err(CE_WARN, "!Unknown command from controller");
6348                 return;
6349         }
6350 
6351         mutex_enter(&softs->aifq_mutex);
6352 
6353         /* Save AIF */
6354         fibp = &softs->aifq[softs->aifq_idx].d;
6355         fib_size = (fib_size0 > AAC_FIB_SIZE) ? AAC_FIB_SIZE : fib_size0;
6356         ddi_rep_get8(acc, (uint8_t *)fibp, (uint8_t *)fibp0, fib_size,
6357             DDI_DEV_AUTOINCR);
6358 
6359         if (aac_check_acc_handle(softs->pci_mem_handle) != DDI_SUCCESS) {
6360                 ddi_fm_service_impact(softs->devinfo_p,
6361                     DDI_SERVICE_UNAFFECTED);
6362                 mutex_exit(&softs->aifq_mutex);
6363                 return;
6364         }
6365 
6366         AACDB_PRINT_AIF(softs, (struct aac_aif_command *)&fibp->data[0]);
6367 
6368         /* Modify AIF contexts */
6369         current = softs->aifq_idx;
6370         next = (current + 1) % AAC_AIFQ_LENGTH;
6371         if (next == 0) {
6372                 struct aac_fib_context *ctx_p;
6373 
6374                 softs->aifq_wrap = 1;
6375                 for (ctx_p = softs->fibctx_p; ctx_p; ctx_p = ctx_p->next) {
6376                         if (next == ctx_p->ctx_idx) {
6377                                 ctx_p->ctx_flags |= AAC_CTXFLAG_FILLED;
6378                         } else if (current == ctx_p->ctx_idx &&
6379                             (ctx_p->ctx_flags & AAC_CTXFLAG_FILLED)) {
6380                                 ctx_p->ctx_idx = next;
6381                                 ctx_p->ctx_overrun++;
6382                         }
6383                 }
6384         }
6385         softs->aifq_idx = next;
6386 
6387         /* Wakeup AIF threads */
6388         cv_broadcast(&softs->aifq_cv);
6389         mutex_exit(&softs->aifq_mutex);
6390 
6391         /* Wakeup event thread to handle aif */
6392         aac_event_disp(softs, AAC_EVENT_AIF);
6393 }
6394 
6395 static int
6396 aac_return_aif_common(struct aac_softstate *softs, struct aac_fib_context *ctx,
6397     struct aac_fib **fibpp)
6398 {
6399         int current;
6400 
6401         current = ctx->ctx_idx;
6402         if (current == softs->aifq_idx &&
6403             !(ctx->ctx_flags & AAC_CTXFLAG_FILLED))
6404                 return (EAGAIN); /* Empty */
6405 
6406         *fibpp = &softs->aifq[current].d;
6407 
6408         ctx->ctx_flags &= ~AAC_CTXFLAG_FILLED;
6409         ctx->ctx_idx = (current + 1) % AAC_AIFQ_LENGTH;
6410         return (0);
6411 }
6412 
6413 int
6414 aac_return_aif(struct aac_softstate *softs, struct aac_fib_context *ctx,
6415     struct aac_fib **fibpp)
6416 {
6417         int rval;
6418 
6419         mutex_enter(&softs->aifq_mutex);
6420         rval = aac_return_aif_common(softs, ctx, fibpp);
6421         mutex_exit(&softs->aifq_mutex);
6422         return (rval);
6423 }
6424 
6425 int
6426 aac_return_aif_wait(struct aac_softstate *softs, struct aac_fib_context *ctx,
6427     struct aac_fib **fibpp)
6428 {
6429         int rval;
6430 
6431         mutex_enter(&softs->aifq_mutex);
6432         rval = aac_return_aif_common(softs, ctx, fibpp);
6433         if (rval == EAGAIN) {
6434                 AACDB_PRINT(softs, CE_NOTE, "Waiting for AIF");
6435                 rval = cv_wait_sig(&softs->aifq_cv, &softs->aifq_mutex);
6436         }
6437         mutex_exit(&softs->aifq_mutex);
6438         return ((rval > 0) ? 0 : EINTR);
6439 }
6440 
6441 /*
6442  * The following function comes from Adaptec:
6443  *
6444  * When driver sees a particular event that means containers are changed, it
6445  * will rescan containers. However a change may not be complete until some
6446  * other event is received. For example, creating or deleting an array will
6447  * incur as many as six AifEnConfigChange events which would generate six
6448  * container rescans. To diminish rescans, driver set a flag to wait for
6449  * another particular event. When sees that events come in, it will do rescan.
6450  */
6451 static int
6452 aac_handle_aif(struct aac_softstate *softs, struct aac_aif_command *aif)
6453 {
6454         ddi_acc_handle_t acc = softs->comm_space_acc_handle;
6455         int en_type;
6456         int devcfg_needed;
6457         int cid;
6458         uint32_t bus_id, tgt_id;
6459         enum aac_cfg_event event = AAC_CFG_NULL_EXIST;
6460 
6461         devcfg_needed = 0;
6462         en_type = LE_32((uint32_t)aif->data.EN.type);
6463 
6464         switch (LE_32((uint32_t)aif->command)) {
6465         case AifCmdDriverNotify: {
6466                 cid = LE_32(aif->data.EN.data.ECC.container[0]);
6467 
6468                 switch (en_type) {
6469                 case AifDenMorphComplete:
6470                 case AifDenVolumeExtendComplete:
6471                         if (AAC_DEV_IS_VALID(&softs->containers[cid].dev))
6472                                 softs->devcfg_wait_on = AifEnConfigChange;
6473                         break;
6474                 }
6475                 if (softs->devcfg_wait_on == en_type)
6476                         devcfg_needed = 1;
6477                 break;
6478         }
6479 
6480         case AifCmdEventNotify:
6481                 cid = LE_32(aif->data.EN.data.ECC.container[0]);
6482                 switch (en_type) {
6483                 case AifEnAddContainer:
6484                 case AifEnDeleteContainer:
6485                         softs->devcfg_wait_on = AifEnConfigChange;
6486                         break;
6487                 case AifEnContainerChange:
6488                         if (!softs->devcfg_wait_on)
6489                                 softs->devcfg_wait_on = AifEnConfigChange;
6490                         break;
6491                 case AifEnContainerEvent:
6492                         if (ddi_get32(acc, &aif-> \
6493                             data.EN.data.ECE.eventType) == CT_PUP_MISSING_DRIVE)
6494                                 devcfg_needed = 1;
6495                         break;
6496                 case AifEnAddJBOD:
6497                         if (!(softs->flags & AAC_FLAGS_JBOD))
6498                                 return (AACERR);
6499                         event = AAC_CFG_ADD;
6500                         bus_id = (cid >> 24) & 0xf;
6501                         tgt_id = cid & 0xffff;
6502                         break;
6503                 case AifEnDeleteJBOD:
6504                         if (!(softs->flags & AAC_FLAGS_JBOD))
6505                                 return (AACERR);
6506                         event = AAC_CFG_DELETE;
6507                         bus_id = (cid >> 24) & 0xf;
6508                         tgt_id = cid & 0xffff;
6509                         break;
6510                 }
6511                 if (softs->devcfg_wait_on == en_type)
6512                         devcfg_needed = 1;
6513                 break;
6514 
6515         case AifCmdJobProgress:
6516                 if (LE_32((uint32_t)aif->data.PR[0].jd.type) == AifJobCtrZero) {
6517                         int pr_status;
6518                         uint32_t pr_ftick, pr_ctick;
6519 
6520                         pr_status = LE_32((uint32_t)aif->data.PR[0].status);
6521                         pr_ctick = LE_32(aif->data.PR[0].currentTick);
6522                         pr_ftick = LE_32(aif->data.PR[0].finalTick);
6523 
6524                         if ((pr_ctick == pr_ftick) ||
6525                             (pr_status == AifJobStsSuccess))
6526                                 softs->devcfg_wait_on = AifEnContainerChange;
6527                         else if ((pr_ctick == 0) &&
6528                             (pr_status == AifJobStsRunning))
6529                                 softs->devcfg_wait_on = AifEnContainerChange;
6530                 }
6531                 break;
6532         }
6533 
6534         if (devcfg_needed) {
6535                 softs->devcfg_wait_on = 0;
6536                 (void) aac_probe_containers(softs);
6537         }
6538 
6539         if (event != AAC_CFG_NULL_EXIST) {
6540                 ASSERT(en_type == AifEnAddJBOD || en_type == AifEnDeleteJBOD);
6541                 (void) aac_probe_jbod(softs,
6542                     AAC_P2VTGT(softs, bus_id, tgt_id), event);
6543         }
6544         return (AACOK);
6545 }
6546 
6547 
6548 /*
6549  * Check and handle AIF events
6550  */
6551 static void
6552 aac_aif_event(struct aac_softstate *softs)
6553 {
6554         struct aac_fib *fibp;
6555 
6556         /*CONSTCOND*/
6557         while (1) {
6558                 if (aac_return_aif(softs, &softs->aifctx, &fibp) != 0)
6559                         break; /* No more AIFs to handle, end loop */
6560 
6561                 /* AIF overrun, array create/delete may missed. */
6562                 if (softs->aifctx.ctx_overrun) {
6563                         softs->aifctx.ctx_overrun = 0;
6564                 }
6565 
6566                 /* AIF received, handle it */
6567                 struct aac_aif_command *aifp =
6568                     (struct aac_aif_command *)&fibp->data[0];
6569                 uint32_t aif_command = LE_32((uint32_t)aifp->command);
6570 
6571                 if (aif_command == AifCmdDriverNotify ||
6572                     aif_command == AifCmdEventNotify ||
6573                     aif_command == AifCmdJobProgress)
6574                         (void) aac_handle_aif(softs, aifp);
6575         }
6576 }
6577 
6578 /*
6579  * Timeout recovery
6580  */
6581 /*ARGSUSED*/
6582 static void
6583 aac_cmd_timeout(struct aac_softstate *softs, struct aac_cmd *acp)
6584 {
6585 #ifdef DEBUG
6586         acp->fib_flags |= AACDB_FLAGS_FIB_TIMEOUT;
6587         AACDB_PRINT(softs, CE_WARN, "acp %p timed out", acp);
6588         AACDB_PRINT_FIB(softs, acp->slotp);
6589 #endif
6590 
6591         /*
6592          * Besides the firmware in unhealthy state, an overloaded
6593          * adapter may also incur pkt timeout.
6594          * There is a chance for an adapter with a slower IOP to take
6595          * longer than 60 seconds to process the commands, such as when
6596          * to perform IOs. So the adapter is doing a build on a RAID-5
6597          * while being required longer completion times should be
6598          * tolerated.
6599          */
6600         switch (aac_do_reset(softs)) {
6601         case AAC_IOP_RESET_SUCCEED:
6602                 aac_abort_iocmds(softs, AAC_IOCMD_OUTSTANDING, NULL, CMD_RESET);
6603                 aac_start_waiting_io(softs);
6604                 break;
6605         case AAC_IOP_RESET_FAILED:
6606                 /* Abort all waiting cmds when adapter is dead */
6607                 aac_abort_iocmds(softs, AAC_IOCMD_ALL, NULL, CMD_TIMEOUT);
6608                 break;
6609         case AAC_IOP_RESET_ABNORMAL:
6610                 aac_start_waiting_io(softs);
6611         }
6612 }
6613 
6614 /*
6615  * The following function comes from Adaptec:
6616  *
6617  * Time sync. command added to synchronize time with firmware every 30
6618  * minutes (required for correct AIF timestamps etc.)
6619  */
6620 static void
6621 aac_sync_tick(struct aac_softstate *softs)
6622 {
6623         ddi_acc_handle_t acc;
6624         int rval;
6625 
6626         mutex_enter(&softs->time_mutex);
6627         ASSERT(softs->time_sync <= softs->timebase);
6628         softs->time_sync = 0;
6629         mutex_exit(&softs->time_mutex);
6630 
6631         /* Time sync. with firmware every AAC_SYNC_TICK */
6632         (void) aac_sync_fib_slot_bind(softs, &softs->sync_ac);
6633         acc = softs->sync_ac.slotp->fib_acc_handle;
6634 
6635         ddi_put32(acc, (void *)&softs->sync_ac.slotp->fibp->data[0],
6636             ddi_get_time());
6637         rval = aac_sync_fib(softs, SendHostTime, AAC_FIB_SIZEOF(uint32_t));
6638         aac_sync_fib_slot_release(softs, &softs->sync_ac);
6639 
6640         mutex_enter(&softs->time_mutex);
6641         softs->time_sync = softs->timebase;
6642         if (rval != AACOK)
6643                 /* retry shortly */
6644                 softs->time_sync += aac_tick << 1;
6645         else
6646                 softs->time_sync += AAC_SYNC_TICK;
6647         mutex_exit(&softs->time_mutex);
6648 }
6649 
6650 /*
6651  * Timeout checking and handling
6652  */
6653 static void
6654 aac_daemon(struct aac_softstate *softs)
6655 {
6656         int time_out; /* set if timeout happened */
6657         int time_adjust;
6658         uint32_t softs_timebase;
6659 
6660         mutex_enter(&softs->time_mutex);
6661         ASSERT(softs->time_out <= softs->timebase);
6662         softs->time_out = 0;
6663         softs_timebase = softs->timebase;
6664         mutex_exit(&softs->time_mutex);
6665 
6666         /* Check slots for timeout pkts */
6667         time_adjust = 0;
6668         do {
6669                 struct aac_cmd *acp;
6670 
6671                 time_out = 0;
6672                 for (acp = softs->q_busy.q_head; acp; acp = acp->next) {
6673                         if (acp->timeout == 0)
6674                                 continue;
6675 
6676                         /*
6677                          * If timeout happened, update outstanding cmds
6678                          * to be checked later again.
6679                          */
6680                         if (time_adjust) {
6681                                 acp->timeout += time_adjust;
6682                                 continue;
6683                         }
6684 
6685                         if (acp->timeout <= softs_timebase) {
6686                                 aac_cmd_timeout(softs, acp);
6687                                 time_out = 1;
6688                                 time_adjust = aac_tick * drv_usectohz(1000000);
6689                                 break; /* timeout happened */
6690                         } else {
6691                                 break; /* no timeout */
6692                         }
6693                 }
6694         } while (time_out);
6695 
6696         mutex_enter(&softs->time_mutex);
6697         softs->time_out = softs->timebase + aac_tick;
6698         mutex_exit(&softs->time_mutex);
6699 }
6700 
6701 /*
6702  * The event thread handles various tasks serially for the other parts of
6703  * the driver, so that they can run fast.
6704  */
6705 static void
6706 aac_event_thread(struct aac_softstate *softs)
6707 {
6708         int run = 1;
6709 
6710         DBCALLED(softs, 1);
6711 
6712         mutex_enter(&softs->ev_lock);
6713         while (run) {
6714                 int events;
6715 
6716                 if ((events = softs->events) == 0) {
6717                         cv_wait(&softs->event_disp_cv, &softs->ev_lock);
6718                         events = softs->events;
6719                 }
6720                 softs->events = 0;
6721                 mutex_exit(&softs->ev_lock);
6722 
6723                 mutex_enter(&softs->io_lock);
6724                 if ((softs->state & AAC_STATE_RUN) &&
6725                     (softs->state & AAC_STATE_DEAD) == 0) {
6726                         if (events & AAC_EVENT_TIMEOUT)
6727                                 aac_daemon(softs);
6728                         if (events & AAC_EVENT_SYNCTICK)
6729                                 aac_sync_tick(softs);
6730                         if (events & AAC_EVENT_AIF)
6731                                 aac_aif_event(softs);
6732                 } else {
6733                         run = 0;
6734                 }
6735                 mutex_exit(&softs->io_lock);
6736 
6737                 mutex_enter(&softs->ev_lock);
6738         }
6739 
6740         cv_signal(&softs->event_wait_cv);
6741         mutex_exit(&softs->ev_lock);
6742 }
6743 
6744 /*
6745  * Internal timer. It is only responsbile for time counting and report time
6746  * related events. Events handling is done by aac_event_thread(), so that
6747  * the timer itself could be as precise as possible.
6748  */
6749 static void
6750 aac_timer(void *arg)
6751 {
6752         struct aac_softstate *softs = arg;
6753         int events = 0;
6754 
6755         mutex_enter(&softs->time_mutex);
6756 
6757         /* If timer is being stopped, exit */
6758         if (softs->timeout_id) {
6759                 softs->timeout_id = timeout(aac_timer, (void *)softs,
6760                     (aac_tick * drv_usectohz(1000000)));
6761         } else {
6762                 mutex_exit(&softs->time_mutex);
6763                 return;
6764         }
6765 
6766         /* Time counting */
6767         softs->timebase += aac_tick;
6768 
6769         /* Check time related events */
6770         if (softs->time_out && softs->time_out <= softs->timebase)
6771                 events |= AAC_EVENT_TIMEOUT;
6772         if (softs->time_sync && softs->time_sync <= softs->timebase)
6773                 events |= AAC_EVENT_SYNCTICK;
6774 
6775         mutex_exit(&softs->time_mutex);
6776 
6777         if (events)
6778                 aac_event_disp(softs, events);
6779 }
6780 
6781 /*
6782  * Dispatch events to daemon thread for handling
6783  */
6784 static void
6785 aac_event_disp(struct aac_softstate *softs, int events)
6786 {
6787         mutex_enter(&softs->ev_lock);
6788         softs->events |= events;
6789         cv_broadcast(&softs->event_disp_cv);
6790         mutex_exit(&softs->ev_lock);
6791 }
6792 
6793 /*
6794  * Architecture dependent functions
6795  */
6796 static int
6797 aac_rx_get_fwstatus(struct aac_softstate *softs)
6798 {
6799         return (PCI_MEM_GET32(softs, AAC_OMR0));
6800 }
6801 
6802 static int
6803 aac_rx_get_mailbox(struct aac_softstate *softs, int mb)
6804 {
6805         return (PCI_MEM_GET32(softs, AAC_RX_MAILBOX + mb * 4));
6806 }
6807 
6808 static void
6809 aac_rx_set_mailbox(struct aac_softstate *softs, uint32_t cmd,
6810     uint32_t arg0, uint32_t arg1, uint32_t arg2, uint32_t arg3)
6811 {
6812         PCI_MEM_PUT32(softs, AAC_RX_MAILBOX, cmd);
6813         PCI_MEM_PUT32(softs, AAC_RX_MAILBOX + 4, arg0);
6814         PCI_MEM_PUT32(softs, AAC_RX_MAILBOX + 8, arg1);
6815         PCI_MEM_PUT32(softs, AAC_RX_MAILBOX + 12, arg2);
6816         PCI_MEM_PUT32(softs, AAC_RX_MAILBOX + 16, arg3);
6817 }
6818 
6819 static int
6820 aac_rkt_get_fwstatus(struct aac_softstate *softs)
6821 {
6822         return (PCI_MEM_GET32(softs, AAC_OMR0));
6823 }
6824 
6825 static int
6826 aac_rkt_get_mailbox(struct aac_softstate *softs, int mb)
6827 {
6828         return (PCI_MEM_GET32(softs, AAC_RKT_MAILBOX + mb *4));
6829 }
6830 
6831 static void
6832 aac_rkt_set_mailbox(struct aac_softstate *softs, uint32_t cmd,
6833     uint32_t arg0, uint32_t arg1, uint32_t arg2, uint32_t arg3)
6834 {
6835         PCI_MEM_PUT32(softs, AAC_RKT_MAILBOX, cmd);
6836         PCI_MEM_PUT32(softs, AAC_RKT_MAILBOX + 4, arg0);
6837         PCI_MEM_PUT32(softs, AAC_RKT_MAILBOX + 8, arg1);
6838         PCI_MEM_PUT32(softs, AAC_RKT_MAILBOX + 12, arg2);
6839         PCI_MEM_PUT32(softs, AAC_RKT_MAILBOX + 16, arg3);
6840 }
6841 
6842 /*
6843  * cb_ops functions
6844  */
6845 static int
6846 aac_open(dev_t *devp, int flag, int otyp, cred_t *cred)
6847 {
6848         struct aac_softstate *softs;
6849         int minor0, minor;
6850         int instance;
6851 
6852         DBCALLED(NULL, 2);
6853 
6854         if (otyp != OTYP_BLK && otyp != OTYP_CHR)
6855                 return (EINVAL);
6856 
6857         minor0 = getminor(*devp);
6858         minor = AAC_SCSA_MINOR(minor0);
6859 
6860         if (AAC_IS_SCSA_NODE(minor))
6861                 return (scsi_hba_open(devp, flag, otyp, cred));
6862 
6863         instance = MINOR2INST(minor0);
6864         if (instance >= AAC_MAX_ADAPTERS)
6865                 return (ENXIO);
6866 
6867         softs = ddi_get_soft_state(aac_softstatep, instance);
6868         if (softs == NULL)
6869                 return (ENXIO);
6870 
6871         return (0);
6872 }
6873 
6874 /*ARGSUSED*/
6875 static int
6876 aac_close(dev_t dev, int flag, int otyp, cred_t *cred)
6877 {
6878         int minor0, minor;
6879         int instance;
6880 
6881         DBCALLED(NULL, 2);
6882 
6883         if (otyp != OTYP_BLK && otyp != OTYP_CHR)
6884                 return (EINVAL);
6885 
6886         minor0 = getminor(dev);
6887         minor = AAC_SCSA_MINOR(minor0);
6888 
6889         if (AAC_IS_SCSA_NODE(minor))
6890                 return (scsi_hba_close(dev, flag, otyp, cred));
6891 
6892         instance = MINOR2INST(minor0);
6893         if (instance >= AAC_MAX_ADAPTERS)
6894                 return (ENXIO);
6895 
6896         return (0);
6897 }
6898 
6899 static int
6900 aac_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p,
6901     int *rval_p)
6902 {
6903         struct aac_softstate *softs;
6904         int minor0, minor;
6905         int instance;
6906 
6907         DBCALLED(NULL, 2);
6908 
6909         if (drv_priv(cred_p) != 0)
6910                 return (EPERM);
6911 
6912         minor0 = getminor(dev);
6913         minor = AAC_SCSA_MINOR(minor0);
6914 
6915         if (AAC_IS_SCSA_NODE(minor))
6916                 return (scsi_hba_ioctl(dev, cmd, arg, flag, cred_p, rval_p));
6917 
6918         instance = MINOR2INST(minor0);
6919         if (instance < AAC_MAX_ADAPTERS) {
6920                 softs = ddi_get_soft_state(aac_softstatep, instance);
6921                 return (aac_do_ioctl(softs, dev, cmd, arg, flag));
6922         }
6923         return (ENXIO);
6924 }
6925 
6926 /*
6927  * The IO fault service error handling callback function
6928  */
6929 /*ARGSUSED*/
6930 static int
6931 aac_fm_error_cb(dev_info_t *dip, ddi_fm_error_t *err, const void *impl_data)
6932 {
6933         /*
6934          * as the driver can always deal with an error in any dma or
6935          * access handle, we can just return the fme_status value.
6936          */
6937         pci_ereport_post(dip, err, NULL);
6938         return (err->fme_status);
6939 }
6940 
6941 /*
6942  * aac_fm_init - initialize fma capabilities and register with IO
6943  *               fault services.
6944  */
6945 static void
6946 aac_fm_init(struct aac_softstate *softs)
6947 {
6948         /*
6949          * Need to change iblock to priority for new MSI intr
6950          */
6951         ddi_iblock_cookie_t fm_ibc;
6952 
6953         softs->fm_capabilities = ddi_getprop(DDI_DEV_T_ANY, softs->devinfo_p,
6954             DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS, "fm-capable",
6955             DDI_FM_EREPORT_CAPABLE | DDI_FM_ACCCHK_CAPABLE |
6956             DDI_FM_DMACHK_CAPABLE | DDI_FM_ERRCB_CAPABLE);
6957 
6958         /* Only register with IO Fault Services if we have some capability */
6959         if (softs->fm_capabilities) {
6960                 /* Adjust access and dma attributes for FMA */
6961                 softs->reg_attr.devacc_attr_access = DDI_FLAGERR_ACC;
6962                 softs->addr_dma_attr.dma_attr_flags |= DDI_DMA_FLAGERR;
6963                 softs->buf_dma_attr.dma_attr_flags |= DDI_DMA_FLAGERR;
6964 
6965                 /*
6966                  * Register capabilities with IO Fault Services.
6967                  * fm_capabilities will be updated to indicate
6968                  * capabilities actually supported (not requested.)
6969                  */
6970                 ddi_fm_init(softs->devinfo_p, &softs->fm_capabilities, &fm_ibc);
6971 
6972                 /*
6973                  * Initialize pci ereport capabilities if ereport
6974                  * capable (should always be.)
6975                  */
6976                 if (DDI_FM_EREPORT_CAP(softs->fm_capabilities) ||
6977                     DDI_FM_ERRCB_CAP(softs->fm_capabilities)) {
6978                         pci_ereport_setup(softs->devinfo_p);
6979                 }
6980 
6981                 /*
6982                  * Register error callback if error callback capable.
6983                  */
6984                 if (DDI_FM_ERRCB_CAP(softs->fm_capabilities)) {
6985                         ddi_fm_handler_register(softs->devinfo_p,
6986                             aac_fm_error_cb, (void *) softs);
6987                 }
6988         }
6989 }
6990 
6991 /*
6992  * aac_fm_fini - Releases fma capabilities and un-registers with IO
6993  *               fault services.
6994  */
6995 static void
6996 aac_fm_fini(struct aac_softstate *softs)
6997 {
6998         /* Only unregister FMA capabilities if registered */
6999         if (softs->fm_capabilities) {
7000                 /*
7001                  * Un-register error callback if error callback capable.
7002                  */
7003                 if (DDI_FM_ERRCB_CAP(softs->fm_capabilities)) {
7004                         ddi_fm_handler_unregister(softs->devinfo_p);
7005                 }
7006 
7007                 /*
7008                  * Release any resources allocated by pci_ereport_setup()
7009                  */
7010                 if (DDI_FM_EREPORT_CAP(softs->fm_capabilities) ||
7011                     DDI_FM_ERRCB_CAP(softs->fm_capabilities)) {
7012                         pci_ereport_teardown(softs->devinfo_p);
7013                 }
7014 
7015                 /* Unregister from IO Fault Services */
7016                 ddi_fm_fini(softs->devinfo_p);
7017 
7018                 /* Adjust access and dma attributes for FMA */
7019                 softs->reg_attr.devacc_attr_access = DDI_DEFAULT_ACC;
7020                 softs->addr_dma_attr.dma_attr_flags &= ~DDI_DMA_FLAGERR;
7021                 softs->buf_dma_attr.dma_attr_flags &= ~DDI_DMA_FLAGERR;
7022         }
7023 }
7024 
7025 int
7026 aac_check_acc_handle(ddi_acc_handle_t handle)
7027 {
7028         ddi_fm_error_t de;
7029 
7030         ddi_fm_acc_err_get(handle, &de, DDI_FME_VERSION);
7031         return (de.fme_status);
7032 }
7033 
7034 int
7035 aac_check_dma_handle(ddi_dma_handle_t handle)
7036 {
7037         ddi_fm_error_t de;
7038 
7039         ddi_fm_dma_err_get(handle, &de, DDI_FME_VERSION);
7040         return (de.fme_status);
7041 }
7042 
7043 void
7044 aac_fm_ereport(struct aac_softstate *softs, char *detail)
7045 {
7046         uint64_t ena;
7047         char buf[FM_MAX_CLASS];
7048 
7049         (void) snprintf(buf, FM_MAX_CLASS, "%s.%s", DDI_FM_DEVICE, detail);
7050         ena = fm_ena_generate(0, FM_ENA_FMT1);
7051         if (DDI_FM_EREPORT_CAP(softs->fm_capabilities)) {
7052                 ddi_fm_ereport_post(softs->devinfo_p, buf, ena, DDI_NOSLEEP,
7053                     FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERSION, NULL);
7054         }
7055 }
7056 
7057 /*
7058  * Autoconfiguration support
7059  */
7060 static int
7061 aac_parse_devname(char *devnm, int *tgt, int *lun)
7062 {
7063         char devbuf[SCSI_MAXNAMELEN];
7064         char *addr;
7065         char *p,  *tp, *lp;
7066         long num;
7067 
7068         /* Parse dev name and address */
7069         (void) strcpy(devbuf, devnm);
7070         addr = "";
7071         for (p = devbuf; *p != '\0'; p++) {
7072                 if (*p == '@') {
7073                         addr = p + 1;
7074                         *p = '\0';
7075                 } else if (*p == ':') {
7076                         *p = '\0';
7077                         break;
7078                 }
7079         }
7080 
7081         /* Parse taget and lun */
7082         for (p = tp = addr, lp = NULL; *p != '\0'; p++) {
7083                 if (*p == ',') {
7084                         lp = p + 1;
7085                         *p = '\0';
7086                         break;
7087                 }
7088         }
7089         if (tgt && tp) {
7090                 if (ddi_strtol(tp, NULL, 0x10, &num))
7091                         return (AACERR);
7092                 *tgt = (int)num;
7093         }
7094         if (lun && lp) {
7095                 if (ddi_strtol(lp, NULL, 0x10, &num))
7096                         return (AACERR);
7097                 *lun = (int)num;
7098         }
7099         return (AACOK);
7100 }
7101 
7102 static dev_info_t *
7103 aac_find_child(struct aac_softstate *softs, uint16_t tgt, uint8_t lun)
7104 {
7105         dev_info_t *child = NULL;
7106         char addr[SCSI_MAXNAMELEN];
7107         char tmp[MAXNAMELEN];
7108 
7109         if (tgt < AAC_MAX_LD) {
7110                 if (lun == 0) {
7111                         struct aac_device *dvp = &softs->containers[tgt].dev;
7112 
7113                         child = dvp->dip;
7114                 }
7115         } else {
7116                 (void) sprintf(addr, "%x,%x", tgt, lun);
7117                 for (child = ddi_get_child(softs->devinfo_p);
7118                     child; child = ddi_get_next_sibling(child)) {
7119                         /* We don't care about non-persistent node */
7120                         if (ndi_dev_is_persistent_node(child) == 0)
7121                                 continue;
7122 
7123                         if (aac_name_node(child, tmp, MAXNAMELEN) !=
7124                             DDI_SUCCESS)
7125                                 continue;
7126                         if (strcmp(addr, tmp) == 0)
7127                                 break;
7128                 }
7129         }
7130         return (child);
7131 }
7132 
7133 static int
7134 aac_config_child(struct aac_softstate *softs, struct scsi_device *sd,
7135     dev_info_t **dipp)
7136 {
7137         char *nodename = NULL;
7138         char **compatible = NULL;
7139         int ncompatible = 0;
7140         char *childname;
7141         dev_info_t *ldip = NULL;
7142         int tgt = sd->sd_address.a_target;
7143         int lun = sd->sd_address.a_lun;
7144         int dtype = sd->sd_inq->inq_dtype & DTYPE_MASK;
7145         int rval;
7146 
7147         DBCALLED(softs, 2);
7148 
7149         scsi_hba_nodename_compatible_get(sd->sd_inq, NULL, dtype,
7150             NULL, &nodename, &compatible, &ncompatible);
7151         if (nodename == NULL) {
7152                 AACDB_PRINT(softs, CE_WARN,
7153                     "found no comptible driver for t%dL%d", tgt, lun);
7154                 rval = NDI_FAILURE;
7155                 goto finish;
7156         }
7157         childname = (softs->legacy && dtype == DTYPE_DIRECT) ? "sd" : nodename;
7158 
7159         /* Create dev node */
7160         rval = ndi_devi_alloc(softs->devinfo_p, childname, DEVI_SID_NODEID,
7161             &ldip);
7162         if (rval == NDI_SUCCESS) {
7163                 if (ndi_prop_update_int(DDI_DEV_T_NONE, ldip, "target", tgt)
7164                     != DDI_PROP_SUCCESS) {
7165                         AACDB_PRINT(softs, CE_WARN, "unable to create "
7166                             "property for t%dL%d (target)", tgt, lun);
7167                         rval = NDI_FAILURE;
7168                         goto finish;
7169                 }
7170                 if (ndi_prop_update_int(DDI_DEV_T_NONE, ldip, "lun", lun)
7171                     != DDI_PROP_SUCCESS) {
7172                         AACDB_PRINT(softs, CE_WARN, "unable to create "
7173                             "property for t%dL%d (lun)", tgt, lun);
7174                         rval = NDI_FAILURE;
7175                         goto finish;
7176                 }
7177                 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, ldip,
7178                     "compatible", compatible, ncompatible)
7179                     != DDI_PROP_SUCCESS) {
7180                         AACDB_PRINT(softs, CE_WARN, "unable to create "
7181                             "property for t%dL%d (compatible)", tgt, lun);
7182                         rval = NDI_FAILURE;
7183                         goto finish;
7184                 }
7185 
7186                 rval = ndi_devi_online(ldip, NDI_ONLINE_ATTACH);
7187                 if (rval != NDI_SUCCESS) {
7188                         AACDB_PRINT(softs, CE_WARN, "unable to online t%dL%d",
7189                             tgt, lun);
7190                         ndi_prop_remove_all(ldip);
7191                         (void) ndi_devi_free(ldip);
7192                 }
7193         }
7194 finish:
7195         if (dipp)
7196                 *dipp = ldip;
7197 
7198         scsi_hba_nodename_compatible_free(nodename, compatible);
7199         return (rval);
7200 }
7201 
7202 /*ARGSUSED*/
7203 static int
7204 aac_probe_lun(struct aac_softstate *softs, struct scsi_device *sd)
7205 {
7206         int tgt = sd->sd_address.a_target;
7207         int lun = sd->sd_address.a_lun;
7208 
7209         DBCALLED(softs, 2);
7210 
7211         if (tgt < AAC_MAX_LD) {
7212                 enum aac_cfg_event event;
7213 
7214                 if (lun == 0) {
7215                         mutex_enter(&softs->io_lock);
7216                         event = aac_probe_container(softs, tgt);
7217                         mutex_exit(&softs->io_lock);
7218                         if ((event != AAC_CFG_NULL_NOEXIST) &&
7219                             (event != AAC_CFG_DELETE)) {
7220                                 if (scsi_hba_probe(sd, NULL) ==
7221                                     SCSIPROBE_EXISTS)
7222                                         return (NDI_SUCCESS);
7223                         }
7224                 }
7225                 return (NDI_FAILURE);
7226         } else {
7227                 int dtype;
7228                 int qual; /* device qualifier */
7229 
7230                 if (scsi_hba_probe(sd, NULL) != SCSIPROBE_EXISTS)
7231                         return (NDI_FAILURE);
7232 
7233                 dtype = sd->sd_inq->inq_dtype & DTYPE_MASK;
7234                 qual = dtype >> 5;
7235 
7236                 AACDB_PRINT(softs, CE_NOTE,
7237                     "Phys. device found: tgt %d dtype %d: %s",
7238                     tgt, dtype, sd->sd_inq->inq_vid);
7239 
7240                 /* Only non-DASD and JBOD mode DASD are allowed exposed */
7241                 if (dtype == DTYPE_RODIRECT /* CDROM */ ||
7242                     dtype == DTYPE_SEQUENTIAL /* TAPE */ ||
7243                     dtype == DTYPE_ESI /* SES */) {
7244                         if (!(softs->flags & AAC_FLAGS_NONDASD))
7245                                 return (NDI_FAILURE);
7246                         AACDB_PRINT(softs, CE_NOTE, "non-DASD %d found", tgt);
7247 
7248                 } else if (dtype == DTYPE_DIRECT) {
7249                         if (!(softs->flags & AAC_FLAGS_JBOD) || qual != 0)
7250                                 return (NDI_FAILURE);
7251                         AACDB_PRINT(softs, CE_NOTE, "JBOD DASD %d found", tgt);
7252                 }
7253 
7254                 mutex_enter(&softs->io_lock);
7255                 softs->nondasds[AAC_PD(tgt)].dev.flags |= AAC_DFLAG_VALID;
7256                 mutex_exit(&softs->io_lock);
7257                 return (NDI_SUCCESS);
7258         }
7259 }
7260 
7261 static int
7262 aac_config_lun(struct aac_softstate *softs, uint16_t tgt, uint8_t lun,
7263     dev_info_t **ldip)
7264 {
7265         struct scsi_device sd;
7266         dev_info_t *child;
7267         int rval;
7268 
7269         DBCALLED(softs, 2);
7270 
7271         if ((child = aac_find_child(softs, tgt, lun)) != NULL) {
7272                 if (ldip)
7273                         *ldip = child;
7274                 return (NDI_SUCCESS);
7275         }
7276 
7277         bzero(&sd, sizeof (struct scsi_device));
7278         sd.sd_address.a_hba_tran = softs->hba_tran;
7279         sd.sd_address.a_target = (uint16_t)tgt;
7280         sd.sd_address.a_lun = (uint8_t)lun;
7281         if ((rval = aac_probe_lun(softs, &sd)) == NDI_SUCCESS)
7282                 rval = aac_config_child(softs, &sd, ldip);
7283         /* scsi_unprobe is blank now. Free buffer manually */
7284         if (sd.sd_inq) {
7285                 kmem_free(sd.sd_inq, SUN_INQSIZE);
7286                 sd.sd_inq = (struct scsi_inquiry *)NULL;
7287         }
7288         return (rval);
7289 }
7290 
7291 static int
7292 aac_config_tgt(struct aac_softstate *softs, int tgt)
7293 {
7294         struct scsi_address ap;
7295         struct buf *bp = NULL;
7296         int buf_len = AAC_SCSI_RPTLUNS_HEAD_SIZE + AAC_SCSI_RPTLUNS_ADDR_SIZE;
7297         int list_len = 0;
7298         int lun_total = 0;
7299         dev_info_t *ldip;
7300         int i;
7301 
7302         ap.a_hba_tran = softs->hba_tran;
7303         ap.a_target = (uint16_t)tgt;
7304         ap.a_lun = 0;
7305 
7306         for (i = 0; i < 2; i++) {
7307                 struct scsi_pkt *pkt;
7308                 uchar_t *cdb;
7309                 uchar_t *p;
7310                 uint32_t data;
7311 
7312                 if (bp == NULL) {
7313                         if ((bp = scsi_alloc_consistent_buf(&ap, NULL,
7314                             buf_len, B_READ, NULL_FUNC, NULL)) == NULL)
7315                         return (AACERR);
7316                 }
7317                 if ((pkt = scsi_init_pkt(&ap, NULL, bp, CDB_GROUP5,
7318                     sizeof (struct scsi_arq_status), 0, PKT_CONSISTENT,
7319                     NULL, NULL)) == NULL) {
7320                         scsi_free_consistent_buf(bp);
7321                         return (AACERR);
7322                 }
7323                 cdb = pkt->pkt_cdbp;
7324                 bzero(cdb, CDB_GROUP5);
7325                 cdb[0] = SCMD_REPORT_LUNS;
7326 
7327                 /* Convert buffer len from local to LE_32 */
7328                 data = buf_len;
7329                 for (p = &cdb[9]; p > &cdb[5]; p--) {
7330                         *p = data & 0xff;
7331                         data >>= 8;
7332                 }
7333 
7334                 if (scsi_poll(pkt) < 0 ||
7335                     ((struct scsi_status *)pkt->pkt_scbp)->sts_chk) {
7336                         scsi_destroy_pkt(pkt);
7337                         break;
7338                 }
7339 
7340                 /* Convert list_len from LE_32 to local */
7341                 for (p = (uchar_t *)bp->b_un.b_addr;
7342                     p < (uchar_t *)bp->b_un.b_addr + 4; p++) {
7343                         data <<= 8;
7344                         data |= *p;
7345                 }
7346                 list_len = data;
7347                 if (buf_len < list_len + AAC_SCSI_RPTLUNS_HEAD_SIZE) {
7348                         scsi_free_consistent_buf(bp);
7349                         bp = NULL;
7350                         buf_len = list_len + AAC_SCSI_RPTLUNS_HEAD_SIZE;
7351                 }
7352                 scsi_destroy_pkt(pkt);
7353         }
7354         if (i >= 2) {
7355                 uint8_t *buf = (uint8_t *)(bp->b_un.b_addr +
7356                     AAC_SCSI_RPTLUNS_HEAD_SIZE);
7357 
7358                 for (i = 0; i < (list_len / AAC_SCSI_RPTLUNS_ADDR_SIZE); i++) {
7359                         uint16_t lun;
7360 
7361                         /* Determine report luns addressing type */
7362                         switch (buf[0] & AAC_SCSI_RPTLUNS_ADDR_MASK) {
7363                         /*
7364                          * Vendors in the field have been found to be
7365                          * concatenating bus/target/lun to equal the
7366                          * complete lun value instead of switching to
7367                          * flat space addressing
7368                          */
7369                         case AAC_SCSI_RPTLUNS_ADDR_PERIPHERAL:
7370                         case AAC_SCSI_RPTLUNS_ADDR_LOGICAL_UNIT:
7371                         case AAC_SCSI_RPTLUNS_ADDR_FLAT_SPACE:
7372                                 lun = ((buf[0] & 0x3f) << 8) | buf[1];
7373                                 if (lun > UINT8_MAX) {
7374                                         AACDB_PRINT(softs, CE_WARN,
7375                                             "abnormal lun number: %d", lun);
7376                                         break;
7377                                 }
7378                                 if (aac_config_lun(softs, tgt, lun, &ldip) ==
7379                                     NDI_SUCCESS)
7380                                         lun_total++;
7381                                 break;
7382                         }
7383 
7384                         buf += AAC_SCSI_RPTLUNS_ADDR_SIZE;
7385                 }
7386         } else {
7387                 /* The target may do not support SCMD_REPORT_LUNS. */
7388                 if (aac_config_lun(softs, tgt, 0, &ldip) == NDI_SUCCESS)
7389                         lun_total++;
7390         }
7391         scsi_free_consistent_buf(bp);
7392         return (lun_total);
7393 }
7394 
7395 static void
7396 aac_devcfg(struct aac_softstate *softs, int tgt, int en)
7397 {
7398         struct aac_device *dvp;
7399 
7400         mutex_enter(&softs->io_lock);
7401         dvp = AAC_DEV(softs, tgt);
7402         if (en)
7403                 dvp->flags |= AAC_DFLAG_CONFIGURING;
7404         else
7405                 dvp->flags &= ~AAC_DFLAG_CONFIGURING;
7406         mutex_exit(&softs->io_lock);
7407 }
7408 
7409 static int
7410 aac_tran_bus_config(dev_info_t *parent, uint_t flags, ddi_bus_config_op_t op,
7411     void *arg, dev_info_t **childp)
7412 {
7413         struct aac_softstate *softs;
7414         int circ = 0;
7415         int rval;
7416 
7417         if ((softs = ddi_get_soft_state(aac_softstatep,
7418             ddi_get_instance(parent))) == NULL)
7419                 return (NDI_FAILURE);
7420 
7421         /* Commands for bus config should be blocked as the bus is quiesced */
7422         mutex_enter(&softs->io_lock);
7423         if (softs->state & AAC_STATE_QUIESCED) {
7424                 AACDB_PRINT(softs, CE_NOTE,
7425                     "bus_config abroted because bus is quiesced");
7426                 mutex_exit(&softs->io_lock);
7427                 return (NDI_FAILURE);
7428         }
7429         mutex_exit(&softs->io_lock);
7430 
7431         DBCALLED(softs, 1);
7432 
7433         /* Hold the nexus across the bus_config */
7434         ndi_devi_enter(parent, &circ);
7435         switch (op) {
7436         case BUS_CONFIG_ONE: {
7437                 int tgt, lun;
7438 
7439                 if (aac_parse_devname(arg, &tgt, &lun) != AACOK) {
7440                         rval = NDI_FAILURE;
7441                         break;
7442                 }
7443                 if (tgt >= AAC_MAX_LD) {
7444                         if (tgt >= AAC_MAX_DEV(softs)) {
7445                                 rval = NDI_FAILURE;
7446                                 break;
7447                         }
7448                 }
7449 
7450                 AAC_DEVCFG_BEGIN(softs, tgt);
7451                 rval = aac_config_lun(softs, tgt, lun, childp);
7452                 AAC_DEVCFG_END(softs, tgt);
7453                 break;
7454         }
7455 
7456         case BUS_CONFIG_DRIVER:
7457         case BUS_CONFIG_ALL: {
7458                 uint32_t bus, tgt;
7459                 int index, total;
7460 
7461                 for (tgt = 0; tgt < AAC_MAX_LD; tgt++) {
7462                         AAC_DEVCFG_BEGIN(softs, tgt);
7463                         (void) aac_config_lun(softs, tgt, 0, NULL);
7464                         AAC_DEVCFG_END(softs, tgt);
7465                 }
7466 
7467                 /* Config the non-DASD devices connected to the card */
7468                 total = 0;
7469                 index = AAC_MAX_LD;
7470                 for (bus = 0; bus < softs->bus_max; bus++) {
7471                         AACDB_PRINT(softs, CE_NOTE, "bus %d:", bus);
7472                         for (tgt = 0; tgt < softs->tgt_max; tgt++, index++) {
7473                                 AAC_DEVCFG_BEGIN(softs, index);
7474                                 if (aac_config_tgt(softs, index))
7475                                         total++;
7476                                 AAC_DEVCFG_END(softs, index);
7477                         }
7478                 }
7479                 AACDB_PRINT(softs, CE_CONT,
7480                     "?Total %d phys. device(s) found", total);
7481                 rval = NDI_SUCCESS;
7482                 break;
7483         }
7484         }
7485 
7486         if (rval == NDI_SUCCESS)
7487                 rval = ndi_busop_bus_config(parent, flags, op, arg, childp, 0);
7488         ndi_devi_exit(parent, circ);
7489         return (rval);
7490 }
7491 
7492 /*ARGSUSED*/
7493 static int
7494 aac_handle_dr(struct aac_softstate *softs, int tgt, int lun, int event)
7495 {
7496         struct aac_device *dvp;
7497         dev_info_t *dip;
7498         int valid;
7499         int circ1 = 0;
7500 
7501         DBCALLED(softs, 1);
7502 
7503         /* Hold the nexus across the bus_config */
7504         dvp = AAC_DEV(softs, tgt);
7505         valid = AAC_DEV_IS_VALID(dvp);
7506         dip = dvp->dip;
7507         if (!(softs->state & AAC_STATE_RUN))
7508                 return (AACERR);
7509         mutex_exit(&softs->io_lock);
7510 
7511         switch (event) {
7512         case AAC_CFG_ADD:
7513         case AAC_CFG_DELETE:
7514                 /* Device onlined */
7515                 if (dip == NULL && valid) {
7516                         ndi_devi_enter(softs->devinfo_p, &circ1);
7517                         (void) aac_config_lun(softs, tgt, 0, NULL);
7518                         AACDB_PRINT(softs, CE_NOTE, "c%dt%dL%d onlined",
7519                             softs->instance, tgt, lun);
7520                         ndi_devi_exit(softs->devinfo_p, circ1);
7521                 }
7522                 /* Device offlined */
7523                 if (dip && !valid) {
7524                         mutex_enter(&softs->io_lock);
7525                         (void) aac_do_reset(softs);
7526                         mutex_exit(&softs->io_lock);
7527 
7528                         (void) ndi_devi_offline(dip, NDI_DEVI_REMOVE);
7529                         AACDB_PRINT(softs, CE_NOTE, "c%dt%dL%d offlined",
7530                             softs->instance, tgt, lun);
7531                 }
7532                 break;
7533         }
7534 
7535         mutex_enter(&softs->io_lock);
7536         return (AACOK);
7537 }
7538 
7539 #ifdef DEBUG
7540 
7541 /* -------------------------debug aid functions-------------------------- */
7542 
7543 #define AAC_FIB_CMD_KEY_STRINGS \
7544         TestCommandResponse, "TestCommandResponse", \
7545         TestAdapterCommand, "TestAdapterCommand", \
7546         LastTestCommand, "LastTestCommand", \
7547         ReinitHostNormCommandQueue, "ReinitHostNormCommandQueue", \
7548         ReinitHostHighCommandQueue, "ReinitHostHighCommandQueue", \
7549         ReinitHostHighRespQueue, "ReinitHostHighRespQueue", \
7550         ReinitHostNormRespQueue, "ReinitHostNormRespQueue", \
7551         ReinitAdapNormCommandQueue, "ReinitAdapNormCommandQueue", \
7552         ReinitAdapHighCommandQueue, "ReinitAdapHighCommandQueue", \
7553         ReinitAdapHighRespQueue, "ReinitAdapHighRespQueue", \
7554         ReinitAdapNormRespQueue, "ReinitAdapNormRespQueue", \
7555         InterfaceShutdown, "InterfaceShutdown", \
7556         DmaCommandFib, "DmaCommandFib", \
7557         StartProfile, "StartProfile", \
7558         TermProfile, "TermProfile", \
7559         SpeedTest, "SpeedTest", \
7560         TakeABreakPt, "TakeABreakPt", \
7561         RequestPerfData, "RequestPerfData", \
7562         SetInterruptDefTimer, "SetInterruptDefTimer", \
7563         SetInterruptDefCount, "SetInterruptDefCount", \
7564         GetInterruptDefStatus, "GetInterruptDefStatus", \
7565         LastCommCommand, "LastCommCommand", \
7566         NuFileSystem, "NuFileSystem", \
7567         UFS, "UFS", \
7568         HostFileSystem, "HostFileSystem", \
7569         LastFileSystemCommand, "LastFileSystemCommand", \
7570         ContainerCommand, "ContainerCommand", \
7571         ContainerCommand64, "ContainerCommand64", \
7572         ClusterCommand, "ClusterCommand", \
7573         ScsiPortCommand, "ScsiPortCommand", \
7574         ScsiPortCommandU64, "ScsiPortCommandU64", \
7575         AifRequest, "AifRequest", \
7576         CheckRevision, "CheckRevision", \
7577         FsaHostShutdown, "FsaHostShutdown", \
7578         RequestAdapterInfo, "RequestAdapterInfo", \
7579         IsAdapterPaused, "IsAdapterPaused", \
7580         SendHostTime, "SendHostTime", \
7581         LastMiscCommand, "LastMiscCommand"
7582 
7583 #define AAC_CTVM_SUBCMD_KEY_STRINGS \
7584         VM_Null, "VM_Null", \
7585         VM_NameServe, "VM_NameServe", \
7586         VM_ContainerConfig, "VM_ContainerConfig", \
7587         VM_Ioctl, "VM_Ioctl", \
7588         VM_FilesystemIoctl, "VM_FilesystemIoctl", \
7589         VM_CloseAll, "VM_CloseAll", \
7590         VM_CtBlockRead, "VM_CtBlockRead", \
7591         VM_CtBlockWrite, "VM_CtBlockWrite", \
7592         VM_SliceBlockRead, "VM_SliceBlockRead", \
7593         VM_SliceBlockWrite, "VM_SliceBlockWrite", \
7594         VM_DriveBlockRead, "VM_DriveBlockRead", \
7595         VM_DriveBlockWrite, "VM_DriveBlockWrite", \
7596         VM_EnclosureMgt, "VM_EnclosureMgt", \
7597         VM_Unused, "VM_Unused", \
7598         VM_CtBlockVerify, "VM_CtBlockVerify", \
7599         VM_CtPerf, "VM_CtPerf", \
7600         VM_CtBlockRead64, "VM_CtBlockRead64", \
7601         VM_CtBlockWrite64, "VM_CtBlockWrite64", \
7602         VM_CtBlockVerify64, "VM_CtBlockVerify64", \
7603         VM_CtHostRead64, "VM_CtHostRead64", \
7604         VM_CtHostWrite64, "VM_CtHostWrite64", \
7605         VM_NameServe64, "VM_NameServe64"
7606 
7607 #define AAC_CT_SUBCMD_KEY_STRINGS \
7608         CT_Null, "CT_Null", \
7609         CT_GET_SLICE_COUNT, "CT_GET_SLICE_COUNT", \
7610         CT_GET_PARTITION_COUNT, "CT_GET_PARTITION_COUNT", \
7611         CT_GET_PARTITION_INFO, "CT_GET_PARTITION_INFO", \
7612         CT_GET_CONTAINER_COUNT, "CT_GET_CONTAINER_COUNT", \
7613         CT_GET_CONTAINER_INFO_OLD, "CT_GET_CONTAINER_INFO_OLD", \
7614         CT_WRITE_MBR, "CT_WRITE_MBR", \
7615         CT_WRITE_PARTITION, "CT_WRITE_PARTITION", \
7616         CT_UPDATE_PARTITION, "CT_UPDATE_PARTITION", \
7617         CT_UNLOAD_CONTAINER, "CT_UNLOAD_CONTAINER", \
7618         CT_CONFIG_SINGLE_PRIMARY, "CT_CONFIG_SINGLE_PRIMARY", \
7619         CT_READ_CONFIG_AGE, "CT_READ_CONFIG_AGE", \
7620         CT_WRITE_CONFIG_AGE, "CT_WRITE_CONFIG_AGE", \
7621         CT_READ_SERIAL_NUMBER, "CT_READ_SERIAL_NUMBER", \
7622         CT_ZERO_PAR_ENTRY, "CT_ZERO_PAR_ENTRY", \
7623         CT_READ_MBR, "CT_READ_MBR", \
7624         CT_READ_PARTITION, "CT_READ_PARTITION", \
7625         CT_DESTROY_CONTAINER, "CT_DESTROY_CONTAINER", \
7626         CT_DESTROY2_CONTAINER, "CT_DESTROY2_CONTAINER", \
7627         CT_SLICE_SIZE, "CT_SLICE_SIZE", \
7628         CT_CHECK_CONFLICTS, "CT_CHECK_CONFLICTS", \
7629         CT_MOVE_CONTAINER, "CT_MOVE_CONTAINER", \
7630         CT_READ_LAST_DRIVE, "CT_READ_LAST_DRIVE", \
7631         CT_WRITE_LAST_DRIVE, "CT_WRITE_LAST_DRIVE", \
7632         CT_UNMIRROR, "CT_UNMIRROR", \
7633         CT_MIRROR_DELAY, "CT_MIRROR_DELAY", \
7634         CT_GEN_MIRROR, "CT_GEN_MIRROR", \
7635         CT_GEN_MIRROR2, "CT_GEN_MIRROR2", \
7636         CT_TEST_CONTAINER, "CT_TEST_CONTAINER", \
7637         CT_MOVE2, "CT_MOVE2", \
7638         CT_SPLIT, "CT_SPLIT", \
7639         CT_SPLIT2, "CT_SPLIT2", \
7640         CT_SPLIT_BROKEN, "CT_SPLIT_BROKEN", \
7641         CT_SPLIT_BROKEN2, "CT_SPLIT_BROKEN2", \
7642         CT_RECONFIG, "CT_RECONFIG", \
7643         CT_BREAK2, "CT_BREAK2", \
7644         CT_BREAK, "CT_BREAK", \
7645         CT_MERGE2, "CT_MERGE2", \
7646         CT_MERGE, "CT_MERGE", \
7647         CT_FORCE_ERROR, "CT_FORCE_ERROR", \
7648         CT_CLEAR_ERROR, "CT_CLEAR_ERROR", \
7649         CT_ASSIGN_FAILOVER, "CT_ASSIGN_FAILOVER", \
7650         CT_CLEAR_FAILOVER, "CT_CLEAR_FAILOVER", \
7651         CT_GET_FAILOVER_DATA, "CT_GET_FAILOVER_DATA", \
7652         CT_VOLUME_ADD, "CT_VOLUME_ADD", \
7653         CT_VOLUME_ADD2, "CT_VOLUME_ADD2", \
7654         CT_MIRROR_STATUS, "CT_MIRROR_STATUS", \
7655         CT_COPY_STATUS, "CT_COPY_STATUS", \
7656         CT_COPY, "CT_COPY", \
7657         CT_UNLOCK_CONTAINER, "CT_UNLOCK_CONTAINER", \
7658         CT_LOCK_CONTAINER, "CT_LOCK_CONTAINER", \
7659         CT_MAKE_READ_ONLY, "CT_MAKE_READ_ONLY", \
7660         CT_MAKE_READ_WRITE, "CT_MAKE_READ_WRITE", \
7661         CT_CLEAN_DEAD, "CT_CLEAN_DEAD", \
7662         CT_ABORT_MIRROR_COMMAND, "CT_ABORT_MIRROR_COMMAND", \
7663         CT_SET, "CT_SET", \
7664         CT_GET, "CT_GET", \
7665         CT_GET_NVLOG_ENTRY, "CT_GET_NVLOG_ENTRY", \
7666         CT_GET_DELAY, "CT_GET_DELAY", \
7667         CT_ZERO_CONTAINER_SPACE, "CT_ZERO_CONTAINER_SPACE", \
7668         CT_GET_ZERO_STATUS, "CT_GET_ZERO_STATUS", \
7669         CT_SCRUB, "CT_SCRUB", \
7670         CT_GET_SCRUB_STATUS, "CT_GET_SCRUB_STATUS", \
7671         CT_GET_SLICE_INFO, "CT_GET_SLICE_INFO", \
7672         CT_GET_SCSI_METHOD, "CT_GET_SCSI_METHOD", \
7673         CT_PAUSE_IO, "CT_PAUSE_IO", \
7674         CT_RELEASE_IO, "CT_RELEASE_IO", \
7675         CT_SCRUB2, "CT_SCRUB2", \
7676         CT_MCHECK, "CT_MCHECK", \
7677         CT_CORRUPT, "CT_CORRUPT", \
7678         CT_GET_TASK_COUNT, "CT_GET_TASK_COUNT", \
7679         CT_PROMOTE, "CT_PROMOTE", \
7680         CT_SET_DEAD, "CT_SET_DEAD", \
7681         CT_CONTAINER_OPTIONS, "CT_CONTAINER_OPTIONS", \
7682         CT_GET_NV_PARAM, "CT_GET_NV_PARAM", \
7683         CT_GET_PARAM, "CT_GET_PARAM", \
7684         CT_NV_PARAM_SIZE, "CT_NV_PARAM_SIZE", \
7685         CT_COMMON_PARAM_SIZE, "CT_COMMON_PARAM_SIZE", \
7686         CT_PLATFORM_PARAM_SIZE, "CT_PLATFORM_PARAM_SIZE", \
7687         CT_SET_NV_PARAM, "CT_SET_NV_PARAM", \
7688         CT_ABORT_SCRUB, "CT_ABORT_SCRUB", \
7689         CT_GET_SCRUB_ERROR, "CT_GET_SCRUB_ERROR", \
7690         CT_LABEL_CONTAINER, "CT_LABEL_CONTAINER", \
7691         CT_CONTINUE_DATA, "CT_CONTINUE_DATA", \
7692         CT_STOP_DATA, "CT_STOP_DATA", \
7693         CT_GET_PARTITION_TABLE, "CT_GET_PARTITION_TABLE", \
7694         CT_GET_DISK_PARTITIONS, "CT_GET_DISK_PARTITIONS", \
7695         CT_GET_MISC_STATUS, "CT_GET_MISC_STATUS", \
7696         CT_GET_CONTAINER_PERF_INFO, "CT_GET_CONTAINER_PERF_INFO", \
7697         CT_GET_TIME, "CT_GET_TIME", \
7698         CT_READ_DATA, "CT_READ_DATA", \
7699         CT_CTR, "CT_CTR", \
7700         CT_CTL, "CT_CTL", \
7701         CT_DRAINIO, "CT_DRAINIO", \
7702         CT_RELEASEIO, "CT_RELEASEIO", \
7703         CT_GET_NVRAM, "CT_GET_NVRAM", \
7704         CT_GET_MEMORY, "CT_GET_MEMORY", \
7705         CT_PRINT_CT_LOG, "CT_PRINT_CT_LOG", \
7706         CT_ADD_LEVEL, "CT_ADD_LEVEL", \
7707         CT_NV_ZERO, "CT_NV_ZERO", \
7708         CT_READ_SIGNATURE, "CT_READ_SIGNATURE", \
7709         CT_THROTTLE_ON, "CT_THROTTLE_ON", \
7710         CT_THROTTLE_OFF, "CT_THROTTLE_OFF", \
7711         CT_GET_THROTTLE_STATS, "CT_GET_THROTTLE_STATS", \
7712         CT_MAKE_SNAPSHOT, "CT_MAKE_SNAPSHOT", \
7713         CT_REMOVE_SNAPSHOT, "CT_REMOVE_SNAPSHOT", \
7714         CT_WRITE_USER_FLAGS, "CT_WRITE_USER_FLAGS", \
7715         CT_READ_USER_FLAGS, "CT_READ_USER_FLAGS", \
7716         CT_MONITOR, "CT_MONITOR", \
7717         CT_GEN_MORPH, "CT_GEN_MORPH", \
7718         CT_GET_SNAPSHOT_INFO, "CT_GET_SNAPSHOT_INFO", \
7719         CT_CACHE_SET, "CT_CACHE_SET", \
7720         CT_CACHE_STAT, "CT_CACHE_STAT", \
7721         CT_TRACE_START, "CT_TRACE_START", \
7722         CT_TRACE_STOP, "CT_TRACE_STOP", \
7723         CT_TRACE_ENABLE, "CT_TRACE_ENABLE", \
7724         CT_TRACE_DISABLE, "CT_TRACE_DISABLE", \
7725         CT_FORCE_CORE_DUMP, "CT_FORCE_CORE_DUMP", \
7726         CT_SET_SERIAL_NUMBER, "CT_SET_SERIAL_NUMBER", \
7727         CT_RESET_SERIAL_NUMBER, "CT_RESET_SERIAL_NUMBER", \
7728         CT_ENABLE_RAID5, "CT_ENABLE_RAID5", \
7729         CT_CLEAR_VALID_DUMP_FLAG, "CT_CLEAR_VALID_DUMP_FLAG", \
7730         CT_GET_MEM_STATS, "CT_GET_MEM_STATS", \
7731         CT_GET_CORE_SIZE, "CT_GET_CORE_SIZE", \
7732         CT_CREATE_CONTAINER_OLD, "CT_CREATE_CONTAINER_OLD", \
7733         CT_STOP_DUMPS, "CT_STOP_DUMPS", \
7734         CT_PANIC_ON_TAKE_A_BREAK, "CT_PANIC_ON_TAKE_A_BREAK", \
7735         CT_GET_CACHE_STATS, "CT_GET_CACHE_STATS", \
7736         CT_MOVE_PARTITION, "CT_MOVE_PARTITION", \
7737         CT_FLUSH_CACHE, "CT_FLUSH_CACHE", \
7738         CT_READ_NAME, "CT_READ_NAME", \
7739         CT_WRITE_NAME, "CT_WRITE_NAME", \
7740         CT_TOSS_CACHE, "CT_TOSS_CACHE", \
7741         CT_LOCK_DRAINIO, "CT_LOCK_DRAINIO", \
7742         CT_CONTAINER_OFFLINE, "CT_CONTAINER_OFFLINE", \
7743         CT_SET_CACHE_SIZE, "CT_SET_CACHE_SIZE", \
7744         CT_CLEAN_SHUTDOWN_STATUS, "CT_CLEAN_SHUTDOWN_STATUS", \
7745         CT_CLEAR_DISKLOG_ON_DISK, "CT_CLEAR_DISKLOG_ON_DISK", \
7746         CT_CLEAR_ALL_DISKLOG, "CT_CLEAR_ALL_DISKLOG", \
7747         CT_CACHE_FAVOR, "CT_CACHE_FAVOR", \
7748         CT_READ_PASSTHRU_MBR, "CT_READ_PASSTHRU_MBR", \
7749         CT_SCRUB_NOFIX, "CT_SCRUB_NOFIX", \
7750         CT_SCRUB2_NOFIX, "CT_SCRUB2_NOFIX", \
7751         CT_FLUSH, "CT_FLUSH", \
7752         CT_REBUILD, "CT_REBUILD", \
7753         CT_FLUSH_CONTAINER, "CT_FLUSH_CONTAINER", \
7754         CT_RESTART, "CT_RESTART", \
7755         CT_GET_CONFIG_STATUS, "CT_GET_CONFIG_STATUS", \
7756         CT_TRACE_FLAG, "CT_TRACE_FLAG", \
7757         CT_RESTART_MORPH, "CT_RESTART_MORPH", \
7758         CT_GET_TRACE_INFO, "CT_GET_TRACE_INFO", \
7759         CT_GET_TRACE_ITEM, "CT_GET_TRACE_ITEM", \
7760         CT_COMMIT_CONFIG, "CT_COMMIT_CONFIG", \
7761         CT_CONTAINER_EXISTS, "CT_CONTAINER_EXISTS", \
7762         CT_GET_SLICE_FROM_DEVT, "CT_GET_SLICE_FROM_DEVT", \
7763         CT_OPEN_READ_WRITE, "CT_OPEN_READ_WRITE", \
7764         CT_WRITE_MEMORY_BLOCK, "CT_WRITE_MEMORY_BLOCK", \
7765         CT_GET_CACHE_PARAMS, "CT_GET_CACHE_PARAMS", \
7766         CT_CRAZY_CACHE, "CT_CRAZY_CACHE", \
7767         CT_GET_PROFILE_STRUCT, "CT_GET_PROFILE_STRUCT", \
7768         CT_SET_IO_TRACE_FLAG, "CT_SET_IO_TRACE_FLAG", \
7769         CT_GET_IO_TRACE_STRUCT, "CT_GET_IO_TRACE_STRUCT", \
7770         CT_CID_TO_64BITS_UID, "CT_CID_TO_64BITS_UID", \
7771         CT_64BITS_UID_TO_CID, "CT_64BITS_UID_TO_CID", \
7772         CT_PAR_TO_64BITS_UID, "CT_PAR_TO_64BITS_UID", \
7773         CT_CID_TO_32BITS_UID, "CT_CID_TO_32BITS_UID", \
7774         CT_32BITS_UID_TO_CID, "CT_32BITS_UID_TO_CID", \
7775         CT_PAR_TO_32BITS_UID, "CT_PAR_TO_32BITS_UID", \
7776         CT_SET_FAILOVER_OPTION, "CT_SET_FAILOVER_OPTION", \
7777         CT_GET_FAILOVER_OPTION, "CT_GET_FAILOVER_OPTION", \
7778         CT_STRIPE_ADD2, "CT_STRIPE_ADD2", \
7779         CT_CREATE_VOLUME_SET, "CT_CREATE_VOLUME_SET", \
7780         CT_CREATE_STRIPE_SET, "CT_CREATE_STRIPE_SET", \
7781         CT_VERIFY_CONTAINER, "CT_VERIFY_CONTAINER", \
7782         CT_IS_CONTAINER_DEAD, "CT_IS_CONTAINER_DEAD", \
7783         CT_GET_CONTAINER_OPTION, "CT_GET_CONTAINER_OPTION", \
7784         CT_GET_SNAPSHOT_UNUSED_STRUCT, "CT_GET_SNAPSHOT_UNUSED_STRUCT", \
7785         CT_CLEAR_SNAPSHOT_UNUSED_STRUCT, "CT_CLEAR_SNAPSHOT_UNUSED_STRUCT", \
7786         CT_GET_CONTAINER_INFO, "CT_GET_CONTAINER_INFO", \
7787         CT_CREATE_CONTAINER, "CT_CREATE_CONTAINER", \
7788         CT_CHANGE_CREATIONINFO, "CT_CHANGE_CREATIONINFO", \
7789         CT_CHECK_CONFLICT_UID, "CT_CHECK_CONFLICT_UID", \
7790         CT_CONTAINER_UID_CHECK, "CT_CONTAINER_UID_CHECK", \
7791         CT_IS_CONTAINER_MEATADATA_STANDARD, \
7792             "CT_IS_CONTAINER_MEATADATA_STANDARD", \
7793         CT_IS_SLICE_METADATA_STANDARD, "CT_IS_SLICE_METADATA_STANDARD", \
7794         CT_GET_IMPORT_COUNT, "CT_GET_IMPORT_COUNT", \
7795         CT_CANCEL_ALL_IMPORTS, "CT_CANCEL_ALL_IMPORTS", \
7796         CT_GET_IMPORT_INFO, "CT_GET_IMPORT_INFO", \
7797         CT_IMPORT_ARRAY, "CT_IMPORT_ARRAY", \
7798         CT_GET_LOG_SIZE, "CT_GET_LOG_SIZE", \
7799         CT_ALARM_GET_STATE, "CT_ALARM_GET_STATE", \
7800         CT_ALARM_SET_STATE, "CT_ALARM_SET_STATE", \
7801         CT_ALARM_ON_OFF, "CT_ALARM_ON_OFF", \
7802         CT_GET_EE_OEM_ID, "CT_GET_EE_OEM_ID", \
7803         CT_GET_PPI_HEADERS, "CT_GET_PPI_HEADERS", \
7804         CT_GET_PPI_DATA, "CT_GET_PPI_DATA", \
7805         CT_GET_PPI_ENTRIES, "CT_GET_PPI_ENTRIES", \
7806         CT_DELETE_PPI_BUNDLE, "CT_DELETE_PPI_BUNDLE", \
7807         CT_GET_PARTITION_TABLE_2, "CT_GET_PARTITION_TABLE_2", \
7808         CT_GET_PARTITION_INFO_2, "CT_GET_PARTITION_INFO_2", \
7809         CT_GET_DISK_PARTITIONS_2, "CT_GET_DISK_PARTITIONS_2", \
7810         CT_QUIESCE_ADAPTER, "CT_QUIESCE_ADAPTER", \
7811         CT_CLEAR_PPI_TABLE, "CT_CLEAR_PPI_TABLE"
7812 
7813 #define AAC_CL_SUBCMD_KEY_STRINGS \
7814         CL_NULL, "CL_NULL", \
7815         DS_INIT, "DS_INIT", \
7816         DS_RESCAN, "DS_RESCAN", \
7817         DS_CREATE, "DS_CREATE", \
7818         DS_DELETE, "DS_DELETE", \
7819         DS_ADD_DISK, "DS_ADD_DISK", \
7820         DS_REMOVE_DISK, "DS_REMOVE_DISK", \
7821         DS_MOVE_DISK, "DS_MOVE_DISK", \
7822         DS_TAKE_OWNERSHIP, "DS_TAKE_OWNERSHIP", \
7823         DS_RELEASE_OWNERSHIP, "DS_RELEASE_OWNERSHIP", \
7824         DS_FORCE_OWNERSHIP, "DS_FORCE_OWNERSHIP", \
7825         DS_GET_DISK_SET_PARAM, "DS_GET_DISK_SET_PARAM", \
7826         DS_GET_DRIVE_PARAM, "DS_GET_DRIVE_PARAM", \
7827         DS_GET_SLICE_PARAM, "DS_GET_SLICE_PARAM", \
7828         DS_GET_DISK_SETS, "DS_GET_DISK_SETS", \
7829         DS_GET_DRIVES, "DS_GET_DRIVES", \
7830         DS_SET_DISK_SET_PARAM, "DS_SET_DISK_SET_PARAM", \
7831         DS_ONLINE, "DS_ONLINE", \
7832         DS_OFFLINE, "DS_OFFLINE", \
7833         DS_ONLINE_CONTAINERS, "DS_ONLINE_CONTAINERS", \
7834         DS_FSAPRINT, "DS_FSAPRINT", \
7835         CL_CFG_SET_HOST_IDS, "CL_CFG_SET_HOST_IDS", \
7836         CL_CFG_SET_PARTNER_HOST_IDS, "CL_CFG_SET_PARTNER_HOST_IDS", \
7837         CL_CFG_GET_CLUSTER_CONFIG, "CL_CFG_GET_CLUSTER_CONFIG", \
7838         CC_CLI_CLEAR_MESSAGE_BUFFER, "CC_CLI_CLEAR_MESSAGE_BUFFER", \
7839         CC_SRV_CLEAR_MESSAGE_BUFFER, "CC_SRV_CLEAR_MESSAGE_BUFFER", \
7840         CC_CLI_SHOW_MESSAGE_BUFFER, "CC_CLI_SHOW_MESSAGE_BUFFER", \
7841         CC_SRV_SHOW_MESSAGE_BUFFER, "CC_SRV_SHOW_MESSAGE_BUFFER", \
7842         CC_CLI_SEND_MESSAGE, "CC_CLI_SEND_MESSAGE", \
7843         CC_SRV_SEND_MESSAGE, "CC_SRV_SEND_MESSAGE", \
7844         CC_CLI_GET_MESSAGE, "CC_CLI_GET_MESSAGE", \
7845         CC_SRV_GET_MESSAGE, "CC_SRV_GET_MESSAGE", \
7846         CC_SEND_TEST_MESSAGE, "CC_SEND_TEST_MESSAGE", \
7847         CC_GET_BUSINFO, "CC_GET_BUSINFO", \
7848         CC_GET_PORTINFO, "CC_GET_PORTINFO", \
7849         CC_GET_NAMEINFO, "CC_GET_NAMEINFO", \
7850         CC_GET_CONFIGINFO, "CC_GET_CONFIGINFO", \
7851         CQ_QUORUM_OP, "CQ_QUORUM_OP"
7852 
7853 #define AAC_AIF_SUBCMD_KEY_STRINGS \
7854         AifCmdEventNotify, "AifCmdEventNotify", \
7855         AifCmdJobProgress, "AifCmdJobProgress", \
7856         AifCmdAPIReport, "AifCmdAPIReport", \
7857         AifCmdDriverNotify, "AifCmdDriverNotify", \
7858         AifReqJobList, "AifReqJobList", \
7859         AifReqJobsForCtr, "AifReqJobsForCtr", \
7860         AifReqJobsForScsi, "AifReqJobsForScsi", \
7861         AifReqJobReport, "AifReqJobReport", \
7862         AifReqTerminateJob, "AifReqTerminateJob", \
7863         AifReqSuspendJob, "AifReqSuspendJob", \
7864         AifReqResumeJob, "AifReqResumeJob", \
7865         AifReqSendAPIReport, "AifReqSendAPIReport", \
7866         AifReqAPIJobStart, "AifReqAPIJobStart", \
7867         AifReqAPIJobUpdate, "AifReqAPIJobUpdate", \
7868         AifReqAPIJobFinish, "AifReqAPIJobFinish"
7869 
7870 #define AAC_IOCTL_SUBCMD_KEY_STRINGS \
7871         Reserved_IOCTL, "Reserved_IOCTL", \
7872         GetDeviceHandle, "GetDeviceHandle", \
7873         BusTargetLun_to_DeviceHandle, "BusTargetLun_to_DeviceHandle", \
7874         DeviceHandle_to_BusTargetLun, "DeviceHandle_to_BusTargetLun", \
7875         RescanBus, "RescanBus", \
7876         GetDeviceProbeInfo, "GetDeviceProbeInfo", \
7877         GetDeviceCapacity, "GetDeviceCapacity", \
7878         GetContainerProbeInfo, "GetContainerProbeInfo", \
7879         GetRequestedMemorySize, "GetRequestedMemorySize", \
7880         GetBusInfo, "GetBusInfo", \
7881         GetVendorSpecific, "GetVendorSpecific", \
7882         EnhancedGetDeviceProbeInfo, "EnhancedGetDeviceProbeInfo", \
7883         EnhancedGetBusInfo, "EnhancedGetBusInfo", \
7884         SetupExtendedCounters, "SetupExtendedCounters", \
7885         GetPerformanceCounters, "GetPerformanceCounters", \
7886         ResetPerformanceCounters, "ResetPerformanceCounters", \
7887         ReadModePage, "ReadModePage", \
7888         WriteModePage, "WriteModePage", \
7889         ReadDriveParameter, "ReadDriveParameter", \
7890         WriteDriveParameter, "WriteDriveParameter", \
7891         ResetAdapter, "ResetAdapter", \
7892         ResetBus, "ResetBus", \
7893         ResetBusDevice, "ResetBusDevice", \
7894         ExecuteSrb, "ExecuteSrb", \
7895         Create_IO_Task, "Create_IO_Task", \
7896         Delete_IO_Task, "Delete_IO_Task", \
7897         Get_IO_Task_Info, "Get_IO_Task_Info", \
7898         Check_Task_Progress, "Check_Task_Progress", \
7899         InjectError, "InjectError", \
7900         GetDeviceDefectCounts, "GetDeviceDefectCounts", \
7901         GetDeviceDefectInfo, "GetDeviceDefectInfo", \
7902         GetDeviceStatus, "GetDeviceStatus", \
7903         ClearDeviceStatus, "ClearDeviceStatus", \
7904         DiskSpinControl, "DiskSpinControl", \
7905         DiskSmartControl, "DiskSmartControl", \
7906         WriteSame, "WriteSame", \
7907         ReadWriteLong, "ReadWriteLong", \
7908         FormatUnit, "FormatUnit", \
7909         TargetDeviceControl, "TargetDeviceControl", \
7910         TargetChannelControl, "TargetChannelControl", \
7911         FlashNewCode, "FlashNewCode", \
7912         DiskCheck, "DiskCheck", \
7913         RequestSense, "RequestSense", \
7914         DiskPERControl, "DiskPERControl", \
7915         Read10, "Read10", \
7916         Write10, "Write10"
7917 
7918 #define AAC_AIFEN_KEY_STRINGS \
7919         AifEnGeneric, "Generic", \
7920         AifEnTaskComplete, "TaskComplete", \
7921         AifEnConfigChange, "Config change", \
7922         AifEnContainerChange, "Container change", \
7923         AifEnDeviceFailure, "device failed", \
7924         AifEnMirrorFailover, "Mirror failover", \
7925         AifEnContainerEvent, "container event", \
7926         AifEnFileSystemChange, "File system changed", \
7927         AifEnConfigPause, "Container pause event", \
7928         AifEnConfigResume, "Container resume event", \
7929         AifEnFailoverChange, "Failover space assignment changed", \
7930         AifEnRAID5RebuildDone, "RAID5 rebuild finished", \
7931         AifEnEnclosureManagement, "Enclosure management event", \
7932         AifEnBatteryEvent, "battery event", \
7933         AifEnAddContainer, "Add container", \
7934         AifEnDeleteContainer, "Delete container", \
7935         AifEnSMARTEvent, "SMART Event", \
7936         AifEnBatteryNeedsRecond, "battery needs reconditioning", \
7937         AifEnClusterEvent, "cluster event", \
7938         AifEnDiskSetEvent, "disk set event occured", \
7939         AifDenMorphComplete, "morph operation completed", \
7940         AifDenVolumeExtendComplete, "VolumeExtendComplete"
7941 
7942 struct aac_key_strings {
7943         int key;
7944         char *message;
7945 };
7946 
7947 extern struct scsi_key_strings scsi_cmds[];
7948 
7949 static struct aac_key_strings aac_fib_cmds[] = {
7950         AAC_FIB_CMD_KEY_STRINGS,
7951         -1,                     NULL
7952 };
7953 
7954 static struct aac_key_strings aac_ctvm_subcmds[] = {
7955         AAC_CTVM_SUBCMD_KEY_STRINGS,
7956         -1,                     NULL
7957 };
7958 
7959 static struct aac_key_strings aac_ct_subcmds[] = {
7960         AAC_CT_SUBCMD_KEY_STRINGS,
7961         -1,                     NULL
7962 };
7963 
7964 static struct aac_key_strings aac_cl_subcmds[] = {
7965         AAC_CL_SUBCMD_KEY_STRINGS,
7966         -1,                     NULL
7967 };
7968 
7969 static struct aac_key_strings aac_aif_subcmds[] = {
7970         AAC_AIF_SUBCMD_KEY_STRINGS,
7971         -1,                     NULL
7972 };
7973 
7974 static struct aac_key_strings aac_ioctl_subcmds[] = {
7975         AAC_IOCTL_SUBCMD_KEY_STRINGS,
7976         -1,                     NULL
7977 };
7978 
7979 static struct aac_key_strings aac_aifens[] = {
7980         AAC_AIFEN_KEY_STRINGS,
7981         -1,                     NULL
7982 };
7983 
7984 /*
7985  * The following function comes from Adaptec:
7986  *
7987  * Get the firmware print buffer parameters from the firmware,
7988  * if the command was successful map in the address.
7989  */
7990 static int
7991 aac_get_fw_debug_buffer(struct aac_softstate *softs)
7992 {
7993         if (aac_sync_mbcommand(softs, AAC_MONKER_GETDRVPROP,
7994             0, 0, 0, 0, NULL) == AACOK) {
7995                 uint32_t mondrv_buf_paddrl = AAC_MAILBOX_GET(softs, 1);
7996                 uint32_t mondrv_buf_paddrh = AAC_MAILBOX_GET(softs, 2);
7997                 uint32_t mondrv_buf_size = AAC_MAILBOX_GET(softs, 3);
7998                 uint32_t mondrv_hdr_size = AAC_MAILBOX_GET(softs, 4);
7999 
8000                 if (mondrv_buf_size) {
8001                         uint32_t offset = mondrv_buf_paddrl - \
8002                             softs->pci_mem_base_paddr;
8003 
8004                         /*
8005                          * See if the address is already mapped in, and
8006                          * if so set it up from the base address
8007                          */
8008                         if ((mondrv_buf_paddrh == 0) &&
8009                             (offset + mondrv_buf_size < softs->map_size)) {
8010                                 mutex_enter(&aac_prt_mutex);
8011                                 softs->debug_buf_offset = offset;
8012                                 softs->debug_header_size = mondrv_hdr_size;
8013                                 softs->debug_buf_size = mondrv_buf_size;
8014                                 softs->debug_fw_flags = 0;
8015                                 softs->debug_flags &= ~AACDB_FLAGS_FW_PRINT;
8016                                 mutex_exit(&aac_prt_mutex);
8017 
8018                                 return (AACOK);
8019                         }
8020                 }
8021         }
8022         return (AACERR);
8023 }
8024 
8025 int
8026 aac_dbflag_on(struct aac_softstate *softs, int flag)
8027 {
8028         int debug_flags = softs ? softs->debug_flags : aac_debug_flags;
8029 
8030         return ((debug_flags & (AACDB_FLAGS_FW_PRINT | \
8031             AACDB_FLAGS_KERNEL_PRINT)) && (debug_flags & flag));
8032 }
8033 
8034 static void
8035 aac_cmn_err(struct aac_softstate *softs, uint_t lev, char sl, int noheader)
8036 {
8037         if (noheader) {
8038                 if (sl) {
8039                         aac_fmt[0] = sl;
8040                         cmn_err(lev, aac_fmt, aac_prt_buf);
8041                 } else {
8042                         cmn_err(lev, &aac_fmt[1], aac_prt_buf);
8043                 }
8044         } else {
8045                 if (sl) {
8046                         aac_fmt_header[0] = sl;
8047                         cmn_err(lev, aac_fmt_header,
8048                             softs->vendor_name, softs->instance,
8049                             aac_prt_buf);
8050                 } else {
8051                         cmn_err(lev, &aac_fmt_header[1],
8052                             softs->vendor_name, softs->instance,
8053                             aac_prt_buf);
8054                 }
8055         }
8056 }
8057 
8058 /*
8059  * The following function comes from Adaptec:
8060  *
8061  * Format and print out the data passed in to UART or console
8062  * as specified by debug flags.
8063  */
8064 void
8065 aac_printf(struct aac_softstate *softs, uint_t lev, const char *fmt, ...)
8066 {
8067         va_list args;
8068         char sl; /* system log character */
8069 
8070         mutex_enter(&aac_prt_mutex);
8071         /* Set up parameters and call sprintf function to format the data */
8072         if (strchr("^!?", fmt[0]) == NULL) {
8073                 sl = 0;
8074         } else {
8075                 sl = fmt[0];
8076                 fmt++;
8077         }
8078         va_start(args, fmt);
8079         (void) vsprintf(aac_prt_buf, fmt, args);
8080         va_end(args);
8081 
8082         /* Make sure the softs structure has been passed in for this section */
8083         if (softs) {
8084                 if ((softs->debug_flags & AACDB_FLAGS_FW_PRINT) &&
8085                     /* If we are set up for a Firmware print */
8086                     (softs->debug_buf_size)) {
8087                         uint32_t count, i;
8088 
8089                         /* Make sure the string size is within boundaries */
8090                         count = strlen(aac_prt_buf);
8091                         if (count > softs->debug_buf_size)
8092                                 count = (uint16_t)softs->debug_buf_size;
8093 
8094                         /*
8095                          * Wait for no more than AAC_PRINT_TIMEOUT for the
8096                          * previous message length to clear (the handshake).
8097                          */
8098                         for (i = 0; i < AAC_PRINT_TIMEOUT; i++) {
8099                                 if (!PCI_MEM_GET32(softs,
8100                                     softs->debug_buf_offset + \
8101                                     AAC_FW_DBG_STRLEN_OFFSET))
8102                                         break;
8103 
8104                                 drv_usecwait(1000);
8105                         }
8106 
8107                         /*
8108                          * If the length is clear, copy over the message, the
8109                          * flags, and the length. Make sure the length is the
8110                          * last because that is the signal for the Firmware to
8111                          * pick it up.
8112                          */
8113                         if (!PCI_MEM_GET32(softs, softs->debug_buf_offset + \
8114                             AAC_FW_DBG_STRLEN_OFFSET)) {
8115                                 PCI_MEM_REP_PUT8(softs,
8116                                     softs->debug_buf_offset + \
8117                                     softs->debug_header_size,
8118                                     aac_prt_buf, count);
8119                                 PCI_MEM_PUT32(softs,
8120                                     softs->debug_buf_offset + \
8121                                     AAC_FW_DBG_FLAGS_OFFSET,
8122                                     softs->debug_fw_flags);
8123                                 PCI_MEM_PUT32(softs,
8124                                     softs->debug_buf_offset + \
8125                                     AAC_FW_DBG_STRLEN_OFFSET, count);
8126                         } else {
8127                                 cmn_err(CE_WARN, "UART output fail");
8128                                 softs->debug_flags &= ~AACDB_FLAGS_FW_PRINT;
8129                         }
8130                 }
8131 
8132                 /*
8133                  * If the Kernel Debug Print flag is set, send it off
8134                  * to the Kernel Debugger
8135                  */
8136                 if (softs->debug_flags & AACDB_FLAGS_KERNEL_PRINT)
8137                         aac_cmn_err(softs, lev, sl,
8138                             (softs->debug_flags & AACDB_FLAGS_NO_HEADERS));
8139         } else {
8140                 /* Driver not initialized yet, no firmware or header output */
8141                 if (aac_debug_flags & AACDB_FLAGS_KERNEL_PRINT)
8142                         aac_cmn_err(softs, lev, sl, 1);
8143         }
8144         mutex_exit(&aac_prt_mutex);
8145 }
8146 
8147 /*
8148  * Translate command number to description string
8149  */
8150 static char *
8151 aac_cmd_name(int cmd, struct aac_key_strings *cmdlist)
8152 {
8153         int i;
8154 
8155         for (i = 0; cmdlist[i].key != -1; i++) {
8156                 if (cmd == cmdlist[i].key)
8157                         return (cmdlist[i].message);
8158         }
8159         return (NULL);
8160 }
8161 
8162 static void
8163 aac_print_scmd(struct aac_softstate *softs, struct aac_cmd *acp)
8164 {
8165         struct scsi_pkt *pkt = acp->pkt;
8166         struct scsi_address *ap = &pkt->pkt_address;
8167         int is_pd = 0;
8168         int ctl = ddi_get_instance(softs->devinfo_p);
8169         int tgt = ap->a_target;
8170         int lun = ap->a_lun;
8171         union scsi_cdb *cdbp = (void *)pkt->pkt_cdbp;
8172         uchar_t cmd = cdbp->scc_cmd;
8173         char *desc;
8174 
8175         if (tgt >= AAC_MAX_LD) {
8176                 is_pd = 1;
8177                 ctl = ((struct aac_nondasd *)acp->dvp)->bus;
8178                 tgt = ((struct aac_nondasd *)acp->dvp)->tid;
8179                 lun = 0;
8180         }
8181 
8182         if ((desc = aac_cmd_name(cmd,
8183             (struct aac_key_strings *)scsi_cmds)) == NULL) {
8184                 aac_printf(softs, CE_NOTE,
8185                     "SCMD> Unknown(0x%2x) --> c%dt%dL%d %s",
8186                     cmd, ctl, tgt, lun, is_pd ? "(pd)" : "");
8187                 return;
8188         }
8189 
8190         switch (cmd) {
8191         case SCMD_READ:
8192         case SCMD_WRITE:
8193                 aac_printf(softs, CE_NOTE,
8194                     "SCMD> %s 0x%x[%d] %s --> c%dt%dL%d %s",
8195                     desc, GETG0ADDR(cdbp), GETG0COUNT(cdbp),
8196                     (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8197                     ctl, tgt, lun, is_pd ? "(pd)" : "");
8198                 break;
8199         case SCMD_READ_G1:
8200         case SCMD_WRITE_G1:
8201                 aac_printf(softs, CE_NOTE,
8202                     "SCMD> %s 0x%x[%d] %s --> c%dt%dL%d %s",
8203                     desc, GETG1ADDR(cdbp), GETG1COUNT(cdbp),
8204                     (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8205                     ctl, tgt, lun, is_pd ? "(pd)" : "");
8206                 break;
8207         case SCMD_READ_G4:
8208         case SCMD_WRITE_G4:
8209                 aac_printf(softs, CE_NOTE,
8210                     "SCMD> %s 0x%x.%08x[%d] %s --> c%dt%dL%d %s",
8211                     desc, GETG4ADDR(cdbp), GETG4ADDRTL(cdbp),
8212                     GETG4COUNT(cdbp),
8213                     (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8214                     ctl, tgt, lun, is_pd ? "(pd)" : "");
8215                 break;
8216         case SCMD_READ_G5:
8217         case SCMD_WRITE_G5:
8218                 aac_printf(softs, CE_NOTE,
8219                     "SCMD> %s 0x%x[%d] %s --> c%dt%dL%d %s",
8220                     desc, GETG5ADDR(cdbp), GETG5COUNT(cdbp),
8221                     (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8222                     ctl, tgt, lun, is_pd ? "(pd)" : "");
8223                 break;
8224         default:
8225                 aac_printf(softs, CE_NOTE, "SCMD> %s --> c%dt%dL%d %s",
8226                     desc, ctl, tgt, lun, is_pd ? "(pd)" : "");
8227         }
8228 }
8229 
8230 void
8231 aac_print_fib(struct aac_softstate *softs, struct aac_slot *slotp)
8232 {
8233         struct aac_cmd *acp = slotp->acp;
8234         struct aac_fib *fibp = slotp->fibp;
8235         ddi_acc_handle_t acc = slotp->fib_acc_handle;
8236         uint16_t fib_size;
8237         uint32_t fib_cmd, sub_cmd;
8238         char *cmdstr, *subcmdstr;
8239         char *caller;
8240         int i;
8241 
8242         if (acp) {
8243                 if (!(softs->debug_fib_flags & acp->fib_flags))
8244                         return;
8245                 if (acp->fib_flags & AACDB_FLAGS_FIB_SCMD)
8246                         caller = "SCMD";
8247                 else if (acp->fib_flags & AACDB_FLAGS_FIB_IOCTL)
8248                         caller = "IOCTL";
8249                 else if (acp->fib_flags & AACDB_FLAGS_FIB_SRB)
8250                         caller = "SRB";
8251                 else
8252                         return;
8253         } else {
8254                 if (!(softs->debug_fib_flags & AACDB_FLAGS_FIB_SYNC))
8255                         return;
8256                 caller = "SYNC";
8257         }
8258 
8259         fib_cmd = ddi_get16(acc, &fibp->Header.Command);
8260         cmdstr = aac_cmd_name(fib_cmd, aac_fib_cmds);
8261         sub_cmd = (uint32_t)-1;
8262         subcmdstr = NULL;
8263 
8264         /* Print FIB header */
8265         if (softs->debug_fib_flags & AACDB_FLAGS_FIB_HEADER) {
8266                 aac_printf(softs, CE_NOTE, "FIB> from %s", caller);
8267                 aac_printf(softs, CE_NOTE, "     XferState  %d",
8268                     ddi_get32(acc, &fibp->Header.XferState));
8269                 aac_printf(softs, CE_NOTE, "     Command    %d",
8270                     ddi_get16(acc, &fibp->Header.Command));
8271                 aac_printf(softs, CE_NOTE, "     StructType %d",
8272                     ddi_get8(acc, &fibp->Header.StructType));
8273                 aac_printf(softs, CE_NOTE, "     Flags      0x%x",
8274                     ddi_get8(acc, &fibp->Header.Flags));
8275                 aac_printf(softs, CE_NOTE, "     Size       %d",
8276                     ddi_get16(acc, &fibp->Header.Size));
8277                 aac_printf(softs, CE_NOTE, "     SenderSize %d",
8278                     ddi_get16(acc, &fibp->Header.SenderSize));
8279                 aac_printf(softs, CE_NOTE, "     SenderAddr 0x%x",
8280                     ddi_get32(acc, &fibp->Header.SenderFibAddress));
8281                 aac_printf(softs, CE_NOTE, "     RcvrAddr   0x%x",
8282                     ddi_get32(acc, &fibp->Header.ReceiverFibAddress));
8283                 aac_printf(softs, CE_NOTE, "     SenderData 0x%x",
8284                     ddi_get32(acc, &fibp->Header.SenderData));
8285         }
8286 
8287         /* Print FIB data */
8288         switch (fib_cmd) {
8289         case ContainerCommand:
8290                 sub_cmd = ddi_get32(acc,
8291                     (void *)&(((uint32_t *)(void *)&fibp->data[0])[0]));
8292                 subcmdstr = aac_cmd_name(sub_cmd, aac_ctvm_subcmds);
8293                 if (subcmdstr == NULL)
8294                         break;
8295 
8296                 switch (sub_cmd) {
8297                 case VM_ContainerConfig: {
8298                         struct aac_Container *pContainer =
8299                             (struct aac_Container *)fibp->data;
8300 
8301                         fib_cmd = sub_cmd;
8302                         cmdstr = subcmdstr;
8303                         sub_cmd = (uint32_t)-1;
8304                         subcmdstr = NULL;
8305 
8306                         sub_cmd = ddi_get32(acc,
8307                             &pContainer->CTCommand.command);
8308                         subcmdstr = aac_cmd_name(sub_cmd, aac_ct_subcmds);
8309                         if (subcmdstr == NULL)
8310                                 break;
8311                         aac_printf(softs, CE_NOTE, "FIB> %s (0x%x, 0x%x, 0x%x)",
8312                             subcmdstr,
8313                             ddi_get32(acc, &pContainer->CTCommand.param[0]),
8314                             ddi_get32(acc, &pContainer->CTCommand.param[1]),
8315                             ddi_get32(acc, &pContainer->CTCommand.param[2]));
8316                         return;
8317                 }
8318 
8319                 case VM_Ioctl:
8320                         fib_cmd = sub_cmd;
8321                         cmdstr = subcmdstr;
8322                         sub_cmd = (uint32_t)-1;
8323                         subcmdstr = NULL;
8324 
8325                         sub_cmd = ddi_get32(acc,
8326                             (void *)&(((uint32_t *)(void *)&fibp->data[0])[4]));
8327                         subcmdstr = aac_cmd_name(sub_cmd, aac_ioctl_subcmds);
8328                         break;
8329 
8330                 case VM_CtBlockRead:
8331                 case VM_CtBlockWrite: {
8332                         struct aac_blockread *br =
8333                             (struct aac_blockread *)fibp->data;
8334                         struct aac_sg_table *sg = &br->SgMap;
8335                         uint32_t sgcount = ddi_get32(acc, &sg->SgCount);
8336 
8337                         aac_printf(softs, CE_NOTE,
8338                             "FIB> %s Container %d  0x%x/%d", subcmdstr,
8339                             ddi_get32(acc, &br->ContainerId),
8340                             ddi_get32(acc, &br->BlockNumber),
8341                             ddi_get32(acc, &br->ByteCount));
8342                         for (i = 0; i < sgcount; i++)
8343                                 aac_printf(softs, CE_NOTE,
8344                                     "     %d: 0x%08x/%d", i,
8345                                     ddi_get32(acc, &sg->SgEntry[i].SgAddress),
8346                                     ddi_get32(acc, &sg->SgEntry[i]. \
8347                                     SgByteCount));
8348                         return;
8349                 }
8350                 }
8351                 break;
8352 
8353         case ContainerCommand64: {
8354                 struct aac_blockread64 *br =
8355                     (struct aac_blockread64 *)fibp->data;
8356                 struct aac_sg_table64 *sg = &br->SgMap64;
8357                 uint32_t sgcount = ddi_get32(acc, &sg->SgCount);
8358                 uint64_t sgaddr;
8359 
8360                 sub_cmd = br->Command;
8361                 subcmdstr = NULL;
8362                 if (sub_cmd == VM_CtHostRead64)
8363                         subcmdstr = "VM_CtHostRead64";
8364                 else if (sub_cmd == VM_CtHostWrite64)
8365                         subcmdstr = "VM_CtHostWrite64";
8366                 else
8367                         break;
8368 
8369                 aac_printf(softs, CE_NOTE,
8370                     "FIB> %s Container %d  0x%x/%d", subcmdstr,
8371                     ddi_get16(acc, &br->ContainerId),
8372                     ddi_get32(acc, &br->BlockNumber),
8373                     ddi_get16(acc, &br->SectorCount));
8374                 for (i = 0; i < sgcount; i++) {
8375                         sgaddr = ddi_get64(acc,
8376                             &sg->SgEntry64[i].SgAddress);
8377                         aac_printf(softs, CE_NOTE,
8378                             "     %d: 0x%08x.%08x/%d", i,
8379                             AAC_MS32(sgaddr), AAC_LS32(sgaddr),
8380                             ddi_get32(acc, &sg->SgEntry64[i]. \
8381                             SgByteCount));
8382                 }
8383                 return;
8384         }
8385 
8386         case RawIo: {
8387                 struct aac_raw_io *io = (struct aac_raw_io *)fibp->data;
8388                 struct aac_sg_tableraw *sg = &io->SgMapRaw;
8389                 uint32_t sgcount = ddi_get32(acc, &sg->SgCount);
8390                 uint64_t sgaddr;
8391 
8392                 aac_printf(softs, CE_NOTE,
8393                     "FIB> RawIo Container %d  0x%llx/%d 0x%x",
8394                     ddi_get16(acc, &io->ContainerId),
8395                     ddi_get64(acc, &io->BlockNumber),
8396                     ddi_get32(acc, &io->ByteCount),
8397                     ddi_get16(acc, &io->Flags));
8398                 for (i = 0; i < sgcount; i++) {
8399                         sgaddr = ddi_get64(acc, &sg->SgEntryRaw[i].SgAddress);
8400                         aac_printf(softs, CE_NOTE, "     %d: 0x%08x.%08x/%d", i,
8401                             AAC_MS32(sgaddr), AAC_LS32(sgaddr),
8402                             ddi_get32(acc, &sg->SgEntryRaw[i].SgByteCount));
8403                 }
8404                 return;
8405         }
8406 
8407         case ClusterCommand:
8408                 sub_cmd = ddi_get32(acc,
8409                     (void *)&(((uint32_t *)(void *)fibp->data)[0]));
8410                 subcmdstr = aac_cmd_name(sub_cmd, aac_cl_subcmds);
8411                 break;
8412 
8413         case AifRequest:
8414                 sub_cmd = ddi_get32(acc,
8415                     (void *)&(((uint32_t *)(void *)fibp->data)[0]));
8416                 subcmdstr = aac_cmd_name(sub_cmd, aac_aif_subcmds);
8417                 break;
8418 
8419         default:
8420                 break;
8421         }
8422 
8423         fib_size = ddi_get16(acc, &(fibp->Header.Size));
8424         if (subcmdstr)
8425                 aac_printf(softs, CE_NOTE, "FIB> %s, sz=%d",
8426                     subcmdstr, fib_size);
8427         else if (cmdstr && sub_cmd == (uint32_t)-1)
8428                 aac_printf(softs, CE_NOTE, "FIB> %s, sz=%d",
8429                     cmdstr, fib_size);
8430         else if (cmdstr)
8431                 aac_printf(softs, CE_NOTE, "FIB> %s: Unknown(0x%x), sz=%d",
8432                     cmdstr, sub_cmd, fib_size);
8433         else
8434                 aac_printf(softs, CE_NOTE, "FIB> Unknown(0x%x), sz=%d",
8435                     fib_cmd, fib_size);
8436 }
8437 
8438 static void
8439 aac_print_aif(struct aac_softstate *softs, struct aac_aif_command *aif)
8440 {
8441         int aif_command;
8442         uint32_t aif_seqnumber;
8443         int aif_en_type;
8444         char *str;
8445 
8446         aif_command = LE_32(aif->command);
8447         aif_seqnumber = LE_32(aif->seqNumber);
8448         aif_en_type = LE_32(aif->data.EN.type);
8449 
8450         switch (aif_command) {
8451         case AifCmdEventNotify:
8452                 str = aac_cmd_name(aif_en_type, aac_aifens);
8453                 if (str)
8454                         aac_printf(softs, CE_NOTE, "AIF! %s", str);
8455                 else
8456                         aac_printf(softs, CE_NOTE, "AIF! Unknown(0x%x)",
8457                             aif_en_type);
8458                 break;
8459 
8460         case AifCmdJobProgress:
8461                 switch (LE_32(aif->data.PR[0].status)) {
8462                 case AifJobStsSuccess:
8463                         str = "success"; break;
8464                 case AifJobStsFinished:
8465                         str = "finished"; break;
8466                 case AifJobStsAborted:
8467                         str = "aborted"; break;
8468                 case AifJobStsFailed:
8469                         str = "failed"; break;
8470                 case AifJobStsSuspended:
8471                         str = "suspended"; break;
8472                 case AifJobStsRunning:
8473                         str = "running"; break;
8474                 default:
8475                         str = "unknown"; break;
8476                 }
8477                 aac_printf(softs, CE_NOTE,
8478                     "AIF! JobProgress (%d) - %s (%d, %d)",
8479                     aif_seqnumber, str,
8480                     LE_32(aif->data.PR[0].currentTick),
8481                     LE_32(aif->data.PR[0].finalTick));
8482                 break;
8483 
8484         case AifCmdAPIReport:
8485                 aac_printf(softs, CE_NOTE, "AIF! APIReport (%d)",
8486                     aif_seqnumber);
8487                 break;
8488 
8489         case AifCmdDriverNotify:
8490                 aac_printf(softs, CE_NOTE, "AIF! DriverNotify (%d)",
8491                     aif_seqnumber);
8492                 break;
8493 
8494         default:
8495                 aac_printf(softs, CE_NOTE, "AIF! AIF %d (%d)",
8496                     aif_command, aif_seqnumber);
8497                 break;
8498         }
8499 }
8500 
8501 #endif /* DEBUG */