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