mirror of
https://github.com/morrownr/8821cu-20210916.git
synced 2024-11-19 20:10:08 +00:00
916 lines
29 KiB
C
916 lines
29 KiB
C
/******************************************************************************
|
|
*
|
|
* Copyright(c) 2016 - 2019 Realtek Corporation. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of version 2 of the GNU General Public License as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include "halmac_init_88xx.h"
|
|
#include "halmac_88xx_cfg.h"
|
|
#include "halmac_fw_88xx.h"
|
|
#include "halmac_common_88xx.h"
|
|
#include "halmac_cfg_wmac_88xx.h"
|
|
#include "halmac_efuse_88xx.h"
|
|
#include "halmac_mimo_88xx.h"
|
|
#include "halmac_bb_rf_88xx.h"
|
|
#if HALMAC_SDIO_SUPPORT
|
|
#include "halmac_sdio_88xx.h"
|
|
#endif
|
|
#if HALMAC_USB_SUPPORT
|
|
#include "halmac_usb_88xx.h"
|
|
#endif
|
|
#if HALMAC_PCIE_SUPPORT
|
|
#include "halmac_pcie_88xx.h"
|
|
#endif
|
|
#include "halmac_gpio_88xx.h"
|
|
#include "halmac_flash_88xx.h"
|
|
|
|
#if HALMAC_8822B_SUPPORT
|
|
#include "halmac_8822b/halmac_init_8822b.h"
|
|
#endif
|
|
|
|
#if HALMAC_8821C_SUPPORT
|
|
#include "halmac_8821c/halmac_init_8821c.h"
|
|
#endif
|
|
|
|
#if HALMAC_8822C_SUPPORT
|
|
#include "halmac_8822c/halmac_init_8822c.h"
|
|
#endif
|
|
|
|
#if HALMAC_8812F_SUPPORT
|
|
#include "halmac_8812f/halmac_init_8812f.h"
|
|
#endif
|
|
|
|
#if HALMAC_PLATFORM_TESTPROGRAM
|
|
#include "halmisc_api_88xx.h"
|
|
#endif
|
|
|
|
#if HALMAC_88XX_SUPPORT
|
|
|
|
#define PLTFM_INFO_MALLOC_MAX_SIZE 16384
|
|
#define PLTFM_INFO_RSVD_PG_SIZE 16384
|
|
#define DLFW_PKT_MAX_SIZE 8192 /* need multiple of 2 */
|
|
|
|
static void
|
|
init_state_machine_88xx(struct halmac_adapter *adapter);
|
|
|
|
static enum halmac_ret_status
|
|
verify_io_88xx(struct halmac_adapter *adapter);
|
|
|
|
static enum halmac_ret_status
|
|
verify_send_rsvd_page_88xx(struct halmac_adapter *adapter);
|
|
|
|
void
|
|
init_adapter_param_88xx(struct halmac_adapter *adapter)
|
|
{
|
|
adapter->api_registry.rx_exp_en = 1;
|
|
adapter->api_registry.la_mode_en = 1;
|
|
adapter->api_registry.cfg_drv_rsvd_pg_en = 1;
|
|
adapter->api_registry.sdio_cmd53_4byte_en = 1;
|
|
|
|
adapter->efuse_map = (u8 *)NULL;
|
|
adapter->efuse_map_valid = 0;
|
|
adapter->efuse_end = 0;
|
|
|
|
adapter->dlfw_pkt_size = DLFW_PKT_MAX_SIZE;
|
|
adapter->pltfm_info.malloc_size = PLTFM_INFO_MALLOC_MAX_SIZE;
|
|
adapter->pltfm_info.rsvd_pg_size = PLTFM_INFO_RSVD_PG_SIZE;
|
|
|
|
adapter->cfg_param_info.buf = NULL;
|
|
adapter->cfg_param_info.buf_wptr = NULL;
|
|
adapter->cfg_param_info.num = 0;
|
|
adapter->cfg_param_info.full_fifo_mode = 0;
|
|
adapter->cfg_param_info.buf_size = 0;
|
|
adapter->cfg_param_info.avl_buf_size = 0;
|
|
adapter->cfg_param_info.offset_accum = 0;
|
|
adapter->cfg_param_info.value_accum = 0;
|
|
|
|
adapter->ch_sw_info.buf = NULL;
|
|
adapter->ch_sw_info.buf_wptr = NULL;
|
|
adapter->ch_sw_info.extra_info_en = 0;
|
|
adapter->ch_sw_info.buf_size = 0;
|
|
adapter->ch_sw_info.avl_buf_size = 0;
|
|
adapter->ch_sw_info.total_size = 0;
|
|
adapter->ch_sw_info.ch_num = 0;
|
|
|
|
adapter->drv_info_size = 0;
|
|
adapter->tx_desc_transfer = 0;
|
|
|
|
adapter->txff_alloc.tx_fifo_pg_num = 0;
|
|
adapter->txff_alloc.acq_pg_num = 0;
|
|
adapter->txff_alloc.rsvd_boundary = 0;
|
|
adapter->txff_alloc.rsvd_drv_addr = 0;
|
|
adapter->txff_alloc.rsvd_h2c_info_addr = 0;
|
|
adapter->txff_alloc.rsvd_h2cq_addr = 0;
|
|
adapter->txff_alloc.rsvd_cpu_instr_addr = 0;
|
|
adapter->txff_alloc.rsvd_fw_txbuf_addr = 0;
|
|
adapter->txff_alloc.pub_queue_pg_num = 0;
|
|
adapter->txff_alloc.high_queue_pg_num = 0;
|
|
adapter->txff_alloc.low_queue_pg_num = 0;
|
|
adapter->txff_alloc.normal_queue_pg_num = 0;
|
|
adapter->txff_alloc.extra_queue_pg_num = 0;
|
|
|
|
adapter->txff_alloc.la_mode = HALMAC_LA_MODE_DISABLE;
|
|
adapter->txff_alloc.rx_fifo_exp_mode =
|
|
HALMAC_RX_FIFO_EXPANDING_MODE_DISABLE;
|
|
|
|
adapter->hw_cfg_info.chk_security_keyid = 0;
|
|
adapter->hw_cfg_info.acq_num = 8;
|
|
adapter->hw_cfg_info.page_size = TX_PAGE_SIZE_88XX;
|
|
adapter->hw_cfg_info.tx_align_size = TX_ALIGN_SIZE_88XX;
|
|
adapter->hw_cfg_info.txdesc_size = TX_DESC_SIZE_88XX;
|
|
adapter->hw_cfg_info.rxdesc_size = RX_DESC_SIZE_88XX;
|
|
adapter->hw_cfg_info.rx_desc_fifo_size = 0;
|
|
|
|
adapter->sdio_cmd53_4byte = HALMAC_SDIO_CMD53_4BYTE_MODE_DISABLE;
|
|
adapter->sdio_hw_info.io_hi_speed_flag = 0;
|
|
adapter->sdio_hw_info.io_indir_flag = 1;
|
|
adapter->sdio_hw_info.io_warn_flag = 0;
|
|
adapter->sdio_hw_info.spec_ver = HALMAC_SDIO_SPEC_VER_2_00;
|
|
adapter->sdio_hw_info.clock_speed = 50;
|
|
adapter->sdio_hw_info.block_size = 512;
|
|
adapter->sdio_hw_info.tx_seq = 1;
|
|
adapter->sdio_fs.macid_map = (u8 *)NULL;
|
|
|
|
adapter->watcher.get_watcher.sdio_rn_not_align = 0;
|
|
|
|
adapter->pinmux_info.wl_led = 0;
|
|
adapter->pinmux_info.sdio_int = 0;
|
|
adapter->pinmux_info.sw_io_0 = 0;
|
|
adapter->pinmux_info.sw_io_1 = 0;
|
|
adapter->pinmux_info.sw_io_2 = 0;
|
|
adapter->pinmux_info.sw_io_3 = 0;
|
|
adapter->pinmux_info.sw_io_4 = 0;
|
|
adapter->pinmux_info.sw_io_5 = 0;
|
|
adapter->pinmux_info.sw_io_6 = 0;
|
|
adapter->pinmux_info.sw_io_7 = 0;
|
|
adapter->pinmux_info.sw_io_8 = 0;
|
|
adapter->pinmux_info.sw_io_9 = 0;
|
|
adapter->pinmux_info.sw_io_10 = 0;
|
|
adapter->pinmux_info.sw_io_11 = 0;
|
|
adapter->pinmux_info.sw_io_12 = 0;
|
|
adapter->pinmux_info.sw_io_13 = 0;
|
|
adapter->pinmux_info.sw_io_14 = 0;
|
|
adapter->pinmux_info.sw_io_15 = 0;
|
|
|
|
adapter->pcie_refautok_en = 1;
|
|
adapter->pwr_off_flow_flag = 0;
|
|
|
|
adapter->rx_ignore_info.hdr_chk_mask = 1;
|
|
adapter->rx_ignore_info.fcs_chk_mask = 1;
|
|
adapter->rx_ignore_info.hdr_chk_en = 0;
|
|
adapter->rx_ignore_info.fcs_chk_en = 0;
|
|
adapter->rx_ignore_info.cck_rst_en = 0;
|
|
adapter->rx_ignore_info.fcs_chk_thr = HALMAC_PSF_FCS_CHK_THR_28;
|
|
|
|
init_adapter_dynamic_param_88xx(adapter);
|
|
init_state_machine_88xx(adapter);
|
|
}
|
|
|
|
void
|
|
init_adapter_dynamic_param_88xx(struct halmac_adapter *adapter)
|
|
{
|
|
adapter->h2c_info.seq_num = 0;
|
|
adapter->h2c_info.buf_fs = 0;
|
|
}
|
|
|
|
enum halmac_ret_status
|
|
mount_api_88xx(struct halmac_adapter *adapter)
|
|
{
|
|
struct halmac_api *api = NULL;
|
|
|
|
adapter->halmac_api =
|
|
(struct halmac_api *)PLTFM_MALLOC(sizeof(struct halmac_api));
|
|
if (!adapter->halmac_api)
|
|
return HALMAC_RET_MALLOC_FAIL;
|
|
|
|
api = (struct halmac_api *)adapter->halmac_api;
|
|
|
|
api->halmac_read_efuse = NULL;
|
|
api->halmac_write_efuse = NULL;
|
|
|
|
/* Mount function pointer */
|
|
api->halmac_register_api = register_api_88xx;
|
|
api->halmac_download_firmware = download_firmware_88xx;
|
|
api->halmac_free_download_firmware = free_download_firmware_88xx;
|
|
api->halmac_reset_wifi_fw = reset_wifi_fw_88xx;
|
|
api->halmac_get_fw_version = get_fw_version_88xx;
|
|
api->halmac_cfg_mac_addr = cfg_mac_addr_88xx;
|
|
api->halmac_cfg_bssid = cfg_bssid_88xx;
|
|
api->halmac_cfg_transmitter_addr = cfg_transmitter_addr_88xx;
|
|
api->halmac_cfg_net_type = cfg_net_type_88xx;
|
|
api->halmac_cfg_tsf_rst = cfg_tsf_rst_88xx;
|
|
api->halmac_cfg_bcn_space = cfg_bcn_space_88xx;
|
|
api->halmac_rw_bcn_ctrl = rw_bcn_ctrl_88xx;
|
|
api->halmac_cfg_multicast_addr = cfg_multicast_addr_88xx;
|
|
api->halmac_cfg_operation_mode = cfg_operation_mode_88xx;
|
|
api->halmac_cfg_ch_bw = cfg_ch_bw_88xx;
|
|
api->halmac_cfg_bw = cfg_bw_88xx;
|
|
api->halmac_init_mac_cfg = init_mac_cfg_88xx;
|
|
api->halmac_dump_efuse_map = dump_efuse_map_88xx;
|
|
api->halmac_dump_efuse_map_bt = dump_efuse_map_bt_88xx;
|
|
api->halmac_write_efuse_bt = write_efuse_bt_88xx;
|
|
api->halmac_read_efuse_bt = read_efuse_bt_88xx;
|
|
api->halmac_cfg_efuse_auto_check = cfg_efuse_auto_check_88xx;
|
|
api->halmac_dump_logical_efuse_map = dump_log_efuse_map_88xx;
|
|
api->halmac_dump_logical_efuse_mask = dump_log_efuse_mask_88xx;
|
|
api->halmac_pg_efuse_by_map = pg_efuse_by_map_88xx;
|
|
api->halmac_mask_logical_efuse = mask_log_efuse_88xx;
|
|
api->halmac_get_efuse_size = get_efuse_size_88xx;
|
|
api->halmac_get_efuse_available_size = get_efuse_available_size_88xx;
|
|
api->halmac_get_c2h_info = get_c2h_info_88xx;
|
|
|
|
api->halmac_get_logical_efuse_size = get_log_efuse_size_88xx;
|
|
|
|
api->halmac_write_logical_efuse = write_log_efuse_88xx;
|
|
api->halmac_write_logical_efuse_word = write_log_efuse_word_88xx;
|
|
api->halmac_read_logical_efuse = read_logical_efuse_88xx;
|
|
|
|
api->halmac_write_wifi_phy_efuse = write_wifi_phy_efuse_88xx;
|
|
api->halmac_read_wifi_phy_efuse = read_wifi_phy_efuse_88xx;
|
|
|
|
api->halmac_ofld_func_cfg = ofld_func_cfg_88xx;
|
|
api->halmac_h2c_lb = h2c_lb_88xx;
|
|
api->halmac_debug = mac_debug_88xx;
|
|
api->halmac_cfg_parameter = cfg_parameter_88xx;
|
|
api->halmac_update_datapack = update_datapack_88xx;
|
|
api->halmac_run_datapack = run_datapack_88xx;
|
|
api->halmac_send_bt_coex = send_bt_coex_88xx;
|
|
api->halmac_verify_platform_api = verify_platform_api_88xx;
|
|
api->halmac_update_packet = update_packet_88xx;
|
|
api->halmac_bcn_ie_filter = bcn_ie_filter_88xx;
|
|
api->halmac_cfg_txbf = cfg_txbf_88xx;
|
|
api->halmac_cfg_mumimo = cfg_mumimo_88xx;
|
|
api->halmac_cfg_sounding = cfg_sounding_88xx;
|
|
api->halmac_del_sounding = del_sounding_88xx;
|
|
api->halmac_su_bfer_entry_init = su_bfer_entry_init_88xx;
|
|
api->halmac_su_bfee_entry_init = su_bfee_entry_init_88xx;
|
|
api->halmac_mu_bfer_entry_init = mu_bfer_entry_init_88xx;
|
|
api->halmac_mu_bfee_entry_init = mu_bfee_entry_init_88xx;
|
|
api->halmac_su_bfer_entry_del = su_bfer_entry_del_88xx;
|
|
api->halmac_su_bfee_entry_del = su_bfee_entry_del_88xx;
|
|
api->halmac_mu_bfer_entry_del = mu_bfer_entry_del_88xx;
|
|
api->halmac_mu_bfee_entry_del = mu_bfee_entry_del_88xx;
|
|
|
|
api->halmac_add_ch_info = add_ch_info_88xx;
|
|
api->halmac_add_extra_ch_info = add_extra_ch_info_88xx;
|
|
api->halmac_ctrl_ch_switch = ctrl_ch_switch_88xx;
|
|
api->halmac_p2pps = p2pps_88xx;
|
|
api->halmac_clear_ch_info = clear_ch_info_88xx;
|
|
api->halmac_send_general_info = send_general_info_88xx;
|
|
api->halmac_send_scan_packet = send_scan_packet_88xx;
|
|
api->halmac_drop_scan_packet = drop_scan_packet_88xx;
|
|
|
|
api->halmac_start_iqk = start_iqk_88xx;
|
|
api->halmac_start_dpk = start_dpk_88xx;
|
|
api->halmac_ctrl_pwr_tracking = ctrl_pwr_tracking_88xx;
|
|
api->halmac_psd = psd_88xx;
|
|
api->halmac_cfg_la_mode = cfg_la_mode_88xx;
|
|
api->halmac_cfg_rxff_expand_mode = cfg_rxfifo_expand_mode_88xx;
|
|
|
|
api->halmac_config_security = config_security_88xx;
|
|
api->halmac_get_used_cam_entry_num = get_used_cam_entry_num_88xx;
|
|
api->halmac_read_cam_entry = read_cam_entry_88xx;
|
|
api->halmac_write_cam = write_cam_88xx;
|
|
api->halmac_clear_cam_entry = clear_cam_entry_88xx;
|
|
|
|
api->halmac_cfg_drv_rsvd_pg_num = cfg_drv_rsvd_pg_num_88xx;
|
|
api->halmac_get_chip_version = get_version_88xx;
|
|
|
|
api->halmac_query_status = query_status_88xx;
|
|
api->halmac_reset_feature = reset_ofld_feature_88xx;
|
|
api->halmac_check_fw_status = check_fw_status_88xx;
|
|
api->halmac_dump_fw_dmem = dump_fw_dmem_88xx;
|
|
api->halmac_cfg_max_dl_size = cfg_max_dl_size_88xx;
|
|
|
|
api->halmac_dump_fifo = dump_fifo_88xx;
|
|
api->halmac_get_fifo_size = get_fifo_size_88xx;
|
|
|
|
api->halmac_chk_txdesc = chk_txdesc_88xx;
|
|
api->halmac_dl_drv_rsvd_page = dl_drv_rsvd_page_88xx;
|
|
api->halmac_cfg_csi_rate = cfg_csi_rate_88xx;
|
|
|
|
api->halmac_txfifo_is_empty = txfifo_is_empty_88xx;
|
|
api->halmac_download_flash = download_flash_88xx;
|
|
api->halmac_read_flash = read_flash_88xx;
|
|
api->halmac_erase_flash = erase_flash_88xx;
|
|
api->halmac_check_flash = check_flash_88xx;
|
|
api->halmac_cfg_edca_para = cfg_edca_para_88xx;
|
|
api->halmac_pinmux_wl_led_mode = pinmux_wl_led_mode_88xx;
|
|
api->halmac_pinmux_wl_led_sw_ctrl = pinmux_wl_led_sw_ctrl_88xx;
|
|
api->halmac_pinmux_sdio_int_polarity = pinmux_sdio_int_polarity_88xx;
|
|
api->halmac_pinmux_gpio_mode = pinmux_gpio_mode_88xx;
|
|
api->halmac_pinmux_gpio_output = pinmux_gpio_output_88xx;
|
|
api->halmac_pinmux_pin_status = pinmux_pin_status_88xx;
|
|
|
|
api->halmac_rx_cut_amsdu_cfg = rx_cut_amsdu_cfg_88xx;
|
|
api->halmac_fw_snding = fw_snding_88xx;
|
|
api->halmac_get_mac_addr = get_mac_addr_88xx;
|
|
|
|
api->halmac_enter_cpu_sleep_mode = enter_cpu_sleep_mode_88xx;
|
|
api->halmac_get_cpu_mode = get_cpu_mode_88xx;
|
|
api->halmac_drv_fwctrl = drv_fwctrl_88xx;
|
|
api->halmac_get_watcher = get_watcher_88xx;
|
|
|
|
if (adapter->intf == HALMAC_INTERFACE_SDIO) {
|
|
#if HALMAC_SDIO_SUPPORT
|
|
api->halmac_deinit_sdio_cfg = deinit_sdio_cfg_88xx;
|
|
api->halmac_cfg_rx_aggregation = cfg_sdio_rx_agg_88xx;
|
|
api->halmac_deinit_interface_cfg = deinit_sdio_cfg_88xx;
|
|
api->halmac_cfg_tx_agg_align = cfg_txagg_sdio_align_88xx;
|
|
api->halmac_set_bulkout_num = set_sdio_bulkout_num_88xx;
|
|
api->halmac_get_usb_bulkout_id = get_sdio_bulkout_id_88xx;
|
|
api->halmac_reg_read_indirect_32 = sdio_indirect_reg_r32_88xx;
|
|
api->halmac_reg_sdio_cmd53_read_n = sdio_reg_rn_88xx;
|
|
api->halmac_sdio_cmd53_4byte = sdio_cmd53_4byte_88xx;
|
|
api->halmac_sdio_hw_info = sdio_hw_info_88xx;
|
|
api->halmac_en_ref_autok_pcie = en_ref_autok_sdio_88xx;
|
|
|
|
#endif
|
|
} else if (adapter->intf == HALMAC_INTERFACE_USB) {
|
|
#if HALMAC_USB_SUPPORT
|
|
api->halmac_init_usb_cfg = init_usb_cfg_88xx;
|
|
api->halmac_deinit_usb_cfg = deinit_usb_cfg_88xx;
|
|
api->halmac_cfg_rx_aggregation = cfg_usb_rx_agg_88xx;
|
|
api->halmac_init_interface_cfg = init_usb_cfg_88xx;
|
|
api->halmac_deinit_interface_cfg = deinit_usb_cfg_88xx;
|
|
api->halmac_cfg_tx_agg_align = cfg_txagg_usb_align_88xx;
|
|
api->halmac_tx_allowed_sdio = tx_allowed_usb_88xx;
|
|
api->halmac_set_bulkout_num = set_usb_bulkout_num_88xx;
|
|
api->halmac_get_sdio_tx_addr = get_usb_tx_addr_88xx;
|
|
api->halmac_get_usb_bulkout_id = get_usb_bulkout_id_88xx;
|
|
api->halmac_reg_read_8 = reg_r8_usb_88xx;
|
|
api->halmac_reg_write_8 = reg_w8_usb_88xx;
|
|
api->halmac_reg_read_16 = reg_r16_usb_88xx;
|
|
api->halmac_reg_write_16 = reg_w16_usb_88xx;
|
|
api->halmac_reg_read_32 = reg_r32_usb_88xx;
|
|
api->halmac_reg_write_32 = reg_w32_usb_88xx;
|
|
api->halmac_reg_read_indirect_32 = usb_indirect_reg_r32_88xx;
|
|
api->halmac_reg_sdio_cmd53_read_n = usb_reg_rn_88xx;
|
|
api->halmac_en_ref_autok_pcie = en_ref_autok_usb_88xx;
|
|
#endif
|
|
} else if (adapter->intf == HALMAC_INTERFACE_PCIE) {
|
|
#if HALMAC_PCIE_SUPPORT
|
|
api->halmac_init_pcie_cfg = init_pcie_cfg_88xx;
|
|
api->halmac_deinit_pcie_cfg = deinit_pcie_cfg_88xx;
|
|
api->halmac_cfg_rx_aggregation = cfg_pcie_rx_agg_88xx;
|
|
api->halmac_init_interface_cfg = init_pcie_cfg_88xx;
|
|
api->halmac_deinit_interface_cfg = deinit_pcie_cfg_88xx;
|
|
api->halmac_cfg_tx_agg_align = cfg_txagg_pcie_align_88xx;
|
|
api->halmac_tx_allowed_sdio = tx_allowed_pcie_88xx;
|
|
api->halmac_set_bulkout_num = set_pcie_bulkout_num_88xx;
|
|
api->halmac_get_sdio_tx_addr = get_pcie_tx_addr_88xx;
|
|
api->halmac_get_usb_bulkout_id = get_pcie_bulkout_id_88xx;
|
|
api->halmac_reg_read_8 = reg_r8_pcie_88xx;
|
|
api->halmac_reg_write_8 = reg_w8_pcie_88xx;
|
|
api->halmac_reg_read_16 = reg_r16_pcie_88xx;
|
|
api->halmac_reg_write_16 = reg_w16_pcie_88xx;
|
|
api->halmac_reg_read_32 = reg_r32_pcie_88xx;
|
|
api->halmac_reg_write_32 = reg_w32_pcie_88xx;
|
|
api->halmac_reg_read_indirect_32 = pcie_indirect_reg_r32_88xx;
|
|
api->halmac_reg_sdio_cmd53_read_n = pcie_reg_rn_88xx;
|
|
api->halmac_en_ref_autok_pcie = en_ref_autok_pcie_88xx;
|
|
#endif
|
|
} else {
|
|
PLTFM_MSG_ERR("[ERR]Set halmac io function Error!!\n");
|
|
}
|
|
|
|
if (adapter->chip_id == HALMAC_CHIP_ID_8822B) {
|
|
#if HALMAC_8822B_SUPPORT
|
|
mount_api_8822b(adapter);
|
|
#endif
|
|
} else if (adapter->chip_id == HALMAC_CHIP_ID_8821C) {
|
|
#if HALMAC_8821C_SUPPORT
|
|
mount_api_8821c(adapter);
|
|
#endif
|
|
} else if (adapter->chip_id == HALMAC_CHIP_ID_8822C) {
|
|
#if HALMAC_8822C_SUPPORT
|
|
mount_api_8822c(adapter);
|
|
#endif
|
|
} else if (adapter->chip_id == HALMAC_CHIP_ID_8812F) {
|
|
#if HALMAC_8812F_SUPPORT
|
|
mount_api_8812f(adapter);
|
|
#endif
|
|
} else {
|
|
PLTFM_MSG_ERR("[ERR]Chip ID undefine!!\n");
|
|
return HALMAC_RET_CHIP_NOT_SUPPORT;
|
|
}
|
|
|
|
#if HALMAC_PLATFORM_TESTPROGRAM
|
|
halmac_mount_misc_api_88xx(adapter);
|
|
#endif
|
|
|
|
return HALMAC_RET_SUCCESS;
|
|
}
|
|
|
|
static void
|
|
init_state_machine_88xx(struct halmac_adapter *adapter)
|
|
{
|
|
struct halmac_state *state = &adapter->halmac_state;
|
|
|
|
init_ofld_feature_state_machine_88xx(adapter);
|
|
|
|
state->api_state = HALMAC_API_STATE_INIT;
|
|
|
|
state->dlfw_state = HALMAC_DLFW_NONE;
|
|
state->mac_pwr = HALMAC_MAC_POWER_OFF;
|
|
state->gpio_cfg_state = HALMAC_GPIO_CFG_STATE_IDLE;
|
|
state->rsvd_pg_state = HALMAC_RSVD_PG_STATE_IDLE;
|
|
}
|
|
|
|
void
|
|
init_ofld_feature_state_machine_88xx(struct halmac_adapter *adapter)
|
|
{
|
|
struct halmac_state *state = &adapter->halmac_state;
|
|
|
|
state->efuse_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
state->efuse_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->efuse_state.seq_num = adapter->h2c_info.seq_num;
|
|
|
|
state->cfg_param_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
state->cfg_param_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->cfg_param_state.seq_num = adapter->h2c_info.seq_num;
|
|
|
|
state->scan_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
state->scan_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->scan_state.seq_num = adapter->h2c_info.seq_num;
|
|
|
|
state->update_pkt_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->update_pkt_state.seq_num = adapter->h2c_info.seq_num;
|
|
|
|
state->iqk_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->iqk_state.seq_num = adapter->h2c_info.seq_num;
|
|
|
|
state->pwr_trk_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->pwr_trk_state.seq_num = adapter->h2c_info.seq_num;
|
|
|
|
state->psd_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->psd_state.seq_num = adapter->h2c_info.seq_num;
|
|
state->psd_state.data_size = 0;
|
|
state->psd_state.seg_size = 0;
|
|
state->psd_state.data = NULL;
|
|
|
|
state->fw_snding_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
state->fw_snding_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->fw_snding_state.seq_num = adapter->h2c_info.seq_num;
|
|
|
|
state->wlcpu_mode = HALMAC_WLCPU_ACTIVE;
|
|
}
|
|
|
|
/**
|
|
* register_api_88xx() - register feature list
|
|
* @adapter
|
|
* @registry : feature list, 1->enable 0->disable
|
|
* Author : Ivan Lin
|
|
*
|
|
* Default is enable all api registry
|
|
*
|
|
* Return : enum halmac_ret_status
|
|
* More details of status code can be found in prototype document
|
|
*/
|
|
enum halmac_ret_status
|
|
register_api_88xx(struct halmac_adapter *adapter,
|
|
struct halmac_api_registry *registry)
|
|
{
|
|
if (!registry)
|
|
return HALMAC_RET_NULL_POINTER;
|
|
|
|
PLTFM_MSG_TRACE("[TRACE]%s ===>\n", __func__);
|
|
|
|
PLTFM_MEMCPY(&adapter->api_registry, registry, sizeof(*registry));
|
|
|
|
PLTFM_MSG_TRACE("[TRACE]%s <===\n", __func__);
|
|
|
|
return HALMAC_RET_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* init_mac_cfg_88xx() - config page1~page7 register
|
|
* @adapter : the adapter of halmac
|
|
* @mode : trx mode
|
|
* Author : KaiYuan Chang/Ivan Lin
|
|
* Return : enum halmac_ret_status
|
|
* More details of status code can be found in prototype document
|
|
*/
|
|
enum halmac_ret_status
|
|
init_mac_cfg_88xx(struct halmac_adapter *adapter, enum halmac_trx_mode mode)
|
|
{
|
|
struct halmac_api *api = (struct halmac_api *)adapter->halmac_api;
|
|
enum halmac_ret_status status = HALMAC_RET_SUCCESS;
|
|
|
|
PLTFM_MSG_TRACE("[TRACE]%s ===>\n", __func__);
|
|
|
|
status = api->halmac_init_trx_cfg(adapter, mode);
|
|
if (status != HALMAC_RET_SUCCESS) {
|
|
PLTFM_MSG_ERR("[ERR]init trx %x\n", status);
|
|
return status;
|
|
}
|
|
|
|
status = api->halmac_init_protocol_cfg(adapter);
|
|
if (status != HALMAC_RET_SUCCESS) {
|
|
PLTFM_MSG_ERR("[ERR]init ptcl %x\n", status);
|
|
return status;
|
|
}
|
|
|
|
status = api->halmac_init_edca_cfg(adapter);
|
|
if (status != HALMAC_RET_SUCCESS) {
|
|
PLTFM_MSG_ERR("[ERR]init edca %x\n", status);
|
|
return status;
|
|
}
|
|
|
|
status = api->halmac_init_wmac_cfg(adapter);
|
|
if (status != HALMAC_RET_SUCCESS) {
|
|
PLTFM_MSG_ERR("[ERR]init wmac %x\n", status);
|
|
return status;
|
|
}
|
|
|
|
PLTFM_MSG_TRACE("[TRACE]%s <===\n", __func__);
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* reset_ofld_feature_88xx() -reset async api cmd status
|
|
* @adapter : the adapter of halmac
|
|
* @feature_id : feature_id
|
|
* Author : Ivan Lin/KaiYuan Chang
|
|
* Return : enum halmac_ret_status.
|
|
* More details of status code can be found in prototype document
|
|
*/
|
|
enum halmac_ret_status
|
|
reset_ofld_feature_88xx(struct halmac_adapter *adapter,
|
|
enum halmac_feature_id feature_id)
|
|
{
|
|
struct halmac_state *state = &adapter->halmac_state;
|
|
|
|
PLTFM_MSG_TRACE("[TRACE]%s ===>\n", __func__);
|
|
|
|
switch (feature_id) {
|
|
case HALMAC_FEATURE_CFG_PARA:
|
|
state->cfg_param_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->cfg_param_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_DUMP_PHYSICAL_EFUSE:
|
|
case HALMAC_FEATURE_DUMP_LOGICAL_EFUSE:
|
|
case HALMAC_FEATURE_DUMP_LOGICAL_EFUSE_MASK:
|
|
state->efuse_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->efuse_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_CHANNEL_SWITCH:
|
|
state->scan_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->scan_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_UPDATE_PACKET:
|
|
state->update_pkt_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_SEND_SCAN_PACKET:
|
|
state->scan_pkt_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_DROP_SCAN_PACKET:
|
|
state->drop_pkt_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_IQK:
|
|
state->iqk_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_POWER_TRACKING:
|
|
state->pwr_trk_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_PSD:
|
|
state->psd_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_FW_SNDING:
|
|
state->fw_snding_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->fw_snding_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_DPK:
|
|
state->dpk_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
break;
|
|
case HALMAC_FEATURE_ALL:
|
|
state->cfg_param_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->cfg_param_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
state->efuse_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->efuse_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
state->scan_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->scan_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
state->update_pkt_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->scan_pkt_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->drop_pkt_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->iqk_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->pwr_trk_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->psd_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->fw_snding_state.proc_status = HALMAC_CMD_PROCESS_IDLE;
|
|
state->fw_snding_state.cmd_cnstr_state = HALMAC_CMD_CNSTR_IDLE;
|
|
break;
|
|
default:
|
|
PLTFM_MSG_ERR("[ERR]invalid feature id\n");
|
|
return HALMAC_RET_INVALID_FEATURE_ID;
|
|
}
|
|
|
|
PLTFM_MSG_TRACE("[TRACE]%s <===\n", __func__);
|
|
|
|
return HALMAC_RET_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* (debug API)verify_platform_api_88xx() - verify platform api
|
|
* @adapter : the adapter of halmac
|
|
* Author : KaiYuan Chang/Ivan Lin
|
|
* Return : enum halmac_ret_status
|
|
* More details of status code can be found in prototype document
|
|
*/
|
|
enum halmac_ret_status
|
|
verify_platform_api_88xx(struct halmac_adapter *adapter)
|
|
{
|
|
enum halmac_ret_status ret_status = HALMAC_RET_SUCCESS;
|
|
|
|
PLTFM_MSG_TRACE("[TRACE]%s ===>\n", __func__);
|
|
|
|
ret_status = verify_io_88xx(adapter);
|
|
|
|
if (ret_status != HALMAC_RET_SUCCESS)
|
|
return ret_status;
|
|
|
|
if (adapter->txff_alloc.la_mode != HALMAC_LA_MODE_FULL)
|
|
ret_status = verify_send_rsvd_page_88xx(adapter);
|
|
|
|
if (ret_status != HALMAC_RET_SUCCESS)
|
|
return ret_status;
|
|
|
|
PLTFM_MSG_TRACE("[TRACE]%s <===\n", __func__);
|
|
|
|
return ret_status;
|
|
}
|
|
|
|
void
|
|
tx_desc_chksum_88xx(struct halmac_adapter *adapter, u8 enable)
|
|
{
|
|
u16 value16;
|
|
struct halmac_api *api = (struct halmac_api *)adapter->halmac_api;
|
|
|
|
PLTFM_MSG_TRACE("[TRACE]%s ===>\n", __func__);
|
|
|
|
adapter->tx_desc_checksum = enable;
|
|
|
|
value16 = HALMAC_REG_R16(REG_TXDMA_OFFSET_CHK);
|
|
if (enable == 1)
|
|
HALMAC_REG_W16(REG_TXDMA_OFFSET_CHK, value16 | BIT(13));
|
|
else
|
|
HALMAC_REG_W16(REG_TXDMA_OFFSET_CHK, value16 & ~BIT(13));
|
|
}
|
|
|
|
static enum halmac_ret_status
|
|
verify_io_88xx(struct halmac_adapter *adapter)
|
|
{
|
|
u8 value8;
|
|
u8 wvalue8;
|
|
u32 value32;
|
|
u32 value32_2;
|
|
u32 wvalue32;
|
|
u32 offset;
|
|
enum halmac_ret_status ret_status = HALMAC_RET_SUCCESS;
|
|
|
|
if (adapter->intf == HALMAC_INTERFACE_SDIO) {
|
|
#if HALMAC_SDIO_SUPPORT
|
|
offset = REG_PAGE5_DUMMY;
|
|
if (0 == (offset & 0xFFFF0000))
|
|
offset |= WLAN_IOREG_OFFSET;
|
|
|
|
ret_status = cnv_to_sdio_bus_offset_88xx(adapter, &offset);
|
|
|
|
/* Verify CMD52 R/W */
|
|
wvalue8 = 0xab;
|
|
PLTFM_SDIO_CMD52_W(offset, wvalue8);
|
|
|
|
value8 = PLTFM_SDIO_CMD52_R(offset);
|
|
|
|
if (value8 != wvalue8) {
|
|
PLTFM_MSG_ERR("[ERR]cmd52 r/w\n");
|
|
ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
|
|
}
|
|
|
|
/* Verify CMD53 R/W */
|
|
PLTFM_SDIO_CMD52_W(offset, 0xaa);
|
|
PLTFM_SDIO_CMD52_W(offset + 1, 0xbb);
|
|
PLTFM_SDIO_CMD52_W(offset + 2, 0xcc);
|
|
PLTFM_SDIO_CMD52_W(offset + 3, 0xdd);
|
|
|
|
value32 = PLTFM_SDIO_CMD53_R32(offset);
|
|
|
|
if (value32 != 0xddccbbaa) {
|
|
PLTFM_MSG_ERR("[ERR]cmd53 r\n");
|
|
ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
|
|
}
|
|
|
|
wvalue32 = 0x11223344;
|
|
PLTFM_SDIO_CMD53_W32(offset, wvalue32);
|
|
|
|
value32 = PLTFM_SDIO_CMD53_R32(offset);
|
|
|
|
if (value32 != wvalue32) {
|
|
PLTFM_MSG_ERR("[ERR]cmd53 w\n");
|
|
ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
|
|
}
|
|
|
|
/* value32 should be 0x33441122 */
|
|
value32 = PLTFM_SDIO_CMD53_R32(offset + 2);
|
|
|
|
wvalue32 = 0x11225566;
|
|
PLTFM_SDIO_CMD53_W32(offset, wvalue32);
|
|
|
|
/* value32 should be 0x55661122 */
|
|
value32_2 = PLTFM_SDIO_CMD53_R32(offset + 2);
|
|
if (value32_2 == value32) {
|
|
PLTFM_MSG_ERR("[ERR]cmd52 is used\n");
|
|
ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
|
|
}
|
|
#else
|
|
return HALMAC_RET_WRONG_INTF;
|
|
#endif
|
|
} else {
|
|
wvalue32 = 0x77665511;
|
|
PLTFM_REG_W32(REG_PAGE5_DUMMY, wvalue32);
|
|
|
|
value32 = PLTFM_REG_R32(REG_PAGE5_DUMMY);
|
|
if (value32 != wvalue32) {
|
|
PLTFM_MSG_ERR("[ERR]reg rw\n");
|
|
ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
|
|
}
|
|
}
|
|
|
|
return ret_status;
|
|
}
|
|
|
|
static enum halmac_ret_status
|
|
verify_send_rsvd_page_88xx(struct halmac_adapter *adapter)
|
|
{
|
|
u8 txdesc_size = adapter->hw_cfg_info.txdesc_size;
|
|
u8 *rsvd_buf = NULL;
|
|
u8 *rsvd_page = NULL;
|
|
u32 i;
|
|
u32 pkt_size = 64;
|
|
u32 payload = 0xab;
|
|
enum halmac_ret_status ret_status = HALMAC_RET_SUCCESS;
|
|
|
|
rsvd_buf = (u8 *)PLTFM_MALLOC(pkt_size);
|
|
|
|
if (!rsvd_buf) {
|
|
PLTFM_MSG_ERR("[ERR]rsvd buf malloc!!\n");
|
|
return HALMAC_RET_MALLOC_FAIL;
|
|
}
|
|
|
|
PLTFM_MEMSET(rsvd_buf, (u8)payload, pkt_size);
|
|
|
|
ret_status = dl_rsvd_page_88xx(adapter,
|
|
adapter->txff_alloc.rsvd_boundary,
|
|
rsvd_buf, pkt_size);
|
|
if (ret_status != HALMAC_RET_SUCCESS) {
|
|
PLTFM_FREE(rsvd_buf, pkt_size);
|
|
return ret_status;
|
|
}
|
|
|
|
rsvd_page = (u8 *)PLTFM_MALLOC(pkt_size + txdesc_size);
|
|
|
|
if (!rsvd_page) {
|
|
PLTFM_MSG_ERR("[ERR]rsvd page malloc!!\n");
|
|
PLTFM_FREE(rsvd_buf, pkt_size);
|
|
return HALMAC_RET_MALLOC_FAIL;
|
|
}
|
|
|
|
PLTFM_MEMSET(rsvd_page, 0x00, pkt_size + txdesc_size);
|
|
|
|
ret_status = dump_fifo_88xx(adapter, HAL_FIFO_SEL_RSVD_PAGE, 0,
|
|
pkt_size + txdesc_size, rsvd_page);
|
|
|
|
if (ret_status != HALMAC_RET_SUCCESS) {
|
|
PLTFM_FREE(rsvd_buf, pkt_size);
|
|
PLTFM_FREE(rsvd_page, pkt_size + txdesc_size);
|
|
return ret_status;
|
|
}
|
|
|
|
for (i = 0; i < pkt_size; i++) {
|
|
if (*(rsvd_buf + i) != *(rsvd_page + (i + txdesc_size))) {
|
|
PLTFM_MSG_ERR("[ERR]Compare RSVD page Fail\n");
|
|
ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
|
|
}
|
|
}
|
|
|
|
PLTFM_FREE(rsvd_buf, pkt_size);
|
|
PLTFM_FREE(rsvd_page, pkt_size + txdesc_size);
|
|
|
|
return ret_status;
|
|
}
|
|
|
|
enum halmac_ret_status
|
|
pg_num_parser_88xx(struct halmac_adapter *adapter, enum halmac_trx_mode mode,
|
|
struct halmac_pg_num *tbl)
|
|
{
|
|
u8 flag;
|
|
u16 hpq_num = 0;
|
|
u16 lpq_num = 0;
|
|
u16 npq_num = 0;
|
|
u16 gapq_num = 0;
|
|
u16 expq_num = 0;
|
|
u16 pubq_num = 0;
|
|
u32 i = 0;
|
|
|
|
flag = 0;
|
|
for (i = 0; i < HALMAC_TRX_MODE_MAX; i++) {
|
|
if (mode == tbl[i].mode) {
|
|
hpq_num = tbl[i].hq_num;
|
|
lpq_num = tbl[i].lq_num;
|
|
npq_num = tbl[i].nq_num;
|
|
expq_num = tbl[i].exq_num;
|
|
gapq_num = tbl[i].gap_num;
|
|
pubq_num = adapter->txff_alloc.acq_pg_num - hpq_num -
|
|
lpq_num - npq_num - expq_num - gapq_num;
|
|
flag = 1;
|
|
PLTFM_MSG_TRACE("[TRACE]%s done\n", __func__);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (flag == 0) {
|
|
PLTFM_MSG_ERR("[ERR]trx mode!!\n");
|
|
return HALMAC_RET_TRX_MODE_NOT_SUPPORT;
|
|
}
|
|
|
|
if (adapter->txff_alloc.acq_pg_num <
|
|
hpq_num + lpq_num + npq_num + expq_num + gapq_num) {
|
|
PLTFM_MSG_ERR("[ERR]acqnum = %d\n",
|
|
adapter->txff_alloc.acq_pg_num);
|
|
PLTFM_MSG_ERR("[ERR]hpq_num = %d\n", hpq_num);
|
|
PLTFM_MSG_ERR("[ERR]LPQ_num = %d\n", lpq_num);
|
|
PLTFM_MSG_ERR("[ERR]npq_num = %d\n", npq_num);
|
|
PLTFM_MSG_ERR("[ERR]EPQ_num = %d\n", expq_num);
|
|
PLTFM_MSG_ERR("[ERR]gapq_num = %d\n", gapq_num);
|
|
return HALMAC_RET_CFG_TXFIFO_PAGE_FAIL;
|
|
}
|
|
|
|
adapter->txff_alloc.high_queue_pg_num = hpq_num;
|
|
adapter->txff_alloc.low_queue_pg_num = lpq_num;
|
|
adapter->txff_alloc.normal_queue_pg_num = npq_num;
|
|
adapter->txff_alloc.extra_queue_pg_num = expq_num;
|
|
adapter->txff_alloc.pub_queue_pg_num = pubq_num;
|
|
|
|
return HALMAC_RET_SUCCESS;
|
|
}
|
|
|
|
enum halmac_ret_status
|
|
rqpn_parser_88xx(struct halmac_adapter *adapter, enum halmac_trx_mode mode,
|
|
struct halmac_rqpn *tbl)
|
|
{
|
|
u8 flag;
|
|
u32 i;
|
|
|
|
flag = 0;
|
|
for (i = 0; i < HALMAC_TRX_MODE_MAX; i++) {
|
|
if (mode == tbl[i].mode) {
|
|
adapter->pq_map[HALMAC_PQ_MAP_VO] = tbl[i].dma_map_vo;
|
|
adapter->pq_map[HALMAC_PQ_MAP_VI] = tbl[i].dma_map_vi;
|
|
adapter->pq_map[HALMAC_PQ_MAP_BE] = tbl[i].dma_map_be;
|
|
adapter->pq_map[HALMAC_PQ_MAP_BK] = tbl[i].dma_map_bk;
|
|
adapter->pq_map[HALMAC_PQ_MAP_MG] = tbl[i].dma_map_mg;
|
|
adapter->pq_map[HALMAC_PQ_MAP_HI] = tbl[i].dma_map_hi;
|
|
flag = 1;
|
|
PLTFM_MSG_TRACE("[TRACE]%s done\n", __func__);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (flag == 0) {
|
|
PLTFM_MSG_ERR("[ERR]trx mdoe!!\n");
|
|
return HALMAC_RET_TRX_MODE_NOT_SUPPORT;
|
|
}
|
|
|
|
return HALMAC_RET_SUCCESS;
|
|
}
|
|
|
|
enum halmac_ret_status
|
|
fwff_is_empty_88xx(struct halmac_adapter *adapter)
|
|
{
|
|
struct halmac_api *api = (struct halmac_api *)adapter->halmac_api;
|
|
u32 cnt;
|
|
|
|
cnt = 5000;
|
|
while (HALMAC_REG_R16(REG_FWFF_CTRL) !=
|
|
HALMAC_REG_R16(REG_FWFF_PKT_INFO)) {
|
|
if (cnt == 0) {
|
|
PLTFM_MSG_ERR("[ERR]polling fwff empty fail\n");
|
|
return HALMAC_RET_FWFF_NO_EMPTY;
|
|
}
|
|
cnt--;
|
|
PLTFM_DELAY_US(50);
|
|
}
|
|
return HALMAC_RET_SUCCESS;
|
|
}
|
|
|
|
#endif /* HALMAC_88XX_SUPPORT */
|