Lines Matching refs:ioc
67 static int _ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type,
86 * @ioc: per adapter object
88 * Context: Calling function should acquire ioc->sas_device_lock
94 _ctl_sas_device_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
99 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
112 * @ioc: per adapter object
122 _ctl_display_some_debug(struct MPT2SAS_ADAPTER *ioc, u16 smid,
128 if (!(ioc->logging_level & MPT_DEBUG_IOCTL))
131 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
138 snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
142 desc = ioc->tmp_string;
159 snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
164 desc = ioc->tmp_string;
190 snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
194 desc = ioc->tmp_string;
218 ioc->name, calling_function_name, desc, smid);
226 ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
237 spin_lock_irqsave(&ioc->sas_device_lock, flags);
238 sas_device = _ctl_sas_device_find_by_handle(ioc,
242 "phy(%d)\n", ioc->name, (unsigned long long)
246 ioc->name, sas_device->enclosure_logical_id,
249 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
253 "(0x%02x)\n", ioc->name,
262 * @ioc: per adapter object
268 * The callback handler when using ioc->ctl_cb_idx.
274 mpt2sas_ctl_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
282 if (ioc->ctl_cmds.status == MPT2_CMD_NOT_USED)
284 if (ioc->ctl_cmds.smid != smid)
286 ioc->ctl_cmds.status |= MPT2_CMD_COMPLETE;
287 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
289 memcpy(ioc->ctl_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
290 ioc->ctl_cmds.status |= MPT2_CMD_REPLY_VALID;
300 sense_data = mpt2sas_base_get_sense_buffer(ioc,
302 memcpy(ioc->ctl_cmds.sense, sense_data, sz);
307 _ctl_display_some_debug(ioc, smid, "ctl_done", mpi_reply);
309 ioc->ctl_cmds.status &= ~MPT2_CMD_PENDING;
310 complete(&ioc->ctl_cmds.done);
316 * @ioc: per adapter object
319 * The bitmask in ioc->event_type[] indicates which events should be
325 _ctl_check_event_type(struct MPT2SAS_ADAPTER *ioc, u16 event)
330 if (event >= 128 || !event || !ioc->event_log)
337 return desired_event & ioc->event_type[i];
342 * @ioc: per adapter object
348 mpt2sas_ctl_add_to_event_log(struct MPT2SAS_ADAPTER *ioc,
357 if (!ioc->event_log)
362 if (_ctl_check_event_type(ioc, event)) {
365 i = ioc->event_context % MPT2SAS_CTL_EVENT_LOG_SIZE;
366 event_log = ioc->event_log;
368 event_log[i].context = ioc->event_context++;
382 (send_aen && !ioc->aen_event_read_flag)) {
383 ioc->aen_event_read_flag = 1;
392 * @ioc: per adapter object
397 * This function merely adds a new work task into ioc->firmware_event_thread.
404 mpt2sas_ctl_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
409 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
410 mpt2sas_ctl_add_to_event_log(ioc, mpi_reply);
416 * @ioc: per adapter object
417 * @iocpp: The ioc pointer is returned in this.
424 struct MPT2SAS_ADAPTER *ioc;
426 list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
427 if (ioc->id != ioc_number)
429 *iocpp = ioc;
438 * @ioc: per adapter object
447 mpt2sas_ctl_reset_handler(struct MPT2SAS_ADAPTER *ioc, int reset_phase)
454 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
455 "MPT2_IOC_PRE_RESET\n", ioc->name, __func__));
457 if (!(ioc->diag_buffer_status[i] &
460 if ((ioc->diag_buffer_status[i] &
463 _ctl_send_release(ioc, i, &issue_reset);
467 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
468 "MPT2_IOC_AFTER_RESET\n", ioc->name, __func__));
469 if (ioc->ctl_cmds.status & MPT2_CMD_PENDING) {
470 ioc->ctl_cmds.status |= MPT2_CMD_RESET;
471 mpt2sas_base_free_smid(ioc, ioc->ctl_cmds.smid);
472 complete(&ioc->ctl_cmds.done);
476 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
477 "MPT2_IOC_DONE_RESET\n", ioc->name, __func__));
480 if (!(ioc->diag_buffer_status[i] &
483 if ((ioc->diag_buffer_status[i] &
486 ioc->diag_buffer_status[i] |=
529 struct MPT2SAS_ADAPTER *ioc;
533 list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
534 if (ioc->aen_event_read_flag)
542 * @ioc: per adapter object
550 _ctl_set_task_mid(struct MPT2SAS_ADAPTER *ioc, struct mpt2_ioctl_command *karg,
574 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
575 for (i = ioc->scsiio_depth; i && !found; i--) {
576 scmd = ioc->scsi_lookup[i - 1].scmd;
587 tm_request->TaskMID = cpu_to_le16(ioc->scsi_lookup[i - 1].smid);
590 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
593 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
594 "handle(0x%04x), lun(%d), no active mid!!\n", ioc->name,
596 tm_reply = ioc->ctl_cmds.reply;
603 sz = min_t(u32, karg->max_reply_bytes, ioc->reply_sz);
604 if (copy_to_user(karg->reply_frame_buf_ptr, ioc->ctl_cmds.reply,
611 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
612 "handle(0x%04x), lun(%d), task_mid(%d)\n", ioc->name,
620 * @ioc: per adapter object
626 _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
650 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
652 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
655 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
657 ioc->name, __func__);
663 ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
667 "%s: failed due to ioc not operational\n",
668 ioc->name, __func__);
673 ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
675 "operational state(count=%d)\n", ioc->name,
679 printk(MPT2SAS_INFO_FMT "%s: ioc is operational\n",
680 ioc->name, __func__);
682 mpi_request = kzalloc(ioc->request_sz, GFP_KERNEL);
685 "mpi_request\n", ioc->name, __func__);
691 if (karg.data_sge_offset * 4 > ioc->request_sz ||
706 smid = mpt2sas_base_get_smid_hpr(ioc, ioc->ctl_cb_idx);
709 ioc->name, __func__);
715 smid = mpt2sas_base_get_smid_scsiio(ioc, ioc->ctl_cb_idx, NULL);
718 ioc->name, __func__);
725 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
726 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
727 request = mpt2sas_base_get_msg_frame(ioc, smid);
729 ioc->ctl_cmds.smid = smid;
737 ioc->facts.MaxDevHandle) {
739 mpt2sas_base_free_smid(ioc, smid);
746 data_out = pci_alloc_consistent(ioc->pdev, data_out_sz,
752 mpt2sas_base_free_smid(ioc, smid);
760 mpt2sas_base_free_smid(ioc, smid);
766 data_in = pci_alloc_consistent(ioc->pdev, data_in_sz,
772 mpt2sas_base_free_smid(ioc, smid);
781 mpt2sas_base_build_zero_len_sge(ioc, psge);
787 ioc->base_add_sg_single(psge, sgl_flags |
791 psge += ioc->sge_size;
798 ioc->base_add_sg_single(psge, sgl_flags |
805 ioc->base_add_sg_single(psge, sgl_flags |
812 ioc->base_add_sg_single(psge, sgl_flags |
818 _ctl_display_some_debug(ioc, smid, "ctl_request", NULL);
821 init_completion(&ioc->ctl_cmds.done);
830 mpt2sas_base_get_sense_buffer_dma(ioc, smid);
831 memset(ioc->ctl_cmds.sense, 0, SCSI_SENSE_BUFFERSIZE);
833 mpt2sas_base_put_smid_scsi_io(ioc, smid,
836 mpt2sas_base_put_smid_default(ioc, smid);
844 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "TASK_MGMT: "
845 "handle(0x%04x), task_type(0x%02x)\n", ioc->name,
852 if (_ctl_set_task_mid(ioc, &karg, tm_request)) {
853 mpt2sas_base_free_smid(ioc, smid);
858 mpt2sas_scsih_set_tm_flag(ioc, le16_to_cpu(
860 mpt2sas_base_put_smid_hi_priority(ioc, smid);
869 /* ioc determines which port to use */
878 ioc->ioc_link_reset_in_progress = 1;
879 ioc->ignore_loginfos = 1;
881 mpt2sas_base_put_smid_default(ioc, smid);
892 ioc->ioc_link_reset_in_progress = 1;
893 ioc->ignore_loginfos = 1;
895 mpt2sas_base_put_smid_default(ioc, smid);
899 mpt2sas_base_put_smid_default(ioc, smid);
907 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
912 mpt2sas_scsih_clear_tm_flag(ioc, le16_to_cpu(
916 ioc->ioc_link_reset_in_progress) {
917 ioc->ioc_link_reset_in_progress = 0;
918 ioc->ignore_loginfos = 0;
920 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
921 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
924 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
929 mpi_reply = ioc->ctl_cmds.reply;
934 (ioc->logging_level & MPT_DEBUG_TM)) {
940 "TerminationCount(0x%08x)\n", ioc->name,
959 sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz);
960 if (copy_to_user(karg.reply_frame_buf_ptr, ioc->ctl_cmds.reply,
975 ioc->ctl_cmds.sense, sz)) {
990 "= (0x%04x)\n", ioc->name,
992 mpt2sas_halt_firmware(ioc);
993 mpt2sas_scsih_issue_tm(ioc,
997 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
999 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1007 pci_free_consistent(ioc->pdev, data_in_sz, data_in,
1011 pci_free_consistent(ioc->pdev, data_out_sz, data_out,
1015 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1016 mutex_unlock(&ioc->ctl_cmds.mutex);
1028 struct MPT2SAS_ADAPTER *ioc;
1035 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1038 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1042 if (ioc->is_warpdrive)
1046 if (ioc->pfacts)
1047 karg.port_number = ioc->pfacts[0].PortNumber;
1048 karg.hw_rev = ioc->pdev->revision;
1049 karg.pci_id = ioc->pdev->device;
1050 karg.subsystem_device = ioc->pdev->subsystem_device;
1051 karg.subsystem_vendor = ioc->pdev->subsystem_vendor;
1052 karg.pci_information.u.bits.bus = ioc->pdev->bus->number;
1053 karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn);
1054 karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn);
1055 karg.pci_information.segment_id = pci_domain_nr(ioc->pdev->bus);
1056 karg.firmware_version = ioc->facts.FWVersion.Word;
1060 karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
1078 struct MPT2SAS_ADAPTER *ioc;
1085 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1088 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1092 memcpy(karg.event_types, ioc->event_type,
1111 struct MPT2SAS_ADAPTER *ioc;
1118 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1121 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1124 if (ioc->event_log)
1126 memcpy(ioc->event_type, karg.event_types,
1128 mpt2sas_base_validate_event_type(ioc, ioc->event_type);
1131 ioc->event_context = 0;
1132 ioc->aen_event_read_flag = 0;
1133 ioc->event_log = kcalloc(MPT2SAS_CTL_EVENT_LOG_SIZE,
1135 if (!ioc->event_log) {
1151 struct MPT2SAS_ADAPTER *ioc;
1160 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1163 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1174 if (!max || !ioc->event_log)
1178 if (copy_to_user(uarg->event_data, ioc->event_log, number_bytes)) {
1185 ioc->aen_event_read_flag = 0;
1197 struct MPT2SAS_ADAPTER *ioc;
1205 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1208 if (ioc->shost_recovery || ioc->pci_error_recovery ||
1209 ioc->is_driver_loading)
1211 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1214 retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1217 ioc->name, ((!retval) ? "SUCCESS" : "FAILED"));
1223 * @ioc: per adapter object
1227 _ctl_btdh_search_sas_device(struct MPT2SAS_ADAPTER *ioc,
1234 if (list_empty(&ioc->sas_device_list))
1237 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1238 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
1253 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1259 * @ioc: per adapter object
1263 _ctl_btdh_search_raid_device(struct MPT2SAS_ADAPTER *ioc,
1270 if (list_empty(&ioc->raid_device_list))
1273 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1274 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1289 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1301 struct MPT2SAS_ADAPTER *ioc;
1309 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1312 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1315 rc = _ctl_btdh_search_sas_device(ioc, &karg);
1317 _ctl_btdh_search_raid_device(ioc, &karg);
1329 * @ioc: per adapter object
1335 _ctl_diag_capability(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type)
1341 if (ioc->facts.IOCCapabilities &
1346 if (ioc->facts.IOCCapabilities &
1351 if (ioc->facts.IOCCapabilities &
1361 * @ioc: per adapter object
1366 _ctl_diag_register_2(struct MPT2SAS_ADAPTER *ioc,
1381 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1384 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1386 ioc->name, __func__);
1392 if (!_ctl_diag_capability(ioc, buffer_type)) {
1394 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1398 if (ioc->diag_buffer_status[buffer_type] &
1401 "buffer for buffer_type(0x%02x)\n", ioc->name, __func__,
1408 "is not 4 byte aligned\n", ioc->name, __func__);
1412 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1415 ioc->name, __func__);
1421 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1422 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1423 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1424 ioc->ctl_cmds.smid = smid;
1426 request_data = ioc->diag_buffer[buffer_type];
1428 ioc->unique_id[buffer_type] = diag_register->unique_id;
1429 ioc->diag_buffer_status[buffer_type] = 0;
1430 memcpy(ioc->product_specific[buffer_type],
1432 ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags;
1435 request_data_dma = ioc->diag_buffer_dma[buffer_type];
1436 if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) {
1437 pci_free_consistent(ioc->pdev,
1438 ioc->diag_buffer_sz[buffer_type],
1445 ioc->diag_buffer_sz[buffer_type] = 0;
1446 ioc->diag_buffer_dma[buffer_type] = 0;
1448 ioc->pdev, request_data_sz, &request_data_dma);
1452 ioc->name, __func__, request_data_sz);
1453 mpt2sas_base_free_smid(ioc, smid);
1456 ioc->diag_buffer[buffer_type] = request_data;
1457 ioc->diag_buffer_sz[buffer_type] = request_data_sz;
1458 ioc->diag_buffer_dma[buffer_type] = request_data_dma;
1469 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: diag_buffer(0x%p), "
1470 "dma(0x%llx), sz(%d)\n", ioc->name, __func__, request_data,
1476 cpu_to_le32(ioc->product_specific[buffer_type][i]);
1478 init_completion(&ioc->ctl_cmds.done);
1479 mpt2sas_base_put_smid_default(ioc, smid);
1480 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1483 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
1484 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
1488 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
1494 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
1496 ioc->name, __func__);
1501 mpi_reply = ioc->ctl_cmds.reply;
1505 ioc->diag_buffer_status[buffer_type] |=
1507 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n",
1508 ioc->name, __func__));
1511 "log_info(0x%08x)\n", ioc->name, __func__,
1518 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1524 pci_free_consistent(ioc->pdev, request_data_sz,
1527 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1533 * @ioc: per adapter object
1540 mpt2sas_enable_diag_buffer(struct MPT2SAS_ADAPTER *ioc, u8 bits_to_register)
1548 ioc->name);
1553 _ctl_diag_register_2(ioc, &diag_register);
1558 ioc->name);
1563 _ctl_diag_register_2(ioc, &diag_register);
1568 ioc->name);
1573 _ctl_diag_register_2(ioc, &diag_register);
1589 struct MPT2SAS_ADAPTER *ioc;
1597 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1600 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1602 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1604 rc = _ctl_diag_register_2(ioc, &karg);
1605 mutex_unlock(&ioc->ctl_cmds.mutex);
1620 struct MPT2SAS_ADAPTER *ioc;
1631 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1634 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1638 if (!_ctl_diag_capability(ioc, buffer_type)) {
1640 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1644 if ((ioc->diag_buffer_status[buffer_type] &
1647 "registered\n", ioc->name, __func__, buffer_type);
1650 if ((ioc->diag_buffer_status[buffer_type] &
1653 "released\n", ioc->name, __func__, buffer_type);
1657 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1659 "registered\n", ioc->name, __func__, karg.unique_id);
1663 request_data = ioc->diag_buffer[buffer_type];
1666 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1670 request_data_sz = ioc->diag_buffer_sz[buffer_type];
1671 request_data_dma = ioc->diag_buffer_dma[buffer_type];
1672 pci_free_consistent(ioc->pdev, request_data_sz,
1674 ioc->diag_buffer[buffer_type] = NULL;
1675 ioc->diag_buffer_status[buffer_type] = 0;
1691 struct MPT2SAS_ADAPTER *ioc;
1701 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1704 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1710 if (!_ctl_diag_capability(ioc, buffer_type)) {
1712 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1716 if ((ioc->diag_buffer_status[buffer_type] &
1719 "registered\n", ioc->name, __func__, buffer_type);
1724 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1726 "registered\n", ioc->name, __func__,
1732 request_data = ioc->diag_buffer[buffer_type];
1735 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1739 if (ioc->diag_buffer_status[buffer_type] & MPT2_DIAG_BUFFER_IS_RELEASED)
1749 ioc->product_specific[buffer_type][i];
1751 karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type];
1753 karg.unique_id = ioc->unique_id[buffer_type];
1754 karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type];
1758 "data @ %p\n", ioc->name, __func__, arg);
1766 * @ioc: per adapter object
1772 _ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type, u8 *issue_reset)
1782 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1788 ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
1790 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
1791 "skipping due to FAULT state\n", ioc->name,
1797 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1799 ioc->name, __func__);
1804 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1807 ioc->name, __func__);
1812 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1813 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1814 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1815 ioc->ctl_cmds.smid = smid;
1822 init_completion(&ioc->ctl_cmds.done);
1823 mpt2sas_base_put_smid_default(ioc, smid);
1824 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1827 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
1828 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
1832 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
1839 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
1841 ioc->name, __func__);
1846 mpi_reply = ioc->ctl_cmds.reply;
1850 ioc->diag_buffer_status[buffer_type] |=
1852 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n",
1853 ioc->name, __func__));
1856 "log_info(0x%08x)\n", ioc->name, __func__,
1862 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1879 struct MPT2SAS_ADAPTER *ioc;
1890 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1893 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1897 if (!_ctl_diag_capability(ioc, buffer_type)) {
1899 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1903 if ((ioc->diag_buffer_status[buffer_type] &
1906 "registered\n", ioc->name, __func__, buffer_type);
1910 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1912 "registered\n", ioc->name, __func__, karg.unique_id);
1916 if (ioc->diag_buffer_status[buffer_type] &
1919 "is already released\n", ioc->name, __func__,
1924 request_data = ioc->diag_buffer[buffer_type];
1928 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1933 if ((ioc->diag_buffer_status[buffer_type] &
1935 ioc->diag_buffer_status[buffer_type] |=
1937 ioc->diag_buffer_status[buffer_type] &=
1940 "was released due to host reset\n", ioc->name, __func__,
1945 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1947 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1950 rc = _ctl_send_release(ioc, buffer_type, &issue_reset);
1953 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1956 mutex_unlock(&ioc->ctl_cmds.mutex);
1970 struct MPT2SAS_ADAPTER *ioc;
1986 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1989 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1993 if (!_ctl_diag_capability(ioc, buffer_type)) {
1995 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1999 if (karg.unique_id != ioc->unique_id[buffer_type]) {
2001 "registered\n", ioc->name, __func__, karg.unique_id);
2005 request_data = ioc->diag_buffer[buffer_type];
2008 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
2012 request_size = ioc->diag_buffer_sz[buffer_type];
2016 "or bytes_to_read are not 4 byte aligned\n", ioc->name,
2025 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: diag_buffer(%p), "
2026 "offset(%d), sz(%d)\n", ioc->name, __func__,
2039 "mpt_diag_read_buffer_t data @ %p\n", ioc->name,
2047 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: Reregister "
2048 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type));
2049 if ((ioc->diag_buffer_status[buffer_type] &
2051 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
2052 "buffer_type(0x%02x) is still registered\n", ioc->name,
2058 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
2060 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
2063 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
2065 ioc->name, __func__);
2070 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
2073 ioc->name, __func__);
2079 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
2080 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
2081 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
2082 ioc->ctl_cmds.smid = smid;
2087 cpu_to_le32(ioc->diag_buffer_sz[buffer_type]);
2089 cpu_to_le64(ioc->diag_buffer_dma[buffer_type]);
2092 cpu_to_le32(ioc->product_specific[buffer_type][i]);
2096 init_completion(&ioc->ctl_cmds.done);
2097 mpt2sas_base_put_smid_default(ioc, smid);
2098 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
2101 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
2102 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
2106 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
2112 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
2114 ioc->name, __func__);
2119 mpi_reply = ioc->ctl_cmds.reply;
2123 ioc->diag_buffer_status[buffer_type] |=
2125 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n",
2126 ioc->name, __func__));
2129 "log_info(0x%08x)\n", ioc->name, __func__,
2136 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2141 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
2142 mutex_unlock(&ioc->ctl_cmds.mutex);
2170 struct MPT2SAS_ADAPTER *ioc;
2178 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
2179 !ioc)
2182 if (ioc->shost_recovery || ioc->pci_error_recovery ||
2183 ioc->is_driver_loading)
2188 ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
2234 struct MPT2SAS_ADAPTER *ioc;
2242 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
2243 !ioc)
2246 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT
2247 "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd));
2286 struct MPT2SAS_ADAPTER *ioc;
2299 if (_ctl_verify_adapter(karg32.hdr.ioc_number, &ioc) == -1 || !ioc)
2302 if (ioc->shost_recovery || ioc->pci_error_recovery ||
2303 ioc->is_driver_loading)
2321 return _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
2361 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2364 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
2365 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
2366 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
2367 ioc->facts.FWVersion.Word & 0x000000FF);
2383 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2385 u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
2407 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2410 ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8);
2426 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2428 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.ChipName);
2445 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2448 le32_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word));
2465 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2468 le32_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word));
2485 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2487 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardName);
2503 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2505 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardAssembly);
2522 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2524 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardTracerNumber);
2544 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2546 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
2566 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2568 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
2587 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2589 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->facts.RequestCredit);
2608 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2611 (unsigned long long)ioc->sas_hba.sas_address);
2628 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2630 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->logging_level);
2637 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2643 ioc->logging_level = val;
2644 printk(MPT2SAS_INFO_FMT "logging_level=%08xh\n", ioc->name,
2645 ioc->logging_level);
2665 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2667 return snprintf(buf, PAGE_SIZE, "%d\n", ioc->fwfault_debug);
2674 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2680 ioc->fwfault_debug = val;
2681 printk(MPT2SAS_INFO_FMT "fwfault_debug=%d\n", ioc->name,
2682 ioc->fwfault_debug);
2690 * _ctl_ioc_reset_count_show - ioc reset count
2703 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2705 return snprintf(buf, PAGE_SIZE, "%08d\n", ioc->ioc_reset_count);
2725 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2727 if ((ioc->facts.IOCCapabilities &
2728 MPI2_IOCFACTS_CAPABILITY_MSI_X_INDEX) && ioc->msix_enable)
2729 reply_queue_count = ioc->reply_queue_count;
2758 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2762 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
2764 "registered\n", ioc->name, __func__);
2768 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2771 "registered\n", ioc->name, __func__);
2776 ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE];
2782 ioc->ring_buffer_sz = size;
2804 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2808 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
2810 "registered\n", ioc->name, __func__);
2814 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2817 "registered\n", ioc->name, __func__);
2821 if (ioc->ring_buffer_offset > ioc->ring_buffer_sz)
2824 size = ioc->ring_buffer_sz - ioc->ring_buffer_offset;
2826 request_data = ioc->diag_buffer[0] + ioc->ring_buffer_offset;
2836 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2842 ioc->ring_buffer_offset = val;
2864 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2866 if ((!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) ||
2867 ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2870 else if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2882 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2892 if ((ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) &&
2893 (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2895 ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2900 ioc->name);
2904 ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] = 0;
2905 _ctl_diag_register_2(ioc, &diag_register);
2908 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE])
2910 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2913 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2917 ioc->name);
2918 _ctl_send_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE, &issue_reset);
3039 struct MPT2SAS_ADAPTER *ioc;
3042 list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
3046 if (!ioc->diag_buffer[i])
3048 pci_free_consistent(ioc->pdev, ioc->diag_buffer_sz[i],
3049 ioc->diag_buffer[i], ioc->diag_buffer_dma[i]);
3050 ioc->diag_buffer[i] = NULL;
3051 ioc->diag_buffer_status[i] = 0;
3054 kfree(ioc->event_log);