Skip site navigation (1)Skip section navigation (2)
Date:      Sun, 18 Oct 2015 20:20:48 +0000 (UTC)
From:      "Conrad E. Meyer" <cem@FreeBSD.org>
To:        src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org
Subject:   svn commit: r289545 - in head/sys/dev/ntb: if_ntb ntb_hw
Message-ID:  <201510182020.t9IKKmKX093094@repo.freebsd.org>

next in thread | raw e-mail | index | archive | help
Author: cem
Date: Sun Oct 18 20:20:48 2015
New Revision: 289545
URL: https://svnweb.freebsd.org/changeset/base/289545

Log:
  if_ntb: Rename things to match Linux driver
  
  No functional change.  Part of the huge rewrite (e26a5843).
  
  Obtained from:	Linux (e26a5843) (Dual BSD/GPL driver)
  Sponsored by:	EMC / Isilon Storage Division

Modified:
  head/sys/dev/ntb/if_ntb/if_ntb.c
  head/sys/dev/ntb/ntb_hw/ntb_hw.c
  head/sys/dev/ntb/ntb_hw/ntb_hw.h

Modified: head/sys/dev/ntb/if_ntb/if_ntb.c
==============================================================================
--- head/sys/dev/ntb/if_ntb/if_ntb.c	Sun Oct 18 20:20:38 2015	(r289544)
+++ head/sys/dev/ntb/if_ntb/if_ntb.c	Sun Oct 18 20:20:48 2015	(r289545)
@@ -1,5 +1,6 @@
 /*-
  * Copyright (C) 2013 Intel Corporation
+ * Copyright (C) 2015 EMC Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -110,13 +111,13 @@ struct ntb_rx_info {
 };
 
 struct ntb_transport_qp {
-	struct ntb_netdev	*transport;
+	struct ntb_transport_ctx	*transport;
 	struct ntb_softc	*ntb;
 
 	void			*cb_data;
 
 	bool			client_ready;
-	bool			qp_link;
+	bool			link_is_up;
 	uint8_t			qp_num;	/* Only 64 QPs are allowed.  0-63 */
 
 	struct ntb_rx_info	*rx_info;
