Lines Matching defs:instance
182 * anything that has to do with a particular instance of the device.
183 * Per-instance initialization must be done in attach().
269 * The kernel calls a driver's attach() entry point to attach an instance of
270 * a device (for MegaRAID, it is instance of a controller) or to resume
271 * operation for an instance of a device that has been suspended or has been
275 * - allocate a soft-state structure for the device instance (for MegaRAID,
276 * controller instance)
277 * - initialize per-instance mutexes
280 * - map the registers and memory of the device instance (for MegaRAID,
281 * controller instance)
282 * - create minor device nodes for the device instance (for MegaRAID,
283 * controller instance)
284 * - report that the device instance (for MegaRAID, controller instance) has
307 struct megasas_instance *instance;
330 /* allocate the soft state for the instance */
340 instance = (struct megasas_instance *)ddi_get_soft_state
343 if (instance == NULL) {
352 bzero((caddr_t)instance,
355 instance->func_ptr = kmem_zalloc(
357 ASSERT(instance->func_ptr);
360 if (pci_config_setup(dip, &instance->pci_handle) !=
366 kmem_free(instance->func_ptr,
377 pci_config_teardown(&instance->pci_handle);
378 kmem_free(instance->func_ptr,
385 vendor_id = pci_config_get16(instance->pci_handle,
387 device_id = pci_config_get16(instance->pci_handle,
390 subsysvid = pci_config_get16(instance->pci_handle,
392 subsysid = pci_config_get16(instance->pci_handle,
395 pci_config_put16(instance->pci_handle, PCI_CONF_COMM,
396 (pci_config_get16(instance->pci_handle,
398 irq = pci_config_get8(instance->pci_handle,
407 command = pci_config_get16(instance->pci_handle,
413 pci_config_put16(instance->pci_handle,
428 instance->func_ptr->read_fw_status_reg =
430 instance->func_ptr->issue_cmd = issue_cmd_ppc;
431 instance->func_ptr->issue_cmd_in_sync_mode =
433 instance->func_ptr->issue_cmd_in_poll_mode =
435 instance->func_ptr->enable_intr =
437 instance->func_ptr->disable_intr =
439 instance->func_ptr->intr_ack = intr_ack_ppc;
443 instance->func_ptr->read_fw_status_reg =
445 instance->func_ptr->issue_cmd =
447 instance->func_ptr->issue_cmd_in_sync_mode =
449 instance->func_ptr->issue_cmd_in_poll_mode =
451 instance->func_ptr->enable_intr =
453 instance->func_ptr->disable_intr =
455 instance->func_ptr->intr_ack =
459 instance->baseaddress = pci_config_get32(
460 instance->pci_handle, PCI_CONF_BASE0);
461 instance->baseaddress &= 0x0fffc;
463 instance->dip = dip;
464 instance->vendor_id = vendor_id;
465 instance->device_id = device_id;
466 instance->subsysvid = subsysvid;
467 instance->subsysid = subsysid;
470 instance->fm_capabilities = ddi_prop_get_int(
471 DDI_DEV_T_ANY, instance->dip, DDI_PROP_DONTPASS,
476 megasas_fm_init(instance);
479 if (init_mfi(instance) != DDI_SUCCESS) {
496 &instance->iblock_cookie) != DDI_SUCCESS) {
502 &instance->soft_iblock_cookie) != DDI_SUCCESS) {
512 instance->isr_level = HIGH_LEVEL_INTR;
513 mutex_init(&instance->cmd_pool_mtx,
515 instance->soft_iblock_cookie);
516 mutex_init(&instance->cmd_pend_mtx,
518 instance->soft_iblock_cookie);
524 instance->isr_level = NORMAL_LEVEL_INTR;
525 mutex_init(&instance->cmd_pool_mtx,
527 instance->iblock_cookie);
528 mutex_init(&instance->cmd_pend_mtx,
530 instance->iblock_cookie);
533 mutex_init(&instance->completed_pool_mtx,
535 instance->iblock_cookie);
536 mutex_init(&instance->int_cmd_mtx, "int_cmd_mtx",
537 MUTEX_DRIVER, instance->iblock_cookie);
538 mutex_init(&instance->aen_cmd_mtx, "aen_cmd_mtx",
539 MUTEX_DRIVER, instance->iblock_cookie);
540 mutex_init(&instance->abort_cmd_mtx, "abort_cmd_mtx",
541 MUTEX_DRIVER, instance->iblock_cookie);
543 cv_init(&instance->int_cmd_cv, NULL, CV_DRIVER, NULL);
544 cv_init(&instance->abort_cmd_cv, NULL, CV_DRIVER, NULL);
546 INIT_LIST_HEAD(&instance->completed_pool_list);
550 (caddr_t)instance) != DDI_SUCCESS) {
560 if (instance->isr_level == HIGH_LEVEL_INTR) {
562 &instance->soft_intr_id, NULL, NULL,
563 megasas_softintr, (caddr_t)instance) !=
585 instance->tran = tran;
587 tran->tran_hba_private = instance;
607 tran_dma_attr.dma_attr_sgllen = instance->max_num_sge;
609 /* Attach this instance of the hba */
643 (void) sprintf(instance->iocnode, "%d:lsirdctl",
650 if (ddi_create_minor_node(dip, instance->iocnode,
662 instance->func_ptr->enable_intr(instance);
665 if (start_mfi_aen(instance)) {
672 "AEN started for instance %d.", instance_no));
677 if (megasas_check_acc_handle(instance->regmap_handle) !=
681 if (megasas_check_acc_handle(instance->pci_handle) !=
713 ddi_remove_minor_node(dip, instance->iocnode);
722 ddi_remove_softintr(instance->soft_intr_id);
726 ddi_remove_intr(dip, 0, instance->iblock_cookie);
729 megasas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
730 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
732 megasas_fm_fini(instance);
734 pci_config_teardown(&instance->pci_handle);
752 * the driver knows. The mapping of minor numbers to device instance is
765 struct megasas_instance *instance;
771 instance = (struct megasas_instance *)
775 if (instance == NULL) {
779 *resultp = instance->dip;
784 *resultp = (void *)instance;
800 * A driver's detach() entry point is called to detach an instance of a device
801 * that is bound to the driver. The entry point is called with the instance of
813 struct megasas_instance *instance;
822 instance = (struct megasas_instance *)ddi_get_soft_state(megasas_state,
825 if (!instance) {
827 "megasas:%d could not get instance in detach",
835 instance_no, instance->vendor_id, instance->device_id,
836 instance->subsysvid, instance->subsysid));
851 scsi_hba_tran_free(instance->tran);
853 if (abort_aen_cmd(instance, instance->aen_cmd)) {
860 instance->func_ptr->disable_intr(instance);
862 if (instance->isr_level == HIGH_LEVEL_INTR) {
863 ddi_remove_softintr(instance->soft_intr_id);
866 ddi_remove_intr(dip, 0, instance->iblock_cookie);
868 free_space_for_mfi(instance);
870 megasas_fm_fini(instance);
872 pci_config_teardown(&instance->pci_handle);
874 kmem_free(instance->func_ptr,
997 struct megasas_instance *instance;
1003 instance = ddi_get_soft_state(megasas_state, MINOR2INST(getminor(dev)));
1005 if (instance == NULL) {
1021 rval = handle_drv_ioctl(instance, &ioctl, mode);
1023 rval = handle_mfi_ioctl(instance, &ioctl, mode);
1042 rval = handle_mfi_aen(instance, &aen);
1083 struct megasas_instance *instance;
1086 instance = (struct megasas_instance *)ddi_get_soft_state
1091 if (!instance) {
1098 con_log(CL_ANN, (CE_NOTE, "flushing cache for instance %d ..",
1101 flush_cache(instance);
1115 * tran_tgt_init - initialize a target device instance
1124 * By returning DDI_FAILURE, the instance of the target driver for that device
1163 struct megasas_instance *instance;
1168 instance = ADDR2MEGA(ap);
1172 pkt = scsi_hba_pkt_alloc(instance->dip, ap, cmdlen, statuslen,
1211 if (megasas_dma_alloc(instance, pkt, bp, flags,
1220 if (megasas_dma_move(instance, pkt, bp) == -1) {
1243 * TRAN_ACCEPT - pkt has been submitted to the instance
1250 struct megasas_instance *instance = ADDR2MEGA(ap);
1259 cmd = build_cmd(instance, ap, pkt, &cmd_done);
1282 if (instance->fw_outstanding > instance->max_fw_cmds) {
1284 return_mfi_pkt(instance, cmd);
1292 instance->func_ptr->issue_cmd(cmd, instance);
1299 instance->func_ptr-> issue_cmd_in_poll_mode(instance, cmd);
1327 return_mfi_pkt(instance, cmd);
1328 (void) megasas_common_check(instance, cmd);
1376 struct megasas_instance *instance = ADDR2MEGA(ap);
1380 if (wait_for_outstanding(instance)) {
1405 struct megasas_instance *instance = ddi_get_soft_state(megasas_state,
1410 if (wait_for_outstanding(instance)) {
1435 struct megasas_instance *instance = ADDR2MEGA(ap);
1471 rval = instance->init_id;
1688 megasas_isr(struct megasas_instance *instance)
1699 ASSERT(instance);
1700 if (!instance->func_ptr->intr_ack(instance)) {
1704 (void) ddi_dma_sync(instance->mfi_internal_dma_obj.dma_handle,
1707 if (megasas_check_dma_handle(instance->mfi_internal_dma_obj.dma_handle)
1709 megasas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
1710 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
1714 producer = *instance->producer;
1715 consumer = *instance->consumer;
1720 mutex_enter(&instance->completed_pool_mtx);
1723 context = instance->reply_queue[consumer];
1724 cmd = instance->cmd_list[context];
1725 mlist_add_tail(&cmd->list, &instance->completed_pool_list);
1728 if (consumer == (instance->max_fw_cmds + 1)) {
1733 mutex_exit(&instance->completed_pool_mtx);
1735 *instance->consumer = consumer;
1736 (void) ddi_dma_sync(instance->mfi_internal_dma_obj.dma_handle,
1739 if (instance->softint_running) {
1745 if (instance->isr_level == HIGH_LEVEL_INTR) {
1747 ddi_trigger_softintr(instance->soft_intr_id);
1754 (void) megasas_softintr(instance);
1772 get_mfi_pkt(struct megasas_instance *instance)
1774 mlist_t *head = &instance->cmd_pool_list;
1777 mutex_enter(&instance->cmd_pool_mtx);
1778 ASSERT(mutex_owned(&instance->cmd_pool_mtx));
1786 mutex_exit(&instance->cmd_pool_mtx);
1795 return_mfi_pkt(struct megasas_instance *instance, struct megasas_cmd *cmd)
1797 mutex_enter(&instance->cmd_pool_mtx);
1798 ASSERT(mutex_owned(&instance->cmd_pool_mtx));
1800 mlist_add(&cmd->list, &instance->cmd_pool_list);
1802 mutex_exit(&instance->cmd_pool_mtx);
1809 destroy_mfi_frame_pool(struct megasas_instance *instance)
1812 uint32_t max_cmd = instance->max_fw_cmds;
1819 cmd = instance->cmd_list[i];
1822 (void) mega_free_dma_obj(instance, cmd->frame_dma_obj);
1833 create_mfi_frame_pool(struct megasas_instance *instance)
1844 max_cmd = instance->max_fw_cmds;
1849 sgl_sz = sge_sz * instance->max_num_sge;
1856 cmd = instance->cmd_list[i];
1866 cookie_cnt = mega_alloc_dma_obj(instance, &cmd->frame_dma_obj);
1909 free_additional_dma_buffer(struct megasas_instance *instance)
1911 if (instance->mfi_internal_dma_obj.status == DMA_OBJ_ALLOCATED) {
1912 (void) mega_free_dma_obj(instance,
1913 instance->mfi_internal_dma_obj);
1914 instance->mfi_internal_dma_obj.status = DMA_OBJ_FREED;
1917 if (instance->mfi_evt_detail_obj.status == DMA_OBJ_ALLOCATED) {
1918 (void) mega_free_dma_obj(instance,
1919 instance->mfi_evt_detail_obj);
1920 instance->mfi_evt_detail_obj.status = DMA_OBJ_FREED;
1928 alloc_additional_dma_buffer(struct megasas_instance *instance)
1934 reply_q_sz = sizeof (uint32_t) * (instance->max_fw_cmds + 1 + 2);
1936 instance->mfi_internal_dma_obj.size = internal_buf_size;
1937 instance->mfi_internal_dma_obj.dma_attr = megasas_generic_dma_attr;
1938 instance->mfi_internal_dma_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
1939 instance->mfi_internal_dma_obj.dma_attr.dma_attr_count_max =
1941 instance->mfi_internal_dma_obj.dma_attr.dma_attr_sgllen = 1;
1943 if (mega_alloc_dma_obj(instance, &instance->mfi_internal_dma_obj)
1949 bzero(instance->mfi_internal_dma_obj.buffer, internal_buf_size);
1951 instance->mfi_internal_dma_obj.status |= DMA_OBJ_ALLOCATED;
1953 instance->producer = (uint32_t *)((unsigned long)
1954 instance->mfi_internal_dma_obj.buffer);
1955 instance->consumer = (uint32_t *)((unsigned long)
1956 instance->mfi_internal_dma_obj.buffer + 4);
1957 instance->reply_queue = (uint32_t *)((unsigned long)
1958 instance->mfi_internal_dma_obj.buffer + 8);
1959 instance->internal_buf = (caddr_t)(((unsigned long)
1960 instance->mfi_internal_dma_obj.buffer) + reply_q_sz + 8);
1961 instance->internal_buf_dmac_add =
1962 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address +
1964 instance->internal_buf_size = internal_buf_size -
1968 instance->mfi_evt_detail_obj.size = sizeof (struct megasas_evt_detail);
1969 instance->mfi_evt_detail_obj.dma_attr = megasas_generic_dma_attr;
1970 instance->mfi_evt_detail_obj.dma_attr.dma_attr_addr_hi = 0xFFFFFFFFU;
1971 instance->mfi_evt_detail_obj.dma_attr.dma_attr_count_max = 0xFFFFFFFFU;
1972 instance->mfi_evt_detail_obj.dma_attr.dma_attr_sgllen = 1;
1973 instance->mfi_evt_detail_obj.dma_attr.dma_attr_align = 1;
1975 if (mega_alloc_dma_obj(instance, &instance->mfi_evt_detail_obj) != 1) {
1981 bzero(instance->mfi_evt_detail_obj.buffer,
1984 instance->mfi_evt_detail_obj.status |= DMA_OBJ_ALLOCATED;
1993 free_space_for_mfi(struct megasas_instance *instance)
1996 uint32_t max_cmd = instance->max_fw_cmds;
1999 if (instance->cmd_list == NULL) {
2003 free_additional_dma_buffer(instance);
2006 destroy_mfi_frame_pool(instance);
2009 for (i = 0; i < instance->max_fw_cmds; i++) {
2010 kmem_free(instance->cmd_list[i],
2013 instance->cmd_list[i] = NULL;
2017 kmem_free(instance->cmd_list,
2020 instance->cmd_list = NULL;
2022 INIT_LIST_HEAD(&instance->cmd_pool_list);
2029 alloc_space_for_mfi(struct megasas_instance *instance)
2037 max_cmd = instance->max_fw_cmds;
2041 * instance->cmd_list is an array of struct megasas_cmd pointers.
2045 instance->cmd_list = kmem_zalloc(sz, KM_SLEEP);
2046 ASSERT(instance->cmd_list);
2049 instance->cmd_list[i] = kmem_zalloc(sizeof (struct megasas_cmd),
2051 ASSERT(instance->cmd_list[i]);
2054 INIT_LIST_HEAD(&instance->cmd_pool_list);
2056 /* add all the commands to command pool (instance->cmd_pool) */
2058 cmd = instance->cmd_list[i];
2061 mlist_add_tail(&cmd->list, &instance->cmd_pool_list);
2065 if (create_mfi_frame_pool(instance)) {
2071 if (alloc_additional_dma_buffer(instance)) {
2083 get_ctrl_info(struct megasas_instance *instance,
2092 cmd = get_mfi_pkt(instance);
2102 ci = (struct megasas_ctrl_info *)instance->internal_buf;
2107 return_mfi_pkt(instance, cmd);
2123 dcmd->sgl.sge32[0].phys_addr = instance->internal_buf_dmac_add;
2128 if (!instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
2136 return_mfi_pkt(instance, cmd);
2137 if (megasas_common_check(instance, cmd) != DDI_SUCCESS) {
2148 abort_aen_cmd(struct megasas_instance *instance,
2156 cmd = get_mfi_pkt(instance);
2174 instance->aen_cmd->abort_aen = 1;
2179 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
2187 instance->aen_cmd->abort_aen = 1;
2188 instance->aen_cmd = 0;
2190 return_mfi_pkt(instance, cmd);
2191 (void) megasas_common_check(instance, cmd);
2200 init_mfi(struct megasas_instance *instance)
2208 if ((ddi_dev_regsize(instance->dip, REGISTER_SET_IO, ®length)
2219 if (ddi_regs_map_setup(instance->dip, REGISTER_SET_IO,
2220 &instance->regmap, 0, reglength, &endian_attr,
2221 &instance->regmap_handle) != DDI_SUCCESS) {
2229 if (mfi_state_transition_to_ready(instance)) {
2235 instance->max_num_sge =
2236 (instance->func_ptr->read_fw_status_reg(instance) &
2243 instance->max_fw_cmds =
2244 instance->func_ptr->read_fw_status_reg(instance) & 0xFFFF;
2245 instance->max_fw_cmds = instance->max_fw_cmds - 1;
2247 instance->max_num_sge =
2248 (instance->max_num_sge > MEGASAS_MAX_SGE_CNT) ?
2249 MEGASAS_MAX_SGE_CNT : instance->max_num_sge;
2252 if (alloc_space_for_mfi(instance))
2256 instance->func_ptr->disable_intr(instance);
2264 cmd = get_mfi_pkt(instance);
2275 initq_info->reply_queue_entries = instance->max_fw_cmds + 1;
2279 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address;
2283 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 4;
2287 instance->mfi_internal_dma_obj.dma_cookie[0].dmac_address + 8;
2301 if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
2306 return_mfi_pkt(instance, cmd);
2307 if (megasas_common_check(instance, cmd) != DDI_SUCCESS) {
2312 if (!get_ctrl_info(instance, &ctrl_info)) {
2313 instance->max_sectors_per_req = ctrl_info.max_request_size;
2317 instance->max_sectors_per_req = instance->max_num_sge *
2321 if (megasas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
2330 free_space_for_mfi(instance);
2333 ddi_regs_map_free(&instance->regmap_handle);
2345 mfi_state_transition_to_ready(struct megasas_instance *instance)
2354 instance->func_ptr->read_fw_status_reg(instance) & MFI_STATE_MASK;
2377 /* WR_IB_MSG_0(MFI_INIT_CLEAR_HANDSHAKE, instance); */
2379 MFI_INIT_HOTPLUG, instance);
2393 WR_IB_DOORBELL(MFI_INIT_HOTPLUG, instance);
2400 instance->func_ptr->disable_intr(instance);
2408 /* WR_IB_DOORBELL(MFI_INIT_READY, instance); */
2409 WR_IB_DOORBELL(MFI_RESET_FLAGS, instance);
2441 /* fw_state = RD_OB_MSG_0(instance) & MFI_STATE_MASK; */
2443 instance->func_ptr->read_fw_status_reg(instance) &
2461 fw_ctrl = RD_IB_DOORBELL(instance);
2474 WR_IB_DOORBELL(0xF, instance);
2476 if (megasas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
2486 get_seq_num(struct megasas_instance *instance,
2495 cmd = get_mfi_pkt(instance);
2512 if (mega_alloc_dma_obj(instance, &dcmd_dma_obj) != 1) {
2536 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
2547 if (mega_free_dma_obj(instance, dcmd_dma_obj) != DDI_SUCCESS)
2550 return_mfi_pkt(instance, cmd);
2551 if (megasas_common_check(instance, cmd) != DDI_SUCCESS) {
2561 start_mfi_aen(struct megasas_instance *instance)
2571 if (get_seq_num(instance, &eli)) {
2581 ret = register_mfi_aen(instance, eli.newest_seq_num + 1,
2596 flush_cache(struct megasas_instance *instance)
2601 if (!(cmd = get_mfi_pkt(instance)))
2619 if (instance->func_ptr->issue_cmd_in_poll_mode(instance, cmd)) {
2624 return_mfi_pkt(instance, cmd);
2625 (void) megasas_common_check(instance, cmd);
2630 * @instance: Adapter soft state
2635 service_mfi_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
2639 (struct megasas_evt_detail *)instance->mfi_evt_detail_obj.buffer;
2651 if (ddi_log_sysevent(instance->dip, DDI_VENDOR_LSI, "LSIMEGA", "SAS",
2653 int instance_no = ddi_get_instance(instance->dip);
2661 (void) memset(instance->mfi_evt_detail_obj.buffer, 0,
2667 instance->aen_seq_num = seq_num;
2672 instance->func_ptr->issue_cmd(cmd, instance);
2677 * @instance: Adapter soft state
2685 complete_cmd_in_sync_mode(struct megasas_instance *instance,
2696 cv_broadcast(&instance->int_cmd_cv);
2707 megasas_softintr(struct megasas_instance *instance)
2719 ASSERT(instance);
2720 mutex_enter(&instance->completed_pool_mtx);
2722 if (mlist_empty(&instance->completed_pool_list)) {
2723 mutex_exit(&instance->completed_pool_mtx);
2727 instance->softint_running = 1;
2730 mlist_splice(&instance->completed_pool_list, &process_list);
2731 INIT_LIST_HEAD(&instance->completed_pool_list);
2733 mutex_exit(&instance->completed_pool_mtx);
2745 megasas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
2746 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
2767 complete_cmd_in_sync_mode(instance, cmd);
2912 atomic_add_16(&instance->fw_outstanding, (-1));
2914 return_mfi_pkt(instance, cmd);
2916 (void) megasas_common_check(instance, cmd);
2921 ddi_fm_service_impact(instance->dip,
2936 complete_cmd_in_sync_mode(instance, cmd);
2942 if ((instance->aen_cmd == cmd) &&
2943 (instance->aen_cmd->abort_aen)) {
2948 service_mfi_aen(instance, cmd);
2950 atomic_add_16(&instance->fw_outstanding,
2954 complete_cmd_in_sync_mode(instance, cmd);
2964 complete_cmd_in_sync_mode(instance, cmd);
2967 megasas_fm_ereport(instance, DDI_FM_DEVICE_NO_RESPONSE);
2968 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
2981 instance->softint_running = 0;
2992 mega_alloc_dma_obj(struct megasas_instance *instance, dma_obj_t *obj)
3001 i = ddi_dma_alloc_handle(instance->dip, &obj->dma_attr,
3048 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
3053 ddi_fm_service_impact(instance->dip, DDI_SERVICE_LOST);
3067 mega_free_dma_obj(struct megasas_instance *instance, dma_obj_t obj)
3071 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
3076 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
3094 megasas_dma_alloc(struct megasas_instance *instance, struct scsi_pkt *pkt,
3127 tmp_dma_attr.dma_attr_sgllen = instance->max_num_sge;
3130 if ((i = ddi_dma_alloc_handle(instance->dip, &tmp_dma_attr,
3188 if (i == instance->max_num_sge ||
3241 megasas_dma_move(struct megasas_instance *instance, struct scsi_pkt *pkt,
3281 if (i == instance->max_num_sge ||
3305 build_cmd(struct megasas_instance *instance, struct scsi_address *ap,
3321 acmd->device_id = MAP_DEVICE_ID(instance, ap);
3325 if (!(cmd = get_mfi_pkt(instance))) {
3359 * flush_cache(instance);
3360 * return_mfi_pkt(instance, cmd);
3508 * @instance: Adapter soft state
3515 wait_for_outstanding(struct megasas_instance *instance)
3521 if (!instance->fw_outstanding) {
3528 if (instance->fw_outstanding) {
3532 ddi_fm_acc_err_clear(instance->regmap_handle, DDI_FME_VERSION);
3541 issue_mfi_pthru(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
3589 if (mega_alloc_dma_obj(instance, &pthru_dma_obj) != 1) {
3632 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
3655 if (mega_free_dma_obj(instance, pthru_dma_obj) != DDI_SUCCESS)
3666 issue_mfi_dcmd(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
3714 if (mega_alloc_dma_obj(instance, &dcmd_dma_obj) != 1) {
3749 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
3767 if (mega_free_dma_obj(instance, dcmd_dma_obj) != DDI_SUCCESS)
3778 issue_mfi_smp(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
3857 if (mega_alloc_dma_obj(instance, &request_dma_obj) != 1) {
3883 if (mega_alloc_dma_obj(instance, &response_dma_obj) != 1) {
3954 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
3987 if (mega_free_dma_obj(instance, request_dma_obj) != DDI_SUCCESS)
3993 if (mega_free_dma_obj(instance, response_dma_obj) !=
4005 issue_mfi_stp(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
4070 if (mega_alloc_dma_obj(instance, &fis_dma_obj) != 1) {
4099 if (mega_alloc_dma_obj(instance, &data_dma_obj) != 1) {
4135 if (instance->func_ptr->issue_cmd_in_sync_mode(instance, cmd)) {
4162 if (mega_free_dma_obj(instance, fis_dma_obj) != DDI_SUCCESS)
4168 if (mega_free_dma_obj(instance, data_dma_obj) != DDI_SUCCESS)
4195 handle_drv_ioctl(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
4261 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, instance->dip,
4281 pci_config_get8(instance->pci_handle, i);
4310 handle_mfi_ioctl(struct megasas_instance *instance, struct megasas_ioctl *ioctl,
4318 cmd = get_mfi_pkt(instance);
4330 rval = issue_mfi_dcmd(instance, ioctl, cmd, mode);
4333 rval = issue_mfi_smp(instance, ioctl, cmd, mode);
4336 rval = issue_mfi_stp(instance, ioctl, cmd, mode);
4340 rval = issue_mfi_pthru(instance, ioctl, cmd, mode);
4350 return_mfi_pkt(instance, cmd);
4351 if (megasas_common_check(instance, cmd) != DDI_SUCCESS)
4360 handle_mfi_aen(struct megasas_instance *instance, struct megasas_aen *aen)
4364 rval = register_mfi_aen(instance, instance->aen_seq_num,
4373 register_mfi_aen(struct megasas_instance *instance, uint32_t seq_num,
4398 if (instance->aen_cmd) {
4399 prev_aen.word = instance->aen_cmd->frame->dcmd.mbox.w[1];
4426 ret_val = abort_aen_cmd(instance, instance->aen_cmd);
4439 cmd = get_mfi_pkt(instance);
4449 (void) memset(instance->mfi_evt_detail_obj.buffer, 0,
4463 instance->mfi_evt_detail_obj.dma_cookie[0].dmac_address;
4466 instance->aen_seq_num = seq_num;
4473 instance->aen_cmd = cmd;
4478 /* atomic_add_16 (&instance->fw_outstanding, 1); */
4479 instance->func_ptr->issue_cmd(cmd, instance);
4554 read_fw_status_reg_xscale(struct megasas_instance *instance)
4556 return ((int)RD_OB_MSG_0(instance));
4560 read_fw_status_reg_ppc(struct megasas_instance *instance)
4562 return ((int)RD_OB_SCRATCH_PAD_0(instance));
4566 issue_cmd_xscale(struct megasas_cmd *cmd, struct megasas_instance *instance)
4568 atomic_inc_16(&instance->fw_outstanding);
4572 (cmd->frame_count - 1), instance);
4576 issue_cmd_ppc(struct megasas_cmd *cmd, struct megasas_instance *instance)
4578 atomic_inc_16(&instance->fw_outstanding);
4582 (((cmd->frame_count - 1) << 1) | 1), instance);
4589 issue_cmd_in_sync_mode_xscale(struct megasas_instance *instance,
4598 (cmd->frame_count - 1), instance);
4600 mutex_enter(&instance->int_cmd_mtx);
4603 cv_wait(&instance->int_cmd_cv, &instance->int_cmd_mtx);
4606 mutex_exit(&instance->int_cmd_mtx);
4616 issue_cmd_in_sync_mode_ppc(struct megasas_instance *instance,
4627 (((cmd->frame_count - 1) << 1) | 1), instance);
4629 mutex_enter(&instance->int_cmd_mtx);
4632 cv_wait(&instance->int_cmd_cv, &instance->int_cmd_mtx);
4635 mutex_exit(&instance->int_cmd_mtx);
4650 issue_cmd_in_poll_mode_xscale(struct megasas_instance *instance,
4663 (cmd->frame_count - 1), instance);
4681 issue_cmd_in_poll_mode_ppc(struct megasas_instance *instance,
4696 (((cmd->frame_count - 1) << 1) | 1), instance);
4714 enable_intr_xscale(struct megasas_instance *instance)
4716 MFI_ENABLE_INTR(instance);
4720 enable_intr_ppc(struct megasas_instance *instance)
4726 /* WR_OB_DOORBELL_CLEAR(0xFFFFFFFF, instance); */
4727 WR_OB_DOORBELL_CLEAR(OB_DOORBELL_CLEAR_MASK, instance);
4733 /* WR_OB_INTR_MASK(~0x80000000, instance); */
4734 WR_OB_INTR_MASK(~(MFI_REPLY_1078_MESSAGE_INTR), instance);
4737 mask = RD_OB_INTR_MASK(instance);
4744 disable_intr_xscale(struct megasas_instance *instance)
4746 MFI_DISABLE_INTR(instance);
4750 disable_intr_ppc(struct megasas_instance *instance)
4757 "outbound_intr_mask = 0x%x\n", RD_OB_INTR_MASK(instance)));
4759 /* WR_OB_INTR_MASK(0xFFFFFFFF, instance); */
4760 WR_OB_INTR_MASK(OB_INTR_MASK, instance);
4763 "outbound_intr_mask = 0x%x\n", RD_OB_INTR_MASK(instance)));
4766 mask = RD_OB_INTR_MASK(instance);
4773 intr_ack_xscale(struct megasas_instance *instance)
4778 status = RD_OB_INTR_STATUS(instance);
4785 WR_OB_INTR_STATUS(status, instance);
4791 intr_ack_ppc(struct megasas_instance *instance)
4798 status = RD_OB_INTR_STATUS(instance);
4811 WR_OB_DOORBELL_CLEAR(status, instance);
4814 status = RD_OB_INTR_STATUS(instance);
4822 megasas_common_check(struct megasas_instance *instance,
4829 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4836 if (megasas_check_dma_handle(instance->mfi_internal_dma_obj.dma_handle)
4838 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4845 if (megasas_check_dma_handle(instance->mfi_evt_detail_obj.dma_handle) !=
4847 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4854 if (megasas_check_acc_handle(instance->regmap_handle) != DDI_SUCCESS) {
4855 ddi_fm_service_impact(instance->dip, DDI_SERVICE_UNAFFECTED);
4856 ddi_fm_acc_err_clear(instance->regmap_handle, DDI_FME_VER0);
4880 megasas_fm_init(struct megasas_instance *instance)
4886 if (instance->fm_capabilities) {
4897 ddi_fm_init(instance->dip, &instance->fm_capabilities, &fm_ibc);
4904 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities) ||
4905 DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
4906 pci_ereport_setup(instance->dip);
4912 if (DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
4913 ddi_fm_handler_register(instance->dip,
4914 megasas_fm_error_cb, (void*) instance);
4923 megasas_fm_fini(struct megasas_instance *instance)
4926 if (instance->fm_capabilities) {
4930 if (DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
4931 ddi_fm_handler_unregister(instance->dip);
4937 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities) ||
4938 DDI_FM_ERRCB_CAP(instance->fm_capabilities)) {
4939 pci_ereport_teardown(instance->dip);
4943 ddi_fm_fini(instance->dip);
4980 megasas_fm_ereport(struct megasas_instance *instance, char *detail)
4987 if (DDI_FM_EREPORT_CAP(instance->fm_capabilities)) {
4988 ddi_fm_ereport_post(instance->dip, buf, ena, DDI_NOSLEEP,