2 * Copyright (c) 2011 LSI Corp.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * LSI MPT-Fusion Host Adapter FreeBSD
28 * $FreeBSD: src/sys/dev/mps/mps_sas_lsi.c,v 1.1 2012/01/26 18:17:21 ken Exp $
31 /* Communications core for LSI MPT2 */
33 /* TODO Move headers to mpsvar */
34 #include <sys/types.h>
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
38 #include <sys/module.h>
41 #include <sys/eventhandler.h>
43 #include <sys/malloc.h>
45 #include <sys/sysctl.h>
46 #include <sys/endian.h>
47 #include <sys/queue.h>
48 #include <sys/kthread.h>
49 #include <sys/taskqueue.h>
54 #include <machine/stdarg.h>
56 #include <bus/cam/cam.h>
57 #include <bus/cam/cam_ccb.h>
58 #include <bus/cam/cam_debug.h>
59 #include <bus/cam/cam_sim.h>
60 #include <bus/cam/cam_xpt_sim.h>
61 #include <bus/cam/cam_xpt_periph.h>
62 #include <bus/cam/cam_periph.h>
63 #include <bus/cam/scsi/scsi_all.h>
64 #include <bus/cam/scsi/scsi_message.h>
66 #include <dev/raid/mps/mpi/mpi2_type.h>
67 #include <dev/raid/mps/mpi/mpi2.h>
68 #include <dev/raid/mps/mpi/mpi2_ioc.h>
69 #include <dev/raid/mps/mpi/mpi2_sas.h>
70 #include <dev/raid/mps/mpi/mpi2_cnfg.h>
71 #include <dev/raid/mps/mpi/mpi2_init.h>
72 #include <dev/raid/mps/mpi/mpi2_raid.h>
73 #include <dev/raid/mps/mpi/mpi2_tool.h>
74 #include <dev/raid/mps/mps_ioctl.h>
75 #include <dev/raid/mps/mpsvar.h>
76 #include <dev/raid/mps/mps_table.h>
77 #include <dev/raid/mps/mps_sas.h>
79 /* For Hashed SAS Address creation for SATA Drives */
80 #define MPT2SAS_SN_LEN 20
81 #define MPT2SAS_MN_LEN 40
83 struct mps_fw_event_work {
86 TAILQ_ENTRY(mps_fw_event_work) ev_link;
89 union _sata_sas_address {
98 * define the IDENTIFY DEVICE structure
100 struct _ata_identify_device_data {
101 u16 reserved1[10]; /* 0-9 */
102 u16 serial_number[10]; /* 10-19 */
103 u16 reserved2[7]; /* 20-26 */
104 u16 model_number[20]; /* 27-46*/
105 u16 reserved3[209]; /* 47-255*/
108 static void mpssas_fw_work(struct mps_softc *sc,
109 struct mps_fw_event_work *fw_event);
110 static void mpssas_fw_event_free(struct mps_softc *,
111 struct mps_fw_event_work *);
112 static int mpssas_add_device(struct mps_softc *sc, u16 handle, u8 linkrate);
113 static int mpssas_get_sata_identify(struct mps_softc *sc, u16 handle,
114 Mpi2SataPassthroughReply_t *mpi_reply, char *id_buffer, int sz,
116 int mpssas_get_sas_address_for_sata_disk(struct mps_softc *sc,
117 u64 *sas_address, u16 handle, u32 device_info);
118 static int mpssas_volume_add(struct mps_softc *sc,
119 Mpi2EventIrConfigElement_t *element);
122 mpssas_evt_handler(struct mps_softc *sc, uintptr_t data,
123 MPI2_EVENT_NOTIFICATION_REPLY *event)
125 struct mps_fw_event_work *fw_event;
128 mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
129 mps_print_evt_sas(sc, event);
130 mpssas_record_event(sc, event);
132 fw_event = kmalloc(sizeof(struct mps_fw_event_work), M_MPT2,
135 kprintf("%s: allocate failed for fw_event\n", __func__);
138 sz = le16toh(event->EventDataLength) * 4;
139 fw_event->event_data = kmalloc(sz, M_MPT2, M_ZERO|M_NOWAIT);
140 if (!fw_event->event_data) {
141 kprintf("%s: allocate failed for event_data\n", __func__);
142 kfree(fw_event, M_MPT2);
146 bcopy(event->EventData, fw_event->event_data, sz);
147 fw_event->event = event->Event;
148 if ((event->Event == MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
149 event->Event == MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE ||
150 event->Event == MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST) &&
151 sc->track_mapping_events)
152 sc->pending_map_events++;
155 * When wait_for_port_enable flag is set, make sure that all the events
156 * are processed. Increment the startup_refcount and decrement it after
157 * events are processed.
159 if ((event->Event == MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
160 event->Event == MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST) &&
161 sc->wait_for_port_enable)
162 mpssas_startup_increment(sc->sassc);
164 TAILQ_INSERT_TAIL(&sc->sassc->ev_queue, fw_event, ev_link);
165 taskqueue_enqueue(sc->sassc->ev_tq, &sc->sassc->ev_task);
170 mpssas_fw_event_free(struct mps_softc *sc, struct mps_fw_event_work *fw_event)
173 kfree(fw_event->event_data, M_MPT2);
174 kfree(fw_event, M_MPT2);
178 * _mps_fw_work - delayed task for processing firmware events
179 * @sc: per adapter object
180 * @fw_event: The fw_event_work object
186 mpssas_fw_work(struct mps_softc *sc, struct mps_fw_event_work *fw_event)
188 struct mpssas_softc *sassc;
191 switch (fw_event->event) {
192 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
194 MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *data;
195 MPI2_EVENT_SAS_TOPO_PHY_ENTRY *phy;
198 data = (MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *)
199 fw_event->event_data;
201 mps_mapping_topology_change_event(sc, fw_event->event_data);
203 for (i = 0; i < data->NumEntries; i++) {
205 switch (phy->PhyStatus & MPI2_EVENT_SAS_TOPO_RC_MASK) {
206 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
207 if (mpssas_add_device(sc,
208 phy->AttachedDevHandle, phy->LinkRate)){
209 kprintf("%s: failed to add device with "
210 "handle 0x%x\n", __func__,
211 phy->AttachedDevHandle);
212 mpssas_prepare_remove(sassc, phy->
216 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
217 mpssas_prepare_remove(sassc, phy->
220 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
221 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
222 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
228 * refcount was incremented for this event in
229 * mpssas_evt_handler. Decrement it here because the event has
232 mpssas_startup_decrement(sassc);
235 case MPI2_EVENT_SAS_DISCOVERY:
237 MPI2_EVENT_DATA_SAS_DISCOVERY *data;
239 data = (MPI2_EVENT_DATA_SAS_DISCOVERY *)fw_event->event_data;
241 if (data->ReasonCode & MPI2_EVENT_SAS_DISC_RC_STARTED)
242 mps_dprint(sc, MPS_TRACE,"SAS discovery start event\n");
243 if (data->ReasonCode & MPI2_EVENT_SAS_DISC_RC_COMPLETED) {
244 mps_dprint(sc, MPS_TRACE,"SAS discovery stop event\n");
245 sassc->flags &= ~MPSSAS_IN_DISCOVERY;
246 mpssas_discovery_end(sassc);
250 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
252 Mpi2EventDataSasEnclDevStatusChange_t *data;
253 data = (Mpi2EventDataSasEnclDevStatusChange_t *)
254 fw_event->event_data;
255 mps_mapping_enclosure_dev_status_change_event(sc,
256 fw_event->event_data);
259 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
261 Mpi2EventIrConfigElement_t *element;
264 Mpi2EventDataIrConfigChangeList_t *event_data;
265 struct mpssas_target *targ;
268 event_data = fw_event->event_data;
269 foreign_config = (le32toh(event_data->Flags) &
270 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
273 (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
274 id = mps_mapping_get_raid_id_from_handle
275 (sc, element->VolDevHandle);
277 mps_mapping_ir_config_change_event(sc, event_data);
279 for (i = 0; i < event_data->NumElements; i++, element++) {
280 switch (element->ReasonCode) {
281 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
282 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
283 if (!foreign_config) {
284 if (mpssas_volume_add(sc, element)) {
285 kprintf("%s: failed to add RAID "
286 "volume with handle 0x%x\n",
287 __func__, le16toh(element->
292 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
293 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
295 * Rescan after volume is deleted or removed.
297 if (!foreign_config) {
298 if (id == MPS_MAP_BAD_ID) {
299 kprintf("%s: could not get ID "
300 "for volume with handle "
301 "0x%04x\n", __func__,
302 element->VolDevHandle);
306 targ = &sassc->targets[id];
308 targ->encl_slot = 0x0;
309 targ->encl_handle = 0x0;
310 targ->exp_dev_handle = 0x0;
312 targ->linkrate = 0x0;
313 mpssas_rescan_target(sc, targ);
314 kprintf("RAID target id 0x%x removed\n",
318 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
320 * Phys Disk of a volume has been created. Hide
323 mpssas_prepare_remove(sassc, element->
326 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
328 * Phys Disk of a volume has been deleted.
329 * Expose it to the OS.
331 if (mpssas_add_device(sc,
332 element->PhysDiskDevHandle, 0)){
333 kprintf("%s: failed to add device with "
334 "handle 0x%x\n", __func__,
335 element->PhysDiskDevHandle);
336 mpssas_prepare_remove(sassc, element->
343 * refcount was incremented for this event in
344 * mpssas_evt_handler. Decrement it here because the event has
347 mpssas_startup_decrement(sassc);
350 case MPI2_EVENT_IR_VOLUME:
352 Mpi2EventDataIrVolume_t *event_data = fw_event->event_data;
355 * Informational only.
357 mps_dprint(sc, MPS_INFO, "Received IR Volume event:\n");
358 switch (event_data->ReasonCode) {
359 case MPI2_EVENT_IR_VOLUME_RC_SETTINGS_CHANGED:
360 mps_dprint(sc, MPS_INFO, " Volume Settings "
361 "changed from 0x%x to 0x%x for Volome with "
362 "handle 0x%x", event_data->PreviousValue,
363 event_data->NewValue,
364 event_data->VolDevHandle);
366 case MPI2_EVENT_IR_VOLUME_RC_STATUS_FLAGS_CHANGED:
367 mps_dprint(sc, MPS_INFO, " Volume Status "
368 "changed from 0x%x to 0x%x for Volome with "
369 "handle 0x%x", event_data->PreviousValue,
370 event_data->NewValue,
371 event_data->VolDevHandle);
373 case MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED:
374 mps_dprint(sc, MPS_INFO, " Volume State "
375 "changed from 0x%x to 0x%x for Volome with "
376 "handle 0x%x", event_data->PreviousValue,
377 event_data->NewValue,
378 event_data->VolDevHandle);
385 case MPI2_EVENT_IR_PHYSICAL_DISK:
387 Mpi2EventDataIrPhysicalDisk_t *event_data =
388 fw_event->event_data;
391 * Informational only.
393 mps_dprint(sc, MPS_INFO, "Received IR Phys Disk event:\n");
394 switch (event_data->ReasonCode) {
395 case MPI2_EVENT_IR_PHYSDISK_RC_SETTINGS_CHANGED:
396 mps_dprint(sc, MPS_INFO, " Phys Disk Settings "
397 "changed from 0x%x to 0x%x for Phys Disk Number "
398 "%d and handle 0x%x at Enclosure handle 0x%x, Slot "
399 "%d", event_data->PreviousValue,
400 event_data->NewValue, event_data->PhysDiskNum,
401 event_data->PhysDiskDevHandle,
402 event_data->EnclosureHandle, event_data->Slot);
404 case MPI2_EVENT_IR_PHYSDISK_RC_STATUS_FLAGS_CHANGED:
405 mps_dprint(sc, MPS_INFO, " Phys Disk Status changed "
406 "from 0x%x to 0x%x for Phys Disk Number %d and "
407 "handle 0x%x at Enclosure handle 0x%x, Slot %d",
408 event_data->PreviousValue, event_data->NewValue,
409 event_data->PhysDiskNum,
410 event_data->PhysDiskDevHandle,
411 event_data->EnclosureHandle, event_data->Slot);
413 case MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED:
414 mps_dprint(sc, MPS_INFO, " Phys Disk State changed "
415 "from 0x%x to 0x%x for Phys Disk Number %d and "
416 "handle 0x%x at Enclosure handle 0x%x, Slot %d",
417 event_data->PreviousValue, event_data->NewValue,
418 event_data->PhysDiskNum,
419 event_data->PhysDiskDevHandle,
420 event_data->EnclosureHandle, event_data->Slot);
427 case MPI2_EVENT_IR_OPERATION_STATUS:
429 Mpi2EventDataIrOperationStatus_t *event_data =
430 fw_event->event_data;
433 * Informational only.
435 mps_dprint(sc, MPS_INFO, "Received IR Op Status event:\n");
436 mps_dprint(sc, MPS_INFO, " RAID Operation of %d is %d "
437 "percent complete for Volume with handle 0x%x",
438 event_data->RAIDOperation, event_data->PercentComplete,
439 event_data->VolDevHandle);
442 case MPI2_EVENT_LOG_ENTRY_ADDED:
444 pMpi2EventDataLogEntryAdded_t logEntry;
445 uint16_t logQualifier;
448 logEntry = (pMpi2EventDataLogEntryAdded_t)fw_event->event_data;
449 logQualifier = logEntry->LogEntryQualifier;
451 if (logQualifier == MPI2_WD_LOG_ENTRY) {
452 logCode = logEntry->LogData[0];
455 case MPI2_WD_SSD_THROTTLING:
456 kprintf("WarpDrive Warning: IO Throttling has "
457 "occurred in the WarpDrive subsystem. "
458 "Check WarpDrive documentation for "
459 "additional details\n");
461 case MPI2_WD_DRIVE_LIFE_WARN:
462 kprintf("WarpDrive Warning: Program/Erase "
463 "Cycles for the WarpDrive subsystem in "
464 "degraded range. Check WarpDrive "
465 "documentation for additional details\n");
467 case MPI2_WD_DRIVE_LIFE_DEAD:
468 kprintf("WarpDrive Fatal Error: There are no "
469 "Program/Erase Cycles for the WarpDrive "
470 "subsystem. The storage device will be in "
471 "read-only mode. Check WarpDrive "
472 "documentation for additional details\n");
474 case MPI2_WD_RAIL_MON_FAIL:
475 kprintf("WarpDrive Fatal Error: The Backup Rail "
476 "Monitor has failed on the WarpDrive "
477 "subsystem. Check WarpDrive documentation "
478 "for additional details\n");
486 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
487 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
489 mps_dprint(sc, MPS_TRACE,"Unhandled event 0x%0X\n",
494 mpssas_fw_event_free(sc, fw_event);
498 mpssas_firmware_event_work(void *arg, int pending)
500 struct mps_fw_event_work *fw_event;
501 struct mps_softc *sc;
503 sc = (struct mps_softc *)arg;
505 while ((fw_event = TAILQ_FIRST(&sc->sassc->ev_queue)) != NULL) {
506 TAILQ_REMOVE(&sc->sassc->ev_queue, fw_event, ev_link);
507 mpssas_fw_work(sc, fw_event);
513 mpssas_add_device(struct mps_softc *sc, u16 handle, u8 linkrate){
515 struct mpssas_softc *sassc;
516 struct mpssas_target *targ;
517 Mpi2ConfigReply_t mpi_reply;
518 Mpi2SasDevicePage0_t config_page;
519 uint64_t sas_address, sata_sas_address;
520 uint64_t parent_sas_address = 0;
521 u16 ioc_pg8_flags = le16toh(sc->ioc_pg8.Flags);
522 u32 device_info, parent_devinfo = 0;
528 mpssas_startup_increment(sassc);
529 if ((mps_config_get_sas_device_pg0(sc, &mpi_reply, &config_page,
530 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
531 kprintf("%s: error reading SAS device page0\n", __func__);
536 device_info = le32toh(config_page.DeviceInfo);
538 if (((device_info & MPI2_SAS_DEVICE_INFO_SMP_TARGET) == 0)
539 && (config_page.ParentDevHandle != 0)) {
540 Mpi2ConfigReply_t tmp_mpi_reply;
541 Mpi2SasDevicePage0_t parent_config_page;
543 if ((mps_config_get_sas_device_pg0(sc, &tmp_mpi_reply,
544 &parent_config_page, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
545 le16toh(config_page.ParentDevHandle)))) {
546 kprintf("%s: error reading SAS device %#x page0\n",
547 __func__, le16toh(config_page.ParentDevHandle));
549 parent_sas_address = parent_config_page.SASAddress.High;
550 parent_sas_address = (parent_sas_address << 32) |
551 parent_config_page.SASAddress.Low;
552 parent_devinfo = le32toh(parent_config_page.DeviceInfo);
555 /* TODO Check proper endianess */
556 sas_address = config_page.SASAddress.High;
557 sas_address = (sas_address << 32) |
558 config_page.SASAddress.Low;
560 if ((ioc_pg8_flags & MPI2_IOCPAGE8_FLAGS_MASK_MAPPING_MODE)
561 == MPI2_IOCPAGE8_FLAGS_DEVICE_PERSISTENCE_MAPPING) {
562 if (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE) {
563 ret = mpssas_get_sas_address_for_sata_disk(sc,
564 &sata_sas_address, handle, device_info);
566 id = mps_mapping_get_sas_id(sc,
567 sata_sas_address, handle);
569 id = mps_mapping_get_sas_id(sc,
570 sas_address, handle);
572 id = mps_mapping_get_sas_id(sc, sas_address,
575 id = mps_mapping_get_sas_id(sc, sas_address, handle);
577 if (id == MPS_MAP_BAD_ID) {
578 kprintf("failure at %s:%d/%s()! Could not get ID for device "
579 "with handle 0x%04x\n", __FILE__, __LINE__, __func__,
584 mps_vprintf(sc, "SAS Address from SAS device page0 = %jx\n",
586 targ = &sassc->targets[id];
587 targ->devinfo = device_info;
588 targ->devname = le32toh(config_page.DeviceName.High);
589 targ->devname = (targ->devname << 32) |
590 le32toh(config_page.DeviceName.Low);
591 targ->encl_handle = le16toh(config_page.EnclosureHandle);
592 targ->encl_slot = le16toh(config_page.Slot);
593 targ->handle = handle;
594 targ->parent_handle = le16toh(config_page.ParentDevHandle);
595 targ->sasaddr = mps_to_u64(&config_page.SASAddress);
596 targ->parent_sasaddr = le64toh(parent_sas_address);
597 targ->parent_devinfo = parent_devinfo;
599 targ->linkrate = (linkrate>>4);
601 TAILQ_INIT(&targ->commands);
602 TAILQ_INIT(&targ->timedout_commands);
603 SLIST_INIT(&targ->luns);
604 mps_describe_devinfo(targ->devinfo, devstring, 80);
605 mps_vprintf(sc, "Found device <%s> <%s> <0x%04x> <%d/%d>\n", devstring,
606 mps_describe_table(mps_linkrate_names, targ->linkrate),
607 targ->handle, targ->encl_handle, targ->encl_slot);
608 if ((sassc->flags & MPSSAS_IN_STARTUP) == 0)
609 mpssas_rescan_target(sc, targ);
610 mps_vprintf(sc, "Target id 0x%x added\n", targ->tid);
612 mpssas_startup_decrement(sassc);
618 mpssas_get_sas_address_for_sata_disk(struct mps_softc *sc,
619 u64 *sas_address, u16 handle, u32 device_info)
621 Mpi2SataPassthroughReply_t mpi_reply;
622 int i, rc, try_count;
624 union _sata_sas_address hash_address;
625 struct _ata_identify_device_data ata_identify;
626 u8 buffer[MPT2SAS_MN_LEN + MPT2SAS_SN_LEN];
630 memset(&ata_identify, 0, sizeof(ata_identify));
633 rc = mpssas_get_sata_identify(sc, handle, &mpi_reply,
634 (char *)&ata_identify, sizeof(ata_identify), device_info);
636 ioc_status = le16toh(mpi_reply.IOCStatus)
637 & MPI2_IOCSTATUS_MASK;
638 sas_status = mpi_reply.SASStatus;
639 } while ((rc == -EAGAIN || ioc_status || sas_status) &&
642 if (rc == 0 && !ioc_status && !sas_status) {
643 mps_dprint(sc, MPS_INFO, "%s: got SATA identify successfully "
644 "for handle = 0x%x with try_count = %d\n",
645 __func__, handle, try_count);
647 mps_dprint(sc, MPS_INFO, "%s: handle = 0x%x failed\n",
651 /* Copy & byteswap the 40 byte model number to a buffer */
652 for (i = 0; i < MPT2SAS_MN_LEN; i += 2) {
653 buffer[i] = ((u8 *)ata_identify.model_number)[i + 1];
654 buffer[i + 1] = ((u8 *)ata_identify.model_number)[i];
656 /* Copy & byteswap the 20 byte serial number to a buffer */
657 for (i = 0; i < MPT2SAS_SN_LEN; i += 2) {
658 buffer[MPT2SAS_MN_LEN + i] =
659 ((u8 *)ata_identify.serial_number)[i + 1];
660 buffer[MPT2SAS_MN_LEN + i + 1] =
661 ((u8 *)ata_identify.serial_number)[i];
663 bufferptr = (u32 *)buffer;
664 /* There are 60 bytes to hash down to 8. 60 isn't divisible by 8,
665 * so loop through the first 56 bytes (7*8),
666 * and then add in the last dword.
668 hash_address.word.low = 0;
669 hash_address.word.high = 0;
670 for (i = 0; (i < ((MPT2SAS_MN_LEN+MPT2SAS_SN_LEN)/8)); i++) {
671 hash_address.word.low += *bufferptr;
673 hash_address.word.high += *bufferptr;
676 /* Add the last dword */
677 hash_address.word.low += *bufferptr;
678 /* Make sure the hash doesn't start with 5, because it could clash
679 * with a SAS address. Change 5 to a D.
681 if ((hash_address.word.high & 0x000000F0) == (0x00000050))
682 hash_address.word.high |= 0x00000080;
683 *sas_address = (u64)hash_address.wwid[0] << 56 |
684 (u64)hash_address.wwid[1] << 48 | (u64)hash_address.wwid[2] << 40 |
685 (u64)hash_address.wwid[3] << 32 | (u64)hash_address.wwid[4] << 24 |
686 (u64)hash_address.wwid[5] << 16 | (u64)hash_address.wwid[6] << 8 |
687 (u64)hash_address.wwid[7];
692 mpssas_get_sata_identify(struct mps_softc *sc, u16 handle,
693 Mpi2SataPassthroughReply_t *mpi_reply, char *id_buffer, int sz, u32 devinfo)
695 Mpi2SataPassthroughRequest_t *mpi_request;
696 Mpi2SataPassthroughReply_t *reply;
697 struct mps_command *cm;
701 buffer = kmalloc( sz, M_MPT2, M_NOWAIT | M_ZERO);
705 if ((cm = mps_alloc_command(sc)) == NULL) {
706 kfree(buffer, M_MPT2);
709 mpi_request = (MPI2_SATA_PASSTHROUGH_REQUEST *)cm->cm_req;
710 bzero(mpi_request,sizeof(MPI2_SATA_PASSTHROUGH_REQUEST));
711 mpi_request->Function = MPI2_FUNCTION_SATA_PASSTHROUGH;
712 mpi_request->VF_ID = 0;
713 mpi_request->DevHandle = htole16(handle);
714 mpi_request->PassthroughFlags = (MPI2_SATA_PT_REQ_PT_FLAGS_PIO |
715 MPI2_SATA_PT_REQ_PT_FLAGS_READ);
716 mpi_request->DataLength = htole32(sz);
717 mpi_request->CommandFIS[0] = 0x27;
718 mpi_request->CommandFIS[1] = 0x80;
719 mpi_request->CommandFIS[2] = (devinfo &
720 MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? 0xA1 : 0xEC;
721 cm->cm_sge = &mpi_request->SGL;
722 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
723 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
724 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
725 cm->cm_data = buffer;
726 cm->cm_length = htole32(sz);
727 error = mps_request_polled(sc, cm);
728 reply = (Mpi2SataPassthroughReply_t *)cm->cm_reply;
729 if (error || (reply == NULL)) {
731 /* If the poll returns error then we need to do diag reset */
732 kprintf("%s: poll for page completed with error %d",
737 bcopy(buffer, id_buffer, sz);
738 bcopy(reply, mpi_reply, sizeof(Mpi2SataPassthroughReply_t));
739 if ((reply->IOCStatus & MPI2_IOCSTATUS_MASK) !=
740 MPI2_IOCSTATUS_SUCCESS) {
741 kprintf("%s: error reading SATA PASSTHRU; iocstatus = 0x%x\n",
742 __func__, reply->IOCStatus);
747 mps_free_command(sc, cm);
748 kfree(buffer, M_MPT2);
753 mpssas_volume_add(struct mps_softc *sc, Mpi2EventIrConfigElement_t *element)
755 struct mpssas_softc *sassc;
756 struct mpssas_target *targ;
758 u16 handle = le16toh(element->VolDevHandle);
763 mpssas_startup_increment(sassc);
764 mps_config_get_volume_wwid(sc, handle, &wwid);
766 kprintf("%s: invalid WWID; cannot add volume to mapping table\n",
772 id = mps_mapping_get_raid_id(sc, wwid, handle);
773 if (id == MPS_MAP_BAD_ID) {
774 kprintf("%s: could not get ID for volume with handle 0x%04x and "
775 "WWID 0x%016llx\n", __func__, handle,
776 (unsigned long long)wwid);
781 targ = &sassc->targets[id];
783 targ->handle = handle;
784 targ->devname = wwid;
785 TAILQ_INIT(&targ->commands);
786 TAILQ_INIT(&targ->timedout_commands);
787 SLIST_INIT(&targ->luns);
788 if ((sassc->flags & MPSSAS_IN_STARTUP) == 0)
789 mpssas_rescan_target(sc, targ);
790 mps_dprint(sc, MPS_INFO, "RAID target id %d added (WWID = 0x%jx)\n",
793 mpssas_startup_decrement(sassc);
798 * mpssas_ir_shutdown - IR shutdown notification
799 * @sc: per adapter object
801 * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
802 * the host system is shutting down.
807 mpssas_ir_shutdown(struct mps_softc *sc)
809 u16 volume_mapping_flags;
810 u16 ioc_pg8_flags = le16toh(sc->ioc_pg8.Flags);
811 struct dev_mapping_table *mt_entry;
812 u32 start_idx, end_idx;
813 unsigned int id, found_volume = 0;
814 struct mps_command *cm;
815 Mpi2RaidActionRequest_t *action;
819 mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
821 /* is IR firmware build loaded? */
822 if (!sc->ir_firmware)
825 /* are there any volumes? Look at IR target IDs. */
826 // TODO-later, this should be looked up in the RAID config structure
827 // when it is implemented.
828 volume_mapping_flags = le16toh(sc->ioc_pg8.IRVolumeMappingFlags) &
829 MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
830 if (volume_mapping_flags == MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) {
832 if (ioc_pg8_flags & MPI2_IOCPAGE8_FLAGS_RESERVED_TARGETID_0)
835 start_idx = sc->max_devices - sc->max_volumes;
836 end_idx = start_idx + sc->max_volumes - 1;
838 for (id = start_idx; id < end_idx; id++) {
839 mt_entry = &sc->mapping_table[id];
840 if ((mt_entry->physical_id != 0) &&
841 (mt_entry->missing_count == 0)) {
850 if ((cm = mps_alloc_command(sc)) == NULL) {
851 kprintf("%s: command alloc failed\n", __func__);
855 action = (MPI2_RAID_ACTION_REQUEST *)cm->cm_req;
856 action->Function = MPI2_FUNCTION_RAID_ACTION;
857 action->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
858 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
859 mps_request_polled(sc, cm);
862 * Don't check for reply, just leave.
865 mps_free_command(sc, cm);