Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  1 /*
  2  *  linux/drivers/net/wireless/libertas/if_sdio.c
  3  *
  4  *  Copyright 2007 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 
 29 #include <linux/moduleparam.h>
 30 #include <linux/firmware.h>
 31 #include <linux/netdevice.h>
 32 #include <linux/delay.h>
 33 #include <linux/mmc/card.h>
 34 #include <linux/mmc/sdio_func.h>
 35 #include <linux/mmc/sdio_ids.h>
 36 
 37 #include "host.h"
 38 #include "decl.h"
 39 #include "defs.h"
 40 #include "dev.h"
 41 #include "if_sdio.h"
 42 
 43 static char *lbs_helper_name = NULL;
 44 module_param_named(helper_name, lbs_helper_name, charp, 0644);
 45 
 46 static char *lbs_fw_name = NULL;
 47 module_param_named(fw_name, lbs_fw_name, charp, 0644);
 48 
 49 static const struct sdio_device_id if_sdio_ids[] = {
 50         { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_LIBERTAS) },
 51         { /* end: all zeroes */                                         },
 52 };
 53 
 54 MODULE_DEVICE_TABLE(sdio, if_sdio_ids);
 55 
 56 struct if_sdio_model {
 57         int model;
 58         const char *helper;
 59         const char *firmware;
 60 };
 61 
 62 static struct if_sdio_model if_sdio_models[] = {
 63         {
 64                 /* 8385 */
 65                 .model = 0x04,
 66                 .helper = "sd8385_helper.bin",
 67                 .firmware = "sd8385.bin",
 68         },
 69         {
 70                 /* 8686 */
 71                 .model = 0x0B,
 72                 .helper = "sd8686_helper.bin",
 73                 .firmware = "sd8686.bin",
 74         },
 75 };
 76 
 77 struct if_sdio_packet {
 78         struct if_sdio_packet   *next;
 79         u16                     nb;
 80         u8                      buffer[0] __attribute__((aligned(4)));
 81 };
 82 
 83 struct if_sdio_card {
 84         struct sdio_func        *func;
 85         struct lbs_private      *priv;
 86 
 87         int                     model;
 88         unsigned long           ioport;
 89 
 90         const char              *helper;
 91         const char              *firmware;
 92 
 93         u8                      buffer[65536];
 94         u8                      int_cause;
 95         u32                     event;
 96 
 97         spinlock_t              lock;
 98         struct if_sdio_packet   *packets;
 99         struct work_struct      packet_worker;
100 };
101 
102 /********************************************************************/
103 /* I/O                                                              */
104 /********************************************************************/
105 
106 static u16 if_sdio_read_scratch(struct if_sdio_card *card, int *err)
107 {
108         int ret, reg;
109         u16 scratch;
110 
111         if (card->model == 0x04)
112                 reg = IF_SDIO_SCRATCH_OLD;
113         else
114                 reg = IF_SDIO_SCRATCH;
115 
116         scratch = sdio_readb(card->func, reg, &ret);
117         if (!ret)
118                 scratch |= sdio_readb(card->func, reg + 1, &ret) << 8;
119 
120         if (err)
121                 *err = ret;
122 
123         if (ret)
124                 return 0xffff;
125 
126         return scratch;
127 }
128 
129 static int if_sdio_handle_cmd(struct if_sdio_card *card,
130                 u8 *buffer, unsigned size)
131 {
132         int ret;
133         unsigned long flags;
134 
135         lbs_deb_enter(LBS_DEB_SDIO);
136 
137         spin_lock_irqsave(&card->priv->driver_lock, flags);
138 
139         if (size > LBS_CMD_BUFFER_SIZE) {
140                 lbs_deb_sdio("response packet too large (%d bytes)\n",
141                         (int)size);
142                 ret = -E2BIG;
143                 goto out;
144         }
145 
146         memcpy(card->priv->upld_buf, buffer, size);
147         card->priv->upld_len = size;
148 
149         card->int_cause |= MRVDRV_CMD_UPLD_RDY;
150 
151         lbs_interrupt(card->priv);
152 
153         ret = 0;
154 
155 out:
156         spin_unlock_irqrestore(&card->priv->driver_lock, flags);
157 
158         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
159 
160         return ret;
161 }
162 
163 static int if_sdio_handle_data(struct if_sdio_card *card,
164                 u8 *buffer, unsigned size)
165 {
166         int ret;
167         struct sk_buff *skb;
168         char *data;
169 
170         lbs_deb_enter(LBS_DEB_SDIO);
171 
172         if (size > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
173                 lbs_deb_sdio("response packet too large (%d bytes)\n",
174                         (int)size);
175                 ret = -E2BIG;
176                 goto out;
177         }
178 
179         skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + NET_IP_ALIGN);
180         if (!skb) {
181                 ret = -ENOMEM;
182                 goto out;
183         }
184 
185         skb_reserve(skb, NET_IP_ALIGN);
186 
187         data = skb_put(skb, size);
188 
189         memcpy(data, buffer, size);
190 
191         lbs_process_rxed_packet(card->priv, skb);
192 
193         ret = 0;
194 
195 out:
196         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
197 
198         return ret;
199 }
200 
201 static int if_sdio_handle_event(struct if_sdio_card *card,
202                 u8 *buffer, unsigned size)
203 {
204         int ret;
205         unsigned long flags;
206         u32 event;
207 
208         lbs_deb_enter(LBS_DEB_SDIO);
209 
210         if (card->model == 0x04) {
211                 event = sdio_readb(card->func, IF_SDIO_EVENT, &ret);
212                 if (ret)
213                         goto out;
214         } else {
215                 if (size < 4) {
216                         lbs_deb_sdio("event packet too small (%d bytes)\n",
217                                 (int)size);
218                         ret = -EINVAL;
219                         goto out;
220                 }
221                 event = buffer[3] << 24;
222                 event |= buffer[2] << 16;
223                 event |= buffer[1] << 8;
224                 event |= buffer[0] << 0;
225                 event <<= SBI_EVENT_CAUSE_SHIFT;
226         }
227 
228         spin_lock_irqsave(&card->priv->driver_lock, flags);
229 
230         card->event = event;
231         card->int_cause |= MRVDRV_CARDEVENT;
232 
233         lbs_interrupt(card->priv);
234 
235         spin_unlock_irqrestore(&card->priv->driver_lock, flags);
236 
237         ret = 0;
238 
239 out:
240         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
241 
242         return ret;
243 }
244 
245 static int if_sdio_card_to_host(struct if_sdio_card *card)
246 {
247         int ret;
248         u8 status;
249         u16 size, type, chunk;
250         unsigned long timeout;
251 
252         lbs_deb_enter(LBS_DEB_SDIO);
253 
254         size = if_sdio_read_scratch(card, &ret);
255         if (ret)
256                 goto out;
257 
258         if (size < 4) {
259                 lbs_deb_sdio("invalid packet size (%d bytes) from firmware\n",
260                         (int)size);
261                 ret = -EINVAL;
262                 goto out;
263         }
264 
265         timeout = jiffies + HZ;
266         while (1) {
267                 status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
268                 if (ret)
269                         goto out;
270                 if (status & IF_SDIO_IO_RDY)
271                         break;
272                 if (time_after(jiffies, timeout)) {
273                         ret = -ETIMEDOUT;
274                         goto out;
275                 }
276                 mdelay(1);
277         }
278 
279         /*
280          * The transfer must be in one transaction or the firmware
281          * goes suicidal.
282          */
283         chunk = size;
284         if ((chunk > card->func->cur_blksize) || (chunk > 512)) {
285                 chunk = (chunk + card->func->cur_blksize - 1) /
286                         card->func->cur_blksize * card->func->cur_blksize;
287         }
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 
334 out:
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 
343 static void if_sdio_host_to_card_worker(struct work_struct *work)
344 {
345         struct if_sdio_card *card;
346         struct if_sdio_packet *packet;
347         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;
386 release:
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 
399 static 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;
407         u8 *firmware;
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 
451                 *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size);
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 
499 release:
500         sdio_set_block_size(card->func, 0);
501         sdio_release_host(card->func);
502         kfree(chunk_buffer);
503 release_fw:
504         release_firmware(fw);
505 
506 out:
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 
515 static 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;
523         u8 *firmware;
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,
599                                 chunk_buffer, (chunk_size + 31) / 32 * 32);
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 
635 release:
636         sdio_set_block_size(card->func, 0);
637         sdio_release_host(card->func);
638         kfree(chunk_buffer);
639 release_fw:
640         release_firmware(fw);
641 
642 out:
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 
651 static 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 
678 success:
679         ret = 0;
680 
681 out:
682         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
683 
684         return ret;
685 }
686 
687 /*******************************************************************/
688 /* Libertas callbacks                                              */
689 /*******************************************************************/
690 
691 static int if_sdio_host_to_card(struct lbs_private *priv,
692                 u8 type, u8 *buf, u16 nb)
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
711          * goes suicidal.
712          */
713         size = nb + 4;
714         if ((size > card->func->cur_blksize) || (size > 512)) {
715                 size = (size + card->func->cur_blksize - 1) /
716                         card->func->cur_blksize * card->func->cur_blksize;
717         }
718 
719         packet = kzalloc(sizeof(struct if_sdio_packet) + size,
720                         GFP_ATOMIC);
721         if (!packet) {
722                 ret = -ENOMEM;
723                 goto out;
724         }
725 
726         packet->next = NULL;
727         packet->nb = size;
728 
729         /*
730          * SDIO specific header.
731          */
732         packet->buffer[0] = (nb + 4) & 0xff;
733         packet->buffer[1] = ((nb + 4) >> 8) & 0xff;
734         packet->buffer[2] = type;
735         packet->buffer[3] = 0;
736 
737         memcpy(packet->buffer + 4, buf, nb);
738 
739         spin_lock_irqsave(&card->lock, flags);
740 
741         if (!card->packets)
742                 card->packets = packet;
743         else {
744                 cur = card->packets;
745                 while (cur->next)
746                         cur = cur->next;
747                 cur->next = packet;
748         }
749 
750         switch (type) {
751         case MVMS_CMD:
752                 priv->dnld_sent = DNLD_CMD_SENT;
753                 break;
754         case MVMS_DAT:
755                 priv->dnld_sent = DNLD_DATA_SENT;
756                 break;
757         default:
758                 lbs_deb_sdio("unknown packet type %d\n", (int)type);
759         }
760 
761         spin_unlock_irqrestore(&card->lock, flags);
762 
763         schedule_work(&card->packet_worker);
764 
765         ret = 0;
766 
767 out:
768         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
769 
770         return ret;
771 }
772 
773 static int if_sdio_get_int_status(struct lbs_private *priv, u8 *ireg)
774 {
775         struct if_sdio_card *card;
776 
777         lbs_deb_enter(LBS_DEB_SDIO);
778 
779         card = priv->card;
780 
781         *ireg = card->int_cause;
782         card->int_cause = 0;
783 
784         lbs_deb_leave(LBS_DEB_SDIO);
785 
786         return 0;
787 }
788 
789 static int if_sdio_read_event_cause(struct lbs_private *priv)
790 {
791         struct if_sdio_card *card;
792 
793         lbs_deb_enter(LBS_DEB_SDIO);
794 
795         card = priv->card;
796 
797         priv->eventcause = card->event;
798 
799         lbs_deb_leave(LBS_DEB_SDIO);
800 
801         return 0;
802 }
803 
804 /*******************************************************************/
805 /* SDIO callbacks                                                  */
806 /*******************************************************************/
807 
808 static void if_sdio_interrupt(struct sdio_func *func)
809 {
810         int ret;
811         struct if_sdio_card *card;
812         u8 cause;
813 
814         lbs_deb_enter(LBS_DEB_SDIO);
815 
816         card = sdio_get_drvdata(func);
817 
818         cause = sdio_readb(card->func, IF_SDIO_H_INT_STATUS, &ret);
819         if (ret)
820                 goto out;
821 
822         lbs_deb_sdio("interrupt: 0x%X\n", (unsigned)cause);
823 
824         sdio_writeb(card->func, ~cause, IF_SDIO_H_INT_STATUS, &ret);
825         if (ret)
826                 goto out;
827 
828         /*
829          * Ignore the define name, this really means the card has
830          * successfully received the command.
831          */
832         if (cause & IF_SDIO_H_INT_DNLD)
833                 lbs_host_to_card_done(card->priv);
834 
835 
836         if (cause & IF_SDIO_H_INT_UPLD) {
837                 ret = if_sdio_card_to_host(card);
838                 if (ret)
839                         goto out;
840         }
841 
842         ret = 0;
843 
844 out:
845         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
846 }
847 
848 static int if_sdio_probe(struct sdio_func *func,
849                 const struct sdio_device_id *id)
850 {
851         struct if_sdio_card *card;
852         struct lbs_private *priv;
853         int ret, i;
854         unsigned int model;
855         struct if_sdio_packet *packet;
856 
857         lbs_deb_enter(LBS_DEB_SDIO);
858 
859         for (i = 0;i < func->card->num_info;i++) {
860                 if (sscanf(func->card->info[i],
861                                 "802.11 SDIO ID: %x", &model) == 1)
862                         break;
863                 if (sscanf(func->card->info[i],
864                                 "ID: %x", &model) == 1)
865                         break;
866                if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) {
867                        model = 4;
868                        break;
869                }
870         }
871 
872         if (i == func->card->num_info) {
873                 lbs_pr_err("unable to identify card model\n");
874                 return -ENODEV;
875         }
876 
877         card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL);
878         if (!card)
879                 return -ENOMEM;
880 
881         card->func = func;
882         card->model = model;
883         spin_lock_init(&card->lock);
884         INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker);
885 
886         for (i = 0;i < ARRAY_SIZE(if_sdio_models);i++) {
887                 if (card->model == if_sdio_models[i].model)
888                         break;
889         }
890 
891         if (i == ARRAY_SIZE(if_sdio_models)) {
892                 lbs_pr_err("unkown card model 0x%x\n", card->model);
893                 ret = -ENODEV;
894                 goto free;
895         }
896 
897         card->helper = if_sdio_models[i].helper;
898         card->firmware = if_sdio_models[i].firmware;
899 
900         if (lbs_helper_name) {
901                 lbs_deb_sdio("overriding helper firmware: %s\n",
902                         lbs_helper_name);
903                 card->helper = lbs_helper_name;
904         }
905 
906         if (lbs_fw_name) {
907                 lbs_deb_sdio("overriding firmware: %s\n", lbs_fw_name);
908                 card->firmware = lbs_fw_name;
909         }
910 
911         sdio_claim_host(func);
912 
913         ret = sdio_enable_func(func);
914         if (ret)
915                 goto release;
916 
917         ret = sdio_claim_irq(func, if_sdio_interrupt);
918         if (ret)
919                 goto disable;
920 
921         card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret);
922         if (ret)
923                 goto release_int;
924 
925         card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8;
926         if (ret)
927                 goto release_int;
928 
929         card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16;
930         if (ret)
931                 goto release_int;
932 
933         sdio_release_host(func);
934 
935         sdio_set_drvdata(func, card);
936 
937         lbs_deb_sdio("class = 0x%X, vendor = 0x%X, "
938                         "device = 0x%X, model = 0x%X, ioport = 0x%X\n",
939                         func->class, func->vendor, func->device,
940                         model, (unsigned)card->ioport);
941 
942         ret = if_sdio_prog_firmware(card);
943         if (ret)
944                 goto reclaim;
945 
946         priv = lbs_add_card(card, &func->dev);
947         if (!priv) {
948                 ret = -ENOMEM;
949                 goto reclaim;
950         }
951 
952         card->priv = priv;
953 
954         priv->card = card;
955         priv->hw_host_to_card = if_sdio_host_to_card;
956         priv->hw_get_int_status = if_sdio_get_int_status;
957         priv->hw_read_event_cause = if_sdio_read_event_cause;
958 
959         priv->fw_ready = 1;
960 
961         /*
962          * Enable interrupts now that everything is set up
963          */
964         sdio_claim_host(func);
965         sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret);
966         sdio_release_host(func);
967         if (ret)
968                 goto reclaim;
969 
970         ret = lbs_start_card(priv);
971         if (ret)
972                 goto err_activate_card;
973 
974 out:
975         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
976 
977         return ret;
978 
979 err_activate_card:
980         flush_scheduled_work();
981         free_netdev(priv->dev);
982         kfree(priv);
983 reclaim:
984         sdio_claim_host(func);
985 release_int:
986         sdio_release_irq(func);
987 disable:
988         sdio_disable_func(func);
989 release:
990         sdio_release_host(func);
991 free:
992         while (card->packets) {
993                 packet = card->packets;
994                 card->packets = card->packets->next;
995                 kfree(packet);
996         }
997 
998         kfree(card);
999 
1000         goto out;
1001 }
1002 
1003 static void if_sdio_remove(struct sdio_func *func)
1004 {
1005         struct if_sdio_card *card;
1006         struct if_sdio_packet *packet;
1007 
1008         lbs_deb_enter(LBS_DEB_SDIO);
1009 
1010         card = sdio_get_drvdata(func);
1011 
1012         card->priv->surpriseremoved = 1;
1013 
1014         lbs_deb_sdio("call remove card\n");
1015         lbs_stop_card(card->priv);
1016         lbs_remove_card(card->priv);
1017 
1018         flush_scheduled_work();
1019 
1020         sdio_claim_host(func);
1021         sdio_release_irq(func);
1022         sdio_disable_func(func);
1023         sdio_release_host(func);
1024 
1025         while (card->packets) {
1026                 packet = card->packets;
1027                 card->packets = card->packets->next;
1028                 kfree(packet);
1029         }
1030 
1031         kfree(card);
1032 
1033         lbs_deb_leave(LBS_DEB_SDIO);
1034 }
1035 
1036 static struct sdio_driver if_sdio_driver = {
1037         .name           = "libertas_sdio",
1038         .id_table       = if_sdio_ids,
1039         .probe          = if_sdio_probe,
1040         .remove         = if_sdio_remove,
1041 };
1042 
1043 /*******************************************************************/
1044 /* Module functions                                                */
1045 /*******************************************************************/
1046 
1047 static int __init if_sdio_init_module(void)
1048 {
1049         int ret = 0;
1050 
1051         lbs_deb_enter(LBS_DEB_SDIO);
1052 
1053         printk(KERN_INFO "libertas_sdio: Libertas SDIO driver\n");
1054         printk(KERN_INFO "libertas_sdio: Copyright Pierre Ossman\n");
1055 
1056         ret = sdio_register_driver(&if_sdio_driver);
1057 
1058         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
1059 
1060         return ret;
1061 }
1062 
1063 static void __exit if_sdio_exit_module(void)
1064 {
1065         lbs_deb_enter(LBS_DEB_SDIO);
1066 
1067         sdio_unregister_driver(&if_sdio_driver);
1068 
1069         lbs_deb_leave(LBS_DEB_SDIO);
1070 }
1071 
1072 module_init(if_sdio_init_module);
1073 module_exit(if_sdio_exit_module);
1074 
1075 MODULE_DESCRIPTION("Libertas SDIO WLAN Driver");
1076 MODULE_AUTHOR("Pierre Ossman");
1077 MODULE_LICENSE("GPL");
1078 
  This page was automatically generated by the LXR engine.