Files
android/drivers/misc/mediatek/connectivity/fmradio/plat/legacy_wmt.c
T
threeeye bc1d038eac REVVL 6 Pro kernel bring-up: full working tree snapshot (2026-09-12)
Squashed backup commit (no shallow-clone history issues) of
xiaomi-mt6833-dev/kernel_xiaomi_mt6833 (lineage-23.2 branch, upstream
commit 9eece662e) plus all fixes applied to get everpal_defconfig building
clean against a modern (GCC 15.2.0) toolchain -- see the previous commit
message on the lineage-23.2 branch (also in this repo history is not
available here since this is a squashed snapshot; full incremental history
lives in the local DL380 checkout and the upstream GitHub remote).

Upstream: https://github.com/xiaomi-mt6833-dev/kernel_xiaomi_mt6833 (lineage-23.2)
2026-09-12 13:36:46 +00:00

429 lines
9.7 KiB
C

/*
* Copyright (C) 2019 MediaTek Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 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 http://www.gnu.org/licenses/gpl-2.0.html for more details.
*/
#include "plat.h"
#include "fm_cmd.h"
static int (*whole_chip_reset)(signed int sta);
static void WCNfm_wholechip_rst_cb(
ENUM_WMTDRV_TYPE_T src, ENUM_WMTDRV_TYPE_T dst,
ENUM_WMTMSG_TYPE_T type, void *buf, unsigned int sz)
{
/* To handle reset procedure please */
ENUM_WMTRSTMSG_TYPE_T rst_msg;
if (sz > sizeof(ENUM_WMTRSTMSG_TYPE_T)) {
/*message format invalid */
WCN_DBG(FM_WAR | LINK, "message format invalid!\n");
return;
}
memcpy((char *)&rst_msg, (char *)buf, sz);
WCN_DBG(FM_WAR | LINK,
"[src=%d], [dst=%d], [type=%d], [buf=0x%x], [sz=%d], [max=%d]\n",
src, dst, type, rst_msg, sz, WMTRSTMSG_RESET_MAX);
if ((src == WMTDRV_TYPE_WMT) && (dst == WMTDRV_TYPE_FM)
&& (type == WMTMSG_TYPE_RESET)) {
if (rst_msg == WMTRSTMSG_RESET_START) {
WCN_DBG(FM_WAR | LINK, "FM restart start!\n");
if (whole_chip_reset)
whole_chip_reset(1);
} else if (rst_msg == WMTRSTMSG_RESET_END_FAIL) {
WCN_DBG(FM_WAR | LINK, "FM restart end fail!\n");
if (whole_chip_reset)
whole_chip_reset(2);
} else if (rst_msg == WMTRSTMSG_RESET_END) {
WCN_DBG(FM_WAR | LINK, "FM restart end!\n");
if (whole_chip_reset)
whole_chip_reset(0);
}
}
}
static void fw_eint_handler(void)
{
fm_event_parser(fm_rds_parser);
}
static int fm_stp_send_data(unsigned char *buf, unsigned int len)
{
return mtk_wcn_stp_send_data(buf, len, FM_TASK_INDX);
}
static int fm_stp_recv_data(unsigned char *buf, unsigned int len)
{
return mtk_wcn_stp_receive_data(buf, len, FM_TASK_INDX);
}
static int fm_stp_register_event_cb(void *cb)
{
return mtk_wcn_stp_register_event_cb(FM_TASK_INDX, cb);
}
static int fm_wmt_msgcb_reg(void *data)
{
/* get whole chip reset cb */
whole_chip_reset = data;
return mtk_wcn_wmt_msgcb_reg(
WMTDRV_TYPE_FM, WCNfm_wholechip_rst_cb);
}
static int fm_wmt_func_on(void)
{
int ret = 0;
ret = mtk_wcn_wmt_func_on(WMTDRV_TYPE_FM) != MTK_WCN_BOOL_FALSE;
return ret;
}
static int fm_wmt_func_off(void)
{
int ret = 0;
ret = mtk_wcn_wmt_func_off(WMTDRV_TYPE_FM) != MTK_WCN_BOOL_FALSE;
return ret;
}
static unsigned int fm_wmt_ic_info_get(void)
{
return mtk_wcn_wmt_ic_info_get(WMTCHIN_HWVER);
}
static int fm_wmt_chipid_query(void)
{
return mtk_wcn_wmt_chipid_query();
}
static signed int fm_drv_switch_clk_64m(void)
{
unsigned int val = 0;
int i = 0, ret = 0;
/* switch SPI clock to 64MHz */
fm_host_reg_read(0x81026004, &val);
/* Set 0x81026004[0] = 0x1 */
ret = fm_host_reg_write(0x81026004, val | 0x1);
if (ret) {
WCN_DBG(FM_ERR | CHIP,
"Switch SPI clock to 64MHz failed\n");
return -1;
}
for (i = 0; i < 100; i++) {
fm_host_reg_read(0x81026004, &val);
if ((val & 0x18) == 0x10)
break;
fm_delayus(10);
}
if (i == 100) {
WCN_DBG(FM_ERR | CHIP,
"switch_SPI_clock_to_64MHz polling timeout\n");
return -1;
}
/* Capture next (with SPI Clock: 64MHz) */
fm_host_reg_read(0x81026004, &val);
/* Set 0x81026004[2] = 0x1 */
ret = fm_host_reg_write(0x81026004, val | 0x4);
if (ret) {
WCN_DBG(FM_ERR | CHIP,
"Switch SPI clock to 64MHz failed\n");
return -1;
}
return 0;
}
static signed int fm_drv_switch_clk_26m(void)
{
unsigned int val = 0;
int i = 0, ret = 0;
/* Capture next (with SPI Clock: 26MHz) */
fm_host_reg_read(0x81026004, &val);
/* Set 0x81026004[2] = 0x0 */
ret = fm_host_reg_write(0x81026004, val & 0xFFFFFFFB);
if (ret) {
WCN_DBG(FM_ERR | CHIP,
"Switch SPI clock to 26MHz failed\n");
return -1;
}
/* switch SPI clock to 26MHz */
fm_host_reg_read(0x81026004, &val);
/* Set 0x81026004[0] = 0x0 */
ret = fm_host_reg_write(0x81026004, val & 0xFFFFFFFE);
if (ret) {
WCN_DBG(FM_ERR | CHIP,
"Switch SPI clock to 26MHz failed\n");
return -1;
}
for (i = 0; i < 100; i++) {
fm_host_reg_read(0x81026004, &val);
if ((val & 0x18) == 0x8)
break;
fm_delayus(10);
}
if (i == 100) {
WCN_DBG(FM_ERR | CHIP,
"switch_SPI_clock_to_26MHz polling timeout\n");
return -1;
}
return 0;
}
static int fm_drv_spi_clock_switch(enum fm_spi_speed speed)
{
int ret = 0;
switch (speed) {
case FM_SPI_SPEED_26M:
ret = fm_drv_switch_clk_26m();
break;
case FM_SPI_SPEED_64M:
ret = fm_drv_switch_clk_64m();
break;
default:
ret = -1;
break;
}
return ret;
}
static int drv_get_hw_version(void)
{
#if defined(MT6625_FM) || defined(MT6627_FM) || defined(MT6630_FM) || defined(MT6632_FM) || defined(soc)
return FM_CONNAC_LEGACY;
#else
int id = fm_wmt_chipid_query();
int ret = FM_CONNAC_UNKNOWN;
switch (id) {
case 0x6758:
case 0x6759:
case 0x6771:
case 0x6775:
case 0x6797:
ret = FM_CONNAC_LEGACY;
break;
case 0x6765:
case 0x6761:
case 0x3967:
ret = FM_CONNAC_1_0;
break;
case 0x6768:
case 0x6785:
case 0x8168:
ret = FM_CONNAC_1_2;
break;
case 0x6779:
case 0x6873:
case 0x6853:
ret = FM_CONNAC_1_5;
break;
default:
ret = FM_CONNAC_UNKNOWN;
break;
}
return ret;
#endif
}
static unsigned char drv_get_top_index(void)
{
if (drv_get_hw_version() < FM_CONNAC_1_5)
return 4;
return 5;
}
static unsigned int drv_get_get_adie(void)
{
#if defined(MT6625_FM) || defined(MT6627_FM) || defined(MT6630_FM) || defined(MT6632_FM) || defined(soc)
return 0;
#elif defined(MT6631_FM)
return 0x6631;
#elif defined(MT6635_FM)
return 0x6635;
#else
return mtk_wcn_wmt_ic_info_get(WMTCHIN_ADIE);
#endif
}
signed int __weak fm_low_ops_register(struct fm_callback *cb,
struct fm_basic_interface *bi)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak fm_low_ops_unregister(struct fm_basic_interface *bi)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak fm_rds_ops_register(struct fm_basic_interface *bi,
struct fm_rds_interface *ri)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak fm_rds_ops_unregister(struct fm_rds_interface *ri)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak mt6631_fm_low_ops_register(
struct fm_callback *cb, struct fm_basic_interface *bi)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak mt6631_fm_low_ops_unregister(struct fm_basic_interface *bi)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak mt6631_fm_rds_ops_register(
struct fm_basic_interface *bi, struct fm_rds_interface *ri)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak mt6631_fm_rds_ops_unregister(struct fm_rds_interface *ri)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak mt6635_fm_low_ops_register(
struct fm_callback *cb, struct fm_basic_interface *bi)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak mt6635_fm_low_ops_unregister(struct fm_basic_interface *bi)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak mt6635_fm_rds_ops_register(
struct fm_basic_interface *bi, struct fm_rds_interface *ri)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
signed int __weak mt6635_fm_rds_ops_unregister(struct fm_rds_interface *ri)
{
WCN_DBG(FM_NTC | CHIP, "default %s\n", __func__);
return -1;
}
void register_fw_ops_init(void)
{
struct fm_ext_interface *ei = &fm_wcn_ops.ei;
unsigned int adie = drv_get_get_adie();
ei->eint_handler = fw_eint_handler;
ei->stp_send_data = fm_stp_send_data;
ei->stp_recv_data = fm_stp_recv_data;
ei->stp_register_event_cb = fm_stp_register_event_cb;
ei->wmt_msgcb_reg = fm_wmt_msgcb_reg;
ei->wmt_func_on = fm_wmt_func_on;
ei->wmt_func_off = fm_wmt_func_off;
ei->wmt_ic_info_get = fm_wmt_ic_info_get;
ei->wmt_chipid_query = fm_wmt_chipid_query;
ei->spi_clock_switch = fm_drv_spi_clock_switch;
ei->get_hw_version = drv_get_hw_version;
ei->get_top_index = drv_get_top_index;
ei->get_get_adie = drv_get_get_adie;
WCN_DBG(FM_NTC | CHIP, "adie=0x%x\n", adie);
if (adie == 0x6631) {
ei->low_ops_register = mt6631_fm_low_ops_register;
ei->low_ops_unregister = mt6631_fm_low_ops_unregister;
ei->rds_ops_register = mt6631_fm_rds_ops_register;
ei->rds_ops_unregister = mt6631_fm_rds_ops_unregister;
} else if (adie == 0x6635) {
ei->low_ops_register = mt6635_fm_low_ops_register;
ei->low_ops_unregister = mt6635_fm_low_ops_unregister;
ei->rds_ops_register = mt6635_fm_rds_ops_register;
ei->rds_ops_unregister = mt6635_fm_rds_ops_unregister;
} else {
#if defined(MT6631_FM)
ei->low_ops_register = mt6631_fm_low_ops_register;
ei->low_ops_unregister = mt6631_fm_low_ops_unregister;
ei->rds_ops_register = mt6631_fm_rds_ops_register;
ei->rds_ops_unregister = mt6631_fm_rds_ops_unregister;
#elif defined(MT6635_FM)
ei->low_ops_register = mt6635_fm_low_ops_register;
ei->low_ops_unregister = mt6635_fm_low_ops_unregister;
ei->rds_ops_register = mt6635_fm_rds_ops_register;
ei->rds_ops_unregister = mt6635_fm_rds_ops_unregister;
#else
ei->low_ops_register = fm_low_ops_register;
ei->low_ops_unregister = fm_low_ops_unregister;
ei->rds_ops_register = fm_rds_ops_register;
ei->rds_ops_unregister = fm_rds_ops_unregister;
#endif
}
}
void register_fw_ops_uninit(void)
{
}
int fm_register_irq(struct platform_driver *drv, unsigned int irq_num)
{
return 0;
}
int fm_register_plat(unsigned int family_id, unsigned int conn_id)
{
return 0;
}
int fm_wcn_ops_register(void)
{
register_fw_ops_init();
return 0;
}
int fm_wcn_ops_unregister(void)
{
register_fw_ops_uninit();
return 0;
}