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