sdio.c 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368
  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. #include <linux/irq.h>
  24. #include <linux/module.h>
  25. #include <linux/crc7.h>
  26. #include <linux/vmalloc.h>
  27. #include <linux/mmc/sdio_func.h>
  28. #include <linux/mmc/sdio_ids.h>
  29. #include <linux/mmc/card.h>
  30. #include <linux/mmc/host.h>
  31. #include <linux/gpio.h>
  32. #include <linux/wl12xx.h>
  33. #include <linux/pm_runtime.h>
  34. #include "wl12xx.h"
  35. #include "wl12xx_80211.h"
  36. #include "io.h"
  37. #ifndef SDIO_VENDOR_ID_TI
  38. #define SDIO_VENDOR_ID_TI 0x0097
  39. #endif
  40. #ifndef SDIO_DEVICE_ID_TI_WL1271
  41. #define SDIO_DEVICE_ID_TI_WL1271 0x4076
  42. #endif
  43. static const struct sdio_device_id wl1271_devices[] = {
  44. { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) },
  45. {}
  46. };
  47. MODULE_DEVICE_TABLE(sdio, wl1271_devices);
  48. /* The max SDIO block size is 256 when working with tx padding to SDIO block */
  49. #define TX_PAD_SDIO_BLK_SIZE 256
  50. static void wl1271_sdio_set_block_size(struct wl1271 *wl)
  51. {
  52. wl->block_size = TX_PAD_SDIO_BLK_SIZE;
  53. sdio_claim_host(wl->if_priv);
  54. sdio_set_block_size(wl->if_priv, TX_PAD_SDIO_BLK_SIZE);
  55. sdio_release_host(wl->if_priv);
  56. }
  57. static inline struct sdio_func *wl_to_func(struct wl1271 *wl)
  58. {
  59. return wl->if_priv;
  60. }
  61. static struct device *wl1271_sdio_wl_to_dev(struct wl1271 *wl)
  62. {
  63. return &(wl_to_func(wl)->dev);
  64. }
  65. static irqreturn_t wl1271_hardirq(int irq, void *cookie)
  66. {
  67. struct wl1271 *wl = cookie;
  68. unsigned long flags;
  69. wl1271_debug(DEBUG_IRQ, "IRQ");
  70. /* complete the ELP completion */
  71. spin_lock_irqsave(&wl->wl_lock, flags);
  72. set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
  73. if (wl->elp_compl) {
  74. complete(wl->elp_compl);
  75. wl->elp_compl = NULL;
  76. }
  77. spin_unlock_irqrestore(&wl->wl_lock, flags);
  78. return IRQ_WAKE_THREAD;
  79. }
  80. static void wl1271_sdio_disable_interrupts(struct wl1271 *wl)
  81. {
  82. disable_irq(wl->irq);
  83. }
  84. static void wl1271_sdio_enable_interrupts(struct wl1271 *wl)
  85. {
  86. enable_irq(wl->irq);
  87. }
  88. static void wl1271_sdio_reset(struct wl1271 *wl)
  89. {
  90. }
  91. static void wl1271_sdio_init(struct wl1271 *wl)
  92. {
  93. }
  94. static void wl1271_sdio_raw_read(struct wl1271 *wl, int addr, void *buf,
  95. size_t len, bool fixed)
  96. {
  97. int ret;
  98. struct sdio_func *func = wl_to_func(wl);
  99. if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
  100. ((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret);
  101. wl1271_debug(DEBUG_SDIO, "sdio read 52 addr 0x%x, byte 0x%02x",
  102. addr, ((u8 *)buf)[0]);
  103. } else {
  104. if (fixed)
  105. ret = sdio_readsb(func, buf, addr, len);
  106. else
  107. ret = sdio_memcpy_fromio(func, buf, addr, len);
  108. wl1271_debug(DEBUG_SDIO, "sdio read 53 addr 0x%x, %zu bytes",
  109. addr, len);
  110. wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
  111. }
  112. if (ret)
  113. wl1271_error("sdio read failed (%d)", ret);
  114. }
  115. static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf,
  116. size_t len, bool fixed)
  117. {
  118. int ret;
  119. struct sdio_func *func = wl_to_func(wl);
  120. if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
  121. sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret);
  122. wl1271_debug(DEBUG_SDIO, "sdio write 52 addr 0x%x, byte 0x%02x",
  123. addr, ((u8 *)buf)[0]);
  124. } else {
  125. wl1271_debug(DEBUG_SDIO, "sdio write 53 addr 0x%x, %zu bytes",
  126. addr, len);
  127. wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
  128. if (fixed)
  129. ret = sdio_writesb(func, addr, buf, len);
  130. else
  131. ret = sdio_memcpy_toio(func, addr, buf, len);
  132. }
  133. if (ret)
  134. wl1271_error("sdio write failed (%d)", ret);
  135. }
  136. static int wl1271_sdio_power_on(struct wl1271 *wl)
  137. {
  138. struct sdio_func *func = wl_to_func(wl);
  139. int ret;
  140. /* Make sure the card will not be powered off by runtime PM */
  141. ret = pm_runtime_get_sync(&func->dev);
  142. if (ret < 0)
  143. goto out;
  144. /* Runtime PM might be disabled, so power up the card manually */
  145. ret = mmc_power_restore_host(func->card->host);
  146. if (ret < 0)
  147. goto out;
  148. sdio_claim_host(func);
  149. sdio_enable_func(func);
  150. /* Set the default block size in case it was modified */
  151. sdio_set_block_size(func, 0);
  152. out:
  153. return ret;
  154. }
  155. static int wl1271_sdio_power_off(struct wl1271 *wl)
  156. {
  157. struct sdio_func *func = wl_to_func(wl);
  158. int ret;
  159. sdio_disable_func(func);
  160. sdio_release_host(func);
  161. /* Runtime PM might be disabled, so power off the card manually */
  162. ret = mmc_power_save_host(func->card->host);
  163. if (ret < 0)
  164. return ret;
  165. /* Let runtime PM know the card is powered off */
  166. return pm_runtime_put_sync(&func->dev);
  167. }
  168. static int wl1271_sdio_set_power(struct wl1271 *wl, bool enable)
  169. {
  170. if (enable)
  171. return wl1271_sdio_power_on(wl);
  172. else
  173. return wl1271_sdio_power_off(wl);
  174. }
  175. static struct wl1271_if_operations sdio_ops = {
  176. .read = wl1271_sdio_raw_read,
  177. .write = wl1271_sdio_raw_write,
  178. .reset = wl1271_sdio_reset,
  179. .init = wl1271_sdio_init,
  180. .power = wl1271_sdio_set_power,
  181. .dev = wl1271_sdio_wl_to_dev,
  182. .enable_irq = wl1271_sdio_enable_interrupts,
  183. .disable_irq = wl1271_sdio_disable_interrupts,
  184. .set_block_size = wl1271_sdio_set_block_size,
  185. };
  186. static int __devinit wl1271_probe(struct sdio_func *func,
  187. const struct sdio_device_id *id)
  188. {
  189. struct ieee80211_hw *hw;
  190. const struct wl12xx_platform_data *wlan_data;
  191. struct wl1271 *wl;
  192. int ret;
  193. /* We are only able to handle the wlan function */
  194. if (func->num != 0x02)
  195. return -ENODEV;
  196. hw = wl1271_alloc_hw();
  197. if (IS_ERR(hw))
  198. return PTR_ERR(hw);
  199. wl = hw->priv;
  200. wl->if_priv = func;
  201. wl->if_ops = &sdio_ops;
  202. /* Grab access to FN0 for ELP reg. */
  203. func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
  204. /* Use block mode for transferring over one block size of data */
  205. func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
  206. wlan_data = wl12xx_get_platform_data();
  207. if (IS_ERR(wlan_data)) {
  208. ret = PTR_ERR(wlan_data);
  209. wl1271_error("missing wlan platform data: %d", ret);
  210. goto out_free;
  211. }
  212. wl->irq = wlan_data->irq;
  213. wl->ref_clock = wlan_data->board_ref_clock;
  214. wl->tcxo_clock = wlan_data->board_tcxo_clock;
  215. ret = request_threaded_irq(wl->irq, wl1271_hardirq, wl1271_irq,
  216. IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
  217. DRIVER_NAME, wl);
  218. if (ret < 0) {
  219. wl1271_error("request_irq() failed: %d", ret);
  220. goto out_free;
  221. }
  222. disable_irq(wl->irq);
  223. ret = wl1271_init_ieee80211(wl);
  224. if (ret)
  225. goto out_irq;
  226. ret = wl1271_register_hw(wl);
  227. if (ret)
  228. goto out_irq;
  229. sdio_set_drvdata(func, wl);
  230. /* Tell PM core that we don't need the card to be powered now */
  231. pm_runtime_put_noidle(&func->dev);
  232. wl1271_notice("initialized");
  233. return 0;
  234. out_irq:
  235. free_irq(wl->irq, wl);
  236. out_free:
  237. wl1271_free_hw(wl);
  238. return ret;
  239. }
  240. static void __devexit wl1271_remove(struct sdio_func *func)
  241. {
  242. struct wl1271 *wl = sdio_get_drvdata(func);
  243. /* Undo decrement done above in wl1271_probe */
  244. pm_runtime_get_noresume(&func->dev);
  245. wl1271_unregister_hw(wl);
  246. free_irq(wl->irq, wl);
  247. wl1271_free_hw(wl);
  248. }
  249. static int wl1271_suspend(struct device *dev)
  250. {
  251. /* Tell MMC/SDIO core it's OK to power down the card
  252. * (if it isn't already), but not to remove it completely */
  253. return 0;
  254. }
  255. static int wl1271_resume(struct device *dev)
  256. {
  257. return 0;
  258. }
  259. static const struct dev_pm_ops wl1271_sdio_pm_ops = {
  260. .suspend = wl1271_suspend,
  261. .resume = wl1271_resume,
  262. };
  263. static struct sdio_driver wl1271_sdio_driver = {
  264. .name = "wl1271_sdio",
  265. .id_table = wl1271_devices,
  266. .probe = wl1271_probe,
  267. .remove = __devexit_p(wl1271_remove),
  268. .drv = {
  269. .pm = &wl1271_sdio_pm_ops,
  270. },
  271. };
  272. static int __init wl1271_init(void)
  273. {
  274. int ret;
  275. ret = sdio_register_driver(&wl1271_sdio_driver);
  276. if (ret < 0) {
  277. wl1271_error("failed to register sdio driver: %d", ret);
  278. goto out;
  279. }
  280. out:
  281. return ret;
  282. }
  283. static void __exit wl1271_exit(void)
  284. {
  285. sdio_unregister_driver(&wl1271_sdio_driver);
  286. wl1271_notice("unloaded");
  287. }
  288. module_init(wl1271_init);
  289. module_exit(wl1271_exit);
  290. MODULE_LICENSE("GPL");
  291. MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
  292. MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
  293. MODULE_FIRMWARE(WL1271_FW_NAME);
  294. MODULE_FIRMWARE(WL128X_FW_NAME);
  295. MODULE_FIRMWARE(WL127X_AP_FW_NAME);
  296. MODULE_FIRMWARE(WL128X_AP_FW_NAME);