1 /******************************************************************************
2
3 Copyright (c) 2013-2015, Intel Corporation
4 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 are met:
8
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
11
12 2. Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in the
14 documentation and/or other materials provided with the distribution.
15
16 3. Neither the name of the Intel Corporation nor the names of its
17 contributors may be used to endorse or promote products derived from
18 this software without specific prior written permission.
19
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
31
32 ******************************************************************************/
33 /*$FreeBSD$*/
34
35 #include "i40e_osdep.h"
36 #include "i40e_register.h"
37 #include "i40e_status.h"
38 #include "i40e_alloc.h"
39 #include "i40e_hmc.h"
40 #include "i40e_type.h"
41
42 /**
43 * i40e_add_sd_table_entry - Adds a segment descriptor to the table
44 * @hw: pointer to our hw struct
45 * @hmc_info: pointer to the HMC configuration information struct
46 * @sd_index: segment descriptor index to manipulate
47 * @type: what type of segment descriptor we're manipulating
48 * @direct_mode_sz: size to alloc in direct mode
49 **/
i40e_add_sd_table_entry(struct i40e_hw * hw,struct i40e_hmc_info * hmc_info,u32 sd_index,enum i40e_sd_entry_type type,u64 direct_mode_sz)50 enum i40e_status_code i40e_add_sd_table_entry(struct i40e_hw *hw,
51 struct i40e_hmc_info *hmc_info,
52 u32 sd_index,
53 enum i40e_sd_entry_type type,
54 u64 direct_mode_sz)
55 {
56 enum i40e_status_code ret_code = I40E_SUCCESS;
57 struct i40e_hmc_sd_entry *sd_entry;
58 enum i40e_memory_type mem_type;
59 bool dma_mem_alloc_done = FALSE;
60 struct i40e_dma_mem mem;
61 u64 alloc_len;
62
63 if (NULL == hmc_info->sd_table.sd_entry) {
64 ret_code = I40E_ERR_BAD_PTR;
65 DEBUGOUT("i40e_add_sd_table_entry: bad sd_entry\n");
66 goto exit;
67 }
68
69 if (sd_index >= hmc_info->sd_table.sd_cnt) {
70 ret_code = I40E_ERR_INVALID_SD_INDEX;
71 DEBUGOUT("i40e_add_sd_table_entry: bad sd_index\n");
72 goto exit;
73 }
74
75 sd_entry = &hmc_info->sd_table.sd_entry[sd_index];
76 if (!sd_entry->valid) {
77 if (I40E_SD_TYPE_PAGED == type) {
78 mem_type = i40e_mem_pd;
79 alloc_len = I40E_HMC_PAGED_BP_SIZE;
80 } else {
81 mem_type = i40e_mem_bp_jumbo;
82 alloc_len = direct_mode_sz;
83 }
84
85 /* allocate a 4K pd page or 2M backing page */
86 ret_code = i40e_allocate_dma_mem(hw, &mem, mem_type, alloc_len,
87 I40E_HMC_PD_BP_BUF_ALIGNMENT);
88 if (ret_code)
89 goto exit;
90 dma_mem_alloc_done = TRUE;
91 if (I40E_SD_TYPE_PAGED == type) {
92 ret_code = i40e_allocate_virt_mem(hw,
93 &sd_entry->u.pd_table.pd_entry_virt_mem,
94 sizeof(struct i40e_hmc_pd_entry) * 512);
95 if (ret_code)
96 goto exit;
97 sd_entry->u.pd_table.pd_entry =
98 (struct i40e_hmc_pd_entry *)
99 sd_entry->u.pd_table.pd_entry_virt_mem.va;
100 i40e_memcpy(&sd_entry->u.pd_table.pd_page_addr,
101 &mem, sizeof(struct i40e_dma_mem),
102 I40E_NONDMA_TO_NONDMA);
103 } else {
104 i40e_memcpy(&sd_entry->u.bp.addr,
105 &mem, sizeof(struct i40e_dma_mem),
106 I40E_NONDMA_TO_NONDMA);
107 sd_entry->u.bp.sd_pd_index = sd_index;
108 }
109 /* initialize the sd entry */
110 hmc_info->sd_table.sd_entry[sd_index].entry_type = type;
111
112 /* increment the ref count */
113 I40E_INC_SD_REFCNT(&hmc_info->sd_table);
114 }
115 /* Increment backing page reference count */
116 if (I40E_SD_TYPE_DIRECT == sd_entry->entry_type)
117 I40E_INC_BP_REFCNT(&sd_entry->u.bp);
118 exit:
119 if (I40E_SUCCESS != ret_code)
120 if (dma_mem_alloc_done)
121 i40e_free_dma_mem(hw, &mem);
122
123 return ret_code;
124 }
125
126 /**
127 * i40e_add_pd_table_entry - Adds page descriptor to the specified table
128 * @hw: pointer to our HW structure
129 * @hmc_info: pointer to the HMC configuration information structure
130 * @pd_index: which page descriptor index to manipulate
131 * @rsrc_pg: if not NULL, use preallocated page instead of allocating new one.
132 *
133 * This function:
134 * 1. Initializes the pd entry
135 * 2. Adds pd_entry in the pd_table
136 * 3. Mark the entry valid in i40e_hmc_pd_entry structure
137 * 4. Initializes the pd_entry's ref count to 1
138 * assumptions:
139 * 1. The memory for pd should be pinned down, physically contiguous and
140 * aligned on 4K boundary and zeroed memory.
141 * 2. It should be 4K in size.
142 **/
i40e_add_pd_table_entry(struct i40e_hw * hw,struct i40e_hmc_info * hmc_info,u32 pd_index,struct i40e_dma_mem * rsrc_pg)143 enum i40e_status_code i40e_add_pd_table_entry(struct i40e_hw *hw,
144 struct i40e_hmc_info *hmc_info,
145 u32 pd_index,
146 struct i40e_dma_mem *rsrc_pg)
147 {
148 enum i40e_status_code ret_code = I40E_SUCCESS;
149 struct i40e_hmc_pd_table *pd_table;
150 struct i40e_hmc_pd_entry *pd_entry;
151 struct i40e_dma_mem mem;
152 struct i40e_dma_mem *page = &mem;
153 u32 sd_idx, rel_pd_idx;
154 u64 *pd_addr;
155 u64 page_desc;
156
157 if (pd_index / I40E_HMC_PD_CNT_IN_SD >= hmc_info->sd_table.sd_cnt) {
158 ret_code = I40E_ERR_INVALID_PAGE_DESC_INDEX;
159 DEBUGOUT("i40e_add_pd_table_entry: bad pd_index\n");
160 goto exit;
161 }
162
163 /* find corresponding sd */
164 sd_idx = (pd_index / I40E_HMC_PD_CNT_IN_SD);
165 if (I40E_SD_TYPE_PAGED !=
166 hmc_info->sd_table.sd_entry[sd_idx].entry_type)
167 goto exit;
168
169 rel_pd_idx = (pd_index % I40E_HMC_PD_CNT_IN_SD);
170 pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
171 pd_entry = &pd_table->pd_entry[rel_pd_idx];
172 if (!pd_entry->valid) {
173 if (rsrc_pg) {
174 pd_entry->rsrc_pg = TRUE;
175 page = rsrc_pg;
176 } else {
177 /* allocate a 4K backing page */
178 ret_code = i40e_allocate_dma_mem(hw, page, i40e_mem_bp,
179 I40E_HMC_PAGED_BP_SIZE,
180 I40E_HMC_PD_BP_BUF_ALIGNMENT);
181 if (ret_code)
182 goto exit;
183 pd_entry->rsrc_pg = FALSE;
184 }
185
186 i40e_memcpy(&pd_entry->bp.addr, page,
187 sizeof(struct i40e_dma_mem), I40E_NONDMA_TO_NONDMA);
188 pd_entry->bp.sd_pd_index = pd_index;
189 pd_entry->bp.entry_type = I40E_SD_TYPE_PAGED;
190 /* Set page address and valid bit */
191 page_desc = page->pa | 0x1;
192
193 pd_addr = (u64 *)pd_table->pd_page_addr.va;
194 pd_addr += rel_pd_idx;
195
196 /* Add the backing page physical address in the pd entry */
197 i40e_memcpy(pd_addr, &page_desc, sizeof(u64),
198 I40E_NONDMA_TO_DMA);
199
200 pd_entry->sd_index = sd_idx;
201 pd_entry->valid = TRUE;
202 I40E_INC_PD_REFCNT(pd_table);
203 }
204 I40E_INC_BP_REFCNT(&pd_entry->bp);
205 exit:
206 return ret_code;
207 }
208
209 /**
210 * i40e_remove_pd_bp - remove a backing page from a page descriptor
211 * @hw: pointer to our HW structure
212 * @hmc_info: pointer to the HMC configuration information structure
213 * @idx: the page index
214 * @is_pf: distinguishes a VF from a PF
215 *
216 * This function:
217 * 1. Marks the entry in pd tabe (for paged address mode) or in sd table
218 * (for direct address mode) invalid.
219 * 2. Write to register PMPDINV to invalidate the backing page in FV cache
220 * 3. Decrement the ref count for the pd _entry
221 * assumptions:
222 * 1. Caller can deallocate the memory used by backing storage after this
223 * function returns.
224 **/
i40e_remove_pd_bp(struct i40e_hw * hw,struct i40e_hmc_info * hmc_info,u32 idx)225 enum i40e_status_code i40e_remove_pd_bp(struct i40e_hw *hw,
226 struct i40e_hmc_info *hmc_info,
227 u32 idx)
228 {
229 enum i40e_status_code ret_code = I40E_SUCCESS;
230 struct i40e_hmc_pd_entry *pd_entry;
231 struct i40e_hmc_pd_table *pd_table;
232 struct i40e_hmc_sd_entry *sd_entry;
233 u32 sd_idx, rel_pd_idx;
234 u64 *pd_addr;
235
236 /* calculate index */
237 sd_idx = idx / I40E_HMC_PD_CNT_IN_SD;
238 rel_pd_idx = idx % I40E_HMC_PD_CNT_IN_SD;
239 if (sd_idx >= hmc_info->sd_table.sd_cnt) {
240 ret_code = I40E_ERR_INVALID_PAGE_DESC_INDEX;
241 DEBUGOUT("i40e_remove_pd_bp: bad idx\n");
242 goto exit;
243 }
244 sd_entry = &hmc_info->sd_table.sd_entry[sd_idx];
245 if (I40E_SD_TYPE_PAGED != sd_entry->entry_type) {
246 ret_code = I40E_ERR_INVALID_SD_TYPE;
247 DEBUGOUT("i40e_remove_pd_bp: wrong sd_entry type\n");
248 goto exit;
249 }
250 /* get the entry and decrease its ref counter */
251 pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
252 pd_entry = &pd_table->pd_entry[rel_pd_idx];
253 I40E_DEC_BP_REFCNT(&pd_entry->bp);
254 if (pd_entry->bp.ref_cnt)
255 goto exit;
256
257 /* mark the entry invalid */
258 pd_entry->valid = FALSE;
259 I40E_DEC_PD_REFCNT(pd_table);
260 pd_addr = (u64 *)pd_table->pd_page_addr.va;
261 pd_addr += rel_pd_idx;
262 i40e_memset(pd_addr, 0, sizeof(u64), I40E_DMA_MEM);
263 I40E_INVALIDATE_PF_HMC_PD(hw, sd_idx, idx);
264
265 /* free memory here */
266 if (!pd_entry->rsrc_pg)
267 ret_code = i40e_free_dma_mem(hw, &(pd_entry->bp.addr));
268 if (I40E_SUCCESS != ret_code)
269 goto exit;
270 if (!pd_table->ref_cnt)
271 i40e_free_virt_mem(hw, &pd_table->pd_entry_virt_mem);
272 exit:
273 return ret_code;
274 }
275
276 /**
277 * i40e_prep_remove_sd_bp - Prepares to remove a backing page from a sd entry
278 * @hmc_info: pointer to the HMC configuration information structure
279 * @idx: the page index
280 **/
i40e_prep_remove_sd_bp(struct i40e_hmc_info * hmc_info,u32 idx)281 enum i40e_status_code i40e_prep_remove_sd_bp(struct i40e_hmc_info *hmc_info,
282 u32 idx)
283 {
284 enum i40e_status_code ret_code = I40E_SUCCESS;
285 struct i40e_hmc_sd_entry *sd_entry;
286
287 /* get the entry and decrease its ref counter */
288 sd_entry = &hmc_info->sd_table.sd_entry[idx];
289 I40E_DEC_BP_REFCNT(&sd_entry->u.bp);
290 if (sd_entry->u.bp.ref_cnt) {
291 ret_code = I40E_ERR_NOT_READY;
292 goto exit;
293 }
294 I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
295
296 /* mark the entry invalid */
297 sd_entry->valid = FALSE;
298 exit:
299 return ret_code;
300 }
301
302 /**
303 * i40e_remove_sd_bp_new - Removes a backing page from a segment descriptor
304 * @hw: pointer to our hw struct
305 * @hmc_info: pointer to the HMC configuration information structure
306 * @idx: the page index
307 * @is_pf: used to distinguish between VF and PF
308 **/
i40e_remove_sd_bp_new(struct i40e_hw * hw,struct i40e_hmc_info * hmc_info,u32 idx,bool is_pf)309 enum i40e_status_code i40e_remove_sd_bp_new(struct i40e_hw *hw,
310 struct i40e_hmc_info *hmc_info,
311 u32 idx, bool is_pf)
312 {
313 struct i40e_hmc_sd_entry *sd_entry;
314
315 if (!is_pf)
316 return I40E_NOT_SUPPORTED;
317
318 /* get the entry and decrease its ref counter */
319 sd_entry = &hmc_info->sd_table.sd_entry[idx];
320 I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_DIRECT);
321
322 return i40e_free_dma_mem(hw, &(sd_entry->u.bp.addr));
323 }
324
325 /**
326 * i40e_prep_remove_pd_page - Prepares to remove a PD page from sd entry.
327 * @hmc_info: pointer to the HMC configuration information structure
328 * @idx: segment descriptor index to find the relevant page descriptor
329 **/
i40e_prep_remove_pd_page(struct i40e_hmc_info * hmc_info,u32 idx)330 enum i40e_status_code i40e_prep_remove_pd_page(struct i40e_hmc_info *hmc_info,
331 u32 idx)
332 {
333 enum i40e_status_code ret_code = I40E_SUCCESS;
334 struct i40e_hmc_sd_entry *sd_entry;
335
336 sd_entry = &hmc_info->sd_table.sd_entry[idx];
337
338 if (sd_entry->u.pd_table.ref_cnt) {
339 ret_code = I40E_ERR_NOT_READY;
340 goto exit;
341 }
342
343 /* mark the entry invalid */
344 sd_entry->valid = FALSE;
345
346 I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
347 exit:
348 return ret_code;
349 }
350
351 /**
352 * i40e_remove_pd_page_new - Removes a PD page from sd entry.
353 * @hw: pointer to our hw struct
354 * @hmc_info: pointer to the HMC configuration information structure
355 * @idx: segment descriptor index to find the relevant page descriptor
356 * @is_pf: used to distinguish between VF and PF
357 **/
i40e_remove_pd_page_new(struct i40e_hw * hw,struct i40e_hmc_info * hmc_info,u32 idx,bool is_pf)358 enum i40e_status_code i40e_remove_pd_page_new(struct i40e_hw *hw,
359 struct i40e_hmc_info *hmc_info,
360 u32 idx, bool is_pf)
361 {
362 struct i40e_hmc_sd_entry *sd_entry;
363
364 if (!is_pf)
365 return I40E_NOT_SUPPORTED;
366
367 sd_entry = &hmc_info->sd_table.sd_entry[idx];
368 I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_PAGED);
369
370 return i40e_free_dma_mem(hw, &(sd_entry->u.pd_table.pd_page_addr));
371 }
372