Loading...
1/*
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
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/* ======================== Module parameters ======================== */
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/* ======================== Local structures ======================== */
69
70
71typedef struct bt3c_info_t {
72 struct pcmcia_device *p_dev;
73
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
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/* 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 {
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 /* 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
228 iobase = info->p_dev->resource[0]->start;
229
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;
252 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
253 inb(iobase + DATA_H);
254 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
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 /* Unknown packet */
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 /* our irq handler is shared */
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 //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 }
377 r = IRQ_HANDLED;
378 }
379
380 spin_unlock(&(info->lock));
381
382 return r;
383}
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
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 /* Prepend skb with frame type */
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/* ======================== Card services HCI interaction ======================== */
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 /* 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);
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 /* 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
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 /* Load firmware */
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 /* 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
647static int bt3c_probe(struct pcmcia_device *link)
648{
649 bt3c_info_t *info;
650
651 /* Create new info device */
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 /* 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;
724
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. */
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 const 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);
1/*
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
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/* ======================== Module parameters ======================== */
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/* ======================== Local structures ======================== */
68
69
70typedef struct bt3c_info_t {
71 struct pcmcia_device *p_dev;
72
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
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/* 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 {
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 skb = skb_dequeue(&(info->txq));
197 if (!skb) {
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
227 iobase = info->p_dev->resource[0]->start;
228
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 info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
242 if (!info->rx_skb) {
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 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
252 inb(iobase + DATA_H);
253 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
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 /* Unknown packet */
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->hdev, 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 /* our irq handler is shared */
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 //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 }
376 r = IRQ_HANDLED;
377 }
378
379 spin_unlock(&(info->lock));
380
381 return r;
382}
383
384
385
386/* ======================== HCI interface ======================== */
387
388
389static int bt3c_hci_flush(struct hci_dev *hdev)
390{
391 bt3c_info_t *info = hci_get_drvdata(hdev);
392
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 hci_dev *hdev, struct sk_buff *skb)
420{
421 bt3c_info_t *info = hci_get_drvdata(hdev);
422 unsigned long flags;
423
424 switch (bt_cb(skb)->pkt_type) {
425 case HCI_COMMAND_PKT:
426 hdev->stat.cmd_tx++;
427 break;
428 case HCI_ACLDATA_PKT:
429 hdev->stat.acl_tx++;
430 break;
431 case HCI_SCODATA_PKT:
432 hdev->stat.sco_tx++;
433 break;
434 };
435
436 /* Prepend skb with frame type */
437 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
438 skb_queue_tail(&(info->txq), skb);
439
440 spin_lock_irqsave(&(info->lock), flags);
441
442 bt3c_write_wakeup(info);
443
444 spin_unlock_irqrestore(&(info->lock), flags);
445
446 return 0;
447}
448
449
450
451/* ======================== Card services HCI interaction ======================== */
452
453
454static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
455 int count)
456{
457 char *ptr = (char *) firmware;
458 char b[9];
459 unsigned int iobase, size, addr, fcs, tmp;
460 int i, err = 0;
461
462 iobase = info->p_dev->resource[0]->start;
463
464 /* Reset */
465 bt3c_io_write(iobase, 0x8040, 0x0404);
466 bt3c_io_write(iobase, 0x8040, 0x0400);
467
468 udelay(1);
469
470 bt3c_io_write(iobase, 0x8040, 0x0404);
471
472 udelay(17);
473
474 /* Load */
475 while (count) {
476 if (ptr[0] != 'S') {
477 BT_ERR("Bad address in firmware");
478 err = -EFAULT;
479 goto error;
480 }
481
482 memset(b, 0, sizeof(b));
483 memcpy(b, ptr + 2, 2);
484 size = simple_strtoul(b, NULL, 16);
485
486 memset(b, 0, sizeof(b));
487 memcpy(b, ptr + 4, 8);
488 addr = simple_strtoul(b, NULL, 16);
489
490 memset(b, 0, sizeof(b));
491 memcpy(b, ptr + (size * 2) + 2, 2);
492 fcs = simple_strtoul(b, NULL, 16);
493
494 memset(b, 0, sizeof(b));
495 for (tmp = 0, i = 0; i < size; i++) {
496 memcpy(b, ptr + (i * 2) + 2, 2);
497 tmp += simple_strtol(b, NULL, 16);
498 }
499
500 if (((tmp + fcs) & 0xff) != 0xff) {
501 BT_ERR("Checksum error in firmware");
502 err = -EILSEQ;
503 goto error;
504 }
505
506 if (ptr[1] == '3') {
507 bt3c_address(iobase, addr);
508
509 memset(b, 0, sizeof(b));
510 for (i = 0; i < (size - 4) / 2; i++) {
511 memcpy(b, ptr + (i * 4) + 12, 4);
512 tmp = simple_strtoul(b, NULL, 16);
513 bt3c_put(iobase, tmp);
514 }
515 }
516
517 ptr += (size * 2) + 6;
518 count -= (size * 2) + 6;
519 }
520
521 udelay(17);
522
523 /* Boot */
524 bt3c_address(iobase, 0x3000);
525 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
526
527error:
528 udelay(17);
529
530 /* Clear */
531 bt3c_io_write(iobase, 0x7006, 0x0000);
532 bt3c_io_write(iobase, 0x7005, 0x0000);
533 bt3c_io_write(iobase, 0x7001, 0x0000);
534
535 return err;
536}
537
538
539static int bt3c_open(bt3c_info_t *info)
540{
541 const struct firmware *firmware;
542 struct hci_dev *hdev;
543 int err;
544
545 spin_lock_init(&(info->lock));
546
547 skb_queue_head_init(&(info->txq));
548
549 info->rx_state = RECV_WAIT_PACKET_TYPE;
550 info->rx_count = 0;
551 info->rx_skb = NULL;
552
553 /* Initialize HCI device */
554 hdev = hci_alloc_dev();
555 if (!hdev) {
556 BT_ERR("Can't allocate HCI device");
557 return -ENOMEM;
558 }
559
560 info->hdev = hdev;
561
562 hdev->bus = HCI_PCCARD;
563 hci_set_drvdata(hdev, info);
564 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
565
566 hdev->open = bt3c_hci_open;
567 hdev->close = bt3c_hci_close;
568 hdev->flush = bt3c_hci_flush;
569 hdev->send = bt3c_hci_send_frame;
570
571 /* Load firmware */
572 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
573 if (err < 0) {
574 BT_ERR("Firmware request failed");
575 goto error;
576 }
577
578 err = bt3c_load_firmware(info, firmware->data, firmware->size);
579
580 release_firmware(firmware);
581
582 if (err < 0) {
583 BT_ERR("Firmware loading failed");
584 goto error;
585 }
586
587 /* Timeout before it is safe to send the first HCI packet */
588 msleep(1000);
589
590 /* Register HCI device */
591 err = hci_register_dev(hdev);
592 if (err < 0) {
593 BT_ERR("Can't register HCI device");
594 goto error;
595 }
596
597 return 0;
598
599error:
600 info->hdev = NULL;
601 hci_free_dev(hdev);
602 return err;
603}
604
605
606static int bt3c_close(bt3c_info_t *info)
607{
608 struct hci_dev *hdev = info->hdev;
609
610 if (!hdev)
611 return -ENODEV;
612
613 bt3c_hci_close(hdev);
614
615 hci_unregister_dev(hdev);
616 hci_free_dev(hdev);
617
618 return 0;
619}
620
621static int bt3c_probe(struct pcmcia_device *link)
622{
623 bt3c_info_t *info;
624
625 /* Create new info device */
626 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
627 if (!info)
628 return -ENOMEM;
629
630 info->p_dev = link;
631 link->priv = info;
632
633 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
634 CONF_AUTO_SET_IO;
635
636 return bt3c_config(link);
637}
638
639
640static void bt3c_detach(struct pcmcia_device *link)
641{
642 bt3c_release(link);
643}
644
645static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
646{
647 int *try = priv_data;
648
649 if (!try)
650 p_dev->io_lines = 16;
651
652 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
653 return -EINVAL;
654
655 p_dev->resource[0]->end = 8;
656 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
657 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
658
659 return pcmcia_request_io(p_dev);
660}
661
662static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
663 void *priv_data)
664{
665 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
666 int j;
667
668 if (p_dev->io_lines > 3)
669 return -ENODEV;
670
671 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
672 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
673 p_dev->resource[0]->end = 8;
674
675 for (j = 0; j < 5; j++) {
676 p_dev->resource[0]->start = base[j];
677 p_dev->io_lines = base[j] ? 16 : 3;
678 if (!pcmcia_request_io(p_dev))
679 return 0;
680 }
681 return -ENODEV;
682}
683
684static int bt3c_config(struct pcmcia_device *link)
685{
686 bt3c_info_t *info = link->priv;
687 int i;
688 unsigned long try;
689
690 /* First pass: look for a config entry that looks normal.
691 Two tries: without IO aliases, then with aliases */
692 for (try = 0; try < 2; try++)
693 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
694 goto found_port;
695
696 /* Second pass: try to find an entry that isn't picky about
697 its base address, then try to grab any standard serial port
698 address, and finally try to get any free port. */
699 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
700 goto found_port;
701
702 BT_ERR("No usable port range found");
703 goto failed;
704
705found_port:
706 i = pcmcia_request_irq(link, &bt3c_interrupt);
707 if (i != 0)
708 goto failed;
709
710 i = pcmcia_enable_device(link);
711 if (i != 0)
712 goto failed;
713
714 if (bt3c_open(info) != 0)
715 goto failed;
716
717 return 0;
718
719failed:
720 bt3c_release(link);
721 return -ENODEV;
722}
723
724
725static void bt3c_release(struct pcmcia_device *link)
726{
727 bt3c_info_t *info = link->priv;
728
729 bt3c_close(info);
730
731 pcmcia_disable_device(link);
732}
733
734
735static const struct pcmcia_device_id bt3c_ids[] = {
736 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
737 PCMCIA_DEVICE_NULL
738};
739MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
740
741static struct pcmcia_driver bt3c_driver = {
742 .owner = THIS_MODULE,
743 .name = "bt3c_cs",
744 .probe = bt3c_probe,
745 .remove = bt3c_detach,
746 .id_table = bt3c_ids,
747};
748module_pcmcia_driver(bt3c_driver);