arch/mips/include/asm/octeon/cvmx-pow.h

   1 /***********************license start***************
   2  * Author: Cavium Networks
   3  *
   4  * Contact: support@caviumnetworks.com
   5  * This file is part of the OCTEON SDK
   6  *
   7  * Copyright (c) 2003-2008 Cavium Networks
   8  *
   9  * This file is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License, Version 2, as
  11  * published by the Free Software Foundation.
  12  *
  13  * This file is distributed in the hope that it will be useful, but
  14  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  15  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  16  * NONINFRINGEMENT.  See the GNU General Public License for more
  17  * details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this file; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  22  * or visit http://www.gnu.org/licenses/.
  23  *
  24  * This file may also be available under a different license from Cavium.
  25  * Contact Cavium Networks for more information
  26  ***********************license end**************************************/
  27
  28 /**
  29  * Interface to the hardware Packet Order / Work unit.
  30  *
  31  * New, starting with SDK 1.7.0, cvmx-pow supports a number of
  32  * extended consistency checks. The define
  33  * CVMX_ENABLE_POW_CHECKS controls the runtime insertion of POW
  34  * internal state checks to find common programming errors. If
  35  * CVMX_ENABLE_POW_CHECKS is not defined, checks are by default
  36  * enabled. For example, cvmx-pow will check for the following
  37  * program errors or POW state inconsistency.
  38  * - Requesting a POW operation with an active tag switch in
  39  *   progress.
  40  * - Waiting for a tag switch to complete for an excessively
  41  *   long period. This is normally a sign of an error in locking
  42  *   causing deadlock.
  43  * - Illegal tag switches from NULL_NULL.
  44  * - Illegal tag switches from NULL.
  45  * - Illegal deschedule request.
  46  * - WQE pointer not matching the one attached to the core by
  47  *   the POW.
  48  *
  49  */
  50
  51 #ifndef __CVMX_POW_H__
  52 #define __CVMX_POW_H__
  53
  54 #include <asm/octeon/cvmx-pow-defs.h>
  55
  56 #include <asm/octeon/cvmx-scratch.h>
  57 #include <asm/octeon/cvmx-wqe.h>
  58
  59 /* Default to having all POW constancy checks turned on */
  60 #ifndef CVMX_ENABLE_POW_CHECKS
  61 #define CVMX_ENABLE_POW_CHECKS 1
  62 #endif
  63
  64 enum cvmx_pow_tag_type {
  65         /* Tag ordering is maintained */
  66         CVMX_POW_TAG_TYPE_ORDERED   = 0L,
  67         /* Tag ordering is maintained, and at most one PP has the tag */
  68         CVMX_POW_TAG_TYPE_ATOMIC    = 1L,
  69         /*
  70          * The work queue entry from the order - NEVER tag switch from
  71          * NULL to NULL
  72          */
  73         CVMX_POW_TAG_TYPE_NULL      = 2L,
  74         /* A tag switch to NULL, and there is no space reserved in POW
  75          * - NEVER tag switch to NULL_NULL
  76          * - NEVER tag switch from NULL_NULL
  77          * - NULL_NULL is entered at the beginning of time and on a deschedule.
  78          * - NULL_NULL can be exited by a new work request. A NULL_SWITCH
  79          * load can also switch the state to NULL
  80          */
  81         CVMX_POW_TAG_TYPE_NULL_NULL = 3L
  82 };
  83
  84 /**
  85  * Wait flag values for pow functions.
  86  */
  87 typedef enum {
  88         CVMX_POW_WAIT = 1,
  89         CVMX_POW_NO_WAIT = 0,
  90 } cvmx_pow_wait_t;
  91
  92 /**
  93  *  POW tag operations.  These are used in the data stored to the POW.
  94  */
  95 typedef enum {
  96         /*
  97          * switch the tag (only) for this PP
  98          * - the previous tag should be non-NULL in this case
  99          * - tag switch response required
 100          * - fields used: op, type, tag
 101          */
 102         CVMX_POW_TAG_OP_SWTAG = 0L,
 103         /*
 104          * switch the tag for this PP, with full information
 105          * - this should be used when the previous tag is NULL
 106          * - tag switch response required
 107          * - fields used: address, op, grp, type, tag
 108          */
 109         CVMX_POW_TAG_OP_SWTAG_FULL = 1L,
 110         /*
 111          * switch the tag (and/or group) for this PP and de-schedule
 112          * - OK to keep the tag the same and only change the group
 113          * - fields used: op, no_sched, grp, type, tag
 114          */
 115         CVMX_POW_TAG_OP_SWTAG_DESCH = 2L,
 116         /*
 117          * just de-schedule
 118          * - fields used: op, no_sched
 119          */
 120         CVMX_POW_TAG_OP_DESCH = 3L,
 121         /*
 122          * create an entirely new work queue entry
 123          * - fields used: address, op, qos, grp, type, tag
 124          */
 125         CVMX_POW_TAG_OP_ADDWQ = 4L,
 126         /*
 127          * just update the work queue pointer and grp for this PP
 128          * - fields used: address, op, grp
 129          */
 130         CVMX_POW_TAG_OP_UPDATE_WQP_GRP = 5L,
 131         /*
 132          * set the no_sched bit on the de-schedule list
 133          *
 134          * - does nothing if the selected entry is not on the
 135          *   de-schedule list
 136          *
 137          * - does nothing if the stored work queue pointer does not
 138          *   match the address field
 139          *
 140          * - fields used: address, index, op
 141          *
 142          *  Before issuing a *_NSCHED operation, SW must guarantee
 143          *  that all prior deschedules and set/clr NSCHED operations
 144          *  are complete and all prior switches are complete. The
 145          *  hardware provides the opsdone bit and swdone bit for SW
 146          *  polling. After issuing a *_NSCHED operation, SW must
 147          *  guarantee that the set/clr NSCHED is complete before any
 148          *  subsequent operations.
 149          */
 150         CVMX_POW_TAG_OP_SET_NSCHED = 6L,
 151         /*
 152          * clears the no_sched bit on the de-schedule list
 153          *
 154          * - does nothing if the selected entry is not on the
 155          *   de-schedule list
 156          *
 157          * - does nothing if the stored work queue pointer does not
 158          *   match the address field
 159          *
 160          * - fields used: address, index, op
 161          *
 162          * Before issuing a *_NSCHED operation, SW must guarantee that
 163          * all prior deschedules and set/clr NSCHED operations are
 164          * complete and all prior switches are complete. The hardware
 165          * provides the opsdone bit and swdone bit for SW
 166          * polling. After issuing a *_NSCHED operation, SW must
 167          * guarantee that the set/clr NSCHED is complete before any
 168          * subsequent operations.
 169          */
 170         CVMX_POW_TAG_OP_CLR_NSCHED = 7L,
 171         /* do nothing */
 172         CVMX_POW_TAG_OP_NOP = 15L
 173 } cvmx_pow_tag_op_t;
 174
 175 /**
 176  * This structure defines the store data on a store to POW
 177  */
 178 typedef union {
 179         uint64_t u64;
 180         struct {
 181                 /*
 182                  * Don't reschedule this entry. no_sched is used for
 183                  * CVMX_POW_TAG_OP_SWTAG_DESCH and
 184                  * CVMX_POW_TAG_OP_DESCH
 185                  */
 186                 uint64_t no_sched:1;
 187                 uint64_t unused:2;
 188                 /* Tontains index of entry for a CVMX_POW_TAG_OP_*_NSCHED */
 189                 uint64_t index:13;
 190                 /* The operation to perform */
 191                 cvmx_pow_tag_op_t op:4;
 192                 uint64_t unused2:2;
 193                 /*
 194                  * The QOS level for the packet. qos is only used for
 195                  * CVMX_POW_TAG_OP_ADDWQ
 196                  */
 197                 uint64_t qos:3;
 198                 /*
 199                  * The group that the work queue entry will be
 200                  * scheduled to grp is used for CVMX_POW_TAG_OP_ADDWQ,
 201                  * CVMX_POW_TAG_OP_SWTAG_FULL,
 202                  * CVMX_POW_TAG_OP_SWTAG_DESCH, and
 203                  * CVMX_POW_TAG_OP_UPDATE_WQP_GRP
 204                  */
 205                 uint64_t grp:4;
 206                 /*
 207                  * The type of the tag. type is used for everything
 208                  * except CVMX_POW_TAG_OP_DESCH,
 209                  * CVMX_POW_TAG_OP_UPDATE_WQP_GRP, and
 210                  * CVMX_POW_TAG_OP_*_NSCHED
 211                  */
 212                 uint64_t type:3;
 213                 /*
 214                  * The actual tag. tag is used for everything except
 215                  * CVMX_POW_TAG_OP_DESCH,
 216                  * CVMX_POW_TAG_OP_UPDATE_WQP_GRP, and
 217                  * CVMX_POW_TAG_OP_*_NSCHED
 218                  */
 219                 uint64_t tag:32;
 220         } s;
 221 } cvmx_pow_tag_req_t;
 222
 223 /**
 224  * This structure describes the address to load stuff from POW
 225  */
 226 typedef union {
 227         uint64_t u64;
 228
 229     /**
 230      * Address for new work request loads (did<2:0> == 0)
 231      */
 232         struct {
 233                 /* Mips64 address region. Should be CVMX_IO_SEG */
 234                 uint64_t mem_region:2;
 235                 /* Must be zero */
 236                 uint64_t reserved_49_61:13;
 237                 /* Must be one */
 238                 uint64_t is_io:1;
 239                 /* the ID of POW -- did<2:0> == 0 in this case */
 240                 uint64_t did:8;
 241                 /* Must be zero */
 242                 uint64_t reserved_4_39:36;
 243                 /*
 244                  * If set, don't return load response until work is
 245                  * available.
 246                  */
 247                 uint64_t wait:1;
 248                 /* Must be zero */
 249                 uint64_t reserved_0_2:3;
 250         } swork;
 251
 252     /**
 253      * Address for loads to get POW internal status
 254      */
 255         struct {
 256                 /* Mips64 address region. Should be CVMX_IO_SEG */
 257                 uint64_t mem_region:2;
 258                 /* Must be zero */
 259                 uint64_t reserved_49_61:13;
 260                 /* Must be one */
 261                 uint64_t is_io:1;
 262                 /* the ID of POW -- did<2:0> == 1 in this case */
 263                 uint64_t did:8;
 264                 /* Must be zero */
 265                 uint64_t reserved_10_39:30;
 266                 /* The core id to get status for */
 267                 uint64_t coreid:4;
 268                 /*
 269                  * If set and get_cur is set, return reverse tag-list
 270                  * pointer rather than forward tag-list pointer.
 271                  */
 272                 uint64_t get_rev:1;
 273                 /*
 274                  * If set, return current status rather than pending
 275                  * status.
 276                  */
 277                 uint64_t get_cur:1;
 278                 /*
 279                  * If set, get the work-queue pointer rather than
 280                  * tag/type.
 281                  */
 282                 uint64_t get_wqp:1;
 283                 /* Must be zero */
 284                 uint64_t reserved_0_2:3;
 285         } sstatus;
 286
 287     /**
 288      * Address for memory loads to get POW internal state
 289      */
 290         struct {
 291                 /* Mips64 address region. Should be CVMX_IO_SEG */
 292                 uint64_t mem_region:2;
 293                 /* Must be zero */
 294                 uint64_t reserved_49_61:13;
 295                 /* Must be one */
 296                 uint64_t is_io:1;
 297                 /* the ID of POW -- did<2:0> == 2 in this case */
 298                 uint64_t did:8;
 299                 /* Must be zero */
 300                 uint64_t reserved_16_39:24;
 301                 /* POW memory index */
 302                 uint64_t index:11;
 303                 /*
 304                  * If set, return deschedule information rather than
 305                  * the standard response for work-queue index (invalid
 306                  * if the work-queue entry is not on the deschedule
 307                  * list).
 308                  */
 309                 uint64_t get_des:1;
 310                 /*
 311                  * If set, get the work-queue pointer rather than
 312                  * tag/type (no effect when get_des set).
 313                  */
 314                 uint64_t get_wqp:1;
 315                 /* Must be zero */
 316                 uint64_t reserved_0_2:3;
 317         } smemload;
 318
 319     /**
 320      * Address for index/pointer loads
 321      */
 322         struct {
 323                 /* Mips64 address region. Should be CVMX_IO_SEG */
 324                 uint64_t mem_region:2;
 325                 /* Must be zero */
 326                 uint64_t reserved_49_61:13;
 327                 /* Must be one */
 328                 uint64_t is_io:1;
 329                 /* the ID of POW -- did<2:0> == 3 in this case */
 330                 uint64_t did:8;
 331                 /* Must be zero */
 332                 uint64_t reserved_9_39:31;
 333                 /*
 334                  * when {get_rmt ==0 AND get_des_get_tail == 0}, this
 335                  * field selects one of eight POW internal-input
 336                  * queues (0-7), one per QOS level; values 8-15 are
 337                  * illegal in this case; when {get_rmt ==0 AND
 338                  * get_des_get_tail == 1}, this field selects one of
 339                  * 16 deschedule lists (per group); when get_rmt ==1,
 340                  * this field selects one of 16 memory-input queue
 341                  * lists.  The two memory-input queue lists associated
 342                  * with each QOS level are:
 343                  *
 344                  * - qosgrp = 0, qosgrp = 8:      QOS0
 345                  * - qosgrp = 1, qosgrp = 9:      QOS1
 346                  * - qosgrp = 2, qosgrp = 10:     QOS2
 347                  * - qosgrp = 3, qosgrp = 11:     QOS3
 348                  * - qosgrp = 4, qosgrp = 12:     QOS4
 349                  * - qosgrp = 5, qosgrp = 13:     QOS5
 350                  * - qosgrp = 6, qosgrp = 14:     QOS6
 351                  * - qosgrp = 7, qosgrp = 15:     QOS7
 352                  */
 353                 uint64_t qosgrp:4;
 354                 /*
 355                  * If set and get_rmt is clear, return deschedule list
 356                  * indexes rather than indexes for the specified qos
 357                  * level; if set and get_rmt is set, return the tail
 358                  * pointer rather than the head pointer for the
 359                  * specified qos level.
 360                  */
 361                 uint64_t get_des_get_tail:1;
 362                 /*
 363                  * If set, return remote pointers rather than the
 364                  * local indexes for the specified qos level.
 365                  */
 366                 uint64_t get_rmt:1;
 367                 /* Must be zero */
 368                 uint64_t reserved_0_2:3;
 369         } sindexload;
 370
 371     /**
 372      * address for NULL_RD request (did<2:0> == 4) when this is read,
 373      * HW attempts to change the state to NULL if it is NULL_NULL (the
 374      * hardware cannot switch from NULL_NULL to NULL if a POW entry is
 375      * not available - software may need to recover by finishing
 376      * another piece of work before a POW entry can ever become
 377      * available.)
 378      */
 379         struct {
 380                 /* Mips64 address region. Should be CVMX_IO_SEG */
 381                 uint64_t mem_region:2;
 382                 /* Must be zero */
 383                 uint64_t reserved_49_61:13;
 384                 /* Must be one */
 385                 uint64_t is_io:1;
 386                 /* the ID of POW -- did<2:0> == 4 in this case */
 387                 uint64_t did:8;
 388                 /* Must be zero */
 389                 uint64_t reserved_0_39:40;
 390         } snull_rd;
 391 } cvmx_pow_load_addr_t;
 392
 393 /**
 394  * This structure defines the response to a load/SENDSINGLE to POW
 395  * (except CSR reads)
 396  */
 397 typedef union {
 398         uint64_t u64;
 399
 400     /**
 401      * Response to new work request loads
 402      */
 403         struct {
 404                 /*
 405                  * Set when no new work queue entry was returned.  *
 406                  * If there was de-scheduled work, the HW will
 407                  * definitely return it. When this bit is set, it
 408                  * could mean either mean:
 409                  *
 410                  * - There was no work, or
 411                  *
 412                  * - There was no work that the HW could find. This
 413                  *   case can happen, regardless of the wait bit value
 414                  *   in the original request, when there is work in
 415                  *   the IQ's that is too deep down the list.
 416                  */
 417                 uint64_t no_work:1;
 418                 /* Must be zero */
 419                 uint64_t reserved_40_62:23;
 420                 /* 36 in O1 -- the work queue pointer */
 421                 uint64_t addr:40;
 422         } s_work;
 423
 424     /**
 425      * Result for a POW Status Load (when get_cur==0 and get_wqp==0)
 426      */
 427         struct {
 428                 uint64_t reserved_62_63:2;
 429                 /* Set when there is a pending non-NULL SWTAG or
 430                  * SWTAG_FULL, and the POW entry has not left the list
 431                  * for the original tag. */
 432                 uint64_t pend_switch:1;
 433                 /* Set when SWTAG_FULL and pend_switch is set. */
 434                 uint64_t pend_switch_full:1;
 435                 /*
 436                  * Set when there is a pending NULL SWTAG, or an
 437                  * implicit switch to NULL.
 438                  */
 439                 uint64_t pend_switch_null:1;
 440                 /* Set when there is a pending DESCHED or SWTAG_DESCHED. */
 441                 uint64_t pend_desched:1;
 442                 /*
 443                  * Set when there is a pending SWTAG_DESCHED and
 444                  * pend_desched is set.
 445                  */
 446                 uint64_t pend_desched_switch:1;
 447                 /* Set when nosched is desired and pend_desched is set. */
 448                 uint64_t pend_nosched:1;
 449                 /* Set when there is a pending GET_WORK. */
 450                 uint64_t pend_new_work:1;
 451                 /*
 452                  * When pend_new_work is set, this bit indicates that
 453                  * the wait bit was set.
 454                  */
 455                 uint64_t pend_new_work_wait:1;
 456                 /* Set when there is a pending NULL_RD. */
 457                 uint64_t pend_null_rd:1;
 458                 /* Set when there is a pending CLR_NSCHED. */
 459                 uint64_t pend_nosched_clr:1;
 460                 uint64_t reserved_51:1;
 461                 /* This is the index when pend_nosched_clr is set. */
 462                 uint64_t pend_index:11;
 463                 /*
 464                  * This is the new_grp when (pend_desched AND
 465                  * pend_desched_switch) is set.
 466                  */
 467                 uint64_t pend_grp:4;
 468                 uint64_t reserved_34_35:2;
 469                 /*
 470                  * This is the tag type when pend_switch or
 471                  * (pend_desched AND pend_desched_switch) are set.
 472                  */
 473                 uint64_t pend_type:2;
 474                 /*
 475                  * - this is the tag when pend_switch or (pend_desched
 476                  *    AND pend_desched_switch) are set.
 477                  */
 478                 uint64_t pend_tag:32;
 479         } s_sstatus0;
 480
 481     /**
 482      * Result for a POW Status Load (when get_cur==0 and get_wqp==1)
 483      */
 484         struct {
 485                 uint64_t reserved_62_63:2;
 486                 /*
 487                  * Set when there is a pending non-NULL SWTAG or
 488                  * SWTAG_FULL, and the POW entry has not left the list
 489                  * for the original tag.
 490                  */
 491                 uint64_t pend_switch:1;
 492                 /* Set when SWTAG_FULL and pend_switch is set. */
 493                 uint64_t pend_switch_full:1;
 494                 /*
 495                  * Set when there is a pending NULL SWTAG, or an
 496                  * implicit switch to NULL.
 497                  */
 498                 uint64_t pend_switch_null:1;
 499                 /*
 500                  * Set when there is a pending DESCHED or
 501                  * SWTAG_DESCHED.
 502                  */
 503                 uint64_t pend_desched:1;
 504                 /*
 505                  * Set when there is a pending SWTAG_DESCHED and
 506                  * pend_desched is set.
 507                  */
 508                 uint64_t pend_desched_switch:1;
 509                 /* Set when nosched is desired and pend_desched is set. */
 510                 uint64_t pend_nosched:1;
 511                 /* Set when there is a pending GET_WORK. */
 512                 uint64_t pend_new_work:1;
 513                 /*
 514                  * When pend_new_work is set, this bit indicates that
 515                  * the wait bit was set.
 516                  */
 517                 uint64_t pend_new_work_wait:1;
 518                 /* Set when there is a pending NULL_RD. */
 519                 uint64_t pend_null_rd:1;
 520                 /* Set when there is a pending CLR_NSCHED. */
 521                 uint64_t pend_nosched_clr:1;
 522                 uint64_t reserved_51:1;
 523                 /* This is the index when pend_nosched_clr is set. */
 524                 uint64_t pend_index:11;
 525                 /*
 526                  * This is the new_grp when (pend_desched AND
 527                  * pend_desched_switch) is set.
 528                  */
 529                 uint64_t pend_grp:4;
 530                 /* This is the wqp when pend_nosched_clr is set. */
 531                 uint64_t pend_wqp:36;
 532         } s_sstatus1;
 533
 534     /**
 535      * Result for a POW Status Load (when get_cur==1, get_wqp==0, and
 536      * get_rev==0)
 537      */
 538         struct {
 539                 uint64_t reserved_62_63:2;
 540                 /*
 541                  * Points to the next POW entry in the tag list when
 542                  * tail == 0 (and tag_type is not NULL or NULL_NULL).
 543                  */
 544                 uint64_t link_index:11;
 545                 /* The POW entry attached to the core. */
 546                 uint64_t index:11;
 547                 /*
 548                  * The group attached to the core (updated when new
 549                  * tag list entered on SWTAG_FULL).
 550                  */
 551                 uint64_t grp:4;
 552                 /*
 553                  * Set when this POW entry is at the head of its tag
 554                  * list (also set when in the NULL or NULL_NULL
 555                  * state).
 556                  */
 557                 uint64_t head:1;
 558                 /*
 559                  * Set when this POW entry is at the tail of its tag
 560                  * list (also set when in the NULL or NULL_NULL
 561                  * state).
 562                  */
 563                 uint64_t tail:1;
 564                 /*
 565                  * The tag type attached to the core (updated when new
 566                  * tag list entered on SWTAG, SWTAG_FULL, or
 567                  * SWTAG_DESCHED).
 568                  */
 569                 uint64_t tag_type:2;
 570                 /*
 571                  * The tag attached to the core (updated when new tag
 572                  * list entered on SWTAG, SWTAG_FULL, or
 573                  * SWTAG_DESCHED).
 574                  */
 575                 uint64_t tag:32;
 576         } s_sstatus2;
 577
 578     /**
 579      * Result for a POW Status Load (when get_cur==1, get_wqp==0, and get_rev==1)
 580      */
 581         struct {
 582                 uint64_t reserved_62_63:2;
 583                 /*
 584                  * Points to the prior POW entry in the tag list when
 585                  * head == 0 (and tag_type is not NULL or
 586                  * NULL_NULL). This field is unpredictable when the
 587                  * core's state is NULL or NULL_NULL.
 588                  */
 589                 uint64_t revlink_index:11;
 590                 /* The POW entry attached to the core. */
 591                 uint64_t index:11;
 592                 /*
 593                  * The group attached to the core (updated when new
 594                  * tag list entered on SWTAG_FULL).
 595                  */
 596                 uint64_t grp:4;
 597                 /* Set when this POW entry is at the head of its tag
 598                  * list (also set when in the NULL or NULL_NULL
 599                  * state).
 600                  */
 601                 uint64_t head:1;
 602                 /*
 603                  * Set when this POW entry is at the tail of its tag
 604                  * list (also set when in the NULL or NULL_NULL
 605                  * state).
 606                  */
 607                 uint64_t tail:1;
 608                 /*
 609                  * The tag type attached to the core (updated when new
 610                  * tag list entered on SWTAG, SWTAG_FULL, or
 611                  * SWTAG_DESCHED).
 612                  */
 613                 uint64_t tag_type:2;
 614                 /*
 615                  * The tag attached to the core (updated when new tag
 616                  * list entered on SWTAG, SWTAG_FULL, or
 617                  * SWTAG_DESCHED).
 618                  */
 619                 uint64_t tag:32;
 620         } s_sstatus3;
 621
 622     /**
 623      * Result for a POW Status Load (when get_cur==1, get_wqp==1, and
 624      * get_rev==0)
 625      */
 626         struct {
 627                 uint64_t reserved_62_63:2;
 628                 /*
 629                  * Points to the next POW entry in the tag list when
 630                  * tail == 0 (and tag_type is not NULL or NULL_NULL).
 631                  */
 632                 uint64_t link_index:11;
 633                 /* The POW entry attached to the core. */
 634                 uint64_t index:11;
 635                 /*
 636                  * The group attached to the core (updated when new
 637                  * tag list entered on SWTAG_FULL).
 638                  */
 639                 uint64_t grp:4;
 640                 /*
 641                  * The wqp attached to the core (updated when new tag
 642                  * list entered on SWTAG_FULL).
 643                  */
 644                 uint64_t wqp:36;
 645         } s_sstatus4;
 646
 647     /**
 648      * Result for a POW Status Load (when get_cur==1, get_wqp==1, and
 649      * get_rev==1)
 650      */
 651         struct {
 652                 uint64_t reserved_62_63:2;
 653                 /*
 654                  * Points to the prior POW entry in the tag list when
 655                  * head == 0 (and tag_type is not NULL or
 656                  * NULL_NULL). This field is unpredictable when the
 657                  * core's state is NULL or NULL_NULL.
 658                  */
 659                 uint64_t revlink_index:11;
 660                 /* The POW entry attached to the core. */
 661                 uint64_t index:11;
 662                 /*
 663                  * The group attached to the core (updated when new
 664                  * tag list entered on SWTAG_FULL).
 665                  */
 666                 uint64_t grp:4;
 667                 /*
 668                  * The wqp attached to the core (updated when new tag
 669                  * list entered on SWTAG_FULL).
 670                  */
 671                 uint64_t wqp:36;
 672         } s_sstatus5;
 673
 674     /**
 675      * Result For POW Memory Load (get_des == 0 and get_wqp == 0)
 676      */
 677         struct {
 678                 uint64_t reserved_51_63:13;
 679                 /*
 680                  * The next entry in the input, free, descheduled_head
 681                  * list (unpredictable if entry is the tail of the
 682                  * list).
 683                  */
 684                 uint64_t next_index:11;
 685                 /* The group of the POW entry. */
 686                 uint64_t grp:4;
 687                 uint64_t reserved_35:1;
 688                 /*
 689                  * Set when this POW entry is at the tail of its tag
 690                  * list (also set when in the NULL or NULL_NULL
 691                  * state).
 692                  */
 693                 uint64_t tail:1;
 694                 /* The tag type of the POW entry. */
 695                 uint64_t tag_type:2;
 696                 /* The tag of the POW entry. */
 697                 uint64_t tag:32;
 698         } s_smemload0;
 699
 700     /**
 701      * Result For POW Memory Load (get_des == 0 and get_wqp == 1)
 702      */
 703         struct {
 704                 uint64_t reserved_51_63:13;
 705                 /*
 706                  * The next entry in the input, free, descheduled_head
 707                  * list (unpredictable if entry is the tail of the
 708                  * list).
 709                  */
 710                 uint64_t next_index:11;
 711                 /* The group of the POW entry. */
 712                 uint64_t grp:4;
 713                 /* The WQP held in the POW entry. */
 714                 uint64_t wqp:36;
 715         } s_smemload1;
 716
 717     /**
 718      * Result For POW Memory Load (get_des == 1)
 719      */
 720         struct {
 721                 uint64_t reserved_51_63:13;
 722                 /*
 723                  * The next entry in the tag list connected to the
 724                  * descheduled head.
 725                  */
 726                 uint64_t fwd_index:11;
 727                 /* The group of the POW entry. */
 728                 uint64_t grp:4;
 729                 /* The nosched bit for the POW entry. */
 730                 uint64_t nosched:1;
 731                 /* There is a pending tag switch */
 732                 uint64_t pend_switch:1;
 733                 /*
 734                  * The next tag type for the new tag list when
 735                  * pend_switch is set.
 736                  */
 737                 uint64_t pend_type:2;
 738                 /*
 739                  * The next tag for the new tag list when pend_switch
 740                  * is set.
 741                  */
 742                 uint64_t pend_tag:32;
 743         } s_smemload2;
 744
 745     /**
 746      * Result For POW Index/Pointer Load (get_rmt == 0/get_des_get_tail == 0)
 747      */
 748         struct {
 749                 uint64_t reserved_52_63:12;
 750                 /*
 751                  * set when there is one or more POW entries on the
 752                  * free list.
 753                  */
 754                 uint64_t free_val:1;
 755                 /*
 756                  * set when there is exactly one POW entry on the free
 757                  * list.
 758                  */
 759                 uint64_t free_one:1;
 760                 uint64_t reserved_49:1;
 761                 /*
 762                  * when free_val is set, indicates the first entry on
 763                  * the free list.
 764                  */
 765                 uint64_t free_head:11;
 766                 uint64_t reserved_37:1;
 767                 /*
 768                  * when free_val is set, indicates the last entry on
 769                  * the free list.
 770                  */
 771                 uint64_t free_tail:11;
 772                 /*
 773                  * set when there is one or more POW entries on the
 774                  * input Q list selected by qosgrp.
 775                  */
 776                 uint64_t loc_val:1;
 777                 /*
 778                  * set when there is exactly one POW entry on the
 779                  * input Q list selected by qosgrp.
 780                  */
 781                 uint64_t loc_one:1;
 782                 uint64_t reserved_23:1;
 783                 /*
 784                  * when loc_val is set, indicates the first entry on
 785                  * the input Q list selected by qosgrp.
 786                  */
 787                 uint64_t loc_head:11;
 788                 uint64_t reserved_11:1;
 789                 /*
 790                  * when loc_val is set, indicates the last entry on
 791                  * the input Q list selected by qosgrp.
 792                  */
 793                 uint64_t loc_tail:11;
 794         } sindexload0;
 795
 796     /**
 797      * Result For POW Index/Pointer Load (get_rmt == 0/get_des_get_tail == 1)
 798      */
 799         struct {
 800                 uint64_t reserved_52_63:12;
 801                 /*
 802                  * set when there is one or more POW entries on the
 803                  * nosched list.
 804                  */
 805                 uint64_t nosched_val:1;
 806                 /*
 807                  * set when there is exactly one POW entry on the
 808                  * nosched list.
 809                  */
 810                 uint64_t nosched_one:1;
 811                 uint64_t reserved_49:1;
 812                 /*
 813                  * when nosched_val is set, indicates the first entry
 814                  * on the nosched list.
 815                  */
 816                 uint64_t nosched_head:11;
 817                 uint64_t reserved_37:1;
 818                 /*
 819                  * when nosched_val is set, indicates the last entry
 820                  * on the nosched list.
 821                  */
 822                 uint64_t nosched_tail:11;
 823                 /*
 824                  * set when there is one or more descheduled heads on
 825                  * the descheduled list selected by qosgrp.
 826                  */
 827                 uint64_t des_val:1;
 828                 /*
 829                  * set when there is exactly one descheduled head on
 830                  * the descheduled list selected by qosgrp.
 831                  */
 832                 uint64_t des_one:1;
 833                 uint64_t reserved_23:1;
 834                 /*
 835                  * when des_val is set, indicates the first
 836                  * descheduled head on the descheduled list selected
 837                  * by qosgrp.
 838                  */
 839                 uint64_t des_head:11;
 840                 uint64_t reserved_11:1;
 841                 /*
 842                  * when des_val is set, indicates the last descheduled
 843                  * head on the descheduled list selected by qosgrp.
 844                  */
 845                 uint64_t des_tail:11;
 846         } sindexload1;
 847
 848     /**
 849      * Result For POW Index/Pointer Load (get_rmt == 1/get_des_get_tail == 0)
 850      */
 851         struct {
 852                 uint64_t reserved_39_63:25;
 853                 /*
 854                  * Set when this DRAM list is the current head
 855                  * (i.e. is the next to be reloaded when the POW
 856                  * hardware reloads a POW entry from DRAM). The POW
 857                  * hardware alternates between the two DRAM lists
 858                  * associated with a QOS level when it reloads work
 859                  * from DRAM into the POW unit.
 860                  */
 861                 uint64_t rmt_is_head:1;
 862                 /*
 863                  * Set when the DRAM portion of the input Q list
 864                  * selected by qosgrp contains one or more pieces of
 865                  * work.
 866                  */
 867                 uint64_t rmt_val:1;
 868                 /*
 869                  * Set when the DRAM portion of the input Q list
 870                  * selected by qosgrp contains exactly one piece of
 871                  * work.
 872                  */
 873                 uint64_t rmt_one:1;
 874                 /*
 875                  * When rmt_val is set, indicates the first piece of
 876                  * work on the DRAM input Q list selected by
 877                  * qosgrp.
 878                  */
 879                 uint64_t rmt_head:36;
 880         } sindexload2;
 881
 882     /**
 883      * Result For POW Index/Pointer Load (get_rmt ==
 884      * 1/get_des_get_tail == 1)
 885      */
 886         struct {
 887                 uint64_t reserved_39_63:25;
 888                 /*
 889                  * set when this DRAM list is the current head
 890                  * (i.e. is the next to be reloaded when the POW
 891                  * hardware reloads a POW entry from DRAM). The POW
 892                  * hardware alternates between the two DRAM lists
 893                  * associated with a QOS level when it reloads work
 894                  * from DRAM into the POW unit.
 895                  */
 896                 uint64_t rmt_is_head:1;
 897                 /*
 898                  * set when the DRAM portion of the input Q list
 899                  * selected by qosgrp contains one or more pieces of
 900                  * work.
 901                  */
 902                 uint64_t rmt_val:1;
 903                 /*
 904                  * set when the DRAM portion of the input Q list
 905                  * selected by qosgrp contains exactly one piece of
 906                  * work.
 907                  */
 908                 uint64_t rmt_one:1;
 909                 /*
 910                  * when rmt_val is set, indicates the last piece of
 911                  * work on the DRAM input Q list selected by
 912                  * qosgrp.
 913                  */
 914                 uint64_t rmt_tail:36;
 915         } sindexload3;
 916
 917     /**
 918      * Response to NULL_RD request loads
 919      */
 920         struct {
 921                 uint64_t unused:62;
 922                 /* of type cvmx_pow_tag_type_t. state is one of the
 923                  * following:
 924                  *
 925                  * - CVMX_POW_TAG_TYPE_ORDERED
 926                  * - CVMX_POW_TAG_TYPE_ATOMIC
 927                  * - CVMX_POW_TAG_TYPE_NULL
 928                  * - CVMX_POW_TAG_TYPE_NULL_NULL
 929                  */
 930                 uint64_t state:2;
 931         } s_null_rd;
 932
 933 } cvmx_pow_tag_load_resp_t;
 934
 935 /**
 936  * This structure describes the address used for stores to the POW.
 937  *  The store address is meaningful on stores to the POW.  The
 938  *  hardware assumes that an aligned 64-bit store was used for all
 939  *  these stores.  Note the assumption that the work queue entry is
 940  *  aligned on an 8-byte boundary (since the low-order 3 address bits
 941  *  must be zero).  Note that not all fields are used by all
 942  *  operations.
 943  *
 944  *  NOTE: The following is the behavior of the pending switch bit at the PP
 945  *       for POW stores (i.e. when did<7:3> == 0xc)
 946  *     - did<2:0> == 0      => pending switch bit is set
 947  *     - did<2:0> == 1      => no affect on the pending switch bit
 948  *     - did<2:0> == 3      => pending switch bit is cleared
 949  *     - did<2:0> == 7      => no affect on the pending switch bit
 950  *     - did<2:0> == others => must not be used
 951  *     - No other loads/stores have an affect on the pending switch bit
 952  *     - The switch bus from POW can clear the pending switch bit
 953  *
 954  *  NOTE: did<2:0> == 2 is used by the HW for a special single-cycle
 955  *  ADDWQ command that only contains the pointer). SW must never use
 956  *  did<2:0> == 2.
 957  */
 958 typedef union {
 959     /**
 960      * Unsigned 64 bit integer representation of store address
 961      */
 962         uint64_t u64;
 963
 964         struct {
 965                 /* Memory region.  Should be CVMX_IO_SEG in most cases */
 966                 uint64_t mem_reg:2;
 967                 uint64_t reserved_49_61:13;     /* Must be zero */
 968                 uint64_t is_io:1;       /* Must be one */
 969                 /* Device ID of POW.  Note that different sub-dids are used. */
 970                 uint64_t did:8;
 971                 uint64_t reserved_36_39:4;      /* Must be zero */
 972                 /* Address field. addr<2:0> must be zero */
 973                 uint64_t addr:36;
 974         } stag;
 975 } cvmx_pow_tag_store_addr_t;
 976
 977 /**
 978  * decode of the store data when an IOBDMA SENDSINGLE is sent to POW
 979  */
 980 typedef union {
 981         uint64_t u64;
 982
 983         struct {
 984                 /*
 985                  * the (64-bit word) location in scratchpad to write
 986                  * to (if len != 0)
 987                  */
 988                 uint64_t scraddr:8;
 989                 /* the number of words in the response (0 => no response) */
 990                 uint64_t len:8;
 991                 /* the ID of the device on the non-coherent bus */
 992                 uint64_t did:8;
 993                 uint64_t unused:36;
 994                 /* if set, don't return load response until work is available */
 995                 uint64_t wait:1;
 996                 uint64_t unused2:3;
 997         } s;
 998
 999 } cvmx_pow_iobdma_store_t;
