Version:  2.0.40 2.2.26 2.4.37 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 3.16

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  * @m_type: TM_MUTEX_ON or TM_MUTEX_OFF
2372  * Context: user
2373  *
2374  * A generic API for sending task management requests to firmware.
2375  *
2376  * The callback index is set inside `ioc->tm_cb_idx`.
2377  *
2378  * Return SUCCESS or FAILED.
2379  */
2380 int
2381 mpt2sas_scsih_issue_tm(struct MPT2SAS_ADAPTER *ioc, u16 handle, uint channel,
2382     uint id, uint lun, u8 type, u16 smid_task, ulong timeout,
2383         enum mutex_type m_type)
2384 {
2385         Mpi2SCSITaskManagementRequest_t *mpi_request;
2386         Mpi2SCSITaskManagementReply_t *mpi_reply;
2387         u16 smid = 0;
2388         u32 ioc_state;
2389         unsigned long timeleft;
2390         struct scsiio_tracker *scsi_lookup = NULL;
2391         int rc;
2392 
2393         if (m_type == TM_MUTEX_ON)
2394                 mutex_lock(&ioc->tm_cmds.mutex);
2395         if (ioc->tm_cmds.status != MPT2_CMD_NOT_USED) {
2396                 printk(MPT2SAS_INFO_FMT "%s: tm_cmd busy!!!\n",
2397                     __func__, ioc->name);
2398                 rc = FAILED;
2399                 goto err_out;
2400         }
2401 
2402         if (ioc->shost_recovery || ioc->remove_host ||
2403             ioc->pci_error_recovery) {
2404                 printk(MPT2SAS_INFO_FMT "%s: host reset in progress!\n",
2405                     __func__, ioc->name);
2406                 rc = FAILED;
2407                 goto err_out;
2408         }
2409 
2410         ioc_state = mpt2sas_base_get_iocstate(ioc, 0);
2411         if (ioc_state & MPI2_DOORBELL_USED) {
2412                 dhsprintk(ioc, printk(MPT2SAS_INFO_FMT "unexpected doorbell "
2413                     "active!\n", ioc->name));
2414                 rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2415                     FORCE_BIG_HAMMER);
2416                 rc = (!rc) ? SUCCESS : FAILED;
2417                 goto err_out;
2418         }
2419 
2420         if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) {
2421                 mpt2sas_base_fault_info(ioc, ioc_state &
2422                     MPI2_DOORBELL_DATA_MASK);
2423                 rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2424                     FORCE_BIG_HAMMER);
2425                 rc = (!rc) ? SUCCESS : FAILED;
2426                 goto err_out;
2427         }
2428 
2429         smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
2430         if (!smid) {
2431                 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
2432                     ioc->name, __func__);
2433                 rc = FAILED;
2434                 goto err_out;
2435         }
2436 
2437         if (type == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
2438                 scsi_lookup = &ioc->scsi_lookup[smid_task - 1];
2439 
2440         dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "sending tm: handle(0x%04x),"
2441             " task_type(0x%02x), smid(%d)\n", ioc->name, handle, type,
2442             smid_task));
2443         ioc->tm_cmds.status = MPT2_CMD_PENDING;
2444         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
2445         ioc->tm_cmds.smid = smid;
2446         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
2447         memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t));
2448         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
2449         mpi_request->DevHandle = cpu_to_le16(handle);
2450         mpi_request->TaskType = type;
2451         mpi_request->TaskMID = cpu_to_le16(smid_task);
2452         int_to_scsilun(lun, (struct scsi_lun *)mpi_request->LUN);
2453         mpt2sas_scsih_set_tm_flag(ioc, handle);
2454         init_completion(&ioc->tm_cmds.done);
2455         mpt2sas_base_put_smid_hi_priority(ioc, smid);
2456         timeleft = wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
2457         if (!(ioc->tm_cmds.status & MPT2_CMD_COMPLETE)) {
2458                 printk(MPT2SAS_ERR_FMT "%s: timeout\n",
2459                     ioc->name, __func__);
2460                 _debug_dump_mf(mpi_request,
2461                     sizeof(Mpi2SCSITaskManagementRequest_t)/4);
2462                 if (!(ioc->tm_cmds.status & MPT2_CMD_RESET)) {
2463                         rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2464                             FORCE_BIG_HAMMER);
2465                         rc = (!rc) ? SUCCESS : FAILED;
2466                         ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
2467                         mpt2sas_scsih_clear_tm_flag(ioc, handle);
2468                         goto err_out;
2469                 }
2470         }
2471 
2472         if (ioc->tm_cmds.status & MPT2_CMD_REPLY_VALID) {
2473                 mpi_reply = ioc->tm_cmds.reply;
2474                 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "complete tm: "
2475                     "ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
2476                     ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
2477                     le32_to_cpu(mpi_reply->IOCLogInfo),
2478                     le32_to_cpu(mpi_reply->TerminationCount)));
2479                 if (ioc->logging_level & MPT_DEBUG_TM) {
2480                         _scsih_response_code(ioc, mpi_reply->ResponseCode);
2481                         if (mpi_reply->IOCStatus)
2482                                 _debug_dump_mf(mpi_request,
2483                                     sizeof(Mpi2SCSITaskManagementRequest_t)/4);
2484                 }
2485         }
2486 
2487         switch (type) {
2488         case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
2489                 rc = SUCCESS;
2490                 if (scsi_lookup->scmd == NULL)
2491                         break;
2492                 rc = FAILED;
2493                 break;
2494 
2495         case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
2496                 if (_scsih_scsi_lookup_find_by_target(ioc, id, channel))
2497                         rc = FAILED;
2498                 else
2499                         rc = SUCCESS;
2500                 break;
2501 
2502         case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
2503         case MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET:
2504                 if (_scsih_scsi_lookup_find_by_lun(ioc, id, lun, channel))
2505                         rc = FAILED;
2506                 else
2507                         rc = SUCCESS;
2508                 break;
2509         case MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK:
2510                 rc = SUCCESS;
2511                 break;
2512         default:
2513                 rc = FAILED;
2514                 break;
2515         }
2516 
2517         mpt2sas_scsih_clear_tm_flag(ioc, handle);
2518         ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
2519         if (m_type == TM_MUTEX_ON)
2520                 mutex_unlock(&ioc->tm_cmds.mutex);
2521 
2522         return rc;
2523 
2524  err_out:
2525         if (m_type == TM_MUTEX_ON)
2526                 mutex_unlock(&ioc->tm_cmds.mutex);
2527         return rc;
2528 }
2529 
2530 /**
2531  * _scsih_tm_display_info - displays info about the device
2532  * @ioc: per adapter struct
2533  * @scmd: pointer to scsi command object
2534  *
2535  * Called by task management callback handlers.
2536  */
2537 static void
2538 _scsih_tm_display_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
2539 {
2540         struct scsi_target *starget = scmd->device->sdev_target;
2541         struct MPT2SAS_TARGET *priv_target = starget->hostdata;
2542         struct _sas_device *sas_device = NULL;
2543         unsigned long flags;
2544         char *device_str = NULL;
2545 
2546         if (!priv_target)
2547                 return;
2548         if (ioc->hide_ir_msg)
2549                 device_str = "WarpDrive";
2550         else
2551                 device_str = "volume";
2552 
2553         scsi_print_command(scmd);
2554         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2555                 starget_printk(KERN_INFO, starget, "%s handle(0x%04x), "
2556                     "%s wwid(0x%016llx)\n", device_str, priv_target->handle,
2557                     device_str, (unsigned long long)priv_target->sas_address);
2558         } else {
2559                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2560                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
2561                     priv_target->sas_address);
2562                 if (sas_device) {
2563                         if (priv_target->flags &
2564                             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2565                                 starget_printk(KERN_INFO, starget,
2566                                     "volume handle(0x%04x), "
2567                                     "volume wwid(0x%016llx)\n",
2568                                     sas_device->volume_handle,
2569                                    (unsigned long long)sas_device->volume_wwid);
2570                         }
2571                         starget_printk(KERN_INFO, starget,
2572                             "handle(0x%04x), sas_address(0x%016llx), phy(%d)\n",
2573                             sas_device->handle,
2574                             (unsigned long long)sas_device->sas_address,
2575                             sas_device->phy);
2576                         starget_printk(KERN_INFO, starget,
2577                             "enclosure_logical_id(0x%016llx), slot(%d)\n",
2578                            (unsigned long long)sas_device->enclosure_logical_id,
2579                             sas_device->slot);
2580                 }
2581                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2582         }
2583 }
2584 
2585 /**
2586  * _scsih_abort - eh threads main abort routine
2587  * @scmd: pointer to scsi command object
2588  *
2589  * Returns SUCCESS if command aborted else FAILED
2590  */
2591 static int
2592 _scsih_abort(struct scsi_cmnd *scmd)
2593 {
2594         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2595         struct MPT2SAS_DEVICE *sas_device_priv_data;
2596         u16 smid;
2597         u16 handle;
2598         int r;
2599 
2600         sdev_printk(KERN_INFO, scmd->device, "attempting task abort! "
2601             "scmd(%p)\n", scmd);
2602         _scsih_tm_display_info(ioc, scmd);
2603 
2604         sas_device_priv_data = scmd->device->hostdata;
2605         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2606                 sdev_printk(KERN_INFO, scmd->device, "device been deleted! "
2607                     "scmd(%p)\n", scmd);
2608                 scmd->result = DID_NO_CONNECT << 16;
2609                 scmd->scsi_done(scmd);
2610                 r = SUCCESS;
2611                 goto out;
2612         }
2613 
2614         /* search for the command */
2615         smid = _scsih_scsi_lookup_find_by_scmd(ioc, scmd);
2616         if (!smid) {
2617                 scmd->result = DID_RESET << 16;
2618                 r = SUCCESS;
2619                 goto out;
2620         }
2621 
2622         /* for hidden raid components and volumes this is not supported */
2623         if (sas_device_priv_data->sas_target->flags &
2624             MPT_TARGET_FLAGS_RAID_COMPONENT ||
2625             sas_device_priv_data->sas_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2626                 scmd->result = DID_RESET << 16;
2627                 r = FAILED;
2628                 goto out;
2629         }
2630 
2631         mpt2sas_halt_firmware(ioc);
2632 
2633         handle = sas_device_priv_data->sas_target->handle;
2634         r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2635             scmd->device->id, scmd->device->lun,
2636             MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30, TM_MUTEX_ON);
2637 
2638  out:
2639         sdev_printk(KERN_INFO, scmd->device, "task abort: %s scmd(%p)\n",
2640             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2641         return r;
2642 }
2643 
2644 /**
2645  * _scsih_dev_reset - eh threads main device reset routine
2646  * @scmd: pointer to scsi command object
2647  *
2648  * Returns SUCCESS if command aborted else FAILED
2649  */
2650 static int
2651 _scsih_dev_reset(struct scsi_cmnd *scmd)
2652 {
2653         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2654         struct MPT2SAS_DEVICE *sas_device_priv_data;
2655         struct _sas_device *sas_device;
2656         unsigned long flags;
2657         u16     handle;
2658         int r;
2659 
2660         struct scsi_target *starget = scmd->device->sdev_target;
2661 
2662         starget_printk(KERN_INFO, starget, "attempting device reset! "
2663             "scmd(%p)\n", scmd);
2664         _scsih_tm_display_info(ioc, scmd);
2665 
2666         sas_device_priv_data = scmd->device->hostdata;
2667         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2668                 starget_printk(KERN_INFO, starget, "device been deleted! "
2669                     "scmd(%p)\n", scmd);
2670                 scmd->result = DID_NO_CONNECT << 16;
2671                 scmd->scsi_done(scmd);
2672                 r = SUCCESS;
2673                 goto out;
2674         }
2675 
2676         /* for hidden raid components obtain the volume_handle */
2677         handle = 0;
2678         if (sas_device_priv_data->sas_target->flags &
2679             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2680                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2681                 sas_device = _scsih_sas_device_find_by_handle(ioc,
2682                    sas_device_priv_data->sas_target->handle);
2683                 if (sas_device)
2684                         handle = sas_device->volume_handle;
2685                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2686         } else
2687                 handle = sas_device_priv_data->sas_target->handle;
2688 
2689         if (!handle) {
2690                 scmd->result = DID_RESET << 16;
2691                 r = FAILED;
2692                 goto out;
2693         }
2694 
2695         r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2696             scmd->device->id, scmd->device->lun,
2697             MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, 0, 30, TM_MUTEX_ON);
2698 
2699  out:
2700         sdev_printk(KERN_INFO, scmd->device, "device reset: %s scmd(%p)\n",
2701             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2702         return r;
2703 }
2704 
2705 /**
2706  * _scsih_target_reset - eh threads main target reset routine
2707  * @scmd: pointer to scsi command object
2708  *
2709  * Returns SUCCESS if command aborted else FAILED
2710  */
2711 static int
2712 _scsih_target_reset(struct scsi_cmnd *scmd)
2713 {
2714         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2715         struct MPT2SAS_DEVICE *sas_device_priv_data;
2716         struct _sas_device *sas_device;
2717         unsigned long flags;
2718         u16     handle;
2719         int r;
2720         struct scsi_target *starget = scmd->device->sdev_target;
2721 
2722         starget_printk(KERN_INFO, starget, "attempting target reset! "
2723             "scmd(%p)\n", scmd);
2724         _scsih_tm_display_info(ioc, scmd);
2725 
2726         sas_device_priv_data = scmd->device->hostdata;
2727         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2728                 starget_printk(KERN_INFO, starget, "target been deleted! "
2729                     "scmd(%p)\n", scmd);
2730                 scmd->result = DID_NO_CONNECT << 16;
2731                 scmd->scsi_done(scmd);
2732                 r = SUCCESS;
2733                 goto out;
2734         }
2735 
2736         /* for hidden raid components obtain the volume_handle */
2737         handle = 0;
2738         if (sas_device_priv_data->sas_target->flags &
2739             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2740                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2741                 sas_device = _scsih_sas_device_find_by_handle(ioc,
2742                    sas_device_priv_data->sas_target->handle);
2743                 if (sas_device)
2744                         handle = sas_device->volume_handle;
2745                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2746         } else
2747                 handle = sas_device_priv_data->sas_target->handle;
2748 
2749         if (!handle) {
2750                 scmd->result = DID_RESET << 16;
2751                 r = FAILED;
2752                 goto out;
2753         }
2754 
2755         r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2756             scmd->device->id, 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0,
2757             30, TM_MUTEX_ON);
2758 
2759  out:
2760         starget_printk(KERN_INFO, starget, "target reset: %s scmd(%p)\n",
2761             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2762         return r;
2763 }
2764 
2765 /**
2766  * _scsih_host_reset - eh threads main host reset routine
2767  * @scmd: pointer to scsi command object
2768  *
2769  * Returns SUCCESS if command aborted else FAILED
2770  */
2771 static int
2772 _scsih_host_reset(struct scsi_cmnd *scmd)
2773 {
2774         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2775         int r, retval;
2776 
2777         printk(MPT2SAS_INFO_FMT "attempting host reset! scmd(%p)\n",
2778             ioc->name, scmd);
2779         scsi_print_command(scmd);
2780 
2781         retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2782             FORCE_BIG_HAMMER);
2783         r = (retval < 0) ? FAILED : SUCCESS;
2784         printk(MPT2SAS_INFO_FMT "host reset: %s scmd(%p)\n",
2785             ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2786 
2787         return r;
2788 }
2789 
2790 /**
2791  * _scsih_fw_event_add - insert and queue up fw_event
2792  * @ioc: per adapter object
2793  * @fw_event: object describing the event
2794  * Context: This function will acquire ioc->fw_event_lock.
2795  *
2796  * This adds the firmware event object into link list, then queues it up to
2797  * be processed from user context.
2798  *
2799  * Return nothing.
2800  */
2801 static void
2802 _scsih_fw_event_add(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
2803 {
2804         unsigned long flags;
2805 
2806         if (ioc->firmware_event_thread == NULL)
2807                 return;
2808 
2809         spin_lock_irqsave(&ioc->fw_event_lock, flags);
2810         list_add_tail(&fw_event->list, &ioc->fw_event_list);
2811         INIT_DELAYED_WORK(&fw_event->delayed_work, _firmware_event_work);
2812         queue_delayed_work(ioc->firmware_event_thread,
2813             &fw_event->delayed_work, 0);
2814         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2815 }
2816 
2817 /**
2818  * _scsih_fw_event_free - delete fw_event
2819  * @ioc: per adapter object
2820  * @fw_event: object describing the event
2821  * Context: This function will acquire ioc->fw_event_lock.
2822  *
2823  * This removes firmware event object from link list, frees associated memory.
2824  *
2825  * Return nothing.
2826  */
2827 static void
2828 _scsih_fw_event_free(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work
2829     *fw_event)
2830 {
2831         unsigned long flags;
2832 
2833         spin_lock_irqsave(&ioc->fw_event_lock, flags);
2834         list_del(&fw_event->list);
2835         kfree(fw_event->event_data);
2836         kfree(fw_event);
2837         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2838 }
2839 
2840 
2841 /**
2842  * _scsih_error_recovery_delete_devices - remove devices not responding
2843  * @ioc: per adapter object
2844  *
2845  * Return nothing.
2846  */
2847 static void
2848 _scsih_error_recovery_delete_devices(struct MPT2SAS_ADAPTER *ioc)
2849 {
2850         struct fw_event_work *fw_event;
2851 
2852         if (ioc->is_driver_loading)
2853                 return;
2854 
2855         fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
2856         if (!fw_event)
2857                 return;
2858 
2859         fw_event->event = MPT2SAS_REMOVE_UNRESPONDING_DEVICES;
2860         fw_event->ioc = ioc;
2861         _scsih_fw_event_add(ioc, fw_event);
2862 }
2863 
2864 /**
2865  * mpt2sas_port_enable_complete - port enable completed (fake event)
2866  * @ioc: per adapter object
2867  *
2868  * Return nothing.
2869  */
2870 void
2871 mpt2sas_port_enable_complete(struct MPT2SAS_ADAPTER *ioc)
2872 {
2873         struct fw_event_work *fw_event;
2874 
2875         fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
2876         if (!fw_event)
2877                 return;
2878         fw_event->event = MPT2SAS_PORT_ENABLE_COMPLETE;
2879         fw_event->ioc = ioc;
2880         _scsih_fw_event_add(ioc, fw_event);
2881 }
2882 
2883 /**
2884  * _scsih_fw_event_cleanup_queue - cleanup event queue
2885  * @ioc: per adapter object
2886  *
2887  * Walk the firmware event queue, either killing timers, or waiting
2888  * for outstanding events to complete
2889  *
2890  * Return nothing.
2891  */
2892 static void
2893 _scsih_fw_event_cleanup_queue(struct MPT2SAS_ADAPTER *ioc)
2894 {
2895         struct fw_event_work *fw_event, *next;
2896 
2897         if (list_empty(&ioc->fw_event_list) ||
2898              !ioc->firmware_event_thread || in_interrupt())
2899                 return;
2900 
2901         list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
2902                 if (cancel_delayed_work(&fw_event->delayed_work)) {
2903                         _scsih_fw_event_free(ioc, fw_event);
2904                         continue;
2905                 }
2906                 fw_event->cancel_pending_work = 1;
2907         }
2908 }
2909 
2910 /**
2911  * _scsih_ublock_io_all_device - unblock every device
2912  * @ioc: per adapter object
2913  *
2914  * change the device state from block to running
2915  */
2916 static void
2917 _scsih_ublock_io_all_device(struct MPT2SAS_ADAPTER *ioc)
2918 {
2919         struct MPT2SAS_DEVICE *sas_device_priv_data;
2920         struct scsi_device *sdev;
2921 
2922         shost_for_each_device(sdev, ioc->shost) {
2923                 sas_device_priv_data = sdev->hostdata;
2924                 if (!sas_device_priv_data)
2925                         continue;
2926                 if (!sas_device_priv_data->block)
2927                         continue;
2928                 sas_device_priv_data->block = 0;
2929                 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev, "device_running, "
2930                     "handle(0x%04x)\n",
2931                     sas_device_priv_data->sas_target->handle));
2932                 scsi_internal_device_unblock(sdev, SDEV_RUNNING);
2933         }
2934 }
2935 /**
2936  * _scsih_ublock_io_device - set the device state to SDEV_RUNNING
2937  * @ioc: per adapter object
2938  * @handle: device handle
2939  *
2940  * During device pull we need to appropiately set the sdev state.
2941  */
2942 static void
2943 _scsih_ublock_io_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
2944 {
2945         struct MPT2SAS_DEVICE *sas_device_priv_data;
2946         struct scsi_device *sdev;
2947 
2948         shost_for_each_device(sdev, ioc->shost) {
2949                 sas_device_priv_data = sdev->hostdata;
2950                 if (!sas_device_priv_data)
2951                         continue;
2952                 if (!sas_device_priv_data->block)
2953                         continue;
2954                 if (sas_device_priv_data->sas_target->sas_address ==
2955                                                                 sas_address) {
2956                         dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
2957                             MPT2SAS_INFO_FMT "SDEV_RUNNING: "
2958                             "sas address(0x%016llx)\n", ioc->name,
2959                                 (unsigned long long)sas_address));
2960                         sas_device_priv_data->block = 0;
2961                         scsi_internal_device_unblock(sdev, SDEV_RUNNING);
2962                 }
2963         }
2964 }
2965 
2966 /**
2967  * _scsih_block_io_all_device - set the device state to SDEV_BLOCK
2968  * @ioc: per adapter object
2969  * @handle: device handle
2970  *
2971  * During device pull we need to appropiately set the sdev state.
2972  */
2973 static void
2974 _scsih_block_io_all_device(struct MPT2SAS_ADAPTER *ioc)
2975 {
2976         struct MPT2SAS_DEVICE *sas_device_priv_data;
2977         struct scsi_device *sdev;
2978 
2979         shost_for_each_device(sdev, ioc->shost) {
2980                 sas_device_priv_data = sdev->hostdata;
2981                 if (!sas_device_priv_data)
2982                         continue;
2983                 if (sas_device_priv_data->block)
2984                         continue;
2985                 sas_device_priv_data->block = 1;
2986                 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev, "device_blocked, "
2987                     "handle(0x%04x)\n",
2988                     sas_device_priv_data->sas_target->handle));
2989                 scsi_internal_device_block(sdev);
2990         }
2991 }
2992 
2993 
2994 /**
2995  * _scsih_block_io_device - set the device state to SDEV_BLOCK
2996  * @ioc: per adapter object
2997  * @handle: device handle
2998  *
2999  * During device pull we need to appropiately set the sdev state.
3000  */
3001 static void
3002 _scsih_block_io_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3003 {
3004         struct MPT2SAS_DEVICE *sas_device_priv_data;
3005         struct scsi_device *sdev;
3006 
3007         shost_for_each_device(sdev, ioc->shost) {
3008                 sas_device_priv_data = sdev->hostdata;
3009                 if (!sas_device_priv_data)
3010                         continue;
3011                 if (sas_device_priv_data->block)
3012                         continue;
3013                 if (sas_device_priv_data->sas_target->handle == handle) {
3014                         dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
3015                             MPT2SAS_INFO_FMT "SDEV_BLOCK: "
3016                             "handle(0x%04x)\n", ioc->name, handle));
3017                         sas_device_priv_data->block = 1;
3018                         scsi_internal_device_block(sdev);
3019                 }
3020         }
3021 }
3022 
3023 /**
3024  * _scsih_block_io_to_children_attached_to_ex
3025  * @ioc: per adapter object
3026  * @sas_expander: the sas_device object
3027  *
3028  * This routine set sdev state to SDEV_BLOCK for all devices
3029  * attached to this expander. This function called when expander is
3030  * pulled.
3031  */
3032 static void
3033 _scsih_block_io_to_children_attached_to_ex(struct MPT2SAS_ADAPTER *ioc,
3034     struct _sas_node *sas_expander)
3035 {
3036         struct _sas_port *mpt2sas_port;
3037         struct _sas_device *sas_device;
3038         struct _sas_node *expander_sibling;
3039         unsigned long flags;
3040 
3041         if (!sas_expander)
3042                 return;
3043 
3044         list_for_each_entry(mpt2sas_port,
3045            &sas_expander->sas_port_list, port_list) {
3046                 if (mpt2sas_port->remote_identify.device_type ==
3047                     SAS_END_DEVICE) {
3048                         spin_lock_irqsave(&ioc->sas_device_lock, flags);
3049                         sas_device =
3050                             mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
3051                            mpt2sas_port->remote_identify.sas_address);
3052                         if (sas_device)
3053                                 set_bit(sas_device->handle,
3054                                     ioc->blocking_handles);
3055                         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3056                 }
3057         }
3058 
3059         list_for_each_entry(mpt2sas_port,
3060            &sas_expander->sas_port_list, port_list) {
3061 
3062                 if (mpt2sas_port->remote_identify.device_type ==
3063                     SAS_EDGE_EXPANDER_DEVICE ||
3064                     mpt2sas_port->remote_identify.device_type ==
3065                     SAS_FANOUT_EXPANDER_DEVICE) {
3066                         expander_sibling =
3067                             mpt2sas_scsih_expander_find_by_sas_address(
3068                             ioc, mpt2sas_port->remote_identify.sas_address);
3069                         _scsih_block_io_to_children_attached_to_ex(ioc,
3070                             expander_sibling);
3071                 }
3072         }
3073 }
3074 
3075 /**
3076  * _scsih_block_io_to_children_attached_directly
3077  * @ioc: per adapter object
3078  * @event_data: topology change event data
3079  *
3080  * This routine set sdev state to SDEV_BLOCK for all devices
3081  * direct attached during device pull.
3082  */
3083 static void
3084 _scsih_block_io_to_children_attached_directly(struct MPT2SAS_ADAPTER *ioc,
3085     Mpi2EventDataSasTopologyChangeList_t *event_data)
3086 {
3087         int i;
3088         u16 handle;
3089         u16 reason_code;
3090         u8 phy_number;
3091 
3092         for (i = 0; i < event_data->NumEntries; i++) {
3093                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3094                 if (!handle)
3095                         continue;
3096                 phy_number = event_data->StartPhyNum + i;
3097                 reason_code = event_data->PHY[i].PhyStatus &
3098                     MPI2_EVENT_SAS_TOPO_RC_MASK;
3099                 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING)
3100                         _scsih_block_io_device(ioc, handle);
3101         }
3102 }
3103 
3104 /**
3105  * _scsih_tm_tr_send - send task management request
3106  * @ioc: per adapter object
3107  * @handle: device handle
3108  * Context: interrupt time.
3109  *
3110  * This code is to initiate the device removal handshake protocol
3111  * with controller firmware.  This function will issue target reset
3112  * using high priority request queue.  It will send a sas iounit
3113  * control request (MPI2_SAS_OP_REMOVE_DEVICE) from this completion.
3114  *
3115  * This is designed to send muliple task management request at the same
3116  * time to the fifo. If the fifo is full, we will append the request,
3117  * and process it in a future completion.
3118  */
3119 static void
3120 _scsih_tm_tr_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3121 {
3122         Mpi2SCSITaskManagementRequest_t *mpi_request;
3123         u16 smid;
3124         struct _sas_device *sas_device;
3125         struct MPT2SAS_TARGET *sas_target_priv_data = NULL;
3126         u64 sas_address = 0;
3127         unsigned long flags;
3128         struct _tr_list *delayed_tr;
3129         u32 ioc_state;
3130 
3131         if (ioc->remove_host) {
3132                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host has been "
3133                     "removed: handle(0x%04x)\n", __func__, ioc->name, handle));
3134                 return;
3135         } else if (ioc->pci_error_recovery) {
3136                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host in pci "
3137                     "error recovery: handle(0x%04x)\n", __func__, ioc->name,
3138                     handle));
3139                 return;
3140         }
3141         ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
3142         if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
3143                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host is not "
3144                    "operational: handle(0x%04x)\n", __func__, ioc->name,
3145                    handle));
3146                 return;
3147         }
3148 
3149         /* if PD, then return */
3150         if (test_bit(handle, ioc->pd_handles))
3151                 return;
3152 
3153         spin_lock_irqsave(&ioc->sas_device_lock, flags);
3154         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
3155         if (sas_device && sas_device->starget &&
3156              sas_device->starget->hostdata) {
3157                 sas_target_priv_data = sas_device->starget->hostdata;
3158                 sas_target_priv_data->deleted = 1;
3159                 sas_address = sas_device->sas_address;
3160         }
3161         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3162 
3163         if (sas_target_priv_data) {
3164                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "setting delete flag: "
3165                 "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, handle,
3166                         (unsigned long long)sas_address));
3167                 _scsih_ublock_io_device(ioc, sas_address);
3168                 sas_target_priv_data->handle = MPT2SAS_INVALID_DEVICE_HANDLE;
3169         }
3170 
3171         smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
3172         if (!smid) {
3173                 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3174                 if (!delayed_tr)
3175                         return;
3176                 INIT_LIST_HEAD(&delayed_tr->list);
3177                 delayed_tr->handle = handle;
3178                 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3179                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3180                     "DELAYED:tr:handle(0x%04x), (open)\n",
3181                     ioc->name, handle));
3182                 return;
3183         }
3184 
3185         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "tr_send:handle(0x%04x), "
3186             "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid,
3187             ioc->tm_tr_cb_idx));
3188         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
3189         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3190         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3191         mpi_request->DevHandle = cpu_to_le16(handle);
3192         mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3193         mpt2sas_base_put_smid_hi_priority(ioc, smid);
3194 }
3195 
3196 
3197 
3198 /**
3199  * _scsih_sas_control_complete - completion routine
3200  * @ioc: per adapter object
3201  * @smid: system request message index
3202  * @msix_index: MSIX table index supplied by the OS
3203  * @reply: reply message frame(lower 32bit addr)
3204  * Context: interrupt time.
3205  *
3206  * This is the sas iounit control completion routine.
3207  * This code is part of the code to initiate the device removal
3208  * handshake protocol with controller firmware.
3209  *
3210  * Return 1 meaning mf should be freed from _base_interrupt
3211  *        0 means the mf is freed from this function.
3212  */
3213 static u8
3214 _scsih_sas_control_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
3215     u8 msix_index, u32 reply)
3216 {
3217         Mpi2SasIoUnitControlReply_t *mpi_reply =
3218             mpt2sas_base_get_reply_virt_addr(ioc, reply);
3219         if (likely(mpi_reply)) {
3220                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3221                 "sc_complete:handle(0x%04x), (open) "
3222                 "smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
3223                 ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid,
3224                 le16_to_cpu(mpi_reply->IOCStatus),
3225                 le32_to_cpu(mpi_reply->IOCLogInfo)));
3226         } else {
3227                 printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
3228                     ioc->name, __FILE__, __LINE__, __func__);
3229         }
3230         return 1;
3231 }
3232 
3233 /**
3234  * _scsih_tm_tr_volume_send - send target reset request for volumes
3235  * @ioc: per adapter object
3236  * @handle: device handle
3237  * Context: interrupt time.
3238  *
3239  * This is designed to send muliple task management request at the same
3240  * time to the fifo. If the fifo is full, we will append the request,
3241  * and process it in a future completion.
3242  */
3243 static void
3244 _scsih_tm_tr_volume_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3245 {
3246         Mpi2SCSITaskManagementRequest_t *mpi_request;
3247         u16 smid;
3248         struct _tr_list *delayed_tr;
3249 
3250         if (ioc->shost_recovery || ioc->remove_host ||
3251             ioc->pci_error_recovery) {
3252                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host reset in "
3253                    "progress!\n", __func__, ioc->name));
3254                 return;
3255         }
3256 
3257         smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
3258         if (!smid) {
3259                 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3260                 if (!delayed_tr)
3261                         return;
3262                 INIT_LIST_HEAD(&delayed_tr->list);
3263                 delayed_tr->handle = handle;
3264                 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
3265                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3266                     "DELAYED:tr:handle(0x%04x), (open)\n",
3267                     ioc->name, handle));
3268                 return;
3269         }
3270 
3271         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "tr_send:handle(0x%04x), "
3272             "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid,
3273             ioc->tm_tr_volume_cb_idx));
3274         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
3275         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3276         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3277         mpi_request->DevHandle = cpu_to_le16(handle);
3278         mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3279         mpt2sas_base_put_smid_hi_priority(ioc, smid);
3280 }
3281 
3282 /**
3283  * _scsih_tm_volume_tr_complete - target reset completion
3284  * @ioc: per adapter object
3285  * @smid: system request message index
3286  * @msix_index: MSIX table index supplied by the OS
3287  * @reply: reply message frame(lower 32bit addr)
3288  * Context: interrupt time.
3289  *
3290  * Return 1 meaning mf should be freed from _base_interrupt
3291  *        0 means the mf is freed from this function.
3292  */
3293 static u8
3294 _scsih_tm_volume_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
3295     u8 msix_index, u32 reply)
3296 {
3297         u16 handle;
3298         Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3299         Mpi2SCSITaskManagementReply_t *mpi_reply =
3300             mpt2sas_base_get_reply_virt_addr(ioc, reply);
3301 
3302         if (ioc->shost_recovery || ioc->remove_host ||
3303             ioc->pci_error_recovery) {
3304                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host reset in "
3305                    "progress!\n", __func__, ioc->name));
3306                 return 1;
3307         }
3308         if (unlikely(!mpi_reply)) {
3309                 printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
3310                     ioc->name, __FILE__, __LINE__, __func__);
3311                 return 1;
3312         }
3313         mpi_request_tm = mpt2sas_base_get_msg_frame(ioc, smid);
3314         handle = le16_to_cpu(mpi_request_tm->DevHandle);
3315         if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
3316                 dewtprintk(ioc, printk("spurious interrupt: "
3317                     "handle(0x%04x:0x%04x), smid(%d)!!!\n", handle,
3318                     le16_to_cpu(mpi_reply->DevHandle), smid));
3319                 return 0;
3320         }
3321 
3322         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3323             "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
3324             "loginfo(0x%08x), completed(%d)\n", ioc->name,
3325             handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3326             le32_to_cpu(mpi_reply->IOCLogInfo),
3327             le32_to_cpu(mpi_reply->TerminationCount)));
3328 
3329         return _scsih_check_for_pending_tm(ioc, smid);
3330 }
3331 
3332 /**
3333  * _scsih_tm_tr_complete -
3334  * @ioc: per adapter object
3335  * @smid: system request message index
3336  * @msix_index: MSIX table index supplied by the OS
3337  * @reply: reply message frame(lower 32bit addr)
3338  * Context: interrupt time.
3339  *
3340  * This is the target reset completion routine.
3341  * This code is part of the code to initiate the device removal
3342  * handshake protocol with controller firmware.
3343  * It will send a sas iounit control request (MPI2_SAS_OP_REMOVE_DEVICE)
3344  *
3345  * Return 1 meaning mf should be freed from _base_interrupt
3346  *        0 means the mf is freed from this function.
3347  */
3348 static u8
3349 _scsih_tm_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
3350     u32 reply)
3351 {
3352         u16 handle;
3353         Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3354         Mpi2SCSITaskManagementReply_t *mpi_reply =
3355             mpt2sas_base_get_reply_virt_addr(ioc, reply);
3356         Mpi2SasIoUnitControlRequest_t *mpi_request;
3357         u16 smid_sas_ctrl;
3358         u32 ioc_state;
3359 
3360         if (ioc->remove_host) {
3361                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host has been "
3362                    "removed\n", __func__, ioc->name));
3363                 return 1;
3364         } else if (ioc->pci_error_recovery) {
3365                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host in pci "
3366                     "error recovery\n", __func__, ioc->name));
3367                 return 1;
3368         }
3369         ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
3370         if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
3371                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host is not "
3372                     "operational\n", __func__, ioc->name));
3373                 return 1;
3374         }
3375         if (unlikely(!mpi_reply)) {
3376                 printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
3377                     ioc->name, __FILE__, __LINE__, __func__);
3378                 return 1;
3379         }
3380         mpi_request_tm = mpt2sas_base_get_msg_frame(ioc, smid);
3381         handle = le16_to_cpu(mpi_request_tm->DevHandle);
3382         if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
3383                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "spurious interrupt: "
3384                     "handle(0x%04x:0x%04x), smid(%d)!!!\n", ioc->name, handle,
3385                     le16_to_cpu(mpi_reply->DevHandle), smid));
3386                 return 0;
3387         }
3388 
3389         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3390             "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
3391             "loginfo(0x%08x), completed(%d)\n", ioc->name,
3392             handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3393             le32_to_cpu(mpi_reply->IOCLogInfo),
3394             le32_to_cpu(mpi_reply->TerminationCount)));
3395 
3396         smid_sas_ctrl = mpt2sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
3397         if (!smid_sas_ctrl) {
3398                 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
3399                     ioc->name, __func__);
3400                 return 1;
3401         }
3402 
3403         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "sc_send:handle(0x%04x), "
3404             "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid_sas_ctrl,
3405             ioc->tm_sas_control_cb_idx));
3406         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid_sas_ctrl);
3407         memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
3408         mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
3409         mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
3410         mpi_request->DevHandle = mpi_request_tm->DevHandle;
3411         mpt2sas_base_put_smid_default(ioc, smid_sas_ctrl);
3412 
3413         return _scsih_check_for_pending_tm(ioc, smid);
3414 }
3415 
3416 /**
3417  * _scsih_check_for_pending_tm - check for pending task management
3418  * @ioc: per adapter object
3419  * @smid: system request message index
3420  *
3421  * This will check delayed target reset list, and feed the
3422  * next reqeust.
3423  *
3424  * Return 1 meaning mf should be freed from _base_interrupt
3425  *        0 means the mf is freed from this function.
3426  */
3427 static u8
3428 _scsih_check_for_pending_tm(struct MPT2SAS_ADAPTER *ioc, u16 smid)
3429 {
3430         struct _tr_list *delayed_tr;
3431 
3432         if (!list_empty(&ioc->delayed_tr_volume_list)) {
3433                 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
3434                     struct _tr_list, list);
3435                 mpt2sas_base_free_smid(ioc, smid);
3436                 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
3437                 list_del(&delayed_tr->list);
3438                 kfree(delayed_tr);
3439                 return 0;
3440         }
3441 
3442         if (!list_empty(&ioc->delayed_tr_list)) {
3443                 delayed_tr = list_entry(ioc->delayed_tr_list.next,
3444                     struct _tr_list, list);
3445                 mpt2sas_base_free_smid(ioc, smid);
3446                 _scsih_tm_tr_send(ioc, delayed_tr->handle);
3447                 list_del(&delayed_tr->list);
3448                 kfree(delayed_tr);
3449                 return 0;
3450         }
3451 
3452         return 1;
3453 }
3454 
3455 /**
3456  * _scsih_check_topo_delete_events - sanity check on topo events
3457  * @ioc: per adapter object
3458  * @event_data: the event data payload
3459  *
3460  * This routine added to better handle cable breaker.
3461  *
3462  * This handles the case where driver receives multiple expander
3463  * add and delete events in a single shot.  When there is a delete event
3464  * the routine will void any pending add events waiting in the event queue.
3465  *
3466  * Return nothing.
3467  */
3468 static void
3469 _scsih_check_topo_delete_events(struct MPT2SAS_ADAPTER *ioc,
3470     Mpi2EventDataSasTopologyChangeList_t *event_data)
3471 {
3472         struct fw_event_work *fw_event;
3473         Mpi2EventDataSasTopologyChangeList_t *local_event_data;
3474         u16 expander_handle;
3475         struct _sas_node *sas_expander;
3476         unsigned long flags;
3477         int i, reason_code;
3478         u16 handle;
3479 
3480         for (i = 0 ; i < event_data->NumEntries; i++) {
3481                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3482                 if (!handle)
3483                         continue;
3484                 reason_code = event_data->PHY[i].PhyStatus &
3485                     MPI2_EVENT_SAS_TOPO_RC_MASK;
3486                 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)
3487                         _scsih_tm_tr_send(ioc, handle);
3488         }
3489 
3490         expander_handle = le16_to_cpu(event_data->ExpanderDevHandle);
3491         if (expander_handle < ioc->sas_hba.num_phys) {
3492                 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3493                 return;
3494         }
3495         if (event_data->ExpStatus ==
3496             MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING) {
3497                 /* put expander attached devices into blocking state */
3498                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
3499                 sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
3500                     expander_handle);
3501                 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
3502                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
3503                 do {
3504                         handle = find_first_bit(ioc->blocking_handles,
3505                             ioc->facts.MaxDevHandle);
3506                         if (handle < ioc->facts.MaxDevHandle)
3507                                 _scsih_block_io_device(ioc, handle);
3508                 } while (test_and_clear_bit(handle, ioc->blocking_handles));
3509         } else if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_RESPONDING)
3510                 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3511 
3512         if (event_data->ExpStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
3513                 return;
3514 
3515         /* mark ignore flag for pending events */
3516         spin_lock_irqsave(&ioc->fw_event_lock, flags);
3517         list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
3518                 if (fw_event->event != MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
3519                     fw_event->ignore)
3520                         continue;
3521                 local_event_data = fw_event->event_data;
3522                 if (local_event_data->ExpStatus ==
3523                     MPI2_EVENT_SAS_TOPO_ES_ADDED ||
3524                     local_event_data->ExpStatus ==
3525                     MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
3526                         if (le16_to_cpu(local_event_data->ExpanderDevHandle) ==
3527                             expander_handle) {
3528                                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3529                                     "setting ignoring flag\n", ioc->name));
3530                                 fw_event->ignore = 1;
3531                         }
3532                 }
3533         }
3534         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3535 }
3536 
3537 /**
3538  * _scsih_set_volume_delete_flag - setting volume delete flag
3539  * @ioc: per adapter object
3540  * @handle: device handle
3541  *
3542  * This
3543  * Return nothing.
3544  */
3545 static void
3546 _scsih_set_volume_delete_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3547 {
3548         struct _raid_device *raid_device;
3549         struct MPT2SAS_TARGET *sas_target_priv_data;
3550         unsigned long flags;
3551 
3552         spin_lock_irqsave(&ioc->raid_device_lock, flags);
3553         raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
3554         if (raid_device && raid_device->starget &&
3555             raid_device->starget->hostdata) {
3556                 sas_target_priv_data =
3557                     raid_device->starget->hostdata;
3558                 sas_target_priv_data->deleted = 1;
3559                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3560                     "setting delete flag: handle(0x%04x), "
3561                     "wwid(0x%016llx)\n", ioc->name, handle,
3562                     (unsigned long long) raid_device->wwid));
3563         }
3564         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
3565 }
3566 
3567 /**
3568  * _scsih_set_volume_handle_for_tr - set handle for target reset to volume
3569  * @handle: input handle
3570  * @a: handle for volume a
3571  * @b: handle for volume b
3572  *
3573  * IR firmware only supports two raid volumes.  The purpose of this
3574  * routine is to set the volume handle in either a or b. When the given
3575  * input handle is non-zero, or when a and b have not been set before.
3576  */
3577 static void
3578 _scsih_set_volume_handle_for_tr(u16 handle, u16 *a, u16 *b)
3579 {
3580         if (!handle || handle == *a || handle == *b)
3581                 return;
3582         if (!*a)
3583                 *a = handle;
3584         else if (!*b)
3585                 *b = handle;
3586 }
3587 
3588 /**
3589  * _scsih_check_ir_config_unhide_events - check for UNHIDE events
3590  * @ioc: per adapter object
3591  * @event_data: the event data payload
3592  * Context: interrupt time.
3593  *
3594  * This routine will send target reset to volume, followed by target
3595  * resets to the PDs. This is called when a PD has been removed, or
3596  * volume has been deleted or removed. When the target reset is sent
3597  * to volume, the PD target resets need to be queued to start upon
3598  * completion of the volume target reset.
3599  *
3600  * Return nothing.
3601  */
3602 static void
3603 _scsih_check_ir_config_unhide_events(struct MPT2SAS_ADAPTER *ioc,
3604     Mpi2EventDataIrConfigChangeList_t *event_data)
3605 {
3606         Mpi2EventIrConfigElement_t *element;
3607         int i;
3608         u16 handle, volume_handle, a, b;
3609         struct _tr_list *delayed_tr;
3610 
3611         a = 0;
3612         b = 0;
3613 
3614         if (ioc->is_warpdrive)
3615                 return;
3616 
3617         /* Volume Resets for Deleted or Removed */
3618         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3619         for (i = 0; i < event_data->NumElements; i++, element++) {
3620                 if (element->ReasonCode ==
3621                     MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED ||
3622                     element->ReasonCode ==
3623                     MPI2_EVENT_IR_CHANGE_RC_REMOVED) {
3624                         volume_handle = le16_to_cpu(element->VolDevHandle);
3625                         _scsih_set_volume_delete_flag(ioc, volume_handle);
3626                         _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
3627                 }
3628         }
3629 
3630         /* Volume Resets for UNHIDE events */
3631         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3632         for (i = 0; i < event_data->NumElements; i++, element++) {
3633                 if (le32_to_cpu(event_data->Flags) &
3634                     MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
3635                         continue;
3636                 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_UNHIDE) {
3637                         volume_handle = le16_to_cpu(element->VolDevHandle);
3638                         _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
3639                 }
3640         }
3641 
3642         if (a)
3643                 _scsih_tm_tr_volume_send(ioc, a);
3644         if (b)
3645                 _scsih_tm_tr_volume_send(ioc, b);
3646 
3647         /* PD target resets */
3648         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3649         for (i = 0; i < event_data->NumElements; i++, element++) {
3650                 if (element->ReasonCode != MPI2_EVENT_IR_CHANGE_RC_UNHIDE)
3651                         continue;
3652                 handle = le16_to_cpu(element->PhysDiskDevHandle);
3653                 volume_handle = le16_to_cpu(element->VolDevHandle);
3654                 clear_bit(handle, ioc->pd_handles);
3655                 if (!volume_handle)
3656                         _scsih_tm_tr_send(ioc, handle);
3657                 else if (volume_handle == a || volume_handle == b) {
3658                         delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3659                         BUG_ON(!delayed_tr);
3660                         INIT_LIST_HEAD(&delayed_tr->list);
3661                         delayed_tr->handle = handle;
3662                         list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3663                         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3664                             "DELAYED:tr:handle(0x%04x), (open)\n", ioc->name,
3665                             handle));
3666                 } else
3667                         _scsih_tm_tr_send(ioc, handle);
3668         }
3669 }
3670 
3671 
3672 /**
3673  * _scsih_check_volume_delete_events - set delete flag for volumes
3674  * @ioc: per adapter object
3675  * @event_data: the event data payload
3676  * Context: interrupt time.
3677  *
3678  * This will handle the case when the cable connected to entire volume is
3679  * pulled. We will take care of setting the deleted flag so normal IO will
3680  * not be sent.
3681  *
3682  * Return nothing.
3683  */
3684 static void
3685 _scsih_check_volume_delete_events(struct MPT2SAS_ADAPTER *ioc,
3686     Mpi2EventDataIrVolume_t *event_data)
3687 {
3688         u32 state;
3689 
3690         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
3691                 return;
3692         state = le32_to_cpu(event_data->NewValue);
3693         if (state == MPI2_RAID_VOL_STATE_MISSING || state ==
3694             MPI2_RAID_VOL_STATE_FAILED)
3695                 _scsih_set_volume_delete_flag(ioc,
3696                     le16_to_cpu(event_data->VolDevHandle));
3697 }
3698 
3699 /**
3700  * _scsih_flush_running_cmds - completing outstanding commands.
3701  * @ioc: per adapter object
3702  *
3703  * The flushing out of all pending scmd commands following host reset,
3704  * where all IO is dropped to the floor.
3705  *
3706  * Return nothing.
3707  */
3708 static void
3709 _scsih_flush_running_cmds(struct MPT2SAS_ADAPTER *ioc)
3710 {
3711         struct scsi_cmnd *scmd;
3712         u16 smid;
3713         u16 count = 0;
3714 
3715         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
3716                 scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
3717                 if (!scmd)
3718                         continue;
3719                 count++;
3720                 mpt2sas_base_free_smid(ioc, smid);
3721                 scsi_dma_unmap(scmd);
3722                 if (ioc->pci_error_recovery)
3723                         scmd->result = DID_NO_CONNECT << 16;
3724                 else
3725                         scmd->result = DID_RESET << 16;
3726                 scmd->scsi_done(scmd);
3727         }
3728         dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "completing %d cmds\n",
3729             ioc->name, count));
3730 }
3731 
3732 /**
3733  * _scsih_setup_eedp - setup MPI request for EEDP transfer
3734  * @scmd: pointer to scsi command object
3735  * @mpi_request: pointer to the SCSI_IO reqest message frame
3736  *
3737  * Supporting protection 1 and 3.
3738  *
3739  * Returns nothing
3740  */
3741 static void
3742 _scsih_setup_eedp(struct scsi_cmnd *scmd, Mpi2SCSIIORequest_t *mpi_request)
3743 {
3744         u16 eedp_flags;
3745         unsigned char prot_op = scsi_get_prot_op(scmd);
3746         unsigned char prot_type = scsi_get_prot_type(scmd);
3747 
3748         if (prot_type == SCSI_PROT_DIF_TYPE0 || prot_op == SCSI_PROT_NORMAL)
3749                 return;
3750 
3751         if (prot_op ==  SCSI_PROT_READ_STRIP)
3752                 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP;
3753         else if (prot_op ==  SCSI_PROT_WRITE_INSERT)
3754                 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP;
3755         else
3756                 return;
3757 
3758         switch (prot_type) {
3759         case SCSI_PROT_DIF_TYPE1:
3760         case SCSI_PROT_DIF_TYPE2:
3761 
3762                 /*
3763                 * enable ref/guard checking
3764                 * auto increment ref tag
3765                 */
3766                 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
3767                     MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
3768                     MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
3769                 mpi_request->CDB.EEDP32.PrimaryReferenceTag =
3770                     cpu_to_be32(scsi_get_lba(scmd));
3771                 break;
3772 
3773         case SCSI_PROT_DIF_TYPE3:
3774 
3775                 /*
3776                 * enable guard checking
3777                 */
3778                 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
3779                 break;
3780         }
3781         mpi_request->EEDPBlockSize = cpu_to_le32(scmd->device->sector_size);
3782         mpi_request->EEDPFlags = cpu_to_le16(eedp_flags);
3783 }
3784 
3785 /**
3786  * _scsih_eedp_error_handling - return sense code for EEDP errors
3787  * @scmd: pointer to scsi command object
3788  * @ioc_status: ioc status
3789  *
3790  * Returns nothing
3791  */
3792 static void
3793 _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
3794 {
3795         u8 ascq;
3796 
3797         switch (ioc_status) {
3798         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
3799                 ascq = 0x01;
3800                 break;
3801         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
3802                 ascq = 0x02;
3803                 break;
3804         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
3805                 ascq = 0x03;
3806                 break;
3807         default:
3808                 ascq = 0x00;
3809                 break;
3810         }
3811 
3812         scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 0x10, ascq);
3813         scmd->result = DRIVER_SENSE << 24 | (DID_ABORT << 16) |
3814             SAM_STAT_CHECK_CONDITION;
3815 }
3816 
3817 /**
3818  * _scsih_scsi_direct_io_get - returns direct io flag
3819  * @ioc: per adapter object
3820  * @smid: system request message index
3821  *
3822  * Returns the smid stored scmd pointer.
3823  */
3824 static inline u8
3825 _scsih_scsi_direct_io_get(struct MPT2SAS_ADAPTER *ioc, u16 smid)
3826 {
3827         return ioc->scsi_lookup[smid - 1].direct_io;
3828 }
3829 
3830 /**
3831  * _scsih_scsi_direct_io_set - sets direct io flag
3832  * @ioc: per adapter object
3833  * @smid: system request message index
3834  * @direct_io: Zero or non-zero value to set in the direct_io flag
3835  *
3836  * Returns Nothing.
3837  */
3838 static inline void
3839 _scsih_scsi_direct_io_set(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 direct_io)
3840 {
3841         ioc->scsi_lookup[smid - 1].direct_io = direct_io;
3842 }
3843 
3844 
3845 /**
3846  * _scsih_setup_direct_io - setup MPI request for WARPDRIVE Direct I/O
3847  * @ioc: per adapter object
3848  * @scmd: pointer to scsi command object
3849  * @raid_device: pointer to raid device data structure
3850  * @mpi_request: pointer to the SCSI_IO reqest message frame
3851  * @smid: system request message index
3852  *
3853  * Returns nothing
3854  */
3855 static void
3856 _scsih_setup_direct_io(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
3857         struct _raid_device *raid_device, Mpi2SCSIIORequest_t *mpi_request,
3858         u16 smid)
3859 {
3860         u32 v_lba, p_lba, stripe_off, stripe_unit, column, io_size;
3861         u32 stripe_sz, stripe_exp;
3862         u8 num_pds, *cdb_ptr, i;
3863         u8 cdb0 = scmd->cmnd[0];
3864         u64 v_llba;
3865 
3866         /*
3867          * Try Direct I/O to RAID memeber disks
3868          */
3869         if (cdb0 == READ_16 || cdb0 == READ_10 ||
3870             cdb0 == WRITE_16 || cdb0 == WRITE_10) {
3871                 cdb_ptr = mpi_request->CDB.CDB32;
3872 
3873                 if ((cdb0 < READ_16) || !(cdb_ptr[2] | cdb_ptr[3] | cdb_ptr[4]
3874                         | cdb_ptr[5])) {
3875                         io_size = scsi_bufflen(scmd) >>
3876                             raid_device->block_exponent;
3877                         i = (cdb0 < READ_16) ? 2 : 6;
3878                         /* get virtual lba */
3879                         v_lba = be32_to_cpu(*(__be32 *)(&cdb_ptr[i]));
3880 
3881                         if (((u64)v_lba + (u64)io_size - 1) <=
3882                             (u32)raid_device->max_lba) {
3883                                 stripe_sz = raid_device->stripe_sz;
3884                                 stripe_exp = raid_device->stripe_exponent;
3885                                 stripe_off = v_lba & (stripe_sz - 1);
3886 
3887                                 /* Check whether IO falls within a stripe */
3888                                 if ((stripe_off + io_size) <= stripe_sz) {
3889                                         num_pds = raid_device->num_pds;
3890                                         p_lba = v_lba >> stripe_exp;
3891                                         stripe_unit = p_lba / num_pds;
3892                                         column = p_lba % num_pds;
3893                                         p_lba = (stripe_unit << stripe_exp) +
3894                                             stripe_off;
3895                                         mpi_request->DevHandle =
3896                                                 cpu_to_le16(raid_device->
3897                                                     pd_handle[column]);
3898                                         (*(__be32 *)(&cdb_ptr[i])) =
3899                                                 cpu_to_be32(p_lba);
3900                                         /*
3901                                         * WD: To indicate this I/O is directI/O
3902                                         */
3903                                         _scsih_scsi_direct_io_set(ioc, smid, 1);
3904                                 }
3905                         }
3906                 } else {
3907                         io_size = scsi_bufflen(scmd) >>
3908                             raid_device->block_exponent;
3909                         /* get virtual lba */
3910                         v_llba = be64_to_cpu(*(__be64 *)(&cdb_ptr[2]));
3911 
3912                         if ((v_llba + (u64)io_size - 1) <=
3913                             raid_device->max_lba) {
3914                                 stripe_sz = raid_device->stripe_sz;
3915                                 stripe_exp = raid_device->stripe_exponent;
3916                                 stripe_off = (u32) (v_llba & (stripe_sz - 1));
3917 
3918                                 /* Check whether IO falls within a stripe */
3919                                 if ((stripe_off + io_size) <= stripe_sz) {
3920                                         num_pds = raid_device->num_pds;
3921                                         p_lba = (u32)(v_llba >> stripe_exp);
3922                                         stripe_unit = p_lba / num_pds;
3923                                         column = p_lba % num_pds;
3924                                         p_lba = (stripe_unit << stripe_exp) +
3925                                             stripe_off;
3926                                         mpi_request->DevHandle =
3927                                                 cpu_to_le16(raid_device->
3928                                                     pd_handle[column]);
3929                                         (*(__be64 *)(&cdb_ptr[2])) =
3930                                             cpu_to_be64((u64)p_lba);
3931                                         /*
3932                                         * WD: To indicate this I/O is directI/O
3933                                         */
3934                                         _scsih_scsi_direct_io_set(ioc, smid, 1);
3935                                 }
3936                         }
3937                 }
3938         }
3939 }
3940 
3941 /**
3942  * _scsih_qcmd - main scsi request entry point
3943  * @scmd: pointer to scsi command object
3944  * @done: function pointer to be invoked on completion
3945  *
3946  * The callback index is set inside `ioc->scsi_io_cb_idx`.
3947  *
3948  * Returns 0 on success.  If there's a failure, return either:
3949  * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or
3950  * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full
3951  */
3952 static int
3953 _scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
3954 {
3955         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
3956         struct MPT2SAS_DEVICE *sas_device_priv_data;
3957         struct MPT2SAS_TARGET *sas_target_priv_data;
3958         struct _raid_device *raid_device;
3959         Mpi2SCSIIORequest_t *mpi_request;
3960         u32 mpi_control;
3961         u16 smid;
3962 
3963         sas_device_priv_data = scmd->device->hostdata;
3964         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
3965                 scmd->result = DID_NO_CONNECT << 16;
3966                 scmd->scsi_done(scmd);
3967                 return 0;
3968         }
3969 
3970         if (ioc->pci_error_recovery || ioc->remove_host) {
3971                 scmd->result = DID_NO_CONNECT << 16;
3972                 scmd->scsi_done(scmd);
3973                 return 0;
3974         }
3975 
3976         sas_target_priv_data = sas_device_priv_data->sas_target;
3977         /* invalid device handle */
3978         if (sas_target_priv_data->handle == MPT2SAS_INVALID_DEVICE_HANDLE) {
3979                 scmd->result = DID_NO_CONNECT << 16;
3980                 scmd->scsi_done(scmd);
3981                 return 0;
3982         }
3983 
3984         /* host recovery or link resets sent via IOCTLs */
3985         if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress)
3986                 return SCSI_MLQUEUE_HOST_BUSY;
3987         /* device busy with task management */
3988         else if (sas_device_priv_data->block || sas_target_priv_data->tm_busy)
3989                 return SCSI_MLQUEUE_DEVICE_BUSY;
3990         /* device has been deleted */
3991         else if (sas_target_priv_data->deleted) {
3992                 scmd->result = DID_NO_CONNECT << 16;
3993                 scmd->scsi_done(scmd);
3994                 return 0;
3995         }
3996 
3997         if (scmd->sc_data_direction == DMA_FROM_DEVICE)
3998                 mpi_control = MPI2_SCSIIO_CONTROL_READ;
3999         else if (scmd->sc_data_direction == DMA_TO_DEVICE)
4000                 mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
4001         else
4002                 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
4003 
4004         /* set tags */
4005         if (!(sas_device_priv_data->flags & MPT_DEVICE_FLAGS_INIT)) {
4006                 if (scmd->device->tagged_supported) {
4007                         if (scmd->device->ordered_tags)
4008                                 mpi_control |= MPI2_SCSIIO_CONTROL_ORDEREDQ;
4009                         else
4010                                 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
4011                 } else
4012                         mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
4013         } else
4014                 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
4015         /* Make sure Device is not raid volume.
4016          * We do not expose raid functionality to upper layer for warpdrive.
4017          */
4018         if (!ioc->is_warpdrive && !_scsih_is_raid(&scmd->device->sdev_gendev) &&
4019             sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32)
4020                 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
4021 
4022         smid = mpt2sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
4023         if (!smid) {
4024                 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
4025                     ioc->name, __func__);
4026                 goto out;
4027         }
4028         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
4029         memset(mpi_request, 0, sizeof(Mpi2SCSIIORequest_t));
4030         _scsih_setup_eedp(scmd, mpi_request);
4031         if (scmd->cmd_len == 32)
4032                 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT;
4033         mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
4034         if (sas_device_priv_data->sas_target->flags &
4035             MPT_TARGET_FLAGS_RAID_COMPONENT)
4036                 mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
4037         else
4038         mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
4039         mpi_request->DevHandle =
4040             cpu_to_le16(sas_device_priv_data->sas_target->handle);
4041         mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
4042         mpi_request->Control = cpu_to_le32(mpi_control);
4043         mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len);
4044         mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR;
4045         mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
4046         mpi_request->SenseBufferLowAddress =
4047             mpt2sas_base_get_sense_buffer_dma(ioc, smid);
4048         mpi_request->SGLOffset0 = offsetof(Mpi2SCSIIORequest_t, SGL) / 4;
4049         mpi_request->SGLFlags = cpu_to_le16(MPI2_SCSIIO_SGLFLAGS_TYPE_MPI +
4050             MPI2_SCSIIO_SGLFLAGS_SYSTEM_ADDR);
4051         mpi_request->VF_ID = 0; /* TODO */
4052         mpi_request->VP_ID = 0;
4053         int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *)
4054             mpi_request->LUN);
4055         memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
4056 
4057         if (!mpi_request->DataLength) {
4058                 mpt2sas_base_build_zero_len_sge(ioc, &mpi_request->SGL);
4059         } else {
4060                 if (_scsih_build_scatter_gather(ioc, scmd, smid)) {
4061                         mpt2sas_base_free_smid(ioc, smid);
4062                         goto out;
4063                 }
4064         }
4065 
4066         raid_device = sas_target_priv_data->raid_device;
4067         if (raid_device && raid_device->direct_io_enabled)
4068                 _scsih_setup_direct_io(ioc, scmd, raid_device, mpi_request,
4069                     smid);
4070 
4071         if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST))
4072                 mpt2sas_base_put_smid_scsi_io(ioc, smid,
4073                     le16_to_cpu(mpi_request->DevHandle));
4074         else
4075                 mpt2sas_base_put_smid_default(ioc, smid);
4076         return 0;
4077 
4078  out:
4079         return SCSI_MLQUEUE_HOST_BUSY;
4080 }
4081 
4082 /**
4083  * _scsih_normalize_sense - normalize descriptor and fixed format sense data
4084  * @sense_buffer: sense data returned by target
4085  * @data: normalized skey/asc/ascq
4086  *
4087  * Return nothing.
4088  */
4089 static void
4090 _scsih_normalize_sense(char *sense_buffer, struct sense_info *data)
4091 {
4092         if ((sense_buffer[0] & 0x7F) >= 0x72) {
4093                 /* descriptor format */
4094                 data->skey = sense_buffer[1] & 0x0F;
4095                 data->asc = sense_buffer[2];
4096                 data->ascq = sense_buffer[3];
4097         } else {
4098                 /* fixed format */
4099                 data->skey = sense_buffer[2] & 0x0F;
4100                 data->asc = sense_buffer[12];
4101                 data->ascq = sense_buffer[13];
4102         }
4103 }
4104 
4105 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4106 /**
4107  * _scsih_scsi_ioc_info - translated non-successful SCSI_IO request
4108  * @ioc: per adapter object
4109  * @scmd: pointer to scsi command object
4110  * @mpi_reply: reply mf payload returned from firmware
4111  *
4112  * scsi_status - SCSI Status code returned from target device
4113  * scsi_state - state info associated with SCSI_IO determined by ioc
4114  * ioc_status - ioc supplied status info
4115  *
4116  * Return nothing.
4117  */
4118 static void
4119 _scsih_scsi_ioc_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
4120     Mpi2SCSIIOReply_t *mpi_reply, u16 smid)
4121 {
4122         u32 response_info;
4123         u8 *response_bytes;
4124         u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) &
4125             MPI2_IOCSTATUS_MASK;
4126         u8 scsi_state = mpi_reply->SCSIState;
4127         u8 scsi_status = mpi_reply->SCSIStatus;
4128         char *desc_ioc_state = NULL;
4129         char *desc_scsi_status = NULL;
4130         char *desc_scsi_state = ioc->tmp_string;
4131         u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
4132         struct _sas_device *sas_device = NULL;
4133         unsigned long flags;
4134         struct scsi_target *starget = scmd->device->sdev_target;
4135         struct MPT2SAS_TARGET *priv_target = starget->hostdata;
4136         char *device_str = NULL;
4137 
4138         if (!priv_target)
4139                 return;
4140 
4141         if (ioc->hide_ir_msg)
4142                 device_str = "WarpDrive";
4143         else
4144                 device_str = "volume";
4145 
4146         if (log_info == 0x31170000)
4147                 return;
4148 
4149         switch (ioc_status) {
4150         case MPI2_IOCSTATUS_SUCCESS:
4151                 desc_ioc_state = "success";
4152                 break;
4153         case MPI2_IOCSTATUS_INVALID_FUNCTION:
4154                 desc_ioc_state = "invalid function";
4155                 break;
4156         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4157                 desc_ioc_state = "scsi recovered error";
4158                 break;
4159         case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE:
4160                 desc_ioc_state = "scsi invalid dev handle";
4161                 break;
4162         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4163                 desc_ioc_state = "scsi device not there";
4164                 break;
4165         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4166                 desc_ioc_state = "scsi data overrun";
4167                 break;
4168         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4169                 desc_ioc_state = "scsi data underrun";
4170                 break;
4171         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4172                 desc_ioc_state = "scsi io data error";
4173                 break;
4174         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4175                 desc_ioc_state = "scsi protocol error";
4176                 break;
4177         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4178                 desc_ioc_state = "scsi task terminated";
4179                 break;
4180         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4181                 desc_ioc_state = "scsi residual mismatch";
4182                 break;
4183         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4184                 desc_ioc_state = "scsi task mgmt failed";
4185                 break;
4186         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4187                 desc_ioc_state = "scsi ioc terminated";
4188                 break;
4189         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4190                 desc_ioc_state = "scsi ext terminated";
4191                 break;
4192         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4193                 desc_ioc_state = "eedp guard error";
4194                 break;
4195         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4196                 desc_ioc_state = "eedp ref tag error";
4197                 break;
4198         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4199                 desc_ioc_state = "eedp app tag error";
4200                 break;
4201         default:
4202                 desc_ioc_state = "unknown";
4203                 break;
4204         }
4205 
4206         switch (scsi_status) {
4207         case MPI2_SCSI_STATUS_GOOD:
4208                 desc_scsi_status = "good";
4209                 break;
4210         case MPI2_SCSI_STATUS_CHECK_CONDITION:
4211                 desc_scsi_status = "check condition";
4212                 break;
4213         case MPI2_SCSI_STATUS_CONDITION_MET:
4214                 desc_scsi_status = "condition met";
4215                 break;
4216         case MPI2_SCSI_STATUS_BUSY:
4217                 desc_scsi_status = "busy";
4218                 break;
4219         case MPI2_SCSI_STATUS_INTERMEDIATE:
4220                 desc_scsi_status = "intermediate";
4221                 break;
4222         case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET:
4223                 desc_scsi_status = "intermediate condmet";
4224                 break;
4225         case MPI2_SCSI_STATUS_RESERVATION_CONFLICT:
4226                 desc_scsi_status = "reservation conflict";
4227                 break;
4228         case MPI2_SCSI_STATUS_COMMAND_TERMINATED:
4229                 desc_scsi_status = "command terminated";
4230                 break;
4231         case MPI2_SCSI_STATUS_TASK_SET_FULL:
4232                 desc_scsi_status = "task set full";
4233                 break;
4234         case MPI2_SCSI_STATUS_ACA_ACTIVE:
4235                 desc_scsi_status = "aca active";
4236                 break;
4237         case MPI2_SCSI_STATUS_TASK_ABORTED:
4238                 desc_scsi_status = "task aborted";
4239                 break;
4240         default:
4241                 desc_scsi_status = "unknown";
4242                 break;
4243         }
4244 
4245         desc_scsi_state[0] = '\0';
4246         if (!scsi_state)
4247                 desc_scsi_state = " ";
4248         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4249                 strcat(desc_scsi_state, "response info ");
4250         if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4251                 strcat(desc_scsi_state, "state terminated ");
4252         if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS)
4253                 strcat(desc_scsi_state, "no status ");
4254         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED)
4255                 strcat(desc_scsi_state, "autosense failed ");
4256         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)
4257                 strcat(desc_scsi_state, "autosense valid ");
4258 
4259         scsi_print_command(scmd);
4260 
4261         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
4262                 printk(MPT2SAS_WARN_FMT "\t%s wwid(0x%016llx)\n", ioc->name,
4263                     device_str, (unsigned long long)priv_target->sas_address);
4264         } else {
4265                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4266                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
4267                     priv_target->sas_address);
4268                 if (sas_device) {
4269                         printk(MPT2SAS_WARN_FMT "\tsas_address(0x%016llx), "
4270                             "phy(%d)\n", ioc->name, sas_device->sas_address,
4271                             sas_device->phy);
4272                         printk(MPT2SAS_WARN_FMT
4273                             "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
4274                             ioc->name, sas_device->enclosure_logical_id,
4275                             sas_device->slot);
4276                 }
4277                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4278         }
4279 
4280         printk(MPT2SAS_WARN_FMT "\thandle(0x%04x), ioc_status(%s)(0x%04x), "
4281             "smid(%d)\n", ioc->name, le16_to_cpu(mpi_reply->DevHandle),
4282             desc_ioc_state, ioc_status, smid);
4283         printk(MPT2SAS_WARN_FMT "\trequest_len(%d), underflow(%d), "
4284             "resid(%d)\n", ioc->name, scsi_bufflen(scmd), scmd->underflow,
4285             scsi_get_resid(scmd));
4286         printk(MPT2SAS_WARN_FMT "\ttag(%d), transfer_count(%d), "
4287             "sc->result(0x%08x)\n", ioc->name, le16_to_cpu(mpi_reply->TaskTag),
4288             le32_to_cpu(mpi_reply->TransferCount), scmd->result);
4289         printk(MPT2SAS_WARN_FMT "\tscsi_status(%s)(0x%02x), "
4290             "scsi_state(%s)(0x%02x)\n", ioc->name, desc_scsi_status,
4291             scsi_status, desc_scsi_state, scsi_state);
4292 
4293         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
4294                 struct sense_info data;
4295                 _scsih_normalize_sense(scmd->sense_buffer, &data);
4296                 printk(MPT2SAS_WARN_FMT "\t[sense_key,asc,ascq]: "
4297                     "[0x%02x,0x%02x,0x%02x], count(%d)\n", ioc->name, data.skey,
4298                     data.asc, data.ascq, le32_to_cpu(mpi_reply->SenseCount));
4299         }
4300 
4301         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
4302                 response_info = le32_to_cpu(mpi_reply->ResponseInfo);
4303                 response_bytes = (u8 *)&response_info;
4304                 _scsih_response_code(ioc, response_bytes[0]);
4305         }
4306 }
4307 #endif
4308 
4309 /**
4310  * _scsih_turn_on_fault_led - illuminate Fault LED
4311  * @ioc: per adapter object
4312  * @handle: device handle
4313  * Context: process
4314  *
4315  * Return nothing.
4316  */
4317 static void
4318 _scsih_turn_on_fault_led(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4319 {
4320         Mpi2SepReply_t mpi_reply;
4321         Mpi2SepRequest_t mpi_request;
4322 
4323         memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
4324         mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
4325         mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
4326         mpi_request.SlotStatus =
4327             cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
4328         mpi_request.DevHandle = cpu_to_le16(handle);
4329         mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
4330         if ((mpt2sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
4331             &mpi_request)) != 0) {
4332                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n", ioc->name,
4333                 __FILE__, __LINE__, __func__);
4334                 return;
4335         }
4336 
4337         if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
4338                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "enclosure_processor: "
4339                     "ioc_status (0x%04x), loginfo(0x%08x)\n", ioc->name,
4340                     le16_to_cpu(mpi_reply.IOCStatus),
4341                     le32_to_cpu(mpi_reply.IOCLogInfo)));
4342                 return;
4343         }
4344 }
4345 
4346 /**
4347  * _scsih_send_event_to_turn_on_fault_led - fire delayed event
4348  * @ioc: per adapter object
4349  * @handle: device handle
4350  * Context: interrupt.
4351  *
4352  * Return nothing.
4353  */
4354 static void
4355 _scsih_send_event_to_turn_on_fault_led(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4356 {
4357         struct fw_event_work *fw_event;
4358 
4359         fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
4360         if (!fw_event)
4361                 return;
4362         fw_event->event = MPT2SAS_TURN_ON_FAULT_LED;
4363         fw_event->device_handle = handle;
4364         fw_event->ioc = ioc;
4365         _scsih_fw_event_add(ioc, fw_event);
4366 }
4367 
4368 /**
4369  * _scsih_smart_predicted_fault - process smart errors
4370  * @ioc: per adapter object
4371  * @handle: device handle
4372  * Context: interrupt.
4373  *
4374  * Return nothing.
4375  */
4376 static void
4377 _scsih_smart_predicted_fault(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4378 {
4379         struct scsi_target *starget;
4380         struct MPT2SAS_TARGET *sas_target_priv_data;
4381         Mpi2EventNotificationReply_t *event_reply;
4382         Mpi2EventDataSasDeviceStatusChange_t *event_data;
4383         struct _sas_device *sas_device;
4384         ssize_t sz;
4385         unsigned long flags;
4386 
4387         /* only handle non-raid devices */
4388         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4389         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4390         if (!sas_device) {
4391                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4392                 return;
4393         }
4394         starget = sas_device->starget;
4395         sas_target_priv_data = starget->hostdata;
4396 
4397         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) ||
4398            ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))) {
4399                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4400                 return;
4401         }
4402         starget_printk(KERN_WARNING, starget, "predicted fault\n");
4403         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4404 
4405         if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
4406                 _scsih_send_event_to_turn_on_fault_led(ioc, handle);
4407 
4408         /* insert into event log */
4409         sz = offsetof(Mpi2EventNotificationReply_t, EventData) +
4410              sizeof(Mpi2EventDataSasDeviceStatusChange_t);
4411         event_reply = kzalloc(sz, GFP_ATOMIC);
4412         if (!event_reply) {
4413                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4414                     ioc->name, __FILE__, __LINE__, __func__);
4415                 return;
4416         }
4417 
4418         event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION;
4419         event_reply->Event =
4420             cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE);
4421         event_reply->MsgLength = sz/4;
4422         event_reply->EventDataLength =
4423             cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4);
4424         event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
4425             event_reply->EventData;
4426         event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
4427         event_data->ASC = 0x5D;
4428         event_data->DevHandle = cpu_to_le16(handle);
4429         event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
4430         mpt2sas_ctl_add_to_event_log(ioc, event_reply);
4431         kfree(event_reply);
4432 }
4433 
4434 /**
4435  * _scsih_io_done - scsi request callback
4436  * @ioc: per adapter object
4437  * @smid: system request message index
4438  * @msix_index: MSIX table index supplied by the OS
4439  * @reply: reply message frame(lower 32bit addr)
4440  *
4441  * Callback handler when using _scsih_qcmd.
4442  *
4443  * Return 1 meaning mf should be freed from _base_interrupt
4444  *        0 means the mf is freed from this function.
4445  */
4446 static u8
4447 _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
4448 {
4449         Mpi2SCSIIORequest_t *mpi_request;
4450         Mpi2SCSIIOReply_t *mpi_reply;
4451         struct scsi_cmnd *scmd;
4452         u16 ioc_status;
4453         u32 xfer_cnt;
4454         u8 scsi_state;
4455         u8 scsi_status;
4456         u32 log_info;
4457         struct MPT2SAS_DEVICE *sas_device_priv_data;
4458         u32 response_code = 0;
4459         unsigned long flags;
4460 
4461         mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
4462         scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
4463         if (scmd == NULL)
4464                 return 1;
4465 
4466         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
4467 
4468         if (mpi_reply == NULL) {
4469                 scmd->result = DID_OK << 16;
4470                 goto out;
4471         }
4472 
4473         sas_device_priv_data = scmd->device->hostdata;
4474         if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
4475              sas_device_priv_data->sas_target->deleted) {
4476                 scmd->result = DID_NO_CONNECT << 16;
4477                 goto out;
4478         }
4479         ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
4480         /*
4481          * WARPDRIVE: If direct_io is set then it is directIO,
4482          * the failed direct I/O should be redirected to volume
4483          */
4484         if (_scsih_scsi_direct_io_get(ioc, smid) &&
4485             ((ioc_status & MPI2_IOCSTATUS_MASK)
4486             != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) {
4487                 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4488                 ioc->scsi_lookup[smid - 1].scmd = scmd;
4489                 _scsih_scsi_direct_io_set(ioc, smid, 0);
4490                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4491                 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
4492                 mpi_request->DevHandle =
4493                     cpu_to_le16(sas_device_priv_data->sas_target->handle);
4494                 mpt2sas_base_put_smid_scsi_io(ioc, smid,
4495                     sas_device_priv_data->sas_target->handle);
4496                 return 0;
4497         }
4498 
4499 
4500         /* turning off TLR */
4501         scsi_state = mpi_reply->SCSIState;
4502         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4503                 response_code =
4504                     le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
4505         if (!sas_device_priv_data->tlr_snoop_check) {
4506                 sas_device_priv_data->tlr_snoop_check++;
4507         /* Make sure Device is not raid volume.
4508          * We do not expose raid functionality to upper layer for warpdrive.
4509          */
4510         if (!ioc->is_warpdrive && !_scsih_is_raid(&scmd->device->sdev_gendev) &&
4511                 sas_is_tlr_enabled(scmd->device) &&
4512                     response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) {
4513                         sas_disable_tlr(scmd->device);
4514                         sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n");
4515                 }
4516         }
4517 
4518         xfer_cnt = le32_to_cpu(mpi_reply->TransferCount);
4519         scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt);
4520         if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
4521                 log_info =  le32_to_cpu(mpi_reply->IOCLogInfo);
4522         else
4523                 log_info = 0;
4524         ioc_status &= MPI2_IOCSTATUS_MASK;
4525         scsi_status = mpi_reply->SCSIStatus;
4526 
4527         if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
4528             (scsi_status == MPI2_SCSI_STATUS_BUSY ||
4529              scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT ||
4530              scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) {
4531                 ioc_status = MPI2_IOCSTATUS_SUCCESS;
4532         }
4533 
4534         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
4535                 struct sense_info data;
4536                 const void *sense_data = mpt2sas_base_get_sense_buffer(ioc,
4537                     smid);
4538                 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
4539                     le32_to_cpu(mpi_reply->SenseCount));
4540                 memcpy(scmd->sense_buffer, sense_data, sz);
4541                 _scsih_normalize_sense(scmd->sense_buffer, &data);
4542                 /* failure prediction threshold exceeded */
4543                 if (data.asc == 0x5D)
4544                         _scsih_smart_predicted_fault(ioc,
4545                             le16_to_cpu(mpi_reply->DevHandle));
4546         }
4547 
4548         switch (ioc_status) {
4549         case MPI2_IOCSTATUS_BUSY:
4550         case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES:
4551                 scmd->result = SAM_STAT_BUSY;
4552                 break;
4553 
4554         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4555                 scmd->result = DID_NO_CONNECT << 16;
4556                 break;
4557 
4558         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4559                 if (sas_device_priv_data->block) {
4560                         scmd->result = DID_TRANSPORT_DISRUPTED << 16;
4561                         goto out;
4562                 }
4563                 scmd->result = DID_SOFT_ERROR << 16;
4564                 break;
4565         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4566         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4567                 scmd->result = DID_RESET << 16;
4568                 break;
4569 
4570         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4571                 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt))
4572                         scmd->result = DID_SOFT_ERROR << 16;
4573                 else
4574                         scmd->result = (DID_OK << 16) | scsi_status;
4575                 break;
4576 
4577         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4578                 scmd->result = (DID_OK << 16) | scsi_status;
4579 
4580                 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID))
4581                         break;
4582 
4583                 if (xfer_cnt < scmd->underflow) {
4584                         if (scsi_status == SAM_STAT_BUSY)
4585                                 scmd->result = SAM_STAT_BUSY;
4586                         else
4587                                 scmd->result = DID_SOFT_ERROR << 16;
4588                 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
4589                      MPI2_SCSI_STATE_NO_SCSI_STATUS))
4590                         scmd->result = DID_SOFT_ERROR << 16;
4591                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4592                         scmd->result = DID_RESET << 16;
4593                 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
4594                         mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
4595                         mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
4596                         scmd->result = (DRIVER_SENSE << 24) |
4597                             SAM_STAT_CHECK_CONDITION;
4598                         scmd->sense_buffer[0] = 0x70;
4599                         scmd->sense_buffer[2] = ILLEGAL_REQUEST;
4600                         scmd->sense_buffer[12] = 0x20;
4601                         scmd->sense_buffer[13] = 0;
4602                 }
4603                 break;
4604 
4605         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4606                 scsi_set_resid(scmd, 0);
4607         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4608         case MPI2_IOCSTATUS_SUCCESS:
4609                 scmd->result = (DID_OK << 16) | scsi_status;
4610                 if (response_code ==
4611                     MPI2_SCSITASKMGMT_RSP_INVALID_FRAME ||
4612                     (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
4613                      MPI2_SCSI_STATE_NO_SCSI_STATUS)))
4614                         scmd->result = DID_SOFT_ERROR << 16;
4615                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4616                         scmd->result = DID_RESET << 16;
4617                 break;
4618 
4619         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4620         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4621         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4622                 _scsih_eedp_error_handling(scmd, ioc_status);
4623                 break;
4624         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4625         case MPI2_IOCSTATUS_INVALID_FUNCTION:
4626         case MPI2_IOCSTATUS_INVALID_SGL:
4627         case MPI2_IOCSTATUS_INTERNAL_ERROR:
4628         case MPI2_IOCSTATUS_INVALID_FIELD:
4629         case MPI2_IOCSTATUS_INVALID_STATE:
4630         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4631         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4632         default:
4633                 scmd->result = DID_SOFT_ERROR << 16;
4634                 break;
4635 
4636         }
4637 
4638 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4639         if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
4640                 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
4641 #endif
4642 
4643  out:
4644         scsi_dma_unmap(scmd);
4645         scmd->scsi_done(scmd);
4646         return 1;
4647 }
4648 
4649 /**
4650  * _scsih_sas_host_refresh - refreshing sas host object contents
4651  * @ioc: per adapter object
4652  * Context: user
4653  *
4654  * During port enable, fw will send topology events for every device. Its
4655  * possible that the handles may change from the previous setting, so this
4656  * code keeping handles updating if changed.
4657  *
4658  * Return nothing.
4659  */
4660 static void
4661 _scsih_sas_host_refresh(struct MPT2SAS_ADAPTER *ioc)
4662 {
4663         u16 sz;
4664         u16 ioc_status;
4665         int i;
4666         Mpi2ConfigReply_t mpi_reply;
4667         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
4668         u16 attached_handle;
4669         u8 link_rate;
4670 
4671         dtmprintk(ioc, printk(MPT2SAS_INFO_FMT
4672             "updating handles for sas_host(0x%016llx)\n",
4673             ioc->name, (unsigned long long)ioc->sas_hba.sas_address));
4674 
4675         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
4676             * sizeof(Mpi2SasIOUnit0PhyData_t));
4677         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
4678         if (!sas_iounit_pg0) {
4679                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4680                     ioc->name, __FILE__, __LINE__, __func__);
4681                 return;
4682         }
4683 
4684         if ((mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4685             sas_iounit_pg0, sz)) != 0)
4686                 goto out;
4687         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
4688         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
4689                 goto out;
4690         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4691                 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4;
4692                 if (i == 0)
4693                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4694                             PhyData[0].ControllerDevHandle);
4695                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4696                 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i].
4697                     AttachedDevHandle);
4698                 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
4699                         link_rate = MPI2_SAS_NEG_LINK_RATE_1_5;
4700                 mpt2sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
4701                     attached_handle, i, link_rate);
4702         }
4703  out:
4704         kfree(sas_iounit_pg0);
4705 }
4706 
4707 /**
4708  * _scsih_sas_host_add - create sas host object
4709  * @ioc: per adapter object
4710  *
4711  * Creating host side data object, stored in ioc->sas_hba
4712  *
4713  * Return nothing.
4714  */
4715 static void
4716 _scsih_sas_host_add(struct MPT2SAS_ADAPTER *ioc)
4717 {
4718         int i;
4719         Mpi2ConfigReply_t mpi_reply;
4720         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
4721         Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
4722         Mpi2SasPhyPage0_t phy_pg0;
4723         Mpi2SasDevicePage0_t sas_device_pg0;
4724         Mpi2SasEnclosurePage0_t enclosure_pg0;
4725         u16 ioc_status;
4726         u16 sz;
4727         u16 device_missing_delay;
4728 
4729         mpt2sas_config_get_number_hba_phys(ioc, &ioc->sas_hba.num_phys);
4730         if (!ioc->sas_hba.num_phys) {
4731                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4732                     ioc->name, __FILE__, __LINE__, __func__);
4733                 return;
4734         }
4735 
4736         /* sas_iounit page 0 */
4737         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
4738             sizeof(Mpi2SasIOUnit0PhyData_t));
4739         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
4740         if (!sas_iounit_pg0) {
4741                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4742                     ioc->name, __FILE__, __LINE__, __func__);
4743                 return;
4744         }
4745         if ((mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4746             sas_iounit_pg0, sz))) {
4747                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4748                     ioc->name, __FILE__, __LINE__, __func__);
4749                 goto out;
4750         }
4751         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4752             MPI2_IOCSTATUS_MASK;
4753         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4754                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4755                     ioc->name, __FILE__, __LINE__, __func__);
4756                 goto out;
4757         }
4758 
4759         /* sas_iounit page 1 */
4760         sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
4761             sizeof(Mpi2SasIOUnit1PhyData_t));
4762         sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
4763         if (!sas_iounit_pg1) {
4764                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4765                     ioc->name, __FILE__, __LINE__, __func__);
4766                 goto out;
4767         }
4768         if ((mpt2sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
4769             sas_iounit_pg1, sz))) {
4770                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4771                     ioc->name, __FILE__, __LINE__, __func__);
4772                 goto out;
4773         }
4774         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4775             MPI2_IOCSTATUS_MASK;
4776         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4777                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4778                     ioc->name, __FILE__, __LINE__, __func__);
4779                 goto out;
4780         }
4781 
4782         ioc->io_missing_delay =
4783             le16_to_cpu(sas_iounit_pg1->IODeviceMissingDelay);
4784         device_missing_delay =
4785             le16_to_cpu(sas_iounit_pg1->ReportDeviceMissingDelay);
4786         if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16)
4787                 ioc->device_missing_delay = (device_missing_delay &
4788                     MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16;
4789         else
4790                 ioc->device_missing_delay = device_missing_delay &
4791                     MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
4792 
4793         ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
4794         ioc->sas_hba.phy = kcalloc(ioc->sas_hba.num_phys,
4795             sizeof(struct _sas_phy), GFP_KERNEL);
4796         if (!ioc->sas_hba.phy) {
4797                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4798                     ioc->name, __FILE__, __LINE__, __func__);
4799                 goto out;
4800         }
4801         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4802                 if ((mpt2sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
4803                     i))) {
4804                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4805                             ioc->name, __FILE__, __LINE__, __func__);
4806                         goto out;
4807                 }
4808                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4809                     MPI2_IOCSTATUS_MASK;
4810                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4811                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4812                             ioc->name, __FILE__, __LINE__, __func__);
4813                         goto out;
4814                 }
4815 
4816                 if (i == 0)
4817                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4818                             PhyData[0].ControllerDevHandle);
4819                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4820                 ioc->sas_hba.phy[i].phy_id = i;
4821                 mpt2sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
4822                     phy_pg0, ioc->sas_hba.parent_dev);
4823         }
4824         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4825             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
4826                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4827                     ioc->name, __FILE__, __LINE__, __func__);
4828                 goto out;
4829         }
4830         ioc->sas_hba.enclosure_handle =
4831             le16_to_cpu(sas_device_pg0.EnclosureHandle);
4832         ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
4833         printk(MPT2SAS_INFO_FMT "host_add: handle(0x%04x), "
4834             "sas_addr(0x%016llx), phys(%d)\n", ioc->name, ioc->sas_hba.handle,
4835             (unsigned long long) ioc->sas_hba.sas_address,
4836             ioc->sas_hba.num_phys) ;
4837 
4838         if (ioc->sas_hba.enclosure_handle) {
4839                 if (!(mpt2sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4840                     &enclosure_pg0,
4841                    MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
4842                    ioc->sas_hba.enclosure_handle))) {
4843                         ioc->sas_hba.enclosure_logical_id =
4844                             le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
4845                 }
4846         }
4847 
4848  out:
4849         kfree(sas_iounit_pg1);
4850         kfree(sas_iounit_pg0);
4851 }
4852 
4853 /**
4854  * _scsih_expander_add -  creating expander object
4855  * @ioc: per adapter object
4856  * @handle: expander handle
4857  *
4858  * Creating expander object, stored in ioc->sas_expander_list.
4859  *
4860  * Return 0 for success, else error.
4861  */
4862 static int
4863 _scsih_expander_add(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4864 {
4865         struct _sas_node *sas_expander;
4866         Mpi2ConfigReply_t mpi_reply;
4867         Mpi2ExpanderPage0_t expander_pg0;
4868         Mpi2ExpanderPage1_t expander_pg1;
4869         Mpi2SasEnclosurePage0_t enclosure_pg0;
4870         u32 ioc_status;
4871         u16 parent_handle;
4872         u64 sas_address, sas_address_parent = 0;
4873         int i;
4874         unsigned long flags;
4875         struct _sas_port *mpt2sas_port = NULL;
4876         int rc = 0;
4877 
4878         if (!handle)
4879                 return -1;
4880 
4881         if (ioc->shost_recovery || ioc->pci_error_recovery)
4882                 return -1;
4883 
4884         if ((mpt2sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
4885             MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) {
4886                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4887                     ioc->name, __FILE__, __LINE__, __func__);
4888                 return -1;
4889         }
4890 
4891         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4892             MPI2_IOCSTATUS_MASK;
4893         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4894                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4895                     ioc->name, __FILE__, __LINE__, __func__);
4896                 return -1;
4897         }
4898 
4899         /* handle out of order topology events */
4900         parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle);
4901         if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
4902             != 0) {
4903                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4904                     ioc->name, __FILE__, __LINE__, __func__);
4905                 return -1;
4906         }
4907         if (sas_address_parent != ioc->sas_hba.sas_address) {
4908                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4909                 sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
4910                     sas_address_parent);
4911                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4912                 if (!sas_expander) {
4913                         rc = _scsih_expander_add(ioc, parent_handle);
4914                         if (rc != 0)
4915                                 return rc;
4916                 }
4917         }
4918 
4919         spin_lock_irqsave(&ioc->sas_node_lock, flags);
4920         sas_address = le64_to_cpu(expander_pg0.SASAddress);
4921         sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
4922             sas_address);
4923         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4924 
4925         if (sas_expander)
4926                 return 0;
4927 
4928         sas_expander = kzalloc(sizeof(struct _sas_node),
4929             GFP_KERNEL);
4930         if (!sas_expander) {
4931                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4932                     ioc->name, __FILE__, __LINE__, __func__);
4933                 return -1;
4934         }
4935 
4936         sas_expander->handle = handle;
4937         sas_expander->num_phys = expander_pg0.NumPhys;
4938         sas_expander->sas_address_parent = sas_address_parent;
4939         sas_expander->sas_address = sas_address;
4940 
4941         printk(MPT2SAS_INFO_FMT "expander_add: handle(0x%04x),"
4942             " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name,
4943             handle, parent_handle, (unsigned long long)
4944             sas_expander->sas_address, sas_expander->num_phys);
4945 
4946         if (!sas_expander->num_phys)
4947                 goto out_fail;
4948         sas_expander->phy = kcalloc(sas_expander->num_phys,
4949             sizeof(struct _sas_phy), GFP_KERNEL);
4950         if (!sas_expander->phy) {
4951                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4952                     ioc->name, __FILE__, __LINE__, __func__);
4953                 rc = -1;
4954                 goto out_fail;
4955         }
4956 
4957         INIT_LIST_HEAD(&sas_expander->sas_port_list);
4958         mpt2sas_port = mpt2sas_transport_port_add(ioc, handle,
4959             sas_address_parent);
4960         if (!mpt2sas_port) {
4961                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4962                     ioc->name, __FILE__, __LINE__, __func__);
4963                 rc = -1;
4964                 goto out_fail;
4965         }
4966         sas_expander->parent_dev = &mpt2sas_port->rphy->dev;
4967 
4968         for (i = 0 ; i < sas_expander->num_phys ; i++) {
4969                 if ((mpt2sas_config_get_expander_pg1(ioc, &mpi_reply,
4970                     &expander_pg1, i, handle))) {
4971                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4972                             ioc->name, __FILE__, __LINE__, __func__);
4973                         rc = -1;
4974                         goto out_fail;
4975                 }
4976                 sas_expander->phy[i].handle = handle;
4977                 sas_expander->phy[i].phy_id = i;
4978 
4979                 if ((mpt2sas_transport_add_expander_phy(ioc,
4980                     &sas_expander->phy[i], expander_pg1,
4981                     sas_expander->parent_dev))) {
4982                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4983                             ioc->name, __FILE__, __LINE__, __func__);
4984                         rc = -1;
4985                         goto out_fail;
4986                 }
4987         }
4988 
4989         if (sas_expander->enclosure_handle) {
4990                 if (!(mpt2sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4991                     &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
4992                    sas_expander->enclosure_handle))) {
4993                         sas_expander->enclosure_logical_id =
4994                             le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
4995                 }
4996         }
4997 
4998         _scsih_expander_node_add(ioc, sas_expander);
4999          return 0;
5000 
5001  out_fail:
5002 
5003         if (mpt2sas_port)
5004                 mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
5005                     sas_address_parent);
5006         kfree(sas_expander);
5007         return rc;
5008 }
5009 
5010 /**
5011  * _scsih_done -  scsih callback handler.
5012  * @ioc: per adapter object
5013  * @smid: system request message index
5014  * @msix_index: MSIX table index supplied by the OS
5015  * @reply: reply message frame(lower 32bit addr)
5016  *
5017  * Callback handler when sending internal generated message frames.
5018  * The callback index passed is `ioc->scsih_cb_idx`
5019  *
5020  * Return 1 meaning mf should be freed from _base_interrupt
5021  *        0 means the mf is freed from this function.
5022  */
5023 static u8
5024 _scsih_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
5025 {
5026         MPI2DefaultReply_t *mpi_reply;
5027 
5028         mpi_reply =  mpt2sas_base_get_reply_virt_addr(ioc, reply);
5029         if (ioc->scsih_cmds.status == MPT2_CMD_NOT_USED)
5030                 return 1;
5031         if (ioc->scsih_cmds.smid != smid)
5032                 return 1;
5033         ioc->scsih_cmds.status |= MPT2_CMD_COMPLETE;
5034         if (mpi_reply) {
5035                 memcpy(ioc->scsih_cmds.reply, mpi_reply,
5036                     mpi_reply->MsgLength*4);
5037                 ioc->scsih_cmds.status |= MPT2_CMD_REPLY_VALID;
5038         }
5039         ioc->scsih_cmds.status &= ~MPT2_CMD_PENDING;
5040         complete(&ioc->scsih_cmds.done);
5041         return 1;
5042 }
5043 
5044 /**
5045  * mpt2sas_expander_remove - removing expander object
5046  * @ioc: per adapter object
5047  * @sas_address: expander sas_address
5048  *
5049  * Return nothing.
5050  */
5051 void
5052 mpt2sas_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
5053 {
5054         struct _sas_node *sas_expander;
5055         unsigned long flags;
5056 
5057         if (ioc->shost_recovery)
5058                 return;
5059 
5060         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5061         sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
5062             sas_address);
5063         if (sas_expander)
5064                 list_del(&sas_expander->list);
5065         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5066         if (sas_expander)
5067                 _scsih_expander_node_remove(ioc, sas_expander);
5068 }
5069 
5070 /**
5071  * _scsih_check_access_status - check access flags
5072  * @ioc: per adapter object
5073  * @sas_address: sas address
5074  * @handle: sas device handle
5075  * @access_flags: errors returned during discovery of the device
5076  *
5077  * Return 0 for success, else failure
5078  */
5079 static u8
5080 _scsih_check_access_status(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
5081    u16 handle, u8 access_status)
5082 {
5083         u8 rc = 1;
5084         char *desc = NULL;
5085 
5086         switch (access_status) {
5087         case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS:
5088         case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION:
5089                 rc = 0;
5090                 break;
5091         case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED:
5092                 desc = "sata capability failed";
5093                 break;
5094         case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT:
5095                 desc = "sata affiliation conflict";
5096                 break;
5097         case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE:
5098                 desc = "route not addressable";
5099                 break;
5100         case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE:
5101                 desc = "smp error not addressable";
5102                 break;
5103         case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED:
5104                 desc = "device blocked";
5105                 break;
5106         case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED:
5107         case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN:
5108         case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT:
5109         case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG:
5110         case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION:
5111         case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER:
5112         case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN:
5113         case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN:
5114         case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN:
5115         case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION:
5116         case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE:
5117         case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX:
5118                 desc = "sata initialization failed";
5119                 break;
5120         default:
5121                 desc = "unknown";
5122                 break;
5123         }
5124 
5125         if (!rc)
5126                 return 0;
5127 
5128         printk(MPT2SAS_ERR_FMT "discovery errors(%s): sas_address(0x%016llx), "
5129             "handle(0x%04x)\n", ioc->name, desc,
5130             (unsigned long long)sas_address, handle);
5131         return rc;
5132 }
5133 
5134 static void
5135 _scsih_check_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
5136 {
5137         Mpi2ConfigReply_t mpi_reply;
5138         Mpi2SasDevicePage0_t sas_device_pg0;
5139         struct _sas_device *sas_device;
5140         u32 ioc_status;
5141         unsigned long flags;
5142         u64 sas_address;
5143         struct scsi_target *starget;
5144         struct MPT2SAS_TARGET *sas_target_priv_data;
5145         u32 device_info;
5146 
5147 
5148         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5149             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)))
5150                 return;
5151 
5152         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
5153         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
5154                 return;
5155 
5156         /* check if this is end device */
5157         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5158         if (!(_scsih_is_end_device(device_info)))
5159                 return;
5160 
5161         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5162         sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5163         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5164             sas_address);
5165 
5166         if (!sas_device) {
5167                 printk(MPT2SAS_ERR_FMT "device is not present "
5168                     "handle(0x%04x), no sas_device!!!\n", ioc->name, handle);
5169                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5170                 return;
5171         }
5172 
5173         if (unlikely(sas_device->handle != handle)) {
5174                 starget = sas_device->starget;
5175                 sas_target_priv_data = starget->hostdata;
5176                 starget_printk(KERN_INFO, starget, "handle changed from(0x%04x)"
5177                    " to (0x%04x)!!!\n", sas_device->handle, handle);
5178                 sas_target_priv_data->handle = handle;
5179                 sas_device->handle = handle;
5180         }
5181 
5182         /* check if device is present */
5183         if (!(le16_to_cpu(sas_device_pg0.Flags) &
5184             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
5185                 printk(MPT2SAS_ERR_FMT "device is not present "
5186                     "handle(0x%04x), flags!!!\n", ioc->name, handle);
5187                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5188                 return;
5189         }
5190 
5191         /* check if there were any issues with discovery */
5192         if (_scsih_check_access_status(ioc, sas_address, handle,
5193             sas_device_pg0.AccessStatus)) {
5194                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5195                 return;
5196         }
5197         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5198         _scsih_ublock_io_device(ioc, sas_address);
5199 
5200 }
5201 
5202 /**
5203  * _scsih_add_device -  creating sas device object
5204  * @ioc: per adapter object
5205  * @handle: sas device handle
5206  * @phy_num: phy number end device attached to
5207  * @is_pd: is this hidden raid component
5208  *
5209  * Creating end device object, stored in ioc->sas_device_list.
5210  *
5211  * Returns 0 for success, non-zero for failure.
5212  */
5213 static int
5214 _scsih_add_device(struct MPT2SAS_ADAPTER *ioc, u16 handle, u8 phy_num, u8 is_pd)
5215 {
5216         Mpi2ConfigReply_t mpi_reply;
5217         Mpi2SasDevicePage0_t sas_device_pg0;
5218         Mpi2SasEnclosurePage0_t enclosure_pg0;
5219         struct _sas_device *sas_device;
5220         u32 ioc_status;
5221         __le64 sas_address;
5222         u32 device_info;
5223         unsigned long flags;
5224 
5225         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5226             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
5227                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5228                     ioc->name, __FILE__, __LINE__, __func__);
5229                 return -1;
5230         }
5231 
5232         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5233             MPI2_IOCSTATUS_MASK;
5234         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5235                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5236                     ioc->name, __FILE__, __LINE__, __func__);
5237                 return -1;
5238         }
5239 
5240         sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5241 
5242         /* check if device is present */
5243         if (!(le16_to_cpu(sas_device_pg0.Flags) &
5244             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
5245                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5246                     ioc->name, __FILE__, __LINE__, __func__);
5247                 printk(MPT2SAS_ERR_FMT "Flags = 0x%04x\n",
5248                     ioc->name, le16_to_cpu(sas_device_pg0.Flags));
5249                 return -1;
5250         }
5251 
5252         /* check if there were any issues with discovery */
5253         if (_scsih_check_access_status(ioc, sas_address, handle,
5254             sas_device_pg0.AccessStatus))
5255                 return -1;
5256 
5257         /* check if this is end device */
5258         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5259         if (!(_scsih_is_end_device(device_info))) {
5260                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5261                     ioc->name, __FILE__, __LINE__, __func__);
5262                 return -1;
5263         }
5264 
5265 
5266         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5267         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5268             sas_address);
5269         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5270 
5271         if (sas_device)
5272                 return 0;
5273 
5274         sas_device = kzalloc(sizeof(struct _sas_device),
5275             GFP_KERNEL);
5276         if (!sas_device) {
5277                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5278                     ioc->name, __FILE__, __LINE__, __func__);
5279                 return -1;
5280         }
5281 
5282         sas_device->handle = handle;
5283         if (_scsih_get_sas_address(ioc, le16_to_cpu
5284                 (sas_device_pg0.ParentDevHandle),
5285                 &sas_device->sas_address_parent) != 0)
5286                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5287                     ioc->name, __FILE__, __LINE__, __func__);
5288         sas_device->enclosure_handle =
5289             le16_to_cpu(sas_device_pg0.EnclosureHandle);
5290         sas_device->slot =
5291             le16_to_cpu(sas_device_pg0.Slot);
5292         sas_device->device_info = device_info;
5293         sas_device->sas_address = sas_address;
5294         sas_device->phy = sas_device_pg0.PhyNum;
5295 
5296         /* get enclosure_logical_id */
5297         if (sas_device->enclosure_handle && !(mpt2sas_config_get_enclosure_pg0(
5298            ioc, &mpi_reply, &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
5299            sas_device->enclosure_handle)))
5300                 sas_device->enclosure_logical_id =
5301                     le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
5302 
5303         /* get device name */
5304         sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName);
5305 
5306         if (ioc->wait_for_discovery_to_complete)
5307                 _scsih_sas_device_init_add(ioc, sas_device);
5308         else
5309                 _scsih_sas_device_add(ioc, sas_device);
5310 
5311         return 0;
5312 }
5313 
5314 /**
5315  * _scsih_remove_device -  removing sas device object
5316  * @ioc: per adapter object
5317  * @sas_device_delete: the sas_device object
5318  *
5319  * Return nothing.
5320  */
5321 static void
5322 _scsih_remove_device(struct MPT2SAS_ADAPTER *ioc,
5323     struct _sas_device *sas_device)
5324 {
5325         struct MPT2SAS_TARGET *sas_target_priv_data;
5326 
5327         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter: "
5328             "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
5329                 sas_device->handle, (unsigned long long)
5330             sas_device->sas_address));
5331 
5332         if (sas_device->starget && sas_device->starget->hostdata) {
5333                 sas_target_priv_data = sas_device->starget->hostdata;
5334                 sas_target_priv_data->deleted = 1;
5335                 _scsih_ublock_io_device(ioc, sas_device->sas_address);
5336                 sas_target_priv_data->handle =
5337                      MPT2SAS_INVALID_DEVICE_HANDLE;
5338         }
5339 
5340         if (!ioc->hide_drives)
5341                 mpt2sas_transport_port_remove(ioc,
5342                     sas_device->sas_address,
5343                     sas_device->sas_address_parent);
5344 
5345         printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), sas_addr"
5346             "(0x%016llx)\n", ioc->name, sas_device->handle,
5347             (unsigned long long) sas_device->sas_address);
5348 
5349         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: exit: "
5350             "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
5351             sas_device->handle, (unsigned long long)
5352             sas_device->sas_address));
5353         kfree(sas_device);
5354 }
5355 /**
5356  * _scsih_device_remove_by_handle - removing device object by handle
5357  * @ioc: per adapter object
5358  * @handle: device handle
5359  *
5360  * Return nothing.
5361  */
5362 static void
5363 _scsih_device_remove_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
5364 {
5365         struct _sas_device *sas_device;
5366         unsigned long flags;
5367 
5368         if (ioc->shost_recovery)
5369                 return;
5370 
5371         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5372         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5373         if (sas_device)
5374                 list_del(&sas_device->list);
5375         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5376         if (sas_device)
5377                 _scsih_remove_device(ioc, sas_device);
5378 }
5379 
5380 /**
5381  * mpt2sas_device_remove_by_sas_address - removing device object by sas address
5382  * @ioc: per adapter object
5383  * @sas_address: device sas_address
5384  *
5385  * Return nothing.
5386  */
5387 void
5388 mpt2sas_device_remove_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
5389         u64 sas_address)
5390 {
5391         struct _sas_device *sas_device;
5392         unsigned long flags;
5393 
5394         if (ioc->shost_recovery)
5395                 return;
5396 
5397         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5398         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5399             sas_address);
5400         if (sas_device)
5401                 list_del(&sas_device->list);
5402         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5403         if (sas_device)
5404                 _scsih_remove_device(ioc, sas_device);
5405 }
5406 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5407 /**
5408  * _scsih_sas_topology_change_event_debug - debug for topology event
5409  * @ioc: per adapter object
5410  * @event_data: event data payload
5411  * Context: user.
5412  */
5413 static void
5414 _scsih_sas_topology_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5415     Mpi2EventDataSasTopologyChangeList_t *event_data)
5416 {
5417         int i;
5418         u16 handle;
5419         u16 reason_code;
5420         u8 phy_number;
5421         char *status_str = NULL;
5422         u8 link_rate, prev_link_rate;
5423 
5424         switch (event_data->ExpStatus) {
5425         case MPI2_EVENT_SAS_TOPO_ES_ADDED:
5426                 status_str = "add";
5427                 break;
5428         case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING:
5429                 status_str = "remove";
5430                 break;
5431         case MPI2_EVENT_SAS_TOPO_ES_RESPONDING:
5432         case 0:
5433                 status_str =  "responding";
5434                 break;
5435         case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING:
5436                 status_str = "remove delay";
5437                 break;
5438         default:
5439                 status_str = "unknown status";
5440                 break;
5441         }
5442         printk(MPT2SAS_INFO_FMT "sas topology change: (%s)\n",
5443             ioc->name, status_str);
5444         printk(KERN_INFO "\thandle(0x%04x), enclosure_handle(0x%04x) "
5445             "start_phy(%02d), count(%d)\n",
5446             le16_to_cpu(event_data->ExpanderDevHandle),
5447             le16_to_cpu(event_data->EnclosureHandle),
5448             event_data->StartPhyNum, event_data->NumEntries);
5449         for (i = 0; i < event_data->NumEntries; i++) {
5450                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
5451                 if (!handle)
5452                         continue;
5453                 phy_number = event_data->StartPhyNum + i;
5454                 reason_code = event_data->PHY[i].PhyStatus &
5455                     MPI2_EVENT_SAS_TOPO_RC_MASK;
5456                 switch (reason_code) {
5457                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
5458                         status_str = "target add";
5459                         break;
5460                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
5461                         status_str = "target remove";
5462                         break;
5463                 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
5464                         status_str = "delay target remove";
5465                         break;
5466                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
5467                         status_str = "link rate change";
5468                         break;
5469                 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
5470                         status_str = "target responding";
5471                         break;
5472                 default:
5473                         status_str = "unknown";
5474                         break;
5475                 }
5476                 link_rate = event_data->PHY[i].LinkRate >> 4;
5477                 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
5478                 printk(KERN_INFO "\tphy(%02d), attached_handle(0x%04x): %s:"
5479                     " link rate: new(0x%02x), old(0x%02x)\n", phy_number,
5480                     handle, status_str, link_rate, prev_link_rate);
5481 
5482         }
5483 }
5484 #endif
5485 
5486 /**
5487  * _scsih_sas_topology_change_event - handle topology changes
5488  * @ioc: per adapter object
5489  * @fw_event: The fw_event_work object
5490  * Context: user.
5491  *
5492  */
5493 static void
5494 _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
5495     struct fw_event_work *fw_event)
5496 {
5497         int i;
5498         u16 parent_handle, handle;
5499         u16 reason_code;
5500         u8 phy_number, max_phys;
5501         struct _sas_node *sas_expander;
5502         u64 sas_address;
5503         unsigned long flags;
5504         u8 link_rate, prev_link_rate;
5505         Mpi2EventDataSasTopologyChangeList_t *event_data = fw_event->event_data;
5506 
5507 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5508         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5509                 _scsih_sas_topology_change_event_debug(ioc, event_data);
5510 #endif
5511 
5512         if (ioc->remove_host || ioc->pci_error_recovery)
5513                 return;
5514 
5515         if (!ioc->sas_hba.num_phys)
5516                 _scsih_sas_host_add(ioc);
5517         else
5518                 _scsih_sas_host_refresh(ioc);
5519 
5520         if (fw_event->ignore) {
5521                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "ignoring expander "
5522                     "event\n", ioc->name));
5523                 return;
5524         }
5525 
5526         parent_handle = le16_to_cpu(event_data->ExpanderDevHandle);
5527 
5528         /* handle expander add */
5529         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED)
5530                 if (_scsih_expander_add(ioc, parent_handle) != 0)
5531                         return;
5532 
5533         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5534         sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
5535             parent_handle);
5536         if (sas_expander) {
5537                 sas_address = sas_expander->sas_address;
5538                 max_phys = sas_expander->num_phys;
5539         } else if (parent_handle < ioc->sas_hba.num_phys) {
5540                 sas_address = ioc->sas_hba.sas_address;
5541                 max_phys = ioc->sas_hba.num_phys;
5542         } else {
5543         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5544                 return;
5545         }
5546         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5547 
5548         /* handle siblings events */
5549         for (i = 0; i < event_data->NumEntries; i++) {
5550                 if (fw_event->ignore) {
5551                         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "ignoring "
5552                             "expander event\n", ioc->name));
5553                         return;
5554                 }
5555                 if (ioc->shost_recovery || ioc->remove_host ||
5556                     ioc->pci_error_recovery)
5557                         return;
5558                 phy_number = event_data->StartPhyNum + i;
5559                 if (phy_number >= max_phys)
5560                         continue;
5561                 reason_code = event_data->PHY[i].PhyStatus &
5562                     MPI2_EVENT_SAS_TOPO_RC_MASK;
5563                 if ((event_data->PHY[i].PhyStatus &
5564                     MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code !=
5565                     MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING))
5566                         continue;
5567                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
5568                 if (!handle)
5569                         continue;
5570                 link_rate = event_data->PHY[i].LinkRate >> 4;
5571                 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
5572                 switch (reason_code) {
5573                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
5574 
5575                         if (ioc->shost_recovery)
5576                                 break;
5577 
5578                         if (link_rate == prev_link_rate)
5579                                 break;
5580 
5581                         mpt2sas_transport_update_links(ioc, sas_address,
5582                             handle, phy_number, link_rate);
5583 
5584                         if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
5585                                 break;
5586 
5587                         _scsih_check_device(ioc, handle);
5588                         break;
5589                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
5590 
5591                         if (ioc->shost_recovery)
5592                                 break;
5593 
5594                         mpt2sas_transport_update_links(ioc, sas_address,
5595                             handle, phy_number, link_rate);
5596 
5597                         _scsih_add_device(ioc, handle, phy_number, 0);
5598                         break;
5599                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
5600 
5601                         _scsih_device_remove_by_handle(ioc, handle);
5602                         break;
5603                 }
5604         }
5605 
5606         /* handle expander removal */
5607         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING &&
5608             sas_expander)
5609                 mpt2sas_expander_remove(ioc, sas_address);
5610 
5611 }
5612 
5613 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5614 /**
5615  * _scsih_sas_device_status_change_event_debug - debug for device event
5616  * @event_data: event data payload
5617  * Context: user.
5618  *
5619  * Return nothing.
5620  */
5621 static void
5622 _scsih_sas_device_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5623     Mpi2EventDataSasDeviceStatusChange_t *event_data)
5624 {
5625         char *reason_str = NULL;
5626 
5627         switch (event_data->ReasonCode) {
5628         case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
5629                 reason_str = "smart data";
5630                 break;
5631         case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
5632                 reason_str = "unsupported device discovered";
5633                 break;
5634         case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
5635                 reason_str = "internal device reset";
5636                 break;
5637         case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
5638                 reason_str = "internal task abort";
5639                 break;
5640         case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
5641                 reason_str = "internal task abort set";
5642                 break;
5643         case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
5644                 reason_str = "internal clear task set";
5645                 break;
5646         case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
5647                 reason_str = "internal query task";
5648                 break;
5649         case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE:
5650                 reason_str = "sata init failure";
5651                 break;
5652         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
5653                 reason_str = "internal device reset complete";
5654                 break;
5655         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
5656                 reason_str = "internal task abort complete";
5657                 break;
5658         case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
5659                 reason_str = "internal async notification";
5660                 break;
5661         case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY:
5662                 reason_str = "expander reduced functionality";
5663                 break;
5664         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY:
5665                 reason_str = "expander reduced functionality complete";
5666                 break;
5667         default:
5668                 reason_str = "unknown reason";
5669                 break;
5670         }
5671         printk(MPT2SAS_INFO_FMT "device status change: (%s)\n"
5672             "\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
5673             ioc->name, reason_str, le16_to_cpu(event_data->DevHandle),
5674             (unsigned long long)le64_to_cpu(event_data->SASAddress),
5675             le16_to_cpu(event_data->TaskTag));
5676         if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA)
5677                 printk(MPT2SAS_INFO_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
5678                     event_data->ASC, event_data->ASCQ);
5679         printk(KERN_INFO "\n");
5680 }
5681 #endif
5682 
5683 /**
5684  * _scsih_sas_device_status_change_event - handle device status change
5685  * @ioc: per adapter object
5686  * @fw_event: The fw_event_work object
5687  * Context: user.
5688  *
5689  * Return nothing.
5690  */
5691 static void
5692 _scsih_sas_device_status_change_event(struct MPT2SAS_ADAPTER *ioc,
5693     struct fw_event_work *fw_event)
5694 {
5695         struct MPT2SAS_TARGET *target_priv_data;
5696         struct _sas_device *sas_device;
5697         u64 sas_address;
5698         unsigned long flags;
5699         Mpi2EventDataSasDeviceStatusChange_t *event_data =
5700             fw_event->event_data;
5701 
5702 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5703         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5704                 _scsih_sas_device_status_change_event_debug(ioc,
5705                      event_data);
5706 #endif
5707 
5708         /* In MPI Revision K (0xC), the internal device reset complete was
5709          * implemented, so avoid setting tm_busy flag for older firmware.
5710          */
5711         if ((ioc->facts.HeaderVersion >> 8) < 0xC)
5712                 return;
5713 
5714         if (event_data->ReasonCode !=
5715             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
5716            event_data->ReasonCode !=
5717             MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET)
5718                 return;
5719 
5720         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5721         sas_address = le64_to_cpu(event_data->SASAddress);
5722         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5723             sas_address);
5724 
5725         if (!sas_device || !sas_device->starget) {
5726                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5727                 return;
5728         }
5729 
5730         target_priv_data = sas_device->starget->hostdata;
5731         if (!target_priv_data) {
5732                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5733                 return;
5734         }
5735 
5736         if (event_data->ReasonCode ==
5737             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
5738                 target_priv_data->tm_busy = 1;
5739         else
5740                 target_priv_data->tm_busy = 0;
5741         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5742 }
5743 
5744 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5745 /**
5746  * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure event
5747  * @ioc: per adapter object
5748  * @event_data: event data payload
5749  * Context: user.
5750  *
5751  * Return nothing.
5752  */
5753 static void
5754 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5755     Mpi2EventDataSasEnclDevStatusChange_t *event_data)
5756 {
5757         char *reason_str = NULL;
5758 
5759         switch (event_data->ReasonCode) {
5760         case MPI2_EVENT_SAS_ENCL_RC_ADDED:
5761                 reason_str = "enclosure add";
5762                 break;
5763         case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
5764                 reason_str = "enclosure remove";
5765                 break;
5766         default:
5767                 reason_str = "unknown reason";
5768                 break;
5769         }
5770 
5771         printk(MPT2SAS_INFO_FMT "enclosure status change: (%s)\n"
5772             "\thandle(0x%04x), enclosure logical id(0x%016llx)"
5773             " number slots(%d)\n", ioc->name, reason_str,
5774             le16_to_cpu(event_data->EnclosureHandle),
5775             (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID),
5776             le16_to_cpu(event_data->StartSlot));
5777 }
5778 #endif
5779 
5780 /**
5781  * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events
5782  * @ioc: per adapter object
5783  * @fw_event: The fw_event_work object
5784  * Context: user.
5785  *
5786  * Return nothing.
5787  */
5788 static void
5789 _scsih_sas_enclosure_dev_status_change_event(struct MPT2SAS_ADAPTER *ioc,
5790     struct fw_event_work *fw_event)
5791 {
5792 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5793         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5794                 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
5795                      fw_event->event_data);
5796 #endif
5797 }
5798 
5799 /**
5800  * _scsih_sas_broadcast_primitive_event - handle broadcast events
5801  * @ioc: per adapter object
5802  * @fw_event: The fw_event_work object
5803  * Context: user.
5804  *
5805  * Return nothing.
5806  */
5807 static void
5808 _scsih_sas_broadcast_primitive_event(struct MPT2SAS_ADAPTER *ioc,
5809     struct fw_event_work *fw_event)
5810 {
5811         struct scsi_cmnd *scmd;
5812         struct scsi_device *sdev;
5813         u16 smid, handle;
5814         u32 lun;
5815         struct MPT2SAS_DEVICE *sas_device_priv_data;
5816         u32 termination_count;
5817         u32 query_count;
5818         Mpi2SCSITaskManagementReply_t *mpi_reply;
5819         Mpi2EventDataSasBroadcastPrimitive_t *event_data = fw_event->event_data;
5820         u16 ioc_status;
5821         unsigned long flags;
5822         int r;
5823         u8 max_retries = 0;
5824         u8 task_abort_retries;
5825 
5826         mutex_lock(&ioc->tm_cmds.mutex);
5827         pr_info(MPT2SAS_FMT
5828                 "%s: enter: phy number(%d), width(%d)\n",
5829                 ioc->name, __func__, event_data->PhyNum,
5830                 event_data->PortWidth);
5831 
5832         _scsih_block_io_all_device(ioc);
5833 
5834         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5835         mpi_reply = ioc->tm_cmds.reply;
5836 broadcast_aen_retry:
5837 
5838         /* sanity checks for retrying this loop */
5839         if (max_retries++ == 5) {
5840                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: giving up\n",
5841                     ioc->name, __func__));
5842                 goto out;
5843         } else if (max_retries > 1)
5844                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: %d retry\n",
5845                     ioc->name, __func__, max_retries - 1));
5846 
5847         termination_count = 0;
5848         query_count = 0;
5849         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
5850                 if (ioc->shost_recovery)
5851                         goto out;
5852                 scmd = _scsih_scsi_lookup_get(ioc, smid);
5853                 if (!scmd)
5854                         continue;
5855                 sdev = scmd->device;
5856                 sas_device_priv_data = sdev->hostdata;
5857                 if (!sas_device_priv_data || !sas_device_priv_data->sas_target)
5858                         continue;
5859                  /* skip hidden raid components */
5860                 if (sas_device_priv_data->sas_target->flags &
5861                     MPT_TARGET_FLAGS_RAID_COMPONENT)
5862                         continue;
5863                  /* skip volumes */
5864                 if (sas_device_priv_data->sas_target->flags &
5865                     MPT_TARGET_FLAGS_VOLUME)
5866                         continue;
5867 
5868                 handle = sas_device_priv_data->sas_target->handle;
5869                 lun = sas_device_priv_data->lun;
5870                 query_count++;
5871 
5872                 if (ioc->shost_recovery)
5873                         goto out;
5874 
5875                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5876                 r = mpt2sas_scsih_issue_tm(ioc, handle, 0, 0, lun,
5877                     MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30,
5878                     TM_MUTEX_OFF);
5879                 if (r == FAILED) {
5880                         sdev_printk(KERN_WARNING, sdev,
5881                             "mpt2sas_scsih_issue_tm: FAILED when sending "
5882                             "QUERY_TASK: scmd(%p)\n", scmd);
5883                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5884                         goto broadcast_aen_retry;
5885                 }
5886                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
5887                     & MPI2_IOCSTATUS_MASK;
5888                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5889                         sdev_printk(KERN_WARNING, sdev, "query task: FAILED "
5890                             "with IOCSTATUS(0x%04x), scmd(%p)\n", ioc_status,
5891                             scmd);
5892                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5893                         goto broadcast_aen_retry;
5894                 }
5895 
5896                 /* see if IO is still owned by IOC and target */
5897                 if (mpi_reply->ResponseCode ==
5898                      MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
5899                      mpi_reply->ResponseCode ==
5900                      MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) {
5901                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5902                         continue;
5903                 }
5904                 task_abort_retries = 0;
5905  tm_retry:
5906                 if (task_abort_retries++ == 60) {
5907                         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
5908                             "%s: ABORT_TASK: giving up\n", ioc->name,
5909                             __func__));
5910                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5911                         goto broadcast_aen_retry;
5912                 }
5913 
5914                 if (ioc->shost_recovery)
5915                         goto out_no_lock;
5916 
5917                 r = mpt2sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id,
5918                     sdev->lun, MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30,
5919                     TM_MUTEX_OFF);
5920                 if (r == FAILED) {
5921                         sdev_printk(KERN_WARNING, sdev,
5922                             "mpt2sas_scsih_issue_tm: ABORT_TASK: FAILED : "
5923                             "scmd(%p)\n", scmd);
5924                         goto tm_retry;
5925                 }
5926 
5927                 if (task_abort_retries > 1)
5928                         sdev_printk(KERN_WARNING, sdev,
5929                             "mpt2sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):"
5930                             " scmd(%p)\n",
5931                             task_abort_retries - 1, scmd);
5932 
5933                 termination_count += le32_to_cpu(mpi_reply->TerminationCount);
5934                 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5935         }
5936 
5937         if (ioc->broadcast_aen_pending) {
5938                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: loop back due to"
5939                      " pending AEN\n", ioc->name, __func__));
5940                  ioc->broadcast_aen_pending = 0;
5941                  goto broadcast_aen_retry;
5942         }
5943 
5944  out:
5945         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5946  out_no_lock:
5947 
5948         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
5949             "%s - exit, query_count = %d termination_count = %d\n",
5950             ioc->name, __func__, query_count, termination_count));
5951 
5952         ioc->broadcast_aen_busy = 0;
5953         if (!ioc->shost_recovery)
5954                 _scsih_ublock_io_all_device(ioc);
5955         mutex_unlock(&ioc->tm_cmds.mutex);
5956 }
5957 
5958 /**
5959  * _scsih_sas_discovery_event - handle discovery events
5960  * @ioc: per adapter object
5961  * @fw_event: The fw_event_work object
5962  * Context: user.
5963  *
5964  * Return nothing.
5965  */
5966 static void
5967 _scsih_sas_discovery_event(struct MPT2SAS_ADAPTER *ioc,
5968     struct fw_event_work *fw_event)
5969 {
5970         Mpi2EventDataSasDiscovery_t *event_data = fw_event->event_data;
5971 
5972 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5973         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
5974                 printk(MPT2SAS_INFO_FMT "discovery event: (%s)", ioc->name,
5975                     (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ?
5976                     "start" : "stop");
5977         if (event_data->DiscoveryStatus)
5978                 printk("discovery_status(0x%08x)",
5979                     le32_to_cpu(event_data->DiscoveryStatus));
5980         printk("\n");
5981         }
5982 #endif
5983 
5984         if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
5985             !ioc->sas_hba.num_phys) {
5986                 if (disable_discovery > 0 && ioc->shost_recovery) {
5987                         /* Wait for the reset to complete */
5988                         while (ioc->shost_recovery)
5989                                 ssleep(1);
5990                 }
5991                 _scsih_sas_host_add(ioc);
5992         }
5993 }
5994 
5995 /**
5996  * _scsih_reprobe_lun - reprobing lun
5997  * @sdev: scsi device struct
5998  * @no_uld_attach: sdev->no_uld_attach flag setting
5999  *
6000  **/
6001 static void
6002 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
6003 {
6004         int rc;
6005 
6006         sdev->no_uld_attach = no_uld_attach ? 1 : 0;
6007         sdev_printk(KERN_INFO, sdev, "%s raid component\n",
6008             sdev->no_uld_attach ? "hidding" : "exposing");
6009         rc = scsi_device_reprobe(sdev);
6010 }
6011 
6012 /**
6013  * _scsih_sas_volume_add - add new volume
6014  * @ioc: per adapter object
6015  * @element: IR config element data
6016  * Context: user.
6017  *
6018  * Return nothing.
6019  */
6020 static void
6021 _scsih_sas_volume_add(struct MPT2SAS_ADAPTER *ioc,
6022     Mpi2EventIrConfigElement_t *element)
6023 {
6024         struct _raid_device *raid_device;
6025         unsigned long flags;
6026         u64 wwid;
6027         u16 handle = le16_to_cpu(element->VolDevHandle);
6028         int rc;
6029 
6030         mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
6031         if (!wwid) {
6032                 printk(MPT2SAS_ERR_FMT
6033                     "failure at %s:%d/%s()!\n", ioc->name,
6034                     __FILE__, __LINE__, __func__);
6035                 return;
6036         }
6037 
6038         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6039         raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
6040         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6041 
6042         if (raid_device)
6043                 return;
6044 
6045         raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
6046         if (!raid_device) {
6047                 printk(MPT2SAS_ERR_FMT
6048                     "failure at %s:%d/%s()!\n", ioc->name,
6049                     __FILE__, __LINE__, __func__);
6050                 return;
6051         }
6052 
6053         raid_device->id = ioc->sas_id++;
6054         raid_device->channel = RAID_CHANNEL;
6055         raid_device->handle = handle;
6056         raid_device->wwid = wwid;
6057         _scsih_raid_device_add(ioc, raid_device);
6058         if (!ioc->wait_for_discovery_to_complete) {
6059                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6060                     raid_device->id, 0);
6061                 if (rc)
6062                         _scsih_raid_device_remove(ioc, raid_device);
6063         } else {
6064                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6065                 _scsih_determine_boot_device(ioc, raid_device, 1);
6066                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6067         }
6068 }
6069 
6070 /**
6071  * _scsih_sas_volume_delete - delete volume
6072  * @ioc: per adapter object
6073  * @handle: volume device handle
6074  * Context: user.
6075  *
6076  * Return nothing.
6077  */
6078 static void
6079 _scsih_sas_volume_delete(struct MPT2SAS_ADAPTER *ioc, u16 handle)
6080 {
6081         struct _raid_device *raid_device;
6082         unsigned long flags;
6083         struct MPT2SAS_TARGET *sas_target_priv_data;
6084         struct scsi_target *starget = NULL;
6085 
6086         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6087         raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6088         if (raid_device) {
6089                 if (raid_device->starget) {
6090                         starget = raid_device->starget;
6091                         sas_target_priv_data = starget->hostdata;
6092                         sas_target_priv_data->deleted = 1;
6093                 }
6094                 printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), wwid"
6095                     "(0x%016llx)\n", ioc->name,  raid_device->handle,
6096                     (unsigned long long) raid_device->wwid);
6097                 list_del(&raid_device->list);
6098                 kfree(raid_device);
6099         }
6100         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6101         if (starget)
6102                 scsi_remove_target(&starget->dev);
6103 }
6104 
6105 /**
6106  * _scsih_sas_pd_expose - expose pd component to /dev/sdX
6107  * @ioc: per adapter object
6108  * @element: IR config element data
6109  * Context: user.
6110  *
6111  * Return nothing.
6112  */
6113 static void
6114 _scsih_sas_pd_expose(struct MPT2SAS_ADAPTER *ioc,
6115     Mpi2EventIrConfigElement_t *element)
6116 {
6117         struct _sas_device *sas_device;
6118         struct scsi_target *starget = NULL;
6119         struct MPT2SAS_TARGET *sas_target_priv_data;
6120         unsigned long flags;
6121         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6122 
6123         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6124         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6125         if (sas_device) {
6126                 sas_device->volume_handle = 0;
6127                 sas_device->volume_wwid = 0;
6128                 clear_bit(handle, ioc->pd_handles);
6129                 if (sas_device->starget && sas_device->starget->hostdata) {
6130                         starget = sas_device->starget;
6131                         sas_target_priv_data = starget->hostdata;
6132                         sas_target_priv_data->flags &=
6133                             ~MPT_TARGET_FLAGS_RAID_COMPONENT;
6134                 }
6135         }
6136         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6137         if (!sas_device)
6138                 return;
6139 
6140         /* exposing raid component */
6141         if (starget)
6142                 starget_for_each_device(starget, NULL, _scsih_reprobe_lun);
6143 }
6144 
6145 /**
6146  * _scsih_sas_pd_hide - hide pd component from /dev/sdX
6147  * @ioc: per adapter object
6148  * @element: IR config element data
6149  * Context: user.
6150  *
6151  * Return nothing.
6152  */
6153 static void
6154 _scsih_sas_pd_hide(struct MPT2SAS_ADAPTER *ioc,
6155     Mpi2EventIrConfigElement_t *element)
6156 {
6157         struct _sas_device *sas_device;
6158         struct scsi_target *starget = NULL;
6159         struct MPT2SAS_TARGET *sas_target_priv_data;
6160         unsigned long flags;
6161         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6162         u16 volume_handle = 0;
6163         u64 volume_wwid = 0;
6164 
6165         mpt2sas_config_get_volume_handle(ioc, handle, &volume_handle);
6166         if (volume_handle)
6167                 mpt2sas_config_get_volume_wwid(ioc, volume_handle,
6168                     &volume_wwid);
6169 
6170         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6171         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6172         if (sas_device) {
6173                 set_bit(handle, ioc->pd_handles);
6174                 if (sas_device->starget && sas_device->starget->hostdata) {
6175                         starget = sas_device->starget;
6176                         sas_target_priv_data = starget->hostdata;
6177                         sas_target_priv_data->flags |=
6178                             MPT_TARGET_FLAGS_RAID_COMPONENT;
6179                         sas_device->volume_handle = volume_handle;
6180                         sas_device->volume_wwid = volume_wwid;
6181                 }
6182         }
6183         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6184         if (!sas_device)
6185                 return;
6186 
6187         /* hiding raid component */
6188         if (starget)
6189                 starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun);
6190 }
6191 
6192 /**
6193  * _scsih_sas_pd_delete - delete pd component
6194  * @ioc: per adapter object
6195  * @element: IR config element data
6196  * Context: user.
6197  *
6198  * Return nothing.
6199  */
6200 static void
6201 _scsih_sas_pd_delete(struct MPT2SAS_ADAPTER *ioc,
6202     Mpi2EventIrConfigElement_t *element)
6203 {
6204         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6205 
6206         _scsih_device_remove_by_handle(ioc, handle);
6207 }
6208 
6209 /**
6210  * _scsih_sas_pd_add - remove pd component
6211  * @ioc: per adapter object
6212  * @element: IR config element data
6213  * Context: user.
6214  *
6215  * Return nothing.
6216  */
6217 static void
6218 _scsih_sas_pd_add(struct MPT2SAS_ADAPTER *ioc,
6219     Mpi2EventIrConfigElement_t *element)
6220 {
6221         struct _sas_device *sas_device;
6222         unsigned long flags;
6223         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6224         Mpi2ConfigReply_t mpi_reply;
6225         Mpi2SasDevicePage0_t sas_device_pg0;
6226         u32 ioc_status;
6227         u64 sas_address;
6228         u16 parent_handle;
6229 
6230         set_bit(handle, ioc->pd_handles);
6231 
6232         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6233         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6234         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6235         if (sas_device)
6236                 return;
6237 
6238         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
6239             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
6240                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6241                     ioc->name, __FILE__, __LINE__, __func__);
6242                 return;
6243         }
6244 
6245         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6246             MPI2_IOCSTATUS_MASK;
6247         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6248                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6249                     ioc->name, __FILE__, __LINE__, __func__);
6250                 return;
6251         }
6252 
6253         parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6254         if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6255                 mpt2sas_transport_update_links(ioc, sas_address, handle,
6256                     sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
6257 
6258         _scsih_add_device(ioc, handle, 0, 1);
6259 }
6260 
6261 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
6262 /**
6263  * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events
6264  * @ioc: per adapter object
6265  * @event_data: event data payload
6266  * Context: user.
6267  *
6268  * Return nothing.
6269  */
6270 static void
6271 _scsih_sas_ir_config_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
6272     Mpi2EventDataIrConfigChangeList_t *event_data)
6273 {
6274         Mpi2EventIrConfigElement_t *element;
6275         u8 element_type;
6276         int i;
6277         char *reason_str = NULL, *element_str = NULL;
6278 
6279         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
6280 
6281         printk(MPT2SAS_INFO_FMT "raid config change: (%s), elements(%d)\n",
6282             ioc->name, (le32_to_cpu(event_data->Flags) &
6283             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ?
6284             "foreign" : "native", event_data->NumElements);
6285         for (i = 0; i < event_data->NumElements; i++, element++) {
6286                 switch (element->ReasonCode) {
6287                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
6288                         reason_str = "add";
6289                         break;
6290                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
6291                         reason_str = "remove";
6292                         break;
6293                 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:
6294                         reason_str = "no change";
6295                         break;
6296                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
6297                         reason_str = "hide";
6298                         break;
6299                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
6300                         reason_str = "unhide";
6301                         break;
6302                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
6303                         reason_str = "volume_created";
6304                         break;
6305                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
6306                         reason_str = "volume_deleted";
6307                         break;
6308                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
6309                         reason_str = "pd_created";
6310                         break;
6311                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
6312                         reason_str = "pd_deleted";
6313                         break;
6314                 default:
6315                         reason_str = "unknown reason";
6316                         break;
6317                 }
6318                 element_type = le16_to_cpu(element->ElementFlags) &
6319                     MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
6320                 switch (element_type) {
6321                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:
6322                         element_str = "volume";
6323                         break;
6324                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:
6325                         element_str = "phys disk";
6326                         break;
6327                 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:
6328                         element_str = "hot spare";
6329                         break;
6330                 default:
6331                         element_str = "unknown element";
6332                         break;
6333                 }
6334                 printk(KERN_INFO "\t(%s:%s), vol handle(0x%04x), "
6335                     "pd handle(0x%04x), pd num(0x%02x)\n", element_str,
6336                     reason_str, le16_to_cpu(element->VolDevHandle),
6337                     le16_to_cpu(element->PhysDiskDevHandle),
6338                     element->PhysDiskNum);
6339         }
6340 }
6341 #endif
6342 
6343 /**
6344  * _scsih_sas_ir_config_change_event - handle ir configuration change events
6345  * @ioc: per adapter object
6346  * @fw_event: The fw_event_work object
6347  * Context: user.
6348  *
6349  * Return nothing.
6350  */
6351 static void
6352 _scsih_sas_ir_config_change_event(struct MPT2SAS_ADAPTER *ioc,
6353     struct fw_event_work *fw_event)
6354 {
6355         Mpi2EventIrConfigElement_t *element;
6356         int i;
6357         u8 foreign_config;
6358         Mpi2EventDataIrConfigChangeList_t *event_data = fw_event->event_data;
6359 
6360 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
6361         if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6362             && !ioc->hide_ir_msg)
6363                 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
6364 
6365 #endif
6366 
6367         if (ioc->shost_recovery)
6368                 return;
6369 
6370         foreign_config = (le32_to_cpu(event_data->Flags) &
6371             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
6372 
6373         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
6374         for (i = 0; i < event_data->NumElements; i++, element++) {
6375 
6376                 switch (element->ReasonCode) {
6377                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
6378                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
6379                         if (!foreign_config)
6380                                 _scsih_sas_volume_add(ioc, element);
6381                         break;
6382                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
6383                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
6384                         if (!foreign_config)
6385                                 _scsih_sas_volume_delete(ioc,
6386                                     le16_to_cpu(element->VolDevHandle));
6387                         break;
6388                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
6389                         if (!ioc->is_warpdrive)
6390                                 _scsih_sas_pd_hide(ioc, element);
6391                         break;
6392                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
6393                         if (!ioc->is_warpdrive)
6394                                 _scsih_sas_pd_expose(ioc, element);
6395                         break;
6396                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
6397                         if (!ioc->is_warpdrive)
6398                                 _scsih_sas_pd_add(ioc, element);
6399                         break;
6400                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
6401                         if (!ioc->is_warpdrive)
6402                                 _scsih_sas_pd_delete(ioc, element);
6403                         break;
6404                 }
6405         }
6406 }
6407 
6408 /**
6409  * _scsih_sas_ir_volume_event - IR volume event
6410  * @ioc: per adapter object
6411  * @fw_event: The fw_event_work object
6412  * Context: user.
6413  *
6414  * Return nothing.
6415  */
6416 static void
6417 _scsih_sas_ir_volume_event(struct MPT2SAS_ADAPTER *ioc,
6418     struct fw_event_work *fw_event)
6419 {
6420         u64 wwid;
6421         unsigned long flags;
6422         struct _raid_device *raid_device;
6423         u16 handle;
6424         u32 state;
6425         int rc;
6426         Mpi2EventDataIrVolume_t *event_data = fw_event->event_data;
6427 
6428         if (ioc->shost_recovery)
6429                 return;
6430 
6431         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
6432                 return;
6433 
6434         handle = le16_to_cpu(event_data->VolDevHandle);
6435         state = le32_to_cpu(event_data->NewValue);
6436         if (!ioc->hide_ir_msg)
6437                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
6438                     "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
6439                     le32_to_cpu(event_data->PreviousValue), state));
6440 
6441         switch (state) {
6442         case MPI2_RAID_VOL_STATE_MISSING:
6443         case MPI2_RAID_VOL_STATE_FAILED:
6444                 _scsih_sas_volume_delete(ioc, handle);
6445                 break;
6446 
6447         case MPI2_RAID_VOL_STATE_ONLINE:
6448         case MPI2_RAID_VOL_STATE_DEGRADED:
6449         case MPI2_RAID_VOL_STATE_OPTIMAL:
6450 
6451                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6452                 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6453                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6454 
6455                 if (raid_device)
6456                         break;
6457 
6458                 mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
6459                 if (!wwid) {
6460                         printk(MPT2SAS_ERR_FMT
6461                             "failure at %s:%d/%s()!\n", ioc->name,
6462                             __FILE__, __LINE__, __func__);
6463                         break;
6464                 }
6465 
6466                 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
6467                 if (!raid_device) {
6468                         printk(MPT2SAS_ERR_FMT
6469                             "failure at %s:%d/%s()!\n", ioc->name,
6470                             __FILE__, __LINE__, __func__);
6471                         break;
6472                 }
6473 
6474                 raid_device->id = ioc->sas_id++;
6475                 raid_device->channel = RAID_CHANNEL;
6476                 raid_device->handle = handle;
6477                 raid_device->wwid = wwid;
6478                 _scsih_raid_device_add(ioc, raid_device);
6479                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6480                     raid_device->id, 0);
6481                 if (rc)
6482                         _scsih_raid_device_remove(ioc, raid_device);
6483                 break;
6484 
6485         case MPI2_RAID_VOL_STATE_INITIALIZING:
6486         default:
6487                 break;
6488         }
6489 }
6490 
6491 /**
6492  * _scsih_sas_ir_physical_disk_event - PD event
6493  * @ioc: per adapter object
6494  * @fw_event: The fw_event_work object
6495  * Context: user.
6496  *
6497  * Return nothing.
6498  */
6499 static void
6500 _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
6501     struct fw_event_work *fw_event)
6502 {
6503         u16 handle, parent_handle;
6504         u32 state;
6505         struct _sas_device *sas_device;
6506         unsigned long flags;
6507         Mpi2ConfigReply_t mpi_reply;
6508         Mpi2SasDevicePage0_t sas_device_pg0;
6509         u32 ioc_status;
6510         Mpi2EventDataIrPhysicalDisk_t *event_data = fw_event->event_data;
6511         u64 sas_address;
6512 
6513         if (ioc->shost_recovery)
6514                 return;
6515 
6516         if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
6517                 return;
6518 
6519         handle = le16_to_cpu(event_data->PhysDiskDevHandle);
6520         state = le32_to_cpu(event_data->NewValue);
6521 
6522         if (!ioc->hide_ir_msg)
6523                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
6524                     "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
6525                     le32_to_cpu(event_data->PreviousValue), state));
6526 
6527         switch (state) {
6528         case MPI2_RAID_PD_STATE_ONLINE:
6529         case MPI2_RAID_PD_STATE_DEGRADED:
6530         case MPI2_RAID_PD_STATE_REBUILDING:
6531         case MPI2_RAID_PD_STATE_OPTIMAL:
6532         case MPI2_RAID_PD_STATE_HOT_SPARE:
6533 
6534                 if (!ioc->is_warpdrive)
6535                         set_bit(handle, ioc->pd_handles);
6536 
6537                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6538                 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6539                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6540 
6541                 if (sas_device)
6542                         return;
6543 
6544                 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6545                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
6546                     handle))) {
6547                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6548                             ioc->name, __FILE__, __LINE__, __func__);
6549                         return;
6550                 }
6551 
6552                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6553                     MPI2_IOCSTATUS_MASK;
6554                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6555                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6556                             ioc->name, __FILE__, __LINE__, __func__);
6557                         return;
6558                 }
6559 
6560                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6561                 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6562                         mpt2sas_transport_update_links(ioc, sas_address, handle,
6563                             sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
6564 
6565                 _scsih_add_device(ioc, handle, 0, 1);
6566 
6567                 break;
6568 
6569         case MPI2_RAID_PD_STATE_OFFLINE:
6570         case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
6571         case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
6572         default:
6573                 break;
6574         }
6575 }
6576 
6577 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
6578 /**
6579  * _scsih_sas_ir_operation_status_event_debug - debug for IR op event
6580  * @ioc: per adapter object
6581  * @event_data: event data payload
6582  * Context: user.
6583  *
6584  * Return nothing.
6585  */
6586 static void
6587 _scsih_sas_ir_operation_status_event_debug(struct MPT2SAS_ADAPTER *ioc,
6588     Mpi2EventDataIrOperationStatus_t *event_data)
6589 {
6590         char *reason_str = NULL;
6591 
6592         switch (event_data->RAIDOperation) {
6593         case MPI2_EVENT_IR_RAIDOP_RESYNC:
6594                 reason_str = "resync";
6595                 break;
6596         case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:
6597                 reason_str = "online capacity expansion";
6598                 break;
6599         case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
6600                 reason_str = "consistency check";
6601                 break;
6602         case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:
6603                 reason_str = "background init";
6604                 break;
6605         case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:
6606                 reason_str = "make data consistent";
6607                 break;
6608         }
6609 
6610         if (!reason_str)
6611                 return;
6612 
6613         printk(MPT2SAS_INFO_FMT "raid operational status: (%s)"
6614             "\thandle(0x%04x), percent complete(%d)\n",
6615             ioc->name, reason_str,
6616             le16_to_cpu(event_data->VolDevHandle),
6617             event_data->PercentComplete);
6618 }
6619 #endif
6620 
6621 /**
6622  * _scsih_sas_ir_operation_status_event - handle RAID operation events
6623  * @ioc: per adapter object
6624  * @fw_event: The fw_event_work object
6625  * Context: user.
6626  *
6627  * Return nothing.
6628  */
6629 static void
6630 _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
6631     struct fw_event_work *fw_event)
6632 {
6633         Mpi2EventDataIrOperationStatus_t *event_data = fw_event->event_data;
6634         static struct _raid_device *raid_device;
6635         unsigned long flags;
6636         u16 handle;
6637 
6638 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
6639         if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6640             && !ioc->hide_ir_msg)
6641                 _scsih_sas_ir_operation_status_event_debug(ioc,
6642                      event_data);
6643 #endif
6644 
6645         /* code added for raid transport support */
6646         if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
6647 
6648                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6649                 handle = le16_to_cpu(event_data->VolDevHandle);
6650                 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6651                 if (raid_device)
6652                         raid_device->percent_complete =
6653                             event_data->PercentComplete;
6654                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6655         }
6656 }
6657 
6658 /**
6659  * _scsih_prep_device_scan - initialize parameters prior to device scan
6660  * @ioc: per adapter object
6661  *
6662  * Set the deleted flag prior to device scan.  If the device is found during
6663  * the scan, then we clear the deleted flag.
6664  */
6665 static void
6666 _scsih_prep_device_scan(struct MPT2SAS_ADAPTER *ioc)
6667 {
6668         struct MPT2SAS_DEVICE *sas_device_priv_data;
6669         struct scsi_device *sdev;
6670 
6671         shost_for_each_device(sdev, ioc->shost) {
6672                 sas_device_priv_data = sdev->hostdata;
6673                 if (sas_device_priv_data && sas_device_priv_data->sas_target)
6674                         sas_device_priv_data->sas_target->deleted = 1;
6675         }
6676 }
6677 
6678 /**
6679  * _scsih_mark_responding_sas_device - mark a sas_devices as responding
6680  * @ioc: per adapter object
6681  * @sas_address: sas address
6682  * @slot: enclosure slot id
6683  * @handle: device handle
6684  *
6685  * After host reset, find out whether devices are still responding.
6686  * Used in _scsi_remove_unresponsive_sas_devices.
6687  *
6688  * Return nothing.
6689  */
6690 static void
6691 _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
6692     u16 slot, u16 handle)
6693 {
6694         struct MPT2SAS_TARGET *sas_target_priv_data = NULL;
6695         struct scsi_target *starget;
6696         struct _sas_device *sas_device;
6697         unsigned long flags;
6698 
6699         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6700         list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
6701                 if (sas_device->sas_address == sas_address &&
6702                     sas_device->slot == slot) {
6703                         sas_device->responding = 1;
6704                         starget = sas_device->starget;
6705                         if (starget && starget->hostdata) {
6706                                 sas_target_priv_data = starget->hostdata;
6707                                 sas_target_priv_data->tm_busy = 0;
6708                                 sas_target_priv_data->deleted = 0;
6709                         } else
6710                                 sas_target_priv_data = NULL;
6711                         if (starget)
6712                                 starget_printk(KERN_INFO, starget,
6713                                     "handle(0x%04x), sas_addr(0x%016llx), "
6714                                     "enclosure logical id(0x%016llx), "
6715                                     "slot(%d)\n", handle,
6716                                     (unsigned long long)sas_device->sas_address,
6717                                     (unsigned long long)
6718                                     sas_device->enclosure_logical_id,
6719                                     sas_device->slot);
6720                         if (sas_device->handle == handle)
6721                                 goto out;
6722                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
6723                             sas_device->handle);
6724                         sas_device->handle = handle;
6725                         if (sas_target_priv_data)
6726                                 sas_target_priv_data->handle = handle;
6727                         goto out;
6728                 }
6729         }
6730  out:
6731         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6732 }
6733 
6734 /**
6735  * _scsih_search_responding_sas_devices -
6736  * @ioc: per adapter object
6737  *
6738  * After host reset, find out whether devices are still responding.
6739  * If not remove.
6740  *
6741  * Return nothing.
6742  */
6743 static void
6744 _scsih_search_responding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
6745 {
6746         Mpi2SasDevicePage0_t sas_device_pg0;
6747         Mpi2ConfigReply_t mpi_reply;
6748         u16 ioc_status;
6749         __le64 sas_address;
6750         u16 handle;
6751         u32 device_info;
6752         u16 slot;
6753 
6754         printk(MPT2SAS_INFO_FMT "search for end-devices: start\n", ioc->name);
6755 
6756         if (list_empty(&ioc->sas_device_list))
6757                 goto out;
6758 
6759         handle = 0xFFFF;
6760         while (!(mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6761             &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
6762             handle))) {
6763                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6764                     MPI2_IOCSTATUS_MASK;
6765                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
6766                         break;
6767                 handle = le16_to_cpu(sas_device_pg0.DevHandle);
6768                 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
6769                 if (!(_scsih_is_end_device(device_info)))
6770                         continue;
6771                 sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
6772                 slot = le16_to_cpu(sas_device_pg0.Slot);
6773                 _scsih_mark_responding_sas_device(ioc, sas_address, slot,
6774                     handle);
6775         }
6776 out:
6777         printk(MPT2SAS_INFO_FMT "search for end-devices: complete\n",
6778             ioc->name);
6779 }
6780 
6781 /**
6782  * _scsih_mark_responding_raid_device - mark a raid_device as responding
6783  * @ioc: per adapter object
6784  * @wwid: world wide identifier for raid volume
6785  * @handle: device handle
6786  *
6787  * After host reset, find out whether devices are still responding.
6788  * Used in _scsi_remove_unresponsive_raid_devices.
6789  *
6790  * Return nothing.
6791  */
6792 static void
6793 _scsih_mark_responding_raid_device(struct MPT2SAS_ADAPTER *ioc, u64 wwid,
6794     u16 handle)
6795 {
6796         struct MPT2SAS_TARGET *sas_target_priv_data;
6797         struct scsi_target *starget;
6798         struct _raid_device *raid_device;
6799         unsigned long flags;
6800 
6801         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6802         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
6803                 if (raid_device->wwid == wwid && raid_device->starget) {
6804                         starget = raid_device->starget;
6805                         if (starget && starget->hostdata) {
6806                                 sas_target_priv_data = starget->hostdata;
6807                                 sas_target_priv_data->deleted = 0;
6808                         } else
6809                                 sas_target_priv_data = NULL;
6810                         raid_device->responding = 1;
6811                         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6812                         starget_printk(KERN_INFO, raid_device->starget,
6813                             "handle(0x%04x), wwid(0x%016llx)\n", handle,
6814                             (unsigned long long)raid_device->wwid);
6815                         /*
6816                          * WARPDRIVE: The handles of the PDs might have changed
6817                          * across the host reset so re-initialize the
6818                          * required data for Direct IO
6819                          */
6820                         _scsih_init_warpdrive_properties(ioc, raid_device);
6821                         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6822                         if (raid_device->handle == handle) {
6823                                 spin_unlock_irqrestore(&ioc->raid_device_lock,
6824                                     flags);
6825                                 return;
6826                         }
6827                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
6828                             raid_device->handle);
6829                         raid_device->handle = handle;
6830                         if (sas_target_priv_data)
6831                                 sas_target_priv_data->handle = handle;
6832                         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6833                         return;
6834                 }
6835         }
6836 
6837         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6838 }
6839 
6840 /**
6841  * _scsih_search_responding_raid_devices -
6842  * @ioc: per adapter object
6843  *
6844  * After host reset, find out whether devices are still responding.
6845  * If not remove.
6846  *
6847  * Return nothing.
6848  */
6849 static void
6850 _scsih_search_responding_raid_devices(struct MPT2SAS_ADAPTER *ioc)
6851 {
6852         Mpi2RaidVolPage1_t volume_pg1;
6853         Mpi2RaidVolPage0_t volume_pg0;
6854         Mpi2RaidPhysDiskPage0_t pd_pg0;
6855         Mpi2ConfigReply_t mpi_reply;
6856         u16 ioc_status;
6857         u16 handle;
6858         u8 phys_disk_num;
6859 
6860         if (!ioc->ir_firmware)
6861                 return;
6862 
6863         printk(MPT2SAS_INFO_FMT "search for raid volumes: start\n",
6864             ioc->name);
6865 
6866         if (list_empty(&ioc->raid_device_list))
6867                 goto out;
6868 
6869         handle = 0xFFFF;
6870         while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
6871             &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
6872                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6873                     MPI2_IOCSTATUS_MASK;
6874                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
6875                         break;
6876                 handle = le16_to_cpu(volume_pg1.DevHandle);
6877 
6878                 if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
6879                     &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
6880                      sizeof(Mpi2RaidVolPage0_t)))
6881                         continue;
6882 
6883                 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
6884                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
6885                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED)
6886                         _scsih_mark_responding_raid_device(ioc,
6887                             le64_to_cpu(volume_pg1.WWID), handle);
6888         }
6889 
6890         /* refresh the pd_handles */
6891         if (!ioc->is_warpdrive) {
6892                 phys_disk_num = 0xFF;
6893                 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
6894                 while (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
6895                     &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
6896                     phys_disk_num))) {
6897                         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6898                             MPI2_IOCSTATUS_MASK;
6899                         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
6900                                 break;
6901                         phys_disk_num = pd_pg0.PhysDiskNum;
6902                         handle = le16_to_cpu(pd_pg0.DevHandle);
6903                         set_bit(handle, ioc->pd_handles);
6904                 }
6905         }
6906 out:
6907         printk(MPT2SAS_INFO_FMT "search for responding raid volumes: "
6908             "complete\n", ioc->name);
6909 }
6910 
6911 /**
6912  * _scsih_mark_responding_expander - mark a expander as responding
6913  * @ioc: per adapter object
6914  * @sas_address: sas address
6915  * @handle:
6916  *
6917  * After host reset, find out whether devices are still responding.
6918  * Used in _scsi_remove_unresponsive_expanders.
6919  *
6920  * Return nothing.
6921  */
6922 static void
6923 _scsih_mark_responding_expander(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
6924      u16 handle)
6925 {
6926         struct _sas_node *sas_expander;
6927         unsigned long flags;
6928         int i;
6929 
6930         spin_lock_irqsave(&ioc->sas_node_lock, flags);
6931         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
6932                 if (sas_expander->sas_address != sas_address)
6933                         continue;
6934                 sas_expander->responding = 1;
6935                 if (sas_expander->handle == handle)
6936                         goto out;
6937                 printk(KERN_INFO "\texpander(0x%016llx): handle changed"
6938                     " from(0x%04x) to (0x%04x)!!!\n",
6939                     (unsigned long long)sas_expander->sas_address,
6940                     sas_expander->handle, handle);
6941                 sas_expander->handle = handle;
6942                 for (i = 0 ; i < sas_expander->num_phys ; i++)
6943                         sas_expander->phy[i].handle = handle;
6944                 goto out;
6945         }
6946  out:
694