samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Rozštěpit 0
Zdrojový kód Úkoly Pull requesty Akce Balíčky Projekty Vydání Wiki Aktivita

qcacmn: Add pktlog handler to process rate events

Procházet zdrojové kódy 
Add dp_msg_pktlog_handler to handle
rate events from the firmware.

Change-Id: I24776caa3b78ec38d94421f243ec72d81ee3102d
CRs-Fixed: 2340639
Tento commit je obsažen v:
Venkata Sharath Chandra Manchala
2018-10-28 21:01:23 -07:00
odevzdal nshrivas
rodič 58e34a3e10
revize 0ce469e330
4 změnil soubory, kde provedl 189 přidání a 29 odebrání
Stáhněte soubor záplaty Stáhněte rozdílový soubor Rozbalit všechny soubory Sbalit všechny soubory

7
dp/wifi3.0/dp_htt.c
Zobrazit soubor

@@ -2874,7 +2874,7 @@ dp_ppdu_stats_ind_handler(struct htt_soc *soc,
#endif
#if defined(WDI_EVENT_ENABLE) && \
!defined(REMOVE_PKT_LOG) && defined(CONFIG_WIN)
!defined(REMOVE_PKT_LOG)
/*
* dp_pktlog_msg_handler() - Pktlog msg handler
* @htt_soc: HTT SOC handle
@@ -2884,7 +2884,7 @@ dp_ppdu_stats_ind_handler(struct htt_soc *soc,
*/
static void
dp_pktlog_msg_handler(struct htt_soc *soc,
uint32_t *msg_word)
uint32_t *msg_word)
{
uint8_t pdev_id;
uint32_t *pl_hdr;
@@ -2900,11 +2900,10 @@ dp_pktlog_msg_handler(struct htt_soc *soc,
#else
static void
dp_pktlog_msg_handler(struct htt_soc *soc,
uint32_t *msg_word)
uint32_t *msg_word)
{
}
#endif
/*
* dp_htt_t2h_msg_handler() - Generic Target to host Msg/event handler
* @context: Opaque context (HTT SOC handle)

5
utils/pktlog/include/pktlog_ac_i.h
Zobrazit soubor

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2012-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2012-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
@@ -45,9 +45,7 @@ struct ath_pktlog_arg {
#endif
size_t log_size;
uint16_t timestamp;
#ifdef HELIUMPLUS
uint32_t type_specific_data;
#endif
char *buf;
};
@@ -64,5 +62,6 @@ A_STATUS process_rate_update(void *pdev, void *data);
A_STATUS process_sw_event(void *pdev, void *data);
int process_pktlog_lite(void *context, void *log_data, uint16_t log_type);
int process_rx_desc_remote(void *pdev, void *data);
A_STATUS process_offload_pktlog(struct cdp_pdev *pdev, void *data);
#endif /* REMOVE_PKT_LOG */
#endif

129
utils/pktlog/pktlog_ac.c
Zobrazit soubor

@@ -50,6 +50,7 @@ wdi_event_subscribe PKTLOG_RCUPDATE_SUBSCRIBER;
wdi_event_subscribe PKTLOG_SW_EVENT_SUBSCRIBER;
wdi_event_subscribe PKTLOG_LITE_T2H_SUBSCRIBER;
wdi_event_subscribe PKTLOG_LITE_RX_SUBSCRIBER;
wdi_event_subscribe PKTLOG_OFFLOAD_SUBSCRIBER;
struct ol_pl_arch_dep_funcs ol_pl_funcs = {
.pktlog_init = pktlog_init,
@@ -164,18 +165,25 @@ pktlog_enable_tgt(struct hif_opaque_softc *_scn, uint32_t log_state,
if (log_state & ATH_PKTLOG_SW_EVENT)
types |= WMI_PKTLOG_EVENT_SW;
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG,
"%s: Pktlog events: %d", __func__, types);
return pktlog_wma_post_msg(types, WMI_PDEV_PKTLOG_ENABLE_CMDID,
ini_triggered, user_triggered);
}
#ifdef HELIUMPLUS
/**
* wdi_pktlog_subscribe() - Subscribe pktlog callbacks
* @cdp_pdev: abstract pdev handle
* @log_state: Pktlog registration
*
* Return: zero on success, non-zero on failure
*/
static inline A_STATUS
wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
{
#ifdef CONFIG_MCL
void *soc = cds_get_context(QDF_MODULE_ID_SOC);
#else
/*TODO: WIN implementation to get soc */
#endif
if (!cdp_pdev) {
qdf_print("Invalid pdev in %s", __func__);
@@ -220,28 +228,80 @@ wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
return A_ERROR;
}
}
if (log_state & ATH_PKTLOG_LITE_T2H) {
if (cdp_wdi_event_sub(soc, cdp_pdev,
&PKTLOG_LITE_T2H_SUBSCRIBER,
WDI_EVENT_LITE_T2H)) {
return A_OK;
}
#else
static inline A_STATUS
wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
{
void *soc = cds_get_context(QDF_MODULE_ID_SOC);
if (!cdp_pdev) {
qdf_print("Invalid pdev in %s", __func__);
return A_ERROR;
}
if ((log_state & ATH_PKTLOG_TX) ||
(log_state & ATH_PKTLOG_RCFIND) ||
(log_state & ATH_PKTLOG_RCUPDATE) ||
(log_state & ATH_PKTLOG_RX)) {
if (cdp_wdi_event_sub(soc,
cdp_pdev,
&PKTLOG_OFFLOAD_SUBSCRIBER,
WDI_EVENT_OFFLOAD_ALL)) {
return A_ERROR;
}
}
if (log_state & ATH_PKTLOG_RX) {
if (cdp_wdi_event_sub(soc, cdp_pdev,
&PKTLOG_RX_SUBSCRIBER,
WDI_EVENT_RX_DESC)) {
return A_ERROR;
}
}
if (log_state & ATH_PKTLOG_SW_EVENT) {
if (cdp_wdi_event_sub(soc, cdp_pdev,
&PKTLOG_SW_EVENT_SUBSCRIBER,
WDI_EVENT_SW_EVENT)) {
return A_ERROR;
}
}
if (log_state & ATH_PKTLOG_LITE_T2H) {
if (cdp_wdi_event_sub(soc, cdp_pdev,
&PKTLOG_LITE_T2H_SUBSCRIBER,
WDI_EVENT_LITE_T2H)) {
return A_ERROR;
}
}
if (log_state & ATH_PKTLOG_LITE_RX) {
if (cdp_wdi_event_sub(soc, cdp_pdev,
&PKTLOG_LITE_RX_SUBSCRIBER,
WDI_EVENT_LITE_RX)) {
&PKTLOG_LITE_RX_SUBSCRIBER,
WDI_EVENT_LITE_RX)) {
return A_ERROR;
}
}
return A_OK;
}
#endif
void pktlog_callback(void *pdev, enum WDI_EVENT event, void *log_data,
u_int16_t peer_id, uint32_t status)
{
switch (event) {
case WDI_EVENT_OFFLOAD_ALL:
{
if (process_offload_pktlog(pdev, log_data)) {
qdf_print("Unable to process offload info");
return;
}
break;
}
case WDI_EVENT_TX_STATUS:
{
/*
@@ -349,14 +409,19 @@ lit_pktlog_callback(void *context, enum WDI_EVENT event, void *log_data,
}
}
#ifdef HELIUMPLUS
/**
* wdi_pktlog_unsubscribe() - Unsubscribe pktlog callbacks
* @cdp_pdev: abstract pdev handle
* @log_state: Pktlog registration
*
* Return: zero on success, non-zero on failure
*/
A_STATUS
wdi_pktlog_unsubscribe(struct cdp_pdev *pdev, uint32_t log_state)
{
#ifdef CONFIG_MCL
void *soc = cds_get_context(QDF_MODULE_ID_SOC);
#else
/* TODO: WIN implementation to get soc */
#endif
if (log_state & ATH_PKTLOG_TX) {
if (cdp_wdi_event_unsub(soc, pdev,
@@ -376,6 +441,7 @@ wdi_pktlog_unsubscribe(struct cdp_pdev *pdev, uint32_t log_state)
return A_ERROR;
}
}
if (log_state & ATH_PKTLOG_RCFIND) {
if (cdp_wdi_event_unsub(soc, pdev,
&PKTLOG_RCFIND_SUBSCRIBER,
@@ -397,23 +463,51 @@ wdi_pktlog_unsubscribe(struct cdp_pdev *pdev, uint32_t log_state)
return A_ERROR;
}
}
return A_OK;
}
#else
A_STATUS
wdi_pktlog_unsubscribe(struct cdp_pdev *pdev, uint32_t log_state)
{
void *soc = cds_get_context(QDF_MODULE_ID_SOC);
if ((log_state & ATH_PKTLOG_TX) ||
(log_state & ATH_PKTLOG_RCFIND) ||
(log_state & ATH_PKTLOG_RCUPDATE) ||
(log_state & ATH_PKTLOG_RX)) {
if (cdp_wdi_event_unsub(soc,
pdev,
&PKTLOG_OFFLOAD_SUBSCRIBER,
WDI_EVENT_OFFLOAD_ALL)) {
return A_ERROR;
}
}
if (log_state & ATH_PKTLOG_RX) {
if (cdp_wdi_event_unsub(soc, pdev,
&PKTLOG_RX_SUBSCRIBER,
WDI_EVENT_RX_DESC)) {
return A_ERROR;
}
}
if (log_state & ATH_PKTLOG_LITE_T2H) {
if (cdp_wdi_event_unsub(soc, pdev,
&PKTLOG_LITE_T2H_SUBSCRIBER,
WDI_EVENT_LITE_T2H)) {
&PKTLOG_LITE_T2H_SUBSCRIBER,
WDI_EVENT_LITE_T2H)) {
return A_ERROR;
}
}
if (log_state & ATH_PKTLOG_LITE_RX) {
if (cdp_wdi_event_unsub(soc, pdev,
&PKTLOG_LITE_RX_SUBSCRIBER,
WDI_EVENT_LITE_RX)) {
&PKTLOG_LITE_RX_SUBSCRIBER,
WDI_EVENT_LITE_RX)) {
return A_ERROR;
}
}
return A_OK;
}
#endif
int pktlog_disable(struct hif_opaque_softc *scn)
{
@@ -515,6 +609,7 @@ void pktlog_init(struct hif_opaque_softc *scn)
} else if (pl_dev->callback_type == PKTLOG_LITE_CALLBACK_REGISTRATION) {
PKTLOG_LITE_T2H_SUBSCRIBER.callback = lit_pktlog_callback;
PKTLOG_LITE_RX_SUBSCRIBER.callback = lit_pktlog_callback;
PKTLOG_OFFLOAD_SUBSCRIBER.callback = pktlog_callback;
}
}

77
utils/pktlog/pktlog_internal.c
Zobrazit soubor

@@ -110,9 +110,7 @@ void pktlog_getbuf_intsafe(struct ath_pktlog_arg *plarg)
log_hdr->size = (uint16_t) log_size;
log_hdr->missed_cnt = plarg->missed_cnt;
log_hdr->timestamp = plarg->timestamp;
#ifdef HELIUMPLUS
log_hdr->type_specific_data = plarg->type_specific_data;
#endif
cur_wr_offset += sizeof(*log_hdr);
if ((buf_size - cur_wr_offset) < log_size) {
@@ -157,9 +155,8 @@ char *pktlog_getbuf(struct pktlog_dev_t *pl_dev,
plarg.flags = pl_hdr->flags;
plarg.missed_cnt = pl_hdr->missed_cnt;
plarg.timestamp = pl_hdr->timestamp;
#ifdef HELIUMPLUS
plarg.type_specific_data = pl_hdr->type_specific_data;
#endif
if (flags & PHFLAGS_INTERRUPT_CONTEXT) {
/*
* We are already in interrupt context, no need to make it
@@ -453,7 +450,6 @@ A_STATUS process_tx_info(struct cdp_pdev *txrx_pdev, void *data)
}
return A_OK;
}
#else
A_STATUS process_tx_info(struct cdp_pdev *txrx_pdev, void *data)
{
@@ -640,6 +636,77 @@ A_STATUS process_tx_info(struct cdp_pdev *txrx_pdev, void *data)
}
#endif
/**
* process_offload_pktlog() - Process full pktlog events
* pdev: abstract pdev handle
* data: pktlog buffer
*
* Return: zero on success, non-zero on failure
*/
A_STATUS
process_offload_pktlog(struct cdp_pdev *pdev, void *data)
{
struct pktlog_dev_t *pl_dev = get_pktlog_handle();
struct ath_pktlog_info *pl_info;
struct ath_pktlog_hdr pl_hdr;
uint32_t *pl_tgt_hdr;
void *txdesc_hdr_ctl = NULL;
size_t log_size = 0;
size_t tmp_log_size = 0;
if (!pl_dev) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"Invalid context in %s\n", __func__);
return A_ERROR;
}
if (!data) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"Invalid data in %s\n", __func__);
return A_ERROR;
}
pl_tgt_hdr = (uint32_t *)data;
pl_hdr.flags = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_FLAGS_OFFSET) &
ATH_PKTLOG_HDR_FLAGS_MASK) >>
ATH_PKTLOG_HDR_FLAGS_SHIFT;
pl_hdr.missed_cnt = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MISSED_CNT_OFFSET) &
ATH_PKTLOG_HDR_MISSED_CNT_MASK) >>
ATH_PKTLOG_HDR_MISSED_CNT_SHIFT;
pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
pl_hdr.size = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_SIZE_OFFSET) &
ATH_PKTLOG_HDR_SIZE_MASK) >> ATH_PKTLOG_HDR_SIZE_SHIFT;
pl_hdr.timestamp = *(pl_tgt_hdr + ATH_PKTLOG_HDR_TIMESTAMP_OFFSET);
pl_hdr.type_specific_data = *(pl_tgt_hdr
+ ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET);
/*
* Must include to process different types
* TX_CTL, TX_STATUS, TX_MSDU_ID, TX_FRM_HDR
*/
pl_info = pl_dev->pl_info;
tmp_log_size = sizeof(frm_hdr) + pl_hdr.size;
log_size = pl_hdr.size;
txdesc_hdr_ctl =
(void *)pktlog_getbuf(pl_dev, pl_info, log_size, &pl_hdr);
if (!txdesc_hdr_ctl) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"Failed to allocate pktlog descriptor");
return A_NO_MEMORY;
}
qdf_assert(txdesc_hdr_ctl);
qdf_assert(pl_hdr->size < PKTLOG_MAX_TX_WORDS * sizeof(u_int32_t));
qdf_mem_copy(txdesc_hdr_ctl,
((void *)data + sizeof(struct ath_pktlog_hdr)),
pl_hdr.size);
cds_pkt_stats_to_logger_thread(&pl_hdr, NULL, txdesc_hdr_ctl);
return A_OK;
}
/* TODO: hardware dependent function */
A_STATUS process_rx_info_remote(void *pdev, void *data)
{