IntelFrameworkModulePkg/Bus/Pci/PciBusDxe/PciResourceSupport.h

   1 /**@file
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 **/
  13
  14 #ifndef _EFI_PCI_RESOURCE_SUPPORT_H
  15 #define _EFI_PCI_RESOURCE_SUPPORT_H
  16
  17 #define RESERVED_RESOURCE_SIGNATURE SIGNATURE_32 ('r', 's', 'v', 'd')
  18
  19 typedef struct {
  20   UINT64        Base;
  21   UINT64        Length;
  22   PCI_BAR_TYPE  ResType;
  23 } PCI_RESERVED_RESOURCE_NODE;
  24
  25 typedef struct {
  26   UINT32                      Signature;
  27   LIST_ENTRY                  Link;
  28   PCI_RESERVED_RESOURCE_NODE  Node;
  29 } PCI_RESERVED_RESOURCE_LIST;
  30
  31 #define RESOURCED_LIST_FROM_NODE(a) \
  32   CR (a, PCI_RESERVED_RESOURCE_LIST, Node, RESERVED_RESOURCE_SIGNATURE)
  33
  34 #define RESOURCED_LIST_FROM_LINK(a) \
  35   CR (a, PCI_RESERVED_RESOURCE_LIST, Link, RESERVED_RESOURCE_SIGNATURE)
  36
  37 typedef enum {
  38   PciResUsageTypical            = 0,
  39   PciResUsagePadding,
  40   PciResUsageOptionRomProcessing
  41 } PCI_RESOURCE_USAGE;
  42
  43 #define PCI_RESOURCE_SIGNATURE  SIGNATURE_32 ('p', 'c', 'r', 'c')
  44
  45 typedef struct {
  46   UINT32              Signature;
  47   LIST_ENTRY          Link;
  48   LIST_ENTRY          ChildList;
  49   PCI_IO_DEVICE       *PciDev;
  50   UINT64              Alignment;
  51   UINT64              Offset;
  52   UINT8               Bar;
  53   PCI_BAR_TYPE        ResType;
  54   UINT64              Length;
  55   BOOLEAN             Reserved;
  56   PCI_RESOURCE_USAGE  ResourceUsage;
  57 } PCI_RESOURCE_NODE;
  58
  59 #define RESOURCE_NODE_FROM_LINK(a) \
  60   CR (a, PCI_RESOURCE_NODE, Link, PCI_RESOURCE_SIGNATURE)
  61
  62 /**
  63   The function is used to skip VGA range
  64
  65   @param Start    address including VGA range
  66   @param Length   length of VGA range.
  67
  68   @retval EFI_SUCCESS success
  69 **/
  70 EFI_STATUS
  71 SkipVGAAperture (
  72   OUT UINT64   *Start,
  73   IN  UINT64   Length
  74   );
  75
  76 /**
  77   This function is used to skip ISA aliasing aperture
  78
  79   @param Start    address including ISA aliasing aperture
  80   @param Length   length of ISA aliasing aperture
  81
  82   @retval EFI_SUCCESS success
  83 **/
  84 EFI_STATUS
  85 SkipIsaAliasAperture (
  86   OUT UINT64   *Start,
  87   IN  UINT64   Length
  88   );
  89
  90 /**
  91   This function inserts a resource node into the resource list.
  92   The resource list is sorted in descend order.
  93
  94   @param Bridge  PCI resource node for bridge
  95   @param ResNode Resource node want to be inserted
  96
  97   @retval EFI_SUCCESS Success
  98 **/
  99 EFI_STATUS
 100 InsertResourceNode (
 101   PCI_RESOURCE_NODE *Bridge,
 102   PCI_RESOURCE_NODE *ResNode
 103   );
 104
 105 /**
 106
 107 Routine Description:
 108
 109   This routine is used to merge two different resource tree in need of
 110   resoure degradation. For example, if a upstream PPB doesn't support,
 111   prefetchable memory decoding, the PCI bus driver will choose to call this function
 112   to merge prefectchable memory resource list into normal memory list.
 113
 114   If the TypeMerge is TRUE, Res resource type is changed to the type of destination resource
 115   type.
 116
 117   @param Dst        Point to destination resource tree
 118   @param Res        Point to source resource tree
 119   @param TypeMerge  If the TypeMerge is TRUE, Res resource type is changed to the type of
 120                     destination resource type.
 121
 122
 123   @retval EFI_SUCCESS Success
 124 **/
 125 EFI_STATUS
 126 MergeResourceTree (
 127   PCI_RESOURCE_NODE *Dst,
 128   PCI_RESOURCE_NODE *Res,
 129   BOOLEAN           TypeMerge
 130   );
 131
 132 /**
 133   This function is used to calculate the IO16 aperture
 134   for a bridge.
 135
 136   @param Bridge PCI resource node for bridge.
 137
 138   @retval EFI_SUCCESS Success
 139 **/
 140 EFI_STATUS
 141 CalculateApertureIo16 (
 142   IN PCI_RESOURCE_NODE *Bridge
 143   );
 144
 145 /**
 146   This function is used to calculate the resource aperture
 147   for a given bridge device
 148
 149   @param Bridge Give bridge device
 150
 151   @retval EFI_SUCCESS Success
 152 **/
 153 EFI_STATUS
 154 CalculateResourceAperture (
 155   IN PCI_RESOURCE_NODE *Bridge
 156   );
 157
 158 /**
 159   Get IO/Memory resource infor for given PCI device
 160
 161   @param PciDev     Pci device instance
 162   @param IoNode     Resource info node for IO
 163   @param Mem32Node  Resource info node for 32-bit memory
 164   @param PMem32Node Resource info node for 32-bit PMemory
 165   @param Mem64Node  Resource info node for 64-bit memory
 166   @param PMem64Node Resource info node for 64-bit PMemory
 167
 168   @retval EFI_SUCCESS Success
 169 **/
 170 EFI_STATUS
 171 GetResourceFromDevice (
 172   PCI_IO_DEVICE     *PciDev,
 173   PCI_RESOURCE_NODE *IoNode,
 174   PCI_RESOURCE_NODE *Mem32Node,
 175   PCI_RESOURCE_NODE *PMem32Node,
 176   PCI_RESOURCE_NODE *Mem64Node,
 177   PCI_RESOURCE_NODE *PMem64Node
 178   );
 179
 180 /**
 181   This function is used to create a resource node
 182
 183   @param PciDev       Pci device instance
 184   @param Length       Length of Io/Memory resource
 185   @param Alignment    Alignment of resource
 186   @param Bar          Bar index
 187   @param ResType      Type of resource: IO/Memory
 188   @param ResUage      Resource usage
 189 **/
 190 PCI_RESOURCE_NODE *
 191 CreateResourceNode (
 192   IN PCI_IO_DEVICE         *PciDev,
 193   IN UINT64                Length,
 194   IN UINT64                Alignment,
 195   IN UINT8                 Bar,
 196   IN PCI_BAR_TYPE          ResType,
 197   IN PCI_RESOURCE_USAGE    ResUsage
 198   );
 199
 200 /**
 201   This routine is used to extract resource request from
 202   device node list.
 203
 204   @param Bridge     Pci device instance
 205   @param IoNode     Resource info node for IO
 206   @param Mem32Node  Resource info node for 32-bit memory
 207   @param PMem32Node Resource info node for 32-bit PMemory
 208   @param Mem64Node  Resource info node for 64-bit memory
 209   @param PMem64Node Resource info node for 64-bit PMemory
 210
 211   @retval EFI_SUCCESS Success
 212 **/
 213 EFI_STATUS
 214 CreateResourceMap (
 215   IN PCI_IO_DEVICE     *Bridge,
 216   IN PCI_RESOURCE_NODE *IoNode,
 217   IN PCI_RESOURCE_NODE *Mem32Node,
 218   IN PCI_RESOURCE_NODE *PMem32Node,
 219   IN PCI_RESOURCE_NODE *Mem64Node,
 220   IN PCI_RESOURCE_NODE *PMem64Node
 221   );
 222
 223 /**
 224   This function is used to do the resource padding for a specific platform
 225
 226   @param Bridge     Pci device instance
 227   @param IoNode     Resource info node for IO
 228   @param Mem32Node  Resource info node for 32-bit memory
 229   @param PMem32Node Resource info node for 32-bit PMemory
 230   @param Mem64Node  Resource info node for 64-bit memory
 231   @param PMem64Node Resource info node for 64-bit PMemory
 232
 233   @retval EFI_SUCCESS Success
 234 **/
 235 EFI_STATUS
 236 ResourcePaddingPolicy (
 237   PCI_IO_DEVICE     *PciDev,
 238   PCI_RESOURCE_NODE *IoNode,
 239   PCI_RESOURCE_NODE *Mem32Node,
 240   PCI_RESOURCE_NODE *PMem32Node,
 241   PCI_RESOURCE_NODE *Mem64Node,
 242   PCI_RESOURCE_NODE *PMem64Node
 243   );
 244
 245 /**
 246   This function is used to degrade resource if the upstream bridge
 247   doesn't support certain resource. Degradation path is
 248   PMEM64 -> MEM64  -> MEM32
 249   PMEM64 -> PMEM32 -> MEM32
 250   IO32   -> IO16
 251
 252   @param Bridge     Pci device instance
 253   @param IoNode     Resource info node for IO
 254   @param Mem32Node  Resource info node for 32-bit memory
 255   @param PMem32Node Resource info node for 32-bit PMemory
 256   @param Mem64Node  Resource info node for 64-bit memory
 257   @param PMem64Node Resource info node for 64-bit PMemory
 258
 259   @retval EFI_SUCCESS Success
 260 **/
 261 EFI_STATUS
 262 DegradeResource (
 263   IN PCI_IO_DEVICE     *Bridge,
 264   IN PCI_RESOURCE_NODE *Mem32Node,
 265   IN PCI_RESOURCE_NODE *PMem32Node,
 266   IN PCI_RESOURCE_NODE *Mem64Node,
 267   IN PCI_RESOURCE_NODE *PMem64Node
 268   );
 269
 270 /**
 271   Test whether bridge device support decode resource
 272
 273   @param Bridge    Bridge device instance
 274   @param Decode    Decode type according to resource type
 275
 276   @return whether bridge device support decode resource
 277
 278 **/
 279 BOOLEAN
 280 BridgeSupportResourceDecode (
 281   IN PCI_IO_DEVICE *Bridge,
 282   IN UINT32        Decode
 283   );
 284
 285 /**
 286   This function is used to program the resource allocated
 287   for each resource node
 288
 289
 290   @param Base     Base address of resource
 291   @param Bridge   Bridge device instance
 292
 293   @retval EFI_SUCCESS Success
 294 **/
 295 EFI_STATUS
 296 ProgramResource (
 297   IN UINT64            Base,
 298   IN PCI_RESOURCE_NODE *Bridge
 299   );
 300
 301 /**
 302   Program Bar register.
 303
 304   @param Base  Base address for resource
 305   @param Node  Point to resoure node structure
 306
 307   @retval EFI_SUCCESS Success
 308 **/
 309 EFI_STATUS
 310 ProgramBar (
 311   IN UINT64            Base,
 312   IN PCI_RESOURCE_NODE *Node
 313   );
 314
 315 /**
 316   Program PPB apperture
 317
 318   @param Base  Base address for resource
 319   @param Node  Point to resoure node structure
 320
 321   @retval EFI_SUCCESS Success
 322 **/
 323 EFI_STATUS
 324 ProgramPpbApperture (
 325   IN UINT64            Base,
 326   IN PCI_RESOURCE_NODE *Node
 327   );
 328
 329 /**
 330   Program parent bridge for oprom
 331
 332   @param PciDevice      Pci deivce instance
 333   @param OptionRomBase  Base address for oprom
 334   @param Enable         Enable/Disable
 335
 336   @retval EFI_SUCCESS Success
 337 **/
 338 EFI_STATUS
 339 ProgrameUpstreamBridgeForRom (
 340   IN PCI_IO_DEVICE   *PciDevice,
 341   IN UINT32          OptionRomBase,
 342   IN BOOLEAN         Enable
 343   );
 344
 345 /**
 346   Test whether resource exists for a bridge
 347
 348   @param Bridge  Point to resource node for a bridge
 349
 350   @return whether resource exists
 351 **/
 352 BOOLEAN
 353 ResourceRequestExisted (
 354   IN PCI_RESOURCE_NODE *Bridge
 355   );
 356
 357 /**
 358   Initialize resource pool structure.
 359
 360   @param ResourcePool Point to resource pool structure
 361   @param ResourceType Type of resource
 362 **/
 363 EFI_STATUS
 364 InitializeResourcePool (
 365   PCI_RESOURCE_NODE   *ResourcePool,
 366   PCI_BAR_TYPE        ResourceType
 367   );
 368
 369 /**
 370   Get all resource information for given Pci device
 371
 372   @param PciDev         Pci device instance
 373   @param IoBridge       Io resource node
 374   @param Mem32Bridge    32-bit memory node
 375   @param PMem32Bridge   32-bit Pmemory node
 376   @param Mem64Bridge    64-bit memory node
 377   @param PMem64Bridge   64-bit PMemory node
 378   @param IoPool         Link list header for Io resource
 379   @param Mem32Pool      Link list header for 32-bit memory
 380   @param PMem32Pool     Link list header for 32-bit Pmemory
 381   @param Mem64Pool      Link list header for 64-bit memory
 382   @param PMem64Pool     Link list header for 64-bit Pmemory
 383
 384   @retval EFI_SUCCESS Success
 385 **/
 386 EFI_STATUS
 387 GetResourceMap (
 388   PCI_IO_DEVICE      *PciDev,
 389   PCI_RESOURCE_NODE  **IoBridge,
 390   PCI_RESOURCE_NODE  **Mem32Bridge,
 391   PCI_RESOURCE_NODE  **PMem32Bridge,
 392   PCI_RESOURCE_NODE  **Mem64Bridge,
 393   PCI_RESOURCE_NODE  **PMem64Bridge,
 394   PCI_RESOURCE_NODE  *IoPool,
 395   PCI_RESOURCE_NODE  *Mem32Pool,
 396   PCI_RESOURCE_NODE  *PMem32Pool,
 397   PCI_RESOURCE_NODE  *Mem64Pool,
 398   PCI_RESOURCE_NODE  *PMem64Pool
 399   );
 400
 401 /**
 402   Destory given resource tree
 403
 404   @param Bridge  root node of resource tree
 405
 406   @retval EFI_SUCCESS Success
 407 **/
 408 EFI_STATUS
 409 DestroyResourceTree (
 410   IN PCI_RESOURCE_NODE *Bridge
 411   );
 412
 413 /**
 414   Record the reserved resource and insert to reserved list.
 415
 416   @param Base     Base address of reserved resourse
 417   @param Length   Length of reserved resource
 418   @param ResType  Resource type
 419   @param Bridge   Pci device instance
 420 **/
 421 EFI_STATUS
 422 RecordReservedResource (
 423   IN UINT64         Base,
 424   IN UINT64         Length,
 425   IN PCI_BAR_TYPE   ResType,
 426   IN PCI_IO_DEVICE  *Bridge
 427   );
 428
 429 /**
 430   Insert resource padding for P2C
 431
 432   @param PciDev     Pci device instance
 433   @param IoNode     Resource info node for IO
 434   @param Mem32Node  Resource info node for 32-bit memory
 435   @param PMem32Node Resource info node for 32-bit PMemory
 436   @param Mem64Node  Resource info node for 64-bit memory
 437   @param PMem64Node Resource info node for 64-bit PMemory
 438
 439   @retval EFI_SUCCESS Success
 440 **/
 441 EFI_STATUS
 442 ResourcePaddingForCardBusBridge (
 443   PCI_IO_DEVICE     *PciDev,
 444   PCI_RESOURCE_NODE *IoNode,
 445   PCI_RESOURCE_NODE *Mem32Node,
 446   PCI_RESOURCE_NODE *PMem32Node,
 447   PCI_RESOURCE_NODE *Mem64Node,
 448   PCI_RESOURCE_NODE *PMem64Node
 449   );
 450
 451 /**
 452   Program P2C register for given resource node
 453
 454   @param Base    Base address of P2C device
 455   @param Node    Given resource node.
 456
 457   @retval EFI_SUCCESS Success
 458 **/
 459 EFI_STATUS
 460 ProgramP2C (
 461   IN UINT64            Base,
 462   IN PCI_RESOURCE_NODE *Node
 463   );
 464
 465 /**
 466   Create padding resource node.
 467
 468   @param PciDev     Pci device instance
 469   @param IoNode     Resource info node for IO
 470   @param Mem32Node  Resource info node for 32-bit memory
 471   @param PMem32Node Resource info node for 32-bit PMemory
 472   @param Mem64Node  Resource info node for 64-bit memory
 473   @param PMem64Node Resource info node for 64-bit PMemory
 474
 475   @retval EFI_SUCCESS Success
 476
 477 **/
 478 EFI_STATUS
 479 ApplyResourcePadding (
 480   PCI_IO_DEVICE     *PciDev,
 481   PCI_RESOURCE_NODE *IoNode,
 482   PCI_RESOURCE_NODE *Mem32Node,
 483   PCI_RESOURCE_NODE *PMem32Node,
 484   PCI_RESOURCE_NODE *Mem64Node,
 485   PCI_RESOURCE_NODE *PMem64Node
 486   );
 487
 488 /**
 489   Get padding resource for PPB
 490   Light PCI bus driver woundn't support hotplug root device
 491   So no need to pad resource for them
 492
 493   @param   PciIoDevice Pci device instance
 494 **/
 495 VOID
 496 GetResourcePaddingPpb (
 497   IN  PCI_IO_DEVICE                  *PciIoDevice
 498   );
 499
 500 /**
 501   Reset and all bus number from specific bridge.
 502
 503   @param Bridge           Parent specific bridge
 504   @param StartBusNumber   start bus number
 505 **/
 506 EFI_STATUS
 507 ResetAllPpbBusNumber (
 508   IN PCI_IO_DEVICE                      *Bridge,
 509   IN UINT8                              StartBusNumber
 510   );
 511
 512 #endif