]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/scsi/mpt3sas/mpt3sas_scsih.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'armsoc-late' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc
[mirror_ubuntu-bionic-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>
54#include <linux/interrupt.h>
55#include <linux/aer.h>
56#include <linux/raid_class.h>
57
58#include "mpt3sas_base.h"
59
60MODULE_AUTHOR(MPT3SAS_AUTHOR);
61MODULE_DESCRIPTION(MPT3SAS_DESCRIPTION);
62MODULE_LICENSE("GPL");
63MODULE_VERSION(MPT3SAS_DRIVER_VERSION);
64
65#define RAID_CHANNEL 1
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);
75
76static u8 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid);
77
78static void _scsih_scan_start(struct Scsi_Host *shost);
79static int _scsih_scan_finished(struct Scsi_Host *shost, unsigned long time);
80
81/* global parameters */
82LIST_HEAD(mpt3sas_ioc_list);
83
84/* local parameters */
85static u8 scsi_io_cb_idx = -1;
86static u8 tm_cb_idx = -1;
87static u8 ctl_cb_idx = -1;
88static u8 base_cb_idx = -1;
89static u8 port_enable_cb_idx = -1;
90static u8 transport_cb_idx = -1;
91static u8 scsih_cb_idx = -1;
92static u8 config_cb_idx = -1;
93static int mpt_ids;
94
95static u8 tm_tr_cb_idx = -1 ;
96static u8 tm_tr_volume_cb_idx = -1 ;
97static u8 tm_sas_control_cb_idx = -1;
98
99/* command line options */
100static u32 logging_level;
101MODULE_PARM_DESC(logging_level,
102 " bits for enabling additional logging info (default=0)");
103
104
105static ushort max_sectors = 0xFFFF;
106module_param(max_sectors, ushort, 0);
107MODULE_PARM_DESC(max_sectors, "max sectors, range 64 to 32767 default=32767");
108
109
110static int missing_delay[2] = {-1, -1};
111module_param_array(missing_delay, int, NULL, 0);
112MODULE_PARM_DESC(missing_delay, " device missing delay , io missing delay");
113
114/* scsi-mid layer global parmeter is max_report_luns, which is 511 */
115#define MPT3SAS_MAX_LUN (16895)
1abf635d
HR		 116static u64 max_lun = MPT3SAS_MAX_LUN;
117module_param(max_lun, ullong, 0);
f92363d1
SR		 118MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
119
120
121
122
123/* diag_buffer_enable is bitwise
124 * bit 0 set = TRACE
125 * bit 1 set = SNAPSHOT
126 * bit 2 set = EXTENDED
127 *
128 * Either bit can be set, or both
129 */
130static int diag_buffer_enable = -1;
131module_param(diag_buffer_enable, int, 0);
132MODULE_PARM_DESC(diag_buffer_enable,
133 " post diag buffers (TRACE=1/SNAPSHOT=2/EXTENDED=4/default=0)");
134static int disable_discovery = -1;
135module_param(disable_discovery, int, 0);
136MODULE_PARM_DESC(disable_discovery, " disable discovery ");
137
138
139/* permit overriding the host protection capabilities mask (EEDP/T10 PI) */
140static int prot_mask = -1;
141module_param(prot_mask, int, 0);
142MODULE_PARM_DESC(prot_mask, " host protection capabilities mask, def=7 ");
143
144
145/* raid transport support */
146
147static struct raid_template *mpt3sas_raid_template;
148
149
150/**
151 * struct sense_info - common structure for obtaining sense keys
152 * @skey: sense key
153 * @asc: additional sense code
154 * @ascq: additional sense code qualifier
155 */
156struct sense_info {
157 u8 skey;
158 u8 asc;
159 u8 ascq;
160};
161
162#define MPT3SAS_PROCESS_TRIGGER_DIAG (0xFFFB)
0f624c39 163#define MPT3SAS_TURN_ON_PFA_LED (0xFFFC)
f92363d1
SR		 164#define MPT3SAS_PORT_ENABLE_COMPLETE (0xFFFD)
165#define MPT3SAS_ABRT_TASK_SET (0xFFFE)
166#define MPT3SAS_REMOVE_UNRESPONDING_DEVICES (0xFFFF)
167/**
168 * struct fw_event_work - firmware event struct
169 * @list: link list framework
170 * @work: work object (ioc->fault_reset_work_q)
171 * @cancel_pending_work: flag set during reset handling
172 * @ioc: per adapter object
173 * @device_handle: device handle
174 * @VF_ID: virtual function id
175 * @VP_ID: virtual port id
176 * @ignore: flag meaning this event has been marked to ignore
177 * @event: firmware event MPI2_EVENT_XXX defined in mpt2_ioc.h
178 * @event_data: reply event data payload follows
179 *
180 * This object stored on ioc->fw_event_list.
181 */
182struct fw_event_work {
183 struct list_head list;
184 struct work_struct work;
185 u8 cancel_pending_work;
186 struct delayed_work delayed_work;
187
188 struct MPT3SAS_ADAPTER *ioc;
189 u16 device_handle;
190 u8 VF_ID;
191 u8 VP_ID;
192 u8 ignore;
193 u16 event;
35b62362 194 char event_data[0] __aligned(4);
f92363d1
SR		 195};
196
197/* raid transport support */
198static struct raid_template *mpt3sas_raid_template;
199
200/**
201 * struct _scsi_io_transfer - scsi io transfer
202 * @handle: sas device handle (assigned by firmware)
203 * @is_raid: flag set for hidden raid components
204 * @dir: DMA_TO_DEVICE, DMA_FROM_DEVICE,
205 * @data_length: data transfer length
206 * @data_dma: dma pointer to data
207 * @sense: sense data
208 * @lun: lun number
209 * @cdb_length: cdb length
210 * @cdb: cdb contents
211 * @timeout: timeout for this command
212 * @VF_ID: virtual function id
213 * @VP_ID: virtual port id
214 * @valid_reply: flag set for reply message
215 * @sense_length: sense length
216 * @ioc_status: ioc status
217 * @scsi_state: scsi state
218 * @scsi_status: scsi staus
219 * @log_info: log information
220 * @transfer_length: data length transfer when there is a reply message
221 *
222 * Used for sending internal scsi commands to devices within this module.
223 * Refer to _scsi_send_scsi_io().
224 */
225struct _scsi_io_transfer {
226 u16 handle;
227 u8 is_raid;
228 enum dma_data_direction dir;
229 u32 data_length;
230 dma_addr_t data_dma;
231 u8 sense[SCSI_SENSE_BUFFERSIZE];
232 u32 lun;
233 u8 cdb_length;
234 u8 cdb[32];
235 u8 timeout;
236 u8 VF_ID;
237 u8 VP_ID;
238 u8 valid_reply;
239 /* the following bits are only valid when 'valid_reply = 1' */
240 u32 sense_length;
241 u16 ioc_status;
242 u8 scsi_state;
243 u8 scsi_status;
244 u32 log_info;
245 u32 transfer_length;
246};
247
248/*
249 * The pci device ids are defined in mpi/mpi2_cnfg.h.
250 */
9baa3c34 251static const struct pci_device_id scsih_pci_table[] = {
f92363d1
SR		 252 /* Fury ~ 3004 and 3008 */
253 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3004,
254 PCI_ANY_ID, PCI_ANY_ID },
255 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3008,
256 PCI_ANY_ID, PCI_ANY_ID },
257 /* Invader ~ 3108 */
258 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_1,
259 PCI_ANY_ID, PCI_ANY_ID },
260 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_2,
261 PCI_ANY_ID, PCI_ANY_ID },
262 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_5,
263 PCI_ANY_ID, PCI_ANY_ID },
264 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_6,
265 PCI_ANY_ID, PCI_ANY_ID },
266 {0} /* Terminating entry */
267};
268MODULE_DEVICE_TABLE(pci, scsih_pci_table);
269
270/**
271 * _scsih_set_debug_level - global setting of ioc->logging_level.
272 *
273 * Note: The logging levels are defined in mpt3sas_debug.h.
274 */
275static int
276_scsih_set_debug_level(const char *val, struct kernel_param *kp)
277{
278 int ret = param_set_int(val, kp);
279 struct MPT3SAS_ADAPTER *ioc;
280
281 if (ret)
282 return ret;
283
284 pr_info("setting logging_level(0x%08x)\n", logging_level);
285 list_for_each_entry(ioc, &mpt3sas_ioc_list, list)
286 ioc->logging_level = logging_level;
287 return 0;
288}
289module_param_call(logging_level, _scsih_set_debug_level, param_get_int,
290 &logging_level, 0644);
291
292/**
293 * _scsih_srch_boot_sas_address - search based on sas_address
294 * @sas_address: sas address
295 * @boot_device: boot device object from bios page 2
296 *
297 * Returns 1 when there's a match, 0 means no match.
298 */
299static inline int
300_scsih_srch_boot_sas_address(u64 sas_address,
301 Mpi2BootDeviceSasWwid_t *boot_device)
302{
303 return (sas_address == le64_to_cpu(boot_device->SASAddress)) ? 1 : 0;
304}
305
306/**
307 * _scsih_srch_boot_device_name - search based on device name
308 * @device_name: device name specified in INDENTIFY fram
309 * @boot_device: boot device object from bios page 2
310 *
311 * Returns 1 when there's a match, 0 means no match.
312 */
313static inline int
314_scsih_srch_boot_device_name(u64 device_name,
315 Mpi2BootDeviceDeviceName_t *boot_device)
316{
317 return (device_name == le64_to_cpu(boot_device->DeviceName)) ? 1 : 0;
318}
319
320/**
321 * _scsih_srch_boot_encl_slot - search based on enclosure_logical_id/slot
322 * @enclosure_logical_id: enclosure logical id
323 * @slot_number: slot number
324 * @boot_device: boot device object from bios page 2
325 *
326 * Returns 1 when there's a match, 0 means no match.
327 */
328static inline int
329_scsih_srch_boot_encl_slot(u64 enclosure_logical_id, u16 slot_number,
330 Mpi2BootDeviceEnclosureSlot_t *boot_device)
331{
332 return (enclosure_logical_id == le64_to_cpu(boot_device->
333 EnclosureLogicalID) && slot_number == le16_to_cpu(boot_device->
334 SlotNumber)) ? 1 : 0;
335}
336
337/**
338 * _scsih_is_boot_device - search for matching boot device.
339 * @sas_address: sas address
340 * @device_name: device name specified in INDENTIFY fram
341 * @enclosure_logical_id: enclosure logical id
342 * @slot_number: slot number
343 * @form: specifies boot device form
344 * @boot_device: boot device object from bios page 2
345 *
346 * Returns 1 when there's a match, 0 means no match.
347 */
348static int
349_scsih_is_boot_device(u64 sas_address, u64 device_name,
350 u64 enclosure_logical_id, u16 slot, u8 form,
351 Mpi2BiosPage2BootDevice_t *boot_device)
352{
353 int rc = 0;
354
355 switch (form) {
356 case MPI2_BIOSPAGE2_FORM_SAS_WWID:
357 if (!sas_address)
358 break;
359 rc = _scsih_srch_boot_sas_address(
360 sas_address, &boot_device->SasWwid);
361 break;
362 case MPI2_BIOSPAGE2_FORM_ENCLOSURE_SLOT:
363 if (!enclosure_logical_id)
364 break;
365 rc = _scsih_srch_boot_encl_slot(
366 enclosure_logical_id,
367 slot, &boot_device->EnclosureSlot);
368 break;
369 case MPI2_BIOSPAGE2_FORM_DEVICE_NAME:
370 if (!device_name)
371 break;
372 rc = _scsih_srch_boot_device_name(
373 device_name, &boot_device->DeviceName);
374 break;
375 case MPI2_BIOSPAGE2_FORM_NO_DEVICE_SPECIFIED:
376 break;
377 }
378
379 return rc;
380}
381
382/**
383 * _scsih_get_sas_address - set the sas_address for given device handle
384 * @handle: device handle
385 * @sas_address: sas address
386 *
387 * Returns 0 success, non-zero when failure
388 */
389static int
390_scsih_get_sas_address(struct MPT3SAS_ADAPTER *ioc, u16 handle,
391 u64 *sas_address)
392{
393 Mpi2SasDevicePage0_t sas_device_pg0;
394 Mpi2ConfigReply_t mpi_reply;
395 u32 ioc_status;
396
397 *sas_address = 0;
398
399 if (handle <= ioc->sas_hba.num_phys) {
400 *sas_address = ioc->sas_hba.sas_address;
401 return 0;
402 }
403
404 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
405 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
406 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
407 __FILE__, __LINE__, __func__);
408 return -ENXIO;
409 }
410
411 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
412 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
413 *sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
414 return 0;
415 }
416
417 /* we hit this becuase the given parent handle doesn't exist */
418 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
419 return -ENXIO;
420
421 /* else error case */
422 pr_err(MPT3SAS_FMT
423 "handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n",
424 ioc->name, handle, ioc_status,
425 __FILE__, __LINE__, __func__);
426 return -EIO;
427}
428
429/**
430 * _scsih_determine_boot_device - determine boot device.
431 * @ioc: per adapter object
432 * @device: either sas_device or raid_device object
433 * @is_raid: [flag] 1 = raid object, 0 = sas object
434 *
435 * Determines whether this device should be first reported device to
436 * to scsi-ml or sas transport, this purpose is for persistent boot device.
437 * There are primary, alternate, and current entries in bios page 2. The order
438 * priority is primary, alternate, then current. This routine saves
439 * the corresponding device object and is_raid flag in the ioc object.
440 * The saved data to be used later in _scsih_probe_boot_devices().
441 */
442static void
443_scsih_determine_boot_device(struct MPT3SAS_ADAPTER *ioc,
444 void *device, u8 is_raid)
445{
446 struct _sas_device *sas_device;
447 struct _raid_device *raid_device;
448 u64 sas_address;
449 u64 device_name;
450 u64 enclosure_logical_id;
451 u16 slot;
452
453 /* only process this function when driver loads */
454 if (!ioc->is_driver_loading)
455 return;
456
457 /* no Bios, return immediately */
458 if (!ioc->bios_pg3.BiosVersion)
459 return;
460
461 if (!is_raid) {
462 sas_device = device;
463 sas_address = sas_device->sas_address;
464 device_name = sas_device->device_name;
465 enclosure_logical_id = sas_device->enclosure_logical_id;
466 slot = sas_device->slot;
467 } else {
468 raid_device = device;
469 sas_address = raid_device->wwid;
470 device_name = 0;
471 enclosure_logical_id = 0;
472 slot = 0;
473 }
474
475 if (!ioc->req_boot_device.device) {
476 if (_scsih_is_boot_device(sas_address, device_name,
477 enclosure_logical_id, slot,
478 (ioc->bios_pg2.ReqBootDeviceForm &
479 MPI2_BIOSPAGE2_FORM_MASK),
480 &ioc->bios_pg2.RequestedBootDevice)) {
481 dinitprintk(ioc, pr_info(MPT3SAS_FMT
482 "%s: req_boot_device(0x%016llx)\n",
483 ioc->name, __func__,
484 (unsigned long long)sas_address));
485 ioc->req_boot_device.device = device;
486 ioc->req_boot_device.is_raid = is_raid;
487 }
488 }
489
490 if (!ioc->req_alt_boot_device.device) {
491 if (_scsih_is_boot_device(sas_address, device_name,
492 enclosure_logical_id, slot,
493 (ioc->bios_pg2.ReqAltBootDeviceForm &
494 MPI2_BIOSPAGE2_FORM_MASK),
495 &ioc->bios_pg2.RequestedAltBootDevice)) {
496 dinitprintk(ioc, pr_info(MPT3SAS_FMT
497 "%s: req_alt_boot_device(0x%016llx)\n",
498 ioc->name, __func__,
499 (unsigned long long)sas_address));
500 ioc->req_alt_boot_device.device = device;
501 ioc->req_alt_boot_device.is_raid = is_raid;
502 }
503 }
504
505 if (!ioc->current_boot_device.device) {
506 if (_scsih_is_boot_device(sas_address, device_name,
507 enclosure_logical_id, slot,
508 (ioc->bios_pg2.CurrentBootDeviceForm &
509 MPI2_BIOSPAGE2_FORM_MASK),
510 &ioc->bios_pg2.CurrentBootDevice)) {
511 dinitprintk(ioc, pr_info(MPT3SAS_FMT
512 "%s: current_boot_device(0x%016llx)\n",
513 ioc->name, __func__,
514 (unsigned long long)sas_address));
515 ioc->current_boot_device.device = device;
516 ioc->current_boot_device.is_raid = is_raid;
517 }
518 }
519}
520
521/**
522 * mpt3sas_scsih_sas_device_find_by_sas_address - sas device search
523 * @ioc: per adapter object
524 * @sas_address: sas address
525 * Context: Calling function should acquire ioc->sas_device_lock
526 *
527 * This searches for sas_device based on sas_address, then return sas_device
528 * object.
529 */
530struct _sas_device *
531mpt3sas_scsih_sas_device_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
532 u64 sas_address)
533{
534 struct _sas_device *sas_device;
535
536 list_for_each_entry(sas_device, &ioc->sas_device_list, list)
537 if (sas_device->sas_address == sas_address)
538 return sas_device;
539
540 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
541 if (sas_device->sas_address == sas_address)
542 return sas_device;
543
544 return NULL;
545}
546
547/**
548 * _scsih_sas_device_find_by_handle - sas device search
549 * @ioc: per adapter object
550 * @handle: sas device handle (assigned by firmware)
551 * Context: Calling function should acquire ioc->sas_device_lock
552 *
553 * This searches for sas_device based on sas_address, then return sas_device
554 * object.
555 */
556static struct _sas_device *
557_scsih_sas_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
558{
559 struct _sas_device *sas_device;
560
561 list_for_each_entry(sas_device, &ioc->sas_device_list, list)
562 if (sas_device->handle == handle)
563 return sas_device;
564
565 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
566 if (sas_device->handle == handle)
567 return sas_device;
568
569 return NULL;
570}
571
572/**
573 * _scsih_sas_device_remove - remove sas_device from list.
574 * @ioc: per adapter object
575 * @sas_device: the sas_device object
576 * Context: This function will acquire ioc->sas_device_lock.
577 *
578 * Removing object and freeing associated memory from the ioc->sas_device_list.
579 */
580static void
581_scsih_sas_device_remove(struct MPT3SAS_ADAPTER *ioc,
582 struct _sas_device *sas_device)
583{
584 unsigned long flags;
585
586 if (!sas_device)
587 return;
588
589 spin_lock_irqsave(&ioc->sas_device_lock, flags);
590 list_del(&sas_device->list);
591 kfree(sas_device);
592 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
593}
594
595/**
596 * _scsih_device_remove_by_handle - removing device object by handle
597 * @ioc: per adapter object
598 * @handle: device handle
599 *
600 * Return nothing.
601 */
602static void
603_scsih_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
604{
605 struct _sas_device *sas_device;
606 unsigned long flags;
607
608 if (ioc->shost_recovery)
609 return;
610
611 spin_lock_irqsave(&ioc->sas_device_lock, flags);
612 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
613 if (sas_device)
614 list_del(&sas_device->list);
615 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
616 if (sas_device)
617 _scsih_remove_device(ioc, sas_device);
618}
619
620/**
621 * mpt3sas_device_remove_by_sas_address - removing device object by sas address
622 * @ioc: per adapter object
623 * @sas_address: device sas_address
624 *
625 * Return nothing.
626 */
627void
628mpt3sas_device_remove_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
629 u64 sas_address)
630{
631 struct _sas_device *sas_device;
632 unsigned long flags;
633
634 if (ioc->shost_recovery)
635 return;
636
637 spin_lock_irqsave(&ioc->sas_device_lock, flags);
638 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
639 sas_address);
640 if (sas_device)
641 list_del(&sas_device->list);
642 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
643 if (sas_device)
644 _scsih_remove_device(ioc, sas_device);
645}
646
647/**
648 * _scsih_sas_device_add - insert sas_device to the list.
649 * @ioc: per adapter object
650 * @sas_device: the sas_device object
651 * Context: This function will acquire ioc->sas_device_lock.
652 *
653 * Adding new object to the ioc->sas_device_list.
654 */
655static void
656_scsih_sas_device_add(struct MPT3SAS_ADAPTER *ioc,
657 struct _sas_device *sas_device)
658{
659 unsigned long flags;
660
661 dewtprintk(ioc, pr_info(MPT3SAS_FMT
662 "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
663 ioc->name, __func__, sas_device->handle,
664 (unsigned long long)sas_device->sas_address));
665
666 spin_lock_irqsave(&ioc->sas_device_lock, flags);
667 list_add_tail(&sas_device->list, &ioc->sas_device_list);
668 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
669
670 if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
671 sas_device->sas_address_parent)) {
672 _scsih_sas_device_remove(ioc, sas_device);
673 } else if (!sas_device->starget) {
674 /*
675 * When asyn scanning is enabled, its not possible to remove
676 * devices while scanning is turned on due to an oops in
677 * scsi_sysfs_add_sdev()->add_device()->sysfs_addrm_start()
678 */
f5edbe77 679 if (!ioc->is_driver_loading) {
f92363d1
SR		 680 mpt3sas_transport_port_remove(ioc,
681 sas_device->sas_address,
682 sas_device->sas_address_parent);
f5edbe77
SR		 683 _scsih_sas_device_remove(ioc, sas_device);
684 }
f92363d1
SR		 685 }
686}
687
688/**
689 * _scsih_sas_device_init_add - insert sas_device to the list.
690 * @ioc: per adapter object
691 * @sas_device: the sas_device object
692 * Context: This function will acquire ioc->sas_device_lock.
693 *
694 * Adding new object at driver load time to the ioc->sas_device_init_list.
695 */
696static void
697_scsih_sas_device_init_add(struct MPT3SAS_ADAPTER *ioc,
698 struct _sas_device *sas_device)
699{
700 unsigned long flags;
701
702 dewtprintk(ioc, pr_info(MPT3SAS_FMT
703 "%s: handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name,
704 __func__, sas_device->handle,
705 (unsigned long long)sas_device->sas_address));
706
707 spin_lock_irqsave(&ioc->sas_device_lock, flags);
708 list_add_tail(&sas_device->list, &ioc->sas_device_init_list);
709 _scsih_determine_boot_device(ioc, sas_device, 0);
710 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
711}
712
713/**
714 * _scsih_raid_device_find_by_id - raid device search
715 * @ioc: per adapter object
716 * @id: sas device target id
717 * @channel: sas device channel
718 * Context: Calling function should acquire ioc->raid_device_lock
719 *
720 * This searches for raid_device based on target id, then return raid_device
721 * object.
722 */
723static struct _raid_device *
724_scsih_raid_device_find_by_id(struct MPT3SAS_ADAPTER *ioc, int id, int channel)
725{
726 struct _raid_device *raid_device, *r;
727
728 r = NULL;
729 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
730 if (raid_device->id == id && raid_device->channel == channel) {
731 r = raid_device;
732 goto out;
733 }
734 }
735
736 out:
737 return r;
738}
739
740/**
741 * _scsih_raid_device_find_by_handle - raid device search
742 * @ioc: per adapter object
743 * @handle: sas device handle (assigned by firmware)
744 * Context: Calling function should acquire ioc->raid_device_lock
745 *
746 * This searches for raid_device based on handle, then return raid_device
747 * object.
748 */
749static struct _raid_device *
750_scsih_raid_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
751{
752 struct _raid_device *raid_device, *r;
753
754 r = NULL;
755 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
756 if (raid_device->handle != handle)
757 continue;
758 r = raid_device;
759 goto out;
760 }
761
762 out:
763 return r;
764}
765
766/**
767 * _scsih_raid_device_find_by_wwid - raid device search
768 * @ioc: per adapter object
769 * @handle: sas device handle (assigned by firmware)
770 * Context: Calling function should acquire ioc->raid_device_lock
771 *
772 * This searches for raid_device based on wwid, then return raid_device
773 * object.
774 */
775static struct _raid_device *
776_scsih_raid_device_find_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
777{
778 struct _raid_device *raid_device, *r;
779
780 r = NULL;
781 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
782 if (raid_device->wwid != wwid)
783 continue;
784 r = raid_device;
785 goto out;
786 }
787
788 out:
789 return r;
790}
791
792/**
793 * _scsih_raid_device_add - add raid_device object
794 * @ioc: per adapter object
795 * @raid_device: raid_device object
796 *
797 * This is added to the raid_device_list link list.
798 */
799static void
800_scsih_raid_device_add(struct MPT3SAS_ADAPTER *ioc,
801 struct _raid_device *raid_device)
802{
803 unsigned long flags;
804
805 dewtprintk(ioc, pr_info(MPT3SAS_FMT
806 "%s: handle(0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
807 raid_device->handle, (unsigned long long)raid_device->wwid));
808
809 spin_lock_irqsave(&ioc->raid_device_lock, flags);
810 list_add_tail(&raid_device->list, &ioc->raid_device_list);
811 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
812}
813
814/**
815 * _scsih_raid_device_remove - delete raid_device object
816 * @ioc: per adapter object
817 * @raid_device: raid_device object
818 *
819 */
820static void
821_scsih_raid_device_remove(struct MPT3SAS_ADAPTER *ioc,
822 struct _raid_device *raid_device)
823{
824 unsigned long flags;
825
826 spin_lock_irqsave(&ioc->raid_device_lock, flags);
827 list_del(&raid_device->list);
828 kfree(raid_device);
829 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
830}
831
832/**
833 * mpt3sas_scsih_expander_find_by_handle - expander device search
834 * @ioc: per adapter object
835 * @handle: expander handle (assigned by firmware)
836 * Context: Calling function should acquire ioc->sas_device_lock
837 *
838 * This searches for expander device based on handle, then returns the
839 * sas_node object.
840 */
841struct _sas_node *
842mpt3sas_scsih_expander_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
843{
844 struct _sas_node *sas_expander, *r;
845
846 r = NULL;
847 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
848 if (sas_expander->handle != handle)
849 continue;
850 r = sas_expander;
851 goto out;
852 }
853 out:
854 return r;
855}
856
857/**
858 * mpt3sas_scsih_expander_find_by_sas_address - expander device search
859 * @ioc: per adapter object
860 * @sas_address: sas address
861 * Context: Calling function should acquire ioc->sas_node_lock.
862 *
863 * This searches for expander device based on sas_address, then returns the
864 * sas_node object.
865 */
866struct _sas_node *
867mpt3sas_scsih_expander_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
868 u64 sas_address)
869{
870 struct _sas_node *sas_expander, *r;
871
872 r = NULL;
873 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
874 if (sas_expander->sas_address != sas_address)
875 continue;
876 r = sas_expander;
877 goto out;
878 }
879 out:
880 return r;
881}
882
883/**
884 * _scsih_expander_node_add - insert expander device to the list.
885 * @ioc: per adapter object
886 * @sas_expander: the sas_device object
887 * Context: This function will acquire ioc->sas_node_lock.
888 *
889 * Adding new object to the ioc->sas_expander_list.
890 *
891 * Return nothing.
892 */
893static void
894_scsih_expander_node_add(struct MPT3SAS_ADAPTER *ioc,
895 struct _sas_node *sas_expander)
896{
897 unsigned long flags;
898
899 spin_lock_irqsave(&ioc->sas_node_lock, flags);
900 list_add_tail(&sas_expander->list, &ioc->sas_expander_list);
901 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
902}
903
904/**
905 * _scsih_is_end_device - determines if device is an end device
906 * @device_info: bitfield providing information about the device.
907 * Context: none
908 *
909 * Returns 1 if end device.
910 */
911static int
912_scsih_is_end_device(u32 device_info)
913{
914 if (device_info & MPI2_SAS_DEVICE_INFO_END_DEVICE &&
915 ((device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) |
916 (device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET) |
917 (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)))
918 return 1;
919 else
920 return 0;
921}
922
923/**
924 * _scsih_scsi_lookup_get - returns scmd entry
925 * @ioc: per adapter object
926 * @smid: system request message index
927 *
928 * Returns the smid stored scmd pointer.
929 */
930static struct scsi_cmnd *
931_scsih_scsi_lookup_get(struct MPT3SAS_ADAPTER *ioc, u16 smid)
932{
933 return ioc->scsi_lookup[smid - 1].scmd;
934}
935
936/**
937 * _scsih_scsi_lookup_get_clear - returns scmd entry
938 * @ioc: per adapter object
939 * @smid: system request message index
940 *
941 * Returns the smid stored scmd pointer.
942 * Then will derefrence the stored scmd pointer.
943 */
944static inline struct scsi_cmnd *
945_scsih_scsi_lookup_get_clear(struct MPT3SAS_ADAPTER *ioc, u16 smid)
946{
947 unsigned long flags;
948 struct scsi_cmnd *scmd;
949
950 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
951 scmd = ioc->scsi_lookup[smid - 1].scmd;
952 ioc->scsi_lookup[smid - 1].scmd = NULL;
953 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
954
955 return scmd;
956}
957
958/**
959 * _scsih_scsi_lookup_find_by_scmd - scmd lookup
960 * @ioc: per adapter object
961 * @smid: system request message index
962 * @scmd: pointer to scsi command object
963 * Context: This function will acquire ioc->scsi_lookup_lock.
964 *
965 * This will search for a scmd pointer in the scsi_lookup array,
966 * returning the revelent smid. A returned value of zero means invalid.
967 */
968static u16
969_scsih_scsi_lookup_find_by_scmd(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd
970 *scmd)
971{
972 u16 smid;
973 unsigned long flags;
974 int i;
975
976 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
977 smid = 0;
978 for (i = 0; i < ioc->scsiio_depth; i++) {
979 if (ioc->scsi_lookup[i].scmd == scmd) {
980 smid = ioc->scsi_lookup[i].smid;
981 goto out;
982 }
983 }
984 out:
985 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
986 return smid;
987}
988
989/**
990 * _scsih_scsi_lookup_find_by_target - search for matching channel:id
991 * @ioc: per adapter object
992 * @id: target id
993 * @channel: channel
994 * Context: This function will acquire ioc->scsi_lookup_lock.
995 *
996 * This will search for a matching channel:id in the scsi_lookup array,
997 * returning 1 if found.
998 */
999static u8
1000_scsih_scsi_lookup_find_by_target(struct MPT3SAS_ADAPTER *ioc, int id,
1001 int channel)
1002{
1003 u8 found;
1004 unsigned long flags;
1005 int i;
1006
1007 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1008 found = 0;
1009 for (i = 0 ; i < ioc->scsiio_depth; i++) {
1010 if (ioc->scsi_lookup[i].scmd &&
1011 (ioc->scsi_lookup[i].scmd->device->id == id &&
1012 ioc->scsi_lookup[i].scmd->device->channel == channel)) {
1013 found = 1;
1014 goto out;
1015 }
1016 }
1017 out:
1018 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1019 return found;
1020}
1021
1022/**
1023 * _scsih_scsi_lookup_find_by_lun - search for matching channel:id:lun
1024 * @ioc: per adapter object
1025 * @id: target id
1026 * @lun: lun number
1027 * @channel: channel
1028 * Context: This function will acquire ioc->scsi_lookup_lock.
1029 *
1030 * This will search for a matching channel:id:lun in the scsi_lookup array,
1031 * returning 1 if found.
1032 */
1033static u8
1034_scsih_scsi_lookup_find_by_lun(struct MPT3SAS_ADAPTER *ioc, int id,
1035 unsigned int lun, int channel)
1036{
1037 u8 found;
1038 unsigned long flags;
1039 int i;
1040
1041 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1042 found = 0;
1043 for (i = 0 ; i < ioc->scsiio_depth; i++) {
1044 if (ioc->scsi_lookup[i].scmd &&
1045 (ioc->scsi_lookup[i].scmd->device->id == id &&
1046 ioc->scsi_lookup[i].scmd->device->channel == channel &&
1047 ioc->scsi_lookup[i].scmd->device->lun == lun)) {
1048 found = 1;
1049 goto out;
1050 }
1051 }
1052 out:
1053 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1054 return found;
1055}
1056
cf75d5d6
CH		 1057/**
1058 * _scsih_change_queue_depth - setting device queue depth
1059 * @sdev: scsi device struct
1060 * @qdepth: requested queue depth
1061 *
1062 * Returns queue depth.
1063 */
1064static int
1065_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
f92363d1
SR		 1066{
1067 struct Scsi_Host *shost = sdev->host;
1068 int max_depth;
1069 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1070 struct MPT3SAS_DEVICE *sas_device_priv_data;
1071 struct MPT3SAS_TARGET *sas_target_priv_data;
1072 struct _sas_device *sas_device;
1073 unsigned long flags;
1074
1075 max_depth = shost->can_queue;
1076
1077 /* limit max device queue for SATA to 32 */
1078 sas_device_priv_data = sdev->hostdata;
1079 if (!sas_device_priv_data)
1080 goto not_sata;
1081 sas_target_priv_data = sas_device_priv_data->sas_target;
1082 if (!sas_target_priv_data)
1083 goto not_sata;
1084 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))
1085 goto not_sata;
1086 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1087 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
1088 sas_device_priv_data->sas_target->sas_address);
1089 if (sas_device && sas_device->device_info &
1090 MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
1091 max_depth = MPT3SAS_SATA_QUEUE_DEPTH;
1092 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1093
1094 not_sata:
1095
1096 if (!sdev->tagged_supported)
1097 max_depth = 1;
1098 if (qdepth > max_depth)
1099 qdepth = max_depth;
cf75d5d6 1100 return scsi_change_queue_depth(sdev, qdepth);
f92363d1
SR		 1101}
1102
f92363d1
SR		 1103/**
1104 * _scsih_target_alloc - target add routine
1105 * @starget: scsi target struct
1106 *
1107 * Returns 0 if ok. Any other return is assumed to be an error and
1108 * the device is ignored.
1109 */
1110static int
1111_scsih_target_alloc(struct scsi_target *starget)
1112{
1113 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1114 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1115 struct MPT3SAS_TARGET *sas_target_priv_data;
1116 struct _sas_device *sas_device;
1117 struct _raid_device *raid_device;
1118 unsigned long flags;
1119 struct sas_rphy *rphy;
1120
62c4da44
JL		 1121 sas_target_priv_data = kzalloc(sizeof(*sas_target_priv_data),
1122 GFP_KERNEL);
f92363d1
SR		 1123 if (!sas_target_priv_data)
1124 return -ENOMEM;
1125
1126 starget->hostdata = sas_target_priv_data;
1127 sas_target_priv_data->starget = starget;
1128 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
1129
1130 /* RAID volumes */
1131 if (starget->channel == RAID_CHANNEL) {
1132 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1133 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1134 starget->channel);
1135 if (raid_device) {
1136 sas_target_priv_data->handle = raid_device->handle;
1137 sas_target_priv_data->sas_address = raid_device->wwid;
1138 sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME;
1139 raid_device->starget = starget;
1140 }
1141 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1142 return 0;
1143 }
1144
1145 /* sas/sata devices */
1146 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1147 rphy = dev_to_rphy(starget->dev.parent);
1148 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
1149 rphy->identify.sas_address);
1150
1151 if (sas_device) {
1152 sas_target_priv_data->handle = sas_device->handle;
1153 sas_target_priv_data->sas_address = sas_device->sas_address;
1154 sas_device->starget = starget;
1155 sas_device->id = starget->id;
1156 sas_device->channel = starget->channel;
1157 if (test_bit(sas_device->handle, ioc->pd_handles))
1158 sas_target_priv_data->flags |=
1159 MPT_TARGET_FLAGS_RAID_COMPONENT;
1160 if (sas_device->fast_path)
1161 sas_target_priv_data->flags |= MPT_TARGET_FASTPATH_IO;
1162 }
1163 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1164
1165 return 0;
1166}
1167
1168/**
1169 * _scsih_target_destroy - target destroy routine
1170 * @starget: scsi target struct
1171 *
1172 * Returns nothing.
1173 */
1174static void
1175_scsih_target_destroy(struct scsi_target *starget)
1176{
1177 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1178 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1179 struct MPT3SAS_TARGET *sas_target_priv_data;
1180 struct _sas_device *sas_device;
1181 struct _raid_device *raid_device;
1182 unsigned long flags;
1183 struct sas_rphy *rphy;
1184
1185 sas_target_priv_data = starget->hostdata;
1186 if (!sas_target_priv_data)
1187 return;
1188
1189 if (starget->channel == RAID_CHANNEL) {
1190 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1191 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1192 starget->channel);
1193 if (raid_device) {
1194 raid_device->starget = NULL;
1195 raid_device->sdev = NULL;
1196 }
1197 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1198 goto out;
1199 }
1200
1201 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1202 rphy = dev_to_rphy(starget->dev.parent);
1203 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
1204 rphy->identify.sas_address);
1205 if (sas_device && (sas_device->starget == starget) &&
1206 (sas_device->id == starget->id) &&
1207 (sas_device->channel == starget->channel))
1208 sas_device->starget = NULL;
1209
1210 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1211
1212 out:
1213 kfree(sas_target_priv_data);
1214 starget->hostdata = NULL;
1215}
1216
1217/**
1218 * _scsih_slave_alloc - device add routine
1219 * @sdev: scsi device struct
1220 *
1221 * Returns 0 if ok. Any other return is assumed to be an error and
1222 * the device is ignored.
1223 */
1224static int
1225_scsih_slave_alloc(struct scsi_device *sdev)
1226{
1227 struct Scsi_Host *shost;
1228 struct MPT3SAS_ADAPTER *ioc;
1229 struct MPT3SAS_TARGET *sas_target_priv_data;
1230 struct MPT3SAS_DEVICE *sas_device_priv_data;
1231 struct scsi_target *starget;
1232 struct _raid_device *raid_device;
b65cfedf 1233 struct _sas_device *sas_device;
f92363d1
SR		 1234 unsigned long flags;
1235
62c4da44
JL		 1236 sas_device_priv_data = kzalloc(sizeof(*sas_device_priv_data),
1237 GFP_KERNEL);
f92363d1
SR		 1238 if (!sas_device_priv_data)
1239 return -ENOMEM;
1240
1241 sas_device_priv_data->lun = sdev->lun;
1242 sas_device_priv_data->flags = MPT_DEVICE_FLAGS_INIT;
1243
1244 starget = scsi_target(sdev);
1245 sas_target_priv_data = starget->hostdata;
1246 sas_target_priv_data->num_luns++;
1247 sas_device_priv_data->sas_target = sas_target_priv_data;
1248 sdev->hostdata = sas_device_priv_data;
1249 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT))
1250 sdev->no_uld_attach = 1;
1251
1252 shost = dev_to_shost(&starget->dev);
1253 ioc = shost_priv(shost);
1254 if (starget->channel == RAID_CHANNEL) {
1255 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1256 raid_device = _scsih_raid_device_find_by_id(ioc,
1257 starget->id, starget->channel);
1258 if (raid_device)
1259 raid_device->sdev = sdev; /* raid is single lun */
1260 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1261 }
1262
b65cfedf
SR		 1263 if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
1264 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1265 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
1266 sas_target_priv_data->sas_address);
1267 if (sas_device && (sas_device->starget == NULL)) {
1268 sdev_printk(KERN_INFO, sdev,
1269 "%s : sas_device->starget set to starget @ %d\n",
1270 __func__, __LINE__);
1271 sas_device->starget = starget;
1272 }
1273 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1274 }
1275
f92363d1
SR		 1276 return 0;
1277}
1278
1279/**
1280 * _scsih_slave_destroy - device destroy routine
1281 * @sdev: scsi device struct
1282 *
1283 * Returns nothing.
1284 */
1285static void
1286_scsih_slave_destroy(struct scsi_device *sdev)
1287{
1288 struct MPT3SAS_TARGET *sas_target_priv_data;
1289 struct scsi_target *starget;
1290 struct Scsi_Host *shost;
1291 struct MPT3SAS_ADAPTER *ioc;
1292 struct _sas_device *sas_device;
1293 unsigned long flags;
1294
1295 if (!sdev->hostdata)
1296 return;
1297
1298 starget = scsi_target(sdev);
1299 sas_target_priv_data = starget->hostdata;
1300 sas_target_priv_data->num_luns--;
1301
1302 shost = dev_to_shost(&starget->dev);
1303 ioc = shost_priv(shost);
1304
1305 if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
1306 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1307 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
1308 sas_target_priv_data->sas_address);
1309 if (sas_device && !sas_target_priv_data->num_luns)
1310 sas_device->starget = NULL;
1311 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1312 }
1313
1314 kfree(sdev->hostdata);
1315 sdev->hostdata = NULL;
1316}
1317
1318/**
1319 * _scsih_display_sata_capabilities - sata capabilities
1320 * @ioc: per adapter object
1321 * @handle: device handle
1322 * @sdev: scsi device struct
1323 */
1324static void
1325_scsih_display_sata_capabilities(struct MPT3SAS_ADAPTER *ioc,
1326 u16 handle, struct scsi_device *sdev)
1327{
1328 Mpi2ConfigReply_t mpi_reply;
1329 Mpi2SasDevicePage0_t sas_device_pg0;
1330 u32 ioc_status;
1331 u16 flags;
1332 u32 device_info;
1333
1334 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
1335 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
1336 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1337 ioc->name, __FILE__, __LINE__, __func__);
1338 return;
1339 }
1340
1341 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1342 MPI2_IOCSTATUS_MASK;
1343 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1344 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1345 ioc->name, __FILE__, __LINE__, __func__);
1346 return;
1347 }
1348
1349 flags = le16_to_cpu(sas_device_pg0.Flags);
1350 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
1351
1352 sdev_printk(KERN_INFO, sdev,
1353 "atapi(%s), ncq(%s), asyn_notify(%s), smart(%s), fua(%s), "
1354 "sw_preserve(%s)\n",
1355 (device_info & MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? "y" : "n",
1356 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_NCQ_SUPPORTED) ? "y" : "n",
1357 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_ASYNCHRONOUS_NOTIFY) ? "y" :
1358 "n",
1359 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SMART_SUPPORTED) ? "y" : "n",
1360 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_FUA_SUPPORTED) ? "y" : "n",
1361 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SW_PRESERVE) ? "y" : "n");
1362}
1363
1364/*
1365 * raid transport support -
1366 * Enabled for SLES11 and newer, in older kernels the driver will panic when
1367 * unloading the driver followed by a load - I beleive that the subroutine
1368 * raid_class_release() is not cleaning up properly.
1369 */
1370
1371/**
1372 * _scsih_is_raid - return boolean indicating device is raid volume
1373 * @dev the device struct object
1374 */
1375static int
1376_scsih_is_raid(struct device *dev)
1377{
1378 struct scsi_device *sdev = to_scsi_device(dev);
1379
1380 return (sdev->channel == RAID_CHANNEL) ? 1 : 0;
1381}
1382
1383/**
1384 * _scsih_get_resync - get raid volume resync percent complete
1385 * @dev the device struct object
1386 */
1387static void
1388_scsih_get_resync(struct device *dev)
1389{
1390 struct scsi_device *sdev = to_scsi_device(dev);
1391 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
1392 static struct _raid_device *raid_device;
1393 unsigned long flags;
1394 Mpi2RaidVolPage0_t vol_pg0;
1395 Mpi2ConfigReply_t mpi_reply;
1396 u32 volume_status_flags;
1397 u8 percent_complete;
1398 u16 handle;
1399
1400 percent_complete = 0;
1401 handle = 0;
1402 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1403 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1404 sdev->channel);
1405 if (raid_device) {
1406 handle = raid_device->handle;
1407 percent_complete = raid_device->percent_complete;
1408 }
1409 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1410
1411 if (!handle)
1412 goto out;
1413
1414 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1415 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
1416 sizeof(Mpi2RaidVolPage0_t))) {
1417 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1418 ioc->name, __FILE__, __LINE__, __func__);
1419 percent_complete = 0;
1420 goto out;
1421 }
1422
1423 volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags);
1424 if (!(volume_status_flags &
1425 MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS))
1426 percent_complete = 0;
1427
1428 out:
1429 raid_set_resync(mpt3sas_raid_template, dev, percent_complete);
1430}
1431
1432/**
1433 * _scsih_get_state - get raid volume level
1434 * @dev the device struct object
1435 */
1436static void
1437_scsih_get_state(struct device *dev)
1438{
1439 struct scsi_device *sdev = to_scsi_device(dev);
1440 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
1441 static struct _raid_device *raid_device;
1442 unsigned long flags;
1443 Mpi2RaidVolPage0_t vol_pg0;
1444 Mpi2ConfigReply_t mpi_reply;
1445 u32 volstate;
1446 enum raid_state state = RAID_STATE_UNKNOWN;
1447 u16 handle = 0;
1448
1449 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1450 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1451 sdev->channel);
1452 if (raid_device)
1453 handle = raid_device->handle;
1454 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1455
1456 if (!raid_device)
1457 goto out;
1458
1459 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1460 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
1461 sizeof(Mpi2RaidVolPage0_t))) {
1462 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1463 ioc->name, __FILE__, __LINE__, __func__);
1464 goto out;
1465 }
1466
1467 volstate = le32_to_cpu(vol_pg0.VolumeStatusFlags);
1468 if (volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) {
1469 state = RAID_STATE_RESYNCING;
1470 goto out;
1471 }
1472
1473 switch (vol_pg0.VolumeState) {
1474 case MPI2_RAID_VOL_STATE_OPTIMAL:
1475 case MPI2_RAID_VOL_STATE_ONLINE:
1476 state = RAID_STATE_ACTIVE;
1477 break;
1478 case MPI2_RAID_VOL_STATE_DEGRADED:
1479 state = RAID_STATE_DEGRADED;
1480 break;
1481 case MPI2_RAID_VOL_STATE_FAILED:
1482 case MPI2_RAID_VOL_STATE_MISSING:
1483 state = RAID_STATE_OFFLINE;
1484 break;
1485 }
1486 out:
1487 raid_set_state(mpt3sas_raid_template, dev, state);
1488}
1489
1490/**
1491 * _scsih_set_level - set raid level
1492 * @sdev: scsi device struct
1493 * @volume_type: volume type
1494 */
1495static void
1496_scsih_set_level(struct scsi_device *sdev, u8 volume_type)
1497{
1498 enum raid_level level = RAID_LEVEL_UNKNOWN;
1499
1500 switch (volume_type) {
1501 case MPI2_RAID_VOL_TYPE_RAID0:
1502 level = RAID_LEVEL_0;
1503 break;
1504 case MPI2_RAID_VOL_TYPE_RAID10:
1505 level = RAID_LEVEL_10;
1506 break;
1507 case MPI2_RAID_VOL_TYPE_RAID1E:
1508 level = RAID_LEVEL_1E;
1509 break;
1510 case MPI2_RAID_VOL_TYPE_RAID1:
1511 level = RAID_LEVEL_1;
1512 break;
1513 }
1514
1515 raid_set_level(mpt3sas_raid_template, &sdev->sdev_gendev, level);
1516}
1517
1518
1519/**
1520 * _scsih_get_volume_capabilities - volume capabilities
1521 * @ioc: per adapter object
1522 * @sas_device: the raid_device object
1523 *
1524 * Returns 0 for success, else 1
1525 */
1526static int
1527_scsih_get_volume_capabilities(struct MPT3SAS_ADAPTER *ioc,
1528 struct _raid_device *raid_device)
1529{
1530 Mpi2RaidVolPage0_t *vol_pg0;
1531 Mpi2RaidPhysDiskPage0_t pd_pg0;
1532 Mpi2SasDevicePage0_t sas_device_pg0;
1533 Mpi2ConfigReply_t mpi_reply;
1534 u16 sz;
1535 u8 num_pds;
1536
1537 if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle,
1538 &num_pds)) || !num_pds) {
1539 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1540 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1541 __func__));
1542 return 1;
1543 }
1544
1545 raid_device->num_pds = num_pds;
1546 sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds *
1547 sizeof(Mpi2RaidVol0PhysDisk_t));
1548 vol_pg0 = kzalloc(sz, GFP_KERNEL);
1549 if (!vol_pg0) {
1550 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1551 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1552 __func__));
1553 return 1;
1554 }
1555
1556 if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
1557 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
1558 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1559 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1560 __func__));
1561 kfree(vol_pg0);
1562 return 1;
1563 }
1564
1565 raid_device->volume_type = vol_pg0->VolumeType;
1566
1567 /* figure out what the underlying devices are by
1568 * obtaining the device_info bits for the 1st device
1569 */
1570 if (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
1571 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
1572 vol_pg0->PhysDisk[0].PhysDiskNum))) {
1573 if (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
1574 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
1575 le16_to_cpu(pd_pg0.DevHandle)))) {
1576 raid_device->device_info =
1577 le32_to_cpu(sas_device_pg0.DeviceInfo);
1578 }
1579 }
1580
1581 kfree(vol_pg0);
1582 return 0;
1583}
1584
1585
1586
1587/**
1588 * _scsih_enable_tlr - setting TLR flags
1589 * @ioc: per adapter object
1590 * @sdev: scsi device struct
1591 *
1592 * Enabling Transaction Layer Retries for tape devices when
1593 * vpd page 0x90 is present
1594 *
1595 */
1596static void
1597_scsih_enable_tlr(struct MPT3SAS_ADAPTER *ioc, struct scsi_device *sdev)
1598{
1599
1600 /* only for TAPE */
1601 if (sdev->type != TYPE_TAPE)
1602 return;
1603
1604 if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
1605 return;
1606
1607 sas_enable_tlr(sdev);
1608 sdev_printk(KERN_INFO, sdev, "TLR %s\n",
1609 sas_is_tlr_enabled(sdev) ? "Enabled" : "Disabled");
1610 return;
1611
1612}
1613
1614/**
1615 * _scsih_slave_configure - device configure routine.
1616 * @sdev: scsi device struct
1617 *
1618 * Returns 0 if ok. Any other return is assumed to be an error and
1619 * the device is ignored.
1620 */
1621static int
1622_scsih_slave_configure(struct scsi_device *sdev)
1623{
1624 struct Scsi_Host *shost = sdev->host;
1625 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1626 struct MPT3SAS_DEVICE *sas_device_priv_data;
1627 struct MPT3SAS_TARGET *sas_target_priv_data;
1628 struct _sas_device *sas_device;
1629 struct _raid_device *raid_device;
1630 unsigned long flags;
1631 int qdepth;
1632 u8 ssp_target = 0;
1633 char *ds = "";
1634 char *r_level = "";
1635 u16 handle, volume_handle = 0;
1636 u64 volume_wwid = 0;
1637
1638 qdepth = 1;
1639 sas_device_priv_data = sdev->hostdata;
1640 sas_device_priv_data->configured_lun = 1;
1641 sas_device_priv_data->flags &= ~MPT_DEVICE_FLAGS_INIT;
1642 sas_target_priv_data = sas_device_priv_data->sas_target;
1643 handle = sas_target_priv_data->handle;
1644
1645 /* raid volume handling */
1646 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME) {
1647
1648 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1649 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
1650 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1651 if (!raid_device) {
1652 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1653 "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
1654 __LINE__, __func__));
1655 return 1;
1656 }
1657
1658 if (_scsih_get_volume_capabilities(ioc, raid_device)) {
1659 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1660 "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
1661 __LINE__, __func__));
1662 return 1;
1663 }
1664
1665
1666 /* RAID Queue Depth Support
1667 * IS volume = underlying qdepth of drive type, either
1668 * MPT3SAS_SAS_QUEUE_DEPTH or MPT3SAS_SATA_QUEUE_DEPTH
1669 * IM/IME/R10 = 128 (MPT3SAS_RAID_QUEUE_DEPTH)
1670 */
1671 if (raid_device->device_info &
1672 MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
1673 qdepth = MPT3SAS_SAS_QUEUE_DEPTH;
1674 ds = "SSP";
1675 } else {
1676 qdepth = MPT3SAS_SATA_QUEUE_DEPTH;
1677 if (raid_device->device_info &
1678 MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
1679 ds = "SATA";
1680 else
1681 ds = "STP";
1682 }
1683
1684 switch (raid_device->volume_type) {
1685 case MPI2_RAID_VOL_TYPE_RAID0:
1686 r_level = "RAID0";
1687 break;
1688 case MPI2_RAID_VOL_TYPE_RAID1E:
1689 qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
1690 if (ioc->manu_pg10.OEMIdentifier &&
1691 (le32_to_cpu(ioc->manu_pg10.GenericFlags0) &
1692 MFG10_GF0_R10_DISPLAY) &&
1693 !(raid_device->num_pds % 2))
1694 r_level = "RAID10";
1695 else
1696 r_level = "RAID1E";
1697 break;
1698 case MPI2_RAID_VOL_TYPE_RAID1:
1699 qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
1700 r_level = "RAID1";
1701 break;
1702 case MPI2_RAID_VOL_TYPE_RAID10:
1703 qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
1704 r_level = "RAID10";
1705 break;
1706 case MPI2_RAID_VOL_TYPE_UNKNOWN:
1707 default:
1708 qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
1709 r_level = "RAIDX";
1710 break;
1711 }
1712
1713 sdev_printk(KERN_INFO, sdev,
1714 "%s: handle(0x%04x), wwid(0x%016llx), pd_count(%d), type(%s)\n",
1715 r_level, raid_device->handle,
1716 (unsigned long long)raid_device->wwid,
1717 raid_device->num_pds, ds);
1718
1719
db5ed4df 1720 _scsih_change_queue_depth(sdev, qdepth);
f92363d1
SR		 1721
1722/* raid transport support */
1723 _scsih_set_level(sdev, raid_device->volume_type);
1724 return 0;
1725 }
1726
1727 /* non-raid handling */
1728 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1729 if (mpt3sas_config_get_volume_handle(ioc, handle,
1730 &volume_handle)) {
1731 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1732 "failure at %s:%d/%s()!\n", ioc->name,
1733 __FILE__, __LINE__, __func__));
1734 return 1;
1735 }
1736 if (volume_handle && mpt3sas_config_get_volume_wwid(ioc,
1737 volume_handle, &volume_wwid)) {
1738 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1739 "failure at %s:%d/%s()!\n", ioc->name,
1740 __FILE__, __LINE__, __func__));
1741 return 1;
1742 }
1743 }
1744
1745 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1746 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
1747 sas_device_priv_data->sas_target->sas_address);
1748 if (!sas_device) {
1749 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1750 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1751 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1752 __func__));
1753 return 1;
1754 }
1755
1756 sas_device->volume_handle = volume_handle;
1757 sas_device->volume_wwid = volume_wwid;
1758 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
1759 qdepth = MPT3SAS_SAS_QUEUE_DEPTH;
1760 ssp_target = 1;
1761 ds = "SSP";
1762 } else {
1763 qdepth = MPT3SAS_SATA_QUEUE_DEPTH;
1764 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET)
1765 ds = "STP";
1766 else if (sas_device->device_info &
1767 MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
1768 ds = "SATA";
1769 }
1770
1771 sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), " \
1772 "sas_addr(0x%016llx), phy(%d), device_name(0x%016llx)\n",
1773 ds, handle, (unsigned long long)sas_device->sas_address,
1774 sas_device->phy, (unsigned long long)sas_device->device_name);
1775 sdev_printk(KERN_INFO, sdev,
1776 "%s: enclosure_logical_id(0x%016llx), slot(%d)\n",
1777 ds, (unsigned long long)
1778 sas_device->enclosure_logical_id, sas_device->slot);
1779
1780 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1781
1782 if (!ssp_target)
1783 _scsih_display_sata_capabilities(ioc, handle, sdev);
1784
1785
db5ed4df 1786 _scsih_change_queue_depth(sdev, qdepth);
f92363d1
SR		 1787
1788 if (ssp_target) {
1789 sas_read_port_mode_page(sdev);
1790 _scsih_enable_tlr(ioc, sdev);
1791 }
1792
1793 return 0;
1794}
1795
1796/**
1797 * _scsih_bios_param - fetch head, sector, cylinder info for a disk
1798 * @sdev: scsi device struct
1799 * @bdev: pointer to block device context
1800 * @capacity: device size (in 512 byte sectors)
1801 * @params: three element array to place output:
1802 * params[0] number of heads (max 255)
1803 * params[1] number of sectors (max 63)
1804 * params[2] number of cylinders
1805 *
1806 * Return nothing.
1807 */
1808static int
1809_scsih_bios_param(struct scsi_device *sdev, struct block_device *bdev,
1810 sector_t capacity, int params[])
1811{
1812 int heads;
1813 int sectors;
1814 sector_t cylinders;
1815 ulong dummy;
1816
1817 heads = 64;
1818 sectors = 32;
1819
1820 dummy = heads * sectors;
1821 cylinders = capacity;
1822 sector_div(cylinders, dummy);
1823
1824 /*
1825 * Handle extended translation size for logical drives
1826 * > 1Gb
1827 */
1828 if ((ulong)capacity >= 0x200000) {
1829 heads = 255;
1830 sectors = 63;
1831 dummy = heads * sectors;
1832 cylinders = capacity;
1833 sector_div(cylinders, dummy);
1834 }
1835
1836 /* return result */
1837 params[0] = heads;
1838 params[1] = sectors;
1839 params[2] = cylinders;
1840
1841 return 0;
1842}
1843
1844/**
1845 * _scsih_response_code - translation of device response code
1846 * @ioc: per adapter object
1847 * @response_code: response code returned by the device
1848 *
1849 * Return nothing.
1850 */
1851static void
1852_scsih_response_code(struct MPT3SAS_ADAPTER *ioc, u8 response_code)
1853{
1854 char *desc;
1855
1856 switch (response_code) {
1857 case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE:
1858 desc = "task management request completed";
1859 break;
1860 case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME:
1861 desc = "invalid frame";
1862 break;
1863 case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
1864 desc = "task management request not supported";
1865 break;
1866 case MPI2_SCSITASKMGMT_RSP_TM_FAILED:
1867 desc = "task management request failed";
1868 break;
1869 case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED:
1870 desc = "task management request succeeded";
1871 break;
1872 case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN:
1873 desc = "invalid lun";
1874 break;
1875 case 0xA:
1876 desc = "overlapped tag attempted";
1877 break;
1878 case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
1879 desc = "task queued, however not sent to target";
1880 break;
1881 default:
1882 desc = "unknown";
1883 break;
1884 }
1885 pr_warn(MPT3SAS_FMT "response_code(0x%01x): %s\n",
1886 ioc->name, response_code, desc);
1887}
1888
1889/**
1890 * _scsih_tm_done - tm completion routine
1891 * @ioc: per adapter object
1892 * @smid: system request message index
1893 * @msix_index: MSIX table index supplied by the OS
1894 * @reply: reply message frame(lower 32bit addr)
1895 * Context: none.
1896 *
1897 * The callback handler when using scsih_issue_tm.
1898 *
1899 * Return 1 meaning mf should be freed from _base_interrupt
1900 * 0 means the mf is freed from this function.
1901 */
1902static u8
1903_scsih_tm_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
1904{
1905 MPI2DefaultReply_t *mpi_reply;
1906
1907 if (ioc->tm_cmds.status == MPT3_CMD_NOT_USED)
1908 return 1;
1909 if (ioc->tm_cmds.smid != smid)
1910 return 1;
1911 mpt3sas_base_flush_reply_queues(ioc);
1912 ioc->tm_cmds.status |= MPT3_CMD_COMPLETE;
1913 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
1914 if (mpi_reply) {
1915 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
1916 ioc->tm_cmds.status |= MPT3_CMD_REPLY_VALID;
1917 }
1918 ioc->tm_cmds.status &= ~MPT3_CMD_PENDING;
1919 complete(&ioc->tm_cmds.done);
1920 return 1;
1921}
1922
1923/**
1924 * mpt3sas_scsih_set_tm_flag - set per target tm_busy
1925 * @ioc: per adapter object
1926 * @handle: device handle
1927 *
1928 * During taskmangement request, we need to freeze the device queue.
1929 */
1930void
1931mpt3sas_scsih_set_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1932{
1933 struct MPT3SAS_DEVICE *sas_device_priv_data;
1934 struct scsi_device *sdev;
1935 u8 skip = 0;
1936
1937 shost_for_each_device(sdev, ioc->shost) {
1938 if (skip)
1939 continue;
1940 sas_device_priv_data = sdev->hostdata;
1941 if (!sas_device_priv_data)
1942 continue;
1943 if (sas_device_priv_data->sas_target->handle == handle) {
1944 sas_device_priv_data->sas_target->tm_busy = 1;
1945 skip = 1;
1946 ioc->ignore_loginfos = 1;
1947 }
1948 }
1949}
1950
1951/**
1952 * mpt3sas_scsih_clear_tm_flag - clear per target tm_busy
1953 * @ioc: per adapter object
1954 * @handle: device handle
1955 *
1956 * During taskmangement request, we need to freeze the device queue.
1957 */
1958void
1959mpt3sas_scsih_clear_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1960{
1961 struct MPT3SAS_DEVICE *sas_device_priv_data;
1962 struct scsi_device *sdev;
1963 u8 skip = 0;
1964
1965 shost_for_each_device(sdev, ioc->shost) {
1966 if (skip)
1967 continue;
1968 sas_device_priv_data = sdev->hostdata;
1969 if (!sas_device_priv_data)
1970 continue;
1971 if (sas_device_priv_data->sas_target->handle == handle) {
1972 sas_device_priv_data->sas_target->tm_busy = 0;
1973 skip = 1;
1974 ioc->ignore_loginfos = 0;
1975 }
1976 }
1977}
1978
1979/**
1980 * mpt3sas_scsih_issue_tm - main routine for sending tm requests
1981 * @ioc: per adapter struct
1982 * @device_handle: device handle
1983 * @channel: the channel assigned by the OS
1984 * @id: the id assigned by the OS
1985 * @lun: lun number
1986 * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in mpi2_init.h)
1987 * @smid_task: smid assigned to the task
1988 * @timeout: timeout in seconds
f92363d1
SR		 1989 * @m_type: TM_MUTEX_ON or TM_MUTEX_OFF
1990 * Context: user
1991 *
1992 * A generic API for sending task management requests to firmware.
1993 *
1994 * The callback index is set inside `ioc->tm_cb_idx`.
1995 *
1996 * Return SUCCESS or FAILED.
1997 */
1998int
1999mpt3sas_scsih_issue_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle, uint channel,
2000 uint id, uint lun, u8 type, u16 smid_task, ulong timeout,
c62e46de 2001 enum mutex_type m_type)
f92363d1
SR		 2002{
2003 Mpi2SCSITaskManagementRequest_t *mpi_request;
2004 Mpi2SCSITaskManagementReply_t *mpi_reply;
2005 u16 smid = 0;
2006 u32 ioc_state;
2007 unsigned long timeleft;
2008 struct scsiio_tracker *scsi_lookup = NULL;
2009 int rc;
2010
2011 if (m_type == TM_MUTEX_ON)
2012 mutex_lock(&ioc->tm_cmds.mutex);
2013 if (ioc->tm_cmds.status != MPT3_CMD_NOT_USED) {
2014 pr_info(MPT3SAS_FMT "%s: tm_cmd busy!!!\n",
2015 __func__, ioc->name);
2016 rc = FAILED;
2017 goto err_out;
2018 }
2019
2020 if (ioc->shost_recovery || ioc->remove_host ||
2021 ioc->pci_error_recovery) {
2022 pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
2023 __func__, ioc->name);
2024 rc = FAILED;
2025 goto err_out;
2026 }
2027
2028 ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
2029 if (ioc_state & MPI2_DOORBELL_USED) {
2030 dhsprintk(ioc, pr_info(MPT3SAS_FMT
2031 "unexpected doorbell active!\n", ioc->name));
2032 rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2033 FORCE_BIG_HAMMER);
2034 rc = (!rc) ? SUCCESS : FAILED;
2035 goto err_out;
2036 }
2037
2038 if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) {
2039 mpt3sas_base_fault_info(ioc, ioc_state &
2040 MPI2_DOORBELL_DATA_MASK);
2041 rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2042 FORCE_BIG_HAMMER);
2043 rc = (!rc) ? SUCCESS : FAILED;
2044 goto err_out;
2045 }
2046
2047 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
2048 if (!smid) {
2049 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
2050 ioc->name, __func__);
2051 rc = FAILED;
2052 goto err_out;
2053 }
2054
2055 if (type == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
2056 scsi_lookup = &ioc->scsi_lookup[smid_task - 1];
2057
2058 dtmprintk(ioc, pr_info(MPT3SAS_FMT
2059 "sending tm: handle(0x%04x), task_type(0x%02x), smid(%d)\n",
2060 ioc->name, handle, type, smid_task));
2061 ioc->tm_cmds.status = MPT3_CMD_PENDING;
2062 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
2063 ioc->tm_cmds.smid = smid;
2064 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
2065 memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t));
2066 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
2067 mpi_request->DevHandle = cpu_to_le16(handle);
2068 mpi_request->TaskType = type;
2069 mpi_request->TaskMID = cpu_to_le16(smid_task);
2070 int_to_scsilun(lun, (struct scsi_lun *)mpi_request->LUN);
2071 mpt3sas_scsih_set_tm_flag(ioc, handle);
2072 init_completion(&ioc->tm_cmds.done);
2073 mpt3sas_base_put_smid_hi_priority(ioc, smid);
2074 timeleft = wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
2075 if (!(ioc->tm_cmds.status & MPT3_CMD_COMPLETE)) {
2076 pr_err(MPT3SAS_FMT "%s: timeout\n",
2077 ioc->name, __func__);
2078 _debug_dump_mf(mpi_request,
2079 sizeof(Mpi2SCSITaskManagementRequest_t)/4);
2080 if (!(ioc->tm_cmds.status & MPT3_CMD_RESET)) {
2081 rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2082 FORCE_BIG_HAMMER);
2083 rc = (!rc) ? SUCCESS : FAILED;
2084 ioc->tm_cmds.status = MPT3_CMD_NOT_USED;
2085 mpt3sas_scsih_clear_tm_flag(ioc, handle);
2086 goto err_out;
2087 }
2088 }
2089
2090 if (ioc->tm_cmds.status & MPT3_CMD_REPLY_VALID) {
2091 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
2092 mpi_reply = ioc->tm_cmds.reply;
2093 dtmprintk(ioc, pr_info(MPT3SAS_FMT "complete tm: " \
2094 "ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
2095 ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
2096 le32_to_cpu(mpi_reply->IOCLogInfo),
2097 le32_to_cpu(mpi_reply->TerminationCount)));
2098 if (ioc->logging_level & MPT_DEBUG_TM) {
2099 _scsih_response_code(ioc, mpi_reply->ResponseCode);
2100 if (mpi_reply->IOCStatus)
2101 _debug_dump_mf(mpi_request,
2102 sizeof(Mpi2SCSITaskManagementRequest_t)/4);
2103 }
2104 }
2105
2106 switch (type) {
2107 case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
2108 rc = SUCCESS;
2109 if (scsi_lookup->scmd == NULL)
2110 break;
2111 rc = FAILED;
2112 break;
2113
2114 case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
2115 if (_scsih_scsi_lookup_find_by_target(ioc, id, channel))
2116 rc = FAILED;
2117 else
2118 rc = SUCCESS;
2119 break;
2120 case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
2121 case MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET:
2122 if (_scsih_scsi_lookup_find_by_lun(ioc, id, lun, channel))
2123 rc = FAILED;
2124 else
2125 rc = SUCCESS;
2126 break;
2127 case MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK:
2128 rc = SUCCESS;
2129 break;
2130 default:
2131 rc = FAILED;
2132 break;
2133 }
2134
2135 mpt3sas_scsih_clear_tm_flag(ioc, handle);
2136 ioc->tm_cmds.status = MPT3_CMD_NOT_USED;
2137 if (m_type == TM_MUTEX_ON)
2138 mutex_unlock(&ioc->tm_cmds.mutex);
2139
2140 return rc;
2141
2142 err_out:
2143 if (m_type == TM_MUTEX_ON)
2144 mutex_unlock(&ioc->tm_cmds.mutex);
2145 return rc;
2146}
2147
2148/**
2149 * _scsih_tm_display_info - displays info about the device
2150 * @ioc: per adapter struct
2151 * @scmd: pointer to scsi command object
2152 *
2153 * Called by task management callback handlers.
2154 */
2155static void
2156_scsih_tm_display_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
2157{
2158 struct scsi_target *starget = scmd->device->sdev_target;
2159 struct MPT3SAS_TARGET *priv_target = starget->hostdata;
2160 struct _sas_device *sas_device = NULL;
2161 unsigned long flags;
2162 char *device_str = NULL;
2163
2164 if (!priv_target)
2165 return;
2166 device_str = "volume";
2167
2168 scsi_print_command(scmd);
2169 if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2170 starget_printk(KERN_INFO, starget,
2171 "%s handle(0x%04x), %s wwid(0x%016llx)\n",
2172 device_str, priv_target->handle,
2173 device_str, (unsigned long long)priv_target->sas_address);
2174 } else {
2175 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2176 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
2177 priv_target->sas_address);
2178 if (sas_device) {
2179 if (priv_target->flags &
2180 MPT_TARGET_FLAGS_RAID_COMPONENT) {
2181 starget_printk(KERN_INFO, starget,
2182 "volume handle(0x%04x), "
2183 "volume wwid(0x%016llx)\n",
2184 sas_device->volume_handle,
2185 (unsigned long long)sas_device->volume_wwid);
2186 }
2187 starget_printk(KERN_INFO, starget,
2188 "handle(0x%04x), sas_address(0x%016llx), phy(%d)\n",
2189 sas_device->handle,
2190 (unsigned long long)sas_device->sas_address,
2191 sas_device->phy);
2192 starget_printk(KERN_INFO, starget,
2193 "enclosure_logical_id(0x%016llx), slot(%d)\n",
2194 (unsigned long long)sas_device->enclosure_logical_id,
2195 sas_device->slot);
2196 }
2197 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2198 }
2199}
2200
2201/**
2202 * _scsih_abort - eh threads main abort routine
2203 * @scmd: pointer to scsi command object
2204 *
2205 * Returns SUCCESS if command aborted else FAILED
2206 */
2207static int
2208_scsih_abort(struct scsi_cmnd *scmd)
2209{
2210 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2211 struct MPT3SAS_DEVICE *sas_device_priv_data;
2212 u16 smid;
2213 u16 handle;
2214 int r;
2215
2216 sdev_printk(KERN_INFO, scmd->device,
2217 "attempting task abort! scmd(%p)\n", scmd);
2218 _scsih_tm_display_info(ioc, scmd);
2219
2220 sas_device_priv_data = scmd->device->hostdata;
2221 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2222 sdev_printk(KERN_INFO, scmd->device,
2223 "device been deleted! scmd(%p)\n", scmd);
2224 scmd->result = DID_NO_CONNECT << 16;
2225 scmd->scsi_done(scmd);
2226 r = SUCCESS;
2227 goto out;
2228 }
2229
2230 /* search for the command */
2231 smid = _scsih_scsi_lookup_find_by_scmd(ioc, scmd);
2232 if (!smid) {
2233 scmd->result = DID_RESET << 16;
2234 r = SUCCESS;
2235 goto out;
2236 }
2237
2238 /* for hidden raid components and volumes this is not supported */
2239 if (sas_device_priv_data->sas_target->flags &
2240 MPT_TARGET_FLAGS_RAID_COMPONENT ||
2241 sas_device_priv_data->sas_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2242 scmd->result = DID_RESET << 16;
2243 r = FAILED;
2244 goto out;
2245 }
2246
2247 mpt3sas_halt_firmware(ioc);
2248
2249 handle = sas_device_priv_data->sas_target->handle;
2250 r = mpt3sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2251 scmd->device->id, scmd->device->lun,
c62e46de 2252 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30, TM_MUTEX_ON);
f92363d1
SR		 2253
2254 out:
2255 sdev_printk(KERN_INFO, scmd->device, "task abort: %s scmd(%p)\n",
2256 ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2257 return r;
2258}
2259
2260/**
2261 * _scsih_dev_reset - eh threads main device reset routine
2262 * @scmd: pointer to scsi command object
2263 *
2264 * Returns SUCCESS if command aborted else FAILED
2265 */
2266static int
2267_scsih_dev_reset(struct scsi_cmnd *scmd)
2268{
2269 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2270 struct MPT3SAS_DEVICE *sas_device_priv_data;
2271 struct _sas_device *sas_device;
2272 unsigned long flags;
2273 u16 handle;
2274 int r;
2275
2276 sdev_printk(KERN_INFO, scmd->device,
2277 "attempting device reset! scmd(%p)\n", scmd);
2278 _scsih_tm_display_info(ioc, scmd);
2279
2280 sas_device_priv_data = scmd->device->hostdata;
2281 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2282 sdev_printk(KERN_INFO, scmd->device,
2283 "device been deleted! scmd(%p)\n", scmd);
2284 scmd->result = DID_NO_CONNECT << 16;
2285 scmd->scsi_done(scmd);
2286 r = SUCCESS;
2287 goto out;
2288 }
2289
2290 /* for hidden raid components obtain the volume_handle */
2291 handle = 0;
2292 if (sas_device_priv_data->sas_target->flags &
2293 MPT_TARGET_FLAGS_RAID_COMPONENT) {
2294 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2295 sas_device = _scsih_sas_device_find_by_handle(ioc,
2296 sas_device_priv_data->sas_target->handle);
2297 if (sas_device)
2298 handle = sas_device->volume_handle;
2299 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2300 } else
2301 handle = sas_device_priv_data->sas_target->handle;
2302
2303 if (!handle) {
2304 scmd->result = DID_RESET << 16;
2305 r = FAILED;
2306 goto out;
2307 }
2308
2309 r = mpt3sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2310 scmd->device->id, scmd->device->lun,
c62e46de 2311 MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, 0, 30, TM_MUTEX_ON);
f92363d1
SR		 2312
2313 out:
2314 sdev_printk(KERN_INFO, scmd->device, "device reset: %s scmd(%p)\n",
2315 ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2316 return r;
2317}
2318
2319/**
2320 * _scsih_target_reset - eh threads main target reset routine
2321 * @scmd: pointer to scsi command object
2322 *
2323 * Returns SUCCESS if command aborted else FAILED
2324 */
2325static int
2326_scsih_target_reset(struct scsi_cmnd *scmd)
2327{
2328 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2329 struct MPT3SAS_DEVICE *sas_device_priv_data;
2330 struct _sas_device *sas_device;
2331 unsigned long flags;
2332 u16 handle;
2333 int r;
2334 struct scsi_target *starget = scmd->device->sdev_target;
2335
2336 starget_printk(KERN_INFO, starget, "attempting target reset! scmd(%p)\n",
2337 scmd);
2338 _scsih_tm_display_info(ioc, scmd);
2339
2340 sas_device_priv_data = scmd->device->hostdata;
2341 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2342 starget_printk(KERN_INFO, starget, "target been deleted! scmd(%p)\n",
2343 scmd);
2344 scmd->result = DID_NO_CONNECT << 16;
2345 scmd->scsi_done(scmd);
2346 r = SUCCESS;
2347 goto out;
2348 }
2349
2350 /* for hidden raid components obtain the volume_handle */
2351 handle = 0;
2352 if (sas_device_priv_data->sas_target->flags &
2353 MPT_TARGET_FLAGS_RAID_COMPONENT) {
2354 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2355 sas_device = _scsih_sas_device_find_by_handle(ioc,
2356 sas_device_priv_data->sas_target->handle);
2357 if (sas_device)
2358 handle = sas_device->volume_handle;
2359 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2360 } else
2361 handle = sas_device_priv_data->sas_target->handle;
2362
2363 if (!handle) {
2364 scmd->result = DID_RESET << 16;
2365 r = FAILED;
2366 goto out;
2367 }
2368
2369 r = mpt3sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2370 scmd->device->id, 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0,
c62e46de 2371 30, TM_MUTEX_ON);
f92363d1
SR		 2372
2373 out:
2374 starget_printk(KERN_INFO, starget, "target reset: %s scmd(%p)\n",
2375 ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2376 return r;
2377}
2378
2379
2380/**
2381 * _scsih_host_reset - eh threads main host reset routine
2382 * @scmd: pointer to scsi command object
2383 *
2384 * Returns SUCCESS if command aborted else FAILED
2385 */
2386static int
2387_scsih_host_reset(struct scsi_cmnd *scmd)
2388{
2389 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2390 int r, retval;
2391
2392 pr_info(MPT3SAS_FMT "attempting host reset! scmd(%p)\n",
2393 ioc->name, scmd);
2394 scsi_print_command(scmd);
2395
ddb588be
SR		 2396 if (ioc->is_driver_loading) {
2397 pr_info(MPT3SAS_FMT "Blocking the host reset\n",
2398 ioc->name);
2399 r = FAILED;
2400 goto out;
2401 }
2402
f92363d1
SR		 2403 retval = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2404 FORCE_BIG_HAMMER);
2405 r = (retval < 0) ? FAILED : SUCCESS;
ddb588be 2406out:
f92363d1
SR		 2407 pr_info(MPT3SAS_FMT "host reset: %s scmd(%p)\n",
2408 ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2409
2410 return r;
2411}
2412
2413/**
2414 * _scsih_fw_event_add - insert and queue up fw_event
2415 * @ioc: per adapter object
2416 * @fw_event: object describing the event
2417 * Context: This function will acquire ioc->fw_event_lock.
2418 *
2419 * This adds the firmware event object into link list, then queues it up to
2420 * be processed from user context.
2421 *
2422 * Return nothing.
2423 */
2424static void
2425_scsih_fw_event_add(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
2426{
2427 unsigned long flags;
2428
2429 if (ioc->firmware_event_thread == NULL)
2430 return;
2431
2432 spin_lock_irqsave(&ioc->fw_event_lock, flags);
2433 INIT_LIST_HEAD(&fw_event->list);
2434 list_add_tail(&fw_event->list, &ioc->fw_event_list);
2435 INIT_WORK(&fw_event->work, _firmware_event_work);
2436 queue_work(ioc->firmware_event_thread, &fw_event->work);
2437 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2438}
2439
2440/**
2441 * _scsih_fw_event_free - delete fw_event
2442 * @ioc: per adapter object
2443 * @fw_event: object describing the event
2444 * Context: This function will acquire ioc->fw_event_lock.
2445 *
2446 * This removes firmware event object from link list, frees associated memory.
2447 *
2448 * Return nothing.
2449 */
2450static void
2451_scsih_fw_event_free(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work
2452 *fw_event)
2453{
2454 unsigned long flags;
2455
2456 spin_lock_irqsave(&ioc->fw_event_lock, flags);
2457 list_del(&fw_event->list);
f92363d1
SR		 2458 kfree(fw_event);
2459 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2460}
2461
2462
2463 /**
2464 * mpt3sas_send_trigger_data_event - send event for processing trigger data
2465 * @ioc: per adapter object
2466 * @event_data: trigger event data
2467 *
2468 * Return nothing.
2469 */
2470void
2471mpt3sas_send_trigger_data_event(struct MPT3SAS_ADAPTER *ioc,
2472 struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data)
2473{
2474 struct fw_event_work *fw_event;
2475
2476 if (ioc->is_driver_loading)
2477 return;
35b62362
JL		 2478 fw_event = kzalloc(sizeof(*fw_event) + sizeof(*event_data),
2479 GFP_ATOMIC);
f92363d1
SR		 2480 if (!fw_event)
2481 return;
f92363d1
SR		 2482 fw_event->event = MPT3SAS_PROCESS_TRIGGER_DIAG;
2483 fw_event->ioc = ioc;
2484 memcpy(fw_event->event_data, event_data, sizeof(*event_data));
2485 _scsih_fw_event_add(ioc, fw_event);
2486}
2487
2488/**
2489 * _scsih_error_recovery_delete_devices - remove devices not responding
2490 * @ioc: per adapter object
2491 *
2492 * Return nothing.
2493 */
2494static void
2495_scsih_error_recovery_delete_devices(struct MPT3SAS_ADAPTER *ioc)
2496{
2497 struct fw_event_work *fw_event;
2498
2499 if (ioc->is_driver_loading)
2500 return;
2501 fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
2502 if (!fw_event)
2503 return;
2504 fw_event->event = MPT3SAS_REMOVE_UNRESPONDING_DEVICES;
2505 fw_event->ioc = ioc;
2506 _scsih_fw_event_add(ioc, fw_event);
2507}
2508
2509/**
2510 * mpt3sas_port_enable_complete - port enable completed (fake event)
2511 * @ioc: per adapter object
2512 *
2513 * Return nothing.
2514 */
2515void
2516mpt3sas_port_enable_complete(struct MPT3SAS_ADAPTER *ioc)
2517{
2518 struct fw_event_work *fw_event;
2519
2520 fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
2521 if (!fw_event)
2522 return;
2523 fw_event->event = MPT3SAS_PORT_ENABLE_COMPLETE;
2524 fw_event->ioc = ioc;
2525 _scsih_fw_event_add(ioc, fw_event);
2526}
2527
2528/**
2529 * _scsih_fw_event_cleanup_queue - cleanup event queue
2530 * @ioc: per adapter object
2531 *
2532 * Walk the firmware event queue, either killing timers, or waiting
2533 * for outstanding events to complete
2534 *
2535 * Return nothing.
2536 */
2537static void
2538_scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc)
2539{
2540 struct fw_event_work *fw_event, *next;
2541
2542 if (list_empty(&ioc->fw_event_list) ||
2543 !ioc->firmware_event_thread || in_interrupt())
2544 return;
2545
2546 list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
4dc06fd8 2547 if (cancel_delayed_work_sync(&fw_event->delayed_work)) {
f92363d1
SR		 2548 _scsih_fw_event_free(ioc, fw_event);
2549 continue;
2550 }
f92363d1
SR		 2551 }
2552}
2553
2554/**
2555 * _scsih_ublock_io_all_device - unblock every device
2556 * @ioc: per adapter object
2557 *
2558 * change the device state from block to running
2559 */
2560static void
2561_scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc)
2562{
2563 struct MPT3SAS_DEVICE *sas_device_priv_data;
2564 struct scsi_device *sdev;
2565
2566 shost_for_each_device(sdev, ioc->shost) {
2567 sas_device_priv_data = sdev->hostdata;
2568 if (!sas_device_priv_data)
2569 continue;
2570 if (!sas_device_priv_data->block)
2571 continue;
2572
2573 sas_device_priv_data->block = 0;
2574 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
2575 "device_running, handle(0x%04x)\n",
2576 sas_device_priv_data->sas_target->handle));
2577 scsi_internal_device_unblock(sdev, SDEV_RUNNING);
2578 }
2579}
2580
2581
2582/**
2583 * _scsih_ublock_io_device - prepare device to be deleted
2584 * @ioc: per adapter object
2585 * @sas_addr: sas address
2586 *
2587 * unblock then put device in offline state
2588 */
2589static void
2590_scsih_ublock_io_device(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
2591{
2592 struct MPT3SAS_DEVICE *sas_device_priv_data;
2593 struct scsi_device *sdev;
2594
2595 shost_for_each_device(sdev, ioc->shost) {
2596 sas_device_priv_data = sdev->hostdata;
2597 if (!sas_device_priv_data)
2598 continue;
2599 if (sas_device_priv_data->sas_target->sas_address
2600 != sas_address)
2601 continue;
2602 if (sas_device_priv_data->block) {
2603 sas_device_priv_data->block = 0;
2604 scsi_internal_device_unblock(sdev, SDEV_RUNNING);
2605 }
2606 }
2607}
2608
2609/**
2610 * _scsih_block_io_all_device - set the device state to SDEV_BLOCK
2611 * @ioc: per adapter object
2612 * @handle: device handle
2613 *
2614 * During device pull we need to appropiately set the sdev state.
2615 */
2616static void
2617_scsih_block_io_all_device(struct MPT3SAS_ADAPTER *ioc)
2618{
2619 struct MPT3SAS_DEVICE *sas_device_priv_data;
2620 struct scsi_device *sdev;
2621
2622 shost_for_each_device(sdev, ioc->shost) {
2623 sas_device_priv_data = sdev->hostdata;
2624 if (!sas_device_priv_data)
2625 continue;
2626 if (sas_device_priv_data->block)
2627 continue;
2628 sas_device_priv_data->block = 1;
2629 scsi_internal_device_block(sdev);
2630 sdev_printk(KERN_INFO, sdev, "device_blocked, handle(0x%04x)\n",
2631 sas_device_priv_data->sas_target->handle);
2632 }
2633}
2634
2635/**
2636 * _scsih_block_io_device - set the device state to SDEV_BLOCK
2637 * @ioc: per adapter object
2638 * @handle: device handle
2639 *
2640 * During device pull we need to appropiately set the sdev state.
2641 */
2642static void
2643_scsih_block_io_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2644{
2645 struct MPT3SAS_DEVICE *sas_device_priv_data;
2646 struct scsi_device *sdev;
2647
2648 shost_for_each_device(sdev, ioc->shost) {
2649 sas_device_priv_data = sdev->hostdata;
2650 if (!sas_device_priv_data)
2651 continue;
2652 if (sas_device_priv_data->sas_target->handle != handle)
2653 continue;
2654 if (sas_device_priv_data->block)
2655 continue;
2656 sas_device_priv_data->block = 1;
2657 scsi_internal_device_block(sdev);
2658 sdev_printk(KERN_INFO, sdev,
2659 "device_blocked, handle(0x%04x)\n", handle);
2660 }
2661}
2662
2663/**
2664 * _scsih_block_io_to_children_attached_to_ex
2665 * @ioc: per adapter object
2666 * @sas_expander: the sas_device object
2667 *
2668 * This routine set sdev state to SDEV_BLOCK for all devices
2669 * attached to this expander. This function called when expander is
2670 * pulled.
2671 */
2672static void
2673_scsih_block_io_to_children_attached_to_ex(struct MPT3SAS_ADAPTER *ioc,
2674 struct _sas_node *sas_expander)
2675{
2676 struct _sas_port *mpt3sas_port;
2677 struct _sas_device *sas_device;
2678 struct _sas_node *expander_sibling;
2679 unsigned long flags;
2680
2681 if (!sas_expander)
2682 return;
2683
2684 list_for_each_entry(mpt3sas_port,
2685 &sas_expander->sas_port_list, port_list) {
2686 if (mpt3sas_port->remote_identify.device_type ==
2687 SAS_END_DEVICE) {
2688 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2689 sas_device =
2690 mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
2691 mpt3sas_port->remote_identify.sas_address);
2692 if (sas_device)
2693 set_bit(sas_device->handle,
2694 ioc->blocking_handles);
2695 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2696 }
2697 }
2698
2699 list_for_each_entry(mpt3sas_port,
2700 &sas_expander->sas_port_list, port_list) {
2701
2702 if (mpt3sas_port->remote_identify.device_type ==
2703 SAS_EDGE_EXPANDER_DEVICE ||
2704 mpt3sas_port->remote_identify.device_type ==
2705 SAS_FANOUT_EXPANDER_DEVICE) {
2706 expander_sibling =
2707 mpt3sas_scsih_expander_find_by_sas_address(
2708 ioc, mpt3sas_port->remote_identify.sas_address);
2709 _scsih_block_io_to_children_attached_to_ex(ioc,
2710 expander_sibling);
2711 }
2712 }
2713}
2714
2715/**
2716 * _scsih_block_io_to_children_attached_directly
2717 * @ioc: per adapter object
2718 * @event_data: topology change event data
2719 *
2720 * This routine set sdev state to SDEV_BLOCK for all devices
2721 * direct attached during device pull.
2722 */
2723static void
2724_scsih_block_io_to_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
2725 Mpi2EventDataSasTopologyChangeList_t *event_data)
2726{
2727 int i;
2728 u16 handle;
2729 u16 reason_code;
f92363d1
SR		 2730
2731 for (i = 0; i < event_data->NumEntries; i++) {
2732 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
2733 if (!handle)
2734 continue;
f92363d1
SR		 2735 reason_code = event_data->PHY[i].PhyStatus &
2736 MPI2_EVENT_SAS_TOPO_RC_MASK;
2737 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING)
2738 _scsih_block_io_device(ioc, handle);
2739 }
2740}
2741
2742/**
2743 * _scsih_tm_tr_send - send task management request
2744 * @ioc: per adapter object
2745 * @handle: device handle
2746 * Context: interrupt time.
2747 *
2748 * This code is to initiate the device removal handshake protocol
2749 * with controller firmware. This function will issue target reset
2750 * using high priority request queue. It will send a sas iounit
2751 * control request (MPI2_SAS_OP_REMOVE_DEVICE) from this completion.
2752 *
2753 * This is designed to send muliple task management request at the same
2754 * time to the fifo. If the fifo is full, we will append the request,
2755 * and process it in a future completion.
2756 */
2757static void
2758_scsih_tm_tr_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2759{
2760 Mpi2SCSITaskManagementRequest_t *mpi_request;
2761 u16 smid;
2762 struct _sas_device *sas_device;
2763 struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
2764 u64 sas_address = 0;
2765 unsigned long flags;
2766 struct _tr_list *delayed_tr;
2767 u32 ioc_state;
2768
2769 if (ioc->remove_host) {
2770 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2771 "%s: host has been removed: handle(0x%04x)\n",
2772 __func__, ioc->name, handle));
2773 return;
2774 } else if (ioc->pci_error_recovery) {
2775 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2776 "%s: host in pci error recovery: handle(0x%04x)\n",
2777 __func__, ioc->name,
2778 handle));
2779 return;
2780 }
2781 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
2782 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
2783 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2784 "%s: host is not operational: handle(0x%04x)\n",
2785 __func__, ioc->name,
2786 handle));
2787 return;
2788 }
2789
2790 /* if PD, then return */
2791 if (test_bit(handle, ioc->pd_handles))
2792 return;
2793
2794 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2795 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
2796 if (sas_device && sas_device->starget &&
2797 sas_device->starget->hostdata) {
2798 sas_target_priv_data = sas_device->starget->hostdata;
2799 sas_target_priv_data->deleted = 1;
2800 sas_address = sas_device->sas_address;
2801 }
2802 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2803
2804 if (sas_target_priv_data) {
2805 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2806 "setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n",
2807 ioc->name, handle,
2808 (unsigned long long)sas_address));
2809 _scsih_ublock_io_device(ioc, sas_address);
2810 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
2811 }
2812
2813 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
2814 if (!smid) {
2815 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
2816 if (!delayed_tr)
2817 return;
2818 INIT_LIST_HEAD(&delayed_tr->list);
2819 delayed_tr->handle = handle;
2820 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
2821 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2822 "DELAYED:tr:handle(0x%04x), (open)\n",
2823 ioc->name, handle));
2824 return;
2825 }
2826
2827 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2828 "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
2829 ioc->name, handle, smid,
2830 ioc->tm_tr_cb_idx));
2831 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
2832 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
2833 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
2834 mpi_request->DevHandle = cpu_to_le16(handle);
2835 mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
2836 mpt3sas_base_put_smid_hi_priority(ioc, smid);
2837 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_DEVICE_REMOVAL);
2838}
2839
2840/**
2841 * _scsih_tm_tr_complete -
2842 * @ioc: per adapter object
2843 * @smid: system request message index
2844 * @msix_index: MSIX table index supplied by the OS
2845 * @reply: reply message frame(lower 32bit addr)
2846 * Context: interrupt time.
2847 *
2848 * This is the target reset completion routine.
2849 * This code is part of the code to initiate the device removal
2850 * handshake protocol with controller firmware.
2851 * It will send a sas iounit control request (MPI2_SAS_OP_REMOVE_DEVICE)
2852 *
2853 * Return 1 meaning mf should be freed from _base_interrupt
2854 * 0 means the mf is freed from this function.
2855 */
2856static u8
2857_scsih_tm_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
2858 u32 reply)
2859{
2860 u16 handle;
2861 Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
2862 Mpi2SCSITaskManagementReply_t *mpi_reply =
2863 mpt3sas_base_get_reply_virt_addr(ioc, reply);
2864 Mpi2SasIoUnitControlRequest_t *mpi_request;
2865 u16 smid_sas_ctrl;
2866 u32 ioc_state;
2867
2868 if (ioc->remove_host) {
2869 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2870 "%s: host has been removed\n", __func__, ioc->name));
2871 return 1;
2872 } else if (ioc->pci_error_recovery) {
2873 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2874 "%s: host in pci error recovery\n", __func__,
2875 ioc->name));
2876 return 1;
2877 }
2878 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
2879 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
2880 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2881 "%s: host is not operational\n", __func__, ioc->name));
2882 return 1;
2883 }
2884 if (unlikely(!mpi_reply)) {
2885 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
2886 ioc->name, __FILE__, __LINE__, __func__);
2887 return 1;
2888 }
2889 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
2890 handle = le16_to_cpu(mpi_request_tm->DevHandle);
2891 if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
2892 dewtprintk(ioc, pr_err(MPT3SAS_FMT
2893 "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
2894 ioc->name, handle,
2895 le16_to_cpu(mpi_reply->DevHandle), smid));
2896 return 0;
2897 }
2898
2899 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
2900 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2901 "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
2902 "loginfo(0x%08x), completed(%d)\n", ioc->name,
2903 handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
2904 le32_to_cpu(mpi_reply->IOCLogInfo),
2905 le32_to_cpu(mpi_reply->TerminationCount)));
2906
2907 smid_sas_ctrl = mpt3sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
2908 if (!smid_sas_ctrl) {
2909 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
2910 ioc->name, __func__);
2911 return 1;
2912 }
2913
2914 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2915 "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
2916 ioc->name, handle, smid_sas_ctrl,
2917 ioc->tm_sas_control_cb_idx));
2918 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid_sas_ctrl);
2919 memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
2920 mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
2921 mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
2922 mpi_request->DevHandle = mpi_request_tm->DevHandle;
2923 mpt3sas_base_put_smid_default(ioc, smid_sas_ctrl);
2924
2925 return _scsih_check_for_pending_tm(ioc, smid);
2926}
2927
2928
2929/**
2930 * _scsih_sas_control_complete - completion routine
2931 * @ioc: per adapter object
2932 * @smid: system request message index
2933 * @msix_index: MSIX table index supplied by the OS
2934 * @reply: reply message frame(lower 32bit addr)
2935 * Context: interrupt time.
2936 *
2937 * This is the sas iounit control completion routine.
2938 * This code is part of the code to initiate the device removal
2939 * handshake protocol with controller firmware.
2940 *
2941 * Return 1 meaning mf should be freed from _base_interrupt
2942 * 0 means the mf is freed from this function.
2943 */
2944static u8
2945_scsih_sas_control_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
2946 u8 msix_index, u32 reply)
2947{
2948 Mpi2SasIoUnitControlReply_t *mpi_reply =
2949 mpt3sas_base_get_reply_virt_addr(ioc, reply);
2950
2951 if (likely(mpi_reply)) {
2952 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2953 "sc_complete:handle(0x%04x), (open) "
2954 "smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
2955 ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid,
2956 le16_to_cpu(mpi_reply->IOCStatus),
2957 le32_to_cpu(mpi_reply->IOCLogInfo)));
2958 } else {
2959 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
2960 ioc->name, __FILE__, __LINE__, __func__);
2961 }
2962 return 1;
2963}
2964
2965/**
2966 * _scsih_tm_tr_volume_send - send target reset request for volumes
2967 * @ioc: per adapter object
2968 * @handle: device handle
2969 * Context: interrupt time.
2970 *
2971 * This is designed to send muliple task management request at the same
2972 * time to the fifo. If the fifo is full, we will append the request,
2973 * and process it in a future completion.
2974 */
2975static void
2976_scsih_tm_tr_volume_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2977{
2978 Mpi2SCSITaskManagementRequest_t *mpi_request;
2979 u16 smid;
2980 struct _tr_list *delayed_tr;
2981
2982 if (ioc->shost_recovery || ioc->remove_host ||
2983 ioc->pci_error_recovery) {
2984 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2985 "%s: host reset in progress!\n",
2986 __func__, ioc->name));
2987 return;
2988 }
2989
2990 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
2991 if (!smid) {
2992 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
2993 if (!delayed_tr)
2994 return;
2995 INIT_LIST_HEAD(&delayed_tr->list);
2996 delayed_tr->handle = handle;
2997 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
2998 dewtprintk(ioc, pr_info(MPT3SAS_FMT
2999 "DELAYED:tr:handle(0x%04x), (open)\n",
3000 ioc->name, handle));
3001 return;
3002 }
3003
3004 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3005 "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
3006 ioc->name, handle, smid,
3007 ioc->tm_tr_volume_cb_idx));
3008 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3009 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3010 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3011 mpi_request->DevHandle = cpu_to_le16(handle);
3012 mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3013 mpt3sas_base_put_smid_hi_priority(ioc, smid);
3014}
3015
3016/**
3017 * _scsih_tm_volume_tr_complete - target reset completion
3018 * @ioc: per adapter object
3019 * @smid: system request message index
3020 * @msix_index: MSIX table index supplied by the OS
3021 * @reply: reply message frame(lower 32bit addr)
3022 * Context: interrupt time.
3023 *
3024 * Return 1 meaning mf should be freed from _base_interrupt
3025 * 0 means the mf is freed from this function.
3026 */
3027static u8
3028_scsih_tm_volume_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
3029 u8 msix_index, u32 reply)
3030{
3031 u16 handle;
3032 Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3033 Mpi2SCSITaskManagementReply_t *mpi_reply =
3034 mpt3sas_base_get_reply_virt_addr(ioc, reply);
3035
3036 if (ioc->shost_recovery || ioc->remove_host ||
3037 ioc->pci_error_recovery) {
3038 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3039 "%s: host reset in progress!\n",
3040 __func__, ioc->name));
3041 return 1;
3042 }
3043 if (unlikely(!mpi_reply)) {
3044 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
3045 ioc->name, __FILE__, __LINE__, __func__);
3046 return 1;
3047 }
3048
3049 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
3050 handle = le16_to_cpu(mpi_request_tm->DevHandle);
3051 if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
3052 dewtprintk(ioc, pr_err(MPT3SAS_FMT
3053 "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
3054 ioc->name, handle,
3055 le16_to_cpu(mpi_reply->DevHandle), smid));
3056 return 0;
3057 }
3058
3059 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3060 "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
3061 "loginfo(0x%08x), completed(%d)\n", ioc->name,
3062 handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3063 le32_to_cpu(mpi_reply->IOCLogInfo),
3064 le32_to_cpu(mpi_reply->TerminationCount)));
3065
3066 return _scsih_check_for_pending_tm(ioc, smid);
3067}
3068
3069
3070/**
3071 * _scsih_check_for_pending_tm - check for pending task management
3072 * @ioc: per adapter object
3073 * @smid: system request message index
3074 *
3075 * This will check delayed target reset list, and feed the
3076 * next reqeust.
3077 *
3078 * Return 1 meaning mf should be freed from _base_interrupt
3079 * 0 means the mf is freed from this function.
3080 */
3081static u8
3082_scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid)
3083{
3084 struct _tr_list *delayed_tr;
3085
3086 if (!list_empty(&ioc->delayed_tr_volume_list)) {
3087 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
3088 struct _tr_list, list);
3089 mpt3sas_base_free_smid(ioc, smid);
3090 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
3091 list_del(&delayed_tr->list);
3092 kfree(delayed_tr);
3093 return 0;
3094 }
3095
3096 if (!list_empty(&ioc->delayed_tr_list)) {
3097 delayed_tr = list_entry(ioc->delayed_tr_list.next,
3098 struct _tr_list, list);
3099 mpt3sas_base_free_smid(ioc, smid);
3100 _scsih_tm_tr_send(ioc, delayed_tr->handle);
3101 list_del(&delayed_tr->list);
3102 kfree(delayed_tr);
3103 return 0;
3104 }
3105
3106 return 1;
3107}
3108
3109/**
3110 * _scsih_check_topo_delete_events - sanity check on topo events
3111 * @ioc: per adapter object
3112 * @event_data: the event data payload
3113 *
3114 * This routine added to better handle cable breaker.
3115 *
3116 * This handles the case where driver receives multiple expander
3117 * add and delete events in a single shot. When there is a delete event
3118 * the routine will void any pending add events waiting in the event queue.
3119 *
3120 * Return nothing.
3121 */
3122static void
3123_scsih_check_topo_delete_events(struct MPT3SAS_ADAPTER *ioc,
3124 Mpi2EventDataSasTopologyChangeList_t *event_data)
3125{
3126 struct fw_event_work *fw_event;
3127 Mpi2EventDataSasTopologyChangeList_t *local_event_data;
3128 u16 expander_handle;
3129 struct _sas_node *sas_expander;
3130 unsigned long flags;
3131 int i, reason_code;
3132 u16 handle;
3133
3134 for (i = 0 ; i < event_data->NumEntries; i++) {
3135 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3136 if (!handle)
3137 continue;
3138 reason_code = event_data->PHY[i].PhyStatus &
3139 MPI2_EVENT_SAS_TOPO_RC_MASK;
3140 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)
3141 _scsih_tm_tr_send(ioc, handle);
3142 }
3143
3144 expander_handle = le16_to_cpu(event_data->ExpanderDevHandle);
3145 if (expander_handle < ioc->sas_hba.num_phys) {
3146 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3147 return;
3148 }
3149 if (event_data->ExpStatus ==
3150 MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING) {
3151 /* put expander attached devices into blocking state */
3152 spin_lock_irqsave(&ioc->sas_node_lock, flags);
3153 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
3154 expander_handle);
3155 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
3156 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
3157 do {
3158 handle = find_first_bit(ioc->blocking_handles,
3159 ioc->facts.MaxDevHandle);
3160 if (handle < ioc->facts.MaxDevHandle)
3161 _scsih_block_io_device(ioc, handle);
3162 } while (test_and_clear_bit(handle, ioc->blocking_handles));
3163 } else if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_RESPONDING)
3164 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3165
3166 if (event_data->ExpStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
3167 return;
3168
3169 /* mark ignore flag for pending events */
3170 spin_lock_irqsave(&ioc->fw_event_lock, flags);
3171 list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
3172 if (fw_event->event != MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
3173 fw_event->ignore)
3174 continue;
35b62362
JL		 3175 local_event_data = (Mpi2EventDataSasTopologyChangeList_t *)
3176 fw_event->event_data;
f92363d1
SR		 3177 if (local_event_data->ExpStatus ==
3178 MPI2_EVENT_SAS_TOPO_ES_ADDED ||
3179 local_event_data->ExpStatus ==
3180 MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
3181 if (le16_to_cpu(local_event_data->ExpanderDevHandle) ==
3182 expander_handle) {
3183 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3184 "setting ignoring flag\n", ioc->name));
3185 fw_event->ignore = 1;
3186 }
3187 }
3188 }
3189 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3190}
3191
3192/**
3193 * _scsih_set_volume_delete_flag - setting volume delete flag
3194 * @ioc: per adapter object
3195 * @handle: device handle
3196 *
3197 * This returns nothing.
3198 */
3199static void
3200_scsih_set_volume_delete_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3201{
3202 struct _raid_device *raid_device;
3203 struct MPT3SAS_TARGET *sas_target_priv_data;
3204 unsigned long flags;
3205
3206 spin_lock_irqsave(&ioc->raid_device_lock, flags);
3207 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
3208 if (raid_device && raid_device->starget &&
3209 raid_device->starget->hostdata) {
3210 sas_target_priv_data =
3211 raid_device->starget->hostdata;
3212 sas_target_priv_data->deleted = 1;
3213 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3214 "setting delete flag: handle(0x%04x), "
3215 "wwid(0x%016llx)\n", ioc->name, handle,
3216 (unsigned long long) raid_device->wwid));
3217 }
3218 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
3219}
3220
3221/**
3222 * _scsih_set_volume_handle_for_tr - set handle for target reset to volume
3223 * @handle: input handle
3224 * @a: handle for volume a
3225 * @b: handle for volume b
3226 *
3227 * IR firmware only supports two raid volumes. The purpose of this
3228 * routine is to set the volume handle in either a or b. When the given
3229 * input handle is non-zero, or when a and b have not been set before.
3230 */
3231static void
3232_scsih_set_volume_handle_for_tr(u16 handle, u16 *a, u16 *b)
3233{
3234 if (!handle || handle == *a || handle == *b)
3235 return;
3236 if (!*a)
3237 *a = handle;
3238 else if (!*b)
3239 *b = handle;
3240}
3241
3242/**
3243 * _scsih_check_ir_config_unhide_events - check for UNHIDE events
3244 * @ioc: per adapter object
3245 * @event_data: the event data payload
3246 * Context: interrupt time.
3247 *
3248 * This routine will send target reset to volume, followed by target
3249 * resets to the PDs. This is called when a PD has been removed, or
3250 * volume has been deleted or removed. When the target reset is sent
3251 * to volume, the PD target resets need to be queued to start upon
3252 * completion of the volume target reset.
3253 *
3254 * Return nothing.
3255 */
3256static void
3257_scsih_check_ir_config_unhide_events(struct MPT3SAS_ADAPTER *ioc,
3258 Mpi2EventDataIrConfigChangeList_t *event_data)
3259{
3260 Mpi2EventIrConfigElement_t *element;
3261 int i;
3262 u16 handle, volume_handle, a, b;
3263 struct _tr_list *delayed_tr;
3264
3265 a = 0;
3266 b = 0;
3267
3268 /* Volume Resets for Deleted or Removed */
3269 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3270 for (i = 0; i < event_data->NumElements; i++, element++) {
3271 if (le32_to_cpu(event_data->Flags) &
3272 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
3273 continue;
3274 if (element->ReasonCode ==
3275 MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED ||
3276 element->ReasonCode ==
3277 MPI2_EVENT_IR_CHANGE_RC_REMOVED) {
3278 volume_handle = le16_to_cpu(element->VolDevHandle);
3279 _scsih_set_volume_delete_flag(ioc, volume_handle);
3280 _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
3281 }
3282 }
3283
3284 /* Volume Resets for UNHIDE events */
3285 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3286 for (i = 0; i < event_data->NumElements; i++, element++) {
3287 if (le32_to_cpu(event_data->Flags) &
3288 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
3289 continue;
3290 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_UNHIDE) {
3291 volume_handle = le16_to_cpu(element->VolDevHandle);
3292 _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
3293 }
3294 }
3295
3296 if (a)
3297 _scsih_tm_tr_volume_send(ioc, a);
3298 if (b)
3299 _scsih_tm_tr_volume_send(ioc, b);
3300
3301 /* PD target resets */
3302 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3303 for (i = 0; i < event_data->NumElements; i++, element++) {
3304 if (element->ReasonCode != MPI2_EVENT_IR_CHANGE_RC_UNHIDE)
3305 continue;
3306 handle = le16_to_cpu(element->PhysDiskDevHandle);
3307 volume_handle = le16_to_cpu(element->VolDevHandle);
3308 clear_bit(handle, ioc->pd_handles);
3309 if (!volume_handle)
3310 _scsih_tm_tr_send(ioc, handle);
3311 else if (volume_handle == a || volume_handle == b) {
3312 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3313 BUG_ON(!delayed_tr);
3314 INIT_LIST_HEAD(&delayed_tr->list);
3315 delayed_tr->handle = handle;
3316 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3317 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3318 "DELAYED:tr:handle(0x%04x), (open)\n", ioc->name,
3319 handle));
3320 } else
3321 _scsih_tm_tr_send(ioc, handle);
3322 }
3323}
3324
3325
3326/**
3327 * _scsih_check_volume_delete_events - set delete flag for volumes
3328 * @ioc: per adapter object
3329 * @event_data: the event data payload
3330 * Context: interrupt time.
3331 *
3332 * This will handle the case when the cable connected to entire volume is
3333 * pulled. We will take care of setting the deleted flag so normal IO will
3334 * not be sent.
3335 *
3336 * Return nothing.
3337 */
3338static void
3339_scsih_check_volume_delete_events(struct MPT3SAS_ADAPTER *ioc,
3340 Mpi2EventDataIrVolume_t *event_data)
3341{
3342 u32 state;
3343
3344 if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
3345 return;
3346 state = le32_to_cpu(event_data->NewValue);
3347 if (state == MPI2_RAID_VOL_STATE_MISSING || state ==
3348 MPI2_RAID_VOL_STATE_FAILED)
3349 _scsih_set_volume_delete_flag(ioc,
3350 le16_to_cpu(event_data->VolDevHandle));
3351}
3352
2d8ce8c9
SR		 3353/**
3354 * _scsih_temp_threshold_events - display temperature threshold exceeded events
3355 * @ioc: per adapter object
3356 * @event_data: the temp threshold event data
3357 * Context: interrupt time.
3358 *
3359 * Return nothing.
3360 */
3361static void
3362_scsih_temp_threshold_events(struct MPT3SAS_ADAPTER *ioc,
3363 Mpi2EventDataTemperature_t *event_data)
3364{
3365 if (ioc->temp_sensors_count >= event_data->SensorNum) {
3366 pr_err(MPT3SAS_FMT "Temperature Threshold flags %s%s%s%s"
3367 " exceeded for Sensor: %d !!!\n", ioc->name,
3368 ((le16_to_cpu(event_data->Status) & 0x1) == 1) ? "0 " : " ",
3369 ((le16_to_cpu(event_data->Status) & 0x2) == 2) ? "1 " : " ",
3370 ((le16_to_cpu(event_data->Status) & 0x4) == 4) ? "2 " : " ",
3371 ((le16_to_cpu(event_data->Status) & 0x8) == 8) ? "3 " : " ",
3372 event_data->SensorNum);
3373 pr_err(MPT3SAS_FMT "Current Temp In Celsius: %d\n",
3374 ioc->name, event_data->CurrentTemperature);
3375 }
3376}
3377
f92363d1
SR		 3378/**
3379 * _scsih_flush_running_cmds - completing outstanding commands.
3380 * @ioc: per adapter object
3381 *
3382 * The flushing out of all pending scmd commands following host reset,
3383 * where all IO is dropped to the floor.
3384 *
3385 * Return nothing.
3386 */
3387static void
3388_scsih_flush_running_cmds(struct MPT3SAS_ADAPTER *ioc)
3389{
3390 struct scsi_cmnd *scmd;
3391 u16 smid;
3392 u16 count = 0;
3393
3394 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
3395 scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
3396 if (!scmd)
3397 continue;
3398 count++;
3399 mpt3sas_base_free_smid(ioc, smid);
3400 scsi_dma_unmap(scmd);
3401 if (ioc->pci_error_recovery)
3402 scmd->result = DID_NO_CONNECT << 16;
3403 else
3404 scmd->result = DID_RESET << 16;
3405 scmd->scsi_done(scmd);
3406 }
3407 dtmprintk(ioc, pr_info(MPT3SAS_FMT "completing %d cmds\n",
3408 ioc->name, count));
3409}
3410
3411/**
3412 * _scsih_setup_eedp - setup MPI request for EEDP transfer
3413 * @ioc: per adapter object
3414 * @scmd: pointer to scsi command object
3415 * @mpi_request: pointer to the SCSI_IO reqest message frame
3416 *
3417 * Supporting protection 1 and 3.
3418 *
3419 * Returns nothing
3420 */
3421static void
3422_scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
3423 Mpi2SCSIIORequest_t *mpi_request)
3424{
3425 u16 eedp_flags;
3426 unsigned char prot_op = scsi_get_prot_op(scmd);
3427 unsigned char prot_type = scsi_get_prot_type(scmd);
3428 Mpi25SCSIIORequest_t *mpi_request_3v =
3429 (Mpi25SCSIIORequest_t *)mpi_request;
3430
3431 if (prot_type == SCSI_PROT_DIF_TYPE0 || prot_op == SCSI_PROT_NORMAL)
3432 return;
3433
3434 if (prot_op == SCSI_PROT_READ_STRIP)
3435 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP;
3436 else if (prot_op == SCSI_PROT_WRITE_INSERT)
3437 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP;
3438 else
3439 return;
3440
3441 switch (prot_type) {
3442 case SCSI_PROT_DIF_TYPE1:
3443 case SCSI_PROT_DIF_TYPE2:
3444
3445 /*
3446 * enable ref/guard checking
3447 * auto increment ref tag
3448 */
3449 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
3450 MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
3451 MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
3452 mpi_request->CDB.EEDP32.PrimaryReferenceTag =
3453 cpu_to_be32(scsi_get_lba(scmd));
3454 break;
3455
3456 case SCSI_PROT_DIF_TYPE3:
3457
3458 /*
3459 * enable guard checking
3460 */
3461 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
3462
3463 break;
3464 }
3465
3466 mpi_request_3v->EEDPBlockSize =
3467 cpu_to_le16(scmd->device->sector_size);
3468 mpi_request->EEDPFlags = cpu_to_le16(eedp_flags);
3469}
3470
3471/**
3472 * _scsih_eedp_error_handling - return sense code for EEDP errors
3473 * @scmd: pointer to scsi command object
3474 * @ioc_status: ioc status
3475 *
3476 * Returns nothing
3477 */
3478static void
3479_scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
3480{
3481 u8 ascq;
3482
3483 switch (ioc_status) {
3484 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
3485 ascq = 0x01;
3486 break;
3487 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
3488 ascq = 0x02;
3489 break;
3490 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
3491 ascq = 0x03;
3492 break;
3493 default:
3494 ascq = 0x00;
3495 break;
3496 }
3497 scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 0x10,
3498 ascq);
3499 scmd->result = DRIVER_SENSE << 24 | (DID_ABORT << 16) |
3500 SAM_STAT_CHECK_CONDITION;
3501}
3502
3503
3504/**
d8bfbd8d 3505 * _scsih_qcmd - main scsi request entry point
f92363d1
SR		 3506 * @scmd: pointer to scsi command object
3507 * @done: function pointer to be invoked on completion
3508 *
3509 * The callback index is set inside `ioc->scsi_io_cb_idx`.
3510 *
3511 * Returns 0 on success. If there's a failure, return either:
3512 * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or
3513 * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full
3514 */
3515static int
d8bfbd8d 3516_scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
f92363d1 3517{
d8bfbd8d 3518 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
f92363d1
SR		 3519 struct MPT3SAS_DEVICE *sas_device_priv_data;
3520 struct MPT3SAS_TARGET *sas_target_priv_data;
3521 Mpi2SCSIIORequest_t *mpi_request;
3522 u32 mpi_control;
3523 u16 smid;
3524 u16 handle;
3525
3526#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
3527 if (ioc->logging_level & MPT_DEBUG_SCSI)
3528 scsi_print_command(scmd);
3529#endif
3530
f92363d1
SR		 3531 sas_device_priv_data = scmd->device->hostdata;
3532 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
3533 scmd->result = DID_NO_CONNECT << 16;
3534 scmd->scsi_done(scmd);
3535 return 0;
3536 }
3537
3538 if (ioc->pci_error_recovery || ioc->remove_host) {
3539 scmd->result = DID_NO_CONNECT << 16;
3540 scmd->scsi_done(scmd);
3541 return 0;
3542 }
3543
3544 sas_target_priv_data = sas_device_priv_data->sas_target;
3545
3546 /* invalid device handle */
3547 handle = sas_target_priv_data->handle;
3548 if (handle == MPT3SAS_INVALID_DEVICE_HANDLE) {
3549 scmd->result = DID_NO_CONNECT << 16;
3550 scmd->scsi_done(scmd);
3551 return 0;
3552 }
3553
3554
3555 /* host recovery or link resets sent via IOCTLs */
3556 if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress)
3557 return SCSI_MLQUEUE_HOST_BUSY;
3558
3559 /* device has been deleted */
3560 else if (sas_target_priv_data->deleted) {
3561 scmd->result = DID_NO_CONNECT << 16;
3562 scmd->scsi_done(scmd);
3563 return 0;
3564 /* device busy with task managment */
3565 } else if (sas_target_priv_data->tm_busy ||
3566 sas_device_priv_data->block)
3567 return SCSI_MLQUEUE_DEVICE_BUSY;
3568
3569 if (scmd->sc_data_direction == DMA_FROM_DEVICE)
3570 mpi_control = MPI2_SCSIIO_CONTROL_READ;
3571 else if (scmd->sc_data_direction == DMA_TO_DEVICE)
3572 mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
3573 else
3574 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
3575
3576 /* set tags */
609aa22f 3577 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
f92363d1
SR		 3578
3579 if ((sas_device_priv_data->flags & MPT_DEVICE_TLR_ON) &&
3580 scmd->cmd_len != 32)
3581 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
3582
3583 smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
3584 if (!smid) {
3585 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
3586 ioc->name, __func__);
3587 goto out;
3588 }
3589 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3590 memset(mpi_request, 0, sizeof(Mpi2SCSIIORequest_t));
3591 _scsih_setup_eedp(ioc, scmd, mpi_request);
3592
3593 if (scmd->cmd_len == 32)
3594 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT;
3595 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
3596 if (sas_device_priv_data->sas_target->flags &
3597 MPT_TARGET_FLAGS_RAID_COMPONENT)
3598 mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
3599 else
3600 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
3601 mpi_request->DevHandle = cpu_to_le16(handle);
3602 mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
3603 mpi_request->Control = cpu_to_le32(mpi_control);
3604 mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len);
3605 mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR;
3606 mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
3607 mpi_request->SenseBufferLowAddress =
3608 mpt3sas_base_get_sense_buffer_dma(ioc, smid);
3609 mpi_request->SGLOffset0 = offsetof(Mpi2SCSIIORequest_t, SGL) / 4;
3610 int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *)
3611 mpi_request->LUN);
3612 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
3613
3614 if (mpi_request->DataLength) {
3615 if (ioc->build_sg_scmd(ioc, scmd, smid)) {
3616 mpt3sas_base_free_smid(ioc, smid);
3617 goto out;
3618 }
3619 } else
3620 ioc->build_zero_len_sge(ioc, &mpi_request->SGL);
3621
3622 if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)) {
3623 if (sas_target_priv_data->flags & MPT_TARGET_FASTPATH_IO) {
3624 mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len |
3625 MPI25_SCSIIO_IOFLAGS_FAST_PATH);
3626 mpt3sas_base_put_smid_fast_path(ioc, smid, handle);
3627 } else
3628 mpt3sas_base_put_smid_scsi_io(ioc, smid, handle);
3629 } else
3630 mpt3sas_base_put_smid_default(ioc, smid);
3631 return 0;
3632
3633 out:
3634 return SCSI_MLQUEUE_HOST_BUSY;
3635}
f92363d1
SR		 3636
3637/**
3638 * _scsih_normalize_sense - normalize descriptor and fixed format sense data
3639 * @sense_buffer: sense data returned by target
3640 * @data: normalized skey/asc/ascq
3641 *
3642 * Return nothing.
3643 */
3644static void
3645_scsih_normalize_sense(char *sense_buffer, struct sense_info *data)
3646{
3647 if ((sense_buffer[0] & 0x7F) >= 0x72) {
3648 /* descriptor format */
3649 data->skey = sense_buffer[1] & 0x0F;
3650 data->asc = sense_buffer[2];
3651 data->ascq = sense_buffer[3];
3652 } else {
3653 /* fixed format */
3654 data->skey = sense_buffer[2] & 0x0F;
3655 data->asc = sense_buffer[12];
3656 data->ascq = sense_buffer[13];
3657 }
3658}
3659
3660#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
3661/**
3662 * _scsih_scsi_ioc_info - translated non-succesfull SCSI_IO request
3663 * @ioc: per adapter object
3664 * @scmd: pointer to scsi command object
3665 * @mpi_reply: reply mf payload returned from firmware
3666 *
3667 * scsi_status - SCSI Status code returned from target device
3668 * scsi_state - state info associated with SCSI_IO determined by ioc
3669 * ioc_status - ioc supplied status info
3670 *
3671 * Return nothing.
3672 */
3673static void
3674_scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
3675 Mpi2SCSIIOReply_t *mpi_reply, u16 smid)
3676{
3677 u32 response_info;
3678 u8 *response_bytes;
3679 u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) &
3680 MPI2_IOCSTATUS_MASK;
3681 u8 scsi_state = mpi_reply->SCSIState;
3682 u8 scsi_status = mpi_reply->SCSIStatus;
3683 char *desc_ioc_state = NULL;
3684 char *desc_scsi_status = NULL;
3685 char *desc_scsi_state = ioc->tmp_string;
3686 u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
3687 struct _sas_device *sas_device = NULL;
3688 unsigned long flags;
3689 struct scsi_target *starget = scmd->device->sdev_target;
3690 struct MPT3SAS_TARGET *priv_target = starget->hostdata;
3691 char *device_str = NULL;
3692
3693 if (!priv_target)
3694 return;
3695 device_str = "volume";
3696
3697 if (log_info == 0x31170000)
3698 return;
3699
3700 switch (ioc_status) {
3701 case MPI2_IOCSTATUS_SUCCESS:
3702 desc_ioc_state = "success";
3703 break;
3704 case MPI2_IOCSTATUS_INVALID_FUNCTION:
3705 desc_ioc_state = "invalid function";
3706 break;
3707 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
3708 desc_ioc_state = "scsi recovered error";
3709 break;
3710 case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE:
3711 desc_ioc_state = "scsi invalid dev handle";
3712 break;
3713 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
3714 desc_ioc_state = "scsi device not there";
3715 break;
3716 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
3717 desc_ioc_state = "scsi data overrun";
3718 break;
3719 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
3720 desc_ioc_state = "scsi data underrun";
3721 break;
3722 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
3723 desc_ioc_state = "scsi io data error";
3724 break;
3725 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
3726 desc_ioc_state = "scsi protocol error";
3727 break;
3728 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
3729 desc_ioc_state = "scsi task terminated";
3730 break;
3731 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
3732 desc_ioc_state = "scsi residual mismatch";
3733 break;
3734 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
3735 desc_ioc_state = "scsi task mgmt failed";
3736 break;
3737 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
3738 desc_ioc_state = "scsi ioc terminated";
3739 break;
3740 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
3741 desc_ioc_state = "scsi ext terminated";
3742 break;
3743 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
3744 desc_ioc_state = "eedp guard error";
3745 break;
3746 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
3747 desc_ioc_state = "eedp ref tag error";
3748 break;
3749 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
3750 desc_ioc_state = "eedp app tag error";
3751 break;
3752 default:
3753 desc_ioc_state = "unknown";
3754 break;
3755 }
3756
3757 switch (scsi_status) {
3758 case MPI2_SCSI_STATUS_GOOD:
3759 desc_scsi_status = "good";
3760 break;
3761 case MPI2_SCSI_STATUS_CHECK_CONDITION:
3762 desc_scsi_status = "check condition";
3763 break;
3764 case MPI2_SCSI_STATUS_CONDITION_MET:
3765 desc_scsi_status = "condition met";
3766 break;
3767 case MPI2_SCSI_STATUS_BUSY:
3768 desc_scsi_status = "busy";
3769 break;
3770 case MPI2_SCSI_STATUS_INTERMEDIATE:
3771 desc_scsi_status = "intermediate";
3772 break;
3773 case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET:
3774 desc_scsi_status = "intermediate condmet";
3775 break;
3776 case MPI2_SCSI_STATUS_RESERVATION_CONFLICT:
3777 desc_scsi_status = "reservation conflict";
3778 break;
3779 case MPI2_SCSI_STATUS_COMMAND_TERMINATED:
3780 desc_scsi_status = "command terminated";
3781 break;
3782 case MPI2_SCSI_STATUS_TASK_SET_FULL:
3783 desc_scsi_status = "task set full";
3784 break;
3785 case MPI2_SCSI_STATUS_ACA_ACTIVE:
3786 desc_scsi_status = "aca active";
3787 break;
3788 case MPI2_SCSI_STATUS_TASK_ABORTED:
3789 desc_scsi_status = "task aborted";
3790 break;
3791 default:
3792 desc_scsi_status = "unknown";
3793 break;
3794 }
3795
3796 desc_scsi_state[0] = '\0';
3797 if (!scsi_state)
3798 desc_scsi_state = " ";
3799 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
3800 strcat(desc_scsi_state, "response info ");
3801 if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
3802 strcat(desc_scsi_state, "state terminated ");
3803 if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS)
3804 strcat(desc_scsi_state, "no status ");
3805 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED)
3806 strcat(desc_scsi_state, "autosense failed ");
3807 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)
3808 strcat(desc_scsi_state, "autosense valid ");
3809
3810 scsi_print_command(scmd);
3811
3812 if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
3813 pr_warn(MPT3SAS_FMT "\t%s wwid(0x%016llx)\n", ioc->name,
3814 device_str, (unsigned long long)priv_target->sas_address);
3815 } else {
3816 spin_lock_irqsave(&ioc->sas_device_lock, flags);
3817 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
3818 priv_target->sas_address);
3819 if (sas_device) {
3820 pr_warn(MPT3SAS_FMT
3821 "\tsas_address(0x%016llx), phy(%d)\n",
3822 ioc->name, (unsigned long long)
3823 sas_device->sas_address, sas_device->phy);
3824 pr_warn(MPT3SAS_FMT
3825 "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
3826 ioc->name, (unsigned long long)
3827 sas_device->enclosure_logical_id, sas_device->slot);
3828 }
3829 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3830 }
3831
3832 pr_warn(MPT3SAS_FMT
3833 "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n",
3834 ioc->name, le16_to_cpu(mpi_reply->DevHandle),
3835 desc_ioc_state, ioc_status, smid);
3836 pr_warn(MPT3SAS_FMT
3837 "\trequest_len(%d), underflow(%d), resid(%d)\n",
3838 ioc->name, scsi_bufflen(scmd), scmd->underflow,
3839 scsi_get_resid(scmd));
3840 pr_warn(MPT3SAS_FMT
3841 "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n",
3842 ioc->name, le16_to_cpu(mpi_reply->TaskTag),
3843 le32_to_cpu(mpi_reply->TransferCount), scmd->result);
3844 pr_warn(MPT3SAS_FMT
3845 "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n",
3846 ioc->name, desc_scsi_status,
3847 scsi_status, desc_scsi_state, scsi_state);
3848
3849 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
3850 struct sense_info data;
3851 _scsih_normalize_sense(scmd->sense_buffer, &data);
3852 pr_warn(MPT3SAS_FMT
3853 "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n",
3854 ioc->name, data.skey,
3855 data.asc, data.ascq, le32_to_cpu(mpi_reply->SenseCount));
3856 }
3857
3858 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
3859 response_info = le32_to_cpu(mpi_reply->ResponseInfo);
3860 response_bytes = (u8 *)&response_info;
3861 _scsih_response_code(ioc, response_bytes[0]);
3862 }
3863}
3864#endif
3865
3866/**
0f624c39 3867 * _scsih_turn_on_pfa_led - illuminate PFA LED
f92363d1
SR		 3868 * @ioc: per adapter object
3869 * @handle: device handle
3870 * Context: process
3871 *
3872 * Return nothing.
3873 */
3874static void
0f624c39 3875_scsih_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
f92363d1
SR		 3876{
3877 Mpi2SepReply_t mpi_reply;
3878 Mpi2SepRequest_t mpi_request;
0f624c39
SR		 3879 struct _sas_device *sas_device;
3880
3881 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
3882 if (!sas_device)
3883 return;
f92363d1
SR		 3884
3885 memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
3886 mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
3887 mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
3888 mpi_request.SlotStatus =
3889 cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
3890 mpi_request.DevHandle = cpu_to_le16(handle);
3891 mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
3892 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
3893 &mpi_request)) != 0) {
3894 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
3895 __FILE__, __LINE__, __func__);
3896 return;
3897 }
0f624c39 3898 sas_device->pfa_led_on = 1;
f92363d1
SR		 3899
3900 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
3901 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3902 "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
3903 ioc->name, le16_to_cpu(mpi_reply.IOCStatus),
3904 le32_to_cpu(mpi_reply.IOCLogInfo)));
3905 return;
3906 }
3907}
0f624c39
SR		 3908/**
3909 * _scsih_turn_off_pfa_led - turn off Fault LED
3910 * @ioc: per adapter object
3911 * @sas_device: sas device whose PFA LED has to turned off
3912 * Context: process
3913 *
3914 * Return nothing.
3915 */
3916static void
3917_scsih_turn_off_pfa_led(struct MPT3SAS_ADAPTER *ioc,
3918 struct _sas_device *sas_device)
3919{
3920 Mpi2SepReply_t mpi_reply;
3921 Mpi2SepRequest_t mpi_request;
f92363d1 3922
0f624c39
SR		 3923 memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
3924 mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
3925 mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
3926 mpi_request.SlotStatus = 0;
3927 mpi_request.Slot = cpu_to_le16(sas_device->slot);
3928 mpi_request.DevHandle = 0;
3929 mpi_request.EnclosureHandle = cpu_to_le16(sas_device->enclosure_handle);
3930 mpi_request.Flags = MPI2_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS;
3931 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
3932 &mpi_request)) != 0) {
3933 printk(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
3934 __FILE__, __LINE__, __func__);
3935 return;
3936 }
3937
3938 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
3939 dewtprintk(ioc, printk(MPT3SAS_FMT
3940 "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
3941 ioc->name, le16_to_cpu(mpi_reply.IOCStatus),
3942 le32_to_cpu(mpi_reply.IOCLogInfo)));
3943 return;
3944 }
3945}
f92363d1 3946/**
0f624c39 3947 * _scsih_send_event_to_turn_on_pfa_led - fire delayed event
f92363d1
SR		 3948 * @ioc: per adapter object
3949 * @handle: device handle
3950 * Context: interrupt.
3951 *
3952 * Return nothing.
3953 */
3954static void
0f624c39 3955_scsih_send_event_to_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
f92363d1
SR		 3956{
3957 struct fw_event_work *fw_event;
3958
3959 fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
3960 if (!fw_event)
3961 return;
0f624c39 3962 fw_event->event = MPT3SAS_TURN_ON_PFA_LED;
f92363d1
SR		 3963 fw_event->device_handle = handle;
3964 fw_event->ioc = ioc;
3965 _scsih_fw_event_add(ioc, fw_event);
3966}
3967
3968/**
3969 * _scsih_smart_predicted_fault - process smart errors
3970 * @ioc: per adapter object
3971 * @handle: device handle
3972 * Context: interrupt.
3973 *
3974 * Return nothing.
3975 */
3976static void
3977_scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3978{
3979 struct scsi_target *starget;
3980 struct MPT3SAS_TARGET *sas_target_priv_data;
3981 Mpi2EventNotificationReply_t *event_reply;
3982 Mpi2EventDataSasDeviceStatusChange_t *event_data;
3983 struct _sas_device *sas_device;
3984 ssize_t sz;
3985 unsigned long flags;
3986
3987 /* only handle non-raid devices */
3988 spin_lock_irqsave(&ioc->sas_device_lock, flags);
3989 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
3990 if (!sas_device) {
3991 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3992 return;
3993 }
3994 starget = sas_device->starget;
3995 sas_target_priv_data = starget->hostdata;
3996
3997 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) ||
3998 ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))) {
3999 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4000 return;
4001 }
4002 starget_printk(KERN_WARNING, starget, "predicted fault\n");
4003 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4004
4005 if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
0f624c39 4006 _scsih_send_event_to_turn_on_pfa_led(ioc, handle);
f92363d1
SR		 4007
4008 /* insert into event log */
4009 sz = offsetof(Mpi2EventNotificationReply_t, EventData) +
4010 sizeof(Mpi2EventDataSasDeviceStatusChange_t);
4011 event_reply = kzalloc(sz, GFP_KERNEL);
4012 if (!event_reply) {
4013 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4014 ioc->name, __FILE__, __LINE__, __func__);
4015 return;
4016 }
4017
4018 event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION;
4019 event_reply->Event =
4020 cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE);
4021 event_reply->MsgLength = sz/4;
4022 event_reply->EventDataLength =
4023 cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4);
4024 event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
4025 event_reply->EventData;
4026 event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
4027 event_data->ASC = 0x5D;
4028 event_data->DevHandle = cpu_to_le16(handle);
4029 event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
4030 mpt3sas_ctl_add_to_event_log(ioc, event_reply);
4031 kfree(event_reply);
4032}
4033
4034/**
4035 * _scsih_io_done - scsi request callback
4036 * @ioc: per adapter object
4037 * @smid: system request message index
4038 * @msix_index: MSIX table index supplied by the OS
4039 * @reply: reply message frame(lower 32bit addr)
4040 *
4041 * Callback handler when using _scsih_qcmd.
4042 *
4043 * Return 1 meaning mf should be freed from _base_interrupt
4044 * 0 means the mf is freed from this function.
4045 */
4046static u8
4047_scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
4048{
4049 Mpi2SCSIIORequest_t *mpi_request;
4050 Mpi2SCSIIOReply_t *mpi_reply;
4051 struct scsi_cmnd *scmd;
4052 u16 ioc_status;
4053 u32 xfer_cnt;
4054 u8 scsi_state;
4055 u8 scsi_status;
4056 u32 log_info;
4057 struct MPT3SAS_DEVICE *sas_device_priv_data;
4058 u32 response_code = 0;
4059
4060 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
4061 scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
4062 if (scmd == NULL)
4063 return 1;
4064
4065 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4066
4067 if (mpi_reply == NULL) {
4068 scmd->result = DID_OK << 16;
4069 goto out;
4070 }
4071
4072 sas_device_priv_data = scmd->device->hostdata;
4073 if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
4074 sas_device_priv_data->sas_target->deleted) {
4075 scmd->result = DID_NO_CONNECT << 16;
4076 goto out;
4077 }
4078 ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
4079
4080 /* turning off TLR */
4081 scsi_state = mpi_reply->SCSIState;
4082 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4083 response_code =
4084 le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
4085 if (!sas_device_priv_data->tlr_snoop_check) {
4086 sas_device_priv_data->tlr_snoop_check++;
4087 if ((sas_device_priv_data->flags & MPT_DEVICE_TLR_ON) &&
4088 response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME)
4089 sas_device_priv_data->flags &=
4090 ~MPT_DEVICE_TLR_ON;
4091 }
4092
4093 xfer_cnt = le32_to_cpu(mpi_reply->TransferCount);
4094 scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt);
4095 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
4096 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
4097 else
4098 log_info = 0;
4099 ioc_status &= MPI2_IOCSTATUS_MASK;
4100 scsi_status = mpi_reply->SCSIStatus;
4101
4102 if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
4103 (scsi_status == MPI2_SCSI_STATUS_BUSY ||
4104 scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT ||
4105 scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) {
4106 ioc_status = MPI2_IOCSTATUS_SUCCESS;
4107 }
4108
4109 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
4110 struct sense_info data;
4111 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc,
4112 smid);
4113 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
4114 le32_to_cpu(mpi_reply->SenseCount));
4115 memcpy(scmd->sense_buffer, sense_data, sz);
4116 _scsih_normalize_sense(scmd->sense_buffer, &data);
4117 /* failure prediction threshold exceeded */
4118 if (data.asc == 0x5D)
4119 _scsih_smart_predicted_fault(ioc,
4120 le16_to_cpu(mpi_reply->DevHandle));
4121 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
4122 }
4123
4124 switch (ioc_status) {
4125 case MPI2_IOCSTATUS_BUSY:
4126 case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES:
4127 scmd->result = SAM_STAT_BUSY;
4128 break;
4129
4130 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4131 scmd->result = DID_NO_CONNECT << 16;
4132 break;
4133
4134 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4135 if (sas_device_priv_data->block) {
4136 scmd->result = DID_TRANSPORT_DISRUPTED << 16;
4137 goto out;
4138 }
4139 if (log_info == 0x31110630) {
4140 if (scmd->retries > 2) {
4141 scmd->result = DID_NO_CONNECT << 16;
4142 scsi_device_set_state(scmd->device,
4143 SDEV_OFFLINE);
4144 } else {
4145 scmd->result = DID_SOFT_ERROR << 16;
4146 scmd->device->expecting_cc_ua = 1;
4147 }
4148 break;
4149 }
4150 scmd->result = DID_SOFT_ERROR << 16;
4151 break;
4152 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4153 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4154 scmd->result = DID_RESET << 16;
4155 break;
4156
4157 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4158 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt))
4159 scmd->result = DID_SOFT_ERROR << 16;
4160 else
4161 scmd->result = (DID_OK << 16) | scsi_status;
4162 break;
4163
4164 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4165 scmd->result = (DID_OK << 16) | scsi_status;
4166
4167 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID))
4168 break;
4169
4170 if (xfer_cnt < scmd->underflow) {
4171 if (scsi_status == SAM_STAT_BUSY)
4172 scmd->result = SAM_STAT_BUSY;
4173 else
4174 scmd->result = DID_SOFT_ERROR << 16;
4175 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
4176 MPI2_SCSI_STATE_NO_SCSI_STATUS))
4177 scmd->result = DID_SOFT_ERROR << 16;
4178 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4179 scmd->result = DID_RESET << 16;
4180 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
4181 mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
4182 mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
4183 scmd->result = (DRIVER_SENSE << 24) |
4184 SAM_STAT_CHECK_CONDITION;
4185 scmd->sense_buffer[0] = 0x70;
4186 scmd->sense_buffer[2] = ILLEGAL_REQUEST;
4187 scmd->sense_buffer[12] = 0x20;
4188 scmd->sense_buffer[13] = 0;
4189 }
4190 break;
4191
4192 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4193 scsi_set_resid(scmd, 0);
4194 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4195 case MPI2_IOCSTATUS_SUCCESS:
4196 scmd->result = (DID_OK << 16) | scsi_status;
4197 if (response_code ==
4198 MPI2_SCSITASKMGMT_RSP_INVALID_FRAME ||
4199 (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
4200 MPI2_SCSI_STATE_NO_SCSI_STATUS)))
4201 scmd->result = DID_SOFT_ERROR << 16;
4202 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4203 scmd->result = DID_RESET << 16;
4204 break;
4205
4206 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4207 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4208 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4209 _scsih_eedp_error_handling(scmd, ioc_status);
4210 break;
4211
4212 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4213 case MPI2_IOCSTATUS_INVALID_FUNCTION:
4214 case MPI2_IOCSTATUS_INVALID_SGL:
4215 case MPI2_IOCSTATUS_INTERNAL_ERROR:
4216 case MPI2_IOCSTATUS_INVALID_FIELD:
4217 case MPI2_IOCSTATUS_INVALID_STATE:
4218 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4219 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4220 default:
4221 scmd->result = DID_SOFT_ERROR << 16;
4222 break;
4223
4224 }
4225
4226#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
4227 if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
4228 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
4229#endif
4230
4231 out:
4232
4233 scsi_dma_unmap(scmd);
4234
4235 scmd->scsi_done(scmd);
4236 return 1;
4237}
4238
4239/**
4240 * _scsih_sas_host_refresh - refreshing sas host object contents
4241 * @ioc: per adapter object
4242 * Context: user
4243 *
4244 * During port enable, fw will send topology events for every device. Its
4245 * possible that the handles may change from the previous setting, so this
4246 * code keeping handles updating if changed.
4247 *
4248 * Return nothing.
4249 */
4250static void
4251_scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc)
4252{
4253 u16 sz;
4254 u16 ioc_status;
4255 int i;
4256 Mpi2ConfigReply_t mpi_reply;
4257 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
4258 u16 attached_handle;
4259 u8 link_rate;
4260
4261 dtmprintk(ioc, pr_info(MPT3SAS_FMT
4262 "updating handles for sas_host(0x%016llx)\n",
4263 ioc->name, (unsigned long long)ioc->sas_hba.sas_address));
4264
4265 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
4266 * sizeof(Mpi2SasIOUnit0PhyData_t));
4267 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
4268 if (!sas_iounit_pg0) {
4269 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4270 ioc->name, __FILE__, __LINE__, __func__);
4271 return;
4272 }
4273
4274 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4275 sas_iounit_pg0, sz)) != 0)
4276 goto out;
4277 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
4278 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
4279 goto out;
4280 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4281 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4;
4282 if (i == 0)
4283 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4284 PhyData[0].ControllerDevHandle);
4285 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4286 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i].
4287 AttachedDevHandle);
4288 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
4289 link_rate = MPI2_SAS_NEG_LINK_RATE_1_5;
4290 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
4291 attached_handle, i, link_rate);
4292 }
4293 out:
4294 kfree(sas_iounit_pg0);
4295}
4296
4297/**
4298 * _scsih_sas_host_add - create sas host object
4299 * @ioc: per adapter object
4300 *
4301 * Creating host side data object, stored in ioc->sas_hba
4302 *
4303 * Return nothing.
4304 */
4305static void
4306_scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc)
4307{
4308 int i;
4309 Mpi2ConfigReply_t mpi_reply;
4310 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
4311 Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
4312 Mpi2SasPhyPage0_t phy_pg0;
4313 Mpi2SasDevicePage0_t sas_device_pg0;
4314 Mpi2SasEnclosurePage0_t enclosure_pg0;
4315 u16 ioc_status;
4316 u16 sz;
4317 u8 device_missing_delay;
4318
4319 mpt3sas_config_get_number_hba_phys(ioc, &ioc->sas_hba.num_phys);
4320 if (!ioc->sas_hba.num_phys) {
4321 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4322 ioc->name, __FILE__, __LINE__, __func__);
4323 return;
4324 }
4325
4326 /* sas_iounit page 0 */
4327 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
4328 sizeof(Mpi2SasIOUnit0PhyData_t));
4329 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
4330 if (!sas_iounit_pg0) {
4331 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4332 ioc->name, __FILE__, __LINE__, __func__);
4333 return;
4334 }
4335 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4336 sas_iounit_pg0, sz))) {
4337 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4338 ioc->name, __FILE__, __LINE__, __func__);
4339 goto out;
4340 }
4341 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4342 MPI2_IOCSTATUS_MASK;
4343 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4344 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4345 ioc->name, __FILE__, __LINE__, __func__);
4346 goto out;
4347 }
4348
4349 /* sas_iounit page 1 */
4350 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
4351 sizeof(Mpi2SasIOUnit1PhyData_t));
4352 sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
4353 if (!sas_iounit_pg1) {
4354 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4355 ioc->name, __FILE__, __LINE__, __func__);
4356 goto out;
4357 }
4358 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
4359 sas_iounit_pg1, sz))) {
4360 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4361 ioc->name, __FILE__, __LINE__, __func__);
4362 goto out;
4363 }
4364 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4365 MPI2_IOCSTATUS_MASK;
4366 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4367 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4368 ioc->name, __FILE__, __LINE__, __func__);
4369 goto out;
4370 }
4371
4372 ioc->io_missing_delay =
4373 sas_iounit_pg1->IODeviceMissingDelay;
4374 device_missing_delay =
4375 sas_iounit_pg1->ReportDeviceMissingDelay;
4376 if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16)
4377 ioc->device_missing_delay = (device_missing_delay &
4378 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16;
4379 else
4380 ioc->device_missing_delay = device_missing_delay &
4381 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
4382
4383 ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
4384 ioc->sas_hba.phy = kcalloc(ioc->sas_hba.num_phys,
4385 sizeof(struct _sas_phy), GFP_KERNEL);
4386 if (!ioc->sas_hba.phy) {
4387 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4388 ioc->name, __FILE__, __LINE__, __func__);
4389 goto out;
4390 }
4391 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4392 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
4393 i))) {
4394 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4395 ioc->name, __FILE__, __LINE__, __func__);
4396 goto out;
4397 }
4398 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4399 MPI2_IOCSTATUS_MASK;
4400 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4401 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4402 ioc->name, __FILE__, __LINE__, __func__);
4403 goto out;
4404 }
4405
4406 if (i == 0)
4407 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4408 PhyData[0].ControllerDevHandle);
4409 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4410 ioc->sas_hba.phy[i].phy_id = i;
4411 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
4412 phy_pg0, ioc->sas_hba.parent_dev);
4413 }
4414 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4415 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
4416 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4417 ioc->name, __FILE__, __LINE__, __func__);
4418 goto out;
4419 }
4420 ioc->sas_hba.enclosure_handle =
4421 le16_to_cpu(sas_device_pg0.EnclosureHandle);
4422 ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
4423 pr_info(MPT3SAS_FMT
4424 "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
4425 ioc->name, ioc->sas_hba.handle,
4426 (unsigned long long) ioc->sas_hba.sas_address,
4427 ioc->sas_hba.num_phys) ;
4428
4429 if (ioc->sas_hba.enclosure_handle) {
4430 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4431 &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
4432 ioc->sas_hba.enclosure_handle)))
4433 ioc->sas_hba.enclosure_logical_id =
4434 le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
4435 }
4436
4437 out:
4438 kfree(sas_iounit_pg1);
4439 kfree(sas_iounit_pg0);
4440}
4441
4442/**
4443 * _scsih_expander_add - creating expander object
4444 * @ioc: per adapter object
4445 * @handle: expander handle
4446 *
4447 * Creating expander object, stored in ioc->sas_expander_list.
4448 *
4449 * Return 0 for success, else error.
4450 */
4451static int
4452_scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4453{
4454 struct _sas_node *sas_expander;
4455 Mpi2ConfigReply_t mpi_reply;
4456 Mpi2ExpanderPage0_t expander_pg0;
4457 Mpi2ExpanderPage1_t expander_pg1;
4458 Mpi2SasEnclosurePage0_t enclosure_pg0;
4459 u32 ioc_status;
4460 u16 parent_handle;
4461 u64 sas_address, sas_address_parent = 0;
4462 int i;
4463 unsigned long flags;
4464 struct _sas_port *mpt3sas_port = NULL;
4465
4466 int rc = 0;
4467
4468 if (!handle)
4469 return -1;
4470
4471 if (ioc->shost_recovery || ioc->pci_error_recovery)
4472 return -1;
4473
4474 if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
4475 MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) {
4476 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4477 ioc->name, __FILE__, __LINE__, __func__);
4478 return -1;
4479 }
4480
4481 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4482 MPI2_IOCSTATUS_MASK;
4483 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4484 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4485 ioc->name, __FILE__, __LINE__, __func__);
4486 return -1;
4487 }
4488
4489 /* handle out of order topology events */
4490 parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle);
4491 if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
4492 != 0) {
4493 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4494 ioc->name, __FILE__, __LINE__, __func__);
4495 return -1;
4496 }
4497 if (sas_address_parent != ioc->sas_hba.sas_address) {
4498 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4499 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
4500 sas_address_parent);
4501 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4502 if (!sas_expander) {
4503 rc = _scsih_expander_add(ioc, parent_handle);
4504 if (rc != 0)
4505 return rc;
4506 }
4507 }
4508
4509 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4510 sas_address = le64_to_cpu(expander_pg0.SASAddress);
4511 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
4512 sas_address);
4513 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4514
4515 if (sas_expander)
4516 return 0;
4517
4518 sas_expander = kzalloc(sizeof(struct _sas_node),
4519 GFP_KERNEL);
4520 if (!sas_expander) {
4521 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4522 ioc->name, __FILE__, __LINE__, __func__);
4523 return -1;
4524 }
4525
4526 sas_expander->handle = handle;
4527 sas_expander->num_phys = expander_pg0.NumPhys;
4528 sas_expander->sas_address_parent = sas_address_parent;
4529 sas_expander->sas_address = sas_address;
4530
4531 pr_info(MPT3SAS_FMT "expander_add: handle(0x%04x)," \
4532 " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name,
4533 handle, parent_handle, (unsigned long long)
4534 sas_expander->sas_address, sas_expander->num_phys);
4535
4536 if (!sas_expander->num_phys)
4537 goto out_fail;
4538 sas_expander->phy = kcalloc(sas_expander->num_phys,
4539 sizeof(struct _sas_phy), GFP_KERNEL);
4540 if (!sas_expander->phy) {
4541 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4542 ioc->name, __FILE__, __LINE__, __func__);
4543 rc = -1;
4544 goto out_fail;
4545 }
4546
4547 INIT_LIST_HEAD(&sas_expander->sas_port_list);
4548 mpt3sas_port = mpt3sas_transport_port_add(ioc, handle,
4549 sas_address_parent);
4550 if (!mpt3sas_port) {
4551 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4552 ioc->name, __FILE__, __LINE__, __func__);
4553 rc = -1;
4554 goto out_fail;
4555 }
4556 sas_expander->parent_dev = &mpt3sas_port->rphy->dev;
4557
4558 for (i = 0 ; i < sas_expander->num_phys ; i++) {
4559 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
4560 &expander_pg1, i, handle))) {
4561 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4562 ioc->name, __FILE__, __LINE__, __func__);
4563 rc = -1;
4564 goto out_fail;
4565 }
4566 sas_expander->phy[i].handle = handle;
4567 sas_expander->phy[i].phy_id = i;
4568
4569 if ((mpt3sas_transport_add_expander_phy(ioc,
4570 &sas_expander->phy[i], expander_pg1,
4571 sas_expander->parent_dev))) {
4572 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4573 ioc->name, __FILE__, __LINE__, __func__);
4574 rc = -1;
4575 goto out_fail;
4576 }
4577 }
4578
4579 if (sas_expander->enclosure_handle) {
4580 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4581 &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
4582 sas_expander->enclosure_handle)))
4583 sas_expander->enclosure_logical_id =
4584 le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
4585 }
4586
4587 _scsih_expander_node_add(ioc, sas_expander);
4588 return 0;
4589
4590 out_fail:
4591
4592 if (mpt3sas_port)
4593 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
4594 sas_address_parent);
4595 kfree(sas_expander);
4596 return rc;
4597}
4598
4599/**
4600 * mpt3sas_expander_remove - removing expander object
4601 * @ioc: per adapter object
4602 * @sas_address: expander sas_address
4603 *
4604 * Return nothing.
4605 */
4606void
4607mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
4608{
4609 struct _sas_node *sas_expander;
4610 unsigned long flags;
4611
4612 if (ioc->shost_recovery)
4613 return;
4614
4615 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4616 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
4617 sas_address);
4618 if (sas_expander)
4619 list_del(&sas_expander->list);
4620 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4621 if (sas_expander)
4622 _scsih_expander_node_remove(ioc, sas_expander);
4623}
4624
4625/**
4626 * _scsih_done - internal SCSI_IO callback handler.
4627 * @ioc: per adapter object
4628 * @smid: system request message index
4629 * @msix_index: MSIX table index supplied by the OS
4630 * @reply: reply message frame(lower 32bit addr)
4631 *
4632 * Callback handler when sending internal generated SCSI_IO.
4633 * The callback index passed is `ioc->scsih_cb_idx`
4634 *
4635 * Return 1 meaning mf should be freed from _base_interrupt
4636 * 0 means the mf is freed from this function.
4637 */
4638static u8
4639_scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
4640{
4641 MPI2DefaultReply_t *mpi_reply;
4642
4643 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
4644 if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED)
4645 return 1;
4646 if (ioc->scsih_cmds.smid != smid)
4647 return 1;
4648 ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE;
4649 if (mpi_reply) {
4650 memcpy(ioc->scsih_cmds.reply, mpi_reply,
4651 mpi_reply->MsgLength*4);
4652 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID;
4653 }
4654 ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING;
4655 complete(&ioc->scsih_cmds.done);
4656 return 1;
4657}
4658
4659
4660
4661
4662#define MPT3_MAX_LUNS (255)
4663
4664
4665/**
4666 * _scsih_check_access_status - check access flags
4667 * @ioc: per adapter object
4668 * @sas_address: sas address
4669 * @handle: sas device handle
4670 * @access_flags: errors returned during discovery of the device
4671 *
4672 * Return 0 for success, else failure
4673 */
4674static u8
4675_scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
4676 u16 handle, u8 access_status)
4677{
4678 u8 rc = 1;
4679 char *desc = NULL;
4680
4681 switch (access_status) {
4682 case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS:
4683 case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION:
4684 rc = 0;
4685 break;
4686 case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED:
4687 desc = "sata capability failed";
4688 break;
4689 case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT:
4690 desc = "sata affiliation conflict";
4691 break;
4692 case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE:
4693 desc = "route not addressable";
4694 break;
4695 case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE:
4696 desc = "smp error not addressable";
4697 break;
4698 case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED:
4699 desc = "device blocked";
4700 break;
4701 case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED:
4702 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN:
4703 case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT:
4704 case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG:
4705 case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION:
4706 case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER:
4707 case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN:
4708 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN:
4709 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN:
4710 case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION:
4711 case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE:
4712 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX:
4713 desc = "sata initialization failed";
4714 break;
4715 default:
4716 desc = "unknown";
4717 break;
4718 }
4719
4720 if (!rc)
4721 return 0;
4722
4723 pr_err(MPT3SAS_FMT
4724 "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n",
4725 ioc->name, desc, (unsigned long long)sas_address, handle);
4726 return rc;
4727}
4728
4729/**
4730 * _scsih_check_device - checking device responsiveness
4731 * @ioc: per adapter object
4732 * @parent_sas_address: sas address of parent expander or sas host
4733 * @handle: attached device handle
4734 * @phy_numberv: phy number
4735 * @link_rate: new link rate
4736 *
4737 * Returns nothing.
4738 */
4739static void
4740_scsih_check_device(struct MPT3SAS_ADAPTER *ioc,
4741 u64 parent_sas_address, u16 handle, u8 phy_number, u8 link_rate)
4742{
4743 Mpi2ConfigReply_t mpi_reply;
4744 Mpi2SasDevicePage0_t sas_device_pg0;
4745 struct _sas_device *sas_device;
4746 u32 ioc_status;
4747 unsigned long flags;
4748 u64 sas_address;
4749 struct scsi_target *starget;
4750 struct MPT3SAS_TARGET *sas_target_priv_data;
4751 u32 device_info;
4752
4753
4754 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4755 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)))
4756 return;
4757
4758 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
4759 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
4760 return;
4761
4762 /* wide port handling ~ we need only handle device once for the phy that
4763 * is matched in sas device page zero
4764 */
4765 if (phy_number != sas_device_pg0.PhyNum)
4766 return;
4767
4768 /* check if this is end device */
4769 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
4770 if (!(_scsih_is_end_device(device_info)))
4771 return;
4772
4773 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4774 sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
4775 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
4776 sas_address);
4777
4778 if (!sas_device) {
4779 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4780 return;
4781 }
4782
4783 if (unlikely(sas_device->handle != handle)) {
4784 starget = sas_device->starget;
4785 sas_target_priv_data = starget->hostdata;
4786 starget_printk(KERN_INFO, starget,
4787 "handle changed from(0x%04x) to (0x%04x)!!!\n",
4788 sas_device->handle, handle);
4789 sas_target_priv_data->handle = handle;
4790 sas_device->handle = handle;
4791 }
4792
4793 /* check if device is present */
4794 if (!(le16_to_cpu(sas_device_pg0.Flags) &
4795 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
4796 pr_err(MPT3SAS_FMT
4797 "device is not present handle(0x%04x), flags!!!\n",
4798 ioc->name, handle);
4799 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4800 return;
4801 }
4802
4803 /* check if there were any issues with discovery */
4804 if (_scsih_check_access_status(ioc, sas_address, handle,
4805 sas_device_pg0.AccessStatus)) {
4806 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4807 return;
4808 }
4809
4810 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4811 _scsih_ublock_io_device(ioc, sas_address);
4812
4813}
4814
4815/**
4816 * _scsih_add_device - creating sas device object
4817 * @ioc: per adapter object
4818 * @handle: sas device handle
4819 * @phy_num: phy number end device attached to
4820 * @is_pd: is this hidden raid component
4821 *
4822 * Creating end device object, stored in ioc->sas_device_list.
4823 *
4824 * Returns 0 for success, non-zero for failure.
4825 */
4826static int
4827_scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num,
4828 u8 is_pd)
4829{
4830 Mpi2ConfigReply_t mpi_reply;
4831 Mpi2SasDevicePage0_t sas_device_pg0;
4832 Mpi2SasEnclosurePage0_t enclosure_pg0;
4833 struct _sas_device *sas_device;
4834 u32 ioc_status;
4835 u64 sas_address;
4836 u32 device_info;
4837 unsigned long flags;
4838
4839 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4840 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
4841 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4842 ioc->name, __FILE__, __LINE__, __func__);
4843 return -1;
4844 }
4845
4846 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4847 MPI2_IOCSTATUS_MASK;
4848 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4849 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4850 ioc->name, __FILE__, __LINE__, __func__);
4851 return -1;
4852 }
4853
4854 /* check if this is end device */
4855 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
4856 if (!(_scsih_is_end_device(device_info)))
4857 return -1;
4858 sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
4859
4860 /* check if device is present */
4861 if (!(le16_to_cpu(sas_device_pg0.Flags) &
4862 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
4863 pr_err(MPT3SAS_FMT "device is not present handle(0x04%x)!!!\n",
4864 ioc->name, handle);
4865 return -1;
4866 }
4867
4868 /* check if there were any issues with discovery */
4869 if (_scsih_check_access_status(ioc, sas_address, handle,
4870 sas_device_pg0.AccessStatus))
4871 return -1;
4872
4873 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4874 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
4875 sas_address);
4876 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4877
4878 if (sas_device)
4879 return -1;
4880
4881 sas_device = kzalloc(sizeof(struct _sas_device),
4882 GFP_KERNEL);
4883 if (!sas_device) {
4884 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4885 ioc->name, __FILE__, __LINE__, __func__);
4886 return 0;
4887 }
4888
4889 sas_device->handle = handle;
4890 if (_scsih_get_sas_address(ioc,
4891 le16_to_cpu(sas_device_pg0.ParentDevHandle),
4892 &sas_device->sas_address_parent) != 0)
4893 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4894 ioc->name, __FILE__, __LINE__, __func__);
4895 sas_device->enclosure_handle =
4896 le16_to_cpu(sas_device_pg0.EnclosureHandle);
4897 sas_device->slot =
4898 le16_to_cpu(sas_device_pg0.Slot);
4899 sas_device->device_info = device_info;
4900 sas_device->sas_address = sas_address;
4901 sas_device->phy = sas_device_pg0.PhyNum;
4902 sas_device->fast_path = (le16_to_cpu(sas_device_pg0.Flags) &
4903 MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0;
4904
4905 /* get enclosure_logical_id */
4906 if (sas_device->enclosure_handle && !(mpt3sas_config_get_enclosure_pg0(
4907 ioc, &mpi_reply, &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
4908 sas_device->enclosure_handle)))
4909 sas_device->enclosure_logical_id =
4910 le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
4911
4912 /* get device name */
4913 sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName);
4914
4915 if (ioc->wait_for_discovery_to_complete)
4916 _scsih_sas_device_init_add(ioc, sas_device);
4917 else
4918 _scsih_sas_device_add(ioc, sas_device);
4919
4920 return 0;
4921}
4922
4923/**
4924 * _scsih_remove_device - removing sas device object
4925 * @ioc: per adapter object
4926 * @sas_device_delete: the sas_device object
4927 *
4928 * Return nothing.
4929 */
4930static void
4931_scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
4932 struct _sas_device *sas_device)
4933{
4934 struct MPT3SAS_TARGET *sas_target_priv_data;
4935
0f624c39
SR		 4936 if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) &&
4937 (sas_device->pfa_led_on)) {
4938 _scsih_turn_off_pfa_led(ioc, sas_device);
4939 sas_device->pfa_led_on = 0;
4940 }
f92363d1
SR		 4941 dewtprintk(ioc, pr_info(MPT3SAS_FMT
4942 "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n",
4943 ioc->name, __func__,
4944 sas_device->handle, (unsigned long long)
4945 sas_device->sas_address));
4946
4947 if (sas_device->starget && sas_device->starget->hostdata) {
4948 sas_target_priv_data = sas_device->starget->hostdata;
4949 sas_target_priv_data->deleted = 1;
4950 _scsih_ublock_io_device(ioc, sas_device->sas_address);
4951 sas_target_priv_data->handle =
4952 MPT3SAS_INVALID_DEVICE_HANDLE;
4953 }
4954 mpt3sas_transport_port_remove(ioc,
4955 sas_device->sas_address,
4956 sas_device->sas_address_parent);
4957
4958 pr_info(MPT3SAS_FMT
4959 "removing handle(0x%04x), sas_addr(0x%016llx)\n",
4960 ioc->name, sas_device->handle,
4961 (unsigned long long) sas_device->sas_address);
4962
4963 dewtprintk(ioc, pr_info(MPT3SAS_FMT
4964 "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n",
4965 ioc->name, __func__,
4966 sas_device->handle, (unsigned long long)
4967 sas_device->sas_address));
4968
4969 kfree(sas_device);
4970}
4971
4972#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
4973/**
4974 * _scsih_sas_topology_change_event_debug - debug for topology event
4975 * @ioc: per adapter object
4976 * @event_data: event data payload
4977 * Context: user.
4978 */
4979static void
4980_scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
4981 Mpi2EventDataSasTopologyChangeList_t *event_data)
4982{
4983 int i;
4984 u16 handle;
4985 u16 reason_code;
4986 u8 phy_number;
4987 char *status_str = NULL;
4988 u8 link_rate, prev_link_rate;
4989
4990 switch (event_data->ExpStatus) {
4991 case MPI2_EVENT_SAS_TOPO_ES_ADDED:
4992 status_str = "add";
4993 break;
4994 case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING:
4995 status_str = "remove";
4996 break;
4997 case MPI2_EVENT_SAS_TOPO_ES_RESPONDING:
4998 case 0:
4999 status_str = "responding";
5000 break;
5001 case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING:
5002 status_str = "remove delay";
5003 break;
5004 default:
5005 status_str = "unknown status";
5006 break;
5007 }
5008 pr_info(MPT3SAS_FMT "sas topology change: (%s)\n",
5009 ioc->name, status_str);
5010 pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \
5011 "start_phy(%02d), count(%d)\n",
5012 le16_to_cpu(event_data->ExpanderDevHandle),
5013 le16_to_cpu(event_data->EnclosureHandle),
5014 event_data->StartPhyNum, event_data->NumEntries);
5015 for (i = 0; i < event_data->NumEntries; i++) {
5016 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
5017 if (!handle)
5018 continue;
5019 phy_number = event_data->StartPhyNum + i;
5020 reason_code = event_data->PHY[i].PhyStatus &
5021 MPI2_EVENT_SAS_TOPO_RC_MASK;
5022 switch (reason_code) {
5023 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
5024 status_str = "target add";
5025 break;
5026 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
5027 status_str = "target remove";
5028 break;
5029 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
5030 status_str = "delay target remove";
5031 break;
5032 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
5033 status_str = "link rate change";
5034 break;
5035 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
5036 status_str = "target responding";
5037 break;
5038 default:
5039 status_str = "unknown";
5040 break;
5041 }
5042 link_rate = event_data->PHY[i].LinkRate >> 4;
5043 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
5044 pr_info("\tphy(%02d), attached_handle(0x%04x): %s:" \
5045 " link rate: new(0x%02x), old(0x%02x)\n", phy_number,
5046 handle, status_str, link_rate, prev_link_rate);
5047
5048 }
5049}
5050#endif
5051
5052/**
5053 * _scsih_sas_topology_change_event - handle topology changes
5054 * @ioc: per adapter object
5055 * @fw_event: The fw_event_work object
5056 * Context: user.
5057 *
5058 */
5059static int
5060_scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
5061 struct fw_event_work *fw_event)
5062{
5063 int i;
5064 u16 parent_handle, handle;
5065 u16 reason_code;
5066 u8 phy_number, max_phys;
5067 struct _sas_node *sas_expander;
5068 u64 sas_address;
5069 unsigned long flags;
5070 u8 link_rate, prev_link_rate;
35b62362
JL		 5071 Mpi2EventDataSasTopologyChangeList_t *event_data =
5072 (Mpi2EventDataSasTopologyChangeList_t *)
5073 fw_event->event_data;
f92363d1
SR		 5074
5075#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
5076 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5077 _scsih_sas_topology_change_event_debug(ioc, event_data);
5078#endif
5079
5080 if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery)
5081 return 0;
5082
5083 if (!ioc->sas_hba.num_phys)
5084 _scsih_sas_host_add(ioc);
5085 else
5086 _scsih_sas_host_refresh(ioc);
5087
5088 if (fw_event->ignore) {
5089 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5090 "ignoring expander event\n", ioc->name));
5091 return 0;
5092 }
5093
5094 parent_handle = le16_to_cpu(event_data->ExpanderDevHandle);
5095
5096 /* handle expander add */
5097 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED)
5098 if (_scsih_expander_add(ioc, parent_handle) != 0)
5099 return 0;
5100
5101 spin_lock_irqsave(&ioc->sas_node_lock, flags);
5102 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
5103 parent_handle);
5104 if (sas_expander) {
5105 sas_address = sas_expander->sas_address;
5106 max_phys = sas_expander->num_phys;
5107 } else if (parent_handle < ioc->sas_hba.num_phys) {
5108 sas_address = ioc->sas_hba.sas_address;
5109 max_phys = ioc->sas_hba.num_phys;
5110 } else {
5111 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5112 return 0;
5113 }
5114 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5115
5116 /* handle siblings events */
5117 for (i = 0; i < event_data->NumEntries; i++) {
5118 if (fw_event->ignore) {
5119 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5120 "ignoring expander event\n", ioc->name));
5121 return 0;
5122 }
5123 if (ioc->remove_host || ioc->pci_error_recovery)
5124 return 0;
5125 phy_number = event_data->StartPhyNum + i;
5126 if (phy_number >= max_phys)
5127 continue;
5128 reason_code = event_data->PHY[i].PhyStatus &
5129 MPI2_EVENT_SAS_TOPO_RC_MASK;
5130 if ((event_data->PHY[i].PhyStatus &
5131 MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code !=
5132 MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING))
5133 continue;
5134 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
5135 if (!handle)
5136 continue;
5137 link_rate = event_data->PHY[i].LinkRate >> 4;
5138 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
5139 switch (reason_code) {
5140 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
5141
5142 if (ioc->shost_recovery)
5143 break;
5144
5145 if (link_rate == prev_link_rate)
5146 break;
5147
5148 mpt3sas_transport_update_links(ioc, sas_address,
5149 handle, phy_number, link_rate);
5150
5151 if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
5152 break;
5153
5154 _scsih_check_device(ioc, sas_address, handle,
5155 phy_number, link_rate);
5156
5157
5158 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
5159
5160 if (ioc->shost_recovery)
5161 break;
5162
5163 mpt3sas_transport_update_links(ioc, sas_address,
5164 handle, phy_number, link_rate);
5165
5166 _scsih_add_device(ioc, handle, phy_number, 0);
5167
5168 break;
5169 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
5170
5171 _scsih_device_remove_by_handle(ioc, handle);
5172 break;
5173 }
5174 }
5175
5176 /* handle expander removal */
5177 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING &&
5178 sas_expander)
5179 mpt3sas_expander_remove(ioc, sas_address);
5180
5181 return 0;
5182}
5183
5184#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
5185/**
5186 * _scsih_sas_device_status_change_event_debug - debug for device event
5187 * @event_data: event data payload
5188 * Context: user.
5189 *
5190 * Return nothing.
5191 */
5192static void
5193_scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
5194 Mpi2EventDataSasDeviceStatusChange_t *event_data)
5195{
5196 char *reason_str = NULL;
5197
5198 switch (event_data->ReasonCode) {
5199 case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
5200 reason_str = "smart data";
5201 break;
5202 case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
5203 reason_str = "unsupported device discovered";
5204 break;
5205 case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
5206 reason_str = "internal device reset";
5207 break;
5208 case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
5209 reason_str = "internal task abort";
5210 break;
5211 case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
5212 reason_str = "internal task abort set";
5213 break;
5214 case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
5215 reason_str = "internal clear task set";
5216 break;
5217 case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
5218 reason_str = "internal query task";
5219 break;
5220 case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE:
5221 reason_str = "sata init failure";
5222 break;
5223 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
5224 reason_str = "internal device reset complete";
5225 break;
5226 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
5227 reason_str = "internal task abort complete";
5228 break;
5229 case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
5230 reason_str = "internal async notification";
5231 break;
5232 case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY:
5233 reason_str = "expander reduced functionality";
5234 break;
5235 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY:
5236 reason_str = "expander reduced functionality complete";
5237 break;
5238 default:
5239 reason_str = "unknown reason";
5240 break;
5241 }
5242 pr_info(MPT3SAS_FMT "device status change: (%s)\n"
5243 "\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
5244 ioc->name, reason_str, le16_to_cpu(event_data->DevHandle),
5245 (unsigned long long)le64_to_cpu(event_data->SASAddress),
5246 le16_to_cpu(event_data->TaskTag));
5247 if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA)
5248 pr_info(MPT3SAS_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
5249 event_data->ASC, event_data->ASCQ);
5250 pr_info("\n");
5251}
5252#endif
5253
5254/**
5255 * _scsih_sas_device_status_change_event - handle device status change
5256 * @ioc: per adapter object
5257 * @fw_event: The fw_event_work object
5258 * Context: user.
5259 *
5260 * Return nothing.
5261 */
5262static void
5263_scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
5264 struct fw_event_work *fw_event)
5265{
5266 struct MPT3SAS_TARGET *target_priv_data;
5267 struct _sas_device *sas_device;
5268 u64 sas_address;
5269 unsigned long flags;
5270 Mpi2EventDataSasDeviceStatusChange_t *event_data =
35b62362
JL		 5271 (Mpi2EventDataSasDeviceStatusChange_t *)
5272 fw_event->event_data;
f92363d1
SR		 5273
5274#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
5275 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5276 _scsih_sas_device_status_change_event_debug(ioc,
5277 event_data);
5278#endif
5279
5280 /* In MPI Revision K (0xC), the internal device reset complete was
5281 * implemented, so avoid setting tm_busy flag for older firmware.
5282 */
5283 if ((ioc->facts.HeaderVersion >> 8) < 0xC)
5284 return;
5285
5286 if (event_data->ReasonCode !=
5287 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
5288 event_data->ReasonCode !=
5289 MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET)
5290 return;
5291
5292 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5293 sas_address = le64_to_cpu(event_data->SASAddress);
5294 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
5295 sas_address);
5296
5297 if (!sas_device || !sas_device->starget) {
5298 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5299 return;
5300 }
5301
5302 target_priv_data = sas_device->starget->hostdata;
5303 if (!target_priv_data) {
5304 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5305 return;
5306 }
5307
5308 if (event_data->ReasonCode ==
5309 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
5310 target_priv_data->tm_busy = 1;
5311 else
5312 target_priv_data->tm_busy = 0;
5313 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5314}
5315
5316#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
5317/**
5318 * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure
5319 * event
5320 * @ioc: per adapter object
5321 * @event_data: event data payload
5322 * Context: user.
5323 *
5324 * Return nothing.
5325 */
5326static void
5327_scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
5328 Mpi2EventDataSasEnclDevStatusChange_t *event_data)
5329{
5330 char *reason_str = NULL;
5331
5332 switch (event_data->ReasonCode) {
5333 case MPI2_EVENT_SAS_ENCL_RC_ADDED:
5334 reason_str = "enclosure add";
5335 break;
5336 case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
5337 reason_str = "enclosure remove";
5338 break;
5339 default:
5340 reason_str = "unknown reason";
5341 break;
5342 }
5343
5344 pr_info(MPT3SAS_FMT "enclosure status change: (%s)\n"
5345 "\thandle(0x%04x), enclosure logical id(0x%016llx)"
5346 " number slots(%d)\n", ioc->name, reason_str,
5347 le16_to_cpu(event_data->EnclosureHandle),
5348 (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID),
5349 le16_to_cpu(event_data->StartSlot));
5350}
5351#endif
5352
5353/**
5354 * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events
5355 * @ioc: per adapter object
5356 * @fw_event: The fw_event_work object
5357 * Context: user.
5358 *
5359 * Return nothing.
5360 */
5361static void
5362_scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc,
5363 struct fw_event_work *fw_event)
5364{
5365#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
5366 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5367 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
35b62362 5368 (Mpi2EventDataSasEnclDevStatusChange_t *)
f92363d1
SR		 5369 fw_event->event_data);
5370#endif
5371}
5372
5373/**
5374 * _scsih_sas_broadcast_primitive_event - handle broadcast events
5375 * @ioc: per adapter object
5376 * @fw_event: The fw_event_work object
5377 * Context: user.
5378 *
5379 * Return nothing.
5380 */
5381static void
5382_scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc,
5383 struct fw_event_work *fw_event)
5384{
5385 struct scsi_cmnd *scmd;
5386 struct scsi_device *sdev;
5387 u16 smid, handle;
5388 u32 lun;
5389 struct MPT3SAS_DEVICE *sas_device_priv_data;
5390 u32 termination_count;
5391 u32 query_count;
5392 Mpi2SCSITaskManagementReply_t *mpi_reply;
35b62362
JL		 5393 Mpi2EventDataSasBroadcastPrimitive_t *event_data =
5394 (Mpi2EventDataSasBroadcastPrimitive_t *)
5395 fw_event->event_data;
f92363d1
SR		 5396 u16 ioc_status;
5397 unsigned long flags;
5398 int r;
5399 u8 max_retries = 0;
5400 u8 task_abort_retries;
5401
5402 mutex_lock(&ioc->tm_cmds.mutex);
5403 pr_info(MPT3SAS_FMT
5404 "%s: enter: phy number(%d), width(%d)\n",
5405 ioc->name, __func__, event_data->PhyNum,
5406 event_data->PortWidth);
5407
5408 _scsih_block_io_all_device(ioc);
5409
5410 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5411 mpi_reply = ioc->tm_cmds.reply;
5412 broadcast_aen_retry:
5413
5414 /* sanity checks for retrying this loop */
5415 if (max_retries++ == 5) {
5416 dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: giving up\n",
5417 ioc->name, __func__));
5418 goto out;
5419 } else if (max_retries > 1)
5420 dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: %d retry\n",
5421 ioc->name, __func__, max_retries - 1));
5422
5423 termination_count = 0;
5424 query_count = 0;
5425 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
5426 if (ioc->shost_recovery)
5427 goto out;
5428 scmd = _scsih_scsi_lookup_get(ioc, smid);
5429 if (!scmd)
5430 continue;
5431 sdev = scmd->device;
5432 sas_device_priv_data = sdev->hostdata;
5433 if (!sas_device_priv_data || !sas_device_priv_data->sas_target)
5434 continue;
5435 /* skip hidden raid components */
5436 if (sas_device_priv_data->sas_target->flags &
5437 MPT_TARGET_FLAGS_RAID_COMPONENT)
5438 continue;
5439 /* skip volumes */
5440 if (sas_device_priv_data->sas_target->flags &
5441 MPT_TARGET_FLAGS_VOLUME)
5442 continue;
5443
5444 handle = sas_device_priv_data->sas_target->handle;
5445 lun = sas_device_priv_data->lun;
5446 query_count++;
5447
5448 if (ioc->shost_recovery)
5449 goto out;
5450
5451 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5452 r = mpt3sas_scsih_issue_tm(ioc, handle, 0, 0, lun,
c62e46de 5453 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30,
f92363d1
SR		 5454 TM_MUTEX_OFF);
5455 if (r == FAILED) {
5456 sdev_printk(KERN_WARNING, sdev,
5457 "mpt3sas_scsih_issue_tm: FAILED when sending "
5458 "QUERY_TASK: scmd(%p)\n", scmd);
5459 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5460 goto broadcast_aen_retry;
5461 }
5462 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
5463 & MPI2_IOCSTATUS_MASK;
5464 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5465 sdev_printk(KERN_WARNING, sdev,
5466 "query task: FAILED with IOCSTATUS(0x%04x), scmd(%p)\n",
5467 ioc_status, scmd);
5468 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5469 goto broadcast_aen_retry;
5470 }
5471
5472 /* see if IO is still owned by IOC and target */
5473 if (mpi_reply->ResponseCode ==
5474 MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
5475 mpi_reply->ResponseCode ==
5476 MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) {
5477 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5478 continue;
5479 }
5480 task_abort_retries = 0;
5481 tm_retry:
5482 if (task_abort_retries++ == 60) {
5483 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5484 "%s: ABORT_TASK: giving up\n", ioc->name,
5485 __func__));
5486 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5487 goto broadcast_aen_retry;
5488 }
5489
5490 if (ioc->shost_recovery)
5491 goto out_no_lock;
5492
5493 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id,
5494 sdev->lun, MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30,
c62e46de 5495 TM_MUTEX_OFF);
f92363d1
SR		 5496 if (r == FAILED) {
5497 sdev_printk(KERN_WARNING, sdev,
5498 "mpt3sas_scsih_issue_tm: ABORT_TASK: FAILED : "
5499 "scmd(%p)\n", scmd);
5500 goto tm_retry;
5501 }
5502
5503 if (task_abort_retries > 1)
5504 sdev_printk(KERN_WARNING, sdev,
5505 "mpt3sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):"
5506 " scmd(%p)\n",
5507 task_abort_retries - 1, scmd);
5508
5509 termination_count += le32_to_cpu(mpi_reply->TerminationCount);
5510 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5511 }
5512
5513 if (ioc->broadcast_aen_pending) {
5514 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5515 "%s: loop back due to pending AEN\n",
5516 ioc->name, __func__));
5517 ioc->broadcast_aen_pending = 0;
5518 goto broadcast_aen_retry;
5519 }
5520
5521 out:
5522 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5523 out_no_lock:
5524
5525 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5526 "%s - exit, query_count = %d termination_count = %d\n",
5527 ioc->name, __func__, query_count, termination_count));
5528
5529 ioc->broadcast_aen_busy = 0;
5530 if (!ioc->shost_recovery)
5531 _scsih_ublock_io_all_device(ioc);
5532 mutex_unlock(&ioc->tm_cmds.mutex);
5533}
5534
5535/**
5536 * _scsih_sas_discovery_event - handle discovery events
5537 * @ioc: per adapter object
5538 * @fw_event: The fw_event_work object
5539 * Context: user.
5540 *
5541 * Return nothing.
5542 */
5543static void
5544_scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc,
5545 struct fw_event_work *fw_event)
5546{
35b62362
JL		 5547 Mpi2EventDataSasDiscovery_t *event_data =
5548 (Mpi2EventDataSasDiscovery_t *) fw_event->event_data;
f92363d1
SR		 5549
5550#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
5551 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
5552 pr_info(MPT3SAS_FMT "discovery event: (%s)", ioc->name,
5553 (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ?
5554 "start" : "stop");
5555 if (event_data->DiscoveryStatus)
5556 pr_info("discovery_status(0x%08x)",
5557 le32_to_cpu(event_data->DiscoveryStatus));
5558 pr_info("\n");
5559 }
5560#endif
5561
5562 if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
5563 !ioc->sas_hba.num_phys) {
5564 if (disable_discovery > 0 && ioc->shost_recovery) {
5565 /* Wait for the reset to complete */
5566 while (ioc->shost_recovery)
5567 ssleep(1);
5568 }
5569 _scsih_sas_host_add(ioc);
5570 }
5571}
5572
5573/**
5574 * _scsih_ir_fastpath - turn on fastpath for IR physdisk
5575 * @ioc: per adapter object
5576 * @handle: device handle for physical disk
5577 * @phys_disk_num: physical disk number
5578 *
5579 * Return 0 for success, else failure.
5580 */
5581static int
5582_scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num)
5583{
5584 Mpi2RaidActionRequest_t *mpi_request;
5585 Mpi2RaidActionReply_t *mpi_reply;
5586 u16 smid;
5587 u8 issue_reset = 0;
5588 int rc = 0;
5589 u16 ioc_status;
5590 u32 log_info;
5591
5592
5593 mutex_lock(&ioc->scsih_cmds.mutex);
5594
5595 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
5596 pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n",
5597 ioc->name, __func__);
5598 rc = -EAGAIN;
5599 goto out;
5600 }
5601 ioc->scsih_cmds.status = MPT3_CMD_PENDING;
5602
5603 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
5604 if (!smid) {
5605 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
5606 ioc->name, __func__);
5607 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
5608 rc = -EAGAIN;
5609 goto out;
5610 }
5611
5612 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
5613 ioc->scsih_cmds.smid = smid;
5614 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
5615
5616 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
5617 mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN;
5618 mpi_request->PhysDiskNum = phys_disk_num;
5619
5620 dewtprintk(ioc, pr_info(MPT3SAS_FMT "IR RAID_ACTION: turning fast "\
5621 "path on for handle(0x%04x), phys_disk_num (0x%02x)\n", ioc->name,
5622 handle, phys_disk_num));
5623
5624 init_completion(&ioc->scsih_cmds.done);
5625 mpt3sas_base_put_smid_default(ioc, smid);
5626 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
5627
5628 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
5629 pr_err(MPT3SAS_FMT "%s: timeout\n",
5630 ioc->name, __func__);
5631 if (!(ioc->scsih_cmds.status & MPT3_CMD_RESET))
5632 issue_reset = 1;
5633 rc = -EFAULT;
5634 goto out;
5635 }
5636
5637 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
5638
5639 mpi_reply = ioc->scsih_cmds.reply;
5640 ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
5641 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
5642 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
5643 else
5644 log_info = 0;
5645 ioc_status &= MPI2_IOCSTATUS_MASK;
5646 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5647 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5648 "IR RAID_ACTION: failed: ioc_status(0x%04x), "
5649 "loginfo(0x%08x)!!!\n", ioc->name, ioc_status,
5650 log_info));
5651 rc = -EFAULT;
5652 } else
5653 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5654 "IR RAID_ACTION: completed successfully\n",
5655 ioc->name));
5656 }
5657
5658 out:
5659 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
5660 mutex_unlock(&ioc->scsih_cmds.mutex);
5661
5662 if (issue_reset)
5663 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
5664 FORCE_BIG_HAMMER);
5665 return rc;
5666}
5667
5668/**
5669 * _scsih_reprobe_lun - reprobing lun
5670 * @sdev: scsi device struct
5671 * @no_uld_attach: sdev->no_uld_attach flag setting
5672 *
5673 **/
5674static void
5675_scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
5676{
5677 int rc;
5678 sdev->no_uld_attach = no_uld_attach ? 1 : 0;
5679 sdev_printk(KERN_INFO, sdev, "%s raid component\n",
5680 sdev->no_uld_attach ? "hidding" : "exposing");
5681 rc = scsi_device_reprobe(sdev);
5682}
5683
5684/**
5685 * _scsih_sas_volume_add - add new volume
5686 * @ioc: per adapter object
5687 * @element: IR config element data
5688 * Context: user.
5689 *
5690 * Return nothing.
5691 */
5692static void
5693_scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc,
5694 Mpi2EventIrConfigElement_t *element)
5695{
5696 struct _raid_device *raid_device;
5697 unsigned long flags;
5698 u64 wwid;
5699 u16 handle = le16_to_cpu(element->VolDevHandle);
5700 int rc;
5701
5702 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
5703 if (!wwid) {
5704 pr_err(MPT3SAS_FMT
5705 "failure at %s:%d/%s()!\n", ioc->name,
5706 __FILE__, __LINE__, __func__);
5707 return;
5708 }
5709
5710 spin_lock_irqsave(&ioc->raid_device_lock, flags);
5711 raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
5712 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
5713
5714 if (raid_device)
5715 return;
5716
5717 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
5718 if (!raid_device) {
5719 pr_err(MPT3SAS_FMT
5720 "failure at %s:%d/%s()!\n", ioc->name,
5721 __FILE__, __LINE__, __func__);
5722 return;
5723 }
5724
5725 raid_device->id = ioc->sas_id++;
5726 raid_device->channel = RAID_CHANNEL;
5727 raid_device->handle = handle;
5728 raid_device->wwid = wwid;
5729 _scsih_raid_device_add(ioc, raid_device);
5730 if (!ioc->wait_for_discovery_to_complete) {
5731 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
5732 raid_device->id, 0);
5733 if (rc)
5734 _scsih_raid_device_remove(ioc, raid_device);
5735 } else {
5736 spin_lock_irqsave(&ioc->raid_device_lock, flags);
5737 _scsih_determine_boot_device(ioc, raid_device, 1);
5738 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
5739 }
5740}
5741
5742/**
5743 * _scsih_sas_volume_delete - delete volume
5744 * @ioc: per adapter object
5745 * @handle: volume device handle
5746 * Context: user.
5747 *
5748 * Return nothing.
5749 */
5750static void
5751_scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5752{
5753 struct _raid_device *raid_device;
5754 unsigned long flags;
5755 struct MPT3SAS_TARGET *sas_target_priv_data;
5756 struct scsi_target *starget = NULL;
5757
5758 spin_lock_irqsave(&ioc->raid_device_lock, flags);
5759 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
5760 if (raid_device) {
5761 if (raid_device->starget) {
5762 starget = raid_device->starget;
5763 sas_target_priv_data = starget->hostdata;
5764 sas_target_priv_data->deleted = 1;
5765 }
5766 pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n",
5767 ioc->name, raid_device->handle,
5768 (unsigned long long) raid_device->wwid);
5769 list_del(&raid_device->list);
5770 kfree(raid_device);
5771 }
5772 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
5773 if (starget)
5774 scsi_remove_target(&starget->dev);
5775}
5776
5777/**
5778 * _scsih_sas_pd_expose - expose pd component to /dev/sdX
5779 * @ioc: per adapter object
5780 * @element: IR config element data
5781 * Context: user.
5782 *
5783 * Return nothing.
5784 */
5785static void
5786_scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc,
5787 Mpi2EventIrConfigElement_t *element)
5788{
5789 struct _sas_device *sas_device;
5790 struct scsi_target *starget = NULL;
5791 struct MPT3SAS_TARGET *sas_target_priv_data;
5792 unsigned long flags;
5793 u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
5794
5795 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5796 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5797 if (sas_device) {
5798 sas_device->volume_handle = 0;
5799 sas_device->volume_wwid = 0;
5800 clear_bit(handle, ioc->pd_handles);
5801 if (sas_device->starget && sas_device->starget->hostdata) {
5802 starget = sas_device->starget;
5803 sas_target_priv_data = starget->hostdata;
5804 sas_target_priv_data->flags &=
5805 ~MPT_TARGET_FLAGS_RAID_COMPONENT;
5806 }
5807 }
5808 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5809 if (!sas_device)
5810 return;
5811
5812 /* exposing raid component */
5813 if (starget)
5814 starget_for_each_device(starget, NULL, _scsih_reprobe_lun);
5815}
5816
5817/**
5818 * _scsih_sas_pd_hide - hide pd component from /dev/sdX
5819 * @ioc: per adapter object
5820 * @element: IR config element data
5821 * Context: user.
5822 *
5823 * Return nothing.
5824 */
5825static void
5826_scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc,
5827 Mpi2EventIrConfigElement_t *element)
5828{
5829 struct _sas_device *sas_device;
5830 struct scsi_target *starget = NULL;
5831 struct MPT3SAS_TARGET *sas_target_priv_data;
5832 unsigned long flags;
5833 u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
5834 u16 volume_handle = 0;
5835 u64 volume_wwid = 0;
5836
5837 mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle);
5838 if (volume_handle)
5839 mpt3sas_config_get_volume_wwid(ioc, volume_handle,
5840 &volume_wwid);
5841
5842 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5843 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5844 if (sas_device) {
5845 set_bit(handle, ioc->pd_handles);
5846 if (sas_device->starget && sas_device->starget->hostdata) {
5847 starget = sas_device->starget;
5848 sas_target_priv_data = starget->hostdata;
5849 sas_target_priv_data->flags |=
5850 MPT_TARGET_FLAGS_RAID_COMPONENT;
5851 sas_device->volume_handle = volume_handle;
5852 sas_device->volume_wwid = volume_wwid;
5853 }
5854 }
5855 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5856 if (!sas_device)
5857 return;
5858
5859 /* hiding raid component */
5860 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
5861 if (starget)
5862 starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun);
5863}
5864
5865/**
5866 * _scsih_sas_pd_delete - delete pd component
5867 * @ioc: per adapter object
5868 * @element: IR config element data
5869 * Context: user.
5870 *
5871 * Return nothing.
5872 */
5873static void
5874_scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc,
5875 Mpi2EventIrConfigElement_t *element)
5876{
5877 u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
5878
5879 _scsih_device_remove_by_handle(ioc, handle);
5880}
5881
5882/**
5883 * _scsih_sas_pd_add - remove pd component
5884 * @ioc: per adapter object
5885 * @element: IR config element data
5886 * Context: user.
5887 *
5888 * Return nothing.
5889 */
5890static void
5891_scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc,
5892 Mpi2EventIrConfigElement_t *element)
5893{
5894 struct _sas_device *sas_device;
5895 unsigned long flags;
5896 u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
5897 Mpi2ConfigReply_t mpi_reply;
5898 Mpi2SasDevicePage0_t sas_device_pg0;
5899 u32 ioc_status;
5900 u64 sas_address;
5901 u16 parent_handle;
5902
5903 set_bit(handle, ioc->pd_handles);
5904
5905 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5906 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5907 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5908 if (sas_device) {
5909 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
5910 return;
5911 }
5912
5913 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5914 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
5915 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5916 ioc->name, __FILE__, __LINE__, __func__);
5917 return;
5918 }
5919
5920 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5921 MPI2_IOCSTATUS_MASK;
5922 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5923 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5924 ioc->name, __FILE__, __LINE__, __func__);
5925 return;
5926 }
5927
5928 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
5929 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
5930 mpt3sas_transport_update_links(ioc, sas_address, handle,
5931 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
5932
5933 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
5934 _scsih_add_device(ioc, handle, 0, 1);
5935}
5936
5937#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
5938/**
5939 * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events
5940 * @ioc: per adapter object
5941 * @event_data: event data payload
5942 * Context: user.
5943 *
5944 * Return nothing.
5945 */
5946static void
5947_scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
5948 Mpi2EventDataIrConfigChangeList_t *event_data)
5949{
5950 Mpi2EventIrConfigElement_t *element;
5951 u8 element_type;
5952 int i;
5953 char *reason_str = NULL, *element_str = NULL;
5954
5955 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
5956
5957 pr_info(MPT3SAS_FMT "raid config change: (%s), elements(%d)\n",
5958 ioc->name, (le32_to_cpu(event_data->Flags) &
5959 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ?
5960 "foreign" : "native", event_data->NumElements);
5961 for (i = 0; i < event_data->NumElements; i++, element++) {
5962 switch (element->ReasonCode) {
5963 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
5964 reason_str = "add";
5965 break;
5966 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
5967 reason_str = "remove";
5968 break;
5969 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:
5970 reason_str = "no change";
5971 break;
5972 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
5973 reason_str = "hide";
5974 break;
5975 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
5976 reason_str = "unhide";
5977 break;
5978 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
5979 reason_str = "volume_created";
5980 break;
5981 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
5982 reason_str = "volume_deleted";
5983 break;
5984 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
5985 reason_str = "pd_created";
5986 break;
5987 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
5988 reason_str = "pd_deleted";
5989 break;
5990 default:
5991 reason_str = "unknown reason";
5992 break;
5993 }
5994 element_type = le16_to_cpu(element->ElementFlags) &
5995 MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
5996 switch (element_type) {
5997 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:
5998 element_str = "volume";
5999 break;
6000 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:
6001 element_str = "phys disk";
6002 break;
6003 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:
6004 element_str = "hot spare";
6005 break;
6006 default:
6007 element_str = "unknown element";
6008 break;
6009 }
6010 pr_info("\t(%s:%s), vol handle(0x%04x), " \
6011 "pd handle(0x%04x), pd num(0x%02x)\n", element_str,
6012 reason_str, le16_to_cpu(element->VolDevHandle),
6013 le16_to_cpu(element->PhysDiskDevHandle),
6014 element->PhysDiskNum);
6015 }
6016}
6017#endif
6018
6019/**
6020 * _scsih_sas_ir_config_change_event - handle ir configuration change events
6021 * @ioc: per adapter object
6022 * @fw_event: The fw_event_work object
6023 * Context: user.
6024 *
6025 * Return nothing.
6026 */
6027static void
6028_scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc,
6029 struct fw_event_work *fw_event)
6030{
6031 Mpi2EventIrConfigElement_t *element;
6032 int i;
6033 u8 foreign_config;
35b62362
JL		 6034 Mpi2EventDataIrConfigChangeList_t *event_data =
6035 (Mpi2EventDataIrConfigChangeList_t *)
6036 fw_event->event_data;
f92363d1
SR		 6037
6038#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
6039 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6040 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
6041
6042#endif
6043
6044 foreign_config = (le32_to_cpu(event_data->Flags) &
6045 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
6046
6047 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
6048 if (ioc->shost_recovery) {
6049
6050 for (i = 0; i < event_data->NumElements; i++, element++) {
6051 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_HIDE)
6052 _scsih_ir_fastpath(ioc,
6053 le16_to_cpu(element->PhysDiskDevHandle),
6054 element->PhysDiskNum);
6055 }
6056 return;
6057 }
6058 for (i = 0; i < event_data->NumElements; i++, element++) {
6059
6060 switch (element->ReasonCode) {
6061 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
6062 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
6063 if (!foreign_config)
6064 _scsih_sas_volume_add(ioc, element);
6065 break;
6066 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
6067 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
6068 if (!foreign_config)
6069 _scsih_sas_volume_delete(ioc,
6070 le16_to_cpu(element->VolDevHandle));
6071 break;
6072 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
6073 _scsih_sas_pd_hide(ioc, element);
6074 break;
6075 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
6076 _scsih_sas_pd_expose(ioc, element);
6077 break;
6078 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
6079 _scsih_sas_pd_add(ioc, element);
6080 break;
6081 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
6082 _scsih_sas_pd_delete(ioc, element);
6083 break;
6084 }
6085 }
6086}
6087
6088/**
6089 * _scsih_sas_ir_volume_event - IR volume event
6090 * @ioc: per adapter object
6091 * @fw_event: The fw_event_work object
6092 * Context: user.
6093 *
6094 * Return nothing.
6095 */
6096static void
6097_scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc,
6098 struct fw_event_work *fw_event)
6099{
6100 u64 wwid;
6101 unsigned long flags;
6102 struct _raid_device *raid_device;
6103 u16 handle;
6104 u32 state;
6105 int rc;
35b62362
JL		 6106 Mpi2EventDataIrVolume_t *event_data =
6107 (Mpi2EventDataIrVolume_t *) fw_event->event_data;
f92363d1
SR		 6108
6109 if (ioc->shost_recovery)
6110 return;
6111
6112 if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
6113 return;
6114
6115 handle = le16_to_cpu(event_data->VolDevHandle);
6116 state = le32_to_cpu(event_data->NewValue);
6117 dewtprintk(ioc, pr_info(MPT3SAS_FMT
6118 "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
6119 ioc->name, __func__, handle,
6120 le32_to_cpu(event_data->PreviousValue), state));
6121 switch (state) {
6122 case MPI2_RAID_VOL_STATE_MISSING:
6123 case MPI2_RAID_VOL_STATE_FAILED:
6124 _scsih_sas_volume_delete(ioc, handle);
6125 break;
6126
6127 case MPI2_RAID_VOL_STATE_ONLINE:
6128 case MPI2_RAID_VOL_STATE_DEGRADED:
6129 case MPI2_RAID_VOL_STATE_OPTIMAL:
6130
6131 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6132 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6133 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6134
6135 if (raid_device)
6136 break;
6137
6138 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
6139 if (!wwid) {
6140 pr_err(MPT3SAS_FMT
6141 "failure at %s:%d/%s()!\n", ioc->name,
6142 __FILE__, __LINE__, __func__);
6143 break;
6144 }
6145
6146 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
6147 if (!raid_device) {
6148 pr_err(MPT3SAS_FMT
6149 "failure at %s:%d/%s()!\n", ioc->name,
6150 __FILE__, __LINE__, __func__);
6151 break;
6152 }
6153
6154 raid_device->id = ioc->sas_id++;
6155 raid_device->channel = RAID_CHANNEL;
6156 raid_device->handle = handle;
6157 raid_device->wwid = wwid;
6158 _scsih_raid_device_add(ioc, raid_device);
6159 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6160 raid_device->id, 0);
6161 if (rc)
6162 _scsih_raid_device_remove(ioc, raid_device);
6163 break;
6164
6165 case MPI2_RAID_VOL_STATE_INITIALIZING:
6166 default:
6167 break;
6168 }
6169}
6170
6171/**
6172 * _scsih_sas_ir_physical_disk_event - PD event
6173 * @ioc: per adapter object
6174 * @fw_event: The fw_event_work object
6175 * Context: user.
6176 *
6177 * Return nothing.
6178 */
6179static void
6180_scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc,
6181 struct fw_event_work *fw_event)
6182{
6183 u16 handle, parent_handle;
6184 u32 state;
6185 struct _sas_device *sas_device;
6186 unsigned long flags;
6187 Mpi2ConfigReply_t mpi_reply;
6188 Mpi2SasDevicePage0_t sas_device_pg0;
6189 u32 ioc_status;
35b62362
JL		 6190 Mpi2EventDataIrPhysicalDisk_t *event_data =
6191 (Mpi2EventDataIrPhysicalDisk_t *) fw_event->event_data;
f92363d1
SR		 6192 u64 sas_address;
6193
6194 if (ioc->shost_recovery)
6195 return;
6196
6197 if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
6198 return;
6199
6200 handle = le16_to_cpu(event_data->PhysDiskDevHandle);
6201 state = le32_to_cpu(event_data->NewValue);
6202
6203 dewtprintk(ioc, pr_info(MPT3SAS_FMT
6204 "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
6205 ioc->name, __func__, handle,
6206 le32_to_cpu(event_data->PreviousValue), state));
6207 switch (state) {
6208 case MPI2_RAID_PD_STATE_ONLINE:
6209 case MPI2_RAID_PD_STATE_DEGRADED:
6210 case MPI2_RAID_PD_STATE_REBUILDING:
6211 case MPI2_RAID_PD_STATE_OPTIMAL:
6212 case MPI2_RAID_PD_STATE_HOT_SPARE:
6213
6214 set_bit(handle, ioc->pd_handles);
6215 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6216 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6217 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6218
6219 if (sas_device)
6220 return;
6221
6222 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6223 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
6224 handle))) {
6225 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6226 ioc->name, __FILE__, __LINE__, __func__);
6227 return;
6228 }
6229
6230 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6231 MPI2_IOCSTATUS_MASK;
6232 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6233 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6234 ioc->name, __FILE__, __LINE__, __func__);
6235 return;
6236 }
6237
6238 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6239 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6240 mpt3sas_transport_update_links(ioc, sas_address, handle,
6241 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
6242
6243 _scsih_add_device(ioc, handle, 0, 1);
6244
6245 break;
6246
6247 case MPI2_RAID_PD_STATE_OFFLINE:
6248 case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
6249 case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
6250 default:
6251 break;
6252 }
6253}
6254
6255#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
6256/**
6257 * _scsih_sas_ir_operation_status_event_debug - debug for IR op event
6258 * @ioc: per adapter object
6259 * @event_data: event data payload
6260 * Context: user.
6261 *
6262 * Return nothing.
6263 */
6264static void
6265_scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc,
6266 Mpi2EventDataIrOperationStatus_t *event_data)
6267{
6268 char *reason_str = NULL;
6269
6270 switch (event_data->RAIDOperation) {
6271 case MPI2_EVENT_IR_RAIDOP_RESYNC:
6272 reason_str = "resync";
6273 break;
6274 case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:
6275 reason_str = "online capacity expansion";
6276 break;
6277 case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
6278 reason_str = "consistency check";
6279 break;
6280 case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:
6281 reason_str = "background init";
6282 break;
6283 case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:
6284 reason_str = "make data consistent";
6285 break;
6286 }
6287
6288 if (!reason_str)
6289 return;
6290
6291 pr_info(MPT3SAS_FMT "raid operational status: (%s)" \
6292 "\thandle(0x%04x), percent complete(%d)\n",
6293 ioc->name, reason_str,
6294 le16_to_cpu(event_data->VolDevHandle),
6295 event_data->PercentComplete);
6296}
6297#endif
6298
6299/**
6300 * _scsih_sas_ir_operation_status_event - handle RAID operation events
6301 * @ioc: per adapter object
6302 * @fw_event: The fw_event_work object
6303 * Context: user.
6304 *
6305 * Return nothing.
6306 */
6307static void
6308_scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc,
6309 struct fw_event_work *fw_event)
6310{
35b62362
JL		 6311 Mpi2EventDataIrOperationStatus_t *event_data =
6312 (Mpi2EventDataIrOperationStatus_t *)
6313 fw_event->event_data;
f92363d1
SR		 6314 static struct _raid_device *raid_device;
6315 unsigned long flags;
6316 u16 handle;
6317
6318#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
6319 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6320 _scsih_sas_ir_operation_status_event_debug(ioc,
6321 event_data);
6322#endif
6323
6324 /* code added for raid transport support */
6325 if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
6326
6327 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6328 handle = le16_to_cpu(event_data->VolDevHandle);
6329 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6330 if (raid_device)
6331 raid_device->percent_complete =
6332 event_data->PercentComplete;
6333 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6334 }
6335}
6336
6337/**
6338 * _scsih_prep_device_scan - initialize parameters prior to device scan
6339 * @ioc: per adapter object
6340 *
6341 * Set the deleted flag prior to device scan. If the device is found during
6342 * the scan, then we clear the deleted flag.
6343 */
6344static void
6345_scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc)
6346{
6347 struct MPT3SAS_DEVICE *sas_device_priv_data;
6348 struct scsi_device *sdev;
6349
6350 shost_for_each_device(sdev, ioc->shost) {
6351 sas_device_priv_data = sdev->hostdata;
6352 if (sas_device_priv_data && sas_device_priv_data->sas_target)
6353 sas_device_priv_data->sas_target->deleted = 1;
6354 }
6355}
6356
6357/**
6358 * _scsih_mark_responding_sas_device - mark a sas_devices as responding
6359 * @ioc: per adapter object
6360 * @sas_address: sas address
6361 * @slot: enclosure slot id
6362 * @handle: device handle
6363 *
6364 * After host reset, find out whether devices are still responding.
6365 * Used in _scsih_remove_unresponsive_sas_devices.
6366 *
6367 * Return nothing.
6368 */
6369static void
6370_scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
6371 u16 slot, u16 handle)
6372{
6373 struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
6374 struct scsi_target *starget;
6375 struct _sas_device *sas_device;
6376 unsigned long flags;
6377
6378 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6379 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
6380 if (sas_device->sas_address == sas_address &&
6381 sas_device->slot == slot) {
6382 sas_device->responding = 1;
6383 starget = sas_device->starget;
6384 if (starget && starget->hostdata) {
6385 sas_target_priv_data = starget->hostdata;
6386 sas_target_priv_data->tm_busy = 0;
6387 sas_target_priv_data->deleted = 0;
6388 } else
6389 sas_target_priv_data = NULL;
6390 if (starget)
6391 starget_printk(KERN_INFO, starget,
6392 "handle(0x%04x), sas_addr(0x%016llx), "
6393 "enclosure logical id(0x%016llx), "
6394 "slot(%d)\n", handle,
6395 (unsigned long long)sas_device->sas_address,
6396 (unsigned long long)
6397 sas_device->enclosure_logical_id,
6398 sas_device->slot);
6399 if (sas_device->handle == handle)
6400 goto out;
6401 pr_info("\thandle changed from(0x%04x)!!!\n",
6402 sas_device->handle);
6403 sas_device->handle = handle;
6404 if (sas_target_priv_data)
6405 sas_target_priv_data->handle = handle;
6406 goto out;
6407 }
6408 }
6409 out:
6410 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6411}
6412
6413/**
6414 * _scsih_search_responding_sas_devices -
6415 * @ioc: per adapter object
6416 *
6417 * After host reset, find out whether devices are still responding.
6418 * If not remove.
6419 *
6420 * Return nothing.
6421 */
6422static void
6423_scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
6424{
6425 Mpi2SasDevicePage0_t sas_device_pg0;
6426 Mpi2ConfigReply_t mpi_reply;
6427 u16 ioc_status;
6428 u16 handle;
6429 u32 device_info;
6430
6431 pr_info(MPT3SAS_FMT "search for end-devices: start\n", ioc->name);
6432
6433 if (list_empty(&ioc->sas_device_list))
6434 goto out;
6435
6436 handle = 0xFFFF;
6437 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6438 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
6439 handle))) {
6440 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6441 MPI2_IOCSTATUS_MASK;
14be49ac 6442 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
f92363d1
SR		 6443 break;
6444 handle = le16_to_cpu(sas_device_pg0.DevHandle);
6445 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
6446 if (!(_scsih_is_end_device(device_info)))
6447 continue;
6448 _scsih_mark_responding_sas_device(ioc,
6449 le64_to_cpu(sas_device_pg0.SASAddress),
6450 le16_to_cpu(sas_device_pg0.Slot), handle);
6451 }
6452
6453 out:
6454 pr_info(MPT3SAS_FMT "search for end-devices: complete\n",
6455 ioc->name);
6456}
6457
6458/**
6459 * _scsih_mark_responding_raid_device - mark a raid_device as responding
6460 * @ioc: per adapter object
6461 * @wwid: world wide identifier for raid volume
6462 * @handle: device handle
6463 *
6464 * After host reset, find out whether devices are still responding.
6465 * Used in _scsih_remove_unresponsive_raid_devices.
6466 *
6467 * Return nothing.
6468 */
6469static void
6470_scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
6471 u16 handle)
6472{
6473 struct MPT3SAS_TARGET *sas_target_priv_data;
6474 struct scsi_target *starget;
6475 struct _raid_device *raid_device;
6476 unsigned long flags;
6477
6478 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6479 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
6480 if (raid_device->wwid == wwid && raid_device->starget) {
6481 starget = raid_device->starget;
6482 if (starget && starget->hostdata) {
6483 sas_target_priv_data = starget->hostdata;
6484 sas_target_priv_data->deleted = 0;
6485 } else
6486 sas_target_priv_data = NULL;
6487 raid_device->responding = 1;
6488 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6489 starget_printk(KERN_INFO, raid_device->starget,
6490 "handle(0x%04x), wwid(0x%016llx)\n", handle,
6491 (unsigned long long)raid_device->wwid);
6492 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6493 if (raid_device->handle == handle) {
6494 spin_unlock_irqrestore(&ioc->raid_device_lock,
6495 flags);
6496 return;
6497 }
6498 pr_info("\thandle changed from(0x%04x)!!!\n",
6499 raid_device->handle);
6500 raid_device->handle = handle;
6501 if (sas_target_priv_data)
6502 sas_target_priv_data->handle = handle;
6503 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6504 return;
6505 }
6506 }
6507 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6508}
6509
6510/**
6511 * _scsih_search_responding_raid_devices -
6512 * @ioc: per adapter object
6513 *
6514 * After host reset, find out whether devices are still responding.
6515 * If not remove.
6516 *
6517 * Return nothing.
6518 */
6519static void
6520_scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc)
6521{
6522 Mpi2RaidVolPage1_t volume_pg1;
6523 Mpi2RaidVolPage0_t volume_pg0;
6524 Mpi2RaidPhysDiskPage0_t pd_pg0;
6525 Mpi2ConfigReply_t mpi_reply;
6526 u16 ioc_status;
6527 u16 handle;
6528 u8 phys_disk_num;
6529
6530 if (!ioc->ir_firmware)
6531 return;
6532
6533 pr_info(MPT3SAS_FMT "search for raid volumes: start\n",
6534 ioc->name);
6535
6536 if (list_empty(&ioc->raid_device_list))
6537 goto out;
6538
6539 handle = 0xFFFF;
6540 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
6541 &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
6542 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6543 MPI2_IOCSTATUS_MASK;
14be49ac 6544 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
f92363d1
SR		 6545 break;
6546 handle = le16_to_cpu(volume_pg1.DevHandle);
6547
6548 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
6549 &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
6550 sizeof(Mpi2RaidVolPage0_t)))
6551 continue;
6552
6553 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
6554 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
6555 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED)
6556 _scsih_mark_responding_raid_device(ioc,
6557 le64_to_cpu(volume_pg1.WWID), handle);
6558 }
6559
6560 /* refresh the pd_handles */
6561 phys_disk_num = 0xFF;
6562 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
6563 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
6564 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
6565 phys_disk_num))) {
6566 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6567 MPI2_IOCSTATUS_MASK;
14be49ac 6568 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
f92363d1
SR		 6569 break;
6570 phys_disk_num = pd_pg0.PhysDiskNum;
6571 handle = le16_to_cpu(pd_pg0.DevHandle);
6572 set_bit(handle, ioc->pd_handles);
6573 }
6574 out:
6575 pr_info(MPT3SAS_FMT "search for responding raid volumes: complete\n",
6576 ioc->name);
6577}
6578
6579/**
6580 * _scsih_mark_responding_expander - mark a expander as responding
6581 * @ioc: per adapter object
6582 * @sas_address: sas address
6583 * @handle:
6584 *
6585 * After host reset, find out whether devices are still responding.
6586 * Used in _scsih_remove_unresponsive_expanders.
6587 *
6588 * Return nothing.
6589 */
6590static void
6591_scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
6592 u16 handle)
6593{
6594 struct _sas_node *sas_expander;
6595 unsigned long flags;
6596 int i;
6597
6598 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6599 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
6600 if (sas_expander->sas_address != sas_address)
6601 continue;
6602 sas_expander->responding = 1;
6603 if (sas_expander->handle == handle)
6604 goto out;
6605 pr_info("\texpander(0x%016llx): handle changed" \
6606 " from(0x%04x) to (0x%04x)!!!\n",
6607 (unsigned long long)sas_expander->sas_address,
6608 sas_expander->handle, handle);
6609 sas_expander->handle = handle;
6610 for (i = 0 ; i < sas_expander->num_phys ; i++)
6611 sas_expander->phy[i].handle = handle;
6612 goto out;
6613 }
6614 out:
6615 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6616}
6617
6618/**
6619 * _scsih_search_responding_expanders -
6620 * @ioc: per adapter object
6621 *
6622 * After host reset, find out whether devices are still responding.
6623 * If not remove.
6624 *
6625 * Return nothing.
6626 */
6627static void
6628_scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc)
6629{
6630 Mpi2ExpanderPage0_t expander_pg0;
6631 Mpi2ConfigReply_t mpi_reply;
6632 u16 ioc_status;
6633 u64 sas_address;
6634 u16 handle;
6635
6636 pr_info(MPT3SAS_FMT "search for expanders: start\n", ioc->name);
6637
6638 if (list_empty(&ioc->sas_expander_list))
6639 goto out;
6640
6641 handle = 0xFFFF;
6642 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
6643 MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
6644
6645 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6646 MPI2_IOCSTATUS_MASK;
14be49ac 6647 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
f92363d1
SR		 6648 break;
6649
6650 handle = le16_to_cpu(expander_pg0.DevHandle);
6651 sas_address = le64_to_cpu(expander_pg0.SASAddress);
6652 pr_info("\texpander present: handle(0x%04x), sas_addr(0x%016llx)\n",
6653 handle,
6654 (unsigned long long)sas_address);
6655 _scsih_mark_responding_expander(ioc, sas_address, handle);
6656 }
6657
6658 out:
6659 pr_info(MPT3SAS_FMT "search for expanders: complete\n", ioc->name);
6660}
6661
6662/**
6663 * _scsih_remove_unresponding_sas_devices - removing unresponding devices
6664 * @ioc: per adapter object
6665 *
6666 * Return nothing.
6667 */
6668static void
6669_scsih_remove_unresponding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
6670{
6671 struct _sas_device *sas_device, *sas_device_next;
6672 struct _sas_node *sas_expander, *sas_expander_next;
6673 struct _raid_device *raid_device, *raid_device_next;
6674 struct list_head tmp_list;
6675 unsigned long flags;
6676
6677 pr_info(MPT3SAS_FMT "removing unresponding devices: start\n",
6678 ioc->name);
6679
6680 /* removing unresponding end devices */
6681 pr_info(MPT3SAS_FMT "removing unresponding devices: end-devices\n",
6682 ioc->name);
6683 list_for_each_entry_safe(sas_device, sas_device_next,
6684 &ioc->sas_device_list, list) {
6685 if (!sas_device->responding)
6686 mpt3sas_device_remove_by_sas_address(ioc,
6687 sas_device->sas_address);
6688 else
6689 sas_device->responding = 0;
6690 }
6691
6692 /* removing unresponding volumes */
6693 if (ioc->ir_firmware) {
6694 pr_info(MPT3SAS_FMT "removing unresponding devices: volumes\n",
6695 ioc->name);
6696 list_for_each_entry_safe(raid_device, raid_device_next,
6697 &ioc->raid_device_list, list) {
6698 if (!raid_device->responding)
6699 _scsih_sas_volume_delete(ioc,
6700 raid_device->handle);
6701 else
6702 raid_device->responding = 0;
6703 }
6704 }
6705
6706 /* removing unresponding expanders */
6707 pr_info(MPT3SAS_FMT "removing unresponding devices: expanders\n",
6708 ioc->name);
6709 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6710 INIT_LIST_HEAD(&tmp_list);
6711 list_for_each_entry_safe(sas_expander, sas_expander_next,
6712 &ioc->sas_expander_list, list) {
6713 if (!sas_expander->responding)
6714 list_move_tail(&sas_expander->list, &tmp_list);
6715 else
6716 sas_expander->responding = 0;
6717 }
6718 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6719 list_for_each_entry_safe(sas_expander, sas_expander_next, &tmp_list,
6720 list) {
6721 list_del(&sas_expander->list);
6722 _scsih_expander_node_remove(ioc, sas_expander);
6723 }
6724
6725 pr_info(MPT3SAS_FMT "removing unresponding devices: complete\n",
6726 ioc->name);
6727
6728 /* unblock devices */
6729 _scsih_ublock_io_all_device(ioc);
6730}
6731
6732static void
6733_scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc,
6734 struct _sas_node *sas_expander, u16 handle)
6735{
6736 Mpi2ExpanderPage1_t expander_pg1;
6737 Mpi2ConfigReply_t mpi_reply;
6738 int i;
6739
6740 for (i = 0 ; i < sas_expander->num_phys ; i++) {
6741 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
6742 &expander_pg1, i, handle))) {
6743 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6744 ioc->name, __FILE__, __LINE__, __func__);
6745 return;
6746 }
6747
6748 mpt3sas_transport_update_links(ioc, sas_expander->sas_address,
6749 le16_to_cpu(expander_pg1.AttachedDevHandle), i,
6750 expander_pg1.NegotiatedLinkRate >> 4);
6751 }
6752}
6753
6754/**
6755 * _scsih_scan_for_devices_after_reset - scan for devices after host reset
6756 * @ioc: per adapter object
6757 *
6758 * Return nothing.
6759 */
6760static void
6761_scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc)
6762{
6763 Mpi2ExpanderPage0_t expander_pg0;
6764 Mpi2SasDevicePage0_t sas_device_pg0;
6765 Mpi2RaidVolPage1_t volume_pg1;
6766 Mpi2RaidVolPage0_t volume_pg0;
6767 Mpi2RaidPhysDiskPage0_t pd_pg0;
6768 Mpi2EventIrConfigElement_t element;
6769 Mpi2ConfigReply_t mpi_reply;
6770 u8 phys_disk_num;
6771 u16 ioc_status;
6772 u16 handle, parent_handle;
6773 u64 sas_address;
6774 struct _sas_device *sas_device;
6775 struct _sas_node *expander_device;
6776 static struct _raid_device *raid_device;
6777 u8 retry_count;
6778 unsigned long flags;
6779
6780 pr_info(MPT3SAS_FMT "scan devices: start\n", ioc->name);
6781
6782 _scsih_sas_host_refresh(ioc);
6783
6784 pr_info(MPT3SAS_FMT "\tscan devices: expanders start\n", ioc->name);
6785
6786 /* expanders */
6787 handle = 0xFFFF;
6788 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
6789 MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
6790 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6791 MPI2_IOCSTATUS_MASK;
f92363d1
SR		 6792 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6793 pr_info(MPT3SAS_FMT "\tbreak from expander scan: " \
6794 "ioc_status(0x%04x), loginfo(0x%08x)\n",
6795 ioc->name, ioc_status,
6796 le32_to_cpu(mpi_reply.IOCLogInfo));
6797 break;
6798 }
6799 handle = le16_to_cpu(expander_pg0.DevHandle);
6800 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6801 expander_device = mpt3sas_scsih_expander_find_by_sas_address(
6802 ioc, le64_to_cpu(expander_pg0.SASAddress));
6803 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6804 if (expander_device)
6805 _scsih_refresh_expander_links(ioc, expander_device,
6806 handle);
6807 else {
6808 pr_info(MPT3SAS_FMT "\tBEFORE adding expander: " \
6809 "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
6810 handle, (unsigned long long)
6811 le64_to_cpu(expander_pg0.SASAddress));
6812 _scsih_expander_add(ioc, handle);
6813 pr_info(MPT3SAS_FMT "\tAFTER adding expander: " \
6814 "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
6815 handle, (unsigned long long)
6816 le64_to_cpu(expander_pg0.SASAddress));
6817 }
6818 }
6819
6820 pr_info(MPT3SAS_FMT "\tscan devices: expanders complete\n",
6821 ioc->name);
6822
6823 if (!ioc->ir_firmware)
6824 goto skip_to_sas;
6825
6826 pr_info(MPT3SAS_FMT "\tscan devices: phys disk start\n", ioc->name);
6827
6828 /* phys disk */
6829 phys_disk_num = 0xFF;
6830 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
6831 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
6832 phys_disk_num))) {
6833 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6834 MPI2_IOCSTATUS_MASK;
f92363d1
SR		 6835 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6836 pr_info(MPT3SAS_FMT "\tbreak from phys disk scan: "\
6837 "ioc_status(0x%04x), loginfo(0x%08x)\n",
6838 ioc->name, ioc_status,
6839 le32_to_cpu(mpi_reply.IOCLogInfo));
6840 break;
6841 }
6842 phys_disk_num = pd_pg0.PhysDiskNum;
6843 handle = le16_to_cpu(pd_pg0.DevHandle);
6844 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6845 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6846 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6847 if (sas_device)
6848 continue;
6849 if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6850 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
6851 handle) != 0)
6852 continue;
6853 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6854 MPI2_IOCSTATUS_MASK;
6855 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6856 pr_info(MPT3SAS_FMT "\tbreak from phys disk scan " \
6857 "ioc_status(0x%04x), loginfo(0x%08x)\n",
6858 ioc->name, ioc_status,
6859 le32_to_cpu(mpi_reply.IOCLogInfo));
6860 break;
6861 }
6862 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6863 if (!_scsih_get_sas_address(ioc, parent_handle,
6864 &sas_address)) {
6865 pr_info(MPT3SAS_FMT "\tBEFORE adding phys disk: " \
6866 " handle (0x%04x), sas_addr(0x%016llx)\n",
6867 ioc->name, handle, (unsigned long long)
6868 le64_to_cpu(sas_device_pg0.SASAddress));
6869 mpt3sas_transport_update_links(ioc, sas_address,
6870 handle, sas_device_pg0.PhyNum,
6871 MPI2_SAS_NEG_LINK_RATE_1_5);
6872 set_bit(handle, ioc->pd_handles);
6873 retry_count = 0;
6874 /* This will retry adding the end device.
6875 * _scsih_add_device() will decide on retries and
6876 * return "1" when it should be retried
6877 */
6878 while (_scsih_add_device(ioc, handle, retry_count++,
6879 1)) {
6880 ssleep(1);
6881 }
6882 pr_info(MPT3SAS_FMT "\tAFTER adding phys disk: " \
6883 " handle (0x%04x), sas_addr(0x%016llx)\n",
6884 ioc->name, handle, (unsigned long long)
6885 le64_to_cpu(sas_device_pg0.SASAddress));
6886 }
6887 }
6888
6889 pr_info(MPT3SAS_FMT "\tscan devices: phys disk complete\n",
6890 ioc->name);
6891
6892 pr_info(MPT3SAS_FMT "\tscan devices: volumes start\n", ioc->name);
6893
6894 /* volumes */
6895 handle = 0xFFFF;
6896 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
6897 &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
6898 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6899 MPI2_IOCSTATUS_MASK;
f92363d1
SR		 6900 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6901 pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \
6902 "ioc_status(0x%04x), loginfo(0x%08x)\n",
6903 ioc->name, ioc_status,
6904 le32_to_cpu(mpi_reply.IOCLogInfo));
6905 break;
6906 }
6907 handle = le16_to_cpu(volume_pg1.DevHandle);
6908 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6909 raid_device = _scsih_raid_device_find_by_wwid(ioc,
6910 le64_to_cpu(volume_pg1.WWID));
6911 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6912 if (raid_device)
6913 continue;
6914 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
6915 &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
6916 sizeof(Mpi2RaidVolPage0_t)))
6917 continue;
6918 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6919 MPI2_IOCSTATUS_MASK;
6920 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6921 pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \
6922 "ioc_status(0x%04x), loginfo(0x%08x)\n",
6923 ioc->name, ioc_status,
6924 le32_to_cpu(mpi_reply.IOCLogInfo));
6925 break;
6926 }
6927 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
6928 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
6929 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) {
6930 memset(&element, 0, sizeof(Mpi2EventIrConfigElement_t));
6931 element.ReasonCode = MPI2_EVENT_IR_CHANGE_RC_ADDED;
6932 element.VolDevHandle = volume_pg1.DevHandle;
6933 pr_info(MPT3SAS_FMT
6934 "\tBEFORE adding volume: handle (0x%04x)\n",
6935 ioc->name, volume_pg1.DevHandle);
6936 _scsih_sas_volume_add(ioc, &element);
6937 pr_info(MPT3SAS_FMT
6938 "\tAFTER adding volume: handle (0x%04x)\n",
6939 ioc->name, volume_pg1.DevHandle);
6940 }
6941 }
6942
6943 pr_info(MPT3SAS_FMT "\tscan devices: volumes complete\n",
6944 ioc->name);
6945
6946 skip_to_sas:
6947
6948 pr_info(MPT3SAS_FMT "\tscan devices: end devices start\n",
6949 ioc->name);
6950
6951 /* sas devices */
6952 handle = 0xFFFF;
6953 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6954 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
6955 handle))) {
6956 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6957 MPI2_IOCSTATUS_MASK;
f92363d1
SR		 6958 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6959 pr_info(MPT3SAS_FMT "\tbreak from end device scan:"\
6960 " ioc_status(0x%04x), loginfo(0x%08x)\n",
6961 ioc->name, ioc_status,
6962 le32_to_cpu(mpi_reply.IOCLogInfo));
6963 break;
6964 }
6965 handle = le16_to_cpu(sas_device_pg0.DevHandle);
6966 if (!(_scsih_is_end_device(
6967 le32_to_cpu(sas_device_pg0.DeviceInfo))))
6968 continue;
6969 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6970 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
6971 le64_to_cpu(sas_device_pg0.SASAddress));
6972 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6973 if (sas_device)
6974 continue;
6975 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6976 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) {
6977 pr_info(MPT3SAS_FMT "\tBEFORE adding end device: " \
6978 "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
6979 handle, (unsigned long long)
6980 le64_to_cpu(sas_device_pg0.SASAddress));
6981 mpt3sas_transport_update_links(ioc, sas_address, handle,
6982 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
6983 retry_count = 0;
6984 /* This will retry adding the end device.
6985 * _scsih_add_device() will decide on retries and
6986 * return "1" when it should be retried
6987 */
6988 while (_scsih_add_device(ioc, handle, retry_count++,
6989 0)) {
6990 ssleep(1);
6991 }
6992 pr_info(MPT3SAS_FMT "\tAFTER adding end device: " \
6993 "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
6994 handle, (unsigned long long)
6995 le64_to_cpu(sas_device_pg0.SASAddress));
6996 }
6997 }
6998 pr_info(MPT3SAS_FMT "\tscan devices: end devices complete\n",
6999 ioc->name);
7000
7001 pr_info(MPT3SAS_FMT "scan devices: complete\n", ioc->name);
7002}
7003/**
7004 * mpt3sas_scsih_reset_handler - reset callback handler (for scsih)
7005 * @ioc: per adapter object
7006 * @reset_phase: phase
7007 *
7008 * The handler for doing any required cleanup or initialization.
7009 *
7010 * The reset phase can be MPT3_IOC_PRE_RESET, MPT3_IOC_AFTER_RESET,
7011 * MPT3_IOC_DONE_RESET
7012 *
7013 * Return nothing.
7014 */
7015void
7016mpt3sas_scsih_reset_handler(struct MPT3SAS_ADAPTER *ioc, int reset_phase)
7017{
7018 switch (reset_phase) {
7019 case MPT3_IOC_PRE_RESET:
7020 dtmprintk(ioc, pr_info(MPT3SAS_FMT
7021 "%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__));
7022 break;
7023 case MPT3_IOC_AFTER_RESET:
7024 dtmprintk(ioc, pr_info(MPT3SAS_FMT
7025 "%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__));
7026 if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) {
7027 ioc->scsih_cmds.status |= MPT3_CMD_RESET;
7028 mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
7029 complete(&ioc->scsih_cmds.done);
7030 }
7031 if (ioc->tm_cmds.status & MPT3_CMD_PENDING) {
7032 ioc->tm_cmds.status |= MPT3_CMD_RESET;
7033 mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid);
7034 complete(&ioc->tm_cmds.done);
7035 }
7036
7037 _scsih_fw_event_cleanup_queue(ioc);
7038 _scsih_flush_running_cmds(ioc);
7039 break;
7040 case MPT3_IOC_DONE_RESET:
7041 dtmprintk(ioc, pr_info(MPT3SAS_FMT
7042 "%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__));
7043 if ((!ioc->is_driver_loading) && !(disable_discovery > 0 &&
7044 !ioc->sas_hba.num_phys)) {
7045 _scsih_prep_device_scan(ioc);
7046 _scsih_search_responding_sas_devices(ioc);
7047 _scsih_search_responding_raid_devices(ioc);
7048 _scsih_search_responding_expanders(ioc);
7049 _scsih_error_recovery_delete_devices(ioc);
7050 }
7051 break;
7052 }
7053}
7054
7055/**
7056 * _mpt3sas_fw_work - delayed task for processing firmware events
7057 * @ioc: per adapter object
7058 * @fw_event: The fw_event_work object
7059 * Context: user.
7060 *
7061 * Return nothing.
7062 */
7063static void
7064_mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
7065{
7066 /* the queue is being flushed so ignore this event */
4dc06fd8 7067 if (ioc->remove_host ||
f92363d1
SR		 7068 ioc->pci_error_recovery) {
7069 _scsih_fw_event_free(ioc, fw_event);
7070 return;
7071 }
7072
7073 switch (fw_event->event) {
7074 case MPT3SAS_PROCESS_TRIGGER_DIAG:
35b62362
JL		 7075 mpt3sas_process_trigger_data(ioc,
7076 (struct SL_WH_TRIGGERS_EVENT_DATA_T *)
7077 fw_event->event_data);
f92363d1
SR		 7078 break;
7079 case MPT3SAS_REMOVE_UNRESPONDING_DEVICES:
7080 while (scsi_host_in_recovery(ioc->shost) || ioc->shost_recovery)
7081 ssleep(1);
7082 _scsih_remove_unresponding_sas_devices(ioc);
7083 _scsih_scan_for_devices_after_reset(ioc);
7084 break;
7085 case MPT3SAS_PORT_ENABLE_COMPLETE:
7086 ioc->start_scan = 0;
7087 if (missing_delay[0] != -1 && missing_delay[1] != -1)
7088 mpt3sas_base_update_missing_delay(ioc, missing_delay[0],
7089 missing_delay[1]);
7090 dewtprintk(ioc, pr_info(MPT3SAS_FMT
7091 "port enable: complete from worker thread\n",
7092 ioc->name));
7093 break;
0f624c39
SR		 7094 case MPT3SAS_TURN_ON_PFA_LED:
7095 _scsih_turn_on_pfa_led(ioc, fw_event->device_handle);
f92363d1
SR		 7096 break;
7097 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
7098 _scsih_sas_topology_change_event(ioc, fw_event);
7099 break;
7100 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
7101 _scsih_sas_device_status_change_event(ioc, fw_event);
7102 break;
7103 case MPI2_EVENT_SAS_DISCOVERY:
7104 _scsih_sas_discovery_event(ioc, fw_event);
7105 break;
7106 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
7107 _scsih_sas_broadcast_primitive_event(ioc, fw_event);
7108 break;
7109 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
7110 _scsih_sas_enclosure_dev_status_change_event(ioc,
7111 fw_event);
7112 break;
7113 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
7114 _scsih_sas_ir_config_change_event(ioc, fw_event);
7115 break;
7116 case MPI2_EVENT_IR_VOLUME:
7117 _scsih_sas_ir_volume_event(ioc, fw_event);
7118 break;
7119 case MPI2_EVENT_IR_PHYSICAL_DISK:
7120 _scsih_sas_ir_physical_disk_event(ioc, fw_event);
7121 break;
7122 case MPI2_EVENT_IR_OPERATION_STATUS:
7123 _scsih_sas_ir_operation_status_event(ioc, fw_event);
7124 break;
7125 }
7126 _scsih_fw_event_free(ioc, fw_event);
7127}
7128
7129/**
7130 * _firmware_event_work
7131 * @ioc: per adapter object
7132 * @work: The fw_event_work object
7133 * Context: user.
7134 *
7135 * wrappers for the work thread handling firmware events
7136 *
7137 * Return nothing.
7138 */
7139
7140static void
7141_firmware_event_work(struct work_struct *work)
7142{
7143 struct fw_event_work *fw_event = container_of(work,
7144 struct fw_event_work, work);
7145
7146 _mpt3sas_fw_work(fw_event->ioc, fw_event);
7147}
7148
7149/**
7150 * mpt3sas_scsih_event_callback - firmware event handler (called at ISR time)
7151 * @ioc: per adapter object
7152 * @msix_index: MSIX table index supplied by the OS
7153 * @reply: reply message frame(lower 32bit addr)
7154 * Context: interrupt.
7155 *
7156 * This function merely adds a new work task into ioc->firmware_event_thread.
7157 * The tasks are worked from _firmware_event_work in user context.
7158 *
7159 * Return 1 meaning mf should be freed from _base_interrupt
7160 * 0 means the mf is freed from this function.
7161 */
7162u8
7163mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
7164 u32 reply)
7165{
7166 struct fw_event_work *fw_event;
7167 Mpi2EventNotificationReply_t *mpi_reply;
7168 u16 event;
7169 u16 sz;
7170
7171 /* events turned off due to host reset or driver unloading */
7172 if (ioc->remove_host || ioc->pci_error_recovery)
7173 return 1;
7174
7175 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
7176
7177 if (unlikely(!mpi_reply)) {
7178 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
7179 ioc->name, __FILE__, __LINE__, __func__);
7180 return 1;
7181 }
7182
7183 event = le16_to_cpu(mpi_reply->Event);
7184
7185 if (event != MPI2_EVENT_LOG_ENTRY_ADDED)
7186 mpt3sas_trigger_event(ioc, event, 0);
7187
7188 switch (event) {
7189 /* handle these */
7190 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
7191 {
7192 Mpi2EventDataSasBroadcastPrimitive_t *baen_data =
7193 (Mpi2EventDataSasBroadcastPrimitive_t *)
7194 mpi_reply->EventData;
7195
7196 if (baen_data->Primitive !=
7197 MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
7198 return 1;
7199
7200 if (ioc->broadcast_aen_busy) {
7201 ioc->broadcast_aen_pending++;
7202 return 1;
7203 } else
7204 ioc->broadcast_aen_busy = 1;
7205 break;
7206 }
7207
7208 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
7209 _scsih_check_topo_delete_events(ioc,
7210 (Mpi2EventDataSasTopologyChangeList_t *)
7211 mpi_reply->EventData);
7212 break;
7213 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
7214 _scsih_check_ir_config_unhide_events(ioc,
7215 (Mpi2EventDataIrConfigChangeList_t *)
7216 mpi_reply->EventData);
7217 break;
7218 case MPI2_EVENT_IR_VOLUME:
7219 _scsih_check_volume_delete_events(ioc,
7220 (Mpi2EventDataIrVolume_t *)
7221 mpi_reply->EventData);
7222 break;
7223
7224 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
7225 case MPI2_EVENT_IR_OPERATION_STATUS:
7226 case MPI2_EVENT_SAS_DISCOVERY:
7227 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
7228 case MPI2_EVENT_IR_PHYSICAL_DISK:
7229 break;
7230
2d8ce8c9
SR		 7231 case MPI2_EVENT_TEMP_THRESHOLD:
7232 _scsih_temp_threshold_events(ioc,
7233 (Mpi2EventDataTemperature_t *)
7234 mpi_reply->EventData);
7235 break;
7236
f92363d1
SR		 7237 default: /* ignore the rest */
7238 return 1;
7239 }
7240
f92363d1 7241 sz = le16_to_cpu(mpi_reply->EventDataLength) * 4;
35b62362
JL		 7242 fw_event = kzalloc(sizeof(*fw_event) + sz, GFP_ATOMIC);
7243 if (!fw_event) {
f92363d1
SR		 7244 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
7245 ioc->name, __FILE__, __LINE__, __func__);
f92363d1
SR		 7246 return 1;
7247 }
7248
7249 memcpy(fw_event->event_data, mpi_reply->EventData, sz);
7250 fw_event->ioc = ioc;
7251 fw_event->VF_ID = mpi_reply->VF_ID;
7252 fw_event->VP_ID = mpi_reply->VP_ID;
7253 fw_event->event = event;
7254 _scsih_fw_event_add(ioc, fw_event);
7255 return 1;
7256}
7257
7258/* shost template */
7259static struct scsi_host_template scsih_driver_template = {
7260 .module = THIS_MODULE,
7261 .name = "Fusion MPT SAS Host",
7262 .proc_name = MPT3SAS_DRIVER_NAME,
7263 .queuecommand = _scsih_qcmd,
7264 .target_alloc = _scsih_target_alloc,
7265 .slave_alloc = _scsih_slave_alloc,
7266 .slave_configure = _scsih_slave_configure,
7267 .target_destroy = _scsih_target_destroy,
7268 .slave_destroy = _scsih_slave_destroy,
7269 .scan_finished = _scsih_scan_finished,
7270 .scan_start = _scsih_scan_start,
7271 .change_queue_depth = _scsih_change_queue_depth,
f92363d1
SR		 7272 .eh_abort_handler = _scsih_abort,
7273 .eh_device_reset_handler = _scsih_dev_reset,
7274 .eh_target_reset_handler = _scsih_target_reset,
7275 .eh_host_reset_handler = _scsih_host_reset,
7276 .bios_param = _scsih_bios_param,
7277 .can_queue = 1,
7278 .this_id = -1,
7279 .sg_tablesize = MPT3SAS_SG_DEPTH,
7280 .max_sectors = 32767,
7281 .cmd_per_lun = 7,
7282 .use_clustering = ENABLE_CLUSTERING,
7283 .shost_attrs = mpt3sas_host_attrs,
7284 .sdev_attrs = mpt3sas_dev_attrs,
c40ecc12 7285 .track_queue_depth = 1,
f92363d1
SR		 7286};
7287
7288/**
7289 * _scsih_expander_node_remove - removing expander device from list.
7290 * @ioc: per adapter object
7291 * @sas_expander: the sas_device object
7292 * Context: Calling function should acquire ioc->sas_node_lock.
7293 *
7294 * Removing object and freeing associated memory from the
7295 * ioc->sas_expander_list.
7296 *
7297 * Return nothing.
7298 */
7299static void
7300_scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
7301 struct _sas_node *sas_expander)
7302{
7303 struct _sas_port *mpt3sas_port, *next;
7304
7305 /* remove sibling ports attached to this expander */
7306 list_for_each_entry_safe(mpt3sas_port, next,
7307 &sas_expander->sas_port_list, port_list) {
7308 if (ioc->shost_recovery)
7309 return;
7310 if (mpt3sas_port->remote_identify.device_type ==
7311 SAS_END_DEVICE)
7312 mpt3sas_device_remove_by_sas_address(ioc,
7313 mpt3sas_port->remote_identify.sas_address);
7314 else if (mpt3sas_port->remote_identify.device_type ==
7315 SAS_EDGE_EXPANDER_DEVICE ||
7316 mpt3sas_port->remote_identify.device_type ==
7317 SAS_FANOUT_EXPANDER_DEVICE)
7318 mpt3sas_expander_remove(ioc,
7319 mpt3sas_port->remote_identify.sas_address);
7320 }
7321
7322 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
7323 sas_expander->sas_address_parent);
7324
7325 pr_info(MPT3SAS_FMT
7326 "expander_remove: handle(0x%04x), sas_addr(0x%016llx)\n",
7327 ioc->name,
7328 sas_expander->handle, (unsigned long long)
7329 sas_expander->sas_address);
7330
7331 kfree(sas_expander->phy);
7332 kfree(sas_expander);
7333}
7334
7335/**
7336 * _scsih_ir_shutdown - IR shutdown notification
7337 * @ioc: per adapter object
7338 *
7339 * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
7340 * the host system is shutting down.
7341 *
7342 * Return nothing.
7343 */
7344static void
7345_scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc)
7346{
7347 Mpi2RaidActionRequest_t *mpi_request;
7348 Mpi2RaidActionReply_t *mpi_reply;
7349 u16 smid;
7350
7351 /* is IR firmware build loaded ? */
7352 if (!ioc->ir_firmware)
7353 return;
7354
7355 /* are there any volumes ? */
7356 if (list_empty(&ioc->raid_device_list))
7357 return;
7358
7359 mutex_lock(&ioc->scsih_cmds.mutex);
7360
7361 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
7362 pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n",
7363 ioc->name, __func__);
7364 goto out;
7365 }
7366 ioc->scsih_cmds.status = MPT3_CMD_PENDING;
7367
7368 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
7369 if (!smid) {
7370 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
7371 ioc->name, __func__);
7372 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
7373 goto out;
7374 }
7375
7376 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
7377 ioc->scsih_cmds.smid = smid;
7378 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
7379
7380 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
7381 mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
7382
7383 pr_info(MPT3SAS_FMT "IR shutdown (sending)\n", ioc->name);
7384 init_completion(&ioc->scsih_cmds.done);
7385 mpt3sas_base_put_smid_default(ioc, smid);
7386 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
7387
7388 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
7389 pr_err(MPT3SAS_FMT "%s: timeout\n",
7390 ioc->name, __func__);
7391 goto out;
7392 }
7393
7394 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
7395 mpi_reply = ioc->scsih_cmds.reply;
7396 pr_info(MPT3SAS_FMT
7397 "IR shutdown (complete): ioc_status(0x%04x), loginfo(0x%08x)\n",
7398 ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
7399 le32_to_cpu(mpi_reply->IOCLogInfo));
7400 }
7401
7402 out:
7403 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
7404 mutex_unlock(&ioc->scsih_cmds.mutex);
7405}
7406
7407/**
7408 * _scsih_remove - detach and remove add host
7409 * @pdev: PCI device struct
7410 *
7411 * Routine called when unloading the driver.
7412 * Return nothing.
7413 */
6f039790 7414static void _scsih_remove(struct pci_dev *pdev)
f92363d1
SR		 7415{
7416 struct Scsi_Host *shost = pci_get_drvdata(pdev);
7417 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
7418 struct _sas_port *mpt3sas_port, *next_port;
7419 struct _raid_device *raid_device, *next;
7420 struct MPT3SAS_TARGET *sas_target_priv_data;
7421 struct workqueue_struct *wq;
7422 unsigned long flags;
7423
7424 ioc->remove_host = 1;
7425 _scsih_fw_event_cleanup_queue(ioc);
7426
7427 spin_lock_irqsave(&ioc->fw_event_lock, flags);
7428 wq = ioc->firmware_event_thread;
7429 ioc->firmware_event_thread = NULL;
7430 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
7431 if (wq)
7432 destroy_workqueue(wq);
7433
7434 /* release all the volumes */
7435 _scsih_ir_shutdown(ioc);
7436 list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
7437 list) {
7438 if (raid_device->starget) {
7439 sas_target_priv_data =
7440 raid_device->starget->hostdata;
7441 sas_target_priv_data->deleted = 1;
7442 scsi_remove_target(&raid_device->starget->dev);
7443 }
7444 pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n",
7445 ioc->name, raid_device->handle,
7446 (unsigned long long) raid_device->wwid);
7447 _scsih_raid_device_remove(ioc, raid_device);
7448 }
7449
7450 /* free ports attached to the sas_host */
7451 list_for_each_entry_safe(mpt3sas_port, next_port,
7452 &ioc->sas_hba.sas_port_list, port_list) {
7453 if (mpt3sas_port->remote_identify.device_type ==
7454 SAS_END_DEVICE)
7455 mpt3sas_device_remove_by_sas_address(ioc,
7456 mpt3sas_port->remote_identify.sas_address);
7457 else if (mpt3sas_port->remote_identify.device_type ==
7458 SAS_EDGE_EXPANDER_DEVICE ||
7459 mpt3sas_port->remote_identify.device_type ==
7460 SAS_FANOUT_EXPANDER_DEVICE)
7461 mpt3sas_expander_remove(ioc,
7462 mpt3sas_port->remote_identify.sas_address);
7463 }
7464
7465 /* free phys attached to the sas_host */
7466 if (ioc->sas_hba.num_phys) {
7467 kfree(ioc->sas_hba.phy);
7468 ioc->sas_hba.phy = NULL;
7469 ioc->sas_hba.num_phys = 0;
7470 }
7471
7472 sas_remove_host(shost);
4dc06fd8 7473 scsi_remove_host(shost);
f92363d1
SR		 7474 mpt3sas_base_detach(ioc);
7475 list_del(&ioc->list);
f92363d1
SR		 7476 scsi_host_put(shost);
7477}
7478
7479/**
7480 * _scsih_shutdown - routine call during system shutdown
7481 * @pdev: PCI device struct
7482 *
7483 * Return nothing.
7484 */
7485static void
7486_scsih_shutdown(struct pci_dev *pdev)
7487{
7488 struct Scsi_Host *shost = pci_get_drvdata(pdev);
7489 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
7490 struct workqueue_struct *wq;
7491 unsigned long flags;
7492
7493 ioc->remove_host = 1;
7494 _scsih_fw_event_cleanup_queue(ioc);
7495
7496 spin_lock_irqsave(&ioc->fw_event_lock, flags);
7497 wq = ioc->firmware_event_thread;
7498 ioc->firmware_event_thread = NULL;
7499 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
7500 if (wq)
7501 destroy_workqueue(wq);
7502
7503 _scsih_ir_shutdown(ioc);
7504 mpt3sas_base_detach(ioc);
7505}
7506
7507
7508/**
7509 * _scsih_probe_boot_devices - reports 1st device
7510 * @ioc: per adapter object
7511 *
7512 * If specified in bios page 2, this routine reports the 1st
7513 * device scsi-ml or sas transport for persistent boot device
7514 * purposes. Please refer to function _scsih_determine_boot_device()
7515 */
7516static void
7517_scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc)
7518{
7519 u8 is_raid;
7520 void *device;
7521 struct _sas_device *sas_device;
7522 struct _raid_device *raid_device;
7523 u16 handle;
7524 u64 sas_address_parent;
7525 u64 sas_address;
7526 unsigned long flags;
7527 int rc;
7528
7529 /* no Bios, return immediately */
7530 if (!ioc->bios_pg3.BiosVersion)
7531 return;
7532
7533 device = NULL;
7534 is_raid = 0;
7535 if (ioc->req_boot_device.device) {
7536 device = ioc->req_boot_device.device;
7537 is_raid = ioc->req_boot_device.is_raid;
7538 } else if (ioc->req_alt_boot_device.device) {
7539 device = ioc->req_alt_boot_device.device;
7540 is_raid = ioc->req_alt_boot_device.is_raid;
7541 } else if (ioc->current_boot_device.device) {
7542 device = ioc->current_boot_device.device;
7543 is_raid = ioc->current_boot_device.is_raid;
7544 }
7545
7546 if (!device)
7547 return;
7548
7549 if (is_raid) {
7550 raid_device = device;
7551 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
7552 raid_device->id, 0);
7553 if (rc)
7554 _scsih_raid_device_remove(ioc, raid_device);
7555 } else {
7556 spin_lock_irqsave(&ioc->sas_device_lock, flags);
7557 sas_device = device;
7558 handle = sas_device->handle;
7559 sas_address_parent = sas_device->sas_address_parent;
7560 sas_address = sas_device->sas_address;
7561 list_move_tail(&sas_device->list, &ioc->sas_device_list);
7562 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7563
7564 if (!mpt3sas_transport_port_add(ioc, handle,
7565 sas_address_parent)) {
7566 _scsih_sas_device_remove(ioc, sas_device);
7567 } else if (!sas_device->starget) {
f5edbe77
SR		 7568 if (!ioc->is_driver_loading) {
7569 mpt3sas_transport_port_remove(ioc,
7570 sas_address,
f92363d1 7571 sas_address_parent);
f5edbe77
SR		 7572 _scsih_sas_device_remove(ioc, sas_device);
7573 }
f92363d1
SR		 7574 }
7575 }
7576}
7577
7578/**
7579 * _scsih_probe_raid - reporting raid volumes to scsi-ml
7580 * @ioc: per adapter object
7581 *
7582 * Called during initial loading of the driver.
7583 */
7584static void
7585_scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc)
7586{
7587 struct _raid_device *raid_device, *raid_next;
7588 int rc;
7589
7590 list_for_each_entry_safe(raid_device, raid_next,
7591 &ioc->raid_device_list, list) {
7592 if (raid_device->starget)
7593 continue;
7594 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
7595 raid_device->id, 0);
7596 if (rc)
7597 _scsih_raid_device_remove(ioc, raid_device);
7598 }
7599}
7600
7601/**
7602 * _scsih_probe_sas - reporting sas devices to sas transport
7603 * @ioc: per adapter object
7604 *
7605 * Called during initial loading of the driver.
7606 */
7607static void
7608_scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc)
7609{
7610 struct _sas_device *sas_device, *next;
7611 unsigned long flags;
7612
7613 /* SAS Device List */
7614 list_for_each_entry_safe(sas_device, next, &ioc->sas_device_init_list,
7615 list) {
7616
7617 if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
7618 sas_device->sas_address_parent)) {
7619 list_del(&sas_device->list);
7620 kfree(sas_device);
7621 continue;
7622 } else if (!sas_device->starget) {
7623 /*
7624 * When asyn scanning is enabled, its not possible to
7625 * remove devices while scanning is turned on due to an
7626 * oops in scsi_sysfs_add_sdev()->add_device()->
7627 * sysfs_addrm_start()
7628 */
f5edbe77 7629 if (!ioc->is_driver_loading) {
f92363d1
SR		 7630 mpt3sas_transport_port_remove(ioc,
7631 sas_device->sas_address,
7632 sas_device->sas_address_parent);
f5edbe77
SR		 7633 list_del(&sas_device->list);
7634 kfree(sas_device);
7635 continue;
7636 }
f92363d1
SR		 7637 }
7638
7639 spin_lock_irqsave(&ioc->sas_device_lock, flags);
7640 list_move_tail(&sas_device->list, &ioc->sas_device_list);
7641 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7642 }
7643}
7644
7645/**
7646 * _scsih_probe_devices - probing for devices
7647 * @ioc: per adapter object
7648 *
7649 * Called during initial loading of the driver.
7650 */
7651static void
7652_scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc)
7653{
7654 u16 volume_mapping_flags;
7655
7656 if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
7657 return; /* return when IOC doesn't support initiator mode */
7658
7659 _scsih_probe_boot_devices(ioc);
7660
7661 if (ioc->ir_firmware) {
7662 volume_mapping_flags =
7663 le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
7664 MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
7665 if (volume_mapping_flags ==
7666 MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) {
7667 _scsih_probe_raid(ioc);
7668 _scsih_probe_sas(ioc);
7669 } else {
7670 _scsih_probe_sas(ioc);
7671 _scsih_probe_raid(ioc);
7672 }
7673 } else
7674 _scsih_probe_sas(ioc);
7675}
7676
7677/**
7678 * _scsih_scan_start - scsi lld callback for .scan_start
7679 * @shost: SCSI host pointer
7680 *
7681 * The shost has the ability to discover targets on its own instead
7682 * of scanning the entire bus. In our implemention, we will kick off
7683 * firmware discovery.
7684 */
7685static void
7686_scsih_scan_start(struct Scsi_Host *shost)
7687{
7688 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
7689 int rc;
7690 if (diag_buffer_enable != -1 && diag_buffer_enable != 0)
7691 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable);
7692
7693 if (disable_discovery > 0)
7694 return;
7695
7696 ioc->start_scan = 1;
7697 rc = mpt3sas_port_enable(ioc);
7698
7699 if (rc != 0)
7700 pr_info(MPT3SAS_FMT "port enable: FAILED\n", ioc->name);
7701}
7702
7703/**
7704 * _scsih_scan_finished - scsi lld callback for .scan_finished
7705 * @shost: SCSI host pointer
7706 * @time: elapsed time of the scan in jiffies
7707 *
7708 * This function will be called periodicallyn until it returns 1 with the
7709 * scsi_host and the elapsed time of the scan in jiffies. In our implemention,
7710 * we wait for firmware discovery to complete, then return 1.
7711 */
7712static int
7713_scsih_scan_finished(struct Scsi_Host *shost, unsigned long time)
7714{
7715 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
7716
7717 if (disable_discovery > 0) {
7718 ioc->is_driver_loading = 0;
7719 ioc->wait_for_discovery_to_complete = 0;
7720 return 1;
7721 }
7722
7723 if (time >= (300 * HZ)) {
7724 ioc->base_cmds.status = MPT3_CMD_NOT_USED;
7725 pr_info(MPT3SAS_FMT
7726 "port enable: FAILED with timeout (timeout=300s)\n",
7727 ioc->name);
7728 ioc->is_driver_loading = 0;
7729 return 1;
7730 }
7731
7732 if (ioc->start_scan)
7733 return 0;
7734
7735 if (ioc->start_scan_failed) {
7736 pr_info(MPT3SAS_FMT
7737 "port enable: FAILED with (ioc_status=0x%08x)\n",
7738 ioc->name, ioc->start_scan_failed);
7739 ioc->is_driver_loading = 0;
7740 ioc->wait_for_discovery_to_complete = 0;
7741 ioc->remove_host = 1;
7742 return 1;
7743 }
7744
7745 pr_info(MPT3SAS_FMT "port enable: SUCCESS\n", ioc->name);
7746 ioc->base_cmds.status = MPT3_CMD_NOT_USED;
7747
7748 if (ioc->wait_for_discovery_to_complete) {
7749 ioc->wait_for_discovery_to_complete = 0;
7750 _scsih_probe_devices(ioc);
7751 }
7752 mpt3sas_base_start_watchdog(ioc);
7753 ioc->is_driver_loading = 0;
7754 return 1;
7755}
7756
7757/**
7758 * _scsih_probe - attach and add scsi host
7759 * @pdev: PCI device struct
7760 * @id: pci device id
7761 *
7762 * Returns 0 success, anything else error.
7763 */
7764static int
7765_scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
7766{
7767 struct MPT3SAS_ADAPTER *ioc;
7768 struct Scsi_Host *shost;
b65f1d4d 7769 int rv;
f92363d1
SR		 7770
7771 shost = scsi_host_alloc(&scsih_driver_template,
7772 sizeof(struct MPT3SAS_ADAPTER));
7773 if (!shost)
7774 return -ENODEV;
7775
7776 /* init local params */
7777 ioc = shost_priv(shost);
7778 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
7779 INIT_LIST_HEAD(&ioc->list);
7780 list_add_tail(&ioc->list, &mpt3sas_ioc_list);
7781 ioc->shost = shost;
7782 ioc->id = mpt_ids++;
7783 sprintf(ioc->name, "%s%d", MPT3SAS_DRIVER_NAME, ioc->id);
7784 ioc->pdev = pdev;
7785 ioc->scsi_io_cb_idx = scsi_io_cb_idx;
7786 ioc->tm_cb_idx = tm_cb_idx;
7787 ioc->ctl_cb_idx = ctl_cb_idx;
7788 ioc->base_cb_idx = base_cb_idx;
7789 ioc->port_enable_cb_idx = port_enable_cb_idx;
7790 ioc->transport_cb_idx = transport_cb_idx;
7791 ioc->scsih_cb_idx = scsih_cb_idx;
7792 ioc->config_cb_idx = config_cb_idx;
7793 ioc->tm_tr_cb_idx = tm_tr_cb_idx;
7794 ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx;
7795 ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
7796 ioc->logging_level = logging_level;
7797 ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds;
7798 /* misc semaphores and spin locks */
7799 mutex_init(&ioc->reset_in_progress_mutex);
7800 spin_lock_init(&ioc->ioc_reset_in_progress_lock);
7801 spin_lock_init(&ioc->scsi_lookup_lock);
7802 spin_lock_init(&ioc->sas_device_lock);
7803 spin_lock_init(&ioc->sas_node_lock);
7804 spin_lock_init(&ioc->fw_event_lock);
7805 spin_lock_init(&ioc->raid_device_lock);
7806 spin_lock_init(&ioc->diag_trigger_lock);
7807
7808 INIT_LIST_HEAD(&ioc->sas_device_list);
7809 INIT_LIST_HEAD(&ioc->sas_device_init_list);
7810 INIT_LIST_HEAD(&ioc->sas_expander_list);
7811 INIT_LIST_HEAD(&ioc->fw_event_list);
7812 INIT_LIST_HEAD(&ioc->raid_device_list);
7813 INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
7814 INIT_LIST_HEAD(&ioc->delayed_tr_list);
7815 INIT_LIST_HEAD(&ioc->delayed_tr_volume_list);
cf9bd21a 7816 INIT_LIST_HEAD(&ioc->reply_queue_list);
f92363d1
SR		 7817
7818 /* init shost parameters */
7819 shost->max_cmd_len = 32;
7820 shost->max_lun = max_lun;
7821 shost->transportt = mpt3sas_transport_template;
7822 shost->unique_id = ioc->id;
7823
7824 if (max_sectors != 0xFFFF) {
7825 if (max_sectors < 64) {
7826 shost->max_sectors = 64;
7827 pr_warn(MPT3SAS_FMT "Invalid value %d passed " \
7828 "for max_sectors, range is 64 to 32767. Assigning "
7829 "value of 64.\n", ioc->name, max_sectors);
7830 } else if (max_sectors > 32767) {
7831 shost->max_sectors = 32767;
7832 pr_warn(MPT3SAS_FMT "Invalid value %d passed " \
7833 "for max_sectors, range is 64 to 32767. Assigning "
7834 "default value of 32767.\n", ioc->name,
7835 max_sectors);
7836 } else {
7837 shost->max_sectors = max_sectors & 0xFFFE;
7838 pr_info(MPT3SAS_FMT
7839 "The max_sectors value is set to %d\n",
7840 ioc->name, shost->max_sectors);
7841 }
7842 }
7843
f92363d1
SR		 7844 /* register EEDP capabilities with SCSI layer */
7845 if (prot_mask > 0)
7846 scsi_host_set_prot(shost, prot_mask);
7847 else
7848 scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION
7849 | SHOST_DIF_TYPE2_PROTECTION
7850 | SHOST_DIF_TYPE3_PROTECTION);
7851
7852 scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
7853
7854 /* event thread */
7855 snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
7856 "fw_event%d", ioc->id);
7857 ioc->firmware_event_thread = create_singlethread_workqueue(
7858 ioc->firmware_event_name);
7859 if (!ioc->firmware_event_thread) {
7860 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
7861 ioc->name, __FILE__, __LINE__, __func__);
b65f1d4d 7862 rv = -ENODEV;
f92363d1
SR		 7863 goto out_thread_fail;
7864 }
7865
7866 ioc->is_driver_loading = 1;
7867 if ((mpt3sas_base_attach(ioc))) {
7868 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
7869 ioc->name, __FILE__, __LINE__, __func__);
b65f1d4d 7870 rv = -ENODEV;
f92363d1
SR		 7871 goto out_attach_fail;
7872 }
b65f1d4d
SR		 7873 rv = scsi_add_host(shost, &pdev->dev);
7874 if (rv) {
4dc06fd8
RS		 7875 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
7876 ioc->name, __FILE__, __LINE__, __func__);
4dc06fd8
RS		 7877 goto out_add_shost_fail;
7878 }
7879
f92363d1
SR		 7880 scsi_scan_host(shost);
7881 return 0;
4dc06fd8
RS		 7882out_add_shost_fail:
7883 mpt3sas_base_detach(ioc);
f92363d1
SR		 7884 out_attach_fail:
7885 destroy_workqueue(ioc->firmware_event_thread);
7886 out_thread_fail:
7887 list_del(&ioc->list);
f92363d1 7888 scsi_host_put(shost);
b65f1d4d 7889 return rv;
f92363d1
SR		 7890}
7891
7892#ifdef CONFIG_PM
7893/**
7894 * _scsih_suspend - power management suspend main entry point
7895 * @pdev: PCI device struct
7896 * @state: PM state change to (usually PCI_D3)
7897 *
7898 * Returns 0 success, anything else error.
7899 */
7900static int
7901_scsih_suspend(struct pci_dev *pdev, pm_message_t state)
7902{
7903 struct Scsi_Host *shost = pci_get_drvdata(pdev);
7904 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
7905 pci_power_t device_state;
7906
7907 mpt3sas_base_stop_watchdog(ioc);
7908 flush_scheduled_work();
7909 scsi_block_requests(shost);
7910 device_state = pci_choose_state(pdev, state);
7911 pr_info(MPT3SAS_FMT
7912 "pdev=0x%p, slot=%s, entering operating state [D%d]\n",
7913 ioc->name, pdev, pci_name(pdev), device_state);
7914
7915 pci_save_state(pdev);
7916 mpt3sas_base_free_resources(ioc);
7917 pci_set_power_state(pdev, device_state);
7918 return 0;
7919}
7920
7921/**
7922 * _scsih_resume - power management resume main entry point
7923 * @pdev: PCI device struct
7924 *
7925 * Returns 0 success, anything else error.
7926 */
7927static int
7928_scsih_resume(struct pci_dev *pdev)
7929{
7930 struct Scsi_Host *shost = pci_get_drvdata(pdev);
7931 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
7932 pci_power_t device_state = pdev->current_state;
7933 int r;
7934
7935 pr_info(MPT3SAS_FMT
7936 "pdev=0x%p, slot=%s, previous operating state [D%d]\n",
7937 ioc->name, pdev, pci_name(pdev), device_state);
7938
7939 pci_set_power_state(pdev, PCI_D0);
7940 pci_enable_wake(pdev, PCI_D0, 0);
7941 pci_restore_state(pdev);
7942 ioc->pdev = pdev;
7943 r = mpt3sas_base_map_resources(ioc);
7944 if (r)
7945 return r;
7946
7947 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, SOFT_RESET);
7948 scsi_unblock_requests(shost);
7949 mpt3sas_base_start_watchdog(ioc);
7950 return 0;
7951}
7952#endif /* CONFIG_PM */
7953
7954/**
7955 * _scsih_pci_error_detected - Called when a PCI error is detected.
7956 * @pdev: PCI device struct
7957 * @state: PCI channel state
7958 *
7959 * Description: Called when a PCI error is detected.
7960 *
7961 * Return value:
7962 * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
7963 */
7964static pci_ers_result_t
7965_scsih_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
7966{
7967 struct Scsi_Host *shost = pci_get_drvdata(pdev);
7968 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
7969
7970 pr_info(MPT3SAS_FMT "PCI error: detected callback, state(%d)!!\n",
7971 ioc->name, state);
7972
7973 switch (state) {
7974 case pci_channel_io_normal:
7975 return PCI_ERS_RESULT_CAN_RECOVER;
7976 case pci_channel_io_frozen:
7977 /* Fatal error, prepare for slot reset */
7978 ioc->pci_error_recovery = 1;
7979 scsi_block_requests(ioc->shost);
7980 mpt3sas_base_stop_watchdog(ioc);
7981 mpt3sas_base_free_resources(ioc);
7982 return PCI_ERS_RESULT_NEED_RESET;
7983 case pci_channel_io_perm_failure:
7984 /* Permanent error, prepare for device removal */
7985 ioc->pci_error_recovery = 1;
7986 mpt3sas_base_stop_watchdog(ioc);
7987 _scsih_flush_running_cmds(ioc);
7988 return PCI_ERS_RESULT_DISCONNECT;
7989 }
7990 return PCI_ERS_RESULT_NEED_RESET;
7991}
7992
7993/**
7994 * _scsih_pci_slot_reset - Called when PCI slot has been reset.
7995 * @pdev: PCI device struct
7996 *
7997 * Description: This routine is called by the pci error recovery
7998 * code after the PCI slot has been reset, just before we
7999 * should resume normal operations.
8000 */
8001static pci_ers_result_t
8002_scsih_pci_slot_reset(struct pci_dev *pdev)
8003{
8004 struct Scsi_Host *shost = pci_get_drvdata(pdev);
8005 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8006 int rc;
8007
8008 pr_info(MPT3SAS_FMT "PCI error: slot reset callback!!\n",
8009 ioc->name);
8010
8011 ioc->pci_error_recovery = 0;
8012 ioc->pdev = pdev;
8013 pci_restore_state(pdev);
8014 rc = mpt3sas_base_map_resources(ioc);
8015 if (rc)
8016 return PCI_ERS_RESULT_DISCONNECT;
8017
8018 rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
8019 FORCE_BIG_HAMMER);
8020
8021 pr_warn(MPT3SAS_FMT "hard reset: %s\n", ioc->name,
8022 (rc == 0) ? "success" : "failed");
8023
8024 if (!rc)
8025 return PCI_ERS_RESULT_RECOVERED;
8026 else
8027 return PCI_ERS_RESULT_DISCONNECT;
8028}
8029
8030/**
8031 * _scsih_pci_resume() - resume normal ops after PCI reset
8032 * @pdev: pointer to PCI device
8033 *
8034 * Called when the error recovery driver tells us that its
8035 * OK to resume normal operation. Use completion to allow
8036 * halted scsi ops to resume.
8037 */
8038static void
8039_scsih_pci_resume(struct pci_dev *pdev)
8040{
8041 struct Scsi_Host *shost = pci_get_drvdata(pdev);
8042 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8043
8044 pr_info(MPT3SAS_FMT "PCI error: resume callback!!\n", ioc->name);
8045
8046 pci_cleanup_aer_uncorrect_error_status(pdev);
8047 mpt3sas_base_start_watchdog(ioc);
8048 scsi_unblock_requests(ioc->shost);
8049}
8050
8051/**
8052 * _scsih_pci_mmio_enabled - Enable MMIO and dump debug registers
8053 * @pdev: pointer to PCI device
8054 */
8055static pci_ers_result_t
8056_scsih_pci_mmio_enabled(struct pci_dev *pdev)
8057{
8058 struct Scsi_Host *shost = pci_get_drvdata(pdev);
8059 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8060
8061 pr_info(MPT3SAS_FMT "PCI error: mmio enabled callback!!\n",
8062 ioc->name);
8063
8064 /* TODO - dump whatever for debugging purposes */
8065
8066 /* Request a slot reset. */
8067 return PCI_ERS_RESULT_NEED_RESET;
8068}
8069
8070/* raid transport support */
8071static struct raid_function_template mpt3sas_raid_functions = {
8072 .cookie = &scsih_driver_template,
8073 .is_raid = _scsih_is_raid,
8074 .get_resync = _scsih_get_resync,
8075 .get_state = _scsih_get_state,
8076};
8077
8078static struct pci_error_handlers _scsih_err_handler = {
8079 .error_detected = _scsih_pci_error_detected,
8080 .mmio_enabled = _scsih_pci_mmio_enabled,
8081 .slot_reset = _scsih_pci_slot_reset,
8082 .resume = _scsih_pci_resume,
8083};
8084
8085static struct pci_driver scsih_driver = {
8086 .name = MPT3SAS_DRIVER_NAME,
8087 .id_table = scsih_pci_table,
8088 .probe = _scsih_probe,
6f039790 8089 .remove = _scsih_remove,
f92363d1
SR		 8090 .shutdown = _scsih_shutdown,
8091 .err_handler = &_scsih_err_handler,
8092#ifdef CONFIG_PM
8093 .suspend = _scsih_suspend,
8094 .resume = _scsih_resume,
8095#endif
8096};
8097
8098
8099/**
8100 * _scsih_init - main entry point for this driver.
8101 *
8102 * Returns 0 success, anything else error.
8103 */
8104static int __init
8105_scsih_init(void)
8106{
8107 int error;
8108
8109 mpt_ids = 0;
8110
8111 pr_info("%s version %s loaded\n", MPT3SAS_DRIVER_NAME,
8112 MPT3SAS_DRIVER_VERSION);
8113
8114 mpt3sas_transport_template =
8115 sas_attach_transport(&mpt3sas_transport_functions);
8116 if (!mpt3sas_transport_template)
8117 return -ENODEV;
8118
8119/* raid transport support */
8120 mpt3sas_raid_template = raid_class_attach(&mpt3sas_raid_functions);
8121 if (!mpt3sas_raid_template) {
8122 sas_release_transport(mpt3sas_transport_template);
8123 return -ENODEV;
8124 }
8125
8126 mpt3sas_base_initialize_callback_handler();
8127
8128 /* queuecommand callback hander */
8129 scsi_io_cb_idx = mpt3sas_base_register_callback_handler(_scsih_io_done);
8130
8131 /* task managment callback handler */
8132 tm_cb_idx = mpt3sas_base_register_callback_handler(_scsih_tm_done);
8133
8134 /* base internal commands callback handler */
8135 base_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_base_done);
8136 port_enable_cb_idx = mpt3sas_base_register_callback_handler(
8137 mpt3sas_port_enable_done);
8138
8139 /* transport internal commands callback handler */
8140 transport_cb_idx = mpt3sas_base_register_callback_handler(
8141 mpt3sas_transport_done);
8142
8143 /* scsih internal commands callback handler */
8144 scsih_cb_idx = mpt3sas_base_register_callback_handler(_scsih_done);
8145
8146 /* configuration page API internal commands callback handler */
8147 config_cb_idx = mpt3sas_base_register_callback_handler(
8148 mpt3sas_config_done);
8149
8150 /* ctl module callback handler */
8151 ctl_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_ctl_done);
8152
8153 tm_tr_cb_idx = mpt3sas_base_register_callback_handler(
8154 _scsih_tm_tr_complete);
8155
8156 tm_tr_volume_cb_idx = mpt3sas_base_register_callback_handler(
8157 _scsih_tm_volume_tr_complete);
8158
8159 tm_sas_control_cb_idx = mpt3sas_base_register_callback_handler(
8160 _scsih_sas_control_complete);
8161
8162 mpt3sas_ctl_init();
8163
8164 error = pci_register_driver(&scsih_driver);
8165 if (error) {
8166 /* raid transport support */
8167 raid_class_release(mpt3sas_raid_template);
8168 sas_release_transport(mpt3sas_transport_template);
8169 }
8170
8171 return error;
8172}
8173
8174/**
8175 * _scsih_exit - exit point for this driver (when it is a module).
8176 *
8177 * Returns 0 success, anything else error.
8178 */
8179static void __exit
8180_scsih_exit(void)
8181{
8182 pr_info("mpt3sas version %s unloading\n",
8183 MPT3SAS_DRIVER_VERSION);
8184
8185 mpt3sas_ctl_exit();
8186
8187 pci_unregister_driver(&scsih_driver);
8188
8189
8190 mpt3sas_base_release_callback_handler(scsi_io_cb_idx);
8191 mpt3sas_base_release_callback_handler(tm_cb_idx);
8192 mpt3sas_base_release_callback_handler(base_cb_idx);
8193 mpt3sas_base_release_callback_handler(port_enable_cb_idx);
8194 mpt3sas_base_release_callback_handler(transport_cb_idx);
8195 mpt3sas_base_release_callback_handler(scsih_cb_idx);
8196 mpt3sas_base_release_callback_handler(config_cb_idx);
8197 mpt3sas_base_release_callback_handler(ctl_cb_idx);
8198
8199 mpt3sas_base_release_callback_handler(tm_tr_cb_idx);
8200 mpt3sas_base_release_callback_handler(tm_tr_volume_cb_idx);
8201 mpt3sas_base_release_callback_handler(tm_sas_control_cb_idx);
8202
8203/* raid transport support */
8204 raid_class_release(mpt3sas_raid_template);
8205 sas_release_transport(mpt3sas_transport_template);
8206}
8207
8208module_init(_scsih_init);
8209module_exit(_scsih_exit);
ubuntu-bionic-kernel mirror