hw/net/can/xlnx-zynqmp-can.c

   1 /*
   2  * QEMU model of the Xilinx ZynqMP CAN controller.
   3  * This implementation is based on the following datasheet:
   4  * https://www.xilinx.com/support/documentation/user_guides/ug1085-zynq-ultrascale-trm.pdf
   5  *
   6  * Copyright (c) 2020 Xilinx Inc.
   7  *
   8  * Written-by: Vikram Garhwal<fnu.vikram@xilinx.com>
   9  *
  10  * Based on QEMU CAN Device emulation implemented by Jin Yang, Deniz Eren and
  11  * Pavel Pisa
  12  *
  13  * Permission is hereby granted, free of charge, to any person obtaining a copy
  14  * of this software and associated documentation files (the "Software"), to deal
  15  * in the Software without restriction, including without limitation the rights
  16  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  17  * copies of the Software, and to permit persons to whom the Software is
  18  * furnished to do so, subject to the following conditions:
  19  *
  20  * The above copyright notice and this permission notice shall be included in
  21  * all copies or substantial portions of the Software.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  24  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  25  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  26  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  27  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  28  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  29  * THE SOFTWARE.
  30  */
  31
  32 #include "qemu/osdep.h"
  33 #include "hw/sysbus.h"
  34 #include "hw/register.h"
  35 #include "hw/irq.h"
  36 #include "qapi/error.h"
  37 #include "qemu/bitops.h"
  38 #include "qemu/log.h"
  39 #include "qemu/cutils.h"
  40 #include "migration/vmstate.h"
  41 #include "hw/qdev-properties.h"
  42 #include "net/can_emu.h"
  43 #include "net/can_host.h"
  44 #include "qemu/event_notifier.h"
  45 #include "qom/object_interfaces.h"
  46 #include "hw/net/xlnx-zynqmp-can.h"
  47 #include "trace.h"
  48
  49 #ifndef XLNX_ZYNQMP_CAN_ERR_DEBUG
  50 #define XLNX_ZYNQMP_CAN_ERR_DEBUG 0
  51 #endif
  52
  53 #define MAX_DLC            8
  54 #undef ERROR
  55
  56 REG32(SOFTWARE_RESET_REGISTER, 0x0)
  57     FIELD(SOFTWARE_RESET_REGISTER, CEN, 1, 1)
  58     FIELD(SOFTWARE_RESET_REGISTER, SRST, 0, 1)
  59 REG32(MODE_SELECT_REGISTER, 0x4)
  60     FIELD(MODE_SELECT_REGISTER, SNOOP, 2, 1)
  61     FIELD(MODE_SELECT_REGISTER, LBACK, 1, 1)
  62     FIELD(MODE_SELECT_REGISTER, SLEEP, 0, 1)
  63 REG32(ARBITRATION_PHASE_BAUD_RATE_PRESCALER_REGISTER, 0x8)
  64     FIELD(ARBITRATION_PHASE_BAUD_RATE_PRESCALER_REGISTER, BRP, 0, 8)
  65 REG32(ARBITRATION_PHASE_BIT_TIMING_REGISTER, 0xc)
  66     FIELD(ARBITRATION_PHASE_BIT_TIMING_REGISTER, SJW, 7, 2)
  67     FIELD(ARBITRATION_PHASE_BIT_TIMING_REGISTER, TS2, 4, 3)
  68     FIELD(ARBITRATION_PHASE_BIT_TIMING_REGISTER, TS1, 0, 4)
  69 REG32(ERROR_COUNTER_REGISTER, 0x10)
  70     FIELD(ERROR_COUNTER_REGISTER, REC, 8, 8)
  71     FIELD(ERROR_COUNTER_REGISTER, TEC, 0, 8)
  72 REG32(ERROR_STATUS_REGISTER, 0x14)
  73     FIELD(ERROR_STATUS_REGISTER, ACKER, 4, 1)
  74     FIELD(ERROR_STATUS_REGISTER, BERR, 3, 1)
  75     FIELD(ERROR_STATUS_REGISTER, STER, 2, 1)
  76     FIELD(ERROR_STATUS_REGISTER, FMER, 1, 1)
  77     FIELD(ERROR_STATUS_REGISTER, CRCER, 0, 1)
  78 REG32(STATUS_REGISTER, 0x18)
  79     FIELD(STATUS_REGISTER, SNOOP, 12, 1)
  80     FIELD(STATUS_REGISTER, ACFBSY, 11, 1)
  81     FIELD(STATUS_REGISTER, TXFLL, 10, 1)
  82     FIELD(STATUS_REGISTER, TXBFLL, 9, 1)
  83     FIELD(STATUS_REGISTER, ESTAT, 7, 2)
  84     FIELD(STATUS_REGISTER, ERRWRN, 6, 1)
  85     FIELD(STATUS_REGISTER, BBSY, 5, 1)
  86     FIELD(STATUS_REGISTER, BIDLE, 4, 1)
  87     FIELD(STATUS_REGISTER, NORMAL, 3, 1)
  88     FIELD(STATUS_REGISTER, SLEEP, 2, 1)
  89     FIELD(STATUS_REGISTER, LBACK, 1, 1)
  90     FIELD(STATUS_REGISTER, CONFIG, 0, 1)
  91 REG32(INTERRUPT_STATUS_REGISTER, 0x1c)
  92     FIELD(INTERRUPT_STATUS_REGISTER, TXFEMP, 14, 1)
  93     FIELD(INTERRUPT_STATUS_REGISTER, TXFWMEMP, 13, 1)
  94     FIELD(INTERRUPT_STATUS_REGISTER, RXFWMFLL, 12, 1)
  95     FIELD(INTERRUPT_STATUS_REGISTER, WKUP, 11, 1)
  96     FIELD(INTERRUPT_STATUS_REGISTER, SLP, 10, 1)
  97     FIELD(INTERRUPT_STATUS_REGISTER, BSOFF, 9, 1)
  98     FIELD(INTERRUPT_STATUS_REGISTER, ERROR, 8, 1)
  99     FIELD(INTERRUPT_STATUS_REGISTER, RXNEMP, 7, 1)
 100     FIELD(INTERRUPT_STATUS_REGISTER, RXOFLW, 6, 1)
 101     FIELD(INTERRUPT_STATUS_REGISTER, RXUFLW, 5, 1)
 102     FIELD(INTERRUPT_STATUS_REGISTER, RXOK, 4, 1)
 103     FIELD(INTERRUPT_STATUS_REGISTER, TXBFLL, 3, 1)
 104     FIELD(INTERRUPT_STATUS_REGISTER, TXFLL, 2, 1)
 105     FIELD(INTERRUPT_STATUS_REGISTER, TXOK, 1, 1)
 106     FIELD(INTERRUPT_STATUS_REGISTER, ARBLST, 0, 1)
 107 REG32(INTERRUPT_ENABLE_REGISTER, 0x20)
 108     FIELD(INTERRUPT_ENABLE_REGISTER, ETXFEMP, 14, 1)
 109     FIELD(INTERRUPT_ENABLE_REGISTER, ETXFWMEMP, 13, 1)
 110     FIELD(INTERRUPT_ENABLE_REGISTER, ERXFWMFLL, 12, 1)
 111     FIELD(INTERRUPT_ENABLE_REGISTER, EWKUP, 11, 1)
 112     FIELD(INTERRUPT_ENABLE_REGISTER, ESLP, 10, 1)
 113     FIELD(INTERRUPT_ENABLE_REGISTER, EBSOFF, 9, 1)
 114     FIELD(INTERRUPT_ENABLE_REGISTER, EERROR, 8, 1)
 115     FIELD(INTERRUPT_ENABLE_REGISTER, ERXNEMP, 7, 1)
 116     FIELD(INTERRUPT_ENABLE_REGISTER, ERXOFLW, 6, 1)
 117     FIELD(INTERRUPT_ENABLE_REGISTER, ERXUFLW, 5, 1)
 118     FIELD(INTERRUPT_ENABLE_REGISTER, ERXOK, 4, 1)
 119     FIELD(INTERRUPT_ENABLE_REGISTER, ETXBFLL, 3, 1)
 120     FIELD(INTERRUPT_ENABLE_REGISTER, ETXFLL, 2, 1)
 121     FIELD(INTERRUPT_ENABLE_REGISTER, ETXOK, 1, 1)
 122     FIELD(INTERRUPT_ENABLE_REGISTER, EARBLST, 0, 1)
 123 REG32(INTERRUPT_CLEAR_REGISTER, 0x24)
 124     FIELD(INTERRUPT_CLEAR_REGISTER, CTXFEMP, 14, 1)
 125     FIELD(INTERRUPT_CLEAR_REGISTER, CTXFWMEMP, 13, 1)
 126     FIELD(INTERRUPT_CLEAR_REGISTER, CRXFWMFLL, 12, 1)
 127     FIELD(INTERRUPT_CLEAR_REGISTER, CWKUP, 11, 1)
 128     FIELD(INTERRUPT_CLEAR_REGISTER, CSLP, 10, 1)
 129     FIELD(INTERRUPT_CLEAR_REGISTER, CBSOFF, 9, 1)
 130     FIELD(INTERRUPT_CLEAR_REGISTER, CERROR, 8, 1)
 131     FIELD(INTERRUPT_CLEAR_REGISTER, CRXNEMP, 7, 1)
 132     FIELD(INTERRUPT_CLEAR_REGISTER, CRXOFLW, 6, 1)
 133     FIELD(INTERRUPT_CLEAR_REGISTER, CRXUFLW, 5, 1)
 134     FIELD(INTERRUPT_CLEAR_REGISTER, CRXOK, 4, 1)
 135     FIELD(INTERRUPT_CLEAR_REGISTER, CTXBFLL, 3, 1)
 136     FIELD(INTERRUPT_CLEAR_REGISTER, CTXFLL, 2, 1)
 137     FIELD(INTERRUPT_CLEAR_REGISTER, CTXOK, 1, 1)
 138     FIELD(INTERRUPT_CLEAR_REGISTER, CARBLST, 0, 1)
 139 REG32(TIMESTAMP_REGISTER, 0x28)
 140     FIELD(TIMESTAMP_REGISTER, CTS, 0, 1)
 141 REG32(WIR, 0x2c)
 142     FIELD(WIR, EW, 8, 8)
 143     FIELD(WIR, FW, 0, 8)
 144 REG32(TXFIFO_ID, 0x30)
 145     FIELD(TXFIFO_ID, IDH, 21, 11)
 146     FIELD(TXFIFO_ID, SRRRTR, 20, 1)
 147     FIELD(TXFIFO_ID, IDE, 19, 1)
 148     FIELD(TXFIFO_ID, IDL, 1, 18)
 149     FIELD(TXFIFO_ID, RTR, 0, 1)
 150 REG32(TXFIFO_DLC, 0x34)
 151     FIELD(TXFIFO_DLC, DLC, 28, 4)
 152 REG32(TXFIFO_DATA1, 0x38)
 153     FIELD(TXFIFO_DATA1, DB0, 24, 8)
 154     FIELD(TXFIFO_DATA1, DB1, 16, 8)
 155     FIELD(TXFIFO_DATA1, DB2, 8, 8)
 156     FIELD(TXFIFO_DATA1, DB3, 0, 8)
 157 REG32(TXFIFO_DATA2, 0x3c)
 158     FIELD(TXFIFO_DATA2, DB4, 24, 8)
 159     FIELD(TXFIFO_DATA2, DB5, 16, 8)
 160     FIELD(TXFIFO_DATA2, DB6, 8, 8)
 161     FIELD(TXFIFO_DATA2, DB7, 0, 8)
 162 REG32(TXHPB_ID, 0x40)
 163     FIELD(TXHPB_ID, IDH, 21, 11)
 164     FIELD(TXHPB_ID, SRRRTR, 20, 1)
 165     FIELD(TXHPB_ID, IDE, 19, 1)
 166     FIELD(TXHPB_ID, IDL, 1, 18)
 167     FIELD(TXHPB_ID, RTR, 0, 1)
 168 REG32(TXHPB_DLC, 0x44)
 169     FIELD(TXHPB_DLC, DLC, 28, 4)
 170 REG32(TXHPB_DATA1, 0x48)
 171     FIELD(TXHPB_DATA1, DB0, 24, 8)
 172     FIELD(TXHPB_DATA1, DB1, 16, 8)
 173     FIELD(TXHPB_DATA1, DB2, 8, 8)
 174     FIELD(TXHPB_DATA1, DB3, 0, 8)
 175 REG32(TXHPB_DATA2, 0x4c)
 176     FIELD(TXHPB_DATA2, DB4, 24, 8)
 177     FIELD(TXHPB_DATA2, DB5, 16, 8)
 178     FIELD(TXHPB_DATA2, DB6, 8, 8)
 179     FIELD(TXHPB_DATA2, DB7, 0, 8)
 180 REG32(RXFIFO_ID, 0x50)
 181     FIELD(RXFIFO_ID, IDH, 21, 11)
 182     FIELD(RXFIFO_ID, SRRRTR, 20, 1)
 183     FIELD(RXFIFO_ID, IDE, 19, 1)
 184     FIELD(RXFIFO_ID, IDL, 1, 18)
 185     FIELD(RXFIFO_ID, RTR, 0, 1)
 186 REG32(RXFIFO_DLC, 0x54)
 187     FIELD(RXFIFO_DLC, DLC, 28, 4)
 188     FIELD(RXFIFO_DLC, RXT, 0, 16)
 189 REG32(RXFIFO_DATA1, 0x58)
 190     FIELD(RXFIFO_DATA1, DB0, 24, 8)
 191     FIELD(RXFIFO_DATA1, DB1, 16, 8)
 192     FIELD(RXFIFO_DATA1, DB2, 8, 8)
 193     FIELD(RXFIFO_DATA1, DB3, 0, 8)
 194 REG32(RXFIFO_DATA2, 0x5c)
 195     FIELD(RXFIFO_DATA2, DB4, 24, 8)
 196     FIELD(RXFIFO_DATA2, DB5, 16, 8)
 197     FIELD(RXFIFO_DATA2, DB6, 8, 8)
 198     FIELD(RXFIFO_DATA2, DB7, 0, 8)
 199 REG32(AFR, 0x60)
 200     FIELD(AFR, UAF4, 3, 1)
 201     FIELD(AFR, UAF3, 2, 1)
 202     FIELD(AFR, UAF2, 1, 1)
 203     FIELD(AFR, UAF1, 0, 1)
 204 REG32(AFMR1, 0x64)
 205     FIELD(AFMR1, AMIDH, 21, 11)
 206     FIELD(AFMR1, AMSRR, 20, 1)
 207     FIELD(AFMR1, AMIDE, 19, 1)
 208     FIELD(AFMR1, AMIDL, 1, 18)
 209     FIELD(AFMR1, AMRTR, 0, 1)
 210 REG32(AFIR1, 0x68)
 211     FIELD(AFIR1, AIIDH, 21, 11)
 212     FIELD(AFIR1, AISRR, 20, 1)
 213     FIELD(AFIR1, AIIDE, 19, 1)
 214     FIELD(AFIR1, AIIDL, 1, 18)
 215     FIELD(AFIR1, AIRTR, 0, 1)
 216 REG32(AFMR2, 0x6c)
 217     FIELD(AFMR2, AMIDH, 21, 11)
 218     FIELD(AFMR2, AMSRR, 20, 1)
 219     FIELD(AFMR2, AMIDE, 19, 1)
 220     FIELD(AFMR2, AMIDL, 1, 18)
 221     FIELD(AFMR2, AMRTR, 0, 1)
 222 REG32(AFIR2, 0x70)
 223     FIELD(AFIR2, AIIDH, 21, 11)
 224     FIELD(AFIR2, AISRR, 20, 1)
 225     FIELD(AFIR2, AIIDE, 19, 1)
 226     FIELD(AFIR2, AIIDL, 1, 18)
 227     FIELD(AFIR2, AIRTR, 0, 1)
 228 REG32(AFMR3, 0x74)
 229     FIELD(AFMR3, AMIDH, 21, 11)
 230     FIELD(AFMR3, AMSRR, 20, 1)
 231     FIELD(AFMR3, AMIDE, 19, 1)
 232     FIELD(AFMR3, AMIDL, 1, 18)
 233     FIELD(AFMR3, AMRTR, 0, 1)
 234 REG32(AFIR3, 0x78)
 235     FIELD(AFIR3, AIIDH, 21, 11)
 236     FIELD(AFIR3, AISRR, 20, 1)
 237     FIELD(AFIR3, AIIDE, 19, 1)
 238     FIELD(AFIR3, AIIDL, 1, 18)
 239     FIELD(AFIR3, AIRTR, 0, 1)
 240 REG32(AFMR4, 0x7c)
 241     FIELD(AFMR4, AMIDH, 21, 11)
 242     FIELD(AFMR4, AMSRR, 20, 1)
 243     FIELD(AFMR4, AMIDE, 19, 1)
 244     FIELD(AFMR4, AMIDL, 1, 18)
 245     FIELD(AFMR4, AMRTR, 0, 1)
 246 REG32(AFIR4, 0x80)
 247     FIELD(AFIR4, AIIDH, 21, 11)
 248     FIELD(AFIR4, AISRR, 20, 1)
 249     FIELD(AFIR4, AIIDE, 19, 1)
 250     FIELD(AFIR4, AIIDL, 1, 18)
 251     FIELD(AFIR4, AIRTR, 0, 1)
 252
 253 static void can_update_irq(XlnxZynqMPCANState *s)
 254 {
 255     uint32_t irq;
 256
 257     /* Watermark register interrupts. */
 258     if ((fifo32_num_free(&s->tx_fifo) / CAN_FRAME_SIZE) >
 259             ARRAY_FIELD_EX32(s->regs, WIR, EW)) {
 260         ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, TXFWMEMP, 1);
 261     }
 262
 263     if ((fifo32_num_used(&s->rx_fifo) / CAN_FRAME_SIZE) >
 264             ARRAY_FIELD_EX32(s->regs, WIR, FW)) {
 265         ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXFWMFLL, 1);
 266     }
 267
 268     /* RX Interrupts. */
 269     if (fifo32_num_used(&s->rx_fifo) >= CAN_FRAME_SIZE) {
 270         ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXNEMP, 1);
 271     }
 272
 273     /* TX interrupts. */
 274     if (fifo32_is_empty(&s->tx_fifo)) {
 275         ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, TXFEMP, 1);
 276     }
 277
 278     if (fifo32_is_full(&s->tx_fifo)) {
 279         ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, TXFLL, 1);
 280     }
 281
 282     if (fifo32_is_full(&s->txhpb_fifo)) {
 283         ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, TXBFLL, 1);
 284     }
 285
 286     irq = s->regs[R_INTERRUPT_STATUS_REGISTER];
 287     irq &= s->regs[R_INTERRUPT_ENABLE_REGISTER];
 288
 289     trace_xlnx_can_update_irq(s->regs[R_INTERRUPT_STATUS_REGISTER],
 290                               s->regs[R_INTERRUPT_ENABLE_REGISTER], irq);
 291     qemu_set_irq(s->irq, irq);
 292 }
 293
 294 static void can_ier_post_write(RegisterInfo *reg, uint64_t val)
 295 {
 296     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 297
 298     can_update_irq(s);
 299 }
 300
 301 static uint64_t can_icr_pre_write(RegisterInfo *reg, uint64_t val)
 302 {
 303     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 304
 305     s->regs[R_INTERRUPT_STATUS_REGISTER] &= ~val;
 306     can_update_irq(s);
 307
 308     return 0;
 309 }
 310
 311 static void can_config_reset(XlnxZynqMPCANState *s)
 312 {
 313     /* Reset all the configuration registers. */
 314     register_reset(&s->reg_info[R_SOFTWARE_RESET_REGISTER]);
 315     register_reset(&s->reg_info[R_MODE_SELECT_REGISTER]);
 316     register_reset(
 317               &s->reg_info[R_ARBITRATION_PHASE_BAUD_RATE_PRESCALER_REGISTER]);
 318     register_reset(&s->reg_info[R_ARBITRATION_PHASE_BIT_TIMING_REGISTER]);
 319     register_reset(&s->reg_info[R_STATUS_REGISTER]);
 320     register_reset(&s->reg_info[R_INTERRUPT_STATUS_REGISTER]);
 321     register_reset(&s->reg_info[R_INTERRUPT_ENABLE_REGISTER]);
 322     register_reset(&s->reg_info[R_INTERRUPT_CLEAR_REGISTER]);
 323     register_reset(&s->reg_info[R_WIR]);
 324 }
 325
 326 static void can_config_mode(XlnxZynqMPCANState *s)
 327 {
 328     register_reset(&s->reg_info[R_ERROR_COUNTER_REGISTER]);
 329     register_reset(&s->reg_info[R_ERROR_STATUS_REGISTER]);
 330
 331     /* Put XlnxZynqMPCAN in configuration mode. */
 332     ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, CONFIG, 1);
 333     ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, WKUP, 0);
 334     ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, SLP, 0);
 335     ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, BSOFF, 0);
 336     ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, ERROR, 0);
 337     ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXOFLW, 0);
 338     ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXOK, 0);
 339     ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, TXOK, 0);
 340     ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, ARBLST, 0);
 341
 342     can_update_irq(s);
 343 }
 344
 345 static void update_status_register_mode_bits(XlnxZynqMPCANState *s)
 346 {
 347     bool sleep_status = ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, SLEEP);
 348     bool sleep_mode = ARRAY_FIELD_EX32(s->regs, MODE_SELECT_REGISTER, SLEEP);
 349     /* Wake up interrupt bit. */
 350     bool wakeup_irq_val = sleep_status && (sleep_mode == 0);
 351     /* Sleep interrupt bit. */
 352     bool sleep_irq_val = sleep_mode && (sleep_status == 0);
 353
 354     /* Clear previous core mode status bits. */
 355     ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, LBACK, 0);
 356     ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, SLEEP, 0);
 357     ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, SNOOP, 0);
 358     ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, NORMAL, 0);
 359
 360     /* set current mode bit and generate irqs accordingly. */
 361     if (ARRAY_FIELD_EX32(s->regs, MODE_SELECT_REGISTER, LBACK)) {
 362         ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, LBACK, 1);
 363     } else if (ARRAY_FIELD_EX32(s->regs, MODE_SELECT_REGISTER, SLEEP)) {
 364         ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, SLEEP, 1);
 365         ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, SLP,
 366                          sleep_irq_val);
 367     } else if (ARRAY_FIELD_EX32(s->regs, MODE_SELECT_REGISTER, SNOOP)) {
 368         ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, SNOOP, 1);
 369     } else {
 370         /*
 371          * If all bits are zero then XlnxZynqMPCAN is set in normal mode.
 372          */
 373         ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, NORMAL, 1);
 374         /* Set wakeup interrupt bit. */
 375         ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, WKUP,
 376                          wakeup_irq_val);
 377     }
 378
 379     can_update_irq(s);
 380 }
 381
 382 static void can_exit_sleep_mode(XlnxZynqMPCANState *s)
 383 {
 384     ARRAY_FIELD_DP32(s->regs, MODE_SELECT_REGISTER, SLEEP, 0);
 385     update_status_register_mode_bits(s);
 386 }
 387
 388 static void generate_frame(qemu_can_frame *frame, uint32_t *data)
 389 {
 390     frame->can_id = data[0];
 391     frame->can_dlc = FIELD_EX32(data[1], TXFIFO_DLC, DLC);
 392
 393     frame->data[0] = FIELD_EX32(data[2], TXFIFO_DATA1, DB3);
 394     frame->data[1] = FIELD_EX32(data[2], TXFIFO_DATA1, DB2);
 395     frame->data[2] = FIELD_EX32(data[2], TXFIFO_DATA1, DB1);
 396     frame->data[3] = FIELD_EX32(data[2], TXFIFO_DATA1, DB0);
 397
 398     frame->data[4] = FIELD_EX32(data[3], TXFIFO_DATA2, DB7);
 399     frame->data[5] = FIELD_EX32(data[3], TXFIFO_DATA2, DB6);
 400     frame->data[6] = FIELD_EX32(data[3], TXFIFO_DATA2, DB5);
 401     frame->data[7] = FIELD_EX32(data[3], TXFIFO_DATA2, DB4);
 402 }
 403
 404 static bool tx_ready_check(XlnxZynqMPCANState *s)
 405 {
 406     if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, SRST)) {
 407         g_autofree char *path = object_get_canonical_path(OBJECT(s));
 408
 409         qemu_log_mask(LOG_GUEST_ERROR, "%s: Attempting to transfer data while"
 410                       " data while controller is in reset mode.\n",
 411                       path);
 412         return false;
 413     }
 414
 415     if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN) == 0) {
 416         g_autofree char *path = object_get_canonical_path(OBJECT(s));
 417
 418         qemu_log_mask(LOG_GUEST_ERROR, "%s: Attempting to transfer"
 419                       " data while controller is in configuration mode. Reset"
 420                       " the core so operations can start fresh.\n",
 421                       path);
 422         return false;
 423     }
 424
 425     if (ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, SNOOP)) {
 426         g_autofree char *path = object_get_canonical_path(OBJECT(s));
 427
 428         qemu_log_mask(LOG_GUEST_ERROR, "%s: Attempting to transfer"
 429                       " data while controller is in SNOOP MODE.\n",
 430                       path);
 431         return false;
 432     }
 433
 434     return true;
 435 }
 436
 437 static void transfer_fifo(XlnxZynqMPCANState *s, Fifo32 *fifo)
 438 {
 439     qemu_can_frame frame;
 440     uint32_t data[CAN_FRAME_SIZE];
 441     int i;
 442     bool can_tx = tx_ready_check(s);
 443
 444     if (!can_tx) {
 445         g_autofree char *path = object_get_canonical_path(OBJECT(s));
 446
 447         qemu_log_mask(LOG_GUEST_ERROR, "%s: Controller is not enabled for data"
 448                       " transfer.\n", path);
 449         can_update_irq(s);
 450         return;
 451     }
 452
 453     while (!fifo32_is_empty(fifo)) {
 454         for (i = 0; i < CAN_FRAME_SIZE; i++) {
 455             data[i] = fifo32_pop(fifo);
 456         }
 457
 458         if (ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, LBACK)) {
 459             /*
 460              * Controller is in loopback. In Loopback mode, the CAN core
 461              * transmits a recessive bitstream on to the XlnxZynqMPCAN Bus.
 462              * Any message transmitted is looped back to the RX line and
 463              * acknowledged. The XlnxZynqMPCAN core receives any message
 464              * that it transmits.
 465              */
 466             if (fifo32_is_full(&s->rx_fifo)) {
 467                 ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXOFLW, 1);
 468             } else {
 469                 for (i = 0; i < CAN_FRAME_SIZE; i++) {
 470                     fifo32_push(&s->rx_fifo, data[i]);
 471                 }
 472
 473                 ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXOK, 1);
 474             }
 475         } else {
 476             /* Normal mode Tx. */
 477             generate_frame(&frame, data);
 478
 479             trace_xlnx_can_tx_data(frame.can_id, frame.can_dlc,
 480                                    frame.data[0], frame.data[1],
 481                                    frame.data[2], frame.data[3],
 482                                    frame.data[4], frame.data[5],
 483                                    frame.data[6], frame.data[7]);
 484             can_bus_client_send(&s->bus_client, &frame, 1);
 485         }
 486     }
 487
 488     ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, TXOK, 1);
 489     ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, TXBFLL, 0);
 490
 491     if (ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, SLEEP)) {
 492         can_exit_sleep_mode(s);
 493     }
 494
 495     can_update_irq(s);
 496 }
 497
 498 static uint64_t can_srr_pre_write(RegisterInfo *reg, uint64_t val)
 499 {
 500     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 501
 502     ARRAY_FIELD_DP32(s->regs, SOFTWARE_RESET_REGISTER, CEN,
 503                      FIELD_EX32(val, SOFTWARE_RESET_REGISTER, CEN));
 504
 505     if (FIELD_EX32(val, SOFTWARE_RESET_REGISTER, SRST)) {
 506         trace_xlnx_can_reset(val);
 507
 508         /* First, core will do software reset then will enter in config mode. */
 509         can_config_reset(s);
 510     }
 511
 512     if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN) == 0) {
 513         can_config_mode(s);
 514     } else {
 515         /*
 516          * Leave config mode. Now XlnxZynqMPCAN core will enter normal,
 517          * sleep, snoop or loopback mode depending upon LBACK, SLEEP, SNOOP
 518          * register states.
 519          */
 520         ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, CONFIG, 0);
 521
 522         ptimer_transaction_begin(s->can_timer);
 523         ptimer_set_count(s->can_timer, 0);
 524         ptimer_transaction_commit(s->can_timer);
 525
 526         /* XlnxZynqMPCAN is out of config mode. It will send pending data. */
 527         transfer_fifo(s, &s->txhpb_fifo);
 528         transfer_fifo(s, &s->tx_fifo);
 529     }
 530
 531     update_status_register_mode_bits(s);
 532
 533     return s->regs[R_SOFTWARE_RESET_REGISTER];
 534 }
 535
 536 static uint64_t can_msr_pre_write(RegisterInfo *reg, uint64_t val)
 537 {
 538     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 539     uint8_t multi_mode;
 540
 541     /*
 542      * Multiple mode set check. This is done to make sure user doesn't set
 543      * multiple modes.
 544      */
 545     multi_mode = FIELD_EX32(val, MODE_SELECT_REGISTER, LBACK) +
 546                  FIELD_EX32(val, MODE_SELECT_REGISTER, SLEEP) +
 547                  FIELD_EX32(val, MODE_SELECT_REGISTER, SNOOP);
 548
 549     if (multi_mode > 1) {
 550         g_autofree char *path = object_get_canonical_path(OBJECT(s));
 551
 552         qemu_log_mask(LOG_GUEST_ERROR, "%s: Attempting to config"
 553                       " several modes simultaneously. One mode will be selected"
 554                       " according to their priority: LBACK > SLEEP > SNOOP.\n",
 555                       path);
 556     }
 557
 558     if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN) == 0) {
 559         /* We are in configuration mode, any mode can be selected. */
 560         s->regs[R_MODE_SELECT_REGISTER] = val;
 561     } else {
 562         bool sleep_mode_bit = FIELD_EX32(val, MODE_SELECT_REGISTER, SLEEP);
 563
 564         ARRAY_FIELD_DP32(s->regs, MODE_SELECT_REGISTER, SLEEP, sleep_mode_bit);
 565
 566         if (FIELD_EX32(val, MODE_SELECT_REGISTER, LBACK)) {
 567             g_autofree char *path = object_get_canonical_path(OBJECT(s));
 568
 569             qemu_log_mask(LOG_GUEST_ERROR, "%s: Attempting to set"
 570                           " LBACK mode without setting CEN bit as 0.\n",
 571                           path);
 572         } else if (FIELD_EX32(val, MODE_SELECT_REGISTER, SNOOP)) {
 573             g_autofree char *path = object_get_canonical_path(OBJECT(s));
 574
 575             qemu_log_mask(LOG_GUEST_ERROR, "%s: Attempting to set"
 576                           " SNOOP mode without setting CEN bit as 0.\n",
 577                           path);
 578         }
 579
 580         update_status_register_mode_bits(s);
 581     }
 582
 583     return s->regs[R_MODE_SELECT_REGISTER];
 584 }
 585
 586 static uint64_t can_brpr_pre_write(RegisterInfo  *reg, uint64_t val)
 587 {
 588     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 589
 590     /* Only allow writes when in config mode. */
 591     if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN)) {
 592         return s->regs[R_ARBITRATION_PHASE_BAUD_RATE_PRESCALER_REGISTER];
 593     }
 594
 595     return val;
 596 }
 597
 598 static uint64_t can_btr_pre_write(RegisterInfo  *reg, uint64_t val)
 599 {
 600     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 601
 602     /* Only allow writes when in config mode. */
 603     if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN)) {
 604         return s->regs[R_ARBITRATION_PHASE_BIT_TIMING_REGISTER];
 605     }
 606
 607     return val;
 608 }
 609
 610 static uint64_t can_tcr_pre_write(RegisterInfo  *reg, uint64_t val)
 611 {
 612     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 613
 614     if (FIELD_EX32(val, TIMESTAMP_REGISTER, CTS)) {
 615         ptimer_transaction_begin(s->can_timer);
 616         ptimer_set_count(s->can_timer, 0);
 617         ptimer_transaction_commit(s->can_timer);
 618     }
 619
 620     return 0;
 621 }
 622
 623 static void update_rx_fifo(XlnxZynqMPCANState *s, const qemu_can_frame *frame)
 624 {
 625     bool filter_pass = false;
 626     uint16_t timestamp = 0;
 627
 628     /* If no filter is enabled. Message will be stored in FIFO. */
 629     if (!((ARRAY_FIELD_EX32(s->regs, AFR, UAF1)) |
 630        (ARRAY_FIELD_EX32(s->regs, AFR, UAF2)) |
 631        (ARRAY_FIELD_EX32(s->regs, AFR, UAF3)) |
 632        (ARRAY_FIELD_EX32(s->regs, AFR, UAF4)))) {
 633         filter_pass = true;
 634     }
 635
 636     /*
 637      * Messages that pass any of the acceptance filters will be stored in
 638      * the RX FIFO.
 639      */
 640     if (ARRAY_FIELD_EX32(s->regs, AFR, UAF1)) {
 641         uint32_t id_masked = s->regs[R_AFMR1] & frame->can_id;
 642         uint32_t filter_id_masked = s->regs[R_AFMR1] & s->regs[R_AFIR1];
 643
 644         if (filter_id_masked == id_masked) {
 645             filter_pass = true;
 646         }
 647     }
 648
 649     if (ARRAY_FIELD_EX32(s->regs, AFR, UAF2)) {
 650         uint32_t id_masked = s->regs[R_AFMR2] & frame->can_id;
 651         uint32_t filter_id_masked = s->regs[R_AFMR2] & s->regs[R_AFIR2];
 652
 653         if (filter_id_masked == id_masked) {
 654             filter_pass = true;
 655         }
 656     }
 657
 658     if (ARRAY_FIELD_EX32(s->regs, AFR, UAF3)) {
 659         uint32_t id_masked = s->regs[R_AFMR3] & frame->can_id;
 660         uint32_t filter_id_masked = s->regs[R_AFMR3] & s->regs[R_AFIR3];
 661
 662         if (filter_id_masked == id_masked) {
 663             filter_pass = true;
 664         }
 665     }
 666
 667     if (ARRAY_FIELD_EX32(s->regs, AFR, UAF4)) {
 668         uint32_t id_masked = s->regs[R_AFMR4] & frame->can_id;
 669         uint32_t filter_id_masked = s->regs[R_AFMR4] & s->regs[R_AFIR4];
 670
 671         if (filter_id_masked == id_masked) {
 672             filter_pass = true;
 673         }
 674     }
 675
 676     if (!filter_pass) {
 677         trace_xlnx_can_rx_fifo_filter_reject(frame->can_id, frame->can_dlc);
 678         return;
 679     }
 680
 681     /* Store the message in fifo if it passed through any of the filters. */
 682     if (filter_pass && frame->can_dlc <= MAX_DLC) {
 683
 684         if (fifo32_is_full(&s->rx_fifo)) {
 685             ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXOFLW, 1);
 686         } else {
 687             timestamp = CAN_TIMER_MAX - ptimer_get_count(s->can_timer);
 688
 689             fifo32_push(&s->rx_fifo, frame->can_id);
 690
 691             fifo32_push(&s->rx_fifo, deposit32(0, R_RXFIFO_DLC_DLC_SHIFT,
 692                                                R_RXFIFO_DLC_DLC_LENGTH,
 693                                                frame->can_dlc) |
 694                                      deposit32(0, R_RXFIFO_DLC_RXT_SHIFT,
 695                                                R_RXFIFO_DLC_RXT_LENGTH,
 696                                                timestamp));
 697
 698             /* First 32 bit of the data. */
 699             fifo32_push(&s->rx_fifo, deposit32(0, R_RXFIFO_DATA1_DB3_SHIFT,
 700                                                R_RXFIFO_DATA1_DB3_LENGTH,
 701                                                frame->data[0]) |
 702                                      deposit32(0, R_RXFIFO_DATA1_DB2_SHIFT,
 703                                                R_RXFIFO_DATA1_DB2_LENGTH,
 704                                                frame->data[1]) |
 705                                      deposit32(0, R_RXFIFO_DATA1_DB1_SHIFT,
 706                                                R_RXFIFO_DATA1_DB1_LENGTH,
 707                                                frame->data[2]) |
 708                                      deposit32(0, R_RXFIFO_DATA1_DB0_SHIFT,
 709                                                R_RXFIFO_DATA1_DB0_LENGTH,
 710                                                frame->data[3]));
 711             /* Last 32 bit of the data. */
 712             fifo32_push(&s->rx_fifo, deposit32(0, R_RXFIFO_DATA2_DB7_SHIFT,
 713                                                R_RXFIFO_DATA2_DB7_LENGTH,
 714                                                frame->data[4]) |
 715                                      deposit32(0, R_RXFIFO_DATA2_DB6_SHIFT,
 716                                                R_RXFIFO_DATA2_DB6_LENGTH,
 717                                                frame->data[5]) |
 718                                      deposit32(0, R_RXFIFO_DATA2_DB5_SHIFT,
 719                                                R_RXFIFO_DATA2_DB5_LENGTH,
 720                                                frame->data[6]) |
 721                                      deposit32(0, R_RXFIFO_DATA2_DB4_SHIFT,
 722                                                R_RXFIFO_DATA2_DB4_LENGTH,
 723                                                frame->data[7]));
 724
 725             ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXOK, 1);
 726             trace_xlnx_can_rx_data(frame->can_id, frame->can_dlc,
 727                                    frame->data[0], frame->data[1],
 728                                    frame->data[2], frame->data[3],
 729                                    frame->data[4], frame->data[5],
 730                                    frame->data[6], frame->data[7]);
 731         }
 732
 733         can_update_irq(s);
 734     }
 735 }
 736
 737 static uint64_t can_rxfifo_pre_read(RegisterInfo *reg, uint64_t val)
 738 {
 739     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 740
 741     if (!fifo32_is_empty(&s->rx_fifo)) {
 742         val = fifo32_pop(&s->rx_fifo);
 743     } else {
 744         ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXUFLW, 1);
 745     }
 746
 747     can_update_irq(s);
 748     return val;
 749 }
 750
 751 static void can_filter_enable_post_write(RegisterInfo *reg, uint64_t val)
 752 {
 753     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 754
 755     if (ARRAY_FIELD_EX32(s->regs, AFR, UAF1) &&
 756         ARRAY_FIELD_EX32(s->regs, AFR, UAF2) &&
 757         ARRAY_FIELD_EX32(s->regs, AFR, UAF3) &&
 758         ARRAY_FIELD_EX32(s->regs, AFR, UAF4)) {
 759         ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, ACFBSY, 1);
 760     } else {
 761         ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, ACFBSY, 0);
 762     }
 763 }
 764
 765 static uint64_t can_filter_mask_pre_write(RegisterInfo *reg, uint64_t val)
 766 {
 767     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 768     uint32_t reg_idx = (reg->access->addr) / 4;
 769     uint32_t filter_number = (reg_idx - R_AFMR1) / 2;
 770
 771     /* modify an acceptance filter, the corresponding UAF bit should be '0'. */
 772     if (!(s->regs[R_AFR] & (1 << filter_number))) {
 773         s->regs[reg_idx] = val;
 774
 775         trace_xlnx_can_filter_mask_pre_write(filter_number, s->regs[reg_idx]);
 776     } else {
 777         g_autofree char *path = object_get_canonical_path(OBJECT(s));
 778
 779         qemu_log_mask(LOG_GUEST_ERROR, "%s: Acceptance filter %d"
 780                       " mask is not set as corresponding UAF bit is not 0.\n",
 781                       path, filter_number + 1);
 782     }
 783
 784     return s->regs[reg_idx];
 785 }
 786
 787 static uint64_t can_filter_id_pre_write(RegisterInfo *reg, uint64_t val)
 788 {
 789     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 790     uint32_t reg_idx = (reg->access->addr) / 4;
 791     uint32_t filter_number = (reg_idx - R_AFIR1) / 2;
 792
 793     if (!(s->regs[R_AFR] & (1 << filter_number))) {
 794         s->regs[reg_idx] = val;
 795
 796         trace_xlnx_can_filter_id_pre_write(filter_number, s->regs[reg_idx]);
 797     } else {
 798         g_autofree char *path = object_get_canonical_path(OBJECT(s));
 799
 800         qemu_log_mask(LOG_GUEST_ERROR, "%s: Acceptance filter %d"
 801                       " id is not set as corresponding UAF bit is not 0.\n",
 802                       path, filter_number + 1);
 803     }
 804
 805     return s->regs[reg_idx];
 806 }
 807
 808 static void can_tx_post_write(RegisterInfo *reg, uint64_t val)
 809 {
 810     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque);
 811
 812     bool is_txhpb = reg->access->addr > A_TXFIFO_DATA2;
 813
 814     bool initiate_transfer = (reg->access->addr == A_TXFIFO_DATA2) ||
 815                              (reg->access->addr == A_TXHPB_DATA2);
 816
 817     Fifo32 *f = is_txhpb ? &s->txhpb_fifo : &s->tx_fifo;
 818
 819     if (!fifo32_is_full(f)) {
 820         fifo32_push(f, val);
 821     } else {
 822         g_autofree char *path = object_get_canonical_path(OBJECT(s));
 823
 824         qemu_log_mask(LOG_GUEST_ERROR, "%s: TX FIFO is full.\n", path);
 825     }
 826
 827     /* Initiate the message send if TX register is written. */
 828     if (initiate_transfer &&
 829         ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN)) {
 830         transfer_fifo(s, f);
 831     }
 832
 833     can_update_irq(s);
 834 }
 835
 836 static const RegisterAccessInfo can_regs_info[] = {
 837     {   .name = "SOFTWARE_RESET_REGISTER",
 838         .addr = A_SOFTWARE_RESET_REGISTER,
 839         .rsvd = 0xfffffffc,
 840         .pre_write = can_srr_pre_write,
 841     },{ .name = "MODE_SELECT_REGISTER",
 842         .addr = A_MODE_SELECT_REGISTER,
 843         .rsvd = 0xfffffff8,
 844         .pre_write = can_msr_pre_write,
 845     },{ .name = "ARBITRATION_PHASE_BAUD_RATE_PRESCALER_REGISTER",
 846         .addr = A_ARBITRATION_PHASE_BAUD_RATE_PRESCALER_REGISTER,
 847         .rsvd = 0xffffff00,
 848         .pre_write = can_brpr_pre_write,
 849     },{ .name = "ARBITRATION_PHASE_BIT_TIMING_REGISTER",
 850         .addr = A_ARBITRATION_PHASE_BIT_TIMING_REGISTER,
 851         .rsvd = 0xfffffe00,
 852         .pre_write = can_btr_pre_write,
 853     },{ .name = "ERROR_COUNTER_REGISTER",
 854         .addr = A_ERROR_COUNTER_REGISTER,
 855         .rsvd = 0xffff0000,
 856         .ro = 0xffffffff,
 857     },{ .name = "ERROR_STATUS_REGISTER",
 858         .addr = A_ERROR_STATUS_REGISTER,
 859         .rsvd = 0xffffffe0,
 860         .w1c = 0x1f,
 861     },{ .name = "STATUS_REGISTER",  .addr = A_STATUS_REGISTER,
 862         .reset = 0x1,
 863         .rsvd = 0xffffe000,
 864         .ro = 0x1fff,
 865     },{ .name = "INTERRUPT_STATUS_REGISTER",
 866         .addr = A_INTERRUPT_STATUS_REGISTER,
 867         .reset = 0x6000,
 868         .rsvd = 0xffff8000,
 869         .ro = 0x7fff,
 870     },{ .name = "INTERRUPT_ENABLE_REGISTER",
 871         .addr = A_INTERRUPT_ENABLE_REGISTER,
 872         .rsvd = 0xffff8000,
 873         .post_write = can_ier_post_write,
 874     },{ .name = "INTERRUPT_CLEAR_REGISTER",
 875         .addr = A_INTERRUPT_CLEAR_REGISTER,
 876         .rsvd = 0xffff8000,
 877         .pre_write = can_icr_pre_write,
 878     },{ .name = "TIMESTAMP_REGISTER",
 879         .addr = A_TIMESTAMP_REGISTER,
 880         .rsvd = 0xfffffffe,
 881         .pre_write = can_tcr_pre_write,
 882     },{ .name = "WIR",  .addr = A_WIR,
 883         .reset = 0x3f3f,
 884         .rsvd = 0xffff0000,
 885     },{ .name = "TXFIFO_ID",  .addr = A_TXFIFO_ID,
 886         .post_write = can_tx_post_write,
 887     },{ .name = "TXFIFO_DLC",  .addr = A_TXFIFO_DLC,
 888         .rsvd = 0xfffffff,
 889         .post_write = can_tx_post_write,
 890     },{ .name = "TXFIFO_DATA1",  .addr = A_TXFIFO_DATA1,
 891         .post_write = can_tx_post_write,
 892     },{ .name = "TXFIFO_DATA2",  .addr = A_TXFIFO_DATA2,
 893         .post_write = can_tx_post_write,
 894     },{ .name = "TXHPB_ID",  .addr = A_TXHPB_ID,
 895         .post_write = can_tx_post_write,
 896     },{ .name = "TXHPB_DLC",  .addr = A_TXHPB_DLC,
 897         .rsvd = 0xfffffff,
 898         .post_write = can_tx_post_write,
 899     },{ .name = "TXHPB_DATA1",  .addr = A_TXHPB_DATA1,
 900         .post_write = can_tx_post_write,
 901     },{ .name = "TXHPB_DATA2",  .addr = A_TXHPB_DATA2,
 902         .post_write = can_tx_post_write,
 903     },{ .name = "RXFIFO_ID",  .addr = A_RXFIFO_ID,
 904         .ro = 0xffffffff,
 905         .post_read = can_rxfifo_pre_read,
 906     },{ .name = "RXFIFO_DLC",  .addr = A_RXFIFO_DLC,
 907         .rsvd = 0xfff0000,
 908         .post_read = can_rxfifo_pre_read,
 909     },{ .name = "RXFIFO_DATA1",  .addr = A_RXFIFO_DATA1,
 910         .post_read = can_rxfifo_pre_read,
 911     },{ .name = "RXFIFO_DATA2",  .addr = A_RXFIFO_DATA2,
 912         .post_read = can_rxfifo_pre_read,
 913     },{ .name = "AFR",  .addr = A_AFR,
 914         .rsvd = 0xfffffff0,
 915         .post_write = can_filter_enable_post_write,
 916     },{ .name = "AFMR1",  .addr = A_AFMR1,
 917         .pre_write = can_filter_mask_pre_write,
 918     },{ .name = "AFIR1",  .addr = A_AFIR1,
 919         .pre_write = can_filter_id_pre_write,
 920     },{ .name = "AFMR2",  .addr = A_AFMR2,
 921         .pre_write = can_filter_mask_pre_write,
 922     },{ .name = "AFIR2",  .addr = A_AFIR2,
 923         .pre_write = can_filter_id_pre_write,
 924     },{ .name = "AFMR3",  .addr = A_AFMR3,
 925         .pre_write = can_filter_mask_pre_write,
 926     },{ .name = "AFIR3",  .addr = A_AFIR3,
 927         .pre_write = can_filter_id_pre_write,
 928     },{ .name = "AFMR4",  .addr = A_AFMR4,
 929         .pre_write = can_filter_mask_pre_write,
 930     },{ .name = "AFIR4",  .addr = A_AFIR4,
 931         .pre_write = can_filter_id_pre_write,
 932     }
 933 };
 934
 935 static void xlnx_zynqmp_can_ptimer_cb(void *opaque)
 936 {
 937     /* No action required on the timer rollover. */
 938 }
 939
 940 static const MemoryRegionOps can_ops = {
 941     .read = register_read_memory,
 942     .write = register_write_memory,
 943     .endianness = DEVICE_LITTLE_ENDIAN,
 944     .valid = {
 945         .min_access_size = 4,
 946         .max_access_size = 4,
 947     },
 948 };
 949
 950 static void xlnx_zynqmp_can_reset_init(Object *obj, ResetType type)
 951 {
 952     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(obj);
 953     unsigned int i;
 954
 955     for (i = R_RXFIFO_ID; i < ARRAY_SIZE(s->reg_info); ++i) {
 956         register_reset(&s->reg_info[i]);
 957     }
 958
 959     ptimer_transaction_begin(s->can_timer);
 960     ptimer_set_count(s->can_timer, 0);
 961     ptimer_transaction_commit(s->can_timer);
 962 }
 963
 964 static void xlnx_zynqmp_can_reset_hold(Object *obj)
 965 {
 966     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(obj);
 967     unsigned int i;
 968
 969     for (i = 0; i < R_RXFIFO_ID; ++i) {
 970         register_reset(&s->reg_info[i]);
 971     }
 972
 973     /*
 974      * Reset FIFOs when CAN model is reset. This will clear the fifo writes
 975      * done by post_write which gets called from register_reset function,
 976      * post_write handle will not be able to trigger tx because CAN will be
 977      * disabled when software_reset_register is cleared first.
 978      */
 979     fifo32_reset(&s->rx_fifo);
 980     fifo32_reset(&s->tx_fifo);
 981     fifo32_reset(&s->txhpb_fifo);
 982 }
 983
 984 static bool xlnx_zynqmp_can_can_receive(CanBusClientState *client)
 985 {
 986     XlnxZynqMPCANState *s = container_of(client, XlnxZynqMPCANState,
 987                                          bus_client);
 988
 989     if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, SRST)) {
 990         g_autofree char *path = object_get_canonical_path(OBJECT(s));
 991
 992         qemu_log_mask(LOG_GUEST_ERROR, "%s: Controller is in reset state.\n",
 993                       path);
 994         return false;
 995     }
 996
 997     if ((ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN)) == 0) {
 998         g_autofree char *path = object_get_canonical_path(OBJECT(s));
 999
1000         qemu_log_mask(LOG_GUEST_ERROR, "%s: Controller is disabled. Incoming"
1001                       " messages will be discarded.\n", path);
1002         return false;
1003     }
1004
1005     return true;
1006 }
1007
1008 static ssize_t xlnx_zynqmp_can_receive(CanBusClientState *client,
1009                                const qemu_can_frame *buf, size_t buf_size) {
1010     XlnxZynqMPCANState *s = container_of(client, XlnxZynqMPCANState,
1011                                          bus_client);
1012     const qemu_can_frame *frame = buf;
1013
1014     if (buf_size <= 0) {
1015         g_autofree char *path = object_get_canonical_path(OBJECT(s));
1016
1017         qemu_log_mask(LOG_GUEST_ERROR, "%s: Error in the data received.\n",
1018                       path);
1019         return 0;
1020     }
1021
1022     if (ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, SNOOP)) {
1023         /* Snoop Mode: Just keep the data. no response back. */
1024         update_rx_fifo(s, frame);
1025     } else if ((ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, SLEEP))) {
1026         /*
1027          * XlnxZynqMPCAN is in sleep mode. Any data on bus will bring it to wake
1028          * up state.
1029          */
1030         can_exit_sleep_mode(s);
1031         update_rx_fifo(s, frame);
1032     } else if ((ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, SLEEP)) == 0) {
1033         update_rx_fifo(s, frame);
1034     } else {
1035         /*
1036          * XlnxZynqMPCAN will not participate in normal bus communication
1037          * and will not receive any messages transmitted by other CAN nodes.
1038          */
1039         trace_xlnx_can_rx_discard(s->regs[R_STATUS_REGISTER]);
1040     }
1041
1042     return 1;
1043 }
1044
1045 static CanBusClientInfo can_xilinx_bus_client_info = {
1046     .can_receive = xlnx_zynqmp_can_can_receive,
1047     .receive = xlnx_zynqmp_can_receive,
1048 };
1049
1050 static int xlnx_zynqmp_can_connect_to_bus(XlnxZynqMPCANState *s,
1051                                           CanBusState *bus)
1052 {
1053     s->bus_client.info = &can_xilinx_bus_client_info;
1054
1055     if (can_bus_insert_client(bus, &s->bus_client) < 0) {
1056         return -1;
1057     }
1058     return 0;
1059 }
1060
1061 static void xlnx_zynqmp_can_realize(DeviceState *dev, Error **errp)
1062 {
1063     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(dev);
1064
1065     if (s->canbus) {
1066         if (xlnx_zynqmp_can_connect_to_bus(s, s->canbus) < 0) {
1067             g_autofree char *path = object_get_canonical_path(OBJECT(s));
1068
1069             error_setg(errp, "%s: xlnx_zynqmp_can_connect_to_bus"
1070                        " failed.", path);
1071             return;
1072         }
1073     }
1074
1075     /* Create RX FIFO, TXFIFO, TXHPB storage. */
1076     fifo32_create(&s->rx_fifo, RXFIFO_SIZE);
1077     fifo32_create(&s->tx_fifo, RXFIFO_SIZE);
1078     fifo32_create(&s->txhpb_fifo, CAN_FRAME_SIZE);
1079
1080     /* Allocate a new timer. */
1081     s->can_timer = ptimer_init(xlnx_zynqmp_can_ptimer_cb, s,
1082                                PTIMER_POLICY_LEGACY);
1083
1084     ptimer_transaction_begin(s->can_timer);
1085
1086     ptimer_set_freq(s->can_timer, s->cfg.ext_clk_freq);
1087     ptimer_set_limit(s->can_timer, CAN_TIMER_MAX, 1);
1088     ptimer_run(s->can_timer, 0);
1089     ptimer_transaction_commit(s->can_timer);
1090 }
1091
1092 static void xlnx_zynqmp_can_init(Object *obj)
1093 {
1094     XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(obj);
1095     SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
1096
1097     RegisterInfoArray *reg_array;
1098
1099     memory_region_init(&s->iomem, obj, TYPE_XLNX_ZYNQMP_CAN,
1100                         XLNX_ZYNQMP_CAN_R_MAX * 4);
1101     reg_array = register_init_block32(DEVICE(obj), can_regs_info,
1102                                ARRAY_SIZE(can_regs_info),
1103                                s->reg_info, s->regs,
1104                                &can_ops,
1105                                XLNX_ZYNQMP_CAN_ERR_DEBUG,
1106                                XLNX_ZYNQMP_CAN_R_MAX * 4);
1107
1108     memory_region_add_subregion(&s->iomem, 0x00, &reg_array->mem);
1109     sysbus_init_mmio(sbd, &s->iomem);
1110     sysbus_init_irq(SYS_BUS_DEVICE(obj), &s->irq);
1111 }
1112
1113 static const VMStateDescription vmstate_can = {
1114     .name = TYPE_XLNX_ZYNQMP_CAN,
1115     .version_id = 1,
1116     .minimum_version_id = 1,
1117     .fields = (VMStateField[]) {
1118         VMSTATE_FIFO32(rx_fifo, XlnxZynqMPCANState),
1119         VMSTATE_FIFO32(tx_fifo, XlnxZynqMPCANState),
1120         VMSTATE_FIFO32(txhpb_fifo, XlnxZynqMPCANState),
1121         VMSTATE_UINT32_ARRAY(regs, XlnxZynqMPCANState, XLNX_ZYNQMP_CAN_R_MAX),
1122         VMSTATE_PTIMER(can_timer, XlnxZynqMPCANState),
1123         VMSTATE_END_OF_LIST(),
1124     }
1125 };
1126
1127 static Property xlnx_zynqmp_can_properties[] = {
1128     DEFINE_PROP_UINT32("ext_clk_freq", XlnxZynqMPCANState, cfg.ext_clk_freq,
1129                        CAN_DEFAULT_CLOCK),
1130     DEFINE_PROP_LINK("canbus", XlnxZynqMPCANState, canbus, TYPE_CAN_BUS,
1131                      CanBusState *),
1132     DEFINE_PROP_END_OF_LIST(),
1133 };
1134
1135 static void xlnx_zynqmp_can_class_init(ObjectClass *klass, void *data)
1136 {
1137     DeviceClass *dc = DEVICE_CLASS(klass);
1138     ResettableClass *rc = RESETTABLE_CLASS(klass);
1139
1140     rc->phases.enter = xlnx_zynqmp_can_reset_init;
1141     rc->phases.hold = xlnx_zynqmp_can_reset_hold;
1142     dc->realize = xlnx_zynqmp_can_realize;
1143     device_class_set_props(dc, xlnx_zynqmp_can_properties);
1144     dc->vmsd = &vmstate_can;
1145 }
1146
1147 static const TypeInfo can_info = {
1148     .name          = TYPE_XLNX_ZYNQMP_CAN,
1149     .parent        = TYPE_SYS_BUS_DEVICE,
1150     .instance_size = sizeof(XlnxZynqMPCANState),
1151     .class_init    = xlnx_zynqmp_can_class_init,
1152     .instance_init = xlnx_zynqmp_can_init,
1153 };
1154
1155 static void can_register_types(void)
1156 {
1157     type_register_static(&can_info);
1158 }
1159
1160 type_init(can_register_types)