blob: 7703d6e06fd988926dd2e697e32c4a57eee37158 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/delay.h>
31#include <linux/errno.h>
32#include <linux/ptrace.h>
33#include <linux/ioport.h>
34#include <linux/spinlock.h>
35#include <linux/moduleparam.h>
36
37#include <linux/skbuff.h>
38#include <linux/string.h>
39#include <linux/serial.h>
40#include <linux/serial_reg.h>
41#include <linux/bitops.h>
42#include <asm/system.h>
43#include <asm/io.h>
44
45#include <linux/device.h>
46#include <linux/firmware.h>
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <pcmcia/cs_types.h>
49#include <pcmcia/cs.h>
50#include <pcmcia/cistpl.h>
51#include <pcmcia/ciscode.h>
52#include <pcmcia/ds.h>
53#include <pcmcia/cisreg.h>
54
55#include <net/bluetooth/bluetooth.h>
56#include <net/bluetooth/hci_core.h>
57
58
59
60/* ======================== Module parameters ======================== */
61
62
63MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
64MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
65MODULE_LICENSE("GPL");
Marcel Holtmann23121192007-02-17 23:59:02 +010066MODULE_FIRMWARE("BT3CPCC.bin");
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68
69
70/* ======================== Local structures ======================== */
71
72
73typedef struct bt3c_info_t {
Dominik Brodowskifd238232006-03-05 10:45:09 +010074 struct pcmcia_device *p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 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
Dominik Brodowski15b99ac2006-03-31 17:26:06 +020090static int bt3c_config(struct pcmcia_device *link);
Dominik Brodowskifba395e2006-03-31 17:21:06 +020091static void bt3c_release(struct pcmcia_device *link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Dominik Brodowskicc3b4862005-11-14 21:23:14 +010093static void bt3c_detach(struct pcmcia_device *p_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
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 {
Dominik Brodowskifd238232006-03-05 10:45:09 +0100193 register unsigned int iobase = info->p_dev->io.BasePort1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 register struct sk_buff *skb;
195 register int len;
196
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100197 if (!pcmcia_dev_present(info->p_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 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
Dominik Brodowskifd238232006-03-05 10:45:09 +0100231 iobase = info->p_dev->io.BasePort1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
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;
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700255 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 inb(iobase + DATA_H);
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700257 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700259 switch (bt_cb(info->rx_skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
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 */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700278 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 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:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300306 eh = hci_event_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 info->rx_state = RECV_WAIT_DATA;
308 info->rx_count = eh->plen;
309 break;
310
311 case RECV_WAIT_ACL_HEADER:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300312 ah = hci_acl_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 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:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300319 sh = hci_sco_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 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
David Howells7d12e782006-10-05 14:55:46 +0100341static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
343 bt3c_info_t *info = dev_inst;
344 unsigned int iobase;
345 int iir;
346
Jeff Garzikac019362007-10-20 13:45:57 +0200347 BUG_ON(!info->hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Dominik Brodowskifd238232006-03-05 10:45:09 +0100349 iobase = info->p_dev->io.BasePort1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
351 spin_lock(&(info->lock));
352
353 iir = inb(iobase + CONTROL);
354 if (iir & 0x80) {
355 int stat = bt3c_read(iobase, 0x7001);
356
357 if ((stat & 0xff) == 0x7f) {
358 BT_ERR("Very strange (stat=0x%04x)", stat);
359 } else if ((stat & 0xff) != 0xff) {
360 if (stat & 0x0020) {
361 int stat = bt3c_read(iobase, 0x7002) & 0x10;
362 BT_INFO("%s: Antenna %s", info->hdev->name,
363 stat ? "out" : "in");
364 }
365 if (stat & 0x0001)
366 bt3c_receive(info);
367 if (stat & 0x0002) {
368 //BT_ERR("Ack (stat=0x%04x)", stat);
369 clear_bit(XMIT_SENDING, &(info->tx_state));
370 bt3c_write_wakeup(info);
371 }
372
373 bt3c_io_write(iobase, 0x7001, 0x0000);
374
375 outb(iir, iobase + CONTROL);
376 }
377 }
378
379 spin_unlock(&(info->lock));
380
381 return IRQ_HANDLED;
382}
383
384
385
386/* ======================== HCI interface ======================== */
387
388
389static int bt3c_hci_flush(struct hci_dev *hdev)
390{
391 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
392
393 /* Drop TX queue */
394 skb_queue_purge(&(info->txq));
395
396 return 0;
397}
398
399
400static int bt3c_hci_open(struct hci_dev *hdev)
401{
402 set_bit(HCI_RUNNING, &(hdev->flags));
403
404 return 0;
405}
406
407
408static int bt3c_hci_close(struct hci_dev *hdev)
409{
410 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
411 return 0;
412
413 bt3c_hci_flush(hdev);
414
415 return 0;
416}
417
418
419static int bt3c_hci_send_frame(struct sk_buff *skb)
420{
421 bt3c_info_t *info;
422 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
423 unsigned long flags;
424
425 if (!hdev) {
426 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
427 return -ENODEV;
428 }
429
430 info = (bt3c_info_t *) (hdev->driver_data);
431
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700432 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 case HCI_COMMAND_PKT:
434 hdev->stat.cmd_tx++;
435 break;
436 case HCI_ACLDATA_PKT:
437 hdev->stat.acl_tx++;
438 break;
439 case HCI_SCODATA_PKT:
440 hdev->stat.sco_tx++;
441 break;
442 };
443
444 /* Prepend skb with frame type */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700445 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 skb_queue_tail(&(info->txq), skb);
447
448 spin_lock_irqsave(&(info->lock), flags);
449
450 bt3c_write_wakeup(info);
451
452 spin_unlock_irqrestore(&(info->lock), flags);
453
454 return 0;
455}
456
457
458static void bt3c_hci_destruct(struct hci_dev *hdev)
459{
460}
461
462
463static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
464{
465 return -ENOIOCTLCMD;
466}
467
468
469
470/* ======================== Card services HCI interaction ======================== */
471
472
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473static int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, int count)
474{
475 char *ptr = (char *) firmware;
476 char b[9];
477 unsigned int iobase, size, addr, fcs, tmp;
478 int i, err = 0;
479
Dominik Brodowskifd238232006-03-05 10:45:09 +0100480 iobase = info->p_dev->io.BasePort1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 /* Reset */
483 bt3c_io_write(iobase, 0x8040, 0x0404);
484 bt3c_io_write(iobase, 0x8040, 0x0400);
485
486 udelay(1);
487
488 bt3c_io_write(iobase, 0x8040, 0x0404);
489
490 udelay(17);
491
492 /* Load */
493 while (count) {
494 if (ptr[0] != 'S') {
495 BT_ERR("Bad address in firmware");
496 err = -EFAULT;
497 goto error;
498 }
499
500 memset(b, 0, sizeof(b));
501 memcpy(b, ptr + 2, 2);
502 size = simple_strtol(b, NULL, 16);
503
504 memset(b, 0, sizeof(b));
505 memcpy(b, ptr + 4, 8);
506 addr = simple_strtol(b, NULL, 16);
507
508 memset(b, 0, sizeof(b));
509 memcpy(b, ptr + (size * 2) + 2, 2);
510 fcs = simple_strtol(b, NULL, 16);
511
512 memset(b, 0, sizeof(b));
513 for (tmp = 0, i = 0; i < size; i++) {
514 memcpy(b, ptr + (i * 2) + 2, 2);
515 tmp += simple_strtol(b, NULL, 16);
516 }
517
518 if (((tmp + fcs) & 0xff) != 0xff) {
519 BT_ERR("Checksum error in firmware");
520 err = -EILSEQ;
521 goto error;
522 }
523
524 if (ptr[1] == '3') {
525 bt3c_address(iobase, addr);
526
527 memset(b, 0, sizeof(b));
528 for (i = 0; i < (size - 4) / 2; i++) {
529 memcpy(b, ptr + (i * 4) + 12, 4);
530 tmp = simple_strtol(b, NULL, 16);
531 bt3c_put(iobase, tmp);
532 }
533 }
534
535 ptr += (size * 2) + 6;
536 count -= (size * 2) + 6;
537 }
538
539 udelay(17);
540
541 /* Boot */
542 bt3c_address(iobase, 0x3000);
543 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
544
545error:
546 udelay(17);
547
548 /* Clear */
549 bt3c_io_write(iobase, 0x7006, 0x0000);
550 bt3c_io_write(iobase, 0x7005, 0x0000);
551 bt3c_io_write(iobase, 0x7001, 0x0000);
552
553 return err;
554}
555
556
557static int bt3c_open(bt3c_info_t *info)
558{
559 const struct firmware *firmware;
560 struct hci_dev *hdev;
561 int err;
562
563 spin_lock_init(&(info->lock));
564
565 skb_queue_head_init(&(info->txq));
566
567 info->rx_state = RECV_WAIT_PACKET_TYPE;
568 info->rx_count = 0;
569 info->rx_skb = NULL;
570
571 /* Initialize HCI device */
572 hdev = hci_alloc_dev();
573 if (!hdev) {
574 BT_ERR("Can't allocate HCI device");
575 return -ENOMEM;
576 }
577
578 info->hdev = hdev;
579
580 hdev->type = HCI_PCCARD;
581 hdev->driver_data = info;
Marcel Holtmann27d35282006-07-03 10:02:37 +0200582 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583
584 hdev->open = bt3c_hci_open;
585 hdev->close = bt3c_hci_close;
586 hdev->flush = bt3c_hci_flush;
587 hdev->send = bt3c_hci_send_frame;
588 hdev->destruct = bt3c_hci_destruct;
589 hdev->ioctl = bt3c_hci_ioctl;
590
591 hdev->owner = THIS_MODULE;
592
593 /* Load firmware */
Dominik Brodowskifd238232006-03-05 10:45:09 +0100594 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 if (err < 0) {
596 BT_ERR("Firmware request failed");
597 goto error;
598 }
599
600 err = bt3c_load_firmware(info, firmware->data, firmware->size);
601
602 release_firmware(firmware);
603
604 if (err < 0) {
605 BT_ERR("Firmware loading failed");
606 goto error;
607 }
608
609 /* Timeout before it is safe to send the first HCI packet */
610 msleep(1000);
611
612 /* Register HCI device */
613 err = hci_register_dev(hdev);
614 if (err < 0) {
615 BT_ERR("Can't register HCI device");
616 goto error;
617 }
618
619 return 0;
620
621error:
622 info->hdev = NULL;
623 hci_free_dev(hdev);
624 return err;
625}
626
627
628static int bt3c_close(bt3c_info_t *info)
629{
630 struct hci_dev *hdev = info->hdev;
631
632 if (!hdev)
633 return -ENODEV;
634
635 bt3c_hci_close(hdev);
636
637 if (hci_unregister_dev(hdev) < 0)
638 BT_ERR("Can't unregister HCI device %s", hdev->name);
639
640 hci_free_dev(hdev);
641
642 return 0;
643}
644
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200645static int bt3c_probe(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646{
647 bt3c_info_t *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
649 /* Create new info device */
Deepak Saxena089b1db2005-11-07 01:01:26 -0800650 info = kzalloc(sizeof(*info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 if (!info)
Dominik Brodowskif8cfa612005-11-14 21:25:51 +0100652 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200654 info->p_dev = link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 link->priv = info;
656
657 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
658 link->io.NumPorts1 = 8;
659 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
660 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
661
662 link->irq.Handler = bt3c_interrupt;
663 link->irq.Instance = info;
664
665 link->conf.Attributes = CONF_ENABLE_IRQ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 link->conf.IntType = INT_MEMORY_AND_IO;
667
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200668 return bt3c_config(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669}
670
671
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200672static void bt3c_detach(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673{
674 bt3c_info_t *info = link->priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100676 bt3c_release(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 kfree(info);
678}
679
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200680static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681{
682 int i;
683
684 i = pcmcia_get_tuple_data(handle, tuple);
685 if (i != CS_SUCCESS)
686 return i;
687
688 return pcmcia_parse_tuple(handle, tuple, parse);
689}
690
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200691static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692{
693 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
694 return CS_NO_MORE_ITEMS;
695 return get_tuple(handle, tuple, parse);
696}
697
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200698static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699{
700 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
701 return CS_NO_MORE_ITEMS;
702 return get_tuple(handle, tuple, parse);
703}
704
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200705static int bt3c_config(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
Olof Johansson906da802008-02-04 22:27:35 -0800707 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 bt3c_info_t *info = link->priv;
709 tuple_t tuple;
710 u_short buf[256];
711 cisparse_t parse;
712 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
Dominik Brodowskiaf2b3b52006-10-25 21:49:27 -0400713 int i, j, try;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 /* First pass: look for a config entry that looks normal. */
716 tuple.TupleData = (cisdata_t *)buf;
717 tuple.TupleOffset = 0;
718 tuple.TupleDataMax = 255;
719 tuple.Attributes = 0;
720 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
721 /* Two tries: without IO aliases, then with aliases */
722 for (try = 0; try < 2; try++) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200723 i = first_tuple(link, &tuple, &parse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 while (i != CS_NO_MORE_ITEMS) {
725 if (i != CS_SUCCESS)
726 goto next_entry;
727 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
Dominik Brodowski70294b42006-01-15 12:43:16 +0100728 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
730 link->conf.ConfigIndex = cf->index;
731 link->io.BasePort1 = cf->io.win[0].base;
732 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200733 i = pcmcia_request_io(link, &link->io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 if (i == CS_SUCCESS)
735 goto found_port;
736 }
737next_entry:
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200738 i = next_tuple(link, &tuple, &parse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 }
740 }
741
742 /* Second pass: try to find an entry that isn't picky about
743 its base address, then try to grab any standard serial port
744 address, and finally try to get any free port. */
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200745 i = first_tuple(link, &tuple, &parse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 while (i != CS_NO_MORE_ITEMS) {
747 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
748 link->conf.ConfigIndex = cf->index;
749 for (j = 0; j < 5; j++) {
750 link->io.BasePort1 = base[j];
751 link->io.IOAddrLines = base[j] ? 16 : 3;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200752 i = pcmcia_request_io(link, &link->io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 if (i == CS_SUCCESS)
754 goto found_port;
755 }
756 }
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200757 i = next_tuple(link, &tuple, &parse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 }
759
760found_port:
761 if (i != CS_SUCCESS) {
762 BT_ERR("No usable port range found");
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200763 cs_error(link, RequestIO, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 goto failed;
765 }
766
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200767 i = pcmcia_request_irq(link, &link->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 if (i != CS_SUCCESS) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200769 cs_error(link, RequestIRQ, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 link->irq.AssignedIRQ = 0;
771 }
772
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200773 i = pcmcia_request_configuration(link, &link->conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 if (i != CS_SUCCESS) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200775 cs_error(link, RequestConfiguration, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 goto failed;
777 }
778
779 if (bt3c_open(info) != 0)
780 goto failed;
781
782 strcpy(info->node.dev_name, info->hdev->name);
Dominik Brodowskifd238232006-03-05 10:45:09 +0100783 link->dev_node = &info->node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200785 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787failed:
788 bt3c_release(link);
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200789 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790}
791
792
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200793static void bt3c_release(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
795 bt3c_info_t *info = link->priv;
796
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100797 bt3c_close(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200799 pcmcia_disable_device(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800}
801
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700803static struct pcmcia_device_id bt3c_ids[] = {
804 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
805 PCMCIA_DEVICE_NULL
806};
807MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
808
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809static struct pcmcia_driver bt3c_driver = {
810 .owner = THIS_MODULE,
811 .drv = {
812 .name = "bt3c_cs",
813 },
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200814 .probe = bt3c_probe,
Dominik Brodowskicc3b4862005-11-14 21:23:14 +0100815 .remove = bt3c_detach,
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700816 .id_table = bt3c_ids,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817};
818
819static int __init init_bt3c_cs(void)
820{
821 return pcmcia_register_driver(&bt3c_driver);
822}
823
824
825static void __exit exit_bt3c_cs(void)
826{
827 pcmcia_unregister_driver(&bt3c_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828}
829
830module_init(init_bt3c_cs);
831module_exit(exit_bt3c_cs);