1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018 Netronome Systems, Inc. 3 * All rights reserved. 4 */ 5 6 #ifndef __NFP_CPP_H__ 7 #define __NFP_CPP_H__ 8 9 #include <ethdev_pci.h> 10 11 #include "nfp-common/nfp_platform.h" 12 #include "nfp-common/nfp_resid.h" 13 14 struct nfp_cpp_mutex; 15 16 /* 17 * NFP CPP handle 18 */ 19 struct nfp_cpp { 20 uint32_t model; 21 uint32_t interface; 22 uint8_t *serial; 23 int serial_len; 24 void *priv; 25 26 /* Mutex cache */ 27 struct nfp_cpp_mutex *mutex_cache; 28 const struct nfp_cpp_operations *op; 29 30 /* 31 * NFP-6xxx originating island IMB CPP Address Translation. CPP Target 32 * ID is index into array. Values are obtained at runtime from local 33 * island XPB CSRs. 34 */ 35 uint32_t imb_cat_table[16]; 36 37 int driver_lock_needed; 38 }; 39 40 /* 41 * NFP CPP device area handle 42 */ 43 struct nfp_cpp_area { 44 struct nfp_cpp *cpp; 45 char *name; 46 unsigned long long offset; 47 unsigned long size; 48 /* Here follows the 'priv' part of nfp_cpp_area. */ 49 }; 50 51 /* 52 * NFP CPP operations structure 53 */ 54 struct nfp_cpp_operations { 55 /* Size of priv area in struct nfp_cpp_area */ 56 size_t area_priv_size; 57 58 /* Instance an NFP CPP */ 59 int (*init)(struct nfp_cpp *cpp, struct rte_pci_device *dev); 60 61 /* 62 * Free the bus. 63 * Called only once, during nfp_cpp_unregister() 64 */ 65 void (*free)(struct nfp_cpp *cpp); 66 67 /* 68 * Initialize a new NFP CPP area 69 * NOTE: This is _not_ serialized 70 */ 71 int (*area_init)(struct nfp_cpp_area *area, 72 uint32_t dest, 73 unsigned long long address, 74 unsigned long size); 75 /* 76 * Clean up a NFP CPP area before it is freed 77 * NOTE: This is _not_ serialized 78 */ 79 void (*area_cleanup)(struct nfp_cpp_area *area); 80 81 /* 82 * Acquire resources for a NFP CPP area 83 * Serialized 84 */ 85 int (*area_acquire)(struct nfp_cpp_area *area); 86 /* 87 * Release resources for a NFP CPP area 88 * Serialized 89 */ 90 void (*area_release)(struct nfp_cpp_area *area); 91 /* 92 * Return a void IO pointer to a NFP CPP area 93 * NOTE: This is _not_ serialized 94 */ 95 96 void *(*area_iomem)(struct nfp_cpp_area *area); 97 98 void *(*area_mapped)(struct nfp_cpp_area *area); 99 /* 100 * Perform a read from a NFP CPP area 101 * Serialized 102 */ 103 int (*area_read)(struct nfp_cpp_area *area, 104 void *kernel_vaddr, 105 unsigned long offset, 106 unsigned int length); 107 /* 108 * Perform a write to a NFP CPP area 109 * Serialized 110 */ 111 int (*area_write)(struct nfp_cpp_area *area, 112 const void *kernel_vaddr, 113 unsigned long offset, 114 unsigned int length); 115 }; 116 117 /* 118 * This should be the only external function the transport 119 * module supplies 120 */ 121 const struct nfp_cpp_operations *nfp_cpp_transport_operations(void); 122 123 /* 124 * Set the model id 125 * 126 * @param cpp NFP CPP operations structure 127 * @param model Model ID 128 */ 129 void nfp_cpp_model_set(struct nfp_cpp *cpp, uint32_t model); 130 131 /* 132 * Set the private instance owned data of a nfp_cpp struct 133 * 134 * @param cpp NFP CPP operations structure 135 * @param interface Interface ID 136 */ 137 void nfp_cpp_interface_set(struct nfp_cpp *cpp, uint32_t interface); 138 139 /* 140 * Set the private instance owned data of a nfp_cpp struct 141 * 142 * @param cpp NFP CPP operations structure 143 * @param serial NFP serial byte array 144 * @param len Length of the serial byte array 145 */ 146 int nfp_cpp_serial_set(struct nfp_cpp *cpp, const uint8_t *serial, 147 size_t serial_len); 148 149 /* 150 * Set the private data of the nfp_cpp instance 151 * 152 * @param cpp NFP CPP operations structure 153 * @return Opaque device pointer 154 */ 155 void nfp_cpp_priv_set(struct nfp_cpp *cpp, void *priv); 156 157 /* 158 * Return the private data of the nfp_cpp instance 159 * 160 * @param cpp NFP CPP operations structure 161 * @return Opaque device pointer 162 */ 163 void *nfp_cpp_priv(struct nfp_cpp *cpp); 164 165 /* 166 * Get the privately allocated portion of a NFP CPP area handle 167 * 168 * @param cpp_area NFP CPP area handle 169 * @return Pointer to the private area, or NULL on failure 170 */ 171 void *nfp_cpp_area_priv(struct nfp_cpp_area *cpp_area); 172 173 uint32_t __nfp_cpp_model_autodetect(struct nfp_cpp *cpp, uint32_t *model); 174 175 /* 176 * NFP CPP core interface for CPP clients. 177 */ 178 179 /* 180 * Open a NFP CPP handle to a CPP device 181 * 182 * @param[in] id 0-based ID for the CPP interface to use 183 * 184 * @return NFP CPP handle, or NULL on failure (and set errno accordingly). 185 */ 186 struct nfp_cpp *nfp_cpp_from_device_name(struct rte_pci_device *dev, 187 int driver_lock_needed); 188 189 /* 190 * Free a NFP CPP handle 191 * 192 * @param[in] cpp NFP CPP handle 193 */ 194 void nfp_cpp_free(struct nfp_cpp *cpp); 195 196 #define NFP_CPP_MODEL_INVALID 0xffffffff 197 198 /* 199 * NFP_CPP_MODEL_CHIP_of - retrieve the chip ID from the model ID 200 * 201 * The chip ID is a 16-bit BCD+A-F encoding for the chip type. 202 * 203 * @param[in] model NFP CPP model id 204 * @return NFP CPP chip id 205 */ 206 #define NFP_CPP_MODEL_CHIP_of(model) (((model) >> 16) & 0xffff) 207 208 /* 209 * NFP_CPP_MODEL_IS_6000 - Check for the NFP6000 family of devices 210 * 211 * NOTE: The NFP4000 series is considered as a NFP6000 series variant. 212 * 213 * @param[in] model NFP CPP model id 214 * @return true if model is in the NFP6000 family, false otherwise. 215 */ 216 #define NFP_CPP_MODEL_IS_6000(model) \ 217 ((NFP_CPP_MODEL_CHIP_of(model) >= 0x4000) && \ 218 (NFP_CPP_MODEL_CHIP_of(model) < 0x7000)) 219 220 /* 221 * nfp_cpp_model - Retrieve the Model ID of the NFP 222 * 223 * @param[in] cpp NFP CPP handle 224 * @return NFP CPP Model ID 225 */ 226 uint32_t nfp_cpp_model(struct nfp_cpp *cpp); 227 228 /* 229 * NFP Interface types - logical interface for this CPP connection 4 bits are 230 * reserved for interface type. 231 */ 232 #define NFP_CPP_INTERFACE_TYPE_INVALID 0x0 233 #define NFP_CPP_INTERFACE_TYPE_PCI 0x1 234 #define NFP_CPP_INTERFACE_TYPE_ARM 0x2 235 #define NFP_CPP_INTERFACE_TYPE_RPC 0x3 236 #define NFP_CPP_INTERFACE_TYPE_ILA 0x4 237 238 /* 239 * Construct a 16-bit NFP Interface ID 240 * 241 * Interface IDs consists of 4 bits of interface type, 4 bits of unit 242 * identifier, and 8 bits of channel identifier. 243 * 244 * The NFP Interface ID is used in the implementation of NFP CPP API mutexes, 245 * which use the MU Atomic CompareAndWrite operation - hence the limit to 16 246 * bits to be able to use the NFP Interface ID as a lock owner. 247 * 248 * @param[in] type NFP Interface Type 249 * @param[in] unit Unit identifier for the interface type 250 * @param[in] channel Channel identifier for the interface unit 251 * @return Interface ID 252 */ 253 #define NFP_CPP_INTERFACE(type, unit, channel) \ 254 ((((type) & 0xf) << 12) | \ 255 (((unit) & 0xf) << 8) | \ 256 (((channel) & 0xff) << 0)) 257 258 /* 259 * Get the interface type of a NFP Interface ID 260 * @param[in] interface NFP Interface ID 261 * @return NFP Interface ID's type 262 */ 263 #define NFP_CPP_INTERFACE_TYPE_of(interface) (((interface) >> 12) & 0xf) 264 265 /* 266 * Get the interface unit of a NFP Interface ID 267 * @param[in] interface NFP Interface ID 268 * @return NFP Interface ID's unit 269 */ 270 #define NFP_CPP_INTERFACE_UNIT_of(interface) (((interface) >> 8) & 0xf) 271 272 /* 273 * Get the interface channel of a NFP Interface ID 274 * @param[in] interface NFP Interface ID 275 * @return NFP Interface ID's channel 276 */ 277 #define NFP_CPP_INTERFACE_CHANNEL_of(interface) (((interface) >> 0) & 0xff) 278 279 /* 280 * Retrieve the Interface ID of the NFP 281 * @param[in] cpp NFP CPP handle 282 * @return NFP CPP Interface ID 283 */ 284 uint16_t nfp_cpp_interface(struct nfp_cpp *cpp); 285 286 /* 287 * Retrieve the NFP Serial Number (unique per NFP) 288 * @param[in] cpp NFP CPP handle 289 * @param[out] serial Pointer to reference the serial number array 290 * 291 * @return size of the NFP6000 serial number, in bytes 292 */ 293 int nfp_cpp_serial(struct nfp_cpp *cpp, const uint8_t **serial); 294 295 /* 296 * Allocate a NFP CPP area handle, as an offset into a CPP ID 297 * @param[in] cpp NFP CPP handle 298 * @param[in] cpp_id NFP CPP ID 299 * @param[in] address Offset into the NFP CPP ID address space 300 * @param[in] size Size of the area to reserve 301 * 302 * @return NFP CPP handle, or NULL on failure (and set errno accordingly). 303 */ 304 struct nfp_cpp_area *nfp_cpp_area_alloc(struct nfp_cpp *cpp, uint32_t cpp_id, 305 unsigned long long address, 306 unsigned long size); 307 308 /* 309 * Allocate a NFP CPP area handle, as an offset into a CPP ID, by a named owner 310 * @param[in] cpp NFP CPP handle 311 * @param[in] cpp_id NFP CPP ID 312 * @param[in] name Name of owner of the area 313 * @param[in] address Offset into the NFP CPP ID address space 314 * @param[in] size Size of the area to reserve 315 * 316 * @return NFP CPP handle, or NULL on failure (and set errno accordingly). 317 */ 318 struct nfp_cpp_area *nfp_cpp_area_alloc_with_name(struct nfp_cpp *cpp, 319 uint32_t cpp_id, 320 const char *name, 321 unsigned long long address, 322 unsigned long size); 323 324 /* 325 * Free an allocated NFP CPP area handle 326 * @param[in] area NFP CPP area handle 327 */ 328 void nfp_cpp_area_free(struct nfp_cpp_area *area); 329 330 /* 331 * Acquire the resources needed to access the NFP CPP area handle 332 * 333 * @param[in] area NFP CPP area handle 334 * 335 * @return 0 on success, -1 on failure (and set errno accordingly). 336 */ 337 int nfp_cpp_area_acquire(struct nfp_cpp_area *area); 338 339 /* 340 * Release the resources needed to access the NFP CPP area handle 341 * 342 * @param[in] area NFP CPP area handle 343 */ 344 void nfp_cpp_area_release(struct nfp_cpp_area *area); 345 346 /* 347 * Allocate, then acquire the resources needed to access the NFP CPP area handle 348 * @param[in] cpp NFP CPP handle 349 * @param[in] cpp_id NFP CPP ID 350 * @param[in] address Offset into the NFP CPP ID address space 351 * @param[in] size Size of the area to reserve 352 * 353 * @return NFP CPP handle, or NULL on failure (and set errno accordingly). 354 */ 355 struct nfp_cpp_area *nfp_cpp_area_alloc_acquire(struct nfp_cpp *cpp, 356 uint32_t cpp_id, 357 unsigned long long address, 358 unsigned long size); 359 360 /* 361 * Release the resources, then free the NFP CPP area handle 362 * @param[in] area NFP CPP area handle 363 */ 364 void nfp_cpp_area_release_free(struct nfp_cpp_area *area); 365 366 uint8_t *nfp_cpp_map_area(struct nfp_cpp *cpp, int domain, int target, 367 uint64_t addr, unsigned long size, 368 struct nfp_cpp_area **area); 369 /* 370 * Return an IO pointer to the beginning of the NFP CPP area handle. The area 371 * must be acquired with 'nfp_cpp_area_acquire()' before calling this operation. 372 * 373 * @param[in] area NFP CPP area handle 374 * 375 * @return Pointer to IO memory, or NULL on failure (and set errno accordingly). 376 */ 377 void *nfp_cpp_area_mapped(struct nfp_cpp_area *area); 378 379 /* 380 * Read from a NFP CPP area handle into a buffer. The area must be acquired with 381 * 'nfp_cpp_area_acquire()' before calling this operation. 382 * 383 * @param[in] area NFP CPP area handle 384 * @param[in] offset Offset into the area 385 * @param[in] buffer Location of buffer to receive the data 386 * @param[in] length Length of the data to read 387 * 388 * @return bytes read on success, -1 on failure (and set errno accordingly). 389 * 390 */ 391 int nfp_cpp_area_read(struct nfp_cpp_area *area, unsigned long offset, 392 void *buffer, size_t length); 393 394 /* 395 * Write to a NFP CPP area handle from a buffer. The area must be acquired with 396 * 'nfp_cpp_area_acquire()' before calling this operation. 397 * 398 * @param[in] area NFP CPP area handle 399 * @param[in] offset Offset into the area 400 * @param[in] buffer Location of buffer that holds the data 401 * @param[in] length Length of the data to read 402 * 403 * @return bytes written on success, -1 on failure (and set errno accordingly). 404 */ 405 int nfp_cpp_area_write(struct nfp_cpp_area *area, unsigned long offset, 406 const void *buffer, size_t length); 407 408 /* 409 * nfp_cpp_area_iomem() - get IOMEM region for CPP area 410 * @area: CPP area handle 411 * 412 * Returns an iomem pointer for use with readl()/writel() style operations. 413 * 414 * NOTE: Area must have been locked down with an 'acquire'. 415 * 416 * Return: pointer to the area, or NULL 417 */ 418 void *nfp_cpp_area_iomem(struct nfp_cpp_area *area); 419 420 /* 421 * Verify that IO can be performed on an offset in an area 422 * 423 * @param[in] area NFP CPP area handle 424 * @param[in] offset Offset into the area 425 * @param[in] size Size of region to validate 426 * 427 * @return 0 on success, -1 on failure (and set errno accordingly). 428 */ 429 int nfp_cpp_area_check_range(struct nfp_cpp_area *area, 430 unsigned long long offset, unsigned long size); 431 432 /* 433 * Get the NFP CPP handle that is the parent of a NFP CPP area handle 434 * 435 * @param cpp_area NFP CPP area handle 436 * @return NFP CPP handle 437 */ 438 struct nfp_cpp *nfp_cpp_area_cpp(struct nfp_cpp_area *cpp_area); 439 440 /* 441 * Get the name passed during allocation of the NFP CPP area handle 442 * 443 * @param cpp_area NFP CPP area handle 444 * @return Pointer to the area's name 445 */ 446 const char *nfp_cpp_area_name(struct nfp_cpp_area *cpp_area); 447 448 /* 449 * Read a block of data from a NFP CPP ID 450 * 451 * @param[in] cpp NFP CPP handle 452 * @param[in] cpp_id NFP CPP ID 453 * @param[in] address Offset into the NFP CPP ID address space 454 * @param[in] kernel_vaddr Buffer to copy read data to 455 * @param[in] length Size of the area to reserve 456 * 457 * @return bytes read on success, -1 on failure (and set errno accordingly). 458 */ 459 int nfp_cpp_read(struct nfp_cpp *cpp, uint32_t cpp_id, 460 unsigned long long address, void *kernel_vaddr, size_t length); 461 462 /* 463 * Write a block of data to a NFP CPP ID 464 * 465 * @param[in] cpp NFP CPP handle 466 * @param[in] cpp_id NFP CPP ID 467 * @param[in] address Offset into the NFP CPP ID address space 468 * @param[in] kernel_vaddr Buffer to copy write data from 469 * @param[in] length Size of the area to reserve 470 * 471 * @return bytes written on success, -1 on failure (and set errno accordingly). 472 */ 473 int nfp_cpp_write(struct nfp_cpp *cpp, uint32_t cpp_id, 474 unsigned long long address, const void *kernel_vaddr, 475 size_t length); 476 477 478 479 /* 480 * Fill a NFP CPP area handle and offset with a value 481 * 482 * @param[in] area NFP CPP area handle 483 * @param[in] offset Offset into the NFP CPP ID address space 484 * @param[in] value 32-bit value to fill area with 485 * @param[in] length Size of the area to reserve 486 * 487 * @return bytes written on success, -1 on failure (and set errno accordingly). 488 */ 489 int nfp_cpp_area_fill(struct nfp_cpp_area *area, unsigned long offset, 490 uint32_t value, size_t length); 491 492 /* 493 * Read a single 32-bit value from a NFP CPP area handle 494 * 495 * @param area NFP CPP area handle 496 * @param offset offset into NFP CPP area handle 497 * @param value output value 498 * 499 * The area must be acquired with 'nfp_cpp_area_acquire()' before calling this 500 * operation. 501 * 502 * NOTE: offset must be 32-bit aligned. 503 * 504 * @return 0 on success, or -1 on error (and set errno accordingly). 505 */ 506 int nfp_cpp_area_readl(struct nfp_cpp_area *area, unsigned long offset, 507 uint32_t *value); 508 509 /* 510 * Write a single 32-bit value to a NFP CPP area handle 511 * 512 * @param area NFP CPP area handle 513 * @param offset offset into NFP CPP area handle 514 * @param value value to write 515 * 516 * The area must be acquired with 'nfp_cpp_area_acquire()' before calling this 517 * operation. 518 * 519 * NOTE: offset must be 32-bit aligned. 520 * 521 * @return 0 on success, or -1 on error (and set errno accordingly). 522 */ 523 int nfp_cpp_area_writel(struct nfp_cpp_area *area, unsigned long offset, 524 uint32_t value); 525 526 /* 527 * Read a single 64-bit value from a NFP CPP area handle 528 * 529 * @param area NFP CPP area handle 530 * @param offset offset into NFP CPP area handle 531 * @param value output value 532 * 533 * The area must be acquired with 'nfp_cpp_area_acquire()' before calling this 534 * operation. 535 * 536 * NOTE: offset must be 64-bit aligned. 537 * 538 * @return 0 on success, or -1 on error (and set errno accordingly). 539 */ 540 int nfp_cpp_area_readq(struct nfp_cpp_area *area, unsigned long offset, 541 uint64_t *value); 542 543 /* 544 * Write a single 64-bit value to a NFP CPP area handle 545 * 546 * @param area NFP CPP area handle 547 * @param offset offset into NFP CPP area handle 548 * @param value value to write 549 * 550 * The area must be acquired with 'nfp_cpp_area_acquire()' before calling this 551 * operation. 552 * 553 * NOTE: offset must be 64-bit aligned. 554 * 555 * @return 0 on success, or -1 on error (and set errno accordingly). 556 */ 557 int nfp_cpp_area_writeq(struct nfp_cpp_area *area, unsigned long offset, 558 uint64_t value); 559 560 /* 561 * Write a single 32-bit value on the XPB bus 562 * 563 * @param cpp NFP CPP device handle 564 * @param xpb_tgt XPB target and address 565 * @param value value to write 566 * 567 * @return 0 on success, or -1 on failure (and set errno accordingly). 568 */ 569 int nfp_xpb_writel(struct nfp_cpp *cpp, uint32_t xpb_tgt, uint32_t value); 570 571 /* 572 * Read a single 32-bit value from the XPB bus 573 * 574 * @param cpp NFP CPP device handle 575 * @param xpb_tgt XPB target and address 576 * @param value output value 577 * 578 * @return 0 on success, or -1 on failure (and set errno accordingly). 579 */ 580 int nfp_xpb_readl(struct nfp_cpp *cpp, uint32_t xpb_tgt, uint32_t *value); 581 582 /* 583 * Modify bits of a 32-bit value from the XPB bus 584 * 585 * @param cpp NFP CPP device handle 586 * @param xpb_tgt XPB target and address 587 * @param mask mask of bits to alter 588 * @param value value to modify 589 * 590 * @return 0 on success, or -1 on failure (and set errno accordingly). 591 */ 592 int nfp_xpb_writelm(struct nfp_cpp *cpp, uint32_t xpb_tgt, uint32_t mask, 593 uint32_t value); 594 595 /* 596 * Modify bits of a 32-bit value from the XPB bus 597 * 598 * @param cpp NFP CPP device handle 599 * @param xpb_tgt XPB target and address 600 * @param mask mask of bits to alter 601 * @param value value to monitor for 602 * @param timeout_us maximum number of us to wait (-1 for forever) 603 * 604 * @return >= 0 on success, or -1 on failure (and set errno accordingly). 605 */ 606 int nfp_xpb_waitlm(struct nfp_cpp *cpp, uint32_t xpb_tgt, uint32_t mask, 607 uint32_t value, int timeout_us); 608 609 /* 610 * Read a 32-bit word from a NFP CPP ID 611 * 612 * @param cpp NFP CPP handle 613 * @param cpp_id NFP CPP ID 614 * @param address offset into the NFP CPP ID address space 615 * @param value output value 616 * 617 * @return 0 on success, or -1 on failure (and set errno accordingly). 618 */ 619 int nfp_cpp_readl(struct nfp_cpp *cpp, uint32_t cpp_id, 620 unsigned long long address, uint32_t *value); 621 622 /* 623 * Write a 32-bit value to a NFP CPP ID 624 * 625 * @param cpp NFP CPP handle 626 * @param cpp_id NFP CPP ID 627 * @param address offset into the NFP CPP ID address space 628 * @param value value to write 629 * 630 * @return 0 on success, or -1 on failure (and set errno accordingly). 631 * 632 */ 633 int nfp_cpp_writel(struct nfp_cpp *cpp, uint32_t cpp_id, 634 unsigned long long address, uint32_t value); 635 636 /* 637 * Read a 64-bit work from a NFP CPP ID 638 * 639 * @param cpp NFP CPP handle 640 * @param cpp_id NFP CPP ID 641 * @param address offset into the NFP CPP ID address space 642 * @param value output value 643 * 644 * @return 0 on success, or -1 on failure (and set errno accordingly). 645 */ 646 int nfp_cpp_readq(struct nfp_cpp *cpp, uint32_t cpp_id, 647 unsigned long long address, uint64_t *value); 648 649 /* 650 * Write a 64-bit value to a NFP CPP ID 651 * 652 * @param cpp NFP CPP handle 653 * @param cpp_id NFP CPP ID 654 * @param address offset into the NFP CPP ID address space 655 * @param value value to write 656 * 657 * @return 0 on success, or -1 on failure (and set errno accordingly). 658 */ 659 int nfp_cpp_writeq(struct nfp_cpp *cpp, uint32_t cpp_id, 660 unsigned long long address, uint64_t value); 661 662 /* 663 * Initialize a mutex location 664 665 * The CPP target:address must point to a 64-bit aligned location, and will 666 * initialize 64 bits of data at the location. 667 * 668 * This creates the initial mutex state, as locked by this nfp_cpp_interface(). 669 * 670 * This function should only be called when setting up the initial lock state 671 * upon boot-up of the system. 672 * 673 * @param cpp NFP CPP handle 674 * @param target NFP CPP target ID 675 * @param address Offset into the address space of the NFP CPP target ID 676 * @param key_id Unique 32-bit value for this mutex 677 * 678 * @return 0 on success, or -1 on failure (and set errno accordingly). 679 */ 680 int nfp_cpp_mutex_init(struct nfp_cpp *cpp, int target, 681 unsigned long long address, uint32_t key_id); 682 683 /* 684 * Create a mutex handle from an address controlled by a MU Atomic engine 685 * 686 * The CPP target:address must point to a 64-bit aligned location, and reserve 687 * 64 bits of data at the location for use by the handle. 688 * 689 * Only target/address pairs that point to entities that support the MU Atomic 690 * Engine's CmpAndSwap32 command are supported. 691 * 692 * @param cpp NFP CPP handle 693 * @param target NFP CPP target ID 694 * @param address Offset into the address space of the NFP CPP target ID 695 * @param key_id 32-bit unique key (must match the key at this location) 696 * 697 * @return A non-NULL struct nfp_cpp_mutex * on success, NULL on 698 * failure. 699 */ 700 struct nfp_cpp_mutex *nfp_cpp_mutex_alloc(struct nfp_cpp *cpp, int target, 701 unsigned long long address, 702 uint32_t key_id); 703 704 /* 705 * Get the NFP CPP handle the mutex was created with 706 * 707 * @param mutex NFP mutex handle 708 * @return NFP CPP handle 709 */ 710 struct nfp_cpp *nfp_cpp_mutex_cpp(struct nfp_cpp_mutex *mutex); 711 712 /* 713 * Get the mutex key 714 * 715 * @param mutex NFP mutex handle 716 * @return Mutex key 717 */ 718 uint32_t nfp_cpp_mutex_key(struct nfp_cpp_mutex *mutex); 719 720 /* 721 * Get the mutex owner 722 * 723 * @param mutex NFP mutex handle 724 * @return Interface ID of the mutex owner 725 * 726 * NOTE: This is for debug purposes ONLY - the owner may change at any time, 727 * unless it has been locked by this NFP CPP handle. 728 */ 729 uint16_t nfp_cpp_mutex_owner(struct nfp_cpp_mutex *mutex); 730 731 /* 732 * Get the mutex target 733 * 734 * @param mutex NFP mutex handle 735 * @return Mutex CPP target (ie NFP_CPP_TARGET_MU) 736 */ 737 int nfp_cpp_mutex_target(struct nfp_cpp_mutex *mutex); 738 739 /* 740 * Get the mutex address 741 * 742 * @param mutex NFP mutex handle 743 * @return Mutex CPP address 744 */ 745 uint64_t nfp_cpp_mutex_address(struct nfp_cpp_mutex *mutex); 746 747 /* 748 * Free a mutex handle - does not alter the lock state 749 * 750 * @param mutex NFP CPP Mutex handle 751 */ 752 void nfp_cpp_mutex_free(struct nfp_cpp_mutex *mutex); 753 754 /* 755 * Lock a mutex handle, using the NFP MU Atomic Engine 756 * 757 * @param mutex NFP CPP Mutex handle 758 * 759 * @return 0 on success, or -1 on failure (and set errno accordingly). 760 */ 761 int nfp_cpp_mutex_lock(struct nfp_cpp_mutex *mutex); 762 763 /* 764 * Unlock a mutex handle, using the NFP MU Atomic Engine 765 * 766 * @param mutex NFP CPP Mutex handle 767 * 768 * @return 0 on success, or -1 on failure (and set errno accordingly). 769 */ 770 int nfp_cpp_mutex_unlock(struct nfp_cpp_mutex *mutex); 771 772 /* 773 * Attempt to lock a mutex handle, using the NFP MU Atomic Engine 774 * 775 * @param mutex NFP CPP Mutex handle 776 * @return 0 if the lock succeeded, -1 on failure (and errno set 777 * appropriately). 778 */ 779 int nfp_cpp_mutex_trylock(struct nfp_cpp_mutex *mutex); 780 781 #endif /* !__NFP_CPP_H__ */ 782