drivers/net/ethernet/netronome/nfp/nfpcore/nfp_cppcore.c

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