blob: 4fc01949d39981a77b6e9dca90606ab94ae259b8 [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/cistpl.h>
49#include <pcmcia/ciscode.h>
50#include <pcmcia/ds.h>
51#include <pcmcia/cisreg.h>
52
53#include <net/bluetooth/bluetooth.h>
54#include <net/bluetooth/hci_core.h>
55
56
57
58/* ======================== Module parameters ======================== */
59
60
Marcel Holtmann63fbd242008-08-18 13:23:53 +020061MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -070062MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
63MODULE_LICENSE("GPL");
Marcel Holtmann23121192007-02-17 23:59:02 +010064MODULE_FIRMWARE("BT3CPCC.bin");
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66
67
68/* ======================== Local structures ======================== */
69
70
71typedef struct bt3c_info_t {
Dominik Brodowskifd238232006-03-05 10:45:09 +010072 struct pcmcia_device *p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
74 struct hci_dev *hdev;
75
76 spinlock_t lock; /* For serializing operations */
77
78 struct sk_buff_head txq;
79 unsigned long tx_state;
80
81 unsigned long rx_state;
82 unsigned long rx_count;
83 struct sk_buff *rx_skb;
84} bt3c_info_t;
85
86
Dominik Brodowski15b99ac2006-03-31 17:26:06 +020087static int bt3c_config(struct pcmcia_device *link);
Dominik Brodowskifba395e2006-03-31 17:21:06 +020088static void bt3c_release(struct pcmcia_device *link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Dominik Brodowskicc3b4862005-11-14 21:23:14 +010090static void bt3c_detach(struct pcmcia_device *p_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
93/* Transmit states */
94#define XMIT_SENDING 1
95#define XMIT_WAKEUP 2
96#define XMIT_WAITING 8
97
98/* Receiver states */
99#define RECV_WAIT_PACKET_TYPE 0
100#define RECV_WAIT_EVENT_HEADER 1
101#define RECV_WAIT_ACL_HEADER 2
102#define RECV_WAIT_SCO_HEADER 3
103#define RECV_WAIT_DATA 4
104
105
106
107/* ======================== Special I/O functions ======================== */
108
109
110#define DATA_L 0
111#define DATA_H 1
112#define ADDR_L 2
113#define ADDR_H 3
114#define CONTROL 4
115
116
117static inline void bt3c_address(unsigned int iobase, unsigned short addr)
118{
119 outb(addr & 0xff, iobase + ADDR_L);
120 outb((addr >> 8) & 0xff, iobase + ADDR_H);
121}
122
123
124static inline void bt3c_put(unsigned int iobase, unsigned short value)
125{
126 outb(value & 0xff, iobase + DATA_L);
127 outb((value >> 8) & 0xff, iobase + DATA_H);
128}
129
130
131static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
132{
133 bt3c_address(iobase, addr);
134 bt3c_put(iobase, value);
135}
136
137
138static inline unsigned short bt3c_get(unsigned int iobase)
139{
140 unsigned short value = inb(iobase + DATA_L);
141
142 value |= inb(iobase + DATA_H) << 8;
143
144 return value;
145}
146
147
148static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
149{
150 bt3c_address(iobase, addr);
151
152 return bt3c_get(iobase);
153}
154
155
156
157/* ======================== Interrupt handling ======================== */
158
159
160static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
161{
162 int actual = 0;
163
164 bt3c_address(iobase, 0x7080);
165
166 /* Fill FIFO with current frame */
167 while (actual < len) {
168 /* Transmit next byte */
169 bt3c_put(iobase, buf[actual]);
170 actual++;
171 }
172
173 bt3c_io_write(iobase, 0x7005, actual);
174
175 return actual;
176}
177
178
179static void bt3c_write_wakeup(bt3c_info_t *info)
180{
181 if (!info) {
182 BT_ERR("Unknown device");
183 return;
184 }
185
186 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
187 return;
188
189 do {
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200190 register unsigned int iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 register struct sk_buff *skb;
192 register int len;
193
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100194 if (!pcmcia_dev_present(info->p_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 break;
196
197
198 if (!(skb = skb_dequeue(&(info->txq)))) {
199 clear_bit(XMIT_SENDING, &(info->tx_state));
200 break;
201 }
202
203 /* Send frame */
204 len = bt3c_write(iobase, 256, skb->data, skb->len);
205
206 if (len != skb->len) {
207 BT_ERR("Very strange");
208 }
209
210 kfree_skb(skb);
211
212 info->hdev->stat.byte_tx += len;
213
214 } while (0);
215}
216
217
218static void bt3c_receive(bt3c_info_t *info)
219{
220 unsigned int iobase;
221 int size = 0, avail;
222
223 if (!info) {
224 BT_ERR("Unknown device");
225 return;
226 }
227
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200228 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
230 avail = bt3c_read(iobase, 0x7006);
231 //printk("bt3c_cs: receiving %d bytes\n", avail);
232
233 bt3c_address(iobase, 0x7480);
234 while (size < avail) {
235 size++;
236 info->hdev->stat.byte_rx++;
237
238 /* Allocate packet */
239 if (info->rx_skb == NULL) {
240 info->rx_state = RECV_WAIT_PACKET_TYPE;
241 info->rx_count = 0;
242 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
243 BT_ERR("Can't allocate mem for new packet");
244 return;
245 }
246 }
247
248
249 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
250
251 info->rx_skb->dev = (void *) info->hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700252 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 inb(iobase + DATA_H);
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700254 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700256 switch (bt_cb(info->rx_skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
258 case HCI_EVENT_PKT:
259 info->rx_state = RECV_WAIT_EVENT_HEADER;
260 info->rx_count = HCI_EVENT_HDR_SIZE;
261 break;
262
263 case HCI_ACLDATA_PKT:
264 info->rx_state = RECV_WAIT_ACL_HEADER;
265 info->rx_count = HCI_ACL_HDR_SIZE;
266 break;
267
268 case HCI_SCODATA_PKT:
269 info->rx_state = RECV_WAIT_SCO_HEADER;
270 info->rx_count = HCI_SCO_HDR_SIZE;
271 break;
272
273 default:
274 /* Unknown packet */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700275 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 info->hdev->stat.err_rx++;
277 clear_bit(HCI_RUNNING, &(info->hdev->flags));
278
279 kfree_skb(info->rx_skb);
280 info->rx_skb = NULL;
281 break;
282
283 }
284
285 } else {
286
287 __u8 x = inb(iobase + DATA_L);
288
289 *skb_put(info->rx_skb, 1) = x;
290 inb(iobase + DATA_H);
291 info->rx_count--;
292
293 if (info->rx_count == 0) {
294
295 int dlen;
296 struct hci_event_hdr *eh;
297 struct hci_acl_hdr *ah;
298 struct hci_sco_hdr *sh;
299
300 switch (info->rx_state) {
301
302 case RECV_WAIT_EVENT_HEADER:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300303 eh = hci_event_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 info->rx_state = RECV_WAIT_DATA;
305 info->rx_count = eh->plen;
306 break;
307
308 case RECV_WAIT_ACL_HEADER:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300309 ah = hci_acl_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 dlen = __le16_to_cpu(ah->dlen);
311 info->rx_state = RECV_WAIT_DATA;
312 info->rx_count = dlen;
313 break;
314
315 case RECV_WAIT_SCO_HEADER:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300316 sh = hci_sco_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 info->rx_state = RECV_WAIT_DATA;
318 info->rx_count = sh->dlen;
319 break;
320
321 case RECV_WAIT_DATA:
322 hci_recv_frame(info->rx_skb);
323 info->rx_skb = NULL;
324 break;
325
326 }
327
328 }
329
330 }
331
332 }
333
334 bt3c_io_write(iobase, 0x7006, 0x0000);
335}
336
337
David Howells7d12e782006-10-05 14:55:46 +0100338static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
340 bt3c_info_t *info = dev_inst;
341 unsigned int iobase;
342 int iir;
Alan Coxaafcf992008-10-05 17:35:41 +0100343 irqreturn_t r = IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Mike Frysinger74278472009-09-14 13:43:49 -0400345 if (!info || !info->hdev)
346 /* our irq handler is shared */
347 return IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200349 iobase = info->p_dev->resource[0]->start;
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) {
Andre Haupt34a55ed2009-02-02 14:45:11 -0800361 int status = bt3c_read(iobase, 0x7002) & 0x10;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 BT_INFO("%s: Antenna %s", info->hdev->name,
Andre Haupt34a55ed2009-02-02 14:45:11 -0800363 status ? "out" : "in");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 }
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 }
Alan Coxaafcf992008-10-05 17:35:41 +0100377 r = IRQ_HANDLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 }
379
380 spin_unlock(&(info->lock));
381
Alan Coxaafcf992008-10-05 17:35:41 +0100382 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383}
384
385
386
387/* ======================== HCI interface ======================== */
388
389
390static int bt3c_hci_flush(struct hci_dev *hdev)
391{
392 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
393
394 /* Drop TX queue */
395 skb_queue_purge(&(info->txq));
396
397 return 0;
398}
399
400
401static int bt3c_hci_open(struct hci_dev *hdev)
402{
403 set_bit(HCI_RUNNING, &(hdev->flags));
404
405 return 0;
406}
407
408
409static int bt3c_hci_close(struct hci_dev *hdev)
410{
411 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
412 return 0;
413
414 bt3c_hci_flush(hdev);
415
416 return 0;
417}
418
419
420static int bt3c_hci_send_frame(struct sk_buff *skb)
421{
422 bt3c_info_t *info;
423 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
424 unsigned long flags;
425
426 if (!hdev) {
427 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
428 return -ENODEV;
429 }
430
431 info = (bt3c_info_t *) (hdev->driver_data);
432
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700433 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 case HCI_COMMAND_PKT:
435 hdev->stat.cmd_tx++;
436 break;
437 case HCI_ACLDATA_PKT:
438 hdev->stat.acl_tx++;
439 break;
440 case HCI_SCODATA_PKT:
441 hdev->stat.sco_tx++;
442 break;
443 };
444
445 /* Prepend skb with frame type */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700446 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 skb_queue_tail(&(info->txq), skb);
448
449 spin_lock_irqsave(&(info->lock), flags);
450
451 bt3c_write_wakeup(info);
452
453 spin_unlock_irqrestore(&(info->lock), flags);
454
455 return 0;
456}
457
458
459static void bt3c_hci_destruct(struct hci_dev *hdev)
460{
461}
462
463
464static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
465{
466 return -ENOIOCTLCMD;
467}
468
469
470
471/* ======================== Card services HCI interaction ======================== */
472
473
David Woodhouse8187b4f2008-05-23 23:56:51 +0100474static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
475 int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476{
477 char *ptr = (char *) firmware;
478 char b[9];
479 unsigned int iobase, size, addr, fcs, tmp;
480 int i, err = 0;
481
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200482 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 /* Reset */
485 bt3c_io_write(iobase, 0x8040, 0x0404);
486 bt3c_io_write(iobase, 0x8040, 0x0400);
487
488 udelay(1);
489
490 bt3c_io_write(iobase, 0x8040, 0x0404);
491
492 udelay(17);
493
494 /* Load */
495 while (count) {
496 if (ptr[0] != 'S') {
497 BT_ERR("Bad address in firmware");
498 err = -EFAULT;
499 goto error;
500 }
501
502 memset(b, 0, sizeof(b));
503 memcpy(b, ptr + 2, 2);
Julia Lawall51a6fbc82008-11-30 12:17:20 +0100504 size = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
506 memset(b, 0, sizeof(b));
507 memcpy(b, ptr + 4, 8);
Julia Lawall51a6fbc82008-11-30 12:17:20 +0100508 addr = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
510 memset(b, 0, sizeof(b));
511 memcpy(b, ptr + (size * 2) + 2, 2);
Julia Lawall51a6fbc82008-11-30 12:17:20 +0100512 fcs = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
514 memset(b, 0, sizeof(b));
515 for (tmp = 0, i = 0; i < size; i++) {
516 memcpy(b, ptr + (i * 2) + 2, 2);
517 tmp += simple_strtol(b, NULL, 16);
518 }
519
520 if (((tmp + fcs) & 0xff) != 0xff) {
521 BT_ERR("Checksum error in firmware");
522 err = -EILSEQ;
523 goto error;
524 }
525
526 if (ptr[1] == '3') {
527 bt3c_address(iobase, addr);
528
529 memset(b, 0, sizeof(b));
530 for (i = 0; i < (size - 4) / 2; i++) {
531 memcpy(b, ptr + (i * 4) + 12, 4);
Julia Lawall51a6fbc82008-11-30 12:17:20 +0100532 tmp = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 bt3c_put(iobase, tmp);
534 }
535 }
536
537 ptr += (size * 2) + 6;
538 count -= (size * 2) + 6;
539 }
540
541 udelay(17);
542
543 /* Boot */
544 bt3c_address(iobase, 0x3000);
545 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
546
547error:
548 udelay(17);
549
550 /* Clear */
551 bt3c_io_write(iobase, 0x7006, 0x0000);
552 bt3c_io_write(iobase, 0x7005, 0x0000);
553 bt3c_io_write(iobase, 0x7001, 0x0000);
554
555 return err;
556}
557
558
559static int bt3c_open(bt3c_info_t *info)
560{
561 const struct firmware *firmware;
562 struct hci_dev *hdev;
563 int err;
564
565 spin_lock_init(&(info->lock));
566
567 skb_queue_head_init(&(info->txq));
568
569 info->rx_state = RECV_WAIT_PACKET_TYPE;
570 info->rx_count = 0;
571 info->rx_skb = NULL;
572
573 /* Initialize HCI device */
574 hdev = hci_alloc_dev();
575 if (!hdev) {
576 BT_ERR("Can't allocate HCI device");
577 return -ENOMEM;
578 }
579
580 info->hdev = hdev;
581
Marcel Holtmannc13854ce2010-02-08 15:27:07 +0100582 hdev->bus = HCI_PCCARD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 hdev->driver_data = info;
Marcel Holtmann27d35282006-07-03 10:02:37 +0200584 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
586 hdev->open = bt3c_hci_open;
587 hdev->close = bt3c_hci_close;
588 hdev->flush = bt3c_hci_flush;
589 hdev->send = bt3c_hci_send_frame;
590 hdev->destruct = bt3c_hci_destruct;
591 hdev->ioctl = bt3c_hci_ioctl;
592
593 hdev->owner = THIS_MODULE;
594
595 /* Load firmware */
Dominik Brodowskifd238232006-03-05 10:45:09 +0100596 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 if (err < 0) {
598 BT_ERR("Firmware request failed");
599 goto error;
600 }
601
602 err = bt3c_load_firmware(info, firmware->data, firmware->size);
603
604 release_firmware(firmware);
605
606 if (err < 0) {
607 BT_ERR("Firmware loading failed");
608 goto error;
609 }
610
611 /* Timeout before it is safe to send the first HCI packet */
612 msleep(1000);
613
614 /* Register HCI device */
615 err = hci_register_dev(hdev);
616 if (err < 0) {
617 BT_ERR("Can't register HCI device");
618 goto error;
619 }
620
621 return 0;
622
623error:
624 info->hdev = NULL;
625 hci_free_dev(hdev);
626 return err;
627}
628
629
630static int bt3c_close(bt3c_info_t *info)
631{
632 struct hci_dev *hdev = info->hdev;
633
634 if (!hdev)
635 return -ENODEV;
636
637 bt3c_hci_close(hdev);
638
639 if (hci_unregister_dev(hdev) < 0)
640 BT_ERR("Can't unregister HCI device %s", hdev->name);
641
642 hci_free_dev(hdev);
643
644 return 0;
645}
646
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200647static int bt3c_probe(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648{
649 bt3c_info_t *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
651 /* Create new info device */
Deepak Saxena089b1db2005-11-07 01:01:26 -0800652 info = kzalloc(sizeof(*info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 if (!info)
Dominik Brodowskif8cfa612005-11-14 21:25:51 +0100654 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200656 info->p_dev = link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 link->priv = info;
658
Dominik Brodowski00990e72010-07-30 13:13:46 +0200659 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
660 CONF_AUTO_SET_IO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200662 return bt3c_config(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663}
664
665
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200666static void bt3c_detach(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667{
668 bt3c_info_t *info = link->priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100670 bt3c_release(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 kfree(info);
672}
673
Dominik Brodowski00990e72010-07-30 13:13:46 +0200674static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675{
Dominik Brodowski00990e72010-07-30 13:13:46 +0200676 int *try = priv_data;
Dominik Brodowski90abdc32010-07-24 17:23:51 +0200677
Dominik Brodowski00990e72010-07-30 13:13:46 +0200678 if (try == 0)
679 p_dev->io_lines = 16;
680
681 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
682 return -EINVAL;
683
684 p_dev->resource[0]->end = 8;
685 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
686 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
687
688 return pcmcia_request_io(p_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689}
690
Dominik Brodowskied588722008-07-29 08:38:55 +0200691static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
Dominik Brodowskied588722008-07-29 08:38:55 +0200692 void *priv_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
Dominik Brodowskied588722008-07-29 08:38:55 +0200694 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
695 int j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
Dominik Brodowski00990e72010-07-30 13:13:46 +0200697 if (p_dev->io_lines > 3)
698 return -ENODEV;
699
700 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
701 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
702 p_dev->resource[0]->end = 8;
703
704 for (j = 0; j < 5; j++) {
705 p_dev->resource[0]->start = base[j];
706 p_dev->io_lines = base[j] ? 16 : 3;
707 if (!pcmcia_request_io(p_dev))
708 return 0;
Dominik Brodowskied588722008-07-29 08:38:55 +0200709 }
710 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711}
712
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200713static int bt3c_config(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 bt3c_info_t *info = link->priv;
Dominik Brodowskied588722008-07-29 08:38:55 +0200716 int i;
717 unsigned long try;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
Dominik Brodowskied588722008-07-29 08:38:55 +0200719 /* First pass: look for a config entry that looks normal.
720 Two tries: without IO aliases, then with aliases */
721 for (try = 0; try < 2; try++)
722 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
723 goto found_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
725 /* Second pass: try to find an entry that isn't picky about
726 its base address, then try to grab any standard serial port
727 address, and finally try to get any free port. */
Dominik Brodowskied588722008-07-29 08:38:55 +0200728 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
729 goto found_port;
730
731 BT_ERR("No usable port range found");
Dominik Brodowskied588722008-07-29 08:38:55 +0200732 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
734found_port:
Dominik Brodowskieb141202010-03-07 12:21:16 +0100735 i = pcmcia_request_irq(link, &bt3c_interrupt);
Dominik Brodowski9ac3e582009-10-24 15:45:06 +0200736 if (i != 0)
Dominik Brodowskieb141202010-03-07 12:21:16 +0100737 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
Dominik Brodowski1ac71e52010-07-29 19:27:09 +0200739 i = pcmcia_enable_device(link);
Dominik Brodowski9ac3e582009-10-24 15:45:06 +0200740 if (i != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
743 if (bt3c_open(info) != 0)
744 goto failed;
745
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200746 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748failed:
749 bt3c_release(link);
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200750 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751}
752
753
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200754static void bt3c_release(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755{
756 bt3c_info_t *info = link->priv;
757
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100758 bt3c_close(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200760 pcmcia_disable_device(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761}
762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
Joe Perches25f8f542011-05-03 19:29:01 -0700764static const struct pcmcia_device_id bt3c_ids[] = {
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700765 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
766 PCMCIA_DEVICE_NULL
767};
768MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770static struct pcmcia_driver bt3c_driver = {
771 .owner = THIS_MODULE,
Dominik Brodowski2e9b9812010-08-08 11:36:26 +0200772 .name = "bt3c_cs",
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200773 .probe = bt3c_probe,
Dominik Brodowskicc3b4862005-11-14 21:23:14 +0100774 .remove = bt3c_detach,
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700775 .id_table = bt3c_ids,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776};
777
778static int __init init_bt3c_cs(void)
779{
780 return pcmcia_register_driver(&bt3c_driver);
781}
782
783
784static void __exit exit_bt3c_cs(void)
785{
786 pcmcia_unregister_driver(&bt3c_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787}
788
789module_init(init_bt3c_cs);
790module_exit(exit_bt3c_cs);