Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a390e85c authored by Felipe Balbi's avatar Felipe Balbi Committed by Luciano Coelho
Browse files

wl12xx: move common init code from bus modules to main 



Move all common parts from sdio.c and spi.c to main.c, since they now
can be handled as part of the platform driver.

Signed-off-by: default avatarFelipe Balbi <balbi@ti.com>
[forward-ported, cleaned-up and rephrased commit message]
[added a bunch of fixes and a new pdata element]
[moved some new code into main.c as well]
Signed-off-by: default avatarLuciano Coelho <coelho@ti.com>
parent ce2a217c

drivers/net/wireless/wl12xx/io.c

+6 −5
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/spi/spi.h>

#include <linux/interrupt.h>



#include "wl12xx.h"

#include "wl12xx_80211.h"
@@ -46,7 +47,7 @@ 
bool wl1271_set_block_size(struct wl1271 *wl)

{

	if (wl->if_ops->set_block_size) {

		wl->if_ops->set_block_size(wl, WL12XX_BUS_BLOCK_SIZE);

		wl->if_ops->set_block_size(wl->dev, WL12XX_BUS_BLOCK_SIZE);

		return true;

	}
@@ -55,12 +56,12 @@ bool wl1271_set_block_size(struct wl1271 *wl) 


void wl1271_disable_interrupts(struct wl1271 *wl)

{

	wl->if_ops->disable_irq(wl);

	disable_irq(wl->irq);

}



void wl1271_enable_interrupts(struct wl1271 *wl)

{

	wl->if_ops->enable_irq(wl);

	enable_irq(wl->irq);

}



/* Set the SPI partitions to access the chip addresses
@@ -128,13 +129,13 @@ EXPORT_SYMBOL_GPL(wl1271_set_partition); 
void wl1271_io_reset(struct wl1271 *wl)

{

	if (wl->if_ops->reset)

		wl->if_ops->reset(wl);

		wl->if_ops->reset(wl->dev);

}



void wl1271_io_init(struct wl1271 *wl)

{

	if (wl->if_ops->init)

		wl->if_ops->init(wl);

		wl->if_ops->init(wl->dev);

}



void wl1271_top_reg_write(struct wl1271 *wl, int addr, u16 val)

drivers/net/wireless/wl12xx/io.h

+4 −10
Original line number Diff line number Diff line
@@ -51,23 +51,17 @@ void wl1271_enable_interrupts(struct wl1271 *wl); 
void wl1271_io_reset(struct wl1271 *wl);

void wl1271_io_init(struct wl1271 *wl);



static inline struct device *wl1271_wl_to_dev(struct wl1271 *wl)

{

	return wl->if_ops->dev(wl);

}





/* Raw target IO, address is not translated */

static inline void wl1271_raw_write(struct wl1271 *wl, int addr, void *buf,

				    size_t len, bool fixed)

{

	wl->if_ops->write(wl, addr, buf, len, fixed);

	wl->if_ops->write(wl->dev, addr, buf, len, fixed);

}



static inline void wl1271_raw_read(struct wl1271 *wl, int addr, void *buf,

				   size_t len, bool fixed)

{

	wl->if_ops->read(wl, addr, buf, len, fixed);

	wl->if_ops->read(wl->dev, addr, buf, len, fixed);

}



static inline u32 wl1271_raw_read32(struct wl1271 *wl, int addr)
@@ -155,13 +149,13 @@ static inline void wl1271_write32(struct wl1271 *wl, int addr, u32 val) 


static inline void wl1271_power_off(struct wl1271 *wl)

{

	wl->if_ops->power(wl, false);

	wl->if_ops->power(wl->dev, false);

	clear_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);

}



static inline int wl1271_power_on(struct wl1271 *wl)

{

	int ret = wl->if_ops->power(wl, true);

	int ret = wl->if_ops->power(wl->dev, true);

	if (ret == 0)

		set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);

