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/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
61
62
63MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
64MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
65MODULE_LICENSE("GPL");
66MODULE_FIRMWARE("BT3CPCC.bin");
67
68
69
70
71
72
73typedef struct bt3c_info_t {
74 struct pcmcia_device *p_dev;
75 dev_node_t node;
76
77 struct hci_dev *hdev;
78
79 spinlock_t lock;
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
90static int bt3c_config(struct pcmcia_device *link);
91static void bt3c_release(struct pcmcia_device *link);
92
93static void bt3c_detach(struct pcmcia_device *p_dev);
94
95
96
97#define XMIT_SENDING 1
98#define XMIT_WAKEUP 2
99#define XMIT_WAITING 8
100
101
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
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
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
170 while (actual < len) {
171
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 {
193 register unsigned int iobase = info->p_dev->io.BasePort1;
194 register struct sk_buff *skb;
195 register int len;
196
197 if (!pcmcia_dev_present(info->p_dev))
198 break;
199
200
201 if (!(skb = skb_dequeue(&(info->txq)))) {
202 clear_bit(XMIT_SENDING, &(info->tx_state));
203 break;
204 }
205
206
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
231 iobase = info->p_dev->io.BasePort1;
232
233 avail = bt3c_read(iobase, 0x7006);
234
235
236 bt3c_address(iobase, 0x7480);
237 while (size < avail) {
238 size++;
239 info->hdev->stat.byte_rx++;
240
241
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;
255 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
256 inb(iobase + DATA_H);
257
258
259 switch (bt_cb(info->rx_skb)->pkt_type) {
260
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
278 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
279 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:
306 eh = hci_event_hdr(info->rx_skb);
307 info->rx_state = RECV_WAIT_DATA;
308 info->rx_count = eh->plen;
309 break;
310
311 case RECV_WAIT_ACL_HEADER:
312 ah = hci_acl_hdr(info->rx_skb);
313 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:
319 sh = hci_sco_hdr(info->rx_skb);
320 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
341static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
342{
343 bt3c_info_t *info = dev_inst;
344 unsigned int iobase;
345 int iir;
346 irqreturn_t r = IRQ_NONE;
347
348 BUG_ON(!info->hdev);
349
350 iobase = info->p_dev->io.BasePort1;
351
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) {
362 int status = bt3c_read(iobase, 0x7002) & 0x10;
363 BT_INFO("%s: Antenna %s", info->hdev->name,
364 status ? "out" : "in");
365 }
366 if (stat & 0x0001)
367 bt3c_receive(info);
368 if (stat & 0x0002) {
369
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 }
378 r = IRQ_HANDLED;
379 }
380
381 spin_unlock(&(info->lock));
382
383 return r;
384}
385
386
387
388
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
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
434 switch (bt_cb(skb)->pkt_type) {
435 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
447 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
448 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
473
474
475static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
476 int count)
477{
478 char *ptr = (char *) firmware;
479 char b[9];
480 unsigned int iobase, size, addr, fcs, tmp;
481 int i, err = 0;
482
483 iobase = info->p_dev->io.BasePort1;
484
485
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
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);
505 size = simple_strtoul(b, NULL, 16);
506
507 memset(b, 0, sizeof(b));
508 memcpy(b, ptr + 4, 8);
509 addr = simple_strtoul(b, NULL, 16);
510
511 memset(b, 0, sizeof(b));
512 memcpy(b, ptr + (size * 2) + 2, 2);
513 fcs = simple_strtoul(b, NULL, 16);
514
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);
533 tmp = simple_strtoul(b, NULL, 16);
534 bt3c_put(iobase, tmp);
535 }
536 }
537
538 ptr += (size * 2) + 6;
539 count -= (size * 2) + 6;
540 }
541
542 udelay(17);
543
544
545 bt3c_address(iobase, 0x3000);
546 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
547
548error:
549 udelay(17);
550
551
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
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;
585 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
586
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
597 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
598 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
613 msleep(1000);
614
615
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
648static int bt3c_probe(struct pcmcia_device *link)
649{
650 bt3c_info_t *info;
651
652
653 info = kzalloc(sizeof(*info), GFP_KERNEL);
654 if (!info)
655 return -ENOMEM;
656
657 info->p_dev = link;
658 link->priv = info;
659
660 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
661 link->io.NumPorts1 = 8;
662 link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT;
663 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;
669 link->conf.IntType = INT_MEMORY_AND_IO;
670
671 return bt3c_config(link);
672}
673
674
675static void bt3c_detach(struct pcmcia_device *link)
676{
677 bt3c_info_t *info = link->priv;
678
679 bt3c_release(link);
680 kfree(info);
681}
682
683static int bt3c_check_config(struct pcmcia_device *p_dev,
684 cistpl_cftable_entry_t *cf,
685 cistpl_cftable_entry_t *dflt,
686 unsigned int vcc,
687 void *priv_data)
688{
689 unsigned long try = (unsigned long) priv_data;
690
691 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)) {
695 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;
702}
703
704static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
705 cistpl_cftable_entry_t *cf,
706 cistpl_cftable_entry_t *dflt,
707 unsigned int vcc,
708 void *priv_data)
709{
710 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
711 int j;
712
713 if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
714 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;
722}
723
724static int bt3c_config(struct pcmcia_device *link)
725{
726 bt3c_info_t *info = link->priv;
727 int i;
728 unsigned long try;
729
730
731
732 for (try = 0; try < 2; try++)
733 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
734 goto found_port;
735
736
737
738
739 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;
745
746found_port:
747 i = pcmcia_request_irq(link, &link->irq);
748 if (i != 0) {
749 cs_error(link, RequestIRQ, i);
750 link->irq.AssignedIRQ = 0;
751 }
752
753 i = pcmcia_request_configuration(link, &link->conf);
754 if (i != 0) {
755 cs_error(link, RequestConfiguration, i);
756 goto failed;
757 }
758
759 if (bt3c_open(info) != 0)
760 goto failed;
761
762 strcpy(info->node.dev_name, info->hdev->name);
763 link->dev_node = &info->node;
764
765 return 0;
766
767failed:
768 bt3c_release(link);
769 return -ENODEV;
770}
771
772
773static void bt3c_release(struct pcmcia_device *link)
774{
775 bt3c_info_t *info = link->priv;
776
777 bt3c_close(info);
778
779 pcmcia_disable_device(link);
780}
781
782
783static 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
789static struct pcmcia_driver bt3c_driver = {
790 .owner = THIS_MODULE,
791 .drv = {
792 .name = "bt3c_cs",
793 },
794 .probe = bt3c_probe,
795 .remove = bt3c_detach,
796 .id_table = bt3c_ids,
797};
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);
808}
809
810module_init(init_bt3c_cs);
811module_exit(exit_bt3c_cs);
812
