sys/dev/ntb/ntb_hw/ntb_hw.c

   1 /*-
   2  * Copyright (c) 2016 Alexander Motin <mav@FreeBSD.org>
   3  * Copyright (C) 2013 Intel Corporation
   4  * Copyright (C) 2015 EMC Corporation
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * The Non-Transparent Bridge (NTB) is a device that allows you to connect
  31  * two or more systems using a PCI-e links, providing remote memory access.
  32  *
  33  * This module contains a driver for NTB hardware in Intel Xeon/Atom CPUs.
  34  *
  35  * NOTE: Much of the code in this module is shared with Linux. Any patches may
  36  * be picked up and redistributed in Linux with a dual GPL/BSD license.
  37  */
  38
  39 #include <sys/cdefs.h>
  40 __FBSDID("$FreeBSD$");
  41
  42 #include <sys/param.h>
  43 #include <sys/kernel.h>
  44 #include <sys/systm.h>
  45 #include <sys/bus.h>
  46 #include <sys/endian.h>
  47 #include <sys/interrupt.h>
  48 #include <sys/malloc.h>
  49 #include <sys/module.h>
  50 #include <sys/mutex.h>
  51 #include <sys/pciio.h>
  52 #include <sys/queue.h>
  53 #include <sys/rman.h>
  54 #include <sys/sbuf.h>
  55 #include <sys/sysctl.h>
  56 #include <vm/vm.h>
  57 #include <vm/pmap.h>
  58 #include <machine/bus.h>
  59 #include <machine/intr_machdep.h>
  60 #include <machine/resource.h>
  61 #include <dev/pci/pcireg.h>
  62 #include <dev/pci/pcivar.h>
  63
  64 #include "ntb_regs.h"
  65 #include "../ntb.h"
  66
  67 #define MAX_MSIX_INTERRUPTS MAX(XEON_DB_COUNT, ATOM_DB_COUNT)
  68
  69 #define NTB_HB_TIMEOUT          1 /* second */
  70 #define ATOM_LINK_RECOVERY_TIME 500 /* ms */
  71 #define BAR_HIGH_MASK           (~((1ull << 12) - 1))
  72
  73 #define NTB_MSIX_VER_GUARD      0xaabbccdd
  74 #define NTB_MSIX_RECEIVED       0xe0f0e0f0
  75
  76 /*
  77  * PCI constants could be somewhere more generic, but aren't defined/used in
  78  * pci.c.
  79  */
  80 #define PCI_MSIX_ENTRY_SIZE             16
  81 #define PCI_MSIX_ENTRY_LOWER_ADDR       0
  82 #define PCI_MSIX_ENTRY_UPPER_ADDR       4
  83 #define PCI_MSIX_ENTRY_DATA             8
  84
  85 enum ntb_device_type {
  86         NTB_XEON,
  87         NTB_ATOM
  88 };
  89
  90 /* ntb_conn_type are hardware numbers, cannot change. */
  91 enum ntb_conn_type {
  92         NTB_CONN_TRANSPARENT = 0,
  93         NTB_CONN_B2B = 1,
  94         NTB_CONN_RP = 2,
  95 };
  96
  97 enum ntb_b2b_direction {
  98         NTB_DEV_USD = 0,
  99         NTB_DEV_DSD = 1,
 100 };
 101
 102 enum ntb_bar {
 103         NTB_CONFIG_BAR = 0,
 104         NTB_B2B_BAR_1,
 105         NTB_B2B_BAR_2,
 106         NTB_B2B_BAR_3,
 107         NTB_MAX_BARS
 108 };
 109
 110 enum {
 111         NTB_MSIX_GUARD = 0,
 112         NTB_MSIX_DATA0,
 113         NTB_MSIX_DATA1,
 114         NTB_MSIX_DATA2,
 115         NTB_MSIX_OFS0,
 116         NTB_MSIX_OFS1,
 117         NTB_MSIX_OFS2,
 118         NTB_MSIX_DONE,
 119         NTB_MAX_MSIX_SPAD
 120 };
 121
 122 /* Device features and workarounds */
 123 #define HAS_FEATURE(ntb, feature)       \
 124         (((ntb)->features & (feature)) != 0)
 125
 126 struct ntb_hw_info {
 127         uint32_t                device_id;
 128         const char              *desc;
 129         enum ntb_device_type    type;
 130         uint32_t                features;
 131 };
 132
 133 struct ntb_pci_bar_info {
 134         bus_space_tag_t         pci_bus_tag;
 135         bus_space_handle_t      pci_bus_handle;
 136         int                     pci_resource_id;
 137         struct resource         *pci_resource;
 138         vm_paddr_t              pbase;
 139         caddr_t                 vbase;
 140         vm_size_t               size;
 141         vm_memattr_t            map_mode;
 142
 143         /* Configuration register offsets */
 144         uint32_t                psz_off;
 145         uint32_t                ssz_off;
 146         uint32_t                pbarxlat_off;
 147 };
 148
 149 struct ntb_int_info {
 150         struct resource *res;
 151         int             rid;
 152         void            *tag;
 153 };
 154
 155 struct ntb_vec {
 156         struct ntb_softc        *ntb;
 157         uint32_t                num;
 158         unsigned                masked;
 159 };
 160
 161 struct ntb_reg {
 162         uint32_t        ntb_ctl;
 163         uint32_t        lnk_sta;
 164         uint8_t         db_size;
 165         unsigned        mw_bar[NTB_MAX_BARS];
 166 };
 167
 168 struct ntb_alt_reg {
 169         uint32_t        db_bell;
 170         uint32_t        db_mask;
 171         uint32_t        spad;
 172 };
 173
 174 struct ntb_xlat_reg {
 175         uint32_t        bar0_base;
 176         uint32_t        bar2_base;
 177         uint32_t        bar4_base;
 178         uint32_t        bar5_base;
 179
 180         uint32_t        bar2_xlat;
 181         uint32_t        bar4_xlat;
 182         uint32_t        bar5_xlat;
 183
 184         uint32_t        bar2_limit;
 185         uint32_t        bar4_limit;
 186         uint32_t        bar5_limit;
 187 };
 188
 189 struct ntb_b2b_addr {
 190         uint64_t        bar0_addr;
 191         uint64_t        bar2_addr64;
 192         uint64_t        bar4_addr64;
 193         uint64_t        bar4_addr32;
 194         uint64_t        bar5_addr32;
 195 };
 196
 197 struct ntb_msix_data {
 198         uint32_t        nmd_ofs;
 199         uint32_t        nmd_data;
 200 };
 201
 202 struct ntb_softc {
 203         /* ntb.c context. Do not move! Must go first! */
 204         void                    *ntb_store;
 205
 206         device_t                device;
 207         enum ntb_device_type    type;
 208         uint32_t                features;
 209
 210         struct ntb_pci_bar_info bar_info[NTB_MAX_BARS];
 211         struct ntb_int_info     int_info[MAX_MSIX_INTERRUPTS];
 212         uint32_t                allocated_interrupts;
 213
 214         struct ntb_msix_data    peer_msix_data[XEON_NONLINK_DB_MSIX_BITS];
 215         struct ntb_msix_data    msix_data[XEON_NONLINK_DB_MSIX_BITS];
 216         bool                    peer_msix_good;
 217         bool                    peer_msix_done;
 218         struct ntb_pci_bar_info *peer_lapic_bar;
 219         struct callout          peer_msix_work;
 220
 221         struct callout          heartbeat_timer;
 222         struct callout          lr_timer;
 223
 224         struct ntb_vec          *msix_vec;
 225
 226         uint32_t                ppd;
 227         enum ntb_conn_type      conn_type;
 228         enum ntb_b2b_direction  dev_type;
 229
 230         /* Offset of peer bar0 in B2B BAR */
 231         uint64_t                        b2b_off;
 232         /* Memory window used to access peer bar0 */
 233 #define B2B_MW_DISABLED                 UINT8_MAX
 234         uint8_t                         b2b_mw_idx;
 235         uint32_t                        msix_xlat;
 236         uint8_t                         msix_mw_idx;
 237
 238         uint8_t                         mw_count;
 239         uint8_t                         spad_count;
 240         uint8_t                         db_count;
 241         uint8_t                         db_vec_count;
 242         uint8_t                         db_vec_shift;
 243
 244         /* Protects local db_mask. */
 245 #define DB_MASK_LOCK(sc)        mtx_lock_spin(&(sc)->db_mask_lock)
 246 #define DB_MASK_UNLOCK(sc)      mtx_unlock_spin(&(sc)->db_mask_lock)
 247 #define DB_MASK_ASSERT(sc,f)    mtx_assert(&(sc)->db_mask_lock, (f))
 248         struct mtx                      db_mask_lock;
 249
 250         volatile uint32_t               ntb_ctl;
 251         volatile uint32_t               lnk_sta;
 252
 253         uint64_t                        db_valid_mask;
 254         uint64_t                        db_link_mask;
 255         uint64_t                        db_mask;
 256         uint64_t                        fake_db_bell;   /* NTB_SB01BASE_LOCKUP*/
 257
 258         int                             last_ts;        /* ticks @ last irq */
 259
 260         const struct ntb_reg            *reg;
 261         const struct ntb_alt_reg        *self_reg;
 262         const struct ntb_alt_reg        *peer_reg;
 263         const struct ntb_xlat_reg       *xlat_reg;
 264 };
 265
 266 #ifdef __i386__
 267 static __inline uint64_t
 268 bus_space_read_8(bus_space_tag_t tag, bus_space_handle_t handle,
 269     bus_size_t offset)
 270 {
 271
 272         return (bus_space_read_4(tag, handle, offset) |
 273             ((uint64_t)bus_space_read_4(tag, handle, offset + 4)) << 32);
 274 }
 275
 276 static __inline void
 277 bus_space_write_8(bus_space_tag_t tag, bus_space_handle_t handle,
 278     bus_size_t offset, uint64_t val)
 279 {
 280
 281         bus_space_write_4(tag, handle, offset, val);
 282         bus_space_write_4(tag, handle, offset + 4, val >> 32);
 283 }
 284 #endif
 285
 286 #define intel_ntb_bar_read(SIZE, bar, offset) \
 287             bus_space_read_ ## SIZE (ntb->bar_info[(bar)].pci_bus_tag, \
 288             ntb->bar_info[(bar)].pci_bus_handle, (offset))
 289 #define intel_ntb_bar_write(SIZE, bar, offset, val) \
 290             bus_space_write_ ## SIZE (ntb->bar_info[(bar)].pci_bus_tag, \
 291             ntb->bar_info[(bar)].pci_bus_handle, (offset), (val))
 292 #define intel_ntb_reg_read(SIZE, offset) \
 293             intel_ntb_bar_read(SIZE, NTB_CONFIG_BAR, offset)
 294 #define intel_ntb_reg_write(SIZE, offset, val) \
 295             intel_ntb_bar_write(SIZE, NTB_CONFIG_BAR, offset, val)
 296 #define intel_ntb_mw_read(SIZE, offset) \
 297             intel_ntb_bar_read(SIZE, intel_ntb_mw_to_bar(ntb, ntb->b2b_mw_idx), \
 298                 offset)
 299 #define intel_ntb_mw_write(SIZE, offset, val) \
 300             intel_ntb_bar_write(SIZE, intel_ntb_mw_to_bar(ntb, ntb->b2b_mw_idx), \
 301                 offset, val)
 302
 303 static int intel_ntb_probe(device_t device);
 304 static int intel_ntb_attach(device_t device);
 305 static int intel_ntb_detach(device_t device);
 306 static uint64_t intel_ntb_db_valid_mask(device_t dev);
 307 static void intel_ntb_spad_clear(device_t dev);
 308 static uint64_t intel_ntb_db_vector_mask(device_t dev, uint32_t vector);
 309 static bool intel_ntb_link_is_up(device_t dev, enum ntb_speed *speed,
 310     enum ntb_width *width);
 311 static int intel_ntb_link_enable(device_t dev, enum ntb_speed speed,
 312     enum ntb_width width);
 313 static int intel_ntb_link_disable(device_t dev);
 314 static int intel_ntb_spad_read(device_t dev, unsigned int idx, uint32_t *val);
 315 static int intel_ntb_peer_spad_write(device_t dev, unsigned int idx, uint32_t val);
 316
 317 static unsigned intel_ntb_user_mw_to_idx(struct ntb_softc *, unsigned uidx);
 318 static inline enum ntb_bar intel_ntb_mw_to_bar(struct ntb_softc *, unsigned mw);
 319 static inline bool bar_is_64bit(struct ntb_softc *, enum ntb_bar);
 320 static inline void bar_get_xlat_params(struct ntb_softc *, enum ntb_bar,
 321     uint32_t *base, uint32_t *xlat, uint32_t *lmt);
 322 static int intel_ntb_map_pci_bars(struct ntb_softc *ntb);
 323 static int intel_ntb_mw_set_wc_internal(struct ntb_softc *, unsigned idx,
 324     vm_memattr_t);
 325 static void print_map_success(struct ntb_softc *, struct ntb_pci_bar_info *,
 326     const char *);
 327 static int map_mmr_bar(struct ntb_softc *ntb, struct ntb_pci_bar_info *bar);
 328 static int map_memory_window_bar(struct ntb_softc *ntb,
 329     struct ntb_pci_bar_info *bar);
 330 static void intel_ntb_unmap_pci_bar(struct ntb_softc *ntb);
 331 static int intel_ntb_remap_msix(device_t, uint32_t desired, uint32_t avail);
 332 static int intel_ntb_init_isr(struct ntb_softc *ntb);
 333 static int intel_ntb_setup_legacy_interrupt(struct ntb_softc *ntb);
 334 static int intel_ntb_setup_msix(struct ntb_softc *ntb, uint32_t num_vectors);
 335 static void intel_ntb_teardown_interrupts(struct ntb_softc *ntb);
 336 static inline uint64_t intel_ntb_vec_mask(struct ntb_softc *, uint64_t db_vector);
 337 static void intel_ntb_interrupt(struct ntb_softc *, uint32_t vec);
 338 static void ndev_vec_isr(void *arg);
 339 static void ndev_irq_isr(void *arg);
 340 static inline uint64_t db_ioread(struct ntb_softc *, uint64_t regoff);
 341 static inline void db_iowrite(struct ntb_softc *, uint64_t regoff, uint64_t);
 342 static inline void db_iowrite_raw(struct ntb_softc *, uint64_t regoff, uint64_t);
 343 static int intel_ntb_create_msix_vec(struct ntb_softc *ntb, uint32_t num_vectors);
 344 static void intel_ntb_free_msix_vec(struct ntb_softc *ntb);
 345 static void intel_ntb_get_msix_info(struct ntb_softc *ntb);
 346 static void intel_ntb_exchange_msix(void *);
 347 static struct ntb_hw_info *intel_ntb_get_device_info(uint32_t device_id);
 348 static void intel_ntb_detect_max_mw(struct ntb_softc *ntb);
 349 static int intel_ntb_detect_xeon(struct ntb_softc *ntb);
 350 static int intel_ntb_detect_atom(struct ntb_softc *ntb);
 351 static int intel_ntb_xeon_init_dev(struct ntb_softc *ntb);
 352 static int intel_ntb_atom_init_dev(struct ntb_softc *ntb);
 353 static void intel_ntb_teardown_xeon(struct ntb_softc *ntb);
 354 static void configure_atom_secondary_side_bars(struct ntb_softc *ntb);
 355 static void xeon_reset_sbar_size(struct ntb_softc *, enum ntb_bar idx,
 356     enum ntb_bar regbar);
 357 static void xeon_set_sbar_base_and_limit(struct ntb_softc *,
 358     uint64_t base_addr, enum ntb_bar idx, enum ntb_bar regbar);
 359 static void xeon_set_pbar_xlat(struct ntb_softc *, uint64_t base_addr,
 360     enum ntb_bar idx);
 361 static int xeon_setup_b2b_mw(struct ntb_softc *,
 362     const struct ntb_b2b_addr *addr, const struct ntb_b2b_addr *peer_addr);
 363 static inline bool link_is_up(struct ntb_softc *ntb);
 364 static inline bool _xeon_link_is_up(struct ntb_softc *ntb);
 365 static inline bool atom_link_is_err(struct ntb_softc *ntb);
 366 static inline enum ntb_speed intel_ntb_link_sta_speed(struct ntb_softc *);
 367 static inline enum ntb_width intel_ntb_link_sta_width(struct ntb_softc *);
 368 static void atom_link_hb(void *arg);
 369 static void recover_atom_link(void *arg);
 370 static bool intel_ntb_poll_link(struct ntb_softc *ntb);
 371 static void save_bar_parameters(struct ntb_pci_bar_info *bar);
 372 static void intel_ntb_sysctl_init(struct ntb_softc *);
 373 static int sysctl_handle_features(SYSCTL_HANDLER_ARGS);
 374 static int sysctl_handle_link_admin(SYSCTL_HANDLER_ARGS);
 375 static int sysctl_handle_link_status_human(SYSCTL_HANDLER_ARGS);
 376 static int sysctl_handle_link_status(SYSCTL_HANDLER_ARGS);
 377 static int sysctl_handle_register(SYSCTL_HANDLER_ARGS);
 378
 379 static unsigned g_ntb_hw_debug_level;
 380 SYSCTL_UINT(_hw_ntb, OID_AUTO, debug_level, CTLFLAG_RWTUN,
 381     &g_ntb_hw_debug_level, 0, "ntb_hw log level -- higher is more verbose");
 382 #define intel_ntb_printf(lvl, ...) do {                         \
 383         if ((lvl) <= g_ntb_hw_debug_level) {                    \
 384                 device_printf(ntb->device, __VA_ARGS__);        \
 385         }                                                       \
 386 } while (0)
 387
 388 #define _NTB_PAT_UC     0
 389 #define _NTB_PAT_WC     1
 390 #define _NTB_PAT_WT     4
 391 #define _NTB_PAT_WP     5
 392 #define _NTB_PAT_WB     6
 393 #define _NTB_PAT_UCM    7
 394 static unsigned g_ntb_mw_pat = _NTB_PAT_UC;
 395 SYSCTL_UINT(_hw_ntb, OID_AUTO, default_mw_pat, CTLFLAG_RDTUN,
 396     &g_ntb_mw_pat, 0, "Configure the default memory window cache flags (PAT): "
 397     "UC: "  __XSTRING(_NTB_PAT_UC) ", "
 398     "WC: "  __XSTRING(_NTB_PAT_WC) ", "
 399     "WT: "  __XSTRING(_NTB_PAT_WT) ", "
 400     "WP: "  __XSTRING(_NTB_PAT_WP) ", "
 401     "WB: "  __XSTRING(_NTB_PAT_WB) ", "
 402     "UC-: " __XSTRING(_NTB_PAT_UCM));
 403
 404 static inline vm_memattr_t
 405 intel_ntb_pat_flags(void)
 406 {
 407
 408         switch (g_ntb_mw_pat) {
 409         case _NTB_PAT_WC:
 410                 return (VM_MEMATTR_WRITE_COMBINING);
 411         case _NTB_PAT_WT:
 412                 return (VM_MEMATTR_WRITE_THROUGH);
 413         case _NTB_PAT_WP:
 414                 return (VM_MEMATTR_WRITE_PROTECTED);
 415         case _NTB_PAT_WB:
 416                 return (VM_MEMATTR_WRITE_BACK);
 417         case _NTB_PAT_UCM:
 418                 return (VM_MEMATTR_WEAK_UNCACHEABLE);
 419         case _NTB_PAT_UC:
 420                 /* FALLTHROUGH */
 421         default:
 422                 return (VM_MEMATTR_UNCACHEABLE);
 423         }
 424 }
 425
 426 /*
 427  * Well, this obviously doesn't belong here, but it doesn't seem to exist
 428  * anywhere better yet.
 429  */
 430 static inline const char *
 431 intel_ntb_vm_memattr_to_str(vm_memattr_t pat)
 432 {
 433
 434         switch (pat) {
 435         case VM_MEMATTR_WRITE_COMBINING:
 436                 return ("WRITE_COMBINING");
 437         case VM_MEMATTR_WRITE_THROUGH:
 438                 return ("WRITE_THROUGH");
 439         case VM_MEMATTR_WRITE_PROTECTED:
 440                 return ("WRITE_PROTECTED");
 441         case VM_MEMATTR_WRITE_BACK:
 442                 return ("WRITE_BACK");
 443         case VM_MEMATTR_WEAK_UNCACHEABLE:
 444                 return ("UNCACHED");
 445         case VM_MEMATTR_UNCACHEABLE:
 446                 return ("UNCACHEABLE");
 447         default:
 448                 return ("UNKNOWN");
 449         }
 450 }
 451
 452 static int g_ntb_msix_idx = 1;
 453 SYSCTL_INT(_hw_ntb, OID_AUTO, msix_mw_idx, CTLFLAG_RDTUN, &g_ntb_msix_idx,
 454     0, "Use this memory window to access the peer MSIX message complex on "
 455     "certain Xeon-based NTB systems, as a workaround for a hardware errata.  "
 456     "Like b2b_mw_idx, negative values index from the last available memory "
 457     "window.  (Applies on Xeon platforms with SB01BASE_LOCKUP errata.)");
 458
 459 static int g_ntb_mw_idx = -1;
 460 SYSCTL_INT(_hw_ntb, OID_AUTO, b2b_mw_idx, CTLFLAG_RDTUN, &g_ntb_mw_idx,
 461     0, "Use this memory window to access the peer NTB registers.  A "
 462     "non-negative value starts from the first MW index; a negative value "
 463     "starts from the last MW index.  The default is -1, i.e., the last "
 464     "available memory window.  Both sides of the NTB MUST set the same "
 465     "value here!  (Applies on Xeon platforms with SDOORBELL_LOCKUP errata.)");
 466
 467 /* Hardware owns the low 16 bits of features. */
 468 #define NTB_BAR_SIZE_4K         (1 << 0)
 469 #define NTB_SDOORBELL_LOCKUP    (1 << 1)
 470 #define NTB_SB01BASE_LOCKUP     (1 << 2)
 471 #define NTB_B2BDOORBELL_BIT14   (1 << 3)
 472 /* Software/configuration owns the top 16 bits. */
 473 #define NTB_SPLIT_BAR           (1ull << 16)
 474
 475 #define NTB_FEATURES_STR \
 476     "\20\21SPLIT_BAR4\04B2B_DOORBELL_BIT14\03SB01BASE_LOCKUP" \
 477     "\02SDOORBELL_LOCKUP\01BAR_SIZE_4K"
 478
 479 static struct ntb_hw_info pci_ids[] = {
 480         /* XXX: PS/SS IDs left out until they are supported. */
 481         { 0x0C4E8086, "BWD Atom Processor S1200 Non-Transparent Bridge B2B",
 482                 NTB_ATOM, 0 },
 483
 484         { 0x37258086, "JSF Xeon C35xx/C55xx Non-Transparent Bridge B2B",
 485                 NTB_XEON, NTB_SDOORBELL_LOCKUP | NTB_B2BDOORBELL_BIT14 },
 486         { 0x3C0D8086, "SNB Xeon E5/Core i7 Non-Transparent Bridge B2B",
 487                 NTB_XEON, NTB_SDOORBELL_LOCKUP | NTB_B2BDOORBELL_BIT14 },
 488         { 0x0E0D8086, "IVT Xeon E5 V2 Non-Transparent Bridge B2B", NTB_XEON,
 489                 NTB_SDOORBELL_LOCKUP | NTB_B2BDOORBELL_BIT14 |
 490                     NTB_SB01BASE_LOCKUP | NTB_BAR_SIZE_4K },
 491         { 0x2F0D8086, "HSX Xeon E5 V3 Non-Transparent Bridge B2B", NTB_XEON,
 492                 NTB_SDOORBELL_LOCKUP | NTB_B2BDOORBELL_BIT14 |
 493                     NTB_SB01BASE_LOCKUP },
 494         { 0x6F0D8086, "BDX Xeon E5 V4 Non-Transparent Bridge B2B", NTB_XEON,
 495                 NTB_SDOORBELL_LOCKUP | NTB_B2BDOORBELL_BIT14 |
 496                     NTB_SB01BASE_LOCKUP },
 497
 498         { 0x00000000, NULL, NTB_ATOM, 0 }
 499 };
 500
 501 static const struct ntb_reg atom_reg = {
 502         .ntb_ctl = ATOM_NTBCNTL_OFFSET,
 503         .lnk_sta = ATOM_LINK_STATUS_OFFSET,
 504         .db_size = sizeof(uint64_t),
 505         .mw_bar = { NTB_B2B_BAR_1, NTB_B2B_BAR_2 },
 506 };
 507
 508 static const struct ntb_alt_reg atom_pri_reg = {
 509         .db_bell = ATOM_PDOORBELL_OFFSET,
 510         .db_mask = ATOM_PDBMSK_OFFSET,
 511         .spad = ATOM_SPAD_OFFSET,
 512 };
 513
 514 static const struct ntb_alt_reg atom_b2b_reg = {
 515         .db_bell = ATOM_B2B_DOORBELL_OFFSET,
 516         .spad = ATOM_B2B_SPAD_OFFSET,
 517 };
 518
 519 static const struct ntb_xlat_reg atom_sec_xlat = {
 520 #if 0
 521         /* "FIXME" says the Linux driver. */
 522         .bar0_base = ATOM_SBAR0BASE_OFFSET,
 523         .bar2_base = ATOM_SBAR2BASE_OFFSET,
 524         .bar4_base = ATOM_SBAR4BASE_OFFSET,
 525
 526         .bar2_limit = ATOM_SBAR2LMT_OFFSET,
 527         .bar4_limit = ATOM_SBAR4LMT_OFFSET,
 528 #endif
 529
 530         .bar2_xlat = ATOM_SBAR2XLAT_OFFSET,
 531         .bar4_xlat = ATOM_SBAR4XLAT_OFFSET,
 532 };
 533
 534 static const struct ntb_reg xeon_reg = {
 535         .ntb_ctl = XEON_NTBCNTL_OFFSET,
 536         .lnk_sta = XEON_LINK_STATUS_OFFSET,
 537         .db_size = sizeof(uint16_t),
 538         .mw_bar = { NTB_B2B_BAR_1, NTB_B2B_BAR_2, NTB_B2B_BAR_3 },
 539 };
 540
 541 static const struct ntb_alt_reg xeon_pri_reg = {
 542         .db_bell = XEON_PDOORBELL_OFFSET,
 543         .db_mask = XEON_PDBMSK_OFFSET,
 544         .spad = XEON_SPAD_OFFSET,
 545 };
 546
 547 static const struct ntb_alt_reg xeon_b2b_reg = {
 548         .db_bell = XEON_B2B_DOORBELL_OFFSET,
 549         .spad = XEON_B2B_SPAD_OFFSET,
 550 };
 551
 552 static const struct ntb_xlat_reg xeon_sec_xlat = {
 553         .bar0_base = XEON_SBAR0BASE_OFFSET,
 554         .bar2_base = XEON_SBAR2BASE_OFFSET,
 555         .bar4_base = XEON_SBAR4BASE_OFFSET,
 556         .bar5_base = XEON_SBAR5BASE_OFFSET,
 557
 558         .bar2_limit = XEON_SBAR2LMT_OFFSET,
 559         .bar4_limit = XEON_SBAR4LMT_OFFSET,
 560         .bar5_limit = XEON_SBAR5LMT_OFFSET,
 561
 562         .bar2_xlat = XEON_SBAR2XLAT_OFFSET,
 563         .bar4_xlat = XEON_SBAR4XLAT_OFFSET,
 564         .bar5_xlat = XEON_SBAR5XLAT_OFFSET,
 565 };
 566
 567 static struct ntb_b2b_addr xeon_b2b_usd_addr = {
 568         .bar0_addr = XEON_B2B_BAR0_ADDR,
 569         .bar2_addr64 = XEON_B2B_BAR2_ADDR64,
 570         .bar4_addr64 = XEON_B2B_BAR4_ADDR64,
 571         .bar4_addr32 = XEON_B2B_BAR4_ADDR32,
 572         .bar5_addr32 = XEON_B2B_BAR5_ADDR32,
 573 };
 574
 575 static struct ntb_b2b_addr xeon_b2b_dsd_addr = {
 576         .bar0_addr = XEON_B2B_BAR0_ADDR,
 577         .bar2_addr64 = XEON_B2B_BAR2_ADDR64,
 578         .bar4_addr64 = XEON_B2B_BAR4_ADDR64,
 579         .bar4_addr32 = XEON_B2B_BAR4_ADDR32,
 580         .bar5_addr32 = XEON_B2B_BAR5_ADDR32,
 581 };
 582
 583 SYSCTL_NODE(_hw_ntb, OID_AUTO, xeon_b2b, CTLFLAG_RW, 0,
 584     "B2B MW segment overrides -- MUST be the same on both sides");
 585
 586 SYSCTL_UQUAD(_hw_ntb_xeon_b2b, OID_AUTO, usd_bar2_addr64, CTLFLAG_RDTUN,
 587     &xeon_b2b_usd_addr.bar2_addr64, 0, "If using B2B topology on Xeon "
 588     "hardware, use this 64-bit address on the bus between the NTB devices for "
 589     "the window at BAR2, on the upstream side of the link.  MUST be the same "
 590     "address on both sides.");
 591 SYSCTL_UQUAD(_hw_ntb_xeon_b2b, OID_AUTO, usd_bar4_addr64, CTLFLAG_RDTUN,
 592     &xeon_b2b_usd_addr.bar4_addr64, 0, "See usd_bar2_addr64, but BAR4.");
 593 SYSCTL_UQUAD(_hw_ntb_xeon_b2b, OID_AUTO, usd_bar4_addr32, CTLFLAG_RDTUN,
 594     &xeon_b2b_usd_addr.bar4_addr32, 0, "See usd_bar2_addr64, but BAR4 "
 595     "(split-BAR mode).");
 596 SYSCTL_UQUAD(_hw_ntb_xeon_b2b, OID_AUTO, usd_bar5_addr32, CTLFLAG_RDTUN,
 597     &xeon_b2b_usd_addr.bar5_addr32, 0, "See usd_bar2_addr64, but BAR5 "
 598     "(split-BAR mode).");
 599
 600 SYSCTL_UQUAD(_hw_ntb_xeon_b2b, OID_AUTO, dsd_bar2_addr64, CTLFLAG_RDTUN,
 601     &xeon_b2b_dsd_addr.bar2_addr64, 0, "If using B2B topology on Xeon "
 602     "hardware, use this 64-bit address on the bus between the NTB devices for "
 603     "the window at BAR2, on the downstream side of the link.  MUST be the same"
 604     " address on both sides.");
 605 SYSCTL_UQUAD(_hw_ntb_xeon_b2b, OID_AUTO, dsd_bar4_addr64, CTLFLAG_RDTUN,
 606     &xeon_b2b_dsd_addr.bar4_addr64, 0, "See dsd_bar2_addr64, but BAR4.");
 607 SYSCTL_UQUAD(_hw_ntb_xeon_b2b, OID_AUTO, dsd_bar4_addr32, CTLFLAG_RDTUN,
 608     &xeon_b2b_dsd_addr.bar4_addr32, 0, "See dsd_bar2_addr64, but BAR4 "
 609     "(split-BAR mode).");
 610 SYSCTL_UQUAD(_hw_ntb_xeon_b2b, OID_AUTO, dsd_bar5_addr32, CTLFLAG_RDTUN,
 611     &xeon_b2b_dsd_addr.bar5_addr32, 0, "See dsd_bar2_addr64, but BAR5 "
 612     "(split-BAR mode).");
 613
 614 /*
 615  * OS <-> Driver interface structures
 616  */
 617 MALLOC_DEFINE(M_NTB, "ntb_hw", "ntb_hw driver memory allocations");
 618
 619 /*
 620  * OS <-> Driver linkage functions
 621  */
 622 static int
 623 intel_ntb_probe(device_t device)
 624 {
 625         struct ntb_hw_info *p;
 626
 627         p = intel_ntb_get_device_info(pci_get_devid(device));
 628         if (p == NULL)
 629                 return (ENXIO);
 630
 631         device_set_desc(device, p->desc);
 632         return (0);
 633 }
 634
 635 static int
 636 intel_ntb_attach(device_t device)
 637 {
 638         struct ntb_softc *ntb;
 639         struct ntb_hw_info *p;
 640         int error;
 641
 642         ntb = device_get_softc(device);
 643         p = intel_ntb_get_device_info(pci_get_devid(device));
 644
 645         ntb->device = device;
 646         ntb->type = p->type;
 647         ntb->features = p->features;
 648         ntb->b2b_mw_idx = B2B_MW_DISABLED;
 649         ntb->msix_mw_idx = B2B_MW_DISABLED;
 650
 651         /* Heartbeat timer for NTB_ATOM since there is no link interrupt */
 652         callout_init(&ntb->heartbeat_timer, 1);
 653         callout_init(&ntb->lr_timer, 1);
 654         callout_init(&ntb->peer_msix_work, 1);
 655         mtx_init(&ntb->db_mask_lock, "ntb hw bits", NULL, MTX_SPIN);
 656
 657         if (ntb->type == NTB_ATOM)
 658                 error = intel_ntb_detect_atom(ntb);
 659         else
 660                 error = intel_ntb_detect_xeon(ntb);
 661         if (error != 0)
 662                 goto out;
 663
 664         intel_ntb_detect_max_mw(ntb);
 665
 666         pci_enable_busmaster(ntb->device);
 667
 668         error = intel_ntb_map_pci_bars(ntb);
 669         if (error != 0)
 670                 goto out;
 671         if (ntb->type == NTB_ATOM)
 672                 error = intel_ntb_atom_init_dev(ntb);
 673         else
 674                 error = intel_ntb_xeon_init_dev(ntb);
 675         if (error != 0)
 676                 goto out;
 677
 678         intel_ntb_spad_clear(device);
 679
 680         intel_ntb_poll_link(ntb);
 681
 682         intel_ntb_sysctl_init(ntb);
 683
 684         /* Attach children to this controller */
 685         error = ntb_register_device(device);
 686
 687 out:
 688         if (error != 0)
 689                 intel_ntb_detach(device);
 690         return (error);
 691 }
 692
 693 static int
 694 intel_ntb_detach(device_t device)
 695 {
 696         struct ntb_softc *ntb;
 697
 698         ntb = device_get_softc(device);
 699
 700         /* Detach & delete all children */
 701         ntb_unregister_device(device);
 702
 703         if (ntb->self_reg != NULL) {
 704                 DB_MASK_LOCK(ntb);
 705                 db_iowrite(ntb, ntb->self_reg->db_mask, ntb->db_valid_mask);
 706                 DB_MASK_UNLOCK(ntb);
 707         }
 708         callout_drain(&ntb->heartbeat_timer);
 709         callout_drain(&ntb->lr_timer);
 710         callout_drain(&ntb->peer_msix_work);
 711         pci_disable_busmaster(ntb->device);
 712         if (ntb->type == NTB_XEON)
 713                 intel_ntb_teardown_xeon(ntb);
 714         intel_ntb_teardown_interrupts(ntb);
 715
 716         mtx_destroy(&ntb->db_mask_lock);
 717
 718         intel_ntb_unmap_pci_bar(ntb);
 719
 720         return (0);
 721 }
 722
 723 /*
 724  * Driver internal routines
 725  */
 726 static inline enum ntb_bar
 727 intel_ntb_mw_to_bar(struct ntb_softc *ntb, unsigned mw)
 728 {
 729
 730         KASSERT(mw < ntb->mw_count,
 731             ("%s: mw:%u > count:%u", __func__, mw, (unsigned)ntb->mw_count));
 732         KASSERT(ntb->reg->mw_bar[mw] != 0, ("invalid mw"));
 733
 734         return (ntb->reg->mw_bar[mw]);
 735 }
 736
 737 static inline bool
 738 bar_is_64bit(struct ntb_softc *ntb, enum ntb_bar bar)
 739 {
 740         /* XXX This assertion could be stronger. */
 741         KASSERT(bar < NTB_MAX_BARS, ("bogus bar"));
 742         return (bar < NTB_B2B_BAR_2 || !HAS_FEATURE(ntb, NTB_SPLIT_BAR));
 743 }
 744
 745 static inline void
 746 bar_get_xlat_params(struct ntb_softc *ntb, enum ntb_bar bar, uint32_t *base,
 747     uint32_t *xlat, uint32_t *lmt)
 748 {
 749         uint32_t basev, lmtv, xlatv;
 750
 751         switch (bar) {
 752         case NTB_B2B_BAR_1:
 753                 basev = ntb->xlat_reg->bar2_base;
 754                 lmtv = ntb->xlat_reg->bar2_limit;
 755                 xlatv = ntb->xlat_reg->bar2_xlat;
 756                 break;
 757         case NTB_B2B_BAR_2:
 758                 basev = ntb->xlat_reg->bar4_base;
 759                 lmtv = ntb->xlat_reg->bar4_limit;
 760                 xlatv = ntb->xlat_reg->bar4_xlat;
 761                 break;
 762         case NTB_B2B_BAR_3:
 763                 basev = ntb->xlat_reg->bar5_base;
 764                 lmtv = ntb->xlat_reg->bar5_limit;
 765                 xlatv = ntb->xlat_reg->bar5_xlat;
 766                 break;
 767         default:
 768                 KASSERT(bar >= NTB_B2B_BAR_1 && bar < NTB_MAX_BARS,
 769                     ("bad bar"));
 770                 basev = lmtv = xlatv = 0;
 771                 break;
 772         }
 773
 774         if (base != NULL)
 775                 *base = basev;
 776         if (xlat != NULL)
 777                 *xlat = xlatv;
 778         if (lmt != NULL)
 779                 *lmt = lmtv;
 780 }
 781
 782 static int
 783 intel_ntb_map_pci_bars(struct ntb_softc *ntb)
 784 {
 785         int rc;
 786
 787         ntb->bar_info[NTB_CONFIG_BAR].pci_resource_id = PCIR_BAR(0);
 788         rc = map_mmr_bar(ntb, &ntb->bar_info[NTB_CONFIG_BAR]);
 789         if (rc != 0)
 790                 goto out;
 791
 792         ntb->bar_info[NTB_B2B_BAR_1].pci_resource_id = PCIR_BAR(2);
 793         rc = map_memory_window_bar(ntb, &ntb->bar_info[NTB_B2B_BAR_1]);
 794         if (rc != 0)
 795                 goto out;
 796         ntb->bar_info[NTB_B2B_BAR_1].psz_off = XEON_PBAR23SZ_OFFSET;
 797         ntb->bar_info[NTB_B2B_BAR_1].ssz_off = XEON_SBAR23SZ_OFFSET;
 798         ntb->bar_info[NTB_B2B_BAR_1].pbarxlat_off = XEON_PBAR2XLAT_OFFSET;
 799
 800         ntb->bar_info[NTB_B2B_BAR_2].pci_resource_id = PCIR_BAR(4);
 801         rc = map_memory_window_bar(ntb, &ntb->bar_info[NTB_B2B_BAR_2]);
 802         if (rc != 0)
 803                 goto out;
 804         ntb->bar_info[NTB_B2B_BAR_2].psz_off = XEON_PBAR4SZ_OFFSET;
 805         ntb->bar_info[NTB_B2B_BAR_2].ssz_off = XEON_SBAR4SZ_OFFSET;
 806         ntb->bar_info[NTB_B2B_BAR_2].pbarxlat_off = XEON_PBAR4XLAT_OFFSET;
 807
 808         if (!HAS_FEATURE(ntb, NTB_SPLIT_BAR))
 809                 goto out;
 810
 811         ntb->bar_info[NTB_B2B_BAR_3].pci_resource_id = PCIR_BAR(5);
 812         rc = map_memory_window_bar(ntb, &ntb->bar_info[NTB_B2B_BAR_3]);
 813         ntb->bar_info[NTB_B2B_BAR_3].psz_off = XEON_PBAR5SZ_OFFSET;
 814         ntb->bar_info[NTB_B2B_BAR_3].ssz_off = XEON_SBAR5SZ_OFFSET;
 815         ntb->bar_info[NTB_B2B_BAR_3].pbarxlat_off = XEON_PBAR5XLAT_OFFSET;
 816
 817 out:
 818         if (rc != 0)
 819                 device_printf(ntb->device,
 820                     "unable to allocate pci resource\n");
 821         return (rc);
 822 }
 823
 824 static void
 825 print_map_success(struct ntb_softc *ntb, struct ntb_pci_bar_info *bar,
 826     const char *kind)
 827 {
 828
 829         device_printf(ntb->device,
 830             "Mapped BAR%d v:[%p-%p] p:[%p-%p] (0x%jx bytes) (%s)\n",
 831             PCI_RID2BAR(bar->pci_resource_id), bar->vbase,
 832             (char *)bar->vbase + bar->size - 1,
 833             (void *)bar->pbase, (void *)(bar->pbase + bar->size - 1),
 834             (uintmax_t)bar->size, kind);
 835 }
 836
 837 static int
 838 map_mmr_bar(struct ntb_softc *ntb, struct ntb_pci_bar_info *bar)
 839 {
 840
 841         bar->pci_resource = bus_alloc_resource_any(ntb->device, SYS_RES_MEMORY,
 842             &bar->pci_resource_id, RF_ACTIVE);
 843         if (bar->pci_resource == NULL)
 844                 return (ENXIO);
 845
 846         save_bar_parameters(bar);
 847         bar->map_mode = VM_MEMATTR_UNCACHEABLE;
 848         print_map_success(ntb, bar, "mmr");
 849         return (0);
 850 }
 851
 852 static int
 853 map_memory_window_bar(struct ntb_softc *ntb, struct ntb_pci_bar_info *bar)
 854 {
 855         int rc;
 856         vm_memattr_t mapmode;
 857         uint8_t bar_size_bits = 0;
 858
 859         bar->pci_resource = bus_alloc_resource_any(ntb->device, SYS_RES_MEMORY,
 860             &bar->pci_resource_id, RF_ACTIVE);
 861
 862         if (bar->pci_resource == NULL)
 863                 return (ENXIO);
 864
 865         save_bar_parameters(bar);
 866         /*
 867          * Ivytown NTB BAR sizes are misreported by the hardware due to a
 868          * hardware issue. To work around this, query the size it should be
 869          * configured to by the device and modify the resource to correspond to
 870          * this new size. The BIOS on systems with this problem is required to
 871          * provide enough address space to allow the driver to make this change
 872          * safely.
 873          *
 874          * Ideally I could have just specified the size when I allocated the
 875          * resource like:
 876          *  bus_alloc_resource(ntb->device,
 877          *      SYS_RES_MEMORY, &bar->pci_resource_id, 0ul, ~0ul,
 878          *      1ul << bar_size_bits, RF_ACTIVE);
 879          * but the PCI driver does not honor the size in this call, so we have
 880          * to modify it after the fact.
 881          */
 882         if (HAS_FEATURE(ntb, NTB_BAR_SIZE_4K)) {
 883                 if (bar->pci_resource_id == PCIR_BAR(2))
 884                         bar_size_bits = pci_read_config(ntb->device,
 885                             XEON_PBAR23SZ_OFFSET, 1);
 886                 else
 887                         bar_size_bits = pci_read_config(ntb->device,
 888                             XEON_PBAR45SZ_OFFSET, 1);
 889
 890                 rc = bus_adjust_resource(ntb->device, SYS_RES_MEMORY,
 891                     bar->pci_resource, bar->pbase,
 892                     bar->pbase + (1ul << bar_size_bits) - 1);
 893                 if (rc != 0) {
 894                         device_printf(ntb->device,
 895                             "unable to resize bar\n");
 896                         return (rc);
 897                 }
 898
 899                 save_bar_parameters(bar);
 900         }
 901
 902         bar->map_mode = VM_MEMATTR_UNCACHEABLE;
 903         print_map_success(ntb, bar, "mw");
 904
 905         /*
 906          * Optionally, mark MW BARs as anything other than UC to improve
 907          * performance.
 908          */
 909         mapmode = intel_ntb_pat_flags();
 910         if (mapmode == bar->map_mode)
 911                 return (0);
 912
 913         rc = pmap_change_attr((vm_offset_t)bar->vbase, bar->size, mapmode);
 914         if (rc == 0) {
 915                 bar->map_mode = mapmode;
 916                 device_printf(ntb->device,
 917                     "Marked BAR%d v:[%p-%p] p:[%p-%p] as "
 918                     "%s.\n",
 919                     PCI_RID2BAR(bar->pci_resource_id), bar->vbase,
 920                     (char *)bar->vbase + bar->size - 1,
 921                     (void *)bar->pbase, (void *)(bar->pbase + bar->size - 1),
 922                     intel_ntb_vm_memattr_to_str(mapmode));
 923         } else
 924                 device_printf(ntb->device,
 925                     "Unable to mark BAR%d v:[%p-%p] p:[%p-%p] as "
 926                     "%s: %d\n",
 927                     PCI_RID2BAR(bar->pci_resource_id), bar->vbase,
 928                     (char *)bar->vbase + bar->size - 1,
 929                     (void *)bar->pbase, (void *)(bar->pbase + bar->size - 1),
 930                     intel_ntb_vm_memattr_to_str(mapmode), rc);
 931                 /* Proceed anyway */
 932         return (0);
 933 }
 934
 935 static void
 936 intel_ntb_unmap_pci_bar(struct ntb_softc *ntb)
 937 {
 938         struct ntb_pci_bar_info *current_bar;
 939         int i;
 940
 941         for (i = 0; i < NTB_MAX_BARS; i++) {
 942                 current_bar = &ntb->bar_info[i];
 943                 if (current_bar->pci_resource != NULL)
 944                         bus_release_resource(ntb->device, SYS_RES_MEMORY,
 945                             current_bar->pci_resource_id,
 946                             current_bar->pci_resource);
 947         }
 948 }
 949
 950 static int
 951 intel_ntb_setup_msix(struct ntb_softc *ntb, uint32_t num_vectors)
 952 {
 953         uint32_t i;
 954         int rc;
 955
 956         for (i = 0; i < num_vectors; i++) {
 957                 ntb->int_info[i].rid = i + 1;
 958                 ntb->int_info[i].res = bus_alloc_resource_any(ntb->device,
 959                     SYS_RES_IRQ, &ntb->int_info[i].rid, RF_ACTIVE);
 960                 if (ntb->int_info[i].res == NULL) {
 961                         device_printf(ntb->device,
 962                             "bus_alloc_resource failed\n");
 963                         return (ENOMEM);
 964                 }
 965                 ntb->int_info[i].tag = NULL;
 966                 ntb->allocated_interrupts++;
 967                 rc = bus_setup_intr(ntb->device, ntb->int_info[i].res,
 968                     INTR_MPSAFE | INTR_TYPE_MISC, NULL, ndev_vec_isr,
 969                     &ntb->msix_vec[i], &ntb->int_info[i].tag);
 970                 if (rc != 0) {
 971                         device_printf(ntb->device, "bus_setup_intr failed\n");
 972                         return (ENXIO);
 973                 }
 974         }
 975         return (0);
 976 }
 977
 978 /*
 979  * The Linux NTB driver drops from MSI-X to legacy INTx if a unique vector
 980  * cannot be allocated for each MSI-X message.  JHB seems to think remapping
 981  * should be okay.  This tunable should enable us to test that hypothesis
 982  * when someone gets their hands on some Xeon hardware.
 983  */
 984 static int ntb_force_remap_mode;
 985 SYSCTL_INT(_hw_ntb, OID_AUTO, force_remap_mode, CTLFLAG_RDTUN,
 986     &ntb_force_remap_mode, 0, "If enabled, force MSI-X messages to be remapped"
 987     " to a smaller number of ithreads, even if the desired number are "
 988     "available");
 989
 990 /*
 991  * In case it is NOT ok, give consumers an abort button.
 992  */
 993 static int ntb_prefer_intx;
 994 SYSCTL_INT(_hw_ntb, OID_AUTO, prefer_intx_to_remap, CTLFLAG_RDTUN,
 995     &ntb_prefer_intx, 0, "If enabled, prefer to use legacy INTx mode rather "
 996     "than remapping MSI-X messages over available slots (match Linux driver "
 997     "behavior)");
 998
 999 /*
1000  * Remap the desired number of MSI-X messages to available ithreads in a simple
1001  * round-robin fashion.
1002  */
1003 static int
1004 intel_ntb_remap_msix(device_t dev, uint32_t desired, uint32_t avail)
1005 {
1006         u_int *vectors;
1007         uint32_t i;
1008         int rc;
1009
1010         if (ntb_prefer_intx != 0)
1011                 return (ENXIO);
1012
1013         vectors = malloc(desired * sizeof(*vectors), M_NTB, M_ZERO | M_WAITOK);
1014
1015         for (i = 0; i < desired; i++)
1016                 vectors[i] = (i % avail) + 1;
1017
1018         rc = pci_remap_msix(dev, desired, vectors);
1019         free(vectors, M_NTB);
1020         return (rc);
1021 }
1022
1023 static int
1024 intel_ntb_init_isr(struct ntb_softc *ntb)
1025 {
1026         uint32_t desired_vectors, num_vectors;
1027         int rc;
1028
1029         ntb->allocated_interrupts = 0;
1030         ntb->last_ts = ticks;
1031
1032         /*
1033          * Mask all doorbell interrupts.  (Except link events!)
1034          */
1035         DB_MASK_LOCK(ntb);
1036         ntb->db_mask = ntb->db_valid_mask;
1037         db_iowrite(ntb, ntb->self_reg->db_mask, ntb->db_mask);
1038         DB_MASK_UNLOCK(ntb);
1039
1040         num_vectors = desired_vectors = MIN(pci_msix_count(ntb->device),
1041             ntb->db_count);
1042         if (desired_vectors >= 1) {
1043                 rc = pci_alloc_msix(ntb->device, &num_vectors);
1044
1045                 if (ntb_force_remap_mode != 0 && rc == 0 &&
1046                     num_vectors == desired_vectors)
1047                         num_vectors--;
1048
1049                 if (rc == 0 && num_vectors < desired_vectors) {
1050                         rc = intel_ntb_remap_msix(ntb->device, desired_vectors,
1051                             num_vectors);
1052                         if (rc == 0)
1053                                 num_vectors = desired_vectors;
1054                         else
1055                                 pci_release_msi(ntb->device);
1056                 }
1057                 if (rc != 0)
1058                         num_vectors = 1;
1059         } else
1060                 num_vectors = 1;
1061
1062         if (ntb->type == NTB_XEON && num_vectors < ntb->db_vec_count) {
1063                 if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP)) {
1064                         device_printf(ntb->device,
1065                             "Errata workaround does not support MSI or INTX\n");
1066                         return (EINVAL);
1067                 }
1068
1069                 ntb->db_vec_count = 1;
1070                 ntb->db_vec_shift = XEON_DB_TOTAL_SHIFT;
1071                 rc = intel_ntb_setup_legacy_interrupt(ntb);
1072         } else {
1073                 if (num_vectors - 1 != XEON_NONLINK_DB_MSIX_BITS &&
1074                     HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP)) {
1075                         device_printf(ntb->device,
1076                             "Errata workaround expects %d doorbell bits\n",
1077                             XEON_NONLINK_DB_MSIX_BITS);
1078                         return (EINVAL);
1079                 }
1080
1081                 intel_ntb_create_msix_vec(ntb, num_vectors);
1082                 rc = intel_ntb_setup_msix(ntb, num_vectors);
1083         }
1084         if (rc != 0) {
1085                 device_printf(ntb->device,
1086                     "Error allocating interrupts: %d\n", rc);
1087                 intel_ntb_free_msix_vec(ntb);
1088         }
1089
1090         return (rc);
1091 }
1092
1093 static int
1094 intel_ntb_setup_legacy_interrupt(struct ntb_softc *ntb)
1095 {
1096         int rc;
1097
1098         ntb->int_info[0].rid = 0;
1099         ntb->int_info[0].res = bus_alloc_resource_any(ntb->device, SYS_RES_IRQ,
1100             &ntb->int_info[0].rid, RF_SHAREABLE|RF_ACTIVE);
1101         if (ntb->int_info[0].res == NULL) {
1102                 device_printf(ntb->device, "bus_alloc_resource failed\n");
1103                 return (ENOMEM);
1104         }
1105
1106         ntb->int_info[0].tag = NULL;
1107         ntb->allocated_interrupts = 1;
1108
1109         rc = bus_setup_intr(ntb->device, ntb->int_info[0].res,
1110             INTR_MPSAFE | INTR_TYPE_MISC, NULL, ndev_irq_isr,
1111             ntb, &ntb->int_info[0].tag);
1112         if (rc != 0) {
1113                 device_printf(ntb->device, "bus_setup_intr failed\n");
1114                 return (ENXIO);
1115         }
1116
1117         return (0);
1118 }
1119
1120 static void
1121 intel_ntb_teardown_interrupts(struct ntb_softc *ntb)
1122 {
1123         struct ntb_int_info *current_int;
1124         int i;
1125
1126         for (i = 0; i < ntb->allocated_interrupts; i++) {
1127                 current_int = &ntb->int_info[i];
1128                 if (current_int->tag != NULL)
1129                         bus_teardown_intr(ntb->device, current_int->res,
1130                             current_int->tag);
1131
1132                 if (current_int->res != NULL)
1133                         bus_release_resource(ntb->device, SYS_RES_IRQ,
1134                             rman_get_rid(current_int->res), current_int->res);
1135         }
1136
1137         intel_ntb_free_msix_vec(ntb);
1138         pci_release_msi(ntb->device);
1139 }
1140
1141 /*
1142  * Doorbell register and mask are 64-bit on Atom, 16-bit on Xeon.  Abstract it
1143  * out to make code clearer.
1144  */
1145 static inline uint64_t
1146 db_ioread(struct ntb_softc *ntb, uint64_t regoff)
1147 {
1148
1149         if (ntb->type == NTB_ATOM)
1150                 return (intel_ntb_reg_read(8, regoff));
1151
1152         KASSERT(ntb->type == NTB_XEON, ("bad ntb type"));
1153
1154         return (intel_ntb_reg_read(2, regoff));
1155 }
1156
1157 static inline void
1158 db_iowrite(struct ntb_softc *ntb, uint64_t regoff, uint64_t val)
1159 {
1160
1161         KASSERT((val & ~ntb->db_valid_mask) == 0,
1162             ("%s: Invalid bits 0x%jx (valid: 0x%jx)", __func__,
1163              (uintmax_t)(val & ~ntb->db_valid_mask),
1164              (uintmax_t)ntb->db_valid_mask));
1165
1166         if (regoff == ntb->self_reg->db_mask)
1167                 DB_MASK_ASSERT(ntb, MA_OWNED);
1168         db_iowrite_raw(ntb, regoff, val);
1169 }
1170
1171 static inline void
1172 db_iowrite_raw(struct ntb_softc *ntb, uint64_t regoff, uint64_t val)
1173 {
1174
1175         if (ntb->type == NTB_ATOM) {
1176                 intel_ntb_reg_write(8, regoff, val);
1177                 return;
1178         }
1179
1180         KASSERT(ntb->type == NTB_XEON, ("bad ntb type"));
1181         intel_ntb_reg_write(2, regoff, (uint16_t)val);
1182 }
1183
1184 static void
1185 intel_ntb_db_set_mask(device_t dev, uint64_t bits)
1186 {
1187         struct ntb_softc *ntb = device_get_softc(dev);
1188
1189         DB_MASK_LOCK(ntb);
1190         ntb->db_mask |= bits;
1191         if (!HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP))
1192                 db_iowrite(ntb, ntb->self_reg->db_mask, ntb->db_mask);
1193         DB_MASK_UNLOCK(ntb);
1194 }
1195
1196 static void
1197 intel_ntb_db_clear_mask(device_t dev, uint64_t bits)
1198 {
1199         struct ntb_softc *ntb = device_get_softc(dev);
1200         uint64_t ibits;
1201         int i;
1202
1203         KASSERT((bits & ~ntb->db_valid_mask) == 0,
1204             ("%s: Invalid bits 0x%jx (valid: 0x%jx)", __func__,
1205              (uintmax_t)(bits & ~ntb->db_valid_mask),
1206              (uintmax_t)ntb->db_valid_mask));
1207
1208         DB_MASK_LOCK(ntb);
1209         ibits = ntb->fake_db_bell & ntb->db_mask & bits;
1210         ntb->db_mask &= ~bits;
1211         if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP)) {
1212                 /* Simulate fake interrupts if unmasked DB bits are set. */
1213                 for (i = 0; i < XEON_NONLINK_DB_MSIX_BITS; i++) {
1214                         if ((ibits & intel_ntb_db_vector_mask(dev, i)) != 0)
1215                                 swi_sched(ntb->int_info[i].tag, 0);
1216                 }
1217         } else {
1218                 db_iowrite(ntb, ntb->self_reg->db_mask, ntb->db_mask);
1219         }
1220         DB_MASK_UNLOCK(ntb);
1221 }
1222
1223 static uint64_t
1224 intel_ntb_db_read(device_t dev)
1225 {
1226         struct ntb_softc *ntb = device_get_softc(dev);
1227
1228         if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP))
1229                 return (ntb->fake_db_bell);
1230
1231         return (db_ioread(ntb, ntb->self_reg->db_bell));
1232 }
1233
1234 static void
1235 intel_ntb_db_clear(device_t dev, uint64_t bits)
1236 {
1237         struct ntb_softc *ntb = device_get_softc(dev);
1238
1239         KASSERT((bits & ~ntb->db_valid_mask) == 0,
1240             ("%s: Invalid bits 0x%jx (valid: 0x%jx)", __func__,
1241              (uintmax_t)(bits & ~ntb->db_valid_mask),
1242              (uintmax_t)ntb->db_valid_mask));
1243
1244         if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP)) {
1245                 DB_MASK_LOCK(ntb);
1246                 ntb->fake_db_bell &= ~bits;
1247                 DB_MASK_UNLOCK(ntb);
1248                 return;
1249         }
1250
1251         db_iowrite(ntb, ntb->self_reg->db_bell, bits);
1252 }
1253
1254 static inline uint64_t
1255 intel_ntb_vec_mask(struct ntb_softc *ntb, uint64_t db_vector)
1256 {
1257         uint64_t shift, mask;
1258
1259         if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP)) {
1260                 /*
1261                  * Remap vectors in custom way to make at least first
1262                  * three doorbells to not generate stray events.
1263                  * This breaks Linux compatibility (if one existed)
1264                  * when more then one DB is used (not by if_ntb).
1265                  */
1266                 if (db_vector < XEON_NONLINK_DB_MSIX_BITS - 1)
1267                         return (1 << db_vector);
1268                 if (db_vector == XEON_NONLINK_DB_MSIX_BITS - 1)
1269                         return (0x7ffc);
1270         }
1271
1272         shift = ntb->db_vec_shift;
1273         mask = (1ull << shift) - 1;
1274         return (mask << (shift * db_vector));
1275 }
1276
1277 static void
1278 intel_ntb_interrupt(struct ntb_softc *ntb, uint32_t vec)
1279 {
1280         uint64_t vec_mask;
1281
1282         ntb->last_ts = ticks;
1283         vec_mask = intel_ntb_vec_mask(ntb, vec);
1284
1285         if ((vec_mask & ntb->db_link_mask) != 0) {
1286                 if (intel_ntb_poll_link(ntb))
1287                         ntb_link_event(ntb->device);
1288         }
1289
1290         if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP) &&
1291             (vec_mask & ntb->db_link_mask) == 0) {
1292                 DB_MASK_LOCK(ntb);
1293
1294                 /* Do not report same DB events again if not cleared yet. */
1295                 vec_mask &= ~ntb->fake_db_bell;
1296
1297                 /* Update our internal doorbell register. */
1298                 ntb->fake_db_bell |= vec_mask;
1299
1300                 /* Do not report masked DB events. */
1301                 vec_mask &= ~ntb->db_mask;
1302
1303                 DB_MASK_UNLOCK(ntb);
1304         }
1305
1306         if ((vec_mask & ntb->db_valid_mask) != 0)
1307                 ntb_db_event(ntb->device, vec);
1308 }
1309
1310 static void
1311 ndev_vec_isr(void *arg)
1312 {
1313         struct ntb_vec *nvec = arg;
1314
1315         intel_ntb_interrupt(nvec->ntb, nvec->num);
1316 }
1317
1318 static void
1319 ndev_irq_isr(void *arg)
1320 {
1321         /* If we couldn't set up MSI-X, we only have the one vector. */
1322         intel_ntb_interrupt(arg, 0);
1323 }
1324
1325 static int
1326 intel_ntb_create_msix_vec(struct ntb_softc *ntb, uint32_t num_vectors)
1327 {
1328         uint32_t i;
1329
1330         ntb->msix_vec = malloc(num_vectors * sizeof(*ntb->msix_vec), M_NTB,
1331             M_ZERO | M_WAITOK);
1332         for (i = 0; i < num_vectors; i++) {
1333                 ntb->msix_vec[i].num = i;
1334                 ntb->msix_vec[i].ntb = ntb;
1335         }
1336
1337         return (0);
1338 }
1339
1340 static void
1341 intel_ntb_free_msix_vec(struct ntb_softc *ntb)
1342 {
1343
1344         if (ntb->msix_vec == NULL)
1345                 return;
1346
1347         free(ntb->msix_vec, M_NTB);
1348         ntb->msix_vec = NULL;
1349 }
1350
1351 static void
1352 intel_ntb_get_msix_info(struct ntb_softc *ntb)
1353 {
1354         struct pci_devinfo *dinfo;
1355         struct pcicfg_msix *msix;
1356         uint32_t laddr, data, i, offset;
1357
1358         dinfo = device_get_ivars(ntb->device);
1359         msix = &dinfo->cfg.msix;
1360
1361         CTASSERT(XEON_NONLINK_DB_MSIX_BITS == nitems(ntb->msix_data));
1362
1363         for (i = 0; i < XEON_NONLINK_DB_MSIX_BITS; i++) {
1364                 offset = msix->msix_table_offset + i * PCI_MSIX_ENTRY_SIZE;
1365
1366                 laddr = bus_read_4(msix->msix_table_res, offset +
1367                     PCI_MSIX_ENTRY_LOWER_ADDR);
1368                 intel_ntb_printf(2, "local MSIX addr(%u): 0x%x\n", i, laddr);
1369
1370                 KASSERT((laddr & MSI_INTEL_ADDR_BASE) == MSI_INTEL_ADDR_BASE,
1371                     ("local MSIX addr 0x%x not in MSI base 0x%x", laddr,
1372                      MSI_INTEL_ADDR_BASE));
1373                 ntb->msix_data[i].nmd_ofs = laddr;
1374
1375                 data = bus_read_4(msix->msix_table_res, offset +
1376                     PCI_MSIX_ENTRY_DATA);
1377                 intel_ntb_printf(2, "local MSIX data(%u): 0x%x\n", i, data);
1378
1379                 ntb->msix_data[i].nmd_data = data;
1380         }
1381 }
1382
1383 static struct ntb_hw_info *
1384 intel_ntb_get_device_info(uint32_t device_id)
1385 {
1386         struct ntb_hw_info *ep = pci_ids;
1387
1388         while (ep->device_id) {
1389                 if (ep->device_id == device_id)
1390                         return (ep);
1391                 ++ep;
1392         }
1393         return (NULL);
1394 }
1395
1396 static void
1397 intel_ntb_teardown_xeon(struct ntb_softc *ntb)
1398 {
1399
1400         if (ntb->reg != NULL)
1401                 intel_ntb_link_disable(ntb->device);
1402 }
1403
1404 static void
1405 intel_ntb_detect_max_mw(struct ntb_softc *ntb)
1406 {
1407
1408         if (ntb->type == NTB_ATOM) {
1409                 ntb->mw_count = ATOM_MW_COUNT;
1410                 return;
1411         }
1412
1413         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR))
1414                 ntb->mw_count = XEON_HSX_SPLIT_MW_COUNT;
1415         else
1416                 ntb->mw_count = XEON_SNB_MW_COUNT;
1417 }
1418
1419 static int
1420 intel_ntb_detect_xeon(struct ntb_softc *ntb)
1421 {
1422         uint8_t ppd, conn_type;
1423
1424         ppd = pci_read_config(ntb->device, NTB_PPD_OFFSET, 1);
1425         ntb->ppd = ppd;
1426
1427         if ((ppd & XEON_PPD_DEV_TYPE) != 0)
1428                 ntb->dev_type = NTB_DEV_DSD;
1429         else
1430                 ntb->dev_type = NTB_DEV_USD;
1431
1432         if ((ppd & XEON_PPD_SPLIT_BAR) != 0)
1433                 ntb->features |= NTB_SPLIT_BAR;
1434
1435         if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP) &&
1436             !HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
1437                 device_printf(ntb->device,
1438                     "Can not apply SB01BASE_LOCKUP workaround "
1439                     "with split BARs disabled!\n");
1440                 device_printf(ntb->device,
1441                     "Expect system hangs under heavy NTB traffic!\n");
1442                 ntb->features &= ~NTB_SB01BASE_LOCKUP;
1443         }
1444
1445         /*
1446          * SDOORBELL errata workaround gets in the way of SB01BASE_LOCKUP
1447          * errata workaround; only do one at a time.
1448          */
1449         if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP))
1450                 ntb->features &= ~NTB_SDOORBELL_LOCKUP;
1451
1452         conn_type = ppd & XEON_PPD_CONN_TYPE;
1453         switch (conn_type) {
1454         case NTB_CONN_B2B:
1455                 ntb->conn_type = conn_type;
1456                 break;
1457         case NTB_CONN_RP:
1458         case NTB_CONN_TRANSPARENT:
1459         default:
1460                 device_printf(ntb->device, "Unsupported connection type: %u\n",
1461                     (unsigned)conn_type);
1462                 return (ENXIO);
1463         }
1464         return (0);
1465 }
1466
1467 static int
1468 intel_ntb_detect_atom(struct ntb_softc *ntb)
1469 {
1470         uint32_t ppd, conn_type;
1471
1472         ppd = pci_read_config(ntb->device, NTB_PPD_OFFSET, 4);
1473         ntb->ppd = ppd;
1474
1475         if ((ppd & ATOM_PPD_DEV_TYPE) != 0)
1476                 ntb->dev_type = NTB_DEV_DSD;
1477         else
1478                 ntb->dev_type = NTB_DEV_USD;
1479
1480         conn_type = (ppd & ATOM_PPD_CONN_TYPE) >> 8;
1481         switch (conn_type) {
1482         case NTB_CONN_B2B:
1483                 ntb->conn_type = conn_type;
1484                 break;
1485         default:
1486                 device_printf(ntb->device, "Unsupported NTB configuration\n");
1487                 return (ENXIO);
1488         }
1489         return (0);
1490 }
1491
1492 static int
1493 intel_ntb_xeon_init_dev(struct ntb_softc *ntb)
1494 {
1495         int rc;
1496
1497         ntb->spad_count         = XEON_SPAD_COUNT;
1498         ntb->db_count           = XEON_DB_COUNT;
1499         ntb->db_link_mask       = XEON_DB_LINK_BIT;
1500         ntb->db_vec_count       = XEON_DB_MSIX_VECTOR_COUNT;
1501         ntb->db_vec_shift       = XEON_DB_MSIX_VECTOR_SHIFT;
1502
1503         if (ntb->conn_type != NTB_CONN_B2B) {
1504                 device_printf(ntb->device, "Connection type %d not supported\n",
1505                     ntb->conn_type);
1506                 return (ENXIO);
1507         }
1508
1509         ntb->reg = &xeon_reg;
1510         ntb->self_reg = &xeon_pri_reg;
1511         ntb->peer_reg = &xeon_b2b_reg;
1512         ntb->xlat_reg = &xeon_sec_xlat;
1513
1514         if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP)) {
1515                 ntb->fake_db_bell = 0;
1516                 ntb->msix_mw_idx = (ntb->mw_count + g_ntb_msix_idx) %
1517                     ntb->mw_count;
1518                 intel_ntb_printf(2, "Setting up MSIX mw idx %d means %u\n",
1519                     g_ntb_msix_idx, ntb->msix_mw_idx);
1520                 rc = intel_ntb_mw_set_wc_internal(ntb, ntb->msix_mw_idx,
1521                     VM_MEMATTR_UNCACHEABLE);
1522                 KASSERT(rc == 0, ("shouldn't fail"));
1523         } else if (HAS_FEATURE(ntb, NTB_SDOORBELL_LOCKUP)) {
1524                 /*
1525                  * There is a Xeon hardware errata related to writes to SDOORBELL or
1526                  * B2BDOORBELL in conjunction with inbound access to NTB MMIO space,
1527                  * which may hang the system.  To workaround this, use a memory
1528                  * window to access the interrupt and scratch pad registers on the
1529                  * remote system.
1530                  */
1531                 ntb->b2b_mw_idx = (ntb->mw_count + g_ntb_mw_idx) %
1532                     ntb->mw_count;
1533                 intel_ntb_printf(2, "Setting up b2b mw idx %d means %u\n",
1534                     g_ntb_mw_idx, ntb->b2b_mw_idx);
1535                 rc = intel_ntb_mw_set_wc_internal(ntb, ntb->b2b_mw_idx,
1536                     VM_MEMATTR_UNCACHEABLE);
1537                 KASSERT(rc == 0, ("shouldn't fail"));
1538         } else if (HAS_FEATURE(ntb, NTB_B2BDOORBELL_BIT14))
1539                 /*
1540                  * HW Errata on bit 14 of b2bdoorbell register.  Writes will not be
1541                  * mirrored to the remote system.  Shrink the number of bits by one,
1542                  * since bit 14 is the last bit.
1543                  *
1544                  * On REGS_THRU_MW errata mode, we don't use the b2bdoorbell register
1545                  * anyway.  Nor for non-B2B connection types.
1546                  */
1547                 ntb->db_count = XEON_DB_COUNT - 1;
1548
1549         ntb->db_valid_mask = (1ull << ntb->db_count) - 1;
1550
1551         if (ntb->dev_type == NTB_DEV_USD)
1552                 rc = xeon_setup_b2b_mw(ntb, &xeon_b2b_dsd_addr,
1553                     &xeon_b2b_usd_addr);
1554         else
1555                 rc = xeon_setup_b2b_mw(ntb, &xeon_b2b_usd_addr,
1556                     &xeon_b2b_dsd_addr);
1557         if (rc != 0)
1558                 return (rc);
1559
1560         /* Enable Bus Master and Memory Space on the secondary side */
1561         intel_ntb_reg_write(2, XEON_SPCICMD_OFFSET,
1562             PCIM_CMD_MEMEN | PCIM_CMD_BUSMASTEREN);
1563
1564         /*
1565          * Mask all doorbell interrupts.
1566          */
1567         DB_MASK_LOCK(ntb);
1568         ntb->db_mask = ntb->db_valid_mask;
1569         db_iowrite(ntb, ntb->self_reg->db_mask, ntb->db_mask);
1570         DB_MASK_UNLOCK(ntb);
1571
1572         rc = intel_ntb_init_isr(ntb);
1573         return (rc);
1574 }
1575
1576 static int
1577 intel_ntb_atom_init_dev(struct ntb_softc *ntb)
1578 {
1579         int error;
1580
1581         KASSERT(ntb->conn_type == NTB_CONN_B2B,
1582             ("Unsupported NTB configuration (%d)\n", ntb->conn_type));
1583
1584         ntb->spad_count          = ATOM_SPAD_COUNT;
1585         ntb->db_count            = ATOM_DB_COUNT;
1586         ntb->db_vec_count        = ATOM_DB_MSIX_VECTOR_COUNT;
1587         ntb->db_vec_shift        = ATOM_DB_MSIX_VECTOR_SHIFT;
1588         ntb->db_valid_mask       = (1ull << ntb->db_count) - 1;
1589
1590         ntb->reg = &atom_reg;
1591         ntb->self_reg = &atom_pri_reg;
1592         ntb->peer_reg = &atom_b2b_reg;
1593         ntb->xlat_reg = &atom_sec_xlat;
1594
1595         /*
1596          * FIXME - MSI-X bug on early Atom HW, remove once internal issue is
1597          * resolved.  Mask transaction layer internal parity errors.
1598          */
1599         pci_write_config(ntb->device, 0xFC, 0x4, 4);
1600
1601         configure_atom_secondary_side_bars(ntb);
1602
1603         /* Enable Bus Master and Memory Space on the secondary side */
1604         intel_ntb_reg_write(2, ATOM_SPCICMD_OFFSET,
1605             PCIM_CMD_MEMEN | PCIM_CMD_BUSMASTEREN);
1606
1607         error = intel_ntb_init_isr(ntb);
1608         if (error != 0)
1609                 return (error);
1610
1611         /* Initiate PCI-E link training */
1612         intel_ntb_link_enable(ntb->device, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
1613
1614         callout_reset(&ntb->heartbeat_timer, 0, atom_link_hb, ntb);
1615
1616         return (0);
1617 }
1618
1619 /* XXX: Linux driver doesn't seem to do any of this for Atom. */
1620 static void
1621 configure_atom_secondary_side_bars(struct ntb_softc *ntb)
1622 {
1623
1624         if (ntb->dev_type == NTB_DEV_USD) {
1625                 intel_ntb_reg_write(8, ATOM_PBAR2XLAT_OFFSET,
1626                     XEON_B2B_BAR2_ADDR64);
1627                 intel_ntb_reg_write(8, ATOM_PBAR4XLAT_OFFSET,
1628                     XEON_B2B_BAR4_ADDR64);
1629                 intel_ntb_reg_write(8, ATOM_MBAR23_OFFSET, XEON_B2B_BAR2_ADDR64);
1630                 intel_ntb_reg_write(8, ATOM_MBAR45_OFFSET, XEON_B2B_BAR4_ADDR64);
1631         } else {
1632                 intel_ntb_reg_write(8, ATOM_PBAR2XLAT_OFFSET,
1633                     XEON_B2B_BAR2_ADDR64);
1634                 intel_ntb_reg_write(8, ATOM_PBAR4XLAT_OFFSET,
1635                     XEON_B2B_BAR4_ADDR64);
1636                 intel_ntb_reg_write(8, ATOM_MBAR23_OFFSET, XEON_B2B_BAR2_ADDR64);
1637                 intel_ntb_reg_write(8, ATOM_MBAR45_OFFSET, XEON_B2B_BAR4_ADDR64);
1638         }
1639 }
1640
1641
1642 /*
1643  * When working around Xeon SDOORBELL errata by remapping remote registers in a
1644  * MW, limit the B2B MW to half a MW.  By sharing a MW, half the shared MW
1645  * remains for use by a higher layer.
1646  *
1647  * Will only be used if working around SDOORBELL errata and the BIOS-configured
1648  * MW size is sufficiently large.
1649  */
1650 static unsigned int ntb_b2b_mw_share;
1651 SYSCTL_UINT(_hw_ntb, OID_AUTO, b2b_mw_share, CTLFLAG_RDTUN, &ntb_b2b_mw_share,
1652     0, "If enabled (non-zero), prefer to share half of the B2B peer register "
1653     "MW with higher level consumers.  Both sides of the NTB MUST set the same "
1654     "value here.");
1655
1656 static void
1657 xeon_reset_sbar_size(struct ntb_softc *ntb, enum ntb_bar idx,
1658     enum ntb_bar regbar)
1659 {
1660         struct ntb_pci_bar_info *bar;
1661         uint8_t bar_sz;
1662
1663         if (!HAS_FEATURE(ntb, NTB_SPLIT_BAR) && idx >= NTB_B2B_BAR_3)
1664                 return;
1665
1666         bar = &ntb->bar_info[idx];
1667         bar_sz = pci_read_config(ntb->device, bar->psz_off, 1);
1668         if (idx == regbar) {
1669                 if (ntb->b2b_off != 0)
1670                         bar_sz--;
1671                 else
1672                         bar_sz = 0;
1673         }
1674         pci_write_config(ntb->device, bar->ssz_off, bar_sz, 1);
1675         bar_sz = pci_read_config(ntb->device, bar->ssz_off, 1);
1676         (void)bar_sz;
1677 }
1678
1679 static void
1680 xeon_set_sbar_base_and_limit(struct ntb_softc *ntb, uint64_t bar_addr,
1681     enum ntb_bar idx, enum ntb_bar regbar)
1682 {
1683         uint64_t reg_val;
1684         uint32_t base_reg, lmt_reg;
1685
1686         bar_get_xlat_params(ntb, idx, &base_reg, NULL, &lmt_reg);
1687         if (idx == regbar) {
1688                 if (ntb->b2b_off)
1689                         bar_addr += ntb->b2b_off;
1690                 else
1691                         bar_addr = 0;
1692         }
1693
1694         if (!bar_is_64bit(ntb, idx)) {
1695                 intel_ntb_reg_write(4, base_reg, bar_addr);
1696                 reg_val = intel_ntb_reg_read(4, base_reg);
1697                 (void)reg_val;
1698
1699                 intel_ntb_reg_write(4, lmt_reg, bar_addr);
1700                 reg_val = intel_ntb_reg_read(4, lmt_reg);
1701                 (void)reg_val;
1702         } else {
1703                 intel_ntb_reg_write(8, base_reg, bar_addr);
1704                 reg_val = intel_ntb_reg_read(8, base_reg);
1705                 (void)reg_val;
1706
1707                 intel_ntb_reg_write(8, lmt_reg, bar_addr);
1708                 reg_val = intel_ntb_reg_read(8, lmt_reg);
1709                 (void)reg_val;
1710         }
1711 }
1712
1713 static void
1714 xeon_set_pbar_xlat(struct ntb_softc *ntb, uint64_t base_addr, enum ntb_bar idx)
1715 {
1716         struct ntb_pci_bar_info *bar;
1717
1718         bar = &ntb->bar_info[idx];
1719         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR) && idx >= NTB_B2B_BAR_2) {
1720                 intel_ntb_reg_write(4, bar->pbarxlat_off, base_addr);
1721                 base_addr = intel_ntb_reg_read(4, bar->pbarxlat_off);
1722         } else {
1723                 intel_ntb_reg_write(8, bar->pbarxlat_off, base_addr);
1724                 base_addr = intel_ntb_reg_read(8, bar->pbarxlat_off);
1725         }
1726         (void)base_addr;
1727 }
1728
1729 static int
1730 xeon_setup_b2b_mw(struct ntb_softc *ntb, const struct ntb_b2b_addr *addr,
1731     const struct ntb_b2b_addr *peer_addr)
1732 {
1733         struct ntb_pci_bar_info *b2b_bar;
1734         vm_size_t bar_size;
1735         uint64_t bar_addr;
1736         enum ntb_bar b2b_bar_num, i;
1737
1738         if (ntb->b2b_mw_idx == B2B_MW_DISABLED) {
1739                 b2b_bar = NULL;
1740                 b2b_bar_num = NTB_CONFIG_BAR;
1741                 ntb->b2b_off = 0;
1742         } else {
1743                 b2b_bar_num = intel_ntb_mw_to_bar(ntb, ntb->b2b_mw_idx);
1744                 KASSERT(b2b_bar_num > 0 && b2b_bar_num < NTB_MAX_BARS,
1745                     ("invalid b2b mw bar"));
1746
1747                 b2b_bar = &ntb->bar_info[b2b_bar_num];
1748                 bar_size = b2b_bar->size;
1749
1750                 if (ntb_b2b_mw_share != 0 &&
1751                     (bar_size >> 1) >= XEON_B2B_MIN_SIZE)
1752                         ntb->b2b_off = bar_size >> 1;
1753                 else if (bar_size >= XEON_B2B_MIN_SIZE) {
1754                         ntb->b2b_off = 0;
1755                 } else {
1756                         device_printf(ntb->device,
1757                             "B2B bar size is too small!\n");
1758                         return (EIO);
1759                 }
1760         }
1761
1762         /*
1763          * Reset the secondary bar sizes to match the primary bar sizes.
1764          * (Except, disable or halve the size of the B2B secondary bar.)
1765          */
1766         for (i = NTB_B2B_BAR_1; i < NTB_MAX_BARS; i++)
1767                 xeon_reset_sbar_size(ntb, i, b2b_bar_num);
1768
1769         bar_addr = 0;
1770         if (b2b_bar_num == NTB_CONFIG_BAR)
1771                 bar_addr = addr->bar0_addr;
1772         else if (b2b_bar_num == NTB_B2B_BAR_1)
1773                 bar_addr = addr->bar2_addr64;
1774         else if (b2b_bar_num == NTB_B2B_BAR_2 && !HAS_FEATURE(ntb, NTB_SPLIT_BAR))
1775                 bar_addr = addr->bar4_addr64;
1776         else if (b2b_bar_num == NTB_B2B_BAR_2)
1777                 bar_addr = addr->bar4_addr32;
1778         else if (b2b_bar_num == NTB_B2B_BAR_3)
1779                 bar_addr = addr->bar5_addr32;
1780         else
1781                 KASSERT(false, ("invalid bar"));
1782
1783         intel_ntb_reg_write(8, XEON_SBAR0BASE_OFFSET, bar_addr);
1784
1785         /*
1786          * Other SBARs are normally hit by the PBAR xlat, except for the b2b
1787          * register BAR.  The B2B BAR is either disabled above or configured
1788          * half-size.  It starts at PBAR xlat + offset.
1789          *
1790          * Also set up incoming BAR limits == base (zero length window).
1791          */
1792         xeon_set_sbar_base_and_limit(ntb, addr->bar2_addr64, NTB_B2B_BAR_1,
1793             b2b_bar_num);
1794         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
1795                 xeon_set_sbar_base_and_limit(ntb, addr->bar4_addr32,
1796                     NTB_B2B_BAR_2, b2b_bar_num);
1797                 xeon_set_sbar_base_and_limit(ntb, addr->bar5_addr32,
1798                     NTB_B2B_BAR_3, b2b_bar_num);
1799         } else
1800                 xeon_set_sbar_base_and_limit(ntb, addr->bar4_addr64,
1801                     NTB_B2B_BAR_2, b2b_bar_num);
1802
1803         /* Zero incoming translation addrs */
1804         intel_ntb_reg_write(8, XEON_SBAR2XLAT_OFFSET, 0);
1805         intel_ntb_reg_write(8, XEON_SBAR4XLAT_OFFSET, 0);
1806
1807         if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP)) {
1808                 uint32_t xlat_reg, lmt_reg;
1809                 enum ntb_bar bar_num;
1810
1811                 /*
1812                  * We point the chosen MSIX MW BAR xlat to remote LAPIC for
1813                  * workaround
1814                  */
1815                 bar_num = intel_ntb_mw_to_bar(ntb, ntb->msix_mw_idx);
1816                 bar_get_xlat_params(ntb, bar_num, NULL, &xlat_reg, &lmt_reg);
1817                 if (bar_is_64bit(ntb, bar_num)) {
1818                         intel_ntb_reg_write(8, xlat_reg, MSI_INTEL_ADDR_BASE);
1819                         ntb->msix_xlat = intel_ntb_reg_read(8, xlat_reg);
1820                         intel_ntb_reg_write(8, lmt_reg, 0);
1821                 } else {
1822                         intel_ntb_reg_write(4, xlat_reg, MSI_INTEL_ADDR_BASE);
1823                         ntb->msix_xlat = intel_ntb_reg_read(4, xlat_reg);
1824                         intel_ntb_reg_write(4, lmt_reg, 0);
1825                 }
1826
1827                 ntb->peer_lapic_bar =  &ntb->bar_info[bar_num];
1828         }
1829         (void)intel_ntb_reg_read(8, XEON_SBAR2XLAT_OFFSET);
1830         (void)intel_ntb_reg_read(8, XEON_SBAR4XLAT_OFFSET);
1831
1832         /* Zero outgoing translation limits (whole bar size windows) */
1833         intel_ntb_reg_write(8, XEON_PBAR2LMT_OFFSET, 0);
1834         intel_ntb_reg_write(8, XEON_PBAR4LMT_OFFSET, 0);
1835
1836         /* Set outgoing translation offsets */
1837         xeon_set_pbar_xlat(ntb, peer_addr->bar2_addr64, NTB_B2B_BAR_1);
1838         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
1839                 xeon_set_pbar_xlat(ntb, peer_addr->bar4_addr32, NTB_B2B_BAR_2);
1840                 xeon_set_pbar_xlat(ntb, peer_addr->bar5_addr32, NTB_B2B_BAR_3);
1841         } else
1842                 xeon_set_pbar_xlat(ntb, peer_addr->bar4_addr64, NTB_B2B_BAR_2);
1843
1844         /* Set the translation offset for B2B registers */
1845         bar_addr = 0;
1846         if (b2b_bar_num == NTB_CONFIG_BAR)
1847                 bar_addr = peer_addr->bar0_addr;
1848         else if (b2b_bar_num == NTB_B2B_BAR_1)
1849                 bar_addr = peer_addr->bar2_addr64;
1850         else if (b2b_bar_num == NTB_B2B_BAR_2 && !HAS_FEATURE(ntb, NTB_SPLIT_BAR))
1851                 bar_addr = peer_addr->bar4_addr64;
1852         else if (b2b_bar_num == NTB_B2B_BAR_2)
1853                 bar_addr = peer_addr->bar4_addr32;
1854         else if (b2b_bar_num == NTB_B2B_BAR_3)
1855                 bar_addr = peer_addr->bar5_addr32;
1856         else
1857                 KASSERT(false, ("invalid bar"));
1858
1859         /*
1860          * B2B_XLAT_OFFSET is a 64-bit register but can only be written 32 bits
1861          * at a time.
1862          */
1863         intel_ntb_reg_write(4, XEON_B2B_XLAT_OFFSETL, bar_addr & 0xffffffff);
1864         intel_ntb_reg_write(4, XEON_B2B_XLAT_OFFSETU, bar_addr >> 32);
1865         return (0);
1866 }
1867
1868 static inline bool
1869 _xeon_link_is_up(struct ntb_softc *ntb)
1870 {
1871
1872         if (ntb->conn_type == NTB_CONN_TRANSPARENT)
1873                 return (true);
1874         return ((ntb->lnk_sta & NTB_LINK_STATUS_ACTIVE) != 0);
1875 }
1876
1877 static inline bool
1878 link_is_up(struct ntb_softc *ntb)
1879 {
1880
1881         if (ntb->type == NTB_XEON)
1882                 return (_xeon_link_is_up(ntb) && (ntb->peer_msix_good ||
1883                     !HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP)));
1884
1885         KASSERT(ntb->type == NTB_ATOM, ("ntb type"));
1886         return ((ntb->ntb_ctl & ATOM_CNTL_LINK_DOWN) == 0);
1887 }
1888
1889 static inline bool
1890 atom_link_is_err(struct ntb_softc *ntb)
1891 {
1892         uint32_t status;
1893
1894         KASSERT(ntb->type == NTB_ATOM, ("ntb type"));
1895
1896         status = intel_ntb_reg_read(4, ATOM_LTSSMSTATEJMP_OFFSET);
1897         if ((status & ATOM_LTSSMSTATEJMP_FORCEDETECT) != 0)
1898                 return (true);
1899
1900         status = intel_ntb_reg_read(4, ATOM_IBSTERRRCRVSTS0_OFFSET);
1901         return ((status & ATOM_IBIST_ERR_OFLOW) != 0);
1902 }
1903
1904 /* Atom does not have link status interrupt, poll on that platform */
1905 static void
1906 atom_link_hb(void *arg)
1907 {
1908         struct ntb_softc *ntb = arg;
1909         sbintime_t timo, poll_ts;
1910
1911         timo = NTB_HB_TIMEOUT * hz;
1912         poll_ts = ntb->last_ts + timo;
1913
1914         /*
1915          * Delay polling the link status if an interrupt was received, unless
1916          * the cached link status says the link is down.
1917          */
1918         if ((sbintime_t)ticks - poll_ts < 0 && link_is_up(ntb)) {
1919                 timo = poll_ts - ticks;
1920                 goto out;
1921         }
1922
1923         if (intel_ntb_poll_link(ntb))
1924                 ntb_link_event(ntb->device);
1925
1926         if (!link_is_up(ntb) && atom_link_is_err(ntb)) {
1927                 /* Link is down with error, proceed with recovery */
1928                 callout_reset(&ntb->lr_timer, 0, recover_atom_link, ntb);
1929                 return;
1930         }
1931
1932 out:
1933         callout_reset(&ntb->heartbeat_timer, timo, atom_link_hb, ntb);
1934 }
1935
1936 static void
1937 atom_perform_link_restart(struct ntb_softc *ntb)
1938 {
1939         uint32_t status;
1940
1941         /* Driver resets the NTB ModPhy lanes - magic! */
1942         intel_ntb_reg_write(1, ATOM_MODPHY_PCSREG6, 0xe0);
1943         intel_ntb_reg_write(1, ATOM_MODPHY_PCSREG4, 0x40);
1944         intel_ntb_reg_write(1, ATOM_MODPHY_PCSREG4, 0x60);
1945         intel_ntb_reg_write(1, ATOM_MODPHY_PCSREG6, 0x60);
1946
1947         /* Driver waits 100ms to allow the NTB ModPhy to settle */
1948         pause("ModPhy", hz / 10);
1949
1950         /* Clear AER Errors, write to clear */
1951         status = intel_ntb_reg_read(4, ATOM_ERRCORSTS_OFFSET);
1952         status &= PCIM_AER_COR_REPLAY_ROLLOVER;
1953         intel_ntb_reg_write(4, ATOM_ERRCORSTS_OFFSET, status);
1954
1955         /* Clear unexpected electrical idle event in LTSSM, write to clear */
1956         status = intel_ntb_reg_read(4, ATOM_LTSSMERRSTS0_OFFSET);
1957         status |= ATOM_LTSSMERRSTS0_UNEXPECTEDEI;
1958         intel_ntb_reg_write(4, ATOM_LTSSMERRSTS0_OFFSET, status);
1959
1960         /* Clear DeSkew Buffer error, write to clear */
1961         status = intel_ntb_reg_read(4, ATOM_DESKEWSTS_OFFSET);
1962         status |= ATOM_DESKEWSTS_DBERR;
1963         intel_ntb_reg_write(4, ATOM_DESKEWSTS_OFFSET, status);
1964
1965         status = intel_ntb_reg_read(4, ATOM_IBSTERRRCRVSTS0_OFFSET);
1966         status &= ATOM_IBIST_ERR_OFLOW;
1967         intel_ntb_reg_write(4, ATOM_IBSTERRRCRVSTS0_OFFSET, status);
1968
1969         /* Releases the NTB state machine to allow the link to retrain */
1970         status = intel_ntb_reg_read(4, ATOM_LTSSMSTATEJMP_OFFSET);
1971         status &= ~ATOM_LTSSMSTATEJMP_FORCEDETECT;
1972         intel_ntb_reg_write(4, ATOM_LTSSMSTATEJMP_OFFSET, status);
1973 }
1974
1975 static int
1976 intel_ntb_link_enable(device_t dev, enum ntb_speed speed __unused,
1977     enum ntb_width width __unused)
1978 {
1979         struct ntb_softc *ntb = device_get_softc(dev);
1980         uint32_t cntl;
1981
1982         intel_ntb_printf(2, "%s\n", __func__);
1983
1984         if (ntb->type == NTB_ATOM) {
1985                 pci_write_config(ntb->device, NTB_PPD_OFFSET,
1986                     ntb->ppd | ATOM_PPD_INIT_LINK, 4);
1987                 return (0);
1988         }
1989
1990         if (ntb->conn_type == NTB_CONN_TRANSPARENT) {
1991                 ntb_link_event(dev);
1992                 return (0);
1993         }
1994
1995         cntl = intel_ntb_reg_read(4, ntb->reg->ntb_ctl);
1996         cntl &= ~(NTB_CNTL_LINK_DISABLE | NTB_CNTL_CFG_LOCK);
1997         cntl |= NTB_CNTL_P2S_BAR23_SNOOP | NTB_CNTL_S2P_BAR23_SNOOP;
1998         cntl |= NTB_CNTL_P2S_BAR4_SNOOP | NTB_CNTL_S2P_BAR4_SNOOP;
1999         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR))
2000                 cntl |= NTB_CNTL_P2S_BAR5_SNOOP | NTB_CNTL_S2P_BAR5_SNOOP;
2001         intel_ntb_reg_write(4, ntb->reg->ntb_ctl, cntl);
2002         return (0);
2003 }
2004
2005 static int
2006 intel_ntb_link_disable(device_t dev)
2007 {
2008         struct ntb_softc *ntb = device_get_softc(dev);
2009         uint32_t cntl;
2010
2011         intel_ntb_printf(2, "%s\n", __func__);
2012
2013         if (ntb->conn_type == NTB_CONN_TRANSPARENT) {
2014                 ntb_link_event(dev);
2015                 return (0);
2016         }
2017
2018         cntl = intel_ntb_reg_read(4, ntb->reg->ntb_ctl);
2019         cntl &= ~(NTB_CNTL_P2S_BAR23_SNOOP | NTB_CNTL_S2P_BAR23_SNOOP);
2020         cntl &= ~(NTB_CNTL_P2S_BAR4_SNOOP | NTB_CNTL_S2P_BAR4_SNOOP);
2021         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR))
2022                 cntl &= ~(NTB_CNTL_P2S_BAR5_SNOOP | NTB_CNTL_S2P_BAR5_SNOOP);
2023         cntl |= NTB_CNTL_LINK_DISABLE | NTB_CNTL_CFG_LOCK;
2024         intel_ntb_reg_write(4, ntb->reg->ntb_ctl, cntl);
2025         return (0);
2026 }
2027
2028 static bool
2029 intel_ntb_link_enabled(device_t dev)
2030 {
2031         struct ntb_softc *ntb = device_get_softc(dev);
2032         uint32_t cntl;
2033
2034         if (ntb->type == NTB_ATOM) {
2035                 cntl = pci_read_config(ntb->device, NTB_PPD_OFFSET, 4);
2036                 return ((cntl & ATOM_PPD_INIT_LINK) != 0);
2037         }
2038
2039         if (ntb->conn_type == NTB_CONN_TRANSPARENT)
2040                 return (true);
2041
2042         cntl = intel_ntb_reg_read(4, ntb->reg->ntb_ctl);
2043         return ((cntl & NTB_CNTL_LINK_DISABLE) == 0);
2044 }
2045
2046 static void
2047 recover_atom_link(void *arg)
2048 {
2049         struct ntb_softc *ntb = arg;
2050         unsigned speed, width, oldspeed, oldwidth;
2051         uint32_t status32;
2052
2053         atom_perform_link_restart(ntb);
2054
2055         /*
2056          * There is a potential race between the 2 NTB devices recovering at
2057          * the same time.  If the times are the same, the link will not recover
2058          * and the driver will be stuck in this loop forever.  Add a random
2059          * interval to the recovery time to prevent this race.
2060          */
2061         status32 = arc4random() % ATOM_LINK_RECOVERY_TIME;
2062         pause("Link", (ATOM_LINK_RECOVERY_TIME + status32) * hz / 1000);
2063
2064         if (atom_link_is_err(ntb))
2065                 goto retry;
2066
2067         status32 = intel_ntb_reg_read(4, ntb->reg->ntb_ctl);
2068         if ((status32 & ATOM_CNTL_LINK_DOWN) != 0)
2069                 goto out;
2070
2071         status32 = intel_ntb_reg_read(4, ntb->reg->lnk_sta);
2072         width = NTB_LNK_STA_WIDTH(status32);
2073         speed = status32 & NTB_LINK_SPEED_MASK;
2074
2075         oldwidth = NTB_LNK_STA_WIDTH(ntb->lnk_sta);
2076         oldspeed = ntb->lnk_sta & NTB_LINK_SPEED_MASK;
2077         if (oldwidth != width || oldspeed != speed)
2078                 goto retry;
2079
2080 out:
2081         callout_reset(&ntb->heartbeat_timer, NTB_HB_TIMEOUT * hz, atom_link_hb,
2082             ntb);
2083         return;
2084
2085 retry:
2086         callout_reset(&ntb->lr_timer, NTB_HB_TIMEOUT * hz, recover_atom_link,
2087             ntb);
2088 }
2089
2090 /*
2091  * Polls the HW link status register(s); returns true if something has changed.
2092  */
2093 static bool
2094 intel_ntb_poll_link(struct ntb_softc *ntb)
2095 {
2096         uint32_t ntb_cntl;
2097         uint16_t reg_val;
2098
2099         if (ntb->type == NTB_ATOM) {
2100                 ntb_cntl = intel_ntb_reg_read(4, ntb->reg->ntb_ctl);
2101                 if (ntb_cntl == ntb->ntb_ctl)
2102                         return (false);
2103
2104                 ntb->ntb_ctl = ntb_cntl;
2105                 ntb->lnk_sta = intel_ntb_reg_read(4, ntb->reg->lnk_sta);
2106         } else {
2107                 db_iowrite_raw(ntb, ntb->self_reg->db_bell, ntb->db_link_mask);
2108
2109                 reg_val = pci_read_config(ntb->device, ntb->reg->lnk_sta, 2);
2110                 if (reg_val == ntb->lnk_sta)
2111                         return (false);
2112
2113                 ntb->lnk_sta = reg_val;
2114
2115                 if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP)) {
2116                         if (_xeon_link_is_up(ntb)) {
2117                                 if (!ntb->peer_msix_good) {
2118                                         callout_reset(&ntb->peer_msix_work, 0,
2119                                             intel_ntb_exchange_msix, ntb);
2120                                         return (false);
2121                                 }
2122                         } else {
2123                                 ntb->peer_msix_good = false;
2124                                 ntb->peer_msix_done = false;
2125                         }
2126                 }
2127         }
2128         return (true);
2129 }
2130
2131 static inline enum ntb_speed
2132 intel_ntb_link_sta_speed(struct ntb_softc *ntb)
2133 {
2134
2135         if (!link_is_up(ntb))
2136                 return (NTB_SPEED_NONE);
2137         return (ntb->lnk_sta & NTB_LINK_SPEED_MASK);
2138 }
2139
2140 static inline enum ntb_width
2141 intel_ntb_link_sta_width(struct ntb_softc *ntb)
2142 {
2143
2144         if (!link_is_up(ntb))
2145                 return (NTB_WIDTH_NONE);
2146         return (NTB_LNK_STA_WIDTH(ntb->lnk_sta));
2147 }
2148
2149 SYSCTL_NODE(_hw_ntb, OID_AUTO, debug_info, CTLFLAG_RW, 0,
2150     "Driver state, statistics, and HW registers");
2151
2152 #define NTB_REGSZ_MASK  (3ul << 30)
2153 #define NTB_REG_64      (1ul << 30)
2154 #define NTB_REG_32      (2ul << 30)
2155 #define NTB_REG_16      (3ul << 30)
2156 #define NTB_REG_8       (0ul << 30)
2157
2158 #define NTB_DB_READ     (1ul << 29)
2159 #define NTB_PCI_REG     (1ul << 28)
2160 #define NTB_REGFLAGS_MASK       (NTB_REGSZ_MASK | NTB_DB_READ | NTB_PCI_REG)
2161
2162 static void
2163 intel_ntb_sysctl_init(struct ntb_softc *ntb)
2164 {
2165         struct sysctl_oid_list *globals, *tree_par, *regpar, *statpar, *errpar;
2166         struct sysctl_ctx_list *ctx;
2167         struct sysctl_oid *tree, *tmptree;
2168
2169         ctx = device_get_sysctl_ctx(ntb->device);
2170         globals = SYSCTL_CHILDREN(device_get_sysctl_tree(ntb->device));
2171
2172         SYSCTL_ADD_PROC(ctx, globals, OID_AUTO, "link_status",
2173             CTLFLAG_RD | CTLTYPE_STRING, ntb, 0,
2174             sysctl_handle_link_status_human, "A",
2175             "Link status (human readable)");
2176         SYSCTL_ADD_PROC(ctx, globals, OID_AUTO, "active",
2177             CTLFLAG_RD | CTLTYPE_UINT, ntb, 0, sysctl_handle_link_status,
2178             "IU", "Link status (1=active, 0=inactive)");
2179         SYSCTL_ADD_PROC(ctx, globals, OID_AUTO, "admin_up",
2180             CTLFLAG_RW | CTLTYPE_UINT, ntb, 0, sysctl_handle_link_admin,
2181             "IU", "Set/get interface status (1=UP, 0=DOWN)");
2182
2183         tree = SYSCTL_ADD_NODE(ctx, globals, OID_AUTO, "debug_info",
2184             CTLFLAG_RD, NULL, "Driver state, statistics, and HW registers");
2185         tree_par = SYSCTL_CHILDREN(tree);
2186
2187         SYSCTL_ADD_UINT(ctx, tree_par, OID_AUTO, "conn_type", CTLFLAG_RD,
2188             &ntb->conn_type, 0, "0 - Transparent; 1 - B2B; 2 - Root Port");
2189         SYSCTL_ADD_UINT(ctx, tree_par, OID_AUTO, "dev_type", CTLFLAG_RD,
2190             &ntb->dev_type, 0, "0 - USD; 1 - DSD");
2191         SYSCTL_ADD_UINT(ctx, tree_par, OID_AUTO, "ppd", CTLFLAG_RD,
2192             &ntb->ppd, 0, "Raw PPD register (cached)");
2193
2194         if (ntb->b2b_mw_idx != B2B_MW_DISABLED) {
2195                 SYSCTL_ADD_U8(ctx, tree_par, OID_AUTO, "b2b_idx", CTLFLAG_RD,
2196                     &ntb->b2b_mw_idx, 0,
2197                     "Index of the MW used for B2B remote register access");
2198                 SYSCTL_ADD_UQUAD(ctx, tree_par, OID_AUTO, "b2b_off",
2199                     CTLFLAG_RD, &ntb->b2b_off,
2200                     "If non-zero, offset of B2B register region in shared MW");
2201         }
2202
2203         SYSCTL_ADD_PROC(ctx, tree_par, OID_AUTO, "features",
2204             CTLFLAG_RD | CTLTYPE_STRING, ntb, 0, sysctl_handle_features, "A",
2205             "Features/errata of this NTB device");
2206
2207         SYSCTL_ADD_UINT(ctx, tree_par, OID_AUTO, "ntb_ctl", CTLFLAG_RD,
2208             __DEVOLATILE(uint32_t *, &ntb->ntb_ctl), 0,
2209             "NTB CTL register (cached)");
2210         SYSCTL_ADD_UINT(ctx, tree_par, OID_AUTO, "lnk_sta", CTLFLAG_RD,
2211             __DEVOLATILE(uint32_t *, &ntb->lnk_sta), 0,
2212             "LNK STA register (cached)");
2213
2214         SYSCTL_ADD_U8(ctx, tree_par, OID_AUTO, "mw_count", CTLFLAG_RD,
2215             &ntb->mw_count, 0, "MW count");
2216         SYSCTL_ADD_U8(ctx, tree_par, OID_AUTO, "spad_count", CTLFLAG_RD,
2217             &ntb->spad_count, 0, "Scratchpad count");
2218         SYSCTL_ADD_U8(ctx, tree_par, OID_AUTO, "db_count", CTLFLAG_RD,
2219             &ntb->db_count, 0, "Doorbell count");
2220         SYSCTL_ADD_U8(ctx, tree_par, OID_AUTO, "db_vec_count", CTLFLAG_RD,
2221             &ntb->db_vec_count, 0, "Doorbell vector count");
2222         SYSCTL_ADD_U8(ctx, tree_par, OID_AUTO, "db_vec_shift", CTLFLAG_RD,
2223             &ntb->db_vec_shift, 0, "Doorbell vector shift");
2224
2225         SYSCTL_ADD_UQUAD(ctx, tree_par, OID_AUTO, "db_valid_mask", CTLFLAG_RD,
2226             &ntb->db_valid_mask, "Doorbell valid mask");
2227         SYSCTL_ADD_UQUAD(ctx, tree_par, OID_AUTO, "db_link_mask", CTLFLAG_RD,
2228             &ntb->db_link_mask, "Doorbell link mask");
2229         SYSCTL_ADD_UQUAD(ctx, tree_par, OID_AUTO, "db_mask", CTLFLAG_RD,
2230             &ntb->db_mask, "Doorbell mask (cached)");
2231
2232         tmptree = SYSCTL_ADD_NODE(ctx, tree_par, OID_AUTO, "registers",
2233             CTLFLAG_RD, NULL, "Raw HW registers (big-endian)");
2234         regpar = SYSCTL_CHILDREN(tmptree);
2235
2236         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "ntbcntl",
2237             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb, NTB_REG_32 |
2238             ntb->reg->ntb_ctl, sysctl_handle_register, "IU",
2239             "NTB Control register");
2240         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "lnkcap",
2241             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb, NTB_REG_32 |
2242             0x19c, sysctl_handle_register, "IU",
2243             "NTB Link Capabilities");
2244         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "lnkcon",
2245             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb, NTB_REG_32 |
2246             0x1a0, sysctl_handle_register, "IU",
2247             "NTB Link Control register");
2248
2249         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "db_mask",
2250             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2251             NTB_REG_64 | NTB_DB_READ | ntb->self_reg->db_mask,
2252             sysctl_handle_register, "QU", "Doorbell mask register");
2253         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "db_bell",
2254             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2255             NTB_REG_64 | NTB_DB_READ | ntb->self_reg->db_bell,
2256             sysctl_handle_register, "QU", "Doorbell register");
2257
2258         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_xlat23",
2259             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2260             NTB_REG_64 | ntb->xlat_reg->bar2_xlat,
2261             sysctl_handle_register, "QU", "Incoming XLAT23 register");
2262         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
2263                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_xlat4",
2264                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2265                     NTB_REG_32 | ntb->xlat_reg->bar4_xlat,
2266                     sysctl_handle_register, "IU", "Incoming XLAT4 register");
2267                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_xlat5",
2268                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2269                     NTB_REG_32 | ntb->xlat_reg->bar5_xlat,
2270                     sysctl_handle_register, "IU", "Incoming XLAT5 register");
2271         } else {
2272                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_xlat45",
2273                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2274                     NTB_REG_64 | ntb->xlat_reg->bar4_xlat,
2275                     sysctl_handle_register, "QU", "Incoming XLAT45 register");
2276         }
2277
2278         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_lmt23",
2279             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2280             NTB_REG_64 | ntb->xlat_reg->bar2_limit,
2281             sysctl_handle_register, "QU", "Incoming LMT23 register");
2282         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
2283                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_lmt4",
2284                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2285                     NTB_REG_32 | ntb->xlat_reg->bar4_limit,
2286                     sysctl_handle_register, "IU", "Incoming LMT4 register");
2287                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_lmt5",
2288                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2289                     NTB_REG_32 | ntb->xlat_reg->bar5_limit,
2290                     sysctl_handle_register, "IU", "Incoming LMT5 register");
2291         } else {
2292                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "incoming_lmt45",
2293                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2294                     NTB_REG_64 | ntb->xlat_reg->bar4_limit,
2295                     sysctl_handle_register, "QU", "Incoming LMT45 register");
2296         }
2297
2298         if (ntb->type == NTB_ATOM)
2299                 return;
2300
2301         tmptree = SYSCTL_ADD_NODE(ctx, regpar, OID_AUTO, "xeon_stats",
2302             CTLFLAG_RD, NULL, "Xeon HW statistics");
2303         statpar = SYSCTL_CHILDREN(tmptree);
2304         SYSCTL_ADD_PROC(ctx, statpar, OID_AUTO, "upstream_mem_miss",
2305             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2306             NTB_REG_16 | XEON_USMEMMISS_OFFSET,
2307             sysctl_handle_register, "SU", "Upstream Memory Miss");
2308
2309         tmptree = SYSCTL_ADD_NODE(ctx, regpar, OID_AUTO, "xeon_hw_err",
2310             CTLFLAG_RD, NULL, "Xeon HW errors");
2311         errpar = SYSCTL_CHILDREN(tmptree);
2312
2313         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "ppd",
2314             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2315             NTB_REG_8 | NTB_PCI_REG | NTB_PPD_OFFSET,
2316             sysctl_handle_register, "CU", "PPD");
2317
2318         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "pbar23_sz",
2319             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2320             NTB_REG_8 | NTB_PCI_REG | XEON_PBAR23SZ_OFFSET,
2321             sysctl_handle_register, "CU", "PBAR23 SZ (log2)");
2322         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "pbar4_sz",
2323             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2324             NTB_REG_8 | NTB_PCI_REG | XEON_PBAR4SZ_OFFSET,
2325             sysctl_handle_register, "CU", "PBAR4 SZ (log2)");
2326         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "pbar5_sz",
2327             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2328             NTB_REG_8 | NTB_PCI_REG | XEON_PBAR5SZ_OFFSET,
2329             sysctl_handle_register, "CU", "PBAR5 SZ (log2)");
2330
2331         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar23_sz",
2332             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2333             NTB_REG_8 | NTB_PCI_REG | XEON_SBAR23SZ_OFFSET,
2334             sysctl_handle_register, "CU", "SBAR23 SZ (log2)");
2335         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar4_sz",
2336             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2337             NTB_REG_8 | NTB_PCI_REG | XEON_SBAR4SZ_OFFSET,
2338             sysctl_handle_register, "CU", "SBAR4 SZ (log2)");
2339         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar5_sz",
2340             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2341             NTB_REG_8 | NTB_PCI_REG | XEON_SBAR5SZ_OFFSET,
2342             sysctl_handle_register, "CU", "SBAR5 SZ (log2)");
2343
2344         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "devsts",
2345             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2346             NTB_REG_16 | NTB_PCI_REG | XEON_DEVSTS_OFFSET,
2347             sysctl_handle_register, "SU", "DEVSTS");
2348         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "lnksts",
2349             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2350             NTB_REG_16 | NTB_PCI_REG | XEON_LINK_STATUS_OFFSET,
2351             sysctl_handle_register, "SU", "LNKSTS");
2352         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "slnksts",
2353             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2354             NTB_REG_16 | NTB_PCI_REG | XEON_SLINK_STATUS_OFFSET,
2355             sysctl_handle_register, "SU", "SLNKSTS");
2356
2357         SYSCTL_ADD_PROC(ctx, errpar, OID_AUTO, "uncerrsts",
2358             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2359             NTB_REG_32 | NTB_PCI_REG | XEON_UNCERRSTS_OFFSET,
2360             sysctl_handle_register, "IU", "UNCERRSTS");
2361         SYSCTL_ADD_PROC(ctx, errpar, OID_AUTO, "corerrsts",
2362             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2363             NTB_REG_32 | NTB_PCI_REG | XEON_CORERRSTS_OFFSET,
2364             sysctl_handle_register, "IU", "CORERRSTS");
2365
2366         if (ntb->conn_type != NTB_CONN_B2B)
2367                 return;
2368
2369         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_xlat23",
2370             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2371             NTB_REG_64 | ntb->bar_info[NTB_B2B_BAR_1].pbarxlat_off,
2372             sysctl_handle_register, "QU", "Outgoing XLAT23 register");
2373         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
2374                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_xlat4",
2375                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2376                     NTB_REG_32 | ntb->bar_info[NTB_B2B_BAR_2].pbarxlat_off,
2377                     sysctl_handle_register, "IU", "Outgoing XLAT4 register");
2378                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_xlat5",
2379                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2380                     NTB_REG_32 | ntb->bar_info[NTB_B2B_BAR_3].pbarxlat_off,
2381                     sysctl_handle_register, "IU", "Outgoing XLAT5 register");
2382         } else {
2383                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_xlat45",
2384                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2385                     NTB_REG_64 | ntb->bar_info[NTB_B2B_BAR_2].pbarxlat_off,
2386                     sysctl_handle_register, "QU", "Outgoing XLAT45 register");
2387         }
2388
2389         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_lmt23",
2390             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2391             NTB_REG_64 | XEON_PBAR2LMT_OFFSET,
2392             sysctl_handle_register, "QU", "Outgoing LMT23 register");
2393         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
2394                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_lmt4",
2395                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2396                     NTB_REG_32 | XEON_PBAR4LMT_OFFSET,
2397                     sysctl_handle_register, "IU", "Outgoing LMT4 register");
2398                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_lmt5",
2399                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2400                     NTB_REG_32 | XEON_PBAR5LMT_OFFSET,
2401                     sysctl_handle_register, "IU", "Outgoing LMT5 register");
2402         } else {
2403                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "outgoing_lmt45",
2404                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2405                     NTB_REG_64 | XEON_PBAR4LMT_OFFSET,
2406                     sysctl_handle_register, "QU", "Outgoing LMT45 register");
2407         }
2408
2409         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar01_base",
2410             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2411             NTB_REG_64 | ntb->xlat_reg->bar0_base,
2412             sysctl_handle_register, "QU", "Secondary BAR01 base register");
2413         SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar23_base",
2414             CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2415             NTB_REG_64 | ntb->xlat_reg->bar2_base,
2416             sysctl_handle_register, "QU", "Secondary BAR23 base register");
2417         if (HAS_FEATURE(ntb, NTB_SPLIT_BAR)) {
2418                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar4_base",
2419                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2420                     NTB_REG_32 | ntb->xlat_reg->bar4_base,
2421                     sysctl_handle_register, "IU",
2422                     "Secondary BAR4 base register");
2423                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar5_base",
2424                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2425                     NTB_REG_32 | ntb->xlat_reg->bar5_base,
2426                     sysctl_handle_register, "IU",
2427                     "Secondary BAR5 base register");
2428         } else {
2429                 SYSCTL_ADD_PROC(ctx, regpar, OID_AUTO, "sbar45_base",
2430                     CTLFLAG_RD | CTLTYPE_OPAQUE, ntb,
2431                     NTB_REG_64 | ntb->xlat_reg->bar4_base,
2432                     sysctl_handle_register, "QU",
2433                     "Secondary BAR45 base register");
2434         }
2435 }
2436
2437 static int
2438 sysctl_handle_features(SYSCTL_HANDLER_ARGS)
2439 {
2440         struct ntb_softc *ntb = arg1;
2441         struct sbuf sb;
2442         int error;
2443
2444         sbuf_new_for_sysctl(&sb, NULL, 256, req);
2445
2446         sbuf_printf(&sb, "%b", ntb->features, NTB_FEATURES_STR);
2447         error = sbuf_finish(&sb);
2448         sbuf_delete(&sb);
2449
2450         if (error || !req->newptr)
2451                 return (error);
2452         return (EINVAL);
2453 }
2454
2455 static int
2456 sysctl_handle_link_admin(SYSCTL_HANDLER_ARGS)
2457 {
2458         struct ntb_softc *ntb = arg1;
2459         unsigned old, new;
2460         int error;
2461
2462         old = intel_ntb_link_enabled(ntb->device);
2463
2464         error = SYSCTL_OUT(req, &old, sizeof(old));
2465         if (error != 0 || req->newptr == NULL)
2466                 return (error);
2467
2468         error = SYSCTL_IN(req, &new, sizeof(new));
2469         if (error != 0)
2470                 return (error);
2471
2472         intel_ntb_printf(0, "Admin set interface state to '%sabled'\n",
2473             (new != 0)? "en" : "dis");
2474
2475         if (new != 0)
2476                 error = intel_ntb_link_enable(ntb->device, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
2477         else
2478                 error = intel_ntb_link_disable(ntb->device);
2479         return (error);
2480 }
2481
2482 static int
2483 sysctl_handle_link_status_human(SYSCTL_HANDLER_ARGS)
2484 {
2485         struct ntb_softc *ntb = arg1;
2486         struct sbuf sb;
2487         enum ntb_speed speed;
2488         enum ntb_width width;
2489         int error;
2490
2491         sbuf_new_for_sysctl(&sb, NULL, 32, req);
2492
2493         if (intel_ntb_link_is_up(ntb->device, &speed, &width))
2494                 sbuf_printf(&sb, "up / PCIe Gen %u / Width x%u",
2495                     (unsigned)speed, (unsigned)width);
2496         else
2497                 sbuf_printf(&sb, "down");
2498
2499         error = sbuf_finish(&sb);
2500         sbuf_delete(&sb);
2501
2502         if (error || !req->newptr)
2503                 return (error);
2504         return (EINVAL);
2505 }
2506
2507 static int
2508 sysctl_handle_link_status(SYSCTL_HANDLER_ARGS)
2509 {
2510         struct ntb_softc *ntb = arg1;
2511         unsigned res;
2512         int error;
2513
2514         res = intel_ntb_link_is_up(ntb->device, NULL, NULL);
2515
2516         error = SYSCTL_OUT(req, &res, sizeof(res));
2517         if (error || !req->newptr)
2518                 return (error);
2519         return (EINVAL);
2520 }
2521
2522 static int
2523 sysctl_handle_register(SYSCTL_HANDLER_ARGS)
2524 {
2525         struct ntb_softc *ntb;
2526         const void *outp;
2527         uintptr_t sz;
2528         uint64_t umv;
2529         char be[sizeof(umv)];
2530         size_t outsz;
2531         uint32_t reg;
2532         bool db, pci;
2533         int error;
2534
2535         ntb = arg1;
2536         reg = arg2 & ~NTB_REGFLAGS_MASK;
2537         sz = arg2 & NTB_REGSZ_MASK;
2538         db = (arg2 & NTB_DB_READ) != 0;
2539         pci = (arg2 & NTB_PCI_REG) != 0;
2540
2541         KASSERT(!(db && pci), ("bogus"));
2542
2543         if (db) {
2544                 KASSERT(sz == NTB_REG_64, ("bogus"));
2545                 umv = db_ioread(ntb, reg);
2546                 outsz = sizeof(uint64_t);
2547         } else {
2548                 switch (sz) {
2549                 case NTB_REG_64:
2550                         if (pci)
2551                                 umv = pci_read_config(ntb->device, reg, 8);
2552                         else
2553                                 umv = intel_ntb_reg_read(8, reg);
2554                         outsz = sizeof(uint64_t);
2555                         break;
2556                 case NTB_REG_32:
2557                         if (pci)
2558                                 umv = pci_read_config(ntb->device, reg, 4);
2559                         else
2560                                 umv = intel_ntb_reg_read(4, reg);
2561                         outsz = sizeof(uint32_t);
2562                         break;
2563                 case NTB_REG_16:
2564                         if (pci)
2565                                 umv = pci_read_config(ntb->device, reg, 2);
2566                         else
2567                                 umv = intel_ntb_reg_read(2, reg);
2568                         outsz = sizeof(uint16_t);
2569                         break;
2570                 case NTB_REG_8:
2571                         if (pci)
2572                                 umv = pci_read_config(ntb->device, reg, 1);
2573                         else
2574                                 umv = intel_ntb_reg_read(1, reg);
2575                         outsz = sizeof(uint8_t);
2576                         break;
2577                 default:
2578                         panic("bogus");
2579                         break;
2580                 }
2581         }
2582
2583         /* Encode bigendian so that sysctl -x is legible. */
2584         be64enc(be, umv);
2585         outp = ((char *)be) + sizeof(umv) - outsz;
2586
2587         error = SYSCTL_OUT(req, outp, outsz);
2588         if (error || !req->newptr)
2589                 return (error);
2590         return (EINVAL);
2591 }
2592
2593 static unsigned
2594 intel_ntb_user_mw_to_idx(struct ntb_softc *ntb, unsigned uidx)
2595 {
2596
2597         if ((ntb->b2b_mw_idx != B2B_MW_DISABLED && ntb->b2b_off == 0 &&
2598             uidx >= ntb->b2b_mw_idx) ||
2599             (ntb->msix_mw_idx != B2B_MW_DISABLED && uidx >= ntb->msix_mw_idx))
2600                 uidx++;
2601         if ((ntb->b2b_mw_idx != B2B_MW_DISABLED && ntb->b2b_off == 0 &&
2602             uidx >= ntb->b2b_mw_idx) &&
2603             (ntb->msix_mw_idx != B2B_MW_DISABLED && uidx >= ntb->msix_mw_idx))
2604                 uidx++;
2605         return (uidx);
2606 }
2607
2608 #ifndef EARLY_AP_STARTUP
2609 static int msix_ready;
2610
2611 static void
2612 intel_ntb_msix_ready(void *arg __unused)
2613 {
2614
2615         msix_ready = 1;
2616 }
2617 SYSINIT(intel_ntb_msix_ready, SI_SUB_SMP, SI_ORDER_ANY,
2618     intel_ntb_msix_ready, NULL);
2619 #endif
2620
2621 static void
2622 intel_ntb_exchange_msix(void *ctx)
2623 {
2624         struct ntb_softc *ntb;
2625         uint32_t val;
2626         unsigned i;
2627
2628         ntb = ctx;
2629
2630         if (ntb->peer_msix_good)
2631                 goto msix_good;
2632         if (ntb->peer_msix_done)
2633                 goto msix_done;
2634
2635 #ifndef EARLY_AP_STARTUP
2636         /* Block MSIX negotiation until SMP started and IRQ reshuffled. */
2637         if (!msix_ready)
2638                 goto reschedule;
2639 #endif
2640
2641         intel_ntb_get_msix_info(ntb);
2642         for (i = 0; i < XEON_NONLINK_DB_MSIX_BITS; i++) {
2643                 intel_ntb_peer_spad_write(ntb->device, NTB_MSIX_DATA0 + i,
2644                     ntb->msix_data[i].nmd_data);
2645                 intel_ntb_peer_spad_write(ntb->device, NTB_MSIX_OFS0 + i,
2646                     ntb->msix_data[i].nmd_ofs - ntb->msix_xlat);
2647         }
2648         intel_ntb_peer_spad_write(ntb->device, NTB_MSIX_GUARD, NTB_MSIX_VER_GUARD);
2649
2650         intel_ntb_spad_read(ntb->device, NTB_MSIX_GUARD, &val);
2651         if (val != NTB_MSIX_VER_GUARD)
2652                 goto reschedule;
2653
2654         for (i = 0; i < XEON_NONLINK_DB_MSIX_BITS; i++) {
2655                 intel_ntb_spad_read(ntb->device, NTB_MSIX_DATA0 + i, &val);
2656                 intel_ntb_printf(2, "remote MSIX data(%u): 0x%x\n", i, val);
2657                 ntb->peer_msix_data[i].nmd_data = val;
2658                 intel_ntb_spad_read(ntb->device, NTB_MSIX_OFS0 + i, &val);
2659                 intel_ntb_printf(2, "remote MSIX addr(%u): 0x%x\n", i, val);
2660                 ntb->peer_msix_data[i].nmd_ofs = val;
2661         }
2662
2663         ntb->peer_msix_done = true;
2664
2665 msix_done:
2666         intel_ntb_peer_spad_write(ntb->device, NTB_MSIX_DONE, NTB_MSIX_RECEIVED);
2667         intel_ntb_spad_read(ntb->device, NTB_MSIX_DONE, &val);
2668         if (val != NTB_MSIX_RECEIVED)
2669                 goto reschedule;
2670
2671         intel_ntb_spad_clear(ntb->device);
2672         ntb->peer_msix_good = true;
2673         /* Give peer time to see our NTB_MSIX_RECEIVED. */
2674         goto reschedule;
2675
2676 msix_good:
2677         intel_ntb_poll_link(ntb);
2678         ntb_link_event(ntb->device);
2679         return;
2680
2681 reschedule:
2682         ntb->lnk_sta = pci_read_config(ntb->device, ntb->reg->lnk_sta, 2);
2683         if (_xeon_link_is_up(ntb)) {
2684                 callout_reset(&ntb->peer_msix_work,
2685                     hz * (ntb->peer_msix_good ? 2 : 1) / 100,
2686                     intel_ntb_exchange_msix, ntb);
2687         } else
2688                 intel_ntb_spad_clear(ntb->device);
2689 }
2690
2691 /*
2692  * Public API to the rest of the OS
2693  */
2694
2695 static uint8_t
2696 intel_ntb_spad_count(device_t dev)
2697 {
2698         struct ntb_softc *ntb = device_get_softc(dev);
2699
2700         return (ntb->spad_count);
2701 }
2702
2703 static uint8_t
2704 intel_ntb_mw_count(device_t dev)
2705 {
2706         struct ntb_softc *ntb = device_get_softc(dev);
2707         uint8_t res;
2708
2709         res = ntb->mw_count;
2710         if (ntb->b2b_mw_idx != B2B_MW_DISABLED && ntb->b2b_off == 0)
2711                 res--;
2712         if (ntb->msix_mw_idx != B2B_MW_DISABLED)
2713                 res--;
2714         return (res);
2715 }
2716
2717 static int
2718 intel_ntb_spad_write(device_t dev, unsigned int idx, uint32_t val)
2719 {
2720         struct ntb_softc *ntb = device_get_softc(dev);
2721
2722         if (idx >= ntb->spad_count)
2723                 return (EINVAL);
2724
2725         intel_ntb_reg_write(4, ntb->self_reg->spad + idx * 4, val);
2726
2727         return (0);
2728 }
2729
2730 /*
2731  * Zeros the local scratchpad.
2732  */
2733 static void
2734 intel_ntb_spad_clear(device_t dev)
2735 {
2736         struct ntb_softc *ntb = device_get_softc(dev);
2737         unsigned i;
2738
2739         for (i = 0; i < ntb->spad_count; i++)
2740                 intel_ntb_spad_write(dev, i, 0);
2741 }
2742
2743 static int
2744 intel_ntb_spad_read(device_t dev, unsigned int idx, uint32_t *val)
2745 {
2746         struct ntb_softc *ntb = device_get_softc(dev);
2747
2748         if (idx >= ntb->spad_count)
2749                 return (EINVAL);
2750
2751         *val = intel_ntb_reg_read(4, ntb->self_reg->spad + idx * 4);
2752
2753         return (0);
2754 }
2755
2756 static int
2757 intel_ntb_peer_spad_write(device_t dev, unsigned int idx, uint32_t val)
2758 {
2759         struct ntb_softc *ntb = device_get_softc(dev);
2760
2761         if (idx >= ntb->spad_count)
2762                 return (EINVAL);
2763
2764         if (HAS_FEATURE(ntb, NTB_SDOORBELL_LOCKUP))
2765                 intel_ntb_mw_write(4, XEON_SPAD_OFFSET + idx * 4, val);
2766         else
2767                 intel_ntb_reg_write(4, ntb->peer_reg->spad + idx * 4, val);
2768
2769         return (0);
2770 }
2771
2772 static int
2773 intel_ntb_peer_spad_read(device_t dev, unsigned int idx, uint32_t *val)
2774 {
2775         struct ntb_softc *ntb = device_get_softc(dev);
2776
2777         if (idx >= ntb->spad_count)
2778                 return (EINVAL);
2779
2780         if (HAS_FEATURE(ntb, NTB_SDOORBELL_LOCKUP))
2781                 *val = intel_ntb_mw_read(4, XEON_SPAD_OFFSET + idx * 4);
2782         else
2783                 *val = intel_ntb_reg_read(4, ntb->peer_reg->spad + idx * 4);
2784
2785         return (0);
2786 }
2787
2788 static int
2789 intel_ntb_mw_get_range(device_t dev, unsigned mw_idx, vm_paddr_t *base,
2790     caddr_t *vbase, size_t *size, size_t *align, size_t *align_size,
2791     bus_addr_t *plimit)
2792 {
2793         struct ntb_softc *ntb = device_get_softc(dev);
2794         struct ntb_pci_bar_info *bar;
2795         bus_addr_t limit;
2796         size_t bar_b2b_off;
2797         enum ntb_bar bar_num;
2798
2799         if (mw_idx >= intel_ntb_mw_count(dev))
2800                 return (EINVAL);
2801         mw_idx = intel_ntb_user_mw_to_idx(ntb, mw_idx);
2802
2803         bar_num = intel_ntb_mw_to_bar(ntb, mw_idx);
2804         bar = &ntb->bar_info[bar_num];
2805         bar_b2b_off = 0;
2806         if (mw_idx == ntb->b2b_mw_idx) {
2807                 KASSERT(ntb->b2b_off != 0,
2808                     ("user shouldn't get non-shared b2b mw"));
2809                 bar_b2b_off = ntb->b2b_off;
2810         }
2811
2812         if (bar_is_64bit(ntb, bar_num))
2813                 limit = BUS_SPACE_MAXADDR;
2814         else
2815                 limit = BUS_SPACE_MAXADDR_32BIT;
2816
2817         if (base != NULL)
2818                 *base = bar->pbase + bar_b2b_off;
2819         if (vbase != NULL)
2820                 *vbase = bar->vbase + bar_b2b_off;
2821         if (size != NULL)
2822                 *size = bar->size - bar_b2b_off;
2823         if (align != NULL)
2824                 *align = bar->size;
2825         if (align_size != NULL)
2826                 *align_size = 1;
2827         if (plimit != NULL)
2828                 *plimit = limit;
2829         return (0);
2830 }
2831
2832 static int
2833 intel_ntb_mw_set_trans(device_t dev, unsigned idx, bus_addr_t addr, size_t size)
2834 {
2835         struct ntb_softc *ntb = device_get_softc(dev);
2836         struct ntb_pci_bar_info *bar;
2837         uint64_t base, limit, reg_val;
2838         size_t bar_size, mw_size;
2839         uint32_t base_reg, xlat_reg, limit_reg;
2840         enum ntb_bar bar_num;
2841
2842         if (idx >= intel_ntb_mw_count(dev))
2843                 return (EINVAL);
2844         idx = intel_ntb_user_mw_to_idx(ntb, idx);
2845
2846         bar_num = intel_ntb_mw_to_bar(ntb, idx);
2847         bar = &ntb->bar_info[bar_num];
2848
2849         bar_size = bar->size;
2850         if (idx == ntb->b2b_mw_idx)
2851                 mw_size = bar_size - ntb->b2b_off;
2852         else
2853                 mw_size = bar_size;
2854
2855         /* Hardware requires that addr is aligned to bar size */
2856         if ((addr & (bar_size - 1)) != 0)
2857                 return (EINVAL);
2858
2859         if (size > mw_size)
2860                 return (EINVAL);
2861
2862         bar_get_xlat_params(ntb, bar_num, &base_reg, &xlat_reg, &limit_reg);
2863
2864         limit = 0;
2865         if (bar_is_64bit(ntb, bar_num)) {
2866                 base = intel_ntb_reg_read(8, base_reg) & BAR_HIGH_MASK;
2867
2868                 if (limit_reg != 0 && size != mw_size)
2869                         limit = base + size;
2870
2871                 /* Set and verify translation address */
2872                 intel_ntb_reg_write(8, xlat_reg, addr);
2873                 reg_val = intel_ntb_reg_read(8, xlat_reg) & BAR_HIGH_MASK;
2874                 if (reg_val != addr) {
2875                         intel_ntb_reg_write(8, xlat_reg, 0);
2876                         return (EIO);
2877                 }
2878
2879                 /* Set and verify the limit */
2880                 intel_ntb_reg_write(8, limit_reg, limit);
2881                 reg_val = intel_ntb_reg_read(8, limit_reg) & BAR_HIGH_MASK;
2882                 if (reg_val != limit) {
2883                         intel_ntb_reg_write(8, limit_reg, base);
2884                         intel_ntb_reg_write(8, xlat_reg, 0);
2885                         return (EIO);
2886                 }
2887         } else {
2888                 /* Configure 32-bit (split) BAR MW */
2889
2890                 if ((addr & UINT32_MAX) != addr)
2891                         return (ERANGE);
2892                 if (((addr + size) & UINT32_MAX) != (addr + size))
2893                         return (ERANGE);
2894
2895                 base = intel_ntb_reg_read(4, base_reg) & BAR_HIGH_MASK;
2896
2897                 if (limit_reg != 0 && size != mw_size)
2898                         limit = base + size;
2899
2900                 /* Set and verify translation address */
2901                 intel_ntb_reg_write(4, xlat_reg, addr);
2902                 reg_val = intel_ntb_reg_read(4, xlat_reg) & BAR_HIGH_MASK;
2903                 if (reg_val != addr) {
2904                         intel_ntb_reg_write(4, xlat_reg, 0);
2905                         return (EIO);
2906                 }
2907
2908                 /* Set and verify the limit */
2909                 intel_ntb_reg_write(4, limit_reg, limit);
2910                 reg_val = intel_ntb_reg_read(4, limit_reg) & BAR_HIGH_MASK;
2911                 if (reg_val != limit) {
2912                         intel_ntb_reg_write(4, limit_reg, base);
2913                         intel_ntb_reg_write(4, xlat_reg, 0);
2914                         return (EIO);
2915                 }
2916         }
2917         return (0);
2918 }
2919
2920 static int
2921 intel_ntb_mw_clear_trans(device_t dev, unsigned mw_idx)
2922 {
2923
2924         return (intel_ntb_mw_set_trans(dev, mw_idx, 0, 0));
2925 }
2926
2927 static int
2928 intel_ntb_mw_get_wc(device_t dev, unsigned idx, vm_memattr_t *mode)
2929 {
2930         struct ntb_softc *ntb = device_get_softc(dev);
2931         struct ntb_pci_bar_info *bar;
2932
2933         if (idx >= intel_ntb_mw_count(dev))
2934                 return (EINVAL);
2935         idx = intel_ntb_user_mw_to_idx(ntb, idx);
2936
2937         bar = &ntb->bar_info[intel_ntb_mw_to_bar(ntb, idx)];
2938         *mode = bar->map_mode;
2939         return (0);
2940 }
2941
2942 static int
2943 intel_ntb_mw_set_wc(device_t dev, unsigned idx, vm_memattr_t mode)
2944 {
2945         struct ntb_softc *ntb = device_get_softc(dev);
2946
2947         if (idx >= intel_ntb_mw_count(dev))
2948                 return (EINVAL);
2949
2950         idx = intel_ntb_user_mw_to_idx(ntb, idx);
2951         return (intel_ntb_mw_set_wc_internal(ntb, idx, mode));
2952 }
2953
2954 static int
2955 intel_ntb_mw_set_wc_internal(struct ntb_softc *ntb, unsigned idx, vm_memattr_t mode)
2956 {
2957         struct ntb_pci_bar_info *bar;
2958         int rc;
2959
2960         bar = &ntb->bar_info[intel_ntb_mw_to_bar(ntb, idx)];
2961         if (bar->map_mode == mode)
2962                 return (0);
2963
2964         rc = pmap_change_attr((vm_offset_t)bar->vbase, bar->size, mode);
2965         if (rc == 0)
2966                 bar->map_mode = mode;
2967
2968         return (rc);
2969 }
2970
2971 static void
2972 intel_ntb_peer_db_set(device_t dev, uint64_t bit)
2973 {
2974         struct ntb_softc *ntb = device_get_softc(dev);
2975
2976         if (HAS_FEATURE(ntb, NTB_SB01BASE_LOCKUP)) {
2977                 struct ntb_pci_bar_info *lapic;
2978                 unsigned i;
2979
2980                 lapic = ntb->peer_lapic_bar;
2981
2982                 for (i = 0; i < XEON_NONLINK_DB_MSIX_BITS; i++) {
2983                         if ((bit & intel_ntb_db_vector_mask(dev, i)) != 0)
2984                                 bus_space_write_4(lapic->pci_bus_tag,
2985                                     lapic->pci_bus_handle,
2986                                     ntb->peer_msix_data[i].nmd_ofs,
2987                                     ntb->peer_msix_data[i].nmd_data);
2988                 }
2989                 return;
2990         }
2991
2992         if (HAS_FEATURE(ntb, NTB_SDOORBELL_LOCKUP)) {
2993                 intel_ntb_mw_write(2, XEON_PDOORBELL_OFFSET, bit);
2994                 return;
2995         }
2996
2997         db_iowrite(ntb, ntb->peer_reg->db_bell, bit);
2998 }
2999
3000 static int
3001 intel_ntb_peer_db_addr(device_t dev, bus_addr_t *db_addr, vm_size_t *db_size)
3002 {
3003         struct ntb_softc *ntb = device_get_softc(dev);
3004         struct ntb_pci_bar_info *bar;
3005         uint64_t regoff;
3006
3007         KASSERT((db_addr != NULL && db_size != NULL), ("must be non-NULL"));
3008
3009         if (!HAS_FEATURE(ntb, NTB_SDOORBELL_LOCKUP)) {
3010                 bar = &ntb->bar_info[NTB_CONFIG_BAR];
3011                 regoff = ntb->peer_reg->db_bell;
3012         } else {
3013                 KASSERT(ntb->b2b_mw_idx != B2B_MW_DISABLED,
3014                     ("invalid b2b idx"));
3015
3016                 bar = &ntb->bar_info[intel_ntb_mw_to_bar(ntb, ntb->b2b_mw_idx)];
3017                 regoff = XEON_PDOORBELL_OFFSET;
3018         }
3019         KASSERT(bar->pci_bus_tag != X86_BUS_SPACE_IO, ("uh oh"));
3020
3021         /* HACK: Specific to current x86 bus implementation. */
3022         *db_addr = ((uint64_t)bar->pci_bus_handle + regoff);
3023         *db_size = ntb->reg->db_size;
3024         return (0);
3025 }
3026
3027 static uint64_t
3028 intel_ntb_db_valid_mask(device_t dev)
3029 {
3030         struct ntb_softc *ntb = device_get_softc(dev);
3031
3032         return (ntb->db_valid_mask);
3033 }
3034
3035 static int
3036 intel_ntb_db_vector_count(device_t dev)
3037 {
3038         struct ntb_softc *ntb = device_get_softc(dev);
3039
3040         return (ntb->db_vec_count);
3041 }
3042
3043 static uint64_t
3044 intel_ntb_db_vector_mask(device_t dev, uint32_t vector)
3045 {
3046         struct ntb_softc *ntb = device_get_softc(dev);
3047
3048         if (vector > ntb->db_vec_count)
3049                 return (0);
3050         return (ntb->db_valid_mask & intel_ntb_vec_mask(ntb, vector));
3051 }
3052
3053 static bool
3054 intel_ntb_link_is_up(device_t dev, enum ntb_speed *speed, enum ntb_width *width)
3055 {
3056         struct ntb_softc *ntb = device_get_softc(dev);
3057
3058         if (speed != NULL)
3059                 *speed = intel_ntb_link_sta_speed(ntb);
3060         if (width != NULL)
3061                 *width = intel_ntb_link_sta_width(ntb);
3062         return (link_is_up(ntb));
3063 }
3064
3065 static void
3066 save_bar_parameters(struct ntb_pci_bar_info *bar)
3067 {
3068
3069         bar->pci_bus_tag = rman_get_bustag(bar->pci_resource);
3070         bar->pci_bus_handle = rman_get_bushandle(bar->pci_resource);
3071         bar->pbase = rman_get_start(bar->pci_resource);
3072         bar->size = rman_get_size(bar->pci_resource);
3073         bar->vbase = rman_get_virtual(bar->pci_resource);
3074 }
3075
3076 static device_method_t ntb_intel_methods[] = {
3077         /* Device interface */
3078         DEVMETHOD(device_probe,         intel_ntb_probe),
3079         DEVMETHOD(device_attach,        intel_ntb_attach),
3080         DEVMETHOD(device_detach,        intel_ntb_detach),
3081         /* NTB interface */
3082         DEVMETHOD(ntb_link_is_up,       intel_ntb_link_is_up),
3083         DEVMETHOD(ntb_link_enable,      intel_ntb_link_enable),
3084         DEVMETHOD(ntb_link_disable,     intel_ntb_link_disable),
3085         DEVMETHOD(ntb_link_enabled,     intel_ntb_link_enabled),
3086         DEVMETHOD(ntb_mw_count,         intel_ntb_mw_count),
3087         DEVMETHOD(ntb_mw_get_range,     intel_ntb_mw_get_range),
3088         DEVMETHOD(ntb_mw_set_trans,     intel_ntb_mw_set_trans),
3089         DEVMETHOD(ntb_mw_clear_trans,   intel_ntb_mw_clear_trans),
3090         DEVMETHOD(ntb_mw_get_wc,        intel_ntb_mw_get_wc),
3091         DEVMETHOD(ntb_mw_set_wc,        intel_ntb_mw_set_wc),
3092         DEVMETHOD(ntb_spad_count,       intel_ntb_spad_count),
3093         DEVMETHOD(ntb_spad_clear,       intel_ntb_spad_clear),
3094         DEVMETHOD(ntb_spad_write,       intel_ntb_spad_write),
3095         DEVMETHOD(ntb_spad_read,        intel_ntb_spad_read),
3096         DEVMETHOD(ntb_peer_spad_write,  intel_ntb_peer_spad_write),
3097         DEVMETHOD(ntb_peer_spad_read,   intel_ntb_peer_spad_read),
3098         DEVMETHOD(ntb_db_valid_mask,    intel_ntb_db_valid_mask),
3099         DEVMETHOD(ntb_db_vector_count,  intel_ntb_db_vector_count),
3100         DEVMETHOD(ntb_db_vector_mask,   intel_ntb_db_vector_mask),
3101         DEVMETHOD(ntb_db_clear,         intel_ntb_db_clear),
3102         DEVMETHOD(ntb_db_clear_mask,    intel_ntb_db_clear_mask),
3103         DEVMETHOD(ntb_db_read,          intel_ntb_db_read),
3104         DEVMETHOD(ntb_db_set_mask,      intel_ntb_db_set_mask),
3105         DEVMETHOD(ntb_peer_db_addr,     intel_ntb_peer_db_addr),
3106         DEVMETHOD(ntb_peer_db_set,      intel_ntb_peer_db_set),
3107         DEVMETHOD_END
3108 };
3109
3110 static DEFINE_CLASS_0(ntb_hw, ntb_intel_driver, ntb_intel_methods,
3111     sizeof(struct ntb_softc));
3112 DRIVER_MODULE(ntb_intel, pci, ntb_intel_driver, ntb_hw_devclass, NULL, NULL);
3113 MODULE_DEPEND(ntb_intel, ntb, 1, 1, 1);
3114 MODULE_VERSION(ntb_intel, 1);