networking: add and use skb_put_u8()
[sfrench/cifs-2.6.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 struct bt3c_info {
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 };
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(struct bt3c_info *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                 kfree_skb(skb);
209
210                 info->hdev->stat.byte_tx += len;
211
212         } while (0);
213 }
214
215
216 static void bt3c_receive(struct bt3c_info *info)
217 {
218         unsigned int iobase;
219         int size = 0, avail;
220
221         if (!info) {
222                 BT_ERR("Unknown device");
223                 return;
224         }
225
226         iobase = info->p_dev->resource[0]->start;
227
228         avail = bt3c_read(iobase, 0x7006);
229
230         bt3c_address(iobase, 0x7480);
231         while (size < avail) {
232                 size++;
233                 info->hdev->stat.byte_rx++;
234
235                 /* Allocate packet */
236                 if (!info->rx_skb) {
237                         info->rx_state = RECV_WAIT_PACKET_TYPE;
238                         info->rx_count = 0;
239                         info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
240                         if (!info->rx_skb) {
241                                 BT_ERR("Can't allocate mem for new packet");
242                                 return;
243                         }
244                 }
245
246
247                 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
248
249                         hci_skb_pkt_type(info->rx_skb) = inb(iobase + DATA_L);
250                         inb(iobase + DATA_H);
251
252                         switch (hci_skb_pkt_type(info->rx_skb)) {
253
254                         case HCI_EVENT_PKT:
255                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
256                                 info->rx_count = HCI_EVENT_HDR_SIZE;
257                                 break;
258
259                         case HCI_ACLDATA_PKT:
260                                 info->rx_state = RECV_WAIT_ACL_HEADER;
261                                 info->rx_count = HCI_ACL_HDR_SIZE;
262                                 break;
263
264                         case HCI_SCODATA_PKT:
265                                 info->rx_state = RECV_WAIT_SCO_HEADER;
266                                 info->rx_count = HCI_SCO_HDR_SIZE;
267                                 break;
268
269                         default:
270                                 /* Unknown packet */
271                                 BT_ERR("Unknown HCI packet with type 0x%02x received",
272                                        hci_skb_pkt_type(info->rx_skb));
273                                 info->hdev->stat.err_rx++;
274
275                                 kfree_skb(info->rx_skb);
276                                 info->rx_skb = NULL;
277                                 break;
278
279                         }
280
281                 } else {
282
283                         __u8 x = inb(iobase + DATA_L);
284
285                         skb_put_u8(info->rx_skb, x);
286                         inb(iobase + DATA_H);
287                         info->rx_count--;
288
289                         if (info->rx_count == 0) {
290
291                                 int dlen;
292                                 struct hci_event_hdr *eh;
293                                 struct hci_acl_hdr *ah;
294                                 struct hci_sco_hdr *sh;
295
296                                 switch (info->rx_state) {
297
298                                 case RECV_WAIT_EVENT_HEADER:
299                                         eh = hci_event_hdr(info->rx_skb);
300                                         info->rx_state = RECV_WAIT_DATA;
301                                         info->rx_count = eh->plen;
302                                         break;
303
304                                 case RECV_WAIT_ACL_HEADER:
305                                         ah = hci_acl_hdr(info->rx_skb);
306                                         dlen = __le16_to_cpu(ah->dlen);
307                                         info->rx_state = RECV_WAIT_DATA;
308                                         info->rx_count = dlen;
309                                         break;
310
311                                 case RECV_WAIT_SCO_HEADER:
312                                         sh = hci_sco_hdr(info->rx_skb);
313                                         info->rx_state = RECV_WAIT_DATA;
314                                         info->rx_count = sh->dlen;
315                                         break;
316
317                                 case RECV_WAIT_DATA:
318                                         hci_recv_frame(info->hdev, info->rx_skb);
319                                         info->rx_skb = NULL;
320                                         break;
321
322                                 }
323
324                         }
325
326                 }
327
328         }
329
330         bt3c_io_write(iobase, 0x7006, 0x0000);
331 }
332
333
334 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
335 {
336         struct bt3c_info *info = dev_inst;
337         unsigned int iobase;
338         int iir;
339         irqreturn_t r = IRQ_NONE;
340
341         if (!info || !info->hdev)
342                 /* our irq handler is shared */
343                 return IRQ_NONE;
344
345         iobase = info->p_dev->resource[0]->start;
346
347         spin_lock(&(info->lock));
348
349         iir = inb(iobase + CONTROL);
350         if (iir & 0x80) {
351                 int stat = bt3c_read(iobase, 0x7001);
352
353                 if ((stat & 0xff) == 0x7f) {
354                         BT_ERR("Very strange (stat=0x%04x)", stat);
355                 } else if ((stat & 0xff) != 0xff) {
356                         if (stat & 0x0020) {
357                                 int status = bt3c_read(iobase, 0x7002) & 0x10;
358                                 BT_INFO("%s: Antenna %s", info->hdev->name,
359                                                         status ? "out" : "in");
360                         }
361                         if (stat & 0x0001)
362                                 bt3c_receive(info);
363                         if (stat & 0x0002) {
364                                 clear_bit(XMIT_SENDING, &(info->tx_state));
365                                 bt3c_write_wakeup(info);
366                         }
367
368                         bt3c_io_write(iobase, 0x7001, 0x0000);
369
370                         outb(iir, iobase + CONTROL);
371                 }
372                 r = IRQ_HANDLED;
373         }
374
375         spin_unlock(&(info->lock));
376
377         return r;
378 }
379
380
381
382 /* ======================== HCI interface ======================== */
383
384
385 static int bt3c_hci_flush(struct hci_dev *hdev)
386 {
387         struct bt3c_info *info = hci_get_drvdata(hdev);
388
389         /* Drop TX queue */
390         skb_queue_purge(&(info->txq));
391
392         return 0;
393 }
394
395
396 static int bt3c_hci_open(struct hci_dev *hdev)
397 {
398         return 0;
399 }
400
401
402 static int bt3c_hci_close(struct hci_dev *hdev)
403 {
404         bt3c_hci_flush(hdev);
405
406         return 0;
407 }
408
409
410 static int bt3c_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
411 {
412         struct bt3c_info *info = hci_get_drvdata(hdev);
413         unsigned long flags;
414
415         switch (hci_skb_pkt_type(skb)) {
416         case HCI_COMMAND_PKT:
417                 hdev->stat.cmd_tx++;
418                 break;
419         case HCI_ACLDATA_PKT:
420                 hdev->stat.acl_tx++;
421                 break;
422         case HCI_SCODATA_PKT:
423                 hdev->stat.sco_tx++;
424                 break;
425         }
426
427         /* Prepend skb with frame type */
428         memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
429         skb_queue_tail(&(info->txq), skb);
430
431         spin_lock_irqsave(&(info->lock), flags);
432
433         bt3c_write_wakeup(info);
434
435         spin_unlock_irqrestore(&(info->lock), flags);
436
437         return 0;
438 }
439
440
441
442 /* ======================== Card services HCI interaction ======================== */
443
444
445 static int bt3c_load_firmware(struct bt3c_info *info,
446                               const unsigned char *firmware,
447                               int count)
448 {
449         char *ptr = (char *) firmware;
450         char b[9];
451         unsigned int iobase, tmp;
452         unsigned long size, addr, fcs;
453         int i, err = 0;
454
455         iobase = info->p_dev->resource[0]->start;
456
457         /* Reset */
458         bt3c_io_write(iobase, 0x8040, 0x0404);
459         bt3c_io_write(iobase, 0x8040, 0x0400);
460
461         udelay(1);
462
463         bt3c_io_write(iobase, 0x8040, 0x0404);
464
465         udelay(17);
466
467         /* Load */
468         while (count) {
469                 if (ptr[0] != 'S') {
470                         BT_ERR("Bad address in firmware");
471                         err = -EFAULT;
472                         goto error;
473                 }
474
475                 memset(b, 0, sizeof(b));
476                 memcpy(b, ptr + 2, 2);
477                 if (kstrtoul(b, 16, &size) < 0)
478                         return -EINVAL;
479
480                 memset(b, 0, sizeof(b));
481                 memcpy(b, ptr + 4, 8);
482                 if (kstrtoul(b, 16, &addr) < 0)
483                         return -EINVAL;
484
485                 memset(b, 0, sizeof(b));
486                 memcpy(b, ptr + (size * 2) + 2, 2);
487                 if (kstrtoul(b, 16, &fcs) < 0)
488                         return -EINVAL;
489
490                 memset(b, 0, sizeof(b));
491                 for (tmp = 0, i = 0; i < size; i++) {
492                         memcpy(b, ptr + (i * 2) + 2, 2);
493                         tmp += simple_strtol(b, NULL, 16);
494                 }
495
496                 if (((tmp + fcs) & 0xff) != 0xff) {
497                         BT_ERR("Checksum error in firmware");
498                         err = -EILSEQ;
499                         goto error;
500                 }
501
502                 if (ptr[1] == '3') {
503                         bt3c_address(iobase, addr);
504
505                         memset(b, 0, sizeof(b));
506                         for (i = 0; i < (size - 4) / 2; i++) {
507                                 memcpy(b, ptr + (i * 4) + 12, 4);
508                                 tmp = simple_strtoul(b, NULL, 16);
509                                 bt3c_put(iobase, tmp);
510                         }
511                 }
512
513                 ptr   += (size * 2) + 6;
514                 count -= (size * 2) + 6;
515         }
516
517         udelay(17);
518
519         /* Boot */
520         bt3c_address(iobase, 0x3000);
521         outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
522
523 error:
524         udelay(17);
525
526         /* Clear */
527         bt3c_io_write(iobase, 0x7006, 0x0000);
528         bt3c_io_write(iobase, 0x7005, 0x0000);
529         bt3c_io_write(iobase, 0x7001, 0x0000);
530
531         return err;
532 }
533
534
535 static int bt3c_open(struct bt3c_info *info)
536 {
537         const struct firmware *firmware;
538         struct hci_dev *hdev;
539         int err;
540
541         spin_lock_init(&(info->lock));
542
543         skb_queue_head_init(&(info->txq));
544
545         info->rx_state = RECV_WAIT_PACKET_TYPE;
546         info->rx_count = 0;
547         info->rx_skb = NULL;
548
549         /* Initialize HCI device */
550         hdev = hci_alloc_dev();
551         if (!hdev) {
552                 BT_ERR("Can't allocate HCI device");
553                 return -ENOMEM;
554         }
555
556         info->hdev = hdev;
557
558         hdev->bus = HCI_PCCARD;
559         hci_set_drvdata(hdev, info);
560         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
561
562         hdev->open  = bt3c_hci_open;
563         hdev->close = bt3c_hci_close;
564         hdev->flush = bt3c_hci_flush;
565         hdev->send  = bt3c_hci_send_frame;
566
567         /* Load firmware */
568         err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
569         if (err < 0) {
570                 BT_ERR("Firmware request failed");
571                 goto error;
572         }
573
574         err = bt3c_load_firmware(info, firmware->data, firmware->size);
575
576         release_firmware(firmware);
577
578         if (err < 0) {
579                 BT_ERR("Firmware loading failed");
580                 goto error;
581         }
582
583         /* Timeout before it is safe to send the first HCI packet */
584         msleep(1000);
585
586         /* Register HCI device */
587         err = hci_register_dev(hdev);
588         if (err < 0) {
589                 BT_ERR("Can't register HCI device");
590                 goto error;
591         }
592
593         return 0;
594
595 error:
596         info->hdev = NULL;
597         hci_free_dev(hdev);
598         return err;
599 }
600
601
602 static int bt3c_close(struct bt3c_info *info)
603 {
604         struct hci_dev *hdev = info->hdev;
605
606         if (!hdev)
607                 return -ENODEV;
608
609         bt3c_hci_close(hdev);
610
611         hci_unregister_dev(hdev);
612         hci_free_dev(hdev);
613
614         return 0;
615 }
616
617 static int bt3c_probe(struct pcmcia_device *link)
618 {
619         struct bt3c_info *info;
620
621         /* Create new info device */
622         info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
623         if (!info)
624                 return -ENOMEM;
625
626         info->p_dev = link;
627         link->priv = info;
628
629         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
630                 CONF_AUTO_SET_IO;
631
632         return bt3c_config(link);
633 }
634
635
636 static void bt3c_detach(struct pcmcia_device *link)
637 {
638         bt3c_release(link);
639 }
640
641 static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
642 {
643         int *try = priv_data;
644
645         if (!try)
646                 p_dev->io_lines = 16;
647
648         if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
649                 return -EINVAL;
650
651         p_dev->resource[0]->end = 8;
652         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
653         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
654
655         return pcmcia_request_io(p_dev);
656 }
657
658 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
659                                       void *priv_data)
660 {
661         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
662         int j;
663
664         if (p_dev->io_lines > 3)
665                 return -ENODEV;
666
667         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
668         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
669         p_dev->resource[0]->end = 8;
670
671         for (j = 0; j < 5; j++) {
672                 p_dev->resource[0]->start = base[j];
673                 p_dev->io_lines = base[j] ? 16 : 3;
674                 if (!pcmcia_request_io(p_dev))
675                         return 0;
676         }
677         return -ENODEV;
678 }
679
680 static int bt3c_config(struct pcmcia_device *link)
681 {
682         struct bt3c_info *info = link->priv;
683         int i;
684         unsigned long try;
685
686         /* First pass: look for a config entry that looks normal.
687            Two tries: without IO aliases, then with aliases */
688         for (try = 0; try < 2; try++)
689                 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
690                         goto found_port;
691
692         /* Second pass: try to find an entry that isn't picky about
693            its base address, then try to grab any standard serial port
694            address, and finally try to get any free port. */
695         if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
696                 goto found_port;
697
698         BT_ERR("No usable port range found");
699         goto failed;
700
701 found_port:
702         i = pcmcia_request_irq(link, &bt3c_interrupt);
703         if (i != 0)
704                 goto failed;
705
706         i = pcmcia_enable_device(link);
707         if (i != 0)
708                 goto failed;
709
710         if (bt3c_open(info) != 0)
711                 goto failed;
712
713         return 0;
714
715 failed:
716         bt3c_release(link);
717         return -ENODEV;
718 }
719
720
721 static void bt3c_release(struct pcmcia_device *link)
722 {
723         struct bt3c_info *info = link->priv;
724
725         bt3c_close(info);
726
727         pcmcia_disable_device(link);
728 }
729
730
731 static const struct pcmcia_device_id bt3c_ids[] = {
732         PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
733         PCMCIA_DEVICE_NULL
734 };
735 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
736
737 static struct pcmcia_driver bt3c_driver = {
738         .owner          = THIS_MODULE,
739         .name           = "bt3c_cs",
740         .probe          = bt3c_probe,
741         .remove         = bt3c_detach,
742         .id_table       = bt3c_ids,
743 };
744 module_pcmcia_driver(bt3c_driver);