1 /*******************************************************************************
2  *
3  * Intel Ethernet Controller XL710 Family Linux Driver
4  * Copyright(c) 2013 - 2014 Intel Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program.  If not, see <http://www.gnu.org/licenses/>.
17  *
18  * The full GNU General Public License is included in this distribution in
19  * the file called "COPYING".
20  *
21  * Contact Information:
22  * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
23  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24  *
25  ******************************************************************************/
26 
27 #include "i40e_osdep.h"
28 #include "i40e_register.h"
29 #include "i40e_status.h"
30 #include "i40e_alloc.h"
31 #include "i40e_hmc.h"
32 #include "i40e_type.h"
33 
34 /**
35  * i40e_add_sd_table_entry - Adds a segment descriptor to the table
36  * @hw: pointer to our hw struct
37  * @hmc_info: pointer to the HMC configuration information struct
38  * @sd_index: segment descriptor index to manipulate
39  * @type: what type of segment descriptor we're manipulating
40  * @direct_mode_sz: size to alloc in direct mode
41  **/
42 i40e_status i40e_add_sd_table_entry(struct i40e_hw *hw,
43 					      struct i40e_hmc_info *hmc_info,
44 					      u32 sd_index,
45 					      enum i40e_sd_entry_type type,
46 					      u64 direct_mode_sz)
47 {
48 	enum i40e_memory_type mem_type __attribute__((unused));
49 	struct i40e_hmc_sd_entry *sd_entry;
50 	bool dma_mem_alloc_done = false;
51 	struct i40e_dma_mem mem;
52 	i40e_status ret_code;
53 	u64 alloc_len;
54 
55 	if (NULL == hmc_info->sd_table.sd_entry) {
56 		ret_code = I40E_ERR_BAD_PTR;
57 		hw_dbg(hw, "i40e_add_sd_table_entry: bad sd_entry\n");
58 		goto exit;
59 	}
60 
61 	if (sd_index >= hmc_info->sd_table.sd_cnt) {
62 		ret_code = I40E_ERR_INVALID_SD_INDEX;
63 		hw_dbg(hw, "i40e_add_sd_table_entry: bad sd_index\n");
64 		goto exit;
65 	}
66 
67 	sd_entry = &hmc_info->sd_table.sd_entry[sd_index];
68 	if (!sd_entry->valid) {
69 		if (I40E_SD_TYPE_PAGED == type) {
70 			mem_type = i40e_mem_pd;
71 			alloc_len = I40E_HMC_PAGED_BP_SIZE;
72 		} else {
73 			mem_type = i40e_mem_bp_jumbo;
74 			alloc_len = direct_mode_sz;
75 		}
76 
77 		/* allocate a 4K pd page or 2M backing page */
78 		ret_code = i40e_allocate_dma_mem(hw, &mem, mem_type, alloc_len,
79 						 I40E_HMC_PD_BP_BUF_ALIGNMENT);
80 		if (ret_code)
81 			goto exit;
82 		dma_mem_alloc_done = true;
83 		if (I40E_SD_TYPE_PAGED == type) {
84 			ret_code = i40e_allocate_virt_mem(hw,
85 					&sd_entry->u.pd_table.pd_entry_virt_mem,
86 					sizeof(struct i40e_hmc_pd_entry) * 512);
87 			if (ret_code)
88 				goto exit;
89 			sd_entry->u.pd_table.pd_entry =
90 				(struct i40e_hmc_pd_entry *)
91 				sd_entry->u.pd_table.pd_entry_virt_mem.va;
92 			sd_entry->u.pd_table.pd_page_addr = mem;
93 		} else {
94 			sd_entry->u.bp.addr = mem;
95 			sd_entry->u.bp.sd_pd_index = sd_index;
96 		}
97 		/* initialize the sd entry */
98 		hmc_info->sd_table.sd_entry[sd_index].entry_type = type;
99 
100 		/* increment the ref count */
101 		I40E_INC_SD_REFCNT(&hmc_info->sd_table);
102 	}
103 	/* Increment backing page reference count */
104 	if (I40E_SD_TYPE_DIRECT == sd_entry->entry_type)
105 		I40E_INC_BP_REFCNT(&sd_entry->u.bp);
106 exit:
107 	if (ret_code)
108 		if (dma_mem_alloc_done)
109 			i40e_free_dma_mem(hw, &mem);
110 
111 	return ret_code;
112 }
113 
114 /**
115  * i40e_add_pd_table_entry - Adds page descriptor to the specified table
116  * @hw: pointer to our HW structure
117  * @hmc_info: pointer to the HMC configuration information structure
118  * @pd_index: which page descriptor index to manipulate
119  *
120  * This function:
121  *	1. Initializes the pd entry
122  *	2. Adds pd_entry in the pd_table
123  *	3. Mark the entry valid in i40e_hmc_pd_entry structure
124  *	4. Initializes the pd_entry's ref count to 1
125  * assumptions:
126  *	1. The memory for pd should be pinned down, physically contiguous and
127  *	   aligned on 4K boundary and zeroed memory.
128  *	2. It should be 4K in size.
129  **/
130 i40e_status i40e_add_pd_table_entry(struct i40e_hw *hw,
131 					      struct i40e_hmc_info *hmc_info,
132 					      u32 pd_index)
133 {
134 	i40e_status ret_code = 0;
135 	struct i40e_hmc_pd_table *pd_table;
136 	struct i40e_hmc_pd_entry *pd_entry;
137 	struct i40e_dma_mem mem;
138 	u32 sd_idx, rel_pd_idx;
139 	u64 *pd_addr;
140 	u64 page_desc;
141 
142 	if (pd_index / I40E_HMC_PD_CNT_IN_SD >= hmc_info->sd_table.sd_cnt) {
143 		ret_code = I40E_ERR_INVALID_PAGE_DESC_INDEX;
144 		hw_dbg(hw, "i40e_add_pd_table_entry: bad pd_index\n");
145 		goto exit;
146 	}
147 
148 	/* find corresponding sd */
149 	sd_idx = (pd_index / I40E_HMC_PD_CNT_IN_SD);
150 	if (I40E_SD_TYPE_PAGED !=
151 	    hmc_info->sd_table.sd_entry[sd_idx].entry_type)
152 		goto exit;
153 
154 	rel_pd_idx = (pd_index % I40E_HMC_PD_CNT_IN_SD);
155 	pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
156 	pd_entry = &pd_table->pd_entry[rel_pd_idx];
157 	if (!pd_entry->valid) {
158 		/* allocate a 4K backing page */
159 		ret_code = i40e_allocate_dma_mem(hw, &mem, i40e_mem_bp,
160 						 I40E_HMC_PAGED_BP_SIZE,
161 						 I40E_HMC_PD_BP_BUF_ALIGNMENT);
162 		if (ret_code)
163 			goto exit;
164 
165 		pd_entry->bp.addr = mem;
166 		pd_entry->bp.sd_pd_index = pd_index;
167 		pd_entry->bp.entry_type = I40E_SD_TYPE_PAGED;
168 		/* Set page address and valid bit */
169 		page_desc = mem.pa | 0x1;
170 
171 		pd_addr = (u64 *)pd_table->pd_page_addr.va;
172 		pd_addr += rel_pd_idx;
173 
174 		/* Add the backing page physical address in the pd entry */
175 		memcpy(pd_addr, &page_desc, sizeof(u64));
176 
177 		pd_entry->sd_index = sd_idx;
178 		pd_entry->valid = true;
179 		I40E_INC_PD_REFCNT(pd_table);
180 	}
181 	I40E_INC_BP_REFCNT(&pd_entry->bp);
182 exit:
183 	return ret_code;
184 }
185 
186 /**
187  * i40e_remove_pd_bp - remove a backing page from a page descriptor
188  * @hw: pointer to our HW structure
189  * @hmc_info: pointer to the HMC configuration information structure
190  * @idx: the page index
191  * @is_pf: distinguishes a VF from a PF
192  *
193  * This function:
194  *	1. Marks the entry in pd tabe (for paged address mode) or in sd table
195  *	   (for direct address mode) invalid.
196  *	2. Write to register PMPDINV to invalidate the backing page in FV cache
197  *	3. Decrement the ref count for the pd _entry
198  * assumptions:
199  *	1. Caller can deallocate the memory used by backing storage after this
200  *	   function returns.
201  **/
202 i40e_status i40e_remove_pd_bp(struct i40e_hw *hw,
203 					struct i40e_hmc_info *hmc_info,
204 					u32 idx, bool is_pf)
205 {
206 	i40e_status ret_code = 0;
207 	struct i40e_hmc_pd_entry *pd_entry;
208 	struct i40e_hmc_pd_table *pd_table;
209 	struct i40e_hmc_sd_entry *sd_entry;
210 	u32 sd_idx, rel_pd_idx;
211 	u64 *pd_addr;
212 
213 	/* calculate index */
214 	sd_idx = idx / I40E_HMC_PD_CNT_IN_SD;
215 	rel_pd_idx = idx % I40E_HMC_PD_CNT_IN_SD;
216 	if (sd_idx >= hmc_info->sd_table.sd_cnt) {
217 		ret_code = I40E_ERR_INVALID_PAGE_DESC_INDEX;
218 		hw_dbg(hw, "i40e_remove_pd_bp: bad idx\n");
219 		goto exit;
220 	}
221 	sd_entry = &hmc_info->sd_table.sd_entry[sd_idx];
222 	if (I40E_SD_TYPE_PAGED != sd_entry->entry_type) {
223 		ret_code = I40E_ERR_INVALID_SD_TYPE;
224 		hw_dbg(hw, "i40e_remove_pd_bp: wrong sd_entry type\n");
225 		goto exit;
226 	}
227 	/* get the entry and decrease its ref counter */
228 	pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
229 	pd_entry = &pd_table->pd_entry[rel_pd_idx];
230 	I40E_DEC_BP_REFCNT(&pd_entry->bp);
231 	if (pd_entry->bp.ref_cnt)
232 		goto exit;
233 
234 	/* mark the entry invalid */
235 	pd_entry->valid = false;
236 	I40E_DEC_PD_REFCNT(pd_table);
237 	pd_addr = (u64 *)pd_table->pd_page_addr.va;
238 	pd_addr += rel_pd_idx;
239 	memset(pd_addr, 0, sizeof(u64));
240 	if (is_pf)
241 		I40E_INVALIDATE_PF_HMC_PD(hw, sd_idx, idx);
242 	else
243 		I40E_INVALIDATE_VF_HMC_PD(hw, sd_idx, idx, hmc_info->hmc_fn_id);
244 
245 	/* free memory here */
246 	ret_code = i40e_free_dma_mem(hw, &(pd_entry->bp.addr));
247 	if (ret_code)
248 		goto exit;
249 	if (!pd_table->ref_cnt)
250 		i40e_free_virt_mem(hw, &pd_table->pd_entry_virt_mem);
251 exit:
252 	return ret_code;
253 }
254 
255 /**
256  * i40e_prep_remove_sd_bp - Prepares to remove a backing page from a sd entry
257  * @hmc_info: pointer to the HMC configuration information structure
258  * @idx: the page index
259  **/
260 i40e_status i40e_prep_remove_sd_bp(struct i40e_hmc_info *hmc_info,
261 					     u32 idx)
262 {
263 	i40e_status ret_code = 0;
264 	struct i40e_hmc_sd_entry *sd_entry;
265 
266 	/* get the entry and decrease its ref counter */
267 	sd_entry = &hmc_info->sd_table.sd_entry[idx];
268 	I40E_DEC_BP_REFCNT(&sd_entry->u.bp);
269 	if (sd_entry->u.bp.ref_cnt) {
270 		ret_code = I40E_ERR_NOT_READY;
271 		goto exit;
272 	}
273 	I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
274 
275 	/* mark the entry invalid */
276 	sd_entry->valid = false;
277 exit:
278 	return ret_code;
279 }
280 
281 /**
282  * i40e_remove_sd_bp_new - Removes a backing page from a segment descriptor
283  * @hw: pointer to our hw struct
284  * @hmc_info: pointer to the HMC configuration information structure
285  * @idx: the page index
286  * @is_pf: used to distinguish between VF and PF
287  **/
288 i40e_status i40e_remove_sd_bp_new(struct i40e_hw *hw,
289 					    struct i40e_hmc_info *hmc_info,
290 					    u32 idx, bool is_pf)
291 {
292 	struct i40e_hmc_sd_entry *sd_entry;
293 	i40e_status ret_code = 0;
294 
295 	/* get the entry and decrease its ref counter */
296 	sd_entry = &hmc_info->sd_table.sd_entry[idx];
297 	if (is_pf) {
298 		I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_DIRECT);
299 	} else {
300 		ret_code = I40E_NOT_SUPPORTED;
301 		goto exit;
302 	}
303 	ret_code = i40e_free_dma_mem(hw, &(sd_entry->u.bp.addr));
304 	if (ret_code)
305 		goto exit;
306 exit:
307 	return ret_code;
308 }
309 
310 /**
311  * i40e_prep_remove_pd_page - Prepares to remove a PD page from sd entry.
312  * @hmc_info: pointer to the HMC configuration information structure
313  * @idx: segment descriptor index to find the relevant page descriptor
314  **/
315 i40e_status i40e_prep_remove_pd_page(struct i40e_hmc_info *hmc_info,
316 					       u32 idx)
317 {
318 	i40e_status ret_code = 0;
319 	struct i40e_hmc_sd_entry *sd_entry;
320 
321 	sd_entry = &hmc_info->sd_table.sd_entry[idx];
322 
323 	if (sd_entry->u.pd_table.ref_cnt) {
324 		ret_code = I40E_ERR_NOT_READY;
325 		goto exit;
326 	}
327 
328 	/* mark the entry invalid */
329 	sd_entry->valid = false;
330 
331 	I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
332 exit:
333 	return ret_code;
334 }
335 
336 /**
337  * i40e_remove_pd_page_new - Removes a PD page from sd entry.
338  * @hw: pointer to our hw struct
339  * @hmc_info: pointer to the HMC configuration information structure
340  * @idx: segment descriptor index to find the relevant page descriptor
341  * @is_pf: used to distinguish between VF and PF
342  **/
343 i40e_status i40e_remove_pd_page_new(struct i40e_hw *hw,
344 					      struct i40e_hmc_info *hmc_info,
345 					      u32 idx, bool is_pf)
346 {
347 	i40e_status ret_code = 0;
348 	struct i40e_hmc_sd_entry *sd_entry;
349 
350 	sd_entry = &hmc_info->sd_table.sd_entry[idx];
351 	if (is_pf) {
352 		I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_PAGED);
353 	} else {
354 		ret_code = I40E_NOT_SUPPORTED;
355 		goto exit;
356 	}
357 	/* free memory here */
358 	ret_code = i40e_free_dma_mem(hw, &(sd_entry->u.pd_table.pd_page_addr));
359 	if (ret_code)
360 		goto exit;
361 exit:
362 	return ret_code;
363 }
364