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