@@ -172,19 +173,20 @@ struct ntb_queue_handlers {
 
 
 struct ntb_transport_mw {
-	size_t		size;
+	size_t		xlat_size;
 	void		*virt_addr;
 	vm_paddr_t	dma_addr;
 };
 
-struct ntb_netdev {
+struct ntb_transport_ctx {
 	struct ntb_softc	*ntb;
 	struct ifnet		*ifp;
-	struct ntb_transport_mw	mw[NTB_MAX_NUM_MW];
-	struct ntb_transport_qp	*qps;
+	struct ntb_transport_mw	mw_vec[NTB_MAX_NUM_MW];
+	struct ntb_transport_qp	*qp_vec;
 	struct _qpset		qp_bitmap;
-	uint8_t			max_qps;
-	enum ntb_link_event	transport_link;
+	unsigned		mw_count;
+	unsigned		qp_count;
+	enum ntb_link_event	link_is_up;
 	struct callout		link_work;
 	struct ntb_transport_qp *qp;
 	uint64_t		bufsize;
@@ -193,7 +195,7 @@ struct ntb_netdev {
 	struct mtx		rx_lock;
 };
 
-static struct ntb_netdev net_softc;
+static struct ntb_transport_ctx net_softc;
 
 enum {
 	IF_NTB_DESC_DONE_FLAG = 1 << 0,
@@ -226,7 +228,7 @@ enum {
 	IF_NTB_MAX_SPAD,
 };
 
-#define QP_TO_MW(ntb, qp)	((qp) % ntb_mw_count(ntb))
+#define QP_TO_MW(nt, qp)	((qp) % nt->mw_count)
 #define NTB_QP_DEF_NUM_ENTRIES	100
 #define NTB_LINK_DOWN_TIMEOUT	10
 
@@ -243,7 +245,7 @@ static void ntb_net_rx_handler(struct nt
 static void ntb_net_event_handler(void *data, enum ntb_link_event status);
 static int ntb_transport_init(struct ntb_softc *ntb);
 static void ntb_transport_free(void *transport);
-static void ntb_transport_init_queue(struct ntb_netdev *nt,
+static void ntb_transport_init_queue(struct ntb_transport_ctx *nt,
     unsigned int qp_num);
 static void ntb_transport_free_queue(struct ntb_transport_qp *qp);
 static struct ntb_transport_qp * ntb_transport_create_queue(void *data,
@@ -264,12 +266,12 @@ static void ntb_rx_copy_task(struct ntb_
 static void ntb_rx_completion_task(void *arg, int pending);
 static void ntb_transport_event_callback(void *data, enum ntb_hw_event event);
 static void ntb_transport_link_work(void *arg);
-static int ntb_set_mw(struct ntb_netdev *nt, int num_mw, unsigned int size);
-static void ntb_free_mw(struct ntb_netdev *nt, int num_mw);
-static void ntb_transport_setup_qp_mw(struct ntb_netdev *nt,
+static int ntb_set_mw(struct ntb_transport_ctx *, int num_mw, unsigned size);
+static void ntb_free_mw(struct ntb_transport_ctx *nt, int num_mw);
+static void ntb_transport_setup_qp_mw(struct ntb_transport_ctx *nt,
     unsigned int qp_num);
 static void ntb_qp_link_work(void *arg);
-static void ntb_transport_link_cleanup(struct ntb_netdev *nt);
+static void ntb_transport_link_cleanup(struct ntb_transport_ctx *nt);
 static void ntb_qp_link_down(struct ntb_transport_qp *qp);
 static void ntb_qp_link_cleanup(struct ntb_transport_qp *qp);
 static void ntb_transport_link_down(struct ntb_transport_qp *qp);
@@ -380,7 +382,7 @@ ntb_teardown_interface(void)
 static void
 ntb_net_init(void *arg)
 {
-	struct ntb_netdev *ntb_softc = arg;
+	struct ntb_transport_ctx *ntb_softc = arg;
 	struct ifnet *ifp = ntb_softc->ifp;
 
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
@@ -392,7 +394,7 @@ ntb_net_init(void *arg)
 static int
 ntb_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 {
-	struct ntb_netdev *nt = ifp->if_softc;
+	struct ntb_transport_ctx *nt = ifp->if_softc;
 	struct ifreq *ifr = (struct ifreq *)data;
 	int error = 0;
 
@@ -421,7 +423,7 @@ static void
 ntb_start(struct ifnet *ifp)
 {
 	struct mbuf *m_head;
-	struct ntb_netdev *nt = ifp->if_softc;
+	struct ntb_transport_ctx *nt = ifp->if_softc;
 	int rc;
 
 	mtx_lock(&nt->tx_lock);
@@ -495,37 +497,37 @@ ntb_net_event_handler(void *data, enum n
 static int
 ntb_transport_init(struct ntb_softc *ntb)
 {
-	struct ntb_netdev *nt = &net_softc;
+	struct ntb_transport_ctx *nt = &net_softc;
 	int rc;
 	uint8_t i;
 
+	nt->mw_count = ntb_mw_count(ntb);
 	if (max_num_clients == 0)
-		nt->max_qps = MIN(ntb_get_max_cbs(ntb), ntb_mw_count(ntb));
+		nt->qp_count = MIN(ntb_get_max_cbs(ntb), ntb_mw_count(ntb));
 	else
-		nt->max_qps = MIN(ntb_get_max_cbs(ntb), max_num_clients);
+		nt->qp_count = MIN(ntb_get_max_cbs(ntb), max_num_clients);
 
 	ntb_register_transport(ntb, nt);
 	mtx_init(&nt->tx_lock, "ntb transport tx", NULL, MTX_DEF);
 	mtx_init(&nt->rx_lock, "ntb transport rx", NULL, MTX_DEF);
 
-	nt->qps = malloc(nt->max_qps * sizeof(struct ntb_transport_qp),
-			  M_NTB_IF, M_WAITOK|M_ZERO);
+	nt->qp_vec = malloc(nt->qp_count * sizeof(*nt->qp_vec), M_NTB_IF,
+	    M_WAITOK | M_ZERO);
 
-	KASSERT(nt->max_qps <= QP_SETSIZE, ("invalid max_qps"));
+	KASSERT(nt->qp_count <= QP_SETSIZE, ("invalid qp_count"));
 
-	for (i = 0; i < nt->max_qps; i++) {
+	for (i = 0; i < nt->qp_count; i++) {
 		set_bit(i, &nt->qp_bitmap);
 		ntb_transport_init_queue(nt, i);
 	}
 
 	callout_init(&nt->link_work, 0);
 
-	rc = ntb_register_event_callback(ntb,
-					 ntb_transport_event_callback);
+	rc = ntb_register_event_callback(ntb, ntb_transport_event_callback);
 	if (rc != 0)
 		goto err;
 
-	if (ntb_query_link_status(ntb)) {
+	if (ntb_link_is_up(ntb)) {
 		if (bootverbose)
 			device_printf(ntb_get_device(ntb), "link up\n");
 		callout_reset(&nt->link_work, 0, ntb_transport_link_work, nt);
@@ -534,7 +536,7 @@ ntb_transport_init(struct ntb_softc *ntb
 	return (0);
 
 err:
-	free(nt->qps, M_NTB_IF);
+	free(nt->qp_vec, M_NTB_IF);
 	ntb_unregister_transport(ntb);
 	return (rc);
 }
@@ -542,7 +544,7 @@ err:
 static void
 ntb_transport_free(void *transport)
 {
-	struct ntb_netdev *nt = transport;
+	struct ntb_transport_ctx *nt = transport;
 	struct ntb_softc *ntb = nt->ntb;
 	uint8_t i;
 
@@ -551,46 +553,46 @@ ntb_transport_free(void *transport)
 	callout_drain(&nt->link_work);
 
 	/* verify that all the qps are freed */
-	for (i = 0; i < nt->max_qps; i++)
+	for (i = 0; i < nt->qp_count; i++)
 		if (!test_bit(i, &nt->qp_bitmap))
-			ntb_transport_free_queue(&nt->qps[i]);
+			ntb_transport_free_queue(&nt->qp_vec[i]);
 
 	ntb_unregister_event_callback(ntb);
 
 	for (i = 0; i < NTB_MAX_NUM_MW; i++)
 		ntb_free_mw(nt, i);
 
-	free(nt->qps, M_NTB_IF);
+	free(nt->qp_vec, M_NTB_IF);
 	ntb_unregister_transport(ntb);
 }
 
 static void
-ntb_transport_init_queue(struct ntb_netdev *nt, unsigned int qp_num)
+ntb_transport_init_queue(struct ntb_transport_ctx *nt, unsigned int qp_num)
 {
 	struct ntb_transport_qp *qp;
 	unsigned int num_qps_mw, tx_size;
-	uint8_t mw_num, mw_max;
+	uint8_t mw_num, mw_count;
 
-	mw_max = ntb_mw_count(nt->ntb);
-	mw_num = QP_TO_MW(nt->ntb, qp_num);
+	mw_count = ntb_mw_count(nt->ntb);
+	mw_num = QP_TO_MW(nt, qp_num);
 
-	qp = &nt->qps[qp_num];
+	qp = &nt->qp_vec[qp_num];
 	qp->qp_num = qp_num;
 	qp->transport = nt;
 	qp->ntb = nt->ntb;
-	qp->qp_link = NTB_LINK_DOWN;
-	qp->client_ready = NTB_LINK_DOWN;
+	qp->link_is_up = false;
+	qp->client_ready = false;
 	qp->event_handler = NULL;
 
-	if (nt->max_qps % mw_max && mw_num + 1 < nt->max_qps / mw_max)
-		num_qps_mw = nt->max_qps / mw_max + 1;
+	if (nt->qp_count % mw_count && mw_num + 1 < nt->qp_count / mw_count)
+		num_qps_mw = nt->qp_count / mw_count + 1;
 	else
-		num_qps_mw = nt->max_qps / mw_max;
+		num_qps_mw = nt->qp_count / mw_count;
 
-	tx_size = (unsigned int) ntb_get_mw_size(qp->ntb, mw_num) / num_qps_mw;
+	tx_size = ntb_get_mw_size(qp->ntb, mw_num) / num_qps_mw;
 	qp->rx_info = (struct ntb_rx_info *)
 	    ((char *)ntb_get_mw_vbase(qp->ntb, mw_num) +
-	    (qp_num / mw_max * tx_size));
+	    (qp_num / mw_count * tx_size));
 	tx_size -= sizeof(struct ntb_rx_info);
 
 	qp->tx_mw = qp->rx_info + 1;
@@ -657,7 +659,7 @@ ntb_transport_create_queue(void *data, s
 {
 	struct ntb_queue_entry *entry;
 	struct ntb_transport_qp *qp;
-	struct ntb_netdev *nt;
+	struct ntb_transport_ctx *nt;
 	unsigned int free_queue;
 	int rc, i;
 
@@ -674,7 +676,7 @@ ntb_transport_create_queue(void *data, s
 
 	clear_bit(free_queue, &nt->qp_bitmap);
 
-	qp = &nt->qps[free_queue];
+	qp = &nt->qp_vec[free_queue];
 	qp->cb_data = data;
 	qp->rx_handler = handlers->rx_handler;
 	qp->tx_handler = handlers->tx_handler;
@@ -725,11 +727,11 @@ ntb_transport_link_up(struct ntb_transpo
 	if (qp == NULL)
 		return;
 
-	qp->client_ready = NTB_LINK_UP;
+	qp->client_ready = true;
 	if (bootverbose)
 		device_printf(ntb_get_device(qp->ntb), "qp client ready\n");
 
-	if (qp->transport->transport_link == NTB_LINK_UP)
+	if (qp->transport->link_is_up)
 		callout_reset(&qp->link_work, 0, ntb_qp_link_work, qp);
 }
 
@@ -757,7 +759,7 @@ ntb_transport_tx_enqueue(struct ntb_tran
 	struct ntb_queue_entry *entry;
 	int rc;
 
-	if (qp == NULL || qp->qp_link != NTB_LINK_UP || len == 0) {
+	if (qp == NULL || !qp->link_is_up || len == 0) {
 		CTR0(KTR_NTB, "TX: link not up");
 		return (EINVAL);
 	}
@@ -839,7 +841,7 @@ ntb_tx_copy_task(struct ntb_transport_qp
 	/* TODO: replace with bus_space_write */
 	hdr->flags = entry->flags | IF_NTB_DESC_DONE_FLAG;
 
-	ntb_ring_doorbell(qp->ntb, qp->qp_num);
+	ntb_peer_db_set(qp->ntb, 1ull << qp->qp_num);
 
 	/*
 	 * The entry length can only be zero if the packet is intended to be a
@@ -1013,7 +1015,7 @@ ntb_rx_completion_task(void *arg, int pe
 	while ((entry = ntb_list_rm(&qp->ntb_rx_free_q_lock, &qp->rx_free_q))) {
 		m = entry->buf;
 		CTR2(KTR_NTB, "RX: completing entry %p, mbuf %p", entry, m);
-		if (qp->rx_handler && qp->client_ready == NTB_LINK_UP)
+		if (qp->rx_handler && qp->client_ready)
 			qp->rx_handler(qp, qp->cb_data, m, entry->len);
 
 		entry->buf = NULL;
@@ -1035,7 +1037,7 @@ ntb_rx_completion_task(void *arg, int pe
 static void
 ntb_transport_event_callback(void *data, enum ntb_hw_event event)
 {
-	struct ntb_netdev *nt = data;
+	struct ntb_transport_ctx *nt = data;
 
 	switch (event) {
 	case NTB_EVENT_HW_LINK_UP:
@@ -1057,7 +1059,7 @@ ntb_transport_event_callback(void *data,
 static void
 ntb_transport_link_work(void *arg)
 {
-	struct ntb_netdev *nt = arg;
+	struct ntb_transport_ctx *nt = arg;
 	struct ntb_softc *ntb = nt->ntb;
 	struct ntb_transport_qp *qp;
 	uint64_t val64;
@@ -1068,45 +1070,45 @@ ntb_transport_link_work(void *arg)
 
 	/* send the local info, in the opposite order of the way we read it */
 	for (i = 0; i < num_mw; i++) {
-		rc = ntb_write_remote_spad(ntb, IF_NTB_MW0_SZ_HIGH + (i * 2),
+		rc = ntb_peer_spad_write(ntb, IF_NTB_MW0_SZ_HIGH + (i * 2),
 		    (uint64_t)ntb_get_mw_size(ntb, i) >> 32);
 		if (rc != 0)
 			goto out;
 
-		rc = ntb_write_remote_spad(ntb, IF_NTB_MW0_SZ_LOW + (i * 2),
+		rc = ntb_peer_spad_write(ntb, IF_NTB_MW0_SZ_LOW + (i * 2),
 		    (uint32_t)ntb_get_mw_size(ntb, i));
 		if (rc != 0)
 			goto out;
 	}
 
-	rc = ntb_write_remote_spad(ntb, IF_NTB_NUM_MWS, num_mw);
+	rc = ntb_peer_spad_write(ntb, IF_NTB_NUM_MWS, num_mw);
 	if (rc != 0)
 		goto out;
 
-	rc = ntb_write_remote_spad(ntb, IF_NTB_NUM_QPS, nt->max_qps);
+	rc = ntb_peer_spad_write(ntb, IF_NTB_NUM_QPS, nt->qp_count);
 	if (rc != 0)
 		goto out;
 
-	rc = ntb_write_remote_spad(ntb, IF_NTB_VERSION, NTB_TRANSPORT_VERSION);
+	rc = ntb_peer_spad_write(ntb, IF_NTB_VERSION, NTB_TRANSPORT_VERSION);
 	if (rc != 0)
 		goto out;
 
 	/* Query the remote side for its info */
-	rc = ntb_read_local_spad(ntb, IF_NTB_VERSION, &val);
+	rc = ntb_spad_read(ntb, IF_NTB_VERSION, &val);
 	if (rc != 0)
 		goto out;
 
 	if (val != NTB_TRANSPORT_VERSION)
 		goto out;
 
-	rc = ntb_read_local_spad(ntb, IF_NTB_NUM_QPS, &val);
+	rc = ntb_spad_read(ntb, IF_NTB_NUM_QPS, &val);
 	if (rc != 0)
 		goto out;
 
-	if (val != nt->max_qps)
+	if (val != nt->qp_count)
 		goto out;
 
-	rc = ntb_read_local_spad(ntb, IF_NTB_NUM_MWS, &val);
+	rc = ntb_spad_read(ntb, IF_NTB_NUM_MWS, &val);
 	if (rc != 0)
 		goto out;
 
@@ -1114,14 +1116,14 @@ ntb_transport_link_work(void *arg)
 		goto out;
 
 	for (i = 0; i < num_mw; i++) {
-		rc = ntb_read_local_spad(ntb, IF_NTB_MW0_SZ_HIGH + (i * 2),
+		rc = ntb_spad_read(ntb, IF_NTB_MW0_SZ_HIGH + (i * 2),
 		    &val);
 		if (rc != 0)
 			goto free_mws;
 
 		val64 = (uint64_t)val << 32;
 
-		rc = ntb_read_local_spad(ntb, IF_NTB_MW0_SZ_LOW + (i * 2),
+		rc = ntb_spad_read(ntb, IF_NTB_MW0_SZ_LOW + (i * 2),
 		    &val);
 		if (rc != 0)
 			goto free_mws;
@@ -1133,16 +1135,16 @@ ntb_transport_link_work(void *arg)
 			goto free_mws;
 	}
 
-	nt->transport_link = NTB_LINK_UP;
+	nt->link_is_up = true;
 	if (bootverbose)
 		device_printf(ntb_get_device(ntb), "transport link up\n");
 
-	for (i = 0; i < nt->max_qps; i++) {
-		qp = &nt->qps[i];
+	for (i = 0; i < nt->qp_count; i++) {
+		qp = &nt->qp_vec[i];
 
 		ntb_transport_setup_qp_mw(nt, i);
 
-		if (qp->client_ready == NTB_LINK_UP)
+		if (qp->client_ready)
 			callout_reset(&qp->link_work, 0, ntb_qp_link_work, qp);
 	}
 
@@ -1152,32 +1154,32 @@ free_mws:
 	for (i = 0; i < NTB_MAX_NUM_MW; i++)
 		ntb_free_mw(nt, i);
 out:
-	if (ntb_query_link_status(ntb))
+	if (ntb_link_is_up(ntb))
 		callout_reset(&nt->link_work,
 		    NTB_LINK_DOWN_TIMEOUT * hz / 1000, ntb_transport_link_work, nt);
 }
 
 static int
-ntb_set_mw(struct ntb_netdev *nt, int num_mw, unsigned int size)
+ntb_set_mw(struct ntb_transport_ctx *nt, int num_mw, unsigned int size)
 {
-	struct ntb_transport_mw *mw = &nt->mw[num_mw];
+	struct ntb_transport_mw *mw = &nt->mw_vec[num_mw];
 
 	/* No need to re-setup */
-	if (mw->size == size)
+	if (mw->xlat_size == size)
 		return (0);
 
-	if (mw->size != 0)
+	if (mw->xlat_size != 0)
 		ntb_free_mw(nt, num_mw);
 
 	/* Alloc memory for receiving data.  Must be 4k aligned */
-	mw->size = size;
+	mw->xlat_size = size;
 
-	mw->virt_addr = contigmalloc(mw->size, M_NTB_IF, M_ZERO, 0,
-	    BUS_SPACE_MAXADDR, mw->size, 0);
+	mw->virt_addr = contigmalloc(mw->xlat_size, M_NTB_IF, M_ZERO, 0,
+	    BUS_SPACE_MAXADDR, mw->xlat_size, 0);
 	if (mw->virt_addr == NULL) {
-		mw->size = 0;
+		mw->xlat_size = 0;
 		printf("ntb: Unable to allocate MW buffer of size %zu\n",
-		    mw->size);
+		    mw->xlat_size);
 		return (ENOMEM);
 	}
 	/* TODO: replace with bus_space_* functions */
@@ -1203,37 +1205,37 @@ ntb_set_mw(struct ntb_netdev *nt, int nu
 }
 
 static void
-ntb_free_mw(struct ntb_netdev *nt, int num_mw)
+ntb_free_mw(struct ntb_transport_ctx *nt, int num_mw)
 {
-	struct ntb_transport_mw *mw = &nt->mw[num_mw];
+	struct ntb_transport_mw *mw = &nt->mw_vec[num_mw];
 
 	if (mw->virt_addr == NULL)
 		return;
 
-	contigfree(mw->virt_addr, mw->size, M_NTB_IF);
+	contigfree(mw->virt_addr, mw->xlat_size, M_NTB_IF);
 	mw->virt_addr = NULL;
 }
 
 static void
-ntb_transport_setup_qp_mw(struct ntb_netdev *nt, unsigned int qp_num)
+ntb_transport_setup_qp_mw(struct ntb_transport_ctx *nt, unsigned int qp_num)
 {
-	struct ntb_transport_qp *qp = &nt->qps[qp_num];
+	struct ntb_transport_qp *qp = &nt->qp_vec[qp_num];
 	void *offset;
 	unsigned int rx_size, num_qps_mw;
-	uint8_t mw_num, mw_max;
+	uint8_t mw_num, mw_count;
 	unsigned int i;
 
-	mw_max = ntb_mw_count(nt->ntb);
-	mw_num = QP_TO_MW(nt->ntb, qp_num);
+	mw_count = ntb_mw_count(nt->ntb);
+	mw_num = QP_TO_MW(nt, qp_num);
 
-	if (nt->max_qps % mw_max && mw_num + 1 < nt->max_qps / mw_max)
-		num_qps_mw = nt->max_qps / mw_max + 1;
+	if (nt->qp_count % mw_count && mw_num + 1 < nt->qp_count / mw_count)
+		num_qps_mw = nt->qp_count / mw_count + 1;
 	else
-		num_qps_mw = nt->max_qps / mw_max;
+		num_qps_mw = nt->qp_count / mw_count;
 
-	rx_size = (unsigned int) nt->mw[mw_num].size / num_qps_mw;
-	qp->remote_rx_info = (void *)((uint8_t *)nt->mw[mw_num].virt_addr +
-			     (qp_num / mw_max * rx_size));
+	rx_size = nt->mw_vec[mw_num].xlat_size / num_qps_mw;
+	qp->remote_rx_info = (void *)((uint8_t *)nt->mw_vec[mw_num].virt_addr +
+	    (qp_num / mw_count * rx_size));
 	rx_size -= sizeof(struct ntb_rx_info);
 
 	qp->rx_buff = qp->remote_rx_info + 1;
@@ -1263,27 +1265,27 @@ ntb_qp_link_work(void *arg)
 {
 	struct ntb_transport_qp *qp = arg;
 	struct ntb_softc *ntb = qp->ntb;
-	struct ntb_netdev *nt = qp->transport;
+	struct ntb_transport_ctx *nt = qp->transport;
 	int rc, val;
 
 
-	rc = ntb_read_remote_spad(ntb, IF_NTB_QP_LINKS, &val);
+	rc = ntb_peer_spad_read(ntb, IF_NTB_QP_LINKS, &val);
 	if (rc != 0)
 		return;
 
-	rc = ntb_write_remote_spad(ntb, IF_NTB_QP_LINKS, val | 1 << qp->qp_num);
+	rc = ntb_peer_spad_write(ntb, IF_NTB_QP_LINKS, val | 1 << qp->qp_num);
 
 	/* query remote spad for qp ready bits */
-	rc = ntb_read_local_spad(ntb, IF_NTB_QP_LINKS, &val);
+	rc = ntb_spad_read(ntb, IF_NTB_QP_LINKS, &val);
 
 	/* See if the remote side is up */
 	if ((1 << qp->qp_num & val) != 0) {
-		qp->qp_link = NTB_LINK_UP;
+		qp->link_is_up = true;
 		if (qp->event_handler != NULL)
 			qp->event_handler(qp->cb_data, NTB_LINK_UP);
 		if (bootverbose)
 			device_printf(ntb_get_device(ntb), "qp link up\n");
-	} else if (nt->transport_link == NTB_LINK_UP) {
+	} else if (nt->link_is_up) {
 		callout_reset(&qp->link_work,
 		    NTB_LINK_DOWN_TIMEOUT * hz / 1000, ntb_qp_link_work, qp);
 	}
@@ -1291,19 +1293,19 @@ ntb_qp_link_work(void *arg)
 
 /* Link down event*/
 static void
-ntb_transport_link_cleanup(struct ntb_netdev *nt)
+ntb_transport_link_cleanup(struct ntb_transport_ctx *nt)
 {
 	uint8_t i;
 
 	/* Pass along the info to any clients */
-	for (i = 0; i < nt->max_qps; i++)
+	for (i = 0; i < nt->qp_count; i++)
 		if (!test_bit(i, &nt->qp_bitmap))
-			ntb_qp_link_down(&nt->qps[i]);
+			ntb_qp_link_down(&nt->qp_vec[i]);
 
-	if (nt->transport_link == NTB_LINK_DOWN)
+	if (!nt->link_is_up)
 		callout_drain(&nt->link_work);
 	else
-		nt->transport_link = NTB_LINK_DOWN;
+		nt->link_is_up = false;
 
 	/*
 	 * The scratchpad registers keep the values if the remote side
@@ -1311,7 +1313,7 @@ ntb_transport_link_cleanup(struct ntb_ne
 	 * time they are accessed
 	 */
 	for (i = 0; i < IF_NTB_MAX_SPAD; i++)
-		ntb_write_local_spad(nt->ntb, i, 0);
+		ntb_spad_write(nt->ntb, i, 0);
 }
 
 
@@ -1325,9 +1327,9 @@ ntb_qp_link_down(struct ntb_transport_qp
 static void
 ntb_qp_link_cleanup(struct ntb_transport_qp *qp)
 {
-	struct ntb_netdev *nt = qp->transport;
+	struct ntb_transport_ctx *nt = qp->transport;
 
-	if (qp->qp_link == NTB_LINK_DOWN) {
+	if (!qp->link_is_up) {
 		callout_drain(&qp->link_work);
 		return;
 	}
@@ -1335,9 +1337,9 @@ ntb_qp_link_cleanup(struct ntb_transport
 	if (qp->event_handler != NULL)
 		qp->event_handler(qp->cb_data, NTB_LINK_DOWN);
 
-	qp->qp_link = NTB_LINK_DOWN;
+	qp->link_is_up = false;
 
-	if (nt->transport_link == NTB_LINK_UP)
+	if (nt->link_is_up)
 		callout_reset(&qp->link_work,
 		    NTB_LINK_DOWN_TIMEOUT * hz / 1000, ntb_qp_link_work, qp);
 }
@@ -1359,16 +1361,16 @@ ntb_transport_link_down(struct ntb_trans
 	if (qp == NULL)
 		return;
 
-	qp->client_ready = NTB_LINK_DOWN;
+	qp->client_ready = false;
 
-	rc = ntb_read_remote_spad(qp->ntb, IF_NTB_QP_LINKS, &val);
+	rc = ntb_peer_spad_read(qp->ntb, IF_NTB_QP_LINKS, &val);
 	if (rc != 0)
 		return;
 
-	rc = ntb_write_remote_spad(qp->ntb, IF_NTB_QP_LINKS,
+	rc = ntb_peer_spad_write(qp->ntb, IF_NTB_QP_LINKS,
 	   val & ~(1 << qp->qp_num));
 
-	if (qp->qp_link == NTB_LINK_UP)
+	if (qp->link_is_up)
 		ntb_send_link_down(qp);
 	else
 		callout_drain(&qp->link_work);
@@ -1381,10 +1383,10 @@ ntb_send_link_down(struct ntb_transport_
 	struct ntb_queue_entry *entry;
 	int i, rc;
 
-	if (qp->qp_link == NTB_LINK_DOWN)
+	if (!qp->link_is_up)
 		return;
 
-	qp->qp_link = NTB_LINK_DOWN;
+	qp->link_is_up = false;
 
 	for (i = 0; i < NTB_LINK_DOWN_TIMEOUT; i++) {
 		entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q);

Modified: head/sys/dev/ntb/ntb_hw/ntb_hw.c
==============================================================================
--- head/sys/dev/ntb/ntb_hw/ntb_hw.c	Sun Oct 18 20:20:38 2015	(r289544)
+++ head/sys/dev/ntb/ntb_hw/ntb_hw.c	Sun Oct 18 20:20:48 2015	(r289545)
@@ -1891,7 +1891,7 @@ ntb_mw_count(struct ntb_softc *ntb)
 }
 
 /**
- * ntb_write_local_spad() - write to the secondary scratchpad register
+ * ntb_spad_write() - write to the secondary scratchpad register
  * @ntb: pointer to ntb_softc instance
  * @idx: index to the scratchpad register, 0 based
  * @val: the data value to put into the register
@@ -1902,7 +1902,7 @@ ntb_mw_count(struct ntb_softc *ntb)
  * RETURNS: An appropriate ERRNO error value on error, or zero for success.
  */
 int
-ntb_write_local_spad(struct ntb_softc *ntb, unsigned int idx, uint32_t val)
+ntb_spad_write(struct ntb_softc *ntb, unsigned int idx, uint32_t val)
 {
 
 	if (idx >= ntb->spad_count)
@@ -1914,7 +1914,7 @@ ntb_write_local_spad(struct ntb_softc *n
 }
 
 /**
- * ntb_read_local_spad() - read from the primary scratchpad register
+ * ntb_spad_read() - read from the primary scratchpad register
  * @ntb: pointer to ntb_softc instance
  * @idx: index to scratchpad register, 0 based
  * @val: pointer to 32bit integer for storing the register value
@@ -1925,7 +1925,7 @@ ntb_write_local_spad(struct ntb_softc *n
  * RETURNS: An appropriate ERRNO error value on error, or zero for success.
  */
 int
-ntb_read_local_spad(struct ntb_softc *ntb, unsigned int idx, uint32_t *val)
+ntb_spad_read(struct ntb_softc *ntb, unsigned int idx, uint32_t *val)
 {
 
 	if (idx >= ntb->spad_count)
@@ -1937,7 +1937,7 @@ ntb_read_local_spad(struct ntb_softc *nt
 }
 
 /**
- * ntb_write_remote_spad() - write to the secondary scratchpad register
+ * ntb_peer_spad_write() - write to the secondary scratchpad register
  * @ntb: pointer to ntb_softc instance
  * @idx: index to the scratchpad register, 0 based
  * @val: the data value to put into the register
@@ -1948,7 +1948,7 @@ ntb_read_local_spad(struct ntb_softc *nt
  * RETURNS: An appropriate ERRNO error value on error, or zero for success.
  */
 int
-ntb_write_remote_spad(struct ntb_softc *ntb, unsigned int idx, uint32_t val)
+ntb_peer_spad_write(struct ntb_softc *ntb, unsigned int idx, uint32_t val)
 {
 
 	if (idx >= ntb->spad_count)
@@ -1963,7 +1963,7 @@ ntb_write_remote_spad(struct ntb_softc *
 }
 
 /**
- * ntb_read_remote_spad() - read from the primary scratchpad register
+ * ntb_peer_spad_read() - read from the primary scratchpad register
  * @ntb: pointer to ntb_softc instance
  * @idx: index to scratchpad register, 0 based
  * @val: pointer to 32bit integer for storing the register value
@@ -1974,7 +1974,7 @@ ntb_write_remote_spad(struct ntb_softc *
  * RETURNS: An appropriate ERRNO error value on error, or zero for success.
  */
 int
-ntb_read_remote_spad(struct ntb_softc *ntb, unsigned int idx, uint32_t *val)
+ntb_peer_spad_read(struct ntb_softc *ntb, unsigned int idx, uint32_t *val)
 {
 
 	if (idx >= ntb->spad_count)
@@ -2074,23 +2074,16 @@ ntb_set_mw_addr(struct ntb_softc *ntb, u
 }
 
 /**
- * ntb_ring_doorbell() - Set the doorbell on the secondary/external side
+ * ntb_peer_db_set() - Set the doorbell on the secondary/external side
  * @ntb: pointer to ntb_softc instance
- * @db: doorbell to ring
+ * @bit: doorbell bits to ring
  *
  * This function allows triggering of a doorbell on the secondary/external
  * side that will initiate an interrupt on the remote host
  */
 void
-ntb_ring_doorbell(struct ntb_softc *ntb, unsigned int db)
+ntb_peer_db_set(struct ntb_softc *ntb, uint64_t bit)
 {
-	uint64_t bit;
-
-	if (ntb->type == NTB_SOC)
-		bit = 1 << db;
-	else
-		bit = ((1 << ntb->db_vec_shift) - 1) <<
-		    (db * ntb->db_vec_shift);
 
 	if (HAS_FEATURE(NTB_SDOORBELL_LOCKUP)) {
 		ntb_mw_write(2, XEON_SHADOW_PDOORBELL_OFFSET, bit);
@@ -2139,7 +2132,7 @@ ntb_get_peer_db_addr(struct ntb_softc *n
 }
 
 /**
- * ntb_query_link_status() - return the hardware link status
+ * ntb_link_is_up() - return the hardware link status
  * @ndev: pointer to ntb_device instance
  *
  * Returns true if the hardware is connected to the remote system
@@ -2147,7 +2140,7 @@ ntb_get_peer_db_addr(struct ntb_softc *n
  * RETURNS: true or false based on the hardware link state
  */
 bool
-ntb_query_link_status(struct ntb_softc *ntb)
+ntb_link_is_up(struct ntb_softc *ntb)
 {
 
 	return (ntb->link_status == NTB_LINK_UP);

Modified: head/sys/dev/ntb/ntb_hw/ntb_hw.h
==============================================================================
--- head/sys/dev/ntb/ntb_hw/ntb_hw.h	Sun Oct 18 20:20:38 2015	(r289544)
+++ head/sys/dev/ntb/ntb_hw/ntb_hw.h	Sun Oct 18 20:20:48 2015	(r289545)
@@ -65,19 +65,19 @@ void ntb_unregister_transport(struct ntb
 uint8_t ntb_get_max_cbs(struct ntb_softc *ntb);
 uint8_t ntb_mw_count(struct ntb_softc *ntb);
 uint8_t ntb_get_max_spads(struct ntb_softc *ntb);
-int ntb_write_local_spad(struct ntb_softc *ntb, unsigned int idx, uint32_t val);
-int ntb_read_local_spad(struct ntb_softc *ntb, unsigned int idx, uint32_t *val);
-int ntb_write_remote_spad(struct ntb_softc *ntb, unsigned int idx,
+int ntb_spad_write(struct ntb_softc *ntb, unsigned int idx, uint32_t val);
+int ntb_spad_read(struct ntb_softc *ntb, unsigned int idx, uint32_t *val);
+int ntb_peer_spad_write(struct ntb_softc *ntb, unsigned int idx,
     uint32_t val);
-int ntb_read_remote_spad(struct ntb_softc *ntb, unsigned int idx,
+int ntb_peer_spad_read(struct ntb_softc *ntb, unsigned int idx,
     uint32_t *val);
 void *ntb_get_mw_vbase(struct ntb_softc *ntb, unsigned int mw);
 bus_addr_t ntb_get_mw_pbase(struct ntb_softc *ntb, unsigned int mw);
 u_long ntb_get_mw_size(struct ntb_softc *ntb, unsigned int mw);
 void ntb_set_mw_addr(struct ntb_softc *ntb, unsigned int mw, uint64_t addr);
-void ntb_ring_doorbell(struct ntb_softc *ntb, unsigned int db);
+void ntb_peer_db_set(struct ntb_softc *ntb, uint64_t bit);
 bus_addr_t ntb_get_peer_db_addr(struct ntb_softc *ntb, vm_size_t *sz_out);
-bool ntb_query_link_status(struct ntb_softc *ntb);
+bool ntb_link_is_up(struct ntb_softc *ntb);
 device_t ntb_get_device(struct ntb_softc *ntb);
 
 /* Hardware owns the low 32 bits of features. */



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201510182020.t9IKKmKX093094>