sys/compat/linuxkpi/common/include/linux/pci.h

   1 /*-
   2  * Copyright (c) 2010 Isilon Systems, Inc.
   3  * Copyright (c) 2010 iX Systems, Inc.
   4  * Copyright (c) 2010 Panasas, Inc.
   5  * Copyright (c) 2013-2016 Mellanox Technologies, Ltd.
   6  * All rights reserved.
   7  * Copyright (c) 2020-2021 The FreeBSD Foundation
   8  *
   9  * Portions of this software were developed by Björn Zeeb
  10  * under sponsorship from the FreeBSD Foundation.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice unmodified, this list of conditions, and the following
  17  *    disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * $FreeBSD$
  34  */
  35 #ifndef _LINUXKPI_LINUX_PCI_H_
  36 #define _LINUXKPI_LINUX_PCI_H_
  37
  38 #define CONFIG_PCI_MSI
  39
  40 #include <linux/types.h>
  41
  42 #include <sys/param.h>
  43 #include <sys/bus.h>
  44 #include <sys/module.h>
  45 #include <sys/nv.h>
  46 #include <sys/pciio.h>
  47 #include <sys/rman.h>
  48 #include <dev/pci/pcivar.h>
  49 #include <dev/pci/pcireg.h>
  50 #include <dev/pci/pci_private.h>
  51
  52 #include <machine/resource.h>
  53
  54 #include <linux/list.h>
  55 #include <linux/dmapool.h>
  56 #include <linux/dma-mapping.h>
  57 #include <linux/compiler.h>
  58 #include <linux/errno.h>
  59 #include <asm/atomic.h>
  60 #include <linux/device.h>
  61 #include <linux/pci_ids.h>
  62
  63 struct pci_device_id {
  64         uint32_t        vendor;
  65         uint32_t        device;
  66         uint32_t        subvendor;
  67         uint32_t        subdevice;
  68         uint32_t        class;
  69         uint32_t        class_mask;
  70         uintptr_t       driver_data;
  71 };
  72
  73 /* Linux has an empty element at the end of the ID table -> nitems() - 1. */
  74 #define MODULE_DEVICE_TABLE(_bus, _table)                               \
  75                                                                         \
  76 static device_method_t _ ## _bus ## _ ## _table ## _methods[] = {       \
  77         DEVMETHOD_END                                                   \
  78 };                                                                      \
  79                                                                         \
  80 static driver_t _ ## _bus ## _ ## _table ## _driver = {                 \
  81         "lkpi_" #_bus #_table,                                          \
  82         _ ## _bus ## _ ## _table ## _methods,                           \
  83         0                                                               \
  84 };                                                                      \
  85                                                                         \
  86 static devclass_t _ ## _bus ## _ ## _table ## _devclass;                \
  87                                                                         \
  88 DRIVER_MODULE(lkpi_ ## _table, pci, _ ## _bus ## _ ## _table ## _driver,\
  89         _ ## _bus ## _ ## _table ## _devclass, 0, 0);                   \
  90                                                                         \
  91 MODULE_PNP_INFO("U32:vendor;U32:device;V32:subvendor;V32:subdevice",    \
  92     _bus, lkpi_ ## _table, _table, nitems(_table) - 1)
  93
  94 #define PCI_ANY_ID                      -1U
  95
  96 #define PCI_DEVFN(slot, func)   ((((slot) & 0x1f) << 3) | ((func) & 0x07))
  97 #define PCI_SLOT(devfn)         (((devfn) >> 3) & 0x1f)
  98 #define PCI_FUNC(devfn)         ((devfn) & 0x07)
  99 #define PCI_BUS_NUM(devfn)      (((devfn) >> 8) & 0xff)
 100
 101 #define PCI_VDEVICE(_vendor, _device)                                   \
 102             .vendor = PCI_VENDOR_ID_##_vendor, .device = (_device),     \
 103             .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 104 #define PCI_DEVICE(_vendor, _device)                                    \
 105             .vendor = (_vendor), .device = (_device),                   \
 106             .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 107
 108 #define to_pci_dev(n)   container_of(n, struct pci_dev, dev)
 109
 110 #define PCI_VENDOR_ID           PCIR_DEVVENDOR
 111 #define PCI_COMMAND             PCIR_COMMAND
 112 #define PCI_COMMAND_INTX_DISABLE        PCIM_CMD_INTxDIS
 113 #define PCI_EXP_DEVCTL          PCIER_DEVICE_CTL                /* Device Control */
 114 #define PCI_EXP_LNKCTL          PCIER_LINK_CTL                  /* Link Control */
 115 #define PCI_EXP_LNKCTL_ASPM_L0S PCIEM_LINK_CTL_ASPMC_L0S
 116 #define PCI_EXP_LNKCTL_ASPM_L1  PCIEM_LINK_CTL_ASPMC_L1
 117 #define PCI_EXP_LNKCTL_ASPMC    PCIEM_LINK_CTL_ASPMC
 118 #define PCI_EXP_LNKCTL_CLKREQ_EN PCIEM_LINK_CTL_ECPM            /* Enable clock PM */
 119 #define PCI_EXP_LNKCTL_HAWD     PCIEM_LINK_CTL_HAWD
 120 #define PCI_EXP_FLAGS_TYPE      PCIEM_FLAGS_TYPE                /* Device/Port type */
 121 #define PCI_EXP_DEVCAP          PCIER_DEVICE_CAP                /* Device capabilities */
 122 #define PCI_EXP_DEVSTA          PCIER_DEVICE_STA                /* Device Status */
 123 #define PCI_EXP_LNKCAP          PCIER_LINK_CAP                  /* Link Capabilities */
 124 #define PCI_EXP_LNKSTA          PCIER_LINK_STA                  /* Link Status */
 125 #define PCI_EXP_SLTCAP          PCIER_SLOT_CAP                  /* Slot Capabilities */
 126 #define PCI_EXP_SLTCTL          PCIER_SLOT_CTL                  /* Slot Control */
 127 #define PCI_EXP_SLTSTA          PCIER_SLOT_STA                  /* Slot Status */
 128 #define PCI_EXP_RTCTL           PCIER_ROOT_CTL                  /* Root Control */
 129 #define PCI_EXP_RTCAP           PCIER_ROOT_CAP                  /* Root Capabilities */
 130 #define PCI_EXP_RTSTA           PCIER_ROOT_STA                  /* Root Status */
 131 #define PCI_EXP_DEVCAP2         PCIER_DEVICE_CAP2               /* Device Capabilities 2 */
 132 #define PCI_EXP_DEVCTL2         PCIER_DEVICE_CTL2               /* Device Control 2 */
 133 #define PCI_EXP_DEVCTL2_LTR_EN  PCIEM_CTL2_LTR_ENABLE
 134 #define PCI_EXP_LNKCAP2         PCIER_LINK_CAP2                 /* Link Capabilities 2 */
 135 #define PCI_EXP_LNKCTL2         PCIER_LINK_CTL2                 /* Link Control 2 */
 136 #define PCI_EXP_LNKSTA2         PCIER_LINK_STA2                 /* Link Status 2 */
 137 #define PCI_EXP_FLAGS           PCIER_FLAGS                     /* Capabilities register */
 138 #define PCI_EXP_FLAGS_VERS      PCIEM_FLAGS_VERSION             /* Capability version */
 139 #define PCI_EXP_TYPE_ROOT_PORT  PCIEM_TYPE_ROOT_PORT            /* Root Port */
 140 #define PCI_EXP_TYPE_ENDPOINT   PCIEM_TYPE_ENDPOINT             /* Express Endpoint */
 141 #define PCI_EXP_TYPE_LEG_END    PCIEM_TYPE_LEGACY_ENDPOINT      /* Legacy Endpoint */
 142 #define PCI_EXP_TYPE_DOWNSTREAM PCIEM_TYPE_DOWNSTREAM_PORT      /* Downstream Port */
 143 #define PCI_EXP_FLAGS_SLOT      PCIEM_FLAGS_SLOT                /* Slot implemented */
 144 #define PCI_EXP_TYPE_RC_EC      PCIEM_TYPE_ROOT_EC              /* Root Complex Event Collector */
 145 #define PCI_EXP_LNKCAP_SLS_2_5GB 0x01   /* Supported Link Speed 2.5GT/s */
 146 #define PCI_EXP_LNKCAP_SLS_5_0GB 0x02   /* Supported Link Speed 5.0GT/s */
 147 #define PCI_EXP_LNKCAP_SLS_8_0GB 0x04   /* Supported Link Speed 8.0GT/s */
 148 #define PCI_EXP_LNKCAP_SLS_16_0GB 0x08  /* Supported Link Speed 16.0GT/s */
 149 #define PCI_EXP_LNKCAP_MLW      0x03f0  /* Maximum Link Width */
 150 #define PCI_EXP_LNKCAP2_SLS_2_5GB 0x02  /* Supported Link Speed 2.5GT/s */
 151 #define PCI_EXP_LNKCAP2_SLS_5_0GB 0x04  /* Supported Link Speed 5.0GT/s */
 152 #define PCI_EXP_LNKCAP2_SLS_8_0GB 0x08  /* Supported Link Speed 8.0GT/s */
 153 #define PCI_EXP_LNKCAP2_SLS_16_0GB 0x10 /* Supported Link Speed 16.0GT/s */
 154 #define PCI_EXP_LNKCTL2_TLS             0x000f
 155 #define PCI_EXP_LNKCTL2_TLS_2_5GT       0x0001  /* Supported Speed 2.5GT/s */
 156 #define PCI_EXP_LNKCTL2_TLS_5_0GT       0x0002  /* Supported Speed 5GT/s */
 157 #define PCI_EXP_LNKCTL2_TLS_8_0GT       0x0003  /* Supported Speed 8GT/s */
 158 #define PCI_EXP_LNKCTL2_TLS_16_0GT      0x0004  /* Supported Speed 16GT/s */
 159 #define PCI_EXP_LNKCTL2_TLS_32_0GT      0x0005  /* Supported Speed 32GT/s */
 160 #define PCI_EXP_LNKCTL2_ENTER_COMP      0x0010  /* Enter Compliance */
 161 #define PCI_EXP_LNKCTL2_TX_MARGIN       0x0380  /* Transmit Margin */
 162
 163 #define PCI_EXP_LNKCAP_CLKPM    0x00040000
 164 #define PCI_EXP_DEVSTA_TRPND    0x0020
 165
 166 #define IORESOURCE_MEM  (1 << SYS_RES_MEMORY)
 167 #define IORESOURCE_IO   (1 << SYS_RES_IOPORT)
 168 #define IORESOURCE_IRQ  (1 << SYS_RES_IRQ)
 169
 170 enum pci_bus_speed {
 171         PCI_SPEED_UNKNOWN = -1,
 172         PCIE_SPEED_2_5GT,
 173         PCIE_SPEED_5_0GT,
 174         PCIE_SPEED_8_0GT,
 175         PCIE_SPEED_16_0GT,
 176 };
 177
 178 enum pcie_link_width {
 179         PCIE_LNK_WIDTH_RESRV    = 0x00,
 180         PCIE_LNK_X1             = 0x01,
 181         PCIE_LNK_X2             = 0x02,
 182         PCIE_LNK_X4             = 0x04,
 183         PCIE_LNK_X8             = 0x08,
 184         PCIE_LNK_X12            = 0x0c,
 185         PCIE_LNK_X16            = 0x10,
 186         PCIE_LNK_X32            = 0x20,
 187         PCIE_LNK_WIDTH_UNKNOWN  = 0xff,
 188 };
 189
 190 #define PCIE_LINK_STATE_L0S             0x00000001
 191 #define PCIE_LINK_STATE_L1              0x00000002
 192 #define PCIE_LINK_STATE_CLKPM           0x00000004
 193
 194 typedef int pci_power_t;
 195
 196 #define PCI_D0  PCI_POWERSTATE_D0
 197 #define PCI_D1  PCI_POWERSTATE_D1
 198 #define PCI_D2  PCI_POWERSTATE_D2
 199 #define PCI_D3hot       PCI_POWERSTATE_D3
 200 #define PCI_D3cold      4
 201
 202 #define PCI_POWER_ERROR PCI_POWERSTATE_UNKNOWN
 203
 204 #define PCI_ERR_ROOT_COMMAND            PCIR_AER_ROOTERR_CMD
 205 #define PCI_ERR_ROOT_ERR_SRC            PCIR_AER_COR_SOURCE_ID
 206
 207 #define PCI_EXT_CAP_ID_ERR              PCIZ_AER
 208 #define PCI_EXT_CAP_ID_L1SS             PCIZ_L1PM
 209
 210 #define PCI_L1SS_CTL1                   0x8
 211 #define PCI_L1SS_CTL1_L1SS_MASK         0xf
 212
 213 #define PCI_IRQ_LEGACY                  0x01
 214 #define PCI_IRQ_MSI                     0x02
 215 #define PCI_IRQ_MSIX                    0x04
 216
 217 struct pci_dev;
 218
 219 struct pci_driver {
 220         struct list_head                node;
 221         char                            *name;
 222         const struct pci_device_id              *id_table;
 223         int  (*probe)(struct pci_dev *dev, const struct pci_device_id *id);
 224         void (*remove)(struct pci_dev *dev);
 225         int  (*suspend) (struct pci_dev *dev, pm_message_t state);      /* Device suspended */
 226         int  (*resume) (struct pci_dev *dev);           /* Device woken up */
 227         void (*shutdown) (struct pci_dev *dev);         /* Device shutdown */
 228         driver_t                        bsddriver;
 229         devclass_t                      bsdclass;
 230         struct device_driver            driver;
 231         const struct pci_error_handlers       *err_handler;
 232         int                             bsd_probe_return;
 233         int  (*bsd_iov_init)(device_t dev, uint16_t num_vfs,
 234             const nvlist_t *pf_config);
 235         void  (*bsd_iov_uninit)(device_t dev);
 236         int  (*bsd_iov_add_vf)(device_t dev, uint16_t vfnum,
 237             const nvlist_t *vf_config);
 238        uintptr_t                       _spare[8];
 239 };
 240
 241 /*
 242  * Pseudo-stable KPI. In 13.0 we neglected to include any spare fields to allow
 243  * for growth in struct pci_driver. Those were added in 13.1, but can't be used
 244  * until 13.1 is the oldest supported release so that packages built in 13.0
 245  * will continue to work on stable/13 and 13.1 release. The 13.0 driver was 92
 246  * or 182 bytes on 32 or 64 bit systems (respectively). We added 64 or 32 bytes
 247  * of padding, hence the math below (which shouldn't be changed as spare fields
 248  * are used up).
 249  */
 250 #ifdef __LP64__
 251 #define __PCI_DRIVER_SIZE (184 + 64)
 252 #else
 253 #define __PCI_DRIVER_SIZE (92 + 32)
 254 #endif
 255 _Static_assert(sizeof(struct pci_driver) == __PCI_DRIVER_SIZE,
 256     "linuxkpi struct pci_driver: Bad size");
 257 #undef __PCI_DRIVER_SIZE
 258
 259 struct pci_bus {
 260         struct pci_dev  *self;
 261         int             domain;
 262         int             number;
 263 };
 264
 265 extern struct list_head pci_drivers;
 266 extern struct list_head pci_devices;
 267 extern spinlock_t pci_lock;
 268
 269 #define __devexit_p(x)  x
 270
 271 #define module_pci_driver(_driver)                                      \
 272                                                                         \
 273 static inline int                                                       \
 274 _pci_init(void)                                                         \
 275 {                                                                       \
 276                                                                         \
 277         return (linux_pci_register_driver(&_driver));                   \
 278 }                                                                       \
 279                                                                         \
 280 static inline void                                                      \
 281 _pci_exit(void)                                                         \
 282 {                                                                       \
 283                                                                         \
 284         linux_pci_unregister_driver(&_driver);                          \
 285 }                                                                       \
 286                                                                         \
 287 module_init(_pci_init);                                                 \
 288 module_exit(_pci_exit)
 289
 290 /*
 291  * If we find drivers accessing this from multiple KPIs we may have to
 292  * refcount objects of this structure.
 293  */
 294 struct pci_mmio_region {
 295         TAILQ_ENTRY(pci_mmio_region)    next;
 296         struct resource                 *res;
 297         int                             rid;
 298         int                             type;
 299 };
 300
 301 struct pci_dev {
 302         struct device           dev;
 303         struct list_head        links;
 304         struct pci_driver       *pdrv;
 305         struct pci_bus          *bus;
 306         uint16_t                device;
 307         uint16_t                vendor;
 308         uint16_t                subsystem_vendor;
 309         uint16_t                subsystem_device;
 310         unsigned int            irq;
 311         unsigned int            devfn;
 312         uint32_t                class;
 313         uint8_t                 revision;
 314         bool                    msi_enabled;
 315
 316         TAILQ_HEAD(, pci_mmio_region)   mmio;
 317
 318         /* Add all new items at the end of the list in 13 */
 319         struct pci_dev          *root;
 320         phys_addr_t             rom;
 321         size_t                  romlen;
 322         bool                    managed;        /* devres "pcim_*(). */
 323         bool                    want_iomap_res;
 324         bool                    msix_enabled;
 325 };
 326
 327 /* XXX add kassert here on the mmio offset */
 328
 329 /* We need some meta-struct to keep track of these for devres. */
 330 struct pci_devres {
 331         bool            enable_io;
 332         /* PCIR_MAX_BAR_0 + 1 = 6 => BIT(0..5). */
 333         uint8_t         region_mask;
 334         struct resource *region_table[PCIR_MAX_BAR_0 + 1]; /* Not needed. */
 335 };
 336 struct pcim_iomap_devres {
 337         void            *mmio_table[PCIR_MAX_BAR_0 + 1];
 338         struct resource *res_table[PCIR_MAX_BAR_0 + 1];
 339 };
 340
 341 int pci_request_region(struct pci_dev *pdev, int bar, const char *res_name);
 342 int pci_alloc_irq_vectors(struct pci_dev *pdev, int minv, int maxv,
 343     unsigned int flags);
 344
 345 /* Internal helper function(s). */
 346 struct pci_dev *lkpinew_pci_dev(device_t);
 347 struct pci_devres *lkpi_pci_devres_get_alloc(struct pci_dev *pdev);
 348 void lkpi_pci_devres_release(struct device *, void *);
 349 struct resource *_lkpi_pci_iomap(struct pci_dev *pdev, int bar, int mmio_size);
 350 void lkpi_pcim_iomap_table_release(struct device *, void *);
 351
 352 static inline int
 353 pci_resource_type(struct pci_dev *pdev, int bar)
 354 {
 355         struct pci_map *pm;
 356
 357         pm = pci_find_bar(pdev->dev.bsddev, PCIR_BAR(bar));
 358         if (!pm)
 359                 return (-1);
 360
 361         if (PCI_BAR_IO(pm->pm_value))
 362                 return (SYS_RES_IOPORT);
 363         else
 364                 return (SYS_RES_MEMORY);
 365 }
 366
 367 struct resource_list_entry *linux_pci_reserve_bar(struct pci_dev *pdev,
 368                     struct resource_list *rl, int type, int rid);
 369
 370 static inline struct resource_list_entry *
 371 linux_pci_get_rle(struct pci_dev *pdev, int type, int rid, bool reserve_bar)
 372 {
 373         struct pci_devinfo *dinfo;
 374         struct resource_list *rl;
 375         struct resource_list_entry *rle;
 376
 377         dinfo = device_get_ivars(pdev->dev.bsddev);
 378         rl = &dinfo->resources;
 379         rle = resource_list_find(rl, type, rid);
 380         /* Reserve resources for this BAR if needed. */
 381         if (rle == NULL && reserve_bar)
 382                 rle = linux_pci_reserve_bar(pdev, rl, type, rid);
 383         return (rle);
 384 }
 385
 386 static inline struct resource_list_entry *
 387 linux_pci_get_bar(struct pci_dev *pdev, int bar, bool reserve)
 388 {
 389         int type;
 390
 391         type = pci_resource_type(pdev, bar);
 392         if (type < 0)
 393                 return (NULL);
 394         bar = PCIR_BAR(bar);
 395         return (linux_pci_get_rle(pdev, type, bar, reserve));
 396 }
 397
 398 static inline struct device *
 399 linux_pci_find_irq_dev(unsigned int irq)
 400 {
 401         struct pci_dev *pdev;
 402         struct device *found;
 403
 404         found = NULL;
 405         spin_lock(&pci_lock);
 406         list_for_each_entry(pdev, &pci_devices, links) {
 407                 if (irq == pdev->dev.irq ||
 408                     (irq >= pdev->dev.irq_start && irq < pdev->dev.irq_end)) {
 409                         found = &pdev->dev;
 410                         break;
 411                 }
 412         }
 413         spin_unlock(&pci_lock);
 414         return (found);
 415 }
 416
 417 /*
 418  * All drivers just seem to want to inspect the type not flags.
 419  */
 420 static inline int
 421 pci_resource_flags(struct pci_dev *pdev, int bar)
 422 {
 423         int type;
 424
 425         type = pci_resource_type(pdev, bar);
 426         if (type < 0)
 427                 return (0);
 428         return (1 << type);
 429 }
 430
 431 static inline const char *
 432 pci_name(struct pci_dev *d)
 433 {
 434
 435         return device_get_desc(d->dev.bsddev);
 436 }
 437
 438 static inline void *
 439 pci_get_drvdata(struct pci_dev *pdev)
 440 {
 441
 442         return dev_get_drvdata(&pdev->dev);
 443 }
 444
 445 static inline void
 446 pci_set_drvdata(struct pci_dev *pdev, void *data)
 447 {
 448
 449         dev_set_drvdata(&pdev->dev, data);
 450 }
 451
 452 static inline struct pci_dev *
 453 pci_dev_get(struct pci_dev *pdev)
 454 {
 455
 456         if (pdev != NULL)
 457                 get_device(&pdev->dev);
 458         return (pdev);
 459 }
 460
 461 static __inline void
 462 pci_dev_put(struct pci_dev *pdev)
 463 {
 464
 465         if (pdev != NULL)
 466                 put_device(&pdev->dev);
 467 }
 468
 469 static inline int
 470 pci_enable_device(struct pci_dev *pdev)
 471 {
 472
 473         pci_enable_io(pdev->dev.bsddev, SYS_RES_IOPORT);
 474         pci_enable_io(pdev->dev.bsddev, SYS_RES_MEMORY);
 475         return (0);
 476 }
 477
 478 static inline void
 479 pci_disable_device(struct pci_dev *pdev)
 480 {
 481
 482         pci_disable_busmaster(pdev->dev.bsddev);
 483 }
 484
 485 static inline int
 486 pci_set_master(struct pci_dev *pdev)
 487 {
 488
 489         pci_enable_busmaster(pdev->dev.bsddev);
 490         return (0);
 491 }
 492
 493 static inline int
 494 pci_set_power_state(struct pci_dev *pdev, int state)
 495 {
 496
 497         pci_set_powerstate(pdev->dev.bsddev, state);
 498         return (0);
 499 }
 500
 501 static inline int
 502 pci_clear_master(struct pci_dev *pdev)
 503 {
 504
 505         pci_disable_busmaster(pdev->dev.bsddev);
 506         return (0);
 507 }
 508
 509 static inline bool
 510 pci_is_root_bus(struct pci_bus *pbus)
 511 {
 512
 513         return (pbus->self == NULL);
 514 }
 515
 516 static inline struct pci_dev *
 517 pci_upstream_bridge(struct pci_dev *pdev)
 518 {
 519
 520         if (pci_is_root_bus(pdev->bus))
 521                 return (NULL);
 522
 523         /*
 524          * If we do not have a (proper) "upstream bridge" set, e.g., we point
 525          * to ourselves, try to handle this case on the fly like we do
 526          * for pcie_find_root_port().
 527          */
 528         if (pdev == pdev->bus->self) {
 529                 device_t bridge;
 530
 531                 bridge = device_get_parent(pdev->dev.bsddev);
 532                 if (bridge == NULL)
 533                         goto done;
 534                 bridge = device_get_parent(bridge);
 535                 if (bridge == NULL)
 536                         goto done;
 537                 if (device_get_devclass(device_get_parent(bridge)) !=
 538                     devclass_find("pci"))
 539                         goto done;
 540
 541                 /*
 542                  * "bridge" is a PCI-to-PCI bridge.  Create a Linux pci_dev
 543                  * for it so it can be returned.
 544                  */
 545                 pdev->bus->self = lkpinew_pci_dev(bridge);
 546         }
 547 done:
 548         return (pdev->bus->self);
 549 }
 550
 551 static inline struct pci_devres *
 552 lkpi_pci_devres_find(struct pci_dev *pdev)
 553 {
 554
 555         if (!pdev->managed)
 556                 return (NULL);
 557
 558         return (lkpi_pci_devres_get_alloc(pdev));
 559 }
 560
 561 static inline void
 562 pci_release_region(struct pci_dev *pdev, int bar)
 563 {
 564         struct resource_list_entry *rle;
 565         struct pci_devres *dr;
 566         struct pci_mmio_region *mmio, *p;
 567
 568         if ((rle = linux_pci_get_bar(pdev, bar, false)) == NULL)
 569                 return;
 570
 571         /*
 572          * As we implicitly track the requests we also need to clear them on
 573          * release.  Do clear before resource release.
 574          */
 575         dr = lkpi_pci_devres_find(pdev);
 576         if (dr != NULL) {
 577                 KASSERT(dr->region_table[bar] == rle->res, ("%s: pdev %p bar %d"
 578                     " region_table res %p != rel->res %p\n", __func__, pdev,
 579                     bar, dr->region_table[bar], rle->res));
 580                 dr->region_table[bar] = NULL;
 581                 dr->region_mask &= ~(1 << bar);
 582         }
 583
 584         TAILQ_FOREACH_SAFE(mmio, &pdev->mmio, next, p) {
 585                 if (rle->res != (void *)rman_get_bushandle(mmio->res))
 586                         continue;
 587                 TAILQ_REMOVE(&pdev->mmio, mmio, next);
 588                 free(mmio, M_DEVBUF);
 589         }
 590
 591         bus_release_resource(pdev->dev.bsddev, rle->type, rle->rid, rle->res);
 592 }
 593
 594 static inline void
 595 pci_release_regions(struct pci_dev *pdev)
 596 {
 597         int i;
 598
 599         for (i = 0; i <= PCIR_MAX_BAR_0; i++)
 600                 pci_release_region(pdev, i);
 601 }
 602
 603 static inline int
 604 pci_request_regions(struct pci_dev *pdev, const char *res_name)
 605 {
 606         int error;
 607         int i;
 608
 609         for (i = 0; i <= PCIR_MAX_BAR_0; i++) {
 610                 error = pci_request_region(pdev, i, res_name);
 611                 if (error && error != -ENODEV) {
 612                         pci_release_regions(pdev);
 613                         return (error);
 614                 }
 615         }
 616         return (0);
 617 }
 618
 619 static inline void
 620 lkpi_pci_disable_msix(struct pci_dev *pdev)
 621 {
 622
 623         pci_release_msi(pdev->dev.bsddev);
 624
 625         /*
 626          * The MSIX IRQ numbers associated with this PCI device are no
 627          * longer valid and might be re-assigned. Make sure
 628          * linux_pci_find_irq_dev() does no longer see them by
 629          * resetting their references to zero:
 630          */
 631         pdev->dev.irq_start = 0;
 632         pdev->dev.irq_end = 0;
 633         pdev->msix_enabled = false;
 634 }
 635 /* Only for consistency. No conflict on that one. */
 636 #define pci_disable_msix(pdev)          lkpi_pci_disable_msix(pdev)
 637
 638 static inline void
 639 lkpi_pci_disable_msi(struct pci_dev *pdev)
 640 {
 641
 642         pci_release_msi(pdev->dev.bsddev);
 643
 644         pdev->dev.irq_start = 0;
 645         pdev->dev.irq_end = 0;
 646         pdev->irq = pdev->dev.irq;
 647         pdev->msi_enabled = false;
 648 }
 649 #define pci_disable_msi(pdev)           lkpi_pci_disable_msi(pdev)
 650 #define pci_free_irq_vectors(pdev)      lkpi_pci_disable_msi(pdev)
 651
 652 unsigned long   pci_resource_start(struct pci_dev *pdev, int bar);
 653 unsigned long   pci_resource_len(struct pci_dev *pdev, int bar);
 654
 655 static inline bus_addr_t
 656 pci_bus_address(struct pci_dev *pdev, int bar)
 657 {
 658
 659         return (pci_resource_start(pdev, bar));
 660 }
 661
 662 #define PCI_CAP_ID_EXP  PCIY_EXPRESS
 663 #define PCI_CAP_ID_PCIX PCIY_PCIX
 664 #define PCI_CAP_ID_AGP  PCIY_AGP
 665 #define PCI_CAP_ID_PM   PCIY_PMG
 666
 667 #define PCI_EXP_DEVCTL          PCIER_DEVICE_CTL
 668 #define PCI_EXP_DEVCTL_PAYLOAD  PCIEM_CTL_MAX_PAYLOAD
 669 #define PCI_EXP_DEVCTL_READRQ   PCIEM_CTL_MAX_READ_REQUEST
 670 #define PCI_EXP_LNKCTL          PCIER_LINK_CTL
 671 #define PCI_EXP_LNKSTA          PCIER_LINK_STA
 672
 673 static inline int
 674 pci_find_capability(struct pci_dev *pdev, int capid)
 675 {
 676         int reg;
 677
 678         if (pci_find_cap(pdev->dev.bsddev, capid, &reg))
 679                 return (0);
 680         return (reg);
 681 }
 682
 683 static inline int pci_pcie_cap(struct pci_dev *dev)
 684 {
 685         return pci_find_capability(dev, PCI_CAP_ID_EXP);
 686 }
 687
 688 static inline int
 689 pci_find_ext_capability(struct pci_dev *pdev, int capid)
 690 {
 691         int reg;
 692
 693         if (pci_find_extcap(pdev->dev.bsddev, capid, &reg))
 694                 return (0);
 695         return (reg);
 696 }
 697
 698 #define PCIM_PCAP_PME_SHIFT     11
 699 static __inline bool
 700 pci_pme_capable(struct pci_dev *pdev, uint32_t flag)
 701 {
 702         struct pci_devinfo *dinfo;
 703         pcicfgregs *cfg;
 704
 705         if (flag > (PCIM_PCAP_D3PME_COLD >> PCIM_PCAP_PME_SHIFT))
 706                 return (false);
 707
 708         dinfo = device_get_ivars(pdev->dev.bsddev);
 709         cfg = &dinfo->cfg;
 710
 711         if (cfg->pp.pp_cap == 0)
 712                 return (false);
 713
 714         if ((cfg->pp.pp_cap & (1 << (PCIM_PCAP_PME_SHIFT + flag))) != 0)
 715                 return (true);
 716
 717         return (false);
 718 }
 719
 720 static inline int
 721 pci_disable_link_state(struct pci_dev *pdev, uint32_t flags)
 722 {
 723
 724         if (!pci_enable_aspm)
 725                 return (-EPERM);
 726
 727         return (-ENXIO);
 728 }
 729
 730 static inline int
 731 pci_read_config_byte(const struct pci_dev *pdev, int where, u8 *val)
 732 {
 733
 734         *val = (u8)pci_read_config(pdev->dev.bsddev, where, 1);
 735         return (0);
 736 }
 737
 738 static inline int
 739 pci_read_config_word(const struct pci_dev *pdev, int where, u16 *val)
 740 {
 741
 742         *val = (u16)pci_read_config(pdev->dev.bsddev, where, 2);
 743         return (0);
 744 }
 745
 746 static inline int
 747 pci_read_config_dword(const struct pci_dev *pdev, int where, u32 *val)
 748 {
 749
 750         *val = (u32)pci_read_config(pdev->dev.bsddev, where, 4);
 751         return (0);
 752 }
 753
 754 static inline int
 755 pci_write_config_byte(const struct pci_dev *pdev, int where, u8 val)
 756 {
 757
 758         pci_write_config(pdev->dev.bsddev, where, val, 1);
 759         return (0);
 760 }
 761
 762 static inline int
 763 pci_write_config_word(const struct pci_dev *pdev, int where, u16 val)
 764 {
 765
 766         pci_write_config(pdev->dev.bsddev, where, val, 2);
 767         return (0);
 768 }
 769
 770 static inline int
 771 pci_write_config_dword(const struct pci_dev *pdev, int where, u32 val)
 772 {
 773
 774         pci_write_config(pdev->dev.bsddev, where, val, 4);
 775         return (0);
 776 }
 777
 778 int     linux_pci_register_driver(struct pci_driver *pdrv);
 779 int     linux_pci_register_drm_driver(struct pci_driver *pdrv);
 780 void    linux_pci_unregister_driver(struct pci_driver *pdrv);
 781 void    linux_pci_unregister_drm_driver(struct pci_driver *pdrv);
 782
 783 #define pci_register_driver(pdrv)       linux_pci_register_driver(pdrv)
 784 #define pci_unregister_driver(pdrv)     linux_pci_unregister_driver(pdrv)
 785
 786 struct msix_entry {
 787         int entry;
 788         int vector;
 789 };
 790
 791 /*
 792  * Enable msix, positive errors indicate actual number of available
 793  * vectors.  Negative errors are failures.
 794  *
 795  * NB: define added to prevent this definition of pci_enable_msix from
 796  * clashing with the native FreeBSD version.
 797  */
 798 #define pci_enable_msix(...) \
 799   linux_pci_enable_msix(__VA_ARGS__)
 800
 801 static inline int
 802 pci_enable_msix(struct pci_dev *pdev, struct msix_entry *entries, int nreq)
 803 {
 804         struct resource_list_entry *rle;
 805         int error;
 806         int avail;
 807         int i;
 808
 809         avail = pci_msix_count(pdev->dev.bsddev);
 810         if (avail < nreq) {
 811                 if (avail == 0)
 812                         return -EINVAL;
 813                 return avail;
 814         }
 815         avail = nreq;
 816         if ((error = -pci_alloc_msix(pdev->dev.bsddev, &avail)) != 0)
 817                 return error;
 818         /*
 819          * Handle case where "pci_alloc_msix()" may allocate less
 820          * interrupts than available and return with no error:
 821          */
 822         if (avail < nreq) {
 823                 pci_release_msi(pdev->dev.bsddev);
 824                 return avail;
 825         }
 826         rle = linux_pci_get_rle(pdev, SYS_RES_IRQ, 1, false);
 827         pdev->dev.irq_start = rle->start;
 828         pdev->dev.irq_end = rle->start + avail;
 829         for (i = 0; i < nreq; i++)
 830                 entries[i].vector = pdev->dev.irq_start + i;
 831         pdev->msix_enabled = true;
 832         return (0);
 833 }
 834
 835 #define pci_enable_msix_range(...) \
 836   linux_pci_enable_msix_range(__VA_ARGS__)
 837
 838 static inline int
 839 pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries,
 840     int minvec, int maxvec)
 841 {
 842         int nvec = maxvec;
 843         int rc;
 844
 845         if (maxvec < minvec)
 846                 return (-ERANGE);
 847
 848         do {
 849                 rc = pci_enable_msix(dev, entries, nvec);
 850                 if (rc < 0) {
 851                         return (rc);
 852                 } else if (rc > 0) {
 853                         if (rc < minvec)
 854                                 return (-ENOSPC);
 855                         nvec = rc;
 856                 }
 857         } while (rc);
 858         return (nvec);
 859 }
 860
 861 #define pci_enable_msi(pdev) \
 862   linux_pci_enable_msi(pdev)
 863
 864 static inline int
 865 pci_enable_msi(struct pci_dev *pdev)
 866 {
 867         struct resource_list_entry *rle;
 868         int error;
 869         int avail;
 870
 871         avail = pci_msi_count(pdev->dev.bsddev);
 872         if (avail < 1)
 873                 return -EINVAL;
 874
 875         avail = 1;      /* this function only enable one MSI IRQ */
 876         if ((error = -pci_alloc_msi(pdev->dev.bsddev, &avail)) != 0)
 877                 return error;
 878
 879         rle = linux_pci_get_rle(pdev, SYS_RES_IRQ, 1, false);
 880         pdev->dev.irq_start = rle->start;
 881         pdev->dev.irq_end = rle->start + avail;
 882         pdev->irq = rle->start;
 883         pdev->msi_enabled = true;
 884         return (0);
 885 }
 886
 887 static inline int
 888 pci_channel_offline(struct pci_dev *pdev)
 889 {
 890
 891         return (pci_read_config(pdev->dev.bsddev, PCIR_VENDOR, 2) == PCIV_INVALID);
 892 }
 893
 894 static inline int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
 895 {
 896         return -ENODEV;
 897 }
 898
 899 static inline void pci_disable_sriov(struct pci_dev *dev)
 900 {
 901 }
 902
 903 static inline void *
 904 pci_iomap(struct pci_dev *pdev, int mmio_bar, int mmio_size)
 905 {
 906         struct resource *res;
 907
 908         res = _lkpi_pci_iomap(pdev, mmio_bar, mmio_size);
 909         if (res == NULL)
 910                 return (NULL);
 911         /* This is a FreeBSD extension so we can use bus_*(). */
 912         if (pdev->want_iomap_res)
 913                 return (res);
 914         return ((void *)rman_get_bushandle(res));
 915 }
 916
 917 static inline void
 918 pci_iounmap(struct pci_dev *pdev, void *res)
 919 {
 920         struct pci_mmio_region *mmio, *p;
 921
 922         TAILQ_FOREACH_SAFE(mmio, &pdev->mmio, next, p) {
 923                 if (res != (void *)rman_get_bushandle(mmio->res))
 924                         continue;
 925                 bus_release_resource(pdev->dev.bsddev,
 926                     mmio->type, mmio->rid, mmio->res);
 927                 TAILQ_REMOVE(&pdev->mmio, mmio, next);
 928                 free(mmio, M_DEVBUF);
 929                 return;
 930         }
 931 }
 932
 933 static inline void
 934 lkpi_pci_save_state(struct pci_dev *pdev)
 935 {
 936
 937         pci_save_state(pdev->dev.bsddev);
 938 }
 939
 940 static inline void
 941 lkpi_pci_restore_state(struct pci_dev *pdev)
 942 {
 943
 944         pci_restore_state(pdev->dev.bsddev);
 945 }
 946
 947 #define pci_save_state(dev)     lkpi_pci_save_state(dev)
 948 #define pci_restore_state(dev)  lkpi_pci_restore_state(dev)
 949
 950 #define DEFINE_PCI_DEVICE_TABLE(_table) \
 951         const struct pci_device_id _table[] __devinitdata
 952
 953 /* XXX This should not be necessary. */
 954 #define pcix_set_mmrbc(d, v)    0
 955 #define pcix_get_max_mmrbc(d)   0
 956 #define pcie_set_readrq(d, v)   pci_set_max_read_req((d)->dev.bsddev, (v))
 957
 958 #define PCI_DMA_BIDIRECTIONAL   0
 959 #define PCI_DMA_TODEVICE        1
 960 #define PCI_DMA_FROMDEVICE      2
 961 #define PCI_DMA_NONE            3
 962
 963 #define pci_pool                dma_pool
 964 #define pci_pool_destroy(...)   dma_pool_destroy(__VA_ARGS__)
 965 #define pci_pool_alloc(...)     dma_pool_alloc(__VA_ARGS__)
 966 #define pci_pool_free(...)      dma_pool_free(__VA_ARGS__)
 967 #define pci_pool_create(_name, _pdev, _size, _align, _alloc)            \
 968             dma_pool_create(_name, &(_pdev)->dev, _size, _align, _alloc)
 969 #define pci_free_consistent(_hwdev, _size, _vaddr, _dma_handle)         \
 970             dma_free_coherent((_hwdev) == NULL ? NULL : &(_hwdev)->dev, \
 971                 _size, _vaddr, _dma_handle)
 972 #define pci_map_sg(_hwdev, _sg, _nents, _dir)                           \
 973             dma_map_sg((_hwdev) == NULL ? NULL : &(_hwdev->dev),        \
 974                 _sg, _nents, (enum dma_data_direction)_dir)
 975 #define pci_map_single(_hwdev, _ptr, _size, _dir)                       \
 976             dma_map_single((_hwdev) == NULL ? NULL : &(_hwdev->dev),    \
 977                 (_ptr), (_size), (enum dma_data_direction)_dir)
 978 #define pci_unmap_single(_hwdev, _addr, _size, _dir)                    \
 979             dma_unmap_single((_hwdev) == NULL ? NULL : &(_hwdev)->dev,  \
 980                 _addr, _size, (enum dma_data_direction)_dir)
 981 #define pci_unmap_sg(_hwdev, _sg, _nents, _dir)                         \
 982             dma_unmap_sg((_hwdev) == NULL ? NULL : &(_hwdev)->dev,      \
 983                 _sg, _nents, (enum dma_data_direction)_dir)
 984 #define pci_map_page(_hwdev, _page, _offset, _size, _dir)               \
 985             dma_map_page((_hwdev) == NULL ? NULL : &(_hwdev)->dev, _page,\
 986                 _offset, _size, (enum dma_data_direction)_dir)
 987 #define pci_unmap_page(_hwdev, _dma_address, _size, _dir)               \
 988             dma_unmap_page((_hwdev) == NULL ? NULL : &(_hwdev)->dev,    \
 989                 _dma_address, _size, (enum dma_data_direction)_dir)
 990 #define pci_set_dma_mask(_pdev, mask)   dma_set_mask(&(_pdev)->dev, (mask))
 991 #define pci_dma_mapping_error(_pdev, _dma_addr)                         \
 992             dma_mapping_error(&(_pdev)->dev, _dma_addr)
 993 #define pci_set_consistent_dma_mask(_pdev, _mask)                       \
 994             dma_set_coherent_mask(&(_pdev)->dev, (_mask))
 995 #define DECLARE_PCI_UNMAP_ADDR(x)       DEFINE_DMA_UNMAP_ADDR(x);
 996 #define DECLARE_PCI_UNMAP_LEN(x)        DEFINE_DMA_UNMAP_LEN(x);
 997 #define pci_unmap_addr          dma_unmap_addr
 998 #define pci_unmap_addr_set      dma_unmap_addr_set
 999 #define pci_unmap_len           dma_unmap_len
1000 #define pci_unmap_len_set       dma_unmap_len_set
1001
1002 typedef unsigned int __bitwise pci_channel_state_t;
1003 typedef unsigned int __bitwise pci_ers_result_t;
1004
1005 enum pci_channel_state {
1006         pci_channel_io_normal = 1,
1007         pci_channel_io_frozen = 2,
1008         pci_channel_io_perm_failure = 3,
1009 };
1010
1011 enum pci_ers_result {
1012         PCI_ERS_RESULT_NONE = 1,
1013         PCI_ERS_RESULT_CAN_RECOVER = 2,
1014         PCI_ERS_RESULT_NEED_RESET = 3,
1015         PCI_ERS_RESULT_DISCONNECT = 4,
1016         PCI_ERS_RESULT_RECOVERED = 5,
1017 };
1018
1019 /* PCI bus error event callbacks */
1020 struct pci_error_handlers {
1021         pci_ers_result_t (*error_detected)(struct pci_dev *dev,
1022             enum pci_channel_state error);
1023         pci_ers_result_t (*mmio_enabled)(struct pci_dev *dev);
1024         pci_ers_result_t (*link_reset)(struct pci_dev *dev);
1025         pci_ers_result_t (*slot_reset)(struct pci_dev *dev);
1026         void (*resume)(struct pci_dev *dev);
1027 };
1028
1029 /* FreeBSD does not support SRIOV - yet */
1030 static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
1031 {
1032         return dev;
1033 }
1034
1035 static inline bool pci_is_pcie(struct pci_dev *dev)
1036 {
1037         return !!pci_pcie_cap(dev);
1038 }
1039
1040 static inline u16 pcie_flags_reg(struct pci_dev *dev)
1041 {
1042         int pos;
1043         u16 reg16;
1044
1045         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
1046         if (!pos)
1047                 return 0;
1048
1049         pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &reg16);
1050
1051         return reg16;
1052 }
1053
1054 static inline int pci_pcie_type(struct pci_dev *dev)
1055 {
1056         return (pcie_flags_reg(dev) & PCI_EXP_FLAGS_TYPE) >> 4;
1057 }
1058
1059 static inline int pcie_cap_version(struct pci_dev *dev)
1060 {
1061         return pcie_flags_reg(dev) & PCI_EXP_FLAGS_VERS;
1062 }
1063
1064 static inline bool pcie_cap_has_lnkctl(struct pci_dev *dev)
1065 {
1066         int type = pci_pcie_type(dev);
1067
1068         return pcie_cap_version(dev) > 1 ||
1069                type == PCI_EXP_TYPE_ROOT_PORT ||
1070                type == PCI_EXP_TYPE_ENDPOINT ||
1071                type == PCI_EXP_TYPE_LEG_END;
1072 }
1073
1074 static inline bool pcie_cap_has_devctl(const struct pci_dev *dev)
1075 {
1076                 return true;
1077 }
1078
1079 static inline bool pcie_cap_has_sltctl(struct pci_dev *dev)
1080 {
1081         int type = pci_pcie_type(dev);
1082
1083         return pcie_cap_version(dev) > 1 || type == PCI_EXP_TYPE_ROOT_PORT ||
1084             (type == PCI_EXP_TYPE_DOWNSTREAM &&
1085             pcie_flags_reg(dev) & PCI_EXP_FLAGS_SLOT);
1086 }
1087
1088 static inline bool pcie_cap_has_rtctl(struct pci_dev *dev)
1089 {
1090         int type = pci_pcie_type(dev);
1091
1092         return pcie_cap_version(dev) > 1 || type == PCI_EXP_TYPE_ROOT_PORT ||
1093             type == PCI_EXP_TYPE_RC_EC;
1094 }
1095
1096 static bool pcie_capability_reg_implemented(struct pci_dev *dev, int pos)
1097 {
1098         if (!pci_is_pcie(dev))
1099                 return false;
1100
1101         switch (pos) {
1102         case PCI_EXP_FLAGS_TYPE:
1103                 return true;
1104         case PCI_EXP_DEVCAP:
1105         case PCI_EXP_DEVCTL:
1106         case PCI_EXP_DEVSTA:
1107                 return pcie_cap_has_devctl(dev);
1108         case PCI_EXP_LNKCAP:
1109         case PCI_EXP_LNKCTL:
1110         case PCI_EXP_LNKSTA:
1111                 return pcie_cap_has_lnkctl(dev);
1112         case PCI_EXP_SLTCAP:
1113         case PCI_EXP_SLTCTL:
1114         case PCI_EXP_SLTSTA:
1115                 return pcie_cap_has_sltctl(dev);
1116         case PCI_EXP_RTCTL:
1117         case PCI_EXP_RTCAP:
1118         case PCI_EXP_RTSTA:
1119                 return pcie_cap_has_rtctl(dev);
1120         case PCI_EXP_DEVCAP2:
1121         case PCI_EXP_DEVCTL2:
1122         case PCI_EXP_LNKCAP2:
1123         case PCI_EXP_LNKCTL2:
1124         case PCI_EXP_LNKSTA2:
1125                 return pcie_cap_version(dev) > 1;
1126         default:
1127                 return false;
1128         }
1129 }
1130
1131 static inline int
1132 pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *dst)
1133 {
1134         if (pos & 3)
1135                 return -EINVAL;
1136
1137         if (!pcie_capability_reg_implemented(dev, pos))
1138                 return -EINVAL;
1139
1140         return pci_read_config_dword(dev, pci_pcie_cap(dev) + pos, dst);
1141 }
1142
1143 static inline int
1144 pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *dst)
1145 {
1146         if (pos & 3)
1147                 return -EINVAL;
1148
1149         if (!pcie_capability_reg_implemented(dev, pos))
1150                 return -EINVAL;
1151
1152         return pci_read_config_word(dev, pci_pcie_cap(dev) + pos, dst);
1153 }
1154
1155 static inline int
1156 pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val)
1157 {
1158         if (pos & 1)
1159                 return -EINVAL;
1160
1161         if (!pcie_capability_reg_implemented(dev, pos))
1162                 return 0;
1163
1164         return pci_write_config_word(dev, pci_pcie_cap(dev) + pos, val);
1165 }
1166
1167 static inline int pcie_get_minimum_link(struct pci_dev *dev,
1168     enum pci_bus_speed *speed, enum pcie_link_width *width)
1169 {
1170         *speed = PCI_SPEED_UNKNOWN;
1171         *width = PCIE_LNK_WIDTH_UNKNOWN;
1172         return (0);
1173 }
1174
1175 static inline int
1176 pci_num_vf(struct pci_dev *dev)
1177 {
1178         return (0);
1179 }
1180
1181 static inline enum pci_bus_speed
1182 pcie_get_speed_cap(struct pci_dev *dev)
1183 {
1184         device_t root;
1185         uint32_t lnkcap, lnkcap2;
1186         int error, pos;
1187
1188         root = device_get_parent(dev->dev.bsddev);
1189         if (root == NULL)
1190                 return (PCI_SPEED_UNKNOWN);
1191         root = device_get_parent(root);
1192         if (root == NULL)
1193                 return (PCI_SPEED_UNKNOWN);
1194         root = device_get_parent(root);
1195         if (root == NULL)
1196                 return (PCI_SPEED_UNKNOWN);
1197
1198         if (pci_get_vendor(root) == PCI_VENDOR_ID_VIA ||
1199             pci_get_vendor(root) == PCI_VENDOR_ID_SERVERWORKS)
1200                 return (PCI_SPEED_UNKNOWN);
1201
1202         if ((error = pci_find_cap(root, PCIY_EXPRESS, &pos)) != 0)
1203                 return (PCI_SPEED_UNKNOWN);
1204
1205         lnkcap2 = pci_read_config(root, pos + PCIER_LINK_CAP2, 4);
1206
1207         if (lnkcap2) {  /* PCIe r3.0-compliant */
1208                 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB)
1209                         return (PCIE_SPEED_2_5GT);
1210                 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB)
1211                         return (PCIE_SPEED_5_0GT);
1212                 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB)
1213                         return (PCIE_SPEED_8_0GT);
1214                 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_16_0GB)
1215                         return (PCIE_SPEED_16_0GT);
1216         } else {        /* pre-r3.0 */
1217                 lnkcap = pci_read_config(root, pos + PCIER_LINK_CAP, 4);
1218                 if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB)
1219                         return (PCIE_SPEED_2_5GT);
1220                 if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB)
1221                         return (PCIE_SPEED_5_0GT);
1222                 if (lnkcap & PCI_EXP_LNKCAP_SLS_8_0GB)
1223                         return (PCIE_SPEED_8_0GT);
1224                 if (lnkcap & PCI_EXP_LNKCAP_SLS_16_0GB)
1225                         return (PCIE_SPEED_16_0GT);
1226         }
1227         return (PCI_SPEED_UNKNOWN);
1228 }
1229
1230 static inline enum pcie_link_width
1231 pcie_get_width_cap(struct pci_dev *dev)
1232 {
1233         uint32_t lnkcap;
1234
1235         pcie_capability_read_dword(dev, PCI_EXP_LNKCAP, &lnkcap);
1236         if (lnkcap)
1237                 return ((lnkcap & PCI_EXP_LNKCAP_MLW) >> 4);
1238
1239         return (PCIE_LNK_WIDTH_UNKNOWN);
1240 }
1241
1242 static inline int
1243 pcie_get_mps(struct pci_dev *dev)
1244 {
1245         return (pci_get_max_payload(dev->dev.bsddev));
1246 }
1247
1248 static inline uint32_t
1249 PCIE_SPEED2MBS_ENC(enum pci_bus_speed spd)
1250 {
1251
1252         switch(spd) {
1253         case PCIE_SPEED_16_0GT:
1254                 return (16000 * 128 / 130);
1255         case PCIE_SPEED_8_0GT:
1256                 return (8000 * 128 / 130);
1257         case PCIE_SPEED_5_0GT:
1258                 return (5000 * 8 / 10);
1259         case PCIE_SPEED_2_5GT:
1260                 return (2500 * 8 / 10);
1261         default:
1262                 return (0);
1263         }
1264 }
1265
1266 static inline uint32_t
1267 pcie_bandwidth_available(struct pci_dev *pdev,
1268     struct pci_dev **limiting,
1269     enum pci_bus_speed *speed,
1270     enum pcie_link_width *width)
1271 {
1272         enum pci_bus_speed nspeed = pcie_get_speed_cap(pdev);
1273         enum pcie_link_width nwidth = pcie_get_width_cap(pdev);
1274
1275         if (speed)
1276                 *speed = nspeed;
1277         if (width)
1278                 *width = nwidth;
1279
1280         return (nwidth * PCIE_SPEED2MBS_ENC(nspeed));
1281 }
1282
1283 static inline struct pci_dev *
1284 pcie_find_root_port(struct pci_dev *pdev)
1285 {
1286         device_t root;
1287
1288         if (pdev->root != NULL)
1289                 return (pdev->root);
1290
1291         root = pci_find_pcie_root_port(pdev->dev.bsddev);
1292         if (root == NULL)
1293                 return (NULL);
1294
1295         pdev->root = lkpinew_pci_dev(root);
1296         return (pdev->root);
1297 }
1298
1299 /* This is needed when people rip out the device "HotPlug". */
1300 static inline void
1301 pci_lock_rescan_remove(void)
1302 {
1303 }
1304
1305 static inline void
1306 pci_unlock_rescan_remove(void)
1307 {
1308 }
1309
1310 static __inline void
1311 pci_stop_and_remove_bus_device(struct pci_dev *pdev)
1312 {
1313 }
1314
1315 /*
1316  * The following functions can be used to attach/detach the LinuxKPI's
1317  * PCI device runtime. The pci_driver and pci_device_id pointer is
1318  * allowed to be NULL. Other pointers must be all valid.
1319  * The pci_dev structure should be zero-initialized before passed
1320  * to the linux_pci_attach_device function.
1321  */
1322 extern int linux_pci_attach_device(device_t, struct pci_driver *,
1323     const struct pci_device_id *, struct pci_dev *);
1324 extern int linux_pci_detach_device(struct pci_dev *);
1325
1326 static inline int
1327 pci_dev_present(const struct pci_device_id *cur)
1328 {
1329         while (cur != NULL && (cur->vendor || cur->device)) {
1330                 if (pci_find_device(cur->vendor, cur->device) != NULL) {
1331                         return (1);
1332                 }
1333                 cur++;
1334         }
1335         return (0);
1336 }
1337
1338 struct pci_dev *lkpi_pci_get_domain_bus_and_slot(int domain,
1339     unsigned int bus, unsigned int devfn);
1340 #define pci_get_domain_bus_and_slot(domain, bus, devfn) \
1341         lkpi_pci_get_domain_bus_and_slot(domain, bus, devfn)
1342
1343 static inline int
1344 pci_domain_nr(struct pci_bus *pbus)
1345 {
1346
1347         return (pbus->domain);
1348 }
1349
1350 static inline int
1351 pci_bus_read_config(struct pci_bus *bus, unsigned int devfn,
1352                     int pos, uint32_t *val, int len)
1353 {
1354
1355         *val = pci_read_config(bus->self->dev.bsddev, pos, len);
1356         return (0);
1357 }
1358
1359 static inline int
1360 pci_bus_read_config_word(struct pci_bus *bus, unsigned int devfn, int pos, u16 *val)
1361 {
1362         uint32_t tmp;
1363         int ret;
1364
1365         ret = pci_bus_read_config(bus, devfn, pos, &tmp, 2);
1366         *val = (u16)tmp;
1367         return (ret);
1368 }
1369
1370 static inline int
1371 pci_bus_read_config_byte(struct pci_bus *bus, unsigned int devfn, int pos, u8 *val)
1372 {
1373         uint32_t tmp;
1374         int ret;
1375
1376         ret = pci_bus_read_config(bus, devfn, pos, &tmp, 1);
1377         *val = (u8)tmp;
1378         return (ret);
1379 }
1380
1381 static inline int
1382 pci_bus_write_config(struct pci_bus *bus, unsigned int devfn, int pos,
1383     uint32_t val, int size)
1384 {
1385
1386         pci_write_config(bus->self->dev.bsddev, pos, val, size);
1387         return (0);
1388 }
1389
1390 static inline int
1391 pci_bus_write_config_byte(struct pci_bus *bus, unsigned int devfn, int pos,
1392     uint8_t val)
1393 {
1394         return (pci_bus_write_config(bus, devfn, pos, val, 1));
1395 }
1396
1397 static inline int
1398 pci_bus_write_config_word(struct pci_bus *bus, unsigned int devfn, int pos,
1399     uint16_t val)
1400 {
1401         return (pci_bus_write_config(bus, devfn, pos, val, 2));
1402 }
1403
1404 struct pci_dev *lkpi_pci_get_class(unsigned int class, struct pci_dev *from);
1405 #define pci_get_class(class, from)      lkpi_pci_get_class(class, from)
1406
1407 /* -------------------------------------------------------------------------- */
1408
1409 static inline int
1410 pcim_enable_device(struct pci_dev *pdev)
1411 {
1412         struct pci_devres *dr;
1413         int error;
1414
1415         /* Here we cannot run through the pdev->managed check. */
1416         dr = lkpi_pci_devres_get_alloc(pdev);
1417         if (dr == NULL)
1418                 return (-ENOMEM);
1419
1420         /* If resources were enabled before do not do it again. */
1421         if (dr->enable_io)
1422                 return (0);
1423
1424         error = pci_enable_device(pdev);
1425         if (error == 0)
1426                 dr->enable_io = true;
1427
1428         /* This device is not managed. */
1429         pdev->managed = true;
1430
1431         return (error);
1432 }
1433
1434 static inline struct pcim_iomap_devres *
1435 lkpi_pcim_iomap_devres_find(struct pci_dev *pdev)
1436 {
1437         struct pcim_iomap_devres *dr;
1438
1439         dr = lkpi_devres_find(&pdev->dev, lkpi_pcim_iomap_table_release,
1440             NULL, NULL);
1441         if (dr == NULL) {
1442                 dr = lkpi_devres_alloc(lkpi_pcim_iomap_table_release,
1443                     sizeof(*dr), GFP_KERNEL | __GFP_ZERO);
1444                 if (dr != NULL)
1445                         lkpi_devres_add(&pdev->dev, dr);
1446         }
1447
1448         if (dr == NULL)
1449                 device_printf(pdev->dev.bsddev, "%s: NULL\n", __func__);
1450
1451         return (dr);
1452 }
1453
1454 static inline void __iomem **
1455 pcim_iomap_table(struct pci_dev *pdev)
1456 {
1457         struct pcim_iomap_devres *dr;
1458
1459         dr = lkpi_pcim_iomap_devres_find(pdev);
1460         if (dr == NULL)
1461                 return (NULL);
1462
1463         /*
1464          * If the driver has manually set a flag to be able to request the
1465          * resource to use bus_read/write_<n>, return the shadow table.
1466          */
1467         if (pdev->want_iomap_res)
1468                 return ((void **)dr->res_table);
1469
1470         /* This is the Linux default. */
1471         return (dr->mmio_table);
1472 }
1473
1474 static inline int
1475 pcim_iomap_regions_request_all(struct pci_dev *pdev, uint32_t mask, char *name)
1476 {
1477         struct pcim_iomap_devres *dr;
1478         void *res;
1479         uint32_t mappings, requests, req_mask;
1480         int bar, error;
1481
1482         dr = lkpi_pcim_iomap_devres_find(pdev);
1483         if (dr == NULL)
1484                 return (-ENOMEM);
1485
1486         /* Request all the BARs ("regions") we do not iomap. */
1487         req_mask = ((1 << (PCIR_MAX_BAR_0 + 1)) - 1) & ~mask;
1488         for (bar = requests = 0; requests != req_mask; bar++) {
1489                 if ((req_mask & (1 << bar)) == 0)
1490                         continue;
1491                 error = pci_request_region(pdev, bar, name);
1492                 if (error != 0 && error != -ENODEV)
1493                         goto err;
1494                 requests |= (1 << bar);
1495         }
1496
1497         /* Now iomap all the requested (by "mask") ones. */
1498         for (bar = mappings = 0; mappings != mask; bar++) {
1499                 if ((mask & (1 << bar)) == 0)
1500                         continue;
1501
1502                 /* Request double is not allowed. */
1503                 if (dr->mmio_table[bar] != NULL) {
1504                         device_printf(pdev->dev.bsddev, "%s: bar %d %p\n",
1505                              __func__, bar, dr->mmio_table[bar]);
1506                         goto err;
1507                 }
1508
1509                 res = _lkpi_pci_iomap(pdev, bar, 0);
1510                 if (res == NULL)
1511                         goto err;
1512                 dr->mmio_table[bar] = (void *)rman_get_bushandle(res);
1513                 dr->res_table[bar] = res;
1514
1515                 mappings |= (1 << bar);
1516         }
1517
1518         return (0);
1519
1520 err:
1521         for (bar = PCIR_MAX_BAR_0; bar >= 0; bar--) {
1522                 if ((mappings & (1 << bar)) != 0) {
1523                         res = dr->mmio_table[bar];
1524                         if (res == NULL)
1525                                 continue;
1526                         pci_iounmap(pdev, res);
1527                 } else if ((requests & (1 << bar)) != 0) {
1528                         pci_release_region(pdev, bar);
1529                 }
1530         }
1531
1532         return (-EINVAL);
1533 }
1534
1535 /* This is a FreeBSD extension so we can use bus_*(). */
1536 static inline void
1537 linuxkpi_pcim_want_to_use_bus_functions(struct pci_dev *pdev)
1538 {
1539         pdev->want_iomap_res = true;
1540 }
1541
1542 #endif  /* _LINUXKPI_LINUX_PCI_H_ */