xref: /freebsd/sys/dev/mpr/mpr_sas_lsi.c (revision 7c1b51d6dc2e165ae7333373513b080f17cf79bd)
1 /*-
2  * Copyright (c) 2011-2015 LSI Corp.
3  * Copyright (c) 2013-2016 Avago Technologies
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  *
27  * Avago Technologies (LSI) MPT-Fusion Host Adapter FreeBSD
28  */
29 
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32 
33 /* Communications core for Avago Technologies (LSI) MPT3 */
34 
35 /* TODO Move headers to mprvar */
36 #include <sys/types.h>
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/kernel.h>
40 #include <sys/selinfo.h>
41 #include <sys/module.h>
42 #include <sys/bus.h>
43 #include <sys/conf.h>
44 #include <sys/bio.h>
45 #include <sys/malloc.h>
46 #include <sys/uio.h>
47 #include <sys/sysctl.h>
48 #include <sys/endian.h>
49 #include <sys/queue.h>
50 #include <sys/kthread.h>
51 #include <sys/taskqueue.h>
52 #include <sys/sbuf.h>
53 
54 #include <machine/bus.h>
55 #include <machine/resource.h>
56 #include <sys/rman.h>
57 
58 #include <machine/stdarg.h>
59 
60 #include <cam/cam.h>
61 #include <cam/cam_ccb.h>
62 #include <cam/cam_debug.h>
63 #include <cam/cam_sim.h>
64 #include <cam/cam_xpt_sim.h>
65 #include <cam/cam_xpt_periph.h>
66 #include <cam/cam_periph.h>
67 #include <cam/scsi/scsi_all.h>
68 #include <cam/scsi/scsi_message.h>
69 
70 #include <dev/mpr/mpi/mpi2_type.h>
71 #include <dev/mpr/mpi/mpi2.h>
72 #include <dev/mpr/mpi/mpi2_ioc.h>
73 #include <dev/mpr/mpi/mpi2_sas.h>
74 #include <dev/mpr/mpi/mpi2_pci.h>
75 #include <dev/mpr/mpi/mpi2_cnfg.h>
76 #include <dev/mpr/mpi/mpi2_init.h>
77 #include <dev/mpr/mpi/mpi2_raid.h>
78 #include <dev/mpr/mpi/mpi2_tool.h>
79 #include <dev/mpr/mpr_ioctl.h>
80 #include <dev/mpr/mprvar.h>
81 #include <dev/mpr/mpr_table.h>
82 #include <dev/mpr/mpr_sas.h>
83 
84 /* For Hashed SAS Address creation for SATA Drives */
85 #define MPT2SAS_SN_LEN 20
86 #define MPT2SAS_MN_LEN 40
87 
88 struct mpr_fw_event_work {
89 	u16			event;
90 	void			*event_data;
91 	TAILQ_ENTRY(mpr_fw_event_work)	ev_link;
92 };
93 
94 union _sata_sas_address {
95 	u8 wwid[8];
96 	struct {
97 		u32 high;
98 		u32 low;
99 	} word;
100 };
101 
102 /*
103  * define the IDENTIFY DEVICE structure
104  */
105 struct _ata_identify_device_data {
106 	u16 reserved1[10];	/* 0-9 */
107 	u16 serial_number[10];	/* 10-19 */
108 	u16 reserved2[7];	/* 20-26 */
109 	u16 model_number[20];	/* 27-46*/
110 	u16 reserved3[170];	/* 47-216 */
111 	u16 rotational_speed;	/* 217 */
112 	u16 reserved4[38];	/* 218-255 */
113 };
114 static u32 event_count;
115 static void mprsas_fw_work(struct mpr_softc *sc,
116     struct mpr_fw_event_work *fw_event);
117 static void mprsas_fw_event_free(struct mpr_softc *,
118     struct mpr_fw_event_work *);
119 static int mprsas_add_device(struct mpr_softc *sc, u16 handle, u8 linkrate);
120 static int mprsas_add_pcie_device(struct mpr_softc *sc, u16 handle,
121     u8 linkrate);
122 static int mprsas_get_sata_identify(struct mpr_softc *sc, u16 handle,
123     Mpi2SataPassthroughReply_t *mpi_reply, char *id_buffer, int sz,
124     u32 devinfo);
125 static void mprsas_ata_id_timeout(void *data);
126 int mprsas_get_sas_address_for_sata_disk(struct mpr_softc *sc,
127     u64 *sas_address, u16 handle, u32 device_info, u8 *is_SATA_SSD);
128 static int mprsas_volume_add(struct mpr_softc *sc,
129     u16 handle);
130 static void mprsas_SSU_to_SATA_devices(struct mpr_softc *sc);
131 static void mprsas_stop_unit_done(struct cam_periph *periph,
132     union ccb *done_ccb);
133 
134 void
135 mprsas_evt_handler(struct mpr_softc *sc, uintptr_t data,
136     MPI2_EVENT_NOTIFICATION_REPLY *event)
137 {
138 	struct mpr_fw_event_work *fw_event;
139 	u16 sz;
140 
141 	mpr_dprint(sc, MPR_TRACE, "%s\n", __func__);
142 	MPR_DPRINT_EVENT(sc, sas, event);
143 	mprsas_record_event(sc, event);
144 
145 	fw_event = malloc(sizeof(struct mpr_fw_event_work), M_MPR,
146 	     M_ZERO|M_NOWAIT);
147 	if (!fw_event) {
148 		printf("%s: allocate failed for fw_event\n", __func__);
149 		return;
150 	}
151 	sz = le16toh(event->EventDataLength) * 4;
152 	fw_event->event_data = malloc(sz, M_MPR, M_ZERO|M_NOWAIT);
153 	if (!fw_event->event_data) {
154 		printf("%s: allocate failed for event_data\n", __func__);
155 		free(fw_event, M_MPR);
156 		return;
157 	}
158 
159 	bcopy(event->EventData, fw_event->event_data, sz);
160 	fw_event->event = event->Event;
161 	if ((event->Event == MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
162 	    event->Event == MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST ||
163 	    event->Event == MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE ||
164 	    event->Event == MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST) &&
165 	    sc->track_mapping_events)
166 		sc->pending_map_events++;
167 
168 	/*
169 	 * When wait_for_port_enable flag is set, make sure that all the events
170 	 * are processed. Increment the startup_refcount and decrement it after
171 	 * events are processed.
172 	 */
173 	if ((event->Event == MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
174 	    event->Event == MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST ||
175 	    event->Event == MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST) &&
176 	    sc->wait_for_port_enable)
177 		mprsas_startup_increment(sc->sassc);
178 
179 	TAILQ_INSERT_TAIL(&sc->sassc->ev_queue, fw_event, ev_link);
180 	taskqueue_enqueue(sc->sassc->ev_tq, &sc->sassc->ev_task);
181 }
182 
183 static void
184 mprsas_fw_event_free(struct mpr_softc *sc, struct mpr_fw_event_work *fw_event)
185 {
186 
187 	free(fw_event->event_data, M_MPR);
188 	free(fw_event, M_MPR);
189 }
190 
191 /**
192  * _mpr_fw_work - delayed task for processing firmware events
193  * @sc: per adapter object
194  * @fw_event: The fw_event_work object
195  * Context: user.
196  *
197  * Return nothing.
198  */
199 static void
200 mprsas_fw_work(struct mpr_softc *sc, struct mpr_fw_event_work *fw_event)
201 {
202 	struct mprsas_softc *sassc;
203 	sassc = sc->sassc;
204 
205 	mpr_dprint(sc, MPR_EVENT, "(%d)->(%s) Working on  Event: [%x]\n",
206 	    event_count++, __func__, fw_event->event);
207 	switch (fw_event->event) {
208 	case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
209 	{
210 		MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *data;
211 		MPI2_EVENT_SAS_TOPO_PHY_ENTRY *phy;
212 		uint8_t i;
213 
214 		data = (MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *)
215 		    fw_event->event_data;
216 
217 		mpr_mapping_topology_change_event(sc, fw_event->event_data);
218 
219 		for (i = 0; i < data->NumEntries; i++) {
220 			phy = &data->PHY[i];
221 			switch (phy->PhyStatus & MPI2_EVENT_SAS_TOPO_RC_MASK) {
222 			case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
223 				if (mprsas_add_device(sc,
224 				    le16toh(phy->AttachedDevHandle),
225 				    phy->LinkRate)) {
226 					mpr_dprint(sc, MPR_ERROR, "%s: "
227 					    "failed to add device with handle "
228 					    "0x%x\n", __func__,
229 					    le16toh(phy->AttachedDevHandle));
230 					mprsas_prepare_remove(sassc, le16toh(
231 					    phy->AttachedDevHandle));
232 				}
233 				break;
234 			case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
235 				mprsas_prepare_remove(sassc, le16toh(
236 				    phy->AttachedDevHandle));
237 				break;
238 			case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
239 			case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
240 			case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
241 			default:
242 				break;
243 			}
244 		}
245 		/*
246 		 * refcount was incremented for this event in
247 		 * mprsas_evt_handler.  Decrement it here because the event has
248 		 * been processed.
249 		 */
250 		mprsas_startup_decrement(sassc);
251 		break;
252 	}
253 	case MPI2_EVENT_SAS_DISCOVERY:
254 	{
255 		MPI2_EVENT_DATA_SAS_DISCOVERY *data;
256 
257 		data = (MPI2_EVENT_DATA_SAS_DISCOVERY *)fw_event->event_data;
258 
259 		if (data->ReasonCode & MPI2_EVENT_SAS_DISC_RC_STARTED)
260 			mpr_dprint(sc, MPR_TRACE,"SAS discovery start event\n");
261 		if (data->ReasonCode & MPI2_EVENT_SAS_DISC_RC_COMPLETED) {
262 			mpr_dprint(sc, MPR_TRACE,"SAS discovery stop event\n");
263 			sassc->flags &= ~MPRSAS_IN_DISCOVERY;
264 			mprsas_discovery_end(sassc);
265 		}
266 		break;
267 	}
268 	case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
269 	{
270 		Mpi2EventDataSasEnclDevStatusChange_t *data;
271 		data = (Mpi2EventDataSasEnclDevStatusChange_t *)
272 		    fw_event->event_data;
273 		mpr_mapping_enclosure_dev_status_change_event(sc,
274 		    fw_event->event_data);
275 		break;
276 	}
277 	case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
278 	{
279 		Mpi2EventIrConfigElement_t *element;
280 		int i;
281 		u8 foreign_config, reason;
282 		u16 elementType;
283 		Mpi2EventDataIrConfigChangeList_t *event_data;
284 		struct mprsas_target *targ;
285 		unsigned int id;
286 
287 		event_data = fw_event->event_data;
288 		foreign_config = (le32toh(event_data->Flags) &
289 		    MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
290 
291 		element =
292 		    (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
293 		id = mpr_mapping_get_raid_tid_from_handle(sc,
294 		    element->VolDevHandle);
295 
296 		mpr_mapping_ir_config_change_event(sc, event_data);
297 		for (i = 0; i < event_data->NumElements; i++, element++) {
298 			reason = element->ReasonCode;
299 			elementType = le16toh(element->ElementFlags) &
300 			    MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
301 			/*
302 			 * check for element type of Phys Disk or Hot Spare
303 			 */
304 			if ((elementType !=
305 			    MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT)
306 			    && (elementType !=
307 			    MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT))
308 				// do next element
309 				goto skip_fp_send;
310 
311 			/*
312 			 * check for reason of Hide, Unhide, PD Created, or PD
313 			 * Deleted
314 			 */
315 			if ((reason != MPI2_EVENT_IR_CHANGE_RC_HIDE) &&
316 			    (reason != MPI2_EVENT_IR_CHANGE_RC_UNHIDE) &&
317 			    (reason != MPI2_EVENT_IR_CHANGE_RC_PD_CREATED) &&
318 			    (reason != MPI2_EVENT_IR_CHANGE_RC_PD_DELETED))
319 				goto skip_fp_send;
320 
321 			// check for a reason of Hide or PD Created
322 			if ((reason == MPI2_EVENT_IR_CHANGE_RC_HIDE) ||
323 			    (reason == MPI2_EVENT_IR_CHANGE_RC_PD_CREATED))
324 			{
325 				// build RAID Action message
326 				Mpi2RaidActionRequest_t	*action;
327 				Mpi2RaidActionReply_t *reply = NULL;
328 				struct mpr_command *cm;
329 				int error = 0;
330 				if ((cm = mpr_alloc_command(sc)) == NULL) {
331 					printf("%s: command alloc failed\n",
332 					    __func__);
333 					return;
334 				}
335 
336 				mpr_dprint(sc, MPR_EVENT, "Sending FP action "
337 				    "from "
338 				    "MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST "
339 				    ":\n");
340 				action = (MPI2_RAID_ACTION_REQUEST *)cm->cm_req;
341 				action->Function = MPI2_FUNCTION_RAID_ACTION;
342 				action->Action =
343 				    MPI2_RAID_ACTION_PHYSDISK_HIDDEN;
344 				action->PhysDiskNum = element->PhysDiskNum;
345 				cm->cm_desc.Default.RequestFlags =
346 				    MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
347 				error = mpr_request_polled(sc, &cm);
348 				if (cm != NULL)
349 					reply = (Mpi2RaidActionReply_t *)
350 					    cm->cm_reply;
351 				if (error || (reply == NULL)) {
352 					/* FIXME */
353 					/*
354 					 * If the poll returns error then we
355 					 * need to do diag reset
356 					 */
357 					printf("%s: poll for page completed "
358 					    "with error %d", __func__, error);
359 				}
360 				if (reply && (le16toh(reply->IOCStatus) &
361 				    MPI2_IOCSTATUS_MASK) !=
362 				    MPI2_IOCSTATUS_SUCCESS) {
363 					mpr_dprint(sc, MPR_ERROR, "%s: error "
364 					    "sending RaidActionPage; "
365 					    "iocstatus = 0x%x\n", __func__,
366 					    le16toh(reply->IOCStatus));
367 				}
368 
369 				if (cm)
370 					mpr_free_command(sc, cm);
371 			}
372 skip_fp_send:
373 			mpr_dprint(sc, MPR_EVENT, "Received "
374 			    "MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST Reason "
375 			    "code %x:\n", element->ReasonCode);
376 			switch (element->ReasonCode) {
377 			case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
378 			case MPI2_EVENT_IR_CHANGE_RC_ADDED:
379 				if (!foreign_config) {
380 					if (mprsas_volume_add(sc,
381 					    le16toh(element->VolDevHandle))) {
382 						printf("%s: failed to add RAID "
383 						    "volume with handle 0x%x\n",
384 						    __func__, le16toh(element->
385 						    VolDevHandle));
386 					}
387 				}
388 				break;
389 			case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
390 			case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
391 				/*
392 				 * Rescan after volume is deleted or removed.
393 				 */
394 				if (!foreign_config) {
395 					if (id == MPR_MAP_BAD_ID) {
396 						printf("%s: could not get ID "
397 						    "for volume with handle "
398 						    "0x%04x\n", __func__,
399 						    le16toh(element->
400 						    VolDevHandle));
401 						break;
402 					}
403 
404 					targ = &sassc->targets[id];
405 					targ->handle = 0x0;
406 					targ->encl_slot = 0x0;
407 					targ->encl_handle = 0x0;
408 					targ->encl_level_valid = 0x0;
409 					targ->encl_level = 0x0;
410 					targ->connector_name[0] = ' ';
411 					targ->connector_name[1] = ' ';
412 					targ->connector_name[2] = ' ';
413 					targ->connector_name[3] = ' ';
414 					targ->exp_dev_handle = 0x0;
415 					targ->phy_num = 0x0;
416 					targ->linkrate = 0x0;
417 					mprsas_rescan_target(sc, targ);
418 					printf("RAID target id 0x%x removed\n",
419 					    targ->tid);
420 				}
421 				break;
422 			case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
423 			case MPI2_EVENT_IR_CHANGE_RC_HIDE:
424 				/*
425 				 * Phys Disk of a volume has been created.  Hide
426 				 * it from the OS.
427 				 */
428 				targ = mprsas_find_target_by_handle(sassc, 0,
429 				    element->PhysDiskDevHandle);
430 				if (targ == NULL)
431 					break;
432 				targ->flags |= MPR_TARGET_FLAGS_RAID_COMPONENT;
433 				mprsas_rescan_target(sc, targ);
434 				break;
435 			case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
436 				/*
437 				 * Phys Disk of a volume has been deleted.
438 				 * Expose it to the OS.
439 				 */
440 				if (mprsas_add_device(sc,
441 				    le16toh(element->PhysDiskDevHandle), 0)) {
442 					printf("%s: failed to add device with "
443 					    "handle 0x%x\n", __func__,
444 					    le16toh(element->
445 					    PhysDiskDevHandle));
446 					mprsas_prepare_remove(sassc,
447 					    le16toh(element->
448 					    PhysDiskDevHandle));
449 				}
450 				break;
451 			}
452 		}
453 		/*
454 		 * refcount was incremented for this event in
455 		 * mprsas_evt_handler.  Decrement it here because the event has
456 		 * been processed.
457 		 */
458 		mprsas_startup_decrement(sassc);
459 		break;
460 	}
461 	case MPI2_EVENT_IR_VOLUME:
462 	{
463 		Mpi2EventDataIrVolume_t *event_data = fw_event->event_data;
464 
465 		/*
466 		 * Informational only.
467 		 */
468 		mpr_dprint(sc, MPR_EVENT, "Received IR Volume event:\n");
469 		switch (event_data->ReasonCode) {
470 		case MPI2_EVENT_IR_VOLUME_RC_SETTINGS_CHANGED:
471   			mpr_dprint(sc, MPR_EVENT, "   Volume Settings "
472   			    "changed from 0x%x to 0x%x for Volome with "
473  			    "handle 0x%x", le32toh(event_data->PreviousValue),
474  			    le32toh(event_data->NewValue),
475  			    le16toh(event_data->VolDevHandle));
476 			break;
477 		case MPI2_EVENT_IR_VOLUME_RC_STATUS_FLAGS_CHANGED:
478   			mpr_dprint(sc, MPR_EVENT, "   Volume Status "
479   			    "changed from 0x%x to 0x%x for Volome with "
480  			    "handle 0x%x", le32toh(event_data->PreviousValue),
481  			    le32toh(event_data->NewValue),
482  			    le16toh(event_data->VolDevHandle));
483 			break;
484 		case MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED:
485   			mpr_dprint(sc, MPR_EVENT, "   Volume State "
486   			    "changed from 0x%x to 0x%x for Volome with "
487  			    "handle 0x%x", le32toh(event_data->PreviousValue),
488  			    le32toh(event_data->NewValue),
489  			    le16toh(event_data->VolDevHandle));
490 				u32 state;
491 				struct mprsas_target *targ;
492 				state = le32toh(event_data->NewValue);
493 				switch (state) {
494 				case MPI2_RAID_VOL_STATE_MISSING:
495 				case MPI2_RAID_VOL_STATE_FAILED:
496 					mprsas_prepare_volume_remove(sassc,
497 					    event_data->VolDevHandle);
498 					break;
499 
500 				case MPI2_RAID_VOL_STATE_ONLINE:
501 				case MPI2_RAID_VOL_STATE_DEGRADED:
502 				case MPI2_RAID_VOL_STATE_OPTIMAL:
503 					targ =
504 					    mprsas_find_target_by_handle(sassc,
505 					    0, event_data->VolDevHandle);
506 					if (targ) {
507 						printf("%s %d: Volume handle "
508 						    "0x%x is already added \n",
509 						    __func__, __LINE__,
510 						    event_data->VolDevHandle);
511 						break;
512 					}
513 					if (mprsas_volume_add(sc,
514 					    le16toh(event_data->
515 					    VolDevHandle))) {
516 						printf("%s: failed to add RAID "
517 						    "volume with handle 0x%x\n",
518 						    __func__, le16toh(
519 						    event_data->VolDevHandle));
520 					}
521 					break;
522 				default:
523 					break;
524 				}
525 			break;
526 		default:
527 			break;
528 		}
529 		break;
530 	}
531 	case MPI2_EVENT_IR_PHYSICAL_DISK:
532 	{
533 		Mpi2EventDataIrPhysicalDisk_t *event_data =
534 		    fw_event->event_data;
535 		struct mprsas_target *targ;
536 
537 		/*
538 		 * Informational only.
539 		 */
540 		mpr_dprint(sc, MPR_EVENT, "Received IR Phys Disk event:\n");
541 		switch (event_data->ReasonCode) {
542 		case MPI2_EVENT_IR_PHYSDISK_RC_SETTINGS_CHANGED:
543   			mpr_dprint(sc, MPR_EVENT, "   Phys Disk Settings "
544   			    "changed from 0x%x to 0x%x for Phys Disk Number "
545   			    "%d and handle 0x%x at Enclosure handle 0x%x, Slot "
546  			    "%d", le32toh(event_data->PreviousValue),
547  			    le32toh(event_data->NewValue),
548 			    event_data->PhysDiskNum,
549  			    le16toh(event_data->PhysDiskDevHandle),
550  			    le16toh(event_data->EnclosureHandle),
551 			    le16toh(event_data->Slot));
552 			break;
553 		case MPI2_EVENT_IR_PHYSDISK_RC_STATUS_FLAGS_CHANGED:
554   			mpr_dprint(sc, MPR_EVENT, "   Phys Disk Status changed "
555   			    "from 0x%x to 0x%x for Phys Disk Number %d and "
556   			    "handle 0x%x at Enclosure handle 0x%x, Slot %d",
557  			    le32toh(event_data->PreviousValue),
558  			    le32toh(event_data->NewValue),
559 			    event_data->PhysDiskNum,
560  			    le16toh(event_data->PhysDiskDevHandle),
561  			    le16toh(event_data->EnclosureHandle),
562 			    le16toh(event_data->Slot));
563 			break;
564 		case MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED:
565   			mpr_dprint(sc, MPR_EVENT, "   Phys Disk State changed "
566   			    "from 0x%x to 0x%x for Phys Disk Number %d and "
567   			    "handle 0x%x at Enclosure handle 0x%x, Slot %d",
568  			    le32toh(event_data->PreviousValue),
569  			    le32toh(event_data->NewValue),
570 			    event_data->PhysDiskNum,
571  			    le16toh(event_data->PhysDiskDevHandle),
572  			    le16toh(event_data->EnclosureHandle),
573 			    le16toh(event_data->Slot));
574 			switch (event_data->NewValue) {
575 				case MPI2_RAID_PD_STATE_ONLINE:
576 				case MPI2_RAID_PD_STATE_DEGRADED:
577 				case MPI2_RAID_PD_STATE_REBUILDING:
578 				case MPI2_RAID_PD_STATE_OPTIMAL:
579 				case MPI2_RAID_PD_STATE_HOT_SPARE:
580 					targ = mprsas_find_target_by_handle(
581 					    sassc, 0,
582 					    event_data->PhysDiskDevHandle);
583 					if (targ) {
584 						targ->flags |=
585 						    MPR_TARGET_FLAGS_RAID_COMPONENT;
586 						printf("%s %d: Found Target "
587 						    "for handle 0x%x.\n",
588 						    __func__, __LINE__ ,
589 						    event_data->
590 						    PhysDiskDevHandle);
591 					}
592 				break;
593 				case MPI2_RAID_PD_STATE_OFFLINE:
594 				case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
595 				case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
596 				default:
597 					targ = mprsas_find_target_by_handle(
598 					    sassc, 0,
599 					    event_data->PhysDiskDevHandle);
600 					if (targ) {
601 						targ->flags |=
602 					    ~MPR_TARGET_FLAGS_RAID_COMPONENT;
603 						printf("%s %d: Found Target "
604 						    "for handle 0x%x.  \n",
605 						    __func__, __LINE__ ,
606 						    event_data->
607 						    PhysDiskDevHandle);
608 					}
609 				break;
610 			}
611 		default:
612 			break;
613 		}
614 		break;
615 	}
616 	case MPI2_EVENT_IR_OPERATION_STATUS:
617 	{
618 		Mpi2EventDataIrOperationStatus_t *event_data =
619 		    fw_event->event_data;
620 
621 		/*
622 		 * Informational only.
623 		 */
624 		mpr_dprint(sc, MPR_EVENT, "Received IR Op Status event:\n");
625 		mpr_dprint(sc, MPR_EVENT, "   RAID Operation of %d is %d "
626 		    "percent complete for Volume with handle 0x%x",
627 		    event_data->RAIDOperation, event_data->PercentComplete,
628 		    le16toh(event_data->VolDevHandle));
629 		break;
630 	}
631 	case MPI2_EVENT_TEMP_THRESHOLD:
632 	{
633 		pMpi2EventDataTemperature_t	temp_event;
634 
635 		temp_event = (pMpi2EventDataTemperature_t)fw_event->event_data;
636 
637 		/*
638 		 * The Temp Sensor Count must be greater than the event's Sensor
639 		 * Num to be valid.  If valid, print the temp thresholds that
640 		 * have been exceeded.
641 		 */
642 		if (sc->iounit_pg8.NumSensors > temp_event->SensorNum) {
643 			mpr_dprint(sc, MPR_FAULT, "Temperature Threshold flags "
644 			    "%s %s %s %s exceeded for Sensor: %d !!!\n",
645 			    ((temp_event->Status & 0x01) == 1) ? "0 " : " ",
646 			    ((temp_event->Status & 0x02) == 2) ? "1 " : " ",
647 			    ((temp_event->Status & 0x04) == 4) ? "2 " : " ",
648 			    ((temp_event->Status & 0x08) == 8) ? "3 " : " ",
649 			    temp_event->SensorNum);
650 			mpr_dprint(sc, MPR_FAULT, "Current Temp in Celsius: "
651 			    "%d\n", temp_event->CurrentTemperature);
652 		}
653 		break;
654 	}
655 	case MPI2_EVENT_ACTIVE_CABLE_EXCEPTION:
656 	{
657 		pMpi26EventDataActiveCableExcept_t	ace_event_data;
658 		ace_event_data =
659 		    (pMpi26EventDataActiveCableExcept_t)fw_event->event_data;
660 
661 		switch(ace_event_data->ReasonCode) {
662 		case MPI26_EVENT_ACTIVE_CABLE_INSUFFICIENT_POWER:
663 		{
664 			mpr_printf(sc, "Currently a cable with "
665 			    "ReceptacleID %d cannot be powered and device "
666 			    "connected to this active cable will not be seen. "
667 			    "This active cable requires %d mW of power.\n",
668 			    ace_event_data->ReceptacleID,
669 			    ace_event_data->ActiveCablePowerRequirement);
670 			break;
671 		}
672 		case MPI26_EVENT_ACTIVE_CABLE_DEGRADED:
673 		{
674 			mpr_printf(sc, "Currently a cable with "
675 			    "ReceptacleID %d is not running at optimal speed "
676 			    "(12 Gb/s rate)\n", ace_event_data->ReceptacleID);
677 			break;
678 		}
679 		default:
680 			break;
681 		}
682 		break;
683 	}
684 	case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST:
685 	{
686 		MPI26_EVENT_DATA_PCIE_TOPOLOGY_CHANGE_LIST *data;
687 		MPI26_EVENT_PCIE_TOPO_PORT_ENTRY *port_entry;
688 		uint8_t i, link_rate;
689 		uint16_t handle;
690 
691 		data = (MPI26_EVENT_DATA_PCIE_TOPOLOGY_CHANGE_LIST *)
692 		    fw_event->event_data;
693 
694 		mpr_mapping_pcie_topology_change_event(sc,
695 		    fw_event->event_data);
696 
697 		for (i = 0; i < data->NumEntries; i++) {
698 			port_entry = &data->PortEntry[i];
699 			handle = le16toh(port_entry->AttachedDevHandle);
700 			link_rate = port_entry->CurrentPortInfo &
701 			    MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK;
702 			switch (port_entry->PortStatus) {
703 			case MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED:
704 				if (link_rate <
705 				    MPI26_EVENT_PCIE_TOPO_PI_RATE_2_5) {
706 					mpr_dprint(sc, MPR_ERROR, "%s: Cannot "
707 					    "add PCIe device with handle 0x%x "
708 					    "with unknown link rate.\n",
709 					    __func__, handle);
710 					break;
711 				}
712 				if (mprsas_add_pcie_device(sc, handle,
713 				    link_rate)) {
714 					mpr_dprint(sc, MPR_ERROR, "%s: failed "
715 					    "to add PCIe device with handle "
716 					    "0x%x\n", __func__, handle);
717 					mprsas_prepare_remove(sassc, handle);
718 				}
719 				break;
720 			case MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING:
721 				mprsas_prepare_remove(sassc, handle);
722 				break;
723 			case MPI26_EVENT_PCIE_TOPO_PS_PORT_CHANGED:
724 			case MPI26_EVENT_PCIE_TOPO_PS_NO_CHANGE:
725 			case MPI26_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING:
726 			default:
727 				break;
728 			}
729 		}
730 		/*
731 		 * refcount was incremented for this event in
732 		 * mprsas_evt_handler.  Decrement it here because the event has
733 		 * been processed.
734 		 */
735 		mprsas_startup_decrement(sassc);
736 		break;
737 	}
738 	case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
739 	case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
740 	default:
741 		mpr_dprint(sc, MPR_TRACE,"Unhandled event 0x%0X\n",
742 		    fw_event->event);
743 		break;
744 
745 	}
746 	mpr_dprint(sc, MPR_EVENT, "(%d)->(%s) Event Free: [%x]\n", event_count,
747 	    __func__, fw_event->event);
748 	mprsas_fw_event_free(sc, fw_event);
749 }
750 
751 void
752 mprsas_firmware_event_work(void *arg, int pending)
753 {
754 	struct mpr_fw_event_work *fw_event;
755 	struct mpr_softc *sc;
756 
757 	sc = (struct mpr_softc *)arg;
758 	mpr_lock(sc);
759 	while ((fw_event = TAILQ_FIRST(&sc->sassc->ev_queue)) != NULL) {
760 		TAILQ_REMOVE(&sc->sassc->ev_queue, fw_event, ev_link);
761 		mprsas_fw_work(sc, fw_event);
762 	}
763 	mpr_unlock(sc);
764 }
765 
766 static int
767 mprsas_add_device(struct mpr_softc *sc, u16 handle, u8 linkrate)
768 {
769 	char devstring[80];
770 	struct mprsas_softc *sassc;
771 	struct mprsas_target *targ;
772 	Mpi2ConfigReply_t mpi_reply;
773 	Mpi2SasDevicePage0_t config_page;
774 	uint64_t sas_address, parent_sas_address = 0;
775 	u32 device_info, parent_devinfo = 0;
776 	unsigned int id;
777 	int ret = 1, error = 0, i;
778 	struct mprsas_lun *lun;
779 	u8 is_SATA_SSD = 0;
780 	struct mpr_command *cm;
781 
782 	sassc = sc->sassc;
783 	mprsas_startup_increment(sassc);
784 	if ((mpr_config_get_sas_device_pg0(sc, &mpi_reply, &config_page,
785 	     MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
786 		printf("%s: error reading SAS device page0\n", __func__);
787 		error = ENXIO;
788 		goto out;
789 	}
790 
791 	device_info = le32toh(config_page.DeviceInfo);
792 
793 	if (((device_info & MPI2_SAS_DEVICE_INFO_SMP_TARGET) == 0)
794 	    && (le16toh(config_page.ParentDevHandle) != 0)) {
795 		Mpi2ConfigReply_t tmp_mpi_reply;
796 		Mpi2SasDevicePage0_t parent_config_page;
797 
798 		if ((mpr_config_get_sas_device_pg0(sc, &tmp_mpi_reply,
799 		     &parent_config_page, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
800 		     le16toh(config_page.ParentDevHandle)))) {
801 			mpr_dprint(sc, MPR_MAPPING|MPR_FAULT,
802 			   "%s: error reading SAS device %#x page0\n",
803 			    __func__, le16toh(config_page.ParentDevHandle));
804 		} else {
805 			parent_sas_address = parent_config_page.SASAddress.High;
806 			parent_sas_address = (parent_sas_address << 32) |
807 			    parent_config_page.SASAddress.Low;
808 			parent_devinfo = le32toh(parent_config_page.DeviceInfo);
809 		}
810 	}
811 	/* TODO Check proper endianness */
812 	sas_address = config_page.SASAddress.High;
813 	sas_address = (sas_address << 32) | config_page.SASAddress.Low;
814 	mpr_dprint(sc, MPR_MAPPING, "Handle 0x%04x SAS Address from SAS device "
815 	    "page0 = %jx\n", handle, sas_address);
816 
817 	/*
818 	 * Always get SATA Identify information because this is used to
819 	 * determine if Start/Stop Unit should be sent to the drive when the
820 	 * system is shutdown.
821 	 */
822 	if (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE) {
823 		ret = mprsas_get_sas_address_for_sata_disk(sc, &sas_address,
824 		    handle, device_info, &is_SATA_SSD);
825 		if (ret) {
826 			mpr_dprint(sc, MPR_MAPPING|MPR_ERROR,
827 			    "%s: failed to get disk type (SSD or HDD) for SATA "
828 			    "device with handle 0x%04x\n",
829 			    __func__, handle);
830 		} else {
831 			mpr_dprint(sc, MPR_MAPPING, "Handle 0x%04x SAS Address "
832 			    "from SATA device = %jx\n", handle, sas_address);
833 		}
834 	}
835 
836 	/*
837 	 * use_phynum:
838 	 *  1 - use the PhyNum field as a fallback to the mapping logic
839 	 *  0 - never use the PhyNum field
840 	 * -1 - only use the PhyNum field
841 	 *
842 	 * Note that using the Phy number to map a device can cause device adds
843 	 * to fail if multiple enclosures/expanders are in the topology. For
844 	 * example, if two devices are in the same slot number in two different
845 	 * enclosures within the topology, only one of those devices will be
846 	 * added. PhyNum mapping should not be used if multiple enclosures are
847 	 * in the topology.
848 	 */
849 	id = MPR_MAP_BAD_ID;
850 	if (sc->use_phynum != -1)
851 		id = mpr_mapping_get_tid(sc, sas_address, handle);
852 	if (id == MPR_MAP_BAD_ID) {
853 		if ((sc->use_phynum == 0) ||
854 		    ((id = config_page.PhyNum) > sassc->maxtargets)) {
855 			mpr_dprint(sc, MPR_INFO, "failure at %s:%d/%s()! "
856 			    "Could not get ID for device with handle 0x%04x\n",
857 			    __FILE__, __LINE__, __func__, handle);
858 			error = ENXIO;
859 			goto out;
860 		}
861 	}
862 	mpr_dprint(sc, MPR_MAPPING, "%s: Target ID for added device is %d.\n",
863 	    __func__, id);
864 
865 	/*
866 	 * Only do the ID check and reuse check if the target is not from a
867 	 * RAID Component. For Physical Disks of a Volume, the ID will be reused
868 	 * when a volume is deleted because the mapping entry for the PD will
869 	 * still be in the mapping table. The ID check should not be done here
870 	 * either since this PD is already being used.
871 	 */
872 	targ = &sassc->targets[id];
873 	if (!(targ->flags & MPR_TARGET_FLAGS_RAID_COMPONENT)) {
874 		if (mprsas_check_id(sassc, id) != 0) {
875 			mpr_dprint(sc, MPR_MAPPING|MPR_INFO,
876 			    "Excluding target id %d\n", id);
877 			error = ENXIO;
878 			goto out;
879 		}
880 
881 		if (targ->handle != 0x0) {
882 			mpr_dprint(sc, MPR_MAPPING, "Attempting to reuse "
883 			    "target id %d handle 0x%04x\n", id, targ->handle);
884 			error = ENXIO;
885 			goto out;
886 		}
887 	}
888 
889 	targ->devinfo = device_info;
890 	targ->devname = le32toh(config_page.DeviceName.High);
891 	targ->devname = (targ->devname << 32) |
892 	    le32toh(config_page.DeviceName.Low);
893 	targ->encl_handle = le16toh(config_page.EnclosureHandle);
894 	targ->encl_slot = le16toh(config_page.Slot);
895 	targ->encl_level = config_page.EnclosureLevel;
896 	targ->connector_name[0] = config_page.ConnectorName[0];
897 	targ->connector_name[1] = config_page.ConnectorName[1];
898 	targ->connector_name[2] = config_page.ConnectorName[2];
899 	targ->connector_name[3] = config_page.ConnectorName[3];
900 	targ->handle = handle;
901 	targ->parent_handle = le16toh(config_page.ParentDevHandle);
902 	targ->sasaddr = mpr_to_u64(&config_page.SASAddress);
903 	targ->parent_sasaddr = le64toh(parent_sas_address);
904 	targ->parent_devinfo = parent_devinfo;
905 	targ->tid = id;
906 	targ->linkrate = (linkrate>>4);
907 	targ->flags = 0;
908 	if (is_SATA_SSD) {
909 		targ->flags = MPR_TARGET_IS_SATA_SSD;
910 	}
911 	if ((le16toh(config_page.Flags) &
912 	    MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) &&
913 	    (le16toh(config_page.Flags) &
914 	    MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE)) {
915 		targ->scsi_req_desc_type =
916 		    MPI25_REQ_DESCRIPT_FLAGS_FAST_PATH_SCSI_IO;
917 	}
918 	if (le16toh(config_page.Flags) &
919 	    MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
920 		targ->encl_level_valid = TRUE;
921 	}
922 	TAILQ_INIT(&targ->commands);
923 	TAILQ_INIT(&targ->timedout_commands);
924 	while (!SLIST_EMPTY(&targ->luns)) {
925 		lun = SLIST_FIRST(&targ->luns);
926 		SLIST_REMOVE_HEAD(&targ->luns, lun_link);
927 		free(lun, M_MPR);
928 	}
929 	SLIST_INIT(&targ->luns);
930 
931 	mpr_describe_devinfo(targ->devinfo, devstring, 80);
932 	mpr_dprint(sc, (MPR_INFO|MPR_MAPPING), "Found device <%s> <%s> "
933 	    "handle<0x%04x> enclosureHandle<0x%04x> slot %d\n", devstring,
934 	    mpr_describe_table(mpr_linkrate_names, targ->linkrate),
935 	    targ->handle, targ->encl_handle, targ->encl_slot);
936 	if (targ->encl_level_valid) {
937 		mpr_dprint(sc, (MPR_INFO|MPR_MAPPING), "At enclosure level %d "
938 		    "and connector name (%4s)\n", targ->encl_level,
939 		    targ->connector_name);
940 	}
941 #if ((__FreeBSD_version >= 1000000) && (__FreeBSD_version < 1000039)) || \
942     (__FreeBSD_version < 902502)
943 	if ((sassc->flags & MPRSAS_IN_STARTUP) == 0)
944 #endif
945 		mprsas_rescan_target(sc, targ);
946 	mpr_dprint(sc, MPR_MAPPING, "Target id 0x%x added\n", targ->tid);
947 
948 	/*
949 	 * Check all commands to see if the SATA_ID_TIMEOUT flag has been set.
950 	 * If so, send a Target Reset TM to the target that was just created.
951 	 * An Abort Task TM should be used instead of a Target Reset, but that
952 	 * would be much more difficult because targets have not been fully
953 	 * discovered yet, and LUN's haven't been setup.  So, just reset the
954 	 * target instead of the LUN.
955 	 */
956 	for (i = 1; i < sc->num_reqs; i++) {
957 		cm = &sc->commands[i];
958 		if (cm->cm_flags & MPR_CM_FLAGS_SATA_ID_TIMEOUT) {
959 			targ->timeouts++;
960 			cm->cm_state = MPR_CM_STATE_TIMEDOUT;
961 
962 			if ((targ->tm = mprsas_alloc_tm(sc)) != NULL) {
963 				mpr_dprint(sc, MPR_INFO, "%s: sending Target "
964 				    "Reset for stuck SATA identify command "
965 				    "(cm = %p)\n", __func__, cm);
966 				targ->tm->cm_targ = targ;
967 				mprsas_send_reset(sc, targ->tm,
968 				    MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET);
969 			} else {
970 				mpr_dprint(sc, MPR_ERROR, "Failed to allocate "
971 				    "tm for Target Reset after SATA ID command "
972 				    "timed out (cm %p)\n", cm);
973 			}
974 			/*
975 			 * No need to check for more since the target is
976 			 * already being reset.
977 			 */
978 			break;
979 		}
980 	}
981 out:
982 	/*
983 	 * Free the commands that may not have been freed from the SATA ID call
984 	 */
985 	for (i = 1; i < sc->num_reqs; i++) {
986 		cm = &sc->commands[i];
987 		if (cm->cm_flags & MPR_CM_FLAGS_SATA_ID_TIMEOUT) {
988 			mpr_free_command(sc, cm);
989 		}
990 	}
991 	mprsas_startup_decrement(sassc);
992 	return (error);
993 }
994 
995 int
996 mprsas_get_sas_address_for_sata_disk(struct mpr_softc *sc,
997     u64 *sas_address, u16 handle, u32 device_info, u8 *is_SATA_SSD)
998 {
999 	Mpi2SataPassthroughReply_t mpi_reply;
1000 	int i, rc, try_count;
1001 	u32 *bufferptr;
1002 	union _sata_sas_address hash_address;
1003 	struct _ata_identify_device_data ata_identify;
1004 	u8 buffer[MPT2SAS_MN_LEN + MPT2SAS_SN_LEN];
1005 	u32 ioc_status;
1006 	u8 sas_status;
1007 
1008 	memset(&ata_identify, 0, sizeof(ata_identify));
1009 	memset(&mpi_reply, 0, sizeof(mpi_reply));
1010 	try_count = 0;
1011 	do {
1012 		rc = mprsas_get_sata_identify(sc, handle, &mpi_reply,
1013 		    (char *)&ata_identify, sizeof(ata_identify), device_info);
1014 		try_count++;
1015 		ioc_status = le16toh(mpi_reply.IOCStatus)
1016 		    & MPI2_IOCSTATUS_MASK;
1017 		sas_status = mpi_reply.SASStatus;
1018 		switch (ioc_status) {
1019 		case MPI2_IOCSTATUS_SUCCESS:
1020 			break;
1021 		case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
1022 			/* No sense sleeping.  this error won't get better */
1023 			break;
1024 		default:
1025 			if (sc->spinup_wait_time > 0) {
1026 				mpr_dprint(sc, MPR_INFO, "Sleeping %d seconds "
1027 				    "after SATA ID error to wait for spinup\n",
1028 				    sc->spinup_wait_time);
1029 				msleep(&sc->msleep_fake_chan, &sc->mpr_mtx, 0,
1030 				    "mprid", sc->spinup_wait_time * hz);
1031 			}
1032 		}
1033 	} while (((rc && (rc != EWOULDBLOCK)) ||
1034 	    (ioc_status && (ioc_status != MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR))
1035 	    || sas_status) && (try_count < 5));
1036 
1037 	if (rc == 0 && !ioc_status && !sas_status) {
1038 		mpr_dprint(sc, MPR_MAPPING, "%s: got SATA identify "
1039 		    "successfully for handle = 0x%x with try_count = %d\n",
1040 		    __func__, handle, try_count);
1041 	} else {
1042 		mpr_dprint(sc, MPR_MAPPING, "%s: handle = 0x%x failed\n",
1043 		    __func__, handle);
1044 		return -1;
1045 	}
1046 	/* Copy & byteswap the 40 byte model number to a buffer */
1047 	for (i = 0; i < MPT2SAS_MN_LEN; i += 2) {
1048 		buffer[i] = ((u8 *)ata_identify.model_number)[i + 1];
1049 		buffer[i + 1] = ((u8 *)ata_identify.model_number)[i];
1050 	}
1051 	/* Copy & byteswap the 20 byte serial number to a buffer */
1052 	for (i = 0; i < MPT2SAS_SN_LEN; i += 2) {
1053 		buffer[MPT2SAS_MN_LEN + i] =
1054 		    ((u8 *)ata_identify.serial_number)[i + 1];
1055 		buffer[MPT2SAS_MN_LEN + i + 1] =
1056 		    ((u8 *)ata_identify.serial_number)[i];
1057 	}
1058 	bufferptr = (u32 *)buffer;
1059 	/* There are 60 bytes to hash down to 8. 60 isn't divisible by 8,
1060 	 * so loop through the first 56 bytes (7*8),
1061 	 * and then add in the last dword.
1062 	 */
1063 	hash_address.word.low  = 0;
1064 	hash_address.word.high = 0;
1065 	for (i = 0; (i < ((MPT2SAS_MN_LEN+MPT2SAS_SN_LEN)/8)); i++) {
1066 		hash_address.word.low += *bufferptr;
1067 		bufferptr++;
1068 		hash_address.word.high += *bufferptr;
1069 		bufferptr++;
1070 	}
1071 	/* Add the last dword */
1072 	hash_address.word.low += *bufferptr;
1073 	/* Make sure the hash doesn't start with 5, because it could clash
1074 	 * with a SAS address. Change 5 to a D.
1075 	 */
1076 	if ((hash_address.word.high & 0x000000F0) == (0x00000050))
1077 		hash_address.word.high |= 0x00000080;
1078 	*sas_address = (u64)hash_address.wwid[0] << 56 |
1079 	    (u64)hash_address.wwid[1] << 48 | (u64)hash_address.wwid[2] << 40 |
1080 	    (u64)hash_address.wwid[3] << 32 | (u64)hash_address.wwid[4] << 24 |
1081 	    (u64)hash_address.wwid[5] << 16 | (u64)hash_address.wwid[6] <<  8 |
1082 	    (u64)hash_address.wwid[7];
1083 	if (ata_identify.rotational_speed == 1) {
1084 		*is_SATA_SSD = 1;
1085 	}
1086 
1087 	return 0;
1088 }
1089 
1090 static int
1091 mprsas_get_sata_identify(struct mpr_softc *sc, u16 handle,
1092     Mpi2SataPassthroughReply_t *mpi_reply, char *id_buffer, int sz, u32 devinfo)
1093 {
1094 	Mpi2SataPassthroughRequest_t *mpi_request;
1095 	Mpi2SataPassthroughReply_t *reply;
1096 	struct mpr_command *cm;
1097 	char *buffer;
1098 	int error = 0;
1099 
1100 	buffer = malloc( sz, M_MPR, M_NOWAIT | M_ZERO);
1101 	if (!buffer)
1102 		return ENOMEM;
1103 
1104 	if ((cm = mpr_alloc_command(sc)) == NULL) {
1105 		free(buffer, M_MPR);
1106 		return (EBUSY);
1107 	}
1108 	mpi_request = (MPI2_SATA_PASSTHROUGH_REQUEST *)cm->cm_req;
1109 	bzero(mpi_request,sizeof(MPI2_SATA_PASSTHROUGH_REQUEST));
1110 	mpi_request->Function = MPI2_FUNCTION_SATA_PASSTHROUGH;
1111 	mpi_request->VF_ID = 0;
1112 	mpi_request->DevHandle = htole16(handle);
1113 	mpi_request->PassthroughFlags = (MPI2_SATA_PT_REQ_PT_FLAGS_PIO |
1114 	    MPI2_SATA_PT_REQ_PT_FLAGS_READ);
1115 	mpi_request->DataLength = htole32(sz);
1116 	mpi_request->CommandFIS[0] = 0x27;
1117 	mpi_request->CommandFIS[1] = 0x80;
1118 	mpi_request->CommandFIS[2] =  (devinfo &
1119 	    MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? 0xA1 : 0xEC;
1120 	cm->cm_sge = &mpi_request->SGL;
1121 	cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
1122 	cm->cm_flags = MPR_CM_FLAGS_DATAIN;
1123 	cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
1124 	cm->cm_data = buffer;
1125 	cm->cm_length = htole32(sz);
1126 
1127 	/*
1128 	 * Start a timeout counter specifically for the SATA ID command. This
1129 	 * is used to fix a problem where the FW does not send a reply sometimes
1130 	 * when a bad disk is in the topology. So, this is used to timeout the
1131 	 * command so that processing can continue normally.
1132 	 */
1133 	mpr_dprint(sc, MPR_XINFO, "%s start timeout counter for SATA ID "
1134 	    "command\n", __func__);
1135 	callout_reset(&cm->cm_callout, MPR_ATA_ID_TIMEOUT * hz,
1136 	    mprsas_ata_id_timeout, cm);
1137 	error = mpr_wait_command(sc, &cm, 60, CAN_SLEEP);
1138 	mpr_dprint(sc, MPR_XINFO, "%s stop timeout counter for SATA ID "
1139 	    "command\n", __func__);
1140 	/* XXX KDM need to fix the case where this command is destroyed */
1141 	callout_stop(&cm->cm_callout);
1142 
1143 	if (cm != NULL)
1144 		reply = (Mpi2SataPassthroughReply_t *)cm->cm_reply;
1145 	if (error || (reply == NULL)) {
1146 		/* FIXME */
1147 		/*
1148 		 * If the request returns an error then we need to do a diag
1149 		 * reset
1150 		 */
1151 		printf("%s: request for page completed with error %d",
1152 		    __func__, error);
1153 		error = ENXIO;
1154 		goto out;
1155 	}
1156 	bcopy(buffer, id_buffer, sz);
1157 	bcopy(reply, mpi_reply, sizeof(Mpi2SataPassthroughReply_t));
1158 	if ((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) !=
1159 	    MPI2_IOCSTATUS_SUCCESS) {
1160 		printf("%s: error reading SATA PASSTHRU; iocstatus = 0x%x\n",
1161 		    __func__, reply->IOCStatus);
1162 		error = ENXIO;
1163 		goto out;
1164 	}
1165 out:
1166 	/*
1167 	 * If the SATA_ID_TIMEOUT flag has been set for this command, don't free
1168 	 * it.  The command will be freed after sending a target reset TM. If
1169 	 * the command did timeout, use EWOULDBLOCK.
1170 	 */
1171 	if ((cm->cm_flags & MPR_CM_FLAGS_SATA_ID_TIMEOUT) == 0)
1172 		mpr_free_command(sc, cm);
1173 	else if (error == 0)
1174 		error = EWOULDBLOCK;
1175 	cm->cm_data = NULL;
1176 	free(buffer, M_MPR);
1177 	return (error);
1178 }
1179 
1180 static void
1181 mprsas_ata_id_timeout(void *data)
1182 {
1183 	struct mpr_softc *sc;
1184 	struct mpr_command *cm;
1185 
1186 	cm = (struct mpr_command *)data;
1187 	sc = cm->cm_sc;
1188 	mtx_assert(&sc->mpr_mtx, MA_OWNED);
1189 
1190 	mpr_dprint(sc, MPR_INFO, "%s checking ATA ID command %p sc %p\n",
1191 	    __func__, cm, sc);
1192 	if ((callout_pending(&cm->cm_callout)) ||
1193 	    (!callout_active(&cm->cm_callout))) {
1194 		mpr_dprint(sc, MPR_INFO, "%s ATA ID command almost timed out\n",
1195 		    __func__);
1196 		return;
1197 	}
1198 	callout_deactivate(&cm->cm_callout);
1199 
1200 	/*
1201 	 * Run the interrupt handler to make sure it's not pending.  This
1202 	 * isn't perfect because the command could have already completed
1203 	 * and been re-used, though this is unlikely.
1204 	 */
1205 	mpr_intr_locked(sc);
1206 	if (cm->cm_state == MPR_CM_STATE_FREE) {
1207 		mpr_dprint(sc, MPR_INFO, "%s ATA ID command almost timed out\n",
1208 		    __func__);
1209 		return;
1210 	}
1211 
1212 	mpr_dprint(sc, MPR_INFO, "ATA ID command timeout cm %p\n", cm);
1213 
1214 	/*
1215 	 * Send wakeup() to the sleeping thread that issued this ATA ID command.
1216 	 * wakeup() will cause msleep to return a 0 (not EWOULDBLOCK), and this
1217 	 * will keep reinit() from being called. This way, an Abort Task TM can
1218 	 * be issued so that the timed out command can be cleared. The Abort
1219 	 * Task cannot be sent from here because the driver has not completed
1220 	 * setting up targets.  Instead, the command is flagged so that special
1221 	 * handling will be used to send the abort.
1222 	 */
1223 	cm->cm_flags |= MPR_CM_FLAGS_SATA_ID_TIMEOUT;
1224 	wakeup(cm);
1225 }
1226 
1227 static int
1228 mprsas_add_pcie_device(struct mpr_softc *sc, u16 handle, u8 linkrate)
1229 {
1230 	char devstring[80];
1231 	struct mprsas_softc *sassc;
1232 	struct mprsas_target *targ;
1233 	Mpi2ConfigReply_t mpi_reply;
1234 	Mpi26PCIeDevicePage0_t config_page;
1235 	Mpi26PCIeDevicePage2_t config_page2;
1236 	uint64_t pcie_wwid, parent_wwid = 0;
1237 	u32 device_info, parent_devinfo = 0;
1238 	unsigned int id;
1239 	int error = 0;
1240 	struct mprsas_lun *lun;
1241 
1242 	sassc = sc->sassc;
1243 	mprsas_startup_increment(sassc);
1244 	if ((mpr_config_get_pcie_device_pg0(sc, &mpi_reply, &config_page,
1245 	     MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle))) {
1246 		printf("%s: error reading PCIe device page0\n", __func__);
1247 		error = ENXIO;
1248 		goto out;
1249 	}
1250 
1251 	device_info = le32toh(config_page.DeviceInfo);
1252 
1253 	if (((device_info & MPI26_PCIE_DEVINFO_PCI_SWITCH) == 0)
1254 	    && (le16toh(config_page.ParentDevHandle) != 0)) {
1255 		Mpi2ConfigReply_t tmp_mpi_reply;
1256 		Mpi26PCIeDevicePage0_t parent_config_page;
1257 
1258 		if ((mpr_config_get_pcie_device_pg0(sc, &tmp_mpi_reply,
1259 		     &parent_config_page, MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE,
1260 		     le16toh(config_page.ParentDevHandle)))) {
1261 			printf("%s: error reading PCIe device %#x page0\n",
1262 			    __func__, le16toh(config_page.ParentDevHandle));
1263 		} else {
1264 			parent_wwid = parent_config_page.WWID.High;
1265 			parent_wwid = (parent_wwid << 32) |
1266 			    parent_config_page.WWID.Low;
1267 			parent_devinfo = le32toh(parent_config_page.DeviceInfo);
1268 		}
1269 	}
1270 	/* TODO Check proper endianness */
1271 	pcie_wwid = config_page.WWID.High;
1272 	pcie_wwid = (pcie_wwid << 32) | config_page.WWID.Low;
1273 	mpr_dprint(sc, MPR_INFO, "PCIe WWID from PCIe device page0 = %jx\n",
1274 	    pcie_wwid);
1275 
1276 	if ((mpr_config_get_pcie_device_pg2(sc, &mpi_reply, &config_page2,
1277 	     MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle))) {
1278 		printf("%s: error reading PCIe device page2\n", __func__);
1279 		error = ENXIO;
1280 		goto out;
1281 	}
1282 
1283 	id = mpr_mapping_get_tid(sc, pcie_wwid, handle);
1284 	if (id == MPR_MAP_BAD_ID) {
1285 		mpr_dprint(sc, MPR_ERROR | MPR_INFO, "failure at %s:%d/%s()! "
1286 		    "Could not get ID for device with handle 0x%04x\n",
1287 		    __FILE__, __LINE__, __func__, handle);
1288 		error = ENXIO;
1289 		goto out;
1290 	}
1291 	mpr_dprint(sc, MPR_MAPPING, "%s: Target ID for added device is %d.\n",
1292 	    __func__, id);
1293 
1294 	if (mprsas_check_id(sassc, id) != 0) {
1295 		mpr_dprint(sc, MPR_MAPPING|MPR_INFO,
1296 		    "Excluding target id %d\n", id);
1297 		error = ENXIO;
1298 		goto out;
1299 	}
1300 
1301 	mpr_dprint(sc, MPR_MAPPING, "WWID from PCIe device page0 = %jx\n",
1302 	    pcie_wwid);
1303 	targ = &sassc->targets[id];
1304 	targ->devinfo = device_info;
1305 	targ->encl_handle = le16toh(config_page.EnclosureHandle);
1306 	targ->encl_slot = le16toh(config_page.Slot);
1307 	targ->encl_level = config_page.EnclosureLevel;
1308 	targ->connector_name[0] = ((char *)&config_page.ConnectorName)[0];
1309 	targ->connector_name[1] = ((char *)&config_page.ConnectorName)[1];
1310 	targ->connector_name[2] = ((char *)&config_page.ConnectorName)[2];
1311 	targ->connector_name[3] = ((char *)&config_page.ConnectorName)[3];
1312 	targ->is_nvme = device_info & MPI26_PCIE_DEVINFO_NVME;
1313 	targ->MDTS = config_page2.MaximumDataTransferSize;
1314 	/*
1315 	 * Assume always TRUE for encl_level_valid because there is no valid
1316 	 * flag for PCIe.
1317 	 */
1318 	targ->encl_level_valid = TRUE;
1319 	targ->handle = handle;
1320 	targ->parent_handle = le16toh(config_page.ParentDevHandle);
1321 	targ->sasaddr = mpr_to_u64(&config_page.WWID);
1322 	targ->parent_sasaddr = le64toh(parent_wwid);
1323 	targ->parent_devinfo = parent_devinfo;
1324 	targ->tid = id;
1325 	targ->linkrate = linkrate;
1326 	targ->flags = 0;
1327 	if ((le16toh(config_page.Flags) &
1328 	    MPI26_PCIEDEV0_FLAGS_ENABLED_FAST_PATH) &&
1329 	    (le16toh(config_page.Flags) &
1330 	    MPI26_PCIEDEV0_FLAGS_FAST_PATH_CAPABLE)) {
1331 		targ->scsi_req_desc_type =
1332 		    MPI25_REQ_DESCRIPT_FLAGS_FAST_PATH_SCSI_IO;
1333 	}
1334 	TAILQ_INIT(&targ->commands);
1335 	TAILQ_INIT(&targ->timedout_commands);
1336 	while (!SLIST_EMPTY(&targ->luns)) {
1337 		lun = SLIST_FIRST(&targ->luns);
1338 		SLIST_REMOVE_HEAD(&targ->luns, lun_link);
1339 		free(lun, M_MPR);
1340 	}
1341 	SLIST_INIT(&targ->luns);
1342 
1343 	mpr_describe_devinfo(targ->devinfo, devstring, 80);
1344 	mpr_dprint(sc, (MPR_INFO|MPR_MAPPING), "Found PCIe device <%s> <%s> "
1345 	    "handle<0x%04x> enclosureHandle<0x%04x> slot %d\n", devstring,
1346 	    mpr_describe_table(mpr_pcie_linkrate_names, targ->linkrate),
1347 	    targ->handle, targ->encl_handle, targ->encl_slot);
1348 	if (targ->encl_level_valid) {
1349 		mpr_dprint(sc, (MPR_INFO|MPR_MAPPING), "At enclosure level %d "
1350 		    "and connector name (%4s)\n", targ->encl_level,
1351 		    targ->connector_name);
1352 	}
1353 #if ((__FreeBSD_version >= 1000000) && (__FreeBSD_version < 1000039)) || \
1354     (__FreeBSD_version < 902502)
1355 	if ((sassc->flags & MPRSAS_IN_STARTUP) == 0)
1356 #endif
1357 		mprsas_rescan_target(sc, targ);
1358 	mpr_dprint(sc, MPR_MAPPING, "Target id 0x%x added\n", targ->tid);
1359 
1360 out:
1361 	mprsas_startup_decrement(sassc);
1362 	return (error);
1363 }
1364 
1365 static int
1366 mprsas_volume_add(struct mpr_softc *sc, u16 handle)
1367 {
1368 	struct mprsas_softc *sassc;
1369 	struct mprsas_target *targ;
1370 	u64 wwid;
1371 	unsigned int id;
1372 	int error = 0;
1373 	struct mprsas_lun *lun;
1374 
1375 	sassc = sc->sassc;
1376 	mprsas_startup_increment(sassc);
1377 	/* wwid is endian safe */
1378 	mpr_config_get_volume_wwid(sc, handle, &wwid);
1379 	if (!wwid) {
1380 		printf("%s: invalid WWID; cannot add volume to mapping table\n",
1381 		    __func__);
1382 		error = ENXIO;
1383 		goto out;
1384 	}
1385 
1386 	id = mpr_mapping_get_raid_tid(sc, wwid, handle);
1387 	if (id == MPR_MAP_BAD_ID) {
1388 		printf("%s: could not get ID for volume with handle 0x%04x and "
1389 		    "WWID 0x%016llx\n", __func__, handle,
1390 		    (unsigned long long)wwid);
1391 		error = ENXIO;
1392 		goto out;
1393 	}
1394 
1395 	targ = &sassc->targets[id];
1396 	targ->tid = id;
1397 	targ->handle = handle;
1398 	targ->devname = wwid;
1399 	TAILQ_INIT(&targ->commands);
1400 	TAILQ_INIT(&targ->timedout_commands);
1401 	while (!SLIST_EMPTY(&targ->luns)) {
1402 		lun = SLIST_FIRST(&targ->luns);
1403 		SLIST_REMOVE_HEAD(&targ->luns, lun_link);
1404 		free(lun, M_MPR);
1405 	}
1406 	SLIST_INIT(&targ->luns);
1407 #if ((__FreeBSD_version >= 1000000) && (__FreeBSD_version < 1000039)) || \
1408     (__FreeBSD_version < 902502)
1409 	if ((sassc->flags & MPRSAS_IN_STARTUP) == 0)
1410 #endif
1411 		mprsas_rescan_target(sc, targ);
1412 	mpr_dprint(sc, MPR_MAPPING, "RAID target id %d added (WWID = 0x%jx)\n",
1413 	    targ->tid, wwid);
1414 out:
1415 	mprsas_startup_decrement(sassc);
1416 	return (error);
1417 }
1418 
1419 /**
1420  * mprsas_SSU_to_SATA_devices
1421  * @sc: per adapter object
1422  *
1423  * Looks through the target list and issues a StartStopUnit SCSI command to each
1424  * SATA direct-access device.  This helps to ensure that data corruption is
1425  * avoided when the system is being shut down.  This must be called after the IR
1426  * System Shutdown RAID Action is sent if in IR mode.
1427  *
1428  * Return nothing.
1429  */
1430 static void
1431 mprsas_SSU_to_SATA_devices(struct mpr_softc *sc)
1432 {
1433 	struct mprsas_softc *sassc = sc->sassc;
1434 	union ccb *ccb;
1435 	path_id_t pathid = cam_sim_path(sassc->sim);
1436 	target_id_t targetid;
1437 	struct mprsas_target *target;
1438 	char path_str[64];
1439 	struct timeval cur_time, start_time;
1440 
1441 	mpr_lock(sc);
1442 
1443 	/*
1444 	 * For each target, issue a StartStopUnit command to stop the device.
1445 	 */
1446 	sc->SSU_started = TRUE;
1447 	sc->SSU_refcount = 0;
1448 	for (targetid = 0; targetid < sc->max_devices; targetid++) {
1449 		target = &sassc->targets[targetid];
1450 		if (target->handle == 0x0) {
1451 			continue;
1452 		}
1453 
1454 		/*
1455 		 * The stop_at_shutdown flag will be set if this device is
1456 		 * a SATA direct-access end device.
1457 		 */
1458 		if (target->stop_at_shutdown) {
1459 			ccb = xpt_alloc_ccb_nowait();
1460 			if (ccb == NULL) {
1461 				mpr_dprint(sc, MPR_FAULT, "Unable to alloc CCB "
1462 				    "to stop unit.\n");
1463 				return;
1464 			}
1465 
1466 			if (xpt_create_path(&ccb->ccb_h.path, xpt_periph,
1467 			    pathid, targetid, CAM_LUN_WILDCARD) !=
1468 			    CAM_REQ_CMP) {
1469 				mpr_dprint(sc, MPR_ERROR, "Unable to create "
1470 				    "path to stop unit.\n");
1471 				xpt_free_ccb(ccb);
1472 				return;
1473 			}
1474 			xpt_path_string(ccb->ccb_h.path, path_str,
1475 			    sizeof(path_str));
1476 
1477 			mpr_dprint(sc, MPR_INFO, "Sending StopUnit: path %s "
1478 			    "handle %d\n", path_str, target->handle);
1479 
1480 			/*
1481 			 * Issue a START STOP UNIT command for the target.
1482 			 * Increment the SSU counter to be used to count the
1483 			 * number of required replies.
1484 			 */
1485 			mpr_dprint(sc, MPR_INFO, "Incrementing SSU count\n");
1486 			sc->SSU_refcount++;
1487 			ccb->ccb_h.target_id =
1488 			    xpt_path_target_id(ccb->ccb_h.path);
1489 			ccb->ccb_h.ppriv_ptr1 = sassc;
1490 			scsi_start_stop(&ccb->csio,
1491 			    /*retries*/0,
1492 			    mprsas_stop_unit_done,
1493 			    MSG_SIMPLE_Q_TAG,
1494 			    /*start*/FALSE,
1495 			    /*load/eject*/0,
1496 			    /*immediate*/FALSE,
1497 			    MPR_SENSE_LEN,
1498 			    /*timeout*/10000);
1499 			xpt_action(ccb);
1500 		}
1501 	}
1502 
1503 	mpr_unlock(sc);
1504 
1505 	/*
1506 	 * Wait until all of the SSU commands have completed or time has
1507 	 * expired (60 seconds).  Pause for 100ms each time through.  If any
1508 	 * command times out, the target will be reset in the SCSI command
1509 	 * timeout routine.
1510 	 */
1511 	getmicrotime(&start_time);
1512 	while (sc->SSU_refcount) {
1513 		pause("mprwait", hz/10);
1514 
1515 		getmicrotime(&cur_time);
1516 		if ((cur_time.tv_sec - start_time.tv_sec) > 60) {
1517 			mpr_dprint(sc, MPR_ERROR, "Time has expired waiting "
1518 			    "for SSU commands to complete.\n");
1519 			break;
1520 		}
1521 	}
1522 }
1523 
1524 static void
1525 mprsas_stop_unit_done(struct cam_periph *periph, union ccb *done_ccb)
1526 {
1527 	struct mprsas_softc *sassc;
1528 	char path_str[64];
1529 
1530 	if (done_ccb == NULL)
1531 		return;
1532 
1533 	sassc = (struct mprsas_softc *)done_ccb->ccb_h.ppriv_ptr1;
1534 
1535 	xpt_path_string(done_ccb->ccb_h.path, path_str, sizeof(path_str));
1536 	mpr_dprint(sassc->sc, MPR_INFO, "Completing stop unit for %s\n",
1537 	    path_str);
1538 
1539 	/*
1540 	 * Nothing more to do except free the CCB and path.  If the command
1541 	 * timed out, an abort reset, then target reset will be issued during
1542 	 * the SCSI Command process.
1543 	 */
1544 	xpt_free_path(done_ccb->ccb_h.path);
1545 	xpt_free_ccb(done_ccb);
1546 }
1547 
1548 /**
1549  * mprsas_ir_shutdown - IR shutdown notification
1550  * @sc: per adapter object
1551  *
1552  * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
1553  * the host system is shutting down.
1554  *
1555  * Return nothing.
1556  */
1557 void
1558 mprsas_ir_shutdown(struct mpr_softc *sc)
1559 {
1560 	u16 volume_mapping_flags;
1561 	u16 ioc_pg8_flags = le16toh(sc->ioc_pg8.Flags);
1562 	struct dev_mapping_table *mt_entry;
1563 	u32 start_idx, end_idx;
1564 	unsigned int id, found_volume = 0;
1565 	struct mpr_command *cm;
1566 	Mpi2RaidActionRequest_t	*action;
1567 	target_id_t targetid;
1568 	struct mprsas_target *target;
1569 
1570 	mpr_dprint(sc, MPR_TRACE, "%s\n", __func__);
1571 
1572 	/* is IR firmware build loaded? */
1573 	if (!sc->ir_firmware)
1574 		goto out;
1575 
1576 	/* are there any volumes?  Look at IR target IDs. */
1577 	// TODO-later, this should be looked up in the RAID config structure
1578 	// when it is implemented.
1579 	volume_mapping_flags = le16toh(sc->ioc_pg8.IRVolumeMappingFlags) &
1580 	    MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
1581 	if (volume_mapping_flags == MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) {
1582 		start_idx = 0;
1583 		if (ioc_pg8_flags & MPI2_IOCPAGE8_FLAGS_RESERVED_TARGETID_0)
1584 			start_idx = 1;
1585 	} else
1586 		start_idx = sc->max_devices - sc->max_volumes;
1587 	end_idx = start_idx + sc->max_volumes - 1;
1588 
1589 	for (id = start_idx; id < end_idx; id++) {
1590 		mt_entry = &sc->mapping_table[id];
1591 		if ((mt_entry->physical_id != 0) &&
1592 		    (mt_entry->missing_count == 0)) {
1593 			found_volume = 1;
1594 			break;
1595 		}
1596 	}
1597 
1598 	if (!found_volume)
1599 		goto out;
1600 
1601 	if ((cm = mpr_alloc_command(sc)) == NULL) {
1602 		printf("%s: command alloc failed\n", __func__);
1603 		goto out;
1604 	}
1605 
1606 	action = (MPI2_RAID_ACTION_REQUEST *)cm->cm_req;
1607 	action->Function = MPI2_FUNCTION_RAID_ACTION;
1608 	action->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
1609 	cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
1610 	mpr_lock(sc);
1611 	mpr_wait_command(sc, &cm, 5, CAN_SLEEP);
1612 	mpr_unlock(sc);
1613 
1614 	/*
1615 	 * Don't check for reply, just leave.
1616 	 */
1617 	if (cm)
1618 		mpr_free_command(sc, cm);
1619 
1620 out:
1621 	/*
1622 	 * All of the targets must have the correct value set for
1623 	 * 'stop_at_shutdown' for the current 'enable_ssu' sysctl variable.
1624 	 *
1625 	 * The possible values for the 'enable_ssu' variable are:
1626 	 * 0: disable to SSD and HDD
1627 	 * 1: disable only to HDD (default)
1628 	 * 2: disable only to SSD
1629 	 * 3: enable to SSD and HDD
1630 	 * anything else will default to 1.
1631 	 */
1632 	for (targetid = 0; targetid < sc->max_devices; targetid++) {
1633 		target = &sc->sassc->targets[targetid];
1634 		if (target->handle == 0x0) {
1635 			continue;
1636 		}
1637 
1638 		if (target->supports_SSU) {
1639 			switch (sc->enable_ssu) {
1640 			case MPR_SSU_DISABLE_SSD_DISABLE_HDD:
1641 				target->stop_at_shutdown = FALSE;
1642 				break;
1643 			case MPR_SSU_DISABLE_SSD_ENABLE_HDD:
1644 				target->stop_at_shutdown = TRUE;
1645 				if (target->flags & MPR_TARGET_IS_SATA_SSD) {
1646 					target->stop_at_shutdown = FALSE;
1647 				}
1648 				break;
1649 			case MPR_SSU_ENABLE_SSD_ENABLE_HDD:
1650 				target->stop_at_shutdown = TRUE;
1651 				break;
1652 			case MPR_SSU_ENABLE_SSD_DISABLE_HDD:
1653 			default:
1654 				target->stop_at_shutdown = TRUE;
1655 				if ((target->flags &
1656 				    MPR_TARGET_IS_SATA_SSD) == 0) {
1657 					target->stop_at_shutdown = FALSE;
1658 				}
1659 				break;
1660 			}
1661 		}
1662 	}
1663 	mprsas_SSU_to_SATA_devices(sc);
1664 }
1665