drivers/net/wireless/libra/libra_sdioif.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");