nfp_cppcore.c

   1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2/* Copyright (C) 2015-2018 Netronome Systems, Inc. */
   3
   4/*
   5 * nfp_cppcore.c
   6 * Provides low-level access to the NFP's internal CPP bus
   7 * Authors: Jakub Kicinski <jakub.kicinski@netronome.com>
   8 *          Jason McMullan <jason.mcmullan@netronome.com>
   9 *          Rolf Neugebauer <rolf.neugebauer@netronome.com>
  10 */
  11
  12#include <linux/unaligned.h>
  13#include <linux/delay.h>
  14#include <linux/device.h>
  15#include <linux/ioport.h>
  16#include <linux/kernel.h>
  17#include <linux/module.h>
  18#include <linux/mutex.h>
  19#include <linux/sched.h>
  20#include <linux/slab.h>
  21#include <linux/wait.h>
  22
  23#include "nfp_arm.h"
  24#include "nfp_cpp.h"
  25#include "nfp6000/nfp6000.h"
  26
  27#define NFP_ARM_GCSR_SOFTMODEL2                              0x0000014c
  28#define NFP_ARM_GCSR_SOFTMODEL3                              0x00000150
  29
  30struct nfp_cpp_resource {
  31	struct list_head list;
  32	const char *name;
  33	u32 cpp_id;
  34	u64 start;
  35	u64 end;
  36};
  37
  38/**
  39 * struct nfp_cpp - main nfpcore device structure
  40 * Following fields are read-only after probe() exits or netdevs are spawned.
  41 * @dev:		embedded device structure
  42 * @op:			low-level implementation ops
  43 * @priv:		private data of the low-level implementation
  44 * @model:		chip model
  45 * @interface:		chip interface id we are using to reach it
  46 * @serial:		chip serial number
  47 * @imb_cat_table:	CPP Mapping Table
  48 * @mu_locality_lsb:	MU access type bit offset
  49 *
  50 * Following fields use explicit locking:
  51 * @resource_list:	NFP CPP resource list
  52 * @resource_lock:	protects @resource_list
  53 *
  54 * @area_cache_list:	cached areas for cpp/xpb read/write speed up
  55 * @area_cache_mutex:	protects @area_cache_list
  56 *
  57 * @waitq:		area wait queue
  58 */
  59struct nfp_cpp {
  60	struct device dev;
  61
  62	void *priv;
  63
  64	u32 model;
  65	u16 interface;
  66	u8 serial[NFP_SERIAL_LEN];
  67
  68	const struct nfp_cpp_operations *op;
  69	struct list_head resource_list;
  70	rwlock_t resource_lock;
  71	wait_queue_head_t waitq;
  72
  73	u32 imb_cat_table[16];
  74	unsigned int mu_locality_lsb;
  75
  76	struct mutex area_cache_mutex;
  77	struct list_head area_cache_list;
  78};
  79
  80/* Element of the area_cache_list */
  81struct nfp_cpp_area_cache {
  82	struct list_head entry;
  83	u32 id;
  84	u64 addr;
  85	u32 size;
  86	struct nfp_cpp_area *area;
  87};
  88
  89struct nfp_cpp_area {
  90	struct nfp_cpp *cpp;
  91	struct kref kref;
  92	atomic_t refcount;
  93	struct mutex mutex;	/* Lock for the area's refcount */
  94	unsigned long long offset;
  95	unsigned long size;
  96	struct nfp_cpp_resource resource;
  97	void __iomem *iomem;
  98	/* Here follows the 'priv' part of nfp_cpp_area. */
  99};
 100
 101struct nfp_cpp_explicit {
 102	struct nfp_cpp *cpp;
 103	struct nfp_cpp_explicit_command cmd;
 104	/* Here follows the 'priv' part of nfp_cpp_area. */
 105};
 106
 107static void __resource_add(struct list_head *head, struct nfp_cpp_resource *res)
 108{
 109	struct nfp_cpp_resource *tmp;
 110	struct list_head *pos;
 111
 112	list_for_each(pos, head) {
 113		tmp = container_of(pos, struct nfp_cpp_resource, list);
 114
 115		if (tmp->cpp_id > res->cpp_id)
 116			break;
 117
 118		if (tmp->cpp_id == res->cpp_id && tmp->start > res->start)
 119			break;
 120	}
 121
 122	list_add_tail(&res->list, pos);
 123}
 124
 125static void __resource_del(struct nfp_cpp_resource *res)
 126{
 127	list_del_init(&res->list);
 128}
 129
 130static void __release_cpp_area(struct kref *kref)
 131{
 132	struct nfp_cpp_area *area =
 133		container_of(kref, struct nfp_cpp_area, kref);
 134	struct nfp_cpp *cpp = nfp_cpp_area_cpp(area);
 135
 136	if (area->cpp->op->area_cleanup)
 137		area->cpp->op->area_cleanup(area);
 138
 139	write_lock(&cpp->resource_lock);
 140	__resource_del(&area->resource);
 141	write_unlock(&cpp->resource_lock);
 142	kfree(area);
 143}
 144
 145static void nfp_cpp_area_put(struct nfp_cpp_area *area)
 146{
 147	kref_put(&area->kref, __release_cpp_area);
 148}
 149
 150static struct nfp_cpp_area *nfp_cpp_area_get(struct nfp_cpp_area *area)
 151{
 152	kref_get(&area->kref);
 153
 154	return area;
 155}
 156
 157/**
 158 * nfp_cpp_free() - free the CPP handle
 159 * @cpp:	CPP handle
 160 */
 161void nfp_cpp_free(struct nfp_cpp *cpp)
 162{
 163	struct nfp_cpp_area_cache *cache, *ctmp;
 164	struct nfp_cpp_resource *res, *rtmp;
 165
 166	/* Remove all caches */
 167	list_for_each_entry_safe(cache, ctmp, &cpp->area_cache_list, entry) {
 168		list_del(&cache->entry);
 169		if (cache->id)
 170			nfp_cpp_area_release(cache->area);
 171		nfp_cpp_area_free(cache->area);
 172		kfree(cache);
 173	}
 174
 175	/* There should be no dangling areas at this point */
 176	WARN_ON(!list_empty(&cpp->resource_list));
 177
 178	/* .. but if they weren't, try to clean up. */
 179	list_for_each_entry_safe(res, rtmp, &cpp->resource_list, list) {
 180		struct nfp_cpp_area *area = container_of(res,
 181							 struct nfp_cpp_area,
 182							 resource);
 183
 184		dev_err(cpp->dev.parent, "Dangling area: %d:%d:%d:0x%0llx-0x%0llx%s%s\n",
 185			NFP_CPP_ID_TARGET_of(res->cpp_id),
 186			NFP_CPP_ID_ACTION_of(res->cpp_id),
 187			NFP_CPP_ID_TOKEN_of(res->cpp_id),
 188			res->start, res->end,
 189			res->name ? " " : "",
 190			res->name ? res->name : "");
 191
 192		if (area->cpp->op->area_release)
 193			area->cpp->op->area_release(area);
 194
 195		__release_cpp_area(&area->kref);
 196	}
 197
 198	if (cpp->op->free)
 199		cpp->op->free(cpp);
 200
 201	device_unregister(&cpp->dev);
 202
 203	kfree(cpp);
 204}
 205
 206/**
 207 * nfp_cpp_model() - Retrieve the Model ID of the NFP
 208 * @cpp:	NFP CPP handle
 209 *
 210 * Return: NFP CPP Model ID
 211 */
 212u32 nfp_cpp_model(struct nfp_cpp *cpp)
 213{
 214	return cpp->model;
 215}
 216
 217/**
 218 * nfp_cpp_interface() - Retrieve the Interface ID of the NFP
 219 * @cpp:	NFP CPP handle
 220 *
 221 * Return: NFP CPP Interface ID
 222 */
 223u16 nfp_cpp_interface(struct nfp_cpp *cpp)
 224{
 225	return cpp->interface;
 226}
 227
 228/**
 229 * nfp_cpp_serial() - Retrieve the Serial ID of the NFP
 230 * @cpp:	NFP CPP handle
 231 * @serial:	Pointer to NFP serial number
 232 *
 233 * Return:  Length of NFP serial number
 234 */
 235int nfp_cpp_serial(struct nfp_cpp *cpp, const u8 **serial)
 236{
 237	*serial = &cpp->serial[0];
 238	return sizeof(cpp->serial);
 239}
 240
 241#define NFP_IMB_TGTADDRESSMODECFG_MODE_of(_x)		(((_x) >> 13) & 0x7)
 242#define NFP_IMB_TGTADDRESSMODECFG_ADDRMODE		BIT(12)
 243#define   NFP_IMB_TGTADDRESSMODECFG_ADDRMODE_32_BIT	0
 244#define   NFP_IMB_TGTADDRESSMODECFG_ADDRMODE_40_BIT	BIT(12)
 245
 246static int nfp_cpp_set_mu_locality_lsb(struct nfp_cpp *cpp)
 247{
 248	unsigned int mode, addr40;
 249	u32 imbcppat;
 250	int res;
 251
 252	imbcppat = cpp->imb_cat_table[NFP_CPP_TARGET_MU];
 253	mode = NFP_IMB_TGTADDRESSMODECFG_MODE_of(imbcppat);
 254	addr40 = !!(imbcppat & NFP_IMB_TGTADDRESSMODECFG_ADDRMODE);
 255
 256	res = nfp_cppat_mu_locality_lsb(mode, addr40);
 257	if (res < 0)
 258		return res;
 259	cpp->mu_locality_lsb = res;
 260
 261	return 0;
 262}
 263
 264unsigned int nfp_cpp_mu_locality_lsb(struct nfp_cpp *cpp)
 265{
 266	return cpp->mu_locality_lsb;
 267}
 268
 269/**
 270 * nfp_cpp_area_alloc_with_name() - allocate a new CPP area
 271 * @cpp:	CPP device handle
 272 * @dest:	NFP CPP ID
 273 * @name:	Name of region
 274 * @address:	Address of region
 275 * @size:	Size of region
 276 *
 277 * Allocate and initialize a CPP area structure.  The area must later
 278 * be locked down with an 'acquire' before it can be safely accessed.
 279 *
 280 * NOTE: @address and @size must be 32-bit aligned values.
 281 *
 282 * Return: NFP CPP area handle, or NULL
 283 */
 284struct nfp_cpp_area *
 285nfp_cpp_area_alloc_with_name(struct nfp_cpp *cpp, u32 dest, const char *name,
 286			     unsigned long long address, unsigned long size)
 287{
 288	struct nfp_cpp_area *area;
 289	u64 tmp64 = address;
 290	int err, name_len;
 291
 292	/* Remap from cpp_island to cpp_target */
 293	err = nfp_target_cpp(dest, tmp64, &dest, &tmp64, cpp->imb_cat_table);
 294	if (err < 0)
 295		return NULL;
 296
 297	address = tmp64;
 298
 299	if (!name)
 300		name = "(reserved)";
 301
 302	name_len = strlen(name) + 1;
 303	area = kzalloc(sizeof(*area) + cpp->op->area_priv_size + name_len,
 304		       GFP_KERNEL);
 305	if (!area)
 306		return NULL;
 307
 308	area->cpp = cpp;
 309	area->resource.name = (void *)area + sizeof(*area) +
 310		cpp->op->area_priv_size;
 311	memcpy((char *)area->resource.name, name, name_len);
 312
 313	area->resource.cpp_id = dest;
 314	area->resource.start = address;
 315	area->resource.end = area->resource.start + size - 1;
 316	INIT_LIST_HEAD(&area->resource.list);
 317
 318	atomic_set(&area->refcount, 0);
 319	kref_init(&area->kref);
 320	mutex_init(&area->mutex);
 321
 322	if (cpp->op->area_init) {
 323		int err;
 324
 325		err = cpp->op->area_init(area, dest, address, size);
 326		if (err < 0) {
 327			kfree(area);
 328			return NULL;
 329		}
 330	}
 331
 332	write_lock(&cpp->resource_lock);
 333	__resource_add(&cpp->resource_list, &area->resource);
 334	write_unlock(&cpp->resource_lock);
 335
 336	area->offset = address;
 337	area->size = size;
 338
 339	return area;
 340}
 341
 342/**
 343 * nfp_cpp_area_alloc() - allocate a new CPP area
 344 * @cpp:	CPP handle
 345 * @dest:	CPP id
 346 * @address:	Start address on CPP target
 347 * @size:	Size of area in bytes
 348 *
 349 * Allocate and initialize a CPP area structure.  The area must later
 350 * be locked down with an 'acquire' before it can be safely accessed.
 351 *
 352 * NOTE: @address and @size must be 32-bit aligned values.
 353 *
 354 * Return: NFP CPP Area handle, or NULL
 355 */
 356struct nfp_cpp_area *
 357nfp_cpp_area_alloc(struct nfp_cpp *cpp, u32 dest,
 358		   unsigned long long address, unsigned long size)
 359{
 360	return nfp_cpp_area_alloc_with_name(cpp, dest, NULL, address, size);
 361}
 362
 363/**
 364 * nfp_cpp_area_alloc_acquire() - allocate a new CPP area and lock it down
 365 * @cpp:	CPP handle
 366 * @name:	Name of region
 367 * @dest:	CPP id
 368 * @address:	Start address on CPP target
 369 * @size:	Size of area
 370 *
 371 * Allocate and initialize a CPP area structure, and lock it down so
 372 * that it can be accessed directly.
 373 *
 374 * NOTE: @address and @size must be 32-bit aligned values.
 375 * The area must also be 'released' when the structure is freed.
 376 *
 377 * Return: NFP CPP Area handle, or NULL
 378 */
 379struct nfp_cpp_area *
 380nfp_cpp_area_alloc_acquire(struct nfp_cpp *cpp, const char *name, u32 dest,
 381			   unsigned long long address, unsigned long size)
 382{
 383	struct nfp_cpp_area *area;
 384
 385	area = nfp_cpp_area_alloc_with_name(cpp, dest, name, address, size);
 386	if (!area)
 387		return NULL;
 388
 389	if (nfp_cpp_area_acquire(area)) {
 390		nfp_cpp_area_free(area);
 391		return NULL;
 392	}
 393
 394	return area;
 395}
 396
 397/**
 398 * nfp_cpp_area_free() - free up the CPP area
 399 * @area:	CPP area handle
 400 *
 401 * Frees up memory resources held by the CPP area.
 402 */
 403void nfp_cpp_area_free(struct nfp_cpp_area *area)
 404{
 405	if (atomic_read(&area->refcount))
 406		nfp_warn(area->cpp, "Warning: freeing busy area\n");
 407	nfp_cpp_area_put(area);
 408}
 409
 410static bool nfp_cpp_area_acquire_try(struct nfp_cpp_area *area, int *status)
 411{
 412	*status = area->cpp->op->area_acquire(area);
 413
 414	return *status != -EAGAIN;
 415}
 416
 417static int __nfp_cpp_area_acquire(struct nfp_cpp_area *area)
 418{
 419	int err, status;
 420
 421	if (atomic_inc_return(&area->refcount) > 1)
 422		return 0;
 423
 424	if (!area->cpp->op->area_acquire)
 425		return 0;
 426
 427	err = wait_event_interruptible(area->cpp->waitq,
 428				       nfp_cpp_area_acquire_try(area, &status));
 429	if (!err)
 430		err = status;
 431	if (err) {
 432		nfp_warn(area->cpp, "Warning: area wait failed: %d\n", err);
 433		atomic_dec(&area->refcount);
 434		return err;
 435	}
 436
 437	nfp_cpp_area_get(area);
 438
 439	return 0;
 440}
 441
 442/**
 443 * nfp_cpp_area_acquire() - lock down a CPP area for access
 444 * @area:	CPP area handle
 445 *
 446 * Locks down the CPP area for a potential long term activity.  Area
 447 * must always be locked down before being accessed.
 448 *
 449 * Return: 0, or -ERRNO
 450 */
 451int nfp_cpp_area_acquire(struct nfp_cpp_area *area)
 452{
 453	int ret;
 454
 455	mutex_lock(&area->mutex);
 456	ret = __nfp_cpp_area_acquire(area);
 457	mutex_unlock(&area->mutex);
 458
 459	return ret;
 460}
 461
 462/**
 463 * nfp_cpp_area_acquire_nonblocking() - lock down a CPP area for access
 464 * @area:	CPP area handle
 465 *
 466 * Locks down the CPP area for a potential long term activity.  Area
 467 * must always be locked down before being accessed.
 468 *
 469 * NOTE: Returns -EAGAIN is no area is available
 470 *
 471 * Return: 0, or -ERRNO
 472 */
 473int nfp_cpp_area_acquire_nonblocking(struct nfp_cpp_area *area)
 474{
 475	mutex_lock(&area->mutex);
 476	if (atomic_inc_return(&area->refcount) == 1) {
 477		if (area->cpp->op->area_acquire) {
 478			int err;
 479
 480			err = area->cpp->op->area_acquire(area);
 481			if (err < 0) {
 482				atomic_dec(&area->refcount);
 483				mutex_unlock(&area->mutex);
 484				return err;
 485			}
 486		}
 487	}
 488	mutex_unlock(&area->mutex);
 489
 490	nfp_cpp_area_get(area);
 491	return 0;
 492}
 493
 494/**
 495 * nfp_cpp_area_release() - release a locked down CPP area
 496 * @area:	CPP area handle
 497 *
 498 * Releases a previously locked down CPP area.
 499 */
 500void nfp_cpp_area_release(struct nfp_cpp_area *area)
 501{
 502	mutex_lock(&area->mutex);
 503	/* Only call the release on refcount == 0 */
 504	if (atomic_dec_and_test(&area->refcount)) {
 505		if (area->cpp->op->area_release) {
 506			area->cpp->op->area_release(area);
 507			/* Let anyone waiting for a BAR try to get one.. */
 508			wake_up_interruptible_all(&area->cpp->waitq);
 509		}
 510	}
 511	mutex_unlock(&area->mutex);
 512
 513	nfp_cpp_area_put(area);
 514}
 515
 516/**
 517 * nfp_cpp_area_release_free() - release CPP area and free it
 518 * @area:	CPP area handle
 519 *
 520 * Releases CPP area and frees up memory resources held by the it.
 521 */
 522void nfp_cpp_area_release_free(struct nfp_cpp_area *area)
 523{
 524	nfp_cpp_area_release(area);
 525	nfp_cpp_area_free(area);
 526}
 527
 528/**
 529 * nfp_cpp_area_read() - read data from CPP area
 530 * @area:	  CPP area handle
 531 * @offset:	  offset into CPP area
 532 * @kernel_vaddr: kernel address to put data into
 533 * @length:	  number of bytes to read
 534 *
 535 * Read data from indicated CPP region.
 536 *
 537 * NOTE: @offset and @length must be 32-bit aligned values.
 538 * Area must have been locked down with an 'acquire'.
 539 *
 540 * Return: length of io, or -ERRNO
 541 */
 542int nfp_cpp_area_read(struct nfp_cpp_area *area,
 543		      unsigned long offset, void *kernel_vaddr,
 544		      size_t length)
 545{
 546	return area->cpp->op->area_read(area, kernel_vaddr, offset, length);
 547}
 548
 549/**
 550 * nfp_cpp_area_write() - write data to CPP area
 551 * @area:	CPP area handle
 552 * @offset:	offset into CPP area
 553 * @kernel_vaddr: kernel address to read data from
 554 * @length:	number of bytes to write
 555 *
 556 * Write data to indicated CPP region.
 557 *
 558 * NOTE: @offset and @length must be 32-bit aligned values.
 559 * Area must have been locked down with an 'acquire'.
 560 *
 561 * Return: length of io, or -ERRNO
 562 */
 563int nfp_cpp_area_write(struct nfp_cpp_area *area,
 564		       unsigned long offset, const void *kernel_vaddr,
 565		       size_t length)
 566{
 567	return area->cpp->op->area_write(area, kernel_vaddr, offset, length);
 568}
 569
 570/**
 571 * nfp_cpp_area_size() - return size of a CPP area
 572 * @cpp_area:	CPP area handle
 573 *
 574 * Return: Size of the area
 575 */
 576size_t nfp_cpp_area_size(struct nfp_cpp_area *cpp_area)
 577{
 578	return cpp_area->size;
 579}
 580
 581/**
 582 * nfp_cpp_area_name() - return name of a CPP area
 583 * @cpp_area:	CPP area handle
 584 *
 585 * Return: Name of the area, or NULL
 586 */
 587const char *nfp_cpp_area_name(struct nfp_cpp_area *cpp_area)
 588{
 589	return cpp_area->resource.name;
 590}
 591
 592/**
 593 * nfp_cpp_area_priv() - return private struct for CPP area
 594 * @cpp_area:	CPP area handle
 595 *
 596 * Return: Private data for the CPP area
 597 */
 598void *nfp_cpp_area_priv(struct nfp_cpp_area *cpp_area)
 599{
 600	return &cpp_area[1];
 601}
 602
 603/**
 604 * nfp_cpp_area_cpp() - return CPP handle for CPP area
 605 * @cpp_area:	CPP area handle
 606 *
 607 * Return: NFP CPP handle
 608 */
 609struct nfp_cpp *nfp_cpp_area_cpp(struct nfp_cpp_area *cpp_area)
 610{
 611	return cpp_area->cpp;
 612}
 613
 614/**
 615 * nfp_cpp_area_resource() - get resource
 616 * @area:	CPP area handle
 617 *
 618 * NOTE: Area must have been locked down with an 'acquire'.
 619 *
 620 * Return: struct resource pointer, or NULL
 621 */
 622struct resource *nfp_cpp_area_resource(struct nfp_cpp_area *area)
 623{
 624	struct resource *res = NULL;
 625
 626	if (area->cpp->op->area_resource)
 627		res = area->cpp->op->area_resource(area);
 628
 629	return res;
 630}
 631
 632/**
 633 * nfp_cpp_area_phys() - get physical address of CPP area
 634 * @area:	CPP area handle
 635 *
 636 * NOTE: Area must have been locked down with an 'acquire'.
 637 *
 638 * Return: phy_addr_t of the area, or NULL
 639 */
 640phys_addr_t nfp_cpp_area_phys(struct nfp_cpp_area *area)
 641{
 642	phys_addr_t addr = ~0;
 643
 644	if (area->cpp->op->area_phys)
 645		addr = area->cpp->op->area_phys(area);
 646
 647	return addr;
 648}
 649
 650/**
 651 * nfp_cpp_area_iomem() - get IOMEM region for CPP area
 652 * @area:	CPP area handle
 653 *
 654 * Returns an iomem pointer for use with readl()/writel() style
 655 * operations.
 656 *
 657 * NOTE: Area must have been locked down with an 'acquire'.
 658 *
 659 * Return: __iomem pointer to the area, or NULL
 660 */
 661void __iomem *nfp_cpp_area_iomem(struct nfp_cpp_area *area)
 662{
 663	void __iomem *iomem = NULL;
 664
 665	if (area->cpp->op->area_iomem)
 666		iomem = area->cpp->op->area_iomem(area);
 667
 668	return iomem;
 669}
 670
 671/**
 672 * nfp_cpp_area_readl() - Read a u32 word from an area
 673 * @area:	CPP Area handle
 674 * @offset:	Offset into area
 675 * @value:	Pointer to read buffer
 676 *
 677 * Return: 0 on success, or -ERRNO
 678 */
 679int nfp_cpp_area_readl(struct nfp_cpp_area *area,
 680		       unsigned long offset, u32 *value)
 681{
 682	u8 tmp[4];
 683	int n;
 684
 685	n = nfp_cpp_area_read(area, offset, &tmp, sizeof(tmp));
 686	if (n != sizeof(tmp))
 687		return n < 0 ? n : -EIO;
 688
 689	*value = get_unaligned_le32(tmp);
 690	return 0;
 691}
 692
 693/**
 694 * nfp_cpp_area_writel() - Write a u32 word to an area
 695 * @area:	CPP Area handle
 696 * @offset:	Offset into area
 697 * @value:	Value to write
 698 *
 699 * Return: 0 on success, or -ERRNO
 700 */
 701int nfp_cpp_area_writel(struct nfp_cpp_area *area,
 702			unsigned long offset, u32 value)
 703{
 704	u8 tmp[4];
 705	int n;
 706
 707	put_unaligned_le32(value, tmp);
 708	n = nfp_cpp_area_write(area, offset, &tmp, sizeof(tmp));
 709
 710	return n == sizeof(tmp) ? 0 : n < 0 ? n : -EIO;
 711}
 712
 713/**
 714 * nfp_cpp_area_readq() - Read a u64 word from an area
 715 * @area:	CPP Area handle
 716 * @offset:	Offset into area
 717 * @value:	Pointer to read buffer
 718 *
 719 * Return: 0 on success, or -ERRNO
 720 */
 721int nfp_cpp_area_readq(struct nfp_cpp_area *area,
 722		       unsigned long offset, u64 *value)
 723{
 724	u8 tmp[8];
 725	int n;
 726
 727	n = nfp_cpp_area_read(area, offset, &tmp, sizeof(tmp));
 728	if (n != sizeof(tmp))
 729		return n < 0 ? n : -EIO;
 730
 731	*value = get_unaligned_le64(tmp);
 732	return 0;
 733}
 734
 735/**
 736 * nfp_cpp_area_writeq() - Write a u64 word to an area
 737 * @area:	CPP Area handle
 738 * @offset:	Offset into area
 739 * @value:	Value to write
 740 *
 741 * Return: 0 on success, or -ERRNO
 742 */
 743int nfp_cpp_area_writeq(struct nfp_cpp_area *area,
 744			unsigned long offset, u64 value)
 745{
 746	u8 tmp[8];
 747	int n;
 748
 749	put_unaligned_le64(value, tmp);
 750	n = nfp_cpp_area_write(area, offset, &tmp, sizeof(tmp));
 751
 752	return n == sizeof(tmp) ? 0 : n < 0 ? n : -EIO;
 753}
 754
 755/**
 756 * nfp_cpp_area_fill() - fill a CPP area with a value
 757 * @area:	CPP area
 758 * @offset:	offset into CPP area
 759 * @value:	value to fill with
 760 * @length:	length of area to fill
 761 *
 762 * Fill indicated area with given value.
 763 *
 764 * Return: length of io, or -ERRNO
 765 */
 766int nfp_cpp_area_fill(struct nfp_cpp_area *area,
 767		      unsigned long offset, u32 value, size_t length)
 768{
 769	u8 tmp[4];
 770	size_t i;
 771	int k;
 772
 773	put_unaligned_le32(value, tmp);
 774
 775	if (offset % sizeof(tmp) || length % sizeof(tmp))
 776		return -EINVAL;
 777
 778	for (i = 0; i < length; i += sizeof(tmp)) {
 779		k = nfp_cpp_area_write(area, offset + i, &tmp, sizeof(tmp));
 780		if (k < 0)
 781			return k;
 782	}
 783
 784	return i;
 785}
 786
 787/**
 788 * nfp_cpp_area_cache_add() - Permanently reserve and area for the hot cache
 789 * @cpp:	NFP CPP handle
 790 * @size:	Size of the area - MUST BE A POWER OF 2.
 791 */
 792int nfp_cpp_area_cache_add(struct nfp_cpp *cpp, size_t size)
 793{
 794	struct nfp_cpp_area_cache *cache;
 795	struct nfp_cpp_area *area;
 796
 797	/* Allocate an area - we use the MU target's base as a placeholder,
 798	 * as all supported chips have a MU.
 799	 */
 800	area = nfp_cpp_area_alloc(cpp, NFP_CPP_ID(7, NFP_CPP_ACTION_RW, 0),
 801				  0, size);
 802	if (!area)
 803		return -ENOMEM;
 804
 805	cache = kzalloc(sizeof(*cache), GFP_KERNEL);
 806	if (!cache) {
 807		nfp_cpp_area_free(area);
 808		return -ENOMEM;
 809	}
 810
 811	cache->id = 0;
 812	cache->addr = 0;
 813	cache->size = size;
 814	cache->area = area;
 815	mutex_lock(&cpp->area_cache_mutex);
 816	list_add_tail(&cache->entry, &cpp->area_cache_list);
 817	mutex_unlock(&cpp->area_cache_mutex);
 818
 819	return 0;
 820}
 821
 822static struct nfp_cpp_area_cache *
 823area_cache_get(struct nfp_cpp *cpp, u32 id,
 824	       u64 addr, unsigned long *offset, size_t length)
 825{
 826	struct nfp_cpp_area_cache *cache;
 827	int err;
 828
 829	/* Early exit when length == 0, which prevents
 830	 * the need for special case code below when
 831	 * checking against available cache size.
 832	 */
 833	if (length == 0 || id == 0)
 834		return NULL;
 835
 836	/* Remap from cpp_island to cpp_target */
 837	err = nfp_target_cpp(id, addr, &id, &addr, cpp->imb_cat_table);
 838	if (err < 0)
 839		return NULL;
 840
 841	mutex_lock(&cpp->area_cache_mutex);
 842
 843	if (list_empty(&cpp->area_cache_list)) {
 844		mutex_unlock(&cpp->area_cache_mutex);
 845		return NULL;
 846	}
 847
 848	addr += *offset;
 849
 850	/* See if we have a match */
 851	list_for_each_entry(cache, &cpp->area_cache_list, entry) {
 852		if (id == cache->id &&
 853		    addr >= cache->addr &&
 854		    addr + length <= cache->addr + cache->size)
 855			goto exit;
 856	}
 857
 858	/* No matches - inspect the tail of the LRU */
 859	cache = list_entry(cpp->area_cache_list.prev,
 860			   struct nfp_cpp_area_cache, entry);
 861
 862	/* Can we fit in the cache entry? */
 863	if (round_down(addr + length - 1, cache->size) !=
 864	    round_down(addr, cache->size)) {
 865		mutex_unlock(&cpp->area_cache_mutex);
 866		return NULL;
 867	}
 868
 869	/* If id != 0, we will need to release it */
 870	if (cache->id) {
 871		nfp_cpp_area_release(cache->area);
 872		cache->id = 0;
 873		cache->addr = 0;
 874	}
 875
 876	/* Adjust the start address to be cache size aligned */
 877	cache->addr = addr & ~(u64)(cache->size - 1);
 878
 879	/* Re-init to the new ID and address */
 880	if (cpp->op->area_init) {
 881		err = cpp->op->area_init(cache->area,
 882					 id, cache->addr, cache->size);
 883		if (err < 0) {
 884			mutex_unlock(&cpp->area_cache_mutex);
 885			return NULL;
 886		}
 887	}
 888
 889	/* Attempt to acquire */
 890	err = nfp_cpp_area_acquire(cache->area);
 891	if (err < 0) {
 892		mutex_unlock(&cpp->area_cache_mutex);
 893		return NULL;
 894	}
 895
 896	cache->id = id;
 897
 898exit:
 899	/* Adjust offset */
 900	*offset = addr - cache->addr;
 901	return cache;
 902}
 903
 904static void
 905area_cache_put(struct nfp_cpp *cpp, struct nfp_cpp_area_cache *cache)
 906{
 907	if (!cache)
 908		return;
 909
 910	/* Move to front of LRU */
 911	list_move(&cache->entry, &cpp->area_cache_list);
 912
 913	mutex_unlock(&cpp->area_cache_mutex);
 914}
 915
 916static int __nfp_cpp_read(struct nfp_cpp *cpp, u32 destination,
 917			  unsigned long long address, void *kernel_vaddr,
 918			  size_t length)
 919{
 920	struct nfp_cpp_area_cache *cache;
 921	struct nfp_cpp_area *area;
 922	unsigned long offset = 0;
 923	int err;
 924
 925	cache = area_cache_get(cpp, destination, address, &offset, length);
 926	if (cache) {
 927		area = cache->area;
 928	} else {
 929		area = nfp_cpp_area_alloc(cpp, destination, address, length);
 930		if (!area)
 931			return -ENOMEM;
 932
 933		err = nfp_cpp_area_acquire(area);
 934		if (err) {
 935			nfp_cpp_area_free(area);
 936			return err;
 937		}
 938	}
 939
 940	err = nfp_cpp_area_read(area, offset, kernel_vaddr, length);
 941
 942	if (cache)
 943		area_cache_put(cpp, cache);
 944	else
 945		nfp_cpp_area_release_free(area);
 946
 947	return err;
 948}
 949
 950/**
 951 * nfp_cpp_read() - read from CPP target
 952 * @cpp:		CPP handle
 953 * @destination:	CPP id
 954 * @address:		offset into CPP target
 955 * @kernel_vaddr:	kernel buffer for result
 956 * @length:		number of bytes to read
 957 *
 958 * Return: length of io, or -ERRNO
 959 */
 960int nfp_cpp_read(struct nfp_cpp *cpp, u32 destination,
 961		 unsigned long long address, void *kernel_vaddr,
 962		 size_t length)
 963{
 964	size_t n, offset;
 965	int ret;
 966
 967	for (offset = 0; offset < length; offset += n) {
 968		unsigned long long r_addr = address + offset;
 969
 970		/* make first read smaller to align to safe window */
 971		n = min_t(size_t, length - offset,
 972			  ALIGN(r_addr + 1, NFP_CPP_SAFE_AREA_SIZE) - r_addr);
 973
 974		ret = __nfp_cpp_read(cpp, destination, address + offset,
 975				     kernel_vaddr + offset, n);
 976		if (ret < 0)
 977			return ret;
 978		if (ret != n)
 979			return offset + n;
 980	}
 981
 982	return length;
 983}
 984
 985static int __nfp_cpp_write(struct nfp_cpp *cpp, u32 destination,
 986			   unsigned long long address,
 987			   const void *kernel_vaddr, size_t length)
 988{
 989	struct nfp_cpp_area_cache *cache;
 990	struct nfp_cpp_area *area;
 991	unsigned long offset = 0;
 992	int err;
 993
 994	cache = area_cache_get(cpp, destination, address, &offset, length);
 995	if (cache) {
 996		area = cache->area;
 997	} else {
 998		area = nfp_cpp_area_alloc(cpp, destination, address, length);
 999		if (!area)
1000			return -ENOMEM;
1001
1002		err = nfp_cpp_area_acquire(area);
1003		if (err) {
1004			nfp_cpp_area_free(area);
1005			return err;
1006		}
1007	}
1008
1009	err = nfp_cpp_area_write(area, offset, kernel_vaddr, length);
1010
1011	if (cache)
1012		area_cache_put(cpp, cache);
1013	else
1014		nfp_cpp_area_release_free(area);
1015
1016	return err;
1017}
1018
1019/**
1020 * nfp_cpp_write() - write to CPP target
1021 * @cpp:		CPP handle
1022 * @destination:	CPP id
1023 * @address:		offset into CPP target
1024 * @kernel_vaddr:	kernel buffer to read from
1025 * @length:		number of bytes to write
1026 *
1027 * Return: length of io, or -ERRNO
1028 */
1029int nfp_cpp_write(struct nfp_cpp *cpp, u32 destination,
1030		  unsigned long long address,
1031		  const void *kernel_vaddr, size_t length)
1032{
1033	size_t n, offset;
1034	int ret;
1035
1036	for (offset = 0; offset < length; offset += n) {
1037		unsigned long long w_addr = address + offset;
1038
1039		/* make first write smaller to align to safe window */
1040		n = min_t(size_t, length - offset,
1041			  ALIGN(w_addr + 1, NFP_CPP_SAFE_AREA_SIZE) - w_addr);
1042
1043		ret = __nfp_cpp_write(cpp, destination, address + offset,
1044				      kernel_vaddr + offset, n);
1045		if (ret < 0)
1046			return ret;
1047		if (ret != n)
1048			return offset + n;
1049	}
1050
1051	return length;
1052}
1053
1054/* Return the correct CPP address, and fixup xpb_addr as needed. */
1055static u32 nfp_xpb_to_cpp(struct nfp_cpp *cpp, u32 *xpb_addr)
1056{
1057	int island;
1058	u32 xpb;
1059
1060	xpb = NFP_CPP_ID(14, NFP_CPP_ACTION_RW, 0);
1061	/* Ensure that non-local XPB accesses go
1062	 * out through the global XPBM bus.
1063	 */
1064	island = (*xpb_addr >> 24) & 0x3f;
1065	if (!island)
1066		return xpb;
1067
1068	if (island != 1) {
1069		*xpb_addr |= 1 << 30;
1070		return xpb;
1071	}
1072
1073	/* Accesses to the ARM Island overlay uses Island 0 / Global Bit */
1074	*xpb_addr &= ~0x7f000000;
1075	if (*xpb_addr < 0x60000) {
1076		*xpb_addr |= 1 << 30;
1077	} else {
1078		/* And only non-ARM interfaces use the island id = 1 */
1079		if (NFP_CPP_INTERFACE_TYPE_of(nfp_cpp_interface(cpp))
1080		    != NFP_CPP_INTERFACE_TYPE_ARM)
1081			*xpb_addr |= 1 << 24;
1082	}
1083
1084	return xpb;
1085}
1086
1087/**
1088 * nfp_xpb_readl() - Read a u32 word from a XPB location
1089 * @cpp:	CPP device handle
1090 * @xpb_addr:	Address for operation
1091 * @value:	Pointer to read buffer
1092 *
1093 * Return: 0 on success, or -ERRNO
1094 */
1095int nfp_xpb_readl(struct nfp_cpp *cpp, u32 xpb_addr, u32 *value)
1096{
1097	u32 cpp_dest = nfp_xpb_to_cpp(cpp, &xpb_addr);
1098
1099	return nfp_cpp_readl(cpp, cpp_dest, xpb_addr, value);
1100}
1101
1102/**
1103 * nfp_xpb_writel() - Write a u32 word to a XPB location
1104 * @cpp:	CPP device handle
1105 * @xpb_addr:	Address for operation
1106 * @value:	Value to write
1107 *
1108 * Return: 0 on success, or -ERRNO
1109 */
1110int nfp_xpb_writel(struct nfp_cpp *cpp, u32 xpb_addr, u32 value)
1111{
1112	u32 cpp_dest = nfp_xpb_to_cpp(cpp, &xpb_addr);
1113
1114	return nfp_cpp_writel(cpp, cpp_dest, xpb_addr, value);
1115}
1116
1117/**
1118 * nfp_xpb_writelm() - Modify bits of a 32-bit value from the XPB bus
1119 * @cpp:	NFP CPP device handle
1120 * @xpb_tgt:	XPB target and address
1121 * @mask:	mask of bits to alter
1122 * @value:	value to modify
1123 *
1124 * KERNEL: This operation is safe to call in interrupt or softirq context.
1125 *
1126 * Return: 0 on success, or -ERRNO
1127 */
1128int nfp_xpb_writelm(struct nfp_cpp *cpp, u32 xpb_tgt,
1129		    u32 mask, u32 value)
1130{
1131	int err;
1132	u32 tmp;
1133
1134	err = nfp_xpb_readl(cpp, xpb_tgt, &tmp);
1135	if (err < 0)
1136		return err;
1137
1138	tmp &= ~mask;
1139	tmp |= mask & value;
1140	return nfp_xpb_writel(cpp, xpb_tgt, tmp);
1141}
1142
1143/* Lockdep markers */
1144static struct lock_class_key nfp_cpp_resource_lock_key;
1145
1146static void nfp_cpp_dev_release(struct device *dev)
1147{
1148	/* Nothing to do here - it just makes the kernel happy */
1149}
1150
1151/**
1152 * nfp_cpp_from_operations() - Create a NFP CPP handle
1153 *                             from an operations structure
1154 * @ops:	NFP CPP operations structure
1155 * @parent:	Parent device
1156 * @priv:	Private data of low-level implementation
1157 *
1158 * NOTE: On failure, cpp_ops->free will be called!
1159 *
1160 * Return: NFP CPP handle on success, ERR_PTR on failure
1161 */
1162struct nfp_cpp *
1163nfp_cpp_from_operations(const struct nfp_cpp_operations *ops,
1164			struct device *parent, void *priv)
1165{
1166	const u32 arm = NFP_CPP_ID(NFP_CPP_TARGET_ARM, NFP_CPP_ACTION_RW, 0);
1167	struct nfp_cpp *cpp;
1168	int ifc, err;
1169	u32 mask[2];
1170	u32 xpbaddr;
1171	size_t tgt;
1172
1173	cpp = kzalloc(sizeof(*cpp), GFP_KERNEL);
1174	if (!cpp) {
1175		err = -ENOMEM;
1176		goto err_malloc;
1177	}
1178
1179	cpp->op = ops;
1180	cpp->priv = priv;
1181
1182	ifc = ops->get_interface(parent);
1183	if (ifc < 0) {
1184		err = ifc;
1185		goto err_free_cpp;
1186	}
1187	cpp->interface = ifc;
1188	if (ops->read_serial) {
1189		err = ops->read_serial(parent, cpp->serial);
1190		if (err)
1191			goto err_free_cpp;
1192	}
1193
1194	rwlock_init(&cpp->resource_lock);
1195	init_waitqueue_head(&cpp->waitq);
1196	lockdep_set_class(&cpp->resource_lock, &nfp_cpp_resource_lock_key);
1197	INIT_LIST_HEAD(&cpp->resource_list);
1198	INIT_LIST_HEAD(&cpp->area_cache_list);
1199	mutex_init(&cpp->area_cache_mutex);
1200	cpp->dev.init_name = "cpp";
1201	cpp->dev.parent = parent;
1202	cpp->dev.release = nfp_cpp_dev_release;
1203	err = device_register(&cpp->dev);
1204	if (err < 0) {
1205		put_device(&cpp->dev);
1206		goto err_free_cpp;
1207	}
1208
1209	dev_set_drvdata(&cpp->dev, cpp);
1210
1211	/* NOTE: cpp_lock is NOT locked for op->init,
1212	 * since it may call NFP CPP API operations
1213	 */
1214	if (cpp->op->init) {
1215		err = cpp->op->init(cpp);
1216		if (err < 0) {
1217			dev_err(parent,
1218				"NFP interface initialization failed\n");
1219			goto err_out;
1220		}
1221	}
1222
1223	err = nfp_cpp_model_autodetect(cpp, &cpp->model);
1224	if (err < 0) {
1225		dev_err(parent, "NFP model detection failed\n");
1226		goto err_out;
1227	}
1228
1229	for (tgt = 0; tgt < ARRAY_SIZE(cpp->imb_cat_table); tgt++) {
1230			/* Hardcoded XPB IMB Base, island 0 */
1231		xpbaddr = 0x000a0000 + (tgt * 4);
1232		err = nfp_xpb_readl(cpp, xpbaddr,
1233				    &cpp->imb_cat_table[tgt]);
1234		if (err < 0) {
1235			dev_err(parent,
1236				"Can't read CPP mapping from device\n");
1237			goto err_out;
1238		}
1239	}
1240
1241	nfp_cpp_readl(cpp, arm, NFP_ARM_GCSR + NFP_ARM_GCSR_SOFTMODEL2,
1242		      &mask[0]);
1243	nfp_cpp_readl(cpp, arm, NFP_ARM_GCSR + NFP_ARM_GCSR_SOFTMODEL3,
1244		      &mask[1]);
1245
1246	err = nfp_cpp_set_mu_locality_lsb(cpp);
1247	if (err < 0) {
1248		dev_err(parent,	"Can't calculate MU locality bit offset\n");
1249		goto err_out;
1250	}
1251
1252	dev_info(cpp->dev.parent, "Model: 0x%08x, SN: %pM, Ifc: 0x%04x\n",
1253		 nfp_cpp_model(cpp), cpp->serial, nfp_cpp_interface(cpp));
1254
1255	return cpp;
1256
1257err_out:
1258	device_unregister(&cpp->dev);
1259err_free_cpp:
1260	kfree(cpp);
1261err_malloc:
1262	return ERR_PTR(err);
1263}
1264
1265/**
1266 * nfp_cpp_priv() - Get the operations private data of a CPP handle
1267 * @cpp:	CPP handle
1268 *
1269 * Return: Private data for the NFP CPP handle
1270 */
1271void *nfp_cpp_priv(struct nfp_cpp *cpp)
1272{
1273	return cpp->priv;
1274}
1275
1276/**
1277 * nfp_cpp_device() - Get the Linux device handle of a CPP handle
1278 * @cpp:	CPP handle
1279 *
1280 * Return: Device for the NFP CPP bus
1281 */
1282struct device *nfp_cpp_device(struct nfp_cpp *cpp)
1283{
1284	return &cpp->dev;
1285}
1286
1287#define NFP_EXPL_OP(func, expl, args...)			  \
1288	({							  \
1289		struct nfp_cpp *cpp = nfp_cpp_explicit_cpp(expl); \
1290		int err = -ENODEV;				  \
1291								  \
1292		if (cpp->op->func)				  \
1293			err = cpp->op->func(expl, ##args);	  \
1294		err;						  \
1295	})
1296
1297#define NFP_EXPL_OP_NR(func, expl, args...)			  \
1298	({							  \
1299		struct nfp_cpp *cpp = nfp_cpp_explicit_cpp(expl); \
1300								  \
1301		if (cpp->op->func)				  \
1302			cpp->op->func(expl, ##args);		  \
1303								  \
1304	})
1305
1306/**
1307 * nfp_cpp_explicit_acquire() - Acquire explicit access handle
1308 * @cpp:	NFP CPP handle
1309 *
1310 * The 'data_ref' and 'signal_ref' values are useful when
1311 * constructing the NFP_EXPL_CSR1 and NFP_EXPL_POST values.
1312 *
1313 * Return: NFP CPP explicit handle
1314 */
1315struct nfp_cpp_explicit *nfp_cpp_explicit_acquire(struct nfp_cpp *cpp)
1316{
1317	struct nfp_cpp_explicit *expl;
1318	int err;
1319
1320	expl = kzalloc(sizeof(*expl) + cpp->op->explicit_priv_size, GFP_KERNEL);
1321	if (!expl)
1322		return NULL;
1323
1324	expl->cpp = cpp;
1325	err = NFP_EXPL_OP(explicit_acquire, expl);
1326	if (err < 0) {
1327		kfree(expl);
1328		return NULL;
1329	}
1330
1331	return expl;
1332}
1333
1334/**
1335 * nfp_cpp_explicit_set_target() - Set target fields for explicit
1336 * @expl:	Explicit handle
1337 * @cpp_id:	CPP ID field
1338 * @len:	CPP Length field
1339 * @mask:	CPP Mask field
1340 *
1341 * Return: 0, or -ERRNO
1342 */
1343int nfp_cpp_explicit_set_target(struct nfp_cpp_explicit *expl,
1344				u32 cpp_id, u8 len, u8 mask)
1345{
1346	expl->cmd.cpp_id = cpp_id;
1347	expl->cmd.len = len;
1348	expl->cmd.byte_mask = mask;
1349
1350	return 0;
1351}
1352
1353/**
1354 * nfp_cpp_explicit_set_data() - Set data fields for explicit
1355 * @expl:	Explicit handle
1356 * @data_master: CPP Data Master field
1357 * @data_ref:	CPP Data Ref field
1358 *
1359 * Return: 0, or -ERRNO
1360 */
1361int nfp_cpp_explicit_set_data(struct nfp_cpp_explicit *expl,
1362			      u8 data_master, u16 data_ref)
1363{
1364	expl->cmd.data_master = data_master;
1365	expl->cmd.data_ref = data_ref;
1366
1367	return 0;
1368}
1369
1370/**
1371 * nfp_cpp_explicit_set_signal() - Set signal fields for explicit
1372 * @expl:	Explicit handle
1373 * @signal_master: CPP Signal Master field
1374 * @signal_ref:	CPP Signal Ref field
1375 *
1376 * Return: 0, or -ERRNO
1377 */
1378int nfp_cpp_explicit_set_signal(struct nfp_cpp_explicit *expl,
1379				u8 signal_master, u8 signal_ref)
1380{
1381	expl->cmd.signal_master = signal_master;
1382	expl->cmd.signal_ref = signal_ref;
1383
1384	return 0;
1385}
1386
1387/**
1388 * nfp_cpp_explicit_set_posted() - Set completion fields for explicit
1389 * @expl:	Explicit handle
1390 * @posted:	True for signaled completion, false otherwise
1391 * @siga:	CPP Signal A field
1392 * @siga_mode:	CPP Signal A Mode field
1393 * @sigb:	CPP Signal B field
1394 * @sigb_mode:	CPP Signal B Mode field
1395 *
1396 * Return: 0, or -ERRNO
1397 */
1398int nfp_cpp_explicit_set_posted(struct nfp_cpp_explicit *expl, int posted,
1399				u8 siga,
1400				enum nfp_cpp_explicit_signal_mode siga_mode,
1401				u8 sigb,
1402				enum nfp_cpp_explicit_signal_mode sigb_mode)
1403{
1404	expl->cmd.posted = posted;
1405	expl->cmd.siga = siga;
1406	expl->cmd.sigb = sigb;
1407	expl->cmd.siga_mode = siga_mode;
1408	expl->cmd.sigb_mode = sigb_mode;
1409
1410	return 0;
1411}
1412
1413/**
1414 * nfp_cpp_explicit_put() - Set up the write (pull) data for a explicit access
1415 * @expl:	NFP CPP Explicit handle
1416 * @buff:	Data to have the target pull in the transaction
1417 * @len:	Length of data, in bytes
1418 *
1419 * The 'len' parameter must be less than or equal to 128 bytes.
1420 *
1421 * If this function is called before the configuration
1422 * registers are set, it will return -EINVAL.
1423 *
1424 * Return: 0, or -ERRNO
1425 */
1426int nfp_cpp_explicit_put(struct nfp_cpp_explicit *expl,
1427			 const void *buff, size_t len)
1428{
1429	return NFP_EXPL_OP(explicit_put, expl, buff, len);
1430}
1431
1432/**
1433 * nfp_cpp_explicit_do() - Execute a transaction, and wait for it to complete
1434 * @expl:	NFP CPP Explicit handle
1435 * @address:	Address to send in the explicit transaction
1436 *
1437 * If this function is called before the configuration
1438 * registers are set, it will return -1, with an errno of EINVAL.
1439 *
1440 * Return: 0, or -ERRNO
1441 */
1442int nfp_cpp_explicit_do(struct nfp_cpp_explicit *expl, u64 address)
1443{
1444	return NFP_EXPL_OP(explicit_do, expl, &expl->cmd, address);
1445}
1446
1447/**
1448 * nfp_cpp_explicit_get() - Get the 'push' (read) data from a explicit access
1449 * @expl:	NFP CPP Explicit handle
1450 * @buff:	Data that the target pushed in the transaction
1451 * @len:	Length of data, in bytes
1452 *
1453 * The 'len' parameter must be less than or equal to 128 bytes.
1454 *
1455 * If this function is called before all three configuration
1456 * registers are set, it will return -1, with an errno of EINVAL.
1457 *
1458 * If this function is called before nfp_cpp_explicit_do()
1459 * has completed, it will return -1, with an errno of EBUSY.
1460 *
1461 * Return: 0, or -ERRNO
1462 */
1463int nfp_cpp_explicit_get(struct nfp_cpp_explicit *expl, void *buff, size_t len)
1464{
1465	return NFP_EXPL_OP(explicit_get, expl, buff, len);
1466}
1467
1468/**
1469 * nfp_cpp_explicit_release() - Release explicit access handle
1470 * @expl:	NFP CPP Explicit handle
1471 *
1472 */
1473void nfp_cpp_explicit_release(struct nfp_cpp_explicit *expl)
1474{
1475	NFP_EXPL_OP_NR(explicit_release, expl);
1476	kfree(expl);
1477}
1478
1479/**
1480 * nfp_cpp_explicit_cpp() - return CPP handle for CPP explicit
1481 * @cpp_explicit:	CPP explicit handle
1482 *
1483 * Return: NFP CPP handle of the explicit
1484 */
1485struct nfp_cpp *nfp_cpp_explicit_cpp(struct nfp_cpp_explicit *cpp_explicit)
1486{
1487	return cpp_explicit->cpp;
1488}
1489
1490/**
1491 * nfp_cpp_explicit_priv() - return private struct for CPP explicit
1492 * @cpp_explicit:	CPP explicit handle
1493 *
1494 * Return: private data of the explicit, or NULL
1495 */
1496void *nfp_cpp_explicit_priv(struct nfp_cpp_explicit *cpp_explicit)
1497{
1498	return &cpp_explicit[1];
1499}