mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-14 06:24:53 +08:00
octeontx2-af: Add RVU block LF provisioning support
Added support for a RVU PF/VF to request AF via mailbox to attach or detach NPA/NIX/SSO/SSOW/TIM/CPT block LFs. Also supports partial detachment and modifying current LF attached count of a certian block type. Signed-off-by: Sunil Goutham <sgoutham@marvell.com> Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Sunil Goutham
David S. Miller
parent
114a767e8b
commit
746ea74241
@ -118,7 +118,17 @@ static inline struct mbox_msghdr *otx2_mbox_alloc_msg(struct otx2_mbox *mbox,
|
||||
#define MBOX_MSG_MAX 0xFFFF
|
||||
|
||||
#define MBOX_MESSAGES \
|
||||
M(READY, 0x001, msg_req, ready_msg_rsp)
|
||||
/* Generic mbox IDs (range 0x000 - 0x1FF) */ \
|
||||
M(READY, 0x001, msg_req, ready_msg_rsp) \
|
||||
M(ATTACH_RESOURCES, 0x002, rsrc_attach, msg_rsp) \
|
||||
M(DETACH_RESOURCES, 0x003, rsrc_detach, msg_rsp) \
|
||||
/* CGX mbox IDs (range 0x200 - 0x3FF) */ \
|
||||
/* NPA mbox IDs (range 0x400 - 0x5FF) */ \
|
||||
/* SSO/SSOW mbox IDs (range 0x600 - 0x7FF) */ \
|
||||
/* TIM mbox IDs (range 0x800 - 0x9FF) */ \
|
||||
/* CPT mbox IDs (range 0xA00 - 0xBFF) */ \
|
||||
/* NPC mbox IDs (range 0x6000 - 0x7FFF) */ \
|
||||
/* NIX mbox IDs (range 0x8000 - 0xFFFF) */ \
|
||||
|
||||
enum {
|
||||
#define M(_name, _id, _1, _2) MBOX_MSG_ ## _name = _id,
|
||||
@ -147,4 +157,37 @@ struct ready_msg_rsp {
|
||||
u16 sclk_feq; /* SCLK frequency */
|
||||
};
|
||||
|
||||
/* Structure for requesting resource provisioning.
|
||||
* 'modify' flag to be used when either requesting more
|
||||
* or to detach partial of a cetain resource type.
|
||||
* Rest of the fields specify how many of what type to
|
||||
* be attached.
|
||||
*/
|
||||
struct rsrc_attach {
|
||||
struct mbox_msghdr hdr;
|
||||
u8 modify:1;
|
||||
u8 npalf:1;
|
||||
u8 nixlf:1;
|
||||
u16 sso;
|
||||
u16 ssow;
|
||||
u16 timlfs;
|
||||
u16 cptlfs;
|
||||
};
|
||||
|
||||
/* Structure for relinquishing resources.
|
||||
* 'partial' flag to be used when relinquishing all resources
|
||||
* but only of a certain type. If not set, all resources of all
|
||||
* types provisioned to the RVU function will be detached.
|
||||
*/
|
||||
struct rsrc_detach {
|
||||
struct mbox_msghdr hdr;
|
||||
u8 partial:1;
|
||||
u8 npalf:1;
|
||||
u8 nixlf:1;
|
||||
u8 sso:1;
|
||||
u8 ssow:1;
|
||||
u8 timlfs:1;
|
||||
u8 cptlfs:1;
|
||||
};
|
||||
|
||||
#endif /* MBOX_H */
|
||||
|
||||
@ -58,6 +58,41 @@ int rvu_poll_reg(struct rvu *rvu, u64 block, u64 offset, u64 mask, bool zero)
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
int rvu_alloc_rsrc(struct rsrc_bmap *rsrc)
|
||||
{
|
||||
int id;
|
||||
|
||||
if (!rsrc->bmap)
|
||||
return -EINVAL;
|
||||
|
||||
id = find_first_zero_bit(rsrc->bmap, rsrc->max);
|
||||
if (id >= rsrc->max)
|
||||
return -ENOSPC;
|
||||
|
||||
__set_bit(id, rsrc->bmap);
|
||||
|
||||
return id;
|
||||
}
|
||||
|
||||
void rvu_free_rsrc(struct rsrc_bmap *rsrc, int id)
|
||||
{
|
||||
if (!rsrc->bmap)
|
||||
return;
|
||||
|
||||
__clear_bit(id, rsrc->bmap);
|
||||
}
|
||||
|
||||
int rvu_rsrc_free_count(struct rsrc_bmap *rsrc)
|
||||
{
|
||||
int used;
|
||||
|
||||
if (!rsrc->bmap)
|
||||
return 0;
|
||||
|
||||
used = bitmap_weight(rsrc->bmap, rsrc->max);
|
||||
return (rsrc->max - used);
|
||||
}
|
||||
|
||||
int rvu_alloc_bitmap(struct rsrc_bmap *rsrc)
|
||||
{
|
||||
rsrc->bmap = kcalloc(BITS_TO_LONGS(rsrc->max),
|
||||
@ -67,6 +102,78 @@ int rvu_alloc_bitmap(struct rsrc_bmap *rsrc)
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Convert BLOCK_TYPE_E to a BLOCK_ADDR_E.
|
||||
* Some silicon variants of OcteonTX2 supports
|
||||
* multiple blocks of same type.
|
||||
*
|
||||
* @pcifunc has to be zero when no LF is yet attached.
|
||||
*/
|
||||
int rvu_get_blkaddr(struct rvu *rvu, int blktype, u16 pcifunc)
|
||||
{
|
||||
int devnum, blkaddr = -ENODEV;
|
||||
u64 cfg, reg;
|
||||
bool is_pf;
|
||||
|
||||
switch (blktype) {
|
||||
case BLKTYPE_NPA:
|
||||
blkaddr = BLKADDR_NPA;
|
||||
goto exit;
|
||||
case BLKTYPE_NIX:
|
||||
/* For now assume NIX0 */
|
||||
if (!pcifunc) {
|
||||
blkaddr = BLKADDR_NIX0;
|
||||
goto exit;
|
||||
}
|
||||
break;
|
||||
case BLKTYPE_SSO:
|
||||
blkaddr = BLKADDR_SSO;
|
||||
goto exit;
|
||||
case BLKTYPE_SSOW:
|
||||
blkaddr = BLKADDR_SSOW;
|
||||
goto exit;
|
||||
case BLKTYPE_TIM:
|
||||
blkaddr = BLKADDR_TIM;
|
||||
goto exit;
|
||||
case BLKTYPE_CPT:
|
||||
/* For now assume CPT0 */
|
||||
if (!pcifunc) {
|
||||
blkaddr = BLKADDR_CPT0;
|
||||
goto exit;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
/* Check if this is a RVU PF or VF */
|
||||
if (pcifunc & RVU_PFVF_FUNC_MASK) {
|
||||
is_pf = false;
|
||||
devnum = rvu_get_hwvf(rvu, pcifunc);
|
||||
} else {
|
||||
is_pf = true;
|
||||
devnum = rvu_get_pf(pcifunc);
|
||||
}
|
||||
|
||||
/* Check if the 'pcifunc' has a NIX LF from 'BLKADDR_NIX0' */
|
||||
if (blktype == BLKTYPE_NIX) {
|
||||
reg = is_pf ? RVU_PRIV_PFX_NIX0_CFG : RVU_PRIV_HWVFX_NIX0_CFG;
|
||||
cfg = rvu_read64(rvu, BLKADDR_RVUM, reg | (devnum << 16));
|
||||
if (cfg)
|
||||
blkaddr = BLKADDR_NIX0;
|
||||
}
|
||||
|
||||
/* Check if the 'pcifunc' has a CPT LF from 'BLKADDR_CPT0' */
|
||||
if (blktype == BLKTYPE_CPT) {
|
||||
reg = is_pf ? RVU_PRIV_PFX_CPT0_CFG : RVU_PRIV_HWVFX_CPT0_CFG;
|
||||
cfg = rvu_read64(rvu, BLKADDR_RVUM, reg | (devnum << 16));
|
||||
if (cfg)
|
||||
blkaddr = BLKADDR_CPT0;
|
||||
}
|
||||
|
||||
exit:
|
||||
if (is_block_implemented(rvu->hw, blkaddr))
|
||||
return blkaddr;
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static void rvu_update_rsrc_map(struct rvu *rvu, struct rvu_pfvf *pfvf,
|
||||
struct rvu_block *block, u16 pcifunc,
|
||||
u16 lf, bool attach)
|
||||
@ -152,6 +259,17 @@ struct rvu_pfvf *rvu_get_pfvf(struct rvu *rvu, int pcifunc)
|
||||
return &rvu->pf[rvu_get_pf(pcifunc)];
|
||||
}
|
||||
|
||||
bool is_block_implemented(struct rvu_hwinfo *hw, int blkaddr)
|
||||
{
|
||||
struct rvu_block *block;
|
||||
|
||||
if (blkaddr < BLKADDR_RVUM || blkaddr >= BLK_COUNT)
|
||||
return false;
|
||||
|
||||
block = &hw->block[blkaddr];
|
||||
return block->implemented;
|
||||
}
|
||||
|
||||
static void rvu_check_block_implemented(struct rvu *rvu)
|
||||
{
|
||||
struct rvu_hwinfo *hw = rvu->hw;
|
||||
@ -272,8 +390,8 @@ nix:
|
||||
block->type = BLKTYPE_NIX;
|
||||
block->lfshift = 8;
|
||||
block->lookup_reg = NIX_AF_RVU_LF_CFG_DEBUG;
|
||||
block->pf_lfcnt_reg = RVU_PRIV_PFX_NIX_CFG;
|
||||
block->vf_lfcnt_reg = RVU_PRIV_HWVFX_NIX_CFG;
|
||||
block->pf_lfcnt_reg = RVU_PRIV_PFX_NIX0_CFG;
|
||||
block->vf_lfcnt_reg = RVU_PRIV_HWVFX_NIX0_CFG;
|
||||
block->lfcfg_reg = NIX_PRIV_LFX_CFG;
|
||||
block->msixcfg_reg = NIX_PRIV_LFX_INT_CFG;
|
||||
block->lfreset_reg = NIX_AF_LF_RST;
|
||||
@ -359,8 +477,8 @@ cpt:
|
||||
block->multislot = true;
|
||||
block->lfshift = 3;
|
||||
block->lookup_reg = CPT_AF_RVU_LF_CFG_DEBUG;
|
||||
block->pf_lfcnt_reg = RVU_PRIV_PFX_CPT_CFG;
|
||||
block->vf_lfcnt_reg = RVU_PRIV_HWVFX_CPT_CFG;
|
||||
block->pf_lfcnt_reg = RVU_PRIV_PFX_CPT0_CFG;
|
||||
block->vf_lfcnt_reg = RVU_PRIV_HWVFX_CPT0_CFG;
|
||||
block->lfcfg_reg = CPT_PRIV_LFX_CFG;
|
||||
block->msixcfg_reg = CPT_PRIV_LFX_INT_CFG;
|
||||
block->lfreset_reg = CPT_AF_LF_RST;
|
||||
@ -398,6 +516,8 @@ init:
|
||||
rvu_scan_block(rvu, block);
|
||||
}
|
||||
|
||||
spin_lock_init(&rvu->rsrc_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -407,6 +527,350 @@ static int rvu_mbox_handler_READY(struct rvu *rvu, struct msg_req *req,
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Get current count of a RVU block's LF/slots
|
||||
* provisioned to a given RVU func.
|
||||
*/
|
||||
static u16 rvu_get_rsrc_mapcount(struct rvu_pfvf *pfvf, int blktype)
|
||||
{
|
||||
switch (blktype) {
|
||||
case BLKTYPE_NPA:
|
||||
return pfvf->npalf ? 1 : 0;
|
||||
case BLKTYPE_NIX:
|
||||
return pfvf->nixlf ? 1 : 0;
|
||||
case BLKTYPE_SSO:
|
||||
return pfvf->sso;
|
||||
case BLKTYPE_SSOW:
|
||||
return pfvf->ssow;
|
||||
case BLKTYPE_TIM:
|
||||
return pfvf->timlfs;
|
||||
case BLKTYPE_CPT:
|
||||
return pfvf->cptlfs;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int rvu_lookup_rsrc(struct rvu *rvu, struct rvu_block *block,
|
||||
int pcifunc, int slot)
|
||||
{
|
||||
u64 val;
|
||||
|
||||
val = ((u64)pcifunc << 24) | (slot << 16) | (1ULL << 13);
|
||||
rvu_write64(rvu, block->addr, block->lookup_reg, val);
|
||||
/* Wait for the lookup to finish */
|
||||
/* TODO: put some timeout here */
|
||||
while (rvu_read64(rvu, block->addr, block->lookup_reg) & (1ULL << 13))
|
||||
;
|
||||
|
||||
val = rvu_read64(rvu, block->addr, block->lookup_reg);
|
||||
|
||||
/* Check LF valid bit */
|
||||
if (!(val & (1ULL << 12)))
|
||||
return -1;
|
||||
|
||||
return (val & 0xFFF);
|
||||
}
|
||||
|
||||
static void rvu_detach_block(struct rvu *rvu, int pcifunc, int blktype)
|
||||
{
|
||||
struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
|
||||
struct rvu_hwinfo *hw = rvu->hw;
|
||||
struct rvu_block *block;
|
||||
int slot, lf, num_lfs;
|
||||
int blkaddr;
|
||||
|
||||
blkaddr = rvu_get_blkaddr(rvu, blktype, pcifunc);
|
||||
if (blkaddr < 0)
|
||||
return;
|
||||
|
||||
block = &hw->block[blkaddr];
|
||||
|
||||
num_lfs = rvu_get_rsrc_mapcount(pfvf, block->type);
|
||||
if (!num_lfs)
|
||||
return;
|
||||
|
||||
for (slot = 0; slot < num_lfs; slot++) {
|
||||
lf = rvu_lookup_rsrc(rvu, block, pcifunc, slot);
|
||||
if (lf < 0) /* This should never happen */
|
||||
continue;
|
||||
|
||||
/* Disable the LF */
|
||||
rvu_write64(rvu, blkaddr, block->lfcfg_reg |
|
||||
(lf << block->lfshift), 0x00ULL);
|
||||
|
||||
/* Update SW maintained mapping info as well */
|
||||
rvu_update_rsrc_map(rvu, pfvf, block,
|
||||
pcifunc, lf, false);
|
||||
|
||||
/* Free the resource */
|
||||
rvu_free_rsrc(&block->lf, lf);
|
||||
}
|
||||
}
|
||||
|
||||
static int rvu_detach_rsrcs(struct rvu *rvu, struct rsrc_detach *detach,
|
||||
u16 pcifunc)
|
||||
{
|
||||
struct rvu_hwinfo *hw = rvu->hw;
|
||||
bool is_pf, detach_all = true;
|
||||
struct rvu_block *block;
|
||||
int devnum, blkid;
|
||||
|
||||
/* Check if this is for a RVU PF or VF */
|
||||
if (pcifunc & RVU_PFVF_FUNC_MASK) {
|
||||
is_pf = false;
|
||||
devnum = rvu_get_hwvf(rvu, pcifunc);
|
||||
} else {
|
||||
is_pf = true;
|
||||
devnum = rvu_get_pf(pcifunc);
|
||||
}
|
||||
|
||||
spin_lock(&rvu->rsrc_lock);
|
||||
|
||||
/* Check for partial resource detach */
|
||||
if (detach && detach->partial)
|
||||
detach_all = false;
|
||||
|
||||
/* Check for RVU block's LFs attached to this func,
|
||||
* if so, detach them.
|
||||
*/
|
||||
for (blkid = 0; blkid < BLK_COUNT; blkid++) {
|
||||
block = &hw->block[blkid];
|
||||
if (!block->lf.bmap)
|
||||
continue;
|
||||
if (!detach_all && detach) {
|
||||
if (blkid == BLKADDR_NPA && !detach->npalf)
|
||||
continue;
|
||||
else if ((blkid == BLKADDR_NIX0) && !detach->nixlf)
|
||||
continue;
|
||||
else if ((blkid == BLKADDR_SSO) && !detach->sso)
|
||||
continue;
|
||||
else if ((blkid == BLKADDR_SSOW) && !detach->ssow)
|
||||
continue;
|
||||
else if ((blkid == BLKADDR_TIM) && !detach->timlfs)
|
||||
continue;
|
||||
else if ((blkid == BLKADDR_CPT0) && !detach->cptlfs)
|
||||
continue;
|
||||
}
|
||||
rvu_detach_block(rvu, pcifunc, block->type);
|
||||
}
|
||||
|
||||
spin_unlock(&rvu->rsrc_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int rvu_mbox_handler_DETACH_RESOURCES(struct rvu *rvu,
|
||||
struct rsrc_detach *detach,
|
||||
struct msg_rsp *rsp)
|
||||
{
|
||||
return rvu_detach_rsrcs(rvu, detach, detach->hdr.pcifunc);
|
||||
}
|
||||
|
||||
static void rvu_attach_block(struct rvu *rvu, int pcifunc,
|
||||
int blktype, int num_lfs)
|
||||
{
|
||||
struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
|
||||
struct rvu_hwinfo *hw = rvu->hw;
|
||||
struct rvu_block *block;
|
||||
int slot, lf;
|
||||
int blkaddr;
|
||||
u64 cfg;
|
||||
|
||||
if (!num_lfs)
|
||||
return;
|
||||
|
||||
blkaddr = rvu_get_blkaddr(rvu, blktype, 0);
|
||||
if (blkaddr < 0)
|
||||
return;
|
||||
|
||||
block = &hw->block[blkaddr];
|
||||
if (!block->lf.bmap)
|
||||
return;
|
||||
|
||||
for (slot = 0; slot < num_lfs; slot++) {
|
||||
/* Allocate the resource */
|
||||
lf = rvu_alloc_rsrc(&block->lf);
|
||||
if (lf < 0)
|
||||
return;
|
||||
|
||||
cfg = (1ULL << 63) | (pcifunc << 8) | slot;
|
||||
rvu_write64(rvu, blkaddr, block->lfcfg_reg |
|
||||
(lf << block->lfshift), cfg);
|
||||
rvu_update_rsrc_map(rvu, pfvf, block,
|
||||
pcifunc, lf, true);
|
||||
}
|
||||
}
|
||||
|
||||
static int rvu_check_rsrc_availability(struct rvu *rvu,
|
||||
struct rsrc_attach *req, u16 pcifunc)
|
||||
{
|
||||
struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
|
||||
struct rvu_hwinfo *hw = rvu->hw;
|
||||
struct rvu_block *block;
|
||||
int free_lfs, mappedlfs;
|
||||
|
||||
/* Only one NPA LF can be attached */
|
||||
if (req->npalf && !rvu_get_rsrc_mapcount(pfvf, BLKTYPE_NPA)) {
|
||||
block = &hw->block[BLKADDR_NPA];
|
||||
free_lfs = rvu_rsrc_free_count(&block->lf);
|
||||
if (!free_lfs)
|
||||
goto fail;
|
||||
} else if (req->npalf) {
|
||||
dev_err(&rvu->pdev->dev,
|
||||
"Func 0x%x: Invalid req, already has NPA\n",
|
||||
pcifunc);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Only one NIX LF can be attached */
|
||||
if (req->nixlf && !rvu_get_rsrc_mapcount(pfvf, BLKTYPE_NIX)) {
|
||||
block = &hw->block[BLKADDR_NIX0];
|
||||
free_lfs = rvu_rsrc_free_count(&block->lf);
|
||||
if (!free_lfs)
|
||||
goto fail;
|
||||
} else if (req->nixlf) {
|
||||
dev_err(&rvu->pdev->dev,
|
||||
"Func 0x%x: Invalid req, already has NIX\n",
|
||||
pcifunc);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (req->sso) {
|
||||
block = &hw->block[BLKADDR_SSO];
|
||||
/* Is request within limits ? */
|
||||
if (req->sso > block->lf.max) {
|
||||
dev_err(&rvu->pdev->dev,
|
||||
"Func 0x%x: Invalid SSO req, %d > max %d\n",
|
||||
pcifunc, req->sso, block->lf.max);
|
||||
return -EINVAL;
|
||||
}
|
||||
mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
|
||||
free_lfs = rvu_rsrc_free_count(&block->lf);
|
||||
/* Check if additional resources are available */
|
||||
if (req->sso > mappedlfs &&
|
||||
((req->sso - mappedlfs) > free_lfs))
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (req->ssow) {
|
||||
block = &hw->block[BLKADDR_SSOW];
|
||||
if (req->ssow > block->lf.max) {
|
||||
dev_err(&rvu->pdev->dev,
|
||||
"Func 0x%x: Invalid SSOW req, %d > max %d\n",
|
||||
pcifunc, req->sso, block->lf.max);
|
||||
return -EINVAL;
|
||||
}
|
||||
mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
|
||||
free_lfs = rvu_rsrc_free_count(&block->lf);
|
||||
if (req->ssow > mappedlfs &&
|
||||
((req->ssow - mappedlfs) > free_lfs))
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (req->timlfs) {
|
||||
block = &hw->block[BLKADDR_TIM];
|
||||
if (req->timlfs > block->lf.max) {
|
||||
dev_err(&rvu->pdev->dev,
|
||||
"Func 0x%x: Invalid TIMLF req, %d > max %d\n",
|
||||
pcifunc, req->timlfs, block->lf.max);
|
||||
return -EINVAL;
|
||||
}
|
||||
mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
|
||||
free_lfs = rvu_rsrc_free_count(&block->lf);
|
||||
if (req->timlfs > mappedlfs &&
|
||||
((req->timlfs - mappedlfs) > free_lfs))
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (req->cptlfs) {
|
||||
block = &hw->block[BLKADDR_CPT0];
|
||||
if (req->cptlfs > block->lf.max) {
|
||||
dev_err(&rvu->pdev->dev,
|
||||
"Func 0x%x: Invalid CPTLF req, %d > max %d\n",
|
||||
pcifunc, req->cptlfs, block->lf.max);
|
||||
return -EINVAL;
|
||||
}
|
||||
mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
|
||||
free_lfs = rvu_rsrc_free_count(&block->lf);
|
||||
if (req->cptlfs > mappedlfs &&
|
||||
((req->cptlfs - mappedlfs) > free_lfs))
|
||||
goto fail;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
dev_info(rvu->dev, "Request for %s failed\n", block->name);
|
||||
return -ENOSPC;
|
||||
}
|
||||
|
||||
static int rvu_mbox_handler_ATTACH_RESOURCES(struct rvu *rvu,
|
||||
struct rsrc_attach *attach,
|
||||
struct msg_rsp *rsp)
|
||||
{
|
||||
u16 pcifunc = attach->hdr.pcifunc;
|
||||
int devnum, err;
|
||||
bool is_pf;
|
||||
|
||||
/* If first request, detach all existing attached resources */
|
||||
if (!attach->modify)
|
||||
rvu_detach_rsrcs(rvu, NULL, pcifunc);
|
||||
|
||||
/* Check if this is for a RVU PF or VF */
|
||||
if (pcifunc & RVU_PFVF_FUNC_MASK) {
|
||||
is_pf = false;
|
||||
devnum = rvu_get_hwvf(rvu, pcifunc);
|
||||
} else {
|
||||
is_pf = true;
|
||||
devnum = rvu_get_pf(pcifunc);
|
||||
}
|
||||
|
||||
spin_lock(&rvu->rsrc_lock);
|
||||
|
||||
/* Check if the request can be accommodated */
|
||||
err = rvu_check_rsrc_availability(rvu, attach, pcifunc);
|
||||
if (err)
|
||||
goto exit;
|
||||
|
||||
/* Now attach the requested resources */
|
||||
if (attach->npalf)
|
||||
rvu_attach_block(rvu, pcifunc, BLKTYPE_NPA, 1);
|
||||
|
||||
if (attach->nixlf)
|
||||
rvu_attach_block(rvu, pcifunc, BLKTYPE_NIX, 1);
|
||||
|
||||
if (attach->sso) {
|
||||
/* RVU func doesn't know which exact LF or slot is attached
|
||||
* to it, it always sees as slot 0,1,2. So for a 'modify'
|
||||
* request, simply detach all existing attached LFs/slots
|
||||
* and attach a fresh.
|
||||
*/
|
||||
if (attach->modify)
|
||||
rvu_detach_block(rvu, pcifunc, BLKTYPE_SSO);
|
||||
rvu_attach_block(rvu, pcifunc, BLKTYPE_SSO, attach->sso);
|
||||
}
|
||||
|
||||
if (attach->ssow) {
|
||||
if (attach->modify)
|
||||
rvu_detach_block(rvu, pcifunc, BLKTYPE_SSOW);
|
||||
rvu_attach_block(rvu, pcifunc, BLKTYPE_SSOW, attach->ssow);
|
||||
}
|
||||
|
||||
if (attach->timlfs) {
|
||||
if (attach->modify)
|
||||
rvu_detach_block(rvu, pcifunc, BLKTYPE_TIM);
|
||||
rvu_attach_block(rvu, pcifunc, BLKTYPE_TIM, attach->timlfs);
|
||||
}
|
||||
|
||||
if (attach->cptlfs) {
|
||||
if (attach->modify)
|
||||
rvu_detach_block(rvu, pcifunc, BLKTYPE_CPT);
|
||||
rvu_attach_block(rvu, pcifunc, BLKTYPE_CPT, attach->cptlfs);
|
||||
}
|
||||
|
||||
exit:
|
||||
spin_unlock(&rvu->rsrc_lock);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int rvu_process_mbox_msg(struct rvu *rvu, int devid,
|
||||
struct mbox_msghdr *req)
|
||||
{
|
||||
|
||||
@ -83,6 +83,7 @@ struct rvu {
|
||||
struct rvu_hwinfo *hw;
|
||||
struct rvu_pfvf *pf;
|
||||
struct rvu_pfvf *hwvf;
|
||||
spinlock_t rsrc_lock; /* Serialize resource alloc/free */
|
||||
|
||||
/* Mbox */
|
||||
struct otx2_mbox mbox;
|
||||
@ -120,8 +121,13 @@ static inline u64 rvupf_read64(struct rvu *rvu, u64 offset)
|
||||
*/
|
||||
|
||||
int rvu_alloc_bitmap(struct rsrc_bmap *rsrc);
|
||||
int rvu_poll_reg(struct rvu *rvu, u64 block, u64 offset, u64 mask, bool zero);
|
||||
int rvu_alloc_rsrc(struct rsrc_bmap *rsrc);
|
||||
void rvu_free_rsrc(struct rsrc_bmap *rsrc, int id);
|
||||
int rvu_rsrc_free_count(struct rsrc_bmap *rsrc);
|
||||
int rvu_get_pf(u16 pcifunc);
|
||||
struct rvu_pfvf *rvu_get_pfvf(struct rvu *rvu, int pcifunc);
|
||||
bool is_block_implemented(struct rvu_hwinfo *hw, int blkaddr);
|
||||
int rvu_get_blkaddr(struct rvu *rvu, int blktype, u16 pcifunc);
|
||||
int rvu_poll_reg(struct rvu *rvu, u64 block, u64 offset, u64 mask, bool zero);
|
||||
|
||||
#endif /* RVU_H */
|
||||
|
||||
@ -54,20 +54,20 @@
|
||||
#define RVU_PRIV_PFX_MSIX_CFG(a) (0x8000110 | (a) << 16)
|
||||
#define RVU_PRIV_PFX_ID_CFG(a) (0x8000120 | (a) << 16)
|
||||
#define RVU_PRIV_PFX_INT_CFG(a) (0x8000200 | (a) << 16)
|
||||
#define RVU_PRIV_PFX_NIX_CFG (0x8000300)
|
||||
#define RVU_PRIV_PFX_NIX0_CFG (0x8000300)
|
||||
#define RVU_PRIV_PFX_NPA_CFG (0x8000310)
|
||||
#define RVU_PRIV_PFX_SSO_CFG (0x8000320)
|
||||
#define RVU_PRIV_PFX_SSOW_CFG (0x8000330)
|
||||
#define RVU_PRIV_PFX_TIM_CFG (0x8000340)
|
||||
#define RVU_PRIV_PFX_CPT_CFG (0x8000350)
|
||||
#define RVU_PRIV_PFX_CPT0_CFG (0x8000350)
|
||||
#define RVU_PRIV_BLOCK_TYPEX_REV(a) (0x8000400 | (a) << 3)
|
||||
#define RVU_PRIV_HWVFX_INT_CFG(a) (0x8001280 | (a) << 16)
|
||||
#define RVU_PRIV_HWVFX_NIX_CFG (0x8001300)
|
||||
#define RVU_PRIV_HWVFX_NIX0_CFG (0x8001300)
|
||||
#define RVU_PRIV_HWVFX_NPA_CFG (0x8001310)
|
||||
#define RVU_PRIV_HWVFX_SSO_CFG (0x8001320)
|
||||
#define RVU_PRIV_HWVFX_SSOW_CFG (0x8001330)
|
||||
#define RVU_PRIV_HWVFX_TIM_CFG (0x8001340)
|
||||
#define RVU_PRIV_HWVFX_CPT_CFG (0x8001350)
|
||||
#define RVU_PRIV_HWVFX_CPT0_CFG (0x8001350)
|
||||
|
||||
/* RVU PF registers */
|
||||
#define RVU_PF_VFX_PFVF_MBOX0 (0x00000)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user