1000
1001 /* CSR typedefs have been moved to cvmx-csr-*.h */
1002
1003 /**
1004  * Get the POW tag for this core. This returns the current
1005  * tag type, tag, group, and POW entry index associated with
1006  * this core. Index is only valid if the tag type isn't NULL_NULL.
1007  * If a tag switch is pending this routine returns the tag before
1008  * the tag switch, not after.
1009  *
1010  * Returns Current tag
1011  */
1012 static inline cvmx_pow_tag_req_t cvmx_pow_get_current_tag(void)
1013 {
1014         cvmx_pow_load_addr_t load_addr;
1015         cvmx_pow_tag_load_resp_t load_resp;
1016         cvmx_pow_tag_req_t result;
1017
1018         load_addr.u64 = 0;
1019         load_addr.sstatus.mem_region = CVMX_IO_SEG;
1020         load_addr.sstatus.is_io = 1;
1021         load_addr.sstatus.did = CVMX_OCT_DID_TAG_TAG1;
1022         load_addr.sstatus.coreid = cvmx_get_core_num();
1023         load_addr.sstatus.get_cur = 1;
1024         load_resp.u64 = cvmx_read_csr(load_addr.u64);
1025         result.u64 = 0;
1026         result.s.grp = load_resp.s_sstatus2.grp;
1027         result.s.index = load_resp.s_sstatus2.index;
1028         result.s.type = load_resp.s_sstatus2.tag_type;
1029         result.s.tag = load_resp.s_sstatus2.tag;
1030         return result;
1031 }
1032
1033 /**
1034  * Get the POW WQE for this core. This returns the work queue
1035  * entry currently associated with this core.
1036  *
1037  * Returns WQE pointer
1038  */
1039 static inline cvmx_wqe_t *cvmx_pow_get_current_wqp(void)
1040 {
1041         cvmx_pow_load_addr_t load_addr;
1042         cvmx_pow_tag_load_resp_t load_resp;
1043
1044         load_addr.u64 = 0;
1045         load_addr.sstatus.mem_region = CVMX_IO_SEG;
1046         load_addr.sstatus.is_io = 1;
1047         load_addr.sstatus.did = CVMX_OCT_DID_TAG_TAG1;
1048         load_addr.sstatus.coreid = cvmx_get_core_num();
1049         load_addr.sstatus.get_cur = 1;
1050         load_addr.sstatus.get_wqp = 1;
1051         load_resp.u64 = cvmx_read_csr(load_addr.u64);
1052         return (cvmx_wqe_t *) cvmx_phys_to_ptr(load_resp.s_sstatus4.wqp);
1053 }
1054
1055 #ifndef CVMX_MF_CHORD
1056 #define CVMX_MF_CHORD(dest)         CVMX_RDHWR(dest, 30)
1057 #endif
1058
1059 /**
1060  * Print a warning if a tag switch is pending for this core
1061  *
1062  * @function: Function name checking for a pending tag switch
1063  */
1064 static inline void __cvmx_pow_warn_if_pending_switch(const char *function)
1065 {
1066         uint64_t switch_complete;
1067         CVMX_MF_CHORD(switch_complete);
1068         if (!switch_complete)
1069                 pr_warning("%s called with tag switch in progress\n", function);
1070 }
1071
1072 /**
1073  * Waits for a tag switch to complete by polling the completion bit.
1074  * Note that switches to NULL complete immediately and do not need
1075  * to be waited for.
1076  */
1077 static inline void cvmx_pow_tag_sw_wait(void)
1078 {
1079         const uint64_t MAX_CYCLES = 1ull << 31;
1080         uint64_t switch_complete;
1081         uint64_t start_cycle = cvmx_get_cycle();
1082         while (1) {
1083                 CVMX_MF_CHORD(switch_complete);
1084                 if (unlikely(switch_complete))
1085                         break;
1086                 if (unlikely(cvmx_get_cycle() > start_cycle + MAX_CYCLES)) {
1087                         pr_warning("Tag switch is taking a long time, "
1088                                    "possible deadlock\n");
1089                         start_cycle = -MAX_CYCLES - 1;
1090                 }
1091         }
1092 }
1093
1094 /**
1095  * Synchronous work request.  Requests work from the POW.
1096  * This function does NOT wait for previous tag switches to complete,
1097  * so the caller must ensure that there is not a pending tag switch.
1098  *
1099  * @wait:   When set, call stalls until work becomes avaiable, or times out.
1100  *               If not set, returns immediately.
1101  *
1102  * Returns Returns the WQE pointer from POW. Returns NULL if no work
1103  * was available.
1104  */
1105 static inline cvmx_wqe_t *cvmx_pow_work_request_sync_nocheck(cvmx_pow_wait_t
1106                                                              wait)
1107 {
1108         cvmx_pow_load_addr_t ptr;
1109         cvmx_pow_tag_load_resp_t result;
1110
1111         if (CVMX_ENABLE_POW_CHECKS)
1112                 __cvmx_pow_warn_if_pending_switch(__func__);
1113
1114         ptr.u64 = 0;
1115         ptr.swork.mem_region = CVMX_IO_SEG;
1116         ptr.swork.is_io = 1;
1117         ptr.swork.did = CVMX_OCT_DID_TAG_SWTAG;
1118         ptr.swork.wait = wait;
1119
1120         result.u64 = cvmx_read_csr(ptr.u64);
1121
1122         if (result.s_work.no_work)
1123                 return NULL;
1124         else
1125                 return (cvmx_wqe_t *) cvmx_phys_to_ptr(result.s_work.addr);
1126 }
1127
1128 /**
1129  * Synchronous work request.  Requests work from the POW.
1130  * This function waits for any previous tag switch to complete before
1131  * requesting the new work.
1132  *
1133  * @wait:   When set, call stalls until work becomes avaiable, or times out.
1134  *               If not set, returns immediately.
1135  *
1136  * Returns Returns the WQE pointer from POW. Returns NULL if no work
1137  * was available.
1138  */
1139 static inline cvmx_wqe_t *cvmx_pow_work_request_sync(cvmx_pow_wait_t wait)
1140 {
1141         if (CVMX_ENABLE_POW_CHECKS)
1142                 __cvmx_pow_warn_if_pending_switch(__func__);
1143
1144         /* Must not have a switch pending when requesting work */
1145         cvmx_pow_tag_sw_wait();
1146         return cvmx_pow_work_request_sync_nocheck(wait);
1147
1148 }
1149
1150 /**
1151  * Synchronous null_rd request.  Requests a switch out of NULL_NULL POW state.
1152  * This function waits for any previous tag switch to complete before
1153  * requesting the null_rd.
1154  *
1155  * Returns Returns the POW state of type cvmx_pow_tag_type_t.
1156  */
1157 static inline enum cvmx_pow_tag_type cvmx_pow_work_request_null_rd(void)
1158 {
1159         cvmx_pow_load_addr_t ptr;
1160         cvmx_pow_tag_load_resp_t result;
1161
1162         if (CVMX_ENABLE_POW_CHECKS)
1163                 __cvmx_pow_warn_if_pending_switch(__func__);
1164
1165         /* Must not have a switch pending when requesting work */
1166         cvmx_pow_tag_sw_wait();
1167
1168         ptr.u64 = 0;
1169         ptr.snull_rd.mem_region = CVMX_IO_SEG;
1170         ptr.snull_rd.is_io = 1;
1171         ptr.snull_rd.did = CVMX_OCT_DID_TAG_NULL_RD;
1172
1173         result.u64 = cvmx_read_csr(ptr.u64);
1174
1175         return (enum cvmx_pow_tag_type) result.s_null_rd.state;
1176 }
1177
1178 /**
1179  * Asynchronous work request.  Work is requested from the POW unit,
1180  * and should later be checked with function
1181  * cvmx_pow_work_response_async.  This function does NOT wait for
1182  * previous tag switches to complete, so the caller must ensure that
1183  * there is not a pending tag switch.
1184  *
1185  * @scr_addr: Scratch memory address that response will be returned
1186  *            to, which is either a valid WQE, or a response with the
1187  *            invalid bit set.  Byte address, must be 8 byte aligned.
1188  *
1189  * @wait: 1 to cause response to wait for work to become available (or
1190  *        timeout), 0 to cause response to return immediately
1191  */
1192 static inline void cvmx_pow_work_request_async_nocheck(int scr_addr,
1193                                                        cvmx_pow_wait_t wait)
1194 {
1195         cvmx_pow_iobdma_store_t data;
1196
1197         if (CVMX_ENABLE_POW_CHECKS)
1198                 __cvmx_pow_warn_if_pending_switch(__func__);
1199
1200         /* scr_addr must be 8 byte aligned */
1201         data.s.scraddr = scr_addr >> 3;
1202         data.s.len = 1;
1203         data.s.did = CVMX_OCT_DID_TAG_SWTAG;
1204         data.s.wait = wait;
1205         cvmx_send_single(data.u64);
1206 }
1207
1208 /**
1209  * Asynchronous work request.  Work is requested from the POW unit,
1210  * and should later be checked with function
1211  * cvmx_pow_work_response_async.  This function waits for any previous
1212  * tag switch to complete before requesting the new work.
1213  *
1214  * @scr_addr: Scratch memory address that response will be returned
1215  *            to, which is either a valid WQE, or a response with the
1216  *            invalid bit set.  Byte address, must be 8 byte aligned.
1217  *
1218  * @wait: 1 to cause response to wait for work to become available (or
1219  *                  timeout), 0 to cause response to return immediately
1220  */
1221 static inline void cvmx_pow_work_request_async(int scr_addr,
1222                                                cvmx_pow_wait_t wait)
1223 {
1224         if (CVMX_ENABLE_POW_CHECKS)
1225                 __cvmx_pow_warn_if_pending_switch(__func__);
1226
1227         /* Must not have a switch pending when requesting work */
1228         cvmx_pow_tag_sw_wait();
1229         cvmx_pow_work_request_async_nocheck(scr_addr, wait);
1230 }
1231
1232 /**
1233  * Gets result of asynchronous work request.  Performs a IOBDMA sync
1234  * to wait for the response.
1235  *
1236  * @scr_addr: Scratch memory address to get result from Byte address,
1237  *            must be 8 byte aligned.
1238  *
1239  * Returns Returns the WQE from the scratch register, or NULL if no
1240  * work was available.
1241  */
1242 static inline cvmx_wqe_t *cvmx_pow_work_response_async(int scr_addr)
1243 {
1244         cvmx_pow_tag_load_resp_t result;
1245
1246         CVMX_SYNCIOBDMA;
1247         result.u64 = cvmx_scratch_read64(scr_addr);
1248
1249         if (result.s_work.no_work)
1250                 return NULL;
1251         else
1252                 return (cvmx_wqe_t *) cvmx_phys_to_ptr(result.s_work.addr);
1253 }
1254
1255 /**
1256  * Checks if a work queue entry pointer returned by a work
1257  * request is valid.  It may be invalid due to no work
1258  * being available or due to a timeout.
1259  *
1260  * @wqe_ptr: pointer to a work queue entry returned by the POW
1261  *
1262  * Returns 0 if pointer is valid
1263  *         1 if invalid (no work was returned)
1264  */
1265 static inline uint64_t cvmx_pow_work_invalid(cvmx_wqe_t *wqe_ptr)
1266 {
1267         return wqe_ptr == NULL;
1268 }
1269
1270 /**
1271  * Starts a tag switch to the provided tag value and tag type.
1272  * Completion for the tag switch must be checked for separately.  This
1273  * function does NOT update the work queue entry in dram to match tag
1274  * value and type, so the application must keep track of these if they
1275  * are important to the application.  This tag switch command must not
1276  * be used for switches to NULL, as the tag switch pending bit will be
1277  * set by the switch request, but never cleared by the hardware.
1278  *
1279  * NOTE: This should not be used when switching from a NULL tag.  Use
1280  * cvmx_pow_tag_sw_full() instead.
1281  *
1282  * This function does no checks, so the caller must ensure that any
1283  * previous tag switch has completed.
1284  *
1285  * @tag:      new tag value
1286  * @tag_type: new tag type (ordered or atomic)
1287  */
1288 static inline void cvmx_pow_tag_sw_nocheck(uint32_t tag,
1289                                            enum cvmx_pow_tag_type tag_type)
1290 {
1291         cvmx_addr_t ptr;
1292         cvmx_pow_tag_req_t tag_req;
1293
1294         if (CVMX_ENABLE_POW_CHECKS) {
1295                 cvmx_pow_tag_req_t current_tag;
1296                 __cvmx_pow_warn_if_pending_switch(__func__);
1297                 current_tag = cvmx_pow_get_current_tag();
1298                 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL_NULL)
1299                         pr_warning("%s called with NULL_NULL tag\n",
1300                                    __func__);
1301                 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL)
1302                         pr_warning("%s called with NULL tag\n", __func__);
1303                 if ((current_tag.s.type == tag_type)
1304                    && (current_tag.s.tag == tag))
1305                         pr_warning("%s called to perform a tag switch to the "
1306                                    "same tag\n",
1307                              __func__);
1308                 if (tag_type == CVMX_POW_TAG_TYPE_NULL)
1309                         pr_warning("%s called to perform a tag switch to "
1310                                    "NULL. Use cvmx_pow_tag_sw_null() instead\n",
1311                              __func__);
1312         }
1313
1314         /*
1315          * Note that WQE in DRAM is not updated here, as the POW does
1316          * not read from DRAM once the WQE is in flight.  See hardware
1317          * manual for complete details.  It is the application's
1318          * responsibility to keep track of the current tag value if
1319          * that is important.
1320          */
1321
1322         tag_req.u64 = 0;
1323         tag_req.s.op = CVMX_POW_TAG_OP_SWTAG;
1324         tag_req.s.tag = tag;
1325         tag_req.s.type = tag_type;
1326
1327         ptr.u64 = 0;
1328         ptr.sio.mem_region = CVMX_IO_SEG;
1329         ptr.sio.is_io = 1;
1330         ptr.sio.did = CVMX_OCT_DID_TAG_SWTAG;
1331
1332         /* once this store arrives at POW, it will attempt the switch
1333            software must wait for the switch to complete separately */
1334         cvmx_write_io(ptr.u64, tag_req.u64);
1335 }
1336
1337 /**
1338  * Starts a tag switch to the provided tag value and tag type.
1339  * Completion for the tag switch must be checked for separately.  This
1340  * function does NOT update the work queue entry in dram to match tag
1341  * value and type, so the application must keep track of these if they
1342  * are important to the application.  This tag switch command must not
1343  * be used for switches to NULL, as the tag switch pending bit will be
1344  * set by the switch request, but never cleared by the hardware.
1345  *
1346  * NOTE: This should not be used when switching from a NULL tag.  Use
1347  * cvmx_pow_tag_sw_full() instead.
1348  *
1349  * This function waits for any previous tag switch to complete, and also
1350  * displays an error on tag switches to NULL.
1351  *
1352  * @tag:      new tag value
1353  * @tag_type: new tag type (ordered or atomic)
1354  */
1355 static inline void cvmx_pow_tag_sw(uint32_t tag,
1356                                    enum cvmx_pow_tag_type tag_type)
1357 {
1358         if (CVMX_ENABLE_POW_CHECKS)
1359                 __cvmx_pow_warn_if_pending_switch(__func__);
1360
1361         /*
1362          * Note that WQE in DRAM is not updated here, as the POW does
1363          * not read from DRAM once the WQE is in flight.  See hardware
1364          * manual for complete details.  It is the application's
1365          * responsibility to keep track of the current tag value if
1366          * that is important.
1367          */
1368
1369         /*
1370          * Ensure that there is not a pending tag switch, as a tag
1371          * switch cannot be started if a previous switch is still
1372          * pending.
1373          */
1374         cvmx_pow_tag_sw_wait();
1375         cvmx_pow_tag_sw_nocheck(tag, tag_type);
1376 }
1377
1378 /**
1379  * Starts a tag switch to the provided tag value and tag type.
1380  * Completion for the tag switch must be checked for separately.  This
1381  * function does NOT update the work queue entry in dram to match tag
1382  * value and type, so the application must keep track of these if they
1383  * are important to the application.  This tag switch command must not
1384  * be used for switches to NULL, as the tag switch pending bit will be
1385  * set by the switch request, but never cleared by the hardware.
1386  *
1387  * This function must be used for tag switches from NULL.
1388  *
1389  * This function does no checks, so the caller must ensure that any
1390  * previous tag switch has completed.
1391  *
1392  * @wqp:      pointer to work queue entry to submit.  This entry is
1393  *            updated to match the other parameters
1394  * @tag:      tag value to be assigned to work queue entry
1395  * @tag_type: type of tag
1396  * @group:    group value for the work queue entry.
1397  */
1398 static inline void cvmx_pow_tag_sw_full_nocheck(cvmx_wqe_t *wqp, uint32_t tag,
1399                                                 enum cvmx_pow_tag_type tag_type,
1400                                                 uint64_t group)
1401 {
1402         cvmx_addr_t ptr;
1403         cvmx_pow_tag_req_t tag_req;
1404
1405         if (CVMX_ENABLE_POW_CHECKS) {
1406                 cvmx_pow_tag_req_t current_tag;
1407                 __cvmx_pow_warn_if_pending_switch(__func__);
1408                 current_tag = cvmx_pow_get_current_tag();
1409                 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL_NULL)
1410                         pr_warning("%s called with NULL_NULL tag\n",
1411                                    __func__);
1412                 if ((current_tag.s.type == tag_type)
1413                    && (current_tag.s.tag == tag))
1414                         pr_warning("%s called to perform a tag switch to "
1415                                    "the same tag\n",
1416                              __func__);
1417                 if (tag_type == CVMX_POW_TAG_TYPE_NULL)
1418                         pr_warning("%s called to perform a tag switch to "
1419                                    "NULL. Use cvmx_pow_tag_sw_null() instead\n",
1420                              __func__);
1421                 if (wqp != cvmx_phys_to_ptr(0x80))
1422                         if (wqp != cvmx_pow_get_current_wqp())
1423                                 pr_warning("%s passed WQE(%p) doesn't match "
1424                                            "the address in the POW(%p)\n",
1425                                      __func__, wqp,
1426                                      cvmx_pow_get_current_wqp());
1427         }
1428
1429         /*
1430          * Note that WQE in DRAM is not updated here, as the POW does
1431          * not read from DRAM once the WQE is in flight.  See hardware
1432          * manual for complete details.  It is the application's
1433          * responsibility to keep track of the current tag value if
1434          * that is important.
1435          */
1436
1437         tag_req.u64 = 0;
1438         tag_req.s.op = CVMX_POW_TAG_OP_SWTAG_FULL;
1439         tag_req.s.tag = tag;
1440         tag_req.s.type = tag_type;
1441         tag_req.s.grp = group;
1442
1443         ptr.u64 = 0;
1444         ptr.sio.mem_region = CVMX_IO_SEG;
1445         ptr.sio.is_io = 1;
1446         ptr.sio.did = CVMX_OCT_DID_TAG_SWTAG;
1447         ptr.sio.offset = CAST64(wqp);
1448
1449         /*
1450          * once this store arrives at POW, it will attempt the switch
1451          * software must wait for the switch to complete separately.
1452          */
1453         cvmx_write_io(ptr.u64, tag_req.u64);
1454 }
1455
1456 /**
1457  * Starts a tag switch to the provided tag value and tag type.
1458  * Completion for the tag switch must be checked for separately.  This
1459  * function does NOT update the work queue entry in dram to match tag
1460  * value and type, so the application must keep track of these if they
1461  * are important to the application.  This tag switch command must not
1462  * be used for switches to NULL, as the tag switch pending bit will be
1463  * set by the switch request, but never cleared by the hardware.
1464  *
1465  * This function must be used for tag switches from NULL.
1466  *
1467  * This function waits for any pending tag switches to complete
1468  * before requesting the tag switch.
1469  *
1470  * @wqp:      pointer to work queue entry to submit.  This entry is updated
1471  *            to match the other parameters
1472  * @tag:      tag value to be assigned to work queue entry
1473  * @tag_type: type of tag
1474  * @group:      group value for the work queue entry.
1475  */
1476 static inline void cvmx_pow_tag_sw_full(cvmx_wqe_t *wqp, uint32_t tag,
1477                                         enum cvmx_pow_tag_type tag_type,
1478                                         uint64_t group)
1479 {
1480         if (CVMX_ENABLE_POW_CHECKS)
1481                 __cvmx_pow_warn_if_pending_switch(__func__);
1482
1483         /*
1484          * Ensure that there is not a pending tag switch, as a tag
1485          * switch cannot be started if a previous switch is still
1486          * pending.
1487          */
1488         cvmx_pow_tag_sw_wait();
1489         cvmx_pow_tag_sw_full_nocheck(wqp, tag, tag_type, group);
1490 }
1491
1492 /**
1493  * Switch to a NULL tag, which ends any ordering or
1494  * synchronization provided by the POW for the current
1495  * work queue entry.  This operation completes immediately,
1496  * so completion should not be waited for.
1497  * This function does NOT wait for previous tag switches to complete,
1498  * so the caller must ensure that any previous tag switches have completed.
1499  */
1500 static inline void cvmx_pow_tag_sw_null_nocheck(void)
1501 {
1502         cvmx_addr_t ptr;
1503         cvmx_pow_tag_req_t tag_req;
1504
1505         if (CVMX_ENABLE_POW_CHECKS) {
1506                 cvmx_pow_tag_req_t current_tag;
1507                 __cvmx_pow_warn_if_pending_switch(__func__);
1508                 current_tag = cvmx_pow_get_current_tag();
1509                 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL_NULL)
1510                         pr_warning("%s called with NULL_NULL tag\n",
1511                                    __func__);
1512                 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL)
1513                         pr_warning("%s called when we already have a "
1514                                    "NULL tag\n",
1515                              __func__);
1516         }
1517
1518         tag_req.u64 = 0;
1519         tag_req.s.op = CVMX_POW_TAG_OP_SWTAG;
1520         tag_req.s.type = CVMX_POW_TAG_TYPE_NULL;
1521
1522         ptr.u64 = 0;
1523         ptr.sio.mem_region = CVMX_IO_SEG;
1524         ptr.sio.is_io = 1;
1525         ptr.sio.did = CVMX_OCT_DID_TAG_TAG1;
1526
1527         cvmx_write_io(ptr.u64, tag_req.u64);
1528
1529         /* switch to NULL completes immediately */
1530 }
1531
1532 /**
1533  * Switch to a NULL tag, which ends any ordering or
1534  * synchronization provided by the POW for the current
1535  * work queue entry.  This operation completes immediately,
1536  * so completion should not be waited for.
1537  * This function waits for any pending tag switches to complete
1538  * before requesting the switch to NULL.
1539  */
1540 static inline void cvmx_pow_tag_sw_null(void)
1541 {
1542         if (CVMX_ENABLE_POW_CHECKS)
1543                 __cvmx_pow_warn_if_pending_switch(__func__);
1544
1545         /*
1546          * Ensure that there is not a pending tag switch, as a tag
1547          * switch cannot be started if a previous switch is still
1548          * pending.
1549          */
1550         cvmx_pow_tag_sw_wait();
1551         cvmx_pow_tag_sw_null_nocheck();
1552
1553         /* switch to NULL completes immediately */
1554 }
1555
1556 /**
1557  * Submits work to an input queue.  This function updates the work
1558  * queue entry in DRAM to match the arguments given.  Note that the
1559  * tag provided is for the work queue entry submitted, and is
1560  * unrelated to the tag that the core currently holds.
1561  *
1562  * @wqp:      pointer to work queue entry to submit.  This entry is
1563  *            updated to match the other parameters
1564  * @tag:      tag value to be assigned to work queue entry
1565  * @tag_type: type of tag
1566  * @qos:      Input queue to add to.
1567  * @grp:      group value for the work queue entry.
1568  */
1569 static inline void cvmx_pow_work_submit(cvmx_wqe_t *wqp, uint32_t tag,
1570                                         enum cvmx_pow_tag_type tag_type,
1571                                         uint64_t qos, uint64_t grp)
1572 {
1573         cvmx_addr_t ptr;
1574         cvmx_pow_tag_req_t tag_req;
1575
1576         wqp->qos = qos;
1577         wqp->tag = tag;
1578         wqp->tag_type = tag_type;
1579         wqp->grp = grp;
1580
1581         tag_req.u64 = 0;
1582         tag_req.s.op = CVMX_POW_TAG_OP_ADDWQ;
1583         tag_req.s.type = tag_type;
1584         tag_req.s.tag = tag;
1585         tag_req.s.qos = qos;
1586         tag_req.s.grp = grp;
1587
1588         ptr.u64 = 0;
1589         ptr.sio.mem_region = CVMX_IO_SEG;
1590         ptr.sio.is_io = 1;
1591         ptr.sio.did = CVMX_OCT_DID_TAG_TAG1;
1592         ptr.sio.offset = cvmx_ptr_to_phys(wqp);
1593
1594         /*
1595          * SYNC write to memory before the work submit.  This is
1596          * necessary as POW may read values from DRAM at this time.
1597          */
1598         CVMX_SYNCWS;
1599         cvmx_write_io(ptr.u64, tag_req.u64);
1600 }
1601
1602 /**
1603  * This function sets the group mask for a core.  The group mask
1604  * indicates which groups each core will accept work from. There are
1605  * 16 groups.
1606  *
1607  * @core_num:   core to apply mask to
1608  * @mask:   Group mask. There are 16 groups, so only bits 0-15 are valid,
1609  *               representing groups 0-15.
1610  *               Each 1 bit in the mask enables the core to accept work from
1611  *               the corresponding group.
1612  */
1613 static inline void cvmx_pow_set_group_mask(uint64_t core_num, uint64_t mask)
1614 {
1615         union cvmx_pow_pp_grp_mskx grp_msk;
1616
1617         grp_msk.u64 = cvmx_read_csr(CVMX_POW_PP_GRP_MSKX(core_num));
1618         grp_msk.s.grp_msk = mask;
1619         cvmx_write_csr(CVMX_POW_PP_GRP_MSKX(core_num), grp_msk.u64);
1620 }
1621
1622 /**
1623  * This function sets POW static priorities for a core. Each input queue has
1624  * an associated priority value.
1625  *
1626  * @core_num:   core to apply priorities to
1627  * @priority:   Vector of 8 priorities, one per POW Input Queue (0-7).
1628  *                   Highest priority is 0 and lowest is 7. A priority value
1629  *                   of 0xF instructs POW to skip the Input Queue when
1630  *                   scheduling to this specific core.
1631  *                   NOTE: priorities should not have gaps in values, meaning
1632  *                         {0,1,1,1,1,1,1,1} is a valid configuration while
1633  *                         {0,2,2,2,2,2,2,2} is not.
1634  */
1635 static inline void cvmx_pow_set_priority(uint64_t core_num,
1636                                          const uint8_t priority[])
1637 {
1638         /* POW priorities are supported on CN5xxx and later */
1639         if (!OCTEON_IS_MODEL(OCTEON_CN3XXX)) {
1640                 union cvmx_pow_pp_grp_mskx grp_msk;
1641
1642                 grp_msk.u64 = cvmx_read_csr(CVMX_POW_PP_GRP_MSKX(core_num));
1643                 grp_msk.s.qos0_pri = priority[0];
1644                 grp_msk.s.qos1_pri = priority[1];
1645                 grp_msk.s.qos2_pri = priority[2];
1646                 grp_msk.s.qos3_pri = priority[3];
1647                 grp_msk.s.qos4_pri = priority[4];
1648                 grp_msk.s.qos5_pri = priority[5];
1649                 grp_msk.s.qos6_pri = priority[6];
1650                 grp_msk.s.qos7_pri = priority[7];
1651
1652                 /* Detect gaps between priorities and flag error */
1653                 {
1654                         int i;
1655                         uint32_t prio_mask = 0;
1656
1657                         for (i = 0; i < 8; i++)
1658                                 if (priority[i] != 0xF)
1659                                         prio_mask |= 1 << priority[i];
1660
1661                         if (prio_mask ^ ((1 << cvmx_pop(prio_mask)) - 1)) {
1662                                 pr_err("POW static priorities should be "
1663                                        "contiguous (0x%llx)\n",
1664                                      (unsigned long long)prio_mask);
1665                                 return;
1666                         }
1667                 }
1668
1669                 cvmx_write_csr(CVMX_POW_PP_GRP_MSKX(core_num), grp_msk.u64);
1670         }
1671 }
1672
1673 /**
1674  * Performs a tag switch and then an immediate deschedule. This completes
1675  * immediately, so completion must not be waited for.  This function does NOT
1676  * update the wqe in DRAM to match arguments.
1677  *
1678  * This function does NOT wait for any prior tag switches to complete, so the
1679  * calling code must do this.
1680  *
1681  * Note the following CAVEAT of the Octeon HW behavior when
1682  * re-scheduling DE-SCHEDULEd items whose (next) state is
1683  * ORDERED:
1684  *   - If there are no switches pending at the time that the
1685  *     HW executes the de-schedule, the HW will only re-schedule
1686  *     the head of the FIFO associated with the given tag. This
1687  *     means that in many respects, the HW treats this ORDERED
1688  *     tag as an ATOMIC tag. Note that in the SWTAG_DESCH
1689  *     case (to an ORDERED tag), the HW will do the switch
1690  *     before the deschedule whenever it is possible to do
1691  *     the switch immediately, so it may often look like
1692  *     this case.
1693  *   - If there is a pending switch to ORDERED at the time
1694  *     the HW executes the de-schedule, the HW will perform
1695  *     the switch at the time it re-schedules, and will be
1696  *     able to reschedule any/all of the entries with the
1697  *     same tag.
1698  * Due to this behavior, the RECOMMENDATION to software is
1699  * that they have a (next) state of ATOMIC when they
1700  * DE-SCHEDULE. If an ORDERED tag is what was really desired,
1701  * SW can choose to immediately switch to an ORDERED tag
1702  * after the work (that has an ATOMIC tag) is re-scheduled.
1703  * Note that since there are never any tag switches pending
1704  * when the HW re-schedules, this switch can be IMMEDIATE upon
1705  * the reception of the pointer during the re-schedule.
1706  *
1707  * @tag:      New tag value
1708  * @tag_type: New tag type
1709  * @group:    New group value
1710  * @no_sched: Control whether this work queue entry will be rescheduled.
1711  *                 - 1 : don't schedule this work
1712  *                 - 0 : allow this work to be scheduled.
1713  */
1714 static inline void cvmx_pow_tag_sw_desched_nocheck(
1715         uint32_t tag,
1716         enum cvmx_pow_tag_type tag_type,
1717         uint64_t group,
1718         uint64_t no_sched)
1719 {
1720         cvmx_addr_t ptr;
1721         cvmx_pow_tag_req_t tag_req;
1722
1723         if (CVMX_ENABLE_POW_CHECKS) {
1724                 cvmx_pow_tag_req_t current_tag;
1725                 __cvmx_pow_warn_if_pending_switch(__func__);
1726                 current_tag = cvmx_pow_get_current_tag();
1727                 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL_NULL)
1728                         pr_warning("%s called with NULL_NULL tag\n",
1729                                    __func__);
1730                 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL)
1731                         pr_warning("%s called with NULL tag. Deschedule not "
1732                                    "allowed from NULL state\n",
1733                              __func__);
1734                 if ((current_tag.s.type != CVMX_POW_TAG_TYPE_ATOMIC)
1735                         && (tag_type != CVMX_POW_TAG_TYPE_ATOMIC))
1736                         pr_warning("%s called where neither the before or "
1737                                    "after tag is ATOMIC\n",
1738                              __func__);
1739         }
1740
1741         tag_req.u64 = 0;
1742         tag_req.s.op = CVMX_POW_TAG_OP_SWTAG_DESCH;
1743         tag_req.s.tag = tag;
1744         tag_req.s.type = tag_type;
1745         tag_req.s.grp = group;
1746         tag_req.s.no_sched = no_sched;
1747
1748         ptr.u64 = 0;
1749         ptr.sio.mem_region = CVMX_IO_SEG;
1750         ptr.sio.is_io = 1;
1751         ptr.sio.did = CVMX_OCT_DID_TAG_TAG3;
1752         /*
1753          * since TAG3 is used, this store will clear the local pending
1754          * switch bit.
1755          */
1756         cvmx_write_io(ptr.u64, tag_req.u64);
1757 }
1758
1759 /**
1760  * Performs a tag switch and then an immediate deschedule. This completes
1761  * immediately, so completion must not be waited for.  This function does NOT
1762  * update the wqe in DRAM to match arguments.
1763  *
1764  * This function waits for any prior tag switches to complete, so the
1765  * calling code may call this function with a pending tag switch.
1766  *
1767  * Note the following CAVEAT of the Octeon HW behavior when
1768  * re-scheduling DE-SCHEDULEd items whose (next) state is
1769  * ORDERED:
1770  *   - If there are no switches pending at the time that the
1771  *     HW executes the de-schedule, the HW will only re-schedule
1772  *     the head of the FIFO associated with the given tag. This
1773  *     means that in many respects, the HW treats this ORDERED
1774  *     tag as an ATOMIC tag. Note that in the SWTAG_DESCH
1775  *     case (to an ORDERED tag), the HW will do the switch
1776  *     before the deschedule whenever it is possible to do
1777  *     the switch immediately, so it may often look like
1778  *     this case.
1779  *   - If there is a pending switch to ORDERED at the time
1780  *     the HW executes the de-schedule, the HW will perform
1781  *     the switch at the time it re-schedules, and will be
1782  *     able to reschedule any/all of the entries with the
1783  *     same tag.
1784  * Due to this behavior, the RECOMMENDATION to software is
1785  * that they have a (next) state of ATOMIC when they
1786  * DE-SCHEDULE. If an ORDERED tag is what was really desired,
1787  * SW can choose to immediately switch to an ORDERED tag
1788  * after the work (that has an ATOMIC tag) is re-scheduled.
1789  * Note that since there are never any tag switches pending
1790  * when the HW re-schedules, this switch can be IMMEDIATE upon
1791  * the reception of the pointer during the re-schedule.
1792  *
1793  * @tag:      New tag value
1794  * @tag_type: New tag type
1795  * @group:    New group value
1796  * @no_sched: Control whether this work queue entry will be rescheduled.
1797  *                 - 1 : don't schedule this work
1798  *                 - 0 : allow this work to be scheduled.
1799  */
1800 static inline void cvmx_pow_tag_sw_desched(uint32_t tag,
1801                                            enum cvmx_pow_tag_type tag_type,
1802                                            uint64_t group, uint64_t no_sched)
1803 {
1804         if (CVMX_ENABLE_POW_CHECKS)
1805                 __cvmx_pow_warn_if_pending_switch(__func__);
1806
1807         /* Need to make sure any writes to the work queue entry are complete */
1808         CVMX_SYNCWS;
1809         /*
1810          * Ensure that there is not a pending tag switch, as a tag
1811          * switch cannot be started if a previous switch is still
1812          * pending.
1813          */
1814         cvmx_pow_tag_sw_wait();
1815         cvmx_pow_tag_sw_desched_nocheck(tag, tag_type, group, no_sched);
1816 }
1817
1818 /**
1819  * Descchedules the current work queue entry.
1820  *
1821  * @no_sched: no schedule flag value to be set on the work queue
1822  *            entry.  If this is set the entry will not be
1823  *            rescheduled.
1824  */
1825 static inline void cvmx_pow_desched(uint64_t no_sched)
1826 {
1827         cvmx_addr_t ptr;
1828         cvmx_pow_tag_req_t tag_req;
1829
1830         if (CVMX_ENABLE_POW_CHECKS) {
1831                 cvmx_pow_tag_req_t current_tag;
1832                 __cvmx_pow_warn_if_pending_switch(__func__);
1833                 current_tag = cvmx_pow_get_current_tag();
1834                 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL_NULL)
1835                         pr_warning("%s called with NULL_NULL tag\n",
1836                                    __func__);
1837                 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL)
1838                         pr_warning("%s called with NULL tag. Deschedule not "
1839                                    "expected from NULL state\n",
1840                              __func__);
1841         }
1842
1843         /* Need to make sure any writes to the work queue entry are complete */
1844         CVMX_SYNCWS;
1845
1846         tag_req.u64 = 0;
1847         tag_req.s.op = CVMX_POW_TAG_OP_DESCH;
1848         tag_req.s.no_sched = no_sched;
1849
1850         ptr.u64 = 0;
1851         ptr.sio.mem_region = CVMX_IO_SEG;
1852         ptr.sio.is_io = 1;
1853         ptr.sio.did = CVMX_OCT_DID_TAG_TAG3;
1854         /*
1855          * since TAG3 is used, this store will clear the local pending
1856          * switch bit.
1857          */
1858         cvmx_write_io(ptr.u64, tag_req.u64);
1859 }
1860
1861 /****************************************************
1862 * Define usage of bits within the 32 bit tag values.
1863 *****************************************************/
1864
1865 /*
1866  * Number of bits of the tag used by software.  The SW bits are always
1867  * a contiguous block of the high starting at bit 31.  The hardware
1868  * bits are always the low bits.  By default, the top 8 bits of the
1869  * tag are reserved for software, and the low 24 are set by the IPD
1870  * unit.
1871  */
1872 #define CVMX_TAG_SW_BITS    (8)
1873 #define CVMX_TAG_SW_SHIFT   (32 - CVMX_TAG_SW_BITS)
1874
1875 /* Below is the list of values for the top 8 bits of the tag. */
1876 /*
1877  * Tag values with top byte of this value are reserved for internal
1878  * executive uses.
1879  */
1880 #define CVMX_TAG_SW_BITS_INTERNAL  0x1
1881 /* The executive divides the remaining 24 bits as follows:
1882  *  - the upper 8 bits (bits 23 - 16 of the tag) define a subgroup
1883  *
1884  *  - the lower 16 bits (bits 15 - 0 of the tag) define are the value
1885  *    with the subgroup
1886  *
1887  * Note that this section describes the format of tags generated by
1888  * software - refer to the hardware documentation for a description of
1889  * the tags values generated by the packet input hardware.  Subgroups
1890  * are defined here.
1891  */
1892 /* Mask for the value portion of the tag */
1893 #define CVMX_TAG_SUBGROUP_MASK  0xFFFF
1894 #define CVMX_TAG_SUBGROUP_SHIFT 16
1895 #define CVMX_TAG_SUBGROUP_PKO  0x1
1896
1897 /* End of executive tag subgroup definitions */
1898
1899 /*
1900  * The remaining values software bit values 0x2 - 0xff are available
1901  * for application use.
1902  */
1903
1904 /**
1905  * This function creates a 32 bit tag value from the two values provided.
1906  *
1907  * @sw_bits: The upper bits (number depends on configuration) are set
1908  *           to this value.  The remainder of bits are set by the
1909  *           hw_bits parameter.
1910  *
1911  * @hw_bits: The lower bits (number depends on configuration) are set
1912  *           to this value.  The remainder of bits are set by the
1913  *           sw_bits parameter.
1914  *
1915  * Returns 32 bit value of the combined hw and sw bits.
1916  */
1917 static inline uint32_t cvmx_pow_tag_compose(uint64_t sw_bits, uint64_t hw_bits)
1918 {
1919         return ((sw_bits & cvmx_build_mask(CVMX_TAG_SW_BITS)) <<
1920                         CVMX_TAG_SW_SHIFT) |
1921                 (hw_bits & cvmx_build_mask(32 - CVMX_TAG_SW_BITS));
1922 }
1923
1924 /**
1925  * Extracts the bits allocated for software use from the tag
1926  *
1927  * @tag:    32 bit tag value
1928  *
1929  * Returns N bit software tag value, where N is configurable with the
1930  * CVMX_TAG_SW_BITS define
1931  */
1932 static inline uint32_t cvmx_pow_tag_get_sw_bits(uint64_t tag)
1933 {
1934         return (tag >> (32 - CVMX_TAG_SW_BITS)) &
1935                 cvmx_build_mask(CVMX_TAG_SW_BITS);
1936 }
1937
1938 /**
1939  *
1940  * Extracts the bits allocated for hardware use from the tag
1941  *
1942  * @tag:    32 bit tag value
1943  *
1944  * Returns (32 - N) bit software tag value, where N is configurable
1945  * with the CVMX_TAG_SW_BITS define
1946  */
1947 static inline uint32_t cvmx_pow_tag_get_hw_bits(uint64_t tag)
1948 {
1949         return tag & cvmx_build_mask(32 - CVMX_TAG_SW_BITS);
1950 }
1951
1952 /**
1953  * Store the current POW internal state into the supplied
1954  * buffer. It is recommended that you pass a buffer of at least
1955  * 128KB. The format of the capture may change based on SDK
1956  * version and Octeon chip.
1957  *
1958  * @buffer: Buffer to store capture into
1959  * @buffer_size:
1960  *               The size of the supplied buffer
1961  *
1962  * Returns Zero on success, negative on failure
1963  */
1964 extern int cvmx_pow_capture(void *buffer, int buffer_size);
1965
1966 /**
1967  * Dump a POW capture to the console in a human readable format.
1968  *
1969  * @buffer: POW capture from cvmx_pow_capture()
1970  * @buffer_size:
1971  *               Size of the buffer
1972  */
1973 extern void cvmx_pow_display(void *buffer, int buffer_size);
1974
1975 /**
1976  * Return the number of POW entries supported by this chip
1977  *
1978  * Returns Number of POW entries
1979  */
1980 extern int cvmx_pow_get_num_entries(void);
1981
1982 #endif /* __CVMX_POW_H__ */