Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

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

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