wl1251: fix ELP_CTRL register reads

[pandora-wifi.git] / drivers / net / wireless / wl12xx / wl1251_sdio.c

diff --git a/drivers/net/wireless/wl12xx/wl1251_sdio.c b/drivers/net/wireless/wl12xx/wl1251_sdio.c
index 7409c34..0228e97 100644 (file)
--- a/drivers/net/wireless/wl12xx/wl1251_sdio.c
+++ b/drivers/net/wireless/wl12xx/wl1251_sdio.c
@@ -25,6 +25,7 @@
 #include <linux/mmc/sdio_ids.h>
 #include <linux/platform_device.h>
 #include <linux/spi/wl12xx.h>
 #include <linux/mmc/sdio_ids.h>
 #include <linux/platform_device.h>
 #include <linux/spi/wl12xx.h>

+#include <linux/irq.h>

 
 #include "wl1251.h"
 
 
 #include "wl1251.h"
 


@@ -36,11 +37,17 @@
 #define SDIO_DEVICE_ID_TI_WL1251       0x9066
 #endif
 
 #define SDIO_DEVICE_ID_TI_WL1251       0x9066
 #endif
 

+struct wl1251_sdio {
+       struct sdio_func *func;
+       u32 elp_val;
+};
+

 static struct wl12xx_platform_data *wl12xx_board_data;
 
 static struct sdio_func *wl_to_func(struct wl1251 *wl)
 {
 static struct wl12xx_platform_data *wl12xx_board_data;
 
 static struct sdio_func *wl_to_func(struct wl1251 *wl)
 {

-       return wl->if_priv;
+       struct wl1251_sdio *wl_sdio = wl->if_priv;
+       return wl_sdio->func;

 }
 
 static void wl1251_sdio_interrupt(struct sdio_func *func)
 }
 
 static void wl1251_sdio_interrupt(struct sdio_func *func)


