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  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice unmodified, this list of conditions, and the following
  13  *    disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * $FreeBSD$
  30  */
  31 #ifndef _LINUX_PCI_H_
  32 #define _LINUX_PCI_H_
  33
  34 #define CONFIG_PCI_MSI
  35
  36 #include <linux/types.h>
  37
  38 #include <sys/param.h>
  39 #include <sys/bus.h>
  40 #include <sys/nv.h>
  41 #include <sys/pciio.h>
  42 #include <sys/rman.h>
  43 #include <sys/bus.h>
  44 #include <dev/pci/pcivar.h>
  45 #include <dev/pci/pcireg.h>
  46 #include <dev/pci/pci_private.h>
  47
  48 #include <machine/resource.h>
  49
  50 #include <linux/list.h>
  51 #include <linux/dmapool.h>
  52 #include <linux/dma-mapping.h>
  53 #include <linux/compiler.h>
  54 #include <linux/errno.h>
  55 #include <asm/atomic.h>
  56 #include <linux/device.h>
  57
  58 struct pci_device_id {
  59         uint32_t        vendor;
  60         uint32_t        device;
  61         uint32_t        subvendor;
  62         uint32_t        subdevice;
  63         uint32_t        class;
  64         uint32_t        class_mask;
  65         uintptr_t       driver_data;
  66 };
  67
  68 #define MODULE_DEVICE_TABLE(bus, table)
  69
  70 #define PCI_BASE_CLASS_DISPLAY          0x03
  71 #define PCI_CLASS_DISPLAY_VGA           0x0300
  72 #define PCI_CLASS_DISPLAY_OTHER         0x0380
  73 #define PCI_BASE_CLASS_BRIDGE           0x06
  74 #define PCI_CLASS_BRIDGE_ISA            0x0601
  75
  76 #define PCI_ANY_ID                      -1U
  77 #define PCI_VENDOR_ID_APPLE             0x106b
  78 #define PCI_VENDOR_ID_ASUSTEK           0x1043
  79 #define PCI_VENDOR_ID_ATI               0x1002
  80 #define PCI_VENDOR_ID_DELL              0x1028
  81 #define PCI_VENDOR_ID_HP                0x103c
  82 #define PCI_VENDOR_ID_IBM               0x1014
  83 #define PCI_VENDOR_ID_INTEL             0x8086
  84 #define PCI_VENDOR_ID_MELLANOX                  0x15b3
  85 #define PCI_VENDOR_ID_REDHAT_QUMRANET   0x1af4
  86 #define PCI_VENDOR_ID_SERVERWORKS       0x1166
  87 #define PCI_VENDOR_ID_SONY              0x104d
  88 #define PCI_VENDOR_ID_TOPSPIN                   0x1867
  89 #define PCI_VENDOR_ID_VIA               0x1106
  90 #define PCI_SUBVENDOR_ID_REDHAT_QUMRANET        0x1af4
  91 #define PCI_DEVICE_ID_ATI_RADEON_QY     0x5159
  92 #define PCI_DEVICE_ID_MELLANOX_TAVOR            0x5a44
  93 #define PCI_DEVICE_ID_MELLANOX_TAVOR_BRIDGE     0x5a46
  94 #define PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT     0x6278
  95 #define PCI_DEVICE_ID_MELLANOX_ARBEL            0x6282
  96 #define PCI_DEVICE_ID_MELLANOX_SINAI_OLD        0x5e8c
  97 #define PCI_DEVICE_ID_MELLANOX_SINAI            0x6274
  98 #define PCI_SUBDEVICE_ID_QEMU           0x1100
  99
 100 #define PCI_DEVFN(slot, func)   ((((slot) & 0x1f) << 3) | ((func) & 0x07))
 101 #define PCI_SLOT(devfn)         (((devfn) >> 3) & 0x1f)
 102 #define PCI_FUNC(devfn)         ((devfn) & 0x07)
 103 #define PCI_BUS_NUM(devfn)      (((devfn) >> 8) & 0xff)
 104
 105 #define PCI_VDEVICE(_vendor, _device)                                   \
 106             .vendor = PCI_VENDOR_ID_##_vendor, .device = (_device),     \
 107             .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 108 #define PCI_DEVICE(_vendor, _device)                                    \
 109             .vendor = (_vendor), .device = (_device),                   \
 110             .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 111
 112 #define to_pci_dev(n)   container_of(n, struct pci_dev, dev)
 113
 114 #define PCI_VENDOR_ID           PCIR_DEVVENDOR
 115 #define PCI_COMMAND             PCIR_COMMAND
 116 #define PCI_EXP_DEVCTL          PCIER_DEVICE_CTL                /* Device Control */
 117 #define PCI_EXP_LNKCTL          PCIER_LINK_CTL                  /* Link Control */
 118 #define PCI_EXP_FLAGS_TYPE      PCIEM_FLAGS_TYPE                /* Device/Port type */
 119 #define PCI_EXP_DEVCAP          PCIER_DEVICE_CAP                /* Device capabilities */
 120 #define PCI_EXP_DEVSTA          PCIER_DEVICE_STA                /* Device Status */
 121 #define PCI_EXP_LNKCAP          PCIER_LINK_CAP                  /* Link Capabilities */
 122 #define PCI_EXP_LNKSTA          PCIER_LINK_STA                  /* Link Status */
 123 #define PCI_EXP_SLTCAP          PCIER_SLOT_CAP                  /* Slot Capabilities */
 124 #define PCI_EXP_SLTCTL          PCIER_SLOT_CTL                  /* Slot Control */
 125 #define PCI_EXP_SLTSTA          PCIER_SLOT_STA                  /* Slot Status */
 126 #define PCI_EXP_RTCTL           PCIER_ROOT_CTL                  /* Root Control */
 127 #define PCI_EXP_RTCAP           PCIER_ROOT_CAP                  /* Root Capabilities */
 128 #define PCI_EXP_RTSTA           PCIER_ROOT_STA                  /* Root Status */
 129 #define PCI_EXP_DEVCAP2         PCIER_DEVICE_CAP2               /* Device Capabilities 2 */
 130 #define PCI_EXP_DEVCTL2         PCIER_DEVICE_CTL2               /* Device Control 2 */
 131 #define PCI_EXP_LNKCAP2         PCIER_LINK_CAP2                 /* Link Capabilities 2 */
 132 #define PCI_EXP_LNKCTL2         PCIER_LINK_CTL2                 /* Link Control 2 */
 133 #define PCI_EXP_LNKSTA2         PCIER_LINK_STA2                 /* Link Status 2 */
 134 #define PCI_EXP_FLAGS           PCIER_FLAGS                     /* Capabilities register */
 135 #define PCI_EXP_FLAGS_VERS      PCIEM_FLAGS_VERSION             /* Capability version */
 136 #define PCI_EXP_TYPE_ROOT_PORT  PCIEM_TYPE_ROOT_PORT            /* Root Port */
 137 #define PCI_EXP_TYPE_ENDPOINT   PCIEM_TYPE_ENDPOINT             /* Express Endpoint */
 138 #define PCI_EXP_TYPE_LEG_END    PCIEM_TYPE_LEGACY_ENDPOINT      /* Legacy Endpoint */
 139 #define PCI_EXP_TYPE_DOWNSTREAM PCIEM_TYPE_DOWNSTREAM_PORT      /* Downstream Port */
 140 #define PCI_EXP_FLAGS_SLOT      PCIEM_FLAGS_SLOT                /* Slot implemented */
 141 #define PCI_EXP_TYPE_RC_EC      PCIEM_TYPE_ROOT_EC              /* Root Complex Event Collector */
 142 #define PCI_EXP_LNKCAP_SLS_2_5GB 0x01   /* Supported Link Speed 2.5GT/s */
 143 #define PCI_EXP_LNKCAP_SLS_5_0GB 0x02   /* Supported Link Speed 5.0GT/s */
 144 #define PCI_EXP_LNKCAP_SLS_8_0GB 0x04   /* Supported Link Speed 8.0GT/s */
 145 #define PCI_EXP_LNKCAP_SLS_16_0GB 0x08  /* Supported Link Speed 16.0GT/s */
 146 #define PCI_EXP_LNKCAP_MLW      0x03f0  /* Maximum Link Width */
 147 #define PCI_EXP_LNKCAP2_SLS_2_5GB 0x02  /* Supported Link Speed 2.5GT/s */
 148 #define PCI_EXP_LNKCAP2_SLS_5_0GB 0x04  /* Supported Link Speed 5.0GT/s */
 149 #define PCI_EXP_LNKCAP2_SLS_8_0GB 0x08  /* Supported Link Speed 8.0GT/s */
 150 #define PCI_EXP_LNKCAP2_SLS_16_0GB 0x10 /* Supported Link Speed 16.0GT/s */
 151
 152 #define PCI_EXP_LNKCTL_HAWD     PCIEM_LINK_CTL_HAWD
 153 #define PCI_EXP_LNKCAP_CLKPM    0x00040000
 154 #define PCI_EXP_DEVSTA_TRPND    0x0020
 155
 156 #define IORESOURCE_MEM  (1 << SYS_RES_MEMORY)
 157 #define IORESOURCE_IO   (1 << SYS_RES_IOPORT)
 158 #define IORESOURCE_IRQ  (1 << SYS_RES_IRQ)
 159
 160 enum pci_bus_speed {
 161         PCI_SPEED_UNKNOWN = -1,
 162         PCIE_SPEED_2_5GT,
 163         PCIE_SPEED_5_0GT,
 164         PCIE_SPEED_8_0GT,
 165         PCIE_SPEED_16_0GT,
 166 };
 167
 168 enum pcie_link_width {
 169         PCIE_LNK_WIDTH_RESRV    = 0x00,
 170         PCIE_LNK_X1             = 0x01,
 171         PCIE_LNK_X2             = 0x02,
 172         PCIE_LNK_X4             = 0x04,
 173         PCIE_LNK_X8             = 0x08,
 174         PCIE_LNK_X12            = 0x0c,
 175         PCIE_LNK_X16            = 0x10,
 176         PCIE_LNK_X32            = 0x20,
 177         PCIE_LNK_WIDTH_UNKNOWN  = 0xff,
 178 };
 179
 180 typedef int pci_power_t;
 181
 182 #define PCI_D0  PCI_POWERSTATE_D0
 183 #define PCI_D1  PCI_POWERSTATE_D1
 184 #define PCI_D2  PCI_POWERSTATE_D2
 185 #define PCI_D3hot       PCI_POWERSTATE_D3
 186 #define PCI_D3cold      4
 187
 188 #define PCI_POWER_ERROR PCI_POWERSTATE_UNKNOWN
 189
 190 struct pci_dev;
 191
 192 struct pci_driver {
 193         struct list_head                links;
 194         char                            *name;
 195         const struct pci_device_id              *id_table;
 196         int  (*probe)(struct pci_dev *dev, const struct pci_device_id *id);
 197         void (*remove)(struct pci_dev *dev);
 198         int  (*suspend) (struct pci_dev *dev, pm_message_t state);      /* Device suspended */
 199         int  (*resume) (struct pci_dev *dev);           /* Device woken up */
 200         void (*shutdown) (struct pci_dev *dev);         /* Device shutdown */
 201         driver_t                        bsddriver;
 202         devclass_t                      bsdclass;
 203         struct device_driver            driver;
 204         const struct pci_error_handlers       *err_handler;
 205         bool                            isdrm;
 206         int  (*bsd_iov_init)(device_t dev, uint16_t num_vfs,
 207             const nvlist_t *pf_config);
 208         void  (*bsd_iov_uninit)(device_t dev);
 209         int  (*bsd_iov_add_vf)(device_t dev, uint16_t vfnum,
 210             const nvlist_t *vf_config);
 211 };
 212
 213 struct pci_bus {
 214         struct pci_dev  *self;
 215         int             domain;
 216         int             number;
 217 };
 218
 219 extern struct list_head pci_drivers;
 220 extern struct list_head pci_devices;
 221 extern spinlock_t pci_lock;
 222
 223 #define __devexit_p(x)  x
 224
 225 struct pci_mmio_region {
 226         TAILQ_ENTRY(pci_mmio_region)    next;
 227         struct resource                 *res;
 228         int                             rid;
 229         int                             type;
 230 };
 231
 232 struct pci_dev {
 233         struct device           dev;
 234         struct list_head        links;
 235         struct pci_driver       *pdrv;
 236         struct pci_bus          *bus;
 237         uint16_t                device;
 238         uint16_t                vendor;
 239         uint16_t                subsystem_vendor;
 240         uint16_t                subsystem_device;
 241         unsigned int            irq;
 242         unsigned int            devfn;
 243         uint32_t                class;
 244         uint8_t                 revision;
 245         bool                    msi_enabled;
 246
 247         TAILQ_HEAD(, pci_mmio_region)   mmio;
 248 };
 249
 250 static inline struct resource_list_entry *
 251 linux_pci_get_rle(struct pci_dev *pdev, int type, int rid)
 252 {
 253         struct pci_devinfo *dinfo;
 254         struct resource_list *rl;
 255
 256         dinfo = device_get_ivars(pdev->dev.bsddev);
 257         rl = &dinfo->resources;
 258         return resource_list_find(rl, type, rid);
 259 }
 260
 261 static inline struct resource_list_entry *
 262 linux_pci_get_bar(struct pci_dev *pdev, int bar)
 263 {
 264         struct resource_list_entry *rle;
 265
 266         bar = PCIR_BAR(bar);
 267         if ((rle = linux_pci_get_rle(pdev, SYS_RES_MEMORY, bar)) == NULL)
 268                 rle = linux_pci_get_rle(pdev, SYS_RES_IOPORT, bar);
 269         return (rle);
 270 }
 271
 272 static inline struct device *
 273 linux_pci_find_irq_dev(unsigned int irq)
 274 {
 275         struct pci_dev *pdev;
 276         struct device *found;
 277
 278         found = NULL;
 279         spin_lock(&pci_lock);
 280         list_for_each_entry(pdev, &pci_devices, links) {
 281                 if (irq == pdev->dev.irq ||
 282                     (irq >= pdev->dev.irq_start && irq < pdev->dev.irq_end)) {
 283                         found = &pdev->dev;
 284                         break;
 285                 }
 286         }
 287         spin_unlock(&pci_lock);
 288         return (found);
 289 }
 290
 291 static inline int
 292 pci_resource_type(struct pci_dev *pdev, int bar)
 293 {
 294         struct pci_map *pm;
 295
 296         pm = pci_find_bar(pdev->dev.bsddev, PCIR_BAR(bar));
 297         if (!pm)
 298                 return (-1);
 299
 300         if (PCI_BAR_IO(pm->pm_value))
 301                 return (SYS_RES_IOPORT);
 302         else
 303                 return (SYS_RES_MEMORY);
 304 }
 305
 306 /*
 307  * All drivers just seem to want to inspect the type not flags.
 308  */
 309 static inline int
 310 pci_resource_flags(struct pci_dev *pdev, int bar)
 311 {
 312         int type;
 313
 314         type = pci_resource_type(pdev, bar);
 315         if (type < 0)
 316                 return (0);
 317         return (1 << type);
 318 }
 319
 320 static inline const char *
 321 pci_name(struct pci_dev *d)
 322 {
 323
 324         return device_get_desc(d->dev.bsddev);
 325 }
 326
 327 static inline void *
 328 pci_get_drvdata(struct pci_dev *pdev)
 329 {
 330
 331         return dev_get_drvdata(&pdev->dev);
 332 }
 333
 334 static inline void
 335 pci_set_drvdata(struct pci_dev *pdev, void *data)
 336 {
 337
 338         dev_set_drvdata(&pdev->dev, data);
 339 }
 340
 341 static inline int
 342 pci_enable_device(struct pci_dev *pdev)
 343 {
 344
 345         pci_enable_io(pdev->dev.bsddev, SYS_RES_IOPORT);
 346         pci_enable_io(pdev->dev.bsddev, SYS_RES_MEMORY);
 347         return (0);
 348 }
 349
 350 static inline void
 351 pci_disable_device(struct pci_dev *pdev)
 352 {
 353
 354         pci_disable_busmaster(pdev->dev.bsddev);
 355 }
 356
 357 static inline int
 358 pci_set_master(struct pci_dev *pdev)
 359 {
 360
 361         pci_enable_busmaster(pdev->dev.bsddev);
 362         return (0);
 363 }
 364
 365 static inline int
 366 pci_set_power_state(struct pci_dev *pdev, int state)
 367 {
 368
 369         pci_set_powerstate(pdev->dev.bsddev, state);
 370         return (0);
 371 }
 372
 373 static inline int
 374 pci_clear_master(struct pci_dev *pdev)
 375 {
 376
 377         pci_disable_busmaster(pdev->dev.bsddev);
 378         return (0);
 379 }
 380
 381 static inline int
 382 pci_request_region(struct pci_dev *pdev, int bar, const char *res_name)
 383 {
 384         int rid;
 385         int type;
 386
 387         type = pci_resource_type(pdev, bar);
 388         if (type < 0)
 389                 return (-ENODEV);
 390         rid = PCIR_BAR(bar);
 391         if (bus_alloc_resource_any(pdev->dev.bsddev, type, &rid,
 392             RF_ACTIVE) == NULL)
 393                 return (-EINVAL);
 394         return (0);
 395 }
 396
 397 static inline void
 398 pci_release_region(struct pci_dev *pdev, int bar)
 399 {
 400         struct resource_list_entry *rle;
 401
 402         if ((rle = linux_pci_get_bar(pdev, bar)) == NULL)
 403                 return;
 404         bus_release_resource(pdev->dev.bsddev, rle->type, rle->rid, rle->res);
 405 }
 406
 407 static inline void
 408 pci_release_regions(struct pci_dev *pdev)
 409 {
 410         int i;
 411
 412         for (i = 0; i <= PCIR_MAX_BAR_0; i++)
 413                 pci_release_region(pdev, i);
 414 }
 415
 416 static inline int
 417 pci_request_regions(struct pci_dev *pdev, const char *res_name)
 418 {
 419         int error;
 420         int i;
 421
 422         for (i = 0; i <= PCIR_MAX_BAR_0; i++) {
 423                 error = pci_request_region(pdev, i, res_name);
 424                 if (error && error != -ENODEV) {
 425                         pci_release_regions(pdev);
 426                         return (error);
 427                 }
 428         }
 429         return (0);
 430 }
 431
 432 static inline void
 433 pci_disable_msix(struct pci_dev *pdev)
 434 {
 435
 436         pci_release_msi(pdev->dev.bsddev);
 437
 438         /*
 439          * The MSIX IRQ numbers associated with this PCI device are no
 440          * longer valid and might be re-assigned. Make sure
 441          * linux_pci_find_irq_dev() does no longer see them by
 442          * resetting their references to zero:
 443          */
 444         pdev->dev.irq_start = 0;
 445         pdev->dev.irq_end = 0;
 446 }
 447
 448 #define pci_disable_msi(pdev) \
 449   linux_pci_disable_msi(pdev)
 450
 451 static inline void
 452 linux_pci_disable_msi(struct pci_dev *pdev)
 453 {
 454
 455         pci_release_msi(pdev->dev.bsddev);
 456
 457         pdev->dev.irq_start = 0;
 458         pdev->dev.irq_end = 0;
 459         pdev->irq = pdev->dev.irq;
 460         pdev->msi_enabled = false;
 461 }
 462
 463 unsigned long   pci_resource_start(struct pci_dev *pdev, int bar);
 464 unsigned long   pci_resource_len(struct pci_dev *pdev, int bar);
 465
 466 static inline bus_addr_t
 467 pci_bus_address(struct pci_dev *pdev, int bar)
 468 {
 469
 470         return (pci_resource_start(pdev, bar));
 471 }
 472
 473 #define PCI_CAP_ID_EXP  PCIY_EXPRESS
 474 #define PCI_CAP_ID_PCIX PCIY_PCIX
 475 #define PCI_CAP_ID_AGP  PCIY_AGP
 476 #define PCI_CAP_ID_PM   PCIY_PMG
 477
 478 #define PCI_EXP_DEVCTL          PCIER_DEVICE_CTL
 479 #define PCI_EXP_DEVCTL_PAYLOAD  PCIEM_CTL_MAX_PAYLOAD
 480 #define PCI_EXP_DEVCTL_READRQ   PCIEM_CTL_MAX_READ_REQUEST
 481 #define PCI_EXP_LNKCTL          PCIER_LINK_CTL
 482 #define PCI_EXP_LNKSTA          PCIER_LINK_STA
 483
 484 static inline int
 485 pci_find_capability(struct pci_dev *pdev, int capid)
 486 {
 487         int reg;
 488
 489         if (pci_find_cap(pdev->dev.bsddev, capid, &reg))
 490                 return (0);
 491         return (reg);
 492 }
 493
 494 static inline int pci_pcie_cap(struct pci_dev *dev)
 495 {
 496         return pci_find_capability(dev, PCI_CAP_ID_EXP);
 497 }
 498
 499 static inline int
 500 pci_read_config_byte(struct pci_dev *pdev, int where, u8 *val)
 501 {
 502
 503         *val = (u8)pci_read_config(pdev->dev.bsddev, where, 1);
 504         return (0);
 505 }
 506
 507 static inline int
 508 pci_read_config_word(struct pci_dev *pdev, int where, u16 *val)
 509 {
 510
 511         *val = (u16)pci_read_config(pdev->dev.bsddev, where, 2);
 512         return (0);
 513 }
 514
 515 static inline int
 516 pci_read_config_dword(struct pci_dev *pdev, int where, u32 *val)
 517 {
 518
 519         *val = (u32)pci_read_config(pdev->dev.bsddev, where, 4);
 520         return (0);
 521 }
 522
 523 static inline int
 524 pci_write_config_byte(struct pci_dev *pdev, int where, u8 val)
 525 {
 526
 527         pci_write_config(pdev->dev.bsddev, where, val, 1);
 528         return (0);
 529 }
 530
 531 static inline int
 532 pci_write_config_word(struct pci_dev *pdev, int where, u16 val)
 533 {
 534
 535         pci_write_config(pdev->dev.bsddev, where, val, 2);
 536         return (0);
 537 }
 538
 539 static inline int
 540 pci_write_config_dword(struct pci_dev *pdev, int where, u32 val)
 541 {
 542
 543         pci_write_config(pdev->dev.bsddev, where, val, 4);
 544         return (0);
 545 }
 546
 547 int     linux_pci_register_driver(struct pci_driver *pdrv);
 548 int     linux_pci_register_drm_driver(struct pci_driver *pdrv);
 549 void    linux_pci_unregister_driver(struct pci_driver *pdrv);
 550 void    linux_pci_unregister_drm_driver(struct pci_driver *pdrv);
 551
 552 #define pci_register_driver(pdrv)       linux_pci_register_driver(pdrv)
 553 #define pci_unregister_driver(pdrv)     linux_pci_unregister_driver(pdrv)
 554
 555 struct msix_entry {
 556         int entry;
 557         int vector;
 558 };
 559
 560 /*
 561  * Enable msix, positive errors indicate actual number of available
 562  * vectors.  Negative errors are failures.
 563  *
 564  * NB: define added to prevent this definition of pci_enable_msix from
 565  * clashing with the native FreeBSD version.
 566  */
 567 #define pci_enable_msix(...) \
 568   linux_pci_enable_msix(__VA_ARGS__)
 569
 570 static inline int
 571 pci_enable_msix(struct pci_dev *pdev, struct msix_entry *entries, int nreq)
 572 {
 573         struct resource_list_entry *rle;
 574         int error;
 575         int avail;
 576         int i;
 577
 578         avail = pci_msix_count(pdev->dev.bsddev);
 579         if (avail < nreq) {
 580                 if (avail == 0)
 581                         return -EINVAL;
 582                 return avail;
 583         }
 584         avail = nreq;
 585         if ((error = -pci_alloc_msix(pdev->dev.bsddev, &avail)) != 0)
 586                 return error;
 587         /*
 588          * Handle case where "pci_alloc_msix()" may allocate less
 589          * interrupts than available and return with no error:
 590          */
 591         if (avail < nreq) {
 592                 pci_release_msi(pdev->dev.bsddev);
 593                 return avail;
 594         }
 595         rle = linux_pci_get_rle(pdev, SYS_RES_IRQ, 1);
 596         pdev->dev.irq_start = rle->start;
 597         pdev->dev.irq_end = rle->start + avail;
 598         for (i = 0; i < nreq; i++)
 599                 entries[i].vector = pdev->dev.irq_start + i;
 600         return (0);
 601 }
 602
 603 #define pci_enable_msix_range(...) \
 604   linux_pci_enable_msix_range(__VA_ARGS__)
 605
 606 static inline int
 607 pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries,
 608     int minvec, int maxvec)
 609 {
 610         int nvec = maxvec;
 611         int rc;
 612
 613         if (maxvec < minvec)
 614                 return (-ERANGE);
 615
 616         do {
 617                 rc = pci_enable_msix(dev, entries, nvec);
 618                 if (rc < 0) {
 619                         return (rc);
 620                 } else if (rc > 0) {
 621                         if (rc < minvec)
 622                                 return (-ENOSPC);
 623                         nvec = rc;
 624                 }
 625         } while (rc);
 626         return (nvec);
 627 }
 628
 629 #define pci_enable_msi(pdev) \
 630   linux_pci_enable_msi(pdev)
 631
 632 static inline int
 633 pci_enable_msi(struct pci_dev *pdev)
 634 {
 635         struct resource_list_entry *rle;
 636         int error;
 637         int avail;
 638
 639         avail = pci_msi_count(pdev->dev.bsddev);
 640         if (avail < 1)
 641                 return -EINVAL;
 642
 643         avail = 1;      /* this function only enable one MSI IRQ */
 644         if ((error = -pci_alloc_msi(pdev->dev.bsddev, &avail)) != 0)
 645                 return error;
 646
 647         rle = linux_pci_get_rle(pdev, SYS_RES_IRQ, 1);
 648         pdev->dev.irq_start = rle->start;
 649         pdev->dev.irq_end = rle->start + avail;
 650         pdev->irq = rle->start;
 651         pdev->msi_enabled = true;
 652         return (0);
 653 }
 654
 655 static inline int
 656 pci_channel_offline(struct pci_dev *pdev)
 657 {
 658
 659         return (pci_read_config(pdev->dev.bsddev, PCIR_VENDOR, 2) == PCIV_INVALID);
 660 }
 661
 662 static inline int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
 663 {
 664         return -ENODEV;
 665 }
 666 static inline void pci_disable_sriov(struct pci_dev *dev)
 667 {
 668 }
 669
 670 static inline void *
 671 pci_iomap(struct pci_dev *dev, int mmio_bar, int mmio_size __unused)
 672 {
 673         struct pci_mmio_region *mmio;
 674
 675         mmio = malloc(sizeof(*mmio), M_DEVBUF, M_WAITOK | M_ZERO);
 676         mmio->rid = PCIR_BAR(mmio_bar);
 677         mmio->type = pci_resource_type(dev, mmio_bar);
 678         mmio->res = bus_alloc_resource_any(dev->dev.bsddev, mmio->type,
 679             &mmio->rid, RF_ACTIVE);
 680         if (mmio->res == NULL) {
 681                 free(mmio, M_DEVBUF);
 682                 return (NULL);
 683         }
 684         TAILQ_INSERT_TAIL(&dev->mmio, mmio, next);
 685
 686         return ((void *)rman_get_bushandle(mmio->res));
 687 }
 688
 689 static inline void
 690 pci_iounmap(struct pci_dev *dev, void *res)
 691 {
 692         struct pci_mmio_region *mmio, *p;
 693
 694         TAILQ_FOREACH_SAFE(mmio, &dev->mmio, next, p) {
 695                 if (res != (void *)rman_get_bushandle(mmio->res))
 696                         continue;
 697                 bus_release_resource(dev->dev.bsddev,
 698                     mmio->type, mmio->rid, mmio->res);
 699                 TAILQ_REMOVE(&dev->mmio, mmio, next);
 700                 free(mmio, M_DEVBUF);
 701                 return;
 702         }
 703 }
 704
 705 #define DEFINE_PCI_DEVICE_TABLE(_table) \
 706         const struct pci_device_id _table[] __devinitdata
 707
 708 /* XXX This should not be necessary. */
 709 #define pcix_set_mmrbc(d, v)    0
 710 #define pcix_get_max_mmrbc(d)   0
 711 #define pcie_set_readrq(d, v)   pci_set_max_read_req(&(d)->dev, (v))
 712
 713 #define PCI_DMA_BIDIRECTIONAL   0
 714 #define PCI_DMA_TODEVICE        1
 715 #define PCI_DMA_FROMDEVICE      2
 716 #define PCI_DMA_NONE            3
 717
 718 #define pci_pool                dma_pool
 719 #define pci_pool_destroy(...)   dma_pool_destroy(__VA_ARGS__)
 720 #define pci_pool_alloc(...)     dma_pool_alloc(__VA_ARGS__)
 721 #define pci_pool_free(...)      dma_pool_free(__VA_ARGS__)
 722 #define pci_pool_create(_name, _pdev, _size, _align, _alloc)            \
 723             dma_pool_create(_name, &(_pdev)->dev, _size, _align, _alloc)
 724 #define pci_free_consistent(_hwdev, _size, _vaddr, _dma_handle)         \
 725             dma_free_coherent((_hwdev) == NULL ? NULL : &(_hwdev)->dev, \
 726                 _size, _vaddr, _dma_handle)
 727 #define pci_map_sg(_hwdev, _sg, _nents, _dir)                           \
 728             dma_map_sg((_hwdev) == NULL ? NULL : &(_hwdev->dev),        \
 729                 _sg, _nents, (enum dma_data_direction)_dir)
 730 #define pci_map_single(_hwdev, _ptr, _size, _dir)                       \
 731             dma_map_single((_hwdev) == NULL ? NULL : &(_hwdev->dev),    \
 732                 (_ptr), (_size), (enum dma_data_direction)_dir)
 733 #define pci_unmap_single(_hwdev, _addr, _size, _dir)                    \
 734             dma_unmap_single((_hwdev) == NULL ? NULL : &(_hwdev)->dev,  \
 735                 _addr, _size, (enum dma_data_direction)_dir)
 736 #define pci_unmap_sg(_hwdev, _sg, _nents, _dir)                         \
 737             dma_unmap_sg((_hwdev) == NULL ? NULL : &(_hwdev)->dev,      \
 738                 _sg, _nents, (enum dma_data_direction)_dir)
 739 #define pci_map_page(_hwdev, _page, _offset, _size, _dir)               \
 740             dma_map_page((_hwdev) == NULL ? NULL : &(_hwdev)->dev, _page,\
 741                 _offset, _size, (enum dma_data_direction)_dir)
 742 #define pci_unmap_page(_hwdev, _dma_address, _size, _dir)               \
 743             dma_unmap_page((_hwdev) == NULL ? NULL : &(_hwdev)->dev,    \
 744                 _dma_address, _size, (enum dma_data_direction)_dir)
 745 #define pci_set_dma_mask(_pdev, mask)   dma_set_mask(&(_pdev)->dev, (mask))
 746 #define pci_dma_mapping_error(_pdev, _dma_addr)                         \
 747             dma_mapping_error(&(_pdev)->dev, _dma_addr)
 748 #define pci_set_consistent_dma_mask(_pdev, _mask)                       \
 749             dma_set_coherent_mask(&(_pdev)->dev, (_mask))
 750 #define DECLARE_PCI_UNMAP_ADDR(x)       DEFINE_DMA_UNMAP_ADDR(x);
 751 #define DECLARE_PCI_UNMAP_LEN(x)        DEFINE_DMA_UNMAP_LEN(x);
 752 #define pci_unmap_addr          dma_unmap_addr
 753 #define pci_unmap_addr_set      dma_unmap_addr_set
 754 #define pci_unmap_len           dma_unmap_len
 755 #define pci_unmap_len_set       dma_unmap_len_set
 756
 757 typedef unsigned int __bitwise pci_channel_state_t;
 758 typedef unsigned int __bitwise pci_ers_result_t;
 759
 760 enum pci_channel_state {
 761         pci_channel_io_normal = 1,
 762         pci_channel_io_frozen = 2,
 763         pci_channel_io_perm_failure = 3,
 764 };
 765
 766 enum pci_ers_result {
 767         PCI_ERS_RESULT_NONE = 1,
 768         PCI_ERS_RESULT_CAN_RECOVER = 2,
 769         PCI_ERS_RESULT_NEED_RESET = 3,
 770         PCI_ERS_RESULT_DISCONNECT = 4,
 771         PCI_ERS_RESULT_RECOVERED = 5,
 772 };
 773
 774 /* PCI bus error event callbacks */
 775 struct pci_error_handlers {
 776         pci_ers_result_t (*error_detected)(struct pci_dev *dev,
 777             enum pci_channel_state error);
 778         pci_ers_result_t (*mmio_enabled)(struct pci_dev *dev);
 779         pci_ers_result_t (*link_reset)(struct pci_dev *dev);
 780         pci_ers_result_t (*slot_reset)(struct pci_dev *dev);
 781         void (*resume)(struct pci_dev *dev);
 782 };
 783
 784 /* FreeBSD does not support SRIOV - yet */
 785 static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
 786 {
 787         return dev;
 788 }
 789
 790 static inline bool pci_is_pcie(struct pci_dev *dev)
 791 {
 792         return !!pci_pcie_cap(dev);
 793 }
 794
 795 static inline u16 pcie_flags_reg(struct pci_dev *dev)
 796 {
 797         int pos;
 798         u16 reg16;
 799
 800         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
 801         if (!pos)
 802                 return 0;
 803
 804         pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &reg16);
 805
 806         return reg16;
 807 }
 808
 809 static inline int pci_pcie_type(struct pci_dev *dev)
 810 {
 811         return (pcie_flags_reg(dev) & PCI_EXP_FLAGS_TYPE) >> 4;
 812 }
 813
 814 static inline int pcie_cap_version(struct pci_dev *dev)
 815 {
 816         return pcie_flags_reg(dev) & PCI_EXP_FLAGS_VERS;
 817 }
 818
 819 static inline bool pcie_cap_has_lnkctl(struct pci_dev *dev)
 820 {
 821         int type = pci_pcie_type(dev);
 822
 823         return pcie_cap_version(dev) > 1 ||
 824                type == PCI_EXP_TYPE_ROOT_PORT ||
 825                type == PCI_EXP_TYPE_ENDPOINT ||
 826                type == PCI_EXP_TYPE_LEG_END;
 827 }
 828
 829 static inline bool pcie_cap_has_devctl(const struct pci_dev *dev)
 830 {
 831                 return true;
 832 }
 833
 834 static inline bool pcie_cap_has_sltctl(struct pci_dev *dev)
 835 {
 836         int type = pci_pcie_type(dev);
 837
 838         return pcie_cap_version(dev) > 1 || type == PCI_EXP_TYPE_ROOT_PORT ||
 839             (type == PCI_EXP_TYPE_DOWNSTREAM &&
 840             pcie_flags_reg(dev) & PCI_EXP_FLAGS_SLOT);
 841 }
 842
 843 static inline bool pcie_cap_has_rtctl(struct pci_dev *dev)
 844 {
 845         int type = pci_pcie_type(dev);
 846
 847         return pcie_cap_version(dev) > 1 || type == PCI_EXP_TYPE_ROOT_PORT ||
 848             type == PCI_EXP_TYPE_RC_EC;
 849 }
 850
 851 static bool pcie_capability_reg_implemented(struct pci_dev *dev, int pos)
 852 {
 853         if (!pci_is_pcie(dev))
 854                 return false;
 855
 856         switch (pos) {
 857         case PCI_EXP_FLAGS_TYPE:
 858                 return true;
 859         case PCI_EXP_DEVCAP:
 860         case PCI_EXP_DEVCTL:
 861         case PCI_EXP_DEVSTA:
 862                 return pcie_cap_has_devctl(dev);
 863         case PCI_EXP_LNKCAP:
 864         case PCI_EXP_LNKCTL:
 865         case PCI_EXP_LNKSTA:
 866                 return pcie_cap_has_lnkctl(dev);
 867         case PCI_EXP_SLTCAP:
 868         case PCI_EXP_SLTCTL:
 869         case PCI_EXP_SLTSTA:
 870                 return pcie_cap_has_sltctl(dev);
 871         case PCI_EXP_RTCTL:
 872         case PCI_EXP_RTCAP:
 873         case PCI_EXP_RTSTA:
 874                 return pcie_cap_has_rtctl(dev);
 875         case PCI_EXP_DEVCAP2:
 876         case PCI_EXP_DEVCTL2:
 877         case PCI_EXP_LNKCAP2:
 878         case PCI_EXP_LNKCTL2:
 879         case PCI_EXP_LNKSTA2:
 880                 return pcie_cap_version(dev) > 1;
 881         default:
 882                 return false;
 883         }
 884 }
 885
 886 static inline int
 887 pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *dst)
 888 {
 889         if (pos & 3)
 890                 return -EINVAL;
 891
 892         if (!pcie_capability_reg_implemented(dev, pos))
 893                 return -EINVAL;
 894
 895         return pci_read_config_dword(dev, pci_pcie_cap(dev) + pos, dst);
 896 }
 897
 898 static inline int
 899 pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *dst)
 900 {
 901         if (pos & 3)
 902                 return -EINVAL;
 903
 904         if (!pcie_capability_reg_implemented(dev, pos))
 905                 return -EINVAL;
 906
 907         return pci_read_config_word(dev, pci_pcie_cap(dev) + pos, dst);
 908 }
 909
 910 static inline int
 911 pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val)
 912 {
 913         if (pos & 1)
 914                 return -EINVAL;
 915
 916         if (!pcie_capability_reg_implemented(dev, pos))
 917                 return 0;
 918
 919         return pci_write_config_word(dev, pci_pcie_cap(dev) + pos, val);
 920 }
 921
 922 static inline int pcie_get_minimum_link(struct pci_dev *dev,
 923     enum pci_bus_speed *speed, enum pcie_link_width *width)
 924 {
 925         *speed = PCI_SPEED_UNKNOWN;
 926         *width = PCIE_LNK_WIDTH_UNKNOWN;
 927         return (0);
 928 }
 929
 930 static inline int
 931 pci_num_vf(struct pci_dev *dev)
 932 {
 933         return (0);
 934 }
 935
 936 static inline enum pci_bus_speed
 937 pcie_get_speed_cap(struct pci_dev *dev)
 938 {
 939         device_t root;
 940         uint32_t lnkcap, lnkcap2;
 941         int error, pos;
 942
 943         root = device_get_parent(dev->dev.bsddev);
 944         if (root == NULL)
 945                 return (PCI_SPEED_UNKNOWN);
 946         root = device_get_parent(root);
 947         if (root == NULL)
 948                 return (PCI_SPEED_UNKNOWN);
 949         root = device_get_parent(root);
 950         if (root == NULL)
 951                 return (PCI_SPEED_UNKNOWN);
 952
 953         if (pci_get_vendor(root) == PCI_VENDOR_ID_VIA ||
 954             pci_get_vendor(root) == PCI_VENDOR_ID_SERVERWORKS)
 955                 return (PCI_SPEED_UNKNOWN);
 956
 957         if ((error = pci_find_cap(root, PCIY_EXPRESS, &pos)) != 0)
 958                 return (PCI_SPEED_UNKNOWN);
 959
 960         lnkcap2 = pci_read_config(root, pos + PCIER_LINK_CAP2, 4);
 961
 962         if (lnkcap2) {  /* PCIe r3.0-compliant */
 963                 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB)
 964                         return (PCIE_SPEED_2_5GT);
 965                 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB)
 966                         return (PCIE_SPEED_5_0GT);
 967                 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB)
 968                         return (PCIE_SPEED_8_0GT);
 969                 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_16_0GB)
 970                         return (PCIE_SPEED_16_0GT);
 971         } else {        /* pre-r3.0 */
 972                 lnkcap = pci_read_config(root, pos + PCIER_LINK_CAP, 4);
 973                 if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB)
 974                         return (PCIE_SPEED_2_5GT);
 975                 if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB)
 976                         return (PCIE_SPEED_5_0GT);
 977                 if (lnkcap & PCI_EXP_LNKCAP_SLS_8_0GB)
 978                         return (PCIE_SPEED_8_0GT);
 979                 if (lnkcap & PCI_EXP_LNKCAP_SLS_16_0GB)
 980                         return (PCIE_SPEED_16_0GT);
 981         }
 982         return (PCI_SPEED_UNKNOWN);
 983 }
 984
 985 static inline enum pcie_link_width
 986 pcie_get_width_cap(struct pci_dev *dev)
 987 {
 988         uint32_t lnkcap;
 989
 990         pcie_capability_read_dword(dev, PCI_EXP_LNKCAP, &lnkcap);
 991         if (lnkcap)
 992                 return ((lnkcap & PCI_EXP_LNKCAP_MLW) >> 4);
 993
 994         return (PCIE_LNK_WIDTH_UNKNOWN);
 995 }
 996
 997 static inline int
 998 pcie_get_mps(struct pci_dev *dev)
 999 {
1000         return (pci_get_max_payload(dev->dev.bsddev));
1001 }
1002
1003 static inline uint32_t
1004 PCIE_SPEED2MBS_ENC(enum pci_bus_speed spd)
1005 {
1006
1007         switch(spd) {
1008         case PCIE_SPEED_16_0GT:
1009                 return (16000 * 128 / 130);
1010         case PCIE_SPEED_8_0GT:
1011                 return (8000 * 128 / 130);
1012         case PCIE_SPEED_5_0GT:
1013                 return (5000 * 8 / 10);
1014         case PCIE_SPEED_2_5GT:
1015                 return (2500 * 8 / 10);
1016         default:
1017                 return (0);
1018         }
1019 }
1020
1021 static inline uint32_t
1022 pcie_bandwidth_available(struct pci_dev *pdev,
1023     struct pci_dev **limiting,
1024     enum pci_bus_speed *speed,
1025     enum pcie_link_width *width)
1026 {
1027         enum pci_bus_speed nspeed = pcie_get_speed_cap(pdev);
1028         enum pcie_link_width nwidth = pcie_get_width_cap(pdev);
1029
1030         if (speed)
1031                 *speed = nspeed;
1032         if (width)
1033                 *width = nwidth;
1034
1035         return (nwidth * PCIE_SPEED2MBS_ENC(nspeed));
1036 }
1037
1038 /*
1039  * The following functions can be used to attach/detach the LinuxKPI's
1040  * PCI device runtime. The pci_driver and pci_device_id pointer is
1041  * allowed to be NULL. Other pointers must be all valid.
1042  * The pci_dev structure should be zero-initialized before passed
1043  * to the linux_pci_attach_device function.
1044  */
1045 extern int linux_pci_attach_device(device_t, struct pci_driver *,
1046     const struct pci_device_id *, struct pci_dev *);
1047 extern int linux_pci_detach_device(struct pci_dev *);
1048
1049 static inline int
1050 pci_dev_present(const struct pci_device_id *cur)
1051 {
1052         while (cur != NULL && (cur->vendor || cur->device)) {
1053                 if (pci_find_device(cur->vendor, cur->device) != NULL) {
1054                         return (1);
1055                 }
1056                 cur++;
1057         }
1058         return (0);
1059 }
1060
1061 #endif  /* _LINUX_PCI_H_ */