1e47937d1SCarl Delsey /*- 2e47937d1SCarl Delsey * Copyright (C) 2013 Intel Corporation 3e47937d1SCarl Delsey * All rights reserved. 4e47937d1SCarl Delsey * 5e47937d1SCarl Delsey * Redistribution and use in source and binary forms, with or without 6e47937d1SCarl Delsey * modification, are permitted provided that the following conditions 7e47937d1SCarl Delsey * are met: 8e47937d1SCarl Delsey * 1. Redistributions of source code must retain the above copyright 9e47937d1SCarl Delsey * notice, this list of conditions and the following disclaimer. 10e47937d1SCarl Delsey * 2. Redistributions in binary form must reproduce the above copyright 11e47937d1SCarl Delsey * notice, this list of conditions and the following disclaimer in the 12e47937d1SCarl Delsey * documentation and/or other materials provided with the distribution. 13e47937d1SCarl Delsey * 14e47937d1SCarl Delsey * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15e47937d1SCarl Delsey * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16e47937d1SCarl Delsey * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17e47937d1SCarl Delsey * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18e47937d1SCarl Delsey * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19e47937d1SCarl Delsey * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20e47937d1SCarl Delsey * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21e47937d1SCarl Delsey * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22e47937d1SCarl Delsey * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23e47937d1SCarl Delsey * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24e47937d1SCarl Delsey * SUCH DAMAGE. 25e47937d1SCarl Delsey */ 26e47937d1SCarl Delsey 27e47937d1SCarl Delsey #include <sys/cdefs.h> 28e47937d1SCarl Delsey __FBSDID("$FreeBSD$"); 29e47937d1SCarl Delsey 30e47937d1SCarl Delsey #include <sys/param.h> 31e47937d1SCarl Delsey #include <sys/kernel.h> 32e47937d1SCarl Delsey #include <sys/systm.h> 33b67ddac2SConrad Meyer #include <sys/bitset.h> 34e47937d1SCarl Delsey #include <sys/bus.h> 35e47937d1SCarl Delsey #include <sys/ktr.h> 36737bc501SConrad Meyer #include <sys/limits.h> 37e47937d1SCarl Delsey #include <sys/lock.h> 38e47937d1SCarl Delsey #include <sys/malloc.h> 39e47937d1SCarl Delsey #include <sys/module.h> 40e47937d1SCarl Delsey #include <sys/mutex.h> 41e47937d1SCarl Delsey #include <sys/queue.h> 42e47937d1SCarl Delsey #include <sys/socket.h> 43e47937d1SCarl Delsey #include <sys/sockio.h> 44902362c9SConrad Meyer #include <sys/sysctl.h> 45e47937d1SCarl Delsey #include <sys/taskqueue.h> 46b67ddac2SConrad Meyer 47e47937d1SCarl Delsey #include <net/if.h> 48e47937d1SCarl Delsey #include <net/if_media.h> 49e47937d1SCarl Delsey #include <net/if_types.h> 50e47937d1SCarl Delsey #include <net/if_var.h> 51e47937d1SCarl Delsey #include <net/bpf.h> 52e47937d1SCarl Delsey #include <net/ethernet.h> 53b67ddac2SConrad Meyer 54e47937d1SCarl Delsey #include <vm/vm.h> 55e47937d1SCarl Delsey #include <vm/pmap.h> 56b67ddac2SConrad Meyer 57e47937d1SCarl Delsey #include <machine/bus.h> 58e47937d1SCarl Delsey #include <machine/cpufunc.h> 59e47937d1SCarl Delsey #include <machine/pmap.h> 60e47937d1SCarl Delsey 61e47937d1SCarl Delsey #include "../ntb_hw/ntb_hw.h" 62e47937d1SCarl Delsey 63e47937d1SCarl Delsey /* 64e47937d1SCarl Delsey * The Non-Transparent Bridge (NTB) is a device on some Intel processors that 65e47937d1SCarl Delsey * allows you to connect two systems using a PCI-e link. 66e47937d1SCarl Delsey * 67e47937d1SCarl Delsey * This module contains a protocol for sending and receiving messages, and 68e47937d1SCarl Delsey * exposes that protocol through a simulated ethernet device called ntb. 69e47937d1SCarl Delsey * 70e47937d1SCarl Delsey * NOTE: Much of the code in this module is shared with Linux. Any patches may 71e47937d1SCarl Delsey * be picked up and redistributed in Linux with a dual GPL/BSD license. 72e47937d1SCarl Delsey */ 73e47937d1SCarl Delsey 74b67ddac2SConrad Meyer #define QP_SETSIZE 64 75b67ddac2SConrad Meyer BITSET_DEFINE(_qpset, QP_SETSIZE); 76b67ddac2SConrad Meyer #define test_bit(pos, addr) BIT_ISSET(QP_SETSIZE, (pos), (addr)) 77b67ddac2SConrad Meyer #define set_bit(pos, addr) BIT_SET(QP_SETSIZE, (pos), (addr)) 78b67ddac2SConrad Meyer #define clear_bit(pos, addr) BIT_CLR(QP_SETSIZE, (pos), (addr)) 79b67ddac2SConrad Meyer #define ffs_bit(addr) BIT_FFS(QP_SETSIZE, (addr)) 80e47937d1SCarl Delsey 81e47937d1SCarl Delsey #define KTR_NTB KTR_SPARE3 82e47937d1SCarl Delsey 83e47937d1SCarl Delsey #define NTB_TRANSPORT_VERSION 3 84e47937d1SCarl Delsey #define NTB_RX_MAX_PKTS 64 85e47937d1SCarl Delsey #define NTB_RXQ_SIZE 300 86e47937d1SCarl Delsey 87e47937d1SCarl Delsey static unsigned int transport_mtu = 0x4000 + ETHER_HDR_LEN + ETHER_CRC_LEN; 8859cf83b8SConrad Meyer 89b8a291bdSConrad Meyer static unsigned int max_num_clients; 90b8a291bdSConrad Meyer SYSCTL_UINT(_hw_ntb, OID_AUTO, max_num_clients, CTLFLAG_RDTUN, 91b8a291bdSConrad Meyer &max_num_clients, 0, "Maximum number of NTB transport clients. " 92b8a291bdSConrad Meyer "0 (default) - use all available NTB memory windows; " 93b8a291bdSConrad Meyer "positive integer N - Limit to N memory windows."); 94e47937d1SCarl Delsey 95e47937d1SCarl Delsey STAILQ_HEAD(ntb_queue_list, ntb_queue_entry); 96e47937d1SCarl Delsey 97e47937d1SCarl Delsey struct ntb_queue_entry { 98e47937d1SCarl Delsey /* ntb_queue list reference */ 99e47937d1SCarl Delsey STAILQ_ENTRY(ntb_queue_entry) entry; 100e47937d1SCarl Delsey 101e47937d1SCarl Delsey /* info on data to be transfered */ 102e47937d1SCarl Delsey void *cb_data; 103e47937d1SCarl Delsey void *buf; 104e47937d1SCarl Delsey uint64_t len; 105e47937d1SCarl Delsey uint64_t flags; 106e47937d1SCarl Delsey }; 107e47937d1SCarl Delsey 108e47937d1SCarl Delsey struct ntb_rx_info { 109e47937d1SCarl Delsey unsigned int entry; 110e47937d1SCarl Delsey }; 111e47937d1SCarl Delsey 112e47937d1SCarl Delsey struct ntb_transport_qp { 113e47937d1SCarl Delsey struct ntb_netdev *transport; 114e47937d1SCarl Delsey struct ntb_softc *ntb; 115e47937d1SCarl Delsey 116e47937d1SCarl Delsey void *cb_data; 117e47937d1SCarl Delsey 118e47937d1SCarl Delsey bool client_ready; 119e47937d1SCarl Delsey bool qp_link; 1202a6e50d2SCarl Delsey uint8_t qp_num; /* Only 64 QPs are allowed. 0-63 */ 121e47937d1SCarl Delsey 122e47937d1SCarl Delsey struct ntb_rx_info *rx_info; 123e47937d1SCarl Delsey struct ntb_rx_info *remote_rx_info; 124e47937d1SCarl Delsey 125e47937d1SCarl Delsey void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data, 126e47937d1SCarl Delsey void *data, int len); 127e47937d1SCarl Delsey struct ntb_queue_list tx_free_q; 128e47937d1SCarl Delsey struct mtx ntb_tx_free_q_lock; 129e47937d1SCarl Delsey void *tx_mw; 130e47937d1SCarl Delsey uint64_t tx_index; 131e47937d1SCarl Delsey uint64_t tx_max_entry; 132e47937d1SCarl Delsey uint64_t tx_max_frame; 133e47937d1SCarl Delsey 134e47937d1SCarl Delsey void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data, 135e47937d1SCarl Delsey void *data, int len); 136e47937d1SCarl Delsey struct ntb_queue_list rx_pend_q; 137e47937d1SCarl Delsey struct ntb_queue_list rx_free_q; 138e47937d1SCarl Delsey struct mtx ntb_rx_pend_q_lock; 139e47937d1SCarl Delsey struct mtx ntb_rx_free_q_lock; 140e47937d1SCarl Delsey struct task rx_completion_task; 141e47937d1SCarl Delsey void *rx_buff; 142e47937d1SCarl Delsey uint64_t rx_index; 143e47937d1SCarl Delsey uint64_t rx_max_entry; 144e47937d1SCarl Delsey uint64_t rx_max_frame; 145e47937d1SCarl Delsey 146531c7b99SConrad Meyer void (*event_handler)(void *data, enum ntb_link_event status); 147e47937d1SCarl Delsey struct callout link_work; 148e47937d1SCarl Delsey struct callout queue_full; 149e47937d1SCarl Delsey struct callout rx_full; 150e47937d1SCarl Delsey 151e47937d1SCarl Delsey uint64_t last_rx_no_buf; 152e47937d1SCarl Delsey 153e47937d1SCarl Delsey /* Stats */ 154e47937d1SCarl Delsey uint64_t rx_bytes; 155e47937d1SCarl Delsey uint64_t rx_pkts; 156e47937d1SCarl Delsey uint64_t rx_ring_empty; 157e47937d1SCarl Delsey uint64_t rx_err_no_buf; 158e47937d1SCarl Delsey uint64_t rx_err_oflow; 159e47937d1SCarl Delsey uint64_t rx_err_ver; 160e47937d1SCarl Delsey uint64_t tx_bytes; 161e47937d1SCarl Delsey uint64_t tx_pkts; 162e47937d1SCarl Delsey uint64_t tx_ring_full; 163e47937d1SCarl Delsey }; 164e47937d1SCarl Delsey 165e47937d1SCarl Delsey struct ntb_queue_handlers { 166e47937d1SCarl Delsey void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data, 167e47937d1SCarl Delsey void *data, int len); 168e47937d1SCarl Delsey void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data, 169e47937d1SCarl Delsey void *data, int len); 170531c7b99SConrad Meyer void (*event_handler)(void *data, enum ntb_link_event status); 171e47937d1SCarl Delsey }; 172e47937d1SCarl Delsey 173e47937d1SCarl Delsey 174e47937d1SCarl Delsey struct ntb_transport_mw { 175e47937d1SCarl Delsey size_t size; 176e47937d1SCarl Delsey void *virt_addr; 177e47937d1SCarl Delsey vm_paddr_t dma_addr; 178e47937d1SCarl Delsey }; 179e47937d1SCarl Delsey 180e47937d1SCarl Delsey struct ntb_netdev { 181e47937d1SCarl Delsey struct ntb_softc *ntb; 182e47937d1SCarl Delsey struct ifnet *ifp; 183b8a291bdSConrad Meyer struct ntb_transport_mw mw[NTB_MAX_NUM_MW]; 184e47937d1SCarl Delsey struct ntb_transport_qp *qps; 185b67ddac2SConrad Meyer struct _qpset qp_bitmap; 186b67ddac2SConrad Meyer uint8_t max_qps; 187b67ddac2SConrad Meyer enum ntb_link_event transport_link; 188e47937d1SCarl Delsey struct callout link_work; 189e47937d1SCarl Delsey struct ntb_transport_qp *qp; 190e47937d1SCarl Delsey uint64_t bufsize; 191e47937d1SCarl Delsey u_char eaddr[ETHER_ADDR_LEN]; 192e47937d1SCarl Delsey struct mtx tx_lock; 193e47937d1SCarl Delsey struct mtx rx_lock; 194e47937d1SCarl Delsey }; 195e47937d1SCarl Delsey 196e47937d1SCarl Delsey static struct ntb_netdev net_softc; 197e47937d1SCarl Delsey 198e47937d1SCarl Delsey enum { 199e47937d1SCarl Delsey IF_NTB_DESC_DONE_FLAG = 1 << 0, 200e47937d1SCarl Delsey IF_NTB_LINK_DOWN_FLAG = 1 << 1, 201e47937d1SCarl Delsey }; 202e47937d1SCarl Delsey 203e47937d1SCarl Delsey struct ntb_payload_header { 204e47937d1SCarl Delsey uint64_t ver; 205e47937d1SCarl Delsey uint64_t len; 206e47937d1SCarl Delsey uint64_t flags; 207e47937d1SCarl Delsey }; 208e47937d1SCarl Delsey 209e47937d1SCarl Delsey enum { 21092bbfa50SConrad Meyer /* 21192bbfa50SConrad Meyer * The order of this enum is part of the if_ntb remote protocol. Do 21292bbfa50SConrad Meyer * not reorder without bumping protocol version (and it's probably best 21392bbfa50SConrad Meyer * to keep the protocol in lock-step with the Linux NTB driver. 21492bbfa50SConrad Meyer */ 215e47937d1SCarl Delsey IF_NTB_VERSION = 0, 216e47937d1SCarl Delsey IF_NTB_QP_LINKS, 21792bbfa50SConrad Meyer IF_NTB_NUM_QPS, 21892bbfa50SConrad Meyer IF_NTB_NUM_MWS, 21992bbfa50SConrad Meyer /* 22092bbfa50SConrad Meyer * N.B.: transport_link_work assumes MW1 enums = MW0 + 2. 22192bbfa50SConrad Meyer */ 22292bbfa50SConrad Meyer IF_NTB_MW0_SZ_HIGH, 22392bbfa50SConrad Meyer IF_NTB_MW0_SZ_LOW, 22492bbfa50SConrad Meyer IF_NTB_MW1_SZ_HIGH, 22592bbfa50SConrad Meyer IF_NTB_MW1_SZ_LOW, 226e47937d1SCarl Delsey IF_NTB_MAX_SPAD, 227e47937d1SCarl Delsey }; 228e47937d1SCarl Delsey 22960c996fcSConrad Meyer #define QP_TO_MW(ntb, qp) ((qp) % ntb_mw_count(ntb)) 230e47937d1SCarl Delsey #define NTB_QP_DEF_NUM_ENTRIES 100 231e47937d1SCarl Delsey #define NTB_LINK_DOWN_TIMEOUT 10 232e47937d1SCarl Delsey 233e47937d1SCarl Delsey static int ntb_handle_module_events(struct module *m, int what, void *arg); 234e47937d1SCarl Delsey static int ntb_setup_interface(void); 235e47937d1SCarl Delsey static int ntb_teardown_interface(void); 236e47937d1SCarl Delsey static void ntb_net_init(void *arg); 237e47937d1SCarl Delsey static int ntb_ioctl(struct ifnet *ifp, u_long command, caddr_t data); 238e47937d1SCarl Delsey static void ntb_start(struct ifnet *ifp); 239e47937d1SCarl Delsey static void ntb_net_tx_handler(struct ntb_transport_qp *qp, void *qp_data, 240e47937d1SCarl Delsey void *data, int len); 241e47937d1SCarl Delsey static void ntb_net_rx_handler(struct ntb_transport_qp *qp, void *qp_data, 242e47937d1SCarl Delsey void *data, int len); 243531c7b99SConrad Meyer static void ntb_net_event_handler(void *data, enum ntb_link_event status); 244e47937d1SCarl Delsey static int ntb_transport_init(struct ntb_softc *ntb); 245e47937d1SCarl Delsey static void ntb_transport_free(void *transport); 246e47937d1SCarl Delsey static void ntb_transport_init_queue(struct ntb_netdev *nt, 247e47937d1SCarl Delsey unsigned int qp_num); 248e47937d1SCarl Delsey static void ntb_transport_free_queue(struct ntb_transport_qp *qp); 249e47937d1SCarl Delsey static struct ntb_transport_qp * ntb_transport_create_queue(void *data, 250e47937d1SCarl Delsey struct ntb_softc *pdev, const struct ntb_queue_handlers *handlers); 251e47937d1SCarl Delsey static void ntb_transport_link_up(struct ntb_transport_qp *qp); 252e47937d1SCarl Delsey static int ntb_transport_tx_enqueue(struct ntb_transport_qp *qp, void *cb, 253e47937d1SCarl Delsey void *data, unsigned int len); 254e47937d1SCarl Delsey static int ntb_process_tx(struct ntb_transport_qp *qp, 255e47937d1SCarl Delsey struct ntb_queue_entry *entry); 256e47937d1SCarl Delsey static void ntb_tx_copy_task(struct ntb_transport_qp *qp, 257e47937d1SCarl Delsey struct ntb_queue_entry *entry, void *offset); 258e47937d1SCarl Delsey static void ntb_qp_full(void *arg); 259737bc501SConrad Meyer static int ntb_transport_rxc_db(void *arg, int dummy); 260e47937d1SCarl Delsey static void ntb_rx_pendq_full(void *arg); 261e47937d1SCarl Delsey static int ntb_process_rxc(struct ntb_transport_qp *qp); 262e47937d1SCarl Delsey static void ntb_rx_copy_task(struct ntb_transport_qp *qp, 263e47937d1SCarl Delsey struct ntb_queue_entry *entry, void *offset); 264e47937d1SCarl Delsey static void ntb_rx_completion_task(void *arg, int pending); 265e47937d1SCarl Delsey static void ntb_transport_event_callback(void *data, enum ntb_hw_event event); 266e47937d1SCarl Delsey static void ntb_transport_link_work(void *arg); 267e47937d1SCarl Delsey static int ntb_set_mw(struct ntb_netdev *nt, int num_mw, unsigned int size); 26892bbfa50SConrad Meyer static void ntb_free_mw(struct ntb_netdev *nt, int num_mw); 269e47937d1SCarl Delsey static void ntb_transport_setup_qp_mw(struct ntb_netdev *nt, 270e47937d1SCarl Delsey unsigned int qp_num); 271e47937d1SCarl Delsey static void ntb_qp_link_work(void *arg); 272e47937d1SCarl Delsey static void ntb_transport_link_cleanup(struct ntb_netdev *nt); 273e47937d1SCarl Delsey static void ntb_qp_link_down(struct ntb_transport_qp *qp); 274e47937d1SCarl Delsey static void ntb_qp_link_cleanup(struct ntb_transport_qp *qp); 275e47937d1SCarl Delsey static void ntb_transport_link_down(struct ntb_transport_qp *qp); 276e47937d1SCarl Delsey static void ntb_send_link_down(struct ntb_transport_qp *qp); 277e47937d1SCarl Delsey static void ntb_list_add(struct mtx *lock, struct ntb_queue_entry *entry, 278e47937d1SCarl Delsey struct ntb_queue_list *list); 279e47937d1SCarl Delsey static struct ntb_queue_entry *ntb_list_rm(struct mtx *lock, 280e47937d1SCarl Delsey struct ntb_queue_list *list); 281e47937d1SCarl Delsey static void create_random_local_eui48(u_char *eaddr); 282e47937d1SCarl Delsey static unsigned int ntb_transport_max_size(struct ntb_transport_qp *qp); 283e47937d1SCarl Delsey 284e47937d1SCarl Delsey MALLOC_DEFINE(M_NTB_IF, "if_ntb", "ntb network driver"); 285e47937d1SCarl Delsey 286e47937d1SCarl Delsey /* Module setup and teardown */ 287e47937d1SCarl Delsey static int 288e47937d1SCarl Delsey ntb_handle_module_events(struct module *m, int what, void *arg) 289e47937d1SCarl Delsey { 290e47937d1SCarl Delsey int err = 0; 291e47937d1SCarl Delsey 292e47937d1SCarl Delsey switch (what) { 293e47937d1SCarl Delsey case MOD_LOAD: 294e47937d1SCarl Delsey err = ntb_setup_interface(); 295e47937d1SCarl Delsey break; 296e47937d1SCarl Delsey case MOD_UNLOAD: 297e47937d1SCarl Delsey err = ntb_teardown_interface(); 298e47937d1SCarl Delsey break; 299e47937d1SCarl Delsey default: 300e47937d1SCarl Delsey err = EOPNOTSUPP; 301e47937d1SCarl Delsey break; 302e47937d1SCarl Delsey } 303e47937d1SCarl Delsey return (err); 304e47937d1SCarl Delsey } 305e47937d1SCarl Delsey 30664d95724SCarl Delsey static moduledata_t if_ntb_mod = { 30764d95724SCarl Delsey "if_ntb", 308e47937d1SCarl Delsey ntb_handle_module_events, 309e47937d1SCarl Delsey NULL 310e47937d1SCarl Delsey }; 311e47937d1SCarl Delsey 31264d95724SCarl Delsey DECLARE_MODULE(if_ntb, if_ntb_mod, SI_SUB_KLD, SI_ORDER_ANY); 31364d95724SCarl Delsey MODULE_DEPEND(if_ntb, ntb_hw, 1, 1, 1); 314e47937d1SCarl Delsey 315e47937d1SCarl Delsey static int 316fd95aefdSConrad Meyer ntb_setup_interface(void) 317e47937d1SCarl Delsey { 318e47937d1SCarl Delsey struct ifnet *ifp; 319e47937d1SCarl Delsey struct ntb_queue_handlers handlers = { ntb_net_rx_handler, 320e47937d1SCarl Delsey ntb_net_tx_handler, ntb_net_event_handler }; 321e47937d1SCarl Delsey 322e47937d1SCarl Delsey net_softc.ntb = devclass_get_softc(devclass_find("ntb_hw"), 0); 323e47937d1SCarl Delsey if (net_softc.ntb == NULL) { 3242a6e50d2SCarl Delsey printf("ntb: Cannot find devclass\n"); 325e47937d1SCarl Delsey return (ENXIO); 326e47937d1SCarl Delsey } 327e47937d1SCarl Delsey 328e47937d1SCarl Delsey ntb_transport_init(net_softc.ntb); 329e47937d1SCarl Delsey 330e47937d1SCarl Delsey ifp = net_softc.ifp = if_alloc(IFT_ETHER); 331e47937d1SCarl Delsey if (ifp == NULL) { 332e47937d1SCarl Delsey printf("ntb: cannot allocate ifnet structure\n"); 333e47937d1SCarl Delsey return (ENOMEM); 334e47937d1SCarl Delsey } 335e47937d1SCarl Delsey 336e47937d1SCarl Delsey net_softc.qp = ntb_transport_create_queue(ifp, net_softc.ntb, 337e47937d1SCarl Delsey &handlers); 338e47937d1SCarl Delsey if_initname(ifp, "ntb", 0); 339e47937d1SCarl Delsey ifp->if_init = ntb_net_init; 340e47937d1SCarl Delsey ifp->if_softc = &net_softc; 341e47937d1SCarl Delsey ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX; 342e47937d1SCarl Delsey ifp->if_ioctl = ntb_ioctl; 343e47937d1SCarl Delsey ifp->if_start = ntb_start; 344e47937d1SCarl Delsey IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN); 345e47937d1SCarl Delsey ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN; 346e47937d1SCarl Delsey IFQ_SET_READY(&ifp->if_snd); 347e47937d1SCarl Delsey create_random_local_eui48(net_softc.eaddr); 348e47937d1SCarl Delsey ether_ifattach(ifp, net_softc.eaddr); 349e47937d1SCarl Delsey ifp->if_capabilities = IFCAP_HWCSUM | IFCAP_JUMBO_MTU; 350e47937d1SCarl Delsey ifp->if_capenable = ifp->if_capabilities; 351e47937d1SCarl Delsey 352e47937d1SCarl Delsey ntb_transport_link_up(net_softc.qp); 353e47937d1SCarl Delsey net_softc.bufsize = ntb_transport_max_size(net_softc.qp) + 354e47937d1SCarl Delsey sizeof(struct ether_header); 355e47937d1SCarl Delsey return (0); 356e47937d1SCarl Delsey } 357e47937d1SCarl Delsey 358e47937d1SCarl Delsey static int 359fd95aefdSConrad Meyer ntb_teardown_interface(void) 360e47937d1SCarl Delsey { 361e47937d1SCarl Delsey 362538779c1SCarl Delsey if (net_softc.qp != NULL) 363e47937d1SCarl Delsey ntb_transport_link_down(net_softc.qp); 364e47937d1SCarl Delsey 365538779c1SCarl Delsey if (net_softc.ifp != NULL) { 366538779c1SCarl Delsey ether_ifdetach(net_softc.ifp); 367538779c1SCarl Delsey if_free(net_softc.ifp); 368538779c1SCarl Delsey } 369538779c1SCarl Delsey 370538779c1SCarl Delsey if (net_softc.qp != NULL) { 371e47937d1SCarl Delsey ntb_transport_free_queue(net_softc.qp); 372e47937d1SCarl Delsey ntb_transport_free(&net_softc); 373538779c1SCarl Delsey } 374e47937d1SCarl Delsey 375e47937d1SCarl Delsey return (0); 376e47937d1SCarl Delsey } 377e47937d1SCarl Delsey 378e47937d1SCarl Delsey /* Network device interface */ 379e47937d1SCarl Delsey 380e47937d1SCarl Delsey static void 381e47937d1SCarl Delsey ntb_net_init(void *arg) 382e47937d1SCarl Delsey { 383e47937d1SCarl Delsey struct ntb_netdev *ntb_softc = arg; 384e47937d1SCarl Delsey struct ifnet *ifp = ntb_softc->ifp; 385e47937d1SCarl Delsey 386e47937d1SCarl Delsey ifp->if_drv_flags |= IFF_DRV_RUNNING; 387e47937d1SCarl Delsey ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 388e47937d1SCarl Delsey ifp->if_flags |= IFF_UP; 389e47937d1SCarl Delsey if_link_state_change(ifp, LINK_STATE_UP); 390e47937d1SCarl Delsey } 391e47937d1SCarl Delsey 392e47937d1SCarl Delsey static int 393e47937d1SCarl Delsey ntb_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 394e47937d1SCarl Delsey { 395e47937d1SCarl Delsey struct ntb_netdev *nt = ifp->if_softc; 396e47937d1SCarl Delsey struct ifreq *ifr = (struct ifreq *)data; 397e47937d1SCarl Delsey int error = 0; 398e47937d1SCarl Delsey 399e47937d1SCarl Delsey switch (command) { 400e47937d1SCarl Delsey case SIOCSIFMTU: 401e47937d1SCarl Delsey { 402e47937d1SCarl Delsey if (ifr->ifr_mtu > ntb_transport_max_size(nt->qp) - 403e47937d1SCarl Delsey ETHER_HDR_LEN - ETHER_CRC_LEN) { 404e47937d1SCarl Delsey error = EINVAL; 405e47937d1SCarl Delsey break; 406e47937d1SCarl Delsey } 407e47937d1SCarl Delsey 408e47937d1SCarl Delsey ifp->if_mtu = ifr->ifr_mtu; 409e47937d1SCarl Delsey break; 410e47937d1SCarl Delsey } 411e47937d1SCarl Delsey default: 412e47937d1SCarl Delsey error = ether_ioctl(ifp, command, data); 413e47937d1SCarl Delsey break; 414e47937d1SCarl Delsey } 415e47937d1SCarl Delsey 416e47937d1SCarl Delsey return (error); 417e47937d1SCarl Delsey } 418e47937d1SCarl Delsey 419e47937d1SCarl Delsey 420e47937d1SCarl Delsey static void 421e47937d1SCarl Delsey ntb_start(struct ifnet *ifp) 422e47937d1SCarl Delsey { 423e47937d1SCarl Delsey struct mbuf *m_head; 424e47937d1SCarl Delsey struct ntb_netdev *nt = ifp->if_softc; 425e47937d1SCarl Delsey int rc; 426e47937d1SCarl Delsey 427e47937d1SCarl Delsey mtx_lock(&nt->tx_lock); 428e47937d1SCarl Delsey ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 429e47937d1SCarl Delsey CTR0(KTR_NTB, "TX: ntb_start"); 430e47937d1SCarl Delsey while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) { 431e47937d1SCarl Delsey IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head); 432e47937d1SCarl Delsey CTR1(KTR_NTB, "TX: start mbuf %p", m_head); 433e47937d1SCarl Delsey rc = ntb_transport_tx_enqueue(nt->qp, m_head, m_head, 434e47937d1SCarl Delsey m_length(m_head, NULL)); 435e47937d1SCarl Delsey if (rc != 0) { 436e47937d1SCarl Delsey CTR1(KTR_NTB, 4372a6e50d2SCarl Delsey "TX: could not tx mbuf %p. Returning to snd q", 438e47937d1SCarl Delsey m_head); 439e47937d1SCarl Delsey if (rc == EAGAIN) { 440e47937d1SCarl Delsey ifp->if_drv_flags |= IFF_DRV_OACTIVE; 441e47937d1SCarl Delsey IFQ_DRV_PREPEND(&ifp->if_snd, m_head); 442e47937d1SCarl Delsey callout_reset(&nt->qp->queue_full, hz / 1000, 443e47937d1SCarl Delsey ntb_qp_full, ifp); 444e47937d1SCarl Delsey } 445e47937d1SCarl Delsey break; 446e47937d1SCarl Delsey } 447e47937d1SCarl Delsey 448e47937d1SCarl Delsey } 449e47937d1SCarl Delsey mtx_unlock(&nt->tx_lock); 450e47937d1SCarl Delsey } 451e47937d1SCarl Delsey 452e47937d1SCarl Delsey /* Network Device Callbacks */ 453e47937d1SCarl Delsey static void 454e47937d1SCarl Delsey ntb_net_tx_handler(struct ntb_transport_qp *qp, void *qp_data, void *data, 455e47937d1SCarl Delsey int len) 456e47937d1SCarl Delsey { 457e47937d1SCarl Delsey 458e47937d1SCarl Delsey m_freem(data); 459e47937d1SCarl Delsey CTR1(KTR_NTB, "TX: tx_handler freeing mbuf %p", data); 460e47937d1SCarl Delsey } 461e47937d1SCarl Delsey 462e47937d1SCarl Delsey static void 463e47937d1SCarl Delsey ntb_net_rx_handler(struct ntb_transport_qp *qp, void *qp_data, void *data, 464e47937d1SCarl Delsey int len) 465e47937d1SCarl Delsey { 466e47937d1SCarl Delsey struct mbuf *m = data; 467e47937d1SCarl Delsey struct ifnet *ifp = qp_data; 468e47937d1SCarl Delsey 469e47937d1SCarl Delsey CTR0(KTR_NTB, "RX: rx handler"); 470e47937d1SCarl Delsey (*ifp->if_input)(ifp, m); 471e47937d1SCarl Delsey } 472e47937d1SCarl Delsey 473e47937d1SCarl Delsey static void 474531c7b99SConrad Meyer ntb_net_event_handler(void *data, enum ntb_link_event status) 475e47937d1SCarl Delsey { 476531c7b99SConrad Meyer struct ifnet *ifp; 477e47937d1SCarl Delsey 478531c7b99SConrad Meyer ifp = data; 479531c7b99SConrad Meyer (void)ifp; 480531c7b99SConrad Meyer 481531c7b99SConrad Meyer /* XXX The Linux driver munges with the carrier status here. */ 482531c7b99SConrad Meyer 483531c7b99SConrad Meyer switch (status) { 484531c7b99SConrad Meyer case NTB_LINK_DOWN: 485531c7b99SConrad Meyer break; 486531c7b99SConrad Meyer case NTB_LINK_UP: 487531c7b99SConrad Meyer break; 488531c7b99SConrad Meyer default: 489531c7b99SConrad Meyer panic("Bogus ntb_link_event %u\n", status); 490531c7b99SConrad Meyer } 491e47937d1SCarl Delsey } 492e47937d1SCarl Delsey 493e47937d1SCarl Delsey /* Transport Init and teardown */ 494e47937d1SCarl Delsey 495e47937d1SCarl Delsey static int 496e47937d1SCarl Delsey ntb_transport_init(struct ntb_softc *ntb) 497e47937d1SCarl Delsey { 498e47937d1SCarl Delsey struct ntb_netdev *nt = &net_softc; 499b67ddac2SConrad Meyer int rc; 500b67ddac2SConrad Meyer uint8_t i; 501e47937d1SCarl Delsey 502b8a291bdSConrad Meyer if (max_num_clients == 0) 50360c996fcSConrad Meyer nt->max_qps = MIN(ntb_get_max_cbs(ntb), ntb_mw_count(ntb)); 504b8a291bdSConrad Meyer else 505b8a291bdSConrad Meyer nt->max_qps = MIN(ntb_get_max_cbs(ntb), max_num_clients); 506b8a291bdSConrad Meyer 507e47937d1SCarl Delsey ntb_register_transport(ntb, nt); 508e47937d1SCarl Delsey mtx_init(&nt->tx_lock, "ntb transport tx", NULL, MTX_DEF); 509e47937d1SCarl Delsey mtx_init(&nt->rx_lock, "ntb transport rx", NULL, MTX_DEF); 510e47937d1SCarl Delsey 511e47937d1SCarl Delsey nt->qps = malloc(nt->max_qps * sizeof(struct ntb_transport_qp), 512e47937d1SCarl Delsey M_NTB_IF, M_WAITOK|M_ZERO); 513e47937d1SCarl Delsey 514b67ddac2SConrad Meyer KASSERT(nt->max_qps <= QP_SETSIZE, ("invalid max_qps")); 515e47937d1SCarl Delsey 516b67ddac2SConrad Meyer for (i = 0; i < nt->max_qps; i++) { 517b67ddac2SConrad Meyer set_bit(i, &nt->qp_bitmap); 518e47937d1SCarl Delsey ntb_transport_init_queue(nt, i); 519b67ddac2SConrad Meyer } 520e47937d1SCarl Delsey 521e47937d1SCarl Delsey callout_init(&nt->link_work, 0); 522e47937d1SCarl Delsey 523e47937d1SCarl Delsey rc = ntb_register_event_callback(ntb, 524e47937d1SCarl Delsey ntb_transport_event_callback); 525e47937d1SCarl Delsey if (rc != 0) 526e47937d1SCarl Delsey goto err; 527e47937d1SCarl Delsey 528d43c0fbaSCarl Delsey if (ntb_query_link_status(ntb)) { 529d43c0fbaSCarl Delsey if (bootverbose) 530d43c0fbaSCarl Delsey device_printf(ntb_get_device(ntb), "link up\n"); 531e47937d1SCarl Delsey callout_reset(&nt->link_work, 0, ntb_transport_link_work, nt); 532d43c0fbaSCarl Delsey } 533e47937d1SCarl Delsey 534e47937d1SCarl Delsey return (0); 535e47937d1SCarl Delsey 536e47937d1SCarl Delsey err: 537e47937d1SCarl Delsey free(nt->qps, M_NTB_IF); 538e47937d1SCarl Delsey ntb_unregister_transport(ntb); 539e47937d1SCarl Delsey return (rc); 540e47937d1SCarl Delsey } 541e47937d1SCarl Delsey 542e47937d1SCarl Delsey static void 543e47937d1SCarl Delsey ntb_transport_free(void *transport) 544e47937d1SCarl Delsey { 545e47937d1SCarl Delsey struct ntb_netdev *nt = transport; 546e47937d1SCarl Delsey struct ntb_softc *ntb = nt->ntb; 547b67ddac2SConrad Meyer uint8_t i; 548e47937d1SCarl Delsey 5494d07d562SConrad Meyer ntb_transport_link_cleanup(nt); 550e47937d1SCarl Delsey 551e47937d1SCarl Delsey callout_drain(&nt->link_work); 552e47937d1SCarl Delsey 5532a6e50d2SCarl Delsey /* verify that all the qps are freed */ 554e47937d1SCarl Delsey for (i = 0; i < nt->max_qps; i++) 555e47937d1SCarl Delsey if (!test_bit(i, &nt->qp_bitmap)) 556e47937d1SCarl Delsey ntb_transport_free_queue(&nt->qps[i]); 557e47937d1SCarl Delsey 558e47937d1SCarl Delsey ntb_unregister_event_callback(ntb); 559e47937d1SCarl Delsey 560b8a291bdSConrad Meyer for (i = 0; i < NTB_MAX_NUM_MW; i++) 56192bbfa50SConrad Meyer ntb_free_mw(nt, i); 562e47937d1SCarl Delsey 563e47937d1SCarl Delsey free(nt->qps, M_NTB_IF); 564e47937d1SCarl Delsey ntb_unregister_transport(ntb); 565e47937d1SCarl Delsey } 566e47937d1SCarl Delsey 567e47937d1SCarl Delsey static void 568e47937d1SCarl Delsey ntb_transport_init_queue(struct ntb_netdev *nt, unsigned int qp_num) 569e47937d1SCarl Delsey { 570e47937d1SCarl Delsey struct ntb_transport_qp *qp; 571e47937d1SCarl Delsey unsigned int num_qps_mw, tx_size; 572b8a291bdSConrad Meyer uint8_t mw_num, mw_max; 573b8a291bdSConrad Meyer 57460c996fcSConrad Meyer mw_max = ntb_mw_count(nt->ntb); 575b8a291bdSConrad Meyer mw_num = QP_TO_MW(nt->ntb, qp_num); 576e47937d1SCarl Delsey 577e47937d1SCarl Delsey qp = &nt->qps[qp_num]; 578e47937d1SCarl Delsey qp->qp_num = qp_num; 579e47937d1SCarl Delsey qp->transport = nt; 580e47937d1SCarl Delsey qp->ntb = nt->ntb; 581e47937d1SCarl Delsey qp->qp_link = NTB_LINK_DOWN; 582e47937d1SCarl Delsey qp->client_ready = NTB_LINK_DOWN; 583e47937d1SCarl Delsey qp->event_handler = NULL; 584e47937d1SCarl Delsey 585b8a291bdSConrad Meyer if (nt->max_qps % mw_max && mw_num + 1 < nt->max_qps / mw_max) 586b8a291bdSConrad Meyer num_qps_mw = nt->max_qps / mw_max + 1; 587e47937d1SCarl Delsey else 588b8a291bdSConrad Meyer num_qps_mw = nt->max_qps / mw_max; 589e47937d1SCarl Delsey 590e47937d1SCarl Delsey tx_size = (unsigned int) ntb_get_mw_size(qp->ntb, mw_num) / num_qps_mw; 591e47937d1SCarl Delsey qp->rx_info = (struct ntb_rx_info *) 592e47937d1SCarl Delsey ((char *)ntb_get_mw_vbase(qp->ntb, mw_num) + 593b8a291bdSConrad Meyer (qp_num / mw_max * tx_size)); 594e47937d1SCarl Delsey tx_size -= sizeof(struct ntb_rx_info); 595e47937d1SCarl Delsey 596262d9f67SConrad Meyer qp->tx_mw = qp->rx_info + 1; 5977ee9e4bcSConrad Meyer /* Due to house-keeping, there must be at least 2 buffs */ 598e47937d1SCarl Delsey qp->tx_max_frame = min(transport_mtu + sizeof(struct ntb_payload_header), 5997ee9e4bcSConrad Meyer tx_size / 2); 600e47937d1SCarl Delsey qp->tx_max_entry = tx_size / qp->tx_max_frame; 601e47937d1SCarl Delsey 602e47937d1SCarl Delsey callout_init(&qp->link_work, 0); 603fd90e2edSJung-uk Kim callout_init(&qp->queue_full, 1); 604fd90e2edSJung-uk Kim callout_init(&qp->rx_full, 1); 605e47937d1SCarl Delsey 606e47937d1SCarl Delsey mtx_init(&qp->ntb_rx_pend_q_lock, "ntb rx pend q", NULL, MTX_SPIN); 607e47937d1SCarl Delsey mtx_init(&qp->ntb_rx_free_q_lock, "ntb rx free q", NULL, MTX_SPIN); 608e47937d1SCarl Delsey mtx_init(&qp->ntb_tx_free_q_lock, "ntb tx free q", NULL, MTX_SPIN); 609e47937d1SCarl Delsey TASK_INIT(&qp->rx_completion_task, 0, ntb_rx_completion_task, qp); 610e47937d1SCarl Delsey 611e47937d1SCarl Delsey STAILQ_INIT(&qp->rx_pend_q); 612e47937d1SCarl Delsey STAILQ_INIT(&qp->rx_free_q); 613e47937d1SCarl Delsey STAILQ_INIT(&qp->tx_free_q); 614e47937d1SCarl Delsey } 615e47937d1SCarl Delsey 616e47937d1SCarl Delsey static void 617e47937d1SCarl Delsey ntb_transport_free_queue(struct ntb_transport_qp *qp) 618e47937d1SCarl Delsey { 619e47937d1SCarl Delsey struct ntb_queue_entry *entry; 620e47937d1SCarl Delsey 621e47937d1SCarl Delsey if (qp == NULL) 622e47937d1SCarl Delsey return; 623e47937d1SCarl Delsey 624e47937d1SCarl Delsey callout_drain(&qp->link_work); 625e47937d1SCarl Delsey 626e47937d1SCarl Delsey ntb_unregister_db_callback(qp->ntb, qp->qp_num); 627e47937d1SCarl Delsey 628e47937d1SCarl Delsey while ((entry = ntb_list_rm(&qp->ntb_rx_free_q_lock, &qp->rx_free_q))) 629e47937d1SCarl Delsey free(entry, M_NTB_IF); 630e47937d1SCarl Delsey 631e47937d1SCarl Delsey while ((entry = ntb_list_rm(&qp->ntb_rx_pend_q_lock, &qp->rx_pend_q))) 632e47937d1SCarl Delsey free(entry, M_NTB_IF); 633e47937d1SCarl Delsey 634e47937d1SCarl Delsey while ((entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q))) 635e47937d1SCarl Delsey free(entry, M_NTB_IF); 636e47937d1SCarl Delsey 637e47937d1SCarl Delsey set_bit(qp->qp_num, &qp->transport->qp_bitmap); 638e47937d1SCarl Delsey } 639e47937d1SCarl Delsey 640e47937d1SCarl Delsey /** 641e47937d1SCarl Delsey * ntb_transport_create_queue - Create a new NTB transport layer queue 642e47937d1SCarl Delsey * @rx_handler: receive callback function 643e47937d1SCarl Delsey * @tx_handler: transmit callback function 644e47937d1SCarl Delsey * @event_handler: event callback function 645e47937d1SCarl Delsey * 646e47937d1SCarl Delsey * Create a new NTB transport layer queue and provide the queue with a callback 647e47937d1SCarl Delsey * routine for both transmit and receive. The receive callback routine will be 648e47937d1SCarl Delsey * used to pass up data when the transport has received it on the queue. The 649e47937d1SCarl Delsey * transmit callback routine will be called when the transport has completed the 650e47937d1SCarl Delsey * transmission of the data on the queue and the data is ready to be freed. 651e47937d1SCarl Delsey * 652e47937d1SCarl Delsey * RETURNS: pointer to newly created ntb_queue, NULL on error. 653e47937d1SCarl Delsey */ 654e47937d1SCarl Delsey static struct ntb_transport_qp * 655e47937d1SCarl Delsey ntb_transport_create_queue(void *data, struct ntb_softc *pdev, 656e47937d1SCarl Delsey const struct ntb_queue_handlers *handlers) 657e47937d1SCarl Delsey { 658e47937d1SCarl Delsey struct ntb_queue_entry *entry; 659e47937d1SCarl Delsey struct ntb_transport_qp *qp; 660e47937d1SCarl Delsey struct ntb_netdev *nt; 661e47937d1SCarl Delsey unsigned int free_queue; 662e47937d1SCarl Delsey int rc, i; 663e47937d1SCarl Delsey 664e47937d1SCarl Delsey nt = ntb_find_transport(pdev); 665e47937d1SCarl Delsey if (nt == NULL) 666e47937d1SCarl Delsey goto err; 667e47937d1SCarl Delsey 668b67ddac2SConrad Meyer free_queue = ffs_bit(&nt->qp_bitmap); 669e47937d1SCarl Delsey if (free_queue == 0) 670e47937d1SCarl Delsey goto err; 671e47937d1SCarl Delsey 672e47937d1SCarl Delsey /* decrement free_queue to make it zero based */ 673e47937d1SCarl Delsey free_queue--; 674e47937d1SCarl Delsey 675e47937d1SCarl Delsey clear_bit(free_queue, &nt->qp_bitmap); 676e47937d1SCarl Delsey 677e47937d1SCarl Delsey qp = &nt->qps[free_queue]; 678e47937d1SCarl Delsey qp->cb_data = data; 679e47937d1SCarl Delsey qp->rx_handler = handlers->rx_handler; 680e47937d1SCarl Delsey qp->tx_handler = handlers->tx_handler; 681e47937d1SCarl Delsey qp->event_handler = handlers->event_handler; 682e47937d1SCarl Delsey 683e47937d1SCarl Delsey for (i = 0; i < NTB_QP_DEF_NUM_ENTRIES; i++) { 684e47937d1SCarl Delsey entry = malloc(sizeof(struct ntb_queue_entry), M_NTB_IF, 685e47937d1SCarl Delsey M_WAITOK|M_ZERO); 686e47937d1SCarl Delsey entry->cb_data = nt->ifp; 687e47937d1SCarl Delsey entry->buf = NULL; 688e47937d1SCarl Delsey entry->len = transport_mtu; 689e47937d1SCarl Delsey ntb_list_add(&qp->ntb_rx_pend_q_lock, entry, &qp->rx_pend_q); 690e47937d1SCarl Delsey } 691e47937d1SCarl Delsey 692e47937d1SCarl Delsey for (i = 0; i < NTB_QP_DEF_NUM_ENTRIES; i++) { 693e47937d1SCarl Delsey entry = malloc(sizeof(struct ntb_queue_entry), M_NTB_IF, 694e47937d1SCarl Delsey M_WAITOK|M_ZERO); 695e47937d1SCarl Delsey ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q); 696e47937d1SCarl Delsey } 697e47937d1SCarl Delsey 698e47937d1SCarl Delsey rc = ntb_register_db_callback(qp->ntb, free_queue, qp, 699e47937d1SCarl Delsey ntb_transport_rxc_db); 700e47937d1SCarl Delsey if (rc != 0) 701e47937d1SCarl Delsey goto err1; 702e47937d1SCarl Delsey 703e47937d1SCarl Delsey return (qp); 704e47937d1SCarl Delsey 705e47937d1SCarl Delsey err1: 706e47937d1SCarl Delsey while ((entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q))) 707e47937d1SCarl Delsey free(entry, M_NTB_IF); 708e47937d1SCarl Delsey while ((entry = ntb_list_rm(&qp->ntb_rx_free_q_lock, &qp->rx_free_q))) 709e47937d1SCarl Delsey free(entry, M_NTB_IF); 710e47937d1SCarl Delsey set_bit(free_queue, &nt->qp_bitmap); 711e47937d1SCarl Delsey err: 712e47937d1SCarl Delsey return (NULL); 713e47937d1SCarl Delsey } 714e47937d1SCarl Delsey 715e47937d1SCarl Delsey /** 716e47937d1SCarl Delsey * ntb_transport_link_up - Notify NTB transport of client readiness to use queue 717e47937d1SCarl Delsey * @qp: NTB transport layer queue to be enabled 718e47937d1SCarl Delsey * 719e47937d1SCarl Delsey * Notify NTB transport layer of client readiness to use queue 720e47937d1SCarl Delsey */ 721e47937d1SCarl Delsey static void 722e47937d1SCarl Delsey ntb_transport_link_up(struct ntb_transport_qp *qp) 723e47937d1SCarl Delsey { 724e47937d1SCarl Delsey 725e47937d1SCarl Delsey if (qp == NULL) 726e47937d1SCarl Delsey return; 727e47937d1SCarl Delsey 728e47937d1SCarl Delsey qp->client_ready = NTB_LINK_UP; 729d43c0fbaSCarl Delsey if (bootverbose) 730d43c0fbaSCarl Delsey device_printf(ntb_get_device(qp->ntb), "qp client ready\n"); 731e47937d1SCarl Delsey 732e47937d1SCarl Delsey if (qp->transport->transport_link == NTB_LINK_UP) 733e47937d1SCarl Delsey callout_reset(&qp->link_work, 0, ntb_qp_link_work, qp); 734e47937d1SCarl Delsey } 735e47937d1SCarl Delsey 736e47937d1SCarl Delsey 737e47937d1SCarl Delsey 738e47937d1SCarl Delsey /* Transport Tx */ 739e47937d1SCarl Delsey 740e47937d1SCarl Delsey /** 741e47937d1SCarl Delsey * ntb_transport_tx_enqueue - Enqueue a new NTB queue entry 742e47937d1SCarl Delsey * @qp: NTB transport layer queue the entry is to be enqueued on 743e47937d1SCarl Delsey * @cb: per buffer pointer for callback function to use 744e47937d1SCarl Delsey * @data: pointer to data buffer that will be sent 745e47937d1SCarl Delsey * @len: length of the data buffer 746e47937d1SCarl Delsey * 747e47937d1SCarl Delsey * Enqueue a new transmit buffer onto the transport queue from which a NTB 7482c6fb1deSConrad Meyer * payload will be transmitted. This assumes that a lock is being held to 749e47937d1SCarl Delsey * serialize access to the qp. 750e47937d1SCarl Delsey * 751e47937d1SCarl Delsey * RETURNS: An appropriate ERRNO error value on error, or zero for success. 752e47937d1SCarl Delsey */ 753e47937d1SCarl Delsey static int 754e47937d1SCarl Delsey ntb_transport_tx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data, 755e47937d1SCarl Delsey unsigned int len) 756e47937d1SCarl Delsey { 757e47937d1SCarl Delsey struct ntb_queue_entry *entry; 758e47937d1SCarl Delsey int rc; 759e47937d1SCarl Delsey 760e47937d1SCarl Delsey if (qp == NULL || qp->qp_link != NTB_LINK_UP || len == 0) { 761e47937d1SCarl Delsey CTR0(KTR_NTB, "TX: link not up"); 762e47937d1SCarl Delsey return (EINVAL); 763e47937d1SCarl Delsey } 764e47937d1SCarl Delsey 765e47937d1SCarl Delsey entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q); 766e47937d1SCarl Delsey if (entry == NULL) { 7672a6e50d2SCarl Delsey CTR0(KTR_NTB, "TX: could not get entry from tx_free_q"); 768e47937d1SCarl Delsey return (ENOMEM); 769e47937d1SCarl Delsey } 770e47937d1SCarl Delsey CTR1(KTR_NTB, "TX: got entry %p from tx_free_q", entry); 771e47937d1SCarl Delsey 772e47937d1SCarl Delsey entry->cb_data = cb; 773e47937d1SCarl Delsey entry->buf = data; 774e47937d1SCarl Delsey entry->len = len; 775e47937d1SCarl Delsey entry->flags = 0; 776e47937d1SCarl Delsey 777e47937d1SCarl Delsey rc = ntb_process_tx(qp, entry); 778e47937d1SCarl Delsey if (rc != 0) { 779e47937d1SCarl Delsey ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q); 780e47937d1SCarl Delsey CTR1(KTR_NTB, 781e47937d1SCarl Delsey "TX: process_tx failed. Returning entry %p to tx_free_q", 782e47937d1SCarl Delsey entry); 783e47937d1SCarl Delsey } 784e47937d1SCarl Delsey return (rc); 785e47937d1SCarl Delsey } 786e47937d1SCarl Delsey 787e47937d1SCarl Delsey static int 788e47937d1SCarl Delsey ntb_process_tx(struct ntb_transport_qp *qp, struct ntb_queue_entry *entry) 789e47937d1SCarl Delsey { 790e47937d1SCarl Delsey void *offset; 791e47937d1SCarl Delsey 792e47937d1SCarl Delsey offset = (char *)qp->tx_mw + qp->tx_max_frame * qp->tx_index; 793e47937d1SCarl Delsey CTR3(KTR_NTB, 794e47937d1SCarl Delsey "TX: process_tx: tx_pkts=%u, tx_index=%u, remote entry=%u", 795e47937d1SCarl Delsey qp->tx_pkts, qp->tx_index, qp->remote_rx_info->entry); 796e47937d1SCarl Delsey if (qp->tx_index == qp->remote_rx_info->entry) { 797e47937d1SCarl Delsey CTR0(KTR_NTB, "TX: ring full"); 798e47937d1SCarl Delsey qp->tx_ring_full++; 799e47937d1SCarl Delsey return (EAGAIN); 800e47937d1SCarl Delsey } 801e47937d1SCarl Delsey 802e47937d1SCarl Delsey if (entry->len > qp->tx_max_frame - sizeof(struct ntb_payload_header)) { 803e47937d1SCarl Delsey if (qp->tx_handler != NULL) 804e47937d1SCarl Delsey qp->tx_handler(qp, qp->cb_data, entry->buf, 805e47937d1SCarl Delsey EIO); 806e47937d1SCarl Delsey 807e47937d1SCarl Delsey ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q); 808e47937d1SCarl Delsey CTR1(KTR_NTB, 809e47937d1SCarl Delsey "TX: frame too big. returning entry %p to tx_free_q", 810e47937d1SCarl Delsey entry); 811e47937d1SCarl Delsey return (0); 812e47937d1SCarl Delsey } 813e47937d1SCarl Delsey CTR2(KTR_NTB, "TX: copying entry %p to offset %p", entry, offset); 814e47937d1SCarl Delsey ntb_tx_copy_task(qp, entry, offset); 815e47937d1SCarl Delsey 816e47937d1SCarl Delsey qp->tx_index++; 817e47937d1SCarl Delsey qp->tx_index %= qp->tx_max_entry; 818e47937d1SCarl Delsey 819e47937d1SCarl Delsey qp->tx_pkts++; 820e47937d1SCarl Delsey 821e47937d1SCarl Delsey return (0); 822e47937d1SCarl Delsey } 823e47937d1SCarl Delsey 824e47937d1SCarl Delsey static void 825e47937d1SCarl Delsey ntb_tx_copy_task(struct ntb_transport_qp *qp, struct ntb_queue_entry *entry, 826e47937d1SCarl Delsey void *offset) 827e47937d1SCarl Delsey { 828e47937d1SCarl Delsey struct ntb_payload_header *hdr; 829e47937d1SCarl Delsey 830e47937d1SCarl Delsey CTR2(KTR_NTB, "TX: copying %d bytes to offset %p", entry->len, offset); 831e47937d1SCarl Delsey if (entry->buf != NULL) 832e47937d1SCarl Delsey m_copydata((struct mbuf *)entry->buf, 0, entry->len, offset); 833e47937d1SCarl Delsey 834e47937d1SCarl Delsey hdr = (struct ntb_payload_header *)((char *)offset + qp->tx_max_frame - 835e47937d1SCarl Delsey sizeof(struct ntb_payload_header)); 836e47937d1SCarl Delsey hdr->len = entry->len; /* TODO: replace with bus_space_write */ 837e47937d1SCarl Delsey hdr->ver = qp->tx_pkts; /* TODO: replace with bus_space_write */ 838e47937d1SCarl Delsey wmb(); 839e47937d1SCarl Delsey /* TODO: replace with bus_space_write */ 840e47937d1SCarl Delsey hdr->flags = entry->flags | IF_NTB_DESC_DONE_FLAG; 841e47937d1SCarl Delsey 8421d9352afSConrad Meyer ntb_ring_doorbell(qp->ntb, qp->qp_num); 843e47937d1SCarl Delsey 844e47937d1SCarl Delsey /* 845e47937d1SCarl Delsey * The entry length can only be zero if the packet is intended to be a 846e47937d1SCarl Delsey * "link down" or similar. Since no payload is being sent in these 847e47937d1SCarl Delsey * cases, there is nothing to add to the completion queue. 848e47937d1SCarl Delsey */ 849e47937d1SCarl Delsey if (entry->len > 0) { 850e47937d1SCarl Delsey qp->tx_bytes += entry->len; 851e47937d1SCarl Delsey 852e47937d1SCarl Delsey if (qp->tx_handler) 853e47937d1SCarl Delsey qp->tx_handler(qp, qp->cb_data, entry->cb_data, 854e47937d1SCarl Delsey entry->len); 855e47937d1SCarl Delsey } 856e47937d1SCarl Delsey 857e47937d1SCarl Delsey CTR2(KTR_NTB, 858e47937d1SCarl Delsey "TX: entry %p sent. hdr->ver = %d, Returning to tx_free_q", entry, 859e47937d1SCarl Delsey hdr->ver); 860e47937d1SCarl Delsey ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q); 861e47937d1SCarl Delsey } 862e47937d1SCarl Delsey 863e47937d1SCarl Delsey static void 864e47937d1SCarl Delsey ntb_qp_full(void *arg) 865e47937d1SCarl Delsey { 866e47937d1SCarl Delsey 867e47937d1SCarl Delsey CTR0(KTR_NTB, "TX: qp_full callout"); 868e47937d1SCarl Delsey ntb_start(arg); 869e47937d1SCarl Delsey } 870e47937d1SCarl Delsey 871e47937d1SCarl Delsey /* Transport Rx */ 872e47937d1SCarl Delsey static void 873e47937d1SCarl Delsey ntb_rx_pendq_full(void *arg) 874e47937d1SCarl Delsey { 875e47937d1SCarl Delsey 876e47937d1SCarl Delsey CTR0(KTR_NTB, "RX: ntb_rx_pendq_full callout"); 877737bc501SConrad Meyer ntb_transport_rxc_db(arg, 0); 878e47937d1SCarl Delsey } 879e47937d1SCarl Delsey 880737bc501SConrad Meyer static int 881737bc501SConrad Meyer ntb_transport_rxc_db(void *arg, int dummy __unused) 882e47937d1SCarl Delsey { 883737bc501SConrad Meyer struct ntb_transport_qp *qp = arg; 884ae92db9eSConrad Meyer uint64_t i; 885ae92db9eSConrad Meyer int rc; 886e47937d1SCarl Delsey 887e47937d1SCarl Delsey /* 888e47937d1SCarl Delsey * Limit the number of packets processed in a single interrupt to 889e47937d1SCarl Delsey * provide fairness to others 890e47937d1SCarl Delsey */ 891e47937d1SCarl Delsey mtx_lock(&qp->transport->rx_lock); 892e47937d1SCarl Delsey CTR0(KTR_NTB, "RX: transport_rx"); 893737bc501SConrad Meyer for (i = 0; i < MIN(qp->rx_max_entry, INT_MAX); i++) { 894e47937d1SCarl Delsey rc = ntb_process_rxc(qp); 895e47937d1SCarl Delsey if (rc != 0) { 896e47937d1SCarl Delsey CTR0(KTR_NTB, "RX: process_rxc failed"); 897e47937d1SCarl Delsey break; 898e47937d1SCarl Delsey } 899e47937d1SCarl Delsey } 900e47937d1SCarl Delsey mtx_unlock(&qp->transport->rx_lock); 901737bc501SConrad Meyer 902737bc501SConrad Meyer return ((int)i); 903e47937d1SCarl Delsey } 904e47937d1SCarl Delsey 905e47937d1SCarl Delsey static int 906e47937d1SCarl Delsey ntb_process_rxc(struct ntb_transport_qp *qp) 907e47937d1SCarl Delsey { 908e47937d1SCarl Delsey struct ntb_payload_header *hdr; 909e47937d1SCarl Delsey struct ntb_queue_entry *entry; 910e47937d1SCarl Delsey void *offset; 911e47937d1SCarl Delsey 912e47937d1SCarl Delsey offset = (void *) 913e47937d1SCarl Delsey ((char *)qp->rx_buff + qp->rx_max_frame * qp->rx_index); 914e47937d1SCarl Delsey hdr = (void *) 915e47937d1SCarl Delsey ((char *)offset + qp->rx_max_frame - 916e47937d1SCarl Delsey sizeof(struct ntb_payload_header)); 917e47937d1SCarl Delsey 918e47937d1SCarl Delsey CTR1(KTR_NTB, "RX: process_rxc rx_index = %u", qp->rx_index); 919e47937d1SCarl Delsey entry = ntb_list_rm(&qp->ntb_rx_pend_q_lock, &qp->rx_pend_q); 920e47937d1SCarl Delsey if (entry == NULL) { 921e47937d1SCarl Delsey qp->rx_err_no_buf++; 922e47937d1SCarl Delsey CTR0(KTR_NTB, "RX: No entries in rx_pend_q"); 923e47937d1SCarl Delsey return (ENOMEM); 924e47937d1SCarl Delsey } 925e47937d1SCarl Delsey callout_stop(&qp->rx_full); 926e47937d1SCarl Delsey CTR1(KTR_NTB, "RX: rx entry %p from rx_pend_q", entry); 927e47937d1SCarl Delsey 928e47937d1SCarl Delsey if ((hdr->flags & IF_NTB_DESC_DONE_FLAG) == 0) { 929e47937d1SCarl Delsey CTR1(KTR_NTB, 930e47937d1SCarl Delsey "RX: hdr not done. Returning entry %p to rx_pend_q", entry); 931e47937d1SCarl Delsey ntb_list_add(&qp->ntb_rx_pend_q_lock, entry, &qp->rx_pend_q); 932e47937d1SCarl Delsey qp->rx_ring_empty++; 933e47937d1SCarl Delsey return (EAGAIN); 934e47937d1SCarl Delsey } 935e47937d1SCarl Delsey 936e47937d1SCarl Delsey if (hdr->ver != (uint32_t) qp->rx_pkts) { 937e47937d1SCarl Delsey CTR3(KTR_NTB,"RX: ver != rx_pkts (%x != %lx). " 938e47937d1SCarl Delsey "Returning entry %p to rx_pend_q", hdr->ver, qp->rx_pkts, 939e47937d1SCarl Delsey entry); 940e47937d1SCarl Delsey ntb_list_add(&qp->ntb_rx_pend_q_lock, entry, &qp->rx_pend_q); 941e47937d1SCarl Delsey qp->rx_err_ver++; 942e47937d1SCarl Delsey return (EIO); 943e47937d1SCarl Delsey } 944e47937d1SCarl Delsey 945e47937d1SCarl Delsey if ((hdr->flags & IF_NTB_LINK_DOWN_FLAG) != 0) { 946e47937d1SCarl Delsey ntb_qp_link_down(qp); 947e47937d1SCarl Delsey CTR1(KTR_NTB, 948e47937d1SCarl Delsey "RX: link down. adding entry %p back to rx_pend_q", entry); 949e47937d1SCarl Delsey ntb_list_add(&qp->ntb_rx_pend_q_lock, entry, &qp->rx_pend_q); 950e47937d1SCarl Delsey goto out; 951e47937d1SCarl Delsey } 952e47937d1SCarl Delsey 953e47937d1SCarl Delsey if (hdr->len <= entry->len) { 954e47937d1SCarl Delsey entry->len = hdr->len; 955e47937d1SCarl Delsey ntb_rx_copy_task(qp, entry, offset); 956e47937d1SCarl Delsey } else { 957e47937d1SCarl Delsey CTR1(KTR_NTB, 958e47937d1SCarl Delsey "RX: len too long. Returning entry %p to rx_pend_q", entry); 959e47937d1SCarl Delsey ntb_list_add(&qp->ntb_rx_pend_q_lock, entry, &qp->rx_pend_q); 960e47937d1SCarl Delsey 961e47937d1SCarl Delsey qp->rx_err_oflow++; 962e47937d1SCarl Delsey } 963e47937d1SCarl Delsey 964e47937d1SCarl Delsey qp->rx_bytes += hdr->len; 965e47937d1SCarl Delsey qp->rx_pkts++; 966e47937d1SCarl Delsey CTR1(KTR_NTB, "RX: received %ld rx_pkts", qp->rx_pkts); 967e47937d1SCarl Delsey 968e47937d1SCarl Delsey 969e47937d1SCarl Delsey out: 970e47937d1SCarl Delsey /* Ensure that the data is globally visible before clearing the flag */ 971e47937d1SCarl Delsey wmb(); 972e47937d1SCarl Delsey hdr->flags = 0; 973e47937d1SCarl Delsey /* TODO: replace with bus_space_write */ 974e47937d1SCarl Delsey qp->rx_info->entry = qp->rx_index; 975e47937d1SCarl Delsey 976e47937d1SCarl Delsey qp->rx_index++; 977e47937d1SCarl Delsey qp->rx_index %= qp->rx_max_entry; 978e47937d1SCarl Delsey 979e47937d1SCarl Delsey return (0); 980e47937d1SCarl Delsey } 981e47937d1SCarl Delsey 982e47937d1SCarl Delsey static void 983e47937d1SCarl Delsey ntb_rx_copy_task(struct ntb_transport_qp *qp, struct ntb_queue_entry *entry, 984e47937d1SCarl Delsey void *offset) 985e47937d1SCarl Delsey { 986e47937d1SCarl Delsey struct ifnet *ifp = entry->cb_data; 987e47937d1SCarl Delsey unsigned int len = entry->len; 988e47937d1SCarl Delsey struct mbuf *m; 989e47937d1SCarl Delsey 990e47937d1SCarl Delsey CTR2(KTR_NTB, "RX: copying %d bytes from offset %p", len, offset); 991e47937d1SCarl Delsey m = m_devget(offset, len, 0, ifp, NULL); 992e47937d1SCarl Delsey m->m_pkthdr.csum_flags = CSUM_IP_CHECKED | CSUM_IP_VALID; 993e47937d1SCarl Delsey 994e47937d1SCarl Delsey entry->buf = (void *)m; 995e47937d1SCarl Delsey 996e47937d1SCarl Delsey CTR2(KTR_NTB, 997e47937d1SCarl Delsey "RX: copied entry %p to mbuf %p. Adding entry to rx_free_q", entry, 998e47937d1SCarl Delsey m); 999e47937d1SCarl Delsey ntb_list_add(&qp->ntb_rx_free_q_lock, entry, &qp->rx_free_q); 1000e47937d1SCarl Delsey 1001e47937d1SCarl Delsey taskqueue_enqueue(taskqueue_swi, &qp->rx_completion_task); 1002e47937d1SCarl Delsey } 1003e47937d1SCarl Delsey 1004e47937d1SCarl Delsey static void 1005e47937d1SCarl Delsey ntb_rx_completion_task(void *arg, int pending) 1006e47937d1SCarl Delsey { 1007e47937d1SCarl Delsey struct ntb_transport_qp *qp = arg; 1008e47937d1SCarl Delsey struct mbuf *m; 1009e47937d1SCarl Delsey struct ntb_queue_entry *entry; 1010e47937d1SCarl Delsey 1011e47937d1SCarl Delsey CTR0(KTR_NTB, "RX: rx_completion_task"); 1012e47937d1SCarl Delsey 1013e47937d1SCarl Delsey while ((entry = ntb_list_rm(&qp->ntb_rx_free_q_lock, &qp->rx_free_q))) { 1014e47937d1SCarl Delsey m = entry->buf; 1015e47937d1SCarl Delsey CTR2(KTR_NTB, "RX: completing entry %p, mbuf %p", entry, m); 1016e47937d1SCarl Delsey if (qp->rx_handler && qp->client_ready == NTB_LINK_UP) 1017e47937d1SCarl Delsey qp->rx_handler(qp, qp->cb_data, m, entry->len); 1018e47937d1SCarl Delsey 1019e47937d1SCarl Delsey entry->buf = NULL; 1020e47937d1SCarl Delsey entry->len = qp->transport->bufsize; 1021e47937d1SCarl Delsey 1022e47937d1SCarl Delsey CTR1(KTR_NTB,"RX: entry %p removed from rx_free_q " 1023e47937d1SCarl Delsey "and added to rx_pend_q", entry); 1024e47937d1SCarl Delsey ntb_list_add(&qp->ntb_rx_pend_q_lock, entry, &qp->rx_pend_q); 1025e47937d1SCarl Delsey if (qp->rx_err_no_buf > qp->last_rx_no_buf) { 1026e47937d1SCarl Delsey qp->last_rx_no_buf = qp->rx_err_no_buf; 1027e47937d1SCarl Delsey CTR0(KTR_NTB, "RX: could spawn rx task"); 1028e47937d1SCarl Delsey callout_reset(&qp->rx_full, hz / 1000, ntb_rx_pendq_full, 1029e47937d1SCarl Delsey qp); 1030e47937d1SCarl Delsey } 1031e47937d1SCarl Delsey } 1032e47937d1SCarl Delsey } 1033e47937d1SCarl Delsey 1034e47937d1SCarl Delsey /* Link Event handler */ 1035e47937d1SCarl Delsey static void 1036e47937d1SCarl Delsey ntb_transport_event_callback(void *data, enum ntb_hw_event event) 1037e47937d1SCarl Delsey { 1038e47937d1SCarl Delsey struct ntb_netdev *nt = data; 1039e47937d1SCarl Delsey 1040e47937d1SCarl Delsey switch (event) { 1041e47937d1SCarl Delsey case NTB_EVENT_HW_LINK_UP: 1042d43c0fbaSCarl Delsey if (bootverbose) 1043d43c0fbaSCarl Delsey device_printf(ntb_get_device(nt->ntb), "HW link up\n"); 1044e47937d1SCarl Delsey callout_reset(&nt->link_work, 0, ntb_transport_link_work, nt); 1045e47937d1SCarl Delsey break; 1046e47937d1SCarl Delsey case NTB_EVENT_HW_LINK_DOWN: 1047d43c0fbaSCarl Delsey if (bootverbose) 1048d43c0fbaSCarl Delsey device_printf(ntb_get_device(nt->ntb), "HW link down\n"); 1049e47937d1SCarl Delsey ntb_transport_link_cleanup(nt); 1050e47937d1SCarl Delsey break; 1051e47937d1SCarl Delsey default: 1052e47937d1SCarl Delsey panic("ntb: Unknown NTB event"); 1053e47937d1SCarl Delsey } 1054e47937d1SCarl Delsey } 1055e47937d1SCarl Delsey 1056e47937d1SCarl Delsey /* Link bring up */ 1057e47937d1SCarl Delsey static void 1058e47937d1SCarl Delsey ntb_transport_link_work(void *arg) 1059e47937d1SCarl Delsey { 1060e47937d1SCarl Delsey struct ntb_netdev *nt = arg; 1061e47937d1SCarl Delsey struct ntb_softc *ntb = nt->ntb; 1062e47937d1SCarl Delsey struct ntb_transport_qp *qp; 106392bbfa50SConrad Meyer uint64_t val64; 106459cf83b8SConrad Meyer uint32_t val, i, num_mw; 106559cf83b8SConrad Meyer int rc; 106659cf83b8SConrad Meyer 106760c996fcSConrad Meyer num_mw = ntb_mw_count(ntb); 1068e47937d1SCarl Delsey 106992bbfa50SConrad Meyer /* send the local info, in the opposite order of the way we read it */ 107059cf83b8SConrad Meyer for (i = 0; i < num_mw; i++) { 107192bbfa50SConrad Meyer rc = ntb_write_remote_spad(ntb, IF_NTB_MW0_SZ_HIGH + (i * 2), 1072e26b6f00SConrad Meyer (uint64_t)ntb_get_mw_size(ntb, i) >> 32); 1073e47937d1SCarl Delsey if (rc != 0) 1074e47937d1SCarl Delsey goto out; 1075e47937d1SCarl Delsey 107692bbfa50SConrad Meyer rc = ntb_write_remote_spad(ntb, IF_NTB_MW0_SZ_LOW + (i * 2), 107792bbfa50SConrad Meyer (uint32_t)ntb_get_mw_size(ntb, i)); 1078e47937d1SCarl Delsey if (rc != 0) 1079e47937d1SCarl Delsey goto out; 108092bbfa50SConrad Meyer } 1081e47937d1SCarl Delsey 108259cf83b8SConrad Meyer rc = ntb_write_remote_spad(ntb, IF_NTB_NUM_MWS, num_mw); 1083e47937d1SCarl Delsey if (rc != 0) 1084e47937d1SCarl Delsey goto out; 1085e47937d1SCarl Delsey 1086e47937d1SCarl Delsey rc = ntb_write_remote_spad(ntb, IF_NTB_NUM_QPS, nt->max_qps); 1087e47937d1SCarl Delsey if (rc != 0) 1088e47937d1SCarl Delsey goto out; 1089e47937d1SCarl Delsey 109092bbfa50SConrad Meyer rc = ntb_write_remote_spad(ntb, IF_NTB_VERSION, NTB_TRANSPORT_VERSION); 1091e47937d1SCarl Delsey if (rc != 0) 1092e47937d1SCarl Delsey goto out; 1093e47937d1SCarl Delsey 1094e47937d1SCarl Delsey /* Query the remote side for its info */ 1095e47937d1SCarl Delsey rc = ntb_read_local_spad(ntb, IF_NTB_VERSION, &val); 1096e47937d1SCarl Delsey if (rc != 0) 1097e47937d1SCarl Delsey goto out; 1098e47937d1SCarl Delsey 1099e47937d1SCarl Delsey if (val != NTB_TRANSPORT_VERSION) 1100e47937d1SCarl Delsey goto out; 1101e47937d1SCarl Delsey 1102e47937d1SCarl Delsey rc = ntb_read_local_spad(ntb, IF_NTB_NUM_QPS, &val); 1103e47937d1SCarl Delsey if (rc != 0) 1104e47937d1SCarl Delsey goto out; 1105e47937d1SCarl Delsey 1106e47937d1SCarl Delsey if (val != nt->max_qps) 1107e47937d1SCarl Delsey goto out; 1108e47937d1SCarl Delsey 110992bbfa50SConrad Meyer rc = ntb_read_local_spad(ntb, IF_NTB_NUM_MWS, &val); 1110e47937d1SCarl Delsey if (rc != 0) 1111e47937d1SCarl Delsey goto out; 1112e47937d1SCarl Delsey 111359cf83b8SConrad Meyer if (val != num_mw) 1114e47937d1SCarl Delsey goto out; 1115e47937d1SCarl Delsey 111659cf83b8SConrad Meyer for (i = 0; i < num_mw; i++) { 111792bbfa50SConrad Meyer rc = ntb_read_local_spad(ntb, IF_NTB_MW0_SZ_HIGH + (i * 2), 111892bbfa50SConrad Meyer &val); 1119e47937d1SCarl Delsey if (rc != 0) 112092bbfa50SConrad Meyer goto free_mws; 1121e47937d1SCarl Delsey 112292bbfa50SConrad Meyer val64 = (uint64_t)val << 32; 112392bbfa50SConrad Meyer 112492bbfa50SConrad Meyer rc = ntb_read_local_spad(ntb, IF_NTB_MW0_SZ_LOW + (i * 2), 112592bbfa50SConrad Meyer &val); 1126e47937d1SCarl Delsey if (rc != 0) 112792bbfa50SConrad Meyer goto free_mws; 1128e47937d1SCarl Delsey 112992bbfa50SConrad Meyer val64 |= val; 1130e47937d1SCarl Delsey 113192bbfa50SConrad Meyer rc = ntb_set_mw(nt, i, val64); 1132e47937d1SCarl Delsey if (rc != 0) 113392bbfa50SConrad Meyer goto free_mws; 113492bbfa50SConrad Meyer } 1135e47937d1SCarl Delsey 1136e47937d1SCarl Delsey nt->transport_link = NTB_LINK_UP; 1137d43c0fbaSCarl Delsey if (bootverbose) 1138d43c0fbaSCarl Delsey device_printf(ntb_get_device(ntb), "transport link up\n"); 1139e47937d1SCarl Delsey 1140e47937d1SCarl Delsey for (i = 0; i < nt->max_qps; i++) { 1141e47937d1SCarl Delsey qp = &nt->qps[i]; 1142e47937d1SCarl Delsey 1143e47937d1SCarl Delsey ntb_transport_setup_qp_mw(nt, i); 1144e47937d1SCarl Delsey 1145e47937d1SCarl Delsey if (qp->client_ready == NTB_LINK_UP) 1146e47937d1SCarl Delsey callout_reset(&qp->link_work, 0, ntb_qp_link_work, qp); 1147e47937d1SCarl Delsey } 1148e47937d1SCarl Delsey 1149e47937d1SCarl Delsey return; 1150e47937d1SCarl Delsey 115192bbfa50SConrad Meyer free_mws: 1152b8a291bdSConrad Meyer for (i = 0; i < NTB_MAX_NUM_MW; i++) 115392bbfa50SConrad Meyer ntb_free_mw(nt, i); 1154e47937d1SCarl Delsey out: 1155e47937d1SCarl Delsey if (ntb_query_link_status(ntb)) 1156e47937d1SCarl Delsey callout_reset(&nt->link_work, 1157e47937d1SCarl Delsey NTB_LINK_DOWN_TIMEOUT * hz / 1000, ntb_transport_link_work, nt); 1158e47937d1SCarl Delsey } 1159e47937d1SCarl Delsey 1160e47937d1SCarl Delsey static int 1161e47937d1SCarl Delsey ntb_set_mw(struct ntb_netdev *nt, int num_mw, unsigned int size) 1162e47937d1SCarl Delsey { 1163e47937d1SCarl Delsey struct ntb_transport_mw *mw = &nt->mw[num_mw]; 1164e47937d1SCarl Delsey 11650125f2c1SConrad Meyer /* No need to re-setup */ 11660125f2c1SConrad Meyer if (mw->size == size) 11670125f2c1SConrad Meyer return (0); 11680125f2c1SConrad Meyer 11690125f2c1SConrad Meyer if (mw->size != 0) 11700125f2c1SConrad Meyer ntb_free_mw(nt, num_mw); 11710125f2c1SConrad Meyer 1172e47937d1SCarl Delsey /* Alloc memory for receiving data. Must be 4k aligned */ 1173e47937d1SCarl Delsey mw->size = size; 1174e47937d1SCarl Delsey 1175e47937d1SCarl Delsey mw->virt_addr = contigmalloc(mw->size, M_NTB_IF, M_ZERO, 0, 1176e47937d1SCarl Delsey BUS_SPACE_MAXADDR, mw->size, 0); 1177e47937d1SCarl Delsey if (mw->virt_addr == NULL) { 11780125f2c1SConrad Meyer mw->size = 0; 1179d957796cSConrad Meyer printf("ntb: Unable to allocate MW buffer of size %zu\n", 1180d957796cSConrad Meyer mw->size); 1181e47937d1SCarl Delsey return (ENOMEM); 1182e47937d1SCarl Delsey } 1183e47937d1SCarl Delsey /* TODO: replace with bus_space_* functions */ 1184e47937d1SCarl Delsey mw->dma_addr = vtophys(mw->virt_addr); 1185e47937d1SCarl Delsey 1186d957796cSConrad Meyer /* 1187d957796cSConrad Meyer * Ensure that the allocation from contigmalloc is aligned as 1188d957796cSConrad Meyer * requested. XXX: This may not be needed -- brought in for parity 1189d957796cSConrad Meyer * with the Linux driver. 1190d957796cSConrad Meyer */ 1191d957796cSConrad Meyer if (mw->dma_addr % size != 0) { 1192d957796cSConrad Meyer device_printf(ntb_get_device(nt->ntb), 1193d957796cSConrad Meyer "DMA memory 0x%jx not aligned to BAR size 0x%x\n", 1194d957796cSConrad Meyer (uintmax_t)mw->dma_addr, size); 1195d957796cSConrad Meyer ntb_free_mw(nt, num_mw); 1196d957796cSConrad Meyer return (ENOMEM); 1197d957796cSConrad Meyer } 1198d957796cSConrad Meyer 1199e47937d1SCarl Delsey /* Notify HW the memory location of the receive buffer */ 1200e47937d1SCarl Delsey ntb_set_mw_addr(nt->ntb, num_mw, mw->dma_addr); 1201e47937d1SCarl Delsey 1202e47937d1SCarl Delsey return (0); 1203e47937d1SCarl Delsey } 1204e47937d1SCarl Delsey 1205e47937d1SCarl Delsey static void 120692bbfa50SConrad Meyer ntb_free_mw(struct ntb_netdev *nt, int num_mw) 120792bbfa50SConrad Meyer { 120892bbfa50SConrad Meyer struct ntb_transport_mw *mw = &nt->mw[num_mw]; 120992bbfa50SConrad Meyer 121092bbfa50SConrad Meyer if (mw->virt_addr == NULL) 121192bbfa50SConrad Meyer return; 121292bbfa50SConrad Meyer 121392bbfa50SConrad Meyer contigfree(mw->virt_addr, mw->size, M_NTB_IF); 121492bbfa50SConrad Meyer mw->virt_addr = NULL; 121592bbfa50SConrad Meyer } 121692bbfa50SConrad Meyer 121792bbfa50SConrad Meyer static void 1218e47937d1SCarl Delsey ntb_transport_setup_qp_mw(struct ntb_netdev *nt, unsigned int qp_num) 1219e47937d1SCarl Delsey { 1220e47937d1SCarl Delsey struct ntb_transport_qp *qp = &nt->qps[qp_num]; 1221e47937d1SCarl Delsey void *offset; 1222e47937d1SCarl Delsey unsigned int rx_size, num_qps_mw; 1223b8a291bdSConrad Meyer uint8_t mw_num, mw_max; 1224e47937d1SCarl Delsey unsigned int i; 1225e47937d1SCarl Delsey 122660c996fcSConrad Meyer mw_max = ntb_mw_count(nt->ntb); 1227b8a291bdSConrad Meyer mw_num = QP_TO_MW(nt->ntb, qp_num); 1228b8a291bdSConrad Meyer 1229b8a291bdSConrad Meyer if (nt->max_qps % mw_max && mw_num + 1 < nt->max_qps / mw_max) 1230b8a291bdSConrad Meyer num_qps_mw = nt->max_qps / mw_max + 1; 1231e47937d1SCarl Delsey else 1232b8a291bdSConrad Meyer num_qps_mw = nt->max_qps / mw_max; 1233e47937d1SCarl Delsey 1234e47937d1SCarl Delsey rx_size = (unsigned int) nt->mw[mw_num].size / num_qps_mw; 1235e47937d1SCarl Delsey qp->remote_rx_info = (void *)((uint8_t *)nt->mw[mw_num].virt_addr + 1236b8a291bdSConrad Meyer (qp_num / mw_max * rx_size)); 1237e47937d1SCarl Delsey rx_size -= sizeof(struct ntb_rx_info); 1238e47937d1SCarl Delsey 1239262d9f67SConrad Meyer qp->rx_buff = qp->remote_rx_info + 1; 12407ee9e4bcSConrad Meyer /* Due to house-keeping, there must be at least 2 buffs */ 1241e47937d1SCarl Delsey qp->rx_max_frame = min(transport_mtu + sizeof(struct ntb_payload_header), 12427ee9e4bcSConrad Meyer rx_size / 2); 1243e47937d1SCarl Delsey qp->rx_max_entry = rx_size / qp->rx_max_frame; 1244e47937d1SCarl Delsey qp->rx_index = 0; 1245e47937d1SCarl Delsey 12467ee9e4bcSConrad Meyer qp->remote_rx_info->entry = qp->rx_max_entry - 1; 1247e47937d1SCarl Delsey 1248e47937d1SCarl Delsey /* setup the hdr offsets with 0's */ 1249e47937d1SCarl Delsey for (i = 0; i < qp->rx_max_entry; i++) { 1250e47937d1SCarl Delsey offset = (void *)((uint8_t *)qp->rx_buff + 1251e47937d1SCarl Delsey qp->rx_max_frame * (i + 1) - 1252e47937d1SCarl Delsey sizeof(struct ntb_payload_header)); 1253e47937d1SCarl Delsey memset(offset, 0, sizeof(struct ntb_payload_header)); 1254e47937d1SCarl Delsey } 1255e47937d1SCarl Delsey 1256e47937d1SCarl Delsey qp->rx_pkts = 0; 1257e47937d1SCarl Delsey qp->tx_pkts = 0; 1258a30525bfSConrad Meyer qp->tx_index = 0; 1259e47937d1SCarl Delsey } 1260e47937d1SCarl Delsey 1261e47937d1SCarl Delsey static void 1262e47937d1SCarl Delsey ntb_qp_link_work(void *arg) 1263e47937d1SCarl Delsey { 1264e47937d1SCarl Delsey struct ntb_transport_qp *qp = arg; 1265e47937d1SCarl Delsey struct ntb_softc *ntb = qp->ntb; 1266e47937d1SCarl Delsey struct ntb_netdev *nt = qp->transport; 1267e47937d1SCarl Delsey int rc, val; 1268e47937d1SCarl Delsey 1269e47937d1SCarl Delsey 1270e47937d1SCarl Delsey rc = ntb_read_remote_spad(ntb, IF_NTB_QP_LINKS, &val); 1271e47937d1SCarl Delsey if (rc != 0) 1272e47937d1SCarl Delsey return; 1273e47937d1SCarl Delsey 1274e47937d1SCarl Delsey rc = ntb_write_remote_spad(ntb, IF_NTB_QP_LINKS, val | 1 << qp->qp_num); 1275e47937d1SCarl Delsey 1276e47937d1SCarl Delsey /* query remote spad for qp ready bits */ 1277e47937d1SCarl Delsey rc = ntb_read_local_spad(ntb, IF_NTB_QP_LINKS, &val); 1278e47937d1SCarl Delsey 1279e47937d1SCarl Delsey /* See if the remote side is up */ 1280e47937d1SCarl Delsey if ((1 << qp->qp_num & val) != 0) { 1281e47937d1SCarl Delsey qp->qp_link = NTB_LINK_UP; 1282e47937d1SCarl Delsey if (qp->event_handler != NULL) 1283e47937d1SCarl Delsey qp->event_handler(qp->cb_data, NTB_LINK_UP); 1284d43c0fbaSCarl Delsey if (bootverbose) 1285d43c0fbaSCarl Delsey device_printf(ntb_get_device(ntb), "qp link up\n"); 1286e47937d1SCarl Delsey } else if (nt->transport_link == NTB_LINK_UP) { 1287e47937d1SCarl Delsey callout_reset(&qp->link_work, 1288e47937d1SCarl Delsey NTB_LINK_DOWN_TIMEOUT * hz / 1000, ntb_qp_link_work, qp); 1289e47937d1SCarl Delsey } 1290e47937d1SCarl Delsey } 1291e47937d1SCarl Delsey 1292e47937d1SCarl Delsey /* Link down event*/ 1293e47937d1SCarl Delsey static void 1294e47937d1SCarl Delsey ntb_transport_link_cleanup(struct ntb_netdev *nt) 1295e47937d1SCarl Delsey { 1296b67ddac2SConrad Meyer uint8_t i; 1297e47937d1SCarl Delsey 1298e47937d1SCarl Delsey /* Pass along the info to any clients */ 1299e47937d1SCarl Delsey for (i = 0; i < nt->max_qps; i++) 1300e47937d1SCarl Delsey if (!test_bit(i, &nt->qp_bitmap)) 1301e47937d1SCarl Delsey ntb_qp_link_down(&nt->qps[i]); 1302e47937d1SCarl Delsey 13034d07d562SConrad Meyer if (nt->transport_link == NTB_LINK_DOWN) 13044d07d562SConrad Meyer callout_drain(&nt->link_work); 13054d07d562SConrad Meyer else 13064d07d562SConrad Meyer nt->transport_link = NTB_LINK_DOWN; 13074d07d562SConrad Meyer 1308e47937d1SCarl Delsey /* 1309e47937d1SCarl Delsey * The scratchpad registers keep the values if the remote side 1310e47937d1SCarl Delsey * goes down, blast them now to give them a sane value the next 1311e47937d1SCarl Delsey * time they are accessed 1312e47937d1SCarl Delsey */ 1313e47937d1SCarl Delsey for (i = 0; i < IF_NTB_MAX_SPAD; i++) 1314e47937d1SCarl Delsey ntb_write_local_spad(nt->ntb, i, 0); 1315e47937d1SCarl Delsey } 1316e47937d1SCarl Delsey 1317e47937d1SCarl Delsey 1318e47937d1SCarl Delsey static void 1319e47937d1SCarl Delsey ntb_qp_link_down(struct ntb_transport_qp *qp) 1320e47937d1SCarl Delsey { 1321e47937d1SCarl Delsey 1322e47937d1SCarl Delsey ntb_qp_link_cleanup(qp); 1323e47937d1SCarl Delsey } 1324e47937d1SCarl Delsey 1325e47937d1SCarl Delsey static void 1326e47937d1SCarl Delsey ntb_qp_link_cleanup(struct ntb_transport_qp *qp) 1327e47937d1SCarl Delsey { 1328e47937d1SCarl Delsey struct ntb_netdev *nt = qp->transport; 1329e47937d1SCarl Delsey 1330e47937d1SCarl Delsey if (qp->qp_link == NTB_LINK_DOWN) { 1331e47937d1SCarl Delsey callout_drain(&qp->link_work); 1332e47937d1SCarl Delsey return; 1333e47937d1SCarl Delsey } 1334e47937d1SCarl Delsey 1335e47937d1SCarl Delsey if (qp->event_handler != NULL) 1336e47937d1SCarl Delsey qp->event_handler(qp->cb_data, NTB_LINK_DOWN); 1337e47937d1SCarl Delsey 1338e47937d1SCarl Delsey qp->qp_link = NTB_LINK_DOWN; 1339e47937d1SCarl Delsey 1340e47937d1SCarl Delsey if (nt->transport_link == NTB_LINK_UP) 1341e47937d1SCarl Delsey callout_reset(&qp->link_work, 1342e47937d1SCarl Delsey NTB_LINK_DOWN_TIMEOUT * hz / 1000, ntb_qp_link_work, qp); 1343e47937d1SCarl Delsey } 1344e47937d1SCarl Delsey 1345e47937d1SCarl Delsey /* Link commanded down */ 1346e47937d1SCarl Delsey /** 1347e47937d1SCarl Delsey * ntb_transport_link_down - Notify NTB transport to no longer enqueue data 1348e47937d1SCarl Delsey * @qp: NTB transport layer queue to be disabled 1349e47937d1SCarl Delsey * 1350e47937d1SCarl Delsey * Notify NTB transport layer of client's desire to no longer receive data on 1351e47937d1SCarl Delsey * transport queue specified. It is the client's responsibility to ensure all 13522c6fb1deSConrad Meyer * entries on queue are purged or otherwise handled appropriately. 1353e47937d1SCarl Delsey */ 1354e47937d1SCarl Delsey static void 1355e47937d1SCarl Delsey ntb_transport_link_down(struct ntb_transport_qp *qp) 1356e47937d1SCarl Delsey { 1357e47937d1SCarl Delsey int rc, val; 1358e47937d1SCarl Delsey 1359e47937d1SCarl Delsey if (qp == NULL) 1360e47937d1SCarl Delsey return; 1361e47937d1SCarl Delsey 1362e47937d1SCarl Delsey qp->client_ready = NTB_LINK_DOWN; 1363e47937d1SCarl Delsey 1364e47937d1SCarl Delsey rc = ntb_read_remote_spad(qp->ntb, IF_NTB_QP_LINKS, &val); 1365e47937d1SCarl Delsey if (rc != 0) 1366e47937d1SCarl Delsey return; 1367e47937d1SCarl Delsey 1368e47937d1SCarl Delsey rc = ntb_write_remote_spad(qp->ntb, IF_NTB_QP_LINKS, 1369e47937d1SCarl Delsey val & ~(1 << qp->qp_num)); 1370e47937d1SCarl Delsey 1371e47937d1SCarl Delsey if (qp->qp_link == NTB_LINK_UP) 1372e47937d1SCarl Delsey ntb_send_link_down(qp); 1373e47937d1SCarl Delsey else 1374e47937d1SCarl Delsey callout_drain(&qp->link_work); 1375e47937d1SCarl Delsey 1376e47937d1SCarl Delsey } 1377e47937d1SCarl Delsey 1378e47937d1SCarl Delsey static void 1379e47937d1SCarl Delsey ntb_send_link_down(struct ntb_transport_qp *qp) 1380e47937d1SCarl Delsey { 1381e47937d1SCarl Delsey struct ntb_queue_entry *entry; 1382e47937d1SCarl Delsey int i, rc; 1383e47937d1SCarl Delsey 1384e47937d1SCarl Delsey if (qp->qp_link == NTB_LINK_DOWN) 1385e47937d1SCarl Delsey return; 1386e47937d1SCarl Delsey 1387e47937d1SCarl Delsey qp->qp_link = NTB_LINK_DOWN; 1388e47937d1SCarl Delsey 1389e47937d1SCarl Delsey for (i = 0; i < NTB_LINK_DOWN_TIMEOUT; i++) { 1390e47937d1SCarl Delsey entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q); 1391e47937d1SCarl Delsey if (entry != NULL) 1392e47937d1SCarl Delsey break; 1393e47937d1SCarl Delsey pause("NTB Wait for link down", hz / 10); 1394e47937d1SCarl Delsey } 1395e47937d1SCarl Delsey 1396e47937d1SCarl Delsey if (entry == NULL) 1397e47937d1SCarl Delsey return; 1398e47937d1SCarl Delsey 1399e47937d1SCarl Delsey entry->cb_data = NULL; 1400e47937d1SCarl Delsey entry->buf = NULL; 1401e47937d1SCarl Delsey entry->len = 0; 1402e47937d1SCarl Delsey entry->flags = IF_NTB_LINK_DOWN_FLAG; 1403e47937d1SCarl Delsey 1404e47937d1SCarl Delsey mtx_lock(&qp->transport->tx_lock); 1405e47937d1SCarl Delsey rc = ntb_process_tx(qp, entry); 1406e47937d1SCarl Delsey if (rc != 0) 1407e47937d1SCarl Delsey printf("ntb: Failed to send link down\n"); 1408e47937d1SCarl Delsey mtx_unlock(&qp->transport->tx_lock); 1409e47937d1SCarl Delsey } 1410e47937d1SCarl Delsey 1411e47937d1SCarl Delsey 1412e47937d1SCarl Delsey /* List Management */ 1413e47937d1SCarl Delsey 1414e47937d1SCarl Delsey static void 1415e47937d1SCarl Delsey ntb_list_add(struct mtx *lock, struct ntb_queue_entry *entry, 1416e47937d1SCarl Delsey struct ntb_queue_list *list) 1417e47937d1SCarl Delsey { 1418e47937d1SCarl Delsey 1419e47937d1SCarl Delsey mtx_lock_spin(lock); 1420e47937d1SCarl Delsey STAILQ_INSERT_TAIL(list, entry, entry); 1421e47937d1SCarl Delsey mtx_unlock_spin(lock); 1422e47937d1SCarl Delsey } 1423e47937d1SCarl Delsey 1424e47937d1SCarl Delsey static struct ntb_queue_entry * 1425e47937d1SCarl Delsey ntb_list_rm(struct mtx *lock, struct ntb_queue_list *list) 1426e47937d1SCarl Delsey { 1427e47937d1SCarl Delsey struct ntb_queue_entry *entry; 1428e47937d1SCarl Delsey 1429e47937d1SCarl Delsey mtx_lock_spin(lock); 1430e47937d1SCarl Delsey if (STAILQ_EMPTY(list)) { 1431e47937d1SCarl Delsey entry = NULL; 1432e47937d1SCarl Delsey goto out; 1433e47937d1SCarl Delsey } 1434e47937d1SCarl Delsey entry = STAILQ_FIRST(list); 1435e47937d1SCarl Delsey STAILQ_REMOVE_HEAD(list, entry); 1436e47937d1SCarl Delsey out: 1437e47937d1SCarl Delsey mtx_unlock_spin(lock); 1438e47937d1SCarl Delsey 1439e47937d1SCarl Delsey return (entry); 1440e47937d1SCarl Delsey } 1441e47937d1SCarl Delsey 1442e47937d1SCarl Delsey /* Helper functions */ 1443e47937d1SCarl Delsey /* TODO: This too should really be part of the kernel */ 1444e47937d1SCarl Delsey #define EUI48_MULTICAST 1 << 0 1445e47937d1SCarl Delsey #define EUI48_LOCALLY_ADMINISTERED 1 << 1 1446e47937d1SCarl Delsey static void 1447e47937d1SCarl Delsey create_random_local_eui48(u_char *eaddr) 1448e47937d1SCarl Delsey { 1449e47937d1SCarl Delsey static uint8_t counter = 0; 1450e47937d1SCarl Delsey uint32_t seed = ticks; 1451e47937d1SCarl Delsey 1452e47937d1SCarl Delsey eaddr[0] = EUI48_LOCALLY_ADMINISTERED; 1453e47937d1SCarl Delsey memcpy(&eaddr[1], &seed, sizeof(uint32_t)); 1454e47937d1SCarl Delsey eaddr[5] = counter++; 1455e47937d1SCarl Delsey } 1456e47937d1SCarl Delsey 1457e47937d1SCarl Delsey /** 1458e47937d1SCarl Delsey * ntb_transport_max_size - Query the max payload size of a qp 1459e47937d1SCarl Delsey * @qp: NTB transport layer queue to be queried 1460e47937d1SCarl Delsey * 1461e47937d1SCarl Delsey * Query the maximum payload size permissible on the given qp 1462e47937d1SCarl Delsey * 1463e47937d1SCarl Delsey * RETURNS: the max payload size of a qp 1464e47937d1SCarl Delsey */ 1465e47937d1SCarl Delsey static unsigned int 1466e47937d1SCarl Delsey ntb_transport_max_size(struct ntb_transport_qp *qp) 1467e47937d1SCarl Delsey { 1468e47937d1SCarl Delsey 1469e47937d1SCarl Delsey if (qp == NULL) 1470e47937d1SCarl Delsey return (0); 1471e47937d1SCarl Delsey 1472e47937d1SCarl Delsey return (qp->tx_max_frame - sizeof(struct ntb_payload_header)); 1473e47937d1SCarl Delsey } 1474