/* Determine if a given PCIe's DMA Queues are empty */ static int nfp6000_check_empty_pcie_dma_queues(struct nfp_device *nfp, int pci_island, int *empty) { u32 tmp; const int dma_low = 128, dma_med = 64, dma_hi = 64; int hi, med, low, ok, err; struct nfp_cpp *cpp = nfp_device_cpp(nfp); const u32 pci = NFP_CPP_ISLAND_ID(NFP_CPP_TARGET_PCIE, 2, 0, pci_island + 4); ok = 1; err = nfp_cpp_readl(cpp, pci, NFP_PCIE_DMA + NFP_PCIE_DMA_QSTS0_TOPCI, &tmp); if (err < 0) return err; low = NFP_PCIE_DMA_DMAQUEUESTATUS0_DMA_LO_AVAIL_of(tmp); err = nfp_cpp_readl(cpp, pci, NFP_PCIE_DMA + NFP_PCIE_DMA_QSTS1_TOPCI, &tmp); if (err < 0) return err; med = NFP_PCIE_DMA_DMAQUEUESTATUS1_DMA_MED_AVAIL_of(tmp); hi = NFP_PCIE_DMA_DMAQUEUESTATUS1_DMA_HI_AVAIL_of(tmp); ok &= low == dma_low; ok &= med == dma_med; ok &= hi == dma_hi; *empty = ok; return 0; }
/** * nfp_cpp_mutex_reclaim() - Unlock mutex if held by local endpoint * @cpp: NFP CPP handle * @target: NFP CPP target ID (ie NFP_CPP_TARGET_CLS or NFP_CPP_TARGET_MU) * @address: Offset into the address space of the NFP CPP target ID * * Release lock if held by local system. Extreme care is advised, call only * when no local lock users can exist. * * Return: 0 if the lock was OK, 1 if locked by us, -errno on invalid mutex */ int nfp_cpp_mutex_reclaim(struct nfp_cpp *cpp, int target, unsigned long long address) { const u32 mur = NFP_CPP_ID(target, 3, 0); /* atomic_read */ const u32 muw = NFP_CPP_ID(target, 4, 0); /* atomic_write */ u16 interface = nfp_cpp_interface(cpp); int err; u32 tmp; err = nfp_cpp_mutex_validate(interface, &target, address); if (err) return err; /* Check lock */ err = nfp_cpp_readl(cpp, mur, address, &tmp); if (err < 0) return err; if (nfp_mutex_is_unlocked(tmp) || nfp_mutex_owner(tmp) != interface) return 0; /* Bust the lock */ err = nfp_cpp_writel(cpp, muw, address, nfp_mutex_unlocked(interface)); if (err < 0) return err; return 1; }
/** * nfp_cpp_mutex_alloc() - Create a mutex handle * @cpp: NFP CPP handle * @target: NFP CPP target ID (ie NFP_CPP_TARGET_CLS or NFP_CPP_TARGET_MU) * @address: Offset into the address space of the NFP CPP target ID * @key: 32-bit unique key (must match the key at this location) * * The CPP target:address must point to a 64-bit aligned location, and * reserve 64 bits of data at the location for use by the handle. * * Only target/address pairs that point to entities that support the * MU Atomic Engine's CmpAndSwap32 command are supported. * * Return: A non-NULL struct nfp_cpp_mutex * on success, NULL on failure. */ struct nfp_cpp_mutex *nfp_cpp_mutex_alloc(struct nfp_cpp *cpp, int target, unsigned long long address, u32 key) { const u32 mur = NFP_CPP_ID(target, 3, 0); /* atomic_read */ u16 interface = nfp_cpp_interface(cpp); struct nfp_cpp_mutex *mutex; int err; u32 tmp; err = nfp_cpp_mutex_validate(interface, &target, address); if (err) return NULL; err = nfp_cpp_readl(cpp, mur, address + 4, &tmp); if (err < 0) return NULL; if (tmp != key) return NULL; mutex = kzalloc(sizeof(*mutex), GFP_KERNEL); if (!mutex) return NULL; mutex->cpp = cpp; mutex->target = target; mutex->address = address; mutex->key = key; mutex->depth = 0; return mutex; }
static int nfp6000_stop_me(struct nfp_device *nfp, int island, int menum) { int err; struct nfp_cpp *cpp = nfp_device_cpp(nfp); u32 tmp; u32 me_r = NFP_CPP_ID(NFP_CPP_TARGET_CT_XPB, 2, 1); u32 me_w = NFP_CPP_ID(NFP_CPP_TARGET_CT_XPB, 3, 1); u64 mecsr = (island << 24) | NFP_CT_ME(menum); err = nfp_cpp_readl(cpp, me_r, mecsr + NFP_ME_CTXENABLES, &tmp); if (err < 0) return err; tmp &= ~(NFP_ME_CTXENABLES_INUSECONTEXTS | NFP_ME_CTXENABLES_CTXENABLES(0xff)); tmp &= ~NFP_ME_CTXENABLES_CSECCERROR; tmp &= ~NFP_ME_CTXENABLES_BREAKPOINT; tmp &= ~NFP_ME_CTXENABLES_REGISTERPARITYERR; err = nfp_cpp_writel(cpp, me_w, mecsr + NFP_ME_CTXENABLES, tmp); if (err < 0) return err; mdelay(1); /* This may seem like a rushed test, but in the 1 microsecond sleep * the ME has executed about a 1000 instructions and even more during * the time it took the host to execute this code and for the CPP * command to reach the CSR in the test read anyway. * * If one of those instructions did not swap out, the code is a very * inefficient single-threaded sequence of instructions which would * be very rare or very specific. */ err = nfp_cpp_readl(cpp, me_r, mecsr + NFP_ME_ACTCTXSTATUS, &tmp); if (err < 0) return err; if (tmp & NFP_ME_ACTCTXSTATUS_AB0) { nfp_err(nfp, "ME%d.%d did not stop after 1000us\n", island, menum); return -EIO; } return 0; }
/** * nfp_cpp_mutex_unlock() - Unlock a mutex handle, using the MU Atomic Engine * @mutex: NFP CPP Mutex handle * * Return: 0 on success, or -errno on failure */ int nfp_cpp_mutex_unlock(struct nfp_cpp_mutex *mutex) { const u32 muw = NFP_CPP_ID(mutex->target, 4, 0); /* atomic_write */ const u32 mur = NFP_CPP_ID(mutex->target, 3, 0); /* atomic_read */ struct nfp_cpp *cpp = mutex->cpp; u32 key, value; u16 interface; int err; interface = nfp_cpp_interface(cpp); if (mutex->depth > 1) { mutex->depth--; return 0; } err = nfp_cpp_readl(mutex->cpp, mur, mutex->address + 4, &key); if (err < 0) return err; if (key != mutex->key) return -EPERM; err = nfp_cpp_readl(mutex->cpp, mur, mutex->address, &value); if (err < 0) return err; if (value != nfp_mutex_locked(interface)) return -EACCES; err = nfp_cpp_writel(cpp, muw, mutex->address, nfp_mutex_unlocked(interface)); if (err < 0) return err; mutex->depth = 0; return 0; }
/** * nfp_rtsym_read_le() - Read a simple unsigned scalar value from symbol * @cpp: NFP CPP handle * @name: Symbol name * @error: Poniter to error code (optional) * * Lookup a symbol, map, read it and return it's value. Value of the symbol * will be interpreted as a simple little-endian unsigned value. Symbol can * be 4 or 8 bytes in size. * * Return: value read, on error sets the error and returns ~0ULL. */ u64 nfp_rtsym_read_le(struct nfp_cpp *cpp, const char *name, int *error) { const struct nfp_rtsym *sym; u32 val32, id; u64 val; int err; sym = nfp_rtsym_lookup(cpp, name); if (!sym) { err = -ENOENT; goto exit; } id = NFP_CPP_ISLAND_ID(sym->target, NFP_CPP_ACTION_RW, 0, sym->domain); switch (sym->size) { case 4: err = nfp_cpp_readl(cpp, id, sym->addr, &val32); val = val32; break; case 8: err = nfp_cpp_readq(cpp, id, sym->addr, &val); break; default: nfp_err(cpp, "rtsym '%s' unsupported or non-scalar size: %lld\n", name, sym->size); err = -EINVAL; break; } if (err == sym->size) err = 0; else if (err >= 0) err = -EIO; exit: if (error) *error = err; if (err) return ~0ULL; return val; }
static int nfp6000_pcie_monitor_set(struct nfp_cpp *cpp, int pci, u32 flags) { u32 cls = NFP_CPP_ID(NFP_CPP_TARGET_CLS, NFP_CPP_ACTION_RW, 0); u64 base = (1ULL << 34) | 0x4000; u32 tmp; int err; /* Get PCIe Monitor ABI */ err = nfp_cpp_readl(cpp, cls, base + NFP_MON_PCIE_MAGIC, &tmp); if (err < 0) return err; /* Mask off ABI minor */ tmp &= ~0xf; if (tmp != NFP_MON_PCIE_ABI(0)) return 0; return nfp_cpp_writel(cpp, cls, base + NFP_MON_PCIE_CTL(pci), flags); }
/** * nfp_cpp_mutex_trylock() - Attempt to lock a mutex handle * @mutex: NFP CPP Mutex handle * * Return: 0 if the lock succeeded, -errno on failure */ int nfp_cpp_mutex_trylock(struct nfp_cpp_mutex *mutex) { const u32 muw = NFP_CPP_ID(mutex->target, 4, 0); /* atomic_write */ const u32 mus = NFP_CPP_ID(mutex->target, 5, 3); /* test_set_imm */ const u32 mur = NFP_CPP_ID(mutex->target, 3, 0); /* atomic_read */ struct nfp_cpp *cpp = mutex->cpp; u32 key, value, tmp; int err; if (mutex->depth > 0) { if (mutex->depth == NFP_MUTEX_DEPTH_MAX) return -E2BIG; mutex->depth++; return 0; } /* Verify that the lock marker is not damaged */ err = nfp_cpp_readl(cpp, mur, mutex->address + 4, &key); if (err < 0) return err; if (key != mutex->key) return -EPERM; /* Compare against the unlocked state, and if true, * write the interface id into the top 16 bits, and * mark as locked. */ value = nfp_mutex_locked(nfp_cpp_interface(cpp)); /* We use test_set_imm here, as it implies a read * of the current state, and sets the bits in the * bytemask of the command to 1s. Since the mutex * is guaranteed to be 64-bit aligned, the bytemask * of this 32-bit command is ensured to be 8'b00001111, * which implies that the lower 4 bits will be set to * ones regardless of the initial state. * * Since this is a 'Readback' operation, with no Pull * data, we can treat this as a normal Push (read) * atomic, which returns the original value. */ err = nfp_cpp_readl(cpp, mus, mutex->address, &tmp); if (err < 0) return err; /* Was it unlocked? */ if (nfp_mutex_is_unlocked(tmp)) { /* The read value can only be 0x....0000 in the unlocked state. * If there was another contending for this lock, then * the lock state would be 0x....000f */ /* Write our owner ID into the lock * While not strictly necessary, this helps with * debug and bookkeeping. */ err = nfp_cpp_writel(cpp, muw, mutex->address, value); if (err < 0) return err; mutex->depth = 1; return 0; } return nfp_mutex_is_locked(tmp) ? -EBUSY : -EINVAL; }