Lines Matching defs:instance
86 #define WR_IB_PICK_QPORT(addr, instance) \
87 if ((instance)->skinny) { \
88 WR_IB_LOW_QPORT((addr), (instance)); \
89 WR_IB_HIGH_QPORT(0, (instance)); \
91 WR_IB_QPORT((addr), (instance)); \
160 static void flush_cache(struct mrsas_instance *instance);
162 static int start_mfi_aen(struct mrsas_instance *instance);
163 static int handle_drv_ioctl(struct mrsas_instance *instance,
165 static int handle_mfi_ioctl(struct mrsas_instance *instance,
167 static int handle_mfi_aen(struct mrsas_instance *instance,
178 static int wait_for_outstanding(struct mrsas_instance *instance);
179 static int register_mfi_aen(struct mrsas_instance *instance,
181 static int issue_mfi_pthru(struct mrsas_instance *instance, struct
183 static int issue_mfi_dcmd(struct mrsas_instance *instance, struct
185 static int issue_mfi_smp(struct mrsas_instance *instance, struct
187 static int issue_mfi_stp(struct mrsas_instance *instance, struct
189 static int abort_aen_cmd(struct mrsas_instance *instance,
192 static void mrsas_rem_intrs(struct mrsas_instance *instance);
193 static int mrsas_add_intrs(struct mrsas_instance *instance, int intr_type);
346 * anything that has to do with a particular instance of the device.
347 * Per-instance initialization must be done in attach().
438 * The kernel calls a driver's attach() entry point to attach an instance of
439 * a device (for MegaRAID, it is instance of a controller) or to resume
440 * operation for an instance of a device that has been suspended or has been
444 * - allocate a soft-state structure for the device instance (for MegaRAID,
445 * controller instance)
446 * - initialize per-instance mutexes
449 * - map the registers and memory of the device instance (for MegaRAID,
450 * controller instance)
451 * - create minor device nodes for the device instance (for MegaRAID,
452 * controller instance)
453 * - report that the device instance (for MegaRAID, controller instance) has
474 struct mrsas_instance *instance;
493 /* allocate the soft state for the instance */
500 instance = (struct mrsas_instance *)ddi_get_soft_state
503 if (instance == NULL) {
509 instance->unroll.softs = 1;
512 if (pci_config_setup(dip, &instance->pci_handle) !=
523 pci_config_teardown(&instance->pci_handle);
528 vendor_id = pci_config_get16(instance->pci_handle,
530 device_id = pci_config_get16(instance->pci_handle,
533 subsysvid = pci_config_get16(instance->pci_handle,
535 subsysid = pci_config_get16(instance->pci_handle,
538 pci_config_put16(instance->pci_handle, PCI_CONF_COMM,
539 (pci_config_get16(instance->pci_handle,
541 irq = pci_config_get8(instance->pci_handle,
550 command = pci_config_get16(instance->pci_handle,
556 pci_config_put16(instance->pci_handle,
573 instance->func_ptr =
575 instance->tbolt = 1;
582 * instance as Skinny, because the register set is
587 instance->skinny = 1;
595 instance->func_ptr =
602 pci_config_teardown(&instance->pci_handle);
607 instance->baseaddress = pci_config_get32(
608 instance->pci_handle, PCI_CONF_BASE0);
609 instance->baseaddress &= 0x0fffc;
611 instance->dip = dip;
612 instance->vendor_id = vendor_id;
613 instance->device_id = device_id;
614 instance->subsysvid = subsysvid;
615 instance->subsysid = subsysid;
616 instance->instance = instance_no;
619 instance->fm_capabilities = ddi_prop_get_int(
620 DDI_DEV_T_ANY, instance->dip, DDI_PROP_DONTPASS,
625 mrsas_fm_init(instance);
628 if ((ddi_dev_regsize(instance->dip,
639 if (ddi_regs_map_setup(instance->dip,
640 REGISTER_SET_IO_2108, &instance->regmap, 0,
641 reglength, &endian_attr, &instance->regmap_handle)
647 instance->unroll.regs = 1;
653 instance->func_ptr->disable_intr(instance);
694 if (mrsas_add_intrs(instance, DDI_INTR_TYPE_MSIX) !=
700 instance->intr_type = DDI_INTR_TYPE_MSIX;
702 if (mrsas_add_intrs(instance, DDI_INTR_TYPE_MSI) !=
708 instance->intr_type = DDI_INTR_TYPE_MSI;
711 if (mrsas_add_intrs(instance, DDI_INTR_TYPE_FIXED) !=
717 instance->intr_type = DDI_INTR_TYPE_FIXED;
725 instance->unroll.intr = 1;
740 if (mrsas_init_adapter(instance) != DDI_SUCCESS) {
748 INIT_LIST_HEAD(&instance->completed_pool_list);
749 mutex_init(&instance->completed_pool_mtx, NULL,
750 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
752 mutex_init(&instance->sync_map_mtx, NULL,
753 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
755 mutex_init(&instance->app_cmd_pool_mtx, NULL,
756 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
758 mutex_init(&instance->config_dev_mtx, NULL,
759 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
761 mutex_init(&instance->cmd_pend_mtx, NULL,
762 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
764 mutex_init(&instance->ocr_flags_mtx, NULL,
765 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
767 mutex_init(&instance->int_cmd_mtx, NULL,
768 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
769 cv_init(&instance->int_cmd_cv, NULL, CV_DRIVER, NULL);
771 mutex_init(&instance->cmd_pool_mtx, NULL,
772 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
774 mutex_init(&instance->reg_write_mtx, NULL,
775 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
777 if (instance->tbolt) {
778 mutex_init(&instance->cmd_app_pool_mtx, NULL,
779 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
781 mutex_init(&instance->chip_mtx, NULL,
782 MUTEX_DRIVER, DDI_INTR_PRI(instance->intr_pri));
786 instance->unroll.mutexs = 1;
788 instance->timeout_id = (timeout_id_t)-1;
791 instance->isr_level = instance->intr_pri;
792 if (!(instance->tbolt)) {
793 if (instance->isr_level == HIGH_LEVEL_INTR) {
796 &instance->soft_intr_id, NULL, NULL,
797 mrsas_softintr, (caddr_t)instance) !=
805 instance->unroll.soft_isr = 1;
810 instance->softint_running = 0;
821 instance->tran = tran;
822 instance->unroll.tran = 1;
824 tran->tran_hba_private = instance;
829 if (instance->tbolt)
850 tran_dma_attr.dma_attr_sgllen = instance->max_num_sge;
852 /* Attach this instance of the hba */
860 instance->unroll.tranSetup = 1;
873 instance->unroll.devctl = 1;
884 instance->unroll.scsictl = 1;
886 (void) sprintf(instance->iocnode, "%d:lsirdctl", instance_no);
892 if (ddi_create_minor_node(dip, instance->iocnode,
900 instance->unroll.ioctl = 1;
903 if ((instance->taskq = ddi_taskq_create(dip,
906 instance->taskq = NULL;
909 instance->unroll.taskq = 1;
913 instance->func_ptr->enable_intr(instance);
916 if (start_mfi_aen(instance)) {
920 instance->unroll.aenPend = 1;
922 (CE_CONT, "AEN started for instance %d.", instance_no));
928 if (mrsas_check_acc_handle(instance->regmap_handle) !=
932 if (mrsas_check_acc_handle(instance->pci_handle) !=
937 instance->mr_ld_list =
940 instance->unroll.ldlist_buff = 1;
943 if (instance->tbolt || instance->skinny) {
944 instance->mr_tbolt_pd_max = MRSAS_TBOLT_PD_TGT_MAX;
945 instance->mr_tbolt_pd_list =
946 kmem_zalloc(MRSAS_TBOLT_GET_PD_MAX(instance) *
948 ASSERT(instance->mr_tbolt_pd_list);
949 for (i = 0; i < instance->mr_tbolt_pd_max; i++) {
950 instance->mr_tbolt_pd_list[i].lun_type =
952 instance->mr_tbolt_pd_list[i].dev_id =
956 instance->unroll.pdlist_buff = 1;
980 mrsas_undo_resources(dip, instance);
982 mrsas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
983 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
985 mrsas_fm_fini(instance);
987 pci_config_teardown(&instance->pci_handle);
1001 * the driver knows. The mapping of minor numbers to device instance is
1014 struct mrsas_instance *instance;
1020 instance = (struct mrsas_instance *)
1024 if (instance == NULL) {
1028 *resultp = instance->dip;
1050 * A driver's detach() entry point is called to detach an instance of a device
1051 * that is bound to the driver. The entry point is called with the instance of
1063 struct mrsas_instance *instance;
1073 instance = (struct mrsas_instance *)ddi_get_soft_state(mrsas_state,
1076 if (!instance) {
1077 dev_err(dip, CE_WARN, "could not get instance in detach");
1087 mutex_enter(&instance->config_dev_mtx);
1088 if (instance->timeout_id != (timeout_id_t)-1) {
1089 mutex_exit(&instance->config_dev_mtx);
1090 (void) untimeout(instance->timeout_id);
1091 instance->timeout_id = (timeout_id_t)-1;
1092 mutex_enter(&instance->config_dev_mtx);
1093 instance->unroll.timer = 0;
1095 mutex_exit(&instance->config_dev_mtx);
1097 if (instance->unroll.tranSetup == 1) {
1103 instance->unroll.tranSetup = 0;
1108 flush_cache(instance);
1110 mrsas_undo_resources(dip, instance);
1112 mrsas_fm_fini(instance);
1114 pci_config_teardown(&instance->pci_handle);
1139 mrsas_undo_resources(dev_info_t *dip, struct mrsas_instance *instance)
1143 if (instance->unroll.ioctl == 1) {
1144 ddi_remove_minor_node(dip, instance->iocnode);
1145 instance->unroll.ioctl = 0;
1148 if (instance->unroll.scsictl == 1) {
1150 instance->unroll.scsictl = 0;
1153 if (instance->unroll.devctl == 1) {
1155 instance->unroll.devctl = 0;
1158 if (instance->unroll.tranSetup == 1) {
1163 instance->unroll.tranSetup = 0;
1167 if (instance->unroll.tran == 1) {
1168 scsi_hba_tran_free(instance->tran);
1169 instance->unroll.tran = 0;
1173 if (instance->unroll.syncCmd == 1) {
1174 if (instance->tbolt) {
1175 if (abort_syncmap_cmd(instance,
1176 instance->map_update_cmd)) {
1181 instance->unroll.syncCmd = 0;
1186 if (instance->unroll.aenPend == 1) {
1187 if (abort_aen_cmd(instance, instance->aen_cmd))
1191 instance->unroll.aenPend = 0;
1199 if (instance->unroll.timer == 1) {
1200 if (instance->timeout_id != (timeout_id_t)-1) {
1201 (void) untimeout(instance->timeout_id);
1202 instance->timeout_id = (timeout_id_t)-1;
1204 instance->unroll.timer = 0;
1208 instance->func_ptr->disable_intr(instance);
1211 if (instance->unroll.mutexs == 1) {
1212 mutex_destroy(&instance->cmd_pool_mtx);
1213 mutex_destroy(&instance->app_cmd_pool_mtx);
1214 mutex_destroy(&instance->cmd_pend_mtx);
1215 mutex_destroy(&instance->completed_pool_mtx);
1216 mutex_destroy(&instance->sync_map_mtx);
1217 mutex_destroy(&instance->int_cmd_mtx);
1218 cv_destroy(&instance->int_cmd_cv);
1219 mutex_destroy(&instance->config_dev_mtx);
1220 mutex_destroy(&instance->ocr_flags_mtx);
1221 mutex_destroy(&instance->reg_write_mtx);
1223 if (instance->tbolt) {
1224 mutex_destroy(&instance->cmd_app_pool_mtx);
1225 mutex_destroy(&instance->chip_mtx);
1228 instance->unroll.mutexs = 0;
1233 if (instance->unroll.soft_isr == 1) {
1234 ddi_remove_softintr(instance->soft_intr_id);
1235 instance->unroll.soft_isr = 0;
1238 if (instance->unroll.intr == 1) {
1239 mrsas_rem_intrs(instance);
1240 instance->unroll.intr = 0;
1244 if (instance->unroll.taskq == 1) {
1245 if (instance->taskq) {
1246 ddi_taskq_destroy(instance->taskq);
1247 instance->unroll.taskq = 0;
1256 if (instance->unroll.verBuff == 1) {
1257 (void) mrsas_free_dma_obj(instance, instance->drv_ver_dma_obj);
1258 instance->unroll.verBuff = 0;
1261 if (instance->unroll.pdlist_buff == 1) {
1262 if (instance->mr_tbolt_pd_list != NULL) {
1263 kmem_free(instance->mr_tbolt_pd_list,
1264 MRSAS_TBOLT_GET_PD_MAX(instance) *
1268 instance->mr_tbolt_pd_list = NULL;
1269 instance->unroll.pdlist_buff = 0;
1272 if (instance->unroll.ldlist_buff == 1) {
1273 if (instance->mr_ld_list != NULL) {
1274 kmem_free(instance->mr_ld_list, MRDRV_MAX_LD
1278 instance->mr_ld_list = NULL;
1279 instance->unroll.ldlist_buff = 0;
1282 if (instance->tbolt) {
1283 if (instance->unroll.alloc_space_mpi2 == 1) {
1284 free_space_for_mpi2(instance);
1285 instance->unroll.alloc_space_mpi2 = 0;
1288 if (instance->unroll.alloc_space_mfi == 1) {
1289 free_space_for_mfi(instance);
1290 instance->unroll.alloc_space_mfi = 0;
1294 if (instance->unroll.regs == 1) {
1295 ddi_regs_map_free(&instance->regmap_handle);
1296 instance->unroll.regs = 0;
1403 struct mrsas_instance *instance;
1408 instance = ddi_get_soft_state(mrsas_state, MINOR2INST(getminor(dev)));
1410 if (instance == NULL) {
1431 rval = handle_drv_ioctl(instance, ioctl, mode);
1433 rval = handle_mfi_ioctl(instance, ioctl, mode);
1453 rval = handle_mfi_aen(instance, &aen);
1496 struct mrsas_instance *instance;
1499 instance = (struct mrsas_instance *)ddi_get_soft_state
1504 if (!instance) {
1510 instance->func_ptr->disable_intr(instance);
1512 con_log(CL_ANN1, (CE_CONT, "flushing cache for instance %d",
1515 flush_cache(instance);
1526 struct mrsas_instance *instance;
1529 instance = (struct mrsas_instance *)ddi_get_soft_state
1534 if (!instance) {
1539 if (instance->deadadapter || instance->adapterresetinprogress) {
1545 if (abort_aen_cmd(instance, instance->aen_cmd)) {
1550 if (instance->tbolt) {
1551 if (abort_syncmap_cmd(instance,
1552 instance->map_update_cmd)) {
1560 instance->func_ptr->disable_intr(instance);
1562 con_log(CL_ANN1, (CE_CONT, "flushing cache for instance %d",
1565 flush_cache(instance);
1567 if (wait_for_outstanding(instance)) {
1584 * tran_tgt_init - initialize a target device instance
1593 * By returning DDI_FAILURE, the instance of the target driver for that device
1601 struct mrsas_instance *instance;
1609 instance = ADDR2MR(&sd->sd_address);
1616 if ((child = mrsas_find_child(instance, tgt, lun)) != NULL) {
1632 (void *)instance->mr_ld_list[tgt].dip, (void *)tgt_dip));
1635 if (instance->mr_ld_list[tgt].dip == NULL &&
1637 mutex_enter(&instance->config_dev_mtx);
1638 instance->mr_ld_list[tgt].dip = tgt_dip;
1639 instance->mr_ld_list[tgt].lun_type = MRSAS_LD_LUN;
1640 instance->mr_ld_list[tgt].flag = MRDRV_TGT_VALID;
1641 mutex_exit(&instance->config_dev_mtx);
1646 else if (instance->tbolt || instance->skinny) {
1647 if (instance->mr_tbolt_pd_list[tgt].dip == NULL) {
1648 mutex_enter(&instance->config_dev_mtx);
1649 instance->mr_tbolt_pd_list[tgt].dip = tgt_dip;
1650 instance->mr_tbolt_pd_list[tgt].flag =
1652 mutex_exit(&instance->config_dev_mtx);
1667 struct mrsas_instance *instance;
1671 instance = ADDR2MR(&sd->sd_address);
1676 if (instance->mr_ld_list[tgt].dip == tgt_dip) {
1677 mutex_enter(&instance->config_dev_mtx);
1678 instance->mr_ld_list[tgt].dip = NULL;
1679 mutex_exit(&instance->config_dev_mtx);
1684 else if (instance->tbolt || instance->skinny) {
1685 mutex_enter(&instance->config_dev_mtx);
1686 instance->mr_tbolt_pd_list[tgt].dip = NULL;
1687 mutex_exit(&instance->config_dev_mtx);
1696 mrsas_find_child(struct mrsas_instance *instance, uint16_t tgt, uint8_t lun)
1703 for (child = ddi_get_child(instance->dip); child;
1779 struct mrsas_instance *instance;
1784 instance = ADDR2MR(ap);
1788 pkt = scsi_hba_pkt_alloc(instance->dip, ap, cmdlen, statuslen,
1827 if (mrsas_dma_alloc(instance, pkt, bp, flags,
1835 if (mrsas_dma_move(instance, pkt, bp) == DDI_FAILURE) {
1858 * TRAN_ACCEPT - pkt has been submitted to the instance
1865 struct mrsas_instance *instance = ADDR2MR(ap);
1869 if (instance->deadadapter == 1) {
1880 if (instance->adapterresetinprogress) {
1892 cmd = build_cmd(instance, ap, pkt, &cmd_done);
1916 if (instance->fw_outstanding > instance->max_fw_cmds) {
1919 uint16_t, instance->fw_outstanding,
1920 uint16_t, instance->max_fw_cmds);
1921 mrsas_return_mfi_pkt(instance, cmd);
1930 instance->func_ptr->issue_cmd(cmd, instance);
1935 instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd);
1967 (void) mrsas_common_check(instance, cmd);
1970 mrsas_return_mfi_pkt(instance, cmd);
2020 struct mrsas_instance *instance = ADDR2MR(ap);
2024 if (wait_for_outstanding(instance)) {
2051 struct mrsas_instance *instance = ADDR2MR(ap);
2062 if (instance->tbolt) {
2092 rval = instance->init_id;
2302 mrsas_isr(struct mrsas_instance *instance)
2315 ASSERT(instance);
2316 if (instance->tbolt) {
2317 mutex_enter(&instance->chip_mtx);
2318 if ((instance->intr_type == DDI_INTR_TYPE_FIXED) &&
2319 !(instance->func_ptr->intr_ack(instance))) {
2320 mutex_exit(&instance->chip_mtx);
2323 retval = mr_sas_tbolt_process_outstanding_cmd(instance);
2324 mutex_exit(&instance->chip_mtx);
2327 if ((instance->intr_type == DDI_INTR_TYPE_FIXED) &&
2328 !instance->func_ptr->intr_ack(instance)) {
2333 (void) ddi_dma_sync(instance->mfi_internal_dma_obj.dma_handle,
2336 if (mrsas_check_dma_handle(instance->mfi_internal_dma_obj.dma_handle)
2338 mrsas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
2339 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
2354 mutex_enter(&instance->completed_pool_mtx);
2355 mutex_enter(&instance->cmd_pend_mtx);
2357 producer = ddi_get32(instance->mfi_internal_dma_obj.acc_handle,
2358 instance->producer);
2359 consumer = ddi_get32(instance->mfi_internal_dma_obj.acc_handle,
2360 instance->consumer);
2368 mutex_exit(&instance->cmd_pend_mtx);
2369 mutex_exit(&instance->completed_pool_mtx);
2374 context = ddi_get32(instance->mfi_internal_dma_obj.acc_handle,
2375 &instance->reply_queue[consumer]);
2376 cmd = instance->cmd_list[context];
2390 mlist_add_tail(&cmd->list, &instance->completed_pool_list);
2393 if (consumer == (instance->max_fw_cmds + 1)) {
2397 ddi_put32(instance->mfi_internal_dma_obj.acc_handle,
2398 instance->consumer, consumer);
2399 mutex_exit(&instance->cmd_pend_mtx);
2400 mutex_exit(&instance->completed_pool_mtx);
2402 (void) ddi_dma_sync(instance->mfi_internal_dma_obj.dma_handle,
2405 if (instance->softint_running) {
2411 if (instance->isr_level == HIGH_LEVEL_INTR) {
2413 ddi_trigger_softintr(instance->soft_intr_id);
2420 (void) mrsas_softintr(instance);
2445 mrsas_get_mfi_pkt(struct mrsas_instance *instance)
2447 mlist_t *head = &instance->cmd_pool_list;
2450 mutex_enter(&instance->cmd_pool_mtx);
2462 mutex_exit(&instance->cmd_pool_mtx);
2468 get_mfi_app_pkt(struct mrsas_instance *instance)
2470 mlist_t *head = &instance->app_cmd_pool_list;
2473 mutex_enter(&instance->app_cmd_pool_mtx);
2485 mutex_exit(&instance->app_cmd_pool_mtx);
2493 mrsas_return_mfi_pkt(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
2495 mutex_enter(&instance->cmd_pool_mtx);
2497 mlist_add_tail(&cmd->list, &instance->cmd_pool_list);
2499 mutex_exit(&instance->cmd_pool_mtx);
2503 return_mfi_app_pkt(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
2505 mutex_enter(&instance->app_cmd_pool_mtx);
2507 mlist_add(&cmd->list, &instance->app_cmd_pool_list);
2509 mutex_exit(&instance->app_cmd_pool_mtx);
2512 push_pending_mfi_pkt(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
2517 mutex_enter(&instance->cmd_pend_mtx);
2519 mlist_add_tail(&cmd->list, &instance->cmd_pend_list);
2539 if (hdr && instance->timeout_id == (timeout_id_t)-1) {
2540 instance->timeout_id = timeout(io_timeout_checker,
2541 (void *) instance, drv_usectohz(MRSAS_1_SECOND));
2554 if (pkt && instance->timeout_id == (timeout_id_t)-1) {
2555 instance->timeout_id = timeout(io_timeout_checker,
2556 (void *) instance, drv_usectohz(MRSAS_1_SECOND));
2560 mutex_exit(&instance->cmd_pend_mtx);
2565 mrsas_print_pending_cmds(struct mrsas_instance *instance)
2567 mlist_t *head = &instance->cmd_pend_list;
2579 dev_err(instance->dip, CE_NOTE,
2583 mutex_enter(&instance->cmd_pend_mtx);
2586 mutex_exit(&instance->cmd_pend_mtx);
2593 mutex_exit(&instance->cmd_pend_mtx);
2619 mrsas_print_cmd_details(instance, cmd,
2622 mrsas_print_cmd_details(instance, cmd,
2639 mrsas_complete_pending_cmds(struct mrsas_instance *instance)
2651 mutex_enter(&instance->cmd_pend_mtx);
2652 mlist_for_each_safe(pos, next, &instance->cmd_pend_list) {
2683 complete_cmd_in_sync_mode(instance, cmd);
2696 mutex_exit(&instance->cmd_pend_mtx);
2703 mrsas_print_cmd_details(struct mrsas_instance *instance, struct mrsas_cmd *cmd,
2711 instance->mpi2_frame_pool_dma_obj.acc_handle;
2719 if (instance->tbolt) {
2736 if ((detail == 0xDD) && instance->tbolt) {
2774 mrsas_issue_pending_cmds(struct mrsas_instance *instance)
2776 mlist_t *head = &instance->cmd_pend_list;
2783 mutex_enter(&instance->cmd_pend_mtx);
2786 mutex_exit(&instance->cmd_pend_mtx);
2799 dev_err(instance->dip, CE_CONT,
2804 dev_err(instance->dip,
2808 mrsas_print_cmd_details(instance, cmd, 0xDD);
2810 dev_err(instance->dip, CE_WARN,
2813 if (instance->tbolt)
2814 mrsas_tbolt_kill_adapter(instance);
2816 (void) mrsas_kill_adapter(instance);
2830 dev_err(instance->dip, CE_CONT,
2838 dev_err(instance->dip, CE_CONT,
2841 instance->func_ptr->issue_cmd_in_sync_mode(
2842 instance, cmd);
2844 instance->func_ptr->issue_cmd(cmd, instance);
2864 destroy_mfi_frame_pool(struct mrsas_instance *instance)
2867 uint32_t max_cmd = instance->max_fw_cmds;
2875 cmd = instance->cmd_list[i];
2878 (void) mrsas_free_dma_obj(instance, cmd->frame_dma_obj);
2889 create_mfi_frame_pool(struct mrsas_instance *instance)
2900 max_cmd = instance->max_fw_cmds;
2903 sgl_sz = sge_sz * instance->max_num_sge;
2910 cmd = instance->cmd_list[i];
2919 cookie_cnt = mrsas_alloc_dma_obj(instance, &cmd->frame_dma_obj,
2923 dev_err(instance->dip, CE_WARN,
2944 dev_err(instance->dip, CE_WARN,
2962 destroy_mfi_frame_pool(instance);
2971 free_additional_dma_buffer(struct mrsas_instance *instance)
2973 if (instance->mfi_internal_dma_obj.status == DMA_OBJ_ALLOCATED) {
2974 (void) mrsas_free_dma_obj(instance,
2975 instance->mfi_internal_dma_obj);
2976 instance->mfi_internal_dma_obj.status = DMA_OBJ_FREED;
2979 if (instance->mfi_evt_detail_obj.status == DMA_OBJ_ALLOCATED) {
2980 (void) mrsas_free_dma_obj(instance,
2981 instance->mfi_evt_detail_obj);
2982 instance->mfi_evt_detail_obj.status = DMA_OBJ_FREED;
2990 alloc_additional_dma_buffer(struct mrsas_instance *instance)
2996 reply_q_sz = sizeof (uint32_t) * (instance->max_fw_cmds + 1 + 2);
2998 instance->mfi_internal_dma_obj.size = internal_buf_size;
2999 instance->mfi_internal_dma_obj.dma_attr = mrsas_generic_dma_attr;
3000 instance->mfi_internal_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3001 instance->mfi_internal_dma_obj.dma_attr.dma_attr_count_max =
3003 instance->mfi_internal_dma_obj.dma_attr.dma_attr_sgllen = 1;
3005 if (mrsas_alloc_dma_obj(instance, &instance->mfi_internal_dma_obj,
3007 dev_err(instance->dip, CE_WARN,
3012 bzero(instance->mfi_internal_dma_obj.buffer, internal_buf_size);
3014 instance->mfi_internal_dma_obj.status |= DMA_OBJ_ALLOCATED;
3016 instance->producer = (uint32_t *)((unsigned long)
3017 instance->mfi_internal_dma_obj.buffer);
3018 instance->consumer = (uint32_t *)((unsigned long)
3019 instance->mfi_internal_dma_obj.buffer + 4);
3020 instance->reply_queue = (uint32_t *)((unsigned long)
3021 instance->mfi_internal_dma_obj.buffer + 8);
3022 instance->internal_buf = (caddr_t)(((unsigned long)
3023 instance->mfi_internal_dma_obj.buffer) + reply_q_sz + 8);
3024 instance->internal_buf_dmac_add =
3025 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address +
3027 instance->internal_buf_size = internal_buf_size -
3031 instance->mfi_evt_detail_obj.size = sizeof (struct mrsas_evt_detail);
3032 instance->mfi_evt_detail_obj.dma_attr = mrsas_generic_dma_attr;
3033 instance->mfi_evt_detail_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3034 instance->mfi_evt_detail_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
3035 instance->mfi_evt_detail_obj.dma_attr.dma_attr_sgllen = 1;
3036 instance->mfi_evt_detail_obj.dma_attr.dma_attr_align = 1;
3038 if (mrsas_alloc_dma_obj(instance, &instance->mfi_evt_detail_obj,
3040 dev_err(instance->dip, CE_WARN, "alloc_additional_dma_buffer: "
3045 bzero(instance->mfi_evt_detail_obj.buffer,
3048 instance->mfi_evt_detail_obj.status |= DMA_OBJ_ALLOCATED;
3053 if (instance->mfi_internal_dma_obj.status == DMA_OBJ_ALLOCATED) {
3054 (void) mrsas_free_dma_obj(instance,
3055 instance->mfi_internal_dma_obj);
3056 instance->mfi_internal_dma_obj.status = DMA_OBJ_FREED;
3064 mrsas_free_cmd_pool(struct mrsas_instance *instance)
3071 if (instance->cmd_list == NULL) {
3075 max_cmd = instance->max_fw_cmds;
3082 if (instance->cmd_list[i] != NULL) {
3083 kmem_free(instance->cmd_list[i],
3087 instance->cmd_list[i] = NULL;
3091 if (instance->cmd_list != NULL)
3092 kmem_free(instance->cmd_list, sz);
3094 instance->cmd_list = NULL;
3096 INIT_LIST_HEAD(&instance->cmd_pool_list);
3097 INIT_LIST_HEAD(&instance->cmd_pend_list);
3098 if (instance->tbolt) {
3099 INIT_LIST_HEAD(&instance->cmd_app_pool_list);
3101 INIT_LIST_HEAD(&instance->app_cmd_pool_list);
3111 mrsas_alloc_cmd_pool(struct mrsas_instance *instance)
3121 max_cmd = instance->max_fw_cmds;
3129 * instance->cmd_list is an array of struct mrsas_cmd pointers.
3133 instance->cmd_list = kmem_zalloc(sz, KM_SLEEP);
3134 ASSERT(instance->cmd_list);
3138 instance->cmd_list[count] =
3140 ASSERT(instance->cmd_list[count]);
3145 INIT_LIST_HEAD(&instance->cmd_pool_list);
3146 INIT_LIST_HEAD(&instance->cmd_pend_list);
3147 INIT_LIST_HEAD(&instance->app_cmd_pool_list);
3158 cmd = instance->cmd_list[i];
3160 mlist_add_tail(&cmd->list, &instance->app_cmd_pool_list);
3165 cmd = instance->cmd_list[i];
3167 mlist_add_tail(&cmd->list, &instance->cmd_pool_list);
3176 if (instance->cmd_list[i] != NULL) {
3177 kmem_free(instance->cmd_list[i],
3180 instance->cmd_list[i] = NULL;
3185 if (instance->cmd_list != NULL)
3186 kmem_free(instance->cmd_list, sz);
3187 instance->cmd_list = NULL;
3197 free_space_for_mfi(struct mrsas_instance *instance)
3201 if (instance->cmd_list == NULL) {
3206 free_additional_dma_buffer(instance);
3209 destroy_mfi_frame_pool(instance);
3213 mrsas_free_cmd_pool(instance);
3220 alloc_space_for_mfi(struct mrsas_instance *instance)
3223 if (mrsas_alloc_cmd_pool(instance)) {
3224 dev_err(instance->dip, CE_WARN, "error creating cmd pool");
3229 if (create_mfi_frame_pool(instance)) {
3230 dev_err(instance->dip, CE_WARN,
3236 if (alloc_additional_dma_buffer(instance)) {
3237 dev_err(instance->dip, CE_WARN,
3245 destroy_mfi_frame_pool(instance);
3248 mrsas_free_cmd_pool(instance);
3259 get_ctrl_info(struct mrsas_instance *instance,
3268 if (instance->tbolt) {
3269 cmd = get_raid_msg_mfi_pkt(instance);
3271 cmd = mrsas_get_mfi_pkt(instance);
3277 DTRACE_PROBE2(info_mfi_err, uint16_t, instance->fw_outstanding,
3278 uint16_t, instance->max_fw_cmds);
3289 ci = (struct mrsas_ctrl_info *)instance->internal_buf;
3292 dev_err(instance->dip, CE_WARN,
3294 mrsas_return_mfi_pkt(instance, cmd);
3315 instance->internal_buf_dmac_add);
3321 if (instance->tbolt) {
3322 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
3325 if (!instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
3343 dev_err(instance->dip, CE_WARN,
3348 if (mrsas_common_check(instance, cmd) != DDI_SUCCESS) {
3351 if (instance->tbolt) {
3352 return_raid_msg_mfi_pkt(instance, cmd);
3354 mrsas_return_mfi_pkt(instance, cmd);
3364 abort_aen_cmd(struct mrsas_instance *instance,
3374 if (instance->tbolt) {
3375 cmd = get_raid_msg_mfi_pkt(instance);
3377 cmd = mrsas_get_mfi_pkt(instance);
3383 DTRACE_PROBE2(abort_mfi_err, uint16_t, instance->fw_outstanding,
3384 uint16_t, instance->max_fw_cmds);
3408 instance->aen_cmd->abort_aen = 1;
3412 if (instance->tbolt) {
3413 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
3416 if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
3424 instance->aen_cmd->abort_aen = 1;
3425 instance->aen_cmd = 0;
3427 if (instance->tbolt) {
3428 return_raid_msg_mfi_pkt(instance, cmd);
3430 mrsas_return_mfi_pkt(instance, cmd);
3433 atomic_add_16(&instance->fw_outstanding, (-1));
3440 mrsas_build_init_cmd(struct mrsas_instance *instance,
3473 &initq_info->reply_queue_entries, instance->max_fw_cmds + 1);
3479 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address);
3485 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 4);
3491 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 8);
3509 instance->drv_ver_dma_obj.size = sizeof (drv_ver_info.drv_ver);
3510 instance->drv_ver_dma_obj.dma_attr = mrsas_generic_dma_attr;
3511 instance->drv_ver_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
3512 instance->drv_ver_dma_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
3513 instance->drv_ver_dma_obj.dma_attr.dma_attr_sgllen = 1;
3514 instance->drv_ver_dma_obj.dma_attr.dma_attr_align = 1;
3516 if (mrsas_alloc_dma_obj(instance, &instance->drv_ver_dma_obj,
3523 (void) memset(instance->drv_ver_dma_obj.buffer, 0,
3527 (uint8_t *)instance->drv_ver_dma_obj.buffer,
3533 instance->drv_ver_dma_obj.dma_cookie[0].dmac_address);
3550 mrsas_init_adapter_ppc(struct mrsas_instance *instance)
3558 if (alloc_space_for_mfi(instance) != DDI_SUCCESS) {
3565 cmd = mrsas_get_mfi_pkt(instance);
3568 instance->fw_outstanding, uint16_t, instance->max_fw_cmds);
3572 if (mrsas_build_init_cmd(instance, &cmd) != DDI_SUCCESS) {
3583 if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
3588 if (mrsas_common_check(instance, cmd) != DDI_SUCCESS)
3590 mrsas_return_mfi_pkt(instance, cmd);
3593 (instance->func_ptr->read_fw_status_reg(instance) & 0x04000000)) {
3595 instance->flag_ieee = 1;
3597 instance->flag_ieee = 0;
3600 ASSERT(!instance->skinny || instance->flag_ieee);
3602 instance->unroll.alloc_space_mfi = 1;
3603 instance->unroll.verBuff = 1;
3609 (void) mrsas_free_dma_obj(instance, instance->drv_ver_dma_obj);
3612 mrsas_return_mfi_pkt(instance, cmd);
3613 free_space_for_mfi(instance);
3623 mrsas_init_adapter(struct mrsas_instance *instance)
3629 if (mfi_state_transition_to_ready(instance)) {
3635 instance->max_num_sge =
3636 (instance->func_ptr->read_fw_status_reg(instance) &
3638 instance->max_num_sge =
3639 (instance->max_num_sge > MRSAS_MAX_SGE_CNT) ?
3640 MRSAS_MAX_SGE_CNT : instance->max_num_sge;
3647 instance->max_fw_cmds =
3648 instance->func_ptr->read_fw_status_reg(instance) & 0xFFFF;
3649 instance->max_fw_cmds = instance->max_fw_cmds - 1;
3654 if (instance->func_ptr->init_adapter(instance) != DDI_SUCCESS) {
3661 instance->disable_online_ctrl_reset = 0;
3663 if (!get_ctrl_info(instance, &ctrl_info)) {
3664 instance->max_sectors_per_req = ctrl_info.max_request_size;
3669 instance->max_sectors_per_req = instance->max_num_sge *
3674 instance->disable_online_ctrl_reset = 1;
3683 mrsas_issue_init_mfi(struct mrsas_instance *instance)
3697 cmd = get_mfi_app_pkt(instance);
3720 &initq_info->reply_queue_entries, instance->max_fw_cmds + 1);
3725 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address);
3730 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 4);
3736 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 8);
3755 if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
3759 return_mfi_app_pkt(instance, cmd);
3763 if (mrsas_common_check(instance, cmd) != DDI_SUCCESS) {
3764 return_mfi_app_pkt(instance, cmd);
3768 return_mfi_app_pkt(instance, cmd);
3779 mfi_state_transition_to_ready(struct mrsas_instance *instance)
3791 instance->func_ptr->read_fw_status_reg(instance);
3816 /* WR_IB_MSG_0(MFI_INIT_CLEAR_HANDSHAKE, instance); */
3817 if (!instance->tbolt && !instance->skinny) {
3819 MFI_INIT_HOTPLUG, instance);
3822 MFI_INIT_HOTPLUG, instance);
3824 max_wait = (instance->tbolt == 1) ? 180 : 2;
3836 if (!instance->tbolt && !instance->skinny) {
3837 WR_IB_DOORBELL(MFI_INIT_HOTPLUG, instance);
3840 instance);
3842 max_wait = (instance->tbolt == 1) ? 180 : 10;
3847 instance->func_ptr->disable_intr(instance);
3855 /* WR_IB_DOORBELL(MFI_INIT_READY, instance); */
3856 if (!instance->tbolt && !instance->skinny) {
3857 WR_IB_DOORBELL(MFI_RESET_FLAGS, instance);
3860 instance);
3864 RD_RESERVED0_REGISTER(instance);
3874 max_wait = (instance->tbolt == 1) ? 180 : 10;
3881 max_wait = (instance->tbolt == 1) ? 180 : 2;
3885 max_wait = (instance->tbolt == 1) ? 180 : 2;
3889 max_wait = (instance->tbolt == 1) ? 180 : 2;
3915 /* fw_state = RD_OB_MSG_0(instance) & MFI_STATE_MASK; */
3917 instance->func_ptr->read_fw_status_reg(instance);
3941 if (!instance->tbolt && !instance->skinny) {
3942 fw_ctrl = RD_IB_DOORBELL(instance);
3954 WR_IB_DOORBELL(0xF, instance);
3957 if (mrsas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
3968 get_seq_num(struct mrsas_instance *instance,
3977 if (instance->tbolt) {
3978 cmd = get_raid_msg_mfi_pkt(instance);
3980 cmd = mrsas_get_mfi_pkt(instance);
3984 dev_err(instance->dip, CE_WARN, "failed to get a cmd");
3986 instance->fw_outstanding, uint16_t, instance->max_fw_cmds);
4005 if (mrsas_alloc_dma_obj(instance, &dcmd_dma_obj,
4007 dev_err(instance->dip, CE_WARN,
4035 if (instance->tbolt) {
4036 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
4039 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
4040 dev_err(instance->dip, CE_WARN, "get_seq_num: "
4050 if (mrsas_free_dma_obj(instance, dcmd_dma_obj) != DDI_SUCCESS)
4053 if (instance->tbolt) {
4054 return_raid_msg_mfi_pkt(instance, cmd);
4056 mrsas_return_mfi_pkt(instance, cmd);
4066 start_mfi_aen(struct mrsas_instance *instance)
4076 if (get_seq_num(instance, &eli)) {
4077 dev_err(instance->dip, CE_WARN,
4087 ret = register_mfi_aen(instance, eli.newest_seq_num + 1,
4091 dev_err(instance->dip, CE_WARN,
4104 flush_cache(struct mrsas_instance *instance)
4108 if (instance->tbolt) {
4109 cmd = get_raid_msg_mfi_pkt(instance);
4111 cmd = mrsas_get_mfi_pkt(instance);
4118 instance->fw_outstanding, uint16_t, instance->max_fw_cmds);
4145 if (instance->tbolt) {
4146 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
4149 if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
4154 if (instance->tbolt) {
4155 return_raid_msg_mfi_pkt(instance, cmd);
4157 mrsas_return_mfi_pkt(instance, cmd);
4164 * @instance: Adapter soft state
4169 service_mfi_aen(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
4173 (struct mrsas_evt_detail *)instance->mfi_evt_detail_obj.buffer;
4194 if (ddi_log_sysevent(instance->dip, DDI_VENDOR_LSI, "LSIMEGA", "SAS",
4196 int instance_no = ddi_get_instance(instance->dip);
4214 if (instance->mr_ld_list[tgt].dip != NULL) {
4215 mutex_enter(&instance->config_dev_mtx);
4216 instance->mr_ld_list[tgt].flag =
4218 mutex_exit(&instance->config_dev_mtx);
4219 rval = mrsas_service_evt(instance, tgt, 0,
4231 mutex_enter(&instance->config_dev_mtx);
4232 instance->mr_ld_list[tgt].flag = (uint8_t)~MRDRV_TGT_VALID;
4233 mutex_exit(&instance->config_dev_mtx);
4234 rval = mrsas_service_evt(instance,
4245 rval = mrsas_service_evt(instance,
4257 if (instance->tbolt || instance->skinny) {
4265 mutex_enter(&instance->config_dev_mtx);
4266 instance->mr_tbolt_pd_list[tgt].flag =
4268 mutex_exit(&instance->config_dev_mtx);
4269 rval = mrsas_service_evt(instance, ddi_get16(
4281 if (instance->tbolt || instance->skinny) {
4282 rval = mrsas_service_evt(instance,
4295 if (instance->tbolt || instance->skinny) {
4301 mutex_enter(&instance->config_dev_mtx);
4302 instance->mr_tbolt_pd_list[tgt].flag =
4304 mutex_exit(&instance->config_dev_mtx);
4305 rval = mrsas_service_evt(instance,
4318 rval = mrsas_service_evt(instance,
4339 (void) memset(instance->mfi_evt_detail_obj.buffer, 0,
4345 instance->aen_seq_num = seq_num;
4353 instance->func_ptr->issue_cmd(cmd, instance);
4358 * @instance: Adapter soft state
4366 complete_cmd_in_sync_mode(struct mrsas_instance *instance,
4377 mutex_enter(&instance->int_cmd_mtx);
4381 cv_broadcast(&instance->int_cmd_cv);
4382 mutex_exit(&instance->int_cmd_mtx);
4389 * @instance: Adapter soft state
4393 mrsas_initiate_ocr_if_fw_is_faulty(struct mrsas_instance *instance)
4398 cur_abs_reg_val = instance->func_ptr->read_fw_status_reg(instance);
4401 if (instance->disable_online_ctrl_reset == 1) {
4402 dev_err(instance->dip, CE_WARN,
4428 mrsas_softintr(struct mrsas_instance *instance)
4440 ASSERT(instance);
4442 mutex_enter(&instance->completed_pool_mtx);
4444 if (mlist_empty(&instance->completed_pool_list)) {
4445 mutex_exit(&instance->completed_pool_mtx);
4449 instance->softint_running = 1;
4452 mlist_splice(&instance->completed_pool_list, &process_list);
4453 INIT_LIST_HEAD(&instance->completed_pool_list);
4455 mutex_exit(&instance->completed_pool_mtx);
4467 mrsas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
4468 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
4492 complete_cmd_in_sync_mode(instance, cmd);
4648 atomic_add_16(&instance->fw_outstanding, (-1));
4650 (void) mrsas_common_check(instance, cmd);
4655 ddi_fm_service_impact(instance->dip,
4662 mrsas_return_mfi_pkt(instance, cmd);
4674 complete_cmd_in_sync_mode(instance, cmd);
4682 if ((instance->aen_cmd == cmd) &&
4683 (instance->aen_cmd->abort_aen)) {
4688 atomic_add_16(&instance->fw_outstanding,
4690 service_mfi_aen(instance, cmd);
4693 complete_cmd_in_sync_mode(instance, cmd);
4704 complete_cmd_in_sync_mode(instance, cmd);
4708 mrsas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
4709 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
4731 instance->softint_running = 0;
4742 mrsas_alloc_dma_obj(struct mrsas_instance *instance, dma_obj_t *obj,
4754 i = ddi_dma_alloc_handle(instance->dip, &obj->dma_attr,
4802 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
4807 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
4821 mrsas_free_dma_obj(struct mrsas_instance *instance, dma_obj_t obj)
4833 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4838 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4856 mrsas_dma_alloc(struct mrsas_instance *instance, struct scsi_pkt *pkt,
4889 tmp_dma_attr.dma_attr_sgllen = instance->max_num_sge;
4891 if (instance->tbolt) {
4899 if ((i = ddi_dma_alloc_handle(instance->dip, &tmp_dma_attr,
4957 if (i == instance->max_num_sge ||
5010 mrsas_dma_move(struct mrsas_instance *instance, struct scsi_pkt *pkt,
5050 if (i == instance->max_num_sge ||
5074 build_cmd(struct mrsas_instance *instance, struct scsi_address *ap,
5092 acmd->device_id = MAP_DEVICE_ID(instance, ap);
5096 if (!(cmd = mrsas_get_mfi_pkt(instance))) {
5098 instance->fw_outstanding, uint16_t, instance->max_fw_cmds);
5134 if (instance->flag_ieee) {
5143 * flush_cache(instance);
5144 * mrsas_return_mfi_pkt(instance, cmd);
5187 if (instance->flag_ieee) {
5268 mrsas_return_mfi_pkt(instance, cmd);
5297 if (instance->flag_ieee) {
5319 if (instance->flag_ieee) {
5349 * @instance: Adapter soft state
5356 wait_for_outstanding(struct mrsas_instance *instance)
5362 if (!instance->fw_outstanding) {
5369 if (instance->fw_outstanding) {
5380 issue_mfi_pthru(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
5396 if (instance->adapterresetinprogress) {
5434 if (mrsas_alloc_dma_obj(instance, &pthru_dma_obj,
5484 if (instance->tbolt) {
5485 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
5488 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
5540 if (mrsas_free_dma_obj(instance, pthru_dma_obj) != DDI_SUCCESS)
5551 issue_mfi_dcmd(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
5567 if (instance->adapterresetinprogress) {
5604 if (mrsas_alloc_dma_obj(instance, &dcmd_dma_obj,
5647 if (instance->tbolt) {
5648 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
5651 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
5677 if (mrsas_free_dma_obj(instance, dcmd_dma_obj) != DDI_SUCCESS)
5688 issue_mfi_smp(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
5713 if (instance->adapterresetinprogress) {
5775 if (mrsas_alloc_dma_obj(instance, &request_dma_obj,
5809 if (mrsas_alloc_dma_obj(instance, &response_dma_obj,
5887 if (instance->tbolt) {
5888 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
5891 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
5934 if (mrsas_free_dma_obj(instance, request_dma_obj) !=
5941 if (mrsas_free_dma_obj(instance, response_dma_obj) !=
5953 issue_mfi_stp(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
5973 if (instance->adapterresetinprogress) {
6025 if (mrsas_alloc_dma_obj(instance, &fis_dma_obj,
6061 if (mrsas_alloc_dma_obj(instance, &data_dma_obj,
6104 if (instance->tbolt) {
6105 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
6108 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
6145 if (mrsas_free_dma_obj(instance, fis_dma_obj) != DDI_SUCCESS)
6151 if (mrsas_free_dma_obj(instance, data_dma_obj) != DDI_SUCCESS)
6179 handle_drv_ioctl(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
6242 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, instance->dip,
6262 pci_config_get8(instance->pci_handle, i);
6291 handle_mfi_ioctl(struct mrsas_instance *instance, struct mrsas_ioctl *ioctl,
6299 if (instance->tbolt) {
6300 cmd = get_raid_msg_mfi_pkt(instance);
6302 cmd = mrsas_get_mfi_pkt(instance);
6308 instance->fw_outstanding, uint16_t, instance->max_fw_cmds);
6321 rval = issue_mfi_dcmd(instance, ioctl, cmd, mode);
6324 rval = issue_mfi_smp(instance, ioctl, cmd, mode);
6327 rval = issue_mfi_stp(instance, ioctl, cmd, mode);
6331 rval = issue_mfi_pthru(instance, ioctl, cmd, mode);
6340 if (mrsas_common_check(instance, cmd) != DDI_SUCCESS)
6343 if (instance->tbolt) {
6344 return_raid_msg_mfi_pkt(instance, cmd);
6346 mrsas_return_mfi_pkt(instance, cmd);
6356 handle_mfi_aen(struct mrsas_instance *instance, struct mrsas_aen *aen)
6360 rval = register_mfi_aen(instance, instance->aen_seq_num,
6369 register_mfi_aen(struct mrsas_instance *instance, uint32_t seq_num,
6395 aen_cmd = instance->aen_cmd;
6426 ret_val = abort_aen_cmd(instance, aen_cmd);
6440 if (instance->tbolt) {
6441 cmd = get_raid_msg_mfi_pkt(instance);
6443 cmd = mrsas_get_mfi_pkt(instance);
6447 DTRACE_PROBE2(mfi_aen_err, uint16_t, instance->fw_outstanding,
6448 uint16_t, instance->max_fw_cmds);
6462 (void) memset(instance->mfi_evt_detail_obj.buffer, 0,
6482 instance->mfi_evt_detail_obj.dma_cookie[0].dmac_address);
6486 instance->aen_seq_num = seq_num;
6494 instance->aen_cmd = cmd;
6499 /* atomic_add_16 (&instance->fw_outstanding, 1); */
6500 if (instance->tbolt) {
6501 mr_sas_tbolt_build_mfi_cmd(instance, cmd);
6503 instance->func_ptr->issue_cmd(cmd, instance);
6581 struct mrsas_instance *instance = arg;
6589 if (instance->adapterresetinprogress == 1) {
6593 instance->timeout_id = timeout(io_timeout_checker,
6594 (void *) instance, drv_usectohz(MRSAS_1_SECOND));
6599 if (mrsas_initiate_ocr_if_fw_is_faulty(instance) == 1) {
6600 dev_err(instance->dip, CE_WARN, "io_timeout_checker: "
6602 dev_err(instance->dip, CE_CONT, "io_timeout_checker: "
6604 instance->fw_outstanding, instance->max_fw_cmds);
6605 if (instance->adapterresetinprogress == 0) {
6606 instance->adapterresetinprogress = 1;
6607 if (instance->tbolt)
6608 (void) mrsas_tbolt_reset_ppc(instance);
6610 (void) mrsas_reset_ppc(instance);
6611 instance->adapterresetinprogress = 0;
6613 instance->timeout_id = timeout(io_timeout_checker,
6614 (void *) instance, drv_usectohz(MRSAS_1_SECOND));
6620 mutex_enter(&instance->cmd_pend_mtx);
6621 mlist_for_each_safe(pos, next, &instance->cmd_pend_list) {
6642 dev_err(instance->dip, CE_WARN, "%llx: "
6646 instance->fw_outstanding, instance->max_fw_cmds);
6652 mutex_exit(&instance->cmd_pend_mtx);
6655 if (instance->disable_online_ctrl_reset == 1) {
6656 dev_err(instance->dip, CE_WARN, "%s(): OCR is NOT "
6660 if (instance->tbolt)
6661 mrsas_tbolt_kill_adapter(instance);
6663 (void) mrsas_kill_adapter(instance);
6668 if (instance->adapterresetinprogress == 0) {
6669 if (instance->tbolt) {
6671 instance);
6674 instance);
6678 dev_err(instance->dip, CE_WARN,
6684 mrsas_print_cmd_details(instance, cmd, 0xDD);
6686 if (instance->tbolt)
6687 mrsas_tbolt_kill_adapter(instance);
6689 (void) mrsas_kill_adapter(instance);
6697 instance->timeout_id =
6698 timeout(io_timeout_checker, (void *)instance,
6703 read_fw_status_reg_ppc(struct mrsas_instance *instance)
6705 return ((uint32_t)RD_OB_SCRATCH_PAD_0(instance));
6709 issue_cmd_ppc(struct mrsas_cmd *cmd, struct mrsas_instance *instance)
6712 atomic_inc_16(&instance->fw_outstanding);
6718 ": %p instance : %p pkt : %p pkt_time : %x\n",
6719 gethrtime(), (void *)cmd, (void *)instance,
6721 if (instance->adapterresetinprogress) {
6725 push_pending_mfi_pkt(instance, cmd);
6730 "ISSUED CMD TO FW : called : cmd : %p, instance: %p"
6731 "(NO PKT)\n", gethrtime(), (void *)cmd, (void *)instance));
6734 mutex_enter(&instance->reg_write_mtx);
6737 (((cmd->frame_count - 1) << 1) | 1), instance);
6738 mutex_exit(&instance->reg_write_mtx);
6746 issue_cmd_in_sync_mode_ppc(struct mrsas_instance *instance,
6755 if (instance->adapterresetinprogress) {
6764 (((cmd->frame_count - 1) << 1) | 1), instance);
6769 push_pending_mfi_pkt(instance, cmd);
6774 mutex_enter(&instance->reg_write_mtx);
6777 (((cmd->frame_count - 1) << 1) | 1), instance);
6778 mutex_exit(&instance->reg_write_mtx);
6780 mutex_enter(&instance->int_cmd_mtx);
6782 cv_wait(&instance->int_cmd_cv, &instance->int_cmd_mtx);
6784 mutex_exit(&instance->int_cmd_mtx);
6799 issue_cmd_in_poll_mode_ppc(struct mrsas_instance *instance,
6819 (((cmd->frame_count - 1) << 1) | 1), instance);
6839 enable_intr_ppc(struct mrsas_instance *instance)
6845 if (instance->skinny) {
6847 WR_OB_INTR_MASK(0xfffffffe, instance);
6849 /* WR_OB_DOORBELL_CLEAR(0xFFFFFFFF, instance); */
6850 WR_OB_DOORBELL_CLEAR(OB_DOORBELL_CLEAR_MASK, instance);
6852 /* WR_OB_INTR_MASK(~0x80000000, instance); */
6853 WR_OB_INTR_MASK(~(MFI_REPLY_2108_MESSAGE_INTR_MASK), instance);
6857 mask = RD_OB_INTR_MASK(instance);
6864 disable_intr_ppc(struct mrsas_instance *instance)
6871 "outbound_intr_mask = 0x%x", RD_OB_INTR_MASK(instance)));
6875 WR_OB_INTR_MASK(OB_INTR_MASK, instance);
6878 "outbound_intr_mask = 0x%x", RD_OB_INTR_MASK(instance)));
6881 mask = RD_OB_INTR_MASK(instance);
6888 intr_ack_ppc(struct mrsas_instance *instance)
6896 status = RD_OB_INTR_STATUS(instance);
6908 if (mrsas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
6909 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
6921 if (instance->skinny) {
6922 WR_OB_INTR_STATUS(status, instance);
6924 WR_OB_DOORBELL_CLEAR(status, instance);
6928 status = RD_OB_INTR_STATUS(instance);
6942 mrsas_kill_adapter(struct mrsas_instance *instance)
6944 if (instance->deadadapter == 1)
6949 mutex_enter(&instance->ocr_flags_mtx);
6950 instance->deadadapter = 1;
6951 mutex_exit(&instance->ocr_flags_mtx);
6952 instance->func_ptr->disable_intr(instance);
6953 WR_IB_DOORBELL(MFI_STOP_ADP, instance);
6954 (void) mrsas_complete_pending_cmds(instance);
6960 mrsas_reset_ppc(struct mrsas_instance *instance)
6969 if (instance->deadadapter == 1) {
6970 dev_err(instance->dip, CE_WARN, "mrsas_reset_ppc: "
6974 mutex_enter(&instance->ocr_flags_mtx);
6975 instance->adapterresetinprogress = 1;
6976 mutex_exit(&instance->ocr_flags_mtx);
6980 instance->func_ptr->disable_intr(instance);
6982 WR_IB_WRITE_SEQ(0, instance);
6983 WR_IB_WRITE_SEQ(4, instance);
6984 WR_IB_WRITE_SEQ(0xb, instance);
6985 WR_IB_WRITE_SEQ(2, instance);
6986 WR_IB_WRITE_SEQ(7, instance);
6987 WR_IB_WRITE_SEQ(0xd, instance);
6991 status = RD_OB_DRWE(instance);
6995 status = RD_OB_DRWE(instance);
6997 dev_err(instance->dip, CE_WARN,
7003 WR_IB_DRWE(status | DIAG_RESET_ADAPTER, instance);
7005 status = RD_OB_DRWE(instance);
7008 status = RD_OB_DRWE(instance);
7010 dev_err(instance->dip, CE_WARN, "mrsas_reset_ppc: "
7013 (void) mrsas_kill_adapter(instance);
7022 if (mfi_state_transition_to_ready(instance) ||
7025 instance->func_ptr->read_fw_status_reg(instance);
7041 instance->fw_fault_count_after_ocr++;
7042 if (instance->fw_fault_count_after_ocr
7044 dev_err(instance->dip, CE_WARN,
7048 instance->fw_fault_count_after_ocr);
7052 dev_err(instance->dip, CE_WARN,
7058 (void) mrsas_kill_adapter(instance);
7064 instance->fw_fault_count_after_ocr = 0;
7067 ddi_put32(instance->mfi_internal_dma_obj.acc_handle,
7068 instance->producer, 0);
7070 ddi_put32(instance->mfi_internal_dma_obj.acc_handle,
7071 instance->consumer, 0);
7075 "producer %x consumer %x", *instance->producer,
7076 *instance->consumer));
7080 (void) mrsas_issue_init_mfi(instance);
7086 (void) mrsas_print_pending_cmds(instance);
7090 instance->func_ptr->enable_intr(instance);
7091 instance->fw_outstanding = 0;
7095 (void) mrsas_issue_pending_cmds(instance);
7103 instance->aen_cmd->retry_count_for_ocr = 0;
7104 instance->aen_cmd->drv_pkt_time = 0;
7106 instance->func_ptr->issue_cmd(instance->aen_cmd, instance);
7109 mutex_enter(&instance->ocr_flags_mtx);
7110 instance->adapterresetinprogress = 0;
7111 mutex_exit(&instance->ocr_flags_mtx);
7123 mrsas_common_check(struct mrsas_instance *instance, struct mrsas_cmd *cmd)
7130 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
7137 if (mrsas_check_dma_handle(instance->mfi_internal_dma_obj.dma_handle)
7139 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
7146 if (mrsas_check_dma_handle(instance->mfi_evt_detail_obj.dma_handle) !=
7148 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
7155 if (mrsas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
7156 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
7158 ddi_fm_acc_err_clear(instance->regmap_handle, DDI_FME_VER0);
7183 mrsas_fm_init(struct mrsas_instance *instance)
7189 if (instance->fm_capabilities) {
7200 ddi_fm_init(instance->dip, &instance->fm_capabilities, &fm_ibc);
7207 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities) ||
7208 DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
7209 pci_ereport_setup(instance->dip);
7215 if (DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
7216 ddi_fm_handler_register(instance->dip,
7217 mrsas_fm_error_cb, (void*) instance);
7226 mrsas_fm_fini(struct mrsas_instance *instance)
7229 if (instance->fm_capabilities) {
7233 if (DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
7234 ddi_fm_handler_unregister(instance->dip);
7240 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities) ||
7241 DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
7242 pci_ereport_teardown(instance->dip);
7246 ddi_fm_fini(instance->dip);
7283 mrsas_fm_ereport(struct mrsas_instance *instance, char *detail)
7290 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities)) {
7291 ddi_fm_ereport_post(instance->dip, buf, ena, DDI_NOSLEEP,
7297 mrsas_add_intrs(struct mrsas_instance *instance, int intr_type)
7300 dev_info_t *dip = instance->dip;
7337 instance->intr_htable_size = count * sizeof (ddi_intr_handle_t);
7338 instance->intr_htable = kmem_zalloc(instance->intr_htable_size,
7340 ASSERT(instance->intr_htable);
7347 ret = ddi_intr_alloc(dip, instance->intr_htable, intr_type, 0,
7360 instance->intr_cnt = actual;
7365 if ((ret = ddi_intr_get_pri(instance->intr_htable[0],
7366 &instance->intr_pri)) != DDI_SUCCESS) {
7375 if (instance->intr_pri >= ddi_intr_get_hilevel_pri()) {
7382 instance->intr_pri));
7386 ret = ddi_intr_add_handler(instance->intr_htable[i],
7387 (ddi_intr_handler_t *)mrsas_isr, (caddr_t)instance,
7400 if ((ret = ddi_intr_get_cap(instance->intr_htable[0],
7401 &instance->intr_cap)) != DDI_SUCCESS) {
7407 if (instance->intr_cap & DDI_INTR_FLAG_BLOCK) {
7410 (void) ddi_intr_block_enable(instance->intr_htable,
7411 instance->intr_cnt);
7415 for (i = 0; i < instance->intr_cnt; i++) {
7416 (void) ddi_intr_enable(instance->intr_htable[i]);
7426 (void) ddi_intr_remove_handler(instance->intr_htable[i]);
7430 (void) ddi_intr_free(instance->intr_htable[i]);
7433 if (instance->intr_htable != NULL)
7434 kmem_free(instance->intr_htable, instance->intr_htable_size);
7436 instance->intr_htable = NULL;
7437 instance->intr_htable_size = 0;
7445 mrsas_rem_intrs(struct mrsas_instance *instance)
7452 if (instance->intr_cap & DDI_INTR_FLAG_BLOCK) {
7453 (void) ddi_intr_block_disable(instance->intr_htable,
7454 instance->intr_cnt);
7456 for (i = 0; i < instance->intr_cnt; i++) {
7457 (void) ddi_intr_disable(instance->intr_htable[i]);
7463 for (i = 0; i < instance->intr_cnt; i++) {
7464 (void) ddi_intr_remove_handler(instance->intr_htable[i]);
7465 (void) ddi_intr_free(instance->intr_htable[i]);
7468 if (instance->intr_htable != NULL)
7469 kmem_free(instance->intr_htable, instance->intr_htable_size);
7471 instance->intr_htable = NULL;
7472 instance->intr_htable_size = 0;
7480 struct mrsas_instance *instance;
7489 if ((instance = ddi_get_soft_state(mrsas_state,
7512 rval = mrsas_config_ld(instance, tgt, lun, childp);
7514 } else if ((instance->tbolt || instance->skinny) && lun != 0) {
7515 rval = mrsas_tbolt_config_pd(instance,
7527 rval = mrsas_config_all_devices(instance);
7546 mrsas_config_all_devices(struct mrsas_instance *instance)
7551 (void) mrsas_config_ld(instance, tgt, 0, NULL);
7557 if (instance->tbolt || instance->skinny) {
7558 for (tgt = 0; tgt < instance->mr_tbolt_pd_max; tgt++) {
7559 (void) mrsas_tbolt_config_pd(instance, tgt, 1, NULL);
7613 mrsas_config_ld(struct mrsas_instance *instance, uint16_t tgt,
7623 if ((child = mrsas_find_child(instance, tgt, lun)) != NULL) {
7627 if (instance->mr_ld_list[tgt].flag != MRDRV_TGT_VALID) {
7628 rval = mrsas_service_evt(instance, tgt, 0,
7639 sd->sd_address.a_hba_tran = instance->tran;
7644 rval = mrsas_config_scsi_device(instance, sd, ldip);
7661 mrsas_config_scsi_device(struct mrsas_instance *instance,
7690 rval = ndi_devi_alloc(instance->dip, childname, DEVI_SID_NODEID, &ldip);
7744 mrsas_service_evt(struct mrsas_instance *instance, int tgt, int lun, int event,
7753 if ((instance->taskq == NULL) || (mrevt =
7758 mrevt->instance = instance;
7764 if ((ddi_taskq_dispatch(instance->taskq,
7780 struct mrsas_instance *instance = mrevt->instance;
7790 mutex_enter(&instance->config_dev_mtx);
7791 dip = instance->mr_ld_list[mrevt->tgt].dip;
7792 mutex_exit(&instance->config_dev_mtx);
7795 mutex_enter(&instance->config_dev_mtx);
7796 dip = instance->mr_tbolt_pd_list[mrevt->tgt].dip;
7797 mutex_exit(&instance->config_dev_mtx);
7802 ndi_devi_enter(instance->dip, &circ1);
7808 (void) mrsas_config_ld(instance, mrevt->tgt,
7811 } else if (instance->tbolt || instance->skinny) {
7812 (void) mrsas_tbolt_config_pd(instance,
7856 ndi_devi_exit(instance->dip, circ1);