Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/scsi/mpt2sas/mpt2sas_scsih.c

  1 /*
  2  * Scsi Host Layer for MPT (Message Passing Technology) based controllers
  3  *
  4  * This code is based on drivers/scsi/mpt2sas/mpt2_scsih.c
  5  * Copyright (C) 2007-2013  LSI Corporation
  6  *  (mailto:DL-MPTFusionLinux@lsi.com)
  7  *
  8  * This program is free software; you can redistribute it and/or
  9  * modify it under the terms of the GNU General Public License
 10  * as published by the Free Software Foundation; either version 2
 11  * of the License, or (at your option) any later version.
 12  *
 13  * This program is distributed in the hope that it will be useful,
 14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16  * GNU General Public License for more details.
 17  *
 18  * NO WARRANTY
 19  * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
 20  * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
 21  * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
 22  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
 23  * solely responsible for determining the appropriateness of using and
 24  * distributing the Program and assumes all risks associated with its
 25  * exercise of rights under this Agreement, including but not limited to
 26  * the risks and costs of program errors, damage to or loss of data,
 27  * programs or equipment, and unavailability or interruption of operations.
 28 
 29  * DISCLAIMER OF LIABILITY
 30  * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
 31  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 32  * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
 33  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 34  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 35  * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
 36  * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
 37 
 38  * You should have received a copy of the GNU General Public License
 39  * along with this program; if not, write to the Free Software
 40  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 41  * USA.
 42  */
 43 
 44 #include <linux/module.h>
 45 #include <linux/kernel.h>
 46 #include <linux/init.h>
 47 #include <linux/errno.h>
 48 #include <linux/blkdev.h>
 49 #include <linux/sched.h>
 50 #include <linux/workqueue.h>
 51 #include <linux/delay.h>
 52 #include <linux/pci.h>
 53 #include <linux/interrupt.h>
 54 #include <linux/aer.h>
 55 #include <linux/raid_class.h>
 56 #include <linux/slab.h>
 57 
 58 #include "mpt2sas_base.h"
 59 
 60 MODULE_AUTHOR(MPT2SAS_AUTHOR);
 61 MODULE_DESCRIPTION(MPT2SAS_DESCRIPTION);
 62 MODULE_LICENSE("GPL");
 63 MODULE_VERSION(MPT2SAS_DRIVER_VERSION);
 64 
 65 #define RAID_CHANNEL 1
 66 
 67 /* forward proto's */
 68 static void _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
 69     struct _sas_node *sas_expander);
 70 static void _firmware_event_work(struct work_struct *work);
 71 
 72 static u8 _scsih_check_for_pending_tm(struct MPT2SAS_ADAPTER *ioc, u16 smid);
 73 
 74 static void _scsih_scan_start(struct Scsi_Host *shost);
 75 static int _scsih_scan_finished(struct Scsi_Host *shost, unsigned long time);
 76 
 77 /* global parameters */
 78 LIST_HEAD(mpt2sas_ioc_list);
 79 
 80 /* local parameters */
 81 static u8 scsi_io_cb_idx = -1;
 82 static u8 tm_cb_idx = -1;
 83 static u8 ctl_cb_idx = -1;
 84 static u8 base_cb_idx = -1;
 85 static u8 port_enable_cb_idx = -1;
 86 static u8 transport_cb_idx = -1;
 87 static u8 scsih_cb_idx = -1;
 88 static u8 config_cb_idx = -1;
 89 static int mpt_ids;
 90 
 91 static u8 tm_tr_cb_idx = -1 ;
 92 static u8 tm_tr_volume_cb_idx = -1 ;
 93 static u8 tm_sas_control_cb_idx = -1;
 94 
 95 /* command line options */
 96 static u32 logging_level;
 97 MODULE_PARM_DESC(logging_level, " bits for enabling additional logging info "
 98     "(default=0)");
 99 
