tobi/M7350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
2d95e8761a
M7350/kernel/drivers/net/wireless/wcnss/wcnss_wlan.c
T f9cc65cfda M7350v1_en_gpl
2024-09-09 08:52:07 +00:00

1965 lines
49 KiB
C
Raw Blame History

/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only 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 the
* GNU General Public License for more details.
*/
#include <linux/module.h>
#include <linux/firmware.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/wcnss_wlan.h>
#include <linux/platform_data/qcom_wcnss_device.h>
#include <linux/workqueue.h>
#include <linux/jiffies.h>
#include <linux/gpio.h>
#include <linux/wakelock.h>
#include <linux/delay.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/clk.h>
#include <linux/ratelimit.h>
#include <linux/kthread.h>
#include <linux/wait.h>
#include <linux/uaccess.h>
#include <linux/mfd/pm8xxx/misc.h>
#include <mach/msm_smd.h>
#include <mach/msm_iomap.h>
#include <mach/subsystem_restart.h>
#ifdef CONFIG_WCNSS_MEM_PRE_ALLOC
#include "wcnss_prealloc.h"
#endif
#define DEVICE "wcnss_wlan"
#define VERSION "1.01"
#define WCNSS_PIL_DEVICE "wcnss"
/* module params */
#define WCNSS_CONFIG_UNSPECIFIED (-1)
#define UINT32_MAX (0xFFFFFFFFU)
static int has_48mhz_xo = WCNSS_CONFIG_UNSPECIFIED;
module_param(has_48mhz_xo, int, S_IWUSR | S_IRUGO);
MODULE_PARM_DESC(has_48mhz_xo, "Is an external 48 MHz XO present");
static int has_calibrated_data = WCNSS_CONFIG_UNSPECIFIED;
module_param(has_calibrated_data, int, S_IWUSR | S_IRUGO);
MODULE_PARM_DESC(has_calibrated_data, "whether calibrated data file available");
static int has_autodetect_xo = WCNSS_CONFIG_UNSPECIFIED;
module_param(has_autodetect_xo, int, S_IWUSR | S_IRUGO);
MODULE_PARM_DESC(has_autodetect_xo, "Perform auto detect to configure IRIS XO");
static int do_not_cancel_vote = WCNSS_CONFIG_UNSPECIFIED;
module_param(do_not_cancel_vote, int, S_IWUSR | S_IRUGO);
MODULE_PARM_DESC(do_not_cancel_vote, "Do not cancel votes for wcnss");
static DEFINE_SPINLOCK(reg_spinlock);
#define MSM_RIVA_PHYS 0x03204000
#define MSM_PRONTO_PHYS 0xfb21b000
#define RIVA_SPARE_OFFSET 0x0b4
#define RIVA_SUSPEND_BIT BIT(24)
#define MSM_RIVA_CCU_BASE 0x03200800
#define CCU_RIVA_INVALID_ADDR_OFFSET 0x100
#define CCU_RIVA_LAST_ADDR0_OFFSET 0x104
#define CCU_RIVA_LAST_ADDR1_OFFSET 0x108
#define CCU_RIVA_LAST_ADDR2_OFFSET 0x10c
#define PRONTO_PMU_SPARE_OFFSET 0x1088
#define PRONTO_PMU_GDSCR_OFFSET 0x0024
#define PRONTO_PMU_GDSCR_SW_COLLAPSE BIT(0)
#define PRONTO_PMU_GDSCR_HW_CTRL BIT(1)
#define PRONTO_PMU_CBCR_OFFSET 0x0008
#define PRONTO_PMU_CBCR_CLK_EN BIT(0)
#define MSM_PRONTO_A2XB_BASE 0xfb100400
#define A2XB_CFG_OFFSET 0x00
#define A2XB_INT_SRC_OFFSET 0x0c
#define A2XB_TSTBUS_CTRL_OFFSET 0x14
#define A2XB_TSTBUS_OFFSET 0x18
#define A2XB_ERR_INFO_OFFSET 0x1c
#define WCNSS_TSTBUS_CTRL_EN BIT(0)
#define WCNSS_TSTBUS_CTRL_AXIM (0x02 << 1)
#define WCNSS_TSTBUS_CTRL_CMDFIFO (0x03 << 1)
#define WCNSS_TSTBUS_CTRL_WRFIFO (0x04 << 1)
#define WCNSS_TSTBUS_CTRL_RDFIFO (0x05 << 1)
#define WCNSS_TSTBUS_CTRL_CTRL (0x07 << 1)
#define WCNSS_TSTBUS_CTRL_AXIM_CFG0 (0x00 << 6)
#define WCNSS_TSTBUS_CTRL_AXIM_CFG1 (0x01 << 6)
#define WCNSS_TSTBUS_CTRL_CTRL_CFG0 (0x00 << 12)
#define WCNSS_TSTBUS_CTRL_CTRL_CFG1 (0x01 << 12)
#define MSM_PRONTO_CCPU_BASE 0xfb205050
#define CCU_PRONTO_INVALID_ADDR_OFFSET 0x08
#define CCU_PRONTO_LAST_ADDR0_OFFSET 0x0c
#define CCU_PRONTO_LAST_ADDR1_OFFSET 0x10
#define CCU_PRONTO_LAST_ADDR2_OFFSET 0x14
#define WCNSS_DEF_WLAN_RX_BUFF_COUNT 1024
#define WCNSS_CTRL_CHANNEL "WCNSS_CTRL"
#define WCNSS_MAX_FRAME_SIZE (4*1024)
#define WCNSS_VERSION_LEN 30
/* message types */
#define WCNSS_CTRL_MSG_START 0x01000000
#define WCNSS_VERSION_REQ (WCNSS_CTRL_MSG_START + 0)
#define WCNSS_VERSION_RSP (WCNSS_CTRL_MSG_START + 1)
#define WCNSS_NVBIN_DNLD_REQ (WCNSS_CTRL_MSG_START + 2)
#define WCNSS_NVBIN_DNLD_RSP (WCNSS_CTRL_MSG_START + 3)
#define WCNSS_CALDATA_UPLD_REQ (WCNSS_CTRL_MSG_START + 4)
#define WCNSS_CALDATA_UPLD_RSP (WCNSS_CTRL_MSG_START + 5)
#define WCNSS_CALDATA_DNLD_REQ (WCNSS_CTRL_MSG_START + 6)
#define WCNSS_CALDATA_DNLD_RSP (WCNSS_CTRL_MSG_START + 7)
#define VALID_VERSION(version) \
((strncmp(version, "INVALID", WCNSS_VERSION_LEN)) ? 1 : 0)
#define FW_CALDATA_CAPABLE() \
((penv->fw_major >= 1) && (penv->fw_minor >= 5) ? 1 : 0)
struct smd_msg_hdr {
unsigned int msg_type;
unsigned int msg_len;
};
struct wcnss_version {
struct smd_msg_hdr hdr;
unsigned char major;
unsigned char minor;
unsigned char version;
unsigned char revision;
};
struct wcnss_pmic_dump {
char reg_name[10];
u16 reg_addr;
};
static struct wcnss_pmic_dump wcnss_pmic_reg_dump[] = {
{"S2", 0x1D8},
{"L4", 0xB4},
{"L10", 0xC0},
{"LVS2", 0x62},
{"S4", 0x1E8},
{"LVS7", 0x06C},
{"LVS1", 0x060},
};
#define NVBIN_FILE "wlan/prima/WCNSS_qcom_wlan_nv.bin"
/*
* On SMD channel 4K of maximum data can be transferred, including message
* header, so NV fragment size as next multiple of 1Kb is 3Kb.
*/
#define NV_FRAGMENT_SIZE 3072
#define MAX_CALIBRATED_DATA_SIZE (64*1024)
#define LAST_FRAGMENT (1 << 0)
#define MESSAGE_TO_FOLLOW (1 << 1)
#define CAN_RECEIVE_CALDATA (1 << 15)
#define WCNSS_RESP_SUCCESS 1
#define WCNSS_RESP_FAIL 0
/* Macro to find the total number fragments of the NV bin Image */
#define TOTALFRAGMENTS(x) (((x % NV_FRAGMENT_SIZE) == 0) ? \
(x / NV_FRAGMENT_SIZE) : ((x / NV_FRAGMENT_SIZE) + 1))
struct nvbin_dnld_req_params {
/*
* Fragment sequence number of the NV bin Image. NV Bin Image
* might not fit into one message due to size limitation of
* the SMD channel FIFO so entire NV blob is chopped into
* multiple fragments starting with seqeunce number 0. The
* last fragment is indicated by marking is_last_fragment field
* to 1. At receiving side, NV blobs would be concatenated
* together without any padding bytes in between.
*/
unsigned short frag_number;
/*
* bit 0: When set to 1 it indicates that no more fragments will
* be sent.
* bit 1: When set, a new message will be followed by this message
* bit 2- bit 14: Reserved
* bit 15: when set, it indicates that the sender is capable of
* receiving Calibrated data.
*/
unsigned short msg_flags;
/* NV Image size (number of bytes) */
unsigned int nvbin_buffer_size;
/*
* Following the 'nvbin_buffer_size', there should be
* nvbin_buffer_size bytes of NV bin Image i.e.
* uint8[nvbin_buffer_size].
*/
};
struct nvbin_dnld_req_msg {
/*
* Note: The length specified in nvbin_dnld_req_msg messages
* should be hdr.msg_len = sizeof(nvbin_dnld_req_msg) +
* nvbin_buffer_size.
*/
struct smd_msg_hdr hdr;
struct nvbin_dnld_req_params dnld_req_params;
};
struct cal_data_params {
/* The total size of the calibrated data, including all the
* fragments.
*/
unsigned int total_size;
unsigned short frag_number;
/*
* bit 0: When set to 1 it indicates that no more fragments will
* be sent.
* bit 1: When set, a new message will be followed by this message
* bit 2- bit 15: Reserved
*/
unsigned short msg_flags;
/*
* fragment size
*/
unsigned int frag_size;
/*
* Following the frag_size, frag_size of fragmented
* data will be followed.
*/
};
struct cal_data_msg {
/*
* The length specified in cal_data_msg should be
* hdr.msg_len = sizeof(cal_data_msg) + frag_size
*/
struct smd_msg_hdr hdr;
struct cal_data_params cal_params;
};
static struct {
struct platform_device *pdev;
void *pil;
struct resource *mmio_res;
struct resource *tx_irq_res;
struct resource *rx_irq_res;
struct resource *gpios_5wire;
const struct dev_pm_ops *pm_ops;
int triggered;
int smd_channel_ready;
u32 wlan_rx_buff_count;
smd_channel_t *smd_ch;
unsigned char wcnss_version[WCNSS_VERSION_LEN];
unsigned char fw_major;
unsigned char fw_minor;
unsigned int serial_number;
int thermal_mitigation;
enum wcnss_hw_type wcnss_hw_type;
void (*tm_notify)(struct device *, int);
struct wcnss_wlan_config wlan_config;
struct delayed_work wcnss_work;
struct work_struct wcnssctrl_version_work;
struct work_struct wcnssctrl_nvbin_dnld_work;
struct work_struct wcnssctrl_rx_work;
struct wake_lock wcnss_wake_lock;
void __iomem *msm_wcnss_base;
void __iomem *riva_ccu_base;
void __iomem *pronto_a2xb_base;
void __iomem *pronto_ccpu_base;
void __iomem *fiq_reg;
int ssr_boot;
int nv_downloaded;
unsigned char *fw_cal_data;
unsigned char *user_cal_data;
int fw_cal_rcvd;
int fw_cal_exp_frag;
int fw_cal_available;
int user_cal_read;
int user_cal_available;
u32 user_cal_rcvd;
int user_cal_exp_size;
int device_opened;
struct mutex dev_lock;
wait_queue_head_t read_wait;
} *penv = NULL;
static ssize_t wcnss_serial_number_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
if (!penv)
return -ENODEV;
return scnprintf(buf, PAGE_SIZE, "%08X\n", penv->serial_number);
}
static ssize_t wcnss_serial_number_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
unsigned int value;
if (!penv)
return -ENODEV;
if (sscanf(buf, "%08X", &value) != 1)
return -EINVAL;
penv->serial_number = value;
return count;
}
static DEVICE_ATTR(serial_number, S_IRUSR | S_IWUSR,
wcnss_serial_number_show, wcnss_serial_number_store);
static ssize_t wcnss_thermal_mitigation_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
if (!penv)
return -ENODEV;
return scnprintf(buf, PAGE_SIZE, "%u\n", penv->thermal_mitigation);
}
static ssize_t wcnss_thermal_mitigation_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int value;
if (!penv)
return -ENODEV;
if (sscanf(buf, "%d", &value) != 1)
return -EINVAL;
penv->thermal_mitigation = value;
if (penv->tm_notify)
(penv->tm_notify)(dev, value);
return count;
}
static DEVICE_ATTR(thermal_mitigation, S_IRUSR | S_IWUSR,
wcnss_thermal_mitigation_show, wcnss_thermal_mitigation_store);
static ssize_t wcnss_version_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
if (!penv)
return -ENODEV;
return scnprintf(buf, PAGE_SIZE, "%s", penv->wcnss_version);
}
static DEVICE_ATTR(wcnss_version, S_IRUSR,
wcnss_version_show, NULL);
void wcnss_riva_dump_pmic_regs(void)
{
int i, rc;
u8 val;
for (i = 0; i < ARRAY_SIZE(wcnss_pmic_reg_dump); i++) {
val = 0;
rc = pm8xxx_read_register(wcnss_pmic_reg_dump[i].reg_addr,
&val);
if (rc)
pr_err("PMIC READ: Failed to read addr = %d\n",
wcnss_pmic_reg_dump[i].reg_addr);
else
pr_info_ratelimited("PMIC READ: %s addr = %x, value = %x\n",
wcnss_pmic_reg_dump[i].reg_name,
wcnss_pmic_reg_dump[i].reg_addr, val);
}
}
/* wcnss_reset_intr() is invoked when host drivers fails to
* communicate with WCNSS over SMD; so logging these registers
* helps to know WCNSS failure reason
*/
void wcnss_riva_log_debug_regs(void)
{
void __iomem *ccu_reg;
u32 reg = 0;
ccu_reg = penv->riva_ccu_base + CCU_RIVA_INVALID_ADDR_OFFSET;
reg = readl_relaxed(ccu_reg);
pr_info_ratelimited("%s: CCU_CCPU_INVALID_ADDR %08x\n", __func__, reg);
ccu_reg = penv->riva_ccu_base + CCU_RIVA_LAST_ADDR0_OFFSET;
reg = readl_relaxed(ccu_reg);
pr_info_ratelimited("%s: CCU_CCPU_LAST_ADDR0 %08x\n", __func__, reg);
ccu_reg = penv->riva_ccu_base + CCU_RIVA_LAST_ADDR1_OFFSET;
reg = readl_relaxed(ccu_reg);
pr_info_ratelimited("%s: CCU_CCPU_LAST_ADDR1 %08x\n", __func__, reg);
ccu_reg = penv->riva_ccu_base + CCU_RIVA_LAST_ADDR2_OFFSET;
reg = readl_relaxed(ccu_reg);
pr_info_ratelimited("%s: CCU_CCPU_LAST_ADDR2 %08x\n", __func__, reg);
wcnss_riva_dump_pmic_regs();
}
EXPORT_SYMBOL(wcnss_riva_log_debug_regs);
/* Log pronto debug registers before sending reset interrupt */
void wcnss_pronto_log_debug_regs(void)
{
void __iomem *reg_addr, *tst_addr, *tst_ctrl_addr;
u32 reg = 0;
reg_addr = penv->msm_wcnss_base + PRONTO_PMU_SPARE_OFFSET;
reg = readl_relaxed(reg_addr);
pr_info_ratelimited("%s: PRONTO_PMU_SPARE %08x\n", __func__, reg);
reg_addr = penv->msm_wcnss_base + PRONTO_PMU_GDSCR_OFFSET;
reg = readl_relaxed(reg_addr);
reg >>= 31;
if (!reg) {
pr_info_ratelimited("%s: Cannot log, Pronto common SS is power collapsed\n",
__func__);
return;
}
reg &= ~(PRONTO_PMU_GDSCR_SW_COLLAPSE | PRONTO_PMU_GDSCR_HW_CTRL);
writel_relaxed(reg, reg_addr);
reg_addr = penv->msm_wcnss_base + PRONTO_PMU_CBCR_OFFSET;
reg = readl_relaxed(reg_addr);
reg |= PRONTO_PMU_CBCR_CLK_EN;
writel_relaxed(reg, reg_addr);
reg_addr = penv->pronto_a2xb_base + A2XB_CFG_OFFSET;
reg = readl_relaxed(reg_addr);
pr_info_ratelimited("%s: A2XB_CFG_OFFSET %08x\n", __func__, reg);
reg_addr = penv->pronto_a2xb_base + A2XB_INT_SRC_OFFSET;
reg = readl_relaxed(reg_addr);
pr_info_ratelimited("%s: A2XB_INT_SRC_OFFSET %08x\n", __func__, reg);
reg_addr = penv->pronto_a2xb_base + A2XB_ERR_INFO_OFFSET;
reg = readl_relaxed(reg_addr);
pr_info_ratelimited("%s: A2XB_ERR_INFO_OFFSET %08x\n", __func__, reg);
reg_addr = penv->pronto_ccpu_base + CCU_PRONTO_INVALID_ADDR_OFFSET;
reg = readl_relaxed(reg_addr);
pr_info_ratelimited("%s: CCU_CCPU_INVALID_ADDR %08x\n", __func__, reg);
reg_addr = penv->pronto_ccpu_base + CCU_PRONTO_LAST_ADDR0_OFFSET;
reg = readl_relaxed(reg_addr);
pr_info_ratelimited("%s: CCU_CCPU_LAST_ADDR0 %08x\n", __func__, reg);
reg_addr = penv->pronto_ccpu_base + CCU_PRONTO_LAST_ADDR1_OFFSET;
reg = readl_relaxed(reg_addr);
pr_info_ratelimited("%s: CCU_CCPU_LAST_ADDR1 %08x\n", __func__, reg);
reg_addr = penv->pronto_ccpu_base + CCU_PRONTO_LAST_ADDR2_OFFSET;
reg = readl_relaxed(reg_addr);
pr_info_ratelimited("%s: CCU_CCPU_LAST_ADDR2 %08x\n", __func__, reg);
tst_addr = penv->pronto_a2xb_base + A2XB_TSTBUS_OFFSET;
tst_ctrl_addr = penv->pronto_a2xb_base + A2XB_TSTBUS_CTRL_OFFSET;
/* read data FIFO */
reg = 0;
reg = reg | WCNSS_TSTBUS_CTRL_EN | WCNSS_TSTBUS_CTRL_RDFIFO;
writel_relaxed(reg, tst_ctrl_addr);
reg = readl_relaxed(tst_addr);
pr_info_ratelimited("%s: Read data FIFO testbus %08x\n",
__func__, reg);
/* command FIFO */
reg = 0;
reg = reg | WCNSS_TSTBUS_CTRL_EN | WCNSS_TSTBUS_CTRL_CMDFIFO;
writel_relaxed(reg, tst_ctrl_addr);
reg = readl_relaxed(tst_addr);
pr_info_ratelimited("%s: Command FIFO testbus %08x\n",
__func__, reg);
/* write data FIFO */
reg = 0;
reg = reg | WCNSS_TSTBUS_CTRL_EN | WCNSS_TSTBUS_CTRL_WRFIFO;
writel_relaxed(reg, tst_ctrl_addr);
reg = readl_relaxed(tst_addr);
pr_info_ratelimited("%s: Rrite data FIFO testbus %08x\n",
__func__, reg);
/* AXIM SEL CFG0 */
reg = 0;
reg = reg | WCNSS_TSTBUS_CTRL_EN | WCNSS_TSTBUS_CTRL_AXIM |
WCNSS_TSTBUS_CTRL_AXIM_CFG0;
writel_relaxed(reg, tst_ctrl_addr);
reg = readl_relaxed(tst_addr);
pr_info_ratelimited("%s: AXIM SEL CFG0 testbus %08x\n",
__func__, reg);
/* AXIM SEL CFG1 */
reg = 0;
reg = reg | WCNSS_TSTBUS_CTRL_EN | WCNSS_TSTBUS_CTRL_AXIM |
WCNSS_TSTBUS_CTRL_AXIM_CFG1;
writel_relaxed(reg, tst_ctrl_addr);
reg = readl_relaxed(tst_addr);
pr_info_ratelimited("%s: AXIM SEL CFG1 testbus %08x\n",
__func__, reg);
/* CTRL SEL CFG0 */
reg = 0;
reg = reg | WCNSS_TSTBUS_CTRL_EN | WCNSS_TSTBUS_CTRL_CTRL |
WCNSS_TSTBUS_CTRL_CTRL_CFG0;
writel_relaxed(reg, tst_ctrl_addr);
reg = readl_relaxed(tst_addr);
pr_info_ratelimited("%s: CTRL SEL CFG0 testbus %08x\n",
__func__, reg);
/* CTRL SEL CFG1 */
reg = 0;
reg = reg | WCNSS_TSTBUS_CTRL_EN | WCNSS_TSTBUS_CTRL_CTRL |
WCNSS_TSTBUS_CTRL_CTRL_CFG1;
writel_relaxed(reg, tst_ctrl_addr);
reg = readl_relaxed(tst_addr);
pr_info_ratelimited("%s: CTRL SEL CFG1 testbus %08x\n", __func__, reg);
}
EXPORT_SYMBOL(wcnss_pronto_log_debug_regs);
/* interface to reset wcnss by sending the reset interrupt */
void wcnss_reset_intr(void)
{
if (wcnss_hardware_type() == WCNSS_PRONTO_HW) {
wcnss_pronto_log_debug_regs();
wmb();
__raw_writel(1 << 16, penv->fiq_reg);
} else {
wcnss_riva_log_debug_regs();
wmb();
__raw_writel(1 << 24, MSM_APCS_GCC_BASE + 0x8);
}
}
EXPORT_SYMBOL(wcnss_reset_intr);
static int wcnss_create_sysfs(struct device *dev)
{
int ret;
if (!dev)
return -ENODEV;
ret = device_create_file(dev, &dev_attr_serial_number);
if (ret)
return ret;
ret = device_create_file(dev, &dev_attr_thermal_mitigation);
if (ret)
goto remove_serial;
ret = device_create_file(dev, &dev_attr_wcnss_version);
if (ret)
goto remove_thermal;
return 0;
remove_thermal:
device_remove_file(dev, &dev_attr_thermal_mitigation);
remove_serial:
device_remove_file(dev, &dev_attr_serial_number);
return ret;
}
static void wcnss_remove_sysfs(struct device *dev)
{
if (dev) {
device_remove_file(dev, &dev_attr_serial_number);
device_remove_file(dev, &dev_attr_thermal_mitigation);
device_remove_file(dev, &dev_attr_wcnss_version);
}
}
static void wcnss_smd_notify_event(void *data, unsigned int event)
{
int len = 0;
if (penv != data) {
pr_err("wcnss: invalid env pointer in smd callback\n");
return;
}
switch (event) {
case SMD_EVENT_DATA:
len = smd_read_avail(penv->smd_ch);
if (len < 0) {
pr_err("wcnss: failed to read from smd %d\n", len);
return;
}
schedule_work(&penv->wcnssctrl_rx_work);
break;
case SMD_EVENT_OPEN:
pr_debug("wcnss: opening WCNSS SMD channel :%s",
WCNSS_CTRL_CHANNEL);
schedule_work(&penv->wcnssctrl_version_work);
break;
case SMD_EVENT_CLOSE:
pr_debug("wcnss: closing WCNSS SMD channel :%s",
WCNSS_CTRL_CHANNEL);
/* This SMD is closed only during SSR */
penv->ssr_boot = true;
penv->nv_downloaded = 0;
break;
default:
break;
}
}
static void wcnss_post_bootup(struct work_struct *work)
{
if (do_not_cancel_vote == 1) {
pr_info("%s: Keeping APPS vote for Iris & WCNSS\n", __func__);
return;
}
pr_info("%s: Cancel APPS vote for Iris & WCNSS\n", __func__);
/* Since WCNSS is up, cancel any APPS vote for Iris & WCNSS VREGs */
wcnss_wlan_power(&penv->pdev->dev, &penv->wlan_config,
WCNSS_WLAN_SWITCH_OFF);
}
static int
wcnss_pronto_gpios_config(struct device *dev, bool enable)
{
int rc = 0;
int i, j;
int WCNSS_WLAN_NUM_GPIOS = 5;
for (i = 0; i < WCNSS_WLAN_NUM_GPIOS; i++) {
int gpio = of_get_gpio(dev->of_node, i);
if (enable) {
rc = gpio_request(gpio, "wcnss_wlan");
if (rc) {
pr_err("WCNSS gpio_request %d err %d\n",
gpio, rc);
goto fail;
}
} else
gpio_free(gpio);
}
return rc;
fail:
for (j = WCNSS_WLAN_NUM_GPIOS-1; j >= 0; j--) {
int gpio = of_get_gpio(dev->of_node, i);
gpio_free(gpio);
}
return rc;
}
static int
wcnss_gpios_config(struct resource *gpios_5wire, bool enable)
{
int i, j;
int rc = 0;
for (i = gpios_5wire->start; i <= gpios_5wire->end; i++) {
if (enable) {
rc = gpio_request(i, gpios_5wire->name);
if (rc) {
pr_err("WCNSS gpio_request %d err %d\n", i, rc);
goto fail;
}
} else
gpio_free(i);
}
return rc;
fail:
for (j = i-1; j >= gpios_5wire->start; j--)
gpio_free(j);
return rc;
}
static int __devinit
wcnss_wlan_ctrl_probe(struct platform_device *pdev)
{
if (!penv)
return -ENODEV;
penv->smd_channel_ready = 1;
pr_info("%s: SMD ctrl channel up\n", __func__);
/* Schedule a work to do any post boot up activity */
INIT_DELAYED_WORK(&penv->wcnss_work, wcnss_post_bootup);
schedule_delayed_work(&penv->wcnss_work, msecs_to_jiffies(10000));
return 0;
}
void wcnss_flush_delayed_boot_votes()
{
flush_delayed_work(&penv->wcnss_work);
}
EXPORT_SYMBOL(wcnss_flush_delayed_boot_votes);
static int __devexit
wcnss_wlan_ctrl_remove(struct platform_device *pdev)
{
if (penv)
penv->smd_channel_ready = 0;
pr_info("%s: SMD ctrl channel down\n", __func__);
return 0;
}
static struct platform_driver wcnss_wlan_ctrl_driver = {
.driver = {
.name = "WLAN_CTRL",
.owner = THIS_MODULE,
},
.probe = wcnss_wlan_ctrl_probe,
.remove = __devexit_p(wcnss_wlan_ctrl_remove),
};
static int __devexit
wcnss_ctrl_remove(struct platform_device *pdev)
{
if (penv && penv->smd_ch)
smd_close(penv->smd_ch);
return 0;
}
static int __devinit
wcnss_ctrl_probe(struct platform_device *pdev)
{
int ret = 0;
if (!penv)
return -ENODEV;
ret = smd_named_open_on_edge(WCNSS_CTRL_CHANNEL, SMD_APPS_WCNSS,
&penv->smd_ch, penv, wcnss_smd_notify_event);
if (ret < 0) {
pr_err("wcnss: cannot open the smd command channel %s: %d\n",
WCNSS_CTRL_CHANNEL, ret);
return -ENODEV;
}
smd_disable_read_intr(penv->smd_ch);
return 0;
}
/* platform device for WCNSS_CTRL SMD channel */
static struct platform_driver wcnss_ctrl_driver = {
.driver = {
.name = "WCNSS_CTRL",
.owner = THIS_MODULE,
},
.probe = wcnss_ctrl_probe,
.remove = __devexit_p(wcnss_ctrl_remove),
};
struct device *wcnss_wlan_get_device(void)
{
if (penv && penv->pdev && penv->smd_channel_ready)
return &penv->pdev->dev;
return NULL;
}
EXPORT_SYMBOL(wcnss_wlan_get_device);
struct platform_device *wcnss_get_platform_device(void)
{
if (penv && penv->pdev)
return penv->pdev;
return NULL;
}
EXPORT_SYMBOL(wcnss_get_platform_device);
struct wcnss_wlan_config *wcnss_get_wlan_config(void)
{
if (penv && penv->pdev)
return &penv->wlan_config;
return NULL;
}
EXPORT_SYMBOL(wcnss_get_wlan_config);
int wcnss_device_ready(void)
{
if (penv && penv->pdev && penv->nv_downloaded)
return 1;
return 0;
}
EXPORT_SYMBOL(wcnss_device_ready);
struct resource *wcnss_wlan_get_memory_map(struct device *dev)
{
if (penv && dev && (dev == &penv->pdev->dev) && penv->smd_channel_ready)
return penv->mmio_res;
return NULL;
}
EXPORT_SYMBOL(wcnss_wlan_get_memory_map);
int wcnss_wlan_get_dxe_tx_irq(struct device *dev)
{
if (penv && dev && (dev == &penv->pdev->dev) &&
penv->tx_irq_res && penv->smd_channel_ready)
return penv->tx_irq_res->start;
return WCNSS_WLAN_IRQ_INVALID;
}
EXPORT_SYMBOL(wcnss_wlan_get_dxe_tx_irq);
int wcnss_wlan_get_dxe_rx_irq(struct device *dev)
{
if (penv && dev && (dev == &penv->pdev->dev) &&
penv->rx_irq_res && penv->smd_channel_ready)
return penv->rx_irq_res->start;
return WCNSS_WLAN_IRQ_INVALID;
}
EXPORT_SYMBOL(wcnss_wlan_get_dxe_rx_irq);
void wcnss_wlan_register_pm_ops(struct device *dev,
const struct dev_pm_ops *pm_ops)
{
if (penv && dev && (dev == &penv->pdev->dev) && pm_ops)
penv->pm_ops = pm_ops;
}
EXPORT_SYMBOL(wcnss_wlan_register_pm_ops);
void wcnss_wlan_unregister_pm_ops(struct device *dev,
const struct dev_pm_ops *pm_ops)
{
if (penv && dev && (dev == &penv->pdev->dev) && pm_ops) {
if (pm_ops->suspend != penv->pm_ops->suspend ||
pm_ops->resume != penv->pm_ops->resume)
pr_err("PM APIs dont match with registered APIs\n");
penv->pm_ops = NULL;
}
}
EXPORT_SYMBOL(wcnss_wlan_unregister_pm_ops);
void wcnss_register_thermal_mitigation(struct device *dev,
void (*tm_notify)(struct device *, int))
{
if (penv && dev && tm_notify)
penv->tm_notify = tm_notify;
}
EXPORT_SYMBOL(wcnss_register_thermal_mitigation);
void wcnss_unregister_thermal_mitigation(
void (*tm_notify)(struct device *, int))
{
if (penv && tm_notify) {
if (tm_notify != penv->tm_notify)
pr_err("tm_notify doesn't match registered\n");
penv->tm_notify = NULL;
}
}
EXPORT_SYMBOL(wcnss_unregister_thermal_mitigation);
unsigned int wcnss_get_serial_number(void)
{
if (penv)
return penv->serial_number;
return 0;
}
EXPORT_SYMBOL(wcnss_get_serial_number);
static int enable_wcnss_suspend_notify;
static int enable_wcnss_suspend_notify_set(const char *val,
struct kernel_param *kp)
{
int ret;
ret = param_set_int(val, kp);
if (ret)
return ret;
if (enable_wcnss_suspend_notify)
pr_debug("Suspend notification activated for wcnss\n");
return 0;
}
module_param_call(enable_wcnss_suspend_notify, enable_wcnss_suspend_notify_set,
param_get_int, &enable_wcnss_suspend_notify, S_IRUGO | S_IWUSR);
int wcnss_xo_auto_detect_enabled(void)
{
return (has_autodetect_xo == 1 ? 1 : 0);
}
void wcnss_suspend_notify(void)
{
void __iomem *pmu_spare_reg;
u32 reg = 0;
unsigned long flags;
if (!enable_wcnss_suspend_notify)
return;
if (wcnss_hardware_type() == WCNSS_PRONTO_HW)
return;
/* For Riva */
pmu_spare_reg = penv->msm_wcnss_base + RIVA_SPARE_OFFSET;
spin_lock_irqsave(&reg_spinlock, flags);
reg = readl_relaxed(pmu_spare_reg);
reg |= RIVA_SUSPEND_BIT;
writel_relaxed(reg, pmu_spare_reg);
spin_unlock_irqrestore(&reg_spinlock, flags);
}
EXPORT_SYMBOL(wcnss_suspend_notify);
void wcnss_resume_notify(void)
{
void __iomem *pmu_spare_reg;
u32 reg = 0;
unsigned long flags;
if (!enable_wcnss_suspend_notify)
return;
if (wcnss_hardware_type() == WCNSS_PRONTO_HW)
return;
/* For Riva */
pmu_spare_reg = penv->msm_wcnss_base + RIVA_SPARE_OFFSET;
spin_lock_irqsave(&reg_spinlock, flags);
reg = readl_relaxed(pmu_spare_reg);
reg &= ~RIVA_SUSPEND_BIT;
writel_relaxed(reg, pmu_spare_reg);
spin_unlock_irqrestore(&reg_spinlock, flags);
}
EXPORT_SYMBOL(wcnss_resume_notify);
static int wcnss_wlan_suspend(struct device *dev)
{
if (penv && dev && (dev == &penv->pdev->dev) &&
penv->smd_channel_ready &&
penv->pm_ops && penv->pm_ops->suspend)
return penv->pm_ops->suspend(dev);
return 0;
}
static int wcnss_wlan_resume(struct device *dev)
{
if (penv && dev && (dev == &penv->pdev->dev) &&
penv->smd_channel_ready &&
penv->pm_ops && penv->pm_ops->resume)
return penv->pm_ops->resume(dev);
return 0;
}
void wcnss_prevent_suspend()
{
if (penv)
wake_lock(&penv->wcnss_wake_lock);
}
EXPORT_SYMBOL(wcnss_prevent_suspend);
void wcnss_allow_suspend()
{
if (penv)
wake_unlock(&penv->wcnss_wake_lock);
}
EXPORT_SYMBOL(wcnss_allow_suspend);
int wcnss_hardware_type(void)
{
if (penv)
return penv->wcnss_hw_type;
else
return -ENODEV;
}
EXPORT_SYMBOL(wcnss_hardware_type);
int fw_cal_data_available(void)
{
if (penv)
return penv->fw_cal_available;
else
return -ENODEV;
}
u32 wcnss_get_wlan_rx_buff_count(void)
{
if (penv)
return penv->wlan_rx_buff_count;
else
return WCNSS_DEF_WLAN_RX_BUFF_COUNT;
}
EXPORT_SYMBOL(wcnss_get_wlan_rx_buff_count);
static int wcnss_smd_tx(void *data, int len)
{
int ret = 0;
ret = smd_write_avail(penv->smd_ch);
if (ret < len) {
pr_err("wcnss: no space available for smd frame\n");
return -ENOSPC;
}
ret = smd_write(penv->smd_ch, data, len);
if (ret < len) {
pr_err("wcnss: failed to write Command %d", len);
ret = -ENODEV;
}
return ret;
}
static unsigned char wcnss_fw_status(void)
{
int len = 0;
int rc = 0;
unsigned char fw_status = 0xFF;
len = smd_read_avail(penv->smd_ch);
if (len < 1) {
pr_err("%s: invalid firmware status", __func__);
return fw_status;
}
rc = smd_read(penv->smd_ch, &fw_status, 1);
if (rc < 0) {
pr_err("%s: incomplete data read from smd\n", __func__);
return fw_status;
}
return fw_status;
}
static void wcnss_send_cal_rsp(unsigned char fw_status)
{
struct smd_msg_hdr *rsphdr;
unsigned char *msg = NULL;
int rc;
msg = kmalloc((sizeof(struct smd_msg_hdr) + 1), GFP_KERNEL);
if (NULL == msg) {
pr_err("wcnss: %s: failed to get memory\n", __func__);
return;
}
rsphdr = (struct smd_msg_hdr *)msg;
rsphdr->msg_type = WCNSS_CALDATA_UPLD_RSP;
rsphdr->msg_len = sizeof(struct smd_msg_hdr) + 1;
memcpy(msg+sizeof(struct smd_msg_hdr), &fw_status, 1);
rc = wcnss_smd_tx(msg, rsphdr->msg_len);
if (rc < 0)
pr_err("wcnss: smd tx failed\n");
kfree(msg);
}
/* Collect calibrated data from WCNSS */
void extract_cal_data(int len)
{
int rc;
struct cal_data_params calhdr;
unsigned char fw_status = WCNSS_RESP_FAIL;
if (len < sizeof(struct cal_data_params)) {
pr_err("wcnss: incomplete cal header length\n");
return;
}
rc = smd_read(penv->smd_ch, (unsigned char *)&calhdr,
sizeof(struct cal_data_params));
if (rc < sizeof(struct cal_data_params)) {
pr_err("wcnss: incomplete cal header read from smd\n");
return;
}
if (penv->fw_cal_exp_frag != calhdr.frag_number) {
pr_err("wcnss: Invalid frgament");
goto exit;
}
if (calhdr.frag_size > WCNSS_MAX_FRAME_SIZE) {
pr_err("wcnss: Invalid fragment size");
goto exit;
}
if (0 == calhdr.frag_number) {
if (calhdr.total_size > MAX_CALIBRATED_DATA_SIZE) {
pr_err("wcnss: Invalid cal data size %d",
calhdr.total_size);
goto exit;
}
kfree(penv->fw_cal_data);
penv->fw_cal_rcvd = 0;
penv->fw_cal_data = kmalloc(calhdr.total_size,
GFP_KERNEL);
if (penv->fw_cal_data == NULL) {
smd_read(penv->smd_ch, NULL, calhdr.frag_size);
goto exit;
}
}
mutex_lock(&penv->dev_lock);
if (penv->fw_cal_rcvd + calhdr.frag_size >
MAX_CALIBRATED_DATA_SIZE) {
pr_err("calibrated data size is more than expected %d",
penv->fw_cal_rcvd + calhdr.frag_size);
penv->fw_cal_exp_frag = 0;
penv->fw_cal_rcvd = 0;
smd_read(penv->smd_ch, NULL, calhdr.frag_size);
goto unlock_exit;
}
rc = smd_read(penv->smd_ch, penv->fw_cal_data + penv->fw_cal_rcvd,
calhdr.frag_size);
if (rc < calhdr.frag_size)
goto unlock_exit;
penv->fw_cal_exp_frag++;
penv->fw_cal_rcvd += calhdr.frag_size;
if (calhdr.msg_flags & LAST_FRAGMENT) {
penv->fw_cal_exp_frag = 0;
penv->fw_cal_available = true;
pr_info("wcnss: cal data collection completed\n");
}
mutex_unlock(&penv->dev_lock);
wake_up(&penv->read_wait);
if (penv->fw_cal_available) {
fw_status = WCNSS_RESP_SUCCESS;
wcnss_send_cal_rsp(fw_status);
}
return;
unlock_exit:
mutex_unlock(&penv->dev_lock);
exit:
wcnss_send_cal_rsp(fw_status);
return;
}
static void wcnssctrl_rx_handler(struct work_struct *worker)
{
int len = 0;
int rc = 0;
unsigned char buf[sizeof(struct wcnss_version)];
struct smd_msg_hdr *phdr;
struct wcnss_version *pversion;
int hw_type;
unsigned char fw_status = 0;
len = smd_read_avail(penv->smd_ch);
if (len > WCNSS_MAX_FRAME_SIZE) {
pr_err("wcnss: frame larger than the allowed size\n");
smd_read(penv->smd_ch, NULL, len);
return;
}
if (len <= 0)
return;
rc = smd_read(penv->smd_ch, buf, sizeof(struct smd_msg_hdr));
if (rc < sizeof(struct smd_msg_hdr)) {
pr_err("wcnss: incomplete header read from smd\n");
return;
}
len -= sizeof(struct smd_msg_hdr);
phdr = (struct smd_msg_hdr *)buf;
switch (phdr->msg_type) {
case WCNSS_VERSION_RSP:
if (len != sizeof(struct wcnss_version)
- sizeof(struct smd_msg_hdr)) {
pr_err("wcnss: invalid version data from wcnss %d\n",
len);
return;
}
rc = smd_read(penv->smd_ch, buf+sizeof(struct smd_msg_hdr),
len);
if (rc < len) {
pr_err("wcnss: incomplete data read from smd\n");
return;
}
pversion = (struct wcnss_version *)buf;
penv->fw_major = pversion->major;
penv->fw_minor = pversion->minor;
snprintf(penv->wcnss_version, WCNSS_VERSION_LEN,
"%02x%02x%02x%02x", pversion->major, pversion->minor,
pversion->version, pversion->revision);
pr_info("wcnss: version %s\n", penv->wcnss_version);
/* schedule work to download nvbin to ccpu */
hw_type = wcnss_hardware_type();
switch (hw_type) {
case WCNSS_RIVA_HW:
/* supported only if riva major >= 1 and minor >= 4 */
if ((pversion->major >= 1) && (pversion->minor >= 4)) {
pr_info("wcnss: schedule dnld work for riva\n");
schedule_work(&penv->wcnssctrl_nvbin_dnld_work);
}
break;
case WCNSS_PRONTO_HW:
/* supported only if pronto major >= 1 and minor >= 4 */
if ((pversion->major >= 1) && (pversion->minor >= 4)) {
pr_info("wcnss: schedule dnld work for pronto\n");
schedule_work(&penv->wcnssctrl_nvbin_dnld_work);
}
break;
default:
pr_info("wcnss: unknown hw type (%d), will not schedule dnld work\n",
hw_type);
break;
}
break;
case WCNSS_NVBIN_DNLD_RSP:
penv->nv_downloaded = true;
fw_status = wcnss_fw_status();
pr_debug("wcnss: received WCNSS_NVBIN_DNLD_RSP from ccpu %u\n",
fw_status);
break;
case WCNSS_CALDATA_DNLD_RSP:
penv->nv_downloaded = true;
fw_status = wcnss_fw_status();
pr_debug("wcnss: received WCNSS_CALDATA_DNLD_RSP from ccpu %u\n",
fw_status);
break;
case WCNSS_CALDATA_UPLD_REQ:
penv->fw_cal_available = 0;
extract_cal_data(len);
break;
default:
pr_err("wcnss: invalid message type %d\n", phdr->msg_type);
}
return;
}
static void wcnss_send_version_req(struct work_struct *worker)
{
struct smd_msg_hdr smd_msg;
int ret = 0;
smd_msg.msg_type = WCNSS_VERSION_REQ;
smd_msg.msg_len = sizeof(smd_msg);
ret = wcnss_smd_tx(&smd_msg, smd_msg.msg_len);
if (ret < 0)
pr_err("wcnss: smd tx failed\n");
return;
}
static void wcnss_nvbin_dnld(void)
{
int ret = 0;
struct nvbin_dnld_req_msg *dnld_req_msg;
unsigned short total_fragments = 0;
unsigned short count = 0;
unsigned short retry_count = 0;
unsigned short cur_frag_size = 0;
unsigned char *outbuffer = NULL;
const void *nv_blob_addr = NULL;
unsigned int nv_blob_size = 0;
const struct firmware *nv = NULL;
struct device *dev = &penv->pdev->dev;
ret = request_firmware(&nv, NVBIN_FILE, dev);
if (ret || !nv || !nv->data || !nv->size) {
pr_err("wcnss: %s: request_firmware failed for %s\n",
__func__, NVBIN_FILE);
return;
}
/*
* First 4 bytes in nv blob is validity bitmap.
* We cannot validate nv, so skip those 4 bytes.
*/
nv_blob_addr = nv->data + 4;
nv_blob_size = nv->size - 4;
total_fragments = TOTALFRAGMENTS(nv_blob_size);
pr_info("wcnss: NV bin size: %d, total_fragments: %d\n",
nv_blob_size, total_fragments);
/* get buffer for nv bin dnld req message */
outbuffer = kmalloc((sizeof(struct nvbin_dnld_req_msg) +
NV_FRAGMENT_SIZE), GFP_KERNEL);
if (NULL == outbuffer) {
pr_err("wcnss: %s: failed to get buffer\n", __func__);
goto err_free_nv;
}
dnld_req_msg = (struct nvbin_dnld_req_msg *)outbuffer;
dnld_req_msg->hdr.msg_type = WCNSS_NVBIN_DNLD_REQ;
dnld_req_msg->dnld_req_params.msg_flags = 0;
for (count = 0; count < total_fragments; count++) {
dnld_req_msg->dnld_req_params.frag_number = count;
if (count == (total_fragments - 1)) {
/* last fragment, take care of boundry condition */
cur_frag_size = nv_blob_size % NV_FRAGMENT_SIZE;
if (!cur_frag_size)
cur_frag_size = NV_FRAGMENT_SIZE;
dnld_req_msg->dnld_req_params.msg_flags |=
LAST_FRAGMENT;
dnld_req_msg->dnld_req_params.msg_flags |=
CAN_RECEIVE_CALDATA;
} else {
cur_frag_size = NV_FRAGMENT_SIZE;
dnld_req_msg->dnld_req_params.msg_flags &=
~LAST_FRAGMENT;
}
dnld_req_msg->dnld_req_params.nvbin_buffer_size =
cur_frag_size;
dnld_req_msg->hdr.msg_len =
sizeof(struct nvbin_dnld_req_msg) + cur_frag_size;
/* copy NV fragment */
memcpy((outbuffer + sizeof(struct nvbin_dnld_req_msg)),
(nv_blob_addr + count * NV_FRAGMENT_SIZE),
cur_frag_size);
ret = wcnss_smd_tx(outbuffer, dnld_req_msg->hdr.msg_len);
retry_count = 0;
while ((ret == -ENOSPC) && (retry_count <= 3)) {
pr_debug("wcnss: %s: smd tx failed, ENOSPC\n",
__func__);
pr_debug("fragment: %d, len: %d, TotFragments: %d, retry_count: %d\n",
count, dnld_req_msg->hdr.msg_len,
total_fragments, retry_count);
/* wait and try again */
msleep(20);
retry_count++;
ret = wcnss_smd_tx(outbuffer,
dnld_req_msg->hdr.msg_len);
}
if (ret < 0) {
pr_err("wcnss: %s: smd tx failed\n", __func__);
pr_err("fragment %d, len: %d, TotFragments: %d, retry_count: %d\n",
count, dnld_req_msg->hdr.msg_len,
total_fragments, retry_count);
goto err_dnld;
}
}
err_dnld:
/* free buffer */
kfree(outbuffer);
err_free_nv:
/* release firmware */
release_firmware(nv);
return;
}
static void wcnss_caldata_dnld(const void *cal_data,
unsigned int cal_data_size, bool msg_to_follow)
{
int ret = 0;
struct cal_data_msg *cal_msg;
unsigned short total_fragments = 0;
unsigned short count = 0;
unsigned short retry_count = 0;
unsigned short cur_frag_size = 0;
unsigned char *outbuffer = NULL;
total_fragments = TOTALFRAGMENTS(cal_data_size);
outbuffer = kmalloc((sizeof(struct cal_data_msg) +
NV_FRAGMENT_SIZE), GFP_KERNEL);
if (NULL == outbuffer) {
pr_err("wcnss: %s: failed to get buffer\n", __func__);
return;
}
cal_msg = (struct cal_data_msg *)outbuffer;
cal_msg->hdr.msg_type = WCNSS_CALDATA_DNLD_REQ;
cal_msg->cal_params.msg_flags = 0;
for (count = 0; count < total_fragments; count++) {
cal_msg->cal_params.frag_number = count;
if (count == (total_fragments - 1)) {
cur_frag_size = cal_data_size % NV_FRAGMENT_SIZE;
if (!cur_frag_size)
cur_frag_size = NV_FRAGMENT_SIZE;
cal_msg->cal_params.msg_flags
|= LAST_FRAGMENT;
if (msg_to_follow)
cal_msg->cal_params.msg_flags |=
MESSAGE_TO_FOLLOW;
} else {
cur_frag_size = NV_FRAGMENT_SIZE;
cal_msg->cal_params.msg_flags &=
~LAST_FRAGMENT;
}
cal_msg->cal_params.total_size = cal_data_size;
cal_msg->cal_params.frag_size =
cur_frag_size;
cal_msg->hdr.msg_len =
sizeof(struct cal_data_msg) + cur_frag_size;
memcpy((outbuffer + sizeof(struct cal_data_msg)),
(cal_data + count * NV_FRAGMENT_SIZE),
cur_frag_size);
ret = wcnss_smd_tx(outbuffer, cal_msg->hdr.msg_len);
retry_count = 0;
while ((ret == -ENOSPC) && (retry_count <= 3)) {
pr_debug("wcnss: %s: smd tx failed, ENOSPC\n",
__func__);
pr_debug("fragment: %d, len: %d, TotFragments: %d, retry_count: %d\n",
count, cal_msg->hdr.msg_len,
total_fragments, retry_count);
/* wait and try again */
msleep(20);
retry_count++;
ret = wcnss_smd_tx(outbuffer,
cal_msg->hdr.msg_len);
}
if (ret < 0) {
pr_err("wcnss: %s: smd tx failed\n", __func__);
pr_err("fragment %d, len: %d, TotFragments: %d, retry_count: %d\n",
count, cal_msg->hdr.msg_len,
total_fragments, retry_count);
goto err_dnld;
}
}
err_dnld:
/* free buffer */
kfree(outbuffer);
return;
}
static void wcnss_nvbin_dnld_main(struct work_struct *worker)
{
int retry = 0;
if (!FW_CALDATA_CAPABLE())
goto nv_download;
if (!penv->fw_cal_available && WCNSS_CONFIG_UNSPECIFIED
!= has_calibrated_data && !penv->user_cal_available) {
while (!penv->user_cal_available && retry++ < 5)
msleep(500);
}
/* only cal data is sent during ssr (if available) */
if (penv->fw_cal_available && penv->ssr_boot) {
pr_info_ratelimited("wcnss: cal download during SSR, using fw cal");
wcnss_caldata_dnld(penv->fw_cal_data, penv->fw_cal_rcvd, false);
return;
} else if (penv->user_cal_available && penv->ssr_boot) {
pr_info_ratelimited("wcnss: cal download during SSR, using user cal");
wcnss_caldata_dnld(penv->user_cal_data,
penv->user_cal_rcvd, false);
return;
} else if (penv->user_cal_available) {
pr_info_ratelimited("wcnss: cal download during cold boot, using user cal");
wcnss_caldata_dnld(penv->user_cal_data,
penv->user_cal_rcvd, true);
}
nv_download:
pr_info_ratelimited("wcnss: NV download");
wcnss_nvbin_dnld();
return;
}
static int
wcnss_trigger_config(struct platform_device *pdev)
{
int ret;
struct qcom_wcnss_opts *pdata;
unsigned long wcnss_phys_addr;
int size = 0;
struct resource *res;
int has_pronto_hw = of_property_read_bool(pdev->dev.of_node,
"qcom,has-pronto-hw");
if (of_property_read_u32(pdev->dev.of_node,
"qcom,wlan-rx-buff-count", &penv->wlan_rx_buff_count)) {
penv->wlan_rx_buff_count = WCNSS_DEF_WLAN_RX_BUFF_COUNT;
}
/* make sure we are only triggered once */
if (penv->triggered)
return 0;
penv->triggered = 1;
/* initialize the WCNSS device configuration */
pdata = pdev->dev.platform_data;
if (WCNSS_CONFIG_UNSPECIFIED == has_48mhz_xo) {
if (has_pronto_hw) {
has_48mhz_xo = of_property_read_bool(pdev->dev.of_node,
"qcom,has-48mhz-xo");
} else {
has_48mhz_xo = pdata->has_48mhz_xo;
}
}
penv->wcnss_hw_type = (has_pronto_hw) ? WCNSS_PRONTO_HW : WCNSS_RIVA_HW;
penv->wlan_config.use_48mhz_xo = has_48mhz_xo;
if (WCNSS_CONFIG_UNSPECIFIED == has_autodetect_xo && has_pronto_hw) {
has_autodetect_xo = of_property_read_bool(pdev->dev.of_node,
"qcom,has-autodetect-xo");
}
penv->thermal_mitigation = 0;
strlcpy(penv->wcnss_version, "INVALID", WCNSS_VERSION_LEN);
/* Configure 5 wire GPIOs */
if (!has_pronto_hw) {
penv->gpios_5wire = platform_get_resource_byname(pdev,
IORESOURCE_IO, "wcnss_gpios_5wire");
/* allocate 5-wire GPIO resources */
if (!penv->gpios_5wire) {
dev_err(&pdev->dev, "insufficient IO resources\n");
ret = -ENOENT;
goto fail_gpio_res;
}
ret = wcnss_gpios_config(penv->gpios_5wire, true);
} else
ret = wcnss_pronto_gpios_config(&pdev->dev, true);
if (ret) {
dev_err(&pdev->dev, "WCNSS gpios config failed.\n");
goto fail_gpio_res;
}
/* power up the WCNSS */
ret = wcnss_wlan_power(&pdev->dev, &penv->wlan_config,
WCNSS_WLAN_SWITCH_ON);
if (ret) {
dev_err(&pdev->dev, "WCNSS Power-up failed.\n");
goto fail_power;
}
/* trigger initialization of the WCNSS */
penv->pil = subsystem_get(WCNSS_PIL_DEVICE);
if (IS_ERR(penv->pil)) {
dev_err(&pdev->dev, "Peripheral Loader failed on WCNSS.\n");
ret = PTR_ERR(penv->pil);
penv->pil = NULL;
goto fail_pil;
}
/* allocate resources */
penv->mmio_res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
"wcnss_mmio");
penv->tx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ,
"wcnss_wlantx_irq");
penv->rx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ,
"wcnss_wlanrx_irq");
if (!(penv->mmio_res && penv->tx_irq_res && penv->rx_irq_res)) {
dev_err(&pdev->dev, "insufficient resources\n");
ret = -ENOENT;
goto fail_res;
}
INIT_WORK(&penv->wcnssctrl_rx_work, wcnssctrl_rx_handler);
INIT_WORK(&penv->wcnssctrl_version_work, wcnss_send_version_req);
INIT_WORK(&penv->wcnssctrl_nvbin_dnld_work, wcnss_nvbin_dnld_main);
wake_lock_init(&penv->wcnss_wake_lock, WAKE_LOCK_SUSPEND, "wcnss");
if (wcnss_hardware_type() == WCNSS_PRONTO_HW) {
size = 0x3000;
wcnss_phys_addr = MSM_PRONTO_PHYS;
} else {
wcnss_phys_addr = MSM_RIVA_PHYS;
size = SZ_256;
}
penv->msm_wcnss_base = ioremap(wcnss_phys_addr, size);
if (!penv->msm_wcnss_base) {
ret = -ENOMEM;
pr_err("%s: ioremap wcnss physical failed\n", __func__);
goto fail_wake;
}
if (wcnss_hardware_type() == WCNSS_RIVA_HW) {
penv->riva_ccu_base = ioremap(MSM_RIVA_CCU_BASE, SZ_512);
if (!penv->riva_ccu_base) {
ret = -ENOMEM;
pr_err("%s: ioremap wcnss physical failed\n", __func__);
goto fail_ioremap;
}
} else {
penv->pronto_a2xb_base = ioremap(MSM_PRONTO_A2XB_BASE, SZ_512);
if (!penv->pronto_a2xb_base) {
ret = -ENOMEM;
pr_err("%s: ioremap wcnss physical failed\n", __func__);
goto fail_ioremap;
}
penv->pronto_ccpu_base = ioremap(MSM_PRONTO_CCPU_BASE, SZ_512);
if (!penv->pronto_ccpu_base) {
ret = -ENOMEM;
pr_err("%s: ioremap wcnss physical failed\n", __func__);
goto fail_ioremap2;
}
/* for reset FIQ */
res = platform_get_resource_byname(penv->pdev,
IORESOURCE_MEM, "wcnss_fiq");
if (!res) {
dev_err(&pdev->dev, "insufficient irq mem resources\n");
ret = -ENOENT;
goto fail_ioremap3;
}
penv->fiq_reg = ioremap_nocache(res->start, resource_size(res));
if (!penv->fiq_reg) {
pr_err("wcnss: %s: ioremap_nocache() failed fiq_reg addr:%pr\n",
__func__, &res->start);
ret = -ENOMEM;
goto fail_ioremap3;
}
}
return 0;
fail_ioremap3:
iounmap(penv->pronto_ccpu_base);
fail_ioremap2:
iounmap(penv->pronto_a2xb_base);
fail_ioremap:
iounmap(penv->msm_wcnss_base);
fail_wake:
wake_lock_destroy(&penv->wcnss_wake_lock);
fail_res:
if (penv->pil)
subsystem_put(penv->pil);
fail_pil:
wcnss_wlan_power(&pdev->dev, &penv->wlan_config,
WCNSS_WLAN_SWITCH_OFF);
fail_power:
if (has_pronto_hw)
wcnss_pronto_gpios_config(&pdev->dev, false);
else
wcnss_gpios_config(penv->gpios_5wire, false);
fail_gpio_res:
penv = NULL;
return ret;
}
static int wcnss_node_open(struct inode *inode, struct file *file)
{
struct platform_device *pdev;
if (!penv)
return -EFAULT;
/* first open is only to trigger WCNSS platform driver */
if (!penv->triggered) {
pr_info(DEVICE " triggered by userspace\n");
pdev = penv->pdev;
return wcnss_trigger_config(pdev);
} else if (penv->device_opened) {
pr_info(DEVICE " already opened\n");
return -EBUSY;
}
mutex_lock(&penv->dev_lock);
penv->user_cal_rcvd = 0;
penv->user_cal_read = 0;
penv->user_cal_available = false;
penv->user_cal_data = NULL;
penv->device_opened = 1;
mutex_unlock(&penv->dev_lock);
return 0;
}
static ssize_t wcnss_wlan_read(struct file *fp, char __user
*buffer, size_t count, loff_t *position)
{
int rc = 0;
if (!penv || !penv->device_opened)
return -EFAULT;
rc = wait_event_interruptible(penv->read_wait, penv->fw_cal_rcvd
> penv->user_cal_read || penv->fw_cal_available);
if (rc < 0)
return rc;
mutex_lock(&penv->dev_lock);
if (penv->fw_cal_available && penv->fw_cal_rcvd
== penv->user_cal_read) {
rc = 0;
goto exit;
}
if (count > penv->fw_cal_rcvd - penv->user_cal_read)
count = penv->fw_cal_rcvd - penv->user_cal_read;
rc = copy_to_user(buffer, penv->fw_cal_data +
penv->user_cal_read, count);
if (rc == 0) {
penv->user_cal_read += count;
rc = count;
}
exit:
mutex_unlock(&penv->dev_lock);
return rc;
}
/* first (valid) write to this device should be 4 bytes cal file size */
static ssize_t wcnss_wlan_write(struct file *fp, const char __user
*user_buffer, size_t count, loff_t *position)
{
int rc = 0;
size_t size = 0;
if (!penv || !penv->device_opened || penv->user_cal_available)
return -EFAULT;
if (penv->user_cal_rcvd == 0 && count >= 4
&& !penv->user_cal_data) {
rc = copy_from_user((void *)&size, user_buffer, 4);
if (!size || size > MAX_CALIBRATED_DATA_SIZE) {
pr_err(DEVICE " invalid size to write %d\n", size);
return -EFAULT;
}
rc += count;
count -= 4;
penv->user_cal_exp_size = size;
penv->user_cal_data = kmalloc(size, GFP_KERNEL);
if (penv->user_cal_data == NULL) {
pr_err(DEVICE " no memory to write\n");
return -ENOMEM;
}
if (0 == count)
goto exit;
} else if (penv->user_cal_rcvd == 0 && count < 4)
return -EFAULT;
if ((UINT32_MAX - count < penv->user_cal_rcvd) ||
MAX_CALIBRATED_DATA_SIZE < count + penv->user_cal_rcvd) {
pr_err(DEVICE " invalid size to write %d\n", count +
penv->user_cal_rcvd);
rc = -ENOMEM;
goto exit;
}
rc = copy_from_user((void *)penv->user_cal_data +
penv->user_cal_rcvd, user_buffer, count);
if (0 == rc) {
penv->user_cal_rcvd += count;
rc += count;
}
if (penv->user_cal_rcvd == penv->user_cal_exp_size) {
penv->user_cal_available = true;
pr_info_ratelimited("wcnss: user cal written");
}
exit:
return rc;
}
static const struct file_operations wcnss_node_fops = {
.owner = THIS_MODULE,
.open = wcnss_node_open,
.read = wcnss_wlan_read,
.write = wcnss_wlan_write,
};
static struct miscdevice wcnss_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = DEVICE,
.fops = &wcnss_node_fops,
};
static int __devinit
wcnss_wlan_probe(struct platform_device *pdev)
{
int ret = 0;
/* verify we haven't been called more than once */
if (penv) {
dev_err(&pdev->dev, "cannot handle multiple devices.\n");
return -ENODEV;
}
/* create an environment to track the device */
penv = devm_kzalloc(&pdev->dev, sizeof(*penv), GFP_KERNEL);
if (!penv) {
dev_err(&pdev->dev, "cannot allocate device memory.\n");
return -ENOMEM;
}
penv->pdev = pdev;
/* register sysfs entries */
ret = wcnss_create_sysfs(&pdev->dev);
if (ret) {
penv = NULL;
return -ENOENT;
}
mutex_init(&penv->dev_lock);
init_waitqueue_head(&penv->read_wait);
/* Since we were built into the kernel we'll be called as part
* of kernel initialization. We don't know if userspace
* applications are available to service PIL at this time
* (they probably are not), so we simply create a device node
* here. When userspace is available it should touch the
* device so that we know that WCNSS configuration can take
* place
*/
pr_info(DEVICE " probed in built-in mode\n");
return misc_register(&wcnss_misc);
}
static int __devexit
wcnss_wlan_remove(struct platform_device *pdev)
{
wcnss_remove_sysfs(&pdev->dev);
penv = NULL;
return 0;
}
static const struct dev_pm_ops wcnss_wlan_pm_ops = {
.suspend = wcnss_wlan_suspend,
.resume = wcnss_wlan_resume,
};
#ifdef CONFIG_WCNSS_CORE_PRONTO
static struct of_device_id msm_wcnss_pronto_match[] = {
{.compatible = "qcom,wcnss_wlan"},
{}
};
#endif
static struct platform_driver wcnss_wlan_driver = {
.driver = {
.name = DEVICE,
.owner = THIS_MODULE,
.pm = &wcnss_wlan_pm_ops,
#ifdef CONFIG_WCNSS_CORE_PRONTO
.of_match_table = msm_wcnss_pronto_match,
#endif
},
.probe = wcnss_wlan_probe,
.remove = __devexit_p(wcnss_wlan_remove),
};
static int __init wcnss_wlan_init(void)
{
int ret = 0;
platform_driver_register(&wcnss_wlan_driver);
platform_driver_register(&wcnss_wlan_ctrl_driver);
platform_driver_register(&wcnss_ctrl_driver);
#ifdef CONFIG_WCNSS_MEM_PRE_ALLOC
ret = wcnss_prealloc_init();
if (ret < 0)
pr_err("wcnss: pre-allocation failed\n");
#endif
return ret;
}
static void __exit wcnss_wlan_exit(void)
{
if (penv) {
if (penv->pil)
subsystem_put(penv->pil);
penv = NULL;
}
platform_driver_unregister(&wcnss_ctrl_driver);
platform_driver_unregister(&wcnss_wlan_ctrl_driver);
platform_driver_unregister(&wcnss_wlan_driver);
#ifdef CONFIG_WCNSS_MEM_PRE_ALLOC
wcnss_prealloc_deinit();
#endif
}
module_init(wcnss_wlan_init);
module_exit(wcnss_wlan_exit);
MODULE_LICENSE("GPL v2");
MODULE_VERSION(VERSION);
MODULE_DESCRIPTION(DEVICE "Driver");
Reference in New Issue View Git Blame Copy Permalink