/* This file is autogenerated by tracetool, do not edit. */

#ifndef TRACE_HW_SD_GENERATED_TRACERS_H
#define TRACE_HW_SD_GENERATED_TRACERS_H

#include "trace/control.h"

extern TraceEvent _TRACE_ALLWINNER_SDHOST_SET_INSERTED_EVENT;
extern TraceEvent _TRACE_ALLWINNER_SDHOST_PROCESS_DESC_EVENT;
extern TraceEvent _TRACE_ALLWINNER_SDHOST_READ_EVENT;
extern TraceEvent _TRACE_ALLWINNER_SDHOST_WRITE_EVENT;
extern TraceEvent _TRACE_ALLWINNER_SDHOST_UPDATE_IRQ_EVENT;
extern TraceEvent _TRACE_BCM2835_SDHOST_READ_EVENT;
extern TraceEvent _TRACE_BCM2835_SDHOST_WRITE_EVENT;
extern TraceEvent _TRACE_BCM2835_SDHOST_EDM_CHANGE_EVENT;
extern TraceEvent _TRACE_BCM2835_SDHOST_UPDATE_IRQ_EVENT;
extern TraceEvent _TRACE_SDBUS_COMMAND_EVENT;
extern TraceEvent _TRACE_SDBUS_READ_EVENT;
extern TraceEvent _TRACE_SDBUS_WRITE_EVENT;
extern TraceEvent _TRACE_SDBUS_SET_VOLTAGE_EVENT;
extern TraceEvent _TRACE_SDBUS_GET_DAT_LINES_EVENT;
extern TraceEvent _TRACE_SDBUS_GET_CMD_LINE_EVENT;
extern TraceEvent _TRACE_SDHCI_SET_INSERTED_EVENT;
extern TraceEvent _TRACE_SDHCI_SEND_COMMAND_EVENT;
extern TraceEvent _TRACE_SDHCI_ERROR_EVENT;
extern TraceEvent _TRACE_SDHCI_RESPONSE4_EVENT;
extern TraceEvent _TRACE_SDHCI_RESPONSE16_EVENT;
extern TraceEvent _TRACE_SDHCI_END_TRANSFER_EVENT;
extern TraceEvent _TRACE_SDHCI_ADMA_EVENT;
extern TraceEvent _TRACE_SDHCI_ADMA_LOOP_EVENT;
extern TraceEvent _TRACE_SDHCI_ADMA_TRANSFER_COMPLETED_EVENT;
extern TraceEvent _TRACE_SDHCI_ACCESS_EVENT;
extern TraceEvent _TRACE_SDHCI_READ_DATAPORT_EVENT;
extern TraceEvent _TRACE_SDHCI_WRITE_DATAPORT_EVENT;
extern TraceEvent _TRACE_SDHCI_CAPAREG_EVENT;
extern TraceEvent _TRACE_SDCARD_NORMAL_COMMAND_EVENT;
extern TraceEvent _TRACE_SDCARD_APP_COMMAND_EVENT;
extern TraceEvent _TRACE_SDCARD_RESPONSE_EVENT;
extern TraceEvent _TRACE_SDCARD_POWERUP_EVENT;
extern TraceEvent _TRACE_SDCARD_INQUIRY_CMD41_EVENT;
extern TraceEvent _TRACE_SDCARD_RESET_EVENT;
extern TraceEvent _TRACE_SDCARD_SET_BLOCKLEN_EVENT;
extern TraceEvent _TRACE_SDCARD_INSERTED_EVENT;
extern TraceEvent _TRACE_SDCARD_EJECTED_EVENT;
extern TraceEvent _TRACE_SDCARD_ERASE_EVENT;
extern TraceEvent _TRACE_SDCARD_LOCK_EVENT;
extern TraceEvent _TRACE_SDCARD_UNLOCK_EVENT;
extern TraceEvent _TRACE_SDCARD_READ_BLOCK_EVENT;
extern TraceEvent _TRACE_SDCARD_WRITE_BLOCK_EVENT;
extern TraceEvent _TRACE_SDCARD_WRITE_DATA_EVENT;
extern TraceEvent _TRACE_SDCARD_READ_DATA_EVENT;
extern TraceEvent _TRACE_SDCARD_SET_VOLTAGE_EVENT;
extern TraceEvent _TRACE_PXA2XX_MMCI_READ_EVENT;
extern TraceEvent _TRACE_PXA2XX_MMCI_WRITE_EVENT;
extern TraceEvent _TRACE_PL181_COMMAND_SEND_EVENT;
extern TraceEvent _TRACE_PL181_COMMAND_SENT_EVENT;
extern TraceEvent _TRACE_PL181_COMMAND_RESPONSE_PENDING_EVENT;
extern TraceEvent _TRACE_PL181_COMMAND_TIMEOUT_EVENT;
extern TraceEvent _TRACE_PL181_FIFO_PUSH_EVENT;
extern TraceEvent _TRACE_PL181_FIFO_POP_EVENT;
extern TraceEvent _TRACE_PL181_FIFO_TRANSFER_COMPLETE_EVENT;
extern TraceEvent _TRACE_PL181_DATA_ENGINE_IDLE_EVENT;
extern TraceEvent _TRACE_ASPEED_SDHCI_READ_EVENT;
extern TraceEvent _TRACE_ASPEED_SDHCI_WRITE_EVENT;
extern uint16_t _TRACE_ALLWINNER_SDHOST_SET_INSERTED_DSTATE;
extern uint16_t _TRACE_ALLWINNER_SDHOST_PROCESS_DESC_DSTATE;
extern uint16_t _TRACE_ALLWINNER_SDHOST_READ_DSTATE;
extern uint16_t _TRACE_ALLWINNER_SDHOST_WRITE_DSTATE;
extern uint16_t _TRACE_ALLWINNER_SDHOST_UPDATE_IRQ_DSTATE;
extern uint16_t _TRACE_BCM2835_SDHOST_READ_DSTATE;
extern uint16_t _TRACE_BCM2835_SDHOST_WRITE_DSTATE;
extern uint16_t _TRACE_BCM2835_SDHOST_EDM_CHANGE_DSTATE;
extern uint16_t _TRACE_BCM2835_SDHOST_UPDATE_IRQ_DSTATE;
extern uint16_t _TRACE_SDBUS_COMMAND_DSTATE;
extern uint16_t _TRACE_SDBUS_READ_DSTATE;
extern uint16_t _TRACE_SDBUS_WRITE_DSTATE;
extern uint16_t _TRACE_SDBUS_SET_VOLTAGE_DSTATE;
extern uint16_t _TRACE_SDBUS_GET_DAT_LINES_DSTATE;
extern uint16_t _TRACE_SDBUS_GET_CMD_LINE_DSTATE;
extern uint16_t _TRACE_SDHCI_SET_INSERTED_DSTATE;
extern uint16_t _TRACE_SDHCI_SEND_COMMAND_DSTATE;
extern uint16_t _TRACE_SDHCI_ERROR_DSTATE;
extern uint16_t _TRACE_SDHCI_RESPONSE4_DSTATE;
extern uint16_t _TRACE_SDHCI_RESPONSE16_DSTATE;
extern uint16_t _TRACE_SDHCI_END_TRANSFER_DSTATE;
extern uint16_t _TRACE_SDHCI_ADMA_DSTATE;
extern uint16_t _TRACE_SDHCI_ADMA_LOOP_DSTATE;
extern uint16_t _TRACE_SDHCI_ADMA_TRANSFER_COMPLETED_DSTATE;
extern uint16_t _TRACE_SDHCI_ACCESS_DSTATE;
extern uint16_t _TRACE_SDHCI_READ_DATAPORT_DSTATE;
extern uint16_t _TRACE_SDHCI_WRITE_DATAPORT_DSTATE;
extern uint16_t _TRACE_SDHCI_CAPAREG_DSTATE;
extern uint16_t _TRACE_SDCARD_NORMAL_COMMAND_DSTATE;
extern uint16_t _TRACE_SDCARD_APP_COMMAND_DSTATE;
extern uint16_t _TRACE_SDCARD_RESPONSE_DSTATE;
extern uint16_t _TRACE_SDCARD_POWERUP_DSTATE;
extern uint16_t _TRACE_SDCARD_INQUIRY_CMD41_DSTATE;
extern uint16_t _TRACE_SDCARD_RESET_DSTATE;
extern uint16_t _TRACE_SDCARD_SET_BLOCKLEN_DSTATE;
extern uint16_t _TRACE_SDCARD_INSERTED_DSTATE;
extern uint16_t _TRACE_SDCARD_EJECTED_DSTATE;
extern uint16_t _TRACE_SDCARD_ERASE_DSTATE;
extern uint16_t _TRACE_SDCARD_LOCK_DSTATE;
extern uint16_t _TRACE_SDCARD_UNLOCK_DSTATE;
extern uint16_t _TRACE_SDCARD_READ_BLOCK_DSTATE;
extern uint16_t _TRACE_SDCARD_WRITE_BLOCK_DSTATE;
extern uint16_t _TRACE_SDCARD_WRITE_DATA_DSTATE;
extern uint16_t _TRACE_SDCARD_READ_DATA_DSTATE;
extern uint16_t _TRACE_SDCARD_SET_VOLTAGE_DSTATE;
extern uint16_t _TRACE_PXA2XX_MMCI_READ_DSTATE;
extern uint16_t _TRACE_PXA2XX_MMCI_WRITE_DSTATE;
extern uint16_t _TRACE_PL181_COMMAND_SEND_DSTATE;
extern uint16_t _TRACE_PL181_COMMAND_SENT_DSTATE;
extern uint16_t _TRACE_PL181_COMMAND_RESPONSE_PENDING_DSTATE;
extern uint16_t _TRACE_PL181_COMMAND_TIMEOUT_DSTATE;
extern uint16_t _TRACE_PL181_FIFO_PUSH_DSTATE;
extern uint16_t _TRACE_PL181_FIFO_POP_DSTATE;
extern uint16_t _TRACE_PL181_FIFO_TRANSFER_COMPLETE_DSTATE;
extern uint16_t _TRACE_PL181_DATA_ENGINE_IDLE_DSTATE;
extern uint16_t _TRACE_ASPEED_SDHCI_READ_DSTATE;
extern uint16_t _TRACE_ASPEED_SDHCI_WRITE_DSTATE;
#define TRACE_ALLWINNER_SDHOST_SET_INSERTED_ENABLED 1
#define TRACE_ALLWINNER_SDHOST_PROCESS_DESC_ENABLED 1
#define TRACE_ALLWINNER_SDHOST_READ_ENABLED 1
#define TRACE_ALLWINNER_SDHOST_WRITE_ENABLED 1
#define TRACE_ALLWINNER_SDHOST_UPDATE_IRQ_ENABLED 1
#define TRACE_BCM2835_SDHOST_READ_ENABLED 1
#define TRACE_BCM2835_SDHOST_WRITE_ENABLED 1
#define TRACE_BCM2835_SDHOST_EDM_CHANGE_ENABLED 1
#define TRACE_BCM2835_SDHOST_UPDATE_IRQ_ENABLED 1
#define TRACE_SDBUS_COMMAND_ENABLED 1
#define TRACE_SDBUS_READ_ENABLED 1
#define TRACE_SDBUS_WRITE_ENABLED 1
#define TRACE_SDBUS_SET_VOLTAGE_ENABLED 1
#define TRACE_SDBUS_GET_DAT_LINES_ENABLED 1
#define TRACE_SDBUS_GET_CMD_LINE_ENABLED 1
#define TRACE_SDHCI_SET_INSERTED_ENABLED 1
#define TRACE_SDHCI_SEND_COMMAND_ENABLED 1
#define TRACE_SDHCI_ERROR_ENABLED 1
#define TRACE_SDHCI_RESPONSE4_ENABLED 1
#define TRACE_SDHCI_RESPONSE16_ENABLED 1
#define TRACE_SDHCI_END_TRANSFER_ENABLED 1
#define TRACE_SDHCI_ADMA_ENABLED 1
#define TRACE_SDHCI_ADMA_LOOP_ENABLED 1
#define TRACE_SDHCI_ADMA_TRANSFER_COMPLETED_ENABLED 1
#define TRACE_SDHCI_ACCESS_ENABLED 1
#define TRACE_SDHCI_READ_DATAPORT_ENABLED 1
#define TRACE_SDHCI_WRITE_DATAPORT_ENABLED 1
#define TRACE_SDHCI_CAPAREG_ENABLED 1
#define TRACE_SDCARD_NORMAL_COMMAND_ENABLED 1
#define TRACE_SDCARD_APP_COMMAND_ENABLED 1
#define TRACE_SDCARD_RESPONSE_ENABLED 1
#define TRACE_SDCARD_POWERUP_ENABLED 1
#define TRACE_SDCARD_INQUIRY_CMD41_ENABLED 1
#define TRACE_SDCARD_RESET_ENABLED 1
#define TRACE_SDCARD_SET_BLOCKLEN_ENABLED 1
#define TRACE_SDCARD_INSERTED_ENABLED 1
#define TRACE_SDCARD_EJECTED_ENABLED 1
#define TRACE_SDCARD_ERASE_ENABLED 1
#define TRACE_SDCARD_LOCK_ENABLED 1
#define TRACE_SDCARD_UNLOCK_ENABLED 1
#define TRACE_SDCARD_READ_BLOCK_ENABLED 1
#define TRACE_SDCARD_WRITE_BLOCK_ENABLED 1
#define TRACE_SDCARD_WRITE_DATA_ENABLED 1
#define TRACE_SDCARD_READ_DATA_ENABLED 1
#define TRACE_SDCARD_SET_VOLTAGE_ENABLED 1
#define TRACE_PXA2XX_MMCI_READ_ENABLED 1
#define TRACE_PXA2XX_MMCI_WRITE_ENABLED 1
#define TRACE_PL181_COMMAND_SEND_ENABLED 1
#define TRACE_PL181_COMMAND_SENT_ENABLED 1
#define TRACE_PL181_COMMAND_RESPONSE_PENDING_ENABLED 1
#define TRACE_PL181_COMMAND_TIMEOUT_ENABLED 1
#define TRACE_PL181_FIFO_PUSH_ENABLED 1
#define TRACE_PL181_FIFO_POP_ENABLED 1
#define TRACE_PL181_FIFO_TRANSFER_COMPLETE_ENABLED 1
#define TRACE_PL181_DATA_ENGINE_IDLE_ENABLED 1
#define TRACE_ASPEED_SDHCI_READ_ENABLED 1
#define TRACE_ASPEED_SDHCI_WRITE_ENABLED 1
#include "qemu/log-for-trace.h"
#include "qemu/error-report.h"


