// SPDX-License-Identifier: GPL-2.0
|
/******************************************************************************
|
*
|
* Copyright(c) 2016 Realtek Corporation.
|
*
|
* Contact Information:
|
* wlanfae <wlanfae@realtek.com>
|
* Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
|
* Hsinchu 300, Taiwan.
|
*
|
* Larry Finger <Larry.Finger@lwfinger.net>
|
*
|
*****************************************************************************/
|
#include "halmac_2_platform.h"
|
#include "halmac_type.h"
|
#include "halmac_88xx/halmac_api_88xx.h"
|
#include "halmac_88xx/halmac_88xx_cfg.h"
|
|
#include "halmac_88xx/halmac_8822b/halmac_8822b_cfg.h"
|
|
static enum halmac_ret_status
|
halmac_check_platform_api(void *driver_adapter,
|
enum halmac_interface halmac_interface,
|
struct halmac_platform_api *halmac_platform_api)
|
{
|
void *adapter_local = NULL;
|
|
adapter_local = driver_adapter;
|
|
if (!halmac_platform_api)
|
return HALMAC_RET_PLATFORM_API_NULL;
|
|
if (halmac_interface == HALMAC_INTERFACE_SDIO) {
|
if (!halmac_platform_api->SDIO_CMD52_READ) {
|
pr_err("(!halmac_platform_api->SDIO_CMD52_READ)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->SDIO_CMD53_READ_8) {
|
pr_err("(!halmac_platform_api->SDIO_CMD53_READ_8)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->SDIO_CMD53_READ_16) {
|
pr_err("(!halmac_platform_api->SDIO_CMD53_READ_16)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->SDIO_CMD53_READ_32) {
|
pr_err("(!halmac_platform_api->SDIO_CMD53_READ_32)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->SDIO_CMD53_READ_N) {
|
pr_err("(!halmac_platform_api->SDIO_CMD53_READ_N)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->SDIO_CMD52_WRITE) {
|
pr_err("(!halmac_platform_api->SDIO_CMD52_WRITE)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->SDIO_CMD53_WRITE_8) {
|
pr_err("(!halmac_platform_api->SDIO_CMD53_WRITE_8)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->SDIO_CMD53_WRITE_16) {
|
pr_err("(!halmac_platform_api->SDIO_CMD53_WRITE_16)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->SDIO_CMD53_WRITE_32) {
|
pr_err("(!halmac_platform_api->SDIO_CMD53_WRITE_32)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
}
|
|
if (halmac_interface == HALMAC_INTERFACE_USB ||
|
halmac_interface == HALMAC_INTERFACE_PCIE) {
|
if (!halmac_platform_api->REG_READ_8) {
|
pr_err("(!halmac_platform_api->REG_READ_8)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->REG_READ_16) {
|
pr_err("(!halmac_platform_api->REG_READ_16)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->REG_READ_32) {
|
pr_err("(!halmac_platform_api->REG_READ_32)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->REG_WRITE_8) {
|
pr_err("(!halmac_platform_api->REG_WRITE_8)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->REG_WRITE_16) {
|
pr_err("(!halmac_platform_api->REG_WRITE_16)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
if (!halmac_platform_api->REG_WRITE_32) {
|
pr_err("(!halmac_platform_api->REG_WRITE_32)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
}
|
|
if (!halmac_platform_api->EVENT_INDICATION) {
|
pr_err("(!halmac_platform_api->EVENT_INDICATION)\n");
|
return HALMAC_RET_PLATFORM_API_NULL;
|
}
|
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"%s ==========>\n", __func__);
|
|
return HALMAC_RET_SUCCESS;
|
}
|
|
static enum halmac_ret_status
|
halmac_convert_to_sdio_bus_offset(u32 *halmac_offset)
|
{
|
switch ((*halmac_offset) & 0xFFFF0000) {
|
case WLAN_IOREG_OFFSET:
|
*halmac_offset = (HALMAC_SDIO_CMD_ADDR_MAC_REG << 13) |
|
(*halmac_offset & HALMAC_WLAN_MAC_REG_MSK);
|
break;
|
case SDIO_LOCAL_OFFSET:
|
*halmac_offset = (HALMAC_SDIO_CMD_ADDR_SDIO_REG << 13) |
|
(*halmac_offset & HALMAC_SDIO_LOCAL_MSK);
|
break;
|
default:
|
*halmac_offset = 0xFFFFFFFF;
|
return HALMAC_RET_CONVERT_SDIO_OFFSET_FAIL;
|
}
|
|
return HALMAC_RET_SUCCESS;
|
}
|
|
static u8
|
platform_reg_read_8_sdio(void *driver_adapter,
|
struct halmac_platform_api *halmac_platform_api,
|
u32 offset)
|
{
|
u8 value8;
|
u32 halmac_offset = offset;
|
enum halmac_ret_status status = HALMAC_RET_SUCCESS;
|
|
if ((halmac_offset & 0xFFFF0000) == 0)
|
halmac_offset |= WLAN_IOREG_OFFSET;
|
|
status = halmac_convert_to_sdio_bus_offset(&halmac_offset);
|
if (status != HALMAC_RET_SUCCESS) {
|
pr_err("%s error = %x\n", __func__, status);
|
return status;
|
}
|
|
value8 = halmac_platform_api->SDIO_CMD52_READ(driver_adapter,
|
halmac_offset);
|
|
return value8;
|
}
|
|
static enum halmac_ret_status
|
platform_reg_write_8_sdio(void *driver_adapter,
|
struct halmac_platform_api *halmac_platform_api,
|
u32 offset, u8 data)
|
{
|
enum halmac_ret_status status = HALMAC_RET_SUCCESS;
|
u32 halmac_offset = offset;
|
|
if ((halmac_offset & 0xFFFF0000) == 0)
|
halmac_offset |= WLAN_IOREG_OFFSET;
|
|
status = halmac_convert_to_sdio_bus_offset(&halmac_offset);
|
|
if (status != HALMAC_RET_SUCCESS) {
|
pr_err("halmac_reg_write_8_sdio_88xx error = %x\n", status);
|
return status;
|
}
|
halmac_platform_api->SDIO_CMD52_WRITE(driver_adapter, halmac_offset,
|
data);
|
|
return HALMAC_RET_SUCCESS;
|
}
|
|
static enum halmac_ret_status
|
halmac_get_chip_info(void *driver_adapter,
|
struct halmac_platform_api *halmac_platform_api,
|
enum halmac_interface halmac_interface,
|
struct halmac_adapter *halmac_adapter)
|
{
|
struct halmac_api *halmac_api = (struct halmac_api *)NULL;
|
u8 chip_id, chip_version;
|
u32 polling_count;
|
|
halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
|
|
/* Get Chip_id and Chip_version */
|
if (halmac_adapter->halmac_interface == HALMAC_INTERFACE_SDIO) {
|
platform_reg_write_8_sdio(
|
driver_adapter, halmac_platform_api, REG_SDIO_HSUS_CTRL,
|
platform_reg_read_8_sdio(driver_adapter,
|
halmac_platform_api,
|
REG_SDIO_HSUS_CTRL) &
|
~(BIT(0)));
|
|
polling_count = 10000;
|
while (!(platform_reg_read_8_sdio(driver_adapter,
|
halmac_platform_api,
|
REG_SDIO_HSUS_CTRL) &
|
0x02)) {
|
polling_count--;
|
if (polling_count == 0)
|
return HALMAC_RET_SDIO_LEAVE_SUSPEND_FAIL;
|
}
|
|
chip_id = platform_reg_read_8_sdio(
|
driver_adapter, halmac_platform_api, REG_SYS_CFG2);
|
chip_version = platform_reg_read_8_sdio(driver_adapter,
|
halmac_platform_api,
|
REG_SYS_CFG1 + 1) >>
|
4;
|
} else {
|
chip_id = halmac_platform_api->REG_READ_8(driver_adapter,
|
REG_SYS_CFG2);
|
chip_version = halmac_platform_api->REG_READ_8(
|
driver_adapter, REG_SYS_CFG1 + 1) >>
|
4;
|
}
|
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"[TRACE]Chip id : 0x%X\n", chip_id);
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"[TRACE]Chip version : 0x%X\n", chip_version);
|
|
halmac_adapter->chip_version = (enum halmac_chip_ver)chip_version;
|
|
if (chip_id == HALMAC_CHIP_ID_HW_DEF_8822B)
|
halmac_adapter->chip_id = HALMAC_CHIP_ID_8822B;
|
else if (chip_id == HALMAC_CHIP_ID_HW_DEF_8821C)
|
halmac_adapter->chip_id = HALMAC_CHIP_ID_8821C;
|
else if (chip_id == HALMAC_CHIP_ID_HW_DEF_8814B)
|
halmac_adapter->chip_id = HALMAC_CHIP_ID_8814B;
|
else if (chip_id == HALMAC_CHIP_ID_HW_DEF_8197F)
|
halmac_adapter->chip_id = HALMAC_CHIP_ID_8197F;
|
else
|
halmac_adapter->chip_id = HALMAC_CHIP_ID_UNDEFINE;
|
|
if (halmac_adapter->chip_id == HALMAC_CHIP_ID_UNDEFINE)
|
return HALMAC_RET_CHIP_NOT_SUPPORT;
|
|
return HALMAC_RET_SUCCESS;
|
}
|
|
/**
|
* halmac_init_adapter() - init halmac_adapter
|
* @driver_adapter : the adapter of caller
|
* @halmac_platform_api : the platform APIs which is used in halmac APIs
|
* @halmac_interface : bus interface
|
* @pp_halmac_adapter : the adapter of halmac
|
* @pp_halmac_api : the function pointer of APIs, caller shall call APIs by
|
* function pointer
|
* 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
|
halmac_init_adapter(void *driver_adapter,
|
struct halmac_platform_api *halmac_platform_api,
|
enum halmac_interface halmac_interface,
|
struct halmac_adapter **pp_halmac_adapter,
|
struct halmac_api **pp_halmac_api)
|
{
|
struct halmac_adapter *halmac_adapter = (struct halmac_adapter *)NULL;
|
enum halmac_ret_status status = HALMAC_RET_SUCCESS;
|
|
union {
|
u32 i;
|
u8 x[4];
|
} ENDIAN_CHECK = {0x01000000};
|
|
status = halmac_check_platform_api(driver_adapter, halmac_interface,
|
halmac_platform_api);
|
if (status != HALMAC_RET_SUCCESS)
|
return status;
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
HALMAC_SVN_VER "\n");
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"HALMAC_MAJOR_VER = %x\n", HALMAC_MAJOR_VER);
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"HALMAC_PROTOTYPE_VER = %x\n", HALMAC_PROTOTYPE_VER);
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"HALMAC_MINOR_VER = %x\n", HALMAC_MINOR_VER);
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"HALMAC_PATCH_VER = %x\n", HALMAC_PATCH_VER);
|
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"halmac_init_adapter_88xx ==========>\n");
|
|
/* Check endian setting - Little endian : 1, Big endian : 0*/
|
if (ENDIAN_CHECK.x[0] == HALMAC_SYSTEM_ENDIAN) {
|
pr_err("Endian setting Err!!\n");
|
return HALMAC_RET_ENDIAN_ERR;
|
}
|
|
halmac_adapter = kzalloc(sizeof(*halmac_adapter), GFP_KERNEL);
|
if (!halmac_adapter) {
|
/* out of memory */
|
return HALMAC_RET_MALLOC_FAIL;
|
}
|
|
/* return halmac adapter address to caller */
|
*pp_halmac_adapter = halmac_adapter;
|
|
/* Record caller info */
|
halmac_adapter->halmac_platform_api = halmac_platform_api;
|
halmac_adapter->driver_adapter = driver_adapter;
|
halmac_interface = halmac_interface == HALMAC_INTERFACE_AXI ?
|
HALMAC_INTERFACE_PCIE :
|
halmac_interface;
|
halmac_adapter->halmac_interface = halmac_interface;
|
|
spin_lock_init(&halmac_adapter->efuse_lock);
|
spin_lock_init(&halmac_adapter->h2c_seq_lock);
|
|
/*Get Chip*/
|
if (halmac_get_chip_info(driver_adapter, halmac_platform_api,
|
halmac_interface,
|
halmac_adapter) != HALMAC_RET_SUCCESS) {
|
pr_err("HALMAC_RET_CHIP_NOT_SUPPORT\n");
|
return HALMAC_RET_CHIP_NOT_SUPPORT;
|
}
|
|
/* Assign function pointer to halmac API */
|
halmac_init_adapter_para_88xx(halmac_adapter);
|
status = halmac_mount_api_88xx(halmac_adapter);
|
|
/* Return halmac API function pointer */
|
*pp_halmac_api = (struct halmac_api *)halmac_adapter->halmac_api;
|
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"halmac_init_adapter_88xx <==========\n");
|
|
return status;
|
}
|
|
/**
|
* halmac_halt_api() - stop halmac_api action
|
* @halmac_adapter : the adapter of halmac
|
* Author : Ivan Lin
|
* Return : enum halmac_ret_status
|
* More details of status code can be found in prototype document
|
*/
|
enum halmac_ret_status halmac_halt_api(struct halmac_adapter *halmac_adapter)
|
{
|
void *driver_adapter = NULL;
|
struct halmac_platform_api *halmac_platform_api =
|
(struct halmac_platform_api *)NULL;
|
|
if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
|
return HALMAC_RET_ADAPTER_INVALID;
|
|
driver_adapter = halmac_adapter->driver_adapter;
|
halmac_platform_api = halmac_adapter->halmac_platform_api;
|
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"%s ==========>\n", __func__);
|
halmac_adapter->halmac_state.api_state = HALMAC_API_STATE_HALT;
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"%s ==========>\n", __func__);
|
return HALMAC_RET_SUCCESS;
|
}
|
|
/**
|
* halmac_deinit_adapter() - deinit halmac adapter
|
* @halmac_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
|
halmac_deinit_adapter(struct halmac_adapter *halmac_adapter)
|
{
|
void *driver_adapter = NULL;
|
|
if (halmac_adapter_validate(halmac_adapter) != HALMAC_RET_SUCCESS)
|
return HALMAC_RET_ADAPTER_INVALID;
|
|
driver_adapter = halmac_adapter->driver_adapter;
|
|
HALMAC_RT_TRACE(driver_adapter, HALMAC_MSG_INIT, DBG_DMESG,
|
"[TRACE]halmac_deinit_adapter_88xx ==========>\n");
|
|
kfree(halmac_adapter->hal_efuse_map);
|
halmac_adapter->hal_efuse_map = (u8 *)NULL;
|
|
kfree(halmac_adapter->halmac_state.psd_set.data);
|
halmac_adapter->halmac_state.psd_set.data = (u8 *)NULL;
|
|
kfree(halmac_adapter->halmac_api);
|
halmac_adapter->halmac_api = NULL;
|
|
halmac_adapter->hal_adapter_backup = NULL;
|
kfree(halmac_adapter);
|
|
return HALMAC_RET_SUCCESS;
|
}
|
|
/**
|
* halmac_get_version() - get HALMAC version
|
* @version : return version of major, prototype and minor information
|
* 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 halmac_get_version(struct halmac_ver *version)
|
{
|
version->major_ver = (u8)HALMAC_MAJOR_VER;
|
version->prototype_ver = (u8)HALMAC_PROTOTYPE_VER;
|
version->minor_ver = (u8)HALMAC_MINOR_VER;
|
|
return HALMAC_RET_SUCCESS;
|
}
|
