drivers/dma/hisilicon/hisi_dmadev.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2021 HiSilicon Limited
   3  */
   4
   5 #ifndef HISI_DMADEV_H
   6 #define HISI_DMADEV_H
   7
   8 #include <rte_byteorder.h>
   9 #include <rte_common.h>
  10
  11 #define BIT(x)  (1ul << (x))
  12 #define BITS_PER_LONG   (__SIZEOF_LONG__ * 8)
  13 #define GENMASK(h, l) \
  14                 (((~0UL) << (l)) & (~0UL >> (BITS_PER_LONG - 1 - (h))))
  15 #define BF_SHF(x) (__builtin_ffsll(x) - 1)
  16 #define FIELD_GET(mask, reg) \
  17                 ((typeof(mask))(((reg) & (mask)) >> BF_SHF(mask)))
  18
  19 #define lower_32_bits(x) ((uint32_t)(x))
  20 #define upper_32_bits(x) ((uint32_t)(((x) >> 16) >> 16))
  21
  22 #define PCI_VENDOR_ID_HUAWEI                    0x19e5
  23 #define HISI_DMA_DEVICE_ID                      0xA122
  24 #define HISI_DMA_PCI_REVISION_ID_REG            0x08
  25 #define HISI_DMA_REVISION_HIP08B                0x21
  26
  27 #define HISI_DMA_MAX_HW_QUEUES                  4
  28 #define HISI_DMA_MAX_DESC_NUM                   8192
  29 #define HISI_DMA_MIN_DESC_NUM                   32
  30
  31 /**
  32  * The HIP08B(HiSilicon IP08) and later Chip(e.g. HiSilicon IP09) are DMA iEPs,
  33  * they have the same pci device id but with different pci revision.
  34  * Unfortunately, they have different register layouts, so the layout
  35  * enumerations are defined.
  36  */
  37 enum {
  38         HISI_DMA_REG_LAYOUT_INVALID = 0,
  39         HISI_DMA_REG_LAYOUT_HIP08
  40 };
  41
  42 /**
  43  * Hardware PCI bar register MAP:
  44  *
  45  *     --------------
  46  *     | Misc-reg-0 |
  47  *     |            |
  48  *     --------------   -> Queue base
  49  *     |            |
  50  *     | Queue-0    |
  51  *     |            |
  52  *     --------------   ---
  53  *     |            |    ^
  54  *     | Queue-1    |   Queue region
  55  *     |            |    v
  56  *     --------------   ---
  57  *     | ...        |
  58  *     | Queue-x    |
  59  *     | ...        |
  60  *     --------------
  61  *     | Misc-reg-1 |
  62  *     --------------
  63  *
  64  * As described above, a single queue register is continuous and occupies the
  65  * length of queue-region. The global offset for a single queue register is
  66  * calculated by:
  67  *     offset = queue-base + (queue-id * queue-region) + reg-offset-in-region.
  68  *
  69  * The first part of queue region is basically the same for HIP08 and later chip
  70  * register layouts, therefore, HISI_QUEUE_* registers are defined for it.
  71  */
  72 #define HISI_DMA_QUEUE_SQ_BASE_L_REG            0x0
  73 #define HISI_DMA_QUEUE_SQ_BASE_H_REG            0x4
  74 #define HISI_DMA_QUEUE_SQ_DEPTH_REG             0x8
  75 #define HISI_DMA_QUEUE_SQ_TAIL_REG              0xC
  76 #define HISI_DMA_QUEUE_CQ_BASE_L_REG            0x10
  77 #define HISI_DMA_QUEUE_CQ_BASE_H_REG            0x14
  78 #define HISI_DMA_QUEUE_CQ_DEPTH_REG             0x18
  79 #define HISI_DMA_QUEUE_CQ_HEAD_REG              0x1C
  80 #define HISI_DMA_QUEUE_CTRL0_REG                0x20
  81 #define HISI_DMA_QUEUE_CTRL0_EN_B               0
  82 #define HISI_DMA_QUEUE_CTRL0_PAUSE_B            4
  83 #define HISI_DMA_QUEUE_CTRL1_REG                0x24
  84 #define HISI_DMA_QUEUE_CTRL1_RESET_B            0
  85 #define HISI_DMA_QUEUE_FSM_REG                  0x30
  86 #define HISI_DMA_QUEUE_FSM_STS_M                GENMASK(3, 0)
  87 #define HISI_DMA_QUEUE_INT_STATUS_REG           0x40
  88 #define HISI_DMA_QUEUE_ERR_INT_NUM0_REG         0x84
  89 #define HISI_DMA_QUEUE_ERR_INT_NUM1_REG         0x88
  90 #define HISI_DMA_QUEUE_ERR_INT_NUM2_REG         0x8C
  91 #define HISI_DMA_QUEUE_REGION_SIZE              0x100
  92
  93 /**
  94  * HiSilicon IP08 DMA register and field define:
  95  */
  96 #define HISI_DMA_HIP08_QUEUE_BASE                       0x0
  97 #define HISI_DMA_HIP08_QUEUE_CTRL0_ERR_ABORT_B          2
  98 #define HISI_DMA_HIP08_QUEUE_INT_MASK_REG               0x44
  99 #define HISI_DMA_HIP08_QUEUE_INT_MASK_M                 GENMASK(14, 0)
 100 #define HISI_DMA_HIP08_QUEUE_ERR_INT_NUM3_REG           0x90
 101 #define HISI_DMA_HIP08_QUEUE_ERR_INT_NUM4_REG           0x94
 102 #define HISI_DMA_HIP08_QUEUE_ERR_INT_NUM5_REG           0x98
 103 #define HISI_DMA_HIP08_QUEUE_ERR_INT_NUM6_REG           0x48
 104 #define HISI_DMA_HIP08_MODE_REG                         0x217C
 105 #define HISI_DMA_HIP08_MODE_SEL_B                       0
 106 #define HISI_DMA_HIP08_DUMP_START_REG                   0x2000
 107 #define HISI_DMA_HIP08_DUMP_END_REG                     0x2280
 108
 109 /**
 110  * In fact, there are multiple states, but it need to pay attention to
 111  * the following two states for the driver:
 112  */
 113 enum {
 114         HISI_DMA_STATE_IDLE = 0,
 115         HISI_DMA_STATE_RUN,
 116 };
 117
 118 /**
 119  * After scanning the CQ array, the CQ head register needs to be updated.
 120  * Updating the register involves write memory barrier operations.
 121  * Here use the following method to reduce WMB operations:
 122  *   a) malloc more CQEs, which correspond to the macro HISI_DMA_CQ_RESERVED.
 123  *   b) update the CQ head register after accumulated number of completed CQs
 124  *      is greater than or equal to HISI_DMA_CQ_RESERVED.
 125  */
 126 #define HISI_DMA_CQ_RESERVED            64
 127
 128 struct hisi_dma_sqe {
 129         uint32_t dw0;
 130 #define SQE_FENCE_FLAG  BIT(10)
 131 #define SQE_OPCODE_M2M  0x4
 132         uint32_t dw1;
 133         uint32_t dw2;
 134         uint32_t length;
 135         uint64_t src_addr;
 136         uint64_t dst_addr;
 137 };
 138
 139 struct hisi_dma_cqe {
 140         uint64_t rsv;
 141         uint64_t misc;
 142 #define CQE_SQ_HEAD_MASK        GENMASK(15, 0)
 143 #define CQE_VALID_B             BIT(48)
 144 #define CQE_STATUS_MASK         GENMASK(63, 49)
 145 };
 146
 147 struct hisi_dma_dev {
 148         struct hisi_dma_sqe *sqe;
 149         volatile struct hisi_dma_cqe *cqe;
 150         uint16_t *status; /* the completion status array of SQEs. */
 151
 152         volatile void *sq_tail_reg; /**< register address for doorbell. */
 153         volatile void *cq_head_reg; /**< register address for answer CQ. */
 154
 155         uint16_t sq_depth_mask; /**< SQ depth - 1, the SQ depth is power of 2 */
 156         uint16_t cq_depth; /* CQ depth */
 157
 158         uint16_t ridx; /**< ring index which will assign to the next request. */
 159         /** ring index which returned by hisi_dmadev_completed APIs. */
 160         uint16_t cridx;
 161
 162         /**
 163          * SQE array management fields:
 164          *
 165          *  -----------------------------------------------------
 166          *  | SQE0 | SQE1 | SQE2 |   ...  | SQEx | ... | SQEn-1 |
 167          *  -----------------------------------------------------
 168          *     ^             ^               ^
 169          *     |             |               |
 170          *   sq_head     cq_sq_head       sq_tail
 171          *
 172          *  sq_head: index to the oldest completed request, this filed was
 173          *           updated by hisi_dmadev_completed* APIs.
 174          *  sq_tail: index of the next new request, this field was updated by
 175          *           hisi_dmadev_copy API.
 176          *  cq_sq_head: next index of index that has been completed by hardware,
 177          *              this filed was updated by hisi_dmadev_completed* APIs.
 178          *
 179          *  [sq_head, cq_sq_head): the SQEs that hardware already completed.
 180          *  [cq_sq_head, sq_tail): the SQEs that hardware processing.
 181          */
 182         uint16_t sq_head;
 183         uint16_t sq_tail;
 184         uint16_t cq_sq_head;
 185         /**
 186          * The driver scans the CQE array, if the valid bit changes, the CQE is
 187          * considered valid.
 188          * Note: One CQE is corresponding to one or several SQEs, e.g. app
 189          *       submits two copy requests, the hardware processes the two SQEs,
 190          *       but it may write back only one CQE and the CQE's sq_head field
 191          *       indicates the index of the second copy request in the SQE
 192          *       array.
 193          */
 194         uint16_t cq_head; /**< CQ index for next scans. */
 195         /** accumulated number of completed CQs
 196          * @see HISI_DMA_CQ_RESERVED
 197          */
 198         uint16_t cqs_completed;
 199         uint8_t cqe_vld; /**< valid bit for CQE, will change for every round. */
 200
 201         uint64_t submitted;
 202         uint64_t completed;
 203         uint64_t errors;
 204
 205         /**
 206          * The following fields are not accessed in the I/O path, so they are
 207          * placed at the end.
 208          */
 209         struct rte_dma_dev_data *data;
 210         uint8_t revision; /**< PCI revision. */
 211         uint8_t reg_layout; /**< hardware register layout. */
 212         void *io_base;
 213         uint8_t queue_id; /**< hardware DMA queue index. */
 214         const struct rte_memzone *iomz;
 215         uint32_t iomz_sz;
 216         rte_iova_t sqe_iova;
 217         rte_iova_t cqe_iova;
 218 };
 219
 220 #endif /* HISI_DMADEV_H */