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