pcmcia: convert pcmcia_request_configuration to pcmcia_enable_device
[linux-2.6.git] / drivers / net / wireless / libertas / if_cs.c
1 /*
2
3   Driver for the Marvell 8385 based compact flash WLAN cards.
4
5   (C) 2007 by Holger Schurig <hs4233@mail.mn-solutions.de>
6
7   This program is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 2 of the License, or
10   (at your option) any later version.
11
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program; see the file COPYING.  If not, write to
19   the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
20   Boston, MA 02110-1301, USA.
21
22 */
23
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/delay.h>
27 #include <linux/moduleparam.h>
28 #include <linux/firmware.h>
29 #include <linux/netdevice.h>
30
31 #include <pcmcia/cistpl.h>
32 #include <pcmcia/ds.h>
33
34 #include <linux/io.h>
35
36 #define DRV_NAME "libertas_cs"
37
38 #include "decl.h"
39 #include "defs.h"
40 #include "dev.h"
41
42
43 /********************************************************************/
44 /* Module stuff                                                     */
45 /********************************************************************/
46
47 MODULE_AUTHOR("Holger Schurig <hs4233@mail.mn-solutions.de>");
48 MODULE_DESCRIPTION("Driver for Marvell 83xx compact flash WLAN cards");
49 MODULE_LICENSE("GPL");
50 MODULE_FIRMWARE("libertas_cs_helper.fw");
51
52
53
54 /********************************************************************/
55 /* Data structures                                                  */
56 /********************************************************************/
57
58 struct if_cs_card {
59         struct pcmcia_device *p_dev;
60         struct lbs_private *priv;
61         void __iomem *iobase;
62         bool align_regs;
63 };
64
65
66
67 /********************************************************************/
68 /* Hardware access                                                  */
69 /********************************************************************/
70
71 /* This define enables wrapper functions which allow you
72    to dump all register accesses. You normally won't this,
73    except for development */
74 /* #define DEBUG_IO */
75
76 #ifdef DEBUG_IO
77 static int debug_output = 0;
78 #else
79 /* This way the compiler optimizes the printk's away */
80 #define debug_output 0
81 #endif
82
83 static inline unsigned int if_cs_read8(struct if_cs_card *card, uint reg)
84 {
85         unsigned int val = ioread8(card->iobase + reg);
86         if (debug_output)
87                 printk(KERN_INFO "inb %08x<%02x\n", reg, val);
88         return val;
89 }
90 static inline unsigned int if_cs_read16(struct if_cs_card *card, uint reg)
91 {
92         unsigned int val = ioread16(card->iobase + reg);
93         if (debug_output)
94                 printk(KERN_INFO "inw %08x<%04x\n", reg, val);
95         return val;
96 }
97 static inline void if_cs_read16_rep(
98         struct if_cs_card *card,
99         uint reg,
100         void *buf,
101         unsigned long count)
102 {
103         if (debug_output)
104                 printk(KERN_INFO "insw %08x<(0x%lx words)\n",
105                         reg, count);
106         ioread16_rep(card->iobase + reg, buf, count);
107 }
108
109 static inline void if_cs_write8(struct if_cs_card *card, uint reg, u8 val)
110 {
111         if (debug_output)
112                 printk(KERN_INFO "outb %08x>%02x\n", reg, val);
113         iowrite8(val, card->iobase + reg);
114 }
115
116 static inline void if_cs_write16(struct if_cs_card *card, uint reg, u16 val)
117 {
118         if (debug_output)
119                 printk(KERN_INFO "outw %08x>%04x\n", reg, val);
120         iowrite16(val, card->iobase + reg);
121 }
122
123 static inline void if_cs_write16_rep(
124         struct if_cs_card *card,
125         uint reg,
126         const void *buf,
127         unsigned long count)
128 {
129         if (debug_output)
130                 printk(KERN_INFO "outsw %08x>(0x%lx words)\n",
131                         reg, count);
132         iowrite16_rep(card->iobase + reg, buf, count);
133 }
134
135
136 /*
137  * I know that polling/delaying is frowned upon. However, this procedure
138  * with polling is needed while downloading the firmware. At this stage,
139  * the hardware does unfortunately not create any interrupts.
140  *
141  * Fortunately, this function is never used once the firmware is in
142  * the card. :-)
143  *
144  * As a reference, see the "Firmware Specification v5.1", page 18
145  * and 19. I did not follow their suggested timing to the word,
146  * but this works nice & fast anyway.
147  */
148 static int if_cs_poll_while_fw_download(struct if_cs_card *card, uint addr, u8 reg)
149 {
150         int i;
151
152         for (i = 0; i < 100000; i++) {
153                 u8 val = if_cs_read8(card, addr);
154                 if (val == reg)
155                         return 0;
156                 udelay(5);
157         }
158         return -ETIME;
159 }
160
161
162
163 /*
164  * First the bitmasks for the host/card interrupt/status registers:
165  */
166 #define IF_CS_BIT_TX                    0x0001
167 #define IF_CS_BIT_RX                    0x0002
168 #define IF_CS_BIT_COMMAND               0x0004
169 #define IF_CS_BIT_RESP                  0x0008
170 #define IF_CS_BIT_EVENT                 0x0010
171 #define IF_CS_BIT_MASK                  0x001f
172
173
174
175 /*
176  * It's not really clear to me what the host status register is for. It
177  * needs to be set almost in union with "host int cause". The following
178  * bits from above are used:
179  *
180  *   IF_CS_BIT_TX         driver downloaded a data packet
181  *   IF_CS_BIT_RX         driver got a data packet
182  *   IF_CS_BIT_COMMAND    driver downloaded a command
183  *   IF_CS_BIT_RESP       not used (has some meaning with powerdown)
184  *   IF_CS_BIT_EVENT      driver read a host event
185  */
186 #define IF_CS_HOST_STATUS               0x00000000
187
188 /*
189  * With the host int cause register can the host (that is, Linux) cause
190  * an interrupt in the firmware, to tell the firmware about those events:
191  *
192  *   IF_CS_BIT_TX         a data packet has been downloaded
193  *   IF_CS_BIT_RX         a received data packet has retrieved
194  *   IF_CS_BIT_COMMAND    a firmware block or a command has been downloaded
195  *   IF_CS_BIT_RESP       not used (has some meaning with powerdown)
196  *   IF_CS_BIT_EVENT      a host event (link lost etc) has been retrieved
197  */
198 #define IF_CS_HOST_INT_CAUSE            0x00000002
199
200 /*
201  * The host int mask register is used to enable/disable interrupt.  However,
202  * I have the suspicion that disabled interrupts are lost.
203  */
204 #define IF_CS_HOST_INT_MASK             0x00000004
205
206 /*
207  * Used to send or receive data packets:
208  */
209 #define IF_CS_WRITE                     0x00000016
210 #define IF_CS_WRITE_LEN                 0x00000014
211 #define IF_CS_READ                      0x00000010
212 #define IF_CS_READ_LEN                  0x00000024
213
214 /*
215  * Used to send commands (and to send firmware block) and to
216  * receive command responses:
217  */
218 #define IF_CS_CMD                       0x0000001A
219 #define IF_CS_CMD_LEN                   0x00000018
220 #define IF_CS_RESP                      0x00000012
221 #define IF_CS_RESP_LEN                  0x00000030
222
223 /*
224  * The card status registers shows what the card/firmware actually
225  * accepts:
226  *
227  *   IF_CS_BIT_TX        you may send a data packet
228  *   IF_CS_BIT_RX        you may retrieve a data packet
229  *   IF_CS_BIT_COMMAND   you may send a command
230  *   IF_CS_BIT_RESP      you may retrieve a command response
231  *   IF_CS_BIT_EVENT     the card has a event for use (link lost, snr low etc)
232  *
233  * When reading this register several times, you will get back the same
234  * results --- with one exception: the IF_CS_BIT_EVENT clear itself
235  * automatically.
236  *
237  * Not that we don't rely on BIT_RX,_BIT_RESP or BIT_EVENT because
238  * we handle this via the card int cause register.
239  */
240 #define IF_CS_CARD_STATUS               0x00000020
241 #define IF_CS_CARD_STATUS_MASK          0x7f00
242
243 /*
244  * The card int cause register is used by the card/firmware to notify us
245  * about the following events:
246  *
247  *   IF_CS_BIT_TX        a data packet has successfully been sentx
248  *   IF_CS_BIT_RX        a data packet has been received and can be retrieved
249  *   IF_CS_BIT_COMMAND   not used
250  *   IF_CS_BIT_RESP      the firmware has a command response for us
251  *   IF_CS_BIT_EVENT     the card has a event for use (link lost, snr low etc)
252  */
253 #define IF_CS_CARD_INT_CAUSE            0x00000022
254
255 /*
256  * This is used to for handshaking with the card's bootloader/helper image
257  * to synchronize downloading of firmware blocks.
258  */
259 #define IF_CS_SQ_READ_LOW               0x00000028
260 #define IF_CS_SQ_HELPER_OK              0x10
261
262 /*
263  * The scratch register tells us ...
264  *
265  * IF_CS_SCRATCH_BOOT_OK     the bootloader runs
266  * IF_CS_SCRATCH_HELPER_OK   the helper firmware already runs
267  */
268 #define IF_CS_SCRATCH                   0x0000003F
269 #define IF_CS_SCRATCH_BOOT_OK           0x00
270 #define IF_CS_SCRATCH_HELPER_OK         0x5a
271
272 /*
273  * Used to detect ancient chips:
274  */
275 #define IF_CS_PRODUCT_ID                0x0000001C
276 #define IF_CS_CF8385_B1_REV             0x12
277 #define IF_CS_CF8381_B3_REV             0x04
278 #define IF_CS_CF8305_B1_REV             0x03
279
280 /*
281  * Used to detect other cards than CF8385 since their revisions of silicon
282  * doesn't match those from CF8385, eg. CF8381 B3 works with this driver.
283  */
284 #define CF8305_MANFID           0x02db
285 #define CF8305_CARDID           0x8103
286 #define CF8381_MANFID           0x02db
287 #define CF8381_CARDID           0x6064
288 #define CF8385_MANFID           0x02df
289 #define CF8385_CARDID           0x8103
290
291 static inline int if_cs_hw_is_cf8305(struct pcmcia_device *p_dev)
292 {
293         return (p_dev->manf_id == CF8305_MANFID &&
294                 p_dev->card_id == CF8305_CARDID);
295 }
296
297 static inline int if_cs_hw_is_cf8381(struct pcmcia_device *p_dev)
298 {
299         return (p_dev->manf_id == CF8381_MANFID &&
300                 p_dev->card_id == CF8381_CARDID);
301 }
302
303 static inline int if_cs_hw_is_cf8385(struct pcmcia_device *p_dev)
304 {
305         return (p_dev->manf_id == CF8385_MANFID &&
306                 p_dev->card_id == CF8385_CARDID);
307 }
308
309 /********************************************************************/
310 /* I/O and interrupt handling                                       */
311 /********************************************************************/
312
313 static inline void if_cs_enable_ints(struct if_cs_card *card)
314 {
315         lbs_deb_enter(LBS_DEB_CS);
316         if_cs_write16(card, IF_CS_HOST_INT_MASK, 0);
317 }
318
319 static inline void if_cs_disable_ints(struct if_cs_card *card)
320 {
321         lbs_deb_enter(LBS_DEB_CS);
322         if_cs_write16(card, IF_CS_HOST_INT_MASK, IF_CS_BIT_MASK);
323 }
324
325 /*
326  * Called from if_cs_host_to_card to send a command to the hardware
327  */
328 static int if_cs_send_cmd(struct lbs_private *priv, u8 *buf, u16 nb)
329 {
330         struct if_cs_card *card = (struct if_cs_card *)priv->card;
331         int ret = -1;
332         int loops = 0;
333
334         lbs_deb_enter(LBS_DEB_CS);
335         if_cs_disable_ints(card);
336
337         /* Is hardware ready? */
338         while (1) {
339                 u16 status = if_cs_read16(card, IF_CS_CARD_STATUS);
340                 if (status & IF_CS_BIT_COMMAND)
341                         break;
342                 if (++loops > 100) {
343                         lbs_pr_err("card not ready for commands\n");
344                         goto done;
345                 }
346                 mdelay(1);
347         }
348
349         if_cs_write16(card, IF_CS_CMD_LEN, nb);
350
351         if_cs_write16_rep(card, IF_CS_CMD, buf, nb / 2);
352         /* Are we supposed to transfer an odd amount of bytes? */
353         if (nb & 1)
354                 if_cs_write8(card, IF_CS_CMD, buf[nb-1]);
355
356         /* "Assert the download over interrupt command in the Host
357          * status register" */
358         if_cs_write16(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND);
359
360         /* "Assert the download over interrupt command in the Card
361          * interrupt case register" */
362         if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND);
363         ret = 0;
364
365 done:
366         if_cs_enable_ints(card);
367         lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
368         return ret;
369 }
370
371 /*
372  * Called from if_cs_host_to_card to send a data to the hardware
373  */
374 static void if_cs_send_data(struct lbs_private *priv, u8 *buf, u16 nb)
375 {
376         struct if_cs_card *card = (struct if_cs_card *)priv->card;
377         u16 status;
378
379         lbs_deb_enter(LBS_DEB_CS);
380         if_cs_disable_ints(card);
381
382         status = if_cs_read16(card, IF_CS_CARD_STATUS);
383         BUG_ON((status & IF_CS_BIT_TX) == 0);
384
385         if_cs_write16(card, IF_CS_WRITE_LEN, nb);
386
387         /* write even number of bytes, then odd byte if necessary */
388         if_cs_write16_rep(card, IF_CS_WRITE, buf, nb / 2);
389         if (nb & 1)
390                 if_cs_write8(card, IF_CS_WRITE, buf[nb-1]);
391
392         if_cs_write16(card, IF_CS_HOST_STATUS, IF_CS_BIT_TX);
393         if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_TX);
394         if_cs_enable_ints(card);
395
396         lbs_deb_leave(LBS_DEB_CS);
397 }
398
399 /*
400  * Get the command result out of the card.
401  */
402 static int if_cs_receive_cmdres(struct lbs_private *priv, u8 *data, u32 *len)
403 {
404         unsigned long flags;
405         int ret = -1;
406         u16 status;
407
408         lbs_deb_enter(LBS_DEB_CS);
409
410         /* is hardware ready? */
411         status = if_cs_read16(priv->card, IF_CS_CARD_STATUS);
412         if ((status & IF_CS_BIT_RESP) == 0) {
413                 lbs_pr_err("no cmd response in card\n");
414                 *len = 0;
415                 goto out;
416         }
417
418         *len = if_cs_read16(priv->card, IF_CS_RESP_LEN);
419         if ((*len == 0) || (*len > LBS_CMD_BUFFER_SIZE)) {
420                 lbs_pr_err("card cmd buffer has invalid # of bytes (%d)\n", *len);
421                 goto out;
422         }
423
424         /* read even number of bytes, then odd byte if necessary */
425         if_cs_read16_rep(priv->card, IF_CS_RESP, data, *len/sizeof(u16));
426         if (*len & 1)
427                 data[*len-1] = if_cs_read8(priv->card, IF_CS_RESP);
428
429         /* This is a workaround for a firmware that reports too much
430          * bytes */
431         *len -= 8;
432         ret = 0;
433
434         /* Clear this flag again */
435         spin_lock_irqsave(&priv->driver_lock, flags);
436         priv->dnld_sent = DNLD_RES_RECEIVED;
437         spin_unlock_irqrestore(&priv->driver_lock, flags);
438
439 out:
440         lbs_deb_leave_args(LBS_DEB_CS, "ret %d, len %d", ret, *len);
441         return ret;
442 }
443
444 static struct sk_buff *if_cs_receive_data(struct lbs_private *priv)
445 {
446         struct sk_buff *skb = NULL;
447         u16 len;
448         u8 *data;
449
450         lbs_deb_enter(LBS_DEB_CS);
451
452         len = if_cs_read16(priv->card, IF_CS_READ_LEN);
453         if (len == 0 || len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
454                 lbs_pr_err("card data buffer has invalid # of bytes (%d)\n", len);
455                 priv->dev->stats.rx_dropped++;
456                 goto dat_err;
457         }
458
459         skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + 2);
460         if (!skb)
461                 goto out;
462         skb_put(skb, len);
463         skb_reserve(skb, 2);/* 16 byte align */
464         data = skb->data;
465
466         /* read even number of bytes, then odd byte if necessary */
467         if_cs_read16_rep(priv->card, IF_CS_READ, data, len/sizeof(u16));
468         if (len & 1)
469                 data[len-1] = if_cs_read8(priv->card, IF_CS_READ);
470
471 dat_err:
472         if_cs_write16(priv->card, IF_CS_HOST_STATUS, IF_CS_BIT_RX);
473         if_cs_write16(priv->card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_RX);
474
475 out:
476         lbs_deb_leave_args(LBS_DEB_CS, "ret %p", skb);
477         return skb;
478 }
479
480 static irqreturn_t if_cs_interrupt(int irq, void *data)
481 {
482         struct if_cs_card *card = data;
483         struct lbs_private *priv = card->priv;
484         u16 cause;
485
486         lbs_deb_enter(LBS_DEB_CS);
487
488         /* Ask card interrupt cause register if there is something for us */
489         cause = if_cs_read16(card, IF_CS_CARD_INT_CAUSE);
490         lbs_deb_cs("cause 0x%04x\n", cause);
491
492         if (cause == 0) {
493                 /* Not for us */
494                 return IRQ_NONE;
495         }
496
497         if (cause == 0xffff) {
498                 /* Read in junk, the card has probably been removed */
499                 card->priv->surpriseremoved = 1;
500                 return IRQ_HANDLED;
501         }
502
503         if (cause & IF_CS_BIT_RX) {
504                 struct sk_buff *skb;
505                 lbs_deb_cs("rx packet\n");
506                 skb = if_cs_receive_data(priv);
507                 if (skb)
508                         lbs_process_rxed_packet(priv, skb);
509         }
510
511         if (cause & IF_CS_BIT_TX) {
512                 lbs_deb_cs("tx done\n");
513                 lbs_host_to_card_done(priv);
514         }
515
516         if (cause & IF_CS_BIT_RESP) {
517                 unsigned long flags;
518                 u8 i;
519
520                 lbs_deb_cs("cmd resp\n");
521                 spin_lock_irqsave(&priv->driver_lock, flags);
522                 i = (priv->resp_idx == 0) ? 1 : 0;
523                 spin_unlock_irqrestore(&priv->driver_lock, flags);
524
525                 BUG_ON(priv->resp_len[i]);
526                 if_cs_receive_cmdres(priv, priv->resp_buf[i],
527                         &priv->resp_len[i]);
528
529                 spin_lock_irqsave(&priv->driver_lock, flags);
530                 lbs_notify_command_response(priv, i);
531                 spin_unlock_irqrestore(&priv->driver_lock, flags);
532         }
533
534         if (cause & IF_CS_BIT_EVENT) {
535                 u16 status = if_cs_read16(priv->card, IF_CS_CARD_STATUS);
536                 if_cs_write16(priv->card, IF_CS_HOST_INT_CAUSE,
537                         IF_CS_BIT_EVENT);
538                 lbs_queue_event(priv, (status & IF_CS_CARD_STATUS_MASK) >> 8);
539         }
540
541         /* Clear interrupt cause */
542         if_cs_write16(card, IF_CS_CARD_INT_CAUSE, cause & IF_CS_BIT_MASK);
543
544         lbs_deb_leave(LBS_DEB_CS);
545         return IRQ_HANDLED;
546 }
547
548
549
550
551 /********************************************************************/
552 /* Firmware                                                         */
553 /********************************************************************/
554
555 /*
556  * Tries to program the helper firmware.
557  *
558  * Return 0 on success
559  */
560 static int if_cs_prog_helper(struct if_cs_card *card)
561 {
562         int ret = 0;
563         int sent = 0;
564         u8  scratch;
565         const struct firmware *fw;
566
567         lbs_deb_enter(LBS_DEB_CS);
568
569         /*
570          * This is the only place where an unaligned register access happens on
571          * the CF8305 card, therefore for the sake of speed of the driver, we do
572          * the alignment correction here.
573          */
574         if (card->align_regs)
575                 scratch = if_cs_read16(card, IF_CS_SCRATCH) >> 8;
576         else
577                 scratch = if_cs_read8(card, IF_CS_SCRATCH);
578
579         /* "If the value is 0x5a, the firmware is already
580          * downloaded successfully"
581          */
582         if (scratch == IF_CS_SCRATCH_HELPER_OK)
583                 goto done;
584
585         /* "If the value is != 00, it is invalid value of register */
586         if (scratch != IF_CS_SCRATCH_BOOT_OK) {
587                 ret = -ENODEV;
588                 goto done;
589         }
590
591         /* TODO: make firmware file configurable */
592         ret = request_firmware(&fw, "libertas_cs_helper.fw",
593                 &card->p_dev->dev);
594         if (ret) {
595                 lbs_pr_err("can't load helper firmware\n");
596                 ret = -ENODEV;
597                 goto done;
598         }
599         lbs_deb_cs("helper size %td\n", fw->size);
600
601         /* "Set the 5 bytes of the helper image to 0" */
602         /* Not needed, this contains an ARM branch instruction */
603
604         for (;;) {
605                 /* "the number of bytes to send is 256" */
606                 int count = 256;
607                 int remain = fw->size - sent;
608
609                 if (remain < count)
610                         count = remain;
611
612                 /* "write the number of bytes to be sent to the I/O Command
613                  * write length register" */
614                 if_cs_write16(card, IF_CS_CMD_LEN, count);
615
616                 /* "write this to I/O Command port register as 16 bit writes */
617                 if (count)
618                         if_cs_write16_rep(card, IF_CS_CMD,
619                                 &fw->data[sent],
620                                 count >> 1);
621
622                 /* "Assert the download over interrupt command in the Host
623                  * status register" */
624                 if_cs_write8(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND);
625
626                 /* "Assert the download over interrupt command in the Card
627                  * interrupt case register" */
628                 if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND);
629
630                 /* "The host polls the Card Status register ... for 50 ms before
631                    declaring a failure */
632                 ret = if_cs_poll_while_fw_download(card, IF_CS_CARD_STATUS,
633                         IF_CS_BIT_COMMAND);
634                 if (ret < 0) {
635                         lbs_pr_err("can't download helper at 0x%x, ret %d\n",
636                                 sent, ret);
637                         goto err_release;
638                 }
639
640                 if (count == 0)
641                         break;
642
643                 sent += count;
644         }
645
646 err_release:
647         release_firmware(fw);
648 done:
649         lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
650         return ret;
651 }
652
653
654 static int if_cs_prog_real(struct if_cs_card *card)
655 {
656         const struct firmware *fw;
657         int ret = 0;
658         int retry = 0;
659         int len = 0;
660         int sent;
661
662         lbs_deb_enter(LBS_DEB_CS);
663
664         /* TODO: make firmware file configurable */
665         ret = request_firmware(&fw, "libertas_cs.fw",
666                 &card->p_dev->dev);
667         if (ret) {
668                 lbs_pr_err("can't load firmware\n");
669                 ret = -ENODEV;
670                 goto done;
671         }
672         lbs_deb_cs("fw size %td\n", fw->size);
673
674         ret = if_cs_poll_while_fw_download(card, IF_CS_SQ_READ_LOW,
675                 IF_CS_SQ_HELPER_OK);
676         if (ret < 0) {
677                 lbs_pr_err("helper firmware doesn't answer\n");
678                 goto err_release;
679         }
680
681         for (sent = 0; sent < fw->size; sent += len) {
682                 len = if_cs_read16(card, IF_CS_SQ_READ_LOW);
683                 if (len & 1) {
684                         retry++;
685                         lbs_pr_info("odd, need to retry this firmware block\n");
686                 } else {
687                         retry = 0;
688                 }
689
690                 if (retry > 20) {
691                         lbs_pr_err("could not download firmware\n");
692                         ret = -ENODEV;
693                         goto err_release;
694                 }
695                 if (retry) {
696                         sent -= len;
697                 }
698
699
700                 if_cs_write16(card, IF_CS_CMD_LEN, len);
701
702                 if_cs_write16_rep(card, IF_CS_CMD,
703                         &fw->data[sent],
704                         (len+1) >> 1);
705                 if_cs_write8(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND);
706                 if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND);
707
708                 ret = if_cs_poll_while_fw_download(card, IF_CS_CARD_STATUS,
709                         IF_CS_BIT_COMMAND);
710                 if (ret < 0) {
711                         lbs_pr_err("can't download firmware at 0x%x\n", sent);
712                         goto err_release;
713                 }
714         }
715
716         ret = if_cs_poll_while_fw_download(card, IF_CS_SCRATCH, 0x5a);
717         if (ret < 0)
718                 lbs_pr_err("firmware download failed\n");
719
720 err_release:
721         release_firmware(fw);
722
723 done:
724         lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
725         return ret;
726 }
727
728
729
730 /********************************************************************/
731 /* Callback functions for libertas.ko                               */
732 /********************************************************************/
733
734 /* Send commands or data packets to the card */
735 static int if_cs_host_to_card(struct lbs_private *priv,
736         u8 type,
737         u8 *buf,
738         u16 nb)
739 {
740         int ret = -1;
741
742         lbs_deb_enter_args(LBS_DEB_CS, "type %d, bytes %d", type, nb);
743
744         switch (type) {
745         case MVMS_DAT:
746                 priv->dnld_sent = DNLD_DATA_SENT;
747                 if_cs_send_data(priv, buf, nb);
748                 ret = 0;
749                 break;
750         case MVMS_CMD:
751                 priv->dnld_sent = DNLD_CMD_SENT;
752                 ret = if_cs_send_cmd(priv, buf, nb);
753                 break;
754         default:
755                 lbs_pr_err("%s: unsupported type %d\n", __func__, type);
756         }
757
758         lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
759         return ret;
760 }
761
762
763 /********************************************************************/
764 /* Card Services                                                    */
765 /********************************************************************/
766
767 /*
768  * After a card is removed, if_cs_release() will unregister the
769  * device, and release the PCMCIA configuration.  If the device is
770  * still open, this will be postponed until it is closed.
771  */
772 static void if_cs_release(struct pcmcia_device *p_dev)
773 {
774         struct if_cs_card *card = p_dev->priv;
775
776         lbs_deb_enter(LBS_DEB_CS);
777
778         free_irq(p_dev->irq, card);
779         pcmcia_disable_device(p_dev);
780         if (card->iobase)
781                 ioport_unmap(card->iobase);
782
783         lbs_deb_leave(LBS_DEB_CS);
784 }
785
786
787 /*
788  * This creates an "instance" of the driver, allocating local data
789  * structures for one device.  The device is registered with Card
790  * Services.
791  *
792  * The dev_link structure is initialized, but we don't actually
793  * configure the card at this point -- we wait until we receive a card
794  * insertion event.
795  */
796
797 static int if_cs_ioprobe(struct pcmcia_device *p_dev,
798                          cistpl_cftable_entry_t *cfg,
799                          cistpl_cftable_entry_t *dflt,
800                          unsigned int vcc,
801                          void *priv_data)
802 {
803         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
804         p_dev->resource[0]->start = cfg->io.win[0].base;
805         p_dev->resource[0]->end = cfg->io.win[0].len;
806
807         /* Do we need to allocate an interrupt? */
808         p_dev->config_flags |= CONF_ENABLE_IRQ;
809
810         /* IO window settings */
811         if (cfg->io.nwin != 1) {
812                 lbs_pr_err("wrong CIS (check number of IO windows)\n");
813                 return -ENODEV;
814         }
815
816         /* This reserves IO space but doesn't actually enable it */
817         return pcmcia_request_io(p_dev);
818 }
819
820 static int if_cs_probe(struct pcmcia_device *p_dev)
821 {
822         int ret = -ENOMEM;
823         unsigned int prod_id;
824         struct lbs_private *priv;
825         struct if_cs_card *card;
826
827         lbs_deb_enter(LBS_DEB_CS);
828
829         card = kzalloc(sizeof(struct if_cs_card), GFP_KERNEL);
830         if (!card) {
831                 lbs_pr_err("error in kzalloc\n");
832                 goto out;
833         }
834         card->p_dev = p_dev;
835         p_dev->priv = card;
836
837         if (pcmcia_loop_config(p_dev, if_cs_ioprobe, NULL)) {
838                 lbs_pr_err("error in pcmcia_loop_config\n");
839                 goto out1;
840         }
841
842         /*
843          * Allocate an interrupt line.  Note that this does not assign
844          * a handler to the interrupt, unless the 'Handler' member of
845          * the irq structure is initialized.
846          */
847         if (!p_dev->irq)
848                 goto out1;
849
850         /* Initialize io access */
851         card->iobase = ioport_map(p_dev->resource[0]->start,
852                                 resource_size(p_dev->resource[0]));
853         if (!card->iobase) {
854                 lbs_pr_err("error in ioport_map\n");
855                 ret = -EIO;
856                 goto out1;
857         }
858
859         /*
860          * This actually configures the PCMCIA socket -- setting up
861          * the I/O windows and the interrupt mapping, and putting the
862          * card and host interface into "Memory and IO" mode.
863          */
864         ret = pcmcia_enable_device(p_dev);
865         if (ret) {
866                 lbs_pr_err("error in pcmcia_enable_device\n");
867                 goto out2;
868         }
869
870         /* Finally, report what we've done */
871         lbs_deb_cs("irq %d, io %pR", p_dev->irq, p_dev->resource[0]);
872
873         /*
874          * Most of the libertas cards can do unaligned register access, but some
875          * weird ones can not. That's especially true for the CF8305 card.
876          */
877         card->align_regs = 0;
878
879         /* Check if we have a current silicon */
880         prod_id = if_cs_read8(card, IF_CS_PRODUCT_ID);
881         if (if_cs_hw_is_cf8305(p_dev)) {
882                 card->align_regs = 1;
883                 if (prod_id < IF_CS_CF8305_B1_REV) {
884                         lbs_pr_err("old chips like 8305 rev B3 "
885                                 "aren't supported\n");
886                         ret = -ENODEV;
887                         goto out2;
888                 }
889         }
890
891         if (if_cs_hw_is_cf8381(p_dev) && prod_id < IF_CS_CF8381_B3_REV) {
892                 lbs_pr_err("old chips like 8381 rev B3 aren't supported\n");
893                 ret = -ENODEV;
894                 goto out2;
895         }
896
897         if (if_cs_hw_is_cf8385(p_dev) && prod_id < IF_CS_CF8385_B1_REV) {
898                 lbs_pr_err("old chips like 8385 rev B1 aren't supported\n");
899                 ret = -ENODEV;
900                 goto out2;
901         }
902
903         /* Load the firmware early, before calling into libertas.ko */
904         ret = if_cs_prog_helper(card);
905         if (ret == 0 && !if_cs_hw_is_cf8305(p_dev))
906                 ret = if_cs_prog_real(card);
907         if (ret)
908                 goto out2;
909
910         /* Make this card known to the libertas driver */
911         priv = lbs_add_card(card, &p_dev->dev);
912         if (!priv) {
913                 ret = -ENOMEM;
914                 goto out2;
915         }
916
917         /* Finish setting up fields in lbs_private */
918         card->priv = priv;
919         priv->card = card;
920         priv->hw_host_to_card = if_cs_host_to_card;
921         priv->enter_deep_sleep = NULL;
922         priv->exit_deep_sleep = NULL;
923         priv->reset_deep_sleep_wakeup = NULL;
924         priv->fw_ready = 1;
925
926         /* Now actually get the IRQ */
927         ret = request_irq(p_dev->irq, if_cs_interrupt,
928                 IRQF_SHARED, DRV_NAME, card);
929         if (ret) {
930                 lbs_pr_err("error in request_irq\n");
931                 goto out3;
932         }
933
934         /* Clear any interrupt cause that happend while sending
935          * firmware/initializing card */
936         if_cs_write16(card, IF_CS_CARD_INT_CAUSE, IF_CS_BIT_MASK);
937         if_cs_enable_ints(card);
938
939         /* And finally bring the card up */
940         if (lbs_start_card(priv) != 0) {
941                 lbs_pr_err("could not activate card\n");
942                 goto out3;
943         }
944
945         ret = 0;
946         goto out;
947
948 out3:
949         lbs_remove_card(priv);
950 out2:
951         ioport_unmap(card->iobase);
952 out1:
953         pcmcia_disable_device(p_dev);
954 out:
955         lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
956         return ret;
957 }
958
959
960 /*
961  * This deletes a driver "instance".  The device is de-registered with
962  * Card Services.  If it has been released, all local data structures
963  * are freed.  Otherwise, the structures will be freed when the device
964  * is released.
965  */
966 static void if_cs_detach(struct pcmcia_device *p_dev)
967 {
968         struct if_cs_card *card = p_dev->priv;
969
970         lbs_deb_enter(LBS_DEB_CS);
971
972         lbs_stop_card(card->priv);
973         lbs_remove_card(card->priv);
974         if_cs_disable_ints(card);
975         if_cs_release(p_dev);
976         kfree(card);
977
978         lbs_deb_leave(LBS_DEB_CS);
979 }
980
981
982
983 /********************************************************************/
984 /* Module initialization                                            */
985 /********************************************************************/
986
987 static struct pcmcia_device_id if_cs_ids[] = {
988         PCMCIA_DEVICE_MANF_CARD(CF8305_MANFID, CF8305_CARDID),
989         PCMCIA_DEVICE_MANF_CARD(CF8381_MANFID, CF8381_CARDID),
990         PCMCIA_DEVICE_MANF_CARD(CF8385_MANFID, CF8385_CARDID),
991         PCMCIA_DEVICE_NULL,
992 };
993 MODULE_DEVICE_TABLE(pcmcia, if_cs_ids);
994
995
996 static struct pcmcia_driver lbs_driver = {
997         .owner          = THIS_MODULE,
998         .drv            = {
999                 .name   = DRV_NAME,
1000         },
1001         .probe          = if_cs_probe,
1002         .remove         = if_cs_detach,
1003         .id_table       = if_cs_ids,
1004 };
1005
1006
1007 static int __init if_cs_init(void)
1008 {
1009         int ret;
1010
1011         lbs_deb_enter(LBS_DEB_CS);
1012         ret = pcmcia_register_driver(&lbs_driver);
1013         lbs_deb_leave(LBS_DEB_CS);
1014         return ret;
1015 }
1016
1017
1018 static void __exit if_cs_exit(void)
1019 {
1020         lbs_deb_enter(LBS_DEB_CS);
1021         pcmcia_unregister_driver(&lbs_driver);
1022         lbs_deb_leave(LBS_DEB_CS);
1023 }
1024
1025
1026 module_init(if_cs_init);
1027 module_exit(if_cs_exit);