Release 4.8 drivers/net/wireless/ti/wlcore/sdio.c

Directory: drivers/net/wireless/ti/wlcore
/*
 * This file is part of wl1271
 *
 * Copyright (C) 2009-2010 Nokia Corporation
 *
 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#include <linux/irq.h>
#include <linux/module.h>
#include <linux/vmalloc.h>
#include <linux/platform_device.h>
#include <linux/mmc/sdio.h>
#include <linux/mmc/sdio_func.h>
#include <linux/mmc/sdio_ids.h>
#include <linux/mmc/card.h>
#include <linux/mmc/host.h>
#include <linux/gpio.h>
#include <linux/pm_runtime.h>
#include <linux/printk.h>
#include <linux/of.h>
#include <linux/of_irq.h>

#include "wlcore.h"
#include "wl12xx_80211.h"
#include "io.h"

#ifndef SDIO_VENDOR_ID_TI

#define SDIO_VENDOR_ID_TI		0x0097
#endif

#ifndef SDIO_DEVICE_ID_TI_WL1271

#define SDIO_DEVICE_ID_TI_WL1271	0x4076
#endif


static bool dump = false;


struct wl12xx_sdio_glue {
	
struct device *dev;
	
struct platform_device *core;
};


static const struct sdio_device_id wl1271_devices[] = {
	{ SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) },
	{}
};
MODULE_DEVICE_TABLE(sdio, wl1271_devices);



static void wl1271_sdio_set_block_size(struct device *child,
				       unsigned int blksz)
{
	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);
	struct sdio_func *func = dev_to_sdio_func(glue->dev);

	sdio_claim_host(func);
	sdio_set_block_size(func, blksz);
	sdio_release_host(func);
}

Contributors
Person Tokens Prop Commits CommitProp
felipe balbi felipe balbi 23 41.07% 2 33.33%
teemu paasikivi teemu paasikivi 15 26.79% 1 16.67%
luciano coelho luciano coelho 8 14.29% 1 16.67%
eliad peller eliad peller 6 10.71% 1 16.67%
ido yariv ido yariv 4 7.14% 1 16.67%
Total 56 100.00% 6 100.00%



static int __must_check wl12xx_sdio_raw_read(struct device *child, int addr,
					     void *buf, size_t len, bool fixed)
{
	int ret;
	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);
	struct sdio_func *func = dev_to_sdio_func(glue->dev);

	sdio_claim_host(func);

	if (unlikely(dump)) {
		printk(KERN_DEBUG "wlcore_sdio: READ from 0x%04x\n", addr);
		print_hex_dump(KERN_DEBUG, "wlcore_sdio: READ ",
				DUMP_PREFIX_OFFSET, 16, 1,
				buf, len, false);
	}

	if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG)) {
		((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret);
		dev_dbg(child->parent, "sdio read 52 addr 0x%x, byte 0x%02x\n",
			addr, ((u8 *)buf)[0]);
	} else {
		if (fixed)
			ret = sdio_readsb(func, buf, addr, len);
		else
			ret = sdio_memcpy_fromio(func, buf, addr, len);

		dev_dbg(child->parent, "sdio read 53 addr 0x%x, %zu bytes\n",
			addr, len);
	}

	sdio_release_host(func);

	if (WARN_ON(ret))
		dev_err(child->parent, "sdio read failed (%d)\n", ret);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
teemu paasikivi teemu paasikivi 130 59.09% 1 11.11%
luciano coelho luciano coelho 53 24.09% 3 33.33%
felipe balbi felipe balbi 19 8.64% 2 22.22%
eliad peller eliad peller 10 4.55% 1 11.11%
ido yariv ido yariv 8 3.64% 2 22.22%
Total 220 100.00% 9 100.00%



static int __must_check wl12xx_sdio_raw_write(struct device *child, int addr,
					      void *buf, size_t len, bool fixed)
{
	int ret;
	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);
	struct sdio_func *func = dev_to_sdio_func(glue->dev);

	sdio_claim_host(func);

	if (unlikely(dump)) {
		printk(KERN_DEBUG "wlcore_sdio: WRITE to 0x%04x\n", addr);
		print_hex_dump(KERN_DEBUG, "wlcore_sdio: WRITE ",
				DUMP_PREFIX_OFFSET, 16, 1,
				buf, len, false);
	}

	if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG)) {
		sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret);
		dev_dbg(child->parent, "sdio write 52 addr 0x%x, byte 0x%02x\n",
			addr, ((u8 *)buf)[0]);
	} else {
		dev_dbg(child->parent, "sdio write 53 addr 0x%x, %zu bytes\n",
			addr, len);

		if (fixed)
			ret = sdio_writesb(func, addr, buf, len);
		else
			ret = sdio_memcpy_toio(func, addr, buf, len);
	}

	sdio_release_host(func);

	if (WARN_ON(ret))
		dev_err(child->parent, "sdio write failed (%d)\n", ret);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
teemu paasikivi teemu paasikivi 130 59.09% 1 11.11%
luciano coelho luciano coelho 53 24.09% 3 33.33%
felipe balbi felipe balbi 19 8.64% 2 22.22%
eliad peller eliad peller 10 4.55% 1 11.11%
ido yariv ido yariv 8 3.64% 2 22.22%
Total 220 100.00% 9 100.00%



static int wl12xx_sdio_power_on(struct wl12xx_sdio_glue *glue)
{
	int ret;
	struct sdio_func *func = dev_to_sdio_func(glue->dev);
	struct mmc_card *card = func->card;

	ret = pm_runtime_get_sync(&card->dev);
	if (ret) {
		/*
                 * Runtime PM might be temporarily disabled, or the device
                 * might have a positive reference counter. Make sure it is
                 * really powered on.
                 */
		ret = mmc_power_restore_host(card->host);
		if (ret < 0) {
			pm_runtime_put_sync(&card->dev);
			goto out;
		}
	}

	sdio_claim_host(func);
	sdio_enable_func(func);
	sdio_release_host(func);

out:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
ido yariv ido yariv 37 37.00% 2 18.18%
ohad ben-cohen ohad ben-cohen 24 24.00% 4 36.36%
teemu paasikivi teemu paasikivi 18 18.00% 2 18.18%
felipe balbi felipe balbi 16 16.00% 2 18.18%
eliad peller eliad peller 5 5.00% 1 9.09%
Total 100 100.00% 11 100.00%



static int wl12xx_sdio_power_off(struct wl12xx_sdio_glue *glue)
{
	int ret;
	struct sdio_func *func = dev_to_sdio_func(glue->dev);
	struct mmc_card *card = func->card;

	sdio_claim_host(func);
	sdio_disable_func(func);
	sdio_release_host(func);

	/* Power off the card manually in case it wasn't powered off above */
	ret = mmc_power_save_host(card->host);
	if (ret < 0)
		goto out;

	/* Let runtime PM know the card is powered off */
	pm_runtime_put_sync(&card->dev);

out:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
ido yariv ido yariv 33 39.76% 2 20.00%
ohad ben-cohen ohad ben-cohen 17 20.48% 4 40.00%
felipe balbi felipe balbi 16 19.28% 2 20.00%
teemu paasikivi teemu paasikivi 12 14.46% 1 10.00%
eliad peller eliad peller 5 6.02% 1 10.00%
Total 83 100.00% 10 100.00%



static int wl12xx_sdio_set_power(struct device *child, bool enable)
{
	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);

	if (enable)
		return wl12xx_sdio_power_on(glue);
	else
		return wl12xx_sdio_power_off(glue);
}

Contributors
Person Tokens Prop Commits CommitProp
ohad ben-cohen ohad ben-cohen 23 53.49% 2 50.00%
felipe balbi felipe balbi 19 44.19% 1 25.00%
teemu paasikivi teemu paasikivi 1 2.33% 1 25.00%
Total 43 100.00% 4 100.00%


static struct wl1271_if_operations sdio_ops = {
	.read		= wl12xx_sdio_raw_read,
	.write		= wl12xx_sdio_raw_write,
	.power		= wl12xx_sdio_set_power,
	.set_block_size = wl1271_sdio_set_block_size,
};

#ifdef CONFIG_OF

static const struct of_device_id wlcore_sdio_of_match_table[] = {
	{ .compatible = "ti,wl1271" },
	{ .compatible = "ti,wl1273" },
	{ .compatible = "ti,wl1281" },
	{ .compatible = "ti,wl1283" },
	{ .compatible = "ti,wl1801" },
	{ .compatible = "ti,wl1805" },
	{ .compatible = "ti,wl1807" },
	{ .compatible = "ti,wl1831" },
	{ .compatible = "ti,wl1835" },
	{ .compatible = "ti,wl1837" },
	{ }
};



static int wlcore_probe_of(struct device *dev, int *irq,
			   struct wlcore_platdev_data *pdev_data)
{
	struct device_node *np = dev->of_node;

	if (!np || !of_match_node(wlcore_sdio_of_match_table, np))
		return -ENODATA;

	*irq = irq_of_parse_and_map(np, 0);
	if (!*irq) {
		dev_err(dev, "No irq in platform data\n");
		return -EINVAL;
	}

