projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
pcmcia: move driver name to struct pcmcia_driver
[deliverable/linux.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, void *priv_data)
798 {
799 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
800 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
801
802 if (p_dev->resource[1]->end) {
803 lbs_pr_err("wrong CIS (check number of IO windows)\n");
804 return -ENODEV;
805 }
806
807 /* This reserves IO space but doesn't actually enable it */
808 return pcmcia_request_io(p_dev);
809 }
810
811 static int if_cs_probe(struct pcmcia_device *p_dev)
812 {
813 int ret = -ENOMEM;
814 unsigned int prod_id;
815 struct lbs_private *priv;
816 struct if_cs_card *card;
817
818 lbs_deb_enter(LBS_DEB_CS);
819
820 card = kzalloc(sizeof(struct if_cs_card), GFP_KERNEL);
821 if (!card) {
822 lbs_pr_err("error in kzalloc\n");
823 goto out;
824 }
825 card->p_dev = p_dev;
826 p_dev->priv = card;
827
828 p_dev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
829
830 if (pcmcia_loop_config(p_dev, if_cs_ioprobe, NULL)) {
831 lbs_pr_err("error in pcmcia_loop_config\n");
832 goto out1;
833 }
834
835 /*
836 * Allocate an interrupt line. Note that this does not assign
837 * a handler to the interrupt, unless the 'Handler' member of
838 * the irq structure is initialized.
839 */
840 if (!p_dev->irq)
841 goto out1;
842
843 /* Initialize io access */
844 card->iobase = ioport_map(p_dev->resource[0]->start,
845 resource_size(p_dev->resource[0]));
846 if (!card->iobase) {
847 lbs_pr_err("error in ioport_map\n");
848 ret = -EIO;
849 goto out1;
850 }
851
852 /*
853 * This actually configures the PCMCIA socket -- setting up
854 * the I/O windows and the interrupt mapping, and putting the
855 * card and host interface into "Memory and IO" mode.
856 */
857 ret = pcmcia_enable_device(p_dev);
858 if (ret) {
859 lbs_pr_err("error in pcmcia_enable_device\n");
860 goto out2;
861 }
862
863 /* Finally, report what we've done */
864 lbs_deb_cs("irq %d, io %pR", p_dev->irq, p_dev->resource[0]);
865
866 /*
867 * Most of the libertas cards can do unaligned register access, but some
868 * weird ones can not. That's especially true for the CF8305 card.
869 */
870 card->align_regs = 0;
871
872 /* Check if we have a current silicon */
873 prod_id = if_cs_read8(card, IF_CS_PRODUCT_ID);
874 if (if_cs_hw_is_cf8305(p_dev)) {
875 card->align_regs = 1;
876 if (prod_id < IF_CS_CF8305_B1_REV) {
877 lbs_pr_err("old chips like 8305 rev B3 "
878 "aren't supported\n");
879 ret = -ENODEV;
880 goto out2;
881 }
882 }
883
884 if (if_cs_hw_is_cf8381(p_dev) && prod_id < IF_CS_CF8381_B3_REV) {
885 lbs_pr_err("old chips like 8381 rev B3 aren't supported\n");
886 ret = -ENODEV;
887 goto out2;
888 }
889
890 if (if_cs_hw_is_cf8385(p_dev) && prod_id < IF_CS_CF8385_B1_REV) {
891 lbs_pr_err("old chips like 8385 rev B1 aren't supported\n");
892 ret = -ENODEV;
893 goto out2;
894 }
895
896 /* Load the firmware early, before calling into libertas.ko */
897 ret = if_cs_prog_helper(card);
898 if (ret == 0 && !if_cs_hw_is_cf8305(p_dev))
899 ret = if_cs_prog_real(card);
900 if (ret)
901 goto out2;
902
903 /* Make this card known to the libertas driver */
904 priv = lbs_add_card(card, &p_dev->dev);
905 if (!priv) {
906 ret = -ENOMEM;
907 goto out2;
908 }
909
910 /* Finish setting up fields in lbs_private */
911 card->priv = priv;
912 priv->card = card;
913 priv->hw_host_to_card = if_cs_host_to_card;
914 priv->enter_deep_sleep = NULL;
915 priv->exit_deep_sleep = NULL;
916 priv->reset_deep_sleep_wakeup = NULL;
917 priv->fw_ready = 1;
918
919 /* Now actually get the IRQ */
920 ret = request_irq(p_dev->irq, if_cs_interrupt,
921 IRQF_SHARED, DRV_NAME, card);
922 if (ret) {
923 lbs_pr_err("error in request_irq\n");
924 goto out3;
925 }
926
927 /* Clear any interrupt cause that happend while sending
928 * firmware/initializing card */
929 if_cs_write16(card, IF_CS_CARD_INT_CAUSE, IF_CS_BIT_MASK);
930 if_cs_enable_ints(card);
931
932 /* And finally bring the card up */
933 if (lbs_start_card(priv) != 0) {
934 lbs_pr_err("could not activate card\n");
935 goto out3;
936 }
937
938 ret = 0;
939 goto out;
940
941 out3:
942 lbs_remove_card(priv);
943 out2:
944 ioport_unmap(card->iobase);
945 out1:
946 pcmcia_disable_device(p_dev);
947 out:
948 lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
949 return ret;
950 }
951
952
953 /*
954 * This deletes a driver "instance". The device is de-registered with
955 * Card Services. If it has been released, all local data structures
956 * are freed. Otherwise, the structures will be freed when the device
957 * is released.
958 */
959 static void if_cs_detach(struct pcmcia_device *p_dev)
960 {
961 struct if_cs_card *card = p_dev->priv;
962
963 lbs_deb_enter(LBS_DEB_CS);
964
965 lbs_stop_card(card->priv);
966 lbs_remove_card(card->priv);
967 if_cs_disable_ints(card);
968 if_cs_release(p_dev);
969 kfree(card);
970
971 lbs_deb_leave(LBS_DEB_CS);
972 }
973
974
975
976 /********************************************************************/
977 /* Module initialization */
978 /********************************************************************/
979
980 static struct pcmcia_device_id if_cs_ids[] = {
981 PCMCIA_DEVICE_MANF_CARD(CF8305_MANFID, CF8305_CARDID),
982 PCMCIA_DEVICE_MANF_CARD(CF8381_MANFID, CF8381_CARDID),
983 PCMCIA_DEVICE_MANF_CARD(CF8385_MANFID, CF8385_CARDID),
984 PCMCIA_DEVICE_NULL,
985 };
986 MODULE_DEVICE_TABLE(pcmcia, if_cs_ids);
987
988
989 static struct pcmcia_driver lbs_driver = {
990 .owner = THIS_MODULE,
991 .name = DRV_NAME,
992 .probe = if_cs_probe,
993 .remove = if_cs_detach,
994 .id_table = if_cs_ids,
995 };
996
997
998 static int __init if_cs_init(void)
999 {
1000 int ret;
1001
1002 lbs_deb_enter(LBS_DEB_CS);
1003 ret = pcmcia_register_driver(&lbs_driver);
1004 lbs_deb_leave(LBS_DEB_CS);
1005 return ret;
1006 }
1007
1008
1009 static void __exit if_cs_exit(void)
1010 {
1011 lbs_deb_enter(LBS_DEB_CS);
1012 pcmcia_unregister_driver(&lbs_driver);
1013 lbs_deb_leave(LBS_DEB_CS);
1014 }
1015
1016
1017 module_init(if_cs_init);
1018 module_exit(if_cs_exit);
Linux kernel - Deliverables
This page took 0.056137 seconds and 5 git commands to generate.