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