1 /*
   2  * mr_sas.c: source for mr_sas driver
   3  *
   4  * Solaris MegaRAID device driver for SAS2.0 controllers
   5  * Copyright (c) 2008-2012, LSI Logic Corporation.
   6  * All rights reserved.
   7  *
   8  * Version:
   9  * Author:
  10  *              Swaminathan K S
  11  *              Arun Chandrashekhar
  12  *              Manju R
  13  *              Rasheed
  14  *              Shakeel Bukhari
  15  *
  16  * Redistribution and use in source and binary forms, with or without
  17  * modification, are permitted provided that the following conditions are met:
  18  *
  19  * 1. Redistributions of source code must retain the above copyright notice,
  20  *    this list of conditions and the following disclaimer.
  21  *
  22  * 2. Redistributions in binary form must reproduce the above copyright notice,
  23  *    this list of conditions and the following disclaimer in the documentation
  24  *    and/or other materials provided with the distribution.
  25  *
  26  * 3. Neither the name of the author nor the names of its contributors may be
  27  *    used to endorse or promote products derived from this software without
  28  *    specific prior written permission.
  29  *
  30  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  31  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  32  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  33  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  34  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  35  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  36  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  37  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  38  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  39  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  40  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  41  * DAMAGE.
  42  */
  43 
  44 /*
  45  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
  46  * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
  47  * Copyright 2018 Nexenta Systems, Inc.
  48  * Copyright 2015, 2017 Citrus IT Limited. All rights reserved.
  49  * Copyright 2015 Garrett D'Amore <garrett@damore.org>
  50  */
  51 
  52 #include <sys/types.h>
  53 #include <sys/param.h>
  54 #include <sys/file.h>
  55 #include <sys/errno.h>
  56 #include <sys/open.h>
  57 #include <sys/cred.h>
  58 #include <sys/modctl.h>
  59 #include <sys/conf.h>
  60 #include <sys/devops.h>
  61 #include <sys/cmn_err.h>
  62 #include <sys/kmem.h>
  63 #include <sys/stat.h>
  64 #include <sys/mkdev.h>
  65 #include <sys/pci.h>
  66 #include <sys/scsi/scsi.h>
  67 #include <sys/ddi.h>
  68 #include <sys/sunddi.h>
  69 #include <sys/atomic.h>
  70 #include <sys/signal.h>
  71 #include <sys/byteorder.h>
  72 #include <sys/sdt.h>
  73 
  74 #include "mr_sas.h"
  75 
  76 /*
  77  * FMA header files
  78  */
  79 #include <sys/ddifm.h>
  80 #include <sys/fm/protocol.h>
  81 #include <sys/fm/util.h>
  82 #include <sys/fm/io/ddi.h>
  83 
  84 /* Macros to help Skinny and stock 2108/MFI live together. */
  85 #define WR_IB_PICK_QPORT(addr, instance) \
  86         if ((instance)->skinny) { \
  87                 WR_IB_LOW_QPORT((addr), (instance)); \
  88                 WR_IB_HIGH_QPORT(0, (instance)); \
  89         } else { \
  90                 WR_IB_QPORT((addr), (instance)); \
  91         }
  92 
  93 /*
  94  * Local static data
  95  */
  96 static void     *mrsas_state = NULL;
  97 static volatile boolean_t       mrsas_relaxed_ordering = B_TRUE;
  98 volatile int    debug_level_g = CL_NONE;
  99 static volatile int     msi_enable = 1;
 100 static volatile int     ctio_enable = 1;
 101 
 102 /* Default Timeout value to issue online controller reset */
 103 volatile int  debug_timeout_g  = 0xF0;          /* 0xB4; */
 104 /* Simulate consecutive firmware fault */
 105 static volatile int  debug_fw_faults_after_ocr_g  = 0;
 106 #ifdef OCRDEBUG
 107 /* Simulate three consecutive timeout for an IO */
 108 static volatile int  debug_consecutive_timeout_after_ocr_g  = 0;
 109 #endif
 110 
 111 #pragma weak scsi_hba_open
 112 #pragma weak scsi_hba_close
 113 #pragma weak scsi_hba_ioctl
 114 
 115 /* Local static prototypes. */
 116 static int      mrsas_getinfo(dev_info_t *, ddi_info_cmd_t,  void *, void **);
 117 static int      mrsas_attach(dev_info_t *, ddi_attach_cmd_t);
 118 #ifdef __sparc
 119 static int      mrsas_reset(dev_info_t *, ddi_reset_cmd_t);
 120 #else
 121 static int      mrsas_quiesce(dev_info_t *);
 122 #endif
 123 static int      mrsas_detach(dev_info_t *, ddi_detach_cmd_t);
 124 static int      mrsas_open(dev_t *, int, int, cred_t *);
 125 static int      mrsas_close(dev_t, int, int, cred_t *);
 126 static int      mrsas_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
 127 
 128 static int      mrsas_tran_tgt_init(dev_info_t *, dev_info_t *,
 129                     scsi_hba_tran_t *, struct scsi_device *);
 130 static struct scsi_pkt *mrsas_tran_init_pkt(struct scsi_address *, register
 131                     struct scsi_pkt *, struct buf *, int, int, int, int,
 132                     int (*)(), caddr_t);
 133 static int      mrsas_tran_start(struct scsi_address *,
 134                     register struct scsi_pkt *);
 135 static int      mrsas_tran_abort(struct scsi_address *, struct scsi_pkt *);
 136 static int      mrsas_tran_reset(struct scsi_address *, int);
 137 static int      mrsas_tran_getcap(struct scsi_address *, char *, int);
 138 static int      mrsas_tran_setcap(struct scsi_address *, char *, int, int);
 139 static void     mrsas_tran_destroy_pkt(struct scsi_address *,
 140                     struct scsi_pkt *);
 141 static void     mrsas_tran_dmafree(struct scsi_address *, struct scsi_pkt *);
 142 static void     mrsas_tran_sync_pkt(struct scsi_address *, struct scsi_pkt *);
 143 static int      mrsas_tran_quiesce(dev_info_t *dip);
 144 static int      mrsas_tran_unquiesce(dev_info_t *dip);
 145 static uint_t   mrsas_isr();
 146 static uint_t   mrsas_softintr();
 147 static void     mrsas_undo_resources(dev_info_t *, struct mrsas_instance *);
 148 
 149 static void     free_space_for_mfi(struct mrsas_instance *);
 150 static uint32_t read_fw_status_reg_ppc(struct mrsas_instance *);
 151 static void     issue_cmd_ppc(struct mrsas_cmd *, struct mrsas_instance *);
 152 static int      issue_cmd_in_poll_mode_ppc(struct mrsas_instance *,
 153                     struct mrsas_cmd *);
 154 static int      issue_cmd_in_sync_mode_ppc(struct mrsas_instance *,
 155                     struct mrsas_cmd *);
 156 static void     enable_intr_ppc(struct mrsas_instance *);
 157 static void     disable_intr_ppc(struct mrsas_instance *);
 158 static int      intr_ack_ppc(struct mrsas_instance *);
 159 static void     flush_cache(struct mrsas_instance *instance);
 160 void    display_scsi_inquiry(caddr_t);
 161 static int      start_mfi_aen(struct mrsas_instance *instance);
 162 static int      handle_drv_ioctl(struct mrsas_instance *instance,
 163                     struct mrsas_ioctl *ioctl, int mode);
 164 static int      handle_mfi_ioctl(struct mrsas_instance *instance,
 165                     struct mrsas_ioctl *ioctl, int mode);
 166 static int      handle_mfi_aen(struct mrsas_instance *instance,
 167                     struct mrsas_aen *aen);
 168 static struct mrsas_cmd *build_cmd(struct mrsas_instance *,
 169     struct scsi_address *, struct scsi_pkt *, uchar_t *);
 170 static int      alloc_additional_dma_buffer(struct mrsas_instance *);
 171 static void     complete_cmd_in_sync_mode(struct mrsas_instance *,
 172                 struct mrsas_cmd *);
 173 static int      mrsas_kill_adapter(struct mrsas_instance *);
 174 static int      mrsas_issue_init_mfi(struct mrsas_instance *);
 175 static int      mrsas_reset_ppc(struct mrsas_instance *);
 176 static uint32_t mrsas_initiate_ocr_if_fw_is_faulty(struct mrsas_instance *);
 177 static int      wait_for_outstanding(struct mrsas_instance *instance);
 178 static int      register_mfi_aen(struct mrsas_instance *instance,
 179                     uint32_t seq_num, uint32_t class_locale_word);
 180 static int      issue_mfi_pthru(struct mrsas_instance *instance, struct
 181                     mrsas_ioctl *ioctl, struct mrsas_cmd *cmd, int mode);
 182 static int      issue_mfi_dcmd(struct mrsas_instance *instance, struct
 183                     mrsas_ioctl *ioctl, struct mrsas_cmd *cmd, int mode);
 184 static int      issue_mfi_smp(struct mrsas_instance *instance, struct
 185                     mrsas_ioctl *ioctl, struct mrsas_cmd *cmd, int mode);
 186 static int      issue_mfi_stp(struct mrsas_instance *instance, struct
 187                     mrsas_ioctl *ioctl, struct mrsas_cmd *cmd, int mode);
 188 static int      abort_aen_cmd(struct mrsas_instance *instance,
 189                     struct mrsas_cmd *cmd_to_abort);
 190 
 191 static void     mrsas_rem_intrs(struct mrsas_instance *instance);
 192 static int      mrsas_add_intrs(struct mrsas_instance *instance, int intr_type);
 193 
 194 static void     mrsas_tran_tgt_free(dev_info_t *, dev_info_t *,
 195                     scsi_hba_tran_t *, struct scsi_device *);
 196 static int      mrsas_tran_bus_config(dev_info_t *, uint_t,
 197                     ddi_bus_config_op_t, void *, dev_info_t **);
 198 static int      mrsas_parse_devname(char *, int *, int *);
 199 static int      mrsas_config_all_devices(struct mrsas_instance *);
 200 static int      mrsas_config_ld(struct mrsas_instance *, uint16_t,
 201                         uint8_t, dev_info_t **);
 202 static int      mrsas_name_node(dev_info_t *, char *, int);
 203 static void     mrsas_issue_evt_taskq(struct mrsas_eventinfo *);
 204 static void     free_additional_dma_buffer(struct mrsas_instance *);
 205 static void io_timeout_checker(void *);
 206 static void mrsas_fm_init(struct mrsas_instance *);
 207 static void mrsas_fm_fini(struct mrsas_instance *);
 208 
 209 static struct mrsas_function_template mrsas_function_template_ppc = {
 210         .read_fw_status_reg = read_fw_status_reg_ppc,
 211         .issue_cmd = issue_cmd_ppc,
 212         .issue_cmd_in_sync_mode = issue_cmd_in_sync_mode_ppc,
 213         .issue_cmd_in_poll_mode = issue_cmd_in_poll_mode_ppc,
 214         .enable_intr = enable_intr_ppc,
 215         .disable_intr = disable_intr_ppc,
 216         .intr_ack = intr_ack_ppc,
 217         .init_adapter = mrsas_init_adapter_ppc
 218 };
 219 
 220 
 221 static struct mrsas_function_template mrsas_function_template_fusion = {
 222         .read_fw_status_reg = tbolt_read_fw_status_reg,
 223         .issue_cmd = tbolt_issue_cmd,
 224         .issue_cmd_in_sync_mode = tbolt_issue_cmd_in_sync_mode,
 225         .issue_cmd_in_poll_mode = tbolt_issue_cmd_in_poll_mode,
 226         .enable_intr = tbolt_enable_intr,
 227         .disable_intr = tbolt_disable_intr,
 228         .intr_ack = tbolt_intr_ack,
 229         .init_adapter = mrsas_init_adapter_tbolt
 230 };
 231 
 232 
 233 ddi_dma_attr_t mrsas_generic_dma_attr = {
 234         DMA_ATTR_V0,            /* dma_attr_version */
 235         0,                      /* low DMA address range */
 236         0xFFFFFFFFU,            /* high DMA address range */
 237         0xFFFFFFFFU,            /* DMA counter register  */
 238         8,                      /* DMA address alignment */
 239         0x07,                   /* DMA burstsizes  */
 240         1,                      /* min DMA size */
 241         0xFFFFFFFFU,            /* max DMA size */
 242         0xFFFFFFFFU,            /* segment boundary */
 243         MRSAS_MAX_SGE_CNT,      /* dma_attr_sglen */
 244         512,                    /* granularity of device */
 245         0                       /* bus specific DMA flags */
 246 };
 247 
 248 int32_t mrsas_max_cap_maxxfer = 0x1000000;
 249 
 250 /*
 251  * Fix for: Thunderbolt controller IO timeout when IO write size is 1MEG,
 252  * Limit size to 256K
 253  */
 254 uint32_t mrsas_tbolt_max_cap_maxxfer = (512 * 512);
 255 
 256 /*
 257  * cb_ops contains base level routines
 258  */
 259 static struct cb_ops mrsas_cb_ops = {
 260         mrsas_open,             /* open */
 261         mrsas_close,            /* close */
 262         nodev,                  /* strategy */
 263         nodev,                  /* print */
 264         nodev,                  /* dump */
 265         nodev,                  /* read */
 266         nodev,                  /* write */
 267         mrsas_ioctl,            /* ioctl */
 268         nodev,                  /* devmap */
 269         nodev,                  /* mmap */
 270         nodev,                  /* segmap */
 271         nochpoll,               /* poll */
 272         nodev,                  /* cb_prop_op */
 273         0,                      /* streamtab  */
 274         D_NEW | D_HOTPLUG,      /* cb_flag */
 275         CB_REV,                 /* cb_rev */
 276         nodev,                  /* cb_aread */
 277         nodev                   /* cb_awrite */
 278 };
 279 
 280 /*
 281  * dev_ops contains configuration routines
 282  */
 283 static struct dev_ops mrsas_ops = {
 284         DEVO_REV,               /* rev, */
 285         0,                      /* refcnt */
 286         mrsas_getinfo,          /* getinfo */
 287         nulldev,                /* identify */
 288         nulldev,                /* probe */
 289         mrsas_attach,           /* attach */
 290         mrsas_detach,           /* detach */
 291 #ifdef  __sparc
 292         mrsas_reset,            /* reset */
 293 #else   /* __sparc */
 294         nodev,
 295 #endif  /* __sparc */
 296         &mrsas_cb_ops,              /* char/block ops */
 297         NULL,                   /* bus ops */
 298         NULL,                   /* power */
 299 #ifdef __sparc
 300         ddi_quiesce_not_needed
 301 #else   /* __sparc */
 302         mrsas_quiesce   /* quiesce */
 303 #endif  /* __sparc */
 304 };
 305 
 306 static struct modldrv modldrv = {
 307         &mod_driverops,             /* module type - driver */
 308         MRSAS_VERSION,
 309         &mrsas_ops,         /* driver ops */
 310 };
 311 
 312 static struct modlinkage modlinkage = {
 313         MODREV_1,       /* ml_rev - must be MODREV_1 */
 314         &modldrv,   /* ml_linkage */
 315         NULL            /* end of driver linkage */
 316 };
 317 
 318 static struct ddi_device_acc_attr endian_attr = {
 319         DDI_DEVICE_ATTR_V1,
 320         DDI_STRUCTURE_LE_ACC,
 321         DDI_STRICTORDER_ACC,
 322         DDI_DEFAULT_ACC
 323 };
 324 
 325 /* Use the LSI Fast Path for the 2208 (tbolt) commands. */
 326 unsigned int enable_fp = 1;
 327 
 328 
 329 /*
 330  * ************************************************************************** *
 331  *                                                                            *
 332  *         common entry points - for loadable kernel modules                  *
 333  *                                                                            *
 334  * ************************************************************************** *
 335  */
 336 
 337 /*
 338  * _init - initialize a loadable module
 339  * @void
 340  *
 341  * The driver should perform any one-time resource allocation or data
 342  * initialization during driver loading in _init(). For example, the driver
 343  * should initialize any mutexes global to the driver in this routine.
 344  * The driver should not, however, use _init() to allocate or initialize
 345  * anything that has to do with a particular instance of the device.
 346  * Per-instance initialization must be done in attach().
 347  */
 348 int
 349 _init(void)
 350 {
 351         int ret;
 352 
 353         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
 354 
 355         ret = ddi_soft_state_init(&mrsas_state,
 356             sizeof (struct mrsas_instance), 0);
 357 
 358         if (ret != DDI_SUCCESS) {
 359                 cmn_err(CE_WARN, "mr_sas: could not init state");
 360                 return (ret);
 361         }
 362 
 363         if ((ret = scsi_hba_init(&modlinkage)) != DDI_SUCCESS) {
 364                 cmn_err(CE_WARN, "mr_sas: could not init scsi hba");
 365                 ddi_soft_state_fini(&mrsas_state);
 366                 return (ret);
 367         }
 368 
 369         ret = mod_install(&modlinkage);
 370 
 371         if (ret != DDI_SUCCESS) {
 372                 cmn_err(CE_WARN, "mr_sas: mod_install failed");
 373                 scsi_hba_fini(&modlinkage);
 374                 ddi_soft_state_fini(&mrsas_state);
 375         }
 376 
 377         return (ret);
 378 }
 379 
 380 /*
 381  * _info - returns information about a loadable module.
 382  * @void
 383  *
 384  * _info() is called to return module information. This is a typical entry
 385  * point that does predefined role. It simply calls mod_info().
 386  */
 387 int
 388 _info(struct modinfo *modinfop)
 389 {
 390         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
 391 
 392         return (mod_info(&modlinkage, modinfop));
 393 }
 394 
 395 /*
 396  * _fini - prepare a loadable module for unloading
 397  * @void
 398  *
 399  * In _fini(), the driver should release any resources that were allocated in
 400  * _init(). The driver must remove itself from the system module list.
 401  */
 402 int
 403 _fini(void)
 404 {
 405         int ret;
 406 
 407         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
 408 
 409         if ((ret = mod_remove(&modlinkage)) != DDI_SUCCESS) {
 410                 con_log(CL_ANN1,
 411                     (CE_WARN, "_fini: mod_remove() failed, error 0x%X", ret));
 412                 return (ret);
 413         }
 414 
 415         scsi_hba_fini(&modlinkage);
 416         con_log(CL_DLEVEL1, (CE_NOTE, "_fini: scsi_hba_fini() done."));
 417 
 418         ddi_soft_state_fini(&mrsas_state);
 419         con_log(CL_DLEVEL1, (CE_NOTE, "_fini: ddi_soft_state_fini() done."));
 420 
 421         return (ret);
 422 }
 423 
 424 
 425 /*
 426  * ************************************************************************** *
 427  *                                                                            *
 428  *               common entry points - for autoconfiguration                  *
 429  *                                                                            *
 430  * ************************************************************************** *
 431  */
 432 /*
 433  * attach - adds a device to the system as part of initialization
 434  * @dip:
 435  * @cmd:
 436  *
 437  * The kernel calls a driver's attach() entry point to attach an instance of
 438  * a device (for MegaRAID, it is instance of a controller) or to resume
 439  * operation for an instance of a device that has been suspended or has been
 440  * shut down by the power management framework
 441  * The attach() entry point typically includes the following types of
 442  * processing:
 443  * - allocate a soft-state structure for the device instance (for MegaRAID,
 444  *   controller instance)
 445  * - initialize per-instance mutexes
 446  * - initialize condition variables
 447  * - register the device's interrupts (for MegaRAID, controller's interrupts)
 448  * - map the registers and memory of the device instance (for MegaRAID,
 449  *   controller instance)
 450  * - create minor device nodes for the device instance (for MegaRAID,
 451  *   controller instance)
 452  * - report that the device instance (for MegaRAID, controller instance) has
 453  *   attached
 454  */
 455 static int
 456 mrsas_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 457 {
 458         int             instance_no;
 459         int             nregs;
 460         int             i = 0;
 461         uint8_t         irq;
 462         uint16_t        vendor_id;
 463         uint16_t        device_id;
 464         uint16_t        subsysvid;
 465         uint16_t        subsysid;
 466         uint16_t        command;
 467         off_t           reglength = 0;
 468         int             intr_types = 0;
 469         char            *data;
 470 
 471         scsi_hba_tran_t         *tran;
 472         ddi_dma_attr_t  tran_dma_attr;
 473         struct mrsas_instance   *instance;
 474 
 475         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
 476 
 477         /* CONSTCOND */
 478         ASSERT(NO_COMPETING_THREADS);
 479 
 480         instance_no = ddi_get_instance(dip);
 481 
 482         /*
 483          * check to see whether this device is in a DMA-capable slot.
 484          */
 485         if (ddi_slaveonly(dip) == DDI_SUCCESS) {
 486                 dev_err(dip, CE_WARN, "Device in slave-only slot, unused");
 487                 return (DDI_FAILURE);
 488         }
 489 
 490         switch (cmd) {
 491         case DDI_ATTACH:
 492                 /* allocate the soft state for the instance */
 493                 if (ddi_soft_state_zalloc(mrsas_state, instance_no)
 494                     != DDI_SUCCESS) {
 495                         dev_err(dip, CE_WARN, "Failed to allocate soft state");
 496                         return (DDI_FAILURE);
 497                 }
 498 
 499                 instance = (struct mrsas_instance *)ddi_get_soft_state
 500                     (mrsas_state, instance_no);
 501 
 502                 if (instance == NULL) {
 503                         dev_err(dip, CE_WARN, "Bad soft state");
 504                         ddi_soft_state_free(mrsas_state, instance_no);
 505                         return (DDI_FAILURE);
 506                 }
 507 
 508                 instance->unroll.softs       = 1;
 509 
 510                 /* Setup the PCI configuration space handles */
 511                 if (pci_config_setup(dip, &instance->pci_handle) !=
 512                     DDI_SUCCESS) {
 513                         dev_err(dip, CE_WARN, "pci config setup failed");
 514 
 515                         ddi_soft_state_free(mrsas_state, instance_no);
 516                         return (DDI_FAILURE);
 517                 }
 518 
 519                 if (ddi_dev_nregs(dip, &nregs) != DDI_SUCCESS) {
 520                         dev_err(dip, CE_WARN, "Failed to get registers");
 521 
 522                         pci_config_teardown(&instance->pci_handle);
 523                         ddi_soft_state_free(mrsas_state, instance_no);
 524                         return (DDI_FAILURE);
 525                 }
 526 
 527                 vendor_id = pci_config_get16(instance->pci_handle,
 528                     PCI_CONF_VENID);
 529                 device_id = pci_config_get16(instance->pci_handle,
 530                     PCI_CONF_DEVID);
 531 
 532                 subsysvid = pci_config_get16(instance->pci_handle,
 533                     PCI_CONF_SUBVENID);
 534                 subsysid = pci_config_get16(instance->pci_handle,
 535                     PCI_CONF_SUBSYSID);
 536 
 537                 pci_config_put16(instance->pci_handle, PCI_CONF_COMM,
 538                     (pci_config_get16(instance->pci_handle,
 539                     PCI_CONF_COMM) | PCI_COMM_ME));
 540                 irq = pci_config_get8(instance->pci_handle,
 541                     PCI_CONF_ILINE);
 542 
 543                 dev_err(dip, CE_CONT,
 544                     "?0x%x:0x%x 0x%x:0x%x, irq:%d drv-ver:%s\n",
 545                     vendor_id, device_id, subsysvid,
 546                     subsysid, irq, MRSAS_VERSION);
 547 
 548                 /* enable bus-mastering */
 549                 command = pci_config_get16(instance->pci_handle,
 550                     PCI_CONF_COMM);
 551 
 552                 if (!(command & PCI_COMM_ME)) {
 553                         command |= PCI_COMM_ME;
 554 
 555                         pci_config_put16(instance->pci_handle,
 556                             PCI_CONF_COMM, command);
 557 
 558                         con_log(CL_ANN, (CE_CONT, "mr_sas%d: "
 559                             "enable bus-mastering", instance_no));
 560                 } else {
 561                         con_log(CL_DLEVEL1, (CE_CONT, "mr_sas%d: "
 562                             "bus-mastering already set", instance_no));
 563                 }
 564 
 565                 /* initialize function pointers */
 566                 switch (device_id) {
 567                 case PCI_DEVICE_ID_LSI_INVADER:
 568                 case PCI_DEVICE_ID_LSI_FURY:
 569                 case PCI_DEVICE_ID_LSI_INTRUDER:
 570                 case PCI_DEVICE_ID_LSI_INTRUDER_24:
 571                 case PCI_DEVICE_ID_LSI_CUTLASS_52:
 572                 case PCI_DEVICE_ID_LSI_CUTLASS_53:
 573                         dev_err(dip, CE_CONT, "?Gen3 device detected\n");
 574                         instance->gen3 = 1;
 575                         /* FALLTHROUGH */
 576                 case PCI_DEVICE_ID_LSI_TBOLT:
 577                         dev_err(dip, CE_CONT, "?TBOLT device detected\n");
 578 
 579                         instance->func_ptr =
 580                             &mrsas_function_template_fusion;
 581                         instance->tbolt = 1;
 582                         break;
 583 
 584                 case PCI_DEVICE_ID_LSI_SKINNY:
 585                 case PCI_DEVICE_ID_LSI_SKINNY_NEW:
 586                         /*
 587                          * FALLTHRU to PPC-style functions, but mark this
 588                          * instance as Skinny, because the register set is
 589                          * slightly different (See WR_IB_PICK_QPORT), and
 590                          * certain other features are available to a Skinny
 591                          * HBA.
 592                          */
 593                         dev_err(dip, CE_CONT, "?Skinny device detected\n");
 594                         instance->skinny = 1;
 595                         /* FALLTHRU */
 596 
 597                 case PCI_DEVICE_ID_LSI_2108VDE:
 598                 case PCI_DEVICE_ID_LSI_2108V:
 599                         dev_err(dip, CE_CONT,
 600                             "?2108 Liberator device detected\n");
 601 
 602                         instance->func_ptr =
 603                             &mrsas_function_template_ppc;
 604                         break;
 605 
 606                 default:
 607                         dev_err(dip, CE_WARN, "Invalid device detected");
 608 
 609                         pci_config_teardown(&instance->pci_handle);
 610                         ddi_soft_state_free(mrsas_state, instance_no);
 611                         return (DDI_FAILURE);
 612                 }
 613 
 614                 instance->baseaddress = pci_config_get32(
 615                     instance->pci_handle, PCI_CONF_BASE0);
 616                 instance->baseaddress &= 0x0fffc;
 617 
 618                 instance->dip                = dip;
 619                 instance->vendor_id  = vendor_id;
 620                 instance->device_id  = device_id;
 621                 instance->subsysvid  = subsysvid;
 622                 instance->subsysid   = subsysid;
 623                 instance->instance   = instance_no;
 624 
 625                 /* Initialize FMA */
 626                 instance->fm_capabilities = ddi_prop_get_int(
 627                     DDI_DEV_T_ANY, instance->dip, DDI_PROP_DONTPASS,
 628                     "fm-capable", DDI_FM_EREPORT_CAPABLE |
 629                     DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE
 630                     | DDI_FM_ERRCB_CAPABLE);
 631 
 632                 mrsas_fm_init(instance);
 633 
 634                 /* Setup register map */
 635                 if ((ddi_dev_regsize(instance->dip,
 636                     REGISTER_SET_IO_2108, &reglength) != DDI_SUCCESS) ||
 637                     reglength < MINIMUM_MFI_MEM_SZ) {
 638                         goto fail_attach;
 639                 }
 640                 if (reglength > DEFAULT_MFI_MEM_SZ) {
 641                         reglength = DEFAULT_MFI_MEM_SZ;
 642                         con_log(CL_DLEVEL1, (CE_NOTE,
 643                             "mr_sas: register length to map is 0x%lx bytes",
 644                             reglength));
 645                 }
 646                 if (ddi_regs_map_setup(instance->dip,
 647                     REGISTER_SET_IO_2108, &instance->regmap, 0,
 648                     reglength, &endian_attr, &instance->regmap_handle)
 649                     != DDI_SUCCESS) {
 650                         dev_err(dip, CE_WARN, "couldn't map control registers");
 651                         goto fail_attach;
 652                 }
 653 
 654                 instance->unroll.regs = 1;
 655 
 656                 /*
 657                  * Disable Interrupt Now.
 658                  * Setup Software interrupt
 659                  */
 660                 instance->func_ptr->disable_intr(instance);
 661 
 662                 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
 663                     "mrsas-enable-msi", &data) == DDI_SUCCESS) {
 664                         if (strncmp(data, "no", 3) == 0) {
 665                                 msi_enable = 0;
 666                                 con_log(CL_ANN1, (CE_WARN,
 667                                     "msi_enable = %d disabled", msi_enable));
 668                         }
 669                         ddi_prop_free(data);
 670                 }
 671 
 672                 dev_err(dip, CE_CONT, "?msi_enable = %d\n", msi_enable);
 673 
 674                 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
 675                     "mrsas-enable-fp", &data) == DDI_SUCCESS) {
 676                         if (strncmp(data, "no", 3) == 0) {
 677                                 enable_fp = 0;
 678                                 dev_err(dip, CE_NOTE,
 679                                     "enable_fp = %d, Fast-Path disabled.\n",
 680                                     enable_fp);
 681                         }
 682 
 683                         ddi_prop_free(data);
 684                 }
 685 
 686                 dev_err(dip, CE_CONT, "?enable_fp = %d\n", enable_fp);
 687 
 688                 /* Check for all supported interrupt types */
 689                 if (ddi_intr_get_supported_types(
 690                     dip, &intr_types) != DDI_SUCCESS) {
 691                         dev_err(dip, CE_WARN,
 692                             "ddi_intr_get_supported_types() failed");
 693                         goto fail_attach;
 694                 }
 695 
 696                 con_log(CL_DLEVEL1, (CE_NOTE,
 697                     "ddi_intr_get_supported_types() ret: 0x%x", intr_types));
 698 
 699                 /* Initialize and Setup Interrupt handler */
 700                 if (msi_enable && (intr_types & DDI_INTR_TYPE_MSIX)) {
 701                         if (mrsas_add_intrs(instance, DDI_INTR_TYPE_MSIX) !=
 702                             DDI_SUCCESS) {
 703                                 dev_err(dip, CE_WARN,
 704                                     "MSIX interrupt query failed");
 705                                 goto fail_attach;
 706                         }
 707                         instance->intr_type = DDI_INTR_TYPE_MSIX;
 708                 } else if (msi_enable && (intr_types & DDI_INTR_TYPE_MSI)) {
 709                         if (mrsas_add_intrs(instance, DDI_INTR_TYPE_MSI) !=
 710                             DDI_SUCCESS) {
 711                                 dev_err(dip, CE_WARN,
 712                                     "MSI interrupt query failed");
 713                                 goto fail_attach;
 714                         }
 715                         instance->intr_type = DDI_INTR_TYPE_MSI;
 716                 } else if (intr_types & DDI_INTR_TYPE_FIXED) {
 717                         msi_enable = 0;
 718                         if (mrsas_add_intrs(instance, DDI_INTR_TYPE_FIXED) !=
 719                             DDI_SUCCESS) {
 720                                 dev_err(dip, CE_WARN,
 721                                     "FIXED interrupt query failed");
 722                                 goto fail_attach;
 723                         }
 724                         instance->intr_type = DDI_INTR_TYPE_FIXED;
 725                 } else {
 726                         dev_err(dip, CE_WARN, "Device cannot "
 727                             "suppport either FIXED or MSI/X "
 728                             "interrupts");
 729                         goto fail_attach;
 730                 }
 731 
 732                 instance->unroll.intr = 1;
 733 
 734                 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
 735                     "mrsas-enable-ctio", &data) == DDI_SUCCESS) {
 736                         if (strncmp(data, "no", 3) == 0) {
 737                                 ctio_enable = 0;
 738                                 con_log(CL_ANN1, (CE_WARN,
 739                                     "ctio_enable = %d disabled", ctio_enable));
 740                         }
 741                         ddi_prop_free(data);
 742                 }
 743 
 744                 dev_err(dip, CE_CONT, "?ctio_enable = %d\n", ctio_enable);
 745 
 746                 /* setup the mfi based low level driver */
 747                 if (mrsas_init_adapter(instance) != DDI_SUCCESS) {
 748                         dev_err(dip, CE_WARN,
 749                             "could not initialize the low level driver");
 750 
 751                         goto fail_attach;
 752                 }
 753 
 754                 /* Initialize all Mutex */
 755                 INIT_LIST_HEAD(&instance->completed_pool_list);
 756                 mutex_init(&instance->completed_pool_mtx, NULL,
 757                     MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 758 
 759                 mutex_init(&instance->sync_map_mtx, NULL,
 760                     MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 761 
 762                 mutex_init(&instance->app_cmd_pool_mtx, NULL,
 763                     MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 764 
 765                 mutex_init(&instance->config_dev_mtx, NULL,
 766                     MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 767 
 768                 mutex_init(&instance->cmd_pend_mtx, NULL,
 769                     MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 770 
 771                 mutex_init(&instance->ocr_flags_mtx, NULL,
 772                     MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 773 
 774                 mutex_init(&instance->int_cmd_mtx, NULL,
 775                     MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 776                 cv_init(&instance->int_cmd_cv, NULL, CV_DRIVER, NULL);
 777 
 778                 mutex_init(&instance->cmd_pool_mtx, NULL,
 779                     MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 780 
 781                 mutex_init(&instance->reg_write_mtx, NULL,
 782                     MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 783 
 784                 if (instance->tbolt) {
 785                         mutex_init(&instance->cmd_app_pool_mtx, NULL,
 786                             MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 787 
 788                         mutex_init(&instance->chip_mtx, NULL,
 789                             MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
 790 
 791                 }
 792 
 793                 instance->unroll.mutexs = 1;
 794 
 795                 instance->timeout_id = (timeout_id_t)-1;
 796 
 797                 /* Register our soft-isr for highlevel interrupts. */
 798                 instance->isr_level = instance->intr_pri;
 799                 if (!(instance->tbolt)) {
 800                         if (instance->isr_level == HIGH_LEVEL_INTR) {
 801                                 if (ddi_add_softintr(dip,
 802                                     DDI_SOFTINT_HIGH,
 803                                     &instance->soft_intr_id, NULL, NULL,
 804                                     mrsas_softintr, (caddr_t)instance) !=
 805                                     DDI_SUCCESS) {
 806                                         dev_err(dip, CE_WARN,
 807                                             "Software ISR did not register");
 808 
 809                                         goto fail_attach;
 810                                 }
 811 
 812                                 instance->unroll.soft_isr = 1;
 813 
 814                         }
 815                 }
 816 
 817                 instance->softint_running = 0;
 818 
 819                 /* Allocate a transport structure */
 820                 tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
 821 
 822                 if (tran == NULL) {
 823                         dev_err(dip, CE_WARN,
 824                             "scsi_hba_tran_alloc failed");
 825                         goto fail_attach;
 826                 }
 827 
 828                 instance->tran = tran;
 829                 instance->unroll.tran = 1;
 830 
 831                 tran->tran_hba_private       = instance;
 832                 tran->tran_tgt_init  = mrsas_tran_tgt_init;
 833                 tran->tran_tgt_probe = scsi_hba_probe;
 834                 tran->tran_tgt_free  = mrsas_tran_tgt_free;
 835                 tran->tran_init_pkt  = mrsas_tran_init_pkt;
 836                 if (instance->tbolt)
 837                         tran->tran_start = mrsas_tbolt_tran_start;
 838                 else
 839                         tran->tran_start = mrsas_tran_start;
 840                 tran->tran_abort     = mrsas_tran_abort;
 841                 tran->tran_reset     = mrsas_tran_reset;
 842                 tran->tran_getcap    = mrsas_tran_getcap;
 843                 tran->tran_setcap    = mrsas_tran_setcap;
 844                 tran->tran_destroy_pkt       = mrsas_tran_destroy_pkt;
 845                 tran->tran_dmafree   = mrsas_tran_dmafree;
 846                 tran->tran_sync_pkt  = mrsas_tran_sync_pkt;
 847                 tran->tran_quiesce   = mrsas_tran_quiesce;
 848                 tran->tran_unquiesce = mrsas_tran_unquiesce;
 849                 tran->tran_bus_config        = mrsas_tran_bus_config;
 850 
 851                 if (mrsas_relaxed_ordering)
 852                         mrsas_generic_dma_attr.dma_attr_flags |=
 853                             DDI_DMA_RELAXED_ORDERING;
 854 
 855 
 856                 tran_dma_attr = mrsas_generic_dma_attr;
 857                 tran_dma_attr.dma_attr_sgllen = instance->max_num_sge;
 858 
 859                 /* Attach this instance of the hba */
 860                 if (scsi_hba_attach_setup(dip, &tran_dma_attr, tran, 0)
 861                     != DDI_SUCCESS) {
 862                         dev_err(dip, CE_WARN,
 863                             "scsi_hba_attach failed");
 864 
 865                         goto fail_attach;
 866                 }
 867                 instance->unroll.tranSetup = 1;
 868                 con_log(CL_ANN1,
 869                     (CE_CONT, "scsi_hba_attach_setup()  done."));
 870 
 871                 /* create devctl node for cfgadm command */
 872                 if (ddi_create_minor_node(dip, "devctl",
 873                     S_IFCHR, INST2DEVCTL(instance_no),
 874                     DDI_NT_SCSI_NEXUS, 0) == DDI_FAILURE) {
 875                         dev_err(dip, CE_WARN, "failed to create devctl node.");
 876 
 877                         goto fail_attach;
 878                 }
 879 
 880                 instance->unroll.devctl = 1;
 881 
 882                 /* create scsi node for cfgadm command */
 883                 if (ddi_create_minor_node(dip, "scsi", S_IFCHR,
 884                     INST2SCSI(instance_no), DDI_NT_SCSI_ATTACHMENT_POINT, 0) ==
 885                     DDI_FAILURE) {
 886                         dev_err(dip, CE_WARN, "failed to create scsi node.");
 887 
 888                         goto fail_attach;
 889                 }
 890 
 891                 instance->unroll.scsictl = 1;
 892 
 893                 (void) snprintf(instance->iocnode, sizeof (instance->iocnode),
 894                     "%d:lsirdctl", instance_no);
 895 
 896                 /*
 897                  * Create a node for applications
 898                  * for issuing ioctl to the driver.
 899                  */
 900                 if (ddi_create_minor_node(dip, instance->iocnode,
 901                     S_IFCHR, INST2LSIRDCTL(instance_no), DDI_PSEUDO, 0) ==
 902                     DDI_FAILURE) {
 903                         dev_err(dip, CE_WARN, "failed to create ioctl node.");
 904 
 905                         goto fail_attach;
 906                 }
 907 
 908                 instance->unroll.ioctl = 1;
 909 
 910                 /* Create a taskq to handle dr events */
 911                 if ((instance->taskq = ddi_taskq_create(dip,
 912                     "mrsas_dr_taskq", 1, TASKQ_DEFAULTPRI, 0)) == NULL) {
 913                         dev_err(dip, CE_WARN, "failed to create taskq.");
 914                         instance->taskq = NULL;
 915                         goto fail_attach;
 916                 }
 917                 instance->unroll.taskq = 1;
 918                 con_log(CL_ANN1, (CE_CONT, "ddi_taskq_create() done."));
 919 
 920                 /* enable interrupt */
 921                 instance->func_ptr->enable_intr(instance);
 922 
 923                 /* initiate AEN */
 924                 if (start_mfi_aen(instance)) {
 925                         dev_err(dip, CE_WARN, "failed to initiate AEN.");
 926                         goto fail_attach;
 927                 }
 928                 instance->unroll.aenPend = 1;
 929                 con_log(CL_ANN1,
 930                     (CE_CONT, "AEN started for instance %d.", instance_no));
 931 
 932                 /* Finally! We are on the air.  */
 933                 ddi_report_dev(dip);
 934 
 935                 /* FMA handle checking. */
 936                 if (mrsas_check_acc_handle(instance->regmap_handle) !=
 937                     DDI_SUCCESS) {
 938                         goto fail_attach;
 939                 }
 940                 if (mrsas_check_acc_handle(instance->pci_handle) !=
 941                     DDI_SUCCESS) {
 942                         goto fail_attach;
 943                 }
 944 
 945                 instance->mr_ld_list =
 946                     kmem_zalloc(MRDRV_MAX_LD * sizeof (struct mrsas_ld),
 947                     KM_SLEEP);
 948                 instance->unroll.ldlist_buff = 1;
 949 
 950                 if (instance->tbolt || instance->skinny) {
 951                         instance->mr_tbolt_pd_max = MRSAS_TBOLT_PD_TGT_MAX;
 952                         instance->mr_tbolt_pd_list =
 953                             kmem_zalloc(MRSAS_TBOLT_GET_PD_MAX(instance) *
 954                             sizeof (struct mrsas_tbolt_pd), KM_SLEEP);
 955                         ASSERT(instance->mr_tbolt_pd_list);
 956                         for (i = 0; i < instance->mr_tbolt_pd_max; i++) {
 957                                 instance->mr_tbolt_pd_list[i].lun_type =
 958                                     MRSAS_TBOLT_PD_LUN;
 959                                 instance->mr_tbolt_pd_list[i].dev_id =
 960                                     (uint8_t)i;
 961                         }
 962 
 963                         instance->unroll.pdlist_buff = 1;
 964                 }
 965                 break;
 966         case DDI_PM_RESUME:
 967                 con_log(CL_ANN, (CE_NOTE, "mr_sas: DDI_PM_RESUME"));
 968                 break;
 969         case DDI_RESUME:
 970                 con_log(CL_ANN, (CE_NOTE, "mr_sas: DDI_RESUME"));
 971                 break;
 972         default:
 973                 con_log(CL_ANN,
 974                     (CE_WARN, "mr_sas: invalid attach cmd=%x", cmd));
 975                 return (DDI_FAILURE);
 976         }
 977 
 978 
 979         con_log(CL_DLEVEL1,
 980             (CE_NOTE, "mrsas_attach() return SUCCESS instance_num %d",
 981             instance_no));
 982         return (DDI_SUCCESS);
 983 
 984 fail_attach:
 985 
 986         mrsas_undo_resources(dip, instance);
 987 
 988         mrsas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
 989         ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
 990 
 991         mrsas_fm_fini(instance);
 992 
 993         pci_config_teardown(&instance->pci_handle);
 994         ddi_soft_state_free(mrsas_state, instance_no);
 995 
 996         return (DDI_FAILURE);
 997 }
 998 
 999 /*
1000  * getinfo - gets device information
1001  * @dip:
1002  * @cmd:
1003  * @arg:
1004  * @resultp:
1005  *
1006  * The system calls getinfo() to obtain configuration information that only
1007  * the driver knows. The mapping of minor numbers to device instance is
1008  * entirely under the control of the driver. The system sometimes needs to ask
1009  * the driver which device a particular dev_t represents.
1010  * Given the device number return the devinfo pointer from the scsi_device
1011  * structure.
1012  */
1013 /*ARGSUSED*/
1014 static int
1015 mrsas_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,  void *arg, void **resultp)
1016 {
1017         int     rval;
1018         int     mrsas_minor = getminor((dev_t)arg);
1019 
1020         struct mrsas_instance   *instance;
1021 
1022         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1023 
1024         switch (cmd) {
1025                 case DDI_INFO_DEVT2DEVINFO:
1026                         instance = (struct mrsas_instance *)
1027                             ddi_get_soft_state(mrsas_state,
1028                             MINOR2INST(mrsas_minor));
1029 
1030                         if (instance == NULL) {
1031                                 *resultp = NULL;
1032                                 rval = DDI_FAILURE;
1033                         } else {
1034                                 *resultp = instance->dip;
1035                                 rval = DDI_SUCCESS;
1036                         }
1037                         break;
1038                 case DDI_INFO_DEVT2INSTANCE:
1039                         *resultp = (void *)(intptr_t)
1040                             (MINOR2INST(getminor((dev_t)arg)));
1041                         rval = DDI_SUCCESS;
1042                         break;
1043                 default:
1044                         *resultp = NULL;
1045                         rval = DDI_FAILURE;
1046         }
1047 
1048         return (rval);
1049 }
1050 
1051 /*
1052  * detach - detaches a device from the system
1053  * @dip: pointer to the device's dev_info structure
1054  * @cmd: type of detach
1055  *
1056  * A driver's detach() entry point is called to detach an instance of a device
1057  * that is bound to the driver. The entry point is called with the instance of
1058  * the device node to be detached and with DDI_DETACH, which is specified as
1059  * the cmd argument to the entry point.
1060  * This routine is called during driver unload. We free all the allocated
1061  * resources and call the corresponding LLD so that it can also release all
1062  * its resources.
1063  */
1064 static int
1065 mrsas_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1066 {
1067         int     instance_no;
1068 
1069         struct mrsas_instance   *instance;
1070 
1071         con_log(CL_ANN, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1072 
1073 
1074         /* CONSTCOND */
1075         ASSERT(NO_COMPETING_THREADS);
1076 
1077         instance_no = ddi_get_instance(dip);
1078 
1079         instance = (struct mrsas_instance *)ddi_get_soft_state(mrsas_state,
1080             instance_no);
1081 
1082         if (!instance) {
1083                 dev_err(dip, CE_WARN, "could not get instance in detach");
1084 
1085                 return (DDI_FAILURE);
1086         }
1087 
1088         switch (cmd) {
1089                 case DDI_DETACH:
1090                         con_log(CL_ANN, (CE_NOTE,
1091                             "mrsas_detach: DDI_DETACH"));
1092 
1093                         mutex_enter(&instance->config_dev_mtx);
1094                         if (instance->timeout_id != (timeout_id_t)-1) {
1095                                 mutex_exit(&instance->config_dev_mtx);
1096                                 (void) untimeout(instance->timeout_id);
1097                                 instance->timeout_id = (timeout_id_t)-1;
1098                                 mutex_enter(&instance->config_dev_mtx);
1099                                 instance->unroll.timer = 0;
1100                         }
1101                         mutex_exit(&instance->config_dev_mtx);
1102 
1103                         if (instance->unroll.tranSetup == 1) {
1104                                 if (scsi_hba_detach(dip) != DDI_SUCCESS) {
1105                                         dev_err(dip, CE_WARN,
1106                                             "failed to detach");
1107                                         return (DDI_FAILURE);
1108                                 }
1109                                 instance->unroll.tranSetup = 0;
1110                                 con_log(CL_ANN1,
1111                                     (CE_CONT, "scsi_hba_dettach()  done."));
1112                         }
1113 
1114                         flush_cache(instance);
1115 
1116                         mrsas_undo_resources(dip, instance);
1117 
1118                         mrsas_fm_fini(instance);
1119 
1120                         pci_config_teardown(&instance->pci_handle);
1121                         ddi_soft_state_free(mrsas_state, instance_no);
1122                         break;
1123 
1124                 case DDI_PM_SUSPEND:
1125                         con_log(CL_ANN, (CE_NOTE,
1126                             "mrsas_detach: DDI_PM_SUSPEND"));
1127 
1128                         break;
1129                 case DDI_SUSPEND:
1130                         con_log(CL_ANN, (CE_NOTE,
1131                             "mrsas_detach: DDI_SUSPEND"));
1132 
1133                         break;
1134                 default:
1135                         con_log(CL_ANN, (CE_WARN,
1136                             "invalid detach command:0x%x", cmd));
1137                         return (DDI_FAILURE);
1138         }
1139 
1140         return (DDI_SUCCESS);
1141 }
1142 
1143 
1144 static void
1145 mrsas_undo_resources(dev_info_t *dip, struct mrsas_instance *instance)
1146 {
1147         con_log(CL_ANN, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1148 
1149         if (instance->unroll.ioctl == 1) {
1150                 ddi_remove_minor_node(dip, instance->iocnode);
1151                 instance->unroll.ioctl = 0;
1152         }
1153 
1154         if (instance->unroll.scsictl == 1) {
1155                 ddi_remove_minor_node(dip, "scsi");
1156                 instance->unroll.scsictl = 0;
1157         }
1158 
1159         if (instance->unroll.devctl == 1) {
1160                 ddi_remove_minor_node(dip, "devctl");
1161                 instance->unroll.devctl = 0;
1162         }
1163 
1164         if (instance->unroll.tranSetup == 1) {
1165                 if (scsi_hba_detach(dip) != DDI_SUCCESS) {
1166                         dev_err(dip, CE_WARN, "failed to detach");
1167                         return;  /* DDI_FAILURE */
1168                 }
1169                 instance->unroll.tranSetup = 0;
1170                 con_log(CL_ANN1, (CE_CONT, "scsi_hba_dettach()  done."));
1171         }
1172 
1173         if (instance->unroll.tran == 1)       {
1174                 scsi_hba_tran_free(instance->tran);
1175                 instance->unroll.tran = 0;
1176                 con_log(CL_ANN1, (CE_CONT, "scsi_hba_tran_free()  done."));
1177         }
1178 
1179         if (instance->unroll.syncCmd == 1) {
1180                 if (instance->tbolt) {
1181                         if (abort_syncmap_cmd(instance,
1182                             instance->map_update_cmd)) {
1183                                 dev_err(dip, CE_WARN, "mrsas_detach: "
1184                                     "failed to abort previous syncmap command");
1185                         }
1186 
1187                         instance->unroll.syncCmd = 0;
1188                         con_log(CL_ANN1, (CE_CONT, "sync cmd aborted, done."));
1189                 }
1190         }
1191 
1192         if (instance->unroll.aenPend == 1) {
1193                 if (abort_aen_cmd(instance, instance->aen_cmd))
1194                         dev_err(dip, CE_WARN, "mrsas_detach: "
1195                             "failed to abort prevous AEN command");
1196 
1197                 instance->unroll.aenPend = 0;
1198                 con_log(CL_ANN1, (CE_CONT, "aen cmd aborted, done."));
1199                 /* This means the controller is fully initialized and running */
1200                 /* Shutdown should be a last command to controller. */
1201                 /* shutdown_controller(); */
1202         }
1203 
1204 
1205         if (instance->unroll.timer == 1)      {
1206                 if (instance->timeout_id != (timeout_id_t)-1) {
1207                         (void) untimeout(instance->timeout_id);
1208                         instance->timeout_id = (timeout_id_t)-1;
1209 
1210                         instance->unroll.timer = 0;
1211                 }
1212         }
1213 
1214         instance->func_ptr->disable_intr(instance);
1215 
1216 
1217         if (instance->unroll.mutexs == 1) {
1218                 mutex_destroy(&instance->cmd_pool_mtx);
1219                 mutex_destroy(&instance->app_cmd_pool_mtx);
1220                 mutex_destroy(&instance->cmd_pend_mtx);
1221                 mutex_destroy(&instance->completed_pool_mtx);
1222                 mutex_destroy(&instance->sync_map_mtx);
1223                 mutex_destroy(&instance->int_cmd_mtx);
1224                 cv_destroy(&instance->int_cmd_cv);
1225                 mutex_destroy(&instance->config_dev_mtx);
1226                 mutex_destroy(&instance->ocr_flags_mtx);
1227                 mutex_destroy(&instance->reg_write_mtx);
1228 
1229                 if (instance->tbolt) {
1230                         mutex_destroy(&instance->cmd_app_pool_mtx);
1231                         mutex_destroy(&instance->chip_mtx);
1232                 }
1233 
1234                 instance->unroll.mutexs = 0;
1235                 con_log(CL_ANN1, (CE_CONT, "Destroy mutex & cv,      done."));
1236         }
1237 
1238 
1239         if (instance->unroll.soft_isr == 1) {
1240                 ddi_remove_softintr(instance->soft_intr_id);
1241                 instance->unroll.soft_isr = 0;
1242         }
1243 
1244         if (instance->unroll.intr == 1) {
1245                 mrsas_rem_intrs(instance);
1246                 instance->unroll.intr = 0;
1247         }
1248 
1249 
1250         if (instance->unroll.taskq == 1)      {
1251                 if (instance->taskq) {
1252                         ddi_taskq_destroy(instance->taskq);
1253                         instance->unroll.taskq = 0;
1254                 }
1255 
1256         }
1257 
1258         /*
1259          * free dma memory allocated for
1260          * cmds/frames/queues/driver version etc
1261          */
1262         if (instance->unroll.verBuff == 1) {
1263                 (void) mrsas_free_dma_obj(instance, instance->drv_ver_dma_obj);
1264                 instance->unroll.verBuff = 0;
1265         }
1266 
1267         if (instance->unroll.pdlist_buff == 1)       {
1268                 if (instance->mr_tbolt_pd_list != NULL) {
1269                         kmem_free(instance->mr_tbolt_pd_list,
1270                             MRSAS_TBOLT_GET_PD_MAX(instance) *
1271                             sizeof (struct mrsas_tbolt_pd));
1272                 }
1273 
1274                 instance->mr_tbolt_pd_list = NULL;
1275                 instance->unroll.pdlist_buff = 0;
1276         }
1277 
1278         if (instance->unroll.ldlist_buff == 1)       {
1279                 if (instance->mr_ld_list != NULL) {
1280                         kmem_free(instance->mr_ld_list, MRDRV_MAX_LD
1281                             * sizeof (struct mrsas_ld));
1282                 }
1283 
1284                 instance->mr_ld_list = NULL;
1285                 instance->unroll.ldlist_buff = 0;
1286         }
1287 
1288         if (instance->tbolt) {
1289                 if (instance->unroll.alloc_space_mpi2 == 1) {
1290                         free_space_for_mpi2(instance);
1291                         instance->unroll.alloc_space_mpi2 = 0;
1292                 }
1293         } else {
1294                 if (instance->unroll.alloc_space_mfi == 1) {
1295                         free_space_for_mfi(instance);
1296                         instance->unroll.alloc_space_mfi = 0;
1297                 }
1298         }
1299 
1300         if (instance->unroll.regs == 1)       {
1301                 ddi_regs_map_free(&instance->regmap_handle);
1302                 instance->unroll.regs = 0;
1303                 con_log(CL_ANN1, (CE_CONT, "ddi_regs_map_free()  done."));
1304         }
1305 }
1306 
1307 
1308 
1309 /*
1310  * ************************************************************************** *
1311  *                                                                            *
1312  *             common entry points - for character driver types               *
1313  *                                                                            *
1314  * ************************************************************************** *
1315  */
1316 /*
1317  * open - gets access to a device
1318  * @dev:
1319  * @openflags:
1320  * @otyp:
1321  * @credp:
1322  *
1323  * Access to a device by one or more application programs is controlled
1324  * through the open() and close() entry points. The primary function of
1325  * open() is to verify that the open request is allowed.
1326  */
1327 static  int
1328 mrsas_open(dev_t *dev, int openflags, int otyp, cred_t *credp)
1329 {
1330         int     rval = 0;
1331 
1332         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1333 
1334         /* Check root permissions */
1335         if (drv_priv(credp) != 0) {
1336                 con_log(CL_ANN, (CE_WARN,
1337                     "mr_sas: Non-root ioctl access denied!"));
1338                 return (EPERM);
1339         }
1340 
1341         /* Verify we are being opened as a character device */
1342         if (otyp != OTYP_CHR) {
1343                 con_log(CL_ANN, (CE_WARN,
1344                     "mr_sas: ioctl node must be a char node"));
1345                 return (EINVAL);
1346         }
1347 
1348         if (ddi_get_soft_state(mrsas_state, MINOR2INST(getminor(*dev)))
1349             == NULL) {
1350                 return (ENXIO);
1351         }
1352 
1353         if (scsi_hba_open) {
1354                 rval = scsi_hba_open(dev, openflags, otyp, credp);
1355         }
1356 
1357         return (rval);
1358 }
1359 
1360 /*
1361  * close - gives up access to a device
1362  * @dev:
1363  * @openflags:
1364  * @otyp:
1365  * @credp:
1366  *
1367  * close() should perform any cleanup necessary to finish using the minor
1368  * device, and prepare the device (and driver) to be opened again.
1369  */
1370 static  int
1371 mrsas_close(dev_t dev, int openflags, int otyp, cred_t *credp)
1372 {
1373         int     rval = 0;
1374 
1375         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1376 
1377         /* no need for locks! */
1378 
1379         if (scsi_hba_close) {
1380                 rval = scsi_hba_close(dev, openflags, otyp, credp);
1381         }
1382 
1383         return (rval);
1384 }
1385 
1386 /*
1387  * ioctl - performs a range of I/O commands for character drivers
1388  * @dev:
1389  * @cmd:
1390  * @arg:
1391  * @mode:
1392  * @credp:
1393  * @rvalp:
1394  *
1395  * ioctl() routine must make sure that user data is copied into or out of the
1396  * kernel address space explicitly using copyin(), copyout(), ddi_copyin(),
1397  * and ddi_copyout(), as appropriate.
1398  * This is a wrapper routine to serialize access to the actual ioctl routine.
1399  * ioctl() should return 0 on success, or the appropriate error number. The
1400  * driver may also set the value returned to the calling process through rvalp.
1401  */
1402 
1403 static int
1404 mrsas_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1405     int *rvalp)
1406 {
1407         int     rval = 0;
1408 
1409         struct mrsas_instance   *instance;
1410         struct mrsas_ioctl      *ioctl;
1411         struct mrsas_aen        aen;
1412         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1413 
1414         instance = ddi_get_soft_state(mrsas_state, MINOR2INST(getminor(dev)));
1415 
1416         if (instance == NULL) {
1417                 /* invalid minor number */
1418                 con_log(CL_ANN, (CE_WARN, "mr_sas: adapter not found."));
1419                 return (ENXIO);
1420         }
1421 
1422         ioctl = (struct mrsas_ioctl *)kmem_zalloc(sizeof (struct mrsas_ioctl),
1423             KM_SLEEP);
1424         ASSERT(ioctl);
1425 
1426         switch ((uint_t)cmd) {
1427                 case MRSAS_IOCTL_FIRMWARE:
1428                         if (ddi_copyin((void *)arg, ioctl,
1429                             sizeof (struct mrsas_ioctl), mode)) {
1430                                 con_log(CL_ANN, (CE_WARN, "mrsas_ioctl: "
1431                                     "ERROR IOCTL copyin"));
1432                                 kmem_free(ioctl, sizeof (struct mrsas_ioctl));
1433                                 return (EFAULT);
1434                         }
1435 
1436                         if (ioctl->control_code == MRSAS_DRIVER_IOCTL_COMMON) {
1437                                 rval = handle_drv_ioctl(instance, ioctl, mode);
1438                         } else {
1439                                 rval = handle_mfi_ioctl(instance, ioctl, mode);
1440                         }
1441 
1442                         if (ddi_copyout((void *)ioctl, (void *)arg,
1443                             (sizeof (struct mrsas_ioctl) - 1), mode)) {
1444                                 con_log(CL_ANN, (CE_WARN,
1445                                     "mrsas_ioctl: copy_to_user failed"));
1446                                 rval = 1;
1447                         }
1448 
1449                         break;
1450                 case MRSAS_IOCTL_AEN:
1451                         if (ddi_copyin((void *) arg, &aen,
1452                             sizeof (struct mrsas_aen), mode)) {
1453                                 con_log(CL_ANN, (CE_WARN,
1454                                     "mrsas_ioctl: ERROR AEN copyin"));
1455                                 kmem_free(ioctl, sizeof (struct mrsas_ioctl));
1456                                 return (EFAULT);
1457                         }
1458 
1459                         rval = handle_mfi_aen(instance, &aen);
1460 
1461                         if (ddi_copyout((void *) &aen, (void *)arg,
1462                             sizeof (struct mrsas_aen), mode)) {
1463                                 con_log(CL_ANN, (CE_WARN,
1464                                     "mrsas_ioctl: copy_to_user failed"));
1465                                 rval = 1;
1466                         }
1467 
1468                         break;
1469                 default:
1470                         rval = scsi_hba_ioctl(dev, cmd, arg,
1471                             mode, credp, rvalp);
1472 
1473                         con_log(CL_DLEVEL1, (CE_NOTE, "mrsas_ioctl: "
1474                             "scsi_hba_ioctl called, ret = %x.", rval));
1475         }
1476 
1477         kmem_free(ioctl, sizeof (struct mrsas_ioctl));
1478         return (rval);
1479 }
1480 
1481 /*
1482  * ************************************************************************** *
1483  *                                                                            *
1484  *               common entry points - for block driver types                 *
1485  *                                                                            *
1486  * ************************************************************************** *
1487  */
1488 #ifdef __sparc
1489 /*
1490  * reset - TBD
1491  * @dip:
1492  * @cmd:
1493  *
1494  * TBD
1495  */
1496 /*ARGSUSED*/
1497 static int
1498 mrsas_reset(dev_info_t *dip, ddi_reset_cmd_t cmd)
1499 {
1500         int     instance_no;
1501 
1502         struct mrsas_instance   *instance;
1503 
1504         instance_no = ddi_get_instance(dip);
1505         instance = (struct mrsas_instance *)ddi_get_soft_state
1506             (mrsas_state, instance_no);
1507 
1508         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1509 
1510         if (!instance) {
1511                 con_log(CL_ANN, (CE_WARN, "mr_sas:%d could not get adapter "
1512                     "in reset", instance_no));
1513                 return (DDI_FAILURE);
1514         }
1515 
1516         instance->func_ptr->disable_intr(instance);
1517 
1518         con_log(CL_ANN1, (CE_CONT, "flushing cache for instance %d",
1519             instance_no));
1520 
1521         flush_cache(instance);
1522 
1523         return (DDI_SUCCESS);
1524 }
1525 #else /* __sparc */
1526 /*ARGSUSED*/
1527 static int
1528 mrsas_quiesce(dev_info_t *dip)
1529 {
1530         int     instance_no;
1531 
1532         struct mrsas_instance   *instance;
1533 
1534         instance_no = ddi_get_instance(dip);
1535         instance = (struct mrsas_instance *)ddi_get_soft_state
1536             (mrsas_state, instance_no);
1537 
1538         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1539 
1540         if (!instance) {
1541                 con_log(CL_ANN1, (CE_WARN, "mr_sas:%d could not get adapter "
1542                     "in quiesce", instance_no));
1543                 return (DDI_FAILURE);
1544         }
1545         if (instance->deadadapter || instance->adapterresetinprogress) {
1546                 con_log(CL_ANN1, (CE_WARN, "mr_sas:%d adapter is not in "
1547                     "healthy state", instance_no));
1548                 return (DDI_FAILURE);
1549         }
1550 
1551         if (abort_aen_cmd(instance, instance->aen_cmd)) {
1552                 con_log(CL_ANN1, (CE_WARN, "mrsas_quiesce: "
1553                     "failed to abort prevous AEN command QUIESCE"));
1554         }
1555 
1556         if (instance->tbolt) {
1557                 if (abort_syncmap_cmd(instance,
1558                     instance->map_update_cmd)) {
1559                         dev_err(dip, CE_WARN,
1560                             "mrsas_detach: failed to abort "
1561                             "previous syncmap command");
1562                         return (DDI_FAILURE);
1563                 }
1564         }
1565 
1566         instance->func_ptr->disable_intr(instance);
1567 
1568         con_log(CL_ANN1, (CE_CONT, "flushing cache for instance %d",
1569             instance_no));
1570 
1571         flush_cache(instance);
1572 
1573         if (wait_for_outstanding(instance)) {
1574                 con_log(CL_ANN1,
1575                     (CE_CONT, "wait_for_outstanding: return FAIL.\n"));
1576                 return (DDI_FAILURE);
1577         }
1578         return (DDI_SUCCESS);
1579 }
1580 #endif  /* __sparc */
1581 
1582 /*
1583  * ************************************************************************** *
1584  *                                                                            *
1585  *                          entry points (SCSI HBA)                           *
1586  *                                                                            *
1587  * ************************************************************************** *
1588  */
1589 /*
1590  * tran_tgt_init - initialize a target device instance
1591  * @hba_dip:
1592  * @tgt_dip:
1593  * @tran:
1594  * @sd:
1595  *
1596  * The tran_tgt_init() entry point enables the HBA to allocate and initialize
1597  * any per-target resources. tran_tgt_init() also enables the HBA to qualify
1598  * the device's address as valid and supportable for that particular HBA.
1599  * By returning DDI_FAILURE, the instance of the target driver for that device
1600  * is not probed or attached.
1601  */
1602 /*ARGSUSED*/
1603 static int
1604 mrsas_tran_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1605     scsi_hba_tran_t *tran, struct scsi_device *sd)
1606 {
1607         struct mrsas_instance *instance;
1608         uint16_t tgt = sd->sd_address.a_target;
1609         uint8_t lun = sd->sd_address.a_lun;
1610         dev_info_t *child = NULL;
1611 
1612         con_log(CL_DLEVEL2, (CE_NOTE, "mrsas_tgt_init target %d lun %d",
1613             tgt, lun));
1614 
1615         instance = ADDR2MR(&sd->sd_address);
1616 
1617         if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
1618                 /*
1619                  * If no persistent node exists, we don't allow .conf node
1620                  * to be created.
1621                  */
1622                 if ((child = mrsas_find_child(instance, tgt, lun)) != NULL) {
1623                         con_log(CL_DLEVEL2,
1624                             (CE_NOTE, "mrsas_tgt_init find child ="
1625                             " %p t = %d l = %d", (void *)child, tgt, lun));
1626                         if (ndi_merge_node(tgt_dip, mrsas_name_node) !=
1627                             DDI_SUCCESS)
1628                                 /* Create this .conf node */
1629                                 return (DDI_SUCCESS);
1630                 }
1631                 con_log(CL_DLEVEL2, (CE_NOTE, "mrsas_tgt_init in ndi_per "
1632                     "DDI_FAILURE t = %d l = %d", tgt, lun));
1633                 return (DDI_FAILURE);
1634 
1635         }
1636 
1637         con_log(CL_DLEVEL2, (CE_NOTE, "mrsas_tgt_init dev_dip %p tgt_dip %p",
1638             (void *)instance->mr_ld_list[tgt].dip, (void *)tgt_dip));
1639 
1640         if (tgt < MRDRV_MAX_LD && lun == 0) {
1641                 if (instance->mr_ld_list[tgt].dip == NULL &&
1642                     strcmp(ddi_driver_name(sd->sd_dev), "sd") == 0) {
1643                         mutex_enter(&instance->config_dev_mtx);
1644                         instance->mr_ld_list[tgt].dip = tgt_dip;
1645                         instance->mr_ld_list[tgt].lun_type = MRSAS_LD_LUN;
1646                         instance->mr_ld_list[tgt].flag = MRDRV_TGT_VALID;
1647                         mutex_exit(&instance->config_dev_mtx);
1648                 }
1649         } else if (instance->tbolt || instance->skinny) {
1650                 if (instance->mr_tbolt_pd_list[tgt].dip == NULL) {
1651                         mutex_enter(&instance->config_dev_mtx);
1652                         instance->mr_tbolt_pd_list[tgt].dip = tgt_dip;
1653                         instance->mr_tbolt_pd_list[tgt].flag =
1654                             MRDRV_TGT_VALID;
1655                         mutex_exit(&instance->config_dev_mtx);
1656                         con_log(CL_ANN1, (CE_NOTE, "mrsas_tran_tgt_init:"
1657                             "t%xl%x", tgt, lun));
1658                 }
1659         }
1660 
1661         return (DDI_SUCCESS);
1662 }
1663 
1664 /*ARGSUSED*/
1665 static void
1666 mrsas_tran_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1667     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
1668 {
1669         struct mrsas_instance *instance;
1670         int tgt = sd->sd_address.a_target;
1671         int lun = sd->sd_address.a_lun;
1672 
1673         instance = ADDR2MR(&sd->sd_address);
1674 
1675         con_log(CL_DLEVEL2, (CE_NOTE, "tgt_free t = %d l = %d", tgt, lun));
1676 
1677         if (tgt < MRDRV_MAX_LD && lun == 0) {
1678                 if (instance->mr_ld_list[tgt].dip == tgt_dip) {
1679                         mutex_enter(&instance->config_dev_mtx);
1680                         instance->mr_ld_list[tgt].dip = NULL;
1681                         mutex_exit(&instance->config_dev_mtx);
1682                 }
1683         } else if (instance->tbolt || instance->skinny) {
1684                 mutex_enter(&instance->config_dev_mtx);
1685                 instance->mr_tbolt_pd_list[tgt].dip = NULL;
1686                 mutex_exit(&instance->config_dev_mtx);
1687                 con_log(CL_ANN1, (CE_NOTE, "tgt_free: Setting dip = NULL"
1688                     "for tgt:%x", tgt));
1689         }
1690 }
1691 
1692 dev_info_t *
1693 mrsas_find_child(struct mrsas_instance *instance, uint16_t tgt, uint8_t lun)
1694 {
1695         dev_info_t *child = NULL;
1696         char addr[SCSI_MAXNAMELEN];
1697         char tmp[MAXNAMELEN];
1698 
1699         (void) snprintf(addr, sizeof (addr), "%x,%x", tgt, lun);
1700         for (child = ddi_get_child(instance->dip); child;
1701             child = ddi_get_next_sibling(child)) {
1702 
1703                 if (ndi_dev_is_persistent_node(child) == 0) {
1704                         continue;
1705                 }
1706 
1707                 if (mrsas_name_node(child, tmp, MAXNAMELEN) !=
1708                     DDI_SUCCESS) {
1709                         continue;
1710                 }
1711 
1712                 if (strcmp(addr, tmp) == 0) {
1713                         break;
1714                 }
1715         }
1716         con_log(CL_DLEVEL2, (CE_NOTE, "mrsas_find_child: return child = %p",
1717             (void *)child));
1718         return (child);
1719 }
1720 
1721 /*
1722  * mrsas_name_node -
1723  * @dip:
1724  * @name:
1725  * @len:
1726  */
1727 static int
1728 mrsas_name_node(dev_info_t *dip, char *name, int len)
1729 {
1730         int tgt, lun;
1731 
1732         tgt = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1733             DDI_PROP_DONTPASS, "target", -1);
1734         con_log(CL_DLEVEL2, (CE_NOTE,
1735             "mrsas_name_node: dip %p tgt %d", (void *)dip, tgt));
1736         if (tgt == -1) {
1737                 return (DDI_FAILURE);
1738         }
1739         lun = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
1740             "lun", -1);
1741         con_log(CL_DLEVEL2,
1742             (CE_NOTE, "mrsas_name_node: tgt %d lun %d", tgt, lun));
1743         if (lun == -1) {
1744                 return (DDI_FAILURE);
1745         }
1746         (void) snprintf(name, len, "%x,%x", tgt, lun);
1747         return (DDI_SUCCESS);
1748 }
1749 
1750 /*
1751  * tran_init_pkt - allocate & initialize a scsi_pkt structure
1752  * @ap:
1753  * @pkt:
1754  * @bp:
1755  * @cmdlen:
1756  * @statuslen:
1757  * @tgtlen:
1758  * @flags:
1759  * @callback:
1760  *
1761  * The tran_init_pkt() entry point allocates and initializes a scsi_pkt
1762  * structure and DMA resources for a target driver request. The
1763  * tran_init_pkt() entry point is called when the target driver calls the
1764  * SCSA function scsi_init_pkt(). Each call of the tran_init_pkt() entry point
1765  * is a request to perform one or more of three possible services:
1766  *  - allocation and initialization of a scsi_pkt structure
1767  *  - allocation of DMA resources for data transfer
1768  *  - reallocation of DMA resources for the next portion of the data transfer
1769  */
1770 static struct scsi_pkt *
1771 mrsas_tran_init_pkt(struct scsi_address *ap, register struct scsi_pkt *pkt,
1772     struct buf *bp, int cmdlen, int statuslen, int tgtlen,
1773     int flags, int (*callback)(), caddr_t arg)
1774 {
1775         struct scsa_cmd *acmd;
1776         struct mrsas_instance   *instance;
1777         struct scsi_pkt *new_pkt;
1778 
1779         con_log(CL_DLEVEL1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1780 
1781         instance = ADDR2MR(ap);
1782 
1783         /* step #1 : pkt allocation */
1784         if (pkt == NULL) {
1785                 pkt = scsi_hba_pkt_alloc(instance->dip, ap, cmdlen, statuslen,
1786                     tgtlen, sizeof (struct scsa_cmd), callback, arg);
1787                 if (pkt == NULL) {
1788                         return (NULL);
1789                 }
1790 
1791                 acmd = PKT2CMD(pkt);
1792 
1793                 /*
1794                  * Initialize the new pkt - we redundantly initialize
1795                  * all the fields for illustrative purposes.
1796                  */
1797                 acmd->cmd_pkt                = pkt;
1798                 acmd->cmd_flags              = 0;
1799                 acmd->cmd_scblen     = statuslen;
1800                 acmd->cmd_cdblen     = cmdlen;
1801                 acmd->cmd_dmahandle  = NULL;
1802                 acmd->cmd_ncookies   = 0;
1803                 acmd->cmd_cookie     = 0;
1804                 acmd->cmd_cookiecnt  = 0;
1805                 acmd->cmd_nwin               = 0;
1806 
1807                 pkt->pkt_address     = *ap;
1808                 pkt->pkt_comp                = (void (*)())NULL;
1809                 pkt->pkt_flags               = 0;
1810                 pkt->pkt_time                = 0;
1811                 pkt->pkt_resid               = 0;
1812                 pkt->pkt_state               = 0;
1813                 pkt->pkt_statistics  = 0;
1814                 pkt->pkt_reason              = 0;
1815                 new_pkt                 = pkt;
1816         } else {
1817                 acmd = PKT2CMD(pkt);
1818                 new_pkt = NULL;
1819         }
1820 
1821         /* step #2 : dma allocation/move */
1822         if (bp && bp->b_bcount != 0) {
1823                 if (acmd->cmd_dmahandle == NULL) {
1824                         if (mrsas_dma_alloc(instance, pkt, bp, flags,
1825                             callback) == DDI_FAILURE) {
1826                                 if (new_pkt) {
1827                                         scsi_hba_pkt_free(ap, new_pkt);
1828                                 }
1829                                 return ((struct scsi_pkt *)NULL);
1830                         }
1831                 } else {
1832                         if (mrsas_dma_move(instance, pkt, bp) == DDI_FAILURE) {
1833                                 return ((struct scsi_pkt *)NULL);
1834                         }
1835                 }
1836         }
1837 
1838         return (pkt);
1839 }
1840 
1841 /*
1842  * tran_start - transport a SCSI command to the addressed target
1843  * @ap:
1844  * @pkt:
1845  *
1846  * The tran_start() entry point for a SCSI HBA driver is called to transport a
1847  * SCSI command to the addressed target. The SCSI command is described
1848  * entirely within the scsi_pkt structure, which the target driver allocated
1849  * through the HBA driver's tran_init_pkt() entry point. If the command
1850  * involves a data transfer, DMA resources must also have been allocated for
1851  * the scsi_pkt structure.
1852  *
1853  * Return Values :
1854  *      TRAN_BUSY - request queue is full, no more free scbs
1855  *      TRAN_ACCEPT - pkt has been submitted to the instance
1856  */
1857 static int
1858 mrsas_tran_start(struct scsi_address *ap, register struct scsi_pkt *pkt)
1859 {
1860         uchar_t         cmd_done = 0;
1861 
1862         struct mrsas_instance   *instance = ADDR2MR(ap);
1863         struct mrsas_cmd        *cmd;
1864 
1865         con_log(CL_DLEVEL1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1866         if (instance->deadadapter == 1) {
1867                 con_log(CL_ANN1, (CE_WARN,
1868                     "mrsas_tran_start: return TRAN_FATAL_ERROR "
1869                     "for IO, as the HBA doesnt take any more IOs"));
1870                 if (pkt) {
1871                         pkt->pkt_reason              = CMD_DEV_GONE;
1872                         pkt->pkt_statistics  = STAT_DISCON;
1873                 }
1874                 return (TRAN_FATAL_ERROR);
1875         }
1876 
1877         if (instance->adapterresetinprogress) {
1878                 con_log(CL_ANN1, (CE_NOTE, "mrsas_tran_start: Reset flag set, "
1879                     "returning mfi_pkt and setting TRAN_BUSY\n"));
1880                 return (TRAN_BUSY);
1881         }
1882 
1883         con_log(CL_ANN1, (CE_CONT, "chkpnt:%s:%d:SCSI CDB[0]=0x%x time:%x",
1884             __func__, __LINE__, pkt->pkt_cdbp[0], pkt->pkt_time));
1885 
1886         pkt->pkt_reason      = CMD_CMPLT;
1887         *pkt->pkt_scbp = STATUS_GOOD; /* clear arq scsi_status */
1888 
1889         cmd = build_cmd(instance, ap, pkt, &cmd_done);
1890 
1891         /*
1892          * Check if the command is already completed by the mrsas_build_cmd()
1893          * routine. In which case the busy_flag would be clear and scb will be
1894          * NULL and appropriate reason provided in pkt_reason field
1895          */
1896         if (cmd_done) {
1897                 pkt->pkt_reason = CMD_CMPLT;
1898                 pkt->pkt_scbp[0] = STATUS_GOOD;
1899                 pkt->pkt_state |= STATE_GOT_BUS | STATE_GOT_TARGET
1900                     | STATE_SENT_CMD;
1901                 if (((pkt->pkt_flags & FLAG_NOINTR) == 0) && pkt->pkt_comp) {
1902                         (*pkt->pkt_comp)(pkt);
1903                 }
1904 
1905                 return (TRAN_ACCEPT);
1906         }
1907 
1908         if (cmd == NULL) {
1909                 return (TRAN_BUSY);
1910         }
1911 
1912         if ((pkt->pkt_flags & FLAG_NOINTR) == 0) {
1913                 if (instance->fw_outstanding > instance->max_fw_cmds) {
1914                         con_log(CL_ANN, (CE_CONT, "mr_sas:Firmware busy"));
1915                         DTRACE_PROBE2(start_tran_err,
1916                             uint16_t, instance->fw_outstanding,
1917                             uint16_t, instance->max_fw_cmds);
1918                         mrsas_return_mfi_pkt(instance, cmd);
1919                         return (TRAN_BUSY);
1920                 }
1921 
1922                 /* Synchronize the Cmd frame for the controller */
1923                 (void) ddi_dma_sync(cmd->frame_dma_obj.dma_handle, 0, 0,
1924                     DDI_DMA_SYNC_FORDEV);
1925                 con_log(CL_ANN, (CE_CONT, "issue_cmd_ppc: SCSI CDB[0]=0x%x"
1926                     "cmd->index:%x\n", pkt->pkt_cdbp[0], cmd->index));
1927                 instance->func_ptr->issue_cmd(cmd, instance);
1928 
1929         } else {
1930                 struct mrsas_header *hdr = &cmd->frame->hdr;
1931 
1932                 instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd);
1933 
1934                 pkt->pkt_reason              = CMD_CMPLT;
1935                 pkt->pkt_statistics  = 0;
1936                 pkt->pkt_state |= STATE_XFERRED_DATA | STATE_GOT_STATUS;
1937 
1938                 switch (ddi_get8(cmd->frame_dma_obj.acc_handle,
1939                     &hdr->cmd_status)) {
1940                 case MFI_STAT_OK:
1941                         pkt->pkt_scbp[0] = STATUS_GOOD;
1942                         break;
1943 
1944                 case MFI_STAT_SCSI_DONE_WITH_ERROR:
1945                         con_log(CL_ANN, (CE_CONT,
1946                             "mrsas_tran_start: scsi done with error"));
1947                         pkt->pkt_reason      = CMD_CMPLT;
1948                         pkt->pkt_statistics = 0;
1949 
1950                         ((struct scsi_status *)pkt->pkt_scbp)->sts_chk = 1;
1951                         break;
1952 
1953                 case MFI_STAT_DEVICE_NOT_FOUND:
1954                         con_log(CL_ANN, (CE_CONT,
1955                             "mrsas_tran_start: device not found error"));
1956                         pkt->pkt_reason              = CMD_DEV_GONE;
1957                         pkt->pkt_statistics  = STAT_DISCON;
1958                         break;
1959 
1960                 default:
1961                         ((struct scsi_status *)pkt->pkt_scbp)->sts_busy = 1;
1962                 }
1963 
1964                 (void) mrsas_common_check(instance, cmd);
1965                 DTRACE_PROBE2(start_nointr_done, uint8_t, hdr->cmd,
1966                     uint8_t, hdr->cmd_status);
1967                 mrsas_return_mfi_pkt(instance, cmd);
1968 
1969                 if (pkt->pkt_comp) {
1970                         (*pkt->pkt_comp)(pkt);
1971                 }
1972 
1973         }
1974 
1975         return (TRAN_ACCEPT);
1976 }
1977 
1978 /*
1979  * tran_abort - Abort any commands that are currently in transport
1980  * @ap:
1981  * @pkt:
1982  *
1983  * The tran_abort() entry point for a SCSI HBA driver is called to abort any
1984  * commands that are currently in transport for a particular target. This entry
1985  * point is called when a target driver calls scsi_abort(). The tran_abort()
1986  * entry point should attempt to abort the command denoted by the pkt
1987  * parameter. If the pkt parameter is NULL, tran_abort() should attempt to
1988  * abort all outstanding commands in the transport layer for the particular
1989  * target or logical unit.
1990  */
1991 /*ARGSUSED*/
1992 static int
1993 mrsas_tran_abort(struct scsi_address *ap, struct scsi_pkt *pkt)
1994 {
1995         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
1996 
1997         /* abort command not supported by H/W */
1998 
1999         return (DDI_FAILURE);
2000 }
2001 
2002 /*
2003  * tran_reset - reset either the SCSI bus or target
2004  * @ap:
2005  * @level:
2006  *
2007  * The tran_reset() entry point for a SCSI HBA driver is called to reset either
2008  * the SCSI bus or a particular SCSI target device. This entry point is called
2009  * when a target driver calls scsi_reset(). The tran_reset() entry point must
2010  * reset the SCSI bus if level is RESET_ALL. If level is RESET_TARGET, just the
2011  * particular target or logical unit must be reset.
2012  */
2013 /*ARGSUSED*/
2014 static int
2015 mrsas_tran_reset(struct scsi_address *ap, int level)
2016 {
2017         struct mrsas_instance *instance = ADDR2MR(ap);
2018 
2019         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2020 
2021         if (wait_for_outstanding(instance)) {
2022                 con_log(CL_ANN1,
2023                     (CE_CONT, "wait_for_outstanding: return FAIL.\n"));
2024                 return (DDI_FAILURE);
2025         } else {
2026                 return (DDI_SUCCESS);
2027         }
2028 }
2029 
2030 /*
2031  * tran_getcap - get one of a set of SCSA-defined capabilities
2032  * @ap:
2033  * @cap:
2034  * @whom:
2035  *
2036  * The target driver can request the current setting of the capability for a
2037  * particular target by setting the whom parameter to nonzero. A whom value of
2038  * zero indicates a request for the current setting of the general capability
2039  * for the SCSI bus or for adapter hardware. The tran_getcap() should return -1
2040  * for undefined capabilities or the current value of the requested capability.
2041  */
2042 /*ARGSUSED*/
2043 static int
2044 mrsas_tran_getcap(struct scsi_address *ap, char *cap, int whom)
2045 {
2046         int     rval = 0;
2047 
2048         struct mrsas_instance   *instance = ADDR2MR(ap);
2049 
2050         con_log(CL_DLEVEL2, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2051 
2052         /* we do allow inquiring about capabilities for other targets */
2053         if (cap == NULL) {
2054                 return (-1);
2055         }
2056 
2057         switch (scsi_hba_lookup_capstr(cap)) {
2058         case SCSI_CAP_DMA_MAX:
2059                 if (instance->tbolt) {
2060                         /* Limit to 256k max transfer */
2061                         rval = mrsas_tbolt_max_cap_maxxfer;
2062                 } else {
2063                         /* Limit to 16MB max transfer */
2064                         rval = mrsas_max_cap_maxxfer;
2065                 }
2066                 break;
2067         case SCSI_CAP_MSG_OUT:
2068                 rval = 1;
2069                 break;
2070         case SCSI_CAP_DISCONNECT:
2071                 rval = 0;
2072                 break;
2073         case SCSI_CAP_SYNCHRONOUS:
2074                 rval = 0;
2075                 break;
2076         case SCSI_CAP_WIDE_XFER:
2077                 rval = 1;
2078                 break;
2079         case SCSI_CAP_TAGGED_QING:
2080                 rval = 1;
2081                 break;
2082         case SCSI_CAP_UNTAGGED_QING:
2083                 rval = 1;
2084                 break;
2085         case SCSI_CAP_PARITY:
2086                 rval = 1;
2087                 break;
2088         case SCSI_CAP_INITIATOR_ID:
2089                 rval = instance->init_id;
2090                 break;
2091         case SCSI_CAP_ARQ:
2092                 rval = 1;
2093                 break;
2094         case SCSI_CAP_LINKED_CMDS:
2095                 rval = 0;
2096                 break;
2097         case SCSI_CAP_RESET_NOTIFICATION:
2098                 rval = 1;
2099                 break;
2100         case SCSI_CAP_GEOMETRY:
2101                 rval = -1;
2102 
2103                 break;
2104         default:
2105                 con_log(CL_DLEVEL2, (CE_NOTE, "Default cap coming 0x%x",
2106                     scsi_hba_lookup_capstr(cap)));
2107                 rval = -1;
2108                 break;
2109         }
2110 
2111         return (rval);
2112 }
2113 
2114 /*
2115  * tran_setcap - set one of a set of SCSA-defined capabilities
2116  * @ap:
2117  * @cap:
2118  * @value:
2119  * @whom:
2120  *
2121  * The target driver might request that the new value be set for a particular
2122  * target by setting the whom parameter to nonzero. A whom value of zero
2123  * means that request is to set the new value for the SCSI bus or for adapter
2124  * hardware in general.
2125  * The tran_setcap() should return the following values as appropriate:
2126  * - -1 for undefined capabilities
2127  * - 0 if the HBA driver cannot set the capability to the requested value
2128  * - 1 if the HBA driver is able to set the capability to the requested value
2129  */
2130 /*ARGSUSED*/
2131 static int
2132 mrsas_tran_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2133 {
2134         int             rval = 1;
2135 
2136         con_log(CL_DLEVEL2, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2137 
2138         /* We don't allow setting capabilities for other targets */
2139         if (cap == NULL || whom == 0) {
2140                 return (-1);
2141         }
2142 
2143         switch (scsi_hba_lookup_capstr(cap)) {
2144                 case SCSI_CAP_DMA_MAX:
2145                 case SCSI_CAP_MSG_OUT:
2146                 case SCSI_CAP_PARITY:
2147                 case SCSI_CAP_LINKED_CMDS:
2148                 case SCSI_CAP_RESET_NOTIFICATION:
2149                 case SCSI_CAP_DISCONNECT:
2150                 case SCSI_CAP_SYNCHRONOUS:
2151                 case SCSI_CAP_UNTAGGED_QING:
2152                 case SCSI_CAP_WIDE_XFER:
2153                 case SCSI_CAP_INITIATOR_ID:
2154                 case SCSI_CAP_ARQ:
2155                         /*
2156                          * None of these are settable via
2157                          * the capability interface.
2158                          */
2159                         break;
2160                 case SCSI_CAP_TAGGED_QING:
2161                         rval = 1;
2162                         break;
2163                 case SCSI_CAP_SECTOR_SIZE:
2164                         rval = 1;
2165                         break;
2166 
2167                 case SCSI_CAP_TOTAL_SECTORS:
2168                         rval = 1;
2169                         break;
2170                 default:
2171                         rval = -1;
2172                         break;
2173         }
2174 
2175         return (rval);
2176 }
2177 
2178 /*
2179  * tran_destroy_pkt - deallocate scsi_pkt structure
2180  * @ap:
2181  * @pkt:
2182  *
2183  * The tran_destroy_pkt() entry point is the HBA driver function that
2184  * deallocates scsi_pkt structures. The tran_destroy_pkt() entry point is
2185  * called when the target driver calls scsi_destroy_pkt(). The
2186  * tran_destroy_pkt() entry point must free any DMA resources that have been
2187  * allocated for the packet. An implicit DMA synchronization occurs if the
2188  * DMA resources are freed and any cached data remains after the completion
2189  * of the transfer.
2190  */
2191 static void
2192 mrsas_tran_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
2193 {
2194         struct scsa_cmd *acmd = PKT2CMD(pkt);
2195 
2196         con_log(CL_DLEVEL2, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2197 
2198         if (acmd->cmd_flags & CFLAG_DMAVALID) {
2199                 acmd->cmd_flags &= ~CFLAG_DMAVALID;
2200 
2201                 (void) ddi_dma_unbind_handle(acmd->cmd_dmahandle);
2202 
2203                 ddi_dma_free_handle(&acmd->cmd_dmahandle);
2204 
2205                 acmd->cmd_dmahandle = NULL;
2206         }
2207 
2208         /* free the pkt */
2209         scsi_hba_pkt_free(ap, pkt);
2210 }
2211 
2212 /*
2213  * tran_dmafree - deallocates DMA resources
2214  * @ap:
2215  * @pkt:
2216  *
2217  * The tran_dmafree() entry point deallocates DMAQ resources that have been
2218  * allocated for a scsi_pkt structure. The tran_dmafree() entry point is
2219  * called when the target driver calls scsi_dmafree(). The tran_dmafree() must
2220  * free only DMA resources allocated for a scsi_pkt structure, not the
2221  * scsi_pkt itself. When DMA resources are freed, a DMA synchronization is
2222  * implicitly performed.
2223  */
2224 /*ARGSUSED*/
2225 static void
2226 mrsas_tran_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
2227 {
2228         register struct scsa_cmd *acmd = PKT2CMD(pkt);
2229 
2230         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2231 
2232         if (acmd->cmd_flags & CFLAG_DMAVALID) {
2233                 acmd->cmd_flags &= ~CFLAG_DMAVALID;
2234 
2235                 (void) ddi_dma_unbind_handle(acmd->cmd_dmahandle);
2236 
2237                 ddi_dma_free_handle(&acmd->cmd_dmahandle);
2238 
2239                 acmd->cmd_dmahandle = NULL;
2240         }
2241 }
2242 
2243 /*
2244  * tran_sync_pkt - synchronize the DMA object allocated
2245  * @ap:
2246  * @pkt:
2247  *
2248  * The tran_sync_pkt() entry point synchronizes the DMA object allocated for
2249  * the scsi_pkt structure before or after a DMA transfer. The tran_sync_pkt()
2250  * entry point is called when the target driver calls scsi_sync_pkt(). If the
2251  * data transfer direction is a DMA read from device to memory, tran_sync_pkt()
2252  * must synchronize the CPU's view of the data. If the data transfer direction
2253  * is a DMA write from memory to device, tran_sync_pkt() must synchronize the
2254  * device's view of the data.
2255  */
2256 /*ARGSUSED*/
2257 static void
2258 mrsas_tran_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
2259 {
2260         register struct scsa_cmd        *acmd = PKT2CMD(pkt);
2261 
2262         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2263 
2264         if (acmd->cmd_flags & CFLAG_DMAVALID) {
2265                 (void) ddi_dma_sync(acmd->cmd_dmahandle, acmd->cmd_dma_offset,
2266                     acmd->cmd_dma_len, (acmd->cmd_flags & CFLAG_DMASEND) ?
2267                     DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
2268         }
2269 }
2270 
2271 /*ARGSUSED*/
2272 static int
2273 mrsas_tran_quiesce(dev_info_t *dip)
2274 {
2275         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2276 
2277         return (1);
2278 }
2279 
2280 /*ARGSUSED*/
2281 static int
2282 mrsas_tran_unquiesce(dev_info_t *dip)
2283 {
2284         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2285 
2286         return (1);
2287 }
2288 
2289 
2290 /*
2291  * mrsas_isr(caddr_t)
2292  *
2293  * The Interrupt Service Routine
2294  *
2295  * Collect status for all completed commands and do callback
2296  *
2297  */
2298 static uint_t
2299 mrsas_isr(struct mrsas_instance *instance)
2300 {
2301         int             need_softintr;
2302         uint32_t        producer;
2303         uint32_t        consumer;
2304         uint32_t        context;
2305         int             retval;
2306 
2307         struct mrsas_cmd        *cmd;
2308         struct mrsas_header     *hdr;
2309         struct scsi_pkt         *pkt;
2310 
2311         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2312         ASSERT(instance);
2313         if (instance->tbolt) {
2314                 mutex_enter(&instance->chip_mtx);
2315                 if ((instance->intr_type == DDI_INTR_TYPE_FIXED) &&
2316                     !(instance->func_ptr->intr_ack(instance))) {
2317                         mutex_exit(&instance->chip_mtx);
2318                         return (DDI_INTR_UNCLAIMED);
2319                 }
2320                 retval = mr_sas_tbolt_process_outstanding_cmd(instance);
2321                 mutex_exit(&instance->chip_mtx);
2322                 return (retval);
2323         } else {
2324                 if ((instance->intr_type == DDI_INTR_TYPE_FIXED) &&
2325                     !instance->func_ptr->intr_ack(instance)) {
2326                         return (DDI_INTR_UNCLAIMED);
2327                 }
2328         }
2329 
2330         (void) ddi_dma_sync(instance->mfi_internal_dma_obj.dma_handle,
2331             0, 0, DDI_DMA_SYNC_FORCPU);
2332 
2333         if (mrsas_check_dma_handle(instance->mfi_internal_dma_obj.dma_handle)
2334             != DDI_SUCCESS) {
2335                 mrsas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
2336                 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
2337                 con_log(CL_ANN1, (CE_WARN,
2338                     "mr_sas_isr(): FMA check, returning DDI_INTR_UNCLAIMED"));
2339                 return (DDI_INTR_CLAIMED);
2340         }
2341         con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
2342 
2343 #ifdef OCRDEBUG
2344         if (debug_consecutive_timeout_after_ocr_g == 1) {
2345                 con_log(CL_ANN1, (CE_NOTE,
2346                     "simulating consecutive timeout after ocr"));
2347                 return (DDI_INTR_CLAIMED);
2348         }
2349 #endif
2350 
2351         mutex_enter(&instance->completed_pool_mtx);
2352         mutex_enter(&instance->cmd_pend_mtx);
2353 
2354         producer = ddi_get32(instance->mfi_internal_dma_obj.acc_handle,
2355             instance->producer);
2356         consumer = ddi_get32(instance->mfi_internal_dma_obj.acc_handle,
2357             instance->consumer);
2358 
2359         con_log(CL_ANN, (CE_CONT, " producer %x consumer %x ",
2360             producer, consumer));
2361         if (producer == consumer) {
2362                 con_log(CL_ANN, (CE_WARN, "producer ==  consumer case"));
2363                 DTRACE_PROBE2(isr_pc_err, uint32_t, producer,
2364                     uint32_t, consumer);
2365                 mutex_exit(&instance->cmd_pend_mtx);
2366                 mutex_exit(&instance->completed_pool_mtx);
2367                 return (DDI_INTR_CLAIMED);
2368         }
2369 
2370         while (consumer != producer) {
2371                 context = ddi_get32(instance->mfi_internal_dma_obj.acc_handle,
2372                     &instance->reply_queue[consumer]);
2373                 cmd = instance->cmd_list[context];
2374 
2375                 if (cmd->sync_cmd == MRSAS_TRUE) {
2376                         hdr = (struct mrsas_header *)&cmd->frame->hdr;
2377                         if (hdr) {
2378                                 mlist_del_init(&cmd->list);
2379                         }
2380                 } else {
2381                         pkt = cmd->pkt;
2382                         if (pkt) {
2383                                 mlist_del_init(&cmd->list);
2384                         }
2385                 }
2386 
2387                 mlist_add_tail(&cmd->list, &instance->completed_pool_list);
2388 
2389                 consumer++;
2390                 if (consumer == (instance->max_fw_cmds + 1)) {
2391                         consumer = 0;
2392                 }
2393         }
2394         ddi_put32(instance->mfi_internal_dma_obj.acc_handle,
2395             instance->consumer, consumer);
2396         mutex_exit(&instance->cmd_pend_mtx);
2397         mutex_exit(&instance->completed_pool_mtx);
2398 
2399         (void) ddi_dma_sync(instance->mfi_internal_dma_obj.dma_handle,
2400             0, 0, DDI_DMA_SYNC_FORDEV);
2401 
2402         if (instance->softint_running) {
2403                 need_softintr = 0;
2404         } else {
2405                 need_softintr = 1;
2406         }
2407 
2408         if (instance->isr_level == HIGH_LEVEL_INTR) {
2409                 if (need_softintr) {
2410                         ddi_trigger_softintr(instance->soft_intr_id);
2411                 }
2412         } else {
2413                 /*
2414                  * Not a high-level interrupt, therefore call the soft level
2415                  * interrupt explicitly
2416                  */
2417                 (void) mrsas_softintr(instance);
2418         }
2419 
2420         return (DDI_INTR_CLAIMED);
2421 }
2422 
2423 
2424 /*
2425  * ************************************************************************** *
2426  *                                                                            *
2427  *                                  libraries                                 *
2428  *                                                                            *
2429  * ************************************************************************** *
2430  */
2431 /*
2432  * get_mfi_pkt : Get a command from the free pool
2433  * After successful allocation, the caller of this routine
2434  * must clear the frame buffer (memset to zero) before
2435  * using the packet further.
2436  *
2437  * ***** Note *****
2438  * After clearing the frame buffer the context id of the
2439  * frame buffer SHOULD be restored back.
2440  */
2441 struct mrsas_cmd *
2442 mrsas_get_mfi_pkt(struct mrsas_instance *instance)
2443 {
2444         mlist_t                 *head = &instance->cmd_pool_list;
2445         struct mrsas_cmd        *cmd = NULL;
2446 
2447         mutex_enter(&instance->cmd_pool_mtx);
2448 
2449         if (!mlist_empty(head)) {
2450                 cmd = mlist_entry(head->next, struct mrsas_cmd, list);
2451                 mlist_del_init(head->next);
2452         }
2453         if (cmd != NULL) {
2454                 cmd->pkt = NULL;
2455                 cmd->retry_count_for_ocr = 0;
2456                 cmd->drv_pkt_time = 0;
2457 
2458         }
2459         mutex_exit(&instance->cmd_pool_mtx);
2460 
2461         return (cmd);
2462 }
2463 
2464 static struct mrsas_cmd *
2465 get_mfi_app_pkt(struct mrsas_instance *instance)
2466 {
2467         mlist_t                         *head = &instance->app_cmd_pool_list;
2468         struct mrsas_cmd        *cmd = NULL;
2469 
2470         mutex_enter(&instance->app_cmd_pool_mtx);
2471 
2472         if (!mlist_empty(head)) {
2473                 cmd = mlist_entry(head->next, struct mrsas_cmd, list);
2474                 mlist_del_init(head->next);
2475         }
2476         if (cmd != NULL) {
2477                 cmd->pkt = NULL;
2478                 cmd->retry_count_for_ocr = 0;
2479                 cmd->drv_pkt_time = 0;
2480         }
2481 
2482         mutex_exit(&instance->app_cmd_pool_mtx);
2483 
2484         return (cmd);
2485 }
2486 /*
2487  * return_mfi_pkt : Return a cmd to free command pool
2488  */
2489 void
2490 mrsas_return_mfi_pkt(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
2491 {
2492         mutex_enter(&instance->cmd_pool_mtx);
2493         /* use mlist_add_tail for debug assistance */
2494         mlist_add_tail(&cmd->list, &instance->cmd_pool_list);
2495 
2496         mutex_exit(&instance->cmd_pool_mtx);
2497 }
2498 
2499 static void
2500 return_mfi_app_pkt(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
2501 {
2502         mutex_enter(&instance->app_cmd_pool_mtx);
2503 
2504         mlist_add(&cmd->list, &instance->app_cmd_pool_list);
2505 
2506         mutex_exit(&instance->app_cmd_pool_mtx);
2507 }
2508 void
2509 push_pending_mfi_pkt(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
2510 {
2511         struct scsi_pkt *pkt;
2512         struct mrsas_header     *hdr;
2513         con_log(CL_DLEVEL2, (CE_NOTE, "push_pending_pkt(): Called\n"));
2514         mutex_enter(&instance->cmd_pend_mtx);
2515         mlist_del_init(&cmd->list);
2516         mlist_add_tail(&cmd->list, &instance->cmd_pend_list);
2517         if (cmd->sync_cmd == MRSAS_TRUE) {
2518                 hdr = (struct mrsas_header *)&cmd->frame->hdr;
2519                 if (hdr) {
2520                         con_log(CL_ANN1, (CE_CONT,
2521                             "push_pending_mfi_pkt: "
2522                             "cmd %p index %x "
2523                             "time %llx",
2524                             (void *)cmd, cmd->index,
2525                             gethrtime()));
2526                         /* Wait for specified interval  */
2527                         cmd->drv_pkt_time = ddi_get16(
2528                             cmd->frame_dma_obj.acc_handle, &hdr->timeout);
2529                         if (cmd->drv_pkt_time < debug_timeout_g)
2530                                 cmd->drv_pkt_time = (uint16_t)debug_timeout_g;
2531                                 con_log(CL_ANN1, (CE_CONT,
2532                                     "push_pending_pkt(): "
2533                                     "Called IO Timeout Value %x\n",
2534                                     cmd->drv_pkt_time));
2535                 }
2536                 if (hdr && instance->timeout_id == (timeout_id_t)-1) {
2537                         instance->timeout_id = timeout(io_timeout_checker,
2538                             (void *) instance, drv_usectohz(MRSAS_1_SECOND));
2539                 }
2540         } else {
2541                 pkt = cmd->pkt;
2542                 if (pkt) {
2543                         con_log(CL_ANN1, (CE_CONT,
2544                             "push_pending_mfi_pkt: "
2545                             "cmd %p index %x pkt %p, "
2546                             "time %llx",
2547                             (void *)cmd, cmd->index, (void *)pkt,
2548                             gethrtime()));
2549                         cmd->drv_pkt_time = (uint16_t)debug_timeout_g;
2550                 }
2551                 if (pkt && instance->timeout_id == (timeout_id_t)-1) {
2552                         instance->timeout_id = timeout(io_timeout_checker,
2553                             (void *) instance, drv_usectohz(MRSAS_1_SECOND));
2554                 }
2555         }
2556 
2557         mutex_exit(&instance->cmd_pend_mtx);
2558 
2559 }
2560 
2561 int
2562 mrsas_print_pending_cmds(struct mrsas_instance *instance)
2563 {
2564         mlist_t *head = &instance->cmd_pend_list;
2565         mlist_t *tmp = head;
2566         struct mrsas_cmd *cmd = NULL;
2567         struct mrsas_header     *hdr;
2568         unsigned int            flag = 1;
2569         struct scsi_pkt *pkt;
2570         int saved_level;
2571         int cmd_count = 0;
2572 
2573         saved_level = debug_level_g;
2574         debug_level_g = CL_ANN1;
2575 
2576         dev_err(instance->dip, CE_NOTE,
2577             "mrsas_print_pending_cmds(): Called");
2578 
2579         while (flag) {
2580                 mutex_enter(&instance->cmd_pend_mtx);
2581                 tmp     =       tmp->next;
2582                 if (tmp == head) {
2583                         mutex_exit(&instance->cmd_pend_mtx);
2584                         flag = 0;
2585                         con_log(CL_ANN1, (CE_CONT, "mrsas_print_pending_cmds():"
2586                             " NO MORE CMDS PENDING....\n"));
2587                         break;
2588                 } else {
2589                         cmd = mlist_entry(tmp, struct mrsas_cmd, list);
2590                         mutex_exit(&instance->cmd_pend_mtx);
2591                         if (cmd) {
2592                                 if (cmd->sync_cmd == MRSAS_TRUE) {
2593                                         hdr = (struct mrsas_header *)
2594                                             &cmd->frame->hdr;
2595                                         if (hdr) {
2596                                                 con_log(CL_ANN1, (CE_CONT,
2597                                                     "print: cmd %p index 0x%x "
2598                                                     "drv_pkt_time 0x%x (NO-PKT)"
2599                                                     " hdr %p\n", (void *)cmd,
2600                                                     cmd->index,
2601                                                     cmd->drv_pkt_time,
2602                                                     (void *)hdr));
2603                                         }
2604                                 } else {
2605                                         pkt = cmd->pkt;
2606                                         if (pkt) {
2607                                         con_log(CL_ANN1, (CE_CONT,
2608                                             "print: cmd %p index 0x%x "
2609                                             "drv_pkt_time 0x%x pkt %p \n",
2610                                             (void *)cmd, cmd->index,
2611                                             cmd->drv_pkt_time, (void *)pkt));
2612                                         }
2613                                 }
2614 
2615                                 if (++cmd_count == 1) {
2616                                         mrsas_print_cmd_details(instance, cmd,
2617                                             0xDD);
2618                                 } else {
2619                                         mrsas_print_cmd_details(instance, cmd,
2620                                             1);
2621                                 }
2622 
2623                         }
2624                 }
2625         }
2626         con_log(CL_ANN1, (CE_CONT, "mrsas_print_pending_cmds(): Done\n"));
2627 
2628 
2629         debug_level_g = saved_level;
2630 
2631         return (DDI_SUCCESS);
2632 }
2633 
2634 
2635 int
2636 mrsas_complete_pending_cmds(struct mrsas_instance *instance)
2637 {
2638 
2639         struct mrsas_cmd *cmd = NULL;
2640         struct scsi_pkt *pkt;
2641         struct mrsas_header *hdr;
2642 
2643         struct mlist_head               *pos, *next;
2644 
2645         con_log(CL_ANN1, (CE_NOTE,
2646             "mrsas_complete_pending_cmds(): Called"));
2647 
2648         mutex_enter(&instance->cmd_pend_mtx);
2649         mlist_for_each_safe(pos, next, &instance->cmd_pend_list) {
2650                 cmd = mlist_entry(pos, struct mrsas_cmd, list);
2651                 if (cmd) {
2652                         pkt = cmd->pkt;
2653                         if (pkt) { /* for IO */
2654                                 if (((pkt->pkt_flags & FLAG_NOINTR)
2655                                     == 0) && pkt->pkt_comp) {
2656                                         pkt->pkt_reason
2657                                             = CMD_DEV_GONE;
2658                                         pkt->pkt_statistics
2659                                             = STAT_DISCON;
2660                                         con_log(CL_ANN1, (CE_CONT,
2661                                             "fail and posting to scsa "
2662                                             "cmd %p index %x"
2663                                             " pkt %p "
2664                                             "time : %llx",
2665                                             (void *)cmd, cmd->index,
2666                                             (void *)pkt, gethrtime()));
2667                                         (*pkt->pkt_comp)(pkt);
2668                                 }
2669                         } else { /* for DCMDS */
2670                                 if (cmd->sync_cmd == MRSAS_TRUE) {
2671                                 hdr = (struct mrsas_header *)&cmd->frame->hdr;
2672                                 con_log(CL_ANN1, (CE_CONT,
2673                                     "posting invalid status to application "
2674                                     "cmd %p index %x"
2675                                     " hdr %p "
2676                                     "time : %llx",
2677                                     (void *)cmd, cmd->index,
2678                                     (void *)hdr, gethrtime()));
2679                                 hdr->cmd_status = MFI_STAT_INVALID_STATUS;
2680                                 complete_cmd_in_sync_mode(instance, cmd);
2681                                 }
2682                         }
2683                         mlist_del_init(&cmd->list);
2684                 } else {
2685                         con_log(CL_ANN1, (CE_CONT,
2686                             "mrsas_complete_pending_cmds:"
2687                             "NULL command\n"));
2688                 }
2689                 con_log(CL_ANN1, (CE_CONT,
2690                     "mrsas_complete_pending_cmds:"
2691                     "looping for more commands\n"));
2692         }
2693         mutex_exit(&instance->cmd_pend_mtx);
2694 
2695         con_log(CL_ANN1, (CE_CONT, "mrsas_complete_pending_cmds(): DONE\n"));
2696         return (DDI_SUCCESS);
2697 }
2698 
2699 void
2700 mrsas_print_cmd_details(struct mrsas_instance *instance, struct mrsas_cmd *cmd,
2701     int detail)
2702 {
2703         struct scsi_pkt *pkt = cmd->pkt;
2704         Mpi2RaidSCSIIORequest_t *scsi_io = cmd->scsi_io_request;
2705         int i;
2706         int saved_level;
2707         ddi_acc_handle_t acc_handle =
2708             instance->mpi2_frame_pool_dma_obj.acc_handle;
2709 
2710         if (detail == 0xDD) {
2711                 saved_level = debug_level_g;
2712                 debug_level_g = CL_ANN1;
2713         }
2714 
2715 
2716         if (instance->tbolt) {
2717                 con_log(CL_ANN1, (CE_CONT, "print_cmd_details: cmd %p "
2718                     "cmd->index 0x%x SMID 0x%x timer 0x%x sec\n",
2719                     (void *)cmd, cmd->index, cmd->SMID, cmd->drv_pkt_time));
2720         } else {
2721                 con_log(CL_ANN1, (CE_CONT, "print_cmd_details: cmd %p "
2722                     "cmd->index 0x%x timer 0x%x sec\n",
2723                     (void *)cmd, cmd->index, cmd->drv_pkt_time));
2724         }
2725 
2726         if (pkt) {
2727                 con_log(CL_ANN1, (CE_CONT, "scsi_pkt CDB[0]=0x%x",
2728                     pkt->pkt_cdbp[0]));
2729         } else {
2730                 con_log(CL_ANN1, (CE_CONT, "NO-PKT"));
2731         }
2732 
2733         if ((detail == 0xDD) && instance->tbolt) {
2734                 con_log(CL_ANN1, (CE_CONT, "RAID_SCSI_IO_REQUEST\n"));
2735                 con_log(CL_ANN1, (CE_CONT, "DevHandle=0x%X Function=0x%X "
2736                     "IoFlags=0x%X SGLFlags=0x%X DataLength=0x%X\n",
2737                     ddi_get16(acc_handle, &scsi_io->DevHandle),
2738                     ddi_get8(acc_handle, &scsi_io->Function),
2739                     ddi_get16(acc_handle, &scsi_io->IoFlags),
2740                     ddi_get16(acc_handle, &scsi_io->SGLFlags),
2741                     ddi_get32(acc_handle, &scsi_io->DataLength)));
2742 
2743                 for (i = 0; i < 32; i++) {
2744                         con_log(CL_ANN1, (CE_CONT, "CDB[%d]=0x%x ", i,
2745                             ddi_get8(acc_handle, &scsi_io->CDB.CDB32[i])));
2746                 }
2747 
2748                 con_log(CL_ANN1, (CE_CONT, "RAID-CONTEXT\n"));
2749                 con_log(CL_ANN1, (CE_CONT, "status=0x%X extStatus=0x%X "
2750                     "ldTargetId=0x%X timeoutValue=0x%X regLockFlags=0x%X "
2751                     "RAIDFlags=0x%X regLockRowLBA=0x%" PRIu64
2752                     " regLockLength=0x%X spanArm=0x%X\n",
2753                     ddi_get8(acc_handle, &scsi_io->RaidContext.status),
2754                     ddi_get8(acc_handle, &scsi_io->RaidContext.extStatus),
2755                     ddi_get16(acc_handle, &scsi_io->RaidContext.ldTargetId),
2756                     ddi_get16(acc_handle, &scsi_io->RaidContext.timeoutValue),
2757                     ddi_get8(acc_handle, &scsi_io->RaidContext.regLockFlags),
2758                     ddi_get8(acc_handle, &scsi_io->RaidContext.RAIDFlags),
2759                     ddi_get64(acc_handle, &scsi_io->RaidContext.regLockRowLBA),
2760                     ddi_get32(acc_handle, &scsi_io->RaidContext.regLockLength),
2761                     ddi_get8(acc_handle, &scsi_io->RaidContext.spanArm)));
2762         }
2763 
2764         if (detail == 0xDD) {
2765                 debug_level_g = saved_level;
2766         }
2767 }
2768 
2769 
2770 int
2771 mrsas_issue_pending_cmds(struct mrsas_instance *instance)
2772 {
2773         mlist_t *head   =       &instance->cmd_pend_list;
2774         mlist_t *tmp    =       head->next;
2775         struct mrsas_cmd *cmd = NULL;
2776         struct scsi_pkt *pkt;
2777 
2778         con_log(CL_ANN1, (CE_NOTE, "mrsas_issue_pending_cmds(): Called"));
2779         while (tmp != head) {
2780                 mutex_enter(&instance->cmd_pend_mtx);
2781                 cmd = mlist_entry(tmp, struct mrsas_cmd, list);
2782                 tmp = tmp->next;
2783                 mutex_exit(&instance->cmd_pend_mtx);
2784                 if (cmd) {
2785                         con_log(CL_ANN1, (CE_CONT,
2786                             "mrsas_issue_pending_cmds(): "
2787                             "Got a cmd: cmd %p index 0x%x drv_pkt_time 0x%x ",
2788                             (void *)cmd, cmd->index, cmd->drv_pkt_time));
2789 
2790                         /* Reset command timeout value */
2791                         if (cmd->drv_pkt_time < debug_timeout_g)
2792                                 cmd->drv_pkt_time = (uint16_t)debug_timeout_g;
2793 
2794                         cmd->retry_count_for_ocr++;
2795 
2796                         dev_err(instance->dip, CE_CONT,
2797                             "cmd retry count = %d\n",
2798                             cmd->retry_count_for_ocr);
2799 
2800                         if (cmd->retry_count_for_ocr > IO_RETRY_COUNT) {
2801                                 dev_err(instance->dip,
2802                                     CE_WARN, "mrsas_issue_pending_cmds(): "
2803                                     "cmd->retry_count exceeded limit >%d\n",
2804                                     IO_RETRY_COUNT);
2805                                 mrsas_print_cmd_details(instance, cmd, 0xDD);
2806 
2807                                 dev_err(instance->dip, CE_WARN,
2808                                     "mrsas_issue_pending_cmds():"
2809                                     "Calling KILL Adapter");
2810                                 if (instance->tbolt)
2811                                         mrsas_tbolt_kill_adapter(instance);
2812                                 else
2813                                         (void) mrsas_kill_adapter(instance);
2814                                 return (DDI_FAILURE);
2815                         }
2816 
2817                         pkt = cmd->pkt;
2818                         if (pkt) {
2819                                 con_log(CL_ANN1, (CE_CONT,
2820                                     "PENDING PKT-CMD ISSUE: cmd %p index %x "
2821                                     "pkt %p time %llx",
2822                                     (void *)cmd, cmd->index,
2823                                     (void *)pkt,
2824                                     gethrtime()));
2825 
2826                         } else {
2827                                 dev_err(instance->dip, CE_CONT,
2828                                     "mrsas_issue_pending_cmds(): NO-PKT, "
2829                                     "cmd %p index 0x%x drv_pkt_time 0x%x",
2830                                     (void *)cmd, cmd->index, cmd->drv_pkt_time);
2831                         }
2832 
2833 
2834                         if (cmd->sync_cmd == MRSAS_TRUE) {
2835                                 dev_err(instance->dip, CE_CONT,
2836                                     "mrsas_issue_pending_cmds(): "
2837                                     "SYNC_CMD == TRUE \n");
2838                                 instance->func_ptr->issue_cmd_in_sync_mode(
2839                                     instance, cmd);
2840                         } else {
2841                                 instance->func_ptr->issue_cmd(cmd, instance);
2842                         }
2843                 } else {
2844                         con_log(CL_ANN1, (CE_CONT,
2845                             "mrsas_issue_pending_cmds: NULL command\n"));
2846                 }
2847                 con_log(CL_ANN1, (CE_CONT,
2848                     "mrsas_issue_pending_cmds:"
2849                     "looping for more commands"));
2850         }
2851         con_log(CL_ANN1, (CE_CONT, "mrsas_issue_pending_cmds(): DONE\n"));
2852         return (DDI_SUCCESS);
2853 }
2854 
2855 
2856 
2857 /*
2858  * destroy_mfi_frame_pool
2859  */
2860 void
2861 destroy_mfi_frame_pool(struct mrsas_instance *instance)
2862 {
2863         int             i;
2864         uint32_t        max_cmd = instance->max_fw_cmds;
2865 
2866         struct mrsas_cmd        *cmd;
2867 
2868         /* return all frames to pool */
2869 
2870         for (i = 0; i < max_cmd; i++) {
2871 
2872                 cmd = instance->cmd_list[i];
2873 
2874                 if (cmd->frame_dma_obj_status == DMA_OBJ_ALLOCATED)
2875                         (void) mrsas_free_dma_obj(instance, cmd->frame_dma_obj);
2876 
2877                 cmd->frame_dma_obj_status  = DMA_OBJ_FREED;
2878         }
2879 
2880 }
2881 
2882 /*
2883  * create_mfi_frame_pool
2884  */
2885 int
2886 create_mfi_frame_pool(struct mrsas_instance *instance)
2887 {
2888         int             i = 0;
2889         int             cookie_cnt;
2890         uint16_t        max_cmd;
2891         uint16_t        sge_sz;
2892         uint32_t        sgl_sz;
2893         uint32_t        tot_frame_size;
2894         struct mrsas_cmd        *cmd;
2895         int                     retval = DDI_SUCCESS;
2896 
2897         max_cmd = instance->max_fw_cmds;
2898         sge_sz  = sizeof (struct mrsas_sge_ieee);
2899         /* calculated the number of 64byte frames required for SGL */
2900         sgl_sz          = sge_sz * instance->max_num_sge;
2901         tot_frame_size  = sgl_sz + MRMFI_FRAME_SIZE + SENSE_LENGTH;
2902 
2903         con_log(CL_DLEVEL3, (CE_NOTE, "create_mfi_frame_pool: "
2904             "sgl_sz %x tot_frame_size %x", sgl_sz, tot_frame_size));
2905 
2906         while (i < max_cmd) {
2907                 cmd = instance->cmd_list[i];
2908 
2909                 cmd->frame_dma_obj.size      = tot_frame_size;
2910                 cmd->frame_dma_obj.dma_attr = mrsas_generic_dma_attr;
2911                 cmd->frame_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
2912                 cmd->frame_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
2913                 cmd->frame_dma_obj.dma_attr.dma_attr_sgllen = 1;
2914                 cmd->frame_dma_obj.dma_attr.dma_attr_align = 64;
2915 
2916                 cookie_cnt = mrsas_alloc_dma_obj(instance, &cmd->frame_dma_obj,
2917                     (uchar_t)DDI_STRUCTURE_LE_ACC);
2918 
2919                 if (cookie_cnt == -1 || cookie_cnt > 1) {
2920                         dev_err(instance->dip, CE_WARN,
2921                             "create_mfi_frame_pool: could not alloc.");
2922                         retval = DDI_FAILURE;
2923                         goto mrsas_undo_frame_pool;
2924                 }
2925 
2926                 bzero(cmd->frame_dma_obj.buffer, tot_frame_size);
2927 
2928                 cmd->frame_dma_obj_status = DMA_OBJ_ALLOCATED;
2929                 cmd->frame = (union mrsas_frame *)cmd->frame_dma_obj.buffer;
2930                 cmd->frame_phys_addr =
2931                     cmd->frame_dma_obj.dma_cookie[0].dmac_address;
2932 
2933                 cmd->sense = (uint8_t *)(((unsigned long)
2934                     cmd->frame_dma_obj.buffer) +
2935                     tot_frame_size - SENSE_LENGTH);
2936                 cmd->sense_phys_addr =
2937                     cmd->frame_dma_obj.dma_cookie[0].dmac_address +
2938                     tot_frame_size - SENSE_LENGTH;
2939 
2940                 if (!cmd->frame || !cmd->sense) {
2941                         dev_err(instance->dip, CE_WARN,
2942                             "pci_pool_alloc failed");
2943                         retval = ENOMEM;
2944                         goto mrsas_undo_frame_pool;
2945                 }
2946 
2947                 ddi_put32(cmd->frame_dma_obj.acc_handle,
2948                     &cmd->frame->io.context, cmd->index);
2949                 i++;
2950 
2951                 con_log(CL_DLEVEL3, (CE_NOTE, "[%x]-%x",
2952                     cmd->index, cmd->frame_phys_addr));
2953         }
2954 
2955         return (DDI_SUCCESS);
2956 
2957 mrsas_undo_frame_pool:
2958         if (i > 0)
2959                 destroy_mfi_frame_pool(instance);
2960 
2961         return (retval);
2962 }
2963 
2964 /*
2965  * free_additional_dma_buffer
2966  */
2967 static void
2968 free_additional_dma_buffer(struct mrsas_instance *instance)
2969 {
2970         if (instance->mfi_internal_dma_obj.status == DMA_OBJ_ALLOCATED) {
2971                 (void) mrsas_free_dma_obj(instance,
2972                     instance->mfi_internal_dma_obj);
2973                 instance->mfi_internal_dma_obj.status = DMA_OBJ_FREED;
2974         }
2975 
2976         if (instance->mfi_evt_detail_obj.status == DMA_OBJ_ALLOCATED) {
2977                 (void) mrsas_free_dma_obj(instance,
2978                     instance->mfi_evt_detail_obj);
2979                 instance->mfi_evt_detail_obj.status = DMA_OBJ_FREED;
2980         }
2981 }
2982 
2983 /*
2984  * alloc_additional_dma_buffer
2985  */
2986 static int
2987 alloc_additional_dma_buffer(struct mrsas_instance *instance)
2988 {
2989         uint32_t        reply_q_sz;
2990         uint32_t        internal_buf_size = PAGESIZE*2;
2991 
2992         /* max cmds plus 1 + producer & consumer */
2993         reply_q_sz = sizeof (uint32_t) * (instance->max_fw_cmds + 1 + 2);
2994 
2995         instance->mfi_internal_dma_obj.size = internal_buf_size;
2996         instance->mfi_internal_dma_obj.dma_attr      = mrsas_generic_dma_attr;
2997         instance->mfi_internal_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
2998         instance->mfi_internal_dma_obj.dma_attr.dma_attr_count_max =
2999             0xFFFFFFFFU;
3000         instance->mfi_internal_dma_obj.dma_attr.dma_attr_sgllen      = 1;
3001 
3002         if (mrsas_alloc_dma_obj(instance, &instance->mfi_internal_dma_obj,
3003             (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
3004                 dev_err(instance->dip, CE_WARN,
3005                     "could not alloc reply queue");
3006                 return (DDI_FAILURE);
3007         }
3008 
3009         bzero(instance->mfi_internal_dma_obj.buffer, internal_buf_size);
3010 
3011         instance->mfi_internal_dma_obj.status |= DMA_OBJ_ALLOCATED;
3012 
3013         instance->producer = (uint32_t *)((unsigned long)
3014             instance->mfi_internal_dma_obj.buffer);
3015         instance->consumer = (uint32_t *)((unsigned long)
3016             instance->mfi_internal_dma_obj.buffer + 4);
3017         instance->reply_queue = (uint32_t *)((unsigned long)
3018             instance->mfi_internal_dma_obj.buffer + 8);
3019         instance->internal_buf = (caddr_t)(((unsigned long)
3020             instance->mfi_internal_dma_obj.buffer) + reply_q_sz + 8);
3021         instance->internal_buf_dmac_add =
3022             instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address +
3023             (reply_q_sz + 8);
3024         instance->internal_buf_size = internal_buf_size -
3025             (reply_q_sz + 8);
3026 
3027         /* allocate evt_detail */
3028         instance->mfi_evt_detail_obj.size = sizeof (struct mrsas_evt_detail);
3029         instance->mfi_evt_detail_obj.dma_attr = mrsas_generic_dma_attr;
3030         instance->mfi_evt_detail_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3031         instance->mfi_evt_detail_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
3032         instance->mfi_evt_detail_obj.dma_attr.dma_attr_sgllen = 1;
3033         instance->mfi_evt_detail_obj.dma_attr.dma_attr_align = 1;
3034 
3035         if (mrsas_alloc_dma_obj(instance, &instance->mfi_evt_detail_obj,
3036             (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
3037                 dev_err(instance->dip, CE_WARN, "alloc_additional_dma_buffer: "
3038                     "could not allocate data transfer buffer.");
3039                 goto mrsas_undo_internal_buff;
3040         }
3041 
3042         bzero(instance->mfi_evt_detail_obj.buffer,
3043             sizeof (struct mrsas_evt_detail));
3044 
3045         instance->mfi_evt_detail_obj.status |= DMA_OBJ_ALLOCATED;
3046 
3047         return (DDI_SUCCESS);
3048 
3049 mrsas_undo_internal_buff:
3050         if (instance->mfi_internal_dma_obj.status == DMA_OBJ_ALLOCATED) {
3051                 (void) mrsas_free_dma_obj(instance,
3052                     instance->mfi_internal_dma_obj);
3053                 instance->mfi_internal_dma_obj.status = DMA_OBJ_FREED;
3054         }
3055 
3056         return (DDI_FAILURE);
3057 }
3058 
3059 
3060 void
3061 mrsas_free_cmd_pool(struct mrsas_instance *instance)
3062 {
3063         int             i;
3064         uint32_t        max_cmd;
3065         size_t          sz;
3066 
3067         /* already freed */
3068         if (instance->cmd_list == NULL) {
3069                 return;
3070         }
3071 
3072         max_cmd = instance->max_fw_cmds;
3073 
3074         /* size of cmd_list array */
3075         sz = sizeof (struct mrsas_cmd *) * max_cmd;
3076 
3077         /* First free each cmd */
3078         for (i = 0; i < max_cmd; i++) {
3079                 if (instance->cmd_list[i] != NULL) {
3080                         kmem_free(instance->cmd_list[i],
3081                             sizeof (struct mrsas_cmd));
3082                 }
3083 
3084                 instance->cmd_list[i] = NULL;
3085         }
3086 
3087         /* Now, free cmd_list array */
3088         if (instance->cmd_list != NULL)
3089                 kmem_free(instance->cmd_list, sz);
3090 
3091         instance->cmd_list = NULL;
3092 
3093         INIT_LIST_HEAD(&instance->cmd_pool_list);
3094         INIT_LIST_HEAD(&instance->cmd_pend_list);
3095         if (instance->tbolt) {
3096                 INIT_LIST_HEAD(&instance->cmd_app_pool_list);
3097         } else {
3098                 INIT_LIST_HEAD(&instance->app_cmd_pool_list);
3099         }
3100 
3101 }
3102 
3103 
3104 /*
3105  * mrsas_alloc_cmd_pool
3106  */
3107 int
3108 mrsas_alloc_cmd_pool(struct mrsas_instance *instance)
3109 {
3110         int             i;
3111         int             count;
3112         uint32_t        max_cmd;
3113         uint32_t        reserve_cmd;
3114         size_t          sz;
3115 
3116         struct mrsas_cmd        *cmd;
3117 
3118         max_cmd = instance->max_fw_cmds;
3119         con_log(CL_ANN1, (CE_NOTE, "mrsas_alloc_cmd_pool: "
3120             "max_cmd %x", max_cmd));
3121 
3122 
3123         sz = sizeof (struct mrsas_cmd *) * max_cmd;
3124 
3125         /*
3126          * instance->cmd_list is an array of struct mrsas_cmd pointers.
3127          * Allocate the dynamic array first and then allocate individual
3128          * commands.
3129          */
3130         instance->cmd_list = kmem_zalloc(sz, KM_SLEEP);
3131         ASSERT(instance->cmd_list);
3132 
3133         /* create a frame pool and assign one frame to each cmd */
3134         for (count = 0; count < max_cmd; count++) {
3135                 instance->cmd_list[count] =
3136                     kmem_zalloc(sizeof (struct mrsas_cmd), KM_SLEEP);
3137                 ASSERT(instance->cmd_list[count]);
3138         }
3139 
3140         /* add all the commands to command pool */
3141 
3142         INIT_LIST_HEAD(&instance->cmd_pool_list);
3143         INIT_LIST_HEAD(&instance->cmd_pend_list);
3144         INIT_LIST_HEAD(&instance->app_cmd_pool_list);
3145 
3146         /*
3147          * When max_cmd is lower than MRSAS_APP_RESERVED_CMDS, how do I split
3148          * into app_cmd and regular cmd?  For now, just take
3149          * max(1/8th of max, 4);
3150          */
3151         reserve_cmd = min(MRSAS_APP_RESERVED_CMDS,
3152             max(max_cmd >> 3, MRSAS_APP_MIN_RESERVED_CMDS));
3153 
3154         for (i = 0; i < reserve_cmd; i++) {
3155                 cmd = instance->cmd_list[i];
3156                 cmd->index = i;
3157                 mlist_add_tail(&cmd->list, &instance->app_cmd_pool_list);
3158         }
3159 
3160 
3161         for (i = reserve_cmd; i < max_cmd; i++) {
3162                 cmd = instance->cmd_list[i];
3163                 cmd->index = i;
3164                 mlist_add_tail(&cmd->list, &instance->cmd_pool_list);
3165         }
3166 
3167         return (DDI_SUCCESS);
3168 
3169 mrsas_undo_cmds:
3170         if (count > 0) {
3171                 /* free each cmd */
3172                 for (i = 0; i < count; i++) {
3173                         if (instance->cmd_list[i] != NULL) {
3174                                 kmem_free(instance->cmd_list[i],
3175                                     sizeof (struct mrsas_cmd));
3176                         }
3177                         instance->cmd_list[i] = NULL;
3178                 }
3179         }
3180 
3181 mrsas_undo_cmd_list:
3182         if (instance->cmd_list != NULL)
3183                 kmem_free(instance->cmd_list, sz);
3184         instance->cmd_list = NULL;
3185 
3186         return (DDI_FAILURE);
3187 }
3188 
3189 
3190 /*
3191  * free_space_for_mfi
3192  */
3193 static void
3194 free_space_for_mfi(struct mrsas_instance *instance)
3195 {
3196 
3197         /* already freed */
3198         if (instance->cmd_list == NULL) {
3199                 return;
3200         }
3201 
3202         /* Free additional dma buffer */
3203         free_additional_dma_buffer(instance);
3204 
3205         /* Free the MFI frame pool */
3206         destroy_mfi_frame_pool(instance);
3207 
3208         /* Free all the commands in the cmd_list */
3209         /* Free the cmd_list buffer itself */
3210         mrsas_free_cmd_pool(instance);
3211 }
3212 
3213 /*
3214  * alloc_space_for_mfi
3215  */
3216 static int
3217 alloc_space_for_mfi(struct mrsas_instance *instance)
3218 {
3219         /* Allocate command pool (memory for cmd_list & individual commands) */
3220         if (mrsas_alloc_cmd_pool(instance)) {
3221                 dev_err(instance->dip, CE_WARN, "error creating cmd pool");
3222                 return (DDI_FAILURE);
3223         }
3224 
3225         /* Allocate MFI Frame pool */
3226         if (create_mfi_frame_pool(instance)) {
3227                 dev_err(instance->dip, CE_WARN,
3228                     "error creating frame DMA pool");
3229                 goto mfi_undo_cmd_pool;
3230         }
3231 
3232         /* Allocate additional DMA buffer */
3233         if (alloc_additional_dma_buffer(instance)) {
3234                 dev_err(instance->dip, CE_WARN,
3235                     "error creating frame DMA pool");
3236                 goto mfi_undo_frame_pool;
3237         }
3238 
3239         return (DDI_SUCCESS);
3240 
3241 mfi_undo_frame_pool:
3242         destroy_mfi_frame_pool(instance);
3243 
3244 mfi_undo_cmd_pool:
3245         mrsas_free_cmd_pool(instance);
3246 
3247         return (DDI_FAILURE);
3248 }
3249 
3250 
3251 
3252 /*
3253  * get_ctrl_info
3254  */
3255 static int
3256 get_ctrl_info(struct mrsas_instance *instance,
3257     struct mrsas_ctrl_info *ctrl_info)
3258 {
3259         int     ret = 0;
3260 
3261         struct mrsas_cmd                *cmd;
3262         struct mrsas_dcmd_frame *dcmd;
3263         struct mrsas_ctrl_info  *ci;
3264 
3265         if (instance->tbolt) {
3266                 cmd = get_raid_msg_mfi_pkt(instance);
3267         } else {
3268                 cmd = mrsas_get_mfi_pkt(instance);
3269         }
3270 
3271         if (!cmd) {
3272                 con_log(CL_ANN, (CE_WARN,
3273                     "Failed to get a cmd for ctrl info"));
3274                 DTRACE_PROBE2(info_mfi_err, uint16_t, instance->fw_outstanding,
3275                     uint16_t, instance->max_fw_cmds);
3276                 return (DDI_FAILURE);
3277         }
3278 
3279         /* Clear the frame buffer and assign back the context id */
3280         (void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
3281         ddi_put32(cmd->frame_dma_obj.acc_handle, &cmd->frame->hdr.context,
3282             cmd->index);
3283 
3284         dcmd = &cmd->frame->dcmd;
3285 
3286         ci = (struct mrsas_ctrl_info *)instance->internal_buf;
3287 
3288         if (!ci) {
3289                 dev_err(instance->dip, CE_WARN,
3290                     "Failed to alloc mem for ctrl info");
3291                 mrsas_return_mfi_pkt(instance, cmd);
3292                 return (DDI_FAILURE);
3293         }
3294 
3295         (void) memset(ci, 0, sizeof (struct mrsas_ctrl_info));
3296 
3297         /* for( i = 0; i < DCMD_MBOX_SZ; i++ ) dcmd->mbox.b[i] = 0; */
3298         (void) memset(dcmd->mbox.b, 0, DCMD_MBOX_SZ);
3299 
3300         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->cmd, MFI_CMD_OP_DCMD);
3301         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->cmd_status,
3302             MFI_CMD_STATUS_POLL_MODE);
3303         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->sge_count, 1);
3304         ddi_put16(cmd->frame_dma_obj.acc_handle, &dcmd->flags,
3305             MFI_FRAME_DIR_READ);
3306         ddi_put16(cmd->frame_dma_obj.acc_handle, &dcmd->timeout, 0);
3307         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->data_xfer_len,
3308             sizeof (struct mrsas_ctrl_info));
3309         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->opcode,
3310             MR_DCMD_CTRL_GET_INFO);
3311         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->sgl.sge32[0].phys_addr,
3312             instance->internal_buf_dmac_add);
3313         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->sgl.sge32[0].length,
3314             sizeof (struct mrsas_ctrl_info));
3315 
3316         cmd->frame_count = 1;
3317 
3318         if (instance->tbolt) {
3319                 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
3320         }
3321 
3322         if (!instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
3323                 ret = 0;
3324 
3325                 ctrl_info->max_request_size = ddi_get32(
3326                     cmd->frame_dma_obj.acc_handle, &ci->max_request_size);
3327 
3328                 ctrl_info->ld_present_count = ddi_get16(
3329                     cmd->frame_dma_obj.acc_handle, &ci->ld_present_count);
3330 
3331                 ctrl_info->properties.on_off_properties = ddi_get32(
3332                     cmd->frame_dma_obj.acc_handle,
3333                     &ci->properties.on_off_properties);
3334                 ddi_rep_get8(cmd->frame_dma_obj.acc_handle,
3335                     (uint8_t *)(ctrl_info->product_name),
3336                     (uint8_t *)(ci->product_name), 80 * sizeof (char),
3337                     DDI_DEV_AUTOINCR);
3338                 /* should get more members of ci with ddi_get when needed */
3339         } else {
3340                 dev_err(instance->dip, CE_WARN,
3341                     "get_ctrl_info: Ctrl info failed");
3342                 ret = -1;
3343         }
3344 
3345         if (mrsas_common_check(instance, cmd) != DDI_SUCCESS) {
3346                 ret = -1;
3347         }
3348         if (instance->tbolt) {
3349                 return_raid_msg_mfi_pkt(instance, cmd);
3350         } else {
3351                 mrsas_return_mfi_pkt(instance, cmd);
3352         }
3353 
3354         return (ret);
3355 }
3356 
3357 /*
3358  * abort_aen_cmd
3359  */
3360 static int
3361 abort_aen_cmd(struct mrsas_instance *instance,
3362     struct mrsas_cmd *cmd_to_abort)
3363 {
3364         int     ret = 0;
3365 
3366         struct mrsas_cmd                *cmd;
3367         struct mrsas_abort_frame        *abort_fr;
3368 
3369         con_log(CL_ANN1, (CE_NOTE, "chkpnt: abort_aen:%d", __LINE__));
3370 
3371         if (instance->tbolt) {
3372                 cmd = get_raid_msg_mfi_pkt(instance);
3373         } else {
3374                 cmd = mrsas_get_mfi_pkt(instance);
3375         }
3376 
3377         if (!cmd) {
3378                 con_log(CL_ANN1, (CE_WARN,
3379                     "abort_aen_cmd():Failed to get a cmd for abort_aen_cmd"));
3380                 DTRACE_PROBE2(abort_mfi_err, uint16_t, instance->fw_outstanding,
3381                     uint16_t, instance->max_fw_cmds);
3382                 return (DDI_FAILURE);
3383         }
3384 
3385         /* Clear the frame buffer and assign back the context id */
3386         (void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
3387         ddi_put32(cmd->frame_dma_obj.acc_handle, &cmd->frame->hdr.context,
3388             cmd->index);
3389 
3390         abort_fr = &cmd->frame->abort;
3391 
3392         /* prepare and issue the abort frame */
3393         ddi_put8(cmd->frame_dma_obj.acc_handle,
3394             &abort_fr->cmd, MFI_CMD_OP_ABORT);
3395         ddi_put8(cmd->frame_dma_obj.acc_handle, &abort_fr->cmd_status,
3396             MFI_CMD_STATUS_SYNC_MODE);
3397         ddi_put16(cmd->frame_dma_obj.acc_handle, &abort_fr->flags, 0);
3398         ddi_put32(cmd->frame_dma_obj.acc_handle, &abort_fr->abort_context,
3399             cmd_to_abort->index);
3400         ddi_put32(cmd->frame_dma_obj.acc_handle,
3401             &abort_fr->abort_mfi_phys_addr_lo, cmd_to_abort->frame_phys_addr);
3402         ddi_put32(cmd->frame_dma_obj.acc_handle,
3403             &abort_fr->abort_mfi_phys_addr_hi, 0);
3404 
3405         instance->aen_cmd->abort_aen = 1;
3406 
3407         cmd->frame_count = 1;
3408 
3409         if (instance->tbolt) {
3410                 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
3411         }
3412 
3413         if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
3414                 con_log(CL_ANN1, (CE_WARN,
3415                     "abort_aen_cmd: issue_cmd_in_poll_mode failed"));
3416                 ret = -1;
3417         } else {
3418                 ret = 0;
3419         }
3420 
3421         instance->aen_cmd->abort_aen = 1;
3422         instance->aen_cmd = 0;
3423 
3424         if (instance->tbolt) {
3425                 return_raid_msg_mfi_pkt(instance, cmd);
3426         } else {
3427                 mrsas_return_mfi_pkt(instance, cmd);
3428         }
3429 
3430         atomic_add_16(&instance->fw_outstanding, (-1));
3431 
3432         return (ret);
3433 }
3434 
3435 
3436 static int
3437 mrsas_build_init_cmd(struct mrsas_instance *instance,
3438     struct mrsas_cmd **cmd_ptr)
3439 {
3440         struct mrsas_cmd                *cmd;
3441         struct mrsas_init_frame         *init_frame;
3442         struct mrsas_init_queue_info    *initq_info;
3443         struct mrsas_drv_ver            drv_ver_info;
3444 
3445 
3446         /*
3447          * Prepare a init frame. Note the init frame points to queue info
3448          * structure. Each frame has SGL allocated after first 64 bytes. For
3449          * this frame - since we don't need any SGL - we use SGL's space as
3450          * queue info structure
3451          */
3452         cmd = *cmd_ptr;
3453 
3454 
3455         /* Clear the frame buffer and assign back the context id */
3456         (void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
3457         ddi_put32(cmd->frame_dma_obj.acc_handle, &cmd->frame->hdr.context,
3458             cmd->index);
3459 
3460         init_frame = (struct mrsas_init_frame *)cmd->frame;
3461         initq_info = (struct mrsas_init_queue_info *)
3462             ((unsigned long)init_frame + 64);
3463 
3464         (void) memset(init_frame, 0, MRMFI_FRAME_SIZE);
3465         (void) memset(initq_info, 0, sizeof (struct mrsas_init_queue_info));
3466 
3467         ddi_put32(cmd->frame_dma_obj.acc_handle, &initq_info->init_flags, 0);
3468 
3469         ddi_put32(cmd->frame_dma_obj.acc_handle,
3470             &initq_info->reply_queue_entries, instance->max_fw_cmds + 1);
3471 
3472         ddi_put32(cmd->frame_dma_obj.acc_handle,
3473             &initq_info->producer_index_phys_addr_hi, 0);
3474         ddi_put32(cmd->frame_dma_obj.acc_handle,
3475             &initq_info->producer_index_phys_addr_lo,
3476             instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address);
3477 
3478         ddi_put32(cmd->frame_dma_obj.acc_handle,
3479             &initq_info->consumer_index_phys_addr_hi, 0);
3480         ddi_put32(cmd->frame_dma_obj.acc_handle,
3481             &initq_info->consumer_index_phys_addr_lo,
3482             instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 4);
3483 
3484         ddi_put32(cmd->frame_dma_obj.acc_handle,
3485             &initq_info->reply_queue_start_phys_addr_hi, 0);
3486         ddi_put32(cmd->frame_dma_obj.acc_handle,
3487             &initq_info->reply_queue_start_phys_addr_lo,
3488             instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 8);
3489 
3490         ddi_put8(cmd->frame_dma_obj.acc_handle,
3491             &init_frame->cmd, MFI_CMD_OP_INIT);
3492         ddi_put8(cmd->frame_dma_obj.acc_handle, &init_frame->cmd_status,
3493             MFI_CMD_STATUS_POLL_MODE);
3494         ddi_put16(cmd->frame_dma_obj.acc_handle, &init_frame->flags, 0);
3495         ddi_put32(cmd->frame_dma_obj.acc_handle,
3496             &init_frame->queue_info_new_phys_addr_lo,
3497             cmd->frame_phys_addr + 64);
3498         ddi_put32(cmd->frame_dma_obj.acc_handle,
3499             &init_frame->queue_info_new_phys_addr_hi, 0);
3500 
3501 
3502         /* fill driver version information */
3503         fill_up_drv_ver(&drv_ver_info);
3504 
3505         /* allocate the driver version data transfer buffer */
3506         instance->drv_ver_dma_obj.size = sizeof (drv_ver_info.drv_ver);
3507         instance->drv_ver_dma_obj.dma_attr = mrsas_generic_dma_attr;
3508         instance->drv_ver_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3509         instance->drv_ver_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
3510         instance->drv_ver_dma_obj.dma_attr.dma_attr_sgllen = 1;
3511         instance->drv_ver_dma_obj.dma_attr.dma_attr_align = 1;
3512 
3513         if (mrsas_alloc_dma_obj(instance, &instance->drv_ver_dma_obj,
3514             (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
3515                 con_log(CL_ANN, (CE_WARN,
3516                     "init_mfi : Could not allocate driver version buffer."));
3517                 return (DDI_FAILURE);
3518         }
3519         /* copy driver version to dma buffer */
3520         (void) memset(instance->drv_ver_dma_obj.buffer, 0,
3521             sizeof (drv_ver_info.drv_ver));
3522         ddi_rep_put8(cmd->frame_dma_obj.acc_handle,
3523             (uint8_t *)drv_ver_info.drv_ver,
3524             (uint8_t *)instance->drv_ver_dma_obj.buffer,
3525             sizeof (drv_ver_info.drv_ver), DDI_DEV_AUTOINCR);
3526 
3527 
3528         /* copy driver version physical address to init frame */
3529         ddi_put64(cmd->frame_dma_obj.acc_handle, &init_frame->driverversion,
3530             instance->drv_ver_dma_obj.dma_cookie[0].dmac_address);
3531 
3532         ddi_put32(cmd->frame_dma_obj.acc_handle, &init_frame->data_xfer_len,
3533             sizeof (struct mrsas_init_queue_info));
3534 
3535         cmd->frame_count = 1;
3536 
3537         *cmd_ptr = cmd;
3538 
3539         return (DDI_SUCCESS);
3540 }
3541 
3542 
3543 /*
3544  * mrsas_init_adapter_ppc - Initialize MFI interface adapter.
3545  */
3546 int
3547 mrsas_init_adapter_ppc(struct mrsas_instance *instance)
3548 {
3549         struct mrsas_cmd                *cmd;
3550 
3551         /*
3552          * allocate memory for mfi adapter(cmd pool, individual commands, mfi
3553          * frames etc
3554          */
3555         if (alloc_space_for_mfi(instance) != DDI_SUCCESS) {
3556                 con_log(CL_ANN, (CE_NOTE,
3557                     "Error, failed to allocate memory for MFI adapter"));
3558                 return (DDI_FAILURE);
3559         }
3560 
3561         /* Build INIT command */
3562         cmd = mrsas_get_mfi_pkt(instance);
3563         if (cmd == NULL) {
3564                 DTRACE_PROBE2(init_adapter_mfi_err, uint16_t,
3565                     instance->fw_outstanding, uint16_t, instance->max_fw_cmds);
3566                 return (DDI_FAILURE);
3567         }
3568 
3569         if (mrsas_build_init_cmd(instance, &cmd) != DDI_SUCCESS) {
3570                 con_log(CL_ANN,
3571                     (CE_NOTE, "Error, failed to build INIT command"));
3572 
3573                 goto fail_undo_alloc_mfi_space;
3574         }
3575 
3576         /*
3577          * Disable interrupt before sending init frame ( see linux driver code)
3578          * send INIT MFI frame in polled mode
3579          */
3580         if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
3581                 con_log(CL_ANN, (CE_WARN, "failed to init firmware"));
3582                 goto fail_fw_init;
3583         }
3584 
3585         if (mrsas_common_check(instance, cmd) != DDI_SUCCESS)
3586                 goto fail_fw_init;
3587         mrsas_return_mfi_pkt(instance, cmd);
3588 
3589         if (ctio_enable &&
3590             (instance->func_ptr->read_fw_status_reg(instance) & 0x04000000)) {
3591                 con_log(CL_ANN, (CE_NOTE, "mr_sas: IEEE SGL's supported"));
3592                 instance->flag_ieee = 1;
3593         } else {
3594                 instance->flag_ieee = 0;
3595         }
3596 
3597         ASSERT(!instance->skinny || instance->flag_ieee);
3598 
3599         instance->unroll.alloc_space_mfi = 1;
3600         instance->unroll.verBuff = 1;
3601 
3602         return (DDI_SUCCESS);
3603 
3604 
3605 fail_fw_init:
3606         (void) mrsas_free_dma_obj(instance, instance->drv_ver_dma_obj);
3607 
3608 fail_undo_alloc_mfi_space:
3609         mrsas_return_mfi_pkt(instance, cmd);
3610         free_space_for_mfi(instance);
3611 
3612         return (DDI_FAILURE);
3613 
3614 }
3615 
3616 /*
3617  * mrsas_init_adapter - Initialize adapter.
3618  */
3619 int
3620 mrsas_init_adapter(struct mrsas_instance *instance)
3621 {
3622         struct mrsas_ctrl_info          ctrl_info;
3623 
3624 
3625         /* we expect the FW state to be READY */
3626         if (mfi_state_transition_to_ready(instance)) {
3627                 con_log(CL_ANN, (CE_WARN, "mr_sas: F/W is not ready"));
3628                 return (DDI_FAILURE);
3629         }
3630 
3631         /* get various operational parameters from status register */
3632         instance->max_num_sge =
3633             (instance->func_ptr->read_fw_status_reg(instance) &
3634             0xFF0000) >> 0x10;
3635         instance->max_num_sge =
3636             (instance->max_num_sge > MRSAS_MAX_SGE_CNT) ?
3637             MRSAS_MAX_SGE_CNT : instance->max_num_sge;
3638 
3639         /*
3640          * Reduce the max supported cmds by 1. This is to ensure that the
3641          * reply_q_sz (1 more than the max cmd that driver may send)
3642          * does not exceed max cmds that the FW can support
3643          */
3644         instance->max_fw_cmds =
3645             instance->func_ptr->read_fw_status_reg(instance) & 0xFFFF;
3646         instance->max_fw_cmds = instance->max_fw_cmds - 1;
3647 
3648 
3649 
3650         /* Initialize adapter */
3651         if (instance->func_ptr->init_adapter(instance) != DDI_SUCCESS) {
3652                 con_log(CL_ANN,
3653                     (CE_WARN, "mr_sas: could not initialize adapter"));
3654                 return (DDI_FAILURE);
3655         }
3656 
3657         /* gather misc FW related information */
3658         instance->disable_online_ctrl_reset = 0;
3659 
3660         if (!get_ctrl_info(instance, &ctrl_info)) {
3661                 instance->max_sectors_per_req = ctrl_info.max_request_size;
3662                 con_log(CL_ANN1, (CE_NOTE,
3663                     "product name %s ld present %d",
3664                     ctrl_info.product_name, ctrl_info.ld_present_count));
3665         } else {
3666                 instance->max_sectors_per_req = instance->max_num_sge *
3667                     PAGESIZE / 512;
3668         }
3669 
3670         if (ctrl_info.properties.on_off_properties & DISABLE_OCR_PROP_FLAG)
3671                 instance->disable_online_ctrl_reset = 1;
3672 
3673         return (DDI_SUCCESS);
3674 
3675 }
3676 
3677 
3678 
3679 static int
3680 mrsas_issue_init_mfi(struct mrsas_instance *instance)
3681 {
3682         struct mrsas_cmd                *cmd;
3683         struct mrsas_init_frame         *init_frame;
3684         struct mrsas_init_queue_info    *initq_info;
3685 
3686 /*
3687  * Prepare a init frame. Note the init frame points to queue info
3688  * structure. Each frame has SGL allocated after first 64 bytes. For
3689  * this frame - since we don't need any SGL - we use SGL's space as
3690  * queue info structure
3691  */
3692         con_log(CL_ANN1, (CE_NOTE,
3693             "mrsas_issue_init_mfi: entry\n"));
3694         cmd = get_mfi_app_pkt(instance);
3695 
3696         if (!cmd) {
3697                 con_log(CL_ANN1, (CE_WARN,
3698                     "mrsas_issue_init_mfi: get_pkt failed\n"));
3699                 return (DDI_FAILURE);
3700         }
3701 
3702         /* Clear the frame buffer and assign back the context id */
3703         (void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
3704         ddi_put32(cmd->frame_dma_obj.acc_handle, &cmd->frame->hdr.context,
3705             cmd->index);
3706 
3707         init_frame = (struct mrsas_init_frame *)cmd->frame;
3708         initq_info = (struct mrsas_init_queue_info *)
3709             ((unsigned long)init_frame + 64);
3710 
3711         (void) memset(init_frame, 0, MRMFI_FRAME_SIZE);
3712         (void) memset(initq_info, 0, sizeof (struct mrsas_init_queue_info));
3713 
3714         ddi_put32(cmd->frame_dma_obj.acc_handle, &initq_info->init_flags, 0);
3715 
3716         ddi_put32(cmd->frame_dma_obj.acc_handle,
3717             &initq_info->reply_queue_entries, instance->max_fw_cmds + 1);
3718         ddi_put32(cmd->frame_dma_obj.acc_handle,
3719             &initq_info->producer_index_phys_addr_hi, 0);
3720         ddi_put32(cmd->frame_dma_obj.acc_handle,
3721             &initq_info->producer_index_phys_addr_lo,
3722             instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address);
3723         ddi_put32(cmd->frame_dma_obj.acc_handle,
3724             &initq_info->consumer_index_phys_addr_hi, 0);
3725         ddi_put32(cmd->frame_dma_obj.acc_handle,
3726             &initq_info->consumer_index_phys_addr_lo,
3727             instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 4);
3728 
3729         ddi_put32(cmd->frame_dma_obj.acc_handle,
3730             &initq_info->reply_queue_start_phys_addr_hi, 0);
3731         ddi_put32(cmd->frame_dma_obj.acc_handle,
3732             &initq_info->reply_queue_start_phys_addr_lo,
3733             instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 8);
3734 
3735         ddi_put8(cmd->frame_dma_obj.acc_handle,
3736             &init_frame->cmd, MFI_CMD_OP_INIT);
3737         ddi_put8(cmd->frame_dma_obj.acc_handle, &init_frame->cmd_status,
3738             MFI_CMD_STATUS_POLL_MODE);
3739         ddi_put16(cmd->frame_dma_obj.acc_handle, &init_frame->flags, 0);
3740         ddi_put32(cmd->frame_dma_obj.acc_handle,
3741             &init_frame->queue_info_new_phys_addr_lo,
3742             cmd->frame_phys_addr + 64);
3743         ddi_put32(cmd->frame_dma_obj.acc_handle,
3744             &init_frame->queue_info_new_phys_addr_hi, 0);
3745 
3746         ddi_put32(cmd->frame_dma_obj.acc_handle, &init_frame->data_xfer_len,
3747             sizeof (struct mrsas_init_queue_info));
3748 
3749         cmd->frame_count = 1;
3750 
3751         /* issue the init frame in polled mode */
3752         if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
3753                 con_log(CL_ANN1, (CE_WARN,
3754                     "mrsas_issue_init_mfi():failed to "
3755                     "init firmware"));
3756                 return_mfi_app_pkt(instance, cmd);
3757                 return (DDI_FAILURE);
3758         }
3759 
3760         if (mrsas_common_check(instance, cmd) != DDI_SUCCESS) {
3761                 return_mfi_app_pkt(instance, cmd);
3762                 return (DDI_FAILURE);
3763         }
3764 
3765         return_mfi_app_pkt(instance, cmd);
3766         con_log(CL_ANN1, (CE_CONT, "mrsas_issue_init_mfi: Done"));
3767 
3768         return (DDI_SUCCESS);
3769 }
3770 /*
3771  * mfi_state_transition_to_ready        : Move the FW to READY state
3772  *
3773  * @reg_set                     : MFI register set
3774  */
3775 int
3776 mfi_state_transition_to_ready(struct mrsas_instance *instance)
3777 {
3778         int             i;
3779         uint8_t         max_wait;
3780         uint32_t        fw_ctrl = 0;
3781         uint32_t        fw_state;
3782         uint32_t        cur_state;
3783         uint32_t        cur_abs_reg_val;
3784         uint32_t        prev_abs_reg_val;
3785         uint32_t        status;
3786 
3787         cur_abs_reg_val =
3788             instance->func_ptr->read_fw_status_reg(instance);
3789         fw_state =
3790             cur_abs_reg_val & MFI_STATE_MASK;
3791         con_log(CL_ANN1, (CE_CONT,
3792             "mfi_state_transition_to_ready:FW state = 0x%x", fw_state));
3793 
3794         while (fw_state != MFI_STATE_READY) {
3795                 con_log(CL_ANN, (CE_CONT,
3796                     "mfi_state_transition_to_ready:FW state%x", fw_state));
3797 
3798                 switch (fw_state) {
3799                 case MFI_STATE_FAULT:
3800                         con_log(CL_ANN, (CE_NOTE,
3801                             "mr_sas: FW in FAULT state!!"));
3802 
3803                         return (ENODEV);
3804                 case MFI_STATE_WAIT_HANDSHAKE:
3805                         /* set the CLR bit in IMR0 */
3806                         con_log(CL_ANN1, (CE_NOTE,
3807                             "mr_sas: FW waiting for HANDSHAKE"));
3808                         /*
3809                          * PCI_Hot Plug: MFI F/W requires
3810                          * (MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG)
3811                          * to be set
3812                          */
3813                         /* WR_IB_MSG_0(MFI_INIT_CLEAR_HANDSHAKE, instance); */
3814                         if (!instance->tbolt && !instance->skinny) {
3815                                 WR_IB_DOORBELL(MFI_INIT_CLEAR_HANDSHAKE |
3816                                     MFI_INIT_HOTPLUG, instance);
3817                         } else {
3818                                 WR_RESERVED0_REGISTER(MFI_INIT_CLEAR_HANDSHAKE |
3819                                     MFI_INIT_HOTPLUG, instance);
3820                         }
3821                         max_wait        = (instance->tbolt == 1) ? 180 : 2;
3822                         cur_state       = MFI_STATE_WAIT_HANDSHAKE;
3823                         break;
3824                 case MFI_STATE_BOOT_MESSAGE_PENDING:
3825                         /* set the CLR bit in IMR0 */
3826                         con_log(CL_ANN1, (CE_NOTE,
3827                             "mr_sas: FW state boot message pending"));
3828                         /*
3829                          * PCI_Hot Plug: MFI F/W requires
3830                          * (MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG)
3831                          * to be set
3832                          */
3833                         if (!instance->tbolt && !instance->skinny) {
3834                                 WR_IB_DOORBELL(MFI_INIT_HOTPLUG, instance);
3835                         } else {
3836                                 WR_RESERVED0_REGISTER(MFI_INIT_HOTPLUG,
3837                                     instance);
3838                         }
3839                         max_wait        = (instance->tbolt == 1) ? 180 : 10;
3840                         cur_state       = MFI_STATE_BOOT_MESSAGE_PENDING;
3841                         break;
3842                 case MFI_STATE_OPERATIONAL:
3843                         /* bring it to READY state; assuming max wait 2 secs */
3844                         instance->func_ptr->disable_intr(instance);
3845                         con_log(CL_ANN1, (CE_NOTE,
3846                             "mr_sas: FW in OPERATIONAL state"));
3847                         /*
3848                          * PCI_Hot Plug: MFI F/W requires
3849                          * (MFI_INIT_READY | MFI_INIT_MFIMODE | MFI_INIT_ABORT)
3850                          * to be set
3851                          */
3852                         /* WR_IB_DOORBELL(MFI_INIT_READY, instance); */
3853                         if (!instance->tbolt && !instance->skinny) {
3854                                 WR_IB_DOORBELL(MFI_RESET_FLAGS, instance);
3855                         } else {
3856                                 WR_RESERVED0_REGISTER(MFI_RESET_FLAGS,
3857                                     instance);
3858 
3859                                 for (i = 0; i < (10 * 1000); i++) {
3860                                         status =
3861                                             RD_RESERVED0_REGISTER(instance);
3862                                         if (status & 1) {
3863                                                 delay(1 *
3864                                                     drv_usectohz(MILLISEC));
3865                                         } else {
3866                                                 break;
3867                                         }
3868                                 }
3869 
3870                         }
3871                         max_wait        = (instance->tbolt == 1) ? 180 : 10;
3872                         cur_state       = MFI_STATE_OPERATIONAL;
3873                         break;
3874                 case MFI_STATE_UNDEFINED:
3875                         /* this state should not last for more than 2 seconds */
3876                         con_log(CL_ANN1, (CE_NOTE, "FW state undefined"));
3877 
3878                         max_wait        = (instance->tbolt == 1) ? 180 : 2;
3879                         cur_state       = MFI_STATE_UNDEFINED;
3880                         break;
3881                 case MFI_STATE_BB_INIT:
3882                         max_wait        = (instance->tbolt == 1) ? 180 : 2;
3883                         cur_state       = MFI_STATE_BB_INIT;
3884                         break;
3885                 case MFI_STATE_FW_INIT:
3886                         max_wait        = (instance->tbolt == 1) ? 180 : 2;
3887                         cur_state       = MFI_STATE_FW_INIT;
3888                         break;
3889                 case MFI_STATE_FW_INIT_2:
3890                         max_wait        = 180;
3891                         cur_state       = MFI_STATE_FW_INIT_2;
3892                         break;
3893                 case MFI_STATE_DEVICE_SCAN:
3894                         max_wait        = 180;
3895                         cur_state       = MFI_STATE_DEVICE_SCAN;
3896                         prev_abs_reg_val = cur_abs_reg_val;
3897                         con_log(CL_NONE, (CE_NOTE,
3898                             "Device scan in progress ...\n"));
3899                         break;
3900                 case MFI_STATE_FLUSH_CACHE:
3901                         max_wait        = 180;
3902                         cur_state       = MFI_STATE_FLUSH_CACHE;
3903                         break;
3904                 default:
3905                         con_log(CL_ANN1, (CE_NOTE,
3906                             "mr_sas: Unknown state 0x%x", fw_state));
3907                         return (ENODEV);
3908                 }
3909 
3910                 /* the cur_state should not last for more than max_wait secs */
3911                 for (i = 0; i < (max_wait * MILLISEC); i++) {
3912                         /* fw_state = RD_OB_MSG_0(instance) & MFI_STATE_MASK; */
3913                         cur_abs_reg_val =
3914                             instance->func_ptr->read_fw_status_reg(instance);
3915                         fw_state = cur_abs_reg_val & MFI_STATE_MASK;
3916 
3917                         if (fw_state == cur_state) {
3918                                 delay(1 * drv_usectohz(MILLISEC));
3919                         } else {
3920                                 break;
3921                         }
3922                 }
3923                 if (fw_state == MFI_STATE_DEVICE_SCAN) {
3924                         if (prev_abs_reg_val != cur_abs_reg_val) {
3925                                 continue;
3926                         }
3927                 }
3928 
3929                 /* return error if fw_state hasn't changed after max_wait */
3930                 if (fw_state == cur_state) {
3931                         con_log(CL_ANN1, (CE_WARN,
3932                             "FW state hasn't changed in %d secs", max_wait));
3933                         return (ENODEV);
3934                 }
3935         };
3936 
3937         /* This may also need to apply to Skinny, but for now, don't worry. */
3938         if (!instance->tbolt && !instance->skinny) {
3939                 fw_ctrl = RD_IB_DOORBELL(instance);
3940                 con_log(CL_ANN1, (CE_CONT,
3941                     "mfi_state_transition_to_ready:FW ctrl = 0x%x", fw_ctrl));
3942 
3943                 /*
3944                  * Write 0xF to the doorbell register to do the following.
3945                  * - Abort all outstanding commands (bit 0).
3946                  * - Transition from OPERATIONAL to READY state (bit 1).
3947                  * - Discard (possible) low MFA posted in 64-bit mode (bit-2).
3948                  * - Set to release FW to continue running (i.e. BIOS handshake
3949                  *   (bit 3).
3950                  */
3951                 WR_IB_DOORBELL(0xF, instance);
3952         }
3953 
3954         if (mrsas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
3955                 return (EIO);
3956         }
3957 
3958         return (DDI_SUCCESS);
3959 }
3960 
3961 /*
3962  * get_seq_num
3963  */
3964 static int
3965 get_seq_num(struct mrsas_instance *instance,
3966     struct mrsas_evt_log_info *eli)
3967 {
3968         int     ret = DDI_SUCCESS;
3969 
3970         dma_obj_t                       dcmd_dma_obj;
3971         struct mrsas_cmd                *cmd;
3972         struct mrsas_dcmd_frame         *dcmd;
3973         struct mrsas_evt_log_info *eli_tmp;
3974         if (instance->tbolt) {
3975                 cmd = get_raid_msg_mfi_pkt(instance);
3976         } else {
3977                 cmd = mrsas_get_mfi_pkt(instance);
3978         }
3979 
3980         if (!cmd) {
3981                 dev_err(instance->dip, CE_WARN, "failed to get a cmd");
3982                 DTRACE_PROBE2(seq_num_mfi_err, uint16_t,
3983                     instance->fw_outstanding, uint16_t, instance->max_fw_cmds);
3984                 return (ENOMEM);
3985         }
3986 
3987         /* Clear the frame buffer and assign back the context id */
3988         (void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
3989         ddi_put32(cmd->frame_dma_obj.acc_handle, &cmd->frame->hdr.context,
3990             cmd->index);
3991 
3992         dcmd = &cmd->frame->dcmd;
3993 
3994         /* allocate the data transfer buffer */
3995         dcmd_dma_obj.size = sizeof (struct mrsas_evt_log_info);
3996         dcmd_dma_obj.dma_attr = mrsas_generic_dma_attr;
3997         dcmd_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3998         dcmd_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
3999         dcmd_dma_obj.dma_attr.dma_attr_sgllen = 1;
4000         dcmd_dma_obj.dma_attr.dma_attr_align = 1;
4001 
4002         if (mrsas_alloc_dma_obj(instance, &dcmd_dma_obj,
4003             (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
4004                 dev_err(instance->dip, CE_WARN,
4005                     "get_seq_num: could not allocate data transfer buffer.");
4006                 return (DDI_FAILURE);
4007         }
4008 
4009         (void) memset(dcmd_dma_obj.buffer, 0,
4010             sizeof (struct mrsas_evt_log_info));
4011 
4012         (void) memset(dcmd->mbox.b, 0, DCMD_MBOX_SZ);
4013 
4014         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->cmd, MFI_CMD_OP_DCMD);
4015         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->cmd_status, 0);
4016         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->sge_count, 1);
4017         ddi_put16(cmd->frame_dma_obj.acc_handle, &dcmd->flags,
4018             MFI_FRAME_DIR_READ);
4019         ddi_put16(cmd->frame_dma_obj.acc_handle, &dcmd->timeout, 0);
4020         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->data_xfer_len,
4021             sizeof (struct mrsas_evt_log_info));
4022         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->opcode,
4023             MR_DCMD_CTRL_EVENT_GET_INFO);
4024         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->sgl.sge32[0].length,
4025             sizeof (struct mrsas_evt_log_info));
4026         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->sgl.sge32[0].phys_addr,
4027             dcmd_dma_obj.dma_cookie[0].dmac_address);
4028 
4029         cmd->sync_cmd = MRSAS_TRUE;
4030         cmd->frame_count = 1;
4031 
4032         if (instance->tbolt) {
4033                 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
4034         }
4035 
4036         if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
4037                 dev_err(instance->dip, CE_WARN, "get_seq_num: "
4038                     "failed to issue MRSAS_DCMD_CTRL_EVENT_GET_INFO");
4039                 ret = DDI_FAILURE;
4040         } else {
4041                 eli_tmp = (struct mrsas_evt_log_info *)dcmd_dma_obj.buffer;
4042                 eli->newest_seq_num = ddi_get32(cmd->frame_dma_obj.acc_handle,
4043                     &eli_tmp->newest_seq_num);
4044                 ret = DDI_SUCCESS;
4045         }
4046 
4047         if (mrsas_free_dma_obj(instance, dcmd_dma_obj) != DDI_SUCCESS)
4048                 ret = DDI_FAILURE;
4049 
4050         if (instance->tbolt) {
4051                 return_raid_msg_mfi_pkt(instance, cmd);
4052         } else {
4053                 mrsas_return_mfi_pkt(instance, cmd);
4054         }
4055 
4056         return (ret);
4057 }
4058 
4059 /*
4060  * start_mfi_aen
4061  */
4062 static int
4063 start_mfi_aen(struct mrsas_instance *instance)
4064 {
4065         int     ret = 0;
4066 
4067         struct mrsas_evt_log_info       eli;
4068         union mrsas_evt_class_locale    class_locale;
4069 
4070         /* get the latest sequence number from FW */
4071         (void) memset(&eli, 0, sizeof (struct mrsas_evt_log_info));
4072 
4073         if (get_seq_num(instance, &eli)) {
4074                 dev_err(instance->dip, CE_WARN,
4075                     "start_mfi_aen: failed to get seq num");
4076                 return (-1);
4077         }
4078 
4079         /* register AEN with FW for latest sequence number plus 1 */
4080         class_locale.members.reserved   = 0;
4081         class_locale.members.locale     = LE_16(MR_EVT_LOCALE_ALL);
4082         class_locale.members.class      = MR_EVT_CLASS_INFO;
4083         class_locale.word       = LE_32(class_locale.word);
4084         ret = register_mfi_aen(instance, eli.newest_seq_num + 1,
4085             class_locale.word);
4086 
4087         if (ret) {
4088                 dev_err(instance->dip, CE_WARN,
4089                     "start_mfi_aen: aen registration failed");
4090                 return (-1);
4091         }
4092 
4093 
4094         return (ret);
4095 }
4096 
4097 /*
4098  * flush_cache
4099  */
4100 static void
4101 flush_cache(struct mrsas_instance *instance)
4102 {
4103         struct mrsas_cmd                *cmd = NULL;
4104         struct mrsas_dcmd_frame         *dcmd;
4105         if (instance->tbolt) {
4106                 cmd = get_raid_msg_mfi_pkt(instance);
4107         } else {
4108                 cmd = mrsas_get_mfi_pkt(instance);
4109         }
4110 
4111         if (!cmd) {
4112                 con_log(CL_ANN1, (CE_WARN,
4113                     "flush_cache():Failed to get a cmd for flush_cache"));
4114                 DTRACE_PROBE2(flush_cache_err, uint16_t,
4115                     instance->fw_outstanding, uint16_t, instance->max_fw_cmds);
4116                 return;
4117         }
4118 
4119         /* Clear the frame buffer and assign back the context id */
4120         (void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
4121         ddi_put32(cmd->frame_dma_obj.acc_handle, &cmd->frame->hdr.context,
4122             cmd->index);
4123 
4124         dcmd = &cmd->frame->dcmd;
4125 
4126         (void) memset(dcmd->mbox.b, 0, DCMD_MBOX_SZ);
4127 
4128         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->cmd, MFI_CMD_OP_DCMD);
4129         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->cmd_status, 0x0);
4130         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->sge_count, 0);
4131         ddi_put16(cmd->frame_dma_obj.acc_handle, &dcmd->flags,
4132             MFI_FRAME_DIR_NONE);
4133         ddi_put16(cmd->frame_dma_obj.acc_handle, &dcmd->timeout, 0);
4134         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->data_xfer_len, 0);
4135         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->opcode,
4136             MR_DCMD_CTRL_CACHE_FLUSH);
4137         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->mbox.b[0],
4138             MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE);
4139 
4140         cmd->frame_count = 1;
4141 
4142         if (instance->tbolt) {
4143                 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
4144         }
4145 
4146         if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
4147                 con_log(CL_ANN1, (CE_WARN,
4148             "flush_cache: failed to issue MFI_DCMD_CTRL_CACHE_FLUSH"));
4149         }
4150         con_log(CL_ANN1, (CE_CONT, "flush_cache done"));
4151         if (instance->tbolt) {
4152                 return_raid_msg_mfi_pkt(instance, cmd);
4153         } else {
4154                 mrsas_return_mfi_pkt(instance, cmd);
4155         }
4156 
4157 }
4158 
4159 /*
4160  * service_mfi_aen-     Completes an AEN command
4161  * @instance:                   Adapter soft state
4162  * @cmd:                        Command to be completed
4163  *
4164  */
4165 void
4166 service_mfi_aen(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
4167 {
4168         uint32_t        seq_num;
4169         struct mrsas_evt_detail *evt_detail =
4170             (struct mrsas_evt_detail *)instance->mfi_evt_detail_obj.buffer;
4171         int             rval = 0;
4172         int             tgt = 0;
4173         uint8_t         dtype;
4174         mrsas_pd_address_t      *pd_addr;
4175         ddi_acc_handle_t                acc_handle;
4176 
4177         con_log(CL_ANN, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
4178 
4179         acc_handle = cmd->frame_dma_obj.acc_handle;
4180         cmd->cmd_status = ddi_get8(acc_handle, &cmd->frame->io.cmd_status);
4181         if (cmd->cmd_status == ENODATA) {
4182                 cmd->cmd_status = 0;
4183         }
4184 
4185         /*
4186          * log the MFI AEN event to the sysevent queue so that
4187          * application will get noticed
4188          */
4189         if (ddi_log_sysevent(instance->dip, DDI_VENDOR_LSI, "LSIMEGA", "SAS",
4190             NULL, NULL, DDI_NOSLEEP) != DDI_SUCCESS) {
4191                 int     instance_no = ddi_get_instance(instance->dip);
4192                 con_log(CL_ANN, (CE_WARN,
4193                     "mr_sas%d: Failed to log AEN event", instance_no));
4194         }
4195         /*
4196          * Check for any ld devices that has changed state. i.e. online
4197          * or offline.
4198          */
4199         con_log(CL_ANN1, (CE_CONT,
4200             "AEN: code = %x class = %x locale = %x args = %x",
4201             ddi_get32(acc_handle, &evt_detail->code),
4202             evt_detail->cl.members.class,
4203             ddi_get16(acc_handle, &evt_detail->cl.members.locale),
4204             ddi_get8(acc_handle, &evt_detail->arg_type)));
4205 
4206         switch (ddi_get32(acc_handle, &evt_detail->code)) {
4207         case MR_EVT_CFG_CLEARED: {
4208                 for (tgt = 0; tgt < MRDRV_MAX_LD; tgt++) {
4209                         if (instance->mr_ld_list[tgt].dip != NULL) {
4210                                 mutex_enter(&instance->config_dev_mtx);
4211                                 instance->mr_ld_list[tgt].flag =
4212                                     (uint8_t)~MRDRV_TGT_VALID;
4213                                 mutex_exit(&instance->config_dev_mtx);
4214                                 rval = mrsas_service_evt(instance, tgt, 0,
4215                                     MRSAS_EVT_UNCONFIG_TGT, NULL);
4216                                 con_log(CL_ANN1, (CE_WARN,
4217                                     "mr_sas: CFG CLEARED AEN rval = %d "
4218                                     "tgt id = %d", rval, tgt));
4219                         }
4220                 }
4221                 break;
4222         }
4223 
4224         case MR_EVT_LD_DELETED: {
4225                 tgt = ddi_get16(acc_handle, &evt_detail->args.ld.target_id);
4226                 mutex_enter(&instance->config_dev_mtx);
4227                 instance->mr_ld_list[tgt].flag = (uint8_t)~MRDRV_TGT_VALID;
4228                 mutex_exit(&instance->config_dev_mtx);
4229                 rval = mrsas_service_evt(instance,
4230                     ddi_get16(acc_handle, &evt_detail->args.ld.target_id), 0,
4231                     MRSAS_EVT_UNCONFIG_TGT, NULL);
4232                 con_log(CL_ANN1, (CE_WARN, "mr_sas: LD DELETED AEN rval = %d "
4233                     "tgt id = %d index = %d", rval,
4234                     ddi_get16(acc_handle, &evt_detail->args.ld.target_id),
4235                     ddi_get8(acc_handle, &evt_detail->args.ld.ld_index)));
4236                 break;
4237         } /* End of MR_EVT_LD_DELETED */
4238 
4239         case MR_EVT_LD_CREATED: {
4240                 rval = mrsas_service_evt(instance,
4241                     ddi_get16(acc_handle, &evt_detail->args.ld.target_id), 0,
4242                     MRSAS_EVT_CONFIG_TGT, NULL);
4243                 con_log(CL_ANN1, (CE_WARN, "mr_sas: LD CREATED AEN rval = %d "
4244                     "tgt id = %d index = %d", rval,
4245                     ddi_get16(acc_handle, &evt_detail->args.ld.target_id),
4246                     ddi_get8(acc_handle, &evt_detail->args.ld.ld_index)));
4247                 break;
4248         } /* End of MR_EVT_LD_CREATED */
4249 
4250         case MR_EVT_PD_REMOVED_EXT: {
4251                 if (instance->tbolt || instance->skinny) {
4252                         pd_addr = &evt_detail->args.pd_addr;
4253                         dtype = pd_addr->scsi_dev_type;
4254                         con_log(CL_DLEVEL1, (CE_NOTE,
4255                             " MR_EVT_PD_REMOVED_EXT: dtype = %x,"
4256                             " arg_type = %d ", dtype, evt_detail->arg_type));
4257                         tgt = ddi_get16(acc_handle,
4258                             &evt_detail->args.pd.device_id);
4259                         mutex_enter(&instance->config_dev_mtx);
4260                         instance->mr_tbolt_pd_list[tgt].flag =
4261                             (uint8_t)~MRDRV_TGT_VALID;
4262                         mutex_exit(&instance->config_dev_mtx);
4263                         rval = mrsas_service_evt(instance, ddi_get16(
4264                             acc_handle, &evt_detail->args.pd.device_id),
4265                             1, MRSAS_EVT_UNCONFIG_TGT, NULL);
4266                         con_log(CL_ANN1, (CE_WARN, "mr_sas: PD_REMOVED:"
4267                             "rval = %d tgt id = %d ", rval,
4268                             ddi_get16(acc_handle,
4269                             &evt_detail->args.pd.device_id)));
4270                 }
4271                 break;
4272         } /* End of MR_EVT_PD_REMOVED_EXT */
4273 
4274         case MR_EVT_PD_INSERTED_EXT: {
4275                 if (instance->tbolt || instance->skinny) {
4276                         rval = mrsas_service_evt(instance,
4277                             ddi_get16(acc_handle,
4278                             &evt_detail->args.pd.device_id),
4279                             1, MRSAS_EVT_CONFIG_TGT, NULL);
4280                         con_log(CL_ANN1, (CE_WARN, "mr_sas: PD_INSERTEDi_EXT:"
4281                             "rval = %d tgt id = %d ", rval,
4282                             ddi_get16(acc_handle,
4283                             &evt_detail->args.pd.device_id)));
4284                 }
4285                 break;
4286         } /* End of MR_EVT_PD_INSERTED_EXT */
4287 
4288         case MR_EVT_PD_STATE_CHANGE: {
4289                 if (instance->tbolt || instance->skinny) {
4290                         tgt = ddi_get16(acc_handle,
4291                             &evt_detail->args.pd.device_id);
4292                         if ((evt_detail->args.pd_state.prevState ==
4293                             PD_SYSTEM) &&
4294                             (evt_detail->args.pd_state.newState != PD_SYSTEM)) {
4295                                 mutex_enter(&instance->config_dev_mtx);
4296                                 instance->mr_tbolt_pd_list[tgt].flag =
4297                                     (uint8_t)~MRDRV_TGT_VALID;
4298                                 mutex_exit(&instance->config_dev_mtx);
4299                                 rval = mrsas_service_evt(instance,
4300                                     ddi_get16(acc_handle,
4301                                     &evt_detail->args.pd.device_id),
4302                                     1, MRSAS_EVT_UNCONFIG_TGT, NULL);
4303                                 con_log(CL_ANN1, (CE_WARN, "mr_sas: PD_REMOVED:"
4304                                     "rval = %d tgt id = %d ", rval,
4305                                     ddi_get16(acc_handle,
4306                                     &evt_detail->args.pd.device_id)));
4307                                 break;
4308                         }
4309                         if ((evt_detail->args.pd_state.prevState
4310                             == UNCONFIGURED_GOOD) &&
4311                             (evt_detail->args.pd_state.newState == PD_SYSTEM)) {
4312                                 rval = mrsas_service_evt(instance,
4313                                     ddi_get16(acc_handle,
4314                                     &evt_detail->args.pd.device_id),
4315                                     1, MRSAS_EVT_CONFIG_TGT, NULL);
4316                                 con_log(CL_ANN1, (CE_WARN,
4317                                     "mr_sas: PD_INSERTED: rval = %d "
4318                                     " tgt id = %d ", rval,
4319                                     ddi_get16(acc_handle,
4320                                     &evt_detail->args.pd.device_id)));
4321                                 break;
4322                         }
4323                 }
4324                 break;
4325         }
4326 
4327         } /* End of Main Switch */
4328 
4329         /* get copy of seq_num and class/locale for re-registration */
4330         seq_num = ddi_get32(acc_handle, &evt_detail->seq_num);
4331         seq_num++;
4332         (void) memset(instance->mfi_evt_detail_obj.buffer, 0,
4333             sizeof (struct mrsas_evt_detail));
4334 
4335         ddi_put8(acc_handle, &cmd->frame->dcmd.cmd_status, 0x0);
4336         ddi_put32(acc_handle, &cmd->frame->dcmd.mbox.w[0], seq_num);
4337 
4338         instance->aen_seq_num = seq_num;
4339 
4340         cmd->frame_count = 1;
4341 
4342         cmd->retry_count_for_ocr = 0;
4343         cmd->drv_pkt_time = 0;
4344 
4345         /* Issue the aen registration frame */
4346         instance->func_ptr->issue_cmd(cmd, instance);
4347 }
4348 
4349 /*
4350  * complete_cmd_in_sync_mode -  Completes an internal command
4351  * @instance:                   Adapter soft state
4352  * @cmd:                        Command to be completed
4353  *
4354  * The issue_cmd_in_sync_mode() function waits for a command to complete
4355  * after it issues a command. This function wakes up that waiting routine by
4356  * calling wake_up() on the wait queue.
4357  */
4358 static void
4359 complete_cmd_in_sync_mode(struct mrsas_instance *instance,
4360     struct mrsas_cmd *cmd)
4361 {
4362         cmd->cmd_status = ddi_get8(cmd->frame_dma_obj.acc_handle,
4363             &cmd->frame->io.cmd_status);
4364 
4365         cmd->sync_cmd = MRSAS_FALSE;
4366 
4367         con_log(CL_ANN1, (CE_NOTE, "complete_cmd_in_sync_mode called %p \n",
4368             (void *)cmd));
4369 
4370         mutex_enter(&instance->int_cmd_mtx);
4371         if (cmd->cmd_status == ENODATA) {
4372                 cmd->cmd_status = 0;
4373         }
4374         cv_broadcast(&instance->int_cmd_cv);
4375         mutex_exit(&instance->int_cmd_mtx);
4376 
4377 }
4378 
4379 /*
4380  * Call this function inside mrsas_softintr.
4381  * mrsas_initiate_ocr_if_fw_is_faulty  - Initiates OCR if FW status is faulty
4382  * @instance:                   Adapter soft state
4383  */
4384 
4385 static uint32_t
4386 mrsas_initiate_ocr_if_fw_is_faulty(struct mrsas_instance *instance)
4387 {
4388         uint32_t        cur_abs_reg_val;
4389         uint32_t        fw_state;
4390 
4391         cur_abs_reg_val =  instance->func_ptr->read_fw_status_reg(instance);
4392         fw_state = cur_abs_reg_val & MFI_STATE_MASK;
4393         if (fw_state == MFI_STATE_FAULT) {
4394                 if (instance->disable_online_ctrl_reset == 1) {
4395                         dev_err(instance->dip, CE_WARN,
4396                             "mrsas_initiate_ocr_if_fw_is_faulty: "
4397                             "FW in Fault state, detected in ISR: "
4398                             "FW doesn't support ocr ");
4399 
4400                         return (ADAPTER_RESET_NOT_REQUIRED);
4401                 } else {
4402                         con_log(CL_ANN, (CE_NOTE,
4403                             "mrsas_initiate_ocr_if_fw_is_faulty: FW in Fault "
4404                             "state, detected in ISR: FW supports ocr "));
4405 
4406                         return (ADAPTER_RESET_REQUIRED);
4407                 }
4408         }
4409 
4410         return (ADAPTER_RESET_NOT_REQUIRED);
4411 }
4412 
4413 /*
4414  * mrsas_softintr - The Software ISR
4415  * @param arg   : HBA soft state
4416  *
4417  * called from high-level interrupt if hi-level interrupt are not there,
4418  * otherwise triggered as a soft interrupt
4419  */
4420 static uint_t
4421 mrsas_softintr(struct mrsas_instance *instance)
4422 {
4423         struct scsi_pkt         *pkt;
4424         struct scsa_cmd         *acmd;
4425         struct mrsas_cmd        *cmd;
4426         struct mlist_head       *pos, *next;
4427         mlist_t                 process_list;
4428         struct mrsas_header     *hdr;
4429         struct scsi_arq_status  *arqstat;
4430 
4431         con_log(CL_ANN1, (CE_NOTE, "mrsas_softintr() called."));
4432 
4433         ASSERT(instance);
4434 
4435         mutex_enter(&instance->completed_pool_mtx);
4436 
4437         if (mlist_empty(&instance->completed_pool_list)) {
4438                 mutex_exit(&instance->completed_pool_mtx);
4439                 return (DDI_INTR_CLAIMED);
4440         }
4441 
4442         instance->softint_running = 1;
4443 
4444         INIT_LIST_HEAD(&process_list);
4445         mlist_splice(&instance->completed_pool_list, &process_list);
4446         INIT_LIST_HEAD(&instance->completed_pool_list);
4447 
4448         mutex_exit(&instance->completed_pool_mtx);
4449 
4450         /* perform all callbacks first, before releasing the SCBs */
4451         mlist_for_each_safe(pos, next, &process_list) {
4452                 cmd = mlist_entry(pos, struct mrsas_cmd, list);
4453 
4454                 /* syncronize the Cmd frame for the controller */
4455                 (void) ddi_dma_sync(cmd->frame_dma_obj.dma_handle,
4456                     0, 0, DDI_DMA_SYNC_FORCPU);
4457 
4458                 if (mrsas_check_dma_handle(cmd->frame_dma_obj.dma_handle) !=
4459                     DDI_SUCCESS) {
4460                         mrsas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
4461                         ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
4462                         con_log(CL_ANN1, (CE_WARN,
4463                             "mrsas_softintr: "
4464                             "FMA check reports DMA handle failure"));
4465                         return (DDI_INTR_CLAIMED);
4466                 }
4467 
4468                 hdr = &cmd->frame->hdr;
4469 
4470                 /* remove the internal command from the process list */
4471                 mlist_del_init(&cmd->list);
4472 
4473                 switch (ddi_get8(cmd->frame_dma_obj.acc_handle, &hdr->cmd)) {
4474                 case MFI_CMD_OP_PD_SCSI:
4475                 case MFI_CMD_OP_LD_SCSI:
4476                 case MFI_CMD_OP_LD_READ:
4477                 case MFI_CMD_OP_LD_WRITE:
4478                         /*
4479                          * MFI_CMD_OP_PD_SCSI and MFI_CMD_OP_LD_SCSI
4480                          * could have been issued either through an
4481                          * IO path or an IOCTL path. If it was via IOCTL,
4482                          * we will send it to internal completion.
4483                          */
4484                         if (cmd->sync_cmd == MRSAS_TRUE) {
4485                                 complete_cmd_in_sync_mode(instance, cmd);
4486                                 break;
4487                         }
4488 
4489                         /* regular commands */
4490                         acmd =  cmd->cmd;
4491                         pkt =   CMD2PKT(acmd);
4492 
4493                         if (acmd->cmd_flags & CFLAG_DMAVALID) {
4494                                 if (acmd->cmd_flags & CFLAG_CONSISTENT) {
4495                                         (void) ddi_dma_sync(acmd->cmd_dmahandle,
4496                                             acmd->cmd_dma_offset,
4497                                             acmd->cmd_dma_len,
4498                                             DDI_DMA_SYNC_FORCPU);
4499                                 }
4500                         }
4501 
4502                         pkt->pkt_reason              = CMD_CMPLT;
4503                         pkt->pkt_statistics  = 0;
4504                         pkt->pkt_state = STATE_GOT_BUS
4505                             | STATE_GOT_TARGET | STATE_SENT_CMD
4506                             | STATE_XFERRED_DATA | STATE_GOT_STATUS;
4507 
4508                         con_log(CL_ANN, (CE_CONT,
4509                             "CDB[0] = %x completed for %s: size %lx context %x",
4510                             pkt->pkt_cdbp[0], ((acmd->islogical) ? "LD" : "PD"),
4511                             acmd->cmd_dmacount, hdr->context));
4512                         DTRACE_PROBE3(softintr_cdb, uint8_t, pkt->pkt_cdbp[0],
4513                             uint_t, acmd->cmd_cdblen, ulong_t,
4514                             acmd->cmd_dmacount);
4515 
4516                         if (pkt->pkt_cdbp[0] == SCMD_INQUIRY) {
4517                                 struct scsi_inquiry     *inq;
4518 
4519                                 if (acmd->cmd_dmacount != 0) {
4520                                         bp_mapin(acmd->cmd_buf);
4521                                         inq = (struct scsi_inquiry *)
4522                                             acmd->cmd_buf->b_un.b_addr;
4523 
4524                                         if (hdr->cmd_status == MFI_STAT_OK) {
4525                                                 display_scsi_inquiry(
4526                                                     (caddr_t)inq);
4527                                         }
4528                                 }
4529                         }
4530 
4531                         DTRACE_PROBE2(softintr_done, uint8_t, hdr->cmd,
4532                             uint8_t, hdr->cmd_status);
4533 
4534                         switch (hdr->cmd_status) {
4535                         case MFI_STAT_OK:
4536                                 pkt->pkt_scbp[0] = STATUS_GOOD;
4537                                 break;
4538                         case MFI_STAT_LD_CC_IN_PROGRESS:
4539                         case MFI_STAT_LD_RECON_IN_PROGRESS:
4540                                 pkt->pkt_scbp[0] = STATUS_GOOD;
4541                                 break;
4542                         case MFI_STAT_LD_INIT_IN_PROGRESS:
4543                                 con_log(CL_ANN,
4544                                     (CE_WARN, "Initialization in Progress"));
4545                                 pkt->pkt_reason      = CMD_TRAN_ERR;
4546 
4547                                 break;
4548                         case MFI_STAT_SCSI_DONE_WITH_ERROR:
4549                                 con_log(CL_ANN, (CE_CONT, "scsi_done error"));
4550 
4551                                 pkt->pkt_reason      = CMD_CMPLT;
4552                                 ((struct scsi_status *)
4553                                     pkt->pkt_scbp)->sts_chk = 1;
4554 
4555                                 if (pkt->pkt_cdbp[0] == SCMD_TEST_UNIT_READY) {
4556                                         con_log(CL_ANN,
4557                                             (CE_WARN, "TEST_UNIT_READY fail"));
4558                                 } else {
4559                                         pkt->pkt_state |= STATE_ARQ_DONE;
4560                                         arqstat = (void *)(pkt->pkt_scbp);
4561                                         arqstat->sts_rqpkt_reason = CMD_CMPLT;
4562                                         arqstat->sts_rqpkt_resid = 0;
4563                                         arqstat->sts_rqpkt_state |=
4564                                             STATE_GOT_BUS | STATE_GOT_TARGET
4565                                             | STATE_SENT_CMD
4566                                             | STATE_XFERRED_DATA;
4567                                         *(uint8_t *)&arqstat->sts_rqpkt_status =
4568                                             STATUS_GOOD;
4569                                         ddi_rep_get8(
4570                                             cmd->frame_dma_obj.acc_handle,
4571                                             (uint8_t *)
4572                                             &(arqstat->sts_sensedata),
4573                                             cmd->sense,
4574                                             sizeof (struct scsi_extended_sense),
4575                                             DDI_DEV_AUTOINCR);
4576                                 }
4577                                 break;
4578                         case MFI_STAT_LD_OFFLINE:
4579                         case MFI_STAT_DEVICE_NOT_FOUND:
4580                                 con_log(CL_ANN, (CE_CONT,
4581                                 "mrsas_softintr:device not found error"));
4582                                 pkt->pkt_reason      = CMD_DEV_GONE;
4583                                 pkt->pkt_statistics  = STAT_DISCON;
4584                                 break;
4585                         case MFI_STAT_LD_LBA_OUT_OF_RANGE:
4586                                 pkt->pkt_state |= STATE_ARQ_DONE;
4587                                 pkt->pkt_reason      = CMD_CMPLT;
4588                                 ((struct scsi_status *)
4589                                     pkt->pkt_scbp)->sts_chk = 1;
4590 
4591                                 arqstat = (void *)(pkt->pkt_scbp);
4592                                 arqstat->sts_rqpkt_reason = CMD_CMPLT;
4593                                 arqstat->sts_rqpkt_resid = 0;
4594                                 arqstat->sts_rqpkt_state |= STATE_GOT_BUS
4595                                     | STATE_GOT_TARGET | STATE_SENT_CMD
4596                                     | STATE_XFERRED_DATA;
4597                                 *(uint8_t *)&arqstat->sts_rqpkt_status =
4598                                     STATUS_GOOD;
4599 
4600                                 arqstat->sts_sensedata.es_valid = 1;
4601                                 arqstat->sts_sensedata.es_key =
4602                                     KEY_ILLEGAL_REQUEST;
4603                                 arqstat->sts_sensedata.es_class =
4604                                     CLASS_EXTENDED_SENSE;
4605 
4606                                 /*
4607                                  * LOGICAL BLOCK ADDRESS OUT OF RANGE:
4608                                  * ASC: 0x21h; ASCQ: 0x00h;
4609                                  */
4610                                 arqstat->sts_sensedata.es_add_code = 0x21;
4611                                 arqstat->sts_sensedata.es_qual_code = 0x00;
4612 
4613                                 break;
4614 
4615                         default:
4616                                 con_log(CL_ANN, (CE_CONT, "Unknown status!"));
4617                                 pkt->pkt_reason      = CMD_TRAN_ERR;
4618 
4619                                 break;
4620                         }
4621 
4622                         atomic_add_16(&instance->fw_outstanding, (-1));
4623 
4624                         (void) mrsas_common_check(instance, cmd);
4625 
4626                         if (acmd->cmd_dmahandle) {
4627                                 if (mrsas_check_dma_handle(
4628                                     acmd->cmd_dmahandle) != DDI_SUCCESS) {
4629                                         ddi_fm_service_impact(instance->dip,
4630                                             DDI_SERVICE_UNAFFECTED);
4631                                         pkt->pkt_reason = CMD_TRAN_ERR;
4632                                         pkt->pkt_statistics = 0;
4633                                 }
4634                         }
4635 
4636                         mrsas_return_mfi_pkt(instance, cmd);
4637 
4638                         /* Call the callback routine */
4639                         if (((pkt->pkt_flags & FLAG_NOINTR) == 0) &&
4640                             pkt->pkt_comp) {
4641                                 (*pkt->pkt_comp)(pkt);
4642                         }
4643 
4644                         break;
4645 
4646                 case MFI_CMD_OP_SMP:
4647                 case MFI_CMD_OP_STP:
4648                         complete_cmd_in_sync_mode(instance, cmd);
4649                         break;
4650 
4651                 case MFI_CMD_OP_DCMD:
4652                         /* see if got an event notification */
4653                         if (ddi_get32(cmd->frame_dma_obj.acc_handle,
4654                             &cmd->frame->dcmd.opcode) ==
4655                             MR_DCMD_CTRL_EVENT_WAIT) {
4656                                 if ((instance->aen_cmd == cmd) &&
4657                                     (instance->aen_cmd->abort_aen)) {
4658                                         con_log(CL_ANN, (CE_WARN,
4659                                             "mrsas_softintr: "
4660                                             "aborted_aen returned"));
4661                                 } else {
4662                                         atomic_add_16(&instance->fw_outstanding,
4663                                             (-1));
4664                                         service_mfi_aen(instance, cmd);
4665                                 }
4666                         } else {
4667                                 complete_cmd_in_sync_mode(instance, cmd);
4668                         }
4669 
4670                         break;
4671 
4672                 case MFI_CMD_OP_ABORT:
4673                         con_log(CL_ANN, (CE_NOTE, "MFI_CMD_OP_ABORT complete"));
4674                         /*
4675                          * MFI_CMD_OP_ABORT successfully completed
4676                          * in the synchronous mode
4677                          */
4678                         complete_cmd_in_sync_mode(instance, cmd);
4679                         break;
4680 
4681                 default:
4682                         mrsas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
4683                         ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
4684 
4685                         if (cmd->pkt != NULL) {
4686                                 pkt = cmd->pkt;
4687                                 if (((pkt->pkt_flags & FLAG_NOINTR) == 0) &&
4688                                     pkt->pkt_comp) {
4689 
4690                                         con_log(CL_ANN1, (CE_CONT, "posting to "
4691                                             "scsa cmd %p index %x pkt %p"
4692                                             "time %llx, default ", (void *)cmd,
4693                                             cmd->index, (void *)pkt,
4694                                             gethrtime()));
4695 
4696                                         (*pkt->pkt_comp)(pkt);
4697 
4698                                 }
4699                         }
4700                         con_log(CL_ANN, (CE_WARN, "Cmd type unknown !"));
4701                         break;
4702                 }
4703         }
4704 
4705         instance->softint_running = 0;
4706 
4707         return (DDI_INTR_CLAIMED);
4708 }
4709 
4710 /*
4711  * mrsas_alloc_dma_obj
4712  *
4713  * Allocate the memory and other resources for an dma object.
4714  */
4715 int
4716 mrsas_alloc_dma_obj(struct mrsas_instance *instance, dma_obj_t *obj,
4717     uchar_t endian_flags)
4718 {
4719         int     i;
4720         size_t  alen = 0;
4721         uint_t  cookie_cnt;
4722         struct ddi_device_acc_attr tmp_endian_attr;
4723 
4724         tmp_endian_attr = endian_attr;
4725         tmp_endian_attr.devacc_attr_endian_flags = endian_flags;
4726         tmp_endian_attr.devacc_attr_access = DDI_DEFAULT_ACC;
4727 
4728         i = ddi_dma_alloc_handle(instance->dip, &obj->dma_attr,
4729             DDI_DMA_SLEEP, NULL, &obj->dma_handle);
4730         if (i != DDI_SUCCESS) {
4731 
4732                 switch (i) {
4733                         case DDI_DMA_BADATTR :
4734                                 con_log(CL_ANN, (CE_WARN,
4735                                 "Failed ddi_dma_alloc_handle- Bad attribute"));
4736                                 break;
4737                         case DDI_DMA_NORESOURCES :
4738                                 con_log(CL_ANN, (CE_WARN,
4739                                 "Failed ddi_dma_alloc_handle- No Resources"));
4740                                 break;
4741                         default :
4742                                 con_log(CL_ANN, (CE_WARN,
4743                                 "Failed ddi_dma_alloc_handle: "
4744                                 "unknown status %d", i));
4745                                 break;
4746                 }
4747 
4748                 return (-1);
4749         }
4750 
4751         if ((ddi_dma_mem_alloc(obj->dma_handle, obj->size, &tmp_endian_attr,
4752             DDI_DMA_RDWR | DDI_DMA_STREAMING, DDI_DMA_SLEEP, NULL,
4753             &obj->buffer, &alen, &obj->acc_handle) != DDI_SUCCESS) ||
4754             alen < obj->size) {
4755 
4756                 ddi_dma_free_handle(&obj->dma_handle);
4757 
4758                 con_log(CL_ANN, (CE_WARN, "Failed : ddi_dma_mem_alloc"));
4759 
4760                 return (-1);
4761         }
4762 
4763         if (ddi_dma_addr_bind_handle(obj->dma_handle, NULL, obj->buffer,
4764             obj->size, DDI_DMA_RDWR | DDI_DMA_STREAMING, DDI_DMA_SLEEP,
4765             NULL, &obj->dma_cookie[0], &cookie_cnt) != DDI_SUCCESS) {
4766 
4767                 ddi_dma_mem_free(&obj->acc_handle);
4768                 ddi_dma_free_handle(&obj->dma_handle);
4769 
4770                 con_log(CL_ANN, (CE_WARN, "Failed : ddi_dma_addr_bind_handle"));
4771 
4772                 return (-1);
4773         }
4774 
4775         if (mrsas_check_dma_handle(obj->dma_handle) != DDI_SUCCESS) {
4776                 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
4777                 return (-1);
4778         }
4779 
4780         if (mrsas_check_acc_handle(obj->acc_handle) != DDI_SUCCESS) {
4781                 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
4782                 return (-1);
4783         }
4784 
4785         return (cookie_cnt);
4786 }
4787 
4788 /*
4789  * mrsas_free_dma_obj(struct mrsas_instance *, dma_obj_t)
4790  *
4791  * De-allocate the memory and other resources for an dma object, which must
4792  * have been alloated by a previous call to mrsas_alloc_dma_obj()
4793  */
4794 int
4795 mrsas_free_dma_obj(struct mrsas_instance *instance, dma_obj_t obj)
4796 {
4797 
4798         if ((obj.dma_handle == NULL) || (obj.acc_handle == NULL)) {
4799                 return (DDI_SUCCESS);
4800         }
4801 
4802         /*
4803          * NOTE: These check-handle functions fail if *_handle == NULL, but
4804          * this function succeeds because of the previous check.
4805          */
4806         if (mrsas_check_dma_handle(obj.dma_handle) != DDI_SUCCESS) {
4807                 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4808                 return (DDI_FAILURE);
4809         }
4810 
4811         if (mrsas_check_acc_handle(obj.acc_handle) != DDI_SUCCESS) {
4812                 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4813                 return (DDI_FAILURE);
4814         }
4815 
4816         (void) ddi_dma_unbind_handle(obj.dma_handle);
4817         ddi_dma_mem_free(&obj.acc_handle);
4818         ddi_dma_free_handle(&obj.dma_handle);
4819         obj.acc_handle = NULL;
4820         return (DDI_SUCCESS);
4821 }
4822 
4823 /*
4824  * mrsas_dma_alloc(instance_t *, struct scsi_pkt *, struct buf *,
4825  * int, int (*)())
4826  *
4827  * Allocate dma resources for a new scsi command
4828  */
4829 int
4830 mrsas_dma_alloc(struct mrsas_instance *instance, struct scsi_pkt *pkt,
4831     struct buf *bp, int flags, int (*callback)())
4832 {
4833         int     dma_flags;
4834         int     (*cb)(caddr_t);
4835         int     i;
4836 
4837         ddi_dma_attr_t  tmp_dma_attr = mrsas_generic_dma_attr;
4838         struct scsa_cmd *acmd = PKT2CMD(pkt);
4839 
4840         acmd->cmd_buf = bp;
4841 
4842         if (bp->b_flags & B_READ) {
4843                 acmd->cmd_flags &= ~CFLAG_DMASEND;
4844                 dma_flags = DDI_DMA_READ;
4845         } else {
4846                 acmd->cmd_flags |= CFLAG_DMASEND;
4847                 dma_flags = DDI_DMA_WRITE;
4848         }
4849 
4850         if (flags & PKT_CONSISTENT) {
4851                 acmd->cmd_flags |= CFLAG_CONSISTENT;
4852                 dma_flags |= DDI_DMA_CONSISTENT;
4853         }
4854 
4855         if (flags & PKT_DMA_PARTIAL) {
4856                 dma_flags |= DDI_DMA_PARTIAL;
4857         }
4858 
4859         dma_flags |= DDI_DMA_REDZONE;
4860 
4861         cb = (callback == NULL_FUNC) ? DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
4862 
4863         tmp_dma_attr.dma_attr_sgllen = instance->max_num_sge;
4864         tmp_dma_attr.dma_attr_addr_hi = 0xffffffffffffffffull;
4865         if (instance->tbolt) {
4866                 /* OCR-RESET FIX */
4867                 tmp_dma_attr.dma_attr_count_max =
4868                     (U64)mrsas_tbolt_max_cap_maxxfer;  /* limit to 256K */
4869                 tmp_dma_attr.dma_attr_maxxfer =
4870                     (U64)mrsas_tbolt_max_cap_maxxfer;  /* limit to 256K */
4871         }
4872 
4873         if ((i = ddi_dma_alloc_handle(instance->dip, &tmp_dma_attr,
4874             cb, 0, &acmd->cmd_dmahandle)) != DDI_SUCCESS) {
4875                 switch (i) {
4876                 case DDI_DMA_BADATTR:
4877                         bioerror(bp, EFAULT);
4878                         return (DDI_FAILURE);
4879 
4880                 case DDI_DMA_NORESOURCES:
4881                         bioerror(bp, 0);
4882                         return (DDI_FAILURE);
4883 
4884                 default:
4885                         con_log(CL_ANN, (CE_PANIC, "ddi_dma_alloc_handle: "
4886                             "impossible result (0x%x)", i));
4887                         bioerror(bp, EFAULT);
4888                         return (DDI_FAILURE);
4889                 }
4890         }
4891 
4892         i = ddi_dma_buf_bind_handle(acmd->cmd_dmahandle, bp, dma_flags,
4893             cb, 0, &acmd->cmd_dmacookies[0], &acmd->cmd_ncookies);
4894 
4895         switch (i) {
4896         case DDI_DMA_PARTIAL_MAP:
4897                 if ((dma_flags & DDI_DMA_PARTIAL) == 0) {
4898                         con_log(CL_ANN, (CE_PANIC, "ddi_dma_buf_bind_handle: "
4899                             "DDI_DMA_PARTIAL_MAP impossible"));
4900                         goto no_dma_cookies;
4901                 }
4902 
4903                 if (ddi_dma_numwin(acmd->cmd_dmahandle, &acmd->cmd_nwin) ==
4904                     DDI_FAILURE) {
4905                         con_log(CL_ANN, (CE_PANIC, "ddi_dma_numwin failed"));
4906                         goto no_dma_cookies;
4907                 }
4908 
4909                 if (ddi_dma_getwin(acmd->cmd_dmahandle, acmd->cmd_curwin,
4910                     &acmd->cmd_dma_offset, &acmd->cmd_dma_len,
4911                     &acmd->cmd_dmacookies[0], &acmd->cmd_ncookies) ==
4912                     DDI_FAILURE) {
4913 
4914                         con_log(CL_ANN, (CE_PANIC, "ddi_dma_getwin failed"));
4915                         goto no_dma_cookies;
4916                 }
4917 
4918                 goto get_dma_cookies;
4919         case DDI_DMA_MAPPED:
4920                 acmd->cmd_nwin = 1;
4921                 acmd->cmd_dma_len = 0;
4922                 acmd->cmd_dma_offset = 0;
4923 
4924 get_dma_cookies:
4925                 i = 0;
4926                 acmd->cmd_dmacount = 0;
4927                 for (;;) {
4928                         acmd->cmd_dmacount +=
4929                             acmd->cmd_dmacookies[i++].dmac_size;
4930 
4931                         if (i == instance->max_num_sge ||
4932                             i == acmd->cmd_ncookies)
4933                                 break;
4934 
4935                         ddi_dma_nextcookie(acmd->cmd_dmahandle,
4936                             &acmd->cmd_dmacookies[i]);
4937                 }
4938 
4939                 acmd->cmd_cookie = i;
4940                 acmd->cmd_cookiecnt = i;
4941 
4942                 acmd->cmd_flags |= CFLAG_DMAVALID;
4943 
4944                 if (bp->b_bcount >= acmd->cmd_dmacount) {
4945                         pkt->pkt_resid = bp->b_bcount - acmd->cmd_dmacount;
4946                 } else {
4947                         pkt->pkt_resid = 0;
4948                 }
4949 
4950                 return (DDI_SUCCESS);
4951         case DDI_DMA_NORESOURCES:
4952                 bioerror(bp, 0);
4953                 break;
4954         case DDI_DMA_NOMAPPING:
4955                 bioerror(bp, EFAULT);
4956                 break;
4957         case DDI_DMA_TOOBIG:
4958                 bioerror(bp, EINVAL);
4959                 break;
4960         case DDI_DMA_INUSE:
4961                 con_log(CL_ANN, (CE_PANIC, "ddi_dma_buf_bind_handle:"
4962                     " DDI_DMA_INUSE impossible"));
4963                 break;
4964         default:
4965                 con_log(CL_ANN, (CE_PANIC, "ddi_dma_buf_bind_handle: "
4966                     "impossible result (0x%x)", i));
4967                 break;
4968         }
4969 
4970 no_dma_cookies:
4971         ddi_dma_free_handle(&acmd->cmd_dmahandle);
4972         acmd->cmd_dmahandle = NULL;
4973         acmd->cmd_flags &= ~CFLAG_DMAVALID;
4974         return (DDI_FAILURE);
4975 }
4976 
4977 /*
4978  * mrsas_dma_move(struct mrsas_instance *, struct scsi_pkt *, struct buf *)
4979  *
4980  * move dma resources to next dma window
4981  *
4982  */
4983 int
4984 mrsas_dma_move(struct mrsas_instance *instance, struct scsi_pkt *pkt,
4985     struct buf *bp)
4986 {
4987         int     i = 0;
4988 
4989         struct scsa_cmd *acmd = PKT2CMD(pkt);
4990 
4991         /*
4992          * If there are no more cookies remaining in this window,
4993          * must move to the next window first.
4994          */
4995         if (acmd->cmd_cookie == acmd->cmd_ncookies) {
4996                 if (acmd->cmd_curwin == acmd->cmd_nwin && acmd->cmd_nwin == 1) {
4997                         return (DDI_SUCCESS);
4998                 }
4999 
5000                 /* at last window, cannot move */
5001                 if (++acmd->cmd_curwin >= acmd->cmd_nwin) {
5002                         return (DDI_FAILURE);
5003                 }
5004 
5005                 if (ddi_dma_getwin(acmd->cmd_dmahandle, acmd->cmd_curwin,
5006                     &acmd->cmd_dma_offset, &acmd->cmd_dma_len,
5007                     &acmd->cmd_dmacookies[0], &acmd->cmd_ncookies) ==
5008                     DDI_FAILURE) {
5009                         return (DDI_FAILURE);
5010                 }
5011 
5012                 acmd->cmd_cookie = 0;
5013         } else {
5014                 /* still more cookies in this window - get the next one */
5015                 ddi_dma_nextcookie(acmd->cmd_dmahandle,
5016                     &acmd->cmd_dmacookies[0]);
5017         }
5018 
5019         /* get remaining cookies in this window, up to our maximum */
5020         for (;;) {
5021                 acmd->cmd_dmacount += acmd->cmd_dmacookies[i++].dmac_size;
5022                 acmd->cmd_cookie++;
5023 
5024                 if (i == instance->max_num_sge ||
5025                     acmd->cmd_cookie == acmd->cmd_ncookies) {
5026                         break;
5027                 }
5028 
5029                 ddi_dma_nextcookie(acmd->cmd_dmahandle,
5030                     &acmd->cmd_dmacookies[i]);
5031         }
5032 
5033         acmd->cmd_cookiecnt = i;
5034 
5035         if (bp->b_bcount >= acmd->cmd_dmacount) {
5036                 pkt->pkt_resid = bp->b_bcount - acmd->cmd_dmacount;
5037         } else {
5038                 pkt->pkt_resid = 0;
5039         }
5040 
5041         return (DDI_SUCCESS);
5042 }
5043 
5044 /*
5045  * build_cmd
5046  */
5047 static struct mrsas_cmd *
5048 build_cmd(struct mrsas_instance *instance, struct scsi_address *ap,
5049     struct scsi_pkt *pkt, uchar_t *cmd_done)
5050 {
5051         uint16_t        flags = 0;
5052         uint32_t        i;
5053         uint32_t        sge_bytes;
5054         uint32_t        tmp_data_xfer_len;
5055         ddi_acc_handle_t acc_handle;
5056         struct mrsas_cmd                *cmd;
5057         struct mrsas_sge64              *mfi_sgl;
5058         struct mrsas_sge_ieee           *mfi_sgl_ieee;
5059         struct scsa_cmd                 *acmd = PKT2CMD(pkt);
5060         struct mrsas_pthru_frame        *pthru;
5061         struct mrsas_io_frame           *ldio;
5062 
5063         /* find out if this is logical or physical drive command.  */
5064         acmd->islogical = MRDRV_IS_LOGICAL(ap);
5065         acmd->device_id = MAP_DEVICE_ID(instance, ap);
5066         *cmd_done = 0;
5067 
5068         /* get the command packet */
5069         if (!(cmd = mrsas_get_mfi_pkt(instance))) {
5070                 DTRACE_PROBE2(build_cmd_mfi_err, uint16_t,
5071                     instance->fw_outstanding, uint16_t, instance->max_fw_cmds);
5072                 return (NULL);
5073         }
5074 
5075         acc_handle = cmd->frame_dma_obj.acc_handle;
5076 
5077         /* Clear the frame buffer and assign back the context id */
5078         (void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
5079         ddi_put32(acc_handle, &cmd->frame->hdr.context, cmd->index);
5080 
5081         cmd->pkt = pkt;
5082         cmd->cmd = acmd;
5083         DTRACE_PROBE3(build_cmds, uint8_t, pkt->pkt_cdbp[0],
5084             ulong_t, acmd->cmd_dmacount, ulong_t, acmd->cmd_dma_len);
5085 
5086         /* lets get the command directions */
5087         if (acmd->cmd_flags & CFLAG_DMASEND) {
5088                 flags = MFI_FRAME_DIR_WRITE;
5089 
5090                 if (acmd->cmd_flags & CFLAG_CONSISTENT) {
5091                         (void) ddi_dma_sync(acmd->cmd_dmahandle,
5092                             acmd->cmd_dma_offset, acmd->cmd_dma_len,
5093                             DDI_DMA_SYNC_FORDEV);
5094                 }
5095         } else if (acmd->cmd_flags & ~CFLAG_DMASEND) {
5096                 flags = MFI_FRAME_DIR_READ;
5097 
5098                 if (acmd->cmd_flags & CFLAG_CONSISTENT) {
5099                         (void) ddi_dma_sync(acmd->cmd_dmahandle,
5100                             acmd->cmd_dma_offset, acmd->cmd_dma_len,
5101                             DDI_DMA_SYNC_FORCPU);
5102                 }
5103         } else {
5104                 flags = MFI_FRAME_DIR_NONE;
5105         }
5106 
5107         if (instance->flag_ieee) {
5108                 flags |= MFI_FRAME_IEEE;
5109         }
5110         flags |= MFI_FRAME_SGL64;
5111 
5112         switch (pkt->pkt_cdbp[0]) {
5113 
5114         /*
5115          * case SCMD_SYNCHRONIZE_CACHE:
5116          *      flush_cache(instance);
5117          *      mrsas_return_mfi_pkt(instance, cmd);
5118          *      *cmd_done = 1;
5119          *
5120          *      return (NULL);
5121          */
5122 
5123         case SCMD_READ:
5124         case SCMD_WRITE:
5125         case SCMD_READ_G1:
5126         case SCMD_WRITE_G1:
5127         case SCMD_READ_G4:
5128         case SCMD_WRITE_G4:
5129         case SCMD_READ_G5:
5130         case SCMD_WRITE_G5:
5131                 if (acmd->islogical) {
5132                         ldio = (struct mrsas_io_frame *)cmd->frame;
5133 
5134                         /*
5135                          * preare the Logical IO frame:
5136                          * 2nd bit is zero for all read cmds
5137                          */
5138                         ddi_put8(acc_handle, &ldio->cmd,
5139                             (pkt->pkt_cdbp[0] & 0x02) ? MFI_CMD_OP_LD_WRITE
5140                             : MFI_CMD_OP_LD_READ);
5141                         ddi_put8(acc_handle, &ldio->cmd_status, 0x0);
5142                         ddi_put8(acc_handle, &ldio->scsi_status, 0x0);
5143                         ddi_put8(acc_handle, &ldio->target_id, acmd->device_id);
5144                         ddi_put16(acc_handle, &ldio->timeout, 0);
5145                         ddi_put8(acc_handle, &ldio->reserved_0, 0);
5146                         ddi_put16(acc_handle, &ldio->pad_0, 0);
5147                         ddi_put16(acc_handle, &ldio->flags, flags);
5148 
5149                         /* Initialize sense Information */
5150                         bzero(cmd->sense, SENSE_LENGTH);
5151                         ddi_put8(acc_handle, &ldio->sense_len, SENSE_LENGTH);
5152                         ddi_put32(acc_handle, &ldio->sense_buf_phys_addr_hi, 0);
5153                         ddi_put32(acc_handle, &ldio->sense_buf_phys_addr_lo,
5154                             cmd->sense_phys_addr);
5155                         ddi_put32(acc_handle, &ldio->start_lba_hi, 0);
5156                         ddi_put8(acc_handle, &ldio->access_byte,
5157                             (acmd->cmd_cdblen != 6) ? pkt->pkt_cdbp[1] : 0);
5158                         ddi_put8(acc_handle, &ldio->sge_count,
5159                             acmd->cmd_cookiecnt);
5160                         if (instance->flag_ieee) {
5161                                 mfi_sgl_ieee =
5162                                     (struct mrsas_sge_ieee *)&ldio->sgl;
5163                         } else {
5164                                 mfi_sgl = (struct mrsas_sge64   *)&ldio->sgl;
5165                         }
5166 
5167                         (void) ddi_get32(acc_handle, &ldio->context);
5168 
5169                         if (acmd->cmd_cdblen == CDB_GROUP0) {
5170                                 /* 6-byte cdb */
5171                                 ddi_put32(acc_handle, &ldio->lba_count, (
5172                                     (uint16_t)(pkt->pkt_cdbp[4])));
5173 
5174                                 ddi_put32(acc_handle, &ldio->start_lba_lo, (
5175                                     ((uint32_t)(pkt->pkt_cdbp[3])) |
5176                                     ((uint32_t)(pkt->pkt_cdbp[2]) << 8) |
5177                                     ((uint32_t)((pkt->pkt_cdbp[1]) & 0x1F)
5178                                     << 16)));
5179                         } else if (acmd->cmd_cdblen == CDB_GROUP1) {
5180                                 /* 10-byte cdb */
5181                                 ddi_put32(acc_handle, &ldio->lba_count, (
5182                                     ((uint16_t)(pkt->pkt_cdbp[8])) |
5183                                     ((uint16_t)(pkt->pkt_cdbp[7]) << 8)));
5184 
5185                                 ddi_put32(acc_handle, &ldio->start_lba_lo, (
5186                                     ((uint32_t)(pkt->pkt_cdbp[5])) |
5187                                     ((uint32_t)(pkt->pkt_cdbp[4]) << 8) |
5188                                     ((uint32_t)(pkt->pkt_cdbp[3]) << 16) |
5189                                     ((uint32_t)(pkt->pkt_cdbp[2]) << 24)));
5190                         } else if (acmd->cmd_cdblen == CDB_GROUP5) {
5191                                 /* 12-byte cdb */
5192                                 ddi_put32(acc_handle, &ldio->lba_count, (
5193                                     ((uint32_t)(pkt->pkt_cdbp[9])) |
5194                                     ((uint32_t)(pkt->pkt_cdbp[8]) << 8) |
5195                                     ((uint32_t)(pkt->pkt_cdbp[7]) << 16) |
5196                                     ((uint32_t)(pkt->pkt_cdbp[6]) << 24)));
5197 
5198                                 ddi_put32(acc_handle, &ldio->start_lba_lo, (
5199                                     ((uint32_t)(pkt->pkt_cdbp[5])) |
5200                                     ((uint32_t)(pkt->pkt_cdbp[4]) << 8) |
5201                                     ((uint32_t)(pkt->pkt_cdbp[3]) << 16) |
5202                                     ((uint32_t)(pkt->pkt_cdbp[2]) << 24)));
5203                         } else if (acmd->cmd_cdblen == CDB_GROUP4) {
5204                                 /* 16-byte cdb */
5205                                 ddi_put32(acc_handle, &ldio->lba_count, (
5206                                     ((uint32_t)(pkt->pkt_cdbp[13])) |
5207                                     ((uint32_t)(pkt->pkt_cdbp[12]) << 8) |
5208                                     ((uint32_t)(pkt->pkt_cdbp[11]) << 16) |
5209                                     ((uint32_t)(pkt->pkt_cdbp[10]) << 24)));
5210 
5211                                 ddi_put32(acc_handle, &ldio->start_lba_lo, (
5212                                     ((uint32_t)(pkt->pkt_cdbp[9])) |
5213                                     ((uint32_t)(pkt->pkt_cdbp[8]) << 8) |
5214                                     ((uint32_t)(pkt->pkt_cdbp[7]) << 16) |
5215                                     ((uint32_t)(pkt->pkt_cdbp[6]) << 24)));
5216 
5217                                 ddi_put32(acc_handle, &ldio->start_lba_hi, (
5218                                     ((uint32_t)(pkt->pkt_cdbp[5])) |
5219                                     ((uint32_t)(pkt->pkt_cdbp[4]) << 8) |
5220                                     ((uint32_t)(pkt->pkt_cdbp[3]) << 16) |
5221                                     ((uint32_t)(pkt->pkt_cdbp[2]) << 24)));
5222                         }
5223 
5224                         break;
5225                 }
5226                 /* For all non-rd/wr and physical disk cmds */
5227                 /* FALLTHROUGH */
5228         default:
5229 
5230                 switch (pkt->pkt_cdbp[0]) {
5231                 case SCMD_MODE_SENSE:
5232                 case SCMD_MODE_SENSE_G1: {
5233                         union scsi_cdb  *cdbp;
5234                         uint16_t        page_code;
5235 
5236                         cdbp = (void *)pkt->pkt_cdbp;
5237                         page_code = (uint16_t)cdbp->cdb_un.sg.scsi[0];
5238                         switch (page_code) {
5239                         case 0x3:
5240                         case 0x4:
5241                                 (void) mrsas_mode_sense_build(pkt);
5242                                 mrsas_return_mfi_pkt(instance, cmd);
5243                                 *cmd_done = 1;
5244                                 return (NULL);
5245                         }
5246                         break;
5247                 }
5248                 default:
5249                         break;
5250                 }
5251 
5252                 pthru   = (struct mrsas_pthru_frame *)cmd->frame;
5253 
5254                 /* prepare the DCDB frame */
5255                 ddi_put8(acc_handle, &pthru->cmd, (acmd->islogical) ?
5256                     MFI_CMD_OP_LD_SCSI : MFI_CMD_OP_PD_SCSI);
5257                 ddi_put8(acc_handle, &pthru->cmd_status, 0x0);
5258                 ddi_put8(acc_handle, &pthru->scsi_status, 0x0);
5259                 ddi_put8(acc_handle, &pthru->target_id, acmd->device_id);
5260                 ddi_put8(acc_handle, &pthru->lun, 0);
5261                 ddi_put8(acc_handle, &pthru->cdb_len, acmd->cmd_cdblen);
5262                 ddi_put16(acc_handle, &pthru->timeout, 0);
5263                 ddi_put16(acc_handle, &pthru->flags, flags);
5264                 tmp_data_xfer_len = 0;
5265                 for (i = 0; i < acmd->cmd_cookiecnt; i++) {
5266                         tmp_data_xfer_len += acmd->cmd_dmacookies[i].dmac_size;
5267                 }
5268                 ddi_put32(acc_handle, &pthru->data_xfer_len,
5269                     tmp_data_xfer_len);
5270                 ddi_put8(acc_handle, &pthru->sge_count, acmd->cmd_cookiecnt);
5271                 if (instance->flag_ieee) {
5272                         mfi_sgl_ieee = (struct mrsas_sge_ieee *)&pthru->sgl;
5273                 } else {
5274                         mfi_sgl = (struct mrsas_sge64 *)&pthru->sgl;
5275                 }
5276 
5277                 bzero(cmd->sense, SENSE_LENGTH);
5278                 ddi_put8(acc_handle, &pthru->sense_len, SENSE_LENGTH);
5279                 ddi_put32(acc_handle, &pthru->sense_buf_phys_addr_hi, 0);
5280                 ddi_put32(acc_handle, &pthru->sense_buf_phys_addr_lo,
5281                     cmd->sense_phys_addr);
5282 
5283                 (void) ddi_get32(acc_handle, &pthru->context);
5284                 ddi_rep_put8(acc_handle, (uint8_t *)pkt->pkt_cdbp,
5285                     (uint8_t *)pthru->cdb, acmd->cmd_cdblen, DDI_DEV_AUTOINCR);
5286 
5287                 break;
5288         }
5289 
5290         /* prepare the scatter-gather list for the firmware */
5291         if (instance->flag_ieee) {
5292                 for (i = 0; i < acmd->cmd_cookiecnt; i++, mfi_sgl_ieee++) {
5293                         ddi_put64(acc_handle, &mfi_sgl_ieee->phys_addr,
5294                             acmd->cmd_dmacookies[i].dmac_laddress);
5295                         ddi_put32(acc_handle, &mfi_sgl_ieee->length,
5296                             acmd->cmd_dmacookies[i].dmac_size);
5297                 }
5298                 sge_bytes = sizeof (struct mrsas_sge_ieee)*acmd->cmd_cookiecnt;
5299         } else {
5300                 for (i = 0; i < acmd->cmd_cookiecnt; i++, mfi_sgl++) {
5301                         ddi_put64(acc_handle, &mfi_sgl->phys_addr,
5302                             acmd->cmd_dmacookies[i].dmac_laddress);
5303                         ddi_put32(acc_handle, &mfi_sgl->length,
5304                             acmd->cmd_dmacookies[i].dmac_size);
5305                 }
5306                 sge_bytes = sizeof (struct mrsas_sge64)*acmd->cmd_cookiecnt;
5307         }
5308 
5309         cmd->frame_count = (sge_bytes / MRMFI_FRAME_SIZE) +
5310             ((sge_bytes % MRMFI_FRAME_SIZE) ? 1 : 0) + 1;
5311 
5312         if (cmd->frame_count >= 8) {
5313                 cmd->frame_count = 8;
5314         }
5315 
5316         return (cmd);
5317 }
5318 
5319 /*
5320  * wait_for_outstanding -       Wait for all outstanding cmds
5321  * @instance:                           Adapter soft state
5322  *
5323  * This function waits for upto MRDRV_RESET_WAIT_TIME seconds for FW to
5324  * complete all its outstanding commands. Returns error if one or more IOs
5325  * are pending after this time period.
5326  */
5327 static int
5328 wait_for_outstanding(struct mrsas_instance *instance)
5329 {
5330         int             i;
5331         uint32_t        wait_time = 90;
5332 
5333         for (i = 0; i < wait_time; i++) {
5334                 if (!instance->fw_outstanding) {
5335                         break;
5336                 }
5337 
5338                 drv_usecwait(MILLISEC); /* wait for 1000 usecs */;
5339         }
5340 
5341         if (instance->fw_outstanding) {
5342                 return (1);
5343         }
5344 
5345         return (0);
5346 }
5347 
5348 /*
5349  * issue_mfi_pthru
5350  */
5351 static int
5352 issue_mfi_pthru(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
5353     struct mrsas_cmd *cmd, int mode)
5354 {
5355         void            *ubuf;
5356         uint32_t        kphys_addr = 0;
5357         uint32_t        xferlen = 0;
5358         uint32_t        new_xfer_length = 0;
5359         uint_t          model;
5360         ddi_acc_handle_t        acc_handle = cmd->frame_dma_obj.acc_handle;
5361         dma_obj_t                       pthru_dma_obj;
5362         struct mrsas_pthru_frame        *kpthru;
5363         struct mrsas_pthru_frame        *pthru;
5364         int i;
5365         pthru = &cmd->frame->pthru;
5366         kpthru = (struct mrsas_pthru_frame *)&ioctl->frame[0];
5367 
5368         if (instance->adapterresetinprogress) {
5369                 con_log(CL_ANN1, (CE_WARN, "issue_mfi_pthru: Reset flag set, "
5370                 "returning mfi_pkt and setting TRAN_BUSY\n"));
5371                 return (DDI_FAILURE);
5372         }
5373         model = ddi_model_convert_from(mode & FMODELS);
5374         if (model == DDI_MODEL_ILP32) {
5375                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_pthru: DDI_MODEL_LP32"));
5376 
5377                 xferlen = kpthru->sgl.sge32[0].length;
5378 
5379                 ubuf    = (void *)(ulong_t)kpthru->sgl.sge32[0].phys_addr;
5380         } else {
5381 #ifdef _ILP32
5382                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_pthru: DDI_MODEL_LP32"));
5383                 xferlen = kpthru->sgl.sge32[0].length;
5384                 ubuf    = (void *)(ulong_t)kpthru->sgl.sge32[0].phys_addr;
5385 #else
5386                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_pthru: DDI_MODEL_LP64"));
5387                 xferlen = kpthru->sgl.sge64[0].length;
5388                 ubuf    = (void *)(ulong_t)kpthru->sgl.sge64[0].phys_addr;
5389 #endif
5390         }
5391 
5392         if (xferlen) {
5393                 /* means IOCTL requires DMA */
5394                 /* allocate the data transfer buffer */
5395                 /* pthru_dma_obj.size = xferlen; */
5396                 MRSAS_GET_BOUNDARY_ALIGNED_LEN(xferlen, new_xfer_length,
5397                     PAGESIZE);
5398                 pthru_dma_obj.size = new_xfer_length;
5399                 pthru_dma_obj.dma_attr = mrsas_generic_dma_attr;
5400                 pthru_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
5401                 pthru_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
5402                 pthru_dma_obj.dma_attr.dma_attr_sgllen = 1;
5403                 pthru_dma_obj.dma_attr.dma_attr_align = 1;
5404 
5405                 /* allocate kernel buffer for DMA */
5406                 if (mrsas_alloc_dma_obj(instance, &pthru_dma_obj,
5407                     (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
5408                         con_log(CL_ANN, (CE_WARN, "issue_mfi_pthru: "
5409                             "could not allocate data transfer buffer."));
5410                         return (DDI_FAILURE);
5411                 }
5412                 (void) memset(pthru_dma_obj.buffer, 0, xferlen);
5413 
5414                 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
5415                 if (kpthru->flags & MFI_FRAME_DIR_WRITE) {
5416                         for (i = 0; i < xferlen; i++) {
5417                                 if (ddi_copyin((uint8_t *)ubuf+i,
5418                                     (uint8_t *)pthru_dma_obj.buffer+i,
5419                                     1, mode)) {
5420                                         con_log(CL_ANN, (CE_WARN,
5421                                             "issue_mfi_pthru : "
5422                                             "copy from user space failed"));
5423                                         return (DDI_FAILURE);
5424                                 }
5425                         }
5426                 }
5427 
5428                 kphys_addr = pthru_dma_obj.dma_cookie[0].dmac_address;
5429         }
5430 
5431         ddi_put8(acc_handle, &pthru->cmd, kpthru->cmd);
5432         ddi_put8(acc_handle, &pthru->sense_len, SENSE_LENGTH);
5433         ddi_put8(acc_handle, &pthru->cmd_status, 0);
5434         ddi_put8(acc_handle, &pthru->scsi_status, 0);
5435         ddi_put8(acc_handle, &pthru->target_id, kpthru->target_id);
5436         ddi_put8(acc_handle, &pthru->lun, kpthru->lun);
5437         ddi_put8(acc_handle, &pthru->cdb_len, kpthru->cdb_len);
5438         ddi_put8(acc_handle, &pthru->sge_count, kpthru->sge_count);
5439         ddi_put16(acc_handle, &pthru->timeout, kpthru->timeout);
5440         ddi_put32(acc_handle, &pthru->data_xfer_len, kpthru->data_xfer_len);
5441 
5442         ddi_put32(acc_handle, &pthru->sense_buf_phys_addr_hi, 0);
5443         pthru->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
5444         /* ddi_put32(acc_handle, &pthru->sense_buf_phys_addr_lo, 0); */
5445 
5446         ddi_rep_put8(acc_handle, (uint8_t *)kpthru->cdb, (uint8_t *)pthru->cdb,
5447             pthru->cdb_len, DDI_DEV_AUTOINCR);
5448 
5449         ddi_put16(acc_handle, &pthru->flags, kpthru->flags & ~MFI_FRAME_SGL64);
5450         ddi_put32(acc_handle, &pthru->sgl.sge32[0].length, xferlen);
5451         ddi_put32(acc_handle, &pthru->sgl.sge32[0].phys_addr, kphys_addr);
5452 
5453         cmd->sync_cmd = MRSAS_TRUE;
5454         cmd->frame_count = 1;
5455 
5456         if (instance->tbolt) {
5457                 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
5458         }
5459 
5460         if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
5461                 con_log(CL_ANN, (CE_WARN,
5462                     "issue_mfi_pthru: fw_ioctl failed"));
5463         } else {
5464                 if (xferlen && kpthru->flags & MFI_FRAME_DIR_READ) {
5465                         for (i = 0; i < xferlen; i++) {
5466                                 if (ddi_copyout(
5467                                     (uint8_t *)pthru_dma_obj.buffer+i,
5468                                     (uint8_t *)ubuf+i, 1, mode)) {
5469                                         con_log(CL_ANN, (CE_WARN,
5470                                             "issue_mfi_pthru : "
5471                                             "copy to user space failed"));
5472                                         return (DDI_FAILURE);
5473                                 }
5474                         }
5475                 }
5476         }
5477 
5478         kpthru->cmd_status = ddi_get8(acc_handle, &pthru->cmd_status);
5479         kpthru->scsi_status = ddi_get8(acc_handle, &pthru->scsi_status);
5480 
5481         con_log(CL_ANN, (CE_CONT, "issue_mfi_pthru: cmd_status %x, "
5482             "scsi_status %x", kpthru->cmd_status, kpthru->scsi_status));
5483         DTRACE_PROBE3(issue_pthru, uint8_t, kpthru->cmd, uint8_t,
5484             kpthru->cmd_status, uint8_t, kpthru->scsi_status);
5485 
5486         if (kpthru->sense_len) {
5487                 uint_t sense_len = SENSE_LENGTH;
5488                 void *sense_ubuf =
5489                     (void *)(ulong_t)kpthru->sense_buf_phys_addr_lo;
5490                 if (kpthru->sense_len <= SENSE_LENGTH) {
5491                         sense_len = kpthru->sense_len;
5492                 }
5493 
5494                 for (i = 0; i < sense_len; i++) {
5495                         if (ddi_copyout(
5496                             (uint8_t *)cmd->sense+i,
5497                             (uint8_t *)sense_ubuf+i, 1, mode)) {
5498                                 con_log(CL_ANN, (CE_WARN,
5499                                     "issue_mfi_pthru : "
5500                                     "copy to user space failed"));
5501                         }
5502                         con_log(CL_DLEVEL1, (CE_WARN,
5503                             "Copying Sense info sense_buff[%d] = 0x%X",
5504                             i, *((uint8_t *)cmd->sense + i)));
5505                 }
5506         }
5507         (void) ddi_dma_sync(cmd->frame_dma_obj.dma_handle, 0, 0,
5508             DDI_DMA_SYNC_FORDEV);
5509 
5510         if (xferlen) {
5511                 /* free kernel buffer */
5512                 if (mrsas_free_dma_obj(instance, pthru_dma_obj) != DDI_SUCCESS)
5513                         return (DDI_FAILURE);
5514         }
5515 
5516         return (DDI_SUCCESS);
5517 }
5518 
5519 /*
5520  * issue_mfi_dcmd
5521  */
5522 static int
5523 issue_mfi_dcmd(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
5524     struct mrsas_cmd *cmd, int mode)
5525 {
5526         void            *ubuf;
5527         uint32_t        kphys_addr = 0;
5528         uint32_t        xferlen = 0;
5529         uint32_t        new_xfer_length = 0;
5530         uint32_t        model;
5531         dma_obj_t       dcmd_dma_obj;
5532         struct mrsas_dcmd_frame *kdcmd;
5533         struct mrsas_dcmd_frame *dcmd;
5534         ddi_acc_handle_t        acc_handle = cmd->frame_dma_obj.acc_handle;
5535         int i;
5536         dcmd = &cmd->frame->dcmd;
5537         kdcmd = (struct mrsas_dcmd_frame *)&ioctl->frame[0];
5538 
5539         if (instance->adapterresetinprogress) {
5540                 con_log(CL_ANN1, (CE_NOTE, "Reset flag set, "
5541                 "returning mfi_pkt and setting TRAN_BUSY"));
5542                 return (DDI_FAILURE);
5543         }
5544         model = ddi_model_convert_from(mode & FMODELS);
5545         if (model == DDI_MODEL_ILP32) {
5546                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_dcmd: DDI_MODEL_ILP32"));
5547 
5548                 xferlen = kdcmd->sgl.sge32[0].length;
5549 
5550                 ubuf    = (void *)(ulong_t)kdcmd->sgl.sge32[0].phys_addr;
5551         } else {
5552 #ifdef _ILP32
5553                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_dcmd: DDI_MODEL_ILP32"));
5554                 xferlen = kdcmd->sgl.sge32[0].length;
5555                 ubuf    = (void *)(ulong_t)kdcmd->sgl.sge32[0].phys_addr;
5556 #else
5557                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_dcmd: DDI_MODEL_LP64"));
5558                 xferlen = kdcmd->sgl.sge64[0].length;
5559                 ubuf    = (void *)(ulong_t)kdcmd->sgl.sge64[0].phys_addr;
5560 #endif
5561         }
5562         if (xferlen) {
5563                 /* means IOCTL requires DMA */
5564                 /* allocate the data transfer buffer */
5565                 /* dcmd_dma_obj.size = xferlen; */
5566                 MRSAS_GET_BOUNDARY_ALIGNED_LEN(xferlen, new_xfer_length,
5567                     PAGESIZE);
5568                 dcmd_dma_obj.size = new_xfer_length;
5569                 dcmd_dma_obj.dma_attr = mrsas_generic_dma_attr;
5570                 dcmd_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
5571                 dcmd_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
5572                 dcmd_dma_obj.dma_attr.dma_attr_sgllen = 1;
5573                 dcmd_dma_obj.dma_attr.dma_attr_align = 1;
5574 
5575                 /* allocate kernel buffer for DMA */
5576                         if (mrsas_alloc_dma_obj(instance, &dcmd_dma_obj,
5577                             (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
5578                                 con_log(CL_ANN,
5579                                     (CE_WARN, "issue_mfi_dcmd: could not "
5580                                     "allocate data transfer buffer."));
5581                                 return (DDI_FAILURE);
5582                         }
5583                 (void) memset(dcmd_dma_obj.buffer, 0, xferlen);
5584 
5585                 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
5586                 if (kdcmd->flags & MFI_FRAME_DIR_WRITE) {
5587                         for (i = 0; i < xferlen; i++) {
5588                                 if (ddi_copyin((uint8_t *)ubuf + i,
5589                                     (uint8_t *)dcmd_dma_obj.buffer + i,
5590                                     1, mode)) {
5591                                         con_log(CL_ANN, (CE_WARN,
5592                                             "issue_mfi_dcmd : "
5593                                             "copy from user space failed"));
5594                                         return (DDI_FAILURE);
5595                                 }
5596                         }
5597                 }
5598 
5599                 kphys_addr = dcmd_dma_obj.dma_cookie[0].dmac_address;
5600         }
5601 
5602         ddi_put8(acc_handle, &dcmd->cmd, kdcmd->cmd);
5603         ddi_put8(acc_handle, &dcmd->cmd_status, 0);
5604         ddi_put8(acc_handle, &dcmd->sge_count, kdcmd->sge_count);
5605         ddi_put16(acc_handle, &dcmd->timeout, kdcmd->timeout);
5606         ddi_put32(acc_handle, &dcmd->data_xfer_len, kdcmd->data_xfer_len);
5607         ddi_put32(acc_handle, &dcmd->opcode, kdcmd->opcode);
5608 
5609         ddi_rep_put8(acc_handle, (uint8_t *)kdcmd->mbox.b,
5610             (uint8_t *)dcmd->mbox.b, DCMD_MBOX_SZ, DDI_DEV_AUTOINCR);
5611 
5612         ddi_put16(acc_handle, &dcmd->flags, kdcmd->flags & ~MFI_FRAME_SGL64);
5613         ddi_put32(acc_handle, &dcmd->sgl.sge32[0].length, xferlen);
5614         ddi_put32(acc_handle, &dcmd->sgl.sge32[0].phys_addr, kphys_addr);
5615 
5616         cmd->sync_cmd = MRSAS_TRUE;
5617         cmd->frame_count = 1;
5618 
5619         if (instance->tbolt) {
5620                 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
5621         }
5622 
5623         if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
5624                 con_log(CL_ANN, (CE_WARN, "issue_mfi_dcmd: fw_ioctl failed"));
5625         } else {
5626                 if (xferlen && (kdcmd->flags & MFI_FRAME_DIR_READ)) {
5627                         for (i = 0; i < xferlen; i++) {
5628                                 if (ddi_copyout(
5629                                     (uint8_t *)dcmd_dma_obj.buffer + i,
5630                                     (uint8_t *)ubuf + i,
5631                                     1, mode)) {
5632                                         con_log(CL_ANN, (CE_WARN,
5633                                             "issue_mfi_dcmd : "
5634                                             "copy to user space failed"));
5635                                         return (DDI_FAILURE);
5636                                 }
5637                         }
5638                 }
5639         }
5640 
5641         kdcmd->cmd_status = ddi_get8(acc_handle, &dcmd->cmd_status);
5642         con_log(CL_ANN,
5643             (CE_CONT, "issue_mfi_dcmd: cmd_status %x", kdcmd->cmd_status));
5644         DTRACE_PROBE3(issue_dcmd, uint32_t, kdcmd->opcode, uint8_t,
5645             kdcmd->cmd, uint8_t, kdcmd->cmd_status);
5646 
5647         if (xferlen) {
5648                 /* free kernel buffer */
5649                 if (mrsas_free_dma_obj(instance, dcmd_dma_obj) != DDI_SUCCESS)
5650                         return (DDI_FAILURE);
5651         }
5652 
5653         return (DDI_SUCCESS);
5654 }
5655 
5656 /*
5657  * issue_mfi_smp
5658  */
5659 static int
5660 issue_mfi_smp(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
5661     struct mrsas_cmd *cmd, int mode)
5662 {
5663         void            *request_ubuf;
5664         void            *response_ubuf;
5665         uint32_t        request_xferlen = 0;
5666         uint32_t        response_xferlen = 0;
5667         uint32_t        new_xfer_length1 = 0;
5668         uint32_t        new_xfer_length2 = 0;
5669         uint_t          model;
5670         dma_obj_t                       request_dma_obj;
5671         dma_obj_t                       response_dma_obj;
5672         ddi_acc_handle_t        acc_handle = cmd->frame_dma_obj.acc_handle;
5673         struct mrsas_smp_frame          *ksmp;
5674         struct mrsas_smp_frame          *smp;
5675         struct mrsas_sge32              *sge32;
5676 #ifndef _ILP32
5677         struct mrsas_sge64              *sge64;
5678 #endif
5679         int i;
5680         uint64_t                        tmp_sas_addr;
5681 
5682         smp = &cmd->frame->smp;
5683         ksmp = (struct mrsas_smp_frame *)&ioctl->frame[0];
5684 
5685         if (instance->adapterresetinprogress) {
5686                 con_log(CL_ANN1, (CE_WARN, "Reset flag set, "
5687                 "returning mfi_pkt and setting TRAN_BUSY\n"));
5688                 return (DDI_FAILURE);
5689         }
5690         model = ddi_model_convert_from(mode & FMODELS);
5691         if (model == DDI_MODEL_ILP32) {
5692                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_smp: DDI_MODEL_ILP32"));
5693 
5694                 sge32                   = &ksmp->sgl[0].sge32[0];
5695                 response_xferlen        = sge32[0].length;
5696                 request_xferlen         = sge32[1].length;
5697                 con_log(CL_ANN, (CE_CONT, "issue_mfi_smp: "
5698                     "response_xferlen = %x, request_xferlen = %x",
5699                     response_xferlen, request_xferlen));
5700 
5701                 response_ubuf   = (void *)(ulong_t)sge32[0].phys_addr;
5702                 request_ubuf    = (void *)(ulong_t)sge32[1].phys_addr;
5703                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_smp: "
5704                     "response_ubuf = %p, request_ubuf = %p",
5705                     response_ubuf, request_ubuf));
5706         } else {
5707 #ifdef _ILP32
5708                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_smp: DDI_MODEL_ILP32"));
5709 
5710                 sge32                   = &ksmp->sgl[0].sge32[0];
5711                 response_xferlen        = sge32[0].length;
5712                 request_xferlen         = sge32[1].length;
5713                 con_log(CL_ANN, (CE_CONT, "issue_mfi_smp: "
5714                     "response_xferlen = %x, request_xferlen = %x",
5715                     response_xferlen, request_xferlen));
5716 
5717                 response_ubuf   = (void *)(ulong_t)sge32[0].phys_addr;
5718                 request_ubuf    = (void *)(ulong_t)sge32[1].phys_addr;
5719                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_smp: "
5720                     "response_ubuf = %p, request_ubuf = %p",
5721                     response_ubuf, request_ubuf));
5722 #else
5723                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_smp: DDI_MODEL_LP64"));
5724 
5725                 sge64                   = &ksmp->sgl[0].sge64[0];
5726                 response_xferlen        = sge64[0].length;
5727                 request_xferlen         = sge64[1].length;
5728 
5729                 response_ubuf   = (void *)(ulong_t)sge64[0].phys_addr;
5730                 request_ubuf    = (void *)(ulong_t)sge64[1].phys_addr;
5731 #endif
5732         }
5733         if (request_xferlen) {
5734                 /* means IOCTL requires DMA */
5735                 /* allocate the data transfer buffer */
5736                 /* request_dma_obj.size = request_xferlen; */
5737                 MRSAS_GET_BOUNDARY_ALIGNED_LEN(request_xferlen,
5738                     new_xfer_length1, PAGESIZE);
5739                 request_dma_obj.size = new_xfer_length1;
5740                 request_dma_obj.dma_attr = mrsas_generic_dma_attr;
5741                 request_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
5742                 request_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
5743                 request_dma_obj.dma_attr.dma_attr_sgllen = 1;
5744                 request_dma_obj.dma_attr.dma_attr_align = 1;
5745 
5746                 /* allocate kernel buffer for DMA */
5747                 if (mrsas_alloc_dma_obj(instance, &request_dma_obj,
5748                     (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
5749                         con_log(CL_ANN, (CE_WARN, "issue_mfi_smp: "
5750                             "could not allocate data transfer buffer."));
5751                         return (DDI_FAILURE);
5752                 }
5753                 (void) memset(request_dma_obj.buffer, 0, request_xferlen);
5754 
5755                 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
5756                 for (i = 0; i < request_xferlen; i++) {
5757                         if (ddi_copyin((uint8_t *)request_ubuf + i,
5758                             (uint8_t *)request_dma_obj.buffer + i,
5759                             1, mode)) {
5760                                 con_log(CL_ANN, (CE_WARN, "issue_mfi_smp: "
5761                                     "copy from user space failed"));
5762                                 return (DDI_FAILURE);
5763                         }
5764                 }
5765         }
5766 
5767         if (response_xferlen) {
5768                 /* means IOCTL requires DMA */
5769                 /* allocate the data transfer buffer */
5770                 /* response_dma_obj.size = response_xferlen; */
5771                 MRSAS_GET_BOUNDARY_ALIGNED_LEN(response_xferlen,
5772                     new_xfer_length2, PAGESIZE);
5773                 response_dma_obj.size = new_xfer_length2;
5774                 response_dma_obj.dma_attr = mrsas_generic_dma_attr;
5775                 response_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
5776                 response_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
5777                 response_dma_obj.dma_attr.dma_attr_sgllen = 1;
5778                 response_dma_obj.dma_attr.dma_attr_align = 1;
5779 
5780                 /* allocate kernel buffer for DMA */
5781                 if (mrsas_alloc_dma_obj(instance, &response_dma_obj,
5782                     (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
5783                         con_log(CL_ANN, (CE_WARN, "issue_mfi_smp: "
5784                             "could not allocate data transfer buffer."));
5785                         return (DDI_FAILURE);
5786                 }
5787                 (void) memset(response_dma_obj.buffer, 0, response_xferlen);
5788 
5789                 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
5790                 for (i = 0; i < response_xferlen; i++) {
5791                         if (ddi_copyin((uint8_t *)response_ubuf + i,
5792                             (uint8_t *)response_dma_obj.buffer + i,
5793                             1, mode)) {
5794                                 con_log(CL_ANN, (CE_WARN, "issue_mfi_smp: "
5795                                     "copy from user space failed"));
5796                                 return (DDI_FAILURE);
5797                         }
5798                 }
5799         }
5800 
5801         ddi_put8(acc_handle, &smp->cmd, ksmp->cmd);
5802         ddi_put8(acc_handle, &smp->cmd_status, 0);
5803         ddi_put8(acc_handle, &smp->connection_status, 0);
5804         ddi_put8(acc_handle, &smp->sge_count, ksmp->sge_count);
5805         /* smp->context              = ksmp->context; */
5806         ddi_put16(acc_handle, &smp->timeout, ksmp->timeout);
5807         ddi_put32(acc_handle, &smp->data_xfer_len, ksmp->data_xfer_len);
5808 
5809         bcopy((void *)&ksmp->sas_addr, (void *)&tmp_sas_addr,
5810             sizeof (uint64_t));
5811         ddi_put64(acc_handle, &smp->sas_addr, tmp_sas_addr);
5812 
5813         ddi_put16(acc_handle, &smp->flags, ksmp->flags & ~MFI_FRAME_SGL64);
5814 
5815         model = ddi_model_convert_from(mode & FMODELS);
5816         if (model == DDI_MODEL_ILP32) {
5817                 con_log(CL_ANN1, (CE_CONT,
5818                     "issue_mfi_smp: DDI_MODEL_ILP32"));
5819 
5820                 sge32 = &smp->sgl[0].sge32[0];
5821                 ddi_put32(acc_handle, &sge32[0].length, response_xferlen);
5822                 ddi_put32(acc_handle, &sge32[0].phys_addr,
5823                     response_dma_obj.dma_cookie[0].dmac_address);
5824                 ddi_put32(acc_handle, &sge32[1].length, request_xferlen);
5825                 ddi_put32(acc_handle, &sge32[1].phys_addr,
5826                     request_dma_obj.dma_cookie[0].dmac_address);
5827         } else {
5828 #ifdef _ILP32
5829                 con_log(CL_ANN1, (CE_CONT,
5830                     "issue_mfi_smp: DDI_MODEL_ILP32"));
5831                 sge32 = &smp->sgl[0].sge32[0];
5832                 ddi_put32(acc_handle, &sge32[0].length, response_xferlen);
5833                 ddi_put32(acc_handle, &sge32[0].phys_addr,
5834                     response_dma_obj.dma_cookie[0].dmac_address);
5835                 ddi_put32(acc_handle, &sge32[1].length, request_xferlen);
5836                 ddi_put32(acc_handle, &sge32[1].phys_addr,
5837                     request_dma_obj.dma_cookie[0].dmac_address);
5838 #else
5839                 con_log(CL_ANN1, (CE_CONT,
5840                     "issue_mfi_smp: DDI_MODEL_LP64"));
5841                 sge64 = &smp->sgl[0].sge64[0];
5842                 ddi_put32(acc_handle, &sge64[0].length, response_xferlen);
5843                 ddi_put64(acc_handle, &sge64[0].phys_addr,
5844                     response_dma_obj.dma_cookie[0].dmac_address);
5845                 ddi_put32(acc_handle, &sge64[1].length, request_xferlen);
5846                 ddi_put64(acc_handle, &sge64[1].phys_addr,
5847                     request_dma_obj.dma_cookie[0].dmac_address);
5848 #endif
5849         }
5850         con_log(CL_ANN1, (CE_CONT, "issue_mfi_smp : "
5851             "smp->response_xferlen = %d, smp->request_xferlen = %d "
5852             "smp->data_xfer_len = %d", ddi_get32(acc_handle, &sge32[0].length),
5853             ddi_get32(acc_handle, &sge32[1].length),
5854             ddi_get32(acc_handle, &smp->data_xfer_len)));
5855 
5856         cmd->sync_cmd = MRSAS_TRUE;
5857         cmd->frame_count = 1;
5858 
5859         if (instance->tbolt) {
5860                 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
5861         }
5862 
5863         if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
5864                 con_log(CL_ANN, (CE_WARN,
5865                     "issue_mfi_smp: fw_ioctl failed"));
5866         } else {
5867                 con_log(CL_ANN1, (CE_CONT,
5868                     "issue_mfi_smp: copy to user space"));
5869 
5870                 if (request_xferlen) {
5871                         for (i = 0; i < request_xferlen; i++) {
5872                                 if (ddi_copyout(
5873                                     (uint8_t *)request_dma_obj.buffer +
5874                                     i, (uint8_t *)request_ubuf + i,
5875                                     1, mode)) {
5876                                         con_log(CL_ANN, (CE_WARN,
5877                                             "issue_mfi_smp : copy to user space"
5878                                             " failed"));
5879                                         return (DDI_FAILURE);
5880                                 }
5881                         }
5882                 }
5883 
5884                 if (response_xferlen) {
5885                         for (i = 0; i < response_xferlen; i++) {
5886                                 if (ddi_copyout(
5887                                     (uint8_t *)response_dma_obj.buffer
5888                                     + i, (uint8_t *)response_ubuf
5889                                     + i, 1, mode)) {
5890                                         con_log(CL_ANN, (CE_WARN,
5891                                             "issue_mfi_smp : copy to "
5892                                             "user space failed"));
5893                                         return (DDI_FAILURE);
5894                                 }
5895                         }
5896                 }
5897         }
5898 
5899         ksmp->cmd_status = ddi_get8(acc_handle, &smp->cmd_status);
5900         con_log(CL_ANN1, (CE_NOTE, "issue_mfi_smp: smp->cmd_status = %d",
5901             ksmp->cmd_status));
5902         DTRACE_PROBE2(issue_smp, uint8_t, ksmp->cmd, uint8_t, ksmp->cmd_status);
5903 
5904         if (request_xferlen) {
5905                 /* free kernel buffer */
5906                 if (mrsas_free_dma_obj(instance, request_dma_obj) !=
5907                     DDI_SUCCESS)
5908                         return (DDI_FAILURE);
5909         }
5910 
5911         if (response_xferlen) {
5912                 /* free kernel buffer */
5913                 if (mrsas_free_dma_obj(instance, response_dma_obj) !=
5914                     DDI_SUCCESS)
5915                         return (DDI_FAILURE);
5916         }
5917 
5918         return (DDI_SUCCESS);
5919 }
5920 
5921 /*
5922  * issue_mfi_stp
5923  */
5924 static int
5925 issue_mfi_stp(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
5926     struct mrsas_cmd *cmd, int mode)
5927 {
5928         void            *fis_ubuf;
5929         void            *data_ubuf;
5930         uint32_t        fis_xferlen = 0;
5931         uint32_t   new_xfer_length1 = 0;
5932         uint32_t   new_xfer_length2 = 0;
5933         uint32_t        data_xferlen = 0;
5934         uint_t          model;
5935         dma_obj_t       fis_dma_obj;
5936         dma_obj_t       data_dma_obj;
5937         struct mrsas_stp_frame  *kstp;
5938         struct mrsas_stp_frame  *stp;
5939         ddi_acc_handle_t        acc_handle = cmd->frame_dma_obj.acc_handle;
5940         int i;
5941 
5942         stp = &cmd->frame->stp;
5943         kstp = (struct mrsas_stp_frame *)&ioctl->frame[0];
5944 
5945         if (instance->adapterresetinprogress) {
5946                 con_log(CL_ANN1, (CE_WARN, "Reset flag set, "
5947                 "returning mfi_pkt and setting TRAN_BUSY\n"));
5948                 return (DDI_FAILURE);
5949         }
5950         model = ddi_model_convert_from(mode & FMODELS);
5951         if (model == DDI_MODEL_ILP32) {
5952                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_stp: DDI_MODEL_ILP32"));
5953 
5954                 fis_xferlen     = kstp->sgl.sge32[0].length;
5955                 data_xferlen    = kstp->sgl.sge32[1].length;
5956 
5957                 fis_ubuf        = (void *)(ulong_t)kstp->sgl.sge32[0].phys_addr;
5958                 data_ubuf       = (void *)(ulong_t)kstp->sgl.sge32[1].phys_addr;
5959         } else {
5960 #ifdef _ILP32
5961                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_stp: DDI_MODEL_ILP32"));
5962 
5963                 fis_xferlen     = kstp->sgl.sge32[0].length;
5964                 data_xferlen    = kstp->sgl.sge32[1].length;
5965 
5966                 fis_ubuf        = (void *)(ulong_t)kstp->sgl.sge32[0].phys_addr;
5967                 data_ubuf       = (void *)(ulong_t)kstp->sgl.sge32[1].phys_addr;
5968 #else
5969                 con_log(CL_ANN1, (CE_CONT, "issue_mfi_stp: DDI_MODEL_LP64"));
5970 
5971                 fis_xferlen     = kstp->sgl.sge64[0].length;
5972                 data_xferlen    = kstp->sgl.sge64[1].length;
5973 
5974                 fis_ubuf        = (void *)(ulong_t)kstp->sgl.sge64[0].phys_addr;
5975                 data_ubuf       = (void *)(ulong_t)kstp->sgl.sge64[1].phys_addr;
5976 #endif
5977         }
5978 
5979 
5980         if (fis_xferlen) {
5981                 con_log(CL_ANN, (CE_CONT, "issue_mfi_stp: "
5982                     "fis_ubuf = %p fis_xferlen = %x", fis_ubuf, fis_xferlen));
5983 
5984                 /* means IOCTL requires DMA */
5985                 /* allocate the data transfer buffer */
5986                 /* fis_dma_obj.size = fis_xferlen; */
5987                 MRSAS_GET_BOUNDARY_ALIGNED_LEN(fis_xferlen,
5988                     new_xfer_length1, PAGESIZE);
5989                 fis_dma_obj.size = new_xfer_length1;
5990                 fis_dma_obj.dma_attr = mrsas_generic_dma_attr;
5991                 fis_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
5992                 fis_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
5993                 fis_dma_obj.dma_attr.dma_attr_sgllen = 1;
5994                 fis_dma_obj.dma_attr.dma_attr_align = 1;
5995 
5996                 /* allocate kernel buffer for DMA */
5997                 if (mrsas_alloc_dma_obj(instance, &fis_dma_obj,
5998                     (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
5999                         con_log(CL_ANN, (CE_WARN, "issue_mfi_stp : "
6000                             "could not allocate data transfer buffer."));
6001                         return (DDI_FAILURE);
6002                 }
6003                 (void) memset(fis_dma_obj.buffer, 0, fis_xferlen);
6004 
6005                 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
6006                 for (i = 0; i < fis_xferlen; i++) {
6007                         if (ddi_copyin((uint8_t *)fis_ubuf + i,
6008                             (uint8_t *)fis_dma_obj.buffer + i, 1, mode)) {
6009                                 con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: "
6010                                     "copy from user space failed"));
6011                                 return (DDI_FAILURE);
6012                         }
6013                 }
6014         }
6015 
6016         if (data_xferlen) {
6017                 con_log(CL_ANN, (CE_CONT, "issue_mfi_stp: data_ubuf = %p "
6018                     "data_xferlen = %x", data_ubuf, data_xferlen));
6019 
6020                 /* means IOCTL requires DMA */
6021                 /* allocate the data transfer buffer */
6022                 /* data_dma_obj.size = data_xferlen; */
6023                 MRSAS_GET_BOUNDARY_ALIGNED_LEN(data_xferlen, new_xfer_length2,
6024                     PAGESIZE);
6025                 data_dma_obj.size = new_xfer_length2;
6026                 data_dma_obj.dma_attr = mrsas_generic_dma_attr;
6027                 data_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
6028                 data_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
6029                 data_dma_obj.dma_attr.dma_attr_sgllen = 1;
6030                 data_dma_obj.dma_attr.dma_attr_align = 1;
6031 
6032                 /* allocate kernel buffer for DMA */
6033                 if (mrsas_alloc_dma_obj(instance, &data_dma_obj,
6034                     (uchar_t)DDI_STRUCTURE_LE_ACC) != 1) {
6035                         con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: "
6036                             "could not allocate data transfer buffer."));
6037                         return (DDI_FAILURE);
6038                 }
6039                 (void) memset(data_dma_obj.buffer, 0, data_xferlen);
6040 
6041                 /* If IOCTL requires DMA WRITE, do ddi_copyin IOCTL data copy */
6042                 for (i = 0; i < data_xferlen; i++) {
6043                         if (ddi_copyin((uint8_t *)data_ubuf + i,
6044                             (uint8_t *)data_dma_obj.buffer + i, 1, mode)) {
6045                                 con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: "
6046                                     "copy from user space failed"));
6047                                 return (DDI_FAILURE);
6048                         }
6049                 }
6050         }
6051 
6052         ddi_put8(acc_handle, &stp->cmd, kstp->cmd);
6053         ddi_put8(acc_handle, &stp->cmd_status, 0);
6054         ddi_put8(acc_handle, &stp->connection_status, 0);
6055         ddi_put8(acc_handle, &stp->target_id, kstp->target_id);
6056         ddi_put8(acc_handle, &stp->sge_count, kstp->sge_count);
6057 
6058         ddi_put16(acc_handle, &stp->timeout, kstp->timeout);
6059         ddi_put32(acc_handle, &stp->data_xfer_len, kstp->data_xfer_len);
6060 
6061         ddi_rep_put8(acc_handle, (uint8_t *)kstp->fis, (uint8_t *)stp->fis, 10,
6062             DDI_DEV_AUTOINCR);
6063 
6064         ddi_put16(acc_handle, &stp->flags, kstp->flags & ~MFI_FRAME_SGL64);
6065         ddi_put32(acc_handle, &stp->stp_flags, kstp->stp_flags);
6066         ddi_put32(acc_handle, &stp->sgl.sge32[0].length, fis_xferlen);
6067         ddi_put32(acc_handle, &stp->sgl.sge32[0].phys_addr,
6068             fis_dma_obj.dma_cookie[0].dmac_address);
6069         ddi_put32(acc_handle, &stp->sgl.sge32[1].length, data_xferlen);
6070         ddi_put32(acc_handle, &stp->sgl.sge32[1].phys_addr,
6071             data_dma_obj.dma_cookie[0].dmac_address);
6072 
6073         cmd->sync_cmd = MRSAS_TRUE;
6074         cmd->frame_count = 1;
6075 
6076         if (instance->tbolt) {
6077                 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
6078         }
6079 
6080         if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
6081                 con_log(CL_ANN, (CE_WARN, "issue_mfi_stp: fw_ioctl failed"));
6082         } else {
6083 
6084                 if (fis_xferlen) {
6085                         for (i = 0; i < fis_xferlen; i++) {
6086                                 if (ddi_copyout(
6087                                     (uint8_t *)fis_dma_obj.buffer + i,
6088                                     (uint8_t *)fis_ubuf + i, 1, mode)) {
6089                                         con_log(CL_ANN, (CE_WARN,
6090                                             "issue_mfi_stp : copy to "
6091                                             "user space failed"));
6092                                         return (DDI_FAILURE);
6093                                 }
6094                         }
6095                 }
6096         }
6097         if (data_xferlen) {
6098                 for (i = 0; i < data_xferlen; i++) {
6099                         if (ddi_copyout(
6100                             (uint8_t *)data_dma_obj.buffer + i,
6101                             (uint8_t *)data_ubuf + i, 1, mode)) {
6102                                 con_log(CL_ANN, (CE_WARN,
6103                                     "issue_mfi_stp : copy to"
6104                                     " user space failed"));
6105                                 return (DDI_FAILURE);
6106                         }
6107                 }
6108         }
6109 
6110         kstp->cmd_status = ddi_get8(acc_handle, &stp->cmd_status);
6111         con_log(CL_ANN1, (CE_NOTE, "issue_mfi_stp: stp->cmd_status = %d",
6112             kstp->cmd_status));
6113         DTRACE_PROBE2(issue_stp, uint8_t, kstp->cmd, uint8_t, kstp->cmd_status);
6114 
6115         if (fis_xferlen) {
6116                 /* free kernel buffer */
6117                 if (mrsas_free_dma_obj(instance, fis_dma_obj) != DDI_SUCCESS)
6118                         return (DDI_FAILURE);
6119         }
6120 
6121         if (data_xferlen) {
6122                 /* free kernel buffer */
6123                 if (mrsas_free_dma_obj(instance, data_dma_obj) != DDI_SUCCESS)
6124                         return (DDI_FAILURE);
6125         }
6126 
6127         return (DDI_SUCCESS);
6128 }
6129 
6130 /*
6131  * fill_up_drv_ver
6132  */
6133 void
6134 fill_up_drv_ver(struct mrsas_drv_ver *dv)
6135 {
6136         (void) memset(dv, 0, sizeof (struct mrsas_drv_ver));
6137 
6138         (void) memcpy(dv->signature, "$LSI LOGIC$", strlen("$LSI LOGIC$"));
6139         (void) memcpy(dv->os_name, "Solaris", strlen("Solaris"));
6140         (void) memcpy(dv->drv_name, "mr_sas", strlen("mr_sas"));
6141         (void) memcpy(dv->drv_ver, MRSAS_VERSION, strlen(MRSAS_VERSION));
6142         (void) memcpy(dv->drv_rel_date, MRSAS_RELDATE,
6143             strlen(MRSAS_RELDATE));
6144 
6145 }
6146 
6147 /*
6148  * handle_drv_ioctl
6149  */
6150 static int
6151 handle_drv_ioctl(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
6152     int mode)
6153 {
6154         int     i;
6155         int     rval = DDI_SUCCESS;
6156         int     *props = NULL;
6157         void    *ubuf;
6158 
6159         uint8_t         *pci_conf_buf;
6160         uint32_t        xferlen;
6161         uint32_t        num_props;
6162         uint_t          model;
6163         struct mrsas_dcmd_frame *kdcmd;
6164         struct mrsas_drv_ver    dv;
6165         struct mrsas_pci_information pi;
6166 
6167         kdcmd = (struct mrsas_dcmd_frame *)&ioctl->frame[0];
6168 
6169         model = ddi_model_convert_from(mode & FMODELS);
6170         if (model == DDI_MODEL_ILP32) {
6171                 con_log(CL_ANN1, (CE_CONT,
6172                     "handle_drv_ioctl: DDI_MODEL_ILP32"));
6173 
6174                 xferlen = kdcmd->sgl.sge32[0].length;
6175 
6176                 ubuf = (void *)(ulong_t)kdcmd->sgl.sge32[0].phys_addr;
6177         } else {
6178 #ifdef _ILP32
6179                 con_log(CL_ANN1, (CE_CONT,
6180                     "handle_drv_ioctl: DDI_MODEL_ILP32"));
6181                 xferlen = kdcmd->sgl.sge32[0].length;
6182                 ubuf = (void *)(ulong_t)kdcmd->sgl.sge32[0].phys_addr;
6183 #else
6184                 con_log(CL_ANN1, (CE_CONT,
6185                     "handle_drv_ioctl: DDI_MODEL_LP64"));
6186                 xferlen = kdcmd->sgl.sge64[0].length;
6187                 ubuf = (void *)(ulong_t)kdcmd->sgl.sge64[0].phys_addr;
6188 #endif
6189         }
6190         con_log(CL_ANN1, (CE_CONT, "handle_drv_ioctl: "
6191             "dataBuf=%p size=%d bytes", ubuf, xferlen));
6192 
6193         switch (kdcmd->opcode) {
6194         case MRSAS_DRIVER_IOCTL_DRIVER_VERSION:
6195                 con_log(CL_ANN1, (CE_CONT, "handle_drv_ioctl: "
6196                     "MRSAS_DRIVER_IOCTL_DRIVER_VERSION"));
6197 
6198                 fill_up_drv_ver(&dv);
6199 
6200                 if (ddi_copyout(&dv, ubuf, xferlen, mode)) {
6201                         con_log(CL_ANN, (CE_WARN, "handle_drv_ioctl: "
6202                             "MRSAS_DRIVER_IOCTL_DRIVER_VERSION : "
6203                             "copy to user space failed"));
6204                         kdcmd->cmd_status = 1;
6205                         rval = 1;
6206                 } else {
6207                         kdcmd->cmd_status = 0;
6208                 }
6209                 break;
6210         case MRSAS_DRIVER_IOCTL_PCI_INFORMATION:
6211                 con_log(CL_ANN1, (CE_NOTE, "handle_drv_ioctl: "
6212                     "MRSAS_DRIVER_IOCTL_PCI_INFORMAITON"));
6213 
6214                 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, instance->dip,
6215                     0, "reg", &props, &num_props)) {
6216                         con_log(CL_ANN, (CE_WARN, "handle_drv_ioctl: "
6217                             "MRSAS_DRIVER_IOCTL_PCI_INFORMATION : "
6218                             "ddi_prop_look_int_array failed"));
6219                         rval = DDI_FAILURE;
6220                 } else {
6221 
6222                         pi.busNumber = (props[0] >> 16) & 0xFF;
6223                         pi.deviceNumber = (props[0] >> 11) & 0x1f;
6224                         pi.functionNumber = (props[0] >> 8) & 0x7;
6225                         ddi_prop_free((void *)props);
6226                 }
6227 
6228                 pci_conf_buf = (uint8_t *)&pi.pciHeaderInfo;
6229 
6230                 for (i = 0; i < (sizeof (struct mrsas_pci_information) -
6231                     offsetof(struct mrsas_pci_information, pciHeaderInfo));
6232                     i++) {
6233                         pci_conf_buf[i] =
6234                             pci_config_get8(instance->pci_handle, i);
6235                 }
6236 
6237                 if (ddi_copyout(&pi, ubuf, xferlen, mode)) {
6238                         con_log(CL_ANN, (CE_WARN, "handle_drv_ioctl: "
6239                             "MRSAS_DRIVER_IOCTL_PCI_INFORMATION : "
6240                             "copy to user space failed"));
6241                         kdcmd->cmd_status = 1;
6242                         rval = 1;
6243                 } else {
6244                         kdcmd->cmd_status = 0;
6245                 }
6246                 break;
6247         default:
6248                 con_log(CL_ANN, (CE_WARN, "handle_drv_ioctl: "
6249                     "invalid driver specific IOCTL opcode = 0x%x",
6250                     kdcmd->opcode));
6251                 kdcmd->cmd_status = 1;
6252                 rval = DDI_FAILURE;
6253                 break;
6254         }
6255 
6256         return (rval);
6257 }
6258 
6259 /*
6260  * handle_mfi_ioctl
6261  */
6262 static int
6263 handle_mfi_ioctl(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
6264     int mode)
6265 {
6266         int     rval = DDI_SUCCESS;
6267 
6268         struct mrsas_header     *hdr;
6269         struct mrsas_cmd        *cmd;
6270 
6271         if (instance->tbolt) {
6272                 cmd = get_raid_msg_mfi_pkt(instance);
6273         } else {
6274                 cmd = mrsas_get_mfi_pkt(instance);
6275         }
6276         if (!cmd) {
6277                 con_log(CL_ANN, (CE_WARN, "mr_sas: "
6278                     "failed to get a cmd packet"));
6279                 DTRACE_PROBE2(mfi_ioctl_err, uint16_t,
6280                     instance->fw_outstanding, uint16_t, instance->max_fw_cmds);
6281                 return (DDI_FAILURE);
6282         }
6283 
6284         /* Clear the frame buffer and assign back the context id */
6285         (void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
6286         ddi_put32(cmd->frame_dma_obj.acc_handle, &cmd->frame->hdr.context,
6287             cmd->index);
6288 
6289         hdr = (struct mrsas_header *)&ioctl->frame[0];
6290 
6291         switch (ddi_get8(cmd->frame_dma_obj.acc_handle, &hdr->cmd)) {
6292         case MFI_CMD_OP_DCMD:
6293                 rval = issue_mfi_dcmd(instance, ioctl, cmd, mode);
6294                 break;
6295         case MFI_CMD_OP_SMP:
6296                 rval = issue_mfi_smp(instance, ioctl, cmd, mode);
6297                 break;
6298         case MFI_CMD_OP_STP:
6299                 rval = issue_mfi_stp(instance, ioctl, cmd, mode);
6300                 break;
6301         case MFI_CMD_OP_LD_SCSI:
6302         case MFI_CMD_OP_PD_SCSI:
6303                 rval = issue_mfi_pthru(instance, ioctl, cmd, mode);
6304                 break;
6305         default:
6306                 con_log(CL_ANN, (CE_WARN, "handle_mfi_ioctl: "
6307                     "invalid mfi ioctl hdr->cmd = %d", hdr->cmd));
6308                 rval = DDI_FAILURE;
6309                 break;
6310         }
6311 
6312         if (mrsas_common_check(instance, cmd) != DDI_SUCCESS)
6313                 rval = DDI_FAILURE;
6314 
6315         if (instance->tbolt) {
6316                 return_raid_msg_mfi_pkt(instance, cmd);
6317         } else {
6318                 mrsas_return_mfi_pkt(instance, cmd);
6319         }
6320 
6321         return (rval);
6322 }
6323 
6324 /*
6325  * AEN
6326  */
6327 static int
6328 handle_mfi_aen(struct mrsas_instance *instance, struct mrsas_aen *aen)
6329 {
6330         int     rval = 0;
6331 
6332         rval = register_mfi_aen(instance, instance->aen_seq_num,
6333             aen->class_locale_word);
6334 
6335         aen->cmd_status = (uint8_t)rval;
6336 
6337         return (rval);
6338 }
6339 
6340 static int
6341 register_mfi_aen(struct mrsas_instance *instance, uint32_t seq_num,
6342     uint32_t class_locale_word)
6343 {
6344         int     ret_val;
6345 
6346         struct mrsas_cmd        *cmd, *aen_cmd;
6347         struct mrsas_dcmd_frame *dcmd;
6348         union mrsas_evt_class_locale    curr_aen;
6349         union mrsas_evt_class_locale    prev_aen;
6350 
6351         con_log(CL_ANN, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
6352         /*
6353          * If there an AEN pending already (aen_cmd), check if the
6354          * class_locale of that pending AEN is inclusive of the new
6355          * AEN request we currently have. If it is, then we don't have
6356          * to do anything. In other words, whichever events the current
6357          * AEN request is subscribing to, have already been subscribed
6358          * to.
6359          *
6360          * If the old_cmd is _not_ inclusive, then we have to abort
6361          * that command, form a class_locale that is superset of both
6362          * old and current and re-issue to the FW
6363          */
6364 
6365         curr_aen.word = LE_32(class_locale_word);
6366         curr_aen.members.locale = LE_16(curr_aen.members.locale);
6367         aen_cmd = instance->aen_cmd;
6368         if (aen_cmd) {
6369                 prev_aen.word = ddi_get32(aen_cmd->frame_dma_obj.acc_handle,
6370                     &aen_cmd->frame->dcmd.mbox.w[1]);
6371                 prev_aen.word = LE_32(prev_aen.word);
6372                 prev_aen.members.locale = LE_16(prev_aen.members.locale);
6373                 /*
6374                  * A class whose enum value is smaller is inclusive of all
6375                  * higher values. If a PROGRESS (= -1) was previously
6376                  * registered, then a new registration requests for higher
6377                  * classes need not be sent to FW. They are automatically
6378                  * included.
6379                  *
6380                  * Locale numbers don't have such hierarchy. They are bitmap
6381                  * values
6382                  */
6383                 if ((prev_aen.members.class <= curr_aen.members.class) &&
6384                     !((prev_aen.members.locale & curr_aen.members.locale) ^
6385                     curr_aen.members.locale)) {
6386                         /*
6387                          * Previously issued event registration includes
6388                          * current request. Nothing to do.
6389                          */
6390 
6391                         return (0);
6392                 } else {
6393                         curr_aen.members.locale |= prev_aen.members.locale;
6394 
6395                         if (prev_aen.members.class < curr_aen.members.class)
6396                                 curr_aen.members.class = prev_aen.members.class;
6397 
6398                         ret_val = abort_aen_cmd(instance, aen_cmd);
6399 
6400                         if (ret_val) {
6401                                 con_log(CL_ANN, (CE_WARN, "register_mfi_aen: "
6402                                     "failed to abort prevous AEN command"));
6403 
6404                                 return (ret_val);
6405                         }
6406                 }
6407         } else {
6408                 curr_aen.word = LE_32(class_locale_word);
6409                 curr_aen.members.locale = LE_16(curr_aen.members.locale);
6410         }
6411 
6412         if (instance->tbolt) {
6413                 cmd = get_raid_msg_mfi_pkt(instance);
6414         } else {
6415                 cmd = mrsas_get_mfi_pkt(instance);
6416         }
6417 
6418         if (!cmd) {
6419                 DTRACE_PROBE2(mfi_aen_err, uint16_t, instance->fw_outstanding,
6420                     uint16_t, instance->max_fw_cmds);
6421                 return (ENOMEM);
6422         }
6423 
6424         /* Clear the frame buffer and assign back the context id */
6425         (void) memset((char *)&cmd->frame[0], 0, sizeof (union mrsas_frame));
6426         ddi_put32(cmd->frame_dma_obj.acc_handle, &cmd->frame->hdr.context,
6427             cmd->index);
6428 
6429         dcmd = &cmd->frame->dcmd;
6430 
6431         /* for(i = 0; i < DCMD_MBOX_SZ; i++) dcmd->mbox.b[i] = 0; */
6432         (void) memset(dcmd->mbox.b, 0, DCMD_MBOX_SZ);
6433 
6434         (void) memset(instance->mfi_evt_detail_obj.buffer, 0,
6435             sizeof (struct mrsas_evt_detail));
6436 
6437         /* Prepare DCMD for aen registration */
6438         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->cmd, MFI_CMD_OP_DCMD);
6439         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->cmd_status, 0x0);
6440         ddi_put8(cmd->frame_dma_obj.acc_handle, &dcmd->sge_count, 1);
6441         ddi_put16(cmd->frame_dma_obj.acc_handle, &dcmd->flags,
6442             MFI_FRAME_DIR_READ);
6443         ddi_put16(cmd->frame_dma_obj.acc_handle, &dcmd->timeout, 0);
6444         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->data_xfer_len,
6445             sizeof (struct mrsas_evt_detail));
6446         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->opcode,
6447             MR_DCMD_CTRL_EVENT_WAIT);
6448         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->mbox.w[0], seq_num);
6449         curr_aen.members.locale = LE_16(curr_aen.members.locale);
6450         curr_aen.word = LE_32(curr_aen.word);
6451         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->mbox.w[1],
6452             curr_aen.word);
6453         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->sgl.sge32[0].phys_addr,
6454             instance->mfi_evt_detail_obj.dma_cookie[0].dmac_address);
6455         ddi_put32(cmd->frame_dma_obj.acc_handle, &dcmd->sgl.sge32[0].length,
6456             sizeof (struct mrsas_evt_detail));
6457 
6458         instance->aen_seq_num = seq_num;
6459 
6460 
6461         /*
6462          * Store reference to the cmd used to register for AEN. When an
6463          * application wants us to register for AEN, we have to abort this
6464          * cmd and re-register with a new EVENT LOCALE supplied by that app
6465          */
6466         instance->aen_cmd = cmd;
6467 
6468         cmd->frame_count = 1;
6469 
6470         /* Issue the aen registration frame */
6471         /* atomic_add_16 (&instance->fw_outstanding, 1); */
6472         if (instance->tbolt) {
6473                 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
6474         }
6475         instance->func_ptr->issue_cmd(cmd, instance);
6476 
6477         return (0);
6478 }
6479 
6480 void
6481 display_scsi_inquiry(caddr_t scsi_inq)
6482 {
6483 #define MAX_SCSI_DEVICE_CODE    14
6484         int             i;
6485         char            inquiry_buf[256] = {0};
6486         int             len;
6487         const char      *const scsi_device_types[] = {
6488                 "Direct-Access    ",
6489                 "Sequential-Access",
6490                 "Printer          ",
6491                 "Processor        ",
6492                 "WORM             ",
6493                 "CD-ROM           ",
6494                 "Scanner          ",
6495                 "Optical Device   ",
6496                 "Medium Changer   ",
6497                 "Communications   ",
6498                 "Unknown          ",
6499                 "Unknown          ",
6500                 "Unknown          ",
6501                 "Enclosure        ",
6502         };
6503 
6504         len = 0;
6505 
6506         len += snprintf(inquiry_buf + len, 265 - len, "  Vendor: ");
6507         for (i = 8; i < 16; i++) {
6508                 len += snprintf(inquiry_buf + len, 265 - len, "%c",
6509                     scsi_inq[i]);
6510         }
6511 
6512         len += snprintf(inquiry_buf + len, 265 - len, "  Model: ");
6513 
6514         for (i = 16; i < 32; i++) {
6515                 len += snprintf(inquiry_buf + len, 265 - len, "%c",
6516                     scsi_inq[i]);
6517         }
6518 
6519         len += snprintf(inquiry_buf + len, 265 - len, "  Rev: ");
6520 
6521         for (i = 32; i < 36; i++) {
6522                 len += snprintf(inquiry_buf + len, 265 - len, "%c",
6523                     scsi_inq[i]);
6524         }
6525 
6526         len += snprintf(inquiry_buf + len, 265 - len, "\n");
6527 
6528 
6529         i = scsi_inq[0] & 0x1f;
6530 
6531 
6532         len += snprintf(inquiry_buf + len, 265 - len, "  Type:   %s ",
6533             i < MAX_SCSI_DEVICE_CODE ? scsi_device_types[i] :
6534             "Unknown          ");
6535 
6536 
6537         len += snprintf(inquiry_buf + len, 265 - len,
6538             "                 ANSI SCSI revision: %02x", scsi_inq[2] & 0x07);
6539 
6540         if ((scsi_inq[2] & 0x07) == 1 && (scsi_inq[3] & 0x0f) == 1) {
6541                 len += snprintf(inquiry_buf + len, 265 - len, " CCS\n");
6542         } else {
6543                 len += snprintf(inquiry_buf + len, 265 - len, "\n");
6544         }
6545 
6546         con_log(CL_DLEVEL2, (CE_CONT, inquiry_buf));
6547 }
6548 
6549 static void
6550 io_timeout_checker(void *arg)
6551 {
6552         struct scsi_pkt *pkt;
6553         struct mrsas_instance *instance = arg;
6554         struct mrsas_cmd        *cmd = NULL;
6555         struct mrsas_header     *hdr;
6556         int time = 0;
6557         int counter = 0;
6558         struct mlist_head       *pos, *next;
6559         mlist_t                 process_list;
6560 
6561         if (instance->adapterresetinprogress == 1) {
6562                 con_log(CL_ANN, (CE_NOTE, "io_timeout_checker:"
6563                     " reset in progress"));
6564 
6565                 instance->timeout_id = timeout(io_timeout_checker,
6566                     (void *) instance, drv_usectohz(MRSAS_1_SECOND));
6567                 return;
6568         }
6569 
6570         /* See if this check needs to be in the beginning or last in ISR */
6571         if (mrsas_initiate_ocr_if_fw_is_faulty(instance) ==  1) {
6572                 dev_err(instance->dip, CE_WARN, "io_timeout_checker: "
6573                     "FW Fault, calling reset adapter");
6574                 dev_err(instance->dip, CE_CONT, "io_timeout_checker: "
6575                     "fw_outstanding 0x%X max_fw_cmds 0x%X",
6576                     instance->fw_outstanding, instance->max_fw_cmds);
6577                 if (instance->adapterresetinprogress == 0) {
6578                         instance->adapterresetinprogress = 1;
6579                         if (instance->tbolt)
6580                                 (void) mrsas_tbolt_reset_ppc(instance);
6581                         else
6582                                 (void) mrsas_reset_ppc(instance);
6583                         instance->adapterresetinprogress = 0;
6584                 }
6585                 instance->timeout_id = timeout(io_timeout_checker,
6586                     (void *) instance, drv_usectohz(MRSAS_1_SECOND));
6587                 return;
6588         }
6589 
6590         INIT_LIST_HEAD(&process_list);
6591 
6592         mutex_enter(&instance->cmd_pend_mtx);
6593         mlist_for_each_safe(pos, next, &instance->cmd_pend_list) {
6594                 cmd = mlist_entry(pos, struct mrsas_cmd, list);
6595 
6596                 if (cmd == NULL) {
6597                         continue;
6598                 }
6599 
6600                 if (cmd->sync_cmd == MRSAS_TRUE) {
6601                         hdr = (struct mrsas_header *)&cmd->frame->hdr;
6602                         if (hdr == NULL) {
6603                                 continue;
6604                         }
6605                         time = --cmd->drv_pkt_time;
6606                 } else {
6607                         pkt = cmd->pkt;
6608                         if (pkt == NULL) {
6609                                 continue;
6610                         }
6611                         time = --cmd->drv_pkt_time;
6612                 }
6613                 if (time <= 0) {
6614                         dev_err(instance->dip, CE_WARN, "%llx: "
6615                             "io_timeout_checker: TIMING OUT: pkt: %p, "
6616                             "cmd %p fw_outstanding 0x%X max_fw_cmds 0x%X",
6617                             gethrtime(), (void *)pkt, (void *)cmd,
6618                             instance->fw_outstanding, instance->max_fw_cmds);
6619 
6620                         counter++;
6621                         break;
6622                 }
6623         }
6624         mutex_exit(&instance->cmd_pend_mtx);
6625 
6626         if (counter) {
6627                 if (instance->disable_online_ctrl_reset == 1) {
6628                         dev_err(instance->dip, CE_WARN, "%s(): OCR is NOT "
6629                             "supported by Firmware, KILL adapter!!!",
6630                             __func__);
6631 
6632                         if (instance->tbolt)
6633                                 mrsas_tbolt_kill_adapter(instance);
6634                         else
6635                                 (void) mrsas_kill_adapter(instance);
6636 
6637                         return;
6638                 } else {
6639                         if (cmd->retry_count_for_ocr <=    IO_RETRY_COUNT) {
6640                                 if (instance->adapterresetinprogress == 0) {
6641                                         if (instance->tbolt) {
6642                                                 (void) mrsas_tbolt_reset_ppc(
6643                                                     instance);
6644                                         } else {
6645                                                 (void) mrsas_reset_ppc(
6646                                                     instance);
6647                                         }
6648                                 }
6649                         } else {
6650                                 dev_err(instance->dip, CE_WARN,
6651                                     "io_timeout_checker: "
6652                                     "cmd %p cmd->index %d "
6653                                     "timed out even after 3 resets: "
6654                                     "so KILL adapter", (void *)cmd, cmd->index);
6655 
6656                                 mrsas_print_cmd_details(instance, cmd, 0xDD);
6657 
6658                                 if (instance->tbolt)
6659                                         mrsas_tbolt_kill_adapter(instance);
6660                                 else
6661                                         (void) mrsas_kill_adapter(instance);
6662                                 return;
6663                         }
6664                 }
6665         }
6666         con_log(CL_ANN, (CE_NOTE, "mrsas: "
6667             "schedule next timeout check: "
6668             "do timeout \n"));
6669         instance->timeout_id =
6670             timeout(io_timeout_checker, (void *)instance,
6671             drv_usectohz(MRSAS_1_SECOND));
6672 }
6673 
6674 static uint32_t
6675 read_fw_status_reg_ppc(struct mrsas_instance *instance)
6676 {
6677         return ((uint32_t)RD_OB_SCRATCH_PAD_0(instance));
6678 }
6679 
6680 static void
6681 issue_cmd_ppc(struct mrsas_cmd *cmd, struct mrsas_instance *instance)
6682 {
6683         struct scsi_pkt *pkt;
6684         atomic_inc_16(&instance->fw_outstanding);
6685 
6686         pkt = cmd->pkt;
6687         if (pkt) {
6688                 con_log(CL_DLEVEL1, (CE_NOTE, "%llx : issue_cmd_ppc:"
6689                     "ISSUED CMD TO FW : called : cmd:"
6690                     ": %p instance : %p pkt : %p pkt_time : %x\n",
6691                     gethrtime(), (void *)cmd, (void *)instance,
6692                     (void *)pkt, cmd->drv_pkt_time));
6693                 if (instance->adapterresetinprogress) {
6694                         cmd->drv_pkt_time = (uint16_t)debug_timeout_g;
6695                         con_log(CL_ANN1, (CE_NOTE, "Reset the scsi_pkt timer"));
6696                 } else {
6697                         push_pending_mfi_pkt(instance, cmd);
6698                 }
6699 
6700         } else {
6701                 con_log(CL_DLEVEL1, (CE_NOTE, "%llx : issue_cmd_ppc:"
6702                     "ISSUED CMD TO FW : called : cmd : %p, instance: %p"
6703                     "(NO PKT)\n", gethrtime(), (void *)cmd, (void *)instance));
6704         }
6705 
6706         mutex_enter(&instance->reg_write_mtx);
6707         /* Issue the command to the FW */
6708         WR_IB_PICK_QPORT((cmd->frame_phys_addr) |
6709             (((cmd->frame_count - 1) << 1) | 1), instance);
6710         mutex_exit(&instance->reg_write_mtx);
6711 
6712 }
6713 
6714 /*
6715  * issue_cmd_in_sync_mode
6716  */
6717 static int
6718 issue_cmd_in_sync_mode_ppc(struct mrsas_instance *instance,
6719     struct mrsas_cmd *cmd)
6720 {
6721         int     i;
6722         uint32_t        msecs = MFI_POLL_TIMEOUT_SECS * MILLISEC;
6723         struct mrsas_header *hdr = &cmd->frame->hdr;
6724 
6725         con_log(CL_ANN1, (CE_NOTE, "issue_cmd_in_sync_mode_ppc: called"));
6726 
6727         if (instance->adapterresetinprogress) {
6728                 cmd->drv_pkt_time = ddi_get16(
6729                     cmd->frame_dma_obj.acc_handle, &hdr->timeout);
6730                 if (cmd->drv_pkt_time < debug_timeout_g)
6731                         cmd->drv_pkt_time = (uint16_t)debug_timeout_g;
6732 
6733                 con_log(CL_ANN1, (CE_NOTE, "sync_mode_ppc: "
6734                     "issue and return in reset case\n"));
6735                 WR_IB_PICK_QPORT((cmd->frame_phys_addr) |
6736                     (((cmd->frame_count - 1) << 1) | 1), instance);
6737 
6738                 return (DDI_SUCCESS);
6739         } else {
6740                 con_log(CL_ANN1, (CE_NOTE, "sync_mode_ppc: pushing the pkt\n"));
6741                 push_pending_mfi_pkt(instance, cmd);
6742         }
6743 
6744         cmd->cmd_status      = ENODATA;
6745 
6746         mutex_enter(&instance->reg_write_mtx);
6747         /* Issue the command to the FW */
6748         WR_IB_PICK_QPORT((cmd->frame_phys_addr) |
6749             (((cmd->frame_count - 1) << 1) | 1), instance);
6750         mutex_exit(&instance->reg_write_mtx);
6751 
6752         mutex_enter(&instance->int_cmd_mtx);
6753         for (i = 0; i < msecs && (cmd->cmd_status == ENODATA); i++) {
6754                 cv_wait(&instance->int_cmd_cv, &instance->int_cmd_mtx);
6755         }
6756         mutex_exit(&instance->int_cmd_mtx);
6757 
6758         con_log(CL_ANN1, (CE_NOTE, "issue_cmd_in_sync_mode_ppc: done"));
6759 
6760         if (i < (msecs -1)) {
6761                 return (DDI_SUCCESS);
6762         } else {
6763                 return (DDI_FAILURE);
6764         }
6765 }
6766 
6767 /*
6768  * issue_cmd_in_poll_mode
6769  */
6770 static int
6771 issue_cmd_in_poll_mode_ppc(struct mrsas_instance *instance,
6772     struct mrsas_cmd *cmd)
6773 {
6774         int             i;
6775         uint16_t        flags;
6776         uint32_t        msecs = MFI_POLL_TIMEOUT_SECS * MILLISEC;
6777         struct mrsas_header *frame_hdr;
6778 
6779         con_log(CL_ANN1, (CE_NOTE, "issue_cmd_in_poll_mode_ppc: called"));
6780 
6781         frame_hdr = (struct mrsas_header *)cmd->frame;
6782         ddi_put8(cmd->frame_dma_obj.acc_handle, &frame_hdr->cmd_status,
6783             MFI_CMD_STATUS_POLL_MODE);
6784         flags = ddi_get16(cmd->frame_dma_obj.acc_handle, &frame_hdr->flags);
6785         flags   |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
6786 
6787         ddi_put16(cmd->frame_dma_obj.acc_handle, &frame_hdr->flags, flags);
6788 
6789         /* issue the frame using inbound queue port */
6790         WR_IB_PICK_QPORT((cmd->frame_phys_addr) |
6791             (((cmd->frame_count - 1) << 1) | 1), instance);
6792 
6793         /* wait for cmd_status to change from 0xFF */
6794         for (i = 0; i < msecs && (
6795             ddi_get8(cmd->frame_dma_obj.acc_handle, &frame_hdr->cmd_status)
6796             == MFI_CMD_STATUS_POLL_MODE); i++) {
6797                 drv_usecwait(MILLISEC); /* wait for 1000 usecs */
6798         }
6799 
6800         if (ddi_get8(cmd->frame_dma_obj.acc_handle, &frame_hdr->cmd_status)
6801             == MFI_CMD_STATUS_POLL_MODE) {
6802                 con_log(CL_ANN, (CE_NOTE, "issue_cmd_in_poll_mode: "
6803                     "cmd polling timed out"));
6804                 return (DDI_FAILURE);
6805         }
6806 
6807         return (DDI_SUCCESS);
6808 }
6809 
6810 static void
6811 enable_intr_ppc(struct mrsas_instance *instance)
6812 {
6813         uint32_t        mask;
6814 
6815         con_log(CL_ANN1, (CE_NOTE, "enable_intr_ppc: called"));
6816 
6817         if (instance->skinny) {
6818                 /* For SKINNY, write ~0x1, from BSD's mfi driver. */
6819                 WR_OB_INTR_MASK(0xfffffffe, instance);
6820         } else {
6821                 /* WR_OB_DOORBELL_CLEAR(0xFFFFFFFF, instance); */
6822                 WR_OB_DOORBELL_CLEAR(OB_DOORBELL_CLEAR_MASK, instance);
6823 
6824                 /* WR_OB_INTR_MASK(~0x80000000, instance); */
6825                 WR_OB_INTR_MASK(~(MFI_REPLY_2108_MESSAGE_INTR_MASK), instance);
6826         }
6827 
6828         /* dummy read to force PCI flush */
6829         mask = RD_OB_INTR_MASK(instance);
6830 
6831         con_log(CL_ANN1, (CE_NOTE, "enable_intr_ppc: "
6832             "outbound_intr_mask = 0x%x", mask));
6833 }
6834 
6835 static void
6836 disable_intr_ppc(struct mrsas_instance *instance)
6837 {
6838         con_log(CL_ANN1, (CE_NOTE, "disable_intr_ppc: called"));
6839 
6840         con_log(CL_ANN1, (CE_NOTE, "disable_intr_ppc: before : "
6841             "outbound_intr_mask = 0x%x", RD_OB_INTR_MASK(instance)));
6842 
6843         /* For now, assume there are no extras needed for Skinny support. */
6844 
6845         WR_OB_INTR_MASK(OB_INTR_MASK, instance);
6846 
6847         con_log(CL_ANN1, (CE_NOTE, "disable_intr_ppc: after : "
6848             "outbound_intr_mask = 0x%x", RD_OB_INTR_MASK(instance)));
6849 
6850         /* dummy read to force PCI flush */
6851         (void) RD_OB_INTR_MASK(instance);
6852 }
6853 
6854 static int
6855 intr_ack_ppc(struct mrsas_instance *instance)
6856 {
6857         uint32_t        status;
6858         int ret = DDI_INTR_CLAIMED;
6859 
6860         con_log(CL_ANN1, (CE_NOTE, "intr_ack_ppc: called"));
6861 
6862         /* check if it is our interrupt */
6863         status = RD_OB_INTR_STATUS(instance);
6864 
6865         con_log(CL_ANN1, (CE_NOTE, "intr_ack_ppc: status = 0x%x", status));
6866 
6867         /*
6868          * NOTE:  Some drivers call out SKINNY here, but the return is the same
6869          * for SKINNY and 2108.
6870          */
6871         if (!(status & MFI_REPLY_2108_MESSAGE_INTR)) {
6872                 ret = DDI_INTR_UNCLAIMED;
6873         }
6874 
6875         if (mrsas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
6876                 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
6877                 ret = DDI_INTR_UNCLAIMED;
6878         }
6879 
6880         if (ret == DDI_INTR_UNCLAIMED) {
6881                 return (ret);
6882         }
6883 
6884         /*
6885          * Clear the interrupt by writing back the same value.
6886          * Another case where SKINNY is slightly different.
6887          */
6888         if (instance->skinny) {
6889                 WR_OB_INTR_STATUS(status, instance);
6890         } else {
6891                 WR_OB_DOORBELL_CLEAR(status, instance);
6892         }
6893 
6894         /* dummy READ */
6895         status = RD_OB_INTR_STATUS(instance);
6896 
6897         con_log(CL_ANN1, (CE_NOTE, "intr_ack_ppc: interrupt cleared"));
6898 
6899         return (ret);
6900 }
6901 
6902 /*
6903  * Marks HBA as bad. This will be called either when an
6904  * IO packet times out even after 3 FW resets
6905  * or FW is found to be fault even after 3 continuous resets.
6906  */
6907 
6908 static int
6909 mrsas_kill_adapter(struct mrsas_instance *instance)
6910 {
6911         if (instance->deadadapter == 1)
6912                 return (DDI_FAILURE);
6913 
6914         con_log(CL_ANN1, (CE_NOTE, "mrsas_kill_adapter: "
6915             "Writing to doorbell with MFI_STOP_ADP "));
6916         mutex_enter(&instance->ocr_flags_mtx);
6917         instance->deadadapter = 1;
6918         mutex_exit(&instance->ocr_flags_mtx);
6919         instance->func_ptr->disable_intr(instance);
6920         WR_IB_DOORBELL(MFI_STOP_ADP, instance);
6921         (void) mrsas_complete_pending_cmds(instance);
6922         return (DDI_SUCCESS);
6923 }
6924 
6925 
6926 static int
6927 mrsas_reset_ppc(struct mrsas_instance *instance)
6928 {
6929         uint32_t status;
6930         uint32_t retry = 0;
6931         uint32_t cur_abs_reg_val;
6932         uint32_t fw_state;
6933 
6934         con_log(CL_ANN, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));
6935 
6936         if (instance->deadadapter == 1) {
6937                 dev_err(instance->dip, CE_WARN, "mrsas_reset_ppc: "
6938                     "no more resets as HBA has been marked dead ");
6939                 return (DDI_FAILURE);
6940         }
6941         mutex_enter(&instance->ocr_flags_mtx);
6942         instance->adapterresetinprogress = 1;
6943         mutex_exit(&instance->ocr_flags_mtx);
6944         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: adpterresetinprogress "
6945             "flag set, time %llx", gethrtime()));
6946 
6947         instance->func_ptr->disable_intr(instance);
6948 retry_reset:
6949         WR_IB_WRITE_SEQ(0, instance);
6950         WR_IB_WRITE_SEQ(4, instance);
6951         WR_IB_WRITE_SEQ(0xb, instance);
6952         WR_IB_WRITE_SEQ(2, instance);
6953         WR_IB_WRITE_SEQ(7, instance);
6954         WR_IB_WRITE_SEQ(0xd, instance);
6955         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: magic number written "
6956             "to write sequence register\n"));
6957         delay(100 * drv_usectohz(MILLISEC));
6958         status = RD_OB_DRWE(instance);
6959 
6960         while (!(status & DIAG_WRITE_ENABLE)) {
6961                 delay(100 * drv_usectohz(MILLISEC));
6962                 status = RD_OB_DRWE(instance);
6963                 if (retry++ == 100) {
6964                         dev_err(instance->dip, CE_WARN,
6965                             "mrsas_reset_ppc: DRWE bit "
6966                             "check retry count %d", retry);
6967                         return (DDI_FAILURE);
6968                 }
6969         }
6970         WR_IB_DRWE(status | DIAG_RESET_ADAPTER, instance);
6971         delay(100 * drv_usectohz(MILLISEC));
6972         status = RD_OB_DRWE(instance);
6973         while (status & DIAG_RESET_ADAPTER) {
6974                 delay(100 * drv_usectohz(MILLISEC));
6975                 status = RD_OB_DRWE(instance);
6976                 if (retry++ == 100) {
6977                         dev_err(instance->dip, CE_WARN, "mrsas_reset_ppc: "
6978                             "RESET FAILED. KILL adapter called.");
6979 
6980                         (void) mrsas_kill_adapter(instance);
6981                         return (DDI_FAILURE);
6982                 }
6983         }
6984         con_log(CL_ANN, (CE_NOTE, "mrsas_reset_ppc: Adapter reset complete"));
6985         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: "
6986             "Calling mfi_state_transition_to_ready"));
6987 
6988         /* Mark HBA as bad, if FW is fault after 3 continuous resets */
6989         if (mfi_state_transition_to_ready(instance) ||
6990             debug_fw_faults_after_ocr_g == 1) {
6991                 cur_abs_reg_val =
6992                     instance->func_ptr->read_fw_status_reg(instance);
6993                 fw_state        = cur_abs_reg_val & MFI_STATE_MASK;
6994 
6995 #ifdef OCRDEBUG
6996                 con_log(CL_ANN1, (CE_NOTE,
6997                     "mrsas_reset_ppc :before fake: FW is not ready "
6998                     "FW state = 0x%x", fw_state));
6999                 if (debug_fw_faults_after_ocr_g == 1)
7000                         fw_state = MFI_STATE_FAULT;
7001 #endif
7002 
7003                 con_log(CL_ANN1, (CE_NOTE,  "mrsas_reset_ppc : FW is not ready "
7004                     "FW state = 0x%x", fw_state));
7005 
7006                 if (fw_state == MFI_STATE_FAULT) {
7007                         /* increment the count */
7008                         instance->fw_fault_count_after_ocr++;
7009                         if (instance->fw_fault_count_after_ocr
7010                             < MAX_FW_RESET_COUNT) {
7011                                 dev_err(instance->dip, CE_WARN,
7012                                     "mrsas_reset_ppc: "
7013                                     "FW is in fault after OCR count %d "
7014                                     "Retry Reset",
7015                                     instance->fw_fault_count_after_ocr);
7016                                 goto retry_reset;
7017 
7018                         } else {
7019                                 dev_err(instance->dip, CE_WARN,
7020                                     "mrsas_reset_ppc: "
7021                                     "Max Reset Count exceeded >%d"
7022                                     "Mark HBA as bad, KILL adapter",
7023                                     MAX_FW_RESET_COUNT);
7024 
7025                                 (void) mrsas_kill_adapter(instance);
7026                                 return (DDI_FAILURE);
7027                         }
7028                 }
7029         }
7030         /* reset the counter as FW is up after OCR */
7031         instance->fw_fault_count_after_ocr = 0;
7032 
7033 
7034         ddi_put32(instance->mfi_internal_dma_obj.acc_handle,
7035             instance->producer, 0);
7036 
7037         ddi_put32(instance->mfi_internal_dma_obj.acc_handle,
7038             instance->consumer, 0);
7039 
7040         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: "
7041             " after resetting produconsumer chck indexs:"
7042             "producer %x consumer %x", *instance->producer,
7043             *instance->consumer));
7044 
7045         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: "
7046             "Calling mrsas_issue_init_mfi"));
7047         (void) mrsas_issue_init_mfi(instance);
7048         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: "
7049             "mrsas_issue_init_mfi Done"));
7050 
7051         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: "
7052             "Calling mrsas_print_pending_cmd\n"));
7053         (void) mrsas_print_pending_cmds(instance);
7054         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: "
7055             "mrsas_print_pending_cmd done\n"));
7056 
7057         instance->func_ptr->enable_intr(instance);
7058         instance->fw_outstanding = 0;
7059 
7060         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: "
7061             "Calling mrsas_issue_pending_cmds"));
7062         (void) mrsas_issue_pending_cmds(instance);
7063         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: "
7064             "issue_pending_cmds done.\n"));
7065 
7066         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: "
7067             "Calling aen registration"));
7068 
7069 
7070         instance->aen_cmd->retry_count_for_ocr = 0;
7071         instance->aen_cmd->drv_pkt_time = 0;
7072 
7073         instance->func_ptr->issue_cmd(instance->aen_cmd, instance);
7074         con_log(CL_ANN1, (CE_NOTE, "Unsetting adpresetinprogress flag.\n"));
7075 
7076         mutex_enter(&instance->ocr_flags_mtx);
7077         instance->adapterresetinprogress = 0;
7078         mutex_exit(&instance->ocr_flags_mtx);
7079         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc: "
7080             "adpterresetinprogress flag unset"));
7081 
7082         con_log(CL_ANN1, (CE_NOTE, "mrsas_reset_ppc done\n"));
7083         return (DDI_SUCCESS);
7084 }
7085 
7086 /*
7087  * FMA functions.
7088  */
7089 int
7090 mrsas_common_check(struct mrsas_instance *instance, struct  mrsas_cmd *cmd)
7091 {
7092         int ret = DDI_SUCCESS;
7093 
7094         if (cmd != NULL &&
7095             mrsas_check_dma_handle(cmd->frame_dma_obj.dma_handle) !=
7096             DDI_SUCCESS) {
7097                 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
7098                 if (cmd->pkt != NULL) {
7099                         cmd->pkt->pkt_reason = CMD_TRAN_ERR;
7100                         cmd->pkt->pkt_statistics = 0;
7101                 }
7102                 ret = DDI_FAILURE;
7103         }
7104         if (mrsas_check_dma_handle(instance->mfi_internal_dma_obj.dma_handle)
7105             != DDI_SUCCESS) {
7106                 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
7107                 if (cmd != NULL && cmd->pkt != NULL) {
7108                         cmd->pkt->pkt_reason = CMD_TRAN_ERR;
7109                         cmd->pkt->pkt_statistics = 0;
7110                 }
7111                 ret = DDI_FAILURE;
7112         }
7113         if (mrsas_check_dma_handle(instance->mfi_evt_detail_obj.dma_handle) !=
7114             DDI_SUCCESS) {
7115                 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
7116                 if (cmd != NULL && cmd->pkt != NULL) {
7117                         cmd->pkt->pkt_reason = CMD_TRAN_ERR;
7118                         cmd->pkt->pkt_statistics = 0;
7119                 }
7120                 ret = DDI_FAILURE;
7121         }
7122         if (mrsas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
7123                 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
7124 
7125                 ddi_fm_acc_err_clear(instance->regmap_handle, DDI_FME_VER0);
7126 
7127                 if (cmd != NULL && cmd->pkt != NULL) {
7128                         cmd->pkt->pkt_reason = CMD_TRAN_ERR;
7129                         cmd->pkt->pkt_statistics = 0;
7130                 }
7131                 ret = DDI_FAILURE;
7132         }
7133 
7134         return (ret);
7135 }
7136 
7137 /*ARGSUSED*/
7138 static int
7139 mrsas_fm_error_cb(dev_info_t *dip, ddi_fm_error_t *err, const void *impl_data)
7140 {
7141         /*
7142          * as the driver can always deal with an error in any dma or
7143          * access handle, we can just return the fme_status value.
7144          */
7145         pci_ereport_post(dip, err, NULL);
7146         return (err->fme_status);
7147 }
7148 
7149 static void
7150 mrsas_fm_init(struct mrsas_instance *instance)
7151 {
7152         /* Need to change iblock to priority for new MSI intr */
7153         ddi_iblock_cookie_t fm_ibc;
7154 
7155         /* Only register with IO Fault Services if we have some capability */
7156         if (instance->fm_capabilities) {
7157                 /* Adjust access and dma attributes for FMA */
7158                 endian_attr.devacc_attr_access = DDI_FLAGERR_ACC;
7159                 mrsas_generic_dma_attr.dma_attr_flags = DDI_DMA_FLAGERR;
7160 
7161                 /*
7162                  * Register capabilities with IO Fault Services.
7163                  * fm_capabilities will be updated to indicate
7164                  * capabilities actually supported (not requested.)
7165                  */
7166 
7167                 ddi_fm_init(instance->dip, &instance->fm_capabilities, &fm_ibc);
7168 
7169                 /*
7170                  * Initialize pci ereport capabilities if ereport
7171                  * capable (should always be.)
7172                  */
7173 
7174                 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities) ||
7175                     DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
7176                         pci_ereport_setup(instance->dip);
7177                 }
7178 
7179                 /*
7180                  * Register error callback if error callback capable.
7181                  */
7182                 if (DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
7183                         ddi_fm_handler_register(instance->dip,
7184                             mrsas_fm_error_cb, (void*) instance);
7185                 }
7186         } else {
7187                 endian_attr.devacc_attr_access = DDI_DEFAULT_ACC;
7188                 mrsas_generic_dma_attr.dma_attr_flags = 0;
7189         }
7190 }
7191 
7192 static void
7193 mrsas_fm_fini(struct mrsas_instance *instance)
7194 {
7195         /* Only unregister FMA capabilities if registered */
7196         if (instance->fm_capabilities) {
7197                 /*
7198                  * Un-register error callback if error callback capable.
7199                  */
7200                 if (DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
7201                         ddi_fm_handler_unregister(instance->dip);
7202                 }
7203 
7204                 /*
7205                  * Release any resources allocated by pci_ereport_setup()
7206                  */
7207                 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities) ||
7208                     DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
7209                         pci_ereport_teardown(instance->dip);
7210                 }
7211 
7212                 /* Unregister from IO Fault Services */
7213                 ddi_fm_fini(instance->dip);
7214 
7215                 /* Adjust access and dma attributes for FMA */
7216                 endian_attr.devacc_attr_access = DDI_DEFAULT_ACC;
7217                 mrsas_generic_dma_attr.dma_attr_flags = 0;
7218         }
7219 }
7220 
7221 int
7222 mrsas_check_acc_handle(ddi_acc_handle_t handle)
7223 {
7224         ddi_fm_error_t de;
7225 
7226         if (handle == NULL) {
7227                 return (DDI_FAILURE);
7228         }
7229 
7230         ddi_fm_acc_err_get(handle, &de, DDI_FME_VERSION);
7231 
7232         return (de.fme_status);
7233 }
7234 
7235 int
7236 mrsas_check_dma_handle(ddi_dma_handle_t handle)
7237 {
7238         ddi_fm_error_t de;
7239 
7240         if (handle == NULL) {
7241                 return (DDI_FAILURE);
7242         }
7243 
7244         ddi_fm_dma_err_get(handle, &de, DDI_FME_VERSION);
7245 
7246         return (de.fme_status);
7247 }
7248 
7249 void
7250 mrsas_fm_ereport(struct mrsas_instance *instance, char *detail)
7251 {
7252         uint64_t ena;
7253         char buf[FM_MAX_CLASS];
7254 
7255         (void) snprintf(buf, FM_MAX_CLASS, "%s.%s", DDI_FM_DEVICE, detail);
7256         ena = fm_ena_generate(0, FM_ENA_FMT1);
7257         if (DDI_FM_EREPORT_CAP(instance->fm_capabilities)) {
7258                 ddi_fm_ereport_post(instance->dip, buf, ena, DDI_NOSLEEP,
7259                     FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERSION, NULL);
7260         }
7261 }
7262 
7263 static int
7264 mrsas_add_intrs(struct mrsas_instance *instance, int intr_type)
7265 {
7266 
7267         dev_info_t *dip = instance->dip;
7268         int     avail, actual, count;
7269         int     i, flag, ret;
7270 
7271         con_log(CL_DLEVEL1, (CE_NOTE, "mrsas_add_intrs: intr_type = %x",
7272             intr_type));
7273 
7274         /* Get number of interrupts */
7275         ret = ddi_intr_get_nintrs(dip, intr_type, &count);
7276         if ((ret != DDI_SUCCESS) || (count == 0)) {
7277                 con_log(CL_ANN, (CE_WARN, "ddi_intr_get_nintrs() failed:"
7278                     "ret %d count %d", ret, count));
7279 
7280                 return (DDI_FAILURE);
7281         }
7282 
7283         con_log(CL_DLEVEL1, (CE_NOTE, "mrsas_add_intrs: count = %d ", count));
7284 
7285         /* Get number of available interrupts */
7286         ret = ddi_intr_get_navail(dip, intr_type, &avail);
7287         if ((ret != DDI_SUCCESS) || (avail == 0)) {
7288                 con_log(CL_ANN, (CE_WARN, "ddi_intr_get_navail() failed:"
7289                     "ret %d avail %d", ret, avail));
7290 
7291                 return (DDI_FAILURE);
7292         }
7293         con_log(CL_DLEVEL1, (CE_NOTE, "mrsas_add_intrs: avail = %d ", avail));
7294 
7295         /* Only one interrupt routine. So limit the count to 1 */
7296         if (count > 1) {
7297                 count = 1;
7298         }
7299 
7300         /*
7301          * Allocate an array of interrupt handlers. Currently we support
7302          * only one interrupt. The framework can be extended later.
7303          */
7304         instance->intr_htable_size = count * sizeof (ddi_intr_handle_t);
7305         instance->intr_htable = kmem_zalloc(instance->intr_htable_size,
7306             KM_SLEEP);
7307         ASSERT(instance->intr_htable);
7308 
7309         flag = ((intr_type == DDI_INTR_TYPE_MSI) ||
7310             (intr_type == DDI_INTR_TYPE_MSIX)) ?
7311             DDI_INTR_ALLOC_STRICT : DDI_INTR_ALLOC_NORMAL;
7312 
7313         /* Allocate interrupt */
7314         ret = ddi_intr_alloc(dip, instance->intr_htable, intr_type, 0,
7315             count, &actual, flag);
7316 
7317         if ((ret != DDI_SUCCESS) || (actual == 0)) {
7318                 con_log(CL_ANN, (CE_WARN, "mrsas_add_intrs: "
7319                     "avail = %d", avail));
7320                 goto mrsas_free_htable;
7321         }
7322 
7323         if (actual < count) {
7324                 con_log(CL_ANN, (CE_WARN, "mrsas_add_intrs: "
7325                     "Requested = %d  Received = %d", count, actual));
7326         }
7327         instance->intr_cnt = actual;
7328 
7329         /*
7330          * Get the priority of the interrupt allocated.
7331          */
7332         if ((ret = ddi_intr_get_pri(instance->intr_htable[0],
7333             &instance->intr_pri)) != DDI_SUCCESS) {
7334                 con_log(CL_ANN, (CE_WARN, "mrsas_add_intrs: "
7335                     "get priority call failed"));
7336                 goto mrsas_free_handles;
7337         }
7338 
7339         /*
7340          * Test for high level mutex. we don't support them.
7341          */
7342         if (instance->intr_pri >= ddi_intr_get_hilevel_pri()) {
7343                 con_log(CL_ANN, (CE_WARN, "mrsas_add_intrs: "
7344                     "High level interrupts not supported."));
7345                 goto mrsas_free_handles;
7346         }
7347 
7348         con_log(CL_DLEVEL1, (CE_NOTE, "mrsas_add_intrs: intr_pri = 0x%x ",
7349             instance->intr_pri));
7350 
7351         /* Call ddi_intr_add_handler() */
7352         for (i = 0; i < actual; i++) {
7353                 ret = ddi_intr_add_handler(instance->intr_htable[i],
7354                     (ddi_intr_handler_t *)mrsas_isr, (caddr_t)instance,
7355                     (caddr_t)(uintptr_t)i);
7356 
7357                 if (ret != DDI_SUCCESS) {
7358                         con_log(CL_ANN, (CE_WARN, "mrsas_add_intrs:"
7359                             "failed %d", ret));
7360                         goto mrsas_free_handles;
7361                 }
7362 
7363         }
7364 
7365         con_log(CL_DLEVEL1, (CE_NOTE, " ddi_intr_add_handler done"));
7366 
7367         if ((ret = ddi_intr_get_cap(instance->intr_htable[0],
7368             &instance->intr_cap)) != DDI_SUCCESS) {
7369                 con_log(CL_ANN, (CE_WARN, "ddi_intr_get_cap() failed %d",
7370                     ret));
7371                 goto mrsas_free_handlers;
7372         }
7373 
7374         if (instance->intr_cap &  DDI_INTR_FLAG_BLOCK) {
7375                 con_log(CL_ANN, (CE_WARN, "Calling ddi_intr_block _enable"));
7376 
7377                 (void) ddi_intr_block_enable(instance->intr_htable,
7378                     instance->intr_cnt);
7379         } else {
7380                 con_log(CL_ANN, (CE_NOTE, " calling ddi_intr_enable"));
7381 
7382                 for (i = 0; i < instance->intr_cnt; i++) {
7383                         (void) ddi_intr_enable(instance->intr_htable[i]);
7384                         con_log(CL_ANN, (CE_NOTE, "ddi intr enable returns "
7385                             "%d", i));
7386                 }
7387         }
7388 
7389         return (DDI_SUCCESS);
7390 
7391 mrsas_free_handlers:
7392         for (i = 0; i < actual; i++)
7393                 (void) ddi_intr_remove_handler(instance->intr_htable[i]);
7394 
7395 mrsas_free_handles:
7396         for (i = 0; i < actual; i++)
7397                 (void) ddi_intr_free(instance->intr_htable[i]);
7398 
7399 mrsas_free_htable:
7400         if (instance->intr_htable != NULL)
7401                 kmem_free(instance->intr_htable, instance->intr_htable_size);
7402 
7403         instance->intr_htable = NULL;
7404         instance->intr_htable_size = 0;
7405 
7406         return (DDI_FAILURE);
7407 
7408 }
7409 
7410 
7411 static void
7412 mrsas_rem_intrs(struct mrsas_instance *instance)
7413 {
7414         int i;
7415 
7416         con_log(CL_ANN, (CE_NOTE, "mrsas_rem_intrs called"));
7417 
7418         /* Disable all interrupts first */
7419         if (instance->intr_cap & DDI_INTR_FLAG_BLOCK) {
7420                 (void) ddi_intr_block_disable(instance->intr_htable,
7421                     instance->intr_cnt);
7422         } else {
7423                 for (i = 0; i < instance->intr_cnt; i++) {
7424                         (void) ddi_intr_disable(instance->intr_htable[i]);
7425                 }
7426         }
7427 
7428         /* Remove all the handlers */
7429 
7430         for (i = 0; i < instance->intr_cnt; i++) {
7431                 (void) ddi_intr_remove_handler(instance->intr_htable[i]);
7432                 (void) ddi_intr_free(instance->intr_htable[i]);
7433         }
7434 
7435         if (instance->intr_htable != NULL)
7436                 kmem_free(instance->intr_htable, instance->intr_htable_size);
7437 
7438         instance->intr_htable = NULL;
7439         instance->intr_htable_size = 0;
7440 
7441 }
7442 
7443 static int
7444 mrsas_tran_bus_config(dev_info_t *parent, uint_t flags,
7445     ddi_bus_config_op_t op, void *arg, dev_info_t **childp)
7446 {
7447         struct mrsas_instance *instance;
7448         int config;
7449         int rval  = NDI_SUCCESS;
7450 
7451         char *ptr = NULL;
7452         int tgt, lun;
7453 
7454         con_log(CL_ANN1, (CE_NOTE, "Bus config called for op = %x", op));
7455 
7456         if ((instance = ddi_get_soft_state(mrsas_state,
7457             ddi_get_instance(parent))) == NULL) {
7458                 return (NDI_FAILURE);
7459         }
7460 
7461         /* Hold nexus during bus_config */
7462         ndi_devi_enter(parent, &config);
7463         switch (op) {
7464         case BUS_CONFIG_ONE: {
7465 
7466                 /* parse wwid/target name out of name given */
7467                 if ((ptr = strchr((char *)arg, '@')) == NULL) {
7468                         rval = NDI_FAILURE;
7469                         break;
7470                 }
7471                 ptr++;
7472 
7473                 if (mrsas_parse_devname(arg, &tgt, &lun) != 0) {
7474                         rval = NDI_FAILURE;
7475                         break;
7476                 }
7477 
7478                 if (lun == 0) {
7479                         rval = mrsas_config_ld(instance, tgt, lun, childp);
7480                 } else if ((instance->tbolt || instance->skinny) && lun != 0) {
7481                         rval = mrsas_tbolt_config_pd(instance,
7482                             tgt, lun, childp);
7483                 } else {
7484                         rval = NDI_FAILURE;
7485                 }
7486 
7487                 break;
7488         }
7489         case BUS_CONFIG_DRIVER:
7490         case BUS_CONFIG_ALL: {
7491 
7492                 rval = mrsas_config_all_devices(instance);
7493 
7494                 rval = NDI_SUCCESS;
7495                 break;
7496         }
7497         }
7498 
7499         if (rval == NDI_SUCCESS) {
7500                 rval = ndi_busop_bus_config(parent, flags, op, arg, childp, 0);
7501 
7502         }
7503         ndi_devi_exit(parent, config);
7504 
7505         con_log(CL_ANN1, (CE_NOTE, "mrsas_tran_bus_config: rval = %x",
7506             rval));
7507         return (rval);
7508 }
7509 
7510 static int
7511 mrsas_config_all_devices(struct mrsas_instance *instance)
7512 {
7513         int rval, tgt;
7514 
7515         for (tgt = 0; tgt < MRDRV_MAX_LD; tgt++) {
7516                 (void) mrsas_config_ld(instance, tgt, 0, NULL);
7517 
7518         }
7519 
7520         /* Config PD devices connected to the card */
7521         if (instance->tbolt || instance->skinny) {
7522                 for (tgt = 0; tgt < instance->mr_tbolt_pd_max; tgt++) {
7523                         (void) mrsas_tbolt_config_pd(instance, tgt, 1, NULL);
7524                 }
7525         }
7526 
7527         rval = NDI_SUCCESS;
7528         return (rval);
7529 }
7530 
7531 static int
7532 mrsas_parse_devname(char *devnm, int *tgt, int *lun)
7533 {
7534         char devbuf[SCSI_MAXNAMELEN];
7535         char *addr;
7536         char *p,  *tp, *lp;
7537         long num;
7538 
7539         /* Parse dev name and address */
7540         (void) strcpy(devbuf, devnm);
7541         addr = "";
7542         for (p = devbuf; *p != '\0'; p++) {
7543                 if (*p == '@') {
7544                         addr = p + 1;
7545                         *p = '\0';
7546                 } else if (*p == ':') {
7547                         *p = '\0';
7548                         break;
7549                 }
7550         }
7551 
7552         /* Parse target and lun */
7553         for (p = tp = addr, lp = NULL; *p != '\0'; p++) {
7554                 if (*p == ',') {
7555                         lp = p + 1;
7556                         *p = '\0';
7557                         break;
7558                 }
7559         }
7560         if (tgt && tp) {
7561                 if (ddi_strtol(tp, NULL, 0x10, &num)) {
7562                         return (DDI_FAILURE); /* Can declare this as constant */
7563                 }
7564                         *tgt = (int)num;
7565         }
7566         if (lun && lp) {
7567                 if (ddi_strtol(lp, NULL, 0x10, &num)) {
7568                         return (DDI_FAILURE);
7569                 }
7570                         *lun = (int)num;
7571         }
7572         return (DDI_SUCCESS);  /* Success case */
7573 }
7574 
7575 static int
7576 mrsas_config_ld(struct mrsas_instance *instance, uint16_t tgt,
7577     uint8_t lun, dev_info_t **ldip)
7578 {
7579         struct scsi_device *sd;
7580         dev_info_t *child;
7581         int rval;
7582 
7583         con_log(CL_DLEVEL1, (CE_NOTE, "mrsas_config_ld: t = %d l = %d",
7584             tgt, lun));
7585 
7586         if ((child = mrsas_find_child(instance, tgt, lun)) != NULL) {
7587                 if (ldip) {
7588                         *ldip = child;
7589                 }
7590                 if (instance->mr_ld_list[tgt].flag != MRDRV_TGT_VALID) {
7591                         rval = mrsas_service_evt(instance, tgt, 0,
7592                             MRSAS_EVT_UNCONFIG_TGT, NULL);
7593                         con_log(CL_ANN1, (CE_WARN,
7594                             "mr_sas: DELETING STALE ENTRY rval = %d "
7595                             "tgt id = %d ", rval, tgt));
7596                         return (NDI_FAILURE);
7597                 }
7598                 return (NDI_SUCCESS);
7599         }
7600 
7601         sd = kmem_zalloc(sizeof (struct scsi_device), KM_SLEEP);
7602         sd->sd_address.a_hba_tran = instance->tran;
7603         sd->sd_address.a_target = (uint16_t)tgt;
7604         sd->sd_address.a_lun = (uint8_t)lun;
7605 
7606         if (scsi_hba_probe(sd, NULL) == SCSIPROBE_EXISTS)
7607                 rval = mrsas_config_scsi_device(instance, sd, ldip);
7608         else
7609                 rval = NDI_FAILURE;
7610 
7611         /* sd_unprobe is blank now. Free buffer manually */
7612         if (sd->sd_inq) {
7613                 kmem_free(sd->sd_inq, SUN_INQSIZE);
7614                 sd->sd_inq = (struct scsi_inquiry *)NULL;
7615         }
7616 
7617         kmem_free(sd, sizeof (struct scsi_device));
7618         con_log(CL_DLEVEL1, (CE_NOTE, "mrsas_config_ld: return rval = %d",
7619             rval));
7620         return (rval);
7621 }
7622 
7623 int
7624 mrsas_config_scsi_device(struct mrsas_instance *instance,
7625     struct scsi_device *sd, dev_info_t **dipp)
7626 {
7627         char *nodename = NULL;
7628         char **compatible = NULL;
7629         int ncompatible = 0;
7630         char *childname;
7631         dev_info_t *ldip = NULL;
7632         int tgt = sd->sd_address.a_target;
7633         int lun = sd->sd_address.a_lun;
7634         int dtype = sd->sd_inq->inq_dtype & DTYPE_MASK;
7635         int rval;
7636 
7637         con_log(CL_DLEVEL1, (CE_NOTE, "mr_sas: scsi_device t%dL%d", tgt, lun));
7638         scsi_hba_nodename_compatible_get(sd->sd_inq, NULL, dtype,
7639             NULL, &nodename, &compatible, &ncompatible);
7640 
7641         if (nodename == NULL) {
7642                 con_log(CL_ANN1, (CE_WARN, "mr_sas: Found no compatible driver "
7643                     "for t%dL%d", tgt, lun));
7644                 rval = NDI_FAILURE;
7645                 goto finish;
7646         }
7647 
7648         childname = (dtype == DTYPE_DIRECT) ? "sd" : nodename;
7649         con_log(CL_DLEVEL1, (CE_NOTE,
7650             "mr_sas: Childname = %2s nodename = %s", childname, nodename));
7651 
7652         /* Create a dev node */
7653         rval = ndi_devi_alloc(instance->dip, childname, DEVI_SID_NODEID, &ldip);
7654         con_log(CL_DLEVEL1, (CE_NOTE,
7655             "mr_sas_config_scsi_device: ndi_devi_alloc rval = %x", rval));
7656         if (rval == NDI_SUCCESS) {
7657                 if (ndi_prop_update_int(DDI_DEV_T_NONE, ldip, "target", tgt) !=
7658                     DDI_PROP_SUCCESS) {
7659                         con_log(CL_ANN1, (CE_WARN, "mr_sas: unable to create "
7660                             "property for t%dl%d target", tgt, lun));
7661                         rval = NDI_FAILURE;
7662                         goto finish;
7663                 }
7664                 if (ndi_prop_update_int(DDI_DEV_T_NONE, ldip, "lun", lun) !=
7665                     DDI_PROP_SUCCESS) {
7666                         con_log(CL_ANN1, (CE_WARN, "mr_sas: unable to create "
7667                             "property for t%dl%d lun", tgt, lun));
7668                         rval = NDI_FAILURE;
7669                         goto finish;
7670                 }
7671 
7672                 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, ldip,
7673                     "compatible", compatible, ncompatible) !=
7674                     DDI_PROP_SUCCESS) {
7675                         con_log(CL_ANN1, (CE_WARN, "mr_sas: unable to create "
7676                             "property for t%dl%d compatible", tgt, lun));
7677                         rval = NDI_FAILURE;
7678                         goto finish;
7679                 }
7680 
7681                 rval = ndi_devi_online(ldip, NDI_ONLINE_ATTACH);
7682                 if (rval != NDI_SUCCESS) {
7683                         con_log(CL_ANN1, (CE_WARN, "mr_sas: unable to online "
7684                             "t%dl%d", tgt, lun));
7685                         ndi_prop_remove_all(ldip);
7686                         (void) ndi_devi_free(ldip);
7687                 } else {
7688                         con_log(CL_ANN1, (CE_CONT, "mr_sas: online Done :"
7689                             "0 t%dl%d", tgt, lun));
7690                 }
7691 
7692         }
7693 finish:
7694         if (dipp) {
7695                 *dipp = ldip;
7696         }
7697 
7698         con_log(CL_DLEVEL1, (CE_NOTE,
7699             "mr_sas: config_scsi_device rval = %d t%dL%d",
7700             rval, tgt, lun));
7701         scsi_hba_nodename_compatible_free(nodename, compatible);
7702         return (rval);
7703 }
7704 
7705 /*ARGSUSED*/
7706 int
7707 mrsas_service_evt(struct mrsas_instance *instance, int tgt, int lun, int event,
7708     uint64_t wwn)
7709 {
7710         struct mrsas_eventinfo *mrevt = NULL;
7711 
7712         con_log(CL_ANN1, (CE_NOTE,
7713             "mrsas_service_evt called for t%dl%d event = %d",
7714             tgt, lun, event));
7715 
7716         if ((instance->taskq == NULL) || (mrevt =
7717             kmem_zalloc(sizeof (struct mrsas_eventinfo), KM_NOSLEEP)) == NULL) {
7718                 return (ENOMEM);
7719         }
7720 
7721         mrevt->instance = instance;
7722         mrevt->tgt = tgt;
7723         mrevt->lun = lun;
7724         mrevt->event = event;
7725         mrevt->wwn = wwn;
7726 
7727         if ((ddi_taskq_dispatch(instance->taskq,
7728             (void (*)(void *))mrsas_issue_evt_taskq, mrevt, DDI_NOSLEEP)) !=
7729             DDI_SUCCESS) {
7730                 con_log(CL_ANN1, (CE_NOTE,
7731                     "mr_sas: Event task failed for t%dl%d event = %d",
7732                     tgt, lun, event));
7733                 kmem_free(mrevt, sizeof (struct mrsas_eventinfo));
7734                 return (DDI_FAILURE);
7735         }
7736         DTRACE_PROBE3(service_evt, int, tgt, int, lun, int, event);
7737         return (DDI_SUCCESS);
7738 }
7739 
7740 static void
7741 mrsas_issue_evt_taskq(struct mrsas_eventinfo *mrevt)
7742 {
7743         struct mrsas_instance *instance = mrevt->instance;
7744         dev_info_t *dip;
7745         int circ1 = 0;
7746 
7747         con_log(CL_ANN1, (CE_NOTE, "mrsas_issue_evt_taskq: called for"
7748             " tgt %d lun %d event %d",
7749             mrevt->tgt, mrevt->lun, mrevt->event));
7750 
7751         if (mrevt->tgt < MRDRV_MAX_LD && mrevt->lun == 0) {
7752                 mutex_enter(&instance->config_dev_mtx);
7753                 dip = instance->mr_ld_list[mrevt->tgt].dip;
7754                 mutex_exit(&instance->config_dev_mtx);
7755         } else {
7756                 mutex_enter(&instance->config_dev_mtx);
7757                 dip = instance->mr_tbolt_pd_list[mrevt->tgt].dip;
7758                 mutex_exit(&instance->config_dev_mtx);
7759         }
7760 
7761 
7762         ndi_devi_enter(instance->dip, &circ1);
7763         switch (mrevt->event) {
7764         case MRSAS_EVT_CONFIG_TGT:
7765                 if (dip == NULL) {
7766                         if (mrevt->lun == 0) {
7767                                 (void) mrsas_config_ld(instance, mrevt->tgt,
7768                                     0, NULL);
7769                         } else if (instance->tbolt || instance->skinny) {
7770                                 (void) mrsas_tbolt_config_pd(instance,
7771                                     mrevt->tgt,
7772                                     1, NULL);
7773                         }
7774                         con_log(CL_ANN1, (CE_NOTE,
7775                             "mr_sas: EVT_CONFIG_TGT called:"
7776                             " for tgt %d lun %d event %d",
7777                             mrevt->tgt, mrevt->lun, mrevt->event));
7778                 } else {
7779                         con_log(CL_ANN1, (CE_NOTE,
7780                             "mr_sas: EVT_CONFIG_TGT dip != NULL:"
7781                             " for tgt %d lun %d event %d",
7782                             mrevt->tgt, mrevt->lun, mrevt->event));
7783                 }
7784                 break;
7785         case MRSAS_EVT_UNCONFIG_TGT:
7786                 if (dip) {
7787                         (void) ndi_devi_offline(dip,
7788                             NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE);
7789                         con_log(CL_ANN1, (CE_NOTE,
7790                             "mr_sas: EVT_UNCONFIG_TGT called:"
7791                             " for tgt %d lun %d event %d",
7792                             mrevt->tgt, mrevt->lun, mrevt->event));
7793                 } else {
7794                         con_log(CL_ANN1, (CE_NOTE,
7795                             "mr_sas: EVT_UNCONFIG_TGT dip == NULL:"
7796                             " for tgt %d lun %d event %d",
7797                             mrevt->tgt, mrevt->lun, mrevt->event));
7798                 }
7799                 break;
7800         }
7801         kmem_free(mrevt, sizeof (struct mrsas_eventinfo));
7802         ndi_devi_exit(instance->dip, circ1);
7803 }
7804 
7805 
7806 int
7807 mrsas_mode_sense_build(struct scsi_pkt *pkt)
7808 {
7809         union scsi_cdb          *cdbp;
7810         uint16_t                page_code;
7811         struct scsa_cmd         *acmd;
7812         struct buf              *bp;
7813         struct mode_header      *modehdrp;
7814 
7815         cdbp = (void *)pkt->pkt_cdbp;
7816         page_code = cdbp->cdb_un.sg.scsi[0];
7817         acmd = PKT2CMD(pkt);
7818         bp = acmd->cmd_buf;
7819         if ((!bp) && bp->b_un.b_addr && bp->b_bcount && acmd->cmd_dmacount) {
7820                 con_log(CL_ANN1, (CE_WARN, "Failing MODESENSE Command"));
7821                 /* ADD pkt statistics as Command failed. */
7822                 return (NULL);
7823         }
7824 
7825         bp_mapin(bp);
7826         bzero(bp->b_un.b_addr, bp->b_bcount);
7827 
7828         switch (page_code) {
7829                 case 0x3: {
7830                         struct mode_format *page3p = NULL;
7831                         modehdrp = (struct mode_header *)(bp->b_un.b_addr);
7832                         modehdrp->bdesc_length = MODE_BLK_DESC_LENGTH;
7833 
7834                         page3p = (void *)((caddr_t)modehdrp +
7835                             MODE_HEADER_LENGTH + MODE_BLK_DESC_LENGTH);
7836                         page3p->mode_page.code = 0x3;
7837                         page3p->mode_page.length =
7838                             (uchar_t)(sizeof (struct mode_format));
7839                         page3p->data_bytes_sect = 512;
7840                         page3p->sect_track = 63;
7841                         break;
7842                 }
7843                 case 0x4: {
7844                         struct mode_geometry *page4p = NULL;
7845                         modehdrp = (struct mode_header *)(bp->b_un.b_addr);
7846                         modehdrp->bdesc_length = MODE_BLK_DESC_LENGTH;
7847 
7848                         page4p = (void *)((caddr_t)modehdrp +
7849                             MODE_HEADER_LENGTH + MODE_BLK_DESC_LENGTH);
7850                         page4p->mode_page.code = 0x4;
7851                         page4p->mode_page.length =
7852                             (uchar_t)(sizeof (struct mode_geometry));
7853                         page4p->heads = 255;
7854                         page4p->rpm = 10000;
7855                         break;
7856                 }
7857                 default:
7858                         break;
7859         }
7860         return (NULL);
7861 }