Lines Matching defs:device
86 struct pqi_encryption_info *encryption_info, struct pqi_scsi_dev *device,
90 struct pqi_encryption_info *encryption_info, struct pqi_scsi_dev *device,
99 struct pqi_scsi_dev *device, u8 lun, unsigned long timeout_msecs);
150 "Disable device ID wildcards.");
237 static inline bool pqi_is_logical_device(struct pqi_scsi_dev *device)
239 return !device->is_physical_device;
425 static inline bool pqi_device_offline(struct pqi_scsi_dev *device)
427 return device->device_offline;
451 static inline void pqi_device_remove_start(struct pqi_scsi_dev *device)
453 device->in_remove = true;
456 static inline bool pqi_device_in_remove(struct pqi_scsi_dev *device)
458 return device->in_remove;
461 static inline void pqi_device_reset_start(struct pqi_scsi_dev *device, u8 lun)
463 device->in_reset[lun] = true;
466 static inline void pqi_device_reset_done(struct pqi_scsi_dev *device, u8 lun)
468 device->in_reset[lun] = false;
471 static inline bool pqi_device_in_reset(struct pqi_scsi_dev *device, u8 lun)
473 return device->in_reset[lun];
540 static inline bool pqi_is_io_high_priority(struct pqi_scsi_dev *device, struct scsi_cmnd *scmd)
547 if (device->ncq_prio_enable) {
826 struct pqi_scsi_dev *device,
840 bmic_device_index = CISS_GET_DRIVE_NUMBER(device->scsi3addr);
1306 * Tack the controller itself onto the end of the logical device list
1346 static inline void pqi_set_bus_target_lun(struct pqi_scsi_dev *device,
1349 device->bus = bus;
1350 device->target = target;
1351 device->lun = lun;
1354 static void pqi_assign_bus_target_lun(struct pqi_scsi_dev *device)
1362 scsi3addr = device->scsi3addr;
1366 /* The specified device is the controller. */
1367 pqi_set_bus_target_lun(device, PQI_HBA_BUS, 0, lunid & 0x3fff);
1368 device->target_lun_valid = true;
1372 if (pqi_is_logical_device(device)) {
1373 if (device->is_external_raid_device) {
1382 pqi_set_bus_target_lun(device, bus, target, lun);
1383 device->target_lun_valid = true;
1391 pqi_set_bus_target_lun(device, PQI_PHYSICAL_DEVICE_BUS, 0, 0);
1395 struct pqi_scsi_dev *device)
1405 rc = pqi_scsi_inquiry(ctrl_info, device->scsi3addr,
1415 device->raid_level = raid_level;
1419 struct pqi_scsi_dev *device, struct raid_map *raid_map)
1432 if (device->raid_level == SA_RAID_1) {
1437 } else if (device->raid_level == SA_RAID_TRIPLE) {
1442 } else if ((device->raid_level == SA_RAID_5 ||
1443 device->raid_level == SA_RAID_6) &&
1459 "logical device %08x%08x %s\n",
1460 *((u32 *)&device->scsi3addr),
1461 *((u32 *)&device->scsi3addr[4]), err_msg);
1467 struct pqi_scsi_dev *device)
1478 device->scsi3addr, raid_map, sizeof(*raid_map), 0, NULL);
1493 device->scsi3addr, raid_map, raid_map_size, 0, NULL);
1508 rc = pqi_validate_raid_map(ctrl_info, device, raid_map);
1512 device->raid_map = raid_map;
1523 struct pqi_scsi_dev *device)
1526 device->max_transfer_encrypted = ~0;
1530 switch (LV_GET_DRIVE_TYPE_MIX(device->scsi3addr)) {
1538 device->max_transfer_encrypted =
1542 device->max_transfer_encrypted =
1548 device->max_transfer_encrypted =
1556 struct pqi_scsi_dev *device)
1566 rc = pqi_scsi_inquiry(ctrl_info, device->scsi3addr,
1576 device->raid_bypass_configured =
1578 if (device->raid_bypass_configured &&
1580 pqi_get_raid_map(ctrl_info, device) == 0) {
1581 device->raid_bypass_enabled = true;
1582 if (get_unaligned_le16(&device->raid_map->flags) &
1584 pqi_set_max_transfer_encrypted(ctrl_info, device);
1596 struct pqi_scsi_dev *device)
1609 rc = pqi_scsi_inquiry(ctrl_info, device->scsi3addr,
1629 device->volume_status = volume_status;
1630 device->volume_offline = volume_offline;
1638 struct pqi_scsi_dev *device,
1645 rc = pqi_identify_physical_device(ctrl_info, device,
1648 device->queue_depth = PQI_PHYSICAL_DISK_DEFAULT_MAX_QUEUE_DEPTH;
1655 memcpy(device->vendor, &id_phys->model[0], sizeof(device->vendor));
1656 memcpy(device->model, &id_phys->model[8], sizeof(device->model));
1658 device->box_index = id_phys->box_index;
1659 device->phys_box_on_bus = id_phys->phys_box_on_bus;
1660 device->phy_connected_dev_type = id_phys->phy_connected_dev_type[0];
1661 device->queue_depth =
1663 device->active_path_index = id_phys->active_path_number;
1664 device->path_map = id_phys->redundant_path_present_map;
1665 memcpy(&device->box,
1667 sizeof(device->box));
1668 memcpy(&device->phys_connector,
1670 sizeof(device->phys_connector));
1671 device->bay = id_phys->phys_bay_in_box;
1672 device->lun_count = id_phys->multi_lun_device_lun_count;
1675 device->phy_id =
1676 id_phys->phy_to_phy_map[device->active_path_index];
1678 device->phy_id = 0xFF;
1680 device->ncq_prio_support =
1684 device->erase_in_progress = !!(get_unaligned_le16(&id_phys->extra_physical_drive_flags) & PQI_DEVICE_ERASE_IN_PROGRESS);
1690 struct pqi_scsi_dev *device)
1699 /* Send an inquiry to the device to see what it is. */
1700 rc = pqi_scsi_inquiry(ctrl_info, device->scsi3addr, 0, buffer, 64);
1707 device->devtype = buffer[0] & 0x1f;
1708 memcpy(device->vendor, &buffer[8], sizeof(device->vendor));
1709 memcpy(device->model, &buffer[16], sizeof(device->model));
1711 if (device->devtype == TYPE_DISK) {
1712 if (device->is_external_raid_device) {
1713 device->raid_level = SA_RAID_UNKNOWN;
1714 device->volume_status = CISS_LV_OK;
1715 device->volume_offline = false;
1717 pqi_get_raid_level(ctrl_info, device);
1718 pqi_get_raid_bypass_status(ctrl_info, device);
1719 pqi_get_volume_status(ctrl_info, device);
1739 static inline bool pqi_keep_device_offline(struct pqi_scsi_dev *device)
1741 return device->erase_in_progress;
1745 struct pqi_scsi_dev *device,
1750 if (device->is_expander_smp_device)
1753 if (pqi_is_logical_device(device))
1754 rc = pqi_get_logical_device_info(ctrl_info, device);
1756 rc = pqi_get_physical_device_info(ctrl_info, device, id_phys);
1762 struct pqi_scsi_dev *device,
1767 rc = pqi_get_device_info_phys_logical(ctrl_info, device, id_phys);
1769 if (rc == 0 && device->lun_count == 0)
1770 device->lun_count = 1;
1776 struct pqi_scsi_dev *device)
1783 switch (device->volume_status) {
1867 unknown_state_str, device->volume_status);
1875 device->bus, device->target, device->lun, status);
1889 struct pqi_scsi_dev *device)
1893 if (pqi_is_logical_device(device))
1894 rc = scsi_add_device(ctrl_info->scsi_host, device->bus,
1895 device->target, device->lun);
1897 rc = pqi_add_sas_device(ctrl_info->sas_host, device);
1904 static inline void pqi_remove_device(struct pqi_ctrl_info *ctrl_info, struct pqi_scsi_dev *device)
1909 for (lun = 0; lun < device->lun_count; lun++) {
1910 rc = pqi_device_wait_for_pending_io(ctrl_info, device, lun,
1914 "scsi %d:%d:%d:%d removing device with %d outstanding command(s)\n",
1915 ctrl_info->scsi_host->host_no, device->bus,
1916 device->target, lun,
1917 atomic_read(&device->scsi_cmds_outstanding[lun]));
1920 if (pqi_is_logical_device(device))
1921 scsi_remove_device(device->sdev);
1923 pqi_remove_sas_device(device);
1925 pqi_device_remove_start(device);
1928 /* Assumes the SCSI device list lock is held. */
1933 struct pqi_scsi_dev *device;
1935 list_for_each_entry(device, &ctrl_info->scsi_device_list, scsi_device_list_entry)
1936 if (device->bus == bus && device->target == target && device->lun == lun)
1937 return device;
1962 struct pqi_scsi_dev *device;
1964 list_for_each_entry(device, &ctrl_info->scsi_device_list, scsi_device_list_entry) {
1965 if (pqi_scsi3addr_equal(device_to_find->scsi3addr, device->scsi3addr)) {
1966 *matching_device = device;
1967 if (pqi_device_equal(device_to_find, device)) {
1979 static inline const char *pqi_device_type(struct pqi_scsi_dev *device)
1981 if (device->is_expander_smp_device)
1984 return scsi_device_type(device->devtype);
1990 char *action, struct pqi_scsi_dev *device)
1996 "%d:%d:", ctrl_info->scsi_host->host_no, device->bus);
1998 if (device->target_lun_valid)
2002 device->target,
2003 device->lun);
2009 if (pqi_is_logical_device(device))
2013 *((u32 *)&device->scsi3addr),
2014 *((u32 *)&device->scsi3addr[4]));
2019 get_unaligned_be64(&device->wwid[0]),
2020 get_unaligned_be64(&device->wwid[8]));
2024 pqi_device_type(device),
2025 device->vendor,
2026 device->model);
2028 if (pqi_is_logical_device(device)) {
2029 if (device->devtype == TYPE_DISK)
2033 device->raid_bypass_configured ? '+' : '-',
2034 device->raid_bypass_enabled ? '+' : '-',
2035 pqi_raid_level_to_string(device->raid_level));
2039 "AIO%c", device->aio_enabled ? '+' : '-');
2040 if (device->devtype == TYPE_DISK ||
2041 device->devtype == TYPE_ZBC)
2044 " qd=%-6d", device->queue_depth);
2067 /* Assumes the SCSI device list lock is held. */
2122 static inline void pqi_free_device(struct pqi_scsi_dev *device)
2124 if (device) {
2125 kfree(device->raid_map);
2126 kfree(device);
2131 * Called when exposing a new device to the OS fails in order to re-adjust
2132 * our internal SCSI device list to match the SCSI ML's view.
2136 struct pqi_scsi_dev *device)
2141 list_del(&device->scsi_device_list_entry);
2144 /* Allow the device structure to be freed later. */
2145 device->keep_device = false;
2148 static inline bool pqi_is_device_added(struct pqi_scsi_dev *device)
2150 if (device->is_expander_smp_device)
2151 return device->sas_port != NULL;
2153 return device->sdev != NULL;
2156 static inline void pqi_init_device_tmf_work(struct pqi_scsi_dev *device)
2161 for (lun = 0, tmf_work = device->tmf_work; lun < PQI_MAX_LUNS_PER_DEVICE; lun++, tmf_work++)
2165 static inline bool pqi_volume_rescan_needed(struct pqi_scsi_dev *device)
2167 if (pqi_device_in_remove(device))
2170 if (device->sdev == NULL)
2173 if (!scsi_device_online(device->sdev))
2176 return device->rescan;
2186 struct pqi_scsi_dev *device;
2195 * than updating the internal device list until after we release the
2202 list_for_each_entry(device, &ctrl_info->scsi_device_list, scsi_device_list_entry)
2203 device->device_gone = true;
2206 device = new_device_list[i];
2208 find_result = pqi_scsi_find_entry(ctrl_info, device,
2214 * The newly found device is already in the existing
2215 * device list.
2217 device->new_device = false;
2219 pqi_scsi_update_device(ctrl_info, matching_device, device);
2223 * The newly found device is NOT in the existing device
2226 device->new_device = true;
2230 * The original device has gone away and we need to add
2231 * the new device.
2233 device->new_device = true;
2239 list_for_each_entry_safe(device, next, &ctrl_info->scsi_device_list,
2241 if (device->device_gone) {
2242 list_del(&device->scsi_device_list_entry);
2243 list_add_tail(&device->delete_list_entry, &delete_list);
2249 device = new_device_list[i];
2250 if (!device->new_device)
2252 if (device->volume_offline)
2254 list_add_tail(&device->scsi_device_list_entry,
2256 list_add_tail(&device->add_list_entry, &add_list);
2257 /* To prevent this device structure from being freed later. */
2258 device->keep_device = true;
2259 pqi_init_device_tmf_work(device);
2270 list_for_each_entry_safe(device, next, &delete_list, delete_list_entry)
2271 if (pqi_is_device_added(device))
2272 pqi_device_remove_start(device);
2278 list_for_each_entry_safe(device, next, &delete_list, delete_list_entry) {
2279 if (device->volume_offline) {
2280 pqi_dev_info(ctrl_info, "offline", device);
2281 pqi_show_volume_status(ctrl_info, device);
2283 pqi_dev_info(ctrl_info, "removed", device);
2285 if (pqi_is_device_added(device))
2286 pqi_remove_device(ctrl_info, device);
2287 list_del(&device->delete_list_entry);
2288 pqi_free_device(device);
2292 * Notify the SML of any existing device changes such as;
2293 * queue depth, device size.
2295 list_for_each_entry(device, &ctrl_info->scsi_device_list, scsi_device_list_entry) {
2296 if (device->sdev && device->queue_depth != device->advertised_queue_depth) {
2297 device->advertised_queue_depth = device->queue_depth;
2298 scsi_change_queue_depth(device->sdev, device->advertised_queue_depth);
2300 if (pqi_volume_rescan_needed(device)) {
2301 device->rescan = false;
2303 scsi_rescan_device(device->sdev);
2311 list_for_each_entry_safe(device, next, &add_list, add_list_entry) {
2312 if (!pqi_is_device_added(device)) {
2313 rc = pqi_add_device(ctrl_info, device);
2315 pqi_dev_info(ctrl_info, "added", device);
2318 "scsi %d:%d:%d:%d addition failed, device not added\n",
2320 device->bus, device->target,
2321 device->lun);
2322 pqi_fixup_botched_add(ctrl_info, device);
2329 static inline bool pqi_is_supported_device(struct pqi_scsi_dev *device)
2337 if (device->device_type == SA_DEVICE_TYPE_CONTROLLER &&
2338 !pqi_is_hba_lunid(device->scsi3addr))
2358 static inline bool pqi_is_multipath_device(struct pqi_scsi_dev *device)
2360 if (pqi_is_logical_device(device))
2363 return (device->path_map & (device->path_map - 1)) != 0;
2366 static inline bool pqi_expose_device(struct pqi_scsi_dev *device)
2368 return !device->is_physical_device || !pqi_skip_device(device->scsi3addr);
2384 struct pqi_scsi_dev *device;
2393 "failed to allocate memory, device discovery stopped";
2455 device = kzalloc(sizeof(*device), GFP_KERNEL);
2456 if (!device) {
2462 list_add_tail(&device->new_device_list_entry,
2466 device = NULL;
2489 if (device)
2490 device = list_next_entry(device, new_device_list_entry);
2492 device = list_first_entry(&new_device_list_head,
2495 memcpy(device->scsi3addr, scsi3addr, sizeof(device->scsi3addr));
2496 device->is_physical_device = is_physical_device;
2498 device->device_type = phys_lun->device_type;
2499 if (device->device_type == SA_DEVICE_TYPE_EXPANDER_SMP)
2500 device->is_expander_smp_device = true;
2502 device->is_external_raid_device =
2506 if (!pqi_is_supported_device(device))
2509 /* Gather information about the device. */
2510 rc = pqi_get_device_info(ctrl_info, device, id_phys);
2517 if (device->is_physical_device)
2519 "obtaining device info failed, skipping physical device %016llx%016llx\n",
2524 "obtaining device info failed, skipping logical device %08x%08x\n",
2525 *((u32 *)&device->scsi3addr),
2526 *((u32 *)&device->scsi3addr[4]));
2532 if (pqi_keep_device_offline(device))
2535 pqi_assign_bus_target_lun(device);
2537 if (device->is_physical_device) {
2538 memcpy(device->wwid, phys_lun->wwid, sizeof(device->wwid));
2542 device->aio_enabled = true;
2543 device->aio_handle =
2547 memcpy(device->volume_id, log_lun->volume_id,
2548 sizeof(device->volume_id));
2551 device->sas_address = get_unaligned_be64(&device->wwid[0]);
2553 new_device_list[num_valid_devices++] = device;
2559 list_for_each_entry_safe(device, next, &new_device_list_head,
2561 if (device->keep_device)
2563 list_del(&device->new_device_list_entry);
2564 pqi_free_device(device);
2894 * parity entries inside the device's raid_map.
2896 * A device's RAID map is bounded by: number of RAID disks squared.
2898 * The devices RAID map size is checked during device
2965 struct pqi_scsi_dev *device, struct scsi_cmnd *scmd,
2980 rmd.raid_level = device->raid_level;
2988 raid_map = device->raid_map;
2994 if (device->raid_level == SA_RAID_1 ||
2995 device->raid_level == SA_RAID_TRIPLE) {
2999 group = device->next_bypass_group[rmd.map_index];
3003 device->next_bypass_group[rmd.map_index] = next_bypass_group;
3006 } else if ((device->raid_level == SA_RAID_5 ||
3007 device->raid_level == SA_RAID_6) &&
3035 if (rmd.data_length > device->max_transfer_encrypted)
3044 switch (device->raid_level) {
3048 encryption_info_ptr, device, &rmd);
3052 encryption_info_ptr, device, &rmd);
3127 struct pqi_scsi_dev *device;
3129 device = io_request->scmd->device->hostdata;
3130 device->raid_bypass_enabled = false;
3131 device->aio_enabled = false;
3137 struct pqi_scsi_dev *device;
3139 device = sdev->hostdata;
3140 if (device->device_offline)
3143 device->device_offline = true;
3147 path, ctrl_info->scsi_host->host_no, device->bus,
3148 device->target, device->lun);
3222 struct pqi_ctrl_info *ctrl_info = shost_to_hba(scmd->device->host);
3223 struct pqi_scsi_dev *device = scmd->device->hostdata;
3229 ctrl_info->scsi_host->host_no, device->bus, device->target, device->lun);
3230 pqi_take_device_offline(scmd->device, "RAID");
3237 sshdr.ascq, ctrl_info->scsi_host->host_no, device->bus, device->target, device->lun);
3262 struct pqi_scsi_dev *device;
3269 device = scmd->device->hostdata;
3294 if (pqi_is_multipath_device(device)) {
3295 pqi_device_remove_start(device);
3307 pqi_take_device_offline(scmd->device, "AIO");
3722 struct pqi_scsi_dev *device;
3726 list_for_each_entry(device, &ctrl_info->scsi_device_list, scsi_device_list_entry) {
3727 if (pqi_is_logical_device(device) && device->devtype == TYPE_DISK)
3728 device->rescan = true;
3737 struct pqi_scsi_dev *device;
3741 list_for_each_entry(device, &ctrl_info->scsi_device_list, scsi_device_list_entry)
3742 if (device->raid_bypass_enabled)
3743 device->raid_bypass_enabled = false;
4838 * Create OQ (Outbound Queue - device to host queue) to dedicate
4884 * Create IQ (Inbound Queue - host to device queue) for
4919 * Create IQ (Inbound Queue - host to device queue) for
4977 * Create OQ (Outbound Queue - device to host queue).
5127 struct device *dev;
5170 struct device *dev;
5530 struct pqi_scsi_dev *device, struct scsi_cmnd *scmd,
5554 memcpy(request->lun_number, device->scsi3addr, sizeof(request->lun_number));
5555 request->ml_device_lun_number = (u8)scmd->device->lun;
5614 struct pqi_scsi_dev *device, struct scsi_cmnd *scmd,
5619 io_high_prio = pqi_is_io_high_priority(device, scmd);
5621 return pqi_raid_submit_io(ctrl_info, device, scmd, queue_group, io_high_prio);
5627 struct pqi_scsi_dev *device;
5639 device = scmd->device->hostdata;
5640 if (pqi_device_offline(device) || pqi_device_in_remove(device))
5643 ctrl_info = shost_to_hba(scmd->device->host);
5667 struct pqi_scsi_dev *device, struct scsi_cmnd *scmd,
5672 io_high_prio = pqi_is_io_high_priority(device, scmd);
5674 return pqi_aio_submit_io(ctrl_info, scmd, device->aio_handle,
5708 put_unaligned_le64(scmd->device->lun << 8, &request->lun_number);
5757 struct pqi_encryption_info *encryption_info, struct pqi_scsi_dev *device,
5776 put_unaligned_le16(*(u16 *)device->scsi3addr & 0x3fff, &r1_request->volume_id);
5818 struct pqi_encryption_info *encryption_info, struct pqi_scsi_dev *device,
5835 if (device->raid_level == SA_RAID_5 || device->raid_level == SA_RAID_51)
5840 put_unaligned_le16(*(u16 *)device->scsi3addr & 0x3fff, &r56_request->volume_id);
5907 struct pqi_scsi_dev *device;
5910 if (!scmd->device) {
5915 device = scmd->device->hostdata;
5916 if (!device) {
5921 atomic_dec(&device->scsi_cmds_outstanding[scmd->device->lun]);
5935 struct pqi_scsi_dev *device;
5950 device = scmd->device->hostdata;
5953 if (device->raid_level != SA_RAID_5 && device->raid_level != SA_RAID_6)
5960 if ((device->raid_level == SA_RAID_5 && !ctrl_info->enable_r5_writes) ||
5961 (device->raid_level == SA_RAID_6 && !ctrl_info->enable_r6_writes))
5967 pqi_stream_data = &device->stream_data[i];
5996 pqi_stream_data = &device->stream_data[lru_index];
6007 struct pqi_scsi_dev *device;
6015 device = scmd->device->hostdata;
6017 if (!device) {
6023 lun = (u8)scmd->device->lun;
6025 atomic_inc(&device->scsi_cmds_outstanding[lun]);
6029 if (pqi_ctrl_offline(ctrl_info) || pqi_device_in_remove(device)) {
6035 if (pqi_ctrl_blocked(ctrl_info) || pqi_device_in_reset(device, lun)) {
6049 if (pqi_is_logical_device(device)) {
6051 if (device->raid_bypass_enabled &&
6054 rc = pqi_raid_bypass_submit_scsi_cmd(ctrl_info, device, scmd, queue_group);
6057 device->raid_bypass_cnt++;
6061 rc = pqi_raid_submit_scsi_cmd(ctrl_info, device, scmd, queue_group);
6063 if (device->aio_enabled)
6064 rc = pqi_aio_submit_scsi_cmd(ctrl_info, device, scmd, queue_group);
6066 rc = pqi_raid_submit_scsi_cmd(ctrl_info, device, scmd, queue_group);
6072 atomic_dec(&device->scsi_cmds_outstanding[lun]);
6167 struct pqi_scsi_dev *device, u8 lun)
6193 scsi_device = scmd->device->hostdata;
6194 if (scsi_device != device)
6197 if ((u8)scmd->device->lun != lun)
6216 struct pqi_scsi_dev *device, u8 lun, unsigned long timeout_msecs)
6226 while ((cmds_outstanding = atomic_read(&device->scsi_cmds_outstanding[lun])) > 0) {
6236 ctrl_info->scsi_host->host_no, device->bus, device->target,
6243 ctrl_info->scsi_host->host_no, device->bus, device->target,
6264 struct pqi_scsi_dev *device, u8 lun, struct completion *wait)
6286 cmds_outstanding = atomic_read(&device->scsi_cmds_outstanding[lun]);
6289 ctrl_info->scsi_host->host_no, device->bus, device->target, lun, wait_secs, cmds_outstanding);
6297 static int pqi_lun_reset(struct pqi_ctrl_info *ctrl_info, struct pqi_scsi_dev *device, u8 lun)
6315 memcpy(request->lun_number, device->scsi3addr,
6317 if (!pqi_is_logical_device(device) && ctrl_info->multi_lun_device_supported)
6326 rc = pqi_wait_for_lun_reset_completion(ctrl_info, device, lun, &wait);
6340 static int pqi_lun_reset_with_retries(struct pqi_ctrl_info *ctrl_info, struct pqi_scsi_dev *device, u8 lun)
6348 reset_rc = pqi_lun_reset(ctrl_info, device, lun);
6357 wait_rc = pqi_device_wait_for_pending_io(ctrl_info, device, lun, timeout_msecs);
6364 static int pqi_device_reset(struct pqi_ctrl_info *ctrl_info, struct pqi_scsi_dev *device, u8 lun)
6370 pqi_fail_io_queued_for_device(ctrl_info, device, lun);
6372 pqi_device_reset_start(device, lun);
6377 rc = pqi_lun_reset_with_retries(ctrl_info, device, lun);
6378 pqi_device_reset_done(device, lun);
6383 static int pqi_device_reset_handler(struct pqi_ctrl_info *ctrl_info, struct pqi_scsi_dev *device, u8 lun, struct scsi_cmnd *scmd, u8 scsi_opcode)
6391 ctrl_info->scsi_host->host_no, device->bus, device->target, lun, scmd, scsi_opcode);
6397 rc = pqi_device_reset(ctrl_info, device, lun);
6401 ctrl_info->scsi_host->host_no, device->bus, device->target, lun,
6413 struct pqi_scsi_dev *device;
6416 shost = scmd->device->host;
6418 device = scmd->device->hostdata;
6421 return pqi_device_reset_handler(ctrl_info, device, (u8)scmd->device->lun, scmd, scsi_opcode);
6432 pqi_device_reset_handler(tmf_work->ctrl_info, tmf_work->device, tmf_work->lun, scmd, tmf_work->scsi_opcode);
6439 struct pqi_scsi_dev *device;
6443 shost = scmd->device->host;
6445 device = scmd->device->hostdata;
6449 shost->host_no, device->bus, device->target, (int)scmd->device->lun, scmd);
6454 shost->host_no, device->bus, device->target, (int)scmd->device->lun, scmd);
6459 tmf_work = &device->tmf_work[scmd->device->lun];
6463 tmf_work->device = device;
6464 tmf_work->lun = (u8)scmd->device->lun;
6473 shost->host_no, device->bus, device->target, (int)scmd->device->lun, scmd);
6482 struct pqi_scsi_dev *device;
6495 device = pqi_find_device_by_sas_rphy(ctrl_info, rphy);
6496 if (device) {
6497 if (device->target_lun_valid) {
6498 device->ignore_device = true;
6500 device->target = sdev_id(sdev);
6501 device->lun = sdev->lun;
6502 device->target_lun_valid = true;
6506 device = pqi_find_scsi_dev(ctrl_info, sdev_channel(sdev),
6510 if (device) {
6511 sdev->hostdata = device;
6512 device->sdev = sdev;
6513 if (device->queue_depth) {
6514 device->advertised_queue_depth = device->queue_depth;
6516 device->advertised_queue_depth);
6518 if (pqi_is_logical_device(device)) {
6522 if (device->device_type == SA_DEVICE_TYPE_NVME)
6543 static inline bool pqi_is_tape_changer_device(struct pqi_scsi_dev *device)
6545 return device->devtype == TYPE_TAPE || device->devtype == TYPE_MEDIUM_CHANGER;
6551 struct pqi_scsi_dev *device;
6553 device = sdev->hostdata;
6554 device->devtype = sdev->type;
6556 if (pqi_is_tape_changer_device(device) && device->ignore_device) {
6558 device->ignore_device = false;
6567 struct pqi_scsi_dev *device;
6577 device = sdev->hostdata;
6578 if (!device) {
6583 device->lun_count--;
6584 if (device->lun_count > 0) {
6590 list_del(&device->scsi_device_list_entry);
6595 pqi_dev_info(ctrl_info, "removed", device);
6596 pqi_free_device(device);
6883 static ssize_t pqi_firmware_version_show(struct device *dev,
6895 static ssize_t pqi_driver_version_show(struct device *dev,
6901 static ssize_t pqi_serial_number_show(struct device *dev,
6913 static ssize_t pqi_model_show(struct device *dev,
6925 static ssize_t pqi_vendor_show(struct device *dev,
6937 static ssize_t pqi_host_rescan_store(struct device *dev,
6947 static ssize_t pqi_lockup_action_show(struct device *dev,
6967 static ssize_t pqi_lockup_action_store(struct device *dev,
6987 static ssize_t pqi_host_enable_stream_detection_show(struct device *dev,
6997 static ssize_t pqi_host_enable_stream_detection_store(struct device *dev,
7015 static ssize_t pqi_host_enable_r5_writes_show(struct device *dev,
7024 static ssize_t pqi_host_enable_r5_writes_store(struct device *dev,
7042 static ssize_t pqi_host_enable_r6_writes_show(struct device *dev,
7051 static ssize_t pqi_host_enable_r6_writes_store(struct device *dev,
7101 static ssize_t pqi_unique_id_show(struct device *dev,
7106 struct pqi_scsi_dev *device;
7118 device = sdev->hostdata;
7119 if (!device) {
7124 if (device->is_physical_device)
7125 memcpy(unique_id, device->wwid, sizeof(device->wwid));
7127 memcpy(unique_id, device->volume_id, sizeof(device->volume_id));
7140 static ssize_t pqi_lunid_show(struct device *dev,
7145 struct pqi_scsi_dev *device;
7157 device = sdev->hostdata;
7158 if (!device) {
7163 memcpy(lunid, device->scsi3addr, sizeof(lunid));
7172 static ssize_t pqi_path_info_show(struct device *dev,
7177 struct pqi_scsi_dev *device;
7195 device = sdev->hostdata;
7196 if (!device) {
7201 bay = device->bay;
7204 if (i == device->active_path_index)
7206 else if (device->path_map & path_map_index)
7215 device->bus, device->target,
7216 device->lun,
7217 scsi_device_type(device->devtype));
7219 if (device->devtype == TYPE_RAID ||
7220 pqi_is_logical_device(device))
7223 memcpy(&phys_connector, &device->phys_connector[i],
7234 box = device->box[i];
7240 if ((device->devtype == TYPE_DISK ||
7241 device->devtype == TYPE_ZBC) &&
7242 pqi_expose_device(device))
7258 static ssize_t pqi_sas_address_show(struct device *dev,
7263 struct pqi_scsi_dev *device;
7275 device = sdev->hostdata;
7276 if (!device) {
7281 sas_address = device->sas_address;
7288 static ssize_t pqi_ssd_smart_path_enabled_show(struct device *dev,
7293 struct pqi_scsi_dev *device;
7304 device = sdev->hostdata;
7305 if (!device) {
7310 buffer[0] = device->raid_bypass_enabled ? '1' : '0';
7319 static ssize_t pqi_raid_level_show(struct device *dev,
7324 struct pqi_scsi_dev *device;
7336 device = sdev->hostdata;
7337 if (!device) {
7342 if (pqi_is_logical_device(device) && device->devtype == TYPE_DISK)
7343 raid_level = pqi_raid_level_to_string(device->raid_level);
7352 static ssize_t pqi_raid_bypass_cnt_show(struct device *dev,
7357 struct pqi_scsi_dev *device;
7369 device = sdev->hostdata;
7370 if (!device) {
7375 raid_bypass_cnt = device->raid_bypass_cnt;
7382 static ssize_t pqi_sas_ncq_prio_enable_show(struct device *dev,
7387 struct pqi_scsi_dev *device;
7399 device = sdev->hostdata;
7400 if (!device) {
7406 device->ncq_prio_enable);
7412 static ssize_t pqi_sas_ncq_prio_enable_store(struct device *dev,
7418 struct pqi_scsi_dev *device;
7430 device = sdev->hostdata;
7432 if (!device) {
7437 if (!device->ncq_prio_support) {
7442 device->ncq_prio_enable = ncq_prio_enable;
7449 static ssize_t pqi_numa_node_show(struct device *dev,
8337 "obtaining device capability failed\n");
8621 "failed to enable PCI device\n");
8815 struct device *dev;
8886 struct device *dev;
8913 struct device *dev;
9001 sdev = scmd->device;
9129 "controller not probed because device ID wildcards are disabled\n");
9135 "controller device ID matched using wildcards\n");
9307 static int pqi_suspend_or_freeze(struct device *dev, bool suspend)
9340 static __maybe_unused int pqi_suspend(struct device *dev)
9345 static int pqi_resume_or_restore(struct device *dev)
9368 static int pqi_freeze(struct device *dev)
9373 static int pqi_thaw(struct device *dev)
9397 static int pqi_poweroff(struct device *dev)