1 /* 2 * 3 * Bluetooth driver for the Anycom BlueCard (LSE039/LSE041) 4 * 5 * Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org> 6 * 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation; 11 * 12 * Software distributed under the License is distributed on an "AS 13 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or 14 * implied. See the License for the specific language governing 15 * rights and limitations under the License. 16 * 17 * The initial developer of the original code is David A. Hinds 18 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds 19 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 20 * 21 */ 22 23 #include <linux/module.h> 24 25 #include <linux/kernel.h> 26 #include <linux/init.h> 27 #include <linux/slab.h> 28 #include <linux/types.h> 29 #include <linux/sched.h> 30 #include <linux/delay.h> 31 #include <linux/timer.h> 32 #include <linux/errno.h> 33 #include <linux/ptrace.h> 34 #include <linux/ioport.h> 35 #include <linux/spinlock.h> 36 #include <linux/moduleparam.h> 37 #include <linux/wait.h> 38 39 #include <linux/skbuff.h> 40 #include <linux/io.h> 41 42 #include <pcmcia/cistpl.h> 43 #include <pcmcia/ciscode.h> 44 #include <pcmcia/ds.h> 45 #include <pcmcia/cisreg.h> 46 47 #include <net/bluetooth/bluetooth.h> 48 #include <net/bluetooth/hci_core.h> 49 50 51 52 /* ======================== Module parameters ======================== */ 53 54 55 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 56 MODULE_DESCRIPTION("Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)"); 57 MODULE_LICENSE("GPL"); 58 59 60 61 /* ======================== Local structures ======================== */ 62 63 64 struct bluecard_info { 65 struct pcmcia_device *p_dev; 66 67 struct hci_dev *hdev; 68 69 spinlock_t lock; /* For serializing operations */ 70 struct timer_list timer; /* For LED control */ 71 72 struct sk_buff_head txq; 73 unsigned long tx_state; 74 75 unsigned long rx_state; 76 unsigned long rx_count; 77 struct sk_buff *rx_skb; 78 79 unsigned char ctrl_reg; 80 unsigned long hw_state; /* Status of the hardware and LED control */ 81 }; 82 83 84 static int bluecard_config(struct pcmcia_device *link); 85 static void bluecard_release(struct pcmcia_device *link); 86 87 static void bluecard_detach(struct pcmcia_device *p_dev); 88 89 90 /* Default baud rate: 57600, 115200, 230400 or 460800 */ 91 #define DEFAULT_BAUD_RATE 230400 92 93 94 /* Hardware states */ 95 #define CARD_READY 1 96 #define CARD_ACTIVITY 2 97 #define CARD_HAS_PCCARD_ID 4 98 #define CARD_HAS_POWER_LED 5 99 #define CARD_HAS_ACTIVITY_LED 6 100 101 /* Transmit states */ 102 #define XMIT_SENDING 1 103 #define XMIT_WAKEUP 2 104 #define XMIT_BUFFER_NUMBER 5 /* unset = buffer one, set = buffer two */ 105 #define XMIT_BUF_ONE_READY 6 106 #define XMIT_BUF_TWO_READY 7 107 #define XMIT_SENDING_READY 8 108 109 /* Receiver states */ 110 #define RECV_WAIT_PACKET_TYPE 0 111 #define RECV_WAIT_EVENT_HEADER 1 112 #define RECV_WAIT_ACL_HEADER 2 113 #define RECV_WAIT_SCO_HEADER 3 114 #define RECV_WAIT_DATA 4 115 116 /* Special packet types */ 117 #define PKT_BAUD_RATE_57600 0x80 118 #define PKT_BAUD_RATE_115200 0x81 119 #define PKT_BAUD_RATE_230400 0x82 120 #define PKT_BAUD_RATE_460800 0x83 121 122 123 /* These are the register offsets */ 124 #define REG_COMMAND 0x20 125 #define REG_INTERRUPT 0x21 126 #define REG_CONTROL 0x22 127 #define REG_RX_CONTROL 0x24 128 #define REG_CARD_RESET 0x30 129 #define REG_LED_CTRL 0x30 130 131 /* REG_COMMAND */ 132 #define REG_COMMAND_TX_BUF_ONE 0x01 133 #define REG_COMMAND_TX_BUF_TWO 0x02 134 #define REG_COMMAND_RX_BUF_ONE 0x04 135 #define REG_COMMAND_RX_BUF_TWO 0x08 136 #define REG_COMMAND_RX_WIN_ONE 0x00 137 #define REG_COMMAND_RX_WIN_TWO 0x10 138 139 /* REG_CONTROL */ 140 #define REG_CONTROL_BAUD_RATE_57600 0x00 141 #define REG_CONTROL_BAUD_RATE_115200 0x01 142 #define REG_CONTROL_BAUD_RATE_230400 0x02 143 #define REG_CONTROL_BAUD_RATE_460800 0x03 144 #define REG_CONTROL_RTS 0x04 145 #define REG_CONTROL_BT_ON 0x08 146 #define REG_CONTROL_BT_RESET 0x10 147 #define REG_CONTROL_BT_RES_PU 0x20 148 #define REG_CONTROL_INTERRUPT 0x40 149 #define REG_CONTROL_CARD_RESET 0x80 150 151 /* REG_RX_CONTROL */ 152 #define RTS_LEVEL_SHIFT_BITS 0x02 153 154 155 156 /* ======================== LED handling routines ======================== */ 157 158 159 static void bluecard_activity_led_timeout(struct timer_list *t) 160 { 161 struct bluecard_info *info = from_timer(info, t, timer); 162 unsigned int iobase = info->p_dev->resource[0]->start; 163 164 if (test_bit(CARD_ACTIVITY, &(info->hw_state))) { 165 /* leave LED in inactive state for HZ/10 for blink effect */ 166 clear_bit(CARD_ACTIVITY, &(info->hw_state)); 167 mod_timer(&(info->timer), jiffies + HZ / 10); 168 } 169 170 /* Disable activity LED, enable power LED */ 171 outb(0x08 | 0x20, iobase + 0x30); 172 } 173 174 175 static void bluecard_enable_activity_led(struct bluecard_info *info) 176 { 177 unsigned int iobase = info->p_dev->resource[0]->start; 178 179 /* don't disturb running blink timer */ 180 if (timer_pending(&(info->timer))) 181 return; 182 183 set_bit(CARD_ACTIVITY, &(info->hw_state)); 184 185 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) { 186 /* Enable activity LED, keep power LED enabled */ 187 outb(0x18 | 0x60, iobase + 0x30); 188 } else { 189 /* Disable power LED */ 190 outb(0x00, iobase + 0x30); 191 } 192 193 /* Stop the LED after HZ/10 */ 194 mod_timer(&(info->timer), jiffies + HZ / 10); 195 } 196 197 198 199 /* ======================== Interrupt handling ======================== */ 200 201 202 static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len) 203 { 204 int i, actual; 205 206 actual = (len > 15) ? 15 : len; 207 208 outb_p(actual, iobase + offset); 209 210 for (i = 0; i < actual; i++) 211 outb_p(buf[i], iobase + offset + i + 1); 212 213 return actual; 214 } 215 216 217 static void bluecard_write_wakeup(struct bluecard_info *info) 218 { 219 if (!info) { 220 BT_ERR("Unknown device"); 221 return; 222 } 223 224 if (!test_bit(XMIT_SENDING_READY, &(info->tx_state))) 225 return; 226 227 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) { 228 set_bit(XMIT_WAKEUP, &(info->tx_state)); 229 return; 230 } 231 232 do { 233 unsigned int iobase = info->p_dev->resource[0]->start; 234 unsigned int offset; 235 unsigned char command; 236 unsigned long ready_bit; 237 register struct sk_buff *skb; 238 int len; 239 240 clear_bit(XMIT_WAKEUP, &(info->tx_state)); 241 242 if (!pcmcia_dev_present(info->p_dev)) 243 return; 244 245 if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) { 246 if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state))) 247 break; 248 offset = 0x10; 249 command = REG_COMMAND_TX_BUF_TWO; 250 ready_bit = XMIT_BUF_TWO_READY; 251 } else { 252 if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state))) 253 break; 254 offset = 0x00; 255 command = REG_COMMAND_TX_BUF_ONE; 256 ready_bit = XMIT_BUF_ONE_READY; 257 } 258 259 skb = skb_dequeue(&(info->txq)); 260 if (!skb) 261 break; 262 263 if (hci_skb_pkt_type(skb) & 0x80) { 264 /* Disable RTS */ 265 info->ctrl_reg |= REG_CONTROL_RTS; 266 outb(info->ctrl_reg, iobase + REG_CONTROL); 267 } 268 269 /* Activate LED */ 270 bluecard_enable_activity_led(info); 271 272 /* Send frame */ 273 len = bluecard_write(iobase, offset, skb->data, skb->len); 274 275 /* Tell the FPGA to send the data */ 276 outb_p(command, iobase + REG_COMMAND); 277 278 /* Mark the buffer as dirty */ 279 clear_bit(ready_bit, &(info->tx_state)); 280 281 if (hci_skb_pkt_type(skb) & 0x80) { 282 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 283 DEFINE_WAIT(wait); 284 285 unsigned char baud_reg; 286 287 switch (hci_skb_pkt_type(skb)) { 288 case PKT_BAUD_RATE_460800: 289 baud_reg = REG_CONTROL_BAUD_RATE_460800; 290 break; 291 case PKT_BAUD_RATE_230400: 292 baud_reg = REG_CONTROL_BAUD_RATE_230400; 293 break; 294 case PKT_BAUD_RATE_115200: 295 baud_reg = REG_CONTROL_BAUD_RATE_115200; 296 break; 297 case PKT_BAUD_RATE_57600: 298 /* Fall through... */ 299 default: 300 baud_reg = REG_CONTROL_BAUD_RATE_57600; 301 break; 302 } 303 304 /* Wait until the command reaches the baseband */ 305 mdelay(100); 306 307 /* Set baud on baseband */ 308 info->ctrl_reg &= ~0x03; 309 info->ctrl_reg |= baud_reg; 310 outb(info->ctrl_reg, iobase + REG_CONTROL); 311 312 /* Enable RTS */ 313 info->ctrl_reg &= ~REG_CONTROL_RTS; 314 outb(info->ctrl_reg, iobase + REG_CONTROL); 315 316 /* Wait before the next HCI packet can be send */ 317 mdelay(1000); 318 } 319 320 if (len == skb->len) { 321 kfree_skb(skb); 322 } else { 323 skb_pull(skb, len); 324 skb_queue_head(&(info->txq), skb); 325 } 326 327 info->hdev->stat.byte_tx += len; 328 329 /* Change buffer */ 330 change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state)); 331 332 } while (test_bit(XMIT_WAKEUP, &(info->tx_state))); 333 334 clear_bit(XMIT_SENDING, &(info->tx_state)); 335 } 336 337 338 static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size) 339 { 340 int i, n, len; 341 342 outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND); 343 344 len = inb(iobase + offset); 345 n = 0; 346 i = 1; 347 348 while (n < len) { 349 350 if (i == 16) { 351 outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND); 352 i = 0; 353 } 354 355 buf[n] = inb(iobase + offset + i); 356 357 n++; 358 i++; 359 360 } 361 362 return len; 363 } 364 365 366 static void bluecard_receive(struct bluecard_info *info, 367 unsigned int offset) 368 { 369 unsigned int iobase; 370 unsigned char buf[31]; 371 int i, len; 372 373 if (!info) { 374 BT_ERR("Unknown device"); 375 return; 376 } 377 378 iobase = info->p_dev->resource[0]->start; 379 380 if (test_bit(XMIT_SENDING_READY, &(info->tx_state))) 381 bluecard_enable_activity_led(info); 382 383 len = bluecard_read(iobase, offset, buf, sizeof(buf)); 384 385 for (i = 0; i < len; i++) { 386 387 /* Allocate packet */ 388 if (!info->rx_skb) { 389 info->rx_state = RECV_WAIT_PACKET_TYPE; 390 info->rx_count = 0; 391 info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC); 392 if (!info->rx_skb) { 393 BT_ERR("Can't allocate mem for new packet"); 394 return; 395 } 396 } 397 398 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 399 400 hci_skb_pkt_type(info->rx_skb) = buf[i]; 401 402 switch (hci_skb_pkt_type(info->rx_skb)) { 403 404 case 0x00: 405 /* init packet */ 406 if (offset != 0x00) { 407 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 408 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 409 set_bit(XMIT_SENDING_READY, &(info->tx_state)); 410 bluecard_write_wakeup(info); 411 } 412 413 kfree_skb(info->rx_skb); 414 info->rx_skb = NULL; 415 break; 416 417 case HCI_EVENT_PKT: 418 info->rx_state = RECV_WAIT_EVENT_HEADER; 419 info->rx_count = HCI_EVENT_HDR_SIZE; 420 break; 421 422 case HCI_ACLDATA_PKT: 423 info->rx_state = RECV_WAIT_ACL_HEADER; 424 info->rx_count = HCI_ACL_HDR_SIZE; 425 break; 426 427 case HCI_SCODATA_PKT: 428 info->rx_state = RECV_WAIT_SCO_HEADER; 429 info->rx_count = HCI_SCO_HDR_SIZE; 430 break; 431 432 default: 433 /* unknown packet */ 434 BT_ERR("Unknown HCI packet with type 0x%02x received", 435 hci_skb_pkt_type(info->rx_skb)); 436 info->hdev->stat.err_rx++; 437 438 kfree_skb(info->rx_skb); 439 info->rx_skb = NULL; 440 break; 441 442 } 443 444 } else { 445 446 skb_put_u8(info->rx_skb, buf[i]); 447 info->rx_count--; 448 449 if (info->rx_count == 0) { 450 451 int dlen; 452 struct hci_event_hdr *eh; 453 struct hci_acl_hdr *ah; 454 struct hci_sco_hdr *sh; 455 456 switch (info->rx_state) { 457 458 case RECV_WAIT_EVENT_HEADER: 459 eh = hci_event_hdr(info->rx_skb); 460 info->rx_state = RECV_WAIT_DATA; 461 info->rx_count = eh->plen; 462 break; 463 464 case RECV_WAIT_ACL_HEADER: 465 ah = hci_acl_hdr(info->rx_skb); 466 dlen = __le16_to_cpu(ah->dlen); 467 info->rx_state = RECV_WAIT_DATA; 468 info->rx_count = dlen; 469 break; 470 471 case RECV_WAIT_SCO_HEADER: 472 sh = hci_sco_hdr(info->rx_skb); 473 info->rx_state = RECV_WAIT_DATA; 474 info->rx_count = sh->dlen; 475 break; 476 477 case RECV_WAIT_DATA: 478 hci_recv_frame(info->hdev, info->rx_skb); 479 info->rx_skb = NULL; 480 break; 481 482 } 483 484 } 485 486 } 487 488 489 } 490 491 info->hdev->stat.byte_rx += len; 492 } 493 494 495 static irqreturn_t bluecard_interrupt(int irq, void *dev_inst) 496 { 497 struct bluecard_info *info = dev_inst; 498 unsigned int iobase; 499 unsigned char reg; 500 501 if (!info || !info->hdev) 502 /* our irq handler is shared */ 503 return IRQ_NONE; 504 505 if (!test_bit(CARD_READY, &(info->hw_state))) 506 return IRQ_HANDLED; 507 508 iobase = info->p_dev->resource[0]->start; 509 510 spin_lock(&(info->lock)); 511 512 /* Disable interrupt */ 513 info->ctrl_reg &= ~REG_CONTROL_INTERRUPT; 514 outb(info->ctrl_reg, iobase + REG_CONTROL); 515 516 reg = inb(iobase + REG_INTERRUPT); 517 518 if ((reg != 0x00) && (reg != 0xff)) { 519 520 if (reg & 0x04) { 521 bluecard_receive(info, 0x00); 522 outb(0x04, iobase + REG_INTERRUPT); 523 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND); 524 } 525 526 if (reg & 0x08) { 527 bluecard_receive(info, 0x10); 528 outb(0x08, iobase + REG_INTERRUPT); 529 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND); 530 } 531 532 if (reg & 0x01) { 533 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 534 outb(0x01, iobase + REG_INTERRUPT); 535 bluecard_write_wakeup(info); 536 } 537 538 if (reg & 0x02) { 539 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 540 outb(0x02, iobase + REG_INTERRUPT); 541 bluecard_write_wakeup(info); 542 } 543 544 } 545 546 /* Enable interrupt */ 547 info->ctrl_reg |= REG_CONTROL_INTERRUPT; 548 outb(info->ctrl_reg, iobase + REG_CONTROL); 549 550 spin_unlock(&(info->lock)); 551 552 return IRQ_HANDLED; 553 } 554 555 556 557 /* ======================== Device specific HCI commands ======================== */ 558 559 560 static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud) 561 { 562 struct bluecard_info *info = hci_get_drvdata(hdev); 563 struct sk_buff *skb; 564 565 /* Ericsson baud rate command */ 566 unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 }; 567 568 skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC); 569 if (!skb) { 570 BT_ERR("Can't allocate mem for new packet"); 571 return -1; 572 } 573 574 switch (baud) { 575 case 460800: 576 cmd[4] = 0x00; 577 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_460800; 578 break; 579 case 230400: 580 cmd[4] = 0x01; 581 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_230400; 582 break; 583 case 115200: 584 cmd[4] = 0x02; 585 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_115200; 586 break; 587 case 57600: 588 /* Fall through... */ 589 default: 590 cmd[4] = 0x03; 591 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_57600; 592 break; 593 } 594 595 skb_put_data(skb, cmd, sizeof(cmd)); 596 597 skb_queue_tail(&(info->txq), skb); 598 599 bluecard_write_wakeup(info); 600 601 return 0; 602 } 603 604 605 606 /* ======================== HCI interface ======================== */ 607 608 609 static int bluecard_hci_flush(struct hci_dev *hdev) 610 { 611 struct bluecard_info *info = hci_get_drvdata(hdev); 612 613 /* Drop TX queue */ 614 skb_queue_purge(&(info->txq)); 615 616 return 0; 617 } 618 619 620 static int bluecard_hci_open(struct hci_dev *hdev) 621 { 622 struct bluecard_info *info = hci_get_drvdata(hdev); 623 unsigned int iobase = info->p_dev->resource[0]->start; 624 625 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 626 bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE); 627 628 /* Enable power LED */ 629 outb(0x08 | 0x20, iobase + 0x30); 630 631 return 0; 632 } 633 634 635 static int bluecard_hci_close(struct hci_dev *hdev) 636 { 637 struct bluecard_info *info = hci_get_drvdata(hdev); 638 unsigned int iobase = info->p_dev->resource[0]->start; 639 640 bluecard_hci_flush(hdev); 641 642 /* Stop LED timer */ 643 del_timer_sync(&(info->timer)); 644 645 /* Disable power LED */ 646 outb(0x00, iobase + 0x30); 647 648 return 0; 649 } 650 651 652 static int bluecard_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 653 { 654 struct bluecard_info *info = hci_get_drvdata(hdev); 655 656 switch (hci_skb_pkt_type(skb)) { 657 case HCI_COMMAND_PKT: 658 hdev->stat.cmd_tx++; 659 break; 660 case HCI_ACLDATA_PKT: 661 hdev->stat.acl_tx++; 662 break; 663 case HCI_SCODATA_PKT: 664 hdev->stat.sco_tx++; 665 break; 666 } 667 668 /* Prepend skb with frame type */ 669 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 670 skb_queue_tail(&(info->txq), skb); 671 672 bluecard_write_wakeup(info); 673 674 return 0; 675 } 676 677 678 679 /* ======================== Card services HCI interaction ======================== */ 680 681 682 static int bluecard_open(struct bluecard_info *info) 683 { 684 unsigned int iobase = info->p_dev->resource[0]->start; 685 struct hci_dev *hdev; 686 unsigned char id; 687 688 spin_lock_init(&(info->lock)); 689 690 timer_setup(&info->timer, bluecard_activity_led_timeout, 0); 691 692 skb_queue_head_init(&(info->txq)); 693 694 info->rx_state = RECV_WAIT_PACKET_TYPE; 695 info->rx_count = 0; 696 info->rx_skb = NULL; 697 698 /* Initialize HCI device */ 699 hdev = hci_alloc_dev(); 700 if (!hdev) { 701 BT_ERR("Can't allocate HCI device"); 702 return -ENOMEM; 703 } 704 705 info->hdev = hdev; 706 707 hdev->bus = HCI_PCCARD; 708 hci_set_drvdata(hdev, info); 709 SET_HCIDEV_DEV(hdev, &info->p_dev->dev); 710 711 hdev->open = bluecard_hci_open; 712 hdev->close = bluecard_hci_close; 713 hdev->flush = bluecard_hci_flush; 714 hdev->send = bluecard_hci_send_frame; 715 716 id = inb(iobase + 0x30); 717 718 if ((id & 0x0f) == 0x02) 719 set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)); 720 721 if (id & 0x10) 722 set_bit(CARD_HAS_POWER_LED, &(info->hw_state)); 723 724 if (id & 0x20) 725 set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state)); 726 727 /* Reset card */ 728 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; 729 outb(info->ctrl_reg, iobase + REG_CONTROL); 730 731 /* Turn FPGA off */ 732 outb(0x80, iobase + 0x30); 733 734 /* Wait some time */ 735 msleep(10); 736 737 /* Turn FPGA on */ 738 outb(0x00, iobase + 0x30); 739 740 /* Activate card */ 741 info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU; 742 outb(info->ctrl_reg, iobase + REG_CONTROL); 743 744 /* Enable interrupt */ 745 outb(0xff, iobase + REG_INTERRUPT); 746 info->ctrl_reg |= REG_CONTROL_INTERRUPT; 747 outb(info->ctrl_reg, iobase + REG_CONTROL); 748 749 if ((id & 0x0f) == 0x03) { 750 /* Disable RTS */ 751 info->ctrl_reg |= REG_CONTROL_RTS; 752 outb(info->ctrl_reg, iobase + REG_CONTROL); 753 754 /* Set baud rate */ 755 info->ctrl_reg |= 0x03; 756 outb(info->ctrl_reg, iobase + REG_CONTROL); 757 758 /* Enable RTS */ 759 info->ctrl_reg &= ~REG_CONTROL_RTS; 760 outb(info->ctrl_reg, iobase + REG_CONTROL); 761 762 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 763 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 764 set_bit(XMIT_SENDING_READY, &(info->tx_state)); 765 } 766 767 /* Start the RX buffers */ 768 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND); 769 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND); 770 771 /* Signal that the hardware is ready */ 772 set_bit(CARD_READY, &(info->hw_state)); 773 774 /* Drop TX queue */ 775 skb_queue_purge(&(info->txq)); 776 777 /* Control the point at which RTS is enabled */ 778 outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL); 779 780 /* Timeout before it is safe to send the first HCI packet */ 781 msleep(1250); 782 783 /* Register HCI device */ 784 if (hci_register_dev(hdev) < 0) { 785 BT_ERR("Can't register HCI device"); 786 info->hdev = NULL; 787 hci_free_dev(hdev); 788 return -ENODEV; 789 } 790 791 return 0; 792 } 793 794 795 static int bluecard_close(struct bluecard_info *info) 796 { 797 unsigned int iobase = info->p_dev->resource[0]->start; 798 struct hci_dev *hdev = info->hdev; 799 800 if (!hdev) 801 return -ENODEV; 802 803 bluecard_hci_close(hdev); 804 805 clear_bit(CARD_READY, &(info->hw_state)); 806 807 /* Reset card */ 808 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; 809 outb(info->ctrl_reg, iobase + REG_CONTROL); 810 811 /* Turn FPGA off */ 812 outb(0x80, iobase + 0x30); 813 814 hci_unregister_dev(hdev); 815 hci_free_dev(hdev); 816 817 return 0; 818 } 819 820 static int bluecard_probe(struct pcmcia_device *link) 821 { 822 struct bluecard_info *info; 823 824 /* Create new info device */ 825 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL); 826 if (!info) 827 return -ENOMEM; 828 829 info->p_dev = link; 830 link->priv = info; 831 832 link->config_flags |= CONF_ENABLE_IRQ; 833 834 return bluecard_config(link); 835 } 836 837 838 static void bluecard_detach(struct pcmcia_device *link) 839 { 840 bluecard_release(link); 841 } 842 843 844 static int bluecard_config(struct pcmcia_device *link) 845 { 846 struct bluecard_info *info = link->priv; 847 int i, n; 848 849 link->config_index = 0x20; 850 851 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; 852 link->resource[0]->end = 64; 853 link->io_lines = 6; 854 855 for (n = 0; n < 0x400; n += 0x40) { 856 link->resource[0]->start = n ^ 0x300; 857 i = pcmcia_request_io(link); 858 if (i == 0) 859 break; 860 } 861 862 if (i != 0) 863 goto failed; 864 865 i = pcmcia_request_irq(link, bluecard_interrupt); 866 if (i != 0) 867 goto failed; 868 869 i = pcmcia_enable_device(link); 870 if (i != 0) 871 goto failed; 872 873 if (bluecard_open(info) != 0) 874 goto failed; 875 876 return 0; 877 878 failed: 879 bluecard_release(link); 880 return -ENODEV; 881 } 882 883 884 static void bluecard_release(struct pcmcia_device *link) 885 { 886 struct bluecard_info *info = link->priv; 887 888 bluecard_close(info); 889 890 del_timer_sync(&(info->timer)); 891 892 pcmcia_disable_device(link); 893 } 894 895 static const struct pcmcia_device_id bluecard_ids[] = { 896 PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e), 897 PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c), 898 PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab), 899 PCMCIA_DEVICE_NULL 900 }; 901 MODULE_DEVICE_TABLE(pcmcia, bluecard_ids); 902 903 static struct pcmcia_driver bluecard_driver = { 904 .owner = THIS_MODULE, 905 .name = "bluecard_cs", 906 .probe = bluecard_probe, 907 .remove = bluecard_detach, 908 .id_table = bluecard_ids, 909 }; 910 module_pcmcia_driver(bluecard_driver); 911