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/mod_devicetable.h>
  24 #include <linux/mmc/sdio_func.h>
  25 #include <linux/mmc/sdio_ids.h>
  26
  27 #include "wl1251.h"
  28
  29 #ifndef SDIO_VENDOR_ID_TI
  30 #define SDIO_VENDOR_ID_TI               0x104c
  31 #endif
  32
  33 #ifndef SDIO_DEVICE_ID_TI_WL1251
  34 #define SDIO_DEVICE_ID_TI_WL1251        0x9066
  35 #endif
  36
  37 static struct sdio_func *wl_to_func(struct wl1251 *wl)
  38 {
  39         return wl->if_priv;
  40 }
  41
  42 static void wl1251_sdio_interrupt(struct sdio_func *func)
  43 {
  44         struct wl1251 *wl = sdio_get_drvdata(func);
  45
  46         wl1251_debug(DEBUG_IRQ, "IRQ");
  47
  48         /* FIXME should be synchronous for sdio */
  49         ieee80211_queue_work(wl->hw, &wl->irq_work);
  50 }
  51
  52 static const struct sdio_device_id wl1251_devices[] = {
  53         { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1251) },
  54         {}
  55 };
  56 MODULE_DEVICE_TABLE(sdio, wl1251_devices);
  57
  58
  59 static void wl1251_sdio_read(struct wl1251 *wl, int addr,
  60                              void *buf, size_t len)
  61 {
  62         int ret;
  63         struct sdio_func *func = wl_to_func(wl);
  64
  65         sdio_claim_host(func);
  66         ret = sdio_memcpy_fromio(func, buf, addr, len);
  67         if (ret)
  68                 wl1251_error("sdio read failed (%d)", ret);
  69         sdio_release_host(func);
  70 }
  71
  72 static void wl1251_sdio_write(struct wl1251 *wl, int addr,
  73                               void *buf, size_t len)
  74 {
  75         int ret;
  76         struct sdio_func *func = wl_to_func(wl);
  77
  78         sdio_claim_host(func);
  79         ret = sdio_memcpy_toio(func, addr, buf, len);
  80         if (ret)
  81                 wl1251_error("sdio write failed (%d)", ret);
  82         sdio_release_host(func);
  83 }
  84
  85 static void wl1251_sdio_reset(struct wl1251 *wl)
  86 {
  87 }
  88
  89 static void wl1251_sdio_enable_irq(struct wl1251 *wl)
  90 {
  91         struct sdio_func *func = wl_to_func(wl);
  92
  93         sdio_claim_host(func);
  94         sdio_claim_irq(func, wl1251_sdio_interrupt);
  95         sdio_release_host(func);
  96 }
  97
  98 static void wl1251_sdio_disable_irq(struct wl1251 *wl)
  99 {
 100         struct sdio_func *func = wl_to_func(wl);
 101
 102         sdio_claim_host(func);
 103         sdio_release_irq(func);
 104         sdio_release_host(func);
 105 }
 106
 107 static void wl1251_sdio_set_power(bool enable)
 108 {
 109 }
 110
 111 static const struct wl1251_if_operations wl1251_sdio_ops = {
 112         .read = wl1251_sdio_read,
 113         .write = wl1251_sdio_write,
 114         .reset = wl1251_sdio_reset,
 115         .enable_irq = wl1251_sdio_enable_irq,
 116         .disable_irq = wl1251_sdio_disable_irq,
 117 };
 118
 119 static int wl1251_sdio_probe(struct sdio_func *func,
 120                              const struct sdio_device_id *id)
 121 {
 122         int ret;
 123         struct wl1251 *wl;
 124         struct ieee80211_hw *hw;
 125
 126         hw = wl1251_alloc_hw();
 127         if (IS_ERR(hw))
 128                 return PTR_ERR(hw);
 129
 130         wl = hw->priv;
 131
 132         sdio_claim_host(func);
 133         ret = sdio_enable_func(func);
 134         if (ret)
 135                 goto release;
 136
 137         sdio_set_block_size(func, 512);
 138
 139         SET_IEEE80211_DEV(hw, &func->dev);
 140         wl->if_priv = func;
 141         wl->if_ops = &wl1251_sdio_ops;
 142         wl->set_power = wl1251_sdio_set_power;
 143
 144         sdio_release_host(func);
 145         ret = wl1251_init_ieee80211(wl);
 146         if (ret)
 147                 goto disable;
 148
 149         sdio_set_drvdata(func, wl);
 150         return ret;
 151
 152 disable:
 153         sdio_claim_host(func);
 154         sdio_disable_func(func);
 155 release:
 156         sdio_release_host(func);
 157         return ret;
 158 }
 159
 160 static void __devexit wl1251_sdio_remove(struct sdio_func *func)
 161 {
 162         struct wl1251 *wl = sdio_get_drvdata(func);
 163
 164         wl1251_free_hw(wl);
 165
 166         sdio_claim_host(func);
 167         sdio_release_irq(func);
 168         sdio_disable_func(func);
 169         sdio_release_host(func);
 170 }
 171
 172 static struct sdio_driver wl1251_sdio_driver = {
 173         .name           = "wl1251_sdio",
 174         .id_table       = wl1251_devices,
 175         .probe          = wl1251_sdio_probe,
 176         .remove         = __devexit_p(wl1251_sdio_remove),
 177 };
 178
 179 static int __init wl1251_sdio_init(void)
 180 {
 181         int err;
 182
 183         err = sdio_register_driver(&wl1251_sdio_driver);
 184         if (err)
 185                 wl1251_error("failed to register sdio driver: %d", err);
 186         return err;
 187 }
 188
 189 static void __exit wl1251_sdio_exit(void)
 190 {
 191         sdio_unregister_driver(&wl1251_sdio_driver);
 192         wl1251_notice("unloaded");
 193 }
 194
 195 module_init(wl1251_sdio_init);
 196 module_exit(wl1251_sdio_exit);
 197
 198 MODULE_LICENSE("GPL");
 199 MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");