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 default: 299 baud_reg = REG_CONTROL_BAUD_RATE_57600; 300 break; 301 } 302 303 /* Wait until the command reaches the baseband */ 304 mdelay(100); 305 306 /* Set baud on baseband */ 307 info->ctrl_reg &= ~0x03; 308 info->ctrl_reg |= baud_reg; 309 outb(info->ctrl_reg, iobase + REG_CONTROL); 310 311 /* Enable RTS */ 312 info->ctrl_reg &= ~REG_CONTROL_RTS; 313 outb(info->ctrl_reg, iobase + REG_CONTROL); 314 315 /* Wait before the next HCI packet can be send */ 316 mdelay(1000); 317 } 318 319 if (len == skb->len) { 320 kfree_skb(skb); 321 } else { 322 skb_pull(skb, len); 323 skb_queue_head(&(info->txq), skb); 324 } 325 326 info->hdev->stat.byte_tx += len; 327 328 /* Change buffer */ 329 change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state)); 330 331 } while (test_bit(XMIT_WAKEUP, &(info->tx_state))); 332 333 clear_bit(XMIT_SENDING, &(info->tx_state)); 334 } 335 336 337 static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size) 338 { 339 int i, n, len; 340 341 outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND); 342 343 len = inb(iobase + offset); 344 n = 0; 345 i = 1; 346 347 while (n < len) { 348 349 if (i == 16) { 350 outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND); 351 i = 0; 352 } 353 354 buf[n] = inb(iobase + offset + i); 355 356 n++; 357 i++; 358 359 } 360 361 return len; 362 } 363 364 365 static void bluecard_receive(struct bluecard_info *info, 366 unsigned int offset) 367 { 368 unsigned int iobase; 369 unsigned char buf[31]; 370 int i, len; 371 372 if (!info) { 373 BT_ERR("Unknown device"); 374 return; 375 } 376 377 iobase = info->p_dev->resource[0]->start; 378 379 if (test_bit(XMIT_SENDING_READY, &(info->tx_state))) 380 bluecard_enable_activity_led(info); 381 382 len = bluecard_read(iobase, offset, buf, sizeof(buf)); 383 384 for (i = 0; i < len; i++) { 385 386 /* Allocate packet */ 387 if (!info->rx_skb) { 388 info->rx_state = RECV_WAIT_PACKET_TYPE; 389 info->rx_count = 0; 390 info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC); 391 if (!info->rx_skb) { 392 BT_ERR("Can't allocate mem for new packet"); 393 return; 394 } 395 } 396 397 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 398 399 hci_skb_pkt_type(info->rx_skb) = buf[i]; 400 401 switch (hci_skb_pkt_type(info->rx_skb)) { 402 403 case 0x00: 404 /* init packet */ 405 if (offset != 0x00) { 406 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 407 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 408 set_bit(XMIT_SENDING_READY, &(info->tx_state)); 409 bluecard_write_wakeup(info); 410 } 411 412 kfree_skb(info->rx_skb); 413 info->rx_skb = NULL; 414 break; 415 416 case HCI_EVENT_PKT: 417 info->rx_state = RECV_WAIT_EVENT_HEADER; 418 info->rx_count = HCI_EVENT_HDR_SIZE; 419 break; 420 421 case HCI_ACLDATA_PKT: 422 info->rx_state = RECV_WAIT_ACL_HEADER; 423 info->rx_count = HCI_ACL_HDR_SIZE; 424 break; 425 426 case HCI_SCODATA_PKT: 427 info->rx_state = RECV_WAIT_SCO_HEADER; 428 info->rx_count = HCI_SCO_HDR_SIZE; 429 break; 430 431 default: 432 /* unknown packet */ 433 BT_ERR("Unknown HCI packet with type 0x%02x received", 434 hci_skb_pkt_type(info->rx_skb)); 435 info->hdev->stat.err_rx++; 436 437 kfree_skb(info->rx_skb); 438 info->rx_skb = NULL; 439 break; 440 441 } 442 443 } else { 444 445 skb_put_u8(info->rx_skb, buf[i]); 446 info->rx_count--; 447 448 if (info->rx_count == 0) { 449 450 int dlen; 451 struct hci_event_hdr *eh; 452 struct hci_acl_hdr *ah; 453 struct hci_sco_hdr *sh; 454 455 switch (info->rx_state) { 456 457 case RECV_WAIT_EVENT_HEADER: 458 eh = hci_event_hdr(info->rx_skb); 459 info->rx_state = RECV_WAIT_DATA; 460 info->rx_count = eh->plen; 461 break; 462 463 case RECV_WAIT_ACL_HEADER: 464 ah = hci_acl_hdr(info->rx_skb); 465 dlen = __le16_to_cpu(ah->dlen); 466 info->rx_state = RECV_WAIT_DATA; 467 info->rx_count = dlen; 468 break; 469 470 case RECV_WAIT_SCO_HEADER: 471 sh = hci_sco_hdr(info->rx_skb); 472 info->rx_state = RECV_WAIT_DATA; 473 info->rx_count = sh->dlen; 474 break; 475 476 case RECV_WAIT_DATA: 477 hci_recv_frame(info->hdev, info->rx_skb); 478 info->rx_skb = NULL; 479 break; 480 481 } 482 483 } 484 485 } 486 487 488 } 489 490 info->hdev->stat.byte_rx += len; 491 } 492 493 494 static irqreturn_t bluecard_interrupt(int irq, void *dev_inst) 495 { 496 struct bluecard_info *info = dev_inst; 497 unsigned int iobase; 498 unsigned char reg; 499 500 if (!info || !info->hdev) 501 /* our irq handler is shared */ 502 return IRQ_NONE; 503 504 if (!test_bit(CARD_READY, &(info->hw_state))) 505 return IRQ_HANDLED; 506 507 iobase = info->p_dev->resource[0]->start; 508 509 spin_lock(&(info->lock)); 510 511 /* Disable interrupt */ 512 info->ctrl_reg &= ~REG_CONTROL_INTERRUPT; 513 outb(info->ctrl_reg, iobase + REG_CONTROL); 514 515 reg = inb(iobase + REG_INTERRUPT); 516 517 if ((reg != 0x00) && (reg != 0xff)) { 518 519 if (reg & 0x04) { 520 bluecard_receive(info, 0x00); 521 outb(0x04, iobase + REG_INTERRUPT); 522 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND); 523 } 524 525 if (reg & 0x08) { 526 bluecard_receive(info, 0x10); 527 outb(0x08, iobase + REG_INTERRUPT); 528 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND); 529 } 530 531 if (reg & 0x01) { 532 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 533 outb(0x01, iobase + REG_INTERRUPT); 534 bluecard_write_wakeup(info); 535 } 536 537 if (reg & 0x02) { 538 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 539 outb(0x02, iobase + REG_INTERRUPT); 540 bluecard_write_wakeup(info); 541 } 542 543 } 544 545 /* Enable interrupt */ 546 info->ctrl_reg |= REG_CONTROL_INTERRUPT; 547 outb(info->ctrl_reg, iobase + REG_CONTROL); 548 549 spin_unlock(&(info->lock)); 550 551 return IRQ_HANDLED; 552 } 553 554 555 556 /* ======================== Device specific HCI commands ======================== */ 557 558 559 static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud) 560 { 561 struct bluecard_info *info = hci_get_drvdata(hdev); 562 struct sk_buff *skb; 563 564 /* Ericsson baud rate command */ 565 unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 }; 566 567 skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_KERNEL); 568 if (!skb) { 569 BT_ERR("Can't allocate mem for new packet"); 570 return -1; 571 } 572 573 switch (baud) { 574 case 460800: 575 cmd[4] = 0x00; 576 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_460800; 577 break; 578 case 230400: 579 cmd[4] = 0x01; 580 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_230400; 581 break; 582 case 115200: 583 cmd[4] = 0x02; 584 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_115200; 585 break; 586 case 57600: 587 default: 588 cmd[4] = 0x03; 589 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_57600; 590 break; 591 } 592 593 skb_put_data(skb, cmd, sizeof(cmd)); 594 595 skb_queue_tail(&(info->txq), skb); 596 597 bluecard_write_wakeup(info); 598 599 return 0; 600 } 601 602 603 604 /* ======================== HCI interface ======================== */ 605 606 607 static int bluecard_hci_flush(struct hci_dev *hdev) 608 { 609 struct bluecard_info *info = hci_get_drvdata(hdev); 610 611 /* Drop TX queue */ 612 skb_queue_purge(&(info->txq)); 613 614 return 0; 615 } 616 617 618 static int bluecard_hci_open(struct hci_dev *hdev) 619 { 620 struct bluecard_info *info = hci_get_drvdata(hdev); 621 unsigned int iobase = info->p_dev->resource[0]->start; 622 623 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 624 bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE); 625 626 /* Enable power LED */ 627 outb(0x08 | 0x20, iobase + 0x30); 628 629 return 0; 630 } 631 632 633 static int bluecard_hci_close(struct hci_dev *hdev) 634 { 635 struct bluecard_info *info = hci_get_drvdata(hdev); 636 unsigned int iobase = info->p_dev->resource[0]->start; 637 638 bluecard_hci_flush(hdev); 639 640 /* Stop LED timer */ 641 del_timer_sync(&(info->timer)); 642 643 /* Disable power LED */ 644 outb(0x00, iobase + 0x30); 645 646 return 0; 647 } 648 649 650 static int bluecard_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 651 { 652 struct bluecard_info *info = hci_get_drvdata(hdev); 653 654 switch (hci_skb_pkt_type(skb)) { 655 case HCI_COMMAND_PKT: 656 hdev->stat.cmd_tx++; 657 break; 658 case HCI_ACLDATA_PKT: 659 hdev->stat.acl_tx++; 660 break; 661 case HCI_SCODATA_PKT: 662 hdev->stat.sco_tx++; 663 break; 664 } 665 666 /* Prepend skb with frame type */ 667 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 668 skb_queue_tail(&(info->txq), skb); 669 670 bluecard_write_wakeup(info); 671 672 return 0; 673 } 674 675 676 677 /* ======================== Card services HCI interaction ======================== */ 678 679 680 static int bluecard_open(struct bluecard_info *info) 681 { 682 unsigned int iobase = info->p_dev->resource[0]->start; 683 struct hci_dev *hdev; 684 unsigned char id; 685 686 spin_lock_init(&(info->lock)); 687 688 timer_setup(&info->timer, bluecard_activity_led_timeout, 0); 689 690 skb_queue_head_init(&(info->txq)); 691 692 info->rx_state = RECV_WAIT_PACKET_TYPE; 693 info->rx_count = 0; 694 info->rx_skb = NULL; 695 696 /* Initialize HCI device */ 697 hdev = hci_alloc_dev(); 698 if (!hdev) { 699 BT_ERR("Can't allocate HCI device"); 700 return -ENOMEM; 701 } 702 703 info->hdev = hdev; 704 705 hdev->bus = HCI_PCCARD; 706 hci_set_drvdata(hdev, info); 707 SET_HCIDEV_DEV(hdev, &info->p_dev->dev); 708 709 hdev->open = bluecard_hci_open; 710 hdev->close = bluecard_hci_close; 711 hdev->flush = bluecard_hci_flush; 712 hdev->send = bluecard_hci_send_frame; 713 714 id = inb(iobase + 0x30); 715 716 if ((id & 0x0f) == 0x02) 717 set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)); 718 719 if (id & 0x10) 720 set_bit(CARD_HAS_POWER_LED, &(info->hw_state)); 721 722 if (id & 0x20) 723 set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state)); 724 725 /* Reset card */ 726 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; 727 outb(info->ctrl_reg, iobase + REG_CONTROL); 728 729 /* Turn FPGA off */ 730 outb(0x80, iobase + 0x30); 731 732 /* Wait some time */ 733 msleep(10); 734 735 /* Turn FPGA on */ 736 outb(0x00, iobase + 0x30); 737 738 /* Activate card */ 739 info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU; 740 outb(info->ctrl_reg, iobase + REG_CONTROL); 741 742 /* Enable interrupt */ 743 outb(0xff, iobase + REG_INTERRUPT); 744 info->ctrl_reg |= REG_CONTROL_INTERRUPT; 745 outb(info->ctrl_reg, iobase + REG_CONTROL); 746 747 if ((id & 0x0f) == 0x03) { 748 /* Disable RTS */ 749 info->ctrl_reg |= REG_CONTROL_RTS; 750 outb(info->ctrl_reg, iobase + REG_CONTROL); 751 752 /* Set baud rate */ 753 info->ctrl_reg |= 0x03; 754 outb(info->ctrl_reg, iobase + REG_CONTROL); 755 756 /* Enable RTS */ 757 info->ctrl_reg &= ~REG_CONTROL_RTS; 758 outb(info->ctrl_reg, iobase + REG_CONTROL); 759 760 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 761 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 762 set_bit(XMIT_SENDING_READY, &(info->tx_state)); 763 } 764 765 /* Start the RX buffers */ 766 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND); 767 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND); 768 769 /* Signal that the hardware is ready */ 770 set_bit(CARD_READY, &(info->hw_state)); 771 772 /* Drop TX queue */ 773 skb_queue_purge(&(info->txq)); 774 775 /* Control the point at which RTS is enabled */ 776 outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL); 777 778 /* Timeout before it is safe to send the first HCI packet */ 779 msleep(1250); 780 781 /* Register HCI device */ 782 if (hci_register_dev(hdev) < 0) { 783 BT_ERR("Can't register HCI device"); 784 info->hdev = NULL; 785 hci_free_dev(hdev); 786 return -ENODEV; 787 } 788 789 return 0; 790 } 791 792 793 static int bluecard_close(struct bluecard_info *info) 794 { 795 unsigned int iobase = info->p_dev->resource[0]->start; 796 struct hci_dev *hdev = info->hdev; 797 798 if (!hdev) 799 return -ENODEV; 800 801 bluecard_hci_close(hdev); 802 803 clear_bit(CARD_READY, &(info->hw_state)); 804 805 /* Reset card */ 806 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; 807 outb(info->ctrl_reg, iobase + REG_CONTROL); 808 809 /* Turn FPGA off */ 810 outb(0x80, iobase + 0x30); 811 812 hci_unregister_dev(hdev); 813 hci_free_dev(hdev); 814 815 return 0; 816 } 817 818 static int bluecard_probe(struct pcmcia_device *link) 819 { 820 struct bluecard_info *info; 821 822 /* Create new info device */ 823 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL); 824 if (!info) 825 return -ENOMEM; 826 827 info->p_dev = link; 828 link->priv = info; 829 830 link->config_flags |= CONF_ENABLE_IRQ; 831 832 return bluecard_config(link); 833 } 834 835 836 static void bluecard_detach(struct pcmcia_device *link) 837 { 838 bluecard_release(link); 839 } 840 841 842 static int bluecard_config(struct pcmcia_device *link) 843 { 844 struct bluecard_info *info = link->priv; 845 int i, n; 846 847 link->config_index = 0x20; 848 849 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; 850 link->resource[0]->end = 64; 851 link->io_lines = 6; 852 853 for (n = 0; n < 0x400; n += 0x40) { 854 link->resource[0]->start = n ^ 0x300; 855 i = pcmcia_request_io(link); 856 if (i == 0) 857 break; 858 } 859 860 if (i != 0) 861 goto failed; 862 863 i = pcmcia_request_irq(link, bluecard_interrupt); 864 if (i != 0) 865 goto failed; 866 867 i = pcmcia_enable_device(link); 868 if (i != 0) 869 goto failed; 870 871 if (bluecard_open(info) != 0) 872 goto failed; 873 874 return 0; 875 876 failed: 877 bluecard_release(link); 878 return -ENODEV; 879 } 880 881 882 static void bluecard_release(struct pcmcia_device *link) 883 { 884 struct bluecard_info *info = link->priv; 885 886 bluecard_close(info); 887 888 del_timer_sync(&(info->timer)); 889 890 pcmcia_disable_device(link); 891 } 892 893 static const struct pcmcia_device_id bluecard_ids[] = { 894 PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e), 895 PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c), 896 PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab), 897 PCMCIA_DEVICE_NULL 898 }; 899 MODULE_DEVICE_TABLE(pcmcia, bluecard_ids); 900 901 static struct pcmcia_driver bluecard_driver = { 902 .owner = THIS_MODULE, 903 .name = "bluecard_cs", 904 .probe = bluecard_probe, 905 .remove = bluecard_detach, 906 .id_table = bluecard_ids, 907 }; 908 module_pcmcia_driver(bluecard_driver); 909