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