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