hw/dma/xlnx-zdma.c

   1 /*
   2  * QEMU model of the ZynqMP generic DMA
   3  *
   4  * Copyright (c) 2014 Xilinx Inc.
   5  * Copyright (c) 2018 FEIMTECH AB
   6  *
   7  * Written by Edgar E. Iglesias <[email protected]>,
   8  *            Francisco Iglesias <[email protected]>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  26  * THE SOFTWARE.
  27  */
  28
  29 #include "qemu/osdep.h"
  30 #include "hw/dma/xlnx-zdma.h"
  31 #include "hw/irq.h"
  32 #include "hw/qdev-properties.h"
  33 #include "migration/vmstate.h"
  34 #include "qemu/bitops.h"
  35 #include "qemu/log.h"
  36 #include "qemu/module.h"
  37 #include "qapi/error.h"
  38
  39 #ifndef XLNX_ZDMA_ERR_DEBUG
  40 #define XLNX_ZDMA_ERR_DEBUG 0
  41 #endif
  42
  43 REG32(ZDMA_ERR_CTRL, 0x0)
  44     FIELD(ZDMA_ERR_CTRL, APB_ERR_RES, 0, 1)
  45 REG32(ZDMA_CH_ISR, 0x100)
  46     FIELD(ZDMA_CH_ISR, DMA_PAUSE, 11, 1)
  47     FIELD(ZDMA_CH_ISR, DMA_DONE, 10, 1)
  48     FIELD(ZDMA_CH_ISR, AXI_WR_DATA, 9, 1)
  49     FIELD(ZDMA_CH_ISR, AXI_RD_DATA, 8, 1)
  50     FIELD(ZDMA_CH_ISR, AXI_RD_DST_DSCR, 7, 1)
  51     FIELD(ZDMA_CH_ISR, AXI_RD_SRC_DSCR, 6, 1)
  52     FIELD(ZDMA_CH_ISR, IRQ_DST_ACCT_ERR, 5, 1)
  53     FIELD(ZDMA_CH_ISR, IRQ_SRC_ACCT_ERR, 4, 1)
  54     FIELD(ZDMA_CH_ISR, BYTE_CNT_OVRFL, 3, 1)
  55     FIELD(ZDMA_CH_ISR, DST_DSCR_DONE, 2, 1)
  56     FIELD(ZDMA_CH_ISR, SRC_DSCR_DONE, 1, 1)
  57     FIELD(ZDMA_CH_ISR, INV_APB, 0, 1)
  58 REG32(ZDMA_CH_IMR, 0x104)
  59     FIELD(ZDMA_CH_IMR, DMA_PAUSE, 11, 1)
  60     FIELD(ZDMA_CH_IMR, DMA_DONE, 10, 1)
  61     FIELD(ZDMA_CH_IMR, AXI_WR_DATA, 9, 1)
  62     FIELD(ZDMA_CH_IMR, AXI_RD_DATA, 8, 1)
  63     FIELD(ZDMA_CH_IMR, AXI_RD_DST_DSCR, 7, 1)
  64     FIELD(ZDMA_CH_IMR, AXI_RD_SRC_DSCR, 6, 1)
  65     FIELD(ZDMA_CH_IMR, IRQ_DST_ACCT_ERR, 5, 1)
  66     FIELD(ZDMA_CH_IMR, IRQ_SRC_ACCT_ERR, 4, 1)
  67     FIELD(ZDMA_CH_IMR, BYTE_CNT_OVRFL, 3, 1)
  68     FIELD(ZDMA_CH_IMR, DST_DSCR_DONE, 2, 1)
  69     FIELD(ZDMA_CH_IMR, SRC_DSCR_DONE, 1, 1)
  70     FIELD(ZDMA_CH_IMR, INV_APB, 0, 1)
  71 REG32(ZDMA_CH_IEN, 0x108)
  72     FIELD(ZDMA_CH_IEN, DMA_PAUSE, 11, 1)
  73     FIELD(ZDMA_CH_IEN, DMA_DONE, 10, 1)
  74     FIELD(ZDMA_CH_IEN, AXI_WR_DATA, 9, 1)
  75     FIELD(ZDMA_CH_IEN, AXI_RD_DATA, 8, 1)
  76     FIELD(ZDMA_CH_IEN, AXI_RD_DST_DSCR, 7, 1)
  77     FIELD(ZDMA_CH_IEN, AXI_RD_SRC_DSCR, 6, 1)
  78     FIELD(ZDMA_CH_IEN, IRQ_DST_ACCT_ERR, 5, 1)
  79     FIELD(ZDMA_CH_IEN, IRQ_SRC_ACCT_ERR, 4, 1)
  80     FIELD(ZDMA_CH_IEN, BYTE_CNT_OVRFL, 3, 1)
  81     FIELD(ZDMA_CH_IEN, DST_DSCR_DONE, 2, 1)
  82     FIELD(ZDMA_CH_IEN, SRC_DSCR_DONE, 1, 1)
  83     FIELD(ZDMA_CH_IEN, INV_APB, 0, 1)
  84 REG32(ZDMA_CH_IDS, 0x10c)
  85     FIELD(ZDMA_CH_IDS, DMA_PAUSE, 11, 1)
  86     FIELD(ZDMA_CH_IDS, DMA_DONE, 10, 1)
  87     FIELD(ZDMA_CH_IDS, AXI_WR_DATA, 9, 1)
  88     FIELD(ZDMA_CH_IDS, AXI_RD_DATA, 8, 1)
  89     FIELD(ZDMA_CH_IDS, AXI_RD_DST_DSCR, 7, 1)
  90     FIELD(ZDMA_CH_IDS, AXI_RD_SRC_DSCR, 6, 1)
  91     FIELD(ZDMA_CH_IDS, IRQ_DST_ACCT_ERR, 5, 1)
  92     FIELD(ZDMA_CH_IDS, IRQ_SRC_ACCT_ERR, 4, 1)
  93     FIELD(ZDMA_CH_IDS, BYTE_CNT_OVRFL, 3, 1)
  94     FIELD(ZDMA_CH_IDS, DST_DSCR_DONE, 2, 1)
  95     FIELD(ZDMA_CH_IDS, SRC_DSCR_DONE, 1, 1)
  96     FIELD(ZDMA_CH_IDS, INV_APB, 0, 1)
  97 REG32(ZDMA_CH_CTRL0, 0x110)
  98     FIELD(ZDMA_CH_CTRL0, OVR_FETCH, 7, 1)
  99     FIELD(ZDMA_CH_CTRL0, POINT_TYPE, 6, 1)
 100     FIELD(ZDMA_CH_CTRL0, MODE, 4, 2)
 101     FIELD(ZDMA_CH_CTRL0, RATE_CTRL, 3, 1)
 102     FIELD(ZDMA_CH_CTRL0, CONT_ADDR, 2, 1)
 103     FIELD(ZDMA_CH_CTRL0, CONT, 1, 1)
 104 REG32(ZDMA_CH_CTRL1, 0x114)
 105     FIELD(ZDMA_CH_CTRL1, DST_ISSUE, 5, 5)
 106     FIELD(ZDMA_CH_CTRL1, SRC_ISSUE, 0, 5)
 107 REG32(ZDMA_CH_FCI, 0x118)
 108     FIELD(ZDMA_CH_FCI, PROG_CELL_CNT, 2, 2)
 109     FIELD(ZDMA_CH_FCI, SIDE, 1, 1)
 110     FIELD(ZDMA_CH_FCI, EN, 0, 1)
 111 REG32(ZDMA_CH_STATUS, 0x11c)
 112     FIELD(ZDMA_CH_STATUS, STATE, 0, 2)
 113 REG32(ZDMA_CH_DATA_ATTR, 0x120)
 114     FIELD(ZDMA_CH_DATA_ATTR, ARBURST, 26, 2)
 115     FIELD(ZDMA_CH_DATA_ATTR, ARCACHE, 22, 4)
 116     FIELD(ZDMA_CH_DATA_ATTR, ARQOS, 18, 4)
 117     FIELD(ZDMA_CH_DATA_ATTR, ARLEN, 14, 4)
 118     FIELD(ZDMA_CH_DATA_ATTR, AWBURST, 12, 2)
 119     FIELD(ZDMA_CH_DATA_ATTR, AWCACHE, 8, 4)
 120     FIELD(ZDMA_CH_DATA_ATTR, AWQOS, 4, 4)
 121     FIELD(ZDMA_CH_DATA_ATTR, AWLEN, 0, 4)
 122 REG32(ZDMA_CH_DSCR_ATTR, 0x124)
 123     FIELD(ZDMA_CH_DSCR_ATTR, AXCOHRNT, 8, 1)
 124     FIELD(ZDMA_CH_DSCR_ATTR, AXCACHE, 4, 4)
 125     FIELD(ZDMA_CH_DSCR_ATTR, AXQOS, 0, 4)
 126 REG32(ZDMA_CH_SRC_DSCR_WORD0, 0x128)
 127 REG32(ZDMA_CH_SRC_DSCR_WORD1, 0x12c)
 128     FIELD(ZDMA_CH_SRC_DSCR_WORD1, MSB, 0, 17)
 129 REG32(ZDMA_CH_SRC_DSCR_WORD2, 0x130)
 130     FIELD(ZDMA_CH_SRC_DSCR_WORD2, SIZE, 0, 30)
 131 REG32(ZDMA_CH_SRC_DSCR_WORD3, 0x134)
 132     FIELD(ZDMA_CH_SRC_DSCR_WORD3, CMD, 3, 2)
 133     FIELD(ZDMA_CH_SRC_DSCR_WORD3, INTR, 2, 1)
 134     FIELD(ZDMA_CH_SRC_DSCR_WORD3, TYPE, 1, 1)
 135     FIELD(ZDMA_CH_SRC_DSCR_WORD3, COHRNT, 0, 1)
 136 REG32(ZDMA_CH_DST_DSCR_WORD0, 0x138)
 137 REG32(ZDMA_CH_DST_DSCR_WORD1, 0x13c)
 138     FIELD(ZDMA_CH_DST_DSCR_WORD1, MSB, 0, 17)
 139 REG32(ZDMA_CH_DST_DSCR_WORD2, 0x140)
 140     FIELD(ZDMA_CH_DST_DSCR_WORD2, SIZE, 0, 30)
 141 REG32(ZDMA_CH_DST_DSCR_WORD3, 0x144)
 142     FIELD(ZDMA_CH_DST_DSCR_WORD3, INTR, 2, 1)
 143     FIELD(ZDMA_CH_DST_DSCR_WORD3, TYPE, 1, 1)
 144     FIELD(ZDMA_CH_DST_DSCR_WORD3, COHRNT, 0, 1)
 145 REG32(ZDMA_CH_WR_ONLY_WORD0, 0x148)
 146 REG32(ZDMA_CH_WR_ONLY_WORD1, 0x14c)
 147 REG32(ZDMA_CH_WR_ONLY_WORD2, 0x150)
 148 REG32(ZDMA_CH_WR_ONLY_WORD3, 0x154)
 149 REG32(ZDMA_CH_SRC_START_LSB, 0x158)
 150 REG32(ZDMA_CH_SRC_START_MSB, 0x15c)
 151     FIELD(ZDMA_CH_SRC_START_MSB, ADDR, 0, 17)
 152 REG32(ZDMA_CH_DST_START_LSB, 0x160)
 153 REG32(ZDMA_CH_DST_START_MSB, 0x164)
 154     FIELD(ZDMA_CH_DST_START_MSB, ADDR, 0, 17)
 155 REG32(ZDMA_CH_RATE_CTRL, 0x18c)
 156     FIELD(ZDMA_CH_RATE_CTRL, CNT, 0, 12)
 157 REG32(ZDMA_CH_SRC_CUR_PYLD_LSB, 0x168)
 158 REG32(ZDMA_CH_SRC_CUR_PYLD_MSB, 0x16c)
 159     FIELD(ZDMA_CH_SRC_CUR_PYLD_MSB, ADDR, 0, 17)
 160 REG32(ZDMA_CH_DST_CUR_PYLD_LSB, 0x170)
 161 REG32(ZDMA_CH_DST_CUR_PYLD_MSB, 0x174)
 162     FIELD(ZDMA_CH_DST_CUR_PYLD_MSB, ADDR, 0, 17)
 163 REG32(ZDMA_CH_SRC_CUR_DSCR_LSB, 0x178)
 164 REG32(ZDMA_CH_SRC_CUR_DSCR_MSB, 0x17c)
 165     FIELD(ZDMA_CH_SRC_CUR_DSCR_MSB, ADDR, 0, 17)
 166 REG32(ZDMA_CH_DST_CUR_DSCR_LSB, 0x180)
 167 REG32(ZDMA_CH_DST_CUR_DSCR_MSB, 0x184)
 168     FIELD(ZDMA_CH_DST_CUR_DSCR_MSB, ADDR, 0, 17)
 169 REG32(ZDMA_CH_TOTAL_BYTE, 0x188)
 170 REG32(ZDMA_CH_RATE_CNTL, 0x18c)
 171     FIELD(ZDMA_CH_RATE_CNTL, CNT, 0, 12)
 172 REG32(ZDMA_CH_IRQ_SRC_ACCT, 0x190)
 173     FIELD(ZDMA_CH_IRQ_SRC_ACCT, CNT, 0, 8)
 174 REG32(ZDMA_CH_IRQ_DST_ACCT, 0x194)
 175     FIELD(ZDMA_CH_IRQ_DST_ACCT, CNT, 0, 8)
 176 REG32(ZDMA_CH_DBG0, 0x198)
 177     FIELD(ZDMA_CH_DBG0, CMN_BUF_FREE, 0, 9)
 178 REG32(ZDMA_CH_DBG1, 0x19c)
 179     FIELD(ZDMA_CH_DBG1, CMN_BUF_OCC, 0, 9)
 180 REG32(ZDMA_CH_CTRL2, 0x200)
 181     FIELD(ZDMA_CH_CTRL2, EN, 0, 1)
 182
 183 enum {
 184     PT_REG = 0,
 185     PT_MEM = 1,
 186 };
 187
 188 enum {
 189     CMD_HALT = 1,
 190     CMD_STOP = 2,
 191 };
 192
 193 enum {
 194     RW_MODE_RW = 0,
 195     RW_MODE_WO = 1,
 196     RW_MODE_RO = 2,
 197 };
 198
 199 enum {
 200     DTYPE_LINEAR = 0,
 201     DTYPE_LINKED = 1,
 202 };
 203
 204 enum {
 205     AXI_BURST_FIXED = 0,
 206     AXI_BURST_INCR  = 1,
 207 };
 208
 209 static void zdma_ch_imr_update_irq(XlnxZDMA *s)
 210 {
 211     bool pending;
 212
 213     pending = s->regs[R_ZDMA_CH_ISR] & ~s->regs[R_ZDMA_CH_IMR];
 214
 215     qemu_set_irq(s->irq_zdma_ch_imr, pending);
 216 }
 217
 218 static void zdma_ch_isr_postw(RegisterInfo *reg, uint64_t val64)
 219 {
 220     XlnxZDMA *s = XLNX_ZDMA(reg->opaque);
 221     zdma_ch_imr_update_irq(s);
 222 }
 223
 224 static uint64_t zdma_ch_ien_prew(RegisterInfo *reg, uint64_t val64)
 225 {
 226     XlnxZDMA *s = XLNX_ZDMA(reg->opaque);
 227     uint32_t val = val64;
 228
 229     s->regs[R_ZDMA_CH_IMR] &= ~val;
 230     zdma_ch_imr_update_irq(s);
 231     return 0;
 232 }
 233
 234 static uint64_t zdma_ch_ids_prew(RegisterInfo *reg, uint64_t val64)
 235 {
 236     XlnxZDMA *s = XLNX_ZDMA(reg->opaque);
 237     uint32_t val = val64;
 238
 239     s->regs[R_ZDMA_CH_IMR] |= val;
 240     zdma_ch_imr_update_irq(s);
 241     return 0;
 242 }
 243
 244 static void zdma_set_state(XlnxZDMA *s, XlnxZDMAState state)
 245 {
 246     s->state = state;
 247     ARRAY_FIELD_DP32(s->regs, ZDMA_CH_STATUS, STATE, state);
 248
 249     /* Signal error if we have an error condition.  */
 250     if (s->error) {
 251         ARRAY_FIELD_DP32(s->regs, ZDMA_CH_STATUS, STATE, 3);
 252     }
 253 }
 254
 255 static void zdma_src_done(XlnxZDMA *s)
 256 {
 257     unsigned int cnt;
 258     cnt = ARRAY_FIELD_EX32(s->regs, ZDMA_CH_IRQ_SRC_ACCT, CNT);
 259     cnt++;
 260     ARRAY_FIELD_DP32(s->regs, ZDMA_CH_IRQ_SRC_ACCT, CNT, cnt);
 261     ARRAY_FIELD_DP32(s->regs, ZDMA_CH_ISR, SRC_DSCR_DONE, true);
 262
 263     /* Did we overflow?  */
 264     if (cnt != ARRAY_FIELD_EX32(s->regs, ZDMA_CH_IRQ_SRC_ACCT, CNT)) {
 265         ARRAY_FIELD_DP32(s->regs, ZDMA_CH_ISR, IRQ_SRC_ACCT_ERR, true);
 266     }
 267     zdma_ch_imr_update_irq(s);
 268 }
 269
 270 static void zdma_dst_done(XlnxZDMA *s)
 271 {
 272     unsigned int cnt;
 273     cnt = ARRAY_FIELD_EX32(s->regs, ZDMA_CH_IRQ_DST_ACCT, CNT);
 274     cnt++;
 275     ARRAY_FIELD_DP32(s->regs, ZDMA_CH_IRQ_DST_ACCT, CNT, cnt);
 276     ARRAY_FIELD_DP32(s->regs, ZDMA_CH_ISR, DST_DSCR_DONE, true);
 277
 278     /* Did we overflow?  */
 279     if (cnt != ARRAY_FIELD_EX32(s->regs, ZDMA_CH_IRQ_DST_ACCT, CNT)) {
 280         ARRAY_FIELD_DP32(s->regs, ZDMA_CH_ISR, IRQ_DST_ACCT_ERR, true);
 281     }
 282     zdma_ch_imr_update_irq(s);
 283 }
 284
 285 static uint64_t zdma_get_regaddr64(XlnxZDMA *s, unsigned int basereg)
 286 {
 287     uint64_t addr;
 288
 289     addr = s->regs[basereg + 1];
 290     addr <<= 32;
 291     addr |= s->regs[basereg];
 292
 293     return addr;
 294 }
 295
 296 static void zdma_put_regaddr64(XlnxZDMA *s, unsigned int basereg, uint64_t addr)
 297 {
 298     s->regs[basereg] = addr;
 299     s->regs[basereg + 1] = addr >> 32;
 300 }
 301
 302 static bool zdma_load_descriptor(XlnxZDMA *s, uint64_t addr, void *buf)
 303 {
 304     /* ZDMA descriptors must be aligned to their own size.  */
 305     if (addr % sizeof(XlnxZDMADescr)) {
 306         qemu_log_mask(LOG_GUEST_ERROR,
 307                       "zdma: unaligned descriptor at %" PRIx64,
 308                       addr);
 309         memset(buf, 0x0, sizeof(XlnxZDMADescr));
 310         s->error = true;
 311         return false;
 312     }
 313
 314     address_space_rw(s->dma_as, addr, s->attr,
 315                      buf, sizeof(XlnxZDMADescr), false);
 316     return true;
 317 }
 318
 319 static void zdma_load_src_descriptor(XlnxZDMA *s)
 320 {
 321     uint64_t src_addr;
 322     unsigned int ptype = ARRAY_FIELD_EX32(s->regs, ZDMA_CH_CTRL0, POINT_TYPE);
 323
 324     if (ptype == PT_REG) {
 325         memcpy(&s->dsc_src, &s->regs[R_ZDMA_CH_SRC_DSCR_WORD0],
 326                sizeof(s->dsc_src));
 327         return;
 328     }
 329
 330     src_addr = zdma_get_regaddr64(s, R_ZDMA_CH_SRC_CUR_DSCR_LSB);
 331
 332     if (!zdma_load_descriptor(s, src_addr, &s->dsc_src)) {
 333         ARRAY_FIELD_DP32(s->regs, ZDMA_CH_ISR, AXI_RD_SRC_DSCR, true);
 334     }
 335 }
 336
 337 static void zdma_load_dst_descriptor(XlnxZDMA *s)
 338 {
 339     uint64_t dst_addr;
 340     unsigned int ptype = ARRAY_FIELD_EX32(s->regs, ZDMA_CH_CTRL0, POINT_TYPE);
 341
 342     if (ptype == PT_REG) {
 343         memcpy(&s->dsc_dst, &s->regs[R_ZDMA_CH_DST_DSCR_WORD0],
 344                sizeof(s->dsc_dst));
 345         return;
 346     }
 347
 348     dst_addr = zdma_get_regaddr64(s, R_ZDMA_CH_DST_CUR_DSCR_LSB);
 349
 350     if (!zdma_load_descriptor(s, dst_addr, &s->dsc_dst)) {
 351         ARRAY_FIELD_DP32(s->regs, ZDMA_CH_ISR, AXI_RD_DST_DSCR, true);
 352     }
 353 }
 354
 355 static uint64_t zdma_update_descr_addr(XlnxZDMA *s, bool type,
 356                                        unsigned int basereg)
 357 {
 358     uint64_t addr, next;
 359
 360     if (type == DTYPE_LINEAR) {
 361         next = zdma_get_regaddr64(s, basereg);
 362         next += sizeof(s->dsc_dst);
 363         zdma_put_regaddr64(s, basereg, next);
 364     } else {
 365         addr = zdma_get_regaddr64(s, basereg);
 366         addr += sizeof(s->dsc_dst);
 367         address_space_rw(s->dma_as, addr, s->attr, (void *) &next, 8, false);
 368         zdma_put_regaddr64(s, basereg, next);
 369     }
 370     return next;
 371 }
 372
 373 static void zdma_write_dst(XlnxZDMA *s, uint8_t *buf, uint32_t len)
 374 {
 375     uint32_t dst_size, dlen;
 376     bool dst_intr, dst_type;
 377     unsigned int ptype = ARRAY_FIELD_EX32(s->regs, ZDMA_CH_CTRL0, POINT_TYPE);
 378     unsigned int rw_mode = ARRAY_FIELD_EX32(s->regs, ZDMA_CH_CTRL0, MODE);
 379     unsigned int burst_type = ARRAY_FIELD_EX32(s->regs, ZDMA_CH_DATA_ATTR,
 380                                                AWBURST);
 381
 382     /* FIXED burst types are only supported in simple dma mode.  */
 383     if (ptype != PT_REG) {
 384         burst_type = AXI_BURST_INCR;
 385     }
 386
 387     while (len) {
 388         dst_size = FIELD_EX32(s->dsc_dst.words[2], ZDMA_CH_DST_DSCR_WORD2,
 389                               SIZE);
 390         dst_type = FIELD_EX32(s->dsc_dst.words[3], ZDMA_CH_DST_DSCR_WORD3,
 391                               TYPE);
 392         if (dst_size == 0 && ptype == PT_MEM) {
 393             uint64_t next;
 394             next = zdma_update_descr_addr(s, dst_type,
 395                                           R_ZDMA_CH_DST_CUR_DSCR_LSB);
 396             zdma_load_descriptor(s, next, &s->dsc_dst);
 397             dst_size = FIELD_EX32(s->dsc_dst.words[2], ZDMA_CH_DST_DSCR_WORD2,
 398                                   SIZE);
 399             dst_type = FIELD_EX32(s->dsc_dst.words[3], ZDMA_CH_DST_DSCR_WORD3,
 400                                   TYPE);
 401         }
 402
 403         /* Match what hardware does by ignoring the dst_size and only using
 404          * the src size for Simple register mode.  */
 405         if (ptype == PT_REG && rw_mode != RW_MODE_WO) {
 406             dst_size = len;
 407         }
 408
 409         dst_intr = FIELD_EX32(s->dsc_dst.words[3], ZDMA_CH_DST_DSCR_WORD3,
 410                               INTR);
 411
 412         dlen = len > dst_size ? dst_size : len;
 413         if (burst_type == AXI_BURST_FIXED) {
 414             if (dlen > (s->cfg.bus_width / 8)) {
 415                 dlen = s->cfg.bus_width / 8;
 416             }
 417         }
 418
 419         address_space_rw(s->dma_as, s->dsc_dst.addr, s->attr, buf, dlen,
 420                          true);
 421         if (burst_type == AXI_BURST_INCR) {
 422             s->dsc_dst.addr += dlen;
 423         }
 424         dst_size -= dlen;
 425         buf += dlen;
 426         len -= dlen;
 427
 428         if (dst_size == 0 && dst_intr) {
 429             zdma_dst_done(s);
 430         }
 431
 432         /* Write back to buffered descriptor.  */
 433         s->dsc_dst.words[2] = FIELD_DP32(s->dsc_dst.words[2],
 434                                          ZDMA_CH_DST_DSCR_WORD2,
 435                                          SIZE,
 436                                          dst_size);
 437     }
 438 }
 439
 440 static void zdma_process_descr(XlnxZDMA *s)
 441 {
 442     uint64_t src_addr;
 443     uint32_t src_size, len;
 444     unsigned int src_cmd;
 445     bool src_intr, src_type;
 446     unsigned int ptype = ARRAY_FIELD_EX32(s->regs, ZDMA_CH_CTRL0, POINT_TYPE);
 447     unsigned int rw_mode = ARRAY_FIELD_EX32(s->regs, ZDMA_CH_CTRL0, MODE);
 448     unsigned int burst_type = ARRAY_FIELD_EX32(s->regs, ZDMA_CH_DATA_ATTR,
 449                                                ARBURST);
 450
 451     src_addr = s->dsc_src.addr;
 452     src_size = FIELD_EX32(s->dsc_src.words[2], ZDMA_CH_SRC_DSCR_WORD2, SIZE);
 453     src_cmd = FIELD_EX32(s->dsc_src.words[3], ZDMA_CH_SRC_DSCR_WORD3, CMD);
 454     src_type = FIELD_EX32(s->dsc_src.words[3], ZDMA_CH_SRC_DSCR_WORD3, TYPE);
 455     src_intr = FIELD_EX32(s->dsc_src.words[3], ZDMA_CH_SRC_DSCR_WORD3, INTR);
 456
 457     /* FIXED burst types and non-rw modes are only supported in
 458      * simple dma mode.
 459      */
 460     if (ptype != PT_REG) {
 461         if (rw_mode != RW_MODE_RW) {
 462             qemu_log_mask(LOG_GUEST_ERROR,
 463                           "zDMA: rw-mode=%d but not simple DMA mode.\n",
 464                           rw_mode);
 465         }
 466         if (burst_type != AXI_BURST_INCR) {
 467             qemu_log_mask(LOG_GUEST_ERROR,
 468                           "zDMA: burst_type=%d but not simple DMA mode.\n",
 469                           burst_type);
 470         }
 471         burst_type = AXI_BURST_INCR;
 472         rw_mode = RW_MODE_RW;
 473     }
 474
 475     if (rw_mode == RW_MODE_WO) {
 476         /* In Simple DMA Write-Only, we need to push DST size bytes
 477          * regardless of what SRC size is set to.  */
 478         src_size = FIELD_EX32(s->dsc_dst.words[2], ZDMA_CH_DST_DSCR_WORD2,
 479                               SIZE);
 480         memcpy(s->buf, &s->regs[R_ZDMA_CH_WR_ONLY_WORD0], s->cfg.bus_width / 8);
 481     }
 482
 483     while (src_size) {
 484         len = src_size > ARRAY_SIZE(s->buf) ? ARRAY_SIZE(s->buf) : src_size;
 485         if (burst_type == AXI_BURST_FIXED) {
 486             if (len > (s->cfg.bus_width / 8)) {
 487                 len = s->cfg.bus_width / 8;
 488             }
 489         }
 490
 491         if (rw_mode == RW_MODE_WO) {
 492             if (len > s->cfg.bus_width / 8) {
 493                 len = s->cfg.bus_width / 8;
 494             }
 495         } else {
 496             address_space_rw(s->dma_as, src_addr, s->attr, s->buf, len,
 497                              false);
 498             if (burst_type == AXI_BURST_INCR) {
 499                 src_addr += len;
 500             }
 501         }
 502
 503         if (rw_mode != RW_MODE_RO) {
 504             zdma_write_dst(s, s->buf, len);
 505         }
 506
 507         s->regs[R_ZDMA_CH_TOTAL_BYTE] += len;
 508         src_size -= len;
 509     }
 510
 511     ARRAY_FIELD_DP32(s->regs, ZDMA_CH_ISR, DMA_DONE, true);
 512
 513     if (src_intr) {
 514         zdma_src_done(s);
 515     }
 516
 517     /* Load next descriptor.  */
 518     if (ptype == PT_REG || src_cmd == CMD_STOP) {
 519         ARRAY_FIELD_DP32(s->regs, ZDMA_CH_CTRL2, EN, 0);
 520         zdma_set_state(s, DISABLED);
 521         return;
 522     }
 523
 524     if (src_cmd == CMD_HALT) {
 525         zdma_set_state(s, PAUSED);
 526         ARRAY_FIELD_DP32(s->regs, ZDMA_CH_ISR, DMA_PAUSE, 1);
 527         zdma_ch_imr_update_irq(s);
 528         return;
 529     }
 530
 531     zdma_update_descr_addr(s, src_type, R_ZDMA_CH_SRC_CUR_DSCR_LSB);
 532 }
 533
 534 static void zdma_run(XlnxZDMA *s)
 535 {
 536     while (s->state == ENABLED && !s->error) {
 537         zdma_load_src_descriptor(s);
 538
 539         if (s->error) {
 540             zdma_set_state(s, DISABLED);
 541         } else {
 542             zdma_process_descr(s);
 543         }
 544     }
 545
 546     zdma_ch_imr_update_irq(s);
 547 }
 548
 549 static void zdma_update_descr_addr_from_start(XlnxZDMA *s)
 550 {
 551     uint64_t src_addr, dst_addr;
 552
 553     src_addr = zdma_get_regaddr64(s, R_ZDMA_CH_SRC_START_LSB);
 554     zdma_put_regaddr64(s, R_ZDMA_CH_SRC_CUR_DSCR_LSB, src_addr);
 555     dst_addr = zdma_get_regaddr64(s, R_ZDMA_CH_DST_START_LSB);
 556     zdma_put_regaddr64(s, R_ZDMA_CH_DST_CUR_DSCR_LSB, dst_addr);
 557     zdma_load_dst_descriptor(s);
 558 }
 559
 560 static void zdma_ch_ctrlx_postw(RegisterInfo *reg, uint64_t val64)
 561 {
 562     XlnxZDMA *s = XLNX_ZDMA(reg->opaque);
 563
 564     if (ARRAY_FIELD_EX32(s->regs, ZDMA_CH_CTRL2, EN)) {
 565         s->error = false;
 566
 567         if (s->state == PAUSED &&
 568             ARRAY_FIELD_EX32(s->regs, ZDMA_CH_CTRL0, CONT)) {
 569             if (ARRAY_FIELD_EX32(s->regs, ZDMA_CH_CTRL0, CONT_ADDR) == 1) {
 570                 zdma_update_descr_addr_from_start(s);
 571             } else {
 572                 bool src_type = FIELD_EX32(s->dsc_src.words[3],
 573                                        ZDMA_CH_SRC_DSCR_WORD3, TYPE);
 574                 zdma_update_descr_addr(s, src_type,
 575                                           R_ZDMA_CH_SRC_CUR_DSCR_LSB);
 576             }
 577             ARRAY_FIELD_DP32(s->regs, ZDMA_CH_CTRL0, CONT, false);
 578             zdma_set_state(s, ENABLED);
 579         } else if (s->state == DISABLED) {
 580             zdma_update_descr_addr_from_start(s);
 581             zdma_set_state(s, ENABLED);
 582         }
 583     } else {
 584         /* Leave Paused state?  */
 585         if (s->state == PAUSED &&
 586             ARRAY_FIELD_EX32(s->regs, ZDMA_CH_CTRL0, CONT)) {
 587             zdma_set_state(s, DISABLED);
 588         }
 589     }
 590
 591     zdma_run(s);
 592 }
 593
 594 static RegisterAccessInfo zdma_regs_info[] = {
 595     {   .name = "ZDMA_ERR_CTRL",  .addr = A_ZDMA_ERR_CTRL,
 596         .rsvd = 0xfffffffe,
 597     },{ .name = "ZDMA_CH_ISR",  .addr = A_ZDMA_CH_ISR,
 598         .rsvd = 0xfffff000,
 599         .w1c = 0xfff,
 600         .post_write = zdma_ch_isr_postw,
 601     },{ .name = "ZDMA_CH_IMR",  .addr = A_ZDMA_CH_IMR,
 602         .reset = 0xfff,
 603         .rsvd = 0xfffff000,
 604         .ro = 0xfff,
 605     },{ .name = "ZDMA_CH_IEN",  .addr = A_ZDMA_CH_IEN,
 606         .rsvd = 0xfffff000,
 607         .pre_write = zdma_ch_ien_prew,
 608     },{ .name = "ZDMA_CH_IDS",  .addr = A_ZDMA_CH_IDS,
 609         .rsvd = 0xfffff000,
 610         .pre_write = zdma_ch_ids_prew,
 611     },{ .name = "ZDMA_CH_CTRL0",  .addr = A_ZDMA_CH_CTRL0,
 612         .reset = 0x80,
 613         .rsvd = 0xffffff01,
 614         .post_write = zdma_ch_ctrlx_postw,
 615     },{ .name = "ZDMA_CH_CTRL1",  .addr = A_ZDMA_CH_CTRL1,
 616         .reset = 0x3ff,
 617         .rsvd = 0xfffffc00,
 618     },{ .name = "ZDMA_CH_FCI",  .addr = A_ZDMA_CH_FCI,
 619         .rsvd = 0xffffffc0,
 620     },{ .name = "ZDMA_CH_STATUS",  .addr = A_ZDMA_CH_STATUS,
 621         .rsvd = 0xfffffffc,
 622         .ro = 0x3,
 623     },{ .name = "ZDMA_CH_DATA_ATTR",  .addr = A_ZDMA_CH_DATA_ATTR,
 624         .reset = 0x483d20f,
 625         .rsvd = 0xf0000000,
 626     },{ .name = "ZDMA_CH_DSCR_ATTR",  .addr = A_ZDMA_CH_DSCR_ATTR,
 627         .rsvd = 0xfffffe00,
 628     },{ .name = "ZDMA_CH_SRC_DSCR_WORD0",  .addr = A_ZDMA_CH_SRC_DSCR_WORD0,
 629     },{ .name = "ZDMA_CH_SRC_DSCR_WORD1",  .addr = A_ZDMA_CH_SRC_DSCR_WORD1,
 630         .rsvd = 0xfffe0000,
 631     },{ .name = "ZDMA_CH_SRC_DSCR_WORD2",  .addr = A_ZDMA_CH_SRC_DSCR_WORD2,
 632         .rsvd = 0xc0000000,
 633     },{ .name = "ZDMA_CH_SRC_DSCR_WORD3",  .addr = A_ZDMA_CH_SRC_DSCR_WORD3,
 634         .rsvd = 0xffffffe0,
 635     },{ .name = "ZDMA_CH_DST_DSCR_WORD0",  .addr = A_ZDMA_CH_DST_DSCR_WORD0,
 636     },{ .name = "ZDMA_CH_DST_DSCR_WORD1",  .addr = A_ZDMA_CH_DST_DSCR_WORD1,
 637         .rsvd = 0xfffe0000,
 638     },{ .name = "ZDMA_CH_DST_DSCR_WORD2",  .addr = A_ZDMA_CH_DST_DSCR_WORD2,
 639         .rsvd = 0xc0000000,
 640     },{ .name = "ZDMA_CH_DST_DSCR_WORD3",  .addr = A_ZDMA_CH_DST_DSCR_WORD3,
 641         .rsvd = 0xfffffffa,
 642     },{ .name = "ZDMA_CH_WR_ONLY_WORD0",  .addr = A_ZDMA_CH_WR_ONLY_WORD0,
 643     },{ .name = "ZDMA_CH_WR_ONLY_WORD1",  .addr = A_ZDMA_CH_WR_ONLY_WORD1,
 644     },{ .name = "ZDMA_CH_WR_ONLY_WORD2",  .addr = A_ZDMA_CH_WR_ONLY_WORD2,
 645     },{ .name = "ZDMA_CH_WR_ONLY_WORD3",  .addr = A_ZDMA_CH_WR_ONLY_WORD3,
 646     },{ .name = "ZDMA_CH_SRC_START_LSB",  .addr = A_ZDMA_CH_SRC_START_LSB,
 647     },{ .name = "ZDMA_CH_SRC_START_MSB",  .addr = A_ZDMA_CH_SRC_START_MSB,
 648         .rsvd = 0xfffe0000,
 649     },{ .name = "ZDMA_CH_DST_START_LSB",  .addr = A_ZDMA_CH_DST_START_LSB,
 650     },{ .name = "ZDMA_CH_DST_START_MSB",  .addr = A_ZDMA_CH_DST_START_MSB,
 651         .rsvd = 0xfffe0000,
 652     },{ .name = "ZDMA_CH_SRC_CUR_PYLD_LSB",  .addr = A_ZDMA_CH_SRC_CUR_PYLD_LSB,
 653         .ro = 0xffffffff,
 654     },{ .name = "ZDMA_CH_SRC_CUR_PYLD_MSB",  .addr = A_ZDMA_CH_SRC_CUR_PYLD_MSB,
 655         .rsvd = 0xfffe0000,
 656         .ro = 0x1ffff,
 657     },{ .name = "ZDMA_CH_DST_CUR_PYLD_LSB",  .addr = A_ZDMA_CH_DST_CUR_PYLD_LSB,
 658         .ro = 0xffffffff,
 659     },{ .name = "ZDMA_CH_DST_CUR_PYLD_MSB",  .addr = A_ZDMA_CH_DST_CUR_PYLD_MSB,
 660         .rsvd = 0xfffe0000,
 661         .ro = 0x1ffff,
 662     },{ .name = "ZDMA_CH_SRC_CUR_DSCR_LSB",  .addr = A_ZDMA_CH_SRC_CUR_DSCR_LSB,
 663         .ro = 0xffffffff,
 664     },{ .name = "ZDMA_CH_SRC_CUR_DSCR_MSB",  .addr = A_ZDMA_CH_SRC_CUR_DSCR_MSB,
 665         .rsvd = 0xfffe0000,
 666         .ro = 0x1ffff,
 667     },{ .name = "ZDMA_CH_DST_CUR_DSCR_LSB",  .addr = A_ZDMA_CH_DST_CUR_DSCR_LSB,
 668         .ro = 0xffffffff,
 669     },{ .name = "ZDMA_CH_DST_CUR_DSCR_MSB",  .addr = A_ZDMA_CH_DST_CUR_DSCR_MSB,
 670         .rsvd = 0xfffe0000,
 671         .ro = 0x1ffff,
 672     },{ .name = "ZDMA_CH_TOTAL_BYTE",  .addr = A_ZDMA_CH_TOTAL_BYTE,
 673         .w1c = 0xffffffff,
 674     },{ .name = "ZDMA_CH_RATE_CNTL",  .addr = A_ZDMA_CH_RATE_CNTL,
 675         .rsvd = 0xfffff000,
 676     },{ .name = "ZDMA_CH_IRQ_SRC_ACCT",  .addr = A_ZDMA_CH_IRQ_SRC_ACCT,
 677         .rsvd = 0xffffff00,
 678         .ro = 0xff,
 679         .cor = 0xff,
 680     },{ .name = "ZDMA_CH_IRQ_DST_ACCT",  .addr = A_ZDMA_CH_IRQ_DST_ACCT,
 681         .rsvd = 0xffffff00,
 682         .ro = 0xff,
 683         .cor = 0xff,
 684     },{ .name = "ZDMA_CH_DBG0",  .addr = A_ZDMA_CH_DBG0,
 685         .rsvd = 0xfffffe00,
 686         .ro = 0x1ff,
 687     },{ .name = "ZDMA_CH_DBG1",  .addr = A_ZDMA_CH_DBG1,
 688         .rsvd = 0xfffffe00,
 689         .ro = 0x1ff,
 690     },{ .name = "ZDMA_CH_CTRL2",  .addr = A_ZDMA_CH_CTRL2,
 691         .rsvd = 0xfffffffe,
 692         .post_write = zdma_ch_ctrlx_postw,
 693     }
 694 };
 695
 696 static void zdma_reset(DeviceState *dev)
 697 {
 698     XlnxZDMA *s = XLNX_ZDMA(dev);
 699     unsigned int i;
 700
 701     for (i = 0; i < ARRAY_SIZE(s->regs_info); ++i) {
 702         register_reset(&s->regs_info[i]);
 703     }
 704
 705     zdma_ch_imr_update_irq(s);
 706 }
 707
 708 static uint64_t zdma_read(void *opaque, hwaddr addr, unsigned size)
 709 {
 710     XlnxZDMA *s = XLNX_ZDMA(opaque);
 711     RegisterInfo *r = &s->regs_info[addr / 4];
 712
 713     if (!r->data) {
 714         gchar *path = object_get_canonical_path(OBJECT(s));
 715         qemu_log("%s: Decode error: read from %" HWADDR_PRIx "\n",
 716                  path,
 717                  addr);
 718         g_free(path);
 719         ARRAY_FIELD_DP32(s->regs, ZDMA_CH_ISR, INV_APB, true);
 720         zdma_ch_imr_update_irq(s);
 721         return 0;
 722     }
 723     return register_read(r, ~0, NULL, false);
 724 }
 725
 726 static void zdma_write(void *opaque, hwaddr addr, uint64_t value,
 727                       unsigned size)
 728 {
 729     XlnxZDMA *s = XLNX_ZDMA(opaque);
 730     RegisterInfo *r = &s->regs_info[addr / 4];
 731
 732     if (!r->data) {
 733         gchar *path = object_get_canonical_path(OBJECT(s));
 734         qemu_log("%s: Decode error: write to %" HWADDR_PRIx "=%" PRIx64 "\n",
 735                  path,
 736                  addr, value);
 737         g_free(path);
 738         ARRAY_FIELD_DP32(s->regs, ZDMA_CH_ISR, INV_APB, true);
 739         zdma_ch_imr_update_irq(s);
 740         return;
 741     }
 742     register_write(r, value, ~0, NULL, false);
 743 }
 744
 745 static const MemoryRegionOps zdma_ops = {
 746     .read = zdma_read,
 747     .write = zdma_write,
 748     .endianness = DEVICE_LITTLE_ENDIAN,
 749     .valid = {
 750         .min_access_size = 4,
 751         .max_access_size = 4,
 752     },
 753 };
 754
 755 static void zdma_realize(DeviceState *dev, Error **errp)
 756 {
 757     XlnxZDMA *s = XLNX_ZDMA(dev);
 758     unsigned int i;
 759
 760     for (i = 0; i < ARRAY_SIZE(zdma_regs_info); ++i) {
 761         RegisterInfo *r = &s->regs_info[zdma_regs_info[i].addr / 4];
 762
 763         *r = (RegisterInfo) {
 764             .data = (uint8_t *)&s->regs[
 765                     zdma_regs_info[i].addr / 4],
 766             .data_size = sizeof(uint32_t),
 767             .access = &zdma_regs_info[i],
 768             .opaque = s,
 769         };
 770     }
 771
 772     if (s->dma_mr) {
 773         s->dma_as = g_malloc0(sizeof(AddressSpace));
 774         address_space_init(s->dma_as, s->dma_mr, NULL);
 775     } else {
 776         s->dma_as = &address_space_memory;
 777     }
 778     s->attr = MEMTXATTRS_UNSPECIFIED;
 779 }
 780
 781 static void zdma_init(Object *obj)
 782 {
 783     XlnxZDMA *s = XLNX_ZDMA(obj);
 784     SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
 785
 786     memory_region_init_io(&s->iomem, obj, &zdma_ops, s,
 787                           TYPE_XLNX_ZDMA, ZDMA_R_MAX * 4);
 788     sysbus_init_mmio(sbd, &s->iomem);
 789     sysbus_init_irq(sbd, &s->irq_zdma_ch_imr);
 790
 791     object_property_add_link(obj, "dma", TYPE_MEMORY_REGION,
 792                              (Object **)&s->dma_mr,
 793                              qdev_prop_allow_set_link_before_realize,
 794                              OBJ_PROP_LINK_STRONG,
 795                              &error_abort);
 796 }
 797
 798 static const VMStateDescription vmstate_zdma = {
 799     .name = TYPE_XLNX_ZDMA,
 800     .version_id = 1,
 801     .minimum_version_id = 1,
 802     .minimum_version_id_old = 1,
 803     .fields = (VMStateField[]) {
 804         VMSTATE_UINT32_ARRAY(regs, XlnxZDMA, ZDMA_R_MAX),
 805         VMSTATE_UINT32(state, XlnxZDMA),
 806         VMSTATE_UINT32_ARRAY(dsc_src.words, XlnxZDMA, 4),
 807         VMSTATE_UINT32_ARRAY(dsc_dst.words, XlnxZDMA, 4),
 808         VMSTATE_END_OF_LIST(),
 809     }
 810 };
 811
 812 static Property zdma_props[] = {
 813     DEFINE_PROP_UINT32("bus-width", XlnxZDMA, cfg.bus_width, 64),
 814     DEFINE_PROP_END_OF_LIST(),
 815 };
 816
 817 static void zdma_class_init(ObjectClass *klass, void *data)
 818 {
 819     DeviceClass *dc = DEVICE_CLASS(klass);
 820
 821     dc->reset = zdma_reset;
 822     dc->realize = zdma_realize;
 823     dc->props = zdma_props;
 824     dc->vmsd = &vmstate_zdma;
 825 }
 826
 827 static const TypeInfo zdma_info = {
 828     .name          = TYPE_XLNX_ZDMA,
 829     .parent        = TYPE_SYS_BUS_DEVICE,
 830     .instance_size = sizeof(XlnxZDMA),
 831     .class_init    = zdma_class_init,
 832     .instance_init = zdma_init,
 833 };
 834
 835 static void zdma_register_types(void)
 836 {
 837     type_register_static(&zdma_info);
 838 }
 839
 840 type_init(zdma_register_types)