if_sdio.c 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230
  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. u8 buffer[65536];
  116. spinlock_t lock;
  117. struct if_sdio_packet *packets;
  118. struct workqueue_struct *workqueue;
  119. struct work_struct packet_worker;
  120. u8 rx_unit;
  121. };
  122. /********************************************************************/
  123. /* I/O */
  124. /********************************************************************/
  125. /*
  126. * For SD8385/SD8686, this function reads firmware status after
  127. * the image is downloaded, or reads RX packet length when
  128. * interrupt (with IF_SDIO_H_INT_UPLD bit set) is received.
  129. * For SD8688, this function reads firmware status only.
  130. */
  131. static u16 if_sdio_read_scratch(struct if_sdio_card *card, int *err)
  132. {
  133. int ret;
  134. u16 scratch;
  135. scratch = sdio_readb(card->func, card->scratch_reg, &ret);
  136. if (!ret)
  137. scratch |= sdio_readb(card->func, card->scratch_reg + 1,
  138. &ret) << 8;
  139. if (err)
  140. *err = ret;
  141. if (ret)
  142. return 0xffff;
  143. return scratch;
  144. }
  145. static u8 if_sdio_read_rx_unit(struct if_sdio_card *card)
  146. {
  147. int ret;
  148. u8 rx_unit;
  149. rx_unit = sdio_readb(card->func, IF_SDIO_RX_UNIT, &ret);
  150. if (ret)
  151. rx_unit = 0;
  152. return rx_unit;
  153. }
  154. static u16 if_sdio_read_rx_len(struct if_sdio_card *card, int *err)
  155. {
  156. int ret;
  157. u16 rx_len;
  158. switch (card->model) {
  159. case IF_SDIO_MODEL_8385:
  160. case IF_SDIO_MODEL_8686:
  161. rx_len = if_sdio_read_scratch(card, &ret);
  162. break;
  163. case IF_SDIO_MODEL_8688:
  164. default: /* for newer chipsets */
  165. rx_len = sdio_readb(card->func, IF_SDIO_RX_LEN, &ret);
  166. if (!ret)
  167. rx_len <<= card->rx_unit;
  168. else
  169. rx_len = 0xffff; /* invalid length */
  170. break;
  171. }
  172. if (err)
  173. *err = ret;
  174. return rx_len;
  175. }
  176. static int if_sdio_handle_cmd(struct if_sdio_card *card,
  177. u8 *buffer, unsigned size)
  178. {
  179. struct lbs_private *priv = card->priv;
  180. int ret;
  181. unsigned long flags;
  182. u8 i;
  183. lbs_deb_enter(LBS_DEB_SDIO);
  184. if (size > LBS_CMD_BUFFER_SIZE) {
  185. lbs_deb_sdio("response packet too large (%d bytes)\n",
  186. (int)size);
  187. ret = -E2BIG;
  188. goto out;
  189. }
  190. spin_lock_irqsave(&priv->driver_lock, flags);
  191. i = (priv->resp_idx == 0) ? 1 : 0;
  192. BUG_ON(priv->resp_len[i]);
  193. priv->resp_len[i] = size;
  194. memcpy(priv->resp_buf[i], buffer, size);
  195. lbs_notify_command_response(priv, i);
  196. spin_unlock_irqrestore(&card->priv->driver_lock, flags);
  197. ret = 0;
  198. out:
  199. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  200. return ret;
  201. }
  202. static int if_sdio_handle_data(struct if_sdio_card *card,
  203. u8 *buffer, unsigned size)
  204. {
  205. int ret;
  206. struct sk_buff *skb;
  207. char *data;
  208. lbs_deb_enter(LBS_DEB_SDIO);
  209. if (size > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
  210. lbs_deb_sdio("response packet too large (%d bytes)\n",
  211. (int)size);
  212. ret = -E2BIG;
  213. goto out;
  214. }
  215. skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + NET_IP_ALIGN);
  216. if (!skb) {
  217. ret = -ENOMEM;
  218. goto out;
  219. }
  220. skb_reserve(skb, NET_IP_ALIGN);
  221. data = skb_put(skb, size);
  222. memcpy(data, buffer, size);
  223. lbs_process_rxed_packet(card->priv, skb);
  224. ret = 0;
  225. out:
  226. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  227. return ret;
  228. }
  229. static int if_sdio_handle_event(struct if_sdio_card *card,
  230. u8 *buffer, unsigned size)
  231. {
  232. int ret;
  233. u32 event;
  234. lbs_deb_enter(LBS_DEB_SDIO);
  235. if (card->model == IF_SDIO_MODEL_8385) {
  236. event = sdio_readb(card->func, IF_SDIO_EVENT, &ret);
  237. if (ret)
  238. goto out;
  239. /* right shift 3 bits to get the event id */
  240. event >>= 3;
  241. } else {
  242. if (size < 4) {
  243. lbs_deb_sdio("event packet too small (%d bytes)\n",
  244. (int)size);
  245. ret = -EINVAL;
  246. goto out;
  247. }
  248. event = buffer[3] << 24;
  249. event |= buffer[2] << 16;
  250. event |= buffer[1] << 8;
  251. event |= buffer[0] << 0;
  252. }
  253. lbs_queue_event(card->priv, event & 0xFF);
  254. ret = 0;
  255. out:
  256. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  257. return ret;
  258. }
  259. static int if_sdio_wait_status(struct if_sdio_card *card, const u8 condition)
  260. {
  261. u8 status;
  262. unsigned long timeout;
  263. int ret = 0;
  264. timeout = jiffies + HZ;
  265. while (1) {
  266. status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
  267. if (ret || (status & condition))
  268. break;
  269. if (time_after(jiffies, timeout))
  270. return -ETIMEDOUT;
  271. mdelay(1);
  272. }
  273. return ret;
  274. }
  275. static int if_sdio_card_to_host(struct if_sdio_card *card)
  276. {
  277. int ret;
  278. u16 size, type, chunk;
  279. lbs_deb_enter(LBS_DEB_SDIO);
  280. size = if_sdio_read_rx_len(card, &ret);
  281. if (ret)
  282. goto out;
  283. if (size < 4) {
  284. lbs_deb_sdio("invalid packet size (%d bytes) from firmware\n",
  285. (int)size);
  286. ret = -EINVAL;
  287. goto out;
  288. }
  289. ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY);
  290. if (ret)
  291. goto out;
  292. /*
  293. * The transfer must be in one transaction or the firmware
  294. * goes suicidal. There's no way to guarantee that for all
  295. * controllers, but we can at least try.
  296. */
  297. chunk = sdio_align_size(card->func, size);
  298. ret = sdio_readsb(card->func, card->buffer, card->ioport, chunk);
  299. if (ret)
  300. goto out;
  301. chunk = card->buffer[0] | (card->buffer[1] << 8);
  302. type = card->buffer[2] | (card->buffer[3] << 8);
  303. lbs_deb_sdio("packet of type %d and size %d bytes\n",
  304. (int)type, (int)chunk);
  305. if (chunk > size) {
  306. lbs_deb_sdio("packet fragment (%d > %d)\n",
  307. (int)chunk, (int)size);
  308. ret = -EINVAL;
  309. goto out;
  310. }
  311. if (chunk < size) {
  312. lbs_deb_sdio("packet fragment (%d < %d)\n",
  313. (int)chunk, (int)size);
  314. }
  315. switch (type) {
  316. case MVMS_CMD:
  317. ret = if_sdio_handle_cmd(card, card->buffer + 4, chunk - 4);
  318. if (ret)
  319. goto out;
  320. break;
  321. case MVMS_DAT:
  322. ret = if_sdio_handle_data(card, card->buffer + 4, chunk - 4);
  323. if (ret)
  324. goto out;
  325. break;
  326. case MVMS_EVENT:
  327. ret = if_sdio_handle_event(card, card->buffer + 4, chunk - 4);
  328. if (ret)
  329. goto out;
  330. break;
  331. default:
  332. lbs_deb_sdio("invalid type (%d) from firmware\n",
  333. (int)type);
  334. ret = -EINVAL;
  335. goto out;
  336. }
  337. out:
  338. if (ret)
  339. lbs_pr_err("problem fetching packet from firmware\n");
  340. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  341. return ret;
  342. }
  343. static void if_sdio_host_to_card_worker(struct work_struct *work)
  344. {
  345. struct if_sdio_card *card;
  346. struct if_sdio_packet *packet;
  347. int ret;
  348. unsigned long flags;
  349. lbs_deb_enter(LBS_DEB_SDIO);
  350. card = container_of(work, struct if_sdio_card, packet_worker);
  351. while (1) {
  352. spin_lock_irqsave(&card->lock, flags);
  353. packet = card->packets;
  354. if (packet)
  355. card->packets = packet->next;
  356. spin_unlock_irqrestore(&card->lock, flags);
  357. if (!packet)
  358. break;
  359. sdio_claim_host(card->func);
  360. ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY);
  361. if (ret == 0) {
  362. ret = sdio_writesb(card->func, card->ioport,
  363. packet->buffer, packet->nb);
  364. }
  365. if (ret)
  366. lbs_pr_err("error %d sending packet to firmware\n", ret);
  367. sdio_release_host(card->func);
  368. kfree(packet);
  369. }
  370. lbs_deb_leave(LBS_DEB_SDIO);
  371. }
  372. /********************************************************************/
  373. /* Firmware */
  374. /********************************************************************/
  375. #define FW_DL_READY_STATUS (IF_SDIO_IO_RDY | IF_SDIO_DL_RDY)
  376. static int if_sdio_prog_helper(struct if_sdio_card *card)
  377. {
  378. int ret;
  379. const struct firmware *fw;
  380. unsigned long timeout;
  381. u8 *chunk_buffer;
  382. u32 chunk_size;
  383. const u8 *firmware;
  384. size_t size;
  385. lbs_deb_enter(LBS_DEB_SDIO);
  386. ret = request_firmware(&fw, card->helper, &card->func->dev);
  387. if (ret) {
  388. lbs_pr_err("can't load helper firmware\n");
  389. goto out;
  390. }
  391. chunk_buffer = kzalloc(64, GFP_KERNEL);
  392. if (!chunk_buffer) {
  393. ret = -ENOMEM;
  394. goto release_fw;
  395. }
  396. sdio_claim_host(card->func);
  397. ret = sdio_set_block_size(card->func, 32);
  398. if (ret)
  399. goto release;
  400. firmware = fw->data;
  401. size = fw->size;
  402. while (size) {
  403. ret = if_sdio_wait_status(card, FW_DL_READY_STATUS);
  404. if (ret)
  405. goto release;
  406. /* On some platforms (like Davinci) the chip needs more time
  407. * between helper blocks.
  408. */
  409. mdelay(2);
  410. chunk_size = min(size, (size_t)60);
  411. *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size);
  412. memcpy(chunk_buffer + 4, firmware, chunk_size);
  413. /*
  414. lbs_deb_sdio("sending %d bytes chunk\n", chunk_size);
  415. */
  416. ret = sdio_writesb(card->func, card->ioport,
  417. chunk_buffer, 64);
  418. if (ret)
  419. goto release;
  420. firmware += chunk_size;
  421. size -= chunk_size;
  422. }
  423. /* an empty block marks the end of the transfer */
  424. memset(chunk_buffer, 0, 4);
  425. ret = sdio_writesb(card->func, card->ioport, chunk_buffer, 64);
  426. if (ret)
  427. goto release;
  428. lbs_deb_sdio("waiting for helper to boot...\n");
  429. /* wait for the helper to boot by looking at the size register */
  430. timeout = jiffies + HZ;
  431. while (1) {
  432. u16 req_size;
  433. req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);
  434. if (ret)
  435. goto release;
  436. req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;
  437. if (ret)
  438. goto release;
  439. if (req_size != 0)
  440. break;
  441. if (time_after(jiffies, timeout)) {
  442. ret = -ETIMEDOUT;
  443. goto release;
  444. }
  445. msleep(10);
  446. }
  447. ret = 0;
  448. release:
  449. sdio_release_host(card->func);
  450. kfree(chunk_buffer);
  451. release_fw:
  452. release_firmware(fw);
  453. out:
  454. if (ret)
  455. lbs_pr_err("failed to load helper firmware\n");
  456. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  457. return ret;
  458. }
  459. static int if_sdio_prog_real(struct if_sdio_card *card)
  460. {
  461. int ret;
  462. const struct firmware *fw;
  463. unsigned long timeout;
  464. u8 *chunk_buffer;
  465. u32 chunk_size;
  466. const u8 *firmware;
  467. size_t size, req_size;
  468. lbs_deb_enter(LBS_DEB_SDIO);
  469. ret = request_firmware(&fw, card->firmware, &card->func->dev);
  470. if (ret) {
  471. lbs_pr_err("can't load firmware\n");
  472. goto out;
  473. }
  474. chunk_buffer = kzalloc(512, GFP_KERNEL);
  475. if (!chunk_buffer) {
  476. ret = -ENOMEM;
  477. goto release_fw;
  478. }
  479. sdio_claim_host(card->func);
  480. ret = sdio_set_block_size(card->func, 32);
  481. if (ret)
  482. goto release;
  483. firmware = fw->data;
  484. size = fw->size;
  485. while (size) {
  486. ret = if_sdio_wait_status(card, FW_DL_READY_STATUS);
  487. if (ret)
  488. goto release;
  489. req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);
  490. if (ret)
  491. goto release;
  492. req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;
  493. if (ret)
  494. goto release;
  495. /*
  496. lbs_deb_sdio("firmware wants %d bytes\n", (int)req_size);
  497. */
  498. if (req_size == 0) {
  499. lbs_deb_sdio("firmware helper gave up early\n");
  500. ret = -EIO;
  501. goto release;
  502. }
  503. if (req_size & 0x01) {
  504. lbs_deb_sdio("firmware helper signalled error\n");
  505. ret = -EIO;
  506. goto release;
  507. }
  508. if (req_size > size)
  509. req_size = size;
  510. while (req_size) {
  511. chunk_size = min(req_size, (size_t)512);
  512. memcpy(chunk_buffer, firmware, chunk_size);
  513. /*
  514. lbs_deb_sdio("sending %d bytes (%d bytes) chunk\n",
  515. chunk_size, (chunk_size + 31) / 32 * 32);
  516. */
  517. ret = sdio_writesb(card->func, card->ioport,
  518. chunk_buffer, roundup(chunk_size, 32));
  519. if (ret)
  520. goto release;
  521. firmware += chunk_size;
  522. size -= chunk_size;
  523. req_size -= chunk_size;
  524. }
  525. }
  526. ret = 0;
  527. lbs_deb_sdio("waiting for firmware to boot...\n");
  528. /* wait for the firmware to boot */
  529. timeout = jiffies + HZ;
  530. while (1) {
  531. u16 scratch;
  532. scratch = if_sdio_read_scratch(card, &ret);
  533. if (ret)
  534. goto release;
  535. if (scratch == IF_SDIO_FIRMWARE_OK)
  536. break;
  537. if (time_after(jiffies, timeout)) {
  538. ret = -ETIMEDOUT;
  539. goto release;
  540. }
  541. msleep(10);
  542. }
  543. ret = 0;
  544. release:
  545. sdio_release_host(card->func);
  546. kfree(chunk_buffer);
  547. release_fw:
  548. release_firmware(fw);
  549. out:
  550. if (ret)
  551. lbs_pr_err("failed to load firmware\n");
  552. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  553. return ret;
  554. }
  555. static int if_sdio_prog_firmware(struct if_sdio_card *card)
  556. {
  557. int ret;
  558. u16 scratch;
  559. lbs_deb_enter(LBS_DEB_SDIO);
  560. sdio_claim_host(card->func);
  561. scratch = if_sdio_read_scratch(card, &ret);
  562. sdio_release_host(card->func);
  563. if (ret)
  564. goto out;
  565. lbs_deb_sdio("firmware status = %#x\n", scratch);
  566. if (scratch == IF_SDIO_FIRMWARE_OK) {
  567. lbs_deb_sdio("firmware already loaded\n");
  568. goto success;
  569. }
  570. ret = if_sdio_prog_helper(card);
  571. if (ret)
  572. goto out;
  573. ret = if_sdio_prog_real(card);
  574. if (ret)
  575. goto out;
  576. success:
  577. sdio_claim_host(card->func);
  578. sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE);
  579. sdio_release_host(card->func);
  580. ret = 0;
  581. out:
  582. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  583. return ret;
  584. }
  585. /*******************************************************************/
  586. /* Libertas callbacks */
  587. /*******************************************************************/
  588. static int if_sdio_host_to_card(struct lbs_private *priv,
  589. u8 type, u8 *buf, u16 nb)
  590. {
  591. int ret;
  592. struct if_sdio_card *card;
  593. struct if_sdio_packet *packet, *cur;
  594. u16 size;
  595. unsigned long flags;
  596. lbs_deb_enter_args(LBS_DEB_SDIO, "type %d, bytes %d", type, nb);
  597. card = priv->card;
  598. if (nb > (65536 - sizeof(struct if_sdio_packet) - 4)) {
  599. ret = -EINVAL;
  600. goto out;
  601. }
  602. /*
  603. * The transfer must be in one transaction or the firmware
  604. * goes suicidal. There's no way to guarantee that for all
  605. * controllers, but we can at least try.
  606. */
  607. size = sdio_align_size(card->func, nb + 4);
  608. packet = kzalloc(sizeof(struct if_sdio_packet) + size,
  609. GFP_ATOMIC);
  610. if (!packet) {
  611. ret = -ENOMEM;
  612. goto out;
  613. }
  614. packet->next = NULL;
  615. packet->nb = size;
  616. /*
  617. * SDIO specific header.
  618. */
  619. packet->buffer[0] = (nb + 4) & 0xff;
  620. packet->buffer[1] = ((nb + 4) >> 8) & 0xff;
  621. packet->buffer[2] = type;
  622. packet->buffer[3] = 0;
  623. memcpy(packet->buffer + 4, buf, nb);
  624. spin_lock_irqsave(&card->lock, flags);
  625. if (!card->packets)
  626. card->packets = packet;
  627. else {
  628. cur = card->packets;
  629. while (cur->next)
  630. cur = cur->next;
  631. cur->next = packet;
  632. }
  633. switch (type) {
  634. case MVMS_CMD:
  635. priv->dnld_sent = DNLD_CMD_SENT;
  636. break;
  637. case MVMS_DAT:
  638. priv->dnld_sent = DNLD_DATA_SENT;
  639. break;
  640. default:
  641. lbs_deb_sdio("unknown packet type %d\n", (int)type);
  642. }
  643. spin_unlock_irqrestore(&card->lock, flags);
  644. queue_work(card->workqueue, &card->packet_worker);
  645. ret = 0;
  646. out:
  647. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  648. return ret;
  649. }
  650. static int if_sdio_enter_deep_sleep(struct lbs_private *priv)
  651. {
  652. int ret = -1;
  653. struct cmd_header cmd;
  654. memset(&cmd, 0, sizeof(cmd));
  655. lbs_deb_sdio("send DEEP_SLEEP command\n");
  656. ret = __lbs_cmd(priv, CMD_802_11_DEEP_SLEEP, &cmd, sizeof(cmd),
  657. lbs_cmd_copyback, (unsigned long) &cmd);
  658. if (ret)
  659. lbs_pr_err("DEEP_SLEEP cmd failed\n");
  660. mdelay(200);
  661. return ret;
  662. }
  663. static int if_sdio_exit_deep_sleep(struct lbs_private *priv)
  664. {
  665. struct if_sdio_card *card = priv->card;
  666. int ret = -1;
  667. lbs_deb_enter(LBS_DEB_SDIO);
  668. sdio_claim_host(card->func);
  669. sdio_writeb(card->func, HOST_POWER_UP, CONFIGURATION_REG, &ret);
  670. if (ret)
  671. lbs_pr_err("sdio_writeb failed!\n");
  672. sdio_release_host(card->func);
  673. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  674. return ret;
  675. }
  676. static int if_sdio_reset_deep_sleep_wakeup(struct lbs_private *priv)
  677. {
  678. struct if_sdio_card *card = priv->card;
  679. int ret = -1;
  680. lbs_deb_enter(LBS_DEB_SDIO);
  681. sdio_claim_host(card->func);
  682. sdio_writeb(card->func, 0, CONFIGURATION_REG, &ret);
  683. if (ret)
  684. lbs_pr_err("sdio_writeb failed!\n");
  685. sdio_release_host(card->func);
  686. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  687. return ret;
  688. }
  689. /*******************************************************************/
  690. /* SDIO callbacks */
  691. /*******************************************************************/
  692. static void if_sdio_interrupt(struct sdio_func *func)
  693. {
  694. int ret;
  695. struct if_sdio_card *card;
  696. u8 cause;
  697. lbs_deb_enter(LBS_DEB_SDIO);
  698. card = sdio_get_drvdata(func);
  699. cause = sdio_readb(card->func, IF_SDIO_H_INT_STATUS, &ret);
  700. if (ret)
  701. goto out;
  702. lbs_deb_sdio("interrupt: 0x%X\n", (unsigned)cause);
  703. sdio_writeb(card->func, ~cause, IF_SDIO_H_INT_STATUS, &ret);
  704. if (ret)
  705. goto out;
  706. /*
  707. * Ignore the define name, this really means the card has
  708. * successfully received the command.
  709. */
  710. card->priv->is_activity_detected = 1;
  711. if (cause & IF_SDIO_H_INT_DNLD)
  712. lbs_host_to_card_done(card->priv);
  713. if (cause & IF_SDIO_H_INT_UPLD) {
  714. ret = if_sdio_card_to_host(card);
  715. if (ret)
  716. goto out;
  717. }
  718. ret = 0;
  719. out:
  720. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  721. }
  722. static int if_sdio_probe(struct sdio_func *func,
  723. const struct sdio_device_id *id)
  724. {
  725. struct if_sdio_card *card;
  726. struct lbs_private *priv;
  727. int ret, i;
  728. unsigned int model;
  729. struct if_sdio_packet *packet;
  730. struct mmc_host *host = func->card->host;
  731. lbs_deb_enter(LBS_DEB_SDIO);
  732. for (i = 0;i < func->card->num_info;i++) {
  733. if (sscanf(func->card->info[i],
  734. "802.11 SDIO ID: %x", &model) == 1)
  735. break;
  736. if (sscanf(func->card->info[i],
  737. "ID: %x", &model) == 1)
  738. break;
  739. if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) {
  740. model = IF_SDIO_MODEL_8385;
  741. break;
  742. }
  743. }
  744. if (i == func->card->num_info) {
  745. lbs_pr_err("unable to identify card model\n");
  746. return -ENODEV;
  747. }
  748. card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL);
  749. if (!card)
  750. return -ENOMEM;
  751. card->func = func;
  752. card->model = model;
  753. switch (card->model) {
  754. case IF_SDIO_MODEL_8385:
  755. card->scratch_reg = IF_SDIO_SCRATCH_OLD;
  756. break;
  757. case IF_SDIO_MODEL_8686:
  758. card->scratch_reg = IF_SDIO_SCRATCH;
  759. break;
  760. case IF_SDIO_MODEL_8688:
  761. default: /* for newer chipsets */
  762. card->scratch_reg = IF_SDIO_FW_STATUS;
  763. break;
  764. }
  765. spin_lock_init(&card->lock);
  766. card->workqueue = create_workqueue("libertas_sdio");
  767. INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker);
  768. for (i = 0;i < ARRAY_SIZE(if_sdio_models);i++) {
  769. if (card->model == if_sdio_models[i].model)
  770. break;
  771. }
  772. if (i == ARRAY_SIZE(if_sdio_models)) {
  773. lbs_pr_err("unknown card model 0x%x\n", card->model);
  774. ret = -ENODEV;
  775. goto free;
  776. }
  777. card->helper = if_sdio_models[i].helper;
  778. card->firmware = if_sdio_models[i].firmware;
  779. if (lbs_helper_name) {
  780. lbs_deb_sdio("overriding helper firmware: %s\n",
  781. lbs_helper_name);
  782. card->helper = lbs_helper_name;
  783. }
  784. if (lbs_fw_name) {
  785. lbs_deb_sdio("overriding firmware: %s\n", lbs_fw_name);
  786. card->firmware = lbs_fw_name;
  787. }
  788. sdio_claim_host(func);
  789. ret = sdio_enable_func(func);
  790. if (ret)
  791. goto release;
  792. ret = sdio_claim_irq(func, if_sdio_interrupt);
  793. if (ret)
  794. goto disable;
  795. /* For 1-bit transfers to the 8686 model, we need to enable the
  796. * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0
  797. * bit to allow access to non-vendor registers. */
  798. if ((card->model == IF_SDIO_MODEL_8686) &&
  799. (host->caps & MMC_CAP_SDIO_IRQ) &&
  800. (host->ios.bus_width == MMC_BUS_WIDTH_1)) {
  801. u8 reg;
  802. func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
  803. reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret);
  804. if (ret)
  805. goto release_int;
  806. reg |= SDIO_BUS_ECSI;
  807. sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret);
  808. if (ret)
  809. goto release_int;
  810. }
  811. card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret);
  812. if (ret)
  813. goto release_int;
  814. card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8;
  815. if (ret)
  816. goto release_int;
  817. card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16;
  818. if (ret)
  819. goto release_int;
  820. sdio_release_host(func);
  821. sdio_set_drvdata(func, card);
  822. lbs_deb_sdio("class = 0x%X, vendor = 0x%X, "
  823. "device = 0x%X, model = 0x%X, ioport = 0x%X\n",
  824. func->class, func->vendor, func->device,
  825. model, (unsigned)card->ioport);
  826. ret = if_sdio_prog_firmware(card);
  827. if (ret)
  828. goto reclaim;
  829. priv = lbs_add_card(card, &func->dev);
  830. if (!priv) {
  831. ret = -ENOMEM;
  832. goto reclaim;
  833. }
  834. card->priv = priv;
  835. priv->card = card;
  836. priv->hw_host_to_card = if_sdio_host_to_card;
  837. priv->enter_deep_sleep = if_sdio_enter_deep_sleep;
  838. priv->exit_deep_sleep = if_sdio_exit_deep_sleep;
  839. priv->reset_deep_sleep_wakeup = if_sdio_reset_deep_sleep_wakeup;
  840. priv->fw_ready = 1;
  841. sdio_claim_host(func);
  842. /*
  843. * Get rx_unit if the chip is SD8688 or newer.
  844. * SD8385 & SD8686 do not have rx_unit.
  845. */
  846. if ((card->model != IF_SDIO_MODEL_8385)
  847. && (card->model != IF_SDIO_MODEL_8686))
  848. card->rx_unit = if_sdio_read_rx_unit(card);
  849. else
  850. card->rx_unit = 0;
  851. /*
  852. * Enable interrupts now that everything is set up
  853. */
  854. sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret);
  855. sdio_release_host(func);
  856. if (ret)
  857. goto reclaim;
  858. /*
  859. * FUNC_INIT is required for SD8688 WLAN/BT multiple functions
  860. */
  861. if (card->model == IF_SDIO_MODEL_8688) {
  862. struct cmd_header cmd;
  863. memset(&cmd, 0, sizeof(cmd));
  864. lbs_deb_sdio("send function INIT command\n");
  865. if (__lbs_cmd(priv, CMD_FUNC_INIT, &cmd, sizeof(cmd),
  866. lbs_cmd_copyback, (unsigned long) &cmd))
  867. lbs_pr_alert("CMD_FUNC_INIT cmd failed\n");
  868. }
  869. ret = lbs_start_card(priv);
  870. if (ret)
  871. goto err_activate_card;
  872. out:
  873. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  874. return ret;
  875. err_activate_card:
  876. flush_workqueue(card->workqueue);
  877. lbs_remove_card(priv);
  878. reclaim:
  879. sdio_claim_host(func);
  880. release_int:
  881. sdio_release_irq(func);
  882. disable:
  883. sdio_disable_func(func);
  884. release:
  885. sdio_release_host(func);
  886. free:
  887. destroy_workqueue(card->workqueue);
  888. while (card->packets) {
  889. packet = card->packets;
  890. card->packets = card->packets->next;
  891. kfree(packet);
  892. }
  893. kfree(card);
  894. goto out;
  895. }
  896. static void if_sdio_remove(struct sdio_func *func)
  897. {
  898. struct if_sdio_card *card;
  899. struct if_sdio_packet *packet;
  900. lbs_deb_enter(LBS_DEB_SDIO);
  901. card = sdio_get_drvdata(func);
  902. if (user_rmmod && (card->model == IF_SDIO_MODEL_8688)) {
  903. /*
  904. * FUNC_SHUTDOWN is required for SD8688 WLAN/BT
  905. * multiple functions
  906. */
  907. struct cmd_header cmd;
  908. memset(&cmd, 0, sizeof(cmd));
  909. lbs_deb_sdio("send function SHUTDOWN command\n");
  910. if (__lbs_cmd(card->priv, CMD_FUNC_SHUTDOWN,
  911. &cmd, sizeof(cmd), lbs_cmd_copyback,
  912. (unsigned long) &cmd))
  913. lbs_pr_alert("CMD_FUNC_SHUTDOWN cmd failed\n");
  914. }
  915. lbs_deb_sdio("call remove card\n");
  916. lbs_stop_card(card->priv);
  917. lbs_remove_card(card->priv);
  918. card->priv->surpriseremoved = 1;
  919. flush_workqueue(card->workqueue);
  920. destroy_workqueue(card->workqueue);
  921. sdio_claim_host(func);
  922. sdio_release_irq(func);
  923. sdio_disable_func(func);
  924. sdio_release_host(func);
  925. while (card->packets) {
  926. packet = card->packets;
  927. card->packets = card->packets->next;
  928. kfree(packet);
  929. }
  930. kfree(card);
  931. lbs_deb_leave(LBS_DEB_SDIO);
  932. }
  933. static struct sdio_driver if_sdio_driver = {
  934. .name = "libertas_sdio",
  935. .id_table = if_sdio_ids,
  936. .probe = if_sdio_probe,
  937. .remove = if_sdio_remove,
  938. };
  939. /*******************************************************************/
  940. /* Module functions */
  941. /*******************************************************************/
  942. static int __init if_sdio_init_module(void)
  943. {
  944. int ret = 0;
  945. lbs_deb_enter(LBS_DEB_SDIO);
  946. printk(KERN_INFO "libertas_sdio: Libertas SDIO driver\n");
  947. printk(KERN_INFO "libertas_sdio: Copyright Pierre Ossman\n");
  948. ret = sdio_register_driver(&if_sdio_driver);
  949. /* Clear the flag in case user removes the card. */
  950. user_rmmod = 0;
  951. lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
  952. return ret;
  953. }
  954. static void __exit if_sdio_exit_module(void)
  955. {
  956. lbs_deb_enter(LBS_DEB_SDIO);
  957. /* Set the flag as user is removing this module. */
  958. user_rmmod = 1;
  959. sdio_unregister_driver(&if_sdio_driver);
  960. lbs_deb_leave(LBS_DEB_SDIO);
  961. }
  962. module_init(if_sdio_init_module);
  963. module_exit(if_sdio_exit_module);
  964. MODULE_DESCRIPTION("Libertas SDIO WLAN Driver");
  965. MODULE_AUTHOR("Pierre Ossman");
  966. MODULE_LICENSE("GPL");