Lines Matching refs:cmd
343 * @cmd: pointer to struct pmcraid_cmd to be initialized
349 void pmcraid_init_cmdblk(struct pmcraid_cmd *cmd, int index)
351 struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb);
352 dma_addr_t dma_addr = cmd->ioa_cb_bus_addr;
359 cmd->index = index;
368 memset(&cmd->ioa_cb->ioarcb.cdb, 0, PMCRAID_MAX_CDB_LEN);
379 cmd->ioa_cb->ioasa.ioasc = 0;
380 cmd->ioa_cb->ioasa.residual_data_length = 0;
381 cmd->time_left = 0;
384 cmd->cmd_done = NULL;
385 cmd->scsi_cmd = NULL;
386 cmd->release = 0;
387 cmd->completion_req = 0;
388 cmd->sense_buffer = 0;
389 cmd->sense_buffer_dma = 0;
390 cmd->dma_handle = 0;
391 init_timer(&cmd->timer);
397 * @cmd: pointer to struct pmcraid_cmd to be reinitialized
402 static void pmcraid_reinit_cmdblk(struct pmcraid_cmd *cmd)
404 pmcraid_init_cmdblk(cmd, -1);
408 * pmcraid_get_free_cmd - get a free cmd block from command block pool
412 * returns pointer to cmd block or NULL if no blocks are available
418 struct pmcraid_cmd *cmd = NULL;
421 /* free cmd block list is protected by free_pool_lock */
425 cmd = list_entry(pinstance->free_cmd_pool.next,
427 list_del(&cmd->free_list);
432 if (cmd != NULL)
433 pmcraid_reinit_cmdblk(cmd);
434 return cmd;
439 * @cmd: pointer to the command block
444 void pmcraid_return_cmd(struct pmcraid_cmd *cmd)
446 struct pmcraid_instance *pinstance = cmd->drv_inst;
450 list_add_tail(&cmd->free_list, &pinstance->free_cmd_pool);
593 * @cmd: pointer to reset command
600 static void pmcraid_bist_done(struct pmcraid_cmd *cmd)
602 struct pmcraid_instance *pinstance = cmd->drv_inst;
611 cmd->time_left > 0) {
613 cmd->timer.expires = jiffies + cmd->time_left;
614 cmd->time_left = 0;
615 cmd->timer.data = (unsigned long)cmd;
616 cmd->timer.function =
618 add_timer(&cmd->timer);
620 cmd->time_left = 0;
623 pmcraid_ioa_reset(cmd);
630 * @cmd: pointer to reset cmd
634 static void pmcraid_start_bist(struct pmcraid_cmd *cmd)
636 struct pmcraid_instance *pinstance = cmd->drv_inst;
647 cmd->time_left = msecs_to_jiffies(PMCRAID_BIST_TIMEOUT);
648 cmd->timer.data = (unsigned long)cmd;
649 cmd->timer.expires = jiffies + msecs_to_jiffies(PMCRAID_BIST_TIMEOUT);
650 cmd->timer.function = (void (*)(unsigned long))pmcraid_bist_done;
651 add_timer(&cmd->timer);
656 * @cmd: pointer to command block used in reset sequence
660 static void pmcraid_reset_alert_done(struct pmcraid_cmd *cmd)
662 struct pmcraid_instance *pinstance = cmd->drv_inst;
671 cmd->time_left <= 0) {
674 pmcraid_ioa_reset(cmd);
679 cmd->time_left -= PMCRAID_CHECK_FOR_RESET_TIMEOUT;
680 cmd->timer.data = (unsigned long)cmd;
681 cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT;
682 cmd->timer.function =
684 add_timer(&cmd->timer);
690 * @cmd : command block to be used for reset sequence.
698 static void pmcraid_reset_alert(struct pmcraid_cmd *cmd)
700 struct pmcraid_instance *pinstance = cmd->drv_inst;
718 cmd->time_left = PMCRAID_RESET_TIMEOUT;
719 cmd->timer.data = (unsigned long)cmd;
720 cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT;
721 cmd->timer.function =
723 add_timer(&cmd->timer);
733 pmcraid_start_bist(cmd);
740 * @cmd : pointer to command structure, that got timedout
747 static void pmcraid_timeout_handler(struct pmcraid_cmd *cmd)
749 struct pmcraid_instance *pinstance = cmd->drv_inst;
753 "Adapter being reset due to cmd(CDB[0] = %x) timeout\n",
754 cmd->ioa_cb->ioarcb.cdb[0]);
765 cmd = pmcraid_get_free_cmd(pinstance);
770 if (cmd == NULL) {
777 pinstance->reset_cmd = cmd;
782 if (pinstance->reset_cmd != cmd) {
787 pmcraid_err("cmd is pending but reset in progress\n");
795 if (cmd == pinstance->reset_cmd)
796 cmd->cmd_done = pmcraid_ioa_reset;
807 pmcraid_reset_alert(cmd);
814 * @cmd: command that got response from IOA
819 static void pmcraid_internal_done(struct pmcraid_cmd *cmd)
821 pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n",
822 cmd->ioa_cb->ioarcb.cdb[0],
823 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
826 * response. Same will be indicated as part of cmd->completion_req
827 * field. Response path needs to wake up any waiters waiting for cmd
830 if (cmd->completion_req) {
831 cmd->completion_req = 0;
832 complete(&cmd->wait_for_completion);
839 if (cmd->release) {
840 cmd->release = 0;
841 pmcraid_return_cmd(cmd);
848 * @cmd: command that got response from IOA
857 static void pmcraid_reinit_cfgtable_done(struct pmcraid_cmd *cmd)
859 pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n",
860 cmd->ioa_cb->ioarcb.cdb[0],
861 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
863 if (cmd->release) {
864 cmd->release = 0;
865 pmcraid_return_cmd(cmd);
868 schedule_work(&cmd->drv_inst->worker_q);
873 * @cmd: pmcraid_command
881 static void pmcraid_erp_done(struct pmcraid_cmd *cmd)
883 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
884 struct pmcraid_instance *pinstance = cmd->drv_inst;
885 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
891 cmd->ioa_cb->ioarcb.cdb[0], ioasc);
897 if (cmd->sense_buffer != NULL) {
899 cmd->sense_buffer,
903 cmd->sense_buffer, cmd->sense_buffer_dma);
904 cmd->sense_buffer = NULL;
905 cmd->sense_buffer_dma = 0;
909 pmcraid_return_cmd(cmd);
919 * @cmd : command to be sent to the device
924 static void _pmcraid_fire_command(struct pmcraid_cmd *cmd)
926 struct pmcraid_instance *pinstance = cmd->drv_inst;
929 /* Add this command block to pending cmd pool. We do this prior to
932 * (isr/tasklet) looks for cmd block in the pending pending list.
935 list_add_tail(&cmd->free_list, &pinstance->pending_cmd_pool);
941 iowrite32(le32_to_cpu(cmd->ioa_cb->ioarcb.ioarcb_bus_addr),
951 * @cmd: pointer to the command block to be fired to IOA
960 struct pmcraid_cmd *cmd,
967 cmd->cmd_done = cmd_done;
971 cmd->timer.data = (unsigned long)cmd;
972 cmd->timer.expires = jiffies + timeout;
973 cmd->timer.function = (void (*)(unsigned long))timeout_func;
974 add_timer(&cmd->timer);
978 _pmcraid_fire_command(cmd);
983 * @cmd: pointer to the command block used for sending IOA shutdown command
988 static void pmcraid_ioa_shutdown_done(struct pmcraid_cmd *cmd)
990 struct pmcraid_instance *pinstance = cmd->drv_inst;
994 pmcraid_ioa_reset(cmd);
1001 * @cmd: pointer to the command block used as part of reset sequence
1006 static void pmcraid_ioa_shutdown(struct pmcraid_cmd *cmd)
1009 cmd->ioa_cb->ioarcb.cdb[0],
1010 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
1015 pmcraid_reinit_cmdblk(cmd);
1016 cmd->ioa_cb->ioarcb.request_type = REQ_TYPE_IOACMD;
1017 cmd->ioa_cb->ioarcb.resource_handle =
1019 cmd->ioa_cb->ioarcb.cdb[0] = PMCRAID_IOA_SHUTDOWN;
1020 cmd->ioa_cb->ioarcb.cdb[1] = PMCRAID_SHUTDOWN_NORMAL;
1024 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle));
1026 pmcraid_notify_ioastate(cmd->drv_inst, PMC_DEVICE_EVENT_SHUTDOWN_START);
1028 pmcraid_send_cmd(cmd, pmcraid_ioa_shutdown_done,
1036 * @cmd: pointer to command block used to send INQUIRY command
1043 static void pmcraid_get_fwversion_done(struct pmcraid_cmd *cmd)
1045 struct pmcraid_instance *pinstance = cmd->drv_inst;
1046 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
1057 pmcraid_reset_alert(cmd);
1060 pmcraid_querycfg(cmd);
1067 * @cmd: pointer to command block used to send INQUIRY command
1072 static void pmcraid_get_fwversion(struct pmcraid_cmd *cmd)
1074 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
1076 struct pmcraid_instance *pinstance = cmd->drv_inst;
1079 pmcraid_reinit_cmdblk(cmd);
1090 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
1103 pmcraid_send_cmd(cmd, pmcraid_get_fwversion_done,
1109 * @cmd: pointer to command block to be used for identify hrrq
1114 static void pmcraid_identify_hrrq(struct pmcraid_cmd *cmd)
1116 struct pmcraid_instance *pinstance = cmd->drv_inst;
1117 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
1118 int index = cmd->hrrq_index;
1123 pmcraid_reinit_cmdblk(cmd);
1124 cmd->hrrq_index = index + 1;
1126 if (cmd->hrrq_index < pinstance->num_hrrq) {
1129 cmd->hrrq_index = 0;
1155 pmcraid_send_cmd(cmd, done_function,
1160 static void pmcraid_process_ccn(struct pmcraid_cmd *cmd);
1161 static void pmcraid_process_ldn(struct pmcraid_cmd *cmd);
1166 * @cmd: initialized command block pointer
1171 static void pmcraid_send_hcam_cmd(struct pmcraid_cmd *cmd)
1173 if (cmd->ioa_cb->ioarcb.cdb[1] == PMCRAID_HCAM_CODE_CONFIG_CHANGE)
1174 atomic_set(&(cmd->drv_inst->ccn.ignore), 0);
1176 atomic_set(&(cmd->drv_inst->ldn.ignore), 0);
1178 pmcraid_send_cmd(cmd, cmd->cmd_done, 0, NULL);
1196 struct pmcraid_cmd *cmd;
1204 cmd = pmcraid_get_free_cmd(pinstance);
1206 if (!cmd) {
1208 return cmd;
1224 hcam->cmd = cmd;
1226 ioarcb = &cmd->ioa_cb->ioarcb;
1227 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
1247 cmd->cmd_done = cmd_done;
1248 return cmd;
1263 struct pmcraid_cmd *cmd = pmcraid_init_hcam(pinstance, type);
1264 pmcraid_send_hcam_cmd(cmd);
1271 * @cmd: pointer to cmd that is used as cancelling command
1275 struct pmcraid_cmd *cmd,
1279 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
1301 * @cmd: command to be used as cancelling command
1306 struct pmcraid_cmd *cmd,
1314 pinstance = cmd->drv_inst;
1319 * currently not pending with IOA, we would have hcam->cmd as non-null
1321 if (hcam->cmd == NULL)
1324 pmcraid_prepare_cancel_cmd(cmd, hcam->cmd);
1329 pmcraid_send_cmd(cmd, cmd_done,
1337 * @cmd: command block to be used for cancelling the HCAM
1339 static void pmcraid_cancel_ccn(struct pmcraid_cmd *cmd)
1342 cmd->ioa_cb->ioarcb.cdb[0],
1343 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
1345 pmcraid_reinit_cmdblk(cmd);
1347 pmcraid_cancel_hcam(cmd,
1355 * @cmd: command block to be used for cancelling the HCAM
1357 static void pmcraid_cancel_ldn(struct pmcraid_cmd *cmd)
1359 pmcraid_cancel_hcam(cmd,
1583 struct pmcraid_cmd *cmd;
1624 pmcraid_err("lost CCN, no free cmd for querycfg\n");
1720 cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1721 if (cmd)
1722 pmcraid_send_hcam_cmd(cmd);
1744 * @cmd: pointer to command that resulted in 'ioasc'
1746 void pmcraid_ioasc_logger(u32 ioasc, struct pmcraid_cmd *cmd)
1751 cmd->drv_inst->current_log_level < error_info->log_level)
1755 pmcraid_err("cmd [%x] for resource %x failed with %x(%s)\n",
1756 cmd->ioa_cb->ioarcb.cdb[0],
1757 cmd->ioa_cb->ioarcb.resource_handle,
1810 * @cmd: pointer to command struct
1818 static void pmcraid_process_ccn(struct pmcraid_cmd *cmd)
1820 struct pmcraid_instance *pinstance = cmd->drv_inst;
1821 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
1824 pinstance->ccn.cmd = NULL;
1825 pmcraid_return_cmd(cmd);
1847 * @cmd: pointer to command block
1854 static void pmcraid_process_ldn(struct pmcraid_cmd *cmd)
1856 struct pmcraid_instance *pinstance = cmd->drv_inst;
1859 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
1864 pinstance->ldn.cmd = NULL;
1865 pmcraid_return_cmd(cmd);
1892 cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);
1893 if (cmd)
1894 pmcraid_send_hcam_cmd(cmd);
1913 * @cmd: pointer to command used as part of reset sequence
1915 static void pmcraid_unregister_hcams(struct pmcraid_cmd *cmd)
1917 struct pmcraid_instance *pinstance = cmd->drv_inst;
1936 pmcraid_reset_alert(cmd);
1944 pmcraid_cancel_ldn(cmd);
1980 * @cmd : pointer to reset command block
1985 static void pmcraid_soft_reset(struct pmcraid_cmd *cmd)
1987 struct pmcraid_instance *pinstance = cmd->drv_inst;
1995 cmd->cmd_done = pmcraid_ioa_reset;
1996 cmd->timer.data = (unsigned long)cmd;
1997 cmd->timer.expires = jiffies +
1999 cmd->timer.function = (void (*)(unsigned long))pmcraid_timeout_handler;
2001 if (!timer_pending(&cmd->timer))
2002 add_timer(&cmd->timer);
2047 * otherwise just completes the commands and returns the cmd blocks to free
2055 struct pmcraid_cmd *cmd, *temp;
2062 list_for_each_entry_safe(cmd, temp, &pinstance->pending_cmd_pool,
2064 list_del(&cmd->free_list);
2067 cmd->ioa_cb->ioasa.ioasc =
2069 cmd->ioa_cb->ioasa.ilid =
2073 del_timer(&cmd->timer);
2080 if (cmd->scsi_cmd) {
2082 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2083 __le32 resp = cmd->ioa_cb->ioarcb.response_handle;
2088 pmcraid_return_cmd(cmd);
2092 cmd->ioa_cb->ioarcb.cdb[0],
2095 } else if (cmd->cmd_done == pmcraid_internal_done ||
2096 cmd->cmd_done == pmcraid_erp_done) {
2097 cmd->cmd_done(cmd);
2098 } else if (cmd->cmd_done != pmcraid_ioa_reset &&
2099 cmd->cmd_done != pmcraid_ioa_shutdown_done) {
2100 pmcraid_return_cmd(cmd);
2113 * @cmd: pointer to the cmd block to be used for entire reset process
2125 static void pmcraid_ioa_reset(struct pmcraid_cmd *cmd)
2127 struct pmcraid_instance *pinstance = cmd->drv_inst;
2132 if (pinstance->reset_cmd != cmd) {
2134 pinstance->reset_cmd = cmd;
2138 pinstance->ioa_state, cmd);
2158 pmcraid_reset_alert(cmd);
2176 pmcraid_reinit_cmdblk(cmd);
2177 pmcraid_identify_hrrq(cmd);
2180 pmcraid_soft_reset(cmd);
2187 pmcraid_reset_alert(cmd);
2198 pmcraid_start_bist(cmd);
2226 pmcraid_reset_alert(cmd);
2240 pmcraid_reset_alert(cmd);
2264 pmcraid_reinit_cmdblk(cmd);
2265 pmcraid_identify_hrrq(cmd);
2268 pmcraid_soft_reset(cmd);
2284 pmcraid_identify_hrrq(cmd);
2310 pmcraid_reinit_cmdblk(cmd);
2311 pmcraid_unregister_hcams(cmd);
2327 pmcraid_return_cmd(cmd);
2354 struct pmcraid_cmd *cmd;
2361 cmd = pmcraid_get_free_cmd(pinstance);
2363 if (cmd == NULL) {
2369 pinstance->reset_cmd = cmd;
2373 pmcraid_ioa_reset(cmd);
2491 * @cmd: pmcraid command struct
2496 static void pmcraid_request_sense(struct pmcraid_cmd *cmd)
2498 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
2502 cmd->sense_buffer = pci_alloc_consistent(cmd->drv_inst->pdev,
2504 &cmd->sense_buffer_dma);
2506 if (cmd->sense_buffer == NULL) {
2509 pmcraid_erp_done(cmd);
2514 memset(&cmd->ioa_cb->ioasa, 0, sizeof(struct pmcraid_ioasa));
2523 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
2530 ioadl->address = cpu_to_le64(cmd->sense_buffer_dma);
2539 pmcraid_send_cmd(cmd, pmcraid_erp_done,
2546 * @cmd: command that failed
2551 static void pmcraid_cancel_all(struct pmcraid_cmd *cmd, u32 sense)
2553 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2554 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
2575 pmcraid_send_cmd(cmd, cmd_done,
2583 * @cmd: pointer to failing command block
2588 static void pmcraid_frame_auto_sense(struct pmcraid_cmd *cmd)
2590 u8 *sense_buf = cmd->scsi_cmd->sense_buffer;
2591 struct pmcraid_resource_entry *res = cmd->scsi_cmd->device->hostdata;
2592 struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa;
2597 cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
2650 * @cmd: pointer to pmcraid_cmd that has failed
2660 static int pmcraid_error_handler(struct pmcraid_cmd *cmd)
2662 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2664 struct pmcraid_instance *pinstance = cmd->drv_inst;
2665 struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa;
2683 pmcraid_frame_auto_sense(cmd);
2687 pmcraid_ioasc_logger(ioasc, cmd);
2744 pmcraid_cancel_all(cmd, sense_copied);
2746 pmcraid_erp_done(cmd);
2748 pmcraid_request_sense(cmd);
2782 struct pmcraid_cmd *cmd;
2816 /* get a free cmd block */
2817 cmd = pmcraid_get_free_cmd(pinstance);
2819 if (cmd == NULL) {
2821 pmcraid_err("%s: no cmd blocks are available\n", __func__);
2825 ioarcb = &cmd->ioa_cb->ioarcb;
2836 init_completion(&cmd->wait_for_completion);
2837 cmd->completion_req = 1;
2839 pmcraid_info("cmd(CDB[0] = %x) for %x with index = %d\n",
2840 cmd->ioa_cb->ioarcb.cdb[0],
2841 le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle),
2842 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2);
2844 pmcraid_send_cmd(cmd,
2855 wait_for_completion(&cmd->wait_for_completion);
2860 pmcraid_return_cmd(cmd);
2862 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
2871 * @cmd: pointer to pmcraid command struct
2884 static int _pmcraid_io_done(struct pmcraid_cmd *cmd, int reslen, int ioasc)
2886 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2892 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
2893 cmd->ioa_cb->ioarcb.cdb[0],
2897 rc = pmcraid_error_handler(cmd);
2910 * @cmd: pointer to pmcraid command struct
2919 static void pmcraid_io_done(struct pmcraid_cmd *cmd)
2921 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
2922 u32 reslen = le32_to_cpu(cmd->ioa_cb->ioasa.residual_data_length);
2924 if (_pmcraid_io_done(cmd, reslen, ioasc) == 0)
2925 pmcraid_return_cmd(cmd);
2931 * @cmd: command block of the command to be aborted
2934 * returns pointer to command structure used as cancelling cmd
2936 static struct pmcraid_cmd *pmcraid_abort_cmd(struct pmcraid_cmd *cmd)
2942 pinstance = (struct pmcraid_instance *)cmd->drv_inst;
2943 res = cmd->scsi_cmd->device->hostdata;
2948 pmcraid_err("%s: no cmd blocks are available\n", __func__);
2952 pmcraid_prepare_cancel_cmd(cancel_cmd, cmd);
2955 cmd->ioa_cb->ioarcb.cdb[0],
2956 cmd->ioa_cb->ioarcb.response_handle >> 2);
3022 struct pmcraid_cmd *cmd;
3055 /* loop over pending cmd list to find cmd corresponding to this
3061 list_for_each_entry(cmd, &pinstance->pending_cmd_pool, free_list) {
3063 if (cmd->scsi_cmd == scsi_cmd) {
3076 cancel_cmd = pmcraid_abort_cmd(cmd);
3082 cancel_cmd->res = cmd->scsi_cmd->device->hostdata;
3196 * @cmd: pmcraid command struct
3204 pmcraid_init_ioadls(struct pmcraid_cmd *cmd, int sgcount)
3207 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
3223 cpu_to_le64((cmd->ioa_cb_bus_addr) +
3229 cpu_to_le64((cmd->ioa_cb_bus_addr) +
3244 * @cmd: pmcraid command struct
3254 struct pmcraid_cmd *cmd
3260 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
3261 struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb);
3287 ioadl = pmcraid_init_ioadls(cmd, nseg);
3467 * would use cmd block queue locks (free_pool_lock and pending_pool_lock)
3482 struct pmcraid_cmd *cmd;
3517 cmd = pmcraid_get_free_cmd(pinstance);
3519 if (cmd == NULL) {
3524 cmd->scsi_cmd = scsi_cmd;
3525 ioarcb = &(cmd->ioa_cb->ioarcb);
3531 * generated internally uses hrrq_id 0, exception to this is the cmd
3537 cmd->cmd_done = pmcraid_io_done;
3555 rc = pmcraid_build_ioadl(pinstance, cmd);
3570 _pmcraid_fire_command(cmd);
3573 pmcraid_return_cmd(cmd);
3634 * @cmd : pointer to struct pmcraid_cmd
3642 struct pmcraid_cmd *cmd,
3649 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
3660 sglist->num_dma_sg = pci_map_sg(cmd->drv_inst->pdev,
3665 dev_err(&cmd->drv_inst->pdev->dev,
3671 cmd->sglist = sglist;
3674 ioadl = pmcraid_init_ioadls(cmd, sglist->num_dma_sg);
3693 * @cmd: pointer to struct pmcraid_cmd for which ioadls were allocated
3701 struct pmcraid_cmd *cmd,
3706 struct pmcraid_sglist *sglist = cmd->sglist;
3709 pci_unmap_sg(cmd->drv_inst->pdev,
3714 cmd->sglist = NULL;
3722 * @cmd: ioctl code
3737 struct pmcraid_cmd *cmd;
3814 cmd = pmcraid_get_free_cmd(pinstance);
3816 if (!cmd) {
3822 cmd->scsi_cmd = NULL;
3823 ioarcb = &(cmd->ioa_cb->ioarcb);
3845 * generated internally uses hrrq_id 0, exception to this is the cmd
3853 rc = pmcraid_build_passthrough_ioadls(cmd,
3866 rc = pmcraid_copy_sglist(cmd->sglist,
3879 cmd->cmd_done = pmcraid_internal_done;
3880 init_completion(&cmd->wait_for_completion);
3881 cmd->completion_req = 1;
3884 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
3885 cmd->ioa_cb->ioarcb.cdb[0],
3886 le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle));
3889 _pmcraid_fire_command(cmd);
3905 wait_for_completion(&cmd->wait_for_completion);
3907 &cmd->wait_for_completion,
3910 pmcraid_info("aborting cmd %d (CDB[0] = %x) due to timeout\n",
3911 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle >> 2),
3912 cmd->ioa_cb->ioarcb.cdb[0]);
3915 cancel_cmd = pmcraid_abort_cmd(cmd);
3942 &cmd->wait_for_completion,
3944 pmcraid_reset_bringup(cmd->drv_inst);
3954 if (PMCRAID_IOASC_SENSE_KEY(le32_to_cpu(cmd->ioa_cb->ioasa.ioasc))) {
3960 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
3961 if (copy_to_user(ioasa, &cmd->ioa_cb->ioasa,
3972 rc = pmcraid_copy_sglist(cmd->sglist,
3983 pmcraid_release_passthrough_ioadls(cmd, request_size, direction);
3984 pmcraid_return_cmd(cmd);
3999 * @cmd: ioctl command passed in
4008 unsigned int cmd,
4015 if (!access_ok(VERIFY_READ, user_buffer, _IOC_SIZE(cmd))) {
4020 switch (cmd) {
4036 * @cmd: ioctl command
4046 int cmd,
4069 if ((_IOC_DIR(cmd) & _IOC_READ) == _IOC_READ)
4089 unsigned int cmd,
4104 retval = pmcraid_check_ioctl_buffer(cmd, (void *)arg, hdr);
4120 switch (_IOC_TYPE(cmd)) {
4126 if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE)
4130 cmd,
4134 if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE)
4141 cmd,
4604 struct pmcraid_cmd *cmd = NULL;
4620 cmd = pinstance->cmd_list[cmd_index];
4625 list_del(&cmd->free_list);
4628 del_timer(&cmd->timer);
4631 if (cmd->cmd_done == pmcraid_ioa_reset) {
4634 cmd->cmd_done(cmd);
4637 } else if (cmd->cmd_done != NULL) {
4638 cmd->cmd_done(cmd);
4803 * pmcraid_allocate_cmd_blocks - allocate memory for cmd block structures
5181 pmcraid_err("couldn't allocate memory for cmd blocks\n");
5556 * @cmd: pointer to reset command block
5558 static void pmcraid_complete_ioa_reset(struct pmcraid_cmd *cmd)
5560 struct pmcraid_instance *pinstance = cmd->drv_inst;
5564 pmcraid_ioa_reset(cmd);
5573 * @cmd: pointer to pmcraid_cmd structure
5578 static void pmcraid_set_supported_devs(struct pmcraid_cmd *cmd)
5580 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
5583 pmcraid_reinit_cmdblk(cmd);
5594 if (cmd->drv_inst->reinit_cfg_table) {
5595 cmd->drv_inst->reinit_cfg_table = 0;
5596 cmd->release = 1;
5604 pmcraid_send_cmd(cmd,
5613 * @cmd: pointer to pmcraid command struct
5623 static void pmcraid_init_res_table(struct pmcraid_cmd *cmd)
5625 struct pmcraid_instance *pinstance = cmd->drv_inst;
5722 pmcraid_set_supported_devs(cmd);
5727 * @cmd: pointer pmcraid_cmd struct
5735 static void pmcraid_querycfg(struct pmcraid_cmd *cmd)
5737 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
5739 struct pmcraid_instance *pinstance = cmd->drv_inst;
5761 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
5776 pmcraid_send_cmd(cmd, pmcraid_init_res_table,