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/system.h>
43#include <asm/io.h>
44
45#include <linux/device.h>
46#include <linux/firmware.h>
47
48#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
59
60
61MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
62MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
63MODULE_LICENSE("GPL");
64MODULE_FIRMWARE("BT3CPCC.bin");
65
66
67
68
69
70
71typedef struct bt3c_info_t {
72 struct pcmcia_device *p_dev;
73
74 struct hci_dev *hdev;
75
76 spinlock_t lock;
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
87static int bt3c_config(struct pcmcia_device *link);
88static void bt3c_release(struct pcmcia_device *link);
89
90static void bt3c_detach(struct pcmcia_device *p_dev);
91
92
93
94#define XMIT_SENDING 1
95#define XMIT_WAKEUP 2
96#define XMIT_WAITING 8
97
98
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
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
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
167 while (actual < len) {
168
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 {
190 register unsigned int iobase = info->p_dev->resource[0]->start;
191 register struct sk_buff *skb;
192 register int len;
193
194 if (!pcmcia_dev_present(info->p_dev))
195 break;
196
197
198 if (!(skb = skb_dequeue(&(info->txq)))) {
199 clear_bit(XMIT_SENDING, &(info->tx_state));
200 break;
201 }
202
203
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
228 iobase = info->p_dev->resource[0]->start;
229
230 avail = bt3c_read(iobase, 0x7006);
231
232
233 bt3c_address(iobase, 0x7480);
234 while (size < avail) {
235 size++;
236 info->hdev->stat.byte_rx++;
237
238
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;
252 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
253 inb(iobase + DATA_H);
254
255
256 switch (bt_cb(info->rx_skb)->pkt_type) {
257
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
275 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
276 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:
303 eh = hci_event_hdr(info->rx_skb);
304 info->rx_state = RECV_WAIT_DATA;
305 info->rx_count = eh->plen;
306 break;
307
308 case RECV_WAIT_ACL_HEADER:
309 ah = hci_acl_hdr(info->rx_skb);
310 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:
316 sh = hci_sco_hdr(info->rx_skb);
317 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
338static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
339{
340 bt3c_info_t *info = dev_inst;
341 unsigned int iobase;
342 int iir;
343 irqreturn_t r = IRQ_NONE;
344
345 if (!info || !info->hdev)
346
347 return IRQ_NONE;
348
349 iobase = info->p_dev->resource[0]->start;
350
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) {
361 int status = bt3c_read(iobase, 0x7002) & 0x10;
362 BT_INFO("%s: Antenna %s", info->hdev->name,
363 status ? "out" : "in");
364 }
365 if (stat & 0x0001)
366 bt3c_receive(info);
367 if (stat & 0x0002) {
368
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 }
377 r = IRQ_HANDLED;
378 }
379
380 spin_unlock(&(info->lock));
381
382 return r;
383}
384
385
386
387
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
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
433 switch (bt_cb(skb)->pkt_type) {
434 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
446 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
447 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
472
473
474static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
475 int count)
476{
477 char *ptr = (char *) firmware;
478 char b[9];
479 unsigned int iobase, size, addr, fcs, tmp;
480 int i, err = 0;
481
482 iobase = info->p_dev->resource[0]->start;
483
484
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
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);
504 size = simple_strtoul(b, NULL, 16);
505
506 memset(b, 0, sizeof(b));
507 memcpy(b, ptr + 4, 8);
508 addr = simple_strtoul(b, NULL, 16);
509
510 memset(b, 0, sizeof(b));
511 memcpy(b, ptr + (size * 2) + 2, 2);
512 fcs = simple_strtoul(b, NULL, 16);
513
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);
532 tmp = simple_strtoul(b, NULL, 16);
533 bt3c_put(iobase, tmp);
534 }
535 }
536
537 ptr += (size * 2) + 6;
538 count -= (size * 2) + 6;
539 }
540
541 udelay(17);
542
543
544 bt3c_address(iobase, 0x3000);
545 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
546
547error:
548 udelay(17);
549
550
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
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
582 hdev->bus = HCI_PCCARD;
583 hdev->driver_data = info;
584 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
585
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
596 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
597 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
612 msleep(1000);
613
614
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
647static int bt3c_probe(struct pcmcia_device *link)
648{
649 bt3c_info_t *info;
650
651
652 info = kzalloc(sizeof(*info), GFP_KERNEL);
653 if (!info)
654 return -ENOMEM;
655
656 info->p_dev = link;
657 link->priv = info;
658
659 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
660 CONF_AUTO_SET_IO;
661
662 return bt3c_config(link);
663}
664
665
666static void bt3c_detach(struct pcmcia_device *link)
667{
668 bt3c_info_t *info = link->priv;
669
670 bt3c_release(link);
671 kfree(info);
672}
673
674static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
675{
676 int *try = priv_data;
677
678 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);
689}
690
691static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
692 void *priv_data)
693{
694 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
695 int j;
696
697 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;
709 }
710 return -ENODEV;
711}
712
713static int bt3c_config(struct pcmcia_device *link)
714{
715 bt3c_info_t *info = link->priv;
716 int i;
717 unsigned long try;
718
719
720
721 for (try = 0; try < 2; try++)
722 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
723 goto found_port;
724
725
726
727
728 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
729 goto found_port;
730
731 BT_ERR("No usable port range found");
732 goto failed;
733
734found_port:
735 i = pcmcia_request_irq(link, &bt3c_interrupt);
736 if (i != 0)
737 goto failed;
738
739 i = pcmcia_enable_device(link);
740 if (i != 0)
741 goto failed;
742
743 if (bt3c_open(info) != 0)
744 goto failed;
745
746 return 0;
747
748failed:
749 bt3c_release(link);
750 return -ENODEV;
751}
752
753
754static void bt3c_release(struct pcmcia_device *link)
755{
756 bt3c_info_t *info = link->priv;
757
758 bt3c_close(info);
759
760 pcmcia_disable_device(link);
761}
762
763
764static struct pcmcia_device_id bt3c_ids[] = {
765 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
766 PCMCIA_DEVICE_NULL
767};
768MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
769
770static struct pcmcia_driver bt3c_driver = {
771 .owner = THIS_MODULE,
772 .name = "bt3c_cs",
773 .probe = bt3c_probe,
774 .remove = bt3c_detach,
775 .id_table = bt3c_ids,
776};
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);
787}
788
789module_init(init_bt3c_cs);
790module_exit(exit_bt3c_cs);
791
