698 lines · c
1// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB2/* Copyright (c) 2015 - 2021 Intel Corporation */3#include "osdep.h"4#include "hmc.h"5#include "defs.h"6#include "type.h"7#include "protos.h"8 9/**10 * irdma_find_sd_index_limit - finds segment descriptor index limit11 * @hmc_info: pointer to the HMC configuration information structure12 * @type: type of HMC resources we're searching13 * @idx: starting index for the object14 * @cnt: number of objects we're trying to create15 * @sd_idx: pointer to return index of the segment descriptor in question16 * @sd_limit: pointer to return the maximum number of segment descriptors17 *18 * This function calculates the segment descriptor index and index limit19 * for the resource defined by irdma_hmc_rsrc_type.20 */21 22static void irdma_find_sd_index_limit(struct irdma_hmc_info *hmc_info, u32 type,23 u32 idx, u32 cnt, u32 *sd_idx,24 u32 *sd_limit)25{26 u64 fpm_addr, fpm_limit;27 28 fpm_addr = hmc_info->hmc_obj[(type)].base +29 hmc_info->hmc_obj[type].size * idx;30 fpm_limit = fpm_addr + hmc_info->hmc_obj[type].size * cnt;31 *sd_idx = (u32)(fpm_addr / IRDMA_HMC_DIRECT_BP_SIZE);32 *sd_limit = (u32)((fpm_limit - 1) / IRDMA_HMC_DIRECT_BP_SIZE);33 *sd_limit += 1;34}35 36/**37 * irdma_find_pd_index_limit - finds page descriptor index limit38 * @hmc_info: pointer to the HMC configuration information struct39 * @type: HMC resource type we're examining40 * @idx: starting index for the object41 * @cnt: number of objects we're trying to create42 * @pd_idx: pointer to return page descriptor index43 * @pd_limit: pointer to return page descriptor index limit44 *45 * Calculates the page descriptor index and index limit for the resource46 * defined by irdma_hmc_rsrc_type.47 */48 49static void irdma_find_pd_index_limit(struct irdma_hmc_info *hmc_info, u32 type,50 u32 idx, u32 cnt, u32 *pd_idx,51 u32 *pd_limit)52{53 u64 fpm_adr, fpm_limit;54 55 fpm_adr = hmc_info->hmc_obj[type].base +56 hmc_info->hmc_obj[type].size * idx;57 fpm_limit = fpm_adr + (hmc_info)->hmc_obj[(type)].size * (cnt);58 *pd_idx = (u32)(fpm_adr / IRDMA_HMC_PAGED_BP_SIZE);59 *pd_limit = (u32)((fpm_limit - 1) / IRDMA_HMC_PAGED_BP_SIZE);60 *pd_limit += 1;61}62 63/**64 * irdma_set_sd_entry - setup entry for sd programming65 * @pa: physical addr66 * @idx: sd index67 * @type: paged or direct sd68 * @entry: sd entry ptr69 */70static void irdma_set_sd_entry(u64 pa, u32 idx, enum irdma_sd_entry_type type,71 struct irdma_update_sd_entry *entry)72{73 entry->data = pa |74 FIELD_PREP(IRDMA_PFHMC_SDDATALOW_PMSDBPCOUNT, IRDMA_HMC_MAX_BP_COUNT) |75 FIELD_PREP(IRDMA_PFHMC_SDDATALOW_PMSDTYPE,76 type == IRDMA_SD_TYPE_PAGED ? 0 : 1) |77 FIELD_PREP(IRDMA_PFHMC_SDDATALOW_PMSDVALID, 1);78 79 entry->cmd = idx | FIELD_PREP(IRDMA_PFHMC_SDCMD_PMSDWR, 1) | BIT(15);80}81 82/**83 * irdma_clr_sd_entry - setup entry for sd clear84 * @idx: sd index85 * @type: paged or direct sd86 * @entry: sd entry ptr87 */88static void irdma_clr_sd_entry(u32 idx, enum irdma_sd_entry_type type,89 struct irdma_update_sd_entry *entry)90{91 entry->data = FIELD_PREP(IRDMA_PFHMC_SDDATALOW_PMSDBPCOUNT, IRDMA_HMC_MAX_BP_COUNT) |92 FIELD_PREP(IRDMA_PFHMC_SDDATALOW_PMSDTYPE,93 type == IRDMA_SD_TYPE_PAGED ? 0 : 1);94 95 entry->cmd = idx | FIELD_PREP(IRDMA_PFHMC_SDCMD_PMSDWR, 1) | BIT(15);96}97 98/**99 * irdma_invalidate_pf_hmc_pd - Invalidates the pd cache in the hardware for PF100 * @dev: pointer to our device struct101 * @sd_idx: segment descriptor index102 * @pd_idx: page descriptor index103 */104static inline void irdma_invalidate_pf_hmc_pd(struct irdma_sc_dev *dev, u32 sd_idx,105 u32 pd_idx)106{107 u32 val = FIELD_PREP(IRDMA_PFHMC_PDINV_PMSDIDX, sd_idx) |108 FIELD_PREP(IRDMA_PFHMC_PDINV_PMSDPARTSEL, 1) |109 FIELD_PREP(IRDMA_PFHMC_PDINV_PMPDIDX, pd_idx);110 111 writel(val, dev->hw_regs[IRDMA_PFHMC_PDINV]);112}113 114/**115 * irdma_hmc_sd_one - setup 1 sd entry for cqp116 * @dev: pointer to the device structure117 * @hmc_fn_id: hmc's function id118 * @pa: physical addr119 * @sd_idx: sd index120 * @type: paged or direct sd121 * @setsd: flag to set or clear sd122 */123int irdma_hmc_sd_one(struct irdma_sc_dev *dev, u8 hmc_fn_id, u64 pa, u32 sd_idx,124 enum irdma_sd_entry_type type, bool setsd)125{126 struct irdma_update_sds_info sdinfo;127 128 sdinfo.cnt = 1;129 sdinfo.hmc_fn_id = hmc_fn_id;130 if (setsd)131 irdma_set_sd_entry(pa, sd_idx, type, sdinfo.entry);132 else133 irdma_clr_sd_entry(sd_idx, type, sdinfo.entry);134 return dev->cqp->process_cqp_sds(dev, &sdinfo);135}136 137/**138 * irdma_hmc_sd_grp - setup group of sd entries for cqp139 * @dev: pointer to the device structure140 * @hmc_info: pointer to the HMC configuration information struct141 * @sd_index: sd index142 * @sd_cnt: number of sd entries143 * @setsd: flag to set or clear sd144 */145static int irdma_hmc_sd_grp(struct irdma_sc_dev *dev,146 struct irdma_hmc_info *hmc_info, u32 sd_index,147 u32 sd_cnt, bool setsd)148{149 struct irdma_hmc_sd_entry *sd_entry;150 struct irdma_update_sds_info sdinfo = {};151 u64 pa;152 u32 i;153 int ret_code = 0;154 155 sdinfo.hmc_fn_id = hmc_info->hmc_fn_id;156 for (i = sd_index; i < sd_index + sd_cnt; i++) {157 sd_entry = &hmc_info->sd_table.sd_entry[i];158 if (!sd_entry || (!sd_entry->valid && setsd) ||159 (sd_entry->valid && !setsd))160 continue;161 if (setsd) {162 pa = (sd_entry->entry_type == IRDMA_SD_TYPE_PAGED) ?163 sd_entry->u.pd_table.pd_page_addr.pa :164 sd_entry->u.bp.addr.pa;165 irdma_set_sd_entry(pa, i, sd_entry->entry_type,166 &sdinfo.entry[sdinfo.cnt]);167 } else {168 irdma_clr_sd_entry(i, sd_entry->entry_type,169 &sdinfo.entry[sdinfo.cnt]);170 }171 sdinfo.cnt++;172 if (sdinfo.cnt == IRDMA_MAX_SD_ENTRIES) {173 ret_code = dev->cqp->process_cqp_sds(dev, &sdinfo);174 if (ret_code) {175 ibdev_dbg(to_ibdev(dev),176 "HMC: sd_programming failed err=%d\n",177 ret_code);178 return ret_code;179 }180 181 sdinfo.cnt = 0;182 }183 }184 if (sdinfo.cnt)185 ret_code = dev->cqp->process_cqp_sds(dev, &sdinfo);186 187 return ret_code;188}189 190/**191 * irdma_hmc_finish_add_sd_reg - program sd entries for objects192 * @dev: pointer to the device structure193 * @info: create obj info194 */195static int irdma_hmc_finish_add_sd_reg(struct irdma_sc_dev *dev,196 struct irdma_hmc_create_obj_info *info)197{198 if (info->start_idx >= info->hmc_info->hmc_obj[info->rsrc_type].cnt)199 return -EINVAL;200 201 if ((info->start_idx + info->count) >202 info->hmc_info->hmc_obj[info->rsrc_type].cnt)203 return -EINVAL;204 205 if (!info->add_sd_cnt)206 return 0;207 return irdma_hmc_sd_grp(dev, info->hmc_info,208 info->hmc_info->sd_indexes[0], info->add_sd_cnt,209 true);210}211 212/**213 * irdma_sc_create_hmc_obj - allocate backing store for hmc objects214 * @dev: pointer to the device structure215 * @info: pointer to irdma_hmc_create_obj_info struct216 *217 * This will allocate memory for PDs and backing pages and populate218 * the sd and pd entries.219 */220int irdma_sc_create_hmc_obj(struct irdma_sc_dev *dev,221 struct irdma_hmc_create_obj_info *info)222{223 struct irdma_hmc_sd_entry *sd_entry;224 u32 sd_idx, sd_lmt;225 u32 pd_idx = 0, pd_lmt = 0;226 u32 pd_idx1 = 0, pd_lmt1 = 0;227 u32 i, j;228 bool pd_error = false;229 int ret_code = 0;230 231 if (info->start_idx >= info->hmc_info->hmc_obj[info->rsrc_type].cnt)232 return -EINVAL;233 234 if ((info->start_idx + info->count) >235 info->hmc_info->hmc_obj[info->rsrc_type].cnt) {236 ibdev_dbg(to_ibdev(dev),237 "HMC: error type %u, start = %u, req cnt %u, cnt = %u\n",238 info->rsrc_type, info->start_idx, info->count,239 info->hmc_info->hmc_obj[info->rsrc_type].cnt);240 return -EINVAL;241 }242 243 irdma_find_sd_index_limit(info->hmc_info, info->rsrc_type,244 info->start_idx, info->count, &sd_idx,245 &sd_lmt);246 if (sd_idx >= info->hmc_info->sd_table.sd_cnt ||247 sd_lmt > info->hmc_info->sd_table.sd_cnt) {248 return -EINVAL;249 }250 251 irdma_find_pd_index_limit(info->hmc_info, info->rsrc_type,252 info->start_idx, info->count, &pd_idx,253 &pd_lmt);254 255 for (j = sd_idx; j < sd_lmt; j++) {256 ret_code = irdma_add_sd_table_entry(dev->hw, info->hmc_info, j,257 info->entry_type,258 IRDMA_HMC_DIRECT_BP_SIZE);259 if (ret_code)260 goto exit_sd_error;261 262 sd_entry = &info->hmc_info->sd_table.sd_entry[j];263 if (sd_entry->entry_type == IRDMA_SD_TYPE_PAGED &&264 (dev->hmc_info == info->hmc_info &&265 info->rsrc_type != IRDMA_HMC_IW_PBLE)) {266 pd_idx1 = max(pd_idx, (j * IRDMA_HMC_MAX_BP_COUNT));267 pd_lmt1 = min(pd_lmt, (j + 1) * IRDMA_HMC_MAX_BP_COUNT);268 for (i = pd_idx1; i < pd_lmt1; i++) {269 /* update the pd table entry */270 ret_code = irdma_add_pd_table_entry(dev,271 info->hmc_info,272 i, NULL);273 if (ret_code) {274 pd_error = true;275 break;276 }277 }278 if (pd_error) {279 while (i && (i > pd_idx1)) {280 irdma_remove_pd_bp(dev, info->hmc_info,281 i - 1);282 i--;283 }284 }285 }286 if (sd_entry->valid)287 continue;288 289 info->hmc_info->sd_indexes[info->add_sd_cnt] = (u16)j;290 info->add_sd_cnt++;291 sd_entry->valid = true;292 }293 return irdma_hmc_finish_add_sd_reg(dev, info);294 295exit_sd_error:296 while (j && (j > sd_idx)) {297 sd_entry = &info->hmc_info->sd_table.sd_entry[j - 1];298 switch (sd_entry->entry_type) {299 case IRDMA_SD_TYPE_PAGED:300 pd_idx1 = max(pd_idx, (j - 1) * IRDMA_HMC_MAX_BP_COUNT);301 pd_lmt1 = min(pd_lmt, (j * IRDMA_HMC_MAX_BP_COUNT));302 for (i = pd_idx1; i < pd_lmt1; i++)303 irdma_prep_remove_pd_page(info->hmc_info, i);304 break;305 case IRDMA_SD_TYPE_DIRECT:306 irdma_prep_remove_pd_page(info->hmc_info, (j - 1));307 break;308 default:309 ret_code = -EINVAL;310 break;311 }312 j--;313 }314 315 return ret_code;316}317 318/**319 * irdma_finish_del_sd_reg - delete sd entries for objects320 * @dev: pointer to the device structure321 * @info: dele obj info322 * @reset: true if called before reset323 */324static int irdma_finish_del_sd_reg(struct irdma_sc_dev *dev,325 struct irdma_hmc_del_obj_info *info,326 bool reset)327{328 struct irdma_hmc_sd_entry *sd_entry;329 int ret_code = 0;330 u32 i, sd_idx;331 struct irdma_dma_mem *mem;332 333 if (!reset)334 ret_code = irdma_hmc_sd_grp(dev, info->hmc_info,335 info->hmc_info->sd_indexes[0],336 info->del_sd_cnt, false);337 338 if (ret_code)339 ibdev_dbg(to_ibdev(dev), "HMC: error cqp sd sd_grp\n");340 for (i = 0; i < info->del_sd_cnt; i++) {341 sd_idx = info->hmc_info->sd_indexes[i];342 sd_entry = &info->hmc_info->sd_table.sd_entry[sd_idx];343 mem = (sd_entry->entry_type == IRDMA_SD_TYPE_PAGED) ?344 &sd_entry->u.pd_table.pd_page_addr :345 &sd_entry->u.bp.addr;346 347 if (!mem || !mem->va) {348 ibdev_dbg(to_ibdev(dev), "HMC: error cqp sd mem\n");349 } else {350 dma_free_coherent(dev->hw->device, mem->size, mem->va,351 mem->pa);352 mem->va = NULL;353 }354 }355 356 return ret_code;357}358 359/**360 * irdma_sc_del_hmc_obj - remove pe hmc objects361 * @dev: pointer to the device structure362 * @info: pointer to irdma_hmc_del_obj_info struct363 * @reset: true if called before reset364 *365 * This will de-populate the SDs and PDs. It frees366 * the memory for PDS and backing storage. After this function is returned,367 * caller should deallocate memory allocated previously for368 * book-keeping information about PDs and backing storage.369 */370int irdma_sc_del_hmc_obj(struct irdma_sc_dev *dev,371 struct irdma_hmc_del_obj_info *info, bool reset)372{373 struct irdma_hmc_pd_table *pd_table;374 u32 sd_idx, sd_lmt;375 u32 pd_idx, pd_lmt, rel_pd_idx;376 u32 i, j;377 int ret_code = 0;378 379 if (info->start_idx >= info->hmc_info->hmc_obj[info->rsrc_type].cnt) {380 ibdev_dbg(to_ibdev(dev),381 "HMC: error start_idx[%04d] >= [type %04d].cnt[%04d]\n",382 info->start_idx, info->rsrc_type,383 info->hmc_info->hmc_obj[info->rsrc_type].cnt);384 return -EINVAL;385 }386 387 if ((info->start_idx + info->count) >388 info->hmc_info->hmc_obj[info->rsrc_type].cnt) {389 ibdev_dbg(to_ibdev(dev),390 "HMC: error start_idx[%04d] + count %04d >= [type %04d].cnt[%04d]\n",391 info->start_idx, info->count, info->rsrc_type,392 info->hmc_info->hmc_obj[info->rsrc_type].cnt);393 return -EINVAL;394 }395 396 irdma_find_pd_index_limit(info->hmc_info, info->rsrc_type,397 info->start_idx, info->count, &pd_idx,398 &pd_lmt);399 400 for (j = pd_idx; j < pd_lmt; j++) {401 sd_idx = j / IRDMA_HMC_PD_CNT_IN_SD;402 403 if (!info->hmc_info->sd_table.sd_entry[sd_idx].valid)404 continue;405 406 if (info->hmc_info->sd_table.sd_entry[sd_idx].entry_type !=407 IRDMA_SD_TYPE_PAGED)408 continue;409 410 rel_pd_idx = j % IRDMA_HMC_PD_CNT_IN_SD;411 pd_table = &info->hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;412 if (pd_table->pd_entry &&413 pd_table->pd_entry[rel_pd_idx].valid) {414 ret_code = irdma_remove_pd_bp(dev, info->hmc_info, j);415 if (ret_code) {416 ibdev_dbg(to_ibdev(dev),417 "HMC: remove_pd_bp error\n");418 return ret_code;419 }420 }421 }422 423 irdma_find_sd_index_limit(info->hmc_info, info->rsrc_type,424 info->start_idx, info->count, &sd_idx,425 &sd_lmt);426 if (sd_idx >= info->hmc_info->sd_table.sd_cnt ||427 sd_lmt > info->hmc_info->sd_table.sd_cnt) {428 ibdev_dbg(to_ibdev(dev), "HMC: invalid sd_idx\n");429 return -EINVAL;430 }431 432 for (i = sd_idx; i < sd_lmt; i++) {433 pd_table = &info->hmc_info->sd_table.sd_entry[i].u.pd_table;434 if (!info->hmc_info->sd_table.sd_entry[i].valid)435 continue;436 switch (info->hmc_info->sd_table.sd_entry[i].entry_type) {437 case IRDMA_SD_TYPE_DIRECT:438 ret_code = irdma_prep_remove_sd_bp(info->hmc_info, i);439 if (!ret_code) {440 info->hmc_info->sd_indexes[info->del_sd_cnt] =441 (u16)i;442 info->del_sd_cnt++;443 }444 break;445 case IRDMA_SD_TYPE_PAGED:446 ret_code = irdma_prep_remove_pd_page(info->hmc_info, i);447 if (ret_code)448 break;449 if (dev->hmc_info != info->hmc_info &&450 info->rsrc_type == IRDMA_HMC_IW_PBLE &&451 pd_table->pd_entry) {452 kfree(pd_table->pd_entry_virt_mem.va);453 pd_table->pd_entry = NULL;454 }455 info->hmc_info->sd_indexes[info->del_sd_cnt] = (u16)i;456 info->del_sd_cnt++;457 break;458 default:459 break;460 }461 }462 return irdma_finish_del_sd_reg(dev, info, reset);463}464 465/**466 * irdma_add_sd_table_entry - Adds a segment descriptor to the table467 * @hw: pointer to our hw struct468 * @hmc_info: pointer to the HMC configuration information struct469 * @sd_index: segment descriptor index to manipulate470 * @type: what type of segment descriptor we're manipulating471 * @direct_mode_sz: size to alloc in direct mode472 */473int irdma_add_sd_table_entry(struct irdma_hw *hw,474 struct irdma_hmc_info *hmc_info, u32 sd_index,475 enum irdma_sd_entry_type type, u64 direct_mode_sz)476{477 struct irdma_hmc_sd_entry *sd_entry;478 struct irdma_dma_mem dma_mem;479 u64 alloc_len;480 481 sd_entry = &hmc_info->sd_table.sd_entry[sd_index];482 if (!sd_entry->valid) {483 if (type == IRDMA_SD_TYPE_PAGED)484 alloc_len = IRDMA_HMC_PAGED_BP_SIZE;485 else486 alloc_len = direct_mode_sz;487 488 /* allocate a 4K pd page or 2M backing page */489 dma_mem.size = ALIGN(alloc_len, IRDMA_HMC_PD_BP_BUF_ALIGNMENT);490 dma_mem.va = dma_alloc_coherent(hw->device, dma_mem.size,491 &dma_mem.pa, GFP_KERNEL);492 if (!dma_mem.va)493 return -ENOMEM;494 if (type == IRDMA_SD_TYPE_PAGED) {495 struct irdma_virt_mem *vmem =496 &sd_entry->u.pd_table.pd_entry_virt_mem;497 498 vmem->size = sizeof(struct irdma_hmc_pd_entry) * 512;499 vmem->va = kzalloc(vmem->size, GFP_KERNEL);500 if (!vmem->va) {501 dma_free_coherent(hw->device, dma_mem.size,502 dma_mem.va, dma_mem.pa);503 dma_mem.va = NULL;504 return -ENOMEM;505 }506 sd_entry->u.pd_table.pd_entry = vmem->va;507 508 memcpy(&sd_entry->u.pd_table.pd_page_addr, &dma_mem,509 sizeof(sd_entry->u.pd_table.pd_page_addr));510 } else {511 memcpy(&sd_entry->u.bp.addr, &dma_mem,512 sizeof(sd_entry->u.bp.addr));513 514 sd_entry->u.bp.sd_pd_index = sd_index;515 }516 517 hmc_info->sd_table.sd_entry[sd_index].entry_type = type;518 hmc_info->sd_table.use_cnt++;519 }520 if (sd_entry->entry_type == IRDMA_SD_TYPE_DIRECT)521 sd_entry->u.bp.use_cnt++;522 523 return 0;524}525 526/**527 * irdma_add_pd_table_entry - Adds page descriptor to the specified table528 * @dev: pointer to our device structure529 * @hmc_info: pointer to the HMC configuration information structure530 * @pd_index: which page descriptor index to manipulate531 * @rsrc_pg: if not NULL, use preallocated page instead of allocating new one.532 *533 * This function:534 * 1. Initializes the pd entry535 * 2. Adds pd_entry in the pd_table536 * 3. Mark the entry valid in irdma_hmc_pd_entry structure537 * 4. Initializes the pd_entry's ref count to 1538 * assumptions:539 * 1. The memory for pd should be pinned down, physically contiguous and540 * aligned on 4K boundary and zeroed memory.541 * 2. It should be 4K in size.542 */543int irdma_add_pd_table_entry(struct irdma_sc_dev *dev,544 struct irdma_hmc_info *hmc_info, u32 pd_index,545 struct irdma_dma_mem *rsrc_pg)546{547 struct irdma_hmc_pd_table *pd_table;548 struct irdma_hmc_pd_entry *pd_entry;549 struct irdma_dma_mem mem;550 struct irdma_dma_mem *page = &mem;551 u32 sd_idx, rel_pd_idx;552 u64 *pd_addr;553 u64 page_desc;554 555 if (pd_index / IRDMA_HMC_PD_CNT_IN_SD >= hmc_info->sd_table.sd_cnt)556 return -EINVAL;557 558 sd_idx = (pd_index / IRDMA_HMC_PD_CNT_IN_SD);559 if (hmc_info->sd_table.sd_entry[sd_idx].entry_type !=560 IRDMA_SD_TYPE_PAGED)561 return 0;562 563 rel_pd_idx = (pd_index % IRDMA_HMC_PD_CNT_IN_SD);564 pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;565 pd_entry = &pd_table->pd_entry[rel_pd_idx];566 if (!pd_entry->valid) {567 if (rsrc_pg) {568 pd_entry->rsrc_pg = true;569 page = rsrc_pg;570 } else {571 page->size = ALIGN(IRDMA_HMC_PAGED_BP_SIZE,572 IRDMA_HMC_PD_BP_BUF_ALIGNMENT);573 page->va = dma_alloc_coherent(dev->hw->device,574 page->size, &page->pa,575 GFP_KERNEL);576 if (!page->va)577 return -ENOMEM;578 579 pd_entry->rsrc_pg = false;580 }581 582 memcpy(&pd_entry->bp.addr, page, sizeof(pd_entry->bp.addr));583 pd_entry->bp.sd_pd_index = pd_index;584 pd_entry->bp.entry_type = IRDMA_SD_TYPE_PAGED;585 page_desc = page->pa | 0x1;586 pd_addr = pd_table->pd_page_addr.va;587 pd_addr += rel_pd_idx;588 memcpy(pd_addr, &page_desc, sizeof(*pd_addr));589 pd_entry->sd_index = sd_idx;590 pd_entry->valid = true;591 pd_table->use_cnt++;592 irdma_invalidate_pf_hmc_pd(dev, sd_idx, rel_pd_idx);593 }594 pd_entry->bp.use_cnt++;595 596 return 0;597}598 599/**600 * irdma_remove_pd_bp - remove a backing page from a page descriptor601 * @dev: pointer to our HW structure602 * @hmc_info: pointer to the HMC configuration information structure603 * @idx: the page index604 *605 * This function:606 * 1. Marks the entry in pd table (for paged address mode) or in sd table607 * (for direct address mode) invalid.608 * 2. Write to register PMPDINV to invalidate the backing page in FV cache609 * 3. Decrement the ref count for the pd _entry610 * assumptions:611 * 1. Caller can deallocate the memory used by backing storage after this612 * function returns.613 */614int irdma_remove_pd_bp(struct irdma_sc_dev *dev,615 struct irdma_hmc_info *hmc_info, u32 idx)616{617 struct irdma_hmc_pd_entry *pd_entry;618 struct irdma_hmc_pd_table *pd_table;619 struct irdma_hmc_sd_entry *sd_entry;620 u32 sd_idx, rel_pd_idx;621 struct irdma_dma_mem *mem;622 u64 *pd_addr;623 624 sd_idx = idx / IRDMA_HMC_PD_CNT_IN_SD;625 rel_pd_idx = idx % IRDMA_HMC_PD_CNT_IN_SD;626 if (sd_idx >= hmc_info->sd_table.sd_cnt)627 return -EINVAL;628 629 sd_entry = &hmc_info->sd_table.sd_entry[sd_idx];630 if (sd_entry->entry_type != IRDMA_SD_TYPE_PAGED)631 return -EINVAL;632 633 pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;634 pd_entry = &pd_table->pd_entry[rel_pd_idx];635 if (--pd_entry->bp.use_cnt)636 return 0;637 638 pd_entry->valid = false;639 pd_table->use_cnt--;640 pd_addr = pd_table->pd_page_addr.va;641 pd_addr += rel_pd_idx;642 memset(pd_addr, 0, sizeof(u64));643 irdma_invalidate_pf_hmc_pd(dev, sd_idx, idx);644 645 if (!pd_entry->rsrc_pg) {646 mem = &pd_entry->bp.addr;647 if (!mem || !mem->va)648 return -EINVAL;649 650 dma_free_coherent(dev->hw->device, mem->size, mem->va,651 mem->pa);652 mem->va = NULL;653 }654 if (!pd_table->use_cnt)655 kfree(pd_table->pd_entry_virt_mem.va);656 657 return 0;658}659 660/**661 * irdma_prep_remove_sd_bp - Prepares to remove a backing page from a sd entry662 * @hmc_info: pointer to the HMC configuration information structure663 * @idx: the page index664 */665int irdma_prep_remove_sd_bp(struct irdma_hmc_info *hmc_info, u32 idx)666{667 struct irdma_hmc_sd_entry *sd_entry;668 669 sd_entry = &hmc_info->sd_table.sd_entry[idx];670 if (--sd_entry->u.bp.use_cnt)671 return -EBUSY;672 673 hmc_info->sd_table.use_cnt--;674 sd_entry->valid = false;675 676 return 0;677}678 679/**680 * irdma_prep_remove_pd_page - Prepares to remove a PD page from sd entry.681 * @hmc_info: pointer to the HMC configuration information structure682 * @idx: segment descriptor index to find the relevant page descriptor683 */684int irdma_prep_remove_pd_page(struct irdma_hmc_info *hmc_info, u32 idx)685{686 struct irdma_hmc_sd_entry *sd_entry;687 688 sd_entry = &hmc_info->sd_table.sd_entry[idx];689 690 if (sd_entry->u.pd_table.use_cnt)691 return -EBUSY;692 693 sd_entry->valid = false;694 hmc_info->sd_table.use_cnt--;695 696 return 0;697}698