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