2e0338d80f32c1db8ba8e2f1a4e524e08298aeb6
[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/config.h>
25 #include <linux/module.h>
26
27 #include <linux/kernel.h>
28 #include <linux/init.h>
29 #include <linux/slab.h>
30 #include <linux/types.h>
31 #include <linux/sched.h>
32 #include <linux/delay.h>
33 #include <linux/errno.h>
34 #include <linux/ptrace.h>
35 #include <linux/ioport.h>
36 #include <linux/spinlock.h>
37 #include <linux/moduleparam.h>
38
39 #include <linux/skbuff.h>
40 #include <linux/string.h>
41 #include <linux/serial.h>
42 #include <linux/serial_reg.h>
43 #include <linux/bitops.h>
44 #include <asm/system.h>
45 #include <asm/io.h>
46
47 #include <linux/device.h>
48 #include <linux/firmware.h>
49
50 #include <pcmcia/cs_types.h>
51 #include <pcmcia/cs.h>
52 #include <pcmcia/cistpl.h>
53 #include <pcmcia/ciscode.h>
54 #include <pcmcia/ds.h>
55 #include <pcmcia/cisreg.h>
56
57 #include <net/bluetooth/bluetooth.h>
58 #include <net/bluetooth/hci_core.h>
59
60
61
62 /* ======================== Module parameters ======================== */
63
64
65 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
66 MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
67 MODULE_LICENSE("GPL");
68
69
70
71 /* ======================== Local structures ======================== */
72
73
74 typedef struct bt3c_info_t {
75         dev_link_t link;
76         dev_node_t node;
77
78         struct hci_dev *hdev;
79
80         spinlock_t lock;                /* For serializing operations */
81
82         struct sk_buff_head txq;
83         unsigned long tx_state;
84
85         unsigned long rx_state;
86         unsigned long rx_count;
87         struct sk_buff *rx_skb;
88 } bt3c_info_t;
89
90
91 static void bt3c_config(dev_link_t *link);
92 static void bt3c_release(dev_link_t *link);
93 static int bt3c_event(event_t event, int priority, event_callback_args_t *args);
94
95 static dev_info_t dev_info = "bt3c_cs";
96
97 static dev_link_t *bt3c_attach(void);
98 static void bt3c_detach(dev_link_t *);
99
100 static dev_link_t *dev_list = NULL;
101
102
103 /* Transmit states  */
104 #define XMIT_SENDING  1
105 #define XMIT_WAKEUP   2
106 #define XMIT_WAITING  8
107
108 /* Receiver states */
109 #define RECV_WAIT_PACKET_TYPE   0
110 #define RECV_WAIT_EVENT_HEADER  1
111 #define RECV_WAIT_ACL_HEADER    2
112 #define RECV_WAIT_SCO_HEADER    3
113 #define RECV_WAIT_DATA          4
114
115
116
117 /* ======================== Special I/O functions ======================== */
118
119
120 #define DATA_L   0
121 #define DATA_H   1
122 #define ADDR_L   2
123 #define ADDR_H   3
124 #define CONTROL  4
125
126
127 static inline void bt3c_address(unsigned int iobase, unsigned short addr)
128 {
129         outb(addr & 0xff, iobase + ADDR_L);
130         outb((addr >> 8) & 0xff, iobase + ADDR_H);
131 }
132
133
134 static inline void bt3c_put(unsigned int iobase, unsigned short value)
135 {
136         outb(value & 0xff, iobase + DATA_L);
137         outb((value >> 8) & 0xff, iobase + DATA_H);
138 }
139
140
141 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
142 {
143         bt3c_address(iobase, addr);
144         bt3c_put(iobase, value);
145 }
146
147
148 static inline unsigned short bt3c_get(unsigned int iobase)
149 {
150         unsigned short value = inb(iobase + DATA_L);
151
152         value |= inb(iobase + DATA_H) << 8;
153
154         return value;
155 }
156
157
158 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
159 {
160         bt3c_address(iobase, addr);
161
162         return bt3c_get(iobase);
163 }
164
165
166
167 /* ======================== Interrupt handling ======================== */
168
169
170 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
171 {
172         int actual = 0;
173
174         bt3c_address(iobase, 0x7080);
175
176         /* Fill FIFO with current frame */
177         while (actual < len) {
178                 /* Transmit next byte */
179                 bt3c_put(iobase, buf[actual]);
180                 actual++;
181         }
182
183         bt3c_io_write(iobase, 0x7005, actual);
184
185         return actual;
186 }
187
188
189 static void bt3c_write_wakeup(bt3c_info_t *info)
190 {
191         if (!info) {
192                 BT_ERR("Unknown device");
193                 return;
194         }
195
196         if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
197                 return;
198
199         do {
200                 register unsigned int iobase = info->link.io.BasePort1;
201                 register struct sk_buff *skb;
202                 register int len;
203
204                 if (!(info->link.state & DEV_PRESENT))
205                         break;
206
207
208                 if (!(skb = skb_dequeue(&(info->txq)))) {
209                         clear_bit(XMIT_SENDING, &(info->tx_state));
210                         break;
211                 }
212
213                 /* Send frame */
214                 len = bt3c_write(iobase, 256, skb->data, skb->len);
215
216                 if (len != skb->len) {
217                         BT_ERR("Very strange");
218                 }
219
220                 kfree_skb(skb);
221
222                 info->hdev->stat.byte_tx += len;
223
224         } while (0);
225 }
226
227
228 static void bt3c_receive(bt3c_info_t *info)
229 {
230         unsigned int iobase;
231         int size = 0, avail;
232
233         if (!info) {
234                 BT_ERR("Unknown device");
235                 return;
236         }
237
238         iobase = info->link.io.BasePort1;
239
240         avail = bt3c_read(iobase, 0x7006);
241         //printk("bt3c_cs: receiving %d bytes\n", avail);
242
243         bt3c_address(iobase, 0x7480);
244         while (size < avail) {
245                 size++;
246                 info->hdev->stat.byte_rx++;
247
248                 /* Allocate packet */
249                 if (info->rx_skb == NULL) {
250                         info->rx_state = RECV_WAIT_PACKET_TYPE;
251                         info->rx_count = 0;
252                         if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
253                                 BT_ERR("Can't allocate mem for new packet");
254                                 return;
255                         }
256                 }
257
258
259                 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
260
261                         info->rx_skb->dev = (void *) info->hdev;
262                         bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
263                         inb(iobase + DATA_H);
264                         //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
265
266                         switch (bt_cb(info->rx_skb)->pkt_type) {
267
268                         case HCI_EVENT_PKT:
269                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
270                                 info->rx_count = HCI_EVENT_HDR_SIZE;
271                                 break;
272
273                         case HCI_ACLDATA_PKT:
274                                 info->rx_state = RECV_WAIT_ACL_HEADER;
275                                 info->rx_count = HCI_ACL_HDR_SIZE;
276                                 break;
277
278                         case HCI_SCODATA_PKT:
279                                 info->rx_state = RECV_WAIT_SCO_HEADER;
280                                 info->rx_count = HCI_SCO_HDR_SIZE;
281                                 break;
282
283                         default:
284                                 /* Unknown packet */
285                                 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
286                                 info->hdev->stat.err_rx++;
287                                 clear_bit(HCI_RUNNING, &(info->hdev->flags));
288
289                                 kfree_skb(info->rx_skb);
290                                 info->rx_skb = NULL;
291                                 break;
292
293                         }
294
295                 } else {
296
297                         __u8 x = inb(iobase + DATA_L);
298
299                         *skb_put(info->rx_skb, 1) = x;
300                         inb(iobase + DATA_H);
301                         info->rx_count--;
302
303                         if (info->rx_count == 0) {
304
305                                 int dlen;
306                                 struct hci_event_hdr *eh;
307                                 struct hci_acl_hdr *ah;
308                                 struct hci_sco_hdr *sh;
309
310                                 switch (info->rx_state) {
311
312                                 case RECV_WAIT_EVENT_HEADER:
313                                         eh = (struct hci_event_hdr *)(info->rx_skb->data);
314                                         info->rx_state = RECV_WAIT_DATA;
315                                         info->rx_count = eh->plen;
316                                         break;
317
318                                 case RECV_WAIT_ACL_HEADER:
319                                         ah = (struct hci_acl_hdr *)(info->rx_skb->data);
320                                         dlen = __le16_to_cpu(ah->dlen);
321                                         info->rx_state = RECV_WAIT_DATA;
322                                         info->rx_count = dlen;
323                                         break;
324
325                                 case RECV_WAIT_SCO_HEADER:
326                                         sh = (struct hci_sco_hdr *)(info->rx_skb->data);
327                                         info->rx_state = RECV_WAIT_DATA;
328                                         info->rx_count = sh->dlen;
329                                         break;
330
331                                 case RECV_WAIT_DATA:
332                                         hci_recv_frame(info->rx_skb);
333                                         info->rx_skb = NULL;
334                                         break;
335
336                                 }
337
338                         }
339
340                 }
341
342         }
343
344         bt3c_io_write(iobase, 0x7006, 0x0000);
345 }
346
347
348 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
349 {
350         bt3c_info_t *info = dev_inst;
351         unsigned int iobase;
352         int iir;
353
354         if (!info || !info->hdev) {
355                 BT_ERR("Call of irq %d for unknown device", irq);
356                 return IRQ_NONE;
357         }
358
359         iobase = info->link.io.BasePort1;
360
361         spin_lock(&(info->lock));
362
363         iir = inb(iobase + CONTROL);
364         if (iir & 0x80) {
365                 int stat = bt3c_read(iobase, 0x7001);
366
367                 if ((stat & 0xff) == 0x7f) {
368                         BT_ERR("Very strange (stat=0x%04x)", stat);
369                 } else if ((stat & 0xff) != 0xff) {
370                         if (stat & 0x0020) {
371                                 int stat = bt3c_read(iobase, 0x7002) & 0x10;
372                                 BT_INFO("%s: Antenna %s", info->hdev->name,
373                                                         stat ? "out" : "in");
374                         }
375                         if (stat & 0x0001)
376                                 bt3c_receive(info);
377                         if (stat & 0x0002) {
378                                 //BT_ERR("Ack (stat=0x%04x)", stat);
379                                 clear_bit(XMIT_SENDING, &(info->tx_state));
380                                 bt3c_write_wakeup(info);
381                         }
382
383                         bt3c_io_write(iobase, 0x7001, 0x0000);
384
385                         outb(iir, iobase + CONTROL);
386                 }
387         }
388
389         spin_unlock(&(info->lock));
390
391         return IRQ_HANDLED;
392 }
393
394
395
396 /* ======================== HCI interface ======================== */
397
398
399 static int bt3c_hci_flush(struct hci_dev *hdev)
400 {
401         bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
402
403         /* Drop TX queue */
404         skb_queue_purge(&(info->txq));
405
406         return 0;
407 }
408
409
410 static int bt3c_hci_open(struct hci_dev *hdev)
411 {
412         set_bit(HCI_RUNNING, &(hdev->flags));
413
414         return 0;
415 }
416
417
418 static int bt3c_hci_close(struct hci_dev *hdev)
419 {
420         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
421                 return 0;
422
423         bt3c_hci_flush(hdev);
424
425         return 0;
426 }
427
428
429 static int bt3c_hci_send_frame(struct sk_buff *skb)
430 {
431         bt3c_info_t *info;
432         struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
433         unsigned long flags;
434
435         if (!hdev) {
436                 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
437                 return -ENODEV;
438         }
439
440         info = (bt3c_info_t *) (hdev->driver_data);
441
442         switch (bt_cb(skb)->pkt_type) {
443         case HCI_COMMAND_PKT:
444                 hdev->stat.cmd_tx++;
445                 break;
446         case HCI_ACLDATA_PKT:
447                 hdev->stat.acl_tx++;
448                 break;
449         case HCI_SCODATA_PKT:
450                 hdev->stat.sco_tx++;
451                 break;
452         };
453
454         /* Prepend skb with frame type */
455         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
456         skb_queue_tail(&(info->txq), skb);
457
458         spin_lock_irqsave(&(info->lock), flags);
459
460         bt3c_write_wakeup(info);
461
462         spin_unlock_irqrestore(&(info->lock), flags);
463
464         return 0;
465 }
466
467
468 static void bt3c_hci_destruct(struct hci_dev *hdev)
469 {
470 }
471
472
473 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
474 {
475         return -ENOIOCTLCMD;
476 }
477
478
479
480 /* ======================== Card services HCI interaction ======================== */
481
482
483 static struct device *bt3c_device(void)
484 {
485         static struct device dev = {
486                 .bus_id = "pcmcia",
487         };
488         kobject_set_name(&dev.kobj, "bt3c");
489         kobject_init(&dev.kobj);
490
491         return &dev;
492 }
493
494
495 static int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, int count)
496 {
497         char *ptr = (char *) firmware;
498         char b[9];
499         unsigned int iobase, size, addr, fcs, tmp;
500         int i, err = 0;
501
502         iobase = info->link.io.BasePort1;
503
504         /* Reset */
505         bt3c_io_write(iobase, 0x8040, 0x0404);
506         bt3c_io_write(iobase, 0x8040, 0x0400);
507
508         udelay(1);
509
510         bt3c_io_write(iobase, 0x8040, 0x0404);
511
512         udelay(17);
513
514         /* Load */
515         while (count) {
516                 if (ptr[0] != 'S') {
517                         BT_ERR("Bad address in firmware");
518                         err = -EFAULT;
519                         goto error;
520                 }
521
522                 memset(b, 0, sizeof(b));
523                 memcpy(b, ptr + 2, 2);
524                 size = simple_strtol(b, NULL, 16);
525
526                 memset(b, 0, sizeof(b));
527                 memcpy(b, ptr + 4, 8);
528                 addr = simple_strtol(b, NULL, 16);
529
530                 memset(b, 0, sizeof(b));
531                 memcpy(b, ptr + (size * 2) + 2, 2);
532                 fcs = simple_strtol(b, NULL, 16);
533
534                 memset(b, 0, sizeof(b));
535                 for (tmp = 0, i = 0; i < size; i++) {
536                         memcpy(b, ptr + (i * 2) + 2, 2);
537                         tmp += simple_strtol(b, NULL, 16);
538                 }
539
540                 if (((tmp + fcs) & 0xff) != 0xff) {
541                         BT_ERR("Checksum error in firmware");
542                         err = -EILSEQ;
543                         goto error;
544                 }
545
546                 if (ptr[1] == '3') {
547                         bt3c_address(iobase, addr);
548
549                         memset(b, 0, sizeof(b));
550                         for (i = 0; i < (size - 4) / 2; i++) {
551                                 memcpy(b, ptr + (i * 4) + 12, 4);
552                                 tmp = simple_strtol(b, NULL, 16);
553                                 bt3c_put(iobase, tmp);
554                         }
555                 }
556
557                 ptr   += (size * 2) + 6;
558                 count -= (size * 2) + 6;
559         }
560
561         udelay(17);
562
563         /* Boot */
564         bt3c_address(iobase, 0x3000);
565         outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
566
567 error:
568         udelay(17);
569
570         /* Clear */
571         bt3c_io_write(iobase, 0x7006, 0x0000);
572         bt3c_io_write(iobase, 0x7005, 0x0000);
573         bt3c_io_write(iobase, 0x7001, 0x0000);
574
575         return err;
576 }
577
578
579 static int bt3c_open(bt3c_info_t *info)
580 {
581         const struct firmware *firmware;
582         struct hci_dev *hdev;
583         int err;
584
585         spin_lock_init(&(info->lock));
586
587         skb_queue_head_init(&(info->txq));
588
589         info->rx_state = RECV_WAIT_PACKET_TYPE;
590         info->rx_count = 0;
591         info->rx_skb = NULL;
592
593         /* Initialize HCI device */
594         hdev = hci_alloc_dev();
595         if (!hdev) {
596                 BT_ERR("Can't allocate HCI device");
597                 return -ENOMEM;
598         }
599
600         info->hdev = hdev;
601
602         hdev->type = HCI_PCCARD;
603         hdev->driver_data = info;
604
605         hdev->open     = bt3c_hci_open;
606         hdev->close    = bt3c_hci_close;
607         hdev->flush    = bt3c_hci_flush;
608         hdev->send     = bt3c_hci_send_frame;
609         hdev->destruct = bt3c_hci_destruct;
610         hdev->ioctl    = bt3c_hci_ioctl;
611
612         hdev->owner = THIS_MODULE;
613
614         /* Load firmware */
615         err = request_firmware(&firmware, "BT3CPCC.bin", bt3c_device());
616         if (err < 0) {
617                 BT_ERR("Firmware request failed");
618                 goto error;
619         }
620
621         err = bt3c_load_firmware(info, firmware->data, firmware->size);
622
623         release_firmware(firmware);
624
625         if (err < 0) {
626                 BT_ERR("Firmware loading failed");
627                 goto error;
628         }
629
630         /* Timeout before it is safe to send the first HCI packet */
631         msleep(1000);
632
633         /* Register HCI device */
634         err = hci_register_dev(hdev);
635         if (err < 0) {
636                 BT_ERR("Can't register HCI device");
637                 goto error;
638         }
639
640         return 0;
641
642 error:
643         info->hdev = NULL;
644         hci_free_dev(hdev);
645         return err;
646 }
647
648
649 static int bt3c_close(bt3c_info_t *info)
650 {
651         struct hci_dev *hdev = info->hdev;
652
653         if (!hdev)
654                 return -ENODEV;
655
656         bt3c_hci_close(hdev);
657
658         if (hci_unregister_dev(hdev) < 0)
659                 BT_ERR("Can't unregister HCI device %s", hdev->name);
660
661         hci_free_dev(hdev);
662
663         return 0;
664 }
665
666 static dev_link_t *bt3c_attach(void)
667 {
668         bt3c_info_t *info;
669         client_reg_t client_reg;
670         dev_link_t *link;
671         int ret;
672
673         /* Create new info device */
674         info = kmalloc(sizeof(*info), GFP_KERNEL);
675         if (!info)
676                 return NULL;
677         memset(info, 0, sizeof(*info));
678
679         link = &info->link;
680         link->priv = info;
681
682         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
683         link->io.NumPorts1 = 8;
684         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
685         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
686
687         link->irq.Handler = bt3c_interrupt;
688         link->irq.Instance = info;
689
690         link->conf.Attributes = CONF_ENABLE_IRQ;
691         link->conf.Vcc = 50;
692         link->conf.IntType = INT_MEMORY_AND_IO;
693
694         /* Register with Card Services */
695         link->next = dev_list;
696         dev_list = link;
697         client_reg.dev_info = &dev_info;
698         client_reg.Version = 0x0210;
699         client_reg.event_callback_args.client_data = link;
700
701         ret = pcmcia_register_client(&link->handle, &client_reg);
702         if (ret != CS_SUCCESS) {
703                 cs_error(link->handle, RegisterClient, ret);
704                 bt3c_detach(link);
705                 return NULL;
706         }
707
708         return link;
709 }
710
711
712 static void bt3c_detach(dev_link_t *link)
713 {
714         bt3c_info_t *info = link->priv;
715         dev_link_t **linkp;
716         int ret;
717
718         /* Locate device structure */
719         for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
720                 if (*linkp == link)
721                         break;
722
723         if (*linkp == NULL)
724                 return;
725
726         if (link->state & DEV_CONFIG)
727                 bt3c_release(link);
728
729         if (link->handle) {
730                 ret = pcmcia_deregister_client(link->handle);
731                 if (ret != CS_SUCCESS)
732                         cs_error(link->handle, DeregisterClient, ret);
733         }
734
735         /* Unlink device structure, free bits */
736         *linkp = link->next;
737
738         kfree(info);
739 }
740
741 static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
742 {
743         int i;
744
745         i = pcmcia_get_tuple_data(handle, tuple);
746         if (i != CS_SUCCESS)
747                 return i;
748
749         return pcmcia_parse_tuple(handle, tuple, parse);
750 }
751
752 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
753 {
754         if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
755                 return CS_NO_MORE_ITEMS;
756         return get_tuple(handle, tuple, parse);
757 }
758
759 static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
760 {
761         if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
762                 return CS_NO_MORE_ITEMS;
763         return get_tuple(handle, tuple, parse);
764 }
765
766 static void bt3c_config(dev_link_t *link)
767 {
768         static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
769         client_handle_t handle = link->handle;
770         bt3c_info_t *info = link->priv;
771         tuple_t tuple;
772         u_short buf[256];
773         cisparse_t parse;
774         cistpl_cftable_entry_t *cf = &parse.cftable_entry;
775         config_info_t config;
776         int i, j, try, last_ret, last_fn;
777
778         tuple.TupleData = (cisdata_t *)buf;
779         tuple.TupleOffset = 0;
780         tuple.TupleDataMax = 255;
781         tuple.Attributes = 0;
782
783         /* Get configuration register information */
784         tuple.DesiredTuple = CISTPL_CONFIG;
785         last_ret = first_tuple(handle, &tuple, &parse);
786         if (last_ret != CS_SUCCESS) {
787                 last_fn = ParseTuple;
788                 goto cs_failed;
789         }
790         link->conf.ConfigBase = parse.config.base;
791         link->conf.Present = parse.config.rmask[0];
792
793         /* Configure card */
794         link->state |= DEV_CONFIG;
795         i = pcmcia_get_configuration_info(handle, &config);
796         link->conf.Vcc = config.Vcc;
797
798         /* First pass: look for a config entry that looks normal. */
799         tuple.TupleData = (cisdata_t *)buf;
800         tuple.TupleOffset = 0;
801         tuple.TupleDataMax = 255;
802         tuple.Attributes = 0;
803         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
804         /* Two tries: without IO aliases, then with aliases */
805         for (try = 0; try < 2; try++) {
806                 i = first_tuple(handle, &tuple, &parse);
807                 while (i != CS_NO_MORE_ITEMS) {
808                         if (i != CS_SUCCESS)
809                                 goto next_entry;
810                         if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
811                                 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
812                         if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
813                                 link->conf.ConfigIndex = cf->index;
814                                 link->io.BasePort1 = cf->io.win[0].base;
815                                 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
816                                 i = pcmcia_request_io(link->handle, &link->io);
817                                 if (i == CS_SUCCESS)
818                                         goto found_port;
819                         }
820 next_entry:
821                         i = next_tuple(handle, &tuple, &parse);
822                 }
823         }
824
825         /* Second pass: try to find an entry that isn't picky about
826            its base address, then try to grab any standard serial port
827            address, and finally try to get any free port. */
828         i = first_tuple(handle, &tuple, &parse);
829         while (i != CS_NO_MORE_ITEMS) {
830                 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
831                         link->conf.ConfigIndex = cf->index;
832                         for (j = 0; j < 5; j++) {
833                                 link->io.BasePort1 = base[j];
834                                 link->io.IOAddrLines = base[j] ? 16 : 3;
835                                 i = pcmcia_request_io(link->handle, &link->io);
836                                 if (i == CS_SUCCESS)
837                                         goto found_port;
838                         }
839                 }
840                 i = next_tuple(handle, &tuple, &parse);
841         }
842
843 found_port:
844         if (i != CS_SUCCESS) {
845                 BT_ERR("No usable port range found");
846                 cs_error(link->handle, RequestIO, i);
847                 goto failed;
848         }
849
850         i = pcmcia_request_irq(link->handle, &link->irq);
851         if (i != CS_SUCCESS) {
852                 cs_error(link->handle, RequestIRQ, i);
853                 link->irq.AssignedIRQ = 0;
854         }
855
856         i = pcmcia_request_configuration(link->handle, &link->conf);
857         if (i != CS_SUCCESS) {
858                 cs_error(link->handle, RequestConfiguration, i);
859                 goto failed;
860         }
861
862         if (bt3c_open(info) != 0)
863                 goto failed;
864
865         strcpy(info->node.dev_name, info->hdev->name);
866         link->dev = &info->node;
867         link->state &= ~DEV_CONFIG_PENDING;
868
869         return;
870
871 cs_failed:
872         cs_error(link->handle, last_fn, last_ret);
873
874 failed:
875         bt3c_release(link);
876 }
877
878
879 static void bt3c_release(dev_link_t *link)
880 {
881         bt3c_info_t *info = link->priv;
882
883         if (link->state & DEV_PRESENT)
884                 bt3c_close(info);
885
886         link->dev = NULL;
887
888         pcmcia_release_configuration(link->handle);
889         pcmcia_release_io(link->handle, &link->io);
890         pcmcia_release_irq(link->handle, &link->irq);
891
892         link->state &= ~DEV_CONFIG;
893 }
894
895
896 static int bt3c_event(event_t event, int priority, event_callback_args_t *args)
897 {
898         dev_link_t *link = args->client_data;
899         bt3c_info_t *info = link->priv;
900
901         switch (event) {
902         case CS_EVENT_CARD_REMOVAL:
903                 link->state &= ~DEV_PRESENT;
904                 if (link->state & DEV_CONFIG) {
905                         bt3c_close(info);
906                         bt3c_release(link);
907                 }
908                 break;
909         case CS_EVENT_CARD_INSERTION:
910                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
911                 bt3c_config(link);
912                 break;
913         case CS_EVENT_PM_SUSPEND:
914                 link->state |= DEV_SUSPEND;
915                 /* Fall through... */
916         case CS_EVENT_RESET_PHYSICAL:
917                 if (link->state & DEV_CONFIG)
918                         pcmcia_release_configuration(link->handle);
919                 break;
920         case CS_EVENT_PM_RESUME:
921                 link->state &= ~DEV_SUSPEND;
922                 /* Fall through... */
923         case CS_EVENT_CARD_RESET:
924                 if (DEV_OK(link))
925                         pcmcia_request_configuration(link->handle, &link->conf);
926                 break;
927         }
928
929         return 0;
930 }
931
932 static struct pcmcia_device_id bt3c_ids[] = {
933         PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
934         PCMCIA_DEVICE_NULL
935 };
936 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
937
938 static struct pcmcia_driver bt3c_driver = {
939         .owner          = THIS_MODULE,
940         .drv            = {
941                 .name   = "bt3c_cs",
942         },
943         .attach         = bt3c_attach,
944         .event          = bt3c_event,
945         .detach         = bt3c_detach,
946         .id_table       = bt3c_ids,
947 };
948
949 static int __init init_bt3c_cs(void)
950 {
951         return pcmcia_register_driver(&bt3c_driver);
952 }
953
954
955 static void __exit exit_bt3c_cs(void)
956 {
957         pcmcia_unregister_driver(&bt3c_driver);
958         BUG_ON(dev_list != NULL);
959 }
960
961 module_init(init_bt3c_cs);
962 module_exit(exit_bt3c_cs);