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