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