Bluetooth: hci_vhci.c: removes unnecessary semicolon
[linux-3.10.git] / drivers / bluetooth / bt3c_cs.c
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
60 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
61 MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
62 MODULE_LICENSE("GPL");
63 MODULE_FIRMWARE("BT3CPCC.bin");
64
65
66
67 /* ======================== Local structures ======================== */
68
69
70 typedef 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
86 static int bt3c_config(struct pcmcia_device *link);
87 static void bt3c_release(struct pcmcia_device *link);
88
89 static 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
116 static 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
123 static 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
130 static 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
137 static 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
147 static 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
159 static 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
178 static 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                 /* 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
217 static 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                         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                         //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->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
337 static 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
389 static 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
400 static int bt3c_hci_open(struct hci_dev *hdev)
401 {
402         set_bit(HCI_RUNNING, &(hdev->flags));
403
404         return 0;
405 }
406
407
408 static 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
419 static 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         /* Prepend skb with frame type */
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
458 static 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
468 static 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         /* 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);
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         /* Boot */
538         bt3c_address(iobase, 0x3000);
539         outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
540
541 error:
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
553 static 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
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         /* Load firmware */
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         /* 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
614 error:
615         info->hdev = NULL;
616         hci_free_dev(hdev);
617         return err;
618 }
619
620
621 static 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
636 static int bt3c_probe(struct pcmcia_device *link)
637 {
638         bt3c_info_t *info;
639
640         /* Create new info device */
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
655 static void bt3c_detach(struct pcmcia_device *link)
656 {
657         bt3c_release(link);
658 }
659
660 static 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
677 static 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
699 static int bt3c_config(struct pcmcia_device *link)
700 {
701         bt3c_info_t *info = link->priv;
702         int i;
703         unsigned long try;
704
705         /* First pass: look for a config entry that looks normal.
706            Two tries: without IO aliases, then with aliases */
707         for (try = 0; try < 2; try++)
708                 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
709                         goto found_port;
710
711         /* Second pass: try to find an entry that isn't picky about
712            its base address, then try to grab any standard serial port
713            address, and finally try to get any free port. */
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
720 found_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
734 failed:
735         bt3c_release(link);
736         return -ENODEV;
737 }
738
739
740 static 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
750 static const struct pcmcia_device_id bt3c_ids[] = {
751         PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
752         PCMCIA_DEVICE_NULL
753 };
754 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
755
756 static 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 };
763
764 static int __init init_bt3c_cs(void)
765 {
766         return pcmcia_register_driver(&bt3c_driver);
767 }
768
769
770 static void __exit exit_bt3c_cs(void)
771 {
772         pcmcia_unregister_driver(&bt3c_driver);
773 }
774
775 module_init(init_bt3c_cs);
776 module_exit(exit_bt3c_cs);