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]) 158