/**
|
* @file Broadcom Dongle Host Driver (DHD), time sync protocol handler
|
*
|
* timesync mesasages are exchanged between the host and device to synchronize the source time
|
* for ingress and egress packets.
|
*
|
* Copyright (C) 2020, Broadcom.
|
*
|
* Unless you and Broadcom execute a separate written software license
|
* agreement governing use of this software, this software is licensed to you
|
* under the terms of the GNU General Public License version 2 (the "GPL"),
|
* available at http://www.broadcom.com/licenses/GPLv2.php, with the
|
* following added to such license:
|
*
|
* As a special exception, the copyright holders of this software give you
|
* permission to link this software with independent modules, and to copy and
|
* distribute the resulting executable under terms of your choice, provided that
|
* you also meet, for each linked independent module, the terms and conditions of
|
* the license of that module. An independent module is a module which is not
|
* derived from this software. The special exception does not apply to any
|
* modifications of the software.
|
*
|
*
|
* <<Broadcom-WL-IPTag/Open:>>
|
*
|
* $Id$:
|
*/
|
|
#include <typedefs.h>
|
#include <bcmutils.h>
|
#include <bcmendian.h>
|
#include <bcmdevs.h>
|
#include <dngl_stats.h>
|
#include <dhd.h>
|
#include <dhd_bus.h>
|
#include <dhd_proto.h>
|
#include <dhd_dbg.h>
|
#include <dhd_timesync.h>
|
#include <bcmpcie.h>
|
#include <bcmmsgbuf.h>
|
|
extern void dhd_msgbuf_delay_post_ts_bufs(dhd_pub_t *dhd);
|
|
#define MAX_FW_CLKINFO_TYPES 8
|
#define MAX_SIZE_FW_CLKINFO_TYPE (MAX_FW_CLKINFO_TYPES * sizeof(ts_fw_clock_info_t))
|
|
#define MAX_FW_TS_LOG_SAMPLES 64
|
|
#define BCMMSGBUF_HOST_TS_BADTAG 0xF0
|
|
#define DHD_DEFAULT_TIMESYNC_TIMER_VALUE 20 /* ms */
|
#define DHD_DEFAULT_TIMESYNC_TIMER_VALUE_MAX 9000 /* ms */
|
|
#define MAX_TS_LOG_SAMPLES_DATA 128
|
#define TS_NODROP_CONFIG_TO 1
|
#define TS_DROP_CONFIG_TO 5
|
|
typedef struct clksrc_ts_log {
|
uchar name[4];
|
uint32 inuse;
|
ts_timestamp_srcid_t log[MAX_FW_TS_LOG_SAMPLES];
|
} clksrc_ts_log_t;
|
|
typedef struct clk_ts_log {
|
uint32 clk_ts_inited;
|
uint32 cur_idx;
|
uint32 seqnum[MAX_FW_TS_LOG_SAMPLES];
|
clksrc_ts_log_t ts_log[MAX_CLKSRC_ID+1];
|
} clk_ts_log_t;
|
|
typedef struct dhd_ts_xt_id {
|
uint16 host_timestamping_config;
|
uint16 host_clock_selection;
|
uint16 host_clk_info;
|
uint16 d2h_clk_correction;
|
} dhd_ts_xt_id_t;
|
|
typedef struct dhd_ts_log_ts_item {
|
uint16 flowid; /* interface, Flow ID */
|
uint8 intf; /* interface */
|
uint8 rsvd;
|
uint32 ts_low; /* time stamp values */
|
uint32 ts_high; /* time stamp values */
|
uint32 proto;
|
uint32 t1;
|
uint32 t2;
|
} dhd_ts_log_ts_item_t;
|
|
typedef struct dhd_ts_log_ts {
|
uint32 max_idx;
|
uint32 cur_idx;
|
dhd_ts_log_ts_item_t ts_log[MAX_TS_LOG_SAMPLES_DATA];
|
} dhd_ts_log_ts_t;
|
|
#define MAX_BUF_SIZE_HOST_CLOCK_INFO 512
|
|
#define HOST_TS_CONFIG_FW_TIMESTAMP_PERIOD_DEFAULT 1000
|
|
struct dhd_ts {
|
dhd_pub_t *dhdp;
|
osl_t *osh;
|
uint32 xt_id;
|
uint16 host_ts_capture_cnt;
|
uint32 fw_ts_capture_cnt;
|
uint32 fw_ts_disc_cnt;
|
uint32 h_clkid_min;
|
uint32 h_clkid_max;
|
uint32 h_tsconf_period;
|
|
/* sould these be per clock source */
|
ts_correction_m_t correction_m;
|
ts_correction_m_t correction_b;
|
|
ts_fw_clock_info_t fw_tlv[MAX_FW_CLKINFO_TYPES];
|
uint32 fw_tlv_len;
|
clk_ts_log_t fw_ts_log;
|
uchar host_ts_host_clk_info_buffer[MAX_BUF_SIZE_HOST_CLOCK_INFO];
|
bool host_ts_host_clk_info_buffer_in_use;
|
dhd_ts_xt_id_t xt_ids;
|
uint32 active_ipc_version;
|
|
uint32 fwts2hsts_delay;
|
uint32 fwts2hsts_delay_wdcount;
|
uint32 ts_watchdog_calls;
|
uint64 last_ts_watchdog_time;
|
uint32 pending_requests;
|
|
dhd_ts_log_ts_t tx_timestamps;
|
dhd_ts_log_ts_t rx_timestamps;
|
/* outside modules could stop timesync independent of the user config */
|
bool timesync_disabled;
|
uint32 host_reset_cnt;
|
bool nodrop_config;
|
|
uint32 suspend_req;
|
uint32 resume_req;
|
};
|
struct dhd_ts *g_dhd_ts;
|
static uint32 dhd_timesync_send_D2H_clk_correction(dhd_ts_t *ts);
|
static uint32 dhd_timesync_send_host_clk_info(dhd_ts_t *ts);
|
static uint32 dhd_timesync_send_host_clock_selection(dhd_ts_t *ts);
|
static uint32 dhd_timesync_send_host_timestamping_config(dhd_ts_t *ts, bool inject_err);
|
static void dhd_timesync_ts_log_dump_item(dhd_ts_log_ts_t *tsl, struct bcmstrbuf *b);
|
|
/* Check for and handle local prot-specific iovar commands */
|
|
enum {
|
IOV_TS_INFO_DUMP,
|
IOV_TS_TX_TS_DUMP,
|
IOV_TS_RX_TS_DUMP,
|
IOV_TS_FW_CLKINFO_DUMP,
|
IOV_TS_HCLK_CLKID_MIN,
|
IOV_TS_HCLK_CLKID_MAX,
|
IOV_TS_HTSCONF_PERIOD,
|
IOV_TS_SEND_TSCONFIG,
|
IOV_TS_SEND_HCLK_SEL,
|
IOV_TS_SEND_HCLK_INFO,
|
IOV_TS_SEND_D2H_CRCT,
|
IOV_TS_TXS_LOG,
|
IOV_TS_RXS_LOG,
|
IOV_TS_INJECT_BAD_XTID,
|
IOV_TS_INJECT_BAD_TAG,
|
IOV_TS_FWTS2HSTS_DELAY,
|
IOV_TS_NODROP_CONFIG,
|
IOV_TS_CLEAR_LOGS,
|
IOV_TS_NO_RETRY,
|
IOV_TS_NO_AGGR,
|
IOV_TS_FIXED_RATE,
|
IOV_LAST
|
};
|
const bcm_iovar_t dhd_ts_iovars[] = {
|
{"ts_info_dump", IOV_TS_INFO_DUMP, 0, 0, IOVT_BUFFER, DHD_IOCTL_MAXLEN },
|
{"ts_tx_ts_dump", IOV_TS_TX_TS_DUMP, 0, 0, IOVT_BUFFER, DHD_IOCTL_MAXLEN },
|
{"ts_rx_ts_dump", IOV_TS_RX_TS_DUMP, 0, 0, IOVT_BUFFER, DHD_IOCTL_MAXLEN },
|
{"ts_fw_clkinfo_dump", IOV_TS_FW_CLKINFO_DUMP, 0, 0, IOVT_BUFFER, DHD_IOCTL_MAXLEN },
|
{"ts_hclk_clkid_min", IOV_TS_HCLK_CLKID_MIN, 0, 0, IOVT_UINT32, 0 },
|
{"ts_hclk_clkid_max", IOV_TS_HCLK_CLKID_MAX, 0, 0, IOVT_UINT32, 0 },
|
{"ts_htsconf_period", IOV_TS_HTSCONF_PERIOD, 0, 0, IOVT_UINT32, 0 },
|
{"ts_send_tsconfig", IOV_TS_SEND_TSCONFIG, 0, 0, IOVT_UINT32, 0 },
|
{"ts_send_hostclk_sel", IOV_TS_SEND_HCLK_SEL, 0, 0, IOVT_UINT32, 0 },
|
{"ts_send_hostclk_info", IOV_TS_SEND_HCLK_INFO, 0, 0, IOVT_UINT32, 0 },
|
{"ts_send_d2h_corect ", IOV_TS_SEND_D2H_CRCT, 0, 0, IOVT_UINT32, 0 },
|
{"ts_txs_log", IOV_TS_TXS_LOG, 0, 0, IOVT_UINT32, 0 },
|
{"ts_rxs_log", IOV_TS_RXS_LOG, 0, 0, IOVT_UINT32, 0 },
|
|
/* error injection cases */
|
{"ts_inject_bad_xtid", IOV_TS_INJECT_BAD_XTID, 0, 0, IOVT_UINT32, 0 },
|
{"ts_inject_bad_tag", IOV_TS_INJECT_BAD_TAG, 0, 0, IOVT_UINT32, 0 },
|
{"ts_fwts2hsts_delay", IOV_TS_FWTS2HSTS_DELAY, 0, 0, IOVT_UINT32, 0 },
|
{"ts_nodrop_config", IOV_TS_NODROP_CONFIG, 0, 0, IOVT_UINT32, 0 },
|
{"ts_clear_logs", IOV_TS_CLEAR_LOGS, 0, 0, IOVT_UINT32, 0 },
|
{"ts_set_no_retry", IOV_TS_NO_RETRY, 0, 0, IOVT_UINT32, 0 },
|
{"ts_set_no_aggr", IOV_TS_NO_AGGR, 0, 0, IOVT_UINT32, 0 },
|
{"ts_set_fixed_rate", IOV_TS_FIXED_RATE, 0, 0, IOVT_UINT32, 0 },
|
|
{NULL, 0, 0, 0, 0, 0 }
|
};
|
|
static int dhd_ts_fw_clksrc_dump(dhd_ts_t *ts, char *buf, int buflen);
|
#ifdef CONFIG_PROC_FS
|
static int dhd_open_proc_ts_fw_clk_dump(struct inode *inode, struct file *file);
|
ssize_t dhd_read_proc_ts_fw_clk_dump(struct file *file, char *user_buf, size_t count, loff_t *loff);
|
static int dhd_open_proc_ts_tx_dump(struct inode *inode, struct file *file);
|
ssize_t dhd_read_proc_ts_tx_dump(struct file *file, char *user_buf, size_t count, loff_t *loff);
|
static int dhd_open_proc_ts_rx_dump(struct inode *inode, struct file *file);
|
ssize_t dhd_read_proc_ts_rx_dump(struct file *file, char *user_buf, size_t count, loff_t *loff);
|
|
static int
|
dhd_open_proc_ts_fw_clk_dump(struct inode *inode, struct file *file)
|
{
|
return single_open(file, 0, NULL);
|
}
|
ssize_t
|
dhd_read_proc_ts_fw_clk_dump(struct file *file, char *user_buf, size_t count, loff_t *loff)
|
{
|
dhd_ts_t *ts;
|
char *buf;
|
ssize_t ret = 0;
|
|
ts = g_dhd_ts;
|
if (ts == NULL) {
|
return -EAGAIN;
|
}
|
if (DHD_BUS_CHECK_SUSPEND_OR_SUSPEND_IN_PROGRESS(ts->dhdp)) {
|
DHD_INFO(("%s bus is in suspend or suspend in progress\n", __func__));
|
return -EAGAIN;
|
}
|
if (DHD_BUS_CHECK_DOWN_OR_DOWN_IN_PROGRESS(ts->dhdp)) {
|
DHD_ERROR(("%s rmmod in progress\n", __func__));
|
return -ENOENT;
|
}
|
buf = kmalloc(count, GFP_KERNEL);
|
if (buf == NULL) {
|
DHD_ERROR(("%s failed to allocate buf with size %zu\n", __func__, count));
|
return -ENOMEM;
|
}
|
ret = dhd_ts_fw_clksrc_dump(ts, buf, count);
|
if (ret < 0) {
|
return 0;
|
}
|
ret = simple_read_from_buffer(user_buf, count, loff, buf, (count - ret));
|
kfree(buf);
|
return ret;
|
}
|
static int dhd_open_proc_ts_tx_dump(struct inode *inode, struct file *file)
|
{
|
return single_open(file, 0, NULL);
|
}
|
ssize_t
|
dhd_read_proc_ts_tx_dump(struct file *file, char *user_buf, size_t count, loff_t *loff)
|
{
|
dhd_ts_t *ts;
|
char *buf;
|
ssize_t ret = 0;
|
struct bcmstrbuf strbuf;
|
|
ts = g_dhd_ts;
|
if (ts == NULL) {
|
return -EAGAIN;
|
}
|
if (DHD_BUS_CHECK_SUSPEND_OR_SUSPEND_IN_PROGRESS(ts->dhdp)) {
|
DHD_INFO(("%s bus is in suspend or suspend in progress\n", __func__));
|
return -EAGAIN;
|
}
|
if (DHD_BUS_CHECK_DOWN_OR_DOWN_IN_PROGRESS(ts->dhdp)) {
|
DHD_ERROR(("%s rmmod in progress\n", __func__));
|
return -ENOENT;
|
}
|
buf = kmalloc(count, GFP_KERNEL);
|
if (buf == NULL) {
|
DHD_ERROR(("%s failed to allocate buf with size %zu\n", __func__, count));
|
return -ENOMEM;
|
}
|
bcm_binit(&strbuf, buf, count);
|
bcm_bprintf(&strbuf, "Tx Log dump\n");
|
dhd_timesync_ts_log_dump_item(&ts->tx_timestamps, &strbuf);
|
ret = simple_read_from_buffer(user_buf, count, loff, buf, (count - strbuf.size));
|
kfree(buf);
|
return ret;
|
}
|
|
static int dhd_open_proc_ts_rx_dump(struct inode *inode, struct file *file)
|
{
|
return single_open(file, 0, NULL);
|
}
|
|
ssize_t
|
dhd_read_proc_ts_rx_dump(struct file *file, char *user_buf, size_t count, loff_t *loff)
|
{
|
dhd_ts_t *ts;
|
char *buf;
|
ssize_t ret = 0;
|
struct bcmstrbuf strbuf;
|
|
ts = g_dhd_ts;
|
if (ts == NULL) {
|
return -EAGAIN;
|
}
|
if (DHD_BUS_CHECK_SUSPEND_OR_SUSPEND_IN_PROGRESS(ts->dhdp)) {
|
DHD_INFO(("%s bus is in suspend or suspend in progress\n", __func__));
|
return -EAGAIN;
|
}
|
if (DHD_BUS_CHECK_DOWN_OR_DOWN_IN_PROGRESS(ts->dhdp)) {
|
DHD_ERROR(("%s rmmod in progress\n", __func__));
|
return -ENOENT;
|
}
|
buf = kmalloc(count, GFP_KERNEL);
|
if (buf == NULL) {
|
DHD_ERROR(("%s failed to allocate buf with size %zu\n", __func__, count));
|
return -ENOMEM;
|
}
|
bcm_binit(&strbuf, buf, count);
|
bcm_bprintf(&strbuf, "Rx Log dump\n");
|
dhd_timesync_ts_log_dump_item(&ts->rx_timestamps, &strbuf);
|
ret = simple_read_from_buffer(user_buf, count, loff, buf, (count - strbuf.size));
|
kfree(buf);
|
return ret;
|
}
|
|
static const struct file_operations proc_fops_ts_fw_clk_dump = {
|
.read = dhd_read_proc_ts_fw_clk_dump,
|
.open = dhd_open_proc_ts_fw_clk_dump,
|
.release = seq_release,
|
};
|
static const struct file_operations proc_fops_ts_tx_dump = {
|
.read = dhd_read_proc_ts_tx_dump,
|
.open = dhd_open_proc_ts_tx_dump,
|
.release = seq_release,
|
};
|
static const struct file_operations proc_fops_ts_rx_dump = {
|
.read = dhd_read_proc_ts_rx_dump,
|
.open = dhd_open_proc_ts_rx_dump,
|
.release = seq_release,
|
};
|
#endif /* CONFIG_PROC_FS */
|
|
int
|
dhd_timesync_detach(dhd_pub_t *dhdp)
|
{
|
dhd_ts_t *ts;
|
|
DHD_TRACE(("%s: %d\n", __FUNCTION__, __LINE__));
|
|
if (!dhdp) {
|
return BCME_OK;
|
}
|
ts = dhdp->ts;
|
#ifdef CONFIG_PROC_FS
|
remove_proc_entry("ts_fw_clk_dump", NULL);
|
remove_proc_entry("ts_tx_dump", NULL);
|
remove_proc_entry("ts_rx_dump", NULL);
|
#endif /* CONFIG_PROC_FS */
|
#ifndef CONFIG_DHD_USE_STATIC_BUF
|
MFREE(dhdp->osh, ts, sizeof(dhd_ts_t));
|
#endif /* CONFIG_DHD_USE_STATIC_BUF */
|
g_dhd_ts = NULL;
|
dhdp->ts = NULL;
|
DHD_INFO(("Deallocated DHD TS\n"));
|
return BCME_OK;
|
}
|
int
|
dhd_timesync_attach(dhd_pub_t *dhdp)
|
{
|
dhd_ts_t *ts;
|
|
DHD_TRACE(("%s: %d\n", __FUNCTION__, __LINE__));
|
/* Allocate prot structure */
|
if (!(ts = (dhd_ts_t *)DHD_OS_PREALLOC(dhdp, DHD_PREALLOC_PROT,
|
sizeof(dhd_ts_t)))) {
|
DHD_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
|
goto fail;
|
}
|
memset(ts, 0, sizeof(*ts));
|
|
g_dhd_ts = ts;
|
ts->osh = dhdp->osh;
|
dhdp->ts = ts;
|
ts->dhdp = dhdp;
|
|
ts->correction_m.low = 1;
|
ts->correction_m.high = 1;
|
|
ts->correction_b.low = 0;
|
ts->correction_m.high = 0;
|
|
ts->fwts2hsts_delay = DHD_DEFAULT_TIMESYNC_TIMER_VALUE;
|
ts->fwts2hsts_delay_wdcount = 0;
|
|
ts->tx_timestamps.max_idx = MAX_TS_LOG_SAMPLES_DATA;
|
ts->rx_timestamps.max_idx = MAX_TS_LOG_SAMPLES_DATA;
|
|
ts->xt_id = 1;
|
|
DHD_INFO(("allocated DHD TS\n"));
|
|
#ifdef CONFIG_PROC_FS
|
if (proc_create("ts_fw_clk_dump", S_IRUSR, NULL, &proc_fops_ts_fw_clk_dump) == NULL) {
|
DHD_ERROR(("Failed to create /proc/ts_fw_clk_dump procfs interface\n"));
|
}
|
if (proc_create("ts_tx_dump", S_IRUSR, NULL, &proc_fops_ts_tx_dump) == NULL) {
|
DHD_ERROR(("Failed to create /proc/ts_tx_dump procfs interface\n"));
|
}
|
if (proc_create("ts_rx_dump", S_IRUSR, NULL, &proc_fops_ts_rx_dump) == NULL) {
|
DHD_ERROR(("Failed to create /proc/ts_rx_dump procfs interface\n"));
|
}
|
#endif /* CONFIG_PROC_FS */
|
|
return BCME_OK;
|
|
fail:
|
if (dhdp->ts != NULL) {
|
dhd_timesync_detach(dhdp);
|
}
|
return BCME_NOMEM;
|
}
|
|
static void
|
dhd_timesync_ts_log_dump_item(dhd_ts_log_ts_t *tsl, struct bcmstrbuf *b)
|
{
|
uint32 i = 0;
|
|
bcm_bprintf(b, "Max_idx: %d, cur_idx %d\n", tsl->max_idx, tsl->cur_idx);
|
for (i = 0; i < tsl->max_idx; i++) {
|
bcm_bprintf(b, "\t idx: %03d, (%d: %d) timestamp: 0x%08x:0x%08x "
|
" proto: %02d, t1: 0x%08x t2: 0x%08x\n",
|
i, tsl->ts_log[i].intf, tsl->ts_log[i].flowid,
|
tsl->ts_log[i].ts_high, tsl->ts_log[i].ts_low,
|
tsl->ts_log[i].proto, tsl->ts_log[i].t1,
|
tsl->ts_log[i].t2);
|
}
|
}
|
|
static int
|
dhd_timesync_ts_log_dump(dhd_ts_t *ts, char *buf, int buflen, bool tx)
|
{
|
struct bcmstrbuf b;
|
struct bcmstrbuf *strbuf = &b;
|
|
bcm_binit(strbuf, buf, buflen);
|
|
if (tx) {
|
bcm_bprintf(strbuf, "Tx Log dump\t");
|
dhd_timesync_ts_log_dump_item(&ts->tx_timestamps, strbuf);
|
}
|
else {
|
bcm_bprintf(strbuf, "Rx Log dump\n");
|
dhd_timesync_ts_log_dump_item(&ts->rx_timestamps, strbuf);
|
}
|
return BCME_OK;
|
}
|
|
static void
|
dhd_timesync_clear_logs(dhd_ts_t *ts)
|
{
|
dhd_ts_log_ts_t *tsl;
|
|
tsl = &ts->rx_timestamps;
|
tsl->cur_idx = 0;
|
memset(tsl->ts_log, 0, sizeof(dhd_ts_log_ts_item_t) *
|
MAX_TS_LOG_SAMPLES_DATA);
|
|
tsl = &ts->tx_timestamps;
|
tsl->cur_idx = 0;
|
memset(tsl->ts_log, 0, sizeof(dhd_ts_log_ts_item_t) *
|
MAX_TS_LOG_SAMPLES_DATA);
|
|
return;
|
}
|
|
void
|
dhd_timesync_debug_info_print(dhd_pub_t *dhdp)
|
{
|
dhd_ts_t *ts = dhdp->ts;
|
uint64 current_time;
|
|
if (!ts) {
|
DHD_ERROR(("%s: %d ts is NULL\n", __FUNCTION__, __LINE__));
|
return;
|
}
|
|
DHD_ERROR(("\nts info dump: active_ipc_version %d\n", ts->active_ipc_version));
|
current_time = OSL_LOCALTIME_NS();
|
DHD_ERROR(("current_time="SEC_USEC_FMT" last_ts_watchdog_time="SEC_USEC_FMT"\n",
|
GET_SEC_USEC(current_time), GET_SEC_USEC(ts->last_ts_watchdog_time)));
|
DHD_ERROR(("timesync disabled %d\n", ts->timesync_disabled));
|
DHD_ERROR(("Host TS dump cnt %d, fw TS dump cnt %d, descrepency %d\n",
|
ts->host_ts_capture_cnt, ts->fw_ts_capture_cnt, ts->fw_ts_disc_cnt));
|
DHD_ERROR(("ts_watchdog calls %d reset cnt %d\n",
|
ts->ts_watchdog_calls, ts->host_reset_cnt));
|
DHD_ERROR(("xt_ids tag/ID %d/%d, %d/%d, %d/%d, %d/%d\n",
|
BCMMSGBUF_HOST_TIMESTAMPING_CONFIG_TAG, ts->xt_ids.host_timestamping_config,
|
BCMMSGBUF_HOST_CLOCK_SELECT_TAG, ts->xt_ids.host_clock_selection,
|
BCMMSGBUF_HOST_CLOCK_INFO_TAG, ts->xt_ids.host_clk_info,
|
BCMMSGBUF_D2H_CLOCK_CORRECTION_TAG, ts->xt_ids.d2h_clk_correction));
|
DHD_ERROR(("pending requests %d suspend req %d resume req %d\n",
|
ts->pending_requests, ts->suspend_req, ts->resume_req));
|
|
}
|
|
static int
|
dhd_timesync_dump(dhd_ts_t *ts, char *buf, int buflen)
|
{
|
struct bcmstrbuf b;
|
struct bcmstrbuf *strbuf = &b;
|
|
bcm_binit(strbuf, buf, buflen);
|
|
bcm_bprintf(strbuf, "ts info dump: active_ipc_version %d\n", ts->active_ipc_version);
|
bcm_bprintf(strbuf, "timesync disabled %d\n", ts->timesync_disabled);
|
bcm_bprintf(strbuf, "Host TS dump cnt %d, fw TS dump cnt %d, descrepency %d\n",
|
ts->host_ts_capture_cnt, ts->fw_ts_capture_cnt, ts->fw_ts_disc_cnt);
|
bcm_bprintf(strbuf, "ts_watchdog calls %d reset cnt %d\n",
|
ts->ts_watchdog_calls, ts->host_reset_cnt);
|
bcm_bprintf(strbuf, "xt_ids tag/ID %d/%d, %d/%d, %d/%d, %d/%d\n",
|
BCMMSGBUF_HOST_TIMESTAMPING_CONFIG_TAG, ts->xt_ids.host_timestamping_config,
|
BCMMSGBUF_HOST_CLOCK_SELECT_TAG, ts->xt_ids.host_clock_selection,
|
BCMMSGBUF_HOST_CLOCK_INFO_TAG, ts->xt_ids.host_clk_info,
|
BCMMSGBUF_D2H_CLOCK_CORRECTION_TAG, ts->xt_ids.d2h_clk_correction);
|
bcm_bprintf(strbuf, "pending requests %d suspend req %d resume req %d\n",
|
ts->pending_requests, ts->suspend_req, ts->resume_req);
|
|
return BCME_OK;
|
}
|
|
static int
|
dhd_timesync_doiovar(dhd_ts_t *ts, const bcm_iovar_t *vi, uint32 actionid, const char *name,
|
void *params, uint plen, void *arg, uint len, int val_size)
|
{
|
int bcmerror = 0;
|
int32 int_val = 0;
|
|
DHD_TRACE(("%s: Enter\n", __FUNCTION__));
|
DHD_TRACE(("%s: actionid = %d; name %s\n", __FUNCTION__, actionid, name));
|
|
if ((bcmerror = bcm_iovar_lencheck(vi, arg, len, IOV_ISSET(actionid))) != 0)
|
goto exit;
|
|
if (plen >= sizeof(int_val))
|
bcopy(params, &int_val, sizeof(int_val));
|
|
switch (actionid) {
|
case IOV_GVAL(IOV_TS_INFO_DUMP):
|
dhd_timesync_dump(ts, arg, len);
|
break;
|
case IOV_GVAL(IOV_TS_TX_TS_DUMP):
|
dhd_timesync_ts_log_dump(ts, arg, len, TRUE);
|
break;
|
case IOV_GVAL(IOV_TS_RX_TS_DUMP):
|
dhd_timesync_ts_log_dump(ts, arg, len, FALSE);
|
break;
|
case IOV_GVAL(IOV_TS_FW_CLKINFO_DUMP):
|
dhd_ts_fw_clksrc_dump(ts, arg, len);
|
break;
|
case IOV_SVAL(IOV_TS_SEND_TSCONFIG):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
bcmerror = dhd_timesync_send_host_timestamping_config(ts, FALSE);
|
break;
|
case IOV_SVAL(IOV_TS_SEND_HCLK_SEL):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
bcmerror = dhd_timesync_send_host_clock_selection(ts);
|
break;
|
case IOV_SVAL(IOV_TS_SEND_HCLK_INFO):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
bcmerror = dhd_timesync_send_host_clk_info(ts);
|
break;
|
case IOV_SVAL(IOV_TS_SEND_D2H_CRCT):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
bcmerror = dhd_timesync_send_D2H_clk_correction(ts);
|
break;
|
case IOV_SVAL(IOV_TS_INJECT_BAD_TAG):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
bcmerror = dhd_timesync_send_host_timestamping_config(ts, TRUE);
|
break;
|
case IOV_SVAL(IOV_TS_INJECT_BAD_XTID): {
|
uint16 old_xt_id;
|
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
old_xt_id = ts->xt_id;
|
ts->xt_id += 10; /* will cause the error now */
|
DHD_ERROR(("generating bad XTID transaction for the device exp %d, sending %d",
|
old_xt_id, ts->xt_id));
|
bcmerror = dhd_timesync_send_host_timestamping_config(ts, FALSE);
|
ts->xt_id = old_xt_id;
|
break;
|
}
|
case IOV_GVAL(IOV_TS_FWTS2HSTS_DELAY):
|
bcopy(&ts->fwts2hsts_delay, arg, val_size);
|
break;
|
case IOV_SVAL(IOV_TS_FWTS2HSTS_DELAY):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
if (int_val > DHD_DEFAULT_TIMESYNC_TIMER_VALUE_MAX) {
|
bcmerror = BCME_RANGE;
|
break;
|
}
|
if (int_val <= DHD_DEFAULT_TIMESYNC_TIMER_VALUE) {
|
bcmerror = BCME_RANGE;
|
break;
|
}
|
ts->fwts2hsts_delay = int_val;
|
break;
|
case IOV_GVAL(IOV_TS_NODROP_CONFIG):
|
bcopy(&ts->nodrop_config, arg, val_size);
|
break;
|
case IOV_SVAL(IOV_TS_NODROP_CONFIG):
|
ts->nodrop_config = int_val;
|
break;
|
case IOV_GVAL(IOV_TS_NO_RETRY):
|
int_val = dhd_prot_pkt_noretry(ts->dhdp, 0, FALSE);
|
bcopy(&int_val, arg, val_size);
|
break;
|
case IOV_SVAL(IOV_TS_NO_RETRY):
|
dhd_prot_pkt_noretry(ts->dhdp, int_val, TRUE);
|
break;
|
case IOV_GVAL(IOV_TS_NO_AGGR):
|
int_val = dhd_prot_pkt_noaggr(ts->dhdp, 0, FALSE);
|
bcopy(&int_val, arg, val_size);
|
break;
|
case IOV_SVAL(IOV_TS_NO_AGGR):
|
dhd_prot_pkt_noaggr(ts->dhdp, int_val, TRUE);
|
break;
|
case IOV_GVAL(IOV_TS_FIXED_RATE):
|
int_val = dhd_prot_pkt_fixed_rate(ts->dhdp, 0, FALSE);
|
bcopy(&int_val, arg, val_size);
|
break;
|
case IOV_SVAL(IOV_TS_FIXED_RATE):
|
dhd_prot_pkt_fixed_rate(ts->dhdp, int_val, TRUE);
|
break;
|
case IOV_SVAL(IOV_TS_CLEAR_LOGS):
|
dhd_timesync_clear_logs(ts);
|
break;
|
case IOV_GVAL(IOV_TS_TXS_LOG):
|
int_val = dhd_prot_data_path_tx_timestamp_logging(ts->dhdp, 0, FALSE);
|
bcopy(&int_val, arg, val_size);
|
break;
|
case IOV_SVAL(IOV_TS_TXS_LOG):
|
dhd_prot_data_path_tx_timestamp_logging(ts->dhdp, int_val, TRUE);
|
break;
|
case IOV_GVAL(IOV_TS_RXS_LOG):
|
int_val = dhd_prot_data_path_rx_timestamp_logging(ts->dhdp, 0, FALSE);
|
bcopy(&int_val, arg, val_size);
|
break;
|
case IOV_SVAL(IOV_TS_RXS_LOG):
|
dhd_prot_data_path_rx_timestamp_logging(ts->dhdp, int_val, TRUE);
|
break;
|
case IOV_SVAL(IOV_TS_HTSCONF_PERIOD):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
ts->h_tsconf_period = int_val;
|
break;
|
case IOV_GVAL(IOV_TS_HTSCONF_PERIOD):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
bcopy(&ts->h_tsconf_period, arg, val_size);
|
break;
|
case IOV_SVAL(IOV_TS_HCLK_CLKID_MAX):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
ts->h_clkid_max = int_val;
|
break;
|
case IOV_GVAL(IOV_TS_HCLK_CLKID_MAX):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
bcopy(&ts->h_clkid_max, arg, val_size);
|
break;
|
|
case IOV_SVAL(IOV_TS_HCLK_CLKID_MIN):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
ts->h_clkid_min = int_val;
|
break;
|
case IOV_GVAL(IOV_TS_HCLK_CLKID_MIN):
|
if (ts->active_ipc_version < 7) {
|
bcmerror = BCME_ERROR;
|
break;
|
}
|
bcopy(&ts->h_clkid_min, arg, val_size);
|
break;
|
default:
|
bcmerror = BCME_UNSUPPORTED;
|
break;
|
}
|
exit:
|
DHD_TRACE(("%s: actionid %d, bcmerror %d\n", __FUNCTION__, actionid, bcmerror));
|
return bcmerror;
|
}
|
|
int
|
dhd_timesync_iovar_op(dhd_ts_t *ts, const char *name,
|
void *params, int plen, void *arg, int len, bool set)
|
{
|
int bcmerror = 0;
|
int val_size;
|
const bcm_iovar_t *vi = NULL;
|
uint32 actionid;
|
|
DHD_TRACE(("%s: Enter\n", __FUNCTION__));
|
|
ASSERT(name);
|
ASSERT(len >= 0);
|
|
/* Get MUST have return space */
|
ASSERT(set || (arg && len));
|
|
/* Set does NOT take qualifiers */
|
ASSERT(!set || (!params && !plen));
|
|
if ((vi = bcm_iovar_lookup(dhd_ts_iovars, name)) == NULL) {
|
DHD_TRACE(("%s: not ours\n", name));
|
bcmerror = BCME_UNSUPPORTED;
|
goto exit;
|
}
|
|
DHD_CTL(("%s: %s %s, len %d plen %d\n", __FUNCTION__,
|
name, (set ? "set" : "get"), len, plen));
|
|
/* set up 'params' pointer in case this is a set command so that
|
* the convenience int and bool code can be common to set and get
|
*/
|
if (params == NULL) {
|
params = arg;
|
plen = len;
|
}
|
|
if (vi->type == IOVT_VOID)
|
val_size = 0;
|
else if (vi->type == IOVT_BUFFER)
|
val_size = len;
|
else
|
/* all other types are integer sized */
|
val_size = sizeof(int);
|
|
actionid = set ? IOV_SVAL(vi->varid) : IOV_GVAL(vi->varid);
|
|
bcmerror = dhd_timesync_doiovar(ts, vi, actionid, name, params, plen, arg, len, val_size);
|
|
exit:
|
return bcmerror;
|
}
|
|
void
|
dhd_timesync_handle_host_ts_complete(dhd_ts_t *ts, uint16 xt_id, uint16 status)
|
{
|
if (ts == NULL) {
|
DHD_ERROR(("%s: called with ts null\n", __FUNCTION__));
|
return;
|
}
|
DHD_INFO(("Host send TS complete, for ID %d, status %d\n", xt_id, status));
|
if (xt_id == ts->xt_ids.host_clk_info) {
|
if (ts->host_ts_host_clk_info_buffer_in_use != TRUE) {
|
DHD_ERROR(("same ID as the host clock info, but buffer not in use: %d\n",
|
ts->xt_ids.host_clk_info));
|
return;
|
}
|
ts->host_ts_host_clk_info_buffer_in_use = FALSE;
|
}
|
ts->pending_requests--;
|
}
|
|
void
|
dhd_timesync_notify_ipc_rev(dhd_ts_t *ts, uint32 ipc_rev)
|
{
|
if (ts != NULL)
|
ts->active_ipc_version = ipc_rev;
|
}
|
|
static int
|
dhd_ts_fw_clksrc_dump(dhd_ts_t *ts, char *buf, int buflen)
|
{
|
struct bcmstrbuf b;
|
struct bcmstrbuf *strbuf = &b;
|
clk_ts_log_t *fw_ts_log;
|
uint32 i = 0, j = 0;
|
clksrc_ts_log_t *clk_src;
|
|
fw_ts_log = &ts->fw_ts_log;
|
|
bcm_binit(strbuf, buf, buflen);
|
|
while (i <= MAX_CLKSRC_ID) {
|
clk_src = &fw_ts_log->ts_log[i];
|
if (clk_src->inuse == FALSE) {
|
bcm_bprintf(strbuf, "clkID %d: not in use\n", i);
|
}
|
else {
|
bcm_bprintf(strbuf, "clkID %d: name %s Max idx %d, cur_idx %d\n",
|
i, clk_src->name, MAX_FW_TS_LOG_SAMPLES, fw_ts_log->cur_idx);
|
j = 0;
|
while (j < MAX_FW_TS_LOG_SAMPLES) {
|
bcm_bprintf(strbuf, "%03d: %03d: 0x%08x-0x%08x\n", j,
|
fw_ts_log->seqnum[j], clk_src->log[j].ts_high,
|
clk_src->log[j].ts_low);
|
j++;
|
}
|
}
|
i++;
|
}
|
return b.size;
|
}
|
|
static void
|
dhd_ts_fw_clksrc_log(dhd_ts_t *ts, uchar *tlvs, uint32 tlv_len, uint32 seqnum)
|
{
|
ts_fw_clock_info_t *fw_clock_info;
|
clksrc_ts_log_t *clk_src;
|
clk_ts_log_t *fw_ts_log;
|
|
fw_ts_log = &ts->fw_ts_log;
|
|
fw_ts_log->seqnum[fw_ts_log->cur_idx] = seqnum;
|
while (tlv_len) {
|
fw_clock_info = (ts_fw_clock_info_t *)tlvs;
|
clk_src = &fw_ts_log->ts_log[(fw_clock_info->ts.ts_high >> 28) & 0xF];
|
if (clk_src->inuse == FALSE) {
|
bcopy(fw_clock_info->clk_src, clk_src->name, sizeof(clk_src->name));
|
clk_src->inuse = TRUE;
|
}
|
clk_src->log[fw_ts_log->cur_idx].ts_low = fw_clock_info->ts.ts_low;
|
clk_src->log[fw_ts_log->cur_idx].ts_high = fw_clock_info->ts.ts_high;
|
|
tlvs += sizeof(*fw_clock_info);
|
tlv_len -= sizeof(*fw_clock_info);
|
}
|
fw_ts_log->cur_idx++;
|
if (fw_ts_log->cur_idx >= MAX_FW_TS_LOG_SAMPLES)
|
fw_ts_log->cur_idx = 0;
|
}
|
|
void
|
dhd_timesync_handle_fw_timestamp(dhd_ts_t *ts, uchar *tlvs, uint32 tlv_len, uint32 seqnum)
|
{
|
ts_fw_clock_info_t *fw_clock_info;
|
uint16 tag_id;
|
|
DHD_INFO(("FW sent timestamp message, tlv_len %d, seqnum %d\n", tlv_len, seqnum));
|
bcm_print_bytes("fw ts", tlvs, tlv_len);
|
/* we are expecting only one TLV type from the firmware side */
|
/* BCMMSGBUF_FW_CLOCK_INFO_TAG */
|
/* Validate the tag ID */
|
if (ts == NULL) {
|
DHD_ERROR(("%s: NULL TS \n", __FUNCTION__));
|
return;
|
}
|
if (tlvs == NULL) {
|
DHD_ERROR(("%s: NULL TLV \n", __FUNCTION__));
|
return;
|
}
|
if (tlv_len < BCM_XTLV_HDR_SIZE) {
|
DHD_ERROR(("%s: bad length %d\n", __FUNCTION__, tlv_len));
|
return;
|
}
|
if (tlv_len > MAX_SIZE_FW_CLKINFO_TYPE) {
|
DHD_ERROR(("tlv_len %d more than what is supported in Host %d\n", tlv_len,
|
(uint32)MAX_SIZE_FW_CLKINFO_TYPE));
|
return;
|
}
|
if (tlv_len % (sizeof(*fw_clock_info))) {
|
DHD_ERROR(("bad tlv_len for the packet %d, needs to be multiple of %d\n", tlv_len,
|
(uint32)(sizeof(*fw_clock_info))));
|
return;
|
}
|
|
/* validate the tag for all the include tag IDs */
|
{
|
uint32 check_len = 0;
|
uchar *tag_ptr = (uchar *)(tlvs);
|
while (check_len < tlv_len) {
|
bcopy(tag_ptr+check_len, &tag_id, sizeof(uint16));
|
DHD_INFO(("FWTS: tag_id %d, offset %d \n",
|
tag_id, check_len));
|
if (tag_id != BCMMSGBUF_FW_CLOCK_INFO_TAG) {
|
DHD_ERROR(("Fatal: invalid tag from FW in TS: %d, offset %d \n",
|
tag_id, check_len));
|
return;
|
}
|
check_len += sizeof(*fw_clock_info);
|
}
|
}
|
|
if (seqnum != (ts->fw_ts_capture_cnt + 1)) {
|
DHD_ERROR(("FW TS descrepency: out of sequence exp %d, got %d, resyncing %d\n",
|
ts->fw_ts_capture_cnt + 1, seqnum, seqnum));
|
ts->fw_ts_disc_cnt++;
|
}
|
ts->fw_ts_capture_cnt = seqnum;
|
|
/* copy it into local info */
|
bcopy(tlvs, &ts->fw_tlv[0], tlv_len);
|
ts->fw_tlv_len = tlv_len;
|
|
dhd_ts_fw_clksrc_log(ts, tlvs, tlv_len, seqnum);
|
/* launch the watchdog to send the host time stamp as per the delay programmed */
|
if (ts->fwts2hsts_delay_wdcount != 0) {
|
DHD_ERROR(("FATAL: Last Host sync is not sent out yet\n"));
|
return;
|
}
|
if (dhd_watchdog_ms == 0) {
|
DHD_ERROR(("FATAL: WATCHDOG is set to 0, timesync can't work properly \n"));
|
return;
|
}
|
/* schedule sending host time sync values to device */
|
ts->fwts2hsts_delay_wdcount = ts->fwts2hsts_delay / dhd_watchdog_ms;
|
if (ts->fwts2hsts_delay_wdcount == 0)
|
ts->fwts2hsts_delay_wdcount = 1;
|
}
|
|
static uint32
|
dhd_timesync_send_host_timestamping_config(dhd_ts_t *ts, bool inject_err)
|
{
|
ts_host_timestamping_config_t ts_config;
|
int ret_val;
|
|
if (ts->timesync_disabled) {
|
DHD_ERROR(("Timesync Disabled: Cannot send HOST TS config msg\n"));
|
return BCME_ERROR;
|
}
|
bzero(&ts_config, sizeof(ts_config));
|
|
ts_config.xtlv.id = BCMMSGBUF_HOST_TIMESTAMPING_CONFIG_TAG;
|
if (inject_err)
|
ts_config.xtlv.id = BCMMSGBUF_HOST_TS_BADTAG;
|
|
ts_config.xtlv.len = sizeof(ts_config) - sizeof(_bcm_xtlv_t);
|
ts_config.period_ms = ts->h_tsconf_period;
|
|
if (ts_config.period_ms) {
|
ts_config.flags |= FLAG_HOST_RESET;
|
ts_config.reset_cnt = ts->host_reset_cnt + 1;
|
}
|
|
if (ts->nodrop_config) {
|
ts_config.flags |= FLAG_CONFIG_NODROP;
|
ts_config.post_delay = TS_NODROP_CONFIG_TO;
|
} else {
|
ts_config.post_delay = TS_DROP_CONFIG_TO;
|
}
|
|
DHD_ERROR(("sending Host Timestamping Config: TLV (ID %d, LEN %d), period %d, seq %d\n",
|
ts_config.xtlv.id, ts_config.xtlv.len, ts_config.period_ms,
|
ts->host_ts_capture_cnt));
|
ret_val = dhd_prot_send_host_timestamp(ts->dhdp, (uchar *)&ts_config, sizeof(ts_config),
|
ts->host_ts_capture_cnt, ts->xt_id);
|
if (ret_val != 0) {
|
DHD_ERROR(("Fatal: Error sending HOST TS config msg to device: %d\n", ret_val));
|
return BCME_ERROR;
|
}
|
|
if (ts_config.period_ms) {
|
ts->host_reset_cnt++;
|
}
|
|
ts->pending_requests++;
|
ts->xt_ids.host_timestamping_config = ts->xt_id;
|
ts->xt_id++;
|
return BCME_OK;
|
}
|
|
static uint32
|
dhd_timesync_send_host_clock_selection(dhd_ts_t *ts)
|
{
|
ts_host_clock_sel_t ts_clk_sel;
|
int ret_val;
|
|
if (ts->timesync_disabled) {
|
DHD_ERROR(("Timesync Disabled: Cannot send HOST clock sel msg\n"));
|
return BCME_ERROR;
|
}
|
|
bzero(&ts_clk_sel, sizeof(ts_clk_sel));
|
|
ts_clk_sel.xtlv.id = BCMMSGBUF_HOST_CLOCK_SELECT_TAG;
|
ts_clk_sel.xtlv.len = sizeof(ts_clk_sel) - sizeof(_bcm_xtlv_t);
|
ts_clk_sel.min_clk_idx = ts->h_clkid_min;
|
ts_clk_sel.max_clk_idx = ts->h_clkid_max;
|
DHD_INFO(("sending Host ClockSel Config: TLV (ID %d, LEN %d), min %d, max %d, seq %d\n",
|
ts_clk_sel.xtlv.id, ts_clk_sel.xtlv.len, ts_clk_sel.min_clk_idx,
|
ts_clk_sel.max_clk_idx,
|
ts->host_ts_capture_cnt));
|
ret_val = dhd_prot_send_host_timestamp(ts->dhdp, (uchar *)&ts_clk_sel, sizeof(ts_clk_sel),
|
ts->host_ts_capture_cnt, ts->xt_id);
|
if (ret_val != 0) {
|
DHD_ERROR(("Fatal: Error sending HOST ClockSel msg to device: %d\n", ret_val));
|
return BCME_ERROR;
|
}
|
ts->xt_ids.host_clock_selection = ts->xt_id;
|
ts->xt_id++;
|
ts->pending_requests++;
|
return BCME_OK;
|
}
|
|
static uint32
|
dhd_timesync_send_host_clk_info(dhd_ts_t *ts)
|
{
|
ts_host_clock_info_t *host_clock_info;
|
uchar *clk_info_buffer;
|
uint32 clk_info_bufsize;
|
int ret_val;
|
|
if (ts->timesync_disabled) {
|
DHD_ERROR(("Timesync Disabled: Cannot send HOST clock config msg\n"));
|
return BCME_ERROR;
|
}
|
if (ts->host_ts_host_clk_info_buffer_in_use == TRUE) {
|
DHD_ERROR(("Host Ts Clock info buffer in Use\n"));
|
return BCME_ERROR;
|
}
|
clk_info_buffer = &ts->host_ts_host_clk_info_buffer[0];
|
clk_info_bufsize = sizeof(ts->host_ts_host_clk_info_buffer);
|
|
DHD_INFO(("clk_info_buf size %d, tlv_len %d, host clk_info_len %d\n",
|
clk_info_bufsize, ts->fw_tlv_len, (uint32)sizeof(*host_clock_info)));
|
|
if (clk_info_bufsize < sizeof(*host_clock_info)) {
|
DHD_ERROR(("clock_info_buf_size too small to fit host clock info %d, %d\n",
|
clk_info_bufsize, (uint32)sizeof(*host_clock_info)));
|
return BCME_ERROR;
|
}
|
|
host_clock_info = (ts_host_clock_info_t *)clk_info_buffer;
|
host_clock_info->xtlv.id = BCMMSGBUF_HOST_CLOCK_INFO_TAG;
|
host_clock_info->xtlv.len = sizeof(*host_clock_info) - sizeof(_bcm_xtlv_t);
|
/* OSL_GET_CYCLES */
|
host_clock_info->ticks.low = 0;
|
host_clock_info->ticks.high = 0;
|
/* OSL_SYS_UPTIME?? */
|
host_clock_info->ns.low = 0;
|
host_clock_info->ns.high = 0;
|
clk_info_buffer += (sizeof(*host_clock_info));
|
clk_info_bufsize -= sizeof(*host_clock_info);
|
|
/* copy the device clk config as that is the reference for this */
|
if (clk_info_bufsize < ts->fw_tlv_len) {
|
DHD_ERROR(("clock info buffer is small to fit dev clk info %d, %d\n",
|
clk_info_bufsize, ts->fw_tlv_len));
|
return BCME_ERROR;
|
}
|
bcopy(ts->fw_tlv, clk_info_buffer, ts->fw_tlv_len);
|
clk_info_bufsize -= ts->fw_tlv_len;
|
|
DHD_INFO(("sending Host TS msg Len %d, xt_id %d, host_ts_capture_count %d\n",
|
(uint32)(sizeof(ts->host_ts_host_clk_info_buffer) - clk_info_bufsize),
|
ts->xt_id, ts->host_ts_capture_cnt));
|
|
bcm_print_bytes("host ts", (uchar *)ts->host_ts_host_clk_info_buffer,
|
sizeof(ts->host_ts_host_clk_info_buffer) - clk_info_bufsize);
|
|
ret_val = dhd_prot_send_host_timestamp(ts->dhdp, (uchar *)ts->host_ts_host_clk_info_buffer,
|
sizeof(ts->host_ts_host_clk_info_buffer) - clk_info_bufsize,
|
ts->host_ts_capture_cnt, ts->xt_id);
|
if (ret_val != 0) {
|
DHD_ERROR(("Fatal: Error sending HOST ClockSel msg to device: %d\n", ret_val));
|
return BCME_ERROR;
|
}
|
ts->host_ts_host_clk_info_buffer_in_use = TRUE;
|
ts->xt_ids.host_clk_info = ts->xt_id;
|
ts->xt_id++;
|
ts->pending_requests++;
|
return BCME_OK;
|
}
|
|
static uint32
|
dhd_timesync_send_D2H_clk_correction(dhd_ts_t *ts)
|
{
|
ts_d2h_clock_correction_t ts_clk_crtion;
|
int ret_val;
|
|
if (ts->timesync_disabled) {
|
DHD_ERROR(("Timesync Disabled: Cannot send d2h clock correction msg\n"));
|
return BCME_ERROR;
|
}
|
|
bzero(&ts_clk_crtion, sizeof(ts_clk_crtion));
|
|
/* XXX: should this be sending for all the clock sources */
|
|
ts_clk_crtion.xtlv.id = BCMMSGBUF_D2H_CLOCK_CORRECTION_TAG;
|
ts_clk_crtion.xtlv.len = sizeof(ts_clk_crtion) - sizeof(_bcm_xtlv_t);
|
ts_clk_crtion.clk_id = ts->h_clkid_max;
|
ts_clk_crtion.m.low = ts->correction_m.low;
|
ts_clk_crtion.m.high = ts->correction_m.high;
|
ts_clk_crtion.b.low = ts->correction_b.low;
|
ts_clk_crtion.b.high = ts->correction_b.high;
|
|
DHD_INFO(("sending D2H Correction: ID %d, LEN %d, clkid %d, m %d:%d, b %d:%d, seq %d\n",
|
ts_clk_crtion.xtlv.id, ts_clk_crtion.xtlv.len, ts_clk_crtion.clk_id,
|
ts_clk_crtion.m.high,
|
ts_clk_crtion.m.low,
|
ts_clk_crtion.b.high,
|
ts_clk_crtion.b.low,
|
ts->host_ts_capture_cnt));
|
|
ret_val = dhd_prot_send_host_timestamp(ts->dhdp, (uchar *)&ts_clk_crtion,
|
sizeof(ts_clk_crtion), ts->host_ts_capture_cnt, ts->xt_id);
|
if (ret_val != 0) {
|
DHD_ERROR(("Fatal: Error sending HOST ClockSel msg to device: %d\n", ret_val));
|
return BCME_ERROR;
|
}
|
ts->xt_ids.d2h_clk_correction = ts->xt_id;
|
ts->xt_id++;
|
ts->pending_requests++;
|
return BCME_OK;
|
}
|
|
bool
|
dhd_timesync_delay_post_bufs(dhd_pub_t *dhdp)
|
{
|
return (dhdp->ts->fwts2hsts_delay != 0);
|
}
|
|
bool
|
dhd_timesync_watchdog(dhd_pub_t *dhdp)
|
{
|
dhd_ts_t *ts = dhdp->ts;
|
|
if (ts == NULL)
|
return FALSE;
|
|
ts->last_ts_watchdog_time = OSL_LOCALTIME_NS();
|
ts->ts_watchdog_calls++;
|
|
/* XXX: this is relying the watchdog to be running..which may not hold good */
|
if (ts->fwts2hsts_delay_wdcount) {
|
ts->fwts2hsts_delay_wdcount--;
|
if (ts->fwts2hsts_delay != 0 && dhdp->busstate == DHD_BUS_DATA &&
|
(ts->fwts2hsts_delay_wdcount == 0)) {
|
/* see if we need to send the host clock info */
|
dhd_timesync_send_host_clk_info(ts);
|
dhd_msgbuf_delay_post_ts_bufs(dhdp);
|
}
|
}
|
return FALSE;
|
}
|
|
static void
|
dhd_timesync_log_timestamp_item(dhd_ts_log_ts_t *tsl, uint16 flowid, uint8 intf,
|
uint32 ts_low, uint32 ts_high, dhd_pkt_parse_t *pkt)
|
{
|
tsl->ts_log[tsl->cur_idx].ts_low = ts_low;
|
tsl->ts_log[tsl->cur_idx].ts_high = ts_high;
|
tsl->ts_log[tsl->cur_idx].intf = intf;
|
tsl->ts_log[tsl->cur_idx].proto = pkt->proto;
|
tsl->ts_log[tsl->cur_idx].t1 = pkt->t1;
|
tsl->ts_log[tsl->cur_idx].t2 = pkt->t2;
|
tsl->cur_idx++;
|
if (tsl->cur_idx == tsl->max_idx)
|
tsl->cur_idx = 0;
|
}
|
|
void
|
dhd_timesync_log_tx_timestamp(dhd_ts_t *ts, uint16 flowid, uint8 intf,
|
uint32 ts_low, uint32 ts_high, dhd_pkt_parse_t *pkt)
|
{
|
if (ts != NULL) {
|
dhd_timesync_log_timestamp_item(&ts->tx_timestamps, flowid, intf,
|
ts_low, ts_high, pkt);
|
}
|
}
|
|
void
|
dhd_timesync_log_rx_timestamp(dhd_ts_t *ts, uint8 intf, uint32 ts_low, uint32 ts_high,
|
dhd_pkt_parse_t *pkt)
|
{
|
if (ts != NULL) {
|
dhd_timesync_log_timestamp_item(&ts->rx_timestamps, 0, intf,
|
ts_low, ts_high, pkt);
|
}
|
}
|
|
void
|
dhd_timesync_control(dhd_pub_t *dhdp, bool disabled)
|
{
|
dhd_ts_t *ts;
|
if (dhdp == NULL)
|
return;
|
|
ts = dhdp->ts;
|
if (ts != NULL) {
|
if (disabled) {
|
DHD_ERROR(("resetting the timesync counter, current(%d)\n",
|
ts->fw_ts_capture_cnt));
|
|
ts->fw_ts_capture_cnt = 0;
|
|
/* Suspend case: Disable timesync after the config message */
|
if ((ts->active_ipc_version >= 7) && (ts->h_tsconf_period != 0)) {
|
uint32 tsconf_period;
|
|
tsconf_period = ts->h_tsconf_period;
|
ts->h_tsconf_period = 0;
|
|
dhd_timesync_send_host_timestamping_config(ts, FALSE);
|
ts->h_tsconf_period = tsconf_period;
|
}
|
ts->timesync_disabled = TRUE;
|
ts->suspend_req++;
|
} else {
|
/* Resume case: Enable timesync before the config message */
|
DHD_ERROR(("enabling the timesync counter, current(%d)\n",
|
ts->fw_ts_capture_cnt));
|
|
ts->timesync_disabled = FALSE;
|
ts->resume_req++;
|
|
if ((ts->active_ipc_version >= 7) && (ts->h_tsconf_period != 0))
|
dhd_timesync_send_host_timestamping_config(ts, FALSE);
|
}
|
}
|
/* XXX: may be all the other internal iovar calls should check for disabled state */
|
}
|
