src/northbridge/amd/amdht/h3finit.h

   1 /*
   2  * This file is part of the LinuxBIOS project.
   3  *
   4  * Copyright (C) 2007 Advanced Micro Devices, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  */
  19
  20 #ifndef H3FINIT_H
  21 #define H3FINIT_H
  22
  23 /*----------------------------------------------------------------------------
  24  *      Mixed (DEFINITIONS AND MACROS / TYPEDEFS, STRUCTURES, ENUMS)
  25  *
  26  *----------------------------------------------------------------------------
  27  */
  28
  29 /*-----------------------------------------------------------------------------
  30  *                      DEFINITIONS AND MACROS
  31  *
  32  *-----------------------------------------------------------------------------
  33  */
  34
  35 /* Width equates for call backs */
  36 #define HT_WIDTH_8_BITS 8
  37 #define HT_WIDTH_16_BITS        16
  38 #define HT_WIDTH_4_BITS 4
  39 #define HT_WIDTH_2_BITS 2
  40
  41 /* Frequency equates for call backs which take an actual frequency setting */
  42 #define HT_FREQUENCY_200M       0
  43 #define HT_FREQUENCY_400M       2
  44 #define HT_FREQUENCY_600M       4
  45 #define HT_FREQUENCY_800M       5
  46 #define HT_FREQUENCY_1000M      6
  47 #define HT_FREQUENCY_1200M      7
  48 #define HT_FREQUENCY_1400M      8
  49 #define HT_FREQUENCY_1600M      9
  50 #define HT_FREQUENCY_1800M      10
  51 #define HT_FREQUENCY_2000M      11
  52 #define HT_FREQUENCY_2200M      12
  53 #define HT_FREQUENCY_2400M      13
  54 #define HT_FREQUENCY_2600M      14
  55
  56 /* Frequency Limit equates for call backs which take a frequency supported mask. */
  57 #define HT_FREQUENCY_LIMIT_200M 1
  58 #define HT_FREQUENCY_LIMIT_400M 7
  59 #define HT_FREQUENCY_LIMIT_600M 0x1F
  60 #define HT_FREQUENCY_LIMIT_800M 0x3F
  61 #define HT_FREQUENCY_LIMIT_1000M        0x7F
  62 #define HT_FREQUENCY_LIMIT_HT1_ONLY     0x7F
  63 #define HT_FREQUENCY_LIMIT_1200M        0xFF
  64 #define HT_FREQUENCY_LIMIT_1400M        0x1FF
  65 #define HT_FREQUENCY_LIMIT_1600M        0x3FF
  66 #define HT_FREQUENCY_LIMIT_1800M        0x7FF
  67 #define HT_FREQUENCY_LIMIT_2000M        0xFFF
  68 #define HT_FREQUENCY_LIMIT_2200M        0x1FFF
  69 #define HT_FREQUENCY_LIMIT_2400M        0x3FFF
  70 #define HT_FREQUENCY_LIMIT_2600M        0x7FFF
  71
  72 /*
  73  * Event Notify definitions
  74  */
  75
  76 /* Event Class definitions */
  77 #define HT_EVENT_CLASS_CRITICAL 1
  78 #define HT_EVENT_CLASS_ERROR            2
  79 #define HT_EVENT_CLASS_HW_FAULT 3
  80 #define HT_EVENT_CLASS_WARNING          4
  81 #define HT_EVENT_CLASS_INFO             5
  82
  83 /* Event definitions. */
  84
  85 /* Coherent subfunction events */
  86 #define HT_EVENT_COH_EVENTS             0x1000
  87 #define HT_EVENT_COH_NO_TOPOLOGY        0x1001
  88 #define HT_EVENT_COH_LINK_EXCEED        0x1002
  89 #define HT_EVENT_COH_FAMILY_FEUD        0x1003
  90 #define HT_EVENT_COH_NODE_DISCOVERED    0x1004
  91 #define HT_EVENT_COH_MPCAP_MISMATCH     0x1005
  92
  93 /* Non-coherent subfunction events */
  94 #define HT_EVENT_NCOH_EVENTS            0x2000
  95 #define HT_EVENT_NCOH_BUID_EXCEED       0x2001
  96 #define HT_EVENT_NCOH_LINK_EXCEED       0x2002
  97 #define HT_EVENT_NCOH_BUS_MAX_EXCEED    0x2003
  98 #define HT_EVENT_NCOH_CFG_MAP_EXCEED    0x2004
  99 #define HT_EVENT_NCOH_DEVICE_FAILED     0x2005
 100 #define HT_EVENT_NCOH_AUTO_DEPTH        0x2006
 101
 102 /* Optimization subfunction events */
 103 #define HT_EVENT_OPT_EVENTS                     0x3000
 104 #define HT_EVENT_OPT_REQUIRED_CAP_RETRY 0x3001
 105 #define HT_EVENT_OPT_REQUIRED_CAP_GEN3          0x3002
 106
 107 /* HW Fault events */
 108 #define HT_EVENT_HW_EVENTS      0x4000
 109 #define HT_EVENT_HW_SYNCHFLOOD  0x4001
 110 #define HT_EVENT_HW_HTCRC       0x4002
 111
 112 /* The bbHT component (hb*) uses 0x5000 for events.
 113  * For consistency, we avoid that range here.
 114  */
 115
 116 /*----------------------------------------------------------------------------
 117  *                      TYPEDEFS, STRUCTURES, ENUMS
 118  *
 119  *----------------------------------------------------------------------------
 120  */
 121
 122 typedef struct {
 123         u8 **topolist;
 124         u8 AutoBusStart;
 125         /* Note: This should always be the form AutoBusCurrent+N*AutoBusIncrement, also bus 253-255 are reserved */
 126         u8 AutoBusMax;
 127         u8 AutoBusIncrement;
 128
 129         /**----------------------------------------------------------------------------------------
 130          *
 131          * BOOL
 132          * AMD_CB_IgnoreLink(u8 Node, u8 Link)
 133          *
 134          * Description:
 135          *      This routine is called every time a coherent link is found and then every
 136          *      time a non-coherent link from a CPU is found.
 137          *      Any coherent or non-coherent link from a CPU can be ignored and not used
 138          *      for discovery or initialization.  Useful for connection based systems.
 139          *      (Note: not called for IO device to IO Device links.)
 140          *
 141          * Parameters:
 142          *      @param[in]   u8   node   = The node on which this link is located
 143          *      @param[in]   u8   link   = The link about to be initialized
 144          *      @param[out]  BOOL result = true to ignore this link and skip it
 145          *                                 false to initialize the link normally
 146          *
 147          * ---------------------------------------------------------------------------------------
 148          */
 149         BOOL (*AMD_CB_IgnoreLink)(u8 Node, u8 Link);
 150
 151         /**----------------------------------------------------------------------------------------
 152          *
 153          * BOOL
 154          * AMD_CB_OverrideBusNumbers(u8 Node, u8 Link, u8 *SecBus, u8 *SubBus)
 155          *
 156          * Description:
 157          *      This routine is called every time a non-coherent chain is processed.
 158          *      If a system can not use the auto Bus numbering feature for non-coherent chain bus
 159          *      assignments, this routine can provide explicit control.  For each chain, provide
 160          *      the bus number range to use.
 161          *
 162          * Parameters:
 163          *      @param[in]  u8   node   = The node on which this chain is located
 164          *      @param[in]  u8   link   = The link on the host for this chain
 165          *      @param[out] u8   secBus = Secondary Bus number for this non-coherent chain
 166          *      @param[out] u8*  subBus = Subordinate Bus number
 167          *      @param[out] BOOL result = true this routine is supplying the bus numbers
 168          *                                false use auto Bus numbering
 169          *
 170          * ---------------------------------------------------------------------------------------
 171          */
 172         BOOL (*AMD_CB_OverrideBusNumbers)(u8 Node, u8 Link, u8 *SecBus, u8 *SubBus);
 173
 174         /**----------------------------------------------------------------------------------------
 175          *
 176          * BOOL
 177          * AMD_CB_ManualBUIDSwapList(u8 Node, u8 Link, u8 **List)
 178          *
 179          * Description:
 180          *      This routine is called every time a non-coherent chain is processed.
 181          *      BUID assignment may be controlled explicitly on a non-coherent chain. Provide a
 182          *      swap list. The first part of the list controls the BUID assignment and the
 183          *      second part of the list provides the device to device linking.  Device orientation
 184          *      can be detected automatically, or explicitly.  See documentation for more details.
 185          *
 186          *      Automatic non-coherent init assigns BUIDs starting at 1 and incrementing sequentially
 187          *      based on each device's unit count.
 188          *
 189          * Parameters:
 190          *      @param[in]  u8  node    = The node on which this chain is located
 191          *      @param[in]  u8  link    = The link on the host for this chain
 192          *      @param[out] u8** list   = supply a pointer to a list
 193          *      @param[out] BOOL result = true to use a manual list
 194          *                                false to initialize the link automatically
 195          *
 196          * ---------------------------------------------------------------------------------------
 197          */
 198         BOOL (*AMD_CB_ManualBUIDSwapList)(u8 Node, u8 Link, u8 **List);
 199
 200         /**----------------------------------------------------------------------------------------
 201          *
 202          * void
 203          * AMD_CB_DeviceCapOverride(u8 HostNode, u8 HostLink, u8 Depth, u8 Segment,
 204          *                                u8 Bus, u8 Dev, u32 DevVenID, u8 Link,
 205          *                                u8 *LinkWidthIn, u8 *LinkWidthOut, u16 *FreqCap)
 206          *
 207          * Description:
 208          *      This routine is called once for every link on every IO device.
 209          *      Update the width and frequency capability if needed for this device.
 210          *      This is used along with device capabilities, the limit call backs, and northbridge
 211          *      limits to compute the default settings.  The components of the device's PCI config
 212          *      address are provided, so its settings can be consulted if need be. The input width
 213          *      and frequency are the reported device capabilities.
 214          *
 215          * Parameters:
 216          *      @param[in]  u8  hostNode  = The node on which this chain is located
 217          *      @param[in]  u8  hostLink  = The link on the host for this chain
 218          *      @param[in]  u8  Depth     = The depth in the I/O chain from the Host
 219          *      @param[in]  u8  Segment   = The Device's PCI Bus Segment number
 220          *      @param[in]  u8  Bus       = The Device's PCI Bus number
 221          *      @param[in]  u8  Dev       = The Device's PCI device Number
 222          *      @param[in]  u32 DevVenID  = The Device's PCI Vendor + Device ID (offset 0x00)
 223          *      @param[in]  u8  Link      = The Device's link number (0 or 1)
 224          *      @param[in,out] u8*  LinkWidthIn  = modify to change the Link Witdh In
 225          *      @param[in,out] u8*  LinkWidthOut  = modify to change the Link Witdh Out
 226          *      @param[in,out] u16* FreqCap = modify to change the link's frequency capability
 227          *
 228          * ---------------------------------------------------------------------------------------
 229          */
 230         void (*AMD_CB_DeviceCapOverride)(
 231                 u8 HostNode,
 232                 u8 HostLink,
 233                 u8 Depth,
 234                 u8 Segment,
 235                 u8 Bus,
 236                 u8 Dev,
 237                 u32 DevVenID,
 238                 u8 Link,
 239                 u8 *LinkWidthIn,
 240                 u8 *LinkWidthOut,
 241                 u16 *FreqCap
 242         );
 243
 244         /**----------------------------------------------------------------------------------------
 245          *
 246          * void
 247          * AMD_CB_Cpu2CpuPCBLimits(u8 NodeA, u8 LinkA, u8 NodeB, u8 LinkB,
 248          *                               u8 *ABLinkWidthLimit, u8 *BALinkWidthLimit, u16 *PCBFreqCap)
 249          *
 250          * Description:
 251          *      For each coherent connection this routine is called once.
 252          *      Update the frequency and width if needed for this link (usually based on board
 253          *      restriction).  This is used with CPU device capabilities and northbridge limits
 254          *      to compute the default settings.  The input width and frequency are valid, but do
 255          *      not necessarily reflect the minimum setting that will be chosen.
 256          *
 257          * Parameters:
 258          *      @param[in]  u8  nodeA  = One node on which this link is located
 259          *      @param[in]  u8  linkA  = The link on this node
 260          *      @param[in]  u8  nodeB  = The other node on which this link is located
 261          *      @param[in]  u8  linkB  = The link on that node
 262          *      @param[in,out]  u8*  ABLinkWidthLimit = modify to change the Link Witdh In
 263          *      @param[in,out]  u8*  BALinkWidthLimit = modify to change the Link Witdh Out
 264          *      @param[in,out]  u16* PCBFreqCap  = modify to change the link's frequency capability
 265          *
 266          * ---------------------------------------------------------------------------------------
 267          */
 268         void (*AMD_CB_Cpu2CpuPCBLimits)(
 269                 u8 NodeA,
 270                 u8 LinkA,
 271                 u8 NodeB,
 272                 u8 LinkB,
 273                 u8 *ABLinkWidthLimit,
 274                 u8 *BALinkWidthLimit,
 275                 u16 *PCBFreqCap
 276         );
 277
 278         /**----------------------------------------------------------------------------------------
 279          *
 280          * void
 281          * AMD_CB_IOPCBLimits(u8 HostNode, u8 HostLink, u8 Depth, u8 *DownstreamLinkWidthLimit,
 282          *                          u8 *UpstreamLinkWidthLimit, u16 *PCBFreqCap)
 283          *
 284          * Description:
 285          *      For each non-coherent connection this routine is called once.
 286          *      Update the frequency and width if needed for this link (usually based on board
 287          *      restriction).  This is used with device capabilities, device overrides, and northbridge limits
 288          *      to compute the default settings. The input width and frequency are valid, but do
 289          *      not necessarily reflect the minimum setting that will be chosen.
 290          *
 291          * Parameters:
 292          *      @param[in]  u8  hostNode  = The node on which this link is located
 293          *      @param[in]  u8  hostLink  = The link about to be initialized
 294          *      @param[in]  u8  Depth  = The depth in the I/O chain from the Host
 295          *      @param[in,out]  u8* DownstreamLinkWidthLimit = modify to change the Link Witdh In
 296          *      @param[in,out]  u8* UpstreamLinkWidthLimit  = modify to change the Link Witdh Out
 297          *      @param[in,out]  u16* PCBFreqCap = modify to change the link's frequency capability
 298          *
 299          * ---------------------------------------------------------------------------------------
 300          */
 301         void (*AMD_CB_IOPCBLimits)(
 302                 u8 HostNode,
 303                 u8 HostLink,
 304                 u8 Depth,
 305                 u8 *DownstreamLinkWidthLimit,
 306                 u8 *UpstreamLinkWidthLimit,
 307                 u16 *PCBFreqCap
 308         );
 309
 310         /**----------------------------------------------------------------------------------------
 311          *
 312          * BOOL
 313          * AMD_CB_SkipRegang(u8 NodeA, u8 LinkA, u8 NodeB, u8 LinkB)
 314          *
 315          * Description:
 316          *      This routine is called whenever two sublinks are both connected to the same CPUs.
 317          *      Normally, unganged subsinks between the same two CPUs are reganged.
 318          *      Return true from this routine to leave the links unganged.
 319          *
 320          * Parameters:
 321          *      @param[in]  u8  nodeA   = One node on which this link is located
 322          *      @param[in]  u8  linkA   = The link on this node
 323          *      @param[in]  u8  nodeB   = The other node on which this link is located
 324          *      @param[in]  u8  linkB   = The link on that node
 325          *      @param[out] BOOL result = true to leave link unganged
 326          *                                false to regang link automatically
 327          *
 328          * ---------------------------------------------------------------------------------------
 329          */
 330         BOOL (*AMD_CB_SkipRegang)(
 331                 u8 NodeA,
 332                 u8 LinkA,
 333                 u8 NodeB,
 334                 u8 LinkB
 335         );
 336
 337         /**----------------------------------------------------------------------------------------
 338          *
 339          * BOOL
 340          * AMD_CB_CustomizeTrafficDistribution()
 341          *
 342          * Description:
 343          *      Near the end of HT initialization, this routine is called once.
 344          *      If this routine will handle traffic distribution in a proprietary way,
 345          *      after detecting which links to distribute traffic on and configuring the system,
 346          *      return true. Return false to let the HT code detect and do traffic distribution
 347          *      This routine can also be used to simply turn this feature off, or to pre-process
 348          *      the system before normal traffic distribution.
 349          *
 350          * Parameters:
 351          *      @param[out]  BOOL result  = true skip traffic distribution
 352          *                                  false do normal traffic distribution
 353          *
 354          * ---------------------------------------------------------------------------------------
 355          */
 356         BOOL (*AMD_CB_CustomizeTrafficDistribution)();
 357
 358
 359         /**----------------------------------------------------------------------------------------
 360          *
 361          * BOOL
 362          * AMD_CB_CustomizeBuffers(u8 Node)
 363          *
 364          * Description:
 365          *      Near the end of HT initialization, this routine is called once per CPU node.
 366          *      Implement proprietary buffer tuning and return true, or return false for normal tuning.
 367          *      This routine can also be used to simply turn this feature off, or to pre-process
 368          *      the system before normal tuning.
 369          *
 370          * Parameters:
 371          *      @param[in] u8 node  = buffer allocation may apply to this node
 372          *      @param[out] BOOL  result  = true skip buffer allocation on this node
 373          *                                  false tune buffers normally
 374          *
 375          * ---------------------------------------------------------------------------------------
 376          */
 377         BOOL (*AMD_CB_CustomizeBuffers)( u8 node );
 378
 379         /**----------------------------------------------------------------------------------------
 380          *
 381          * void
 382          * AMD_CB_OverrideDevicePort(u8 HostNode, u8 HostLink, u8 Depth, u8 *LinkWidthIn,
 383          *                                 u8 *LinkWidthOut, u16 *LinkFrequency)
 384          *
 385          * Description:
 386          *      Called once for each active link on each IO device.
 387          *      Provides an opportunity to directly control the frequency and width,
 388          *      intended for test and debug.  The input frequency and width will be used
 389          *      if not overridden.
 390          *
 391          * Parameters:
 392          *      @param[in]  u8   hostNode  = The node on which this link is located
 393          *      @param[in]  u8   hostLink  = The link about to be initialized
 394          *      @param[in]  u8   Depth     = The depth in the I/O chain from the Host
 395          *      @param[in]  u8   Link      = the link on the device (0 or 1)
 396          *      @param[in,out]  u8*   LinkWidthIn    = modify to change the Link Witdh In
 397          *      @param[in,out]  u8*   LinkWidthOut   = modify to change the Link Witdh Out
 398          *      @param[in,out]  u16*   LinkFrequency = modify to change the link's frequency capability
 399          *
 400          * ---------------------------------------------------------------------------------------
 401          */
 402         void (*AMD_CB_OverrideDevicePort)(
 403                 u8 HostNode,
 404                 u8 HostLink,
 405                 u8 Depth,
 406                 u8 Link,
 407                 u8 *LinkWidthIn,
 408                 u8 *LinkWidthOut,
 409                 u8 *LinkFrequency
 410         );
 411
 412         /**----------------------------------------------------------------------------------------
 413          *
 414          * void
 415          * AMD_CB_OverrideCpuPort(u8 Node, u8 Link, u8 *LinkWidthIn, u8 *LinkWidthOut,
 416          *                              u16 *LinkFrequency)
 417          *
 418          * Description:
 419          *      Called once for each active link on each CPU.
 420          *      Provides an opportunity to directly control the frequency and width,
 421          *      intended for test and debug. The input frequency and width will be used
 422          *      if not overridden.
 423          *
 424          * Parameters:
 425          *      @param[in]  u8  node  = One node on which this link is located
 426          *      @param[in]  u8  link  = The link on this node
 427          *      @param[in,out]  u8*  LinkWidthIn = modify to change the Link Witdh In
 428          *      @param[in,out]  u8*  LinkWidthOut = modify to change the Link Witdh Out
 429          *      @param[in,out]  u16*  LinkFrequency  = modify to change the link's frequency capability
 430          *
 431          *---------------------------------------------------------------------------------------
 432          */
 433         void (*AMD_CB_OverrideCpuPort)(
 434                 u8 Node,
 435                 u8 Link,
 436                 u8 *LinkWidthIn,
 437                 u8 *LinkWidthOut,
 438                 u8 *LinkFrequency
 439         );
 440
 441         /**----------------------------------------------------------------------------------------
 442          *
 443          * void
 444          * AMD_CB_EventNotify(u8 evtClass, u16 event, const u8 *pEventData0)
 445          *
 446          * Description:
 447          *      Errors, events, faults, warnings, and useful information are provided by
 448          *      calling this routine as often as necessary, once for each notification.
 449          *      See elsewhere in this file for class, event, and event data definitions.
 450          *      See the documentation for more details.
 451          *
 452          * Parameters:
 453          *      @param[in]  u8  evtClass = What level event is this
 454          *      @param[in]  u16 event = A unique ID of this event
 455          *      @param[in]  u8* pEventData0 = useful data associated with the event.
 456          *
 457          * ---------------------------------------------------------------------------------------
 458          */
 459         void (*AMD_CB_EventNotify) (
 460                 u8 evtClass,
 461                 u16 event,
 462                 const u8 *pEventData0
 463         );
 464
 465 } AMD_HTBLOCK;
 466
 467 /*
 468  * Event Notification Structures
 469  * These structures are passed to AMD_CB_EventNotify as *pEventData0.
 470  */
 471
 472 /* For event HT_EVENT_HW_SYNCHFLOOD */
 473 typedef struct
 474 {
 475         u8 eSize;
 476         u8 node;
 477         u8 link;
 478 } sHtEventHWSynchFlood;
 479
 480 /* For event HT_EVENT_HW_HTCRC */
 481 typedef struct
 482 {
 483         u8 eSize;
 484         u8 node;
 485         u8 link;
 486         u8 laneMask;
 487 } sHtEventHWHtCrc;
 488
 489 /* For event HT_EVENT_NCOH_BUS_MAX_EXCEED */
 490 typedef struct
 491 {
 492         u8 eSize;
 493         u8 node;
 494         u8 link;
 495         u8 bus;
 496 } sHTEventNcohBusMaxExceed;
 497
 498 /* For event HT_EVENT_NCOH_LINK_EXCEED */
 499 typedef struct
 500 {
 501         u8 eSize;
 502         u8 node;
 503         u8 link;
 504         u8 depth;
 505         u8 maxLinks;
 506 } sHtEventNcohLinkExceed;
 507
 508 /* For event HT_EVENT_NCOH_CFG_MAP_EXCEED */
 509 typedef struct
 510 {
 511         u8 eSize;
 512         u8 node;
 513         u8 link;
 514 } sHtEventNcohCfgMapExceed;
 515
 516 /* For event HT_EVENT_NCOH_BUID_EXCEED */
 517 typedef struct
 518 {
 519         u8 eSize;
 520         u8 node;
 521         u8 link;
 522         u8 depth;
 523         u8 currentBUID;
 524         u8 unitCount;
 525 } sHtEventNcohBuidExceed;
 526
 527 /* For event HT_EVENT_NCOH_DEVICE_FAILED */
 528 typedef struct
 529 {
 530         u8 eSize;
 531         u8 node;
 532         u8 link;
 533         u8 depth;
 534         u8 attemptedBUID;
 535 } sHtEventNcohDeviceFailed;
 536
 537 /* For event HT_EVENT_NCOH_AUTO_DEPTH */
 538 typedef struct
 539 {
 540         u8 eSize;
 541         u8 node;
 542         u8 link;
 543         u8 depth;
 544 } sHtEventNcohAutoDepth;
 545
 546 /* For event HT_EVENT_OPT_REQUIRED_CAP_RETRY,
 547  *            HT_EVENT_OPT_REQUIRED_CAP_GEN3
 548  */
 549 typedef struct
 550 {
 551         u8 eSize;
 552         u8 node;
 553         u8 link;
 554         u8 depth;
 555 } sHtEventOptRequiredCap;
 556
 557 /* For event HT_EVENT_COH_NO_TOPOLOGY */
 558 typedef struct
 559 {
 560         u8 eSize;
 561         u8 totalNodes;
 562 } sHtEventCohNoTopology;
 563
 564 /* For event HT_EVENT_COH_LINK_EXCEED */
 565 typedef struct
 566 {
 567         u8 eSize;
 568         u8 node;
 569         u8 link;
 570         u8 targetNode;
 571         u8 totalNodes;
 572         u8 maxLinks;
 573 } sHtEventCohLinkExceed;
 574
 575 /* For event HT_EVENT_COH_FAMILY_FEUD */
 576 typedef struct
 577 {
 578         u8 eSize;
 579         u8 node;
 580         u8 link;
 581         u8 totalNodes;
 582 } sHtEventCohFamilyFeud;
 583
 584 /* For event HT_EVENT_COH_NODE_DISCOVERED */
 585 typedef struct
 586 {
 587         u8 eSize;
 588         u8 node;
 589         u8 link;
 590         u8 newNode;
 591 } sHtEventCohNodeDiscovered;
 592
 593 /* For event HT_EVENT_COH_MPCAP_MISMATCH */
 594 typedef struct
 595 {
 596         u8 eSize;
 597         u8 node;
 598         u8 link;
 599         u8 sysMpCap;
 600         u8 totalNodes;
 601 } sHtEventCohMpCapMismatch;
 602
 603 /*----------------------------------------------------------------------------
 604  *                      FUNCTIONS PROTOTYPE
 605  *
 606  *----------------------------------------------------------------------------
 607  */
 608 void amdHtInitialize(AMD_HTBLOCK *pBlock);
 609
 610
 611 #endif   /* H3FINIT_H */
 612
 613