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 read_tx_frame(XlnxZynqMPCANState *s, Fifo32 *fifo, uint32_t *data) 438 { 439 unsigned used = fifo32_num_used(fifo); 440 bool is_txhpb = fifo == &s->txhpb_fifo; 441 442 assert(used > 0); 443 used %= CAN_FRAME_SIZE; 444 445 /* 446 * Frame Message Format 447 * 448 * Each frame includes four words (16 bytes). Software must read and write 449 * all four words regardless of the actual number of data bytes and valid 450 * fields in the message. 451 * If software misbehave (not writing all four words), we use the previous 452 * registers content to initialize each missing word. 453 * 454 * If used is 1 then ID, DLC and DATA1 are missing. 455 * if used is 2 then ID and DLC are missing. 456 * if used is 3 then only ID is missing. 457 */ 458 if (used > 0) { 459 data[0] = s->regs[is_txhpb ? R_TXHPB_ID : R_TXFIFO_ID]; 460 } else { 461 data[0] = fifo32_pop(fifo); 462 } 463 if (used == 1 || used == 2) { 464 data[1] = s->regs[is_txhpb ? R_TXHPB_DLC : R_TXFIFO_DLC]; 465 } else { 466 data[1] = fifo32_pop(fifo); 467 } 468 if (used == 1) { 469 data[2] = s->regs[is_txhpb ? R_TXHPB_DATA1 : R_TXFIFO_DATA1]; 470 } else { 471 data[2] = fifo32_pop(fifo); 472 } 473 /* DATA2 triggered the transfer thus is always available */ 474 data[3] = fifo32_pop(fifo); 475 476 if (used) { 477 qemu_log_mask(LOG_GUEST_ERROR, 478 "%s: Incomplete CAN frame (only %u/%u slots used)\n", 479 TYPE_XLNX_ZYNQMP_CAN, used, CAN_FRAME_SIZE); 480 } 481 } 482 483 static void transfer_fifo(XlnxZynqMPCANState *s, Fifo32 *fifo) 484 { 485 qemu_can_frame frame; 486 uint32_t data[CAN_FRAME_SIZE]; 487 int i; 488 bool can_tx = tx_ready_check(s); 489 490 if (!can_tx) { 491 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 492 493 qemu_log_mask(LOG_GUEST_ERROR, "%s: Controller is not enabled for data" 494 " transfer.\n", path); 495 can_update_irq(s); 496 return; 497 } 498 499 while (!fifo32_is_empty(fifo)) { 500 read_tx_frame(s, fifo, data); 501 502 if (ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, LBACK)) { 503 /* 504 * Controller is in loopback. In Loopback mode, the CAN core 505 * transmits a recessive bitstream on to the XlnxZynqMPCAN Bus. 506 * Any message transmitted is looped back to the RX line and 507 * acknowledged. The XlnxZynqMPCAN core receives any message 508 * that it transmits. 509 */ 510 if (fifo32_is_full(&s->rx_fifo)) { 511 ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXOFLW, 1); 512 } else { 513 for (i = 0; i < CAN_FRAME_SIZE; i++) { 514 fifo32_push(&s->rx_fifo, data[i]); 515 } 516 517 ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXOK, 1); 518 } 519 } else { 520 /* Normal mode Tx. */ 521 generate_frame(&frame, data); 522 523 trace_xlnx_can_tx_data(frame.can_id, frame.can_dlc, 524 frame.data[0], frame.data[1], 525 frame.data[2], frame.data[3], 526 frame.data[4], frame.data[5], 527 frame.data[6], frame.data[7]); 528 can_bus_client_send(&s->bus_client, &frame, 1); 529 } 530 } 531 532 ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, TXOK, 1); 533 ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, TXBFLL, 0); 534 535 if (ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, SLEEP)) { 536 can_exit_sleep_mode(s); 537 } 538 539 can_update_irq(s); 540 } 541 542 static uint64_t can_srr_pre_write(RegisterInfo *reg, uint64_t val) 543 { 544 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque); 545 546 ARRAY_FIELD_DP32(s->regs, SOFTWARE_RESET_REGISTER, CEN, 547 FIELD_EX32(val, SOFTWARE_RESET_REGISTER, CEN)); 548 549 if (FIELD_EX32(val, SOFTWARE_RESET_REGISTER, SRST)) { 550 trace_xlnx_can_reset(val); 551 552 /* First, core will do software reset then will enter in config mode. */ 553 can_config_reset(s); 554 } 555 556 if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN) == 0) { 557 can_config_mode(s); 558 } else { 559 /* 560 * Leave config mode. Now XlnxZynqMPCAN core will enter normal, 561 * sleep, snoop or loopback mode depending upon LBACK, SLEEP, SNOOP 562 * register states. 563 */ 564 ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, CONFIG, 0); 565 566 ptimer_transaction_begin(s->can_timer); 567 ptimer_set_count(s->can_timer, 0); 568 ptimer_transaction_commit(s->can_timer); 569 570 /* XlnxZynqMPCAN is out of config mode. It will send pending data. */ 571 transfer_fifo(s, &s->txhpb_fifo); 572 transfer_fifo(s, &s->tx_fifo); 573 } 574 575 update_status_register_mode_bits(s); 576 577 return s->regs[R_SOFTWARE_RESET_REGISTER]; 578 } 579 580 static uint64_t can_msr_pre_write(RegisterInfo *reg, uint64_t val) 581 { 582 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque); 583 uint8_t multi_mode; 584 585 /* 586 * Multiple mode set check. This is done to make sure user doesn't set 587 * multiple modes. 588 */ 589 multi_mode = FIELD_EX32(val, MODE_SELECT_REGISTER, LBACK) + 590 FIELD_EX32(val, MODE_SELECT_REGISTER, SLEEP) + 591 FIELD_EX32(val, MODE_SELECT_REGISTER, SNOOP); 592 593 if (multi_mode > 1) { 594 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 595 596 qemu_log_mask(LOG_GUEST_ERROR, "%s: Attempting to config" 597 " several modes simultaneously. One mode will be selected" 598 " according to their priority: LBACK > SLEEP > SNOOP.\n", 599 path); 600 } 601 602 if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN) == 0) { 603 /* We are in configuration mode, any mode can be selected. */ 604 s->regs[R_MODE_SELECT_REGISTER] = val; 605 } else { 606 bool sleep_mode_bit = FIELD_EX32(val, MODE_SELECT_REGISTER, SLEEP); 607 608 ARRAY_FIELD_DP32(s->regs, MODE_SELECT_REGISTER, SLEEP, sleep_mode_bit); 609 610 if (FIELD_EX32(val, MODE_SELECT_REGISTER, LBACK)) { 611 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 612 613 qemu_log_mask(LOG_GUEST_ERROR, "%s: Attempting to set" 614 " LBACK mode without setting CEN bit as 0.\n", 615 path); 616 } else if (FIELD_EX32(val, MODE_SELECT_REGISTER, SNOOP)) { 617 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 618 619 qemu_log_mask(LOG_GUEST_ERROR, "%s: Attempting to set" 620 " SNOOP mode without setting CEN bit as 0.\n", 621 path); 622 } 623 624 update_status_register_mode_bits(s); 625 } 626 627 return s->regs[R_MODE_SELECT_REGISTER]; 628 } 629 630 static uint64_t can_brpr_pre_write(RegisterInfo *reg, uint64_t val) 631 { 632 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque); 633 634 /* Only allow writes when in config mode. */ 635 if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN)) { 636 return s->regs[R_ARBITRATION_PHASE_BAUD_RATE_PRESCALER_REGISTER]; 637 } 638 639 return val; 640 } 641 642 static uint64_t can_btr_pre_write(RegisterInfo *reg, uint64_t val) 643 { 644 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque); 645 646 /* Only allow writes when in config mode. */ 647 if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN)) { 648 return s->regs[R_ARBITRATION_PHASE_BIT_TIMING_REGISTER]; 649 } 650 651 return val; 652 } 653 654 static uint64_t can_tcr_pre_write(RegisterInfo *reg, uint64_t val) 655 { 656 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque); 657 658 if (FIELD_EX32(val, TIMESTAMP_REGISTER, CTS)) { 659 ptimer_transaction_begin(s->can_timer); 660 ptimer_set_count(s->can_timer, 0); 661 ptimer_transaction_commit(s->can_timer); 662 } 663 664 return 0; 665 } 666 667 static void update_rx_fifo(XlnxZynqMPCANState *s, const qemu_can_frame *frame) 668 { 669 bool filter_pass = false; 670 uint16_t timestamp = 0; 671 672 /* If no filter is enabled. Message will be stored in FIFO. */ 673 if (!((ARRAY_FIELD_EX32(s->regs, AFR, UAF1)) | 674 (ARRAY_FIELD_EX32(s->regs, AFR, UAF2)) | 675 (ARRAY_FIELD_EX32(s->regs, AFR, UAF3)) | 676 (ARRAY_FIELD_EX32(s->regs, AFR, UAF4)))) { 677 filter_pass = true; 678 } 679 680 /* 681 * Messages that pass any of the acceptance filters will be stored in 682 * the RX FIFO. 683 */ 684 if (ARRAY_FIELD_EX32(s->regs, AFR, UAF1)) { 685 uint32_t id_masked = s->regs[R_AFMR1] & frame->can_id; 686 uint32_t filter_id_masked = s->regs[R_AFMR1] & s->regs[R_AFIR1]; 687 688 if (filter_id_masked == id_masked) { 689 filter_pass = true; 690 } 691 } 692 693 if (ARRAY_FIELD_EX32(s->regs, AFR, UAF2)) { 694 uint32_t id_masked = s->regs[R_AFMR2] & frame->can_id; 695 uint32_t filter_id_masked = s->regs[R_AFMR2] & s->regs[R_AFIR2]; 696 697 if (filter_id_masked == id_masked) { 698 filter_pass = true; 699 } 700 } 701 702 if (ARRAY_FIELD_EX32(s->regs, AFR, UAF3)) { 703 uint32_t id_masked = s->regs[R_AFMR3] & frame->can_id; 704 uint32_t filter_id_masked = s->regs[R_AFMR3] & s->regs[R_AFIR3]; 705 706 if (filter_id_masked == id_masked) { 707 filter_pass = true; 708 } 709 } 710 711 if (ARRAY_FIELD_EX32(s->regs, AFR, UAF4)) { 712 uint32_t id_masked = s->regs[R_AFMR4] & frame->can_id; 713 uint32_t filter_id_masked = s->regs[R_AFMR4] & s->regs[R_AFIR4]; 714 715 if (filter_id_masked == id_masked) { 716 filter_pass = true; 717 } 718 } 719 720 if (!filter_pass) { 721 trace_xlnx_can_rx_fifo_filter_reject(frame->can_id, frame->can_dlc); 722 return; 723 } 724 725 /* Store the message in fifo if it passed through any of the filters. */ 726 if (filter_pass && frame->can_dlc <= MAX_DLC) { 727 728 if (fifo32_is_full(&s->rx_fifo)) { 729 ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXOFLW, 1); 730 } else { 731 timestamp = CAN_TIMER_MAX - ptimer_get_count(s->can_timer); 732 733 fifo32_push(&s->rx_fifo, frame->can_id); 734 735 fifo32_push(&s->rx_fifo, deposit32(0, R_RXFIFO_DLC_DLC_SHIFT, 736 R_RXFIFO_DLC_DLC_LENGTH, 737 frame->can_dlc) | 738 deposit32(0, R_RXFIFO_DLC_RXT_SHIFT, 739 R_RXFIFO_DLC_RXT_LENGTH, 740 timestamp)); 741 742 /* First 32 bit of the data. */ 743 fifo32_push(&s->rx_fifo, deposit32(0, R_RXFIFO_DATA1_DB3_SHIFT, 744 R_RXFIFO_DATA1_DB3_LENGTH, 745 frame->data[0]) | 746 deposit32(0, R_RXFIFO_DATA1_DB2_SHIFT, 747 R_RXFIFO_DATA1_DB2_LENGTH, 748 frame->data[1]) | 749 deposit32(0, R_RXFIFO_DATA1_DB1_SHIFT, 750 R_RXFIFO_DATA1_DB1_LENGTH, 751 frame->data[2]) | 752 deposit32(0, R_RXFIFO_DATA1_DB0_SHIFT, 753 R_RXFIFO_DATA1_DB0_LENGTH, 754 frame->data[3])); 755 /* Last 32 bit of the data. */ 756 fifo32_push(&s->rx_fifo, deposit32(0, R_RXFIFO_DATA2_DB7_SHIFT, 757 R_RXFIFO_DATA2_DB7_LENGTH, 758 frame->data[4]) | 759 deposit32(0, R_RXFIFO_DATA2_DB6_SHIFT, 760 R_RXFIFO_DATA2_DB6_LENGTH, 761 frame->data[5]) | 762 deposit32(0, R_RXFIFO_DATA2_DB5_SHIFT, 763 R_RXFIFO_DATA2_DB5_LENGTH, 764 frame->data[6]) | 765 deposit32(0, R_RXFIFO_DATA2_DB4_SHIFT, 766 R_RXFIFO_DATA2_DB4_LENGTH, 767 frame->data[7])); 768 769 ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXOK, 1); 770 trace_xlnx_can_rx_data(frame->can_id, frame->can_dlc, 771 frame->data[0], frame->data[1], 772 frame->data[2], frame->data[3], 773 frame->data[4], frame->data[5], 774 frame->data[6], frame->data[7]); 775 } 776 777 can_update_irq(s); 778 } 779 } 780 781 static uint64_t can_rxfifo_pre_read(RegisterInfo *reg, uint64_t val) 782 { 783 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque); 784 785 if (!fifo32_is_empty(&s->rx_fifo)) { 786 val = fifo32_pop(&s->rx_fifo); 787 } else { 788 ARRAY_FIELD_DP32(s->regs, INTERRUPT_STATUS_REGISTER, RXUFLW, 1); 789 } 790 791 can_update_irq(s); 792 return val; 793 } 794 795 static void can_filter_enable_post_write(RegisterInfo *reg, uint64_t val) 796 { 797 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque); 798 799 if (ARRAY_FIELD_EX32(s->regs, AFR, UAF1) && 800 ARRAY_FIELD_EX32(s->regs, AFR, UAF2) && 801 ARRAY_FIELD_EX32(s->regs, AFR, UAF3) && 802 ARRAY_FIELD_EX32(s->regs, AFR, UAF4)) { 803 ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, ACFBSY, 1); 804 } else { 805 ARRAY_FIELD_DP32(s->regs, STATUS_REGISTER, ACFBSY, 0); 806 } 807 } 808 809 static uint64_t can_filter_mask_pre_write(RegisterInfo *reg, uint64_t val) 810 { 811 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque); 812 uint32_t reg_idx = (reg->access->addr) / 4; 813 uint32_t filter_number = (reg_idx - R_AFMR1) / 2; 814 815 /* modify an acceptance filter, the corresponding UAF bit should be '0'. */ 816 if (!(s->regs[R_AFR] & (1 << filter_number))) { 817 s->regs[reg_idx] = val; 818 819 trace_xlnx_can_filter_mask_pre_write(filter_number, s->regs[reg_idx]); 820 } else { 821 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 822 823 qemu_log_mask(LOG_GUEST_ERROR, "%s: Acceptance filter %d" 824 " mask is not set as corresponding UAF bit is not 0.\n", 825 path, filter_number + 1); 826 } 827 828 return s->regs[reg_idx]; 829 } 830 831 static uint64_t can_filter_id_pre_write(RegisterInfo *reg, uint64_t val) 832 { 833 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque); 834 uint32_t reg_idx = (reg->access->addr) / 4; 835 uint32_t filter_number = (reg_idx - R_AFIR1) / 2; 836 837 if (!(s->regs[R_AFR] & (1 << filter_number))) { 838 s->regs[reg_idx] = val; 839 840 trace_xlnx_can_filter_id_pre_write(filter_number, s->regs[reg_idx]); 841 } else { 842 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 843 844 qemu_log_mask(LOG_GUEST_ERROR, "%s: Acceptance filter %d" 845 " id is not set as corresponding UAF bit is not 0.\n", 846 path, filter_number + 1); 847 } 848 849 return s->regs[reg_idx]; 850 } 851 852 static void can_tx_post_write(RegisterInfo *reg, uint64_t val) 853 { 854 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(reg->opaque); 855 856 bool is_txhpb = reg->access->addr > A_TXFIFO_DATA2; 857 858 bool initiate_transfer = (reg->access->addr == A_TXFIFO_DATA2) || 859 (reg->access->addr == A_TXHPB_DATA2); 860 861 Fifo32 *f = is_txhpb ? &s->txhpb_fifo : &s->tx_fifo; 862 863 if (!fifo32_is_full(f)) { 864 fifo32_push(f, val); 865 } else { 866 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 867 868 qemu_log_mask(LOG_GUEST_ERROR, "%s: TX FIFO is full.\n", path); 869 } 870 871 /* Initiate the message send if TX register is written. */ 872 if (initiate_transfer && 873 ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN)) { 874 transfer_fifo(s, f); 875 } 876 877 can_update_irq(s); 878 } 879 880 static const RegisterAccessInfo can_regs_info[] = { 881 { .name = "SOFTWARE_RESET_REGISTER", 882 .addr = A_SOFTWARE_RESET_REGISTER, 883 .rsvd = 0xfffffffc, 884 .pre_write = can_srr_pre_write, 885 },{ .name = "MODE_SELECT_REGISTER", 886 .addr = A_MODE_SELECT_REGISTER, 887 .rsvd = 0xfffffff8, 888 .pre_write = can_msr_pre_write, 889 },{ .name = "ARBITRATION_PHASE_BAUD_RATE_PRESCALER_REGISTER", 890 .addr = A_ARBITRATION_PHASE_BAUD_RATE_PRESCALER_REGISTER, 891 .rsvd = 0xffffff00, 892 .pre_write = can_brpr_pre_write, 893 },{ .name = "ARBITRATION_PHASE_BIT_TIMING_REGISTER", 894 .addr = A_ARBITRATION_PHASE_BIT_TIMING_REGISTER, 895 .rsvd = 0xfffffe00, 896 .pre_write = can_btr_pre_write, 897 },{ .name = "ERROR_COUNTER_REGISTER", 898 .addr = A_ERROR_COUNTER_REGISTER, 899 .rsvd = 0xffff0000, 900 .ro = 0xffffffff, 901 },{ .name = "ERROR_STATUS_REGISTER", 902 .addr = A_ERROR_STATUS_REGISTER, 903 .rsvd = 0xffffffe0, 904 .w1c = 0x1f, 905 },{ .name = "STATUS_REGISTER", .addr = A_STATUS_REGISTER, 906 .reset = 0x1, 907 .rsvd = 0xffffe000, 908 .ro = 0x1fff, 909 },{ .name = "INTERRUPT_STATUS_REGISTER", 910 .addr = A_INTERRUPT_STATUS_REGISTER, 911 .reset = 0x6000, 912 .rsvd = 0xffff8000, 913 .ro = 0x7fff, 914 },{ .name = "INTERRUPT_ENABLE_REGISTER", 915 .addr = A_INTERRUPT_ENABLE_REGISTER, 916 .rsvd = 0xffff8000, 917 .post_write = can_ier_post_write, 918 },{ .name = "INTERRUPT_CLEAR_REGISTER", 919 .addr = A_INTERRUPT_CLEAR_REGISTER, 920 .rsvd = 0xffff8000, 921 .pre_write = can_icr_pre_write, 922 },{ .name = "TIMESTAMP_REGISTER", 923 .addr = A_TIMESTAMP_REGISTER, 924 .rsvd = 0xfffffffe, 925 .pre_write = can_tcr_pre_write, 926 },{ .name = "WIR", .addr = A_WIR, 927 .reset = 0x3f3f, 928 .rsvd = 0xffff0000, 929 },{ .name = "TXFIFO_ID", .addr = A_TXFIFO_ID, 930 .post_write = can_tx_post_write, 931 },{ .name = "TXFIFO_DLC", .addr = A_TXFIFO_DLC, 932 .rsvd = 0xfffffff, 933 .post_write = can_tx_post_write, 934 },{ .name = "TXFIFO_DATA1", .addr = A_TXFIFO_DATA1, 935 .post_write = can_tx_post_write, 936 },{ .name = "TXFIFO_DATA2", .addr = A_TXFIFO_DATA2, 937 .post_write = can_tx_post_write, 938 },{ .name = "TXHPB_ID", .addr = A_TXHPB_ID, 939 .post_write = can_tx_post_write, 940 },{ .name = "TXHPB_DLC", .addr = A_TXHPB_DLC, 941 .rsvd = 0xfffffff, 942 .post_write = can_tx_post_write, 943 },{ .name = "TXHPB_DATA1", .addr = A_TXHPB_DATA1, 944 .post_write = can_tx_post_write, 945 },{ .name = "TXHPB_DATA2", .addr = A_TXHPB_DATA2, 946 .post_write = can_tx_post_write, 947 },{ .name = "RXFIFO_ID", .addr = A_RXFIFO_ID, 948 .ro = 0xffffffff, 949 .post_read = can_rxfifo_pre_read, 950 },{ .name = "RXFIFO_DLC", .addr = A_RXFIFO_DLC, 951 .rsvd = 0xfff0000, 952 .post_read = can_rxfifo_pre_read, 953 },{ .name = "RXFIFO_DATA1", .addr = A_RXFIFO_DATA1, 954 .post_read = can_rxfifo_pre_read, 955 },{ .name = "RXFIFO_DATA2", .addr = A_RXFIFO_DATA2, 956 .post_read = can_rxfifo_pre_read, 957 },{ .name = "AFR", .addr = A_AFR, 958 .rsvd = 0xfffffff0, 959 .post_write = can_filter_enable_post_write, 960 },{ .name = "AFMR1", .addr = A_AFMR1, 961 .pre_write = can_filter_mask_pre_write, 962 },{ .name = "AFIR1", .addr = A_AFIR1, 963 .pre_write = can_filter_id_pre_write, 964 },{ .name = "AFMR2", .addr = A_AFMR2, 965 .pre_write = can_filter_mask_pre_write, 966 },{ .name = "AFIR2", .addr = A_AFIR2, 967 .pre_write = can_filter_id_pre_write, 968 },{ .name = "AFMR3", .addr = A_AFMR3, 969 .pre_write = can_filter_mask_pre_write, 970 },{ .name = "AFIR3", .addr = A_AFIR3, 971 .pre_write = can_filter_id_pre_write, 972 },{ .name = "AFMR4", .addr = A_AFMR4, 973 .pre_write = can_filter_mask_pre_write, 974 },{ .name = "AFIR4", .addr = A_AFIR4, 975 .pre_write = can_filter_id_pre_write, 976 } 977 }; 978 979 static void xlnx_zynqmp_can_ptimer_cb(void *opaque) 980 { 981 /* No action required on the timer rollover. */ 982 } 983 984 static const MemoryRegionOps can_ops = { 985 .read = register_read_memory, 986 .write = register_write_memory, 987 .endianness = DEVICE_LITTLE_ENDIAN, 988 .valid = { 989 .min_access_size = 4, 990 .max_access_size = 4, 991 }, 992 }; 993 994 static void xlnx_zynqmp_can_reset_init(Object *obj, ResetType type) 995 { 996 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(obj); 997 unsigned int i; 998 999 for (i = R_RXFIFO_ID; i < ARRAY_SIZE(s->reg_info); ++i) { 1000 register_reset(&s->reg_info[i]); 1001 } 1002 1003 ptimer_transaction_begin(s->can_timer); 1004 ptimer_set_count(s->can_timer, 0); 1005 ptimer_transaction_commit(s->can_timer); 1006 } 1007 1008 static void xlnx_zynqmp_can_reset_hold(Object *obj) 1009 { 1010 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(obj); 1011 unsigned int i; 1012 1013 for (i = 0; i < R_RXFIFO_ID; ++i) { 1014 register_reset(&s->reg_info[i]); 1015 } 1016 1017 /* 1018 * Reset FIFOs when CAN model is reset. This will clear the fifo writes 1019 * done by post_write which gets called from register_reset function, 1020 * post_write handle will not be able to trigger tx because CAN will be 1021 * disabled when software_reset_register is cleared first. 1022 */ 1023 fifo32_reset(&s->rx_fifo); 1024 fifo32_reset(&s->tx_fifo); 1025 fifo32_reset(&s->txhpb_fifo); 1026 } 1027 1028 static bool xlnx_zynqmp_can_can_receive(CanBusClientState *client) 1029 { 1030 XlnxZynqMPCANState *s = container_of(client, XlnxZynqMPCANState, 1031 bus_client); 1032 1033 if (ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, SRST)) { 1034 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 1035 1036 qemu_log_mask(LOG_GUEST_ERROR, "%s: Controller is in reset state.\n", 1037 path); 1038 return false; 1039 } 1040 1041 if ((ARRAY_FIELD_EX32(s->regs, SOFTWARE_RESET_REGISTER, CEN)) == 0) { 1042 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 1043 1044 qemu_log_mask(LOG_GUEST_ERROR, "%s: Controller is disabled. Incoming" 1045 " messages will be discarded.\n", path); 1046 return false; 1047 } 1048 1049 return true; 1050 } 1051 1052 static ssize_t xlnx_zynqmp_can_receive(CanBusClientState *client, 1053 const qemu_can_frame *buf, size_t buf_size) { 1054 XlnxZynqMPCANState *s = container_of(client, XlnxZynqMPCANState, 1055 bus_client); 1056 const qemu_can_frame *frame = buf; 1057 1058 if (buf_size <= 0) { 1059 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 1060 1061 qemu_log_mask(LOG_GUEST_ERROR, "%s: Error in the data received.\n", 1062 path); 1063 return 0; 1064 } 1065 1066 if (ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, SNOOP)) { 1067 /* Snoop Mode: Just keep the data. no response back. */ 1068 update_rx_fifo(s, frame); 1069 } else if ((ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, SLEEP))) { 1070 /* 1071 * XlnxZynqMPCAN is in sleep mode. Any data on bus will bring it to wake 1072 * up state. 1073 */ 1074 can_exit_sleep_mode(s); 1075 update_rx_fifo(s, frame); 1076 } else if ((ARRAY_FIELD_EX32(s->regs, STATUS_REGISTER, SLEEP)) == 0) { 1077 update_rx_fifo(s, frame); 1078 } else { 1079 /* 1080 * XlnxZynqMPCAN will not participate in normal bus communication 1081 * and will not receive any messages transmitted by other CAN nodes. 1082 */ 1083 trace_xlnx_can_rx_discard(s->regs[R_STATUS_REGISTER]); 1084 } 1085 1086 return 1; 1087 } 1088 1089 static CanBusClientInfo can_xilinx_bus_client_info = { 1090 .can_receive = xlnx_zynqmp_can_can_receive, 1091 .receive = xlnx_zynqmp_can_receive, 1092 }; 1093 1094 static int xlnx_zynqmp_can_connect_to_bus(XlnxZynqMPCANState *s, 1095 CanBusState *bus) 1096 { 1097 s->bus_client.info = &can_xilinx_bus_client_info; 1098 1099 if (can_bus_insert_client(bus, &s->bus_client) < 0) { 1100 return -1; 1101 } 1102 return 0; 1103 } 1104 1105 static void xlnx_zynqmp_can_realize(DeviceState *dev, Error **errp) 1106 { 1107 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(dev); 1108 1109 if (s->canbus) { 1110 if (xlnx_zynqmp_can_connect_to_bus(s, s->canbus) < 0) { 1111 g_autofree char *path = object_get_canonical_path(OBJECT(s)); 1112 1113 error_setg(errp, "%s: xlnx_zynqmp_can_connect_to_bus" 1114 " failed.", path); 1115 return; 1116 } 1117 } 1118 1119 /* Create RX FIFO, TXFIFO, TXHPB storage. */ 1120 fifo32_create(&s->rx_fifo, RXFIFO_SIZE); 1121 fifo32_create(&s->tx_fifo, RXFIFO_SIZE); 1122 fifo32_create(&s->txhpb_fifo, CAN_FRAME_SIZE); 1123 1124 /* Allocate a new timer. */ 1125 s->can_timer = ptimer_init(xlnx_zynqmp_can_ptimer_cb, s, 1126 PTIMER_POLICY_LEGACY); 1127 1128 ptimer_transaction_begin(s->can_timer); 1129 1130 ptimer_set_freq(s->can_timer, s->cfg.ext_clk_freq); 1131 ptimer_set_limit(s->can_timer, CAN_TIMER_MAX, 1); 1132 ptimer_run(s->can_timer, 0); 1133 ptimer_transaction_commit(s->can_timer); 1134 } 1135 1136 static void xlnx_zynqmp_can_init(Object *obj) 1137 { 1138 XlnxZynqMPCANState *s = XLNX_ZYNQMP_CAN(obj); 1139 SysBusDevice *sbd = SYS_BUS_DEVICE(obj); 1140 1141 RegisterInfoArray *reg_array; 1142 1143 memory_region_init(&s->iomem, obj, TYPE_XLNX_ZYNQMP_CAN, 1144 XLNX_ZYNQMP_CAN_R_MAX * 4); 1145 reg_array = register_init_block32(DEVICE(obj), can_regs_info, 1146 ARRAY_SIZE(can_regs_info), 1147 s->reg_info, s->regs, 1148 &can_ops, 1149 XLNX_ZYNQMP_CAN_ERR_DEBUG, 1150 XLNX_ZYNQMP_CAN_R_MAX * 4); 1151 1152 memory_region_add_subregion(&s->iomem, 0x00, ®_array->mem); 1153 sysbus_init_mmio(sbd, &s->iomem); 1154 sysbus_init_irq(SYS_BUS_DEVICE(obj), &s->irq); 1155 } 1156 1157 static const VMStateDescription vmstate_can = { 1158 .name = TYPE_XLNX_ZYNQMP_CAN, 1159 .version_id = 1, 1160 .minimum_version_id = 1, 1161 .fields = (VMStateField[]) { 1162 VMSTATE_FIFO32(rx_fifo, XlnxZynqMPCANState), 1163 VMSTATE_FIFO32(tx_fifo, XlnxZynqMPCANState), 1164 VMSTATE_FIFO32(txhpb_fifo, XlnxZynqMPCANState), 1165 VMSTATE_UINT32_ARRAY(regs, XlnxZynqMPCANState, XLNX_ZYNQMP_CAN_R_MAX), 1166 VMSTATE_PTIMER(can_timer, XlnxZynqMPCANState), 1167 VMSTATE_END_OF_LIST(), 1168 } 1169 }; 1170 1171 static Property xlnx_zynqmp_can_properties[] = { 1172 DEFINE_PROP_UINT32("ext_clk_freq", XlnxZynqMPCANState, cfg.ext_clk_freq, 1173 CAN_DEFAULT_CLOCK), 1174 DEFINE_PROP_LINK("canbus", XlnxZynqMPCANState, canbus, TYPE_CAN_BUS, 1175 CanBusState *), 1176 DEFINE_PROP_END_OF_LIST(), 1177 }; 1178 1179 static void xlnx_zynqmp_can_class_init(ObjectClass *klass, void *data) 1180 { 1181 DeviceClass *dc = DEVICE_CLASS(klass); 1182 ResettableClass *rc = RESETTABLE_CLASS(klass); 1183 1184 rc->phases.enter = xlnx_zynqmp_can_reset_init; 1185 rc->phases.hold = xlnx_zynqmp_can_reset_hold; 1186 dc->realize = xlnx_zynqmp_can_realize; 1187 device_class_set_props(dc, xlnx_zynqmp_can_properties); 1188 dc->vmsd = &vmstate_can; 1189 } 1190 1191 static const TypeInfo can_info = { 1192 .name = TYPE_XLNX_ZYNQMP_CAN, 1193 .parent = TYPE_SYS_BUS_DEVICE, 1194 .instance_size = sizeof(XlnxZynqMPCANState), 1195 .class_init = xlnx_zynqmp_can_class_init, 1196 .instance_init = xlnx_zynqmp_can_init, 1197 }; 1198 1199 static void can_register_types(void) 1200 { 1201 type_register_static(&can_info); 1202 } 1203 1204 type_init(can_register_types) 1205