	/* optional clock frequency params */
	of_property_read_u32(np, "ref-clock-frequency",
			     &pdev_data->ref_clock_freq);
	of_property_read_u32(np, "tcxo-clock-frequency",
			     &pdev_data->tcxo_clock_freq);

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
eliad peller eliad peller 103 100.00% 2 100.00%
Total 103 100.00% 2 100.00%

#else


static int wlcore_probe_of(struct device *dev, int *irq,
			   struct wlcore_platdev_data *pdev_data)
{
	return -ENODATA;
}
Contributors
Person Tokens Prop Commits CommitProp
eliad peller eliad peller 24 100.00% 2 100.00%
Total 24 100.00% 2 100.00%

#endif



static int wl1271_probe(struct sdio_func *func,
				  const struct sdio_device_id *id)
{
	struct wlcore_platdev_data pdev_data;
	struct wl12xx_sdio_glue *glue;
	struct resource res[1];
	mmc_pm_flag_t mmcflags;
	int ret = -ENOMEM;
	int irq;
	const char *chip_family;

	/* We are only able to handle the wlan function */
	if (func->num != 0x02)
		return -ENODEV;

	memset(&pdev_data, 0x00, sizeof(pdev_data));
	pdev_data.if_ops = &sdio_ops;

	glue = kzalloc(sizeof(*glue), GFP_KERNEL);
	if (!glue) {
		dev_err(&func->dev, "can't allocate glue\n");
		goto out;
	}

	glue->dev = &func->dev;

	/* Grab access to FN0 for ELP reg. */
	func->card->quirks |= MMC_QUIRK_LENIENT_FN0;

	/* Use block mode for transferring over one block size of data */
	func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;

	ret = wlcore_probe_of(&func->dev, &irq, &pdev_data);
	if (ret)
		goto out_free_glue;

	/* if sdio can keep power while host is suspended, enable wow */
	mmcflags = sdio_get_host_pm_caps(func);
	dev_dbg(glue->dev, "sdio PM caps = 0x%x\n", mmcflags);

	if (mmcflags & MMC_PM_KEEP_POWER)
		pdev_data.pwr_in_suspend = true;

	sdio_set_drvdata(func, glue);

	/* Tell PM core that we don't need the card to be powered now */
	pm_runtime_put_noidle(&func->dev);

	/*
         * Due to a hardware bug, we can't differentiate wl18xx from
         * wl12xx, because both report the same device ID.  The only
         * way to differentiate is by checking the SDIO revision,
         * which is 3.00 on the wl18xx chips.
         */
	if (func->card->cccr.sdio_vsn == SDIO_SDIO_REV_3_00)
		chip_family = "wl18xx";
	else
		chip_family = "wl12xx";

	glue->core = platform_device_alloc(chip_family, PLATFORM_DEVID_AUTO);
	if (!glue->core) {
		dev_err(glue->dev, "can't allocate platform_device");
		ret = -ENOMEM;
		goto out_free_glue;
	}

	glue->core->dev.parent = &func->dev;

	memset(res, 0x00, sizeof(res));

	res[0].start = irq;
	res[0].flags = IORESOURCE_IRQ |
		       irqd_get_trigger_type(irq_get_irq_data(irq));
	res[0].name = "irq";

	ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res));
	if (ret) {
		dev_err(glue->dev, "can't add resources\n");
		goto out_dev_put;
	}

	ret = platform_device_add_data(glue->core, &pdev_data,
				       sizeof(pdev_data));
	if (ret) {
		dev_err(glue->dev, "can't add platform data\n");
		goto out_dev_put;
	}

	ret = platform_device_add(glue->core);
	if (ret) {
		dev_err(glue->dev, "can't add platform device\n");
		goto out_dev_put;
	}
	return 0;

out_dev_put:
	platform_device_put(glue->core);

out_free_glue:
	kfree(glue);

out:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
felipe balbi felipe balbi 226 50.00% 3 16.67%
luciano coelho luciano coelho 86 19.03% 6 33.33%
teemu paasikivi teemu paasikivi 58 12.83% 2 11.11%
eliad peller eliad peller 48 10.62% 3 16.67%
christian engelmayer christian engelmayer 10 2.21% 1 5.56%
arik nemtsov arik nemtsov 9 1.99% 1 5.56%
ohad ben-cohen ohad ben-cohen 9 1.99% 1 5.56%
raphael poggi raphael poggi 6 1.33% 1 5.56%
Total 452 100.00% 18 100.00%



static void wl1271_remove(struct sdio_func *func)
{
	struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func);

	/* Undo decrement done above in wl1271_probe */
	pm_runtime_get_noresume(&func->dev);

	platform_device_unregister(glue->core);
	kfree(glue);
}

Contributors
Person Tokens Prop Commits CommitProp
teemu paasikivi teemu paasikivi 19 45.24% 1 20.00%
felipe balbi felipe balbi 13 30.95% 2 40.00%
ohad ben-cohen ohad ben-cohen 9 21.43% 1 20.00%
wei yongjun wei yongjun 1 2.38% 1 20.00%
Total 42 100.00% 5 100.00%

