drivers/net/wireless/ti/wl1251/sdio.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * wl12xx SDIO routines
   4  *
   5  * Copyright (C) 2005 Texas Instruments Incorporated
   6  * Copyright (C) 2008 Google Inc
   7  * Copyright (C) 2009 Bob Copeland (me@bobcopeland.com)
   8  */
   9 #include <linux/interrupt.h>
  10 #include <linux/module.h>
  11 #include <linux/mod_devicetable.h>
  12 #include <linux/mmc/sdio_func.h>
  13 #include <linux/mmc/sdio_ids.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/wl12xx.h>
  16 #include <linux/irq.h>
  17 #include <linux/pm_runtime.h>
  18 #include <linux/of.h>
  19 #include <linux/of_irq.h>
  20
  21 #include "wl1251.h"
  22
  23 struct wl1251_sdio {
  24         struct sdio_func *func;
  25         u32 elp_val;
  26 };
  27
  28 static struct sdio_func *wl_to_func(struct wl1251 *wl)
  29 {
  30         struct wl1251_sdio *wl_sdio = wl->if_priv;
  31         return wl_sdio->func;
  32 }
  33
  34 static void wl1251_sdio_interrupt(struct sdio_func *func)
  35 {
  36         struct wl1251 *wl = sdio_get_drvdata(func);
  37
  38         wl1251_debug(DEBUG_IRQ, "IRQ");
  39
  40         /* FIXME should be synchronous for sdio */
  41         ieee80211_queue_work(wl->hw, &wl->irq_work);
  42 }
  43
  44 static const struct sdio_device_id wl1251_devices[] = {
  45         { SDIO_DEVICE(SDIO_VENDOR_ID_TI_WL1251, SDIO_DEVICE_ID_TI_WL1251) },
  46         {}
  47 };
  48 MODULE_DEVICE_TABLE(sdio, wl1251_devices);
  49
  50
  51 static void wl1251_sdio_read(struct wl1251 *wl, int addr,
  52                              void *buf, size_t len)
  53 {
  54         int ret;
  55         struct sdio_func *func = wl_to_func(wl);
  56
  57         sdio_claim_host(func);
  58         ret = sdio_memcpy_fromio(func, buf, addr, len);
  59         if (ret)
  60                 wl1251_error("sdio read failed (%d)", ret);
  61         sdio_release_host(func);
  62 }
  63
  64 static void wl1251_sdio_write(struct wl1251 *wl, int addr,
  65                               void *buf, size_t len)
  66 {
  67         int ret;
  68         struct sdio_func *func = wl_to_func(wl);
  69
  70         sdio_claim_host(func);
  71         ret = sdio_memcpy_toio(func, addr, buf, len);
  72         if (ret)
  73                 wl1251_error("sdio write failed (%d)", ret);
  74         sdio_release_host(func);
  75 }
  76
  77 static void wl1251_sdio_read_elp(struct wl1251 *wl, int addr, u32 *val)
  78 {
  79         int ret = 0;
  80         struct wl1251_sdio *wl_sdio = wl->if_priv;
  81         struct sdio_func *func = wl_sdio->func;
  82
  83         /*
  84          * The hardware only supports RAW (read after write) access for
  85          * reading, regular sdio_readb won't work here (it interprets
  86          * the unused bits of CMD52 as write data even if we send read
  87          * request).
  88          */
  89         sdio_claim_host(func);
  90         *val = sdio_writeb_readb(func, wl_sdio->elp_val, addr, &ret);
  91         sdio_release_host(func);
  92
  93         if (ret)
  94                 wl1251_error("sdio_readb failed (%d)", ret);
  95 }
  96
  97 static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
  98 {
  99         int ret = 0;
 100         struct wl1251_sdio *wl_sdio = wl->if_priv;
 101         struct sdio_func *func = wl_sdio->func;
 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         else
 110                 wl_sdio->elp_val = val;
 111 }
 112
 113 static void wl1251_sdio_reset(struct wl1251 *wl)
 114 {
 115 }
 116
 117 static void wl1251_sdio_enable_irq(struct wl1251 *wl)
 118 {
 119         struct sdio_func *func = wl_to_func(wl);
 120
 121         sdio_claim_host(func);
 122         sdio_claim_irq(func, wl1251_sdio_interrupt);
 123         sdio_release_host(func);
 124 }
 125
 126 static void wl1251_sdio_disable_irq(struct wl1251 *wl)
 127 {
 128         struct sdio_func *func = wl_to_func(wl);
 129
 130         sdio_claim_host(func);
 131         sdio_release_irq(func);
 132         sdio_release_host(func);
 133 }
 134
 135 /* Interrupts when using dedicated WLAN_IRQ pin */
 136 static irqreturn_t wl1251_line_irq(int irq, void *cookie)
 137 {
 138         struct wl1251 *wl = cookie;
 139
 140         ieee80211_queue_work(wl->hw, &wl->irq_work);
 141
 142         return IRQ_HANDLED;
 143 }
 144
 145 static void wl1251_enable_line_irq(struct wl1251 *wl)
 146 {
 147         return enable_irq(wl->irq);
 148 }
 149
 150 static void wl1251_disable_line_irq(struct wl1251 *wl)
 151 {
 152         return disable_irq(wl->irq);
 153 }
 154
 155 static int wl1251_sdio_set_power(struct wl1251 *wl, bool enable)
 156 {
 157         struct sdio_func *func = wl_to_func(wl);
 158         int ret;
 159
 160         if (enable) {
 161                 ret = pm_runtime_get_sync(&func->dev);
 162                 if (ret < 0) {
 163                         pm_runtime_put_sync(&func->dev);
 164                         goto out;
 165                 }
 166
 167                 sdio_claim_host(func);
 168                 sdio_enable_func(func);
 169                 sdio_release_host(func);
 170         } else {
 171                 sdio_claim_host(func);
 172                 sdio_disable_func(func);
 173                 sdio_release_host(func);
 174
 175                 ret = pm_runtime_put_sync(&func->dev);
 176                 if (ret < 0)
 177                         goto out;
 178         }
 179
 180 out:
 181         return ret;
 182 }
 183
 184 static struct wl1251_if_operations wl1251_sdio_ops = {
 185         .read = wl1251_sdio_read,
 186         .write = wl1251_sdio_write,
 187         .write_elp = wl1251_sdio_write_elp,
 188         .read_elp = wl1251_sdio_read_elp,
 189         .reset = wl1251_sdio_reset,
 190         .power = wl1251_sdio_set_power,
 191 };
 192
 193 static int wl1251_sdio_probe(struct sdio_func *func,
 194                              const struct sdio_device_id *id)
 195 {
 196         int ret;
 197         struct wl1251 *wl;
 198         struct ieee80211_hw *hw;
 199         struct wl1251_sdio *wl_sdio;
 200         const struct wl1251_platform_data *wl1251_board_data;
 201         struct device_node *np = func->dev.of_node;
 202
 203         hw = wl1251_alloc_hw();
 204         if (IS_ERR(hw))
 205                 return PTR_ERR(hw);
 206
 207         wl = hw->priv;
 208
 209         wl_sdio = kzalloc(sizeof(*wl_sdio), GFP_KERNEL);
 210         if (wl_sdio == NULL) {
 211                 ret = -ENOMEM;
 212                 goto out_free_hw;
 213         }
 214
 215         sdio_claim_host(func);
 216         ret = sdio_enable_func(func);
 217         if (ret)
 218                 goto release;
 219
 220         sdio_set_block_size(func, 512);
 221         sdio_release_host(func);
 222
 223         SET_IEEE80211_DEV(hw, &func->dev);
 224         wl_sdio->func = func;
 225         wl->if_priv = wl_sdio;
 226         wl->if_ops = &wl1251_sdio_ops;
 227
 228         wl1251_board_data = wl1251_get_platform_data();
 229         if (!IS_ERR(wl1251_board_data)) {
 230                 wl->irq = wl1251_board_data->irq;
 231                 wl->use_eeprom = wl1251_board_data->use_eeprom;
 232         } else if (np) {
 233                 wl->use_eeprom = of_property_read_bool(np, "ti,wl1251-has-eeprom");
 234                 wl->irq = of_irq_get(np, 0);
 235                 if (wl->irq == -EPROBE_DEFER) {
 236                         ret = -EPROBE_DEFER;
 237                         goto disable;
 238                 }
 239         }
 240
 241         if (wl->irq) {
 242                 irq_set_status_flags(wl->irq, IRQ_NOAUTOEN);
 243                 ret = request_irq(wl->irq, wl1251_line_irq, 0, "wl1251", wl);
 244                 if (ret < 0) {
 245                         wl1251_error("request_irq() failed: %d", ret);
 246                         goto disable;
 247                 }
 248
 249                 irq_set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
 250
 251                 wl1251_sdio_ops.enable_irq = wl1251_enable_line_irq;
 252                 wl1251_sdio_ops.disable_irq = wl1251_disable_line_irq;
 253
 254                 wl1251_info("using dedicated interrupt line");
 255         } else {
 256                 wl1251_sdio_ops.enable_irq = wl1251_sdio_enable_irq;
 257                 wl1251_sdio_ops.disable_irq = wl1251_sdio_disable_irq;
 258
 259                 wl1251_info("using SDIO interrupt");
 260         }
 261
 262         ret = wl1251_init_ieee80211(wl);
 263         if (ret)
 264                 goto out_free_irq;
 265
 266         sdio_set_drvdata(func, wl);
 267
 268         /* Tell PM core that we don't need the card to be powered now */
 269         pm_runtime_put_noidle(&func->dev);
 270
 271         return ret;
 272
 273 out_free_irq:
 274         if (wl->irq)
 275                 free_irq(wl->irq, wl);
 276 disable:
 277         sdio_claim_host(func);
 278         sdio_disable_func(func);
 279 release:
 280         sdio_release_host(func);
 281         kfree(wl_sdio);
 282 out_free_hw:
 283         wl1251_free_hw(wl);
 284         return ret;
 285 }
 286
 287 static void wl1251_sdio_remove(struct sdio_func *func)
 288 {
 289         struct wl1251 *wl = sdio_get_drvdata(func);
 290         struct wl1251_sdio *wl_sdio = wl->if_priv;
 291
 292         /* Undo decrement done above in wl1251_probe */
 293         pm_runtime_get_noresume(&func->dev);
 294
 295         if (wl->irq)
 296                 free_irq(wl->irq, wl);
 297         wl1251_free_hw(wl);
 298         kfree(wl_sdio);
 299
 300         sdio_claim_host(func);
 301         sdio_release_irq(func);
 302         sdio_disable_func(func);
 303         sdio_release_host(func);
 304 }
 305
 306 static int wl1251_suspend(struct device *dev)
 307 {
 308         /*
 309          * Tell MMC/SDIO core it's OK to power down the card
 310          * (if it isn't already), but not to remove it completely.
 311          */
 312         return 0;
 313 }
 314
 315 static int wl1251_resume(struct device *dev)
 316 {
 317         return 0;
 318 }
 319
 320 static const struct dev_pm_ops wl1251_sdio_pm_ops = {
 321         .suspend        = wl1251_suspend,
 322         .resume         = wl1251_resume,
 323 };
 324
 325 static struct sdio_driver wl1251_sdio_driver = {
 326         .name           = "wl1251_sdio",
 327         .id_table       = wl1251_devices,
 328         .probe          = wl1251_sdio_probe,
 329         .remove         = wl1251_sdio_remove,
 330         .drv.pm         = &wl1251_sdio_pm_ops,
 331 };
 332
 333 static int __init wl1251_sdio_init(void)
 334 {
 335         int err;
 336
 337         err = sdio_register_driver(&wl1251_sdio_driver);
 338         if (err)
 339                 wl1251_error("failed to register sdio driver: %d", err);
 340         return err;
 341 }
 342
 343 static void __exit wl1251_sdio_exit(void)
 344 {
 345         sdio_unregister_driver(&wl1251_sdio_driver);
 346         wl1251_notice("unloaded");
 347 }
 348
 349 module_init(wl1251_sdio_init);
 350 module_exit(wl1251_sdio_exit);
 351
 352 MODULE_LICENSE("GPL");
 353 MODULE_AUTHOR("Kalle Valo <kvalo@adurom.com>");