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