sys/dev/raid/mps/mps_table.c

   1 /*-
   2  * Copyright (c) 2009 Yahoo! Inc.
   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  * $FreeBSD: src/sys/dev/mps/mps_table.c,v 1.2 2012/01/26 18:17:21 ken Exp $
  27  */
  28
  29 /* Debugging tables for MPT2 */
  30
  31 /* TODO Move headers to mpsvar */
  32 #include <sys/types.h>
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/kernel.h>
  36 #include <sys/module.h>
  37 #include <sys/bus.h>
  38 #include <sys/conf.h>
  39 #include <sys/eventhandler.h>
  40 #include <sys/bio.h>
  41 #include <sys/malloc.h>
  42 #include <sys/uio.h>
  43 #include <sys/sysctl.h>
  44 #include <sys/queue.h>
  45 #include <sys/kthread.h>
  46 #include <sys/taskqueue.h>
  47
  48 #include <sys/rman.h>
  49
  50 #include <machine/inttypes.h>
  51
  52 #include <bus/cam/scsi/scsi_all.h>
  53
  54 #include <dev/raid/mps/mpi/mpi2_type.h>
  55 #include <dev/raid/mps/mpi/mpi2.h>
  56 #include <dev/raid/mps/mpi/mpi2_ioc.h>
  57 #include <dev/raid/mps/mpi/mpi2_cnfg.h>
  58 #include <dev/raid/mps/mpi/mpi2_init.h>
  59 #include <dev/raid/mps/mpi/mpi2_tool.h>
  60 #include <dev/raid/mps/mps_ioctl.h>
  61 #include <dev/raid/mps/mpsvar.h>
  62 #include <dev/raid/mps/mps_table.h>
  63
  64 char *
  65 mps_describe_table(struct mps_table_lookup *table, u_int code)
  66 {
  67         int i;
  68
  69         for (i = 0; table[i].string != NULL; i++) {
  70                 if (table[i].code == code)
  71                         return(table[i].string);
  72         }
  73         return(table[i+1].string);
  74 }
  75
  76 struct mps_table_lookup mps_event_names[] = {
  77         {"LogData",                     0x01},
  78         {"StateChange",                 0x02},
  79         {"HardResetReceived",           0x05},
  80         {"EventChange",                 0x0a},
  81         {"TaskSetFull",                 0x0e},
  82         {"SasDeviceStatusChange",       0x0f},
  83         {"IrOperationStatus",           0x14},
  84         {"SasDiscovery",                0x16},
  85         {"SasBroadcastPrimitive",       0x17},
  86         {"SasInitDeviceStatusChange",   0x18},
  87         {"SasInitTableOverflow",        0x19},
  88         {"SasTopologyChangeList",       0x1c},
  89         {"SasEnclDeviceStatusChange",   0x1d},
  90         {"IrVolume",                    0x1e},
  91         {"IrPhysicalDisk",              0x1f},
  92         {"IrConfigurationChangeList",   0x20},
  93         {"LogEntryAdded",               0x21},
  94         {"SasPhyCounter",               0x22},
  95         {"GpioInterrupt",               0x23},
  96         {"HbdPhyEvent",                 0x24},
  97         {NULL, 0},
  98         {"Unknown Event", 0}
  99 };
 100
 101 struct mps_table_lookup mps_phystatus_names[] = {
 102         {"NewTargetAdded",              0x01},
 103         {"TargetGone",                  0x02},
 104         {"PHYLinkStatusChange",         0x03},
 105         {"PHYLinkStatusUnchanged",      0x04},
 106         {"TargetMissing",               0x05},
 107         {NULL, 0},
 108         {"Unknown Status", 0}
 109 };
 110
 111 struct mps_table_lookup mps_linkrate_names[] = {
 112         {"PHY disabled",                0x01},
 113         {"Speed Negotiation Failed",    0x02},
 114         {"SATA OOB Complete",           0x03},
 115         {"SATA Port Selector",          0x04},
 116         {"SMP Reset in Progress",       0x05},
 117         {"1.5Gbps",                     0x08},
 118         {"3.0Gbps",                     0x09},
 119         {"6.0Gbps",                     0x0a},
 120         {NULL, 0},
 121         {"LinkRate Unknown",            0x00}
 122 };
 123
 124 struct mps_table_lookup mps_sasdev0_devtype[] = {
 125         {"End Device",                  0x01},
 126         {"Edge Expander",               0x02},
 127         {"Fanout Expander",             0x03},
 128         {NULL, 0},
 129         {"No Device",                   0x00}
 130 };
 131
 132 struct mps_table_lookup mps_phyinfo_reason_names[] = {
 133         {"Power On",                    0x01},
 134         {"Hard Reset",                  0x02},
 135         {"SMP Phy Control Link Reset",  0x03},
 136         {"Loss DWORD Sync",             0x04},
 137         {"Multiplex Sequence",          0x05},
 138         {"I-T Nexus Loss Timer",        0x06},
 139         {"Break Timeout Timer",         0x07},
 140         {"PHY Test Function",           0x08},
 141         {NULL, 0},
 142         {"Unknown Reason",              0x00}
 143 };
 144
 145 struct mps_table_lookup mps_whoinit_names[] = {
 146         {"System BIOS",                 0x01},
 147         {"ROM BIOS",                    0x02},
 148         {"PCI Peer",                    0x03},
 149         {"Host Driver",                 0x04},
 150         {"Manufacturing",               0x05},
 151         {NULL, 0},
 152         {"Not Initialized",             0x00}
 153 };
 154
 155 struct mps_table_lookup mps_sasdisc_reason[] = {
 156         {"Discovery Started",           0x01},
 157         {"Discovery Complete",          0x02},
 158         {NULL, 0},
 159         {"Unknown",                     0x00}
 160 };
 161
 162 struct mps_table_lookup mps_sastopo_exp[] = {
 163         {"Added",                       0x01},
 164         {"Not Responding",              0x02},
 165         {"Responding",                  0x03},
 166         {"Delay Not Responding",        0x04},
 167         {NULL, 0},
 168         {"Unknown",                     0x00}
 169 };
 170
 171 struct mps_table_lookup mps_sasdev_reason[] = {
 172         {"SMART Data",                  0x05},
 173         {"Unsupported",                 0x07},
 174         {"Internal Device Reset",       0x08},
 175         {"Task Abort Internal",         0x09},
 176         {"Abort Task Set Internal",     0x0a},
 177         {"Clear Task Set Internal",     0x0b},
 178         {"Query Task Internal",         0x0c},
 179         {"Async Notification",          0x0d},
 180         {"Cmp Internal Device Reset",   0x0e},
 181         {"Cmp Task Abort Internal",     0x0f},
 182         {"Sata Init Failure",           0x10},
 183         {NULL, 0},
 184         {"Unknown",                     0x00}
 185 };
 186
 187 void
 188 mps_describe_devinfo(uint32_t devinfo, char *string, int len)
 189 {
 190         ksnprintf(string, len, "%b,%s", devinfo,
 191             "\20" "\4SataHost" "\5SmpInit" "\6StpInit" "\7SspInit"
 192             "\10SataDev" "\11SmpTarg" "\12StpTarg" "\13SspTarg" "\14Direct"
 193             "\15LsiDev" "\16AtapiDev" "\17SepDev",
 194             mps_describe_table(mps_sasdev0_devtype, devinfo & 0x03));
 195 }
 196
 197 void
 198 mps_print_iocfacts(struct mps_softc *sc, MPI2_IOC_FACTS_REPLY *facts)
 199 {
 200
 201         MPS_PRINTFIELD_START(sc, "IOCFacts");
 202         MPS_PRINTFIELD(sc, facts, MsgVersion, 0x%x);
 203         MPS_PRINTFIELD(sc, facts, HeaderVersion, 0x%x);
 204         MPS_PRINTFIELD(sc, facts, IOCNumber, %d);
 205         MPS_PRINTFIELD(sc, facts, IOCExceptions, 0x%x);
 206         MPS_PRINTFIELD(sc, facts, MaxChainDepth, %d);
 207         mps_dprint_field(sc, MPS_INFO, "WhoInit: %s\n",
 208             mps_describe_table(mps_whoinit_names, facts->WhoInit));
 209         MPS_PRINTFIELD(sc, facts, NumberOfPorts, %d);
 210         MPS_PRINTFIELD(sc, facts, RequestCredit, %d);
 211         MPS_PRINTFIELD(sc, facts, ProductID, 0x%x);
 212         mps_dprint_field(sc, MPS_INFO, "IOCCapabilities: %b\n",
 213             (u_int)facts->IOCCapabilities, "\20" "\3ScsiTaskFull" "\4DiagTrace"
 214             "\5SnapBuf" "\6ExtBuf" "\7EEDP" "\10BiDirTarg" "\11Multicast"
 215             "\14TransRetry" "\15IR" "\16EventReplay" "\17RaidAccel"
 216             "\20MSIXIndex" "\21HostDisc");
 217         mps_dprint_field(sc, MPS_INFO, "FWVersion= %d-%d-%d-%d\n",
 218             facts->FWVersion.Struct.Major,
 219             facts->FWVersion.Struct.Minor,
 220             facts->FWVersion.Struct.Unit,
 221             facts->FWVersion.Struct.Dev);
 222         MPS_PRINTFIELD(sc, facts, IOCRequestFrameSize, %d);
 223         MPS_PRINTFIELD(sc, facts, MaxInitiators, %d);
 224         MPS_PRINTFIELD(sc, facts, MaxTargets, %d);
 225         MPS_PRINTFIELD(sc, facts, MaxSasExpanders, %d);
 226         MPS_PRINTFIELD(sc, facts, MaxEnclosures, %d);
 227         mps_dprint_field(sc, MPS_INFO, "ProtocolFlags: %b\n",
 228             facts->ProtocolFlags, "\20" "\1ScsiTarg" "\2ScsiInit");
 229         MPS_PRINTFIELD(sc, facts, HighPriorityCredit, %d);
 230         MPS_PRINTFIELD(sc, facts, MaxReplyDescriptorPostQueueDepth, %d);
 231         MPS_PRINTFIELD(sc, facts, ReplyFrameSize, %d);
 232         MPS_PRINTFIELD(sc, facts, MaxVolumes, %d);
 233         MPS_PRINTFIELD(sc, facts, MaxDevHandle, %d);
 234         MPS_PRINTFIELD(sc, facts, MaxPersistentEntries, %d);
 235 }
 236
 237 void
 238 mps_print_portfacts(struct mps_softc *sc, MPI2_PORT_FACTS_REPLY *facts)
 239 {
 240
 241         MPS_PRINTFIELD_START(sc, "PortFacts");
 242         MPS_PRINTFIELD(sc, facts, PortNumber, %d);
 243         MPS_PRINTFIELD(sc, facts, PortType, 0x%x);
 244         MPS_PRINTFIELD(sc, facts, MaxPostedCmdBuffers, %d);
 245 }
 246
 247 void
 248 mps_print_event(struct mps_softc *sc, MPI2_EVENT_NOTIFICATION_REPLY *event)
 249 {
 250
 251         MPS_EVENTFIELD_START(sc, "EventReply");
 252         MPS_EVENTFIELD(sc, event, EventDataLength, %d);
 253         MPS_EVENTFIELD(sc, event, AckRequired, %d);
 254         mps_dprint_field(sc, MPS_EVENT, "Event: %s (0x%x)\n",
 255             mps_describe_table(mps_event_names, event->Event), event->Event);
 256         mps_dprint_field(sc, MPS_EVENT, "EventContext: 0x%x\n",
 257             (u_int)event->EventContext);
 258 }
 259
 260 void
 261 mps_print_sasdev0(struct mps_softc *sc, MPI2_CONFIG_PAGE_SAS_DEV_0 *buf)
 262 {
 263         MPS_PRINTFIELD_START(sc, "SAS Device Page 0");
 264         MPS_PRINTFIELD(sc, buf, Slot, %d);
 265         MPS_PRINTFIELD(sc, buf, EnclosureHandle, 0x%x);
 266         mps_dprint_field(sc, MPS_INFO, "SASAddress: 0x%jx\n",
 267             mps_to_u64(&buf->SASAddress));
 268         MPS_PRINTFIELD(sc, buf, ParentDevHandle, 0x%x);
 269         MPS_PRINTFIELD(sc, buf, PhyNum, %d);
 270         MPS_PRINTFIELD(sc, buf, AccessStatus, 0x%x);
 271         MPS_PRINTFIELD(sc, buf, DevHandle, 0x%x);
 272         MPS_PRINTFIELD(sc, buf, AttachedPhyIdentifier, 0x%x);
 273         MPS_PRINTFIELD(sc, buf, ZoneGroup, %d);
 274         mps_dprint_field(sc, MPS_INFO, "DeviceInfo: %b,%s\n", (int)buf->DeviceInfo,
 275             "\20" "\4SataHost" "\5SmpInit" "\6StpInit" "\7SspInit"
 276             "\10SataDev" "\11SmpTarg" "\12StpTarg" "\13SspTarg" "\14Direct"
 277             "\15LsiDev" "\16AtapiDev" "\17SepDev",
 278             mps_describe_table(mps_sasdev0_devtype, buf->DeviceInfo & 0x03));
 279         MPS_PRINTFIELD(sc, buf, Flags, 0x%x);
 280         MPS_PRINTFIELD(sc, buf, PhysicalPort, %d);
 281         MPS_PRINTFIELD(sc, buf, MaxPortConnections, %d);
 282         mps_dprint_field(sc, MPS_INFO, "DeviceName: 0x%jx\n",
 283             mps_to_u64(&buf->DeviceName));
 284         MPS_PRINTFIELD(sc, buf, PortGroups, %d);
 285         MPS_PRINTFIELD(sc, buf, DmaGroup, %d);
 286         MPS_PRINTFIELD(sc, buf, ControlGroup, %d);
 287 }
 288
 289 void
 290 mps_print_evt_sas(struct mps_softc *sc, MPI2_EVENT_NOTIFICATION_REPLY *event)
 291 {
 292
 293         mps_print_event(sc, event);
 294
 295         switch(event->Event) {
 296         case MPI2_EVENT_SAS_DISCOVERY:
 297         {
 298                 MPI2_EVENT_DATA_SAS_DISCOVERY *data;
 299
 300                 data = (MPI2_EVENT_DATA_SAS_DISCOVERY *)&event->EventData;
 301                 mps_dprint_field(sc, MPS_EVENT, "Flags: %b\n", data->Flags,
 302                     "\20" "\1InProgress" "\2DeviceChange");
 303                 mps_dprint_field(sc, MPS_EVENT, "ReasonCode: %s\n",
 304                     mps_describe_table(mps_sasdisc_reason, data->ReasonCode));
 305                 MPS_EVENTFIELD(sc, data, PhysicalPort, %d);
 306                 mps_dprint_field(sc, MPS_EVENT, "DiscoveryStatus: %b\n",
 307                     (int)data->DiscoveryStatus,  "\20"
 308                     "\1Loop" "\2UnaddressableDev" "\3DupSasAddr" "\5SmpTimeout"
 309                     "\6ExpRouteFull" "\7RouteIndexError" "\10SmpFailed"
 310                     "\11SmpCrcError" "\12SubSubLink" "\13TableTableLink"
 311                     "\14UnsupDevice" "\15TableSubLink" "\16MultiDomain"
 312                     "\17MultiSub" "\20MultiSubSub" "\34DownstreamInit"
 313                     "\35MaxPhys" "\36MaxTargs" "\37MaxExpanders"
 314                     "\40MaxEnclosures");
 315                 break;
 316         }
 317         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
 318         {
 319                 MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *data;
 320                 MPI2_EVENT_SAS_TOPO_PHY_ENTRY *phy;
 321                 int i, phynum;
 322
 323                 data = (MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *)
 324                     &event->EventData;
 325                 MPS_EVENTFIELD(sc, data, EnclosureHandle, 0x%x);
 326                 MPS_EVENTFIELD(sc, data, ExpanderDevHandle, 0x%x);
 327                 MPS_EVENTFIELD(sc, data, NumPhys, %d);
 328                 MPS_EVENTFIELD(sc, data, NumEntries, %d);
 329                 MPS_EVENTFIELD(sc, data, StartPhyNum, %d);
 330                 mps_dprint_field(sc, MPS_EVENT, "ExpStatus: %s (0x%x)\n",
 331                     mps_describe_table(mps_sastopo_exp, data->ExpStatus),
 332                     data->ExpStatus);
 333                 MPS_EVENTFIELD(sc, data, PhysicalPort, %d);
 334                 for (i = 0; i < data->NumEntries; i++) {
 335                         phy = &data->PHY[i];
 336                         phynum = data->StartPhyNum + i;
 337                         mps_dprint_field(sc, MPS_EVENT,
 338                             "PHY[%d].AttachedDevHandle: 0x%04x\n", phynum,
 339                             phy->AttachedDevHandle);
 340                         mps_dprint_field(sc, MPS_EVENT,
 341                             "PHY[%d].LinkRate: %s (0x%x)\n", phynum,
 342                             mps_describe_table(mps_linkrate_names,
 343                             (phy->LinkRate >> 4) & 0xf), phy->LinkRate);
 344                         mps_dprint_field(sc,MPS_EVENT,"PHY[%d].PhyStatus: %s\n",
 345                             phynum, mps_describe_table(mps_phystatus_names,
 346                             phy->PhyStatus));
 347                 }
 348                 break;
 349         }
 350         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
 351         {
 352                 MPI2_EVENT_DATA_SAS_ENCL_DEV_STATUS_CHANGE *data;
 353
 354                 data = (MPI2_EVENT_DATA_SAS_ENCL_DEV_STATUS_CHANGE *)
 355                     &event->EventData;
 356                 MPS_EVENTFIELD(sc, data, EnclosureHandle, 0x%x);
 357                 mps_dprint_field(sc, MPS_EVENT, "ReasonCode: %s\n",
 358                     mps_describe_table(mps_sastopo_exp, data->ReasonCode));
 359                 MPS_EVENTFIELD(sc, data, PhysicalPort, %d);
 360                 MPS_EVENTFIELD(sc, data, NumSlots, %d);
 361                 MPS_EVENTFIELD(sc, data, StartSlot, %d);
 362                 mps_dprint_field(sc, MPS_EVENT, "PhyBits: 0x%x\n",
 363                     (u_int)data->PhyBits);
 364                 break;
 365         }
 366         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
 367         {
 368                 MPI2_EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *data;
 369
 370                 data = (MPI2_EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)
 371                     &event->EventData;
 372                 MPS_EVENTFIELD(sc, data, TaskTag, 0x%x);
 373                 mps_dprint_field(sc, MPS_EVENT, "ReasonCode: %s\n",
 374                     mps_describe_table(mps_sasdev_reason, data->ReasonCode));
 375                 MPS_EVENTFIELD(sc, data, ASC, 0x%x);
 376                 MPS_EVENTFIELD(sc, data, ASCQ, 0x%x);
 377                 MPS_EVENTFIELD(sc, data, DevHandle, 0x%x);
 378                 mps_dprint_field(sc, MPS_EVENT, "SASAddress: 0x%jx\n",
 379                     mps_to_u64(&data->SASAddress));
 380         }
 381         default:
 382                 break;
 383         }
 384 }
 385
 386 void
 387 mps_print_expander1(struct mps_softc *sc, MPI2_CONFIG_PAGE_EXPANDER_1 *buf)
 388 {
 389         MPS_PRINTFIELD_START(sc, "SAS Expander Page 1 #%d", buf->Phy);
 390         MPS_PRINTFIELD(sc, buf, PhysicalPort, %d);
 391         MPS_PRINTFIELD(sc, buf, NumPhys, %d);
 392         MPS_PRINTFIELD(sc, buf, Phy, %d);
 393         MPS_PRINTFIELD(sc, buf, NumTableEntriesProgrammed, %d);
 394         mps_dprint_field(sc, MPS_INFO, "ProgrammedLinkRate: %s (0x%x)\n",
 395             mps_describe_table(mps_linkrate_names,
 396             (buf->ProgrammedLinkRate >> 4) & 0xf), buf->ProgrammedLinkRate);
 397         mps_dprint_field(sc, MPS_INFO, "HwLinkRate: %s (0x%x)\n",
 398             mps_describe_table(mps_linkrate_names,
 399             (buf->HwLinkRate >> 4) & 0xf), buf->HwLinkRate);
 400         MPS_PRINTFIELD(sc, buf, AttachedDevHandle, 0x%04x);
 401         mps_dprint_field(sc, MPS_INFO, "PhyInfo Reason: %s (0x%x)\n",
 402             mps_describe_table(mps_phyinfo_reason_names,
 403             (buf->PhyInfo >> 16) & 0xf), (u_int)buf->PhyInfo);
 404         mps_dprint_field(sc, MPS_INFO, "AttachedDeviceInfo: %b,%s\n",
 405             (int)buf->AttachedDeviceInfo, "\20" "\4SATAhost" "\5SMPinit" "\6STPinit"
 406             "\7SSPinit" "\10SATAdev" "\11SMPtarg" "\12STPtarg" "\13SSPtarg"
 407             "\14Direct" "\15LSIdev" "\16ATAPIdev" "\17SEPdev",
 408             mps_describe_table(mps_sasdev0_devtype,
 409             buf->AttachedDeviceInfo & 0x03));
 410         MPS_PRINTFIELD(sc, buf, ExpanderDevHandle, 0x%04x);
 411         MPS_PRINTFIELD(sc, buf, ChangeCount, %d);
 412         mps_dprint_field(sc, MPS_INFO, "NegotiatedLinkRate: %s (0x%x)\n",
 413             mps_describe_table(mps_linkrate_names,
 414             buf->NegotiatedLinkRate & 0xf), buf->NegotiatedLinkRate);
 415         MPS_PRINTFIELD(sc, buf, PhyIdentifier, %d);
 416         MPS_PRINTFIELD(sc, buf, AttachedPhyIdentifier, %d);
 417         MPS_PRINTFIELD(sc, buf, DiscoveryInfo, 0x%x);
 418         mps_dprint_field(sc, MPS_INFO, "AttachedPhyInfo: 0x%x\n",
 419             (u_int)buf->AttachedPhyInfo);
 420         mps_dprint_field(sc, MPS_INFO, "AttachedPhyInfo Reason: %s (0x%x)\n",
 421             mps_describe_table(mps_phyinfo_reason_names,
 422             buf->AttachedPhyInfo & 0xf), (u_int)buf->AttachedPhyInfo);
 423         MPS_PRINTFIELD(sc, buf, ZoneGroup, %d);
 424         MPS_PRINTFIELD(sc, buf, SelfConfigStatus, 0x%x);
 425 }
 426
 427 void
 428 mps_print_sasphy0(struct mps_softc *sc, MPI2_CONFIG_PAGE_SAS_PHY_0 *buf)
 429 {
 430         MPS_PRINTFIELD_START(sc, "SAS PHY Page 0");
 431         MPS_PRINTFIELD(sc, buf, OwnerDevHandle, 0x%04x);
 432         MPS_PRINTFIELD(sc, buf, AttachedDevHandle, 0x%04x);
 433         MPS_PRINTFIELD(sc, buf, AttachedPhyIdentifier, %d);
 434         mps_dprint_field(sc, MPS_INFO, "AttachedPhyInfo Reason: %s (0x%x)\n",
 435             mps_describe_table(mps_phyinfo_reason_names,
 436             buf->AttachedPhyInfo & 0xf), (u_int)buf->AttachedPhyInfo);
 437         mps_dprint_field(sc, MPS_INFO, "ProgrammedLinkRate: %s (0x%x)\n",
 438             mps_describe_table(mps_linkrate_names,
 439             (buf->ProgrammedLinkRate >> 4) & 0xf), buf->ProgrammedLinkRate);
 440         mps_dprint_field(sc, MPS_INFO, "HwLinkRate: %s (0x%x)\n",
 441             mps_describe_table(mps_linkrate_names,
 442             (buf->HwLinkRate >> 4) & 0xf), buf->HwLinkRate);
 443         MPS_PRINTFIELD(sc, buf, ChangeCount, %d);
 444         MPS_PRINTFIELD(sc, buf, Flags, 0x%x);
 445         mps_dprint_field(sc, MPS_INFO, "PhyInfo Reason: %s (0x%x)\n",
 446             mps_describe_table(mps_phyinfo_reason_names,
 447             (buf->PhyInfo >> 16) & 0xf), (u_int)buf->PhyInfo);
 448         mps_dprint_field(sc, MPS_INFO, "NegotiatedLinkRate: %s (0x%x)\n",
 449             mps_describe_table(mps_linkrate_names,
 450             buf->NegotiatedLinkRate & 0xf), buf->NegotiatedLinkRate);
 451 }
 452
 453 void
 454 mps_print_sgl(struct mps_softc *sc, struct mps_command *cm, int offset)
 455 {
 456         MPI2_SGE_SIMPLE64 *sge;
 457         MPI2_SGE_CHAIN32 *sgc;
 458         MPI2_REQUEST_HEADER *req;
 459         struct mps_chain *chain = NULL;
 460         char *frame;
 461         u_int i = 0, flags;
 462
 463         req = (MPI2_REQUEST_HEADER *)cm->cm_req;
 464         frame = (char *)cm->cm_req;
 465         sge = (MPI2_SGE_SIMPLE64 *)&frame[offset * 4];
 466         kprintf("SGL for command %p\n", cm);
 467
 468         while (frame != NULL) {
 469                 flags = sge->FlagsLength >> MPI2_SGE_FLAGS_SHIFT;
 470                 kprintf("seg%d flags=0x%x len=0x%x addr=0x%jx\n", i, flags,
 471                     (u_int)(sge->FlagsLength & 0xffffff), mps_to_u64(&sge->Address));
 472                 if (flags & (MPI2_SGE_FLAGS_END_OF_LIST |
 473                     MPI2_SGE_FLAGS_END_OF_BUFFER))
 474                         break;
 475                 sge++;
 476                 i++;
 477                 if (flags & MPI2_SGE_FLAGS_LAST_ELEMENT) {
 478                         sgc = (MPI2_SGE_CHAIN32 *)sge;
 479                         kprintf("chain flags=0x%x len=0x%x Offset=0x%x "
 480                             "Address=0x%x\n", sgc->Flags, sgc->Length,
 481                             sgc->NextChainOffset, (u_int)sgc->Address);
 482                         if (chain == NULL)
 483                                 chain = TAILQ_FIRST(&cm->cm_chain_list);
 484                         else
 485                                 chain = TAILQ_NEXT(chain, chain_link);
 486                         frame = (char *)chain->chain;
 487                         sge = (MPI2_SGE_SIMPLE64 *)frame;
 488                         hexdump(frame, 128, NULL, 0);
 489                 }
 490         }
 491 }
 492
 493 void
 494 mps_print_scsiio_cmd(struct mps_softc *sc, struct mps_command *cm)
 495 {
 496         MPI2_SCSI_IO_REQUEST *req;
 497
 498         req = (MPI2_SCSI_IO_REQUEST *)cm->cm_req;
 499         mps_print_sgl(sc, cm, req->SGLOffset0);
 500 }