drivers/net/wireless/wl12xx/main.c

+107 −3
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ 
#include <linux/slab.h>

#include <linux/wl12xx.h>

#include <linux/sched.h>

#include <linux/interrupt.h>



#include "wl12xx.h"

#include "wl12xx_80211.h"
@@ -1067,7 +1068,7 @@ static int wl1271_fetch_firmware(struct wl1271 *wl) 


	wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);



	ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));

	ret = request_firmware(&fw, fw_name, wl->dev);



	if (ret < 0) {

		wl1271_error("could not get firmware: %d", ret);
@@ -1105,7 +1106,7 @@ static int wl1271_fetch_nvs(struct wl1271 *wl) 
	const struct firmware *fw;

	int ret;



	ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));

	ret = request_firmware(&fw, WL12XX_NVS_NAME, wl->dev);



	if (ret < 0) {

		wl1271_error("could not get nvs file: %d", ret);
@@ -4979,7 +4980,7 @@ int wl1271_init_ieee80211(struct wl1271 *wl) 


	wl->hw->wiphy->reg_notifier = wl1271_reg_notify;



	SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));

	SET_IEEE80211_DEV(wl->hw, wl->dev);



	wl->hw->sta_data_size = sizeof(struct wl1271_station);

	wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
@@ -5200,13 +5201,116 @@ int wl1271_free_hw(struct wl1271 *wl) 
}

EXPORT_SYMBOL_GPL(wl1271_free_hw);



static irqreturn_t wl12xx_hardirq(int irq, void *cookie)

{

	struct wl1271 *wl = cookie;

	unsigned long flags;



	wl1271_debug(DEBUG_IRQ, "IRQ");



	/* complete the ELP completion */

	spin_lock_irqsave(&wl->wl_lock, flags);

	set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);

	if (wl->elp_compl) {

		complete(wl->elp_compl);

		wl->elp_compl = NULL;

	}



	if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {

		/* don't enqueue a work right now. mark it as pending */

		set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);

		wl1271_debug(DEBUG_IRQ, "should not enqueue work");

		disable_irq_nosync(wl->irq);

		pm_wakeup_event(wl->dev, 0);

		spin_unlock_irqrestore(&wl->wl_lock, flags);

		return IRQ_HANDLED;

	}

	spin_unlock_irqrestore(&wl->wl_lock, flags);



	return IRQ_WAKE_THREAD;

}



static int __devinit wl12xx_probe(struct platform_device *pdev)

{

	struct wl12xx_platform_data *pdata = pdev->dev.platform_data;

	struct ieee80211_hw *hw;

	struct wl1271 *wl;

	unsigned long irqflags;

	int ret = -ENODEV;



	hw = wl1271_alloc_hw();

	if (IS_ERR(hw)) {

		wl1271_error("can't allocate hw");

		ret = PTR_ERR(hw);

		goto out;

	}



	wl = hw->priv;

	wl->irq = platform_get_irq(pdev, 0);

	wl->ref_clock = pdata->board_ref_clock;

	wl->tcxo_clock = pdata->board_tcxo_clock;

	wl->platform_quirks = pdata->platform_quirks;

	wl->set_power = pdata->set_power;

	wl->dev = &pdev->dev;

	wl->if_ops = pdata->ops;



	platform_set_drvdata(pdev, wl);



	if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)

		irqflags = IRQF_TRIGGER_RISING;

	else

		irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;



	ret = request_threaded_irq(wl->irq, wl12xx_hardirq, wl1271_irq,

				   irqflags,

				   pdev->name, wl);

	if (ret < 0) {

		wl1271_error("request_irq() failed: %d", ret);

		goto out_free_hw;

	}



	ret = enable_irq_wake(wl->irq);

	if (!ret) {

		wl->irq_wake_enabled = true;

		device_init_wakeup(wl->dev, 1);

		if (pdata->pwr_in_suspend)

			hw->wiphy->wowlan.flags = WIPHY_WOWLAN_ANY;



	}

	disable_irq(wl->irq);



	ret = wl1271_init_ieee80211(wl);

	if (ret)

		goto out_irq;



	ret = wl1271_register_hw(wl);

	if (ret)

		goto out_irq;



	return 0;



