drivers/pci/pci-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2014 Google, Inc
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #define LOG_CATEGORY UCLASS_PCI
   8
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <errno.h>
  12 #include <init.h>
  13 #include <log.h>
  14 #include <malloc.h>
  15 #include <pci.h>
  16 #include <asm/global_data.h>
  17 #include <asm/io.h>
  18 #include <dm/device-internal.h>
  19 #include <dm/lists.h>
  20 #include <dm/uclass-internal.h>
  21 #if defined(CONFIG_X86) && defined(CONFIG_HAVE_FSP)
  22 #include <asm/fsp/fsp_support.h>
  23 #endif
  24 #include <dt-bindings/pci/pci.h>
  25 #include <linux/delay.h>
  26 #include "pci_internal.h"
  27
  28 DECLARE_GLOBAL_DATA_PTR;
  29
  30 int pci_get_bus(int busnum, struct udevice **busp)
  31 {
  32         int ret;
  33
  34         ret = uclass_get_device_by_seq(UCLASS_PCI, busnum, busp);
  35
  36         /* Since buses may not be numbered yet try a little harder with bus 0 */
  37         if (ret == -ENODEV) {
  38                 ret = uclass_first_device_err(UCLASS_PCI, busp);
  39                 if (ret)
  40                         return ret;
  41                 ret = uclass_get_device_by_seq(UCLASS_PCI, busnum, busp);
  42         }
  43
  44         return ret;
  45 }
  46
  47 struct udevice *pci_get_controller(struct udevice *dev)
  48 {
  49         while (device_is_on_pci_bus(dev))
  50                 dev = dev->parent;
  51
  52         return dev;
  53 }
  54
  55 pci_dev_t dm_pci_get_bdf(const struct udevice *dev)
  56 {
  57         struct pci_child_plat *pplat = dev_get_parent_plat(dev);
  58         struct udevice *bus = dev->parent;
  59
  60         /*
  61          * This error indicates that @dev is a device on an unprobed PCI bus.
  62          * The bus likely has bus=seq == -1, so the PCI_ADD_BUS() macro below
  63          * will produce a bad BDF>
  64          *
  65          * A common cause of this problem is that this function is called in the
  66          * of_to_plat() method of @dev. Accessing the PCI bus in that
  67          * method is not allowed, since it has not yet been probed. To fix this,
  68          * move that access to the probe() method of @dev instead.
  69          */
  70         if (!device_active(bus))
  71                 log_err("PCI: Device '%s' on unprobed bus '%s'\n", dev->name,
  72                         bus->name);
  73         return PCI_ADD_BUS(dev_seq(bus), pplat->devfn);
  74 }
  75
  76 /**
  77  * pci_get_bus_max() - returns the bus number of the last active bus
  78  *
  79  * Return: last bus number, or -1 if no active buses
  80  */
  81 static int pci_get_bus_max(void)
  82 {
  83         struct udevice *bus;
  84         struct uclass *uc;
  85         int ret = -1;
  86
  87         ret = uclass_get(UCLASS_PCI, &uc);
  88         uclass_foreach_dev(bus, uc) {
  89                 if (dev_seq(bus) > ret)
  90                         ret = dev_seq(bus);
  91         }
  92
  93         debug("%s: ret=%d\n", __func__, ret);
  94
  95         return ret;
  96 }
  97
  98 int pci_last_busno(void)
  99 {
 100         return pci_get_bus_max();
 101 }
 102
 103 int pci_get_ff(enum pci_size_t size)
 104 {
 105         switch (size) {
 106         case PCI_SIZE_8:
 107                 return 0xff;
 108         case PCI_SIZE_16:
 109                 return 0xffff;
 110         default:
 111                 return 0xffffffff;
 112         }
 113 }
 114
 115 static void pci_dev_find_ofnode(struct udevice *bus, phys_addr_t bdf,
 116                                 ofnode *rnode)
 117 {
 118         struct fdt_pci_addr addr;
 119         ofnode node;
 120         int ret;
 121
 122         dev_for_each_subnode(node, bus) {
 123                 ret = ofnode_read_pci_addr(node, FDT_PCI_SPACE_CONFIG, "reg",
 124                                            &addr);
 125                 if (ret)
 126                         continue;
 127
 128                 if (PCI_MASK_BUS(addr.phys_hi) != PCI_MASK_BUS(bdf))
 129                         continue;
 130
 131                 *rnode = node;
 132                 break;
 133         }
 134 };
 135
 136 int pci_bus_find_devfn(const struct udevice *bus, pci_dev_t find_devfn,
 137                        struct udevice **devp)
 138 {
 139         struct udevice *dev;
 140
 141         for (device_find_first_child(bus, &dev);
 142              dev;
 143              device_find_next_child(&dev)) {
 144                 struct pci_child_plat *pplat;
 145
 146                 pplat = dev_get_parent_plat(dev);
 147                 if (pplat && pplat->devfn == find_devfn) {
 148                         *devp = dev;
 149                         return 0;
 150                 }
 151         }
 152
 153         return -ENODEV;
 154 }
 155
 156 int dm_pci_bus_find_bdf(pci_dev_t bdf, struct udevice **devp)
 157 {
 158         struct udevice *bus;
 159         int ret;
 160
 161         ret = pci_get_bus(PCI_BUS(bdf), &bus);
 162         if (ret)
 163                 return ret;
 164         return pci_bus_find_devfn(bus, PCI_MASK_BUS(bdf), devp);
 165 }
 166
 167 static int pci_device_matches_ids(struct udevice *dev,
 168                                   const struct pci_device_id *ids)
 169 {
 170         struct pci_child_plat *pplat;
 171         int i;
 172
 173         pplat = dev_get_parent_plat(dev);
 174         if (!pplat)
 175                 return -EINVAL;
 176         for (i = 0; ids[i].vendor != 0; i++) {
 177                 if (pplat->vendor == ids[i].vendor &&
 178                     pplat->device == ids[i].device)
 179                         return i;
 180         }
 181
 182         return -EINVAL;
 183 }
 184
 185 int pci_bus_find_devices(struct udevice *bus, const struct pci_device_id *ids,
 186                          int *indexp, struct udevice **devp)
 187 {
 188         struct udevice *dev;
 189
 190         /* Scan all devices on this bus */
 191         for (device_find_first_child(bus, &dev);
 192              dev;
 193              device_find_next_child(&dev)) {
 194                 if (pci_device_matches_ids(dev, ids) >= 0) {
 195                         if ((*indexp)-- <= 0) {
 196                                 *devp = dev;
 197                                 return 0;
 198                         }
 199                 }
 200         }
 201
 202         return -ENODEV;
 203 }
 204
 205 int pci_find_device_id(const struct pci_device_id *ids, int index,
 206                        struct udevice **devp)
 207 {
 208         struct udevice *bus;
 209
 210         /* Scan all known buses */
 211         for (uclass_first_device(UCLASS_PCI, &bus);
 212              bus;
 213              uclass_next_device(&bus)) {
 214                 if (!pci_bus_find_devices(bus, ids, &index, devp))
 215                         return 0;
 216         }
 217         *devp = NULL;
 218
 219         return -ENODEV;
 220 }
 221
 222 static int dm_pci_bus_find_device(struct udevice *bus, unsigned int vendor,
 223                                   unsigned int device, int *indexp,
 224                                   struct udevice **devp)
 225 {
 226         struct pci_child_plat *pplat;
 227         struct udevice *dev;
 228
 229         for (device_find_first_child(bus, &dev);
 230              dev;
 231              device_find_next_child(&dev)) {
 232                 pplat = dev_get_parent_plat(dev);
 233                 if (pplat->vendor == vendor && pplat->device == device) {
 234                         if (!(*indexp)--) {
 235                                 *devp = dev;
 236                                 return 0;
 237                         }
 238                 }
 239         }
 240
 241         return -ENODEV;
 242 }
 243
 244 int dm_pci_find_device(unsigned int vendor, unsigned int device, int index,
 245                        struct udevice **devp)
 246 {
 247         struct udevice *bus;
 248
 249         /* Scan all known buses */
 250         for (uclass_first_device(UCLASS_PCI, &bus);
 251              bus;
 252              uclass_next_device(&bus)) {
 253                 if (!dm_pci_bus_find_device(bus, vendor, device, &index, devp))
 254                         return device_probe(*devp);
 255         }
 256         *devp = NULL;
 257
 258         return -ENODEV;
 259 }
 260
 261 int dm_pci_find_class(uint find_class, int index, struct udevice **devp)
 262 {
 263         struct udevice *dev;
 264
 265         /* Scan all known buses */
 266         for (pci_find_first_device(&dev);
 267              dev;
 268              pci_find_next_device(&dev)) {
 269                 struct pci_child_plat *pplat = dev_get_parent_plat(dev);
 270
 271                 if (pplat->class == find_class && !index--) {
 272                         *devp = dev;
 273                         return device_probe(*devp);
 274                 }
 275         }
 276         *devp = NULL;
 277
 278         return -ENODEV;
 279 }
 280
 281 int pci_bus_write_config(struct udevice *bus, pci_dev_t bdf, int offset,
 282                          unsigned long value, enum pci_size_t size)
 283 {
 284         struct dm_pci_ops *ops;
 285
 286         ops = pci_get_ops(bus);
 287         if (!ops->write_config)
 288                 return -ENOSYS;
 289         return ops->write_config(bus, bdf, offset, value, size);
 290 }
 291
 292 int pci_bus_clrset_config32(struct udevice *bus, pci_dev_t bdf, int offset,
 293                             u32 clr, u32 set)
 294 {
 295         ulong val;
 296         int ret;
 297
 298         ret = pci_bus_read_config(bus, bdf, offset, &val, PCI_SIZE_32);
 299         if (ret)
 300                 return ret;
 301         val &= ~clr;
 302         val |= set;
 303
 304         return pci_bus_write_config(bus, bdf, offset, val, PCI_SIZE_32);
 305 }
 306
 307 static int pci_write_config(pci_dev_t bdf, int offset, unsigned long value,
 308                             enum pci_size_t size)
 309 {
 310         struct udevice *bus;
 311         int ret;
 312
 313         ret = pci_get_bus(PCI_BUS(bdf), &bus);
 314         if (ret)
 315                 return ret;
 316
 317         return pci_bus_write_config(bus, bdf, offset, value, size);
 318 }
 319
 320 int dm_pci_write_config(struct udevice *dev, int offset, unsigned long value,
 321                         enum pci_size_t size)
 322 {
 323         struct udevice *bus;
 324
 325         for (bus = dev; device_is_on_pci_bus(bus);)
 326                 bus = bus->parent;
 327         return pci_bus_write_config(bus, dm_pci_get_bdf(dev), offset, value,
 328                                     size);
 329 }
 330
 331 int pci_write_config32(pci_dev_t bdf, int offset, u32 value)
 332 {
 333         return pci_write_config(bdf, offset, value, PCI_SIZE_32);
 334 }
 335
 336 int pci_write_config16(pci_dev_t bdf, int offset, u16 value)
 337 {
 338         return pci_write_config(bdf, offset, value, PCI_SIZE_16);
 339 }
 340
 341 int pci_write_config8(pci_dev_t bdf, int offset, u8 value)
 342 {
 343         return pci_write_config(bdf, offset, value, PCI_SIZE_8);
 344 }
 345
 346 int dm_pci_write_config8(struct udevice *dev, int offset, u8 value)
 347 {
 348         return dm_pci_write_config(dev, offset, value, PCI_SIZE_8);
 349 }
 350
 351 int dm_pci_write_config16(struct udevice *dev, int offset, u16 value)
 352 {
 353         return dm_pci_write_config(dev, offset, value, PCI_SIZE_16);
 354 }
 355
 356 int dm_pci_write_config32(struct udevice *dev, int offset, u32 value)
 357 {
 358         return dm_pci_write_config(dev, offset, value, PCI_SIZE_32);
 359 }
 360
 361 int pci_bus_read_config(const struct udevice *bus, pci_dev_t bdf, int offset,
 362                         unsigned long *valuep, enum pci_size_t size)
 363 {
 364         struct dm_pci_ops *ops;
 365
 366         ops = pci_get_ops(bus);
 367         if (!ops->read_config)
 368                 return -ENOSYS;
 369         return ops->read_config(bus, bdf, offset, valuep, size);
 370 }
 371
 372 static int pci_read_config(pci_dev_t bdf, int offset, unsigned long *valuep,
 373                            enum pci_size_t size)
 374 {
 375         struct udevice *bus;
 376         int ret;
 377
 378         ret = pci_get_bus(PCI_BUS(bdf), &bus);
 379         if (ret)
 380                 return ret;
 381
 382         return pci_bus_read_config(bus, bdf, offset, valuep, size);
 383 }
 384
 385 int dm_pci_read_config(const struct udevice *dev, int offset,
 386                        unsigned long *valuep, enum pci_size_t size)
 387 {
 388         const struct udevice *bus;
 389
 390         for (bus = dev; device_is_on_pci_bus(bus);)
 391                 bus = bus->parent;
 392         return pci_bus_read_config(bus, dm_pci_get_bdf(dev), offset, valuep,
 393                                    size);
 394 }
 395
 396 int pci_read_config32(pci_dev_t bdf, int offset, u32 *valuep)
 397 {
 398         unsigned long value;
 399         int ret;
 400
 401         ret = pci_read_config(bdf, offset, &value, PCI_SIZE_32);
 402         if (ret)
 403                 return ret;
 404         *valuep = value;
 405
 406         return 0;
 407 }
 408
 409 int pci_read_config16(pci_dev_t bdf, int offset, u16 *valuep)
 410 {
 411         unsigned long value;
 412         int ret;
 413
 414         ret = pci_read_config(bdf, offset, &value, PCI_SIZE_16);
 415         if (ret)
 416                 return ret;
 417         *valuep = value;
 418
 419         return 0;
 420 }
 421
 422 int pci_read_config8(pci_dev_t bdf, int offset, u8 *valuep)
 423 {
 424         unsigned long value;
 425         int ret;
 426
 427         ret = pci_read_config(bdf, offset, &value, PCI_SIZE_8);
 428         if (ret)
 429                 return ret;
 430         *valuep = value;
 431
 432         return 0;
 433 }
 434
 435 int dm_pci_read_config8(const struct udevice *dev, int offset, u8 *valuep)
 436 {
 437         unsigned long value;
 438         int ret;
 439
 440         ret = dm_pci_read_config(dev, offset, &value, PCI_SIZE_8);
 441         if (ret)
 442                 return ret;
 443         *valuep = value;
 444
 445         return 0;
 446 }
 447
 448 int dm_pci_read_config16(const struct udevice *dev, int offset, u16 *valuep)
 449 {
 450         unsigned long value;
 451         int ret;
 452
 453         ret = dm_pci_read_config(dev, offset, &value, PCI_SIZE_16);
 454         if (ret)
 455                 return ret;
 456         *valuep = value;
 457
 458         return 0;
 459 }
 460
 461 int dm_pci_read_config32(const struct udevice *dev, int offset, u32 *valuep)
 462 {
 463         unsigned long value;
 464         int ret;
 465
 466         ret = dm_pci_read_config(dev, offset, &value, PCI_SIZE_32);
 467         if (ret)
 468                 return ret;
 469         *valuep = value;
 470
 471         return 0;
 472 }
 473
 474 int dm_pci_clrset_config8(struct udevice *dev, int offset, u32 clr, u32 set)
 475 {
 476         u8 val;
 477         int ret;
 478
 479         ret = dm_pci_read_config8(dev, offset, &val);
 480         if (ret)
 481                 return ret;
 482         val &= ~clr;
 483         val |= set;
 484
 485         return dm_pci_write_config8(dev, offset, val);
 486 }
 487
 488 int dm_pci_clrset_config16(struct udevice *dev, int offset, u32 clr, u32 set)
 489 {
 490         u16 val;
 491         int ret;
 492
 493         ret = dm_pci_read_config16(dev, offset, &val);
 494         if (ret)
 495                 return ret;
 496         val &= ~clr;
 497         val |= set;
 498
 499         return dm_pci_write_config16(dev, offset, val);
 500 }
 501
 502 int dm_pci_clrset_config32(struct udevice *dev, int offset, u32 clr, u32 set)
 503 {
 504         u32 val;
 505         int ret;
 506
 507         ret = dm_pci_read_config32(dev, offset, &val);
 508         if (ret)
 509                 return ret;
 510         val &= ~clr;
 511         val |= set;
 512
 513         return dm_pci_write_config32(dev, offset, val);
 514 }
 515
 516 static void set_vga_bridge_bits(struct udevice *dev)
 517 {
 518         struct udevice *parent = dev->parent;
 519         u16 bc;
 520
 521         while (dev_seq(parent) != 0) {
 522                 dm_pci_read_config16(parent, PCI_BRIDGE_CONTROL, &bc);
 523                 bc |= PCI_BRIDGE_CTL_VGA;
 524                 dm_pci_write_config16(parent, PCI_BRIDGE_CONTROL, bc);
 525                 parent = parent->parent;
 526         }
 527 }
 528
 529 int pci_auto_config_devices(struct udevice *bus)
 530 {
 531         struct pci_controller *hose = dev_get_uclass_priv(bus);
 532         struct pci_child_plat *pplat;
 533         unsigned int sub_bus;
 534         struct udevice *dev;
 535         int ret;
 536
 537         sub_bus = dev_seq(bus);
 538         debug("%s: start\n", __func__);
 539         pciauto_config_init(hose);
 540         for (ret = device_find_first_child(bus, &dev);
 541              !ret && dev;
 542              ret = device_find_next_child(&dev)) {
 543                 unsigned int max_bus;
 544                 int ret;
 545
 546                 debug("%s: device %s\n", __func__, dev->name);
 547                 if (dev_has_ofnode(dev) &&
 548                     dev_read_bool(dev, "pci,no-autoconfig"))
 549                         continue;
 550                 ret = dm_pciauto_config_device(dev);
 551                 if (ret < 0)
 552                         return log_msg_ret("auto", ret);
 553                 max_bus = ret;
 554                 sub_bus = max(sub_bus, max_bus);
 555
 556                 if (dev_get_parent(dev) == bus)
 557                         continue;
 558
 559                 pplat = dev_get_parent_plat(dev);
 560                 if (pplat->class == (PCI_CLASS_DISPLAY_VGA << 8))
 561                         set_vga_bridge_bits(dev);
 562         }
 563         if (hose->last_busno < sub_bus)
 564                 hose->last_busno = sub_bus;
 565         debug("%s: done\n", __func__);
 566
 567         return log_msg_ret("sub", sub_bus);
 568 }
 569
 570 int pci_generic_mmap_write_config(
 571         const struct udevice *bus,
 572         int (*addr_f)(const struct udevice *bus, pci_dev_t bdf, uint offset,
 573                       void **addrp),
 574         pci_dev_t bdf,
 575         uint offset,
 576         ulong value,
 577         enum pci_size_t size)
 578 {
 579         void *address;
 580
 581         if (addr_f(bus, bdf, offset, &address) < 0)
 582                 return 0;
 583
 584         switch (size) {
 585         case PCI_SIZE_8:
 586                 writeb(value, address);
 587                 return 0;
 588         case PCI_SIZE_16:
 589                 writew(value, address);
 590                 return 0;
 591         case PCI_SIZE_32:
 592                 writel(value, address);
 593                 return 0;
 594         default:
 595                 return -EINVAL;
 596         }
 597 }
 598
 599 int pci_generic_mmap_read_config(
 600         const struct udevice *bus,
 601         int (*addr_f)(const struct udevice *bus, pci_dev_t bdf, uint offset,
 602                       void **addrp),
 603         pci_dev_t bdf,
 604         uint offset,
 605         ulong *valuep,
 606         enum pci_size_t size)
 607 {
 608         void *address;
 609
 610         if (addr_f(bus, bdf, offset, &address) < 0) {
 611                 *valuep = pci_get_ff(size);
 612                 return 0;
 613         }
 614
 615         switch (size) {
 616         case PCI_SIZE_8:
 617                 *valuep = readb(address);
 618                 return 0;
 619         case PCI_SIZE_16:
 620                 *valuep = readw(address);
 621                 return 0;
 622         case PCI_SIZE_32:
 623                 *valuep = readl(address);
 624                 return 0;
 625         default:
 626                 return -EINVAL;
 627         }
 628 }
 629
 630 int dm_pci_hose_probe_bus(struct udevice *bus)
 631 {
 632         u8 header_type;
 633         int sub_bus;
 634         int ret;
 635         int ea_pos;
 636         u8 reg;
 637
 638         debug("%s\n", __func__);
 639
 640         dm_pci_read_config8(bus, PCI_HEADER_TYPE, &header_type);
 641         header_type &= 0x7f;
 642         if (header_type != PCI_HEADER_TYPE_BRIDGE) {
 643                 debug("%s: Skipping PCI device %d with Non-Bridge Header Type 0x%x\n",
 644                       __func__, PCI_DEV(dm_pci_get_bdf(bus)), header_type);
 645                 return log_msg_ret("probe", -EINVAL);
 646         }
 647
 648         if (IS_ENABLED(CONFIG_PCI_ENHANCED_ALLOCATION))
 649                 ea_pos = dm_pci_find_capability(bus, PCI_CAP_ID_EA);
 650         else
 651                 ea_pos = 0;
 652
 653         if (ea_pos) {
 654                 dm_pci_read_config8(bus, ea_pos + sizeof(u32) + sizeof(u8),
 655                                     &reg);
 656                 sub_bus = reg;
 657         } else {
 658                 sub_bus = pci_get_bus_max() + 1;
 659         }
 660         debug("%s: bus = %d/%s\n", __func__, sub_bus, bus->name);
 661         dm_pciauto_prescan_setup_bridge(bus, sub_bus);
 662
 663         ret = device_probe(bus);
 664         if (ret) {
 665                 debug("%s: Cannot probe bus %s: %d\n", __func__, bus->name,
 666                       ret);
 667                 return log_msg_ret("probe", ret);
 668         }
 669
 670         if (!ea_pos)
 671                 sub_bus = pci_get_bus_max();
 672
 673         dm_pciauto_postscan_setup_bridge(bus, sub_bus);
 674
 675         return sub_bus;
 676 }
 677
 678 /**
 679  * pci_match_one_device - Tell if a PCI device structure has a matching
 680  *                        PCI device id structure
 681  * @id: single PCI device id structure to match
 682  * @find: the PCI device id structure to match against
 683  *
 684  * Returns true if the finding pci_device_id structure matched or false if
 685  * there is no match.
 686  */
 687 static bool pci_match_one_id(const struct pci_device_id *id,
 688                              const struct pci_device_id *find)
 689 {
 690         if ((id->vendor == PCI_ANY_ID || id->vendor == find->vendor) &&
 691             (id->device == PCI_ANY_ID || id->device == find->device) &&
 692             (id->subvendor == PCI_ANY_ID || id->subvendor == find->subvendor) &&
 693             (id->subdevice == PCI_ANY_ID || id->subdevice == find->subdevice) &&
 694             !((id->class ^ find->class) & id->class_mask))
 695                 return true;
 696
 697         return false;
 698 }
 699
 700 /**
 701  * pci_need_device_pre_reloc() - Check if a device should be bound
 702  *
 703  * This checks a list of vendor/device-ID values indicating devices that should
 704  * be bound before relocation.
 705  *
 706  * @bus: Bus to check
 707  * @vendor: Vendor ID to check
 708  * @device: Device ID to check
 709  * Return: true if the vendor/device is in the list, false if not
 710  */
 711 static bool pci_need_device_pre_reloc(struct udevice *bus, uint vendor,
 712                                       uint device)
 713 {
 714         u32 vendev;
 715         int index;
 716
 717         for (index = 0;
 718              !dev_read_u32_index(bus, "u-boot,pci-pre-reloc", index,
 719                                  &vendev);
 720              index++) {
 721                 if (vendev == PCI_VENDEV(vendor, device))
 722                         return true;
 723         }
 724
 725         return false;
 726 }
 727
 728 /**
 729  * pci_find_and_bind_driver() - Find and bind the right PCI driver
 730  *
 731  * This only looks at certain fields in the descriptor.
 732  *
 733  * @parent:     Parent bus
 734  * @find_id:    Specification of the driver to find
 735  * @bdf:        Bus/device/function addreess - see PCI_BDF()
 736  * @devp:       Returns a pointer to the device created
 737  * Return: 0 if OK, -EPERM if the device is not needed before relocation and
 738  *         therefore was not created, other -ve value on error
 739  */
 740 static int pci_find_and_bind_driver(struct udevice *parent,
 741                                     struct pci_device_id *find_id,
 742                                     pci_dev_t bdf, struct udevice **devp)
 743 {
 744         struct pci_driver_entry *start, *entry;
 745         ofnode node = ofnode_null();
 746         const char *drv;
 747         int n_ents;
 748         int ret;
 749         char name[30], *str;
 750         bool bridge;
 751
 752         *devp = NULL;
 753
 754         debug("%s: Searching for driver: vendor=%x, device=%x\n", __func__,
 755               find_id->vendor, find_id->device);
 756
 757         /* Determine optional OF node */
 758         if (ofnode_valid(dev_ofnode(parent)))
 759                 pci_dev_find_ofnode(parent, bdf, &node);
 760
 761         if (ofnode_valid(node) && !ofnode_is_available(node)) {
 762                 debug("%s: Ignoring disabled device\n", __func__);
 763                 return log_msg_ret("dis", -EPERM);
 764         }
 765
 766         start = ll_entry_start(struct pci_driver_entry, pci_driver_entry);
 767         n_ents = ll_entry_count(struct pci_driver_entry, pci_driver_entry);
 768         for (entry = start; entry != start + n_ents; entry++) {
 769                 const struct pci_device_id *id;
 770                 struct udevice *dev;
 771                 const struct driver *drv;
 772
 773                 for (id = entry->match;
 774                      id->vendor || id->subvendor || id->class_mask;
 775                      id++) {
 776                         if (!pci_match_one_id(id, find_id))
 777                                 continue;
 778
 779                         drv = entry->driver;
 780
 781                         /*
 782                          * In the pre-relocation phase, we only bind devices
 783                          * whose driver has the DM_FLAG_PRE_RELOC set, to save
 784                          * precious memory space as on some platforms as that
 785                          * space is pretty limited (ie: using Cache As RAM).
 786                          */
 787                         if (!(gd->flags & GD_FLG_RELOC) &&
 788                             !(drv->flags & DM_FLAG_PRE_RELOC))
 789                                 return log_msg_ret("pre", -EPERM);
 790
 791                         /*
 792                          * We could pass the descriptor to the driver as
 793                          * plat (instead of NULL) and allow its bind()
 794                          * method to return -ENOENT if it doesn't support this
 795                          * device. That way we could continue the search to
 796                          * find another driver. For now this doesn't seem
 797                          * necesssary, so just bind the first match.
 798                          */
 799                         ret = device_bind(parent, drv, drv->name, NULL, node,
 800                                           &dev);
 801                         if (ret)
 802                                 goto error;
 803                         debug("%s: Match found: %s\n", __func__, drv->name);
 804                         dev->driver_data = id->driver_data;
 805                         *devp = dev;
 806                         return 0;
 807                 }
 808         }
 809
 810         bridge = (find_id->class >> 8) == PCI_CLASS_BRIDGE_PCI;
 811         /*
 812          * In the pre-relocation phase, we only bind bridge devices to save
 813          * precious memory space as on some platforms as that space is pretty
 814          * limited (ie: using Cache As RAM).
 815          */
 816         if (!(gd->flags & GD_FLG_RELOC) && !bridge &&
 817             !pci_need_device_pre_reloc(parent, find_id->vendor,
 818                                        find_id->device))
 819                 return log_msg_ret("notbr", -EPERM);
 820
 821         /* Bind a generic driver so that the device can be used */
 822         sprintf(name, "pci_%x:%x.%x", dev_seq(parent), PCI_DEV(bdf),
 823                 PCI_FUNC(bdf));
 824         str = strdup(name);
 825         if (!str)
 826                 return -ENOMEM;
 827         drv = bridge ? "pci_bridge_drv" : "pci_generic_drv";
 828
 829         ret = device_bind_driver_to_node(parent, drv, str, node, devp);
 830         if (ret) {
 831                 debug("%s: Failed to bind generic driver: %d\n", __func__, ret);
 832                 free(str);
 833                 return ret;
 834         }
 835         debug("%s: No match found: bound generic driver instead\n", __func__);
 836
 837         return 0;
 838
 839 error:
 840         debug("%s: No match found: error %d\n", __func__, ret);
 841         return ret;
 842 }
 843
 844 __weak extern void board_pci_fixup_dev(struct udevice *bus, struct udevice *dev)
 845 {
 846 }
 847
 848 int pci_bind_bus_devices(struct udevice *bus)
 849 {
 850         ulong vendor, device;
 851         ulong header_type;
 852         pci_dev_t bdf, end;
 853         bool found_multi;
 854         int ari_off;
 855         int ret;
 856
 857         found_multi = false;
 858         end = PCI_BDF(dev_seq(bus), PCI_MAX_PCI_DEVICES - 1,
 859                       PCI_MAX_PCI_FUNCTIONS - 1);
 860         for (bdf = PCI_BDF(dev_seq(bus), 0, 0); bdf <= end;
 861              bdf += PCI_BDF(0, 0, 1)) {
 862                 struct pci_child_plat *pplat;
 863                 struct udevice *dev;
 864                 ulong class;
 865
 866                 if (!PCI_FUNC(bdf))
 867                         found_multi = false;
 868                 if (PCI_FUNC(bdf) && !found_multi)
 869                         continue;
 870
 871                 /* Check only the first access, we don't expect problems */
 872                 ret = pci_bus_read_config(bus, bdf, PCI_VENDOR_ID, &vendor,
 873                                           PCI_SIZE_16);
 874                 if (ret || vendor == 0xffff || vendor == 0x0000)
 875                         continue;
 876
 877                 pci_bus_read_config(bus, bdf, PCI_HEADER_TYPE,
 878                                     &header_type, PCI_SIZE_8);
 879
 880                 if (!PCI_FUNC(bdf))
 881                         found_multi = header_type & 0x80;
 882
 883                 debug("%s: bus %d/%s: found device %x, function %d", __func__,
 884                       dev_seq(bus), bus->name, PCI_DEV(bdf), PCI_FUNC(bdf));
 885                 pci_bus_read_config(bus, bdf, PCI_DEVICE_ID, &device,
 886                                     PCI_SIZE_16);
 887                 pci_bus_read_config(bus, bdf, PCI_CLASS_REVISION, &class,
 888                                     PCI_SIZE_32);
 889                 class >>= 8;
 890
 891                 /* Find this device in the device tree */
 892                 ret = pci_bus_find_devfn(bus, PCI_MASK_BUS(bdf), &dev);
 893                 debug(": find ret=%d\n", ret);
 894
 895                 /* If nothing in the device tree, bind a device */
 896                 if (ret == -ENODEV) {
 897                         struct pci_device_id find_id;
 898                         ulong val;
 899
 900                         memset(&find_id, '\0', sizeof(find_id));
 901                         find_id.vendor = vendor;
 902                         find_id.device = device;
 903                         find_id.class = class;
 904                         if ((header_type & 0x7f) == PCI_HEADER_TYPE_NORMAL) {
 905                                 pci_bus_read_config(bus, bdf,
 906                                                     PCI_SUBSYSTEM_VENDOR_ID,
 907                                                     &val, PCI_SIZE_32);
 908                                 find_id.subvendor = val & 0xffff;
 909                                 find_id.subdevice = val >> 16;
 910                         }
 911                         ret = pci_find_and_bind_driver(bus, &find_id, bdf,
 912                                                        &dev);
 913                 }
 914                 if (ret == -EPERM)
 915                         continue;
 916                 else if (ret)
 917                         return ret;
 918
 919                 /* Update the platform data */
 920                 pplat = dev_get_parent_plat(dev);
 921                 pplat->devfn = PCI_MASK_BUS(bdf);
 922                 pplat->vendor = vendor;
 923                 pplat->device = device;
 924                 pplat->class = class;
 925
 926                 if (IS_ENABLED(CONFIG_PCI_ARID)) {
 927                         ari_off = dm_pci_find_ext_capability(dev,
 928                                                              PCI_EXT_CAP_ID_ARI);
 929                         if (ari_off) {
 930                                 u16 ari_cap;
 931
 932                                 /*
 933                                  * Read Next Function number in ARI Cap
 934                                  * Register
 935                                  */
 936                                 dm_pci_read_config16(dev, ari_off + 4,
 937                                                      &ari_cap);
 938                                 /*
 939                                  * Update next scan on this function number,
 940                                  * subtract 1 in BDF to satisfy loop increment.
 941                                  */
 942                                 if (ari_cap & 0xff00) {
 943                                         bdf = PCI_BDF(PCI_BUS(bdf),
 944                                                       PCI_DEV(ari_cap),
 945                                                       PCI_FUNC(ari_cap));
 946                                         bdf = bdf - 0x100;
 947                                 }
 948                         }
 949                 }
 950
 951                 board_pci_fixup_dev(bus, dev);
 952         }
 953
 954         return 0;
 955 }
 956
 957 static int decode_regions(struct pci_controller *hose, ofnode parent_node,
 958                            ofnode node)
 959 {
 960         int pci_addr_cells, addr_cells, size_cells;
 961         int cells_per_record;
 962         struct bd_info *bd;
 963         const u32 *prop;
 964         int max_regions;
 965         int len;
 966         int i;
 967
 968         prop = ofnode_get_property(node, "ranges", &len);
 969         if (!prop) {
 970                 debug("%s: Cannot decode regions\n", __func__);
 971                 return -EINVAL;
 972         }
 973
 974         pci_addr_cells = ofnode_read_simple_addr_cells(node);
 975         addr_cells = ofnode_read_simple_addr_cells(parent_node);
 976         size_cells = ofnode_read_simple_size_cells(node);
 977
 978         /* PCI addresses are always 3-cells */
 979         len /= sizeof(u32);
 980         cells_per_record = pci_addr_cells + addr_cells + size_cells;
 981         hose->region_count = 0;
 982         debug("%s: len=%d, cells_per_record=%d\n", __func__, len,
 983               cells_per_record);
 984
 985         /* Dynamically allocate the regions array */
 986         max_regions = len / cells_per_record + CONFIG_NR_DRAM_BANKS;
 987         hose->regions = (struct pci_region *)
 988                 calloc(1, max_regions * sizeof(struct pci_region));
 989         if (!hose->regions)
 990                 return -ENOMEM;
 991
 992         for (i = 0; i < max_regions; i++, len -= cells_per_record) {
 993                 u64 pci_addr, addr, size;
 994                 int space_code;
 995                 u32 flags;
 996                 int type;
 997                 int pos;
 998
 999                 if (len < cells_per_record)
1000                         break;
1001                 flags = fdt32_to_cpu(prop[0]);
1002                 space_code = (flags >> 24) & 3;
1003                 pci_addr = fdtdec_get_number(prop + 1, 2);
1004                 prop += pci_addr_cells;
1005                 addr = fdtdec_get_number(prop, addr_cells);
1006                 prop += addr_cells;
1007                 size = fdtdec_get_number(prop, size_cells);
1008                 prop += size_cells;
1009                 debug("%s: region %d, pci_addr=%llx, addr=%llx, size=%llx, space_code=%d\n",
1010                       __func__, hose->region_count, pci_addr, addr, size, space_code);
1011                 if (space_code & 2) {
1012                         type = flags & (1U << 30) ? PCI_REGION_PREFETCH :
1013                                         PCI_REGION_MEM;
1014                 } else if (space_code & 1) {
1015                         type = PCI_REGION_IO;
1016                 } else {
1017                         continue;
1018                 }
1019
1020                 if (!IS_ENABLED(CONFIG_SYS_PCI_64BIT) &&
1021                     type == PCI_REGION_MEM && upper_32_bits(pci_addr)) {
1022                         debug(" - pci_addr beyond the 32-bit boundary, ignoring\n");
1023                         continue;
1024                 }
1025
1026                 if (!IS_ENABLED(CONFIG_PHYS_64BIT) && upper_32_bits(addr)) {
1027                         debug(" - addr beyond the 32-bit boundary, ignoring\n");
1028                         continue;
1029                 }
1030
1031                 if (~((pci_addr_t)0) - pci_addr < size) {
1032                         debug(" - PCI range exceeds max address, ignoring\n");
1033                         continue;
1034                 }
1035
1036                 if (~((phys_addr_t)0) - addr < size) {
1037                         debug(" - phys range exceeds max address, ignoring\n");
1038                         continue;
1039                 }
1040
1041                 pos = -1;
1042                 if (!IS_ENABLED(CONFIG_PCI_REGION_MULTI_ENTRY)) {
1043                         for (i = 0; i < hose->region_count; i++) {
1044                                 if (hose->regions[i].flags == type)
1045                                         pos = i;
1046                         }
1047                 }
1048
1049                 if (pos == -1)
1050                         pos = hose->region_count++;
1051                 debug(" - type=%d, pos=%d\n", type, pos);
1052                 pci_set_region(hose->regions + pos, pci_addr, addr, size, type);
1053         }
1054
1055         /* Add a region for our local memory */
1056         bd = gd->bd;
1057         if (!bd)
1058                 return 0;
1059
1060         for (i = 0; i < CONFIG_NR_DRAM_BANKS; ++i) {
1061                 if (bd->bi_dram[i].size) {
1062                         phys_addr_t start = bd->bi_dram[i].start;
1063
1064                         if (IS_ENABLED(CONFIG_PCI_MAP_SYSTEM_MEMORY))
1065                                 start = virt_to_phys((void *)(uintptr_t)bd->bi_dram[i].start);
1066
1067                         pci_set_region(hose->regions + hose->region_count++,
1068                                        start, start, bd->bi_dram[i].size,
1069                                        PCI_REGION_MEM | PCI_REGION_SYS_MEMORY);
1070                 }
1071         }
1072
1073         return 0;
1074 }
1075
1076 static int pci_uclass_pre_probe(struct udevice *bus)
1077 {
1078         struct pci_controller *hose;
1079         struct uclass *uc;
1080         int ret;
1081
1082         debug("%s, bus=%d/%s, parent=%s\n", __func__, dev_seq(bus), bus->name,
1083               bus->parent->name);
1084         hose = dev_get_uclass_priv(bus);
1085
1086         /*
1087          * Set the sequence number, if device_bind() doesn't. We want control
1088          * of this so that numbers are allocated as devices are probed. That
1089          * ensures that sub-bus numbered is correct (sub-buses must get numbers
1090          * higher than their parents)
1091          */
1092         if (dev_seq(bus) == -1) {
1093                 ret = uclass_get(UCLASS_PCI, &uc);
1094                 if (ret)
1095                         return ret;
1096                 bus->seq_ = uclass_find_next_free_seq(uc);
1097         }
1098
1099         /* For bridges, use the top-level PCI controller */
1100         if (!device_is_on_pci_bus(bus)) {
1101                 hose->ctlr = bus;
1102                 ret = decode_regions(hose, dev_ofnode(bus->parent),
1103                                      dev_ofnode(bus));
1104                 if (ret)
1105                         return ret;
1106         } else {
1107                 struct pci_controller *parent_hose;
1108
1109                 parent_hose = dev_get_uclass_priv(bus->parent);
1110                 hose->ctlr = parent_hose->bus;
1111         }
1112
1113         hose->bus = bus;
1114         hose->first_busno = dev_seq(bus);
1115         hose->last_busno = dev_seq(bus);
1116         if (dev_has_ofnode(bus)) {
1117                 hose->skip_auto_config_until_reloc =
1118                         dev_read_bool(bus,
1119                                       "u-boot,skip-auto-config-until-reloc");
1120         }
1121
1122         return 0;
1123 }
1124
1125 static int pci_uclass_post_probe(struct udevice *bus)
1126 {
1127         struct pci_controller *hose = dev_get_uclass_priv(bus);
1128         int ret;
1129
1130         debug("%s: probing bus %d\n", __func__, dev_seq(bus));
1131         ret = pci_bind_bus_devices(bus);
1132         if (ret)
1133                 return log_msg_ret("bind", ret);
1134
1135         if (CONFIG_IS_ENABLED(PCI_PNP) && ll_boot_init() &&
1136             (!hose->skip_auto_config_until_reloc ||
1137              (gd->flags & GD_FLG_RELOC))) {
1138                 ret = pci_auto_config_devices(bus);
1139                 if (ret < 0)
1140                         return log_msg_ret("cfg", ret);
1141         }
1142
1143 #if defined(CONFIG_X86) && defined(CONFIG_HAVE_FSP)
1144         /*
1145          * Per Intel FSP specification, we should call FSP notify API to
1146          * inform FSP that PCI enumeration has been done so that FSP will
1147          * do any necessary initialization as required by the chipset's
1148          * BIOS Writer's Guide (BWG).
1149          *
1150          * Unfortunately we have to put this call here as with driver model,
1151          * the enumeration is all done on a lazy basis as needed, so until
1152          * something is touched on PCI it won't happen.
1153          *
1154          * Note we only call this 1) after U-Boot is relocated, and 2)
1155          * root bus has finished probing.
1156          */
1157         if ((gd->flags & GD_FLG_RELOC) && dev_seq(bus) == 0 && ll_boot_init()) {
1158                 ret = fsp_init_phase_pci();
1159                 if (ret)
1160                         return log_msg_ret("fsp", ret);
1161         }
1162 #endif
1163
1164         return 0;
1165 }
1166
1167 static int pci_uclass_child_post_bind(struct udevice *dev)
1168 {
1169         struct pci_child_plat *pplat;
1170
1171         if (!dev_has_ofnode(dev))
1172                 return 0;
1173
1174         pplat = dev_get_parent_plat(dev);
1175
1176         /* Extract vendor id and device id if available */
1177         ofnode_read_pci_vendev(dev_ofnode(dev), &pplat->vendor, &pplat->device);
1178
1179         /* Extract the devfn from fdt_pci_addr */
1180         pplat->devfn = pci_get_devfn(dev);
1181
1182         return 0;
1183 }
1184
1185 static int pci_bridge_read_config(const struct udevice *bus, pci_dev_t bdf,
1186                                   uint offset, ulong *valuep,
1187                                   enum pci_size_t size)
1188 {
1189         struct pci_controller *hose = dev_get_uclass_priv(bus);
1190
1191         return pci_bus_read_config(hose->ctlr, bdf, offset, valuep, size);
1192 }
1193
1194 static int pci_bridge_write_config(struct udevice *bus, pci_dev_t bdf,
1195                                    uint offset, ulong value,
1196                                    enum pci_size_t size)
1197 {
1198         struct pci_controller *hose = dev_get_uclass_priv(bus);
1199
1200         return pci_bus_write_config(hose->ctlr, bdf, offset, value, size);
1201 }
1202
1203 static int skip_to_next_device(struct udevice *bus, struct udevice **devp)
1204 {
1205         struct udevice *dev;
1206         int ret = 0;
1207
1208         /*
1209          * Scan through all the PCI controllers. On x86 there will only be one
1210          * but that is not necessarily true on other hardware.
1211          */
1212         do {
1213                 device_find_first_child(bus, &dev);
1214                 if (dev) {
1215                         *devp = dev;
1216                         return 0;
1217                 }
1218                 ret = uclass_next_device(&bus);
1219                 if (ret)
1220                         return ret;
1221         } while (bus);
1222
1223         return 0;
1224 }
1225
1226 int pci_find_next_device(struct udevice **devp)
1227 {
1228         struct udevice *child = *devp;
1229         struct udevice *bus = child->parent;
1230         int ret;
1231
1232         /* First try all the siblings */
1233         *devp = NULL;
1234         while (child) {
1235                 device_find_next_child(&child);
1236                 if (child) {
1237                         *devp = child;
1238                         return 0;
1239                 }
1240         }
1241
1242         /* We ran out of siblings. Try the next bus */
1243         ret = uclass_next_device(&bus);
1244         if (ret)
1245                 return ret;
1246
1247         return bus ? skip_to_next_device(bus, devp) : 0;
1248 }
1249
1250 int pci_find_first_device(struct udevice **devp)
1251 {
1252         struct udevice *bus;
1253         int ret;
1254
1255         *devp = NULL;
1256         ret = uclass_first_device(UCLASS_PCI, &bus);
1257         if (ret)
1258                 return ret;
1259
1260         return skip_to_next_device(bus, devp);
1261 }
1262
1263 ulong pci_conv_32_to_size(ulong value, uint offset, enum pci_size_t size)
1264 {
1265         switch (size) {
1266         case PCI_SIZE_8:
1267                 return (value >> ((offset & 3) * 8)) & 0xff;
1268         case PCI_SIZE_16:
1269                 return (value >> ((offset & 2) * 8)) & 0xffff;
1270         default:
1271                 return value;
1272         }
1273 }
1274
1275 ulong pci_conv_size_to_32(ulong old, ulong value, uint offset,
1276                           enum pci_size_t size)
1277 {
1278         uint off_mask;
1279         uint val_mask, shift;
1280         ulong ldata, mask;
1281
1282         switch (size) {
1283         case PCI_SIZE_8:
1284                 off_mask = 3;
1285                 val_mask = 0xff;
1286                 break;
1287         case PCI_SIZE_16:
1288                 off_mask = 2;
1289                 val_mask = 0xffff;
1290                 break;
1291         default:
1292                 return value;
1293         }
1294         shift = (offset & off_mask) * 8;
1295         ldata = (value & val_mask) << shift;
1296         mask = val_mask << shift;
1297         value = (old & ~mask) | ldata;
1298
1299         return value;
1300 }
1301
1302 int pci_get_dma_regions(struct udevice *dev, struct pci_region *memp, int index)
1303 {
1304         int pci_addr_cells, addr_cells, size_cells;
1305         int cells_per_record;
1306         const u32 *prop;
1307         int len;
1308         int i = 0;
1309
1310         prop = ofnode_get_property(dev_ofnode(dev), "dma-ranges", &len);
1311         if (!prop) {
1312                 log_err("PCI: Device '%s': Cannot decode dma-ranges\n",
1313                         dev->name);
1314                 return -EINVAL;
1315         }
1316
1317         pci_addr_cells = ofnode_read_simple_addr_cells(dev_ofnode(dev));
1318         addr_cells = ofnode_read_simple_addr_cells(dev_ofnode(dev->parent));
1319         size_cells = ofnode_read_simple_size_cells(dev_ofnode(dev));
1320
1321         /* PCI addresses are always 3-cells */
1322         len /= sizeof(u32);
1323         cells_per_record = pci_addr_cells + addr_cells + size_cells;
1324         debug("%s: len=%d, cells_per_record=%d\n", __func__, len,
1325               cells_per_record);
1326
1327         while (len) {
1328                 memp->bus_start = fdtdec_get_number(prop + 1, 2);
1329                 prop += pci_addr_cells;
1330                 memp->phys_start = fdtdec_get_number(prop, addr_cells);
1331                 prop += addr_cells;
1332                 memp->size = fdtdec_get_number(prop, size_cells);
1333                 prop += size_cells;
1334
1335                 if (i == index)
1336                         return 0;
1337                 i++;
1338                 len -= cells_per_record;
1339         }
1340
1341         return -EINVAL;
1342 }
1343
1344 int pci_get_regions(struct udevice *dev, struct pci_region **iop,
1345                     struct pci_region **memp, struct pci_region **prefp)
1346 {
1347         struct udevice *bus = pci_get_controller(dev);
1348         struct pci_controller *hose = dev_get_uclass_priv(bus);
1349         int i;
1350
1351         *iop = NULL;
1352         *memp = NULL;
1353         *prefp = NULL;
1354         for (i = 0; i < hose->region_count; i++) {
1355                 switch (hose->regions[i].flags) {
1356                 case PCI_REGION_IO:
1357                         if (!*iop || (*iop)->size < hose->regions[i].size)
1358                                 *iop = hose->regions + i;
1359                         break;
1360                 case PCI_REGION_MEM:
1361                         if (!*memp || (*memp)->size < hose->regions[i].size)
1362                                 *memp = hose->regions + i;
1363                         break;
1364                 case (PCI_REGION_MEM | PCI_REGION_PREFETCH):
1365                         if (!*prefp || (*prefp)->size < hose->regions[i].size)
1366                                 *prefp = hose->regions + i;
1367                         break;
1368                 }
1369         }
1370
1371         return (*iop != NULL) + (*memp != NULL) + (*prefp != NULL);
1372 }
1373
1374 u32 dm_pci_read_bar32(const struct udevice *dev, int barnum)
1375 {
1376         u32 addr;
1377         int bar;
1378
1379         bar = PCI_BASE_ADDRESS_0 + barnum * 4;
1380         dm_pci_read_config32(dev, bar, &addr);
1381
1382         /*
1383          * If we get an invalid address, return this so that comparisons with
1384          * FDT_ADDR_T_NONE work correctly
1385          */
1386         if (addr == 0xffffffff)
1387                 return addr;
1388         else if (addr & PCI_BASE_ADDRESS_SPACE_IO)
1389                 return addr & PCI_BASE_ADDRESS_IO_MASK;
1390         else
1391                 return addr & PCI_BASE_ADDRESS_MEM_MASK;
1392 }
1393
1394 void dm_pci_write_bar32(struct udevice *dev, int barnum, u32 addr)
1395 {
1396         int bar;
1397
1398         bar = PCI_BASE_ADDRESS_0 + barnum * 4;
1399         dm_pci_write_config32(dev, bar, addr);
1400 }
1401
1402 phys_addr_t dm_pci_bus_to_phys(struct udevice *dev, pci_addr_t bus_addr,
1403                                size_t len, unsigned long mask,
1404                                unsigned long flags)
1405 {
1406         struct udevice *ctlr;
1407         struct pci_controller *hose;
1408         struct pci_region *res;
1409         pci_addr_t offset;
1410         int i;
1411
1412         /* The root controller has the region information */
1413         ctlr = pci_get_controller(dev);
1414         hose = dev_get_uclass_priv(ctlr);
1415
1416         if (hose->region_count == 0)
1417                 return bus_addr;
1418
1419         for (i = 0; i < hose->region_count; i++) {
1420                 res = &hose->regions[i];
1421
1422                 if ((res->flags & mask) != flags)
1423                         continue;
1424
1425                 if (bus_addr < res->bus_start)
1426                         continue;
1427
1428                 offset = bus_addr - res->bus_start;
1429                 if (offset >= res->size)
1430                         continue;
1431
1432                 if (len > res->size - offset)
1433                         continue;
1434
1435                 return res->phys_start + offset;
1436         }
1437
1438         puts("pci_hose_bus_to_phys: invalid physical address\n");
1439         return 0;
1440 }
1441
1442 pci_addr_t dm_pci_phys_to_bus(struct udevice *dev, phys_addr_t phys_addr,
1443                               size_t len, unsigned long mask,
1444                               unsigned long flags)
1445 {
1446         struct udevice *ctlr;
1447         struct pci_controller *hose;
1448         struct pci_region *res;
1449         phys_addr_t offset;
1450         int i;
1451
1452         /* The root controller has the region information */
1453         ctlr = pci_get_controller(dev);
1454         hose = dev_get_uclass_priv(ctlr);
1455
1456         if (hose->region_count == 0)
1457                 return phys_addr;
1458
1459         for (i = 0; i < hose->region_count; i++) {
1460                 res = &hose->regions[i];
1461
1462                 if ((res->flags & mask) != flags)
1463                         continue;
1464
1465                 if (phys_addr < res->phys_start)
1466                         continue;
1467
1468                 offset = phys_addr - res->phys_start;
1469                 if (offset >= res->size)
1470                         continue;
1471
1472                 if (len > res->size - offset)
1473                         continue;
1474
1475                 return res->bus_start + offset;
1476         }
1477
1478         puts("pci_hose_phys_to_bus: invalid physical address\n");
1479         return 0;
1480 }
1481
1482 static phys_addr_t dm_pci_map_ea_virt(struct udevice *dev, int ea_off,
1483                                       struct pci_child_plat *pdata)
1484 {
1485         phys_addr_t addr = 0;
1486
1487         /*
1488          * In the case of a Virtual Function device using BAR
1489          * base and size, add offset for VFn BAR(1, 2, 3...n)
1490          */
1491         if (pdata->is_virtfn) {
1492                 size_t sz;
1493                 u32 ea_entry;
1494
1495                 /* MaxOffset, 1st DW */
1496                 dm_pci_read_config32(dev, ea_off + 8, &ea_entry);
1497                 sz = ea_entry & PCI_EA_FIELD_MASK;
1498                 /* Fill up lower 2 bits */
1499                 sz |= (~PCI_EA_FIELD_MASK);
1500
1501                 if (ea_entry & PCI_EA_IS_64) {
1502                         /* MaxOffset 2nd DW */
1503                         dm_pci_read_config32(dev, ea_off + 16, &ea_entry);
1504                         sz |= ((u64)ea_entry) << 32;
1505                 }
1506
1507                 addr = (pdata->virtid - 1) * (sz + 1);
1508         }
1509
1510         return addr;
1511 }
1512
1513 static void *dm_pci_map_ea_bar(struct udevice *dev, int bar, size_t offset,
1514                                size_t len, int ea_off,
1515                                struct pci_child_plat *pdata)
1516 {
1517         int ea_cnt, i, entry_size;
1518         int bar_id = (bar - PCI_BASE_ADDRESS_0) >> 2;
1519         u32 ea_entry;
1520         phys_addr_t addr;
1521
1522         if (IS_ENABLED(CONFIG_PCI_SRIOV)) {
1523                 /*
1524                  * In the case of a Virtual Function device, device is
1525                  * Physical function, so pdata will point to required VF
1526                  * specific data.
1527                  */
1528                 if (pdata->is_virtfn)
1529                         bar_id += PCI_EA_BEI_VF_BAR0;
1530         }
1531
1532         /* EA capability structure header */
1533         dm_pci_read_config32(dev, ea_off, &ea_entry);
1534         ea_cnt = (ea_entry >> 16) & PCI_EA_NUM_ENT_MASK;
1535         ea_off += PCI_EA_FIRST_ENT;
1536
1537         for (i = 0; i < ea_cnt; i++, ea_off += entry_size) {
1538                 /* Entry header */
1539                 dm_pci_read_config32(dev, ea_off, &ea_entry);
1540                 entry_size = ((ea_entry & PCI_EA_ES) + 1) << 2;
1541
1542                 if (((ea_entry & PCI_EA_BEI) >> 4) != bar_id)
1543                         continue;
1544
1545                 /* Base address, 1st DW */
1546                 dm_pci_read_config32(dev, ea_off + 4, &ea_entry);
1547                 addr = ea_entry & PCI_EA_FIELD_MASK;
1548                 if (ea_entry & PCI_EA_IS_64) {
1549                         /* Base address, 2nd DW, skip over 4B MaxOffset */
1550                         dm_pci_read_config32(dev, ea_off + 12, &ea_entry);
1551                         addr |= ((u64)ea_entry) << 32;
1552                 }
1553
1554                 if (IS_ENABLED(CONFIG_PCI_SRIOV))
1555                         addr += dm_pci_map_ea_virt(dev, ea_off, pdata);
1556
1557                 if (~((phys_addr_t)0) - addr < offset)
1558                         return NULL;
1559
1560                 /* size ignored for now */
1561                 return map_physmem(addr + offset, len, MAP_NOCACHE);
1562         }
1563
1564         return 0;
1565 }
1566
1567 void *dm_pci_map_bar(struct udevice *dev, int bar, size_t offset, size_t len,
1568                      unsigned long mask, unsigned long flags)
1569 {
1570         struct pci_child_plat *pdata = dev_get_parent_plat(dev);
1571         struct udevice *udev = dev;
1572         pci_addr_t pci_bus_addr;
1573         u32 bar_response;
1574         int ea_off;
1575
1576         if (IS_ENABLED(CONFIG_PCI_SRIOV)) {
1577                 /*
1578                  * In case of Virtual Function devices, use PF udevice
1579                  * as EA capability is defined in Physical Function
1580                  */
1581                 if (pdata->is_virtfn)
1582                         udev = pdata->pfdev;
1583         }
1584
1585         /*
1586          * if the function supports Enhanced Allocation use that instead of
1587          * BARs
1588          * Incase of virtual functions, pdata will help read VF BEI
1589          * and EA entry size.
1590          */
1591         if (IS_ENABLED(CONFIG_PCI_ENHANCED_ALLOCATION))
1592                 ea_off = dm_pci_find_capability(udev, PCI_CAP_ID_EA);
1593         else
1594                 ea_off = 0;
1595
1596         if (ea_off)
1597                 return dm_pci_map_ea_bar(udev, bar, offset, len, ea_off, pdata);
1598
1599         /* read BAR address */
1600         dm_pci_read_config32(udev, bar, &bar_response);
1601         pci_bus_addr = (pci_addr_t)(bar_response & ~0xf);
1602
1603         if (~((pci_addr_t)0) - pci_bus_addr < offset)
1604                 return NULL;
1605
1606         /*
1607          * Forward the length argument to dm_pci_bus_to_virt. The length will
1608          * be used to check that the entire address range has been declared as
1609          * a PCI range, but a better check would be to probe for the size of
1610          * the bar and prevent overflow more locally.
1611          */
1612         return dm_pci_bus_to_virt(udev, pci_bus_addr + offset, len, mask, flags,
1613                                   MAP_NOCACHE);
1614 }
1615
1616 static int _dm_pci_find_next_capability(struct udevice *dev, u8 pos, int cap)
1617 {
1618         int ttl = PCI_FIND_CAP_TTL;
1619         u8 id;
1620         u16 ent;
1621
1622         dm_pci_read_config8(dev, pos, &pos);
1623
1624         while (ttl--) {
1625                 if (pos < PCI_STD_HEADER_SIZEOF)
1626                         break;
1627                 pos &= ~3;
1628                 dm_pci_read_config16(dev, pos, &ent);
1629
1630                 id = ent & 0xff;
1631                 if (id == 0xff)
1632                         break;
1633                 if (id == cap)
1634                         return pos;
1635                 pos = (ent >> 8);
1636         }
1637
1638         return 0;
1639 }
1640
1641 int dm_pci_find_next_capability(struct udevice *dev, u8 start, int cap)
1642 {
1643         return _dm_pci_find_next_capability(dev, start + PCI_CAP_LIST_NEXT,
1644                                             cap);
1645 }
1646
1647 int dm_pci_find_capability(struct udevice *dev, int cap)
1648 {
1649         u16 status;
1650         u8 header_type;
1651         u8 pos;
1652
1653         dm_pci_read_config16(dev, PCI_STATUS, &status);
1654         if (!(status & PCI_STATUS_CAP_LIST))
1655                 return 0;
1656
1657         dm_pci_read_config8(dev, PCI_HEADER_TYPE, &header_type);
1658         if ((header_type & 0x7f) == PCI_HEADER_TYPE_CARDBUS)
1659                 pos = PCI_CB_CAPABILITY_LIST;
1660         else
1661                 pos = PCI_CAPABILITY_LIST;
1662
1663         return _dm_pci_find_next_capability(dev, pos, cap);
1664 }
1665
1666 int dm_pci_find_next_ext_capability(struct udevice *dev, int start, int cap)
1667 {
1668         u32 header;
1669         int ttl;
1670         int pos = PCI_CFG_SPACE_SIZE;
1671
1672         /* minimum 8 bytes per capability */
1673         ttl = (PCI_CFG_SPACE_EXP_SIZE - PCI_CFG_SPACE_SIZE) / 8;
1674
1675         if (start)
1676                 pos = start;
1677
1678         dm_pci_read_config32(dev, pos, &header);
1679         /*
1680          * If we have no capabilities, this is indicated by cap ID,
1681          * cap version and next pointer all being 0.
1682          */
1683         if (header == 0)
1684                 return 0;
1685
1686         while (ttl--) {
1687                 if (PCI_EXT_CAP_ID(header) == cap)
1688                         return pos;
1689
1690                 pos = PCI_EXT_CAP_NEXT(header);
1691                 if (pos < PCI_CFG_SPACE_SIZE)
1692                         break;
1693
1694                 dm_pci_read_config32(dev, pos, &header);
1695         }
1696
1697         return 0;
1698 }
1699
1700 int dm_pci_find_ext_capability(struct udevice *dev, int cap)
1701 {
1702         return dm_pci_find_next_ext_capability(dev, 0, cap);
1703 }
1704
1705 int dm_pci_flr(struct udevice *dev)
1706 {
1707         int pcie_off;
1708         u32 cap;
1709
1710         /* look for PCI Express Capability */
1711         pcie_off = dm_pci_find_capability(dev, PCI_CAP_ID_EXP);
1712         if (!pcie_off)
1713                 return -ENOENT;
1714
1715         /* check FLR capability */
1716         dm_pci_read_config32(dev, pcie_off + PCI_EXP_DEVCAP, &cap);
1717         if (!(cap & PCI_EXP_DEVCAP_FLR))
1718                 return -ENOENT;
1719
1720         dm_pci_clrset_config16(dev, pcie_off + PCI_EXP_DEVCTL, 0,
1721                                PCI_EXP_DEVCTL_BCR_FLR);
1722
1723         /* wait 100ms, per PCI spec */
1724         mdelay(100);
1725
1726         return 0;
1727 }
1728
1729 #if defined(CONFIG_PCI_SRIOV)
1730 int pci_sriov_init(struct udevice *pdev, int vf_en)
1731 {
1732         u16 vendor, device;
1733         struct udevice *bus;
1734         struct udevice *dev;
1735         pci_dev_t bdf;
1736         u16 ctrl;
1737         u16 num_vfs;
1738         u16 total_vf;
1739         u16 vf_offset;
1740         u16 vf_stride;
1741         int vf, ret;
1742         int pos;
1743
1744         pos = dm_pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
1745         if (!pos) {
1746                 debug("Error: SRIOV capability not found\n");
1747                 return -ENOENT;
1748         }
1749
1750         dm_pci_read_config16(pdev, pos + PCI_SRIOV_CTRL, &ctrl);
1751
1752         dm_pci_read_config16(pdev, pos + PCI_SRIOV_TOTAL_VF, &total_vf);
1753         if (vf_en > total_vf)
1754                 vf_en = total_vf;
1755         dm_pci_write_config16(pdev, pos + PCI_SRIOV_NUM_VF, vf_en);
1756
1757         ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE;
1758         dm_pci_write_config16(pdev, pos + PCI_SRIOV_CTRL, ctrl);
1759
1760         dm_pci_read_config16(pdev, pos + PCI_SRIOV_NUM_VF, &num_vfs);
1761         if (num_vfs > vf_en)
1762                 num_vfs = vf_en;
1763
1764         dm_pci_read_config16(pdev, pos + PCI_SRIOV_VF_OFFSET, &vf_offset);
1765         dm_pci_read_config16(pdev, pos + PCI_SRIOV_VF_STRIDE, &vf_stride);
1766
1767         dm_pci_read_config16(pdev, PCI_VENDOR_ID, &vendor);
1768         dm_pci_read_config16(pdev, pos + PCI_SRIOV_VF_DID, &device);
1769
1770         bdf = dm_pci_get_bdf(pdev);
1771
1772         pci_get_bus(PCI_BUS(bdf), &bus);
1773
1774         if (!bus)
1775                 return -ENODEV;
1776
1777         bdf += PCI_BDF(0, 0, vf_offset);
1778
1779         for (vf = 0; vf < num_vfs; vf++) {
1780                 struct pci_child_plat *pplat;
1781                 ulong class;
1782
1783                 pci_bus_read_config(bus, bdf, PCI_CLASS_DEVICE,
1784                                     &class, PCI_SIZE_16);
1785
1786                 debug("%s: bus %d/%s: found VF %x:%x\n", __func__,
1787                       dev_seq(bus), bus->name, PCI_DEV(bdf), PCI_FUNC(bdf));
1788
1789                 /* Find this device in the device tree */
1790                 ret = pci_bus_find_devfn(bus, PCI_MASK_BUS(bdf), &dev);
1791
1792                 if (ret == -ENODEV) {
1793                         struct pci_device_id find_id;
1794
1795                         memset(&find_id, '\0', sizeof(find_id));
1796                         find_id.vendor = vendor;
1797                         find_id.device = device;
1798                         find_id.class = class;
1799
1800                         ret = pci_find_and_bind_driver(bus, &find_id,
1801                                                        bdf, &dev);
1802
1803                         if (ret)
1804                                 return ret;
1805                 }
1806
1807                 /* Update the platform data */
1808                 pplat = dev_get_parent_plat(dev);
1809                 pplat->devfn = PCI_MASK_BUS(bdf);
1810                 pplat->vendor = vendor;
1811                 pplat->device = device;
1812                 pplat->class = class;
1813                 pplat->is_virtfn = true;
1814                 pplat->pfdev = pdev;
1815                 pplat->virtid = vf * vf_stride + vf_offset;
1816
1817                 debug("%s: bus %d/%s: found VF %x:%x %x:%x class %lx id %x\n",
1818                       __func__, dev_seq(dev), dev->name, PCI_DEV(bdf),
1819                       PCI_FUNC(bdf), vendor, device, class, pplat->virtid);
1820                 bdf += PCI_BDF(0, 0, vf_stride);
1821         }
1822
1823         return 0;
1824 }
1825
1826 int pci_sriov_get_totalvfs(struct udevice *pdev)
1827 {
1828         u16 total_vf;
1829         int pos;
1830
1831         pos = dm_pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
1832         if (!pos) {
1833                 debug("Error: SRIOV capability not found\n");
1834                 return -ENOENT;
1835         }
1836
1837         dm_pci_read_config16(pdev, pos + PCI_SRIOV_TOTAL_VF, &total_vf);
1838
1839         return total_vf;
1840 }
1841 #endif /* SRIOV */
1842
1843 UCLASS_DRIVER(pci) = {
1844         .id             = UCLASS_PCI,
1845         .name           = "pci",
1846         .flags          = DM_UC_FLAG_SEQ_ALIAS | DM_UC_FLAG_NO_AUTO_SEQ,
1847         .post_bind      = dm_scan_fdt_dev,
1848         .pre_probe      = pci_uclass_pre_probe,
1849         .post_probe     = pci_uclass_post_probe,
1850         .child_post_bind = pci_uclass_child_post_bind,
1851         .per_device_auto        = sizeof(struct pci_controller),
1852         .per_child_plat_auto    = sizeof(struct pci_child_plat),
1853 };
1854
1855 static const struct dm_pci_ops pci_bridge_ops = {
1856         .read_config    = pci_bridge_read_config,
1857         .write_config   = pci_bridge_write_config,
1858 };
1859
1860 static const struct udevice_id pci_bridge_ids[] = {
1861         { .compatible = "pci-bridge" },
1862         { }
1863 };
1864
1865 U_BOOT_DRIVER(pci_bridge_drv) = {
1866         .name           = "pci_bridge_drv",
1867         .id             = UCLASS_PCI,
1868         .of_match       = pci_bridge_ids,
1869         .ops            = &pci_bridge_ops,
1870 };
1871
1872 UCLASS_DRIVER(pci_generic) = {
1873         .id             = UCLASS_PCI_GENERIC,
1874         .name           = "pci_generic",
1875 };
1876
1877 static const struct udevice_id pci_generic_ids[] = {
1878         { .compatible = "pci-generic" },
1879         { }
1880 };
1881
1882 U_BOOT_DRIVER(pci_generic_drv) = {
1883         .name           = "pci_generic_drv",
1884         .id             = UCLASS_PCI_GENERIC,
1885         .of_match       = pci_generic_ids,
1886 };
1887
1888 int pci_init(void)
1889 {
1890         struct udevice *bus;
1891
1892         /*
1893          * Enumerate all known controller devices. Enumeration has the side-
1894          * effect of probing them, so PCIe devices will be enumerated too.
1895          */
1896         for (uclass_first_device_check(UCLASS_PCI, &bus);
1897              bus;
1898              uclass_next_device_check(&bus)) {
1899                 ;
1900         }
1901
1902         return 0;
1903 }