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, data);
258 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
260 Mpi2EventIrConfigElement_t *element;
263 Mpi2EventDataIrConfigChangeList_t *event_data;
264 struct mpssas_target *targ;
267 event_data = fw_event->event_data;
268 foreign_config = (le32toh(event_data->Flags) &
269 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
272 (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
273 id = mps_mapping_get_raid_id_from_handle
274 (sc, element->VolDevHandle);
276 mps_mapping_ir_config_change_event(sc, event_data);
278 for (i = 0; i < event_data->NumElements; i++, element++) {
279 switch (element->ReasonCode) {
280 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
281 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
282 if (!foreign_config) {
283 if (mpssas_volume_add(sc, element)) {
284 kprintf("%s: failed to add RAID "
285 "volume with handle 0x%x\n",
286 __func__, le16toh(element->
291 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
292 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
294 * Rescan after volume is deleted or removed.
296 if (!foreign_config) {
297 if (id == MPS_MAP_BAD_ID) {
298 kprintf("%s: could not get ID "
299 "for volume with handle "
300 "0x%04x\n", __func__,
301 element->VolDevHandle);
305 targ = &sassc->targets[id];
307 targ->encl_slot = 0x0;
308 targ->encl_handle = 0x0;
309 targ->exp_dev_handle = 0x0;
311 targ->linkrate = 0x0;
312 mpssas_rescan_target(sc, targ);
313 kprintf("RAID target id 0x%x removed\n",
317 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
319 * Phys Disk of a volume has been created. Hide
322 mpssas_prepare_remove(sassc, element->
325 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
327 * Phys Disk of a volume has been deleted.
328 * Expose it to the OS.
330 if (mpssas_add_device(sc,
331 element->PhysDiskDevHandle, 0)){
332 kprintf("%s: failed to add device with "
333 "handle 0x%x\n", __func__,
334 element->PhysDiskDevHandle);
335 mpssas_prepare_remove(sassc, element->
342 * refcount was incremented for this event in
343 * mpssas_evt_handler. Decrement it here because the event has
346 mpssas_startup_decrement(sassc);
349 case MPI2_EVENT_IR_VOLUME:
351 Mpi2EventDataIrVolume_t *event_data = fw_event->event_data;
354 * Informational only.
356 mps_dprint(sc, MPS_INFO, "Received IR Volume event:\n");
357 switch (event_data->ReasonCode) {
358 case MPI2_EVENT_IR_VOLUME_RC_SETTINGS_CHANGED:
359 mps_dprint(sc, MPS_INFO, " Volume Settings "
360 "changed from 0x%x to 0x%x for Volome with "
361 "handle 0x%x", event_data->PreviousValue,
362 event_data->NewValue,
363 event_data->VolDevHandle);
365 case MPI2_EVENT_IR_VOLUME_RC_STATUS_FLAGS_CHANGED:
366 mps_dprint(sc, MPS_INFO, " Volume Status "
367 "changed from 0x%x to 0x%x for Volome with "
368 "handle 0x%x", event_data->PreviousValue,
369 event_data->NewValue,
370 event_data->VolDevHandle);
372 case MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED:
373 mps_dprint(sc, MPS_INFO, " Volume State "
374 "changed from 0x%x to 0x%x for Volome with "
375 "handle 0x%x", event_data->PreviousValue,
376 event_data->NewValue,
377 event_data->VolDevHandle);
384 case MPI2_EVENT_IR_PHYSICAL_DISK:
386 Mpi2EventDataIrPhysicalDisk_t *event_data =
387 fw_event->event_data;
390 * Informational only.
392 mps_dprint(sc, MPS_INFO, "Received IR Phys Disk event:\n");
393 switch (event_data->ReasonCode) {
394 case MPI2_EVENT_IR_PHYSDISK_RC_SETTINGS_CHANGED:
395 mps_dprint(sc, MPS_INFO, " Phys Disk Settings "
396 "changed from 0x%x to 0x%x for Phys Disk Number "
397 "%d and handle 0x%x at Enclosure handle 0x%x, Slot "
398 "%d", event_data->PreviousValue,
399 event_data->NewValue, event_data->PhysDiskNum,
400 event_data->PhysDiskDevHandle,
401 event_data->EnclosureHandle, event_data->Slot);
403 case MPI2_EVENT_IR_PHYSDISK_RC_STATUS_FLAGS_CHANGED:
404 mps_dprint(sc, MPS_INFO, " Phys Disk Status changed "
405 "from 0x%x to 0x%x for Phys Disk Number %d and "
406 "handle 0x%x at Enclosure handle 0x%x, Slot %d",
407 event_data->PreviousValue, event_data->NewValue,
408 event_data->PhysDiskNum,
409 event_data->PhysDiskDevHandle,
410 event_data->EnclosureHandle, event_data->Slot);
412 case MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED:
413 mps_dprint(sc, MPS_INFO, " Phys Disk State changed "
414 "from 0x%x to 0x%x for Phys Disk Number %d and "
415 "handle 0x%x at Enclosure handle 0x%x, Slot %d",
416 event_data->PreviousValue, event_data->NewValue,
417 event_data->PhysDiskNum,
418 event_data->PhysDiskDevHandle,
419 event_data->EnclosureHandle, event_data->Slot);
426 case MPI2_EVENT_IR_OPERATION_STATUS:
428 Mpi2EventDataIrOperationStatus_t *event_data =
429 fw_event->event_data;
432 * Informational only.
434 mps_dprint(sc, MPS_INFO, "Received IR Op Status event:\n");
435 mps_dprint(sc, MPS_INFO, " RAID Operation of %d is %d "
436 "percent complete for Volume with handle 0x%x",
437 event_data->RAIDOperation, event_data->PercentComplete,
438 event_data->VolDevHandle);
441 case MPI2_EVENT_LOG_ENTRY_ADDED:
443 pMpi2EventDataLogEntryAdded_t logEntry;
444 uint16_t logQualifier;
447 logEntry = (pMpi2EventDataLogEntryAdded_t)fw_event->event_data;
448 logQualifier = logEntry->LogEntryQualifier;
450 if (logQualifier == MPI2_WD_LOG_ENTRY) {
451 logCode = logEntry->LogData[0];
454 case MPI2_WD_SSD_THROTTLING:
455 kprintf("WarpDrive Warning: IO Throttling has "
456 "occurred in the WarpDrive subsystem. "
457 "Check WarpDrive documentation for "
458 "additional details\n");
460 case MPI2_WD_DRIVE_LIFE_WARN:
461 kprintf("WarpDrive Warning: Program/Erase "
462 "Cycles for the WarpDrive subsystem in "
463 "degraded range. Check WarpDrive "
464 "documentation for additional details\n");
466 case MPI2_WD_DRIVE_LIFE_DEAD:
467 kprintf("WarpDrive Fatal Error: There are no "
468 "Program/Erase Cycles for the WarpDrive "
469 "subsystem. The storage device will be in "
470 "read-only mode. Check WarpDrive "
471 "documentation for additional details\n");
473 case MPI2_WD_RAIL_MON_FAIL:
474 kprintf("WarpDrive Fatal Error: The Backup Rail "
475 "Monitor has failed on the WarpDrive "
476 "subsystem. Check WarpDrive documentation "
477 "for additional details\n");
485 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
486 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
488 mps_dprint(sc, MPS_TRACE,"Unhandled event 0x%0X\n",
493 mpssas_fw_event_free(sc, fw_event);
497 mpssas_firmware_event_work(void *arg, int pending)
499 struct mps_fw_event_work *fw_event;
500 struct mps_softc *sc;
502 sc = (struct mps_softc *)arg;
504 while ((fw_event = TAILQ_FIRST(&sc->sassc->ev_queue)) != NULL) {
505 TAILQ_REMOVE(&sc->sassc->ev_queue, fw_event, ev_link);
506 mpssas_fw_work(sc, fw_event);
512 mpssas_add_device(struct mps_softc *sc, u16 handle, u8 linkrate){
514 struct mpssas_softc *sassc;
515 struct mpssas_target *targ;
516 Mpi2ConfigReply_t mpi_reply;
517 Mpi2SasDevicePage0_t config_page;
518 uint64_t sas_address, sata_sas_address;
519 uint64_t parent_sas_address = 0;
520 u16 ioc_pg8_flags = le16toh(sc->ioc_pg8.Flags);
521 u32 device_info, parent_devinfo = 0;
527 mpssas_startup_increment(sassc);
528 if ((mps_config_get_sas_device_pg0(sc, &mpi_reply, &config_page,
529 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
530 kprintf("%s: error reading SAS device page0\n", __func__);
535 device_info = le32toh(config_page.DeviceInfo);
537 if (((device_info & MPI2_SAS_DEVICE_INFO_SMP_TARGET) == 0)
538 && (config_page.ParentDevHandle != 0)) {
539 Mpi2ConfigReply_t tmp_mpi_reply;
540 Mpi2SasDevicePage0_t parent_config_page;
542 if ((mps_config_get_sas_device_pg0(sc, &tmp_mpi_reply,
543 &parent_config_page, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
544 le16toh(config_page.ParentDevHandle)))) {
545 kprintf("%s: error reading SAS device %#x page0\n",
546 __func__, le16toh(config_page.ParentDevHandle));
548 parent_sas_address = parent_config_page.SASAddress.High;
549 parent_sas_address = (parent_sas_address << 32) |
550 parent_config_page.SASAddress.Low;
551 parent_devinfo = le32toh(parent_config_page.DeviceInfo);
554 /* TODO Check proper endianess */
555 sas_address = config_page.SASAddress.High;
556 sas_address = (sas_address << 32) |
557 config_page.SASAddress.Low;
559 if ((ioc_pg8_flags & MPI2_IOCPAGE8_FLAGS_MASK_MAPPING_MODE)
560 == MPI2_IOCPAGE8_FLAGS_DEVICE_PERSISTENCE_MAPPING) {
561 if (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE) {
562 ret = mpssas_get_sas_address_for_sata_disk(sc,
563 &sata_sas_address, handle, device_info);
565 id = mps_mapping_get_sas_id(sc,
566 sata_sas_address, handle);
568 id = mps_mapping_get_sas_id(sc,
569 sas_address, handle);
571 id = mps_mapping_get_sas_id(sc, sas_address,
574 id = mps_mapping_get_sas_id(sc, sas_address, handle);
576 if (id == MPS_MAP_BAD_ID) {
577 kprintf("failure at %s:%d/%s()! Could not get ID for device "
578 "with handle 0x%04x\n", __FILE__, __LINE__, __func__,
583 mps_vprintf(sc, "SAS Address from SAS device page0 = %jx\n",
585 targ = &sassc->targets[id];
586 targ->devinfo = device_info;
587 targ->devname = le32toh(config_page.DeviceName.High);
588 targ->devname = (targ->devname << 32) |
589 le32toh(config_page.DeviceName.Low);
590 targ->encl_handle = le16toh(config_page.EnclosureHandle);
591 targ->encl_slot = le16toh(config_page.Slot);
592 targ->handle = handle;
593 targ->parent_handle = le16toh(config_page.ParentDevHandle);
594 targ->sasaddr = mps_to_u64(&config_page.SASAddress);
595 targ->parent_sasaddr = le64toh(parent_sas_address);
596 targ->parent_devinfo = parent_devinfo;
598 targ->linkrate = (linkrate>>4);
600 TAILQ_INIT(&targ->commands);
601 TAILQ_INIT(&targ->timedout_commands);
602 SLIST_INIT(&targ->luns);
603 mps_describe_devinfo(targ->devinfo, devstring, 80);
604 mps_vprintf(sc, "Found device <%s> <%s> <0x%04x> <%d/%d>\n", devstring,
605 mps_describe_table(mps_linkrate_names, targ->linkrate),
606 targ->handle, targ->encl_handle, targ->encl_slot);
607 if ((sassc->flags & MPSSAS_IN_STARTUP) == 0)
608 mpssas_rescan_target(sc, targ);
609 mps_vprintf(sc, "Target id 0x%x added\n", targ->tid);
611 mpssas_startup_decrement(sassc);
617 mpssas_get_sas_address_for_sata_disk(struct mps_softc *sc,
618 u64 *sas_address, u16 handle, u32 device_info)
620 Mpi2SataPassthroughReply_t mpi_reply;
621 int i, rc, try_count;
623 union _sata_sas_address hash_address;
624 struct _ata_identify_device_data ata_identify;
625 u8 buffer[MPT2SAS_MN_LEN + MPT2SAS_SN_LEN];
629 memset(&ata_identify, 0, sizeof(ata_identify));
632 rc = mpssas_get_sata_identify(sc, handle, &mpi_reply,
633 (char *)&ata_identify, sizeof(ata_identify), device_info);
635 ioc_status = le16toh(mpi_reply.IOCStatus)
636 & MPI2_IOCSTATUS_MASK;
637 sas_status = mpi_reply.SASStatus;
638 } while ((rc == -EAGAIN || ioc_status || sas_status) &&
641 if (rc == 0 && !ioc_status && !sas_status) {
642 mps_dprint(sc, MPS_INFO, "%s: got SATA identify successfully "
643 "for handle = 0x%x with try_count = %d\n",
644 __func__, handle, try_count);
646 mps_dprint(sc, MPS_INFO, "%s: handle = 0x%x failed\n",
650 /* Copy & byteswap the 40 byte model number to a buffer */
651 for (i = 0; i < MPT2SAS_MN_LEN; i += 2) {
652 buffer[i] = ((u8 *)ata_identify.model_number)[i + 1];
653 buffer[i + 1] = ((u8 *)ata_identify.model_number)[i];
655 /* Copy & byteswap the 20 byte serial number to a buffer */
656 for (i = 0; i < MPT2SAS_SN_LEN; i += 2) {
657 buffer[MPT2SAS_MN_LEN + i] =
658 ((u8 *)ata_identify.serial_number)[i + 1];
659 buffer[MPT2SAS_MN_LEN + i + 1] =
660 ((u8 *)ata_identify.serial_number)[i];
662 bufferptr = (u32 *)buffer;
663 /* There are 60 bytes to hash down to 8. 60 isn't divisible by 8,
664 * so loop through the first 56 bytes (7*8),
665 * and then add in the last dword.
667 hash_address.word.low = 0;
668 hash_address.word.high = 0;
669 for (i = 0; (i < ((MPT2SAS_MN_LEN+MPT2SAS_SN_LEN)/8)); i++) {
670 hash_address.word.low += *bufferptr;
672 hash_address.word.high += *bufferptr;
675 /* Add the last dword */
676 hash_address.word.low += *bufferptr;
677 /* Make sure the hash doesn't start with 5, because it could clash
678 * with a SAS address. Change 5 to a D.
680 if ((hash_address.word.high & 0x000000F0) == (0x00000050))
681 hash_address.word.high |= 0x00000080;
682 *sas_address = (u64)hash_address.wwid[0] << 56 |
683 (u64)hash_address.wwid[1] << 48 | (u64)hash_address.wwid[2] << 40 |
684 (u64)hash_address.wwid[3] << 32 | (u64)hash_address.wwid[4] << 24 |
685 (u64)hash_address.wwid[5] << 16 | (u64)hash_address.wwid[6] << 8 |
686 (u64)hash_address.wwid[7];
691 mpssas_get_sata_identify(struct mps_softc *sc, u16 handle,
692 Mpi2SataPassthroughReply_t *mpi_reply, char *id_buffer, int sz, u32 devinfo)
694 Mpi2SataPassthroughRequest_t *mpi_request;
695 Mpi2SataPassthroughReply_t *reply;
696 struct mps_command *cm;
700 buffer = kmalloc( sz, M_MPT2, M_NOWAIT | M_ZERO);
704 if ((cm = mps_alloc_command(sc)) == NULL) {
705 kfree(buffer, M_MPT2);
708 mpi_request = (MPI2_SATA_PASSTHROUGH_REQUEST *)cm->cm_req;
709 bzero(mpi_request,sizeof(MPI2_SATA_PASSTHROUGH_REQUEST));
710 mpi_request->Function = MPI2_FUNCTION_SATA_PASSTHROUGH;
711 mpi_request->VF_ID = 0;
712 mpi_request->DevHandle = htole16(handle);
713 mpi_request->PassthroughFlags = (MPI2_SATA_PT_REQ_PT_FLAGS_PIO |
714 MPI2_SATA_PT_REQ_PT_FLAGS_READ);
715 mpi_request->DataLength = htole32(sz);
716 mpi_request->CommandFIS[0] = 0x27;
717 mpi_request->CommandFIS[1] = 0x80;
718 mpi_request->CommandFIS[2] = (devinfo &
719 MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? 0xA1 : 0xEC;
720 cm->cm_sge = &mpi_request->SGL;
721 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
722 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
723 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
724 cm->cm_data = buffer;
725 cm->cm_length = htole32(sz);
726 error = mps_request_polled(sc, cm);
727 reply = (Mpi2SataPassthroughReply_t *)cm->cm_reply;
728 if (error || (reply == NULL)) {
730 /* If the poll returns error then we need to do diag reset */
731 kprintf("%s: poll for page completed with error %d",
736 bcopy(buffer, id_buffer, sz);
737 bcopy(reply, mpi_reply, sizeof(Mpi2SataPassthroughReply_t));
738 if ((reply->IOCStatus & MPI2_IOCSTATUS_MASK) !=
739 MPI2_IOCSTATUS_SUCCESS) {
740 kprintf("%s: error reading SATA PASSTHRU; iocstatus = 0x%x\n",
741 __func__, reply->IOCStatus);
746 mps_free_command(sc, cm);
747 kfree(buffer, M_MPT2);
752 mpssas_volume_add(struct mps_softc *sc, Mpi2EventIrConfigElement_t *element)
754 struct mpssas_softc *sassc;
755 struct mpssas_target *targ;
757 u16 handle = le16toh(element->VolDevHandle);
762 mpssas_startup_increment(sassc);
763 mps_config_get_volume_wwid(sc, handle, &wwid);
765 kprintf("%s: invalid WWID; cannot add volume to mapping table\n",
771 id = mps_mapping_get_raid_id(sc, wwid, handle);
772 if (id == MPS_MAP_BAD_ID) {
773 kprintf("%s: could not get ID for volume with handle 0x%04x and "
774 "WWID 0x%016llx\n", __func__, handle,
775 (unsigned long long)wwid);
780 targ = &sassc->targets[id];
782 targ->handle = handle;
783 targ->devname = wwid;
784 TAILQ_INIT(&targ->commands);
785 TAILQ_INIT(&targ->timedout_commands);
786 SLIST_INIT(&targ->luns);
787 if ((sassc->flags & MPSSAS_IN_STARTUP) == 0)
788 mpssas_rescan_target(sc, targ);
789 mps_dprint(sc, MPS_INFO, "RAID target id %d added (WWID = 0x%jx)\n",
792 mpssas_startup_decrement(sassc);
797 * mpssas_ir_shutdown - IR shutdown notification
798 * @sc: per adapter object
800 * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
801 * the host system is shutting down.
806 mpssas_ir_shutdown(struct mps_softc *sc)
808 u16 volume_mapping_flags;
809 u16 ioc_pg8_flags = le16toh(sc->ioc_pg8.Flags);
810 struct dev_mapping_table *mt_entry;
811 u32 start_idx, end_idx;
812 unsigned int id, found_volume = 0;
813 struct mps_command *cm;
814 Mpi2RaidActionRequest_t *action;
818 mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
820 /* is IR firmware build loaded? */
821 if (!sc->ir_firmware)
824 /* are there any volumes? Look at IR target IDs. */
825 // TODO-later, this should be looked up in the RAID config structure
826 // when it is implemented.
827 volume_mapping_flags = le16toh(sc->ioc_pg8.IRVolumeMappingFlags) &
828 MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
829 if (volume_mapping_flags == MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) {
831 if (ioc_pg8_flags & MPI2_IOCPAGE8_FLAGS_RESERVED_TARGETID_0)
834 start_idx = sc->max_devices - sc->max_volumes;
835 end_idx = start_idx + sc->max_volumes - 1;
837 for (id = start_idx; id < end_idx; id++) {
838 mt_entry = &sc->mapping_table[id];
839 if ((mt_entry->physical_id != 0) &&
840 (mt_entry->missing_count == 0)) {
849 if ((cm = mps_alloc_command(sc)) == NULL) {
850 kprintf("%s: command alloc failed\n", __func__);
854 action = (MPI2_RAID_ACTION_REQUEST *)cm->cm_req;
855 action->Function = MPI2_FUNCTION_RAID_ACTION;
856 action->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
857 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
858 mps_request_polled(sc, cm);
861 * Don't check for reply, just leave.
864 mps_free_command(sc, cm);