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