out_irq:

	free_irq(wl->irq, wl);



out_free_hw:

	wl1271_free_hw(wl);



out:

	return ret;

}



static int __devexit wl12xx_remove(struct platform_device *pdev)

{

	struct wl1271 *wl = platform_get_drvdata(pdev);



	if (wl->irq_wake_enabled) {

		device_init_wakeup(wl->dev, 0);

		disable_irq_wake(wl->irq);

	}

	wl1271_unregister_hw(wl);

	free_irq(wl->irq, wl);

	wl1271_free_hw(wl);



	return 0;

}

drivers/net/wireless/wl12xx/sdio.c

+31 −143
Original line number Diff line number Diff line
@@ -47,7 +47,6 @@ 


struct wl12xx_sdio_glue {

	struct device *dev;

	struct wl1271 *wl;

	struct platform_device *core;

};
@@ -57,67 +56,22 @@ static const struct sdio_device_id wl1271_devices[] __devinitconst = { 
};

MODULE_DEVICE_TABLE(sdio, wl1271_devices);



static void wl1271_sdio_set_block_size(struct wl1271 *wl, unsigned int blksz)

static void wl1271_sdio_set_block_size(struct device *child,

				       unsigned int blksz)

{

	sdio_claim_host(wl->if_priv);

	sdio_set_block_size(wl->if_priv, blksz);

	sdio_release_host(wl->if_priv);

}



static inline struct wl12xx_sdio_glue *wl_to_glue(struct wl1271 *wl)

{

	return wl->if_priv;

}



static struct device *wl1271_sdio_wl_to_dev(struct wl1271 *wl)

{

	return wl_to_glue(wl)->dev;

}



static irqreturn_t wl1271_hardirq(int irq, void *cookie)

{

	struct wl1271 *wl = cookie;

	unsigned long flags;



	wl1271_debug(DEBUG_IRQ, "IRQ");



	/* complete the ELP completion */

	spin_lock_irqsave(&wl->wl_lock, flags);

	set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);

	if (wl->elp_compl) {

		complete(wl->elp_compl);

		wl->elp_compl = NULL;

	}



	if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {

		/* don't enqueue a work right now. mark it as pending */

		set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);

		wl1271_debug(DEBUG_IRQ, "should not enqueue work");

		disable_irq_nosync(wl->irq);

		pm_wakeup_event(wl1271_sdio_wl_to_dev(wl), 0);

		spin_unlock_irqrestore(&wl->wl_lock, flags);

		return IRQ_HANDLED;

	}

	spin_unlock_irqrestore(&wl->wl_lock, flags);



	return IRQ_WAKE_THREAD;

}



static void wl1271_sdio_disable_interrupts(struct wl1271 *wl)

{

	disable_irq(wl->irq);

}

	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);

	struct sdio_func *func = dev_to_sdio_func(glue->dev);



static void wl1271_sdio_enable_interrupts(struct wl1271 *wl)

{

	enable_irq(wl->irq);

	sdio_claim_host(func);

	sdio_set_block_size(func, blksz);

	sdio_release_host(func);

}



static void wl1271_sdio_raw_read(struct wl1271 *wl, int addr, void *buf,

static void wl12xx_sdio_raw_read(struct device *child, int addr, void *buf,

				 size_t len, bool fixed)

{

	int ret;

	struct wl12xx_sdio_glue *glue = wl_to_glue(wl);

	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);

	struct sdio_func *func = dev_to_sdio_func(glue->dev);



	if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
@@ -139,11 +93,11 @@ static void wl1271_sdio_raw_read(struct wl1271 *wl, int addr, void *buf, 
		wl1271_error("sdio read failed (%d)", ret);

}



static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf,

static void wl12xx_sdio_raw_write(struct device *child, int addr, void *buf,

				  size_t len, bool fixed)

{

	int ret;

	struct wl12xx_sdio_glue *glue = wl_to_glue(wl);

	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);

	struct sdio_func *func = dev_to_sdio_func(glue->dev);



	if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
@@ -165,10 +119,9 @@ static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf, 
		wl1271_error("sdio write failed (%d)", ret);

}



