sys/dev/ntb/ntb_transport.c

   1 /*-
   2  * Copyright (c) 2016-2017 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 transport for sending and receiving messages by
  34  * writing to remote memory window(s) provided by underlying NTB device.
  35  *
  36  * NOTE: Much of the code in this module is shared with Linux. Any patches may
  37  * be picked up and redistributed in Linux with a dual GPL/BSD license.
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __FBSDID("$FreeBSD$");
  42
  43 #include <sys/param.h>
  44 #include <sys/kernel.h>
  45 #include <sys/systm.h>
  46 #include <sys/bus.h>
  47 #include <sys/ktr.h>
  48 #include <sys/limits.h>
  49 #include <sys/lock.h>
  50 #include <sys/malloc.h>
  51 #include <sys/mbuf.h>
  52 #include <sys/module.h>
  53 #include <sys/mutex.h>
  54 #include <sys/queue.h>
  55 #include <sys/sysctl.h>
  56 #include <sys/taskqueue.h>
  57
  58 #include <vm/vm.h>
  59 #include <vm/pmap.h>
  60
  61 #include <machine/bus.h>
  62
  63 #include "ntb.h"
  64 #include "ntb_transport.h"
  65
  66 #define KTR_NTB KTR_SPARE3
  67
  68 #define NTB_TRANSPORT_VERSION   4
  69
  70 static SYSCTL_NODE(_hw, OID_AUTO, ntb_transport, CTLFLAG_RW, 0, "ntb_transport");
  71
  72 static unsigned g_ntb_transport_debug_level;
  73 SYSCTL_UINT(_hw_ntb_transport, OID_AUTO, debug_level, CTLFLAG_RWTUN,
  74     &g_ntb_transport_debug_level, 0,
  75     "ntb_transport log level -- higher is more verbose");
  76 #define ntb_printf(lvl, ...) do {                       \
  77         if ((lvl) <= g_ntb_transport_debug_level) {     \
  78                 printf(__VA_ARGS__);                    \
  79         }                                               \
  80 } while (0)
  81
  82 static unsigned transport_mtu = 0x10000;
  83
  84 static uint64_t max_mw_size = 256*1024*1024;
  85 SYSCTL_UQUAD(_hw_ntb_transport, OID_AUTO, max_mw_size, CTLFLAG_RDTUN, &max_mw_size, 0,
  86     "If enabled (non-zero), limit the size of large memory windows. "
  87     "Both sides of the NTB MUST set the same value here.");
  88
  89 static unsigned enable_xeon_watchdog;
  90 SYSCTL_UINT(_hw_ntb_transport, OID_AUTO, enable_xeon_watchdog, CTLFLAG_RDTUN,
  91     &enable_xeon_watchdog, 0, "If non-zero, write a register every second to "
  92     "keep a watchdog from tearing down the NTB link");
  93
  94 STAILQ_HEAD(ntb_queue_list, ntb_queue_entry);
  95
  96 typedef uint32_t ntb_q_idx_t;
  97
  98 struct ntb_queue_entry {
  99         /* ntb_queue list reference */
 100         STAILQ_ENTRY(ntb_queue_entry) entry;
 101
 102         /* info on data to be transferred */
 103         void            *cb_data;
 104         void            *buf;
 105         uint32_t        len;
 106         uint32_t        flags;
 107
 108         struct ntb_transport_qp         *qp;
 109         struct ntb_payload_header       *x_hdr;
 110         ntb_q_idx_t     index;
 111 };
 112
 113 struct ntb_rx_info {
 114         ntb_q_idx_t     entry;
 115 };
 116
 117 struct ntb_transport_qp {
 118         struct ntb_transport_ctx        *transport;
 119         device_t                 dev;
 120
 121         void                    *cb_data;
 122
 123         bool                    client_ready;
 124         volatile bool           link_is_up;
 125         uint8_t                 qp_num; /* Only 64 QPs are allowed.  0-63 */
 126
 127         struct ntb_rx_info      *rx_info;
 128         struct ntb_rx_info      *remote_rx_info;
 129
 130         void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data,
 131             void *data, int len);
 132         struct ntb_queue_list   tx_free_q;
 133         struct mtx              ntb_tx_free_q_lock;
 134         caddr_t                 tx_mw;
 135         bus_addr_t              tx_mw_phys;
 136         ntb_q_idx_t             tx_index;
 137         ntb_q_idx_t             tx_max_entry;
 138         uint64_t                tx_max_frame;
 139
 140         void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data,
 141             void *data, int len);
 142         struct ntb_queue_list   rx_post_q;
 143         struct ntb_queue_list   rx_pend_q;
 144         /* ntb_rx_q_lock: synchronize access to rx_XXXX_q */
 145         struct mtx              ntb_rx_q_lock;
 146         struct task             rxc_db_work;
 147         struct taskqueue        *rxc_tq;
 148         caddr_t                 rx_buff;
 149         ntb_q_idx_t             rx_index;
 150         ntb_q_idx_t             rx_max_entry;
 151         uint64_t                rx_max_frame;
 152
 153         void (*event_handler)(void *data, enum ntb_link_event status);
 154         struct callout          link_work;
 155         struct callout          rx_full;
 156
 157         uint64_t                last_rx_no_buf;
 158
 159         /* Stats */
 160         uint64_t                rx_bytes;
 161         uint64_t                rx_pkts;
 162         uint64_t                rx_ring_empty;
 163         uint64_t                rx_err_no_buf;
 164         uint64_t                rx_err_oflow;
 165         uint64_t                rx_err_ver;
 166         uint64_t                tx_bytes;
 167         uint64_t                tx_pkts;
 168         uint64_t                tx_ring_full;
 169         uint64_t                tx_err_no_buf;
 170
 171         struct mtx              tx_lock;
 172 };
 173
 174 struct ntb_transport_mw {
 175         vm_paddr_t      phys_addr;
 176         size_t          phys_size;
 177         size_t          xlat_align;
 178         size_t          xlat_align_size;
 179         bus_addr_t      addr_limit;
 180         /* Tx buff is vbase / phys_addr / tx_size */
 181         caddr_t         vbase;
 182         size_t          tx_size;
 183         /* Rx buff is virt_addr / dma_addr / rx_size */
 184         bus_dma_tag_t   dma_tag;
 185         bus_dmamap_t    dma_map;
 186         caddr_t         virt_addr;
 187         bus_addr_t      dma_addr;
 188         size_t          rx_size;
 189         /* rx_size increased to size alignment requirements of the hardware. */
 190         size_t          buff_size;
 191 };
 192
 193 struct ntb_transport_child {
 194         device_t        dev;
 195         int             consumer;
 196         int             qpoff;
 197         int             qpcnt;
 198         struct ntb_transport_child *next;
 199 };
 200
 201 struct ntb_transport_ctx {
 202         device_t                 dev;
 203         struct ntb_transport_child *child;
 204         struct ntb_transport_mw *mw_vec;
 205         struct ntb_transport_qp *qp_vec;
 206         int                     compact;
 207         unsigned                mw_count;
 208         unsigned                qp_count;
 209         uint64_t                qp_bitmap;
 210         volatile bool           link_is_up;
 211         enum ntb_speed          link_speed;
 212         enum ntb_width          link_width;
 213         struct callout          link_work;
 214         struct callout          link_watchdog;
 215         struct task             link_cleanup;
 216 };
 217
 218 enum {
 219         NTBT_DESC_DONE_FLAG = 1 << 0,
 220         NTBT_LINK_DOWN_FLAG = 1 << 1,
 221 };
 222
 223 struct ntb_payload_header {
 224         ntb_q_idx_t ver;
 225         uint32_t len;
 226         uint32_t flags;
 227 };
 228
 229 enum {
 230         /*
 231          * The order of this enum is part of the remote protocol.  Do not
 232          * reorder without bumping protocol version (and it's probably best
 233          * to keep the protocol in lock-step with the Linux NTB driver.
 234          */
 235         NTBT_VERSION = 0,
 236         NTBT_QP_LINKS,
 237         NTBT_NUM_QPS,
 238         NTBT_NUM_MWS,
 239         /*
 240          * N.B.: transport_link_work assumes MW1 enums = MW0 + 2.
 241          */
 242         NTBT_MW0_SZ_HIGH,
 243         NTBT_MW0_SZ_LOW,
 244         NTBT_MW1_SZ_HIGH,
 245         NTBT_MW1_SZ_LOW,
 246
 247         /*
 248          * Some NTB-using hardware have a watchdog to work around NTB hangs; if
 249          * a register or doorbell isn't written every few seconds, the link is
 250          * torn down.  Write an otherwise unused register every few seconds to
 251          * work around this watchdog.
 252          */
 253         NTBT_WATCHDOG_SPAD = 15
 254 };
 255
 256 /*
 257  * Compart version of sratchpad protocol, using twice less registers.
 258  */
 259 enum {
 260         NTBTC_PARAMS = 0,       /* NUM_QPS << 24 + NUM_MWS << 16 + VERSION */
 261         NTBTC_QP_LINKS,         /* QP links status */
 262         NTBTC_MW0_SZ,           /* MW size limited to 32 bits. */
 263 };
 264
 265 #define QP_TO_MW(nt, qp)        ((qp) % nt->mw_count)
 266 #define NTB_QP_DEF_NUM_ENTRIES  100
 267 #define NTB_LINK_DOWN_TIMEOUT   100
 268
 269 static int ntb_transport_probe(device_t dev);
 270 static int ntb_transport_attach(device_t dev);
 271 static int ntb_transport_detach(device_t dev);
 272 static void ntb_transport_init_queue(struct ntb_transport_ctx *nt,
 273     unsigned int qp_num);
 274 static int ntb_process_tx(struct ntb_transport_qp *qp,
 275     struct ntb_queue_entry *entry);
 276 static void ntb_transport_rxc_db(void *arg, int pending);
 277 static int ntb_process_rxc(struct ntb_transport_qp *qp);
 278 static void ntb_memcpy_rx(struct ntb_transport_qp *qp,
 279     struct ntb_queue_entry *entry, void *offset);
 280 static inline void ntb_rx_copy_callback(struct ntb_transport_qp *qp,
 281     void *data);
 282 static void ntb_complete_rxc(struct ntb_transport_qp *qp);
 283 static void ntb_transport_doorbell_callback(void *data, uint32_t vector);
 284 static void ntb_transport_event_callback(void *data);
 285 static void ntb_transport_link_work(void *arg);
 286 static int ntb_set_mw(struct ntb_transport_ctx *, int num_mw, size_t size);
 287 static void ntb_free_mw(struct ntb_transport_ctx *nt, int num_mw);
 288 static int ntb_transport_setup_qp_mw(struct ntb_transport_ctx *nt,
 289     unsigned int qp_num);
 290 static void ntb_qp_link_work(void *arg);
 291 static void ntb_transport_link_cleanup(struct ntb_transport_ctx *nt);
 292 static void ntb_transport_link_cleanup_work(void *, int);
 293 static void ntb_qp_link_down(struct ntb_transport_qp *qp);
 294 static void ntb_qp_link_down_reset(struct ntb_transport_qp *qp);
 295 static void ntb_qp_link_cleanup(struct ntb_transport_qp *qp);
 296 static void ntb_send_link_down(struct ntb_transport_qp *qp);
 297 static void ntb_list_add(struct mtx *lock, struct ntb_queue_entry *entry,
 298     struct ntb_queue_list *list);
 299 static struct ntb_queue_entry *ntb_list_rm(struct mtx *lock,
 300     struct ntb_queue_list *list);
 301 static struct ntb_queue_entry *ntb_list_mv(struct mtx *lock,
 302     struct ntb_queue_list *from, struct ntb_queue_list *to);
 303 static void xeon_link_watchdog_hb(void *);
 304
 305 static const struct ntb_ctx_ops ntb_transport_ops = {
 306         .link_event = ntb_transport_event_callback,
 307         .db_event = ntb_transport_doorbell_callback,
 308 };
 309
 310 MALLOC_DEFINE(M_NTB_T, "ntb_transport", "ntb transport driver");
 311
 312 static inline void
 313 iowrite32(uint32_t val, void *addr)
 314 {
 315
 316         bus_space_write_4(X86_BUS_SPACE_MEM, 0/* HACK */, (uintptr_t)addr,
 317             val);
 318 }
 319
 320 /* Transport Init and teardown */
 321
 322 static void
 323 xeon_link_watchdog_hb(void *arg)
 324 {
 325         struct ntb_transport_ctx *nt;
 326
 327         nt = arg;
 328         ntb_spad_write(nt->dev, NTBT_WATCHDOG_SPAD, 0);
 329         callout_reset(&nt->link_watchdog, 1 * hz, xeon_link_watchdog_hb, nt);
 330 }
 331
 332 static int
 333 ntb_transport_probe(device_t dev)
 334 {
 335
 336         device_set_desc(dev, "NTB Transport");
 337         return (0);
 338 }
 339
 340 static int
 341 ntb_transport_attach(device_t dev)
 342 {
 343         struct ntb_transport_ctx *nt = device_get_softc(dev);
 344         struct ntb_transport_child **cpp = &nt->child;
 345         struct ntb_transport_child *nc;
 346         struct ntb_transport_mw *mw;
 347         uint64_t db_bitmap;
 348         int rc, i, db_count, spad_count, qp, qpu, qpo, qpt;
 349         char cfg[128] = "";
 350         char buf[32];
 351         char *n, *np, *c, *name;
 352
 353         nt->dev = dev;
 354         nt->mw_count = ntb_mw_count(dev);
 355         spad_count = ntb_spad_count(dev);
 356         db_bitmap = ntb_db_valid_mask(dev);
 357         db_count = flsll(db_bitmap);
 358         KASSERT(db_bitmap == (1 << db_count) - 1,
 359             ("Doorbells are not sequential (%jx).\n", db_bitmap));
 360
 361         if (nt->mw_count == 0) {
 362                 device_printf(dev, "At least 1 memory window required.\n");
 363                 return (ENXIO);
 364         }
 365         nt->compact = (spad_count < 4 + 2 * nt->mw_count);
 366         snprintf(buf, sizeof(buf), "hint.%s.%d.compact", device_get_name(dev),
 367             device_get_unit(dev));
 368         TUNABLE_INT_FETCH(buf, &nt->compact);
 369         if (nt->compact) {
 370                 if (spad_count < 3) {
 371                         device_printf(dev, "At least 3 scratchpads required.\n");
 372                         return (ENXIO);
 373                 }
 374                 if (spad_count < 2 + nt->mw_count) {
 375                         nt->mw_count = spad_count - 2;
 376                         device_printf(dev, "Scratchpads enough only for %d "
 377                             "memory windows.\n", nt->mw_count);
 378                 }
 379         } else {
 380                 if (spad_count < 6) {
 381                         device_printf(dev, "At least 6 scratchpads required.\n");
 382                         return (ENXIO);
 383                 }
 384                 if (spad_count < 4 + 2 * nt->mw_count) {
 385                         nt->mw_count = (spad_count - 4) / 2;
 386                         device_printf(dev, "Scratchpads enough only for %d "
 387                             "memory windows.\n", nt->mw_count);
 388                 }
 389         }
 390         if (db_bitmap == 0) {
 391                 device_printf(dev, "At least one doorbell required.\n");
 392                 return (ENXIO);
 393         }
 394
 395         nt->mw_vec = malloc(nt->mw_count * sizeof(*nt->mw_vec), M_NTB_T,
 396             M_WAITOK | M_ZERO);
 397         for (i = 0; i < nt->mw_count; i++) {
 398                 mw = &nt->mw_vec[i];
 399
 400                 rc = ntb_mw_get_range(dev, i, &mw->phys_addr, &mw->vbase,
 401                     &mw->phys_size, &mw->xlat_align, &mw->xlat_align_size,
 402                     &mw->addr_limit);
 403                 if (rc != 0)
 404                         goto err;
 405
 406                 mw->tx_size = mw->phys_size;
 407                 if (max_mw_size != 0 && mw->tx_size > max_mw_size) {
 408                         device_printf(dev, "Memory window %d limited from "
 409                             "%ju to %ju\n", i, (uintmax_t)mw->tx_size,
 410                             max_mw_size);
 411                         mw->tx_size = max_mw_size;
 412                 }
 413                 if (nt->compact && mw->tx_size > UINT32_MAX) {
 414                         device_printf(dev, "Memory window %d is too big "
 415                             "(%ju)\n", i, (uintmax_t)mw->tx_size);
 416                         rc = ENXIO;
 417                         goto err;
 418                 }
 419
 420                 mw->rx_size = 0;
 421                 mw->buff_size = 0;
 422                 mw->virt_addr = NULL;
 423                 mw->dma_addr = 0;
 424
 425                 rc = ntb_mw_set_wc(dev, i, VM_MEMATTR_WRITE_COMBINING);
 426                 if (rc)
 427                         ntb_printf(0, "Unable to set mw%d caching\n", i);
 428
 429                 /*
 430                  * Try to preallocate receive memory early, since there may
 431                  * be not enough contiguous memory later.  It is quite likely
 432                  * that NTB windows are symmetric and this allocation remain,
 433                  * but even if not, we will just reallocate it later.
 434                  */
 435                 ntb_set_mw(nt, i, mw->tx_size);
 436         }
 437
 438         qpu = 0;
 439         qpo = imin(db_count, nt->mw_count);
 440         qpt = db_count;
 441
 442         snprintf(buf, sizeof(buf), "hint.%s.%d.config", device_get_name(dev),
 443             device_get_unit(dev));
 444         TUNABLE_STR_FETCH(buf, cfg, sizeof(cfg));
 445         n = cfg;
 446         i = 0;
 447         while ((c = strsep(&n, ",")) != NULL) {
 448                 np = c;
 449                 name = strsep(&np, ":");
 450                 if (name != NULL && name[0] == 0)
 451                         name = NULL;
 452                 qp = (np && np[0] != 0) ? strtol(np, NULL, 10) : qpo - qpu;
 453                 if (qp <= 0)
 454                         qp = 1;
 455
 456                 if (qp > qpt - qpu) {
 457                         device_printf(dev, "Not enough resources for config\n");
 458                         break;
 459                 }
 460
 461                 nc = malloc(sizeof(*nc), M_DEVBUF, M_WAITOK | M_ZERO);
 462                 nc->consumer = i;
 463                 nc->qpoff = qpu;
 464                 nc->qpcnt = qp;
 465                 nc->dev = device_add_child(dev, name, -1);
 466                 if (nc->dev == NULL) {
 467                         device_printf(dev, "Can not add child.\n");
 468                         break;
 469                 }
 470                 device_set_ivars(nc->dev, nc);
 471                 *cpp = nc;
 472                 cpp = &nc->next;
 473
 474                 if (bootverbose) {
 475                         device_printf(dev, "%d \"%s\": queues %d",
 476                             i, name, qpu);
 477                         if (qp > 1)
 478                                 printf("-%d", qpu + qp - 1);
 479                         printf("\n");
 480                 }
 481
 482                 qpu += qp;
 483                 i++;
 484         }
 485         nt->qp_count = qpu;
 486
 487         nt->qp_vec = malloc(nt->qp_count * sizeof(*nt->qp_vec), M_NTB_T,
 488             M_WAITOK | M_ZERO);
 489
 490         for (i = 0; i < nt->qp_count; i++)
 491                 ntb_transport_init_queue(nt, i);
 492
 493         callout_init(&nt->link_work, 0);
 494         callout_init(&nt->link_watchdog, 0);
 495         TASK_INIT(&nt->link_cleanup, 0, ntb_transport_link_cleanup_work, nt);
 496         nt->link_is_up = false;
 497
 498         rc = ntb_set_ctx(dev, nt, &ntb_transport_ops);
 499         if (rc != 0)
 500                 goto err;
 501
 502         ntb_link_enable(dev, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
 503
 504         for (i = 0; i < nt->mw_count; i++) {
 505                 mw = &nt->mw_vec[i];
 506                 rc = ntb_mw_set_trans(nt->dev, i, mw->dma_addr, mw->buff_size);
 507                 if (rc != 0)
 508                         ntb_printf(0, "load time mw%d xlat fails, rc %d\n", i, rc);
 509         }
 510
 511         if (enable_xeon_watchdog != 0)
 512                 callout_reset(&nt->link_watchdog, 0, xeon_link_watchdog_hb, nt);
 513
 514         bus_generic_attach(dev);
 515         return (0);
 516
 517 err:
 518         free(nt->qp_vec, M_NTB_T);
 519         free(nt->mw_vec, M_NTB_T);
 520         return (rc);
 521 }
 522
 523 static int
 524 ntb_transport_detach(device_t dev)
 525 {
 526         struct ntb_transport_ctx *nt = device_get_softc(dev);
 527         struct ntb_transport_child **cpp = &nt->child;
 528         struct ntb_transport_child *nc;
 529         int error = 0, i;
 530
 531         while ((nc = *cpp) != NULL) {
 532                 *cpp = (*cpp)->next;
 533                 error = device_delete_child(dev, nc->dev);
 534                 if (error)
 535                         break;
 536                 free(nc, M_DEVBUF);
 537         }
 538         KASSERT(nt->qp_bitmap == 0,
 539             ("Some queues not freed on detach (%jx)", nt->qp_bitmap));
 540
 541         ntb_transport_link_cleanup(nt);
 542         taskqueue_drain(taskqueue_swi, &nt->link_cleanup);
 543         callout_drain(&nt->link_work);
 544         callout_drain(&nt->link_watchdog);
 545
 546         ntb_link_disable(dev);
 547         ntb_clear_ctx(dev);
 548
 549         for (i = 0; i < nt->mw_count; i++)
 550                 ntb_free_mw(nt, i);
 551
 552         free(nt->qp_vec, M_NTB_T);
 553         free(nt->mw_vec, M_NTB_T);
 554         return (0);
 555 }
 556
 557 static int
 558 ntb_transport_print_child(device_t dev, device_t child)
 559 {
 560         struct ntb_transport_child *nc = device_get_ivars(child);
 561         int retval;
 562
 563         retval = bus_print_child_header(dev, child);
 564         if (nc->qpcnt > 0) {
 565                 printf(" queue %d", nc->qpoff);
 566                 if (nc->qpcnt > 1)
 567                         printf("-%d", nc->qpoff + nc->qpcnt - 1);
 568         }
 569         retval += printf(" at consumer %d", nc->consumer);
 570         retval += bus_print_child_domain(dev, child);
 571         retval += bus_print_child_footer(dev, child);
 572
 573         return (retval);
 574 }
 575
 576 static int
 577 ntb_transport_child_location_str(device_t dev, device_t child, char *buf,
 578     size_t buflen)
 579 {
 580         struct ntb_transport_child *nc = device_get_ivars(child);
 581
 582         snprintf(buf, buflen, "consumer=%d", nc->consumer);
 583         return (0);
 584 }
 585
 586 int
 587 ntb_transport_queue_count(device_t dev)
 588 {
 589         struct ntb_transport_child *nc = device_get_ivars(dev);
 590
 591         return (nc->qpcnt);
 592 }
 593
 594 static void
 595 ntb_transport_init_queue(struct ntb_transport_ctx *nt, unsigned int qp_num)
 596 {
 597         struct ntb_transport_mw *mw;
 598         struct ntb_transport_qp *qp;
 599         vm_paddr_t mw_base;
 600         uint64_t qp_offset;
 601         size_t tx_size;
 602         unsigned num_qps_mw, mw_num, mw_count;
 603
 604         mw_count = nt->mw_count;
 605         mw_num = QP_TO_MW(nt, qp_num);
 606         mw = &nt->mw_vec[mw_num];
 607
 608         qp = &nt->qp_vec[qp_num];
 609         qp->qp_num = qp_num;
 610         qp->transport = nt;
 611         qp->dev = nt->dev;
 612         qp->client_ready = false;
 613         qp->event_handler = NULL;
 614         ntb_qp_link_down_reset(qp);
 615
 616         if (mw_num < nt->qp_count % mw_count)
 617                 num_qps_mw = nt->qp_count / mw_count + 1;
 618         else
 619                 num_qps_mw = nt->qp_count / mw_count;
 620
 621         mw_base = mw->phys_addr;
 622
 623         tx_size = mw->tx_size / num_qps_mw;
 624         qp_offset = tx_size * (qp_num / mw_count);
 625
 626         qp->tx_mw = mw->vbase + qp_offset;
 627         KASSERT(qp->tx_mw != NULL, ("uh oh?"));
 628
 629         /* XXX Assumes that a vm_paddr_t is equivalent to bus_addr_t */
 630         qp->tx_mw_phys = mw_base + qp_offset;
 631         KASSERT(qp->tx_mw_phys != 0, ("uh oh?"));
 632
 633         tx_size -= sizeof(struct ntb_rx_info);
 634         qp->rx_info = (void *)(qp->tx_mw + tx_size);
 635
 636         /* Due to house-keeping, there must be at least 2 buffs */
 637         qp->tx_max_frame = qmin(transport_mtu, tx_size / 2);
 638         qp->tx_max_entry = tx_size / qp->tx_max_frame;
 639
 640         callout_init(&qp->link_work, 0);
 641         callout_init(&qp->rx_full, 1);
 642
 643         mtx_init(&qp->ntb_rx_q_lock, "ntb rx q", NULL, MTX_SPIN);
 644         mtx_init(&qp->ntb_tx_free_q_lock, "ntb tx free q", NULL, MTX_SPIN);
 645         mtx_init(&qp->tx_lock, "ntb transport tx", NULL, MTX_DEF);
 646         TASK_INIT(&qp->rxc_db_work, 0, ntb_transport_rxc_db, qp);
 647         qp->rxc_tq = taskqueue_create("ntbt_rx", M_WAITOK,
 648             taskqueue_thread_enqueue, &qp->rxc_tq);
 649         taskqueue_start_threads(&qp->rxc_tq, 1, PI_NET, "%s rx%d",
 650             device_get_nameunit(nt->dev), qp_num);
 651
 652         STAILQ_INIT(&qp->rx_post_q);
 653         STAILQ_INIT(&qp->rx_pend_q);
 654         STAILQ_INIT(&qp->tx_free_q);
 655 }
 656
 657 void
 658 ntb_transport_free_queue(struct ntb_transport_qp *qp)
 659 {
 660         struct ntb_transport_ctx *nt = qp->transport;
 661         struct ntb_queue_entry *entry;
 662
 663         callout_drain(&qp->link_work);
 664
 665         ntb_db_set_mask(qp->dev, 1ull << qp->qp_num);
 666         taskqueue_drain_all(qp->rxc_tq);
 667         taskqueue_free(qp->rxc_tq);
 668
 669         qp->cb_data = NULL;
 670         qp->rx_handler = NULL;
 671         qp->tx_handler = NULL;
 672         qp->event_handler = NULL;
 673
 674         while ((entry = ntb_list_rm(&qp->ntb_rx_q_lock, &qp->rx_pend_q)))
 675                 free(entry, M_NTB_T);
 676
 677         while ((entry = ntb_list_rm(&qp->ntb_rx_q_lock, &qp->rx_post_q)))
 678                 free(entry, M_NTB_T);
 679
 680         while ((entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q)))
 681                 free(entry, M_NTB_T);
 682
 683         nt->qp_bitmap &= ~(1 << qp->qp_num);
 684 }
 685
 686 /**
 687  * ntb_transport_create_queue - Create a new NTB transport layer queue
 688  * @rx_handler: receive callback function
 689  * @tx_handler: transmit callback function
 690  * @event_handler: event callback function
 691  *
 692  * Create a new NTB transport layer queue and provide the queue with a callback
 693  * routine for both transmit and receive.  The receive callback routine will be
 694  * used to pass up data when the transport has received it on the queue.   The
 695  * transmit callback routine will be called when the transport has completed the
 696  * transmission of the data on the queue and the data is ready to be freed.
 697  *
 698  * RETURNS: pointer to newly created ntb_queue, NULL on error.
 699  */
 700 struct ntb_transport_qp *
 701 ntb_transport_create_queue(device_t dev, int q,
 702     const struct ntb_queue_handlers *handlers, void *data)
 703 {
 704         struct ntb_transport_child *nc = device_get_ivars(dev);
 705         struct ntb_transport_ctx *nt = device_get_softc(device_get_parent(dev));
 706         struct ntb_queue_entry *entry;
 707         struct ntb_transport_qp *qp;
 708         int i;
 709
 710         if (q < 0 || q >= nc->qpcnt)
 711                 return (NULL);
 712
 713         qp = &nt->qp_vec[nc->qpoff + q];
 714         nt->qp_bitmap |= (1 << qp->qp_num);
 715         qp->cb_data = data;
 716         qp->rx_handler = handlers->rx_handler;
 717         qp->tx_handler = handlers->tx_handler;
 718         qp->event_handler = handlers->event_handler;
 719
 720         for (i = 0; i < NTB_QP_DEF_NUM_ENTRIES; i++) {
 721                 entry = malloc(sizeof(*entry), M_NTB_T, M_WAITOK | M_ZERO);
 722                 entry->cb_data = data;
 723                 entry->buf = NULL;
 724                 entry->len = transport_mtu;
 725                 entry->qp = qp;
 726                 ntb_list_add(&qp->ntb_rx_q_lock, entry, &qp->rx_pend_q);
 727         }
 728
 729         for (i = 0; i < NTB_QP_DEF_NUM_ENTRIES; i++) {
 730                 entry = malloc(sizeof(*entry), M_NTB_T, M_WAITOK | M_ZERO);
 731                 entry->qp = qp;
 732                 ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q);
 733         }
 734
 735         ntb_db_clear(dev, 1ull << qp->qp_num);
 736         return (qp);
 737 }
 738
 739 /**
 740  * ntb_transport_link_up - Notify NTB transport of client readiness to use queue
 741  * @qp: NTB transport layer queue to be enabled
 742  *
 743  * Notify NTB transport layer of client readiness to use queue
 744  */
 745 void
 746 ntb_transport_link_up(struct ntb_transport_qp *qp)
 747 {
 748         struct ntb_transport_ctx *nt = qp->transport;
 749
 750         qp->client_ready = true;
 751
 752         ntb_printf(2, "qp %d client ready\n", qp->qp_num);
 753
 754         if (nt->link_is_up)
 755                 callout_reset(&qp->link_work, 0, ntb_qp_link_work, qp);
 756 }
 757
 758
 759
 760 /* Transport Tx */
 761
 762 /**
 763  * ntb_transport_tx_enqueue - Enqueue a new NTB queue entry
 764  * @qp: NTB transport layer queue the entry is to be enqueued on
 765  * @cb: per buffer pointer for callback function to use
 766  * @data: pointer to data buffer that will be sent
 767  * @len: length of the data buffer
 768  *
 769  * Enqueue a new transmit buffer onto the transport queue from which a NTB
 770  * payload will be transmitted.  This assumes that a lock is being held to
 771  * serialize access to the qp.
 772  *
 773  * RETURNS: An appropriate ERRNO error value on error, or zero for success.
 774  */
 775 int
 776 ntb_transport_tx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
 777     unsigned int len)
 778 {
 779         struct ntb_queue_entry *entry;
 780         int rc;
 781
 782         if (!qp->link_is_up || len == 0) {
 783                 CTR0(KTR_NTB, "TX: link not up");
 784                 return (EINVAL);
 785         }
 786
 787         entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q);
 788         if (entry == NULL) {
 789                 CTR0(KTR_NTB, "TX: could not get entry from tx_free_q");
 790                 qp->tx_err_no_buf++;
 791                 return (EBUSY);
 792         }
 793         CTR1(KTR_NTB, "TX: got entry %p from tx_free_q", entry);
 794
 795         entry->cb_data = cb;
 796         entry->buf = data;
 797         entry->len = len;
 798         entry->flags = 0;
 799
 800         mtx_lock(&qp->tx_lock);
 801         rc = ntb_process_tx(qp, entry);
 802         mtx_unlock(&qp->tx_lock);
 803         if (rc != 0) {
 804                 ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q);
 805                 CTR1(KTR_NTB,
 806                     "TX: process_tx failed. Returning entry %p to tx_free_q",
 807                     entry);
 808         }
 809         return (rc);
 810 }
 811
 812 static void
 813 ntb_tx_copy_callback(void *data)
 814 {
 815         struct ntb_queue_entry *entry = data;
 816         struct ntb_transport_qp *qp = entry->qp;
 817         struct ntb_payload_header *hdr = entry->x_hdr;
 818
 819         iowrite32(entry->flags | NTBT_DESC_DONE_FLAG, &hdr->flags);
 820         CTR1(KTR_NTB, "TX: hdr %p set DESC_DONE", hdr);
 821
 822         ntb_peer_db_set(qp->dev, 1ull << qp->qp_num);
 823
 824         /*
 825          * The entry length can only be zero if the packet is intended to be a
 826          * "link down" or similar.  Since no payload is being sent in these
 827          * cases, there is nothing to add to the completion queue.
 828          */
 829         if (entry->len > 0) {
 830                 qp->tx_bytes += entry->len;
 831
 832                 if (qp->tx_handler)
 833                         qp->tx_handler(qp, qp->cb_data, entry->buf,
 834                             entry->len);
 835                 else
 836                         m_freem(entry->buf);
 837                 entry->buf = NULL;
 838         }
 839
 840         CTR3(KTR_NTB,
 841             "TX: entry %p sent. hdr->ver = %u, hdr->flags = 0x%x, Returning "
 842             "to tx_free_q", entry, hdr->ver, hdr->flags);
 843         ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q);
 844 }
 845
 846 static void
 847 ntb_memcpy_tx(struct ntb_queue_entry *entry, void *offset)
 848 {
 849
 850         CTR2(KTR_NTB, "TX: copying %d bytes to offset %p", entry->len, offset);
 851         if (entry->buf != NULL) {
 852                 m_copydata((struct mbuf *)entry->buf, 0, entry->len, offset);
 853
 854                 /*
 855                  * Ensure that the data is fully copied before setting the
 856                  * flags
 857                  */
 858                 wmb();
 859         }
 860
 861         ntb_tx_copy_callback(entry);
 862 }
 863
 864 static void
 865 ntb_async_tx(struct ntb_transport_qp *qp, struct ntb_queue_entry *entry)
 866 {
 867         struct ntb_payload_header *hdr;
 868         void *offset;
 869
 870         offset = qp->tx_mw + qp->tx_max_frame * qp->tx_index;
 871         hdr = (struct ntb_payload_header *)((char *)offset + qp->tx_max_frame -
 872             sizeof(struct ntb_payload_header));
 873         entry->x_hdr = hdr;
 874
 875         iowrite32(entry->len, &hdr->len);
 876         iowrite32(qp->tx_pkts, &hdr->ver);
 877
 878         ntb_memcpy_tx(entry, offset);
 879 }
 880
 881 static int
 882 ntb_process_tx(struct ntb_transport_qp *qp, struct ntb_queue_entry *entry)
 883 {
 884
 885         CTR3(KTR_NTB,
 886             "TX: process_tx: tx_pkts=%lu, tx_index=%u, remote entry=%u",
 887             qp->tx_pkts, qp->tx_index, qp->remote_rx_info->entry);
 888         if (qp->tx_index == qp->remote_rx_info->entry) {
 889                 CTR0(KTR_NTB, "TX: ring full");
 890                 qp->tx_ring_full++;
 891                 return (EAGAIN);
 892         }
 893
 894         if (entry->len > qp->tx_max_frame - sizeof(struct ntb_payload_header)) {
 895                 if (qp->tx_handler != NULL)
 896                         qp->tx_handler(qp, qp->cb_data, entry->buf,
 897                             EIO);
 898                 else
 899                         m_freem(entry->buf);
 900
 901                 entry->buf = NULL;
 902                 ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q);
 903                 CTR1(KTR_NTB,
 904                     "TX: frame too big. returning entry %p to tx_free_q",
 905                     entry);
 906                 return (0);
 907         }
 908         CTR2(KTR_NTB, "TX: copying entry %p to index %u", entry, qp->tx_index);
 909         ntb_async_tx(qp, entry);
 910
 911         qp->tx_index++;
 912         qp->tx_index %= qp->tx_max_entry;
 913
 914         qp->tx_pkts++;
 915
 916         return (0);
 917 }
 918
 919 /* Transport Rx */
 920 static void
 921 ntb_transport_rxc_db(void *arg, int pending __unused)
 922 {
 923         struct ntb_transport_qp *qp = arg;
 924         uint64_t qp_mask = 1ull << qp->qp_num;
 925         int rc;
 926
 927         CTR0(KTR_NTB, "RX: transport_rx");
 928 again:
 929         while ((rc = ntb_process_rxc(qp)) == 0)
 930                 ;
 931         CTR1(KTR_NTB, "RX: process_rxc returned %d", rc);
 932
 933         if ((ntb_db_read(qp->dev) & qp_mask) != 0) {
 934                 /* If db is set, clear it and check queue once more. */
 935                 ntb_db_clear(qp->dev, qp_mask);
 936                 goto again;
 937         }
 938         if (qp->link_is_up)
 939                 ntb_db_clear_mask(qp->dev, qp_mask);
 940 }
 941
 942 static int
 943 ntb_process_rxc(struct ntb_transport_qp *qp)
 944 {
 945         struct ntb_payload_header *hdr;
 946         struct ntb_queue_entry *entry;
 947         caddr_t offset;
 948
 949         offset = qp->rx_buff + qp->rx_max_frame * qp->rx_index;
 950         hdr = (void *)(offset + qp->rx_max_frame -
 951             sizeof(struct ntb_payload_header));
 952
 953         CTR1(KTR_NTB, "RX: process_rxc rx_index = %u", qp->rx_index);
 954         if ((hdr->flags & NTBT_DESC_DONE_FLAG) == 0) {
 955                 CTR0(KTR_NTB, "RX: hdr not done");
 956                 qp->rx_ring_empty++;
 957                 return (EAGAIN);
 958         }
 959
 960         if ((hdr->flags & NTBT_LINK_DOWN_FLAG) != 0) {
 961                 CTR0(KTR_NTB, "RX: link down");
 962                 ntb_qp_link_down(qp);
 963                 hdr->flags = 0;
 964                 return (EAGAIN);
 965         }
 966
 967         if (hdr->ver != (uint32_t)qp->rx_pkts) {
 968                 CTR2(KTR_NTB,"RX: ver != rx_pkts (%x != %lx). "
 969                     "Returning entry to rx_pend_q", hdr->ver, qp->rx_pkts);
 970                 qp->rx_err_ver++;
 971                 return (EIO);
 972         }
 973
 974         entry = ntb_list_mv(&qp->ntb_rx_q_lock, &qp->rx_pend_q, &qp->rx_post_q);
 975         if (entry == NULL) {
 976                 qp->rx_err_no_buf++;
 977                 CTR0(KTR_NTB, "RX: No entries in rx_pend_q");
 978                 return (EAGAIN);
 979         }
 980         callout_stop(&qp->rx_full);
 981         CTR1(KTR_NTB, "RX: rx entry %p from rx_pend_q", entry);
 982
 983         entry->x_hdr = hdr;
 984         entry->index = qp->rx_index;
 985
 986         if (hdr->len > entry->len) {
 987                 CTR2(KTR_NTB, "RX: len too long. Wanted %ju got %ju",
 988                     (uintmax_t)hdr->len, (uintmax_t)entry->len);
 989                 qp->rx_err_oflow++;
 990
 991                 entry->len = -EIO;
 992                 entry->flags |= NTBT_DESC_DONE_FLAG;
 993
 994                 ntb_complete_rxc(qp);
 995         } else {
 996                 qp->rx_bytes += hdr->len;
 997                 qp->rx_pkts++;
 998
 999                 CTR1(KTR_NTB, "RX: received %ld rx_pkts", qp->rx_pkts);
1000
1001                 entry->len = hdr->len;
1002
1003                 ntb_memcpy_rx(qp, entry, offset);
1004         }
1005
1006         qp->rx_index++;
1007         qp->rx_index %= qp->rx_max_entry;
1008         return (0);
1009 }
1010
1011 static void
1012 ntb_memcpy_rx(struct ntb_transport_qp *qp, struct ntb_queue_entry *entry,
1013     void *offset)
1014 {
1015         struct ifnet *ifp = entry->cb_data;
1016         unsigned int len = entry->len;
1017
1018         CTR2(KTR_NTB, "RX: copying %d bytes from offset %p", len, offset);
1019
1020         entry->buf = (void *)m_devget(offset, len, 0, ifp, NULL);
1021         if (entry->buf == NULL)
1022                 entry->len = -ENOMEM;
1023
1024         /* Ensure that the data is globally visible before clearing the flag */
1025         wmb();
1026
1027         CTR2(KTR_NTB, "RX: copied entry %p to mbuf %p.", entry, entry->buf);
1028         ntb_rx_copy_callback(qp, entry);
1029 }
1030
1031 static inline void
1032 ntb_rx_copy_callback(struct ntb_transport_qp *qp, void *data)
1033 {
1034         struct ntb_queue_entry *entry;
1035
1036         entry = data;
1037         entry->flags |= NTBT_DESC_DONE_FLAG;
1038         ntb_complete_rxc(qp);
1039 }
1040
1041 static void
1042 ntb_complete_rxc(struct ntb_transport_qp *qp)
1043 {
1044         struct ntb_queue_entry *entry;
1045         struct mbuf *m;
1046         unsigned len;
1047
1048         CTR0(KTR_NTB, "RX: rx_completion_task");
1049
1050         mtx_lock_spin(&qp->ntb_rx_q_lock);
1051
1052         while (!STAILQ_EMPTY(&qp->rx_post_q)) {
1053                 entry = STAILQ_FIRST(&qp->rx_post_q);
1054                 if ((entry->flags & NTBT_DESC_DONE_FLAG) == 0)
1055                         break;
1056
1057                 entry->x_hdr->flags = 0;
1058                 iowrite32(entry->index, &qp->rx_info->entry);
1059
1060                 STAILQ_REMOVE_HEAD(&qp->rx_post_q, entry);
1061
1062                 len = entry->len;
1063                 m = entry->buf;
1064
1065                 /*
1066                  * Re-initialize queue_entry for reuse; rx_handler takes
1067                  * ownership of the mbuf.
1068                  */
1069                 entry->buf = NULL;
1070                 entry->len = transport_mtu;
1071                 entry->cb_data = qp->cb_data;
1072
1073                 STAILQ_INSERT_TAIL(&qp->rx_pend_q, entry, entry);
1074
1075                 mtx_unlock_spin(&qp->ntb_rx_q_lock);
1076
1077                 CTR2(KTR_NTB, "RX: completing entry %p, mbuf %p", entry, m);
1078                 if (qp->rx_handler != NULL && qp->client_ready)
1079                         qp->rx_handler(qp, qp->cb_data, m, len);
1080                 else
1081                         m_freem(m);
1082
1083                 mtx_lock_spin(&qp->ntb_rx_q_lock);
1084         }
1085
1086         mtx_unlock_spin(&qp->ntb_rx_q_lock);
1087 }
1088
1089 static void
1090 ntb_transport_doorbell_callback(void *data, uint32_t vector)
1091 {
1092         struct ntb_transport_ctx *nt = data;
1093         struct ntb_transport_qp *qp;
1094         uint64_t vec_mask;
1095         unsigned qp_num;
1096
1097         vec_mask = ntb_db_vector_mask(nt->dev, vector);
1098         vec_mask &= nt->qp_bitmap;
1099         if ((vec_mask & (vec_mask - 1)) != 0)
1100                 vec_mask &= ntb_db_read(nt->dev);
1101         if (vec_mask != 0) {
1102                 ntb_db_set_mask(nt->dev, vec_mask);
1103                 ntb_db_clear(nt->dev, vec_mask);
1104         }
1105         while (vec_mask != 0) {
1106                 qp_num = ffsll(vec_mask) - 1;
1107
1108                 qp = &nt->qp_vec[qp_num];
1109                 if (qp->link_is_up)
1110                         taskqueue_enqueue(qp->rxc_tq, &qp->rxc_db_work);
1111
1112                 vec_mask &= ~(1ull << qp_num);
1113         }
1114 }
1115
1116 /* Link Event handler */
1117 static void
1118 ntb_transport_event_callback(void *data)
1119 {
1120         struct ntb_transport_ctx *nt = data;
1121
1122         if (ntb_link_is_up(nt->dev, &nt->link_speed, &nt->link_width)) {
1123                 ntb_printf(1, "HW link up\n");
1124                 callout_reset(&nt->link_work, 0, ntb_transport_link_work, nt);
1125         } else {
1126                 ntb_printf(1, "HW link down\n");
1127                 taskqueue_enqueue(taskqueue_swi, &nt->link_cleanup);
1128         }
1129 }
1130
1131 /* Link bring up */
1132 static void
1133 ntb_transport_link_work(void *arg)
1134 {
1135         struct ntb_transport_ctx *nt = arg;
1136         struct ntb_transport_mw *mw;
1137         device_t dev = nt->dev;
1138         struct ntb_transport_qp *qp;
1139         uint64_t val64, size;
1140         uint32_t val;
1141         unsigned i;
1142         int rc;
1143
1144         /* send the local info, in the opposite order of the way we read it */
1145         if (nt->compact) {
1146                 for (i = 0; i < nt->mw_count; i++) {
1147                         size = nt->mw_vec[i].tx_size;
1148                         KASSERT(size <= UINT32_MAX, ("size too big (%jx)", size));
1149                         ntb_peer_spad_write(dev, NTBTC_MW0_SZ + i, size);
1150                 }
1151                 ntb_peer_spad_write(dev, NTBTC_QP_LINKS, 0);
1152                 ntb_peer_spad_write(dev, NTBTC_PARAMS,
1153                     (nt->qp_count << 24) | (nt->mw_count << 16) |
1154                     NTB_TRANSPORT_VERSION);
1155         } else {
1156                 for (i = 0; i < nt->mw_count; i++) {
1157                         size = nt->mw_vec[i].tx_size;
1158                         ntb_peer_spad_write(dev, NTBT_MW0_SZ_HIGH + (i * 2),
1159                             size >> 32);
1160                         ntb_peer_spad_write(dev, NTBT_MW0_SZ_LOW + (i * 2), size);
1161                 }
1162                 ntb_peer_spad_write(dev, NTBT_NUM_MWS, nt->mw_count);
1163                 ntb_peer_spad_write(dev, NTBT_NUM_QPS, nt->qp_count);
1164                 ntb_peer_spad_write(dev, NTBT_QP_LINKS, 0);
1165                 ntb_peer_spad_write(dev, NTBT_VERSION, NTB_TRANSPORT_VERSION);
1166         }
1167
1168         /* Query the remote side for its info */
1169         val = 0;
1170         if (nt->compact) {
1171                 ntb_spad_read(dev, NTBTC_PARAMS, &val);
1172                 if (val != ((nt->qp_count << 24) | (nt->mw_count << 16) |
1173                     NTB_TRANSPORT_VERSION))
1174                         goto out;
1175         } else {
1176                 ntb_spad_read(dev, NTBT_VERSION, &val);
1177                 if (val != NTB_TRANSPORT_VERSION)
1178                         goto out;
1179
1180                 ntb_spad_read(dev, NTBT_NUM_QPS, &val);
1181                 if (val != nt->qp_count)
1182                         goto out;
1183
1184                 ntb_spad_read(dev, NTBT_NUM_MWS, &val);
1185                 if (val != nt->mw_count)
1186                         goto out;
1187         }
1188
1189         for (i = 0; i < nt->mw_count; i++) {
1190                 if (nt->compact) {
1191                         ntb_spad_read(dev, NTBTC_MW0_SZ + i, &val);
1192                         val64 = val;
1193                 } else {
1194                         ntb_spad_read(dev, NTBT_MW0_SZ_HIGH + (i * 2), &val);
1195                         val64 = (uint64_t)val << 32;
1196
1197                         ntb_spad_read(dev, NTBT_MW0_SZ_LOW + (i * 2), &val);
1198                         val64 |= val;
1199                 }
1200
1201                 mw = &nt->mw_vec[i];
1202                 mw->rx_size = val64;
1203                 val64 = roundup(val64, mw->xlat_align_size);
1204                 if (mw->buff_size != val64) {
1205
1206                         rc = ntb_set_mw(nt, i, val64);
1207                         if (rc != 0) {
1208                                 ntb_printf(0, "link up set mw%d fails, rc %d\n",
1209                                     i, rc);
1210                                 goto free_mws;
1211                         }
1212
1213                         /* Notify HW the memory location of the receive buffer */
1214                         rc = ntb_mw_set_trans(nt->dev, i, mw->dma_addr,
1215                             mw->buff_size);
1216                         if (rc != 0) {
1217                                 ntb_printf(0, "link up mw%d xlat fails, rc %d\n",
1218                                      i, rc);
1219                                 goto free_mws;
1220                         }
1221                 }
1222         }
1223
1224         nt->link_is_up = true;
1225         ntb_printf(1, "transport link up\n");
1226
1227         for (i = 0; i < nt->qp_count; i++) {
1228                 qp = &nt->qp_vec[i];
1229
1230                 ntb_transport_setup_qp_mw(nt, i);
1231
1232                 if (qp->client_ready)
1233                         callout_reset(&qp->link_work, 0, ntb_qp_link_work, qp);
1234         }
1235
1236         return;
1237
1238 free_mws:
1239         for (i = 0; i < nt->mw_count; i++)
1240                 ntb_free_mw(nt, i);
1241 out:
1242         if (ntb_link_is_up(dev, &nt->link_speed, &nt->link_width))
1243                 callout_reset(&nt->link_work,
1244                     NTB_LINK_DOWN_TIMEOUT * hz / 1000, ntb_transport_link_work, nt);
1245 }
1246
1247 struct ntb_load_cb_args {
1248         bus_addr_t addr;
1249         int error;
1250 };
1251
1252 static void
1253 ntb_load_cb(void *xsc, bus_dma_segment_t *segs, int nsegs, int error)
1254 {
1255         struct ntb_load_cb_args *cba = (struct ntb_load_cb_args *)xsc;
1256
1257         if (!(cba->error = error))
1258                 cba->addr = segs[0].ds_addr;
1259 }
1260
1261 static int
1262 ntb_set_mw(struct ntb_transport_ctx *nt, int num_mw, size_t size)
1263 {
1264         struct ntb_transport_mw *mw = &nt->mw_vec[num_mw];
1265         struct ntb_load_cb_args cba;
1266         size_t buff_size;
1267
1268         if (size == 0)
1269                 return (EINVAL);
1270
1271         buff_size = roundup(size, mw->xlat_align_size);
1272
1273         /* No need to re-setup */
1274         if (mw->buff_size == buff_size)
1275                 return (0);
1276
1277         if (mw->buff_size != 0)
1278                 ntb_free_mw(nt, num_mw);
1279
1280         /* Alloc memory for receiving data.  Must be aligned */
1281         mw->buff_size = buff_size;
1282
1283         if (bus_dma_tag_create(bus_get_dma_tag(nt->dev), mw->xlat_align, 0,
1284             mw->addr_limit, BUS_SPACE_MAXADDR,
1285             NULL, NULL, mw->buff_size, 1, mw->buff_size,
1286             0, NULL, NULL, &mw->dma_tag)) {
1287                 ntb_printf(0, "Unable to create MW tag of size %zu\n",
1288                     mw->buff_size);
1289                 mw->buff_size = 0;
1290                 return (ENOMEM);
1291         }
1292         if (bus_dmamem_alloc(mw->dma_tag, (void **)&mw->virt_addr,
1293             BUS_DMA_WAITOK | BUS_DMA_ZERO, &mw->dma_map)) {
1294                 bus_dma_tag_destroy(mw->dma_tag);
1295                 ntb_printf(0, "Unable to allocate MW buffer of size %zu\n",
1296                     mw->buff_size);
1297                 mw->buff_size = 0;
1298                 return (ENOMEM);
1299         }
1300         if (bus_dmamap_load(mw->dma_tag, mw->dma_map, mw->virt_addr,
1301             mw->buff_size, ntb_load_cb, &cba, BUS_DMA_NOWAIT) || cba.error) {
1302                 bus_dmamem_free(mw->dma_tag, mw->virt_addr, mw->dma_map);
1303                 bus_dma_tag_destroy(mw->dma_tag);
1304                 ntb_printf(0, "Unable to load MW buffer of size %zu\n",
1305                     mw->buff_size);
1306                 mw->buff_size = 0;
1307                 return (ENOMEM);
1308         }
1309         mw->dma_addr = cba.addr;
1310
1311         return (0);
1312 }
1313
1314 static void
1315 ntb_free_mw(struct ntb_transport_ctx *nt, int num_mw)
1316 {
1317         struct ntb_transport_mw *mw = &nt->mw_vec[num_mw];
1318
1319         if (mw->virt_addr == NULL)
1320                 return;
1321
1322         ntb_mw_clear_trans(nt->dev, num_mw);
1323         bus_dmamap_unload(mw->dma_tag, mw->dma_map);
1324         bus_dmamem_free(mw->dma_tag, mw->virt_addr, mw->dma_map);
1325         bus_dma_tag_destroy(mw->dma_tag);
1326         mw->buff_size = 0;
1327         mw->virt_addr = NULL;
1328 }
1329
1330 static int
1331 ntb_transport_setup_qp_mw(struct ntb_transport_ctx *nt, unsigned int qp_num)
1332 {
1333         struct ntb_transport_qp *qp = &nt->qp_vec[qp_num];
1334         struct ntb_transport_mw *mw;
1335         void *offset;
1336         ntb_q_idx_t i;
1337         size_t rx_size;
1338         unsigned num_qps_mw, mw_num, mw_count;
1339
1340         mw_count = nt->mw_count;
1341         mw_num = QP_TO_MW(nt, qp_num);
1342         mw = &nt->mw_vec[mw_num];
1343
1344         if (mw->virt_addr == NULL)
1345                 return (ENOMEM);
1346
1347         if (mw_num < nt->qp_count % mw_count)
1348                 num_qps_mw = nt->qp_count / mw_count + 1;
1349         else
1350                 num_qps_mw = nt->qp_count / mw_count;
1351
1352         rx_size = mw->rx_size / num_qps_mw;
1353         qp->rx_buff = mw->virt_addr + rx_size * (qp_num / mw_count);
1354         rx_size -= sizeof(struct ntb_rx_info);
1355
1356         qp->remote_rx_info = (void*)(qp->rx_buff + rx_size);
1357
1358         /* Due to house-keeping, there must be at least 2 buffs */
1359         qp->rx_max_frame = qmin(transport_mtu, rx_size / 2);
1360         qp->rx_max_entry = rx_size / qp->rx_max_frame;
1361         qp->rx_index = 0;
1362
1363         qp->remote_rx_info->entry = qp->rx_max_entry - 1;
1364
1365         /* Set up the hdr offsets with 0s */
1366         for (i = 0; i < qp->rx_max_entry; i++) {
1367                 offset = (void *)(qp->rx_buff + qp->rx_max_frame * (i + 1) -
1368                     sizeof(struct ntb_payload_header));
1369                 memset(offset, 0, sizeof(struct ntb_payload_header));
1370         }
1371
1372         qp->rx_pkts = 0;
1373         qp->tx_pkts = 0;
1374         qp->tx_index = 0;
1375
1376         return (0);
1377 }
1378
1379 static void
1380 ntb_qp_link_work(void *arg)
1381 {
1382         struct ntb_transport_qp *qp = arg;
1383         device_t dev = qp->dev;
1384         struct ntb_transport_ctx *nt = qp->transport;
1385         int i;
1386         uint32_t val;
1387
1388         /* Report queues that are up on our side */
1389         for (i = 0, val = 0; i < nt->qp_count; i++) {
1390                 if (nt->qp_vec[i].client_ready)
1391                         val |= (1 << i);
1392         }
1393         ntb_peer_spad_write(dev, NTBT_QP_LINKS, val);
1394
1395         /* See if the remote side is up */
1396         ntb_spad_read(dev, NTBT_QP_LINKS, &val);
1397         if ((val & (1ull << qp->qp_num)) != 0) {
1398                 ntb_printf(2, "qp %d link up\n", qp->qp_num);
1399                 qp->link_is_up = true;
1400
1401                 if (qp->event_handler != NULL)
1402                         qp->event_handler(qp->cb_data, NTB_LINK_UP);
1403
1404                 ntb_db_clear_mask(dev, 1ull << qp->qp_num);
1405         } else if (nt->link_is_up)
1406                 callout_reset(&qp->link_work,
1407                     NTB_LINK_DOWN_TIMEOUT * hz / 1000, ntb_qp_link_work, qp);
1408 }
1409
1410 /* Link down event*/
1411 static void
1412 ntb_transport_link_cleanup(struct ntb_transport_ctx *nt)
1413 {
1414         struct ntb_transport_qp *qp;
1415         int i;
1416
1417         callout_drain(&nt->link_work);
1418         nt->link_is_up = 0;
1419
1420         /* Pass along the info to any clients */
1421         for (i = 0; i < nt->qp_count; i++) {
1422                 if ((nt->qp_bitmap & (1 << i)) != 0) {
1423                         qp = &nt->qp_vec[i];
1424                         ntb_qp_link_cleanup(qp);
1425                         callout_drain(&qp->link_work);
1426                 }
1427         }
1428
1429         /*
1430          * The scratchpad registers keep the values if the remote side
1431          * goes down, blast them now to give them a sane value the next
1432          * time they are accessed
1433          */
1434         ntb_spad_clear(nt->dev);
1435 }
1436
1437 static void
1438 ntb_transport_link_cleanup_work(void *arg, int pending __unused)
1439 {
1440
1441         ntb_transport_link_cleanup(arg);
1442 }
1443
1444 static void
1445 ntb_qp_link_down(struct ntb_transport_qp *qp)
1446 {
1447
1448         ntb_qp_link_cleanup(qp);
1449 }
1450
1451 static void
1452 ntb_qp_link_down_reset(struct ntb_transport_qp *qp)
1453 {
1454
1455         qp->link_is_up = false;
1456         ntb_db_set_mask(qp->dev, 1ull << qp->qp_num);
1457
1458         qp->tx_index = qp->rx_index = 0;
1459         qp->tx_bytes = qp->rx_bytes = 0;
1460         qp->tx_pkts = qp->rx_pkts = 0;
1461
1462         qp->rx_ring_empty = 0;
1463         qp->tx_ring_full = 0;
1464
1465         qp->rx_err_no_buf = qp->tx_err_no_buf = 0;
1466         qp->rx_err_oflow = qp->rx_err_ver = 0;
1467 }
1468
1469 static void
1470 ntb_qp_link_cleanup(struct ntb_transport_qp *qp)
1471 {
1472
1473         callout_drain(&qp->link_work);
1474         ntb_qp_link_down_reset(qp);
1475
1476         if (qp->event_handler != NULL)
1477                 qp->event_handler(qp->cb_data, NTB_LINK_DOWN);
1478 }
1479
1480 /* Link commanded down */
1481 /**
1482  * ntb_transport_link_down - Notify NTB transport to no longer enqueue data
1483  * @qp: NTB transport layer queue to be disabled
1484  *
1485  * Notify NTB transport layer of client's desire to no longer receive data on
1486  * transport queue specified.  It is the client's responsibility to ensure all
1487  * entries on queue are purged or otherwise handled appropriately.
1488  */
1489 void
1490 ntb_transport_link_down(struct ntb_transport_qp *qp)
1491 {
1492         struct ntb_transport_ctx *nt = qp->transport;
1493         int i;
1494         uint32_t val;
1495
1496         qp->client_ready = false;
1497         for (i = 0, val = 0; i < nt->qp_count; i++) {
1498                 if (nt->qp_vec[i].client_ready)
1499                         val |= (1 << i);
1500         }
1501         ntb_peer_spad_write(qp->dev, NTBT_QP_LINKS, val);
1502
1503         if (qp->link_is_up)
1504                 ntb_send_link_down(qp);
1505         else
1506                 callout_drain(&qp->link_work);
1507 }
1508
1509 /**
1510  * ntb_transport_link_query - Query transport link state
1511  * @qp: NTB transport layer queue to be queried
1512  *
1513  * Query connectivity to the remote system of the NTB transport queue
1514  *
1515  * RETURNS: true for link up or false for link down
1516  */
1517 bool
1518 ntb_transport_link_query(struct ntb_transport_qp *qp)
1519 {
1520
1521         return (qp->link_is_up);
1522 }
1523
1524 /**
1525  * ntb_transport_link_speed - Query transport link speed
1526  * @qp: NTB transport layer queue to be queried
1527  *
1528  * Query connection speed to the remote system of the NTB transport queue
1529  *
1530  * RETURNS: link speed in bits per second
1531  */
1532 uint64_t
1533 ntb_transport_link_speed(struct ntb_transport_qp *qp)
1534 {
1535         struct ntb_transport_ctx *nt = qp->transport;
1536         uint64_t rate;
1537
1538         if (!nt->link_is_up)
1539                 return (0);
1540         switch (nt->link_speed) {
1541         case NTB_SPEED_GEN1:
1542                 rate = 2500000000 * 8 / 10;
1543                 break;
1544         case NTB_SPEED_GEN2:
1545                 rate = 5000000000 * 8 / 10;
1546                 break;
1547         case NTB_SPEED_GEN3:
1548                 rate = 8000000000 * 128 / 130;
1549                 break;
1550         case NTB_SPEED_GEN4:
1551                 rate = 16000000000 * 128 / 130;
1552                 break;
1553         default:
1554                 return (0);
1555         }
1556         if (nt->link_width <= 0)
1557                 return (0);
1558         return (rate * nt->link_width);
1559 }
1560
1561 static void
1562 ntb_send_link_down(struct ntb_transport_qp *qp)
1563 {
1564         struct ntb_queue_entry *entry;
1565         int i, rc;
1566
1567         if (!qp->link_is_up)
1568                 return;
1569
1570         for (i = 0; i < NTB_LINK_DOWN_TIMEOUT; i++) {
1571                 entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q);
1572                 if (entry != NULL)
1573                         break;
1574                 pause("NTB Wait for link down", hz / 10);
1575         }
1576
1577         if (entry == NULL)
1578                 return;
1579
1580         entry->cb_data = NULL;
1581         entry->buf = NULL;
1582         entry->len = 0;
1583         entry->flags = NTBT_LINK_DOWN_FLAG;
1584
1585         mtx_lock(&qp->tx_lock);
1586         rc = ntb_process_tx(qp, entry);
1587         mtx_unlock(&qp->tx_lock);
1588         if (rc != 0)
1589                 printf("ntb: Failed to send link down\n");
1590
1591         ntb_qp_link_down_reset(qp);
1592 }
1593
1594
1595 /* List Management */
1596
1597 static void
1598 ntb_list_add(struct mtx *lock, struct ntb_queue_entry *entry,
1599     struct ntb_queue_list *list)
1600 {
1601
1602         mtx_lock_spin(lock);
1603         STAILQ_INSERT_TAIL(list, entry, entry);
1604         mtx_unlock_spin(lock);
1605 }
1606
1607 static struct ntb_queue_entry *
1608 ntb_list_rm(struct mtx *lock, struct ntb_queue_list *list)
1609 {
1610         struct ntb_queue_entry *entry;
1611
1612         mtx_lock_spin(lock);
1613         if (STAILQ_EMPTY(list)) {
1614                 entry = NULL;
1615                 goto out;
1616         }
1617         entry = STAILQ_FIRST(list);
1618         STAILQ_REMOVE_HEAD(list, entry);
1619 out:
1620         mtx_unlock_spin(lock);
1621
1622         return (entry);
1623 }
1624
1625 static struct ntb_queue_entry *
1626 ntb_list_mv(struct mtx *lock, struct ntb_queue_list *from,
1627     struct ntb_queue_list *to)
1628 {
1629         struct ntb_queue_entry *entry;
1630
1631         mtx_lock_spin(lock);
1632         if (STAILQ_EMPTY(from)) {
1633                 entry = NULL;
1634                 goto out;
1635         }
1636         entry = STAILQ_FIRST(from);
1637         STAILQ_REMOVE_HEAD(from, entry);
1638         STAILQ_INSERT_TAIL(to, entry, entry);
1639
1640 out:
1641         mtx_unlock_spin(lock);
1642         return (entry);
1643 }
1644
1645 /**
1646  * ntb_transport_qp_num - Query the qp number
1647  * @qp: NTB transport layer queue to be queried
1648  *
1649  * Query qp number of the NTB transport queue
1650  *
1651  * RETURNS: a zero based number specifying the qp number
1652  */
1653 unsigned char ntb_transport_qp_num(struct ntb_transport_qp *qp)
1654 {
1655
1656         return (qp->qp_num);
1657 }
1658
1659 /**
1660  * ntb_transport_max_size - Query the max payload size of a qp
1661  * @qp: NTB transport layer queue to be queried
1662  *
1663  * Query the maximum payload size permissible on the given qp
1664  *
1665  * RETURNS: the max payload size of a qp
1666  */
1667 unsigned int
1668 ntb_transport_max_size(struct ntb_transport_qp *qp)
1669 {
1670
1671         return (qp->tx_max_frame - sizeof(struct ntb_payload_header));
1672 }
1673
1674 unsigned int
1675 ntb_transport_tx_free_entry(struct ntb_transport_qp *qp)
1676 {
1677         unsigned int head = qp->tx_index;
1678         unsigned int tail = qp->remote_rx_info->entry;
1679
1680         return (tail >= head ? tail - head : qp->tx_max_entry + tail - head);
1681 }
1682
1683 static device_method_t ntb_transport_methods[] = {
1684         /* Device interface */
1685         DEVMETHOD(device_probe,     ntb_transport_probe),
1686         DEVMETHOD(device_attach,    ntb_transport_attach),
1687         DEVMETHOD(device_detach,    ntb_transport_detach),
1688         /* Bus interface */
1689         DEVMETHOD(bus_child_location_str, ntb_transport_child_location_str),
1690         DEVMETHOD(bus_print_child,  ntb_transport_print_child),
1691         DEVMETHOD_END
1692 };
1693
1694 devclass_t ntb_transport_devclass;
1695 static DEFINE_CLASS_0(ntb_transport, ntb_transport_driver,
1696     ntb_transport_methods, sizeof(struct ntb_transport_ctx));
1697 DRIVER_MODULE(ntb_transport, ntb_hw, ntb_transport_driver,
1698     ntb_transport_devclass, NULL, NULL);
1699 MODULE_DEPEND(ntb_transport, ntb, 1, 1, 1);
1700 MODULE_VERSION(ntb_transport, 1);