if_sdio.c 28 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318
  1. /*
  2. * linux/drivers/net/wireless/libertas/if_sdio.c
  3. *
  4. * Copyright 2007-2008 Pierre Ossman
  5. *
  6. * Inspired by if_cs.c, Copyright 2007 Holger Schurig
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation; either version 2 of the License, or (at
  11. * your option) any later version.
  12. *
  13. * This hardware has more or less no CMD53 support, so all registers
  14. * must be accessed using sdio_readb()/sdio_writeb().
  15. *
  16. * Transfers must be in one transaction or the firmware goes bonkers.
  17. * This means that the transfer must either be small enough to do a
  18. * byte based transfer or it must be padded to a multiple of the
  19. * current block size.
  20. *
  21. * As SDIO is still new to the kernel, it is unfortunately common with
  22. * bugs in the host controllers related to that. One such bug is that
  23. * controllers cannot do transfers that aren't a multiple of 4 bytes.
  24. * If you don't have time to fix the host controller driver, you can
  25. * work around the problem by modifying if_sdio_host_to_card() and
  26. * if_sdio_card_to_host() to pad the data.
  27. */
  28. #include <linux/kernel.h>
  29. #include <linux/moduleparam.h>
  30. #include <linux/slab.h>
  31. #include <linux/firmware.h>
  32. #include <linux/netdevice.h>
  33. #include <linux/delay.h>
  34. #include <linux/mmc/card.h>
  35. #include <linux/mmc/sdio_func.h>
  36. #include <linux/mmc/sdio_ids.h>
  37. #include <linux/mmc/sdio.h>
  38. #include <linux/mmc/host.h>
  39. #include "host.h"
  40. #include "decl.h"
  41. #include "defs.h"
  42. #include "dev.h"
  43. #include "cmd.h"
  44. #include "if_sdio.h"
  45. /* The if_sdio_remove() callback function is called when
  46. * user removes this module from kernel space or ejects
  47. * the card from the slot. The driver handles these 2 cases
  48. * differently for SD8688 combo chip.
  49. * If the user is removing the module, the FUNC_SHUTDOWN
  50. * command for SD8688 is sent to the firmware.
  51. * If the card is removed, there is no need to send this command.
  52. *
  53. * The variable 'user_rmmod' is used to distinguish these two
  54. * scenarios. This flag is initialized as FALSE in case the card
  55. * is removed, and will be set to TRUE for module removal when
  56. * module_exit function is called.
  57. */
  58. static u8 user_rmmod;
  59. static char *lbs_helper_name = NULL;
  60. module_param_named(helper_name, lbs_helper_name, charp, 0644);
  61. static char *lbs_fw_name = NULL;
  62. module_param_named(fw_name, lbs_fw_name, charp, 0644);
  63. static const struct sdio_device_id if_sdio_ids[] = {
  64. { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,
  65. SDIO_DEVICE_ID_MARVELL_LIBERTAS) },
  66. { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,
  67. SDIO_DEVICE_ID_MARVELL_8688WLAN) },
  68. { /* end: all zeroes */ },
  69. };
  70. MODULE_DEVICE_TABLE(sdio, if_sdio_ids);
  71. struct if_sdio_model {
  72. int model;
  73. const char *helper;
  74. const char *firmware;
  75. };
  76. static struct if_sdio_model if_sdio_models[] = {
  77. {
  78. /* 8385 */
  79. .model = IF_SDIO_MODEL_8385,
  80. .helper = "sd8385_helper.bin",
  81. .firmware = "sd8385.bin",
  82. },
  83. {
  84. /* 8686 */
  85. .model = IF_SDIO_MODEL_8686,
  86. .helper = "sd8686_helper.bin",
  87. .firmware = "sd8686.bin",
  88. },
  89. {
  90. /* 8688 */
  91. .model = IF_SDIO_MODEL_8688,
  92. .helper = "sd8688_helper.bin",
  93. .firmware = "sd8688.bin",
  94. },
  95. };
  96. MODULE_FIRMWARE("sd8385_helper.bin");
  97. MODULE_FIRMWARE("sd8385.bin");
  98. MODULE_FIRMWARE("sd8686_helper.bin");
  99. MODULE_FIRMWARE("sd8686.bin");
  100. MODULE_FIRMWARE("sd8688_helper.bin");
  101. MODULE_FIRMWARE("sd8688.bin");
  102. struct if_sdio_packet {
  103. struct if_sdio_packet *next;
  104. u16 nb;
  105. u8 buffer[0] __attribute__((aligned(4)));
  106. };
  107. struct if_sdio_card {
  108. struct sdio_func *func;
  109. struct lbs_private *priv;
  110. int model;
  111. unsigned long ioport;
  112. unsigned int scratch_reg;
  113. const char *helper;
  114. const char *firmware;
  115. bool helper_allocated;
  116. bool firmware_allocated;
  117. u8 buffer[65536] __attribute__((aligned(4)));
  118. spinlock_t lock;
  119. struct if_sdio_packet *packets;
  120. struct workqueue_struct *workqueue;
  121. struct work_struct packet_worker;
  122. u8 rx_unit;
  123. };
  124. /********************************************************************/
  125. /* I/O */
  126. /********************************************************************/
  127. /*
  128. * For SD8385/SD8686, this function reads firmware status after
  129. * the image is downloaded, or reads RX packet length when
  130. * interrupt (with IF_SDIO_H_INT_UPLD bit set) is received.
  131. * For SD8688, this function reads firmware status only.
  132. */
  133. static u16 if_sdio_read_scratch(struct if_sdio_card *card, int *err)
  134. {
  135. int ret;
  136. u16 scratch;
  137. scratch = sdio_readb(card->func, card->scratch_reg, &ret);
  138. if (!ret)
  139. scratch |= sdio_readb(card->func, card->scratch_reg + 1,
  140. &ret) << 8;
  141. if (err)
  142. *err = ret;
  143. if (ret)
  144. return 0xffff;
  145. return scratch;
  146. }
  147. static u8 if_sdio_read_rx_unit(struct if_sdio_card *card)
  148. {
  149. int ret;
  150. u8 rx_unit;
  151. rx_unit = sdio_readb(card->func, IF_SDIO_RX_UNIT, &ret);
  152. if (ret)
  153. rx_unit = 0;
  154. return rx_unit;
  155. }
  156. static u16 if_sdio_read_rx_len(struct if_sdio_card *card, int *err)
  157. {
  158. int ret;
  159. u16 rx_len;
  160. switch (card->model) {
  161. case IF_SDIO_MODEL_8385:
  162. case IF_SDIO_MODEL_8686:
  163. rx_len = if_sdio_read_scratch(card, &ret);
  164. break;
  165. case IF_SDIO_MODEL_8688:
  166. default: /* for newer chipsets */
  167. rx_len = sdio_readb(card->func, IF_SDIO_RX_LEN, &ret);
  168. if (!ret)
  169. rx_len <<= card->rx_unit;
  170. else
  171. rx_len = 0xffff; /* invalid length */
  172. break;
  173. }
  174. if (err)
  175. *err = ret;
  176. return rx_len;
  177. }
  178. static int if_sdio_handle_cmd(struct if_sdio_card *card,
  179. u8 *buffer, unsigned size)
  180. {
  181. struct lbs_private *priv = card->priv;
  182. int ret;
  183. unsigned long flags;
  184. u8 i;
  185. lbs_deb_enter(LBS_DEB_SDIO);
  186. if (size > LBS_CMD_BUFFER_SIZE) {
  187. lbs_deb_sdio("response packet too large (%d bytes)\n",
  188. (int)size);
  189. ret = -E2BIG;
  190. goto out;
  191. }
  192. spin_lock_irqsave(&priv->driver_lock, flags);
  193. i = (priv->resp_idx == 0) ? 1 : 0;
  194. BUG_ON(priv->resp_len[i]);
  195. priv->resp_len[i] = size;
  196. memcpy(priv->resp_buf[i], buffer, size);
  197. lbs_notify_command_response(priv, i);
  198. spin_unlock_irqrestore(&card->priv->driver_lock, flags);
  199. ret = 0;
  200. out:
  201. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  202. return ret;
  203. }
  204. static int if_sdio_handle_data(struct if_sdio_card *card,
  205. u8 *buffer, unsigned size)
  206. {
  207. int ret;
  208. struct sk_buff *skb;
  209. char *data;
  210. lbs_deb_enter(LBS_DEB_SDIO);
  211. if (size > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
  212. lbs_deb_sdio("response packet too large (%d bytes)\n",
  213. (int)size);
  214. ret = -E2BIG;
  215. goto out;
  216. }
  217. skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + NET_IP_ALIGN);
  218. if (!skb) {
  219. ret = -ENOMEM;
  220. goto out;
  221. }
  222. skb_reserve(skb, NET_IP_ALIGN);
  223. data = skb_put(skb, size);
  224. memcpy(data, buffer, size);
  225. lbs_process_rxed_packet(card->priv, skb);
  226. ret = 0;
  227. out:
  228. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  229. return ret;
  230. }
  231. static int if_sdio_handle_event(struct if_sdio_card *card,
  232. u8 *buffer, unsigned size)
  233. {
  234. int ret;
  235. u32 event;
  236. lbs_deb_enter(LBS_DEB_SDIO);
  237. if (card->model == IF_SDIO_MODEL_8385) {
  238. event = sdio_readb(card->func, IF_SDIO_EVENT, &ret);
  239. if (ret)
  240. goto out;
  241. /* right shift 3 bits to get the event id */
  242. event >>= 3;
  243. } else {
  244. if (size < 4) {
  245. lbs_deb_sdio("event packet too small (%d bytes)\n",
  246. (int)size);
  247. ret = -EINVAL;
  248. goto out;
  249. }
  250. event = buffer[3] << 24;
  251. event |= buffer[2] << 16;
  252. event |= buffer[1] << 8;
  253. event |= buffer[0] << 0;
  254. }
  255. lbs_queue_event(card->priv, event & 0xFF);
  256. ret = 0;
  257. out:
  258. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  259. return ret;
  260. }
  261. static int if_sdio_wait_status(struct if_sdio_card *card, const u8 condition)
  262. {
  263. u8 status;
  264. unsigned long timeout;
  265. int ret = 0;
  266. timeout = jiffies + HZ;
  267. while (1) {
  268. status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
  269. if (ret)
  270. return ret;
  271. if ((status & condition) == condition)
  272. break;
  273. if (time_after(jiffies, timeout))
  274. return -ETIMEDOUT;
  275. mdelay(1);
  276. }
  277. return ret;
  278. }
  279. static int if_sdio_card_to_host(struct if_sdio_card *card)
  280. {
  281. int ret;
  282. u16 size, type, chunk;
  283. lbs_deb_enter(LBS_DEB_SDIO);
  284. size = if_sdio_read_rx_len(card, &ret);
  285. if (ret)
  286. goto out;
  287. if (size < 4) {
  288. lbs_deb_sdio("invalid packet size (%d bytes) from firmware\n",
  289. (int)size);
  290. ret = -EINVAL;
  291. goto out;
  292. }
  293. ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY);
  294. if (ret)
  295. goto out;
  296. /*
  297. * The transfer must be in one transaction or the firmware
  298. * goes suicidal. There's no way to guarantee that for all
  299. * controllers, but we can at least try.
  300. */
  301. chunk = sdio_align_size(card->func, size);
  302. ret = sdio_readsb(card->func, card->buffer, card->ioport, chunk);
  303. if (ret)
  304. goto out;
  305. chunk = card->buffer[0] | (card->buffer[1] << 8);
  306. type = card->buffer[2] | (card->buffer[3] << 8);
  307. lbs_deb_sdio("packet of type %d and size %d bytes\n",
  308. (int)type, (int)chunk);
  309. if (chunk > size) {
  310. lbs_deb_sdio("packet fragment (%d > %d)\n",
  311. (int)chunk, (int)size);
  312. ret = -EINVAL;
  313. goto out;
  314. }
  315. if (chunk < size) {
  316. lbs_deb_sdio("packet fragment (%d < %d)\n",
  317. (int)chunk, (int)size);
  318. }
  319. switch (type) {
  320. case MVMS_CMD:
  321. ret = if_sdio_handle_cmd(card, card->buffer + 4, chunk - 4);
  322. if (ret)
  323. goto out;
  324. break;
  325. case MVMS_DAT:
  326. ret = if_sdio_handle_data(card, card->buffer + 4, chunk - 4);
  327. if (ret)
  328. goto out;
  329. break;
  330. case MVMS_EVENT:
  331. ret = if_sdio_handle_event(card, card->buffer + 4, chunk - 4);
  332. if (ret)
  333. goto out;
  334. break;
  335. default:
  336. lbs_deb_sdio("invalid type (%d) from firmware\n",
  337. (int)type);
  338. ret = -EINVAL;
  339. goto out;
  340. }
  341. out:
  342. if (ret)
  343. lbs_pr_err("problem fetching packet from firmware\n");
  344. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  345. return ret;
  346. }
  347. static void if_sdio_host_to_card_worker(struct work_struct *work)
  348. {
  349. struct if_sdio_card *card;
  350. struct if_sdio_packet *packet;
  351. int ret;
  352. unsigned long flags;
  353. lbs_deb_enter(LBS_DEB_SDIO);
  354. card = container_of(work, struct if_sdio_card, packet_worker);
  355. while (1) {
  356. spin_lock_irqsave(&card->lock, flags);
  357. packet = card->packets;
  358. if (packet)
  359. card->packets = packet->next;
  360. spin_unlock_irqrestore(&card->lock, flags);
  361. if (!packet)
  362. break;
  363. sdio_claim_host(card->func);
  364. ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY);
  365. if (ret == 0) {
  366. ret = sdio_writesb(card->func, card->ioport,
  367. packet->buffer, packet->nb);
  368. }
  369. if (ret)
  370. lbs_pr_err("error %d sending packet to firmware\n", ret);
  371. sdio_release_host(card->func);
  372. kfree(packet);
  373. }
  374. lbs_deb_leave(LBS_DEB_SDIO);
  375. }
  376. /********************************************************************/
  377. /* Firmware */
  378. /********************************************************************/
  379. #define FW_DL_READY_STATUS (IF_SDIO_IO_RDY | IF_SDIO_DL_RDY)
  380. static int if_sdio_prog_helper(struct if_sdio_card *card)
  381. {
  382. int ret;
  383. const struct firmware *fw;
  384. unsigned long timeout;
  385. u8 *chunk_buffer;
  386. u32 chunk_size;
  387. const u8 *firmware;
  388. size_t size;
  389. lbs_deb_enter(LBS_DEB_SDIO);
  390. ret = request_firmware(&fw, card->helper, &card->func->dev);
  391. if (ret) {
  392. lbs_pr_err("can't load helper firmware\n");
  393. goto out;
  394. }
  395. chunk_buffer = kzalloc(64, GFP_KERNEL);
  396. if (!chunk_buffer) {
  397. ret = -ENOMEM;
  398. goto release_fw;
  399. }
  400. sdio_claim_host(card->func);
  401. ret = sdio_set_block_size(card->func, 32);
  402. if (ret)
  403. goto release;
  404. firmware = fw->data;
  405. size = fw->size;
  406. while (size) {
  407. ret = if_sdio_wait_status(card, FW_DL_READY_STATUS);
  408. if (ret)
  409. goto release;
  410. /* On some platforms (like Davinci) the chip needs more time
  411. * between helper blocks.
  412. */
  413. mdelay(2);
  414. chunk_size = min(size, (size_t)60);
  415. *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size);
  416. memcpy(chunk_buffer + 4, firmware, chunk_size);
  417. /*
  418. lbs_deb_sdio("sending %d bytes chunk\n", chunk_size);
  419. */
  420. ret = sdio_writesb(card->func, card->ioport,
  421. chunk_buffer, 64);
  422. if (ret)
  423. goto release;
  424. firmware += chunk_size;
  425. size -= chunk_size;
  426. }
  427. /* an empty block marks the end of the transfer */
  428. memset(chunk_buffer, 0, 4);
  429. ret = sdio_writesb(card->func, card->ioport, chunk_buffer, 64);
  430. if (ret)
  431. goto release;
  432. lbs_deb_sdio("waiting for helper to boot...\n");
  433. /* wait for the helper to boot by looking at the size register */
  434. timeout = jiffies + HZ;
  435. while (1) {
  436. u16 req_size;
  437. req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);
  438. if (ret)
  439. goto release;
  440. req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;
  441. if (ret)
  442. goto release;
  443. if (req_size != 0)
  444. break;
  445. if (time_after(jiffies, timeout)) {
  446. ret = -ETIMEDOUT;
  447. goto release;
  448. }
  449. msleep(10);
  450. }
  451. ret = 0;
  452. release:
  453. sdio_release_host(card->func);
  454. kfree(chunk_buffer);
  455. release_fw:
  456. release_firmware(fw);
  457. out:
  458. if (ret)
  459. lbs_pr_err("failed to load helper firmware\n");
  460. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  461. return ret;
  462. }
  463. static int if_sdio_prog_real(struct if_sdio_card *card)
  464. {
  465. int ret;
  466. const struct firmware *fw;
  467. unsigned long timeout;
  468. u8 *chunk_buffer;
  469. u32 chunk_size;
  470. const u8 *firmware;
  471. size_t size, req_size;
  472. lbs_deb_enter(LBS_DEB_SDIO);
  473. ret = request_firmware(&fw, card->firmware, &card->func->dev);
  474. if (ret) {
  475. lbs_pr_err("can't load firmware\n");
  476. goto out;
  477. }
  478. chunk_buffer = kzalloc(512, GFP_KERNEL);
  479. if (!chunk_buffer) {
  480. ret = -ENOMEM;
  481. goto release_fw;
  482. }
  483. sdio_claim_host(card->func);
  484. ret = sdio_set_block_size(card->func, 32);
  485. if (ret)
  486. goto release;
  487. firmware = fw->data;
  488. size = fw->size;
  489. while (size) {
  490. ret = if_sdio_wait_status(card, FW_DL_READY_STATUS);
  491. if (ret)
  492. goto release;
  493. req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);
  494. if (ret)
  495. goto release;
  496. req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;
  497. if (ret)
  498. goto release;
  499. /*
  500. lbs_deb_sdio("firmware wants %d bytes\n", (int)req_size);
  501. */
  502. if (req_size == 0) {
  503. lbs_deb_sdio("firmware helper gave up early\n");
  504. ret = -EIO;
  505. goto release;
  506. }
  507. if (req_size & 0x01) {
  508. lbs_deb_sdio("firmware helper signalled error\n");
  509. ret = -EIO;
  510. goto release;
  511. }
  512. if (req_size > size)
  513. req_size = size;
  514. while (req_size) {
  515. chunk_size = min(req_size, (size_t)512);
  516. memcpy(chunk_buffer, firmware, chunk_size);
  517. /*
  518. lbs_deb_sdio("sending %d bytes (%d bytes) chunk\n",
  519. chunk_size, (chunk_size + 31) / 32 * 32);
  520. */
  521. ret = sdio_writesb(card->func, card->ioport,
  522. chunk_buffer, roundup(chunk_size, 32));
  523. if (ret)
  524. goto release;
  525. firmware += chunk_size;
  526. size -= chunk_size;
  527. req_size -= chunk_size;
  528. }
  529. }
  530. ret = 0;
  531. lbs_deb_sdio("waiting for firmware to boot...\n");
  532. /* wait for the firmware to boot */
  533. timeout = jiffies + HZ;
  534. while (1) {
  535. u16 scratch;
  536. scratch = if_sdio_read_scratch(card, &ret);
  537. if (ret)
  538. goto release;
  539. if (scratch == IF_SDIO_FIRMWARE_OK)
  540. break;
  541. if (time_after(jiffies, timeout)) {
  542. ret = -ETIMEDOUT;
  543. goto release;
  544. }
  545. msleep(10);
  546. }
  547. ret = 0;
  548. release:
  549. sdio_release_host(card->func);
  550. kfree(chunk_buffer);
  551. release_fw:
  552. release_firmware(fw);
  553. out:
  554. if (ret)
  555. lbs_pr_err("failed to load firmware\n");
  556. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  557. return ret;
  558. }
  559. static int if_sdio_prog_firmware(struct if_sdio_card *card)
  560. {
  561. int ret;
  562. u16 scratch;
  563. lbs_deb_enter(LBS_DEB_SDIO);
  564. sdio_claim_host(card->func);
  565. scratch = if_sdio_read_scratch(card, &ret);
  566. sdio_release_host(card->func);
  567. if (ret)
  568. goto out;
  569. lbs_deb_sdio("firmware status = %#x\n", scratch);
  570. if (scratch == IF_SDIO_FIRMWARE_OK) {
  571. lbs_deb_sdio("firmware already loaded\n");
  572. goto success;
  573. }
  574. ret = if_sdio_prog_helper(card);
  575. if (ret)
  576. goto out;
  577. ret = if_sdio_prog_real(card);
  578. if (ret)
  579. goto out;
  580. success:
  581. sdio_claim_host(card->func);
  582. sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE);
  583. sdio_release_host(card->func);
  584. ret = 0;
  585. out:
  586. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  587. return ret;
  588. }
  589. /*******************************************************************/
  590. /* Libertas callbacks */
  591. /*******************************************************************/
  592. static int if_sdio_host_to_card(struct lbs_private *priv,
  593. u8 type, u8 *buf, u16 nb)
  594. {
  595. int ret;
  596. struct if_sdio_card *card;
  597. struct if_sdio_packet *packet, *cur;
  598. u16 size;
  599. unsigned long flags;
  600. lbs_deb_enter_args(LBS_DEB_SDIO, "type %d, bytes %d", type, nb);
  601. card = priv->card;
  602. if (nb > (65536 - sizeof(struct if_sdio_packet) - 4)) {
  603. ret = -EINVAL;
  604. goto out;
  605. }
  606. /*
  607. * The transfer must be in one transaction or the firmware
  608. * goes suicidal. There's no way to guarantee that for all
  609. * controllers, but we can at least try.
  610. */
  611. size = sdio_align_size(card->func, nb + 4);
  612. packet = kzalloc(sizeof(struct if_sdio_packet) + size,
  613. GFP_ATOMIC);
  614. if (!packet) {
  615. ret = -ENOMEM;
  616. goto out;
  617. }
  618. packet->next = NULL;
  619. packet->nb = size;
  620. /*
  621. * SDIO specific header.
  622. */
  623. packet->buffer[0] = (nb + 4) & 0xff;
  624. packet->buffer[1] = ((nb + 4) >> 8) & 0xff;
  625. packet->buffer[2] = type;
  626. packet->buffer[3] = 0;
  627. memcpy(packet->buffer + 4, buf, nb);
  628. spin_lock_irqsave(&card->lock, flags);
  629. if (!card->packets)
  630. card->packets = packet;
  631. else {
  632. cur = card->packets;
  633. while (cur->next)
  634. cur = cur->next;
  635. cur->next = packet;
  636. }
  637. switch (type) {
  638. case MVMS_CMD:
  639. priv->dnld_sent = DNLD_CMD_SENT;
  640. break;
  641. case MVMS_DAT:
  642. priv->dnld_sent = DNLD_DATA_SENT;
  643. break;
  644. default:
  645. lbs_deb_sdio("unknown packet type %d\n", (int)type);
  646. }
  647. spin_unlock_irqrestore(&card->lock, flags);
  648. queue_work(card->workqueue, &card->packet_worker);
  649. ret = 0;
  650. out:
  651. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  652. return ret;
  653. }
  654. static int if_sdio_enter_deep_sleep(struct lbs_private *priv)
  655. {
  656. int ret = -1;
  657. struct cmd_header cmd;
  658. memset(&cmd, 0, sizeof(cmd));
  659. lbs_deb_sdio("send DEEP_SLEEP command\n");
  660. ret = __lbs_cmd(priv, CMD_802_11_DEEP_SLEEP, &cmd, sizeof(cmd),
  661. lbs_cmd_copyback, (unsigned long) &cmd);
  662. if (ret)
  663. lbs_pr_err("DEEP_SLEEP cmd failed\n");
  664. mdelay(200);
  665. return ret;
  666. }
  667. static int if_sdio_exit_deep_sleep(struct lbs_private *priv)
  668. {
  669. struct if_sdio_card *card = priv->card;
  670. int ret = -1;
  671. lbs_deb_enter(LBS_DEB_SDIO);
  672. sdio_claim_host(card->func);
  673. sdio_writeb(card->func, HOST_POWER_UP, CONFIGURATION_REG, &ret);
  674. if (ret)
  675. lbs_pr_err("sdio_writeb failed!\n");
  676. sdio_release_host(card->func);
  677. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  678. return ret;
  679. }
  680. static int if_sdio_reset_deep_sleep_wakeup(struct lbs_private *priv)
  681. {
  682. struct if_sdio_card *card = priv->card;
  683. int ret = -1;
  684. lbs_deb_enter(LBS_DEB_SDIO);
  685. sdio_claim_host(card->func);
  686. sdio_writeb(card->func, 0, CONFIGURATION_REG, &ret);
  687. if (ret)
  688. lbs_pr_err("sdio_writeb failed!\n");
  689. sdio_release_host(card->func);
  690. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  691. return ret;
  692. }
  693. /*******************************************************************/
  694. /* SDIO callbacks */
  695. /*******************************************************************/
  696. static void if_sdio_interrupt(struct sdio_func *func)
  697. {
  698. int ret;
  699. struct if_sdio_card *card;
  700. u8 cause;
  701. lbs_deb_enter(LBS_DEB_SDIO);
  702. card = sdio_get_drvdata(func);
  703. cause = sdio_readb(card->func, IF_SDIO_H_INT_STATUS, &ret);
  704. if (ret)
  705. goto out;
  706. lbs_deb_sdio("interrupt: 0x%X\n", (unsigned)cause);
  707. sdio_writeb(card->func, ~cause, IF_SDIO_H_INT_STATUS, &ret);
  708. if (ret)
  709. goto out;
  710. /*
  711. * Ignore the define name, this really means the card has
  712. * successfully received the command.
  713. */
  714. card->priv->is_activity_detected = 1;
  715. if (cause & IF_SDIO_H_INT_DNLD)
  716. lbs_host_to_card_done(card->priv);
  717. if (cause & IF_SDIO_H_INT_UPLD) {
  718. ret = if_sdio_card_to_host(card);
  719. if (ret)
  720. goto out;
  721. }
  722. ret = 0;
  723. out:
  724. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  725. }
  726. static int if_sdio_probe(struct sdio_func *func,
  727. const struct sdio_device_id *id)
  728. {
  729. struct if_sdio_card *card;
  730. struct lbs_private *priv;
  731. int ret, i;
  732. unsigned int model;
  733. struct if_sdio_packet *packet;
  734. struct mmc_host *host = func->card->host;
  735. lbs_deb_enter(LBS_DEB_SDIO);
  736. for (i = 0;i < func->card->num_info;i++) {
  737. if (sscanf(func->card->info[i],
  738. "802.11 SDIO ID: %x", &model) == 1)
  739. break;
  740. if (sscanf(func->card->info[i],
  741. "ID: %x", &model) == 1)
  742. break;
  743. if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) {
  744. model = IF_SDIO_MODEL_8385;
  745. break;
  746. }
  747. }
  748. if (i == func->card->num_info) {
  749. lbs_pr_err("unable to identify card model\n");
  750. return -ENODEV;
  751. }
  752. card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL);
  753. if (!card)
  754. return -ENOMEM;
  755. card->func = func;
  756. card->model = model;
  757. switch (card->model) {
  758. case IF_SDIO_MODEL_8385:
  759. card->scratch_reg = IF_SDIO_SCRATCH_OLD;
  760. break;
  761. case IF_SDIO_MODEL_8686:
  762. card->scratch_reg = IF_SDIO_SCRATCH;
  763. break;
  764. case IF_SDIO_MODEL_8688:
  765. default: /* for newer chipsets */
  766. card->scratch_reg = IF_SDIO_FW_STATUS;
  767. break;
  768. }
  769. spin_lock_init(&card->lock);
  770. card->workqueue = create_workqueue("libertas_sdio");
  771. INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker);
  772. for (i = 0;i < ARRAY_SIZE(if_sdio_models);i++) {
  773. if (card->model == if_sdio_models[i].model)
  774. break;
  775. }
  776. if (i == ARRAY_SIZE(if_sdio_models)) {
  777. lbs_pr_err("unknown card model 0x%x\n", card->model);
  778. ret = -ENODEV;
  779. goto free;
  780. }
  781. card->helper = if_sdio_models[i].helper;
  782. card->firmware = if_sdio_models[i].firmware;
  783. kparam_block_sysfs_write(helper_name);
  784. if (lbs_helper_name) {
  785. char *helper = kstrdup(lbs_helper_name, GFP_KERNEL);
  786. if (!helper) {
  787. kparam_unblock_sysfs_write(helper_name);
  788. ret = -ENOMEM;
  789. goto free;
  790. }
  791. lbs_deb_sdio("overriding helper firmware: %s\n",
  792. lbs_helper_name);
  793. card->helper = helper;
  794. card->helper_allocated = true;
  795. }
  796. kparam_unblock_sysfs_write(helper_name);
  797. kparam_block_sysfs_write(fw_name);
  798. if (lbs_fw_name) {
  799. char *fw_name = kstrdup(lbs_fw_name, GFP_KERNEL);
  800. if (!fw_name) {
  801. kparam_unblock_sysfs_write(fw_name);
  802. ret = -ENOMEM;
  803. goto free;
  804. }
  805. lbs_deb_sdio("overriding firmware: %s\n", lbs_fw_name);
  806. card->firmware = fw_name;
  807. card->firmware_allocated = true;
  808. }
  809. kparam_unblock_sysfs_write(fw_name);
  810. sdio_claim_host(func);
  811. ret = sdio_enable_func(func);
  812. if (ret)
  813. goto release;
  814. ret = sdio_claim_irq(func, if_sdio_interrupt);
  815. if (ret)
  816. goto disable;
  817. /* For 1-bit transfers to the 8686 model, we need to enable the
  818. * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0
  819. * bit to allow access to non-vendor registers. */
  820. if ((card->model == IF_SDIO_MODEL_8686) &&
  821. (host->caps & MMC_CAP_SDIO_IRQ) &&
  822. (host->ios.bus_width == MMC_BUS_WIDTH_1)) {
  823. u8 reg;
  824. func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
  825. reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret);
  826. if (ret)
  827. goto release_int;
  828. reg |= SDIO_BUS_ECSI;
  829. sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret);
  830. if (ret)
  831. goto release_int;
  832. }
  833. card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret);
  834. if (ret)
  835. goto release_int;
  836. card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8;
  837. if (ret)
  838. goto release_int;
  839. card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16;
  840. if (ret)
  841. goto release_int;
  842. sdio_release_host(func);
  843. sdio_set_drvdata(func, card);
  844. lbs_deb_sdio("class = 0x%X, vendor = 0x%X, "
  845. "device = 0x%X, model = 0x%X, ioport = 0x%X\n",
  846. func->class, func->vendor, func->device,
  847. model, (unsigned)card->ioport);
  848. ret = if_sdio_prog_firmware(card);
  849. if (ret)
  850. goto reclaim;
  851. priv = lbs_add_card(card, &func->dev);
  852. if (!priv) {
  853. ret = -ENOMEM;
  854. goto reclaim;
  855. }
  856. card->priv = priv;
  857. priv->card = card;
  858. priv->hw_host_to_card = if_sdio_host_to_card;
  859. priv->enter_deep_sleep = if_sdio_enter_deep_sleep;
  860. priv->exit_deep_sleep = if_sdio_exit_deep_sleep;
  861. priv->reset_deep_sleep_wakeup = if_sdio_reset_deep_sleep_wakeup;
  862. priv->fw_ready = 1;
  863. sdio_claim_host(func);
  864. /*
  865. * Get rx_unit if the chip is SD8688 or newer.
  866. * SD8385 & SD8686 do not have rx_unit.
  867. */
  868. if ((card->model != IF_SDIO_MODEL_8385)
  869. && (card->model != IF_SDIO_MODEL_8686))
  870. card->rx_unit = if_sdio_read_rx_unit(card);
  871. else
  872. card->rx_unit = 0;
  873. /*
  874. * Enable interrupts now that everything is set up
  875. */
  876. sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret);
  877. sdio_release_host(func);
  878. if (ret)
  879. goto reclaim;
  880. /*
  881. * FUNC_INIT is required for SD8688 WLAN/BT multiple functions
  882. */
  883. if (card->model == IF_SDIO_MODEL_8688) {
  884. struct cmd_header cmd;
  885. memset(&cmd, 0, sizeof(cmd));
  886. lbs_deb_sdio("send function INIT command\n");
  887. if (__lbs_cmd(priv, CMD_FUNC_INIT, &cmd, sizeof(cmd),
  888. lbs_cmd_copyback, (unsigned long) &cmd))
  889. lbs_pr_alert("CMD_FUNC_INIT cmd failed\n");
  890. }
  891. ret = lbs_start_card(priv);
  892. if (ret)
  893. goto err_activate_card;
  894. out:
  895. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  896. return ret;
  897. err_activate_card:
  898. flush_workqueue(card->workqueue);
  899. lbs_remove_card(priv);
  900. reclaim:
  901. sdio_claim_host(func);
  902. release_int:
  903. sdio_release_irq(func);
  904. disable:
  905. sdio_disable_func(func);
  906. release:
  907. sdio_release_host(func);
  908. free:
  909. destroy_workqueue(card->workqueue);
  910. while (card->packets) {
  911. packet = card->packets;
  912. card->packets = card->packets->next;
  913. kfree(packet);
  914. }
  915. if (card->helper_allocated)
  916. kfree(card->helper);
  917. if (card->firmware_allocated)
  918. kfree(card->firmware);
  919. kfree(card);
  920. goto out;
  921. }
  922. static void if_sdio_remove(struct sdio_func *func)
  923. {
  924. struct if_sdio_card *card;
  925. struct if_sdio_packet *packet;
  926. lbs_deb_enter(LBS_DEB_SDIO);
  927. card = sdio_get_drvdata(func);
  928. if (user_rmmod && (card->model == IF_SDIO_MODEL_8688)) {
  929. /*
  930. * FUNC_SHUTDOWN is required for SD8688 WLAN/BT
  931. * multiple functions
  932. */
  933. struct cmd_header cmd;
  934. memset(&cmd, 0, sizeof(cmd));
  935. lbs_deb_sdio("send function SHUTDOWN command\n");
  936. if (__lbs_cmd(card->priv, CMD_FUNC_SHUTDOWN,
  937. &cmd, sizeof(cmd), lbs_cmd_copyback,
  938. (unsigned long) &cmd))
  939. lbs_pr_alert("CMD_FUNC_SHUTDOWN cmd failed\n");
  940. }
  941. lbs_deb_sdio("call remove card\n");
  942. lbs_stop_card(card->priv);
  943. lbs_remove_card(card->priv);
  944. card->priv->surpriseremoved = 1;
  945. flush_workqueue(card->workqueue);
  946. destroy_workqueue(card->workqueue);
  947. sdio_claim_host(func);
  948. sdio_release_irq(func);
  949. sdio_disable_func(func);
  950. sdio_release_host(func);
  951. while (card->packets) {
  952. packet = card->packets;
  953. card->packets = card->packets->next;
  954. kfree(packet);
  955. }
  956. if (card->helper_allocated)
  957. kfree(card->helper);
  958. if (card->firmware_allocated)
  959. kfree(card->firmware);
  960. kfree(card);
  961. lbs_deb_leave(LBS_DEB_SDIO);
  962. }
  963. static int if_sdio_suspend(struct device *dev)
  964. {
  965. struct sdio_func *func = dev_to_sdio_func(dev);
  966. int ret;
  967. struct if_sdio_card *card = sdio_get_drvdata(func);
  968. mmc_pm_flag_t flags = sdio_get_host_pm_caps(func);
  969. lbs_pr_info("%s: suspend: PM flags = 0x%x\n",
  970. sdio_func_id(func), flags);
  971. /* If we aren't being asked to wake on anything, we should bail out
  972. * and let the SD stack power down the card.
  973. */
  974. if (card->priv->wol_criteria == EHS_REMOVE_WAKEUP) {
  975. lbs_pr_info("Suspend without wake params -- "
  976. "powering down card.");
  977. return -ENOSYS;
  978. }
  979. if (!(flags & MMC_PM_KEEP_POWER)) {
  980. lbs_pr_err("%s: cannot remain alive while host is suspended\n",
  981. sdio_func_id(func));
  982. return -ENOSYS;
  983. }
  984. ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
  985. if (ret)
  986. return ret;
  987. ret = lbs_suspend(card->priv);
  988. if (ret)
  989. return ret;
  990. return sdio_set_host_pm_flags(func, MMC_PM_WAKE_SDIO_IRQ);
  991. }
  992. static int if_sdio_resume(struct device *dev)
  993. {
  994. struct sdio_func *func = dev_to_sdio_func(dev);
  995. struct if_sdio_card *card = sdio_get_drvdata(func);
  996. int ret;
  997. lbs_pr_info("%s: resume: we're back\n", sdio_func_id(func));
  998. ret = lbs_resume(card->priv);
  999. return ret;
  1000. }
  1001. static const struct dev_pm_ops if_sdio_pm_ops = {
  1002. .suspend = if_sdio_suspend,
  1003. .resume = if_sdio_resume,
  1004. };
  1005. static struct sdio_driver if_sdio_driver = {
  1006. .name = "libertas_sdio",
  1007. .id_table = if_sdio_ids,
  1008. .probe = if_sdio_probe,
  1009. .remove = if_sdio_remove,
  1010. .drv = {
  1011. .pm = &if_sdio_pm_ops,
  1012. },
  1013. };
  1014. /*******************************************************************/
  1015. /* Module functions */
  1016. /*******************************************************************/
  1017. static int __init if_sdio_init_module(void)
  1018. {
  1019. int ret = 0;
  1020. lbs_deb_enter(LBS_DEB_SDIO);
  1021. printk(KERN_INFO "libertas_sdio: Libertas SDIO driver\n");
  1022. printk(KERN_INFO "libertas_sdio: Copyright Pierre Ossman\n");
  1023. ret = sdio_register_driver(&if_sdio_driver);
  1024. /* Clear the flag in case user removes the card. */
  1025. user_rmmod = 0;
  1026. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  1027. return ret;
  1028. }
  1029. static void __exit if_sdio_exit_module(void)
  1030. {
  1031. lbs_deb_enter(LBS_DEB_SDIO);
  1032. /* Set the flag as user is removing this module. */
  1033. user_rmmod = 1;
  1034. sdio_unregister_driver(&if_sdio_driver);
  1035. lbs_deb_leave(LBS_DEB_SDIO);
  1036. }
  1037. module_init(if_sdio_init_module);
  1038. module_exit(if_sdio_exit_module);
  1039. MODULE_DESCRIPTION("Libertas SDIO WLAN Driver");
  1040. MODULE_AUTHOR("Pierre Ossman");
  1041. MODULE_LICENSE("GPL");