Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge patch series "mpt3sas: Improve device readiness handling and event recovery"
Ranjan Kumar <ranjan.kumar@broadcom.com> says:
This patch series enhances the mpt3sas driver’s device bring-up,
readiness detection, and event recovery mechanisms to improve
robustness in environments with slow-responding or transient SAS/PCIe
devices.
The series introduces optional control over issuing TEST UNIT READY
(TUR) commands during device unblocking, configurable retry limits,
and a mechanism to requeue firmware topology events when devices are
temporarily busy. Together, these updates reduce discovery failures
and improve recovery reliability following firmware or link events.
Link: https://patch.msgid.link/20251113153712.31850-1-ranjan.kumar@broadcom.com
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+1313
-37
+9
-5
drivers/scsi/mpt3sas/mpt3sas_base.c
+9
-5
drivers/scsi/mpt3sas/mpt3sas_base.c
···
843
843
/* initialize fault polling */
844
844
845
845
INIT_DELAYED_WORK(&ioc->fault_reset_work, _base_fault_reset_work);
846
-
snprintf(ioc->fault_reset_work_q_name,
846
+
scnprintf(ioc->fault_reset_work_q_name,
847
847
sizeof(ioc->fault_reset_work_q_name), "poll_%s%d_status",
848
848
ioc->driver_name, ioc->id);
849
849
ioc->fault_reset_work_q = alloc_ordered_workqueue(
···
1564
1564
int i;
1565
1565
u16 ctl_smid = ioc->scsiio_depth - INTERNAL_SCSIIO_CMDS_COUNT + 1;
1566
1566
u8 cb_idx = 0xFF;
1567
+
u16 discovery_smid =
1568
+
ioc->shost->can_queue + INTERNAL_SCSIIO_FOR_DISCOVERY;
1567
1569
1568
1570
if (smid < ioc->hi_priority_smid) {
1569
1571
struct scsiio_tracker *st;
···
1574
1572
st = _get_st_from_smid(ioc, smid);
1575
1573
if (st)
1576
1574
cb_idx = st->cb_idx;
1577
-
} else if (smid == ctl_smid)
1575
+
} else if (smid < discovery_smid)
1578
1576
cb_idx = ioc->ctl_cb_idx;
1577
+
else
1578
+
cb_idx = ioc->scsih_cb_idx;
1579
1579
} else if (smid < ioc->internal_smid) {
1580
1580
i = smid - ioc->hi_priority_smid;
1581
1581
cb_idx = ioc->hpr_lookup[i].cb_idx;
···
3178
3174
3179
3175
if (index >= ioc->iopoll_q_start_index) {
3180
3176
qid = index - ioc->iopoll_q_start_index;
3181
-
snprintf(reply_q->name, MPT_NAME_LENGTH, "%s%d-mq-poll%d",
3177
+
scnprintf(reply_q->name, MPT_NAME_LENGTH, "%s%d-mq-poll%d",
3182
3178
ioc->driver_name, ioc->id, qid);
3183
3179
reply_q->is_iouring_poll_q = 1;
3184
3180
ioc->io_uring_poll_queues[qid].reply_q = reply_q;
···
3187
3183
3188
3184
3189
3185
if (ioc->msix_enable)
3190
-
snprintf(reply_q->name, MPT_NAME_LENGTH, "%s%d-msix%d",
3186
+
scnprintf(reply_q->name, MPT_NAME_LENGTH, "%s%d-msix%d",
3191
3187
ioc->driver_name, ioc->id, index);
3192
3188
else
3193
-
snprintf(reply_q->name, MPT_NAME_LENGTH, "%s%d",
3189
+
scnprintf(reply_q->name, MPT_NAME_LENGTH, "%s%d",
3194
3190
ioc->driver_name, ioc->id);
3195
3191
r = request_irq(pci_irq_vector(pdev, index), _base_interrupt,
3196
3192
IRQF_SHARED, reply_q->name, reply_q);
+4
drivers/scsi/mpt3sas/mpt3sas_base.h
+4
drivers/scsi/mpt3sas/mpt3sas_base.h
···
147
147
#define INTERNAL_CMDS_COUNT 10 /* reserved cmds */
148
148
/* reserved for issuing internally framed scsi io cmds */
149
149
#define INTERNAL_SCSIIO_CMDS_COUNT 3
150
+
#define INTERNAL_SCSIIO_FOR_DISCOVERY 2
150
151
151
152
#define MPI3_HIM_MASK 0xFFFFFFFF /* mask every bit*/
152
153
···
481
480
u32 flags;
482
481
u8 configured_lun;
483
482
u8 block;
483
+
u8 deleted;
484
484
u8 tlr_snoop_check;
485
485
u8 ignore_delay_remove;
486
486
/* Iopriority Command Handling */
···
579
577
u8 chassis_slot;
580
578
u8 is_chassis_slot_valid;
581
579
u8 connector_name[5];
580
+
u8 ssd_device;
582
581
struct kref refcount;
582
+
583
583
u8 port_type;
584
584
struct hba_port *port;
585
585
struct sas_rphy *rphy;
+1300
-32
drivers/scsi/mpt3sas/mpt3sas_scsih.c
+1300
-32
drivers/scsi/mpt3sas/mpt3sas_scsih.c
···
61
61
62
62
#define PCIE_CHANNEL 2
63
63
64
+
#define MPT3_MAX_LUNS (255)
65
+
64
66
/* forward proto's */
65
67
static void _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
66
68
struct _sas_node *sas_expander);
···
72
70
struct _sas_device *sas_device);
73
71
static int _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle,
74
72
u8 retry_count, u8 is_pd);
75
-
static int _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle);
73
+
static int _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle,
74
+
u8 retry_count);
76
75
static void _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc,
77
76
struct _pcie_device *pcie_device);
78
77
static void
79
78
_scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle);
80
79
static u8 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid);
81
80
static void _scsih_complete_devices_scanning(struct MPT3SAS_ADAPTER *ioc);
81
+
static enum device_responsive_state
82
+
_scsih_wait_for_target_to_become_ready(struct MPT3SAS_ADAPTER *ioc, u16 handle,
83
+
u8 retry_count, u8 is_pd, u8 tr_timeout, u8 tr_method);
84
+
static enum device_responsive_state
85
+
_scsih_ata_pass_thru_idd(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 *is_ssd_device,
86
+
u8 tr_timeout, u8 tr_method);
87
+
static enum device_responsive_state
88
+
_scsih_wait_for_device_to_become_ready(struct MPT3SAS_ADAPTER *ioc, u16 handle,
89
+
u8 retry_count, u8 is_pd, int lun, u8 tr_timeout, u8 tr_method);
90
+
static void _firmware_event_work_delayed(struct work_struct *work);
82
91
83
92
/* global parameters */
84
93
LIST_HEAD(mpt3sas_ioc_list);
···
172
159
MODULE_PARM_DESC(enable_sdev_max_qd,
173
160
"Enable sdev max qd as can_queue, def=disabled(0)");
174
161
162
+
/*
163
+
* permit overriding the SCSI command issuing capability of
164
+
* the driver to bring the drive to READY state
165
+
*/
166
+
static int issue_scsi_cmd_to_bringup_drive = 1;
167
+
module_param(issue_scsi_cmd_to_bringup_drive, int, 0444);
168
+
MODULE_PARM_DESC(issue_scsi_cmd_to_bringup_drive, "allow host driver to\n"
169
+
"issue SCSI commands to bring the drive to READY state, default=1 ");
170
+
175
171
static int multipath_on_hba = -1;
176
172
module_param(multipath_on_hba, int, 0);
177
173
MODULE_PARM_DESC(multipath_on_hba,
···
195
173
MODULE_PARM_DESC(host_tagset_enable,
196
174
"Shared host tagset enable/disable Default: enable(1)");
197
175
176
+
static int command_retry_count = 144;
177
+
module_param(command_retry_count, int, 0444);
178
+
MODULE_PARM_DESC(command_retry_count, "Device discovery TUR command retry\n"
179
+
"count: (default=144)");
180
+
198
181
/* raid transport support */
199
182
static struct raid_template *mpt3sas_raid_template;
200
183
static struct raid_template *mpt2sas_raid_template;
201
184
185
+
/**
186
+
* enum device_responsive_state - responsive state
187
+
* @DEVICE_READY: device is ready to be added
188
+
* @DEVICE_RETRY: device can be retried later
189
+
* @DEVICE_RETRY_UA: retry unit attentions
190
+
* @DEVICE_START_UNIT: requires start unit
191
+
* @DEVICE_STOP_UNIT: requires stop unit
192
+
* @DEVICE_ERROR: device reported some fatal error
193
+
*
194
+
*/
195
+
enum device_responsive_state {
196
+
DEVICE_READY,
197
+
DEVICE_RETRY,
198
+
DEVICE_RETRY_UA,
199
+
DEVICE_START_UNIT,
200
+
DEVICE_STOP_UNIT,
201
+
DEVICE_ERROR,
202
+
};
202
203
203
204
/**
204
205
* struct sense_info - common structure for obtaining sense keys
···
250
205
251
206
/**
252
207
* struct fw_event_work - firmware event struct
208
+
* @retries: retry count for processing the event
209
+
* @delayed_work_active: flag indicating if delayed work is active
210
+
* @delayed_work: delayed work item for deferred event handling
253
211
* @list: link list framework
254
212
* @work: work object (ioc->fault_reset_work_q)
255
213
* @ioc: per adapter object
···
267
219
* This object stored on ioc->fw_event_list.
268
220
*/
269
221
struct fw_event_work {
222
+
u8 *retries;
223
+
u8 delayed_work_active;
224
+
struct delayed_work delayed_work;
270
225
struct list_head list;
271
226
struct work_struct work;
272
227
···
281
230
u16 event;
282
231
struct kref refcount;
283
232
char event_data[] __aligned(4);
233
+
284
234
};
285
235
286
236
static void fw_event_work_free(struct kref *r)
287
237
{
288
-
kfree(container_of(r, struct fw_event_work, refcount));
238
+
struct fw_event_work *fw_work;
239
+
240
+
fw_work = container_of(r, struct fw_event_work, refcount);
241
+
kfree(fw_work->retries);
242
+
kfree(fw_work);
289
243
}
290
244
291
245
static void fw_event_work_get(struct fw_event_work *fw_work)
···
1011
955
sas_device_put(sas_device);
1012
956
}
1013
957
spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
958
+
1014
959
}
1015
960
1016
961
/**
···
2585
2528
char *r_level = "";
2586
2529
u16 handle, volume_handle = 0;
2587
2530
u64 volume_wwid = 0;
2531
+
enum device_responsive_state retval;
2532
+
u8 count = 0;
2588
2533
2589
2534
qdepth = 1;
2590
2535
sas_device_priv_data = sdev->hostdata;
···
2745
2686
2746
2687
pcie_device_put(pcie_device);
2747
2688
spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2689
+
2748
2690
mpt3sas_scsih_change_queue_depth(sdev, qdepth);
2749
2691
lim->virt_boundary_mask = ioc->page_size - 1;
2750
2692
return 0;
···
2797
2737
sas_device_put(sas_device);
2798
2738
spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2799
2739
2800
-
if (!ssp_target)
2740
+
if (!ssp_target) {
2801
2741
_scsih_display_sata_capabilities(ioc, handle, sdev);
2742
+
2743
+
do {
2744
+
retval = _scsih_ata_pass_thru_idd(ioc, handle,
2745
+
&sas_device->ssd_device, 30, 0);
2746
+
} while ((retval == DEVICE_RETRY || retval == DEVICE_RETRY_UA)
2747
+
&& count++ < 3);
2748
+
}
2802
2749
2803
2750
2804
2751
mpt3sas_scsih_change_queue_depth(sdev, qdepth);
···
3662
3595
spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3663
3596
}
3664
3597
3598
+
/**
3599
+
* _scsih_fw_event_requeue - requeue an event
3600
+
* @ioc: per adapter object
3601
+
* @fw_event: object describing the event
3602
+
* @delay: time in milliseconds to wait before retrying the event
3603
+
*
3604
+
* Context: This function will acquire ioc->fw_event_lock.
3605
+
*
3606
+
* Return nothing.
3607
+
*/
3608
+
static void
3609
+
_scsih_fw_event_requeue(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work
3610
+
*fw_event, unsigned long delay)
3611
+
{
3612
+
unsigned long flags;
3613
+
3614
+
if (ioc->firmware_event_thread == NULL)
3615
+
return;
3616
+
3617
+
spin_lock_irqsave(&ioc->fw_event_lock, flags);
3618
+
fw_event_work_get(fw_event);
3619
+
list_add_tail(&fw_event->list, &ioc->fw_event_list);
3620
+
if (!fw_event->delayed_work_active) {
3621
+
fw_event->delayed_work_active = 1;
3622
+
INIT_DELAYED_WORK(&fw_event->delayed_work,
3623
+
_firmware_event_work_delayed);
3624
+
}
3625
+
queue_delayed_work(ioc->firmware_event_thread, &fw_event->delayed_work,
3626
+
msecs_to_jiffies(delay));
3627
+
spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3628
+
}
3665
3629
3666
3630
/**
3667
3631
* mpt3sas_send_trigger_data_event - send event for processing trigger data
···
3923
3825
/**
3924
3826
* _scsih_ublock_io_all_device - unblock every device
3925
3827
* @ioc: per adapter object
3828
+
* @no_turs: flag to disable TEST UNIT READY checks during device unblocking
3926
3829
*
3927
3830
* change the device state from block to running
3928
3831
*/
3929
3832
static void
3930
-
_scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc)
3833
+
_scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc, u8 no_turs)
3931
3834
{
3932
3835
struct MPT3SAS_DEVICE *sas_device_priv_data;
3933
3836
struct scsi_device *sdev;
3837
+
struct MPT3SAS_TARGET *sas_target;
3838
+
enum device_responsive_state rc;
3839
+
struct _sas_device *sas_device = NULL;
3840
+
struct _pcie_device *pcie_device = NULL;
3841
+
int count = 0;
3842
+
u8 tr_method = 0;
3843
+
u8 tr_timeout = 30;
3844
+
3934
3845
3935
3846
shost_for_each_device(sdev, ioc->shost) {
3936
3847
sas_device_priv_data = sdev->hostdata;
3937
3848
if (!sas_device_priv_data)
3938
3849
continue;
3850
+
3851
+
sas_target = sas_device_priv_data->sas_target;
3852
+
if (!sas_target || sas_target->deleted)
3853
+
continue;
3854
+
3939
3855
if (!sas_device_priv_data->block)
3940
3856
continue;
3941
3857
3942
-
dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
3943
-
"device_running, handle(0x%04x)\n",
3944
-
sas_device_priv_data->sas_target->handle));
3858
+
if ((no_turs) || (!issue_scsi_cmd_to_bringup_drive)) {
3859
+
sdev_printk(KERN_WARNING, sdev, "device_unblocked handle(0x%04x)\n",
3860
+
sas_device_priv_data->sas_target->handle);
3861
+
_scsih_internal_device_unblock(sdev, sas_device_priv_data);
3862
+
continue;
3863
+
}
3864
+
3865
+
do {
3866
+
pcie_device = mpt3sas_get_pdev_by_handle(ioc, sas_target->handle);
3867
+
if (pcie_device && (!ioc->tm_custom_handling) &&
3868
+
(!(mpt3sas_scsih_is_pcie_scsi_device(pcie_device->device_info)))) {
3869
+
tr_timeout = pcie_device->reset_timeout;
3870
+
tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE;
3871
+
}
3872
+
rc = _scsih_wait_for_device_to_become_ready(ioc,
3873
+
sas_target->handle, 0, (sas_target->flags &
3874
+
MPT_TARGET_FLAGS_RAID_COMPONENT), sdev->lun, tr_timeout, tr_method);
3875
+
if (rc == DEVICE_RETRY || rc == DEVICE_START_UNIT ||
3876
+
rc == DEVICE_STOP_UNIT || rc == DEVICE_RETRY_UA)
3877
+
ssleep(1);
3878
+
if (pcie_device)
3879
+
pcie_device_put(pcie_device);
3880
+
} while ((rc == DEVICE_RETRY || rc == DEVICE_START_UNIT ||
3881
+
rc == DEVICE_STOP_UNIT || rc == DEVICE_RETRY_UA)
3882
+
&& count++ < command_retry_count);
3883
+
sas_device_priv_data->block = 0;
3884
+
if (rc != DEVICE_READY)
3885
+
sas_device_priv_data->deleted = 1;
3886
+
3945
3887
_scsih_internal_device_unblock(sdev, sas_device_priv_data);
3888
+
3889
+
if (rc != DEVICE_READY) {
3890
+
sdev_printk(KERN_WARNING, sdev, "%s: device_offlined,\n"
3891
+
"handle(0x%04x)\n",
3892
+
__func__, sas_device_priv_data->sas_target->handle);
3893
+
scsi_device_set_state(sdev, SDEV_OFFLINE);
3894
+
sas_device = mpt3sas_get_sdev_by_addr(ioc,
3895
+
sas_device_priv_data->sas_target->sas_address,
3896
+
sas_device_priv_data->sas_target->port);
3897
+
if (sas_device) {
3898
+
_scsih_display_enclosure_chassis_info(NULL, sas_device, sdev, NULL);
3899
+
sas_device_put(sas_device);
3900
+
} else {
3901
+
pcie_device = mpt3sas_get_pdev_by_wwid(ioc,
3902
+
sas_device_priv_data->sas_target->sas_address);
3903
+
if (pcie_device) {
3904
+
if (pcie_device->enclosure_handle != 0)
3905
+
sdev_printk(KERN_INFO, sdev, "enclosure logical id\n"
3906
+
"(0x%016llx), slot(%d)\n", (unsigned long long)
3907
+
pcie_device->enclosure_logical_id,
3908
+
pcie_device->slot);
3909
+
if (pcie_device->connector_name[0] != '\0')
3910
+
sdev_printk(KERN_INFO, sdev, "enclosure level(0x%04x),\n"
3911
+
" connector name( %s)\n",
3912
+
pcie_device->enclosure_level,
3913
+
pcie_device->connector_name);
3914
+
pcie_device_put(pcie_device);
3915
+
}
3916
+
}
3917
+
} else
3918
+
sdev_printk(KERN_WARNING, sdev, "device_unblocked,\n"
3919
+
"handle(0x%04x)\n",
3920
+
sas_device_priv_data->sas_target->handle);
3946
3921
}
3947
3922
}
3948
3923
3924
+
/**
3925
+
* _scsih_ublock_io_device_wait - unblock IO for target
3926
+
* @ioc: per adapter object
3927
+
* @sas_address: sas address
3928
+
* @port: hba port entry
3929
+
*
3930
+
* make sure device is reponsponding before unblocking
3931
+
*/
3932
+
static void
3933
+
_scsih_ublock_io_device_wait(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
3934
+
struct hba_port *port)
3935
+
{
3936
+
struct MPT3SAS_DEVICE *sas_device_priv_data;
3937
+
struct MPT3SAS_TARGET *sas_target;
3938
+
enum device_responsive_state rc;
3939
+
struct scsi_device *sdev;
3940
+
int host_reset_completion_count;
3941
+
struct _sas_device *sas_device;
3942
+
struct _pcie_device *pcie_device;
3943
+
u8 tr_timeout = 30;
3944
+
u8 tr_method = 0;
3945
+
int count = 0;
3946
+
3947
+
/* moving devices from SDEV_OFFLINE to SDEV_BLOCK */
3948
+
shost_for_each_device(sdev, ioc->shost) {
3949
+
sas_device_priv_data = sdev->hostdata;
3950
+
if (!sas_device_priv_data)
3951
+
continue;
3952
+
sas_target = sas_device_priv_data->sas_target;
3953
+
if (!sas_target)
3954
+
continue;
3955
+
if (sas_target->sas_address != sas_address ||
3956
+
sas_target->port != port)
3957
+
continue;
3958
+
if (sdev->sdev_state == SDEV_OFFLINE) {
3959
+
sas_device_priv_data->block = 1;
3960
+
sas_device_priv_data->deleted = 0;
3961
+
scsi_device_set_state(sdev, SDEV_RUNNING);
3962
+
scsi_internal_device_block_nowait(sdev);
3963
+
}
3964
+
}
3965
+
3966
+
/* moving devices from SDEV_BLOCK to SDEV_RUNNING state */
3967
+
shost_for_each_device(sdev, ioc->shost) {
3968
+
sas_device_priv_data = sdev->hostdata;
3969
+
if (!sas_device_priv_data)
3970
+
continue;
3971
+
sas_target = sas_device_priv_data->sas_target;
3972
+
if (!sas_target)
3973
+
continue;
3974
+
if (sas_target->sas_address != sas_address ||
3975
+
sas_target->port != port)
3976
+
continue;
3977
+
if (!sas_device_priv_data->block)
3978
+
continue;
3979
+
3980
+
do {
3981
+
host_reset_completion_count = 0;
3982
+
pcie_device = mpt3sas_get_pdev_by_handle(ioc, sas_target->handle);
3983
+
if (pcie_device && (!ioc->tm_custom_handling) &&
3984
+
(!(mpt3sas_scsih_is_pcie_scsi_device(pcie_device->device_info)))) {
3985
+
tr_timeout = pcie_device->reset_timeout;
3986
+
tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE;
3987
+
}
3988
+
rc = _scsih_wait_for_device_to_become_ready(ioc,
3989
+
sas_target->handle, 0, (sas_target->flags &
3990
+
MPT_TARGET_FLAGS_RAID_COMPONENT), sdev->lun, tr_timeout, tr_method);
3991
+
if (rc == DEVICE_RETRY || rc == DEVICE_START_UNIT ||
3992
+
rc == DEVICE_STOP_UNIT || rc == DEVICE_RETRY_UA) {
3993
+
do {
3994
+
msleep(500);
3995
+
host_reset_completion_count++;
3996
+
} while (rc == DEVICE_RETRY &&
3997
+
ioc->shost_recovery);
3998
+
if (host_reset_completion_count > 1) {
3999
+
rc = _scsih_wait_for_device_to_become_ready(ioc,
4000
+
sas_target->handle, 0, (sas_target->flags &
4001
+
MPT_TARGET_FLAGS_RAID_COMPONENT), sdev->lun,
4002
+
tr_timeout, tr_method);
4003
+
if (rc == DEVICE_RETRY || rc == DEVICE_START_UNIT ||
4004
+
rc == DEVICE_STOP_UNIT || rc == DEVICE_RETRY_UA)
4005
+
msleep(500);
4006
+
}
4007
+
continue;
4008
+
}
4009
+
if (pcie_device)
4010
+
pcie_device_put(pcie_device);
4011
+
} while ((rc == DEVICE_RETRY || rc == DEVICE_START_UNIT ||
4012
+
rc == DEVICE_STOP_UNIT || rc == DEVICE_RETRY_UA)
4013
+
&& count++ <= command_retry_count);
4014
+
4015
+
sas_device_priv_data->block = 0;
4016
+
if (rc != DEVICE_READY)
4017
+
sas_device_priv_data->deleted = 1;
4018
+
scsi_internal_device_unblock_nowait(sdev, SDEV_RUNNING);
4019
+
4020
+
if (rc != DEVICE_READY) {
4021
+
sdev_printk(KERN_WARNING, sdev,
4022
+
"%s: device_offlined, handle(0x%04x)\n",
4023
+
__func__, sas_device_priv_data->sas_target->handle);
4024
+
4025
+
sas_device = mpt3sas_get_sdev_by_handle(ioc,
4026
+
sas_device_priv_data->sas_target->handle);
4027
+
if (sas_device) {
4028
+
_scsih_display_enclosure_chassis_info(NULL, sas_device, sdev, NULL);
4029
+
sas_device_put(sas_device);
4030
+
} else {
4031
+
pcie_device = mpt3sas_get_pdev_by_handle(ioc,
4032
+
sas_device_priv_data->sas_target->handle);
4033
+
if (pcie_device) {
4034
+
if (pcie_device->enclosure_handle != 0)
4035
+
sdev_printk(KERN_INFO, sdev,
4036
+
"device_offlined, enclosure logical id(0x%016llx),\n"
4037
+
" slot(%d)\n", (unsigned long long)
4038
+
pcie_device->enclosure_logical_id,
4039
+
pcie_device->slot);
4040
+
if (pcie_device->connector_name[0] != '\0')
4041
+
sdev_printk(KERN_WARNING, sdev,
4042
+
"device_offlined, enclosure level(0x%04x),\n"
4043
+
"connector name( %s)\n",
4044
+
pcie_device->enclosure_level,
4045
+
pcie_device->connector_name);
4046
+
pcie_device_put(pcie_device);
4047
+
}
4048
+
}
4049
+
scsi_device_set_state(sdev, SDEV_OFFLINE);
4050
+
} else {
4051
+
sdev_printk(KERN_WARNING, sdev,
4052
+
"device_unblocked, handle(0x%04x)\n",
4053
+
sas_device_priv_data->sas_target->handle);
4054
+
}
4055
+
}
4056
+
}
3949
4057
3950
4058
/**
3951
4059
* _scsih_ublock_io_device - prepare device to be deleted
···
7412
7108
return 1;
7413
7109
}
7414
7110
7111
+
/**
7112
+
* _scsi_send_scsi_io - send internal SCSI_IO to target
7113
+
* @ioc: per adapter object
7114
+
* @transfer_packet: packet describing the transfer
7115
+
* @tr_timeout: Target Reset Timeout
7116
+
* @tr_method: Target Reset Method
7117
+
* Context: user
7118
+
*
7119
+
* Returns 0 for success, non-zero for failure.
7120
+
*/
7121
+
static int
7122
+
_scsi_send_scsi_io(struct MPT3SAS_ADAPTER *ioc, struct _scsi_io_transfer
7123
+
*transfer_packet, u8 tr_timeout, u8 tr_method)
7124
+
{
7125
+
Mpi2SCSIIOReply_t *mpi_reply;
7126
+
Mpi2SCSIIORequest_t *mpi_request;
7127
+
u16 smid;
7128
+
u8 issue_reset = 0;
7129
+
int rc;
7130
+
void *priv_sense;
7131
+
u32 mpi_control;
7132
+
void *psge;
7133
+
dma_addr_t data_out_dma = 0;
7134
+
dma_addr_t data_in_dma = 0;
7135
+
size_t data_in_sz = 0;
7136
+
size_t data_out_sz = 0;
7137
+
u16 handle;
7138
+
u8 retry_count = 0, host_reset_count = 0;
7139
+
int tm_return_code;
7415
7140
7141
+
if (ioc->pci_error_recovery) {
7142
+
pr_info("%s: pci error recovery in progress!\n", __func__);
7143
+
return -EFAULT;
7144
+
}
7416
7145
7146
+
if (ioc->shost_recovery) {
7147
+
pr_info("%s: host recovery in progress!\n", __func__);
7148
+
return -EAGAIN;
7149
+
}
7417
7150
7418
-
#define MPT3_MAX_LUNS (255)
7151
+
handle = transfer_packet->handle;
7152
+
if (handle == MPT3SAS_INVALID_DEVICE_HANDLE) {
7153
+
pr_info("%s: no device!\n", __func__);
7154
+
return -EFAULT;
7155
+
}
7156
+
7157
+
mutex_lock(&ioc->scsih_cmds.mutex);
7158
+
7159
+
if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
7160
+
pr_err("%s: scsih_cmd in use\n", __func__);
7161
+
rc = -EAGAIN;
7162
+
goto out;
7163
+
}
7164
+
7165
+
retry_loop:
7166
+
if (test_bit(handle, ioc->device_remove_in_progress)) {
7167
+
pr_info("%s: device removal in progress\n", __func__);
7168
+
rc = -EFAULT;
7169
+
goto out;
7170
+
}
7171
+
7172
+
ioc->scsih_cmds.status = MPT3_CMD_PENDING;
7173
+
7174
+
rc = mpt3sas_wait_for_ioc(ioc, 10);
7175
+
if (rc)
7176
+
goto out;
7177
+
7178
+
/* Use second reserved smid for discovery related IOs */
7179
+
smid = ioc->shost->can_queue + INTERNAL_SCSIIO_FOR_DISCOVERY;
7180
+
7181
+
rc = 0;
7182
+
mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
7183
+
ioc->scsih_cmds.smid = smid;
7184
+
memset(mpi_request, 0, sizeof(Mpi2SCSIIORequest_t));
7185
+
if (transfer_packet->is_raid)
7186
+
mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
7187
+
else
7188
+
mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
7189
+
mpi_request->DevHandle = cpu_to_le16(handle);
7190
+
7191
+
switch (transfer_packet->dir) {
7192
+
case DMA_TO_DEVICE:
7193
+
mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
7194
+
data_out_dma = transfer_packet->data_dma;
7195
+
data_out_sz = transfer_packet->data_length;
7196
+
break;
7197
+
case DMA_FROM_DEVICE:
7198
+
mpi_control = MPI2_SCSIIO_CONTROL_READ;
7199
+
data_in_dma = transfer_packet->data_dma;
7200
+
data_in_sz = transfer_packet->data_length;
7201
+
break;
7202
+
case DMA_BIDIRECTIONAL:
7203
+
mpi_control = MPI2_SCSIIO_CONTROL_BIDIRECTIONAL;
7204
+
/* TODO - is BIDI support needed ?? */
7205
+
WARN_ON_ONCE(true);
7206
+
break;
7207
+
default:
7208
+
case DMA_NONE:
7209
+
mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
7210
+
break;
7211
+
}
7212
+
7213
+
psge = &mpi_request->SGL;
7214
+
ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
7215
+
data_in_sz);
7216
+
7217
+
mpi_request->Control = cpu_to_le32(mpi_control |
7218
+
MPI2_SCSIIO_CONTROL_SIMPLEQ);
7219
+
mpi_request->DataLength = cpu_to_le32(transfer_packet->data_length);
7220
+
mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR;
7221
+
mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
7222
+
mpi_request->SenseBufferLowAddress =
7223
+
mpt3sas_base_get_sense_buffer_dma(ioc, smid);
7224
+
priv_sense = mpt3sas_base_get_sense_buffer(ioc, smid);
7225
+
mpi_request->SGLOffset0 = offsetof(Mpi2SCSIIORequest_t, SGL) / 4;
7226
+
mpi_request->IoFlags = cpu_to_le16(transfer_packet->cdb_length);
7227
+
int_to_scsilun(transfer_packet->lun, (struct scsi_lun *)
7228
+
mpi_request->LUN);
7229
+
memcpy(mpi_request->CDB.CDB32, transfer_packet->cdb,
7230
+
transfer_packet->cdb_length);
7231
+
init_completion(&ioc->scsih_cmds.done);
7232
+
if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST))
7233
+
ioc->put_smid_scsi_io(ioc, smid, handle);
7234
+
else
7235
+
ioc->put_smid_default(ioc, smid);
7236
+
wait_for_completion_timeout(&ioc->scsih_cmds.done,
7237
+
transfer_packet->timeout*HZ);
7238
+
if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
7239
+
mpt3sas_check_cmd_timeout(ioc,
7240
+
ioc->scsih_cmds.status, mpi_request,
7241
+
sizeof(Mpi2SCSIIORequest_t)/4, issue_reset);
7242
+
goto issue_target_reset;
7243
+
}
7244
+
if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
7245
+
transfer_packet->valid_reply = 1;
7246
+
mpi_reply = ioc->scsih_cmds.reply;
7247
+
transfer_packet->sense_length =
7248
+
le32_to_cpu(mpi_reply->SenseCount);
7249
+
if (transfer_packet->sense_length)
7250
+
memcpy(transfer_packet->sense, priv_sense,
7251
+
transfer_packet->sense_length);
7252
+
transfer_packet->transfer_length =
7253
+
le32_to_cpu(mpi_reply->TransferCount);
7254
+
transfer_packet->ioc_status =
7255
+
le16_to_cpu(mpi_reply->IOCStatus) &
7256
+
MPI2_IOCSTATUS_MASK;
7257
+
transfer_packet->scsi_state = mpi_reply->SCSIState;
7258
+
transfer_packet->scsi_status = mpi_reply->SCSIStatus;
7259
+
transfer_packet->log_info =
7260
+
le32_to_cpu(mpi_reply->IOCLogInfo);
7261
+
}
7262
+
goto out;
7263
+
7264
+
issue_target_reset:
7265
+
if (issue_reset) {
7266
+
pr_info("issue target reset: handle (0x%04x)\n", handle);
7267
+
tm_return_code =
7268
+
mpt3sas_scsih_issue_locked_tm(ioc, handle,
7269
+
0xFFFFFFFF, 0xFFFFFFFF, 0,
7270
+
MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, smid, 0,
7271
+
tr_timeout, tr_method);
7272
+
7273
+
if (tm_return_code == SUCCESS) {
7274
+
pr_info("target reset completed: handle (0x%04x)\n", handle);
7275
+
/* If the command is successfully aborted due to
7276
+
* target reset TM then do up to three retries else
7277
+
* command will be terminated by the host reset TM and
7278
+
* hence retry once.
7279
+
*/
7280
+
if (((ioc->scsih_cmds.status & MPT3_CMD_COMPLETE) &&
7281
+
retry_count++ < 3) ||
7282
+
((ioc->scsih_cmds.status & MPT3_CMD_RESET) &&
7283
+
host_reset_count++ == 0)) {
7284
+
pr_info("issue retry: handle (0x%04x)\n", handle);
7285
+
goto retry_loop;
7286
+
}
7287
+
} else
7288
+
pr_info("target reset didn't complete: handle(0x%04x)\n", handle);
7289
+
rc = -EFAULT;
7290
+
} else
7291
+
rc = -EAGAIN;
7292
+
7293
+
out:
7294
+
ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
7295
+
mutex_unlock(&ioc->scsih_cmds.mutex);
7296
+
return rc;
7297
+
}
7298
+
7299
+
/**
7300
+
* _scsih_determine_disposition -
7301
+
* @ioc: per adapter object
7302
+
* @transfer_packet: packet describing the transfer
7303
+
* Context: user
7304
+
*
7305
+
* Determines if an internal generated scsi_io is good data, or
7306
+
* whether it needs to be retried or treated as an error.
7307
+
*
7308
+
* Returns device_responsive_state
7309
+
*/
7310
+
static enum device_responsive_state
7311
+
_scsih_determine_disposition(struct MPT3SAS_ADAPTER *ioc,
7312
+
struct _scsi_io_transfer *transfer_packet)
7313
+
{
7314
+
static enum device_responsive_state rc;
7315
+
struct sense_info sense_info = {0, 0, 0};
7316
+
u8 check_sense = 0;
7317
+
char *desc = NULL;
7318
+
7319
+
if (!transfer_packet->valid_reply)
7320
+
return DEVICE_READY;
7321
+
7322
+
switch (transfer_packet->ioc_status) {
7323
+
case MPI2_IOCSTATUS_BUSY:
7324
+
case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES:
7325
+
case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
7326
+
case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
7327
+
case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
7328
+
rc = DEVICE_RETRY;
7329
+
break;
7330
+
case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
7331
+
if (transfer_packet->log_info == 0x31170000) {
7332
+
rc = DEVICE_RETRY;
7333
+
break;
7334
+
}
7335
+
if (transfer_packet->cdb[0] == REPORT_LUNS)
7336
+
rc = DEVICE_READY;
7337
+
else
7338
+
rc = DEVICE_RETRY;
7339
+
break;
7340
+
case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
7341
+
case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
7342
+
case MPI2_IOCSTATUS_SUCCESS:
7343
+
if (!transfer_packet->scsi_state &&
7344
+
!transfer_packet->scsi_status) {
7345
+
rc = DEVICE_READY;
7346
+
break;
7347
+
}
7348
+
if (transfer_packet->scsi_state &
7349
+
MPI2_SCSI_STATE_AUTOSENSE_VALID) {
7350
+
rc = DEVICE_ERROR;
7351
+
check_sense = 1;
7352
+
break;
7353
+
}
7354
+
if (transfer_packet->scsi_state &
7355
+
(MPI2_SCSI_STATE_AUTOSENSE_FAILED |
7356
+
MPI2_SCSI_STATE_NO_SCSI_STATUS |
7357
+
MPI2_SCSI_STATE_TERMINATED)) {
7358
+
rc = DEVICE_RETRY;
7359
+
break;
7360
+
}
7361
+
if (transfer_packet->scsi_status >=
7362
+
MPI2_SCSI_STATUS_BUSY) {
7363
+
rc = DEVICE_RETRY;
7364
+
break;
7365
+
}
7366
+
rc = DEVICE_READY;
7367
+
break;
7368
+
case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
7369
+
if (transfer_packet->scsi_state &
7370
+
MPI2_SCSI_STATE_TERMINATED)
7371
+
rc = DEVICE_RETRY;
7372
+
else
7373
+
rc = DEVICE_ERROR;
7374
+
break;
7375
+
case MPI2_IOCSTATUS_INSUFFICIENT_POWER:
7376
+
default:
7377
+
rc = DEVICE_ERROR;
7378
+
break;
7379
+
}
7380
+
7381
+
if (check_sense) {
7382
+
_scsih_normalize_sense(transfer_packet->sense, &sense_info);
7383
+
if (sense_info.skey == UNIT_ATTENTION)
7384
+
rc = DEVICE_RETRY_UA;
7385
+
else if (sense_info.skey == NOT_READY) {
7386
+
/* medium isn't present */
7387
+
if (sense_info.asc == 0x3a)
7388
+
rc = DEVICE_READY;
7389
+
/* LOGICAL UNIT NOT READY */
7390
+
else if (sense_info.asc == 0x04) {
7391
+
if (sense_info.ascq == 0x03 ||
7392
+
sense_info.ascq == 0x0b ||
7393
+
sense_info.ascq == 0x0c) {
7394
+
rc = DEVICE_ERROR;
7395
+
} else
7396
+
rc = DEVICE_START_UNIT;
7397
+
}
7398
+
/* LOGICAL UNIT HAS NOT SELF-CONFIGURED YET */
7399
+
else if (sense_info.asc == 0x3e && !sense_info.ascq)
7400
+
rc = DEVICE_START_UNIT;
7401
+
} else if (sense_info.skey == ILLEGAL_REQUEST &&
7402
+
transfer_packet->cdb[0] == REPORT_LUNS) {
7403
+
rc = DEVICE_READY;
7404
+
} else if (sense_info.skey == MEDIUM_ERROR) {
7405
+
7406
+
/* medium is corrupt, lets add the device so
7407
+
* users can collect some info as needed
7408
+
*/
7409
+
7410
+
if (sense_info.asc == 0x31)
7411
+
rc = DEVICE_READY;
7412
+
} else if (sense_info.skey == HARDWARE_ERROR) {
7413
+
/* Defect List Error, still add the device */
7414
+
if (sense_info.asc == 0x19)
7415
+
rc = DEVICE_READY;
7416
+
}
7417
+
}
7418
+
7419
+
if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
7420
+
switch (rc) {
7421
+
case DEVICE_READY:
7422
+
desc = "ready";
7423
+
break;
7424
+
case DEVICE_RETRY:
7425
+
desc = "retry";
7426
+
break;
7427
+
case DEVICE_RETRY_UA:
7428
+
desc = "retry_ua";
7429
+
break;
7430
+
case DEVICE_START_UNIT:
7431
+
desc = "start_unit";
7432
+
break;
7433
+
case DEVICE_STOP_UNIT:
7434
+
desc = "stop_unit";
7435
+
break;
7436
+
case DEVICE_ERROR:
7437
+
desc = "error";
7438
+
break;
7439
+
}
7440
+
7441
+
pr_info("ioc_status(0x%04x),\n"
7442
+
"loginfo(0x%08x), scsi_status(0x%02x),\n"
7443
+
"scsi_state(0x%02x), rc(%s)\n",
7444
+
transfer_packet->ioc_status,
7445
+
transfer_packet->log_info, transfer_packet->scsi_status,
7446
+
transfer_packet->scsi_state, desc);
7447
+
7448
+
if (check_sense)
7449
+
pr_info("\t[sense_key,asc,ascq]:\n"
7450
+
"[0x%02x,0x%02x,0x%02x]\n",
7451
+
sense_info.skey, sense_info.asc, sense_info.ascq);
7452
+
}
7453
+
return rc;
7454
+
}
7455
+
7456
+
/**
7457
+
* _scsih_report_luns - send REPORT_LUNS to target
7458
+
* @ioc: per adapter object
7459
+
* @handle: expander handle
7460
+
* @data: report luns data payload
7461
+
* @data_length: length of data in bytes
7462
+
* @retry_count: Requeue count
7463
+
* @is_pd: is this hidden raid component
7464
+
* @tr_timeout: Target Reset Timeout
7465
+
* @tr_method: Target Reset Method
7466
+
* Context: user
7467
+
*
7468
+
* Returns device_responsive_state
7469
+
*/
7470
+
static enum device_responsive_state
7471
+
_scsih_report_luns(struct MPT3SAS_ADAPTER *ioc, u16 handle, void *data,
7472
+
u32 data_length, u8 retry_count, u8 is_pd, u8 tr_timeout, u8 tr_method)
7473
+
{
7474
+
struct _scsi_io_transfer *transfer_packet;
7475
+
enum device_responsive_state rc;
7476
+
void *lun_data;
7477
+
int return_code;
7478
+
int retries;
7479
+
7480
+
lun_data = NULL;
7481
+
transfer_packet = kzalloc(sizeof(struct _scsi_io_transfer), GFP_KERNEL);
7482
+
if (!transfer_packet) {
7483
+
7484
+
ioc_err(ioc, "failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7485
+
rc = DEVICE_RETRY;
7486
+
goto out;
7487
+
}
7488
+
7489
+
lun_data = dma_alloc_coherent(&ioc->pdev->dev, data_length,
7490
+
&transfer_packet->data_dma, GFP_ATOMIC);
7491
+
if (!lun_data) {
7492
+
7493
+
ioc_err(ioc, "failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7494
+
rc = DEVICE_RETRY;
7495
+
goto out;
7496
+
}
7497
+
7498
+
for (retries = 0; retries < 4; retries++) {
7499
+
rc = DEVICE_ERROR;
7500
+
ioc_info(ioc, "REPORT_LUNS: handle(0x%04x),\n"
7501
+
"retries(%d)\n", handle, retries);
7502
+
memset(lun_data, 0, data_length);
7503
+
transfer_packet->handle = handle;
7504
+
transfer_packet->dir = DMA_FROM_DEVICE;
7505
+
transfer_packet->data_length = data_length;
7506
+
transfer_packet->cdb_length = 12;
7507
+
transfer_packet->cdb[0] = REPORT_LUNS;
7508
+
transfer_packet->cdb[6] = (data_length >> 24) & 0xFF;
7509
+
transfer_packet->cdb[7] = (data_length >> 16) & 0xFF;
7510
+
transfer_packet->cdb[8] = (data_length >> 8) & 0xFF;
7511
+
transfer_packet->cdb[9] = data_length & 0xFF;
7512
+
transfer_packet->timeout = 30;
7513
+
transfer_packet->is_raid = is_pd;
7514
+
7515
+
return_code = _scsi_send_scsi_io(ioc, transfer_packet, tr_timeout, tr_method);
7516
+
switch (return_code) {
7517
+
case 0:
7518
+
rc = _scsih_determine_disposition(ioc, transfer_packet);
7519
+
if (rc == DEVICE_READY) {
7520
+
memcpy(data, lun_data, data_length);
7521
+
goto out;
7522
+
} else if (rc == DEVICE_ERROR)
7523
+
goto out;
7524
+
break;
7525
+
case -EAGAIN:
7526
+
rc = DEVICE_RETRY;
7527
+
break;
7528
+
case -EFAULT:
7529
+
default:
7530
+
ioc_err(ioc, "failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7531
+
goto out;
7532
+
}
7533
+
}
7534
+
out:
7535
+
7536
+
if (lun_data)
7537
+
dma_free_coherent(&ioc->pdev->dev, data_length, lun_data,
7538
+
transfer_packet->data_dma);
7539
+
kfree(transfer_packet);
7540
+
7541
+
if ((rc == DEVICE_RETRY || rc == DEVICE_START_UNIT ||
7542
+
rc == DEVICE_RETRY_UA) && retry_count >= command_retry_count)
7543
+
rc = DEVICE_ERROR;
7544
+
7545
+
return rc;
7546
+
}
7547
+
7548
+
/**
7549
+
* _scsih_start_unit - send START_UNIT to target
7550
+
* @ioc: per adapter object
7551
+
* @handle: expander handle
7552
+
* @lun: lun number
7553
+
* @is_pd: is this hidden raid component
7554
+
* @tr_timeout: Target Reset Timeout
7555
+
* @tr_method: Target Reset Method
7556
+
* Context: user
7557
+
*
7558
+
* Returns device_responsive_state
7559
+
*/
7560
+
static enum device_responsive_state
7561
+
_scsih_start_unit(struct MPT3SAS_ADAPTER *ioc, u16 handle, u32 lun, u8 is_pd,
7562
+
u8 tr_timeout, u8 tr_method)
7563
+
{
7564
+
struct _scsi_io_transfer *transfer_packet;
7565
+
enum device_responsive_state rc;
7566
+
int return_code;
7567
+
7568
+
transfer_packet = kzalloc(sizeof(struct _scsi_io_transfer), GFP_KERNEL);
7569
+
if (!transfer_packet) {
7570
+
7571
+
pr_info("failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7572
+
rc = DEVICE_RETRY;
7573
+
goto out;
7574
+
}
7575
+
7576
+
rc = DEVICE_READY;
7577
+
transfer_packet->handle = handle;
7578
+
transfer_packet->dir = DMA_NONE;
7579
+
transfer_packet->lun = lun;
7580
+
transfer_packet->cdb_length = 6;
7581
+
transfer_packet->cdb[0] = START_STOP;
7582
+
transfer_packet->cdb[1] = 1;
7583
+
transfer_packet->cdb[4] = 1;
7584
+
transfer_packet->timeout = 30;
7585
+
transfer_packet->is_raid = is_pd;
7586
+
7587
+
pr_info("START_UNIT: handle(0x%04x), lun(%d)\n", handle, lun);
7588
+
7589
+
return_code = _scsi_send_scsi_io(ioc, transfer_packet, tr_timeout, tr_method);
7590
+
switch (return_code) {
7591
+
case 0:
7592
+
rc = _scsih_determine_disposition(ioc, transfer_packet);
7593
+
break;
7594
+
case -EAGAIN:
7595
+
rc = DEVICE_RETRY;
7596
+
break;
7597
+
case -EFAULT:
7598
+
default:
7599
+
pr_err("failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7600
+
rc = DEVICE_ERROR;
7601
+
break;
7602
+
}
7603
+
out:
7604
+
kfree(transfer_packet);
7605
+
return rc;
7606
+
}
7607
+
7608
+
/**
7609
+
* _scsih_test_unit_ready - send TUR to target
7610
+
* @ioc: per adapter object
7611
+
* @handle: expander handle
7612
+
* @lun: lun number
7613
+
* @is_pd: is this hidden raid component
7614
+
* @tr_timeout: Target Reset timeout value for Pcie devie
7615
+
* @tr_method: pcie device Target reset method
7616
+
* Context: user
7617
+
*
7618
+
* Returns device_responsive_state
7619
+
*/
7620
+
static enum device_responsive_state
7621
+
_scsih_test_unit_ready(struct MPT3SAS_ADAPTER *ioc, u16 handle, u32 lun,
7622
+
u8 is_pd, u8 tr_timeout, u8 tr_method)
7623
+
{
7624
+
struct _scsi_io_transfer *transfer_packet;
7625
+
enum device_responsive_state rc;
7626
+
int return_code;
7627
+
int sata_init_failure = 0;
7628
+
7629
+
transfer_packet = kzalloc(sizeof(struct _scsi_io_transfer), GFP_KERNEL);
7630
+
if (!transfer_packet) {
7631
+
7632
+
pr_info("failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7633
+
rc = DEVICE_RETRY;
7634
+
goto out;
7635
+
}
7636
+
7637
+
rc = DEVICE_READY;
7638
+
transfer_packet->handle = handle;
7639
+
transfer_packet->dir = DMA_NONE;
7640
+
transfer_packet->lun = lun;
7641
+
transfer_packet->cdb_length = 6;
7642
+
transfer_packet->cdb[0] = TEST_UNIT_READY;
7643
+
transfer_packet->timeout = 30;
7644
+
transfer_packet->is_raid = is_pd;
7645
+
7646
+
sata_init_retry:
7647
+
pr_info("TEST_UNIT_READY: handle(0x%04x) lun(%d)\n", handle, lun);
7648
+
7649
+
return_code = _scsi_send_scsi_io(ioc, transfer_packet, tr_timeout, tr_method);
7650
+
switch (return_code) {
7651
+
case 0:
7652
+
rc = _scsih_determine_disposition(ioc, transfer_packet);
7653
+
if (rc == DEVICE_RETRY &&
7654
+
transfer_packet->log_info == 0x31111000) {
7655
+
if (!sata_init_failure++) {
7656
+
pr_info("SATA Initialization Timeout sending a retry\n");
7657
+
rc = DEVICE_READY;
7658
+
goto sata_init_retry;
7659
+
} else {
7660
+
pr_err("SATA Initialization Failed\n");
7661
+
rc = DEVICE_ERROR;
7662
+
}
7663
+
}
7664
+
break;
7665
+
case -EAGAIN:
7666
+
rc = DEVICE_RETRY;
7667
+
break;
7668
+
case -EFAULT:
7669
+
default:
7670
+
pr_err("failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7671
+
rc = DEVICE_ERROR;
7672
+
break;
7673
+
}
7674
+
out:
7675
+
kfree(transfer_packet);
7676
+
return rc;
7677
+
}
7678
+
7679
+
/**
7680
+
* _scsih_ata_pass_thru_idd - obtain SATA device Identify Device Data
7681
+
* @ioc: per adapter object
7682
+
* @handle: device handle
7683
+
* @is_ssd_device : is this SATA SSD device
7684
+
* @tr_timeout: Target Reset Timeout
7685
+
* @tr_method: Target Reset Method
7686
+
* Context: user
7687
+
*
7688
+
* Returns device_responsive_state
7689
+
*/
7690
+
static enum device_responsive_state
7691
+
_scsih_ata_pass_thru_idd(struct MPT3SAS_ADAPTER *ioc, u16 handle,
7692
+
u8 *is_ssd_device, u8 tr_timeout, u8 tr_method)
7693
+
{
7694
+
struct _scsi_io_transfer *transfer_packet;
7695
+
enum device_responsive_state rc;
7696
+
u16 *idd_data;
7697
+
int return_code;
7698
+
u32 data_length;
7699
+
7700
+
idd_data = NULL;
7701
+
transfer_packet = kzalloc(sizeof(struct _scsi_io_transfer), GFP_KERNEL);
7702
+
if (!transfer_packet) {
7703
+
7704
+
ioc_err(ioc, "failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7705
+
rc = DEVICE_RETRY;
7706
+
goto out;
7707
+
}
7708
+
data_length = 512;
7709
+
idd_data = dma_alloc_coherent(&ioc->pdev->dev, data_length,
7710
+
&transfer_packet->data_dma, GFP_ATOMIC);
7711
+
if (!idd_data) {
7712
+
7713
+
ioc_err(ioc, "failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7714
+
rc = DEVICE_RETRY;
7715
+
goto out;
7716
+
}
7717
+
rc = DEVICE_READY;
7718
+
memset(idd_data, 0, data_length);
7719
+
transfer_packet->handle = handle;
7720
+
transfer_packet->dir = DMA_FROM_DEVICE;
7721
+
transfer_packet->data_length = data_length;
7722
+
transfer_packet->cdb_length = 12;
7723
+
transfer_packet->cdb[0] = ATA_12;
7724
+
transfer_packet->cdb[1] = 0x8;
7725
+
transfer_packet->cdb[2] = 0xd;
7726
+
transfer_packet->cdb[3] = 0x1;
7727
+
transfer_packet->cdb[9] = 0xec;
7728
+
transfer_packet->timeout = 30;
7729
+
7730
+
return_code = _scsi_send_scsi_io(ioc, transfer_packet, 30, 0);
7731
+
switch (return_code) {
7732
+
case 0:
7733
+
rc = _scsih_determine_disposition(ioc, transfer_packet);
7734
+
if (rc == DEVICE_READY) {
7735
+
// Check if nominal media rotation rate is set to 1 i.e. SSD device
7736
+
if (idd_data[217] == 1)
7737
+
*is_ssd_device = 1;
7738
+
}
7739
+
break;
7740
+
case -EAGAIN:
7741
+
rc = DEVICE_RETRY;
7742
+
break;
7743
+
case -EFAULT:
7744
+
default:
7745
+
7746
+
ioc_err(ioc, "failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7747
+
rc = DEVICE_ERROR;
7748
+
break;
7749
+
}
7750
+
7751
+
out:
7752
+
if (idd_data) {
7753
+
dma_free_coherent(&ioc->pdev->dev, data_length, idd_data,
7754
+
transfer_packet->data_dma);
7755
+
}
7756
+
kfree(transfer_packet);
7757
+
return rc;
7758
+
}
7759
+
7760
+
/**
7761
+
* _scsih_wait_for_device_to_become_ready - handle busy devices
7762
+
* @ioc: per adapter object
7763
+
* @handle: expander handle
7764
+
* @retry_count: number of times this event has been retried
7765
+
* @is_pd: is this hidden raid component
7766
+
* @lun: lun number
7767
+
* @tr_timeout: Target Reset Timeout
7768
+
* @tr_method: Target Reset Method
7769
+
*
7770
+
* Some devices spend too much time in busy state, queue event later
7771
+
*
7772
+
* Return the device_responsive_state.
7773
+
*/
7774
+
7775
+
static enum device_responsive_state
7776
+
_scsih_wait_for_device_to_become_ready(struct MPT3SAS_ADAPTER *ioc, u16 handle,
7777
+
u8 retry_count, u8 is_pd, int lun, u8 tr_timeout, u8 tr_method)
7778
+
{
7779
+
enum device_responsive_state rc;
7780
+
7781
+
if (ioc->pci_error_recovery)
7782
+
return DEVICE_ERROR;
7783
+
7784
+
if (ioc->shost_recovery)
7785
+
return DEVICE_RETRY;
7786
+
7787
+
rc = _scsih_test_unit_ready(ioc, handle, lun, is_pd, tr_timeout, tr_method);
7788
+
if (rc == DEVICE_READY || rc == DEVICE_ERROR)
7789
+
return rc;
7790
+
else if (rc == DEVICE_START_UNIT) {
7791
+
rc = _scsih_start_unit(ioc, handle, lun, is_pd, tr_timeout, tr_method);
7792
+
if (rc == DEVICE_ERROR)
7793
+
return rc;
7794
+
rc = _scsih_test_unit_ready(ioc, handle, lun, is_pd, tr_timeout, tr_method);
7795
+
}
7796
+
7797
+
if ((rc == DEVICE_RETRY || rc == DEVICE_START_UNIT ||
7798
+
rc == DEVICE_RETRY_UA) && retry_count >= command_retry_count)
7799
+
rc = DEVICE_ERROR;
7800
+
return rc;
7801
+
}
7802
+
7803
+
static inline int mpt_scsilun_to_int(struct scsi_lun *scsilun)
7804
+
{
7805
+
return scsilun_to_int(scsilun);
7806
+
}
7807
+
7808
+
/**
7809
+
* _scsih_wait_for_target_to_become_ready - handle busy devices
7810
+
* @ioc: per adapter object
7811
+
* @handle: expander handle
7812
+
* @retry_count: number of times this event has been retried
7813
+
* @is_pd: is this hidden raid component
7814
+
* @tr_timeout: Target Reset timeout value
7815
+
* @tr_method: Target Reset method Hot/Protocol level.
7816
+
*
7817
+
* Some devices spend too much time in busy state, queue event later
7818
+
*
7819
+
* Return the device_responsive_state.
7820
+
*/
7821
+
static enum device_responsive_state
7822
+
_scsih_wait_for_target_to_become_ready(struct MPT3SAS_ADAPTER *ioc, u16 handle,
7823
+
u8 retry_count, u8 is_pd, u8 tr_timeout, u8 tr_method)
7824
+
{
7825
+
enum device_responsive_state rc;
7826
+
struct scsi_lun *lun_data;
7827
+
u32 length, num_luns;
7828
+
u8 *data;
7829
+
int lun;
7830
+
struct scsi_lun *lunp;
7831
+
7832
+
lun_data = kcalloc(MPT3_MAX_LUNS, sizeof(struct scsi_lun), GFP_KERNEL);
7833
+
if (!lun_data) {
7834
+
7835
+
ioc_err(ioc, "failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
7836
+
return DEVICE_RETRY;
7837
+
}
7838
+
7839
+
rc = _scsih_report_luns(ioc, handle, lun_data,
7840
+
MPT3_MAX_LUNS * sizeof(struct scsi_lun), retry_count, is_pd,
7841
+
tr_timeout, tr_method);
7842
+
7843
+
if (rc != DEVICE_READY)
7844
+
goto out;
7845
+
7846
+
/* some debug bits*/
7847
+
data = (u8 *)lun_data;
7848
+
length = ((data[0] << 24) | (data[1] << 16) |
7849
+
(data[2] << 8) | (data[3] << 0));
7850
+
7851
+
num_luns = (length / sizeof(struct scsi_lun));
7852
+
7853
+
lunp = &lun_data[1];
7854
+
lun = (num_luns) ? mpt_scsilun_to_int(&lun_data[1]) : 0;
7855
+
rc = _scsih_wait_for_device_to_become_ready(ioc, handle, retry_count,
7856
+
is_pd, lun, tr_timeout, tr_method);
7857
+
7858
+
if (rc == DEVICE_ERROR) {
7859
+
struct scsi_lun *lunq;
7860
+
7861
+
for (lunq = lunp++; lunq <= &lun_data[num_luns]; lunq++) {
7862
+
7863
+
rc = _scsih_wait_for_device_to_become_ready(ioc, handle,
7864
+
retry_count, is_pd, mpt_scsilun_to_int(lunq),
7865
+
tr_timeout, tr_method);
7866
+
if (rc != DEVICE_ERROR)
7867
+
goto out;
7868
+
}
7869
+
}
7870
+
out:
7871
+
kfree(lun_data);
7872
+
return rc;
7873
+
}
7419
7874
7420
7875
7421
7876
/**
···
8302
7239
sas_device->handle, handle);
8303
7240
sas_target_priv_data->handle = handle;
8304
7241
sas_device->handle = handle;
8305
-
if (le16_to_cpu(sas_device_pg0.Flags) &
8306
-
MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
7242
+
if ((le16_to_cpu(sas_device_pg0.Flags) & MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID)
7243
+
&& (ioc->hba_mpi_version_belonged != MPI2_VERSION)) {
8307
7244
sas_device->enclosure_level =
8308
7245
sas_device_pg0.EnclosureLevel;
8309
7246
memcpy(sas_device->connector_name,
···
8345
7282
goto out_unlock;
8346
7283
8347
7284
spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8348
-
_scsih_ublock_io_device(ioc, sas_address, port);
7285
+
7286
+
if (issue_scsi_cmd_to_bringup_drive)
7287
+
_scsih_ublock_io_device_wait(ioc, sas_address, port);
7288
+
else
7289
+
_scsih_ublock_io_device(ioc, sas_address, port);
8349
7290
8350
7291
if (sas_device)
8351
7292
sas_device_put(sas_device);
···
8365
7298
* _scsih_add_device - creating sas device object
8366
7299
* @ioc: per adapter object
8367
7300
* @handle: sas device handle
8368
-
* @phy_num: phy number end device attached to
7301
+
* @retry_count: number of times this event has been retried
8369
7302
* @is_pd: is this hidden raid component
8370
7303
*
8371
7304
* Creating end device object, stored in ioc->sas_device_list.
···
8373
7306
* Return: 0 for success, non-zero for failure.
8374
7307
*/
8375
7308
static int
8376
-
_scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num,
7309
+
_scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 retry_count,
8377
7310
u8 is_pd)
8378
7311
{
8379
7312
Mpi2ConfigReply_t mpi_reply;
8380
7313
Mpi2SasDevicePage0_t sas_device_pg0;
8381
7314
struct _sas_device *sas_device;
8382
7315
struct _enclosure_node *enclosure_dev = NULL;
7316
+
enum device_responsive_state rc;
8383
7317
u32 ioc_status;
8384
7318
u64 sas_address;
8385
7319
u32 device_info;
7320
+
u8 connector_name[5];
8386
7321
u8 port_id;
8387
7322
8388
7323
if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
···
8438
7369
if (enclosure_dev == NULL)
8439
7370
ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
8440
7371
sas_device_pg0.EnclosureHandle);
7372
+
}
7373
+
7374
+
/*
7375
+
* Wait for device that is becoming ready
7376
+
* queue request later if device is busy.
7377
+
*/
7378
+
if ((!ioc->wait_for_discovery_to_complete) &&
7379
+
(issue_scsi_cmd_to_bringup_drive)) {
7380
+
ioc_info(ioc, "detecting: handle(0x%04x),\n"
7381
+
"sas_address(0x%016llx), phy(%d)\n", handle,
7382
+
(unsigned long long)sas_address, sas_device_pg0.PhyNum);
7383
+
rc = _scsih_wait_for_target_to_become_ready(ioc, handle,
7384
+
retry_count, is_pd, 30, 0);
7385
+
if (rc != DEVICE_READY) {
7386
+
if (le16_to_cpu(sas_device_pg0.EnclosureHandle) != 0)
7387
+
dewtprintk(ioc, ioc_info(ioc, "%s:\n"
7388
+
"device not ready: slot(%d)\n", __func__,
7389
+
le16_to_cpu(sas_device_pg0.Slot)));
7390
+
if ((le16_to_cpu(sas_device_pg0.Flags) &
7391
+
MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) &&
7392
+
(ioc->hba_mpi_version_belonged != MPI2_VERSION)) {
7393
+
memcpy(connector_name,
7394
+
sas_device_pg0.ConnectorName, 4);
7395
+
connector_name[4] = '\0';
7396
+
dewtprintk(ioc, ioc_info(ioc, "%s:\n"
7397
+
"device not ready:\n"
7398
+
"enclosure level(0x%04x),\n"
7399
+
"connector name( %s)\n", __func__,
7400
+
sas_device_pg0.EnclosureLevel, connector_name));
7401
+
}
7402
+
7403
+
if ((enclosure_dev) && (le16_to_cpu(enclosure_dev->pg0.Flags) &
7404
+
MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID))
7405
+
ioc_info(ioc, "chassis slot(0x%04x)\n",
7406
+
enclosure_dev->pg0.ChassisSlot);
7407
+
7408
+
if (rc == DEVICE_RETRY || rc == DEVICE_START_UNIT ||
7409
+
rc == DEVICE_STOP_UNIT || rc == DEVICE_RETRY_UA)
7410
+
return 1;
7411
+
else if (rc == DEVICE_ERROR)
7412
+
return 0;
7413
+
}
8441
7414
}
8442
7415
8443
7416
sas_device = kzalloc(sizeof(struct _sas_device),
···
8697
7586
struct fw_event_work *fw_event)
8698
7587
{
8699
7588
int i;
7589
+
int rc;
7590
+
int requeue_event;
8700
7591
u16 parent_handle, handle;
8701
7592
u16 reason_code;
8702
7593
u8 phy_number, max_phys;
8703
7594
struct _sas_node *sas_expander;
7595
+
struct _sas_device *sas_device;
8704
7596
u64 sas_address;
8705
7597
unsigned long flags;
8706
7598
u8 link_rate, prev_link_rate;
···
8753
7639
spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
8754
7640
8755
7641
/* handle siblings events */
8756
-
for (i = 0; i < event_data->NumEntries; i++) {
7642
+
for (i = 0, requeue_event = 0; i < event_data->NumEntries; i++) {
8757
7643
if (fw_event->ignore) {
8758
7644
dewtprintk(ioc,
8759
7645
ioc_info(ioc, "ignoring expander event\n"));
···
8770
7656
MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code !=
8771
7657
MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING))
8772
7658
continue;
7659
+
if (fw_event->delayed_work_active && (reason_code ==
7660
+
MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)) {
7661
+
dewtprintk(ioc, ioc_info(ioc, "ignoring\n"
7662
+
"Target not responding event phy in re-queued event processing\n"));
7663
+
continue;
7664
+
}
7665
+
7666
+
if (fw_event->delayed_work_active && (reason_code ==
7667
+
MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)) {
7668
+
dewtprintk(ioc, ioc_info(ioc, "ignoring Target not responding\n"
7669
+
"event phy in re-queued event processing\n"));
7670
+
continue;
7671
+
}
7672
+
8773
7673
handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
8774
7674
if (!handle)
8775
7675
continue;
···
8807
7679
_scsih_check_device(ioc, sas_address, handle,
8808
7680
phy_number, link_rate);
8809
7681
7682
+
/* This code after this point handles the test case
7683
+
* where a device has been added, however its returning
7684
+
* BUSY for sometime. Then before the Device Missing
7685
+
* Delay expires and the device becomes READY, the
7686
+
* device is removed and added back.
7687
+
*/
7688
+
spin_lock_irqsave(&ioc->sas_device_lock, flags);
7689
+
sas_device = __mpt3sas_get_sdev_by_handle(ioc,
7690
+
handle);
7691
+
spin_unlock_irqrestore(&ioc->sas_device_lock,
7692
+
flags);
7693
+
7694
+
if (sas_device) {
7695
+
sas_device_put(sas_device);
7696
+
break;
7697
+
}
7698
+
8810
7699
if (!test_bit(handle, ioc->pend_os_device_add))
8811
7700
break;
7701
+
7702
+
dewtprintk(ioc, ioc_info(ioc, "handle(0x%04x) device not found: convert\n"
7703
+
"event to a device add\n", handle));
7704
+
event_data->PHY[i].PhyStatus &= 0xF0;
7705
+
event_data->PHY[i].PhyStatus |=
7706
+
MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED;
8812
7707
8813
7708
fallthrough;
8814
7709
···
8843
7692
mpt3sas_transport_update_links(ioc, sas_address,
8844
7693
handle, phy_number, link_rate, port);
8845
7694
8846
-
_scsih_add_device(ioc, handle, phy_number, 0);
7695
+
if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
7696
+
break;
7697
+
7698
+
rc = _scsih_add_device(ioc, handle,
7699
+
fw_event->retries[i], 0);
7700
+
if (rc) {/* retry due to busy device */
7701
+
fw_event->retries[i]++;
7702
+
requeue_event = 1;
7703
+
} else {/* mark entry vacant */
7704
+
event_data->PHY[i].PhyStatus |=
7705
+
MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT;
7706
+
}
8847
7707
8848
7708
break;
8849
7709
case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
···
8869
7707
sas_expander)
8870
7708
mpt3sas_expander_remove(ioc, sas_address, port);
8871
7709
8872
-
return 0;
7710
+
return requeue_event;
8873
7711
}
8874
7712
8875
7713
/**
···
9240
8078
spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
9241
8079
pcie_device_put(pcie_device);
9242
8080
9243
-
_scsih_ublock_io_device(ioc, wwid, NULL);
8081
+
if (issue_scsi_cmd_to_bringup_drive)
8082
+
_scsih_ublock_io_device_wait(ioc, wwid, NULL);
8083
+
else
8084
+
_scsih_ublock_io_device(ioc, wwid, NULL);
9244
8085
9245
8086
return;
9246
8087
}
···
9252
8087
* _scsih_pcie_add_device - creating pcie device object
9253
8088
* @ioc: per adapter object
9254
8089
* @handle: pcie device handle
8090
+
* @retry_count: number of times this event has been retried
9255
8091
*
9256
8092
* Creating end device object, stored in ioc->pcie_device_list.
9257
8093
*
9258
8094
* Return: 1 means queue the event later, 0 means complete the event
9259
8095
*/
9260
8096
static int
9261
-
_scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
8097
+
_scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 retry_count)
9262
8098
{
9263
8099
Mpi26PCIeDevicePage0_t pcie_device_pg0;
9264
8100
Mpi26PCIeDevicePage2_t pcie_device_pg2;
9265
8101
Mpi2ConfigReply_t mpi_reply;
9266
8102
struct _pcie_device *pcie_device;
9267
8103
struct _enclosure_node *enclosure_dev;
8104
+
enum device_responsive_state rc;
8105
+
u8 connector_name[5];
8106
+
u8 tr_timeout = 30;
8107
+
u8 tr_method = 0;
9268
8108
u32 ioc_status;
9269
8109
u64 wwid;
9270
8110
···
9336
8166
"failure at %s:%d/%s()!\n", __FILE__,
9337
8167
__LINE__, __func__);
9338
8168
return 0;
8169
+
}
8170
+
8171
+
if (!ioc->tm_custom_handling) {
8172
+
tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE;
8173
+
if (pcie_device_pg2.ControllerResetTO)
8174
+
tr_timeout = pcie_device_pg2.ControllerResetTO;
8175
+
8176
+
}
8177
+
}
8178
+
8179
+
/*
8180
+
* Wait for device that is becoming ready
8181
+
* queue request later if device is busy.
8182
+
*/
8183
+
if ((!ioc->wait_for_discovery_to_complete) &&
8184
+
(issue_scsi_cmd_to_bringup_drive) &&
8185
+
(pcie_device_pg0.AccessStatus !=
8186
+
MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED)) {
8187
+
ioc_info(ioc, "detecting: handle(0x%04x),\n"
8188
+
"wwid(0x%016llx), port(%d)\n", handle,
8189
+
(unsigned long long)wwid, pcie_device_pg0.PortNum);
8190
+
8191
+
rc = _scsih_wait_for_target_to_become_ready(ioc, handle,
8192
+
retry_count, 0, tr_timeout, tr_method);
8193
+
if (rc != DEVICE_READY) {
8194
+
if (le16_to_cpu(pcie_device_pg0.EnclosureHandle) != 0)
8195
+
dewtprintk(ioc, ioc_info(ioc, "%s:\n"
8196
+
"device not ready: slot(%d)\n",
8197
+
__func__,
8198
+
le16_to_cpu(pcie_device_pg0.Slot)));
8199
+
8200
+
if (le32_to_cpu(pcie_device_pg0.Flags) &
8201
+
MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) {
8202
+
memcpy(connector_name,
8203
+
pcie_device_pg0.ConnectorName, 4);
8204
+
connector_name[4] = '\0';
8205
+
dewtprintk(ioc, ioc_info(ioc, "%s: device not ready: enclosure\n"
8206
+
"level(0x%04x), connector name( %s)\n", __func__,
8207
+
pcie_device_pg0.EnclosureLevel,
8208
+
connector_name));
8209
+
}
8210
+
8211
+
if (rc == DEVICE_RETRY || rc == DEVICE_START_UNIT ||
8212
+
rc == DEVICE_STOP_UNIT || rc == DEVICE_RETRY_UA)
8213
+
return 1;
8214
+
else if (rc == DEVICE_ERROR)
8215
+
return 0;
9339
8216
}
9340
8217
}
9341
8218
···
9547
8330
* Context: user.
9548
8331
*
9549
8332
*/
9550
-
static void
8333
+
static int
9551
8334
_scsih_pcie_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
9552
8335
struct fw_event_work *fw_event)
9553
8336
{
···
9557
8340
u8 link_rate, prev_link_rate;
9558
8341
unsigned long flags;
9559
8342
int rc;
8343
+
int requeue_event;
9560
8344
Mpi26EventDataPCIeTopologyChangeList_t *event_data =
9561
8345
(Mpi26EventDataPCIeTopologyChangeList_t *) fw_event->event_data;
9562
8346
struct _pcie_device *pcie_device;
···
9567
8349
9568
8350
if (ioc->shost_recovery || ioc->remove_host ||
9569
8351
ioc->pci_error_recovery)
9570
-
return;
8352
+
return 0;
9571
8353
9572
8354
if (fw_event->ignore) {
9573
8355
dewtprintk(ioc, ioc_info(ioc, "ignoring switch event\n"));
9574
-
return;
8356
+
return 0;
9575
8357
}
9576
8358
9577
8359
/* handle siblings events */
9578
-
for (i = 0; i < event_data->NumEntries; i++) {
8360
+
for (i = 0, requeue_event = 0; i < event_data->NumEntries; i++) {
9579
8361
if (fw_event->ignore) {
9580
8362
dewtprintk(ioc,
9581
8363
ioc_info(ioc, "ignoring switch event\n"));
9582
-
return;
8364
+
return 0;
9583
8365
}
9584
8366
if (ioc->remove_host || ioc->pci_error_recovery)
9585
-
return;
8367
+
return 0;
9586
8368
reason_code = event_data->PortEntry[i].PortStatus;
9587
8369
handle =
9588
8370
le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle);
···
9636
8418
if (link_rate < MPI26_EVENT_PCIE_TOPO_PI_RATE_2_5)
9637
8419
break;
9638
8420
9639
-
rc = _scsih_pcie_add_device(ioc, handle);
9640
-
if (!rc) {
8421
+
rc = _scsih_pcie_add_device(ioc, handle, fw_event->retries[i]);
8422
+
if (rc) {/* retry due to busy device */
8423
+
fw_event->retries[i]++;
8424
+
requeue_event = 1;
8425
+
} else {
9641
8426
/* mark entry vacant */
9642
8427
/* TODO This needs to be reviewed and fixed,
9643
8428
* we dont have an entry
···
9655
8434
break;
9656
8435
}
9657
8436
}
8437
+
return requeue_event;
9658
8438
}
9659
8439
9660
8440
/**
9661
8441
* _scsih_pcie_device_status_change_event_debug - debug for device event
9662
-
* @ioc: ?
8442
+
* @ioc: per adapter object
9663
8443
* @event_data: event data payload
9664
8444
* Context: user.
9665
8445
*/
···
10032
8810
10033
8811
ioc->broadcast_aen_busy = 0;
10034
8812
if (!ioc->shost_recovery)
10035
-
_scsih_ublock_io_all_device(ioc);
8813
+
_scsih_ublock_io_all_device(ioc, 1);
10036
8814
mutex_unlock(&ioc->tm_cmds.mutex);
10037
8815
}
10038
8816
···
11566
10344
ioc_info(ioc, "removing unresponding devices: complete\n");
11567
10345
11568
10346
/* unblock devices */
11569
-
_scsih_ublock_io_all_device(ioc);
10347
+
_scsih_ublock_io_all_device(ioc, 0);
11570
10348
}
11571
10349
11572
10350
static void
···
11846
10624
}
11847
10625
retry_count = 0;
11848
10626
parent_handle = le16_to_cpu(pcie_device_pg0.ParentDevHandle);
11849
-
_scsih_pcie_add_device(ioc, handle);
10627
+
while (_scsih_pcie_add_device(ioc, handle, retry_count++))
10628
+
ssleep(1);
11850
10629
11851
10630
ioc_info(ioc, "\tAFTER adding pcie end device: handle (0x%04x), wwid(0x%016llx)\n",
11852
10631
handle, (u64)le64_to_cpu(pcie_device_pg0.WWID));
···
11991
10768
_scsih_turn_on_pfa_led(ioc, fw_event->device_handle);
11992
10769
break;
11993
10770
case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
11994
-
_scsih_sas_topology_change_event(ioc, fw_event);
10771
+
if (_scsih_sas_topology_change_event(ioc, fw_event)) {
10772
+
_scsih_fw_event_requeue(ioc, fw_event, 1000);
10773
+
ioc->current_event = NULL;
10774
+
return;
10775
+
}
11995
10776
break;
11996
10777
case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
11997
10778
if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
···
12035
10808
_scsih_pcie_enumeration_event(ioc, fw_event);
12036
10809
break;
12037
10810
case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST:
12038
-
_scsih_pcie_topology_change_event(ioc, fw_event);
10811
+
if (_scsih_pcie_topology_change_event(ioc, fw_event)) {
10812
+
_scsih_fw_event_requeue(ioc, fw_event, 1000);
10813
+
ioc->current_event = NULL;
10814
+
return;
10815
+
}
12039
10816
break;
12040
10817
}
12041
10818
out:
···
12060
10829
{
12061
10830
struct fw_event_work *fw_event = container_of(work,
12062
10831
struct fw_event_work, work);
10832
+
10833
+
_mpt3sas_fw_work(fw_event->ioc, fw_event);
10834
+
}
10835
+
10836
+
static void
10837
+
_firmware_event_work_delayed(struct work_struct *work)
10838
+
{
10839
+
struct fw_event_work *fw_event = container_of(work,
10840
+
struct fw_event_work, delayed_work.work);
12063
10841
12064
10842
_mpt3sas_fw_work(fw_event->ioc, fw_event);
12065
10843
}
···
12251
11011
ioc_err(ioc, "failure at %s:%d/%s()!\n",
12252
11012
__FILE__, __LINE__, __func__);
12253
11013
return 1;
11014
+
}
11015
+
11016
+
if (event == MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST) {
11017
+
Mpi2EventDataSasTopologyChangeList_t *topo_event_data =
11018
+
(Mpi2EventDataSasTopologyChangeList_t *)
11019
+
mpi_reply->EventData;
11020
+
fw_event->retries = kzalloc(topo_event_data->NumEntries,
11021
+
GFP_ATOMIC);
11022
+
if (!fw_event->retries) {
11023
+
11024
+
ioc_err(ioc, "failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
11025
+
kfree(fw_event->event_data);
11026
+
fw_event_work_put(fw_event);
11027
+
return 1;
11028
+
}
11029
+
}
11030
+
11031
+
if (event == MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST) {
11032
+
Mpi26EventDataPCIeTopologyChangeList_t *topo_event_data =
11033
+
(Mpi26EventDataPCIeTopologyChangeList_t *) mpi_reply->EventData;
11034
+
fw_event->retries = kzalloc(topo_event_data->NumEntries,
11035
+
GFP_ATOMIC);
11036
+
if (!fw_event->retries) {
11037
+
11038
+
ioc_err(ioc, "failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__);
11039
+
fw_event_work_put(fw_event);
11040
+
return 1;
11041
+
}
12254
11042
}
12255
11043
12256
11044
memcpy(fw_event->event_data, mpi_reply->EventData, sz);