/*
|
* Copyright (C) 2017 Spreadtrum Communications Inc.
|
*
|
* This software is licensed under the terms of the GNU General Public
|
* License version 2, as published by the Free Software Foundation, and
|
* may be copied, distributed, and modified under those terms.
|
*
|
* 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 <linux/clk.h>
|
#include <linux/delay.h>
|
#include <linux/file.h>
|
#include <linux/firmware.h>
|
#include <linux/fs.h>
|
#include <linux/gnss.h>
|
#include <linux/kernel.h>
|
#include <linux/kthread.h>
|
#include <linux/mm.h>
|
#include <linux/module.h>
|
#include <linux/mfd/syscon.h>
|
#include <linux/of_gpio.h>
|
#include <linux/of_address.h>
|
#include <linux/of_device.h>
|
#include <linux/proc_fs.h>
|
#include <linux/platform_device.h>
|
#include <linux/regulator/consumer.h>
|
#include <linux/regmap.h>
|
#include <linux/sipc.h>
|
#include <linux/slab.h>
|
#include <linux/sprd_otp.h>
|
#include <linux/unistd.h>
|
#include <linux/vmalloc.h>
|
#include <linux/workqueue.h>
|
|
#include "gnss_firmware_bin.h"
|
#include "marlin_firmware_bin.h"
|
#include "wcn_glb.h"
|
#include "wcn_glb_reg.h"
|
#include "wcn_log.h"
|
#include "wcn_misc.h"
|
#include "wcn_procfs.h"
|
#include "wcn_txrx.h"
|
|
struct wcn_device_manage s_wcn_device;
|
|
static void wcn_global_source_init(void)
|
{
|
wcn_boot_init();
|
WCN_INFO("init finish!\n");
|
}
|
|
#ifdef CONFIG_PM_SLEEP
|
static int wcn_resume(struct device *dev)
|
{
|
WCN_INFO("enter\n");
|
#if SUSPEND_RESUME_ENABLE
|
slp_mgr_resume();
|
#endif
|
WCN_INFO("ok\n");
|
|
return 0;
|
}
|
|
static int wcn_suspend(struct device *dev)
|
{
|
WCN_INFO("enter\n");
|
#if SUSPEND_RESUME_ENABLE
|
slp_mgr_suspend();
|
#endif
|
WCN_INFO("ok\n");
|
|
return 0;
|
}
|
#endif /* CONFIG_PM_SLEEP */
|
|
#if WCN_INTEGRATE_PLATFORM_DEBUG
|
static u32 s_wcn_debug_case;
|
static struct task_struct *s_thead_wcn_codes_debug;
|
static int wcn_codes_debug_thread(void *data)
|
{
|
u32 i;
|
static u32 is_first_time = 1;
|
|
while (!kthread_should_stop()) {
|
switch (s_wcn_debug_case) {
|
case WCN_START_MARLIN_DEBUG:
|
for (i = 0; i < 16; i++)
|
start_integrate_wcn(i);
|
|
s_wcn_debug_case = 0;
|
break;
|
|
case WCN_STOP_MARLIN_DEBUG:
|
for (i = 0; i < 16; i++)
|
stop_integrate_wcn(i);
|
|
s_wcn_debug_case = 0;
|
break;
|
|
case WCN_START_MARLIN_DDR_FIRMWARE_DEBUG:
|
for (i = 0; i < 16; i++)
|
start_integrate_wcn(i);
|
|
s_wcn_debug_case = 0;
|
break;
|
|
case WCN_START_GNSS_DEBUG:
|
for (i = 16; i < 32; i++)
|
start_integrate_wcn(i);
|
|
s_wcn_debug_case = 0;
|
break;
|
|
case WCN_STOP_GNSS_DEBUG:
|
for (i = 16; i < 32; i++)
|
stop_integrate_wcn(i);
|
|
s_wcn_debug_case = 0;
|
break;
|
|
case WCN_START_GNSS_DDR_FIRMWARE_DEBUG:
|
for (i = 16; i < 32; i++)
|
start_integrate_wcn(i);
|
|
s_wcn_debug_case = 0;
|
break;
|
|
case WCN_PRINT_INFO:
|
WCN_INFO(
|
"cali[data=%p flag=%p]efuse=%p status=%p gnss=%p\n",
|
&s_wssm_phy_offset_p->wifi.calibration_data,
|
&s_wssm_phy_offset_p->wifi.calibration_flag,
|
&s_wssm_phy_offset_p->wifi.efuse[0],
|
&s_wssm_phy_offset_p->marlin.init_status,
|
&s_wssm_phy_offset_p->include_gnss);
|
break;
|
|
case WCN_BRINGUP_DEBUG:
|
if (is_first_time) {
|
msleep(100000);
|
is_first_time = 0;
|
}
|
|
for (i = 0; i < 16; i++) {
|
msleep(5000);
|
start_integrate_wcn(i);
|
}
|
|
for (i = 0; i < 16; i++) {
|
msleep(5000);
|
stop_integrate_wcn(i);
|
}
|
|
break;
|
|
default:
|
msleep(5000);
|
break;
|
}
|
}
|
|
kthread_stop(s_thead_wcn_codes_debug);
|
|
return 0;
|
}
|
|
static void wcn_codes_debug(void)
|
{
|
/* Check reg read */
|
s_thead_wcn_codes_debug = kthread_create(wcn_codes_debug_thread, NULL,
|
"wcn_codes_debug");
|
wake_up_process(s_thead_wcn_codes_debug);
|
}
|
#endif
|
|
static void wcn_config_ctrlreg(struct wcn_device *wcn_dev, u32 start, u32 end)
|
{
|
u32 reg_read, type, i, val, utemp_val;
|
|
for (i = start; i < end; i++) {
|
val = 0;
|
type = wcn_dev->ctrl_type[i];
|
reg_read = wcn_dev->ctrl_reg[i] -
|
wcn_dev->ctrl_rw_offset[i];
|
wcn_regmap_read(wcn_dev->rmap[type], reg_read, &val);
|
WCN_INFO("ctrl_reg[%d]=0x%x,read=0x%x, set=%x\n",
|
i, reg_read, val,
|
wcn_dev->ctrl_value[i]);
|
utemp_val = wcn_dev->ctrl_value[i];
|
|
if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_PIKE2) {
|
if (wcn_dev->ctrl_rw_offset[i] == 0x00)
|
utemp_val = val | wcn_dev->ctrl_value[i];
|
}
|
|
WCN_INFO("rmap[%d]=%p,ctrl_reg[i]=\n",
|
type, wcn_dev->rmap[type]);
|
wcn_regmap_raw_write_bit(wcn_dev->rmap[type],
|
wcn_dev->ctrl_reg[i],
|
utemp_val);
|
if (wcn_dev->ctrl_us_delay[i] >= 10)
|
usleep_range(wcn_dev->ctrl_us_delay[i],
|
wcn_dev->ctrl_us_delay[i] + 40);
|
else
|
udelay(wcn_dev->ctrl_us_delay[i]);
|
wcn_regmap_read(wcn_dev->rmap[type], reg_read, &val);
|
WCN_INFO("ctrl_reg[%d] = 0x%x, val=0x%x\n",
|
i, reg_read, val);
|
}
|
}
|
|
void wcn_cpu_bootup(struct wcn_device *wcn_dev)
|
{
|
u32 reg_nr;
|
|
if (!wcn_dev)
|
return;
|
|
reg_nr = wcn_dev->reg_nr < REG_CTRL_CNT_MAX ?
|
wcn_dev->reg_nr : REG_CTRL_CNT_MAX;
|
wcn_config_ctrlreg(wcn_dev, wcn_dev->ctrl_probe_num, reg_nr);
|
}
|
|
static struct wcn_proc_data g_proc_data;
|
static const struct of_device_id wcn_match_table[] = {
|
{ .compatible = "sprd,integrate_marlin", .data = &g_proc_data},
|
{ .compatible = "sprd,integrate_gnss", .data = &g_proc_data},
|
{ },
|
};
|
|
static int wcn_parse_dt(struct platform_device *pdev,
|
struct wcn_device *wcn_dev)
|
{
|
struct device_node *np = pdev->dev.of_node;
|
u32 cr_num;
|
int index, ret;
|
u32 i;
|
struct resource res;
|
const struct of_device_id *of_id =
|
of_match_node(wcn_match_table, np);
|
struct wcn_proc_data *pcproc_data;
|
|
WCN_INFO("start!\n");
|
|
if (of_id)
|
pcproc_data = (struct wcn_proc_data *)of_id->data;
|
else {
|
WCN_ERR("not find matched id!");
|
return -EINVAL;
|
}
|
|
if (!wcn_dev) {
|
WCN_ERR("wcn_dev NULL\n");
|
return -EINVAL;
|
}
|
|
/* get the wcn chip name */
|
ret = of_property_read_string(np,
|
"sprd,name",
|
(const char **)&wcn_dev->name);
|
|
/* get apb reg handle */
|
wcn_dev->rmap[REGMAP_AON_APB] = syscon_regmap_lookup_by_phandle(np,
|
"sprd,syscon-ap-apb");
|
if (IS_ERR(wcn_dev->rmap[REGMAP_AON_APB])) {
|
WCN_ERR("failed to find sprd,syscon-ap-apb\n");
|
return -EINVAL;
|
}
|
|
wcn_parse_platform_chip_id(wcn_dev);
|
|
/* get pmu reg handle */
|
wcn_dev->rmap[REGMAP_PMU_APB] = syscon_regmap_lookup_by_phandle(np,
|
"sprd,syscon-ap-pmu");
|
if (IS_ERR(wcn_dev->rmap[REGMAP_PMU_APB])) {
|
WCN_ERR("failed to find sprd,syscon-ap-pmu\n");
|
return -EINVAL;
|
}
|
|
/* get pub apb reg handle:SHARKLE has it, but PIKE2 hasn't */
|
if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKLE) {
|
wcn_dev->rmap[REGMAP_PUB_APB] =
|
syscon_regmap_lookup_by_phandle(np,
|
"sprd,syscon-ap-pub-apb");
|
if (IS_ERR(wcn_dev->rmap[REGMAP_PUB_APB])) {
|
WCN_ERR("failed to find sprd,syscon-ap-pub-apb\n");
|
return -EINVAL;
|
}
|
}
|
|
/* get anlg wrap wcn reg handle */
|
wcn_dev->rmap[REGMAP_ANLG_WRAP_WCN] =
|
syscon_regmap_lookup_by_phandle(
|
np, "sprd,syscon-anlg-wrap-wcn");
|
if (IS_ERR(wcn_dev->rmap[REGMAP_ANLG_WRAP_WCN])) {
|
WCN_ERR("failed to find sprd,anlg-wrap-wcn\n");
|
return -EINVAL;
|
}
|
|
if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKLE) {
|
/* get anlg wrap wcn reg handle */
|
wcn_dev->rmap[REGMAP_ANLG_PHY_G6] =
|
syscon_regmap_lookup_by_phandle(
|
np, "sprd,syscon-anlg-phy-g6");
|
if (IS_ERR(wcn_dev->rmap[REGMAP_ANLG_PHY_G6])) {
|
WCN_ERR("failed to find sprd,anlg-phy-g6\n");
|
return -EINVAL;
|
}
|
}
|
|
/* SharkL3:The base Reg changed which used by AP read CP2 Regs */
|
if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKL3) {
|
/* get anlg wrap wcn reg handle */
|
wcn_dev->rmap[REGMAP_WCN_REG] =
|
syscon_regmap_lookup_by_phandle(np, "sprd,syscon-wcn-reg");
|
if (IS_ERR(wcn_dev->rmap[REGMAP_WCN_REG])) {
|
WCN_ERR("failed to find sprd,wcn-reg\n");
|
return -EINVAL;
|
}
|
|
WCN_INFO("success to find sprd,wcn-reg for SharkL3 %p\n",
|
wcn_dev->rmap[REGMAP_WCN_REG]);
|
}
|
|
if (wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKL3) {
|
/* get anlg wrap wcn reg handle */
|
wcn_dev->rmap[REGMAP_ANLG_PHY_G5] =
|
syscon_regmap_lookup_by_phandle(np, "sprd,syscon-anlg-phy-g5");
|
if (IS_ERR(wcn_dev->rmap[REGMAP_ANLG_PHY_G5]))
|
WCN_ERR("failed to find sprd,anlg-phy-g5\n");
|
}
|
|
ret = of_property_read_u32(np, "sprd,ctrl-probe-num",
|
&wcn_dev->ctrl_probe_num);
|
if (ret) {
|
WCN_ERR("failed to find sprd,ctrl-probe-num\n");
|
return -EINVAL;
|
}
|
|
/*
|
* get ctrl_reg offset, the ctrl-reg variable number, so need
|
* to start reading from the largest until success
|
*/
|
cr_num = of_property_count_elems_of_size(np, "sprd,ctrl-reg", 4);
|
if (cr_num > REG_CTRL_CNT_MAX) {
|
WCN_ERR("DTS config err. cr_num=%d\n", cr_num);
|
return -EINVAL;
|
}
|
|
do {
|
ret = of_property_read_u32_array(np, "sprd,ctrl-reg",
|
(u32 *)wcn_dev->ctrl_reg, cr_num);
|
if (ret)
|
cr_num--;
|
if (!cr_num)
|
return -EINVAL;
|
} while (ret);
|
|
wcn_dev->reg_nr = cr_num;
|
for (i = 0; i < cr_num; i++)
|
WCN_INFO("ctrl_reg[%d] = 0x%x\n",
|
i, wcn_dev->ctrl_reg[i]);
|
|
/* get ctrl_mask */
|
ret = of_property_read_u32_array(np, "sprd,ctrl-mask",
|
(u32 *)wcn_dev->ctrl_mask, cr_num);
|
if (ret)
|
return -EINVAL;
|
for (i = 0; i < cr_num; i++)
|
WCN_INFO("ctrl_mask[%d] = 0x%08x\n",
|
i, wcn_dev->ctrl_mask[i]);
|
|
/* get ctrl_value */
|
ret = of_property_read_u32_array(np,
|
"sprd,ctrl-value",
|
(u32 *)wcn_dev->ctrl_value,
|
cr_num);
|
if (ret)
|
return -EINVAL;
|
for (i = 0; i < cr_num; i++)
|
WCN_INFO("ctrl_value[%d] = 0x%08x\n",
|
i, wcn_dev->ctrl_value[i]);
|
|
/* get ctrl_rw_offset */
|
ret = of_property_read_u32_array(np,
|
"sprd,ctrl-rw-offset",
|
(u32 *)wcn_dev->ctrl_rw_offset,
|
cr_num);
|
if (ret)
|
return -EINVAL;
|
for (i = 0; i < cr_num; i++)
|
WCN_INFO("ctrl_rw_offset[%d] = 0x%08x\n",
|
i, wcn_dev->ctrl_rw_offset[i]);
|
|
/* get ctrl_us_delay */
|
ret = of_property_read_u32_array(np,
|
"sprd,ctrl-us-delay",
|
(u32 *)wcn_dev->ctrl_us_delay,
|
cr_num);
|
if (ret)
|
return -EINVAL;
|
for (i = 0; i < cr_num; i++)
|
WCN_INFO("ctrl_us_delay[%d] = 0x%08x\n",
|
i, wcn_dev->ctrl_us_delay[i]);
|
|
/* get ctrl_type */
|
ret = of_property_read_u32_array(np, "sprd,ctrl-type",
|
(u32 *)wcn_dev->ctrl_type, cr_num);
|
if (ret)
|
return -EINVAL;
|
|
for (i = 0; i < cr_num; i++)
|
WCN_INFO("ctrl_type[%d] = 0x%08x\n",
|
i, wcn_dev->ctrl_type[i]);
|
|
/*
|
* Add a new group to control shut down WCN
|
* get ctrl_reg offset, the ctrl-reg variable number, so need
|
* to start reading from the largest until success
|
*/
|
cr_num = of_property_count_elems_of_size(np,
|
"sprd,ctrl-shutdown-reg", 4);
|
if (cr_num > REG_CTRL_CNT_MAX) {
|
WCN_ERR("DTS config err. cr_num=%d\n", cr_num);
|
return -EINVAL;
|
}
|
|
do {
|
ret = of_property_read_u32_array(np,
|
"sprd,ctrl-shutdown-reg",
|
(u32 *)wcn_dev->ctrl_shutdown_reg,
|
cr_num);
|
if (ret)
|
cr_num--;
|
if (!cr_num)
|
return -EINVAL;
|
} while (ret);
|
|
wcn_dev->reg_shutdown_nr = cr_num;
|
for (i = 0; i < cr_num; i++) {
|
WCN_INFO("ctrl_shutdown_reg[%d] = 0x%x\n",
|
i, wcn_dev->ctrl_shutdown_reg[i]);
|
}
|
|
/* get ctrl_shutdown_mask */
|
ret = of_property_read_u32_array(np,
|
"sprd,ctrl-shutdown-mask",
|
(u32 *)wcn_dev->ctrl_shutdown_mask,
|
cr_num);
|
if (ret)
|
return -EINVAL;
|
for (i = 0; i < cr_num; i++) {
|
WCN_INFO("ctrl_shutdown_mask[%d] = 0x%08x\n",
|
i, wcn_dev->ctrl_shutdown_mask[i]);
|
}
|
|
/* get ctrl_shutdown_value */
|
ret = of_property_read_u32_array(np, "sprd,ctrl-shutdown-value",
|
(u32 *)wcn_dev->ctrl_shutdown_value, cr_num);
|
if (ret)
|
return -EINVAL;
|
for (i = 0; i < cr_num; i++) {
|
WCN_INFO("ctrl_shutdown_value[%d] = 0x%08x\n",
|
i, wcn_dev->ctrl_shutdown_value[i]);
|
}
|
|
/* get ctrl_shutdown_rw_offset */
|
ret = of_property_read_u32_array(np,
|
"sprd,ctrl-shutdown-rw-offset",
|
(u32 *)wcn_dev->ctrl_shutdown_rw_offset, cr_num);
|
if (ret)
|
return -EINVAL;
|
for (i = 0; i < cr_num; i++) {
|
WCN_INFO("ctrl_shutdown_rw_offset[%d] = 0x%08x\n",
|
i, wcn_dev->ctrl_shutdown_rw_offset[i]);
|
}
|
|
/* get ctrl_shutdown_us_delay */
|
ret = of_property_read_u32_array(np,
|
"sprd,ctrl-shutdown-us-delay",
|
(u32 *)wcn_dev->ctrl_shutdown_us_delay, cr_num);
|
if (ret)
|
return -EINVAL;
|
for (i = 0; i < cr_num; i++) {
|
WCN_INFO("ctrl_shutdown_us_delay[%d] = 0x%08x\n",
|
i, wcn_dev->ctrl_shutdown_us_delay[i]);
|
}
|
|
/* get ctrl_shutdown_type */
|
ret = of_property_read_u32_array(np,
|
"sprd,ctrl-shutdown-type",
|
(u32 *)wcn_dev->ctrl_shutdown_type, cr_num);
|
if (ret)
|
return -EINVAL;
|
|
for (i = 0; i < cr_num; i++)
|
WCN_INFO("ctrl_shutdown_type[%d] = 0x%08x\n",
|
i, wcn_dev->ctrl_shutdown_type[i]);
|
|
/* get vddwcn */
|
if (s_wcn_device.vddwcn == NULL) {
|
s_wcn_device.vddwcn = devm_regulator_get(&pdev->dev,
|
"vddwcn");
|
if (IS_ERR(s_wcn_device.vddwcn)) {
|
WCN_ERR("Get regulator of vddwcn error!\n");
|
return -EINVAL;
|
}
|
}
|
|
/* get vddwifipa: only MARLIN has it */
|
if (strcmp(wcn_dev->name, WCN_MARLIN_DEV_NAME) == 0) {
|
wcn_dev->vddwifipa = devm_regulator_get(&pdev->dev,
|
"vddwifipa");
|
if (IS_ERR(wcn_dev->vddwifipa)) {
|
WCN_ERR("Get regulator of vddwifipa error!\n");
|
return -EINVAL;
|
}
|
}
|
|
/* get cp base */
|
index = 0;
|
ret = of_address_to_resource(np, index, &res);
|
if (ret)
|
return -EINVAL;
|
wcn_dev->base_addr = res.start;
|
wcn_dev->maxsz = res.end - res.start + 1;
|
WCN_INFO("cp base = %llu, size = 0x%x\n",
|
(u64)wcn_dev->base_addr, wcn_dev->maxsz);
|
|
ret = of_property_read_string(np, "sprd,file-name",
|
(const char **)&wcn_dev->file_path);
|
if (!ret)
|
WCN_INFO("firmware name:%s\n", wcn_dev->file_path);
|
|
ret = of_property_read_string(np, "sprd,file-name-ext",
|
(const char **)&wcn_dev->file_path_ext);
|
if (!ret)
|
WCN_INFO("firmware name ext:%s\n", wcn_dev->file_path_ext);
|
/* get cp source file length */
|
ret = of_property_read_u32_index(np,
|
"sprd,file-length",
|
0,
|
&wcn_dev->file_length);
|
WCN_INFO("wcn_dev->file_length:%d\n", wcn_dev->file_length);
|
if (ret)
|
return -EINVAL;
|
|
wcn_dev->start = pcproc_data->start;
|
wcn_dev->stop = pcproc_data->stop;
|
|
return 0;
|
}
|
|
static struct wcn_proc_data g_proc_data = {
|
.start = wcn_proc_native_start,
|
.stop = wcn_proc_native_stop,
|
};
|
|
static int wcn_platform_open(struct inode *inode, struct file *filp)
|
{
|
struct platform_proc_file_entry
|
*entry = (struct platform_proc_file_entry *)PDE_DATA(inode);
|
|
WCN_INFO("entry name:%s\n!", entry->name);
|
|
filp->private_data = entry;
|
|
return 0;
|
}
|
|
static ssize_t wcn_platform_read(struct file *filp,
|
char __user *buf,
|
size_t count, loff_t *ppos)
|
{
|
return 0;
|
}
|
|
static ssize_t wcn_platform_write(struct file *filp,
|
const char __user *buf,
|
size_t count,
|
loff_t *ppos)
|
{
|
struct platform_proc_file_entry
|
*entry = (struct platform_proc_file_entry *)filp->private_data;
|
struct wcn_device *wcn_dev = entry->wcn_dev;
|
char *type = entry->name;
|
unsigned int flag;
|
char str[WCN_PROC_FILE_LENGTH_MAX + 1];
|
u32 sub_sys = 0;
|
|
flag = entry->flag;
|
WCN_INFO("type = %s flag = 0x%x\n", type, flag);
|
|
if ((flag & BE_WRONLY) == 0)
|
return -EPERM;
|
|
memset(&str[0], 0, WCN_PROC_FILE_LENGTH_MAX + 1);
|
if (copy_from_user(&str[0], buf, WCN_PROC_FILE_LENGTH_MAX) == 0) {
|
if (strncmp(str, "gnss", strlen("gnss")) == 0)
|
sub_sys = WCN_GNSS;
|
else
|
sub_sys = str[0] - '0';
|
} else {
|
WCN_ERR("copy_from_user too length %s!\n", buf);
|
return -EINVAL;
|
}
|
|
if ((flag & BE_CTRL_ON) != 0) {
|
start_integrate_wcn(sub_sys);
|
wcn_dev->status = CP_NORMAL_STATUS;
|
WCN_INFO("start, str=%s!\n", str);
|
|
return count;
|
} else if ((flag & BE_CTRL_OFF) != 0) {
|
stop_integrate_wcn(sub_sys);
|
wcn_dev->status = CP_STOP_STATUS;
|
WCN_INFO("stop, str=%s!\n", str);
|
|
return count;
|
}
|
|
return 0;
|
}
|
|
static const struct file_operations wcn_platform_fs_fops = {
|
.open = wcn_platform_open,
|
.read = wcn_platform_read,
|
.write = wcn_platform_write,
|
};
|
|
static inline void wcn_platform_fs_init(struct wcn_device *wcn_dev)
|
{
|
u8 i, ucnt;
|
unsigned int flag;
|
umode_t mode = 0;
|
|
wcn_dev->platform_fs.platform_proc_dir_entry =
|
proc_mkdir(wcn_dev->name, NULL);
|
|
memset(wcn_dev->platform_fs.entrys,
|
0,
|
sizeof(wcn_dev->platform_fs.entrys));
|
|
for (flag = 0, ucnt = 0, i = 0;
|
i < MAX_PLATFORM_ENTRY_NUM;
|
i++, flag = 0, mode = 0) {
|
switch (i) {
|
case 0:
|
wcn_dev->platform_fs.entrys[i].name = "start";
|
flag |= (BE_WRONLY | BE_CTRL_ON);
|
ucnt++;
|
break;
|
|
case 1:
|
wcn_dev->platform_fs.entrys[i].name = "stop";
|
flag |= (BE_WRONLY | BE_CTRL_OFF);
|
ucnt++;
|
break;
|
|
case 2:
|
wcn_dev->platform_fs.entrys[i].name = "status";
|
flag |= (BE_RDONLY | BE_RDWDTS);
|
ucnt++;
|
break;
|
|
default:
|
return; /* we didn't use it until now */
|
}
|
|
wcn_dev->platform_fs.entrys[i].flag = flag;
|
|
mode |= (0600);
|
if (flag & (BE_CPDUMP | BE_MNDUMP))
|
mode |= 0004;
|
|
WCN_INFO("entry name is %s type 0x%x addr: 0x%p\n",
|
wcn_dev->platform_fs.entrys[i].name,
|
wcn_dev->platform_fs.entrys[i].flag,
|
&wcn_dev->platform_fs.entrys[i]);
|
|
wcn_dev->platform_fs.entrys[i].platform_proc_dir_entry =
|
proc_create_data(
|
wcn_dev->platform_fs.entrys[i].name,
|
mode,
|
wcn_dev->platform_fs.platform_proc_dir_entry,
|
&wcn_platform_fs_fops,
|
&wcn_dev->platform_fs.entrys[i]);
|
wcn_dev->platform_fs.entrys[i].wcn_dev = wcn_dev;
|
}
|
}
|
|
static inline void wcn_platform_fs_exit(struct wcn_device *wcn_dev)
|
{
|
u8 i = 0;
|
|
for (i = 0; i < MAX_PLATFORM_ENTRY_NUM; i++) {
|
if (!wcn_dev->platform_fs.entrys[i].name)
|
break;
|
|
if (wcn_dev->platform_fs.entrys[i].flag != 0) {
|
remove_proc_entry(wcn_dev->platform_fs.entrys[i].name,
|
wcn_dev->platform_fs.platform_proc_dir_entry);
|
}
|
}
|
|
remove_proc_entry(wcn_dev->name, NULL);
|
}
|
|
static int wcn_probe(struct platform_device *pdev)
|
{
|
struct wcn_device *wcn_dev;
|
static int first = 1;
|
|
WCN_INFO("start!\n");
|
|
wcn_dev = kzalloc(sizeof(struct wcn_device), GFP_KERNEL);
|
if (!wcn_dev)
|
return -ENOMEM;
|
|
if (wcn_parse_dt(pdev, wcn_dev) < 0) {
|
WCN_ERR("wcn_parse_dt Failed!\n");
|
kfree(wcn_dev);
|
return -EINVAL;
|
}
|
|
/* init the regs which can be init in the driver probe */
|
wcn_config_ctrlreg(wcn_dev, 0, wcn_dev->ctrl_probe_num);
|
|
mutex_init(&(wcn_dev->power_lock));
|
|
wcn_platform_fs_init(wcn_dev);
|
|
platform_set_drvdata(pdev, (void *)wcn_dev);
|
|
if (strcmp(wcn_dev->name, WCN_MARLIN_DEV_NAME) == 0)
|
s_wcn_device.btwf_device = wcn_dev;
|
else if (strcmp(wcn_dev->name, WCN_GNSS_DEV_NAME) == 0)
|
s_wcn_device.gnss_device = wcn_dev;
|
|
/* default vddcon is 1.6V, we should set it to 1.2v */
|
if (s_wcn_device.vddcon_voltage_setted == false) {
|
s_wcn_device.vddcon_voltage_setted = true;
|
wcn_power_set_vddcon(WCN_VDDCON_WORK_VOLTAGE);
|
mutex_init(&(s_wcn_device.vddwcn_lock));
|
}
|
|
if (strcmp(wcn_dev->name, WCN_MARLIN_DEV_NAME) == 0) {
|
mutex_init(&(wcn_dev->vddwifipa_lock));
|
if (wcn_platform_chip_id() == AON_CHIP_ID_AA)
|
wcn_power_set_vddwifipa(WCN_VDDWIFIPA_WORK_VOLTAGE);
|
wcn_global_source_init();
|
|
/* register ops */
|
wcn_bus_init();
|
|
proc_fs_init();
|
log_dev_init();
|
mdbg_atcmd_owner_init();
|
wcn_marlin_write_efuse();
|
} else if (strcmp(wcn_dev->name, WCN_GNSS_DEV_NAME) == 0)
|
gnss_write_efuse_data();
|
|
INIT_DELAYED_WORK(&wcn_dev->power_wq, wcn_power_wq);
|
|
if (first) {
|
/* Transceiver can't get into LP, so force deep sleep */
|
if ((wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKLE) ||
|
(wcn_platform_chip_type() == WCN_PLATFORM_TYPE_SHARKL3)) {
|
wcn_sys_soft_release();
|
wcn_sys_deep_sleep_en();
|
}
|
first = 0;
|
}
|
|
#if WCN_INTEGRATE_PLATFORM_DEBUG
|
wcn_codes_debug();
|
#endif
|
|
WCN_INFO("finish!\n");
|
|
return 0;
|
}
|
|
static int wcn_remove(struct platform_device *pdev)
|
{
|
struct wcn_device *wcn_dev = platform_get_drvdata(pdev);
|
|
if (wcn_dev)
|
WCN_INFO("dev name %s\n", wcn_dev->name);
|
|
wcn_platform_fs_exit(wcn_dev);
|
kfree(wcn_dev);
|
wcn_dev = NULL;
|
|
return 0;
|
}
|
|
static void wcn_shutdown(struct platform_device *pdev)
|
{
|
struct wcn_device *wcn_dev = platform_get_drvdata(pdev);
|
|
if (wcn_dev && wcn_dev->wcn_open_status) {
|
/* CPU hold on */
|
wcn_proc_native_stop(wcn_dev);
|
/* wifipa power off */
|
if (strcmp(wcn_dev->name, WCN_MARLIN_DEV_NAME) == 0) {
|
wcn_marlin_power_enable_vddwifipa(false);
|
/* ASIC: disable vddcon, wifipa interval time > 1ms */
|
usleep_range(VDDWIFIPA_VDDCON_MIN_INTERVAL_TIME,
|
VDDWIFIPA_VDDCON_MAX_INTERVAL_TIME);
|
}
|
/* vddcon power off */
|
wcn_power_enable_vddcon(false);
|
wcn_sys_soft_reset();
|
wcn_sys_soft_release();
|
wcn_sys_deep_sleep_en();
|
WCN_INFO("dev name %s\n", wcn_dev->name);
|
}
|
}
|
|
static SIMPLE_DEV_PM_OPS(wcn_pm_ops, wcn_suspend, wcn_resume);
|
static struct platform_driver wcn_driver = {
|
.driver = {
|
.name = "wcn_integrate_platform",
|
.pm = &wcn_pm_ops,
|
.of_match_table = wcn_match_table,
|
},
|
.probe = wcn_probe,
|
.remove = wcn_remove,
|
.shutdown = wcn_shutdown,
|
};
|
|
static int __init wcn_init(void)
|
{
|
WCN_INFO("entry!\n");
|
|
return platform_driver_register(&wcn_driver);
|
}
|
late_initcall(wcn_init);
|
|
static void __exit wcn_exit(void)
|
{
|
platform_driver_unregister(&wcn_driver);
|
}
|
module_exit(wcn_exit);
|
|
MODULE_LICENSE("GPL v2");
|
MODULE_DESCRIPTION("Spreadtrum WCN Integrate Platform Driver");
|
MODULE_AUTHOR("YaoGuang Chen <yaoguang.chen@spreadtrum.com>");
|
