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