/*
|
* Copyright (c) 2015 South Silicon Valley Microelectronics Inc.
|
* Copyright (c) 2015 iComm Corporation
|
*
|
* This program is free software: you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation, either version 3 of the License, or
|
* (at your option) any later version.
|
* 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.
|
* You should have received a copy of the GNU General Public License
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
|
#include <linux/irq.h>
|
#include <linux/version.h>
|
#include <linux/module.h>
|
#include <linux/vmalloc.h>
|
#include <linux/gpio.h>
|
#include <linux/mmc/host.h>
|
#include <linux/delay.h>
|
#include <linux/regulator/consumer.h>
|
#include <linux/semaphore.h>
|
#include <linux/platform_device.h>
|
#ifdef CONFIG_HAS_WAKELOCK
|
#include <linux/wakelock.h>
|
#endif
|
#include <asm/io.h>
|
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 0))
|
#include <linux/printk.h>
|
#include <linux/err.h>
|
#else
|
#include <config/printk.h>
|
#endif
|
#if LINUX_VERSION_CODE > KERNEL_VERSION(3,2,0)
|
#include <linux/wlan_plat.h>
|
#else
|
struct wifi_platform_data {
|
int (*set_power)(int val);
|
int (*set_reset)(int val);
|
int (*set_carddetect)(int val);
|
void *(*mem_prealloc)(int section, unsigned long size);
|
int (*get_mac_addr)(unsigned char *buf);
|
void *(*get_country_code)(char *ccode);
|
};
|
#endif
|
extern int rockchip_wifi_power(int on);
|
extern int rockchip_wifi_set_carddetect(int val);
|
extern int ssv6xxx_get_dev_status(void);
|
static struct wifi_platform_data *wifi_control_data = NULL;
|
#define GPIO_REG_WRITEL(val,reg) do{__raw_writel(val, CTL_PIN_BASE + (reg));}while(0)
|
unsigned int oob_irq = 0;
|
static int g_wifidev_registered = 0;
|
static struct semaphore wifi_control_sem;
|
extern int rockchip_wifi_get_oob_irq(void);
|
extern int ssvdevice_init(void);
|
extern void ssvdevice_exit(void);
|
#ifdef CONFIG_SSV_SUPPORT_AES_ASM
|
extern int aes_init(void);
|
extern void aes_fini(void);
|
extern int sha1_mod_init(void);
|
extern void sha1_mod_fini(void);
|
#endif
|
#ifdef CONFIG_HAS_WAKELOCK
|
struct wake_lock icomm_wake_lock;
|
#endif
|
static int icomm_wifi_power(int on)
|
{
|
printk("%s: %d\n", __func__, on);
|
rockchip_wifi_power(on);
|
return 0;
|
}
|
int icomm_wifi_set_carddetect(int val)
|
{
|
rockchip_wifi_set_carddetect(val);
|
return 0;
|
}
|
static struct wifi_platform_data icomm_wifi_control = {
|
.set_power = icomm_wifi_power,
|
.set_carddetect = icomm_wifi_set_carddetect,
|
};
|
void icomm_wifi_device_release(struct device *dev)
|
{
|
printk("%s\n", __func__);
|
}
|
static struct platform_device icomm_wifi_device = {
|
.name = "icomm_wlan",
|
.id = 1,
|
.dev = {
|
.platform_data = &icomm_wifi_control,
|
.release = icomm_wifi_device_release,
|
},
|
};
|
int wifi_set_power(int on, unsigned long msec)
|
{
|
if (wifi_control_data && wifi_control_data->set_power) {
|
wifi_control_data->set_power(on);
|
}
|
if (msec)
|
msleep(msec);
|
return 0;
|
}
|
static int wifi_set_carddetect(int on)
|
{
|
if (wifi_control_data && wifi_control_data->set_carddetect) {
|
wifi_control_data->set_carddetect(on);
|
}
|
return 0;
|
}
|
static irqreturn_t wifi_wakeup_irq_handler(int irq, void *dev)
|
{
|
printk("%s\n", __func__);
|
wake_lock_timeout(&icomm_wake_lock, HZ);
|
return IRQ_HANDLED;
|
}
|
void setup_wifi_wakeup_BB(void)
|
{
|
int err;
|
oob_irq = rockchip_wifi_get_oob_irq();
|
if (oob_irq <= 0) {
|
printk("%s: oob_irq NULL\n", __func__);
|
return;
|
}
|
err = request_threaded_irq(oob_irq,
|
wifi_wakeup_irq_handler,
|
NULL,
|
IRQF_TRIGGER_FALLING,
|
"wlan_wakeup_irq",
|
NULL);
|
printk("%s: set oob_irq:%d %s\n", __func__, oob_irq, (err < 0) ? "NG": "OK");
|
}
|
void free_wifi_wakeup_BB(void)
|
{
|
if (oob_irq > 0) {
|
free_irq(oob_irq, NULL);
|
oob_irq = 0;
|
}
|
}
|
static int wifi_probe(struct platform_device *pdev)
|
{
|
struct wifi_platform_data *wifi_ctrl =
|
(struct wifi_platform_data *)(pdev->dev.platform_data);
|
printk("%s\n", __func__);
|
wifi_control_data = wifi_ctrl;
|
wifi_set_power(0, 50);
|
wifi_set_power(1, 50);
|
wifi_set_carddetect(1);
|
msleep(120);
|
up(&wifi_control_sem);
|
return 0;
|
}
|
static int wifi_remove(struct platform_device *pdev)
|
{
|
struct wifi_platform_data *wifi_ctrl =
|
(struct wifi_platform_data *)(pdev->dev.platform_data);
|
printk("%s\n", __func__);
|
wifi_control_data = wifi_ctrl;
|
wifi_set_carddetect(0);
|
msleep(120);
|
wifi_set_power(0, 50);
|
#ifdef CONFIG_HAS_WAKELOCK
|
wake_lock_destroy(&icomm_wake_lock);
|
#endif
|
return 0;
|
}
|
#ifdef CONFIG_PM
|
static int wifi_suspend(struct platform_device *pdev, pm_message_t state)
|
{
|
printk("%s\n", __func__);
|
return 0;
|
}
|
static int wifi_resume(struct platform_device *pdev)
|
{
|
printk("%s\n", __func__);
|
#if 0
|
if (wifi_control_data && wifi_control_data->set_carddetect) {
|
wifi_control_data->set_carddetect(0);
|
}
|
msleep(50);
|
if (wifi_control_data && wifi_control_data->set_carddetect) {
|
wifi_control_data->set_carddetect(1);
|
}
|
#endif
|
return 0;
|
}
|
#endif
|
static struct platform_driver wifi_driver = {
|
.probe = wifi_probe,
|
.remove = wifi_remove,
|
#ifdef CONFIG_PM
|
.suspend = wifi_suspend,
|
.resume = wifi_resume,
|
#endif
|
.driver = {
|
.name = "icomm_wlan",
|
}
|
};
|
int initWlan(void)
|
{
|
int ret=0;
|
#ifdef CONFIG_HAS_WAKELOCK
|
wake_lock_init(&icomm_wake_lock, WAKE_LOCK_SUSPEND, "ssv6051");
|
wake_lock(&icomm_wake_lock);
|
#endif
|
sema_init(&wifi_control_sem, 0);
|
platform_device_register(&icomm_wifi_device);
|
platform_driver_register(&wifi_driver);
|
g_wifidev_registered = 1;
|
if (down_timeout(&wifi_control_sem, msecs_to_jiffies(1000)) != 0) {
|
ret = -EINVAL;
|
printk(KERN_ALERT "%s: platform_driver_register timeout\n", __FUNCTION__);
|
}
|
ret = ssvdevice_init();
|
#ifdef CONFIG_HAS_WAKELOCK
|
wake_unlock(&icomm_wake_lock);
|
#endif
|
return ret;
|
}
|
void exitWlan(void)
|
{
|
if (g_wifidev_registered)
|
{
|
ssvdevice_exit();
|
platform_driver_unregister(&wifi_driver);
|
platform_device_unregister(&icomm_wifi_device);
|
g_wifidev_registered = 0;
|
}
|
return;
|
}
|
static __init int generic_wifi_init_module(void)
|
{
|
int ret;
|
int time = 5;
|
printk("%s\n", __func__);
|
#ifdef CONFIG_SSV_SUPPORT_AES_ASM
|
sha1_mod_init();
|
aes_init();
|
#endif
|
ret = initWlan();
|
while(time-- > 0)
|
{
|
msleep(500);
|
if(ssv6xxx_get_dev_status() == 1)
|
break;
|
printk("%s : Retry to carddetect\n",__func__);
|
wifi_set_carddetect(0);
|
wifi_set_power(0, 50);
|
msleep(150);
|
wifi_set_power(1, 50);
|
wifi_set_carddetect(1);
|
}
|
return ret;
|
}
|
static __exit void generic_wifi_exit_module(void)
|
{
|
printk("%s\n", __func__);
|
#ifdef CONFIG_SSV_SUPPORT_AES_ASM
|
aes_fini();
|
sha1_mod_fini();
|
#endif
|
exitWlan();
|
}
|
EXPORT_SYMBOL(generic_wifi_init_module);
|
EXPORT_SYMBOL(generic_wifi_exit_module);
|
module_init(generic_wifi_init_module);
|
module_exit(generic_wifi_exit_module);
|
MODULE_LICENSE("Dual BSD/GPL");
|