static int wl1271_sdio_power_on(struct wl1271 *wl)

static int wl12xx_sdio_power_on(struct wl12xx_sdio_glue *glue)

{

	int ret;

	struct wl12xx_sdio_glue *glue = wl_to_glue(wl);

	struct sdio_func *func = dev_to_sdio_func(glue->dev);



	/* If enabled, tell runtime PM not to power off the card */
@@ -190,10 +143,9 @@ out: 
	return ret;

}



static int wl1271_sdio_power_off(struct wl1271 *wl)

static int wl12xx_sdio_power_off(struct wl12xx_sdio_glue *glue)

{

	int ret;

	struct wl12xx_sdio_glue *glue = wl_to_glue(wl);

	struct sdio_func *func = dev_to_sdio_func(glue->dev);



	sdio_disable_func(func);
@@ -211,33 +163,29 @@ static int wl1271_sdio_power_off(struct wl1271 *wl) 
	return ret;

}



static int wl1271_sdio_set_power(struct wl1271 *wl, bool enable)

static int wl12xx_sdio_set_power(struct device *child, bool enable)

{

	struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent);



	if (enable)

		return wl1271_sdio_power_on(wl);

		return wl12xx_sdio_power_on(glue);

	else

		return wl1271_sdio_power_off(wl);

		return wl12xx_sdio_power_off(glue);

}



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,

	.read		= wl12xx_sdio_raw_read,

	.write		= wl12xx_sdio_raw_write,

	.power		= wl12xx_sdio_set_power,

	.set_block_size = wl1271_sdio_set_block_size,

};



static int __devinit wl1271_probe(struct sdio_func *func,

				  const struct sdio_device_id *id)

