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