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/cs.h> 43 #include <pcmcia/cistpl.h> 44 #include <pcmcia/ciscode.h> 45 #include <pcmcia/ds.h> 46 #include <pcmcia/cisreg.h> 47 48 #include <net/bluetooth/bluetooth.h> 49 #include <net/bluetooth/hci_core.h> 50 51 52 53 /* ======================== Module parameters ======================== */ 54 55 56 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 57 MODULE_DESCRIPTION("Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)"); 58 MODULE_LICENSE("GPL"); 59 60 61 62 /* ======================== Local structures ======================== */ 63 64 65 typedef struct bluecard_info_t { 66 struct pcmcia_device *p_dev; 67 68 struct hci_dev *hdev; 69 70 spinlock_t lock; /* For serializing operations */ 71 struct timer_list timer; /* For LED control */ 72 73 struct sk_buff_head txq; 74 unsigned long tx_state; 75 76 unsigned long rx_state; 77 unsigned long rx_count; 78 struct sk_buff *rx_skb; 79 80 unsigned char ctrl_reg; 81 unsigned long hw_state; /* Status of the hardware and LED control */ 82 } bluecard_info_t; 83 84 85 static int bluecard_config(struct pcmcia_device *link); 86 static void bluecard_release(struct pcmcia_device *link); 87 88 static void bluecard_detach(struct pcmcia_device *p_dev); 89 90 91 /* Default baud rate: 57600, 115200, 230400 or 460800 */ 92 #define DEFAULT_BAUD_RATE 230400 93 94 95 /* Hardware states */ 96 #define CARD_READY 1 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(u_long arg) 160 { 161 bluecard_info_t *info = (bluecard_info_t *)arg; 162 unsigned int iobase = info->p_dev->resource[0]->start; 163 164 if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 165 return; 166 167 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) { 168 /* Disable activity LED */ 169 outb(0x08 | 0x20, iobase + 0x30); 170 } else { 171 /* Disable power LED */ 172 outb(0x00, iobase + 0x30); 173 } 174 } 175 176 177 static void bluecard_enable_activity_led(bluecard_info_t *info) 178 { 179 unsigned int iobase = info->p_dev->resource[0]->start; 180 181 if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 182 return; 183 184 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) { 185 /* Enable activity LED */ 186 outb(0x10 | 0x40, iobase + 0x30); 187 188 /* Stop the LED after HZ/4 */ 189 mod_timer(&(info->timer), jiffies + HZ / 4); 190 } else { 191 /* Enable power LED */ 192 outb(0x08 | 0x20, iobase + 0x30); 193 194 /* Stop the LED after HZ/2 */ 195 mod_timer(&(info->timer), jiffies + HZ / 2); 196 } 197 } 198 199 200 201 /* ======================== Interrupt handling ======================== */ 202 203 204 static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len) 205 { 206 int i, actual; 207 208 actual = (len > 15) ? 15 : len; 209 210 outb_p(actual, iobase + offset); 211 212 for (i = 0; i < actual; i++) 213 outb_p(buf[i], iobase + offset + i + 1); 214 215 return actual; 216 } 217 218 219 static void bluecard_write_wakeup(bluecard_info_t *info) 220 { 221 if (!info) { 222 BT_ERR("Unknown device"); 223 return; 224 } 225 226 if (!test_bit(XMIT_SENDING_READY, &(info->tx_state))) 227 return; 228 229 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) { 230 set_bit(XMIT_WAKEUP, &(info->tx_state)); 231 return; 232 } 233 234 do { 235 register unsigned int iobase = info->p_dev->resource[0]->start; 236 register unsigned int offset; 237 register unsigned char command; 238 register unsigned long ready_bit; 239 register struct sk_buff *skb; 240 register int len; 241 242 clear_bit(XMIT_WAKEUP, &(info->tx_state)); 243 244 if (!pcmcia_dev_present(info->p_dev)) 245 return; 246 247 if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) { 248 if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state))) 249 break; 250 offset = 0x10; 251 command = REG_COMMAND_TX_BUF_TWO; 252 ready_bit = XMIT_BUF_TWO_READY; 253 } else { 254 if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state))) 255 break; 256 offset = 0x00; 257 command = REG_COMMAND_TX_BUF_ONE; 258 ready_bit = XMIT_BUF_ONE_READY; 259 } 260 261 if (!(skb = skb_dequeue(&(info->txq)))) 262 break; 263 264 if (bt_cb(skb)->pkt_type & 0x80) { 265 /* Disable RTS */ 266 info->ctrl_reg |= REG_CONTROL_RTS; 267 outb(info->ctrl_reg, iobase + REG_CONTROL); 268 } 269 270 /* Activate LED */ 271 bluecard_enable_activity_led(info); 272 273 /* Send frame */ 274 len = bluecard_write(iobase, offset, skb->data, skb->len); 275 276 /* Tell the FPGA to send the data */ 277 outb_p(command, iobase + REG_COMMAND); 278 279 /* Mark the buffer as dirty */ 280 clear_bit(ready_bit, &(info->tx_state)); 281 282 if (bt_cb(skb)->pkt_type & 0x80) { 283 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 284 DEFINE_WAIT(wait); 285 286 unsigned char baud_reg; 287 288 switch (bt_cb(skb)->pkt_type) { 289 case PKT_BAUD_RATE_460800: 290 baud_reg = REG_CONTROL_BAUD_RATE_460800; 291 break; 292 case PKT_BAUD_RATE_230400: 293 baud_reg = REG_CONTROL_BAUD_RATE_230400; 294 break; 295 case PKT_BAUD_RATE_115200: 296 baud_reg = REG_CONTROL_BAUD_RATE_115200; 297 break; 298 case PKT_BAUD_RATE_57600: 299 /* Fall through... */ 300 default: 301 baud_reg = REG_CONTROL_BAUD_RATE_57600; 302 break; 303 } 304 305 /* Wait until the command reaches the baseband */ 306 prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE); 307 schedule_timeout(HZ/10); 308 finish_wait(&wq, &wait); 309 310 /* Set baud on baseband */ 311 info->ctrl_reg &= ~0x03; 312 info->ctrl_reg |= baud_reg; 313 outb(info->ctrl_reg, iobase + REG_CONTROL); 314 315 /* Enable RTS */ 316 info->ctrl_reg &= ~REG_CONTROL_RTS; 317 outb(info->ctrl_reg, iobase + REG_CONTROL); 318 319 /* Wait before the next HCI packet can be send */ 320 prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE); 321 schedule_timeout(HZ); 322 finish_wait(&wq, &wait); 323 } 324 325 if (len == skb->len) { 326 kfree_skb(skb); 327 } else { 328 skb_pull(skb, len); 329 skb_queue_head(&(info->txq), skb); 330 } 331 332 info->hdev->stat.byte_tx += len; 333 334 /* Change buffer */ 335 change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state)); 336 337 } while (test_bit(XMIT_WAKEUP, &(info->tx_state))); 338 339 clear_bit(XMIT_SENDING, &(info->tx_state)); 340 } 341 342 343 static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size) 344 { 345 int i, n, len; 346 347 outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND); 348 349 len = inb(iobase + offset); 350 n = 0; 351 i = 1; 352 353 while (n < len) { 354 355 if (i == 16) { 356 outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND); 357 i = 0; 358 } 359 360 buf[n] = inb(iobase + offset + i); 361 362 n++; 363 i++; 364 365 } 366 367 return len; 368 } 369 370 371 static void bluecard_receive(bluecard_info_t *info, unsigned int offset) 372 { 373 unsigned int iobase; 374 unsigned char buf[31]; 375 int i, len; 376 377 if (!info) { 378 BT_ERR("Unknown device"); 379 return; 380 } 381 382 iobase = info->p_dev->resource[0]->start; 383 384 if (test_bit(XMIT_SENDING_READY, &(info->tx_state))) 385 bluecard_enable_activity_led(info); 386 387 len = bluecard_read(iobase, offset, buf, sizeof(buf)); 388 389 for (i = 0; i < len; i++) { 390 391 /* Allocate packet */ 392 if (info->rx_skb == NULL) { 393 info->rx_state = RECV_WAIT_PACKET_TYPE; 394 info->rx_count = 0; 395 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) { 396 BT_ERR("Can't allocate mem for new packet"); 397 return; 398 } 399 } 400 401 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 402 403 info->rx_skb->dev = (void *) info->hdev; 404 bt_cb(info->rx_skb)->pkt_type = buf[i]; 405 406 switch (bt_cb(info->rx_skb)->pkt_type) { 407 408 case 0x00: 409 /* init packet */ 410 if (offset != 0x00) { 411 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 412 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 413 set_bit(XMIT_SENDING_READY, &(info->tx_state)); 414 bluecard_write_wakeup(info); 415 } 416 417 kfree_skb(info->rx_skb); 418 info->rx_skb = NULL; 419 break; 420 421 case HCI_EVENT_PKT: 422 info->rx_state = RECV_WAIT_EVENT_HEADER; 423 info->rx_count = HCI_EVENT_HDR_SIZE; 424 break; 425 426 case HCI_ACLDATA_PKT: 427 info->rx_state = RECV_WAIT_ACL_HEADER; 428 info->rx_count = HCI_ACL_HDR_SIZE; 429 break; 430 431 case HCI_SCODATA_PKT: 432 info->rx_state = RECV_WAIT_SCO_HEADER; 433 info->rx_count = HCI_SCO_HDR_SIZE; 434 break; 435 436 default: 437 /* unknown packet */ 438 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type); 439 info->hdev->stat.err_rx++; 440 441 kfree_skb(info->rx_skb); 442 info->rx_skb = NULL; 443 break; 444 445 } 446 447 } else { 448 449 *skb_put(info->rx_skb, 1) = buf[i]; 450 info->rx_count--; 451 452 if (info->rx_count == 0) { 453 454 int dlen; 455 struct hci_event_hdr *eh; 456 struct hci_acl_hdr *ah; 457 struct hci_sco_hdr *sh; 458 459 switch (info->rx_state) { 460 461 case RECV_WAIT_EVENT_HEADER: 462 eh = hci_event_hdr(info->rx_skb); 463 info->rx_state = RECV_WAIT_DATA; 464 info->rx_count = eh->plen; 465 break; 466 467 case RECV_WAIT_ACL_HEADER: 468 ah = hci_acl_hdr(info->rx_skb); 469 dlen = __le16_to_cpu(ah->dlen); 470 info->rx_state = RECV_WAIT_DATA; 471 info->rx_count = dlen; 472 break; 473 474 case RECV_WAIT_SCO_HEADER: 475 sh = hci_sco_hdr(info->rx_skb); 476 info->rx_state = RECV_WAIT_DATA; 477 info->rx_count = sh->dlen; 478 break; 479 480 case RECV_WAIT_DATA: 481 hci_recv_frame(info->rx_skb); 482 info->rx_skb = NULL; 483 break; 484 485 } 486 487 } 488 489 } 490 491 492 } 493 494 info->hdev->stat.byte_rx += len; 495 } 496 497 498 static irqreturn_t bluecard_interrupt(int irq, void *dev_inst) 499 { 500 bluecard_info_t *info = dev_inst; 501 unsigned int iobase; 502 unsigned char reg; 503 504 if (!info || !info->hdev) 505 /* our irq handler is shared */ 506 return IRQ_NONE; 507 508 if (!test_bit(CARD_READY, &(info->hw_state))) 509 return IRQ_HANDLED; 510 511 iobase = info->p_dev->resource[0]->start; 512 513 spin_lock(&(info->lock)); 514 515 /* Disable interrupt */ 516 info->ctrl_reg &= ~REG_CONTROL_INTERRUPT; 517 outb(info->ctrl_reg, iobase + REG_CONTROL); 518 519 reg = inb(iobase + REG_INTERRUPT); 520 521 if ((reg != 0x00) && (reg != 0xff)) { 522 523 if (reg & 0x04) { 524 bluecard_receive(info, 0x00); 525 outb(0x04, iobase + REG_INTERRUPT); 526 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND); 527 } 528 529 if (reg & 0x08) { 530 bluecard_receive(info, 0x10); 531 outb(0x08, iobase + REG_INTERRUPT); 532 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND); 533 } 534 535 if (reg & 0x01) { 536 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 537 outb(0x01, iobase + REG_INTERRUPT); 538 bluecard_write_wakeup(info); 539 } 540 541 if (reg & 0x02) { 542 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 543 outb(0x02, iobase + REG_INTERRUPT); 544 bluecard_write_wakeup(info); 545 } 546 547 } 548 549 /* Enable interrupt */ 550 info->ctrl_reg |= REG_CONTROL_INTERRUPT; 551 outb(info->ctrl_reg, iobase + REG_CONTROL); 552 553 spin_unlock(&(info->lock)); 554 555 return IRQ_HANDLED; 556 } 557 558 559 560 /* ======================== Device specific HCI commands ======================== */ 561 562 563 static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud) 564 { 565 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 566 struct sk_buff *skb; 567 568 /* Ericsson baud rate command */ 569 unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 }; 570 571 if (!(skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) { 572 BT_ERR("Can't allocate mem for new packet"); 573 return -1; 574 } 575 576 switch (baud) { 577 case 460800: 578 cmd[4] = 0x00; 579 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_460800; 580 break; 581 case 230400: 582 cmd[4] = 0x01; 583 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_230400; 584 break; 585 case 115200: 586 cmd[4] = 0x02; 587 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_115200; 588 break; 589 case 57600: 590 /* Fall through... */ 591 default: 592 cmd[4] = 0x03; 593 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_57600; 594 break; 595 } 596 597 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd)); 598 599 skb_queue_tail(&(info->txq), skb); 600 601 bluecard_write_wakeup(info); 602 603 return 0; 604 } 605 606 607 608 /* ======================== HCI interface ======================== */ 609 610 611 static int bluecard_hci_flush(struct hci_dev *hdev) 612 { 613 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 614 615 /* Drop TX queue */ 616 skb_queue_purge(&(info->txq)); 617 618 return 0; 619 } 620 621 622 static int bluecard_hci_open(struct hci_dev *hdev) 623 { 624 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 625 unsigned int iobase = info->p_dev->resource[0]->start; 626 627 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 628 bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE); 629 630 if (test_and_set_bit(HCI_RUNNING, &(hdev->flags))) 631 return 0; 632 633 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) { 634 /* Enable LED */ 635 outb(0x08 | 0x20, iobase + 0x30); 636 } 637 638 return 0; 639 } 640 641 642 static int bluecard_hci_close(struct hci_dev *hdev) 643 { 644 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 645 unsigned int iobase = info->p_dev->resource[0]->start; 646 647 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags))) 648 return 0; 649 650 bluecard_hci_flush(hdev); 651 652 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) { 653 /* Disable LED */ 654 outb(0x00, iobase + 0x30); 655 } 656 657 return 0; 658 } 659 660 661 static int bluecard_hci_send_frame(struct sk_buff *skb) 662 { 663 bluecard_info_t *info; 664 struct hci_dev *hdev = (struct hci_dev *)(skb->dev); 665 666 if (!hdev) { 667 BT_ERR("Frame for unknown HCI device (hdev=NULL)"); 668 return -ENODEV; 669 } 670 671 info = (bluecard_info_t *)(hdev->driver_data); 672 673 switch (bt_cb(skb)->pkt_type) { 674 case HCI_COMMAND_PKT: 675 hdev->stat.cmd_tx++; 676 break; 677 case HCI_ACLDATA_PKT: 678 hdev->stat.acl_tx++; 679 break; 680 case HCI_SCODATA_PKT: 681 hdev->stat.sco_tx++; 682 break; 683 }; 684 685 /* Prepend skb with frame type */ 686 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 687 skb_queue_tail(&(info->txq), skb); 688 689 bluecard_write_wakeup(info); 690 691 return 0; 692 } 693 694 695 static void bluecard_hci_destruct(struct hci_dev *hdev) 696 { 697 } 698 699 700 static int bluecard_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg) 701 { 702 return -ENOIOCTLCMD; 703 } 704 705 706 707 /* ======================== Card services HCI interaction ======================== */ 708 709 710 static int bluecard_open(bluecard_info_t *info) 711 { 712 unsigned int iobase = info->p_dev->resource[0]->start; 713 struct hci_dev *hdev; 714 unsigned char id; 715 716 spin_lock_init(&(info->lock)); 717 718 init_timer(&(info->timer)); 719 info->timer.function = &bluecard_activity_led_timeout; 720 info->timer.data = (u_long)info; 721 722 skb_queue_head_init(&(info->txq)); 723 724 info->rx_state = RECV_WAIT_PACKET_TYPE; 725 info->rx_count = 0; 726 info->rx_skb = NULL; 727 728 /* Initialize HCI device */ 729 hdev = hci_alloc_dev(); 730 if (!hdev) { 731 BT_ERR("Can't allocate HCI device"); 732 return -ENOMEM; 733 } 734 735 info->hdev = hdev; 736 737 hdev->bus = HCI_PCCARD; 738 hdev->driver_data = info; 739 SET_HCIDEV_DEV(hdev, &info->p_dev->dev); 740 741 hdev->open = bluecard_hci_open; 742 hdev->close = bluecard_hci_close; 743 hdev->flush = bluecard_hci_flush; 744 hdev->send = bluecard_hci_send_frame; 745 hdev->destruct = bluecard_hci_destruct; 746 hdev->ioctl = bluecard_hci_ioctl; 747 748 hdev->owner = THIS_MODULE; 749 750 id = inb(iobase + 0x30); 751 752 if ((id & 0x0f) == 0x02) 753 set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)); 754 755 if (id & 0x10) 756 set_bit(CARD_HAS_POWER_LED, &(info->hw_state)); 757 758 if (id & 0x20) 759 set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state)); 760 761 /* Reset card */ 762 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; 763 outb(info->ctrl_reg, iobase + REG_CONTROL); 764 765 /* Turn FPGA off */ 766 outb(0x80, iobase + 0x30); 767 768 /* Wait some time */ 769 msleep(10); 770 771 /* Turn FPGA on */ 772 outb(0x00, iobase + 0x30); 773 774 /* Activate card */ 775 info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU; 776 outb(info->ctrl_reg, iobase + REG_CONTROL); 777 778 /* Enable interrupt */ 779 outb(0xff, iobase + REG_INTERRUPT); 780 info->ctrl_reg |= REG_CONTROL_INTERRUPT; 781 outb(info->ctrl_reg, iobase + REG_CONTROL); 782 783 if ((id & 0x0f) == 0x03) { 784 /* Disable RTS */ 785 info->ctrl_reg |= REG_CONTROL_RTS; 786 outb(info->ctrl_reg, iobase + REG_CONTROL); 787 788 /* Set baud rate */ 789 info->ctrl_reg |= 0x03; 790 outb(info->ctrl_reg, iobase + REG_CONTROL); 791 792 /* Enable RTS */ 793 info->ctrl_reg &= ~REG_CONTROL_RTS; 794 outb(info->ctrl_reg, iobase + REG_CONTROL); 795 796 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 797 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 798 set_bit(XMIT_SENDING_READY, &(info->tx_state)); 799 } 800 801 /* Start the RX buffers */ 802 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND); 803 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND); 804 805 /* Signal that the hardware is ready */ 806 set_bit(CARD_READY, &(info->hw_state)); 807 808 /* Drop TX queue */ 809 skb_queue_purge(&(info->txq)); 810 811 /* Control the point at which RTS is enabled */ 812 outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL); 813 814 /* Timeout before it is safe to send the first HCI packet */ 815 msleep(1250); 816 817 /* Register HCI device */ 818 if (hci_register_dev(hdev) < 0) { 819 BT_ERR("Can't register HCI device"); 820 info->hdev = NULL; 821 hci_free_dev(hdev); 822 return -ENODEV; 823 } 824 825 return 0; 826 } 827 828 829 static int bluecard_close(bluecard_info_t *info) 830 { 831 unsigned int iobase = info->p_dev->resource[0]->start; 832 struct hci_dev *hdev = info->hdev; 833 834 if (!hdev) 835 return -ENODEV; 836 837 bluecard_hci_close(hdev); 838 839 clear_bit(CARD_READY, &(info->hw_state)); 840 841 /* Reset card */ 842 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; 843 outb(info->ctrl_reg, iobase + REG_CONTROL); 844 845 /* Turn FPGA off */ 846 outb(0x80, iobase + 0x30); 847 848 if (hci_unregister_dev(hdev) < 0) 849 BT_ERR("Can't unregister HCI device %s", hdev->name); 850 851 hci_free_dev(hdev); 852 853 return 0; 854 } 855 856 static int bluecard_probe(struct pcmcia_device *link) 857 { 858 bluecard_info_t *info; 859 860 /* Create new info device */ 861 info = kzalloc(sizeof(*info), GFP_KERNEL); 862 if (!info) 863 return -ENOMEM; 864 865 info->p_dev = link; 866 link->priv = info; 867 868 link->conf.Attributes = CONF_ENABLE_IRQ; 869 link->conf.IntType = INT_MEMORY_AND_IO; 870 871 return bluecard_config(link); 872 } 873 874 875 static void bluecard_detach(struct pcmcia_device *link) 876 { 877 bluecard_info_t *info = link->priv; 878 879 bluecard_release(link); 880 kfree(info); 881 } 882 883 884 static int bluecard_config(struct pcmcia_device *link) 885 { 886 bluecard_info_t *info = link->priv; 887 int i, n; 888 889 link->conf.ConfigIndex = 0x20; 890 891 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; 892 link->resource[0]->end = 64; 893 link->io_lines = 6; 894 895 for (n = 0; n < 0x400; n += 0x40) { 896 link->resource[0]->start = n ^ 0x300; 897 i = pcmcia_request_io(link); 898 if (i == 0) 899 break; 900 } 901 902 if (i != 0) 903 goto failed; 904 905 i = pcmcia_request_irq(link, bluecard_interrupt); 906 if (i != 0) 907 goto failed; 908 909 i = pcmcia_request_configuration(link, &link->conf); 910 if (i != 0) 911 goto failed; 912 913 if (bluecard_open(info) != 0) 914 goto failed; 915 916 return 0; 917 918 failed: 919 bluecard_release(link); 920 return -ENODEV; 921 } 922 923 924 static void bluecard_release(struct pcmcia_device *link) 925 { 926 bluecard_info_t *info = link->priv; 927 928 bluecard_close(info); 929 930 del_timer(&(info->timer)); 931 932 pcmcia_disable_device(link); 933 } 934 935 static struct pcmcia_device_id bluecard_ids[] = { 936 PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e), 937 PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c), 938 PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab), 939 PCMCIA_DEVICE_NULL 940 }; 941 MODULE_DEVICE_TABLE(pcmcia, bluecard_ids); 942 943 static struct pcmcia_driver bluecard_driver = { 944 .owner = THIS_MODULE, 945 .drv = { 946 .name = "bluecard_cs", 947 }, 948 .probe = bluecard_probe, 949 .remove = bluecard_detach, 950 .id_table = bluecard_ids, 951 }; 952 953 static int __init init_bluecard_cs(void) 954 { 955 return pcmcia_register_driver(&bluecard_driver); 956 } 957 958 959 static void __exit exit_bluecard_cs(void) 960 { 961 pcmcia_unregister_driver(&bluecard_driver); 962 } 963 964 module_init(init_bluecard_cs); 965 module_exit(exit_bluecard_cs); 966