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_read_elp(struct wl1251 *wl, int addr, u32 *val)
  86 {
  87         int ret = 0;
  88         struct sdio_func *func = wl_to_func(wl);
  89
  90         sdio_claim_host(func);
  91         *val = sdio_readb(func, addr, &ret);
  92         sdio_release_host(func);
  93
  94         if (ret)
  95                 wl1251_error("sdio_readb failed (%d)", ret);
  96 }
  97
  98 static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
  99 {
 100         int ret = 0;
 101         struct sdio_func *func = wl_to_func(wl);
 102
 103         sdio_claim_host(func);
 104         sdio_writeb(func, val, addr, &ret);
 105         sdio_release_host(func);
 106
 107         if (ret)
 108                 wl1251_error("sdio_writeb failed (%d)", ret);
 109 }
 110
 111 static void wl1251_sdio_reset(struct wl1251 *wl)
 112 {
 113 }
 114
 115 static void wl1251_sdio_enable_irq(struct wl1251 *wl)
 116 {
 117         struct sdio_func *func = wl_to_func(wl);
 118
 119         sdio_claim_host(func);
 120         sdio_claim_irq(func, wl1251_sdio_interrupt);
 121         sdio_release_host(func);
 122 }
 123
 124 static void wl1251_sdio_disable_irq(struct wl1251 *wl)
 125 {
 126         struct sdio_func *func = wl_to_func(wl);
 127
 128         sdio_claim_host(func);
 129         sdio_release_irq(func);
 130         sdio_release_host(func);
 131 }
 132
 133 static void wl1251_sdio_set_power(bool enable)
 134 {
 135 }
 136
 137 static const struct wl1251_if_operations wl1251_sdio_ops = {
 138         .read = wl1251_sdio_read,
 139         .write = wl1251_sdio_write,
 140         .write_elp = wl1251_sdio_write_elp,
 141         .read_elp = wl1251_sdio_read_elp,
 142         .reset = wl1251_sdio_reset,
 143         .enable_irq = wl1251_sdio_enable_irq,
 144         .disable_irq = wl1251_sdio_disable_irq,
 145 };
 146
 147 static int wl1251_sdio_probe(struct sdio_func *func,
 148                              const struct sdio_device_id *id)
 149 {
 150         int ret;
 151         struct wl1251 *wl;
 152         struct ieee80211_hw *hw;
 153
 154         hw = wl1251_alloc_hw();
 155         if (IS_ERR(hw))
 156                 return PTR_ERR(hw);
 157
 158         wl = hw->priv;
 159
 160         sdio_claim_host(func);
 161         ret = sdio_enable_func(func);
 162         if (ret)
 163                 goto release;
 164
 165         sdio_set_block_size(func, 512);
 166
 167         SET_IEEE80211_DEV(hw, &func->dev);
 168         wl->if_priv = func;
 169         wl->if_ops = &wl1251_sdio_ops;
 170         wl->set_power = wl1251_sdio_set_power;
 171
 172         sdio_release_host(func);
 173         ret = wl1251_init_ieee80211(wl);
 174         if (ret)
 175                 goto disable;
 176
 177         sdio_set_drvdata(func, wl);
 178         return ret;
 179
 180 disable:
 181         sdio_claim_host(func);
 182         sdio_disable_func(func);
 183 release:
 184         sdio_release_host(func);
 185         return ret;
 186 }
 187
 188 static void __devexit wl1251_sdio_remove(struct sdio_func *func)
 189 {
 190         struct wl1251 *wl = sdio_get_drvdata(func);
 191
 192         wl1251_free_hw(wl);
 193
 194         sdio_claim_host(func);
 195         sdio_release_irq(func);
 196         sdio_disable_func(func);
 197         sdio_release_host(func);
 198 }
 199
 200 static struct sdio_driver wl1251_sdio_driver = {
 201         .name           = "wl1251_sdio",
 202         .id_table       = wl1251_devices,
 203         .probe          = wl1251_sdio_probe,
 204         .remove         = __devexit_p(wl1251_sdio_remove),
 205 };
 206
 207 static int __init wl1251_sdio_init(void)
 208 {
 209         int err;
 210
 211         err = sdio_register_driver(&wl1251_sdio_driver);
 212         if (err)
 213                 wl1251_error("failed to register sdio driver: %d", err);
 214         return err;
 215 }
 216
 217 static void __exit wl1251_sdio_exit(void)
 218 {
 219         sdio_unregister_driver(&wl1251_sdio_driver);
 220         wl1251_notice("unloaded");
 221 }
 222
 223 module_init(wl1251_sdio_init);
 224 module_exit(wl1251_sdio_exit);
 225
 226 MODULE_LICENSE("GPL");
 227 MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");