The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/mps/mps_table.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2009 Yahoo! Inc.
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD: releng/12.0/sys/dev/mps/mps_table.c 326255 2017-11-27 14:52:40Z pfg $");
   31 
   32 /* Debugging tables for MPT2 */
   33 
   34 /* TODO Move headers to mpsvar */
   35 #include <sys/types.h>
   36 #include <sys/param.h>
   37 #include <sys/systm.h>
   38 #include <sys/kernel.h>
   39 #include <sys/selinfo.h>
   40 #include <sys/module.h>
   41 #include <sys/bus.h>
   42 #include <sys/conf.h>
   43 #include <sys/bio.h>
   44 #include <sys/malloc.h>
   45 #include <sys/uio.h>
   46 #include <sys/sysctl.h>
   47 #include <sys/queue.h>
   48 #include <sys/kthread.h>
   49 #include <sys/taskqueue.h>
   50 
   51 #include <machine/bus.h>
   52 #include <machine/resource.h>
   53 #include <sys/rman.h>
   54 
   55 #include <cam/scsi/scsi_all.h>
   56 
   57 #include <dev/mps/mpi/mpi2_type.h>
   58 #include <dev/mps/mpi/mpi2.h>
   59 #include <dev/mps/mpi/mpi2_ioc.h>
   60 #include <dev/mps/mpi/mpi2_cnfg.h>
   61 #include <dev/mps/mpi/mpi2_init.h>
   62 #include <dev/mps/mpi/mpi2_tool.h>
   63 #include <dev/mps/mps_ioctl.h>
   64 #include <dev/mps/mpsvar.h>
   65 #include <dev/mps/mps_table.h>
   66 
   67 char *
   68 mps_describe_table(struct mps_table_lookup *table, u_int code)
   69 {
   70         int i;
   71 
   72         for (i = 0; table[i].string != NULL; i++) {
   73                 if (table[i].code == code)
   74                         return(table[i].string);
   75         }
   76         return(table[i+1].string);
   77 }
   78 
   79 struct mps_table_lookup mps_event_names[] = {
   80         {"LogData",                     0x01},
   81         {"StateChange",                 0x02},
   82         {"HardResetReceived",           0x05},
   83         {"EventChange",                 0x0a},
   84         {"TaskSetFull",                 0x0e},
   85         {"SasDeviceStatusChange",       0x0f},
   86         {"IrOperationStatus",           0x14},
   87         {"SasDiscovery",                0x16},
   88         {"SasBroadcastPrimitive",       0x17},
   89         {"SasInitDeviceStatusChange",   0x18},
   90         {"SasInitTableOverflow",        0x19},
   91         {"SasTopologyChangeList",       0x1c},
   92         {"SasEnclDeviceStatusChange",   0x1d},
   93         {"IrVolume",                    0x1e},
   94         {"IrPhysicalDisk",              0x1f},
   95         {"IrConfigurationChangeList",   0x20},
   96         {"LogEntryAdded",               0x21},
   97         {"SasPhyCounter",               0x22},
   98         {"GpioInterrupt",               0x23},
   99         {"HbdPhyEvent",                 0x24},
  100         {NULL, 0},
  101         {"Unknown Event", 0}
  102 };
  103 
  104 struct mps_table_lookup mps_phystatus_names[] = {
  105         {"NewTargetAdded",              0x01},
  106         {"TargetGone",                  0x02},
  107         {"PHYLinkStatusChange",         0x03},
  108         {"PHYLinkStatusUnchanged",      0x04},
  109         {"TargetMissing",               0x05},
  110         {NULL, 0},
  111         {"Unknown Status", 0}
  112 };
  113 
  114 struct mps_table_lookup mps_linkrate_names[] = {
  115         {"PHY disabled",                0x01},
  116         {"Speed Negotiation Failed",    0x02},
  117         {"SATA OOB Complete",           0x03},
  118         {"SATA Port Selector",          0x04},
  119         {"SMP Reset in Progress",       0x05},
  120         {"1.5Gbps",                     0x08},
  121         {"3.0Gbps",                     0x09},
  122         {"6.0Gbps",                     0x0a},
  123         {NULL, 0},
  124         {"LinkRate Unknown",            0x00}
  125 };
  126 
  127 struct mps_table_lookup mps_sasdev0_devtype[] = {
  128         {"End Device",                  0x01},
  129         {"Edge Expander",               0x02},
  130         {"Fanout Expander",             0x03},
  131         {NULL, 0},
  132         {"No Device",                   0x00}
  133 };
  134 
  135 struct mps_table_lookup mps_phyinfo_reason_names[] = {
  136         {"Power On",                    0x01},
  137         {"Hard Reset",                  0x02},
  138         {"SMP Phy Control Link Reset",  0x03},
  139         {"Loss DWORD Sync",             0x04},
  140         {"Multiplex Sequence",          0x05},
  141         {"I-T Nexus Loss Timer",        0x06},
  142         {"Break Timeout Timer",         0x07},
  143         {"PHY Test Function",           0x08},
  144         {NULL, 0},
  145         {"Unknown Reason",              0x00}
  146 };
  147 
  148 struct mps_table_lookup mps_whoinit_names[] = {
  149         {"System BIOS",                 0x01},
  150         {"ROM BIOS",                    0x02},
  151         {"PCI Peer",                    0x03},
  152         {"Host Driver",                 0x04},
  153         {"Manufacturing",               0x05},
  154         {NULL, 0},
  155         {"Not Initialized",             0x00}
  156 };
  157 
  158 struct mps_table_lookup mps_sasdisc_reason[] = {
  159         {"Discovery Started",           0x01},
  160         {"Discovery Complete",          0x02},
  161         {NULL, 0},
  162         {"Unknown",                     0x00}
  163 };
  164 
  165 struct mps_table_lookup mps_sastopo_exp[] = {
  166         {"Added",                       0x01},
  167         {"Not Responding",              0x02},
  168         {"Responding",                  0x03},
  169         {"Delay Not Responding",        0x04},
  170         {NULL, 0},
  171         {"Unknown",                     0x00}
  172 };
  173 
  174 struct mps_table_lookup mps_sasdev_reason[] = {
  175         {"SMART Data",                  0x05},
  176         {"Unsupported",                 0x07},
  177         {"Internal Device Reset",       0x08},
  178         {"Task Abort Internal",         0x09},
  179         {"Abort Task Set Internal",     0x0a},
  180         {"Clear Task Set Internal",     0x0b},
  181         {"Query Task Internal",         0x0c},
  182         {"Async Notification",          0x0d},
  183         {"Cmp Internal Device Reset",   0x0e},
  184         {"Cmp Task Abort Internal",     0x0f},
  185         {"Sata Init Failure",           0x10},
  186         {NULL, 0},
  187         {"Unknown",                     0x00}
  188 };
  189 
  190 struct mps_table_lookup mps_iocstatus_string[] = {
  191         {"success",                     MPI2_IOCSTATUS_SUCCESS},
  192         {"invalid function",            MPI2_IOCSTATUS_INVALID_FUNCTION},
  193         {"scsi recovered error",        MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR},
  194         {"scsi invalid dev handle",     MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE},
  195         {"scsi device not there",       MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE},
  196         {"scsi data overrun",           MPI2_IOCSTATUS_SCSI_DATA_OVERRUN},
  197         {"scsi data underrun",          MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN},
  198         {"scsi io data error",          MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR},
  199         {"scsi protocol error",         MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR},
  200         {"scsi task terminated",        MPI2_IOCSTATUS_SCSI_TASK_TERMINATED},
  201         {"scsi residual mismatch",      MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH},
  202         {"scsi task mgmt failed",       MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED},
  203         {"scsi ioc terminated",         MPI2_IOCSTATUS_SCSI_IOC_TERMINATED},
  204         {"scsi ext terminated",         MPI2_IOCSTATUS_SCSI_EXT_TERMINATED},
  205         {"eedp guard error",            MPI2_IOCSTATUS_EEDP_GUARD_ERROR},
  206         {"eedp ref tag error",          MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR},
  207         {"eedp app tag error",          MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR},
  208         {NULL, 0},
  209         {"unknown",                     0x00}
  210 };
  211 
  212 struct mps_table_lookup mps_scsi_status_string[] = {
  213         {"good",                        MPI2_SCSI_STATUS_GOOD},
  214         {"check condition",             MPI2_SCSI_STATUS_CHECK_CONDITION},
  215         {"condition met",               MPI2_SCSI_STATUS_CONDITION_MET},
  216         {"busy",                        MPI2_SCSI_STATUS_BUSY},
  217         {"intermediate",                MPI2_SCSI_STATUS_INTERMEDIATE},
  218         {"intermediate condmet",        MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET},
  219         {"reservation conflict",        MPI2_SCSI_STATUS_RESERVATION_CONFLICT},
  220         {"command terminated",          MPI2_SCSI_STATUS_COMMAND_TERMINATED},
  221         {"task set full",               MPI2_SCSI_STATUS_TASK_SET_FULL},
  222         {"aca active",                  MPI2_SCSI_STATUS_ACA_ACTIVE},
  223         {"task aborted",                MPI2_SCSI_STATUS_TASK_ABORTED},
  224         {NULL, 0},
  225         {"unknown",                     0x00}
  226 };
  227 
  228 struct mps_table_lookup mps_scsi_taskmgmt_string[] = {
  229         {"task mgmt request completed", MPI2_SCSITASKMGMT_RSP_TM_COMPLETE},
  230         {"invalid frame",               MPI2_SCSITASKMGMT_RSP_INVALID_FRAME},
  231         {"task mgmt request not supp",  MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED},
  232         {"task mgmt request failed",    MPI2_SCSITASKMGMT_RSP_TM_FAILED},
  233         {"task mgmt request_succeeded", MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED},
  234         {"invalid lun",                 MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN},
  235         {"overlapped tag attempt",      0xA},
  236         {"task queued on IOC",          MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC},
  237         {NULL, 0},
  238         {"unknown",                     0x00}
  239 };
  240 
  241 void
  242 mps_describe_devinfo(uint32_t devinfo, char *string, int len)
  243 {
  244         snprintf(string, len, "%b,%s", devinfo,
  245             "\2" "\4SataHost" "\5SmpInit" "\6StpInit" "\7SspInit"
  246             "\10SataDev" "\11SmpTarg" "\12StpTarg" "\13SspTarg" "\14Direct"
  247             "\15LsiDev" "\16AtapiDev" "\17SepDev",
  248             mps_describe_table(mps_sasdev0_devtype, devinfo & 0x03));
  249 }
  250 
  251 void
  252 mps_print_iocfacts(struct mps_softc *sc, MPI2_IOC_FACTS_REPLY *facts)
  253 {
  254 
  255         MPS_PRINTFIELD_START(sc, "IOCFacts");
  256         MPS_PRINTFIELD(sc, facts, MsgVersion, 0x%x);
  257         MPS_PRINTFIELD(sc, facts, HeaderVersion, 0x%x);
  258         MPS_PRINTFIELD(sc, facts, IOCNumber, %d);
  259         MPS_PRINTFIELD(sc, facts, IOCExceptions, 0x%x);
  260         MPS_PRINTFIELD(sc, facts, MaxChainDepth, %d);
  261         mps_print_field(sc, "WhoInit: %s\n",
  262             mps_describe_table(mps_whoinit_names, facts->WhoInit));
  263         MPS_PRINTFIELD(sc, facts, NumberOfPorts, %d);
  264         MPS_PRINTFIELD(sc, facts, MaxMSIxVectors, %d);
  265         MPS_PRINTFIELD(sc, facts, RequestCredit, %d);
  266         MPS_PRINTFIELD(sc, facts, ProductID, 0x%x);
  267         mps_print_field(sc, "IOCCapabilities: %b\n",
  268             facts->IOCCapabilities, "\2" "\3ScsiTaskFull" "\4DiagTrace"
  269             "\5SnapBuf" "\6ExtBuf" "\7EEDP" "\10BiDirTarg" "\11Multicast"
  270             "\14TransRetry" "\15IR" "\16EventReplay" "\17RaidAccel"
  271             "\20MSIXIndex" "\21HostDisc");
  272         mps_print_field(sc, "FWVersion= %d-%d-%d-%d\n",
  273             facts->FWVersion.Struct.Major,
  274             facts->FWVersion.Struct.Minor,
  275             facts->FWVersion.Struct.Unit,
  276             facts->FWVersion.Struct.Dev);
  277         MPS_PRINTFIELD(sc, facts, IOCRequestFrameSize, %d);
  278         MPS_PRINTFIELD(sc, facts, MaxInitiators, %d);
  279         MPS_PRINTFIELD(sc, facts, MaxTargets, %d);
  280         MPS_PRINTFIELD(sc, facts, MaxSasExpanders, %d);
  281         MPS_PRINTFIELD(sc, facts, MaxEnclosures, %d);
  282         mps_print_field(sc, "ProtocolFlags: %b\n",
  283             facts->ProtocolFlags, "\2" "\1ScsiTarg" "\2ScsiInit");
  284         MPS_PRINTFIELD(sc, facts, HighPriorityCredit, %d);
  285         MPS_PRINTFIELD(sc, facts, MaxReplyDescriptorPostQueueDepth, %d);
  286         MPS_PRINTFIELD(sc, facts, ReplyFrameSize, %d);
  287         MPS_PRINTFIELD(sc, facts, MaxVolumes, %d);
  288         MPS_PRINTFIELD(sc, facts, MaxDevHandle, %d);
  289         MPS_PRINTFIELD(sc, facts, MaxPersistentEntries, %d);
  290 }
  291 
  292 void
  293 mps_print_portfacts(struct mps_softc *sc, MPI2_PORT_FACTS_REPLY *facts)
  294 {
  295 
  296         MPS_PRINTFIELD_START(sc, "PortFacts");
  297         MPS_PRINTFIELD(sc, facts, PortNumber, %d);
  298         MPS_PRINTFIELD(sc, facts, PortType, 0x%x);
  299         MPS_PRINTFIELD(sc, facts, MaxPostedCmdBuffers, %d);
  300 }
  301 
  302 void
  303 mps_print_evt_generic(struct mps_softc *sc, MPI2_EVENT_NOTIFICATION_REPLY *event)
  304 {
  305 
  306         MPS_PRINTFIELD_START(sc, "EventReply");
  307         MPS_PRINTFIELD(sc, event, EventDataLength, %d);
  308         MPS_PRINTFIELD(sc, event, AckRequired, %d);
  309         mps_print_field(sc, "Event: %s (0x%x)\n",
  310             mps_describe_table(mps_event_names, event->Event), event->Event);
  311         MPS_PRINTFIELD(sc, event, EventContext, 0x%x);
  312 }
  313 
  314 void
  315 mps_print_sasdev0(struct mps_softc *sc, MPI2_CONFIG_PAGE_SAS_DEV_0 *buf)
  316 {
  317         MPS_PRINTFIELD_START(sc, "SAS Device Page 0");
  318         MPS_PRINTFIELD(sc, buf, Slot, %d);
  319         MPS_PRINTFIELD(sc, buf, EnclosureHandle, 0x%x);
  320         mps_print_field(sc, "SASAddress: 0x%jx\n",
  321             mps_to_u64(&buf->SASAddress));
  322         MPS_PRINTFIELD(sc, buf, ParentDevHandle, 0x%x);
  323         MPS_PRINTFIELD(sc, buf, PhyNum, %d);
  324         MPS_PRINTFIELD(sc, buf, AccessStatus, 0x%x);
  325         MPS_PRINTFIELD(sc, buf, DevHandle, 0x%x);
  326         MPS_PRINTFIELD(sc, buf, AttachedPhyIdentifier, 0x%x);
  327         MPS_PRINTFIELD(sc, buf, ZoneGroup, %d);
  328         mps_print_field(sc, "DeviceInfo: %b,%s\n", buf->DeviceInfo,
  329             "\2" "\4SataHost" "\5SmpInit" "\6StpInit" "\7SspInit"
  330             "\10SataDev" "\11SmpTarg" "\12StpTarg" "\13SspTarg" "\14Direct"
  331             "\15LsiDev" "\16AtapiDev" "\17SepDev",
  332             mps_describe_table(mps_sasdev0_devtype, buf->DeviceInfo & 0x03));
  333         MPS_PRINTFIELD(sc, buf, Flags, 0x%x);
  334         MPS_PRINTFIELD(sc, buf, PhysicalPort, %d);
  335         MPS_PRINTFIELD(sc, buf, MaxPortConnections, %d);
  336         mps_print_field(sc, "DeviceName: 0x%jx\n",
  337             mps_to_u64(&buf->DeviceName));
  338         MPS_PRINTFIELD(sc, buf, PortGroups, %d);
  339         MPS_PRINTFIELD(sc, buf, DmaGroup, %d);
  340         MPS_PRINTFIELD(sc, buf, ControlGroup, %d);
  341 }
  342 
  343 void
  344 mps_print_evt_sas(struct mps_softc *sc, MPI2_EVENT_NOTIFICATION_REPLY *event)
  345 {
  346 
  347         mps_print_evt_generic(sc, event);
  348 
  349         switch(event->Event) {
  350         case MPI2_EVENT_SAS_DISCOVERY:
  351         {
  352                 MPI2_EVENT_DATA_SAS_DISCOVERY *data;
  353 
  354                 data = (MPI2_EVENT_DATA_SAS_DISCOVERY *)&event->EventData;
  355                 mps_print_field(sc, "Flags: %b\n", data->Flags,
  356                     "\2" "\1InProgress" "\2DeviceChange");
  357                 mps_print_field(sc, "ReasonCode: %s\n",
  358                     mps_describe_table(mps_sasdisc_reason, data->ReasonCode));
  359                 MPS_PRINTFIELD(sc, data, PhysicalPort, %d);
  360                 mps_print_field(sc, "DiscoveryStatus: %b\n",
  361                     data->DiscoveryStatus,  "\2"
  362                     "\1Loop" "\2UnaddressableDev" "\3DupSasAddr" "\5SmpTimeout"
  363                     "\6ExpRouteFull" "\7RouteIndexError" "\10SmpFailed"
  364                     "\11SmpCrcError" "\12SubSubLink" "\13TableTableLink"
  365                     "\14UnsupDevice" "\15TableSubLink" "\16MultiDomain"
  366                     "\17MultiSub" "\20MultiSubSub" "\34DownstreamInit"
  367                     "\35MaxPhys" "\36MaxTargs" "\37MaxExpanders"
  368                     "\40MaxEnclosures");
  369                 break;
  370         }
  371         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
  372         {
  373                 MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *data;
  374                 MPI2_EVENT_SAS_TOPO_PHY_ENTRY *phy;
  375                 int i, phynum;
  376 
  377                 data = (MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *)
  378                     &event->EventData;
  379                 MPS_PRINTFIELD(sc, data, EnclosureHandle, 0x%x);
  380                 MPS_PRINTFIELD(sc, data, ExpanderDevHandle, 0x%x);
  381                 MPS_PRINTFIELD(sc, data, NumPhys, %d);
  382                 MPS_PRINTFIELD(sc, data, NumEntries, %d);
  383                 MPS_PRINTFIELD(sc, data, StartPhyNum, %d);
  384                 mps_print_field(sc, "ExpStatus: %s (0x%x)\n",
  385                     mps_describe_table(mps_sastopo_exp, data->ExpStatus),
  386                     data->ExpStatus);
  387                 MPS_PRINTFIELD(sc, data, PhysicalPort, %d);
  388                 for (i = 0; i < data->NumEntries; i++) {
  389                         phy = &data->PHY[i];
  390                         phynum = data->StartPhyNum + i;
  391                         mps_print_field(sc,
  392                             "PHY[%d].AttachedDevHandle: 0x%04x\n", phynum,
  393                             phy->AttachedDevHandle);
  394                         mps_print_field(sc,
  395                             "PHY[%d].LinkRate: %s (0x%x)\n", phynum,
  396                             mps_describe_table(mps_linkrate_names,
  397                             (phy->LinkRate >> 4) & 0xf), phy->LinkRate);
  398                         mps_print_field(sc, "PHY[%d].PhyStatus: %s\n",
  399                             phynum, mps_describe_table(mps_phystatus_names,
  400                             phy->PhyStatus));
  401                 }
  402                 break;
  403         }
  404         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
  405         {
  406                 MPI2_EVENT_DATA_SAS_ENCL_DEV_STATUS_CHANGE *data;
  407 
  408                 data = (MPI2_EVENT_DATA_SAS_ENCL_DEV_STATUS_CHANGE *)
  409                     &event->EventData;
  410                 MPS_PRINTFIELD(sc, data, EnclosureHandle, 0x%x);
  411                 mps_print_field(sc, "ReasonCode: %s\n",
  412                     mps_describe_table(mps_sastopo_exp, data->ReasonCode));
  413                 MPS_PRINTFIELD(sc, data, PhysicalPort, %d);
  414                 MPS_PRINTFIELD(sc, data, NumSlots, %d);
  415                 MPS_PRINTFIELD(sc, data, StartSlot, %d);
  416                 MPS_PRINTFIELD(sc, data, PhyBits, 0x%x);
  417                 break;
  418         }
  419         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
  420         {
  421                 MPI2_EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *data;
  422 
  423                 data = (MPI2_EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)
  424                     &event->EventData;
  425                 MPS_PRINTFIELD(sc, data, TaskTag, 0x%x);
  426                 mps_print_field(sc, "ReasonCode: %s\n",
  427                     mps_describe_table(mps_sasdev_reason, data->ReasonCode));
  428                 MPS_PRINTFIELD(sc, data, ASC, 0x%x);
  429                 MPS_PRINTFIELD(sc, data, ASCQ, 0x%x);
  430                 MPS_PRINTFIELD(sc, data, DevHandle, 0x%x);
  431                 mps_print_field(sc, "SASAddress: 0x%jx\n",
  432                     mps_to_u64(&data->SASAddress));
  433         }
  434         default:
  435                 break;
  436         }
  437 }
  438 
  439 void
  440 mps_print_expander1(struct mps_softc *sc, MPI2_CONFIG_PAGE_EXPANDER_1 *buf)
  441 {
  442         MPS_PRINTFIELD_START(sc, "SAS Expander Page 1 #%d", buf->Phy);
  443         MPS_PRINTFIELD(sc, buf, PhysicalPort, %d);
  444         MPS_PRINTFIELD(sc, buf, NumPhys, %d);
  445         MPS_PRINTFIELD(sc, buf, Phy, %d);
  446         MPS_PRINTFIELD(sc, buf, NumTableEntriesProgrammed, %d);
  447         mps_print_field(sc, "ProgrammedLinkRate: %s (0x%x)\n",
  448             mps_describe_table(mps_linkrate_names,
  449             (buf->ProgrammedLinkRate >> 4) & 0xf), buf->ProgrammedLinkRate);
  450         mps_print_field(sc, "HwLinkRate: %s (0x%x)\n",
  451             mps_describe_table(mps_linkrate_names,
  452             (buf->HwLinkRate >> 4) & 0xf), buf->HwLinkRate);
  453         MPS_PRINTFIELD(sc, buf, AttachedDevHandle, 0x%04x);
  454         mps_print_field(sc, "PhyInfo Reason: %s (0x%x)\n",
  455             mps_describe_table(mps_phyinfo_reason_names,
  456             (buf->PhyInfo >> 16) & 0xf), buf->PhyInfo);
  457         mps_print_field(sc, "AttachedDeviceInfo: %b,%s\n",
  458             buf->AttachedDeviceInfo, "\2" "\4SATAhost" "\5SMPinit" "\6STPinit"
  459             "\7SSPinit" "\10SATAdev" "\11SMPtarg" "\12STPtarg" "\13SSPtarg"
  460             "\14Direct" "\15LSIdev" "\16ATAPIdev" "\17SEPdev",
  461             mps_describe_table(mps_sasdev0_devtype,
  462             buf->AttachedDeviceInfo & 0x03));
  463         MPS_PRINTFIELD(sc, buf, ExpanderDevHandle, 0x%04x);
  464         MPS_PRINTFIELD(sc, buf, ChangeCount, %d);
  465         mps_print_field(sc, "NegotiatedLinkRate: %s (0x%x)\n",
  466             mps_describe_table(mps_linkrate_names,
  467             buf->NegotiatedLinkRate & 0xf), buf->NegotiatedLinkRate);
  468         MPS_PRINTFIELD(sc, buf, PhyIdentifier, %d);
  469         MPS_PRINTFIELD(sc, buf, AttachedPhyIdentifier, %d);
  470         MPS_PRINTFIELD(sc, buf, DiscoveryInfo, 0x%x);
  471         MPS_PRINTFIELD(sc, buf, AttachedPhyInfo, 0x%x);
  472         mps_print_field(sc, "AttachedPhyInfo Reason: %s (0x%x)\n",
  473             mps_describe_table(mps_phyinfo_reason_names,
  474             buf->AttachedPhyInfo & 0xf), buf->AttachedPhyInfo);
  475         MPS_PRINTFIELD(sc, buf, ZoneGroup, %d);
  476         MPS_PRINTFIELD(sc, buf, SelfConfigStatus, 0x%x);
  477 }
  478 
  479 void
  480 mps_print_sasphy0(struct mps_softc *sc, MPI2_CONFIG_PAGE_SAS_PHY_0 *buf)
  481 {
  482         MPS_PRINTFIELD_START(sc, "SAS PHY Page 0");
  483         MPS_PRINTFIELD(sc, buf, OwnerDevHandle, 0x%04x);
  484         MPS_PRINTFIELD(sc, buf, AttachedDevHandle, 0x%04x);
  485         MPS_PRINTFIELD(sc, buf, AttachedPhyIdentifier, %d);
  486         mps_print_field(sc, "AttachedPhyInfo Reason: %s (0x%x)\n",
  487             mps_describe_table(mps_phyinfo_reason_names,
  488             buf->AttachedPhyInfo & 0xf), buf->AttachedPhyInfo);
  489         mps_print_field(sc, "ProgrammedLinkRate: %s (0x%x)\n",
  490             mps_describe_table(mps_linkrate_names,
  491             (buf->ProgrammedLinkRate >> 4) & 0xf), buf->ProgrammedLinkRate);
  492         mps_print_field(sc, "HwLinkRate: %s (0x%x)\n",
  493             mps_describe_table(mps_linkrate_names,
  494             (buf->HwLinkRate >> 4) & 0xf), buf->HwLinkRate);
  495         MPS_PRINTFIELD(sc, buf, ChangeCount, %d);
  496         MPS_PRINTFIELD(sc, buf, Flags, 0x%x);
  497         mps_print_field(sc, "PhyInfo Reason: %s (0x%x)\n",
  498             mps_describe_table(mps_phyinfo_reason_names,
  499             (buf->PhyInfo >> 16) & 0xf), buf->PhyInfo);
  500         mps_print_field(sc, "NegotiatedLinkRate: %s (0x%x)\n",
  501             mps_describe_table(mps_linkrate_names,
  502             buf->NegotiatedLinkRate & 0xf), buf->NegotiatedLinkRate);
  503 }
  504 
  505 void
  506 mps_print_sgl(struct mps_softc *sc, struct mps_command *cm, int offset)
  507 {
  508         MPI2_SGE_SIMPLE64 *sge;
  509         MPI2_SGE_CHAIN32 *sgc;
  510         MPI2_REQUEST_HEADER *req;
  511         struct mps_chain *chain = NULL;
  512         char *frame;
  513         u_int i = 0, flags;
  514 
  515         req = (MPI2_REQUEST_HEADER *)cm->cm_req;
  516         frame = (char *)cm->cm_req;
  517         sge = (MPI2_SGE_SIMPLE64 *)&frame[offset * 4];
  518         printf("SGL for command %p\n", cm);
  519 
  520         hexdump(frame, 128, NULL, 0);
  521         while (frame != NULL) {
  522                 flags = le32toh(sge->FlagsLength) >> MPI2_SGE_FLAGS_SHIFT;
  523                 printf("seg%d flags=0x%02x len=0x%06x addr=0x%016jx\n",
  524                     i, flags, le32toh(sge->FlagsLength) & 0xffffff,
  525                     mps_to_u64(&sge->Address));
  526                 if (flags & (MPI2_SGE_FLAGS_END_OF_LIST |
  527                     MPI2_SGE_FLAGS_END_OF_BUFFER))
  528                         break;
  529                 sge++;
  530                 i++;
  531                 if (flags & MPI2_SGE_FLAGS_LAST_ELEMENT) {
  532                         sgc = (MPI2_SGE_CHAIN32 *)sge;
  533                         printf("chain flags=0x%x len=0x%x Offset=0x%x "
  534                             "Address=0x%x\n", sgc->Flags, le16toh(sgc->Length),
  535                             sgc->NextChainOffset, le32toh(sgc->Address));
  536                         if (chain == NULL)
  537                                 chain = TAILQ_FIRST(&cm->cm_chain_list);
  538                         else
  539                                 chain = TAILQ_NEXT(chain, chain_link);
  540                         frame = (char *)chain->chain;
  541                         sge = (MPI2_SGE_SIMPLE64 *)frame;
  542                         hexdump(frame, 128, NULL, 0);
  543                 }
  544         }
  545 }
  546 
  547 void
  548 mps_print_scsiio_cmd(struct mps_softc *sc, struct mps_command *cm)
  549 {
  550         MPI2_SCSI_IO_REQUEST *req;
  551 
  552         req = (MPI2_SCSI_IO_REQUEST *)cm->cm_req;
  553         mps_print_sgl(sc, cm, req->SGLOffset0);
  554 }
  555 

Cache object: 2925bfd17e32900e287ec0125f8a9076


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.