Lines Matching refs:pinstance
154 struct pmcraid_instance *pinstance;
160 pinstance = shost_priv(scsi_dev->host);
162 fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
169 spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
170 list_for_each_entry(temp, &pinstance->used_res_q, queue) {
207 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
409 * @pinstance: adapter instance structure
415 struct pmcraid_instance *pinstance
422 spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags);
424 if (!list_empty(&pinstance->free_cmd_pool)) {
425 cmd = list_entry(pinstance->free_cmd_pool.next,
429 spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags);
446 struct pmcraid_instance *pinstance = cmd->drv_inst;
449 spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags);
450 list_add_tail(&cmd->free_list, &pinstance->free_cmd_pool);
451 spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags);
457 * @pinstance: pointer to adapter instance structure
462 static u32 pmcraid_read_interrupts(struct pmcraid_instance *pinstance)
464 return (pinstance->interrupt_mode) ?
465 ioread32(pinstance->int_regs.ioa_host_msix_interrupt_reg) :
466 ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
472 * @pinstance: pointer to per adapter instance structure
479 struct pmcraid_instance *pinstance,
483 u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);
486 iowrite32(intrs, pinstance->int_regs.ioa_host_interrupt_clr_reg);
487 iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg);
488 ioread32(pinstance->int_regs.global_interrupt_mask_reg);
490 if (!pinstance->interrupt_mode) {
492 pinstance->int_regs.ioa_host_interrupt_mask_reg);
493 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
500 * @pinstance: pointer to per adapter instance structure
507 struct pmcraid_instance *pinstance,
511 u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);
514 iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg);
516 if (!pinstance->interrupt_mode) {
518 pinstance->int_regs.ioa_host_interrupt_mask_reg);
519 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
523 ioread32(pinstance->int_regs.global_interrupt_mask_reg),
524 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg));
530 * @pinstance: pointer to per adapter instance structure
536 struct pmcraid_instance *pinstance
541 if (!pinstance->interrupt_mode) {
543 pinstance->int_regs.ioa_host_interrupt_mask_reg);
544 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
546 pinstance->int_regs.ioa_host_interrupt_clr_reg);
547 ioread32(pinstance->int_regs.ioa_host_interrupt_clr_reg);
550 if (pinstance->reset_cmd != NULL) {
551 del_timer(&pinstance->reset_cmd->timer);
553 pinstance->host->host_lock, lock_flags);
554 pinstance->reset_cmd->cmd_done(pinstance->reset_cmd);
556 pinstance->host->host_lock, lock_flags);
562 * @pinstance: pointer to adapter instance structure
569 static void pmcraid_reset_type(struct pmcraid_instance *pinstance)
575 mask = ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
576 intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
577 alerts = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
583 pinstance->ioa_hard_reset = 1;
588 pinstance->ioa_unit_check = 1;
602 struct pmcraid_instance *pinstance = cmd->drv_inst;
607 rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg);
622 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
624 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
636 struct pmcraid_instance *pinstance = cmd->drv_inst;
641 pinstance->int_regs.host_ioa_interrupt_reg);
642 doorbells = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
643 intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
662 struct pmcraid_instance *pinstance = cmd->drv_inst;
663 u32 status = ioread32(pinstance->ioa_status);
673 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
675 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
700 struct pmcraid_instance *pinstance = cmd->drv_inst;
710 rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg);
726 pinstance->int_regs.host_ioa_interrupt_reg);
728 ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
732 pinstance->ioa_state = IOA_STATE_IN_HARD_RESET;
749 struct pmcraid_instance *pinstance = cmd->drv_inst;
752 dev_info(&pinstance->pdev->dev,
762 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
763 if (!pinstance->ioa_reset_in_progress) {
764 pinstance->ioa_reset_attempts = 0;
765 cmd = pmcraid_get_free_cmd(pinstance);
771 spin_unlock_irqrestore(pinstance->host->host_lock,
777 pinstance->reset_cmd = cmd;
778 pinstance->ioa_reset_in_progress = 1;
782 if (pinstance->reset_cmd != cmd) {
795 if (cmd == pinstance->reset_cmd)
800 if (pinstance->scn.ioa_state != PMC_DEVICE_EVENT_RESET_START &&
801 pinstance->scn.ioa_state != PMC_DEVICE_EVENT_SHUTDOWN_START)
802 pmcraid_notify_ioastate(pinstance,
805 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
806 scsi_block_requests(pinstance->host);
808 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
884 struct pmcraid_instance *pinstance = cmd->drv_inst;
901 pci_free_consistent(pinstance->pdev,
926 struct pmcraid_instance *pinstance = cmd->drv_inst;
934 spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
935 list_add_tail(&cmd->free_list, &pinstance->pending_cmd_pool);
936 spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags);
937 atomic_inc(&pinstance->outstanding_cmds);
942 pinstance->ioarrin);
990 struct pmcraid_instance *pinstance = cmd->drv_inst;
993 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
995 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
1045 struct pmcraid_instance *pinstance = cmd->drv_inst;
1055 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
1056 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
1058 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
1076 struct pmcraid_instance *pinstance = cmd->drv_inst;
1100 ioadl->address = cpu_to_le64(pinstance->inq_data_baddr);
1116 struct pmcraid_instance *pinstance = cmd->drv_inst;
1119 __be64 hrrq_addr = cpu_to_be64(pinstance->hrrq_start_bus_addr[index]);
1126 if (cmd->hrrq_index < pinstance->num_hrrq) {
1184 * @pinstance: pointer to adapter instance structure
1192 struct pmcraid_instance *pinstance,
1204 cmd = pmcraid_get_free_cmd(pinstance);
1214 dma = pinstance->ccn.baddr + PMCRAID_AEN_HDR_SIZE;
1215 hcam = &pinstance->ccn;
1219 dma = pinstance->ldn.baddr + PMCRAID_AEN_HDR_SIZE;
1220 hcam = &pinstance->ldn;
1253 * @pinstance: ioa config struct
1261 static void pmcraid_send_hcam(struct pmcraid_instance *pinstance, u8 type)
1263 struct pmcraid_cmd *cmd = pmcraid_init_hcam(pinstance, type);
1311 struct pmcraid_instance *pinstance;
1314 pinstance = cmd->drv_inst;
1316 &pinstance->ldn : &pinstance->ccn;
1449 * @pinstance: pointer to adapter instance structure
1456 struct pmcraid_instance *pinstance,
1466 aen_msg->hostno = (pinstance->host->unique_id << 16 |
1467 MINOR(pinstance->cdev.dev));
1527 * @pinstance: pointer adapter instance structure
1532 static int pmcraid_notify_ccn(struct pmcraid_instance *pinstance)
1534 return pmcraid_notify_aen(pinstance,
1535 pinstance->ccn.msg,
1536 pinstance->ccn.hcam->data_len +
1542 * @pinstance: pointer adapter instance structure
1547 static int pmcraid_notify_ldn(struct pmcraid_instance *pinstance)
1549 return pmcraid_notify_aen(pinstance,
1550 pinstance->ldn.msg,
1551 pinstance->ldn.hcam->data_len +
1557 * @pinstance: pointer adapter instance structure
1563 static void pmcraid_notify_ioastate(struct pmcraid_instance *pinstance, u32 evt)
1565 pinstance->scn.ioa_state = evt;
1566 pmcraid_notify_aen(pinstance,
1567 &pinstance->scn.msg,
1573 * @pinstance: pointer to per adapter instance structure
1579 static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)
1593 ccn_hcam = (struct pmcraid_hcam_ccn *)pinstance->ccn.hcam;
1595 fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
1599 pinstance->ccn.hcam->ilid,
1600 pinstance->ccn.hcam->op_code,
1601 pinstance->ccn.hcam->notification_type,
1602 pinstance->ccn.hcam->notification_lost,
1603 pinstance->ccn.hcam->flags,
1604 pinstance->host->unique_id,
1617 if (pinstance->ccn.hcam->notification_lost) {
1618 cfgcmd = pmcraid_get_free_cmd(pinstance);
1621 pinstance->reinit_cfg_table = 1;
1633 if (pinstance->ccn.hcam->notification_type ==
1646 spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
1647 list_for_each_entry(res, &pinstance->used_res_q, queue) {
1660 spin_unlock_irqrestore(&pinstance->resource_lock,
1669 if (list_empty(&pinstance->free_res_q)) {
1670 spin_unlock_irqrestore(&pinstance->resource_lock,
1673 spin_lock_irqsave(pinstance->host->host_lock,
1675 pmcraid_send_hcam(pinstance,
1677 spin_unlock_irqrestore(pinstance->host->host_lock,
1682 res = list_entry(pinstance->free_res_q.next,
1688 list_add_tail(&res->queue, &pinstance->used_res_q);
1691 memcpy(&res->cfg_entry, cfg_entry, pinstance->config_table_entry_size);
1693 if (pinstance->ccn.hcam->notification_type ==
1703 schedule_work(&pinstance->worker_q);
1706 list_move_tail(&res->queue, &pinstance->free_res_q);
1710 schedule_work(&pinstance->worker_q);
1712 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
1718 pmcraid_notify_ccn(pinstance);
1720 cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1764 * @pinstance: pointer to per adapter instance structure
1769 static void pmcraid_handle_error_log(struct pmcraid_instance *pinstance)
1774 hcam_ldn = (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam;
1778 pinstance->ldn.hcam->ilid,
1779 pinstance->ldn.hcam->op_code,
1780 pinstance->ldn.hcam->notification_type,
1781 pinstance->ldn.hcam->notification_lost,
1782 pinstance->ldn.hcam->flags,
1783 pinstance->ldn.hcam->overlay_id);
1786 if (pinstance->ldn.hcam->notification_type !=
1790 if (pinstance->ldn.hcam->notification_lost ==
1792 dev_info(&pinstance->pdev->dev, "Error notifications lost\n");
1798 dev_info(&pinstance->pdev->dev,
1801 pinstance->host,
1820 struct pmcraid_instance *pinstance = cmd->drv_inst;
1824 pinstance->ccn.cmd = NULL;
1832 atomic_read(&pinstance->ccn.ignore) == 1) {
1835 dev_info(&pinstance->pdev->dev,
1837 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
1838 pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1839 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
1841 pmcraid_handle_config_change(pinstance);
1856 struct pmcraid_instance *pinstance = cmd->drv_inst;
1858 (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam;
1864 pinstance->ldn.cmd = NULL;
1872 atomic_read(&pinstance->ccn.ignore) == 1) {
1875 pmcraid_handle_error_log(pinstance);
1877 spin_lock_irqsave(pinstance->host->host_lock,
1879 pmcraid_initiate_reset(pinstance);
1880 spin_unlock_irqrestore(pinstance->host->host_lock,
1885 dev_info(&pinstance->pdev->dev,
1890 pmcraid_notify_ldn(pinstance);
1892 cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);
1900 * @pinstance: pointer per adapter instance structure
1905 static void pmcraid_register_hcams(struct pmcraid_instance *pinstance)
1907 pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1908 pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);
1917 struct pmcraid_instance *pinstance = cmd->drv_inst;
1924 atomic_set(&pinstance->ccn.ignore, 1);
1925 atomic_set(&pinstance->ldn.ignore, 1);
1931 if ((pinstance->force_ioa_reset && !pinstance->ioa_bringdown) ||
1932 pinstance->ioa_unit_check) {
1933 pinstance->force_ioa_reset = 0;
1934 pinstance->ioa_unit_check = 0;
1935 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
1949 * @pinstance: pointer to adapter instance structure
1955 static int pmcraid_reset_enable_ioa(struct pmcraid_instance *pinstance)
1959 pmcraid_reinit_buffers(pinstance);
1960 intrs = pmcraid_read_interrupts(pinstance);
1962 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
1965 if (!pinstance->interrupt_mode) {
1967 pinstance->int_regs.
1970 pinstance->int_regs.ioa_host_interrupt_clr_reg);
1987 struct pmcraid_instance *pinstance = cmd->drv_inst;
2013 if (pinstance->interrupt_mode) {
2015 pinstance->int_regs.host_ioa_interrupt_reg);
2016 ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
2019 iowrite32(doorbell, pinstance->int_regs.host_ioa_interrupt_reg);
2020 ioread32(pinstance->int_regs.host_ioa_interrupt_reg),
2021 int_reg = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
2024 ioread32(pinstance->int_regs.host_ioa_interrupt_reg),
2031 * @pinstance: pointer to adapter instance structure
2036 static void pmcraid_get_dump(struct pmcraid_instance *pinstance)
2043 * @pinstance: pointer to adapter instance structure
2053 static void pmcraid_fail_outstanding_cmds(struct pmcraid_instance *pinstance)
2061 spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
2062 list_for_each_entry_safe(cmd, temp, &pinstance->pending_cmd_pool,
2065 spin_unlock_irqrestore(&pinstance->pending_pool_lock,
2103 atomic_dec(&pinstance->outstanding_cmds);
2104 spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
2107 spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags);
2127 struct pmcraid_instance *pinstance = cmd->drv_inst;
2130 pinstance->ioa_reset_in_progress = 1;
2132 if (pinstance->reset_cmd != cmd) {
2134 pinstance->reset_cmd = cmd;
2138 pinstance->ioa_state, cmd);
2140 switch (pinstance->ioa_state) {
2156 pmcraid_disable_interrupts(pinstance, ~0);
2157 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
2165 scsi_block_requests(pinstance->host);
2171 if (pinstance->ioa_hard_reset == 0) {
2172 if (ioread32(pinstance->ioa_status) &
2175 pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
2179 pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET;
2186 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
2197 pinstance->ioa_state = IOA_STATE_IN_HARD_RESET;
2202 pinstance->ioa_reset_attempts++;
2205 if (pinstance->ioa_reset_attempts > PMCRAID_RESET_ATTEMPTS) {
2206 pinstance->ioa_reset_attempts = 0;
2208 pinstance->ioa_state = IOA_STATE_DEAD;
2210 if (pinstance->ioa_bringdown)
2211 pmcraid_notify_ioastate(pinstance,
2214 pmcraid_notify_ioastate(pinstance,
2223 if (pci_restore_state(pinstance->pdev)) {
2225 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
2231 pmcraid_fail_outstanding_cmds(pinstance);
2234 if (pinstance->ioa_unit_check) {
2236 pinstance->ioa_unit_check = 0;
2237 pmcraid_get_dump(pinstance);
2238 pinstance->ioa_reset_attempts--;
2239 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
2248 if (pinstance->ioa_bringdown) {
2250 pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
2251 pinstance->ioa_bringdown = 0;
2252 pinstance->ioa_state = IOA_STATE_UNKNOWN;
2253 pmcraid_notify_ioastate(pinstance,
2261 if (pmcraid_reset_enable_ioa(pinstance)) {
2262 pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
2267 pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET;
2278 pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
2291 pinstance->ioa_state = IOA_STATE_OPERATIONAL;
2302 if (pinstance->ioa_shutdown_type == SHUTDOWN_NONE &&
2303 pinstance->force_ioa_reset == 0) {
2304 pmcraid_notify_ioastate(pinstance,
2308 if (pinstance->ioa_shutdown_type != SHUTDOWN_NONE)
2309 pinstance->ioa_state = IOA_STATE_IN_BRINGDOWN;
2322 pinstance->ioa_reset_in_progress = 0;
2323 pinstance->ioa_reset_attempts = 0;
2324 pinstance->reset_cmd = NULL;
2325 pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
2326 pinstance->ioa_bringdown = 0;
2332 if (pinstance->ioa_state == IOA_STATE_OPERATIONAL)
2333 pmcraid_register_hcams(pinstance);
2335 wake_up_all(&pinstance->reset_wait_q);
2347 * @pinstance: pointer to adapter instance structure
2352 static void pmcraid_initiate_reset(struct pmcraid_instance *pinstance)
2359 if (!pinstance->ioa_reset_in_progress) {
2360 scsi_block_requests(pinstance->host);
2361 cmd = pmcraid_get_free_cmd(pinstance);
2368 pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
2369 pinstance->reset_cmd = cmd;
2370 pinstance->force_ioa_reset = 1;
2371 pmcraid_notify_ioastate(pinstance,
2380 * @pinstance: pointer adapter instance structure
2392 struct pmcraid_instance *pinstance,
2401 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
2403 if (pinstance->ioa_reset_in_progress) {
2406 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2408 wait_event(pinstance->reset_wait_q,
2409 !pinstance->ioa_reset_in_progress);
2411 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
2413 if (pinstance->ioa_state == IOA_STATE_DEAD) {
2414 spin_unlock_irqrestore(pinstance->host->host_lock,
2418 } else if (pinstance->ioa_state == target_state) {
2425 scsi_block_requests(pinstance->host);
2426 reset_cmd = pmcraid_get_free_cmd(pinstance);
2430 spin_unlock_irqrestore(pinstance->host->host_lock,
2436 pinstance->ioa_bringdown = 1;
2438 pinstance->ioa_shutdown_type = shutdown_type;
2439 pinstance->reset_cmd = reset_cmd;
2440 pinstance->force_ioa_reset = reset;
2443 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2445 wait_event(pinstance->reset_wait_q,
2446 !pinstance->ioa_reset_in_progress);
2449 scsi_unblock_requests(pinstance->host);
2450 if (pinstance->ioa_state == target_state)
2460 * @pinstance: pointer to adapter instance structure
2465 static int pmcraid_reset_bringdown(struct pmcraid_instance *pinstance)
2467 return pmcraid_reset_reload(pinstance,
2475 * @pinstance: pointer to adapter instance structure
2480 static int pmcraid_reset_bringup(struct pmcraid_instance *pinstance)
2482 pmcraid_notify_ioastate(pinstance, PMC_DEVICE_EVENT_RESET_START);
2484 return pmcraid_reset_reload(pinstance,
2664 struct pmcraid_instance *pinstance = cmd->drv_inst;
2712 scsi_report_bus_reset(pinstance->host,
2783 struct pmcraid_instance *pinstance;
2789 pinstance =
2803 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
2804 if (pinstance->ioa_reset_in_progress ||
2805 pinstance->ioa_state == IOA_STATE_DEAD) {
2806 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2817 cmd = pmcraid_get_free_cmd(pinstance);
2820 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2849 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2939 struct pmcraid_instance *pinstance;
2942 pinstance = (struct pmcraid_instance *)cmd->drv_inst;
2945 cancel_cmd = pmcraid_get_free_cmd(pinstance);
3021 struct pmcraid_instance *pinstance;
3030 pinstance =
3046 spin_lock_irqsave(pinstance->host->host_lock, host_lock_flags);
3048 if (pinstance->ioa_reset_in_progress ||
3049 pinstance->ioa_state == IOA_STATE_DEAD) {
3050 spin_unlock_irqrestore(pinstance->host->host_lock,
3060 spin_lock_irqsave(&pinstance->pending_pool_lock, pending_lock_flags);
3061 list_for_each_entry(cmd, &pinstance->pending_cmd_pool, free_list) {
3069 spin_unlock_irqrestore(&pinstance->pending_pool_lock,
3078 spin_unlock_irqrestore(pinstance->host->host_lock,
3144 struct pmcraid_instance *pinstance =
3153 if (atomic_read(&pinstance->outstanding_cmds) <=
3159 dev_err(&pinstance->pdev->dev,
3161 return pmcraid_reset_bringup(pinstance) == 0 ? SUCCESS : FAILED;
3243 * @pinstance: pointer to adapter instance structure
3253 struct pmcraid_instance *pinstance,
3479 struct pmcraid_instance *pinstance;
3486 pinstance =
3488 fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
3496 if (pinstance->ioa_state == IOA_STATE_DEAD) {
3504 if (pinstance->ioa_reset_in_progress)
3517 cmd = pmcraid_get_free_cmd(pinstance);
3535 ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) %
3536 pinstance->num_hrrq;
3555 rc = pmcraid_build_ioadl(pinstance, cmd);
3559 scsi_cmd->cmnd[0], pinstance->host->unique_id,
3585 struct pmcraid_instance *pinstance;
3591 pinstance = container_of(inode->i_cdev, struct pmcraid_instance, cdev);
3592 filep->private_data = pinstance;
3602 struct pmcraid_instance *pinstance = filep->private_data;
3605 fasync_helper(-1, filep, 0, &pinstance->aen_queue);
3618 struct pmcraid_instance *pinstance;
3621 pinstance = filep->private_data;
3622 mutex_lock(&pinstance->aen_queue_lock);
3623 rc = fasync_helper(fd, filep, mode, &pinstance->aen_queue);
3624 mutex_unlock(&pinstance->aen_queue_lock);
3721 * @pinstance: pointer to adapter instance structure
3729 struct pmcraid_instance *pinstance,
3749 if (pinstance->ioa_reset_in_progress) {
3751 pinstance->reset_wait_q,
3752 !pinstance->ioa_reset_in_progress,
3762 if (pinstance->ioa_state != IOA_STATE_OPERATIONAL) {
3814 cmd = pmcraid_get_free_cmd(pinstance);
3849 ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) %
3850 pinstance->num_hrrq;
3888 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
3890 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
3914 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
3916 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
3998 * @pinstance: pointer to adapter instance structure
4007 struct pmcraid_instance *pinstance,
4022 pmcraid_reset_bringup(pinstance);
4093 struct pmcraid_instance *pinstance = NULL;
4112 pinstance = filep->private_data;
4114 if (!pinstance) {
4127 scsi_block_requests(pinstance->host);
4129 retval = pmcraid_ioctl_passthrough(pinstance,
4135 scsi_unblock_requests(pinstance->host);
4140 retval = pmcraid_ioctl_driver(pinstance,
4187 struct pmcraid_instance *pinstance =
4189 return snprintf(buf, PAGE_SIZE, "%d\n", pinstance->current_log_level);
4209 struct pmcraid_instance *pinstance;
4219 pinstance = (struct pmcraid_instance *)shost->hostdata;
4220 pinstance->current_log_level = val;
4275 struct pmcraid_instance *pinstance =
4277 u32 adapter_id = (pinstance->pdev->bus->number << 8) |
4278 pinstance->pdev->devfn;
4283 adapter_id, MINOR(pinstance->cdev.dev), aen_group);
4340 struct pmcraid_instance *pinstance;
4347 pinstance = hrrq_vector->drv_inst;
4351 intrs_val = pmcraid_read_interrupts(pinstance);
4353 ((ioread32(pinstance->int_regs.host_ioa_interrupt_reg)
4362 pinstance->ioa_unit_check = 1;
4366 spin_lock_irqsave(pinstance->host->host_lock,
4368 pmcraid_initiate_reset(pinstance);
4370 pinstance->host->host_lock,
4378 pmcraid_clr_trans_op(pinstance);
4385 pinstance->int_regs.host_ioa_interrupt_reg);
4386 ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
4392 tasklet_schedule(&(pinstance->isr_tasklet[hrrq_id]));
4409 struct pmcraid_instance *pinstance;
4422 pinstance = hrrq_vector->drv_inst;
4424 intrs = pmcraid_read_interrupts(pinstance);
4436 pinstance->ioa_unit_check = 1;
4439 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4443 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4444 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
4445 pmcraid_initiate_reset(pinstance);
4446 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
4453 pmcraid_clr_trans_op(pinstance);
4456 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4458 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4461 &(pinstance->isr_tasklet[hrrq_id]));
4480 struct pmcraid_instance *pinstance;
4489 pinstance = container_of(workp, struct pmcraid_instance, worker_q);
4491 if (!atomic_read(&pinstance->expose_resources))
4494 fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
4496 spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
4497 list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue) {
4505 spin_lock_irqsave(pinstance->host->host_lock,
4509 pinstance->host->host_lock,
4514 &pinstance->free_res_q);
4516 &pinstance->resource_lock,
4520 spin_lock_irqsave(&pinstance->resource_lock,
4525 pinstance->host->host_lock,
4531 list_for_each_entry(res, &pinstance->used_res_q, queue) {
4555 spin_unlock_irqrestore(&pinstance->resource_lock,
4557 scsi_add_device(pinstance->host, bus, target, lun);
4558 spin_lock_irqsave(&pinstance->resource_lock,
4563 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
4577 struct pmcraid_instance *pinstance;
4586 pinstance = hrrq_vector->drv_inst;
4588 lockp = &(pinstance->hrrq_lock[id]);
4598 resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
4601 pinstance->host_toggle_bit[id]) {
4606 if (pinstance->hrrq_curr[id] < pinstance->hrrq_end[id]) {
4607 pinstance->hrrq_curr[id]++;
4609 pinstance->hrrq_curr[id] = pinstance->hrrq_start[id];
4610 pinstance->host_toggle_bit[id] ^= 1u;
4616 resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
4620 cmd = pinstance->cmd_list[cmd_index];
4623 spin_lock_irqsave(&pinstance->pending_pool_lock,
4626 spin_unlock_irqrestore(&pinstance->pending_pool_lock,
4629 atomic_dec(&pinstance->outstanding_cmds);
4632 spin_lock_irqsave(pinstance->host->host_lock,
4635 spin_unlock_irqrestore(pinstance->host->host_lock,
4642 resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
4650 * @pinstance: pointer to adapter instance structure
4659 void pmcraid_unregister_interrupt_handler(struct pmcraid_instance *pinstance)
4663 for (i = 0; i < pinstance->num_hrrq; i++)
4664 free_irq(pinstance->hrrq_vector[i].vector,
4665 &(pinstance->hrrq_vector[i]));
4667 if (pinstance->interrupt_mode) {
4668 pci_disable_msix(pinstance->pdev);
4669 pinstance->interrupt_mode = 0;
4675 * @pinstance: pointer to per-adapter instance structure
4681 pmcraid_register_interrupt_handler(struct pmcraid_instance *pinstance)
4684 struct pci_dev *pdev = pinstance->pdev;
4707 pinstance->hrrq_vector[i].hrrq_id = i;
4708 pinstance->hrrq_vector[i].drv_inst = pinstance;
4709 pinstance->hrrq_vector[i].vector = entries[i].vector;
4710 rc = request_irq(pinstance->hrrq_vector[i].vector,
4713 &(pinstance->hrrq_vector[i]));
4719 &(pinstance->hrrq_vector[j]));
4725 pinstance->num_hrrq = num_hrrq;
4726 pinstance->interrupt_mode = 1;
4728 pinstance->int_regs.host_ioa_interrupt_reg);
4729 ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
4737 pinstance->hrrq_vector[0].hrrq_id = 0;
4738 pinstance->hrrq_vector[0].drv_inst = pinstance;
4739 pinstance->hrrq_vector[0].vector = pdev->irq;
4740 pinstance->num_hrrq = 1;
4744 PMCRAID_DRIVER_NAME, &pinstance->hrrq_vector[0]);
4751 * @pinstance: per adapter instance structure pointer
4758 pmcraid_release_cmd_blocks(struct pmcraid_instance *pinstance, int max_index)
4762 kmem_cache_free(pinstance->cmd_cachep, pinstance->cmd_list[i]);
4763 pinstance->cmd_list[i] = NULL;
4765 kmem_cache_destroy(pinstance->cmd_cachep);
4766 pinstance->cmd_cachep = NULL;
4771 * @pinstance: pointer to per adapter instance structure
4782 struct pmcraid_instance *pinstance,
4788 if (pinstance->control_pool == NULL)
4792 pci_pool_free(pinstance->control_pool,
4793 pinstance->cmd_list[i]->ioa_cb,
4794 pinstance->cmd_list[i]->ioa_cb_bus_addr);
4795 pinstance->cmd_list[i]->ioa_cb = NULL;
4796 pinstance->cmd_list[i]->ioa_cb_bus_addr = 0;
4798 pci_pool_destroy(pinstance->control_pool);
4799 pinstance->control_pool = NULL;
4804 * @pinstance - pointer to per adapter instance structure
4812 pmcraid_allocate_cmd_blocks(struct pmcraid_instance *pinstance)
4816 sprintf(pinstance->cmd_pool_name, "pmcraid_cmd_pool_%d",
4817 pinstance->host->unique_id);
4820 pinstance->cmd_cachep = kmem_cache_create(
4821 pinstance->cmd_pool_name,
4824 if (!pinstance->cmd_cachep)
4828 pinstance->cmd_list[i] =
4829 kmem_cache_alloc(pinstance->cmd_cachep, GFP_KERNEL);
4830 if (!pinstance->cmd_list[i]) {
4831 pmcraid_release_cmd_blocks(pinstance, i);
4840 * @pinstance : pointer to per adapter instance structure
4849 pmcraid_allocate_control_blocks(struct pmcraid_instance *pinstance)
4853 sprintf(pinstance->ctl_pool_name, "pmcraid_control_pool_%d",
4854 pinstance->host->unique_id);
4856 pinstance->control_pool =
4857 pci_pool_create(pinstance->ctl_pool_name,
4858 pinstance->pdev,
4862 if (!pinstance->control_pool)
4866 pinstance->cmd_list[i]->ioa_cb =
4868 pinstance->control_pool,
4870 &(pinstance->cmd_list[i]->ioa_cb_bus_addr));
4872 if (!pinstance->cmd_list[i]->ioa_cb) {
4873 pmcraid_release_control_blocks(pinstance, i);
4876 memset(pinstance->cmd_list[i]->ioa_cb, 0,
4884 * @pinstance: pointer to per adapter instance structure
4891 pmcraid_release_host_rrqs(struct pmcraid_instance *pinstance, int maxindex)
4896 pci_free_consistent(pinstance->pdev,
4898 pinstance->hrrq_start[i],
4899 pinstance->hrrq_start_bus_addr[i]);
4902 pinstance->hrrq_start[i] = NULL;
4903 pinstance->hrrq_start_bus_addr[i] = 0;
4904 pinstance->host_toggle_bit[i] = 0;
4910 * @pinstance: pointer to per adapter instance structure
4916 pmcraid_allocate_host_rrqs(struct pmcraid_instance *pinstance)
4922 for (i = 0; i < pinstance->num_hrrq; i++) {
4923 pinstance->hrrq_start[i] =
4925 pinstance->pdev,
4927 &(pinstance->hrrq_start_bus_addr[i]));
4929 if (pinstance->hrrq_start[i] == 0) {
4932 pmcraid_release_host_rrqs(pinstance, i);
4936 memset(pinstance->hrrq_start[i], 0, buffer_size);
4937 pinstance->hrrq_curr[i] = pinstance->hrrq_start[i];
4938 pinstance->hrrq_end[i] =
4939 pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1;
4940 pinstance->host_toggle_bit[i] = 1;
4941 spin_lock_init(&pinstance->hrrq_lock[i]);
4949 * @pinstance: pointer to per adapter instance structure
4954 static void pmcraid_release_hcams(struct pmcraid_instance *pinstance)
4956 if (pinstance->ccn.msg != NULL) {
4957 pci_free_consistent(pinstance->pdev,
4960 pinstance->ccn.msg,
4961 pinstance->ccn.baddr);
4963 pinstance->ccn.msg = NULL;
4964 pinstance->ccn.hcam = NULL;
4965 pinstance->ccn.baddr = 0;
4968 if (pinstance->ldn.msg != NULL) {
4969 pci_free_consistent(pinstance->pdev,
4972 pinstance->ldn.msg,
4973 pinstance->ldn.baddr);
4975 pinstance->ldn.msg = NULL;
4976 pinstance->ldn.hcam = NULL;
4977 pinstance->ldn.baddr = 0;
4983 * @pinstance : pointer to per adapter instance structure
4988 static int pmcraid_allocate_hcams(struct pmcraid_instance *pinstance)
4990 pinstance->ccn.msg = pci_alloc_consistent(
4991 pinstance->pdev,
4994 &(pinstance->ccn.baddr));
4996 pinstance->ldn.msg = pci_alloc_consistent(
4997 pinstance->pdev,
5000 &(pinstance->ldn.baddr));
5002 if (pinstance->ldn.msg == NULL || pinstance->ccn.msg == NULL) {
5003 pmcraid_release_hcams(pinstance);
5005 pinstance->ccn.hcam =
5006 (void *)pinstance->ccn.msg + PMCRAID_AEN_HDR_SIZE;
5007 pinstance->ldn.hcam =
5008 (void *)pinstance->ldn.msg + PMCRAID_AEN_HDR_SIZE;
5010 atomic_set(&pinstance->ccn.ignore, 0);
5011 atomic_set(&pinstance->ldn.ignore, 0);
5014 return (pinstance->ldn.msg == NULL) ? -ENOMEM : 0;
5019 * @pinstance: pointer to per adapter instance structure
5024 static void pmcraid_release_config_buffers(struct pmcraid_instance *pinstance)
5026 if (pinstance->cfg_table != NULL &&
5027 pinstance->cfg_table_bus_addr != 0) {
5028 pci_free_consistent(pinstance->pdev,
5030 pinstance->cfg_table,
5031 pinstance->cfg_table_bus_addr);
5032 pinstance->cfg_table = NULL;
5033 pinstance->cfg_table_bus_addr = 0;
5036 if (pinstance->res_entries != NULL) {
5040 list_del(&pinstance->res_entries[i].queue);
5041 kfree(pinstance->res_entries);
5042 pinstance->res_entries = NULL;
5045 pmcraid_release_hcams(pinstance);
5050 * @pinstance : pointer to per adapter instance structure
5056 pmcraid_allocate_config_buffers(struct pmcraid_instance *pinstance)
5060 pinstance->res_entries =
5064 if (NULL == pinstance->res_entries) {
5070 list_add_tail(&pinstance->res_entries[i].queue,
5071 &pinstance->free_res_q);
5073 pinstance->cfg_table =
5074 pci_alloc_consistent(pinstance->pdev,
5076 &pinstance->cfg_table_bus_addr);
5078 if (NULL == pinstance->cfg_table) {
5080 pmcraid_release_config_buffers(pinstance);
5084 if (pmcraid_allocate_hcams(pinstance)) {
5086 pmcraid_release_config_buffers(pinstance);
5096 * @pinstance: pointer adapter instance structure
5101 static void pmcraid_init_tasklets(struct pmcraid_instance *pinstance)
5104 for (i = 0; i < pinstance->num_hrrq; i++)
5105 tasklet_init(&pinstance->isr_tasklet[i],
5107 (unsigned long)&pinstance->hrrq_vector[i]);
5113 * @pinstance: pointer to adapter instance structure
5118 static void pmcraid_kill_tasklets(struct pmcraid_instance *pinstance)
5121 for (i = 0; i < pinstance->num_hrrq; i++)
5122 tasklet_kill(&pinstance->isr_tasklet[i]);
5128 * @pinstance: pointer to adapter soft state
5133 static void pmcraid_release_buffers(struct pmcraid_instance *pinstance)
5135 pmcraid_release_config_buffers(pinstance);
5136 pmcraid_release_control_blocks(pinstance, PMCRAID_MAX_CMD);
5137 pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD);
5138 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5140 if (pinstance->inq_data != NULL) {
5141 pci_free_consistent(pinstance->pdev,
5143 pinstance->inq_data,
5144 pinstance->inq_data_baddr);
5146 pinstance->inq_data = NULL;
5147 pinstance->inq_data_baddr = 0;
5153 * @pinstance: pointer to per adapter instance structure
5164 static int __devinit pmcraid_init_buffers(struct pmcraid_instance *pinstance)
5168 if (pmcraid_allocate_host_rrqs(pinstance)) {
5170 pinstance->num_hrrq);
5174 if (pmcraid_allocate_config_buffers(pinstance)) {
5176 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5180 if (pmcraid_allocate_cmd_blocks(pinstance)) {
5182 pmcraid_release_config_buffers(pinstance);
5183 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5187 if (pmcraid_allocate_control_blocks(pinstance)) {
5189 pmcraid_release_config_buffers(pinstance);
5190 pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD);
5191 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5196 pinstance->inq_data = pci_alloc_consistent(
5197 pinstance->pdev,
5199 &pinstance->inq_data_baddr);
5201 if (pinstance->inq_data == NULL) {
5203 pmcraid_release_buffers(pinstance);
5212 struct pmcraid_cmd *cmdp = pinstance->cmd_list[i];
5214 cmdp->drv_inst = pinstance;
5215 list_add_tail(&cmdp->free_list, &pinstance->free_cmd_pool);
5223 * @pinstance: pointer to adapter instance
5227 static void pmcraid_reinit_buffers(struct pmcraid_instance *pinstance)
5232 for (i = 0; i < pinstance->num_hrrq; i++) {
5233 memset(pinstance->hrrq_start[i], 0, buffer_size);
5234 pinstance->hrrq_curr[i] = pinstance->hrrq_start[i];
5235 pinstance->hrrq_end[i] =
5236 pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1;
5237 pinstance->host_toggle_bit[i] = 1;
5256 struct pmcraid_instance *pinstance =
5259 pinstance->host = host;
5260 pinstance->pdev = pdev;
5263 pinstance->mapped_dma_addr = mapped_pci_addr;
5267 struct pmcraid_chip_details *chip_cfg = pinstance->chip_cfg;
5268 struct pmcraid_interrupts *pint_regs = &pinstance->int_regs;
5270 pinstance->ioarrin = mapped_pci_addr + chip_cfg->ioarrin;
5286 pinstance->mailbox = mapped_pci_addr + chip_cfg->mailbox;
5287 pinstance->ioa_status = mapped_pci_addr + chip_cfg->ioastatus;
5296 pinstance->ioa_reset_attempts = 0;
5297 init_waitqueue_head(&pinstance->reset_wait_q);
5299 atomic_set(&pinstance->outstanding_cmds, 0);
5300 atomic_set(&pinstance->last_message_id, 0);
5301 atomic_set(&pinstance->expose_resources, 0);
5303 INIT_LIST_HEAD(&pinstance->free_res_q);
5304 INIT_LIST_HEAD(&pinstance->used_res_q);
5305 INIT_LIST_HEAD(&pinstance->free_cmd_pool);
5306 INIT_LIST_HEAD(&pinstance->pending_cmd_pool);
5308 spin_lock_init(&pinstance->free_pool_lock);
5309 spin_lock_init(&pinstance->pending_pool_lock);
5310 spin_lock_init(&pinstance->resource_lock);
5311 mutex_init(&pinstance->aen_queue_lock);
5314 INIT_WORK(&pinstance->worker_q, pmcraid_worker_function);
5317 pinstance->current_log_level = pmcraid_log_level;
5320 pinstance->ioa_state = IOA_STATE_UNKNOWN;
5321 pinstance->reset_cmd = NULL;
5336 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5337 pmcraid_reset_bringdown(pinstance);
5364 * @pinstance: pointer to adapter instance for which to register device
5369 static int pmcraid_setup_chrdev(struct pmcraid_instance *pinstance)
5375 cdev_init(&pinstance->cdev, &pmcraid_fops);
5376 pinstance->cdev.owner = THIS_MODULE;
5378 error = cdev_add(&pinstance->cdev, MKDEV(pmcraid_major, minor), 1);
5391 * @pinstance: pointer to adapter instance structure
5396 static void pmcraid_release_chrdev(struct pmcraid_instance *pinstance)
5398 pmcraid_release_minor(MINOR(pinstance->cdev.dev));
5400 MKDEV(pmcraid_major, MINOR(pinstance->cdev.dev)));
5401 cdev_del(&pinstance->cdev);
5413 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5416 pmcraid_release_chrdev(pinstance);
5419 scsi_remove_host(pinstance->host);
5422 scsi_block_requests(pinstance->host);
5427 pmcraid_disable_interrupts(pinstance, ~0);
5430 pmcraid_kill_tasklets(pinstance);
5431 pmcraid_unregister_interrupt_handler(pinstance);
5432 pmcraid_release_buffers(pinstance);
5433 iounmap(pinstance->mapped_dma_addr);
5435 scsi_host_put(pinstance->host);
5451 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5454 pmcraid_disable_interrupts(pinstance, ~0);
5455 pmcraid_kill_tasklets(pinstance);
5456 pci_set_drvdata(pinstance->pdev, pinstance);
5457 pmcraid_unregister_interrupt_handler(pinstance);
5473 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5474 struct Scsi_Host *host = pinstance->host;
5502 pmcraid_disable_interrupts(pinstance, ~0);
5503 atomic_set(&pinstance->outstanding_cmds, 0);
5504 rc = pmcraid_register_interrupt_handler(pinstance);
5513 pmcraid_init_tasklets(pinstance);
5514 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
5519 pinstance->ioa_hard_reset = 1;
5524 if (pmcraid_reset_bringup(pinstance)) {
5533 pmcraid_disable_interrupts(pinstance, ~0);
5534 pmcraid_kill_tasklets(pinstance);
5535 pmcraid_unregister_interrupt_handler(pinstance);
5560 struct pmcraid_instance *pinstance = cmd->drv_inst;
5563 spin_lock_irqsave(pinstance->host->host_lock, flags);
5565 spin_unlock_irqrestore(pinstance->host->host_lock, flags);
5566 scsi_unblock_requests(pinstance->host);
5567 schedule_work(&pinstance->worker_q);
5625 struct pmcraid_instance *pinstance = cmd->drv_inst;
5633 if (pinstance->cfg_table->flags & MICROCODE_UPDATE_REQUIRED)
5636 fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
5638 /* resource list is protected by pinstance->resource_lock.
5642 spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
5644 list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue)
5647 for (i = 0; i < pinstance->cfg_table->num_entries; i++) {
5648 if (be16_to_cpu(pinstance->inq_data->fw_version) <=
5650 cfgte = &pinstance->cfg_table->entries[i];
5653 &pinstance->cfg_table->entries_ext[i];
5668 &pinstance->used_res_q);
5677 if (list_empty(&pinstance->free_res_q)) {
5683 res = list_entry(pinstance->free_res_q.next,
5689 list_move_tail(&res->queue, &pinstance->used_res_q);
5697 pinstance->config_table_entry_size);
5714 list_move_tail(&res->queue, &pinstance->used_res_q);
5716 list_move_tail(&res->queue, &pinstance->free_res_q);
5721 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
5739 struct pmcraid_instance *pinstance = cmd->drv_inst;
5742 if (be16_to_cpu(pinstance->inq_data->fw_version) <=
5744 pinstance->config_table_entry_size =
5747 pinstance->config_table_entry_size =
5773 ioadl->address = cpu_to_le64(pinstance->cfg_table_bus_addr);
5795 struct pmcraid_instance *pinstance;
5877 pinstance = (struct pmcraid_instance *)host->hostdata;
5878 memset(pinstance, 0, sizeof(*pinstance));
5880 pinstance->chip_cfg =
5890 pci_set_drvdata(pdev, pinstance);
5893 rc = pci_save_state(pinstance->pdev);
5900 pmcraid_disable_interrupts(pinstance, ~0);
5902 rc = pmcraid_register_interrupt_handler(pinstance);
5909 pmcraid_init_tasklets(pinstance);
5912 rc = pmcraid_init_buffers(pinstance);
5920 pmcraid_reset_type(pinstance);
5922 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
5928 if (pmcraid_reset_bringup(pinstance)) {
5935 rc = scsi_add_host(pinstance->host, &pdev->dev);
5941 scsi_scan_host(pinstance->host);
5943 rc = pmcraid_setup_chrdev(pinstance);
5954 atomic_set(&pinstance->expose_resources, 1);
5955 schedule_work(&pinstance->worker_q);
5962 pmcraid_release_buffers(pinstance);
5965 pmcraid_kill_tasklets(pinstance);
5966 pmcraid_unregister_interrupt_handler(pinstance);