blob: d58e22b9f06a46b2b6a082703f822519f0b815b7 [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
Marcel Holtmann63fbd242008-08-18 13:23:53 +020063MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -070064MODULE_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;
Alan Coxaafcf992008-10-05 17:35:41 +0100346 irqreturn_t r = IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Jeff Garzikac019362007-10-20 13:45:57 +0200348 BUG_ON(!info->hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Dominik Brodowskifd238232006-03-05 10:45:09 +0100350 iobase = info->p_dev->io.BasePort1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 spin_lock(&(info->lock));
353
354 iir = inb(iobase + CONTROL);
355 if (iir & 0x80) {
356 int stat = bt3c_read(iobase, 0x7001);
357
358 if ((stat & 0xff) == 0x7f) {
359 BT_ERR("Very strange (stat=0x%04x)", stat);
360 } else if ((stat & 0xff) != 0xff) {
361 if (stat & 0x0020) {
Andre Haupt34a55ed2009-02-02 14:45:11 -0800362 int status = bt3c_read(iobase, 0x7002) & 0x10;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 BT_INFO("%s: Antenna %s", info->hdev->name,
Andre Haupt34a55ed2009-02-02 14:45:11 -0800364 status ? "out" : "in");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 }
366 if (stat & 0x0001)
367 bt3c_receive(info);
368 if (stat & 0x0002) {
369 //BT_ERR("Ack (stat=0x%04x)", stat);
370 clear_bit(XMIT_SENDING, &(info->tx_state));
371 bt3c_write_wakeup(info);
372 }
373
374 bt3c_io_write(iobase, 0x7001, 0x0000);
375
376 outb(iir, iobase + CONTROL);
377 }
Alan Coxaafcf992008-10-05 17:35:41 +0100378 r = IRQ_HANDLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 }
380
381 spin_unlock(&(info->lock));
382
Alan Coxaafcf992008-10-05 17:35:41 +0100383 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384}
385
386
387
388/* ======================== HCI interface ======================== */
389
390
391static int bt3c_hci_flush(struct hci_dev *hdev)
392{
393 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
394
395 /* Drop TX queue */
396 skb_queue_purge(&(info->txq));
397
398 return 0;
399}
400
401
402static int bt3c_hci_open(struct hci_dev *hdev)
403{
404 set_bit(HCI_RUNNING, &(hdev->flags));
405
406 return 0;
407}
408
409
410static int bt3c_hci_close(struct hci_dev *hdev)
411{
412 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
413 return 0;
414
415 bt3c_hci_flush(hdev);
416
417 return 0;
418}
419
420
421static int bt3c_hci_send_frame(struct sk_buff *skb)
422{
423 bt3c_info_t *info;
424 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
425 unsigned long flags;
426
427 if (!hdev) {
428 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
429 return -ENODEV;
430 }
431
432 info = (bt3c_info_t *) (hdev->driver_data);
433
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700434 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 case HCI_COMMAND_PKT:
436 hdev->stat.cmd_tx++;
437 break;
438 case HCI_ACLDATA_PKT:
439 hdev->stat.acl_tx++;
440 break;
441 case HCI_SCODATA_PKT:
442 hdev->stat.sco_tx++;
443 break;
444 };
445
446 /* Prepend skb with frame type */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700447 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 skb_queue_tail(&(info->txq), skb);
449
450 spin_lock_irqsave(&(info->lock), flags);
451
452 bt3c_write_wakeup(info);
453
454 spin_unlock_irqrestore(&(info->lock), flags);
455
456 return 0;
457}
458
459
460static void bt3c_hci_destruct(struct hci_dev *hdev)
461{
462}
463
464
465static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
466{
467 return -ENOIOCTLCMD;
468}
469
470
471
472/* ======================== Card services HCI interaction ======================== */
473
474
David Woodhouse8187b4f2008-05-23 23:56:51 +0100475static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
476 int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477{
478 char *ptr = (char *) firmware;
479 char b[9];
480 unsigned int iobase, size, addr, fcs, tmp;
481 int i, err = 0;
482
Dominik Brodowskifd238232006-03-05 10:45:09 +0100483 iobase = info->p_dev->io.BasePort1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485 /* Reset */
486 bt3c_io_write(iobase, 0x8040, 0x0404);
487 bt3c_io_write(iobase, 0x8040, 0x0400);
488
489 udelay(1);
490
491 bt3c_io_write(iobase, 0x8040, 0x0404);
492
493 udelay(17);
494
495 /* Load */
496 while (count) {
497 if (ptr[0] != 'S') {
498 BT_ERR("Bad address in firmware");
499 err = -EFAULT;
500 goto error;
501 }
502
503 memset(b, 0, sizeof(b));
504 memcpy(b, ptr + 2, 2);
Julia Lawall51a6fbc82008-11-30 12:17:20 +0100505 size = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507 memset(b, 0, sizeof(b));
508 memcpy(b, ptr + 4, 8);
Julia Lawall51a6fbc82008-11-30 12:17:20 +0100509 addr = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
511 memset(b, 0, sizeof(b));
512 memcpy(b, ptr + (size * 2) + 2, 2);
Julia Lawall51a6fbc82008-11-30 12:17:20 +0100513 fcs = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515 memset(b, 0, sizeof(b));
516 for (tmp = 0, i = 0; i < size; i++) {
517 memcpy(b, ptr + (i * 2) + 2, 2);
518 tmp += simple_strtol(b, NULL, 16);
519 }
520
521 if (((tmp + fcs) & 0xff) != 0xff) {
522 BT_ERR("Checksum error in firmware");
523 err = -EILSEQ;
524 goto error;
525 }
526
527 if (ptr[1] == '3') {
528 bt3c_address(iobase, addr);
529
530 memset(b, 0, sizeof(b));
531 for (i = 0; i < (size - 4) / 2; i++) {
532 memcpy(b, ptr + (i * 4) + 12, 4);
Julia Lawall51a6fbc82008-11-30 12:17:20 +0100533 tmp = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 bt3c_put(iobase, tmp);
535 }
536 }
537
538 ptr += (size * 2) + 6;
539 count -= (size * 2) + 6;
540 }
541
542 udelay(17);
543
544 /* Boot */
545 bt3c_address(iobase, 0x3000);
546 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
547
548error:
549 udelay(17);
550
551 /* Clear */
552 bt3c_io_write(iobase, 0x7006, 0x0000);
553 bt3c_io_write(iobase, 0x7005, 0x0000);
554 bt3c_io_write(iobase, 0x7001, 0x0000);
555
556 return err;
557}
558
559
560static int bt3c_open(bt3c_info_t *info)
561{
562 const struct firmware *firmware;
563 struct hci_dev *hdev;
564 int err;
565
566 spin_lock_init(&(info->lock));
567
568 skb_queue_head_init(&(info->txq));
569
570 info->rx_state = RECV_WAIT_PACKET_TYPE;
571 info->rx_count = 0;
572 info->rx_skb = NULL;
573
574 /* Initialize HCI device */
575 hdev = hci_alloc_dev();
576 if (!hdev) {
577 BT_ERR("Can't allocate HCI device");
578 return -ENOMEM;
579 }
580
581 info->hdev = hdev;
582
583 hdev->type = HCI_PCCARD;
584 hdev->driver_data = info;
Marcel Holtmann27d35282006-07-03 10:02:37 +0200585 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
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;
Alan Coxaafcf992008-10-05 17:35:41 +0100662 link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 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 Brodowskied588722008-07-29 08:38:55 +0200683static int bt3c_check_config(struct pcmcia_device *p_dev,
684 cistpl_cftable_entry_t *cf,
Dominik Brodowski8e2fc392008-08-02 15:30:31 +0200685 cistpl_cftable_entry_t *dflt,
Dominik Brodowskiad913c12008-08-02 16:12:00 +0200686 unsigned int vcc,
Dominik Brodowskied588722008-07-29 08:38:55 +0200687 void *priv_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688{
Dominik Brodowskied588722008-07-29 08:38:55 +0200689 unsigned long try = (unsigned long) priv_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Dominik Brodowskied588722008-07-29 08:38:55 +0200691 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
692 p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
693 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
694 (cf->io.win[0].base != 0)) {
Dominik Brodowskied588722008-07-29 08:38:55 +0200695 p_dev->io.BasePort1 = cf->io.win[0].base;
696 p_dev->io.IOAddrLines = (try == 0) ? 16 :
697 cf->io.flags & CISTPL_IO_LINES_MASK;
698 if (!pcmcia_request_io(p_dev, &p_dev->io))
699 return 0;
700 }
701 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702}
703
Dominik Brodowskied588722008-07-29 08:38:55 +0200704static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
705 cistpl_cftable_entry_t *cf,
Dominik Brodowski8e2fc392008-08-02 15:30:31 +0200706 cistpl_cftable_entry_t *dflt,
Dominik Brodowskiad913c12008-08-02 16:12:00 +0200707 unsigned int vcc,
Dominik Brodowskied588722008-07-29 08:38:55 +0200708 void *priv_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
Dominik Brodowskied588722008-07-29 08:38:55 +0200710 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
711 int j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Dominik Brodowskied588722008-07-29 08:38:55 +0200713 if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
Dominik Brodowskied588722008-07-29 08:38:55 +0200714 for (j = 0; j < 5; j++) {
715 p_dev->io.BasePort1 = base[j];
716 p_dev->io.IOAddrLines = base[j] ? 16 : 3;
717 if (!pcmcia_request_io(p_dev, &p_dev->io))
718 return 0;
719 }
720 }
721 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722}
723
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200724static int bt3c_config(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 bt3c_info_t *info = link->priv;
Dominik Brodowskied588722008-07-29 08:38:55 +0200727 int i;
728 unsigned long try;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
Dominik Brodowskied588722008-07-29 08:38:55 +0200730 /* First pass: look for a config entry that looks normal.
731 Two tries: without IO aliases, then with aliases */
732 for (try = 0; try < 2; try++)
733 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
734 goto found_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
736 /* Second pass: try to find an entry that isn't picky about
737 its base address, then try to grab any standard serial port
738 address, and finally try to get any free port. */
Dominik Brodowskied588722008-07-29 08:38:55 +0200739 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
740 goto found_port;
741
742 BT_ERR("No usable port range found");
743 cs_error(link, RequestIO, -ENODEV);
744 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
746found_port:
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200747 i = pcmcia_request_irq(link, &link->irq);
Dominik Brodowski4c89e882008-08-03 10:07:45 +0200748 if (i != 0) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200749 cs_error(link, RequestIRQ, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 link->irq.AssignedIRQ = 0;
751 }
752
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200753 i = pcmcia_request_configuration(link, &link->conf);
Dominik Brodowski4c89e882008-08-03 10:07:45 +0200754 if (i != 0) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200755 cs_error(link, RequestConfiguration, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 goto failed;
757 }
758
759 if (bt3c_open(info) != 0)
760 goto failed;
761
762 strcpy(info->node.dev_name, info->hdev->name);
Dominik Brodowskifd238232006-03-05 10:45:09 +0100763 link->dev_node = &info->node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200765 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767failed:
768 bt3c_release(link);
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200769 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770}
771
772
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200773static void bt3c_release(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774{
775 bt3c_info_t *info = link->priv;
776
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100777 bt3c_close(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200779 pcmcia_disable_device(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780}
781
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700783static struct pcmcia_device_id bt3c_ids[] = {
784 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
785 PCMCIA_DEVICE_NULL
786};
787MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789static struct pcmcia_driver bt3c_driver = {
790 .owner = THIS_MODULE,
791 .drv = {
792 .name = "bt3c_cs",
793 },
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200794 .probe = bt3c_probe,
Dominik Brodowskicc3b4862005-11-14 21:23:14 +0100795 .remove = bt3c_detach,
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700796 .id_table = bt3c_ids,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797};
798
799static int __init init_bt3c_cs(void)
800{
801 return pcmcia_register_driver(&bt3c_driver);
802}
803
804
805static void __exit exit_bt3c_cs(void)
806{
807 pcmcia_unregister_driver(&bt3c_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808}
809
810module_init(init_bt3c_cs);
811module_exit(exit_bt3c_cs);