1 /* 2 * 3 * Driver for the 3Com Bluetooth PCMCIA card 4 * 5 * Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org> 6 * Jose Orlando Pereira <jop@di.uminho.pt> 7 * 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation; 12 * 13 * Software distributed under the License is distributed on an "AS 14 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or 15 * implied. See the License for the specific language governing 16 * rights and limitations under the License. 17 * 18 * The initial developer of the original code is David A. Hinds 19 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds 20 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 21 * 22 */ 23 24 #include <linux/module.h> 25 26 #include <linux/kernel.h> 27 #include <linux/init.h> 28 #include <linux/slab.h> 29 #include <linux/types.h> 30 #include <linux/delay.h> 31 #include <linux/errno.h> 32 #include <linux/ptrace.h> 33 #include <linux/ioport.h> 34 #include <linux/spinlock.h> 35 #include <linux/moduleparam.h> 36 37 #include <linux/skbuff.h> 38 #include <linux/string.h> 39 #include <linux/serial.h> 40 #include <linux/serial_reg.h> 41 #include <linux/bitops.h> 42 #include <asm/system.h> 43 #include <asm/io.h> 44 45 #include <linux/device.h> 46 #include <linux/firmware.h> 47 48 #include <pcmcia/cs_types.h> 49 #include <pcmcia/cs.h> 50 #include <pcmcia/cistpl.h> 51 #include <pcmcia/ciscode.h> 52 #include <pcmcia/ds.h> 53 #include <pcmcia/cisreg.h> 54 55 #include <net/bluetooth/bluetooth.h> 56 #include <net/bluetooth/hci_core.h> 57 58 59 60 /* ======================== Module parameters ======================== */ 61 62 63 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 64 MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card"); 65 MODULE_LICENSE("GPL"); 66 MODULE_FIRMWARE("BT3CPCC.bin"); 67 68 69 70 /* ======================== Local structures ======================== */ 71 72 73 typedef struct bt3c_info_t { 74 struct pcmcia_device *p_dev; 75 76 struct hci_dev *hdev; 77 78 spinlock_t lock; /* For serializing operations */ 79 80 struct sk_buff_head txq; 81 unsigned long tx_state; 82 83 unsigned long rx_state; 84 unsigned long rx_count; 85 struct sk_buff *rx_skb; 86 } bt3c_info_t; 87 88 89 static int bt3c_config(struct pcmcia_device *link); 90 static void bt3c_release(struct pcmcia_device *link); 91 92 static void bt3c_detach(struct pcmcia_device *p_dev); 93 94 95 /* Transmit states */ 96 #define XMIT_SENDING 1 97 #define XMIT_WAKEUP 2 98 #define XMIT_WAITING 8 99 100 /* Receiver states */ 101 #define RECV_WAIT_PACKET_TYPE 0 102 #define RECV_WAIT_EVENT_HEADER 1 103 #define RECV_WAIT_ACL_HEADER 2 104 #define RECV_WAIT_SCO_HEADER 3 105 #define RECV_WAIT_DATA 4 106 107 108 109 /* ======================== Special I/O functions ======================== */ 110 111 112 #define DATA_L 0 113 #define DATA_H 1 114 #define ADDR_L 2 115 #define ADDR_H 3 116 #define CONTROL 4 117 118 119 static inline void bt3c_address(unsigned int iobase, unsigned short addr) 120 { 121 outb(addr & 0xff, iobase + ADDR_L); 122 outb((addr >> 8) & 0xff, iobase + ADDR_H); 123 } 124 125 126 static inline void bt3c_put(unsigned int iobase, unsigned short value) 127 { 128 outb(value & 0xff, iobase + DATA_L); 129 outb((value >> 8) & 0xff, iobase + DATA_H); 130 } 131 132 133 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value) 134 { 135 bt3c_address(iobase, addr); 136 bt3c_put(iobase, value); 137 } 138 139 140 static inline unsigned short bt3c_get(unsigned int iobase) 141 { 142 unsigned short value = inb(iobase + DATA_L); 143 144 value |= inb(iobase + DATA_H) << 8; 145 146 return value; 147 } 148 149 150 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr) 151 { 152 bt3c_address(iobase, addr); 153 154 return bt3c_get(iobase); 155 } 156 157 158 159 /* ======================== Interrupt handling ======================== */ 160 161 162 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len) 163 { 164 int actual = 0; 165 166 bt3c_address(iobase, 0x7080); 167 168 /* Fill FIFO with current frame */ 169 while (actual < len) { 170 /* Transmit next byte */ 171 bt3c_put(iobase, buf[actual]); 172 actual++; 173 } 174 175 bt3c_io_write(iobase, 0x7005, actual); 176 177 return actual; 178 } 179 180 181 static void bt3c_write_wakeup(bt3c_info_t *info) 182 { 183 if (!info) { 184 BT_ERR("Unknown device"); 185 return; 186 } 187 188 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) 189 return; 190 191 do { 192 register unsigned int iobase = info->p_dev->io.BasePort1; 193 register struct sk_buff *skb; 194 register int len; 195 196 if (!pcmcia_dev_present(info->p_dev)) 197 break; 198 199 200 if (!(skb = skb_dequeue(&(info->txq)))) { 201 clear_bit(XMIT_SENDING, &(info->tx_state)); 202 break; 203 } 204 205 /* Send frame */ 206 len = bt3c_write(iobase, 256, skb->data, skb->len); 207 208 if (len != skb->len) { 209 BT_ERR("Very strange"); 210 } 211 212 kfree_skb(skb); 213 214 info->hdev->stat.byte_tx += len; 215 216 } while (0); 217 } 218 219 220 static void bt3c_receive(bt3c_info_t *info) 221 { 222 unsigned int iobase; 223 int size = 0, avail; 224 225 if (!info) { 226 BT_ERR("Unknown device"); 227 return; 228 } 229 230 iobase = info->p_dev->io.BasePort1; 231 232 avail = bt3c_read(iobase, 0x7006); 233 //printk("bt3c_cs: receiving %d bytes\n", avail); 234 235 bt3c_address(iobase, 0x7480); 236 while (size < avail) { 237 size++; 238 info->hdev->stat.byte_rx++; 239 240 /* Allocate packet */ 241 if (info->rx_skb == NULL) { 242 info->rx_state = RECV_WAIT_PACKET_TYPE; 243 info->rx_count = 0; 244 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) { 245 BT_ERR("Can't allocate mem for new packet"); 246 return; 247 } 248 } 249 250 251 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 252 253 info->rx_skb->dev = (void *) info->hdev; 254 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L); 255 inb(iobase + DATA_H); 256 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type); 257 258 switch (bt_cb(info->rx_skb)->pkt_type) { 259 260 case HCI_EVENT_PKT: 261 info->rx_state = RECV_WAIT_EVENT_HEADER; 262 info->rx_count = HCI_EVENT_HDR_SIZE; 263 break; 264 265 case HCI_ACLDATA_PKT: 266 info->rx_state = RECV_WAIT_ACL_HEADER; 267 info->rx_count = HCI_ACL_HDR_SIZE; 268 break; 269 270 case HCI_SCODATA_PKT: 271 info->rx_state = RECV_WAIT_SCO_HEADER; 272 info->rx_count = HCI_SCO_HDR_SIZE; 273 break; 274 275 default: 276 /* Unknown packet */ 277 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type); 278 info->hdev->stat.err_rx++; 279 clear_bit(HCI_RUNNING, &(info->hdev->flags)); 280 281 kfree_skb(info->rx_skb); 282 info->rx_skb = NULL; 283 break; 284 285 } 286 287 } else { 288 289 __u8 x = inb(iobase + DATA_L); 290 291 *skb_put(info->rx_skb, 1) = x; 292 inb(iobase + DATA_H); 293 info->rx_count--; 294 295 if (info->rx_count == 0) { 296 297 int dlen; 298 struct hci_event_hdr *eh; 299 struct hci_acl_hdr *ah; 300 struct hci_sco_hdr *sh; 301 302 switch (info->rx_state) { 303 304 case RECV_WAIT_EVENT_HEADER: 305 eh = hci_event_hdr(info->rx_skb); 306 info->rx_state = RECV_WAIT_DATA; 307 info->rx_count = eh->plen; 308 break; 309 310 case RECV_WAIT_ACL_HEADER: 311 ah = hci_acl_hdr(info->rx_skb); 312 dlen = __le16_to_cpu(ah->dlen); 313 info->rx_state = RECV_WAIT_DATA; 314 info->rx_count = dlen; 315 break; 316 317 case RECV_WAIT_SCO_HEADER: 318 sh = hci_sco_hdr(info->rx_skb); 319 info->rx_state = RECV_WAIT_DATA; 320 info->rx_count = sh->dlen; 321 break; 322 323 case RECV_WAIT_DATA: 324 hci_recv_frame(info->rx_skb); 325 info->rx_skb = NULL; 326 break; 327 328 } 329 330 } 331 332 } 333 334 } 335 336 bt3c_io_write(iobase, 0x7006, 0x0000); 337 } 338 339 340 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst) 341 { 342 bt3c_info_t *info = dev_inst; 343 unsigned int iobase; 344 int iir; 345 irqreturn_t r = IRQ_NONE; 346 347 if (!info || !info->hdev) 348 /* our irq handler is shared */ 349 return IRQ_NONE; 350 351 iobase = info->p_dev->io.BasePort1; 352 353 spin_lock(&(info->lock)); 354 355 iir = inb(iobase + CONTROL); 356 if (iir & 0x80) { 357 int stat = bt3c_read(iobase, 0x7001); 358 359 if ((stat & 0xff) == 0x7f) { 360 BT_ERR("Very strange (stat=0x%04x)", stat); 361 } else if ((stat & 0xff) != 0xff) { 362 if (stat & 0x0020) { 363 int status = bt3c_read(iobase, 0x7002) & 0x10; 364 BT_INFO("%s: Antenna %s", info->hdev->name, 365 status ? "out" : "in"); 366 } 367 if (stat & 0x0001) 368 bt3c_receive(info); 369 if (stat & 0x0002) { 370 //BT_ERR("Ack (stat=0x%04x)", stat); 371 clear_bit(XMIT_SENDING, &(info->tx_state)); 372 bt3c_write_wakeup(info); 373 } 374 375 bt3c_io_write(iobase, 0x7001, 0x0000); 376 377 outb(iir, iobase + CONTROL); 378 } 379 r = IRQ_HANDLED; 380 } 381 382 spin_unlock(&(info->lock)); 383 384 return r; 385 } 386 387 388 389 /* ======================== HCI interface ======================== */ 390 391 392 static int bt3c_hci_flush(struct hci_dev *hdev) 393 { 394 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data); 395 396 /* Drop TX queue */ 397 skb_queue_purge(&(info->txq)); 398 399 return 0; 400 } 401 402 403 static int bt3c_hci_open(struct hci_dev *hdev) 404 { 405 set_bit(HCI_RUNNING, &(hdev->flags)); 406 407 return 0; 408 } 409 410 411 static int bt3c_hci_close(struct hci_dev *hdev) 412 { 413 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags))) 414 return 0; 415 416 bt3c_hci_flush(hdev); 417 418 return 0; 419 } 420 421 422 static int bt3c_hci_send_frame(struct sk_buff *skb) 423 { 424 bt3c_info_t *info; 425 struct hci_dev *hdev = (struct hci_dev *)(skb->dev); 426 unsigned long flags; 427 428 if (!hdev) { 429 BT_ERR("Frame for unknown HCI device (hdev=NULL)"); 430 return -ENODEV; 431 } 432 433 info = (bt3c_info_t *) (hdev->driver_data); 434 435 switch (bt_cb(skb)->pkt_type) { 436 case HCI_COMMAND_PKT: 437 hdev->stat.cmd_tx++; 438 break; 439 case HCI_ACLDATA_PKT: 440 hdev->stat.acl_tx++; 441 break; 442 case HCI_SCODATA_PKT: 443 hdev->stat.sco_tx++; 444 break; 445 }; 446 447 /* Prepend skb with frame type */ 448 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 449 skb_queue_tail(&(info->txq), skb); 450 451 spin_lock_irqsave(&(info->lock), flags); 452 453 bt3c_write_wakeup(info); 454 455 spin_unlock_irqrestore(&(info->lock), flags); 456 457 return 0; 458 } 459 460 461 static void bt3c_hci_destruct(struct hci_dev *hdev) 462 { 463 } 464 465 466 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg) 467 { 468 return -ENOIOCTLCMD; 469 } 470 471 472 473 /* ======================== Card services HCI interaction ======================== */ 474 475 476 static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware, 477 int count) 478 { 479 char *ptr = (char *) firmware; 480 char b[9]; 481 unsigned int iobase, size, addr, fcs, tmp; 482 int i, err = 0; 483 484 iobase = info->p_dev->io.BasePort1; 485 486 /* Reset */ 487 bt3c_io_write(iobase, 0x8040, 0x0404); 488 bt3c_io_write(iobase, 0x8040, 0x0400); 489 490 udelay(1); 491 492 bt3c_io_write(iobase, 0x8040, 0x0404); 493 494 udelay(17); 495 496 /* Load */ 497 while (count) { 498 if (ptr[0] != 'S') { 499 BT_ERR("Bad address in firmware"); 500 err = -EFAULT; 501 goto error; 502 } 503 504 memset(b, 0, sizeof(b)); 505 memcpy(b, ptr + 2, 2); 506 size = simple_strtoul(b, NULL, 16); 507 508 memset(b, 0, sizeof(b)); 509 memcpy(b, ptr + 4, 8); 510 addr = simple_strtoul(b, NULL, 16); 511 512 memset(b, 0, sizeof(b)); 513 memcpy(b, ptr + (size * 2) + 2, 2); 514 fcs = simple_strtoul(b, NULL, 16); 515 516 memset(b, 0, sizeof(b)); 517 for (tmp = 0, i = 0; i < size; i++) { 518 memcpy(b, ptr + (i * 2) + 2, 2); 519 tmp += simple_strtol(b, NULL, 16); 520 } 521 522 if (((tmp + fcs) & 0xff) != 0xff) { 523 BT_ERR("Checksum error in firmware"); 524 err = -EILSEQ; 525 goto error; 526 } 527 528 if (ptr[1] == '3') { 529 bt3c_address(iobase, addr); 530 531 memset(b, 0, sizeof(b)); 532 for (i = 0; i < (size - 4) / 2; i++) { 533 memcpy(b, ptr + (i * 4) + 12, 4); 534 tmp = simple_strtoul(b, NULL, 16); 535 bt3c_put(iobase, tmp); 536 } 537 } 538 539 ptr += (size * 2) + 6; 540 count -= (size * 2) + 6; 541 } 542 543 udelay(17); 544 545 /* Boot */ 546 bt3c_address(iobase, 0x3000); 547 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL); 548 549 error: 550 udelay(17); 551 552 /* Clear */ 553 bt3c_io_write(iobase, 0x7006, 0x0000); 554 bt3c_io_write(iobase, 0x7005, 0x0000); 555 bt3c_io_write(iobase, 0x7001, 0x0000); 556 557 return err; 558 } 559 560 561 static int bt3c_open(bt3c_info_t *info) 562 { 563 const struct firmware *firmware; 564 struct hci_dev *hdev; 565 int err; 566 567 spin_lock_init(&(info->lock)); 568 569 skb_queue_head_init(&(info->txq)); 570 571 info->rx_state = RECV_WAIT_PACKET_TYPE; 572 info->rx_count = 0; 573 info->rx_skb = NULL; 574 575 /* Initialize HCI device */ 576 hdev = hci_alloc_dev(); 577 if (!hdev) { 578 BT_ERR("Can't allocate HCI device"); 579 return -ENOMEM; 580 } 581 582 info->hdev = hdev; 583 584 hdev->bus = HCI_PCCARD; 585 hdev->driver_data = info; 586 SET_HCIDEV_DEV(hdev, &info->p_dev->dev); 587 588 hdev->open = bt3c_hci_open; 589 hdev->close = bt3c_hci_close; 590 hdev->flush = bt3c_hci_flush; 591 hdev->send = bt3c_hci_send_frame; 592 hdev->destruct = bt3c_hci_destruct; 593 hdev->ioctl = bt3c_hci_ioctl; 594 595 hdev->owner = THIS_MODULE; 596 597 /* Load firmware */ 598 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev); 599 if (err < 0) { 600 BT_ERR("Firmware request failed"); 601 goto error; 602 } 603 604 err = bt3c_load_firmware(info, firmware->data, firmware->size); 605 606 release_firmware(firmware); 607 608 if (err < 0) { 609 BT_ERR("Firmware loading failed"); 610 goto error; 611 } 612 613 /* Timeout before it is safe to send the first HCI packet */ 614 msleep(1000); 615 616 /* Register HCI device */ 617 err = hci_register_dev(hdev); 618 if (err < 0) { 619 BT_ERR("Can't register HCI device"); 620 goto error; 621 } 622 623 return 0; 624 625 error: 626 info->hdev = NULL; 627 hci_free_dev(hdev); 628 return err; 629 } 630 631 632 static int bt3c_close(bt3c_info_t *info) 633 { 634 struct hci_dev *hdev = info->hdev; 635 636 if (!hdev) 637 return -ENODEV; 638 639 bt3c_hci_close(hdev); 640 641 if (hci_unregister_dev(hdev) < 0) 642 BT_ERR("Can't unregister HCI device %s", hdev->name); 643 644 hci_free_dev(hdev); 645 646 return 0; 647 } 648 649 static int bt3c_probe(struct pcmcia_device *link) 650 { 651 bt3c_info_t *info; 652 653 /* Create new info device */ 654 info = kzalloc(sizeof(*info), GFP_KERNEL); 655 if (!info) 656 return -ENOMEM; 657 658 info->p_dev = link; 659 link->priv = info; 660 661 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 662 link->io.NumPorts1 = 8; 663 664 link->conf.Attributes = CONF_ENABLE_IRQ; 665 link->conf.IntType = INT_MEMORY_AND_IO; 666 667 return bt3c_config(link); 668 } 669 670 671 static void bt3c_detach(struct pcmcia_device *link) 672 { 673 bt3c_info_t *info = link->priv; 674 675 bt3c_release(link); 676 kfree(info); 677 } 678 679 static int bt3c_check_config(struct pcmcia_device *p_dev, 680 cistpl_cftable_entry_t *cf, 681 cistpl_cftable_entry_t *dflt, 682 unsigned int vcc, 683 void *priv_data) 684 { 685 unsigned long try = (unsigned long) priv_data; 686 687 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM)) 688 p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000; 689 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && 690 (cf->io.win[0].base != 0)) { 691 p_dev->io.BasePort1 = cf->io.win[0].base; 692 p_dev->io.IOAddrLines = (try == 0) ? 16 : 693 cf->io.flags & CISTPL_IO_LINES_MASK; 694 if (!pcmcia_request_io(p_dev, &p_dev->io)) 695 return 0; 696 } 697 return -ENODEV; 698 } 699 700 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev, 701 cistpl_cftable_entry_t *cf, 702 cistpl_cftable_entry_t *dflt, 703 unsigned int vcc, 704 void *priv_data) 705 { 706 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 }; 707 int j; 708 709 if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) { 710 for (j = 0; j < 5; j++) { 711 p_dev->io.BasePort1 = base[j]; 712 p_dev->io.IOAddrLines = base[j] ? 16 : 3; 713 if (!pcmcia_request_io(p_dev, &p_dev->io)) 714 return 0; 715 } 716 } 717 return -ENODEV; 718 } 719 720 static int bt3c_config(struct pcmcia_device *link) 721 { 722 bt3c_info_t *info = link->priv; 723 int i; 724 unsigned long try; 725 726 /* First pass: look for a config entry that looks normal. 727 Two tries: without IO aliases, then with aliases */ 728 for (try = 0; try < 2; try++) 729 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try)) 730 goto found_port; 731 732 /* Second pass: try to find an entry that isn't picky about 733 its base address, then try to grab any standard serial port 734 address, and finally try to get any free port. */ 735 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL)) 736 goto found_port; 737 738 BT_ERR("No usable port range found"); 739 goto failed; 740 741 found_port: 742 i = pcmcia_request_irq(link, &bt3c_interrupt); 743 if (i != 0) 744 goto failed; 745 746 i = pcmcia_request_configuration(link, &link->conf); 747 if (i != 0) 748 goto failed; 749 750 if (bt3c_open(info) != 0) 751 goto failed; 752 753 return 0; 754 755 failed: 756 bt3c_release(link); 757 return -ENODEV; 758 } 759 760 761 static void bt3c_release(struct pcmcia_device *link) 762 { 763 bt3c_info_t *info = link->priv; 764 765 bt3c_close(info); 766 767 pcmcia_disable_device(link); 768 } 769 770 771 static struct pcmcia_device_id bt3c_ids[] = { 772 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02), 773 PCMCIA_DEVICE_NULL 774 }; 775 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids); 776 777 static struct pcmcia_driver bt3c_driver = { 778 .owner = THIS_MODULE, 779 .drv = { 780 .name = "bt3c_cs", 781 }, 782 .probe = bt3c_probe, 783 .remove = bt3c_detach, 784 .id_table = bt3c_ids, 785 }; 786 787 static int __init init_bt3c_cs(void) 788 { 789 return pcmcia_register_driver(&bt3c_driver); 790 } 791 792 793 static void __exit exit_bt3c_cs(void) 794 { 795 pcmcia_unregister_driver(&bt3c_driver); 796 } 797 798 module_init(init_bt3c_cs); 799 module_exit(exit_bt3c_cs); 800