Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/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                 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 
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                         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 
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 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 
454 static 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 
527 error:
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 
539 static 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 
599 error:
600         info->hdev = NULL;
601         hci_free_dev(hdev);
602         return err;
603 }
604 
605 
606 static 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 
621 static 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 
640 static void bt3c_detach(struct pcmcia_device *link)
641 {
642         bt3c_release(link);
643 }
644 
645 static 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 
662 static 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 
684 static 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 
705 found_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 
719 failed:
720         bt3c_release(link);
721         return -ENODEV;
722 }
723 
724 
725 static 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 
735 static const struct pcmcia_device_id bt3c_ids[] = {
736         PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
737         PCMCIA_DEVICE_NULL
738 };
739 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
740 
741 static 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 };
748 module_pcmcia_driver(bt3c_driver);
749 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us