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