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