src/device/device_const.c

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2
   3 #include <assert.h>
   4 #include <console/console.h>
   5 #include <device/device.h>
   6 #include <device/pci_def.h>
   7 #include <device/pci_type.h>
   8 #include <fw_config.h>
   9 #include <types.h>
  10
  11 /** Linked list of ALL devices */
  12 DEVTREE_CONST struct device *DEVTREE_CONST all_devices = &dev_root;
  13
  14 /**
  15  * Given a PCI bus and a devfn number, find the device structure.
  16  *
  17  * Note that this function can return the incorrect device prior
  18  * to PCI enumeration because the secondary field of the bus object
  19  * is 0. The failing scenario is determined by the order of the
  20  * devices in all_devices singly-linked list as well as the time
  21  * when this function is called (secondary reflecting topology).
  22  *
  23  * @param bus The bus number.
  24  * @param devfn A device/function number.
  25  * @return Pointer to the device structure (if found), 0 otherwise.
  26  */
  27
  28 static DEVTREE_CONST struct device *dev_find_slot(unsigned int bus,
  29                                                 unsigned int devfn)
  30 {
  31         DEVTREE_CONST struct device *dev, *result;
  32
  33         result = 0;
  34         for (dev = all_devices; dev; dev = dev->next) {
  35                 if ((dev->path.type == DEVICE_PATH_PCI) &&
  36                     (dev->upstream->secondary == bus) &&
  37                     (dev->upstream->segment_group == 0) &&
  38                     (dev->path.pci.devfn == devfn)) {
  39                         result = dev;
  40                         break;
  41                 }
  42         }
  43         return result;
  44 }
  45
  46 /**
  47  * Given a Device Path Type, find the device structure.
  48  *
  49  * @param prev_match The previously matched device instance.
  50  * @param path_type The Device Path Type.
  51  * @return Pointer to the device structure (if found), 0 otherwise.
  52  */
  53 DEVTREE_CONST struct device *dev_find_path(
  54                 DEVTREE_CONST struct device *prev_match,
  55                 enum device_path_type path_type)
  56 {
  57         DEVTREE_CONST struct device *dev, *result = NULL;
  58
  59         if (prev_match == NULL)
  60                 prev_match = all_devices;
  61         else
  62                 prev_match = prev_match->next;
  63
  64         for (dev = prev_match; dev; dev = dev->next) {
  65                 if (dev->path.type == path_type) {
  66                         result = dev;
  67                         break;
  68                 }
  69         }
  70         return result;
  71 }
  72
  73 /**
  74  * Given a device pointer, find the next PCI device.
  75  *
  76  * @param previous_dev A pointer to a PCI device structure.
  77  * @return Pointer to the next device structure (if found), 0 otherwise.
  78  */
  79 DEVTREE_CONST struct device *dev_find_next_pci_device(
  80                 DEVTREE_CONST struct device *previous_dev)
  81 {
  82         return dev_find_path(previous_dev, DEVICE_PATH_PCI);
  83 }
  84
  85 static int path_eq(const struct device_path *path1,
  86                 const struct device_path *path2)
  87 {
  88         int equal = 0;
  89
  90         if (!path1 || !path2) {
  91                 assert(path1);
  92                 assert(path2);
  93                 /* Return 0 in case assert is considered non-fatal. */
  94                 return 0;
  95         }
  96
  97         if (path1->type != path2->type)
  98                 return 0;
  99
 100         switch (path1->type) {
 101         case DEVICE_PATH_NONE:
 102                 break;
 103         case DEVICE_PATH_ROOT:
 104                 equal = 1;
 105                 break;
 106         case DEVICE_PATH_PCI:
 107                 equal = (path1->pci.devfn == path2->pci.devfn);
 108                 break;
 109         case DEVICE_PATH_PNP:
 110                 equal = (path1->pnp.port == path2->pnp.port) &&
 111                         (path1->pnp.device == path2->pnp.device);
 112                 break;
 113         case DEVICE_PATH_I2C:
 114                 equal = (path1->i2c.device == path2->i2c.device) &&
 115                         (path1->i2c.mode_10bit == path2->i2c.mode_10bit);
 116                 break;
 117         case DEVICE_PATH_APIC:
 118                 equal = (path1->apic.apic_id == path2->apic.apic_id);
 119                 break;
 120         case DEVICE_PATH_DOMAIN:
 121                 equal = (path1->domain.domain == path2->domain.domain);
 122                 break;
 123         case DEVICE_PATH_CPU_CLUSTER:
 124                 equal = (path1->cpu_cluster.cluster
 125                          == path2->cpu_cluster.cluster);
 126                 break;
 127         case DEVICE_PATH_CPU:
 128                 equal = (path1->cpu.id == path2->cpu.id);
 129                 break;
 130         case DEVICE_PATH_CPU_BUS:
 131                 equal = (path1->cpu_bus.id == path2->cpu_bus.id);
 132                 break;
 133         case DEVICE_PATH_GENERIC:
 134                 equal = (path1->generic.id == path2->generic.id) &&
 135                         (path1->generic.subid == path2->generic.subid);
 136                 break;
 137         case DEVICE_PATH_SPI:
 138                 equal = (path1->spi.cs == path2->spi.cs);
 139                 break;
 140         case DEVICE_PATH_USB:
 141                 equal = (path1->usb.port_type == path2->usb.port_type) &&
 142                         (path1->usb.port_id == path2->usb.port_id);
 143                 break;
 144         case DEVICE_PATH_MMIO:
 145                 equal = (path1->mmio.addr == path2->mmio.addr);
 146                 break;
 147         case DEVICE_PATH_GPIO:
 148                 equal = (path1->gpio.id == path2->gpio.id);
 149                 break;
 150         case DEVICE_PATH_MDIO:
 151                 equal = (path1->mdio.addr == path2->mdio.addr);
 152                 break;
 153
 154         default:
 155                 printk(BIOS_ERR, "Unknown device type: %d\n", path1->type);
 156                 break;
 157         }
 158
 159         return equal;
 160 }
 161
 162 /**
 163  * See if a device structure exists for path.
 164  *
 165  * @param parent The bus to find the device on.
 166  * @param path The relative path from the bus to the appropriate device.
 167  * @return Pointer to a device structure for the device on bus at path
 168  *         or 0/NULL if no device is found.
 169  */
 170 DEVTREE_CONST struct device *find_dev_path(
 171         const struct bus *parent, const struct device_path *path)
 172 {
 173         DEVTREE_CONST struct device *child;
 174
 175         if (!parent) {
 176                 BUG();
 177                 /* Return NULL in case asserts are considered non-fatal. */
 178                 return NULL;
 179         }
 180
 181         for (child = parent->children; child; child = child->sibling) {
 182                 if (path_eq(path, &child->path))
 183                         break;
 184         }
 185         return child;
 186 }
 187
 188 /**
 189  * Find the device structure given an array of nested device paths,
 190  *
 191  * @param parent The parent bus to start the search on.
 192  * @param nested_path An array of relative paths from the parent bus to the target device.
 193  * @param nested_path_length Number of path elements in nested_path array.
 194  * @return Pointer to a device structure for the device at nested path
 195  *         or 0/NULL if no device is found.
 196  */
 197 DEVTREE_CONST struct device *find_dev_nested_path(
 198         const struct bus *parent, const struct device_path nested_path[],
 199         size_t nested_path_length)
 200 {
 201         DEVTREE_CONST struct device *child;
 202
 203         if (!parent || !nested_path || !nested_path_length)
 204                 return NULL;
 205
 206         child = find_dev_path(parent, nested_path);
 207
 208         /* Terminate recursion at end of nested path or child not found */
 209         if (nested_path_length == 1 || !child)
 210                 return child;
 211
 212         return find_dev_nested_path(child->downstream, nested_path + 1, nested_path_length - 1);
 213 }
 214
 215 DEVTREE_CONST struct device *pcidev_path_behind(
 216         const struct bus *parent, pci_devfn_t devfn)
 217 {
 218         const struct device_path path = {
 219                 .type = DEVICE_PATH_PCI,
 220                 .pci.devfn = devfn,
 221         };
 222         return find_dev_path(parent, &path);
 223 }
 224
 225 DEVTREE_CONST struct device *pcidev_path_on_bus(unsigned int bus, pci_devfn_t devfn)
 226 {
 227         DEVTREE_CONST struct bus *parent = pci_root_bus();
 228         DEVTREE_CONST struct device *dev = parent->children;
 229
 230         /* FIXME: Write the loop with topology links. */
 231         while (dev) {
 232                 if (dev->path.type != DEVICE_PATH_PCI) {
 233                         dev = dev->next;
 234                         continue;
 235                 }
 236                 if (dev->upstream->secondary == bus && dev->upstream->segment_group == 0)
 237                         return pcidev_path_behind(dev->upstream, devfn);
 238                 dev = dev->next;
 239         }
 240         return NULL;
 241 }
 242
 243 DEVTREE_CONST struct bus *pci_root_bus(void)
 244 {
 245         DEVTREE_CONST struct device *pci_domain;
 246         static DEVTREE_CONST struct bus *pci_root;
 247
 248         if (pci_root)
 249                 return pci_root;
 250
 251         pci_domain = dev_find_path(NULL, DEVICE_PATH_DOMAIN);
 252         if (!pci_domain)
 253                 return NULL;
 254
 255         pci_root = pci_domain->downstream;
 256         return pci_root;
 257 }
 258
 259 DEVTREE_CONST struct device *pcidev_path_on_root(pci_devfn_t devfn)
 260 {
 261         return pcidev_path_behind(pci_root_bus(), devfn);
 262 }
 263
 264 DEVTREE_CONST struct device *pcidev_on_root(uint8_t dev, uint8_t fn)
 265 {
 266         return pcidev_path_on_root(PCI_DEVFN(dev, fn));
 267 }
 268
 269 DEVTREE_CONST struct device *pcidev_path_behind_pci2pci_bridge(
 270                                                         const struct device *bridge,
 271                                                         pci_devfn_t devfn)
 272 {
 273         if (!bridge || (bridge->path.type != DEVICE_PATH_PCI)) {
 274                 BUG();
 275                 /* Return NULL in case asserts are non-fatal. */
 276                 return NULL;
 277         }
 278
 279         return pcidev_path_behind(bridge->downstream, devfn);
 280 }
 281
 282 DEVTREE_CONST struct device *pcidev_path_on_root_debug(pci_devfn_t devfn, const char *func)
 283 {
 284         DEVTREE_CONST struct device *dev = pcidev_path_on_root(devfn);
 285         if (dev)
 286                 return dev;
 287
 288         devtree_bug(func, devfn);
 289
 290         /* FIXME: This can return wrong device. */
 291         return dev_find_slot(0, devfn);
 292 }
 293
 294 void devtree_bug(const char *func, pci_devfn_t devfn)
 295 {
 296         printk(BIOS_ERR, "BUG: %s requests hidden 00:%02x.%u\n", func, devfn >> 3, devfn & 7);
 297 }
 298
 299 void __noreturn devtree_die(void)
 300 {
 301         die("DEVTREE: dev or chip_info is NULL\n");
 302 }
 303
 304 /**
 305  * Given an SMBus bus and a device number, find the device structure.
 306  *
 307  * @param bus The bus number.
 308  * @param addr A device number.
 309  * @return Pointer to the device structure (if found), 0 otherwise.
 310  */
 311 DEVTREE_CONST struct device *dev_find_slot_on_smbus(unsigned int bus,
 312                                                         unsigned int addr)
 313 {
 314         DEVTREE_CONST struct device *dev, *result;
 315
 316         result = 0;
 317         for (dev = all_devices; dev; dev = dev->next) {
 318                 if ((dev->path.type == DEVICE_PATH_I2C) &&
 319                     (dev->upstream->secondary == bus) &&
 320                     (dev->path.i2c.device == addr)) {
 321                         result = dev;
 322                         break;
 323                 }
 324         }
 325         return result;
 326 }
 327
 328 /**
 329  * Given a PnP port and a device number, find the device structure.
 330  *
 331  * @param port The I/O port.
 332  * @param device Logical device number.
 333  * @return Pointer to the device structure (if found), 0 otherwise.
 334  */
 335 DEVTREE_CONST struct device *dev_find_slot_pnp(u16 port, u16 device)
 336 {
 337         DEVTREE_CONST struct device *dev;
 338
 339         for (dev = all_devices; dev; dev = dev->next) {
 340                 if ((dev->path.type == DEVICE_PATH_PNP) &&
 341                     (dev->path.pnp.port == port) &&
 342                     (dev->path.pnp.device == device)) {
 343                         return dev;
 344                 }
 345         }
 346         return 0;
 347 }
 348
 349 /**
 350  * Given a device and previous match iterate through all the children.
 351  *
 352  * @param bus parent device's bus holding all the children
 353  * @param prev_child previous child already traversed, if NULL start at
 354  *        children of parent bus.
 355  * @return pointer to child or NULL when no more children
 356  */
 357 DEVTREE_CONST struct device *dev_bus_each_child(const struct bus *parent,
 358                                         DEVTREE_CONST struct device *prev_child)
 359 {
 360         DEVTREE_CONST struct device *dev;
 361
 362         if (parent == NULL)
 363                 return NULL;
 364
 365         if (prev_child == NULL)
 366                 dev = parent->children;
 367         else
 368                 dev = prev_child->sibling;
 369
 370         return dev;
 371 }
 372
 373 bool is_dev_enabled(const struct device *dev)
 374 {
 375         if (!dev)
 376                 return false;
 377
 378         /* For stages with immutable device tree, first check if device is disabled because of
 379            fw_config probing. In these stages, dev->enabled does not reflect the true state of a
 380            device that uses fw_config probing. */
 381         if (DEVTREE_EARLY && !fw_config_probe_dev(dev, NULL))
 382                 return false;
 383         return dev->enabled;
 384 }
 385
 386 bool is_devfn_enabled(unsigned int devfn)
 387 {
 388         const struct device *dev = pcidev_path_on_root(devfn);
 389         return is_dev_enabled(dev);
 390 }