if_sdio.c 32 KB

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