samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
cf4286b7307bb34a9b91eea974d26cdb9461bfbc
android_kernel_samsung_sm86…/qdf/inc/qdf_trace.h
Manjunathappa Prakash cf4286b730 qcacmn: DPtrace: Do not log to memory during high throughput 
During high TPUT scenario logging of DPT trace is not useful,
require more MIPS. Disable datapacket DPtrace logging during
TPUT runs, but contiue to log special packets like ARP/DHCP/ICMP etc..

Change-Id: I70c9368de4cb2423901449b267452a34d652213d
CRs-Fixed: 2255756
2018-07-02 12:23:38 -07:00

1237 lines
36 KiB
C
Raw Blame History

/*
* Copyright (c) 2014-2018 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#if !defined(__QDF_TRACE_H)
#define __QDF_TRACE_H
/**
* DOC: qdf_trace
* QCA driver framework trace APIs
* Trace, logging, and debugging definitions and APIs
*/
/* Include Files */
#include <qdf_types.h> /* For QDF_MODULE_ID... */
#include <stdarg.h> /* For va_list... */
#include <qdf_status.h>
#include <qdf_nbuf.h>
#include <i_qdf_types.h>
#include <qdf_debugfs.h>
/* Type declarations */
#define FL(x) "%s: %d: " x, __func__, __LINE__
#define QDF_TRACE_BUFFER_SIZE (512)
#ifdef CONFIG_MCL
#define QDF_DEFAULT_TRACE_LEVEL \
((1 << QDF_TRACE_LEVEL_FATAL) | (1 << QDF_TRACE_LEVEL_ERROR))
#else
#define QDF_DEFAULT_TRACE_LEVEL (1 << QDF_TRACE_LEVEL_INFO)
#endif
#define QDF_CATEGORY_INFO_U16(val) (((val >> 16) & 0x0000FFFF))
#define QDF_TRACE_LEVEL_INFO_L16(val) (val & 0x0000FFFF)
typedef int (qdf_abstract_print)(void *priv, const char *fmt, ...);
/*
* Log levels
*/
#define QDF_DEBUG_FUNCTRACE 0x01
#define QDF_DEBUG_LEVEL0 0x02
#define QDF_DEBUG_LEVEL1 0x04
#define QDF_DEBUG_LEVEL2 0x08
#define QDF_DEBUG_LEVEL3 0x10
#define QDF_DEBUG_ERROR 0x20
#define QDF_DEBUG_CFG 0x40
/* DP Trace Implementation */
#ifdef CONFIG_DP_TRACE
#define DPTRACE(p) p
#define DPTRACE_PRINT(args...) QDF_TRACE_DEBUG(QDF_MODULE_ID_QDF, args)
#else
#define DPTRACE(p)
#define DPTRACE_PRINT(args...)
#endif
/* By default Data Path module will have all log levels enabled, except debug
* log level. Debug level will be left up to the framework or user space modules
* to be enabled when issue is detected
*/
#define QDF_DATA_PATH_TRACE_LEVEL \
((1 << QDF_TRACE_LEVEL_FATAL) | (1 << QDF_TRACE_LEVEL_ERROR) | \
(1 << QDF_TRACE_LEVEL_WARN) | (1 << QDF_TRACE_LEVEL_INFO) | \
(1 << QDF_TRACE_LEVEL_INFO_HIGH) | (1 << QDF_TRACE_LEVEL_INFO_MED) | \
(1 << QDF_TRACE_LEVEL_INFO_LOW))
/* Preprocessor definitions and constants */
#define ASSERT_BUFFER_SIZE (512)
#ifndef MAX_QDF_TRACE_RECORDS
#define MAX_QDF_TRACE_RECORDS 4000
#endif
#define QDF_TRACE_DEFAULT_PDEV_ID 0xff
#define INVALID_QDF_TRACE_ADDR 0xffffffff
#define DEFAULT_QDF_TRACE_DUMP_COUNT 0
/*
* first parameter to iwpriv command - dump_dp_trace
* iwpriv wlan0 dump_dp_trace 0 0 -> dump full buffer
* iwpriv wlan0 dump_dp_trace 1 0 -> enable live view mode
* iwpriv wlan0 dump_dp_trace 2 0 -> clear dp trace buffer
* iwpriv wlan0 dump_dp_trace 3 0 -> disable live view mode
*/
#define DUMP_DP_TRACE 0
#define ENABLE_DP_TRACE_LIVE_MODE 1
#define CLEAR_DP_TRACE_BUFFER 2
#define DISABLE_DP_TRACE_LIVE_MODE 3
#ifdef TRACE_RECORD
#define MTRACE(p) p
#else
#define MTRACE(p) do { } while (0)
#endif
#define NO_SESSION 0xFF
/**
* typedef struct qdf_trace_record_s - keep trace record
* @qtime: qtimer ticks
* @time: user timestamp
* @module: module name
* @code: hold record of code
* @session: hold record of session
* @data: hold data
* @pid: hold pid of the process
*/
typedef struct qdf_trace_record_s {
uint64_t qtime;
char time[18];
uint8_t module;
uint8_t code;
uint16_t session;
uint32_t data;
uint32_t pid;
} qdf_trace_record_t, *tp_qdf_trace_record;
/**
* typedef struct s_qdf_trace_data - MTRACE logs are stored in ring buffer
* @head: position of first record
* @tail: position of last record
* @num: count of total record
* @num_since_last_dump: count from last dump
* @enable: config for controlling the trace
* @dump_count: Dump after number of records reach this number
*/
typedef struct s_qdf_trace_data {
uint32_t head;
uint32_t tail;
uint32_t num;
uint16_t num_since_last_dump;
uint8_t enable;
uint16_t dump_count;
} t_qdf_trace_data;
#define CASE_RETURN_STRING(str) case ((str)): return (uint8_t *)(# str);
#ifndef MAX_QDF_DP_TRACE_RECORDS
#define MAX_QDF_DP_TRACE_RECORDS 2000
#endif
#define QDF_DP_TRACE_RECORD_SIZE 40
#define INVALID_QDF_DP_TRACE_ADDR 0xffffffff
#define QDF_DP_TRACE_VERBOSITY_HIGH 4
#define QDF_DP_TRACE_VERBOSITY_MEDIUM 3
#define QDF_DP_TRACE_VERBOSITY_LOW 2
#define QDF_DP_TRACE_VERBOSITY_ULTRA_LOW 1
#define QDF_DP_TRACE_VERBOSITY_BASE 0
/**
* enum QDF_DP_TRACE_ID - Generic ID to identify various events in data path
* @QDF_DP_TRACE_INVALID - invalid
* @QDF_DP_TRACE_DROP_PACKET_RECORD - record drop packet
* @QDF_DP_TRACE_EAPOL_PACKET_RECORD - record EAPOL packet
* @QDF_DP_TRACE_DHCP_PACKET_RECORD - record DHCP packet
* @QDF_DP_TRACE_ARP_PACKET_RECORD - record ARP packet
* @QDF_DP_TRACE_MGMT_PACKET_RECORD - record MGMT pacekt
* @QDF_DP_TRACE_EVENT_RECORD - record events
* @QDF_DP_TRACE_BASE_VERBOSITY - below this are part of base verbosity
* @QDF_DP_TRACE_ICMP_PACKET_RECORD - record ICMP packet
* @QDF_DP_TRACE_ICMPv6_PACKET_RECORD - record ICMPv6 packet
* @QDF_DP_TRACE_HDD_TX_TIMEOUT - HDD tx timeout
* @QDF_DP_TRACE_HDD_SOFTAP_TX_TIMEOUT- SOFTAP HDD tx timeout
* @QDF_DP_TRACE_ULTRA_LOW_VERBOSITY - Below this is not logged for >4PPS
* @QDF_DP_TRACE_TX_PACKET_RECORD - record 32 bytes of tx pkt at any layer
* @QDF_DP_TRACE_RX_PACKET_RECORD - record 32 bytes of rx pkt at any layer
* @QDF_DP_TRACE_HDD_TX_PACKET_RECORD - record 32 bytes of tx pkt at HDD
* @QDF_DP_TRACE_HDD_RX_PACKET_RECORD - record 32 bytes of rx pkt at HDD
* @QDF_DP_TRACE_FREE_PACKET_PTR_RECORD - tx completion ptr record
* @QDF_DP_TRACE_LOW_VERBOSITY - below this are part of low verbosity
* @QDF_DP_TRACE_HDD_TX_PACKET_PTR_RECORD - HDD layer ptr record
* @QDF_DP_TRACE_LI_DP_TX_PACKET_PTR_RECORD - Lithium DP layer ptr record
* @QDF_DP_TRACE_RX_HDD_PACKET_PTR_RECORD - HDD RX record
* @QDF_DP_TRACE_CE_PACKET_PTR_RECORD - CE layer ptr record
* @QDF_DP_TRACE_CE_FAST_PACKET_PTR_RECORD- CE fastpath ptr record
* @QDF_DP_TRACE_CE_FAST_PACKET_ERR_RECORD- CE fastpath error record
* @QDF_DP_TRACE_RX_HTT_PACKET_PTR_RECORD - HTT RX record
* @QDF_DP_TRACE_RX_OFFLOAD_HTT_PACKET_PTR_RECORD- HTT RX offload record
* @QDF_DP_TRACE_RX_LI_DP_PACKET_PTR_RECORD - Lithium DP RX record
* @QDF_DP_TRACE_MED_VERBOSITY - below this are part of med verbosity
* @QDF_DP_TRACE_TXRX_QUEUE_PACKET_PTR_RECORD -tx queue ptr record
* @QDF_DP_TRACE_TXRX_PACKET_PTR_RECORD - txrx packet ptr record
* @QDF_DP_TRACE_TXRX_FAST_PACKET_PTR_RECORD - txrx fast path record
* @QDF_DP_TRACE_HTT_PACKET_PTR_RECORD - htt packet ptr record
* @QDF_DP_TRACE_HTC_PACKET_PTR_RECORD - htc packet ptr record
* @QDF_DP_TRACE_HIF_PACKET_PTR_RECORD - hif packet ptr record
* @QDF_DP_TRACE_RX_TXRX_PACKET_PTR_RECORD - txrx packet ptr record
* @QDF_DP_TRACE_LI_DP_TX_PACKET_RECORD - record 32 bytes of tx pkt at LI_DP
* @QDF_DP_TRACE_LI_DP_RX_PACKET_RECORD - record 32 bytes of rx pkt at LI_DP
* @QDF_DP_TRACE_LI_DP_NULL_RX_PACKET_RECORD
* - record 32 bytes of rx null_queue pkt at LI_DP
* @QDF_DP_TRACE_HIGH_VERBOSITY - below this are part of high verbosity
*/
enum QDF_DP_TRACE_ID {
QDF_DP_TRACE_INVALID,
QDF_DP_TRACE_DROP_PACKET_RECORD,
QDF_DP_TRACE_EAPOL_PACKET_RECORD,
QDF_DP_TRACE_DHCP_PACKET_RECORD,
QDF_DP_TRACE_ARP_PACKET_RECORD,
QDF_DP_TRACE_MGMT_PACKET_RECORD,
QDF_DP_TRACE_EVENT_RECORD,
QDF_DP_TRACE_BASE_VERBOSITY,
QDF_DP_TRACE_ICMP_PACKET_RECORD,
QDF_DP_TRACE_ICMPv6_PACKET_RECORD,
QDF_DP_TRACE_HDD_TX_TIMEOUT,
QDF_DP_TRACE_HDD_SOFTAP_TX_TIMEOUT,
QDF_DP_TRACE_ULTRA_LOW_VERBOSITY,
QDF_DP_TRACE_TX_PACKET_RECORD,
QDF_DP_TRACE_RX_PACKET_RECORD,
QDF_DP_TRACE_HDD_TX_PACKET_RECORD,
QDF_DP_TRACE_HDD_RX_PACKET_RECORD,
QDF_DP_TRACE_FREE_PACKET_PTR_RECORD,
QDF_DP_TRACE_LOW_VERBOSITY,
QDF_DP_TRACE_HDD_TX_PACKET_PTR_RECORD,
QDF_DP_TRACE_LI_DP_TX_PACKET_PTR_RECORD,
QDF_DP_TRACE_RX_HDD_PACKET_PTR_RECORD,
QDF_DP_TRACE_CE_PACKET_PTR_RECORD,
QDF_DP_TRACE_CE_FAST_PACKET_PTR_RECORD,
QDF_DP_TRACE_CE_FAST_PACKET_ERR_RECORD,
QDF_DP_TRACE_RX_HTT_PACKET_PTR_RECORD,
QDF_DP_TRACE_RX_OFFLOAD_HTT_PACKET_PTR_RECORD,
QDF_DP_TRACE_RX_LI_DP_PACKET_PTR_RECORD,
QDF_DP_TRACE_MED_VERBOSITY,
QDF_DP_TRACE_TXRX_QUEUE_PACKET_PTR_RECORD,
QDF_DP_TRACE_TXRX_PACKET_PTR_RECORD,
QDF_DP_TRACE_TXRX_FAST_PACKET_PTR_RECORD,
QDF_DP_TRACE_HTT_PACKET_PTR_RECORD,
QDF_DP_TRACE_HTC_PACKET_PTR_RECORD,
QDF_DP_TRACE_HIF_PACKET_PTR_RECORD,
QDF_DP_TRACE_RX_TXRX_PACKET_PTR_RECORD,
QDF_DP_TRACE_LI_DP_TX_PACKET_RECORD,
QDF_DP_TRACE_LI_DP_RX_PACKET_RECORD,
QDF_DP_TRACE_LI_DP_NULL_RX_PACKET_RECORD,
QDF_DP_TRACE_HIGH_VERBOSITY,
QDF_DP_TRACE_MAX
};
/**
* qdf_proto_dir - direction
* @QDF_TX: TX direction
* @QDF_RX: RX direction
* @QDF_NA: not applicable
*/
enum qdf_proto_dir {
QDF_TX,
QDF_RX,
QDF_NA
};
/**
* struct qdf_dp_trace_ptr_buf - pointer record buffer
* @cookie: cookie value
* @msdu_id: msdu_id
* @status: completion status
*/
struct qdf_dp_trace_ptr_buf {
uint64_t cookie;
uint16_t msdu_id;
uint16_t status;
};
/**
* struct qdf_dp_trace_proto_buf - proto packet buffer
* @sa: source address
* @da: destination address
* @vdev_id : vdev id
* @type: packet type
* @subtype: packet subtype
* @dir: direction
*/
struct qdf_dp_trace_proto_buf {
struct qdf_mac_addr sa;
struct qdf_mac_addr da;
uint8_t vdev_id;
uint8_t type;
uint8_t subtype;
uint8_t dir;
};
/**
* struct qdf_dp_trace_mgmt_buf - mgmt packet buffer
* @vdev_id : vdev id
* @type: packet type
* @subtype: packet subtype
*/
struct qdf_dp_trace_mgmt_buf {
uint8_t vdev_id;
uint8_t type;
uint8_t subtype;
};
/**
* struct qdf_dp_trace_event_buf - event buffer
* @vdev_id : vdev id
* @type: packet type
* @subtype: packet subtype
*/
struct qdf_dp_trace_event_buf {
uint8_t vdev_id;
uint8_t type;
uint8_t subtype;
};
/**
* struct qdf_dp_trace_data_buf - nbuf data buffer
* @msdu_id : msdu id
*/
struct qdf_dp_trace_data_buf {
uint16_t msdu_id;
};
/**
* struct qdf_dp_trace_record_s - Describes a record in DP trace
* @time: time when it got stored
* @code: Describes the particular event
* @data: buffer to store data
* @size: Length of the valid data stored in this record
* @pid : process id which stored the data in this record
*/
struct qdf_dp_trace_record_s {
uint64_t time;
uint8_t code;
uint8_t data[QDF_DP_TRACE_RECORD_SIZE];
uint8_t size;
uint32_t pid;
uint8_t pdev_id;
};
/**
* struct qdf_dp_trace_data - Parameters to configure/control DP trace
* @head: Position of first record
* @tail: Position of last record
* @num: Current index
* @proto_bitmap: defines which protocol to be traced
* @no_of_record: defines every nth packet to be traced
* @verbosity : defines verbosity level
* @ini_conf_verbosity: Configured verbosity from INI
* @enable: enable/disable DP trace
* @count: current packet number
* @live_mode_config: configuration as received during initialization
* @live_mode: current live mode, enabled or disabled, can be throttled based
* on throughput
* @force_live_mode: flag to enable live mode all the time for all packets.
* This can be set/unset from userspace and overrides other
* live mode flags.
* @dynamic_verbosity_modify: Dynamic user configured verbosity overrides all
* @print_pkt_cnt: count of number of packets printed in live mode
* @high_tput_thresh: thresh beyond which live mode is turned off
* @thresh_time_limit: max time, in terms of BW timer intervals to wait,
* for determining if high_tput_thresh has been crossed. ~1s
* @arp_req: stats for arp reqs
* @arp_resp: stats for arp resps
* @icmp_req: stats for icmp reqs
* @icmp_resp: stats for icmp resps
* @dhcp_disc: stats for dhcp discover msgs
* @dhcp_req: stats for dhcp req msgs
* @dhcp_off: stats for dhcp offer msgs
* @dhcp_ack: stats for dhcp ack msgs
* @dhcp_nack: stats for dhcp nack msgs
* @dhcp_others: stats for other dhcp pkts types
* @eapol_m1: stats for eapol m1
* @eapol_m2: stats for eapol m2
* @eapol_m3: stats for eapol m3
* @eapol_m4: stats for eapol m4
* @eapol_others: stats for other eapol pkt types
* @icmpv6_req: stats for icmpv6 reqs
* @icmpv6_resp: stats for icmpv6 resps
* @icmpv6_ns: stats for icmpv6 nss
* @icmpv6_na: stats for icmpv6 nas
* @icmpv6_rs: stats for icmpv6 rss
* @icmpv6_ra: stats for icmpv6 ras
*/
struct s_qdf_dp_trace_data {
uint32_t head;
uint32_t tail;
uint32_t num;
uint8_t proto_bitmap;
uint8_t no_of_record;
uint8_t verbosity;
uint8_t ini_conf_verbosity;
bool enable;
bool live_mode_config;
bool live_mode;
uint32_t curr_pos;
uint32_t saved_tail;
bool force_live_mode;
bool dynamic_verbosity_modify;
uint8_t print_pkt_cnt;
uint8_t high_tput_thresh;
uint16_t thresh_time_limit;
/* Stats */
uint32_t tx_count;
uint32_t rx_count;
u16 arp_req;
u16 arp_resp;
u16 dhcp_disc;
u16 dhcp_req;
u16 dhcp_off;
u16 dhcp_ack;
u16 dhcp_nack;
u16 dhcp_others;
u16 eapol_m1;
u16 eapol_m2;
u16 eapol_m3;
u16 eapol_m4;
u16 eapol_others;
u16 icmp_req;
u16 icmp_resp;
u16 icmpv6_req;
u16 icmpv6_resp;
u16 icmpv6_ns;
u16 icmpv6_na;
u16 icmpv6_rs;
u16 icmpv6_ra;
};
/**
* struct qdf_dpt_debugfs_state - state to control read to debugfs file
* @QDF_DPT_DEBUGFS_STATE_SHOW_STATE_INVALID: invalid state
* @QDF_DPT_DEBUGFS_STATE_SHOW_STATE_INIT: initial state
* @QDF_DPT_DEBUGFS_STATE_SHOW_IN_PROGRESS: read is in progress
* @QDF_DPT_DEBUGFS_STATE_SHOW_COMPLETE: read complete
*/
enum qdf_dpt_debugfs_state {
QDF_DPT_DEBUGFS_STATE_SHOW_STATE_INVALID,
QDF_DPT_DEBUGFS_STATE_SHOW_STATE_INIT,
QDF_DPT_DEBUGFS_STATE_SHOW_IN_PROGRESS,
QDF_DPT_DEBUGFS_STATE_SHOW_COMPLETE,
};
/* Function declarations and documenation */
/**
* qdf_trace_set_level() - Set the trace level for a particular module
* @level : trace level
*
* Trace level is a member of the QDF_TRACE_LEVEL enumeration indicating
* the severity of the condition causing the trace message to be issued.
* More severe conditions are more likely to be logged.
*
* This is an external API that allows trace levels to be set for each module.
*
* Return: nothing
*/
void qdf_trace_set_level(QDF_MODULE_ID module, QDF_TRACE_LEVEL level);
/**
* qdf_trace_get_level() - get the trace level
* @level : trace level
*
* This is an external API that returns a bool value to signify if a
* particular trace level is set for the specified module.
* A member of the QDF_TRACE_LEVEL enumeration indicating the severity
* of the condition causing the trace message to be issued.
*
* Note that individual trace levels are the only valid values
* for this API. QDF_TRACE_LEVEL_NONE and QDF_TRACE_LEVEL_ALL
* are not valid input and will return false
*
* Return:
* false - the specified trace level for the specified module is OFF
* true - the specified trace level for the specified module is ON
*/
bool qdf_trace_get_level(QDF_MODULE_ID module, QDF_TRACE_LEVEL level);
typedef void (*tp_qdf_trace_cb)(void *p_mac, tp_qdf_trace_record, uint16_t);
typedef void (*tp_qdf_state_info_cb) (char **buf, uint16_t *size);
#ifdef WLAN_FEATURE_MEMDUMP_ENABLE
void qdf_register_debugcb_init(void);
void qdf_register_debug_callback(QDF_MODULE_ID module_id,
tp_qdf_state_info_cb qdf_state_infocb);
QDF_STATUS qdf_state_info_dump_all(char *buf, uint16_t size,
uint16_t *driver_dump_size);
#else /* WLAN_FEATURE_MEMDUMP_ENABLE */
static inline void qdf_register_debugcb_init(void)
{
}
#endif /* WLAN_FEATURE_MEMDUMP_ENABLE */
#ifdef TRACE_RECORD
void qdf_trace_register(QDF_MODULE_ID, tp_qdf_trace_cb);
void qdf_trace_init(void);
void qdf_trace(uint8_t module, uint8_t code, uint16_t session, uint32_t data);
void qdf_trace_enable(uint32_t, uint8_t enable);
void qdf_trace_dump_all(void *, uint8_t, uint8_t, uint32_t, uint32_t);
QDF_STATUS qdf_trace_spin_lock_init(void);
#else
#ifdef CONFIG_MCL
static inline
void qdf_trace_init(void)
{
}
static inline
void qdf_trace_enable(uint32_t bitmask_of_module_id, uint8_t enable)
{
}
static inline
void qdf_trace(uint8_t module, uint8_t code, uint16_t session, uint32_t data)
{
}
static inline
void qdf_trace_dump_all(void *p_mac, uint8_t code, uint8_t session,
uint32_t count, uint32_t bitmask_of_module)
{
}
static inline
QDF_STATUS qdf_trace_spin_lock_init(void)
{
return QDF_STATUS_E_INVAL;
}
#endif
#endif
#ifdef CONFIG_DP_TRACE
void qdf_dp_set_proto_bitmap(uint32_t val);
void qdf_dp_trace_set_verbosity(uint32_t val);
void qdf_dp_set_no_of_record(uint32_t val);
#define QDF_DP_TRACE_RECORD_INFO_LIVE (0x1)
#define QDF_DP_TRACE_RECORD_INFO_THROTTLED (0x1 << 1)
bool qdf_dp_trace_log_pkt(uint8_t session_id, struct sk_buff *skb,
enum qdf_proto_dir dir, uint8_t pdev_id);
void qdf_dp_trace_init(bool live_mode_config, uint8_t thresh,
uint16_t time_limit, uint8_t verbosity,
uint8_t proto_bitmap);
void qdf_dp_trace_spin_lock_init(void);
void qdf_dp_trace_set_value(uint8_t proto_bitmap, uint8_t no_of_records,
uint8_t verbosity);
void qdf_dp_trace_set_track(qdf_nbuf_t nbuf, enum qdf_proto_dir dir);
void qdf_dp_trace(qdf_nbuf_t nbuf, enum QDF_DP_TRACE_ID code, uint8_t pdev_id,
uint8_t *data, uint8_t size, enum qdf_proto_dir dir);
void qdf_dp_trace_dump_all(uint32_t count, uint8_t pdev_id);
/**
* qdf_dpt_get_curr_pos_debugfs() - get curr position to start read
* @file: debugfs file to read
* @state: state to control read to debugfs file
*
* Return: curr pos
*/
uint32_t qdf_dpt_get_curr_pos_debugfs(qdf_debugfs_file_t file,
enum qdf_dpt_debugfs_state state);
/**
* qdf_dpt_dump_stats_debugfs() - dump DP Trace stats to debugfs file
* @file: debugfs file to read
* @curr_pos: curr position to start read
*
* Return: QDF_STATUS
*/
QDF_STATUS qdf_dpt_dump_stats_debugfs(qdf_debugfs_file_t file,
uint32_t curr_pos);
/**
* qdf_dpt_set_value_debugfs() - dump DP Trace stats to debugfs file
* @file: debugfs file to read
* @curr_pos: curr position to start read
*
* Return: none
*/
void qdf_dpt_set_value_debugfs(uint8_t proto_bitmap, uint8_t no_of_record,
uint8_t verbosity);
/**
* qdf_dp_trace_dump_stats() - dump DP Trace stats
*
* Return: none
*/
void qdf_dp_trace_dump_stats(void);
typedef void (*tp_qdf_dp_trace_cb)(struct qdf_dp_trace_record_s*,
uint16_t, uint8_t, uint8_t info);
/**
* qdf_dp_display_record() - Displays a record in DP trace
* @record: pointer to a record in DP trace
* @index: record index
* @pdev_id: pdev id for the mgmt pkt
* @info: info used to display pkt (live mode, throttling)
*
* Return: None
*/
void qdf_dp_display_record(struct qdf_dp_trace_record_s *record,
uint16_t index, uint8_t pdev_id,
uint8_t info);
/**
* qdf_dp_display_ptr_record() - display record
* @record: dptrace record
* @rec_index: index
* @pdev_id: pdev id for the mgmt pkt
* @info: info used to display pkt (live mode, throttling)
*
* Return: none
*/
void qdf_dp_display_ptr_record(struct qdf_dp_trace_record_s *record,
uint16_t rec_index, uint8_t pdev_id,
uint8_t info);
/**
* qdf_dp_display_proto_pkt() - display proto packet
* @record: dptrace record
* @index: index
* @pdev_id: pdev id for the mgmt pkt
* @info: info used to display pkt (live mode, throttling)
*
* Return: none
*/
void qdf_dp_display_proto_pkt(struct qdf_dp_trace_record_s *record,
uint16_t index, uint8_t pdev_id,
uint8_t info);
/**
* qdf_dp_display_data_pkt_record() - Displays a data packet in DP trace
* @record: pointer to a record in DP trace
* @rec_index: record index
* @pdev_id: pdev id
* @info: display info regarding record
*
* Return: None
*/
void
qdf_dp_display_data_pkt_record(struct qdf_dp_trace_record_s *record,
uint16_t rec_index, uint8_t pdev_id,
uint8_t info);
void qdf_dp_trace_ptr(qdf_nbuf_t nbuf, enum QDF_DP_TRACE_ID code,
uint8_t pdev_id, uint8_t *data, uint8_t size,
uint16_t msdu_id, uint16_t status);
void qdf_dp_trace_throttle_live_mode(bool high_bw_request);
/**
* qdf_dp_trace_tput_policy() - Change verbosity based on the TPUT
* @is_data_traffic: Is traffic more than low TPUT threashould
*
* Return: None
*/
void qdf_dp_trace_apply_tput_policy(bool is_data_traffic);
/**
* qdf_dp_trace_data_pkt() - trace data packet
* @nbuf: nbuf which needs to be traced
* @pdev_id: pdev_id
* @code: QDF_DP_TRACE_ID for the packet (TX or RX)
* @msdu_id: tx desc id for the nbuf (Only applies to TX packets)
* @dir: TX or RX packet direction
*
* Return: None
*/
void qdf_dp_trace_data_pkt(qdf_nbuf_t nbuf, uint8_t pdev_id,
enum QDF_DP_TRACE_ID code, uint16_t msdu_id,
enum qdf_proto_dir dir);
uint8_t qdf_dp_get_proto_bitmap(void);
uint8_t qdf_dp_get_verbosity(void);
uint8_t qdf_dp_get_no_of_record(void);
/**
* qdf_dp_trace_proto_pkt() - record proto packet
* @code: dptrace code
* @vdev_id: vdev id
* @sa: source mac address
* @da: destination mac address
* @type: proto type
* @subtype: proto subtype
* @dir: direction
* @pdev_id: pdev id
* @print: to print this proto pkt or not
*
* Return: none
*/
void
qdf_dp_trace_proto_pkt(enum QDF_DP_TRACE_ID code, uint8_t vdev_id,
uint8_t *sa, uint8_t *da, enum qdf_proto_type type,
enum qdf_proto_subtype subtype, enum qdf_proto_dir dir,
uint8_t pdev_id, bool print);
void qdf_dp_trace_disable_live_mode(void);
void qdf_dp_trace_enable_live_mode(void);
void qdf_dp_trace_clear_buffer(void);
/**
* qdf_dp_trace_mgmt_pkt() - record mgmt packet
* @code: dptrace code
* @vdev_id: vdev id
* @pdev_id: pdev_id
* @type: proto type
* @subtype: proto subtype
*
* Return: none
*/
void qdf_dp_trace_mgmt_pkt(enum QDF_DP_TRACE_ID code, uint8_t vdev_id,
uint8_t pdev_id, enum qdf_proto_type type,
enum qdf_proto_subtype subtype);
/**
* qdf_dp_display_mgmt_pkt() - display proto packet
* @record: dptrace record
* @index: index
* @pdev_id: pdev id for the mgmt pkt
* @info: info used to display pkt (live mode, throttling)
*
* Return: none
*/
void qdf_dp_display_mgmt_pkt(struct qdf_dp_trace_record_s *record,
uint16_t index, uint8_t pdev_id, uint8_t info);
/**
* qdf_dp_display_event_record() - display event records
* @record: dptrace record
* @index: index
* @pdev_id: pdev id for the mgmt pkt
* @info: info used to display pkt (live mode, throttling)
*
* Return: none
*/
void qdf_dp_display_event_record(struct qdf_dp_trace_record_s *record,
uint16_t index, uint8_t pdev_id, uint8_t info);
void qdf_dp_trace_record_event(enum QDF_DP_TRACE_ID code, uint8_t vdev_id,
uint8_t pdev_id, enum qdf_proto_type type,
enum qdf_proto_subtype subtype);
#else
static inline
bool qdf_dp_trace_log_pkt(uint8_t session_id, struct sk_buff *skb,
enum qdf_proto_dir dir, uint8_t pdev_id)
{
return false;
}
static inline
void qdf_dp_trace_init(bool live_mode_config, uint8_t thresh,
uint16_t time_limit, uint8_t verbosity,
uint8_t proto_bitmap)
{
}
static inline
void qdf_dp_trace_set_track(qdf_nbuf_t nbuf, enum qdf_proto_dir dir)
{
}
static inline
void qdf_dp_trace_set_value(uint8_t proto_bitmap, uint8_t no_of_records,
uint8_t verbosity)
{
}
static inline
void qdf_dp_trace_dump_all(uint32_t count, uint8_t pdev_id)
{
}
static inline
uint32_t qdf_dpt_get_curr_pos_debugfs(qdf_debugfs_file_t file,
enum qdf_dpt_debugfs_state state)
{
return 0;
}
static inline
QDF_STATUS qdf_dpt_dump_stats_debugfs(qdf_debugfs_file_t file,
uint32_t curr_pos)
{
return QDF_STATUS_SUCCESS;
}
static inline
void qdf_dpt_set_value_debugfs(uint8_t proto_bitmap, uint8_t no_of_record,
uint8_t verbosity)
{
}
static inline void qdf_dp_trace_dump_stats(void)
{
}
static inline
void qdf_dp_trace_disable_live_mode(void)
{
}
static inline
void qdf_dp_trace_enable_live_mode(void)
{
}
static inline
void qdf_dp_trace_throttle_live_mode(bool high_bw_request)
{
}
static inline
void qdf_dp_trace_clear_buffer(void)
{
}
static inline
void qdf_dp_trace_data_pkt(qdf_nbuf_t nbuf, uint8_t pdev_id,
enum QDF_DP_TRACE_ID code, uint16_t msdu_id,
enum qdf_proto_dir dir)
{
}
#endif
void qdf_trace_display(void);
void qdf_trace_set_value(QDF_MODULE_ID module, QDF_TRACE_LEVEL level,
uint8_t on);
void qdf_trace_set_module_trace_level(QDF_MODULE_ID module, uint32_t level);
void __printf(3, 4) qdf_snprintf(char *str_buffer, unsigned int size,
char *str_format, ...);
#define QDF_SNPRINTF qdf_snprintf
#ifdef TSOSEG_DEBUG
static inline void qdf_tso_seg_dbg_bug(char *msg)
{
qdf_print("%s", msg);
QDF_BUG(0);
};
/**
* qdf_tso_seg_dbg_init - initialize TSO segment debug structure
* @tsoseg : structure to initialize
*
* TSO segment dbg structures are attached to qdf_tso_seg_elem_t
* structures and are allocated only of TSOSEG_DEBUG is defined.
* When allocated, at the time of the tso_seg_pool initialization,
* which goes with tx_desc initialization (1:1), each structure holds
* a number of (currently 16) history entries, basically describing
* what operation has been performed on this particular tso_seg_elem.
* This history buffer is a circular buffer and the current index is
* held in an atomic variable called cur. It is incremented every
* operation. Each of these operations are added with the function
* qdf_tso_seg_dbg_record.
* For each segment, this initialization function MUST be called PRIOR
* TO any _dbg_record() function calls.
* On free, qdf_tso_seg_elem structure is cleared (using qdf_tso_seg_dbg_zero)
* which clears the tso_desc, BUT DOES NOT CLEAR THE HISTORY element.
*
* Return:
* None
*/
static inline
void qdf_tso_seg_dbg_init(struct qdf_tso_seg_elem_t *tsoseg)
{
tsoseg->dbg.txdesc = NULL;
qdf_atomic_init(&tsoseg->dbg.cur); /* history empty */
}
/**
* qdf_tso_seg_dbg_record - add a history entry to TSO debug structure
* @tsoseg : structure to initialize
* @id : operation ID (identifies the caller)
*
* Adds a history entry to the history circular buffer. Each entry
* contains an operation id (caller, as currently each ID is used only
* once in the source, so it directly identifies the src line that invoked
* the recording.
*
* qdf_tso_seg_dbg_record CAN ONLY BE CALLED AFTER the entry is initialized
* by qdf_tso_seg_dbg_init.
*
* The entry to be added is written at the location pointed by the atomic
* variable called cur. Cur is an ever increasing atomic variable. It is
* masked so that only the lower 4 bits are used (16 history entries).
*
* Return:
* int: the entry this record was recorded at
*/
static inline
int qdf_tso_seg_dbg_record(struct qdf_tso_seg_elem_t *tsoseg, short id)
{
int rc = -1;
unsigned int c;
qdf_assert(tsoseg);
if (id == TSOSEG_LOC_ALLOC) {
c = qdf_atomic_read(&tsoseg->dbg.cur);
/* dont crash on the very first alloc on the segment */
c &= 0x0f;
/* allow only INIT and FREE ops before ALLOC */
if (tsoseg->dbg.h[c].id >= id)
qdf_tso_seg_dbg_bug("Rogue TSO seg alloc");
}
c = qdf_atomic_inc_return(&tsoseg->dbg.cur);
c &= 0x0f;
tsoseg->dbg.h[c].ts = qdf_get_log_timestamp();
tsoseg->dbg.h[c].id = id;
rc = c;
return rc;
};
static inline void
qdf_tso_seg_dbg_setowner(struct qdf_tso_seg_elem_t *tsoseg, void *owner)
{
if (tsoseg)
tsoseg->dbg.txdesc = owner;
};
static inline void
qdf_tso_seg_dbg_zero(struct qdf_tso_seg_elem_t *tsoseg)
{
memset(tsoseg, 0, offsetof(struct qdf_tso_seg_elem_t, dbg));
return;
};
#else
static inline
void qdf_tso_seg_dbg_init(struct qdf_tso_seg_elem_t *tsoseg)
{
};
static inline
int qdf_tso_seg_dbg_record(struct qdf_tso_seg_elem_t *tsoseg, short id)
{
return 0;
};
static inline void qdf_tso_seg_dbg_bug(char *msg)
{
};
static inline void
qdf_tso_seg_dbg_setowner(struct qdf_tso_seg_elem_t *tsoseg, void *owner)
{
};
static inline int
qdf_tso_seg_dbg_zero(struct qdf_tso_seg_elem_t *tsoseg)
{
memset(tsoseg, 0, sizeof(struct qdf_tso_seg_elem_t));
return 0;
};
#endif /* TSOSEG_DEBUG */
void qdf_trace_hex_dump(QDF_MODULE_ID module, QDF_TRACE_LEVEL level,
void *data, int buf_len);
#define ERROR_CODE -1
#define QDF_MAX_NAME_SIZE 32
#define MAX_PRINT_CONFIG_SUPPORTED 32
#define MAX_SUPPORTED_CATEGORY QDF_MODULE_ID_MAX
/**
* qdf_set_pidx() - Sets the global qdf_pidx.
* @pidx : Index of print control object assigned to the module
*
*/
void qdf_set_pidx(int pidx);
/**
* qdf_get_pidx() - Returns the global qdf_pidx.
*
* Return : Current qdf print index.
*/
int qdf_get_pidx(void);
/*
* Shared print control index
* for converged debug framework
*/
#define QDF_PRINT_IDX_SHARED -1
/**
* QDF_PRINT_INFO() - Generic wrapper API for logging
* @idx : Index of print control object
* @module : Module identifier. A member of QDF_MODULE_ID enumeration that
* identifies the module issuing the trace message
* @level : Trace level. A member of QDF_TRACE_LEVEL enumeration indicating
* the severity of the condition causing the trace message to be
* issued.
* @str_format : Format string that contains the message to be logged.
*
*
* This wrapper will be used for any generic logging messages. Wrapper will
* compile a call to converged QDF trace message API.
*
* Return : Nothing
*
*/
void QDF_PRINT_INFO(unsigned int idx, QDF_MODULE_ID module,
QDF_TRACE_LEVEL level,
char *str_format, ...);
/**
* struct category_info : Category information structure
* @category_verbose_mask: Embeds information about category's verbose level
*/
struct category_info {
uint16_t category_verbose_mask;
};
/**
* struct category_name_info : Category name information structure
* @category_name_str: Embeds information about category name
*/
struct category_name_info {
unsigned char category_name_str[QDF_MAX_NAME_SIZE];
};
/**
* qdf_trace_msg_cmn()- Converged logging API
* @idx: Index of print control object assigned to the module
* @category: Category identifier. A member of the QDF_MODULE_ID enumeration
* that identifies the category issuing the trace message.
* @verbose: Verbose level. A member of the QDF_TRACE_LEVEL enumeration
* indicating the severity of the condition causing the trace
* message to be issued. More severe conditions are more likely
* to be logged.
* @str_format: Format string. The message to be logged. This format string
* contains printf-like replacement parameters, which follow this
* parameter in the variable argument list.
* @val: Variable argument list part of the log message
*
* Return: nothing
*
*/
void qdf_trace_msg_cmn(unsigned int idx,
QDF_MODULE_ID category,
QDF_TRACE_LEVEL verbose,
const char *str_format,
va_list val);
/**
* struct qdf_print_ctrl: QDF Print Control structure
* Statically allocated objects of print control
* structure are declared that will support maximum of
* 32 print control objects. Any module that needs to
* register to the print control framework needs to
* obtain a print control object using
* qdf_print_ctrl_register API. It will have to pass
* pointer to category info structure, name and
* custom print function to be used if required.
* @name : Optional name for the control object
* @cat_info : Array of category_info struct
* @custom_print : Custom print handler
* @custom_ctxt : Custom print context
* @dbglvlmac_on : Flag to enable/disable MAC level filtering
* @in_use : Boolean to indicate if control object is in use
*/
struct qdf_print_ctrl {
char name[QDF_MAX_NAME_SIZE];
struct category_info cat_info[MAX_SUPPORTED_CATEGORY];
void (*custom_print)(void *ctxt, const char *fmt, va_list args);
void *custom_ctxt;
#ifdef DBG_LVL_MAC_FILTERING
unsigned char dbglvlmac_on;
#endif
bool in_use;
};
/**
* qdf_print_ctrl_register() - Allocate QDF print control object, assign
* pointer to category info or print control
* structure and return the index to the callee
* @cinfo : Pointer to array of category info structure
* @custom_print_handler : Pointer to custom print handler
* @custom_ctx : Pointer to custom context
* @pctrl_name : Pointer to print control object name
*
* Return : Index of qdf_print_ctrl structure
*
*/
int qdf_print_ctrl_register(const struct category_info *cinfo,
void *custom_print_handler,
void *custom_ctx,
const char *pctrl_name);
/**
* qdf_shared_print_ctrl_init() - Initialize the shared print ctrl obj with
* all categories set to the default level
*
* Return : void
*
*/
void qdf_shared_print_ctrl_init(void);
/**
* qdf_print_setup() - Setup default values to all the print control objects
*
* Register new print control object for the callee
*
* Return : QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE
* on failure
*/
QDF_STATUS qdf_print_setup(void);
/**
* qdf_print_ctrl_cleanup() - Clean up a print control object
*
* Cleanup the print control object for the callee
*
* @pctrl : Index of print control object
*
* Return : QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE on failure
*/
QDF_STATUS qdf_print_ctrl_cleanup(unsigned int idx);
/**
* qdf_print_ctrl_shared_cleanup() - Clean up of the shared object
*
* Cleanup the shared print-ctrl-object
*
* Return : void
*/
void qdf_shared_print_ctrl_cleanup(void);
/**
* qdf_print_set_category_verbose() - Enable/Disable category for a
* print control object with
* user provided verbose level
*
* @idx : Index of the print control object assigned to callee
* @category : Category information
* @verbose: Verbose information
* @is_set: Flag indicating if verbose level needs to be enabled or disabled
*
* Return : QDF_STATUS_SUCCESS for success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS qdf_print_set_category_verbose(unsigned int idx,
QDF_MODULE_ID category,
QDF_TRACE_LEVEL verbose,
bool is_set);
/**
* qdf_print_is_category_enabled() - Get category information for the
* print control object
*
* @idx : Index of print control object
* @category : Category information
*
* Return : Verbose enabled(true) or disabled(false) or invalid input (false)
*/
bool qdf_print_is_category_enabled(unsigned int idx,
QDF_MODULE_ID category);
/**
* qdf_print_is_verbose_enabled() - Get verbose information of a category for
* the print control object
*
* @idx : Index of print control object
* @category : Category information
* @verbose : Verbose information
*
* Return : Verbose enabled(true) or disabled(false) or invalid input (false)
*/
bool qdf_print_is_verbose_enabled(unsigned int idx,
QDF_MODULE_ID category,
QDF_TRACE_LEVEL verbose);
/**
* qdf_print_clean_node_flag() - Clean up node flag for print control object
*
* @idx : Index of print control object
*
* Return : None
*/
void qdf_print_clean_node_flag(unsigned int idx);
#ifdef DBG_LVL_MAC_FILTERING
/**
* qdf_print_set_node_flag() - Set flag to enable MAC level filtering
*
* @idx : Index of print control object
* @enable : Enable/Disable bit sent by callee
*
* Return : QDF_STATUS_SUCCESS on Success and QDF_STATUS_E_FAILURE on Failure
*/
QDF_STATUS qdf_print_set_node_flag(unsigned int idx,
uint8_t enable);
/**
* qdf_print_get_node_flag() - Get flag that controls MAC level filtering
*
* @idx : Index of print control object
*
* Return : Flag that indicates enable(1) or disable(0) or invalid(-1)
*/
bool qdf_print_get_node_flag(unsigned int idx);
#endif
/**
* qdf_logging_init() - Initialize msg logging functionality
*
*
* Return : void
*/
void qdf_logging_init(void);
/**
* qdf_logging_exit() - Cleanup msg logging functionality
*
*
* Return : void
*/
void qdf_logging_exit(void);
#define QDF_SYMBOL_LEN __QDF_SYMBOL_LEN
/**
* qdf_sprint_symbol() - prints the name of a symbol into a string buffer
* @buffer: the string buffer to print into
* @addr: address of the symbol to lookup and print
*
* Return: number of characters printed
*/
int qdf_sprint_symbol(char *buffer, void *addr);
#endif /* __QDF_TRACE_H */
Reference in New Issue View Git Blame Copy Permalink