andy/kunlun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
kunlun/plc/halmac/channel_tools/mac_mm_sniffer.c
andy c756587541 初始提交
2024-09-28 14:24:04 +08:00

546 lines
17 KiB
C
Executable File
Raw Permalink Blame History

/****************************************************************************
Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.
This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
be copied by any method or incorporated into another program without
the express written consent of Aerospace C.Power. This Information or any portion
thereof remains the property of Aerospace C.Power. The Information contained herein
is believed to be accurate and Aerospace C.Power assumes no responsibility or
liability for its use in any way and conveys no license or title under
any patent or copyright and makes no representation or warranty that this
Information is free from patent or copyright infringement.
****************************************************************************/
#include "mac_mm_sniffer.h"
#include "iot_pkt.h"
#include "mac_pdev.h"
#include "mac_rx_hw.h"
#include "mac_rx_buf_ring.h"
#include "iot_eth.h"
#include "iot_ntoh_api.h"
#include "mac_data_api.h"
#include "iot_crypto_aes_api.h"
#include "mac_mm_sniffer_key.h"
#include "mac_hwq_mgr.h"
#include "mpdu_header.h"
#include "iot_io.h"
#include "mac_stream.h"
#include "mac_peer.h"
#include "hw_phy_api.h"
#include "iot_board_api.h"
#include "rf_hw_tonemap.h"
#if HPLC_RF_DEV_SUPPORT
#include "rf_rx_desc_reg_api.h"
#endif
#if (MAC_MM_SNIFFER_MODE)
static mac_mm_sniffer_t *g_sniffer_ctxt = NULL;
#if MAC_MM_SNIFFER_ENC_ENABLE
static void mac_crypt_aes_ecb(iot_pkt_t *input, iot_pkt_t *output)
{
uint32_t data_len = iot_pkt_data_len(input);
uint32_t ase_date_len = \
(data_len & 0xf) ? ((data_len & 0xfffffff0) + 0x10) : data_len;
uint32_t avl_len = iot_pkt_data_len(output) + \
iot_pkt_block_len(output, IOT_PKT_BLOCK_TAIL);
uint8_t *ptr_in = iot_pkt_data(input);
uint8_t *ptr_out = iot_pkt_data(output);
if (avl_len < ase_date_len) {
IOT_ASSERT(0);
}
uint32_t offset = 0;
uint32_t len = 0;
while (data_len > 0) {
if(data_len > 16){
len = 16;
} else {
len = data_len;
}
iot_crypto_aes_ecb(IOT_AES_ENCRYPT, len, ptr_in + offset, ptr_out + offset);
data_len -= len;
offset += len;
}
iot_pkt_set_tail(output, ptr_out + ase_date_len);
}
#else
static void mac_crypt_aes_ecb(iot_pkt_t *input, iot_pkt_t *output)
{
(void)input;
(void)output;
}
#endif /* MAC_MM_SNIFFER_ENC_ENABLE */
static void mac_send_frame_to_host(mac_mm_sniffer_t *sniffer_ctxt,
iot_pkt_t *pkt, uint16_t type)
{
uint8_t *tmp = NULL;
if (type < MAC_TO_ETH_TYPE_START || type > MAC_TO_ETH_TYPE_END) {
IOT_ASSERT(0);
}
/* change byte order for ETH */
sniffer_ctxt->mac_to_eth_header.eth_type = iot_htons(type);
tmp = iot_pkt_push(pkt, MAC_SNIFFER_HDR_RSV_LEN);
IOT_ASSERT(tmp != NULL);
os_mem_cpy(tmp, &sniffer_ctxt->mac_to_eth_header, \
MAC_SNIFFER_HDR_RSV_LEN);
sniffer_ctxt->tx_pkt_ls.next = NULL;
sniffer_ctxt->tx_pkt_ls.pkt = pkt;
if (sniffer_ctxt->uart_handle) {
iot_uart_send(sniffer_ctxt->uart_handle, pkt, NULL);
} else {
iot_eth_send_packet(&sniffer_ctxt->tx_pkt_ls);
}
return;
}
#if HPLC_RF_DEV_SUPPORT
#if ((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU) || \
((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU_UART)))
static uint32_t mac_rf_mm_sniffer_reorder_msdu(
mac_mm_sniffer_t *sniffer_ctxt, iot_pkt_t *rx_buf)
{
IOT_ASSERT(rx_buf != NULL);
uint32_t pbsz;
uint32_t proto = PHY_PROTO_TYPE_GET();
rx_fc_msg_t rx_fc_msg = { 0 };
rf_rx_mpdu_start *mpdu_st;
rf_rx_pb_start *pb_st;
rf_rx_pb_end *pb_ed;
iot_pkt_t *tmp_buf;
mac_stream_t *rx_stream = (mac_stream_t *)sniffer_ctxt->rx_ctxt.rf_rx_stream;
uint8_t *tmp = iot_pkt_block_ptr(rx_buf, IOT_PKT_BLOCK_DATA);
mpdu_st = (rf_rx_mpdu_start *)(tmp + MPDU_START_OFFSET);
pb_st = (rf_rx_pb_start *)(tmp + PB_START_OFFSET);
pb_ed = (rf_rx_pb_end *)(tmp + PB_END_OFFSET);
mac_rf_get_rx_frm_msg_from_fc(proto,
mac_rf_rx_mpdu_st_get_phr_addr(mpdu_st), &rx_fc_msg);
if (pb_ed->rx_pb_crc_err == 1) {
iot_printf("rf rx sof pb err\n");
return ERR_OK;
}
pbsz = phy_rf_get_pbsz(rx_fc_msg.rf_pb_sz_idx);
if (rx_fc_msg.dst_tei != sniffer_ctxt->rx_ctxt.last_rx_dtei ||
rx_fc_msg.src_tei != sniffer_ctxt->rx_ctxt.last_rx_stei ||
rx_fc_msg.nid != sniffer_ctxt->rx_ctxt.last_rx_nid ||
rx_fc_msg.lid != sniffer_ctxt->rx_ctxt.last_rx_lid) {
reorder_buf_flush(&rx_stream->msdu.rx.reorder_buf);
sniffer_ctxt->rx_ctxt.last_rx_dtei = rx_fc_msg.dst_tei;
sniffer_ctxt->rx_ctxt.last_rx_stei = rx_fc_msg.src_tei;
sniffer_ctxt->rx_ctxt.last_rx_nid = rx_fc_msg.nid;
sniffer_ctxt->rx_ctxt.last_rx_lid = rx_fc_msg.lid;
}
tmp_buf = iot_pkt_alloc(iot_pkt_data_len(rx_buf), PLC_MAC_RX_HW_MID);
IOT_ASSERT(tmp_buf);
iot_pkt_cpy(tmp_buf, rx_buf);
reorder_buf_insert(&rx_stream->msdu.rx.reorder_buf,
tmp_buf, pb_st->ssn, pb_st->msdu_start, pb_st->msdu_end,
rx_fc_msg.retry, pbsz);
return ERR_OK;
}
#endif /* ((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU) || \
((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU_UART))) */
/* rf mpdu rx cb */
static uint32_t mac_rf_mm_sniffer_rx_mpdu_handler(void *arg,
iot_pkt_t *rx_buf)
{
(void)arg;
#if PLC_MAC_TX_DEBUG_LOG
iot_printf("%s\n", __FUNCTION__);
#endif
IOT_ASSERT(rx_buf && arg);
uint8_t *tmp_ptr = NULL;
rf_rx_mpdu_start *mpdu_st;
uint32_t delimiter = 0;
iot_pkt_t *tmp_pkt = NULL;
uint16_t fc_len = mac_get_mpdu_fc_len(PHY_PROTO_TYPE_GET());
uint32_t ret = CON_PKT_NOT_CARE;
tmp_ptr = iot_pkt_block_ptr(rx_buf, IOT_PKT_BLOCK_DATA);
mpdu_st = (rf_rx_mpdu_start *)(tmp_ptr + MPDU_START_OFFSET);
delimiter = mac_get_delimi_from_fc(PHY_PROTO_TYPE_GET(),
mac_rf_rx_mpdu_st_get_phr_addr(mpdu_st));
if (delimiter == FC_DELIM_SOF) {
#if ((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU) || \
((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU_UART)))
/* reorder msdu */
if (ERR_OK == mac_rf_mm_sniffer_reorder_msdu(g_sniffer_ctxt, rx_buf)) {
rx_buf = NULL;
}
#endif
if (rx_buf) {
iot_pkt_free(rx_buf);
}
ret = CON_PKT_FREE;
goto out;
}
tmp_pkt = iot_pkt_alloc(iot_pkt_data_len(rx_buf) + fc_len +
MAC_SNIFFER_HDR_RSV_LEN + MAC_SNIFFER_AES_RSV_LEN, PLC_MAC_RX_HW_MID);
IOT_ASSERT(tmp_pkt);
tmp_ptr = iot_pkt_put(tmp_pkt, iot_pkt_data_len(rx_buf) + fc_len);
IOT_ASSERT(tmp_ptr);
tmp_ptr = iot_pkt_reserve(tmp_pkt, MAC_SNIFFER_HDR_RSV_LEN);
IOT_ASSERT(tmp_ptr);
os_mem_cpy(tmp_ptr, iot_pkt_data(rx_buf), PB_PAYLOAD_OFFSET);
os_mem_cpy(tmp_ptr + PB_PAYLOAD_OFFSET,
mac_rf_rx_mpdu_st_get_phr_addr(mpdu_st), fc_len);
os_mem_cpy(tmp_ptr + PB_PAYLOAD_OFFSET + fc_len,
iot_pkt_data(rx_buf) + PB_PAYLOAD_OFFSET,
iot_pkt_data_len(rx_buf) - PB_PAYLOAD_OFFSET);
mac_crypt_aes_ecb(tmp_pkt, tmp_pkt);
mac_send_frame_to_host(g_sniffer_ctxt, tmp_pkt, MAC_TO_ETH_TYPE_RF_PB);
out:
return ret;
}
void mac_rf_sniffer_rx_ctxt_init(mac_mm_sniffer_t *sniffer_ctxt)
{
IOT_ASSERT(sniffer_ctxt);
mac_stream_t *rf_stream = NULL;
mac_vdev_t *dft_vdev = (mac_vdev_t*)sniffer_ctxt->ref_vdev;
mac_peer_t *self_peer = dft_vdev->self_peer;
IOT_ASSERT(self_peer);
rf_stream = find_stream(self_peer, PLC_NID_INVALID, self_peer->tei,
0, IS_RX_STREAM, IS_RF_STREAM);
if (!rf_stream) {
mac_stream_alloc(self_peer, IS_RX_STREAM, 0, IS_RF_STREAM, &rf_stream);
IOT_ASSERT(rf_stream);
}
sniffer_ctxt->rx_ctxt.rf_rx_stream = rf_stream;
}
void mac_rf_sniffer_ring_init()
{
mac_rf_pdev_t *mac_rf_pdev = get_rf_pdev_ptr(PLC_PDEV_ID, RF_PDEV_ID);
if (mac_rf_pdev) {
rx_buf_ring_set_callback(&mac_rf_pdev->ring_hdl,
mac_rf_mm_sniffer_rx_mpdu_handler);
}
}
#else /* HPLC_RF_DEV_SUPPORT */
void mac_rf_sniffer_rx_ctxt_init(mac_mm_sniffer_t *sniffer_ctxt)
{
(void)sniffer_ctxt;
}
void mac_rf_sniffer_ring_init()
{
}
#endif /* HPLC_RF_DEV_SUPPORT */
uint32_t mac_mm_sniffer_rx_msdu(uint32_t proto, iot_pkt_t *msdu_buf)
{
#if PLC_MAC_TX_DEBUG_LOG
iot_printf("%s\n", __FUNCTION__);
#endif
uint8_t *tmp_ptr = NULL;
uint16_t type = 0;
iot_pkt_t *tmp_pkt = iot_pkt_alloc(iot_pkt_data_len(msdu_buf) + \
sizeof(mac_rx_info_t) + MAC_SNIFFER_HDR_RSV_LEN + MAC_SNIFFER_AES_RSV_LEN, \
PLC_MAC_RX_HW_MID);
IOT_ASSERT(tmp_pkt);
tmp_ptr = iot_pkt_put(tmp_pkt, iot_pkt_data_len(msdu_buf) + \
sizeof(mac_rx_info_t));
IOT_ASSERT(tmp_ptr);
tmp_ptr = iot_pkt_reserve(tmp_pkt, MAC_SNIFFER_HDR_RSV_LEN);
IOT_ASSERT(tmp_ptr);
os_mem_cpy(tmp_ptr, iot_pkt_data(msdu_buf) - sizeof(mac_rx_info_t), \
iot_pkt_data_len(msdu_buf) + sizeof(mac_rx_info_t));
if (proto == PLC_PROTO_TYPE_SG) {
#if SUPPORT_IEEE_1901
type = MAC_TO_ETH_TYPE_MSDU_1901;
#else
type = MAC_TO_ETH_TYPE_MSDU_GW;
#endif /* SUPPORT_IEEE_1901 */
} else if (proto == PLC_PROTO_TYPE_SPG) {
type = MAC_TO_ETH_TYPE_MSDU_NW;
}
mac_crypt_aes_ecb(tmp_pkt, tmp_pkt);
mac_send_frame_to_host(g_sniffer_ctxt, tmp_pkt, type);
return ERR_OK;
}
#if ((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU) || \
((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU_UART)))
static uint32_t mac_mm_sniffer_reorder_msdu(
mac_mm_sniffer_t *sniffer_ctxt, iot_pkt_t *rx_buf)
{
IOT_ASSERT(rx_buf != NULL);
uint32_t proto = PHY_PROTO_TYPE_GET();
uint32_t pbsz, ret;
rx_fc_msg_t rx_fc_msg = { 0 };
rx_mpdu_start *mpdu_st;
rx_pb_start *pb_st;
rx_pb_end *pb_ed;
iot_pkt_t *tmp_buf;
mac_stream_t *rx_stream = (mac_stream_t *)sniffer_ctxt->rx_ctxt.rx_stream;
uint8_t *tmp = iot_pkt_block_ptr(rx_buf, IOT_PKT_BLOCK_DATA);
mpdu_st = (rx_mpdu_start *)(tmp + MPDU_START_OFFSET);
pb_st = (rx_pb_start *)(tmp + PB_START_OFFSET);
pb_ed = (rx_pb_end *)(tmp + PB_END_OFFSET);
mac_get_rx_frm_msg_from_fc(PHY_PROTO_TYPE_GET(), \
mac_rx_mpdu_st_get_fc_addr(mpdu_st), &rx_fc_msg);
if (pb_ed->rx_pb_crc_err == 1) {
iot_printf("rx sof pb err\n");
return ERR_OK;
}
/* fix spg msdu_start/msdu_end */
if (PLC_PROTO_TYPE_SPG == proto) {
/**
* sof msdu_start and msdu_end
* fields always 0 in SPG protocol
*/
if (0 == mac_rx_pb_st_get_ssn(pb_st)) {
mac_rx_pb_st_set_msdu_start(pb_st, 1);
}
/* spg must be used long mpdu tx */
if (mac_rx_pb_st_get_last_pb(pb_st)
&& (mac_rx_mpdu_st_get_rx_pb_num(mpdu_st) \
== (mac_rx_pb_st_get_ssn(pb_st) + 1))){
mac_rx_pb_st_set_msdu_end(pb_st, 1);
}
}
ret = phy_get_pb_size(proto, rx_fc_msg.tmi, rx_fc_msg.tmi_ext, &pbsz);
if (ret!= ERR_OK) {
return ERR_FAIL;
}
if (rx_fc_msg.dst_tei != sniffer_ctxt->rx_ctxt.last_rx_dtei || \
rx_fc_msg.src_tei != sniffer_ctxt->rx_ctxt.last_rx_stei || \
rx_fc_msg.nid != sniffer_ctxt->rx_ctxt.last_rx_nid || \
rx_fc_msg.lid != sniffer_ctxt->rx_ctxt.last_rx_lid) {
reorder_buf_flush(&rx_stream->msdu.rx.reorder_buf);
sniffer_ctxt->rx_ctxt.last_rx_dtei = rx_fc_msg.dst_tei;
sniffer_ctxt->rx_ctxt.last_rx_stei = rx_fc_msg.src_tei;
sniffer_ctxt->rx_ctxt.last_rx_nid = rx_fc_msg.nid;
sniffer_ctxt->rx_ctxt.last_rx_lid = rx_fc_msg.lid;
}
tmp_buf = iot_pkt_alloc(iot_pkt_data_len(rx_buf), PLC_MAC_RX_HW_MID);
IOT_ASSERT(tmp_buf);
iot_pkt_cpy(tmp_buf, rx_buf);
reorder_buf_insert(&rx_stream->msdu.rx.reorder_buf, \
tmp_buf, pb_st->ssn, pb_st->msdu_start, pb_st->msdu_end, \
rx_fc_msg.retry, pbsz);
return ERR_OK;
}
#endif /* ((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU) || \
((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU_UART))) */
/* mpdu rx cb */
static uint32_t mac_mm_sniffer_rx_mpdu_handler(void *arg,
iot_pkt_t *rx_buf)
{
(void)arg;
#if PLC_MAC_TX_DEBUG_LOG
iot_printf("%s\n", __FUNCTION__);
#endif
IOT_ASSERT(rx_buf && arg);
uint8_t *tmp_ptr = NULL;
rx_mpdu_start *mpdu_st;
uint32_t delimiter = 0;
iot_pkt_t *tmp_pkt = NULL;
uint16_t fc_len = mac_get_mpdu_fc_len(PHY_PROTO_TYPE_GET());
uint32_t ret = CON_PKT_NOT_CARE;
uint16_t type;
tmp_ptr = iot_pkt_block_ptr(rx_buf, IOT_PKT_BLOCK_DATA);
mpdu_st = (rx_mpdu_start *)(tmp_ptr + MPDU_START_OFFSET);
delimiter = mac_get_delimi_from_fc(PHY_PROTO_TYPE_GET(),
mac_rx_mpdu_st_get_fc_addr(mpdu_st));
if (delimiter == FC_DELIM_SOF) {
#if ((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU) || \
((MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU_UART)))
/* reorder msdu */
if (ERR_OK == mac_mm_sniffer_reorder_msdu(g_sniffer_ctxt, rx_buf)) {
rx_buf = NULL;
}
#endif
if (rx_buf) {
iot_pkt_free(rx_buf);
}
ret = CON_PKT_FREE;
goto out;
}
tmp_pkt = iot_pkt_alloc(iot_pkt_data_len(rx_buf) + fc_len +
MAC_SNIFFER_HDR_RSV_LEN + MAC_SNIFFER_AES_RSV_LEN, PLC_MAC_RX_HW_MID);
IOT_ASSERT(tmp_pkt);
tmp_ptr = iot_pkt_put(tmp_pkt, iot_pkt_data_len(rx_buf) + fc_len);
IOT_ASSERT(tmp_ptr);
tmp_ptr = iot_pkt_reserve(tmp_pkt, MAC_SNIFFER_HDR_RSV_LEN);
IOT_ASSERT(tmp_ptr);
#if SUPPORT_IEEE_1901
mac_fc_sg_to_i1901(PHY_PROTO_TYPE_GET(), mpdu_st);
#endif
os_mem_cpy(tmp_ptr, iot_pkt_data(rx_buf), PB_PAYLOAD_OFFSET);
os_mem_cpy(tmp_ptr + PB_PAYLOAD_OFFSET,
mac_rx_mpdu_st_get_fc_addr(mpdu_st), fc_len);
os_mem_cpy(tmp_ptr + PB_PAYLOAD_OFFSET + fc_len,
iot_pkt_data(rx_buf) + PB_PAYLOAD_OFFSET,
iot_pkt_data_len(rx_buf) - PB_PAYLOAD_OFFSET);
mac_crypt_aes_ecb(tmp_pkt, tmp_pkt);
#if SUPPORT_IEEE_1901
type = MAC_TO_ETH_TYPE_PB_1901;
#else
type = MAC_TO_ETH_TYPE_PB;
#endif /* SUPPORT_IEEE_1901 */
mac_send_frame_to_host(g_sniffer_ctxt, tmp_pkt, type);
out:
return ret;
}
static void mac_sniffer_rx_ctxt_init(mac_mm_sniffer_t *sniffer_ctxt)
{
IOT_ASSERT(sniffer_ctxt);
mac_stream_t *plc_stream = NULL;
mac_vdev_t *dft_vdev = (mac_vdev_t*)sniffer_ctxt->ref_vdev;
mac_peer_t *self_peer = dft_vdev->self_peer;
IOT_ASSERT(self_peer);
plc_stream = find_stream(self_peer, PLC_NID_INVALID,
self_peer->tei, 0, IS_RX_STREAM, IS_PLC_STREAM);
if (!plc_stream) {
mac_stream_alloc(self_peer, IS_RX_STREAM, 0,
IS_PLC_STREAM, &plc_stream);
IOT_ASSERT(plc_stream);
}
sniffer_ctxt->rx_ctxt.rx_stream = plc_stream;
mac_rf_sniffer_rx_ctxt_init(sniffer_ctxt);
}
#if (MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU_UART)
static void mac_sniffer_uart_recv(uint8_t* buffer, uint32_t buffer_len,
bool_t is_full_frame, uint32_t invalid_data_len)
{
(void)buffer;
(void)buffer_len;
(void)is_full_frame;
(void)invalid_data_len;
}
static void mac_sniffer_uart_init(mac_mm_sniffer_t *sniffer_ctxt)
{
uint8_t port = iot_board_get_uart(UART_METER_PORT);
if (sniffer_ctxt->uart_handle) {
return;
}
sniffer_ctxt->uart_handle = iot_uart_open(port, mac_sniffer_uart_recv,
2048, NULL);
if (sniffer_ctxt->uart_handle == NULL) {
iot_printf("%s open uart port: %d fail\n", __FUNCTION__, port);
IOT_ASSERT(0);
}
iot_uart_set_config(sniffer_ctxt->uart_handle, 1000000,
IOT_UART_PARITY_NONE, 8, 1);
}
#else
static void mac_sniffer_uart_init(mac_mm_sniffer_t *sniffer_ctxt)
{
sniffer_ctxt->uart_handle = NULL;
}
#endif /* (MAC_MM_SNIFFER_MODE == MAC_SNIFFER_TYPE_MSDU_UART) */
void mac_mm_sniffer_init(void *vdev)
{
IOT_ASSERT(vdev);
mac_vdev_t *vdev_ptr = (mac_vdev_t*)vdev;
mac_pdev_t *pdev_ptr = g_mac_pdev[vdev_ptr->ref_pdev_id];
if(!g_sniffer_ctxt) {
g_sniffer_ctxt = os_mem_malloc(PLC_MAC_COMMON_MID,
sizeof(*g_sniffer_ctxt));
}
IOT_ASSERT(g_sniffer_ctxt);
rx_buf_ring_set_callback(&pdev_ptr->ring_hdl,
mac_mm_sniffer_rx_mpdu_handler);
mac_rf_sniffer_ring_init();
g_sniffer_ctxt->ref_vdev = vdev;
mac_sniffer_uart_init(g_sniffer_ctxt);
g_sniffer_ctxt->mac_to_eth_header.dst_mac[0] = 0x11;
g_sniffer_ctxt->mac_to_eth_header.dst_mac[1] = 0x22;
g_sniffer_ctxt->mac_to_eth_header.dst_mac[2] = 0x33;
g_sniffer_ctxt->mac_to_eth_header.dst_mac[3] = 0x44;
g_sniffer_ctxt->mac_to_eth_header.dst_mac[4] = 0x55;
g_sniffer_ctxt->mac_to_eth_header.dst_mac[5] = 0x66;
g_sniffer_ctxt->mac_to_eth_header.src_mac[0] = 0x55;
g_sniffer_ctxt->mac_to_eth_header.src_mac[1] = 0x66;
g_sniffer_ctxt->mac_to_eth_header.src_mac[2] = 0x77;
g_sniffer_ctxt->mac_to_eth_header.src_mac[3] = 0x88;
g_sniffer_ctxt->mac_to_eth_header.src_mac[4] = 0x99;
g_sniffer_ctxt->mac_to_eth_header.src_mac[5] = 0xAA;
g_sniffer_ctxt->mac_to_eth_header.eth_type = 0xFFFF;
g_sniffer_ctxt->tx_pkt_ls.next = NULL;
g_sniffer_ctxt->tx_pkt_ls.pkt = NULL;
mac_sniffer_rx_ctxt_init(g_sniffer_ctxt);
iot_crypto_aes_setkey_enc(aes_key, 256);
mac_block_all_tx_ena(&pdev_ptr->hwq_hdl, true);
/* disable sw agc */
phy_swagc_set(false);
return;
}
#endif /* MAC_MM_SNIFFER_MODE */
Reference in New Issue View Git Blame Copy Permalink