1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#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>
30#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/io.h>
43
44#include <linux/device.h>
45#include <linux/firmware.h>
46
47#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
58
59
60MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
61MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
62MODULE_LICENSE("GPL");
63MODULE_FIRMWARE("BT3CPCC.bin");
64
65
66
67
68
69
70typedef struct bt3c_info_t {
71 struct pcmcia_device *p_dev;
72
73 struct hci_dev *hdev;
74
75 spinlock_t lock;
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
86static int bt3c_config(struct pcmcia_device *link);
87static void bt3c_release(struct pcmcia_device *link);
88
89static void bt3c_detach(struct pcmcia_device *p_dev);
90
91
92
93#define XMIT_SENDING 1
94#define XMIT_WAKEUP 2
95#define XMIT_WAITING 8
96
97
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
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
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
166 while (actual < len) {
167
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 {
189 unsigned int iobase = info->p_dev->resource[0]->start;
190 register struct sk_buff *skb;
191 int len;
192
193 if (!pcmcia_dev_present(info->p_dev))
194 break;
195
196
197 if (!(skb = skb_dequeue(&(info->txq)))) {
198 clear_bit(XMIT_SENDING, &(info->tx_state));
199 break;
200 }
201
202
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
227 iobase = info->p_dev->resource[0]->start;
228
229 avail = bt3c_read(iobase, 0x7006);
230
231
232 bt3c_address(iobase, 0x7480);
233 while (size < avail) {
234 size++;
235 info->hdev->stat.byte_rx++;
236
237
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;
251 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
252 inb(iobase + DATA_H);
253
254
255 switch (bt_cb(info->rx_skb)->pkt_type) {
256
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
274 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
275 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:
302 eh = hci_event_hdr(info->rx_skb);
303 info->rx_state = RECV_WAIT_DATA;
304 info->rx_count = eh->plen;
305 break;
306
307 case RECV_WAIT_ACL_HEADER:
308 ah = hci_acl_hdr(info->rx_skb);
309 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:
315 sh = hci_sco_hdr(info->rx_skb);
316 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
337static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
338{
339 bt3c_info_t *info = dev_inst;
340 unsigned int iobase;
341 int iir;
342 irqreturn_t r = IRQ_NONE;
343
344 if (!info || !info->hdev)
345
346 return IRQ_NONE;
347
348 iobase = info->p_dev->resource[0]->start;
349
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) {
360 int status = bt3c_read(iobase, 0x7002) & 0x10;
361 BT_INFO("%s: Antenna %s", info->hdev->name,
362 status ? "out" : "in");
363 }
364 if (stat & 0x0001)
365 bt3c_receive(info);
366 if (stat & 0x0002) {
367
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 }
376 r = IRQ_HANDLED;
377 }
378
379 spin_unlock(&(info->lock));
380
381 return r;
382}
383
384
385
386
387
388
389static int bt3c_hci_flush(struct hci_dev *hdev)
390{
391 bt3c_info_t *info = hci_get_drvdata(hdev);
392
393
394 skb_queue_purge(&(info->txq));
395
396 return 0;
397}
398
399
400static int bt3c_hci_open(struct hci_dev *hdev)
401{
402 set_bit(HCI_RUNNING, &(hdev->flags));
403
404 return 0;
405}
406
407
408static int bt3c_hci_close(struct hci_dev *hdev)
409{
410 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
411 return 0;
412
413 bt3c_hci_flush(hdev);
414
415 return 0;
416}
417
418
419static int bt3c_hci_send_frame(struct sk_buff *skb)
420{
421 bt3c_info_t *info;
422 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
423 unsigned long flags;
424
425 if (!hdev) {
426 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
427 return -ENODEV;
428 }
429
430 info = hci_get_drvdata(hdev);
431
432 switch (bt_cb(skb)->pkt_type) {
433 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
445 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
446 skb_queue_tail(&(info->txq), skb);
447
448 spin_lock_irqsave(&(info->lock), flags);
449
450 bt3c_write_wakeup(info);
451
452 spin_unlock_irqrestore(&(info->lock), flags);
453
454 return 0;
455}
456
457
458static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
459{
460 return -ENOIOCTLCMD;
461}
462
463
464
465
466
467
468static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
469 int count)
470{
471 char *ptr = (char *) firmware;
472 char b[9];
473 unsigned int iobase, size, addr, fcs, tmp;
474 int i, err = 0;
475
476 iobase = info->p_dev->resource[0]->start;
477
478
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
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);
498 size = simple_strtoul(b, NULL, 16);
499
500 memset(b, 0, sizeof(b));
501 memcpy(b, ptr + 4, 8);
502 addr = simple_strtoul(b, NULL, 16);
503
504 memset(b, 0, sizeof(b));
505 memcpy(b, ptr + (size * 2) + 2, 2);
506 fcs = simple_strtoul(b, NULL, 16);
507
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);
526 tmp = simple_strtoul(b, NULL, 16);
527 bt3c_put(iobase, tmp);
528 }
529 }
530
531 ptr += (size * 2) + 6;
532 count -= (size * 2) + 6;
533 }
534
535 udelay(17);
536
537
538 bt3c_address(iobase, 0x3000);
539 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
540
541error:
542 udelay(17);
543
544
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
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
576 hdev->bus = HCI_PCCARD;
577 hci_set_drvdata(hdev, info);
578 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
579
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;
584 hdev->ioctl = bt3c_hci_ioctl;
585
586
587 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
588 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
603 msleep(1000);
604
605
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
630 hci_unregister_dev(hdev);
631 hci_free_dev(hdev);
632
633 return 0;
634}
635
636static int bt3c_probe(struct pcmcia_device *link)
637{
638 bt3c_info_t *info;
639
640
641 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
642 if (!info)
643 return -ENOMEM;
644
645 info->p_dev = link;
646 link->priv = info;
647
648 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
649 CONF_AUTO_SET_IO;
650
651 return bt3c_config(link);
652}
653
654
655static void bt3c_detach(struct pcmcia_device *link)
656{
657 bt3c_release(link);
658}
659
660static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
661{
662 int *try = priv_data;
663
664 if (!try)
665 p_dev->io_lines = 16;
666
667 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
668 return -EINVAL;
669
670 p_dev->resource[0]->end = 8;
671 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
672 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
673
674 return pcmcia_request_io(p_dev);
675}
676
677static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
678 void *priv_data)
679{
680 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
681 int j;
682
683 if (p_dev->io_lines > 3)
684 return -ENODEV;
685
686 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
687 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
688 p_dev->resource[0]->end = 8;
689
690 for (j = 0; j < 5; j++) {
691 p_dev->resource[0]->start = base[j];
692 p_dev->io_lines = base[j] ? 16 : 3;
693 if (!pcmcia_request_io(p_dev))
694 return 0;
695 }
696 return -ENODEV;
697}
698
699static int bt3c_config(struct pcmcia_device *link)
700{
701 bt3c_info_t *info = link->priv;
702 int i;
703 unsigned long try;
704
705
706
707 for (try = 0; try < 2; try++)
708 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
709 goto found_port;
710
711
712
713
714 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
715 goto found_port;
716
717 BT_ERR("No usable port range found");
718 goto failed;
719
720found_port:
721 i = pcmcia_request_irq(link, &bt3c_interrupt);
722 if (i != 0)
723 goto failed;
724
725 i = pcmcia_enable_device(link);
726 if (i != 0)
727 goto failed;
728
729 if (bt3c_open(info) != 0)
730 goto failed;
731
732 return 0;
733
734failed:
735 bt3c_release(link);
736 return -ENODEV;
737}
738
739
740static void bt3c_release(struct pcmcia_device *link)
741{
742 bt3c_info_t *info = link->priv;
743
744 bt3c_close(info);
745
746 pcmcia_disable_device(link);
747}
748
749
750static const struct pcmcia_device_id bt3c_ids[] = {
751 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
752 PCMCIA_DEVICE_NULL
753};
754MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
755
756static struct pcmcia_driver bt3c_driver = {
757 .owner = THIS_MODULE,
758 .name = "bt3c_cs",
759 .probe = bt3c_probe,
760 .remove = bt3c_detach,
761 .id_table = bt3c_ids,
762};
763module_pcmcia_driver(bt3c_driver);
764
