wl1271_sdio_test: Add module for sdio RX/TX testing
This module enables individually generating RX and TX traffic over the SDIO bus on which the WL1271 chipset is connected. This is required to perform RF interference testing. The module takes 2 module parameters 'rx' and 'tx'. To generate RX traffic: modprobe wl1271_sdio_test rx=1 To generate TX traffic: modprobe wl1271_sdio_test tx=1 To generate both RX & TX traffic, set both rx and tx to 1. You can change the testing configuration at runtime by changing the rx & tx values at /sys/modules/wl1271_sdio_test/ To stop testing simply unload the module. Signed-off-by: Roger Quadros <roger.quadros@nokia.com> Reviewed-by: Carlos Chinea <carlos.chinea@nokia.com> Signed-off-by: Luciano Coelho <luciano.coelho@nokia.com>
This commit is contained in:
Roger Quadros
Luciano Coelho
parent
fb6a6819fa
commit
b69eb80bf7
|
|
@ -52,6 +52,14 @@ config WL12XX_SDIO
|
|||
If you choose to build a module, it'll be called wl12xx_sdio.
|
||||
Say N if unsure.
|
||||
|
||||
config WL1271_SDIO_TEST
|
||||
tristate "TI wl1271 SDIO testing support"
|
||||
depends on WL1271 && MMC
|
||||
---help---
|
||||
This module adds support for the SDIO bus testing with the
|
||||
TI wl1271 chipset. Select this if your platform is using
|
||||
the SDIO bus.
|
||||
|
||||
config WL12XX_PLATFORM_DATA
|
||||
bool
|
||||
depends on WL12XX_SDIO != n || WL1251_SDIO != n
|
||||
|
|
|
|||
|
|
@ -9,5 +9,7 @@ obj-$(CONFIG_WL12XX) += wl12xx.o
|
|||
obj-$(CONFIG_WL12XX_SPI) += wl12xx_spi.o
|
||||
obj-$(CONFIG_WL12XX_SDIO) += wl12xx_sdio.o
|
||||
|
||||
obj-$(CONFIG_WL1271_SDIO_TEST) += wl1271_sdio_test.o
|
||||
|
||||
# small builtin driver bit
|
||||
obj-$(CONFIG_WL12XX_PLATFORM_DATA) += wl12xx_platform_data.o
|
||||
|
|
|
|||
|
|
@ -0,0 +1,510 @@
|
|||
/*
|
||||
* wl1271_sdio_test.c - SDIO testing driver for wl1271
|
||||
*
|
||||
* Copyright (C) 2010 Nokia Corporation
|
||||
*
|
||||
* Contact: Roger Quadros <roger.quadros@nokia.com>
|
||||
*
|
||||
* wl1271 read/write routines taken from wl1271_sdio.c
|
||||
*
|
||||
* 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/crc7.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/mmc/sdio_func.h>
|
||||
#include <linux/mmc/sdio_ids.h>
|
||||
#include <linux/mmc/card.h>
|
||||
#include <linux/gpio.h>
|
||||
#include <linux/wl12xx.h>
|
||||
#include <linux/kthread.h>
|
||||
#include <linux/firmware.h>
|
||||
|
||||
#include "wl1271.h"
|
||||
#include "wl1271_io.h"
|
||||
#include "wl1271_boot.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 rx, tx;
|
||||
|
||||
module_param(rx, bool, S_IRUGO | S_IWUSR);
|
||||
MODULE_PARM_DESC(rx, "Perform rx test. Default (0). "
|
||||
"This test continuously reads data from the SDIO device.\n");
|
||||
|
||||
module_param(tx, bool, S_IRUGO | S_IWUSR);
|
||||
MODULE_PARM_DESC(tx, "Perform tx test. Default (0). "
|
||||
"This test continuously writes data to the SDIO device.\n");
|
||||
|
||||
struct wl1271_test {
|
||||
struct wl1271 wl;
|
||||
struct task_struct *test_task;
|
||||
};
|
||||
|
||||
static const struct sdio_device_id wl1271_devices[] = {
|
||||
{ SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) },
|
||||
{}
|
||||
};
|
||||
|
||||
static inline struct sdio_func *wl_to_func(struct wl1271 *wl)
|
||||
{
|
||||
return wl->if_priv;
|
||||
}
|
||||
|
||||
static struct device *wl1271_sdio_wl_to_dev(struct wl1271 *wl)
|
||||
{
|
||||
return &(wl_to_func(wl)->dev);
|
||||
}
|
||||
|
||||
static void wl1271_sdio_raw_read(struct wl1271 *wl, int addr, void *buf,
|
||||
size_t len, bool fixed)
|
||||
{
|
||||
int ret = 0;
|
||||
struct sdio_func *func = wl_to_func(wl);
|
||||
|
||||
if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
|
||||
((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret);
|
||||
wl1271_debug(DEBUG_SDIO, "sdio read 52 addr 0x%x, byte 0x%02x",
|
||||
addr, ((u8 *)buf)[0]);
|
||||
} else {
|
||||
if (fixed)
|
||||
ret = sdio_readsb(func, buf, addr, len);
|
||||
else
|
||||
ret = sdio_memcpy_fromio(func, buf, addr, len);
|
||||
|
||||
wl1271_debug(DEBUG_SDIO, "sdio read 53 addr 0x%x, %zu bytes",
|
||||
addr, len);
|
||||
wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
|
||||
}
|
||||
|
||||
if (ret)
|
||||
wl1271_error("sdio read failed (%d)", ret);
|
||||
}
|
||||
|
||||
static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf,
|
||||
size_t len, bool fixed)
|
||||
{
|
||||
int ret = 0;
|
||||
struct sdio_func *func = wl_to_func(wl);
|
||||
|
||||
if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
|
||||
sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret);
|
||||
wl1271_debug(DEBUG_SDIO, "sdio write 52 addr 0x%x, byte 0x%02x",
|
||||
addr, ((u8 *)buf)[0]);
|
||||
} else {
|
||||
wl1271_debug(DEBUG_SDIO, "sdio write 53 addr 0x%x, %zu bytes",
|
||||
addr, len);
|
||||
wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
|
||||
|
||||
if (fixed)
|
||||
ret = sdio_writesb(func, addr, buf, len);
|
||||
else
|
||||
ret = sdio_memcpy_toio(func, addr, buf, len);
|
||||
}
|
||||
if (ret)
|
||||
wl1271_error("sdio write failed (%d)", ret);
|
||||
|
||||
}
|
||||
|
||||
static int wl1271_sdio_set_power(struct wl1271 *wl, bool enable)
|
||||
{
|
||||
struct sdio_func *func = wl_to_func(wl);
|
||||
|
||||
/* Let the SDIO stack handle wlan_enable control, so we
|
||||
* keep host claimed while wlan is in use to keep wl1271
|
||||
* alive.
|
||||
*/
|
||||
if (enable) {
|
||||
sdio_claim_power(func);
|
||||
sdio_claim_host(func);
|
||||
sdio_enable_func(func);
|
||||
} else {
|
||||
sdio_disable_func(func);
|
||||
sdio_release_host(func);
|
||||
sdio_release_power(func);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void wl1271_sdio_disable_interrupts(struct wl1271 *wl)
|
||||
{
|
||||
}
|
||||
|
||||
static void wl1271_sdio_enable_interrupts(struct wl1271 *wl)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
static struct wl1271_if_operations sdio_ops = {
|
||||
.read = wl1271_sdio_raw_read,
|
||||
.write = wl1271_sdio_raw_write,
|
||||
.power = wl1271_sdio_set_power,
|
||||
.dev = wl1271_sdio_wl_to_dev,
|
||||
.enable_irq = wl1271_sdio_enable_interrupts,
|
||||
.disable_irq = wl1271_sdio_disable_interrupts,
|
||||
};
|
||||
|
||||
static void wl1271_fw_wakeup(struct wl1271 *wl)
|
||||
{
|
||||
u32 elp_reg;
|
||||
|
||||
elp_reg = ELPCTRL_WAKE_UP;
|
||||
wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
|
||||
}
|
||||
|
||||
static int wl1271_fetch_firmware(struct wl1271 *wl)
|
||||
{
|
||||
const struct firmware *fw;
|
||||
int ret;
|
||||
|
||||
ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
|
||||
|
||||
if (ret < 0) {
|
||||
wl1271_error("could not get firmware: %d", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (fw->size % 4) {
|
||||
wl1271_error("firmware size is not multiple of 32 bits: %zu",
|
||||
fw->size);
|
||||
ret = -EILSEQ;
|
||||
goto out;
|
||||
}
|
||||
|
||||
wl->fw_len = fw->size;
|
||||
wl->fw = vmalloc(wl->fw_len);
|
||||
|
||||
if (!wl->fw) {
|
||||
wl1271_error("could not allocate memory for the firmware");
|
||||
ret = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
memcpy(wl->fw, fw->data, wl->fw_len);
|
||||
|
||||
ret = 0;
|
||||
|
||||
out:
|
||||
release_firmware(fw);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int wl1271_fetch_nvs(struct wl1271 *wl)
|
||||
{
|
||||
const struct firmware *fw;
|
||||
int ret;
|
||||
|
||||
ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
|
||||
|
||||
if (ret < 0) {
|
||||
wl1271_error("could not get nvs file: %d", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
|
||||
|
||||
if (!wl->nvs) {
|
||||
wl1271_error("could not allocate memory for the nvs file");
|
||||
ret = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
wl->nvs_len = fw->size;
|
||||
|
||||
out:
|
||||
release_firmware(fw);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int wl1271_chip_wakeup(struct wl1271 *wl)
|
||||
{
|
||||
struct wl1271_partition_set partition;
|
||||
int ret;
|
||||
|
||||
msleep(WL1271_PRE_POWER_ON_SLEEP);
|
||||
ret = wl1271_power_on(wl);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
msleep(WL1271_POWER_ON_SLEEP);
|
||||
|
||||
/* We don't need a real memory partition here, because we only want
|
||||
* to use the registers at this point. */
|
||||
memset(&partition, 0, sizeof(partition));
|
||||
partition.reg.start = REGISTERS_BASE;
|
||||
partition.reg.size = REGISTERS_DOWN_SIZE;
|
||||
wl1271_set_partition(wl, &partition);
|
||||
|
||||
/* ELP module wake up */
|
||||
wl1271_fw_wakeup(wl);
|
||||
|
||||
/* whal_FwCtrl_BootSm() */
|
||||
|
||||
/* 0. read chip id from CHIP_ID */
|
||||
wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
|
||||
|
||||
/* 1. check if chip id is valid */
|
||||
|
||||
switch (wl->chip.id) {
|
||||
case CHIP_ID_1271_PG10:
|
||||
wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
|
||||
wl->chip.id);
|
||||
break;
|
||||
case CHIP_ID_1271_PG20:
|
||||
wl1271_notice("chip id 0x%x (1271 PG20)",
|
||||
wl->chip.id);
|
||||
break;
|
||||
default:
|
||||
wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct wl1271_partition_set part_down = {
|
||||
.mem = {
|
||||
.start = 0x00000000,
|
||||
.size = 0x000177c0
|
||||
},
|
||||
.reg = {
|
||||
.start = REGISTERS_BASE,
|
||||
.size = 0x00008800
|
||||
},
|
||||
.mem2 = {
|
||||
.start = 0x00000000,
|
||||
.size = 0x00000000
|
||||
},
|
||||
.mem3 = {
|
||||
.start = 0x00000000,
|
||||
.size = 0x00000000
|
||||
},
|
||||
};
|
||||
|
||||
static int tester(void *data)
|
||||
{
|
||||
struct wl1271 *wl = data;
|
||||
struct sdio_func *func = wl_to_func(wl);
|
||||
struct device *pdev = &func->dev;
|
||||
int ret = 0;
|
||||
bool rx_started = 0;
|
||||
bool tx_started = 0;
|
||||
uint8_t *tx_buf, *rx_buf;
|
||||
int test_size = PAGE_SIZE;
|
||||
u32 addr = 0;
|
||||
struct wl1271_partition_set partition;
|
||||
|
||||
/* We assume chip is powered up and firmware fetched */
|
||||
|
||||
memcpy(&partition, &part_down, sizeof(partition));
|
||||
partition.mem.start = addr;
|
||||
wl1271_set_partition(wl, &partition);
|
||||
|
||||
tx_buf = kmalloc(test_size, GFP_KERNEL);
|
||||
rx_buf = kmalloc(test_size, GFP_KERNEL);
|
||||
if (!tx_buf || !rx_buf) {
|
||||
dev_err(pdev,
|
||||
"Could not allocate memory. Test will not run.\n");
|
||||
ret = -ENOMEM;
|
||||
goto free;
|
||||
}
|
||||
|
||||
memset(tx_buf, 0x5a, test_size);
|
||||
|
||||
/* write something in data area so we can read it back */
|
||||
wl1271_write(wl, addr, tx_buf, test_size, false);
|
||||
|
||||
while (!kthread_should_stop()) {
|
||||
if (rx && !rx_started) {
|
||||
dev_info(pdev, "starting rx test\n");
|
||||
rx_started = 1;
|
||||
} else if (!rx && rx_started) {
|
||||
dev_info(pdev, "stopping rx test\n");
|
||||
rx_started = 0;
|
||||
}
|
||||
|
||||
if (tx && !tx_started) {
|
||||
dev_info(pdev, "starting tx test\n");
|
||||
tx_started = 1;
|
||||
} else if (!tx && tx_started) {
|
||||
dev_info(pdev, "stopping tx test\n");
|
||||
tx_started = 0;
|
||||
}
|
||||
|
||||
if (rx_started)
|
||||
wl1271_read(wl, addr, rx_buf, test_size, false);
|
||||
|
||||
if (tx_started)
|
||||
wl1271_write(wl, addr, tx_buf, test_size, false);
|
||||
|
||||
if (!rx_started && !tx_started)
|
||||
msleep(100);
|
||||
}
|
||||
|
||||
free:
|
||||
kfree(tx_buf);
|
||||
kfree(rx_buf);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __devinit wl1271_probe(struct sdio_func *func,
|
||||
const struct sdio_device_id *id)
|
||||
{
|
||||
const struct wl12xx_platform_data *wlan_data;
|
||||
struct wl1271 *wl;
|
||||
struct wl1271_test *wl_test;
|
||||
int ret = 0;
|
||||
|
||||
/* wl1271 has 2 sdio functions we handle just the wlan part */
|
||||
if (func->num != 0x02)
|
||||
return -ENODEV;
|
||||
|
||||
wl_test = kzalloc(sizeof(struct wl1271_test), GFP_KERNEL);
|
||||
if (!wl_test) {
|
||||
dev_err(&func->dev, "Could not allocate memory\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
wl = &wl_test->wl;
|
||||
|
||||
wl->if_priv = func;
|
||||
wl->if_ops = &sdio_ops;
|
||||
|
||||
/* Grab access to FN0 for ELP reg. */
|
||||
func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
|
||||
|
||||
wlan_data = wl12xx_get_platform_data();
|
||||
if (IS_ERR(wlan_data)) {
|
||||
ret = PTR_ERR(wlan_data);
|
||||
dev_err(&func->dev, "missing wlan platform data: %d\n", ret);
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
wl->irq = wlan_data->irq;
|
||||
wl->ref_clock = wlan_data->board_ref_clock;
|
||||
|
||||
sdio_set_drvdata(func, wl_test);
|
||||
|
||||
|
||||
/* power up the device */
|
||||
ret = wl1271_chip_wakeup(wl);
|
||||
if (ret) {
|
||||
dev_err(&func->dev, "could not wake up chip\n");
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
if (wl->fw == NULL) {
|
||||
ret = wl1271_fetch_firmware(wl);
|
||||
if (ret < 0) {
|
||||
dev_err(&func->dev, "firmware fetch error\n");
|
||||
goto out_off;
|
||||
}
|
||||
}
|
||||
|
||||
/* fetch NVS */
|
||||
if (wl->nvs == NULL) {
|
||||
ret = wl1271_fetch_nvs(wl);
|
||||
if (ret < 0) {
|
||||
dev_err(&func->dev, "NVS fetch error\n");
|
||||
goto out_off;
|
||||
}
|
||||
}
|
||||
|
||||
ret = wl1271_load_firmware(wl);
|
||||
if (ret < 0) {
|
||||
dev_err(&func->dev, "firmware load error: %d\n", ret);
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
dev_info(&func->dev, "initialized\n");
|
||||
|
||||
/* I/O testing will be done in the tester thread */
|
||||
|
||||
wl_test->test_task = kthread_run(tester, wl, "sdio_tester");
|
||||
if (IS_ERR(wl_test->test_task)) {
|
||||
dev_err(&func->dev, "unable to create kernel thread\n");
|
||||
ret = PTR_ERR(wl_test->test_task);
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
out_off:
|
||||
/* power off the chip */
|
||||
wl1271_power_off(wl);
|
||||
|
||||
out_free:
|
||||
kfree(wl_test);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void __devexit wl1271_remove(struct sdio_func *func)
|
||||
{
|
||||
struct wl1271_test *wl_test = sdio_get_drvdata(func);
|
||||
|
||||
/* stop the I/O test thread */
|
||||
kthread_stop(wl_test->test_task);
|
||||
|
||||
/* power off the chip */
|
||||
wl1271_power_off(&wl_test->wl);
|
||||
|
||||
vfree(wl_test->wl.fw);
|
||||
wl_test->wl.fw = NULL;
|
||||
kfree(wl_test->wl.nvs);
|
||||
wl_test->wl.nvs = NULL;
|
||||
|
||||
kfree(wl_test);
|
||||
}
|
||||
|
||||
static struct sdio_driver wl1271_sdio_driver = {
|
||||
.name = "wl1271_sdio_test",
|
||||
.id_table = wl1271_devices,
|
||||
.probe = wl1271_probe,
|
||||
.remove = __devexit_p(wl1271_remove),
|
||||
};
|
||||
|
||||
static int __init wl1271_init(void)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = sdio_register_driver(&wl1271_sdio_driver);
|
||||
if (ret < 0)
|
||||
pr_err("failed to register sdio driver: %d\n", ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
module_init(wl1271_init);
|
||||
|
||||
static void __exit wl1271_exit(void)
|
||||
{
|
||||
sdio_unregister_driver(&wl1271_sdio_driver);
|
||||
}
|
||||
module_exit(wl1271_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Roger Quadros <roger.quadros@nokia.com>");
|
||||
|
||||
Loading…
Reference in New Issue