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 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L); 251 inb(iobase + DATA_H); 252 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type); 253 254 switch (bt_cb(info->rx_skb)->pkt_type) { 255 256 case HCI_EVENT_PKT: 257 info->rx_state = RECV_WAIT_EVENT_HEADER; 258 info->rx_count = HCI_EVENT_HDR_SIZE; 259 break; 260 261 case HCI_ACLDATA_PKT: 262 info->rx_state = RECV_WAIT_ACL_HEADER; 263 info->rx_count = HCI_ACL_HDR_SIZE; 264 break; 265 266 case HCI_SCODATA_PKT: 267 info->rx_state = RECV_WAIT_SCO_HEADER; 268 info->rx_count = HCI_SCO_HDR_SIZE; 269 break; 270 271 default: 272 /* Unknown packet */ 273 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type); 274 info->hdev->stat.err_rx++; 275 clear_bit(HCI_RUNNING, &(info->hdev->flags)); 276 277 kfree_skb(info->rx_skb); 278 info->rx_skb = NULL; 279 break; 280 281 } 282 283 } else { 284 285 __u8 x = inb(iobase + DATA_L); 286 287 *skb_put(info->rx_skb, 1) = x; 288 inb(iobase + DATA_H); 289 info->rx_count--; 290 291 if (info->rx_count == 0) { 292 293 int dlen; 294 struct hci_event_hdr *eh; 295 struct hci_acl_hdr *ah; 296 struct hci_sco_hdr *sh; 297 298 switch (info->rx_state) { 299 300 case RECV_WAIT_EVENT_HEADER: 301 eh = hci_event_hdr(info->rx_skb); 302 info->rx_state = RECV_WAIT_DATA; 303 info->rx_count = eh->plen; 304 break; 305 306 case RECV_WAIT_ACL_HEADER: 307 ah = hci_acl_hdr(info->rx_skb); 308 dlen = __le16_to_cpu(ah->dlen); 309 info->rx_state = RECV_WAIT_DATA; 310 info->rx_count = dlen; 311 break; 312 313 case RECV_WAIT_SCO_HEADER: 314 sh = hci_sco_hdr(info->rx_skb); 315 info->rx_state = RECV_WAIT_DATA; 316 info->rx_count = sh->dlen; 317 break; 318 319 case RECV_WAIT_DATA: 320 hci_recv_frame(info->hdev, info->rx_skb); 321 info->rx_skb = NULL; 322 break; 323 324 } 325 326 } 327 328 } 329 330 } 331 332 bt3c_io_write(iobase, 0x7006, 0x0000); 333 } 334 335 336 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst) 337 { 338 bt3c_info_t *info = dev_inst; 339 unsigned int iobase; 340 int iir; 341 irqreturn_t r = IRQ_NONE; 342 343 if (!info || !info->hdev) 344 /* our irq handler is shared */ 345 return IRQ_NONE; 346 347 iobase = info->p_dev->resource[0]->start; 348 349 spin_lock(&(info->lock)); 350 351 iir = inb(iobase + CONTROL); 352 if (iir & 0x80) { 353 int stat = bt3c_read(iobase, 0x7001); 354 355 if ((stat & 0xff) == 0x7f) { 356 BT_ERR("Very strange (stat=0x%04x)", stat); 357 } else if ((stat & 0xff) != 0xff) { 358 if (stat & 0x0020) { 359 int status = bt3c_read(iobase, 0x7002) & 0x10; 360 BT_INFO("%s: Antenna %s", info->hdev->name, 361 status ? "out" : "in"); 362 } 363 if (stat & 0x0001) 364 bt3c_receive(info); 365 if (stat & 0x0002) { 366 //BT_ERR("Ack (stat=0x%04x)", stat); 367 clear_bit(XMIT_SENDING, &(info->tx_state)); 368 bt3c_write_wakeup(info); 369 } 370 371 bt3c_io_write(iobase, 0x7001, 0x0000); 372 373 outb(iir, iobase + CONTROL); 374 } 375 r = IRQ_HANDLED; 376 } 377 378 spin_unlock(&(info->lock)); 379 380 return r; 381 } 382 383 384 385 /* ======================== HCI interface ======================== */ 386 387 388 static int bt3c_hci_flush(struct hci_dev *hdev) 389 { 390 bt3c_info_t *info = hci_get_drvdata(hdev); 391 392 /* Drop TX queue */ 393 skb_queue_purge(&(info->txq)); 394 395 return 0; 396 } 397 398 399 static int bt3c_hci_open(struct hci_dev *hdev) 400 { 401 set_bit(HCI_RUNNING, &(hdev->flags)); 402 403 return 0; 404 } 405 406 407 static int bt3c_hci_close(struct hci_dev *hdev) 408 { 409 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags))) 410 return 0; 411 412 bt3c_hci_flush(hdev); 413 414 return 0; 415 } 416 417 418 static int bt3c_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 419 { 420 bt3c_info_t *info = hci_get_drvdata(hdev); 421 unsigned long flags; 422 423 switch (bt_cb(skb)->pkt_type) { 424 case HCI_COMMAND_PKT: 425 hdev->stat.cmd_tx++; 426 break; 427 case HCI_ACLDATA_PKT: 428 hdev->stat.acl_tx++; 429 break; 430 case HCI_SCODATA_PKT: 431 hdev->stat.sco_tx++; 432 break; 433 }; 434 435 /* Prepend skb with frame type */ 436 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 437 skb_queue_tail(&(info->txq), skb); 438 439 spin_lock_irqsave(&(info->lock), flags); 440 441 bt3c_write_wakeup(info); 442 443 spin_unlock_irqrestore(&(info->lock), flags); 444 445 return 0; 446 } 447 448 449 450 /* ======================== Card services HCI interaction ======================== */ 451 452 453 static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware, 454 int count) 455 { 456 char *ptr = (char *) firmware; 457 char b[9]; 458 unsigned int iobase, size, addr, fcs, tmp; 459 int i, err = 0; 460 461 iobase = info->p_dev->resource[0]->start; 462 463 /* Reset */ 464 bt3c_io_write(iobase, 0x8040, 0x0404); 465 bt3c_io_write(iobase, 0x8040, 0x0400); 466 467 udelay(1); 468 469 bt3c_io_write(iobase, 0x8040, 0x0404); 470 471 udelay(17); 472 473 /* Load */ 474 while (count) { 475 if (ptr[0] != 'S') { 476 BT_ERR("Bad address in firmware"); 477 err = -EFAULT; 478 goto error; 479 } 480 481 memset(b, 0, sizeof(b)); 482 memcpy(b, ptr + 2, 2); 483 size = simple_strtoul(b, NULL, 16); 484 485 memset(b, 0, sizeof(b)); 486 memcpy(b, ptr + 4, 8); 487 addr = simple_strtoul(b, NULL, 16); 488 489 memset(b, 0, sizeof(b)); 490 memcpy(b, ptr + (size * 2) + 2, 2); 491 fcs = simple_strtoul(b, NULL, 16); 492 493 memset(b, 0, sizeof(b)); 494 for (tmp = 0, i = 0; i < size; i++) { 495 memcpy(b, ptr + (i * 2) + 2, 2); 496 tmp += simple_strtol(b, NULL, 16); 497 } 498 499 if (((tmp + fcs) & 0xff) != 0xff) { 500 BT_ERR("Checksum error in firmware"); 501 err = -EILSEQ; 502 goto error; 503 } 504 505 if (ptr[1] == '3') { 506 bt3c_address(iobase, addr); 507 508 memset(b, 0, sizeof(b)); 509 for (i = 0; i < (size - 4) / 2; i++) { 510 memcpy(b, ptr + (i * 4) + 12, 4); 511 tmp = simple_strtoul(b, NULL, 16); 512 bt3c_put(iobase, tmp); 513 } 514 } 515 516 ptr += (size * 2) + 6; 517 count -= (size * 2) + 6; 518 } 519 520 udelay(17); 521 522 /* Boot */ 523 bt3c_address(iobase, 0x3000); 524 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL); 525 526 error: 527 udelay(17); 528 529 /* Clear */ 530 bt3c_io_write(iobase, 0x7006, 0x0000); 531 bt3c_io_write(iobase, 0x7005, 0x0000); 532 bt3c_io_write(iobase, 0x7001, 0x0000); 533 534 return err; 535 } 536 537 538 static int bt3c_open(bt3c_info_t *info) 539 { 540 const struct firmware *firmware; 541 struct hci_dev *hdev; 542 int err; 543 544 spin_lock_init(&(info->lock)); 545 546 skb_queue_head_init(&(info->txq)); 547 548 info->rx_state = RECV_WAIT_PACKET_TYPE; 549 info->rx_count = 0; 550 info->rx_skb = NULL; 551 552 /* Initialize HCI device */ 553 hdev = hci_alloc_dev(); 554 if (!hdev) { 555 BT_ERR("Can't allocate HCI device"); 556 return -ENOMEM; 557 } 558 559 info->hdev = hdev; 560 561 hdev->bus = HCI_PCCARD; 562 hci_set_drvdata(hdev, info); 563 SET_HCIDEV_DEV(hdev, &info->p_dev->dev); 564 565 hdev->open = bt3c_hci_open; 566 hdev->close = bt3c_hci_close; 567 hdev->flush = bt3c_hci_flush; 568 hdev->send = bt3c_hci_send_frame; 569 570 /* Load firmware */ 571 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev); 572 if (err < 0) { 573 BT_ERR("Firmware request failed"); 574 goto error; 575 } 576 577 err = bt3c_load_firmware(info, firmware->data, firmware->size); 578 579 release_firmware(firmware); 580 581 if (err < 0) { 582 BT_ERR("Firmware loading failed"); 583 goto error; 584 } 585 586 /* Timeout before it is safe to send the first HCI packet */ 587 msleep(1000); 588 589 /* Register HCI device */ 590 err = hci_register_dev(hdev); 591 if (err < 0) { 592 BT_ERR("Can't register HCI device"); 593 goto error; 594 } 595 596 return 0; 597 598 error: 599 info->hdev = NULL; 600 hci_free_dev(hdev); 601 return err; 602 } 603 604 605 static int bt3c_close(bt3c_info_t *info) 606 { 607 struct hci_dev *hdev = info->hdev; 608 609 if (!hdev) 610 return -ENODEV; 611 612 bt3c_hci_close(hdev); 613 614 hci_unregister_dev(hdev); 615 hci_free_dev(hdev); 616 617 return 0; 618 } 619 620 static int bt3c_probe(struct pcmcia_device *link) 621 { 622 bt3c_info_t *info; 623 624 /* Create new info device */ 625 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL); 626 if (!info) 627 return -ENOMEM; 628 629 info->p_dev = link; 630 link->priv = info; 631 632 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP | 633 CONF_AUTO_SET_IO; 634 635 return bt3c_config(link); 636 } 637 638 639 static void bt3c_detach(struct pcmcia_device *link) 640 { 641 bt3c_release(link); 642 } 643 644 static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data) 645 { 646 int *try = priv_data; 647 648 if (!try) 649 p_dev->io_lines = 16; 650 651 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0)) 652 return -EINVAL; 653 654 p_dev->resource[0]->end = 8; 655 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH; 656 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; 657 658 return pcmcia_request_io(p_dev); 659 } 660 661 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev, 662 void *priv_data) 663 { 664 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 }; 665 int j; 666 667 if (p_dev->io_lines > 3) 668 return -ENODEV; 669 670 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH; 671 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; 672 p_dev->resource[0]->end = 8; 673 674 for (j = 0; j < 5; j++) { 675 p_dev->resource[0]->start = base[j]; 676 p_dev->io_lines = base[j] ? 16 : 3; 677 if (!pcmcia_request_io(p_dev)) 678 return 0; 679 } 680 return -ENODEV; 681 } 682 683 static int bt3c_config(struct pcmcia_device *link) 684 { 685 bt3c_info_t *info = link->priv; 686 int i; 687 unsigned long try; 688 689 /* First pass: look for a config entry that looks normal. 690 Two tries: without IO aliases, then with aliases */ 691 for (try = 0; try < 2; try++) 692 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try)) 693 goto found_port; 694 695 /* Second pass: try to find an entry that isn't picky about 696 its base address, then try to grab any standard serial port 697 address, and finally try to get any free port. */ 698 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL)) 699 goto found_port; 700 701 BT_ERR("No usable port range found"); 702 goto failed; 703 704 found_port: 705 i = pcmcia_request_irq(link, &bt3c_interrupt); 706 if (i != 0) 707 goto failed; 708 709 i = pcmcia_enable_device(link); 710 if (i != 0) 711 goto failed; 712 713 if (bt3c_open(info) != 0) 714 goto failed; 715 716 return 0; 717 718 failed: 719 bt3c_release(link); 720 return -ENODEV; 721 } 722 723 724 static void bt3c_release(struct pcmcia_device *link) 725 { 726 bt3c_info_t *info = link->priv; 727 728 bt3c_close(info); 729 730 pcmcia_disable_device(link); 731 } 732 733 734 static const struct pcmcia_device_id bt3c_ids[] = { 735 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02), 736 PCMCIA_DEVICE_NULL 737 }; 738 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids); 739 740 static struct pcmcia_driver bt3c_driver = { 741 .owner = THIS_MODULE, 742 .name = "bt3c_cs", 743 .probe = bt3c_probe, 744 .remove = bt3c_detach, 745 .id_table = bt3c_ids, 746 }; 747 module_pcmcia_driver(bt3c_driver); 748