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

#ifndef TRACE_HW_MISC_MACIO_GENERATED_TRACERS_H
#define TRACE_HW_MISC_MACIO_GENERATED_TRACERS_H

#include "trace/control.h"

extern TraceEvent _TRACE_CUDA_DELAY_SET_SR_INT_EVENT;
extern TraceEvent _TRACE_CUDA_DATA_SEND_EVENT;
extern TraceEvent _TRACE_CUDA_DATA_RECV_EVENT;
extern TraceEvent _TRACE_CUDA_RECEIVE_PACKET_CMD_EVENT;
extern TraceEvent _TRACE_CUDA_PACKET_RECEIVE_EVENT;
extern TraceEvent _TRACE_CUDA_PACKET_RECEIVE_DATA_EVENT;
extern TraceEvent _TRACE_CUDA_PACKET_SEND_EVENT;
extern TraceEvent _TRACE_CUDA_PACKET_SEND_DATA_EVENT;
extern TraceEvent _TRACE_MACIO_TIMER_WRITE_EVENT;
extern TraceEvent _TRACE_MACIO_TIMER_READ_EVENT;
extern TraceEvent _TRACE_MACIO_SET_GPIO_EVENT;
extern TraceEvent _TRACE_MACIO_GPIO_IRQ_ASSERT_EVENT;
extern TraceEvent _TRACE_MACIO_GPIO_IRQ_DEASSERT_EVENT;
extern TraceEvent _TRACE_MACIO_GPIO_WRITE_EVENT;
extern TraceEvent _TRACE_PMU_ADB_POLL_EVENT;
extern TraceEvent _TRACE_PMU_ONE_SEC_TIMER_EVENT;
extern TraceEvent _TRACE_PMU_CMD_SET_INT_MASK_EVENT;
extern TraceEvent _TRACE_PMU_CMD_SET_ADB_AUTOPOLL_EVENT;
extern TraceEvent _TRACE_PMU_CMD_ADB_NOBUS_EVENT;
extern TraceEvent _TRACE_PMU_CMD_ADB_REQUEST_EVENT;
extern TraceEvent _TRACE_PMU_CMD_ADB_REPLY_EVENT;
extern TraceEvent _TRACE_PMU_DISPATCH_CMD_EVENT;
extern TraceEvent _TRACE_PMU_DISPATCH_UNKNOWN_CMD_EVENT;
extern TraceEvent _TRACE_PMU_DEBUG_PROTOCOL_STRING_EVENT;
extern TraceEvent _TRACE_PMU_DEBUG_PROTOCOL_RESP_SIZE_EVENT;
extern TraceEvent _TRACE_PMU_DEBUG_PROTOCOL_ERROR_EVENT;
extern TraceEvent _TRACE_PMU_DEBUG_PROTOCOL_CLEAR_TREQ_EVENT;
extern TraceEvent _TRACE_PMU_DEBUG_PROTOCOL_CMD_EVENT;
extern TraceEvent _TRACE_PMU_DEBUG_PROTOCOL_CMDLEN_EVENT;
extern TraceEvent _TRACE_PMU_DEBUG_PROTOCOL_CMD_TOOBIG_EVENT;
extern TraceEvent _TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP_SIZE_EVENT;
extern TraceEvent _TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP_EVENT;
extern TraceEvent _TRACE_PMU_DEBUG_PROTOCOL_CMD_RESP_COMPLETE_EVENT;
extern uint16_t _TRACE_CUDA_DELAY_SET_SR_INT_DSTATE;
extern uint16_t _TRACE_CUDA_DATA_SEND_DSTATE;
extern uint16_t _TRACE_CUDA_DATA_RECV_DSTATE;
extern uint16_t _TRACE_CUDA_RECEIVE_PACKET_CMD_DSTATE;
extern uint16_t _TRACE_CUDA_PACKET_RECEIVE_DSTATE;
extern uint16_t _TRACE_CUDA_PACKET_RECEIVE_DATA_DSTATE;
extern uint16_t _TRACE_CUDA_PACKET_SEND_DSTATE;
extern uint16_t _TRACE_CUDA_PACKET_SEND_DATA_DSTATE;
extern uint16_t _TRACE_MACIO_TIMER_WRITE_DSTATE;
extern uint16_t _TRACE_MACIO_TIMER_READ_DSTATE;
extern uint16_t _TRACE_MACIO_SET_GPIO_DSTATE;
extern uint16_t _TRACE_MACIO_GPIO_IRQ_ASSERT_DSTATE;
extern uint16_t _TRACE_MACIO_GPIO_IRQ_DEASSERT_DSTATE;
extern uint16_t _TRACE_MACIO_GPIO_WRITE_DSTATE;
extern uint16_t _TRACE_PMU_ADB_POLL_DSTATE;
extern uint16_t _TRACE_PMU_ONE_SEC_TIMER_DSTATE;
extern uint16_t _TRACE_PMU_CMD_SET_INT_MASK_DSTATE;
extern uint16_t _TRACE_PMU_CMD_SET_ADB_AUTOPOLL_DSTATE;
extern uint16_t _TRACE_PMU_CMD_ADB_NOBUS_DSTATE;
extern uint16_t _TRACE_PMU_CMD_ADB_REQUEST_DSTATE;
extern uint16_t _TRACE_PMU_CMD_ADB_REPLY_DSTATE;
extern uint16_t _TRACE_PMU_DISPATCH_CMD_DSTATE;
extern uint16_t _TRACE_PMU_DISPATCH_UNKNOWN_CMD_DSTATE;
extern uint16_t _TRACE_PMU_DEBUG_PROTOCOL_STRING_DSTATE;
extern uint16_t _TRACE_PMU_DEBUG_PROTOCOL_RESP_SIZE_DSTATE;
extern uint16_t _TRACE_PMU_DEBUG_PROTOCOL_ERROR_DSTATE;
extern uint16_t _TRACE_PMU_DEBUG_PROTOCOL_CLEAR_TREQ_DSTATE;
extern uint16_t _TRACE_PMU_DEBUG_PROTOCOL_CMD_DSTATE;
extern uint16_t _TRACE_PMU_DEBUG_PROTOCOL_CMDLEN_DSTATE;
extern uint16_t _TRACE_PMU_DEBUG_PROTOCOL_CMD_TOOBIG_DSTATE;
extern uint16_t _TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP_SIZE_DSTATE;
extern uint16_t _TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP_DSTATE;
extern uint16_t _TRACE_PMU_DEBUG_PROTOCOL_CMD_RESP_COMPLETE_DSTATE;
#define TRACE_CUDA_DELAY_SET_SR_INT_ENABLED 1
#define TRACE_CUDA_DATA_SEND_ENABLED 1
#define TRACE_CUDA_DATA_RECV_ENABLED 1
#define TRACE_CUDA_RECEIVE_PACKET_CMD_ENABLED 1
#define TRACE_CUDA_PACKET_RECEIVE_ENABLED 1
#define TRACE_CUDA_PACKET_RECEIVE_DATA_ENABLED 1
#define TRACE_CUDA_PACKET_SEND_ENABLED 1
#define TRACE_CUDA_PACKET_SEND_DATA_ENABLED 1
#define TRACE_MACIO_TIMER_WRITE_ENABLED 1
#define TRACE_MACIO_TIMER_READ_ENABLED 1
#define TRACE_MACIO_SET_GPIO_ENABLED 1
#define TRACE_MACIO_GPIO_IRQ_ASSERT_ENABLED 1
#define TRACE_MACIO_GPIO_IRQ_DEASSERT_ENABLED 1
#define TRACE_MACIO_GPIO_WRITE_ENABLED 1
#define TRACE_PMU_ADB_POLL_ENABLED 1
#define TRACE_PMU_ONE_SEC_TIMER_ENABLED 1
#define TRACE_PMU_CMD_SET_INT_MASK_ENABLED 1
#define TRACE_PMU_CMD_SET_ADB_AUTOPOLL_ENABLED 1
#define TRACE_PMU_CMD_ADB_NOBUS_ENABLED 1
#define TRACE_PMU_CMD_ADB_REQUEST_ENABLED 1
#define TRACE_PMU_CMD_ADB_REPLY_ENABLED 1
#define TRACE_PMU_DISPATCH_CMD_ENABLED 1
#define TRACE_PMU_DISPATCH_UNKNOWN_CMD_ENABLED 1
#define TRACE_PMU_DEBUG_PROTOCOL_STRING_ENABLED 1
#define TRACE_PMU_DEBUG_PROTOCOL_RESP_SIZE_ENABLED 1
#define TRACE_PMU_DEBUG_PROTOCOL_ERROR_ENABLED 1
#define TRACE_PMU_DEBUG_PROTOCOL_CLEAR_TREQ_ENABLED 1
#define TRACE_PMU_DEBUG_PROTOCOL_CMD_ENABLED 1
#define TRACE_PMU_DEBUG_PROTOCOL_CMDLEN_ENABLED 1
#define TRACE_PMU_DEBUG_PROTOCOL_CMD_TOOBIG_ENABLED 1
#define TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP_SIZE_ENABLED 1
#define TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP_ENABLED 1
#define TRACE_PMU_DEBUG_PROTOCOL_CMD_RESP_COMPLETE_ENABLED 1
#include "qemu/log-for-trace.h"
#include "qemu/error-report.h"


