1 /* $NetBSD: ixgbe_netbsd.c,v 1.3 2015/02/04 09:05:53 msaitoh Exp $ */
2 /*
3  * Copyright (c) 2011 The NetBSD Foundation, Inc.
4  * All rights reserved.
5  *
6  * This code is derived from software contributed to The NetBSD Foundation
7  * by Coyote Point Systems, Inc.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
19  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
20  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
22  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28  * POSSIBILITY OF SUCH DAMAGE.
29  */
30 #include <sys/param.h>
31 
32 #include <sys/atomic.h>
33 #include <sys/bus.h>
34 #include <sys/condvar.h>
35 #include <sys/cpu.h>
36 #include <sys/kmem.h>
37 #include <sys/mbuf.h>
38 #include <sys/mutex.h>
39 #include <sys/queue.h>
40 #include <sys/workqueue.h>
41 
42 #include "ixgbe_netbsd.h"
43 
44 void
ixgbe_dma_tag_destroy(ixgbe_dma_tag_t * dt)45 ixgbe_dma_tag_destroy(ixgbe_dma_tag_t *dt)
46 {
47 	kmem_free(dt, sizeof(*dt));
48 }
49 
50 int
ixgbe_dma_tag_create(bus_dma_tag_t dmat,bus_size_t alignment,bus_size_t boundary,bus_size_t maxsize,int nsegments,bus_size_t maxsegsize,int flags,ixgbe_dma_tag_t ** dtp)51 ixgbe_dma_tag_create(bus_dma_tag_t dmat, bus_size_t alignment,
52     bus_size_t boundary, bus_size_t maxsize, int nsegments,
53     bus_size_t maxsegsize, int flags, ixgbe_dma_tag_t **dtp)
54 {
55 	ixgbe_dma_tag_t *dt;
56 
57 	*dtp = NULL;
58 
59 	if ((dt = kmem_zalloc(sizeof(*dt), KM_SLEEP)) == NULL)
60 		return ENOMEM;
61 
62 	dt->dt_dmat = dmat;
63 	dt->dt_alignment = alignment;
64 	dt->dt_boundary = boundary;
65 	dt->dt_maxsize = maxsize;
66 	dt->dt_nsegments = nsegments;
67 	dt->dt_maxsegsize = maxsegsize;
68 	dt->dt_flags = flags;
69 	*dtp = dt;
70 
71 	return 0;
72 }
73 
74 void
ixgbe_dmamap_destroy(ixgbe_dma_tag_t * dt,bus_dmamap_t dmam)75 ixgbe_dmamap_destroy(ixgbe_dma_tag_t *dt, bus_dmamap_t dmam)
76 {
77 	bus_dmamap_destroy(dt->dt_dmat, dmam);
78 }
79 
80 void
ixgbe_dmamap_sync(ixgbe_dma_tag_t * dt,bus_dmamap_t dmam,int ops)81 ixgbe_dmamap_sync(ixgbe_dma_tag_t *dt, bus_dmamap_t dmam, int ops)
82 {
83         bus_dmamap_sync(dt->dt_dmat, dmam, 0, dt->dt_maxsize, ops);
84 }
85 
86 void
ixgbe_dmamap_unload(ixgbe_dma_tag_t * dt,bus_dmamap_t dmam)87 ixgbe_dmamap_unload(ixgbe_dma_tag_t *dt, bus_dmamap_t dmam)
88 {
89 	bus_dmamap_unload(dt->dt_dmat, dmam);
90 }
91 
92 int
ixgbe_dmamap_create(ixgbe_dma_tag_t * dt,int flags,bus_dmamap_t * dmamp)93 ixgbe_dmamap_create(ixgbe_dma_tag_t *dt, int flags, bus_dmamap_t *dmamp)
94 {
95 	return bus_dmamap_create(dt->dt_dmat, dt->dt_maxsize, dt->dt_nsegments,
96 	    dt->dt_maxsegsize, dt->dt_boundary, flags, dmamp);
97 }
98 
99 static void
ixgbe_putext(ixgbe_extmem_t * em)100 ixgbe_putext(ixgbe_extmem_t *em)
101 {
102 	ixgbe_extmem_head_t *eh = em->em_head;
103 
104 	mutex_enter(&eh->eh_mtx);
105 
106 	TAILQ_INSERT_HEAD(&eh->eh_freelist, em, em_link);
107 
108 	mutex_exit(&eh->eh_mtx);
109 
110 	return;
111 }
112 
113 static ixgbe_extmem_t *
ixgbe_getext(ixgbe_extmem_head_t * eh,size_t size)114 ixgbe_getext(ixgbe_extmem_head_t *eh, size_t size)
115 {
116 	ixgbe_extmem_t *em;
117 
118 	mutex_enter(&eh->eh_mtx);
119 
120 	TAILQ_FOREACH(em, &eh->eh_freelist, em_link) {
121 		if (em->em_size >= size)
122 			break;
123 	}
124 
125 	if (em != NULL)
126 		TAILQ_REMOVE(&eh->eh_freelist, em, em_link);
127 
128 	mutex_exit(&eh->eh_mtx);
129 
130 	return em;
131 }
132 
133 static ixgbe_extmem_t *
ixgbe_newext(ixgbe_extmem_head_t * eh,bus_dma_tag_t dmat,size_t size)134 ixgbe_newext(ixgbe_extmem_head_t *eh, bus_dma_tag_t dmat, size_t size)
135 {
136 	ixgbe_extmem_t *em;
137 	int nseg, rc;
138 
139 	em = kmem_zalloc(sizeof(*em), KM_SLEEP);
140 
141 	if (em == NULL)
142 		return NULL;
143 
144 	rc = bus_dmamem_alloc(dmat, size, PAGE_SIZE, 0, &em->em_seg, 1, &nseg,
145 	    BUS_DMA_WAITOK);
146 
147 	if (rc != 0)
148 		goto post_zalloc_err;
149 
150 	rc = bus_dmamem_map(dmat, &em->em_seg, 1, size, &em->em_vaddr,
151 	    BUS_DMA_WAITOK);
152 
153 	if (rc != 0)
154 		goto post_dmamem_err;
155 
156 	em->em_dmat = dmat;
157 	em->em_size = size;
158 	em->em_head = eh;
159 
160 	return em;
161 post_dmamem_err:
162 	bus_dmamem_free(dmat, &em->em_seg, 1);
163 post_zalloc_err:
164 	kmem_free(em, sizeof(*em));
165 	return NULL;
166 }
167 
168 void
ixgbe_jcl_reinit(ixgbe_extmem_head_t * eh,bus_dma_tag_t dmat,int nbuf,size_t size)169 ixgbe_jcl_reinit(ixgbe_extmem_head_t *eh, bus_dma_tag_t dmat, int nbuf,
170     size_t size)
171 {
172 	int i;
173 	ixgbe_extmem_t *em;
174 
175 	if (!eh->eh_initialized) {
176 		TAILQ_INIT(&eh->eh_freelist);
177 		mutex_init(&eh->eh_mtx, MUTEX_DEFAULT, IPL_NET);
178 		eh->eh_initialized = true;
179 	}
180 
181 	while ((em = ixgbe_getext(eh, 0)) != NULL) {
182 		KASSERT(em->em_vaddr != NULL);
183 		bus_dmamem_unmap(dmat, em->em_vaddr, em->em_size);
184 		bus_dmamem_free(dmat, &em->em_seg, 1);
185 		memset(em, 0, sizeof(*em));
186 		kmem_free(em, sizeof(*em));
187 	}
188 
189 	for (i = 0; i < nbuf; i++) {
190 		if ((em = ixgbe_newext(eh, dmat, size)) == NULL) {
191 			printf("%s: only %d of %d jumbo buffers allocated\n",
192 			    __func__, i, nbuf);
193 			break;
194 		}
195 		ixgbe_putext(em);
196 	}
197 }
198 
199 static void
ixgbe_jcl_free(struct mbuf * m,void * buf,size_t size,void * arg)200 ixgbe_jcl_free(struct mbuf *m, void *buf, size_t size, void *arg)
201 {
202 	ixgbe_extmem_t *em = arg;
203 
204 	KASSERT(em->em_size == size);
205 
206 	ixgbe_putext(em);
207 	/* this is an abstraction violation, but it does not lead to a
208 	 * double-free
209 	 */
210 	if (__predict_true(m != NULL)) {
211 		KASSERT(m->m_type != MT_FREE);
212 		m->m_type = MT_FREE;
213 		pool_cache_put(mb_cache, m);
214 	}
215 }
216 
217 /* XXX need to wait for the system to finish with each jumbo mbuf and
218  * free it before detaching the driver from the device.
219  */
220 struct mbuf *
ixgbe_getjcl(ixgbe_extmem_head_t * eh,int nowait,int type,int flags,size_t size)221 ixgbe_getjcl(ixgbe_extmem_head_t *eh, int nowait /* M_DONTWAIT */,
222     int type /* MT_DATA */, int flags /* M_PKTHDR */, size_t size)
223 {
224 	ixgbe_extmem_t *em;
225 	struct mbuf *m;
226 
227 	if ((flags & M_PKTHDR) != 0)
228 		m = m_gethdr(nowait, type);
229 	else
230 		m = m_get(nowait, type);
231 
232 	if (m == NULL)
233 		return NULL;
234 
235 	em = ixgbe_getext(eh, size);
236 	if (em == NULL) {
237 		m_freem(m);
238 		return NULL;
239 	}
240 
241 	MEXTADD(m, em->em_vaddr, em->em_size, M_DEVBUF, &ixgbe_jcl_free, em);
242 
243 	if ((m->m_flags & M_EXT) == 0) {
244 		ixgbe_putext(em);
245 		m_freem(m);
246 		return NULL;
247 	}
248 
249 	return m;
250 }
251