#define TRACE_ALLWINNER_SDHOST_SET_INSERTED_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ALLWINNER_SDHOST_SET_INSERTED) || \
    false)

static inline void _nocheck__trace_allwinner_sdhost_set_inserted(bool inserted)
{
    if (trace_event_get_state(TRACE_ALLWINNER_SDHOST_SET_INSERTED) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 4 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:allwinner_sdhost_set_inserted " "inserted %u" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , inserted);
#line 199 "trace/trace-hw_sd.h"
        } else {
#line 4 "../git/hw/sd/trace-events"
            qemu_log("allwinner_sdhost_set_inserted " "inserted %u" "\n", inserted);
#line 203 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_allwinner_sdhost_set_inserted(bool inserted)
{
    if (true) {
        _nocheck__trace_allwinner_sdhost_set_inserted(inserted);
    }
}

#define TRACE_ALLWINNER_SDHOST_PROCESS_DESC_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ALLWINNER_SDHOST_PROCESS_DESC) || \
    false)

static inline void _nocheck__trace_allwinner_sdhost_process_desc(uint64_t desc_addr, uint32_t desc_size, bool is_write, uint32_t max_bytes)
{
    if (trace_event_get_state(TRACE_ALLWINNER_SDHOST_PROCESS_DESC) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 5 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:allwinner_sdhost_process_desc " "desc_addr 0x%" PRIx64 " desc_size %" PRIu32 " is_write %u max_bytes %" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , desc_addr, desc_size, is_write, max_bytes);
#line 230 "trace/trace-hw_sd.h"
        } else {
#line 5 "../git/hw/sd/trace-events"
            qemu_log("allwinner_sdhost_process_desc " "desc_addr 0x%" PRIx64 " desc_size %" PRIu32 " is_write %u max_bytes %" PRIu32 "\n", desc_addr, desc_size, is_write, max_bytes);
#line 234 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_allwinner_sdhost_process_desc(uint64_t desc_addr, uint32_t desc_size, bool is_write, uint32_t max_bytes)
{
    if (true) {
        _nocheck__trace_allwinner_sdhost_process_desc(desc_addr, desc_size, is_write, max_bytes);
    }
}

#define TRACE_ALLWINNER_SDHOST_READ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ALLWINNER_SDHOST_READ) || \
    false)

static inline void _nocheck__trace_allwinner_sdhost_read(uint64_t offset, uint64_t data, unsigned size)
{
    if (trace_event_get_state(TRACE_ALLWINNER_SDHOST_READ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 6 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:allwinner_sdhost_read " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , offset, data, size);
#line 261 "trace/trace-hw_sd.h"
        } else {
#line 6 "../git/hw/sd/trace-events"
            qemu_log("allwinner_sdhost_read " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32 "\n", offset, data, size);
#line 265 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_allwinner_sdhost_read(uint64_t offset, uint64_t data, unsigned size)
{
    if (true) {
        _nocheck__trace_allwinner_sdhost_read(offset, data, size);
    }
}

#define TRACE_ALLWINNER_SDHOST_WRITE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ALLWINNER_SDHOST_WRITE) || \
    false)

static inline void _nocheck__trace_allwinner_sdhost_write(uint64_t offset, uint64_t data, unsigned size)
{
    if (trace_event_get_state(TRACE_ALLWINNER_SDHOST_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 7 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:allwinner_sdhost_write " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , offset, data, size);
#line 292 "trace/trace-hw_sd.h"
        } else {
#line 7 "../git/hw/sd/trace-events"
            qemu_log("allwinner_sdhost_write " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32 "\n", offset, data, size);
#line 296 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_allwinner_sdhost_write(uint64_t offset, uint64_t data, unsigned size)
{
    if (true) {
        _nocheck__trace_allwinner_sdhost_write(offset, data, size);
    }
}

#define TRACE_ALLWINNER_SDHOST_UPDATE_IRQ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ALLWINNER_SDHOST_UPDATE_IRQ) || \
    false)

static inline void _nocheck__trace_allwinner_sdhost_update_irq(uint32_t irq)
{
    if (trace_event_get_state(TRACE_ALLWINNER_SDHOST_UPDATE_IRQ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 8 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:allwinner_sdhost_update_irq " "IRQ bits 0x%" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , irq);
#line 323 "trace/trace-hw_sd.h"
        } else {
#line 8 "../git/hw/sd/trace-events"
            qemu_log("allwinner_sdhost_update_irq " "IRQ bits 0x%" PRIx32 "\n", irq);
#line 327 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_allwinner_sdhost_update_irq(uint32_t irq)
{
    if (true) {
        _nocheck__trace_allwinner_sdhost_update_irq(irq);
    }
}

#define TRACE_BCM2835_SDHOST_READ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_BCM2835_SDHOST_READ) || \
    false)

static inline void _nocheck__trace_bcm2835_sdhost_read(uint64_t offset, uint64_t data, unsigned size)
{
    if (trace_event_get_state(TRACE_BCM2835_SDHOST_READ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 11 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:bcm2835_sdhost_read " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %u" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , offset, data, size);
#line 354 "trace/trace-hw_sd.h"
        } else {
#line 11 "../git/hw/sd/trace-events"
            qemu_log("bcm2835_sdhost_read " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %u" "\n", offset, data, size);
#line 358 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_bcm2835_sdhost_read(uint64_t offset, uint64_t data, unsigned size)
{
    if (true) {
        _nocheck__trace_bcm2835_sdhost_read(offset, data, size);
    }
}

#define TRACE_BCM2835_SDHOST_WRITE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_BCM2835_SDHOST_WRITE) || \
    false)

static inline void _nocheck__trace_bcm2835_sdhost_write(uint64_t offset, uint64_t data, unsigned size)
{
    if (trace_event_get_state(TRACE_BCM2835_SDHOST_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 12 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:bcm2835_sdhost_write " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %u" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , offset, data, size);
#line 385 "trace/trace-hw_sd.h"
        } else {
#line 12 "../git/hw/sd/trace-events"
            qemu_log("bcm2835_sdhost_write " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %u" "\n", offset, data, size);
#line 389 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_bcm2835_sdhost_write(uint64_t offset, uint64_t data, unsigned size)
{
    if (true) {
        _nocheck__trace_bcm2835_sdhost_write(offset, data, size);
    }
}

#define TRACE_BCM2835_SDHOST_EDM_CHANGE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_BCM2835_SDHOST_EDM_CHANGE) || \
    false)

static inline void _nocheck__trace_bcm2835_sdhost_edm_change(const char * why, uint32_t edm)
{
    if (trace_event_get_state(TRACE_BCM2835_SDHOST_EDM_CHANGE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 13 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:bcm2835_sdhost_edm_change " "(%s) EDM now 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , why, edm);
#line 416 "trace/trace-hw_sd.h"
        } else {
#line 13 "../git/hw/sd/trace-events"
            qemu_log("bcm2835_sdhost_edm_change " "(%s) EDM now 0x%x" "\n", why, edm);
#line 420 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_bcm2835_sdhost_edm_change(const char * why, uint32_t edm)
{
    if (true) {
        _nocheck__trace_bcm2835_sdhost_edm_change(why, edm);
    }
}

#define TRACE_BCM2835_SDHOST_UPDATE_IRQ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_BCM2835_SDHOST_UPDATE_IRQ) || \
    false)

static inline void _nocheck__trace_bcm2835_sdhost_update_irq(uint32_t irq)
{
    if (trace_event_get_state(TRACE_BCM2835_SDHOST_UPDATE_IRQ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 14 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:bcm2835_sdhost_update_irq " "IRQ bits 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , irq);
#line 447 "trace/trace-hw_sd.h"
        } else {
#line 14 "../git/hw/sd/trace-events"
            qemu_log("bcm2835_sdhost_update_irq " "IRQ bits 0x%x" "\n", irq);
#line 451 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_bcm2835_sdhost_update_irq(uint32_t irq)
{
    if (true) {
        _nocheck__trace_bcm2835_sdhost_update_irq(irq);
    }
}

#define TRACE_SDBUS_COMMAND_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDBUS_COMMAND) || \
    false)

static inline void _nocheck__trace_sdbus_command(const char * bus_name, uint8_t cmd, uint32_t arg)
{
    if (trace_event_get_state(TRACE_SDBUS_COMMAND) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 17 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdbus_command " "@%s CMD%02d arg 0x%08x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , bus_name, cmd, arg);
#line 478 "trace/trace-hw_sd.h"
        } else {
#line 17 "../git/hw/sd/trace-events"
            qemu_log("sdbus_command " "@%s CMD%02d arg 0x%08x" "\n", bus_name, cmd, arg);
#line 482 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdbus_command(const char * bus_name, uint8_t cmd, uint32_t arg)
{
    if (true) {
        _nocheck__trace_sdbus_command(bus_name, cmd, arg);
    }
}

#define TRACE_SDBUS_READ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDBUS_READ) || \
    false)

static inline void _nocheck__trace_sdbus_read(const char * bus_name, uint8_t value)
{
    if (trace_event_get_state(TRACE_SDBUS_READ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 18 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdbus_read " "@%s value 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , bus_name, value);
#line 509 "trace/trace-hw_sd.h"
        } else {
#line 18 "../git/hw/sd/trace-events"
            qemu_log("sdbus_read " "@%s value 0x%02x" "\n", bus_name, value);
#line 513 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdbus_read(const char * bus_name, uint8_t value)
{
    if (true) {
        _nocheck__trace_sdbus_read(bus_name, value);
    }
}

#define TRACE_SDBUS_WRITE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDBUS_WRITE) || \
    false)

static inline void _nocheck__trace_sdbus_write(const char * bus_name, uint8_t value)
{
    if (trace_event_get_state(TRACE_SDBUS_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 19 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdbus_write " "@%s value 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , bus_name, value);
#line 540 "trace/trace-hw_sd.h"
        } else {
#line 19 "../git/hw/sd/trace-events"
            qemu_log("sdbus_write " "@%s value 0x%02x" "\n", bus_name, value);
#line 544 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdbus_write(const char * bus_name, uint8_t value)
{
    if (true) {
        _nocheck__trace_sdbus_write(bus_name, value);
    }
}

#define TRACE_SDBUS_SET_VOLTAGE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDBUS_SET_VOLTAGE) || \
    false)

static inline void _nocheck__trace_sdbus_set_voltage(const char * bus_name, uint16_t millivolts)
{
    if (trace_event_get_state(TRACE_SDBUS_SET_VOLTAGE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 20 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdbus_set_voltage " "@%s %u (mV)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , bus_name, millivolts);
#line 571 "trace/trace-hw_sd.h"
        } else {
#line 20 "../git/hw/sd/trace-events"
            qemu_log("sdbus_set_voltage " "@%s %u (mV)" "\n", bus_name, millivolts);
#line 575 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdbus_set_voltage(const char * bus_name, uint16_t millivolts)
{
    if (true) {
        _nocheck__trace_sdbus_set_voltage(bus_name, millivolts);
    }
}

#define TRACE_SDBUS_GET_DAT_LINES_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDBUS_GET_DAT_LINES) || \
    false)

static inline void _nocheck__trace_sdbus_get_dat_lines(const char * bus_name, uint8_t dat_lines)
{
    if (trace_event_get_state(TRACE_SDBUS_GET_DAT_LINES) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 21 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdbus_get_dat_lines " "@%s dat_lines: %u" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , bus_name, dat_lines);
#line 602 "trace/trace-hw_sd.h"
        } else {
#line 21 "../git/hw/sd/trace-events"
            qemu_log("sdbus_get_dat_lines " "@%s dat_lines: %u" "\n", bus_name, dat_lines);
#line 606 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdbus_get_dat_lines(const char * bus_name, uint8_t dat_lines)
{
    if (true) {
        _nocheck__trace_sdbus_get_dat_lines(bus_name, dat_lines);
    }
}

#define TRACE_SDBUS_GET_CMD_LINE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDBUS_GET_CMD_LINE) || \
    false)

static inline void _nocheck__trace_sdbus_get_cmd_line(const char * bus_name, bool cmd_line)
{
    if (trace_event_get_state(TRACE_SDBUS_GET_CMD_LINE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 22 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdbus_get_cmd_line " "@%s cmd_line: %u" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , bus_name, cmd_line);
#line 633 "trace/trace-hw_sd.h"
        } else {
#line 22 "../git/hw/sd/trace-events"
            qemu_log("sdbus_get_cmd_line " "@%s cmd_line: %u" "\n", bus_name, cmd_line);
#line 637 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdbus_get_cmd_line(const char * bus_name, bool cmd_line)
{
    if (true) {
        _nocheck__trace_sdbus_get_cmd_line(bus_name, cmd_line);
    }
}

#define TRACE_SDHCI_SET_INSERTED_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_SET_INSERTED) || \
    false)

static inline void _nocheck__trace_sdhci_set_inserted(const char * level)
{
    if (trace_event_get_state(TRACE_SDHCI_SET_INSERTED) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 25 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_set_inserted " "card state changed: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , level);
#line 664 "trace/trace-hw_sd.h"
        } else {
#line 25 "../git/hw/sd/trace-events"
            qemu_log("sdhci_set_inserted " "card state changed: %s" "\n", level);
#line 668 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_set_inserted(const char * level)
{
    if (true) {
        _nocheck__trace_sdhci_set_inserted(level);
    }
}

#define TRACE_SDHCI_SEND_COMMAND_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_SEND_COMMAND) || \
    false)

static inline void _nocheck__trace_sdhci_send_command(uint8_t cmd, uint32_t arg)
{
    if (trace_event_get_state(TRACE_SDHCI_SEND_COMMAND) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 26 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_send_command " "CMD%02u ARG[0x%08x]" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cmd, arg);
#line 695 "trace/trace-hw_sd.h"
        } else {
#line 26 "../git/hw/sd/trace-events"
            qemu_log("sdhci_send_command " "CMD%02u ARG[0x%08x]" "\n", cmd, arg);
#line 699 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_send_command(uint8_t cmd, uint32_t arg)
{
    if (true) {
        _nocheck__trace_sdhci_send_command(cmd, arg);
    }
}

#define TRACE_SDHCI_ERROR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_ERROR) || \
    false)

static inline void _nocheck__trace_sdhci_error(const char * msg)
{
    if (trace_event_get_state(TRACE_SDHCI_ERROR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 27 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_error " "%s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 726 "trace/trace-hw_sd.h"
        } else {
#line 27 "../git/hw/sd/trace-events"
            qemu_log("sdhci_error " "%s" "\n", msg);
#line 730 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_error(const char * msg)
{
    if (true) {
        _nocheck__trace_sdhci_error(msg);
    }
}

#define TRACE_SDHCI_RESPONSE4_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_RESPONSE4) || \
    false)

static inline void _nocheck__trace_sdhci_response4(uint32_t r0)
{
    if (trace_event_get_state(TRACE_SDHCI_RESPONSE4) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 28 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_response4 " "RSPREG[31..0]=0x%08x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , r0);
#line 757 "trace/trace-hw_sd.h"
        } else {
#line 28 "../git/hw/sd/trace-events"
            qemu_log("sdhci_response4 " "RSPREG[31..0]=0x%08x" "\n", r0);
#line 761 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_response4(uint32_t r0)
{
    if (true) {
        _nocheck__trace_sdhci_response4(r0);
    }
}

#define TRACE_SDHCI_RESPONSE16_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_RESPONSE16) || \
    false)

static inline void _nocheck__trace_sdhci_response16(uint32_t r3, uint32_t r2, uint32_t r1, uint32_t r0)
{
    if (trace_event_get_state(TRACE_SDHCI_RESPONSE16) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 29 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_response16 " "RSPREG[127..96]=0x%08x, RSPREG[95..64]=0x%08x, RSPREG[63..32]=0x%08x, RSPREG[31..0]=0x%08x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , r3, r2, r1, r0);
#line 788 "trace/trace-hw_sd.h"
        } else {
#line 29 "../git/hw/sd/trace-events"
            qemu_log("sdhci_response16 " "RSPREG[127..96]=0x%08x, RSPREG[95..64]=0x%08x, RSPREG[63..32]=0x%08x, RSPREG[31..0]=0x%08x" "\n", r3, r2, r1, r0);
#line 792 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_response16(uint32_t r3, uint32_t r2, uint32_t r1, uint32_t r0)
{
    if (true) {
        _nocheck__trace_sdhci_response16(r3, r2, r1, r0);
    }
}

#define TRACE_SDHCI_END_TRANSFER_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_END_TRANSFER) || \
    false)

static inline void _nocheck__trace_sdhci_end_transfer(uint8_t cmd, uint32_t arg)
{
    if (trace_event_get_state(TRACE_SDHCI_END_TRANSFER) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 30 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_end_transfer " "Automatically issue CMD%02u 0x%08x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cmd, arg);
#line 819 "trace/trace-hw_sd.h"
        } else {
#line 30 "../git/hw/sd/trace-events"
            qemu_log("sdhci_end_transfer " "Automatically issue CMD%02u 0x%08x" "\n", cmd, arg);
#line 823 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_end_transfer(uint8_t cmd, uint32_t arg)
{
    if (true) {
        _nocheck__trace_sdhci_end_transfer(cmd, arg);
    }
}

#define TRACE_SDHCI_ADMA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_ADMA) || \
    false)

static inline void _nocheck__trace_sdhci_adma(const char * desc, uint32_t sysad)
{
    if (trace_event_get_state(TRACE_SDHCI_ADMA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 31 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_adma " "%s: admasysaddr=0x%" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , desc, sysad);
#line 850 "trace/trace-hw_sd.h"
        } else {
#line 31 "../git/hw/sd/trace-events"
            qemu_log("sdhci_adma " "%s: admasysaddr=0x%" PRIx32 "\n", desc, sysad);
#line 854 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_adma(const char * desc, uint32_t sysad)
{
    if (true) {
        _nocheck__trace_sdhci_adma(desc, sysad);
    }
}

#define TRACE_SDHCI_ADMA_LOOP_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_ADMA_LOOP) || \
    false)

static inline void _nocheck__trace_sdhci_adma_loop(uint64_t addr, uint16_t length, uint8_t attr)
{
    if (trace_event_get_state(TRACE_SDHCI_ADMA_LOOP) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 32 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_adma_loop " "addr=0x%08" PRIx64 ", len=%d, attr=0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , addr, length, attr);
#line 881 "trace/trace-hw_sd.h"
        } else {
#line 32 "../git/hw/sd/trace-events"
            qemu_log("sdhci_adma_loop " "addr=0x%08" PRIx64 ", len=%d, attr=0x%x" "\n", addr, length, attr);
#line 885 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_adma_loop(uint64_t addr, uint16_t length, uint8_t attr)
{
    if (true) {
        _nocheck__trace_sdhci_adma_loop(addr, length, attr);
    }
}

#define TRACE_SDHCI_ADMA_TRANSFER_COMPLETED_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_ADMA_TRANSFER_COMPLETED) || \
    false)

static inline void _nocheck__trace_sdhci_adma_transfer_completed(void)
{
    if (trace_event_get_state(TRACE_SDHCI_ADMA_TRANSFER_COMPLETED) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 33 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_adma_transfer_completed " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 912 "trace/trace-hw_sd.h"
        } else {
#line 33 "../git/hw/sd/trace-events"
            qemu_log("sdhci_adma_transfer_completed " "" "\n");
#line 916 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_adma_transfer_completed(void)
{
    if (true) {
        _nocheck__trace_sdhci_adma_transfer_completed();
    }
}

#define TRACE_SDHCI_ACCESS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_ACCESS) || \
    false)

static inline void _nocheck__trace_sdhci_access(const char * access, unsigned int size, uint64_t offset, const char * dir, uint64_t val, uint64_t val2)
{
    if (trace_event_get_state(TRACE_SDHCI_ACCESS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 34 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_access " "%s%u: addr[0x%04" PRIx64 "] %s 0x%08" PRIx64 " (%" PRIu64 ")" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , access, size, offset, dir, val, val2);
#line 943 "trace/trace-hw_sd.h"
        } else {
#line 34 "../git/hw/sd/trace-events"
            qemu_log("sdhci_access " "%s%u: addr[0x%04" PRIx64 "] %s 0x%08" PRIx64 " (%" PRIu64 ")" "\n", access, size, offset, dir, val, val2);
#line 947 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_access(const char * access, unsigned int size, uint64_t offset, const char * dir, uint64_t val, uint64_t val2)
{
    if (true) {
        _nocheck__trace_sdhci_access(access, size, offset, dir, val, val2);
    }
}

#define TRACE_SDHCI_READ_DATAPORT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_READ_DATAPORT) || \
    false)

static inline void _nocheck__trace_sdhci_read_dataport(uint16_t data_count)
{
    if (trace_event_get_state(TRACE_SDHCI_READ_DATAPORT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 35 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_read_dataport " "all %u bytes of data have been read from input buffer" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , data_count);
#line 974 "trace/trace-hw_sd.h"
        } else {
#line 35 "../git/hw/sd/trace-events"
            qemu_log("sdhci_read_dataport " "all %u bytes of data have been read from input buffer" "\n", data_count);
#line 978 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_read_dataport(uint16_t data_count)
{
    if (true) {
        _nocheck__trace_sdhci_read_dataport(data_count);
    }
}

#define TRACE_SDHCI_WRITE_DATAPORT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_WRITE_DATAPORT) || \
    false)

static inline void _nocheck__trace_sdhci_write_dataport(uint16_t data_count)
{
    if (trace_event_get_state(TRACE_SDHCI_WRITE_DATAPORT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 36 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_write_dataport " "write buffer filled with %u bytes of data" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , data_count);
#line 1005 "trace/trace-hw_sd.h"
        } else {
#line 36 "../git/hw/sd/trace-events"
            qemu_log("sdhci_write_dataport " "write buffer filled with %u bytes of data" "\n", data_count);
#line 1009 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_write_dataport(uint16_t data_count)
{
    if (true) {
        _nocheck__trace_sdhci_write_dataport(data_count);
    }
}

#define TRACE_SDHCI_CAPAREG_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDHCI_CAPAREG) || \
    false)

static inline void _nocheck__trace_sdhci_capareg(const char * desc, uint16_t val)
{
    if (trace_event_get_state(TRACE_SDHCI_CAPAREG) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 37 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdhci_capareg " "%s: %u" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , desc, val);
#line 1036 "trace/trace-hw_sd.h"
        } else {
#line 37 "../git/hw/sd/trace-events"
            qemu_log("sdhci_capareg " "%s: %u" "\n", desc, val);
#line 1040 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdhci_capareg(const char * desc, uint16_t val)
{
    if (true) {
        _nocheck__trace_sdhci_capareg(desc, val);
    }
}

#define TRACE_SDCARD_NORMAL_COMMAND_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_NORMAL_COMMAND) || \
    false)

static inline void _nocheck__trace_sdcard_normal_command(const char * proto, const char * cmd_desc, uint8_t cmd, uint32_t arg, const char * state)
{
    if (trace_event_get_state(TRACE_SDCARD_NORMAL_COMMAND) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 40 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_normal_command " "%s %20s/ CMD%02d arg 0x%08x (state %s)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , proto, cmd_desc, cmd, arg, state);
#line 1067 "trace/trace-hw_sd.h"
        } else {
#line 40 "../git/hw/sd/trace-events"
            qemu_log("sdcard_normal_command " "%s %20s/ CMD%02d arg 0x%08x (state %s)" "\n", proto, cmd_desc, cmd, arg, state);
#line 1071 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_normal_command(const char * proto, const char * cmd_desc, uint8_t cmd, uint32_t arg, const char * state)
{
    if (true) {
        _nocheck__trace_sdcard_normal_command(proto, cmd_desc, cmd, arg, state);
    }
}

#define TRACE_SDCARD_APP_COMMAND_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_APP_COMMAND) || \
    false)

static inline void _nocheck__trace_sdcard_app_command(const char * proto, const char * acmd_desc, uint8_t acmd, uint32_t arg, const char * state)
{
    if (trace_event_get_state(TRACE_SDCARD_APP_COMMAND) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 41 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_app_command " "%s %23s/ACMD%02d arg 0x%08x (state %s)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , proto, acmd_desc, acmd, arg, state);
#line 1098 "trace/trace-hw_sd.h"
        } else {
#line 41 "../git/hw/sd/trace-events"
            qemu_log("sdcard_app_command " "%s %23s/ACMD%02d arg 0x%08x (state %s)" "\n", proto, acmd_desc, acmd, arg, state);
#line 1102 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_app_command(const char * proto, const char * acmd_desc, uint8_t acmd, uint32_t arg, const char * state)
{
    if (true) {
        _nocheck__trace_sdcard_app_command(proto, acmd_desc, acmd, arg, state);
    }
}

#define TRACE_SDCARD_RESPONSE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_RESPONSE) || \
    false)

static inline void _nocheck__trace_sdcard_response(const char * rspdesc, int rsplen)
{
    if (trace_event_get_state(TRACE_SDCARD_RESPONSE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 42 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_response " "%s (sz:%d)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , rspdesc, rsplen);
#line 1129 "trace/trace-hw_sd.h"
        } else {
#line 42 "../git/hw/sd/trace-events"
            qemu_log("sdcard_response " "%s (sz:%d)" "\n", rspdesc, rsplen);
#line 1133 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_response(const char * rspdesc, int rsplen)
{
    if (true) {
        _nocheck__trace_sdcard_response(rspdesc, rsplen);
    }
}

#define TRACE_SDCARD_POWERUP_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_POWERUP) || \
    false)

static inline void _nocheck__trace_sdcard_powerup(void)
{
    if (trace_event_get_state(TRACE_SDCARD_POWERUP) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 43 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_powerup " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1160 "trace/trace-hw_sd.h"
        } else {
#line 43 "../git/hw/sd/trace-events"
            qemu_log("sdcard_powerup " "" "\n");
#line 1164 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_powerup(void)
{
    if (true) {
        _nocheck__trace_sdcard_powerup();
    }
}

#define TRACE_SDCARD_INQUIRY_CMD41_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_INQUIRY_CMD41) || \
    false)

static inline void _nocheck__trace_sdcard_inquiry_cmd41(void)
{
    if (trace_event_get_state(TRACE_SDCARD_INQUIRY_CMD41) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 44 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_inquiry_cmd41 " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1191 "trace/trace-hw_sd.h"
        } else {
#line 44 "../git/hw/sd/trace-events"
            qemu_log("sdcard_inquiry_cmd41 " "" "\n");
#line 1195 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_inquiry_cmd41(void)
{
    if (true) {
        _nocheck__trace_sdcard_inquiry_cmd41();
    }
}

#define TRACE_SDCARD_RESET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_RESET) || \
    false)

static inline void _nocheck__trace_sdcard_reset(void)
{
    if (trace_event_get_state(TRACE_SDCARD_RESET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 45 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_reset " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1222 "trace/trace-hw_sd.h"
        } else {
#line 45 "../git/hw/sd/trace-events"
            qemu_log("sdcard_reset " "" "\n");
#line 1226 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_reset(void)
{
    if (true) {
        _nocheck__trace_sdcard_reset();
    }
}

#define TRACE_SDCARD_SET_BLOCKLEN_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_SET_BLOCKLEN) || \
    false)

static inline void _nocheck__trace_sdcard_set_blocklen(uint16_t length)
{
    if (trace_event_get_state(TRACE_SDCARD_SET_BLOCKLEN) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 46 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_set_blocklen " "0x%03x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , length);
#line 1253 "trace/trace-hw_sd.h"
        } else {
#line 46 "../git/hw/sd/trace-events"
            qemu_log("sdcard_set_blocklen " "0x%03x" "\n", length);
#line 1257 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_set_blocklen(uint16_t length)
{
    if (true) {
        _nocheck__trace_sdcard_set_blocklen(length);
    }
}

#define TRACE_SDCARD_INSERTED_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_INSERTED) || \
    false)

static inline void _nocheck__trace_sdcard_inserted(bool readonly)
{
    if (trace_event_get_state(TRACE_SDCARD_INSERTED) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 47 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_inserted " "read_only: %u" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , readonly);
#line 1284 "trace/trace-hw_sd.h"
        } else {
#line 47 "../git/hw/sd/trace-events"
            qemu_log("sdcard_inserted " "read_only: %u" "\n", readonly);
#line 1288 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_inserted(bool readonly)
{
    if (true) {
        _nocheck__trace_sdcard_inserted(readonly);
    }
}

#define TRACE_SDCARD_EJECTED_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_EJECTED) || \
    false)

static inline void _nocheck__trace_sdcard_ejected(void)
{
    if (trace_event_get_state(TRACE_SDCARD_EJECTED) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 48 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_ejected " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1315 "trace/trace-hw_sd.h"
        } else {
#line 48 "../git/hw/sd/trace-events"
            qemu_log("sdcard_ejected " "" "\n");
#line 1319 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_ejected(void)
{
    if (true) {
        _nocheck__trace_sdcard_ejected();
    }
}

#define TRACE_SDCARD_ERASE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_ERASE) || \
    false)

static inline void _nocheck__trace_sdcard_erase(uint32_t first, uint32_t last)
{
    if (trace_event_get_state(TRACE_SDCARD_ERASE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 49 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_erase " "addr first 0x%" PRIx32" last 0x%" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , first, last);
#line 1346 "trace/trace-hw_sd.h"
        } else {
#line 49 "../git/hw/sd/trace-events"
            qemu_log("sdcard_erase " "addr first 0x%" PRIx32" last 0x%" PRIx32 "\n", first, last);
#line 1350 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_erase(uint32_t first, uint32_t last)
{
    if (true) {
        _nocheck__trace_sdcard_erase(first, last);
    }
}

#define TRACE_SDCARD_LOCK_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_LOCK) || \
    false)

static inline void _nocheck__trace_sdcard_lock(void)
{
    if (trace_event_get_state(TRACE_SDCARD_LOCK) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 50 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_lock " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1377 "trace/trace-hw_sd.h"
        } else {
#line 50 "../git/hw/sd/trace-events"
            qemu_log("sdcard_lock " "" "\n");
#line 1381 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_lock(void)
{
    if (true) {
        _nocheck__trace_sdcard_lock();
    }
}

#define TRACE_SDCARD_UNLOCK_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_UNLOCK) || \
    false)

static inline void _nocheck__trace_sdcard_unlock(void)
{
    if (trace_event_get_state(TRACE_SDCARD_UNLOCK) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 51 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_unlock " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1408 "trace/trace-hw_sd.h"
        } else {
#line 51 "../git/hw/sd/trace-events"
            qemu_log("sdcard_unlock " "" "\n");
#line 1412 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_unlock(void)
{
    if (true) {
        _nocheck__trace_sdcard_unlock();
    }
}

#define TRACE_SDCARD_READ_BLOCK_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_READ_BLOCK) || \
    false)

static inline void _nocheck__trace_sdcard_read_block(uint64_t addr, uint32_t len)
{
    if (trace_event_get_state(TRACE_SDCARD_READ_BLOCK) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 52 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_read_block " "addr 0x%" PRIx64 " size 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , addr, len);
#line 1439 "trace/trace-hw_sd.h"
        } else {
#line 52 "../git/hw/sd/trace-events"
            qemu_log("sdcard_read_block " "addr 0x%" PRIx64 " size 0x%x" "\n", addr, len);
#line 1443 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_read_block(uint64_t addr, uint32_t len)
{
    if (true) {
        _nocheck__trace_sdcard_read_block(addr, len);
    }
}

#define TRACE_SDCARD_WRITE_BLOCK_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_WRITE_BLOCK) || \
    false)

static inline void _nocheck__trace_sdcard_write_block(uint64_t addr, uint32_t len)
{
    if (trace_event_get_state(TRACE_SDCARD_WRITE_BLOCK) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 53 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_write_block " "addr 0x%" PRIx64 " size 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , addr, len);
#line 1470 "trace/trace-hw_sd.h"
        } else {
#line 53 "../git/hw/sd/trace-events"
            qemu_log("sdcard_write_block " "addr 0x%" PRIx64 " size 0x%x" "\n", addr, len);
#line 1474 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_write_block(uint64_t addr, uint32_t len)
{
    if (true) {
        _nocheck__trace_sdcard_write_block(addr, len);
    }
}

#define TRACE_SDCARD_WRITE_DATA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_WRITE_DATA) || \
    false)

static inline void _nocheck__trace_sdcard_write_data(const char * proto, const char * cmd_desc, uint8_t cmd, uint8_t value)
{
    if (trace_event_get_state(TRACE_SDCARD_WRITE_DATA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 54 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_write_data " "%s %20s/ CMD%02d value 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , proto, cmd_desc, cmd, value);
#line 1501 "trace/trace-hw_sd.h"
        } else {
#line 54 "../git/hw/sd/trace-events"
            qemu_log("sdcard_write_data " "%s %20s/ CMD%02d value 0x%02x" "\n", proto, cmd_desc, cmd, value);
#line 1505 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_write_data(const char * proto, const char * cmd_desc, uint8_t cmd, uint8_t value)
{
    if (true) {
        _nocheck__trace_sdcard_write_data(proto, cmd_desc, cmd, value);
    }
}

#define TRACE_SDCARD_READ_DATA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_READ_DATA) || \
    false)

static inline void _nocheck__trace_sdcard_read_data(const char * proto, const char * cmd_desc, uint8_t cmd, uint32_t length)
{
    if (trace_event_get_state(TRACE_SDCARD_READ_DATA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 55 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_read_data " "%s %20s/ CMD%02d len %" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , proto, cmd_desc, cmd, length);
#line 1532 "trace/trace-hw_sd.h"
        } else {
#line 55 "../git/hw/sd/trace-events"
            qemu_log("sdcard_read_data " "%s %20s/ CMD%02d len %" PRIu32 "\n", proto, cmd_desc, cmd, length);
#line 1536 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_read_data(const char * proto, const char * cmd_desc, uint8_t cmd, uint32_t length)
{
    if (true) {
        _nocheck__trace_sdcard_read_data(proto, cmd_desc, cmd, length);
    }
}

#define TRACE_SDCARD_SET_VOLTAGE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_SET_VOLTAGE) || \
    false)

static inline void _nocheck__trace_sdcard_set_voltage(uint16_t millivolts)
{
    if (trace_event_get_state(TRACE_SDCARD_SET_VOLTAGE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 56 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_set_voltage " "%u mV" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , millivolts);
#line 1563 "trace/trace-hw_sd.h"
        } else {
#line 56 "../git/hw/sd/trace-events"
            qemu_log("sdcard_set_voltage " "%u mV" "\n", millivolts);
#line 1567 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_set_voltage(uint16_t millivolts)
{
    if (true) {
        _nocheck__trace_sdcard_set_voltage(millivolts);
    }
}

#define TRACE_PXA2XX_MMCI_READ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PXA2XX_MMCI_READ) || \
    false)

static inline void _nocheck__trace_pxa2xx_mmci_read(uint8_t size, uint32_t addr, uint32_t value)
{
    if (trace_event_get_state(TRACE_PXA2XX_MMCI_READ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 59 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:pxa2xx_mmci_read " "size %d addr 0x%02x value 0x%08x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , size, addr, value);
#line 1594 "trace/trace-hw_sd.h"
        } else {
#line 59 "../git/hw/sd/trace-events"
            qemu_log("pxa2xx_mmci_read " "size %d addr 0x%02x value 0x%08x" "\n", size, addr, value);
#line 1598 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_pxa2xx_mmci_read(uint8_t size, uint32_t addr, uint32_t value)
{
    if (true) {
        _nocheck__trace_pxa2xx_mmci_read(size, addr, value);
    }
}

#define TRACE_PXA2XX_MMCI_WRITE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PXA2XX_MMCI_WRITE) || \
    false)

static inline void _nocheck__trace_pxa2xx_mmci_write(uint8_t size, uint32_t addr, uint32_t value)
{
    if (trace_event_get_state(TRACE_PXA2XX_MMCI_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 60 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:pxa2xx_mmci_write " "size %d addr 0x%02x value 0x%08x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , size, addr, value);
#line 1625 "trace/trace-hw_sd.h"
        } else {
#line 60 "../git/hw/sd/trace-events"
            qemu_log("pxa2xx_mmci_write " "size %d addr 0x%02x value 0x%08x" "\n", size, addr, value);
#line 1629 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_pxa2xx_mmci_write(uint8_t size, uint32_t addr, uint32_t value)
{
    if (true) {
        _nocheck__trace_pxa2xx_mmci_write(size, addr, value);
    }
}

#define TRACE_PL181_COMMAND_SEND_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PL181_COMMAND_SEND) || \
    false)

static inline void _nocheck__trace_pl181_command_send(uint8_t cmd, uint32_t arg)
{
    if (trace_event_get_state(TRACE_PL181_COMMAND_SEND) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 63 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:pl181_command_send " "sending CMD%02d arg 0x%08" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cmd, arg);
#line 1656 "trace/trace-hw_sd.h"
        } else {
#line 63 "../git/hw/sd/trace-events"
            qemu_log("pl181_command_send " "sending CMD%02d arg 0x%08" PRIx32 "\n", cmd, arg);
#line 1660 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_pl181_command_send(uint8_t cmd, uint32_t arg)
{
    if (true) {
        _nocheck__trace_pl181_command_send(cmd, arg);
    }
}

#define TRACE_PL181_COMMAND_SENT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PL181_COMMAND_SENT) || \
    false)

static inline void _nocheck__trace_pl181_command_sent(void)
{
    if (trace_event_get_state(TRACE_PL181_COMMAND_SENT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 64 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:pl181_command_sent " "command sent" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1687 "trace/trace-hw_sd.h"
        } else {
#line 64 "../git/hw/sd/trace-events"
            qemu_log("pl181_command_sent " "command sent" "\n");
#line 1691 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_pl181_command_sent(void)
{
    if (true) {
        _nocheck__trace_pl181_command_sent();
    }
}

#define TRACE_PL181_COMMAND_RESPONSE_PENDING_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PL181_COMMAND_RESPONSE_PENDING) || \
    false)

static inline void _nocheck__trace_pl181_command_response_pending(void)
{
    if (trace_event_get_state(TRACE_PL181_COMMAND_RESPONSE_PENDING) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 65 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:pl181_command_response_pending " "response received" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1718 "trace/trace-hw_sd.h"
        } else {
#line 65 "../git/hw/sd/trace-events"
            qemu_log("pl181_command_response_pending " "response received" "\n");
#line 1722 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_pl181_command_response_pending(void)
{
    if (true) {
        _nocheck__trace_pl181_command_response_pending();
    }
}

#define TRACE_PL181_COMMAND_TIMEOUT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PL181_COMMAND_TIMEOUT) || \
    false)

static inline void _nocheck__trace_pl181_command_timeout(void)
{
    if (trace_event_get_state(TRACE_PL181_COMMAND_TIMEOUT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 66 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:pl181_command_timeout " "command timeouted" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1749 "trace/trace-hw_sd.h"
        } else {
#line 66 "../git/hw/sd/trace-events"
            qemu_log("pl181_command_timeout " "command timeouted" "\n");
#line 1753 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_pl181_command_timeout(void)
{
    if (true) {
        _nocheck__trace_pl181_command_timeout();
    }
}

#define TRACE_PL181_FIFO_PUSH_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PL181_FIFO_PUSH) || \
    false)

static inline void _nocheck__trace_pl181_fifo_push(uint32_t data)
{
    if (trace_event_get_state(TRACE_PL181_FIFO_PUSH) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 67 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:pl181_fifo_push " "FIFO push 0x%08" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , data);
#line 1780 "trace/trace-hw_sd.h"
        } else {
#line 67 "../git/hw/sd/trace-events"
            qemu_log("pl181_fifo_push " "FIFO push 0x%08" PRIx32 "\n", data);
#line 1784 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_pl181_fifo_push(uint32_t data)
{
    if (true) {
        _nocheck__trace_pl181_fifo_push(data);
    }
}

#define TRACE_PL181_FIFO_POP_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PL181_FIFO_POP) || \
    false)

static inline void _nocheck__trace_pl181_fifo_pop(uint32_t data)
{
    if (trace_event_get_state(TRACE_PL181_FIFO_POP) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 68 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:pl181_fifo_pop " "FIFO pop 0x%08" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , data);
#line 1811 "trace/trace-hw_sd.h"
        } else {
#line 68 "../git/hw/sd/trace-events"
            qemu_log("pl181_fifo_pop " "FIFO pop 0x%08" PRIx32 "\n", data);
#line 1815 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_pl181_fifo_pop(uint32_t data)
{
    if (true) {
        _nocheck__trace_pl181_fifo_pop(data);
    }
}

#define TRACE_PL181_FIFO_TRANSFER_COMPLETE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PL181_FIFO_TRANSFER_COMPLETE) || \
    false)

static inline void _nocheck__trace_pl181_fifo_transfer_complete(void)
{
    if (trace_event_get_state(TRACE_PL181_FIFO_TRANSFER_COMPLETE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 69 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:pl181_fifo_transfer_complete " "FIFO transfer complete" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1842 "trace/trace-hw_sd.h"
        } else {
#line 69 "../git/hw/sd/trace-events"
            qemu_log("pl181_fifo_transfer_complete " "FIFO transfer complete" "\n");
#line 1846 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_pl181_fifo_transfer_complete(void)
{
    if (true) {
        _nocheck__trace_pl181_fifo_transfer_complete();
    }
}

#define TRACE_PL181_DATA_ENGINE_IDLE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PL181_DATA_ENGINE_IDLE) || \
    false)

static inline void _nocheck__trace_pl181_data_engine_idle(void)
{
    if (trace_event_get_state(TRACE_PL181_DATA_ENGINE_IDLE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 70 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:pl181_data_engine_idle " "data engine idle" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1873 "trace/trace-hw_sd.h"
        } else {
#line 70 "../git/hw/sd/trace-events"
            qemu_log("pl181_data_engine_idle " "data engine idle" "\n");
#line 1877 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_pl181_data_engine_idle(void)
{
    if (true) {
        _nocheck__trace_pl181_data_engine_idle();
    }
}

#define TRACE_ASPEED_SDHCI_READ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ASPEED_SDHCI_READ) || \
    false)

static inline void _nocheck__trace_aspeed_sdhci_read(uint64_t addr, uint32_t size, uint64_t data)
{
    if (trace_event_get_state(TRACE_ASPEED_SDHCI_READ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 73 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:aspeed_sdhci_read " "@0x%" PRIx64 " size %u: 0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , addr, size, data);
#line 1904 "trace/trace-hw_sd.h"
        } else {
#line 73 "../git/hw/sd/trace-events"
            qemu_log("aspeed_sdhci_read " "@0x%" PRIx64 " size %u: 0x%" PRIx64 "\n", addr, size, data);
#line 1908 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_aspeed_sdhci_read(uint64_t addr, uint32_t size, uint64_t data)
{
    if (true) {
        _nocheck__trace_aspeed_sdhci_read(addr, size, data);
    }
}

#define TRACE_ASPEED_SDHCI_WRITE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ASPEED_SDHCI_WRITE) || \
    false)

static inline void _nocheck__trace_aspeed_sdhci_write(uint64_t addr, uint32_t size, uint64_t data)
{
    if (trace_event_get_state(TRACE_ASPEED_SDHCI_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 74 "../git/hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:aspeed_sdhci_write " "@0x%" PRIx64 " size %u: 0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , addr, size, data);
#line 1935 "trace/trace-hw_sd.h"
        } else {
#line 74 "../git/hw/sd/trace-events"
            qemu_log("aspeed_sdhci_write " "@0x%" PRIx64 " size %u: 0x%" PRIx64 "\n", addr, size, data);
#line 1939 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_aspeed_sdhci_write(uint64_t addr, uint32_t size, uint64_t data)
{
    if (true) {
        _nocheck__trace_aspeed_sdhci_write(addr, size, data);
    }
}
#endif /* TRACE_HW_SD_GENERATED_TRACERS_H */