#define TRACE_CUDA_DELAY_SET_SR_INT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_CUDA_DELAY_SET_SR_INT) || \
    false)

static inline void _nocheck__trace_cuda_delay_set_sr_int(void)
{
    if (trace_event_get_state(TRACE_CUDA_DELAY_SET_SR_INT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 4 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:cuda_delay_set_sr_int " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 127 "trace/trace-hw_misc_macio.h"
        } else {
#line 4 "../hw/misc/macio/trace-events"
            qemu_log("cuda_delay_set_sr_int " "" "\n");
#line 131 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_cuda_delay_set_sr_int(void)
{
    if (true) {
        _nocheck__trace_cuda_delay_set_sr_int();
    }
}

#define TRACE_CUDA_DATA_SEND_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_CUDA_DATA_SEND) || \
    false)

static inline void _nocheck__trace_cuda_data_send(uint8_t data)
{
    if (trace_event_get_state(TRACE_CUDA_DATA_SEND) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 5 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:cuda_data_send " "send: 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , data);
#line 158 "trace/trace-hw_misc_macio.h"
        } else {
#line 5 "../hw/misc/macio/trace-events"
            qemu_log("cuda_data_send " "send: 0x%02x" "\n", data);
#line 162 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_cuda_data_send(uint8_t data)
{
    if (true) {
        _nocheck__trace_cuda_data_send(data);
    }
}

#define TRACE_CUDA_DATA_RECV_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_CUDA_DATA_RECV) || \
    false)

static inline void _nocheck__trace_cuda_data_recv(uint8_t data)
{
    if (trace_event_get_state(TRACE_CUDA_DATA_RECV) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 6 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:cuda_data_recv " "recv: 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , data);
#line 189 "trace/trace-hw_misc_macio.h"
        } else {
#line 6 "../hw/misc/macio/trace-events"
            qemu_log("cuda_data_recv " "recv: 0x%02x" "\n", data);
#line 193 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_cuda_data_recv(uint8_t data)
{
    if (true) {
        _nocheck__trace_cuda_data_recv(data);
    }
}

#define TRACE_CUDA_RECEIVE_PACKET_CMD_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_CUDA_RECEIVE_PACKET_CMD) || \
    false)

static inline void _nocheck__trace_cuda_receive_packet_cmd(const char * cmd)
{
    if (trace_event_get_state(TRACE_CUDA_RECEIVE_PACKET_CMD) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 7 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:cuda_receive_packet_cmd " "handling command %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cmd);
#line 220 "trace/trace-hw_misc_macio.h"
        } else {
#line 7 "../hw/misc/macio/trace-events"
            qemu_log("cuda_receive_packet_cmd " "handling command %s" "\n", cmd);
#line 224 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_cuda_receive_packet_cmd(const char * cmd)
{
    if (true) {
        _nocheck__trace_cuda_receive_packet_cmd(cmd);
    }
}

#define TRACE_CUDA_PACKET_RECEIVE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_CUDA_PACKET_RECEIVE) || \
    false)

static inline void _nocheck__trace_cuda_packet_receive(int len)
{
    if (trace_event_get_state(TRACE_CUDA_PACKET_RECEIVE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 8 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:cuda_packet_receive " "length %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len);
#line 251 "trace/trace-hw_misc_macio.h"
        } else {
#line 8 "../hw/misc/macio/trace-events"
            qemu_log("cuda_packet_receive " "length %d" "\n", len);
#line 255 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_cuda_packet_receive(int len)
{
    if (true) {
        _nocheck__trace_cuda_packet_receive(len);
    }
}

#define TRACE_CUDA_PACKET_RECEIVE_DATA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_CUDA_PACKET_RECEIVE_DATA) || \
    false)

static inline void _nocheck__trace_cuda_packet_receive_data(int i, const uint8_t data)
{
    if (trace_event_get_state(TRACE_CUDA_PACKET_RECEIVE_DATA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 9 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:cuda_packet_receive_data " "[%d] 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , i, data);
#line 282 "trace/trace-hw_misc_macio.h"
        } else {
#line 9 "../hw/misc/macio/trace-events"
            qemu_log("cuda_packet_receive_data " "[%d] 0x%02x" "\n", i, data);
#line 286 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_cuda_packet_receive_data(int i, const uint8_t data)
{
    if (true) {
        _nocheck__trace_cuda_packet_receive_data(i, data);
    }
}

#define TRACE_CUDA_PACKET_SEND_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_CUDA_PACKET_SEND) || \
    false)

static inline void _nocheck__trace_cuda_packet_send(int len)
{
    if (trace_event_get_state(TRACE_CUDA_PACKET_SEND) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 10 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:cuda_packet_send " "length %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len);
#line 313 "trace/trace-hw_misc_macio.h"
        } else {
#line 10 "../hw/misc/macio/trace-events"
            qemu_log("cuda_packet_send " "length %d" "\n", len);
#line 317 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_cuda_packet_send(int len)
{
    if (true) {
        _nocheck__trace_cuda_packet_send(len);
    }
}

#define TRACE_CUDA_PACKET_SEND_DATA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_CUDA_PACKET_SEND_DATA) || \
    false)

static inline void _nocheck__trace_cuda_packet_send_data(int i, const uint8_t data)
{
    if (trace_event_get_state(TRACE_CUDA_PACKET_SEND_DATA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 11 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:cuda_packet_send_data " "[%d] 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , i, data);
#line 344 "trace/trace-hw_misc_macio.h"
        } else {
#line 11 "../hw/misc/macio/trace-events"
            qemu_log("cuda_packet_send_data " "[%d] 0x%02x" "\n", i, data);
#line 348 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_cuda_packet_send_data(int i, const uint8_t data)
{
    if (true) {
        _nocheck__trace_cuda_packet_send_data(i, data);
    }
}

#define TRACE_MACIO_TIMER_WRITE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_MACIO_TIMER_WRITE) || \
    false)

static inline void _nocheck__trace_macio_timer_write(uint64_t addr, unsigned len, uint64_t val)
{
    if (trace_event_get_state(TRACE_MACIO_TIMER_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 14 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:macio_timer_write " "write addr 0x%"PRIx64 " len %d val 0x%"PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , addr, len, val);
#line 375 "trace/trace-hw_misc_macio.h"
        } else {
#line 14 "../hw/misc/macio/trace-events"
            qemu_log("macio_timer_write " "write addr 0x%"PRIx64 " len %d val 0x%"PRIx64 "\n", addr, len, val);
#line 379 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_macio_timer_write(uint64_t addr, unsigned len, uint64_t val)
{
    if (true) {
        _nocheck__trace_macio_timer_write(addr, len, val);
    }
}

#define TRACE_MACIO_TIMER_READ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_MACIO_TIMER_READ) || \
    false)

static inline void _nocheck__trace_macio_timer_read(uint64_t addr, unsigned len, uint32_t val)
{
    if (trace_event_get_state(TRACE_MACIO_TIMER_READ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 15 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:macio_timer_read " "read addr 0x%"PRIx64 " len %d val 0x%"PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , addr, len, val);
#line 406 "trace/trace-hw_misc_macio.h"
        } else {
#line 15 "../hw/misc/macio/trace-events"
            qemu_log("macio_timer_read " "read addr 0x%"PRIx64 " len %d val 0x%"PRIx32 "\n", addr, len, val);
#line 410 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_macio_timer_read(uint64_t addr, unsigned len, uint32_t val)
{
    if (true) {
        _nocheck__trace_macio_timer_read(addr, len, val);
    }
}

#define TRACE_MACIO_SET_GPIO_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_MACIO_SET_GPIO) || \
    false)

static inline void _nocheck__trace_macio_set_gpio(int gpio, bool state)
{
    if (trace_event_get_state(TRACE_MACIO_SET_GPIO) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 18 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:macio_set_gpio " "setting GPIO %d to %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , gpio, state);
#line 437 "trace/trace-hw_misc_macio.h"
        } else {
#line 18 "../hw/misc/macio/trace-events"
            qemu_log("macio_set_gpio " "setting GPIO %d to %d" "\n", gpio, state);
#line 441 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_macio_set_gpio(int gpio, bool state)
{
    if (true) {
        _nocheck__trace_macio_set_gpio(gpio, state);
    }
}

#define TRACE_MACIO_GPIO_IRQ_ASSERT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_MACIO_GPIO_IRQ_ASSERT) || \
    false)

static inline void _nocheck__trace_macio_gpio_irq_assert(int gpio)
{
    if (trace_event_get_state(TRACE_MACIO_GPIO_IRQ_ASSERT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 19 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:macio_gpio_irq_assert " "asserting GPIO %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , gpio);
#line 468 "trace/trace-hw_misc_macio.h"
        } else {
#line 19 "../hw/misc/macio/trace-events"
            qemu_log("macio_gpio_irq_assert " "asserting GPIO %d" "\n", gpio);
#line 472 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_macio_gpio_irq_assert(int gpio)
{
    if (true) {
        _nocheck__trace_macio_gpio_irq_assert(gpio);
    }
}

#define TRACE_MACIO_GPIO_IRQ_DEASSERT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_MACIO_GPIO_IRQ_DEASSERT) || \
    false)

static inline void _nocheck__trace_macio_gpio_irq_deassert(int gpio)
{
    if (trace_event_get_state(TRACE_MACIO_GPIO_IRQ_DEASSERT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 20 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:macio_gpio_irq_deassert " "deasserting GPIO %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , gpio);
#line 499 "trace/trace-hw_misc_macio.h"
        } else {
#line 20 "../hw/misc/macio/trace-events"
            qemu_log("macio_gpio_irq_deassert " "deasserting GPIO %d" "\n", gpio);
#line 503 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_macio_gpio_irq_deassert(int gpio)
{
    if (true) {
        _nocheck__trace_macio_gpio_irq_deassert(gpio);
    }
}

#define TRACE_MACIO_GPIO_WRITE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_MACIO_GPIO_WRITE) || \
    false)

static inline void _nocheck__trace_macio_gpio_write(uint64_t addr, uint64_t val)
{
    if (trace_event_get_state(TRACE_MACIO_GPIO_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 21 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:macio_gpio_write " "addr: 0x%"PRIx64" value: 0x%"PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , addr, val);
#line 530 "trace/trace-hw_misc_macio.h"
        } else {
#line 21 "../hw/misc/macio/trace-events"
            qemu_log("macio_gpio_write " "addr: 0x%"PRIx64" value: 0x%"PRIx64 "\n", addr, val);
#line 534 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_macio_gpio_write(uint64_t addr, uint64_t val)
{
    if (true) {
        _nocheck__trace_macio_gpio_write(addr, val);
    }
}

#define TRACE_PMU_ADB_POLL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_ADB_POLL) || \
    false)

static inline void _nocheck__trace_pmu_adb_poll(int olen)
{
    if (trace_event_get_state(TRACE_PMU_ADB_POLL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 24 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_adb_poll " "ADB autopoll, olen=%d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , olen);
#line 561 "trace/trace-hw_misc_macio.h"
        } else {
#line 24 "../hw/misc/macio/trace-events"
            qemu_log("pmu_adb_poll " "ADB autopoll, olen=%d" "\n", olen);
#line 565 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_adb_poll(int olen)
{
    if (true) {
        _nocheck__trace_pmu_adb_poll(olen);
    }
}

#define TRACE_PMU_ONE_SEC_TIMER_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_ONE_SEC_TIMER) || \
    false)

static inline void _nocheck__trace_pmu_one_sec_timer(void)
{
    if (trace_event_get_state(TRACE_PMU_ONE_SEC_TIMER) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 25 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_one_sec_timer " "PMU one sec..." "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 592 "trace/trace-hw_misc_macio.h"
        } else {
#line 25 "../hw/misc/macio/trace-events"
            qemu_log("pmu_one_sec_timer " "PMU one sec..." "\n");
#line 596 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_one_sec_timer(void)
{
    if (true) {
        _nocheck__trace_pmu_one_sec_timer();
    }
}

#define TRACE_PMU_CMD_SET_INT_MASK_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_CMD_SET_INT_MASK) || \
    false)

static inline void _nocheck__trace_pmu_cmd_set_int_mask(int intmask)
{
    if (trace_event_get_state(TRACE_PMU_CMD_SET_INT_MASK) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 26 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_cmd_set_int_mask " "Setting PMU int mask to 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , intmask);
#line 623 "trace/trace-hw_misc_macio.h"
        } else {
#line 26 "../hw/misc/macio/trace-events"
            qemu_log("pmu_cmd_set_int_mask " "Setting PMU int mask to 0x%02x" "\n", intmask);
#line 627 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_cmd_set_int_mask(int intmask)
{
    if (true) {
        _nocheck__trace_pmu_cmd_set_int_mask(intmask);
    }
}

#define TRACE_PMU_CMD_SET_ADB_AUTOPOLL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_CMD_SET_ADB_AUTOPOLL) || \
    false)

static inline void _nocheck__trace_pmu_cmd_set_adb_autopoll(int mask)
{
    if (trace_event_get_state(TRACE_PMU_CMD_SET_ADB_AUTOPOLL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 27 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_cmd_set_adb_autopoll " "ADB set autopoll, mask=0x%04x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , mask);
#line 654 "trace/trace-hw_misc_macio.h"
        } else {
#line 27 "../hw/misc/macio/trace-events"
            qemu_log("pmu_cmd_set_adb_autopoll " "ADB set autopoll, mask=0x%04x" "\n", mask);
#line 658 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_cmd_set_adb_autopoll(int mask)
{
    if (true) {
        _nocheck__trace_pmu_cmd_set_adb_autopoll(mask);
    }
}

#define TRACE_PMU_CMD_ADB_NOBUS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_CMD_ADB_NOBUS) || \
    false)

static inline void _nocheck__trace_pmu_cmd_adb_nobus(void)
{
    if (trace_event_get_state(TRACE_PMU_CMD_ADB_NOBUS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 28 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_cmd_adb_nobus " "ADB PACKET with no ADB bus!" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 685 "trace/trace-hw_misc_macio.h"
        } else {
#line 28 "../hw/misc/macio/trace-events"
            qemu_log("pmu_cmd_adb_nobus " "ADB PACKET with no ADB bus!" "\n");
#line 689 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_cmd_adb_nobus(void)
{
    if (true) {
        _nocheck__trace_pmu_cmd_adb_nobus();
    }
}

#define TRACE_PMU_CMD_ADB_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_CMD_ADB_REQUEST) || \
    false)

static inline void _nocheck__trace_pmu_cmd_adb_request(int inlen, int indata0, int indata1, int indata2, int indata3, int indata4)
{
    if (trace_event_get_state(TRACE_PMU_CMD_ADB_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 29 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_cmd_adb_request " "ADB request: len=%d, cmd=0x%02x, pflags=0x%02x, adblen=%d: 0x%02x 0x%02x..." "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , inlen, indata0, indata1, indata2, indata3, indata4);
#line 716 "trace/trace-hw_misc_macio.h"
        } else {
#line 29 "../hw/misc/macio/trace-events"
            qemu_log("pmu_cmd_adb_request " "ADB request: len=%d, cmd=0x%02x, pflags=0x%02x, adblen=%d: 0x%02x 0x%02x..." "\n", inlen, indata0, indata1, indata2, indata3, indata4);
#line 720 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_cmd_adb_request(int inlen, int indata0, int indata1, int indata2, int indata3, int indata4)
{
    if (true) {
        _nocheck__trace_pmu_cmd_adb_request(inlen, indata0, indata1, indata2, indata3, indata4);
    }
}

#define TRACE_PMU_CMD_ADB_REPLY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_CMD_ADB_REPLY) || \
    false)

static inline void _nocheck__trace_pmu_cmd_adb_reply(int len)
{
    if (trace_event_get_state(TRACE_PMU_CMD_ADB_REPLY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 30 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_cmd_adb_reply " "ADB reply is %d bytes" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len);
#line 747 "trace/trace-hw_misc_macio.h"
        } else {
#line 30 "../hw/misc/macio/trace-events"
            qemu_log("pmu_cmd_adb_reply " "ADB reply is %d bytes" "\n", len);
#line 751 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_cmd_adb_reply(int len)
{
    if (true) {
        _nocheck__trace_pmu_cmd_adb_reply(len);
    }
}

#define TRACE_PMU_DISPATCH_CMD_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DISPATCH_CMD) || \
    false)

static inline void _nocheck__trace_pmu_dispatch_cmd(const char * name)
{
    if (trace_event_get_state(TRACE_PMU_DISPATCH_CMD) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 31 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_dispatch_cmd " "handling command %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , name);
#line 778 "trace/trace-hw_misc_macio.h"
        } else {
#line 31 "../hw/misc/macio/trace-events"
            qemu_log("pmu_dispatch_cmd " "handling command %s" "\n", name);
#line 782 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_dispatch_cmd(const char * name)
{
    if (true) {
        _nocheck__trace_pmu_dispatch_cmd(name);
    }
}

#define TRACE_PMU_DISPATCH_UNKNOWN_CMD_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DISPATCH_UNKNOWN_CMD) || \
    false)

static inline void _nocheck__trace_pmu_dispatch_unknown_cmd(int cmd)
{
    if (trace_event_get_state(TRACE_PMU_DISPATCH_UNKNOWN_CMD) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 32 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_dispatch_unknown_cmd " "Unknown PMU command 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cmd);
#line 809 "trace/trace-hw_misc_macio.h"
        } else {
#line 32 "../hw/misc/macio/trace-events"
            qemu_log("pmu_dispatch_unknown_cmd " "Unknown PMU command 0x%02x" "\n", cmd);
#line 813 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_dispatch_unknown_cmd(int cmd)
{
    if (true) {
        _nocheck__trace_pmu_dispatch_unknown_cmd(cmd);
    }
}

#define TRACE_PMU_DEBUG_PROTOCOL_STRING_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DEBUG_PROTOCOL_STRING) || \
    false)

static inline void _nocheck__trace_pmu_debug_protocol_string(const char * str)
{
    if (trace_event_get_state(TRACE_PMU_DEBUG_PROTOCOL_STRING) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 33 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_debug_protocol_string " "%s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , str);
#line 840 "trace/trace-hw_misc_macio.h"
        } else {
#line 33 "../hw/misc/macio/trace-events"
            qemu_log("pmu_debug_protocol_string " "%s" "\n", str);
#line 844 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_debug_protocol_string(const char * str)
{
    if (true) {
        _nocheck__trace_pmu_debug_protocol_string(str);
    }
}

#define TRACE_PMU_DEBUG_PROTOCOL_RESP_SIZE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DEBUG_PROTOCOL_RESP_SIZE) || \
    false)

static inline void _nocheck__trace_pmu_debug_protocol_resp_size(int size)
{
    if (trace_event_get_state(TRACE_PMU_DEBUG_PROTOCOL_RESP_SIZE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 34 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_debug_protocol_resp_size " "sending %d resp bytes" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , size);
#line 871 "trace/trace-hw_misc_macio.h"
        } else {
#line 34 "../hw/misc/macio/trace-events"
            qemu_log("pmu_debug_protocol_resp_size " "sending %d resp bytes" "\n", size);
#line 875 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_debug_protocol_resp_size(int size)
{
    if (true) {
        _nocheck__trace_pmu_debug_protocol_resp_size(size);
    }
}

#define TRACE_PMU_DEBUG_PROTOCOL_ERROR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DEBUG_PROTOCOL_ERROR) || \
    false)

static inline void _nocheck__trace_pmu_debug_protocol_error(int portB)
{
    if (trace_event_get_state(TRACE_PMU_DEBUG_PROTOCOL_ERROR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 35 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_debug_protocol_error " "protocol error! portB=0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , portB);
#line 902 "trace/trace-hw_misc_macio.h"
        } else {
#line 35 "../hw/misc/macio/trace-events"
            qemu_log("pmu_debug_protocol_error " "protocol error! portB=0x%02x" "\n", portB);
#line 906 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_debug_protocol_error(int portB)
{
    if (true) {
        _nocheck__trace_pmu_debug_protocol_error(portB);
    }
}

#define TRACE_PMU_DEBUG_PROTOCOL_CLEAR_TREQ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DEBUG_PROTOCOL_CLEAR_TREQ) || \
    false)

static inline void _nocheck__trace_pmu_debug_protocol_clear_treq(int state)
{
    if (trace_event_get_state(TRACE_PMU_DEBUG_PROTOCOL_CLEAR_TREQ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 36 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_debug_protocol_clear_treq " "TREQ cleared, clearing TACK, state: %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , state);
#line 933 "trace/trace-hw_misc_macio.h"
        } else {
#line 36 "../hw/misc/macio/trace-events"
            qemu_log("pmu_debug_protocol_clear_treq " "TREQ cleared, clearing TACK, state: %d" "\n", state);
#line 937 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_debug_protocol_clear_treq(int state)
{
    if (true) {
        _nocheck__trace_pmu_debug_protocol_clear_treq(state);
    }
}

#define TRACE_PMU_DEBUG_PROTOCOL_CMD_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DEBUG_PROTOCOL_CMD) || \
    false)

static inline void _nocheck__trace_pmu_debug_protocol_cmd(int cmd, int cmdlen, int rsplen)
{
    if (trace_event_get_state(TRACE_PMU_DEBUG_PROTOCOL_CMD) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 37 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_debug_protocol_cmd " "Got command byte 0x%02x, clen=%d, rlen=%d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cmd, cmdlen, rsplen);
#line 964 "trace/trace-hw_misc_macio.h"
        } else {
#line 37 "../hw/misc/macio/trace-events"
            qemu_log("pmu_debug_protocol_cmd " "Got command byte 0x%02x, clen=%d, rlen=%d" "\n", cmd, cmdlen, rsplen);
#line 968 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_debug_protocol_cmd(int cmd, int cmdlen, int rsplen)
{
    if (true) {
        _nocheck__trace_pmu_debug_protocol_cmd(cmd, cmdlen, rsplen);
    }
}

#define TRACE_PMU_DEBUG_PROTOCOL_CMDLEN_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DEBUG_PROTOCOL_CMDLEN) || \
    false)

static inline void _nocheck__trace_pmu_debug_protocol_cmdlen(int len)
{
    if (trace_event_get_state(TRACE_PMU_DEBUG_PROTOCOL_CMDLEN) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 38 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_debug_protocol_cmdlen " "got cmd length byte: %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len);
#line 995 "trace/trace-hw_misc_macio.h"
        } else {
#line 38 "../hw/misc/macio/trace-events"
            qemu_log("pmu_debug_protocol_cmdlen " "got cmd length byte: %d" "\n", len);
#line 999 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_debug_protocol_cmdlen(int len)
{
    if (true) {
        _nocheck__trace_pmu_debug_protocol_cmdlen(len);
    }
}

#define TRACE_PMU_DEBUG_PROTOCOL_CMD_TOOBIG_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DEBUG_PROTOCOL_CMD_TOOBIG) || \
    false)

static inline void _nocheck__trace_pmu_debug_protocol_cmd_toobig(int len)
{
    if (trace_event_get_state(TRACE_PMU_DEBUG_PROTOCOL_CMD_TOOBIG) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 39 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_debug_protocol_cmd_toobig " "command too big (%d bytes)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len);
#line 1026 "trace/trace-hw_misc_macio.h"
        } else {
#line 39 "../hw/misc/macio/trace-events"
            qemu_log("pmu_debug_protocol_cmd_toobig " "command too big (%d bytes)" "\n", len);
#line 1030 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_debug_protocol_cmd_toobig(int len)
{
    if (true) {
        _nocheck__trace_pmu_debug_protocol_cmd_toobig(len);
    }
}

#define TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP_SIZE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP_SIZE) || \
    false)

static inline void _nocheck__trace_pmu_debug_protocol_cmd_send_resp_size(int len)
{
    if (trace_event_get_state(TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP_SIZE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 40 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_debug_protocol_cmd_send_resp_size " "sending length byte: %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len);
#line 1057 "trace/trace-hw_misc_macio.h"
        } else {
#line 40 "../hw/misc/macio/trace-events"
            qemu_log("pmu_debug_protocol_cmd_send_resp_size " "sending length byte: %d" "\n", len);
#line 1061 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_debug_protocol_cmd_send_resp_size(int len)
{
    if (true) {
        _nocheck__trace_pmu_debug_protocol_cmd_send_resp_size(len);
    }
}

#define TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP) || \
    false)

static inline void _nocheck__trace_pmu_debug_protocol_cmd_send_resp(int pos, int len)
{
    if (trace_event_get_state(TRACE_PMU_DEBUG_PROTOCOL_CMD_SEND_RESP) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 41 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_debug_protocol_cmd_send_resp " "sending byte: %d/%d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , pos, len);
#line 1088 "trace/trace-hw_misc_macio.h"
        } else {
#line 41 "../hw/misc/macio/trace-events"
            qemu_log("pmu_debug_protocol_cmd_send_resp " "sending byte: %d/%d" "\n", pos, len);
#line 1092 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_debug_protocol_cmd_send_resp(int pos, int len)
{
    if (true) {
        _nocheck__trace_pmu_debug_protocol_cmd_send_resp(pos, len);
    }
}

#define TRACE_PMU_DEBUG_PROTOCOL_CMD_RESP_COMPLETE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PMU_DEBUG_PROTOCOL_CMD_RESP_COMPLETE) || \
    false)

static inline void _nocheck__trace_pmu_debug_protocol_cmd_resp_complete(int ier)
{
    if (trace_event_get_state(TRACE_PMU_DEBUG_PROTOCOL_CMD_RESP_COMPLETE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 42 "../hw/misc/macio/trace-events"
            qemu_log("%d@%zu.%06zu:pmu_debug_protocol_cmd_resp_complete " "Response send complete. IER=0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , ier);
#line 1119 "trace/trace-hw_misc_macio.h"
        } else {
#line 42 "../hw/misc/macio/trace-events"
            qemu_log("pmu_debug_protocol_cmd_resp_complete " "Response send complete. IER=0x%02x" "\n", ier);
#line 1123 "trace/trace-hw_misc_macio.h"
        }
    }
}

static inline void trace_pmu_debug_protocol_cmd_resp_complete(int ier)
{
    if (true) {
        _nocheck__trace_pmu_debug_protocol_cmd_resp_complete(ier);
    }
}
#endif /* TRACE_HW_MISC_MACIO_GENERATED_TRACERS_H */