#ifdef CONFIG_PM


static int wl1271_suspend(struct device *dev)
{
	/* Tell MMC/SDIO core it's OK to power down the card
         * (if it isn't already), but not to remove it completely */
	struct sdio_func *func = dev_to_sdio_func(dev);
	struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func);
	struct wl1271 *wl = platform_get_drvdata(glue->core);
	mmc_pm_flag_t sdio_flags;
	int ret = 0;

	dev_dbg(dev, "wl1271 suspend. wow_enabled: %d\n",
		wl->wow_enabled);

	/* check whether sdio should keep power */
	if (wl->wow_enabled) {
		sdio_flags = sdio_get_host_pm_caps(func);

		if (!(sdio_flags & MMC_PM_KEEP_POWER)) {
			dev_err(dev, "can't keep power while host "
				     "is suspended\n");
			ret = -EINVAL;
			goto out;
		}

		/* keep power while host suspended */
		ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
		if (ret) {
			dev_err(dev, "error while trying to keep power\n");
			goto out;
		}
	}
out:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
eliad peller eliad peller 98 71.53% 1 25.00%
ohad ben-cohen ohad ben-cohen 14 10.22% 1 25.00%
eyal shapira eyal shapira 14 10.22% 1 25.00%
luciano coelho luciano coelho 11 8.03% 1 25.00%
Total 137 100.00% 4 100.00%



static int wl1271_resume(struct device *dev)
{
	dev_dbg(dev, "wl1271 resume\n");

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
ohad ben-cohen ohad ben-cohen 14 66.67% 1 33.33%
eliad peller eliad peller 4 19.05% 1 33.33%
luciano coelho luciano coelho 3 14.29% 1 33.33%
Total 21 100.00% 3 100.00%


static const struct dev_pm_ops wl1271_sdio_pm_ops = {
	.suspend	= wl1271_suspend,
	.resume		= wl1271_resume,
};
#endif


static struct sdio_driver wl1271_sdio_driver = {
	.name		= "wl1271_sdio",
	.id_table	= wl1271_devices,
	.probe		= wl1271_probe,
	.remove		= wl1271_remove,
#ifdef CONFIG_PM
	.drv = {
		.pm = &wl1271_sdio_pm_ops,
        },
#endif
};



static int __init wl1271_init(void)
{
	return sdio_register_driver(&wl1271_sdio_driver);
}

Contributors
Person Tokens Prop Commits CommitProp
teemu paasikivi teemu paasikivi 15 93.75% 1 50.00%
felipe balbi felipe balbi 1 6.25% 1 50.00%
Total 16 100.00% 2 100.00%



static void __exit wl1271_exit(void)
{
	sdio_unregister_driver(&wl1271_sdio_driver);
}

Contributors
Person Tokens Prop Commits CommitProp
teemu paasikivi teemu paasikivi 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%


module_init(wl1271_init);

module_exit(wl1271_exit);

module_param(dump, bool, S_IRUSR | S_IWUSR);
MODULE_PARM_DESC(dump, "Enable sdio read/write dumps.");

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Overall Contributors
Person Tokens Prop Commits CommitProp
teemu paasikivi teemu paasikivi 553 29.49% 4 8.89%
eliad peller eliad peller 407 21.71% 6 13.33%
felipe balbi felipe balbi 373 19.89% 4 8.89%
luciano coelho luciano coelho 265 14.13% 13 28.89%
ohad ben-cohen ohad ben-cohen 143 7.63% 7 15.56%
ido yariv ido yariv 93 4.96% 5 11.11%
eyal shapira eyal shapira 14 0.75% 1 2.22%
christian engelmayer christian engelmayer 10 0.53% 1 2.22%
arik nemtsov arik nemtsov 9 0.48% 1 2.22%
raphael poggi raphael poggi 6 0.32% 1 2.22%
shahar levi shahar levi 1 0.05% 1 2.22%
wei yongjun wei yongjun 1 0.05% 1 2.22%
bill pemberton bill pemberton 0.00% 0 0.00%
Total 1875 100.00% 45 100.00%
  Directory: drivers/net/wireless/ti/wlcore

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
felipe balbi	felipe balbi	23	41.07%	2	33.33%
teemu paasikivi	teemu paasikivi	15	26.79%	1	16.67%
luciano coelho	luciano coelho	8	14.29%	1	16.67%
eliad peller	eliad peller	6	10.71%	1	16.67%
ido yariv	ido yariv	4	7.14%	1	16.67%
	Total	56	100.00%	6	100.00%
cregit-Linux how code gets into the kernel

Release 4.8 drivers/net/wireless/ti/wlcore/sdio.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
