xref: /freebsd/sys/dev/netmap/if_re_netmap.h (revision 7ef62cebc2f965b0f640263e179276928885e33d)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (C) 2011-2014 Luigi Rizzo. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  */
27 
28 /*
29  * $FreeBSD$
30  *
31  * netmap support for: re
32  *
33  * For more details on netmap support please see ixgbe_netmap.h
34  */
35 
36 
37 #include <net/netmap.h>
38 #include <sys/selinfo.h>
39 #include <vm/vm.h>
40 #include <vm/pmap.h>    /* vtophys ? */
41 #include <dev/netmap/netmap_kern.h>
42 
43 
44 /*
45  * Register/unregister. We are already under netmap lock.
46  */
47 static int
48 re_netmap_reg(struct netmap_adapter *na, int onoff)
49 {
50 	if_t ifp = na->ifp;
51 	struct rl_softc *adapter = if_getsoftc(ifp);
52 
53 	RL_LOCK(adapter);
54 	re_stop(adapter); /* also clears IFF_DRV_RUNNING */
55 	if (onoff) {
56 		nm_set_native_flags(na);
57 	} else {
58 		nm_clear_native_flags(na);
59 	}
60 	re_init_locked(adapter);	/* also enables intr */
61 	RL_UNLOCK(adapter);
62 	return (if_getdrvflags(ifp) & IFF_DRV_RUNNING ? 0 : 1);
63 }
64 
65 
66 /*
67  * Reconcile kernel and user view of the transmit ring.
68  */
69 static int
70 re_netmap_txsync(struct netmap_kring *kring, int flags)
71 {
72 	struct netmap_adapter *na = kring->na;
73 	if_t ifp = na->ifp;
74 	struct netmap_ring *ring = kring->ring;
75 	u_int nm_i;	/* index into the netmap ring */
76 	u_int nic_i;	/* index into the NIC ring */
77 	u_int n;
78 	u_int const lim = kring->nkr_num_slots - 1;
79 	u_int const head = kring->rhead;
80 
81 	/* device-specific */
82 	struct rl_softc *sc = if_getsoftc(ifp);
83 	struct rl_txdesc *txd = sc->rl_ldata.rl_tx_desc;
84 
85 	bus_dmamap_sync(sc->rl_ldata.rl_tx_list_tag,
86 	    sc->rl_ldata.rl_tx_list_map,
87 	    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); // XXX extra postwrite ?
88 
89 	/*
90 	 * First part: process new packets to send.
91 	 */
92 	nm_i = kring->nr_hwcur;
93 	if (nm_i != head) {	/* we have new packets to send */
94 		nic_i = sc->rl_ldata.rl_tx_prodidx;
95 		// XXX or netmap_idx_k2n(kring, nm_i);
96 
97 		for (n = 0; nm_i != head; n++) {
98 			struct netmap_slot *slot = &ring->slot[nm_i];
99 			u_int len = slot->len;
100 			uint64_t paddr;
101 			void *addr = PNMB(na, slot, &paddr);
102 
103 			/* device-specific */
104 			struct rl_desc *desc = &sc->rl_ldata.rl_tx_list[nic_i];
105 			int cmd = slot->len | RL_TDESC_CMD_EOF |
106 				RL_TDESC_CMD_OWN | RL_TDESC_CMD_SOF ;
107 
108 			NM_CHECK_ADDR_LEN(na, addr, len);
109 
110 			if (nic_i == lim)	/* mark end of ring */
111 				cmd |= RL_TDESC_CMD_EOR;
112 
113 			if (slot->flags & NS_BUF_CHANGED) {
114 				/* buffer has changed, reload map */
115 				desc->rl_bufaddr_lo = htole32(RL_ADDR_LO(paddr));
116 				desc->rl_bufaddr_hi = htole32(RL_ADDR_HI(paddr));
117 				netmap_reload_map(na, sc->rl_ldata.rl_tx_mtag,
118 					txd[nic_i].tx_dmamap, addr);
119 			}
120 			slot->flags &= ~(NS_REPORT | NS_BUF_CHANGED);
121 
122 			/* Fill the slot in the NIC ring. */
123 			desc->rl_cmdstat = htole32(cmd);
124 
125 			/* make sure changes to the buffer are synced */
126 			bus_dmamap_sync(sc->rl_ldata.rl_tx_mtag,
127 				txd[nic_i].tx_dmamap,
128 				BUS_DMASYNC_PREWRITE);
129 
130 			nm_i = nm_next(nm_i, lim);
131 			nic_i = nm_next(nic_i, lim);
132 		}
133 		sc->rl_ldata.rl_tx_prodidx = nic_i;
134 		kring->nr_hwcur = head;
135 
136 		/* synchronize the NIC ring */
137 		bus_dmamap_sync(sc->rl_ldata.rl_tx_list_tag,
138 			sc->rl_ldata.rl_tx_list_map,
139 			BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
140 
141 		/* start ? */
142 		CSR_WRITE_1(sc, sc->rl_txstart, RL_TXSTART_START);
143 	}
144 
145 	/*
146 	 * Second part: reclaim buffers for completed transmissions.
147 	 */
148 	if (flags & NAF_FORCE_RECLAIM || nm_kr_txempty(kring)) {
149 		nic_i = sc->rl_ldata.rl_tx_considx;
150 		for (n = 0; nic_i != sc->rl_ldata.rl_tx_prodidx;
151 		    n++, nic_i = RL_TX_DESC_NXT(sc, nic_i)) {
152 			uint32_t cmdstat =
153 				le32toh(sc->rl_ldata.rl_tx_list[nic_i].rl_cmdstat);
154 			if (cmdstat & RL_TDESC_STAT_OWN)
155 				break;
156 		}
157 		if (n > 0) {
158 			sc->rl_ldata.rl_tx_considx = nic_i;
159 			sc->rl_ldata.rl_tx_free += n;
160 			kring->nr_hwtail = nm_prev(netmap_idx_n2k(kring, nic_i), lim);
161 		}
162 	}
163 
164 	return 0;
165 }
166 
167 
168 /*
169  * Reconcile kernel and user view of the receive ring.
170  */
171 static int
172 re_netmap_rxsync(struct netmap_kring *kring, int flags)
173 {
174 	struct netmap_adapter *na = kring->na;
175 	if_t ifp = na->ifp;
176 	struct netmap_ring *ring = kring->ring;
177 	u_int nm_i;	/* index into the netmap ring */
178 	u_int nic_i;	/* index into the NIC ring */
179 	u_int const lim = kring->nkr_num_slots - 1;
180 	u_int const head = kring->rhead;
181 	int force_update = (flags & NAF_FORCE_READ) || kring->nr_kflags & NKR_PENDINTR;
182 
183 	/* device-specific */
184 	struct rl_softc *sc = if_getsoftc(ifp);
185 	struct rl_rxdesc *rxd = sc->rl_ldata.rl_rx_desc;
186 
187 	if (head > lim)
188 		return netmap_ring_reinit(kring);
189 
190 	bus_dmamap_sync(sc->rl_ldata.rl_rx_list_tag,
191 			sc->rl_ldata.rl_rx_list_map,
192 			BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
193 
194 	/*
195 	 * First part: import newly received packets.
196 	 *
197 	 * This device uses all the buffers in the ring, so we need
198 	 * another termination condition in addition to RL_RDESC_STAT_OWN
199 	 * cleared (all buffers could have it cleared). The easiest one
200 	 * is to stop right before nm_hwcur.
201 	 */
202 	if (netmap_no_pendintr || force_update) {
203 		uint32_t stop_i = nm_prev(kring->nr_hwcur, lim);
204 
205 		nic_i = sc->rl_ldata.rl_rx_prodidx; /* next pkt to check */
206 		nm_i = netmap_idx_n2k(kring, nic_i);
207 
208 		while (nm_i != stop_i) {
209 			struct rl_desc *cur_rx = &sc->rl_ldata.rl_rx_list[nic_i];
210 			uint32_t rxstat = le32toh(cur_rx->rl_cmdstat);
211 			uint32_t total_len;
212 
213 			if ((rxstat & RL_RDESC_STAT_OWN) != 0)
214 				break;
215 			total_len = rxstat & sc->rl_rxlenmask;
216 			/* XXX subtract crc */
217 			total_len = (total_len < 4) ? 0 : total_len - 4;
218 			ring->slot[nm_i].len = total_len;
219 			ring->slot[nm_i].flags = 0;
220 			/*  sync was in re_newbuf() */
221 			bus_dmamap_sync(sc->rl_ldata.rl_rx_mtag,
222 			    rxd[nic_i].rx_dmamap, BUS_DMASYNC_POSTREAD);
223 			// if_inc_counter(sc->rl_ifp, IFCOUNTER_IPACKETS, 1);
224 			nm_i = nm_next(nm_i, lim);
225 			nic_i = nm_next(nic_i, lim);
226 		}
227 		sc->rl_ldata.rl_rx_prodidx = nic_i;
228 		kring->nr_hwtail = nm_i;
229 		kring->nr_kflags &= ~NKR_PENDINTR;
230 	}
231 
232 	/*
233 	 * Second part: skip past packets that userspace has released.
234 	 */
235 	nm_i = kring->nr_hwcur;
236 	if (nm_i != head) {
237 		nic_i = netmap_idx_k2n(kring, nm_i);
238 		while (nm_i != head) {
239 			struct netmap_slot *slot = &ring->slot[nm_i];
240 			uint64_t paddr;
241 			void *addr = PNMB(na, slot, &paddr);
242 
243 			struct rl_desc *desc = &sc->rl_ldata.rl_rx_list[nic_i];
244 			int cmd = NETMAP_BUF_SIZE(na) | RL_RDESC_CMD_OWN;
245 
246 			if (addr == NETMAP_BUF_BASE(na)) /* bad buf */
247 				goto ring_reset;
248 
249 			if (nic_i == lim)	/* mark end of ring */
250 				cmd |= RL_RDESC_CMD_EOR;
251 
252 			if (slot->flags & NS_BUF_CHANGED) {
253 				/* buffer has changed, reload map */
254 				desc->rl_bufaddr_lo = htole32(RL_ADDR_LO(paddr));
255 				desc->rl_bufaddr_hi = htole32(RL_ADDR_HI(paddr));
256 				netmap_reload_map(na, sc->rl_ldata.rl_rx_mtag,
257 					rxd[nic_i].rx_dmamap, addr);
258 				slot->flags &= ~NS_BUF_CHANGED;
259 			}
260 			desc->rl_cmdstat = htole32(cmd);
261 			bus_dmamap_sync(sc->rl_ldata.rl_rx_mtag,
262 			    rxd[nic_i].rx_dmamap,
263 			    BUS_DMASYNC_PREREAD);
264 			nm_i = nm_next(nm_i, lim);
265 			nic_i = nm_next(nic_i, lim);
266 		}
267 		kring->nr_hwcur = head;
268 
269 		bus_dmamap_sync(sc->rl_ldata.rl_rx_list_tag,
270 		    sc->rl_ldata.rl_rx_list_map,
271 		    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
272 	}
273 
274 	return 0;
275 
276 ring_reset:
277 	return netmap_ring_reinit(kring);
278 }
279 
280 
281 /*
282  * Additional routines to init the tx and rx rings.
283  * In other drivers we do that inline in the main code.
284  */
285 static void
286 re_netmap_tx_init(struct rl_softc *sc)
287 {
288 	struct rl_txdesc *txd;
289 	struct rl_desc *desc;
290 	int i, n;
291 	struct netmap_adapter *na = NA(sc->rl_ifp);
292 	struct netmap_slot *slot;
293 
294 	slot = netmap_reset(na, NR_TX, 0, 0);
295 	/* slot is NULL if we are not in native netmap mode */
296 	if (!slot)
297 		return;
298 	/* in netmap mode, overwrite addresses and maps */
299 	txd = sc->rl_ldata.rl_tx_desc;
300 	desc = sc->rl_ldata.rl_tx_list;
301 	n = sc->rl_ldata.rl_tx_desc_cnt;
302 
303 	/* l points in the netmap ring, i points in the NIC ring */
304 	for (i = 0; i < n; i++) {
305 		uint64_t paddr;
306 		int l = netmap_idx_n2k(na->tx_rings[0], i);
307 		void *addr = PNMB(na, slot + l, &paddr);
308 
309 		desc[i].rl_bufaddr_lo = htole32(RL_ADDR_LO(paddr));
310 		desc[i].rl_bufaddr_hi = htole32(RL_ADDR_HI(paddr));
311 		netmap_load_map(na, sc->rl_ldata.rl_tx_mtag,
312 			txd[i].tx_dmamap, addr);
313 	}
314 }
315 
316 static void
317 re_netmap_rx_init(struct rl_softc *sc)
318 {
319 	struct netmap_adapter *na = NA(sc->rl_ifp);
320 	struct netmap_slot *slot = netmap_reset(na, NR_RX, 0, 0);
321 	struct rl_desc *desc = sc->rl_ldata.rl_rx_list;
322 	uint32_t cmdstat;
323 	uint32_t nic_i, max_avail;
324 	uint32_t const n = sc->rl_ldata.rl_rx_desc_cnt;
325 
326 	if (!slot)
327 		return;
328 	/*
329 	 * Do not release the slots owned by userspace,
330 	 * and also keep one empty.
331 	 */
332 	max_avail = n - 1 - nm_kr_rxspace(na->rx_rings[0]);
333 	for (nic_i = 0; nic_i < n; nic_i++) {
334 		void *addr;
335 		uint64_t paddr;
336 		uint32_t nm_i = netmap_idx_n2k(na->rx_rings[0], nic_i);
337 
338 		addr = PNMB(na, slot + nm_i, &paddr);
339 
340 		netmap_reload_map(na, sc->rl_ldata.rl_rx_mtag,
341 		    sc->rl_ldata.rl_rx_desc[nic_i].rx_dmamap, addr);
342 		bus_dmamap_sync(sc->rl_ldata.rl_rx_mtag,
343 		    sc->rl_ldata.rl_rx_desc[nic_i].rx_dmamap, BUS_DMASYNC_PREREAD);
344 		desc[nic_i].rl_bufaddr_lo = htole32(RL_ADDR_LO(paddr));
345 		desc[nic_i].rl_bufaddr_hi = htole32(RL_ADDR_HI(paddr));
346 		cmdstat = NETMAP_BUF_SIZE(na);
347 		if (nic_i == n - 1) /* mark the end of ring */
348 			cmdstat |= RL_RDESC_CMD_EOR;
349 		if (nic_i < max_avail)
350 			cmdstat |= RL_RDESC_CMD_OWN;
351 		desc[nic_i].rl_cmdstat = htole32(cmdstat);
352 	}
353 }
354 
355 
356 static void
357 re_netmap_attach(struct rl_softc *sc)
358 {
359 	struct netmap_adapter na;
360 
361 	bzero(&na, sizeof(na));
362 
363 	na.ifp = sc->rl_ifp;
364 	na.na_flags = NAF_BDG_MAYSLEEP;
365 	na.num_tx_desc = sc->rl_ldata.rl_tx_desc_cnt;
366 	na.num_rx_desc = sc->rl_ldata.rl_rx_desc_cnt;
367 	na.nm_txsync = re_netmap_txsync;
368 	na.nm_rxsync = re_netmap_rxsync;
369 	na.nm_register = re_netmap_reg;
370 	na.num_tx_rings = na.num_rx_rings = 1;
371 	netmap_attach(&na);
372 }
373 
374 /* end of file */
375