100 static ushort max_sectors = 0xFFFF;
101 module_param(max_sectors, ushort, 0);
102 MODULE_PARM_DESC(max_sectors, "max sectors, range 64 to 32767  default=32767");
103 
104 static int missing_delay[2] = {-1, -1};
105 module_param_array(missing_delay, int, NULL, 0);
106 MODULE_PARM_DESC(missing_delay, " device missing delay , io missing delay");
107 
108 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
109 #define MPT2SAS_MAX_LUN (16895)
110 static int max_lun = MPT2SAS_MAX_LUN;
111 module_param(max_lun, int, 0);
112 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
113 
114 /* diag_buffer_enable is bitwise
115  * bit 0 set = TRACE
116  * bit 1 set = SNAPSHOT
117  * bit 2 set = EXTENDED
118  *
119  * Either bit can be set, or both
120  */
121 static int diag_buffer_enable = -1;
122 module_param(diag_buffer_enable, int, 0);
123 MODULE_PARM_DESC(diag_buffer_enable, " post diag buffers "
124         "(TRACE=1/SNAPSHOT=2/EXTENDED=4/default=0)");
125 
126 static int disable_discovery = -1;
127 module_param(disable_discovery, int, 0);
128 MODULE_PARM_DESC(disable_discovery, " disable discovery ");
129 
130 /* permit overriding the host protection capabilities mask (EEDP/T10 PI) */
131 static int prot_mask = 0;
132 module_param(prot_mask, int, 0);
133 MODULE_PARM_DESC(prot_mask, " host protection capabilities mask, def=7 ");
134 
135 /**
136  * struct sense_info - common structure for obtaining sense keys
137  * @skey: sense key
138  * @asc: additional sense code
139  * @ascq: additional sense code qualifier
140  */
141 struct sense_info {
142         u8 skey;
143         u8 asc;
144         u8 ascq;
145 };
146 
147 
148 #define MPT2SAS_TURN_ON_FAULT_LED (0xFFFC)
149 #define MPT2SAS_PORT_ENABLE_COMPLETE (0xFFFD)
150 #define MPT2SAS_REMOVE_UNRESPONDING_DEVICES (0xFFFF)
151 /**
152  * struct fw_event_work - firmware event struct
153  * @list: link list framework
154  * @work: work object (ioc->fault_reset_work_q)
155  * @cancel_pending_work: flag set during reset handling
156  * @ioc: per adapter object
157  * @device_handle: device handle
158  * @VF_ID: virtual function id
159  * @VP_ID: virtual port id
160  * @ignore: flag meaning this event has been marked to ignore
161  * @event: firmware event MPI2_EVENT_XXX defined in mpt2_ioc.h
162  * @event_data: reply event data payload follows
163  *
164  * This object stored on ioc->fw_event_list.
165  */
166 struct fw_event_work {
167         struct list_head        list;
168         u8                      cancel_pending_work;
169         struct delayed_work     delayed_work;
170         struct MPT2SAS_ADAPTER *ioc;
171         u16                     device_handle;
172         u8                      VF_ID;
173         u8                      VP_ID;
174         u8                      ignore;
175         u16                     event;
176         void                    *event_data;
177 };
178 
179 /* raid transport support */
180 static struct raid_template *mpt2sas_raid_template;
181 
182 /**
183  * struct _scsi_io_transfer - scsi io transfer
184  * @handle: sas device handle (assigned by firmware)
185  * @is_raid: flag set for hidden raid components
186  * @dir: DMA_TO_DEVICE, DMA_FROM_DEVICE,
187  * @data_length: data transfer length
188  * @data_dma: dma pointer to data
189  * @sense: sense data
190  * @lun: lun number
191  * @cdb_length: cdb length
192  * @cdb: cdb contents
193  * @timeout: timeout for this command
194  * @VF_ID: virtual function id
195  * @VP_ID: virtual port id
196  * @valid_reply: flag set for reply message
197  * @sense_length: sense length
198  * @ioc_status: ioc status
199  * @scsi_state: scsi state
200  * @scsi_status: scsi staus
201  * @log_info: log information
202  * @transfer_length: data length transfer when there is a reply message
203  *
204  * Used for sending internal scsi commands to devices within this module.
205  * Refer to _scsi_send_scsi_io().
206  */
207 struct _scsi_io_transfer {
208         u16     handle;
209         u8      is_raid;
210         enum dma_data_direction dir;
211         u32     data_length;
212         dma_addr_t data_dma;
213         u8      sense[SCSI_SENSE_BUFFERSIZE];
214         u32     lun;
215         u8      cdb_length;
216         u8      cdb[32];
217         u8      timeout;
218         u8      VF_ID;
219         u8      VP_ID;
220         u8      valid_reply;
221   /* the following bits are only valid when 'valid_reply = 1' */
222         u32     sense_length;
223         u16     ioc_status;
224         u8      scsi_state;
225         u8      scsi_status;
226         u32     log_info;
227         u32     transfer_length;
228 };
229 
230 /*
231  * The pci device ids are defined in mpi/mpi2_cnfg.h.
232  */
233 static struct pci_device_id scsih_pci_table[] = {
234         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2004,
235                 PCI_ANY_ID, PCI_ANY_ID },
236         /* Falcon ~ 2008*/
237         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2008,
238                 PCI_ANY_ID, PCI_ANY_ID },
239         /* Liberator ~ 2108 */
240         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_1,
241                 PCI_ANY_ID, PCI_ANY_ID },
242         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_2,
243                 PCI_ANY_ID, PCI_ANY_ID },
244         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3,
245                 PCI_ANY_ID, PCI_ANY_ID },
246         /* Meteor ~ 2116 */
247         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1,
248                 PCI_ANY_ID, PCI_ANY_ID },
249         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2,
250                 PCI_ANY_ID, PCI_ANY_ID },
251         /* Thunderbolt ~ 2208 */
252         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1,
253                 PCI_ANY_ID, PCI_ANY_ID },
254         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2,
255                 PCI_ANY_ID, PCI_ANY_ID },
256         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3,
257                 PCI_ANY_ID, PCI_ANY_ID },
258         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4,
259                 PCI_ANY_ID, PCI_ANY_ID },
260         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5,
261                 PCI_ANY_ID, PCI_ANY_ID },
262         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6,
263                 PCI_ANY_ID, PCI_ANY_ID },
264         /* Mustang ~ 2308 */
265         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_1,
266                 PCI_ANY_ID, PCI_ANY_ID },
267         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_2,
268                 PCI_ANY_ID, PCI_ANY_ID },
269         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3,
270                 PCI_ANY_ID, PCI_ANY_ID },
271         /* SSS6200 */
272         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200,
273                 PCI_ANY_ID, PCI_ANY_ID },
274         {0}     /* Terminating entry */
275 };
276 MODULE_DEVICE_TABLE(pci, scsih_pci_table);
277 
278 /**
279  * _scsih_set_debug_level - global setting of ioc->logging_level.
280  *
281  * Note: The logging levels are defined in mpt2sas_debug.h.
282  */
283 static int
284 _scsih_set_debug_level(const char *val, struct kernel_param *kp)
285 {
286         int ret = param_set_int(val, kp);
287         struct MPT2SAS_ADAPTER *ioc;
288 
289         if (ret)
290                 return ret;
291 
292         printk(KERN_INFO "setting logging_level(0x%08x)\n", logging_level);
293         list_for_each_entry(ioc, &mpt2sas_ioc_list, list)
294                 ioc->logging_level = logging_level;
295         return 0;
296 }
297 module_param_call(logging_level, _scsih_set_debug_level, param_get_int,
298     &logging_level, 0644);
299 
300 /**
301  * _scsih_srch_boot_sas_address - search based on sas_address
302  * @sas_address: sas address
303  * @boot_device: boot device object from bios page 2
304  *
305  * Returns 1 when there's a match, 0 means no match.
306  */
307 static inline int
308 _scsih_srch_boot_sas_address(u64 sas_address,
309     Mpi2BootDeviceSasWwid_t *boot_device)
310 {
311         return (sas_address == le64_to_cpu(boot_device->SASAddress)) ?  1 : 0;
312 }
313 
314 /**
315  * _scsih_srch_boot_device_name - search based on device name
316  * @device_name: device name specified in INDENTIFY fram
317  * @boot_device: boot device object from bios page 2
318  *
319  * Returns 1 when there's a match, 0 means no match.
320  */
321 static inline int
322 _scsih_srch_boot_device_name(u64 device_name,
323     Mpi2BootDeviceDeviceName_t *boot_device)
324 {
325         return (device_name == le64_to_cpu(boot_device->DeviceName)) ? 1 : 0;
326 }
327 
328 /**
329  * _scsih_srch_boot_encl_slot - search based on enclosure_logical_id/slot
330  * @enclosure_logical_id: enclosure logical id
331  * @slot_number: slot number
332  * @boot_device: boot device object from bios page 2
333  *
334  * Returns 1 when there's a match, 0 means no match.
335  */
336 static inline int
337 _scsih_srch_boot_encl_slot(u64 enclosure_logical_id, u16 slot_number,
338     Mpi2BootDeviceEnclosureSlot_t *boot_device)
339 {
340         return (enclosure_logical_id == le64_to_cpu(boot_device->
341             EnclosureLogicalID) && slot_number == le16_to_cpu(boot_device->
342             SlotNumber)) ? 1 : 0;
343 }
344 
345 /**
346  * _scsih_is_boot_device - search for matching boot device.
347  * @sas_address: sas address
348  * @device_name: device name specified in INDENTIFY fram
349  * @enclosure_logical_id: enclosure logical id
350  * @slot_number: slot number
351  * @form: specifies boot device form
352  * @boot_device: boot device object from bios page 2
353  *
354  * Returns 1 when there's a match, 0 means no match.
355  */
356 static int
357 _scsih_is_boot_device(u64 sas_address, u64 device_name,
358     u64 enclosure_logical_id, u16 slot, u8 form,
359     Mpi2BiosPage2BootDevice_t *boot_device)
360 {
361         int rc = 0;
362 
363         switch (form) {
364         case MPI2_BIOSPAGE2_FORM_SAS_WWID:
365                 if (!sas_address)
366                         break;
367                 rc = _scsih_srch_boot_sas_address(
368                     sas_address, &boot_device->SasWwid);
369                 break;
370         case MPI2_BIOSPAGE2_FORM_ENCLOSURE_SLOT:
371                 if (!enclosure_logical_id)
372                         break;
373                 rc = _scsih_srch_boot_encl_slot(
374                     enclosure_logical_id,
375                     slot, &boot_device->EnclosureSlot);
376                 break;
377         case MPI2_BIOSPAGE2_FORM_DEVICE_NAME:
378                 if (!device_name)
379                         break;
380                 rc = _scsih_srch_boot_device_name(
381                     device_name, &boot_device->DeviceName);
382                 break;
383         case MPI2_BIOSPAGE2_FORM_NO_DEVICE_SPECIFIED:
384                 break;
385         }
386 
387         return rc;
388 }
389 
390 /**
391  * _scsih_get_sas_address - set the sas_address for given device handle
392  * @handle: device handle
393  * @sas_address: sas address
394  *
395  * Returns 0 success, non-zero when failure
396  */
397 static int
398 _scsih_get_sas_address(struct MPT2SAS_ADAPTER *ioc, u16 handle,
399     u64 *sas_address)
400 {
401         Mpi2SasDevicePage0_t sas_device_pg0;
402         Mpi2ConfigReply_t mpi_reply;
403         u32 ioc_status;
404         *sas_address = 0;
405 
406         if (handle <= ioc->sas_hba.num_phys) {
407                 *sas_address = ioc->sas_hba.sas_address;
408                 return 0;
409         }
410 
411         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
412             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
413                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n", ioc->name,
414                 __FILE__, __LINE__, __func__);
415                 return -ENXIO;
416         }
417 
418         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
419         if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
420                 *sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
421                 return 0;
422         }
423 
424         /* we hit this becuase the given parent handle doesn't exist */
425         if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
426                 return -ENXIO;
427         /* else error case */
428         printk(MPT2SAS_ERR_FMT "handle(0x%04x), ioc_status(0x%04x), "
429             "failure at %s:%d/%s()!\n", ioc->name, handle, ioc_status,
430              __FILE__, __LINE__, __func__);
431         return -EIO;
432 }
433 
434 /**
435  * _scsih_determine_boot_device - determine boot device.
436  * @ioc: per adapter object
437  * @device: either sas_device or raid_device object
438  * @is_raid: [flag] 1 = raid object, 0 = sas object
439  *
440  * Determines whether this device should be first reported device to
441  * to scsi-ml or sas transport, this purpose is for persistent boot device.
442  * There are primary, alternate, and current entries in bios page 2. The order
443  * priority is primary, alternate, then current.  This routine saves
444  * the corresponding device object and is_raid flag in the ioc object.
445  * The saved data to be used later in _scsih_probe_boot_devices().
446  */
447 static void
448 _scsih_determine_boot_device(struct MPT2SAS_ADAPTER *ioc,
449     void *device, u8 is_raid)
450 {
451         struct _sas_device *sas_device;
452         struct _raid_device *raid_device;
453         u64 sas_address;
454         u64 device_name;
455         u64 enclosure_logical_id;
456         u16 slot;
457 
458          /* only process this function when driver loads */
459         if (!ioc->is_driver_loading)
460                 return;
461 
462          /* no Bios, return immediately */
463         if (!ioc->bios_pg3.BiosVersion)
464                 return;
465 
466         if (!is_raid) {
467                 sas_device = device;
468                 sas_address = sas_device->sas_address;
469                 device_name = sas_device->device_name;
470                 enclosure_logical_id = sas_device->enclosure_logical_id;
471                 slot = sas_device->slot;
472         } else {
473                 raid_device = device;
474                 sas_address = raid_device->wwid;
475                 device_name = 0;
476                 enclosure_logical_id = 0;
477                 slot = 0;
478         }
479 
480         if (!ioc->req_boot_device.device) {
481                 if (_scsih_is_boot_device(sas_address, device_name,
482                     enclosure_logical_id, slot,
483                     (ioc->bios_pg2.ReqBootDeviceForm &
484                     MPI2_BIOSPAGE2_FORM_MASK),
485                     &ioc->bios_pg2.RequestedBootDevice)) {
486                         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT
487                            "%s: req_boot_device(0x%016llx)\n",
488                             ioc->name, __func__,
489                             (unsigned long long)sas_address));
490                         ioc->req_boot_device.device = device;
491                         ioc->req_boot_device.is_raid = is_raid;
492                 }
493         }
494 
495         if (!ioc->req_alt_boot_device.device) {
496                 if (_scsih_is_boot_device(sas_address, device_name,
497                     enclosure_logical_id, slot,
498                     (ioc->bios_pg2.ReqAltBootDeviceForm &
499                     MPI2_BIOSPAGE2_FORM_MASK),
500                     &ioc->bios_pg2.RequestedAltBootDevice)) {
501                         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT
502                            "%s: req_alt_boot_device(0x%016llx)\n",
503                             ioc->name, __func__,
504                             (unsigned long long)sas_address));
505                         ioc->req_alt_boot_device.device = device;
506                         ioc->req_alt_boot_device.is_raid = is_raid;
507                 }
508         }
509 
510         if (!ioc->current_boot_device.device) {
511                 if (_scsih_is_boot_device(sas_address, device_name,
512                     enclosure_logical_id, slot,
513                     (ioc->bios_pg2.CurrentBootDeviceForm &
514                     MPI2_BIOSPAGE2_FORM_MASK),
515                     &ioc->bios_pg2.CurrentBootDevice)) {
516                         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT
517                            "%s: current_boot_device(0x%016llx)\n",
518                             ioc->name, __func__,
519                             (unsigned long long)sas_address));
520                         ioc->current_boot_device.device = device;
521                         ioc->current_boot_device.is_raid = is_raid;
522                 }
523         }
524 }
525 
526 /**
527  * mpt2sas_scsih_sas_device_find_by_sas_address - sas device search
528  * @ioc: per adapter object
529  * @sas_address: sas address
530  * Context: Calling function should acquire ioc->sas_device_lock
531  *
532  * This searches for sas_device based on sas_address, then return sas_device
533  * object.
534  */
535 struct _sas_device *
536 mpt2sas_scsih_sas_device_find_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
537     u64 sas_address)
538 {
539         struct _sas_device *sas_device;
540 
541         list_for_each_entry(sas_device, &ioc->sas_device_list, list)
542                 if (sas_device->sas_address == sas_address)
543                         return sas_device;
544 
545         list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
546                 if (sas_device->sas_address == sas_address)
547                         return sas_device;
548 
549         return NULL;
550 }
551 
552 /**
553  * _scsih_sas_device_find_by_handle - sas device search
554  * @ioc: per adapter object
555  * @handle: sas device handle (assigned by firmware)
556  * Context: Calling function should acquire ioc->sas_device_lock
557  *
558  * This searches for sas_device based on sas_address, then return sas_device
559  * object.
560  */
561 static struct _sas_device *
562 _scsih_sas_device_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
563 {
564         struct _sas_device *sas_device;
565 
566         list_for_each_entry(sas_device, &ioc->sas_device_list, list)
567                 if (sas_device->handle == handle)
568                         return sas_device;
569 
570         list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
571                 if (sas_device->handle == handle)
572                         return sas_device;
573 
574         return NULL;
575 }
576 
577 /**
578  * _scsih_sas_device_remove - remove sas_device from list.
579  * @ioc: per adapter object
580  * @sas_device: the sas_device object
581  * Context: This function will acquire ioc->sas_device_lock.
582  *
583  * Removing object and freeing associated memory from the ioc->sas_device_list.
584  */
585 static void
586 _scsih_sas_device_remove(struct MPT2SAS_ADAPTER *ioc,
587     struct _sas_device *sas_device)
588 {
589         unsigned long flags;
590 
591         if (!sas_device)
592                 return;
593 
594         spin_lock_irqsave(&ioc->sas_device_lock, flags);
595         list_del(&sas_device->list);
596         kfree(sas_device);
597         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
598 }
599 
600 
601 /**
602  * _scsih_sas_device_add - insert sas_device to the list.
603  * @ioc: per adapter object
604  * @sas_device: the sas_device object
605  * Context: This function will acquire ioc->sas_device_lock.
606  *
607  * Adding new object to the ioc->sas_device_list.
608  */
609 static void
610 _scsih_sas_device_add(struct MPT2SAS_ADAPTER *ioc,
611     struct _sas_device *sas_device)
612 {
613         unsigned long flags;
614 
615         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle"
616             "(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
617             sas_device->handle, (unsigned long long)sas_device->sas_address));
618 
619         spin_lock_irqsave(&ioc->sas_device_lock, flags);
620         list_add_tail(&sas_device->list, &ioc->sas_device_list);
621         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
622 
623         if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
624              sas_device->sas_address_parent)) {
625                 _scsih_sas_device_remove(ioc, sas_device);
626         } else if (!sas_device->starget) {
627                 /* When asyn scanning is enabled, its not possible to remove
628                  * devices while scanning is turned on due to an oops in
629                  * scsi_sysfs_add_sdev()->add_device()->sysfs_addrm_start()
630                  */
631                 if (!ioc->is_driver_loading) {
632                         mpt2sas_transport_port_remove(ioc,
633                         sas_device->sas_address,
634                         sas_device->sas_address_parent);
635                         _scsih_sas_device_remove(ioc, sas_device);
636                 }
637         }
638 }
639 
640 /**
641  * _scsih_sas_device_init_add - insert sas_device to the list.
642  * @ioc: per adapter object
643  * @sas_device: the sas_device object
644  * Context: This function will acquire ioc->sas_device_lock.
645  *
646  * Adding new object at driver load time to the ioc->sas_device_init_list.
647  */
648 static void
649 _scsih_sas_device_init_add(struct MPT2SAS_ADAPTER *ioc,
650     struct _sas_device *sas_device)
651 {
652         unsigned long flags;
653 
654         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle"
655             "(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
656             sas_device->handle, (unsigned long long)sas_device->sas_address));
657 
658         spin_lock_irqsave(&ioc->sas_device_lock, flags);
659         list_add_tail(&sas_device->list, &ioc->sas_device_init_list);
660         _scsih_determine_boot_device(ioc, sas_device, 0);
661         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
662 }
663 
664 /**
665  * _scsih_raid_device_find_by_id - raid device search
666  * @ioc: per adapter object
667  * @id: sas device target id
668  * @channel: sas device channel
669  * Context: Calling function should acquire ioc->raid_device_lock
670  *
671  * This searches for raid_device based on target id, then return raid_device
672  * object.
673  */
674 static struct _raid_device *
675 _scsih_raid_device_find_by_id(struct MPT2SAS_ADAPTER *ioc, int id, int channel)
676 {
677         struct _raid_device *raid_device, *r;
678 
679         r = NULL;
680         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
681                 if (raid_device->id == id && raid_device->channel == channel) {
682                         r = raid_device;
683                         goto out;
684                 }
685         }
686 
687  out:
688         return r;
689 }
690 
691 /**
692  * _scsih_raid_device_find_by_handle - raid device search
693  * @ioc: per adapter object
694  * @handle: sas device handle (assigned by firmware)
695  * Context: Calling function should acquire ioc->raid_device_lock
696  *
697  * This searches for raid_device based on handle, then return raid_device
698  * object.
699  */
700 static struct _raid_device *
701 _scsih_raid_device_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
702 {
703         struct _raid_device *raid_device, *r;
704 
705         r = NULL;
706         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
707                 if (raid_device->handle != handle)
708                         continue;
709                 r = raid_device;
710                 goto out;
711         }
712 
713  out:
714         return r;
715 }
716 
717 /**
718  * _scsih_raid_device_find_by_wwid - raid device search
719  * @ioc: per adapter object
720  * @handle: sas device handle (assigned by firmware)
721  * Context: Calling function should acquire ioc->raid_device_lock
722  *
723  * This searches for raid_device based on wwid, then return raid_device
724  * object.
725  */
726 static struct _raid_device *
727 _scsih_raid_device_find_by_wwid(struct MPT2SAS_ADAPTER *ioc, u64 wwid)
728 {
729         struct _raid_device *raid_device, *r;
730 
731         r = NULL;
732         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
733                 if (raid_device->wwid != wwid)
734                         continue;
735                 r = raid_device;
736                 goto out;
737         }
738 
739  out:
740         return r;
741 }
742 
743 /**
744  * _scsih_raid_device_add - add raid_device object
745  * @ioc: per adapter object
746  * @raid_device: raid_device object
747  *
748  * This is added to the raid_device_list link list.
749  */
750 static void
751 _scsih_raid_device_add(struct MPT2SAS_ADAPTER *ioc,
752     struct _raid_device *raid_device)
753 {
754         unsigned long flags;
755 
756         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle"
757             "(0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
758             raid_device->handle, (unsigned long long)raid_device->wwid));
759 
760         spin_lock_irqsave(&ioc->raid_device_lock, flags);
761         list_add_tail(&raid_device->list, &ioc->raid_device_list);
762         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
763 }
764 
765 /**
766  * _scsih_raid_device_remove - delete raid_device object
767  * @ioc: per adapter object
768  * @raid_device: raid_device object
769  *
770  */
771 static void
772 _scsih_raid_device_remove(struct MPT2SAS_ADAPTER *ioc,
773     struct _raid_device *raid_device)
774 {
775         unsigned long flags;
776 
777         spin_lock_irqsave(&ioc->raid_device_lock, flags);
778         list_del(&raid_device->list);
779         kfree(raid_device);
780         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
781 }
782 
783 /**
784  * mpt2sas_scsih_expander_find_by_handle - expander device search
785  * @ioc: per adapter object
786  * @handle: expander handle (assigned by firmware)
787  * Context: Calling function should acquire ioc->sas_device_lock
788  *
789  * This searches for expander device based on handle, then returns the
790  * sas_node object.
791  */
792 struct _sas_node *
793 mpt2sas_scsih_expander_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
794 {
795         struct _sas_node *sas_expander, *r;
796 
797         r = NULL;
798         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
799                 if (sas_expander->handle != handle)
800                         continue;
801                 r = sas_expander;
802                 goto out;
803         }
804  out:
805         return r;
806 }
807 
808 /**
809  * mpt2sas_scsih_expander_find_by_sas_address - expander device search
810  * @ioc: per adapter object
811  * @sas_address: sas address
812  * Context: Calling function should acquire ioc->sas_node_lock.
813  *
814  * This searches for expander device based on sas_address, then returns the
815  * sas_node object.
816  */
817 struct _sas_node *
818 mpt2sas_scsih_expander_find_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
819     u64 sas_address)
820 {
821         struct _sas_node *sas_expander, *r;
822 
823         r = NULL;
824         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
825                 if (sas_expander->sas_address != sas_address)
826                         continue;
827                 r = sas_expander;
828                 goto out;
829         }
830  out:
831         return r;
832 }
833 
834 /**
835  * _scsih_expander_node_add - insert expander device to the list.
836  * @ioc: per adapter object
837  * @sas_expander: the sas_device object
838  * Context: This function will acquire ioc->sas_node_lock.
839  *
840  * Adding new object to the ioc->sas_expander_list.
841  *
842  * Return nothing.
843  */
844 static void
845 _scsih_expander_node_add(struct MPT2SAS_ADAPTER *ioc,
846     struct _sas_node *sas_expander)
847 {
848         unsigned long flags;
849 
850         spin_lock_irqsave(&ioc->sas_node_lock, flags);
851         list_add_tail(&sas_expander->list, &ioc->sas_expander_list);
852         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
853 }
854 
855 /**
856  * _scsih_is_end_device - determines if device is an end device
857  * @device_info: bitfield providing information about the device.
858  * Context: none
859  *
860  * Returns 1 if end device.
861  */
862 static int
863 _scsih_is_end_device(u32 device_info)
864 {
865         if (device_info & MPI2_SAS_DEVICE_INFO_END_DEVICE &&
866                 ((device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) |
867                 (device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET) |
868                 (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)))
869                 return 1;
870         else
871                 return 0;
872 }
873 
874 /**
875  * _scsih_scsi_lookup_get - returns scmd entry
876  * @ioc: per adapter object
877  * @smid: system request message index
878  *
879  * Returns the smid stored scmd pointer.
880  */
881 static struct scsi_cmnd *
882 _scsih_scsi_lookup_get(struct MPT2SAS_ADAPTER *ioc, u16 smid)
883 {
884         return ioc->scsi_lookup[smid - 1].scmd;
885 }
886 
887 /**
888  * _scsih_scsi_lookup_get_clear - returns scmd entry
889  * @ioc: per adapter object
890  * @smid: system request message index
891  *
892  * Returns the smid stored scmd pointer.
893  * Then will derefrence the stored scmd pointer.
894  */
895 static inline struct scsi_cmnd *
896 _scsih_scsi_lookup_get_clear(struct MPT2SAS_ADAPTER *ioc, u16 smid)
897 {
898         unsigned long flags;
899         struct scsi_cmnd *scmd;
900 
901         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
902         scmd = ioc->scsi_lookup[smid - 1].scmd;
903         ioc->scsi_lookup[smid - 1].scmd = NULL;
904         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
905 
906         return scmd;
907 }
908 
909 /**
910  * _scsih_scsi_lookup_find_by_scmd - scmd lookup
911  * @ioc: per adapter object
912  * @smid: system request message index
913  * @scmd: pointer to scsi command object
914  * Context: This function will acquire ioc->scsi_lookup_lock.
915  *
916  * This will search for a scmd pointer in the scsi_lookup array,
917  * returning the revelent smid.  A returned value of zero means invalid.
918  */
919 static u16
920 _scsih_scsi_lookup_find_by_scmd(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd
921     *scmd)
922 {
923         u16 smid;
924         unsigned long   flags;
925         int i;
926 
927         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
928         smid = 0;
929         for (i = 0; i < ioc->scsiio_depth; i++) {
930                 if (ioc->scsi_lookup[i].scmd == scmd) {
931                         smid = ioc->scsi_lookup[i].smid;
932                         goto out;
933                 }
934         }
935  out:
936         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
937         return smid;
938 }
939 
940 /**
941  * _scsih_scsi_lookup_find_by_target - search for matching channel:id
942  * @ioc: per adapter object
943  * @id: target id
944  * @channel: channel
945  * Context: This function will acquire ioc->scsi_lookup_lock.
946  *
947  * This will search for a matching channel:id in the scsi_lookup array,
948  * returning 1 if found.
949  */
950 static u8
951 _scsih_scsi_lookup_find_by_target(struct MPT2SAS_ADAPTER *ioc, int id,
952     int channel)
953 {
954         u8 found;
955         unsigned long   flags;
956         int i;
957 
958         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
959         found = 0;
960         for (i = 0 ; i < ioc->scsiio_depth; i++) {
961                 if (ioc->scsi_lookup[i].scmd &&
962                     (ioc->scsi_lookup[i].scmd->device->id == id &&
963                     ioc->scsi_lookup[i].scmd->device->channel == channel)) {
964                         found = 1;
965                         goto out;
966                 }
967         }
968  out:
969         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
970         return found;
971 }
972 
973 /**
974  * _scsih_scsi_lookup_find_by_lun - search for matching channel:id:lun
975  * @ioc: per adapter object
976  * @id: target id
977  * @lun: lun number
978  * @channel: channel
979  * Context: This function will acquire ioc->scsi_lookup_lock.
980  *
981  * This will search for a matching channel:id:lun in the scsi_lookup array,
982  * returning 1 if found.
983  */
984 static u8
985 _scsih_scsi_lookup_find_by_lun(struct MPT2SAS_ADAPTER *ioc, int id,
986     unsigned int lun, int channel)
987 {
988         u8 found;
989         unsigned long   flags;
990         int i;
991 
992         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
993         found = 0;
994         for (i = 0 ; i < ioc->scsiio_depth; i++) {
995                 if (ioc->scsi_lookup[i].scmd &&
996                     (ioc->scsi_lookup[i].scmd->device->id == id &&
997                     ioc->scsi_lookup[i].scmd->device->channel == channel &&
998                     ioc->scsi_lookup[i].scmd->device->lun == lun)) {
999                         found = 1;
1000                         goto out;
1001                 }
1002         }
1003  out:
1004         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1005         return found;
1006 }
1007 
1008 /**
1009  * _scsih_get_chain_buffer_tracker - obtain chain tracker
1010  * @ioc: per adapter object
1011  * @smid: smid associated to an IO request
1012  *
1013  * Returns chain tracker(from ioc->free_chain_list)
1014  */
1015 static struct chain_tracker *
1016 _scsih_get_chain_buffer_tracker(struct MPT2SAS_ADAPTER *ioc, u16 smid)
1017 {
1018         struct chain_tracker *chain_req;
1019         unsigned long flags;
1020 
1021         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1022         if (list_empty(&ioc->free_chain_list)) {
1023                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1024                 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT "chain buffers not "
1025                         "available\n", ioc->name));
1026                 return NULL;
1027         }
1028         chain_req = list_entry(ioc->free_chain_list.next,
1029             struct chain_tracker, tracker_list);
1030         list_del_init(&chain_req->tracker_list);
1031         list_add_tail(&chain_req->tracker_list,
1032             &ioc->scsi_lookup[smid - 1].chain_list);
1033         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1034         return chain_req;
1035 }
1036 
1037 /**
1038  * _scsih_build_scatter_gather - main sg creation routine
1039  * @ioc: per adapter object
1040  * @scmd: scsi command
1041  * @smid: system request message index
1042  * Context: none.
1043  *
1044  * The main routine that builds scatter gather table from a given
1045  * scsi request sent via the .queuecommand main handler.
1046  *
1047  * Returns 0 success, anything else error
1048  */
1049 static int
1050 _scsih_build_scatter_gather(struct MPT2SAS_ADAPTER *ioc,
1051     struct scsi_cmnd *scmd, u16 smid)
1052 {
1053         Mpi2SCSIIORequest_t *mpi_request;
1054         dma_addr_t chain_dma;
1055         struct scatterlist *sg_scmd;
1056         void *sg_local, *chain;
1057         u32 chain_offset;
1058         u32 chain_length;
1059         u32 chain_flags;
1060         int sges_left;
1061         u32 sges_in_segment;
1062         u32 sgl_flags;
1063         u32 sgl_flags_last_element;
1064         u32 sgl_flags_end_buffer;
1065         struct chain_tracker *chain_req;
1066 
1067         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1068 
1069         /* init scatter gather flags */
1070         sgl_flags = MPI2_SGE_FLAGS_SIMPLE_ELEMENT;
1071         if (scmd->sc_data_direction == DMA_TO_DEVICE)
1072                 sgl_flags |= MPI2_SGE_FLAGS_HOST_TO_IOC;
1073         sgl_flags_last_element = (sgl_flags | MPI2_SGE_FLAGS_LAST_ELEMENT)
1074             << MPI2_SGE_FLAGS_SHIFT;
1075         sgl_flags_end_buffer = (sgl_flags | MPI2_SGE_FLAGS_LAST_ELEMENT |
1076             MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_END_OF_LIST)
1077             << MPI2_SGE_FLAGS_SHIFT;
1078         sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
1079 
1080         sg_scmd = scsi_sglist(scmd);
1081         sges_left = scsi_dma_map(scmd);
1082         if (sges_left < 0) {
1083                 sdev_printk(KERN_ERR, scmd->device, "pci_map_sg"
1084                 " failed: request for %d bytes!\n", scsi_bufflen(scmd));
1085                 return -ENOMEM;
1086         }
1087 
1088         sg_local = &mpi_request->SGL;
1089         sges_in_segment = ioc->max_sges_in_main_message;
1090         if (sges_left <= sges_in_segment)
1091                 goto fill_in_last_segment;
1092 
1093         mpi_request->ChainOffset = (offsetof(Mpi2SCSIIORequest_t, SGL) +
1094             (sges_in_segment * ioc->sge_size))/4;
1095 
1096         /* fill in main message segment when there is a chain following */
1097         while (sges_in_segment) {
1098                 if (sges_in_segment == 1)
1099                         ioc->base_add_sg_single(sg_local,
1100                             sgl_flags_last_element | sg_dma_len(sg_scmd),
1101                             sg_dma_address(sg_scmd));
1102                 else
1103                         ioc->base_add_sg_single(sg_local, sgl_flags |
1104                             sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));
1105                 sg_scmd = sg_next(sg_scmd);
1106                 sg_local += ioc->sge_size;
1107                 sges_left--;
1108                 sges_in_segment--;
1109         }
1110 
1111         /* initializing the chain flags and pointers */
1112         chain_flags = MPI2_SGE_FLAGS_CHAIN_ELEMENT << MPI2_SGE_FLAGS_SHIFT;
1113         chain_req = _scsih_get_chain_buffer_tracker(ioc, smid);
1114         if (!chain_req)
1115                 return -1;
1116         chain = chain_req->chain_buffer;
1117         chain_dma = chain_req->chain_buffer_dma;
1118         do {
1119                 sges_in_segment = (sges_left <=
1120                     ioc->max_sges_in_chain_message) ? sges_left :
1121                     ioc->max_sges_in_chain_message;
1122                 chain_offset = (sges_left == sges_in_segment) ?
1123                     0 : (sges_in_segment * ioc->sge_size)/4;
1124                 chain_length = sges_in_segment * ioc->sge_size;
1125                 if (chain_offset) {
1126                         chain_offset = chain_offset <<
1127                             MPI2_SGE_CHAIN_OFFSET_SHIFT;
1128                         chain_length += ioc->sge_size;
1129                 }
1130                 ioc->base_add_sg_single(sg_local, chain_flags | chain_offset |
1131                     chain_length, chain_dma);
1132                 sg_local = chain;
1133                 if (!chain_offset)
1134                         goto fill_in_last_segment;
1135 
1136                 /* fill in chain segments */
1137                 while (sges_in_segment) {
1138                         if (sges_in_segment == 1)
1139                                 ioc->base_add_sg_single(sg_local,
1140                                     sgl_flags_last_element |
1141                                     sg_dma_len(sg_scmd),
1142                                     sg_dma_address(sg_scmd));
1143                         else
1144                                 ioc->base_add_sg_single(sg_local, sgl_flags |
1145                                     sg_dma_len(sg_scmd),
1146                                     sg_dma_address(sg_scmd));
1147                         sg_scmd = sg_next(sg_scmd);
1148                         sg_local += ioc->sge_size;
1149                         sges_left--;
1150                         sges_in_segment--;
1151                 }
1152 
1153                 chain_req = _scsih_get_chain_buffer_tracker(ioc, smid);
1154                 if (!chain_req)
1155                         return -1;
1156                 chain = chain_req->chain_buffer;
1157                 chain_dma = chain_req->chain_buffer_dma;
1158         } while (1);
1159 
1160 
1161  fill_in_last_segment:
1162 
1163         /* fill the last segment */
1164         while (sges_left) {
1165                 if (sges_left == 1)
1166                         ioc->base_add_sg_single(sg_local, sgl_flags_end_buffer |
1167                             sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));
1168                 else
1169                         ioc->base_add_sg_single(sg_local, sgl_flags |
1170                             sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));
1171                 sg_scmd = sg_next(sg_scmd);
1172                 sg_local += ioc->sge_size;
1173                 sges_left--;
1174         }
1175 
1176         return 0;
1177 }
1178 
1179 /**
1180  * _scsih_adjust_queue_depth - setting device queue depth
1181  * @sdev: scsi device struct
1182  * @qdepth: requested queue depth
1183  *
1184  *
1185  * Returns nothing
1186  */
1187 static void
1188 _scsih_adjust_queue_depth(struct scsi_device *sdev, int qdepth)
1189 {
1190         struct Scsi_Host *shost = sdev->host;
1191         int max_depth;
1192         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1193         struct MPT2SAS_DEVICE *sas_device_priv_data;
1194         struct MPT2SAS_TARGET *sas_target_priv_data;
1195         struct _sas_device *sas_device;
1196         unsigned long flags;
1197 
1198         max_depth = shost->can_queue;
1199 
1200         /* limit max device queue for SATA to 32 */
1201         sas_device_priv_data = sdev->hostdata;
1202         if (!sas_device_priv_data)
1203                 goto not_sata;
1204         sas_target_priv_data = sas_device_priv_data->sas_target;
1205         if (!sas_target_priv_data)
1206                 goto not_sata;
1207         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))
1208                 goto not_sata;
1209         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1210         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1211            sas_device_priv_data->sas_target->sas_address);
1212         if (sas_device && sas_device->device_info &
1213             MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
1214                 max_depth = MPT2SAS_SATA_QUEUE_DEPTH;
1215         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1216 
1217  not_sata:
1218 
1219         if (!sdev->tagged_supported)
1220                 max_depth = 1;
1221         if (qdepth > max_depth)
1222                 qdepth = max_depth;
1223         scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
1224 }
1225 
1226 /**
1227  * _scsih_change_queue_depth - setting device queue depth
1228  * @sdev: scsi device struct
1229  * @qdepth: requested queue depth
1230  * @reason: SCSI_QDEPTH_DEFAULT/SCSI_QDEPTH_QFULL/SCSI_QDEPTH_RAMP_UP
1231  * (see include/scsi/scsi_host.h for definition)
1232  *
1233  * Returns queue depth.
1234  */
1235 static int
1236 _scsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
1237 {
1238         if (reason == SCSI_QDEPTH_DEFAULT || reason == SCSI_QDEPTH_RAMP_UP)
1239                 _scsih_adjust_queue_depth(sdev, qdepth);
1240         else if (reason == SCSI_QDEPTH_QFULL)
1241                 scsi_track_queue_full(sdev, qdepth);
1242         else
1243                 return -EOPNOTSUPP;
1244 
1245         if (sdev->inquiry_len > 7)
1246                 sdev_printk(KERN_INFO, sdev, "qdepth(%d), tagged(%d), "
1247                 "simple(%d), ordered(%d), scsi_level(%d), cmd_que(%d)\n",
1248                 sdev->queue_depth, sdev->tagged_supported, sdev->simple_tags,
1249                 sdev->ordered_tags, sdev->scsi_level,
1250                 (sdev->inquiry[7] & 2) >> 1);
1251 
1252         return sdev->queue_depth;
1253 }
1254 
1255 /**
1256  * _scsih_change_queue_type - changing device queue tag type
1257  * @sdev: scsi device struct
1258  * @tag_type: requested tag type
1259  *
1260  * Returns queue tag type.
1261  */
1262 static int
1263 _scsih_change_queue_type(struct scsi_device *sdev, int tag_type)
1264 {
1265         if (sdev->tagged_supported) {
1266                 scsi_set_tag_type(sdev, tag_type);
1267                 if (tag_type)
1268                         scsi_activate_tcq(sdev, sdev->queue_depth);
1269                 else
1270                         scsi_deactivate_tcq(sdev, sdev->queue_depth);
1271         } else
1272                 tag_type = 0;
1273 
1274         return tag_type;
1275 }
1276 
1277 /**
1278  * _scsih_target_alloc - target add routine
1279  * @starget: scsi target struct
1280  *
1281  * Returns 0 if ok. Any other return is assumed to be an error and
1282  * the device is ignored.
1283  */
1284 static int
1285 _scsih_target_alloc(struct scsi_target *starget)
1286 {
1287         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1288         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1289         struct MPT2SAS_TARGET *sas_target_priv_data;
1290         struct _sas_device *sas_device;
1291         struct _raid_device *raid_device;
1292         unsigned long flags;
1293         struct sas_rphy *rphy;
1294 
1295         sas_target_priv_data = kzalloc(sizeof(struct scsi_target), GFP_KERNEL);
1296         if (!sas_target_priv_data)
1297                 return -ENOMEM;
1298 
1299         starget->hostdata = sas_target_priv_data;
1300         sas_target_priv_data->starget = starget;
1301         sas_target_priv_data->handle = MPT2SAS_INVALID_DEVICE_HANDLE;
1302 
1303         /* RAID volumes */
1304         if (starget->channel == RAID_CHANNEL) {
1305                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1306                 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1307                     starget->channel);
1308                 if (raid_device) {
1309                         sas_target_priv_data->handle = raid_device->handle;
1310                         sas_target_priv_data->sas_address = raid_device->wwid;
1311                         sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME;
1312                         if (ioc->is_warpdrive)
1313                                 sas_target_priv_data->raid_device = raid_device;
1314                         raid_device->starget = starget;
1315                 }
1316                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1317                 return 0;
1318         }
1319 
1320         /* sas/sata devices */
1321         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1322         rphy = dev_to_rphy(starget->dev.parent);
1323         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1324            rphy->identify.sas_address);
1325 
1326         if (sas_device) {
1327                 sas_target_priv_data->handle = sas_device->handle;
1328                 sas_target_priv_data->sas_address = sas_device->sas_address;
1329                 sas_device->starget = starget;
1330                 sas_device->id = starget->id;
1331                 sas_device->channel = starget->channel;
1332                 if (test_bit(sas_device->handle, ioc->pd_handles))
1333                         sas_target_priv_data->flags |=
1334                             MPT_TARGET_FLAGS_RAID_COMPONENT;
1335         }
1336         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1337 
1338         return 0;
1339 }
1340 
1341 /**
1342  * _scsih_target_destroy - target destroy routine
1343  * @starget: scsi target struct
1344  *
1345  * Returns nothing.
1346  */
1347 static void
1348 _scsih_target_destroy(struct scsi_target *starget)
1349 {
1350         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1351         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1352         struct MPT2SAS_TARGET *sas_target_priv_data;
1353         struct _sas_device *sas_device;
1354         struct _raid_device *raid_device;
1355         unsigned long flags;
1356         struct sas_rphy *rphy;
1357 
1358         sas_target_priv_data = starget->hostdata;
1359         if (!sas_target_priv_data)
1360                 return;
1361 
1362         if (starget->channel == RAID_CHANNEL) {
1363                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1364                 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1365                     starget->channel);
1366                 if (raid_device) {
1367                         raid_device->starget = NULL;
1368                         raid_device->sdev = NULL;
1369                 }
1370                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1371                 goto out;
1372         }
1373 
1374         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1375         rphy = dev_to_rphy(starget->dev.parent);
1376         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1377            rphy->identify.sas_address);
1378         if (sas_device && (sas_device->starget == starget) &&
1379             (sas_device->id == starget->id) &&
1380             (sas_device->channel == starget->channel))
1381                 sas_device->starget = NULL;
1382 
1383         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1384 
1385  out:
1386         kfree(sas_target_priv_data);
1387         starget->hostdata = NULL;
1388 }
1389 
1390 /**
1391  * _scsih_slave_alloc - device add routine
1392  * @sdev: scsi device struct
1393  *
1394  * Returns 0 if ok. Any other return is assumed to be an error and
1395  * the device is ignored.
1396  */
1397 static int
1398 _scsih_slave_alloc(struct scsi_device *sdev)
1399 {
1400         struct Scsi_Host *shost;
1401         struct MPT2SAS_ADAPTER *ioc;
1402         struct MPT2SAS_TARGET *sas_target_priv_data;
1403         struct MPT2SAS_DEVICE *sas_device_priv_data;
1404         struct scsi_target *starget;
1405         struct _raid_device *raid_device;
1406         struct _sas_device *sas_device;
1407         unsigned long flags;
1408 
1409         sas_device_priv_data = kzalloc(sizeof(struct scsi_device), GFP_KERNEL);
1410         if (!sas_device_priv_data)
1411                 return -ENOMEM;
1412 
1413         sas_device_priv_data->lun = sdev->lun;
1414         sas_device_priv_data->flags = MPT_DEVICE_FLAGS_INIT;
1415 
1416         starget = scsi_target(sdev);
1417         sas_target_priv_data = starget->hostdata;
1418         sas_target_priv_data->num_luns++;
1419         sas_device_priv_data->sas_target = sas_target_priv_data;
1420         sdev->hostdata = sas_device_priv_data;
1421         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT))
1422                 sdev->no_uld_attach = 1;
1423 
1424         shost = dev_to_shost(&starget->dev);
1425         ioc = shost_priv(shost);
1426         if (starget->channel == RAID_CHANNEL) {
1427                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1428                 raid_device = _scsih_raid_device_find_by_id(ioc,
1429                     starget->id, starget->channel);
1430                 if (raid_device)
1431                         raid_device->sdev = sdev; /* raid is single lun */
1432                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1433         }
1434 
1435         if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
1436                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1437                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1438                                 sas_target_priv_data->sas_address);
1439                 if (sas_device && (sas_device->starget == NULL)) {
1440                         sdev_printk(KERN_INFO, sdev,
1441                              "%s : sas_device->starget set to starget @ %d\n",
1442                              __func__, __LINE__);
1443                         sas_device->starget = starget;
1444                 }
1445                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1446         }
1447 
1448         return 0;
1449 }
1450 
1451 /**
1452  * _scsih_slave_destroy - device destroy routine
1453  * @sdev: scsi device struct
1454  *
1455  * Returns nothing.
1456  */
1457 static void
1458 _scsih_slave_destroy(struct scsi_device *sdev)
1459 {
1460         struct MPT2SAS_TARGET *sas_target_priv_data;
1461         struct scsi_target *starget;
1462         struct Scsi_Host *shost;
1463         struct MPT2SAS_ADAPTER *ioc;
1464         struct _sas_device *sas_device;
1465         unsigned long flags;
1466 
1467         if (!sdev->hostdata)
1468                 return;
1469 
1470         starget = scsi_target(sdev);
1471         sas_target_priv_data = starget->hostdata;
1472         sas_target_priv_data->num_luns--;
1473 
1474         shost = dev_to_shost(&starget->dev);
1475         ioc = shost_priv(shost);
1476 
1477         if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
1478                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1479                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1480                    sas_target_priv_data->sas_address);
1481                 if (sas_device && !sas_target_priv_data->num_luns)
1482                         sas_device->starget = NULL;
1483                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1484         }
1485 
1486         kfree(sdev->hostdata);
1487         sdev->hostdata = NULL;
1488 }
1489 
1490 /**
1491  * _scsih_display_sata_capabilities - sata capabilities
1492  * @ioc: per adapter object
1493  * @handle: device handle
1494  * @sdev: scsi device struct
1495  */
1496 static void
1497 _scsih_display_sata_capabilities(struct MPT2SAS_ADAPTER *ioc,
1498         u16 handle, struct scsi_device *sdev)
1499 {
1500         Mpi2ConfigReply_t mpi_reply;
1501         Mpi2SasDevicePage0_t sas_device_pg0;
1502         u32 ioc_status;
1503         u16 flags;
1504         u32 device_info;
1505 
1506         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
1507             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
1508                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
1509                     ioc->name, __FILE__, __LINE__, __func__);
1510                 return;
1511         }
1512 
1513         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1514             MPI2_IOCSTATUS_MASK;
1515         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1516                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
1517                     ioc->name, __FILE__, __LINE__, __func__);
1518                 return;
1519         }
1520 
1521         flags = le16_to_cpu(sas_device_pg0.Flags);
1522         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
1523 
1524         sdev_printk(KERN_INFO, sdev,
1525             "atapi(%s), ncq(%s), asyn_notify(%s), smart(%s), fua(%s), "
1526             "sw_preserve(%s)\n",
1527             (device_info & MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? "y" : "n",
1528             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_NCQ_SUPPORTED) ? "y" : "n",
1529             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_ASYNCHRONOUS_NOTIFY) ? "y" :
1530             "n",
1531             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SMART_SUPPORTED) ? "y" : "n",
1532             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_FUA_SUPPORTED) ? "y" : "n",
1533             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SW_PRESERVE) ? "y" : "n");
1534 }
1535 
1536 /**
1537  * _scsih_is_raid - return boolean indicating device is raid volume
1538  * @dev the device struct object
1539  */
1540 static int
1541 _scsih_is_raid(struct device *dev)
1542 {
1543         struct scsi_device *sdev = to_scsi_device(dev);
1544         struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
1545 
1546         if (ioc->is_warpdrive)
1547                 return 0;
1548         return (sdev->channel == RAID_CHANNEL) ? 1 : 0;
1549 }
1550 
1551 /**
1552  * _scsih_get_resync - get raid volume resync percent complete
1553  * @dev the device struct object
1554  */
1555 static void
1556 _scsih_get_resync(struct device *dev)
1557 {
1558         struct scsi_device *sdev = to_scsi_device(dev);
1559         struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
1560         static struct _raid_device *raid_device;
1561         unsigned long flags;
1562         Mpi2RaidVolPage0_t vol_pg0;
1563         Mpi2ConfigReply_t mpi_reply;
1564         u32 volume_status_flags;
1565         u8 percent_complete;
1566         u16 handle;
1567 
1568         percent_complete = 0;
1569         handle = 0;
1570         if (ioc->is_warpdrive)
1571                 goto out;
1572 
1573         spin_lock_irqsave(&ioc->raid_device_lock, flags);
1574         raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1575             sdev->channel);
1576         if (raid_device) {
1577                 handle = raid_device->handle;
1578                 percent_complete = raid_device->percent_complete;
1579         }
1580         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1581 
1582         if (!handle)
1583                 goto out;
1584 
1585         if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1586              MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
1587              sizeof(Mpi2RaidVolPage0_t))) {
1588                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
1589                     ioc->name, __FILE__, __LINE__, __func__);
1590                 percent_complete = 0;
1591                 goto out;
1592         }
1593 
1594         volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags);
1595         if (!(volume_status_flags &
1596             MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS))
1597                 percent_complete = 0;
1598 
1599  out:
1600         raid_set_resync(mpt2sas_raid_template, dev, percent_complete);
1601 }
1602 
1603 /**
1604  * _scsih_get_state - get raid volume level
1605  * @dev the device struct object
1606  */
1607 static void
1608 _scsih_get_state(struct device *dev)
1609 {
1610         struct scsi_device *sdev = to_scsi_device(dev);
1611         struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
1612         static struct _raid_device *raid_device;
1613         unsigned long flags;
1614         Mpi2RaidVolPage0_t vol_pg0;
1615         Mpi2ConfigReply_t mpi_reply;
1616         u32 volstate;
1617         enum raid_state state = RAID_STATE_UNKNOWN;
1618         u16 handle = 0;
1619 
1620         spin_lock_irqsave(&ioc->raid_device_lock, flags);
1621         raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1622             sdev->channel);
1623         if (raid_device)
1624                 handle = raid_device->handle;
1625         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1626 
1627         if (!raid_device)
1628                 goto out;
1629 
1630         if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1631              MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
1632              sizeof(Mpi2RaidVolPage0_t))) {
1633                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
1634                     ioc->name, __FILE__, __LINE__, __func__);
1635                 goto out;
1636         }
1637 
1638         volstate = le32_to_cpu(vol_pg0.VolumeStatusFlags);
1639         if (volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) {
1640                 state = RAID_STATE_RESYNCING;
1641                 goto out;
1642         }
1643 
1644         switch (vol_pg0.VolumeState) {
1645         case MPI2_RAID_VOL_STATE_OPTIMAL:
1646         case MPI2_RAID_VOL_STATE_ONLINE:
1647                 state = RAID_STATE_ACTIVE;
1648                 break;
1649         case  MPI2_RAID_VOL_STATE_DEGRADED:
1650                 state = RAID_STATE_DEGRADED;
1651                 break;
1652         case MPI2_RAID_VOL_STATE_FAILED:
1653         case MPI2_RAID_VOL_STATE_MISSING:
1654                 state = RAID_STATE_OFFLINE;
1655                 break;
1656         }
1657  out:
1658         raid_set_state(mpt2sas_raid_template, dev, state);
1659 }
1660 
1661 /**
1662  * _scsih_set_level - set raid level
1663  * @sdev: scsi device struct
1664  * @volume_type: volume type
1665  */
1666 static void
1667 _scsih_set_level(struct scsi_device *sdev, u8 volume_type)
1668 {
1669         enum raid_level level = RAID_LEVEL_UNKNOWN;
1670 
1671         switch (volume_type) {
1672         case MPI2_RAID_VOL_TYPE_RAID0:
1673                 level = RAID_LEVEL_0;
1674                 break;
1675         case MPI2_RAID_VOL_TYPE_RAID10:
1676                 level = RAID_LEVEL_10;
1677                 break;
1678         case MPI2_RAID_VOL_TYPE_RAID1E:
1679                 level = RAID_LEVEL_1E;
1680                 break;
1681         case MPI2_RAID_VOL_TYPE_RAID1:
1682                 level = RAID_LEVEL_1;
1683                 break;
1684         }
1685 
1686         raid_set_level(mpt2sas_raid_template, &sdev->sdev_gendev, level);
1687 }
1688 
1689 /**
1690  * _scsih_get_volume_capabilities - volume capabilities
1691  * @ioc: per adapter object
1692  * @sas_device: the raid_device object
1693  *
1694  * Returns 0 for success, else 1
1695  */
1696 static int
1697 _scsih_get_volume_capabilities(struct MPT2SAS_ADAPTER *ioc,
1698     struct _raid_device *raid_device)
1699 {
1700         Mpi2RaidVolPage0_t *vol_pg0;
1701         Mpi2RaidPhysDiskPage0_t pd_pg0;
1702         Mpi2SasDevicePage0_t sas_device_pg0;
1703         Mpi2ConfigReply_t mpi_reply;
1704         u16 sz;
1705         u8 num_pds;
1706 
1707         if ((mpt2sas_config_get_number_pds(ioc, raid_device->handle,
1708             &num_pds)) || !num_pds) {
1709                 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
1710                     "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1711                     __func__));
1712                 return 1;
1713         }
1714 
1715         raid_device->num_pds = num_pds;
1716         sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds *
1717             sizeof(Mpi2RaidVol0PhysDisk_t));
1718         vol_pg0 = kzalloc(sz, GFP_KERNEL);
1719         if (!vol_pg0) {
1720                 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
1721                     "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1722                     __func__));
1723                 return 1;
1724         }
1725 
1726         if ((mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
1727              MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
1728                 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
1729                     "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1730                     __func__));
1731                 kfree(vol_pg0);
1732                 return 1;
1733         }
1734 
1735         raid_device->volume_type = vol_pg0->VolumeType;
1736 
1737         /* figure out what the underlying devices are by
1738          * obtaining the device_info bits for the 1st device
1739          */
1740         if (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
1741             &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
1742             vol_pg0->PhysDisk[0].PhysDiskNum))) {
1743                 if (!(mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
1744                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
1745                     le16_to_cpu(pd_pg0.DevHandle)))) {
1746                         raid_device->device_info =
1747                             le32_to_cpu(sas_device_pg0.DeviceInfo);
1748                 }
1749         }
1750 
1751         kfree(vol_pg0);
1752         return 0;
1753 }
1754 /**
1755  * _scsih_disable_ddio - Disable direct I/O for all the volumes
1756  * @ioc: per adapter object
1757  */
1758 static void
1759 _scsih_disable_ddio(struct MPT2SAS_ADAPTER *ioc)
1760 {
1761         Mpi2RaidVolPage1_t vol_pg1;
1762         Mpi2ConfigReply_t mpi_reply;
1763         struct _raid_device *raid_device;
1764         u16 handle;
1765         u16 ioc_status;
1766         unsigned long flags;
1767 
1768         handle = 0xFFFF;
1769         while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
1770             &vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
1771                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1772                     MPI2_IOCSTATUS_MASK;
1773                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
1774                         break;
1775                 handle = le16_to_cpu(vol_pg1.DevHandle);
1776                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1777                 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
1778                 if (raid_device)
1779                         raid_device->direct_io_enabled = 0;
1780                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1781         }
1782         return;
1783 }
1784 
1785 
1786 /**
1787  * _scsih_get_num_volumes - Get number of volumes in the ioc
1788  * @ioc: per adapter object
1789  */
1790 static u8
1791 _scsih_get_num_volumes(struct MPT2SAS_ADAPTER *ioc)
1792 {
1793         Mpi2RaidVolPage1_t vol_pg1;
1794         Mpi2ConfigReply_t mpi_reply;
1795         u16 handle;
1796         u8 vol_cnt = 0;
1797         u16 ioc_status;
1798 
1799         handle = 0xFFFF;
1800         while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
1801             &vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
1802                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1803                     MPI2_IOCSTATUS_MASK;
1804                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
1805                         break;
1806                 vol_cnt++;
1807                 handle = le16_to_cpu(vol_pg1.DevHandle);
1808         }
1809         return vol_cnt;
1810 }
1811 
1812 
1813 /**
1814  * _scsih_init_warpdrive_properties - Set properties for warpdrive direct I/O.
1815  * @ioc: per adapter object
1816  * @raid_device: the raid_device object
1817  */
1818 static void
1819 _scsih_init_warpdrive_properties(struct MPT2SAS_ADAPTER *ioc,
1820         struct _raid_device *raid_device)
1821 {
1822         Mpi2RaidVolPage0_t *vol_pg0;
1823         Mpi2RaidPhysDiskPage0_t pd_pg0;
1824         Mpi2ConfigReply_t mpi_reply;
1825         u16 sz;
1826         u8 num_pds, count;
1827         unsigned long stripe_sz, block_sz;
1828         u8 stripe_exp, block_exp;
1829         u64 dev_max_lba;
1830 
1831         if (!ioc->is_warpdrive)
1832                 return;
1833 
1834         if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_EXPOSE_ALL_DISKS) {
1835                 printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
1836                     "globally as drives are exposed\n", ioc->name);
1837                 return;
1838         }
1839         if (_scsih_get_num_volumes(ioc) > 1) {
1840                 _scsih_disable_ddio(ioc);
1841                 printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
1842                     "globally as number of drives > 1\n", ioc->name);
1843                 return;
1844         }
1845         if ((mpt2sas_config_get_number_pds(ioc, raid_device->handle,
1846             &num_pds)) || !num_pds) {
1847                 printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
1848                     "Failure in computing number of drives\n", ioc->name);
1849                 return;
1850         }
1851 
1852         sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds *
1853             sizeof(Mpi2RaidVol0PhysDisk_t));
1854         vol_pg0 = kzalloc(sz, GFP_KERNEL);
1855         if (!vol_pg0) {
1856                 printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
1857                     "Memory allocation failure for RVPG0\n", ioc->name);
1858                 return;
1859         }
1860 
1861         if ((mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
1862              MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
1863                 printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
1864                     "Failure in retrieving RVPG0\n", ioc->name);
1865                 kfree(vol_pg0);
1866                 return;
1867         }
1868 
1869         /*
1870          * WARPDRIVE:If number of physical disks in a volume exceeds the max pds
1871          * assumed for WARPDRIVE, disable direct I/O
1872          */
1873         if (num_pds > MPT_MAX_WARPDRIVE_PDS) {
1874                 printk(MPT2SAS_WARN_FMT "WarpDrive : Direct IO is disabled "
1875                     "for the drive with handle(0x%04x): num_mem=%d, "
1876                     "max_mem_allowed=%d\n", ioc->name, raid_device->handle,
1877                     num_pds, MPT_MAX_WARPDRIVE_PDS);
1878                 kfree(vol_pg0);
1879                 return;
1880         }
1881         for (count = 0; count < num_pds; count++) {
1882                 if (mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
1883                     &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
1884                     vol_pg0->PhysDisk[count].PhysDiskNum) ||
1885                      le16_to_cpu(pd_pg0.DevHandle) ==
1886                     MPT2SAS_INVALID_DEVICE_HANDLE) {
1887                         printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is "
1888                             "disabled for the drive with handle(0x%04x) member"
1889                             "handle retrieval failed for member number=%d\n",
1890                             ioc->name, raid_device->handle,
1891                             vol_pg0->PhysDisk[count].PhysDiskNum);
1892                         goto out_error;
1893                 }
1894                 /* Disable direct I/O if member drive lba exceeds 4 bytes */
1895                 dev_max_lba = le64_to_cpu(pd_pg0.DeviceMaxLBA);
1896                 if (dev_max_lba >> 32) {
1897                         printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is "
1898                             "disabled for the drive with handle(0x%04x) member"
1899                             "handle (0x%04x) unsupported max lba 0x%016llx\n",
1900                             ioc->name, raid_device->handle,
1901                             le16_to_cpu(pd_pg0.DevHandle),
1902                             (unsigned long long)dev_max_lba);
1903                         goto out_error;
1904                 }
1905 
1906                 raid_device->pd_handle[count] = le16_to_cpu(pd_pg0.DevHandle);
1907         }
1908 
1909         /*
1910          * Assumption for WD: Direct I/O is not supported if the volume is
1911          * not RAID0
1912          */
1913         if (raid_device->volume_type != MPI2_RAID_VOL_TYPE_RAID0) {
1914                 printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
1915                     "for the drive with handle(0x%04x): type=%d, "
1916                     "s_sz=%uK, blk_size=%u\n", ioc->name,
1917                     raid_device->handle, raid_device->volume_type,
1918                     (le32_to_cpu(vol_pg0->StripeSize) *
1919                     le16_to_cpu(vol_pg0->BlockSize)) / 1024,
1920                     le16_to_cpu(vol_pg0->BlockSize));
1921                 goto out_error;
1922         }
1923 
1924         stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
1925         stripe_exp = find_first_bit(&stripe_sz, 32);
1926         if (stripe_exp == 32) {
1927                 printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
1928                 "for the drive with handle(0x%04x) invalid stripe sz %uK\n",
1929                     ioc->name, raid_device->handle,
1930                     (le32_to_cpu(vol_pg0->StripeSize) *
1931                     le16_to_cpu(vol_pg0->BlockSize)) / 1024);
1932                 goto out_error;
1933         }
1934         raid_device->stripe_exponent = stripe_exp;
1935         block_sz = le16_to_cpu(vol_pg0->BlockSize);
1936         block_exp = find_first_bit(&block_sz, 16);
1937         if (block_exp == 16) {
1938                 printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
1939                     "for the drive with handle(0x%04x) invalid block sz %u\n",
1940                     ioc->name, raid_device->handle,
1941                     le16_to_cpu(vol_pg0->BlockSize));
1942                 goto out_error;
1943         }
1944         raid_device->block_exponent = block_exp;
1945         raid_device->direct_io_enabled = 1;
1946 
1947         printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is Enabled for the drive"
1948             " with handle(0x%04x)\n", ioc->name, raid_device->handle);
1949         /*
1950          * WARPDRIVE: Though the following fields are not used for direct IO,
1951          * stored for future purpose:
1952          */
1953         raid_device->max_lba = le64_to_cpu(vol_pg0->MaxLBA);
1954         raid_device->stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
1955         raid_device->block_sz = le16_to_cpu(vol_pg0->BlockSize);
1956 
1957 
1958         kfree(vol_pg0);
1959         return;
1960 
1961 out_error:
1962         raid_device->direct_io_enabled = 0;
1963         for (count = 0; count < num_pds; count++)
1964                 raid_device->pd_handle[count] = 0;
1965         kfree(vol_pg0);
1966         return;
1967 }
1968 
1969 /**
1970  * _scsih_enable_tlr - setting TLR flags
1971  * @ioc: per adapter object
1972  * @sdev: scsi device struct
1973  *
1974  * Enabling Transaction Layer Retries for tape devices when
1975  * vpd page 0x90 is present
1976  *
1977  */
1978 static void
1979 _scsih_enable_tlr(struct MPT2SAS_ADAPTER *ioc, struct scsi_device *sdev)
1980 {
1981         /* only for TAPE */
1982         if (sdev->type != TYPE_TAPE)
1983                 return;
1984 
1985         if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
1986                 return;
1987 
1988         sas_enable_tlr(sdev);
1989         sdev_printk(KERN_INFO, sdev, "TLR %s\n",
1990             sas_is_tlr_enabled(sdev) ? "Enabled" : "Disabled");
1991         return;
1992 
1993 }
1994 
1995 /**
1996  * _scsih_slave_configure - device configure routine.
1997  * @sdev: scsi device struct
1998  *
1999  * Returns 0 if ok. Any other return is assumed to be an error and
2000  * the device is ignored.
2001  */
2002 static int
2003 _scsih_slave_configure(struct scsi_device *sdev)
2004 {
2005         struct Scsi_Host *shost = sdev->host;
2006         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2007         struct MPT2SAS_DEVICE *sas_device_priv_data;
2008         struct MPT2SAS_TARGET *sas_target_priv_data;
2009         struct _sas_device *sas_device;
2010         struct _raid_device *raid_device;
2011         unsigned long flags;
2012         int qdepth;
2013         u8 ssp_target = 0;
2014         char *ds = "";
2015         char *r_level = "";
2016         u16 handle, volume_handle = 0;
2017         u64 volume_wwid = 0;
2018 
2019         qdepth = 1;
2020         sas_device_priv_data = sdev->hostdata;
2021         sas_device_priv_data->configured_lun = 1;
2022         sas_device_priv_data->flags &= ~MPT_DEVICE_FLAGS_INIT;
2023         sas_target_priv_data = sas_device_priv_data->sas_target;
2024         handle = sas_target_priv_data->handle;
2025 
2026         /* raid volume handling */
2027         if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME) {
2028 
2029                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
2030                 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
2031                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
2032                 if (!raid_device) {
2033                         dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
2034                             "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
2035                             __LINE__, __func__));
2036                         return 1;
2037                 }
2038 
2039                 if (_scsih_get_volume_capabilities(ioc, raid_device)) {
2040                         dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
2041                             "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
2042                             __LINE__, __func__));
2043                         return 1;
2044                 }
2045                 /*
2046                  * WARPDRIVE: Initialize the required data for Direct IO
2047                  */
2048                 _scsih_init_warpdrive_properties(ioc, raid_device);
2049 
2050                 /* RAID Queue Depth Support
2051                  * IS volume = underlying qdepth of drive type, either
2052                  *    MPT2SAS_SAS_QUEUE_DEPTH or MPT2SAS_SATA_QUEUE_DEPTH
2053                  * IM/IME/R10 = 128 (MPT2SAS_RAID_QUEUE_DEPTH)
2054                  */
2055                 if (raid_device->device_info &
2056                     MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
2057                         qdepth = MPT2SAS_SAS_QUEUE_DEPTH;
2058                         ds = "SSP";
2059                 } else {
2060                         qdepth = MPT2SAS_SATA_QUEUE_DEPTH;
2061                          if (raid_device->device_info &
2062                             MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
2063                                 ds = "SATA";
2064                         else
2065                                 ds = "STP";
2066                 }
2067 
2068                 switch (raid_device->volume_type) {
2069                 case MPI2_RAID_VOL_TYPE_RAID0:
2070                         r_level = "RAID0";
2071                         break;
2072                 case MPI2_RAID_VOL_TYPE_RAID1E:
2073                         qdepth = MPT2SAS_RAID_QUEUE_DEPTH;
2074                         if (ioc->manu_pg10.OEMIdentifier &&
2075                             (le32_to_cpu(ioc->manu_pg10.GenericFlags0) &
2076                             MFG10_GF0_R10_DISPLAY) &&
2077                             !(raid_device->num_pds % 2))
2078                                 r_level = "RAID10";
2079                         else
2080                                 r_level = "RAID1E";
2081                         break;
2082                 case MPI2_RAID_VOL_TYPE_RAID1:
2083                         qdepth = MPT2SAS_RAID_QUEUE_DEPTH;
2084                         r_level = "RAID1";
2085                         break;
2086                 case MPI2_RAID_VOL_TYPE_RAID10:
2087                         qdepth = MPT2SAS_RAID_QUEUE_DEPTH;
2088                         r_level = "RAID10";
2089                         break;
2090                 case MPI2_RAID_VOL_TYPE_UNKNOWN:
2091                 default:
2092                         qdepth = MPT2SAS_RAID_QUEUE_DEPTH;
2093                         r_level = "RAIDX";
2094                         break;
2095                 }
2096 
2097                 if (!ioc->hide_ir_msg)
2098                         sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), "
2099                             "wwid(0x%016llx), pd_count(%d), type(%s)\n",
2100                             r_level, raid_device->handle,
2101                             (unsigned long long)raid_device->wwid,
2102                             raid_device->num_pds, ds);
2103                 _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
2104                 /* raid transport support */
2105                 if (!ioc->is_warpdrive)
2106                         _scsih_set_level(sdev, raid_device->volume_type);
2107                 return 0;
2108         }
2109 
2110         /* non-raid handling */
2111         if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
2112                 if (mpt2sas_config_get_volume_handle(ioc, handle,
2113                     &volume_handle)) {
2114                         dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
2115                             "failure at %s:%d/%s()!\n", ioc->name,
2116                             __FILE__, __LINE__, __func__));
2117                         return 1;
2118                 }
2119                 if (volume_handle && mpt2sas_config_get_volume_wwid(ioc,
2120                     volume_handle, &volume_wwid)) {
2121                         dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
2122                             "failure at %s:%d/%s()!\n", ioc->name,
2123                             __FILE__, __LINE__, __func__));
2124                         return 1;
2125                 }
2126         }
2127 
2128         spin_lock_irqsave(&ioc->sas_device_lock, flags);
2129         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
2130            sas_device_priv_data->sas_target->sas_address);
2131         if (!sas_device) {
2132                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2133                 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
2134                         "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
2135                         __LINE__, __func__));
2136                 return 1;
2137         }
2138         sas_device->volume_handle = volume_handle;
2139         sas_device->volume_wwid = volume_wwid;
2140         if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
2141                 qdepth = MPT2SAS_SAS_QUEUE_DEPTH;
2142                 ssp_target = 1;
2143                 ds = "SSP";
2144         } else {
2145                 qdepth = MPT2SAS_SATA_QUEUE_DEPTH;
2146                 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET)
2147                         ds = "STP";
2148                 else if (sas_device->device_info &
2149                     MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
2150                         ds = "SATA";
2151         }
2152         sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), "
2153             "sas_addr(0x%016llx), phy(%d), device_name(0x%016llx)\n",
2154             ds, sas_device->handle,
2155             (unsigned long long)sas_device->sas_address,
2156             sas_device->phy,
2157             (unsigned long long)sas_device->device_name);
2158         sdev_printk(KERN_INFO, sdev, "%s: "
2159             "enclosure_logical_id(0x%016llx), slot(%d)\n", ds,
2160             (unsigned long long) sas_device->enclosure_logical_id,
2161             sas_device->slot);
2162 
2163         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2164         if (!ssp_target)
2165                 _scsih_display_sata_capabilities(ioc, handle, sdev);
2166 
2167 
2168         _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
2169 
2170         if (ssp_target) {
2171                 sas_read_port_mode_page(sdev);
2172                 _scsih_enable_tlr(ioc, sdev);
2173         }
2174         return 0;
2175 }
2176 
2177 /**
2178  * _scsih_bios_param - fetch head, sector, cylinder info for a disk
2179  * @sdev: scsi device struct
2180  * @bdev: pointer to block device context
2181  * @capacity: device size (in 512 byte sectors)
2182  * @params: three element array to place output:
2183  *              params[0] number of heads (max 255)
2184  *              params[1] number of sectors (max 63)
2185  *              params[2] number of cylinders
2186  *
2187  * Return nothing.
2188  */
2189 static int
2190 _scsih_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2191     sector_t capacity, int params[])
2192 {
2193         int             heads;
2194         int             sectors;
2195         sector_t        cylinders;
2196         ulong           dummy;
2197 
2198         heads = 64;
2199         sectors = 32;
2200 
2201         dummy = heads * sectors;
2202         cylinders = capacity;
2203         sector_div(cylinders, dummy);
2204 
2205         /*
2206          * Handle extended translation size for logical drives
2207          * > 1Gb
2208          */
2209         if ((ulong)capacity >= 0x200000) {
2210                 heads = 255;
2211                 sectors = 63;
2212                 dummy = heads * sectors;
2213                 cylinders = capacity;
2214                 sector_div(cylinders, dummy);
2215         }
2216 
2217         /* return result */
2218         params[0] = heads;
2219         params[1] = sectors;
2220         params[2] = cylinders;
2221 
2222         return 0;
2223 }
2224 
2225 /**
2226  * _scsih_response_code - translation of device response code
2227  * @ioc: per adapter object
2228  * @response_code: response code returned by the device
2229  *
2230  * Return nothing.
2231  */
2232 static void
2233 _scsih_response_code(struct MPT2SAS_ADAPTER *ioc, u8 response_code)
2234 {
2235         char *desc;
2236 
2237         switch (response_code) {
2238         case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE:
2239                 desc = "task management request completed";
2240                 break;
2241         case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME:
2242                 desc = "invalid frame";
2243                 break;
2244         case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
2245                 desc = "task management request not supported";
2246                 break;
2247         case MPI2_SCSITASKMGMT_RSP_TM_FAILED:
2248                 desc = "task management request failed";
2249                 break;
2250         case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED:
2251                 desc = "task management request succeeded";
2252                 break;
2253         case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN:
2254                 desc = "invalid lun";
2255                 break;
2256         case 0xA:
2257                 desc = "overlapped tag attempted";
2258                 break;
2259         case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
2260                 desc = "task queued, however not sent to target";
2261                 break;
2262         default:
2263                 desc = "unknown";
2264                 break;
2265         }
2266         printk(MPT2SAS_WARN_FMT "response_code(0x%01x): %s\n",
2267                 ioc->name, response_code, desc);
2268 }
2269 
2270 /**
2271  * _scsih_tm_done - tm completion routine
2272  * @ioc: per adapter object
2273  * @smid: system request message index
2274  * @msix_index: MSIX table index supplied by the OS
2275  * @reply: reply message frame(lower 32bit addr)
2276  * Context: none.
2277  *
2278  * The callback handler when using scsih_issue_tm.
2279  *
2280  * Return 1 meaning mf should be freed from _base_interrupt
2281  *        0 means the mf is freed from this function.
2282  */
2283 static u8
2284 _scsih_tm_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
2285 {
2286         MPI2DefaultReply_t *mpi_reply;
2287 
2288         if (ioc->tm_cmds.status == MPT2_CMD_NOT_USED)
2289                 return 1;
2290         if (ioc->tm_cmds.smid != smid)
2291                 return 1;
2292         mpt2sas_base_flush_reply_queues(ioc);
2293         ioc->tm_cmds.status |= MPT2_CMD_COMPLETE;
2294         mpi_reply =  mpt2sas_base_get_reply_virt_addr(ioc, reply);
2295         if (mpi_reply) {
2296                 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
2297                 ioc->tm_cmds.status |= MPT2_CMD_REPLY_VALID;
2298         }
2299         ioc->tm_cmds.status &= ~MPT2_CMD_PENDING;
2300         complete(&ioc->tm_cmds.done);
2301         return 1;
2302 }
2303 
2304 /**
2305  * mpt2sas_scsih_set_tm_flag - set per target tm_busy
2306  * @ioc: per adapter object
2307  * @handle: device handle
2308  *
2309  * During taskmangement request, we need to freeze the device queue.
2310  */
2311 void
2312 mpt2sas_scsih_set_tm_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle)
2313 {
2314         struct MPT2SAS_DEVICE *sas_device_priv_data;
2315         struct scsi_device *sdev;
2316         u8 skip = 0;
2317 
2318         shost_for_each_device(sdev, ioc->shost) {
2319                 if (skip)
2320                         continue;
2321                 sas_device_priv_data = sdev->hostdata;
2322                 if (!sas_device_priv_data)
2323                         continue;
2324                 if (sas_device_priv_data->sas_target->handle == handle) {
2325                         sas_device_priv_data->sas_target->tm_busy = 1;
2326                         skip = 1;
2327                         ioc->ignore_loginfos = 1;
2328                 }
2329         }
2330 }
2331 
2332 /**
2333  * mpt2sas_scsih_clear_tm_flag - clear per target tm_busy
2334  * @ioc: per adapter object
2335  * @handle: device handle
2336  *
2337  * During taskmangement request, we need to freeze the device queue.
2338  */
2339 void
2340 mpt2sas_scsih_clear_tm_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle)
2341 {
2342         struct MPT2SAS_DEVICE *sas_device_priv_data;
2343         struct scsi_device *sdev;
2344         u8 skip = 0;
2345 
2346         shost_for_each_device(sdev, ioc->shost) {
2347                 if (skip)
2348                         continue;
2349                 sas_device_priv_data = sdev->hostdata;
2350                 if (!sas_device_priv_data)
2351                         continue;
2352                 if (sas_device_priv_data->sas_target->handle == handle) {
2353                         sas_device_priv_data->sas_target->tm_busy = 0;
2354                         skip = 1;
2355                         ioc->ignore_loginfos = 0;
2356                 }
2357         }
2358 }
2359 
2360 
2361 /**
2362  * mpt2sas_scsih_issue_tm - main routine for sending tm requests
2363  * @ioc: per adapter struct
2364  * @device_handle: device handle
2365  * @channel: the channel assigned by the OS
2366  * @id: the id assigned by the OS
2367  * @lun: lun number
2368  * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in mpi2_init.h)
2369  * @smid_task: smid assigned to the task
2370  * @timeout: timeout in seconds
2371  * @serial_number: the serial_number from scmd
2372  * @m_type: TM_MUTEX_ON or TM_MUTEX_OFF
2373  * Context: user
2374  *
2375  * A generic API for sending task management requests to firmware.
2376  *
2377  * The callback index is set inside `ioc->tm_cb_idx`.
2378  *
2379  * Return SUCCESS or FAILED.
2380  */
2381 int
2382 mpt2sas_scsih_issue_tm(struct MPT2SAS_ADAPTER *ioc, u16 handle, uint channel,
2383     uint id, uint lun, u8 type, u16 smid_task, ulong timeout,
2384         unsigned long serial_number, enum mutex_type m_type)
2385 {
2386         Mpi2SCSITaskManagementRequest_t *mpi_request;
2387         Mpi2SCSITaskManagementReply_t *mpi_reply;
2388         u16 smid = 0;
2389         u32 ioc_state;
2390         unsigned long timeleft;
2391         struct scsiio_tracker *scsi_lookup = NULL;
2392         int rc;
2393 
2394         if (m_type == TM_MUTEX_ON)
2395                 mutex_lock(&ioc->tm_cmds.mutex);
2396         if (ioc->tm_cmds.status != MPT2_CMD_NOT_USED) {
2397                 printk(MPT2SAS_INFO_FMT "%s: tm_cmd busy!!!\n",
2398                     __func__, ioc->name);
2399                 rc = FAILED;
2400                 goto err_out;
2401         }
2402 
2403         if (ioc->shost_recovery || ioc->remove_host ||
2404             ioc->pci_error_recovery) {
2405                 printk(MPT2SAS_INFO_FMT "%s: host reset in progress!\n",
2406                     __func__, ioc->name);
2407                 rc = FAILED;
2408                 goto err_out;
2409         }
2410 
2411         ioc_state = mpt2sas_base_get_iocstate(ioc, 0);
2412         if (ioc_state & MPI2_DOORBELL_USED) {
2413                 dhsprintk(ioc, printk(MPT2SAS_INFO_FMT "unexpected doorbell "
2414                     "active!\n", ioc->name));
2415                 rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2416                     FORCE_BIG_HAMMER);
2417                 rc = (!rc) ? SUCCESS : FAILED;
2418                 goto err_out;
2419         }
2420 
2421         if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) {
2422                 mpt2sas_base_fault_info(ioc, ioc_state &
2423                     MPI2_DOORBELL_DATA_MASK);
2424                 rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2425                     FORCE_BIG_HAMMER);
2426                 rc = (!rc) ? SUCCESS : FAILED;
2427                 goto err_out;
2428         }
2429 
2430         smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
2431         if (!smid) {
2432                 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
2433                     ioc->name, __func__);
2434                 rc = FAILED;
2435                 goto err_out;
2436         }
2437 
2438         if (type == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
2439                 scsi_lookup = &ioc->scsi_lookup[smid_task - 1];
2440 
2441         dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "sending tm: handle(0x%04x),"
2442             " task_type(0x%02x), smid(%d)\n", ioc->name, handle, type,
2443             smid_task));
2444         ioc->tm_cmds.status = MPT2_CMD_PENDING;
2445         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
2446         ioc->tm_cmds.smid = smid;
2447         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
2448         memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t));
2449         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
2450         mpi_request->DevHandle = cpu_to_le16(handle);
2451         mpi_request->TaskType = type;
2452         mpi_request->TaskMID = cpu_to_le16(smid_task);
2453         int_to_scsilun(lun, (struct scsi_lun *)mpi_request->LUN);
2454         mpt2sas_scsih_set_tm_flag(ioc, handle);
2455         init_completion(&ioc->tm_cmds.done);
2456         mpt2sas_base_put_smid_hi_priority(ioc, smid);
2457         timeleft = wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
2458         if (!(ioc->tm_cmds.status & MPT2_CMD_COMPLETE)) {
2459                 printk(MPT2SAS_ERR_FMT "%s: timeout\n",
2460                     ioc->name, __func__);
2461                 _debug_dump_mf(mpi_request,
2462                     sizeof(Mpi2SCSITaskManagementRequest_t)/4);
2463                 if (!(ioc->tm_cmds.status & MPT2_CMD_RESET)) {
2464                         rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2465                             FORCE_BIG_HAMMER);
2466                         rc = (!rc) ? SUCCESS : FAILED;
2467                         ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
2468                         mpt2sas_scsih_clear_tm_flag(ioc, handle);
2469                         goto err_out;
2470                 }
2471         }
2472 
2473         if (ioc->tm_cmds.status & MPT2_CMD_REPLY_VALID) {
2474                 mpi_reply = ioc->tm_cmds.reply;
2475                 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "complete tm: "
2476                     "ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
2477                     ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
2478                     le32_to_cpu(mpi_reply->IOCLogInfo),
2479                     le32_to_cpu(mpi_reply->TerminationCount)));
2480                 if (ioc->logging_level & MPT_DEBUG_TM) {
2481                         _scsih_response_code(ioc, mpi_reply->ResponseCode);
2482                         if (mpi_reply->IOCStatus)
2483                                 _debug_dump_mf(mpi_request,
2484                                     sizeof(Mpi2SCSITaskManagementRequest_t)/4);
2485                 }
2486         }
2487 
2488         switch (type) {
2489         case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
2490                 rc = SUCCESS;
2491                 if (scsi_lookup->scmd == NULL)
2492                         break;
2493                 rc = FAILED;
2494                 break;
2495 
2496         case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
2497                 if (_scsih_scsi_lookup_find_by_target(ioc, id, channel))
2498                         rc = FAILED;
2499                 else
2500                         rc = SUCCESS;
2501                 break;
2502 
2503         case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
2504         case MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET:
2505                 if (_scsih_scsi_lookup_find_by_lun(ioc, id, lun, channel))
2506                         rc = FAILED;
2507                 else
2508                         rc = SUCCESS;
2509                 break;
2510         case MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK:
2511                 rc = SUCCESS;
2512                 break;
2513         default:
2514                 rc = FAILED;
2515                 break;
2516         }
2517 
2518         mpt2sas_scsih_clear_tm_flag(ioc, handle);
2519         ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
2520         if (m_type == TM_MUTEX_ON)
2521                 mutex_unlock(&ioc->tm_cmds.mutex);
2522 
2523         return rc;
2524 
2525  err_out:
2526         if (m_type == TM_MUTEX_ON)
2527                 mutex_unlock(&ioc->tm_cmds.mutex);
2528         return rc;
2529 }
2530 
2531 /**
2532  * _scsih_tm_display_info - displays info about the device
2533  * @ioc: per adapter struct
2534  * @scmd: pointer to scsi command object
2535  *
2536  * Called by task management callback handlers.
2537  */
2538 static void
2539 _scsih_tm_display_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
2540 {
2541         struct scsi_target *starget = scmd->device->sdev_target;
2542         struct MPT2SAS_TARGET *priv_target = starget->hostdata;
2543         struct _sas_device *sas_device = NULL;
2544         unsigned long flags;
2545         char *device_str = NULL;
2546 
2547         if (!priv_target)
2548                 return;
2549         if (ioc->hide_ir_msg)
2550                 device_str = "WarpDrive";
2551         else
2552                 device_str = "volume";
2553 
2554         scsi_print_command(scmd);
2555         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2556                 starget_printk(KERN_INFO, starget, "%s handle(0x%04x), "
2557                     "%s wwid(0x%016llx)\n", device_str, priv_target->handle,
2558                     device_str, (unsigned long long)priv_target->sas_address);
2559         } else {
2560                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2561                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
2562                     priv_target->sas_address);
2563                 if (sas_device) {
2564                         if (priv_target->flags &
2565                             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2566                                 starget_printk(KERN_INFO, starget,
2567                                     "volume handle(0x%04x), "
2568                                     "volume wwid(0x%016llx)\n",
2569                                     sas_device->volume_handle,
2570                                    (unsigned long long)sas_device->volume_wwid);
2571                         }
2572                         starget_printk(KERN_INFO, starget,
2573                             "handle(0x%04x), sas_address(0x%016llx), phy(%d)\n",
2574                             sas_device->handle,
2575                             (unsigned long long)sas_device->sas_address,
2576                             sas_device->phy);
2577                         starget_printk(KERN_INFO, starget,
2578                             "enclosure_logical_id(0x%016llx), slot(%d)\n",
2579                            (unsigned long long)sas_device->enclosure_logical_id,
2580                             sas_device->slot);
2581                 }
2582                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2583         }
2584 }
2585 
2586 /**
2587  * _scsih_abort - eh threads main abort routine
2588  * @scmd: pointer to scsi command object
2589  *
2590  * Returns SUCCESS if command aborted else FAILED
2591  */
2592 static int
2593 _scsih_abort(struct scsi_cmnd *scmd)
2594 {
2595         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2596         struct MPT2SAS_DEVICE *sas_device_priv_data;
2597         u16 smid;
2598         u16 handle;
2599         int r;
2600 
2601         sdev_printk(KERN_INFO, scmd->device, "attempting task abort! "
2602             "scmd(%p)\n", scmd);
2603         _scsih_tm_display_info(ioc, scmd);
2604 
2605         sas_device_priv_data = scmd->device->hostdata;
2606         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2607                 sdev_printk(KERN_INFO, scmd->device, "device been deleted! "
2608                     "scmd(%p)\n", scmd);
2609                 scmd->result = DID_NO_CONNECT << 16;
2610                 scmd->scsi_done(scmd);
2611                 r = SUCCESS;
2612                 goto out;
2613         }
2614 
2615         /* search for the command */
2616         smid = _scsih_scsi_lookup_find_by_scmd(ioc, scmd);
2617         if (!smid) {
2618                 scmd->result = DID_RESET << 16;
2619                 r = SUCCESS;
2620                 goto out;
2621         }
2622 
2623         /* for hidden raid components and volumes this is not supported */
2624         if (sas_device_priv_data->sas_target->flags &
2625             MPT_TARGET_FLAGS_RAID_COMPONENT ||
2626             sas_device_priv_data->sas_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2627                 scmd->result = DID_RESET << 16;
2628                 r = FAILED;
2629                 goto out;
2630         }
2631 
2632         mpt2sas_halt_firmware(ioc);
2633 
2634         handle = sas_device_priv_data->sas_target->handle;
2635         r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2636             scmd->device->id, scmd->device->lun,
2637             MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30,
2638             scmd->serial_number, TM_MUTEX_ON);
2639 
2640  out:
2641         sdev_printk(KERN_INFO, scmd->device, "task abort: %s scmd(%p)\n",
2642             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2643         return r;
2644 }
2645 
2646 /**
2647  * _scsih_dev_reset - eh threads main device reset routine
2648  * @scmd: pointer to scsi command object
2649  *
2650  * Returns SUCCESS if command aborted else FAILED
2651  */
2652 static int
2653 _scsih_dev_reset(struct scsi_cmnd *scmd)
2654 {
2655         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2656         struct MPT2SAS_DEVICE *sas_device_priv_data;
2657         struct _sas_device *sas_device;
2658         unsigned long flags;
2659         u16     handle;
2660         int r;
2661 
2662         struct scsi_target *starget = scmd->device->sdev_target;
2663 
2664         starget_printk(KERN_INFO, starget, "attempting device reset! "
2665             "scmd(%p)\n", scmd);
2666         _scsih_tm_display_info(ioc, scmd);
2667 
2668         sas_device_priv_data = scmd->device->hostdata;
2669         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2670                 starget_printk(KERN_INFO, starget, "device been deleted! "
2671                     "scmd(%p)\n", scmd);
2672                 scmd->result = DID_NO_CONNECT << 16;
2673                 scmd->scsi_done(scmd);
2674                 r = SUCCESS;
2675                 goto out;
2676         }
2677 
2678         /* for hidden raid components obtain the volume_handle */
2679         handle = 0;
2680         if (sas_device_priv_data->sas_target->flags &
2681             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2682                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2683                 sas_device = _scsih_sas_device_find_by_handle(ioc,
2684                    sas_device_priv_data->sas_target->handle);
2685                 if (sas_device)
2686                         handle = sas_device->volume_handle;
2687                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2688         } else
2689                 handle = sas_device_priv_data->sas_target->handle;
2690 
2691         if (!handle) {
2692                 scmd->result = DID_RESET << 16;
2693                 r = FAILED;
2694                 goto out;
2695         }
2696 
2697         r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2698             scmd->device->id, scmd->device->lun,
2699             MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, 0, 30, 0,
2700             TM_MUTEX_ON);
2701 
2702  out:
2703         sdev_printk(KERN_INFO, scmd->device, "device reset: %s scmd(%p)\n",
2704             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2705         return r;
2706 }
2707 
2708 /**
2709  * _scsih_target_reset - eh threads main target reset routine
2710  * @scmd: pointer to scsi command object
2711  *
2712  * Returns SUCCESS if command aborted else FAILED
2713  */
2714 static int
2715 _scsih_target_reset(struct scsi_cmnd *scmd)
2716 {
2717         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2718         struct MPT2SAS_DEVICE *sas_device_priv_data;
2719         struct _sas_device *sas_device;
2720         unsigned long flags;
2721         u16     handle;
2722         int r;
2723         struct scsi_target *starget = scmd->device->sdev_target;
2724 
2725         starget_printk(KERN_INFO, starget, "attempting target reset! "
2726             "scmd(%p)\n", scmd);
2727         _scsih_tm_display_info(ioc, scmd);
2728 
2729         sas_device_priv_data = scmd->device->hostdata;
2730         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2731                 starget_printk(KERN_INFO, starget, "target been deleted! "
2732                     "scmd(%p)\n", scmd);
2733                 scmd->result = DID_NO_CONNECT << 16;
2734                 scmd->scsi_done(scmd);
2735                 r = SUCCESS;
2736                 goto out;
2737         }
2738 
2739         /* for hidden raid components obtain the volume_handle */
2740         handle = 0;
2741         if (sas_device_priv_data->sas_target->flags &
2742             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2743                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2744                 sas_device = _scsih_sas_device_find_by_handle(ioc,
2745                    sas_device_priv_data->sas_target->handle);
2746                 if (sas_device)
2747                         handle = sas_device->volume_handle;
2748                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2749         } else
2750                 handle = sas_device_priv_data->sas_target->handle;
2751 
2752         if (!handle) {
2753                 scmd->result = DID_RESET << 16;
2754                 r = FAILED;
2755                 goto out;
2756         }
2757 
2758         r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2759             scmd->device->id, 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0,
2760             30, 0, TM_MUTEX_ON);
2761 
2762  out:
2763         starget_printk(KERN_INFO, starget, "target reset: %s scmd(%p)\n",
2764             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2765         return r;
2766 }
2767 
2768 /**
2769  * _scsih_host_reset - eh threads main host reset routine
2770  * @scmd: pointer to scsi command object
2771  *
2772  * Returns SUCCESS if command aborted else FAILED
2773  */
2774 static int
2775 _scsih_host_reset(struct scsi_cmnd *scmd)
2776 {
2777         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2778         int r, retval;
2779 
2780         printk(MPT2SAS_INFO_FMT "attempting host reset! scmd(%p)\n",
2781             ioc->name, scmd);
2782         scsi_print_command(scmd);
2783 
2784         retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2785             FORCE_BIG_HAMMER);
2786         r = (retval < 0) ? FAILED : SUCCESS;
2787         printk(MPT2SAS_INFO_FMT "host reset: %s scmd(%p)\n",
2788             ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2789 
2790         return r;
2791 }
2792 
2793 /**
2794  * _scsih_fw_event_add - insert and queue up fw_event
2795  * @ioc: per adapter object
2796  * @fw_event: object describing the event
2797  * Context: This function will acquire ioc->fw_event_lock.
2798  *
2799  * This adds the firmware event object into link list, then queues it up to
2800  * be processed from user context.
2801  *
2802  * Return nothing.
2803  */
2804 static void
2805 _scsih_fw_event_add(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
2806 {
2807         unsigned long flags;
2808 
2809         if (ioc->firmware_event_thread == NULL)
2810                 return;
2811 
2812         spin_lock_irqsave(&ioc->fw_event_lock, flags);
2813         list_add_tail(&fw_event->list, &ioc->fw_event_list);
2814         INIT_DELAYED_WORK(&fw_event->delayed_work, _firmware_event_work);
2815         queue_delayed_work(ioc->firmware_event_thread,
2816             &fw_event->delayed_work, 0);
2817         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2818 }
2819 
2820 /**
2821  * _scsih_fw_event_free - delete fw_event
2822  * @ioc: per adapter object
2823  * @fw_event: object describing the event
2824  * Context: This function will acquire ioc->fw_event_lock.
2825  *
2826  * This removes firmware event object from link list, frees associated memory.
2827  *
2828  * Return nothing.
2829  */
2830 static void
2831 _scsih_fw_event_free(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work
2832     *fw_event)
2833 {
2834         unsigned long flags;
2835 
2836         spin_lock_irqsave(&ioc->fw_event_lock, flags);
2837         list_del(&fw_event->list);
2838         kfree(fw_event->event_data);
2839         kfree(fw_event);
2840         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2841 }
2842 
2843 
2844 /**
2845  * _scsih_error_recovery_delete_devices - remove devices not responding
2846  * @ioc: per adapter object
2847  *
2848  * Return nothing.
2849  */
2850 static void
2851 _scsih_error_recovery_delete_devices(struct MPT2SAS_ADAPTER *ioc)
2852 {
2853         struct fw_event_work *fw_event;
2854 
2855         if (ioc->is_driver_loading)
2856                 return;
2857 
2858         fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
2859         if (!fw_event)
2860                 return;
2861 
2862         fw_event->event = MPT2SAS_REMOVE_UNRESPONDING_DEVICES;
2863         fw_event->ioc = ioc;
2864         _scsih_fw_event_add(ioc, fw_event);
2865 }
2866 
2867 /**
2868  * mpt2sas_port_enable_complete - port enable completed (fake event)
2869  * @ioc: per adapter object
2870  *
2871  * Return nothing.
2872  */
2873 void
2874 mpt2sas_port_enable_complete(struct MPT2SAS_ADAPTER *ioc)
2875 {
2876         struct fw_event_work *fw_event;
2877 
2878         fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
2879         if (!fw_event)
2880                 return;
2881         fw_event->event = MPT2SAS_PORT_ENABLE_COMPLETE;
2882         fw_event->ioc = ioc;
2883         _scsih_fw_event_add(ioc, fw_event);
2884 }
2885 
2886 /**
2887  * _scsih_fw_event_cleanup_queue - cleanup event queue
2888  * @ioc: per adapter object
2889  *
2890  * Walk the firmware event queue, either killing timers, or waiting
2891  * for outstanding events to complete
2892  *
2893  * Return nothing.
2894  */
2895 static void
2896 _scsih_fw_event_cleanup_queue(struct MPT2SAS_ADAPTER *ioc)
2897 {
2898         struct fw_event_work *fw_event, *next;
2899 
2900         if (list_empty(&ioc->fw_event_list) ||
2901              !ioc->firmware_event_thread || in_interrupt())
2902                 return;
2903 
2904         list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
2905                 if (cancel_delayed_work(&fw_event->delayed_work)) {
2906                         _scsih_fw_event_free(ioc, fw_event);
2907                         continue;
2908                 }
2909                 fw_event->cancel_pending_work = 1;
2910         }
2911 }
2912 
2913 /**
2914  * _scsih_ublock_io_all_device - unblock every device
2915  * @ioc: per adapter object
2916  *
2917  * change the device state from block to running
2918  */
2919 static void
2920 _scsih_ublock_io_all_device(struct MPT2SAS_ADAPTER *ioc)
2921 {
2922         struct MPT2SAS_DEVICE *sas_device_priv_data;
2923         struct scsi_device *sdev;
2924 
2925         shost_for_each_device(sdev, ioc->shost) {
2926                 sas_device_priv_data = sdev->hostdata;
2927                 if (!sas_device_priv_data)
2928                         continue;
2929                 if (!sas_device_priv_data->block)
2930                         continue;
2931                 sas_device_priv_data->block = 0;
2932                 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev, "device_running, "
2933                     "handle(0x%04x)\n",
2934                     sas_device_priv_data->sas_target->handle));
2935                 scsi_internal_device_unblock(sdev, SDEV_RUNNING);
2936         }
2937 }
2938 /**
2939  * _scsih_ublock_io_device - set the device state to SDEV_RUNNING
2940  * @ioc: per adapter object
2941  * @handle: device handle
2942  *
2943  * During device pull we need to appropiately set the sdev state.
2944  */
2945 static void
2946 _scsih_ublock_io_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
2947 {
2948         struct MPT2SAS_DEVICE *sas_device_priv_data;
2949         struct scsi_device *sdev;
2950 
2951         shost_for_each_device(sdev, ioc->shost) {
2952                 sas_device_priv_data = sdev->hostdata;
2953                 if (!sas_device_priv_data)
2954                         continue;
2955                 if (!sas_device_priv_data->block)
2956                         continue;
2957                 if (sas_device_priv_data->sas_target->sas_address ==
2958                                                                 sas_address) {
2959                         dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
2960                             MPT2SAS_INFO_FMT "SDEV_RUNNING: "
2961                             "sas address(0x%016llx)\n", ioc->name,
2962                                 (unsigned long long)sas_address));
2963                         sas_device_priv_data->block = 0;
2964                         scsi_internal_device_unblock(sdev, SDEV_RUNNING);
2965                 }
2966         }
2967 }
2968 
2969 /**
2970  * _scsih_block_io_all_device - set the device state to SDEV_BLOCK
2971  * @ioc: per adapter object
2972  * @handle: device handle
2973  *
2974  * During device pull we need to appropiately set the sdev state.
2975  */
2976 static void
2977 _scsih_block_io_all_device(struct MPT2SAS_ADAPTER *ioc)
2978 {
2979         struct MPT2SAS_DEVICE *sas_device_priv_data;
2980         struct scsi_device *sdev;
2981 
2982         shost_for_each_device(sdev, ioc->shost) {
2983                 sas_device_priv_data = sdev->hostdata;
2984                 if (!sas_device_priv_data)
2985                         continue;
2986                 if (sas_device_priv_data->block)
2987                         continue;
2988                 sas_device_priv_data->block = 1;
2989                 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev, "device_blocked, "
2990                     "handle(0x%04x)\n",
2991                     sas_device_priv_data->sas_target->handle));
2992                 scsi_internal_device_block(sdev);
2993         }
2994 }
2995 
2996 
2997 /**
2998  * _scsih_block_io_device - set the device state to SDEV_BLOCK
2999  * @ioc: per adapter object
3000  * @handle: device handle
3001  *
3002  * During device pull we need to appropiately set the sdev state.
3003  */
3004 static void
3005 _scsih_block_io_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3006 {
3007         struct MPT2SAS_DEVICE *sas_device_priv_data;
3008         struct scsi_device *sdev;
3009 
3010         shost_for_each_device(sdev, ioc->shost) {
3011                 sas_device_priv_data = sdev->hostdata;
3012                 if (!sas_device_priv_data)
3013                         continue;
3014                 if (sas_device_priv_data->block)
3015                         continue;
3016                 if (sas_device_priv_data->sas_target->handle == handle) {
3017                         dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
3018                             MPT2SAS_INFO_FMT "SDEV_BLOCK: "
3019                             "handle(0x%04x)\n", ioc->name, handle));
3020                         sas_device_priv_data->block = 1;
3021                         scsi_internal_device_block(sdev);
3022                 }
3023         }
3024 }
3025 
3026 /**
3027  * _scsih_block_io_to_children_attached_to_ex
3028  * @ioc: per adapter object
3029  * @sas_expander: the sas_device object
3030  *
3031  * This routine set sdev state to SDEV_BLOCK for all devices
3032  * attached to this expander. This function called when expander is
3033  * pulled.
3034  */
3035 static void
3036 _scsih_block_io_to_children_attached_to_ex(struct MPT2SAS_ADAPTER *ioc,
3037     struct _sas_node *sas_expander)
3038 {
3039         struct _sas_port *mpt2sas_port;
3040         struct _sas_device *sas_device;
3041         struct _sas_node *expander_sibling;
3042         unsigned long flags;
3043 
3044         if (!sas_expander)
3045                 return;
3046 
3047         list_for_each_entry(mpt2sas_port,
3048            &sas_expander->sas_port_list, port_list) {
3049                 if (mpt2sas_port->remote_identify.device_type ==
3050                     SAS_END_DEVICE) {
3051                         spin_lock_irqsave(&ioc->sas_device_lock, flags);
3052                         sas_device =
3053                             mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
3054                            mpt2sas_port->remote_identify.sas_address);
3055                         if (sas_device)
3056                                 set_bit(sas_device->handle,
3057                                     ioc->blocking_handles);
3058                         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3059                 }
3060         }
3061 
3062         list_for_each_entry(mpt2sas_port,
3063            &sas_expander->sas_port_list, port_list) {
3064 
3065                 if (mpt2sas_port->remote_identify.device_type ==
3066                     SAS_EDGE_EXPANDER_DEVICE ||
3067                     mpt2sas_port->remote_identify.device_type ==
3068                     SAS_FANOUT_EXPANDER_DEVICE) {
3069                         expander_sibling =
3070                             mpt2sas_scsih_expander_find_by_sas_address(
3071                             ioc, mpt2sas_port->remote_identify.sas_address);
3072                         _scsih_block_io_to_children_attached_to_ex(ioc,
3073                             expander_sibling);
3074                 }
3075         }
3076 }
3077 
3078 /**
3079  * _scsih_block_io_to_children_attached_directly
3080  * @ioc: per adapter object
3081  * @event_data: topology change event data
3082  *
3083  * This routine set sdev state to SDEV_BLOCK for all devices
3084  * direct attached during device pull.
3085  */
3086 static void
3087 _scsih_block_io_to_children_attached_directly(struct MPT2SAS_ADAPTER *ioc,
3088     Mpi2EventDataSasTopologyChangeList_t *event_data)
3089 {
3090         int i;
3091         u16 handle;
3092         u16 reason_code;
3093         u8 phy_number;
3094 
3095         for (i = 0; i < event_data->NumEntries; i++) {
3096                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3097                 if (!handle)
3098                         continue;
3099                 phy_number = event_data->StartPhyNum + i;
3100                 reason_code = event_data->PHY[i].PhyStatus &
3101                     MPI2_EVENT_SAS_TOPO_RC_MASK;
3102                 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING)
3103                         _scsih_block_io_device(ioc, handle);
3104         }
3105 }
3106 
3107 /**
3108  * _scsih_tm_tr_send - send task management request
3109  * @ioc: per adapter object
3110  * @handle: device handle
3111  * Context: interrupt time.
3112  *
3113  * This code is to initiate the device removal handshake protocol
3114  * with controller firmware.  This function will issue target reset
3115  * using high priority request queue.  It will send a sas iounit
3116  * control request (MPI2_SAS_OP_REMOVE_DEVICE) from this completion.
3117  *
3118  * This is designed to send muliple task management request at the same
3119  * time to the fifo. If the fifo is full, we will append the request,
3120  * and process it in a future completion.
3121  */
3122 static void
3123 _scsih_tm_tr_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3124 {
3125         Mpi2SCSITaskManagementRequest_t *mpi_request;
3126         u16 smid;
3127         struct _sas_device *sas_device;
3128         struct MPT2SAS_TARGET *sas_target_priv_data = NULL;
3129         u64 sas_address = 0;
3130         unsigned long flags;
3131         struct _tr_list *delayed_tr;
3132         u32 ioc_state;
3133 
3134         if (ioc->remove_host) {
3135                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host has been "
3136                     "removed: handle(0x%04x)\n", __func__, ioc->name, handle));
3137                 return;
3138         } else if (ioc->pci_error_recovery) {
3139                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host in pci "
3140                     "error recovery: handle(0x%04x)\n", __func__, ioc->name,
3141                     handle));
3142                 return;
3143         }
3144         ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
3145         if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
3146                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host is not "
3147                    "operational: handle(0x%04x)\n", __func__, ioc->name,
3148                    handle));
3149                 return;
3150         }
3151 
3152         /* if PD, then return */
3153         if (test_bit(handle, ioc->pd_handles))
3154                 return;
3155 
3156         spin_lock_irqsave(&ioc->sas_device_lock, flags);
3157         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
3158         if (sas_device && sas_device->starget &&
3159              sas_device->starget->hostdata) {
3160                 sas_target_priv_data = sas_device->starget->hostdata;
3161                 sas_target_priv_data->deleted = 1;
3162                 sas_address = sas_device->sas_address;
3163         }
3164         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3165 
3166         if (sas_target_priv_data) {
3167                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "setting delete flag: "
3168                 "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, handle,
3169                         (unsigned long long)sas_address));
3170                 _scsih_ublock_io_device(ioc, sas_address);
3171                 sas_target_priv_data->handle = MPT2SAS_INVALID_DEVICE_HANDLE;
3172         }
3173 
3174         smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
3175         if (!smid) {
3176                 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3177                 if (!delayed_tr)
3178                         return;
3179                 INIT_LIST_HEAD(&delayed_tr->list);
3180                 delayed_tr->handle = handle;
3181                 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3182                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3183                     "DELAYED:tr:handle(0x%04x), (open)\n",
3184                     ioc->name, handle));
3185                 return;
3186         }
3187 
3188         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "tr_send:handle(0x%04x), "
3189             "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid,
3190             ioc->tm_tr_cb_idx));
3191         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
3192         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3193         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3194         mpi_request->DevHandle = cpu_to_le16(handle);
3195         mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3196         mpt2sas_base_put_smid_hi_priority(ioc, smid);
3197 }
3198 
3199 
3200 
3201 /**
3202  * _scsih_sas_control_complete - completion routine
3203  * @ioc: per adapter object
3204  * @smid: system request message index
3205  * @msix_index: MSIX table index supplied by the OS
3206  * @reply: reply message frame(lower 32bit addr)
3207  * Context: interrupt time.
3208  *
3209  * This is the sas iounit control completion routine.
3210  * This code is part of the code to initiate the device removal
3211  * handshake protocol with controller firmware.
3212  *
3213  * Return 1 meaning mf should be freed from _base_interrupt
3214  *        0 means the mf is freed from this function.
3215  */
3216 static u8
3217 _scsih_sas_control_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
3218     u8 msix_index, u32 reply)
3219 {
3220         Mpi2SasIoUnitControlReply_t *mpi_reply =
3221             mpt2sas_base_get_reply_virt_addr(ioc, reply);
3222         if (likely(mpi_reply)) {
3223                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3224                 "sc_complete:handle(0x%04x), (open) "
3225                 "smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
3226                 ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid,
3227                 le16_to_cpu(mpi_reply->IOCStatus),
3228                 le32_to_cpu(mpi_reply->IOCLogInfo)));
3229         } else {
3230                 printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
3231                     ioc->name, __FILE__, __LINE__, __func__);
3232         }
3233         return 1;
3234 }
3235 
3236 /**
3237  * _scsih_tm_tr_volume_send - send target reset request for volumes
3238  * @ioc: per adapter object
3239  * @handle: device handle
3240  * Context: interrupt time.
3241  *
3242  * This is designed to send muliple task management request at the same
3243  * time to the fifo. If the fifo is full, we will append the request,
3244  * and process it in a future completion.
3245  */
3246 static void
3247 _scsih_tm_tr_volume_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3248 {
3249         Mpi2SCSITaskManagementRequest_t *mpi_request;
3250         u16 smid;
3251         struct _tr_list *delayed_tr;
3252 
3253         if (ioc->shost_recovery || ioc->remove_host ||
3254             ioc->pci_error_recovery) {
3255                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host reset in "
3256                    "progress!\n", __func__, ioc->name));
3257                 return;
3258         }
3259 
3260         smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
3261         if (!smid) {
3262                 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3263                 if (!delayed_tr)
3264                         return;
3265                 INIT_LIST_HEAD(&delayed_tr->list);
3266                 delayed_tr->handle = handle;
3267                 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
3268                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3269                     "DELAYED:tr:handle(0x%04x), (open)\n",
3270                     ioc->name, handle));
3271                 return;
3272         }
3273 
3274         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "tr_send:handle(0x%04x), "
3275             "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid,
3276             ioc->tm_tr_volume_cb_idx));
3277         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
3278         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3279         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3280         mpi_request->DevHandle = cpu_to_le16(handle);
3281         mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3282         mpt2sas_base_put_smid_hi_priority(ioc, smid);
3283 }
3284 
3285 /**
3286  * _scsih_tm_volume_tr_complete - target reset completion
3287  * @ioc: per adapter object
3288  * @smid: system request message index
3289  * @msix_index: MSIX table index supplied by the OS
3290  * @reply: reply message frame(lower 32bit addr)
3291  * Context: interrupt time.
3292  *
3293  * Return 1 meaning mf should be freed from _base_interrupt
3294  *        0 means the mf is freed from this function.
3295  */
3296 static u8
3297 _scsih_tm_volume_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
3298     u8 msix_index, u32 reply)
3299 {
3300         u16 handle;
3301         Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3302         Mpi2SCSITaskManagementReply_t *mpi_reply =
3303             mpt2sas_base_get_reply_virt_addr(ioc, reply);
3304 
3305         if (ioc->shost_recovery || ioc->remove_host ||
3306             ioc->pci_error_recovery) {
3307                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host reset in "
3308                    "progress!\n", __func__, ioc->name));
3309                 return 1;
3310         }
3311         if (unlikely(!mpi_reply)) {
3312                 printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
3313                     ioc->name, __FILE__, __LINE__, __func__);
3314                 return 1;
3315         }
3316         mpi_request_tm = mpt2sas_base_get_msg_frame(ioc, smid);
3317         handle = le16_to_cpu(mpi_request_tm->DevHandle);
3318         if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
3319                 dewtprintk(ioc, printk("spurious interrupt: "
3320                     "handle(0x%04x:0x%04x), smid(%d)!!!\n", handle,
3321                     le16_to_cpu(mpi_reply->DevHandle), smid));
3322                 return 0;
3323         }
3324 
3325         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3326             "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
3327             "loginfo(0x%08x), completed(%d)\n", ioc->name,
3328             handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3329             le32_to_cpu(mpi_reply->IOCLogInfo),
3330             le32_to_cpu(mpi_reply->TerminationCount)));
3331 
3332         return _scsih_check_for_pending_tm(ioc, smid);
3333 }
3334 
3335 /**
3336  * _scsih_tm_tr_complete -
3337  * @ioc: per adapter object
3338  * @smid: system request message index
3339  * @msix_index: MSIX table index supplied by the OS
3340  * @reply: reply message frame(lower 32bit addr)
3341  * Context: interrupt time.
3342  *
3343  * This is the target reset completion routine.
3344  * This code is part of the code to initiate the device removal
3345  * handshake protocol with controller firmware.
3346  * It will send a sas iounit control request (MPI2_SAS_OP_REMOVE_DEVICE)
3347  *
3348  * Return 1 meaning mf should be freed from _base_interrupt
3349  *        0 means the mf is freed from this function.
3350  */
3351 static u8
3352 _scsih_tm_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
3353     u32 reply)
3354 {
3355         u16 handle;
3356         Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3357         Mpi2SCSITaskManagementReply_t *mpi_reply =
3358             mpt2sas_base_get_reply_virt_addr(ioc, reply);
3359         Mpi2SasIoUnitControlRequest_t *mpi_request;
3360         u16 smid_sas_ctrl;
3361         u32 ioc_state;
3362 
3363         if (ioc->remove_host) {
3364                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host has been "
3365                    "removed\n", __func__, ioc->name));
3366                 return 1;
3367         } else if (ioc->pci_error_recovery) {
3368                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host in pci "
3369                     "error recovery\n", __func__, ioc->name));
3370                 return 1;
3371         }
3372         ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
3373         if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
3374                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host is not "
3375                     "operational\n", __func__, ioc->name));
3376                 return 1;
3377         }
3378         if (unlikely(!mpi_reply)) {
3379                 printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
3380                     ioc->name, __FILE__, __LINE__, __func__);
3381                 return 1;
3382         }
3383         mpi_request_tm = mpt2sas_base_get_msg_frame(ioc, smid);
3384         handle = le16_to_cpu(mpi_request_tm->DevHandle);
3385         if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
3386                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "spurious interrupt: "
3387                     "handle(0x%04x:0x%04x), smid(%d)!!!\n", ioc->name, handle,
3388                     le16_to_cpu(mpi_reply->DevHandle), smid));
3389                 return 0;
3390         }
3391 
3392         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3393             "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
3394             "loginfo(0x%08x), completed(%d)\n", ioc->name,
3395             handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3396             le32_to_cpu(mpi_reply->IOCLogInfo),
3397             le32_to_cpu(mpi_reply->TerminationCount)));
3398 
3399         smid_sas_ctrl = mpt2sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
3400         if (!smid_sas_ctrl) {
3401                 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
3402                     ioc->name, __func__);
3403                 return 1;
3404         }
3405 
3406         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "sc_send:handle(0x%04x), "
3407             "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid_sas_ctrl,
3408             ioc->tm_sas_control_cb_idx));
3409         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid_sas_ctrl);
3410         memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
3411         mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
3412         mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
3413         mpi_request->DevHandle = mpi_request_tm->DevHandle;
3414         mpt2sas_base_put_smid_default(ioc, smid_sas_ctrl);
3415 
3416         return _scsih_check_for_pending_tm(ioc, smid);
3417 }
3418 
3419 /**
3420  * _scsih_check_for_pending_tm - check for pending task management
3421  * @ioc: per adapter object
3422  * @smid: system request message index
3423  *
3424  * This will check delayed target reset list, and feed the
3425  * next reqeust.
3426  *
3427  * Return 1 meaning mf should be freed from _base_interrupt
3428  *        0 means the mf is freed from this function.
3429  */
3430 static u8
3431 _scsih_check_for_pending_tm(struct MPT2SAS_ADAPTER *ioc, u16 smid)
3432 {
3433         struct _tr_list *delayed_tr;
3434 
3435         if (!list_empty(&ioc->delayed_tr_volume_list)) {
3436                 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
3437                     struct _tr_list, list);
3438                 mpt2sas_base_free_smid(ioc, smid);
3439                 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
3440                 list_del(&delayed_tr->list);
3441                 kfree(delayed_tr);
3442                 return 0;
3443         }
3444 
3445         if (!list_empty(&ioc->delayed_tr_list)) {
3446                 delayed_tr = list_entry(ioc->delayed_tr_list.next,
3447                     struct _tr_list, list);
3448                 mpt2sas_base_free_smid(ioc, smid);
3449                 _scsih_tm_tr_send(ioc, delayed_tr->handle);
3450                 list_del(&delayed_tr->list);
3451                 kfree(delayed_tr);
3452                 return 0;
3453         }
3454 
3455         return 1;
3456 }
3457 
3458 /**
3459  * _scsih_check_topo_delete_events - sanity check on topo events
3460  * @ioc: per adapter object
3461  * @event_data: the event data payload
3462  *
3463  * This routine added to better handle cable breaker.
3464  *
3465  * This handles the case where driver receives multiple expander
3466  * add and delete events in a single shot.  When there is a delete event
3467  * the routine will void any pending add events waiting in the event queue.
3468  *
3469  * Return nothing.
3470  */
3471 static void
3472 _scsih_check_topo_delete_events(struct MPT2SAS_ADAPTER *ioc,
3473     Mpi2EventDataSasTopologyChangeList_t *event_data)
3474 {
3475         struct fw_event_work *fw_event;
3476         Mpi2EventDataSasTopologyChangeList_t *local_event_data;
3477         u16 expander_handle;
3478         struct _sas_node *sas_expander;
3479         unsigned long flags;
3480         int i, reason_code;
3481         u16 handle;
3482 
3483         for (i = 0 ; i < event_data->NumEntries; i++) {
3484                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3485                 if (!handle)
3486                         continue;
3487                 reason_code = event_data->PHY[i].PhyStatus &
3488                     MPI2_EVENT_SAS_TOPO_RC_MASK;
3489                 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)
3490                         _scsih_tm_tr_send(ioc, handle);
3491         }
3492 
3493         expander_handle = le16_to_cpu(event_data->ExpanderDevHandle);
3494         if (expander_handle < ioc->sas_hba.num_phys) {
3495                 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3496                 return;
3497         }
3498         if (event_data->ExpStatus ==
3499             MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING) {
3500                 /* put expander attached devices into blocking state */
3501                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
3502                 sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
3503                     expander_handle);
3504                 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
3505                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
3506                 do {
3507                         handle = find_first_bit(ioc->blocking_handles,
3508                             ioc->facts.MaxDevHandle);
3509                         if (handle < ioc->facts.MaxDevHandle)
3510                                 _scsih_block_io_device(ioc, handle);
3511                 } while (test_and_clear_bit(handle, ioc->blocking_handles));
3512         } else if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_RESPONDING)
3513                 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3514 
3515         if (event_data->ExpStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
3516                 return;
3517 
3518         /* mark ignore flag for pending events */
3519         spin_lock_irqsave(&ioc->fw_event_lock, flags);
3520         list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
3521                 if (fw_event->event != MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
3522                     fw_event->ignore)
3523                         continue;
3524                 local_event_data = fw_event->event_data;
3525                 if (local_event_data->ExpStatus ==
3526                     MPI2_EVENT_SAS_TOPO_ES_ADDED ||
3527                     local_event_data->ExpStatus ==
3528                     MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
3529                         if (le16_to_cpu(local_event_data->ExpanderDevHandle) ==
3530                             expander_handle) {
3531                                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3532                                     "setting ignoring flag\n", ioc->name));
3533                                 fw_event->ignore = 1;
3534                         }
3535                 }
3536         }
3537         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3538 }
3539 
3540 /**
3541  * _scsih_set_volume_delete_flag - setting volume delete flag
3542  * @ioc: per adapter object
3543  * @handle: device handle
3544  *
3545  * This
3546  * Return nothing.
3547  */
3548 static void
3549 _scsih_set_volume_delete_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3550 {
3551         struct _raid_device *raid_device;
3552         struct MPT2SAS_TARGET *sas_target_priv_data;
3553         unsigned long flags;
3554 
3555         spin_lock_irqsave(&ioc->raid_device_lock, flags);
3556         raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
3557         if (raid_device && raid_device->starget &&
3558             raid_device->starget->hostdata) {
3559                 sas_target_priv_data =
3560                     raid_device->starget->hostdata;
3561                 sas_target_priv_data->deleted = 1;
3562                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3563                     "setting delete flag: handle(0x%04x), "
3564                     "wwid(0x%016llx)\n", ioc->name, handle,
3565                     (unsigned long long) raid_device->wwid));
3566         }
3567         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
3568 }
3569 
3570 /**
3571  * _scsih_set_volume_handle_for_tr - set handle for target reset to volume
3572  * @handle: input handle
3573  * @a: handle for volume a
3574  * @b: handle for volume b
3575  *
3576  * IR firmware only supports two raid volumes.  The purpose of this
3577  * routine is to set the volume handle in either a or b. When the given
3578  * input handle is non-zero, or when a and b have not been set before.
3579  */
3580 static void
3581 _scsih_set_volume_handle_for_tr(u16 handle, u16 *a, u16 *b)
3582 {
3583         if (!handle || handle == *a || handle == *b)
3584                 return;
3585         if (!*a)
3586                 *a = handle;
3587         else if (!*b)
3588                 *b = handle;
3589 }
3590 
3591 /**
3592  * _scsih_check_ir_config_unhide_events - check for UNHIDE events
3593  * @ioc: per adapter object
3594  * @event_data: the event data payload
3595  * Context: interrupt time.
3596  *
3597  * This routine will send target reset to volume, followed by target
3598  * resets to the PDs. This is called when a PD has been removed, or
3599  * volume has been deleted or removed. When the target reset is sent
3600  * to volume, the PD target resets need to be queued to start upon
3601  * completion of the volume target reset.
3602  *
3603  * Return nothing.
3604  */
3605 static void
3606 _scsih_check_ir_config_unhide_events(struct MPT2SAS_ADAPTER *ioc,
3607     Mpi2EventDataIrConfigChangeList_t *event_data)
3608 {
3609         Mpi2EventIrConfigElement_t *element;
3610         int i;
3611         u16 handle, volume_handle, a, b;
3612         struct _tr_list *delayed_tr;
3613 
3614         a = 0;
3615         b = 0;
3616 
3617         if (ioc->is_warpdrive)
3618                 return;
3619 
3620         /* Volume Resets for Deleted or Removed */
3621         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3622         for (i = 0; i < event_data->NumElements; i++, element++) {
3623                 if (element->ReasonCode ==
3624                     MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED ||
3625                     element->ReasonCode ==
3626                     MPI2_EVENT_IR_CHANGE_RC_REMOVED) {
3627                         volume_handle = le16_to_cpu(element->VolDevHandle);
3628                         _scsih_set_volume_delete_flag(ioc, volume_handle);
3629                         _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
3630                 }
3631         }
3632 
3633         /* Volume Resets for UNHIDE events */
3634         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3635         for (i = 0; i < event_data->NumElements; i++, element++) {
3636                 if (le32_to_cpu(event_data->Flags) &
3637                     MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
3638                         continue;
3639                 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_UNHIDE) {
3640                         volume_handle = le16_to_cpu(element->VolDevHandle);
3641                         _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
3642                 }
3643         }
3644 
3645         if (a)
3646                 _scsih_tm_tr_volume_send(ioc, a);
3647         if (b)
3648                 _scsih_tm_tr_volume_send(ioc, b);
3649 
3650         /* PD target resets */
3651         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3652         for (i = 0; i < event_data->NumElements; i++, element++) {
3653                 if (element->ReasonCode != MPI2_EVENT_IR_CHANGE_RC_UNHIDE)
3654                         continue;
3655                 handle = le16_to_cpu(element->PhysDiskDevHandle);
3656                 volume_handle = le16_to_cpu(element->VolDevHandle);
3657                 clear_bit(handle, ioc->pd_handles);
3658                 if (!volume_handle)
3659                         _scsih_tm_tr_send(ioc, handle);
3660                 else if (volume_handle == a || volume_handle == b) {
3661                         delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3662                         BUG_ON(!delayed_tr);
3663                         INIT_LIST_HEAD(&delayed_tr->list);
3664                         delayed_tr->handle = handle;
3665                         list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3666                         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3667                             "DELAYED:tr:handle(0x%04x), (open)\n", ioc->name,
3668                             handle));
3669                 } else
3670                         _scsih_tm_tr_send(ioc, handle);
3671         }
3672 }
3673 
3674 
3675 /**
3676  * _scsih_check_volume_delete_events - set delete flag for volumes
3677  * @ioc: per adapter object
3678  * @event_data: the event data payload
3679  * Context: interrupt time.
3680  *
3681  * This will handle the case when the cable connected to entire volume is
3682  * pulled. We will take care of setting the deleted flag so normal IO will
3683  * not be sent.
3684  *
3685  * Return nothing.
3686  */
3687 static void
3688 _scsih_check_volume_delete_events(struct MPT2SAS_ADAPTER *ioc,
3689     Mpi2EventDataIrVolume_t *event_data)
3690 {
3691         u32 state;
3692 
3693         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
3694                 return;
3695         state = le32_to_cpu(event_data->NewValue);
3696         if (state == MPI2_RAID_VOL_STATE_MISSING || state ==
3697             MPI2_RAID_VOL_STATE_FAILED)
3698                 _scsih_set_volume_delete_flag(ioc,
3699                     le16_to_cpu(event_data->VolDevHandle));
3700 }
3701 
3702 /**
3703  * _scsih_flush_running_cmds - completing outstanding commands.
3704  * @ioc: per adapter object
3705  *
3706  * The flushing out of all pending scmd commands following host reset,
3707  * where all IO is dropped to the floor.
3708  *
3709  * Return nothing.
3710  */
3711 static void
3712 _scsih_flush_running_cmds(struct MPT2SAS_ADAPTER *ioc)
3713 {
3714         struct scsi_cmnd *scmd;
3715         u16 smid;
3716         u16 count = 0;
3717 
3718         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
3719                 scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
3720                 if (!scmd)
3721                         continue;
3722                 count++;
3723                 mpt2sas_base_free_smid(ioc, smid);
3724                 scsi_dma_unmap(scmd);
3725                 if (ioc->pci_error_recovery)
3726                         scmd->result = DID_NO_CONNECT << 16;
3727                 else
3728                         scmd->result = DID_RESET << 16;
3729                 scmd->scsi_done(scmd);
3730         }
3731         dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "completing %d cmds\n",
3732             ioc->name, count));
3733 }
3734 
3735 /**
3736  * _scsih_setup_eedp - setup MPI request for EEDP transfer
3737  * @scmd: pointer to scsi command object
3738  * @mpi_request: pointer to the SCSI_IO reqest message frame
3739  *
3740  * Supporting protection 1 and 3.
3741  *
3742  * Returns nothing
3743  */
3744 static void
3745 _scsih_setup_eedp(struct scsi_cmnd *scmd, Mpi2SCSIIORequest_t *mpi_request)
3746 {
3747         u16 eedp_flags;
3748         unsigned char prot_op = scsi_get_prot_op(scmd);
3749         unsigned char prot_type = scsi_get_prot_type(scmd);
3750 
3751         if (prot_type == SCSI_PROT_DIF_TYPE0 || prot_op == SCSI_PROT_NORMAL)
3752                 return;
3753 
3754         if (prot_op ==  SCSI_PROT_READ_STRIP)
3755                 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP;
3756         else if (prot_op ==  SCSI_PROT_WRITE_INSERT)
3757                 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP;
3758         else
3759                 return;
3760 
3761         switch (prot_type) {
3762         case SCSI_PROT_DIF_TYPE1:
3763         case SCSI_PROT_DIF_TYPE2:
3764 
3765                 /*
3766                 * enable ref/guard checking
3767                 * auto increment ref tag
3768                 */
3769                 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
3770                     MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
3771                     MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
3772                 mpi_request->CDB.EEDP32.PrimaryReferenceTag =
3773                     cpu_to_be32(scsi_get_lba(scmd));
3774                 break;
3775 
3776         case SCSI_PROT_DIF_TYPE3:
3777 
3778                 /*
3779                 * enable guard checking
3780                 */
3781                 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
3782                 break;
3783         }
3784         mpi_request->EEDPBlockSize = cpu_to_le32(scmd->device->sector_size);
3785         mpi_request->EEDPFlags = cpu_to_le16(eedp_flags);
3786 }
3787 
3788 /**
3789  * _scsih_eedp_error_handling - return sense code for EEDP errors
3790  * @scmd: pointer to scsi command object
3791  * @ioc_status: ioc status
3792  *
3793  * Returns nothing
3794  */
3795 static void
3796 _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
3797 {
3798         u8 ascq;
3799 
3800         switch (ioc_status) {
3801         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
3802                 ascq = 0x01;
3803                 break;
3804         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
3805                 ascq = 0x02;
3806                 break;
3807         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
3808                 ascq = 0x03;
3809                 break;
3810         default:
3811                 ascq = 0x00;
3812                 break;
3813         }
3814 
3815         scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 0x10, ascq);
3816         scmd->result = DRIVER_SENSE << 24 | (DID_ABORT << 16) |
3817             SAM_STAT_CHECK_CONDITION;
3818 }
3819 
3820 /**
3821  * _scsih_scsi_direct_io_get - returns direct io flag
3822  * @ioc: per adapter object
3823  * @smid: system request message index
3824  *
3825  * Returns the smid stored scmd pointer.
3826  */
3827 static inline u8
3828 _scsih_scsi_direct_io_get(struct MPT2SAS_ADAPTER *ioc, u16 smid)
3829 {
3830         return ioc->scsi_lookup[smid - 1].direct_io;
3831 }
3832 
3833 /**
3834  * _scsih_scsi_direct_io_set - sets direct io flag
3835  * @ioc: per adapter object
3836  * @smid: system request message index
3837  * @direct_io: Zero or non-zero value to set in the direct_io flag
3838  *
3839  * Returns Nothing.
3840  */
3841 static inline void
3842 _scsih_scsi_direct_io_set(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 direct_io)
3843 {
3844         ioc->scsi_lookup[smid - 1].direct_io = direct_io;
3845 }
3846 
3847 
3848 /**
3849  * _scsih_setup_direct_io - setup MPI request for WARPDRIVE Direct I/O
3850  * @ioc: per adapter object
3851  * @scmd: pointer to scsi command object
3852  * @raid_device: pointer to raid device data structure
3853  * @mpi_request: pointer to the SCSI_IO reqest message frame
3854  * @smid: system request message index
3855  *
3856  * Returns nothing
3857  */
3858 static void
3859 _scsih_setup_direct_io(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
3860         struct _raid_device *raid_device, Mpi2SCSIIORequest_t *mpi_request,
3861         u16 smid)
3862 {
3863         u32 v_lba, p_lba, stripe_off, stripe_unit, column, io_size;
3864         u32 stripe_sz, stripe_exp;
3865         u8 num_pds, *cdb_ptr, i;
3866         u8 cdb0 = scmd->cmnd[0];
3867         u64 v_llba;
3868 
3869         /*
3870          * Try Direct I/O to RAID memeber disks
3871          */
3872         if (cdb0 == READ_16 || cdb0 == READ_10 ||
3873             cdb0 == WRITE_16 || cdb0 == WRITE_10) {
3874                 cdb_ptr = mpi_request->CDB.CDB32;
3875 
3876                 if ((cdb0 < READ_16) || !(cdb_ptr[2] | cdb_ptr[3] | cdb_ptr[4]
3877                         | cdb_ptr[5])) {
3878                         io_size = scsi_bufflen(scmd) >>
3879                             raid_device->block_exponent;
3880                         i = (cdb0 < READ_16) ? 2 : 6;
3881                         /* get virtual lba */
3882                         v_lba = be32_to_cpu(*(__be32 *)(&cdb_ptr[i]));
3883 
3884                         if (((u64)v_lba + (u64)io_size - 1) <=
3885                             (u32)raid_device->max_lba) {
3886                                 stripe_sz = raid_device->stripe_sz;
3887                                 stripe_exp = raid_device->stripe_exponent;
3888                                 stripe_off = v_lba & (stripe_sz - 1);
3889 
3890                                 /* Check whether IO falls within a stripe */
3891                                 if ((stripe_off + io_size) <= stripe_sz) {
3892                                         num_pds = raid_device->num_pds;
3893                                         p_lba = v_lba >> stripe_exp;
3894                                         stripe_unit = p_lba / num_pds;
3895                                         column = p_lba % num_pds;
3896                                         p_lba = (stripe_unit << stripe_exp) +
3897                                             stripe_off;
3898                                         mpi_request->DevHandle =
3899                                                 cpu_to_le16(raid_device->
3900                                                     pd_handle[column]);
3901                                         (*(__be32 *)(&cdb_ptr[i])) =
3902                                                 cpu_to_be32(p_lba);
3903                                         /*
3904                                         * WD: To indicate this I/O is directI/O
3905                                         */
3906                                         _scsih_scsi_direct_io_set(ioc, smid, 1);
3907                                 }
3908                         }
3909                 } else {
3910                         io_size = scsi_bufflen(scmd) >>
3911                             raid_device->block_exponent;
3912                         /* get virtual lba */
3913                         v_llba = be64_to_cpu(*(__be64 *)(&cdb_ptr[2]));
3914 
3915                         if ((v_llba + (u64)io_size - 1) <=
3916                             raid_device->max_lba) {
3917                                 stripe_sz = raid_device->stripe_sz;
3918                                 stripe_exp = raid_device->stripe_exponent;
3919                                 stripe_off = (u32) (v_llba & (stripe_sz - 1));
3920 
3921                                 /* Check whether IO falls within a stripe */
3922                                 if ((stripe_off + io_size) <= stripe_sz) {
3923                                         num_pds = raid_device->num_pds;
3924                                         p_lba = (u32)(v_llba >> stripe_exp);
3925                                         stripe_unit = p_lba / num_pds;
3926                                         column = p_lba % num_pds;
3927                                         p_lba = (stripe_unit << stripe_exp) +
3928                                             stripe_off;
3929                                         mpi_request->DevHandle =
3930                                                 cpu_to_le16(raid_device->
3931                                                     pd_handle[column]);
3932                                         (*(__be64 *)(&cdb_ptr[2])) =
3933                                             cpu_to_be64((u64)p_lba);
3934                                         /*
3935                                         * WD: To indicate this I/O is directI/O
3936                                         */
3937                                         _scsih_scsi_direct_io_set(ioc, smid, 1);
3938                                 }
3939                         }
3940                 }
3941         }
3942 }
3943 
3944 /**
3945  * _scsih_qcmd - main scsi request entry point
3946  * @scmd: pointer to scsi command object
3947  * @done: function pointer to be invoked on completion
3948  *
3949  * The callback index is set inside `ioc->scsi_io_cb_idx`.
3950  *
3951  * Returns 0 on success.  If there's a failure, return either:
3952  * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or
3953  * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full
3954  */
3955 static int
3956 _scsih_qcmd_lck(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
3957 {
3958         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3959         struct MPT2SAS_DEVICE *sas_device_priv_data;
3960         struct MPT2SAS_TARGET *sas_target_priv_data;
3961         struct _raid_device *raid_device;
3962         Mpi2SCSIIORequest_t *mpi_request;
3963         u32 mpi_control;
3964         u16 smid;
3965 
3966         scmd->scsi_done = done;
3967         sas_device_priv_data = scmd->device->hostdata;
3968         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
3969                 scmd->result = DID_NO_CONNECT << 16;
3970                 scmd->scsi_done(scmd);
3971                 return 0;
3972         }
3973 
3974         if (ioc->pci_error_recovery || ioc->remove_host) {
3975                 scmd->result = DID_NO_CONNECT << 16;
3976                 scmd->scsi_done(scmd);
3977                 return 0;
3978         }
3979 
3980         sas_target_priv_data = sas_device_priv_data->sas_target;
3981         /* invalid device handle */
3982         if (sas_target_priv_data->handle == MPT2SAS_INVALID_DEVICE_HANDLE) {
3983                 scmd->result = DID_NO_CONNECT << 16;
3984                 scmd->scsi_done(scmd);
3985                 return 0;
3986         }
3987 
3988         /* host recovery or link resets sent via IOCTLs */
3989         if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress)
3990                 return SCSI_MLQUEUE_HOST_BUSY;
3991         /* device busy with task management */
3992         else if (sas_device_priv_data->block || sas_target_priv_data->tm_busy)
3993                 return SCSI_MLQUEUE_DEVICE_BUSY;
3994         /* device has been deleted */
3995         else if (sas_target_priv_data->deleted) {
3996                 scmd->result = DID_NO_CONNECT << 16;
3997                 scmd->scsi_done(scmd);
3998                 return 0;
3999         }
4000 
4001         if (scmd->sc_data_direction == DMA_FROM_DEVICE)
4002                 mpi_control = MPI2_SCSIIO_CONTROL_READ;
4003         else if (scmd->sc_data_direction == DMA_TO_DEVICE)
4004                 mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
4005         else
4006                 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
4007 
4008         /* set tags */
4009         if (!(sas_device_priv_data->flags & MPT_DEVICE_FLAGS_INIT)) {
4010                 if (scmd->device->tagged_supported) {
4011                         if (scmd->device->ordered_tags)
4012                                 mpi_control |= MPI2_SCSIIO_CONTROL_ORDEREDQ;
4013                         else
4014                                 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
4015                 } else
4016                         mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
4017         } else
4018                 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
4019         /* Make sure Device is not raid volume.
4020          * We do not expose raid functionality to upper layer for warpdrive.
4021          */
4022         if (!ioc->is_warpdrive && !_scsih_is_raid(&scmd->device->sdev_gendev) &&
4023             sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32)
4024                 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
4025 
4026         smid = mpt2sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
4027         if (!smid) {
4028                 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
4029                     ioc->name, __func__);
4030                 goto out;
4031         }
4032         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
4033         memset(mpi_request, 0, sizeof(Mpi2SCSIIORequest_t));
4034         _scsih_setup_eedp(scmd, mpi_request);
4035         if (scmd->cmd_len == 32)
4036                 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT;
4037         mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
4038         if (sas_device_priv_data->sas_target->flags &
4039             MPT_TARGET_FLAGS_RAID_COMPONENT)
4040                 mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
4041         else
4042                 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
4043         mpi_request->DevHandle =
4044             cpu_to_le16(sas_device_priv_data->sas_target->handle);
4045         mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
4046         mpi_request->Control = cpu_to_le32(mpi_control);
4047         mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len);
4048         mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR;
4049         mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
4050         mpi_request->SenseBufferLowAddress =
4051             mpt2sas_base_get_sense_buffer_dma(ioc, smid);
4052         mpi_request->SGLOffset0 = offsetof(Mpi2SCSIIORequest_t, SGL) / 4;
4053         mpi_request->SGLFlags = cpu_to_le16(MPI2_SCSIIO_SGLFLAGS_TYPE_MPI +
4054             MPI2_SCSIIO_SGLFLAGS_SYSTEM_ADDR);
4055         mpi_request->VF_ID = 0; /* TODO */
4056         mpi_request->VP_ID = 0;
4057         int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *)
4058             mpi_request->LUN);
4059         memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
4060 
4061         if (!mpi_request->DataLength) {
4062                 mpt2sas_base_build_zero_len_sge(ioc, &mpi_request->SGL);
4063         } else {
4064                 if (_scsih_build_scatter_gather(ioc, scmd, smid)) {
4065                         mpt2sas_base_free_smid(ioc, smid);
4066                         goto out;
4067                 }
4068         }
4069 
4070         raid_device = sas_target_priv_data->raid_device;
4071         if (raid_device && raid_device->direct_io_enabled)
4072                 _scsih_setup_direct_io(ioc, scmd, raid_device, mpi_request,
4073                     smid);
4074 
4075         if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST))
4076                 mpt2sas_base_put_smid_scsi_io(ioc, smid,
4077                     le16_to_cpu(mpi_request->DevHandle));
4078         else
4079                 mpt2sas_base_put_smid_default(ioc, smid);
4080         return 0;
4081 
4082  out:
4083         return SCSI_MLQUEUE_HOST_BUSY;
4084 }
4085 
4086 static DEF_SCSI_QCMD(_scsih_qcmd)
4087 
4088 /**
4089  * _scsih_normalize_sense - normalize descriptor and fixed format sense data
4090  * @sense_buffer: sense data returned by target
4091  * @data: normalized skey/asc/ascq
4092  *
4093  * Return nothing.
4094  */
4095 static void
4096 _scsih_normalize_sense(char *sense_buffer, struct sense_info *data)
4097 {
4098         if ((sense_buffer[0] & 0x7F) >= 0x72) {
4099                 /* descriptor format */
4100                 data->skey = sense_buffer[1] & 0x0F;
4101                 data->asc = sense_buffer[2];
4102                 data->ascq = sense_buffer[3];
4103         } else {
4104                 /* fixed format */
4105                 data->skey = sense_buffer[2] & 0x0F;
4106                 data->asc = sense_buffer[12];
4107                 data->ascq = sense_buffer[13];
4108         }
4109 }
4110 
4111 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4112 /**
4113  * _scsih_scsi_ioc_info - translated non-successful SCSI_IO request
4114  * @ioc: per adapter object
4115  * @scmd: pointer to scsi command object
4116  * @mpi_reply: reply mf payload returned from firmware
4117  *
4118  * scsi_status - SCSI Status code returned from target device
4119  * scsi_state - state info associated with SCSI_IO determined by ioc
4120  * ioc_status - ioc supplied status info
4121  *
4122  * Return nothing.
4123  */
4124 static void
4125 _scsih_scsi_ioc_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
4126     Mpi2SCSIIOReply_t *mpi_reply, u16 smid)
4127 {
4128         u32 response_info;
4129         u8 *response_bytes;
4130         u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) &
4131             MPI2_IOCSTATUS_MASK;
4132         u8 scsi_state = mpi_reply->SCSIState;
4133         u8 scsi_status = mpi_reply->SCSIStatus;
4134         char *desc_ioc_state = NULL;
4135         char *desc_scsi_status = NULL;
4136         char *desc_scsi_state = ioc->tmp_string;
4137         u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
4138         struct _sas_device *sas_device = NULL;
4139         unsigned long flags;
4140         struct scsi_target *starget = scmd->device->sdev_target;
4141         struct MPT2SAS_TARGET *priv_target = starget->hostdata;
4142         char *device_str = NULL;
4143 
4144         if (!priv_target)
4145                 return;
4146 
4147         if (ioc->hide_ir_msg)
4148                 device_str = "WarpDrive";
4149         else
4150                 device_str = "volume";
4151 
4152         if (log_info == 0x31170000)
4153                 return;
4154 
4155         switch (ioc_status) {
4156         case MPI2_IOCSTATUS_SUCCESS:
4157                 desc_ioc_state = "success";
4158                 break;
4159         case MPI2_IOCSTATUS_INVALID_FUNCTION:
4160                 desc_ioc_state = "invalid function";
4161                 break;
4162         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4163                 desc_ioc_state = "scsi recovered error";
4164                 break;
4165         case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE:
4166                 desc_ioc_state = "scsi invalid dev handle";
4167                 break;
4168         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4169                 desc_ioc_state = "scsi device not there";
4170                 break;
4171         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4172                 desc_ioc_state = "scsi data overrun";
4173                 break;
4174         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4175                 desc_ioc_state = "scsi data underrun";
4176                 break;
4177         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4178                 desc_ioc_state = "scsi io data error";
4179                 break;
4180         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4181                 desc_ioc_state = "scsi protocol error";
4182                 break;
4183         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4184                 desc_ioc_state = "scsi task terminated";
4185                 break;
4186         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4187                 desc_ioc_state = "scsi residual mismatch";
4188                 break;
4189         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4190                 desc_ioc_state = "scsi task mgmt failed";
4191                 break;
4192         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4193                 desc_ioc_state = "scsi ioc terminated";
4194                 break;
4195         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4196                 desc_ioc_state = "scsi ext terminated";
4197                 break;
4198         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4199                 desc_ioc_state = "eedp guard error";
4200                 break;
4201         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4202                 desc_ioc_state = "eedp ref tag error";
4203                 break;
4204         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4205                 desc_ioc_state = "eedp app tag error";
4206                 break;
4207         default:
4208                 desc_ioc_state = "unknown";
4209                 break;
4210         }
4211 
4212         switch (scsi_status) {
4213         case MPI2_SCSI_STATUS_GOOD:
4214                 desc_scsi_status = "good";
4215                 break;
4216         case MPI2_SCSI_STATUS_CHECK_CONDITION:
4217                 desc_scsi_status = "check condition";
4218                 break;
4219         case MPI2_SCSI_STATUS_CONDITION_MET:
4220                 desc_scsi_status = "condition met";
4221                 break;
4222         case MPI2_SCSI_STATUS_BUSY:
4223                 desc_scsi_status = "busy";
4224                 break;
4225         case MPI2_SCSI_STATUS_INTERMEDIATE:
4226                 desc_scsi_status = "intermediate";
4227                 break;
4228         case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET:
4229                 desc_scsi_status = "intermediate condmet";
4230                 break;
4231         case MPI2_SCSI_STATUS_RESERVATION_CONFLICT:
4232                 desc_scsi_status = "reservation conflict";
4233                 break;
4234         case MPI2_SCSI_STATUS_COMMAND_TERMINATED:
4235                 desc_scsi_status = "command terminated";
4236                 break;
4237         case MPI2_SCSI_STATUS_TASK_SET_FULL:
4238                 desc_scsi_status = "task set full";
4239                 break;
4240         case MPI2_SCSI_STATUS_ACA_ACTIVE:
4241                 desc_scsi_status = "aca active";
4242                 break;
4243         case MPI2_SCSI_STATUS_TASK_ABORTED:
4244                 desc_scsi_status = "task aborted";
4245                 break;
4246         default:
4247                 desc_scsi_status = "unknown";
4248                 break;
4249         }
4250 
4251         desc_scsi_state[0] = '\0';
4252         if (!scsi_state)
4253                 desc_scsi_state = " ";
4254         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4255                 strcat(desc_scsi_state, "response info ");
4256         if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4257                 strcat(desc_scsi_state, "state terminated ");
4258         if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS)
4259                 strcat(desc_scsi_state, "no status ");
4260         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED)
4261                 strcat(desc_scsi_state, "autosense failed ");
4262         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)
4263                 strcat(desc_scsi_state, "autosense valid ");
4264 
4265         scsi_print_command(scmd);
4266 
4267         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
4268                 printk(MPT2SAS_WARN_FMT "\t%s wwid(0x%016llx)\n", ioc->name,
4269                     device_str, (unsigned long long)priv_target->sas_address);
4270         } else {
4271                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4272                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
4273                     priv_target->sas_address);
4274                 if (sas_device) {
4275                         printk(MPT2SAS_WARN_FMT "\tsas_address(0x%016llx), "
4276                             "phy(%d)\n", ioc->name, sas_device->sas_address,
4277                             sas_device->phy);
4278                         printk(MPT2SAS_WARN_FMT
4279                             "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
4280                             ioc->name, sas_device->enclosure_logical_id,
4281                             sas_device->slot);
4282                 }
4283                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4284         }
4285 
4286         printk(MPT2SAS_WARN_FMT "\thandle(0x%04x), ioc_status(%s)(0x%04x), "
4287             "smid(%d)\n", ioc->name, le16_to_cpu(mpi_reply->DevHandle),
4288             desc_ioc_state, ioc_status, smid);
4289         printk(MPT2SAS_WARN_FMT "\trequest_len(%d), underflow(%d), "
4290             "resid(%d)\n", ioc->name, scsi_bufflen(scmd), scmd->underflow,
4291             scsi_get_resid(scmd));
4292         printk(MPT2SAS_WARN_FMT "\ttag(%d), transfer_count(%d), "
4293             "sc->result(0x%08x)\n", ioc->name, le16_to_cpu(mpi_reply->TaskTag),
4294             le32_to_cpu(mpi_reply->TransferCount), scmd->result);
4295         printk(MPT2SAS_WARN_FMT "\tscsi_status(%s)(0x%02x), "
4296             "scsi_state(%s)(0x%02x)\n", ioc->name, desc_scsi_status,
4297             scsi_status, desc_scsi_state, scsi_state);
4298 
4299         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
4300                 struct sense_info data;
4301                 _scsih_normalize_sense(scmd->sense_buffer, &data);
4302                 printk(MPT2SAS_WARN_FMT "\t[sense_key,asc,ascq]: "
4303                     "[0x%02x,0x%02x,0x%02x], count(%d)\n", ioc->name, data.skey,
4304                     data.asc, data.ascq, le32_to_cpu(mpi_reply->SenseCount));
4305         }
4306 
4307         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
4308                 response_info = le32_to_cpu(mpi_reply->ResponseInfo);
4309                 response_bytes = (u8 *)&response_info;
4310                 _scsih_response_code(ioc, response_bytes[0]);
4311         }
4312 }
4313 #endif
4314 
4315 /**
4316  * _scsih_turn_on_fault_led - illuminate Fault LED
4317  * @ioc: per adapter object
4318  * @handle: device handle
4319  * Context: process
4320  *
4321  * Return nothing.
4322  */
4323 static void
4324 _scsih_turn_on_fault_led(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4325 {
4326         Mpi2SepReply_t mpi_reply;
4327         Mpi2SepRequest_t mpi_request;
4328 
4329         memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
4330         mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
4331         mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
4332         mpi_request.SlotStatus =
4333             cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
4334         mpi_request.DevHandle = cpu_to_le16(handle);
4335         mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
4336         if ((mpt2sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
4337             &mpi_request)) != 0) {
4338                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n", ioc->name,
4339                 __FILE__, __LINE__, __func__);
4340                 return;
4341         }
4342 
4343         if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
4344                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "enclosure_processor: "
4345                     "ioc_status (0x%04x), loginfo(0x%08x)\n", ioc->name,
4346                     le16_to_cpu(mpi_reply.IOCStatus),
4347                     le32_to_cpu(mpi_reply.IOCLogInfo)));
4348                 return;
4349         }
4350 }
4351 
4352 /**
4353  * _scsih_send_event_to_turn_on_fault_led - fire delayed event
4354  * @ioc: per adapter object
4355  * @handle: device handle
4356  * Context: interrupt.
4357  *
4358  * Return nothing.
4359  */
4360 static void
4361 _scsih_send_event_to_turn_on_fault_led(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4362 {
4363         struct fw_event_work *fw_event;
4364 
4365         fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
4366         if (!fw_event)
4367                 return;
4368         fw_event->event = MPT2SAS_TURN_ON_FAULT_LED;
4369         fw_event->device_handle = handle;
4370         fw_event->ioc = ioc;
4371         _scsih_fw_event_add(ioc, fw_event);
4372 }
4373 
4374 /**
4375  * _scsih_smart_predicted_fault - process smart errors
4376  * @ioc: per adapter object
4377  * @handle: device handle
4378  * Context: interrupt.
4379  *
4380  * Return nothing.
4381  */
4382 static void
4383 _scsih_smart_predicted_fault(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4384 {
4385         struct scsi_target *starget;
4386         struct MPT2SAS_TARGET *sas_target_priv_data;
4387         Mpi2EventNotificationReply_t *event_reply;
4388         Mpi2EventDataSasDeviceStatusChange_t *event_data;
4389         struct _sas_device *sas_device;
4390         ssize_t sz;
4391         unsigned long flags;
4392 
4393         /* only handle non-raid devices */
4394         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4395         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4396         if (!sas_device) {
4397                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4398                 return;
4399         }
4400         starget = sas_device->starget;
4401         sas_target_priv_data = starget->hostdata;
4402 
4403         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) ||
4404            ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))) {
4405                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4406                 return;
4407         }
4408         starget_printk(KERN_WARNING, starget, "predicted fault\n");
4409         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4410 
4411         if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
4412                 _scsih_send_event_to_turn_on_fault_led(ioc, handle);
4413 
4414         /* insert into event log */
4415         sz = offsetof(Mpi2EventNotificationReply_t, EventData) +
4416              sizeof(Mpi2EventDataSasDeviceStatusChange_t);
4417         event_reply = kzalloc(sz, GFP_ATOMIC);
4418         if (!event_reply) {
4419                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4420                     ioc->name, __FILE__, __LINE__, __func__);
4421                 return;
4422         }
4423 
4424         event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION;
4425         event_reply->Event =
4426             cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE);
4427         event_reply->MsgLength = sz/4;
4428         event_reply->EventDataLength =
4429             cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4);
4430         event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
4431             event_reply->EventData;
4432         event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
4433         event_data->ASC = 0x5D;
4434         event_data->DevHandle = cpu_to_le16(handle);
4435         event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
4436         mpt2sas_ctl_add_to_event_log(ioc, event_reply);
4437         kfree(event_reply);
4438 }
4439 
4440 /**
4441  * _scsih_io_done - scsi request callback
4442  * @ioc: per adapter object
4443  * @smid: system request message index
4444  * @msix_index: MSIX table index supplied by the OS
4445  * @reply: reply message frame(lower 32bit addr)
4446  *
4447  * Callback handler when using _scsih_qcmd.
4448  *
4449  * Return 1 meaning mf should be freed from _base_interrupt
4450  *        0 means the mf is freed from this function.
4451  */
4452 static u8
4453 _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
4454 {
4455         Mpi2SCSIIORequest_t *mpi_request;
4456         Mpi2SCSIIOReply_t *mpi_reply;
4457         struct scsi_cmnd *scmd;
4458         u16 ioc_status;
4459         u32 xfer_cnt;
4460         u8 scsi_state;
4461         u8 scsi_status;
4462         u32 log_info;
4463         struct MPT2SAS_DEVICE *sas_device_priv_data;
4464         u32 response_code = 0;
4465         unsigned long flags;
4466 
4467         mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
4468         scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
4469         if (scmd == NULL)
4470                 return 1;
4471 
4472         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
4473 
4474         if (mpi_reply == NULL) {
4475                 scmd->result = DID_OK << 16;
4476                 goto out;
4477         }
4478 
4479         sas_device_priv_data = scmd->device->hostdata;
4480         if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
4481              sas_device_priv_data->sas_target->deleted) {
4482                 scmd->result = DID_NO_CONNECT << 16;
4483                 goto out;
4484         }
4485         ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
4486         /*
4487          * WARPDRIVE: If direct_io is set then it is directIO,
4488          * the failed direct I/O should be redirected to volume
4489          */
4490         if (_scsih_scsi_direct_io_get(ioc, smid) &&
4491             ((ioc_status & MPI2_IOCSTATUS_MASK)
4492             != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) {
4493                 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4494                 ioc->scsi_lookup[smid - 1].scmd = scmd;
4495                 _scsih_scsi_direct_io_set(ioc, smid, 0);
4496                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4497                 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
4498                 mpi_request->DevHandle =
4499                     cpu_to_le16(sas_device_priv_data->sas_target->handle);
4500                 mpt2sas_base_put_smid_scsi_io(ioc, smid,
4501                     sas_device_priv_data->sas_target->handle);
4502                 return 0;
4503         }
4504 
4505 
4506         /* turning off TLR */
4507         scsi_state = mpi_reply->SCSIState;
4508         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4509                 response_code =
4510                     le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
4511         if (!sas_device_priv_data->tlr_snoop_check) {
4512                 sas_device_priv_data->tlr_snoop_check++;
4513         /* Make sure Device is not raid volume.
4514          * We do not expose raid functionality to upper layer for warpdrive.
4515          */
4516         if (!ioc->is_warpdrive && !_scsih_is_raid(&scmd->device->sdev_gendev) &&
4517                 sas_is_tlr_enabled(scmd->device) &&
4518                     response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) {
4519                         sas_disable_tlr(scmd->device);
4520                         sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n");
4521                 }
4522         }
4523 
4524         xfer_cnt = le32_to_cpu(mpi_reply->TransferCount);
4525         scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt);
4526         if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
4527                 log_info =  le32_to_cpu(mpi_reply->IOCLogInfo);
4528         else
4529                 log_info = 0;
4530         ioc_status &= MPI2_IOCSTATUS_MASK;
4531         scsi_status = mpi_reply->SCSIStatus;
4532 
4533         if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
4534             (scsi_status == MPI2_SCSI_STATUS_BUSY ||
4535              scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT ||
4536              scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) {
4537                 ioc_status = MPI2_IOCSTATUS_SUCCESS;
4538         }
4539 
4540         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
4541                 struct sense_info data;
4542                 const void *sense_data = mpt2sas_base_get_sense_buffer(ioc,
4543                     smid);
4544                 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
4545                     le32_to_cpu(mpi_reply->SenseCount));
4546                 memcpy(scmd->sense_buffer, sense_data, sz);
4547                 _scsih_normalize_sense(scmd->sense_buffer, &data);
4548                 /* failure prediction threshold exceeded */
4549                 if (data.asc == 0x5D)
4550                         _scsih_smart_predicted_fault(ioc,
4551                             le16_to_cpu(mpi_reply->DevHandle));
4552         }
4553 
4554         switch (ioc_status) {
4555         case MPI2_IOCSTATUS_BUSY:
4556         case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES:
4557                 scmd->result = SAM_STAT_BUSY;
4558                 break;
4559 
4560         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4561                 scmd->result = DID_NO_CONNECT << 16;
4562                 break;
4563 
4564         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4565                 if (sas_device_priv_data->block) {
4566                         scmd->result = DID_TRANSPORT_DISRUPTED << 16;
4567                         goto out;
4568                 }
4569                 scmd->result = DID_SOFT_ERROR << 16;
4570                 break;
4571         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4572         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4573                 scmd->result = DID_RESET << 16;
4574                 break;
4575 
4576         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4577                 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt))
4578                         scmd->result = DID_SOFT_ERROR << 16;
4579                 else
4580                         scmd->result = (DID_OK << 16) | scsi_status;
4581                 break;
4582 
4583         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4584                 scmd->result = (DID_OK << 16) | scsi_status;
4585 
4586                 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID))
4587                         break;
4588 
4589                 if (xfer_cnt < scmd->underflow) {
4590                         if (scsi_status == SAM_STAT_BUSY)
4591                                 scmd->result = SAM_STAT_BUSY;
4592                         else
4593                                 scmd->result = DID_SOFT_ERROR << 16;
4594                 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
4595                      MPI2_SCSI_STATE_NO_SCSI_STATUS))
4596                         scmd->result = DID_SOFT_ERROR << 16;
4597                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4598                         scmd->result = DID_RESET << 16;
4599                 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
4600                         mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
4601                         mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
4602                         scmd->result = (DRIVER_SENSE << 24) |
4603                             SAM_STAT_CHECK_CONDITION;
4604                         scmd->sense_buffer[0] = 0x70;
4605                         scmd->sense_buffer[2] = ILLEGAL_REQUEST;
4606                         scmd->sense_buffer[12] = 0x20;
4607                         scmd->sense_buffer[13] = 0;
4608                 }
4609                 break;
4610 
4611         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4612                 scsi_set_resid(scmd, 0);
4613         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4614         case MPI2_IOCSTATUS_SUCCESS:
4615                 scmd->result = (DID_OK << 16) | scsi_status;
4616                 if (response_code ==
4617                     MPI2_SCSITASKMGMT_RSP_INVALID_FRAME ||
4618                     (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
4619                      MPI2_SCSI_STATE_NO_SCSI_STATUS)))
4620                         scmd->result = DID_SOFT_ERROR << 16;
4621                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4622                         scmd->result = DID_RESET << 16;
4623                 break;
4624 
4625         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4626         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4627         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4628                 _scsih_eedp_error_handling(scmd, ioc_status);
4629                 break;
4630         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4631         case MPI2_IOCSTATUS_INVALID_FUNCTION:
4632         case MPI2_IOCSTATUS_INVALID_SGL:
4633         case MPI2_IOCSTATUS_INTERNAL_ERROR:
4634         case MPI2_IOCSTATUS_INVALID_FIELD:
4635         case MPI2_IOCSTATUS_INVALID_STATE:
4636         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4637         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4638         default:
4639                 scmd->result = DID_SOFT_ERROR << 16;
4640                 break;
4641 
4642         }
4643 
4644 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4645         if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
4646                 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
4647 #endif
4648 
4649  out:
4650         scsi_dma_unmap(scmd);
4651         scmd->scsi_done(scmd);
4652         return 1;
4653 }
4654 
4655 /**
4656  * _scsih_sas_host_refresh - refreshing sas host object contents
4657  * @ioc: per adapter object
4658  * Context: user
4659  *
4660  * During port enable, fw will send topology events for every device. Its
4661  * possible that the handles may change from the previous setting, so this
4662  * code keeping handles updating if changed.
4663  *
4664  * Return nothing.
4665  */
4666 static void
4667 _scsih_sas_host_refresh(struct MPT2SAS_ADAPTER *ioc)
4668 {
4669         u16 sz;
4670         u16 ioc_status;
4671         int i;
4672         Mpi2ConfigReply_t mpi_reply;
4673         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
4674         u16 attached_handle;
4675         u8 link_rate;
4676 
4677         dtmprintk(ioc, printk(MPT2SAS_INFO_FMT
4678             "updating handles for sas_host(0x%016llx)\n",
4679             ioc->name, (unsigned long long)ioc->sas_hba.sas_address));
4680 
4681         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
4682             * sizeof(Mpi2SasIOUnit0PhyData_t));
4683         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
4684         if (!sas_iounit_pg0) {
4685                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4686                     ioc->name, __FILE__, __LINE__, __func__);
4687                 return;
4688         }
4689 
4690         if ((mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4691             sas_iounit_pg0, sz)) != 0)
4692                 goto out;
4693         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
4694         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
4695                 goto out;
4696         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4697                 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4;
4698                 if (i == 0)
4699                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4700                             PhyData[0].ControllerDevHandle);
4701                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4702                 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i].
4703                     AttachedDevHandle);
4704                 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
4705                         link_rate = MPI2_SAS_NEG_LINK_RATE_1_5;
4706                 mpt2sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
4707                     attached_handle, i, link_rate);
4708         }
4709  out:
4710         kfree(sas_iounit_pg0);
4711 }
4712 
4713 /**
4714  * _scsih_sas_host_add - create sas host object
4715  * @ioc: per adapter object
4716  *
4717  * Creating host side data object, stored in ioc->sas_hba
4718  *
4719  * Return nothing.
4720  */
4721 static void
4722 _scsih_sas_host_add(struct MPT2SAS_ADAPTER *ioc)
4723 {
4724         int i;
4725         Mpi2ConfigReply_t mpi_reply;
4726         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
4727         Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
4728         Mpi2SasPhyPage0_t phy_pg0;
4729         Mpi2SasDevicePage0_t sas_device_pg0;
4730         Mpi2SasEnclosurePage0_t enclosure_pg0;
4731         u16 ioc_status;
4732         u16 sz;
4733         u16 device_missing_delay;
4734 
4735         mpt2sas_config_get_number_hba_phys(ioc, &ioc->sas_hba.num_phys);
4736         if (!ioc->sas_hba.num_phys) {
4737                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4738                     ioc->name, __FILE__, __LINE__, __func__);
4739                 return;
4740         }
4741 
4742         /* sas_iounit page 0 */
4743         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
4744             sizeof(Mpi2SasIOUnit0PhyData_t));
4745         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
4746         if (!sas_iounit_pg0) {
4747                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4748                     ioc->name, __FILE__, __LINE__, __func__);
4749                 return;
4750         }
4751         if ((mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4752             sas_iounit_pg0, sz))) {
4753                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4754                     ioc->name, __FILE__, __LINE__, __func__);
4755                 goto out;
4756         }
4757         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4758             MPI2_IOCSTATUS_MASK;
4759         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4760                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4761                     ioc->name, __FILE__, __LINE__, __func__);
4762                 goto out;
4763         }
4764 
4765         /* sas_iounit page 1 */
4766         sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
4767             sizeof(Mpi2SasIOUnit1PhyData_t));
4768         sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
4769         if (!sas_iounit_pg1) {
4770                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4771                     ioc->name, __FILE__, __LINE__, __func__);
4772                 goto out;
4773         }
4774         if ((mpt2sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
4775             sas_iounit_pg1, sz))) {
4776                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4777                     ioc->name, __FILE__, __LINE__, __func__);
4778                 goto out;
4779         }
4780         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4781             MPI2_IOCSTATUS_MASK;
4782         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4783                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4784                     ioc->name, __FILE__, __LINE__, __func__);
4785                 goto out;
4786         }
4787 
4788         ioc->io_missing_delay =
4789             le16_to_cpu(sas_iounit_pg1->IODeviceMissingDelay);
4790         device_missing_delay =
4791             le16_to_cpu(sas_iounit_pg1->ReportDeviceMissingDelay);
4792         if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16)
4793                 ioc->device_missing_delay = (device_missing_delay &
4794                     MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16;
4795         else
4796                 ioc->device_missing_delay = device_missing_delay &
4797                     MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
4798 
4799         ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
4800         ioc->sas_hba.phy = kcalloc(ioc->sas_hba.num_phys,
4801             sizeof(struct _sas_phy), GFP_KERNEL);
4802         if (!ioc->sas_hba.phy) {
4803                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4804                     ioc->name, __FILE__, __LINE__, __func__);
4805                 goto out;
4806         }
4807         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4808                 if ((mpt2sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
4809                     i))) {
4810                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4811                             ioc->name, __FILE__, __LINE__, __func__);
4812                         goto out;
4813                 }
4814                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4815                     MPI2_IOCSTATUS_MASK;
4816                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4817                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4818                             ioc->name, __FILE__, __LINE__, __func__);
4819                         goto out;
4820                 }
4821 
4822                 if (i == 0)
4823                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4824                             PhyData[0].ControllerDevHandle);
4825                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4826                 ioc->sas_hba.phy[i].phy_id = i;
4827                 mpt2sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
4828                     phy_pg0, ioc->sas_hba.parent_dev);
4829         }
4830         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4831             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
4832                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4833                     ioc->name, __FILE__, __LINE__, __func__);
4834                 goto out;
4835         }
4836         ioc->sas_hba.enclosure_handle =
4837             le16_to_cpu(sas_device_pg0.EnclosureHandle);
4838         ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
4839         printk(MPT2SAS_INFO_FMT "host_add: handle(0x%04x), "
4840             "sas_addr(0x%016llx), phys(%d)\n", ioc->name, ioc->sas_hba.handle,
4841             (unsigned long long) ioc->sas_hba.sas_address,
4842             ioc->sas_hba.num_phys) ;
4843 
4844         if (ioc->sas_hba.enclosure_handle) {
4845                 if (!(mpt2sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4846                     &enclosure_pg0,
4847                    MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
4848                    ioc->sas_hba.enclosure_handle))) {
4849                         ioc->sas_hba.enclosure_logical_id =
4850                             le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
4851                 }
4852         }
4853 
4854  out:
4855         kfree(sas_iounit_pg1);
4856         kfree(sas_iounit_pg0);
4857 }
4858 
4859 /**
4860  * _scsih_expander_add -  creating expander object
4861  * @ioc: per adapter object
4862  * @handle: expander handle
4863  *
4864  * Creating expander object, stored in ioc->sas_expander_list.
4865  *
4866  * Return 0 for success, else error.
4867  */
4868 static int
4869 _scsih_expander_add(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4870 {
4871         struct _sas_node *sas_expander;
4872         Mpi2ConfigReply_t mpi_reply;
4873         Mpi2ExpanderPage0_t expander_pg0;
4874         Mpi2ExpanderPage1_t expander_pg1;
4875         Mpi2SasEnclosurePage0_t enclosure_pg0;
4876         u32 ioc_status;
4877         u16 parent_handle;
4878         u64 sas_address, sas_address_parent = 0;
4879         int i;
4880         unsigned long flags;
4881         struct _sas_port *mpt2sas_port = NULL;
4882         int rc = 0;
4883 
4884         if (!handle)
4885                 return -1;
4886 
4887         if (ioc->shost_recovery || ioc->pci_error_recovery)
4888                 return -1;
4889 
4890         if ((mpt2sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
4891             MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) {
4892                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4893                     ioc->name, __FILE__, __LINE__, __func__);
4894                 return -1;
4895         }
4896 
4897         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4898             MPI2_IOCSTATUS_MASK;
4899         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4900                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4901                     ioc->name, __FILE__, __LINE__, __func__);
4902                 return -1;
4903         }
4904 
4905         /* handle out of order topology events */
4906         parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle);
4907         if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
4908             != 0) {
4909                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4910                     ioc->name, __FILE__, __LINE__, __func__);
4911                 return -1;
4912         }
4913         if (sas_address_parent != ioc->sas_hba.sas_address) {
4914                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4915                 sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
4916                     sas_address_parent);
4917                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4918                 if (!sas_expander) {
4919                         rc = _scsih_expander_add(ioc, parent_handle);
4920                         if (rc != 0)
4921                                 return rc;
4922                 }
4923         }
4924 
4925         spin_lock_irqsave(&ioc->sas_node_lock, flags);
4926         sas_address = le64_to_cpu(expander_pg0.SASAddress);
4927         sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
4928             sas_address);
4929         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4930 
4931         if (sas_expander)
4932                 return 0;
4933 
4934         sas_expander = kzalloc(sizeof(struct _sas_node),
4935             GFP_KERNEL);
4936         if (!sas_expander) {
4937                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4938                     ioc->name, __FILE__, __LINE__, __func__);
4939                 return -1;
4940         }
4941 
4942         sas_expander->handle = handle;
4943         sas_expander->num_phys = expander_pg0.NumPhys;
4944         sas_expander->sas_address_parent = sas_address_parent;
4945         sas_expander->sas_address = sas_address;
4946 
4947         printk(MPT2SAS_INFO_FMT "expander_add: handle(0x%04x),"
4948             " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name,
4949             handle, parent_handle, (unsigned long long)
4950             sas_expander->sas_address, sas_expander->num_phys);
4951 
4952         if (!sas_expander->num_phys)
4953                 goto out_fail;
4954         sas_expander->phy = kcalloc(sas_expander->num_phys,
4955             sizeof(struct _sas_phy), GFP_KERNEL);
4956         if (!sas_expander->phy) {
4957                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4958                     ioc->name, __FILE__, __LINE__, __func__);
4959                 rc = -1;
4960                 goto out_fail;
4961         }
4962 
4963         INIT_LIST_HEAD(&sas_expander->sas_port_list);
4964         mpt2sas_port = mpt2sas_transport_port_add(ioc, handle,
4965             sas_address_parent);
4966         if (!mpt2sas_port) {
4967                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4968                     ioc->name, __FILE__, __LINE__, __func__);
4969                 rc = -1;
4970                 goto out_fail;
4971         }
4972         sas_expander->parent_dev = &mpt2sas_port->rphy->dev;
4973 
4974         for (i = 0 ; i < sas_expander->num_phys ; i++) {
4975                 if ((mpt2sas_config_get_expander_pg1(ioc, &mpi_reply,
4976                     &expander_pg1, i, handle))) {
4977                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4978                             ioc->name, __FILE__, __LINE__, __func__);
4979                         rc = -1;
4980                         goto out_fail;
4981                 }
4982                 sas_expander->phy[i].handle = handle;
4983                 sas_expander->phy[i].phy_id = i;
4984 
4985                 if ((mpt2sas_transport_add_expander_phy(ioc,
4986                     &sas_expander->phy[i], expander_pg1,
4987                     sas_expander->parent_dev))) {
4988                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4989                             ioc->name, __FILE__, __LINE__, __func__);
4990                         rc = -1;
4991                         goto out_fail;
4992                 }
4993         }
4994 
4995         if (sas_expander->enclosure_handle) {
4996                 if (!(mpt2sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4997                     &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
4998                    sas_expander->enclosure_handle))) {
4999                         sas_expander->enclosure_logical_id =
5000                             le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
5001                 }
5002         }
5003 
5004         _scsih_expander_node_add(ioc, sas_expander);
5005          return 0;
5006 
5007  out_fail:
5008 
5009         if (mpt2sas_port)
5010                 mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
5011                     sas_address_parent);
5012         kfree(sas_expander);
5013         return rc;
5014 }
5015 
5016 /**
5017  * _scsih_done -  scsih callback handler.
5018  * @ioc: per adapter object
5019  * @smid: system request message index
5020  * @msix_index: MSIX table index supplied by the OS
5021  * @reply: reply message frame(lower 32bit addr)
5022  *
5023  * Callback handler when sending internal generated message frames.
5024  * The callback index passed is `ioc->scsih_cb_idx`
5025  *
5026  * Return 1 meaning mf should be freed from _base_interrupt
5027  *        0 means the mf is freed from this function.
5028  */
5029 static u8
5030 _scsih_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
5031 {
5032         MPI2DefaultReply_t *mpi_reply;
5033 
5034         mpi_reply =  mpt2sas_base_get_reply_virt_addr(ioc, reply);
5035         if (ioc->scsih_cmds.status == MPT2_CMD_NOT_USED)
5036                 return 1;
5037         if (ioc->scsih_cmds.smid != smid)
5038                 return 1;
5039         ioc->scsih_cmds.status |= MPT2_CMD_COMPLETE;
5040         if (mpi_reply) {
5041                 memcpy(ioc->scsih_cmds.reply, mpi_reply,
5042                     mpi_reply->MsgLength*4);
5043                 ioc->scsih_cmds.status |= MPT2_CMD_REPLY_VALID;
5044         }
5045         ioc->scsih_cmds.status &= ~MPT2_CMD_PENDING;
5046         complete(&ioc->scsih_cmds.done);
5047         return 1;
5048 }
5049 
5050 /**
5051  * mpt2sas_expander_remove - removing expander object
5052  * @ioc: per adapter object
5053  * @sas_address: expander sas_address
5054  *
5055  * Return nothing.
5056  */
5057 void
5058 mpt2sas_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
5059 {
5060         struct _sas_node *sas_expander;
5061         unsigned long flags;
5062 
5063         if (ioc->shost_recovery)
5064                 return;
5065 
5066         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5067         sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
5068             sas_address);
5069         if (sas_expander)
5070                 list_del(&sas_expander->list);
5071         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5072         if (sas_expander)
5073                 _scsih_expander_node_remove(ioc, sas_expander);
5074 }
5075 
5076 /**
5077  * _scsih_check_access_status - check access flags
5078  * @ioc: per adapter object
5079  * @sas_address: sas address
5080  * @handle: sas device handle
5081  * @access_flags: errors returned during discovery of the device
5082  *
5083  * Return 0 for success, else failure
5084  */
5085 static u8
5086 _scsih_check_access_status(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
5087    u16 handle, u8 access_status)
5088 {
5089         u8 rc = 1;
5090         char *desc = NULL;
5091 
5092         switch (access_status) {
5093         case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS:
5094         case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION:
5095                 rc = 0;
5096                 break;
5097         case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED:
5098                 desc = "sata capability failed";
5099                 break;
5100         case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT:
5101                 desc = "sata affiliation conflict";
5102                 break;
5103         case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE:
5104                 desc = "route not addressable";
5105                 break;
5106         case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE:
5107                 desc = "smp error not addressable";
5108                 break;
5109         case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED:
5110                 desc = "device blocked";
5111                 break;
5112         case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED:
5113         case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN:
5114         case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT:
5115         case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG:
5116         case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION:
5117         case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER:
5118         case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN:
5119         case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN:
5120         case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN:
5121         case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION:
5122         case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE:
5123         case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX:
5124                 desc = "sata initialization failed";
5125                 break;
5126         default:
5127                 desc = "unknown";
5128                 break;
5129         }
5130 
5131         if (!rc)
5132                 return 0;
5133 
5134         printk(MPT2SAS_ERR_FMT "discovery errors(%s): sas_address(0x%016llx), "
5135             "handle(0x%04x)\n", ioc->name, desc,
5136             (unsigned long long)sas_address, handle);
5137         return rc;
5138 }
5139 
5140 static void
5141 _scsih_check_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
5142 {
5143         Mpi2ConfigReply_t mpi_reply;
5144         Mpi2SasDevicePage0_t sas_device_pg0;
5145         struct _sas_device *sas_device;
5146         u32 ioc_status;
5147         unsigned long flags;
5148         u64 sas_address;
5149         struct scsi_target *starget;
5150         struct MPT2SAS_TARGET *sas_target_priv_data;
5151         u32 device_info;
5152 
5153 
5154         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5155             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)))
5156                 return;
5157 
5158         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
5159         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
5160                 return;
5161 
5162         /* check if this is end device */
5163         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5164         if (!(_scsih_is_end_device(device_info)))
5165                 return;
5166 
5167         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5168         sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5169         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5170             sas_address);
5171 
5172         if (!sas_device) {
5173                 printk(MPT2SAS_ERR_FMT "device is not present "
5174                     "handle(0x%04x), no sas_device!!!\n", ioc->name, handle);
5175                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5176                 return;
5177         }
5178 
5179         if (unlikely(sas_device->handle != handle)) {
5180                 starget = sas_device->starget;
5181                 sas_target_priv_data = starget->hostdata;
5182                 starget_printk(KERN_INFO, starget, "handle changed from(0x%04x)"
5183                    " to (0x%04x)!!!\n", sas_device->handle, handle);
5184                 sas_target_priv_data->handle = handle;
5185                 sas_device->handle = handle;
5186         }
5187 
5188         /* check if device is present */
5189         if (!(le16_to_cpu(sas_device_pg0.Flags) &
5190             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
5191                 printk(MPT2SAS_ERR_FMT "device is not present "
5192                     "handle(0x%04x), flags!!!\n", ioc->name, handle);
5193                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5194                 return;
5195         }
5196 
5197         /* check if there were any issues with discovery */
5198         if (_scsih_check_access_status(ioc, sas_address, handle,
5199             sas_device_pg0.AccessStatus)) {
5200                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5201                 return;
5202         }
5203         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5204         _scsih_ublock_io_device(ioc, sas_address);
5205 
5206 }
5207 
5208 /**
5209  * _scsih_add_device -  creating sas device object
5210  * @ioc: per adapter object
5211  * @handle: sas device handle
5212  * @phy_num: phy number end device attached to
5213  * @is_pd: is this hidden raid component
5214  *
5215  * Creating end device object, stored in ioc->sas_device_list.
5216  *
5217  * Returns 0 for success, non-zero for failure.
5218  */
5219 static int
5220 _scsih_add_device(struct MPT2SAS_ADAPTER *ioc, u16 handle, u8 phy_num, u8 is_pd)
5221 {
5222         Mpi2ConfigReply_t mpi_reply;
5223         Mpi2SasDevicePage0_t sas_device_pg0;
5224         Mpi2SasEnclosurePage0_t enclosure_pg0;
5225         struct _sas_device *sas_device;
5226         u32 ioc_status;
5227         __le64 sas_address;
5228         u32 device_info;
5229         unsigned long flags;
5230 
5231         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5232             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
5233                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5234                     ioc->name, __FILE__, __LINE__, __func__);
5235                 return -1;
5236         }
5237 
5238         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5239             MPI2_IOCSTATUS_MASK;
5240         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5241                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5242                     ioc->name, __FILE__, __LINE__, __func__);
5243                 return -1;
5244         }
5245 
5246         sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5247 
5248         /* check if device is present */
5249         if (!(le16_to_cpu(sas_device_pg0.Flags) &
5250             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
5251                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5252                     ioc->name, __FILE__, __LINE__, __func__);
5253                 printk(MPT2SAS_ERR_FMT "Flags = 0x%04x\n",
5254                     ioc->name, le16_to_cpu(sas_device_pg0.Flags));
5255                 return -1;
5256         }
5257 
5258         /* check if there were any issues with discovery */
5259         if (_scsih_check_access_status(ioc, sas_address, handle,
5260             sas_device_pg0.AccessStatus))
5261                 return -1;
5262 
5263         /* check if this is end device */
5264         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5265         if (!(_scsih_is_end_device(device_info))) {
5266                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5267                     ioc->name, __FILE__, __LINE__, __func__);
5268                 return -1;
5269         }
5270 
5271 
5272         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5273         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5274             sas_address);
5275         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5276 
5277         if (sas_device)
5278                 return 0;
5279 
5280         sas_device = kzalloc(sizeof(struct _sas_device),
5281             GFP_KERNEL);
5282         if (!sas_device) {
5283                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5284                     ioc->name, __FILE__, __LINE__, __func__);
5285                 return -1;
5286         }
5287 
5288         sas_device->handle = handle;
5289         if (_scsih_get_sas_address(ioc, le16_to_cpu
5290                 (sas_device_pg0.ParentDevHandle),
5291                 &sas_device->sas_address_parent) != 0)
5292                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5293                     ioc->name, __FILE__, __LINE__, __func__);
5294         sas_device->enclosure_handle =
5295             le16_to_cpu(sas_device_pg0.EnclosureHandle);
5296         sas_device->slot =
5297             le16_to_cpu(sas_device_pg0.Slot);
5298         sas_device->device_info = device_info;
5299         sas_device->sas_address = sas_address;
5300         sas_device->phy = sas_device_pg0.PhyNum;
5301 
5302         /* get enclosure_logical_id */
5303         if (sas_device->enclosure_handle && !(mpt2sas_config_get_enclosure_pg0(
5304            ioc, &mpi_reply, &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
5305            sas_device->enclosure_handle)))
5306                 sas_device->enclosure_logical_id =
5307                     le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
5308 
5309         /* get device name */
5310         sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName);
5311 
5312         if (ioc->wait_for_discovery_to_complete)
5313                 _scsih_sas_device_init_add(ioc, sas_device);
5314         else
5315                 _scsih_sas_device_add(ioc, sas_device);
5316 
5317         return 0;
5318 }
5319 
5320 /**
5321  * _scsih_remove_device -  removing sas device object
5322  * @ioc: per adapter object
5323  * @sas_device_delete: the sas_device object
5324  *
5325  * Return nothing.
5326  */
5327 static void
5328 _scsih_remove_device(struct MPT2SAS_ADAPTER *ioc,
5329     struct _sas_device *sas_device)
5330 {
5331         struct MPT2SAS_TARGET *sas_target_priv_data;
5332 
5333         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter: "
5334             "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
5335                 sas_device->handle, (unsigned long long)
5336             sas_device->sas_address));
5337 
5338         if (sas_device->starget && sas_device->starget->hostdata) {
5339                 sas_target_priv_data = sas_device->starget->hostdata;
5340                 sas_target_priv_data->deleted = 1;
5341                 _scsih_ublock_io_device(ioc, sas_device->sas_address);
5342                 sas_target_priv_data->handle =
5343                      MPT2SAS_INVALID_DEVICE_HANDLE;
5344         }
5345 
5346         if (!ioc->hide_drives)
5347                 mpt2sas_transport_port_remove(ioc,
5348                     sas_device->sas_address,
5349                     sas_device->sas_address_parent);
5350 
5351         printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), sas_addr"
5352             "(0x%016llx)\n", ioc->name, sas_device->handle,
5353             (unsigned long long) sas_device->sas_address);
5354 
5355         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: exit: "
5356             "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
5357             sas_device->handle, (unsigned long long)
5358             sas_device->sas_address));
5359         kfree(sas_device);
5360 }
5361 /**
5362  * _scsih_device_remove_by_handle - removing device object by handle
5363  * @ioc: per adapter object
5364  * @handle: device handle
5365  *
5366  * Return nothing.
5367  */
5368 static void
5369 _scsih_device_remove_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
5370 {
5371         struct _sas_device *sas_device;
5372         unsigned long flags;
5373 
5374         if (ioc->shost_recovery)
5375                 return;
5376 
5377         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5378         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5379         if (sas_device)
5380                 list_del(&sas_device->list);
5381         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5382         if (sas_device)
5383                 _scsih_remove_device(ioc, sas_device);
5384 }
5385 
5386 /**
5387  * mpt2sas_device_remove_by_sas_address - removing device object by sas address
5388  * @ioc: per adapter object
5389  * @sas_address: device sas_address
5390  *
5391  * Return nothing.
5392  */
5393 void
5394 mpt2sas_device_remove_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
5395         u64 sas_address)
5396 {
5397         struct _sas_device *sas_device;
5398         unsigned long flags;
5399 
5400         if (ioc->shost_recovery)
5401                 return;
5402 
5403         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5404         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5405             sas_address);
5406         if (sas_device)
5407                 list_del(&sas_device->list);
5408         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5409         if (sas_device)
5410                 _scsih_remove_device(ioc, sas_device);
5411 }
5412 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5413 /**
5414  * _scsih_sas_topology_change_event_debug - debug for topology event
5415  * @ioc: per adapter object
5416  * @event_data: event data payload
5417  * Context: user.
5418  */
5419 static void
5420 _scsih_sas_topology_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5421     Mpi2EventDataSasTopologyChangeList_t *event_data)
5422 {
5423         int i;
5424         u16 handle;
5425         u16 reason_code;
5426         u8 phy_number;
5427         char *status_str = NULL;
5428         u8 link_rate, prev_link_rate;
5429 
5430         switch (event_data->ExpStatus) {
5431         case MPI2_EVENT_SAS_TOPO_ES_ADDED:
5432                 status_str = "add";
5433                 break;
5434         case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING:
5435                 status_str = "remove";
5436                 break;
5437         case MPI2_EVENT_SAS_TOPO_ES_RESPONDING:
5438         case 0:
5439                 status_str =  "responding";
5440                 break;
5441         case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING:
5442                 status_str = "remove delay";
5443                 break;
5444         default:
5445                 status_str = "unknown status";
5446                 break;
5447         }
5448         printk(MPT2SAS_INFO_FMT "sas topology change: (%s)\n",
5449             ioc->name, status_str);
5450         printk(KERN_INFO "\thandle(0x%04x), enclosure_handle(0x%04x) "
5451             "start_phy(%02d), count(%d)\n",
5452             le16_to_cpu(event_data->ExpanderDevHandle),
5453             le16_to_cpu(event_data->EnclosureHandle),
5454             event_data->StartPhyNum, event_data->NumEntries);
5455         for (i = 0; i < event_data->NumEntries; i++) {
5456                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
5457                 if (!handle)
5458                         continue;
5459                 phy_number = event_data->StartPhyNum + i;
5460                 reason_code = event_data->PHY[i].PhyStatus &
5461                     MPI2_EVENT_SAS_TOPO_RC_MASK;
5462                 switch (reason_code) {
5463                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
5464                         status_str = "target add";
5465                         break;
5466                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
5467                         status_str = "target remove";
5468                         break;
5469                 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
5470                         status_str = "delay target remove";
5471                         break;
5472                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
5473                         status_str = "link rate change";
5474                         break;
5475                 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
5476                         status_str = "target responding";
5477                         break;
5478                 default:
5479                         status_str = "unknown";
5480                         break;
5481                 }
5482                 link_rate = event_data->PHY[i].LinkRate >> 4;
5483                 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
5484                 printk(KERN_INFO "\tphy(%02d), attached_handle(0x%04x): %s:"
5485                     " link rate: new(0x%02x), old(0x%02x)\n", phy_number,
5486                     handle, status_str, link_rate, prev_link_rate);
5487 
5488         }
5489 }
5490 #endif
5491 
5492 /**
5493  * _scsih_sas_topology_change_event - handle topology changes
5494  * @ioc: per adapter object
5495  * @fw_event: The fw_event_work object
5496  * Context: user.
5497  *
5498  */
5499 static void
5500 _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
5501     struct fw_event_work *fw_event)
5502 {
5503         int i;
5504         u16 parent_handle, handle;
5505         u16 reason_code;
5506         u8 phy_number, max_phys;
5507         struct _sas_node *sas_expander;
5508         u64 sas_address;
5509         unsigned long flags;
5510         u8 link_rate, prev_link_rate;
5511         Mpi2EventDataSasTopologyChangeList_t *event_data = fw_event->event_data;
5512 
5513 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5514         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5515                 _scsih_sas_topology_change_event_debug(ioc, event_data);
5516 #endif
5517 
5518         if (ioc->remove_host || ioc->pci_error_recovery)
5519                 return;
5520 
5521         if (!ioc->sas_hba.num_phys)
5522                 _scsih_sas_host_add(ioc);
5523         else
5524                 _scsih_sas_host_refresh(ioc);
5525 
5526         if (fw_event->ignore) {
5527                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "ignoring expander "
5528                     "event\n", ioc->name));
5529                 return;
5530         }
5531 
5532         parent_handle = le16_to_cpu(event_data->ExpanderDevHandle);
5533 
5534         /* handle expander add */
5535         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED)
5536                 if (_scsih_expander_add(ioc, parent_handle) != 0)
5537                         return;
5538 
5539         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5540         sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
5541             parent_handle);
5542         if (sas_expander) {
5543                 sas_address = sas_expander->sas_address;
5544                 max_phys = sas_expander->num_phys;
5545         } else if (parent_handle < ioc->sas_hba.num_phys) {
5546                 sas_address = ioc->sas_hba.sas_address;
5547                 max_phys = ioc->sas_hba.num_phys;
5548         } else {
5549         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5550                 return;
5551         }
5552         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5553 
5554         /* handle siblings events */
5555         for (i = 0; i < event_data->NumEntries; i++) {
5556                 if (fw_event->ignore) {
5557                         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "ignoring "
5558                             "expander event\n", ioc->name));
5559                         return;
5560                 }
5561                 if (ioc->shost_recovery || ioc->remove_host ||
5562                     ioc->pci_error_recovery)
5563                         return;
5564                 phy_number = event_data->StartPhyNum + i;
5565                 if (phy_number >= max_phys)
5566                         continue;
5567                 reason_code = event_data->PHY[i].PhyStatus &
5568                     MPI2_EVENT_SAS_TOPO_RC_MASK;
5569                 if ((event_data->PHY[i].PhyStatus &
5570                     MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code !=
5571                     MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING))
5572                         continue;
5573                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
5574                 if (!handle)
5575                         continue;
5576                 link_rate = event_data->PHY[i].LinkRate >> 4;
5577                 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
5578                 switch (reason_code) {
5579                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
5580 
5581                         if (ioc->shost_recovery)
5582                                 break;
5583 
5584                         if (link_rate == prev_link_rate)
5585                                 break;
5586 
5587                         mpt2sas_transport_update_links(ioc, sas_address,
5588                             handle, phy_number, link_rate);
5589 
5590                         if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
5591                                 break;
5592 
5593                         _scsih_check_device(ioc, handle);
5594                         break;
5595                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
5596 
5597                         if (ioc->shost_recovery)
5598                                 break;
5599 
5600                         mpt2sas_transport_update_links(ioc, sas_address,
5601                             handle, phy_number, link_rate);
5602 
5603                         _scsih_add_device(ioc, handle, phy_number, 0);
5604                         break;
5605                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
5606 
5607                         _scsih_device_remove_by_handle(ioc, handle);
5608                         break;
5609                 }
5610         }
5611 
5612         /* handle expander removal */
5613         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING &&
5614             sas_expander)
5615                 mpt2sas_expander_remove(ioc, sas_address);
5616 
5617 }
5618 
5619 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5620 /**
5621  * _scsih_sas_device_status_change_event_debug - debug for device event
5622  * @event_data: event data payload
5623  * Context: user.
5624  *
5625  * Return nothing.
5626  */
5627 static void
5628 _scsih_sas_device_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5629     Mpi2EventDataSasDeviceStatusChange_t *event_data)
5630 {
5631         char *reason_str = NULL;
5632 
5633         switch (event_data->ReasonCode) {
5634         case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
5635                 reason_str = "smart data";
5636                 break;
5637         case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
5638                 reason_str = "unsupported device discovered";
5639                 break;
5640         case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
5641                 reason_str = "internal device reset";
5642                 break;
5643         case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
5644                 reason_str = "internal task abort";
5645                 break;
5646         case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
5647                 reason_str = "internal task abort set";
5648                 break;
5649         case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
5650                 reason_str = "internal clear task set";
5651                 break;
5652         case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
5653                 reason_str = "internal query task";
5654                 break;
5655         case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE:
5656                 reason_str = "sata init failure";
5657                 break;
5658         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
5659                 reason_str = "internal device reset complete";
5660                 break;
5661         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
5662                 reason_str = "internal task abort complete";
5663                 break;
5664         case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
5665                 reason_str = "internal async notification";
5666                 break;
5667         case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY:
5668                 reason_str = "expander reduced functionality";
5669                 break;
5670         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY:
5671                 reason_str = "expander reduced functionality complete";
5672                 break;
5673         default:
5674                 reason_str = "unknown reason";
5675                 break;
5676         }
5677         printk(MPT2SAS_INFO_FMT "device status change: (%s)\n"
5678             "\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
5679             ioc->name, reason_str, le16_to_cpu(event_data->DevHandle),
5680             (unsigned long long)le64_to_cpu(event_data->SASAddress),
5681             le16_to_cpu(event_data->TaskTag));
5682         if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA)
5683                 printk(MPT2SAS_INFO_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
5684                     event_data->ASC, event_data->ASCQ);
5685         printk(KERN_INFO "\n");
5686 }
5687 #endif
5688 
5689 /**
5690  * _scsih_sas_device_status_change_event - handle device status change
5691  * @ioc: per adapter object
5692  * @fw_event: The fw_event_work object
5693  * Context: user.
5694  *
5695  * Return nothing.
5696  */
5697 static void
5698 _scsih_sas_device_status_change_event(struct MPT2SAS_ADAPTER *ioc,
5699     struct fw_event_work *fw_event)
5700 {
5701         struct MPT2SAS_TARGET *target_priv_data;
5702         struct _sas_device *sas_device;
5703         u64 sas_address;
5704         unsigned long flags;
5705         Mpi2EventDataSasDeviceStatusChange_t *event_data =
5706             fw_event->event_data;
5707 
5708 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5709         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5710                 _scsih_sas_device_status_change_event_debug(ioc,
5711                      event_data);
5712 #endif
5713 
5714         /* In MPI Revision K (0xC), the internal device reset complete was
5715          * implemented, so avoid setting tm_busy flag for older firmware.
5716          */
5717         if ((ioc->facts.HeaderVersion >> 8) < 0xC)
5718                 return;
5719 
5720         if (event_data->ReasonCode !=
5721             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
5722            event_data->ReasonCode !=
5723             MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET)
5724                 return;
5725 
5726         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5727         sas_address = le64_to_cpu(event_data->SASAddress);
5728         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5729             sas_address);
5730 
5731         if (!sas_device || !sas_device->starget) {
5732                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5733                 return;
5734         }
5735 
5736         target_priv_data = sas_device->starget->hostdata;
5737         if (!target_priv_data) {
5738                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5739                 return;
5740         }
5741 
5742         if (event_data->ReasonCode ==
5743             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
5744                 target_priv_data->tm_busy = 1;
5745         else
5746                 target_priv_data->tm_busy = 0;
5747         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5748 }
5749 
5750 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5751 /**
5752  * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure event
5753  * @ioc: per adapter object
5754  * @event_data: event data payload
5755  * Context: user.
5756  *
5757  * Return nothing.
5758  */
5759 static void
5760 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5761     Mpi2EventDataSasEnclDevStatusChange_t *event_data)
5762 {
5763         char *reason_str = NULL;
5764 
5765         switch (event_data->ReasonCode) {
5766         case MPI2_EVENT_SAS_ENCL_RC_ADDED:
5767                 reason_str = "enclosure add";
5768                 break;
5769         case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
5770                 reason_str = "enclosure remove";
5771                 break;
5772         default:
5773                 reason_str = "unknown reason";
5774                 break;
5775         }
5776 
5777         printk(MPT2SAS_INFO_FMT "enclosure status change: (%s)\n"
5778             "\thandle(0x%04x), enclosure logical id(0x%016llx)"
5779             " number slots(%d)\n", ioc->name, reason_str,
5780             le16_to_cpu(event_data->EnclosureHandle),
5781             (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID),
5782             le16_to_cpu(event_data->StartSlot));
5783 }
5784 #endif
5785 
5786 /**
5787  * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events
5788  * @ioc: per adapter object
5789  * @fw_event: The fw_event_work object
5790  * Context: user.
5791  *
5792  * Return nothing.
5793  */
5794 static void
5795 _scsih_sas_enclosure_dev_status_change_event(struct MPT2SAS_ADAPTER *ioc,
5796     struct fw_event_work *fw_event)
5797 {
5798 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5799         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5800                 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
5801                      fw_event->event_data);
5802 #endif
5803 }
5804 
5805 /**
5806  * _scsih_sas_broadcast_primitive_event - handle broadcast events
5807  * @ioc: per adapter object
5808  * @fw_event: The fw_event_work object
5809  * Context: user.
5810  *
5811  * Return nothing.
5812  */
5813 static void
5814 _scsih_sas_broadcast_primitive_event(struct MPT2SAS_ADAPTER *ioc,
5815     struct fw_event_work *fw_event)
5816 {
5817         struct scsi_cmnd *scmd;
5818         struct scsi_device *sdev;
5819         u16 smid, handle;
5820         u32 lun;
5821         struct MPT2SAS_DEVICE *sas_device_priv_data;
5822         u32 termination_count;
5823         u32 query_count;
5824         Mpi2SCSITaskManagementReply_t *mpi_reply;
5825         Mpi2EventDataSasBroadcastPrimitive_t *event_data = fw_event->event_data;
5826         u16 ioc_status;
5827         unsigned long flags;
5828         int r;
5829         u8 max_retries = 0;
5830         u8 task_abort_retries;
5831 
5832         mutex_lock(&ioc->tm_cmds.mutex);
5833         pr_info(MPT2SAS_FMT
5834                 "%s: enter: phy number(%d), width(%d)\n",
5835                 ioc->name, __func__, event_data->PhyNum,
5836                 event_data->PortWidth);
5837 
5838         _scsih_block_io_all_device(ioc);
5839 
5840         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5841         mpi_reply = ioc->tm_cmds.reply;
5842 broadcast_aen_retry:
5843 
5844         /* sanity checks for retrying this loop */
5845         if (max_retries++ == 5) {
5846                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: giving up\n",
5847                     ioc->name, __func__));
5848                 goto out;
5849         } else if (max_retries > 1)
5850                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: %d retry\n",
5851                     ioc->name, __func__, max_retries - 1));
5852 
5853         termination_count = 0;
5854         query_count = 0;
5855         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
5856                 if (ioc->shost_recovery)
5857                         goto out;
5858                 scmd = _scsih_scsi_lookup_get(ioc, smid);
5859                 if (!scmd)
5860                         continue;
5861                 sdev = scmd->device;
5862                 sas_device_priv_data = sdev->hostdata;
5863                 if (!sas_device_priv_data || !sas_device_priv_data->sas_target)
5864                         continue;
5865                  /* skip hidden raid components */
5866                 if (sas_device_priv_data->sas_target->flags &
5867                     MPT_TARGET_FLAGS_RAID_COMPONENT)
5868                         continue;
5869                  /* skip volumes */
5870                 if (sas_device_priv_data->sas_target->flags &
5871                     MPT_TARGET_FLAGS_VOLUME)
5872                         continue;
5873 
5874                 handle = sas_device_priv_data->sas_target->handle;
5875                 lun = sas_device_priv_data->lun;
5876                 query_count++;
5877 
5878                 if (ioc->shost_recovery)
5879                         goto out;
5880 
5881                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5882                 r = mpt2sas_scsih_issue_tm(ioc, handle, 0, 0, lun,
5883                     MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30, 0,
5884                     TM_MUTEX_OFF);
5885                 if (r == FAILED) {
5886                         sdev_printk(KERN_WARNING, sdev,
5887                             "mpt2sas_scsih_issue_tm: FAILED when sending "
5888                             "QUERY_TASK: scmd(%p)\n", scmd);
5889                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5890                         goto broadcast_aen_retry;
5891                 }
5892                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
5893                     & MPI2_IOCSTATUS_MASK;
5894                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5895                         sdev_printk(KERN_WARNING, sdev, "query task: FAILED "
5896                             "with IOCSTATUS(0x%04x), scmd(%p)\n", ioc_status,
5897                             scmd);
5898                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5899                         goto broadcast_aen_retry;
5900                 }
5901 
5902                 /* see if IO is still owned by IOC and target */
5903                 if (mpi_reply->ResponseCode ==
5904                      MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
5905                      mpi_reply->ResponseCode ==
5906                      MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) {
5907                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5908                         continue;
5909                 }
5910                 task_abort_retries = 0;
5911  tm_retry:
5912                 if (task_abort_retries++ == 60) {
5913                         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
5914                             "%s: ABORT_TASK: giving up\n", ioc->name,
5915                             __func__));
5916                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5917                         goto broadcast_aen_retry;
5918                 }
5919 
5920                 if (ioc->shost_recovery)
5921                         goto out_no_lock;
5922 
5923                 r = mpt2sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id,
5924                     sdev->lun, MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30,
5925                     scmd->serial_number, TM_MUTEX_OFF);
5926                 if (r == FAILED) {
5927                         sdev_printk(KERN_WARNING, sdev,
5928                             "mpt2sas_scsih_issue_tm: ABORT_TASK: FAILED : "
5929                             "scmd(%p)\n", scmd);
5930                         goto tm_retry;
5931                 }
5932 
5933                 if (task_abort_retries > 1)
5934                         sdev_printk(KERN_WARNING, sdev,
5935                             "mpt2sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):"
5936                             " scmd(%p)\n",
5937                             task_abort_retries - 1, scmd);
5938 
5939                 termination_count += le32_to_cpu(mpi_reply->TerminationCount);
5940                 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5941         }
5942 
5943         if (ioc->broadcast_aen_pending) {
5944                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: loop back due to"
5945                      " pending AEN\n", ioc->name, __func__));
5946                  ioc->broadcast_aen_pending = 0;
5947                  goto broadcast_aen_retry;
5948         }
5949 
5950  out:
5951         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5952  out_no_lock:
5953 
5954         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
5955             "%s - exit, query_count = %d termination_count = %d\n",
5956             ioc->name, __func__, query_count, termination_count));
5957 
5958         ioc->broadcast_aen_busy = 0;
5959         if (!ioc->shost_recovery)
5960                 _scsih_ublock_io_all_device(ioc);
5961         mutex_unlock(&ioc->tm_cmds.mutex);
5962 }
5963 
5964 /**
5965  * _scsih_sas_discovery_event - handle discovery events
5966  * @ioc: per adapter object
5967  * @fw_event: The fw_event_work object
5968  * Context: user.
5969  *
5970  * Return nothing.
5971  */
5972 static void
5973 _scsih_sas_discovery_event(struct MPT2SAS_ADAPTER *ioc,
5974     struct fw_event_work *fw_event)
5975 {
5976         Mpi2EventDataSasDiscovery_t *event_data = fw_event->event_data;
5977 
5978 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5979         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
5980                 printk(MPT2SAS_INFO_FMT "discovery event: (%s)", ioc->name,
5981                     (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ?
5982                     "start" : "stop");
5983         if (event_data->DiscoveryStatus)
5984                 printk("discovery_status(0x%08x)",
5985                     le32_to_cpu(event_data->DiscoveryStatus));
5986         printk("\n");
5987         }
5988 #endif
5989 
5990         if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
5991             !ioc->sas_hba.num_phys) {
5992                 if (disable_discovery > 0 && ioc->shost_recovery) {
5993                         /* Wait for the reset to complete */
5994                         while (ioc->shost_recovery)
5995                                 ssleep(1);
5996                 }
5997                 _scsih_sas_host_add(ioc);
5998         }
5999 }
6000 
6001 /**
6002  * _scsih_reprobe_lun - reprobing lun
6003  * @sdev: scsi device struct
6004  * @no_uld_attach: sdev->no_uld_attach flag setting
6005  *
6006  **/
6007 static void
6008 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
6009 {
6010         int rc;
6011 
6012         sdev->no_uld_attach = no_uld_attach ? 1 : 0;
6013         sdev_printk(KERN_INFO, sdev, "%s raid component\n",
6014             sdev->no_uld_attach ? "hidding" : "exposing");
6015         rc = scsi_device_reprobe(sdev);
6016 }
6017 
6018 /**
6019  * _scsih_sas_volume_add - add new volume
6020  * @ioc: per adapter object
6021  * @element: IR config element data
6022  * Context: user.
6023  *
6024  * Return nothing.
6025  */
6026 static void
6027 _scsih_sas_volume_add(struct MPT2SAS_ADAPTER *ioc,
6028     Mpi2EventIrConfigElement_t *element)
6029 {
6030         struct _raid_device *raid_device;
6031         unsigned long flags;
6032         u64 wwid;
6033         u16 handle = le16_to_cpu(element->VolDevHandle);
6034         int rc;
6035 
6036         mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
6037         if (!wwid) {
6038                 printk(MPT2SAS_ERR_FMT
6039                     "failure at %s:%d/%s()!\n", ioc->name,
6040                     __FILE__, __LINE__, __func__);
6041                 return;
6042         }
6043 
6044         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6045         raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
6046         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6047 
6048         if (raid_device)
6049                 return;
6050 
6051         raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
6052         if (!raid_device) {
6053                 printk(MPT2SAS_ERR_FMT
6054                     "failure at %s:%d/%s()!\n", ioc->name,
6055                     __FILE__, __LINE__, __func__);
6056                 return;
6057         }
6058 
6059         raid_device->id = ioc->sas_id++;
6060         raid_device->channel = RAID_CHANNEL;
6061         raid_device->handle = handle;
6062         raid_device->wwid = wwid;
6063         _scsih_raid_device_add(ioc, raid_device);
6064         if (!ioc->wait_for_discovery_to_complete) {
6065                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6066                     raid_device->id, 0);
6067                 if (rc)
6068                         _scsih_raid_device_remove(ioc, raid_device);
6069         } else {
6070                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6071                 _scsih_determine_boot_device(ioc, raid_device, 1);
6072                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6073         }
6074 }
6075 
6076 /**
6077  * _scsih_sas_volume_delete - delete volume
6078  * @ioc: per adapter object
6079  * @handle: volume device handle
6080  * Context: user.
6081  *
6082  * Return nothing.
6083  */
6084 static void
6085 _scsih_sas_volume_delete(struct MPT2SAS_ADAPTER *ioc, u16 handle)
6086 {
6087         struct _raid_device *raid_device;
6088         unsigned long flags;
6089         struct MPT2SAS_TARGET *sas_target_priv_data;
6090         struct scsi_target *starget = NULL;
6091 
6092         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6093         raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6094         if (raid_device) {
6095                 if (raid_device->starget) {
6096                         starget = raid_device->starget;
6097                         sas_target_priv_data = starget->hostdata;
6098                         sas_target_priv_data->deleted = 1;
6099                 }
6100                 printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), wwid"
6101                     "(0x%016llx)\n", ioc->name,  raid_device->handle,
6102                     (unsigned long long) raid_device->wwid);
6103                 list_del(&raid_device->list);
6104                 kfree(raid_device);
6105         }
6106         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6107         if (starget)
6108                 scsi_remove_target(&starget->dev);
6109 }
6110 
6111 /**
6112  * _scsih_sas_pd_expose - expose pd component to /dev/sdX
6113  * @ioc: per adapter object
6114  * @element: IR config element data
6115  * Context: user.
6116  *
6117  * Return nothing.
6118  */
6119 static void
6120 _scsih_sas_pd_expose(struct MPT2SAS_ADAPTER *ioc,
6121     Mpi2EventIrConfigElement_t *element)
6122 {
6123         struct _sas_device *sas_device;
6124         struct scsi_target *starget = NULL;
6125         struct MPT2SAS_TARGET *sas_target_priv_data;
6126         unsigned long flags;
6127         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6128 
6129         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6130         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6131         if (sas_device) {
6132                 sas_device->volume_handle = 0;
6133                 sas_device->volume_wwid = 0;
6134                 clear_bit(handle, ioc->pd_handles);
6135                 if (sas_device->starget && sas_device->starget->hostdata) {
6136                         starget = sas_device->starget;
6137                         sas_target_priv_data = starget->hostdata;
6138                         sas_target_priv_data->flags &=
6139                             ~MPT_TARGET_FLAGS_RAID_COMPONENT;
6140                 }
6141         }
6142         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6143         if (!sas_device)
6144                 return;
6145 
6146         /* exposing raid component */
6147         if (starget)
6148                 starget_for_each_device(starget, NULL, _scsih_reprobe_lun);
6149 }
6150 
6151 /**
6152  * _scsih_sas_pd_hide - hide pd component from /dev/sdX
6153  * @ioc: per adapter object
6154  * @element: IR config element data
6155  * Context: user.
6156  *
6157  * Return nothing.
6158  */
6159 static void
6160 _scsih_sas_pd_hide(struct MPT2SAS_ADAPTER *ioc,
6161     Mpi2EventIrConfigElement_t *element)
6162 {
6163         struct _sas_device *sas_device;
6164         struct scsi_target *starget = NULL;
6165         struct MPT2SAS_TARGET *sas_target_priv_data;
6166         unsigned long flags;
6167         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6168         u16 volume_handle = 0;
6169         u64 volume_wwid = 0;
6170 
6171         mpt2sas_config_get_volume_handle(ioc, handle, &volume_handle);
6172         if (volume_handle)
6173                 mpt2sas_config_get_volume_wwid(ioc, volume_handle,
6174                     &volume_wwid);
6175 
6176         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6177         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6178         if (sas_device) {
6179                 set_bit(handle, ioc->pd_handles);
6180                 if (sas_device->starget && sas_device->starget->hostdata) {
6181                         starget = sas_device->starget;
6182                         sas_target_priv_data = starget->hostdata;
6183                         sas_target_priv_data->flags |=
6184                             MPT_TARGET_FLAGS_RAID_COMPONENT;
6185                         sas_device->volume_handle = volume_handle;
6186                         sas_device->volume_wwid = volume_wwid;
6187                 }
6188         }
6189         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6190         if (!sas_device)
6191                 return;
6192 
6193         /* hiding raid component */
6194         if (starget)
6195                 starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun);
6196 }
6197 
6198 /**
6199  * _scsih_sas_pd_delete - delete pd component
6200  * @ioc: per adapter object
6201  * @element: IR config element data
6202  * Context: user.
6203  *
6204  * Return nothing.
6205  */
6206 static void
6207 _scsih_sas_pd_delete(struct MPT2SAS_ADAPTER *ioc,
6208     Mpi2EventIrConfigElement_t *element)
6209 {
6210         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6211 
6212         _scsih_device_remove_by_handle(ioc, handle);
6213 }
6214 
6215 /**
6216  * _scsih_sas_pd_add - remove pd component
6217  * @ioc: per adapter object
6218  * @element: IR config element data
6219  * Context: user.
6220  *
6221  * Return nothing.
6222  */
6223 static void
6224 _scsih_sas_pd_add(struct MPT2SAS_ADAPTER *ioc,
6225     Mpi2EventIrConfigElement_t *element)
6226 {
6227         struct _sas_device *sas_device;
6228         unsigned long flags;
6229         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6230         Mpi2ConfigReply_t mpi_reply;
6231         Mpi2SasDevicePage0_t sas_device_pg0;
6232         u32 ioc_status;
6233         u64 sas_address;
6234         u16 parent_handle;
6235 
6236         set_bit(handle, ioc->pd_handles);
6237 
6238         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6239         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6240         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6241         if (sas_device)
6242                 return;
6243 
6244         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
6245             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
6246                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6247                     ioc->name, __FILE__, __LINE__, __func__);
6248                 return;
6249         }
6250 
6251         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6252             MPI2_IOCSTATUS_MASK;
6253         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6254                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6255                     ioc->name, __FILE__, __LINE__, __func__);
6256                 return;
6257         }
6258 
6259         parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6260         if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6261                 mpt2sas_transport_update_links(ioc, sas_address, handle,
6262                     sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
6263 
6264         _scsih_add_device(ioc, handle, 0, 1);
6265 }
6266 
6267 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
6268 /**
6269  * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events
6270  * @ioc: per adapter object
6271  * @event_data: event data payload
6272  * Context: user.
6273  *
6274  * Return nothing.
6275  */
6276 static void
6277 _scsih_sas_ir_config_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
6278     Mpi2EventDataIrConfigChangeList_t *event_data)
6279 {
6280         Mpi2EventIrConfigElement_t *element;
6281         u8 element_type;
6282         int i;
6283         char *reason_str = NULL, *element_str = NULL;
6284 
6285         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
6286 
6287         printk(MPT2SAS_INFO_FMT "raid config change: (%s), elements(%d)\n",
6288             ioc->name, (le32_to_cpu(event_data->Flags) &
6289             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ?
6290             "foreign" : "native", event_data->NumElements);
6291         for (i = 0; i < event_data->NumElements; i++, element++) {
6292                 switch (element->ReasonCode) {
6293                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
6294                         reason_str = "add";
6295                         break;
6296                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
6297                         reason_str = "remove";
6298                         break;
6299                 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:
6300                         reason_str = "no change";
6301                         break;
6302                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
6303                         reason_str = "hide";
6304                         break;
6305                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
6306                         reason_str = "unhide";
6307                         break;
6308                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
6309                         reason_str = "volume_created";
6310                         break;
6311                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
6312                         reason_str = "volume_deleted";
6313                         break;
6314                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
6315                         reason_str = "pd_created";
6316                         break;
6317                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
6318                         reason_str = "pd_deleted";
6319                         break;
6320                 default:
6321                         reason_str = "unknown reason";
6322                         break;
6323                 }
6324                 element_type = le16_to_cpu(element->ElementFlags) &
6325                     MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
6326                 switch (element_type) {
6327                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:
6328                         element_str = "volume";
6329                         break;
6330                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:
6331                         element_str = "phys disk";
6332                         break;
6333                 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:
6334                         element_str = "hot spare";
6335                         break;
6336                 default:
6337                         element_str = "unknown element";
6338                         break;
6339                 }
6340                 printk(KERN_INFO "\t(%s:%s), vol handle(0x%04x), "
6341                     "pd handle(0x%04x), pd num(0x%02x)\n", element_str,
6342                     reason_str, le16_to_cpu(element->VolDevHandle),
6343                     le16_to_cpu(element->PhysDiskDevHandle),
6344                     element->PhysDiskNum);
6345         }
6346 }
6347 #endif
6348 
6349 /**
6350  * _scsih_sas_ir_config_change_event - handle ir configuration change events
6351  * @ioc: per adapter object
6352  * @fw_event: The fw_event_work object
6353  * Context: user.
6354  *
6355  * Return nothing.
6356  */
6357 static void
6358 _scsih_sas_ir_config_change_event(struct MPT2SAS_ADAPTER *ioc,
6359     struct fw_event_work *fw_event)
6360 {
6361         Mpi2EventIrConfigElement_t *element;
6362         int i;
6363         u8 foreign_config;
6364         Mpi2EventDataIrConfigChangeList_t *event_data = fw_event->event_data;
6365 
6366 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
6367         if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6368             && !ioc->hide_ir_msg)
6369                 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
6370 
6371 #endif
6372 
6373         if (ioc->shost_recovery)
6374                 return;
6375 
6376         foreign_config = (le32_to_cpu(event_data->Flags) &
6377             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
6378 
6379         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
6380         for (i = 0; i < event_data->NumElements; i++, element++) {
6381 
6382                 switch (element->ReasonCode) {
6383                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
6384                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
6385                         if (!foreign_config)
6386                                 _scsih_sas_volume_add(ioc, element);
6387                         break;
6388                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
6389                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
6390                         if (!foreign_config)
6391                                 _scsih_sas_volume_delete(ioc,
6392                                     le16_to_cpu(element->VolDevHandle));
6393                         break;
6394                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
6395                         if (!ioc->is_warpdrive)
6396                                 _scsih_sas_pd_hide(ioc, element);
6397                         break;
6398                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
6399                         if (!ioc->is_warpdrive)
6400                                 _scsih_sas_pd_expose(ioc, element);
6401                         break;
6402                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
6403                         if (!ioc->is_warpdrive)
6404                                 _scsih_sas_pd_add(ioc, element);
6405                         break;
6406                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
6407                         if (!ioc->is_warpdrive)
6408                                 _scsih_sas_pd_delete(ioc, element);
6409                         break;
6410                 }
6411         }
6412 }
6413 
6414 /**
6415  * _scsih_sas_ir_volume_event - IR volume event
6416  * @ioc: per adapter object
6417  * @fw_event: The fw_event_work object
6418  * Context: user.
6419  *
6420  * Return nothing.
6421  */
6422 static void
6423 _scsih_sas_ir_volume_event(struct MPT2SAS_ADAPTER *ioc,
6424     struct fw_event_work *fw_event)
6425 {
6426         u64 wwid;
6427         unsigned long flags;
6428         struct _raid_device *raid_device;
6429         u16 handle;
6430         u32 state;
6431         int rc;
6432         Mpi2EventDataIrVolume_t *event_data = fw_event->event_data;
6433 
6434         if (ioc->shost_recovery)
6435                 return;
6436 
6437         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
6438                 return;
6439 
6440         handle = le16_to_cpu(event_data->VolDevHandle);
6441         state = le32_to_cpu(event_data->NewValue);
6442         if (!ioc->hide_ir_msg)
6443                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
6444                     "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
6445                     le32_to_cpu(event_data->PreviousValue), state));
6446 
6447         switch (state) {
6448         case MPI2_RAID_VOL_STATE_MISSING:
6449         case MPI2_RAID_VOL_STATE_FAILED:
6450                 _scsih_sas_volume_delete(ioc, handle);
6451                 break;
6452 
6453         case MPI2_RAID_VOL_STATE_ONLINE:
6454         case MPI2_RAID_VOL_STATE_DEGRADED:
6455         case MPI2_RAID_VOL_STATE_OPTIMAL:
6456 
6457                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6458                 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6459                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6460 
6461                 if (raid_device)
6462                         break;
6463 
6464                 mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
6465                 if (!wwid) {
6466                         printk(MPT2SAS_ERR_FMT
6467                             "failure at %s:%d/%s()!\n", ioc->name,
6468                             __FILE__, __LINE__, __func__);
6469                         break;
6470                 }
6471 
6472                 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
6473                 if (!raid_device) {
6474                         printk(MPT2SAS_ERR_FMT
6475                             "failure at %s:%d/%s()!\n", ioc->name,
6476                             __FILE__, __LINE__, __func__);
6477                         break;
6478                 }
6479 
6480                 raid_device->id = ioc->sas_id++;
6481                 raid_device->channel = RAID_CHANNEL;
6482                 raid_device->handle = handle;
6483                 raid_device->wwid = wwid;
6484                 _scsih_raid_device_add(ioc, raid_device);
6485                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6486                     raid_device->id, 0);
6487                 if (rc)
6488                         _scsih_raid_device_remove(ioc, raid_device);
6489                 break;
6490 
6491         case MPI2_RAID_VOL_STATE_INITIALIZING:
6492         default:
6493                 break;
6494         }
6495 }
6496 
6497 /**
6498  * _scsih_sas_ir_physical_disk_event - PD event
6499  * @ioc: per adapter object
6500  * @fw_event: The fw_event_work object
6501  * Context: user.
6502  *
6503  * Return nothing.
6504  */
6505 static void
6506 _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
6507     struct fw_event_work *fw_event)
6508 {
6509         u16 handle, parent_handle;
6510         u32 state;
6511         struct _sas_device *sas_device;
6512         unsigned long flags;
6513         Mpi2ConfigReply_t mpi_reply;
6514         Mpi2SasDevicePage0_t sas_device_pg0;
6515         u32 ioc_status;
6516         Mpi2EventDataIrPhysicalDisk_t *event_data = fw_event->event_data;
6517         u64 sas_address;
6518 
6519         if (ioc->shost_recovery)
6520                 return;
6521 
6522         if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
6523                 return;
6524 
6525         handle = le16_to_cpu(event_data->PhysDiskDevHandle);
6526         state = le32_to_cpu(event_data->NewValue);
6527 
6528         if (!ioc->hide_ir_msg)
6529                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
6530                     "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
6531                     le32_to_cpu(event_data->PreviousValue), state));
6532 
6533         switch (state) {
6534         case MPI2_RAID_PD_STATE_ONLINE:
6535         case MPI2_RAID_PD_STATE_DEGRADED:
6536         case MPI2_RAID_PD_STATE_REBUILDING:
6537         case MPI2_RAID_PD_STATE_OPTIMAL:
6538         case MPI2_RAID_PD_STATE_HOT_SPARE:
6539 
6540                 if (!ioc->is_warpdrive)
6541                         set_bit(handle, ioc->pd_handles);
6542 
6543                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6544                 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6545                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6546 
6547                 if (sas_device)
6548                         return;
6549 
6550                 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6551                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
6552                     handle))) {
6553                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6554                             ioc->name, __FILE__, __LINE__, __func__);
6555                         return;
6556                 }
6557 
6558                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6559                     MPI2_IOCSTATUS_MASK;
6560                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6561                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6562                             ioc->name, __FILE__, __LINE__, __func__);
6563                         return;
6564                 }
6565 
6566                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6567                 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6568                         mpt2sas_transport_update_links(ioc, sas_address, handle,
6569                             sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
6570 
6571                 _scsih_add_device(ioc, handle, 0, 1);
6572 
6573                 break;
6574 
6575         case MPI2_RAID_PD_STATE_OFFLINE:
6576         case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
6577         case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
6578         default:
6579                 break;
6580         }
6581 }
6582 
6583 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
6584 /**
6585  * _scsih_sas_ir_operation_status_event_debug - debug for IR op event
6586  * @ioc: per adapter object
6587  * @event_data: event data payload
6588  * Context: user.
6589  *
6590  * Return nothing.
6591  */
6592 static void
6593 _scsih_sas_ir_operation_status_event_debug(struct MPT2SAS_ADAPTER *ioc,
6594     Mpi2EventDataIrOperationStatus_t *event_data)
6595 {
6596         char *reason_str = NULL;
6597 
6598         switch (event_data->RAIDOperation) {
6599         case MPI2_EVENT_IR_RAIDOP_RESYNC:
6600                 reason_str = "resync";
6601                 break;
6602         case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:
6603                 reason_str = "online capacity expansion";
6604                 break;
6605         case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
6606                 reason_str = "consistency check";
6607                 break;
6608         case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:
6609                 reason_str = "background init";
6610                 break;
6611         case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:
6612                 reason_str = "make data consistent";
6613                 break;
6614         }
6615 
6616         if (!reason_str)
6617                 return;
6618 
6619         printk(MPT2SAS_INFO_FMT "raid operational status: (%s)"
6620             "\thandle(0x%04x), percent complete(%d)\n",
6621             ioc->name, reason_str,
6622             le16_to_cpu(event_data->VolDevHandle),
6623             event_data->PercentComplete);
6624 }
6625 #endif
6626 
6627 /**
6628  * _scsih_sas_ir_operation_status_event - handle RAID operation events
6629  * @ioc: per adapter object
6630  * @fw_event: The fw_event_work object
6631  * Context: user.
6632  *
6633  * Return nothing.
6634  */
6635 static void
6636 _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
6637     struct fw_event_work *fw_event)
6638 {
6639         Mpi2EventDataIrOperationStatus_t *event_data = fw_event->event_data;
6640         static struct _raid_device *raid_device;
6641         unsigned long flags;
6642         u16 handle;
6643 
6644 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
6645         if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6646             && !ioc->hide_ir_msg)
6647                 _scsih_sas_ir_operation_status_event_debug(ioc,
6648                      event_data);
6649 #endif
6650 
6651         /* code added for raid transport support */
6652         if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
6653 
6654                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6655                 handle = le16_to_cpu(event_data->VolDevHandle);
6656                 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6657                 if (raid_device)
6658                         raid_device->percent_complete =
6659                             event_data->PercentComplete;
6660                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6661         }
6662 }
6663 
6664 /**
6665  * _scsih_prep_device_scan - initialize parameters prior to device scan
6666  * @ioc: per adapter object
6667  *
6668  * Set the deleted flag prior to device scan.  If the device is found during
6669  * the scan, then we clear the deleted flag.
6670  */
6671 static void
6672 _scsih_prep_device_scan(struct MPT2SAS_ADAPTER *ioc)
6673 {
6674         struct MPT2SAS_DEVICE *sas_device_priv_data;
6675         struct scsi_device *sdev;
6676 
6677         shost_for_each_device(sdev, ioc->shost) {
6678                 sas_device_priv_data = sdev->hostdata;
6679                 if (sas_device_priv_data && sas_device_priv_data->sas_target)
6680                         sas_device_priv_data->sas_target->deleted = 1;
6681         }
6682 }
6683 
6684 /**
6685  * _scsih_mark_responding_sas_device - mark a sas_devices as responding
6686  * @ioc: per adapter object
6687  * @sas_address: sas address
6688  * @slot: enclosure slot id
6689  * @handle: device handle
6690  *
6691  * After host reset, find out whether devices are still responding.
6692  * Used in _scsi_remove_unresponsive_sas_devices.
6693  *
6694  * Return nothing.
6695  */
6696 static void
6697 _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
6698     u16 slot, u16 handle)
6699 {
6700         struct MPT2SAS_TARGET *sas_target_priv_data = NULL;
6701         struct scsi_target *starget;
6702         struct _sas_device *sas_device;
6703         unsigned long flags;
6704 
6705         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6706         list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
6707                 if (sas_device->sas_address == sas_address &&
6708                     sas_device->slot == slot) {
6709                         sas_device->responding = 1;
6710                         starget = sas_device->starget;
6711                         if (starget && starget->hostdata) {
6712                                 sas_target_priv_data = starget->hostdata;
6713                                 sas_target_priv_data->tm_busy = 0;
6714                                 sas_target_priv_data->deleted = 0;
6715                         } else
6716                                 sas_target_priv_data = NULL;
6717                         if (starget)
6718                                 starget_printk(KERN_INFO, starget,
6719                                     "handle(0x%04x), sas_addr(0x%016llx), "
6720                                     "enclosure logical id(0x%016llx), "
6721                                     "slot(%d)\n", handle,
6722                                     (unsigned long long)sas_device->sas_address,
6723                                     (unsigned long long)
6724                                     sas_device->enclosure_logical_id,
6725                                     sas_device->slot);
6726                         if (sas_device->handle == handle)
6727                                 goto out;
6728                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
6729                             sas_device->handle);
6730                         sas_device->handle = handle;
6731                         if (sas_target_priv_data)
6732                                 sas_target_priv_data->handle = handle;
6733                         goto out;
6734                 }
6735         }
6736  out:
6737         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6738 }
6739 
6740 /**
6741  * _scsih_search_responding_sas_devices -
6742  * @ioc: per adapter object
6743  *
6744  * After host reset, find out whether devices are still responding.
6745  * If not remove.
6746  *
6747  * Return nothing.
6748  */
6749 static void
6750 _scsih_search_responding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
6751 {
6752         Mpi2SasDevicePage0_t sas_device_pg0;
6753         Mpi2ConfigReply_t mpi_reply;
6754         u16 ioc_status;
6755         __le64 sas_address;
6756         u16 handle;
6757         u32 device_info;
6758         u16 slot;
6759 
6760         printk(MPT2SAS_INFO_FMT "search for end-devices: start\n", ioc->name);
6761 
6762         if (list_empty(&ioc->sas_device_list))
6763                 goto out;
6764 
6765         handle = 0xFFFF;
6766         while (!(mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6767             &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
6768             handle))) {
6769                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6770                     MPI2_IOCSTATUS_MASK;
6771                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
6772                         break;
6773                 handle = le16_to_cpu(sas_device_pg0.DevHandle);
6774                 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
6775                 if (!(_scsih_is_end_device(device_info)))
6776                         continue;
6777                 sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
6778                 slot = le16_to_cpu(sas_device_pg0.Slot);
6779                 _scsih_mark_responding_sas_device(ioc, sas_address, slot,
6780                     handle);
6781         }
6782 out:
6783         printk(MPT2SAS_INFO_FMT "search for end-devices: complete\n",
6784             ioc->name);
6785 }
6786 
6787 /**
6788  * _scsih_mark_responding_raid_device - mark a raid_device as responding
6789  * @ioc: per adapter object
6790  * @wwid: world wide identifier for raid volume
6791  * @handle: device handle
6792  *
6793  * After host reset, find out whether devices are still responding.
6794  * Used in _scsi_remove_unresponsive_raid_devices.
6795  *
6796  * Return nothing.
6797  */
6798 static void
6799 _scsih_mark_responding_raid_device(struct MPT2SAS_ADAPTER *ioc, u64 wwid,
6800     u16 handle)
6801 {
6802         struct MPT2SAS_TARGET *sas_target_priv_data;
6803         struct scsi_target *starget;
6804         struct _raid_device *raid_device;
6805         unsigned long flags;
6806 
6807         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6808         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
6809                 if (raid_device->wwid == wwid && raid_device->starget) {
6810                         starget = raid_device->starget;
6811                         if (starget && starget->hostdata) {
6812                                 sas_target_priv_data = starget->hostdata;
6813                                 sas_target_priv_data->deleted = 0;
6814                         } else
6815                                 sas_target_priv_data = NULL;
6816                         raid_device->responding = 1;
6817                         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6818                         starget_printk(KERN_INFO, raid_device->starget,
6819                             "handle(0x%04x), wwid(0x%016llx)\n", handle,
6820                             (unsigned long long)raid_device->wwid);
6821                         /*
6822                          * WARPDRIVE: The handles of the PDs might have changed
6823                          * across the host reset so re-initialize the
6824                          * required data for Direct IO
6825                          */
6826                         _scsih_init_warpdrive_properties(ioc, raid_device);
6827                         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6828                         if (raid_device->handle == handle) {
6829                                 spin_unlock_irqrestore(&ioc->raid_device_lock,
6830                                     flags);
6831                                 return;
6832                         }
6833                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
6834                             raid_device->handle);
6835                         raid_device->handle = handle;
6836                         if (sas_target_priv_data)
6837                                 sas_target_priv_data->handle = handle;
6838                         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6839                         return;
6840                 }
6841         }
6842 
6843         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6844 }
6845 
6846 /**
6847  * _scsih_search_responding_raid_devices -
6848  * @ioc: per adapter object
6849  *
6850  * After host reset, find out whether devices are still responding.
6851  * If not remove.
6852  *
6853  * Return nothing.
6854  */
6855 static void
6856 _scsih_search_responding_raid_devices(struct MPT2SAS_ADAPTER *ioc)
6857 {
6858         Mpi2RaidVolPage1_t volume_pg1;
6859         Mpi2RaidVolPage0_t volume_pg0;
6860         Mpi2RaidPhysDiskPage0_t pd_pg0;
6861         Mpi2ConfigReply_t mpi_reply;
6862         u16 ioc_status;
6863         u16 handle;
6864         u8 phys_disk_num;
6865 
6866         if (!ioc->ir_firmware)
6867                 return;
6868 
6869         printk(MPT2SAS_INFO_FMT "search for raid volumes: start\n",
6870             ioc->name);
6871 
6872         if (list_empty(&ioc->raid_device_list))
6873                 goto out;
6874 
6875         handle = 0xFFFF;
6876         while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
6877             &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
6878                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6879                     MPI2_IOCSTATUS_MASK;
6880                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
6881                         break;
6882                 handle = le16_to_cpu(volume_pg1.DevHandle);
6883 
6884                 if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
6885                     &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
6886                      sizeof(Mpi2RaidVolPage0_t)))
6887                         continue;
6888 
6889                 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
6890                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
6891                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED)
6892                         _scsih_mark_responding_raid_device(ioc,
6893                             le64_to_cpu(volume_pg1.WWID), handle);
6894         }
6895 
6896         /* refresh the pd_handles */
6897         if (!ioc->is_warpdrive) {
6898                 phys_disk_num = 0xFF;
6899                 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
6900                 while (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
6901                     &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
6902                     phys_disk_num))) {
6903                         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6904                             MPI2_IOCSTATUS_MASK;
6905                         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
6906                                 break;
6907                         phys_disk_num = pd_pg0.PhysDiskNum;
6908                         handle = le16_to_cpu(pd_pg0.DevHandle);
6909                         set_bit(handle, ioc->pd_handles);
6910                 }
6911         }
6912 out:
6913         printk(MPT2SAS_INFO_FMT "search for responding raid volumes: "
6914             "complete\n", ioc->name);
6915 }
6916 
6917 /**
6918  * _scsih_mark_responding_expander - mark a expander as responding
6919  * @ioc: per adapter object
6920  * @sas_address: sas address
6921  * @handle:
6922  *
6923  * After host reset, find out whether devices are still responding.
6924  * Used in _scsi_remove_unresponsive_expanders.
6925  *
6926  * Return nothing.
6927  */
6928 static void
6929 _scsih_mark_responding_expander(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
6930      u16 handle)
6931 {
6932         struct _sas_node *sas_expander;
6933         unsigned long flags;
6934         int i;
6935 
6936         spin_lock_irqsave(&ioc->sas_node_lock, flags);
6937         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
6938                 if (sas_expander->sas_address != sas_address)
6939                         continue;
6940                 sas_expander->responding = 1;
6941                 if (sas_expander->handle == handle)
6942                         goto out;
6943                 printk(KERN_INFO "\texpander(0x%016llx): handle changed"
6944                     " from(0x%04x) to (0x%04x)!!!\n",
6945                     (unsigned long long)sas_expander->sas_address,
6946                     sas_expander->handle, handle);
6947                 sas_expander->