{

	struct ieee80211_hw *hw;

	const struct wl12xx_platform_data *wlan_data;

	struct wl1271 *wl;

	struct wl12xx_platform_data *wlan_data;

	struct wl12xx_sdio_glue *glue;

	struct resource res[1];

	unsigned long irqflags;

	mmc_pm_flag_t mmcflags;

	int ret = -ENOMEM;
@@ -251,20 +199,7 @@ static int __devinit wl1271_probe(struct sdio_func *func, 
		goto out;

	}



	hw = wl1271_alloc_hw();

	if (IS_ERR(hw)) {

		wl1271_error("can't allocate hw");

		ret = PTR_ERR(hw);

		goto out_free_glue;

	}



	wl = hw->priv;



	glue->dev = &func->dev;

	glue->wl = wl;



	wl->if_priv = glue;

	wl->if_ops = &sdio_ops;



	/* Grab access to FN0 for ELP reg. */

	func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
@@ -276,48 +211,17 @@ static int __devinit wl1271_probe(struct sdio_func *func, 
	if (IS_ERR(wlan_data)) {

		ret = PTR_ERR(wlan_data);

		wl1271_error("missing wlan platform data: %d", ret);

		goto out_free_hw;

	}



	wl->irq = wlan_data->irq;

	wl->ref_clock = wlan_data->board_ref_clock;

	wl->tcxo_clock = wlan_data->board_tcxo_clock;

	wl->platform_quirks = wlan_data->platform_quirks;



	if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)

		irqflags = IRQF_TRIGGER_RISING;

	else

		irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;



	ret = request_threaded_irq(wl->irq, wl1271_hardirq, wl1271_irq,

				   irqflags,

				   DRIVER_NAME, wl);

	if (ret < 0) {

		wl1271_error("request_irq() failed: %d", ret);

		goto out_free_hw;

		goto out_free_glue;

	}



	ret = enable_irq_wake(wl->irq);

	if (!ret) {

		wl->irq_wake_enabled = true;

		device_init_wakeup(wl1271_sdio_wl_to_dev(wl), 1);



	/* if sdio can keep power while host is suspended, enable wow */

	mmcflags = sdio_get_host_pm_caps(func);

	wl1271_debug(DEBUG_SDIO, "sdio PM caps = 0x%x", mmcflags);



	if (mmcflags & MMC_PM_KEEP_POWER)

			hw->wiphy->wowlan.flags = WIPHY_WOWLAN_ANY;

	}

	disable_irq(wl->irq);



	ret = wl1271_init_ieee80211(wl);

	if (ret)

		goto out_irq;

		wlan_data->pwr_in_suspend = true;



	ret = wl1271_register_hw(wl);

	if (ret)

		goto out_irq;

	wlan_data->ops = &sdio_ops;



	sdio_set_drvdata(func, glue);
@@ -328,7 +232,7 @@ static int __devinit wl1271_probe(struct sdio_func *func, 
	if (!glue->core) {

		wl1271_error("can't allocate platform_device");

		ret = -ENOMEM;

		goto out_unreg_hw;

		goto out_free_glue;

	}



	glue->core->dev.parent = &func->dev;
@@ -362,17 +266,9 @@ static int __devinit wl1271_probe(struct sdio_func *func, 
out_dev_put:

	platform_device_put(glue->core);



out_unreg_hw:

	wl1271_unregister_hw(wl);



out_irq:

	free_irq(wl->irq, wl);



out_free_hw:

	wl1271_free_hw(wl);



out_free_glue:

	kfree(glue);



out:

	return ret;

}
@@ -380,18 +276,10 @@ out: 
static void __devexit wl1271_remove(struct sdio_func *func)

{

	struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func);

	struct wl1271 *wl = glue->wl;



	/* Undo decrement done above in wl1271_probe */

	pm_runtime_get_noresume(&func->dev);



	wl1271_unregister_hw(wl);

	if (wl->irq_wake_enabled) {

		device_init_wakeup(wl1271_sdio_wl_to_dev(wl), 0);

		disable_irq_wake(wl->irq);

	}

	free_irq(wl->irq, wl);

	wl1271_free_hw(wl);

	platform_device_del(glue->core);

	platform_device_put(glue->core);

	kfree(glue);

drivers/net/wireless/wl12xx/spi.c

+22 −139
Original line number Diff line number Diff line
@@ -72,33 +72,12 @@ 


struct wl12xx_spi_glue {

	struct device *dev;

	struct wl1271 *wl;

	struct platform_device *core;

};



static inline struct wl12xx_spi_glue *wl_to_glue(struct wl1271 *wl)

static void wl12xx_spi_reset(struct device *child)

{

	return wl->if_priv;

}



static struct device *wl1271_spi_wl_to_dev(struct wl1271 *wl)

{

	return wl_to_glue(wl)->dev;

}



static void wl1271_spi_disable_interrupts(struct wl1271 *wl)

{

	disable_irq(wl->irq);

}



static void wl1271_spi_enable_interrupts(struct wl1271 *wl)

{

	enable_irq(wl->irq);

}



static void wl1271_spi_reset(struct wl1271 *wl)

{

	struct wl12xx_spi_glue *glue = wl_to_glue(wl);

	struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);

	u8 *cmd;

	struct spi_transfer t;

	struct spi_message m;
@@ -124,9 +103,9 @@ static void wl1271_spi_reset(struct wl1271 *wl) 
	kfree(cmd);

}



static void wl1271_spi_init(struct wl1271 *wl)

static void wl12xx_spi_init(struct device *child)

{

	struct wl12xx_spi_glue *glue = wl_to_glue(wl);

	struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);

	u8 crc[WSPI_INIT_CMD_CRC_LEN], *cmd;

	struct spi_transfer t;

	struct spi_message m;
@@ -181,9 +160,10 @@ static void wl1271_spi_init(struct wl1271 *wl) 


#define WL1271_BUSY_WORD_TIMEOUT 1000



static int wl1271_spi_read_busy(struct wl1271 *wl)

static int wl12xx_spi_read_busy(struct device *child)

{

	struct wl12xx_spi_glue *glue = wl_to_glue(wl);

	struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);

	struct wl1271 *wl = dev_get_drvdata(child);

	struct spi_transfer t[1];

	struct spi_message m;

	u32 *busy_buf;
@@ -215,10 +195,11 @@ static int wl1271_spi_read_busy(struct wl1271 *wl) 
	return -ETIMEDOUT;

}



