drivers/net/fsl-mc/dpio/qbman_portal.h

   1 /*
   2  * Copyright (C) 2014 Freescale Semiconductor
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include "qbman_private.h"
   8 #include <fsl-mc/fsl_qbman_portal.h>
   9 #include <fsl-mc/fsl_dpaa_fd.h>
  10
  11 /* All QBMan command and result structures use this "valid bit" encoding */
  12 #define QB_VALID_BIT ((uint32_t)0x80)
  13
  14 /* Management command result codes */
  15 #define QBMAN_MC_RSLT_OK      0xf0
  16
  17 /* --------------------- */
  18 /* portal data structure */
  19 /* --------------------- */
  20
  21 struct qbman_swp {
  22         const struct qbman_swp_desc *desc;
  23         /* The qbman_sys (ie. arch/OS-specific) support code can put anything it
  24          * needs in here. */
  25         struct qbman_swp_sys sys;
  26         /* Management commands */
  27         struct {
  28 #ifdef QBMAN_CHECKING
  29                 enum swp_mc_check {
  30                         swp_mc_can_start, /* call __qbman_swp_mc_start() */
  31                         swp_mc_can_submit, /* call __qbman_swp_mc_submit() */
  32                         swp_mc_can_poll, /* call __qbman_swp_mc_result() */
  33                 } check;
  34 #endif
  35                 uint32_t valid_bit; /* 0x00 or 0x80 */
  36         } mc;
  37         /* Push dequeues */
  38         uint32_t sdq;
  39         /* Volatile dequeues */
  40         struct {
  41                 /* VDQCR supports a "1 deep pipeline", meaning that if you know
  42                  * the last-submitted command is already executing in the
  43                  * hardware (as evidenced by at least 1 valid dequeue result),
  44                  * you can write another dequeue command to the register, the
  45                  * hardware will start executing it as soon as the
  46                  * already-executing command terminates. (This minimises latency
  47                  * and stalls.) With that in mind, this "busy" variable refers
  48                  * to whether or not a command can be submitted, not whether or
  49                  * not a previously-submitted command is still executing. In
  50                  * other words, once proof is seen that the previously-submitted
  51                  * command is executing, "vdq" is no longer "busy". TODO:
  52                  * convert this to "atomic_t" so that it is thread-safe (without
  53                  * locking). */
  54                 int busy;
  55                 uint32_t valid_bit; /* 0x00 or 0x80 */
  56                 /* We need to determine when vdq is no longer busy. This depends
  57                  * on whether the "busy" (last-submitted) dequeue command is
  58                  * targetting DQRR or main-memory, and detected is based on the
  59                  * presence of the dequeue command's "token" showing up in
  60                  * dequeue entries in DQRR or main-memory (respectively). Debug
  61                  * builds will, when submitting vdq commands, verify that the
  62                  * dequeue result location is not already equal to the command's
  63                  * token value. */
  64                 struct ldpaa_dq *storage; /* NULL if DQRR */
  65                 uint32_t token;
  66         } vdq;
  67         /* DQRR */
  68         struct {
  69                 uint32_t next_idx;
  70                 uint32_t valid_bit;
  71         } dqrr;
  72 };
  73
  74 /* -------------------------- */
  75 /* portal management commands */
  76 /* -------------------------- */
  77
  78 /* Different management commands all use this common base layer of code to issue
  79  * commands and poll for results. The first function returns a pointer to where
  80  * the caller should fill in their MC command (though they should ignore the
  81  * verb byte), the second function commits merges in the caller-supplied command
  82  * verb (which should not include the valid-bit) and submits the command to
  83  * hardware, and the third function checks for a completed response (returns
  84  * non-NULL if only if the response is complete). */
  85 void *qbman_swp_mc_start(struct qbman_swp *p);
  86 void qbman_swp_mc_submit(struct qbman_swp *p, void *cmd, uint32_t cmd_verb);
  87 void *qbman_swp_mc_result(struct qbman_swp *p);
  88
  89 /* Wraps up submit + poll-for-result */
  90 static inline void *qbman_swp_mc_complete(struct qbman_swp *swp, void *cmd,
  91                                           uint32_t cmd_verb)
  92 {
  93         int loopvar;
  94
  95         qbman_swp_mc_submit(swp, cmd, cmd_verb);
  96         DBG_POLL_START(loopvar);
  97         do {
  98                 DBG_POLL_CHECK(loopvar);
  99                 cmd = qbman_swp_mc_result(swp);
 100         } while (!cmd);
 101         return cmd;
 102 }
 103
 104 /* ------------ */
 105 /* qb_attr_code */
 106 /* ------------ */
 107
 108 /* This struct locates a sub-field within a QBMan portal (CENA) cacheline which
 109  * is either serving as a configuration command or a query result. The
 110  * representation is inherently little-endian, as the indexing of the words is
 111  * itself little-endian in nature and layerscape is little endian for anything
 112  * that crosses a word boundary too (64-bit fields are the obvious examples).
 113  */
 114 struct qb_attr_code {
 115         unsigned int word; /* which uint32_t[] array member encodes the field */
 116         unsigned int lsoffset; /* encoding offset from ls-bit */
 117         unsigned int width; /* encoding width. (bool must be 1.) */
 118 };
 119
 120 /* Macros to define codes */
 121 #define QB_CODE(a, b, c) { a, b, c}
 122
 123 /* decode a field from a cacheline */
 124 static inline uint32_t qb_attr_code_decode(const struct qb_attr_code *code,
 125                                       const uint32_t *cacheline)
 126 {
 127         return d32_uint32_t(code->lsoffset, code->width, cacheline[code->word]);
 128 }
 129
 130 /* encode a field to a cacheline */
 131 static inline void qb_attr_code_encode(const struct qb_attr_code *code,
 132                                        uint32_t *cacheline, uint32_t val)
 133 {
 134         cacheline[code->word] =
 135                 r32_uint32_t(code->lsoffset, code->width, cacheline[code->word])
 136                 | e32_uint32_t(code->lsoffset, code->width, val);
 137 }
 138
 139 /* ---------------------- */
 140 /* Descriptors/cachelines */
 141 /* ---------------------- */
 142
 143 /* To avoid needless dynamic allocation, the driver API often gives the caller
 144  * a "descriptor" type that the caller can instantiate however they like.
 145  * Ultimately though, it is just a cacheline of binary storage (or something
 146  * smaller when it is known that the descriptor doesn't need all 64 bytes) for
 147  * holding pre-formatted pieces of harware commands. The performance-critical
 148  * code can then copy these descriptors directly into hardware command
 149  * registers more efficiently than trying to construct/format commands
 150  * on-the-fly. The API user sees the descriptor as an array of 32-bit words in
 151  * order for the compiler to know its size, but the internal details are not
 152  * exposed. The following macro is used within the driver for converting *any*
 153  * descriptor pointer to a usable array pointer. The use of a macro (instead of
 154  * an inline) is necessary to work with different descriptor types and to work
 155  * correctly with const and non-const inputs (and similarly-qualified outputs).
 156  */
 157 #define qb_cl(d) (&(d)->dont_manipulate_directly[0])