blob: d2a0add19cc88a52ddcd703495fdcf0584b00022 [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 */
Deepak Saxena089b1db2005-11-07 01:01:26 -0800674 info = kzalloc(sizeof(*info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 if (!info)
676 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678 link = &info->link;
679 link->priv = info;
680
681 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
682 link->io.NumPorts1 = 8;
683 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
684 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
685
686 link->irq.Handler = bt3c_interrupt;
687 link->irq.Instance = info;
688
689 link->conf.Attributes = CONF_ENABLE_IRQ;
690 link->conf.Vcc = 50;
691 link->conf.IntType = INT_MEMORY_AND_IO;
692
693 /* Register with Card Services */
694 link->next = dev_list;
695 dev_list = link;
696 client_reg.dev_info = &dev_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 client_reg.Version = 0x0210;
698 client_reg.event_callback_args.client_data = link;
699
700 ret = pcmcia_register_client(&link->handle, &client_reg);
701 if (ret != CS_SUCCESS) {
702 cs_error(link->handle, RegisterClient, ret);
703 bt3c_detach(link);
704 return NULL;
705 }
706
707 return link;
708}
709
710
711static void bt3c_detach(dev_link_t *link)
712{
713 bt3c_info_t *info = link->priv;
714 dev_link_t **linkp;
715 int ret;
716
717 /* Locate device structure */
718 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
719 if (*linkp == link)
720 break;
721
722 if (*linkp == NULL)
723 return;
724
725 if (link->state & DEV_CONFIG)
726 bt3c_release(link);
727
728 if (link->handle) {
729 ret = pcmcia_deregister_client(link->handle);
730 if (ret != CS_SUCCESS)
731 cs_error(link->handle, DeregisterClient, ret);
732 }
733
734 /* Unlink device structure, free bits */
735 *linkp = link->next;
736
737 kfree(info);
738}
739
740static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
741{
742 int i;
743
744 i = pcmcia_get_tuple_data(handle, tuple);
745 if (i != CS_SUCCESS)
746 return i;
747
748 return pcmcia_parse_tuple(handle, tuple, parse);
749}
750
751static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
752{
753 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
754 return CS_NO_MORE_ITEMS;
755 return get_tuple(handle, tuple, parse);
756}
757
758static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
759{
760 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
761 return CS_NO_MORE_ITEMS;
762 return get_tuple(handle, tuple, parse);
763}
764
765static void bt3c_config(dev_link_t *link)
766{
767 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
768 client_handle_t handle = link->handle;
769 bt3c_info_t *info = link->priv;
770 tuple_t tuple;
771 u_short buf[256];
772 cisparse_t parse;
773 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
774 config_info_t config;
775 int i, j, try, last_ret, last_fn;
776
777 tuple.TupleData = (cisdata_t *)buf;
778 tuple.TupleOffset = 0;
779 tuple.TupleDataMax = 255;
780 tuple.Attributes = 0;
781
782 /* Get configuration register information */
783 tuple.DesiredTuple = CISTPL_CONFIG;
784 last_ret = first_tuple(handle, &tuple, &parse);
785 if (last_ret != CS_SUCCESS) {
786 last_fn = ParseTuple;
787 goto cs_failed;
788 }
789 link->conf.ConfigBase = parse.config.base;
790 link->conf.Present = parse.config.rmask[0];
791
792 /* Configure card */
793 link->state |= DEV_CONFIG;
794 i = pcmcia_get_configuration_info(handle, &config);
795 link->conf.Vcc = config.Vcc;
796
797 /* First pass: look for a config entry that looks normal. */
798 tuple.TupleData = (cisdata_t *)buf;
799 tuple.TupleOffset = 0;
800 tuple.TupleDataMax = 255;
801 tuple.Attributes = 0;
802 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
803 /* Two tries: without IO aliases, then with aliases */
804 for (try = 0; try < 2; try++) {
805 i = first_tuple(handle, &tuple, &parse);
806 while (i != CS_NO_MORE_ITEMS) {
807 if (i != CS_SUCCESS)
808 goto next_entry;
809 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
810 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
811 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
812 link->conf.ConfigIndex = cf->index;
813 link->io.BasePort1 = cf->io.win[0].base;
814 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
815 i = pcmcia_request_io(link->handle, &link->io);
816 if (i == CS_SUCCESS)
817 goto found_port;
818 }
819next_entry:
820 i = next_tuple(handle, &tuple, &parse);
821 }
822 }
823
824 /* Second pass: try to find an entry that isn't picky about
825 its base address, then try to grab any standard serial port
826 address, and finally try to get any free port. */
827 i = first_tuple(handle, &tuple, &parse);
828 while (i != CS_NO_MORE_ITEMS) {
829 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
830 link->conf.ConfigIndex = cf->index;
831 for (j = 0; j < 5; j++) {
832 link->io.BasePort1 = base[j];
833 link->io.IOAddrLines = base[j] ? 16 : 3;
834 i = pcmcia_request_io(link->handle, &link->io);
835 if (i == CS_SUCCESS)
836 goto found_port;
837 }
838 }
839 i = next_tuple(handle, &tuple, &parse);
840 }
841
842found_port:
843 if (i != CS_SUCCESS) {
844 BT_ERR("No usable port range found");
845 cs_error(link->handle, RequestIO, i);
846 goto failed;
847 }
848
849 i = pcmcia_request_irq(link->handle, &link->irq);
850 if (i != CS_SUCCESS) {
851 cs_error(link->handle, RequestIRQ, i);
852 link->irq.AssignedIRQ = 0;
853 }
854
855 i = pcmcia_request_configuration(link->handle, &link->conf);
856 if (i != CS_SUCCESS) {
857 cs_error(link->handle, RequestConfiguration, i);
858 goto failed;
859 }
860
861 if (bt3c_open(info) != 0)
862 goto failed;
863
864 strcpy(info->node.dev_name, info->hdev->name);
865 link->dev = &info->node;
866 link->state &= ~DEV_CONFIG_PENDING;
867
868 return;
869
870cs_failed:
871 cs_error(link->handle, last_fn, last_ret);
872
873failed:
874 bt3c_release(link);
875}
876
877
878static void bt3c_release(dev_link_t *link)
879{
880 bt3c_info_t *info = link->priv;
881
882 if (link->state & DEV_PRESENT)
883 bt3c_close(info);
884
885 link->dev = NULL;
886
887 pcmcia_release_configuration(link->handle);
888 pcmcia_release_io(link->handle, &link->io);
889 pcmcia_release_irq(link->handle, &link->irq);
890
891 link->state &= ~DEV_CONFIG;
892}
893
894
895static int bt3c_event(event_t event, int priority, event_callback_args_t *args)
896{
897 dev_link_t *link = args->client_data;
898 bt3c_info_t *info = link->priv;
899
900 switch (event) {
901 case CS_EVENT_CARD_REMOVAL:
902 link->state &= ~DEV_PRESENT;
903 if (link->state & DEV_CONFIG) {
904 bt3c_close(info);
905 bt3c_release(link);
906 }
907 break;
908 case CS_EVENT_CARD_INSERTION:
909 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
910 bt3c_config(link);
911 break;
912 case CS_EVENT_PM_SUSPEND:
913 link->state |= DEV_SUSPEND;
914 /* Fall through... */
915 case CS_EVENT_RESET_PHYSICAL:
916 if (link->state & DEV_CONFIG)
917 pcmcia_release_configuration(link->handle);
918 break;
919 case CS_EVENT_PM_RESUME:
920 link->state &= ~DEV_SUSPEND;
921 /* Fall through... */
922 case CS_EVENT_CARD_RESET:
923 if (DEV_OK(link))
924 pcmcia_request_configuration(link->handle, &link->conf);
925 break;
926 }
927
928 return 0;
929}
930
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700931static struct pcmcia_device_id bt3c_ids[] = {
932 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
933 PCMCIA_DEVICE_NULL
934};
935MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
936
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937static struct pcmcia_driver bt3c_driver = {
938 .owner = THIS_MODULE,
939 .drv = {
940 .name = "bt3c_cs",
941 },
942 .attach = bt3c_attach,
Dominik Brodowski1e212f32005-07-07 17:59:00 -0700943 .event = bt3c_event,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 .detach = bt3c_detach,
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700945 .id_table = bt3c_ids,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946};
947
948static int __init init_bt3c_cs(void)
949{
950 return pcmcia_register_driver(&bt3c_driver);
951}
952
953
954static void __exit exit_bt3c_cs(void)
955{
956 pcmcia_unregister_driver(&bt3c_driver);
957 BUG_ON(dev_list != NULL);
958}
959
960module_init(init_bt3c_cs);
961module_exit(exit_bt3c_cs);