pcmcia: re-work pcmcia_request_irq()
[linux-2.6.git] / drivers / bluetooth / bt3c_cs.c
1 /*
2  *
3  *  Driver for the 3Com Bluetooth PCMCIA card
4  *
5  *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org>
6  *                           Jose Orlando Pereira <jop@di.uminho.pt>
7  *
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License version 2 as
11  *  published by the Free Software Foundation;
12  *
13  *  Software distributed under the License is distributed on an "AS
14  *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
15  *  implied. See the License for the specific language governing
16  *  rights and limitations under the License.
17  *
18  *  The initial developer of the original code is David A. Hinds
19  *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
20  *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
21  *
22  */
23
24 #include <linux/module.h>
25
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/slab.h>
29 #include <linux/types.h>
30 #include <linux/delay.h>
31 #include <linux/errno.h>
32 #include <linux/ptrace.h>
33 #include <linux/ioport.h>
34 #include <linux/spinlock.h>
35 #include <linux/moduleparam.h>
36
37 #include <linux/skbuff.h>
38 #include <linux/string.h>
39 #include <linux/serial.h>
40 #include <linux/serial_reg.h>
41 #include <linux/bitops.h>
42 #include <asm/system.h>
43 #include <asm/io.h>
44
45 #include <linux/device.h>
46 #include <linux/firmware.h>
47
48 #include <pcmcia/cs_types.h>
49 #include <pcmcia/cs.h>
50 #include <pcmcia/cistpl.h>
51 #include <pcmcia/ciscode.h>
52 #include <pcmcia/ds.h>
53 #include <pcmcia/cisreg.h>
54
55 #include <net/bluetooth/bluetooth.h>
56 #include <net/bluetooth/hci_core.h>
57
58
59
60 /* ======================== Module parameters ======================== */
61
62
63 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
64 MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
65 MODULE_LICENSE("GPL");
66 MODULE_FIRMWARE("BT3CPCC.bin");
67
68
69
70 /* ======================== Local structures ======================== */
71
72
73 typedef struct bt3c_info_t {
74         struct pcmcia_device *p_dev;
75         dev_node_t node;
76
77         struct hci_dev *hdev;
78
79         spinlock_t lock;                /* For serializing operations */
80
81         struct sk_buff_head txq;
82         unsigned long tx_state;
83
84         unsigned long rx_state;
85         unsigned long rx_count;
86         struct sk_buff *rx_skb;
87 } bt3c_info_t;
88
89
90 static int bt3c_config(struct pcmcia_device *link);
91 static void bt3c_release(struct pcmcia_device *link);
92
93 static void bt3c_detach(struct pcmcia_device *p_dev);
94
95
96 /* Transmit states  */
97 #define XMIT_SENDING  1
98 #define XMIT_WAKEUP   2
99 #define XMIT_WAITING  8
100
101 /* Receiver states */
102 #define RECV_WAIT_PACKET_TYPE   0
103 #define RECV_WAIT_EVENT_HEADER  1
104 #define RECV_WAIT_ACL_HEADER    2
105 #define RECV_WAIT_SCO_HEADER    3
106 #define RECV_WAIT_DATA          4
107
108
109
110 /* ======================== Special I/O functions ======================== */
111
112
113 #define DATA_L   0
114 #define DATA_H   1
115 #define ADDR_L   2
116 #define ADDR_H   3
117 #define CONTROL  4
118
119
120 static inline void bt3c_address(unsigned int iobase, unsigned short addr)
121 {
122         outb(addr & 0xff, iobase + ADDR_L);
123         outb((addr >> 8) & 0xff, iobase + ADDR_H);
124 }
125
126
127 static inline void bt3c_put(unsigned int iobase, unsigned short value)
128 {
129         outb(value & 0xff, iobase + DATA_L);
130         outb((value >> 8) & 0xff, iobase + DATA_H);
131 }
132
133
134 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
135 {
136         bt3c_address(iobase, addr);
137         bt3c_put(iobase, value);
138 }
139
140
141 static inline unsigned short bt3c_get(unsigned int iobase)
142 {
143         unsigned short value = inb(iobase + DATA_L);
144
145         value |= inb(iobase + DATA_H) << 8;
146
147         return value;
148 }
149
150
151 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
152 {
153         bt3c_address(iobase, addr);
154
155         return bt3c_get(iobase);
156 }
157
158
159
160 /* ======================== Interrupt handling ======================== */
161
162
163 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
164 {
165         int actual = 0;
166
167         bt3c_address(iobase, 0x7080);
168
169         /* Fill FIFO with current frame */
170         while (actual < len) {
171                 /* Transmit next byte */
172                 bt3c_put(iobase, buf[actual]);
173                 actual++;
174         }
175
176         bt3c_io_write(iobase, 0x7005, actual);
177
178         return actual;
179 }
180
181
182 static void bt3c_write_wakeup(bt3c_info_t *info)
183 {
184         if (!info) {
185                 BT_ERR("Unknown device");
186                 return;
187         }
188
189         if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
190                 return;
191
192         do {
193                 register unsigned int iobase = info->p_dev->io.BasePort1;
194                 register struct sk_buff *skb;
195                 register int len;
196
197                 if (!pcmcia_dev_present(info->p_dev))
198                         break;
199
200
201                 if (!(skb = skb_dequeue(&(info->txq)))) {
202                         clear_bit(XMIT_SENDING, &(info->tx_state));
203                         break;
204                 }
205
206                 /* Send frame */
207                 len = bt3c_write(iobase, 256, skb->data, skb->len);
208
209                 if (len != skb->len) {
210                         BT_ERR("Very strange");
211                 }
212
213                 kfree_skb(skb);
214
215                 info->hdev->stat.byte_tx += len;
216
217         } while (0);
218 }
219
220
221 static void bt3c_receive(bt3c_info_t *info)
222 {
223         unsigned int iobase;
224         int size = 0, avail;
225
226         if (!info) {
227                 BT_ERR("Unknown device");
228                 return;
229         }
230
231         iobase = info->p_dev->io.BasePort1;
232
233         avail = bt3c_read(iobase, 0x7006);
234         //printk("bt3c_cs: receiving %d bytes\n", avail);
235
236         bt3c_address(iobase, 0x7480);
237         while (size < avail) {
238                 size++;
239                 info->hdev->stat.byte_rx++;
240
241                 /* Allocate packet */
242                 if (info->rx_skb == NULL) {
243                         info->rx_state = RECV_WAIT_PACKET_TYPE;
244                         info->rx_count = 0;
245                         if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
246                                 BT_ERR("Can't allocate mem for new packet");
247                                 return;
248                         }
249                 }
250
251
252                 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
253
254                         info->rx_skb->dev = (void *) info->hdev;
255                         bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
256                         inb(iobase + DATA_H);
257                         //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
258
259                         switch (bt_cb(info->rx_skb)->pkt_type) {
260
261                         case HCI_EVENT_PKT:
262                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
263                                 info->rx_count = HCI_EVENT_HDR_SIZE;
264                                 break;
265
266                         case HCI_ACLDATA_PKT:
267                                 info->rx_state = RECV_WAIT_ACL_HEADER;
268                                 info->rx_count = HCI_ACL_HDR_SIZE;
269                                 break;
270
271                         case HCI_SCODATA_PKT:
272                                 info->rx_state = RECV_WAIT_SCO_HEADER;
273                                 info->rx_count = HCI_SCO_HDR_SIZE;
274                                 break;
275
276                         default:
277                                 /* Unknown packet */
278                                 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
279                                 info->hdev->stat.err_rx++;
280                                 clear_bit(HCI_RUNNING, &(info->hdev->flags));
281
282                                 kfree_skb(info->rx_skb);
283                                 info->rx_skb = NULL;
284                                 break;
285
286                         }
287
288                 } else {
289
290                         __u8 x = inb(iobase + DATA_L);
291
292                         *skb_put(info->rx_skb, 1) = x;
293                         inb(iobase + DATA_H);
294                         info->rx_count--;
295
296                         if (info->rx_count == 0) {
297
298                                 int dlen;
299                                 struct hci_event_hdr *eh;
300                                 struct hci_acl_hdr *ah;
301                                 struct hci_sco_hdr *sh;
302
303                                 switch (info->rx_state) {
304
305                                 case RECV_WAIT_EVENT_HEADER:
306                                         eh = hci_event_hdr(info->rx_skb);
307                                         info->rx_state = RECV_WAIT_DATA;
308                                         info->rx_count = eh->plen;
309                                         break;
310
311                                 case RECV_WAIT_ACL_HEADER:
312                                         ah = hci_acl_hdr(info->rx_skb);
313                                         dlen = __le16_to_cpu(ah->dlen);
314                                         info->rx_state = RECV_WAIT_DATA;
315                                         info->rx_count = dlen;
316                                         break;
317
318                                 case RECV_WAIT_SCO_HEADER:
319                                         sh = hci_sco_hdr(info->rx_skb);
320                                         info->rx_state = RECV_WAIT_DATA;
321                                         info->rx_count = sh->dlen;
322                                         break;
323
324                                 case RECV_WAIT_DATA:
325                                         hci_recv_frame(info->rx_skb);
326                                         info->rx_skb = NULL;
327                                         break;
328
329                                 }
330
331                         }
332
333                 }
334
335         }
336
337         bt3c_io_write(iobase, 0x7006, 0x0000);
338 }
339
340
341 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
342 {
343         bt3c_info_t *info = dev_inst;
344         unsigned int iobase;
345         int iir;
346         irqreturn_t r = IRQ_NONE;
347
348         if (!info || !info->hdev)
349                 /* our irq handler is shared */
350                 return IRQ_NONE;
351
352         iobase = info->p_dev->io.BasePort1;
353
354         spin_lock(&(info->lock));
355
356         iir = inb(iobase + CONTROL);
357         if (iir & 0x80) {
358                 int stat = bt3c_read(iobase, 0x7001);
359
360                 if ((stat & 0xff) == 0x7f) {
361                         BT_ERR("Very strange (stat=0x%04x)", stat);
362                 } else if ((stat & 0xff) != 0xff) {
363                         if (stat & 0x0020) {
364                                 int status = bt3c_read(iobase, 0x7002) & 0x10;
365                                 BT_INFO("%s: Antenna %s", info->hdev->name,
366                                                         status ? "out" : "in");
367                         }
368                         if (stat & 0x0001)
369                                 bt3c_receive(info);
370                         if (stat & 0x0002) {
371                                 //BT_ERR("Ack (stat=0x%04x)", stat);
372                                 clear_bit(XMIT_SENDING, &(info->tx_state));
373                                 bt3c_write_wakeup(info);
374                         }
375
376                         bt3c_io_write(iobase, 0x7001, 0x0000);
377
378                         outb(iir, iobase + CONTROL);
379                 }
380                 r = IRQ_HANDLED;
381         }
382
383         spin_unlock(&(info->lock));
384
385         return r;
386 }
387
388
389
390 /* ======================== HCI interface ======================== */
391
392
393 static int bt3c_hci_flush(struct hci_dev *hdev)
394 {
395         bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
396
397         /* Drop TX queue */
398         skb_queue_purge(&(info->txq));
399
400         return 0;
401 }
402
403
404 static int bt3c_hci_open(struct hci_dev *hdev)
405 {
406         set_bit(HCI_RUNNING, &(hdev->flags));
407
408         return 0;
409 }
410
411
412 static int bt3c_hci_close(struct hci_dev *hdev)
413 {
414         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
415                 return 0;
416
417         bt3c_hci_flush(hdev);
418
419         return 0;
420 }
421
422
423 static int bt3c_hci_send_frame(struct sk_buff *skb)
424 {
425         bt3c_info_t *info;
426         struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
427         unsigned long flags;
428
429         if (!hdev) {
430                 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
431                 return -ENODEV;
432         }
433
434         info = (bt3c_info_t *) (hdev->driver_data);
435
436         switch (bt_cb(skb)->pkt_type) {
437         case HCI_COMMAND_PKT:
438                 hdev->stat.cmd_tx++;
439                 break;
440         case HCI_ACLDATA_PKT:
441                 hdev->stat.acl_tx++;
442                 break;
443         case HCI_SCODATA_PKT:
444                 hdev->stat.sco_tx++;
445                 break;
446         };
447
448         /* Prepend skb with frame type */
449         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
450         skb_queue_tail(&(info->txq), skb);
451
452         spin_lock_irqsave(&(info->lock), flags);
453
454         bt3c_write_wakeup(info);
455
456         spin_unlock_irqrestore(&(info->lock), flags);
457
458         return 0;
459 }
460
461
462 static void bt3c_hci_destruct(struct hci_dev *hdev)
463 {
464 }
465
466
467 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
468 {
469         return -ENOIOCTLCMD;
470 }
471
472
473
474 /* ======================== Card services HCI interaction ======================== */
475
476
477 static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
478                               int count)
479 {
480         char *ptr = (char *) firmware;
481         char b[9];
482         unsigned int iobase, size, addr, fcs, tmp;
483         int i, err = 0;
484
485         iobase = info->p_dev->io.BasePort1;
486
487         /* Reset */
488         bt3c_io_write(iobase, 0x8040, 0x0404);
489         bt3c_io_write(iobase, 0x8040, 0x0400);
490
491         udelay(1);
492
493         bt3c_io_write(iobase, 0x8040, 0x0404);
494
495         udelay(17);
496
497         /* Load */
498         while (count) {
499                 if (ptr[0] != 'S') {
500                         BT_ERR("Bad address in firmware");
501                         err = -EFAULT;
502                         goto error;
503                 }
504
505                 memset(b, 0, sizeof(b));
506                 memcpy(b, ptr + 2, 2);
507                 size = simple_strtoul(b, NULL, 16);
508
509                 memset(b, 0, sizeof(b));
510                 memcpy(b, ptr + 4, 8);
511                 addr = simple_strtoul(b, NULL, 16);
512
513                 memset(b, 0, sizeof(b));
514                 memcpy(b, ptr + (size * 2) + 2, 2);
515                 fcs = simple_strtoul(b, NULL, 16);
516
517                 memset(b, 0, sizeof(b));
518                 for (tmp = 0, i = 0; i < size; i++) {
519                         memcpy(b, ptr + (i * 2) + 2, 2);
520                         tmp += simple_strtol(b, NULL, 16);
521                 }
522
523                 if (((tmp + fcs) & 0xff) != 0xff) {
524                         BT_ERR("Checksum error in firmware");
525                         err = -EILSEQ;
526                         goto error;
527                 }
528
529                 if (ptr[1] == '3') {
530                         bt3c_address(iobase, addr);
531
532                         memset(b, 0, sizeof(b));
533                         for (i = 0; i < (size - 4) / 2; i++) {
534                                 memcpy(b, ptr + (i * 4) + 12, 4);
535                                 tmp = simple_strtoul(b, NULL, 16);
536                                 bt3c_put(iobase, tmp);
537                         }
538                 }
539
540                 ptr   += (size * 2) + 6;
541                 count -= (size * 2) + 6;
542         }
543
544         udelay(17);
545
546         /* Boot */
547         bt3c_address(iobase, 0x3000);
548         outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
549
550 error:
551         udelay(17);
552
553         /* Clear */
554         bt3c_io_write(iobase, 0x7006, 0x0000);
555         bt3c_io_write(iobase, 0x7005, 0x0000);
556         bt3c_io_write(iobase, 0x7001, 0x0000);
557
558         return err;
559 }
560
561
562 static int bt3c_open(bt3c_info_t *info)
563 {
564         const struct firmware *firmware;
565         struct hci_dev *hdev;
566         int err;
567
568         spin_lock_init(&(info->lock));
569
570         skb_queue_head_init(&(info->txq));
571
572         info->rx_state = RECV_WAIT_PACKET_TYPE;
573         info->rx_count = 0;
574         info->rx_skb = NULL;
575
576         /* Initialize HCI device */
577         hdev = hci_alloc_dev();
578         if (!hdev) {
579                 BT_ERR("Can't allocate HCI device");
580                 return -ENOMEM;
581         }
582
583         info->hdev = hdev;
584
585         hdev->bus = HCI_PCCARD;
586         hdev->driver_data = info;
587         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
588
589         hdev->open     = bt3c_hci_open;
590         hdev->close    = bt3c_hci_close;
591         hdev->flush    = bt3c_hci_flush;
592         hdev->send     = bt3c_hci_send_frame;
593         hdev->destruct = bt3c_hci_destruct;
594         hdev->ioctl    = bt3c_hci_ioctl;
595
596         hdev->owner = THIS_MODULE;
597
598         /* Load firmware */
599         err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
600         if (err < 0) {
601                 BT_ERR("Firmware request failed");
602                 goto error;
603         }
604
605         err = bt3c_load_firmware(info, firmware->data, firmware->size);
606
607         release_firmware(firmware);
608
609         if (err < 0) {
610                 BT_ERR("Firmware loading failed");
611                 goto error;
612         }
613
614         /* Timeout before it is safe to send the first HCI packet */
615         msleep(1000);
616
617         /* Register HCI device */
618         err = hci_register_dev(hdev);
619         if (err < 0) {
620                 BT_ERR("Can't register HCI device");
621                 goto error;
622         }
623
624         return 0;
625
626 error:
627         info->hdev = NULL;
628         hci_free_dev(hdev);
629         return err;
630 }
631
632
633 static int bt3c_close(bt3c_info_t *info)
634 {
635         struct hci_dev *hdev = info->hdev;
636
637         if (!hdev)
638                 return -ENODEV;
639
640         bt3c_hci_close(hdev);
641
642         if (hci_unregister_dev(hdev) < 0)
643                 BT_ERR("Can't unregister HCI device %s", hdev->name);
644
645         hci_free_dev(hdev);
646
647         return 0;
648 }
649
650 static int bt3c_probe(struct pcmcia_device *link)
651 {
652         bt3c_info_t *info;
653
654         /* Create new info device */
655         info = kzalloc(sizeof(*info), GFP_KERNEL);
656         if (!info)
657                 return -ENOMEM;
658
659         info->p_dev = link;
660         link->priv = info;
661
662         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
663         link->io.NumPorts1 = 8;
664
665         link->conf.Attributes = CONF_ENABLE_IRQ;
666         link->conf.IntType = INT_MEMORY_AND_IO;
667
668         return bt3c_config(link);
669 }
670
671
672 static void bt3c_detach(struct pcmcia_device *link)
673 {
674         bt3c_info_t *info = link->priv;
675
676         bt3c_release(link);
677         kfree(info);
678 }
679
680 static int bt3c_check_config(struct pcmcia_device *p_dev,
681                              cistpl_cftable_entry_t *cf,
682                              cistpl_cftable_entry_t *dflt,
683                              unsigned int vcc,
684                              void *priv_data)
685 {
686         unsigned long try = (unsigned long) priv_data;
687
688         if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
689                 p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
690         if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
691             (cf->io.win[0].base != 0)) {
692                 p_dev->io.BasePort1 = cf->io.win[0].base;
693                 p_dev->io.IOAddrLines = (try == 0) ? 16 :
694                         cf->io.flags & CISTPL_IO_LINES_MASK;
695                 if (!pcmcia_request_io(p_dev, &p_dev->io))
696                         return 0;
697         }
698         return -ENODEV;
699 }
700
701 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
702                                       cistpl_cftable_entry_t *cf,
703                                       cistpl_cftable_entry_t *dflt,
704                                       unsigned int vcc,
705                                       void *priv_data)
706 {
707         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
708         int j;
709
710         if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
711                 for (j = 0; j < 5; j++) {
712                         p_dev->io.BasePort1 = base[j];
713                         p_dev->io.IOAddrLines = base[j] ? 16 : 3;
714                         if (!pcmcia_request_io(p_dev, &p_dev->io))
715                                 return 0;
716                 }
717         }
718         return -ENODEV;
719 }
720
721 static int bt3c_config(struct pcmcia_device *link)
722 {
723         bt3c_info_t *info = link->priv;
724         int i;
725         unsigned long try;
726
727         /* First pass: look for a config entry that looks normal.
728            Two tries: without IO aliases, then with aliases */
729         for (try = 0; try < 2; try++)
730                 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
731                         goto found_port;
732
733         /* Second pass: try to find an entry that isn't picky about
734            its base address, then try to grab any standard serial port
735            address, and finally try to get any free port. */
736         if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
737                 goto found_port;
738
739         BT_ERR("No usable port range found");
740         goto failed;
741
742 found_port:
743         i = pcmcia_request_irq(link, &bt3c_interrupt);
744         if (i != 0)
745                 goto failed;
746
747         i = pcmcia_request_configuration(link, &link->conf);
748         if (i != 0)
749                 goto failed;
750
751         if (bt3c_open(info) != 0)
752                 goto failed;
753
754         strcpy(info->node.dev_name, info->hdev->name);
755         link->dev_node = &info->node;
756
757         return 0;
758
759 failed:
760         bt3c_release(link);
761         return -ENODEV;
762 }
763
764
765 static void bt3c_release(struct pcmcia_device *link)
766 {
767         bt3c_info_t *info = link->priv;
768
769         bt3c_close(info);
770
771         pcmcia_disable_device(link);
772 }
773
774
775 static struct pcmcia_device_id bt3c_ids[] = {
776         PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
777         PCMCIA_DEVICE_NULL
778 };
779 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
780
781 static struct pcmcia_driver bt3c_driver = {
782         .owner          = THIS_MODULE,
783         .drv            = {
784                 .name   = "bt3c_cs",
785         },
786         .probe          = bt3c_probe,
787         .remove         = bt3c_detach,
788         .id_table       = bt3c_ids,
789 };
790
791 static int __init init_bt3c_cs(void)
792 {
793         return pcmcia_register_driver(&bt3c_driver);
794 }
795
796
797 static void __exit exit_bt3c_cs(void)
798 {
799         pcmcia_unregister_driver(&bt3c_driver);
800 }
801
802 module_init(init_bt3c_cs);
803 module_exit(exit_bt3c_cs);