sys/dev/raid/mps/mps_sas_lsi.c

   1 /*-
   2  * Copyright (c) 2011 LSI Corp.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   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.
  13  *
  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
  24  * SUCH DAMAGE.
  25  *
  26  * LSI MPT-Fusion Host Adapter FreeBSD
  27  *
  28  * $FreeBSD: src/sys/dev/mps/mps_sas_lsi.c,v 1.1 2012/01/26 18:17:21 ken Exp $
  29  */
  30
  31 /* Communications core for LSI MPT2 */
  32
  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>
  39 #include <sys/bus.h>
  40 #include <sys/conf.h>
  41 #include <sys/eventhandler.h>
  42 #include <sys/bio.h>
  43 #include <sys/malloc.h>
  44 #include <sys/uio.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>
  50 #include <sys/sbuf.h>
  51
  52 #include <sys/rman.h>
  53
  54 #include <machine/stdarg.h>
  55
  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>
  65
  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>
  78
  79 /* For Hashed SAS Address creation for SATA Drives */
  80 #define MPT2SAS_SN_LEN 20
  81 #define MPT2SAS_MN_LEN 40
  82
  83 struct mps_fw_event_work {
  84         u16                     event;
  85         void                    *event_data;
  86         TAILQ_ENTRY(mps_fw_event_work)  ev_link;
  87 };
  88
  89 union _sata_sas_address {
  90         u8 wwid[8];
  91         struct {
  92                 u32 high;
  93                 u32 low;
  94         } word;
  95 };
  96
  97 /*
  98  * define the IDENTIFY DEVICE structure
  99  */
 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*/
 106 };
 107
 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,
 115     u32 devinfo);
 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);
 120
 121 void
 122 mpssas_evt_handler(struct mps_softc *sc, uintptr_t data,
 123     MPI2_EVENT_NOTIFICATION_REPLY *event)
 124 {
 125         struct mps_fw_event_work *fw_event;
 126         u16 sz;
 127
 128         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
 129         mps_print_evt_sas(sc, event);
 130         mpssas_record_event(sc, event);
 131
 132         fw_event = kmalloc(sizeof(struct mps_fw_event_work), M_MPT2,
 133              M_ZERO|M_NOWAIT);
 134         if (!fw_event) {
 135                 kprintf("%s: allocate failed for fw_event\n", __func__);
 136                 return;
 137         }
 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);
 143                 return;
 144         }
 145
 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++;
 153
 154         /*
 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.
 158          */
 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);
 163
 164         TAILQ_INSERT_TAIL(&sc->sassc->ev_queue, fw_event, ev_link);
 165         taskqueue_enqueue(sc->sassc->ev_tq, &sc->sassc->ev_task);
 166
 167 }
 168
 169 static void
 170 mpssas_fw_event_free(struct mps_softc *sc, struct mps_fw_event_work *fw_event)
 171 {
 172
 173         kfree(fw_event->event_data, M_MPT2);
 174         kfree(fw_event, M_MPT2);
 175 }
 176
 177 /**
 178  * _mps_fw_work - delayed task for processing firmware events
 179  * @sc: per adapter object
 180  * @fw_event: The fw_event_work object
 181  * Context: user.
 182  *
 183  * Return nothing.
 184  */
 185 static void
 186 mpssas_fw_work(struct mps_softc *sc, struct mps_fw_event_work *fw_event)
 187 {
 188         struct mpssas_softc *sassc;
 189         sassc = sc->sassc;
 190
 191         switch (fw_event->event) {
 192         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
 193         {
 194                 MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *data;
 195                 MPI2_EVENT_SAS_TOPO_PHY_ENTRY *phy;
 196                 int i;
 197
 198                 data = (MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *)
 199                     fw_event->event_data;
 200
 201                 mps_mapping_topology_change_event(sc, fw_event->event_data);
 202
 203                 for (i = 0; i < data->NumEntries; i++) {
 204                         phy = &data->PHY[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->
 213                                             AttachedDevHandle);
 214                                 }
 215                                 break;
 216                         case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
 217                                 mpssas_prepare_remove(sassc, phy->
 218                                     AttachedDevHandle);
 219                                 break;
 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:
 223                         default:
 224                                 break;
 225                         }
 226                 }
 227                 /*
 228                  * refcount was incremented for this event in
 229                  * mpssas_evt_handler.  Decrement it here because the event has
 230                  * been processed.
 231                  */
 232                 mpssas_startup_decrement(sassc);
 233                 break;
 234         }
 235         case MPI2_EVENT_SAS_DISCOVERY:
 236         {
 237                 MPI2_EVENT_DATA_SAS_DISCOVERY *data;
 238
 239                 data = (MPI2_EVENT_DATA_SAS_DISCOVERY *)fw_event->event_data;
 240
 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);
 247                 }
 248                 break;
 249         }
 250         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
 251         {
 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);
 257                 break;
 258         }
 259         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
 260         {
 261                 Mpi2EventIrConfigElement_t *element;
 262                 int i;
 263                 u8 foreign_config;
 264                 Mpi2EventDataIrConfigChangeList_t *event_data;
 265                 struct mpssas_target *targ;
 266                 unsigned int id;
 267
 268                 event_data = fw_event->event_data;
 269                 foreign_config = (le32toh(event_data->Flags) &
 270                     MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
 271
 272                 element =
 273                     (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
 274                 id = mps_mapping_get_raid_id_from_handle
 275                     (sc, element->VolDevHandle);
 276
 277                 mps_mapping_ir_config_change_event(sc, event_data);
 278
 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->
 288                                                     VolDevHandle));
 289                                         }
 290                                 }
 291                                 break;
 292                         case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
 293                         case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
 294                                 /*
 295                                  * Rescan after volume is deleted or removed.
 296                                  */
 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);
 303                                                 break;
 304                                         }
 305
 306                                         targ = &sassc->targets[id];
 307                                         targ->handle = 0x0;
 308                                         targ->encl_slot = 0x0;
 309                                         targ->encl_handle = 0x0;
 310                                         targ->exp_dev_handle = 0x0;
 311                                         targ->phy_num = 0x0;
 312                                         targ->linkrate = 0x0;
 313                                         mpssas_rescan_target(sc, targ);
 314                                         kprintf("RAID target id 0x%x removed\n",
 315                                             targ->tid);
 316                                 }
 317                                 break;
 318                         case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
 319                                 /*
 320                                  * Phys Disk of a volume has been created.  Hide
 321                                  * it from the OS.
 322                                  */
 323                                 mpssas_prepare_remove(sassc, element->
 324                                     PhysDiskDevHandle);
 325                                 break;
 326                         case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
 327                                 /*
 328                                  * Phys Disk of a volume has been deleted.
 329                                  * Expose it to the OS.
 330                                  */
 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->
 337                                             PhysDiskDevHandle);
 338                                 }
 339                                 break;
 340                         }
 341                 }
 342                 /*
 343                  * refcount was incremented for this event in
 344                  * mpssas_evt_handler.  Decrement it here because the event has
 345                  * been processed.
 346                  */
 347                 mpssas_startup_decrement(sassc);
 348                 break;
 349         }
 350         case MPI2_EVENT_IR_VOLUME:
 351         {
 352                 Mpi2EventDataIrVolume_t *event_data = fw_event->event_data;
 353
 354                 /*
 355                  * Informational only.
 356                  */
 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);
 365                         break;
 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);
 372                         break;
 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);
 379                         break;
 380                 default:
 381                         break;
 382                 }
 383                 break;
 384         }
 385         case MPI2_EVENT_IR_PHYSICAL_DISK:
 386         {
 387                 Mpi2EventDataIrPhysicalDisk_t *event_data =
 388                     fw_event->event_data;
 389
 390                 /*
 391                  * Informational only.
 392                  */
 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);
 403                         break;
 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);
 412                         break;
 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);
 421                         break;
 422                 default:
 423                         break;
 424                 }
 425                 break;
 426         }
 427         case MPI2_EVENT_IR_OPERATION_STATUS:
 428         {
 429                 Mpi2EventDataIrOperationStatus_t *event_data =
 430                     fw_event->event_data;
 431
 432                 /*
 433                  * Informational only.
 434                  */
 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);
 440                 break;
 441         }
 442         case MPI2_EVENT_LOG_ENTRY_ADDED:
 443         {
 444                 pMpi2EventDataLogEntryAdded_t   logEntry;
 445                 uint16_t                        logQualifier;
 446                 uint8_t                         logCode;
 447
 448                 logEntry = (pMpi2EventDataLogEntryAdded_t)fw_event->event_data;
 449                 logQualifier = logEntry->LogEntryQualifier;
 450
 451                 if (logQualifier == MPI2_WD_LOG_ENTRY) {
 452                         logCode = logEntry->LogData[0];
 453
 454                         switch (logCode) {
 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");
 460                                 break;
 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");
 466                                 break;
 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");
 473                                 break;
 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");
 479                                 break;
 480                         default:
 481                                 break;
 482                         }
 483                 }
 484                 break;
 485         }
 486         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
 487         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
 488         default:
 489                 mps_dprint(sc, MPS_TRACE,"Unhandled event 0x%0X\n",
 490                     fw_event->event);
 491                 break;
 492
 493         }
 494         mpssas_fw_event_free(sc, fw_event);
 495 }
 496
 497 void
 498 mpssas_firmware_event_work(void *arg, int pending)
 499 {
 500         struct mps_fw_event_work *fw_event;
 501         struct mps_softc *sc;
 502
 503         sc = (struct mps_softc *)arg;
 504         mps_lock(sc);
 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);
 508         }
 509         mps_unlock(sc);
 510 }
 511
 512 static int
 513 mpssas_add_device(struct mps_softc *sc, u16 handle, u8 linkrate){
 514         char devstring[80];
 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;
 523         unsigned int id;
 524         int ret;
 525         int error = 0;
 526
 527         sassc = sc->sassc;
 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__);
 532                 error = ENXIO;
 533                 goto out;
 534         }
 535
 536         device_info = le32toh(config_page.DeviceInfo);
 537
 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;
 542
 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));
 548                 } else {
 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);
 553                 }
 554         }
 555         /* TODO Check proper endianess */
 556         sas_address = config_page.SASAddress.High;
 557         sas_address = (sas_address << 32) |
 558             config_page.SASAddress.Low;
 559
 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);
 565                         if (!ret)
 566                                 id = mps_mapping_get_sas_id(sc,
 567                                     sata_sas_address, handle);
 568                         else
 569                                 id = mps_mapping_get_sas_id(sc,
 570                                     sas_address, handle);
 571                 } else
 572                         id = mps_mapping_get_sas_id(sc, sas_address,
 573                             handle);
 574         } else
 575                 id = mps_mapping_get_sas_id(sc, sas_address, handle);
 576
 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__,
 580                     handle);
 581                 error = ENXIO;
 582                 goto out;
 583         }
 584         mps_vprintf(sc, "SAS Address from SAS device page0 = %jx\n",
 585             sas_address);
 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;
 598         targ->tid = id;
 599         targ->linkrate = (linkrate>>4);
 600         targ->flags = 0;
 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);
 611 out:
 612         mpssas_startup_decrement(sassc);
 613         return (error);
 614
 615 }
 616
 617 int
 618 mpssas_get_sas_address_for_sata_disk(struct mps_softc *sc,
 619     u64 *sas_address, u16 handle, u32 device_info)
 620 {
 621         Mpi2SataPassthroughReply_t mpi_reply;
 622         int i, rc, try_count;
 623         u32 *bufferptr;
 624         union _sata_sas_address hash_address;
 625         struct _ata_identify_device_data ata_identify;
 626         u8 buffer[MPT2SAS_MN_LEN + MPT2SAS_SN_LEN];
 627         u32 ioc_status;
 628         u8 sas_status;
 629
 630         memset(&ata_identify, 0, sizeof(ata_identify));
 631         try_count = 0;
 632         do {
 633                 rc = mpssas_get_sata_identify(sc, handle, &mpi_reply,
 634                     (char *)&ata_identify, sizeof(ata_identify), device_info);
 635                 try_count++;
 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) &&
 640             (try_count < 5));
 641
 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);
 646         } else {
 647                 mps_dprint(sc, MPS_INFO, "%s: handle = 0x%x failed\n",
 648                            __func__, handle);
 649                 return -1;
 650         }
 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];
 655         }
 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];
 662         }
 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.
 667          */
 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;
 672                 bufferptr++;
 673                 hash_address.word.high += *bufferptr;
 674                 bufferptr++;
 675         }
 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.
 680          */
 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];
 688         return 0;
 689 }
 690
 691 static int
 692 mpssas_get_sata_identify(struct mps_softc *sc, u16 handle,
 693     Mpi2SataPassthroughReply_t *mpi_reply, char *id_buffer, int sz, u32 devinfo)
 694 {
 695         Mpi2SataPassthroughRequest_t *mpi_request;
 696         Mpi2SataPassthroughReply_t *reply;
 697         struct mps_command *cm;
 698         char *buffer;
 699         int error = 0;
 700
 701         buffer = kmalloc( sz, M_MPT2, M_NOWAIT | M_ZERO);
 702         if (!buffer)
 703                 return ENOMEM;
 704
 705         if ((cm = mps_alloc_command(sc)) == NULL)
 706                 return (EBUSY);
 707         mpi_request = (MPI2_SATA_PASSTHROUGH_REQUEST *)cm->cm_req;
 708         bzero(mpi_request,sizeof(MPI2_SATA_PASSTHROUGH_REQUEST));
 709         mpi_request->Function = MPI2_FUNCTION_SATA_PASSTHROUGH;
 710         mpi_request->VF_ID = 0;
 711         mpi_request->DevHandle = htole16(handle);
 712         mpi_request->PassthroughFlags = (MPI2_SATA_PT_REQ_PT_FLAGS_PIO |
 713             MPI2_SATA_PT_REQ_PT_FLAGS_READ);
 714         mpi_request->DataLength = htole32(sz);
 715         mpi_request->CommandFIS[0] = 0x27;
 716         mpi_request->CommandFIS[1] = 0x80;
 717         mpi_request->CommandFIS[2] =  (devinfo &
 718             MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? 0xA1 : 0xEC;
 719         cm->cm_sge = &mpi_request->SGL;
 720         cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
 721         cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
 722         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 723         cm->cm_data = buffer;
 724         cm->cm_length = htole32(sz);
 725         error = mps_request_polled(sc, cm);
 726         reply = (Mpi2SataPassthroughReply_t *)cm->cm_reply;
 727         if (error || (reply == NULL)) {
 728                 /* FIXME */
 729                 /* If the poll returns error then we need to do diag reset */
 730                 kprintf("%s: poll for page completed with error %d",
 731                     __func__, error);
 732                 error = ENXIO;
 733                 goto out;
 734         }
 735         bcopy(buffer, id_buffer, sz);
 736         bcopy(reply, mpi_reply, sizeof(Mpi2SataPassthroughReply_t));
 737         if ((reply->IOCStatus & MPI2_IOCSTATUS_MASK) !=
 738             MPI2_IOCSTATUS_SUCCESS) {
 739                 kprintf("%s: error reading SATA PASSTHRU; iocstatus = 0x%x\n",
 740                     __func__, reply->IOCStatus);
 741                 error = ENXIO;
 742                 goto out;
 743         }
 744 out:
 745         mps_free_command(sc, cm);
 746         kfree(buffer, M_MPT2);
 747         return (error);
 748 }
 749
 750 static int
 751 mpssas_volume_add(struct mps_softc *sc, Mpi2EventIrConfigElement_t *element)
 752 {
 753         struct mpssas_softc *sassc;
 754         struct mpssas_target *targ;
 755         u64 wwid;
 756         u16 handle = le16toh(element->VolDevHandle);
 757         unsigned int id;
 758         int error = 0;
 759
 760         sassc = sc->sassc;
 761         mpssas_startup_increment(sassc);
 762         mps_config_get_volume_wwid(sc, handle, &wwid);
 763         if (!wwid) {
 764                 kprintf("%s: invalid WWID; cannot add volume to mapping table\n",
 765                     __func__);
 766                 error = ENXIO;
 767                 goto out;
 768         }
 769
 770         id = mps_mapping_get_raid_id(sc, wwid, handle);
 771         if (id == MPS_MAP_BAD_ID) {
 772                 kprintf("%s: could not get ID for volume with handle 0x%04x and "
 773                     "WWID 0x%016llx\n", __func__, handle,
 774                     (unsigned long long)wwid);
 775                 error = ENXIO;
 776                 goto out;
 777         }
 778
 779         targ = &sassc->targets[id];
 780         targ->tid = id;
 781         targ->handle = handle;
 782         targ->devname = wwid;
 783         TAILQ_INIT(&targ->commands);
 784         TAILQ_INIT(&targ->timedout_commands);
 785         SLIST_INIT(&targ->luns);
 786         if ((sassc->flags & MPSSAS_IN_STARTUP) == 0)
 787                 mpssas_rescan_target(sc, targ);
 788         mps_dprint(sc, MPS_INFO, "RAID target id %d added (WWID = 0x%jx)\n",
 789             targ->tid, wwid);
 790 out:
 791         mpssas_startup_decrement(sassc);
 792         return (error);
 793 }
 794
 795 /**
 796  * mpssas_ir_shutdown - IR shutdown notification
 797  * @sc: per adapter object
 798  *
 799  * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
 800  * the host system is shutting down.
 801  *
 802  * Return nothing.
 803  */
 804 void
 805 mpssas_ir_shutdown(struct mps_softc *sc)
 806 {
 807         u16 volume_mapping_flags;
 808         u16 ioc_pg8_flags = le16toh(sc->ioc_pg8.Flags);
 809         struct dev_mapping_table *mt_entry;
 810         u32 start_idx, end_idx;
 811         unsigned int id, found_volume = 0;
 812         struct mps_command *cm;
 813         Mpi2RaidActionRequest_t *action;
 814
 815         mps_lock(sc);
 816
 817         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
 818
 819         /* is IR firmware build loaded? */
 820         if (!sc->ir_firmware)
 821                 goto back;
 822
 823         /* are there any volumes?  Look at IR target IDs. */
 824         // TODO-later, this should be looked up in the RAID config structure
 825         // when it is implemented.
 826         volume_mapping_flags = le16toh(sc->ioc_pg8.IRVolumeMappingFlags) &
 827             MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
 828         if (volume_mapping_flags == MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) {
 829                 start_idx = 0;
 830                 if (ioc_pg8_flags & MPI2_IOCPAGE8_FLAGS_RESERVED_TARGETID_0)
 831                         start_idx = 1;
 832         } else
 833                 start_idx = sc->max_devices - sc->max_volumes;
 834         end_idx = start_idx + sc->max_volumes - 1;
 835
 836         for (id = start_idx; id < end_idx; id++) {
 837                 mt_entry = &sc->mapping_table[id];
 838                 if ((mt_entry->physical_id != 0) &&
 839                     (mt_entry->missing_count == 0)) {
 840                         found_volume = 1;
 841                         break;
 842                 }
 843         }
 844
 845         if (!found_volume)
 846                 goto back;
 847
 848         if ((cm = mps_alloc_command(sc)) == NULL) {
 849                 kprintf("%s: command alloc failed\n", __func__);
 850                 goto back;
 851         }
 852
 853         action = (MPI2_RAID_ACTION_REQUEST *)cm->cm_req;
 854         action->Function = MPI2_FUNCTION_RAID_ACTION;
 855         action->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
 856         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 857         mps_request_polled(sc, cm);
 858
 859         /*
 860          * Don't check for reply, just leave.
 861          */
 862         if (cm)
 863                 mps_free_command(sc, cm);
 864
 865 back:
 866         mps_unlock(sc);
 867 }