1 /*******************************************************************************
3 * Intel Ethernet Controller XL710 Family Linux Driver
4 * Copyright(c) 2013 - 2014 Intel Corporation.
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.
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
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/>.
18 * The full GNU General Public License is included in this distribution in
19 * the file called "COPYING".
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
25 ******************************************************************************/
27 #include "i40e_osdep.h"
28 #include "i40e_register.h"
29 #include "i40e_status.h"
30 #include "i40e_alloc.h"
32 #include "i40e_type.h"
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
42 i40e_status
i40e_add_sd_table_entry(struct i40e_hw
*hw
,
43 struct i40e_hmc_info
*hmc_info
,
45 enum i40e_sd_entry_type type
,
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
;
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");
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");
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
;
73 mem_type
= i40e_mem_bp_jumbo
;
74 alloc_len
= direct_mode_sz
;
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
);
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);
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
;
94 sd_entry
->u
.bp
.addr
= mem
;
95 sd_entry
->u
.bp
.sd_pd_index
= sd_index
;
97 /* initialize the sd entry */
98 hmc_info
->sd_table
.sd_entry
[sd_index
].entry_type
= type
;
100 /* increment the ref count */
101 I40E_INC_SD_REFCNT(&hmc_info
->sd_table
);
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
);
108 if (dma_mem_alloc_done
)
109 i40e_free_dma_mem(hw
, &mem
);
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
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
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.
130 i40e_status
i40e_add_pd_table_entry(struct i40e_hw
*hw
,
131 struct i40e_hmc_info
*hmc_info
,
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
;
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");
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
)
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
);
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;
171 pd_addr
= (u64
*)pd_table
->pd_page_addr
.va
;
172 pd_addr
+= rel_pd_idx
;
174 /* Add the backing page physical address in the pd entry */
175 memcpy(pd_addr
, &page_desc
, sizeof(u64
));
177 pd_entry
->sd_index
= sd_idx
;
178 pd_entry
->valid
= true;
179 I40E_INC_PD_REFCNT(pd_table
);
181 I40E_INC_BP_REFCNT(&pd_entry
->bp
);
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
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
199 * 1. Caller can deallocate the memory used by backing storage after this
202 i40e_status
i40e_remove_pd_bp(struct i40e_hw
*hw
,
203 struct i40e_hmc_info
*hmc_info
,
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
;
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");
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");
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
)
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 I40E_INVALIDATE_PF_HMC_PD(hw
, sd_idx
, idx
);
242 /* free memory here */
243 ret_code
= i40e_free_dma_mem(hw
, &(pd_entry
->bp
.addr
));
246 if (!pd_table
->ref_cnt
)
247 i40e_free_virt_mem(hw
, &pd_table
->pd_entry_virt_mem
);
253 * i40e_prep_remove_sd_bp - Prepares to remove a backing page from a sd entry
254 * @hmc_info: pointer to the HMC configuration information structure
255 * @idx: the page index
257 i40e_status
i40e_prep_remove_sd_bp(struct i40e_hmc_info
*hmc_info
,
260 i40e_status ret_code
= 0;
261 struct i40e_hmc_sd_entry
*sd_entry
;
263 /* get the entry and decrease its ref counter */
264 sd_entry
= &hmc_info
->sd_table
.sd_entry
[idx
];
265 I40E_DEC_BP_REFCNT(&sd_entry
->u
.bp
);
266 if (sd_entry
->u
.bp
.ref_cnt
) {
267 ret_code
= I40E_ERR_NOT_READY
;
270 I40E_DEC_SD_REFCNT(&hmc_info
->sd_table
);
272 /* mark the entry invalid */
273 sd_entry
->valid
= false;
279 * i40e_remove_sd_bp_new - Removes a backing page from a segment descriptor
280 * @hw: pointer to our hw struct
281 * @hmc_info: pointer to the HMC configuration information structure
282 * @idx: the page index
283 * @is_pf: used to distinguish between VF and PF
285 i40e_status
i40e_remove_sd_bp_new(struct i40e_hw
*hw
,
286 struct i40e_hmc_info
*hmc_info
,
289 struct i40e_hmc_sd_entry
*sd_entry
;
290 i40e_status ret_code
= 0;
292 /* get the entry and decrease its ref counter */
293 sd_entry
= &hmc_info
->sd_table
.sd_entry
[idx
];
295 I40E_CLEAR_PF_SD_ENTRY(hw
, idx
, I40E_SD_TYPE_DIRECT
);
297 ret_code
= I40E_NOT_SUPPORTED
;
300 ret_code
= i40e_free_dma_mem(hw
, &(sd_entry
->u
.bp
.addr
));
308 * i40e_prep_remove_pd_page - Prepares to remove a PD page from sd entry.
309 * @hmc_info: pointer to the HMC configuration information structure
310 * @idx: segment descriptor index to find the relevant page descriptor
312 i40e_status
i40e_prep_remove_pd_page(struct i40e_hmc_info
*hmc_info
,
315 i40e_status ret_code
= 0;
316 struct i40e_hmc_sd_entry
*sd_entry
;
318 sd_entry
= &hmc_info
->sd_table
.sd_entry
[idx
];
320 if (sd_entry
->u
.pd_table
.ref_cnt
) {
321 ret_code
= I40E_ERR_NOT_READY
;
325 /* mark the entry invalid */
326 sd_entry
->valid
= false;
328 I40E_DEC_SD_REFCNT(&hmc_info
->sd_table
);
334 * i40e_remove_pd_page_new - Removes a PD page from sd entry.
335 * @hw: pointer to our hw struct
336 * @hmc_info: pointer to the HMC configuration information structure
337 * @idx: segment descriptor index to find the relevant page descriptor
338 * @is_pf: used to distinguish between VF and PF
340 i40e_status
i40e_remove_pd_page_new(struct i40e_hw
*hw
,
341 struct i40e_hmc_info
*hmc_info
,
344 i40e_status ret_code
= 0;
345 struct i40e_hmc_sd_entry
*sd_entry
;
347 sd_entry
= &hmc_info
->sd_table
.sd_entry
[idx
];
349 I40E_CLEAR_PF_SD_ENTRY(hw
, idx
, I40E_SD_TYPE_PAGED
);
351 ret_code
= I40E_NOT_SUPPORTED
;
354 /* free memory here */
355 ret_code
= i40e_free_dma_mem(hw
, &(sd_entry
->u
.pd_table
.pd_page_addr
));