1 /* 2 * This file is part of wl1271 3 * 4 * Copyright (C) 2009-2010 Nokia Corporation 5 * 6 * Contact: Luciano Coelho <luciano.coelho@nokia.com> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * version 2 as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 20 * 02110-1301 USA 21 * 22 */ 23 24 #include <linux/irq.h> 25 #include <linux/module.h> 26 #include <linux/vmalloc.h> 27 #include <linux/platform_device.h> 28 #include <linux/mmc/sdio_func.h> 29 #include <linux/mmc/sdio_ids.h> 30 #include <linux/mmc/card.h> 31 #include <linux/mmc/host.h> 32 #include <linux/gpio.h> 33 #include <linux/wl12xx.h> 34 #include <linux/pm_runtime.h> 35 36 #include "wlcore.h" 37 #include "wl12xx_80211.h" 38 #include "io.h" 39 40 #ifndef SDIO_VENDOR_ID_TI 41 #define SDIO_VENDOR_ID_TI 0x0097 42 #endif 43 44 #ifndef SDIO_DEVICE_ID_TI_WL1271 45 #define SDIO_DEVICE_ID_TI_WL1271 0x4076 46 #endif 47 48 struct wl12xx_sdio_glue { 49 struct device *dev; 50 struct platform_device *core; 51 }; 52 53 static const struct sdio_device_id wl1271_devices[] __devinitconst = { 54 { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) }, 55 {} 56 }; 57 MODULE_DEVICE_TABLE(sdio, wl1271_devices); 58 59 static void wl1271_sdio_set_block_size(struct device *child, 60 unsigned int blksz) 61 { 62 struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent); 63 struct sdio_func *func = dev_to_sdio_func(glue->dev); 64 65 sdio_claim_host(func); 66 sdio_set_block_size(func, blksz); 67 sdio_release_host(func); 68 } 69 70 static void wl12xx_sdio_raw_read(struct device *child, int addr, void *buf, 71 size_t len, bool fixed) 72 { 73 int ret; 74 struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent); 75 struct sdio_func *func = dev_to_sdio_func(glue->dev); 76 77 sdio_claim_host(func); 78 79 if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG)) { 80 ((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret); 81 dev_dbg(child->parent, "sdio read 52 addr 0x%x, byte 0x%02x\n", 82 addr, ((u8 *)buf)[0]); 83 } else { 84 if (fixed) 85 ret = sdio_readsb(func, buf, addr, len); 86 else 87 ret = sdio_memcpy_fromio(func, buf, addr, len); 88 89 dev_dbg(child->parent, "sdio read 53 addr 0x%x, %zu bytes\n", 90 addr, len); 91 } 92 93 sdio_release_host(func); 94 95 if (ret) 96 dev_err(child->parent, "sdio read failed (%d)\n", ret); 97 } 98 99 static void wl12xx_sdio_raw_write(struct device *child, int addr, void *buf, 100 size_t len, bool fixed) 101 { 102 int ret; 103 struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent); 104 struct sdio_func *func = dev_to_sdio_func(glue->dev); 105 106 sdio_claim_host(func); 107 108 if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG)) { 109 sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret); 110 dev_dbg(child->parent, "sdio write 52 addr 0x%x, byte 0x%02x\n", 111 addr, ((u8 *)buf)[0]); 112 } else { 113 dev_dbg(child->parent, "sdio write 53 addr 0x%x, %zu bytes\n", 114 addr, len); 115 116 if (fixed) 117 ret = sdio_writesb(func, addr, buf, len); 118 else 119 ret = sdio_memcpy_toio(func, addr, buf, len); 120 } 121 122 sdio_release_host(func); 123 124 if (ret) 125 dev_err(child->parent, "sdio write failed (%d)\n", ret); 126 } 127 128 static int wl12xx_sdio_power_on(struct wl12xx_sdio_glue *glue) 129 { 130 int ret; 131 struct sdio_func *func = dev_to_sdio_func(glue->dev); 132 133 /* If enabled, tell runtime PM not to power off the card */ 134 if (pm_runtime_enabled(&func->dev)) { 135 ret = pm_runtime_get_sync(&func->dev); 136 if (ret < 0) 137 goto out; 138 } else { 139 /* Runtime PM is disabled: power up the card manually */ 140 ret = mmc_power_restore_host(func->card->host); 141 if (ret < 0) 142 goto out; 143 } 144 145 sdio_claim_host(func); 146 sdio_enable_func(func); 147 sdio_release_host(func); 148 149 out: 150 return ret; 151 } 152 153 static int wl12xx_sdio_power_off(struct wl12xx_sdio_glue *glue) 154 { 155 int ret; 156 struct sdio_func *func = dev_to_sdio_func(glue->dev); 157 158 sdio_claim_host(func); 159 sdio_disable_func(func); 160 sdio_release_host(func); 161 162 /* Power off the card manually, even if runtime PM is enabled. */ 163 ret = mmc_power_save_host(func->card->host); 164 if (ret < 0) 165 return ret; 166 167 /* If enabled, let runtime PM know the card is powered off */ 168 if (pm_runtime_enabled(&func->dev)) 169 ret = pm_runtime_put_sync(&func->dev); 170 171 return ret; 172 } 173 174 static int wl12xx_sdio_set_power(struct device *child, bool enable) 175 { 176 struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent); 177 178 if (enable) 179 return wl12xx_sdio_power_on(glue); 180 else 181 return wl12xx_sdio_power_off(glue); 182 } 183 184 static struct wl1271_if_operations sdio_ops = { 185 .read = wl12xx_sdio_raw_read, 186 .write = wl12xx_sdio_raw_write, 187 .power = wl12xx_sdio_set_power, 188 .set_block_size = wl1271_sdio_set_block_size, 189 }; 190 191 static int __devinit wl1271_probe(struct sdio_func *func, 192 const struct sdio_device_id *id) 193 { 194 struct wl12xx_platform_data *wlan_data; 195 struct wl12xx_sdio_glue *glue; 196 struct resource res[1]; 197 mmc_pm_flag_t mmcflags; 198 int ret = -ENOMEM; 199 200 /* We are only able to handle the wlan function */ 201 if (func->num != 0x02) 202 return -ENODEV; 203 204 glue = kzalloc(sizeof(*glue), GFP_KERNEL); 205 if (!glue) { 206 dev_err(&func->dev, "can't allocate glue\n"); 207 goto out; 208 } 209 210 glue->dev = &func->dev; 211 212 /* Grab access to FN0 for ELP reg. */ 213 func->card->quirks |= MMC_QUIRK_LENIENT_FN0; 214 215 /* Use block mode for transferring over one block size of data */ 216 func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE; 217 218 wlan_data = wl12xx_get_platform_data(); 219 if (IS_ERR(wlan_data)) { 220 ret = PTR_ERR(wlan_data); 221 dev_err(glue->dev, "missing wlan platform data: %d\n", ret); 222 goto out_free_glue; 223 } 224 225 /* if sdio can keep power while host is suspended, enable wow */ 226 mmcflags = sdio_get_host_pm_caps(func); 227 dev_dbg(glue->dev, "sdio PM caps = 0x%x\n", mmcflags); 228 229 if (mmcflags & MMC_PM_KEEP_POWER) 230 wlan_data->pwr_in_suspend = true; 231 232 wlan_data->ops = &sdio_ops; 233 234 sdio_set_drvdata(func, glue); 235 236 /* Tell PM core that we don't need the card to be powered now */ 237 pm_runtime_put_noidle(&func->dev); 238 239 glue->core = platform_device_alloc("wl12xx", -1); 240 if (!glue->core) { 241 dev_err(glue->dev, "can't allocate platform_device"); 242 ret = -ENOMEM; 243 goto out_free_glue; 244 } 245 246 glue->core->dev.parent = &func->dev; 247 248 memset(res, 0x00, sizeof(res)); 249 250 res[0].start = wlan_data->irq; 251 res[0].flags = IORESOURCE_IRQ; 252 res[0].name = "irq"; 253 254 ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res)); 255 if (ret) { 256 dev_err(glue->dev, "can't add resources\n"); 257 goto out_dev_put; 258 } 259 260 ret = platform_device_add_data(glue->core, wlan_data, 261 sizeof(*wlan_data)); 262 if (ret) { 263 dev_err(glue->dev, "can't add platform data\n"); 264 goto out_dev_put; 265 } 266 267 ret = platform_device_add(glue->core); 268 if (ret) { 269 dev_err(glue->dev, "can't add platform device\n"); 270 goto out_dev_put; 271 } 272 return 0; 273 274 out_dev_put: 275 platform_device_put(glue->core); 276 277 out_free_glue: 278 kfree(glue); 279 280 out: 281 return ret; 282 } 283 284 static void __devexit wl1271_remove(struct sdio_func *func) 285 { 286 struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func); 287 288 /* Undo decrement done above in wl1271_probe */ 289 pm_runtime_get_noresume(&func->dev); 290 291 platform_device_del(glue->core); 292 platform_device_put(glue->core); 293 kfree(glue); 294 } 295 296 #ifdef CONFIG_PM 297 static int wl1271_suspend(struct device *dev) 298 { 299 /* Tell MMC/SDIO core it's OK to power down the card 300 * (if it isn't already), but not to remove it completely */ 301 struct sdio_func *func = dev_to_sdio_func(dev); 302 struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func); 303 struct wl1271 *wl = platform_get_drvdata(glue->core); 304 mmc_pm_flag_t sdio_flags; 305 int ret = 0; 306 307 dev_dbg(dev, "wl1271 suspend. wow_enabled: %d\n", 308 wl->wow_enabled); 309 310 /* check whether sdio should keep power */ 311 if (wl->wow_enabled) { 312 sdio_flags = sdio_get_host_pm_caps(func); 313 314 if (!(sdio_flags & MMC_PM_KEEP_POWER)) { 315 dev_err(dev, "can't keep power while host " 316 "is suspended\n"); 317 ret = -EINVAL; 318 goto out; 319 } 320 321 /* keep power while host suspended */ 322 ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); 323 if (ret) { 324 dev_err(dev, "error while trying to keep power\n"); 325 goto out; 326 } 327 } 328 out: 329 return ret; 330 } 331 332 static int wl1271_resume(struct device *dev) 333 { 334 dev_dbg(dev, "wl1271 resume\n"); 335 336 return 0; 337 } 338 339 static const struct dev_pm_ops wl1271_sdio_pm_ops = { 340 .suspend = wl1271_suspend, 341 .resume = wl1271_resume, 342 }; 343 #endif 344 345 static struct sdio_driver wl1271_sdio_driver = { 346 .name = "wl1271_sdio", 347 .id_table = wl1271_devices, 348 .probe = wl1271_probe, 349 .remove = __devexit_p(wl1271_remove), 350 #ifdef CONFIG_PM 351 .drv = { 352 .pm = &wl1271_sdio_pm_ops, 353 }, 354 #endif 355 }; 356 357 static int __init wl1271_init(void) 358 { 359 return sdio_register_driver(&wl1271_sdio_driver); 360 } 361 362 static void __exit wl1271_exit(void) 363 { 364 sdio_unregister_driver(&wl1271_sdio_driver); 365 } 366 367 module_init(wl1271_init); 368 module_exit(wl1271_exit); 369 370 MODULE_LICENSE("GPL"); 371 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>"); 372 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>"); 373 MODULE_FIRMWARE(WL127X_FW_NAME_SINGLE); 374 MODULE_FIRMWARE(WL127X_FW_NAME_MULTI); 375 MODULE_FIRMWARE(WL127X_PLT_FW_NAME); 376 MODULE_FIRMWARE(WL128X_FW_NAME_SINGLE); 377 MODULE_FIRMWARE(WL128X_FW_NAME_MULTI); 378 MODULE_FIRMWARE(WL128X_PLT_FW_NAME); 379