blob: 308c8599ab55ca480c364cab3b40bc6f41d94faf [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <asm/io.h>
43
44#include <linux/device.h>
45#include <linux/firmware.h>
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <pcmcia/cistpl.h>
48#include <pcmcia/ciscode.h>
49#include <pcmcia/ds.h>
50#include <pcmcia/cisreg.h>
51
52#include <net/bluetooth/bluetooth.h>
53#include <net/bluetooth/hci_core.h>
54
55
56
57/* ======================== Module parameters ======================== */
58
59
Marcel Holtmann63fbd242008-08-18 13:23:53 +020060MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -070061MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
62MODULE_LICENSE("GPL");
Marcel Holtmann23121192007-02-17 23:59:02 +010063MODULE_FIRMWARE("BT3CPCC.bin");
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
65
66
67/* ======================== Local structures ======================== */
68
69
70typedef struct bt3c_info_t {
Dominik Brodowskifd238232006-03-05 10:45:09 +010071 struct pcmcia_device *p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73 struct hci_dev *hdev;
74
75 spinlock_t lock; /* For serializing operations */
76
77 struct sk_buff_head txq;
78 unsigned long tx_state;
79
80 unsigned long rx_state;
81 unsigned long rx_count;
82 struct sk_buff *rx_skb;
83} bt3c_info_t;
84
85
Dominik Brodowski15b99ac2006-03-31 17:26:06 +020086static int bt3c_config(struct pcmcia_device *link);
Dominik Brodowskifba395e2006-03-31 17:21:06 +020087static void bt3c_release(struct pcmcia_device *link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Dominik Brodowskicc3b4862005-11-14 21:23:14 +010089static void bt3c_detach(struct pcmcia_device *p_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92/* Transmit states */
93#define XMIT_SENDING 1
94#define XMIT_WAKEUP 2
95#define XMIT_WAITING 8
96
97/* Receiver states */
98#define RECV_WAIT_PACKET_TYPE 0
99#define RECV_WAIT_EVENT_HEADER 1
100#define RECV_WAIT_ACL_HEADER 2
101#define RECV_WAIT_SCO_HEADER 3
102#define RECV_WAIT_DATA 4
103
104
105
106/* ======================== Special I/O functions ======================== */
107
108
109#define DATA_L 0
110#define DATA_H 1
111#define ADDR_L 2
112#define ADDR_H 3
113#define CONTROL 4
114
115
116static inline void bt3c_address(unsigned int iobase, unsigned short addr)
117{
118 outb(addr & 0xff, iobase + ADDR_L);
119 outb((addr >> 8) & 0xff, iobase + ADDR_H);
120}
121
122
123static inline void bt3c_put(unsigned int iobase, unsigned short value)
124{
125 outb(value & 0xff, iobase + DATA_L);
126 outb((value >> 8) & 0xff, iobase + DATA_H);
127}
128
129
130static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
131{
132 bt3c_address(iobase, addr);
133 bt3c_put(iobase, value);
134}
135
136
137static inline unsigned short bt3c_get(unsigned int iobase)
138{
139 unsigned short value = inb(iobase + DATA_L);
140
141 value |= inb(iobase + DATA_H) << 8;
142
143 return value;
144}
145
146
147static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
148{
149 bt3c_address(iobase, addr);
150
151 return bt3c_get(iobase);
152}
153
154
155
156/* ======================== Interrupt handling ======================== */
157
158
159static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
160{
161 int actual = 0;
162
163 bt3c_address(iobase, 0x7080);
164
165 /* Fill FIFO with current frame */
166 while (actual < len) {
167 /* Transmit next byte */
168 bt3c_put(iobase, buf[actual]);
169 actual++;
170 }
171
172 bt3c_io_write(iobase, 0x7005, actual);
173
174 return actual;
175}
176
177
178static void bt3c_write_wakeup(bt3c_info_t *info)
179{
180 if (!info) {
181 BT_ERR("Unknown device");
182 return;
183 }
184
185 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
186 return;
187
188 do {
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200189 register unsigned int iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 register struct sk_buff *skb;
191 register int len;
192
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100193 if (!pcmcia_dev_present(info->p_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 break;
195
196
197 if (!(skb = skb_dequeue(&(info->txq)))) {
198 clear_bit(XMIT_SENDING, &(info->tx_state));
199 break;
200 }
201
202 /* Send frame */
203 len = bt3c_write(iobase, 256, skb->data, skb->len);
204
205 if (len != skb->len) {
206 BT_ERR("Very strange");
207 }
208
209 kfree_skb(skb);
210
211 info->hdev->stat.byte_tx += len;
212
213 } while (0);
214}
215
216
217static void bt3c_receive(bt3c_info_t *info)
218{
219 unsigned int iobase;
220 int size = 0, avail;
221
222 if (!info) {
223 BT_ERR("Unknown device");
224 return;
225 }
226
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200227 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
229 avail = bt3c_read(iobase, 0x7006);
230 //printk("bt3c_cs: receiving %d bytes\n", avail);
231
232 bt3c_address(iobase, 0x7480);
233 while (size < avail) {
234 size++;
235 info->hdev->stat.byte_rx++;
236
237 /* Allocate packet */
238 if (info->rx_skb == NULL) {
239 info->rx_state = RECV_WAIT_PACKET_TYPE;
240 info->rx_count = 0;
241 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
242 BT_ERR("Can't allocate mem for new packet");
243 return;
244 }
245 }
246
247
248 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
249
250 info->rx_skb->dev = (void *) info->hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700251 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 inb(iobase + DATA_H);
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700253 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700255 switch (bt_cb(info->rx_skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257 case HCI_EVENT_PKT:
258 info->rx_state = RECV_WAIT_EVENT_HEADER;
259 info->rx_count = HCI_EVENT_HDR_SIZE;
260 break;
261
262 case HCI_ACLDATA_PKT:
263 info->rx_state = RECV_WAIT_ACL_HEADER;
264 info->rx_count = HCI_ACL_HDR_SIZE;
265 break;
266
267 case HCI_SCODATA_PKT:
268 info->rx_state = RECV_WAIT_SCO_HEADER;
269 info->rx_count = HCI_SCO_HDR_SIZE;
270 break;
271
272 default:
273 /* Unknown packet */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700274 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 info->hdev->stat.err_rx++;
276 clear_bit(HCI_RUNNING, &(info->hdev->flags));
277
278 kfree_skb(info->rx_skb);
279 info->rx_skb = NULL;
280 break;
281
282 }
283
284 } else {
285
286 __u8 x = inb(iobase + DATA_L);
287
288 *skb_put(info->rx_skb, 1) = x;
289 inb(iobase + DATA_H);
290 info->rx_count--;
291
292 if (info->rx_count == 0) {
293
294 int dlen;
295 struct hci_event_hdr *eh;
296 struct hci_acl_hdr *ah;
297 struct hci_sco_hdr *sh;
298
299 switch (info->rx_state) {
300
301 case RECV_WAIT_EVENT_HEADER:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300302 eh = hci_event_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 info->rx_state = RECV_WAIT_DATA;
304 info->rx_count = eh->plen;
305 break;
306
307 case RECV_WAIT_ACL_HEADER:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300308 ah = hci_acl_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 dlen = __le16_to_cpu(ah->dlen);
310 info->rx_state = RECV_WAIT_DATA;
311 info->rx_count = dlen;
312 break;
313
314 case RECV_WAIT_SCO_HEADER:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300315 sh = hci_sco_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 info->rx_state = RECV_WAIT_DATA;
317 info->rx_count = sh->dlen;
318 break;
319
320 case RECV_WAIT_DATA:
321 hci_recv_frame(info->rx_skb);
322 info->rx_skb = NULL;
323 break;
324
325 }
326
327 }
328
329 }
330
331 }
332
333 bt3c_io_write(iobase, 0x7006, 0x0000);
334}
335
336
David Howells7d12e782006-10-05 14:55:46 +0100337static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
339 bt3c_info_t *info = dev_inst;
340 unsigned int iobase;
341 int iir;
Alan Coxaafcf992008-10-05 17:35:41 +0100342 irqreturn_t r = IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
Mike Frysinger74278472009-09-14 13:43:49 -0400344 if (!info || !info->hdev)
345 /* our irq handler is shared */
346 return IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200348 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
350 spin_lock(&(info->lock));
351
352 iir = inb(iobase + CONTROL);
353 if (iir & 0x80) {
354 int stat = bt3c_read(iobase, 0x7001);
355
356 if ((stat & 0xff) == 0x7f) {
357 BT_ERR("Very strange (stat=0x%04x)", stat);
358 } else if ((stat & 0xff) != 0xff) {
359 if (stat & 0x0020) {
Andre Haupt34a55ed2009-02-02 14:45:11 -0800360 int status = bt3c_read(iobase, 0x7002) & 0x10;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 BT_INFO("%s: Antenna %s", info->hdev->name,
Andre Haupt34a55ed2009-02-02 14:45:11 -0800362 status ? "out" : "in");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 }
364 if (stat & 0x0001)
365 bt3c_receive(info);
366 if (stat & 0x0002) {
367 //BT_ERR("Ack (stat=0x%04x)", stat);
368 clear_bit(XMIT_SENDING, &(info->tx_state));
369 bt3c_write_wakeup(info);
370 }
371
372 bt3c_io_write(iobase, 0x7001, 0x0000);
373
374 outb(iir, iobase + CONTROL);
375 }
Alan Coxaafcf992008-10-05 17:35:41 +0100376 r = IRQ_HANDLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 }
378
379 spin_unlock(&(info->lock));
380
Alan Coxaafcf992008-10-05 17:35:41 +0100381 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382}
383
384
385
386/* ======================== HCI interface ======================== */
387
388
389static int bt3c_hci_flush(struct hci_dev *hdev)
390{
David Herrmann155961e2012-02-09 21:58:32 +0100391 bt3c_info_t *info = hci_get_drvdata(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
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
David Herrmann155961e2012-02-09 21:58:32 +0100430 info = hci_get_drvdata(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
459{
460 return -ENOIOCTLCMD;
461}
462
463
464
465/* ======================== Card services HCI interaction ======================== */
466
467
David Woodhouse8187b4f2008-05-23 23:56:51 +0100468static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
469 int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470{
471 char *ptr = (char *) firmware;
472 char b[9];
473 unsigned int iobase, size, addr, fcs, tmp;
474 int i, err = 0;
475
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200476 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
478 /* Reset */
479 bt3c_io_write(iobase, 0x8040, 0x0404);
480 bt3c_io_write(iobase, 0x8040, 0x0400);
481
482 udelay(1);
483
484 bt3c_io_write(iobase, 0x8040, 0x0404);
485
486 udelay(17);
487
488 /* Load */
489 while (count) {
490 if (ptr[0] != 'S') {
491 BT_ERR("Bad address in firmware");
492 err = -EFAULT;
493 goto error;
494 }
495
496 memset(b, 0, sizeof(b));
497 memcpy(b, ptr + 2, 2);
Julia Lawall51a6fbc2008-11-30 12:17:20 +0100498 size = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
500 memset(b, 0, sizeof(b));
501 memcpy(b, ptr + 4, 8);
Julia Lawall51a6fbc2008-11-30 12:17:20 +0100502 addr = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 memset(b, 0, sizeof(b));
505 memcpy(b, ptr + (size * 2) + 2, 2);
Julia Lawall51a6fbc2008-11-30 12:17:20 +0100506 fcs = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
508 memset(b, 0, sizeof(b));
509 for (tmp = 0, i = 0; i < size; i++) {
510 memcpy(b, ptr + (i * 2) + 2, 2);
511 tmp += simple_strtol(b, NULL, 16);
512 }
513
514 if (((tmp + fcs) & 0xff) != 0xff) {
515 BT_ERR("Checksum error in firmware");
516 err = -EILSEQ;
517 goto error;
518 }
519
520 if (ptr[1] == '3') {
521 bt3c_address(iobase, addr);
522
523 memset(b, 0, sizeof(b));
524 for (i = 0; i < (size - 4) / 2; i++) {
525 memcpy(b, ptr + (i * 4) + 12, 4);
Julia Lawall51a6fbc2008-11-30 12:17:20 +0100526 tmp = simple_strtoul(b, NULL, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 bt3c_put(iobase, tmp);
528 }
529 }
530
531 ptr += (size * 2) + 6;
532 count -= (size * 2) + 6;
533 }
534
535 udelay(17);
536
537 /* Boot */
538 bt3c_address(iobase, 0x3000);
539 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
540
541error:
542 udelay(17);
543
544 /* Clear */
545 bt3c_io_write(iobase, 0x7006, 0x0000);
546 bt3c_io_write(iobase, 0x7005, 0x0000);
547 bt3c_io_write(iobase, 0x7001, 0x0000);
548
549 return err;
550}
551
552
553static int bt3c_open(bt3c_info_t *info)
554{
555 const struct firmware *firmware;
556 struct hci_dev *hdev;
557 int err;
558
559 spin_lock_init(&(info->lock));
560
561 skb_queue_head_init(&(info->txq));
562
563 info->rx_state = RECV_WAIT_PACKET_TYPE;
564 info->rx_count = 0;
565 info->rx_skb = NULL;
566
567 /* Initialize HCI device */
568 hdev = hci_alloc_dev();
569 if (!hdev) {
570 BT_ERR("Can't allocate HCI device");
571 return -ENOMEM;
572 }
573
574 info->hdev = hdev;
575
Marcel Holtmannc13854c2010-02-08 15:27:07 +0100576 hdev->bus = HCI_PCCARD;
David Herrmann155961e2012-02-09 21:58:32 +0100577 hci_set_drvdata(hdev, info);
Marcel Holtmann27d35282006-07-03 10:02:37 +0200578 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 hdev->open = bt3c_hci_open;
581 hdev->close = bt3c_hci_close;
582 hdev->flush = bt3c_hci_flush;
583 hdev->send = bt3c_hci_send_frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 hdev->ioctl = bt3c_hci_ioctl;
585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 /* Load firmware */
Dominik Brodowskifd238232006-03-05 10:45:09 +0100587 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 if (err < 0) {
589 BT_ERR("Firmware request failed");
590 goto error;
591 }
592
593 err = bt3c_load_firmware(info, firmware->data, firmware->size);
594
595 release_firmware(firmware);
596
597 if (err < 0) {
598 BT_ERR("Firmware loading failed");
599 goto error;
600 }
601
602 /* Timeout before it is safe to send the first HCI packet */
603 msleep(1000);
604
605 /* Register HCI device */
606 err = hci_register_dev(hdev);
607 if (err < 0) {
608 BT_ERR("Can't register HCI device");
609 goto error;
610 }
611
612 return 0;
613
614error:
615 info->hdev = NULL;
616 hci_free_dev(hdev);
617 return err;
618}
619
620
621static int bt3c_close(bt3c_info_t *info)
622{
623 struct hci_dev *hdev = info->hdev;
624
625 if (!hdev)
626 return -ENODEV;
627
628 bt3c_hci_close(hdev);
629
David Herrmann13ea4012011-10-26 10:43:18 +0200630 hci_unregister_dev(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 hci_free_dev(hdev);
632
633 return 0;
634}
635
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200636static int bt3c_probe(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637{
638 bt3c_info_t *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
640 /* Create new info device */
Deepak Saxena089b1db2005-11-07 01:01:26 -0800641 info = kzalloc(sizeof(*info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 if (!info)
Dominik Brodowskif8cfa612005-11-14 21:25:51 +0100643 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200645 info->p_dev = link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 link->priv = info;
647
Dominik Brodowski00990e72010-07-30 13:13:46 +0200648 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
649 CONF_AUTO_SET_IO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200651 return bt3c_config(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652}
653
654
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200655static void bt3c_detach(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656{
657 bt3c_info_t *info = link->priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100659 bt3c_release(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 kfree(info);
661}
662
Dominik Brodowski00990e72010-07-30 13:13:46 +0200663static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664{
Dominik Brodowski00990e72010-07-30 13:13:46 +0200665 int *try = priv_data;
Dominik Brodowski90abdc32010-07-24 17:23:51 +0200666
Dominik Brodowski00990e72010-07-30 13:13:46 +0200667 if (try == 0)
668 p_dev->io_lines = 16;
669
670 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
671 return -EINVAL;
672
673 p_dev->resource[0]->end = 8;
674 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
675 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
676
677 return pcmcia_request_io(p_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678}
679
Dominik Brodowskied588722008-07-29 08:38:55 +0200680static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
Dominik Brodowskied588722008-07-29 08:38:55 +0200681 void *priv_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682{
Dominik Brodowskied588722008-07-29 08:38:55 +0200683 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
684 int j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
Dominik Brodowski00990e72010-07-30 13:13:46 +0200686 if (p_dev->io_lines > 3)
687 return -ENODEV;
688
689 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
690 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
691 p_dev->resource[0]->end = 8;
692
693 for (j = 0; j < 5; j++) {
694 p_dev->resource[0]->start = base[j];
695 p_dev->io_lines = base[j] ? 16 : 3;
696 if (!pcmcia_request_io(p_dev))
697 return 0;
Dominik Brodowskied588722008-07-29 08:38:55 +0200698 }
699 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700}
701
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200702static int bt3c_config(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 bt3c_info_t *info = link->priv;
Dominik Brodowskied588722008-07-29 08:38:55 +0200705 int i;
706 unsigned long try;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Dominik Brodowskied588722008-07-29 08:38:55 +0200708 /* First pass: look for a config entry that looks normal.
709 Two tries: without IO aliases, then with aliases */
710 for (try = 0; try < 2; try++)
711 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
712 goto found_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713
714 /* Second pass: try to find an entry that isn't picky about
715 its base address, then try to grab any standard serial port
716 address, and finally try to get any free port. */
Dominik Brodowskied588722008-07-29 08:38:55 +0200717 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
718 goto found_port;
719
720 BT_ERR("No usable port range found");
Dominik Brodowskied588722008-07-29 08:38:55 +0200721 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
723found_port:
Dominik Brodowskieb141202010-03-07 12:21:16 +0100724 i = pcmcia_request_irq(link, &bt3c_interrupt);
Dominik Brodowski9ac3e582009-10-24 15:45:06 +0200725 if (i != 0)
Dominik Brodowskieb141202010-03-07 12:21:16 +0100726 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
Dominik Brodowski1ac71e52010-07-29 19:27:09 +0200728 i = pcmcia_enable_device(link);
Dominik Brodowski9ac3e582009-10-24 15:45:06 +0200729 if (i != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
732 if (bt3c_open(info) != 0)
733 goto failed;
734
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200735 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737failed:
738 bt3c_release(link);
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200739 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740}
741
742
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200743static void bt3c_release(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744{
745 bt3c_info_t *info = link->priv;
746
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100747 bt3c_close(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200749 pcmcia_disable_device(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750}
751
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752
Joe Perches25f8f542011-05-03 19:29:01 -0700753static const struct pcmcia_device_id bt3c_ids[] = {
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700754 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
755 PCMCIA_DEVICE_NULL
756};
757MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759static struct pcmcia_driver bt3c_driver = {
760 .owner = THIS_MODULE,
Dominik Brodowski2e9b9812010-08-08 11:36:26 +0200761 .name = "bt3c_cs",
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200762 .probe = bt3c_probe,
Dominik Brodowskicc3b4862005-11-14 21:23:14 +0100763 .remove = bt3c_detach,
Dominik Brodowskia01c3ed2005-06-27 16:28:37 -0700764 .id_table = bt3c_ids,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765};
766
767static int __init init_bt3c_cs(void)
768{
769 return pcmcia_register_driver(&bt3c_driver);
770}
771
772
773static void __exit exit_bt3c_cs(void)
774{
775 pcmcia_unregister_driver(&bt3c_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776}
777
778module_init(init_bt3c_cs);
779module_exit(exit_bt3c_cs);