Merge git://git.kernel.org/pub/scm/linux/kernel/git/brodo/pcmcia-2.6
[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
347         BUG_ON(!info->hdev);
348
349         iobase = info->p_dev->io.BasePort1;
350
351         spin_lock(&(info->lock));
352
353         iir = inb(iobase + CONTROL);
354         if (iir & 0x80) {
355                 int stat = bt3c_read(iobase, 0x7001);
356
357                 if ((stat & 0xff) == 0x7f) {
358                         BT_ERR("Very strange (stat=0x%04x)", stat);
359                 } else if ((stat & 0xff) != 0xff) {
360                         if (stat & 0x0020) {
361                                 int stat = bt3c_read(iobase, 0x7002) & 0x10;
362                                 BT_INFO("%s: Antenna %s", info->hdev->name,
363                                                         stat ? "out" : "in");
364                         }
365                         if (stat & 0x0001)
366                                 bt3c_receive(info);
367                         if (stat & 0x0002) {
368                                 //BT_ERR("Ack (stat=0x%04x)", stat);
369                                 clear_bit(XMIT_SENDING, &(info->tx_state));
370                                 bt3c_write_wakeup(info);
371                         }
372
373                         bt3c_io_write(iobase, 0x7001, 0x0000);
374
375                         outb(iir, iobase + CONTROL);
376                 }
377         }
378
379         spin_unlock(&(info->lock));
380
381         return IRQ_HANDLED;
382 }
383
384
385
386 /* ======================== HCI interface ======================== */
387
388
389 static int bt3c_hci_flush(struct hci_dev *hdev)
390 {
391         bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
392
393         /* Drop TX queue */
394         skb_queue_purge(&(info->txq));
395
396         return 0;
397 }
398
399
400 static int bt3c_hci_open(struct hci_dev *hdev)
401 {
402         set_bit(HCI_RUNNING, &(hdev->flags));
403
404         return 0;
405 }
406
407
408 static int bt3c_hci_close(struct hci_dev *hdev)
409 {
410         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
411                 return 0;
412
413         bt3c_hci_flush(hdev);
414
415         return 0;
416 }
417
418
419 static int bt3c_hci_send_frame(struct sk_buff *skb)
420 {
421         bt3c_info_t *info;
422         struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
423         unsigned long flags;
424
425         if (!hdev) {
426                 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
427                 return -ENODEV;
428         }
429
430         info = (bt3c_info_t *) (hdev->driver_data);
431
432         switch (bt_cb(skb)->pkt_type) {
433         case HCI_COMMAND_PKT:
434                 hdev->stat.cmd_tx++;
435                 break;
436         case HCI_ACLDATA_PKT:
437                 hdev->stat.acl_tx++;
438                 break;
439         case HCI_SCODATA_PKT:
440                 hdev->stat.sco_tx++;
441                 break;
442         };
443
444         /* Prepend skb with frame type */
445         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
446         skb_queue_tail(&(info->txq), skb);
447
448         spin_lock_irqsave(&(info->lock), flags);
449
450         bt3c_write_wakeup(info);
451
452         spin_unlock_irqrestore(&(info->lock), flags);
453
454         return 0;
455 }
456
457
458 static void bt3c_hci_destruct(struct hci_dev *hdev)
459 {
460 }
461
462
463 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
464 {
465         return -ENOIOCTLCMD;
466 }
467
468
469
470 /* ======================== Card services HCI interaction ======================== */
471
472
473 static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
474                               int count)
475 {
476         char *ptr = (char *) firmware;
477         char b[9];
478         unsigned int iobase, size, addr, fcs, tmp;
479         int i, err = 0;
480
481         iobase = info->p_dev->io.BasePort1;
482
483         /* Reset */
484         bt3c_io_write(iobase, 0x8040, 0x0404);
485         bt3c_io_write(iobase, 0x8040, 0x0400);
486
487         udelay(1);
488
489         bt3c_io_write(iobase, 0x8040, 0x0404);
490
491         udelay(17);
492
493         /* Load */
494         while (count) {
495                 if (ptr[0] != 'S') {
496                         BT_ERR("Bad address in firmware");
497                         err = -EFAULT;
498                         goto error;
499                 }
500
501                 memset(b, 0, sizeof(b));
502                 memcpy(b, ptr + 2, 2);
503                 size = simple_strtol(b, NULL, 16);
504
505                 memset(b, 0, sizeof(b));
506                 memcpy(b, ptr + 4, 8);
507                 addr = simple_strtol(b, NULL, 16);
508
509                 memset(b, 0, sizeof(b));
510                 memcpy(b, ptr + (size * 2) + 2, 2);
511                 fcs = simple_strtol(b, NULL, 16);
512
513                 memset(b, 0, sizeof(b));
514                 for (tmp = 0, i = 0; i < size; i++) {
515                         memcpy(b, ptr + (i * 2) + 2, 2);
516                         tmp += simple_strtol(b, NULL, 16);
517                 }
518
519                 if (((tmp + fcs) & 0xff) != 0xff) {
520                         BT_ERR("Checksum error in firmware");
521                         err = -EILSEQ;
522                         goto error;
523                 }
524
525                 if (ptr[1] == '3') {
526                         bt3c_address(iobase, addr);
527
528                         memset(b, 0, sizeof(b));
529                         for (i = 0; i < (size - 4) / 2; i++) {
530                                 memcpy(b, ptr + (i * 4) + 12, 4);
531                                 tmp = simple_strtol(b, NULL, 16);
532                                 bt3c_put(iobase, tmp);
533                         }
534                 }
535
536                 ptr   += (size * 2) + 6;
537                 count -= (size * 2) + 6;
538         }
539
540         udelay(17);
541
542         /* Boot */
543         bt3c_address(iobase, 0x3000);
544         outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
545
546 error:
547         udelay(17);
548
549         /* Clear */
550         bt3c_io_write(iobase, 0x7006, 0x0000);
551         bt3c_io_write(iobase, 0x7005, 0x0000);
552         bt3c_io_write(iobase, 0x7001, 0x0000);
553
554         return err;
555 }
556
557
558 static int bt3c_open(bt3c_info_t *info)
559 {
560         const struct firmware *firmware;
561         struct hci_dev *hdev;
562         int err;
563
564         spin_lock_init(&(info->lock));
565
566         skb_queue_head_init(&(info->txq));
567
568         info->rx_state = RECV_WAIT_PACKET_TYPE;
569         info->rx_count = 0;
570         info->rx_skb = NULL;
571
572         /* Initialize HCI device */
573         hdev = hci_alloc_dev();
574         if (!hdev) {
575                 BT_ERR("Can't allocate HCI device");
576                 return -ENOMEM;
577         }
578
579         info->hdev = hdev;
580
581         hdev->type = HCI_PCCARD;
582         hdev->driver_data = info;
583         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
584
585         hdev->open     = bt3c_hci_open;
586         hdev->close    = bt3c_hci_close;
587         hdev->flush    = bt3c_hci_flush;
588         hdev->send     = bt3c_hci_send_frame;
589         hdev->destruct = bt3c_hci_destruct;
590         hdev->ioctl    = bt3c_hci_ioctl;
591
592         hdev->owner = THIS_MODULE;
593
594         /* Load firmware */
595         err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
596         if (err < 0) {
597                 BT_ERR("Firmware request failed");
598                 goto error;
599         }
600
601         err = bt3c_load_firmware(info, firmware->data, firmware->size);
602
603         release_firmware(firmware);
604
605         if (err < 0) {
606                 BT_ERR("Firmware loading failed");
607                 goto error;
608         }
609
610         /* Timeout before it is safe to send the first HCI packet */
611         msleep(1000);
612
613         /* Register HCI device */
614         err = hci_register_dev(hdev);
615         if (err < 0) {
616                 BT_ERR("Can't register HCI device");
617                 goto error;
618         }
619
620         return 0;
621
622 error:
623         info->hdev = NULL;
624         hci_free_dev(hdev);
625         return err;
626 }
627
628
629 static int bt3c_close(bt3c_info_t *info)
630 {
631         struct hci_dev *hdev = info->hdev;
632
633         if (!hdev)
634                 return -ENODEV;
635
636         bt3c_hci_close(hdev);
637
638         if (hci_unregister_dev(hdev) < 0)
639                 BT_ERR("Can't unregister HCI device %s", hdev->name);
640
641         hci_free_dev(hdev);
642
643         return 0;
644 }
645
646 static int bt3c_probe(struct pcmcia_device *link)
647 {
648         bt3c_info_t *info;
649
650         /* Create new info device */
651         info = kzalloc(sizeof(*info), GFP_KERNEL);
652         if (!info)
653                 return -ENOMEM;
654
655         info->p_dev = link;
656         link->priv = info;
657
658         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
659         link->io.NumPorts1 = 8;
660         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
661         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
662
663         link->irq.Handler = bt3c_interrupt;
664         link->irq.Instance = info;
665
666         link->conf.Attributes = CONF_ENABLE_IRQ;
667         link->conf.IntType = INT_MEMORY_AND_IO;
668
669         return bt3c_config(link);
670 }
671
672
673 static void bt3c_detach(struct pcmcia_device *link)
674 {
675         bt3c_info_t *info = link->priv;
676
677         bt3c_release(link);
678         kfree(info);
679 }
680
681 static int bt3c_check_config(struct pcmcia_device *p_dev,
682                              cistpl_cftable_entry_t *cf,
683                              cistpl_cftable_entry_t *dflt,
684                              unsigned int vcc,
685                              void *priv_data)
686 {
687         unsigned long try = (unsigned long) priv_data;
688
689         if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
690                 p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
691         if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
692             (cf->io.win[0].base != 0)) {
693                 p_dev->io.BasePort1 = cf->io.win[0].base;
694                 p_dev->io.IOAddrLines = (try == 0) ? 16 :
695                         cf->io.flags & CISTPL_IO_LINES_MASK;
696                 if (!pcmcia_request_io(p_dev, &p_dev->io))
697                         return 0;
698         }
699         return -ENODEV;
700 }
701
702 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
703                                       cistpl_cftable_entry_t *cf,
704                                       cistpl_cftable_entry_t *dflt,
705                                       unsigned int vcc,
706                                       void *priv_data)
707 {
708         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
709         int j;
710
711         if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
712                 for (j = 0; j < 5; j++) {
713                         p_dev->io.BasePort1 = base[j];
714                         p_dev->io.IOAddrLines = base[j] ? 16 : 3;
715                         if (!pcmcia_request_io(p_dev, &p_dev->io))
716                                 return 0;
717                 }
718         }
719         return -ENODEV;
720 }
721
722 static int bt3c_config(struct pcmcia_device *link)
723 {
724         bt3c_info_t *info = link->priv;
725         int i;
726         unsigned long try;
727
728         /* First pass: look for a config entry that looks normal.
729            Two tries: without IO aliases, then with aliases */
730         for (try = 0; try < 2; try++)
731                 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
732                         goto found_port;
733
734         /* Second pass: try to find an entry that isn't picky about
735            its base address, then try to grab any standard serial port
736            address, and finally try to get any free port. */
737         if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
738                 goto found_port;
739
740         BT_ERR("No usable port range found");
741         cs_error(link, RequestIO, -ENODEV);
742         goto failed;
743
744 found_port:
745         i = pcmcia_request_irq(link, &link->irq);
746         if (i != 0) {
747                 cs_error(link, RequestIRQ, i);
748                 link->irq.AssignedIRQ = 0;
749         }
750
751         i = pcmcia_request_configuration(link, &link->conf);
752         if (i != 0) {
753                 cs_error(link, RequestConfiguration, i);
754                 goto failed;
755         }
756
757         if (bt3c_open(info) != 0)
758                 goto failed;
759
760         strcpy(info->node.dev_name, info->hdev->name);
761         link->dev_node = &info->node;
762
763         return 0;
764
765 failed:
766         bt3c_release(link);
767         return -ENODEV;
768 }
769
770
771 static void bt3c_release(struct pcmcia_device *link)
772 {
773         bt3c_info_t *info = link->priv;
774
775         bt3c_close(info);
776
777         pcmcia_disable_device(link);
778 }
779
780
781 static struct pcmcia_device_id bt3c_ids[] = {
782         PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
783         PCMCIA_DEVICE_NULL
784 };
785 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
786
787 static struct pcmcia_driver bt3c_driver = {
788         .owner          = THIS_MODULE,
789         .drv            = {
790                 .name   = "bt3c_cs",
791         },
792         .probe          = bt3c_probe,
793         .remove         = bt3c_detach,
794         .id_table       = bt3c_ids,
795 };
796
797 static int __init init_bt3c_cs(void)
798 {
799         return pcmcia_register_driver(&bt3c_driver);
800 }
801
802
803 static void __exit exit_bt3c_cs(void)
804 {
805         pcmcia_unregister_driver(&bt3c_driver);
806 }
807
808 module_init(init_bt3c_cs);
809 module_exit(exit_bt3c_cs);