projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
scsi: isci: Grammar s/the its/its/
[linux-2.6-block.git] / drivers / scsi / mpt3sas / mpt3sas_scsih.c
CommitLineData
f92363d1
SR		 1/*
2 * Scsi Host Layer for MPT (Message Passing Technology) based controllers
3 *
4 * This code is based on drivers/scsi/mpt3sas/mpt3sas_scsih.c
a4ffce0d 5 * Copyright (C) 2012-2014 LSI Corporation
a03bd153
SR		 6 * Copyright (C) 2013-2014 Avago Technologies
7 * (mailto: MPT-FusionLinux.pdl@avagotech.com)
f92363d1
SR		 8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * NO WARRANTY
20 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
21 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
22 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
23 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
24 * solely responsible for determining the appropriateness of using and
25 * distributing the Program and assumes all risks associated with its
26 * exercise of rights under this Agreement, including but not limited to
27 * the risks and costs of program errors, damage to or loss of data,
28 * programs or equipment, and unavailability or interruption of operations.
29
30 * DISCLAIMER OF LIABILITY
31 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
32 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
34 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
35 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
36 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
37 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
38
39 * You should have received a copy of the GNU General Public License
40 * along with this program; if not, write to the Free Software
41 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
42 * USA.
43 */
44
f92363d1
SR		 45#include <linux/module.h>
46#include <linux/kernel.h>
47#include <linux/init.h>
48#include <linux/errno.h>
49#include <linux/blkdev.h>
50#include <linux/sched.h>
51#include <linux/workqueue.h>
52#include <linux/delay.h>
53#include <linux/pci.h>
ffdadd68 54#include <linux/pci-aspm.h>
f92363d1
SR		 55#include <linux/interrupt.h>
56#include <linux/aer.h>
57#include <linux/raid_class.h>
7786ab6a 58#include <asm/unaligned.h>
f92363d1
SR		 59
60#include "mpt3sas_base.h"
61
f92363d1 62#define RAID_CHANNEL 1
d88e1eab
SPS		 63
64#define PCIE_CHANNEL 2
65
f92363d1
SR		 66/* forward proto's */
67static void _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
68 struct _sas_node *sas_expander);
69static void _firmware_event_work(struct work_struct *work);
70
71static void _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
72 struct _sas_device *sas_device);
73static int _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle,
74 u8 retry_count, u8 is_pd);
c102e00c 75static int _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle);
3075ac49
SPS		 76static void _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc,
77 struct _pcie_device *pcie_device);
4318c734
SPS		 78static void
79_scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle);
f92363d1
SR		 80static u8 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid);
81
f92363d1
SR		 82/* global parameters */
83LIST_HEAD(mpt3sas_ioc_list);
08c4d550
SR		 84/* global ioc lock for list operations */
85DEFINE_SPINLOCK(gioc_lock);
f92363d1 86
c84b06a4
SR		 87MODULE_AUTHOR(MPT3SAS_AUTHOR);
88MODULE_DESCRIPTION(MPT3SAS_DESCRIPTION);
89MODULE_LICENSE("GPL");
90MODULE_VERSION(MPT3SAS_DRIVER_VERSION);
91MODULE_ALIAS("mpt2sas");
92
f92363d1
SR		 93/* local parameters */
94static u8 scsi_io_cb_idx = -1;
95static u8 tm_cb_idx = -1;
96static u8 ctl_cb_idx = -1;
97static u8 base_cb_idx = -1;
98static u8 port_enable_cb_idx = -1;
99static u8 transport_cb_idx = -1;
100static u8 scsih_cb_idx = -1;
101static u8 config_cb_idx = -1;
c84b06a4
SR		 102static int mpt2_ids;
103static int mpt3_ids;
f92363d1
SR		 104
105static u8 tm_tr_cb_idx = -1 ;
106static u8 tm_tr_volume_cb_idx = -1 ;
107static u8 tm_sas_control_cb_idx = -1;
108
109/* command line options */
110static u32 logging_level;
111MODULE_PARM_DESC(logging_level,
112 " bits for enabling additional logging info (default=0)");
113
114
115static ushort max_sectors = 0xFFFF;
116module_param(max_sectors, ushort, 0);
117MODULE_PARM_DESC(max_sectors, "max sectors, range 64 to 32767 default=32767");
118
119
120static int missing_delay[2] = {-1, -1};
121module_param_array(missing_delay, int, NULL, 0);
122MODULE_PARM_DESC(missing_delay, " device missing delay , io missing delay");
123
124/* scsi-mid layer global parmeter is max_report_luns, which is 511 */
125#define MPT3SAS_MAX_LUN (16895)
1abf635d
HR		 126static u64 max_lun = MPT3SAS_MAX_LUN;
127module_param(max_lun, ullong, 0);
f92363d1
SR		 128MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
129
c84b06a4
SR		 130static ushort hbas_to_enumerate;
131module_param(hbas_to_enumerate, ushort, 0);
132MODULE_PARM_DESC(hbas_to_enumerate,
133 " 0 - enumerates both SAS 2.0 & SAS 3.0 generation HBAs\n \
134 1 - enumerates only SAS 2.0 generation HBAs\n \
135 2 - enumerates only SAS 3.0 generation HBAs (default=0)");
f92363d1
SR		 136
137/* diag_buffer_enable is bitwise
138 * bit 0 set = TRACE
139 * bit 1 set = SNAPSHOT
140 * bit 2 set = EXTENDED
141 *
142 * Either bit can be set, or both
143 */
144static int diag_buffer_enable = -1;
145module_param(diag_buffer_enable, int, 0);
146MODULE_PARM_DESC(diag_buffer_enable,
147 " post diag buffers (TRACE=1/SNAPSHOT=2/EXTENDED=4/default=0)");
148static int disable_discovery = -1;
149module_param(disable_discovery, int, 0);
150MODULE_PARM_DESC(disable_discovery, " disable discovery ");
151
152
153/* permit overriding the host protection capabilities mask (EEDP/T10 PI) */
154static int prot_mask = -1;
155module_param(prot_mask, int, 0);
156MODULE_PARM_DESC(prot_mask, " host protection capabilities mask, def=7 ");
157
158
159/* raid transport support */
cf6bf971
C		 160static struct raid_template *mpt3sas_raid_template;
161static struct raid_template *mpt2sas_raid_template;
f92363d1
SR		 162
163
164/**
165 * struct sense_info - common structure for obtaining sense keys
166 * @skey: sense key
167 * @asc: additional sense code
168 * @ascq: additional sense code qualifier
169 */
170struct sense_info {
171 u8 skey;
172 u8 asc;
173 u8 ascq;
174};
175
176#define MPT3SAS_PROCESS_TRIGGER_DIAG (0xFFFB)
0f624c39 177#define MPT3SAS_TURN_ON_PFA_LED (0xFFFC)
f92363d1
SR		 178#define MPT3SAS_PORT_ENABLE_COMPLETE (0xFFFD)
179#define MPT3SAS_ABRT_TASK_SET (0xFFFE)
180#define MPT3SAS_REMOVE_UNRESPONDING_DEVICES (0xFFFF)
181/**
182 * struct fw_event_work - firmware event struct
183 * @list: link list framework
184 * @work: work object (ioc->fault_reset_work_q)
f92363d1
SR		 185 * @ioc: per adapter object
186 * @device_handle: device handle
187 * @VF_ID: virtual function id
188 * @VP_ID: virtual port id
189 * @ignore: flag meaning this event has been marked to ignore
b8ac0cc7
JL		 190 * @event: firmware event MPI2_EVENT_XXX defined in mpi2_ioc.h
191 * @refcount: kref for this event
f92363d1
SR		 192 * @event_data: reply event data payload follows
193 *
194 * This object stored on ioc->fw_event_list.
195 */
196struct fw_event_work {
197 struct list_head list;
198 struct work_struct work;
f92363d1
SR		 199
200 struct MPT3SAS_ADAPTER *ioc;
201 u16 device_handle;
202 u8 VF_ID;
203 u8 VP_ID;
204 u8 ignore;
205 u16 event;
146b16c8 206 struct kref refcount;
35b62362 207 char event_data[0] __aligned(4);
f92363d1
SR		 208};
209
146b16c8
SR		 210static void fw_event_work_free(struct kref *r)
211{
212 kfree(container_of(r, struct fw_event_work, refcount));
213}
214
215static void fw_event_work_get(struct fw_event_work *fw_work)
216{
217 kref_get(&fw_work->refcount);
218}
219
220static void fw_event_work_put(struct fw_event_work *fw_work)
221{
222 kref_put(&fw_work->refcount, fw_event_work_free);
223}
224
225static struct fw_event_work *alloc_fw_event_work(int len)
226{
227 struct fw_event_work *fw_event;
228
229 fw_event = kzalloc(sizeof(*fw_event) + len, GFP_ATOMIC);
230 if (!fw_event)
231 return NULL;
232
233 kref_init(&fw_event->refcount);
234 return fw_event;
235}
236
f92363d1
SR		 237/**
238 * struct _scsi_io_transfer - scsi io transfer
239 * @handle: sas device handle (assigned by firmware)
240 * @is_raid: flag set for hidden raid components
241 * @dir: DMA_TO_DEVICE, DMA_FROM_DEVICE,
242 * @data_length: data transfer length
243 * @data_dma: dma pointer to data
244 * @sense: sense data
245 * @lun: lun number
246 * @cdb_length: cdb length
247 * @cdb: cdb contents
248 * @timeout: timeout for this command
249 * @VF_ID: virtual function id
250 * @VP_ID: virtual port id
251 * @valid_reply: flag set for reply message
252 * @sense_length: sense length
253 * @ioc_status: ioc status
254 * @scsi_state: scsi state
255 * @scsi_status: scsi staus
256 * @log_info: log information
257 * @transfer_length: data length transfer when there is a reply message
258 *
259 * Used for sending internal scsi commands to devices within this module.
260 * Refer to _scsi_send_scsi_io().
261 */
262struct _scsi_io_transfer {
263 u16 handle;
264 u8 is_raid;
265 enum dma_data_direction dir;
266 u32 data_length;
267 dma_addr_t data_dma;
268 u8 sense[SCSI_SENSE_BUFFERSIZE];
269 u32 lun;
270 u8 cdb_length;
271 u8 cdb[32];
272 u8 timeout;
273 u8 VF_ID;
274 u8 VP_ID;
275 u8 valid_reply;
276 /* the following bits are only valid when 'valid_reply = 1' */
277 u32 sense_length;
278 u16 ioc_status;
279 u8 scsi_state;
280 u8 scsi_status;
281 u32 log_info;
282 u32 transfer_length;
283};
284
f92363d1
SR		 285/**
286 * _scsih_set_debug_level - global setting of ioc->logging_level.
4beb4867
BVA		 287 * @val: ?
288 * @kp: ?
f92363d1
SR		 289 *
290 * Note: The logging levels are defined in mpt3sas_debug.h.
291 */
292static int
e4dca7b7 293_scsih_set_debug_level(const char *val, const struct kernel_param *kp)
f92363d1
SR		 294{
295 int ret = param_set_int(val, kp);
296 struct MPT3SAS_ADAPTER *ioc;
297
298 if (ret)
299 return ret;
300
301 pr_info("setting logging_level(0x%08x)\n", logging_level);
08c4d550 302 spin_lock(&gioc_lock);
f92363d1
SR		 303 list_for_each_entry(ioc, &mpt3sas_ioc_list, list)
304 ioc->logging_level = logging_level;
08c4d550 305 spin_unlock(&gioc_lock);
f92363d1
SR		 306 return 0;
307}
308module_param_call(logging_level, _scsih_set_debug_level, param_get_int,
309 &logging_level, 0644);
310
311/**
312 * _scsih_srch_boot_sas_address - search based on sas_address
313 * @sas_address: sas address
314 * @boot_device: boot device object from bios page 2
315 *
4beb4867 316 * Return: 1 when there's a match, 0 means no match.
f92363d1
SR		 317 */
318static inline int
319_scsih_srch_boot_sas_address(u64 sas_address,
320 Mpi2BootDeviceSasWwid_t *boot_device)
321{
322 return (sas_address == le64_to_cpu(boot_device->SASAddress)) ? 1 : 0;
323}
324
325/**
326 * _scsih_srch_boot_device_name - search based on device name
327 * @device_name: device name specified in INDENTIFY fram
328 * @boot_device: boot device object from bios page 2
329 *
4beb4867 330 * Return: 1 when there's a match, 0 means no match.
f92363d1
SR		 331 */
332static inline int
333_scsih_srch_boot_device_name(u64 device_name,
334 Mpi2BootDeviceDeviceName_t *boot_device)
335{
336 return (device_name == le64_to_cpu(boot_device->DeviceName)) ? 1 : 0;
337}
338
339/**
340 * _scsih_srch_boot_encl_slot - search based on enclosure_logical_id/slot
341 * @enclosure_logical_id: enclosure logical id
342 * @slot_number: slot number
343 * @boot_device: boot device object from bios page 2
344 *
4beb4867 345 * Return: 1 when there's a match, 0 means no match.
f92363d1
SR		 346 */
347static inline int
348_scsih_srch_boot_encl_slot(u64 enclosure_logical_id, u16 slot_number,
349 Mpi2BootDeviceEnclosureSlot_t *boot_device)
350{
351 return (enclosure_logical_id == le64_to_cpu(boot_device->
352 EnclosureLogicalID) && slot_number == le16_to_cpu(boot_device->
353 SlotNumber)) ? 1 : 0;
354}
355
356/**
357 * _scsih_is_boot_device - search for matching boot device.
358 * @sas_address: sas address
359 * @device_name: device name specified in INDENTIFY fram
360 * @enclosure_logical_id: enclosure logical id
4beb4867 361 * @slot: slot number
f92363d1
SR		 362 * @form: specifies boot device form
363 * @boot_device: boot device object from bios page 2
364 *
4beb4867 365 * Return: 1 when there's a match, 0 means no match.
f92363d1
SR		 366 */
367static int
368_scsih_is_boot_device(u64 sas_address, u64 device_name,
369 u64 enclosure_logical_id, u16 slot, u8 form,
370 Mpi2BiosPage2BootDevice_t *boot_device)
371{
372 int rc = 0;
373
374 switch (form) {
375 case MPI2_BIOSPAGE2_FORM_SAS_WWID:
376 if (!sas_address)
377 break;
378 rc = _scsih_srch_boot_sas_address(
379 sas_address, &boot_device->SasWwid);
380 break;
381 case MPI2_BIOSPAGE2_FORM_ENCLOSURE_SLOT:
382 if (!enclosure_logical_id)
383 break;
384 rc = _scsih_srch_boot_encl_slot(
385 enclosure_logical_id,
386 slot, &boot_device->EnclosureSlot);
387 break;
388 case MPI2_BIOSPAGE2_FORM_DEVICE_NAME:
389 if (!device_name)
390 break;
391 rc = _scsih_srch_boot_device_name(
392 device_name, &boot_device->DeviceName);
393 break;
394 case MPI2_BIOSPAGE2_FORM_NO_DEVICE_SPECIFIED:
395 break;
396 }
397
398 return rc;
399}
400
401/**
402 * _scsih_get_sas_address - set the sas_address for given device handle
4beb4867 403 * @ioc: ?
f92363d1
SR		 404 * @handle: device handle
405 * @sas_address: sas address
406 *
4beb4867 407 * Return: 0 success, non-zero when failure
f92363d1
SR		 408 */
409static int
410_scsih_get_sas_address(struct MPT3SAS_ADAPTER *ioc, u16 handle,
411 u64 *sas_address)
412{
413 Mpi2SasDevicePage0_t sas_device_pg0;
414 Mpi2ConfigReply_t mpi_reply;
415 u32 ioc_status;
416
417 *sas_address = 0;
418
f92363d1
SR		 419 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
420 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
919d8a3f
JP		 421 ioc_err(ioc, "failure at %s:%d/%s()!\n",
422 __FILE__, __LINE__, __func__);
f92363d1
SR		 423 return -ENXIO;
424 }
425
426 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
427 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
758f8139
SR		 428 /* For HBA, vSES doesn't return HBA SAS address. Instead return
429 * vSES's sas address.
430 */
431 if ((handle <= ioc->sas_hba.num_phys) &&
432 (!(le32_to_cpu(sas_device_pg0.DeviceInfo) &
433 MPI2_SAS_DEVICE_INFO_SEP)))
434 *sas_address = ioc->sas_hba.sas_address;
435 else
436 *sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
f92363d1
SR		 437 return 0;
438 }
439
6c7abffc 440 /* we hit this because the given parent handle doesn't exist */
f92363d1
SR		 441 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
442 return -ENXIO;
443
444 /* else error case */
919d8a3f
JP		 445 ioc_err(ioc, "handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n",
446 handle, ioc_status, __FILE__, __LINE__, __func__);
f92363d1
SR		 447 return -EIO;
448}
449
450/**
451 * _scsih_determine_boot_device - determine boot device.
452 * @ioc: per adapter object
d88e1eab
SPS		 453 * @device: sas_device or pcie_device object
454 * @channel: SAS or PCIe channel
f92363d1
SR		 455 *
456 * Determines whether this device should be first reported device to
457 * to scsi-ml or sas transport, this purpose is for persistent boot device.
458 * There are primary, alternate, and current entries in bios page 2. The order
459 * priority is primary, alternate, then current. This routine saves
d88e1eab 460 * the corresponding device object.
f92363d1
SR		 461 * The saved data to be used later in _scsih_probe_boot_devices().
462 */
463static void
d88e1eab
SPS		 464_scsih_determine_boot_device(struct MPT3SAS_ADAPTER *ioc, void *device,
465 u32 channel)
f92363d1
SR		 466{
467 struct _sas_device *sas_device;
d88e1eab 468 struct _pcie_device *pcie_device;
f92363d1
SR		 469 struct _raid_device *raid_device;
470 u64 sas_address;
471 u64 device_name;
472 u64 enclosure_logical_id;
473 u16 slot;
474
475 /* only process this function when driver loads */
476 if (!ioc->is_driver_loading)
477 return;
478
479 /* no Bios, return immediately */
480 if (!ioc->bios_pg3.BiosVersion)
481 return;
482
d88e1eab 483 if (channel == RAID_CHANNEL) {
f92363d1
SR		 484 raid_device = device;
485 sas_address = raid_device->wwid;
486 device_name = 0;
487 enclosure_logical_id = 0;
488 slot = 0;
d88e1eab
SPS		 489 } else if (channel == PCIE_CHANNEL) {
490 pcie_device = device;
491 sas_address = pcie_device->wwid;
492 device_name = 0;
493 enclosure_logical_id = 0;
494 slot = 0;
495 } else {
496 sas_device = device;
497 sas_address = sas_device->sas_address;
498 device_name = sas_device->device_name;
499 enclosure_logical_id = sas_device->enclosure_logical_id;
500 slot = sas_device->slot;
f92363d1
SR		 501 }
502
503 if (!ioc->req_boot_device.device) {
504 if (_scsih_is_boot_device(sas_address, device_name,
505 enclosure_logical_id, slot,
506 (ioc->bios_pg2.ReqBootDeviceForm &
507 MPI2_BIOSPAGE2_FORM_MASK),
508 &ioc->bios_pg2.RequestedBootDevice)) {
919d8a3f
JP		 509 dinitprintk(ioc,
510 ioc_info(ioc, "%s: req_boot_device(0x%016llx)\n",
511 __func__, (u64)sas_address));
f92363d1 512 ioc->req_boot_device.device = device;
d88e1eab 513 ioc->req_boot_device.channel = channel;
f92363d1
SR		 514 }
515 }
516
517 if (!ioc->req_alt_boot_device.device) {
518 if (_scsih_is_boot_device(sas_address, device_name,
519 enclosure_logical_id, slot,
520 (ioc->bios_pg2.ReqAltBootDeviceForm &
521 MPI2_BIOSPAGE2_FORM_MASK),
522 &ioc->bios_pg2.RequestedAltBootDevice)) {
919d8a3f
JP		 523 dinitprintk(ioc,
524 ioc_info(ioc, "%s: req_alt_boot_device(0x%016llx)\n",
525 __func__, (u64)sas_address));
f92363d1 526 ioc->req_alt_boot_device.device = device;
d88e1eab 527 ioc->req_alt_boot_device.channel = channel;
f92363d1
SR		 528 }
529 }
530
531 if (!ioc->current_boot_device.device) {
532 if (_scsih_is_boot_device(sas_address, device_name,
533 enclosure_logical_id, slot,
534 (ioc->bios_pg2.CurrentBootDeviceForm &
535 MPI2_BIOSPAGE2_FORM_MASK),
536 &ioc->bios_pg2.CurrentBootDevice)) {
919d8a3f
JP		 537 dinitprintk(ioc,
538 ioc_info(ioc, "%s: current_boot_device(0x%016llx)\n",
539 __func__, (u64)sas_address));
f92363d1 540 ioc->current_boot_device.device = device;
d88e1eab 541 ioc->current_boot_device.channel = channel;
f92363d1
SR		 542 }
543 }
544}
545
d1cb5e49
SR		 546static struct _sas_device *
547__mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc,
548 struct MPT3SAS_TARGET *tgt_priv)
549{
550 struct _sas_device *ret;
551
552 assert_spin_locked(&ioc->sas_device_lock);
553
d88e1eab 554 ret = tgt_priv->sas_dev;
d1cb5e49
SR		 555 if (ret)
556 sas_device_get(ret);
557
558 return ret;
559}
560
561static struct _sas_device *
562mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc,
563 struct MPT3SAS_TARGET *tgt_priv)
564{
565 struct _sas_device *ret;
566 unsigned long flags;
567
568 spin_lock_irqsave(&ioc->sas_device_lock, flags);
569 ret = __mpt3sas_get_sdev_from_target(ioc, tgt_priv);
570 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
571
572 return ret;
573}
574
d88e1eab
SPS		 575static struct _pcie_device *
576__mpt3sas_get_pdev_from_target(struct MPT3SAS_ADAPTER *ioc,
577 struct MPT3SAS_TARGET *tgt_priv)
578{
579 struct _pcie_device *ret;
580
581 assert_spin_locked(&ioc->pcie_device_lock);
582
583 ret = tgt_priv->pcie_dev;
584 if (ret)
585 pcie_device_get(ret);
586
587 return ret;
588}
589
590/**
591 * mpt3sas_get_pdev_from_target - pcie device search
592 * @ioc: per adapter object
593 * @tgt_priv: starget private object
594 *
595 * Context: This function will acquire ioc->pcie_device_lock and will release
596 * before returning the pcie_device object.
597 *
598 * This searches for pcie_device from target, then return pcie_device object.
599 */
494f401b 600static struct _pcie_device *
d88e1eab
SPS		 601mpt3sas_get_pdev_from_target(struct MPT3SAS_ADAPTER *ioc,
602 struct MPT3SAS_TARGET *tgt_priv)
603{
604 struct _pcie_device *ret;
605 unsigned long flags;
606
607 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
608 ret = __mpt3sas_get_pdev_from_target(ioc, tgt_priv);
609 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
610
611 return ret;
612}
d1cb5e49
SR		 613
614struct _sas_device *
615__mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc,
616 u64 sas_address)
617{
618 struct _sas_device *sas_device;
619
620 assert_spin_locked(&ioc->sas_device_lock);
621
622 list_for_each_entry(sas_device, &ioc->sas_device_list, list)
623 if (sas_device->sas_address == sas_address)
624 goto found_device;
625
626 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
627 if (sas_device->sas_address == sas_address)
628 goto found_device;
629
630 return NULL;
631
632found_device:
633 sas_device_get(sas_device);
634 return sas_device;
635}
636
f92363d1 637/**
d1cb5e49 638 * mpt3sas_get_sdev_by_addr - sas device search
f92363d1
SR		 639 * @ioc: per adapter object
640 * @sas_address: sas address
641 * Context: Calling function should acquire ioc->sas_device_lock
642 *
643 * This searches for sas_device based on sas_address, then return sas_device
644 * object.
645 */
646struct _sas_device *
d1cb5e49 647mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc,
f92363d1
SR		 648 u64 sas_address)
649{
650 struct _sas_device *sas_device;
d1cb5e49
SR		 651 unsigned long flags;
652
653 spin_lock_irqsave(&ioc->sas_device_lock, flags);
654 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
655 sas_address);
656 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
657
658 return sas_device;
659}
660
661static struct _sas_device *
662__mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
663{
664 struct _sas_device *sas_device;
665
666 assert_spin_locked(&ioc->sas_device_lock);
f92363d1
SR		 667
668 list_for_each_entry(sas_device, &ioc->sas_device_list, list)
d1cb5e49
SR		 669 if (sas_device->handle == handle)
670 goto found_device;
f92363d1
SR		 671
672 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
d1cb5e49
SR		 673 if (sas_device->handle == handle)
674 goto found_device;
f92363d1
SR		 675
676 return NULL;
d1cb5e49
SR		 677
678found_device:
679 sas_device_get(sas_device);
680 return sas_device;
f92363d1
SR		 681}
682
683/**
d1cb5e49 684 * mpt3sas_get_sdev_by_handle - sas device search
f92363d1
SR		 685 * @ioc: per adapter object
686 * @handle: sas device handle (assigned by firmware)
687 * Context: Calling function should acquire ioc->sas_device_lock
688 *
689 * This searches for sas_device based on sas_address, then return sas_device
690 * object.
691 */
c102e00c 692struct _sas_device *
d1cb5e49 693mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
f92363d1
SR		 694{
695 struct _sas_device *sas_device;
d1cb5e49 696 unsigned long flags;
f92363d1 697
d1cb5e49
SR		 698 spin_lock_irqsave(&ioc->sas_device_lock, flags);
699 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
700 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
f92363d1 701
d1cb5e49 702 return sas_device;
f92363d1
SR		 703}
704
75888956
SR		 705/**
706 * _scsih_display_enclosure_chassis_info - display device location info
707 * @ioc: per adapter object
708 * @sas_device: per sas device object
709 * @sdev: scsi device struct
710 * @starget: scsi target struct
75888956
SR		 711 */
712static void
713_scsih_display_enclosure_chassis_info(struct MPT3SAS_ADAPTER *ioc,
714 struct _sas_device *sas_device, struct scsi_device *sdev,
715 struct scsi_target *starget)
716{
717 if (sdev) {
718 if (sas_device->enclosure_handle != 0)
719 sdev_printk(KERN_INFO, sdev,
720 "enclosure logical id (0x%016llx), slot(%d) \n",
721 (unsigned long long)
722 sas_device->enclosure_logical_id,
723 sas_device->slot);
724 if (sas_device->connector_name[0] != '\0')
725 sdev_printk(KERN_INFO, sdev,
726 "enclosure level(0x%04x), connector name( %s)\n",
727 sas_device->enclosure_level,
728 sas_device->connector_name);
729 if (sas_device->is_chassis_slot_valid)
730 sdev_printk(KERN_INFO, sdev, "chassis slot(0x%04x)\n",
731 sas_device->chassis_slot);
732 } else if (starget) {
733 if (sas_device->enclosure_handle != 0)
734 starget_printk(KERN_INFO, starget,
735 "enclosure logical id(0x%016llx), slot(%d) \n",
736 (unsigned long long)
737 sas_device->enclosure_logical_id,
738 sas_device->slot);
739 if (sas_device->connector_name[0] != '\0')
740 starget_printk(KERN_INFO, starget,
741 "enclosure level(0x%04x), connector name( %s)\n",
742 sas_device->enclosure_level,
743 sas_device->connector_name);
744 if (sas_device->is_chassis_slot_valid)
745 starget_printk(KERN_INFO, starget,
746 "chassis slot(0x%04x)\n",
747 sas_device->chassis_slot);
748 } else {
749 if (sas_device->enclosure_handle != 0)
919d8a3f
JP		 750 ioc_info(ioc, "enclosure logical id(0x%016llx), slot(%d)\n",
751 (u64)sas_device->enclosure_logical_id,
752 sas_device->slot);
75888956 753 if (sas_device->connector_name[0] != '\0')
919d8a3f
JP		 754 ioc_info(ioc, "enclosure level(0x%04x), connector name( %s)\n",
755 sas_device->enclosure_level,
756 sas_device->connector_name);
75888956 757 if (sas_device->is_chassis_slot_valid)
919d8a3f
JP		 758 ioc_info(ioc, "chassis slot(0x%04x)\n",
759 sas_device->chassis_slot);
75888956
SR		 760 }
761}
762
f92363d1
SR		 763/**
764 * _scsih_sas_device_remove - remove sas_device from list.
765 * @ioc: per adapter object
766 * @sas_device: the sas_device object
767 * Context: This function will acquire ioc->sas_device_lock.
768 *
d1cb5e49 769 * If sas_device is on the list, remove it and decrement its reference count.
f92363d1
SR		 770 */
771static void
772_scsih_sas_device_remove(struct MPT3SAS_ADAPTER *ioc,
773 struct _sas_device *sas_device)
774{
775 unsigned long flags;
776
777 if (!sas_device)
778 return;
919d8a3f
JP		 779 ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n",
780 sas_device->handle, (u64)sas_device->sas_address);
e6d45e3e 781
75888956 782 _scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL);
f92363d1 783
d1cb5e49
SR		 784 /*
785 * The lock serializes access to the list, but we still need to verify
786 * that nobody removed the entry while we were waiting on the lock.
787 */
f92363d1 788 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49
SR		 789 if (!list_empty(&sas_device->list)) {
790 list_del_init(&sas_device->list);
791 sas_device_put(sas_device);
792 }
f92363d1
SR		 793 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
794}
795
796/**
797 * _scsih_device_remove_by_handle - removing device object by handle
798 * @ioc: per adapter object
799 * @handle: device handle
f92363d1
SR		 800 */
801static void
802_scsih_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
803{
804 struct _sas_device *sas_device;
805 unsigned long flags;
806
807 if (ioc->shost_recovery)
808 return;
809
810 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49
SR		 811 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
812 if (sas_device) {
813 list_del_init(&sas_device->list);
814 sas_device_put(sas_device);
815 }
f92363d1 816 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
d1cb5e49 817 if (sas_device) {
f92363d1 818 _scsih_remove_device(ioc, sas_device);
d1cb5e49
SR		 819 sas_device_put(sas_device);
820 }
f92363d1
SR		 821}
822
823/**
824 * mpt3sas_device_remove_by_sas_address - removing device object by sas address
825 * @ioc: per adapter object
826 * @sas_address: device sas_address
f92363d1
SR		 827 */
828void
829mpt3sas_device_remove_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
830 u64 sas_address)
831{
832 struct _sas_device *sas_device;
833 unsigned long flags;
834
835 if (ioc->shost_recovery)
836 return;
837
838 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49
SR		 839 sas_device = __mpt3sas_get_sdev_by_addr(ioc, sas_address);
840 if (sas_device) {
841 list_del_init(&sas_device->list);
842 sas_device_put(sas_device);
843 }
f92363d1 844 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
d1cb5e49 845 if (sas_device) {
f92363d1 846 _scsih_remove_device(ioc, sas_device);
d1cb5e49
SR		 847 sas_device_put(sas_device);
848 }
f92363d1
SR		 849}
850
851/**
852 * _scsih_sas_device_add - insert sas_device to the list.
853 * @ioc: per adapter object
854 * @sas_device: the sas_device object
855 * Context: This function will acquire ioc->sas_device_lock.
856 *
857 * Adding new object to the ioc->sas_device_list.
858 */
859static void
860_scsih_sas_device_add(struct MPT3SAS_ADAPTER *ioc,
861 struct _sas_device *sas_device)
862{
863 unsigned long flags;
864
919d8a3f
JP		 865 dewtprintk(ioc,
866 ioc_info(ioc, "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
867 __func__, sas_device->handle,
868 (u64)sas_device->sas_address));
f92363d1 869
75888956
SR		 870 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
871 NULL, NULL));
e6d45e3e 872
f92363d1 873 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49 874 sas_device_get(sas_device);
f92363d1
SR		 875 list_add_tail(&sas_device->list, &ioc->sas_device_list);
876 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
877
c696f7b8
SPS		 878 if (ioc->hide_drives) {
879 clear_bit(sas_device->handle, ioc->pend_os_device_add);
880 return;
881 }
882
f92363d1
SR		 883 if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
884 sas_device->sas_address_parent)) {
885 _scsih_sas_device_remove(ioc, sas_device);
886 } else if (!sas_device->starget) {
887 /*
888 * When asyn scanning is enabled, its not possible to remove
889 * devices while scanning is turned on due to an oops in
890 * scsi_sysfs_add_sdev()->add_device()->sysfs_addrm_start()
891 */
f5edbe77 892 if (!ioc->is_driver_loading) {
f92363d1
SR		 893 mpt3sas_transport_port_remove(ioc,
894 sas_device->sas_address,
895 sas_device->sas_address_parent);
f5edbe77
SR		 896 _scsih_sas_device_remove(ioc, sas_device);
897 }
c696f7b8
SPS		 898 } else
899 clear_bit(sas_device->handle, ioc->pend_os_device_add);
f92363d1
SR		 900}
901
902/**
903 * _scsih_sas_device_init_add - insert sas_device to the list.
904 * @ioc: per adapter object
905 * @sas_device: the sas_device object
906 * Context: This function will acquire ioc->sas_device_lock.
907 *
908 * Adding new object at driver load time to the ioc->sas_device_init_list.
909 */
910static void
911_scsih_sas_device_init_add(struct MPT3SAS_ADAPTER *ioc,
912 struct _sas_device *sas_device)
913{
914 unsigned long flags;
915
919d8a3f
JP		 916 dewtprintk(ioc,
917 ioc_info(ioc, "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
918 __func__, sas_device->handle,
919 (u64)sas_device->sas_address));
f92363d1 920
75888956
SR		 921 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
922 NULL, NULL));
e6d45e3e 923
f92363d1 924 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49 925 sas_device_get(sas_device);
f92363d1
SR		 926 list_add_tail(&sas_device->list, &ioc->sas_device_init_list);
927 _scsih_determine_boot_device(ioc, sas_device, 0);
928 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
929}
930
d88e1eab 931
494f401b 932static struct _pcie_device *
d88e1eab
SPS		 933__mpt3sas_get_pdev_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
934{
935 struct _pcie_device *pcie_device;
936
937 assert_spin_locked(&ioc->pcie_device_lock);
938
939 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list)
940 if (pcie_device->wwid == wwid)
941 goto found_device;
942
943 list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list)
944 if (pcie_device->wwid == wwid)
945 goto found_device;
946
947 return NULL;
948
949found_device:
950 pcie_device_get(pcie_device);
951 return pcie_device;
952}
953
954
955/**
956 * mpt3sas_get_pdev_by_wwid - pcie device search
957 * @ioc: per adapter object
958 * @wwid: wwid
959 *
960 * Context: This function will acquire ioc->pcie_device_lock and will release
961 * before returning the pcie_device object.
962 *
963 * This searches for pcie_device based on wwid, then return pcie_device object.
964 */
494f401b 965static struct _pcie_device *
d88e1eab
SPS		 966mpt3sas_get_pdev_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
967{
968 struct _pcie_device *pcie_device;
969 unsigned long flags;
970
971 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
972 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
973 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
974
975 return pcie_device;
976}
977
978
494f401b 979static struct _pcie_device *
d88e1eab
SPS		 980__mpt3sas_get_pdev_by_idchannel(struct MPT3SAS_ADAPTER *ioc, int id,
981 int channel)
982{
983 struct _pcie_device *pcie_device;
984
985 assert_spin_locked(&ioc->pcie_device_lock);
986
987 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list)
988 if (pcie_device->id == id && pcie_device->channel == channel)
989 goto found_device;
990
991 list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list)
992 if (pcie_device->id == id && pcie_device->channel == channel)
993 goto found_device;
994
995 return NULL;
996
997found_device:
998 pcie_device_get(pcie_device);
999 return pcie_device;
1000}
1001
494f401b 1002static struct _pcie_device *
c102e00c
SPS		 1003__mpt3sas_get_pdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1004{
1005 struct _pcie_device *pcie_device;
1006
1007 assert_spin_locked(&ioc->pcie_device_lock);
1008
1009 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list)
1010 if (pcie_device->handle == handle)
1011 goto found_device;
1012
1013 list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list)
1014 if (pcie_device->handle == handle)
1015 goto found_device;
1016
1017 return NULL;
1018
1019found_device:
1020 pcie_device_get(pcie_device);
1021 return pcie_device;
1022}
1023
1024
1025/**
1026 * mpt3sas_get_pdev_by_handle - pcie device search
1027 * @ioc: per adapter object
1028 * @handle: Firmware device handle
1029 *
1030 * Context: This function will acquire ioc->pcie_device_lock and will release
1031 * before returning the pcie_device object.
1032 *
1033 * This searches for pcie_device based on handle, then return pcie_device
1034 * object.
1035 */
1036struct _pcie_device *
1037mpt3sas_get_pdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1038{
1039 struct _pcie_device *pcie_device;
1040 unsigned long flags;
1041
1042 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1043 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
1044 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1045
1046 return pcie_device;
1047}
1048
d88e1eab
SPS		 1049/**
1050 * _scsih_pcie_device_remove - remove pcie_device from list.
1051 * @ioc: per adapter object
1052 * @pcie_device: the pcie_device object
1053 * Context: This function will acquire ioc->pcie_device_lock.
1054 *
1055 * If pcie_device is on the list, remove it and decrement its reference count.
1056 */
1057static void
1058_scsih_pcie_device_remove(struct MPT3SAS_ADAPTER *ioc,
1059 struct _pcie_device *pcie_device)
1060{
1061 unsigned long flags;
1062 int was_on_pcie_device_list = 0;
1063
1064 if (!pcie_device)
1065 return;
919d8a3f
JP		 1066 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
1067 pcie_device->handle, (u64)pcie_device->wwid);
d88e1eab 1068 if (pcie_device->enclosure_handle != 0)
919d8a3f
JP		 1069 ioc_info(ioc, "removing enclosure logical id(0x%016llx), slot(%d)\n",
1070 (u64)pcie_device->enclosure_logical_id,
1071 pcie_device->slot);
d88e1eab 1072 if (pcie_device->connector_name[0] != '\0')
919d8a3f
JP		 1073 ioc_info(ioc, "removing enclosure level(0x%04x), connector name( %s)\n",
1074 pcie_device->enclosure_level,
1075 pcie_device->connector_name);
d88e1eab
SPS		 1076
1077 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1078 if (!list_empty(&pcie_device->list)) {
1079 list_del_init(&pcie_device->list);
1080 was_on_pcie_device_list = 1;
1081 }
1082 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1083 if (was_on_pcie_device_list) {
1084 kfree(pcie_device->serial_number);
1085 pcie_device_put(pcie_device);
1086 }
1087}
3075ac49
SPS		 1088
1089
1090/**
1091 * _scsih_pcie_device_remove_by_handle - removing pcie device object by handle
1092 * @ioc: per adapter object
1093 * @handle: device handle
3075ac49
SPS		 1094 */
1095static void
1096_scsih_pcie_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1097{
1098 struct _pcie_device *pcie_device;
1099 unsigned long flags;
1100 int was_on_pcie_device_list = 0;
1101
1102 if (ioc->shost_recovery)
1103 return;
1104
1105 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1106 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
1107 if (pcie_device) {
1108 if (!list_empty(&pcie_device->list)) {
1109 list_del_init(&pcie_device->list);
1110 was_on_pcie_device_list = 1;
1111 pcie_device_put(pcie_device);
1112 }
1113 }
1114 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1115 if (was_on_pcie_device_list) {
1116 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
1117 pcie_device_put(pcie_device);
1118 }
1119}
1120
c102e00c
SPS		 1121/**
1122 * _scsih_pcie_device_add - add pcie_device object
1123 * @ioc: per adapter object
1124 * @pcie_device: pcie_device object
1125 *
1126 * This is added to the pcie_device_list link list.
1127 */
1128static void
1129_scsih_pcie_device_add(struct MPT3SAS_ADAPTER *ioc,
1130 struct _pcie_device *pcie_device)
1131{
1132 unsigned long flags;
1133
919d8a3f
JP		 1134 dewtprintk(ioc,
1135 ioc_info(ioc, "%s: handle (0x%04x), wwid(0x%016llx)\n",
1136 __func__,
1137 pcie_device->handle, (u64)pcie_device->wwid));
c102e00c 1138 if (pcie_device->enclosure_handle != 0)
919d8a3f
JP		 1139 dewtprintk(ioc,
1140 ioc_info(ioc, "%s: enclosure logical id(0x%016llx), slot( %d)\n",
1141 __func__,
1142 (u64)pcie_device->enclosure_logical_id,
1143 pcie_device->slot));
c102e00c 1144 if (pcie_device->connector_name[0] != '\0')
919d8a3f
JP		 1145 dewtprintk(ioc,
1146 ioc_info(ioc, "%s: enclosure level(0x%04x), connector name( %s)\n",
1147 __func__, pcie_device->enclosure_level,
1148 pcie_device->connector_name));
c102e00c
SPS		 1149
1150 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1151 pcie_device_get(pcie_device);
1152 list_add_tail(&pcie_device->list, &ioc->pcie_device_list);
1153 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1154
1155 if (scsi_add_device(ioc->shost, PCIE_CHANNEL, pcie_device->id, 0)) {
1156 _scsih_pcie_device_remove(ioc, pcie_device);
1157 } else if (!pcie_device->starget) {
1158 if (!ioc->is_driver_loading) {
1159/*TODO-- Need to find out whether this condition will occur or not*/
1160 clear_bit(pcie_device->handle, ioc->pend_os_device_add);
1161 }
1162 } else
1163 clear_bit(pcie_device->handle, ioc->pend_os_device_add);
1164}
1165
1166/*
1167 * _scsih_pcie_device_init_add - insert pcie_device to the init list.
1168 * @ioc: per adapter object
1169 * @pcie_device: the pcie_device object
1170 * Context: This function will acquire ioc->pcie_device_lock.
1171 *
1172 * Adding new object at driver load time to the ioc->pcie_device_init_list.
1173 */
1174static void
1175_scsih_pcie_device_init_add(struct MPT3SAS_ADAPTER *ioc,
1176 struct _pcie_device *pcie_device)
1177{
1178 unsigned long flags;
1179
919d8a3f
JP		 1180 dewtprintk(ioc,
1181 ioc_info(ioc, "%s: handle (0x%04x), wwid(0x%016llx)\n",
1182 __func__,
1183 pcie_device->handle, (u64)pcie_device->wwid));
c102e00c 1184 if (pcie_device->enclosure_handle != 0)
919d8a3f
JP		 1185 dewtprintk(ioc,
1186 ioc_info(ioc, "%s: enclosure logical id(0x%016llx), slot( %d)\n",
1187 __func__,
1188 (u64)pcie_device->enclosure_logical_id,
1189 pcie_device->slot));
c102e00c 1190 if (pcie_device->connector_name[0] != '\0')
919d8a3f
JP		 1191 dewtprintk(ioc,
1192 ioc_info(ioc, "%s: enclosure level(0x%04x), connector name( %s)\n",
1193 __func__, pcie_device->enclosure_level,
1194 pcie_device->connector_name));
c102e00c
SPS		 1195
1196 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1197 pcie_device_get(pcie_device);
1198 list_add_tail(&pcie_device->list, &ioc->pcie_device_init_list);
1199 _scsih_determine_boot_device(ioc, pcie_device, PCIE_CHANNEL);
1200 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1201}
f92363d1
SR		 1202/**
1203 * _scsih_raid_device_find_by_id - raid device search
1204 * @ioc: per adapter object
1205 * @id: sas device target id
1206 * @channel: sas device channel
1207 * Context: Calling function should acquire ioc->raid_device_lock
1208 *
1209 * This searches for raid_device based on target id, then return raid_device
1210 * object.
1211 */
1212static struct _raid_device *
1213_scsih_raid_device_find_by_id(struct MPT3SAS_ADAPTER *ioc, int id, int channel)
1214{
1215 struct _raid_device *raid_device, *r;
1216
1217 r = NULL;
1218 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1219 if (raid_device->id == id && raid_device->channel == channel) {
1220 r = raid_device;
1221 goto out;
1222 }
1223 }
1224
1225 out:
1226 return r;
1227}
1228
1229/**
c84b06a4 1230 * mpt3sas_raid_device_find_by_handle - raid device search
f92363d1
SR		 1231 * @ioc: per adapter object
1232 * @handle: sas device handle (assigned by firmware)
1233 * Context: Calling function should acquire ioc->raid_device_lock
1234 *
1235 * This searches for raid_device based on handle, then return raid_device
1236 * object.
1237 */
c84b06a4
SR		 1238struct _raid_device *
1239mpt3sas_raid_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
f92363d1
SR		 1240{
1241 struct _raid_device *raid_device, *r;
1242
1243 r = NULL;
1244 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1245 if (raid_device->handle != handle)
1246 continue;
1247 r = raid_device;
1248 goto out;
1249 }
1250
1251 out:
1252 return r;
1253}
1254
1255/**
1256 * _scsih_raid_device_find_by_wwid - raid device search
1257 * @ioc: per adapter object
4beb4867 1258 * @wwid: ?
f92363d1
SR		 1259 * Context: Calling function should acquire ioc->raid_device_lock
1260 *
1261 * This searches for raid_device based on wwid, then return raid_device
1262 * object.
1263 */
1264static struct _raid_device *
1265_scsih_raid_device_find_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
1266{
1267 struct _raid_device *raid_device, *r;
1268
1269 r = NULL;
1270 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1271 if (raid_device->wwid != wwid)
1272 continue;
1273 r = raid_device;
1274 goto out;
1275 }
1276
1277 out:
1278 return r;
1279}
1280
1281/**
1282 * _scsih_raid_device_add - add raid_device object
1283 * @ioc: per adapter object
1284 * @raid_device: raid_device object
1285 *
1286 * This is added to the raid_device_list link list.
1287 */
1288static void
1289_scsih_raid_device_add(struct MPT3SAS_ADAPTER *ioc,
1290 struct _raid_device *raid_device)
1291{
1292 unsigned long flags;
1293
919d8a3f
JP		 1294 dewtprintk(ioc,
1295 ioc_info(ioc, "%s: handle(0x%04x), wwid(0x%016llx)\n",
1296 __func__,
1297 raid_device->handle, (u64)raid_device->wwid));
f92363d1
SR		 1298
1299 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1300 list_add_tail(&raid_device->list, &ioc->raid_device_list);
1301 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1302}
1303
1304/**
1305 * _scsih_raid_device_remove - delete raid_device object
1306 * @ioc: per adapter object
1307 * @raid_device: raid_device object
1308 *
1309 */
1310static void
1311_scsih_raid_device_remove(struct MPT3SAS_ADAPTER *ioc,
1312 struct _raid_device *raid_device)
1313{
1314 unsigned long flags;
1315
1316 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1317 list_del(&raid_device->list);
1318 kfree(raid_device);
1319 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1320}
1321
1322/**
1323 * mpt3sas_scsih_expander_find_by_handle - expander device search
1324 * @ioc: per adapter object
1325 * @handle: expander handle (assigned by firmware)
1326 * Context: Calling function should acquire ioc->sas_device_lock
1327 *
1328 * This searches for expander device based on handle, then returns the
1329 * sas_node object.
1330 */
1331struct _sas_node *
1332mpt3sas_scsih_expander_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1333{
1334 struct _sas_node *sas_expander, *r;
1335
1336 r = NULL;
1337 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
1338 if (sas_expander->handle != handle)
1339 continue;
1340 r = sas_expander;
1341 goto out;
1342 }
1343 out:
1344 return r;
1345}
1346
22a923c3
C		 1347/**
1348 * mpt3sas_scsih_enclosure_find_by_handle - exclosure device search
1349 * @ioc: per adapter object
1350 * @handle: enclosure handle (assigned by firmware)
1351 * Context: Calling function should acquire ioc->sas_device_lock
1352 *
1353 * This searches for enclosure device based on handle, then returns the
1354 * enclosure object.
1355 */
1356static struct _enclosure_node *
1357mpt3sas_scsih_enclosure_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1358{
1359 struct _enclosure_node *enclosure_dev, *r;
1360
1361 r = NULL;
1362 list_for_each_entry(enclosure_dev, &ioc->enclosure_list, list) {
1363 if (le16_to_cpu(enclosure_dev->pg0.EnclosureHandle) != handle)
1364 continue;
1365 r = enclosure_dev;
1366 goto out;
1367 }
1368out:
1369 return r;
1370}
f92363d1
SR		 1371/**
1372 * mpt3sas_scsih_expander_find_by_sas_address - expander device search
1373 * @ioc: per adapter object
1374 * @sas_address: sas address
1375 * Context: Calling function should acquire ioc->sas_node_lock.
1376 *
1377 * This searches for expander device based on sas_address, then returns the
1378 * sas_node object.
1379 */
1380struct _sas_node *
1381mpt3sas_scsih_expander_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
1382 u64 sas_address)
1383{
1384 struct _sas_node *sas_expander, *r;
1385
1386 r = NULL;
1387 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
1388 if (sas_expander->sas_address != sas_address)
1389 continue;
1390 r = sas_expander;
1391 goto out;
1392 }
1393 out:
1394 return r;
1395}
1396
1397/**
1398 * _scsih_expander_node_add - insert expander device to the list.
1399 * @ioc: per adapter object
1400 * @sas_expander: the sas_device object
1401 * Context: This function will acquire ioc->sas_node_lock.
1402 *
1403 * Adding new object to the ioc->sas_expander_list.
f92363d1
SR		 1404 */
1405static void
1406_scsih_expander_node_add(struct MPT3SAS_ADAPTER *ioc,
1407 struct _sas_node *sas_expander)
1408{
1409 unsigned long flags;
1410
1411 spin_lock_irqsave(&ioc->sas_node_lock, flags);
1412 list_add_tail(&sas_expander->list, &ioc->sas_expander_list);
1413 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1414}
1415
1416/**
1417 * _scsih_is_end_device - determines if device is an end device
1418 * @device_info: bitfield providing information about the device.
1419 * Context: none
1420 *
4beb4867 1421 * Return: 1 if end device.
f92363d1
SR		 1422 */
1423static int
1424_scsih_is_end_device(u32 device_info)
1425{
1426 if (device_info & MPI2_SAS_DEVICE_INFO_END_DEVICE &&
1427 ((device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) |
1428 (device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET) |
1429 (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)))
1430 return 1;
1431 else
1432 return 0;
1433}
1434
c102e00c
SPS		 1435/**
1436 * _scsih_is_nvme_device - determines if device is an nvme device
1437 * @device_info: bitfield providing information about the device.
1438 * Context: none
1439 *
4beb4867 1440 * Return: 1 if nvme device.
c102e00c
SPS		 1441 */
1442static int
1443_scsih_is_nvme_device(u32 device_info)
1444{
1445 if ((device_info & MPI26_PCIE_DEVINFO_MASK_DEVICE_TYPE)
1446 == MPI26_PCIE_DEVINFO_NVME)
1447 return 1;
1448 else
1449 return 0;
1450}
1451
459325c4 1452/**
dbec4c90 1453 * mpt3sas_scsih_scsi_lookup_get - returns scmd entry
459325c4
C		 1454 * @ioc: per adapter object
1455 * @smid: system request message index
1456 *
4beb4867 1457 * Return: the smid stored scmd pointer.
459325c4
C		 1458 * Then will dereference the stored scmd pointer.
1459 */
dbec4c90
SPS		 1460struct scsi_cmnd *
1461mpt3sas_scsih_scsi_lookup_get(struct MPT3SAS_ADAPTER *ioc, u16 smid)
459325c4
C		 1462{
1463 struct scsi_cmnd *scmd = NULL;
dbec4c90 1464 struct scsiio_tracker *st;
c2fe742f 1465 Mpi25SCSIIORequest_t *mpi_request;
459325c4 1466
dbec4c90
SPS		 1467 if (smid > 0 &&
1468 smid <= ioc->scsiio_depth - INTERNAL_SCSIIO_CMDS_COUNT) {
1469 u32 unique_tag = smid - 1;
f92363d1 1470
c2fe742f
SR		 1471 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1472
1473 /*
1474 * If SCSI IO request is outstanding at driver level then
1475 * DevHandle filed must be non-zero. If DevHandle is zero
1476 * then it means that this smid is free at driver level,
1477 * so return NULL.
1478 */
1479 if (!mpi_request->DevHandle)
1480 return scmd;
1481
dbec4c90
SPS		 1482 scmd = scsi_host_find_tag(ioc->shost, unique_tag);
1483 if (scmd) {
1484 st = scsi_cmd_priv(scmd);
e7018314 1485 if (st->cb_idx == 0xFF || st->smid == 0)
dbec4c90 1486 scmd = NULL;
f92363d1
SR		 1487 }
1488 }
dbec4c90 1489 return scmd;
f92363d1
SR		 1490}
1491
cf75d5d6 1492/**
8a7e4c24 1493 * scsih_change_queue_depth - setting device queue depth
cf75d5d6
CH		 1494 * @sdev: scsi device struct
1495 * @qdepth: requested queue depth
1496 *
4beb4867 1497 * Return: queue depth.
cf75d5d6 1498 */
8bbb1cf6 1499static int
8a7e4c24 1500scsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
f92363d1
SR		 1501{
1502 struct Scsi_Host *shost = sdev->host;
1503 int max_depth;
1504 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1505 struct MPT3SAS_DEVICE *sas_device_priv_data;
1506 struct MPT3SAS_TARGET *sas_target_priv_data;
1507 struct _sas_device *sas_device;
1508 unsigned long flags;
1509
1510 max_depth = shost->can_queue;
1511
1512 /* limit max device queue for SATA to 32 */
1513 sas_device_priv_data = sdev->hostdata;
1514 if (!sas_device_priv_data)
1515 goto not_sata;
1516 sas_target_priv_data = sas_device_priv_data->sas_target;
1517 if (!sas_target_priv_data)
1518 goto not_sata;
1519 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))
1520 goto not_sata;
d1cb5e49 1521
f92363d1 1522 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49
SR		 1523 sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data);
1524 if (sas_device) {
1525 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
1526 max_depth = MPT3SAS_SATA_QUEUE_DEPTH;
1527
1528 sas_device_put(sas_device);
1529 }
f92363d1
SR		 1530 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1531
1532 not_sata:
1533
1534 if (!sdev->tagged_supported)
1535 max_depth = 1;
1536 if (qdepth > max_depth)
1537 qdepth = max_depth;
cf75d5d6 1538 return scsi_change_queue_depth(sdev, qdepth);
f92363d1
SR		 1539}
1540
f92363d1 1541/**
8a7e4c24 1542 * scsih_target_alloc - target add routine
f92363d1
SR		 1543 * @starget: scsi target struct
1544 *
4beb4867 1545 * Return: 0 if ok. Any other return is assumed to be an error and
f92363d1
SR		 1546 * the device is ignored.
1547 */
8bbb1cf6 1548static int
8a7e4c24 1549scsih_target_alloc(struct scsi_target *starget)
f92363d1
SR		 1550{
1551 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1552 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1553 struct MPT3SAS_TARGET *sas_target_priv_data;
1554 struct _sas_device *sas_device;
1555 struct _raid_device *raid_device;
d88e1eab 1556 struct _pcie_device *pcie_device;
f92363d1
SR		 1557 unsigned long flags;
1558 struct sas_rphy *rphy;
1559
62c4da44
JL		 1560 sas_target_priv_data = kzalloc(sizeof(*sas_target_priv_data),
1561 GFP_KERNEL);
f92363d1
SR		 1562 if (!sas_target_priv_data)
1563 return -ENOMEM;
1564
1565 starget->hostdata = sas_target_priv_data;
1566 sas_target_priv_data->starget = starget;
1567 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
1568
1569 /* RAID volumes */
1570 if (starget->channel == RAID_CHANNEL) {
1571 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1572 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1573 starget->channel);
1574 if (raid_device) {
1575 sas_target_priv_data->handle = raid_device->handle;
1576 sas_target_priv_data->sas_address = raid_device->wwid;
1577 sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME;
7786ab6a 1578 if (ioc->is_warpdrive)
6d3a56ed
SR		 1579 sas_target_priv_data->raid_device = raid_device;
1580 raid_device->starget = starget;
f92363d1
SR		 1581 }
1582 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1583 return 0;
1584 }
1585
d88e1eab
SPS		 1586 /* PCIe devices */
1587 if (starget->channel == PCIE_CHANNEL) {
1588 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1589 pcie_device = __mpt3sas_get_pdev_by_idchannel(ioc, starget->id,
1590 starget->channel);
1591 if (pcie_device) {
1592 sas_target_priv_data->handle = pcie_device->handle;
1593 sas_target_priv_data->sas_address = pcie_device->wwid;
1594 sas_target_priv_data->pcie_dev = pcie_device;
1595 pcie_device->starget = starget;
1596 pcie_device->id = starget->id;
1597 pcie_device->channel = starget->channel;
1598 sas_target_priv_data->flags |=
1599 MPT_TARGET_FLAGS_PCIE_DEVICE;
1600 if (pcie_device->fast_path)
1601 sas_target_priv_data->flags |=
1602 MPT_TARGET_FASTPATH_IO;
1603 }
1604 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1605 return 0;
1606 }
1607
f92363d1
SR		 1608 /* sas/sata devices */
1609 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1610 rphy = dev_to_rphy(starget->dev.parent);
d1cb5e49 1611 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
f92363d1
SR		 1612 rphy->identify.sas_address);
1613
1614 if (sas_device) {
1615 sas_target_priv_data->handle = sas_device->handle;
1616 sas_target_priv_data->sas_address = sas_device->sas_address;
d88e1eab 1617 sas_target_priv_data->sas_dev = sas_device;
f92363d1
SR		 1618 sas_device->starget = starget;
1619 sas_device->id = starget->id;
1620 sas_device->channel = starget->channel;
1621 if (test_bit(sas_device->handle, ioc->pd_handles))
1622 sas_target_priv_data->flags |=
1623 MPT_TARGET_FLAGS_RAID_COMPONENT;
1624 if (sas_device->fast_path)
d88e1eab
SPS		 1625 sas_target_priv_data->flags |=
1626 MPT_TARGET_FASTPATH_IO;
f92363d1
SR		 1627 }
1628 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1629
1630 return 0;
1631}
1632
1633/**
8a7e4c24 1634 * scsih_target_destroy - target destroy routine
f92363d1 1635 * @starget: scsi target struct
f92363d1 1636 */
8bbb1cf6 1637static void
8a7e4c24 1638scsih_target_destroy(struct scsi_target *starget)
f92363d1
SR		 1639{
1640 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1641 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1642 struct MPT3SAS_TARGET *sas_target_priv_data;
1643 struct _sas_device *sas_device;
1644 struct _raid_device *raid_device;
d88e1eab 1645 struct _pcie_device *pcie_device;
f92363d1 1646 unsigned long flags;
f92363d1
SR		 1647
1648 sas_target_priv_data = starget->hostdata;
1649 if (!sas_target_priv_data)
1650 return;
1651
1652 if (starget->channel == RAID_CHANNEL) {
1653 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1654 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1655 starget->channel);
1656 if (raid_device) {
1657 raid_device->starget = NULL;
1658 raid_device->sdev = NULL;
1659 }
1660 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1661 goto out;
1662 }
1663
d88e1eab
SPS		 1664 if (starget->channel == PCIE_CHANNEL) {
1665 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1666 pcie_device = __mpt3sas_get_pdev_from_target(ioc,
1667 sas_target_priv_data);
1668 if (pcie_device && (pcie_device->starget == starget) &&
1669 (pcie_device->id == starget->id) &&
1670 (pcie_device->channel == starget->channel))
1671 pcie_device->starget = NULL;
1672
1673 if (pcie_device) {
1674 /*
1675 * Corresponding get() is in _scsih_target_alloc()
1676 */
1677 sas_target_priv_data->pcie_dev = NULL;
1678 pcie_device_put(pcie_device);
1679 pcie_device_put(pcie_device);
1680 }
1681 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1682 goto out;
1683 }
1684
f92363d1 1685 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49 1686 sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data);
f92363d1
SR		 1687 if (sas_device && (sas_device->starget == starget) &&
1688 (sas_device->id == starget->id) &&
1689 (sas_device->channel == starget->channel))
1690 sas_device->starget = NULL;
1691
d1cb5e49
SR		 1692 if (sas_device) {
1693 /*
1694 * Corresponding get() is in _scsih_target_alloc()
1695 */
d88e1eab 1696 sas_target_priv_data->sas_dev = NULL;
d1cb5e49
SR		 1697 sas_device_put(sas_device);
1698
1699 sas_device_put(sas_device);
1700 }
f92363d1
SR		 1701 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1702
1703 out:
1704 kfree(sas_target_priv_data);
1705 starget->hostdata = NULL;
1706}
1707
1708/**
8a7e4c24 1709 * scsih_slave_alloc - device add routine
f92363d1
SR		 1710 * @sdev: scsi device struct
1711 *
4beb4867 1712 * Return: 0 if ok. Any other return is assumed to be an error and
f92363d1
SR		 1713 * the device is ignored.
1714 */
8bbb1cf6 1715static int
8a7e4c24 1716scsih_slave_alloc(struct scsi_device *sdev)
f92363d1
SR		 1717{
1718 struct Scsi_Host *shost;
1719 struct MPT3SAS_ADAPTER *ioc;
1720 struct MPT3SAS_TARGET *sas_target_priv_data;
1721 struct MPT3SAS_DEVICE *sas_device_priv_data;
1722 struct scsi_target *starget;
1723 struct _raid_device *raid_device;
b65cfedf 1724 struct _sas_device *sas_device;
d88e1eab 1725 struct _pcie_device *pcie_device;
f92363d1
SR		 1726 unsigned long flags;
1727
62c4da44
JL		 1728 sas_device_priv_data = kzalloc(sizeof(*sas_device_priv_data),
1729 GFP_KERNEL);
f92363d1
SR		 1730 if (!sas_device_priv_data)
1731 return -ENOMEM;
1732
1733 sas_device_priv_data->lun = sdev->lun;
1734 sas_device_priv_data->flags = MPT_DEVICE_FLAGS_INIT;
1735
1736 starget = scsi_target(sdev);
1737 sas_target_priv_data = starget->hostdata;
1738 sas_target_priv_data->num_luns++;
1739 sas_device_priv_data->sas_target = sas_target_priv_data;
1740 sdev->hostdata = sas_device_priv_data;
1741 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT))
1742 sdev->no_uld_attach = 1;
1743
1744 shost = dev_to_shost(&starget->dev);
1745 ioc = shost_priv(shost);
1746 if (starget->channel == RAID_CHANNEL) {
1747 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1748 raid_device = _scsih_raid_device_find_by_id(ioc,
1749 starget->id, starget->channel);
1750 if (raid_device)
1751 raid_device->sdev = sdev; /* raid is single lun */
1752 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1753 }
d88e1eab
SPS		 1754 if (starget->channel == PCIE_CHANNEL) {
1755 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1756 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc,
1757 sas_target_priv_data->sas_address);
1758 if (pcie_device && (pcie_device->starget == NULL)) {
1759 sdev_printk(KERN_INFO, sdev,
1760 "%s : pcie_device->starget set to starget @ %d\n",
1761 __func__, __LINE__);
1762 pcie_device->starget = starget;
1763 }
1764
1765 if (pcie_device)
1766 pcie_device_put(pcie_device);
1767 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
f92363d1 1768
d88e1eab 1769 } else if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
b65cfedf 1770 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49 1771 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
b65cfedf
SR		 1772 sas_target_priv_data->sas_address);
1773 if (sas_device && (sas_device->starget == NULL)) {
1774 sdev_printk(KERN_INFO, sdev,
1775 "%s : sas_device->starget set to starget @ %d\n",
d1cb5e49 1776 __func__, __LINE__);
b65cfedf
SR		 1777 sas_device->starget = starget;
1778 }
d1cb5e49
SR		 1779
1780 if (sas_device)
1781 sas_device_put(sas_device);
1782
b65cfedf
SR		 1783 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1784 }
1785
f92363d1
SR		 1786 return 0;
1787}
1788
1789/**
8a7e4c24 1790 * scsih_slave_destroy - device destroy routine
f92363d1 1791 * @sdev: scsi device struct
f92363d1 1792 */
8bbb1cf6 1793static void
8a7e4c24 1794scsih_slave_destroy(struct scsi_device *sdev)
f92363d1
SR		 1795{
1796 struct MPT3SAS_TARGET *sas_target_priv_data;
1797 struct scsi_target *starget;
1798 struct Scsi_Host *shost;
1799 struct MPT3SAS_ADAPTER *ioc;
1800 struct _sas_device *sas_device;
d88e1eab 1801 struct _pcie_device *pcie_device;
f92363d1
SR		 1802 unsigned long flags;
1803
1804 if (!sdev->hostdata)
1805 return;
1806
1807 starget = scsi_target(sdev);
1808 sas_target_priv_data = starget->hostdata;
1809 sas_target_priv_data->num_luns--;
1810
1811 shost = dev_to_shost(&starget->dev);
1812 ioc = shost_priv(shost);
1813
d88e1eab
SPS		 1814 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) {
1815 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1816 pcie_device = __mpt3sas_get_pdev_from_target(ioc,
1817 sas_target_priv_data);
1818 if (pcie_device && !sas_target_priv_data->num_luns)
1819 pcie_device->starget = NULL;
1820
1821 if (pcie_device)
1822 pcie_device_put(pcie_device);
1823
1824 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1825
1826 } else if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
f92363d1 1827 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49
SR		 1828 sas_device = __mpt3sas_get_sdev_from_target(ioc,
1829 sas_target_priv_data);
f92363d1
SR		 1830 if (sas_device && !sas_target_priv_data->num_luns)
1831 sas_device->starget = NULL;
d1cb5e49
SR		 1832
1833 if (sas_device)
1834 sas_device_put(sas_device);
f92363d1
SR		 1835 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1836 }
1837
1838 kfree(sdev->hostdata);
1839 sdev->hostdata = NULL;
1840}
1841
1842/**
1843 * _scsih_display_sata_capabilities - sata capabilities
1844 * @ioc: per adapter object
1845 * @handle: device handle
1846 * @sdev: scsi device struct
1847 */
1848static void
1849_scsih_display_sata_capabilities(struct MPT3SAS_ADAPTER *ioc,
1850 u16 handle, struct scsi_device *sdev)
1851{
1852 Mpi2ConfigReply_t mpi_reply;
1853 Mpi2SasDevicePage0_t sas_device_pg0;
1854 u32 ioc_status;
1855 u16 flags;
1856 u32 device_info;
1857
1858 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
1859 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
919d8a3f
JP		 1860 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1861 __FILE__, __LINE__, __func__);
f92363d1
SR		 1862 return;
1863 }
1864
1865 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1866 MPI2_IOCSTATUS_MASK;
1867 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 1868 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1869 __FILE__, __LINE__, __func__);
f92363d1
SR		 1870 return;
1871 }
1872
1873 flags = le16_to_cpu(sas_device_pg0.Flags);
1874 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
1875
1876 sdev_printk(KERN_INFO, sdev,
1877 "atapi(%s), ncq(%s), asyn_notify(%s), smart(%s), fua(%s), "
1878 "sw_preserve(%s)\n",
1879 (device_info & MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? "y" : "n",
1880 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_NCQ_SUPPORTED) ? "y" : "n",
1881 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_ASYNCHRONOUS_NOTIFY) ? "y" :
1882 "n",
1883 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SMART_SUPPORTED) ? "y" : "n",
1884 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_FUA_SUPPORTED) ? "y" : "n",
1885 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SW_PRESERVE) ? "y" : "n");
1886}
1887
1888/*
1889 * raid transport support -
1890 * Enabled for SLES11 and newer, in older kernels the driver will panic when
6c7abffc 1891 * unloading the driver followed by a load - I believe that the subroutine
f92363d1
SR		 1892 * raid_class_release() is not cleaning up properly.
1893 */
1894
1895/**
8a7e4c24 1896 * scsih_is_raid - return boolean indicating device is raid volume
4beb4867 1897 * @dev: the device struct object
f92363d1 1898 */
8bbb1cf6 1899static int
8a7e4c24 1900scsih_is_raid(struct device *dev)
f92363d1
SR		 1901{
1902 struct scsi_device *sdev = to_scsi_device(dev);
7786ab6a 1903 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
f92363d1 1904
7786ab6a
SR		 1905 if (ioc->is_warpdrive)
1906 return 0;
f92363d1
SR		 1907 return (sdev->channel == RAID_CHANNEL) ? 1 : 0;
1908}
1909
cd5897ed
SPS		 1910static int
1911scsih_is_nvme(struct device *dev)
1912{
1913 struct scsi_device *sdev = to_scsi_device(dev);
1914
1915 return (sdev->channel == PCIE_CHANNEL) ? 1 : 0;
1916}
1917
f92363d1 1918/**
8a7e4c24 1919 * scsih_get_resync - get raid volume resync percent complete
4beb4867 1920 * @dev: the device struct object
f92363d1 1921 */
8bbb1cf6 1922static void
8a7e4c24 1923scsih_get_resync(struct device *dev)
f92363d1
SR		 1924{
1925 struct scsi_device *sdev = to_scsi_device(dev);
1926 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
1927 static struct _raid_device *raid_device;
1928 unsigned long flags;
1929 Mpi2RaidVolPage0_t vol_pg0;
1930 Mpi2ConfigReply_t mpi_reply;
1931 u32 volume_status_flags;
1932 u8 percent_complete;
1933 u16 handle;
1934
1935 percent_complete = 0;
1936 handle = 0;
7786ab6a
SR		 1937 if (ioc->is_warpdrive)
1938 goto out;
1939
f92363d1
SR		 1940 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1941 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1942 sdev->channel);
1943 if (raid_device) {
1944 handle = raid_device->handle;
1945 percent_complete = raid_device->percent_complete;
1946 }
1947 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1948
1949 if (!handle)
1950 goto out;
1951
1952 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1953 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
1954 sizeof(Mpi2RaidVolPage0_t))) {
919d8a3f
JP		 1955 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1956 __FILE__, __LINE__, __func__);
f92363d1
SR		 1957 percent_complete = 0;
1958 goto out;
1959 }
1960
1961 volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags);
1962 if (!(volume_status_flags &
1963 MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS))
1964 percent_complete = 0;
1965
1966 out:
b130b0d5
SS		 1967
1968 switch (ioc->hba_mpi_version_belonged) {
1969 case MPI2_VERSION:
c84b06a4 1970 raid_set_resync(mpt2sas_raid_template, dev, percent_complete);
b130b0d5
SS		 1971 break;
1972 case MPI25_VERSION:
1973 case MPI26_VERSION:
c84b06a4 1974 raid_set_resync(mpt3sas_raid_template, dev, percent_complete);
b130b0d5
SS		 1975 break;
1976 }
f92363d1
SR		 1977}
1978
1979/**
8a7e4c24 1980 * scsih_get_state - get raid volume level
4beb4867 1981 * @dev: the device struct object
f92363d1 1982 */
8bbb1cf6 1983static void
8a7e4c24 1984scsih_get_state(struct device *dev)
f92363d1
SR		 1985{
1986 struct scsi_device *sdev = to_scsi_device(dev);
1987 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
1988 static struct _raid_device *raid_device;
1989 unsigned long flags;
1990 Mpi2RaidVolPage0_t vol_pg0;
1991 Mpi2ConfigReply_t mpi_reply;
1992 u32 volstate;
1993 enum raid_state state = RAID_STATE_UNKNOWN;
1994 u16 handle = 0;
1995
1996 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1997 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1998 sdev->channel);
1999 if (raid_device)
2000 handle = raid_device->handle;
2001 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
2002
2003 if (!raid_device)
2004 goto out;
2005
2006 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
2007 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
2008 sizeof(Mpi2RaidVolPage0_t))) {
919d8a3f
JP		 2009 ioc_err(ioc, "failure at %s:%d/%s()!\n",
2010 __FILE__, __LINE__, __func__);
f92363d1
SR		 2011 goto out;
2012 }
2013
2014 volstate = le32_to_cpu(vol_pg0.VolumeStatusFlags);
2015 if (volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) {
2016 state = RAID_STATE_RESYNCING;
2017 goto out;
2018 }
2019
2020 switch (vol_pg0.VolumeState) {
2021 case MPI2_RAID_VOL_STATE_OPTIMAL:
2022 case MPI2_RAID_VOL_STATE_ONLINE:
2023 state = RAID_STATE_ACTIVE;
2024 break;
2025 case MPI2_RAID_VOL_STATE_DEGRADED:
2026 state = RAID_STATE_DEGRADED;
2027 break;
2028 case MPI2_RAID_VOL_STATE_FAILED:
2029 case MPI2_RAID_VOL_STATE_MISSING:
2030 state = RAID_STATE_OFFLINE;
2031 break;
2032 }
2033 out:
b130b0d5
SS		 2034 switch (ioc->hba_mpi_version_belonged) {
2035 case MPI2_VERSION:
c84b06a4 2036 raid_set_state(mpt2sas_raid_template, dev, state);
b130b0d5
SS		 2037 break;
2038 case MPI25_VERSION:
2039 case MPI26_VERSION:
c84b06a4 2040 raid_set_state(mpt3sas_raid_template, dev, state);
b130b0d5
SS		 2041 break;
2042 }
f92363d1
SR		 2043}
2044
2045/**
2046 * _scsih_set_level - set raid level
4beb4867 2047 * @ioc: ?
f92363d1
SR		 2048 * @sdev: scsi device struct
2049 * @volume_type: volume type
2050 */
2051static void
c84b06a4
SR		 2052_scsih_set_level(struct MPT3SAS_ADAPTER *ioc,
2053 struct scsi_device *sdev, u8 volume_type)
f92363d1
SR		 2054{
2055 enum raid_level level = RAID_LEVEL_UNKNOWN;
2056
2057 switch (volume_type) {
2058 case MPI2_RAID_VOL_TYPE_RAID0:
2059 level = RAID_LEVEL_0;
2060 break;
2061 case MPI2_RAID_VOL_TYPE_RAID10:
2062 level = RAID_LEVEL_10;
2063 break;
2064 case MPI2_RAID_VOL_TYPE_RAID1E:
2065 level = RAID_LEVEL_1E;
2066 break;
2067 case MPI2_RAID_VOL_TYPE_RAID1:
2068 level = RAID_LEVEL_1;
2069 break;
2070 }
2071
b130b0d5
SS		 2072 switch (ioc->hba_mpi_version_belonged) {
2073 case MPI2_VERSION:
c84b06a4 2074 raid_set_level(mpt2sas_raid_template,
b130b0d5
SS		 2075 &sdev->sdev_gendev, level);
2076 break;
2077 case MPI25_VERSION:
2078 case MPI26_VERSION:
c84b06a4 2079 raid_set_level(mpt3sas_raid_template,
b130b0d5
SS		 2080 &sdev->sdev_gendev, level);
2081 break;
2082 }
f92363d1
SR		 2083}
2084
2085
2086/**
2087 * _scsih_get_volume_capabilities - volume capabilities
2088 * @ioc: per adapter object
4beb4867 2089 * @raid_device: the raid_device object
f92363d1 2090 *
4beb4867 2091 * Return: 0 for success, else 1
f92363d1
SR		 2092 */
2093static int
2094_scsih_get_volume_capabilities(struct MPT3SAS_ADAPTER *ioc,
2095 struct _raid_device *raid_device)
2096{
2097 Mpi2RaidVolPage0_t *vol_pg0;
2098 Mpi2RaidPhysDiskPage0_t pd_pg0;
2099 Mpi2SasDevicePage0_t sas_device_pg0;
2100 Mpi2ConfigReply_t mpi_reply;
2101 u16 sz;
2102 u8 num_pds;
2103
2104 if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle,
2105 &num_pds)) || !num_pds) {
919d8a3f
JP		 2106 dfailprintk(ioc,
2107 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2108 __FILE__, __LINE__, __func__));
f92363d1
SR		 2109 return 1;
2110 }
2111
2112 raid_device->num_pds = num_pds;
2113 sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds *
2114 sizeof(Mpi2RaidVol0PhysDisk_t));
2115 vol_pg0 = kzalloc(sz, GFP_KERNEL);
2116 if (!vol_pg0) {
919d8a3f
JP		 2117 dfailprintk(ioc,
2118 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2119 __FILE__, __LINE__, __func__));
f92363d1
SR		 2120 return 1;
2121 }
2122
2123 if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
2124 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
919d8a3f
JP		 2125 dfailprintk(ioc,
2126 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2127 __FILE__, __LINE__, __func__));
f92363d1
SR		 2128 kfree(vol_pg0);
2129 return 1;
2130 }
2131
2132 raid_device->volume_type = vol_pg0->VolumeType;
2133
2134 /* figure out what the underlying devices are by
2135 * obtaining the device_info bits for the 1st device
2136 */
2137 if (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
2138 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
2139 vol_pg0->PhysDisk[0].PhysDiskNum))) {
2140 if (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
2141 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
2142 le16_to_cpu(pd_pg0.DevHandle)))) {
2143 raid_device->device_info =
2144 le32_to_cpu(sas_device_pg0.DeviceInfo);
2145 }
2146 }
2147
2148 kfree(vol_pg0);
2149 return 0;
2150}
2151
f92363d1
SR		 2152/**
2153 * _scsih_enable_tlr - setting TLR flags
2154 * @ioc: per adapter object
2155 * @sdev: scsi device struct
2156 *
2157 * Enabling Transaction Layer Retries for tape devices when
2158 * vpd page 0x90 is present
2159 *
2160 */
2161static void
2162_scsih_enable_tlr(struct MPT3SAS_ADAPTER *ioc, struct scsi_device *sdev)
2163{
2164
2165 /* only for TAPE */
2166 if (sdev->type != TYPE_TAPE)
2167 return;
2168
2169 if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
2170 return;
2171
2172 sas_enable_tlr(sdev);
2173 sdev_printk(KERN_INFO, sdev, "TLR %s\n",
2174 sas_is_tlr_enabled(sdev) ? "Enabled" : "Disabled");
2175 return;
2176
2177}
2178
2179/**
8a7e4c24 2180 * scsih_slave_configure - device configure routine.
f92363d1
SR		 2181 * @sdev: scsi device struct
2182 *
4beb4867 2183 * Return: 0 if ok. Any other return is assumed to be an error and
f92363d1
SR		 2184 * the device is ignored.
2185 */
8bbb1cf6 2186static int
8a7e4c24 2187scsih_slave_configure(struct scsi_device *sdev)
f92363d1
SR		 2188{
2189 struct Scsi_Host *shost = sdev->host;
2190 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2191 struct MPT3SAS_DEVICE *sas_device_priv_data;
2192 struct MPT3SAS_TARGET *sas_target_priv_data;
2193 struct _sas_device *sas_device;
d1b01d14 2194 struct _pcie_device *pcie_device;
f92363d1
SR		 2195 struct _raid_device *raid_device;
2196 unsigned long flags;
2197 int qdepth;
2198 u8 ssp_target = 0;
2199 char *ds = "";
2200 char *r_level = "";
2201 u16 handle, volume_handle = 0;
2202 u64 volume_wwid = 0;
2203
2204 qdepth = 1;
2205 sas_device_priv_data = sdev->hostdata;
2206 sas_device_priv_data->configured_lun = 1;
2207 sas_device_priv_data->flags &= ~MPT_DEVICE_FLAGS_INIT;
2208 sas_target_priv_data = sas_device_priv_data->sas_target;
2209 handle = sas_target_priv_data->handle;
2210
2211 /* raid volume handling */
2212 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME) {
2213
2214 spin_lock_irqsave(&ioc->raid_device_lock, flags);
c84b06a4 2215 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
f92363d1
SR		 2216 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
2217 if (!raid_device) {
919d8a3f
JP		 2218 dfailprintk(ioc,
2219 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2220 __FILE__, __LINE__, __func__));
f92363d1
SR		 2221 return 1;
2222 }
2223
2224 if (_scsih_get_volume_capabilities(ioc, raid_device)) {
919d8a3f
JP		 2225 dfailprintk(ioc,
2226 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2227 __FILE__, __LINE__, __func__));
f92363d1
SR		 2228 return 1;
2229 }
2230
7786ab6a
SR		 2231 /*
2232 * WARPDRIVE: Initialize the required data for Direct IO
2233 */
c84b06a4 2234 mpt3sas_init_warpdrive_properties(ioc, raid_device);
f92363d1
SR		 2235
2236 /* RAID Queue Depth Support
2237 * IS volume = underlying qdepth of drive type, either
2238 * MPT3SAS_SAS_QUEUE_DEPTH or MPT3SAS_SATA_QUEUE_DEPTH
2239 * IM/IME/R10 = 128 (MPT3SAS_RAID_QUEUE_DEPTH)
2240 */
2241 if (raid_device->device_info &
2242 MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
2243 qdepth = MPT3SAS_SAS_QUEUE_DEPTH;
2244 ds = "SSP";
2245 } else {
2246 qdepth = MPT3SAS_SATA_QUEUE_DEPTH;
199fd79a 2247 if (raid_device->device_info &
f92363d1
SR		 2248 MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
2249 ds = "SATA";
2250 else
2251 ds = "STP";
2252 }
2253
2254 switch (raid_device->volume_type) {
2255 case MPI2_RAID_VOL_TYPE_RAID0:
2256 r_level = "RAID0";
2257 break;
2258 case MPI2_RAID_VOL_TYPE_RAID1E:
2259 qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
2260 if (ioc->manu_pg10.OEMIdentifier &&
2261 (le32_to_cpu(ioc->manu_pg10.GenericFlags0) &
2262 MFG10_GF0_R10_DISPLAY) &&
2263 !(raid_device->num_pds % 2))
2264 r_level = "RAID10";
2265 else
2266 r_level = "RAID1E";
2267 break;
2268 case MPI2_RAID_VOL_TYPE_RAID1:
2269 qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
2270 r_level = "RAID1";
2271 break;
2272 case MPI2_RAID_VOL_TYPE_RAID10:
2273 qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
2274 r_level = "RAID10";
2275 break;
2276 case MPI2_RAID_VOL_TYPE_UNKNOWN:
2277 default:
2278 qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
2279 r_level = "RAIDX";
2280 break;
2281 }
2282
7786ab6a
SR		 2283 if (!ioc->hide_ir_msg)
2284 sdev_printk(KERN_INFO, sdev,
2285 "%s: handle(0x%04x), wwid(0x%016llx),"
2286 " pd_count(%d), type(%s)\n",
2287 r_level, raid_device->handle,
2288 (unsigned long long)raid_device->wwid,
2289 raid_device->num_pds, ds);
f92363d1 2290
6c197093
C		 2291 if (shost->max_sectors > MPT3SAS_RAID_MAX_SECTORS) {
2292 blk_queue_max_hw_sectors(sdev->request_queue,
2293 MPT3SAS_RAID_MAX_SECTORS);
2294 sdev_printk(KERN_INFO, sdev,
2295 "Set queue's max_sector to: %u\n",
2296 MPT3SAS_RAID_MAX_SECTORS);
2297 }
2298
8a7e4c24 2299 scsih_change_queue_depth(sdev, qdepth);
f92363d1 2300
7786ab6a
SR		 2301 /* raid transport support */
2302 if (!ioc->is_warpdrive)
c84b06a4 2303 _scsih_set_level(ioc, sdev, raid_device->volume_type);
f92363d1
SR		 2304 return 0;
2305 }
2306
2307 /* non-raid handling */
2308 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
2309 if (mpt3sas_config_get_volume_handle(ioc, handle,
2310 &volume_handle)) {
919d8a3f
JP		 2311 dfailprintk(ioc,
2312 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2313 __FILE__, __LINE__, __func__));
f92363d1
SR		 2314 return 1;
2315 }
2316 if (volume_handle && mpt3sas_config_get_volume_wwid(ioc,
2317 volume_handle, &volume_wwid)) {
919d8a3f
JP		 2318 dfailprintk(ioc,
2319 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2320 __FILE__, __LINE__, __func__));
f92363d1
SR		 2321 return 1;
2322 }
2323 }
2324
d1b01d14
SPS		 2325 /* PCIe handling */
2326 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) {
2327 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
2328 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc,
2329 sas_device_priv_data->sas_target->sas_address);
2330 if (!pcie_device) {
2331 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
919d8a3f
JP		 2332 dfailprintk(ioc,
2333 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2334 __FILE__, __LINE__, __func__));
d1b01d14
SPS		 2335 return 1;
2336 }
2337
2338 qdepth = MPT3SAS_NVME_QUEUE_DEPTH;
2339 ds = "NVMe";
2340 sdev_printk(KERN_INFO, sdev,
2341 "%s: handle(0x%04x), wwid(0x%016llx), port(%d)\n",
2342 ds, handle, (unsigned long long)pcie_device->wwid,
2343 pcie_device->port_num);
2344 if (pcie_device->enclosure_handle != 0)
2345 sdev_printk(KERN_INFO, sdev,
2346 "%s: enclosure logical id(0x%016llx), slot(%d)\n",
2347 ds,
2348 (unsigned long long)pcie_device->enclosure_logical_id,
2349 pcie_device->slot);
2350 if (pcie_device->connector_name[0] != '\0')
2351 sdev_printk(KERN_INFO, sdev,
2352 "%s: enclosure level(0x%04x),"
2353 "connector name( %s)\n", ds,
2354 pcie_device->enclosure_level,
2355 pcie_device->connector_name);
d1b01d14
SPS		 2356
2357 if (pcie_device->nvme_mdts)
2358 blk_queue_max_hw_sectors(sdev->request_queue,
2359 pcie_device->nvme_mdts/512);
20a04433
C		 2360
2361 pcie_device_put(pcie_device);
2362 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2363 scsih_change_queue_depth(sdev, qdepth);
d1b01d14
SPS		 2364 /* Enable QUEUE_FLAG_NOMERGES flag, so that IOs won't be
2365 ** merged and can eliminate holes created during merging
2366 ** operation.
2367 **/
8b904b5b 2368 blk_queue_flag_set(QUEUE_FLAG_NOMERGES,
d1b01d14
SPS		 2369 sdev->request_queue);
2370 blk_queue_virt_boundary(sdev->request_queue,
2371 ioc->page_size - 1);
2372 return 0;
2373 }
2374
f92363d1 2375 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49 2376 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
f92363d1
SR		 2377 sas_device_priv_data->sas_target->sas_address);
2378 if (!sas_device) {
2379 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
919d8a3f
JP		 2380 dfailprintk(ioc,
2381 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2382 __FILE__, __LINE__, __func__));
f92363d1
SR		 2383 return 1;
2384 }
2385
2386 sas_device->volume_handle = volume_handle;
2387 sas_device->volume_wwid = volume_wwid;
2388 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
2389 qdepth = MPT3SAS_SAS_QUEUE_DEPTH;
2390 ssp_target = 1;
30158dc9
SS		 2391 if (sas_device->device_info &
2392 MPI2_SAS_DEVICE_INFO_SEP) {
2393 sdev_printk(KERN_WARNING, sdev,
2394 "set ignore_delay_remove for handle(0x%04x)\n",
2395 sas_device_priv_data->sas_target->handle);
2396 sas_device_priv_data->ignore_delay_remove = 1;
2397 ds = "SES";
2398 } else
2399 ds = "SSP";
f92363d1
SR		 2400 } else {
2401 qdepth = MPT3SAS_SATA_QUEUE_DEPTH;
2402 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET)
2403 ds = "STP";
2404 else if (sas_device->device_info &
2405 MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
2406 ds = "SATA";
2407 }
2408
2409 sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), " \
2410 "sas_addr(0x%016llx), phy(%d), device_name(0x%016llx)\n",
2411 ds, handle, (unsigned long long)sas_device->sas_address,
2412 sas_device->phy, (unsigned long long)sas_device->device_name);
75888956
SR		 2413
2414 _scsih_display_enclosure_chassis_info(NULL, sas_device, sdev, NULL);
f92363d1 2415
d1cb5e49 2416 sas_device_put(sas_device);
f92363d1
SR		 2417 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2418
2419 if (!ssp_target)
2420 _scsih_display_sata_capabilities(ioc, handle, sdev);
2421
2422
8a7e4c24 2423 scsih_change_queue_depth(sdev, qdepth);
f92363d1
SR		 2424
2425 if (ssp_target) {
2426 sas_read_port_mode_page(sdev);
2427 _scsih_enable_tlr(ioc, sdev);
2428 }
2429
2430 return 0;
2431}
2432
2433/**
8a7e4c24 2434 * scsih_bios_param - fetch head, sector, cylinder info for a disk
f92363d1
SR		 2435 * @sdev: scsi device struct
2436 * @bdev: pointer to block device context
2437 * @capacity: device size (in 512 byte sectors)
2438 * @params: three element array to place output:
2439 * params[0] number of heads (max 255)
2440 * params[1] number of sectors (max 63)
2441 * params[2] number of cylinders
f92363d1 2442 */
8bbb1cf6 2443static int
8a7e4c24 2444scsih_bios_param(struct scsi_device *sdev, struct block_device *bdev,
f92363d1
SR		 2445 sector_t capacity, int params[])
2446{
2447 int heads;
2448 int sectors;
2449 sector_t cylinders;
2450 ulong dummy;
2451
2452 heads = 64;
2453 sectors = 32;
2454
2455 dummy = heads * sectors;
2456 cylinders = capacity;
2457 sector_div(cylinders, dummy);
2458
2459 /*
2460 * Handle extended translation size for logical drives
2461 * > 1Gb
2462 */
2463 if ((ulong)capacity >= 0x200000) {
2464 heads = 255;
2465 sectors = 63;
2466 dummy = heads * sectors;
2467 cylinders = capacity;
2468 sector_div(cylinders, dummy);
2469 }
2470
2471 /* return result */
2472 params[0] = heads;
2473 params[1] = sectors;
2474 params[2] = cylinders;
2475
2476 return 0;
2477}
2478
2479/**
2480 * _scsih_response_code - translation of device response code
2481 * @ioc: per adapter object
2482 * @response_code: response code returned by the device
f92363d1
SR		 2483 */
2484static void
2485_scsih_response_code(struct MPT3SAS_ADAPTER *ioc, u8 response_code)
2486{
2487 char *desc;
2488
2489 switch (response_code) {
2490 case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE:
2491 desc = "task management request completed";
2492 break;
2493 case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME:
2494 desc = "invalid frame";
2495 break;
2496 case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
2497 desc = "task management request not supported";
2498 break;
2499 case MPI2_SCSITASKMGMT_RSP_TM_FAILED:
2500 desc = "task management request failed";
2501 break;
2502 case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED:
2503 desc = "task management request succeeded";
2504 break;
2505 case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN:
2506 desc = "invalid lun";
2507 break;
2508 case 0xA:
2509 desc = "overlapped tag attempted";
2510 break;
2511 case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
2512 desc = "task queued, however not sent to target";
2513 break;
2514 default:
2515 desc = "unknown";
2516 break;
2517 }
919d8a3f 2518 ioc_warn(ioc, "response_code(0x%01x): %s\n", response_code, desc);
f92363d1
SR		 2519}
2520
2521/**
2522 * _scsih_tm_done - tm completion routine
2523 * @ioc: per adapter object
2524 * @smid: system request message index
2525 * @msix_index: MSIX table index supplied by the OS
2526 * @reply: reply message frame(lower 32bit addr)
2527 * Context: none.
2528 *
2529 * The callback handler when using scsih_issue_tm.
2530 *
4beb4867
BVA		 2531 * Return: 1 meaning mf should be freed from _base_interrupt
2532 * 0 means the mf is freed from this function.
f92363d1
SR		 2533 */
2534static u8
2535_scsih_tm_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
2536{
2537 MPI2DefaultReply_t *mpi_reply;
2538
2539 if (ioc->tm_cmds.status == MPT3_CMD_NOT_USED)
2540 return 1;
2541 if (ioc->tm_cmds.smid != smid)
2542 return 1;
f92363d1
SR		 2543 ioc->tm_cmds.status |= MPT3_CMD_COMPLETE;
2544 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
2545 if (mpi_reply) {
2546 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
2547 ioc->tm_cmds.status |= MPT3_CMD_REPLY_VALID;
2548 }
2549 ioc->tm_cmds.status &= ~MPT3_CMD_PENDING;
2550 complete(&ioc->tm_cmds.done);
2551 return 1;
2552}
2553
2554/**
2555 * mpt3sas_scsih_set_tm_flag - set per target tm_busy
2556 * @ioc: per adapter object
2557 * @handle: device handle
2558 *
2559 * During taskmangement request, we need to freeze the device queue.
2560 */
2561void
2562mpt3sas_scsih_set_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2563{
2564 struct MPT3SAS_DEVICE *sas_device_priv_data;
2565 struct scsi_device *sdev;
2566 u8 skip = 0;
2567
2568 shost_for_each_device(sdev, ioc->shost) {
2569 if (skip)
2570 continue;
2571 sas_device_priv_data = sdev->hostdata;
2572 if (!sas_device_priv_data)
2573 continue;
2574 if (sas_device_priv_data->sas_target->handle == handle) {
2575 sas_device_priv_data->sas_target->tm_busy = 1;
2576 skip = 1;
2577 ioc->ignore_loginfos = 1;
2578 }
2579 }
2580}
2581
2582/**
2583 * mpt3sas_scsih_clear_tm_flag - clear per target tm_busy
2584 * @ioc: per adapter object
2585 * @handle: device handle
2586 *
2587 * During taskmangement request, we need to freeze the device queue.
2588 */
2589void
2590mpt3sas_scsih_clear_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2591{
2592 struct MPT3SAS_DEVICE *sas_device_priv_data;
2593 struct scsi_device *sdev;
2594 u8 skip = 0;
2595
2596 shost_for_each_device(sdev, ioc->shost) {
2597 if (skip)
2598 continue;
2599 sas_device_priv_data = sdev->hostdata;
2600 if (!sas_device_priv_data)
2601 continue;
2602 if (sas_device_priv_data->sas_target->handle == handle) {
2603 sas_device_priv_data->sas_target->tm_busy = 0;
2604 skip = 1;
2605 ioc->ignore_loginfos = 0;
2606 }
2607 }
2608}
2609
2610/**
2611 * mpt3sas_scsih_issue_tm - main routine for sending tm requests
2612 * @ioc: per adapter struct
6da999fe 2613 * @handle: device handle
f92363d1
SR		 2614 * @lun: lun number
2615 * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in mpi2_init.h)
2616 * @smid_task: smid assigned to the task
6da999fe 2617 * @msix_task: MSIX table index supplied by the OS
f92363d1 2618 * @timeout: timeout in seconds
c1a6c5ac 2619 * @tr_method: Target Reset Method
f92363d1
SR		 2620 * Context: user
2621 *
2622 * A generic API for sending task management requests to firmware.
2623 *
2624 * The callback index is set inside `ioc->tm_cb_idx`.
6da999fe 2625 * The caller is responsible to check for outstanding commands.
f92363d1 2626 *
4beb4867 2627 * Return: SUCCESS or FAILED.
f92363d1
SR		 2628 */
2629int
c1a6c5ac
C		 2630mpt3sas_scsih_issue_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle, u64 lun,
2631 u8 type, u16 smid_task, u16 msix_task, u8 timeout, u8 tr_method)
f92363d1
SR		 2632{
2633 Mpi2SCSITaskManagementRequest_t *mpi_request;
2634 Mpi2SCSITaskManagementReply_t *mpi_reply;
2635 u16 smid = 0;
2636 u32 ioc_state;
f92363d1
SR		 2637 int rc;
2638
96902835
CO		 2639 lockdep_assert_held(&ioc->tm_cmds.mutex);
2640
f92363d1 2641 if (ioc->tm_cmds.status != MPT3_CMD_NOT_USED) {
4dc74b2e 2642 ioc_info(ioc, "%s: tm_cmd busy!!!\n", __func__);
96902835 2643 return FAILED;
f92363d1
SR		 2644 }
2645
2646 if (ioc->shost_recovery || ioc->remove_host ||
2647 ioc->pci_error_recovery) {
4dc74b2e 2648 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
96902835 2649 return FAILED;
f92363d1
SR		 2650 }
2651
2652 ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
2653 if (ioc_state & MPI2_DOORBELL_USED) {
919d8a3f 2654 dhsprintk(ioc, ioc_info(ioc, "unexpected doorbell active!\n"));
98c56ad3 2655 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
96902835 2656 return (!rc) ? SUCCESS : FAILED;
f92363d1
SR		 2657 }
2658
2659 if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) {
2660 mpt3sas_base_fault_info(ioc, ioc_state &
2661 MPI2_DOORBELL_DATA_MASK);
98c56ad3 2662 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
96902835 2663 return (!rc) ? SUCCESS : FAILED;
f92363d1
SR		 2664 }
2665
2666 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
2667 if (!smid) {
919d8a3f 2668 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
96902835 2669 return FAILED;
f92363d1
SR		 2670 }
2671
919d8a3f
JP		 2672 dtmprintk(ioc,
2673 ioc_info(ioc, "sending tm: handle(0x%04x), task_type(0x%02x), smid(%d), timeout(%d), tr_method(0x%x)\n",
2674 handle, type, smid_task, timeout, tr_method));
f92363d1
SR		 2675 ioc->tm_cmds.status = MPT3_CMD_PENDING;
2676 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
2677 ioc->tm_cmds.smid = smid;
2678 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
2679 memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t));
2680 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
2681 mpi_request->DevHandle = cpu_to_le16(handle);
2682 mpi_request->TaskType = type;
c1a6c5ac 2683 mpi_request->MsgFlags = tr_method;
f92363d1
SR		 2684 mpi_request->TaskMID = cpu_to_le16(smid_task);
2685 int_to_scsilun(lun, (struct scsi_lun *)mpi_request->LUN);
2686 mpt3sas_scsih_set_tm_flag(ioc, handle);
2687 init_completion(&ioc->tm_cmds.done);
40114bde 2688 mpt3sas_base_put_smid_hi_priority(ioc, smid, msix_task);
8bbb1cf6 2689 wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
f92363d1 2690 if (!(ioc->tm_cmds.status & MPT3_CMD_COMPLETE)) {
d37306ca
C		 2691 if (mpt3sas_base_check_cmd_timeout(ioc,
2692 ioc->tm_cmds.status, mpi_request,
2693 sizeof(Mpi2SCSITaskManagementRequest_t)/4)) {
98c56ad3
CO		 2694 rc = mpt3sas_base_hard_reset_handler(ioc,
2695 FORCE_BIG_HAMMER);
f92363d1 2696 rc = (!rc) ? SUCCESS : FAILED;
96902835 2697 goto out;
f92363d1
SR		 2698 }
2699 }
2700
5f0dfb7a
C		 2701 /* sync IRQs in case those were busy during flush. */
2702 mpt3sas_base_sync_reply_irqs(ioc);
2703
f92363d1
SR		 2704 if (ioc->tm_cmds.status & MPT3_CMD_REPLY_VALID) {
2705 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
2706 mpi_reply = ioc->tm_cmds.reply;
919d8a3f
JP		 2707 dtmprintk(ioc,
2708 ioc_info(ioc, "complete tm: ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
2709 le16_to_cpu(mpi_reply->IOCStatus),
2710 le32_to_cpu(mpi_reply->IOCLogInfo),
2711 le32_to_cpu(mpi_reply->TerminationCount)));
f92363d1
SR		 2712 if (ioc->logging_level & MPT_DEBUG_TM) {
2713 _scsih_response_code(ioc, mpi_reply->ResponseCode);
2714 if (mpi_reply->IOCStatus)
2715 _debug_dump_mf(mpi_request,
2716 sizeof(Mpi2SCSITaskManagementRequest_t)/4);
2717 }
2718 }
6da999fe 2719 rc = SUCCESS;
f92363d1 2720
96902835 2721out:
f92363d1
SR		 2722 mpt3sas_scsih_clear_tm_flag(ioc, handle);
2723 ioc->tm_cmds.status = MPT3_CMD_NOT_USED;
f92363d1 2724 return rc;
96902835 2725}
f92363d1 2726
96902835 2727int mpt3sas_scsih_issue_locked_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle,
c1a6c5ac
C		 2728 u64 lun, u8 type, u16 smid_task, u16 msix_task,
2729 u8 timeout, u8 tr_method)
96902835
CO		 2730{
2731 int ret;
2732
2733 mutex_lock(&ioc->tm_cmds.mutex);
6da999fe 2734 ret = mpt3sas_scsih_issue_tm(ioc, handle, lun, type, smid_task,
c1a6c5ac 2735 msix_task, timeout, tr_method);
96902835
CO		 2736 mutex_unlock(&ioc->tm_cmds.mutex);
2737
2738 return ret;
f92363d1
SR		 2739}
2740
2741/**
2742 * _scsih_tm_display_info - displays info about the device
2743 * @ioc: per adapter struct
2744 * @scmd: pointer to scsi command object
2745 *
2746 * Called by task management callback handlers.
2747 */
2748static void
2749_scsih_tm_display_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
2750{
2751 struct scsi_target *starget = scmd->device->sdev_target;
2752 struct MPT3SAS_TARGET *priv_target = starget->hostdata;
2753 struct _sas_device *sas_device = NULL;
6ce2f1d1 2754 struct _pcie_device *pcie_device = NULL;
f92363d1
SR		 2755 unsigned long flags;
2756 char *device_str = NULL;
2757
2758 if (!priv_target)
2759 return;
7786ab6a
SR		 2760 if (ioc->hide_ir_msg)
2761 device_str = "WarpDrive";
2762 else
2763 device_str = "volume";
f92363d1
SR		 2764
2765 scsi_print_command(scmd);
2766 if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2767 starget_printk(KERN_INFO, starget,
2768 "%s handle(0x%04x), %s wwid(0x%016llx)\n",
2769 device_str, priv_target->handle,
2770 device_str, (unsigned long long)priv_target->sas_address);
6ce2f1d1
SPS		 2771
2772 } else if (priv_target->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) {
2773 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
2774 pcie_device = __mpt3sas_get_pdev_from_target(ioc, priv_target);
2775 if (pcie_device) {
2776 starget_printk(KERN_INFO, starget,
2777 "handle(0x%04x), wwid(0x%016llx), port(%d)\n",
2778 pcie_device->handle,
2779 (unsigned long long)pcie_device->wwid,
2780 pcie_device->port_num);
2781 if (pcie_device->enclosure_handle != 0)
2782 starget_printk(KERN_INFO, starget,
2783 "enclosure logical id(0x%016llx), slot(%d)\n",
2784 (unsigned long long)
2785 pcie_device->enclosure_logical_id,
2786 pcie_device->slot);
2787 if (pcie_device->connector_name[0] != '\0')
2788 starget_printk(KERN_INFO, starget,
2789 "enclosure level(0x%04x), connector name( %s)\n",
2790 pcie_device->enclosure_level,
2791 pcie_device->connector_name);
2792 pcie_device_put(pcie_device);
2793 }
2794 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2795
f92363d1
SR		 2796 } else {
2797 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49 2798 sas_device = __mpt3sas_get_sdev_from_target(ioc, priv_target);
f92363d1
SR		 2799 if (sas_device) {
2800 if (priv_target->flags &
2801 MPT_TARGET_FLAGS_RAID_COMPONENT) {
2802 starget_printk(KERN_INFO, starget,
2803 "volume handle(0x%04x), "
2804 "volume wwid(0x%016llx)\n",
2805 sas_device->volume_handle,
2806 (unsigned long long)sas_device->volume_wwid);
2807 }
2808 starget_printk(KERN_INFO, starget,
2809 "handle(0x%04x), sas_address(0x%016llx), phy(%d)\n",
2810 sas_device->handle,
2811 (unsigned long long)sas_device->sas_address,
2812 sas_device->phy);
75888956
SR		 2813
2814 _scsih_display_enclosure_chassis_info(NULL, sas_device,
2815 NULL, starget);
d1cb5e49
SR		 2816
2817 sas_device_put(sas_device);
f92363d1
SR		 2818 }
2819 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2820 }
2821}
2822
2823/**
8a7e4c24 2824 * scsih_abort - eh threads main abort routine
f92363d1
SR		 2825 * @scmd: pointer to scsi command object
2826 *
4beb4867 2827 * Return: SUCCESS if command aborted else FAILED
f92363d1 2828 */
8bbb1cf6 2829static int
8a7e4c24 2830scsih_abort(struct scsi_cmnd *scmd)
f92363d1
SR		 2831{
2832 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2833 struct MPT3SAS_DEVICE *sas_device_priv_data;
dbec4c90 2834 struct scsiio_tracker *st = scsi_cmd_priv(scmd);
f92363d1
SR		 2835 u16 handle;
2836 int r;
2837
c1a6c5ac
C		 2838 u8 timeout = 30;
2839 struct _pcie_device *pcie_device = NULL;
f92363d1
SR		 2840 sdev_printk(KERN_INFO, scmd->device,
2841 "attempting task abort! scmd(%p)\n", scmd);
2842 _scsih_tm_display_info(ioc, scmd);
2843
2844 sas_device_priv_data = scmd->device->hostdata;
9ff549ff
MFO		 2845 if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
2846 ioc->remove_host) {
f92363d1
SR		 2847 sdev_printk(KERN_INFO, scmd->device,
2848 "device been deleted! scmd(%p)\n", scmd);
2849 scmd->result = DID_NO_CONNECT << 16;
2850 scmd->scsi_done(scmd);
2851 r = SUCCESS;
2852 goto out;
2853 }
2854
dbec4c90
SPS		 2855 /* check for completed command */
2856 if (st == NULL || st->cb_idx == 0xFF) {
f92363d1
SR		 2857 scmd->result = DID_RESET << 16;
2858 r = SUCCESS;
2859 goto out;
2860 }
2861
2862 /* for hidden raid components and volumes this is not supported */
2863 if (sas_device_priv_data->sas_target->flags &
2864 MPT_TARGET_FLAGS_RAID_COMPONENT ||
2865 sas_device_priv_data->sas_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2866 scmd->result = DID_RESET << 16;
2867 r = FAILED;
2868 goto out;
2869 }
2870
2871 mpt3sas_halt_firmware(ioc);
2872
2873 handle = sas_device_priv_data->sas_target->handle;
c1a6c5ac
C		 2874 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
2875 if (pcie_device && (!ioc->tm_custom_handling))
2876 timeout = ioc->nvme_abort_timeout;
6da999fe
HR		 2877 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->lun,
2878 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
c1a6c5ac 2879 st->smid, st->msix_io, timeout, 0);
6da999fe 2880 /* Command must be cleared after abort */
dbec4c90 2881 if (r == SUCCESS && st->cb_idx != 0xFF)
6da999fe 2882 r = FAILED;
f92363d1
SR		 2883 out:
2884 sdev_printk(KERN_INFO, scmd->device, "task abort: %s scmd(%p)\n",
2885 ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
c1a6c5ac
C		 2886 if (pcie_device)
2887 pcie_device_put(pcie_device);
f92363d1
SR		 2888 return r;
2889}
2890
2891/**
8a7e4c24 2892 * scsih_dev_reset - eh threads main device reset routine
f92363d1
SR		 2893 * @scmd: pointer to scsi command object
2894 *
4beb4867 2895 * Return: SUCCESS if command aborted else FAILED
f92363d1 2896 */
8bbb1cf6 2897static int
8a7e4c24 2898scsih_dev_reset(struct scsi_cmnd *scmd)
f92363d1
SR		 2899{
2900 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2901 struct MPT3SAS_DEVICE *sas_device_priv_data;
d1cb5e49 2902 struct _sas_device *sas_device = NULL;
c1a6c5ac 2903 struct _pcie_device *pcie_device = NULL;
f92363d1 2904 u16 handle;
c1a6c5ac
C		 2905 u8 tr_method = 0;
2906 u8 tr_timeout = 30;
f92363d1
SR		 2907 int r;
2908
d1cb5e49
SR		 2909 struct scsi_target *starget = scmd->device->sdev_target;
2910 struct MPT3SAS_TARGET *target_priv_data = starget->hostdata;
2911
f92363d1
SR		 2912 sdev_printk(KERN_INFO, scmd->device,
2913 "attempting device reset! scmd(%p)\n", scmd);
2914 _scsih_tm_display_info(ioc, scmd);
2915
2916 sas_device_priv_data = scmd->device->hostdata;
9ff549ff
MFO		 2917 if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
2918 ioc->remove_host) {
f92363d1
SR		 2919 sdev_printk(KERN_INFO, scmd->device,
2920 "device been deleted! scmd(%p)\n", scmd);
2921 scmd->result = DID_NO_CONNECT << 16;
2922 scmd->scsi_done(scmd);
2923 r = SUCCESS;
2924 goto out;
2925 }
2926
2927 /* for hidden raid components obtain the volume_handle */
2928 handle = 0;
2929 if (sas_device_priv_data->sas_target->flags &
2930 MPT_TARGET_FLAGS_RAID_COMPONENT) {
d1cb5e49
SR		 2931 sas_device = mpt3sas_get_sdev_from_target(ioc,
2932 target_priv_data);
f92363d1
SR		 2933 if (sas_device)
2934 handle = sas_device->volume_handle;
f92363d1
SR		 2935 } else
2936 handle = sas_device_priv_data->sas_target->handle;
2937
2938 if (!handle) {
2939 scmd->result = DID_RESET << 16;
2940 r = FAILED;
2941 goto out;
2942 }
2943
c1a6c5ac
C		 2944 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
2945
2946 if (pcie_device && (!ioc->tm_custom_handling)) {
2947 tr_timeout = pcie_device->reset_timeout;
2948 tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE;
2949 } else
2950 tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
6da999fe 2951 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->lun,
c1a6c5ac
C		 2952 MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, 0, 0,
2953 tr_timeout, tr_method);
74fcfa53
HR		 2954 /* Check for busy commands after reset */
2955 if (r == SUCCESS && atomic_read(&scmd->device->device_busy))
2956 r = FAILED;
f92363d1
SR		 2957 out:
2958 sdev_printk(KERN_INFO, scmd->device, "device reset: %s scmd(%p)\n",
2959 ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
d1cb5e49
SR		 2960
2961 if (sas_device)
2962 sas_device_put(sas_device);
c1a6c5ac
C		 2963 if (pcie_device)
2964 pcie_device_put(pcie_device);
d1cb5e49 2965
f92363d1
SR		 2966 return r;
2967}
2968
2969/**
8a7e4c24 2970 * scsih_target_reset - eh threads main target reset routine
f92363d1
SR		 2971 * @scmd: pointer to scsi command object
2972 *
4beb4867 2973 * Return: SUCCESS if command aborted else FAILED
f92363d1 2974 */
8bbb1cf6 2975static int
8a7e4c24 2976scsih_target_reset(struct scsi_cmnd *scmd)
f92363d1
SR		 2977{
2978 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2979 struct MPT3SAS_DEVICE *sas_device_priv_data;
d1cb5e49 2980 struct _sas_device *sas_device = NULL;
c1a6c5ac 2981 struct _pcie_device *pcie_device = NULL;
f92363d1 2982 u16 handle;
c1a6c5ac
C		 2983 u8 tr_method = 0;
2984 u8 tr_timeout = 30;
f92363d1
SR		 2985 int r;
2986 struct scsi_target *starget = scmd->device->sdev_target;
d1cb5e49 2987 struct MPT3SAS_TARGET *target_priv_data = starget->hostdata;
f92363d1
SR		 2988
2989 starget_printk(KERN_INFO, starget, "attempting target reset! scmd(%p)\n",
2990 scmd);
2991 _scsih_tm_display_info(ioc, scmd);
2992
2993 sas_device_priv_data = scmd->device->hostdata;
9ff549ff
MFO		 2994 if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
2995 ioc->remove_host) {
f92363d1
SR		 2996 starget_printk(KERN_INFO, starget, "target been deleted! scmd(%p)\n",
2997 scmd);
2998 scmd->result = DID_NO_CONNECT << 16;
2999 scmd->scsi_done(scmd);
3000 r = SUCCESS;
3001 goto out;
3002 }
3003
3004 /* for hidden raid components obtain the volume_handle */
3005 handle = 0;
3006 if (sas_device_priv_data->sas_target->flags &
3007 MPT_TARGET_FLAGS_RAID_COMPONENT) {
d1cb5e49
SR		 3008 sas_device = mpt3sas_get_sdev_from_target(ioc,
3009 target_priv_data);
f92363d1
SR		 3010 if (sas_device)
3011 handle = sas_device->volume_handle;
f92363d1
SR		 3012 } else
3013 handle = sas_device_priv_data->sas_target->handle;
3014
3015 if (!handle) {
3016 scmd->result = DID_RESET << 16;
3017 r = FAILED;
3018 goto out;
3019 }
3020
c1a6c5ac
C		 3021 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
3022
3023 if (pcie_device && (!ioc->tm_custom_handling)) {
3024 tr_timeout = pcie_device->reset_timeout;
3025 tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE;
3026 } else
3027 tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
6da999fe 3028 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, 0,
c1a6c5ac
C		 3029 MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 0,
3030 tr_timeout, tr_method);
74fcfa53
HR		 3031 /* Check for busy commands after reset */
3032 if (r == SUCCESS && atomic_read(&starget->target_busy))
3033 r = FAILED;
f92363d1
SR		 3034 out:
3035 starget_printk(KERN_INFO, starget, "target reset: %s scmd(%p)\n",
3036 ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
d1cb5e49
SR		 3037
3038 if (sas_device)
3039 sas_device_put(sas_device);
c1a6c5ac
C		 3040 if (pcie_device)
3041 pcie_device_put(pcie_device);
f92363d1
SR		 3042 return r;
3043}
3044
3045
3046/**
8a7e4c24 3047 * scsih_host_reset - eh threads main host reset routine
f92363d1
SR		 3048 * @scmd: pointer to scsi command object
3049 *
4beb4867 3050 * Return: SUCCESS if command aborted else FAILED
f92363d1 3051 */
8bbb1cf6 3052static int
8a7e4c24 3053scsih_host_reset(struct scsi_cmnd *scmd)
f92363d1
SR		 3054{
3055 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3056 int r, retval;
3057
919d8a3f 3058 ioc_info(ioc, "attempting host reset! scmd(%p)\n", scmd);
f92363d1
SR		 3059 scsi_print_command(scmd);
3060
9ff549ff 3061 if (ioc->is_driver_loading || ioc->remove_host) {
919d8a3f 3062 ioc_info(ioc, "Blocking the host reset\n");
ddb588be
SR		 3063 r = FAILED;
3064 goto out;
3065 }
3066
98c56ad3 3067 retval = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
f92363d1 3068 r = (retval < 0) ? FAILED : SUCCESS;
ddb588be 3069out:
919d8a3f
JP		 3070 ioc_info(ioc, "host reset: %s scmd(%p)\n",
3071 r == SUCCESS ? "SUCCESS" : "FAILED", scmd);
f92363d1
SR		 3072
3073 return r;
3074}
3075
3076/**
3077 * _scsih_fw_event_add - insert and queue up fw_event
3078 * @ioc: per adapter object
3079 * @fw_event: object describing the event
3080 * Context: This function will acquire ioc->fw_event_lock.
3081 *
3082 * This adds the firmware event object into link list, then queues it up to
3083 * be processed from user context.
f92363d1
SR		 3084 */
3085static void
3086_scsih_fw_event_add(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
3087{
3088 unsigned long flags;
3089
3090 if (ioc->firmware_event_thread == NULL)
3091 return;
3092
3093 spin_lock_irqsave(&ioc->fw_event_lock, flags);
146b16c8 3094 fw_event_work_get(fw_event);
f92363d1
SR		 3095 INIT_LIST_HEAD(&fw_event->list);
3096 list_add_tail(&fw_event->list, &ioc->fw_event_list);
3097 INIT_WORK(&fw_event->work, _firmware_event_work);
146b16c8 3098 fw_event_work_get(fw_event);
f92363d1
SR		 3099 queue_work(ioc->firmware_event_thread, &fw_event->work);
3100 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3101}
3102
3103/**
146b16c8 3104 * _scsih_fw_event_del_from_list - delete fw_event from the list
f92363d1
SR		 3105 * @ioc: per adapter object
3106 * @fw_event: object describing the event
3107 * Context: This function will acquire ioc->fw_event_lock.
3108 *
146b16c8 3109 * If the fw_event is on the fw_event_list, remove it and do a put.
f92363d1
SR		 3110 */
3111static void
146b16c8 3112_scsih_fw_event_del_from_list(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work
f92363d1
SR		 3113 *fw_event)
3114{
3115 unsigned long flags;
3116
3117 spin_lock_irqsave(&ioc->fw_event_lock, flags);
146b16c8
SR		 3118 if (!list_empty(&fw_event->list)) {
3119 list_del_init(&fw_event->list);
3120 fw_event_work_put(fw_event);
3121 }
f92363d1
SR		 3122 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3123}
3124
3125
3126 /**
3127 * mpt3sas_send_trigger_data_event - send event for processing trigger data
3128 * @ioc: per adapter object
3129 * @event_data: trigger event data
f92363d1
SR		 3130 */
3131void
3132mpt3sas_send_trigger_data_event(struct MPT3SAS_ADAPTER *ioc,
3133 struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data)
3134{
3135 struct fw_event_work *fw_event;
146b16c8 3136 u16 sz;
f92363d1
SR		 3137
3138 if (ioc->is_driver_loading)
3139 return;
146b16c8
SR		 3140 sz = sizeof(*event_data);
3141 fw_event = alloc_fw_event_work(sz);
f92363d1
SR		 3142 if (!fw_event)
3143 return;
f92363d1
SR		 3144 fw_event->event = MPT3SAS_PROCESS_TRIGGER_DIAG;
3145 fw_event->ioc = ioc;
3146 memcpy(fw_event->event_data, event_data, sizeof(*event_data));
3147 _scsih_fw_event_add(ioc, fw_event);
146b16c8 3148 fw_event_work_put(fw_event);
f92363d1
SR		 3149}
3150
3151/**
3152 * _scsih_error_recovery_delete_devices - remove devices not responding
3153 * @ioc: per adapter object
f92363d1
SR		 3154 */
3155static void
3156_scsih_error_recovery_delete_devices(struct MPT3SAS_ADAPTER *ioc)
3157{
3158 struct fw_event_work *fw_event;
3159
3160 if (ioc->is_driver_loading)
3161 return;
146b16c8 3162 fw_event = alloc_fw_event_work(0);
f92363d1
SR		 3163 if (!fw_event)
3164 return;
3165 fw_event->event = MPT3SAS_REMOVE_UNRESPONDING_DEVICES;
3166 fw_event->ioc = ioc;
3167 _scsih_fw_event_add(ioc, fw_event);
146b16c8 3168 fw_event_work_put(fw_event);
f92363d1
SR		 3169}
3170
3171/**
3172 * mpt3sas_port_enable_complete - port enable completed (fake event)
3173 * @ioc: per adapter object
f92363d1
SR		 3174 */
3175void
3176mpt3sas_port_enable_complete(struct MPT3SAS_ADAPTER *ioc)
3177{
3178 struct fw_event_work *fw_event;
3179
146b16c8 3180 fw_event = alloc_fw_event_work(0);
f92363d1
SR		 3181 if (!fw_event)
3182 return;
3183 fw_event->event = MPT3SAS_PORT_ENABLE_COMPLETE;
3184 fw_event->ioc = ioc;
3185 _scsih_fw_event_add(ioc, fw_event);
146b16c8
SR		 3186 fw_event_work_put(fw_event);
3187}
3188
3189static struct fw_event_work *dequeue_next_fw_event(struct MPT3SAS_ADAPTER *ioc)
3190{
3191 unsigned long flags;
3192 struct fw_event_work *fw_event = NULL;
3193
3194 spin_lock_irqsave(&ioc->fw_event_lock, flags);
3195 if (!list_empty(&ioc->fw_event_list)) {
3196 fw_event = list_first_entry(&ioc->fw_event_list,
3197 struct fw_event_work, list);
3198 list_del_init(&fw_event->list);
3199 }
3200 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3201
3202 return fw_event;
f92363d1
SR		 3203}
3204
3205/**
3206 * _scsih_fw_event_cleanup_queue - cleanup event queue
3207 * @ioc: per adapter object
3208 *
3209 * Walk the firmware event queue, either killing timers, or waiting
3210 * for outstanding events to complete
f92363d1
SR		 3211 */
3212static void
3213_scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc)
3214{
146b16c8 3215 struct fw_event_work *fw_event;
f92363d1
SR		 3216
3217 if (list_empty(&ioc->fw_event_list) ||
3218 !ioc->firmware_event_thread || in_interrupt())
3219 return;
3220
146b16c8
SR		 3221 while ((fw_event = dequeue_next_fw_event(ioc))) {
3222 /*
3223 * Wait on the fw_event to complete. If this returns 1, then
3224 * the event was never executed, and we need a put for the
b8ac0cc7 3225 * reference the work had on the fw_event.
146b16c8
SR		 3226 *
3227 * If it did execute, we wait for it to finish, and the put will
3228 * happen from _firmware_event_work()
3229 */
b8ac0cc7 3230 if (cancel_work_sync(&fw_event->work))
146b16c8
SR		 3231 fw_event_work_put(fw_event);
3232
3233 fw_event_work_put(fw_event);
f92363d1
SR		 3234 }
3235}
3236
df838f92
SR		 3237/**
3238 * _scsih_internal_device_block - block the sdev device
3239 * @sdev: per device object
3240 * @sas_device_priv_data : per device driver private data
3241 *
3242 * make sure device is blocked without error, if not
3243 * print an error
3244 */
3245static void
3246_scsih_internal_device_block(struct scsi_device *sdev,
3247 struct MPT3SAS_DEVICE *sas_device_priv_data)
3248{
3249 int r = 0;
3250
3251 sdev_printk(KERN_INFO, sdev, "device_block, handle(0x%04x)\n",
3252 sas_device_priv_data->sas_target->handle);
3253 sas_device_priv_data->block = 1;
3254
551eb598 3255 r = scsi_internal_device_block_nowait(sdev);
df838f92
SR		 3256 if (r == -EINVAL)
3257 sdev_printk(KERN_WARNING, sdev,
3258 "device_block failed with return(%d) for handle(0x%04x)\n",
b2fe6be7 3259 r, sas_device_priv_data->sas_target->handle);
df838f92
SR		 3260}
3261
3262/**
3263 * _scsih_internal_device_unblock - unblock the sdev device
3264 * @sdev: per device object
3265 * @sas_device_priv_data : per device driver private data
3266 * make sure device is unblocked without error, if not retry
3267 * by blocking and then unblocking
3268 */
3269
3270static void
3271_scsih_internal_device_unblock(struct scsi_device *sdev,
3272 struct MPT3SAS_DEVICE *sas_device_priv_data)
3273{
3274 int r = 0;
3275
3276 sdev_printk(KERN_WARNING, sdev, "device_unblock and setting to running, "
3277 "handle(0x%04x)\n", sas_device_priv_data->sas_target->handle);
3278 sas_device_priv_data->block = 0;
43f7571b 3279 r = scsi_internal_device_unblock_nowait(sdev, SDEV_RUNNING);
df838f92
SR		 3280 if (r == -EINVAL) {
3281 /* The device has been set to SDEV_RUNNING by SD layer during
3282 * device addition but the request queue is still stopped by
3283 * our earlier block call. We need to perform a block again
3284 * to get the device to SDEV_BLOCK and then to SDEV_RUNNING */
3285
3286 sdev_printk(KERN_WARNING, sdev,
3287 "device_unblock failed with return(%d) for handle(0x%04x) "
3288 "performing a block followed by an unblock\n",
b2fe6be7 3289 r, sas_device_priv_data->sas_target->handle);
df838f92 3290 sas_device_priv_data->block = 1;
551eb598 3291 r = scsi_internal_device_block_nowait(sdev);
df838f92
SR		 3292 if (r)
3293 sdev_printk(KERN_WARNING, sdev, "retried device_block "
3294 "failed with return(%d) for handle(0x%04x)\n",
b2fe6be7 3295 r, sas_device_priv_data->sas_target->handle);
df838f92
SR		 3296
3297 sas_device_priv_data->block = 0;
43f7571b 3298 r = scsi_internal_device_unblock_nowait(sdev, SDEV_RUNNING);
df838f92
SR		 3299 if (r)
3300 sdev_printk(KERN_WARNING, sdev, "retried device_unblock"
3301 " failed with return(%d) for handle(0x%04x)\n",
b2fe6be7 3302 r, sas_device_priv_data->sas_target->handle);
df838f92
SR		 3303 }
3304}
3305
f92363d1
SR		 3306/**
3307 * _scsih_ublock_io_all_device - unblock every device
3308 * @ioc: per adapter object
3309 *
3310 * change the device state from block to running
3311 */
3312static void
3313_scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc)
3314{
3315 struct MPT3SAS_DEVICE *sas_device_priv_data;
3316 struct scsi_device *sdev;
3317
3318 shost_for_each_device(sdev, ioc->shost) {
3319 sas_device_priv_data = sdev->hostdata;
3320 if (!sas_device_priv_data)
3321 continue;
3322 if (!sas_device_priv_data->block)
3323 continue;
3324
f92363d1
SR		 3325 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
3326 "device_running, handle(0x%04x)\n",
3327 sas_device_priv_data->sas_target->handle));
df838f92 3328 _scsih_internal_device_unblock(sdev, sas_device_priv_data);
f92363d1
SR		 3329 }
3330}
3331
3332
3333/**
3334 * _scsih_ublock_io_device - prepare device to be deleted
3335 * @ioc: per adapter object
4beb4867 3336 * @sas_address: sas address
f92363d1
SR		 3337 *
3338 * unblock then put device in offline state
3339 */
3340static void
3341_scsih_ublock_io_device(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
3342{
3343 struct MPT3SAS_DEVICE *sas_device_priv_data;
3344 struct scsi_device *sdev;
3345
3346 shost_for_each_device(sdev, ioc->shost) {
3347 sas_device_priv_data = sdev->hostdata;
3348 if (!sas_device_priv_data)
3349 continue;
3350 if (sas_device_priv_data->sas_target->sas_address
3351 != sas_address)
3352 continue;
df838f92
SR		 3353 if (sas_device_priv_data->block)
3354 _scsih_internal_device_unblock(sdev,
3355 sas_device_priv_data);
f92363d1
SR		 3356 }
3357}
3358
3359/**
3360 * _scsih_block_io_all_device - set the device state to SDEV_BLOCK
3361 * @ioc: per adapter object
f92363d1 3362 *
6c7abffc 3363 * During device pull we need to appropriately set the sdev state.
f92363d1
SR		 3364 */
3365static void
3366_scsih_block_io_all_device(struct MPT3SAS_ADAPTER *ioc)
3367{
3368 struct MPT3SAS_DEVICE *sas_device_priv_data;
3369 struct scsi_device *sdev;
3370
3371 shost_for_each_device(sdev, ioc->shost) {
3372 sas_device_priv_data = sdev->hostdata;
3373 if (!sas_device_priv_data)
3374 continue;
3375 if (sas_device_priv_data->block)
3376 continue;
30158dc9
SS		 3377 if (sas_device_priv_data->ignore_delay_remove) {
3378 sdev_printk(KERN_INFO, sdev,
3379 "%s skip device_block for SES handle(0x%04x)\n",
3380 __func__, sas_device_priv_data->sas_target->handle);
3381 continue;
3382 }
df838f92 3383 _scsih_internal_device_block(sdev, sas_device_priv_data);
f92363d1
SR		 3384 }
3385}
3386
3387/**
3388 * _scsih_block_io_device - set the device state to SDEV_BLOCK
3389 * @ioc: per adapter object
3390 * @handle: device handle
3391 *
6c7abffc 3392 * During device pull we need to appropriately set the sdev state.
f92363d1
SR		 3393 */
3394static void
3395_scsih_block_io_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3396{
3397 struct MPT3SAS_DEVICE *sas_device_priv_data;
3398 struct scsi_device *sdev;
e4bc7f5c
SR		 3399 struct _sas_device *sas_device;
3400
d1cb5e49 3401 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
f92363d1
SR		 3402
3403 shost_for_each_device(sdev, ioc->shost) {
3404 sas_device_priv_data = sdev->hostdata;
3405 if (!sas_device_priv_data)
3406 continue;
3407 if (sas_device_priv_data->sas_target->handle != handle)
3408 continue;
3409 if (sas_device_priv_data->block)
3410 continue;
4318c734 3411 if (sas_device && sas_device->pend_sas_rphy_add)
e4bc7f5c 3412 continue;
30158dc9
SS		 3413 if (sas_device_priv_data->ignore_delay_remove) {
3414 sdev_printk(KERN_INFO, sdev,
3415 "%s skip device_block for SES handle(0x%04x)\n",
3416 __func__, sas_device_priv_data->sas_target->handle);
3417 continue;
3418 }
df838f92 3419 _scsih_internal_device_block(sdev, sas_device_priv_data);
f92363d1 3420 }
d1cb5e49 3421
4318c734
SPS		 3422 if (sas_device)
3423 sas_device_put(sas_device);
f92363d1
SR		 3424}
3425
3426/**
3427 * _scsih_block_io_to_children_attached_to_ex
3428 * @ioc: per adapter object
3429 * @sas_expander: the sas_device object
3430 *
3431 * This routine set sdev state to SDEV_BLOCK for all devices
3432 * attached to this expander. This function called when expander is
3433 * pulled.
3434 */
3435static void
3436_scsih_block_io_to_children_attached_to_ex(struct MPT3SAS_ADAPTER *ioc,
3437 struct _sas_node *sas_expander)
3438{
3439 struct _sas_port *mpt3sas_port;
3440 struct _sas_device *sas_device;
3441 struct _sas_node *expander_sibling;
3442 unsigned long flags;
3443
3444 if (!sas_expander)
3445 return;
3446
3447 list_for_each_entry(mpt3sas_port,
3448 &sas_expander->sas_port_list, port_list) {
3449 if (mpt3sas_port->remote_identify.device_type ==
3450 SAS_END_DEVICE) {
3451 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49
SR		 3452 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
3453 mpt3sas_port->remote_identify.sas_address);
3454 if (sas_device) {
f92363d1 3455 set_bit(sas_device->handle,
d1cb5e49
SR		 3456 ioc->blocking_handles);
3457 sas_device_put(sas_device);
3458 }
f92363d1
SR		 3459 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3460 }
3461 }
3462
3463 list_for_each_entry(mpt3sas_port,
3464 &sas_expander->sas_port_list, port_list) {
3465
3466 if (mpt3sas_port->remote_identify.device_type ==
3467 SAS_EDGE_EXPANDER_DEVICE ||
3468 mpt3sas_port->remote_identify.device_type ==
3469 SAS_FANOUT_EXPANDER_DEVICE) {
3470 expander_sibling =
3471 mpt3sas_scsih_expander_find_by_sas_address(
3472 ioc, mpt3sas_port->remote_identify.sas_address);
3473 _scsih_block_io_to_children_attached_to_ex(ioc,
3474 expander_sibling);
3475 }
3476 }
3477}
3478
3479/**
3480 * _scsih_block_io_to_children_attached_directly
3481 * @ioc: per adapter object
3482 * @event_data: topology change event data
3483 *
3484 * This routine set sdev state to SDEV_BLOCK for all devices
3485 * direct attached during device pull.
3486 */
3487static void
3488_scsih_block_io_to_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
3489 Mpi2EventDataSasTopologyChangeList_t *event_data)
3490{
3491 int i;
3492 u16 handle;
3493 u16 reason_code;
f92363d1
SR		 3494
3495 for (i = 0; i < event_data->NumEntries; i++) {
3496 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3497 if (!handle)
3498 continue;
f92363d1
SR		 3499 reason_code = event_data->PHY[i].PhyStatus &
3500 MPI2_EVENT_SAS_TOPO_RC_MASK;
3501 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING)
3502 _scsih_block_io_device(ioc, handle);
3503 }
3504}
3505
4318c734
SPS		 3506/**
3507 * _scsih_block_io_to_pcie_children_attached_directly
3508 * @ioc: per adapter object
3509 * @event_data: topology change event data
3510 *
3511 * This routine set sdev state to SDEV_BLOCK for all devices
3512 * direct attached during device pull/reconnect.
3513 */
3514static void
3515_scsih_block_io_to_pcie_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
3516 Mpi26EventDataPCIeTopologyChangeList_t *event_data)
3517{
3518 int i;
3519 u16 handle;
3520 u16 reason_code;
3521
3522 for (i = 0; i < event_data->NumEntries; i++) {
3523 handle =
3524 le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle);
3525 if (!handle)
3526 continue;
3527 reason_code = event_data->PortEntry[i].PortStatus;
3528 if (reason_code ==
3529 MPI26_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING)
3530 _scsih_block_io_device(ioc, handle);
3531 }
3532}
f92363d1
SR		 3533/**
3534 * _scsih_tm_tr_send - send task management request
3535 * @ioc: per adapter object
3536 * @handle: device handle
3537 * Context: interrupt time.
3538 *
3539 * This code is to initiate the device removal handshake protocol
3540 * with controller firmware. This function will issue target reset
3541 * using high priority request queue. It will send a sas iounit
3542 * control request (MPI2_SAS_OP_REMOVE_DEVICE) from this completion.
3543 *
3544 * This is designed to send muliple task management request at the same
3545 * time to the fifo. If the fifo is full, we will append the request,
3546 * and process it in a future completion.
3547 */
3548static void
3549_scsih_tm_tr_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3550{
3551 Mpi2SCSITaskManagementRequest_t *mpi_request;
3552 u16 smid;
d1cb5e49 3553 struct _sas_device *sas_device = NULL;
6ce2f1d1 3554 struct _pcie_device *pcie_device = NULL;
f92363d1
SR		 3555 struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
3556 u64 sas_address = 0;
3557 unsigned long flags;
3558 struct _tr_list *delayed_tr;
3559 u32 ioc_state;
c1a6c5ac 3560 u8 tr_method = 0;
f92363d1 3561
6ce2f1d1 3562 if (ioc->pci_error_recovery) {
4dc74b2e
JP		 3563 dewtprintk(ioc,
3564 ioc_info(ioc, "%s: host in pci error recovery: handle(0x%04x)\n",
3565 __func__, handle));
f92363d1
SR		 3566 return;
3567 }
3568 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
3569 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
4dc74b2e
JP		 3570 dewtprintk(ioc,
3571 ioc_info(ioc, "%s: host is not operational: handle(0x%04x)\n",
3572 __func__, handle));
f92363d1
SR		 3573 return;
3574 }
3575
3576 /* if PD, then return */
3577 if (test_bit(handle, ioc->pd_handles))
3578 return;
3579
c696f7b8
SPS		 3580 clear_bit(handle, ioc->pend_os_device_add);
3581
f92363d1 3582 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49 3583 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
f92363d1
SR		 3584 if (sas_device && sas_device->starget &&
3585 sas_device->starget->hostdata) {
3586 sas_target_priv_data = sas_device->starget->hostdata;
3587 sas_target_priv_data->deleted = 1;
3588 sas_address = sas_device->sas_address;
3589 }
3590 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6ce2f1d1
SPS		 3591 if (!sas_device) {
3592 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
3593 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
3594 if (pcie_device && pcie_device->starget &&
3595 pcie_device->starget->hostdata) {
3596 sas_target_priv_data = pcie_device->starget->hostdata;
3597 sas_target_priv_data->deleted = 1;
3598 sas_address = pcie_device->wwid;
3599 }
3600 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
c1a6c5ac
C		 3601 if (pcie_device && (!ioc->tm_custom_handling))
3602 tr_method =
3603 MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE;
3604 else
3605 tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
6ce2f1d1 3606 }
f92363d1 3607 if (sas_target_priv_data) {
919d8a3f
JP		 3608 dewtprintk(ioc,
3609 ioc_info(ioc, "setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n",
3610 handle, (u64)sas_address));
6ce2f1d1
SPS		 3611 if (sas_device) {
3612 if (sas_device->enclosure_handle != 0)
919d8a3f
JP		 3613 dewtprintk(ioc,
3614 ioc_info(ioc, "setting delete flag:enclosure logical id(0x%016llx), slot(%d)\n",
3615 (u64)sas_device->enclosure_logical_id,
3616 sas_device->slot));
6ce2f1d1 3617 if (sas_device->connector_name[0] != '\0')
919d8a3f
JP		 3618 dewtprintk(ioc,
3619 ioc_info(ioc, "setting delete flag: enclosure level(0x%04x), connector name( %s)\n",
3620 sas_device->enclosure_level,
3621 sas_device->connector_name));
6ce2f1d1
SPS		 3622 } else if (pcie_device) {
3623 if (pcie_device->enclosure_handle != 0)
919d8a3f
JP		 3624 dewtprintk(ioc,
3625 ioc_info(ioc, "setting delete flag: logical id(0x%016llx), slot(%d)\n",
3626 (u64)pcie_device->enclosure_logical_id,
3627 pcie_device->slot));
6ce2f1d1 3628 if (pcie_device->connector_name[0] != '\0')
919d8a3f
JP		 3629 dewtprintk(ioc,
3630 ioc_info(ioc, "setting delete flag:, enclosure level(0x%04x), connector name( %s)\n",
3631 pcie_device->enclosure_level,
3632 pcie_device->connector_name));
6ce2f1d1 3633 }
f92363d1
SR		 3634 _scsih_ublock_io_device(ioc, sas_address);
3635 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
3636 }
3637
3638 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
3639 if (!smid) {
3640 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3641 if (!delayed_tr)
d1cb5e49 3642 goto out;
f92363d1
SR		 3643 INIT_LIST_HEAD(&delayed_tr->list);
3644 delayed_tr->handle = handle;
3645 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
919d8a3f
JP		 3646 dewtprintk(ioc,
3647 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
3648 handle));
d1cb5e49 3649 goto out;
f92363d1
SR		 3650 }
3651
919d8a3f
JP		 3652 dewtprintk(ioc,
3653 ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
3654 handle, smid, ioc->tm_tr_cb_idx));
f92363d1
SR		 3655 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3656 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3657 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3658 mpi_request->DevHandle = cpu_to_le16(handle);
3659 mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
c1a6c5ac 3660 mpi_request->MsgFlags = tr_method;
c696f7b8 3661 set_bit(handle, ioc->device_remove_in_progress);
40114bde 3662 mpt3sas_base_put_smid_hi_priority(ioc, smid, 0);
f92363d1 3663 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_DEVICE_REMOVAL);
d1cb5e49
SR		 3664
3665out:
3666 if (sas_device)
3667 sas_device_put(sas_device);
6ce2f1d1
SPS		 3668 if (pcie_device)
3669 pcie_device_put(pcie_device);
f92363d1
SR		 3670}
3671
3672/**
3673 * _scsih_tm_tr_complete -
3674 * @ioc: per adapter object
3675 * @smid: system request message index
3676 * @msix_index: MSIX table index supplied by the OS
3677 * @reply: reply message frame(lower 32bit addr)
3678 * Context: interrupt time.
3679 *
3680 * This is the target reset completion routine.
3681 * This code is part of the code to initiate the device removal
3682 * handshake protocol with controller firmware.
3683 * It will send a sas iounit control request (MPI2_SAS_OP_REMOVE_DEVICE)
3684 *
4beb4867
BVA		 3685 * Return: 1 meaning mf should be freed from _base_interrupt
3686 * 0 means the mf is freed from this function.
f92363d1
SR		 3687 */
3688static u8
3689_scsih_tm_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
3690 u32 reply)
3691{
3692 u16 handle;
3693 Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3694 Mpi2SCSITaskManagementReply_t *mpi_reply =
3695 mpt3sas_base_get_reply_virt_addr(ioc, reply);
3696 Mpi2SasIoUnitControlRequest_t *mpi_request;
3697 u16 smid_sas_ctrl;
3698 u32 ioc_state;
fd0331b3 3699 struct _sc_list *delayed_sc;
f92363d1 3700
79eb96d6 3701 if (ioc->pci_error_recovery) {
919d8a3f
JP		 3702 dewtprintk(ioc,
3703 ioc_info(ioc, "%s: host in pci error recovery\n",
3704 __func__));
f92363d1
SR		 3705 return 1;
3706 }
3707 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
3708 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
919d8a3f
JP		 3709 dewtprintk(ioc,
3710 ioc_info(ioc, "%s: host is not operational\n",
3711 __func__));
f92363d1
SR		 3712 return 1;
3713 }
3714 if (unlikely(!mpi_reply)) {
919d8a3f
JP		 3715 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
3716 __FILE__, __LINE__, __func__);
f92363d1
SR		 3717 return 1;
3718 }
3719 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
3720 handle = le16_to_cpu(mpi_request_tm->DevHandle);
3721 if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
919d8a3f
JP		 3722 dewtprintk(ioc,
3723 ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
3724 handle,
3725 le16_to_cpu(mpi_reply->DevHandle), smid));
f92363d1
SR		 3726 return 0;
3727 }
3728
3729 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
919d8a3f
JP		 3730 dewtprintk(ioc,
3731 ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n",
3732 handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3733 le32_to_cpu(mpi_reply->IOCLogInfo),
3734 le32_to_cpu(mpi_reply->TerminationCount)));
f92363d1
SR		 3735
3736 smid_sas_ctrl = mpt3sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
3737 if (!smid_sas_ctrl) {
fd0331b3
SS		 3738 delayed_sc = kzalloc(sizeof(*delayed_sc), GFP_ATOMIC);
3739 if (!delayed_sc)
3740 return _scsih_check_for_pending_tm(ioc, smid);
3741 INIT_LIST_HEAD(&delayed_sc->list);
cf6bf971 3742 delayed_sc->handle = le16_to_cpu(mpi_request_tm->DevHandle);
fd0331b3 3743 list_add_tail(&delayed_sc->list, &ioc->delayed_sc_list);
919d8a3f
JP		 3744 dewtprintk(ioc,
3745 ioc_info(ioc, "DELAYED:sc:handle(0x%04x), (open)\n",
3746 handle));
fd0331b3 3747 return _scsih_check_for_pending_tm(ioc, smid);
f92363d1
SR		 3748 }
3749
919d8a3f
JP		 3750 dewtprintk(ioc,
3751 ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
3752 handle, smid_sas_ctrl, ioc->tm_sas_control_cb_idx));
f92363d1
SR		 3753 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid_sas_ctrl);
3754 memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
3755 mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
3756 mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
3757 mpi_request->DevHandle = mpi_request_tm->DevHandle;
40114bde 3758 mpt3sas_base_put_smid_default(ioc, smid_sas_ctrl);
f92363d1
SR		 3759
3760 return _scsih_check_for_pending_tm(ioc, smid);
3761}
3762
9029a725
SP		 3763/** _scsih_allow_scmd_to_device - check whether scmd needs to
3764 * issue to IOC or not.
3765 * @ioc: per adapter object
3766 * @scmd: pointer to scsi command object
3767 *
3768 * Returns true if scmd can be issued to IOC otherwise returns false.
3769 */
3770inline bool _scsih_allow_scmd_to_device(struct MPT3SAS_ADAPTER *ioc,
3771 struct scsi_cmnd *scmd)
3772{
3773
3774 if (ioc->pci_error_recovery)
3775 return false;
3776
3777 if (ioc->hba_mpi_version_belonged == MPI2_VERSION) {
3778 if (ioc->remove_host)
3779 return false;
3780
3781 return true;
3782 }
3783
3784 if (ioc->remove_host) {
3785
3786 switch (scmd->cmnd[0]) {
3787 case SYNCHRONIZE_CACHE:
3788 case START_STOP:
3789 return true;
3790 default:
3791 return false;
3792 }
3793 }
3794
3795 return true;
3796}
f92363d1
SR		 3797
3798/**
3799 * _scsih_sas_control_complete - completion routine
3800 * @ioc: per adapter object
3801 * @smid: system request message index
3802 * @msix_index: MSIX table index supplied by the OS
3803 * @reply: reply message frame(lower 32bit addr)
3804 * Context: interrupt time.
3805 *
3806 * This is the sas iounit control completion routine.
3807 * This code is part of the code to initiate the device removal
3808 * handshake protocol with controller firmware.
3809 *
4beb4867
BVA		 3810 * Return: 1 meaning mf should be freed from _base_interrupt
3811 * 0 means the mf is freed from this function.
f92363d1
SR		 3812 */
3813static u8
3814_scsih_sas_control_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
3815 u8 msix_index, u32 reply)
3816{
3817 Mpi2SasIoUnitControlReply_t *mpi_reply =
3818 mpt3sas_base_get_reply_virt_addr(ioc, reply);
3819
3820 if (likely(mpi_reply)) {
919d8a3f
JP		 3821 dewtprintk(ioc,
3822 ioc_info(ioc, "sc_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
3823 le16_to_cpu(mpi_reply->DevHandle), smid,
3824 le16_to_cpu(mpi_reply->IOCStatus),
3825 le32_to_cpu(mpi_reply->IOCLogInfo)));
c696f7b8
SPS		 3826 if (le16_to_cpu(mpi_reply->IOCStatus) ==
3827 MPI2_IOCSTATUS_SUCCESS) {
3828 clear_bit(le16_to_cpu(mpi_reply->DevHandle),
3829 ioc->device_remove_in_progress);
3830 }
f92363d1 3831 } else {
919d8a3f
JP		 3832 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
3833 __FILE__, __LINE__, __func__);
f92363d1 3834 }
fd0331b3 3835 return mpt3sas_check_for_pending_internal_cmds(ioc, smid);
f92363d1
SR		 3836}
3837
3838/**
3839 * _scsih_tm_tr_volume_send - send target reset request for volumes
3840 * @ioc: per adapter object
3841 * @handle: device handle
3842 * Context: interrupt time.
3843 *
3844 * This is designed to send muliple task management request at the same
3845 * time to the fifo. If the fifo is full, we will append the request,
3846 * and process it in a future completion.
3847 */
3848static void
3849_scsih_tm_tr_volume_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3850{
3851 Mpi2SCSITaskManagementRequest_t *mpi_request;
3852 u16 smid;
3853 struct _tr_list *delayed_tr;
3854
79eb96d6 3855 if (ioc->pci_error_recovery) {
4dc74b2e
JP		 3856 dewtprintk(ioc,
3857 ioc_info(ioc, "%s: host reset in progress!\n",
3858 __func__));
f92363d1
SR		 3859 return;
3860 }
3861
3862 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
3863 if (!smid) {
3864 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3865 if (!delayed_tr)
3866 return;
3867 INIT_LIST_HEAD(&delayed_tr->list);
3868 delayed_tr->handle = handle;
3869 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
919d8a3f
JP		 3870 dewtprintk(ioc,
3871 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
3872 handle));
f92363d1
SR		 3873 return;
3874 }
3875
919d8a3f
JP		 3876 dewtprintk(ioc,
3877 ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
3878 handle, smid, ioc->tm_tr_volume_cb_idx));
f92363d1
SR		 3879 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3880 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3881 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3882 mpi_request->DevHandle = cpu_to_le16(handle);
3883 mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
40114bde 3884 mpt3sas_base_put_smid_hi_priority(ioc, smid, 0);
f92363d1
SR		 3885}
3886
3887/**
3888 * _scsih_tm_volume_tr_complete - target reset completion
3889 * @ioc: per adapter object
3890 * @smid: system request message index
3891 * @msix_index: MSIX table index supplied by the OS
3892 * @reply: reply message frame(lower 32bit addr)
3893 * Context: interrupt time.
3894 *
4beb4867
BVA		 3895 * Return: 1 meaning mf should be freed from _base_interrupt
3896 * 0 means the mf is freed from this function.
f92363d1
SR		 3897 */
3898static u8
3899_scsih_tm_volume_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
3900 u8 msix_index, u32 reply)
3901{
3902 u16 handle;
3903 Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3904 Mpi2SCSITaskManagementReply_t *mpi_reply =
3905 mpt3sas_base_get_reply_virt_addr(ioc, reply);
3906
79eb96d6 3907 if (ioc->shost_recovery || ioc->pci_error_recovery) {
4dc74b2e
JP		 3908 dewtprintk(ioc,
3909 ioc_info(ioc, "%s: host reset in progress!\n",
3910 __func__));
f92363d1
SR		 3911 return 1;
3912 }
3913 if (unlikely(!mpi_reply)) {
919d8a3f
JP		 3914 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
3915 __FILE__, __LINE__, __func__);
f92363d1
SR		 3916 return 1;
3917 }
3918
3919 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
3920 handle = le16_to_cpu(mpi_request_tm->DevHandle);
3921 if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
919d8a3f
JP		 3922 dewtprintk(ioc,
3923 ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
3924 handle, le16_to_cpu(mpi_reply->DevHandle),
3925 smid));
f92363d1
SR		 3926 return 0;
3927 }
3928
919d8a3f
JP		 3929 dewtprintk(ioc,
3930 ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n",
3931 handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3932 le32_to_cpu(mpi_reply->IOCLogInfo),
3933 le32_to_cpu(mpi_reply->TerminationCount)));
f92363d1
SR		 3934
3935 return _scsih_check_for_pending_tm(ioc, smid);
3936}
3937
fd0331b3
SS		 3938/**
3939 * _scsih_issue_delayed_event_ack - issue delayed Event ACK messages
3940 * @ioc: per adapter object
3941 * @smid: system request message index
3942 * @event: Event ID
3943 * @event_context: used to track events uniquely
3944 *
3945 * Context - processed in interrupt context.
3946 */
8bbb1cf6 3947static void
cf6bf971
C		 3948_scsih_issue_delayed_event_ack(struct MPT3SAS_ADAPTER *ioc, u16 smid, U16 event,
3949 U32 event_context)
fd0331b3
SS		 3950{
3951 Mpi2EventAckRequest_t *ack_request;
3952 int i = smid - ioc->internal_smid;
3953 unsigned long flags;
3954
3955 /* Without releasing the smid just update the
3956 * call back index and reuse the same smid for
3957 * processing this delayed request
3958 */
3959 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
3960 ioc->internal_lookup[i].cb_idx = ioc->base_cb_idx;
3961 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
3962
919d8a3f
JP		 3963 dewtprintk(ioc,
3964 ioc_info(ioc, "EVENT ACK: event(0x%04x), smid(%d), cb(%d)\n",
3965 le16_to_cpu(event), smid, ioc->base_cb_idx));
fd0331b3
SS		 3966 ack_request = mpt3sas_base_get_msg_frame(ioc, smid);
3967 memset(ack_request, 0, sizeof(Mpi2EventAckRequest_t));
3968 ack_request->Function = MPI2_FUNCTION_EVENT_ACK;
3969 ack_request->Event = event;
3970 ack_request->EventContext = event_context;
3971 ack_request->VF_ID = 0; /* TODO */
3972 ack_request->VP_ID = 0;
40114bde 3973 mpt3sas_base_put_smid_default(ioc, smid);
fd0331b3
SS		 3974}
3975
3976/**
3977 * _scsih_issue_delayed_sas_io_unit_ctrl - issue delayed
3978 * sas_io_unit_ctrl messages
3979 * @ioc: per adapter object
3980 * @smid: system request message index
3981 * @handle: device handle
3982 *
3983 * Context - processed in interrupt context.
3984 */
8bbb1cf6 3985static void
fd0331b3
SS		 3986_scsih_issue_delayed_sas_io_unit_ctrl(struct MPT3SAS_ADAPTER *ioc,
3987 u16 smid, u16 handle)
199fd79a
BVA		 3988{
3989 Mpi2SasIoUnitControlRequest_t *mpi_request;
3990 u32 ioc_state;
3991 int i = smid - ioc->internal_smid;
3992 unsigned long flags;
fd0331b3 3993
199fd79a 3994 if (ioc->remove_host) {
4dc74b2e
JP		 3995 dewtprintk(ioc,
3996 ioc_info(ioc, "%s: host has been removed\n",
3997 __func__));
199fd79a
BVA		 3998 return;
3999 } else if (ioc->pci_error_recovery) {
4dc74b2e
JP		 4000 dewtprintk(ioc,
4001 ioc_info(ioc, "%s: host in pci error recovery\n",
4002 __func__));
fd0331b3
SS		 4003 return;
4004 }
4005 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
4006 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
4dc74b2e
JP		 4007 dewtprintk(ioc,
4008 ioc_info(ioc, "%s: host is not operational\n",
4009 __func__));
fd0331b3
SS		 4010 return;
4011 }
4012
4013 /* Without releasing the smid just update the
4014 * call back index and reuse the same smid for
4015 * processing this delayed request
4016 */
4017 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4018 ioc->internal_lookup[i].cb_idx = ioc->tm_sas_control_cb_idx;
4019 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4020
919d8a3f
JP		 4021 dewtprintk(ioc,
4022 ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
4023 handle, smid, ioc->tm_sas_control_cb_idx));
fd0331b3
SS		 4024 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4025 memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
4026 mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
4027 mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
cf6bf971 4028 mpi_request->DevHandle = cpu_to_le16(handle);
40114bde 4029 mpt3sas_base_put_smid_default(ioc, smid);
fd0331b3
SS		 4030}
4031
4032/**
4033 * _scsih_check_for_pending_internal_cmds - check for pending internal messages
4034 * @ioc: per adapter object
4035 * @smid: system request message index
4036 *
4037 * Context: Executed in interrupt context
4038 *
4039 * This will check delayed internal messages list, and process the
4040 * next request.
4041 *
4beb4867
BVA		 4042 * Return: 1 meaning mf should be freed from _base_interrupt
4043 * 0 means the mf is freed from this function.
fd0331b3
SS		 4044 */
4045u8
4046mpt3sas_check_for_pending_internal_cmds(struct MPT3SAS_ADAPTER *ioc, u16 smid)
4047{
4048 struct _sc_list *delayed_sc;
4049 struct _event_ack_list *delayed_event_ack;
4050
4051 if (!list_empty(&ioc->delayed_event_ack_list)) {
4052 delayed_event_ack = list_entry(ioc->delayed_event_ack_list.next,
4053 struct _event_ack_list, list);
4054 _scsih_issue_delayed_event_ack(ioc, smid,
4055 delayed_event_ack->Event, delayed_event_ack->EventContext);
4056 list_del(&delayed_event_ack->list);
4057 kfree(delayed_event_ack);
4058 return 0;
4059 }
4060
4061 if (!list_empty(&ioc->delayed_sc_list)) {
4062 delayed_sc = list_entry(ioc->delayed_sc_list.next,
4063 struct _sc_list, list);
4064 _scsih_issue_delayed_sas_io_unit_ctrl(ioc, smid,
4065 delayed_sc->handle);
4066 list_del(&delayed_sc->list);
4067 kfree(delayed_sc);
4068 return 0;
4069 }
4070 return 1;
4071}
f92363d1
SR		 4072
4073/**
4074 * _scsih_check_for_pending_tm - check for pending task management
4075 * @ioc: per adapter object
4076 * @smid: system request message index
4077 *
4078 * This will check delayed target reset list, and feed the
4079 * next reqeust.
4080 *
4beb4867
BVA		 4081 * Return: 1 meaning mf should be freed from _base_interrupt
4082 * 0 means the mf is freed from this function.
f92363d1
SR		 4083 */
4084static u8
4085_scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid)
4086{
4087 struct _tr_list *delayed_tr;
4088
4089 if (!list_empty(&ioc->delayed_tr_volume_list)) {
4090 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
4091 struct _tr_list, list);
4092 mpt3sas_base_free_smid(ioc, smid);
4093 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
4094 list_del(&delayed_tr->list);
4095 kfree(delayed_tr);
4096 return 0;
4097 }
4098
4099 if (!list_empty(&ioc->delayed_tr_list)) {
4100 delayed_tr = list_entry(ioc->delayed_tr_list.next,
4101 struct _tr_list, list);
4102 mpt3sas_base_free_smid(ioc, smid);
4103 _scsih_tm_tr_send(ioc, delayed_tr->handle);
4104 list_del(&delayed_tr->list);
4105 kfree(delayed_tr);
4106 return 0;
4107 }
4108
4109 return 1;
4110}
4111
4112/**
4113 * _scsih_check_topo_delete_events - sanity check on topo events
4114 * @ioc: per adapter object
4115 * @event_data: the event data payload
4116 *
4117 * This routine added to better handle cable breaker.
4118 *
4119 * This handles the case where driver receives multiple expander
4120 * add and delete events in a single shot. When there is a delete event
4121 * the routine will void any pending add events waiting in the event queue.
f92363d1
SR		 4122 */
4123static void
4124_scsih_check_topo_delete_events(struct MPT3SAS_ADAPTER *ioc,
4125 Mpi2EventDataSasTopologyChangeList_t *event_data)
4126{
4127 struct fw_event_work *fw_event;
4128 Mpi2EventDataSasTopologyChangeList_t *local_event_data;
4129 u16 expander_handle;
4130 struct _sas_node *sas_expander;
4131 unsigned long flags;
4132 int i, reason_code;
4133 u16 handle;
4134
4135 for (i = 0 ; i < event_data->NumEntries; i++) {
4136 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
4137 if (!handle)
4138 continue;
4139 reason_code = event_data->PHY[i].PhyStatus &
4140 MPI2_EVENT_SAS_TOPO_RC_MASK;
4141 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)
4142 _scsih_tm_tr_send(ioc, handle);
4143 }
4144
4145 expander_handle = le16_to_cpu(event_data->ExpanderDevHandle);
4146 if (expander_handle < ioc->sas_hba.num_phys) {
4147 _scsih_block_io_to_children_attached_directly(ioc, event_data);
4148 return;
4149 }
4150 if (event_data->ExpStatus ==
4151 MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING) {
4152 /* put expander attached devices into blocking state */
4153 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4154 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
4155 expander_handle);
4156 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
4157 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4158 do {
4159 handle = find_first_bit(ioc->blocking_handles,
4160 ioc->facts.MaxDevHandle);
4161 if (handle < ioc->facts.MaxDevHandle)
4162 _scsih_block_io_device(ioc, handle);
4163 } while (test_and_clear_bit(handle, ioc->blocking_handles));
4164 } else if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_RESPONDING)
4165 _scsih_block_io_to_children_attached_directly(ioc, event_data);
4166
4167 if (event_data->ExpStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
4168 return;
4169
4170 /* mark ignore flag for pending events */
4171 spin_lock_irqsave(&ioc->fw_event_lock, flags);
4172 list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
4173 if (fw_event->event != MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
4174 fw_event->ignore)
4175 continue;
35b62362
JL		 4176 local_event_data = (Mpi2EventDataSasTopologyChangeList_t *)
4177 fw_event->event_data;
f92363d1
SR		 4178 if (local_event_data->ExpStatus ==
4179 MPI2_EVENT_SAS_TOPO_ES_ADDED ||
4180 local_event_data->ExpStatus ==
4181 MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
4182 if (le16_to_cpu(local_event_data->ExpanderDevHandle) ==
4183 expander_handle) {
919d8a3f
JP		 4184 dewtprintk(ioc,
4185 ioc_info(ioc, "setting ignoring flag\n"));
f92363d1
SR		 4186 fw_event->ignore = 1;
4187 }
4188 }
4189 }
4190 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
4191}
4192
4318c734
SPS		 4193/**
4194 * _scsih_check_pcie_topo_remove_events - sanity check on topo
4195 * events
4196 * @ioc: per adapter object
4197 * @event_data: the event data payload
4198 *
4199 * This handles the case where driver receives multiple switch
4200 * or device add and delete events in a single shot. When there
4201 * is a delete event the routine will void any pending add
4202 * events waiting in the event queue.
4318c734
SPS		 4203 */
4204static void
4205_scsih_check_pcie_topo_remove_events(struct MPT3SAS_ADAPTER *ioc,
4206 Mpi26EventDataPCIeTopologyChangeList_t *event_data)
4207{
4208 struct fw_event_work *fw_event;
4209 Mpi26EventDataPCIeTopologyChangeList_t *local_event_data;
4210 unsigned long flags;
4211 int i, reason_code;
4212 u16 handle, switch_handle;
4213
4214 for (i = 0; i < event_data->NumEntries; i++) {
4215 handle =
4216 le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle);
4217 if (!handle)
4218 continue;
4219 reason_code = event_data->PortEntry[i].PortStatus;
4220 if (reason_code == MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING)
4221 _scsih_tm_tr_send(ioc, handle);
4222 }
4223
4224 switch_handle = le16_to_cpu(event_data->SwitchDevHandle);
4225 if (!switch_handle) {
4226 _scsih_block_io_to_pcie_children_attached_directly(
4227 ioc, event_data);
4228 return;
4229 }
4230 /* TODO We are not supporting cascaded PCIe Switch removal yet*/
4231 if ((event_data->SwitchStatus
4232 == MPI26_EVENT_PCIE_TOPO_SS_DELAY_NOT_RESPONDING) ||
4233 (event_data->SwitchStatus ==
4234 MPI26_EVENT_PCIE_TOPO_SS_RESPONDING))
4235 _scsih_block_io_to_pcie_children_attached_directly(
4236 ioc, event_data);
4237
4238 if (event_data->SwitchStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
4239 return;
4240
4241 /* mark ignore flag for pending events */
4242 spin_lock_irqsave(&ioc->fw_event_lock, flags);
4243 list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
4244 if (fw_event->event != MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST ||
4245 fw_event->ignore)
4246 continue;
4247 local_event_data =
4248 (Mpi26EventDataPCIeTopologyChangeList_t *)
4249 fw_event->event_data;
4250 if (local_event_data->SwitchStatus ==
4251 MPI2_EVENT_SAS_TOPO_ES_ADDED ||
4252 local_event_data->SwitchStatus ==
4253 MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
4254 if (le16_to_cpu(local_event_data->SwitchDevHandle) ==
4255 switch_handle) {
919d8a3f
JP		 4256 dewtprintk(ioc,
4257 ioc_info(ioc, "setting ignoring flag for switch event\n"));
4318c734
SPS		 4258 fw_event->ignore = 1;
4259 }
4260 }
4261 }
4262 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
4263}
4264
f92363d1
SR		 4265/**
4266 * _scsih_set_volume_delete_flag - setting volume delete flag
4267 * @ioc: per adapter object
4268 * @handle: device handle
4269 *
4270 * This returns nothing.
4271 */
4272static void
4273_scsih_set_volume_delete_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4274{
4275 struct _raid_device *raid_device;
4276 struct MPT3SAS_TARGET *sas_target_priv_data;
4277 unsigned long flags;
4278
4279 spin_lock_irqsave(&ioc->raid_device_lock, flags);
c84b06a4 4280 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
f92363d1
SR		 4281 if (raid_device && raid_device->starget &&
4282 raid_device->starget->hostdata) {
4283 sas_target_priv_data =
4284 raid_device->starget->hostdata;
4285 sas_target_priv_data->deleted = 1;
919d8a3f
JP		 4286 dewtprintk(ioc,
4287 ioc_info(ioc, "setting delete flag: handle(0x%04x), wwid(0x%016llx)\n",
4288 handle, (u64)raid_device->wwid));
f92363d1
SR		 4289 }
4290 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4291}
4292
4293/**
4294 * _scsih_set_volume_handle_for_tr - set handle for target reset to volume
4295 * @handle: input handle
4296 * @a: handle for volume a
4297 * @b: handle for volume b
4298 *
4299 * IR firmware only supports two raid volumes. The purpose of this
4300 * routine is to set the volume handle in either a or b. When the given
4301 * input handle is non-zero, or when a and b have not been set before.
4302 */
4303static void
4304_scsih_set_volume_handle_for_tr(u16 handle, u16 *a, u16 *b)
4305{
4306 if (!handle || handle == *a || handle == *b)
4307 return;
4308 if (!*a)
4309 *a = handle;
4310 else if (!*b)
4311 *b = handle;
4312}
4313
4314/**
4315 * _scsih_check_ir_config_unhide_events - check for UNHIDE events
4316 * @ioc: per adapter object
4317 * @event_data: the event data payload
4318 * Context: interrupt time.
4319 *
4320 * This routine will send target reset to volume, followed by target
4321 * resets to the PDs. This is called when a PD has been removed, or
4322 * volume has been deleted or removed. When the target reset is sent
4323 * to volume, the PD target resets need to be queued to start upon
4324 * completion of the volume target reset.
f92363d1
SR		 4325 */
4326static void
4327_scsih_check_ir_config_unhide_events(struct MPT3SAS_ADAPTER *ioc,
4328 Mpi2EventDataIrConfigChangeList_t *event_data)
4329{
4330 Mpi2EventIrConfigElement_t *element;
4331 int i;
4332 u16 handle, volume_handle, a, b;
4333 struct _tr_list *delayed_tr;
4334
4335 a = 0;
4336 b = 0;
4337
7786ab6a
SR		 4338 if (ioc->is_warpdrive)
4339 return;
4340
f92363d1
SR		 4341 /* Volume Resets for Deleted or Removed */
4342 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
4343 for (i = 0; i < event_data->NumElements; i++, element++) {
4344 if (le32_to_cpu(event_data->Flags) &
4345 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
4346 continue;
4347 if (element->ReasonCode ==
4348 MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED ||
4349 element->ReasonCode ==
4350 MPI2_EVENT_IR_CHANGE_RC_REMOVED) {
4351 volume_handle = le16_to_cpu(element->VolDevHandle);
4352 _scsih_set_volume_delete_flag(ioc, volume_handle);
4353 _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
4354 }
4355 }
4356
4357 /* Volume Resets for UNHIDE events */
4358 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
4359 for (i = 0; i < event_data->NumElements; i++, element++) {
4360 if (le32_to_cpu(event_data->Flags) &
4361 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
4362 continue;
4363 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_UNHIDE) {
4364 volume_handle = le16_to_cpu(element->VolDevHandle);
4365 _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
4366 }
4367 }
4368
4369 if (a)
4370 _scsih_tm_tr_volume_send(ioc, a);
4371 if (b)
4372 _scsih_tm_tr_volume_send(ioc, b);
4373
4374 /* PD target resets */
4375 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
4376 for (i = 0; i < event_data->NumElements; i++, element++) {
4377 if (element->ReasonCode != MPI2_EVENT_IR_CHANGE_RC_UNHIDE)
4378 continue;
4379 handle = le16_to_cpu(element->PhysDiskDevHandle);
4380 volume_handle = le16_to_cpu(element->VolDevHandle);
4381 clear_bit(handle, ioc->pd_handles);
4382 if (!volume_handle)
4383 _scsih_tm_tr_send(ioc, handle);
4384 else if (volume_handle == a || volume_handle == b) {
4385 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
4386 BUG_ON(!delayed_tr);
4387 INIT_LIST_HEAD(&delayed_tr->list);
4388 delayed_tr->handle = handle;
4389 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
919d8a3f
JP		 4390 dewtprintk(ioc,
4391 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
4392 handle));
f92363d1
SR		 4393 } else
4394 _scsih_tm_tr_send(ioc, handle);
4395 }
4396}
4397
4398
4399/**
4400 * _scsih_check_volume_delete_events - set delete flag for volumes
4401 * @ioc: per adapter object
4402 * @event_data: the event data payload
4403 * Context: interrupt time.
4404 *
4405 * This will handle the case when the cable connected to entire volume is
4406 * pulled. We will take care of setting the deleted flag so normal IO will
4407 * not be sent.
f92363d1
SR		 4408 */
4409static void
4410_scsih_check_volume_delete_events(struct MPT3SAS_ADAPTER *ioc,
4411 Mpi2EventDataIrVolume_t *event_data)
4412{
4413 u32 state;
4414
4415 if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
4416 return;
4417 state = le32_to_cpu(event_data->NewValue);
4418 if (state == MPI2_RAID_VOL_STATE_MISSING || state ==
4419 MPI2_RAID_VOL_STATE_FAILED)
4420 _scsih_set_volume_delete_flag(ioc,
4421 le16_to_cpu(event_data->VolDevHandle));
4422}
4423
2d8ce8c9
SR		 4424/**
4425 * _scsih_temp_threshold_events - display temperature threshold exceeded events
4426 * @ioc: per adapter object
4427 * @event_data: the temp threshold event data
4428 * Context: interrupt time.
2d8ce8c9
SR		 4429 */
4430static void
4431_scsih_temp_threshold_events(struct MPT3SAS_ADAPTER *ioc,
4432 Mpi2EventDataTemperature_t *event_data)
4433{
4434 if (ioc->temp_sensors_count >= event_data->SensorNum) {
919d8a3f
JP		 4435 ioc_err(ioc, "Temperature Threshold flags %s%s%s%s exceeded for Sensor: %d !!!\n",
4436 le16_to_cpu(event_data->Status) & 0x1 ? "0 " : " ",
4437 le16_to_cpu(event_data->Status) & 0x2 ? "1 " : " ",
4438 le16_to_cpu(event_data->Status) & 0x4 ? "2 " : " ",
4439 le16_to_cpu(event_data->Status) & 0x8 ? "3 " : " ",
4440 event_data->SensorNum);
4441 ioc_err(ioc, "Current Temp In Celsius: %d\n",
4442 event_data->CurrentTemperature);
2d8ce8c9
SR		 4443 }
4444}
4445
ffb58456 4446static int _scsih_set_satl_pending(struct scsi_cmnd *scmd, bool pending)
7ff723ad 4447{
ffb58456
JB		 4448 struct MPT3SAS_DEVICE *priv = scmd->device->hostdata;
4449
4450 if (scmd->cmnd[0] != ATA_12 && scmd->cmnd[0] != ATA_16)
4451 return 0;
4452
4453 if (pending)
4454 return test_and_set_bit(0, &priv->ata_command_pending);
4455
4456 clear_bit(0, &priv->ata_command_pending);
4457 return 0;
7ff723ad
SP		 4458}
4459
f92363d1
SR		 4460/**
4461 * _scsih_flush_running_cmds - completing outstanding commands.
4462 * @ioc: per adapter object
4463 *
4464 * The flushing out of all pending scmd commands following host reset,
4465 * where all IO is dropped to the floor.
f92363d1
SR		 4466 */
4467static void
4468_scsih_flush_running_cmds(struct MPT3SAS_ADAPTER *ioc)
4469{
4470 struct scsi_cmnd *scmd;
dbec4c90 4471 struct scsiio_tracker *st;
f92363d1 4472 u16 smid;
dbec4c90 4473 int count = 0;
f92363d1
SR		 4474
4475 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
dbec4c90 4476 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
f92363d1
SR		 4477 if (!scmd)
4478 continue;
4479 count++;
ffb58456 4480 _scsih_set_satl_pending(scmd, false);
dbec4c90
SPS		 4481 st = scsi_cmd_priv(scmd);
4482 mpt3sas_base_clear_st(ioc, st);
f92363d1 4483 scsi_dma_unmap(scmd);
c666d3be 4484 if (ioc->pci_error_recovery || ioc->remove_host)
f92363d1
SR		 4485 scmd->result = DID_NO_CONNECT << 16;
4486 else
4487 scmd->result = DID_RESET << 16;
4488 scmd->scsi_done(scmd);
4489 }
919d8a3f 4490 dtmprintk(ioc, ioc_info(ioc, "completing %d cmds\n", count));
f92363d1
SR		 4491}
4492
4493/**
4494 * _scsih_setup_eedp - setup MPI request for EEDP transfer
4495 * @ioc: per adapter object
4496 * @scmd: pointer to scsi command object
6c7abffc 4497 * @mpi_request: pointer to the SCSI_IO request message frame
f92363d1
SR		 4498 *
4499 * Supporting protection 1 and 3.
f92363d1
SR		 4500 */
4501static void
4502_scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
016d5c35 4503 Mpi25SCSIIORequest_t *mpi_request)
f92363d1
SR		 4504{
4505 u16 eedp_flags;
4506 unsigned char prot_op = scsi_get_prot_op(scmd);
4507 unsigned char prot_type = scsi_get_prot_type(scmd);
4508 Mpi25SCSIIORequest_t *mpi_request_3v =
4509 (Mpi25SCSIIORequest_t *)mpi_request;
4510
4511 if (prot_type == SCSI_PROT_DIF_TYPE0 || prot_op == SCSI_PROT_NORMAL)
4512 return;
4513
4514 if (prot_op == SCSI_PROT_READ_STRIP)
4515 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP;
4516 else if (prot_op == SCSI_PROT_WRITE_INSERT)
4517 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP;
4518 else
4519 return;
4520
4521 switch (prot_type) {
4522 case SCSI_PROT_DIF_TYPE1:
4523 case SCSI_PROT_DIF_TYPE2:
4524
4525 /*
4526 * enable ref/guard checking
4527 * auto increment ref tag
4528 */
4529 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
4530 MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
4531 MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
4532 mpi_request->CDB.EEDP32.PrimaryReferenceTag =
ddd0bc75 4533 cpu_to_be32(t10_pi_ref_tag(scmd->request));
f92363d1
SR		 4534 break;
4535
4536 case SCSI_PROT_DIF_TYPE3:
4537
4538 /*
4539 * enable guard checking
4540 */
4541 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
4542
4543 break;
4544 }
4545
4546 mpi_request_3v->EEDPBlockSize =
4547 cpu_to_le16(scmd->device->sector_size);
186a18e5
SPS		 4548
4549 if (ioc->is_gen35_ioc)
4550 eedp_flags |= MPI25_SCSIIO_EEDPFLAGS_APPTAG_DISABLE_MODE;
f92363d1
SR		 4551 mpi_request->EEDPFlags = cpu_to_le16(eedp_flags);
4552}
4553
4554/**
4555 * _scsih_eedp_error_handling - return sense code for EEDP errors
4556 * @scmd: pointer to scsi command object
4557 * @ioc_status: ioc status
f92363d1
SR		 4558 */
4559static void
4560_scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
4561{
4562 u8 ascq;
4563
4564 switch (ioc_status) {
4565 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4566 ascq = 0x01;
4567 break;
4568 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4569 ascq = 0x02;
4570 break;
4571 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4572 ascq = 0x03;
4573 break;
4574 default:
4575 ascq = 0x00;
4576 break;
4577 }
4578 scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 0x10,
4579 ascq);
4580 scmd->result = DRIVER_SENSE << 24 | (DID_ABORT << 16) |
4581 SAM_STAT_CHECK_CONDITION;
4582}
4583
f92363d1 4584/**
8a7e4c24 4585 * scsih_qcmd - main scsi request entry point
4beb4867 4586 * @shost: SCSI host pointer
f92363d1 4587 * @scmd: pointer to scsi command object
f92363d1
SR		 4588 *
4589 * The callback index is set inside `ioc->scsi_io_cb_idx`.
4590 *
4beb4867 4591 * Return: 0 on success. If there's a failure, return either:
f92363d1
SR		 4592 * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or
4593 * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full
4594 */
8bbb1cf6 4595static int
8a7e4c24 4596scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
f92363d1 4597{
d8bfbd8d 4598 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
f92363d1
SR		 4599 struct MPT3SAS_DEVICE *sas_device_priv_data;
4600 struct MPT3SAS_TARGET *sas_target_priv_data;
7786ab6a 4601 struct _raid_device *raid_device;
307d9075
AM		 4602 struct request *rq = scmd->request;
4603 int class;
016d5c35
SPS		 4604 Mpi25SCSIIORequest_t *mpi_request;
4605 struct _pcie_device *pcie_device = NULL;
f92363d1
SR		 4606 u32 mpi_control;
4607 u16 smid;
4608 u16 handle;
4609
f92363d1
SR		 4610 if (ioc->logging_level & MPT_DEBUG_SCSI)
4611 scsi_print_command(scmd);
f92363d1 4612
f92363d1
SR		 4613 sas_device_priv_data = scmd->device->hostdata;
4614 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
4615 scmd->result = DID_NO_CONNECT << 16;
4616 scmd->scsi_done(scmd);
4617 return 0;
4618 }
4619
9029a725 4620 if (!(_scsih_allow_scmd_to_device(ioc, scmd))) {
f92363d1
SR		 4621 scmd->result = DID_NO_CONNECT << 16;
4622 scmd->scsi_done(scmd);
4623 return 0;
4624 }
4625
4626 sas_target_priv_data = sas_device_priv_data->sas_target;
4627
4628 /* invalid device handle */
4629 handle = sas_target_priv_data->handle;
4630 if (handle == MPT3SAS_INVALID_DEVICE_HANDLE) {
4631 scmd->result = DID_NO_CONNECT << 16;
4632 scmd->scsi_done(scmd);
4633 return 0;
4634 }
4635
4636
199fd79a
BVA		 4637 if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress) {
4638 /* host recovery or link resets sent via IOCTLs */
f92363d1 4639 return SCSI_MLQUEUE_HOST_BUSY;
199fd79a
BVA		 4640 } else if (sas_target_priv_data->deleted) {
4641 /* device has been deleted */
f92363d1
SR		 4642 scmd->result = DID_NO_CONNECT << 16;
4643 scmd->scsi_done(scmd);
4644 return 0;
f92363d1 4645 } else if (sas_target_priv_data->tm_busy ||
199fd79a
BVA		 4646 sas_device_priv_data->block) {
4647 /* device busy with task management */
f92363d1 4648 return SCSI_MLQUEUE_DEVICE_BUSY;
199fd79a 4649 }
f92363d1 4650
f49d4aed
C		 4651 /*
4652 * Bug work around for firmware SATL handling. The loop
4653 * is based on atomic operations and ensures consistency
4654 * since we're lockless at this point
4655 */
4656 do {
4657 if (test_bit(0, &sas_device_priv_data->ata_command_pending)) {
4658 scmd->result = SAM_STAT_BUSY;
4659 scmd->scsi_done(scmd);
4660 return 0;
4661 }
4662 } while (_scsih_set_satl_pending(scmd, true));
4663
f92363d1
SR		 4664 if (scmd->sc_data_direction == DMA_FROM_DEVICE)
4665 mpi_control = MPI2_SCSIIO_CONTROL_READ;
4666 else if (scmd->sc_data_direction == DMA_TO_DEVICE)
4667 mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
4668 else
4669 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
4670
4671 /* set tags */
609aa22f 4672 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
307d9075
AM		 4673 /* NCQ Prio supported, make sure control indicated high priority */
4674 if (sas_device_priv_data->ncq_prio_enable) {
4675 class = IOPRIO_PRIO_CLASS(req_get_ioprio(rq));
4676 if (class == IOPRIO_CLASS_RT)
4677 mpi_control |= 1 << MPI2_SCSIIO_CONTROL_CMDPRI_SHIFT;
4678 }
7786ab6a
SR		 4679 /* Make sure Device is not raid volume.
4680 * We do not expose raid functionality to upper layer for warpdrive.
4681 */
cd5897ed
SPS		 4682 if (((!ioc->is_warpdrive && !scsih_is_raid(&scmd->device->sdev_gendev))
4683 && !scsih_is_nvme(&scmd->device->sdev_gendev))
4684 && sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32)
f92363d1
SR		 4685 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
4686
4687 smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
4688 if (!smid) {
919d8a3f 4689 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
f49d4aed 4690 _scsih_set_satl_pending(scmd, false);
f92363d1
SR		 4691 goto out;
4692 }
4693 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
016d5c35 4694 memset(mpi_request, 0, ioc->request_sz);
f92363d1
SR		 4695 _scsih_setup_eedp(ioc, scmd, mpi_request);
4696
4697 if (scmd->cmd_len == 32)
4698 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT;
4699 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
4700 if (sas_device_priv_data->sas_target->flags &
4701 MPT_TARGET_FLAGS_RAID_COMPONENT)
4702 mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
4703 else
4704 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
4705 mpi_request->DevHandle = cpu_to_le16(handle);
4706 mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
4707 mpi_request->Control = cpu_to_le32(mpi_control);
4708 mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len);
4709 mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR;
4710 mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
4711 mpi_request->SenseBufferLowAddress =
4712 mpt3sas_base_get_sense_buffer_dma(ioc, smid);
016d5c35 4713 mpi_request->SGLOffset0 = offsetof(Mpi25SCSIIORequest_t, SGL) / 4;
f92363d1
SR		 4714 int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *)
4715 mpi_request->LUN);
4716 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
4717
4718 if (mpi_request->DataLength) {
016d5c35
SPS		 4719 pcie_device = sas_target_priv_data->pcie_dev;
4720 if (ioc->build_sg_scmd(ioc, scmd, smid, pcie_device)) {
f92363d1 4721 mpt3sas_base_free_smid(ioc, smid);
f49d4aed 4722 _scsih_set_satl_pending(scmd, false);
f92363d1
SR		 4723 goto out;
4724 }
4725 } else
4726 ioc->build_zero_len_sge(ioc, &mpi_request->SGL);
4727
7786ab6a
SR		 4728 raid_device = sas_target_priv_data->raid_device;
4729 if (raid_device && raid_device->direct_io_enabled)
cd5897ed 4730 mpt3sas_setup_direct_io(ioc, scmd,
dbec4c90 4731 raid_device, mpi_request);
7786ab6a 4732
f92363d1
SR		 4733 if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)) {
4734 if (sas_target_priv_data->flags & MPT_TARGET_FASTPATH_IO) {
4735 mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len |
4736 MPI25_SCSIIO_IOFLAGS_FAST_PATH);
40114bde 4737 mpt3sas_base_put_smid_fast_path(ioc, smid, handle);
f92363d1 4738 } else
81c16f83 4739 ioc->put_smid_scsi_io(ioc, smid,
7786ab6a 4740 le16_to_cpu(mpi_request->DevHandle));
f92363d1 4741 } else
40114bde 4742 mpt3sas_base_put_smid_default(ioc, smid);
f92363d1
SR		 4743 return 0;
4744
4745 out:
4746 return SCSI_MLQUEUE_HOST_BUSY;
4747}
f92363d1
SR		 4748
4749/**
4750 * _scsih_normalize_sense - normalize descriptor and fixed format sense data
4751 * @sense_buffer: sense data returned by target
4752 * @data: normalized skey/asc/ascq
f92363d1
SR		 4753 */
4754static void
4755_scsih_normalize_sense(char *sense_buffer, struct sense_info *data)
4756{
4757 if ((sense_buffer[0] & 0x7F) >= 0x72) {
4758 /* descriptor format */
4759 data->skey = sense_buffer[1] & 0x0F;
4760 data->asc = sense_buffer[2];
4761 data->ascq = sense_buffer[3];
4762 } else {
4763 /* fixed format */
4764 data->skey = sense_buffer[2] & 0x0F;
4765 data->asc = sense_buffer[12];
4766 data->ascq = sense_buffer[13];
4767 }
4768}
4769
f92363d1
SR		 4770/**
4771 * _scsih_scsi_ioc_info - translated non-succesfull SCSI_IO request
4772 * @ioc: per adapter object
4773 * @scmd: pointer to scsi command object
4774 * @mpi_reply: reply mf payload returned from firmware
4beb4867 4775 * @smid: ?
f92363d1
SR		 4776 *
4777 * scsi_status - SCSI Status code returned from target device
4778 * scsi_state - state info associated with SCSI_IO determined by ioc
4779 * ioc_status - ioc supplied status info
f92363d1
SR		 4780 */
4781static void
4782_scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
4783 Mpi2SCSIIOReply_t *mpi_reply, u16 smid)
4784{
4785 u32 response_info;
4786 u8 *response_bytes;
4787 u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) &
4788 MPI2_IOCSTATUS_MASK;
4789 u8 scsi_state = mpi_reply->SCSIState;
4790 u8 scsi_status = mpi_reply->SCSIStatus;
4791 char *desc_ioc_state = NULL;
4792 char *desc_scsi_status = NULL;
4793 char *desc_scsi_state = ioc->tmp_string;
4794 u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
4795 struct _sas_device *sas_device = NULL;
ec051e5a 4796 struct _pcie_device *pcie_device = NULL;
f92363d1
SR		 4797 struct scsi_target *starget = scmd->device->sdev_target;
4798 struct MPT3SAS_TARGET *priv_target = starget->hostdata;
4799 char *device_str = NULL;
4800
4801 if (!priv_target)
4802 return;
7786ab6a
SR		 4803 if (ioc->hide_ir_msg)
4804 device_str = "WarpDrive";
4805 else
4806 device_str = "volume";
f92363d1
SR		 4807
4808 if (log_info == 0x31170000)
4809 return;
4810
4811 switch (ioc_status) {
4812 case MPI2_IOCSTATUS_SUCCESS:
4813 desc_ioc_state = "success";
4814 break;
4815 case MPI2_IOCSTATUS_INVALID_FUNCTION:
4816 desc_ioc_state = "invalid function";
4817 break;
4818 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4819 desc_ioc_state = "scsi recovered error";
4820 break;
4821 case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE:
4822 desc_ioc_state = "scsi invalid dev handle";
4823 break;
4824 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4825 desc_ioc_state = "scsi device not there";
4826 break;
4827 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4828 desc_ioc_state = "scsi data overrun";
4829 break;
4830 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4831 desc_ioc_state = "scsi data underrun";
4832 break;
4833 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4834 desc_ioc_state = "scsi io data error";
4835 break;
4836 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4837 desc_ioc_state = "scsi protocol error";
4838 break;
4839 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4840 desc_ioc_state = "scsi task terminated";
4841 break;
4842 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4843 desc_ioc_state = "scsi residual mismatch";
4844 break;
4845 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4846 desc_ioc_state = "scsi task mgmt failed";
4847 break;
4848 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4849 desc_ioc_state = "scsi ioc terminated";
4850 break;
4851 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4852 desc_ioc_state = "scsi ext terminated";
4853 break;
4854 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4855 desc_ioc_state = "eedp guard error";
4856 break;
4857 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4858 desc_ioc_state = "eedp ref tag error";
4859 break;
4860 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4861 desc_ioc_state = "eedp app tag error";
4862 break;
b130b0d5
SS		 4863 case MPI2_IOCSTATUS_INSUFFICIENT_POWER:
4864 desc_ioc_state = "insufficient power";
4865 break;
f92363d1
SR		 4866 default:
4867 desc_ioc_state = "unknown";
4868 break;
4869 }
4870
4871 switch (scsi_status) {
4872 case MPI2_SCSI_STATUS_GOOD:
4873 desc_scsi_status = "good";
4874 break;
4875 case MPI2_SCSI_STATUS_CHECK_CONDITION:
4876 desc_scsi_status = "check condition";
4877 break;
4878 case MPI2_SCSI_STATUS_CONDITION_MET:
4879 desc_scsi_status = "condition met";
4880 break;
4881 case MPI2_SCSI_STATUS_BUSY:
4882 desc_scsi_status = "busy";
4883 break;
4884 case MPI2_SCSI_STATUS_INTERMEDIATE:
4885 desc_scsi_status = "intermediate";
4886 break;
4887 case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET:
4888 desc_scsi_status = "intermediate condmet";
4889 break;
4890 case MPI2_SCSI_STATUS_RESERVATION_CONFLICT:
4891 desc_scsi_status = "reservation conflict";
4892 break;
4893 case MPI2_SCSI_STATUS_COMMAND_TERMINATED:
4894 desc_scsi_status = "command terminated";
4895 break;
4896 case MPI2_SCSI_STATUS_TASK_SET_FULL:
4897 desc_scsi_status = "task set full";
4898 break;
4899 case MPI2_SCSI_STATUS_ACA_ACTIVE:
4900 desc_scsi_status = "aca active";
4901 break;
4902 case MPI2_SCSI_STATUS_TASK_ABORTED:
4903 desc_scsi_status = "task aborted";
4904 break;
4905 default:
4906 desc_scsi_status = "unknown";
4907 break;
4908 }
4909
4910 desc_scsi_state[0] = '\0';
4911 if (!scsi_state)
4912 desc_scsi_state = " ";
4913 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4914 strcat(desc_scsi_state, "response info ");
4915 if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4916 strcat(desc_scsi_state, "state terminated ");
4917 if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS)
4918 strcat(desc_scsi_state, "no status ");
4919 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED)
4920 strcat(desc_scsi_state, "autosense failed ");
4921 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)
4922 strcat(desc_scsi_state, "autosense valid ");
4923
4924 scsi_print_command(scmd);
4925
4926 if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
919d8a3f
JP		 4927 ioc_warn(ioc, "\t%s wwid(0x%016llx)\n",
4928 device_str, (u64)priv_target->sas_address);
ec051e5a
SPS		 4929 } else if (priv_target->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) {
4930 pcie_device = mpt3sas_get_pdev_from_target(ioc, priv_target);
4931 if (pcie_device) {
919d8a3f
JP		 4932 ioc_info(ioc, "\twwid(0x%016llx), port(%d)\n",
4933 (u64)pcie_device->wwid, pcie_device->port_num);
ec051e5a 4934 if (pcie_device->enclosure_handle != 0)
919d8a3f
JP		 4935 ioc_info(ioc, "\tenclosure logical id(0x%016llx), slot(%d)\n",
4936 (u64)pcie_device->enclosure_logical_id,
4937 pcie_device->slot);
ec051e5a 4938 if (pcie_device->connector_name[0])
919d8a3f
JP		 4939 ioc_info(ioc, "\tenclosure level(0x%04x), connector name( %s)\n",
4940 pcie_device->enclosure_level,
4941 pcie_device->connector_name);
ec051e5a
SPS		 4942 pcie_device_put(pcie_device);
4943 }
f92363d1 4944 } else {
d1cb5e49 4945 sas_device = mpt3sas_get_sdev_from_target(ioc, priv_target);
f92363d1 4946 if (sas_device) {
919d8a3f
JP		 4947 ioc_warn(ioc, "\tsas_address(0x%016llx), phy(%d)\n",
4948 (u64)sas_device->sas_address, sas_device->phy);
75888956
SR		 4949
4950 _scsih_display_enclosure_chassis_info(ioc, sas_device,
4951 NULL, NULL);
d1cb5e49
SR		 4952
4953 sas_device_put(sas_device);
f92363d1 4954 }
f92363d1
SR		 4955 }
4956
919d8a3f
JP		 4957 ioc_warn(ioc, "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n",
4958 le16_to_cpu(mpi_reply->DevHandle),
4959 desc_ioc_state, ioc_status, smid);
4960 ioc_warn(ioc, "\trequest_len(%d), underflow(%d), resid(%d)\n",
4961 scsi_bufflen(scmd), scmd->underflow, scsi_get_resid(scmd));
4962 ioc_warn(ioc, "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n",
4963 le16_to_cpu(mpi_reply->TaskTag),
4964 le32_to_cpu(mpi_reply->TransferCount), scmd->result);
4965 ioc_warn(ioc, "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n",
4966 desc_scsi_status, scsi_status, desc_scsi_state, scsi_state);
f92363d1
SR		 4967
4968 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
4969 struct sense_info data;
4970 _scsih_normalize_sense(scmd->sense_buffer, &data);
919d8a3f
JP		 4971 ioc_warn(ioc, "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n",
4972 data.skey, data.asc, data.ascq,
4973 le32_to_cpu(mpi_reply->SenseCount));
f92363d1 4974 }
f92363d1
SR		 4975 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
4976 response_info = le32_to_cpu(mpi_reply->ResponseInfo);
4977 response_bytes = (u8 *)&response_info;
4978 _scsih_response_code(ioc, response_bytes[0]);
4979 }
4980}
f92363d1
SR		 4981
4982/**
0f624c39 4983 * _scsih_turn_on_pfa_led - illuminate PFA LED
f92363d1
SR		 4984 * @ioc: per adapter object
4985 * @handle: device handle
4986 * Context: process
f92363d1
SR		 4987 */
4988static void
0f624c39 4989_scsih_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
f92363d1
SR		 4990{
4991 Mpi2SepReply_t mpi_reply;
4992 Mpi2SepRequest_t mpi_request;
0f624c39
SR		 4993 struct _sas_device *sas_device;
4994
d1cb5e49 4995 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
0f624c39
SR		 4996 if (!sas_device)
4997 return;
f92363d1
SR		 4998
4999 memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
5000 mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
5001 mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
5002 mpi_request.SlotStatus =
5003 cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
5004 mpi_request.DevHandle = cpu_to_le16(handle);
5005 mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
5006 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
5007 &mpi_request)) != 0) {
919d8a3f
JP		 5008 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5009 __FILE__, __LINE__, __func__);
d1cb5e49 5010 goto out;
f92363d1 5011 }
0f624c39 5012 sas_device->pfa_led_on = 1;
f92363d1
SR		 5013
5014 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
919d8a3f
JP		 5015 dewtprintk(ioc,
5016 ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
5017 le16_to_cpu(mpi_reply.IOCStatus),
5018 le32_to_cpu(mpi_reply.IOCLogInfo)));
d1cb5e49 5019 goto out;
f92363d1 5020 }
d1cb5e49
SR		 5021out:
5022 sas_device_put(sas_device);
f92363d1 5023}
d1cb5e49 5024
0f624c39
SR		 5025/**
5026 * _scsih_turn_off_pfa_led - turn off Fault LED
5027 * @ioc: per adapter object
5028 * @sas_device: sas device whose PFA LED has to turned off
5029 * Context: process
0f624c39
SR		 5030 */
5031static void
5032_scsih_turn_off_pfa_led(struct MPT3SAS_ADAPTER *ioc,
5033 struct _sas_device *sas_device)
5034{
5035 Mpi2SepReply_t mpi_reply;
5036 Mpi2SepRequest_t mpi_request;
f92363d1 5037
0f624c39
SR		 5038 memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
5039 mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
5040 mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
5041 mpi_request.SlotStatus = 0;
5042 mpi_request.Slot = cpu_to_le16(sas_device->slot);
5043 mpi_request.DevHandle = 0;
5044 mpi_request.EnclosureHandle = cpu_to_le16(sas_device->enclosure_handle);
5045 mpi_request.Flags = MPI2_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS;
5046 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
5047 &mpi_request)) != 0) {
1f95a47e
JP		 5048 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5049 __FILE__, __LINE__, __func__);
0f624c39
SR		 5050 return;
5051 }
5052
5053 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
1f95a47e
JP		 5054 dewtprintk(ioc,
5055 ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
5056 le16_to_cpu(mpi_reply.IOCStatus),
5057 le32_to_cpu(mpi_reply.IOCLogInfo)));
0f624c39
SR		 5058 return;
5059 }
5060}
d1cb5e49 5061
f92363d1 5062/**
0f624c39 5063 * _scsih_send_event_to_turn_on_pfa_led - fire delayed event
f92363d1
SR		 5064 * @ioc: per adapter object
5065 * @handle: device handle
5066 * Context: interrupt.
f92363d1
SR		 5067 */
5068static void
0f624c39 5069_scsih_send_event_to_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
f92363d1
SR		 5070{
5071 struct fw_event_work *fw_event;
5072
146b16c8 5073 fw_event = alloc_fw_event_work(0);
f92363d1
SR		 5074 if (!fw_event)
5075 return;
0f624c39 5076 fw_event->event = MPT3SAS_TURN_ON_PFA_LED;
f92363d1
SR		 5077 fw_event->device_handle = handle;
5078 fw_event->ioc = ioc;
5079 _scsih_fw_event_add(ioc, fw_event);
146b16c8 5080 fw_event_work_put(fw_event);
f92363d1
SR		 5081}
5082
5083/**
5084 * _scsih_smart_predicted_fault - process smart errors
5085 * @ioc: per adapter object
5086 * @handle: device handle
5087 * Context: interrupt.
f92363d1
SR		 5088 */
5089static void
5090_scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5091{
5092 struct scsi_target *starget;
5093 struct MPT3SAS_TARGET *sas_target_priv_data;
5094 Mpi2EventNotificationReply_t *event_reply;
5095 Mpi2EventDataSasDeviceStatusChange_t *event_data;
5096 struct _sas_device *sas_device;
5097 ssize_t sz;
5098 unsigned long flags;
5099
5100 /* only handle non-raid devices */
5101 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49
SR		 5102 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
5103 if (!sas_device)
5104 goto out_unlock;
5105
f92363d1
SR		 5106 starget = sas_device->starget;
5107 sas_target_priv_data = starget->hostdata;
5108
5109 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) ||
d1cb5e49
SR		 5110 ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)))
5111 goto out_unlock;
5112
75888956
SR		 5113 _scsih_display_enclosure_chassis_info(NULL, sas_device, NULL, starget);
5114
f92363d1
SR		 5115 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5116
5117 if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
0f624c39 5118 _scsih_send_event_to_turn_on_pfa_led(ioc, handle);
f92363d1
SR		 5119
5120 /* insert into event log */
5121 sz = offsetof(Mpi2EventNotificationReply_t, EventData) +
5122 sizeof(Mpi2EventDataSasDeviceStatusChange_t);
5123 event_reply = kzalloc(sz, GFP_KERNEL);
5124 if (!event_reply) {
919d8a3f
JP		 5125 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5126 __FILE__, __LINE__, __func__);
d1cb5e49 5127 goto out;
f92363d1
SR		 5128 }
5129
5130 event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION;
5131 event_reply->Event =
5132 cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE);
5133 event_reply->MsgLength = sz/4;
5134 event_reply->EventDataLength =
5135 cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4);
5136 event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
5137 event_reply->EventData;
5138 event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
5139 event_data->ASC = 0x5D;
5140 event_data->DevHandle = cpu_to_le16(handle);
5141 event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
5142 mpt3sas_ctl_add_to_event_log(ioc, event_reply);
5143 kfree(event_reply);
d1cb5e49
SR		 5144out:
5145 if (sas_device)
5146 sas_device_put(sas_device);
5147 return;
5148
5149out_unlock:
5150 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5151 goto out;
f92363d1
SR		 5152}
5153
5154/**
5155 * _scsih_io_done - scsi request callback
5156 * @ioc: per adapter object
5157 * @smid: system request message index
5158 * @msix_index: MSIX table index supplied by the OS
5159 * @reply: reply message frame(lower 32bit addr)
5160 *
5161 * Callback handler when using _scsih_qcmd.
5162 *
4beb4867
BVA		 5163 * Return: 1 meaning mf should be freed from _base_interrupt
5164 * 0 means the mf is freed from this function.
f92363d1
SR		 5165 */
5166static u8
5167_scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
5168{
016d5c35 5169 Mpi25SCSIIORequest_t *mpi_request;
f92363d1
SR		 5170 Mpi2SCSIIOReply_t *mpi_reply;
5171 struct scsi_cmnd *scmd;
dbec4c90 5172 struct scsiio_tracker *st;
f92363d1
SR		 5173 u16 ioc_status;
5174 u32 xfer_cnt;
5175 u8 scsi_state;
5176 u8 scsi_status;
5177 u32 log_info;
5178 struct MPT3SAS_DEVICE *sas_device_priv_data;
5179 u32 response_code = 0;
5180
5181 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
459325c4 5182
dbec4c90 5183 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
f92363d1
SR		 5184 if (scmd == NULL)
5185 return 1;
5186
ffb58456 5187 _scsih_set_satl_pending(scmd, false);
18f6084a 5188
f92363d1
SR		 5189 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
5190
5191 if (mpi_reply == NULL) {
5192 scmd->result = DID_OK << 16;
5193 goto out;
5194 }
5195
5196 sas_device_priv_data = scmd->device->hostdata;
5197 if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
5198 sas_device_priv_data->sas_target->deleted) {
5199 scmd->result = DID_NO_CONNECT << 16;
5200 goto out;
5201 }
5202 ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
5203
7786ab6a
SR		 5204 /*
5205 * WARPDRIVE: If direct_io is set then it is directIO,
5206 * the failed direct I/O should be redirected to volume
5207 */
dbec4c90
SPS		 5208 st = scsi_cmd_priv(scmd);
5209 if (st->direct_io &&
7786ab6a
SR		 5210 ((ioc_status & MPI2_IOCSTATUS_MASK)
5211 != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) {
dbec4c90 5212 st->direct_io = 0;
7786ab6a
SR		 5213 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
5214 mpi_request->DevHandle =
5215 cpu_to_le16(sas_device_priv_data->sas_target->handle);
81c16f83 5216 ioc->put_smid_scsi_io(ioc, smid,
7786ab6a
SR		 5217 sas_device_priv_data->sas_target->handle);
5218 return 0;
5219 }
f92363d1
SR		 5220 /* turning off TLR */
5221 scsi_state = mpi_reply->SCSIState;
5222 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
5223 response_code =
5224 le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
5225 if (!sas_device_priv_data->tlr_snoop_check) {
5226 sas_device_priv_data->tlr_snoop_check++;
cd5897ed 5227 if ((!ioc->is_warpdrive &&
7786ab6a 5228 !scsih_is_raid(&scmd->device->sdev_gendev) &&
cd5897ed
SPS		 5229 !scsih_is_nvme(&scmd->device->sdev_gendev))
5230 && sas_is_tlr_enabled(scmd->device) &&
c84b06a4
SR		 5231 response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) {
5232 sas_disable_tlr(scmd->device);
5233 sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n");
5234 }
f92363d1
SR		 5235 }
5236
5237 xfer_cnt = le32_to_cpu(mpi_reply->TransferCount);
5238 scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt);
5239 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
5240 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
5241 else
5242 log_info = 0;
5243 ioc_status &= MPI2_IOCSTATUS_MASK;
5244 scsi_status = mpi_reply->SCSIStatus;
5245
5246 if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
5247 (scsi_status == MPI2_SCSI_STATUS_BUSY ||
5248 scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT ||
5249 scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) {
5250 ioc_status = MPI2_IOCSTATUS_SUCCESS;
5251 }
5252
5253 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
5254 struct sense_info data;
5255 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc,
5256 smid);
5257 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
5258 le32_to_cpu(mpi_reply->SenseCount));
5259 memcpy(scmd->sense_buffer, sense_data, sz);
5260 _scsih_normalize_sense(scmd->sense_buffer, &data);
5261 /* failure prediction threshold exceeded */
5262 if (data.asc == 0x5D)
5263 _scsih_smart_predicted_fault(ioc,
5264 le16_to_cpu(mpi_reply->DevHandle));
5265 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
f92363d1 5266
0d667f72 5267 if ((ioc->logging_level & MPT_DEBUG_REPLY) &&
e6d45e3e
SR		 5268 ((scmd->sense_buffer[2] == UNIT_ATTENTION) ||
5269 (scmd->sense_buffer[2] == MEDIUM_ERROR) ||
5270 (scmd->sense_buffer[2] == HARDWARE_ERROR)))
5271 _scsih_scsi_ioc_info(ioc, scmd, mpi_reply, smid);
e6d45e3e 5272 }
f92363d1
SR		 5273 switch (ioc_status) {
5274 case MPI2_IOCSTATUS_BUSY:
5275 case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES:
5276 scmd->result = SAM_STAT_BUSY;
5277 break;
5278
5279 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
5280 scmd->result = DID_NO_CONNECT << 16;
5281 break;
5282
5283 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
5284 if (sas_device_priv_data->block) {
5285 scmd->result = DID_TRANSPORT_DISRUPTED << 16;
5286 goto out;
5287 }
5288 if (log_info == 0x31110630) {
5289 if (scmd->retries > 2) {
5290 scmd->result = DID_NO_CONNECT << 16;
5291 scsi_device_set_state(scmd->device,
5292 SDEV_OFFLINE);
5293 } else {
5294 scmd->result = DID_SOFT_ERROR << 16;
5295 scmd->device->expecting_cc_ua = 1;
5296 }
5297 break;
3898f08e
SR		 5298 } else if (log_info == VIRTUAL_IO_FAILED_RETRY) {
5299 scmd->result = DID_RESET << 16;
5300 break;
2ce9a364
SR		 5301 } else if ((scmd->device->channel == RAID_CHANNEL) &&
5302 (scsi_state == (MPI2_SCSI_STATE_TERMINATED |
5303 MPI2_SCSI_STATE_NO_SCSI_STATUS))) {
5304 scmd->result = DID_RESET << 16;
5305 break;
f92363d1
SR		 5306 }
5307 scmd->result = DID_SOFT_ERROR << 16;
5308 break;
5309 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
5310 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
5311 scmd->result = DID_RESET << 16;
5312 break;
5313
5314 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
5315 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt))
5316 scmd->result = DID_SOFT_ERROR << 16;
5317 else
5318 scmd->result = (DID_OK << 16) | scsi_status;
5319 break;
5320
5321 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
5322 scmd->result = (DID_OK << 16) | scsi_status;
5323
5324 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID))
5325 break;
5326
5327 if (xfer_cnt < scmd->underflow) {
5328 if (scsi_status == SAM_STAT_BUSY)
5329 scmd->result = SAM_STAT_BUSY;
5330 else
5331 scmd->result = DID_SOFT_ERROR << 16;
5332 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
5333 MPI2_SCSI_STATE_NO_SCSI_STATUS))
5334 scmd->result = DID_SOFT_ERROR << 16;
5335 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
5336 scmd->result = DID_RESET << 16;
5337 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
5338 mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
5339 mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
5340 scmd->result = (DRIVER_SENSE << 24) |
5341 SAM_STAT_CHECK_CONDITION;
5342 scmd->sense_buffer[0] = 0x70;
5343 scmd->sense_buffer[2] = ILLEGAL_REQUEST;
5344 scmd->sense_buffer[12] = 0x20;
5345 scmd->sense_buffer[13] = 0;
5346 }
5347 break;
5348
5349 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
5350 scsi_set_resid(scmd, 0);
eb0c7af2 5351 /* fall through */
f92363d1
SR		 5352 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
5353 case MPI2_IOCSTATUS_SUCCESS:
5354 scmd->result = (DID_OK << 16) | scsi_status;
5355 if (response_code ==
5356 MPI2_SCSITASKMGMT_RSP_INVALID_FRAME ||
5357 (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
5358 MPI2_SCSI_STATE_NO_SCSI_STATUS)))
5359 scmd->result = DID_SOFT_ERROR << 16;
5360 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
5361 scmd->result = DID_RESET << 16;
5362 break;
5363
5364 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
5365 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
5366 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
5367 _scsih_eedp_error_handling(scmd, ioc_status);
5368 break;
5369
5370 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
5371 case MPI2_IOCSTATUS_INVALID_FUNCTION:
5372 case MPI2_IOCSTATUS_INVALID_SGL:
5373 case MPI2_IOCSTATUS_INTERNAL_ERROR:
5374 case MPI2_IOCSTATUS_INVALID_FIELD:
5375 case MPI2_IOCSTATUS_INVALID_STATE:
5376 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
5377 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
b130b0d5 5378 case MPI2_IOCSTATUS_INSUFFICIENT_POWER:
f92363d1
SR		 5379 default:
5380 scmd->result = DID_SOFT_ERROR << 16;
5381 break;
5382
5383 }
5384
f92363d1
SR		 5385 if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
5386 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
f92363d1
SR		 5387
5388 out:
5389
5390 scsi_dma_unmap(scmd);
dbec4c90 5391 mpt3sas_base_free_smid(ioc, smid);
f92363d1 5392 scmd->scsi_done(scmd);
dbec4c90 5393 return 0;
f92363d1
SR		 5394}
5395
5396/**
5397 * _scsih_sas_host_refresh - refreshing sas host object contents
5398 * @ioc: per adapter object
5399 * Context: user
5400 *
5401 * During port enable, fw will send topology events for every device. Its
5402 * possible that the handles may change from the previous setting, so this
5403 * code keeping handles updating if changed.
f92363d1
SR		 5404 */
5405static void
5406_scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc)
5407{
5408 u16 sz;
5409 u16 ioc_status;
5410 int i;
5411 Mpi2ConfigReply_t mpi_reply;
5412 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
5413 u16 attached_handle;
5414 u8 link_rate;
5415
919d8a3f
JP		 5416 dtmprintk(ioc,
5417 ioc_info(ioc, "updating handles for sas_host(0x%016llx)\n",
5418 (u64)ioc->sas_hba.sas_address));
f92363d1
SR		 5419
5420 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
5421 * sizeof(Mpi2SasIOUnit0PhyData_t));
5422 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
5423 if (!sas_iounit_pg0) {
919d8a3f
JP		 5424 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5425 __FILE__, __LINE__, __func__);
f92363d1
SR		 5426 return;
5427 }
5428
5429 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
5430 sas_iounit_pg0, sz)) != 0)
5431 goto out;
5432 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
5433 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
5434 goto out;
5435 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
5436 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4;
5437 if (i == 0)
5438 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
5439 PhyData[0].ControllerDevHandle);
5440 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
5441 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i].
5442 AttachedDevHandle);
5443 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
5444 link_rate = MPI2_SAS_NEG_LINK_RATE_1_5;
5445 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
5446 attached_handle, i, link_rate);
5447 }
5448 out:
5449 kfree(sas_iounit_pg0);
5450}
5451
5452/**
5453 * _scsih_sas_host_add - create sas host object
5454 * @ioc: per adapter object
5455 *
5456 * Creating host side data object, stored in ioc->sas_hba
f92363d1
SR		 5457 */
5458static void
5459_scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc)
5460{
5461 int i;
5462 Mpi2ConfigReply_t mpi_reply;
5463 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
5464 Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
5465 Mpi2SasPhyPage0_t phy_pg0;
5466 Mpi2SasDevicePage0_t sas_device_pg0;
5467 Mpi2SasEnclosurePage0_t enclosure_pg0;
5468 u16 ioc_status;
5469 u16 sz;
5470 u8 device_missing_delay;
87aa95d4 5471 u8 num_phys;
f92363d1 5472
87aa95d4
JL		 5473 mpt3sas_config_get_number_hba_phys(ioc, &num_phys);
5474 if (!num_phys) {
919d8a3f
JP		 5475 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5476 __FILE__, __LINE__, __func__);
f92363d1
SR		 5477 return;
5478 }
87aa95d4
JL		 5479 ioc->sas_hba.phy = kcalloc(num_phys,
5480 sizeof(struct _sas_phy), GFP_KERNEL);
5481 if (!ioc->sas_hba.phy) {
919d8a3f
JP		 5482 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5483 __FILE__, __LINE__, __func__);
87aa95d4
JL		 5484 goto out;
5485 }
5486 ioc->sas_hba.num_phys = num_phys;
f92363d1
SR		 5487
5488 /* sas_iounit page 0 */
5489 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
5490 sizeof(Mpi2SasIOUnit0PhyData_t));
5491 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
5492 if (!sas_iounit_pg0) {
919d8a3f
JP		 5493 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5494 __FILE__, __LINE__, __func__);
f92363d1
SR		 5495 return;
5496 }
5497 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
5498 sas_iounit_pg0, sz))) {
919d8a3f
JP		 5499 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5500 __FILE__, __LINE__, __func__);
f92363d1
SR		 5501 goto out;
5502 }
5503 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5504 MPI2_IOCSTATUS_MASK;
5505 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 5506 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5507 __FILE__, __LINE__, __func__);
f92363d1
SR		 5508 goto out;
5509 }
5510
5511 /* sas_iounit page 1 */
5512 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
5513 sizeof(Mpi2SasIOUnit1PhyData_t));
5514 sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
5515 if (!sas_iounit_pg1) {
919d8a3f
JP		 5516 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5517 __FILE__, __LINE__, __func__);
f92363d1
SR		 5518 goto out;
5519 }
5520 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
5521 sas_iounit_pg1, sz))) {
919d8a3f
JP		 5522 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5523 __FILE__, __LINE__, __func__);
f92363d1
SR		 5524 goto out;
5525 }
5526 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5527 MPI2_IOCSTATUS_MASK;
5528 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 5529 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5530 __FILE__, __LINE__, __func__);
f92363d1
SR		 5531 goto out;
5532 }
5533
5534 ioc->io_missing_delay =
5535 sas_iounit_pg1->IODeviceMissingDelay;
5536 device_missing_delay =
5537 sas_iounit_pg1->ReportDeviceMissingDelay;
5538 if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16)
5539 ioc->device_missing_delay = (device_missing_delay &
5540 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16;
5541 else
5542 ioc->device_missing_delay = device_missing_delay &
5543 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
5544
5545 ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
f92363d1
SR		 5546 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
5547 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
5548 i))) {
919d8a3f
JP		 5549 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5550 __FILE__, __LINE__, __func__);
f92363d1
SR		 5551 goto out;
5552 }
5553 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5554 MPI2_IOCSTATUS_MASK;
5555 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 5556 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5557 __FILE__, __LINE__, __func__);
f92363d1
SR		 5558 goto out;
5559 }
5560
5561 if (i == 0)
5562 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
5563 PhyData[0].ControllerDevHandle);
5564 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
5565 ioc->sas_hba.phy[i].phy_id = i;
5566 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
5567 phy_pg0, ioc->sas_hba.parent_dev);
5568 }
5569 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5570 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
919d8a3f
JP		 5571 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5572 __FILE__, __LINE__, __func__);
f92363d1
SR		 5573 goto out;
5574 }
5575 ioc->sas_hba.enclosure_handle =
5576 le16_to_cpu(sas_device_pg0.EnclosureHandle);
5577 ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
919d8a3f
JP		 5578 ioc_info(ioc, "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
5579 ioc->sas_hba.handle,
5580 (u64)ioc->sas_hba.sas_address,
5581 ioc->sas_hba.num_phys);
f92363d1
SR		 5582
5583 if (ioc->sas_hba.enclosure_handle) {
5584 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
5585 &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
5586 ioc->sas_hba.enclosure_handle)))
5587 ioc->sas_hba.enclosure_logical_id =
5588 le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
5589 }
5590
5591 out:
5592 kfree(sas_iounit_pg1);
5593 kfree(sas_iounit_pg0);
5594}
5595
5596/**
5597 * _scsih_expander_add - creating expander object
5598 * @ioc: per adapter object
5599 * @handle: expander handle
5600 *
5601 * Creating expander object, stored in ioc->sas_expander_list.
5602 *
4beb4867 5603 * Return: 0 for success, else error.
f92363d1
SR		 5604 */
5605static int
5606_scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5607{
5608 struct _sas_node *sas_expander;
22a923c3 5609 struct _enclosure_node *enclosure_dev;
f92363d1
SR		 5610 Mpi2ConfigReply_t mpi_reply;
5611 Mpi2ExpanderPage0_t expander_pg0;
5612 Mpi2ExpanderPage1_t expander_pg1;
f92363d1
SR		 5613 u32 ioc_status;
5614 u16 parent_handle;
5615 u64 sas_address, sas_address_parent = 0;
5616 int i;
5617 unsigned long flags;
5618 struct _sas_port *mpt3sas_port = NULL;
5619
5620 int rc = 0;
5621
5622 if (!handle)
5623 return -1;
5624
5625 if (ioc->shost_recovery || ioc->pci_error_recovery)
5626 return -1;
5627
5628 if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
5629 MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) {
919d8a3f
JP		 5630 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5631 __FILE__, __LINE__, __func__);
f92363d1
SR		 5632 return -1;
5633 }
5634
5635 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5636 MPI2_IOCSTATUS_MASK;
5637 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 5638 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5639 __FILE__, __LINE__, __func__);
f92363d1
SR		 5640 return -1;
5641 }
5642
5643 /* handle out of order topology events */
5644 parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle);
5645 if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
5646 != 0) {
919d8a3f
JP		 5647 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5648 __FILE__, __LINE__, __func__);
f92363d1
SR		 5649 return -1;
5650 }
5651 if (sas_address_parent != ioc->sas_hba.sas_address) {
5652 spin_lock_irqsave(&ioc->sas_node_lock, flags);
5653 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
5654 sas_address_parent);
5655 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5656 if (!sas_expander) {
5657 rc = _scsih_expander_add(ioc, parent_handle);
5658 if (rc != 0)
5659 return rc;
5660 }
5661 }
5662
5663 spin_lock_irqsave(&ioc->sas_node_lock, flags);
5664 sas_address = le64_to_cpu(expander_pg0.SASAddress);
5665 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
5666 sas_address);
5667 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5668
5669 if (sas_expander)
5670 return 0;
5671
5672 sas_expander = kzalloc(sizeof(struct _sas_node),
5673 GFP_KERNEL);
5674 if (!sas_expander) {
919d8a3f
JP		 5675 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5676 __FILE__, __LINE__, __func__);
f92363d1
SR		 5677 return -1;
5678 }
5679
5680 sas_expander->handle = handle;
5681 sas_expander->num_phys = expander_pg0.NumPhys;
5682 sas_expander->sas_address_parent = sas_address_parent;
5683 sas_expander->sas_address = sas_address;
5684
919d8a3f
JP		 5685 ioc_info(ioc, "expander_add: handle(0x%04x), parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
5686 handle, parent_handle,
5687 (u64)sas_expander->sas_address, sas_expander->num_phys);
f92363d1
SR		 5688
5689 if (!sas_expander->num_phys)
5690 goto out_fail;
5691 sas_expander->phy = kcalloc(sas_expander->num_phys,
5692 sizeof(struct _sas_phy), GFP_KERNEL);
5693 if (!sas_expander->phy) {
919d8a3f
JP		 5694 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5695 __FILE__, __LINE__, __func__);
f92363d1
SR		 5696 rc = -1;
5697 goto out_fail;
5698 }
5699
5700 INIT_LIST_HEAD(&sas_expander->sas_port_list);
5701 mpt3sas_port = mpt3sas_transport_port_add(ioc, handle,
5702 sas_address_parent);
5703 if (!mpt3sas_port) {
919d8a3f
JP		 5704 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5705 __FILE__, __LINE__, __func__);
f92363d1
SR		 5706 rc = -1;
5707 goto out_fail;
5708 }
5709 sas_expander->parent_dev = &mpt3sas_port->rphy->dev;
5710
5711 for (i = 0 ; i < sas_expander->num_phys ; i++) {
5712 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
5713 &expander_pg1, i, handle))) {
919d8a3f
JP		 5714 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5715 __FILE__, __LINE__, __func__);
f92363d1
SR		 5716 rc = -1;
5717 goto out_fail;
5718 }
5719 sas_expander->phy[i].handle = handle;
5720 sas_expander->phy[i].phy_id = i;
5721
5722 if ((mpt3sas_transport_add_expander_phy(ioc,
5723 &sas_expander->phy[i], expander_pg1,
5724 sas_expander->parent_dev))) {
919d8a3f
JP		 5725 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5726 __FILE__, __LINE__, __func__);
f92363d1
SR		 5727 rc = -1;
5728 goto out_fail;
5729 }
5730 }
5731
5732 if (sas_expander->enclosure_handle) {
22a923c3
C		 5733 enclosure_dev =
5734 mpt3sas_scsih_enclosure_find_by_handle(ioc,
5735 sas_expander->enclosure_handle);
5736 if (enclosure_dev)
f92363d1 5737 sas_expander->enclosure_logical_id =
22a923c3 5738 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID);
f92363d1
SR		 5739 }
5740
5741 _scsih_expander_node_add(ioc, sas_expander);
199fd79a 5742 return 0;
f92363d1
SR		 5743
5744 out_fail:
5745
5746 if (mpt3sas_port)
5747 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
5748 sas_address_parent);
5749 kfree(sas_expander);
5750 return rc;
5751}
5752
5753/**
5754 * mpt3sas_expander_remove - removing expander object
5755 * @ioc: per adapter object
5756 * @sas_address: expander sas_address
f92363d1
SR		 5757 */
5758void
5759mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
5760{
5761 struct _sas_node *sas_expander;
5762 unsigned long flags;
5763
5764 if (ioc->shost_recovery)
5765 return;
5766
5767 spin_lock_irqsave(&ioc->sas_node_lock, flags);
5768 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
5769 sas_address);
f92363d1
SR		 5770 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5771 if (sas_expander)
5772 _scsih_expander_node_remove(ioc, sas_expander);
5773}
5774
5775/**
5776 * _scsih_done - internal SCSI_IO callback handler.
5777 * @ioc: per adapter object
5778 * @smid: system request message index
5779 * @msix_index: MSIX table index supplied by the OS
5780 * @reply: reply message frame(lower 32bit addr)
5781 *
5782 * Callback handler when sending internal generated SCSI_IO.
5783 * The callback index passed is `ioc->scsih_cb_idx`
5784 *
4beb4867
BVA		 5785 * Return: 1 meaning mf should be freed from _base_interrupt
5786 * 0 means the mf is freed from this function.
f92363d1
SR		 5787 */
5788static u8
5789_scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
5790{
5791 MPI2DefaultReply_t *mpi_reply;
5792
5793 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
5794 if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED)
5795 return 1;
5796 if (ioc->scsih_cmds.smid != smid)
5797 return 1;
5798 ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE;
5799 if (mpi_reply) {
5800 memcpy(ioc->scsih_cmds.reply, mpi_reply,
5801 mpi_reply->MsgLength*4);
5802 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID;
5803 }
5804 ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING;
5805 complete(&ioc->scsih_cmds.done);
5806 return 1;
5807}
5808
5809
5810
5811
5812#define MPT3_MAX_LUNS (255)
5813
5814
5815/**
5816 * _scsih_check_access_status - check access flags
5817 * @ioc: per adapter object
5818 * @sas_address: sas address
5819 * @handle: sas device handle
4beb4867 5820 * @access_status: errors returned during discovery of the device
f92363d1 5821 *
4beb4867 5822 * Return: 0 for success, else failure
f92363d1
SR		 5823 */
5824static u8
5825_scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
5826 u16 handle, u8 access_status)
5827{
5828 u8 rc = 1;
5829 char *desc = NULL;
5830
5831 switch (access_status) {
5832 case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS:
5833 case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION:
5834 rc = 0;
5835 break;
5836 case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED:
5837 desc = "sata capability failed";
5838 break;
5839 case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT:
5840 desc = "sata affiliation conflict";
5841 break;
5842 case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE:
5843 desc = "route not addressable";
5844 break;
5845 case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE:
5846 desc = "smp error not addressable";
5847 break;
5848 case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED:
5849 desc = "device blocked";
5850 break;
5851 case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED:
5852 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN:
5853 case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT:
5854 case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG:
5855 case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION:
5856 case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER:
5857 case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN:
5858 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN:
5859 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN:
5860 case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION:
5861 case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE:
5862 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX:
5863 desc = "sata initialization failed";
5864 break;
5865 default:
5866 desc = "unknown";
5867 break;
5868 }
5869
5870 if (!rc)
5871 return 0;
5872
919d8a3f
JP		 5873 ioc_err(ioc, "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n",
5874 desc, (u64)sas_address, handle);
f92363d1
SR		 5875 return rc;
5876}
5877
5878/**
5879 * _scsih_check_device - checking device responsiveness
5880 * @ioc: per adapter object
5881 * @parent_sas_address: sas address of parent expander or sas host
5882 * @handle: attached device handle
4beb4867 5883 * @phy_number: phy number
f92363d1 5884 * @link_rate: new link rate
f92363d1
SR		 5885 */
5886static void
5887_scsih_check_device(struct MPT3SAS_ADAPTER *ioc,
5888 u64 parent_sas_address, u16 handle, u8 phy_number, u8 link_rate)
5889{
5890 Mpi2ConfigReply_t mpi_reply;
5891 Mpi2SasDevicePage0_t sas_device_pg0;
5892 struct _sas_device *sas_device;
22a923c3 5893 struct _enclosure_node *enclosure_dev = NULL;
f92363d1
SR		 5894 u32 ioc_status;
5895 unsigned long flags;
5896 u64 sas_address;
5897 struct scsi_target *starget;
5898 struct MPT3SAS_TARGET *sas_target_priv_data;
5899 u32 device_info;
5900
f92363d1
SR		 5901 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5902 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)))
5903 return;
5904
5905 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
5906 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
5907 return;
5908
5909 /* wide port handling ~ we need only handle device once for the phy that
5910 * is matched in sas device page zero
5911 */
5912 if (phy_number != sas_device_pg0.PhyNum)
5913 return;
5914
5915 /* check if this is end device */
5916 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5917 if (!(_scsih_is_end_device(device_info)))
5918 return;
5919
5920 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5921 sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
d1cb5e49 5922 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
f92363d1
SR		 5923 sas_address);
5924
d1cb5e49
SR		 5925 if (!sas_device)
5926 goto out_unlock;
f92363d1
SR		 5927
5928 if (unlikely(sas_device->handle != handle)) {
5929 starget = sas_device->starget;
5930 sas_target_priv_data = starget->hostdata;
5931 starget_printk(KERN_INFO, starget,
5932 "handle changed from(0x%04x) to (0x%04x)!!!\n",
5933 sas_device->handle, handle);
5934 sas_target_priv_data->handle = handle;
5935 sas_device->handle = handle;
aa53bb89 5936 if (le16_to_cpu(sas_device_pg0.Flags) &
e6d45e3e
SR		 5937 MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
5938 sas_device->enclosure_level =
aa53bb89 5939 sas_device_pg0.EnclosureLevel;
310c8e40
CO		 5940 memcpy(sas_device->connector_name,
5941 sas_device_pg0.ConnectorName, 4);
5942 sas_device->connector_name[4] = '\0';
e6d45e3e
SR		 5943 } else {
5944 sas_device->enclosure_level = 0;
5945 sas_device->connector_name[0] = '\0';
5946 }
aba5a85c 5947
22a923c3
C		 5948 sas_device->enclosure_handle =
5949 le16_to_cpu(sas_device_pg0.EnclosureHandle);
5950 sas_device->is_chassis_slot_valid = 0;
5951 enclosure_dev = mpt3sas_scsih_enclosure_find_by_handle(ioc,
5952 sas_device->enclosure_handle);
5953 if (enclosure_dev) {
5954 sas_device->enclosure_logical_id =
5955 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID);
5956 if (le16_to_cpu(enclosure_dev->pg0.Flags) &
5957 MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) {
5958 sas_device->is_chassis_slot_valid = 1;
5959 sas_device->chassis_slot =
5960 enclosure_dev->pg0.ChassisSlot;
5961 }
5962 }
f92363d1
SR		 5963 }
5964
5965 /* check if device is present */
5966 if (!(le16_to_cpu(sas_device_pg0.Flags) &
5967 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
919d8a3f
JP		 5968 ioc_err(ioc, "device is not present handle(0x%04x), flags!!!\n",
5969 handle);
d1cb5e49 5970 goto out_unlock;
f92363d1
SR		 5971 }
5972
5973 /* check if there were any issues with discovery */
5974 if (_scsih_check_access_status(ioc, sas_address, handle,
d1cb5e49
SR		 5975 sas_device_pg0.AccessStatus))
5976 goto out_unlock;
f92363d1
SR		 5977
5978 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5979 _scsih_ublock_io_device(ioc, sas_address);
5980
d1cb5e49
SR		 5981 if (sas_device)
5982 sas_device_put(sas_device);
5983 return;
5984
5985out_unlock:
5986 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5987 if (sas_device)
5988 sas_device_put(sas_device);
f92363d1
SR		 5989}
5990
5991/**
5992 * _scsih_add_device - creating sas device object
5993 * @ioc: per adapter object
5994 * @handle: sas device handle
5995 * @phy_num: phy number end device attached to
5996 * @is_pd: is this hidden raid component
5997 *
5998 * Creating end device object, stored in ioc->sas_device_list.
5999 *
4beb4867 6000 * Return: 0 for success, non-zero for failure.
f92363d1
SR		 6001 */
6002static int
6003_scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num,
6004 u8 is_pd)
6005{
6006 Mpi2ConfigReply_t mpi_reply;
6007 Mpi2SasDevicePage0_t sas_device_pg0;
f92363d1 6008 struct _sas_device *sas_device;
22a923c3 6009 struct _enclosure_node *enclosure_dev = NULL;
f92363d1
SR		 6010 u32 ioc_status;
6011 u64 sas_address;
6012 u32 device_info;
f92363d1
SR		 6013
6014 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
6015 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
919d8a3f
JP		 6016 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6017 __FILE__, __LINE__, __func__);
f92363d1
SR		 6018 return -1;
6019 }
6020
6021 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6022 MPI2_IOCSTATUS_MASK;
6023 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 6024 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6025 __FILE__, __LINE__, __func__);
f92363d1
SR		 6026 return -1;
6027 }
6028
6029 /* check if this is end device */
6030 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
6031 if (!(_scsih_is_end_device(device_info)))
6032 return -1;
c696f7b8 6033 set_bit(handle, ioc->pend_os_device_add);
f92363d1
SR		 6034 sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
6035
6036 /* check if device is present */
6037 if (!(le16_to_cpu(sas_device_pg0.Flags) &
6038 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
919d8a3f
JP		 6039 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n",
6040 handle);
f92363d1
SR		 6041 return -1;
6042 }
6043
6044 /* check if there were any issues with discovery */
6045 if (_scsih_check_access_status(ioc, sas_address, handle,
6046 sas_device_pg0.AccessStatus))
6047 return -1;
6048
d1cb5e49
SR		 6049 sas_device = mpt3sas_get_sdev_by_addr(ioc,
6050 sas_address);
6051 if (sas_device) {
c696f7b8 6052 clear_bit(handle, ioc->pend_os_device_add);
d1cb5e49 6053 sas_device_put(sas_device);
f92363d1 6054 return -1;
d1cb5e49 6055 }
f92363d1 6056
75888956 6057 if (sas_device_pg0.EnclosureHandle) {
22a923c3
C		 6058 enclosure_dev =
6059 mpt3sas_scsih_enclosure_find_by_handle(ioc,
6060 le16_to_cpu(sas_device_pg0.EnclosureHandle));
6061 if (enclosure_dev == NULL)
919d8a3f
JP		 6062 ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
6063 sas_device_pg0.EnclosureHandle);
75888956
SR		 6064 }
6065
f92363d1
SR		 6066 sas_device = kzalloc(sizeof(struct _sas_device),
6067 GFP_KERNEL);
6068 if (!sas_device) {
919d8a3f
JP		 6069 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6070 __FILE__, __LINE__, __func__);
f92363d1
SR		 6071 return 0;
6072 }
6073
d1cb5e49 6074 kref_init(&sas_device->refcount);
f92363d1
SR		 6075 sas_device->handle = handle;
6076 if (_scsih_get_sas_address(ioc,
6077 le16_to_cpu(sas_device_pg0.ParentDevHandle),
6078 &sas_device->sas_address_parent) != 0)
919d8a3f
JP		 6079 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6080 __FILE__, __LINE__, __func__);
f92363d1
SR		 6081 sas_device->enclosure_handle =
6082 le16_to_cpu(sas_device_pg0.EnclosureHandle);
e6d45e3e
SR		 6083 if (sas_device->enclosure_handle != 0)
6084 sas_device->slot =
6085 le16_to_cpu(sas_device_pg0.Slot);
f92363d1
SR		 6086 sas_device->device_info = device_info;
6087 sas_device->sas_address = sas_address;
6088 sas_device->phy = sas_device_pg0.PhyNum;
6089 sas_device->fast_path = (le16_to_cpu(sas_device_pg0.Flags) &
6090 MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0;
6091
aa53bb89
SPS		 6092 if (le16_to_cpu(sas_device_pg0.Flags)
6093 & MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
e6d45e3e 6094 sas_device->enclosure_level =
aa53bb89 6095 sas_device_pg0.EnclosureLevel;
310c8e40
CO		 6096 memcpy(sas_device->connector_name,
6097 sas_device_pg0.ConnectorName, 4);
6098 sas_device->connector_name[4] = '\0';
e6d45e3e
SR		 6099 } else {
6100 sas_device->enclosure_level = 0;
6101 sas_device->connector_name[0] = '\0';
6102 }
22a923c3 6103 /* get enclosure_logical_id & chassis_slot*/
75888956 6104 sas_device->is_chassis_slot_valid = 0;
22a923c3 6105 if (enclosure_dev) {
f92363d1 6106 sas_device->enclosure_logical_id =
22a923c3
C		 6107 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID);
6108 if (le16_to_cpu(enclosure_dev->pg0.Flags) &
75888956
SR		 6109 MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) {
6110 sas_device->is_chassis_slot_valid = 1;
6111 sas_device->chassis_slot =
22a923c3 6112 enclosure_dev->pg0.ChassisSlot;
75888956
SR		 6113 }
6114 }
6115
f92363d1
SR		 6116 /* get device name */
6117 sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName);
6118
6119 if (ioc->wait_for_discovery_to_complete)
6120 _scsih_sas_device_init_add(ioc, sas_device);
6121 else
6122 _scsih_sas_device_add(ioc, sas_device);
6123
d1cb5e49 6124 sas_device_put(sas_device);
f92363d1
SR		 6125 return 0;
6126}
6127
6128/**
6129 * _scsih_remove_device - removing sas device object
6130 * @ioc: per adapter object
4beb4867 6131 * @sas_device: the sas_device object
f92363d1
SR		 6132 */
6133static void
6134_scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
6135 struct _sas_device *sas_device)
6136{
6137 struct MPT3SAS_TARGET *sas_target_priv_data;
6138
0f624c39
SR		 6139 if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) &&
6140 (sas_device->pfa_led_on)) {
6141 _scsih_turn_off_pfa_led(ioc, sas_device);
6142 sas_device->pfa_led_on = 0;
6143 }
75888956 6144
919d8a3f
JP		 6145 dewtprintk(ioc,
6146 ioc_info(ioc, "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n",
6147 __func__,
6148 sas_device->handle, (u64)sas_device->sas_address));
75888956
SR		 6149
6150 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
6151 NULL, NULL));
f92363d1
SR		 6152
6153 if (sas_device->starget && sas_device->starget->hostdata) {
6154 sas_target_priv_data = sas_device->starget->hostdata;
6155 sas_target_priv_data->deleted = 1;
6156 _scsih_ublock_io_device(ioc, sas_device->sas_address);
6157 sas_target_priv_data->handle =
6158 MPT3SAS_INVALID_DEVICE_HANDLE;
6159 }
7786ab6a
SR		 6160
6161 if (!ioc->hide_drives)
6162 mpt3sas_transport_port_remove(ioc,
f92363d1
SR		 6163 sas_device->sas_address,
6164 sas_device->sas_address_parent);
6165
919d8a3f
JP		 6166 ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n",
6167 sas_device->handle, (u64)sas_device->sas_address);
75888956
SR		 6168
6169 _scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL);
f92363d1 6170
919d8a3f
JP		 6171 dewtprintk(ioc,
6172 ioc_info(ioc, "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n",
6173 __func__,
6174 sas_device->handle, (u64)sas_device->sas_address));
75888956
SR		 6175 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
6176 NULL, NULL));
f92363d1
SR		 6177}
6178
f92363d1
SR		 6179/**
6180 * _scsih_sas_topology_change_event_debug - debug for topology event
6181 * @ioc: per adapter object
6182 * @event_data: event data payload
6183 * Context: user.
6184 */
6185static void
6186_scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
6187 Mpi2EventDataSasTopologyChangeList_t *event_data)
6188{
6189 int i;
6190 u16 handle;
6191 u16 reason_code;
6192 u8 phy_number;
6193 char *status_str = NULL;
6194 u8 link_rate, prev_link_rate;
6195
6196 switch (event_data->ExpStatus) {
6197 case MPI2_EVENT_SAS_TOPO_ES_ADDED:
6198 status_str = "add";
6199 break;
6200 case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING:
6201 status_str = "remove";
6202 break;
6203 case MPI2_EVENT_SAS_TOPO_ES_RESPONDING:
6204 case 0:
6205 status_str = "responding";
6206 break;
6207 case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING:
6208 status_str = "remove delay";
6209 break;
6210 default:
6211 status_str = "unknown status";
6212 break;
6213 }
919d8a3f 6214 ioc_info(ioc, "sas topology change: (%s)\n", status_str);
f92363d1
SR		 6215 pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \
6216 "start_phy(%02d), count(%d)\n",
6217 le16_to_cpu(event_data->ExpanderDevHandle),
6218 le16_to_cpu(event_data->EnclosureHandle),
6219 event_data->StartPhyNum, event_data->NumEntries);
6220 for (i = 0; i < event_data->NumEntries; i++) {
6221 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
6222 if (!handle)
6223 continue;
6224 phy_number = event_data->StartPhyNum + i;
6225 reason_code = event_data->PHY[i].PhyStatus &
6226 MPI2_EVENT_SAS_TOPO_RC_MASK;
6227 switch (reason_code) {
6228 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
6229 status_str = "target add";
6230 break;
6231 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
6232 status_str = "target remove";
6233 break;
6234 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
6235 status_str = "delay target remove";
6236 break;
6237 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
6238 status_str = "link rate change";
6239 break;
6240 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
6241 status_str = "target responding";
6242 break;
6243 default:
6244 status_str = "unknown";
6245 break;
6246 }
6247 link_rate = event_data->PHY[i].LinkRate >> 4;
6248 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
6249 pr_info("\tphy(%02d), attached_handle(0x%04x): %s:" \
6250 " link rate: new(0x%02x), old(0x%02x)\n", phy_number,
6251 handle, status_str, link_rate, prev_link_rate);
6252
6253 }
6254}
f92363d1
SR		 6255
6256/**
6257 * _scsih_sas_topology_change_event - handle topology changes
6258 * @ioc: per adapter object
6259 * @fw_event: The fw_event_work object
6260 * Context: user.
6261 *
6262 */
6263static int
6264_scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
6265 struct fw_event_work *fw_event)
6266{
6267 int i;
6268 u16 parent_handle, handle;
6269 u16 reason_code;
6270 u8 phy_number, max_phys;
6271 struct _sas_node *sas_expander;
6272 u64 sas_address;
6273 unsigned long flags;
6274 u8 link_rate, prev_link_rate;
35b62362
JL		 6275 Mpi2EventDataSasTopologyChangeList_t *event_data =
6276 (Mpi2EventDataSasTopologyChangeList_t *)
6277 fw_event->event_data;
f92363d1 6278
f92363d1
SR		 6279 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6280 _scsih_sas_topology_change_event_debug(ioc, event_data);
f92363d1
SR		 6281
6282 if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery)
6283 return 0;
6284
6285 if (!ioc->sas_hba.num_phys)
6286 _scsih_sas_host_add(ioc);
6287 else
6288 _scsih_sas_host_refresh(ioc);
6289
6290 if (fw_event->ignore) {
919d8a3f 6291 dewtprintk(ioc, ioc_info(ioc, "ignoring expander event\n"));
f92363d1
SR		 6292 return 0;
6293 }
6294
6295 parent_handle = le16_to_cpu(event_data->ExpanderDevHandle);
6296
6297 /* handle expander add */
6298 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED)
6299 if (_scsih_expander_add(ioc, parent_handle) != 0)
6300 return 0;
6301
6302 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6303 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
6304 parent_handle);
6305 if (sas_expander) {
6306 sas_address = sas_expander->sas_address;
6307 max_phys = sas_expander->num_phys;
6308 } else if (parent_handle < ioc->sas_hba.num_phys) {
6309 sas_address = ioc->sas_hba.sas_address;
6310 max_phys = ioc->sas_hba.num_phys;
6311 } else {
6312 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6313 return 0;
6314 }
6315 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6316
6317 /* handle siblings events */
6318 for (i = 0; i < event_data->NumEntries; i++) {
6319 if (fw_event->ignore) {
919d8a3f
JP		 6320 dewtprintk(ioc,
6321 ioc_info(ioc, "ignoring expander event\n"));
f92363d1
SR		 6322 return 0;
6323 }
6324 if (ioc->remove_host || ioc->pci_error_recovery)
6325 return 0;
6326 phy_number = event_data->StartPhyNum + i;
6327 if (phy_number >= max_phys)
6328 continue;
6329 reason_code = event_data->PHY[i].PhyStatus &
6330 MPI2_EVENT_SAS_TOPO_RC_MASK;
6331 if ((event_data->PHY[i].PhyStatus &
6332 MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code !=
6333 MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING))
6334 continue;
6335 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
6336 if (!handle)
6337 continue;
6338 link_rate = event_data->PHY[i].LinkRate >> 4;
6339 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
6340 switch (reason_code) {
6341 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
6342
6343 if (ioc->shost_recovery)
6344 break;
6345
6346 if (link_rate == prev_link_rate)
6347 break;
6348
6349 mpt3sas_transport_update_links(ioc, sas_address,
6350 handle, phy_number, link_rate);
6351
6352 if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
6353 break;
6354
6355 _scsih_check_device(ioc, sas_address, handle,
6356 phy_number, link_rate);
6357
c696f7b8
SPS		 6358 if (!test_bit(handle, ioc->pend_os_device_add))
6359 break;
6360
eb0c7af2 6361 /* fall through */
f92363d1
SR		 6362
6363 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
6364
6365 if (ioc->shost_recovery)
6366 break;
6367
6368 mpt3sas_transport_update_links(ioc, sas_address,
6369 handle, phy_number, link_rate);
6370
6371 _scsih_add_device(ioc, handle, phy_number, 0);
6372
6373 break;
6374 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
6375
6376 _scsih_device_remove_by_handle(ioc, handle);
6377 break;
6378 }
6379 }
6380
6381 /* handle expander removal */
6382 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING &&
6383 sas_expander)
6384 mpt3sas_expander_remove(ioc, sas_address);
6385
6386 return 0;
6387}
6388
f92363d1
SR		 6389/**
6390 * _scsih_sas_device_status_change_event_debug - debug for device event
4beb4867 6391 * @ioc: ?
f92363d1
SR		 6392 * @event_data: event data payload
6393 * Context: user.
f92363d1
SR		 6394 */
6395static void
6396_scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
6397 Mpi2EventDataSasDeviceStatusChange_t *event_data)
6398{
6399 char *reason_str = NULL;
6400
6401 switch (event_data->ReasonCode) {
6402 case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
6403 reason_str = "smart data";
6404 break;
6405 case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
6406 reason_str = "unsupported device discovered";
6407 break;
6408 case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
6409 reason_str = "internal device reset";
6410 break;
6411 case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
6412 reason_str = "internal task abort";
6413 break;
6414 case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
6415 reason_str = "internal task abort set";
6416 break;
6417 case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
6418 reason_str = "internal clear task set";
6419 break;
6420 case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
6421 reason_str = "internal query task";
6422 break;
6423 case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE:
6424 reason_str = "sata init failure";
6425 break;
6426 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
6427 reason_str = "internal device reset complete";
6428 break;
6429 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
6430 reason_str = "internal task abort complete";
6431 break;
6432 case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
6433 reason_str = "internal async notification";
6434 break;
6435 case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY:
6436 reason_str = "expander reduced functionality";
6437 break;
6438 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY:
6439 reason_str = "expander reduced functionality complete";
6440 break;
6441 default:
6442 reason_str = "unknown reason";
6443 break;
6444 }
919d8a3f
JP		 6445 ioc_info(ioc, "device status change: (%s)\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
6446 reason_str, le16_to_cpu(event_data->DevHandle),
6447 (u64)le64_to_cpu(event_data->SASAddress),
6448 le16_to_cpu(event_data->TaskTag));
f92363d1 6449 if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA)
919d8a3f
JP		 6450 pr_cont(", ASC(0x%x), ASCQ(0x%x)\n",
6451 event_data->ASC, event_data->ASCQ);
6452 pr_cont("\n");
f92363d1 6453}
f92363d1
SR		 6454
6455/**
6456 * _scsih_sas_device_status_change_event - handle device status change
6457 * @ioc: per adapter object
6458 * @fw_event: The fw_event_work object
6459 * Context: user.
f92363d1
SR		 6460 */
6461static void
6462_scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
6463 struct fw_event_work *fw_event)
6464{
6465 struct MPT3SAS_TARGET *target_priv_data;
6466 struct _sas_device *sas_device;
6467 u64 sas_address;
6468 unsigned long flags;
6469 Mpi2EventDataSasDeviceStatusChange_t *event_data =
35b62362
JL		 6470 (Mpi2EventDataSasDeviceStatusChange_t *)
6471 fw_event->event_data;
f92363d1 6472
f92363d1
SR		 6473 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6474 _scsih_sas_device_status_change_event_debug(ioc,
6475 event_data);
f92363d1
SR		 6476
6477 /* In MPI Revision K (0xC), the internal device reset complete was
6478 * implemented, so avoid setting tm_busy flag for older firmware.
6479 */
6480 if ((ioc->facts.HeaderVersion >> 8) < 0xC)
6481 return;
6482
6483 if (event_data->ReasonCode !=
6484 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
6485 event_data->ReasonCode !=
6486 MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET)
6487 return;
6488
6489 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6490 sas_address = le64_to_cpu(event_data->SASAddress);
d1cb5e49 6491 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
f92363d1
SR		 6492 sas_address);
6493
d1cb5e49
SR		 6494 if (!sas_device || !sas_device->starget)
6495 goto out;
f92363d1
SR		 6496
6497 target_priv_data = sas_device->starget->hostdata;
d1cb5e49
SR		 6498 if (!target_priv_data)
6499 goto out;
f92363d1
SR		 6500
6501 if (event_data->ReasonCode ==
6502 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
6503 target_priv_data->tm_busy = 1;
6504 else
6505 target_priv_data->tm_busy = 0;
d1cb5e49
SR		 6506
6507out:
6508 if (sas_device)
6509 sas_device_put(sas_device);
6510
f92363d1
SR		 6511 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6512}
6513
4318c734 6514
c102e00c
SPS		 6515/**
6516 * _scsih_check_pcie_access_status - check access flags
6517 * @ioc: per adapter object
6518 * @wwid: wwid
6519 * @handle: sas device handle
4beb4867 6520 * @access_status: errors returned during discovery of the device
c102e00c 6521 *
4beb4867 6522 * Return: 0 for success, else failure
c102e00c
SPS		 6523 */
6524static u8
6525_scsih_check_pcie_access_status(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
6526 u16 handle, u8 access_status)
6527{
6528 u8 rc = 1;
6529 char *desc = NULL;
6530
6531 switch (access_status) {
6532 case MPI26_PCIEDEV0_ASTATUS_NO_ERRORS:
6533 case MPI26_PCIEDEV0_ASTATUS_NEEDS_INITIALIZATION:
6534 rc = 0;
6535 break;
6536 case MPI26_PCIEDEV0_ASTATUS_CAPABILITY_FAILED:
6537 desc = "PCIe device capability failed";
6538 break;
6539 case MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED:
6540 desc = "PCIe device blocked";
6541 break;
6542 case MPI26_PCIEDEV0_ASTATUS_MEMORY_SPACE_ACCESS_FAILED:
6543 desc = "PCIe device mem space access failed";
6544 break;
6545 case MPI26_PCIEDEV0_ASTATUS_UNSUPPORTED_DEVICE:
6546 desc = "PCIe device unsupported";
6547 break;
6548 case MPI26_PCIEDEV0_ASTATUS_MSIX_REQUIRED:
6549 desc = "PCIe device MSIx Required";
6550 break;
6551 case MPI26_PCIEDEV0_ASTATUS_INIT_FAIL_MAX:
6552 desc = "PCIe device init fail max";
6553 break;
6554 case MPI26_PCIEDEV0_ASTATUS_UNKNOWN:
6555 desc = "PCIe device status unknown";
6556 break;
6557 case MPI26_PCIEDEV0_ASTATUS_NVME_READY_TIMEOUT:
6558 desc = "nvme ready timeout";
6559 break;
6560 case MPI26_PCIEDEV0_ASTATUS_NVME_DEVCFG_UNSUPPORTED:
6561 desc = "nvme device configuration unsupported";
6562 break;
6563 case MPI26_PCIEDEV0_ASTATUS_NVME_IDENTIFY_FAILED:
6564 desc = "nvme identify failed";
6565 break;
6566 case MPI26_PCIEDEV0_ASTATUS_NVME_QCONFIG_FAILED:
6567 desc = "nvme qconfig failed";
6568 break;
6569 case MPI26_PCIEDEV0_ASTATUS_NVME_QCREATION_FAILED:
6570 desc = "nvme qcreation failed";
6571 break;
6572 case MPI26_PCIEDEV0_ASTATUS_NVME_EVENTCFG_FAILED:
6573 desc = "nvme eventcfg failed";
6574 break;
6575 case MPI26_PCIEDEV0_ASTATUS_NVME_GET_FEATURE_STAT_FAILED:
6576 desc = "nvme get feature stat failed";
6577 break;
6578 case MPI26_PCIEDEV0_ASTATUS_NVME_IDLE_TIMEOUT:
6579 desc = "nvme idle timeout";
6580 break;
6581 case MPI26_PCIEDEV0_ASTATUS_NVME_FAILURE_STATUS:
6582 desc = "nvme failure status";
6583 break;
6584 default:
919d8a3f
JP		 6585 ioc_err(ioc, "NVMe discovery error(0x%02x): wwid(0x%016llx), handle(0x%04x)\n",
6586 access_status, (u64)wwid, handle);
c102e00c
SPS		 6587 return rc;
6588 }
6589
6590 if (!rc)
6591 return rc;
6592
919d8a3f
JP		 6593 ioc_info(ioc, "NVMe discovery error(%s): wwid(0x%016llx), handle(0x%04x)\n",
6594 desc, (u64)wwid, handle);
c102e00c
SPS		 6595 return rc;
6596}
3075ac49
SPS		 6597
6598/**
6599 * _scsih_pcie_device_remove_from_sml - removing pcie device
6600 * from SML and free up associated memory
6601 * @ioc: per adapter object
6602 * @pcie_device: the pcie_device object
3075ac49
SPS		 6603 */
6604static void
6605_scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc,
6606 struct _pcie_device *pcie_device)
6607{
6608 struct MPT3SAS_TARGET *sas_target_priv_data;
6609
919d8a3f
JP		 6610 dewtprintk(ioc,
6611 ioc_info(ioc, "%s: enter: handle(0x%04x), wwid(0x%016llx)\n",
6612 __func__,
6613 pcie_device->handle, (u64)pcie_device->wwid));
3075ac49 6614 if (pcie_device->enclosure_handle != 0)
919d8a3f
JP		 6615 dewtprintk(ioc,
6616 ioc_info(ioc, "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n",
6617 __func__,
6618 (u64)pcie_device->enclosure_logical_id,
6619 pcie_device->slot));
3075ac49 6620 if (pcie_device->connector_name[0] != '\0')
919d8a3f
JP		 6621 dewtprintk(ioc,
6622 ioc_info(ioc, "%s: enter: enclosure level(0x%04x), connector name(%s)\n",
6623 __func__,
6624 pcie_device->enclosure_level,
6625 pcie_device->connector_name));
3075ac49
SPS		 6626
6627 if (pcie_device->starget && pcie_device->starget->hostdata) {
6628 sas_target_priv_data = pcie_device->starget->hostdata;
6629 sas_target_priv_data->deleted = 1;
6630 _scsih_ublock_io_device(ioc, pcie_device->wwid);
6631 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
6632 }
6633
919d8a3f
JP		 6634 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
6635 pcie_device->handle, (u64)pcie_device->wwid);
3075ac49 6636 if (pcie_device->enclosure_handle != 0)
919d8a3f
JP		 6637 ioc_info(ioc, "removing : enclosure logical id(0x%016llx), slot(%d)\n",
6638 (u64)pcie_device->enclosure_logical_id,
6639 pcie_device->slot);
3075ac49 6640 if (pcie_device->connector_name[0] != '\0')
919d8a3f
JP		 6641 ioc_info(ioc, "removing: enclosure level(0x%04x), connector name( %s)\n",
6642 pcie_device->enclosure_level,
6643 pcie_device->connector_name);
3075ac49
SPS		 6644
6645 if (pcie_device->starget)
6646 scsi_remove_target(&pcie_device->starget->dev);
919d8a3f
JP		 6647 dewtprintk(ioc,
6648 ioc_info(ioc, "%s: exit: handle(0x%04x), wwid(0x%016llx)\n",
6649 __func__,
6650 pcie_device->handle, (u64)pcie_device->wwid));
3075ac49 6651 if (pcie_device->enclosure_handle != 0)
919d8a3f
JP		 6652 dewtprintk(ioc,
6653 ioc_info(ioc, "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n",
6654 __func__,
6655 (u64)pcie_device->enclosure_logical_id,
6656 pcie_device->slot));
3075ac49 6657 if (pcie_device->connector_name[0] != '\0')
919d8a3f
JP		 6658 dewtprintk(ioc,
6659 ioc_info(ioc, "%s: exit: enclosure level(0x%04x), connector name( %s)\n",
6660 __func__,
6661 pcie_device->enclosure_level,
6662 pcie_device->connector_name));
3075ac49
SPS		 6663
6664 kfree(pcie_device->serial_number);
6665}
6666
6667
c102e00c
SPS		 6668/**
6669 * _scsih_pcie_check_device - checking device responsiveness
6670 * @ioc: per adapter object
6671 * @handle: attached device handle
c102e00c
SPS		 6672 */
6673static void
6674_scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
6675{
6676 Mpi2ConfigReply_t mpi_reply;
6677 Mpi26PCIeDevicePage0_t pcie_device_pg0;
6678 u32 ioc_status;
6679 struct _pcie_device *pcie_device;
6680 u64 wwid;
6681 unsigned long flags;
6682 struct scsi_target *starget;
6683 struct MPT3SAS_TARGET *sas_target_priv_data;
6684 u32 device_info;
6685
6686 if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
6687 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle)))
6688 return;
6689
6690 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
6691 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
6692 return;
6693
6694 /* check if this is end device */
6695 device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo);
6696 if (!(_scsih_is_nvme_device(device_info)))
6697 return;
6698
6699 wwid = le64_to_cpu(pcie_device_pg0.WWID);
6700 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
6701 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
6702
6703 if (!pcie_device) {
6704 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
6705 return;
6706 }
6707
6708 if (unlikely(pcie_device->handle != handle)) {
6709 starget = pcie_device->starget;
6710 sas_target_priv_data = starget->hostdata;
6711 starget_printk(KERN_INFO, starget,
6712 "handle changed from(0x%04x) to (0x%04x)!!!\n",
6713 pcie_device->handle, handle);
6714 sas_target_priv_data->handle = handle;
6715 pcie_device->handle = handle;
6716
6717 if (le32_to_cpu(pcie_device_pg0.Flags) &
6718 MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) {
6719 pcie_device->enclosure_level =
6720 pcie_device_pg0.EnclosureLevel;
6721 memcpy(&pcie_device->connector_name[0],
6722 &pcie_device_pg0.ConnectorName[0], 4);
6723 } else {
6724 pcie_device->enclosure_level = 0;
6725 pcie_device->connector_name[0] = '\0';
6726 }
6727 }
6728
6729 /* check if device is present */
6730 if (!(le32_to_cpu(pcie_device_pg0.Flags) &
6731 MPI26_PCIEDEV0_FLAGS_DEVICE_PRESENT)) {
919d8a3f
JP		 6732 ioc_info(ioc, "device is not present handle(0x%04x), flags!!!\n",
6733 handle);
c102e00c
SPS		 6734 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
6735 pcie_device_put(pcie_device);
6736 return;
6737 }
6738
6739 /* check if there were any issues with discovery */
6740 if (_scsih_check_pcie_access_status(ioc, wwid, handle,
6741 pcie_device_pg0.AccessStatus)) {
6742 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
6743 pcie_device_put(pcie_device);
6744 return;
6745 }
6746
6747 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
6748 pcie_device_put(pcie_device);
6749
6750 _scsih_ublock_io_device(ioc, wwid);
6751
6752 return;
6753}
6754
6755/**
6756 * _scsih_pcie_add_device - creating pcie device object
6757 * @ioc: per adapter object
6758 * @handle: pcie device handle
6759 *
6760 * Creating end device object, stored in ioc->pcie_device_list.
6761 *
4beb4867 6762 * Return: 1 means queue the event later, 0 means complete the event
c102e00c
SPS		 6763 */
6764static int
6765_scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
6766{
6767 Mpi26PCIeDevicePage0_t pcie_device_pg0;
6768 Mpi26PCIeDevicePage2_t pcie_device_pg2;
6769 Mpi2ConfigReply_t mpi_reply;
c102e00c 6770 struct _pcie_device *pcie_device;
22a923c3 6771 struct _enclosure_node *enclosure_dev;
c102e00c
SPS		 6772 u32 ioc_status;
6773 u64 wwid;
6774
6775 if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
6776 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle))) {
919d8a3f
JP		 6777 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6778 __FILE__, __LINE__, __func__);
c102e00c
SPS		 6779 return 0;
6780 }
6781 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6782 MPI2_IOCSTATUS_MASK;
6783 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 6784 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6785 __FILE__, __LINE__, __func__);
c102e00c
SPS		 6786 return 0;
6787 }
6788
6789 set_bit(handle, ioc->pend_os_device_add);
6790 wwid = le64_to_cpu(pcie_device_pg0.WWID);
6791
6792 /* check if device is present */
6793 if (!(le32_to_cpu(pcie_device_pg0.Flags) &
6794 MPI26_PCIEDEV0_FLAGS_DEVICE_PRESENT)) {
919d8a3f
JP		 6795 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n",
6796 handle);
c102e00c
SPS		 6797 return 0;
6798 }
6799
6800 /* check if there were any issues with discovery */
6801 if (_scsih_check_pcie_access_status(ioc, wwid, handle,
6802 pcie_device_pg0.AccessStatus))
6803 return 0;
6804
6805 if (!(_scsih_is_nvme_device(le32_to_cpu(pcie_device_pg0.DeviceInfo))))
6806 return 0;
6807
6808 pcie_device = mpt3sas_get_pdev_by_wwid(ioc, wwid);
6809 if (pcie_device) {
6810 clear_bit(handle, ioc->pend_os_device_add);
6811 pcie_device_put(pcie_device);
6812 return 0;
6813 }
6814
6815 pcie_device = kzalloc(sizeof(struct _pcie_device), GFP_KERNEL);
6816 if (!pcie_device) {
919d8a3f
JP		 6817 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6818 __FILE__, __LINE__, __func__);
c102e00c
SPS		 6819 return 0;
6820 }
6821
6822 kref_init(&pcie_device->refcount);
6823 pcie_device->id = ioc->pcie_target_id++;
6824 pcie_device->channel = PCIE_CHANNEL;
6825 pcie_device->handle = handle;
6826 pcie_device->device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo);
6827 pcie_device->wwid = wwid;
6828 pcie_device->port_num = pcie_device_pg0.PortNum;
6829 pcie_device->fast_path = (le32_to_cpu(pcie_device_pg0.Flags) &
6830 MPI26_PCIEDEV0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0;
c102e00c
SPS		 6831
6832 pcie_device->enclosure_handle =
6833 le16_to_cpu(pcie_device_pg0.EnclosureHandle);
6834 if (pcie_device->enclosure_handle != 0)
6835 pcie_device->slot = le16_to_cpu(pcie_device_pg0.Slot);
6836
cf6bf971 6837 if (le32_to_cpu(pcie_device_pg0.Flags) &
c102e00c
SPS		 6838 MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) {
6839 pcie_device->enclosure_level = pcie_device_pg0.EnclosureLevel;
6840 memcpy(&pcie_device->connector_name[0],
6841 &pcie_device_pg0.ConnectorName[0], 4);
6842 } else {
6843 pcie_device->enclosure_level = 0;
6844 pcie_device->connector_name[0] = '\0';
6845 }
6846
6847 /* get enclosure_logical_id */
22a923c3
C		 6848 if (pcie_device->enclosure_handle) {
6849 enclosure_dev =
6850 mpt3sas_scsih_enclosure_find_by_handle(ioc,
6851 pcie_device->enclosure_handle);
6852 if (enclosure_dev)
6853 pcie_device->enclosure_logical_id =
6854 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID);
6855 }
c102e00c
SPS		 6856 /* TODO -- Add device name once FW supports it */
6857 if (mpt3sas_config_get_pcie_device_pg2(ioc, &mpi_reply,
6858 &pcie_device_pg2, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)) {
919d8a3f
JP		 6859 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6860 __FILE__, __LINE__, __func__);
c102e00c
SPS		 6861 kfree(pcie_device);
6862 return 0;
6863 }
6864
6865 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
6866 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 6867 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6868 __FILE__, __LINE__, __func__);
c102e00c
SPS		 6869 kfree(pcie_device);
6870 return 0;
6871 }
6872 pcie_device->nvme_mdts =
6873 le32_to_cpu(pcie_device_pg2.MaximumDataTransferSize);
c1a6c5ac
C		 6874 if (pcie_device_pg2.ControllerResetTO)
6875 pcie_device->reset_timeout =
6876 pcie_device_pg2.ControllerResetTO;
6877 else
6878 pcie_device->reset_timeout = 30;
c102e00c
SPS		 6879
6880 if (ioc->wait_for_discovery_to_complete)
6881 _scsih_pcie_device_init_add(ioc, pcie_device);
6882 else
6883 _scsih_pcie_device_add(ioc, pcie_device);
6884
6885 pcie_device_put(pcie_device);
6886 return 0;
6887}
4318c734
SPS		 6888
6889/**
6890 * _scsih_pcie_topology_change_event_debug - debug for topology
6891 * event
6892 * @ioc: per adapter object
6893 * @event_data: event data payload
6894 * Context: user.
6895 */
6896static void
6897_scsih_pcie_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
6898 Mpi26EventDataPCIeTopologyChangeList_t *event_data)
6899{
6900 int i;
6901 u16 handle;
6902 u16 reason_code;
6903 u8 port_number;
6904 char *status_str = NULL;
6905 u8 link_rate, prev_link_rate;
6906
6907 switch (event_data->SwitchStatus) {
6908 case MPI26_EVENT_PCIE_TOPO_SS_ADDED:
6909 status_str = "add";
6910 break;
6911 case MPI26_EVENT_PCIE_TOPO_SS_NOT_RESPONDING:
6912 status_str = "remove";
6913 break;
6914 case MPI26_EVENT_PCIE_TOPO_SS_RESPONDING:
6915 case 0:
6916 status_str = "responding";
6917 break;
6918 case MPI26_EVENT_PCIE_TOPO_SS_DELAY_NOT_RESPONDING:
6919 status_str = "remove delay";
6920 break;
6921 default:
6922 status_str = "unknown status";
6923 break;
6924 }
919d8a3f 6925 ioc_info(ioc, "pcie topology change: (%s)\n", status_str);
4318c734
SPS		 6926 pr_info("\tswitch_handle(0x%04x), enclosure_handle(0x%04x)"
6927 "start_port(%02d), count(%d)\n",
6928 le16_to_cpu(event_data->SwitchDevHandle),
6929 le16_to_cpu(event_data->EnclosureHandle),
6930 event_data->StartPortNum, event_data->NumEntries);
6931 for (i = 0; i < event_data->NumEntries; i++) {
6932 handle =
6933 le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle);
6934 if (!handle)
6935 continue;
6936 port_number = event_data->StartPortNum + i;
6937 reason_code = event_data->PortEntry[i].PortStatus;
6938 switch (reason_code) {
6939 case MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED:
6940 status_str = "target add";
6941 break;
6942 case MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING:
6943 status_str = "target remove";
6944 break;
6945 case MPI26_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING:
6946 status_str = "delay target remove";
6947 break;
6948 case MPI26_EVENT_PCIE_TOPO_PS_PORT_CHANGED:
6949 status_str = "link rate change";
6950 break;
6951 case MPI26_EVENT_PCIE_TOPO_PS_NO_CHANGE:
6952 status_str = "target responding";
6953 break;
6954 default:
6955 status_str = "unknown";
6956 break;
6957 }
6958 link_rate = event_data->PortEntry[i].CurrentPortInfo &
6959 MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK;
6960 prev_link_rate = event_data->PortEntry[i].PreviousPortInfo &
6961 MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK;
6962 pr_info("\tport(%02d), attached_handle(0x%04x): %s:"
6963 " link rate: new(0x%02x), old(0x%02x)\n", port_number,
6964 handle, status_str, link_rate, prev_link_rate);
6965 }
6966}
6967
6968/**
6969 * _scsih_pcie_topology_change_event - handle PCIe topology
6970 * changes
6971 * @ioc: per adapter object
6972 * @fw_event: The fw_event_work object
6973 * Context: user.
6974 *
6975 */
45b7aef7 6976static void
4318c734
SPS		 6977_scsih_pcie_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
6978 struct fw_event_work *fw_event)
6979{
6980 int i;
6981 u16 handle;
6982 u16 reason_code;
6983 u8 link_rate, prev_link_rate;
6984 unsigned long flags;
6985 int rc;
4318c734
SPS		 6986 Mpi26EventDataPCIeTopologyChangeList_t *event_data =
6987 (Mpi26EventDataPCIeTopologyChangeList_t *) fw_event->event_data;
6988 struct _pcie_device *pcie_device;
6989
6990 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6991 _scsih_pcie_topology_change_event_debug(ioc, event_data);
6992
6993 if (ioc->shost_recovery || ioc->remove_host ||
6994 ioc->pci_error_recovery)
45b7aef7 6995 return;
4318c734
SPS		 6996
6997 if (fw_event->ignore) {
919d8a3f 6998 dewtprintk(ioc, ioc_info(ioc, "ignoring switch event\n"));
45b7aef7 6999 return;
4318c734
SPS		 7000 }
7001
7002 /* handle siblings events */
7003 for (i = 0; i < event_data->NumEntries; i++) {
7004 if (fw_event->ignore) {
919d8a3f
JP		 7005 dewtprintk(ioc,
7006 ioc_info(ioc, "ignoring switch event\n"));
45b7aef7 7007 return;
4318c734
SPS		 7008 }
7009 if (ioc->remove_host || ioc->pci_error_recovery)
45b7aef7 7010 return;
4318c734
SPS		 7011 reason_code = event_data->PortEntry[i].PortStatus;
7012 handle =
7013 le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle);
7014 if (!handle)
7015 continue;
7016
7017 link_rate = event_data->PortEntry[i].CurrentPortInfo
7018 & MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK;
7019 prev_link_rate = event_data->PortEntry[i].PreviousPortInfo
7020 & MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK;
7021
7022 switch (reason_code) {
7023 case MPI26_EVENT_PCIE_TOPO_PS_PORT_CHANGED:
7024 if (ioc->shost_recovery)
7025 break;
7026 if (link_rate == prev_link_rate)
7027 break;
7028 if (link_rate < MPI26_EVENT_PCIE_TOPO_PI_RATE_2_5)
7029 break;
7030
7031 _scsih_pcie_check_device(ioc, handle);
7032
7033 /* This code after this point handles the test case
7034 * where a device has been added, however its returning
7035 * BUSY for sometime. Then before the Device Missing
7036 * Delay expires and the device becomes READY, the
7037 * device is removed and added back.
7038 */
7039 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
7040 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
7041 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
7042
7043 if (pcie_device) {
7044 pcie_device_put(pcie_device);
7045 break;
7046 }
7047
7048 if (!test_bit(handle, ioc->pend_os_device_add))
7049 break;
7050
919d8a3f
JP		 7051 dewtprintk(ioc,
7052 ioc_info(ioc, "handle(0x%04x) device not found: convert event to a device add\n",
7053 handle));
4318c734
SPS		 7054 event_data->PortEntry[i].PortStatus &= 0xF0;
7055 event_data->PortEntry[i].PortStatus |=
7056 MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED;
eb0c7af2 7057 /* fall through */
4318c734
SPS		 7058 case MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED:
7059 if (ioc->shost_recovery)
7060 break;
7061 if (link_rate < MPI26_EVENT_PCIE_TOPO_PI_RATE_2_5)
7062 break;
7063
7064 rc = _scsih_pcie_add_device(ioc, handle);
7065 if (!rc) {
7066 /* mark entry vacant */
7067 /* TODO This needs to be reviewed and fixed,
7068 * we dont have an entry
7069 * to make an event void like vacant
7070 */
7071 event_data->PortEntry[i].PortStatus |=
7072 MPI26_EVENT_PCIE_TOPO_PS_NO_CHANGE;
7073 }
7074 break;
7075 case MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING:
7076 _scsih_pcie_device_remove_by_handle(ioc, handle);
7077 break;
7078 }
7079 }
4318c734
SPS		 7080}
7081
7082/**
4beb4867
BVA		 7083 * _scsih_pcie_device_status_change_event_debug - debug for device event
7084 * @ioc: ?
4318c734
SPS		 7085 * @event_data: event data payload
7086 * Context: user.
4318c734
SPS		 7087 */
7088static void
7089_scsih_pcie_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
7090 Mpi26EventDataPCIeDeviceStatusChange_t *event_data)
7091{
7092 char *reason_str = NULL;
7093
7094 switch (event_data->ReasonCode) {
7095 case MPI26_EVENT_PCIDEV_STAT_RC_SMART_DATA:
7096 reason_str = "smart data";
7097 break;
7098 case MPI26_EVENT_PCIDEV_STAT_RC_UNSUPPORTED:
7099 reason_str = "unsupported device discovered";
7100 break;
7101 case MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET:
7102 reason_str = "internal device reset";
7103 break;
7104 case MPI26_EVENT_PCIDEV_STAT_RC_TASK_ABORT_INTERNAL:
7105 reason_str = "internal task abort";
7106 break;
7107 case MPI26_EVENT_PCIDEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
7108 reason_str = "internal task abort set";
7109 break;
7110 case MPI26_EVENT_PCIDEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
7111 reason_str = "internal clear task set";
7112 break;
7113 case MPI26_EVENT_PCIDEV_STAT_RC_QUERY_TASK_INTERNAL:
7114 reason_str = "internal query task";
7115 break;
7116 case MPI26_EVENT_PCIDEV_STAT_RC_DEV_INIT_FAILURE:
7117 reason_str = "device init failure";
7118 break;
7119 case MPI26_EVENT_PCIDEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
7120 reason_str = "internal device reset complete";
7121 break;
7122 case MPI26_EVENT_PCIDEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
7123 reason_str = "internal task abort complete";
7124 break;
7125 case MPI26_EVENT_PCIDEV_STAT_RC_ASYNC_NOTIFICATION:
7126 reason_str = "internal async notification";
7127 break;
c1a6c5ac
C		 7128 case MPI26_EVENT_PCIDEV_STAT_RC_PCIE_HOT_RESET_FAILED:
7129 reason_str = "pcie hot reset failed";
7130 break;
4318c734
SPS		 7131 default:
7132 reason_str = "unknown reason";
7133 break;
7134 }
7135
919d8a3f
JP		 7136 ioc_info(ioc, "PCIE device status change: (%s)\n"
7137 "\thandle(0x%04x), WWID(0x%016llx), tag(%d)",
7138 reason_str, le16_to_cpu(event_data->DevHandle),
7139 (u64)le64_to_cpu(event_data->WWID),
7140 le16_to_cpu(event_data->TaskTag));
4318c734 7141 if (event_data->ReasonCode == MPI26_EVENT_PCIDEV_STAT_RC_SMART_DATA)
919d8a3f 7142 pr_cont(", ASC(0x%x), ASCQ(0x%x)\n",
4318c734 7143 event_data->ASC, event_data->ASCQ);
919d8a3f 7144 pr_cont("\n");
4318c734
SPS		 7145}
7146
7147/**
7148 * _scsih_pcie_device_status_change_event - handle device status
7149 * change
7150 * @ioc: per adapter object
7151 * @fw_event: The fw_event_work object
7152 * Context: user.
4318c734
SPS		 7153 */
7154static void
7155_scsih_pcie_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
7156 struct fw_event_work *fw_event)
7157{
7158 struct MPT3SAS_TARGET *target_priv_data;
7159 struct _pcie_device *pcie_device;
7160 u64 wwid;
7161 unsigned long flags;
7162 Mpi26EventDataPCIeDeviceStatusChange_t *event_data =
7163 (Mpi26EventDataPCIeDeviceStatusChange_t *)fw_event->event_data;
7164 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
7165 _scsih_pcie_device_status_change_event_debug(ioc,
7166 event_data);
7167
7168 if (event_data->ReasonCode !=
7169 MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET &&
7170 event_data->ReasonCode !=
7171 MPI26_EVENT_PCIDEV_STAT_RC_CMP_INTERNAL_DEV_RESET)
7172 return;
7173
7174 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
7175 wwid = le64_to_cpu(event_data->WWID);
7176 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
7177
7178 if (!pcie_device || !pcie_device->starget)
7179 goto out;
7180
7181 target_priv_data = pcie_device->starget->hostdata;
7182 if (!target_priv_data)
7183 goto out;
7184
7185 if (event_data->ReasonCode ==
7186 MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET)
7187 target_priv_data->tm_busy = 1;
7188 else
7189 target_priv_data->tm_busy = 0;
7190out:
7191 if (pcie_device)
7192 pcie_device_put(pcie_device);
7193
7194 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
7195}
7196
f92363d1
SR		 7197/**
7198 * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure
7199 * event
7200 * @ioc: per adapter object
7201 * @event_data: event data payload
7202 * Context: user.
f92363d1
SR		 7203 */
7204static void
7205_scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
7206 Mpi2EventDataSasEnclDevStatusChange_t *event_data)
7207{
7208 char *reason_str = NULL;
7209
7210 switch (event_data->ReasonCode) {
7211 case MPI2_EVENT_SAS_ENCL_RC_ADDED:
7212 reason_str = "enclosure add";
7213 break;
7214 case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
7215 reason_str = "enclosure remove";
7216 break;
7217 default:
7218 reason_str = "unknown reason";
7219 break;
7220 }
7221
919d8a3f
JP		 7222 ioc_info(ioc, "enclosure status change: (%s)\n"
7223 "\thandle(0x%04x), enclosure logical id(0x%016llx) number slots(%d)\n",
7224 reason_str,
7225 le16_to_cpu(event_data->EnclosureHandle),
7226 (u64)le64_to_cpu(event_data->EnclosureLogicalID),
7227 le16_to_cpu(event_data->StartSlot));
f92363d1 7228}
f92363d1
SR		 7229
7230/**
7231 * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events
7232 * @ioc: per adapter object
7233 * @fw_event: The fw_event_work object
7234 * Context: user.
f92363d1
SR		 7235 */
7236static void
7237_scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc,
7238 struct fw_event_work *fw_event)
7239{
22a923c3
C		 7240 Mpi2ConfigReply_t mpi_reply;
7241 struct _enclosure_node *enclosure_dev = NULL;
7242 Mpi2EventDataSasEnclDevStatusChange_t *event_data =
7243 (Mpi2EventDataSasEnclDevStatusChange_t *)fw_event->event_data;
7244 int rc;
7245 u16 enclosure_handle = le16_to_cpu(event_data->EnclosureHandle);
7246
f92363d1
SR		 7247 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
7248 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
35b62362 7249 (Mpi2EventDataSasEnclDevStatusChange_t *)
f92363d1 7250 fw_event->event_data);
22a923c3
C		 7251 if (ioc->shost_recovery)
7252 return;
7253
7254 if (enclosure_handle)
7255 enclosure_dev =
7256 mpt3sas_scsih_enclosure_find_by_handle(ioc,
7257 enclosure_handle);
7258 switch (event_data->ReasonCode) {
7259 case MPI2_EVENT_SAS_ENCL_RC_ADDED:
7260 if (!enclosure_dev) {
7261 enclosure_dev =
7262 kzalloc(sizeof(struct _enclosure_node),
7263 GFP_KERNEL);
7264 if (!enclosure_dev) {
919d8a3f
JP		 7265 ioc_info(ioc, "failure at %s:%d/%s()!\n",
7266 __FILE__, __LINE__, __func__);
22a923c3
C		 7267 return;
7268 }
7269 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
7270 &enclosure_dev->pg0,
7271 MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
7272 enclosure_handle);
7273
7274 if (rc || (le16_to_cpu(mpi_reply.IOCStatus) &
7275 MPI2_IOCSTATUS_MASK)) {
7276 kfree(enclosure_dev);
7277 return;
7278 }
7279
7280 list_add_tail(&enclosure_dev->list,
7281 &ioc->enclosure_list);
7282 }
7283 break;
7284 case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
7285 if (enclosure_dev) {
7286 list_del(&enclosure_dev->list);
7287 kfree(enclosure_dev);
7288 }
7289 break;
7290 default:
7291 break;
7292 }
f92363d1
SR		 7293}
7294
7295/**
7296 * _scsih_sas_broadcast_primitive_event - handle broadcast events
7297 * @ioc: per adapter object
7298 * @fw_event: The fw_event_work object
7299 * Context: user.
f92363d1
SR		 7300 */
7301static void
7302_scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc,
7303 struct fw_event_work *fw_event)
7304{
7305 struct scsi_cmnd *scmd;
7306 struct scsi_device *sdev;
6da999fe 7307 struct scsiio_tracker *st;
f92363d1
SR		 7308 u16 smid, handle;
7309 u32 lun;
7310 struct MPT3SAS_DEVICE *sas_device_priv_data;
7311 u32 termination_count;
7312 u32 query_count;
7313 Mpi2SCSITaskManagementReply_t *mpi_reply;
35b62362
JL		 7314 Mpi2EventDataSasBroadcastPrimitive_t *event_data =
7315 (Mpi2EventDataSasBroadcastPrimitive_t *)
7316 fw_event->event_data;
f92363d1
SR		 7317 u16 ioc_status;
7318 unsigned long flags;
7319 int r;
7320 u8 max_retries = 0;
7321 u8 task_abort_retries;
7322
7323 mutex_lock(&ioc->tm_cmds.mutex);
919d8a3f
JP		 7324 ioc_info(ioc, "%s: enter: phy number(%d), width(%d)\n",
7325 __func__, event_data->PhyNum, event_data->PortWidth);
f92363d1
SR		 7326
7327 _scsih_block_io_all_device(ioc);
7328
7329 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7330 mpi_reply = ioc->tm_cmds.reply;
7331 broadcast_aen_retry:
7332
7333 /* sanity checks for retrying this loop */
7334 if (max_retries++ == 5) {
919d8a3f 7335 dewtprintk(ioc, ioc_info(ioc, "%s: giving up\n", __func__));
f92363d1
SR		 7336 goto out;
7337 } else if (max_retries > 1)
919d8a3f
JP		 7338 dewtprintk(ioc,
7339 ioc_info(ioc, "%s: %d retry\n",
7340 __func__, max_retries - 1));
f92363d1
SR		 7341
7342 termination_count = 0;
7343 query_count = 0;
7344 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
7345 if (ioc->shost_recovery)
7346 goto out;
dbec4c90 7347 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
f92363d1
SR		 7348 if (!scmd)
7349 continue;
dbec4c90 7350 st = scsi_cmd_priv(scmd);
f92363d1
SR		 7351 sdev = scmd->device;
7352 sas_device_priv_data = sdev->hostdata;
7353 if (!sas_device_priv_data || !sas_device_priv_data->sas_target)
7354 continue;
7355 /* skip hidden raid components */
7356 if (sas_device_priv_data->sas_target->flags &
7357 MPT_TARGET_FLAGS_RAID_COMPONENT)
7358 continue;
7359 /* skip volumes */
7360 if (sas_device_priv_data->sas_target->flags &
7361 MPT_TARGET_FLAGS_VOLUME)
7362 continue;
999c8513
C		 7363 /* skip PCIe devices */
7364 if (sas_device_priv_data->sas_target->flags &
7365 MPT_TARGET_FLAGS_PCIE_DEVICE)
7366 continue;
f92363d1
SR		 7367
7368 handle = sas_device_priv_data->sas_target->handle;
7369 lun = sas_device_priv_data->lun;
7370 query_count++;
7371
7372 if (ioc->shost_recovery)
7373 goto out;
7374
7375 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
6da999fe 7376 r = mpt3sas_scsih_issue_tm(ioc, handle, lun,
dbec4c90 7377 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, st->smid,
c1a6c5ac 7378 st->msix_io, 30, 0);
f92363d1
SR		 7379 if (r == FAILED) {
7380 sdev_printk(KERN_WARNING, sdev,
7381 "mpt3sas_scsih_issue_tm: FAILED when sending "
7382 "QUERY_TASK: scmd(%p)\n", scmd);
7383 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7384 goto broadcast_aen_retry;
7385 }
7386 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
7387 & MPI2_IOCSTATUS_MASK;
7388 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7389 sdev_printk(KERN_WARNING, sdev,
7390 "query task: FAILED with IOCSTATUS(0x%04x), scmd(%p)\n",
7391 ioc_status, scmd);
7392 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7393 goto broadcast_aen_retry;
7394 }
7395
7396 /* see if IO is still owned by IOC and target */
7397 if (mpi_reply->ResponseCode ==
7398 MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
7399 mpi_reply->ResponseCode ==
7400 MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) {
7401 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7402 continue;
7403 }
7404 task_abort_retries = 0;
7405 tm_retry:
7406 if (task_abort_retries++ == 60) {
919d8a3f
JP		 7407 dewtprintk(ioc,
7408 ioc_info(ioc, "%s: ABORT_TASK: giving up\n",
7409 __func__));
f92363d1
SR		 7410 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7411 goto broadcast_aen_retry;
7412 }
7413
7414 if (ioc->shost_recovery)
7415 goto out_no_lock;
7416
6da999fe 7417 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->lun,
dbec4c90 7418 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, st->smid,
c1a6c5ac 7419 st->msix_io, 30, 0);
dbec4c90 7420 if (r == FAILED || st->cb_idx != 0xFF) {
f92363d1
SR		 7421 sdev_printk(KERN_WARNING, sdev,
7422 "mpt3sas_scsih_issue_tm: ABORT_TASK: FAILED : "
7423 "scmd(%p)\n", scmd);
7424 goto tm_retry;
7425 }
7426
7427 if (task_abort_retries > 1)
7428 sdev_printk(KERN_WARNING, sdev,
7429 "mpt3sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):"
7430 " scmd(%p)\n",
7431 task_abort_retries - 1, scmd);
7432
7433 termination_count += le32_to_cpu(mpi_reply->TerminationCount);
7434 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7435 }
7436
7437 if (ioc->broadcast_aen_pending) {
919d8a3f
JP		 7438 dewtprintk(ioc,
7439 ioc_info(ioc,
7440 "%s: loop back due to pending AEN\n",
7441 __func__));
f92363d1
SR		 7442 ioc->broadcast_aen_pending = 0;
7443 goto broadcast_aen_retry;
7444 }
7445
7446 out:
7447 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
7448 out_no_lock:
7449
919d8a3f
JP		 7450 dewtprintk(ioc,
7451 ioc_info(ioc, "%s - exit, query_count = %d termination_count = %d\n",
7452 __func__, query_count, termination_count));
f92363d1
SR		 7453
7454 ioc->broadcast_aen_busy = 0;
7455 if (!ioc->shost_recovery)
7456 _scsih_ublock_io_all_device(ioc);
7457 mutex_unlock(&ioc->tm_cmds.mutex);
7458}
7459
7460/**
7461 * _scsih_sas_discovery_event - handle discovery events
7462 * @ioc: per adapter object
7463 * @fw_event: The fw_event_work object
7464 * Context: user.
f92363d1
SR		 7465 */
7466static void
7467_scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc,
7468 struct fw_event_work *fw_event)
7469{
35b62362
JL		 7470 Mpi2EventDataSasDiscovery_t *event_data =
7471 (Mpi2EventDataSasDiscovery_t *) fw_event->event_data;
f92363d1 7472
f92363d1 7473 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
919d8a3f
JP		 7474 ioc_info(ioc, "discovery event: (%s)",
7475 event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED ?
7476 "start" : "stop");
af009411 7477 if (event_data->DiscoveryStatus)
919d8a3f
JP		 7478 pr_cont("discovery_status(0x%08x)",
7479 le32_to_cpu(event_data->DiscoveryStatus));
7480 pr_cont("\n");
f92363d1 7481 }
f92363d1
SR		 7482
7483 if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
7484 !ioc->sas_hba.num_phys) {
7485 if (disable_discovery > 0 && ioc->shost_recovery) {
7486 /* Wait for the reset to complete */
7487 while (ioc->shost_recovery)
7488 ssleep(1);
7489 }
7490 _scsih_sas_host_add(ioc);
7491 }
7492}
7493
95540b8e
C		 7494/**
7495 * _scsih_sas_device_discovery_error_event - display SAS device discovery error
7496 * events
7497 * @ioc: per adapter object
7498 * @fw_event: The fw_event_work object
7499 * Context: user.
95540b8e
C		 7500 */
7501static void
7502_scsih_sas_device_discovery_error_event(struct MPT3SAS_ADAPTER *ioc,
7503 struct fw_event_work *fw_event)
7504{
7505 Mpi25EventDataSasDeviceDiscoveryError_t *event_data =
7506 (Mpi25EventDataSasDeviceDiscoveryError_t *)fw_event->event_data;
7507
7508 switch (event_data->ReasonCode) {
7509 case MPI25_EVENT_SAS_DISC_ERR_SMP_FAILED:
919d8a3f
JP		 7510 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has failed\n",
7511 le16_to_cpu(event_data->DevHandle),
7512 (u64)le64_to_cpu(event_data->SASAddress),
7513 event_data->PhysicalPort);
95540b8e
C		 7514 break;
7515 case MPI25_EVENT_SAS_DISC_ERR_SMP_TIMEOUT:
919d8a3f
JP		 7516 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has timed out\n",
7517 le16_to_cpu(event_data->DevHandle),
7518 (u64)le64_to_cpu(event_data->SASAddress),
7519 event_data->PhysicalPort);
95540b8e
C		 7520 break;
7521 default:
7522 break;
7523 }
7524}
7525
4318c734
SPS		 7526/**
7527 * _scsih_pcie_enumeration_event - handle enumeration events
7528 * @ioc: per adapter object
7529 * @fw_event: The fw_event_work object
7530 * Context: user.
4318c734
SPS		 7531 */
7532static void
7533_scsih_pcie_enumeration_event(struct MPT3SAS_ADAPTER *ioc,
7534 struct fw_event_work *fw_event)
7535{
7536 Mpi26EventDataPCIeEnumeration_t *event_data =
7537 (Mpi26EventDataPCIeEnumeration_t *)fw_event->event_data;
7538
6767aced
DC		 7539 if (!(ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK))
7540 return;
7541
919d8a3f
JP		 7542 ioc_info(ioc, "pcie enumeration event: (%s) Flag 0x%02x",
7543 (event_data->ReasonCode == MPI26_EVENT_PCIE_ENUM_RC_STARTED) ?
7544 "started" : "completed",
7545 event_data->Flags);
4318c734 7546 if (event_data->EnumerationStatus)
6767aced
DC		 7547 pr_cont("enumeration_status(0x%08x)",
7548 le32_to_cpu(event_data->EnumerationStatus));
7549 pr_cont("\n");
4318c734
SPS		 7550}
7551
f92363d1
SR		 7552/**
7553 * _scsih_ir_fastpath - turn on fastpath for IR physdisk
7554 * @ioc: per adapter object
7555 * @handle: device handle for physical disk
7556 * @phys_disk_num: physical disk number
7557 *
4beb4867 7558 * Return: 0 for success, else failure.
f92363d1
SR		 7559 */
7560static int
7561_scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num)
7562{
7563 Mpi2RaidActionRequest_t *mpi_request;
7564 Mpi2RaidActionReply_t *mpi_reply;
7565 u16 smid;
7566 u8 issue_reset = 0;
7567 int rc = 0;
7568 u16 ioc_status;
7569 u32 log_info;
7570
c84b06a4
SR		 7571 if (ioc->hba_mpi_version_belonged == MPI2_VERSION)
7572 return rc;
7573
f92363d1
SR		 7574 mutex_lock(&ioc->scsih_cmds.mutex);
7575
7576 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
919d8a3f 7577 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
f92363d1
SR		 7578 rc = -EAGAIN;
7579 goto out;
7580 }
7581 ioc->scsih_cmds.status = MPT3_CMD_PENDING;
7582
7583 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
7584 if (!smid) {
919d8a3f 7585 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
f92363d1
SR		 7586 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
7587 rc = -EAGAIN;
7588 goto out;
7589 }
7590
7591 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
7592 ioc->scsih_cmds.smid = smid;
7593 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
7594
7595 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
7596 mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN;
7597 mpi_request->PhysDiskNum = phys_disk_num;
7598
919d8a3f
JP		 7599 dewtprintk(ioc,
7600 ioc_info(ioc, "IR RAID_ACTION: turning fast path on for handle(0x%04x), phys_disk_num (0x%02x)\n",
7601 handle, phys_disk_num));
f92363d1
SR		 7602
7603 init_completion(&ioc->scsih_cmds.done);
40114bde 7604 mpt3sas_base_put_smid_default(ioc, smid);
f92363d1
SR		 7605 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
7606
7607 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
d37306ca
C		 7608 issue_reset =
7609 mpt3sas_base_check_cmd_timeout(ioc,
7610 ioc->scsih_cmds.status, mpi_request,
7611 sizeof(Mpi2RaidActionRequest_t)/4);
f92363d1
SR		 7612 rc = -EFAULT;
7613 goto out;
7614 }
7615
7616 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
7617
7618 mpi_reply = ioc->scsih_cmds.reply;
7619 ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
7620 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
7621 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
7622 else
7623 log_info = 0;
7624 ioc_status &= MPI2_IOCSTATUS_MASK;
7625 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 7626 dewtprintk(ioc,
7627 ioc_info(ioc, "IR RAID_ACTION: failed: ioc_status(0x%04x), loginfo(0x%08x)!!!\n",
7628 ioc_status, log_info));
f92363d1
SR		 7629 rc = -EFAULT;
7630 } else
919d8a3f
JP		 7631 dewtprintk(ioc,
7632 ioc_info(ioc, "IR RAID_ACTION: completed successfully\n"));
f92363d1
SR		 7633 }
7634
7635 out:
7636 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
7637 mutex_unlock(&ioc->scsih_cmds.mutex);
7638
7639 if (issue_reset)
98c56ad3 7640 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
f92363d1
SR		 7641 return rc;
7642}
7643
7644/**
7645 * _scsih_reprobe_lun - reprobing lun
7646 * @sdev: scsi device struct
7647 * @no_uld_attach: sdev->no_uld_attach flag setting
7648 *
7649 **/
7650static void
7651_scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
7652{
f92363d1
SR		 7653 sdev->no_uld_attach = no_uld_attach ? 1 : 0;
7654 sdev_printk(KERN_INFO, sdev, "%s raid component\n",
6c7abffc 7655 sdev->no_uld_attach ? "hiding" : "exposing");
8bbb1cf6 7656 WARN_ON(scsi_device_reprobe(sdev));
f92363d1
SR		 7657}
7658
7659/**
7660 * _scsih_sas_volume_add - add new volume
7661 * @ioc: per adapter object
7662 * @element: IR config element data
7663 * Context: user.
f92363d1
SR		 7664 */
7665static void
7666_scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc,
7667 Mpi2EventIrConfigElement_t *element)
7668{
7669 struct _raid_device *raid_device;
7670 unsigned long flags;
7671 u64 wwid;
7672 u16 handle = le16_to_cpu(element->VolDevHandle);
7673 int rc;
7674
7675 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
7676 if (!wwid) {
919d8a3f
JP		 7677 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7678 __FILE__, __LINE__, __func__);
f92363d1
SR		 7679 return;
7680 }
7681
7682 spin_lock_irqsave(&ioc->raid_device_lock, flags);
7683 raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
7684 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7685
7686 if (raid_device)
7687 return;
7688
7689 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
7690 if (!raid_device) {
919d8a3f
JP		 7691 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7692 __FILE__, __LINE__, __func__);
f92363d1
SR		 7693 return;
7694 }
7695
7696 raid_device->id = ioc->sas_id++;
7697 raid_device->channel = RAID_CHANNEL;
7698 raid_device->handle = handle;
7699 raid_device->wwid = wwid;
7700 _scsih_raid_device_add(ioc, raid_device);
7701 if (!ioc->wait_for_discovery_to_complete) {
7702 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
7703 raid_device->id, 0);
7704 if (rc)
7705 _scsih_raid_device_remove(ioc, raid_device);
7706 } else {
7707 spin_lock_irqsave(&ioc->raid_device_lock, flags);
7708 _scsih_determine_boot_device(ioc, raid_device, 1);
7709 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7710 }
7711}
7712
7713/**
7714 * _scsih_sas_volume_delete - delete volume
7715 * @ioc: per adapter object
7716 * @handle: volume device handle
7717 * Context: user.
f92363d1
SR		 7718 */
7719static void
7720_scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle)
7721{
7722 struct _raid_device *raid_device;
7723 unsigned long flags;
7724 struct MPT3SAS_TARGET *sas_target_priv_data;
7725 struct scsi_target *starget = NULL;
7726
7727 spin_lock_irqsave(&ioc->raid_device_lock, flags);
c84b06a4 7728 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
f92363d1
SR		 7729 if (raid_device) {
7730 if (raid_device->starget) {
7731 starget = raid_device->starget;
7732 sas_target_priv_data = starget->hostdata;
7733 sas_target_priv_data->deleted = 1;
7734 }
919d8a3f
JP		 7735 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
7736 raid_device->handle, (u64)raid_device->wwid);
f92363d1
SR		 7737 list_del(&raid_device->list);
7738 kfree(raid_device);
7739 }
7740 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7741 if (starget)
7742 scsi_remove_target(&starget->dev);
7743}
7744
7745/**
7746 * _scsih_sas_pd_expose - expose pd component to /dev/sdX
7747 * @ioc: per adapter object
7748 * @element: IR config element data
7749 * Context: user.
f92363d1
SR		 7750 */
7751static void
7752_scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc,
7753 Mpi2EventIrConfigElement_t *element)
7754{
7755 struct _sas_device *sas_device;
7756 struct scsi_target *starget = NULL;
7757 struct MPT3SAS_TARGET *sas_target_priv_data;
7758 unsigned long flags;
7759 u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
7760
7761 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49 7762 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
f92363d1
SR		 7763 if (sas_device) {
7764 sas_device->volume_handle = 0;
7765 sas_device->volume_wwid = 0;
7766 clear_bit(handle, ioc->pd_handles);
7767 if (sas_device->starget && sas_device->starget->hostdata) {
7768 starget = sas_device->starget;
7769 sas_target_priv_data = starget->hostdata;
7770 sas_target_priv_data->flags &=
7771 ~MPT_TARGET_FLAGS_RAID_COMPONENT;
7772 }
7773 }
7774 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7775 if (!sas_device)
7776 return;
7777
7778 /* exposing raid component */
7779 if (starget)
7780 starget_for_each_device(starget, NULL, _scsih_reprobe_lun);
d1cb5e49
SR		 7781
7782 sas_device_put(sas_device);
f92363d1
SR		 7783}
7784
7785/**
7786 * _scsih_sas_pd_hide - hide pd component from /dev/sdX
7787 * @ioc: per adapter object
7788 * @element: IR config element data
7789 * Context: user.
f92363d1
SR		 7790 */
7791static void
7792_scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc,
7793 Mpi2EventIrConfigElement_t *element)
7794{
7795 struct _sas_device *sas_device;
7796 struct scsi_target *starget = NULL;
7797 struct MPT3SAS_TARGET *sas_target_priv_data;
7798 unsigned long flags;
7799 u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
7800 u16 volume_handle = 0;
7801 u64 volume_wwid = 0;
7802
7803 mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle);
7804 if (volume_handle)
7805 mpt3sas_config_get_volume_wwid(ioc, volume_handle,
7806 &volume_wwid);
7807
7808 spin_lock_irqsave(&ioc->sas_device_lock, flags);
d1cb5e49 7809 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
f92363d1
SR		 7810 if (sas_device) {
7811 set_bit(handle, ioc->pd_handles);
7812 if (sas_device->starget && sas_device->starget->hostdata) {
7813 starget = sas_device->starget;
7814 sas_target_priv_data = starget->hostdata;
7815 sas_target_priv_data->flags |=
7816 MPT_TARGET_FLAGS_RAID_COMPONENT;
7817 sas_device->volume_handle = volume_handle;
7818 sas_device->volume_wwid = volume_wwid;
7819 }
7820 }
7821 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7822 if (!sas_device)
7823 return;
7824
7825 /* hiding raid component */
7826 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
c84b06a4 7827
f92363d1
SR		 7828 if (starget)
7829 starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun);
d1cb5e49
SR		 7830
7831 sas_device_put(sas_device);
f92363d1
SR		 7832}
7833
7834/**
7835 * _scsih_sas_pd_delete - delete pd component
7836 * @ioc: per adapter object
7837 * @element: IR config element data
7838 * Context: user.
f92363d1
SR		 7839 */
7840static void
7841_scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc,
7842 Mpi2EventIrConfigElement_t *element)
7843{
7844 u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
7845
7846 _scsih_device_remove_by_handle(ioc, handle);
7847}
7848
7849/**
7850 * _scsih_sas_pd_add - remove pd component
7851 * @ioc: per adapter object
7852 * @element: IR config element data
7853 * Context: user.
f92363d1
SR		 7854 */
7855static void
7856_scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc,
7857 Mpi2EventIrConfigElement_t *element)
7858{
7859 struct _sas_device *sas_device;
f92363d1
SR		 7860 u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
7861 Mpi2ConfigReply_t mpi_reply;
7862 Mpi2SasDevicePage0_t sas_device_pg0;
7863 u32 ioc_status;
7864 u64 sas_address;
7865 u16 parent_handle;
7866
7867 set_bit(handle, ioc->pd_handles);
7868
d1cb5e49 7869 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
f92363d1
SR		 7870 if (sas_device) {
7871 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
d1cb5e49 7872 sas_device_put(sas_device);
f92363d1
SR		 7873 return;
7874 }
7875
7876 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
7877 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
919d8a3f
JP		 7878 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7879 __FILE__, __LINE__, __func__);
f92363d1
SR		 7880 return;
7881 }
7882
7883 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7884 MPI2_IOCSTATUS_MASK;
7885 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 7886 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7887 __FILE__, __LINE__, __func__);
f92363d1
SR		 7888 return;
7889 }
7890
7891 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
7892 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
7893 mpt3sas_transport_update_links(ioc, sas_address, handle,
7894 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
7895
7896 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
7897 _scsih_add_device(ioc, handle, 0, 1);
7898}
7899
f92363d1
SR		 7900/**
7901 * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events
7902 * @ioc: per adapter object
7903 * @event_data: event data payload
7904 * Context: user.
f92363d1
SR		 7905 */
7906static void
7907_scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
7908 Mpi2EventDataIrConfigChangeList_t *event_data)
7909{
7910 Mpi2EventIrConfigElement_t *element;
7911 u8 element_type;
7912 int i;
7913 char *reason_str = NULL, *element_str = NULL;
7914
7915 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
7916
919d8a3f
JP		 7917 ioc_info(ioc, "raid config change: (%s), elements(%d)\n",
7918 le32_to_cpu(event_data->Flags) & MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG ?
7919 "foreign" : "native",
7920 event_data->NumElements);
f92363d1
SR		 7921 for (i = 0; i < event_data->NumElements; i++, element++) {
7922 switch (element->ReasonCode) {
7923 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
7924 reason_str = "add";
7925 break;
7926 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
7927 reason_str = "remove";
7928 break;
7929 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:
7930 reason_str = "no change";
7931 break;
7932 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
7933 reason_str = "hide";
7934 break;
7935 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
7936 reason_str = "unhide";
7937 break;
7938 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
7939 reason_str = "volume_created";
7940 break;
7941 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
7942 reason_str = "volume_deleted";
7943 break;
7944 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
7945 reason_str = "pd_created";
7946 break;
7947 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
7948 reason_str = "pd_deleted";
7949 break;
7950 default:
7951 reason_str = "unknown reason";
7952 break;
7953 }
7954 element_type = le16_to_cpu(element->ElementFlags) &
7955 MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
7956 switch (element_type) {
7957 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:
7958 element_str = "volume";
7959 break;
7960 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:
7961 element_str = "phys disk";
7962 break;
7963 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:
7964 element_str = "hot spare";
7965 break;
7966 default:
7967 element_str = "unknown element";
7968 break;
7969 }
7970 pr_info("\t(%s:%s), vol handle(0x%04x), " \
7971 "pd handle(0x%04x), pd num(0x%02x)\n", element_str,
7972 reason_str, le16_to_cpu(element->VolDevHandle),
7973 le16_to_cpu(element->PhysDiskDevHandle),
7974 element->PhysDiskNum);
7975 }
7976}
f92363d1
SR		 7977
7978/**
7979 * _scsih_sas_ir_config_change_event - handle ir configuration change events
7980 * @ioc: per adapter object
7981 * @fw_event: The fw_event_work object
7982 * Context: user.
f92363d1
SR		 7983 */
7984static void
7985_scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc,
7986 struct fw_event_work *fw_event)
7987{
7988 Mpi2EventIrConfigElement_t *element;
7989 int i;
7990 u8 foreign_config;
35b62362
JL		 7991 Mpi2EventDataIrConfigChangeList_t *event_data =
7992 (Mpi2EventDataIrConfigChangeList_t *)
7993 fw_event->event_data;
f92363d1 7994
7786ab6a
SR		 7995 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
7996 (!ioc->hide_ir_msg))
f92363d1
SR		 7997 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
7998
f92363d1
SR		 7999 foreign_config = (le32_to_cpu(event_data->Flags) &
8000 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
8001
8002 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
c84b06a4
SR		 8003 if (ioc->shost_recovery &&
8004 ioc->hba_mpi_version_belonged != MPI2_VERSION) {
f92363d1
SR		 8005 for (i = 0; i < event_data->NumElements; i++, element++) {
8006 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_HIDE)
8007 _scsih_ir_fastpath(ioc,
8008 le16_to_cpu(element->PhysDiskDevHandle),
8009 element->PhysDiskNum);
8010 }
8011 return;
8012 }
7786ab6a 8013
f92363d1
SR		 8014 for (i = 0; i < event_data->NumElements; i++, element++) {
8015
8016 switch (element->ReasonCode) {
8017 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
8018 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
8019 if (!foreign_config)
8020 _scsih_sas_volume_add(ioc, element);
8021 break;
8022 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
8023 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
8024 if (!foreign_config)
8025 _scsih_sas_volume_delete(ioc,
8026 le16_to_cpu(element->VolDevHandle));
8027 break;
8028 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
7786ab6a
SR		 8029 if (!ioc->is_warpdrive)
8030 _scsih_sas_pd_hide(ioc, element);
f92363d1
SR		 8031 break;
8032 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
7786ab6a
SR		 8033 if (!ioc->is_warpdrive)
8034 _scsih_sas_pd_expose(ioc, element);
f92363d1
SR		 8035 break;
8036 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
7786ab6a
SR		 8037 if (!ioc->is_warpdrive)
8038 _scsih_sas_pd_add(ioc, element);
f92363d1
SR		 8039 break;
8040 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
7786ab6a
SR		 8041 if (!ioc->is_warpdrive)
8042 _scsih_sas_pd_delete(ioc, element);
f92363d1
SR		 8043 break;
8044 }
8045 }
8046}
8047
8048/**
8049 * _scsih_sas_ir_volume_event - IR volume event
8050 * @ioc: per adapter object
8051 * @fw_event: The fw_event_work object
8052 * Context: user.
f92363d1
SR		 8053 */
8054static void
8055_scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc,
8056 struct fw_event_work *fw_event)
8057{
8058 u64 wwid;
8059 unsigned long flags;
8060 struct _raid_device *raid_device;
8061 u16 handle;
8062 u32 state;
8063 int rc;
35b62362
JL		 8064 Mpi2EventDataIrVolume_t *event_data =
8065 (Mpi2EventDataIrVolume_t *) fw_event->event_data;
f92363d1
SR		 8066
8067 if (ioc->shost_recovery)
8068 return;
8069
8070 if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
8071 return;
8072
8073 handle = le16_to_cpu(event_data->VolDevHandle);
8074 state = le32_to_cpu(event_data->NewValue);
7786ab6a 8075 if (!ioc->hide_ir_msg)
919d8a3f
JP		 8076 dewtprintk(ioc,
8077 ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
8078 __func__, handle,
8079 le32_to_cpu(event_data->PreviousValue),
8080 state));
f92363d1
SR		 8081 switch (state) {
8082 case MPI2_RAID_VOL_STATE_MISSING:
8083 case MPI2_RAID_VOL_STATE_FAILED:
8084 _scsih_sas_volume_delete(ioc, handle);
8085 break;
8086
8087 case MPI2_RAID_VOL_STATE_ONLINE:
8088 case MPI2_RAID_VOL_STATE_DEGRADED:
8089 case MPI2_RAID_VOL_STATE_OPTIMAL:
8090
8091 spin_lock_irqsave(&ioc->raid_device_lock, flags);
c84b06a4 8092 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
f92363d1
SR		 8093 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
8094
8095 if (raid_device)
8096 break;
8097
8098 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
8099 if (!wwid) {
919d8a3f
JP		 8100 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8101 __FILE__, __LINE__, __func__);
f92363d1
SR		 8102 break;
8103 }
8104
8105 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
8106 if (!raid_device) {
919d8a3f
JP		 8107 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8108 __FILE__, __LINE__, __func__);
f92363d1
SR		 8109 break;
8110 }
8111
8112 raid_device->id = ioc->sas_id++;
8113 raid_device->channel = RAID_CHANNEL;
8114 raid_device->handle = handle;
8115 raid_device->wwid = wwid;
8116 _scsih_raid_device_add(ioc, raid_device);
8117 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
8118 raid_device->id, 0);
8119 if (rc)
8120 _scsih_raid_device_remove(ioc, raid_device);
8121 break;
8122
8123 case MPI2_RAID_VOL_STATE_INITIALIZING:
8124 default:
8125 break;
8126 }
8127}
8128
8129/**
8130 * _scsih_sas_ir_physical_disk_event - PD event
8131 * @ioc: per adapter object
8132 * @fw_event: The fw_event_work object
8133 * Context: user.
f92363d1
SR		 8134 */
8135static void
8136_scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc,
8137 struct fw_event_work *fw_event)
8138{
8139 u16 handle, parent_handle;
8140 u32 state;
8141 struct _sas_device *sas_device;
f92363d1
SR		 8142 Mpi2ConfigReply_t mpi_reply;
8143 Mpi2SasDevicePage0_t sas_device_pg0;
8144 u32 ioc_status;
35b62362
JL		 8145 Mpi2EventDataIrPhysicalDisk_t *event_data =
8146 (Mpi2EventDataIrPhysicalDisk_t *) fw_event->event_data;
f92363d1
SR		 8147 u64 sas_address;
8148
8149 if (ioc->shost_recovery)
8150 return;
8151
8152 if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
8153 return;
8154
8155 handle = le16_to_cpu(event_data->PhysDiskDevHandle);
8156 state = le32_to_cpu(event_data->NewValue);
8157
7786ab6a 8158 if (!ioc->hide_ir_msg)
919d8a3f
JP		 8159 dewtprintk(ioc,
8160 ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
8161 __func__, handle,
8162 le32_to_cpu(event_data->PreviousValue),
8163 state));
7786ab6a 8164
f92363d1
SR		 8165 switch (state) {
8166 case MPI2_RAID_PD_STATE_ONLINE:
8167 case MPI2_RAID_PD_STATE_DEGRADED:
8168 case MPI2_RAID_PD_STATE_REBUILDING:
8169 case MPI2_RAID_PD_STATE_OPTIMAL:
8170 case MPI2_RAID_PD_STATE_HOT_SPARE:
8171
7786ab6a
SR		 8172 if (!ioc->is_warpdrive)
8173 set_bit(handle, ioc->pd_handles);
f92363d1 8174
d1cb5e49
SR		 8175 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
8176 if (sas_device) {
8177 sas_device_put(sas_device);
f92363d1 8178 return;
d1cb5e49 8179 }
f92363d1
SR		 8180
8181 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
8182 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
8183 handle))) {
919d8a3f
JP		 8184 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8185 __FILE__, __LINE__, __func__);
f92363d1
SR		 8186 return;
8187 }
8188
8189 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8190 MPI2_IOCSTATUS_MASK;
8191 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 8192 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8193 __FILE__, __LINE__, __func__);
f92363d1
SR		 8194 return;
8195 }
8196
8197 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
8198 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
8199 mpt3sas_transport_update_links(ioc, sas_address, handle,
8200 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
8201
8202 _scsih_add_device(ioc, handle, 0, 1);
8203
8204 break;
8205
8206 case MPI2_RAID_PD_STATE_OFFLINE:
8207 case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
8208 case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
8209 default:
8210 break;
8211 }
8212}
8213
f92363d1
SR		 8214/**
8215 * _scsih_sas_ir_operation_status_event_debug - debug for IR op event
8216 * @ioc: per adapter object
8217 * @event_data: event data payload
8218 * Context: user.
f92363d1
SR		 8219 */
8220static void
8221_scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc,
8222 Mpi2EventDataIrOperationStatus_t *event_data)
8223{
8224 char *reason_str = NULL;
8225
8226 switch (event_data->RAIDOperation) {
8227 case MPI2_EVENT_IR_RAIDOP_RESYNC:
8228 reason_str = "resync";
8229 break;
8230 case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:
8231 reason_str = "online capacity expansion";
8232 break;
8233 case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
8234 reason_str = "consistency check";
8235 break;
8236 case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:
8237 reason_str = "background init";
8238 break;
8239 case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:
8240 reason_str = "make data consistent";
8241 break;
8242 }
8243
8244 if (!reason_str)
8245 return;
8246
919d8a3f
JP		 8247 ioc_info(ioc, "raid operational status: (%s)\thandle(0x%04x), percent complete(%d)\n",
8248 reason_str,
8249 le16_to_cpu(event_data->VolDevHandle),
8250 event_data->PercentComplete);
f92363d1 8251}
f92363d1
SR		 8252
8253/**
8254 * _scsih_sas_ir_operation_status_event - handle RAID operation events
8255 * @ioc: per adapter object
8256 * @fw_event: The fw_event_work object
8257 * Context: user.
f92363d1
SR		 8258 */
8259static void
8260_scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc,
8261 struct fw_event_work *fw_event)
8262{
35b62362
JL		 8263 Mpi2EventDataIrOperationStatus_t *event_data =
8264 (Mpi2EventDataIrOperationStatus_t *)
8265 fw_event->event_data;
f92363d1
SR		 8266 static struct _raid_device *raid_device;
8267 unsigned long flags;
8268 u16 handle;
8269
7786ab6a
SR		 8270 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
8271 (!ioc->hide_ir_msg))
f92363d1
SR		 8272 _scsih_sas_ir_operation_status_event_debug(ioc,
8273 event_data);
f92363d1
SR		 8274
8275 /* code added for raid transport support */
8276 if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
8277
8278 spin_lock_irqsave(&ioc->raid_device_lock, flags);
8279 handle = le16_to_cpu(event_data->VolDevHandle);
c84b06a4 8280 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
f92363d1
SR		 8281 if (raid_device)
8282 raid_device->percent_complete =
8283 event_data->PercentComplete;
8284 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
8285 }
8286}
8287
8288/**
8289 * _scsih_prep_device_scan - initialize parameters prior to device scan
8290 * @ioc: per adapter object
8291 *
8292 * Set the deleted flag prior to device scan. If the device is found during
8293 * the scan, then we clear the deleted flag.
8294 */
8295static void
8296_scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc)
8297{
8298 struct MPT3SAS_DEVICE *sas_device_priv_data;
8299 struct scsi_device *sdev;
8300
8301 shost_for_each_device(sdev, ioc->shost) {
8302 sas_device_priv_data = sdev->hostdata;
8303 if (sas_device_priv_data && sas_device_priv_data->sas_target)
8304 sas_device_priv_data->sas_target->deleted = 1;
8305 }
8306}
8307
8308/**
8309 * _scsih_mark_responding_sas_device - mark a sas_devices as responding
8310 * @ioc: per adapter object
e6d45e3e 8311 * @sas_device_pg0: SAS Device page 0
f92363d1
SR		 8312 *
8313 * After host reset, find out whether devices are still responding.
8314 * Used in _scsih_remove_unresponsive_sas_devices.
f92363d1
SR		 8315 */
8316static void
e6d45e3e
SR		 8317_scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc,
8318Mpi2SasDevicePage0_t *sas_device_pg0)
f92363d1
SR		 8319{
8320 struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
8321 struct scsi_target *starget;
aba5a85c 8322 struct _sas_device *sas_device = NULL;
22a923c3 8323 struct _enclosure_node *enclosure_dev = NULL;
f92363d1
SR		 8324 unsigned long flags;
8325
22a923c3
C		 8326 if (sas_device_pg0->EnclosureHandle) {
8327 enclosure_dev =
8328 mpt3sas_scsih_enclosure_find_by_handle(ioc,
8329 le16_to_cpu(sas_device_pg0->EnclosureHandle));
8330 if (enclosure_dev == NULL)
919d8a3f
JP		 8331 ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
8332 sas_device_pg0->EnclosureHandle);
22a923c3 8333 }
f92363d1
SR		 8334 spin_lock_irqsave(&ioc->sas_device_lock, flags);
8335 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
cf6bf971
C		 8336 if ((sas_device->sas_address == le64_to_cpu(
8337 sas_device_pg0->SASAddress)) && (sas_device->slot ==
8338 le16_to_cpu(sas_device_pg0->Slot))) {
f92363d1
SR		 8339 sas_device->responding = 1;
8340 starget = sas_device->starget;
8341 if (starget && starget->hostdata) {
8342 sas_target_priv_data = starget->hostdata;
8343 sas_target_priv_data->tm_busy = 0;
8344 sas_target_priv_data->deleted = 0;
8345 } else
8346 sas_target_priv_data = NULL;
e6d45e3e 8347 if (starget) {
f92363d1 8348 starget_printk(KERN_INFO, starget,
e6d45e3e 8349 "handle(0x%04x), sas_addr(0x%016llx)\n",
cf6bf971 8350 le16_to_cpu(sas_device_pg0->DevHandle),
f92363d1 8351 (unsigned long long)
e6d45e3e
SR		 8352 sas_device->sas_address);
8353
8354 if (sas_device->enclosure_handle != 0)
8355 starget_printk(KERN_INFO, starget,
8356 "enclosure logical id(0x%016llx),"
8357 " slot(%d)\n",
8358 (unsigned long long)
8359 sas_device->enclosure_logical_id,
8360 sas_device->slot);
8361 }
cf6bf971 8362 if (le16_to_cpu(sas_device_pg0->Flags) &
e6d45e3e
SR		 8363 MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
8364 sas_device->enclosure_level =
aa53bb89 8365 sas_device_pg0->EnclosureLevel;
e6d45e3e
SR		 8366 memcpy(&sas_device->connector_name[0],
8367 &sas_device_pg0->ConnectorName[0], 4);
8368 } else {
8369 sas_device->enclosure_level = 0;
8370 sas_device->connector_name[0] = '\0';
8371 }
8372
22a923c3
C		 8373 sas_device->enclosure_handle =
8374 le16_to_cpu(sas_device_pg0->EnclosureHandle);
8375 sas_device->is_chassis_slot_valid = 0;
8376 if (enclosure_dev) {
8377 sas_device->enclosure_logical_id = le64_to_cpu(
8378 enclosure_dev->pg0.EnclosureLogicalID);
8379 if (le16_to_cpu(enclosure_dev->pg0.Flags) &
8380 MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) {
8381 sas_device->is_chassis_slot_valid = 1;
8382 sas_device->chassis_slot =
8383 enclosure_dev->pg0.ChassisSlot;
8384 }
8385 }
75888956 8386
cf6bf971
C		 8387 if (sas_device->handle == le16_to_cpu(
8388 sas_device_pg0->DevHandle))
f92363d1
SR		 8389 goto out;
8390 pr_info("\thandle changed from(0x%04x)!!!\n",
8391 sas_device->handle);
cf6bf971
C		 8392 sas_device->handle = le16_to_cpu(
8393 sas_device_pg0->DevHandle);
f92363d1 8394 if (sas_target_priv_data)
e6d45e3e 8395 sas_target_priv_data->handle =
cf6bf971 8396 le16_to_cpu(sas_device_pg0->DevHandle);
f92363d1
SR		 8397 goto out;
8398 }
8399 }
8400 out:
8401 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8402}
8403
22a923c3
C		 8404/**
8405 * _scsih_create_enclosure_list_after_reset - Free Existing list,
8406 * And create enclosure list by scanning all Enclosure Page(0)s
8407 * @ioc: per adapter object
22a923c3
C		 8408 */
8409static void
8410_scsih_create_enclosure_list_after_reset(struct MPT3SAS_ADAPTER *ioc)
8411{
8412 struct _enclosure_node *enclosure_dev;
8413 Mpi2ConfigReply_t mpi_reply;
8414 u16 enclosure_handle;
8415 int rc;
8416
8417 /* Free existing enclosure list */
8418 mpt3sas_free_enclosure_list(ioc);
8419
8420 /* Re constructing enclosure list after reset*/
8421 enclosure_handle = 0xFFFF;
8422 do {
8423 enclosure_dev =
8424 kzalloc(sizeof(struct _enclosure_node), GFP_KERNEL);
8425 if (!enclosure_dev) {
919d8a3f 8426 ioc_err(ioc, "failure at %s:%d/%s()!\n",
22a923c3
C		 8427 __FILE__, __LINE__, __func__);
8428 return;
8429 }
8430 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
8431 &enclosure_dev->pg0,
8432 MPI2_SAS_ENCLOS_PGAD_FORM_GET_NEXT_HANDLE,
8433 enclosure_handle);
8434
8435 if (rc || (le16_to_cpu(mpi_reply.IOCStatus) &
8436 MPI2_IOCSTATUS_MASK)) {
8437 kfree(enclosure_dev);
8438 return;
8439 }
8440 list_add_tail(&enclosure_dev->list,
8441 &ioc->enclosure_list);
8442 enclosure_handle =
8443 le16_to_cpu(enclosure_dev->pg0.EnclosureHandle);
8444 } while (1);
8445}
8446
f92363d1
SR		 8447/**
8448 * _scsih_search_responding_sas_devices -
8449 * @ioc: per adapter object
8450 *
8451 * After host reset, find out whether devices are still responding.
8452 * If not remove.
f92363d1
SR		 8453 */
8454static void
8455_scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
8456{
8457 Mpi2SasDevicePage0_t sas_device_pg0;
8458 Mpi2ConfigReply_t mpi_reply;
8459 u16 ioc_status;
8460 u16 handle;
8461 u32 device_info;
8462
919d8a3f 8463 ioc_info(ioc, "search for end-devices: start\n");
f92363d1
SR		 8464
8465 if (list_empty(&ioc->sas_device_list))
8466 goto out;
8467
8468 handle = 0xFFFF;
8469 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
8470 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
8471 handle))) {
8472 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8473 MPI2_IOCSTATUS_MASK;
14be49ac 8474 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
f92363d1 8475 break;
cf6bf971 8476 handle = le16_to_cpu(sas_device_pg0.DevHandle);
f92363d1
SR		 8477 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
8478 if (!(_scsih_is_end_device(device_info)))
8479 continue;
e6d45e3e 8480 _scsih_mark_responding_sas_device(ioc, &sas_device_pg0);
f92363d1
SR		 8481 }
8482
8483 out:
919d8a3f 8484 ioc_info(ioc, "search for end-devices: complete\n");
f92363d1
SR		 8485}
8486
ec051e5a
SPS		 8487/**
8488 * _scsih_mark_responding_pcie_device - mark a pcie_device as responding
8489 * @ioc: per adapter object
8490 * @pcie_device_pg0: PCIe Device page 0
8491 *
8492 * After host reset, find out whether devices are still responding.
8493 * Used in _scsih_remove_unresponding_devices.
ec051e5a
SPS		 8494 */
8495static void
8496_scsih_mark_responding_pcie_device(struct MPT3SAS_ADAPTER *ioc,
8497 Mpi26PCIeDevicePage0_t *pcie_device_pg0)
8498{
8499 struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
8500 struct scsi_target *starget;
8501 struct _pcie_device *pcie_device;
8502 unsigned long flags;
8503
8504 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
8505 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) {
cf6bf971
C		 8506 if ((pcie_device->wwid == le64_to_cpu(pcie_device_pg0->WWID))
8507 && (pcie_device->slot == le16_to_cpu(
8508 pcie_device_pg0->Slot))) {
ec051e5a
SPS		 8509 pcie_device->responding = 1;
8510 starget = pcie_device->starget;
8511 if (starget && starget->hostdata) {
8512 sas_target_priv_data = starget->hostdata;
8513 sas_target_priv_data->tm_busy = 0;
8514 sas_target_priv_data->deleted = 0;
8515 } else
8516 sas_target_priv_data = NULL;
8517 if (starget) {
8518 starget_printk(KERN_INFO, starget,
8519 "handle(0x%04x), wwid(0x%016llx) ",
8520 pcie_device->handle,
8521 (unsigned long long)pcie_device->wwid);
8522 if (pcie_device->enclosure_handle != 0)
8523 starget_printk(KERN_INFO, starget,
8524 "enclosure logical id(0x%016llx), "
8525 "slot(%d)\n",
8526 (unsigned long long)
8527 pcie_device->enclosure_logical_id,
8528 pcie_device->slot);
8529 }
8530
8531 if (((le32_to_cpu(pcie_device_pg0->Flags)) &
8532 MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) &&
8533 (ioc->hba_mpi_version_belonged != MPI2_VERSION)) {
8534 pcie_device->enclosure_level =
8535 pcie_device_pg0->EnclosureLevel;
8536 memcpy(&pcie_device->connector_name[0],
8537 &pcie_device_pg0->ConnectorName[0], 4);
8538 } else {
8539 pcie_device->enclosure_level = 0;
8540 pcie_device->connector_name[0] = '\0';
8541 }
8542
cf6bf971
C		 8543 if (pcie_device->handle == le16_to_cpu(
8544 pcie_device_pg0->DevHandle))
ec051e5a 8545 goto out;
268eb498 8546 pr_info("\thandle changed from(0x%04x)!!!\n",
ec051e5a 8547 pcie_device->handle);
cf6bf971
C		 8548 pcie_device->handle = le16_to_cpu(
8549 pcie_device_pg0->DevHandle);
ec051e5a
SPS		 8550 if (sas_target_priv_data)
8551 sas_target_priv_data->handle =
cf6bf971 8552 le16_to_cpu(pcie_device_pg0->DevHandle);
ec051e5a
SPS		 8553 goto out;
8554 }
8555 }
8556
8557 out:
8558 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8559}
8560
8561/**
8562 * _scsih_search_responding_pcie_devices -
8563 * @ioc: per adapter object
8564 *
8565 * After host reset, find out whether devices are still responding.
8566 * If not remove.
ec051e5a
SPS		 8567 */
8568static void
8569_scsih_search_responding_pcie_devices(struct MPT3SAS_ADAPTER *ioc)
8570{
8571 Mpi26PCIeDevicePage0_t pcie_device_pg0;
8572 Mpi2ConfigReply_t mpi_reply;
8573 u16 ioc_status;
8574 u16 handle;
8575 u32 device_info;
8576
919d8a3f 8577 ioc_info(ioc, "search for end-devices: start\n");
ec051e5a
SPS		 8578
8579 if (list_empty(&ioc->pcie_device_list))
8580 goto out;
8581
8582 handle = 0xFFFF;
8583 while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
8584 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
8585 handle))) {
8586 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8587 MPI2_IOCSTATUS_MASK;
8588 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 8589 ioc_info(ioc, "\tbreak from %s: ioc_status(0x%04x), loginfo(0x%08x)\n",
8590 __func__, ioc_status,
8591 le32_to_cpu(mpi_reply.IOCLogInfo));
ec051e5a
SPS		 8592 break;
8593 }
8594 handle = le16_to_cpu(pcie_device_pg0.DevHandle);
8595 device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo);
8596 if (!(_scsih_is_nvme_device(device_info)))
8597 continue;
ec051e5a
SPS		 8598 _scsih_mark_responding_pcie_device(ioc, &pcie_device_pg0);
8599 }
8600out:
919d8a3f 8601 ioc_info(ioc, "search for PCIe end-devices: complete\n");
ec051e5a
SPS		 8602}
8603
f92363d1
SR		 8604/**
8605 * _scsih_mark_responding_raid_device - mark a raid_device as responding
8606 * @ioc: per adapter object
8607 * @wwid: world wide identifier for raid volume
8608 * @handle: device handle
8609 *
8610 * After host reset, find out whether devices are still responding.
8611 * Used in _scsih_remove_unresponsive_raid_devices.
f92363d1
SR		 8612 */
8613static void
8614_scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
8615 u16 handle)
8616{
7786ab6a 8617 struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
f92363d1
SR		 8618 struct scsi_target *starget;
8619 struct _raid_device *raid_device;
8620 unsigned long flags;
8621
8622 spin_lock_irqsave(&ioc->raid_device_lock, flags);
8623 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
8624 if (raid_device->wwid == wwid && raid_device->starget) {
8625 starget = raid_device->starget;
8626 if (starget && starget->hostdata) {
8627 sas_target_priv_data = starget->hostdata;
8628 sas_target_priv_data->deleted = 0;
8629 } else
8630 sas_target_priv_data = NULL;
8631 raid_device->responding = 1;
8632 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
8633 starget_printk(KERN_INFO, raid_device->starget,
8634 "handle(0x%04x), wwid(0x%016llx)\n", handle,
8635 (unsigned long long)raid_device->wwid);
7786ab6a 8636
7786ab6a
SR		 8637 /*
8638 * WARPDRIVE: The handles of the PDs might have changed
8639 * across the host reset so re-initialize the
8640 * required data for Direct IO
8641 */
c84b06a4 8642 mpt3sas_init_warpdrive_properties(ioc, raid_device);
f92363d1
SR		 8643 spin_lock_irqsave(&ioc->raid_device_lock, flags);
8644 if (raid_device->handle == handle) {
8645 spin_unlock_irqrestore(&ioc->raid_device_lock,
8646 flags);
8647 return;
8648 }
8649 pr_info("\thandle changed from(0x%04x)!!!\n",
8650 raid_device->handle);
8651 raid_device->handle = handle;
8652 if (sas_target_priv_data)
8653 sas_target_priv_data->handle = handle;
8654 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
8655 return;
8656 }
8657 }
8658 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
8659}
8660
8661/**
8662 * _scsih_search_responding_raid_devices -
8663 * @ioc: per adapter object
8664 *
8665 * After host reset, find out whether devices are still responding.
8666 * If not remove.
f92363d1
SR		 8667 */
8668static void
8669_scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc)
8670{
8671 Mpi2RaidVolPage1_t volume_pg1;
8672 Mpi2RaidVolPage0_t volume_pg0;
8673 Mpi2RaidPhysDiskPage0_t pd_pg0;
8674 Mpi2ConfigReply_t mpi_reply;
8675 u16 ioc_status;
8676 u16 handle;
8677 u8 phys_disk_num;
8678
8679 if (!ioc->ir_firmware)
8680 return;
8681
919d8a3f 8682 ioc_info(ioc, "search for raid volumes: start\n");
f92363d1
SR		 8683
8684 if (list_empty(&ioc->raid_device_list))
8685 goto out;
8686
8687 handle = 0xFFFF;
8688 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
8689 &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
8690 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8691 MPI2_IOCSTATUS_MASK;
14be49ac 8692 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
f92363d1
SR		 8693 break;
8694 handle = le16_to_cpu(volume_pg1.DevHandle);
8695
8696 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
8697 &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
8698 sizeof(Mpi2RaidVolPage0_t)))
8699 continue;
8700
8701 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
8702 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
8703 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED)
8704 _scsih_mark_responding_raid_device(ioc,
8705 le64_to_cpu(volume_pg1.WWID), handle);
8706 }
8707
8708 /* refresh the pd_handles */
7786ab6a 8709 if (!ioc->is_warpdrive) {
f92363d1
SR		 8710 phys_disk_num = 0xFF;
8711 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
8712 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
8713 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
8714 phys_disk_num))) {
8715 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8716 MPI2_IOCSTATUS_MASK;
14be49ac 8717 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
f92363d1
SR		 8718 break;
8719 phys_disk_num = pd_pg0.PhysDiskNum;
8720 handle = le16_to_cpu(pd_pg0.DevHandle);
8721 set_bit(handle, ioc->pd_handles);
8722 }
7786ab6a 8723 }
f92363d1 8724 out:
919d8a3f 8725 ioc_info(ioc, "search for responding raid volumes: complete\n");
f92363d1
SR		 8726}
8727
8728/**
8729 * _scsih_mark_responding_expander - mark a expander as responding
8730 * @ioc: per adapter object
aba5a85c 8731 * @expander_pg0:SAS Expander Config Page0
f92363d1
SR		 8732 *
8733 * After host reset, find out whether devices are still responding.
8734 * Used in _scsih_remove_unresponsive_expanders.
f92363d1
SR		 8735 */
8736static void
aba5a85c
SR		 8737_scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc,
8738 Mpi2ExpanderPage0_t *expander_pg0)
f92363d1 8739{
aba5a85c 8740 struct _sas_node *sas_expander = NULL;
f92363d1 8741 unsigned long flags;
22a923c3
C		 8742 int i;
8743 struct _enclosure_node *enclosure_dev = NULL;
aba5a85c 8744 u16 handle = le16_to_cpu(expander_pg0->DevHandle);
22a923c3 8745 u16 enclosure_handle = le16_to_cpu(expander_pg0->EnclosureHandle);
aba5a85c
SR		 8746 u64 sas_address = le64_to_cpu(expander_pg0->SASAddress);
8747
22a923c3
C		 8748 if (enclosure_handle)
8749 enclosure_dev =
8750 mpt3sas_scsih_enclosure_find_by_handle(ioc,
8751 enclosure_handle);
f92363d1
SR		 8752
8753 spin_lock_irqsave(&ioc->sas_node_lock, flags);
8754 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
8755 if (sas_expander->sas_address != sas_address)
8756 continue;
8757 sas_expander->responding = 1;
aba5a85c 8758
22a923c3 8759 if (enclosure_dev) {
aba5a85c 8760 sas_expander->enclosure_logical_id =
22a923c3
C		 8761 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID);
8762 sas_expander->enclosure_handle =
8763 le16_to_cpu(expander_pg0->EnclosureHandle);
8764 }
aba5a85c 8765
f92363d1
SR		 8766 if (sas_expander->handle == handle)
8767 goto out;
8768 pr_info("\texpander(0x%016llx): handle changed" \
8769 " from(0x%04x) to (0x%04x)!!!\n",
8770 (unsigned long long)sas_expander->sas_address,
8771 sas_expander->handle, handle);
8772 sas_expander->handle = handle;
8773 for (i = 0 ; i < sas_expander->num_phys ; i++)
8774 sas_expander->phy[i].handle = handle;
8775 goto out;
8776 }
8777 out:
8778 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
8779}
8780
8781/**
8782 * _scsih_search_responding_expanders -
8783 * @ioc: per adapter object
8784 *
8785 * After host reset, find out whether devices are still responding.
8786 * If not remove.
f92363d1
SR		 8787 */
8788static void
8789_scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc)
8790{
8791 Mpi2ExpanderPage0_t expander_pg0;
8792 Mpi2ConfigReply_t mpi_reply;
8793 u16 ioc_status;
8794 u64 sas_address;
8795 u16 handle;
8796
919d8a3f 8797 ioc_info(ioc, "search for expanders: start\n");
f92363d1
SR		 8798
8799 if (list_empty(&ioc->sas_expander_list))
8800 goto out;
8801
8802 handle = 0xFFFF;
8803 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
8804 MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
8805
8806 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8807 MPI2_IOCSTATUS_MASK;
14be49ac 8808 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
f92363d1
SR		 8809 break;
8810
8811 handle = le16_to_cpu(expander_pg0.DevHandle);
8812 sas_address = le64_to_cpu(expander_pg0.SASAddress);
8813 pr_info("\texpander present: handle(0x%04x), sas_addr(0x%016llx)\n",
8814 handle,
8815 (unsigned long long)sas_address);
aba5a85c 8816 _scsih_mark_responding_expander(ioc, &expander_pg0);
f92363d1
SR		 8817 }
8818
8819 out:
919d8a3f 8820 ioc_info(ioc, "search for expanders: complete\n");
f92363d1
SR		 8821}
8822
8823/**
3075ac49 8824 * _scsih_remove_unresponding_devices - removing unresponding devices
f92363d1 8825 * @ioc: per adapter object
f92363d1
SR		 8826 */
8827static void
3075ac49 8828_scsih_remove_unresponding_devices(struct MPT3SAS_ADAPTER *ioc)
f92363d1
SR		 8829{
8830 struct _sas_device *sas_device, *sas_device_next;
8831 struct _sas_node *sas_expander, *sas_expander_next;
8832 struct _raid_device *raid_device, *raid_device_next;
3075ac49 8833 struct _pcie_device *pcie_device, *pcie_device_next;
f92363d1
SR		 8834 struct list_head tmp_list;
8835 unsigned long flags;
d1cb5e49 8836 LIST_HEAD(head);
f92363d1 8837
919d8a3f 8838 ioc_info(ioc, "removing unresponding devices: start\n");
f92363d1
SR		 8839
8840 /* removing unresponding end devices */
919d8a3f 8841 ioc_info(ioc, "removing unresponding devices: end-devices\n");
d1cb5e49
SR		 8842 /*
8843 * Iterate, pulling off devices marked as non-responding. We become the
8844 * owner for the reference the list had on any object we prune.
8845 */
8846 spin_lock_irqsave(&ioc->sas_device_lock, flags);
f92363d1
SR		 8847 list_for_each_entry_safe(sas_device, sas_device_next,
8848 &ioc->sas_device_list, list) {
8849 if (!sas_device->responding)
d1cb5e49 8850 list_move_tail(&sas_device->list, &head);
f92363d1
SR		 8851 else
8852 sas_device->responding = 0;
8853 }
d1cb5e49
SR		 8854 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8855
8856 /*
8857 * Now, uninitialize and remove the unresponding devices we pruned.
8858 */
8859 list_for_each_entry_safe(sas_device, sas_device_next, &head, list) {
8860 _scsih_remove_device(ioc, sas_device);
8861 list_del_init(&sas_device->list);
8862 sas_device_put(sas_device);
8863 }
f92363d1 8864
919d8a3f 8865 ioc_info(ioc, "Removing unresponding devices: pcie end-devices\n");
3075ac49
SPS		 8866 INIT_LIST_HEAD(&head);
8867 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
8868 list_for_each_entry_safe(pcie_device, pcie_device_next,
8869 &ioc->pcie_device_list, list) {
8870 if (!pcie_device->responding)
8871 list_move_tail(&pcie_device->list, &head);
8872 else
8873 pcie_device->responding = 0;
8874 }
8875 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8876
8877 list_for_each_entry_safe(pcie_device, pcie_device_next, &head, list) {
8878 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
8879 list_del_init(&pcie_device->list);
8880 pcie_device_put(pcie_device);
8881 }
8882
f92363d1
SR		 8883 /* removing unresponding volumes */
8884 if (ioc->ir_firmware) {
919d8a3f 8885 ioc_info(ioc, "removing unresponding devices: volumes\n");
f92363d1
SR		 8886 list_for_each_entry_safe(raid_device, raid_device_next,
8887 &ioc->raid_device_list, list) {
8888 if (!raid_device->responding)
8889 _scsih_sas_volume_delete(ioc,
8890 raid_device->handle);
8891 else
8892 raid_device->responding = 0;
8893 }
8894 }
8895
8896 /* removing unresponding expanders */
919d8a3f 8897 ioc_info(ioc, "removing unresponding devices: expanders\n");
f92363d1
SR		 8898 spin_lock_irqsave(&ioc->sas_node_lock, flags);
8899 INIT_LIST_HEAD(&tmp_list);
8900 list_for_each_entry_safe(sas_expander, sas_expander_next,
8901 &ioc->sas_expander_list, list) {
8902 if (!sas_expander->responding)
8903 list_move_tail(&sas_expander->list, &tmp_list);
8904 else
8905 sas_expander->responding = 0;
8906 }
8907 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
8908 list_for_each_entry_safe(sas_expander, sas_expander_next, &tmp_list,
8909 list) {
f92363d1
SR		 8910 _scsih_expander_node_remove(ioc, sas_expander);
8911 }
8912
919d8a3f 8913 ioc_info(ioc, "removing unresponding devices: complete\n");
f92363d1
SR		 8914
8915 /* unblock devices */
8916 _scsih_ublock_io_all_device(ioc);
8917}
8918
8919static void
8920_scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc,
8921 struct _sas_node *sas_expander, u16 handle)
8922{
8923 Mpi2ExpanderPage1_t expander_pg1;
8924 Mpi2ConfigReply_t mpi_reply;
8925 int i;
8926
8927 for (i = 0 ; i < sas_expander->num_phys ; i++) {
8928 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
8929 &expander_pg1, i, handle))) {
919d8a3f
JP		 8930 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8931 __FILE__, __LINE__, __func__);
f92363d1
SR		 8932 return;
8933 }
8934
8935 mpt3sas_transport_update_links(ioc, sas_expander->sas_address,
8936 le16_to_cpu(expander_pg1.AttachedDevHandle), i,
8937 expander_pg1.NegotiatedLinkRate >> 4);
8938 }
8939}
8940
8941/**
8942 * _scsih_scan_for_devices_after_reset - scan for devices after host reset
8943 * @ioc: per adapter object
f92363d1
SR		 8944 */
8945static void
8946_scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc)
8947{
8948 Mpi2ExpanderPage0_t expander_pg0;
8949 Mpi2SasDevicePage0_t sas_device_pg0;
ec051e5a 8950 Mpi26PCIeDevicePage0_t pcie_device_pg0;
f92363d1
SR		 8951 Mpi2RaidVolPage1_t volume_pg1;
8952 Mpi2RaidVolPage0_t volume_pg0;
8953 Mpi2RaidPhysDiskPage0_t pd_pg0;
8954 Mpi2EventIrConfigElement_t element;
8955 Mpi2ConfigReply_t mpi_reply;
8956 u8 phys_disk_num;
8957 u16 ioc_status;
8958 u16 handle, parent_handle;
8959 u64 sas_address;
8960 struct _sas_device *sas_device;
ec051e5a 8961 struct _pcie_device *pcie_device;
f92363d1
SR		 8962 struct _sas_node *expander_device;
8963 static struct _raid_device *raid_device;
8964 u8 retry_count;
8965 unsigned long flags;
8966
919d8a3f 8967 ioc_info(ioc, "scan devices: start\n");
f92363d1
SR		 8968
8969 _scsih_sas_host_refresh(ioc);
8970
919d8a3f 8971 ioc_info(ioc, "\tscan devices: expanders start\n");
f92363d1
SR		 8972
8973 /* expanders */
8974 handle = 0xFFFF;
8975 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
8976 MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
8977 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8978 MPI2_IOCSTATUS_MASK;
f92363d1 8979 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 8980 ioc_info(ioc, "\tbreak from expander scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
8981 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
f92363d1
SR		 8982 break;
8983 }
8984 handle = le16_to_cpu(expander_pg0.DevHandle);
8985 spin_lock_irqsave(&ioc->sas_node_lock, flags);
8986 expander_device = mpt3sas_scsih_expander_find_by_sas_address(
8987 ioc, le64_to_cpu(expander_pg0.SASAddress));
8988 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
8989 if (expander_device)
8990 _scsih_refresh_expander_links(ioc, expander_device,
8991 handle);
8992 else {
919d8a3f
JP		 8993 ioc_info(ioc, "\tBEFORE adding expander: handle (0x%04x), sas_addr(0x%016llx)\n",
8994 handle,
8995 (u64)le64_to_cpu(expander_pg0.SASAddress));
f92363d1 8996 _scsih_expander_add(ioc, handle);
919d8a3f
JP		 8997 ioc_info(ioc, "\tAFTER adding expander: handle (0x%04x), sas_addr(0x%016llx)\n",
8998 handle,
8999 (u64)le64_to_cpu(expander_pg0.SASAddress));
f92363d1
SR		 9000 }
9001 }
9002
919d8a3f 9003 ioc_info(ioc, "\tscan devices: expanders complete\n");
f92363d1
SR		 9004
9005 if (!ioc->ir_firmware)
9006 goto skip_to_sas;
9007
919d8a3f 9008 ioc_info(ioc, "\tscan devices: phys disk start\n");
f92363d1
SR		 9009
9010 /* phys disk */
9011 phys_disk_num = 0xFF;
9012 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
9013 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
9014 phys_disk_num))) {
9015 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9016 MPI2_IOCSTATUS_MASK;
f92363d1 9017 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 9018 ioc_info(ioc, "\tbreak from phys disk scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9019 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
f92363d1
SR		 9020 break;
9021 }
9022 phys_disk_num = pd_pg0.PhysDiskNum;
9023 handle = le16_to_cpu(pd_pg0.DevHandle);
d1cb5e49
SR		 9024 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
9025 if (sas_device) {
9026 sas_device_put(sas_device);
f92363d1 9027 continue;
d1cb5e49 9028 }
f92363d1
SR		 9029 if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
9030 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
9031 handle) != 0)
9032 continue;
9033 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9034 MPI2_IOCSTATUS_MASK;
9035 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 9036 ioc_info(ioc, "\tbreak from phys disk scan ioc_status(0x%04x), loginfo(0x%08x)\n",
9037 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
f92363d1
SR		 9038 break;
9039 }
9040 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
9041 if (!_scsih_get_sas_address(ioc, parent_handle,
9042 &sas_address)) {
919d8a3f
JP		 9043 ioc_info(ioc, "\tBEFORE adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n",
9044 handle,
9045 (u64)le64_to_cpu(sas_device_pg0.SASAddress));
f92363d1
SR		 9046 mpt3sas_transport_update_links(ioc, sas_address,
9047 handle, sas_device_pg0.PhyNum,
9048 MPI2_SAS_NEG_LINK_RATE_1_5);
9049 set_bit(handle, ioc->pd_handles);
9050 retry_count = 0;
9051 /* This will retry adding the end device.
9052 * _scsih_add_device() will decide on retries and
9053 * return "1" when it should be retried
9054 */
9055 while (_scsih_add_device(ioc, handle, retry_count++,
9056 1)) {
9057 ssleep(1);
9058 }
919d8a3f
JP		 9059 ioc_info(ioc, "\tAFTER adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n",
9060 handle,
9061 (u64)le64_to_cpu(sas_device_pg0.SASAddress));
f92363d1
SR		 9062 }
9063 }
9064
919d8a3f 9065 ioc_info(ioc, "\tscan devices: phys disk complete\n");
f92363d1 9066
919d8a3f 9067 ioc_info(ioc, "\tscan devices: volumes start\n");
f92363d1
SR		 9068
9069 /* volumes */
9070 handle = 0xFFFF;
9071 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
9072 &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
9073 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9074 MPI2_IOCSTATUS_MASK;
f92363d1 9075 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 9076 ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9077 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
f92363d1
SR		 9078 break;
9079 }
9080 handle = le16_to_cpu(volume_pg1.DevHandle);
9081 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9082 raid_device = _scsih_raid_device_find_by_wwid(ioc,
9083 le64_to_cpu(volume_pg1.WWID));
9084 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9085 if (raid_device)
9086 continue;
9087 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
9088 &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
9089 sizeof(Mpi2RaidVolPage0_t)))
9090 continue;
9091 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9092 MPI2_IOCSTATUS_MASK;
9093 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 9094 ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9095 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
f92363d1
SR		 9096 break;
9097 }
9098 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
9099 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
9100 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) {
9101 memset(&element, 0, sizeof(Mpi2EventIrConfigElement_t));
9102 element.ReasonCode = MPI2_EVENT_IR_CHANGE_RC_ADDED;
9103 element.VolDevHandle = volume_pg1.DevHandle;
919d8a3f
JP		 9104 ioc_info(ioc, "\tBEFORE adding volume: handle (0x%04x)\n",
9105 volume_pg1.DevHandle);
f92363d1 9106 _scsih_sas_volume_add(ioc, &element);
919d8a3f
JP		 9107 ioc_info(ioc, "\tAFTER adding volume: handle (0x%04x)\n",
9108 volume_pg1.DevHandle);
f92363d1
SR		 9109 }
9110 }
9111
919d8a3f 9112 ioc_info(ioc, "\tscan devices: volumes complete\n");
f92363d1
SR		 9113
9114 skip_to_sas:
9115
919d8a3f 9116 ioc_info(ioc, "\tscan devices: end devices start\n");
f92363d1
SR		 9117
9118 /* sas devices */
9119 handle = 0xFFFF;
9120 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
9121 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
9122 handle))) {
9123 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9124 MPI2_IOCSTATUS_MASK;
f92363d1 9125 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 9126 ioc_info(ioc, "\tbreak from end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9127 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
f92363d1
SR		 9128 break;
9129 }
9130 handle = le16_to_cpu(sas_device_pg0.DevHandle);
9131 if (!(_scsih_is_end_device(
9132 le32_to_cpu(sas_device_pg0.DeviceInfo))))
9133 continue;
d1cb5e49 9134 sas_device = mpt3sas_get_sdev_by_addr(ioc,
f92363d1 9135 le64_to_cpu(sas_device_pg0.SASAddress));
d1cb5e49
SR		 9136 if (sas_device) {
9137 sas_device_put(sas_device);
f92363d1 9138 continue;
d1cb5e49 9139 }
f92363d1
SR		 9140 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
9141 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) {
919d8a3f
JP		 9142 ioc_info(ioc, "\tBEFORE adding end device: handle (0x%04x), sas_addr(0x%016llx)\n",
9143 handle,
9144 (u64)le64_to_cpu(sas_device_pg0.SASAddress));
f92363d1
SR		 9145 mpt3sas_transport_update_links(ioc, sas_address, handle,
9146 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
9147 retry_count = 0;
9148 /* This will retry adding the end device.
9149 * _scsih_add_device() will decide on retries and
9150 * return "1" when it should be retried
9151 */
9152 while (_scsih_add_device(ioc, handle, retry_count++,
9153 0)) {
9154 ssleep(1);
9155 }
919d8a3f
JP		 9156 ioc_info(ioc, "\tAFTER adding end device: handle (0x%04x), sas_addr(0x%016llx)\n",
9157 handle,
9158 (u64)le64_to_cpu(sas_device_pg0.SASAddress));
f92363d1
SR		 9159 }
9160 }
919d8a3f
JP		 9161 ioc_info(ioc, "\tscan devices: end devices complete\n");
9162 ioc_info(ioc, "\tscan devices: pcie end devices start\n");
ec051e5a
SPS		 9163
9164 /* pcie devices */
9165 handle = 0xFFFF;
9166 while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
9167 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
9168 handle))) {
9169 ioc_status = le16_to_cpu(mpi_reply.IOCStatus)
9170 & MPI2_IOCSTATUS_MASK;
9171 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
919d8a3f
JP		 9172 ioc_info(ioc, "\tbreak from pcie end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9173 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
ec051e5a
SPS		 9174 break;
9175 }
9176 handle = le16_to_cpu(pcie_device_pg0.DevHandle);
9177 if (!(_scsih_is_nvme_device(
9178 le32_to_cpu(pcie_device_pg0.DeviceInfo))))
9179 continue;
9180 pcie_device = mpt3sas_get_pdev_by_wwid(ioc,
9181 le64_to_cpu(pcie_device_pg0.WWID));
9182 if (pcie_device) {
9183 pcie_device_put(pcie_device);
9184 continue;
9185 }
9186 retry_count = 0;
9187 parent_handle = le16_to_cpu(pcie_device_pg0.ParentDevHandle);
9188 _scsih_pcie_add_device(ioc, handle);
f92363d1 9189
919d8a3f
JP		 9190 ioc_info(ioc, "\tAFTER adding pcie end device: handle (0x%04x), wwid(0x%016llx)\n",
9191 handle, (u64)le64_to_cpu(pcie_device_pg0.WWID));
ec051e5a 9192 }
919d8a3f
JP		 9193 ioc_info(ioc, "\tpcie devices: pcie end devices complete\n");
9194 ioc_info(ioc, "scan devices: complete\n");
f92363d1 9195}
c7a35705 9196
f92363d1
SR		 9197/**
9198 * mpt3sas_scsih_reset_handler - reset callback handler (for scsih)
9199 * @ioc: per adapter object
f92363d1
SR		 9200 *
9201 * The handler for doing any required cleanup or initialization.
c7a35705
BVA		 9202 */
9203void mpt3sas_scsih_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc)
9204{
919d8a3f 9205 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__));
c7a35705
BVA		 9206}
9207
9208/**
9209 * mpt3sas_scsih_after_reset_handler - reset callback handler (for scsih)
9210 * @ioc: per adapter object
f92363d1 9211 *
c7a35705 9212 * The handler for doing any required cleanup or initialization.
f92363d1
SR		 9213 */
9214void
c7a35705 9215mpt3sas_scsih_after_reset_handler(struct MPT3SAS_ADAPTER *ioc)
f92363d1 9216{
919d8a3f 9217 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_AFTER_RESET\n", __func__));
c7a35705
BVA		 9218 if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) {
9219 ioc->scsih_cmds.status |= MPT3_CMD_RESET;
9220 mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
9221 complete(&ioc->scsih_cmds.done);
9222 }
9223 if (ioc->tm_cmds.status & MPT3_CMD_PENDING) {
9224 ioc->tm_cmds.status |= MPT3_CMD_RESET;
9225 mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid);
9226 complete(&ioc->tm_cmds.done);
9227 }
f92363d1 9228
c7a35705
BVA		 9229 memset(ioc->pend_os_device_add, 0, ioc->pend_os_device_add_sz);
9230 memset(ioc->device_remove_in_progress, 0,
9231 ioc->device_remove_in_progress_sz);
9232 _scsih_fw_event_cleanup_queue(ioc);
9233 _scsih_flush_running_cmds(ioc);
9234}
9235
9236/**
9237 * mpt3sas_scsih_reset_handler - reset callback handler (for scsih)
9238 * @ioc: per adapter object
9239 *
9240 * The handler for doing any required cleanup or initialization.
9241 */
9242void
9243mpt3sas_scsih_reset_done_handler(struct MPT3SAS_ADAPTER *ioc)
9244{
919d8a3f 9245 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__));
c7a35705
BVA		 9246 if ((!ioc->is_driver_loading) && !(disable_discovery > 0 &&
9247 !ioc->sas_hba.num_phys)) {
9248 _scsih_prep_device_scan(ioc);
9249 _scsih_create_enclosure_list_after_reset(ioc);
9250 _scsih_search_responding_sas_devices(ioc);
9251 _scsih_search_responding_pcie_devices(ioc);
9252 _scsih_search_responding_raid_devices(ioc);
9253 _scsih_search_responding_expanders(ioc);
9254 _scsih_error_recovery_delete_devices(ioc);
f92363d1
SR		 9255 }
9256}
9257
9258/**
9259 * _mpt3sas_fw_work - delayed task for processing firmware events
9260 * @ioc: per adapter object
9261 * @fw_event: The fw_event_work object
9262 * Context: user.
f92363d1
SR		 9263 */
9264static void
9265_mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
9266{
146b16c8
SR		 9267 _scsih_fw_event_del_from_list(ioc, fw_event);
9268
f92363d1 9269 /* the queue is being flushed so ignore this event */
146b16c8
SR		 9270 if (ioc->remove_host || ioc->pci_error_recovery) {
9271 fw_event_work_put(fw_event);
f92363d1
SR		 9272 return;
9273 }
9274
9275 switch (fw_event->event) {
9276 case MPT3SAS_PROCESS_TRIGGER_DIAG:
35b62362
JL		 9277 mpt3sas_process_trigger_data(ioc,
9278 (struct SL_WH_TRIGGERS_EVENT_DATA_T *)
9279 fw_event->event_data);
f92363d1
SR		 9280 break;
9281 case MPT3SAS_REMOVE_UNRESPONDING_DEVICES:
146b16c8
SR		 9282 while (scsi_host_in_recovery(ioc->shost) ||
9283 ioc->shost_recovery) {
9284 /*
9285 * If we're unloading, bail. Otherwise, this can become
9286 * an infinite loop.
9287 */
9288 if (ioc->remove_host)
9289 goto out;
f92363d1 9290 ssleep(1);
146b16c8 9291 }
3075ac49 9292 _scsih_remove_unresponding_devices(ioc);
f92363d1
SR		 9293 _scsih_scan_for_devices_after_reset(ioc);
9294 break;
9295 case MPT3SAS_PORT_ENABLE_COMPLETE:
9296 ioc->start_scan = 0;
199fd79a 9297 if (missing_delay[0] != -1 && missing_delay[1] != -1)
f92363d1
SR		 9298 mpt3sas_base_update_missing_delay(ioc, missing_delay[0],
9299 missing_delay[1]);
919d8a3f
JP		 9300 dewtprintk(ioc,
9301 ioc_info(ioc, "port enable: complete from worker thread\n"));
f92363d1 9302 break;
0f624c39
SR		 9303 case MPT3SAS_TURN_ON_PFA_LED:
9304 _scsih_turn_on_pfa_led(ioc, fw_event->device_handle);
f92363d1
SR		 9305 break;
9306 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
9307 _scsih_sas_topology_change_event(ioc, fw_event);
9308 break;
9309 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
9310 _scsih_sas_device_status_change_event(ioc, fw_event);
9311 break;
9312 case MPI2_EVENT_SAS_DISCOVERY:
9313 _scsih_sas_discovery_event(ioc, fw_event);
9314 break;
95540b8e
C		 9315 case MPI2_EVENT_SAS_DEVICE_DISCOVERY_ERROR:
9316 _scsih_sas_device_discovery_error_event(ioc, fw_event);
9317 break;
f92363d1
SR		 9318 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
9319 _scsih_sas_broadcast_primitive_event(ioc, fw_event);
9320 break;
9321 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
9322 _scsih_sas_enclosure_dev_status_change_event(ioc,
9323 fw_event);
9324 break;
9325 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
9326 _scsih_sas_ir_config_change_event(ioc, fw_event);
9327 break;
9328 case MPI2_EVENT_IR_VOLUME:
9329 _scsih_sas_ir_volume_event(ioc, fw_event);
9330 break;
9331 case MPI2_EVENT_IR_PHYSICAL_DISK:
9332 _scsih_sas_ir_physical_disk_event(ioc, fw_event);
9333 break;
9334 case MPI2_EVENT_IR_OPERATION_STATUS:
9335 _scsih_sas_ir_operation_status_event(ioc, fw_event);
9336 break;
4318c734
SPS		 9337 case MPI2_EVENT_PCIE_DEVICE_STATUS_CHANGE:
9338 _scsih_pcie_device_status_change_event(ioc, fw_event);
9339 break;
9340 case MPI2_EVENT_PCIE_ENUMERATION:
9341 _scsih_pcie_enumeration_event(ioc, fw_event);
9342 break;
9343 case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST:
9344 _scsih_pcie_topology_change_event(ioc, fw_event);
9345 return;
9346 break;
f92363d1 9347 }
146b16c8
SR		 9348out:
9349 fw_event_work_put(fw_event);
f92363d1
SR		 9350}
9351
9352/**
9353 * _firmware_event_work
f92363d1
SR		 9354 * @work: The fw_event_work object
9355 * Context: user.
9356 *
9357 * wrappers for the work thread handling firmware events
f92363d1
SR		 9358 */
9359
9360static void
9361_firmware_event_work(struct work_struct *work)
9362{
9363 struct fw_event_work *fw_event = container_of(work,
9364 struct fw_event_work, work);
9365
9366 _mpt3sas_fw_work(fw_event->ioc, fw_event);
9367}
9368
9369/**
9370 * mpt3sas_scsih_event_callback - firmware event handler (called at ISR time)
9371 * @ioc: per adapter object
9372 * @msix_index: MSIX table index supplied by the OS
9373 * @reply: reply message frame(lower 32bit addr)
9374 * Context: interrupt.
9375 *
9376 * This function merely adds a new work task into ioc->firmware_event_thread.
9377 * The tasks are worked from _firmware_event_work in user context.
9378 *
4beb4867
BVA		 9379 * Return: 1 meaning mf should be freed from _base_interrupt
9380 * 0 means the mf is freed from this function.
f92363d1
SR		 9381 */
9382u8
9383mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
9384 u32 reply)
9385{
9386 struct fw_event_work *fw_event;
9387 Mpi2EventNotificationReply_t *mpi_reply;
9388 u16 event;
9389 u16 sz;
a470a51c 9390 Mpi26EventDataActiveCableExcept_t *ActiveCableEventData;
f92363d1 9391
79eb96d6
C		 9392 /* events turned off due to host reset */
9393 if (ioc->pci_error_recovery)
f92363d1
SR		 9394 return 1;
9395
9396 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
9397
9398 if (unlikely(!mpi_reply)) {
919d8a3f
JP		 9399 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
9400 __FILE__, __LINE__, __func__);
f92363d1
SR		 9401 return 1;
9402 }
9403
9404 event = le16_to_cpu(mpi_reply->Event);
9405
9406 if (event != MPI2_EVENT_LOG_ENTRY_ADDED)
9407 mpt3sas_trigger_event(ioc, event, 0);
9408
9409 switch (event) {
9410 /* handle these */
9411 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
9412 {
9413 Mpi2EventDataSasBroadcastPrimitive_t *baen_data =
9414 (Mpi2EventDataSasBroadcastPrimitive_t *)
9415 mpi_reply->EventData;
9416
9417 if (baen_data->Primitive !=
9418 MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
9419 return 1;
9420
9421 if (ioc->broadcast_aen_busy) {
9422 ioc->broadcast_aen_pending++;
9423 return 1;
9424 } else
9425 ioc->broadcast_aen_busy = 1;
9426 break;
9427 }
9428
9429 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
9430 _scsih_check_topo_delete_events(ioc,
9431 (Mpi2EventDataSasTopologyChangeList_t *)
9432 mpi_reply->EventData);
9433 break;
4318c734
SPS		 9434 case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST:
9435 _scsih_check_pcie_topo_remove_events(ioc,
9436 (Mpi26EventDataPCIeTopologyChangeList_t *)
9437 mpi_reply->EventData);
9438 break;
f92363d1
SR		 9439 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
9440 _scsih_check_ir_config_unhide_events(ioc,
9441 (Mpi2EventDataIrConfigChangeList_t *)
9442 mpi_reply->EventData);
9443 break;
9444 case MPI2_EVENT_IR_VOLUME:
9445 _scsih_check_volume_delete_events(ioc,
9446 (Mpi2EventDataIrVolume_t *)
9447 mpi_reply->EventData);
9448 break;
7786ab6a
SR		 9449 case MPI2_EVENT_LOG_ENTRY_ADDED:
9450 {
9451 Mpi2EventDataLogEntryAdded_t *log_entry;
9452 u32 *log_code;
9453
9454 if (!ioc->is_warpdrive)
9455 break;
9456
9457 log_entry = (Mpi2EventDataLogEntryAdded_t *)
9458 mpi_reply->EventData;
9459 log_code = (u32 *)log_entry->LogData;
f92363d1 9460
7786ab6a
SR		 9461 if (le16_to_cpu(log_entry->LogEntryQualifier)
9462 != MPT2_WARPDRIVE_LOGENTRY)
9463 break;
9464
9465 switch (le32_to_cpu(*log_code)) {
9466 case MPT2_WARPDRIVE_LC_SSDT:
919d8a3f 9467 ioc_warn(ioc, "WarpDrive Warning: IO Throttling has occurred in the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n");
7786ab6a
SR		 9468 break;
9469 case MPT2_WARPDRIVE_LC_SSDLW:
919d8a3f 9470 ioc_warn(ioc, "WarpDrive Warning: Program/Erase Cycles for the WarpDrive subsystem in degraded range. Check WarpDrive documentation for additional details.\n");
7786ab6a
SR		 9471 break;
9472 case MPT2_WARPDRIVE_LC_SSDLF:
919d8a3f 9473 ioc_err(ioc, "WarpDrive Fatal Error: There are no Program/Erase Cycles for the WarpDrive subsystem. The storage device will be in read-only mode. Check WarpDrive documentation for additional details.\n");
7786ab6a
SR		 9474 break;
9475 case MPT2_WARPDRIVE_LC_BRMF:
919d8a3f 9476 ioc_err(ioc, "WarpDrive Fatal Error: The Backup Rail Monitor has failed on the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n");
7786ab6a
SR		 9477 break;
9478 }
9479
9480 break;
9481 }
f92363d1
SR		 9482 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
9483 case MPI2_EVENT_IR_OPERATION_STATUS:
9484 case MPI2_EVENT_SAS_DISCOVERY:
95540b8e 9485 case MPI2_EVENT_SAS_DEVICE_DISCOVERY_ERROR:
f92363d1
SR		 9486 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
9487 case MPI2_EVENT_IR_PHYSICAL_DISK:
4318c734
SPS		 9488 case MPI2_EVENT_PCIE_ENUMERATION:
9489 case MPI2_EVENT_PCIE_DEVICE_STATUS_CHANGE:
f92363d1
SR		 9490 break;
9491
2d8ce8c9
SR		 9492 case MPI2_EVENT_TEMP_THRESHOLD:
9493 _scsih_temp_threshold_events(ioc,
9494 (Mpi2EventDataTemperature_t *)
9495 mpi_reply->EventData);
9496 break;
a470a51c
C		 9497 case MPI2_EVENT_ACTIVE_CABLE_EXCEPTION:
9498 ActiveCableEventData =
9499 (Mpi26EventDataActiveCableExcept_t *) mpi_reply->EventData;
6c44c0fe
C		 9500 switch (ActiveCableEventData->ReasonCode) {
9501 case MPI26_EVENT_ACTIVE_CABLE_INSUFFICIENT_POWER:
919d8a3f
JP		 9502 ioc_notice(ioc, "Currently an active cable with ReceptacleID %d\n",
9503 ActiveCableEventData->ReceptacleID);
b99b1993
SR		 9504 pr_notice("cannot be powered and devices connected\n");
9505 pr_notice("to this active cable will not be seen\n");
9506 pr_notice("This active cable requires %d mW of power\n",
6c44c0fe 9507 ActiveCableEventData->ActiveCablePowerRequirement);
6c44c0fe
C		 9508 break;
9509
9510 case MPI26_EVENT_ACTIVE_CABLE_DEGRADED:
919d8a3f
JP		 9511 ioc_notice(ioc, "Currently a cable with ReceptacleID %d\n",
9512 ActiveCableEventData->ReceptacleID);
b99b1993
SR		 9513 pr_notice(
9514 "is not running at optimal speed(12 Gb/s rate)\n");
6c44c0fe 9515 break;
7ebd67e0 9516 }
6c44c0fe 9517
a470a51c 9518 break;
2d8ce8c9 9519
f92363d1
SR		 9520 default: /* ignore the rest */
9521 return 1;
9522 }
9523
f92363d1 9524 sz = le16_to_cpu(mpi_reply->EventDataLength) * 4;
146b16c8 9525 fw_event = alloc_fw_event_work(sz);
35b62362 9526 if (!fw_event) {
919d8a3f
JP		 9527 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9528 __FILE__, __LINE__, __func__);
f92363d1
SR		 9529 return 1;
9530 }
9531
9532 memcpy(fw_event->event_data, mpi_reply->EventData, sz);
9533 fw_event->ioc = ioc;
9534 fw_event->VF_ID = mpi_reply->VF_ID;
9535 fw_event->VP_ID = mpi_reply->VP_ID;
9536 fw_event->event = event;
9537 _scsih_fw_event_add(ioc, fw_event);
146b16c8 9538 fw_event_work_put(fw_event);
f92363d1
SR		 9539 return 1;
9540}
9541
f92363d1
SR		 9542/**
9543 * _scsih_expander_node_remove - removing expander device from list.
9544 * @ioc: per adapter object
9545 * @sas_expander: the sas_device object
f92363d1
SR		 9546 *
9547 * Removing object and freeing associated memory from the
9548 * ioc->sas_expander_list.
f92363d1
SR		 9549 */
9550static void
9551_scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
9552 struct _sas_node *sas_expander)
9553{
9554 struct _sas_port *mpt3sas_port, *next;
bbe3def3 9555 unsigned long flags;
f92363d1
SR		 9556
9557 /* remove sibling ports attached to this expander */
9558 list_for_each_entry_safe(mpt3sas_port, next,
9559 &sas_expander->sas_port_list, port_list) {
9560 if (ioc->shost_recovery)
9561 return;
9562 if (mpt3sas_port->remote_identify.device_type ==
9563 SAS_END_DEVICE)
9564 mpt3sas_device_remove_by_sas_address(ioc,
9565 mpt3sas_port->remote_identify.sas_address);
9566 else if (mpt3sas_port->remote_identify.device_type ==
9567 SAS_EDGE_EXPANDER_DEVICE ||
9568 mpt3sas_port->remote_identify.device_type ==
9569 SAS_FANOUT_EXPANDER_DEVICE)
9570 mpt3sas_expander_remove(ioc,
9571 mpt3sas_port->remote_identify.sas_address);
9572 }
9573
9574 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
9575 sas_expander->sas_address_parent);
9576
919d8a3f
JP		 9577 ioc_info(ioc, "expander_remove: handle(0x%04x), sas_addr(0x%016llx)\n",
9578 sas_expander->handle, (unsigned long long)
9579 sas_expander->sas_address);
f92363d1 9580
bbe3def3
SR		 9581 spin_lock_irqsave(&ioc->sas_node_lock, flags);
9582 list_del(&sas_expander->list);
9583 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
9584
f92363d1
SR		 9585 kfree(sas_expander->phy);
9586 kfree(sas_expander);
9587}
9588
9589/**
9590 * _scsih_ir_shutdown - IR shutdown notification
9591 * @ioc: per adapter object
9592 *
9593 * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
9594 * the host system is shutting down.
f92363d1
SR		 9595 */
9596static void
9597_scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc)
9598{
9599 Mpi2RaidActionRequest_t *mpi_request;
9600 Mpi2RaidActionReply_t *mpi_reply;
9601 u16 smid;
9602
9603 /* is IR firmware build loaded ? */
9604 if (!ioc->ir_firmware)
9605 return;
9606
9607 /* are there any volumes ? */
9608 if (list_empty(&ioc->raid_device_list))
9609 return;
9610
9611 mutex_lock(&ioc->scsih_cmds.mutex);
9612
9613 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
919d8a3f 9614 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
f92363d1
SR		 9615 goto out;
9616 }
9617 ioc->scsih_cmds.status = MPT3_CMD_PENDING;
9618
9619 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
9620 if (!smid) {
919d8a3f 9621 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
f92363d1
SR		 9622 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
9623 goto out;
9624 }
9625
9626 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
9627 ioc->scsih_cmds.smid = smid;
9628 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
9629
9630 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
9631 mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
9632
7786ab6a 9633 if (!ioc->hide_ir_msg)
919d8a3f 9634 ioc_info(ioc, "IR shutdown (sending)\n");
f92363d1 9635 init_completion(&ioc->scsih_cmds.done);
40114bde 9636 mpt3sas_base_put_smid_default(ioc, smid);
f92363d1
SR		 9637 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
9638
9639 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
919d8a3f 9640 ioc_err(ioc, "%s: timeout\n", __func__);
f92363d1
SR		 9641 goto out;
9642 }
9643
9644 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
9645 mpi_reply = ioc->scsih_cmds.reply;
7786ab6a 9646 if (!ioc->hide_ir_msg)
919d8a3f
JP		 9647 ioc_info(ioc, "IR shutdown (complete): ioc_status(0x%04x), loginfo(0x%08x)\n",
9648 le16_to_cpu(mpi_reply->IOCStatus),
9649 le32_to_cpu(mpi_reply->IOCLogInfo));
f92363d1
SR		 9650 }
9651
9652 out:
9653 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
9654 mutex_unlock(&ioc->scsih_cmds.mutex);
9655}
9656
9657/**
8a7e4c24 9658 * scsih_remove - detach and remove add host
f92363d1
SR		 9659 * @pdev: PCI device struct
9660 *
9661 * Routine called when unloading the driver.
f92363d1 9662 */
8bbb1cf6 9663static void scsih_remove(struct pci_dev *pdev)
f92363d1
SR		 9664{
9665 struct Scsi_Host *shost = pci_get_drvdata(pdev);
9666 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
9667 struct _sas_port *mpt3sas_port, *next_port;
9668 struct _raid_device *raid_device, *next;
9669 struct MPT3SAS_TARGET *sas_target_priv_data;
3075ac49 9670 struct _pcie_device *pcie_device, *pcienext;
f92363d1
SR		 9671 struct workqueue_struct *wq;
9672 unsigned long flags;
9673
9674 ioc->remove_host = 1;
c666d3be
SR		 9675
9676 mpt3sas_wait_for_commands_to_complete(ioc);
9677 _scsih_flush_running_cmds(ioc);
9678
f92363d1
SR		 9679 _scsih_fw_event_cleanup_queue(ioc);
9680
9681 spin_lock_irqsave(&ioc->fw_event_lock, flags);
9682 wq = ioc->firmware_event_thread;
9683 ioc->firmware_event_thread = NULL;
9684 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
9685 if (wq)
9686 destroy_workqueue(wq);
9687
9688 /* release all the volumes */
9689 _scsih_ir_shutdown(ioc);
dc730212 9690 sas_remove_host(shost);
f92363d1
SR		 9691 list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
9692 list) {
9693 if (raid_device->starget) {
9694 sas_target_priv_data =
9695 raid_device->starget->hostdata;
9696 sas_target_priv_data->deleted = 1;
9697 scsi_remove_target(&raid_device->starget->dev);
9698 }
919d8a3f
JP		 9699 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
9700 raid_device->handle, (u64)raid_device->wwid);
f92363d1
SR		 9701 _scsih_raid_device_remove(ioc, raid_device);
9702 }
3075ac49
SPS		 9703 list_for_each_entry_safe(pcie_device, pcienext, &ioc->pcie_device_list,
9704 list) {
9705 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
9706 list_del_init(&pcie_device->list);
9707 pcie_device_put(pcie_device);
9708 }
f92363d1
SR		 9709
9710 /* free ports attached to the sas_host */
9711 list_for_each_entry_safe(mpt3sas_port, next_port,
9712 &ioc->sas_hba.sas_port_list, port_list) {
9713 if (mpt3sas_port->remote_identify.device_type ==
9714 SAS_END_DEVICE)
9715 mpt3sas_device_remove_by_sas_address(ioc,
9716 mpt3sas_port->remote_identify.sas_address);
9717 else if (mpt3sas_port->remote_identify.device_type ==
9718 SAS_EDGE_EXPANDER_DEVICE ||
9719 mpt3sas_port->remote_identify.device_type ==
9720 SAS_FANOUT_EXPANDER_DEVICE)
9721 mpt3sas_expander_remove(ioc,
9722 mpt3sas_port->remote_identify.sas_address);
9723 }
9724
9725 /* free phys attached to the sas_host */
9726 if (ioc->sas_hba.num_phys) {
9727 kfree(ioc->sas_hba.phy);
9728 ioc->sas_hba.phy = NULL;
9729 ioc->sas_hba.num_phys = 0;
9730 }
9731
f92363d1 9732 mpt3sas_base_detach(ioc);
08c4d550 9733 spin_lock(&gioc_lock);
f92363d1 9734 list_del(&ioc->list);
08c4d550 9735 spin_unlock(&gioc_lock);
f92363d1
SR		 9736 scsi_host_put(shost);
9737}
9738
9739/**
8a7e4c24 9740 * scsih_shutdown - routine call during system shutdown
f92363d1 9741 * @pdev: PCI device struct
f92363d1 9742 */
8bbb1cf6 9743static void
8a7e4c24 9744scsih_shutdown(struct pci_dev *pdev)
f92363d1
SR		 9745{
9746 struct Scsi_Host *shost = pci_get_drvdata(pdev);
9747 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
9748 struct workqueue_struct *wq;
9749 unsigned long flags;
9750
9751 ioc->remove_host = 1;
c666d3be
SR		 9752
9753 mpt3sas_wait_for_commands_to_complete(ioc);
9754 _scsih_flush_running_cmds(ioc);
9755
f92363d1
SR		 9756 _scsih_fw_event_cleanup_queue(ioc);
9757
9758 spin_lock_irqsave(&ioc->fw_event_lock, flags);
9759 wq = ioc->firmware_event_thread;
9760 ioc->firmware_event_thread = NULL;
9761 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
9762 if (wq)
9763 destroy_workqueue(wq);
9764
9765 _scsih_ir_shutdown(ioc);
9766 mpt3sas_base_detach(ioc);
9767}
9768
9769
9770/**
9771 * _scsih_probe_boot_devices - reports 1st device
9772 * @ioc: per adapter object
9773 *
9774 * If specified in bios page 2, this routine reports the 1st
9775 * device scsi-ml or sas transport for persistent boot device
9776 * purposes. Please refer to function _scsih_determine_boot_device()
9777 */
9778static void
9779_scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc)
9780{
d88e1eab 9781 u32 channel;
f92363d1
SR		 9782 void *device;
9783 struct _sas_device *sas_device;
9784 struct _raid_device *raid_device;
d88e1eab 9785 struct _pcie_device *pcie_device;
f92363d1
SR		 9786 u16 handle;
9787 u64 sas_address_parent;
9788 u64 sas_address;
9789 unsigned long flags;
9790 int rc;
d88e1eab 9791 int tid;
f92363d1
SR		 9792
9793 /* no Bios, return immediately */
9794 if (!ioc->bios_pg3.BiosVersion)
9795 return;
9796
9797 device = NULL;
f92363d1
SR		 9798 if (ioc->req_boot_device.device) {
9799 device = ioc->req_boot_device.device;
d88e1eab 9800 channel = ioc->req_boot_device.channel;
f92363d1
SR		 9801 } else if (ioc->req_alt_boot_device.device) {
9802 device = ioc->req_alt_boot_device.device;
d88e1eab 9803 channel = ioc->req_alt_boot_device.channel;
f92363d1
SR		 9804 } else if (ioc->current_boot_device.device) {
9805 device = ioc->current_boot_device.device;
d88e1eab 9806 channel = ioc->current_boot_device.channel;
f92363d1
SR		 9807 }
9808
9809 if (!device)
9810 return;
9811
d88e1eab 9812 if (channel == RAID_CHANNEL) {
f92363d1
SR		 9813 raid_device = device;
9814 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
9815 raid_device->id, 0);
9816 if (rc)
9817 _scsih_raid_device_remove(ioc, raid_device);
d88e1eab
SPS		 9818 } else if (channel == PCIE_CHANNEL) {
9819 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
9820 pcie_device = device;
9821 tid = pcie_device->id;
9822 list_move_tail(&pcie_device->list, &ioc->pcie_device_list);
9823 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
9824 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL, tid, 0);
9825 if (rc)
9826 _scsih_pcie_device_remove(ioc, pcie_device);
f92363d1
SR		 9827 } else {
9828 spin_lock_irqsave(&ioc->sas_device_lock, flags);
9829 sas_device = device;
9830 handle = sas_device->handle;
9831 sas_address_parent = sas_device->sas_address_parent;
9832 sas_address = sas_device->sas_address;
9833 list_move_tail(&sas_device->list, &ioc->sas_device_list);
9834 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9835
7786ab6a
SR		 9836 if (ioc->hide_drives)
9837 return;
f92363d1
SR		 9838 if (!mpt3sas_transport_port_add(ioc, handle,
9839 sas_address_parent)) {
9840 _scsih_sas_device_remove(ioc, sas_device);
9841 } else if (!sas_device->starget) {
f5edbe77
SR		 9842 if (!ioc->is_driver_loading) {
9843 mpt3sas_transport_port_remove(ioc,
9844 sas_address,
f92363d1 9845 sas_address_parent);
f5edbe77
SR		 9846 _scsih_sas_device_remove(ioc, sas_device);
9847 }
f92363d1
SR		 9848 }
9849 }
9850}
9851
9852/**
9853 * _scsih_probe_raid - reporting raid volumes to scsi-ml
9854 * @ioc: per adapter object
9855 *
9856 * Called during initial loading of the driver.
9857 */
9858static void
9859_scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc)
9860{
9861 struct _raid_device *raid_device, *raid_next;
9862 int rc;
9863
9864 list_for_each_entry_safe(raid_device, raid_next,
9865 &ioc->raid_device_list, list) {
9866 if (raid_device->starget)
9867 continue;
9868 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
9869 raid_device->id, 0);
9870 if (rc)
9871 _scsih_raid_device_remove(ioc, raid_device);
9872 }
9873}
9874
d1cb5e49
SR		 9875static struct _sas_device *get_next_sas_device(struct MPT3SAS_ADAPTER *ioc)
9876{
9877 struct _sas_device *sas_device = NULL;
9878 unsigned long flags;
9879
9880 spin_lock_irqsave(&ioc->sas_device_lock, flags);
9881 if (!list_empty(&ioc->sas_device_init_list)) {
9882 sas_device = list_first_entry(&ioc->sas_device_init_list,
9883 struct _sas_device, list);
9884 sas_device_get(sas_device);
9885 }
9886 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9887
9888 return sas_device;
9889}
9890
9891static void sas_device_make_active(struct MPT3SAS_ADAPTER *ioc,
9892 struct _sas_device *sas_device)
9893{
9894 unsigned long flags;
9895
9896 spin_lock_irqsave(&ioc->sas_device_lock, flags);
9897
9898 /*
9899 * Since we dropped the lock during the call to port_add(), we need to
9900 * be careful here that somebody else didn't move or delete this item
9901 * while we were busy with other things.
9902 *
9903 * If it was on the list, we need a put() for the reference the list
9904 * had. Either way, we need a get() for the destination list.
9905 */
9906 if (!list_empty(&sas_device->list)) {
9907 list_del_init(&sas_device->list);
9908 sas_device_put(sas_device);
9909 }
9910
9911 sas_device_get(sas_device);
9912 list_add_tail(&sas_device->list, &ioc->sas_device_list);
9913
9914 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9915}
9916
f92363d1
SR		 9917/**
9918 * _scsih_probe_sas - reporting sas devices to sas transport
9919 * @ioc: per adapter object
9920 *
9921 * Called during initial loading of the driver.
9922 */
9923static void
9924_scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc)
9925{
d1cb5e49 9926 struct _sas_device *sas_device;
f92363d1 9927
d1cb5e49
SR		 9928 if (ioc->hide_drives)
9929 return;
7786ab6a 9930
d1cb5e49 9931 while ((sas_device = get_next_sas_device(ioc))) {
f92363d1
SR		 9932 if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
9933 sas_device->sas_address_parent)) {
d1cb5e49
SR		 9934 _scsih_sas_device_remove(ioc, sas_device);
9935 sas_device_put(sas_device);
f92363d1
SR		 9936 continue;
9937 } else if (!sas_device->starget) {
9938 /*
9939 * When asyn scanning is enabled, its not possible to
9940 * remove devices while scanning is turned on due to an
9941 * oops in scsi_sysfs_add_sdev()->add_device()->
9942 * sysfs_addrm_start()
9943 */
f5edbe77 9944 if (!ioc->is_driver_loading) {
f92363d1
SR		 9945 mpt3sas_transport_port_remove(ioc,
9946 sas_device->sas_address,
9947 sas_device->sas_address_parent);
d1cb5e49
SR		 9948 _scsih_sas_device_remove(ioc, sas_device);
9949 sas_device_put(sas_device);
f5edbe77
SR		 9950 continue;
9951 }
f92363d1 9952 }
d1cb5e49
SR		 9953 sas_device_make_active(ioc, sas_device);
9954 sas_device_put(sas_device);
f92363d1
SR		 9955 }
9956}
9957
d88e1eab
SPS		 9958/**
9959 * get_next_pcie_device - Get the next pcie device
9960 * @ioc: per adapter object
9961 *
9962 * Get the next pcie device from pcie_device_init_list list.
9963 *
4beb4867 9964 * Return: pcie device structure if pcie_device_init_list list is not empty
d88e1eab
SPS		 9965 * otherwise returns NULL
9966 */
9967static struct _pcie_device *get_next_pcie_device(struct MPT3SAS_ADAPTER *ioc)
9968{
9969 struct _pcie_device *pcie_device = NULL;
9970 unsigned long flags;
9971
9972 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
9973 if (!list_empty(&ioc->pcie_device_init_list)) {
9974 pcie_device = list_first_entry(&ioc->pcie_device_init_list,
9975 struct _pcie_device, list);
9976 pcie_device_get(pcie_device);
9977 }
9978 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
9979
9980 return pcie_device;
9981}
9982
9983/**
9984 * pcie_device_make_active - Add pcie device to pcie_device_list list
9985 * @ioc: per adapter object
9986 * @pcie_device: pcie device object
9987 *
9988 * Add the pcie device which has registered with SCSI Transport Later to
9989 * pcie_device_list list
9990 */
9991static void pcie_device_make_active(struct MPT3SAS_ADAPTER *ioc,
9992 struct _pcie_device *pcie_device)
9993{
9994 unsigned long flags;
9995
9996 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
9997
9998 if (!list_empty(&pcie_device->list)) {
9999 list_del_init(&pcie_device->list);
10000 pcie_device_put(pcie_device);
10001 }
10002 pcie_device_get(pcie_device);
10003 list_add_tail(&pcie_device->list, &ioc->pcie_device_list);
10004
10005 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
10006}
10007
10008/**
10009 * _scsih_probe_pcie - reporting PCIe devices to scsi-ml
10010 * @ioc: per adapter object
10011 *
10012 * Called during initial loading of the driver.
10013 */
10014static void
10015_scsih_probe_pcie(struct MPT3SAS_ADAPTER *ioc)
10016{
10017 struct _pcie_device *pcie_device;
10018 int rc;
10019
10020 /* PCIe Device List */
10021 while ((pcie_device = get_next_pcie_device(ioc))) {
10022 if (pcie_device->starget) {
10023 pcie_device_put(pcie_device);
10024 continue;
10025 }
10026 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL,
10027 pcie_device->id, 0);
10028 if (rc) {
10029 _scsih_pcie_device_remove(ioc, pcie_device);
10030 pcie_device_put(pcie_device);
10031 continue;
10032 } else if (!pcie_device->starget) {
10033 /*
10034 * When async scanning is enabled, its not possible to
10035 * remove devices while scanning is turned on due to an
10036 * oops in scsi_sysfs_add_sdev()->add_device()->
10037 * sysfs_addrm_start()
10038 */
10039 if (!ioc->is_driver_loading) {
10040 /* TODO-- Need to find out whether this condition will
10041 * occur or not
10042 */
10043 _scsih_pcie_device_remove(ioc, pcie_device);
10044 pcie_device_put(pcie_device);
10045 continue;
10046 }
10047 }
10048 pcie_device_make_active(ioc, pcie_device);
10049 pcie_device_put(pcie_device);
10050 }
10051}
10052
f92363d1
SR		 10053/**
10054 * _scsih_probe_devices - probing for devices
10055 * @ioc: per adapter object
10056 *
10057 * Called during initial loading of the driver.
10058 */
10059static void
10060_scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc)
10061{
10062 u16 volume_mapping_flags;
10063
10064 if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
10065 return; /* return when IOC doesn't support initiator mode */
10066
10067 _scsih_probe_boot_devices(ioc);
10068
10069 if (ioc->ir_firmware) {
10070 volume_mapping_flags =
10071 le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
10072 MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
10073 if (volume_mapping_flags ==
10074 MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) {
10075 _scsih_probe_raid(ioc);
10076 _scsih_probe_sas(ioc);
10077 } else {
10078 _scsih_probe_sas(ioc);
10079 _scsih_probe_raid(ioc);
10080 }
d88e1eab 10081 } else {
f92363d1 10082 _scsih_probe_sas(ioc);
d88e1eab
SPS		 10083 _scsih_probe_pcie(ioc);
10084 }
f92363d1
SR		 10085}
10086
10087/**
8a7e4c24 10088 * scsih_scan_start - scsi lld callback for .scan_start
f92363d1
SR		 10089 * @shost: SCSI host pointer
10090 *
10091 * The shost has the ability to discover targets on its own instead
10092 * of scanning the entire bus. In our implemention, we will kick off
10093 * firmware discovery.
10094 */
8bbb1cf6 10095static void
8a7e4c24 10096scsih_scan_start(struct Scsi_Host *shost)
f92363d1
SR		 10097{
10098 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10099 int rc;
10100 if (diag_buffer_enable != -1 && diag_buffer_enable != 0)
10101 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable);
10102
10103 if (disable_discovery > 0)
10104 return;
10105
10106 ioc->start_scan = 1;
10107 rc = mpt3sas_port_enable(ioc);
10108
10109 if (rc != 0)
919d8a3f 10110 ioc_info(ioc, "port enable: FAILED\n");
f92363d1
SR		 10111}
10112
10113/**
8a7e4c24 10114 * scsih_scan_finished - scsi lld callback for .scan_finished
f92363d1
SR		 10115 * @shost: SCSI host pointer
10116 * @time: elapsed time of the scan in jiffies
10117 *
10118 * This function will be called periodicallyn until it returns 1 with the
10119 * scsi_host and the elapsed time of the scan in jiffies. In our implemention,
10120 * we wait for firmware discovery to complete, then return 1.
10121 */
8bbb1cf6 10122static int
8a7e4c24 10123scsih_scan_finished(struct Scsi_Host *shost, unsigned long time)
f92363d1
SR		 10124{
10125 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10126
10127 if (disable_discovery > 0) {
10128 ioc->is_driver_loading = 0;
10129 ioc->wait_for_discovery_to_complete = 0;
10130 return 1;
10131 }
10132
10133 if (time >= (300 * HZ)) {
e3586147 10134 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
919d8a3f 10135 ioc_info(ioc, "port enable: FAILED with timeout (timeout=300s)\n");
f92363d1
SR		 10136 ioc->is_driver_loading = 0;
10137 return 1;
10138 }
10139
10140 if (ioc->start_scan)
10141 return 0;
10142
10143 if (ioc->start_scan_failed) {
919d8a3f
JP		 10144 ioc_info(ioc, "port enable: FAILED with (ioc_status=0x%08x)\n",
10145 ioc->start_scan_failed);
f92363d1
SR		 10146 ioc->is_driver_loading = 0;
10147 ioc->wait_for_discovery_to_complete = 0;
10148 ioc->remove_host = 1;
10149 return 1;
10150 }
10151
919d8a3f 10152 ioc_info(ioc, "port enable: SUCCESS\n");
e3586147 10153 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
f92363d1
SR		 10154
10155 if (ioc->wait_for_discovery_to_complete) {
10156 ioc->wait_for_discovery_to_complete = 0;
10157 _scsih_probe_devices(ioc);
10158 }
10159 mpt3sas_base_start_watchdog(ioc);
10160 ioc->is_driver_loading = 0;
10161 return 1;
10162}
10163
c84b06a4
SR		 10164/* shost template for SAS 2.0 HBA devices */
10165static struct scsi_host_template mpt2sas_driver_template = {
10166 .module = THIS_MODULE,
10167 .name = "Fusion MPT SAS Host",
10168 .proc_name = MPT2SAS_DRIVER_NAME,
10169 .queuecommand = scsih_qcmd,
10170 .target_alloc = scsih_target_alloc,
10171 .slave_alloc = scsih_slave_alloc,
10172 .slave_configure = scsih_slave_configure,
10173 .target_destroy = scsih_target_destroy,
10174 .slave_destroy = scsih_slave_destroy,
10175 .scan_finished = scsih_scan_finished,
10176 .scan_start = scsih_scan_start,
10177 .change_queue_depth = scsih_change_queue_depth,
10178 .eh_abort_handler = scsih_abort,
10179 .eh_device_reset_handler = scsih_dev_reset,
10180 .eh_target_reset_handler = scsih_target_reset,
10181 .eh_host_reset_handler = scsih_host_reset,
10182 .bios_param = scsih_bios_param,
10183 .can_queue = 1,
10184 .this_id = -1,
10185 .sg_tablesize = MPT2SAS_SG_DEPTH,
10186 .max_sectors = 32767,
10187 .cmd_per_lun = 7,
c84b06a4
SR		 10188 .shost_attrs = mpt3sas_host_attrs,
10189 .sdev_attrs = mpt3sas_dev_attrs,
10190 .track_queue_depth = 1,
dbec4c90 10191 .cmd_size = sizeof(struct scsiio_tracker),
c84b06a4
SR		 10192};
10193
10194/* raid transport support for SAS 2.0 HBA devices */
10195static struct raid_function_template mpt2sas_raid_functions = {
10196 .cookie = &mpt2sas_driver_template,
10197 .is_raid = scsih_is_raid,
10198 .get_resync = scsih_get_resync,
10199 .get_state = scsih_get_state,
10200};
d357e84d 10201
c84b06a4
SR		 10202/* shost template for SAS 3.0 HBA devices */
10203static struct scsi_host_template mpt3sas_driver_template = {
10204 .module = THIS_MODULE,
10205 .name = "Fusion MPT SAS Host",
10206 .proc_name = MPT3SAS_DRIVER_NAME,
10207 .queuecommand = scsih_qcmd,
10208 .target_alloc = scsih_target_alloc,
10209 .slave_alloc = scsih_slave_alloc,
10210 .slave_configure = scsih_slave_configure,
10211 .target_destroy = scsih_target_destroy,
10212 .slave_destroy = scsih_slave_destroy,
10213 .scan_finished = scsih_scan_finished,
10214 .scan_start = scsih_scan_start,
10215 .change_queue_depth = scsih_change_queue_depth,
10216 .eh_abort_handler = scsih_abort,
10217 .eh_device_reset_handler = scsih_dev_reset,
10218 .eh_target_reset_handler = scsih_target_reset,
10219 .eh_host_reset_handler = scsih_host_reset,
10220 .bios_param = scsih_bios_param,
10221 .can_queue = 1,
10222 .this_id = -1,
10223 .sg_tablesize = MPT3SAS_SG_DEPTH,
10224 .max_sectors = 32767,
10225 .cmd_per_lun = 7,
c84b06a4
SR		 10226 .shost_attrs = mpt3sas_host_attrs,
10227 .sdev_attrs = mpt3sas_dev_attrs,
10228 .track_queue_depth = 1,
dbec4c90 10229 .cmd_size = sizeof(struct scsiio_tracker),
c84b06a4
SR		 10230};
10231
10232/* raid transport support for SAS 3.0 HBA devices */
10233static struct raid_function_template mpt3sas_raid_functions = {
10234 .cookie = &mpt3sas_driver_template,
10235 .is_raid = scsih_is_raid,
10236 .get_resync = scsih_get_resync,
10237 .get_state = scsih_get_state,
10238};
10239
10240/**
10241 * _scsih_determine_hba_mpi_version - determine in which MPI version class
10242 * this device belongs to.
10243 * @pdev: PCI device struct
10244 *
10245 * return MPI2_VERSION for SAS 2.0 HBA devices,
b130b0d5
SS		 10246 * MPI25_VERSION for SAS 3.0 HBA devices, and
10247 * MPI26 VERSION for Cutlass & Invader SAS 3.0 HBA devices
c84b06a4 10248 */
8bbb1cf6 10249static u16
c84b06a4
SR		 10250_scsih_determine_hba_mpi_version(struct pci_dev *pdev)
10251{
10252
10253 switch (pdev->device) {
7786ab6a 10254 case MPI2_MFGPAGE_DEVID_SSS6200:
d357e84d
SR		 10255 case MPI2_MFGPAGE_DEVID_SAS2004:
10256 case MPI2_MFGPAGE_DEVID_SAS2008:
10257 case MPI2_MFGPAGE_DEVID_SAS2108_1:
10258 case MPI2_MFGPAGE_DEVID_SAS2108_2:
10259 case MPI2_MFGPAGE_DEVID_SAS2108_3:
10260 case MPI2_MFGPAGE_DEVID_SAS2116_1:
10261 case MPI2_MFGPAGE_DEVID_SAS2116_2:
10262 case MPI2_MFGPAGE_DEVID_SAS2208_1:
10263 case MPI2_MFGPAGE_DEVID_SAS2208_2:
10264 case MPI2_MFGPAGE_DEVID_SAS2208_3:
10265 case MPI2_MFGPAGE_DEVID_SAS2208_4:
10266 case MPI2_MFGPAGE_DEVID_SAS2208_5:
10267 case MPI2_MFGPAGE_DEVID_SAS2208_6:
10268 case MPI2_MFGPAGE_DEVID_SAS2308_1:
10269 case MPI2_MFGPAGE_DEVID_SAS2308_2:
10270 case MPI2_MFGPAGE_DEVID_SAS2308_3:
1244790d 10271 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP:
8f838450 10272 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1:
c84b06a4 10273 return MPI2_VERSION;
d357e84d
SR		 10274 case MPI25_MFGPAGE_DEVID_SAS3004:
10275 case MPI25_MFGPAGE_DEVID_SAS3008:
10276 case MPI25_MFGPAGE_DEVID_SAS3108_1:
10277 case MPI25_MFGPAGE_DEVID_SAS3108_2:
10278 case MPI25_MFGPAGE_DEVID_SAS3108_5:
10279 case MPI25_MFGPAGE_DEVID_SAS3108_6:
c84b06a4 10280 return MPI25_VERSION;
b130b0d5
SS		 10281 case MPI26_MFGPAGE_DEVID_SAS3216:
10282 case MPI26_MFGPAGE_DEVID_SAS3224:
10283 case MPI26_MFGPAGE_DEVID_SAS3316_1:
10284 case MPI26_MFGPAGE_DEVID_SAS3316_2:
10285 case MPI26_MFGPAGE_DEVID_SAS3316_3:
10286 case MPI26_MFGPAGE_DEVID_SAS3316_4:
10287 case MPI26_MFGPAGE_DEVID_SAS3324_1:
10288 case MPI26_MFGPAGE_DEVID_SAS3324_2:
10289 case MPI26_MFGPAGE_DEVID_SAS3324_3:
10290 case MPI26_MFGPAGE_DEVID_SAS3324_4:
998f26ae
SPS		 10291 case MPI26_MFGPAGE_DEVID_SAS3508:
10292 case MPI26_MFGPAGE_DEVID_SAS3508_1:
10293 case MPI26_MFGPAGE_DEVID_SAS3408:
10294 case MPI26_MFGPAGE_DEVID_SAS3516:
10295 case MPI26_MFGPAGE_DEVID_SAS3516_1:
10296 case MPI26_MFGPAGE_DEVID_SAS3416:
15fd7c74 10297 case MPI26_MFGPAGE_DEVID_SAS3616:
eb9c7ce5 10298 case MPI26_ATLAS_PCIe_SWITCH_DEVID:
6c2938f7
SP		 10299 case MPI26_MFGPAGE_DEVID_CFG_SEC_3916:
10300 case MPI26_MFGPAGE_DEVID_HARD_SEC_3916:
10301 case MPI26_MFGPAGE_DEVID_CFG_SEC_3816:
10302 case MPI26_MFGPAGE_DEVID_HARD_SEC_3816:
b130b0d5 10303 return MPI26_VERSION;
d357e84d 10304 }
c84b06a4 10305 return 0;
d357e84d
SR		 10306}
10307
f92363d1 10308/**
c84b06a4 10309 * _scsih_probe - attach and add scsi host
f92363d1
SR		 10310 * @pdev: PCI device struct
10311 * @id: pci device id
10312 *
4beb4867 10313 * Return: 0 success, anything else error.
f92363d1 10314 */
8bbb1cf6 10315static int
c84b06a4 10316_scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
f92363d1
SR		 10317{
10318 struct MPT3SAS_ADAPTER *ioc;
c84b06a4 10319 struct Scsi_Host *shost = NULL;
b65f1d4d 10320 int rv;
c84b06a4
SR		 10321 u16 hba_mpi_version;
10322
10323 /* Determine in which MPI version class this pci device belongs */
10324 hba_mpi_version = _scsih_determine_hba_mpi_version(pdev);
10325 if (hba_mpi_version == 0)
10326 return -ENODEV;
10327
10328 /* Enumerate only SAS 2.0 HBA's if hbas_to_enumerate is one,
10329 * for other generation HBA's return with -ENODEV
10330 */
10331 if ((hbas_to_enumerate == 1) && (hba_mpi_version != MPI2_VERSION))
10332 return -ENODEV;
10333
10334 /* Enumerate only SAS 3.0 HBA's if hbas_to_enumerate is two,
10335 * for other generation HBA's return with -ENODEV
10336 */
b130b0d5
SS		 10337 if ((hbas_to_enumerate == 2) && (!(hba_mpi_version == MPI25_VERSION
10338 || hba_mpi_version == MPI26_VERSION)))
c84b06a4
SR		 10339 return -ENODEV;
10340
10341 switch (hba_mpi_version) {
10342 case MPI2_VERSION:
ffdadd68 10343 pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S |
10344 PCIE_LINK_STATE_L1 | PCIE_LINK_STATE_CLKPM);
c84b06a4
SR		 10345 /* Use mpt2sas driver host template for SAS 2.0 HBA's */
10346 shost = scsi_host_alloc(&mpt2sas_driver_template,
10347 sizeof(struct MPT3SAS_ADAPTER));
10348 if (!shost)
10349 return -ENODEV;
10350 ioc = shost_priv(shost);
10351 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
10352 ioc->hba_mpi_version_belonged = hba_mpi_version;
10353 ioc->id = mpt2_ids++;
10354 sprintf(ioc->driver_name, "%s", MPT2SAS_DRIVER_NAME);
c520691b
SPS		 10355 switch (pdev->device) {
10356 case MPI2_MFGPAGE_DEVID_SSS6200:
c84b06a4
SR		 10357 ioc->is_warpdrive = 1;
10358 ioc->hide_ir_msg = 1;
c520691b 10359 break;
1244790d 10360 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP:
8f838450 10361 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1:
c520691b
SPS		 10362 ioc->is_mcpu_endpoint = 1;
10363 break;
10364 default:
c84b06a4 10365 ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS;
c520691b
SPS		 10366 break;
10367 }
c84b06a4
SR		 10368 break;
10369 case MPI25_VERSION:
b130b0d5 10370 case MPI26_VERSION:
c84b06a4
SR		 10371 /* Use mpt3sas driver host template for SAS 3.0 HBA's */
10372 shost = scsi_host_alloc(&mpt3sas_driver_template,
10373 sizeof(struct MPT3SAS_ADAPTER));
10374 if (!shost)
10375 return -ENODEV;
10376 ioc = shost_priv(shost);
10377 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
10378 ioc->hba_mpi_version_belonged = hba_mpi_version;
10379 ioc->id = mpt3_ids++;
10380 sprintf(ioc->driver_name, "%s", MPT3SAS_DRIVER_NAME);
998f26ae
SPS		 10381 switch (pdev->device) {
10382 case MPI26_MFGPAGE_DEVID_SAS3508:
10383 case MPI26_MFGPAGE_DEVID_SAS3508_1:
10384 case MPI26_MFGPAGE_DEVID_SAS3408:
10385 case MPI26_MFGPAGE_DEVID_SAS3516:
10386 case MPI26_MFGPAGE_DEVID_SAS3516_1:
10387 case MPI26_MFGPAGE_DEVID_SAS3416:
15fd7c74 10388 case MPI26_MFGPAGE_DEVID_SAS3616:
eb9c7ce5 10389 case MPI26_ATLAS_PCIe_SWITCH_DEVID:
cc68e607
SP		 10390 ioc->is_gen35_ioc = 1;
10391 break;
10392 case MPI26_MFGPAGE_DEVID_CFG_SEC_3816:
10393 case MPI26_MFGPAGE_DEVID_CFG_SEC_3916:
10394 dev_info(&pdev->dev,
10395 "HBA is in Configurable Secure mode\n");
a8cc10e2 10396 /* fall through */
6c2938f7
SP		 10397 case MPI26_MFGPAGE_DEVID_HARD_SEC_3816:
10398 case MPI26_MFGPAGE_DEVID_HARD_SEC_3916:
cc68e607 10399 ioc->is_aero_ioc = ioc->is_gen35_ioc = 1;
998f26ae
SPS		 10400 break;
10401 default:
cc68e607 10402 ioc->is_gen35_ioc = ioc->is_aero_ioc = 0;
998f26ae 10403 }
b130b0d5
SS		 10404 if ((ioc->hba_mpi_version_belonged == MPI25_VERSION &&
10405 pdev->revision >= SAS3_PCI_DEVICE_C0_REVISION) ||
0bb337c9
SPS		 10406 (ioc->hba_mpi_version_belonged == MPI26_VERSION)) {
10407 ioc->combined_reply_queue = 1;
10408 if (ioc->is_gen35_ioc)
10409 ioc->combined_reply_index_count =
10410 MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G35;
10411 else
10412 ioc->combined_reply_index_count =
10413 MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G3;
10414 }
c84b06a4
SR		 10415 break;
10416 default:
10417 return -ENODEV;
10418 }
f92363d1 10419
f92363d1 10420 INIT_LIST_HEAD(&ioc->list);
08c4d550 10421 spin_lock(&gioc_lock);
f92363d1 10422 list_add_tail(&ioc->list, &mpt3sas_ioc_list);
08c4d550 10423 spin_unlock(&gioc_lock);
f92363d1 10424 ioc->shost = shost;
f92363d1
SR		 10425 ioc->pdev = pdev;
10426 ioc->scsi_io_cb_idx = scsi_io_cb_idx;
10427 ioc->tm_cb_idx = tm_cb_idx;
10428 ioc->ctl_cb_idx = ctl_cb_idx;
10429 ioc->base_cb_idx = base_cb_idx;
10430 ioc->port_enable_cb_idx = port_enable_cb_idx;
10431 ioc->transport_cb_idx = transport_cb_idx;
10432 ioc->scsih_cb_idx = scsih_cb_idx;
10433 ioc->config_cb_idx = config_cb_idx;
10434 ioc->tm_tr_cb_idx = tm_tr_cb_idx;
10435 ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx;
10436 ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
10437 ioc->logging_level = logging_level;
10438 ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds;
10439 /* misc semaphores and spin locks */
10440 mutex_init(&ioc->reset_in_progress_mutex);
08c4d550
SR		 10441 /* initializing pci_access_mutex lock */
10442 mutex_init(&ioc->pci_access_mutex);
f92363d1
SR		 10443 spin_lock_init(&ioc->ioc_reset_in_progress_lock);
10444 spin_lock_init(&ioc->scsi_lookup_lock);
10445 spin_lock_init(&ioc->sas_device_lock);
10446 spin_lock_init(&ioc->sas_node_lock);
10447 spin_lock_init(&ioc->fw_event_lock);
10448 spin_lock_init(&ioc->raid_device_lock);
d88e1eab 10449 spin_lock_init(&ioc->pcie_device_lock);
f92363d1
SR		 10450 spin_lock_init(&ioc->diag_trigger_lock);
10451
10452 INIT_LIST_HEAD(&ioc->sas_device_list);
10453 INIT_LIST_HEAD(&ioc->sas_device_init_list);
10454 INIT_LIST_HEAD(&ioc->sas_expander_list);
22a923c3 10455 INIT_LIST_HEAD(&ioc->enclosure_list);
d88e1eab
SPS		 10456 INIT_LIST_HEAD(&ioc->pcie_device_list);
10457 INIT_LIST_HEAD(&ioc->pcie_device_init_list);
f92363d1
SR		 10458 INIT_LIST_HEAD(&ioc->fw_event_list);
10459 INIT_LIST_HEAD(&ioc->raid_device_list);
10460 INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
10461 INIT_LIST_HEAD(&ioc->delayed_tr_list);
fd0331b3
SS		 10462 INIT_LIST_HEAD(&ioc->delayed_sc_list);
10463 INIT_LIST_HEAD(&ioc->delayed_event_ack_list);
f92363d1 10464 INIT_LIST_HEAD(&ioc->delayed_tr_volume_list);
cf9bd21a 10465 INIT_LIST_HEAD(&ioc->reply_queue_list);
f92363d1 10466
c84b06a4 10467 sprintf(ioc->name, "%s_cm%d", ioc->driver_name, ioc->id);
d357e84d 10468
f92363d1
SR		 10469 /* init shost parameters */
10470 shost->max_cmd_len = 32;
10471 shost->max_lun = max_lun;
10472 shost->transportt = mpt3sas_transport_template;
10473 shost->unique_id = ioc->id;
10474
0448f019
SPS		 10475 if (ioc->is_mcpu_endpoint) {
10476 /* mCPU MPI support 64K max IO */
10477 shost->max_sectors = 128;
919d8a3f
JP		 10478 ioc_info(ioc, "The max_sectors value is set to %d\n",
10479 shost->max_sectors);
0448f019
SPS		 10480 } else {
10481 if (max_sectors != 0xFFFF) {
10482 if (max_sectors < 64) {
10483 shost->max_sectors = 64;
919d8a3f
JP		 10484 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767. Assigning value of 64.\n",
10485 max_sectors);
0448f019
SPS		 10486 } else if (max_sectors > 32767) {
10487 shost->max_sectors = 32767;
919d8a3f
JP		 10488 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767.Assigning default value of 32767.\n",
10489 max_sectors);
0448f019
SPS		 10490 } else {
10491 shost->max_sectors = max_sectors & 0xFFFE;
919d8a3f
JP		 10492 ioc_info(ioc, "The max_sectors value is set to %d\n",
10493 shost->max_sectors);
0448f019 10494 }
f92363d1
SR		 10495 }
10496 }
f92363d1
SR		 10497 /* register EEDP capabilities with SCSI layer */
10498 if (prot_mask > 0)
10499 scsi_host_set_prot(shost, prot_mask);
10500 else
10501 scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION
10502 | SHOST_DIF_TYPE2_PROTECTION
10503 | SHOST_DIF_TYPE3_PROTECTION);
10504
10505 scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
10506
10507 /* event thread */
10508 snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
c84b06a4 10509 "fw_event_%s%d", ioc->driver_name, ioc->id);
bdff785e 10510 ioc->firmware_event_thread = alloc_ordered_workqueue(
864449ee 10511 ioc->firmware_event_name, 0);
f92363d1 10512 if (!ioc->firmware_event_thread) {
919d8a3f
JP		 10513 ioc_err(ioc, "failure at %s:%d/%s()!\n",
10514 __FILE__, __LINE__, __func__);
b65f1d4d 10515 rv = -ENODEV;
f92363d1
SR		 10516 goto out_thread_fail;
10517 }
10518
10519 ioc->is_driver_loading = 1;
10520 if ((mpt3sas_base_attach(ioc))) {
919d8a3f
JP		 10521 ioc_err(ioc, "failure at %s:%d/%s()!\n",
10522 __FILE__, __LINE__, __func__);
b65f1d4d 10523 rv = -ENODEV;
f92363d1
SR		 10524 goto out_attach_fail;
10525 }
7786ab6a 10526
7786ab6a
SR		 10527 if (ioc->is_warpdrive) {
10528 if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS)
10529 ioc->hide_drives = 0;
10530 else if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_HIDE_ALL_DISKS)
10531 ioc->hide_drives = 1;
10532 else {
c84b06a4 10533 if (mpt3sas_get_num_volumes(ioc))
7786ab6a
SR		 10534 ioc->hide_drives = 1;
10535 else
10536 ioc->hide_drives = 0;
10537 }
10538 } else
10539 ioc->hide_drives = 0;
7786ab6a 10540
b65f1d4d
SR		 10541 rv = scsi_add_host(shost, &pdev->dev);
10542 if (rv) {
919d8a3f
JP		 10543 ioc_err(ioc, "failure at %s:%d/%s()!\n",
10544 __FILE__, __LINE__, __func__);
4dc06fd8
RS		 10545 goto out_add_shost_fail;
10546 }
10547
f92363d1
SR		 10548 scsi_scan_host(shost);
10549 return 0;
4dc06fd8
RS		 10550out_add_shost_fail:
10551 mpt3sas_base_detach(ioc);
f92363d1
SR		 10552 out_attach_fail:
10553 destroy_workqueue(ioc->firmware_event_thread);
10554 out_thread_fail:
08c4d550 10555 spin_lock(&gioc_lock);
f92363d1 10556 list_del(&ioc->list);
08c4d550 10557 spin_unlock(&gioc_lock);
f92363d1 10558 scsi_host_put(shost);
b65f1d4d 10559 return rv;
f92363d1
SR		 10560}
10561
10562#ifdef CONFIG_PM
10563/**
8a7e4c24 10564 * scsih_suspend - power management suspend main entry point
f92363d1
SR		 10565 * @pdev: PCI device struct
10566 * @state: PM state change to (usually PCI_D3)
10567 *
4beb4867 10568 * Return: 0 success, anything else error.
f92363d1 10569 */
8bbb1cf6 10570static int
8a7e4c24 10571scsih_suspend(struct pci_dev *pdev, pm_message_t state)
f92363d1
SR		 10572{
10573 struct Scsi_Host *shost = pci_get_drvdata(pdev);
10574 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10575 pci_power_t device_state;
10576
10577 mpt3sas_base_stop_watchdog(ioc);
10578 flush_scheduled_work();
10579 scsi_block_requests(shost);
10580 device_state = pci_choose_state(pdev, state);
919d8a3f
JP		 10581 ioc_info(ioc, "pdev=0x%p, slot=%s, entering operating state [D%d]\n",
10582 pdev, pci_name(pdev), device_state);
f92363d1
SR		 10583
10584 pci_save_state(pdev);
10585 mpt3sas_base_free_resources(ioc);
10586 pci_set_power_state(pdev, device_state);
10587 return 0;
10588}
10589
10590/**
8a7e4c24 10591 * scsih_resume - power management resume main entry point
f92363d1
SR		 10592 * @pdev: PCI device struct
10593 *
4beb4867 10594 * Return: 0 success, anything else error.
f92363d1 10595 */
8bbb1cf6 10596static int
8a7e4c24 10597scsih_resume(struct pci_dev *pdev)
f92363d1
SR		 10598{
10599 struct Scsi_Host *shost = pci_get_drvdata(pdev);
10600 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10601 pci_power_t device_state = pdev->current_state;
10602 int r;
10603
919d8a3f
JP		 10604 ioc_info(ioc, "pdev=0x%p, slot=%s, previous operating state [D%d]\n",
10605 pdev, pci_name(pdev), device_state);
f92363d1
SR		 10606
10607 pci_set_power_state(pdev, PCI_D0);
10608 pci_enable_wake(pdev, PCI_D0, 0);
10609 pci_restore_state(pdev);
10610 ioc->pdev = pdev;
10611 r = mpt3sas_base_map_resources(ioc);
10612 if (r)
10613 return r;
10614
98c56ad3 10615 mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET);
f92363d1
SR		 10616 scsi_unblock_requests(shost);
10617 mpt3sas_base_start_watchdog(ioc);
10618 return 0;
10619}
10620#endif /* CONFIG_PM */
10621
10622/**
8a7e4c24 10623 * scsih_pci_error_detected - Called when a PCI error is detected.
f92363d1
SR		 10624 * @pdev: PCI device struct
10625 * @state: PCI channel state
10626 *
10627 * Description: Called when a PCI error is detected.
10628 *
4beb4867 10629 * Return: PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT.
f92363d1 10630 */
8bbb1cf6 10631static pci_ers_result_t
8a7e4c24 10632scsih_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
f92363d1
SR		 10633{
10634 struct Scsi_Host *shost = pci_get_drvdata(pdev);
10635 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10636
919d8a3f 10637 ioc_info(ioc, "PCI error: detected callback, state(%d)!!\n", state);
f92363d1
SR		 10638
10639 switch (state) {
10640 case pci_channel_io_normal:
10641 return PCI_ERS_RESULT_CAN_RECOVER;
10642 case pci_channel_io_frozen:
10643 /* Fatal error, prepare for slot reset */
10644 ioc->pci_error_recovery = 1;
10645 scsi_block_requests(ioc->shost);
10646 mpt3sas_base_stop_watchdog(ioc);
10647 mpt3sas_base_free_resources(ioc);
10648 return PCI_ERS_RESULT_NEED_RESET;
10649 case pci_channel_io_perm_failure:
10650 /* Permanent error, prepare for device removal */
10651 ioc->pci_error_recovery = 1;
10652 mpt3sas_base_stop_watchdog(ioc);
10653 _scsih_flush_running_cmds(ioc);
10654 return PCI_ERS_RESULT_DISCONNECT;
10655 }
10656 return PCI_ERS_RESULT_NEED_RESET;
10657}
10658
10659/**
8a7e4c24 10660 * scsih_pci_slot_reset - Called when PCI slot has been reset.
f92363d1
SR		 10661 * @pdev: PCI device struct
10662 *
10663 * Description: This routine is called by the pci error recovery
10664 * code after the PCI slot has been reset, just before we
10665 * should resume normal operations.
10666 */
8bbb1cf6 10667static pci_ers_result_t
8a7e4c24 10668scsih_pci_slot_reset(struct pci_dev *pdev)
f92363d1
SR		 10669{
10670 struct Scsi_Host *shost = pci_get_drvdata(pdev);
10671 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10672 int rc;
10673
919d8a3f 10674 ioc_info(ioc, "PCI error: slot reset callback!!\n");
f92363d1
SR		 10675
10676 ioc->pci_error_recovery = 0;
10677 ioc->pdev = pdev;
10678 pci_restore_state(pdev);
10679 rc = mpt3sas_base_map_resources(ioc);
10680 if (rc)
10681 return PCI_ERS_RESULT_DISCONNECT;
10682
98c56ad3 10683 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
f92363d1 10684
919d8a3f
JP		 10685 ioc_warn(ioc, "hard reset: %s\n",
10686 (rc == 0) ? "success" : "failed");
f92363d1
SR		 10687
10688 if (!rc)
10689 return PCI_ERS_RESULT_RECOVERED;
10690 else
10691 return PCI_ERS_RESULT_DISCONNECT;
10692}
10693
10694/**
8a7e4c24 10695 * scsih_pci_resume() - resume normal ops after PCI reset
f92363d1
SR		 10696 * @pdev: pointer to PCI device
10697 *
10698 * Called when the error recovery driver tells us that its
10699 * OK to resume normal operation. Use completion to allow
10700 * halted scsi ops to resume.
10701 */
8bbb1cf6 10702static void
8a7e4c24 10703scsih_pci_resume(struct pci_dev *pdev)
f92363d1
SR		 10704{
10705 struct Scsi_Host *shost = pci_get_drvdata(pdev);
10706 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10707
919d8a3f 10708 ioc_info(ioc, "PCI error: resume callback!!\n");
f92363d1 10709
f92363d1
SR		 10710 mpt3sas_base_start_watchdog(ioc);
10711 scsi_unblock_requests(ioc->shost);
10712}
10713
10714/**
8a7e4c24 10715 * scsih_pci_mmio_enabled - Enable MMIO and dump debug registers
f92363d1
SR		 10716 * @pdev: pointer to PCI device
10717 */
8bbb1cf6 10718static pci_ers_result_t
8a7e4c24 10719scsih_pci_mmio_enabled(struct pci_dev *pdev)
f92363d1
SR		 10720{
10721 struct Scsi_Host *shost = pci_get_drvdata(pdev);
10722 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10723
919d8a3f 10724 ioc_info(ioc, "PCI error: mmio enabled callback!!\n");
f92363d1
SR		 10725
10726 /* TODO - dump whatever for debugging purposes */
10727
83c3d340
KW		 10728 /* This called only if scsih_pci_error_detected returns
10729 * PCI_ERS_RESULT_CAN_RECOVER. Read/write to the device still
10730 * works, no need to reset slot.
10731 */
10732 return PCI_ERS_RESULT_RECOVERED;
f92363d1
SR		 10733}
10734
307d9075
AM		 10735/**
10736 * scsih__ncq_prio_supp - Check for NCQ command priority support
10737 * @sdev: scsi device struct
10738 *
10739 * This is called when a user indicates they would like to enable
10740 * ncq command priorities. This works only on SATA devices.
10741 */
10742bool scsih_ncq_prio_supp(struct scsi_device *sdev)
10743{
10744 unsigned char *buf;
10745 bool ncq_prio_supp = false;
10746
10747 if (!scsi_device_supports_vpd(sdev))
10748 return ncq_prio_supp;
10749
10750 buf = kmalloc(SCSI_VPD_PG_LEN, GFP_KERNEL);
10751 if (!buf)
10752 return ncq_prio_supp;
10753
10754 if (!scsi_get_vpd_page(sdev, 0x89, buf, SCSI_VPD_PG_LEN))
10755 ncq_prio_supp = (buf[213] >> 4) & 1;
10756
10757 kfree(buf);
10758 return ncq_prio_supp;
10759}
c84b06a4
SR		 10760/*
10761 * The pci device ids are defined in mpi/mpi2_cnfg.h.
10762 */
10763static const struct pci_device_id mpt3sas_pci_table[] = {
10764 /* Spitfire ~ 2004 */
10765 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2004,
10766 PCI_ANY_ID, PCI_ANY_ID },
10767 /* Falcon ~ 2008 */
10768 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2008,
10769 PCI_ANY_ID, PCI_ANY_ID },
10770 /* Liberator ~ 2108 */
10771 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_1,
10772 PCI_ANY_ID, PCI_ANY_ID },
10773 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_2,
10774 PCI_ANY_ID, PCI_ANY_ID },
10775 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3,
10776 PCI_ANY_ID, PCI_ANY_ID },
10777 /* Meteor ~ 2116 */
10778 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1,
10779 PCI_ANY_ID, PCI_ANY_ID },
10780 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2,
10781 PCI_ANY_ID, PCI_ANY_ID },
10782 /* Thunderbolt ~ 2208 */
10783 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1,
10784 PCI_ANY_ID, PCI_ANY_ID },
10785 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2,
10786 PCI_ANY_ID, PCI_ANY_ID },
10787 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3,
10788 PCI_ANY_ID, PCI_ANY_ID },
10789 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4,
10790 PCI_ANY_ID, PCI_ANY_ID },
10791 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5,
10792 PCI_ANY_ID, PCI_ANY_ID },
10793 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6,
10794 PCI_ANY_ID, PCI_ANY_ID },
10795 /* Mustang ~ 2308 */
10796 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_1,
10797 PCI_ANY_ID, PCI_ANY_ID },
10798 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_2,
10799 PCI_ANY_ID, PCI_ANY_ID },
10800 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3,
10801 PCI_ANY_ID, PCI_ANY_ID },
1244790d 10802 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP,
c520691b 10803 PCI_ANY_ID, PCI_ANY_ID },
8f838450
SP		 10804 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1,
10805 PCI_ANY_ID, PCI_ANY_ID },
c84b06a4
SR		 10806 /* SSS6200 */
10807 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200,
10808 PCI_ANY_ID, PCI_ANY_ID },
10809 /* Fury ~ 3004 and 3008 */
10810 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3004,
10811 PCI_ANY_ID, PCI_ANY_ID },
10812 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3008,
10813 PCI_ANY_ID, PCI_ANY_ID },
10814 /* Invader ~ 3108 */
10815 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_1,
10816 PCI_ANY_ID, PCI_ANY_ID },
10817 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_2,
10818 PCI_ANY_ID, PCI_ANY_ID },
10819 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_5,
10820 PCI_ANY_ID, PCI_ANY_ID },
10821 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_6,
10822 PCI_ANY_ID, PCI_ANY_ID },
b130b0d5
SS		 10823 /* Cutlass ~ 3216 and 3224 */
10824 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3216,
10825 PCI_ANY_ID, PCI_ANY_ID },
10826 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3224,
10827 PCI_ANY_ID, PCI_ANY_ID },
10828 /* Intruder ~ 3316 and 3324 */
10829 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_1,
10830 PCI_ANY_ID, PCI_ANY_ID },
10831 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_2,
10832 PCI_ANY_ID, PCI_ANY_ID },
10833 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_3,
10834 PCI_ANY_ID, PCI_ANY_ID },
10835 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_4,
10836 PCI_ANY_ID, PCI_ANY_ID },
10837 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_1,
10838 PCI_ANY_ID, PCI_ANY_ID },
10839 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_2,
10840 PCI_ANY_ID, PCI_ANY_ID },
10841 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_3,
10842 PCI_ANY_ID, PCI_ANY_ID },
10843 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_4,
10844 PCI_ANY_ID, PCI_ANY_ID },
998f26ae
SPS		 10845 /* Ventura, Crusader, Harpoon & Tomcat ~ 3516, 3416, 3508 & 3408*/
10846 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508,
10847 PCI_ANY_ID, PCI_ANY_ID },
10848 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508_1,
10849 PCI_ANY_ID, PCI_ANY_ID },
10850 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3408,
10851 PCI_ANY_ID, PCI_ANY_ID },
10852 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516,
10853 PCI_ANY_ID, PCI_ANY_ID },
10854 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516_1,
10855 PCI_ANY_ID, PCI_ANY_ID },
10856 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3416,
10857 PCI_ANY_ID, PCI_ANY_ID },
15fd7c74
SR		 10858 /* Mercator ~ 3616*/
10859 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3616,
10860 PCI_ANY_ID, PCI_ANY_ID },
6c2938f7
SP		 10861
10862 /* Aero SI 0x00E1 Configurable Secure
10863 * 0x00E2 Hard Secure
10864 */
10865 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_CFG_SEC_3916,
10866 PCI_ANY_ID, PCI_ANY_ID },
10867 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_HARD_SEC_3916,
10868 PCI_ANY_ID, PCI_ANY_ID },
10869
eb9c7ce5
SP		 10870 /* Atlas PCIe Switch Management Port */
10871 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_ATLAS_PCIe_SWITCH_DEVID,
10872 PCI_ANY_ID, PCI_ANY_ID },
10873
6c2938f7
SP		 10874 /* Sea SI 0x00E5 Configurable Secure
10875 * 0x00E6 Hard Secure
10876 */
10877 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_CFG_SEC_3816,
10878 PCI_ANY_ID, PCI_ANY_ID },
10879 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_HARD_SEC_3816,
10880 PCI_ANY_ID, PCI_ANY_ID },
10881
c84b06a4
SR		 10882 {0} /* Terminating entry */
10883};
10884MODULE_DEVICE_TABLE(pci, mpt3sas_pci_table);
10885
10886static struct pci_error_handlers _mpt3sas_err_handler = {
10887 .error_detected = scsih_pci_error_detected,
10888 .mmio_enabled = scsih_pci_mmio_enabled,
10889 .slot_reset = scsih_pci_slot_reset,
10890 .resume = scsih_pci_resume,
10891};
10892
10893static struct pci_driver mpt3sas_driver = {
10894 .name = MPT3SAS_DRIVER_NAME,
10895 .id_table = mpt3sas_pci_table,
10896 .probe = _scsih_probe,
10897 .remove = scsih_remove,
10898 .shutdown = scsih_shutdown,
10899 .err_handler = &_mpt3sas_err_handler,
10900#ifdef CONFIG_PM
10901 .suspend = scsih_suspend,
10902 .resume = scsih_resume,
10903#endif
10904};
10905
f92363d1 10906/**
8a7e4c24 10907 * scsih_init - main entry point for this driver.
f92363d1 10908 *
4beb4867 10909 * Return: 0 success, anything else error.
f92363d1 10910 */
8bbb1cf6 10911static int
8a7e4c24 10912scsih_init(void)
f92363d1 10913{
c84b06a4
SR		 10914 mpt2_ids = 0;
10915 mpt3_ids = 0;
f92363d1 10916
f92363d1
SR		 10917 mpt3sas_base_initialize_callback_handler();
10918
10919 /* queuecommand callback hander */
10920 scsi_io_cb_idx = mpt3sas_base_register_callback_handler(_scsih_io_done);
10921
6c7abffc 10922 /* task management callback handler */
f92363d1
SR		 10923 tm_cb_idx = mpt3sas_base_register_callback_handler(_scsih_tm_done);
10924
10925 /* base internal commands callback handler */
10926 base_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_base_done);
10927 port_enable_cb_idx = mpt3sas_base_register_callback_handler(
10928 mpt3sas_port_enable_done);
10929
10930 /* transport internal commands callback handler */
10931 transport_cb_idx = mpt3sas_base_register_callback_handler(
10932 mpt3sas_transport_done);
10933
10934 /* scsih internal commands callback handler */
10935 scsih_cb_idx = mpt3sas_base_register_callback_handler(_scsih_done);
10936
10937 /* configuration page API internal commands callback handler */
10938 config_cb_idx = mpt3sas_base_register_callback_handler(
10939 mpt3sas_config_done);
10940
10941 /* ctl module callback handler */
10942 ctl_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_ctl_done);
10943
10944 tm_tr_cb_idx = mpt3sas_base_register_callback_handler(
10945 _scsih_tm_tr_complete);
10946
10947 tm_tr_volume_cb_idx = mpt3sas_base_register_callback_handler(
10948 _scsih_tm_volume_tr_complete);
10949
10950 tm_sas_control_cb_idx = mpt3sas_base_register_callback_handler(
10951 _scsih_sas_control_complete);
10952
7497392a 10953 return 0;
f92363d1
SR		 10954}
10955
10956/**
7497392a 10957 * scsih_exit - exit point for this driver (when it is a module).
f92363d1 10958 *
4beb4867 10959 * Return: 0 success, anything else error.
f92363d1 10960 */
8bbb1cf6 10961static void
8a7e4c24 10962scsih_exit(void)
f92363d1 10963{
f92363d1
SR		 10964
10965 mpt3sas_base_release_callback_handler(scsi_io_cb_idx);
10966 mpt3sas_base_release_callback_handler(tm_cb_idx);
10967 mpt3sas_base_release_callback_handler(base_cb_idx);
10968 mpt3sas_base_release_callback_handler(port_enable_cb_idx);
10969 mpt3sas_base_release_callback_handler(transport_cb_idx);
10970 mpt3sas_base_release_callback_handler(scsih_cb_idx);
10971 mpt3sas_base_release_callback_handler(config_cb_idx);
10972 mpt3sas_base_release_callback_handler(ctl_cb_idx);
10973
10974 mpt3sas_base_release_callback_handler(tm_tr_cb_idx);
10975 mpt3sas_base_release_callback_handler(tm_tr_volume_cb_idx);
10976 mpt3sas_base_release_callback_handler(tm_sas_control_cb_idx);
10977
10978/* raid transport support */
c84b06a4
SR		 10979 if (hbas_to_enumerate != 1)
10980 raid_class_release(mpt3sas_raid_template);
10981 if (hbas_to_enumerate != 2)
10982 raid_class_release(mpt2sas_raid_template);
f92363d1
SR		 10983 sas_release_transport(mpt3sas_transport_template);
10984}
7786ab6a 10985
c84b06a4
SR		 10986/**
10987 * _mpt3sas_init - main entry point for this driver.
10988 *
4beb4867 10989 * Return: 0 success, anything else error.
c84b06a4
SR		 10990 */
10991static int __init
10992_mpt3sas_init(void)
10993{
10994 int error;
10995
10996 pr_info("%s version %s loaded\n", MPT3SAS_DRIVER_NAME,
10997 MPT3SAS_DRIVER_VERSION);
10998
10999 mpt3sas_transport_template =
11000 sas_attach_transport(&mpt3sas_transport_functions);
11001 if (!mpt3sas_transport_template)
11002 return -ENODEV;
11003
11004 /* No need attach mpt3sas raid functions template
11005 * if hbas_to_enumarate value is one.
11006 */
11007 if (hbas_to_enumerate != 1) {
11008 mpt3sas_raid_template =
11009 raid_class_attach(&mpt3sas_raid_functions);
11010 if (!mpt3sas_raid_template) {
11011 sas_release_transport(mpt3sas_transport_template);
11012 return -ENODEV;
11013 }
11014 }
11015
11016 /* No need to attach mpt2sas raid functions template
11017 * if hbas_to_enumarate value is two
11018 */
11019 if (hbas_to_enumerate != 2) {
11020 mpt2sas_raid_template =
11021 raid_class_attach(&mpt2sas_raid_functions);
11022 if (!mpt2sas_raid_template) {
11023 sas_release_transport(mpt3sas_transport_template);
11024 return -ENODEV;
11025 }
11026 }
11027
11028 error = scsih_init();
11029 if (error) {
11030 scsih_exit();
11031 return error;
11032 }
11033
11034 mpt3sas_ctl_init(hbas_to_enumerate);
11035
11036 error = pci_register_driver(&mpt3sas_driver);
11037 if (error)
11038 scsih_exit();
11039
11040 return error;
11041}
11042
11043/**
11044 * _mpt3sas_exit - exit point for this driver (when it is a module).
11045 *
11046 */
11047static void __exit
11048_mpt3sas_exit(void)
11049{
11050 pr_info("mpt3sas version %s unloading\n",
11051 MPT3SAS_DRIVER_VERSION);
11052
c84b06a4
SR		 11053 mpt3sas_ctl_exit(hbas_to_enumerate);
11054
87b3576e
C		 11055 pci_unregister_driver(&mpt3sas_driver);
11056
c84b06a4
SR		 11057 scsih_exit();
11058}
11059
11060module_init(_mpt3sas_init);
11061module_exit(_mpt3sas_exit);
Linux 6.x block layer and io_uring tree(s)