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 #include <linux/platform_device.h>
  27 #include <linux/spi/wl12xx.h>
  28
  29 #include "wl1251.h"
  30
  31 #ifndef SDIO_VENDOR_ID_TI
  32 #define SDIO_VENDOR_ID_TI               0x104c
  33 #endif
  34
  35 #ifndef SDIO_DEVICE_ID_TI_WL1251
  36 #define SDIO_DEVICE_ID_TI_WL1251        0x9066
  37 #endif
  38
  39 static struct wl12xx_platform_data *wl12xx_board_data;
  40
  41 static struct sdio_func *wl_to_func(struct wl1251 *wl)
  42 {
  43         return wl->if_priv;
  44 }
  45
  46 static void wl1251_sdio_interrupt(struct sdio_func *func)
  47 {
  48         struct wl1251 *wl = sdio_get_drvdata(func);
  49
  50         wl1251_debug(DEBUG_IRQ, "IRQ");
  51
  52         /* FIXME should be synchronous for sdio */
  53         ieee80211_queue_work(wl->hw, &wl->irq_work);
  54 }
  55
  56 static const struct sdio_device_id wl1251_devices[] = {
  57         { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1251) },
  58         {}
  59 };
  60 MODULE_DEVICE_TABLE(sdio, wl1251_devices);
  61
  62
  63 static void wl1251_sdio_read(struct wl1251 *wl, int addr,
  64                              void *buf, size_t len)
  65 {
  66         int ret;
  67         struct sdio_func *func = wl_to_func(wl);
  68
  69         sdio_claim_host(func);
  70         ret = sdio_memcpy_fromio(func, buf, addr, len);
  71         if (ret)
  72                 wl1251_error("sdio read failed (%d)", ret);
  73         sdio_release_host(func);
  74 }
  75
  76 static void wl1251_sdio_write(struct wl1251 *wl, int addr,
  77                               void *buf, size_t len)
  78 {
  79         int ret;
  80         struct sdio_func *func = wl_to_func(wl);
  81
  82         sdio_claim_host(func);
  83         ret = sdio_memcpy_toio(func, addr, buf, len);
  84         if (ret)
  85                 wl1251_error("sdio write failed (%d)", ret);
  86         sdio_release_host(func);
  87 }
  88
  89 static void wl1251_sdio_read_elp(struct wl1251 *wl, int addr, u32 *val)
  90 {
  91         int ret = 0;
  92         struct sdio_func *func = wl_to_func(wl);
  93
  94         sdio_claim_host(func);
  95         *val = sdio_readb(func, addr, &ret);
  96         sdio_release_host(func);
  97
  98         if (ret)
  99                 wl1251_error("sdio_readb failed (%d)", ret);
 100 }
 101
 102 static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
 103 {
 104         int ret = 0;
 105         struct sdio_func *func = wl_to_func(wl);
 106
 107         sdio_claim_host(func);
 108         sdio_writeb(func, val, addr, &ret);
 109         sdio_release_host(func);
 110
 111         if (ret)
 112                 wl1251_error("sdio_writeb failed (%d)", ret);
 113 }
 114
 115 static void wl1251_sdio_reset(struct wl1251 *wl)
 116 {
 117 }
 118
 119 static void wl1251_sdio_enable_irq(struct wl1251 *wl)
 120 {
 121         struct sdio_func *func = wl_to_func(wl);
 122
 123         sdio_claim_host(func);
 124         sdio_claim_irq(func, wl1251_sdio_interrupt);
 125         sdio_release_host(func);
 126 }
 127
 128 static void wl1251_sdio_disable_irq(struct wl1251 *wl)
 129 {
 130         struct sdio_func *func = wl_to_func(wl);
 131
 132         sdio_claim_host(func);
 133         sdio_release_irq(func);
 134         sdio_release_host(func);
 135 }
 136
 137 static void wl1251_sdio_set_power(bool enable)
 138 {
 139 }
 140
 141 static const struct wl1251_if_operations wl1251_sdio_ops = {
 142         .read = wl1251_sdio_read,
 143         .write = wl1251_sdio_write,
 144         .write_elp = wl1251_sdio_write_elp,
 145         .read_elp = wl1251_sdio_read_elp,
 146         .reset = wl1251_sdio_reset,
 147         .enable_irq = wl1251_sdio_enable_irq,
 148         .disable_irq = wl1251_sdio_disable_irq,
 149 };
 150
 151 static int wl1251_platform_probe(struct platform_device *pdev)
 152 {
 153         if (pdev->id != -1) {
 154                 wl1251_error("can only handle single device");
 155                 return -ENODEV;
 156         }
 157
 158         wl12xx_board_data = pdev->dev.platform_data;
 159         return 0;
 160 }
 161
 162 /*
 163  * Dummy platform_driver for passing platform_data to this driver,
 164  * until we have a way to pass this through SDIO subsystem or
 165  * some other way.
 166  */
 167 static struct platform_driver wl1251_platform_driver = {
 168         .driver = {
 169                 .name   = "wl1251_data",
 170                 .owner  = THIS_MODULE,
 171         },
 172         .probe  = wl1251_platform_probe,
 173 };
 174
 175 static int wl1251_sdio_probe(struct sdio_func *func,
 176                              const struct sdio_device_id *id)
 177 {
 178         int ret;
 179         struct wl1251 *wl;
 180         struct ieee80211_hw *hw;
 181
 182         hw = wl1251_alloc_hw();
 183         if (IS_ERR(hw))
 184                 return PTR_ERR(hw);
 185
 186         wl = hw->priv;
 187
 188         sdio_claim_host(func);
 189         ret = sdio_enable_func(func);
 190         if (ret)
 191                 goto release;
 192
 193         sdio_set_block_size(func, 512);
 194
 195         SET_IEEE80211_DEV(hw, &func->dev);
 196         wl->if_priv = func;
 197         wl->if_ops = &wl1251_sdio_ops;
 198         wl->set_power = wl1251_sdio_set_power;
 199
 200         if (wl12xx_board_data != NULL) {
 201                 wl->set_power = wl12xx_board_data->set_power;
 202                 wl->use_eeprom = wl12xx_board_data->use_eeprom;
 203         }
 204
 205         sdio_release_host(func);
 206         ret = wl1251_init_ieee80211(wl);
 207         if (ret)
 208                 goto disable;
 209
 210         sdio_set_drvdata(func, wl);
 211         return ret;
 212
 213 disable:
 214         sdio_claim_host(func);
 215         sdio_disable_func(func);
 216 release:
 217         sdio_release_host(func);
 218         return ret;
 219 }
 220
 221 static void __devexit wl1251_sdio_remove(struct sdio_func *func)
 222 {
 223         struct wl1251 *wl = sdio_get_drvdata(func);
 224
 225         wl1251_free_hw(wl);
 226
 227         sdio_claim_host(func);
 228         sdio_release_irq(func);
 229         sdio_disable_func(func);
 230         sdio_release_host(func);
 231 }
 232
 233 static struct sdio_driver wl1251_sdio_driver = {
 234         .name           = "wl1251_sdio",
 235         .id_table       = wl1251_devices,
 236         .probe          = wl1251_sdio_probe,
 237         .remove         = __devexit_p(wl1251_sdio_remove),
 238 };
 239
 240 static int __init wl1251_sdio_init(void)
 241 {
 242         int err;
 243
 244         err = platform_driver_register(&wl1251_platform_driver);
 245         if (err) {
 246                 wl1251_error("failed to register platform driver: %d", err);
 247                 return err;
 248         }
 249
 250         err = sdio_register_driver(&wl1251_sdio_driver);
 251         if (err)
 252                 wl1251_error("failed to register sdio driver: %d", err);
 253         return err;
 254 }
 255
 256 static void __exit wl1251_sdio_exit(void)
 257 {
 258         sdio_unregister_driver(&wl1251_sdio_driver);
 259         platform_driver_unregister(&wl1251_platform_driver);
 260         wl1251_notice("unloaded");
 261 }
 262
 263 module_init(wl1251_sdio_init);
 264 module_exit(wl1251_sdio_exit);
 265
 266 MODULE_LICENSE("GPL");
 267 MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");