2 * Copyright (c) 2014 Google, Inc
3 * Written by Simon Glass <sjg@chromium.org>
5 * SPDX-License-Identifier: GPL-2.0+
16 #include <dm/device-internal.h>
17 #if defined(CONFIG_X86) && defined(CONFIG_HAVE_FSP)
18 #include <asm/fsp/fsp_support.h>
21 DECLARE_GLOBAL_DATA_PTR;
23 static int pci_get_bus(int busnum, struct udevice **busp)
27 ret = uclass_get_device_by_seq(UCLASS_PCI, busnum, busp);
29 /* Since buses may not be numbered yet try a little harder with bus 0 */
31 ret = uclass_first_device(UCLASS_PCI, busp);
36 ret = uclass_get_device_by_seq(UCLASS_PCI, busnum, busp);
42 struct pci_controller *pci_bus_to_hose(int busnum)
47 ret = pci_get_bus(busnum, &bus);
49 debug("%s: Cannot get bus %d: ret=%d\n", __func__, busnum, ret);
53 return dev_get_uclass_priv(bus);
56 pci_dev_t pci_get_bdf(struct udevice *dev)
58 struct pci_child_platdata *pplat = dev_get_parent_platdata(dev);
59 struct udevice *bus = dev->parent;
61 return PCI_ADD_BUS(bus->seq, pplat->devfn);
65 * pci_get_bus_max() - returns the bus number of the last active bus
67 * @return last bus number, or -1 if no active buses
69 static int pci_get_bus_max(void)
75 ret = uclass_get(UCLASS_PCI, &uc);
76 uclass_foreach_dev(bus, uc) {
81 debug("%s: ret=%d\n", __func__, ret);
86 int pci_last_busno(void)
88 struct pci_controller *hose;
93 debug("pci_last_busno\n");
94 ret = uclass_get(UCLASS_PCI, &uc);
95 if (ret || list_empty(&uc->dev_head))
98 /* Probe the last bus */
99 bus = list_entry(uc->dev_head.prev, struct udevice, uclass_node);
100 debug("bus = %p, %s\n", bus, bus->name);
102 ret = device_probe(bus);
106 /* If that bus has bridges, we may have new buses now. Get the last */
107 bus = list_entry(uc->dev_head.prev, struct udevice, uclass_node);
108 hose = dev_get_uclass_priv(bus);
109 debug("bus = %s, hose = %p\n", bus->name, hose);
111 return hose->last_busno;
114 int pci_get_ff(enum pci_size_t size)
126 int pci_bus_find_devfn(struct udevice *bus, pci_dev_t find_devfn,
127 struct udevice **devp)
131 for (device_find_first_child(bus, &dev);
133 device_find_next_child(&dev)) {
134 struct pci_child_platdata *pplat;
136 pplat = dev_get_parent_platdata(dev);
137 if (pplat && pplat->devfn == find_devfn) {
146 int pci_bus_find_bdf(pci_dev_t bdf, struct udevice **devp)
151 ret = pci_get_bus(PCI_BUS(bdf), &bus);
154 return pci_bus_find_devfn(bus, PCI_MASK_BUS(bdf), devp);
157 static int pci_device_matches_ids(struct udevice *dev,
158 struct pci_device_id *ids)
160 struct pci_child_platdata *pplat;
163 pplat = dev_get_parent_platdata(dev);
166 for (i = 0; ids[i].vendor != 0; i++) {
167 if (pplat->vendor == ids[i].vendor &&
168 pplat->device == ids[i].device)
175 int pci_bus_find_devices(struct udevice *bus, struct pci_device_id *ids,
176 int *indexp, struct udevice **devp)
180 /* Scan all devices on this bus */
181 for (device_find_first_child(bus, &dev);
183 device_find_next_child(&dev)) {
184 if (pci_device_matches_ids(dev, ids) >= 0) {
185 if ((*indexp)-- <= 0) {
195 int pci_find_device_id(struct pci_device_id *ids, int index,
196 struct udevice **devp)
200 /* Scan all known buses */
201 for (uclass_first_device(UCLASS_PCI, &bus);
203 uclass_next_device(&bus)) {
204 if (!pci_bus_find_devices(bus, ids, &index, devp))
212 int pci_bus_write_config(struct udevice *bus, pci_dev_t bdf, int offset,
213 unsigned long value, enum pci_size_t size)
215 struct dm_pci_ops *ops;
217 ops = pci_get_ops(bus);
218 if (!ops->write_config)
220 return ops->write_config(bus, bdf, offset, value, size);
223 int pci_write_config(pci_dev_t bdf, int offset, unsigned long value,
224 enum pci_size_t size)
229 ret = pci_get_bus(PCI_BUS(bdf), &bus);
233 return pci_bus_write_config(bus, bdf, offset, value, size);
236 int dm_pci_write_config(struct udevice *dev, int offset, unsigned long value,
237 enum pci_size_t size)
241 for (bus = dev; device_is_on_pci_bus(bus);)
243 return pci_bus_write_config(bus, pci_get_bdf(dev), offset, value, size);
247 int pci_write_config32(pci_dev_t bdf, int offset, u32 value)
249 return pci_write_config(bdf, offset, value, PCI_SIZE_32);
252 int pci_write_config16(pci_dev_t bdf, int offset, u16 value)
254 return pci_write_config(bdf, offset, value, PCI_SIZE_16);
257 int pci_write_config8(pci_dev_t bdf, int offset, u8 value)
259 return pci_write_config(bdf, offset, value, PCI_SIZE_8);
262 int dm_pci_write_config8(struct udevice *dev, int offset, u8 value)
264 return dm_pci_write_config(dev, offset, value, PCI_SIZE_8);
267 int dm_pci_write_config16(struct udevice *dev, int offset, u16 value)
269 return dm_pci_write_config(dev, offset, value, PCI_SIZE_16);
272 int dm_pci_write_config32(struct udevice *dev, int offset, u32 value)
274 return dm_pci_write_config(dev, offset, value, PCI_SIZE_32);
277 int pci_bus_read_config(struct udevice *bus, pci_dev_t bdf, int offset,
278 unsigned long *valuep, enum pci_size_t size)
280 struct dm_pci_ops *ops;
282 ops = pci_get_ops(bus);
283 if (!ops->read_config)
285 return ops->read_config(bus, bdf, offset, valuep, size);
288 int pci_read_config(pci_dev_t bdf, int offset, unsigned long *valuep,
289 enum pci_size_t size)
294 ret = pci_get_bus(PCI_BUS(bdf), &bus);
298 return pci_bus_read_config(bus, bdf, offset, valuep, size);
301 int dm_pci_read_config(struct udevice *dev, int offset, unsigned long *valuep,
302 enum pci_size_t size)
306 for (bus = dev; device_is_on_pci_bus(bus);)
308 return pci_bus_read_config(bus, pci_get_bdf(dev), offset, valuep,
312 int pci_read_config32(pci_dev_t bdf, int offset, u32 *valuep)
317 ret = pci_read_config(bdf, offset, &value, PCI_SIZE_32);
325 int pci_read_config16(pci_dev_t bdf, int offset, u16 *valuep)
330 ret = pci_read_config(bdf, offset, &value, PCI_SIZE_16);
338 int pci_read_config8(pci_dev_t bdf, int offset, u8 *valuep)
343 ret = pci_read_config(bdf, offset, &value, PCI_SIZE_8);
351 int dm_pci_read_config8(struct udevice *dev, int offset, u8 *valuep)
356 ret = dm_pci_read_config(dev, offset, &value, PCI_SIZE_8);
364 int dm_pci_read_config16(struct udevice *dev, int offset, u16 *valuep)
369 ret = dm_pci_read_config(dev, offset, &value, PCI_SIZE_16);
377 int dm_pci_read_config32(struct udevice *dev, int offset, u32 *valuep)
382 ret = dm_pci_read_config(dev, offset, &value, PCI_SIZE_32);
390 int pci_auto_config_devices(struct udevice *bus)
392 struct pci_controller *hose = bus->uclass_priv;
393 unsigned int sub_bus;
398 debug("%s: start\n", __func__);
399 pciauto_config_init(hose);
400 for (ret = device_find_first_child(bus, &dev);
402 ret = device_find_next_child(&dev)) {
403 unsigned int max_bus;
406 debug("%s: device %s\n", __func__, dev->name);
407 ret = pciauto_config_device(hose, pci_get_bdf(dev));
411 sub_bus = max(sub_bus, max_bus);
413 debug("%s: done\n", __func__);
418 int dm_pci_hose_probe_bus(struct pci_controller *hose, pci_dev_t bdf)
420 struct udevice *parent, *bus;
424 debug("%s\n", __func__);
427 /* Find the bus within the parent */
428 ret = pci_bus_find_devfn(parent, PCI_MASK_BUS(bdf), &bus);
430 debug("%s: Cannot find device %x on bus %s: %d\n", __func__,
431 bdf, parent->name, ret);
435 sub_bus = pci_get_bus_max() + 1;
436 debug("%s: bus = %d/%s\n", __func__, sub_bus, bus->name);
437 pciauto_prescan_setup_bridge(hose, bdf, sub_bus);
439 ret = device_probe(bus);
441 debug("%s: Cannot probe bus %s: %d\n", __func__, bus->name,
445 if (sub_bus != bus->seq) {
446 printf("%s: Internal error, bus '%s' got seq %d, expected %d\n",
447 __func__, bus->name, bus->seq, sub_bus);
450 sub_bus = pci_get_bus_max();
451 pciauto_postscan_setup_bridge(hose, bdf, sub_bus);
457 * pci_match_one_device - Tell if a PCI device structure has a matching
458 * PCI device id structure
459 * @id: single PCI device id structure to match
460 * @dev: the PCI device structure to match against
462 * Returns the matching pci_device_id structure or %NULL if there is no match.
464 static bool pci_match_one_id(const struct pci_device_id *id,
465 const struct pci_device_id *find)
467 if ((id->vendor == PCI_ANY_ID || id->vendor == find->vendor) &&
468 (id->device == PCI_ANY_ID || id->device == find->device) &&
469 (id->subvendor == PCI_ANY_ID || id->subvendor == find->subvendor) &&
470 (id->subdevice == PCI_ANY_ID || id->subdevice == find->subdevice) &&
471 !((id->class ^ find->class) & id->class_mask))
478 * pci_find_and_bind_driver() - Find and bind the right PCI driver
480 * This only looks at certain fields in the descriptor.
482 static int pci_find_and_bind_driver(struct udevice *parent,
483 struct pci_device_id *find_id, pci_dev_t bdf,
484 struct udevice **devp)
486 struct pci_driver_entry *start, *entry;
495 debug("%s: Searching for driver: vendor=%x, device=%x\n", __func__,
496 find_id->vendor, find_id->device);
497 start = ll_entry_start(struct pci_driver_entry, pci_driver_entry);
498 n_ents = ll_entry_count(struct pci_driver_entry, pci_driver_entry);
499 for (entry = start; entry != start + n_ents; entry++) {
500 const struct pci_device_id *id;
502 const struct driver *drv;
504 for (id = entry->match;
505 id->vendor || id->subvendor || id->class_mask;
507 if (!pci_match_one_id(id, find_id))
513 * In the pre-relocation phase, we only bind devices
514 * whose driver has the DM_FLAG_PRE_RELOC set, to save
515 * precious memory space as on some platforms as that
516 * space is pretty limited (ie: using Cache As RAM).
518 if (!(gd->flags & GD_FLG_RELOC) &&
519 !(drv->flags & DM_FLAG_PRE_RELOC))
523 * We could pass the descriptor to the driver as
524 * platdata (instead of NULL) and allow its bind()
525 * method to return -ENOENT if it doesn't support this
526 * device. That way we could continue the search to
527 * find another driver. For now this doesn't seem
528 * necesssary, so just bind the first match.
530 ret = device_bind(parent, drv, drv->name, NULL, -1,
534 debug("%s: Match found: %s\n", __func__, drv->name);
535 dev->driver_data = find_id->driver_data;
541 bridge = (find_id->class >> 8) == PCI_CLASS_BRIDGE_PCI;
543 * In the pre-relocation phase, we only bind bridge devices to save
544 * precious memory space as on some platforms as that space is pretty
545 * limited (ie: using Cache As RAM).
547 if (!(gd->flags & GD_FLG_RELOC) && !bridge)
550 /* Bind a generic driver so that the device can be used */
551 sprintf(name, "pci_%x:%x.%x", parent->seq, PCI_DEV(bdf),
556 drv = bridge ? "pci_bridge_drv" : "pci_generic_drv";
558 ret = device_bind_driver(parent, drv, str, devp);
560 debug("%s: Failed to bind generic driver: %d\n", __func__, ret);
563 debug("%s: No match found: bound generic driver instead\n", __func__);
568 debug("%s: No match found: error %d\n", __func__, ret);
572 int pci_bind_bus_devices(struct udevice *bus)
574 ulong vendor, device;
581 end = PCI_BDF(bus->seq, PCI_MAX_PCI_DEVICES - 1,
582 PCI_MAX_PCI_FUNCTIONS - 1);
583 for (bdf = PCI_BDF(bus->seq, 0, 0); bdf < end;
584 bdf += PCI_BDF(0, 0, 1)) {
585 struct pci_child_platdata *pplat;
589 if (PCI_FUNC(bdf) && !found_multi)
591 /* Check only the first access, we don't expect problems */
592 ret = pci_bus_read_config(bus, bdf, PCI_HEADER_TYPE,
593 &header_type, PCI_SIZE_8);
596 pci_bus_read_config(bus, bdf, PCI_VENDOR_ID, &vendor,
598 if (vendor == 0xffff || vendor == 0x0000)
602 found_multi = header_type & 0x80;
604 debug("%s: bus %d/%s: found device %x, function %d\n", __func__,
605 bus->seq, bus->name, PCI_DEV(bdf), PCI_FUNC(bdf));
606 pci_bus_read_config(bus, bdf, PCI_DEVICE_ID, &device,
608 pci_bus_read_config(bus, bdf, PCI_CLASS_REVISION, &class,
612 /* Find this device in the device tree */
613 ret = pci_bus_find_devfn(bus, PCI_MASK_BUS(bdf), &dev);
615 /* Search for a driver */
617 /* If nothing in the device tree, bind a generic device */
618 if (ret == -ENODEV) {
619 struct pci_device_id find_id;
622 memset(&find_id, '\0', sizeof(find_id));
623 find_id.vendor = vendor;
624 find_id.device = device;
625 find_id.class = class;
626 if ((header_type & 0x7f) == PCI_HEADER_TYPE_NORMAL) {
627 pci_bus_read_config(bus, bdf,
628 PCI_SUBSYSTEM_VENDOR_ID,
630 find_id.subvendor = val & 0xffff;
631 find_id.subdevice = val >> 16;
633 ret = pci_find_and_bind_driver(bus, &find_id, bdf,
639 /* Update the platform data */
641 pplat = dev_get_parent_platdata(dev);
642 pplat->devfn = PCI_MASK_BUS(bdf);
643 pplat->vendor = vendor;
644 pplat->device = device;
645 pplat->class = class;
651 printf("Cannot read bus configuration: %d\n", ret);
656 static int pci_uclass_post_bind(struct udevice *bus)
659 * If there is no pci device listed in the device tree,
660 * don't bother scanning the device tree.
662 if (bus->of_offset == -1)
666 * Scan the device tree for devices. This does not probe the PCI bus,
667 * as this is not permitted while binding. It just finds devices
668 * mentioned in the device tree.
670 * Before relocation, only bind devices marked for pre-relocation
673 return dm_scan_fdt_node(bus, gd->fdt_blob, bus->of_offset,
674 gd->flags & GD_FLG_RELOC ? false : true);
677 static int decode_regions(struct pci_controller *hose, const void *blob,
678 int parent_node, int node)
680 int pci_addr_cells, addr_cells, size_cells;
681 int cells_per_record;
687 prop = fdt_getprop(blob, node, "ranges", &len);
690 pci_addr_cells = fdt_address_cells(blob, node);
691 addr_cells = fdt_address_cells(blob, parent_node);
692 size_cells = fdt_size_cells(blob, node);
694 /* PCI addresses are always 3-cells */
696 cells_per_record = pci_addr_cells + addr_cells + size_cells;
697 hose->region_count = 0;
698 debug("%s: len=%d, cells_per_record=%d\n", __func__, len,
700 for (i = 0; i < MAX_PCI_REGIONS; i++, len -= cells_per_record) {
701 u64 pci_addr, addr, size;
706 if (len < cells_per_record)
708 flags = fdt32_to_cpu(prop[0]);
709 space_code = (flags >> 24) & 3;
710 pci_addr = fdtdec_get_number(prop + 1, 2);
711 prop += pci_addr_cells;
712 addr = fdtdec_get_number(prop, addr_cells);
714 size = fdtdec_get_number(prop, size_cells);
716 debug("%s: region %d, pci_addr=%" PRIx64 ", addr=%" PRIx64
717 ", size=%" PRIx64 ", space_code=%d\n", __func__,
718 hose->region_count, pci_addr, addr, size, space_code);
719 if (space_code & 2) {
720 type = flags & (1U << 30) ? PCI_REGION_PREFETCH :
722 } else if (space_code & 1) {
723 type = PCI_REGION_IO;
727 debug(" - type=%d\n", type);
728 pci_set_region(hose->regions + hose->region_count++, pci_addr,
732 /* Add a region for our local memory */
734 if (gd->pci_ram_top && gd->pci_ram_top < addr)
735 addr = gd->pci_ram_top;
736 pci_set_region(hose->regions + hose->region_count++, 0, 0, addr,
737 PCI_REGION_MEM | PCI_REGION_SYS_MEMORY);
742 static int pci_uclass_pre_probe(struct udevice *bus)
744 struct pci_controller *hose;
747 debug("%s, bus=%d/%s, parent=%s\n", __func__, bus->seq, bus->name,
749 hose = bus->uclass_priv;
751 /* For bridges, use the top-level PCI controller */
752 if (device_get_uclass_id(bus->parent) == UCLASS_ROOT) {
754 ret = decode_regions(hose, gd->fdt_blob, bus->parent->of_offset,
757 debug("%s: Cannot decode regions\n", __func__);
761 struct pci_controller *parent_hose;
763 parent_hose = dev_get_uclass_priv(bus->parent);
764 hose->ctlr = parent_hose->bus;
767 hose->first_busno = bus->seq;
768 hose->last_busno = bus->seq;
773 static int pci_uclass_post_probe(struct udevice *bus)
777 debug("%s: probing bus %d\n", __func__, bus->seq);
778 ret = pci_bind_bus_devices(bus);
782 #ifdef CONFIG_PCI_PNP
783 ret = pci_auto_config_devices(bus);
788 #if defined(CONFIG_X86) && defined(CONFIG_HAVE_FSP)
790 * Per Intel FSP specification, we should call FSP notify API to
791 * inform FSP that PCI enumeration has been done so that FSP will
792 * do any necessary initialization as required by the chipset's
793 * BIOS Writer's Guide (BWG).
795 * Unfortunately we have to put this call here as with driver model,
796 * the enumeration is all done on a lazy basis as needed, so until
797 * something is touched on PCI it won't happen.
799 * Note we only call this 1) after U-Boot is relocated, and 2)
800 * root bus has finished probing.
802 if ((gd->flags & GD_FLG_RELOC) && (bus->seq == 0)) {
803 ret = fsp_init_phase_pci();
812 static int pci_uclass_child_post_bind(struct udevice *dev)
814 struct pci_child_platdata *pplat;
815 struct fdt_pci_addr addr;
818 if (dev->of_offset == -1)
822 * We could read vendor, device, class if available. But for now we
823 * just check the address.
825 pplat = dev_get_parent_platdata(dev);
826 ret = fdtdec_get_pci_addr(gd->fdt_blob, dev->of_offset,
827 FDT_PCI_SPACE_CONFIG, "reg", &addr);
833 /* extract the devfn from fdt_pci_addr */
834 pplat->devfn = addr.phys_hi & 0xff00;
840 static int pci_bridge_read_config(struct udevice *bus, pci_dev_t bdf,
841 uint offset, ulong *valuep,
842 enum pci_size_t size)
844 struct pci_controller *hose = bus->uclass_priv;
846 return pci_bus_read_config(hose->ctlr, bdf, offset, valuep, size);
849 static int pci_bridge_write_config(struct udevice *bus, pci_dev_t bdf,
850 uint offset, ulong value,
851 enum pci_size_t size)
853 struct pci_controller *hose = bus->uclass_priv;
855 return pci_bus_write_config(hose->ctlr, bdf, offset, value, size);
858 static int skip_to_next_device(struct udevice *bus, struct udevice **devp)
864 * Scan through all the PCI controllers. On x86 there will only be one
865 * but that is not necessarily true on other hardware.
868 device_find_first_child(bus, &dev);
873 ret = uclass_next_device(&bus);
881 int pci_find_next_device(struct udevice **devp)
883 struct udevice *child = *devp;
884 struct udevice *bus = child->parent;
887 /* First try all the siblings */
890 device_find_next_child(&child);
897 /* We ran out of siblings. Try the next bus */
898 ret = uclass_next_device(&bus);
902 return bus ? skip_to_next_device(bus, devp) : 0;
905 int pci_find_first_device(struct udevice **devp)
911 ret = uclass_first_device(UCLASS_PCI, &bus);
915 return skip_to_next_device(bus, devp);
918 UCLASS_DRIVER(pci) = {
921 .flags = DM_UC_FLAG_SEQ_ALIAS,
922 .post_bind = pci_uclass_post_bind,
923 .pre_probe = pci_uclass_pre_probe,
924 .post_probe = pci_uclass_post_probe,
925 .child_post_bind = pci_uclass_child_post_bind,
926 .per_device_auto_alloc_size = sizeof(struct pci_controller),
927 .per_child_platdata_auto_alloc_size =
928 sizeof(struct pci_child_platdata),
931 static const struct dm_pci_ops pci_bridge_ops = {
932 .read_config = pci_bridge_read_config,
933 .write_config = pci_bridge_write_config,
936 static const struct udevice_id pci_bridge_ids[] = {
937 { .compatible = "pci-bridge" },
941 U_BOOT_DRIVER(pci_bridge_drv) = {
942 .name = "pci_bridge_drv",
944 .of_match = pci_bridge_ids,
945 .ops = &pci_bridge_ops,
948 UCLASS_DRIVER(pci_generic) = {
949 .id = UCLASS_PCI_GENERIC,
950 .name = "pci_generic",
953 static const struct udevice_id pci_generic_ids[] = {
954 { .compatible = "pci-generic" },
958 U_BOOT_DRIVER(pci_generic_drv) = {
959 .name = "pci_generic_drv",
960 .id = UCLASS_PCI_GENERIC,
961 .of_match = pci_generic_ids,