@@ -89,10 +96,17 @@ static void wl1251_sdio_write(struct wl1251 *wl, int addr,
 static void wl1251_sdio_read_elp(struct wl1251 *wl, int addr, u32 *val)
 {
        int ret = 0;
 static void wl1251_sdio_read_elp(struct wl1251 *wl, int addr, u32 *val)
 {
        int ret = 0;

-       struct sdio_func *func = wl_to_func(wl);
-
+       struct wl1251_sdio *wl_sdio = wl->if_priv;
+       struct sdio_func *func = wl_sdio->func;
+
+       /*
+        * The hardware only supports RAW (read after write) access for
+        * reading, regular sdio_readb won't work here (it interprets
+        * the unused bits of CMD52 as write data even if we send read
+        * request).
+        */

        sdio_claim_host(func);
        sdio_claim_host(func);

-       *val = sdio_readb(func, addr, &ret);
+       *val = sdio_readb_ext(func, addr, &ret, wl_sdio->elp_val);

        sdio_release_host(func);
 
        if (ret)
        sdio_release_host(func);
 
        if (ret)


@@ -102,7 +116,8 @@ static void wl1251_sdio_read_elp(struct wl1251 *wl, int addr, u32 *val)
 static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
 {
        int ret = 0;
 static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
 {
        int ret = 0;

-       struct sdio_func *func = wl_to_func(wl);
+       struct wl1251_sdio *wl_sdio = wl->if_priv;
+       struct sdio_func *func = wl_sdio->func;

 
        sdio_claim_host(func);
        sdio_writeb(func, val, addr, &ret);
 
        sdio_claim_host(func);
        sdio_writeb(func, val, addr, &ret);


@@ -110,10 +125,26 @@ static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
 
        if (ret)
                wl1251_error("sdio_writeb failed (%d)", ret);
 
        if (ret)
                wl1251_error("sdio_writeb failed (%d)", ret);

+       else
+               wl_sdio->elp_val = val;

 }
 
 static void wl1251_sdio_reset(struct wl1251 *wl)
 {
 }
 
 static void wl1251_sdio_reset(struct wl1251 *wl)
 {

+       extern int sdio_reset_comm(struct mmc_card *card);
+       struct sdio_func *func = wl_to_func(wl);
+       int ret;
+
+       sdio_claim_host(func);
+       sdio_reset_comm(func->card);
+       ret = sdio_enable_func(func);
+       if (ret)
+               goto release;
+
+       sdio_set_block_size(func, 512);
+
+release:
+       sdio_release_host(func);

 }
 
 static void wl1251_sdio_enable_irq(struct wl1251 *wl)
 }
 
 static void wl1251_sdio_enable_irq(struct wl1251 *wl)


@@ -134,18 +165,36 @@ static void wl1251_sdio_disable_irq(struct wl1251 *wl)
        sdio_release_host(func);
 }
 
        sdio_release_host(func);
 }
 

+/* Interrupts when using dedicated WLAN_IRQ pin */
+static irqreturn_t wl1251_line_irq(int irq, void *cookie)
+{
+       struct wl1251 *wl = cookie;
+
+       ieee80211_queue_work(wl->hw, &wl->irq_work);
+
+       return IRQ_HANDLED;
+}
+
+static void wl1251_enable_line_irq(struct wl1251 *wl)
+{
+       return enable_irq(wl->irq);
+}
+
+static void wl1251_disable_line_irq(struct wl1251 *wl)
+{
+       return disable_irq(wl->irq);
+}
+

 static void wl1251_sdio_set_power(bool enable)
 {
 }
 
 static void wl1251_sdio_set_power(bool enable)
 {
 }
 

-static const struct wl1251_if_operations wl1251_sdio_ops = {
+static struct wl1251_if_operations wl1251_sdio_ops = {

        .read = wl1251_sdio_read,
        .write = wl1251_sdio_write,
        .write_elp = wl1251_sdio_write_elp,
        .read_elp = wl1251_sdio_read_elp,
        .reset = wl1251_sdio_reset,
        .read = wl1251_sdio_read,
        .write = wl1251_sdio_write,
        .write_elp = wl1251_sdio_write_elp,
        .read_elp = wl1251_sdio_read_elp,
        .reset = wl1251_sdio_reset,

-       .enable_irq = wl1251_sdio_enable_irq,
-       .disable_irq = wl1251_sdio_disable_irq,

 };
 
 static int wl1251_platform_probe(struct platform_device *pdev)
 };
 
 static int wl1251_platform_probe(struct platform_device *pdev)


@@ -178,6 +227,7 @@ static int wl1251_sdio_probe(struct sdio_func *func,
        int ret;
        struct wl1251 *wl;
        struct ieee80211_hw *hw;
        int ret;
        struct wl1251 *wl;
        struct ieee80211_hw *hw;

+       struct wl1251_sdio *wl_sdio;

 
        hw = wl1251_alloc_hw();
        if (IS_ERR(hw))
 
        hw = wl1251_alloc_hw();
        if (IS_ERR(hw))


@@ -185,43 +235,85 @@ static int wl1251_sdio_probe(struct sdio_func *func,
 
        wl = hw->priv;
 
 
        wl = hw->priv;
 

+       wl_sdio = kzalloc(sizeof(*wl_sdio), GFP_KERNEL);
+       if (wl_sdio == NULL) {
+               ret = -ENOMEM;
+               goto out_free_hw;
+       }
+

        sdio_claim_host(func);
        ret = sdio_enable_func(func);
        if (ret)
                goto release;
 
        sdio_set_block_size(func, 512);
        sdio_claim_host(func);
        ret = sdio_enable_func(func);
        if (ret)
                goto release;
 
        sdio_set_block_size(func, 512);

+       sdio_release_host(func);

 
        SET_IEEE80211_DEV(hw, &func->dev);
 
        SET_IEEE80211_DEV(hw, &func->dev);

-       wl->if_priv = func;
+       wl_sdio->func = func;
+       wl->if_priv = wl_sdio;

        wl->if_ops = &wl1251_sdio_ops;
        wl->set_power = wl1251_sdio_set_power;
 
        if (wl12xx_board_data != NULL) {
                wl->set_power = wl12xx_board_data->set_power;
        wl->if_ops = &wl1251_sdio_ops;
        wl->set_power = wl1251_sdio_set_power;
 
        if (wl12xx_board_data != NULL) {
                wl->set_power = wl12xx_board_data->set_power;

+               wl->irq = wl12xx_board_data->irq;

                wl->use_eeprom = wl12xx_board_data->use_eeprom;
        }
 
                wl->use_eeprom = wl12xx_board_data->use_eeprom;
        }
 

-       sdio_release_host(func);
+       if (wl->irq) {
+               ret = request_irq(wl->irq, wl1251_line_irq, 0, "wl1251", wl);
+               if (ret < 0) {
+                       wl1251_error("request_irq() failed: %d", ret);
+                       goto disable;
+               }
+
+               set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
+               disable_irq(wl->irq);
+
+               wl1251_sdio_ops.enable_irq = wl1251_enable_line_irq;
+               wl1251_sdio_ops.disable_irq = wl1251_disable_line_irq;
+
+               wl1251_info("using dedicated interrupt line");
+       } else {
+               wl1251_sdio_ops.enable_irq = wl1251_sdio_enable_irq;
+               wl1251_sdio_ops.disable_irq = wl1251_sdio_disable_irq;
+
+               wl1251_info("using SDIO interrupt");
+       }
+

        ret = wl1251_init_ieee80211(wl);
        if (ret)
        ret = wl1251_init_ieee80211(wl);
        if (ret)

-               goto disable;
+               goto out_free_irq;
+
+       /* we can power it down now until it's started */
+       wl->set_power(0);

 
        sdio_set_drvdata(func, wl);
        return ret;
 
 
        sdio_set_drvdata(func, wl);
        return ret;
 

+out_free_irq:
+       if (wl->irq)
+               free_irq(wl->irq, wl);

 disable:
        sdio_claim_host(func);
        sdio_disable_func(func);
 release:
        sdio_release_host(func);
 disable:
        sdio_claim_host(func);
        sdio_disable_func(func);
 release:
        sdio_release_host(func);

+       kfree(wl_sdio);
+out_free_hw:
+       wl1251_free_hw(wl);

        return ret;
 }
 
 static void __devexit wl1251_sdio_remove(struct sdio_func *func)
 {
        struct wl1251 *wl = sdio_get_drvdata(func);
        return ret;
 }
 
 static void __devexit wl1251_sdio_remove(struct sdio_func *func)
 {
        struct wl1251 *wl = sdio_get_drvdata(func);

+       struct wl1251_sdio *wl_sdio = wl->if_priv;

 
 

+       if (wl->irq)
+               free_irq(wl->irq, wl);
+       kfree(wl_sdio);

        wl1251_free_hw(wl);
 
        sdio_claim_host(func);
        wl1251_free_hw(wl);
 
        sdio_claim_host(func);