drivers/net/wireless/wl12xx/wl1251_sdio.c

   1 /*
   2  * wl12xx SDIO routines
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  16  * 02110-1301 USA
  17  *
  18  * Copyright (C) 2005 Texas Instruments Incorporated
  19  * Copyright (C) 2008 Google Inc
  20  * Copyright (C) 2009 Bob Copeland (me@bobcopeland.com)
  21  */
  22 #include <linux/module.h>
  23 #include <linux/crc7.h>
  24 #include <linux/mod_devicetable.h>
  25 #include <linux/irq.h>
  26 #include <linux/mmc/sdio_func.h>
  27 #include <linux/mmc/sdio_ids.h>
  28 #include <linux/platform_device.h>
  29
  30 #include "wl1251.h"
  31 #include "wl12xx_80211.h"
  32 #include "wl1251_reg.h"
  33 #include "wl1251_ps.h"
  34 #include "wl1251_io.h"
  35 #include "wl1251_tx.h"
  36 #include "wl1251_debugfs.h"
  37
  38 #ifndef SDIO_VENDOR_ID_TI
  39 #define SDIO_VENDOR_ID_TI               0x104c
  40 #endif
  41
  42 #ifndef SDIO_DEVICE_ID_TI_WL1251
  43 #define SDIO_DEVICE_ID_TI_WL1251        0x9066
  44 #endif
  45
  46 static struct sdio_func *wl_to_func(struct wl1251 *wl)
  47 {
  48         return wl->if_priv;
  49 }
  50
  51 static void wl1251_sdio_interrupt(struct sdio_func *func)
  52 {
  53         struct wl1251 *wl = sdio_get_drvdata(func);
  54
  55         wl1251_debug(DEBUG_IRQ, "IRQ");
  56
  57         /* FIXME should be synchronous for sdio */
  58         ieee80211_queue_work(wl->hw, &wl->irq_work);
  59 }
  60
  61 static const struct sdio_device_id wl1251_devices[] = {
  62         { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1251) },
  63         {}
  64 };
  65 MODULE_DEVICE_TABLE(sdio, wl1251_devices);
  66
  67
  68 void wl1251_sdio_read(struct wl1251 *wl, int addr, void *buf, size_t len)
  69 {
  70         int ret;
  71         struct sdio_func *func = wl_to_func(wl);
  72
  73         sdio_claim_host(func);
  74         ret = sdio_memcpy_fromio(func, buf, addr, len);
  75         if (ret)
  76                 wl1251_error("sdio read failed (%d)", ret);
  77         sdio_release_host(func);
  78 }
  79
  80 void wl1251_sdio_write(struct wl1251 *wl, int addr, void *buf, size_t len)
  81 {
  82         int ret;
  83         struct sdio_func *func = wl_to_func(wl);
  84
  85         sdio_claim_host(func);
  86         ret = sdio_memcpy_toio(func, addr, buf, len);
  87         if (ret)
  88                 wl1251_error("sdio write failed (%d)", ret);
  89         sdio_release_host(func);
  90 }
  91
  92 void wl1251_sdio_reset(struct wl1251 *wl)
  93 {
  94 }
  95
  96 static void wl1251_sdio_enable_irq(struct wl1251 *wl)
  97 {
  98         struct sdio_func *func = wl_to_func(wl);
  99
 100         sdio_claim_host(func);
 101         sdio_claim_irq(func, wl1251_sdio_interrupt);
 102         sdio_release_host(func);
 103 }
 104
 105 static void wl1251_sdio_disable_irq(struct wl1251 *wl)
 106 {
 107         struct sdio_func *func = wl_to_func(wl);
 108
 109         sdio_claim_host(func);
 110         sdio_release_irq(func);
 111         sdio_release_host(func);
 112 }
 113
 114 void wl1251_sdio_set_power(bool enable)
 115 {
 116 }
 117
 118 struct wl1251_if_operations wl1251_sdio_ops = {
 119         .read = wl1251_sdio_read,
 120         .write = wl1251_sdio_write,
 121         .reset = wl1251_sdio_reset,
 122         .enable_irq = wl1251_sdio_enable_irq,
 123         .disable_irq = wl1251_sdio_disable_irq,
 124 };
 125
 126 int wl1251_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id)
 127 {
 128         int ret;
 129         struct wl1251 *wl;
 130         struct ieee80211_hw *hw;
 131
 132         hw = wl1251_alloc_hw();
 133         if (IS_ERR(hw))
 134                 return PTR_ERR(hw);
 135
 136         wl = hw->priv;
 137
 138         sdio_claim_host(func);
 139         ret = sdio_enable_func(func);
 140         if (ret)
 141                 goto release;
 142
 143         sdio_set_block_size(func, 512);
 144
 145         SET_IEEE80211_DEV(hw, &func->dev);
 146         wl->if_priv = func;
 147         wl->if_ops = &wl1251_sdio_ops;
 148         wl->set_power = wl1251_sdio_set_power;
 149
 150         sdio_release_host(func);
 151         ret = wl1251_init_ieee80211(wl);
 152         if (ret)
 153                 goto disable;
 154
 155         sdio_set_drvdata(func, wl);
 156         return ret;
 157
 158 disable:
 159         sdio_claim_host(func);
 160         sdio_disable_func(func);
 161 release:
 162         sdio_release_host(func);
 163         return ret;
 164 }
 165
 166 static void __devexit wl1251_sdio_remove(struct sdio_func *func)
 167 {
 168         struct wl1251 *wl = sdio_get_drvdata(func);
 169
 170         wl1251_free_hw(wl);
 171
 172         sdio_claim_host(func);
 173         sdio_release_irq(func);
 174         sdio_disable_func(func);
 175         sdio_release_host(func);
 176 }
 177
 178 static struct sdio_driver wl1251_sdio_driver = {
 179         .name           = "wl1251_sdio",
 180         .id_table       = wl1251_devices,
 181         .probe          = wl1251_sdio_probe,
 182         .remove         = __devexit_p(wl1251_sdio_remove),
 183 };
 184
 185 static int __init wl1251_sdio_init(void)
 186 {
 187         int err;
 188
 189         err = sdio_register_driver(&wl1251_sdio_driver);
 190         if (err)
 191                 wl1251_error("failed to register sdio driver: %d", err);
 192         return err;
 193 }
 194
 195 static void __exit wl1251_sdio_exit(void)
 196 {
 197         sdio_unregister_driver(&wl1251_sdio_driver);
 198         wl1251_notice("unloaded");
 199 }
 200
 201 module_init(wl1251_sdio_init);
 202 module_exit(wl1251_sdio_exit);
 203
 204 MODULE_LICENSE("GPL");
 205 MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");