[Bluetooth] Fix firmware loading problem of BT3C driver
[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
94 static void bt3c_detach(struct pcmcia_device *p_dev);
95
96
97 /* Transmit states  */
98 #define XMIT_SENDING  1
99 #define XMIT_WAKEUP   2
100 #define XMIT_WAITING  8
101
102 /* Receiver states */
103 #define RECV_WAIT_PACKET_TYPE   0
104 #define RECV_WAIT_EVENT_HEADER  1
105 #define RECV_WAIT_ACL_HEADER    2
106 #define RECV_WAIT_SCO_HEADER    3
107 #define RECV_WAIT_DATA          4
108
109
110
111 /* ======================== Special I/O functions ======================== */
112
113
114 #define DATA_L   0
115 #define DATA_H   1
116 #define ADDR_L   2
117 #define ADDR_H   3
118 #define CONTROL  4
119
120
121 static inline void bt3c_address(unsigned int iobase, unsigned short addr)
122 {
123         outb(addr & 0xff, iobase + ADDR_L);
124         outb((addr >> 8) & 0xff, iobase + ADDR_H);
125 }
126
127
128 static inline void bt3c_put(unsigned int iobase, unsigned short value)
129 {
130         outb(value & 0xff, iobase + DATA_L);
131         outb((value >> 8) & 0xff, iobase + DATA_H);
132 }
133
134
135 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
136 {
137         bt3c_address(iobase, addr);
138         bt3c_put(iobase, value);
139 }
140
141
142 static inline unsigned short bt3c_get(unsigned int iobase)
143 {
144         unsigned short value = inb(iobase + DATA_L);
145
146         value |= inb(iobase + DATA_H) << 8;
147
148         return value;
149 }
150
151
152 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
153 {
154         bt3c_address(iobase, addr);
155
156         return bt3c_get(iobase);
157 }
158
159
160
161 /* ======================== Interrupt handling ======================== */
162
163
164 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
165 {
166         int actual = 0;
167
168         bt3c_address(iobase, 0x7080);
169
170         /* Fill FIFO with current frame */
171         while (actual < len) {
172                 /* Transmit next byte */
173                 bt3c_put(iobase, buf[actual]);
174                 actual++;
175         }
176
177         bt3c_io_write(iobase, 0x7005, actual);
178
179         return actual;
180 }
181
182
183 static void bt3c_write_wakeup(bt3c_info_t *info)
184 {
185         if (!info) {
186                 BT_ERR("Unknown device");
187                 return;
188         }
189
190         if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
191                 return;
192
193         do {
194                 register unsigned int iobase = info->link.io.BasePort1;
195                 register struct sk_buff *skb;
196                 register int len;
197
198                 if (!(info->link.state & DEV_PRESENT))
199                         break;
200
201
202                 if (!(skb = skb_dequeue(&(info->txq)))) {
203                         clear_bit(XMIT_SENDING, &(info->tx_state));
204                         break;
205                 }
206
207                 /* Send frame */
208                 len = bt3c_write(iobase, 256, skb->data, skb->len);
209
210                 if (len != skb->len) {
211                         BT_ERR("Very strange");
212                 }
213
214                 kfree_skb(skb);
215
216                 info->hdev->stat.byte_tx += len;
217
218         } while (0);
219 }
220
221
222 static void bt3c_receive(bt3c_info_t *info)
223 {
224         unsigned int iobase;
225         int size = 0, avail;
226
227         if (!info) {
228                 BT_ERR("Unknown device");
229                 return;
230         }
231
232         iobase = info->link.io.BasePort1;
233
234         avail = bt3c_read(iobase, 0x7006);
235         //printk("bt3c_cs: receiving %d bytes\n", avail);
236
237         bt3c_address(iobase, 0x7480);
238         while (size < avail) {
239                 size++;
240                 info->hdev->stat.byte_rx++;
241
242                 /* Allocate packet */
243                 if (info->rx_skb == NULL) {
244                         info->rx_state = RECV_WAIT_PACKET_TYPE;
245                         info->rx_count = 0;
246                         if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
247                                 BT_ERR("Can't allocate mem for new packet");
248                                 return;
249                         }
250                 }
251
252
253                 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
254
255                         info->rx_skb->dev = (void *) info->hdev;
256                         bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
257                         inb(iobase + DATA_H);
258                         //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
259
260                         switch (bt_cb(info->rx_skb)->pkt_type) {
261
262                         case HCI_EVENT_PKT:
263                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
264                                 info->rx_count = HCI_EVENT_HDR_SIZE;
265                                 break;
266
267                         case HCI_ACLDATA_PKT:
268                                 info->rx_state = RECV_WAIT_ACL_HEADER;
269                                 info->rx_count = HCI_ACL_HDR_SIZE;
270                                 break;
271
272                         case HCI_SCODATA_PKT:
273                                 info->rx_state = RECV_WAIT_SCO_HEADER;
274                                 info->rx_count = HCI_SCO_HDR_SIZE;
275                                 break;
276
277                         default:
278                                 /* Unknown packet */
279                                 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
280                                 info->hdev->stat.err_rx++;
281                                 clear_bit(HCI_RUNNING, &(info->hdev->flags));
282
283                                 kfree_skb(info->rx_skb);
284                                 info->rx_skb = NULL;
285                                 break;
286
287                         }
288
289                 } else {
290
291                         __u8 x = inb(iobase + DATA_L);
292
293                         *skb_put(info->rx_skb, 1) = x;
294                         inb(iobase + DATA_H);
295                         info->rx_count--;
296
297                         if (info->rx_count == 0) {
298
299                                 int dlen;
300                                 struct hci_event_hdr *eh;
301                                 struct hci_acl_hdr *ah;
302                                 struct hci_sco_hdr *sh;
303
304                                 switch (info->rx_state) {
305
306                                 case RECV_WAIT_EVENT_HEADER:
307                                         eh = (struct hci_event_hdr *)(info->rx_skb->data);
308                                         info->rx_state = RECV_WAIT_DATA;
309                                         info->rx_count = eh->plen;
310                                         break;
311
312                                 case RECV_WAIT_ACL_HEADER:
313                                         ah = (struct hci_acl_hdr *)(info->rx_skb->data);
314                                         dlen = __le16_to_cpu(ah->dlen);
315                                         info->rx_state = RECV_WAIT_DATA;
316                                         info->rx_count = dlen;
317                                         break;
318
319                                 case RECV_WAIT_SCO_HEADER:
320                                         sh = (struct hci_sco_hdr *)(info->rx_skb->data);
321                                         info->rx_state = RECV_WAIT_DATA;
322                                         info->rx_count = sh->dlen;
323                                         break;
324
325                                 case RECV_WAIT_DATA:
326                                         hci_recv_frame(info->rx_skb);
327                                         info->rx_skb = NULL;
328                                         break;
329
330                                 }
331
332                         }
333
334                 }
335
336         }
337
338         bt3c_io_write(iobase, 0x7006, 0x0000);
339 }
340
341
342 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
343 {
344         bt3c_info_t *info = dev_inst;
345         unsigned int iobase;
346         int iir;
347
348         if (!info || !info->hdev) {
349                 BT_ERR("Call of irq %d for unknown device", irq);
350                 return IRQ_NONE;
351         }
352
353         iobase = info->link.io.BasePort1;
354
355         spin_lock(&(info->lock));
356
357         iir = inb(iobase + CONTROL);
358         if (iir & 0x80) {
359                 int stat = bt3c_read(iobase, 0x7001);
360
361                 if ((stat & 0xff) == 0x7f) {
362                         BT_ERR("Very strange (stat=0x%04x)", stat);
363                 } else if ((stat & 0xff) != 0xff) {
364                         if (stat & 0x0020) {
365                                 int stat = bt3c_read(iobase, 0x7002) & 0x10;
366                                 BT_INFO("%s: Antenna %s", info->hdev->name,
367                                                         stat ? "out" : "in");
368                         }
369                         if (stat & 0x0001)
370                                 bt3c_receive(info);
371                         if (stat & 0x0002) {
372                                 //BT_ERR("Ack (stat=0x%04x)", stat);
373                                 clear_bit(XMIT_SENDING, &(info->tx_state));
374                                 bt3c_write_wakeup(info);
375                         }
376
377                         bt3c_io_write(iobase, 0x7001, 0x0000);
378
379                         outb(iir, iobase + CONTROL);
380                 }
381         }
382
383         spin_unlock(&(info->lock));
384
385         return IRQ_HANDLED;
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, unsigned char *firmware, int count)
478 {
479         char *ptr = (char *) firmware;
480         char b[9];
481         unsigned int iobase, size, addr, fcs, tmp;
482         int i, err = 0;
483
484         iobase = info->link.io.BasePort1;
485
486         /* Reset */
487         bt3c_io_write(iobase, 0x8040, 0x0404);
488         bt3c_io_write(iobase, 0x8040, 0x0400);
489
490         udelay(1);
491
492         bt3c_io_write(iobase, 0x8040, 0x0404);
493
494         udelay(17);
495
496         /* Load */
497         while (count) {
498                 if (ptr[0] != 'S') {
499                         BT_ERR("Bad address in firmware");
500                         err = -EFAULT;
501                         goto error;
502                 }
503
504                 memset(b, 0, sizeof(b));
505                 memcpy(b, ptr + 2, 2);
506                 size = simple_strtol(b, NULL, 16);
507
508                 memset(b, 0, sizeof(b));
509                 memcpy(b, ptr + 4, 8);
510                 addr = simple_strtol(b, NULL, 16);
511
512                 memset(b, 0, sizeof(b));
513                 memcpy(b, ptr + (size * 2) + 2, 2);
514                 fcs = simple_strtol(b, NULL, 16);
515
516                 memset(b, 0, sizeof(b));
517                 for (tmp = 0, i = 0; i < size; i++) {
518                         memcpy(b, ptr + (i * 2) + 2, 2);
519                         tmp += simple_strtol(b, NULL, 16);
520                 }
521
522                 if (((tmp + fcs) & 0xff) != 0xff) {
523                         BT_ERR("Checksum error in firmware");
524                         err = -EILSEQ;
525                         goto error;
526                 }
527
528                 if (ptr[1] == '3') {
529                         bt3c_address(iobase, addr);
530
531                         memset(b, 0, sizeof(b));
532                         for (i = 0; i < (size - 4) / 2; i++) {
533                                 memcpy(b, ptr + (i * 4) + 12, 4);
534                                 tmp = simple_strtol(b, NULL, 16);
535                                 bt3c_put(iobase, tmp);
536                         }
537                 }
538
539                 ptr   += (size * 2) + 6;
540                 count -= (size * 2) + 6;
541         }
542
543         udelay(17);
544
545         /* Boot */
546         bt3c_address(iobase, 0x3000);
547         outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
548
549 error:
550         udelay(17);
551
552         /* Clear */
553         bt3c_io_write(iobase, 0x7006, 0x0000);
554         bt3c_io_write(iobase, 0x7005, 0x0000);
555         bt3c_io_write(iobase, 0x7001, 0x0000);
556
557         return err;
558 }
559
560
561 static int bt3c_open(bt3c_info_t *info)
562 {
563         const struct firmware *firmware;
564         struct hci_dev *hdev;
565         client_handle_t handle;
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->type = HCI_PCCARD;
586         hdev->driver_data = info;
587
588         hdev->open     = bt3c_hci_open;
589         hdev->close    = bt3c_hci_close;
590         hdev->flush    = bt3c_hci_flush;
591         hdev->send     = bt3c_hci_send_frame;
592         hdev->destruct = bt3c_hci_destruct;
593         hdev->ioctl    = bt3c_hci_ioctl;
594
595         hdev->owner = THIS_MODULE;
596
597         handle = info->link.handle;
598
599         /* Load firmware */
600         err = request_firmware(&firmware, "BT3CPCC.bin", &handle_to_dev(handle));
601         if (err < 0) {
602                 BT_ERR("Firmware request failed");
603                 goto error;
604         }
605
606         err = bt3c_load_firmware(info, firmware->data, firmware->size);
607
608         release_firmware(firmware);
609
610         if (err < 0) {
611                 BT_ERR("Firmware loading failed");
612                 goto error;
613         }
614
615         /* Timeout before it is safe to send the first HCI packet */
616         msleep(1000);
617
618         /* Register HCI device */
619         err = hci_register_dev(hdev);
620         if (err < 0) {
621                 BT_ERR("Can't register HCI device");
622                 goto error;
623         }
624
625         return 0;
626
627 error:
628         info->hdev = NULL;
629         hci_free_dev(hdev);
630         return err;
631 }
632
633
634 static int bt3c_close(bt3c_info_t *info)
635 {
636         struct hci_dev *hdev = info->hdev;
637
638         if (!hdev)
639                 return -ENODEV;
640
641         bt3c_hci_close(hdev);
642
643         if (hci_unregister_dev(hdev) < 0)
644                 BT_ERR("Can't unregister HCI device %s", hdev->name);
645
646         hci_free_dev(hdev);
647
648         return 0;
649 }
650
651 static int bt3c_attach(struct pcmcia_device *p_dev)
652 {
653         bt3c_info_t *info;
654         dev_link_t *link;
655
656         /* Create new info device */
657         info = kzalloc(sizeof(*info), GFP_KERNEL);
658         if (!info)
659                 return -ENOMEM;
660
661         link = &info->link;
662         link->priv = info;
663
664         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
665         link->io.NumPorts1 = 8;
666         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
667         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
668
669         link->irq.Handler = bt3c_interrupt;
670         link->irq.Instance = info;
671
672         link->conf.Attributes = CONF_ENABLE_IRQ;
673         link->conf.Vcc = 50;
674         link->conf.IntType = INT_MEMORY_AND_IO;
675
676         link->handle = p_dev;
677         p_dev->instance = link;
678
679         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
680         bt3c_config(link);
681
682         return 0;
683 }
684
685
686 static void bt3c_detach(struct pcmcia_device *p_dev)
687 {
688         dev_link_t *link = dev_to_instance(p_dev);
689         bt3c_info_t *info = link->priv;
690
691         if (link->state & DEV_CONFIG)
692                 bt3c_release(link);
693
694         kfree(info);
695 }
696
697 static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
698 {
699         int i;
700
701         i = pcmcia_get_tuple_data(handle, tuple);
702         if (i != CS_SUCCESS)
703                 return i;
704
705         return pcmcia_parse_tuple(handle, tuple, parse);
706 }
707
708 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
709 {
710         if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
711                 return CS_NO_MORE_ITEMS;
712         return get_tuple(handle, tuple, parse);
713 }
714
715 static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
716 {
717         if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
718                 return CS_NO_MORE_ITEMS;
719         return get_tuple(handle, tuple, parse);
720 }
721
722 static void bt3c_config(dev_link_t *link)
723 {
724         static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
725         client_handle_t handle = link->handle;
726         bt3c_info_t *info = link->priv;
727         tuple_t tuple;
728         u_short buf[256];
729         cisparse_t parse;
730         cistpl_cftable_entry_t *cf = &parse.cftable_entry;
731         config_info_t config;
732         int i, j, try, last_ret, last_fn;
733
734         tuple.TupleData = (cisdata_t *)buf;
735         tuple.TupleOffset = 0;
736         tuple.TupleDataMax = 255;
737         tuple.Attributes = 0;
738
739         /* Get configuration register information */
740         tuple.DesiredTuple = CISTPL_CONFIG;
741         last_ret = first_tuple(handle, &tuple, &parse);
742         if (last_ret != CS_SUCCESS) {
743                 last_fn = ParseTuple;
744                 goto cs_failed;
745         }
746         link->conf.ConfigBase = parse.config.base;
747         link->conf.Present = parse.config.rmask[0];
748
749         /* Configure card */
750         link->state |= DEV_CONFIG;
751         i = pcmcia_get_configuration_info(handle, &config);
752         link->conf.Vcc = config.Vcc;
753
754         /* First pass: look for a config entry that looks normal. */
755         tuple.TupleData = (cisdata_t *)buf;
756         tuple.TupleOffset = 0;
757         tuple.TupleDataMax = 255;
758         tuple.Attributes = 0;
759         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
760         /* Two tries: without IO aliases, then with aliases */
761         for (try = 0; try < 2; try++) {
762                 i = first_tuple(handle, &tuple, &parse);
763                 while (i != CS_NO_MORE_ITEMS) {
764                         if (i != CS_SUCCESS)
765                                 goto next_entry;
766                         if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
767                                 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
768                         if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
769                                 link->conf.ConfigIndex = cf->index;
770                                 link->io.BasePort1 = cf->io.win[0].base;
771                                 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
772                                 i = pcmcia_request_io(link->handle, &link->io);
773                                 if (i == CS_SUCCESS)
774                                         goto found_port;
775                         }
776 next_entry:
777                         i = next_tuple(handle, &tuple, &parse);
778                 }
779         }
780
781         /* Second pass: try to find an entry that isn't picky about
782            its base address, then try to grab any standard serial port
783            address, and finally try to get any free port. */
784         i = first_tuple(handle, &tuple, &parse);
785         while (i != CS_NO_MORE_ITEMS) {
786                 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
787                         link->conf.ConfigIndex = cf->index;
788                         for (j = 0; j < 5; j++) {
789                                 link->io.BasePort1 = base[j];
790                                 link->io.IOAddrLines = base[j] ? 16 : 3;
791                                 i = pcmcia_request_io(link->handle, &link->io);
792                                 if (i == CS_SUCCESS)
793                                         goto found_port;
794                         }
795                 }
796                 i = next_tuple(handle, &tuple, &parse);
797         }
798
799 found_port:
800         if (i != CS_SUCCESS) {
801                 BT_ERR("No usable port range found");
802                 cs_error(link->handle, RequestIO, i);
803                 goto failed;
804         }
805
806         i = pcmcia_request_irq(link->handle, &link->irq);
807         if (i != CS_SUCCESS) {
808                 cs_error(link->handle, RequestIRQ, i);
809                 link->irq.AssignedIRQ = 0;
810         }
811
812         i = pcmcia_request_configuration(link->handle, &link->conf);
813         if (i != CS_SUCCESS) {
814                 cs_error(link->handle, RequestConfiguration, i);
815                 goto failed;
816         }
817
818         if (bt3c_open(info) != 0)
819                 goto failed;
820
821         strcpy(info->node.dev_name, info->hdev->name);
822         link->dev = &info->node;
823         link->state &= ~DEV_CONFIG_PENDING;
824
825         return;
826
827 cs_failed:
828         cs_error(link->handle, last_fn, last_ret);
829
830 failed:
831         bt3c_release(link);
832 }
833
834
835 static void bt3c_release(dev_link_t *link)
836 {
837         bt3c_info_t *info = link->priv;
838
839         if (link->state & DEV_PRESENT)
840                 bt3c_close(info);
841
842         link->dev = NULL;
843
844         pcmcia_release_configuration(link->handle);
845         pcmcia_release_io(link->handle, &link->io);
846         pcmcia_release_irq(link->handle, &link->irq);
847
848         link->state &= ~DEV_CONFIG;
849 }
850
851 static int bt3c_suspend(struct pcmcia_device *dev)
852 {
853         dev_link_t *link = dev_to_instance(dev);
854
855         link->state |= DEV_SUSPEND;
856         if (link->state & DEV_CONFIG)
857                 pcmcia_release_configuration(link->handle);
858
859         return 0;
860 }
861
862 static int bt3c_resume(struct pcmcia_device *dev)
863 {
864         dev_link_t *link = dev_to_instance(dev);
865
866         link->state &= ~DEV_SUSPEND;
867         if (DEV_OK(link))
868                 pcmcia_request_configuration(link->handle, &link->conf);
869
870         return 0;
871 }
872
873
874 static struct pcmcia_device_id bt3c_ids[] = {
875         PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
876         PCMCIA_DEVICE_NULL
877 };
878 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
879
880 static struct pcmcia_driver bt3c_driver = {
881         .owner          = THIS_MODULE,
882         .drv            = {
883                 .name   = "bt3c_cs",
884         },
885         .probe          = bt3c_attach,
886         .remove         = bt3c_detach,
887         .id_table       = bt3c_ids,
888         .suspend        = bt3c_suspend,
889         .resume         = bt3c_resume,
890 };
891
892 static int __init init_bt3c_cs(void)
893 {
894         return pcmcia_register_driver(&bt3c_driver);
895 }
896
897
898 static void __exit exit_bt3c_cs(void)
899 {
900         pcmcia_unregister_driver(&bt3c_driver);
901 }
902
903 module_init(init_bt3c_cs);
904 module_exit(exit_bt3c_cs);