Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0-only */
0002 /*
0003  * Tracepoints definitions.
0004  *
0005  * Copyright (c) 2018-2020, Silicon Laboratories, Inc.
0006  */
0007 
0008 #undef TRACE_SYSTEM
0009 #define TRACE_SYSTEM wfx
0010 
0011 #if !defined(_WFX_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
0012 #define _WFX_TRACE_H
0013 
0014 #include <linux/tracepoint.h>
0015 #include <net/mac80211.h>
0016 
0017 #include "bus.h"
0018 #include "hif_api_cmd.h"
0019 #include "hif_api_mib.h"
0020 
0021 /* The hell below need some explanations. For each symbolic number, we need to define it with
0022  * TRACE_DEFINE_ENUM() and in a list for __print_symbolic.
0023  *
0024  *   1. Define a new macro that call TRACE_DEFINE_ENUM():
0025  *
0026  *          #define xxx_name(sym) TRACE_DEFINE_ENUM(sym);
0027  *
0028  *   2. Define list of all symbols:
0029  *
0030  *          #define list_names     \
0031  *             ...                 \
0032  *             xxx_name(XXX)       \
0033  *             ...
0034  *
0035  *   3. Instantiate that list_names:
0036  *
0037  *          list_names
0038  *
0039  *   4. Redefine xxx_name() as an entry of array for __print_symbolic()
0040  *
0041  *          #undef xxx_name
0042  *          #define xxx_name(msg) { msg, #msg },
0043  *
0044  *   5. list_name can now nearly be used with __print_symbolic() but, __print_symbolic() dislike
0045  *      last comma of list. So we define a new list with a dummy element:
0046  *
0047  *          #define list_for_print_symbolic list_names { -1, NULL }
0048  */
0049 
0050 #define _hif_msg_list                       \
0051     hif_cnf_name(ADD_KEY)               \
0052     hif_cnf_name(BEACON_TRANSMIT)       \
0053     hif_cnf_name(EDCA_QUEUE_PARAMS)     \
0054     hif_cnf_name(JOIN)                  \
0055     hif_cnf_name(MAP_LINK)              \
0056     hif_cnf_name(READ_MIB)              \
0057     hif_cnf_name(REMOVE_KEY)            \
0058     hif_cnf_name(RESET)                 \
0059     hif_cnf_name(SET_BSS_PARAMS)        \
0060     hif_cnf_name(SET_PM_MODE)           \
0061     hif_cnf_name(START)                 \
0062     hif_cnf_name(START_SCAN)            \
0063     hif_cnf_name(STOP_SCAN)             \
0064     hif_cnf_name(TX)                    \
0065     hif_cnf_name(MULTI_TRANSMIT)        \
0066     hif_cnf_name(UPDATE_IE)             \
0067     hif_cnf_name(WRITE_MIB)             \
0068     hif_cnf_name(CONFIGURATION)         \
0069     hif_cnf_name(CONTROL_GPIO)          \
0070     hif_cnf_name(PREVENT_ROLLBACK)      \
0071     hif_cnf_name(SET_SL_MAC_KEY)        \
0072     hif_cnf_name(SL_CONFIGURE)          \
0073     hif_cnf_name(SL_EXCHANGE_PUB_KEYS)  \
0074     hif_cnf_name(SHUT_DOWN)             \
0075     hif_ind_name(EVENT)                 \
0076     hif_ind_name(JOIN_COMPLETE)         \
0077     hif_ind_name(RX)                    \
0078     hif_ind_name(SCAN_CMPL)             \
0079     hif_ind_name(SET_PM_MODE_CMPL)      \
0080     hif_ind_name(SUSPEND_RESUME_TX)     \
0081     hif_ind_name(SL_EXCHANGE_PUB_KEYS)  \
0082     hif_ind_name(ERROR)                 \
0083     hif_ind_name(EXCEPTION)             \
0084     hif_ind_name(GENERIC)               \
0085     hif_ind_name(WAKEUP)                \
0086     hif_ind_name(STARTUP)
0087 
0088 #define hif_msg_list_enum _hif_msg_list
0089 
0090 #undef hif_cnf_name
0091 #undef hif_ind_name
0092 #define hif_cnf_name(msg) TRACE_DEFINE_ENUM(HIF_CNF_ID_##msg);
0093 #define hif_ind_name(msg) TRACE_DEFINE_ENUM(HIF_IND_ID_##msg);
0094 hif_msg_list_enum
0095 #undef hif_cnf_name
0096 #undef hif_ind_name
0097 #define hif_cnf_name(msg) { HIF_CNF_ID_##msg, #msg },
0098 #define hif_ind_name(msg) { HIF_IND_ID_##msg, #msg },
0099 #define hif_msg_list hif_msg_list_enum { -1, NULL }
0100 
0101 #define _hif_mib_list                                \
0102     hif_mib_name(ARP_IP_ADDRESSES_TABLE)         \
0103     hif_mib_name(ARP_KEEP_ALIVE_PERIOD)          \
0104     hif_mib_name(BEACON_FILTER_ENABLE)           \
0105     hif_mib_name(BEACON_FILTER_TABLE)            \
0106     hif_mib_name(BEACON_STATS)                   \
0107     hif_mib_name(BEACON_WAKEUP_PERIOD)           \
0108     hif_mib_name(BLOCK_ACK_POLICY)               \
0109     hif_mib_name(CCA_CONFIG)                     \
0110     hif_mib_name(CONFIG_DATA_FILTER)             \
0111     hif_mib_name(COUNTERS_TABLE)                 \
0112     hif_mib_name(CURRENT_TX_POWER_LEVEL)         \
0113     hif_mib_name(DOT11_MAC_ADDRESS)              \
0114     hif_mib_name(DOT11_MAX_RECEIVE_LIFETIME)     \
0115     hif_mib_name(DOT11_MAX_TRANSMIT_MSDU_LIFETIME) \
0116     hif_mib_name(DOT11_RTS_THRESHOLD)            \
0117     hif_mib_name(DOT11_WEP_DEFAULT_KEY_ID)       \
0118     hif_mib_name(ETHERTYPE_DATAFRAME_CONDITION)  \
0119     hif_mib_name(EXTENDED_COUNTERS_TABLE)        \
0120     hif_mib_name(GL_BLOCK_ACK_INFO)              \
0121     hif_mib_name(GL_OPERATIONAL_POWER_MODE)      \
0122     hif_mib_name(GL_SET_MULTI_MSG)               \
0123     hif_mib_name(GRP_SEQ_COUNTER)                \
0124     hif_mib_name(INACTIVITY_TIMER)               \
0125     hif_mib_name(INTERFACE_PROTECTION)           \
0126     hif_mib_name(IPV4_ADDR_DATAFRAME_CONDITION)  \
0127     hif_mib_name(IPV6_ADDR_DATAFRAME_CONDITION)  \
0128     hif_mib_name(KEEP_ALIVE_PERIOD)              \
0129     hif_mib_name(MAC_ADDR_DATAFRAME_CONDITION)   \
0130     hif_mib_name(MAGIC_DATAFRAME_CONDITION)      \
0131     hif_mib_name(MAX_TX_POWER_LEVEL)             \
0132     hif_mib_name(NON_ERP_PROTECTION)             \
0133     hif_mib_name(NS_IP_ADDRESSES_TABLE)          \
0134     hif_mib_name(OVERRIDE_INTERNAL_TX_RATE)      \
0135     hif_mib_name(PORT_DATAFRAME_CONDITION)       \
0136     hif_mib_name(PROTECTED_MGMT_POLICY)          \
0137     hif_mib_name(RCPI_RSSI_THRESHOLD)            \
0138     hif_mib_name(RX_FILTER)                      \
0139     hif_mib_name(SET_ASSOCIATION_MODE)           \
0140     hif_mib_name(SET_DATA_FILTERING)             \
0141     hif_mib_name(SET_HT_PROTECTION)              \
0142     hif_mib_name(SET_TX_RATE_RETRY_POLICY)       \
0143     hif_mib_name(SET_UAPSD_INFORMATION)          \
0144     hif_mib_name(SLOT_TIME)                      \
0145     hif_mib_name(STATISTICS_TABLE)               \
0146     hif_mib_name(TEMPLATE_FRAME)                 \
0147     hif_mib_name(TSF_COUNTER)                    \
0148     hif_mib_name(UC_MC_BC_DATAFRAME_CONDITION)
0149 
0150 #define hif_mib_list_enum _hif_mib_list
0151 
0152 #undef hif_mib_name
0153 #define hif_mib_name(mib) TRACE_DEFINE_ENUM(HIF_MIB_ID_##mib);
0154 hif_mib_list_enum
0155 #undef hif_mib_name
0156 #define hif_mib_name(mib) { HIF_MIB_ID_##mib, #mib },
0157 #define hif_mib_list hif_mib_list_enum { -1, NULL }
0158 
0159 DECLARE_EVENT_CLASS(hif_data,
0160     TP_PROTO(const struct wfx_hif_msg *hif, int tx_fill_level, bool is_recv),
0161     TP_ARGS(hif, tx_fill_level, is_recv),
0162     TP_STRUCT__entry(
0163         __field(int, tx_fill_level)
0164         __field(int, msg_id)
0165         __field(const char *, msg_type)
0166         __field(int, msg_len)
0167         __field(int, buf_len)
0168         __field(int, if_id)
0169         __field(int, mib)
0170         __array(u8, buf, 128)
0171     ),
0172     TP_fast_assign(
0173         int header_len;
0174 
0175         __entry->tx_fill_level = tx_fill_level;
0176         __entry->msg_len = le16_to_cpu(hif->len);
0177         __entry->msg_id = hif->id;
0178         __entry->if_id = hif->interface;
0179         if (is_recv)
0180             __entry->msg_type = __entry->msg_id & 0x80 ? "IND" : "CNF";
0181         else
0182             __entry->msg_type = "REQ";
0183         if (!is_recv &&
0184             (__entry->msg_id == HIF_REQ_ID_READ_MIB ||
0185              __entry->msg_id == HIF_REQ_ID_WRITE_MIB)) {
0186             __entry->mib = le16_to_cpup((__le16 *)hif->body);
0187             header_len = 4;
0188         } else {
0189             __entry->mib = -1;
0190             header_len = 0;
0191         }
0192         __entry->buf_len = min_t(int, __entry->msg_len, sizeof(__entry->buf))
0193                    - sizeof(struct wfx_hif_msg) - header_len;
0194         memcpy(__entry->buf, hif->body + header_len, __entry->buf_len);
0195     ),
0196     TP_printk("%d:%d:%s_%s%s%s: %s%s (%d bytes)",
0197         __entry->tx_fill_level,
0198         __entry->if_id,
0199         __entry->msg_type,
0200         __print_symbolic(__entry->msg_id, hif_msg_list),
0201         __entry->mib != -1 ? "/" : "",
0202         __entry->mib != -1 ? __print_symbolic(__entry->mib, hif_mib_list) : "",
0203         __print_hex(__entry->buf, __entry->buf_len),
0204         __entry->msg_len > sizeof(__entry->buf) ? " ..." : "",
0205         __entry->msg_len
0206     )
0207 );
0208 DEFINE_EVENT(hif_data, hif_send,
0209     TP_PROTO(const struct wfx_hif_msg *hif, int tx_fill_level, bool is_recv),
0210     TP_ARGS(hif, tx_fill_level, is_recv));
0211 #define _trace_hif_send(hif, tx_fill_level)\
0212     trace_hif_send(hif, tx_fill_level, false)
0213 DEFINE_EVENT(hif_data, hif_recv,
0214     TP_PROTO(const struct wfx_hif_msg *hif, int tx_fill_level, bool is_recv),
0215     TP_ARGS(hif, tx_fill_level, is_recv));
0216 #define _trace_hif_recv(hif, tx_fill_level)\
0217     trace_hif_recv(hif, tx_fill_level, true)
0218 
0219 #define wfx_reg_list_enum                                 \
0220     wfx_reg_name(WFX_REG_CONFIG,       "CONFIG")      \
0221     wfx_reg_name(WFX_REG_CONTROL,      "CONTROL")     \
0222     wfx_reg_name(WFX_REG_IN_OUT_QUEUE, "QUEUE")       \
0223     wfx_reg_name(WFX_REG_AHB_DPORT,    "AHB")         \
0224     wfx_reg_name(WFX_REG_BASE_ADDR,    "BASE_ADDR")   \
0225     wfx_reg_name(WFX_REG_SRAM_DPORT,   "SRAM")        \
0226     wfx_reg_name(WFX_REG_SET_GEN_R_W,  "SET_GEN_R_W") \
0227     wfx_reg_name(WFX_REG_FRAME_OUT,    "FRAME_OUT")
0228 
0229 #undef wfx_reg_name
0230 #define wfx_reg_name(sym, name) TRACE_DEFINE_ENUM(sym);
0231 wfx_reg_list_enum
0232 #undef wfx_reg_name
0233 #define wfx_reg_name(sym, name) { sym, name },
0234 #define wfx_reg_list wfx_reg_list_enum { -1, NULL }
0235 
0236 DECLARE_EVENT_CLASS(io_data,
0237     TP_PROTO(int reg, int addr, const void *io_buf, size_t len),
0238     TP_ARGS(reg, addr, io_buf, len),
0239     TP_STRUCT__entry(
0240         __field(int, reg)
0241         __field(int, addr)
0242         __field(int, msg_len)
0243         __field(int, buf_len)
0244         __array(u8, buf, 32)
0245         __array(u8, addr_str, 10)
0246     ),
0247     TP_fast_assign(
0248         __entry->reg = reg;
0249         __entry->addr = addr;
0250         __entry->msg_len = len;
0251         __entry->buf_len = min_t(int, sizeof(__entry->buf), __entry->msg_len);
0252         memcpy(__entry->buf, io_buf, __entry->buf_len);
0253         if (addr >= 0)
0254             snprintf(__entry->addr_str, 10, "/%08x", addr);
0255         else
0256             __entry->addr_str[0] = 0;
0257     ),
0258     TP_printk("%s%s: %s%s (%d bytes)",
0259         __print_symbolic(__entry->reg, wfx_reg_list),
0260         __entry->addr_str,
0261         __print_hex(__entry->buf, __entry->buf_len),
0262         __entry->msg_len > sizeof(__entry->buf) ? " ..." : "",
0263         __entry->msg_len
0264     )
0265 );
0266 DEFINE_EVENT(io_data, io_write,
0267     TP_PROTO(int reg, int addr, const void *io_buf, size_t len),
0268     TP_ARGS(reg, addr, io_buf, len));
0269 #define _trace_io_ind_write(reg, addr, io_buf, len)\
0270     trace_io_write(reg, addr, io_buf, len)
0271 #define _trace_io_write(reg, io_buf, len) trace_io_write(reg, -1, io_buf, len)
0272 DEFINE_EVENT(io_data, io_read,
0273     TP_PROTO(int reg, int addr, const void *io_buf, size_t len),
0274     TP_ARGS(reg, addr, io_buf, len));
0275 #define _trace_io_ind_read(reg, addr, io_buf, len)\
0276     trace_io_read(reg, addr, io_buf, len)
0277 #define _trace_io_read(reg, io_buf, len) trace_io_read(reg, -1, io_buf, len)
0278 
0279 DECLARE_EVENT_CLASS(io_data32,
0280     TP_PROTO(int reg, int addr, u32 val),
0281     TP_ARGS(reg, addr, val),
0282     TP_STRUCT__entry(
0283         __field(int, reg)
0284         __field(int, addr)
0285         __field(int, val)
0286         __array(u8, addr_str, 10)
0287     ),
0288     TP_fast_assign(
0289         __entry->reg = reg;
0290         __entry->addr = addr;
0291         __entry->val = val;
0292         if (addr >= 0)
0293             snprintf(__entry->addr_str, 10, "/%08x", addr);
0294         else
0295             __entry->addr_str[0] = 0;
0296     ),
0297     TP_printk("%s%s: %08x",
0298         __print_symbolic(__entry->reg, wfx_reg_list),
0299         __entry->addr_str,
0300         __entry->val
0301     )
0302 );
0303 DEFINE_EVENT(io_data32, io_write32,
0304     TP_PROTO(int reg, int addr, u32 val),
0305     TP_ARGS(reg, addr, val));
0306 #define _trace_io_ind_write32(reg, addr, val) trace_io_write32(reg, addr, val)
0307 #define _trace_io_write32(reg, val) trace_io_write32(reg, -1, val)
0308 DEFINE_EVENT(io_data32, io_read32,
0309     TP_PROTO(int reg, int addr, u32 val),
0310     TP_ARGS(reg, addr, val));
0311 #define _trace_io_ind_read32(reg, addr, val) trace_io_read32(reg, addr, val)
0312 #define _trace_io_read32(reg, val) trace_io_read32(reg, -1, val)
0313 
0314 DECLARE_EVENT_CLASS(piggyback,
0315     TP_PROTO(u32 val, bool ignored),
0316     TP_ARGS(val, ignored),
0317     TP_STRUCT__entry(
0318         __field(int, val)
0319         __field(bool, ignored)
0320     ),
0321     TP_fast_assign(
0322         __entry->val = val;
0323         __entry->ignored = ignored;
0324     ),
0325     TP_printk("CONTROL: %08x%s",
0326         __entry->val,
0327         __entry->ignored ? " (ignored)" : ""
0328     )
0329 );
0330 DEFINE_EVENT(piggyback, piggyback,
0331     TP_PROTO(u32 val, bool ignored),
0332     TP_ARGS(val, ignored));
0333 #define _trace_piggyback(val, ignored) trace_piggyback(val, ignored)
0334 
0335 TRACE_EVENT(bh_stats,
0336     TP_PROTO(int ind, int req, int cnf, int busy, bool release),
0337     TP_ARGS(ind, req, cnf, busy, release),
0338     TP_STRUCT__entry(
0339         __field(int, ind)
0340         __field(int, req)
0341         __field(int, cnf)
0342         __field(int, busy)
0343         __field(bool, release)
0344     ),
0345     TP_fast_assign(
0346         __entry->ind = ind;
0347         __entry->req = req;
0348         __entry->cnf = cnf;
0349         __entry->busy = busy;
0350         __entry->release = release;
0351     ),
0352     TP_printk("IND/REQ/CNF:%3d/%3d/%3d, REQ in progress:%3d, WUP: %s",
0353         __entry->ind,
0354         __entry->req,
0355         __entry->cnf,
0356         __entry->busy,
0357         __entry->release ? "release" : "keep"
0358     )
0359 );
0360 #define _trace_bh_stats(ind, req, cnf, busy, release)\
0361     trace_bh_stats(ind, req, cnf, busy, release)
0362 
0363 TRACE_EVENT(tx_stats,
0364     TP_PROTO(const struct wfx_hif_cnf_tx *tx_cnf, const struct sk_buff *skb,
0365          int delay),
0366     TP_ARGS(tx_cnf, skb, delay),
0367     TP_STRUCT__entry(
0368         __field(int, pkt_id)
0369         __field(int, delay_media)
0370         __field(int, delay_queue)
0371         __field(int, delay_fw)
0372         __field(int, ack_failures)
0373         __field(int, flags)
0374         __array(int, rate, 4)
0375         __array(int, tx_count, 4)
0376     ),
0377     TP_fast_assign(
0378         /* Keep sync with wfx_rates definition in main.c */
0379         static const int hw_rate[] = { 0, 1, 2, 3, 6, 7, 8, 9, 10, 11, 12, 13 };
0380         const struct ieee80211_tx_info *tx_info =
0381             (const struct ieee80211_tx_info *)skb->cb;
0382         const struct ieee80211_tx_rate *rates = tx_info->driver_rates;
0383         int i;
0384 
0385         __entry->pkt_id = tx_cnf->packet_id;
0386         __entry->delay_media = le32_to_cpu(tx_cnf->media_delay);
0387         __entry->delay_queue = le32_to_cpu(tx_cnf->tx_queue_delay);
0388         __entry->delay_fw = delay;
0389         __entry->ack_failures = tx_cnf->ack_failures;
0390         if (!tx_cnf->status || __entry->ack_failures)
0391             __entry->ack_failures += 1;
0392 
0393         for (i = 0; i < IEEE80211_NUM_ACS; i++) {
0394             if (rates[0].flags & IEEE80211_TX_RC_MCS)
0395                 __entry->rate[i] = rates[i].idx;
0396             else
0397                 __entry->rate[i] = hw_rate[rates[i].idx];
0398             __entry->tx_count[i] = rates[i].count;
0399         }
0400         __entry->flags = 0;
0401         if (rates[0].flags & IEEE80211_TX_RC_MCS)
0402             __entry->flags |= 0x01;
0403         if (rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
0404             __entry->flags |= 0x02;
0405         if (rates[0].flags & IEEE80211_TX_RC_GREEN_FIELD)
0406             __entry->flags |= 0x04;
0407         if (rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
0408             __entry->flags |= 0x08;
0409         if (tx_info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM)
0410             __entry->flags |= 0x10;
0411         if (tx_cnf->status)
0412             __entry->flags |= 0x20;
0413         if (tx_cnf->status == HIF_STATUS_TX_FAIL_REQUEUE)
0414             __entry->flags |= 0x40;
0415     ),
0416     TP_printk("packet ID: %08x, rate policy: %s %d|%d %d|%d %d|%d %d|%d -> %d attempt, Delays media/queue/total: %4dus/%4dus/%4dus",
0417         __entry->pkt_id,
0418         __print_flags(__entry->flags, NULL,
0419             { 0x01, "M" }, { 0x02, "S" }, { 0x04, "G" }, { 0x08, "R" },
0420             { 0x10, "D" }, { 0x20, "F" }, { 0x40, "Q" }),
0421         __entry->rate[0],
0422         __entry->tx_count[0],
0423         __entry->rate[1],
0424         __entry->tx_count[1],
0425         __entry->rate[2],
0426         __entry->tx_count[2],
0427         __entry->rate[3],
0428         __entry->tx_count[3],
0429         __entry->ack_failures,
0430         __entry->delay_media,
0431         __entry->delay_queue,
0432         __entry->delay_fw
0433     )
0434 );
0435 #define _trace_tx_stats(tx_cnf, skb, delay) trace_tx_stats(tx_cnf, skb, delay)
0436 
0437 TRACE_EVENT(queues_stats,
0438     TP_PROTO(struct wfx_dev *wdev, const struct wfx_queue *elected_queue),
0439     TP_ARGS(wdev, elected_queue),
0440     TP_STRUCT__entry(
0441         __field(int, vif_id)
0442         __field(int, queue_id)
0443         __array(int, hw, IEEE80211_NUM_ACS * 2)
0444         __array(int, drv, IEEE80211_NUM_ACS * 2)
0445         __array(int, cab, IEEE80211_NUM_ACS * 2)
0446     ),
0447     TP_fast_assign(
0448         const struct wfx_queue *queue;
0449         struct wfx_vif *wvif;
0450         int i, j;
0451 
0452         for (j = 0; j < IEEE80211_NUM_ACS * 2; j++) {
0453             __entry->hw[j] = -1;
0454             __entry->drv[j] = -1;
0455             __entry->cab[j] = -1;
0456         }
0457         __entry->vif_id = -1;
0458         __entry->queue_id = -1;
0459         wvif = NULL;
0460         while ((wvif = wvif_iterate(wdev, wvif)) != NULL) {
0461             for (i = 0; i < IEEE80211_NUM_ACS; i++) {
0462                 j = wvif->id * IEEE80211_NUM_ACS + i;
0463                 WARN_ON(j >= IEEE80211_NUM_ACS * 2);
0464                 queue = &wvif->tx_queue[i];
0465                 __entry->hw[j] = atomic_read(&queue->pending_frames);
0466                 __entry->drv[j] = skb_queue_len(&queue->normal);
0467                 __entry->cab[j] = skb_queue_len(&queue->cab);
0468                 if (queue == elected_queue) {
0469                     __entry->vif_id = wvif->id;
0470                     __entry->queue_id = i;
0471                 }
0472             }
0473         }
0474     ),
0475     TP_printk("got skb from %d/%d, pend. hw/norm/cab: [ %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d ] [ %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d ]",
0476         __entry->vif_id, __entry->queue_id,
0477         __entry->hw[0], __entry->drv[0], __entry->cab[0],
0478         __entry->hw[1], __entry->drv[1], __entry->cab[1],
0479         __entry->hw[2], __entry->drv[2], __entry->cab[2],
0480         __entry->hw[3], __entry->drv[3], __entry->cab[3],
0481         __entry->hw[4], __entry->drv[4], __entry->cab[4],
0482         __entry->hw[5], __entry->drv[5], __entry->cab[5],
0483         __entry->hw[6], __entry->drv[6], __entry->cab[6],
0484         __entry->hw[7], __entry->drv[7], __entry->cab[7]
0485     )
0486 );
0487 
0488 #endif
0489 
0490 /* This part must be outside protection */
0491 #undef TRACE_INCLUDE_PATH
0492 #define TRACE_INCLUDE_PATH .
0493 #undef TRACE_INCLUDE_FILE
0494 #define TRACE_INCLUDE_FILE traces
0495 
0496 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!