M7350/kernel/drivers/net/wireless/libra/libra_sdioif.c
2024-09-09 08:52:07 +00:00

554 lines
13 KiB
C

/* Copyright (c) 2009-2012, 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/libra_sdioif.h>
#include <linux/delay.h>
#include <linux/mmc/sdio.h>
#include <linux/mmc/mmc.h>
#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include <linux/module.h>
/* Libra SDIO function device */
static struct sdio_func *libra_sdio_func;
static struct mmc_host *libra_mmc_host;
static int libra_mmc_host_index;
/* SDIO Card ID / Device ID */
static unsigned short libra_sdio_card_id;
/* completion variables */
struct completion gCard_rem_event_var;
EXPORT_SYMBOL(gCard_rem_event_var);
struct completion gShutdown_event_var;
EXPORT_SYMBOL(gShutdown_event_var);
static suspend_handler_t *libra_suspend_hldr;
static resume_handler_t *libra_resume_hldr;
static notify_card_removal_t *libra_notify_card_removal_hdlr;
static shutdown_handler_t *libra_sdio_shutdown_hdlr;
int libra_enable_sdio_irq_in_chip(struct sdio_func *func, u8 enable)
{
unsigned char reg = 0;
int err = 0;
sdio_claim_host(func);
/* Read the value into reg */
libra_sdiocmd52(func, SDIO_CCCR_IENx, &reg, 0, &err);
if (err)
printk(KERN_ERR "%s: Could not read SDIO_CCCR_IENx register "
"err=%d\n", __func__, err);
if (libra_mmc_host) {
if (enable) {
reg |= 1 << func->num;
reg |= 1;
} else {
reg &= ~(1 << func->num);
}
libra_sdiocmd52(func, SDIO_CCCR_IENx, &reg, 1, &err);
if (err)
printk(KERN_ERR "%s: Could not enable/disable irq "
"err=%d\n", __func__, err);
}
sdio_release_host(func);
return err;
}
EXPORT_SYMBOL(libra_enable_sdio_irq_in_chip);
/**
* libra_sdio_configure() - Function to configure the SDIO device param
* @libra_sdio_rxhandler Rx handler
* @func_drv_fn Function driver function for special setup
* @funcdrv_timeout Function Enable timeout
* @blksize Block size
*
* Configure SDIO device, enable function and set block size
*/
int libra_sdio_configure(sdio_irq_handler_t libra_sdio_rxhandler,
void (*func_drv_fn)(int *status),
unsigned int funcdrv_timeout, unsigned int blksize)
{
int err_ret = 0;
struct sdio_func *func = libra_sdio_func;
if (libra_sdio_func == NULL) {
printk(KERN_ERR "%s: Error SDIO card not detected\n", __func__);
goto cfg_error;
}
sdio_claim_host(func);
/* Currently block sizes are set here. */
func->max_blksize = blksize;
if (sdio_set_block_size(func, blksize)) {
printk(KERN_ERR "%s: Unable to set the block size.\n",
__func__);
sdio_release_host(func);
goto cfg_error;
}
/* Function driver specific configuration. */
if (func_drv_fn) {
(*func_drv_fn)(&err_ret);
if (err_ret) {
printk(KERN_ERR "%s: function driver provided configure function error=%d\n",
__func__, err_ret);
sdio_release_host(func);
goto cfg_error;
}
}
/* We set this based on the function card. */
func->enable_timeout = funcdrv_timeout;
err_ret = sdio_enable_func(func);
if (err_ret != 0) {
printk(KERN_ERR "%s: Unable to enable function %d\n",
__func__, err_ret);
sdio_release_host(func);
goto cfg_error;
}
if (sdio_claim_irq(func, libra_sdio_rxhandler)) {
sdio_disable_func(func);
printk(KERN_ERR "%s: Unable to claim irq.\n", __func__);
sdio_release_host(func);
goto cfg_error;
}
libra_enable_sdio_irq_in_chip(func, 0);
sdio_release_host(func);
return 0;
cfg_error:
return -1;
}
EXPORT_SYMBOL(libra_sdio_configure);
int libra_sdio_configure_suspend_resume(
suspend_handler_t *libra_sdio_suspend_hdlr,
resume_handler_t *libra_sdio_resume_hdlr)
{
libra_suspend_hldr = libra_sdio_suspend_hdlr;
libra_resume_hldr = libra_sdio_resume_hdlr;
return 0;
}
EXPORT_SYMBOL(libra_sdio_configure_suspend_resume);
/*
* libra_sdio_deconfigure() - Function to reset the SDIO device param
*/
void libra_sdio_deconfigure(struct sdio_func *func)
{
if (NULL == libra_sdio_func)
return;
sdio_claim_host(func);
sdio_release_irq(func);
sdio_disable_func(func);
sdio_release_host(func);
}
EXPORT_SYMBOL(libra_sdio_deconfigure);
int libra_enable_sdio_irq(struct sdio_func *func, u8 enable)
{
if (libra_mmc_host && libra_mmc_host->ops &&
libra_mmc_host->ops->enable_sdio_irq) {
libra_mmc_host->ops->enable_sdio_irq(libra_mmc_host, enable);
return 0;
}
printk(KERN_ERR "%s: Could not enable disable irq\n", __func__);
return -EINVAL;
}
EXPORT_SYMBOL(libra_enable_sdio_irq);
int libra_disable_sdio_irq_capability(struct sdio_func *func, u8 disable)
{
if (libra_mmc_host) {
if (disable)
libra_mmc_host->caps &= ~MMC_CAP_SDIO_IRQ;
else
libra_mmc_host->caps |= MMC_CAP_SDIO_IRQ;
return 0;
}
printk(KERN_ERR "%s: Could not change sdio capabilities to polling\n",
__func__);
return -EINVAL;
}
EXPORT_SYMBOL(libra_disable_sdio_irq_capability);
/*
* libra_sdio_release_irq() - Function to release IRQ
*/
void libra_sdio_release_irq(struct sdio_func *func)
{
if (NULL == libra_sdio_func)
return;
sdio_release_irq(func);
}
EXPORT_SYMBOL(libra_sdio_release_irq);
/*
* libra_sdio_disable_func() - Function to disable sdio func
*/
void libra_sdio_disable_func(struct sdio_func *func)
{
if (NULL == libra_sdio_func)
return;
sdio_disable_func(func);
}
EXPORT_SYMBOL(libra_sdio_disable_func);
/*
* Return the SDIO Function device
*/
struct sdio_func *libra_getsdio_funcdev(void)
{
return libra_sdio_func;
}
EXPORT_SYMBOL(libra_getsdio_funcdev);
/*
* Set function driver as the private data for the function device
*/
void libra_sdio_setprivdata(struct sdio_func *sdio_func_dev,
void *padapter)
{
if (NULL == libra_sdio_func)
return;
sdio_set_drvdata(sdio_func_dev, padapter);
}
EXPORT_SYMBOL(libra_sdio_setprivdata);
/*
* Return private data of the function device.
*/
void *libra_sdio_getprivdata(struct sdio_func *sdio_func_dev)
{
return sdio_get_drvdata(sdio_func_dev);
}
EXPORT_SYMBOL(libra_sdio_getprivdata);
/*
* Function driver claims the SDIO device
*/
void libra_claim_host(struct sdio_func *sdio_func_dev,
pid_t *curr_claimed, pid_t current_pid, atomic_t *claim_count)
{
if (NULL == libra_sdio_func)
return;
if (*curr_claimed == current_pid) {
atomic_inc(claim_count);
return;
}
/* Go ahead and claim the host if not locked by anybody. */
sdio_claim_host(sdio_func_dev);
*curr_claimed = current_pid;
atomic_inc(claim_count);
}
EXPORT_SYMBOL(libra_claim_host);
/*
* Function driver releases the SDIO device
*/
void libra_release_host(struct sdio_func *sdio_func_dev,
pid_t *curr_claimed, pid_t current_pid, atomic_t *claim_count)
{
if (NULL == libra_sdio_func)
return;
if (*curr_claimed != current_pid) {
/* Dont release */
return;
}
atomic_dec(claim_count);
if (atomic_read(claim_count) == 0) {
*curr_claimed = 0;
sdio_release_host(sdio_func_dev);
}
}
EXPORT_SYMBOL(libra_release_host);
void libra_sdiocmd52(struct sdio_func *sdio_func_dev, unsigned int addr,
u8 *byte_var, int write, int *err_ret)
{
if (write)
sdio_writeb(sdio_func_dev, byte_var[0], addr, err_ret);
else
byte_var[0] = sdio_readb(sdio_func_dev, addr, err_ret);
}
EXPORT_SYMBOL(libra_sdiocmd52);
u8 libra_sdio_readsb(struct sdio_func *func, void *dst,
unsigned int addr, int count)
{
return sdio_readsb(func, dst, addr, count);
}
EXPORT_SYMBOL(libra_sdio_readsb);
int libra_sdio_memcpy_fromio(struct sdio_func *func,
void *dst, unsigned int addr, int count)
{
return sdio_memcpy_fromio(func, dst, addr, count);
}
EXPORT_SYMBOL(libra_sdio_memcpy_fromio);
int libra_sdio_writesb(struct sdio_func *func,
unsigned int addr, void *src, int count)
{
return sdio_writesb(func, addr, src, count);
}
EXPORT_SYMBOL(libra_sdio_writesb);
int libra_sdio_memcpy_toio(struct sdio_func *func,
unsigned int addr, void *src, int count)
{
return sdio_memcpy_toio(func, addr, src, count);
}
EXPORT_SYMBOL(libra_sdio_memcpy_toio);
int libra_detect_card_change(void)
{
if (libra_mmc_host) {
if (!strcmp(libra_mmc_host->class_dev.class->name, "mmc_host")
&& (libra_mmc_host_index == libra_mmc_host->index)) {
mmc_detect_change(libra_mmc_host, 0);
return 0;
}
}
printk(KERN_ERR "%s: Could not trigger card change\n", __func__);
return -EINVAL;
}
EXPORT_SYMBOL(libra_detect_card_change);
int libra_sdio_enable_polling(void)
{
if (libra_mmc_host) {
if (!strcmp(libra_mmc_host->class_dev.class->name, "mmc_host")
&& (libra_mmc_host_index == libra_mmc_host->index)) {
libra_mmc_host->caps |= MMC_CAP_NEEDS_POLL;
mmc_detect_change(libra_mmc_host, 0);
return 0;
}
}
printk(KERN_ERR "%s: Could not trigger SDIO scan\n", __func__);
return -1;
}
EXPORT_SYMBOL(libra_sdio_enable_polling);
void libra_sdio_set_clock(struct sdio_func *func, unsigned int clk_freq)
{
struct mmc_host *host = func->card->host;
host->ios.clock = clk_freq;
host->ops->set_ios(host, &host->ios);
}
EXPORT_SYMBOL(libra_sdio_set_clock);
/*
* API to get SDIO Device Card ID
*/
void libra_sdio_get_card_id(struct sdio_func *func, unsigned short *card_id)
{
if (card_id)
*card_id = libra_sdio_card_id;
}
EXPORT_SYMBOL(libra_sdio_get_card_id);
/*
* SDIO Probe
*/
static int libra_sdio_probe(struct sdio_func *func,
const struct sdio_device_id *sdio_dev_id)
{
libra_mmc_host = func->card->host;
libra_mmc_host_index = libra_mmc_host->index;
libra_sdio_func = func;
libra_sdio_card_id = sdio_dev_id->device;
printk(KERN_INFO "%s: success with block size of %d device_id=0x%x\n",
__func__,
func->cur_blksize,
sdio_dev_id->device);
/* Turn off SDIO polling from now on */
libra_mmc_host->caps &= ~MMC_CAP_NEEDS_POLL;
return 0;
}
static void libra_sdio_remove(struct sdio_func *func)
{
if (libra_notify_card_removal_hdlr)
libra_notify_card_removal_hdlr();
libra_sdio_func = NULL;
printk(KERN_INFO "%s : Module removed.\n", __func__);
}
#ifdef CONFIG_PM
static int libra_sdio_suspend(struct device *dev)
{
struct sdio_func *func = dev_to_sdio_func(dev);
int ret = 0;
ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
if (ret) {
printk(KERN_ERR "%s: Error Host doesn't support the keep power capability\n" ,
__func__);
return ret;
}
if (libra_suspend_hldr) {
/* Disable SDIO IRQ when driver is being suspended */
libra_enable_sdio_irq(func, 0);
ret = libra_suspend_hldr(func);
if (ret) {
printk(KERN_ERR
"%s: Libra driver is not able to suspend\n" , __func__);
/* Error - Restore SDIO IRQ */
libra_enable_sdio_irq(func, 1);
return ret;
}
}
return sdio_set_host_pm_flags(func, MMC_PM_WAKE_SDIO_IRQ);
}
static int libra_sdio_resume(struct device *dev)
{
struct sdio_func *func = dev_to_sdio_func(dev);
if (libra_resume_hldr) {
libra_resume_hldr(func);
/* Restore SDIO IRQ */
libra_enable_sdio_irq(func, 1);
}
return 0;
}
#else
#define libra_sdio_suspend 0
#define libra_sdio_resume 0
#endif
static void libra_sdio_shutdown(struct device *dev)
{
if (libra_sdio_shutdown_hdlr) {
libra_sdio_shutdown_hdlr();
printk(KERN_INFO "%s : Notified shutdown event to Libra driver.\n",
__func__);
}
}
int libra_sdio_register_shutdown_hdlr(
shutdown_handler_t *libra_shutdown_hdlr)
{
libra_sdio_shutdown_hdlr = libra_shutdown_hdlr;
return 0;
}
EXPORT_SYMBOL(libra_sdio_register_shutdown_hdlr);
int libra_sdio_notify_card_removal(
notify_card_removal_t *libra_sdio_notify_card_removal_hdlr)
{
libra_notify_card_removal_hdlr = libra_sdio_notify_card_removal_hdlr;
return 0;
}
EXPORT_SYMBOL(libra_sdio_notify_card_removal);
static struct sdio_device_id libra_sdioid[] = {
{.class = 0, .vendor = LIBRA_MAN_ID, .device = LIBRA_REV_1_0_CARD_ID},
{.class = 0, .vendor = VOLANS_MAN_ID, .device = VOLANS_REV_2_0_CARD_ID},
{}
};
static const struct dev_pm_ops libra_sdio_pm_ops = {
.suspend = libra_sdio_suspend,
.resume = libra_sdio_resume,
};
static struct sdio_driver libra_sdiofn_driver = {
.name = "libra_sdiofn",
.id_table = libra_sdioid,
.probe = libra_sdio_probe,
.remove = libra_sdio_remove,
.drv.pm = &libra_sdio_pm_ops,
.drv.shutdown = libra_sdio_shutdown,
};
static int __init libra_sdioif_init(void)
{
libra_sdio_func = NULL;
libra_mmc_host = NULL;
libra_mmc_host_index = -1;
libra_suspend_hldr = NULL;
libra_resume_hldr = NULL;
libra_notify_card_removal_hdlr = NULL;
libra_sdio_shutdown_hdlr = NULL;
sdio_register_driver(&libra_sdiofn_driver);
printk(KERN_INFO "%s: Loaded Successfully\n", __func__);
return 0;
}
static void __exit libra_sdioif_exit(void)
{
unsigned int attempts = 0;
if (!libra_detect_card_change()) {
do {
++attempts;
msleep(500);
} while (libra_sdio_func != NULL && attempts < 3);
}
if (libra_sdio_func != NULL)
printk(KERN_ERR "%s: Card removal not detected\n", __func__);
sdio_unregister_driver(&libra_sdiofn_driver);
libra_sdio_func = NULL;
libra_mmc_host = NULL;
libra_mmc_host_index = -1;
printk(KERN_INFO "%s: Unloaded Successfully\n", __func__);
}
module_init(libra_sdioif_init);
module_exit(libra_sdioif_exit);
MODULE_LICENSE("GPL v2");
MODULE_VERSION("1.0");
MODULE_DESCRIPTION("WLAN SDIODriver");