1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/module.h>
25#include <linux/delay.h>
26#include <linux/moduleparam.h>
27#include <linux/firmware.h>
28#include <linux/netdevice.h>
29
30#include <pcmcia/cs_types.h>
31#include <pcmcia/cs.h>
32#include <pcmcia/cistpl.h>
33#include <pcmcia/ds.h>
34
35#include <linux/io.h>
36
37#define DRV_NAME "libertas_cs"
38
39#include "decl.h"
40#include "defs.h"
41#include "dev.h"
42
43
44
45
46
47
48MODULE_AUTHOR("Holger Schurig <hs4233@mail.mn-solutions.de>");
49MODULE_DESCRIPTION("Driver for Marvell 83xx compact flash WLAN cards");
50MODULE_LICENSE("GPL");
51
52
53
54
55
56
57
58struct 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
69
70
71
72
73
74
75
76#ifdef DEBUG_IO
77static int debug_output = 0;
78#else
79
80#define debug_output 0
81#endif
82
83static 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}
90static 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}
97static 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
109static 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
116static 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
123static 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
138
139
140
141
142
143
144
145
146
147
148static 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
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
177
178
179
180
181
182
183
184
185
186#define IF_CS_HOST_STATUS 0x00000000
187
188
189
190
191
192
193
194
195
196
197
198#define IF_CS_HOST_INT_CAUSE 0x00000002
199
200
201
202
203
204#define IF_CS_HOST_INT_MASK 0x00000004
205
206
207
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
216
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
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240#define IF_CS_CARD_STATUS 0x00000020
241#define IF_CS_CARD_STATUS_MASK 0x7f00
242
243
244
245
246
247
248
249
250
251
252
253#define IF_CS_CARD_INT_CAUSE 0x00000022
254
255
256
257
258
259#define IF_CS_SQ_READ_LOW 0x00000028
260#define IF_CS_SQ_HELPER_OK 0x10
261
262
263
264
265
266
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
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
282
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
291static 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
297static 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
303static 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
311
312
313static 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
319static 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
327
328static 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
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
353 if (nb & 1)
354 if_cs_write8(card, IF_CS_CMD, buf[nb-1]);
355
356
357
358 if_cs_write16(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND);
359
360
361
362 if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND);
363 ret = 0;
364
365done:
366 if_cs_enable_ints(card);
367 lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
368 return ret;
369}
370
371
372
373
374static 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
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
401
402static 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
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
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
430
431 *len -= 8;
432 ret = 0;
433
434
435 spin_lock_irqsave(&priv->driver_lock, flags);
436 priv->dnld_sent = DNLD_RES_RECEIVED;
437 spin_unlock_irqrestore(&priv->driver_lock, flags);
438
439out:
440 lbs_deb_leave_args(LBS_DEB_CS, "ret %d, len %d", ret, *len);
441 return ret;
442}
443
444static 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);
464 data = skb->data;
465
466
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
471dat_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
475out:
476 lbs_deb_leave_args(LBS_DEB_CS, "ret %p", skb);
477 return skb;
478}
479
480static 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
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
494 return IRQ_NONE;
495 }
496
497 if (cause == 0xffff) {
498
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
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
553
554
555
556
557
558
559
560static 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
571
572
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
580
581
582 if (scratch == IF_CS_SCRATCH_HELPER_OK)
583 goto done;
584
585
586 if (scratch != IF_CS_SCRATCH_BOOT_OK) {
587 ret = -ENODEV;
588 goto done;
589 }
590
591
592 ret = request_firmware(&fw, "libertas_cs_helper.fw",
593 &handle_to_dev(card->p_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
602
603
604 for (;;) {
605
606 int count = 256;
607 int remain = fw->size - sent;
608
609 if (remain < count)
610 count = remain;
611
612
613
614 if_cs_write16(card, IF_CS_CMD_LEN, count);
615
616
617 if (count)
618 if_cs_write16_rep(card, IF_CS_CMD,
619 &fw->data[sent],
620 count >> 1);
621
622
623
624 if_cs_write8(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND);
625
626
627
628 if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND);
629
630
631
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
646err_release:
647 release_firmware(fw);
648done:
649 lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
650 return ret;
651}
652
653
654static 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
665 ret = request_firmware(&fw, "libertas_cs.fw",
666 &handle_to_dev(card->p_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
720err_release:
721 release_firmware(fw);
722
723done:
724 lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
725 return ret;
726}
727
728
729
730
731
732
733
734
735static 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
765
766
767
768
769
770
771
772static 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.AssignedIRQ, 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
789
790
791
792
793
794
795
796static int if_cs_probe(struct pcmcia_device *p_dev)
797{
798 int ret = -ENOMEM;
799 unsigned int prod_id;
800 struct lbs_private *priv;
801 struct if_cs_card *card;
802
803 tuple_t tuple;
804 cisparse_t parse;
805 cistpl_cftable_entry_t *cfg = &parse.cftable_entry;
806 cistpl_io_t *io = &cfg->io;
807 u_char buf[64];
808
809 lbs_deb_enter(LBS_DEB_CS);
810
811 card = kzalloc(sizeof(struct if_cs_card), GFP_KERNEL);
812 if (!card) {
813 lbs_pr_err("error in kzalloc\n");
814 goto out;
815 }
816 card->p_dev = p_dev;
817 p_dev->priv = card;
818
819 p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
820 p_dev->irq.Handler = NULL;
821 p_dev->irq.IRQInfo1 = IRQ_INFO2_VALID | IRQ_LEVEL_ID;
822
823 p_dev->conf.Attributes = 0;
824 p_dev->conf.IntType = INT_MEMORY_AND_IO;
825
826 tuple.Attributes = 0;
827 tuple.TupleData = buf;
828 tuple.TupleDataMax = sizeof(buf);
829 tuple.TupleOffset = 0;
830
831 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
832 if ((ret = pcmcia_get_first_tuple(p_dev, &tuple)) != 0 ||
833 (ret = pcmcia_get_tuple_data(p_dev, &tuple)) != 0 ||
834 (ret = pcmcia_parse_tuple(&tuple, &parse)) != 0)
835 {
836 lbs_pr_err("error in pcmcia_get_first_tuple etc\n");
837 goto out1;
838 }
839
840 p_dev->conf.ConfigIndex = cfg->index;
841
842
843 if (cfg->irq.IRQInfo1) {
844 p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
845 }
846
847
848 if (cfg->io.nwin != 1) {
849 lbs_pr_err("wrong CIS (check number of IO windows)\n");
850 ret = -ENODEV;
851 goto out1;
852 }
853 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
854 p_dev->io.BasePort1 = io->win[0].base;
855 p_dev->io.NumPorts1 = io->win[0].len;
856
857
858 ret = pcmcia_request_io(p_dev, &p_dev->io);
859 if (ret) {
860 lbs_pr_err("error in pcmcia_request_io\n");
861 goto out1;
862 }
863
864
865
866
867
868
869 if (p_dev->conf.Attributes & CONF_ENABLE_IRQ) {
870 ret = pcmcia_request_irq(p_dev, &p_dev->irq);
871 if (ret) {
872 lbs_pr_err("error in pcmcia_request_irq\n");
873 goto out1;
874 }
875 }
876
877
878 card->iobase = ioport_map(p_dev->io.BasePort1, p_dev->io.NumPorts1);
879 if (!card->iobase) {
880 lbs_pr_err("error in ioport_map\n");
881 ret = -EIO;
882 goto out1;
883 }
884
885
886
887
888
889
890 ret = pcmcia_request_configuration(p_dev, &p_dev->conf);
891 if (ret) {
892 lbs_pr_err("error in pcmcia_request_configuration\n");
893 goto out2;
894 }
895
896
897 lbs_deb_cs("irq %d, io 0x%04x-0x%04x\n",
898 p_dev->irq.AssignedIRQ, p_dev->io.BasePort1,
899 p_dev->io.BasePort1 + p_dev->io.NumPorts1 - 1);
900
901
902
903
904
905 card->align_regs = 0;
906
907
908 prod_id = if_cs_read8(card, IF_CS_PRODUCT_ID);
909 if (if_cs_hw_is_cf8305(p_dev)) {
910 card->align_regs = 1;
911 if (prod_id < IF_CS_CF8305_B1_REV) {
912 lbs_pr_err("old chips like 8305 rev B3 "
913 "aren't supported\n");
914 ret = -ENODEV;
915 goto out2;
916 }
917 }
918
919 if (if_cs_hw_is_cf8381(p_dev) && prod_id < IF_CS_CF8381_B3_REV) {
920 lbs_pr_err("old chips like 8381 rev B3 aren't supported\n");
921 ret = -ENODEV;
922 goto out2;
923 }
924
925 if (if_cs_hw_is_cf8385(p_dev) && prod_id < IF_CS_CF8385_B1_REV) {
926 lbs_pr_err("old chips like 8385 rev B1 aren't supported\n");
927 ret = -ENODEV;
928 goto out2;
929 }
930
931
932 ret = if_cs_prog_helper(card);
933 if (ret == 0 && !if_cs_hw_is_cf8305(p_dev))
934 ret = if_cs_prog_real(card);
935 if (ret)
936 goto out2;
937
938
939 priv = lbs_add_card(card, &p_dev->dev);
940 if (!priv) {
941 ret = -ENOMEM;
942 goto out2;
943 }
944
945
946 card->priv = priv;
947 priv->card = card;
948 priv->hw_host_to_card = if_cs_host_to_card;
949 priv->fw_ready = 1;
950
951
952 ret = request_irq(p_dev->irq.AssignedIRQ, if_cs_interrupt,
953 IRQF_SHARED, DRV_NAME, card);
954 if (ret) {
955 lbs_pr_err("error in request_irq\n");
956 goto out3;
957 }
958
959
960
961 if_cs_write16(card, IF_CS_CARD_INT_CAUSE, IF_CS_BIT_MASK);
962 if_cs_enable_ints(card);
963
964
965 if (lbs_start_card(priv) != 0) {
966 lbs_pr_err("could not activate card\n");
967 goto out3;
968 }
969
970 ret = 0;
971 goto out;
972
973out3:
974 lbs_remove_card(priv);
975out2:
976 ioport_unmap(card->iobase);
977out1:
978 pcmcia_disable_device(p_dev);
979out:
980 lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
981 return ret;
982}
983
984
985
986
987
988
989
990
991static void if_cs_detach(struct pcmcia_device *p_dev)
992{
993 struct if_cs_card *card = p_dev->priv;
994
995 lbs_deb_enter(LBS_DEB_CS);
996
997 lbs_stop_card(card->priv);
998 lbs_remove_card(card->priv);
999 if_cs_disable_ints(card);
1000 if_cs_release(p_dev);
1001 kfree(card);
1002
1003 lbs_deb_leave(LBS_DEB_CS);
1004}
1005
1006
1007
1008
1009
1010
1011
1012static struct pcmcia_device_id if_cs_ids[] = {
1013 PCMCIA_DEVICE_MANF_CARD(CF8305_MANFID, CF8305_CARDID),
1014 PCMCIA_DEVICE_MANF_CARD(CF8381_MANFID, CF8381_CARDID),
1015 PCMCIA_DEVICE_MANF_CARD(CF8385_MANFID, CF8385_CARDID),
1016 PCMCIA_DEVICE_NULL,
1017};
1018MODULE_DEVICE_TABLE(pcmcia, if_cs_ids);
1019
1020
1021static struct pcmcia_driver lbs_driver = {
1022 .owner = THIS_MODULE,
1023 .drv = {
1024 .name = DRV_NAME,
1025 },
1026 .probe = if_cs_probe,
1027 .remove = if_cs_detach,
1028 .id_table = if_cs_ids,
1029};
1030
1031
1032static int __init if_cs_init(void)
1033{
1034 int ret;
1035
1036 lbs_deb_enter(LBS_DEB_CS);
1037 ret = pcmcia_register_driver(&lbs_driver);
1038 lbs_deb_leave(LBS_DEB_CS);
1039 return ret;
1040}
1041
1042
1043static void __exit if_cs_exit(void)
1044{
1045 lbs_deb_enter(LBS_DEB_CS);
1046 pcmcia_unregister_driver(&lbs_driver);
1047 lbs_deb_leave(LBS_DEB_CS);
1048}
1049
1050
1051module_init(if_cs_init);
1052module_exit(if_cs_exit);
1053