blob: b94ac2f9f7baf2d5e9cc0641e52de23cd1536d13 [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 {
Dominik Brodowskifd238232006-03-05 10:45:09 +010075 struct pcmcia_device *p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 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
Dominik Brodowski15b99ac2006-03-31 17:26:06 +020091static int bt3c_config(struct pcmcia_device *link);
Dominik Brodowskifba395e2006-03-31 17:21:06 +020092static void bt3c_release(struct pcmcia_device *link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Dominik Brodowskicc3b4862005-11-14 21:23:14 +010094static void bt3c_detach(struct pcmcia_device *p_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
97/* Transmit states */
98#define XMIT_SENDING 1
99#define XMIT_WAKEUP 2
100#define XMIT_WAITING 8
101
102/* Receiver states */
103#define RECV_WAIT_PACKET_TYPE 0
104#define RECV_WAIT_EVENT_HEADER 1
105#define RECV_WAIT_ACL_HEADER 2
106#define RECV_WAIT_SCO_HEADER 3
107#define RECV_WAIT_DATA 4
108
109
110
111/* ======================== Special I/O functions ======================== */
112
113
114#define DATA_L 0
115#define DATA_H 1
116#define ADDR_L 2
117#define ADDR_H 3
118#define CONTROL 4
119
120
121static inline void bt3c_address(unsigned int iobase, unsigned short addr)
122{
123 outb(addr & 0xff, iobase + ADDR_L);
124 outb((addr >> 8) & 0xff, iobase + ADDR_H);
125}
126
127
128static inline void bt3c_put(unsigned int iobase, unsigned short value)
129{
130 outb(value & 0xff, iobase + DATA_L);
131 outb((value >> 8) & 0xff, iobase + DATA_H);
132}
133
134
135static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
136{
137 bt3c_address(iobase, addr);
138 bt3c_put(iobase, value);
139}
140
141
142static inline unsigned short bt3c_get(unsigned int iobase)
143{
144 unsigned short value = inb(iobase + DATA_L);
145
146 value |= inb(iobase + DATA_H) << 8;
147
148 return value;
149}
150
151
152static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
153{
154 bt3c_address(iobase, addr);
155
156 return bt3c_get(iobase);
157}
158
159
160
161/* ======================== Interrupt handling ======================== */
162
163
164static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
165{
166 int actual = 0;
167
168 bt3c_address(iobase, 0x7080);
169
170 /* Fill FIFO with current frame */
171 while (actual < len) {
172 /* Transmit next byte */
173 bt3c_put(iobase, buf[actual]);
174 actual++;
175 }
176
177 bt3c_io_write(iobase, 0x7005, actual);
178
179 return actual;
180}
181
182
183static void bt3c_write_wakeup(bt3c_info_t *info)
184{
185 if (!info) {
186 BT_ERR("Unknown device");
187 return;
188 }
189
190 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
191 return;
192
193 do {
Dominik Brodowskifd238232006-03-05 10:45:09 +0100194 register unsigned int iobase = info->p_dev->io.BasePort1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 register struct sk_buff *skb;
196 register int len;
197
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100198 if (!pcmcia_dev_present(info->p_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 break;
200
201
202 if (!(skb = skb_dequeue(&(info->txq)))) {
203 clear_bit(XMIT_SENDING, &(info->tx_state));
204 break;
205 }
206
207 /* Send frame */
208 len = bt3c_write(iobase, 256, skb->data, skb->len);
209
210 if (len != skb->len) {
211 BT_ERR("Very strange");
212 }
213
214 kfree_skb(skb);
215
216 info->hdev->stat.byte_tx += len;
217
218 } while (0);
219}
220
221
222static void bt3c_receive(bt3c_info_t *info)
223{
224 unsigned int iobase;
225 int size = 0, avail;
226
227 if (!info) {
228 BT_ERR("Unknown device");
229 return;
230 }
231
Dominik Brodowskifd238232006-03-05 10:45:09 +0100232 iobase = info->p_dev->io.BasePort1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
234 avail = bt3c_read(iobase, 0x7006);
235 //printk("bt3c_cs: receiving %d bytes\n", avail);
236
237 bt3c_address(iobase, 0x7480);
238 while (size < avail) {
239 size++;
240 info->hdev->stat.byte_rx++;
241
242 /* Allocate packet */
243 if (info->rx_skb == NULL) {
244 info->rx_state = RECV_WAIT_PACKET_TYPE;
245 info->rx_count = 0;
246 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
247 BT_ERR("Can't allocate mem for new packet");
248 return;
249 }
250 }
251
252
253 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
254
255 info->rx_skb->dev = (void *) info->hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700256 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 inb(iobase + DATA_H);
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700258 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700260 switch (bt_cb(info->rx_skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
262 case HCI_EVENT_PKT:
263 info->rx_state = RECV_WAIT_EVENT_HEADER;
264 info->rx_count = HCI_EVENT_HDR_SIZE;
265 break;
266
267 case HCI_ACLDATA_PKT:
268 info->rx_state = RECV_WAIT_ACL_HEADER;
269 info->rx_count = HCI_ACL_HDR_SIZE;
270 break;
271
272 case HCI_SCODATA_PKT:
273 info->rx_state = RECV_WAIT_SCO_HEADER;
274 info->rx_count = HCI_SCO_HDR_SIZE;
275 break;
276
277 default:
278 /* Unknown packet */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700279 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 info->hdev->stat.err_rx++;
281 clear_bit(HCI_RUNNING, &(info->hdev->flags));
282
283 kfree_skb(info->rx_skb);
284 info->rx_skb = NULL;
285 break;
286
287 }
288
289 } else {
290
291 __u8 x = inb(iobase + DATA_L);
292
293 *skb_put(info->rx_skb, 1) = x;
294 inb(iobase + DATA_H);
295 info->rx_count--;
296
297 if (info->rx_count == 0) {
298
299 int dlen;
300 struct hci_event_hdr *eh;
301 struct hci_acl_hdr *ah;
302 struct hci_sco_hdr *sh;
303
304 switch (info->rx_state) {
305
306 case RECV_WAIT_EVENT_HEADER:
307 eh = (struct hci_event_hdr *)(info->rx_skb->data);
308 info->rx_state = RECV_WAIT_DATA;
309 info->rx_count = eh->plen;
310 break;
311
312 case RECV_WAIT_ACL_HEADER:
313 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
314 dlen = __le16_to_cpu(ah->dlen);
315 info->rx_state = RECV_WAIT_DATA;
316 info->rx_count = dlen;
317 break;
318
319 case RECV_WAIT_SCO_HEADER:
320 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
321 info->rx_state = RECV_WAIT_DATA;
322 info->rx_count = sh->dlen;
323 break;
324
325 case RECV_WAIT_DATA:
326 hci_recv_frame(info->rx_skb);
327 info->rx_skb = NULL;
328 break;
329
330 }
331
332 }
333
334 }
335
336 }
337
338 bt3c_io_write(iobase, 0x7006, 0x0000);
339}
340
341
342static irqreturn_t bt3c_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
343{
344 bt3c_info_t *info = dev_inst;
345 unsigned int iobase;
346 int iir;
347
348 if (!info || !info->hdev) {
349 BT_ERR("Call of irq %d for unknown device", irq);
350 return IRQ_NONE;
351 }
352
Dominik Brodowskifd238232006-03-05 10:45:09 +0100353 iobase = info->p_dev->io.BasePort1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
355 spin_lock(&(info->lock));
356
357 iir = inb(iobase + CONTROL);
358 if (iir & 0x80) {
359 int stat = bt3c_read(iobase, 0x7001);
360
361 if ((stat & 0xff) == 0x7f) {
362 BT_ERR("Very strange (stat=0x%04x)", stat);
363 } else if ((stat & 0xff) != 0xff) {
364 if (stat & 0x0020) {
365 int stat = bt3c_read(iobase, 0x7002) & 0x10;
366 BT_INFO("%s: Antenna %s", info->hdev->name,
367 stat ? "out" : "in");
368 }
369 if (stat & 0x0001)
370 bt3c_receive(info);
371 if (stat & 0x0002) {
372 //BT_ERR("Ack (stat=0x%04x)", stat);
373 clear_bit(XMIT_SENDING, &(info->tx_state));
374 bt3c_write_wakeup(info);
375 }
376
377 bt3c_io_write(iobase, 0x7001, 0x0000);
378
379 outb(iir, iobase + CONTROL);
380 }
381 }
382
383 spin_unlock(&(info->lock));
384
385 return IRQ_HANDLED;
386}
387
388
389
390/* ======================== HCI interface ======================== */
391
392
393static int bt3c_hci_flush(struct hci_dev *hdev)
394{
395 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
396
397 /* Drop TX queue */
398 skb_queue_purge(&(info->txq));
399
400 return 0;
401}
402
403
404static int bt3c_hci_open(struct hci_dev *hdev)
405{
406 set_bit(HCI_RUNNING, &(hdev->flags));
407
408 return 0;
409}
410
411
412static int bt3c_hci_close(struct hci_dev *hdev)
413{
414 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
415 return 0;
416
417 bt3c_hci_flush(hdev);
418
419 return 0;
420}
421
422
423static int bt3c_hci_send_frame(struct sk_buff *skb)
424{
425 bt3c_info_t *info;
426 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
427 unsigned long flags;
428
429 if (!hdev) {
430 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
431 return -ENODEV;
432 }
433
434 info = (bt3c_info_t *) (hdev->driver_data);
435
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700436 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 case HCI_COMMAND_PKT:
438 hdev->stat.cmd_tx++;
439 break;
440 case HCI_ACLDATA_PKT:
441 hdev->stat.acl_tx++;
442 break;
443 case HCI_SCODATA_PKT:
444 hdev->stat.sco_tx++;
445 break;
446 };
447
448 /* Prepend skb with frame type */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700449 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 skb_queue_tail(&(info->txq), skb);
451
452 spin_lock_irqsave(&(info->lock), flags);
453
454 bt3c_write_wakeup(info);
455
456 spin_unlock_irqrestore(&(info->lock), flags);
457
458 return 0;
459}
460
461
462static void bt3c_hci_destruct(struct hci_dev *hdev)
463{
464}
465
466
467static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
468{
469 return -ENOIOCTLCMD;
470}
471
472
473
474/* ======================== Card services HCI interaction ======================== */
475
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477static int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, int count)
478{
479 char *ptr = (char *) firmware;
480 char b[9];
481 unsigned int iobase, size, addr, fcs, tmp;
482 int i, err = 0;
483
Dominik Brodowskifd238232006-03-05 10:45:09 +0100484 iobase = info->p_dev->io.BasePort1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486 /* Reset */
487 bt3c_io_write(iobase, 0x8040, 0x0404);
488 bt3c_io_write(iobase, 0x8040, 0x0400);
489
490 udelay(1);
491
492 bt3c_io_write(iobase, 0x8040, 0x0404);
493
494 udelay(17);
495
496 /* Load */
497 while (count) {
498 if (ptr[0] != 'S') {
499 BT_ERR("Bad address in firmware");
500 err = -EFAULT;
501 goto error;
502 }
503
504 memset(b, 0, sizeof(b));
505 memcpy(b, ptr + 2, 2);
506 size = simple_strtol(b, NULL, 16);
507
508 memset(b, 0, sizeof(b));
509 memcpy(b, ptr + 4, 8);
510 addr = simple_strtol(b, NULL, 16);
511
512 memset(b, 0, sizeof(b));
513 memcpy(b, ptr + (size * 2) + 2, 2);
514 fcs = simple_strtol(b, NULL, 16);
515
516 memset(b, 0, sizeof(b));
517 for (tmp = 0, i = 0; i < size; i++) {
518 memcpy(b, ptr + (i * 2) + 2, 2);
519 tmp += simple_strtol(b, NULL, 16);
520 }
521
522 if (((tmp + fcs) & 0xff) != 0xff) {
523 BT_ERR("Checksum error in firmware");
524 err = -EILSEQ;
525 goto error;
526 }
527
528 if (ptr[1] == '3') {
529 bt3c_address(iobase, addr);
530
531 memset(b, 0, sizeof(b));
532 for (i = 0; i < (size - 4) / 2; i++) {
533 memcpy(b, ptr + (i * 4) + 12, 4);
534 tmp = simple_strtol(b, NULL, 16);
535 bt3c_put(iobase, tmp);
536 }
537 }
538
539 ptr += (size * 2) + 6;
540 count -= (size * 2) + 6;
541 }
542
543 udelay(17);
544
545 /* Boot */
546 bt3c_address(iobase, 0x3000);
547 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
548
549error:
550 udelay(17);
551
552 /* Clear */
553 bt3c_io_write(iobase, 0x7006, 0x0000);
554 bt3c_io_write(iobase, 0x7005, 0x0000);
555 bt3c_io_write(iobase, 0x7001, 0x0000);
556
557 return err;
558}
559
560
561static int bt3c_open(bt3c_info_t *info)
562{
563 const struct firmware *firmware;
564 struct hci_dev *hdev;
565 int err;
566
567 spin_lock_init(&(info->lock));
568
569 skb_queue_head_init(&(info->txq));
570
571 info->rx_state = RECV_WAIT_PACKET_TYPE;
572 info->rx_count = 0;
573 info->rx_skb = NULL;
574
575 /* Initialize HCI device */
576 hdev = hci_alloc_dev();
577 if (!hdev) {
578 BT_ERR("Can't allocate HCI device");
579 return -ENOMEM;
580 }
581
582 info->hdev = hdev;
583
584 hdev->type = HCI_PCCARD;
585 hdev->driver_data = info;
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 */
Dominik Brodowskifd238232006-03-05 10:45:09 +0100597 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 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
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200648static int bt3c_probe(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649{
650 bt3c_info_t *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
652 /* Create new info device */
Deepak Saxena089b1db2005-11-07 01:01:26 -0800653 info = kzalloc(sizeof(*info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 if (!info)
Dominik Brodowskif8cfa612005-11-14 21:25:51 +0100655 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200657 info->p_dev = link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 link->conf.IntType = INT_MEMORY_AND_IO;
670
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200671 return bt3c_config(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672}
673
674
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200675static void bt3c_detach(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676{
677 bt3c_info_t *info = link->priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100679 bt3c_release(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 kfree(info);
681}
682
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200683static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684{
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
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200694static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695{
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
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200701static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702{
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
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200708static int bt3c_config(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
710 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 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;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200725 last_ret = first_tuple(link, &tuple, &parse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 /* 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++) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200741 i = first_tuple(link, &tuple, &parse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 while (i != CS_NO_MORE_ITEMS) {
743 if (i != CS_SUCCESS)
744 goto next_entry;
745 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
Dominik Brodowski70294b42006-01-15 12:43:16 +0100746 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 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;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200751 i = pcmcia_request_io(link, &link->io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 if (i == CS_SUCCESS)
753 goto found_port;
754 }
755next_entry:
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200756 i = next_tuple(link, &tuple, &parse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 }
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. */
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200763 i = first_tuple(link, &tuple, &parse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 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;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200770 i = pcmcia_request_io(link, &link->io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 if (i == CS_SUCCESS)
772 goto found_port;
773 }
774 }
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200775 i = next_tuple(link, &tuple, &parse);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 }
777
778found_port:
779 if (i != CS_SUCCESS) {
780 BT_ERR("No usable port range found");
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200781 cs_error(link, RequestIO, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 goto failed;
783 }
784
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200785 i = pcmcia_request_irq(link, &link->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 if (i != CS_SUCCESS) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200787 cs_error(link, RequestIRQ, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 link->irq.AssignedIRQ = 0;
789 }
790
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200791 i = pcmcia_request_configuration(link, &link->conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 if (i != CS_SUCCESS) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200793 cs_error(link, RequestConfiguration, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 goto failed;
795 }
796
797 if (bt3c_open(info) != 0)
798 goto failed;
799
800 strcpy(info->node.dev_name, info->hdev->name);
Dominik Brodowskifd238232006-03-05 10:45:09 +0100801 link->dev_node = &info->node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200803 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
805cs_failed:
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200806 cs_error(link, last_fn, last_ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
808failed:
809 bt3c_release(link);
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200810 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811}
812
813
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200814static void bt3c_release(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815{
816 bt3c_info_t *info = link->priv;
817
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100818 bt3c_close(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200820 pcmcia_disable_device(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821}
822
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700824static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830static struct pcmcia_driver bt3c_driver = {
831 .owner = THIS_MODULE,
832 .drv = {
833 .name = "bt3c_cs",
834 },
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200835 .probe = bt3c_probe,
Dominik Brodowskicc3b4862005-11-14 21:23:14 +0100836 .remove = bt3c_detach,
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700837 .id_table = bt3c_ids,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838};
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849}
850
851module_init(init_bt3c_cs);
852module_exit(exit_bt3c_cs);