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