/* 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_RCA_EVENT;
extern TraceEvent _TRACE_SDCARD_SET_BLOCKLEN_EVENT;
extern TraceEvent _TRACE_SDCARD_SET_BLOCK_COUNT_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_REQ_ADDR_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_SDCARD_EXT_CSD_UPDATE_EVENT;
extern TraceEvent _TRACE_SDCARD_SWITCH_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_RCA_DSTATE;
extern uint16_t _TRACE_SDCARD_SET_BLOCKLEN_DSTATE;
extern uint16_t _TRACE_SDCARD_SET_BLOCK_COUNT_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_REQ_ADDR_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_SDCARD_EXT_CSD_UPDATE_DSTATE;
extern uint16_t _TRACE_SDCARD_SWITCH_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_RCA_ENABLED 1
#define TRACE_SDCARD_SET_BLOCKLEN_ENABLED 1
#define TRACE_SDCARD_SET_BLOCK_COUNT_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_REQ_ADDR_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_SDCARD_EXT_CSD_UPDATE_ENABLED 1
#define TRACE_SDCARD_SWITCH_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 "../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 208 "trace/trace-hw_sd.h"
        } else {
#line 4 "../hw/sd/trace-events"
            qemu_log("allwinner_sdhost_set_inserted " "inserted %u" "\n", inserted);
#line 212 "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 "../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 239 "trace/trace-hw_sd.h"
        } else {
#line 5 "../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 243 "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 "../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 270 "trace/trace-hw_sd.h"
        } else {
#line 6 "../hw/sd/trace-events"
            qemu_log("allwinner_sdhost_read " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32 "\n", offset, data, size);
#line 274 "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 "../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 301 "trace/trace-hw_sd.h"
        } else {
#line 7 "../hw/sd/trace-events"
            qemu_log("allwinner_sdhost_write " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32 "\n", offset, data, size);
#line 305 "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 "../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 332 "trace/trace-hw_sd.h"
        } else {
#line 8 "../hw/sd/trace-events"
            qemu_log("allwinner_sdhost_update_irq " "IRQ bits 0x%" PRIx32 "\n", irq);
#line 336 "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 "../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 363 "trace/trace-hw_sd.h"
        } else {
#line 11 "../hw/sd/trace-events"
            qemu_log("bcm2835_sdhost_read " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %u" "\n", offset, data, size);
#line 367 "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 "../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 394 "trace/trace-hw_sd.h"
        } else {
#line 12 "../hw/sd/trace-events"
            qemu_log("bcm2835_sdhost_write " "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %u" "\n", offset, data, size);
#line 398 "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 "../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 425 "trace/trace-hw_sd.h"
        } else {
#line 13 "../hw/sd/trace-events"
            qemu_log("bcm2835_sdhost_edm_change " "(%s) EDM now 0x%x" "\n", why, edm);
#line 429 "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 "../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 456 "trace/trace-hw_sd.h"
        } else {
#line 14 "../hw/sd/trace-events"
            qemu_log("bcm2835_sdhost_update_irq " "IRQ bits 0x%x" "\n", irq);
#line 460 "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 "../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 487 "trace/trace-hw_sd.h"
        } else {
#line 17 "../hw/sd/trace-events"
            qemu_log("sdbus_command " "@%s CMD%02d arg 0x%08x" "\n", bus_name, cmd, arg);
#line 491 "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 "../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 518 "trace/trace-hw_sd.h"
        } else {
#line 18 "../hw/sd/trace-events"
            qemu_log("sdbus_read " "@%s value 0x%02x" "\n", bus_name, value);
#line 522 "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 "../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 549 "trace/trace-hw_sd.h"
        } else {
#line 19 "../hw/sd/trace-events"
            qemu_log("sdbus_write " "@%s value 0x%02x" "\n", bus_name, value);
#line 553 "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 "../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 580 "trace/trace-hw_sd.h"
        } else {
#line 20 "../hw/sd/trace-events"
            qemu_log("sdbus_set_voltage " "@%s %u (mV)" "\n", bus_name, millivolts);
#line 584 "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 "../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 611 "trace/trace-hw_sd.h"
        } else {
#line 21 "../hw/sd/trace-events"
            qemu_log("sdbus_get_dat_lines " "@%s dat_lines: %u" "\n", bus_name, dat_lines);
#line 615 "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 "../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 642 "trace/trace-hw_sd.h"
        } else {
#line 22 "../hw/sd/trace-events"
            qemu_log("sdbus_get_cmd_line " "@%s cmd_line: %u" "\n", bus_name, cmd_line);
#line 646 "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 "../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 673 "trace/trace-hw_sd.h"
        } else {
#line 25 "../hw/sd/trace-events"
            qemu_log("sdhci_set_inserted " "card state changed: %s" "\n", level);
#line 677 "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 "../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 704 "trace/trace-hw_sd.h"
        } else {
#line 26 "../hw/sd/trace-events"
            qemu_log("sdhci_send_command " "CMD%02u ARG[0x%08x]" "\n", cmd, arg);
#line 708 "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 "../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 735 "trace/trace-hw_sd.h"
        } else {
#line 27 "../hw/sd/trace-events"
            qemu_log("sdhci_error " "%s" "\n", msg);
#line 739 "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 "../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 766 "trace/trace-hw_sd.h"
        } else {
#line 28 "../hw/sd/trace-events"
            qemu_log("sdhci_response4 " "RSPREG[31..0]=0x%08x" "\n", r0);
#line 770 "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 "../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 797 "trace/trace-hw_sd.h"
        } else {
#line 29 "../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 801 "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 "../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 828 "trace/trace-hw_sd.h"
        } else {
#line 30 "../hw/sd/trace-events"
            qemu_log("sdhci_end_transfer " "Automatically issue CMD%02u 0x%08x" "\n", cmd, arg);
#line 832 "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 "../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 859 "trace/trace-hw_sd.h"
        } else {
#line 31 "../hw/sd/trace-events"
            qemu_log("sdhci_adma " "%s: admasysaddr=0x%" PRIx32 "\n", desc, sysad);
#line 863 "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 "../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 890 "trace/trace-hw_sd.h"
        } else {
#line 32 "../hw/sd/trace-events"
            qemu_log("sdhci_adma_loop " "addr=0x%08" PRIx64 ", len=%d, attr=0x%x" "\n", addr, length, attr);
#line 894 "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 "../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 921 "trace/trace-hw_sd.h"
        } else {
#line 33 "../hw/sd/trace-events"
            qemu_log("sdhci_adma_transfer_completed " "" "\n");
#line 925 "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 "../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 952 "trace/trace-hw_sd.h"
        } else {
#line 34 "../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 956 "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 "../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 983 "trace/trace-hw_sd.h"
        } else {
#line 35 "../hw/sd/trace-events"
            qemu_log("sdhci_read_dataport " "all %u bytes of data have been read from input buffer" "\n", data_count);
#line 987 "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 "../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 1014 "trace/trace-hw_sd.h"
        } else {
#line 36 "../hw/sd/trace-events"
            qemu_log("sdhci_write_dataport " "write buffer filled with %u bytes of data" "\n", data_count);
#line 1018 "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 "../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 1045 "trace/trace-hw_sd.h"
        } else {
#line 37 "../hw/sd/trace-events"
            qemu_log("sdhci_capareg " "%s: %u" "\n", desc, val);
#line 1049 "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 "../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 1076 "trace/trace-hw_sd.h"
        } else {
#line 40 "../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 1080 "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 "../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 1107 "trace/trace-hw_sd.h"
        } else {
#line 41 "../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 1111 "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 "../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 1138 "trace/trace-hw_sd.h"
        } else {
#line 42 "../hw/sd/trace-events"
            qemu_log("sdcard_response " "%s (sz:%d)" "\n", rspdesc, rsplen);
#line 1142 "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 "../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 1169 "trace/trace-hw_sd.h"
        } else {
#line 43 "../hw/sd/trace-events"
            qemu_log("sdcard_powerup " "" "\n");
#line 1173 "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 "../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 1200 "trace/trace-hw_sd.h"
        } else {
#line 44 "../hw/sd/trace-events"
            qemu_log("sdcard_inquiry_cmd41 " "" "\n");
#line 1204 "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 "../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 1231 "trace/trace-hw_sd.h"
        } else {
#line 45 "../hw/sd/trace-events"
            qemu_log("sdcard_reset " "" "\n");
#line 1235 "trace/trace-hw_sd.h"
        }
    }
}

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

#define TRACE_SDCARD_SET_RCA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_SET_RCA) || \
    false)

static inline void _nocheck__trace_sdcard_set_rca(uint16_t value)
{
    if (trace_event_get_state(TRACE_SDCARD_SET_RCA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 46 "../hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_set_rca " "new RCA: 0x%04x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , value);
#line 1262 "trace/trace-hw_sd.h"
        } else {
#line 46 "../hw/sd/trace-events"
            qemu_log("sdcard_set_rca " "new RCA: 0x%04x" "\n", value);
#line 1266 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_set_rca(uint16_t value)
{
    if (true) {
        _nocheck__trace_sdcard_set_rca(value);
    }
}

#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 47 "../hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_set_blocklen " "block len 0x%03x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , length);
#line 1293 "trace/trace-hw_sd.h"
        } else {
#line 47 "../hw/sd/trace-events"
            qemu_log("sdcard_set_blocklen " "block len 0x%03x" "\n", length);
#line 1297 "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_SET_BLOCK_COUNT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_SET_BLOCK_COUNT) || \
    false)

static inline void _nocheck__trace_sdcard_set_block_count(uint32_t cnt)
{
    if (trace_event_get_state(TRACE_SDCARD_SET_BLOCK_COUNT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 48 "../hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_set_block_count " "block cnt 0x%"PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cnt);
#line 1324 "trace/trace-hw_sd.h"
        } else {
#line 48 "../hw/sd/trace-events"
            qemu_log("sdcard_set_block_count " "block cnt 0x%"PRIx32 "\n", cnt);
#line 1328 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_set_block_count(uint32_t cnt)
{
    if (true) {
        _nocheck__trace_sdcard_set_block_count(cnt);
    }
}

#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 49 "../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 1355 "trace/trace-hw_sd.h"
        } else {
#line 49 "../hw/sd/trace-events"
            qemu_log("sdcard_inserted " "read_only: %u" "\n", readonly);
#line 1359 "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 50 "../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 1386 "trace/trace-hw_sd.h"
        } else {
#line 50 "../hw/sd/trace-events"
            qemu_log("sdcard_ejected " "" "\n");
#line 1390 "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 51 "../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 1417 "trace/trace-hw_sd.h"
        } else {
#line 51 "../hw/sd/trace-events"
            qemu_log("sdcard_erase " "addr first 0x%" PRIx32" last 0x%" PRIx32 "\n", first, last);
#line 1421 "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 52 "../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 1448 "trace/trace-hw_sd.h"
        } else {
#line 52 "../hw/sd/trace-events"
            qemu_log("sdcard_lock " "" "\n");
#line 1452 "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 53 "../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 1479 "trace/trace-hw_sd.h"
        } else {
#line 53 "../hw/sd/trace-events"
            qemu_log("sdcard_unlock " "" "\n");
#line 1483 "trace/trace-hw_sd.h"
        }
    }
}

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

#define TRACE_SDCARD_REQ_ADDR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_REQ_ADDR) || \
    false)

static inline void _nocheck__trace_sdcard_req_addr(uint32_t req_arg, uint64_t addr)
{
    if (trace_event_get_state(TRACE_SDCARD_REQ_ADDR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 54 "../hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_req_addr " "req 0x%" PRIx32 " addr 0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , req_arg, addr);
#line 1510 "trace/trace-hw_sd.h"
        } else {
#line 54 "../hw/sd/trace-events"
            qemu_log("sdcard_req_addr " "req 0x%" PRIx32 " addr 0x%" PRIx64 "\n", req_arg, addr);
#line 1514 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_req_addr(uint32_t req_arg, uint64_t addr)
{
    if (true) {
        _nocheck__trace_sdcard_req_addr(req_arg, addr);
    }
}

#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 55 "../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 1541 "trace/trace-hw_sd.h"
        } else {
#line 55 "../hw/sd/trace-events"
            qemu_log("sdcard_read_block " "addr 0x%" PRIx64 " size 0x%x" "\n", addr, len);
#line 1545 "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 56 "../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 1572 "trace/trace-hw_sd.h"
        } else {
#line 56 "../hw/sd/trace-events"
            qemu_log("sdcard_write_block " "addr 0x%" PRIx64 " size 0x%x" "\n", addr, len);
#line 1576 "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, uint32_t offset, 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 57 "../hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_write_data " "%s %20s/ CMD%02d ofs %"PRIu32" value 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , proto, cmd_desc, cmd, offset, value);
#line 1603 "trace/trace-hw_sd.h"
        } else {
#line 57 "../hw/sd/trace-events"
            qemu_log("sdcard_write_data " "%s %20s/ CMD%02d ofs %"PRIu32" value 0x%02x" "\n", proto, cmd_desc, cmd, offset, value);
#line 1607 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_write_data(const char * proto, const char * cmd_desc, uint8_t cmd, uint32_t offset, uint8_t value)
{
    if (true) {
        _nocheck__trace_sdcard_write_data(proto, cmd_desc, cmd, offset, 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 offset, uint64_t size, uint32_t blklen)
{
    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 58 "../hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_read_data " "%s %20s/ CMD%02d ofs %"PRIu32" size %"PRIu64" blklen %" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , proto, cmd_desc, cmd, offset, size, blklen);
#line 1634 "trace/trace-hw_sd.h"
        } else {
#line 58 "../hw/sd/trace-events"
            qemu_log("sdcard_read_data " "%s %20s/ CMD%02d ofs %"PRIu32" size %"PRIu64" blklen %" PRIu32 "\n", proto, cmd_desc, cmd, offset, size, blklen);
#line 1638 "trace/trace-hw_sd.h"
        }
    }
}

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

#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 59 "../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 1665 "trace/trace-hw_sd.h"
        } else {
#line 59 "../hw/sd/trace-events"
            qemu_log("sdcard_set_voltage " "%u mV" "\n", millivolts);
#line 1669 "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_SDCARD_EXT_CSD_UPDATE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_EXT_CSD_UPDATE) || \
    false)

static inline void _nocheck__trace_sdcard_ext_csd_update(unsigned index, uint8_t oval, uint8_t nval)
{
    if (trace_event_get_state(TRACE_SDCARD_EXT_CSD_UPDATE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 60 "../hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_ext_csd_update " "index %u: 0x%02x -> 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , index, oval, nval);
#line 1696 "trace/trace-hw_sd.h"
        } else {
#line 60 "../hw/sd/trace-events"
            qemu_log("sdcard_ext_csd_update " "index %u: 0x%02x -> 0x%02x" "\n", index, oval, nval);
#line 1700 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_ext_csd_update(unsigned index, uint8_t oval, uint8_t nval)
{
    if (true) {
        _nocheck__trace_sdcard_ext_csd_update(index, oval, nval);
    }
}

#define TRACE_SDCARD_SWITCH_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_SDCARD_SWITCH) || \
    false)

static inline void _nocheck__trace_sdcard_switch(unsigned access, unsigned index, unsigned value, unsigned set)
{
    if (trace_event_get_state(TRACE_SDCARD_SWITCH) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 61 "../hw/sd/trace-events"
            qemu_log("%d@%zu.%06zu:sdcard_switch " "SWITCH acc:%u idx:%u val:%u set:%u" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , access, index, value, set);
#line 1727 "trace/trace-hw_sd.h"
        } else {
#line 61 "../hw/sd/trace-events"
            qemu_log("sdcard_switch " "SWITCH acc:%u idx:%u val:%u set:%u" "\n", access, index, value, set);
#line 1731 "trace/trace-hw_sd.h"
        }
    }
}

static inline void trace_sdcard_switch(unsigned access, unsigned index, unsigned value, unsigned set)
{
    if (true) {
        _nocheck__trace_sdcard_switch(access, index, value, set);
    }
}

#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 64 "../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 1758 "trace/trace-hw_sd.h"
        } else {
#line 64 "../hw/sd/trace-events"
            qemu_log("pl181_command_send " "sending CMD%02d arg 0x%08" PRIx32 "\n", cmd, arg);
#line 1762 "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 65 "../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 1789 "trace/trace-hw_sd.h"
        } else {
#line 65 "../hw/sd/trace-events"
            qemu_log("pl181_command_sent " "command sent" "\n");
#line 1793 "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 66 "../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 1820 "trace/trace-hw_sd.h"
        } else {
#line 66 "../hw/sd/trace-events"
            qemu_log("pl181_command_response_pending " "response received" "\n");
#line 1824 "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 67 "../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 1851 "trace/trace-hw_sd.h"
        } else {
#line 67 "../hw/sd/trace-events"
            qemu_log("pl181_command_timeout " "command timeouted" "\n");
#line 1855 "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 68 "../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 1882 "trace/trace-hw_sd.h"
        } else {
#line 68 "../hw/sd/trace-events"
            qemu_log("pl181_fifo_push " "FIFO push 0x%08" PRIx32 "\n", data);
#line 1886 "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 69 "../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 1913 "trace/trace-hw_sd.h"
        } else {
#line 69 "../hw/sd/trace-events"
            qemu_log("pl181_fifo_pop " "FIFO pop 0x%08" PRIx32 "\n", data);
#line 1917 "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 70 "../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 1944 "trace/trace-hw_sd.h"
        } else {
#line 70 "../hw/sd/trace-events"
            qemu_log("pl181_fifo_transfer_complete " "FIFO transfer complete" "\n");
#line 1948 "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 71 "../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 1975 "trace/trace-hw_sd.h"
        } else {
#line 71 "../hw/sd/trace-events"
            qemu_log("pl181_data_engine_idle " "data engine idle" "\n");
#line 1979 "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 74 "../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 2006 "trace/trace-hw_sd.h"
        } else {
#line 74 "../hw/sd/trace-events"
            qemu_log("aspeed_sdhci_read " "@0x%" PRIx64 " size %u: 0x%" PRIx64 "\n", addr, size, data);
#line 2010 "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 75 "../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 2037 "trace/trace-hw_sd.h"
        } else {
#line 75 "../hw/sd/trace-events"
            qemu_log("aspeed_sdhci_write " "@0x%" PRIx64 " size %u: 0x%" PRIx64 "\n", addr, size, data);
#line 2041 "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 */