static void wl1271_spi_raw_read(struct wl1271 *wl, int addr, void *buf,

static void wl12xx_spi_raw_read(struct device *child, int addr, void *buf,

				size_t len, bool fixed)

{

	struct wl12xx_spi_glue *glue = wl_to_glue(wl);

	struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);

	struct wl1271 *wl = dev_get_drvdata(child);

	struct spi_transfer t[2];

	struct spi_message m;

	u32 *busy_buf;
@@ -257,7 +238,7 @@ static void wl1271_spi_raw_read(struct wl1271 *wl, int addr, void *buf, 
		spi_sync(to_spi_device(glue->dev), &m);



		if (!(busy_buf[WL1271_BUSY_WORD_CNT - 1] & 0x1) &&

		    wl1271_spi_read_busy(wl)) {

		    wl12xx_spi_read_busy(child)) {

			memset(buf, 0, chunk_len);

			return;

		}
@@ -282,10 +263,10 @@ static void wl1271_spi_raw_read(struct wl1271 *wl, int addr, void *buf, 
	}

}



static void wl1271_spi_raw_write(struct wl1271 *wl, int addr, void *buf,

static void wl12xx_spi_raw_write(struct device *child, int addr, void *buf,

				 size_t len, bool fixed)

{

	struct wl12xx_spi_glue *glue = wl_to_glue(wl);

	struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent);

	struct spi_transfer t[2 * WSPI_MAX_NUM_OF_CHUNKS];

	struct spi_message m;

	u32 commands[WSPI_MAX_NUM_OF_CHUNKS];
@@ -333,42 +314,11 @@ static void wl1271_spi_raw_write(struct wl1271 *wl, int addr, void *buf, 
	spi_sync(to_spi_device(glue->dev), &m);

}



static irqreturn_t wl1271_hardirq(int irq, void *cookie)

{

	struct wl1271 *wl = cookie;

	unsigned long flags;



	wl1271_debug(DEBUG_IRQ, "IRQ");



	/* complete the ELP completion */

	spin_lock_irqsave(&wl->wl_lock, flags);

	set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);

	if (wl->elp_compl) {

		complete(wl->elp_compl);

		wl->elp_compl = NULL;

	}

	spin_unlock_irqrestore(&wl->wl_lock, flags);



	return IRQ_WAKE_THREAD;

}



static int wl1271_spi_set_power(struct wl1271 *wl, bool enable)

{

	if (wl->set_power)

		wl->set_power(enable);



	return 0;

}



static struct wl1271_if_operations spi_ops = {

	.read		= wl1271_spi_raw_read,

	.write		= wl1271_spi_raw_write,

	.reset		= wl1271_spi_reset,

	.init		= wl1271_spi_init,

	.power		= wl1271_spi_set_power,

	.dev		= wl1271_spi_wl_to_dev,

	.enable_irq	= wl1271_spi_enable_interrupts,

	.disable_irq	= wl1271_spi_disable_interrupts,

	.read		= wl12xx_spi_raw_read,

	.write		= wl12xx_spi_raw_write,

	.reset		= wl12xx_spi_reset,

	.init		= wl12xx_spi_init,

	.set_block_size = NULL,

};
@@ -376,10 +326,7 @@ static int __devinit wl1271_probe(struct spi_device *spi) 
{

	struct wl12xx_spi_glue *glue;

	struct wl12xx_platform_data *pdata;

	struct ieee80211_hw *hw;

	struct wl1271 *wl;

	struct resource res[1];

	unsigned long irqflags;

	int ret = -ENOMEM;



	pdata = spi->dev.platform_data;
@@ -388,27 +335,17 @@ static int __devinit wl1271_probe(struct spi_device *spi) 
		return -ENODEV;

	}



	pdata->ops = &spi_ops;



	glue = kzalloc(sizeof(*glue), GFP_KERNEL);

	if (!glue) {

		wl1271_error("can't allocate glue");

		goto out;

	}



	hw = wl1271_alloc_hw();

	if (IS_ERR(hw)) {

		ret = PTR_ERR(hw);

		goto out_free_glue;

	}



	wl = hw->priv;



	glue->dev = &spi->dev;

	glue->wl = wl;



	spi_set_drvdata(spi, glue);

	wl->if_priv = glue;



	wl->if_ops = &spi_ops;



	/* This is the only SPI value that we need to set here, the rest

	 * comes from the board-peripherals file */
@@ -417,55 +354,14 @@ static int __devinit wl1271_probe(struct spi_device *spi) 
	ret = spi_setup(spi);

	if (ret < 0) {

		wl1271_error("spi_setup failed");

		goto out_free_hw;

	}



	wl->set_power = pdata->set_power;

	if (!wl->set_power) {

		wl1271_error("set power function missing in platform data");

		ret = -ENODEV;

		goto out_free_hw;

	}



	wl->ref_clock = pdata->board_ref_clock;

	wl->tcxo_clock = pdata->board_tcxo_clock;

	wl->platform_quirks = pdata->platform_quirks;



	if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)

		irqflags = IRQF_TRIGGER_RISING;

	else

		irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;



	wl->irq = spi->irq;

	if (wl->irq < 0) {

		wl1271_error("irq missing in platform data");

		ret = -ENODEV;

		goto out_free_hw;

	}



	ret = request_threaded_irq(wl->irq, wl1271_hardirq, wl1271_irq,

				   irqflags,

				   DRIVER_NAME, wl);

	if (ret < 0) {

		wl1271_error("request_irq() failed: %d", ret);

		goto out_free_hw;

		goto out_free_glue;

	}



	disable_irq(wl->irq);



	ret = wl1271_init_ieee80211(wl);

	if (ret)

		goto out_irq;



	ret = wl1271_register_hw(wl);

	if (ret)

		goto out_irq;



	glue->core = platform_device_alloc("wl12xx-spi", -1);

	if (!glue->core) {

		wl1271_error("can't allocate platform_device");

		ret = -ENOMEM;

		goto out_unreg_hw;

		goto out_free_glue;

	}



	glue->core->dev.parent = &spi->dev;
@@ -499,15 +395,6 @@ static int __devinit wl1271_probe(struct spi_device *spi) 
out_dev_put:

	platform_device_put(glue->core);



out_unreg_hw:

	wl1271_unregister_hw(wl);



out_irq:

	free_irq(wl->irq, wl);



out_free_hw:

	wl1271_free_hw(wl);



out_free_glue:

	kfree(glue);

out:
@@ -517,11 +404,7 @@ out: 
static int __devexit wl1271_remove(struct spi_device *spi)

{

	struct wl12xx_spi_glue *glue = spi_get_drvdata(spi);

	struct wl1271 *wl = glue->wl;



	wl1271_unregister_hw(wl);

	free_irq(wl->irq, wl);

	wl1271_free_hw(wl);

	platform_device_del(glue->core);

	platform_device_put(glue->core);

	kfree(glue);