]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/bluetooth/bt3c_cs.c
IRQ: Typedef the IRQ handler function type
[mirror_ubuntu-artful-kernel.git] / drivers / bluetooth / bt3c_cs.c
CommitLineData
1da177e4
LT
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
1da177e4
LT
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/sched.h>
31#include <linux/delay.h>
32#include <linux/errno.h>
33#include <linux/ptrace.h>
34#include <linux/ioport.h>
35#include <linux/spinlock.h>
36#include <linux/moduleparam.h>
37
38#include <linux/skbuff.h>
39#include <linux/string.h>
40#include <linux/serial.h>
41#include <linux/serial_reg.h>
42#include <linux/bitops.h>
43#include <asm/system.h>
44#include <asm/io.h>
45
46#include <linux/device.h>
47#include <linux/firmware.h>
48
1da177e4
LT
49#include <pcmcia/cs_types.h>
50#include <pcmcia/cs.h>
51#include <pcmcia/cistpl.h>
52#include <pcmcia/ciscode.h>
53#include <pcmcia/ds.h>
54#include <pcmcia/cisreg.h>
55
56#include <net/bluetooth/bluetooth.h>
57#include <net/bluetooth/hci_core.h>
58
59
60
61/* ======================== Module parameters ======================== */
62
63
64MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
65MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
66MODULE_LICENSE("GPL");
67
68
69
70/* ======================== Local structures ======================== */
71
72
73typedef struct bt3c_info_t {
fd238232 74 struct pcmcia_device *p_dev;
1da177e4
LT
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
15b99ac1 90static int bt3c_config(struct pcmcia_device *link);
fba395ee 91static void bt3c_release(struct pcmcia_device *link);
1da177e4 92
cc3b4866 93static void bt3c_detach(struct pcmcia_device *p_dev);
1da177e4 94
1da177e4
LT
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
120static 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
127static 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
134static 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
141static 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
151static 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
163static 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
182static 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 {
fd238232 193 register unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4
LT
194 register struct sk_buff *skb;
195 register int len;
196
e2d40963 197 if (!pcmcia_dev_present(info->p_dev))
1da177e4
LT
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
221static 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
fd238232 231 iobase = info->p_dev->io.BasePort1;
1da177e4
LT
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;
0d48d939 255 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
1da177e4 256 inb(iobase + DATA_H);
0d48d939 257 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
1da177e4 258
0d48d939 259 switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4
LT
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 */
0d48d939 278 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4
LT
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 = (struct hci_event_hdr *)(info->rx_skb->data);
307 info->rx_state = RECV_WAIT_DATA;
308 info->rx_count = eh->plen;
309 break;
310
311 case RECV_WAIT_ACL_HEADER:
312 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
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 = (struct hci_sco_hdr *)(info->rx_skb->data);
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
341static irqreturn_t bt3c_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
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
fd238232 352 iobase = info->p_dev->io.BasePort1;
1da177e4
LT
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
392static 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
403static int bt3c_hci_open(struct hci_dev *hdev)
404{
405 set_bit(HCI_RUNNING, &(hdev->flags));
406
407 return 0;
408}
409
410
411static 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
422static 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
0d48d939 435 switch (bt_cb(skb)->pkt_type) {
1da177e4
LT
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 */
0d48d939 448 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4
LT
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
461static void bt3c_hci_destruct(struct hci_dev *hdev)
462{
463}
464
465
466static 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
1da177e4
LT
476static 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
fd238232 483 iobase = info->p_dev->io.BasePort1;
1da177e4
LT
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
548error:
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
560static 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;
27d35284 585 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4
LT
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 */
fd238232 597 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
1da177e4
LT
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
624error:
625 info->hdev = NULL;
626 hci_free_dev(hdev);
627 return err;
628}
629
630
631static 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
15b99ac1 648static int bt3c_probe(struct pcmcia_device *link)
1da177e4
LT
649{
650 bt3c_info_t *info;
1da177e4
LT
651
652 /* Create new info device */
089b1dbb 653 info = kzalloc(sizeof(*info), GFP_KERNEL);
1da177e4 654 if (!info)
f8cfa618 655 return -ENOMEM;
1da177e4 656
fba395ee 657 info->p_dev = link;
1da177e4
LT
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;
1da177e4
LT
669 link->conf.IntType = INT_MEMORY_AND_IO;
670
15b99ac1 671 return bt3c_config(link);
1da177e4
LT
672}
673
674
fba395ee 675static void bt3c_detach(struct pcmcia_device *link)
1da177e4
LT
676{
677 bt3c_info_t *info = link->priv;
1da177e4 678
e2d40963 679 bt3c_release(link);
1da177e4
LT
680 kfree(info);
681}
682
fba395ee 683static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
1da177e4
LT
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
fba395ee 694static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
1da177e4
LT
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
fba395ee 701static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
1da177e4
LT
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
15b99ac1 708static int bt3c_config(struct pcmcia_device *link)
1da177e4
LT
709{
710 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
1da177e4
LT
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;
1da177e4
LT
716 int i, j, try, last_ret, last_fn;
717
718 tuple.TupleData = (cisdata_t *)buf;
719 tuple.TupleOffset = 0;
720 tuple.TupleDataMax = 255;
721 tuple.Attributes = 0;
722
723 /* Get configuration register information */
724 tuple.DesiredTuple = CISTPL_CONFIG;
fba395ee 725 last_ret = first_tuple(link, &tuple, &parse);
1da177e4
LT
726 if (last_ret != CS_SUCCESS) {
727 last_fn = ParseTuple;
728 goto cs_failed;
729 }
730 link->conf.ConfigBase = parse.config.base;
731 link->conf.Present = parse.config.rmask[0];
732
1da177e4
LT
733 /* First pass: look for a config entry that looks normal. */
734 tuple.TupleData = (cisdata_t *)buf;
735 tuple.TupleOffset = 0;
736 tuple.TupleDataMax = 255;
737 tuple.Attributes = 0;
738 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
739 /* Two tries: without IO aliases, then with aliases */
740 for (try = 0; try < 2; try++) {
fba395ee 741 i = first_tuple(link, &tuple, &parse);
1da177e4
LT
742 while (i != CS_NO_MORE_ITEMS) {
743 if (i != CS_SUCCESS)
744 goto next_entry;
745 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
70294b46 746 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
1da177e4
LT
747 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
748 link->conf.ConfigIndex = cf->index;
749 link->io.BasePort1 = cf->io.win[0].base;
750 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
fba395ee 751 i = pcmcia_request_io(link, &link->io);
1da177e4
LT
752 if (i == CS_SUCCESS)
753 goto found_port;
754 }
755next_entry:
fba395ee 756 i = next_tuple(link, &tuple, &parse);
1da177e4
LT
757 }
758 }
759
760 /* Second pass: try to find an entry that isn't picky about
761 its base address, then try to grab any standard serial port
762 address, and finally try to get any free port. */
fba395ee 763 i = first_tuple(link, &tuple, &parse);
1da177e4
LT
764 while (i != CS_NO_MORE_ITEMS) {
765 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
766 link->conf.ConfigIndex = cf->index;
767 for (j = 0; j < 5; j++) {
768 link->io.BasePort1 = base[j];
769 link->io.IOAddrLines = base[j] ? 16 : 3;
fba395ee 770 i = pcmcia_request_io(link, &link->io);
1da177e4
LT
771 if (i == CS_SUCCESS)
772 goto found_port;
773 }
774 }
fba395ee 775 i = next_tuple(link, &tuple, &parse);
1da177e4
LT
776 }
777
778found_port:
779 if (i != CS_SUCCESS) {
780 BT_ERR("No usable port range found");
fba395ee 781 cs_error(link, RequestIO, i);
1da177e4
LT
782 goto failed;
783 }
784
fba395ee 785 i = pcmcia_request_irq(link, &link->irq);
1da177e4 786 if (i != CS_SUCCESS) {
fba395ee 787 cs_error(link, RequestIRQ, i);
1da177e4
LT
788 link->irq.AssignedIRQ = 0;
789 }
790
fba395ee 791 i = pcmcia_request_configuration(link, &link->conf);
1da177e4 792 if (i != CS_SUCCESS) {
fba395ee 793 cs_error(link, RequestConfiguration, i);
1da177e4
LT
794 goto failed;
795 }
796
797 if (bt3c_open(info) != 0)
798 goto failed;
799
800 strcpy(info->node.dev_name, info->hdev->name);
fd238232 801 link->dev_node = &info->node;
1da177e4 802
15b99ac1 803 return 0;
1da177e4
LT
804
805cs_failed:
fba395ee 806 cs_error(link, last_fn, last_ret);
1da177e4
LT
807
808failed:
809 bt3c_release(link);
15b99ac1 810 return -ENODEV;
1da177e4
LT
811}
812
813
fba395ee 814static void bt3c_release(struct pcmcia_device *link)
1da177e4
LT
815{
816 bt3c_info_t *info = link->priv;
817
e2d40963 818 bt3c_close(info);
1da177e4 819
fba395ee 820 pcmcia_disable_device(link);
1da177e4
LT
821}
822
1da177e4 823
a01c3ed4
DB
824static struct pcmcia_device_id bt3c_ids[] = {
825 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
826 PCMCIA_DEVICE_NULL
827};
828MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
829
1da177e4
LT
830static struct pcmcia_driver bt3c_driver = {
831 .owner = THIS_MODULE,
832 .drv = {
833 .name = "bt3c_cs",
834 },
15b99ac1 835 .probe = bt3c_probe,
cc3b4866 836 .remove = bt3c_detach,
a01c3ed4 837 .id_table = bt3c_ids,
1da177e4
LT
838};
839
840static int __init init_bt3c_cs(void)
841{
842 return pcmcia_register_driver(&bt3c_driver);
843}
844
845
846static void __exit exit_bt3c_cs(void)
847{
848 pcmcia_unregister_driver(&bt3c_driver);
1da177e4
LT
849}
850
851module_init(init_bt3c_cs);
852module_exit(exit_bt3c_cs);