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