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  * Hardware complete status define:
 120  */
 121 #define HISI_DMA_STATUS_SUCCESS                 0x0
 122 #define HISI_DMA_STATUS_INVALID_OPCODE          0x1
 123 #define HISI_DMA_STATUS_INVALID_LENGTH          0x2
 124 #define HISI_DMA_STATUS_USER_ABORT              0x4
 125 #define HISI_DMA_STATUS_REMOTE_READ_ERROR       0x10
 126 #define HISI_DMA_STATUS_AXI_READ_ERROR          0x20
 127 #define HISI_DMA_STATUS_AXI_WRITE_ERROR         0x40
 128 #define HISI_DMA_STATUS_DATA_POISON             0x80
 129 #define HISI_DMA_STATUS_SQE_READ_ERROR          0x100
 130 #define HISI_DMA_STATUS_SQE_READ_POISION        0x200
 131 #define HISI_DMA_STATUS_REMOTE_DATA_POISION     0x400
 132 #define HISI_DMA_STATUS_LINK_DOWN_ERROR         0x800
 133
 134 /**
 135  * After scanning the CQ array, the CQ head register needs to be updated.
 136  * Updating the register involves write memory barrier operations.
 137  * Here use the following method to reduce WMB operations:
 138  *   a) malloc more CQEs, which correspond to the macro HISI_DMA_CQ_RESERVED.
 139  *   b) update the CQ head register after accumulated number of completed CQs
 140  *      is greater than or equal to HISI_DMA_CQ_RESERVED.
 141  */
 142 #define HISI_DMA_CQ_RESERVED            64
 143
 144 struct hisi_dma_sqe {
 145         uint32_t dw0;
 146 #define SQE_FENCE_FLAG  BIT(10)
 147 #define SQE_OPCODE_M2M  0x4
 148         uint32_t dw1;
 149         uint32_t dw2;
 150         uint32_t length;
 151         uint64_t src_addr;
 152         uint64_t dst_addr;
 153 };
 154
 155 struct hisi_dma_cqe {
 156         uint64_t rsv;
 157         uint64_t misc;
 158 #define CQE_SQ_HEAD_MASK        GENMASK(15, 0)
 159 #define CQE_VALID_B             BIT(48)
 160 #define CQE_STATUS_MASK         GENMASK(63, 49)
 161 };
 162
 163 struct hisi_dma_dev {
 164         struct hisi_dma_sqe *sqe;
 165         volatile struct hisi_dma_cqe *cqe;
 166         uint16_t *status; /* the completion status array of SQEs. */
 167
 168         volatile void *sq_tail_reg; /**< register address for doorbell. */
 169         volatile void *cq_head_reg; /**< register address for answer CQ. */
 170
 171         uint16_t sq_depth_mask; /**< SQ depth - 1, the SQ depth is power of 2 */
 172         uint16_t cq_depth; /* CQ depth */
 173
 174         uint16_t ridx; /**< ring index which will assign to the next request. */
 175         /** ring index which returned by hisi_dmadev_completed APIs. */
 176         uint16_t cridx;
 177
 178         /**
 179          * SQE array management fields:
 180          *
 181          *  -----------------------------------------------------
 182          *  | SQE0 | SQE1 | SQE2 |   ...  | SQEx | ... | SQEn-1 |
 183          *  -----------------------------------------------------
 184          *     ^             ^               ^
 185          *     |             |               |
 186          *   sq_head     cq_sq_head       sq_tail
 187          *
 188          *  sq_head: index to the oldest completed request, this filed was
 189          *           updated by hisi_dmadev_completed* APIs.
 190          *  sq_tail: index of the next new request, this field was updated by
 191          *           hisi_dmadev_copy API.
 192          *  cq_sq_head: next index of index that has been completed by hardware,
 193          *              this filed was updated by hisi_dmadev_completed* APIs.
 194          *
 195          *  [sq_head, cq_sq_head): the SQEs that hardware already completed.
 196          *  [cq_sq_head, sq_tail): the SQEs that hardware processing.
 197          */
 198         uint16_t sq_head;
 199         uint16_t sq_tail;
 200         uint16_t cq_sq_head;
 201         /**
 202          * The driver scans the CQE array, if the valid bit changes, the CQE is
 203          * considered valid.
 204          * Note: One CQE is corresponding to one or several SQEs, e.g. app
 205          *       submits two copy requests, the hardware processes the two SQEs,
 206          *       but it may write back only one CQE and the CQE's sq_head field
 207          *       indicates the index of the second copy request in the SQE
 208          *       array.
 209          */
 210         uint16_t cq_head; /**< CQ index for next scans. */
 211         /** accumulated number of completed CQs
 212          * @see HISI_DMA_CQ_RESERVED
 213          */
 214         uint16_t cqs_completed;
 215         uint8_t cqe_vld; /**< valid bit for CQE, will change for every round. */
 216
 217         uint64_t submitted;
 218         uint64_t completed;
 219         uint64_t errors;
 220
 221         /**
 222          * The following fields are not accessed in the I/O path, so they are
 223          * placed at the end.
 224          */
 225         struct rte_dma_dev_data *data;
 226         uint8_t revision; /**< PCI revision. */
 227         uint8_t reg_layout; /**< hardware register layout. */
 228         void *io_base;
 229         uint8_t queue_id; /**< hardware DMA queue index. */
 230         const struct rte_memzone *iomz;
 231         uint32_t iomz_sz;
 232         rte_iova_t sqe_iova;
 233         rte_iova_t cqe_iova;
 234 };
 235
 236 #endif /* HISI_DMADEV_H */