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 <asm/io.h> 41 42 #include <pcmcia/cs_types.h> 43 #include <pcmcia/cs.h> 44 #include <pcmcia/cistpl.h> 45 #include <pcmcia/ciscode.h> 46 #include <pcmcia/ds.h> 47 #include <pcmcia/cisreg.h> 48 49 #include <net/bluetooth/bluetooth.h> 50 #include <net/bluetooth/hci_core.h> 51 52 53 54 /* ======================== Module parameters ======================== */ 55 56 57 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 58 MODULE_DESCRIPTION("Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)"); 59 MODULE_LICENSE("GPL"); 60 61 62 63 /* ======================== Local structures ======================== */ 64 65 66 typedef struct bluecard_info_t { 67 struct pcmcia_device *p_dev; 68 dev_node_t node; 69 70 struct hci_dev *hdev; 71 72 spinlock_t lock; /* For serializing operations */ 73 struct timer_list timer; /* For LED control */ 74 75 struct sk_buff_head txq; 76 unsigned long tx_state; 77 78 unsigned long rx_state; 79 unsigned long rx_count; 80 struct sk_buff *rx_skb; 81 82 unsigned char ctrl_reg; 83 unsigned long hw_state; /* Status of the hardware and LED control */ 84 } bluecard_info_t; 85 86 87 static int bluecard_config(struct pcmcia_device *link); 88 static void bluecard_release(struct pcmcia_device *link); 89 90 static void bluecard_detach(struct pcmcia_device *p_dev); 91 92 93 /* Default baud rate: 57600, 115200, 230400 or 460800 */ 94 #define DEFAULT_BAUD_RATE 230400 95 96 97 /* Hardware states */ 98 #define CARD_READY 1 99 #define CARD_HAS_PCCARD_ID 4 100 #define CARD_HAS_POWER_LED 5 101 #define CARD_HAS_ACTIVITY_LED 6 102 103 /* Transmit states */ 104 #define XMIT_SENDING 1 105 #define XMIT_WAKEUP 2 106 #define XMIT_BUFFER_NUMBER 5 /* unset = buffer one, set = buffer two */ 107 #define XMIT_BUF_ONE_READY 6 108 #define XMIT_BUF_TWO_READY 7 109 #define XMIT_SENDING_READY 8 110 111 /* Receiver states */ 112 #define RECV_WAIT_PACKET_TYPE 0 113 #define RECV_WAIT_EVENT_HEADER 1 114 #define RECV_WAIT_ACL_HEADER 2 115 #define RECV_WAIT_SCO_HEADER 3 116 #define RECV_WAIT_DATA 4 117 118 /* Special packet types */ 119 #define PKT_BAUD_RATE_57600 0x80 120 #define PKT_BAUD_RATE_115200 0x81 121 #define PKT_BAUD_RATE_230400 0x82 122 #define PKT_BAUD_RATE_460800 0x83 123 124 125 /* These are the register offsets */ 126 #define REG_COMMAND 0x20 127 #define REG_INTERRUPT 0x21 128 #define REG_CONTROL 0x22 129 #define REG_RX_CONTROL 0x24 130 #define REG_CARD_RESET 0x30 131 #define REG_LED_CTRL 0x30 132 133 /* REG_COMMAND */ 134 #define REG_COMMAND_TX_BUF_ONE 0x01 135 #define REG_COMMAND_TX_BUF_TWO 0x02 136 #define REG_COMMAND_RX_BUF_ONE 0x04 137 #define REG_COMMAND_RX_BUF_TWO 0x08 138 #define REG_COMMAND_RX_WIN_ONE 0x00 139 #define REG_COMMAND_RX_WIN_TWO 0x10 140 141 /* REG_CONTROL */ 142 #define REG_CONTROL_BAUD_RATE_57600 0x00 143 #define REG_CONTROL_BAUD_RATE_115200 0x01 144 #define REG_CONTROL_BAUD_RATE_230400 0x02 145 #define REG_CONTROL_BAUD_RATE_460800 0x03 146 #define REG_CONTROL_RTS 0x04 147 #define REG_CONTROL_BT_ON 0x08 148 #define REG_CONTROL_BT_RESET 0x10 149 #define REG_CONTROL_BT_RES_PU 0x20 150 #define REG_CONTROL_INTERRUPT 0x40 151 #define REG_CONTROL_CARD_RESET 0x80 152 153 /* REG_RX_CONTROL */ 154 #define RTS_LEVEL_SHIFT_BITS 0x02 155 156 157 158 /* ======================== LED handling routines ======================== */ 159 160 161 static void bluecard_activity_led_timeout(u_long arg) 162 { 163 bluecard_info_t *info = (bluecard_info_t *)arg; 164 unsigned int iobase = info->p_dev->io.BasePort1; 165 166 if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 167 return; 168 169 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) { 170 /* Disable activity LED */ 171 outb(0x08 | 0x20, iobase + 0x30); 172 } else { 173 /* Disable power LED */ 174 outb(0x00, iobase + 0x30); 175 } 176 } 177 178 179 static void bluecard_enable_activity_led(bluecard_info_t *info) 180 { 181 unsigned int iobase = info->p_dev->io.BasePort1; 182 183 if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 184 return; 185 186 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) { 187 /* Enable activity LED */ 188 outb(0x10 | 0x40, iobase + 0x30); 189 190 /* Stop the LED after HZ/4 */ 191 mod_timer(&(info->timer), jiffies + HZ / 4); 192 } else { 193 /* Enable power LED */ 194 outb(0x08 | 0x20, iobase + 0x30); 195 196 /* Stop the LED after HZ/2 */ 197 mod_timer(&(info->timer), jiffies + HZ / 2); 198 } 199 } 200 201 202 203 /* ======================== Interrupt handling ======================== */ 204 205 206 static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len) 207 { 208 int i, actual; 209 210 actual = (len > 15) ? 15 : len; 211 212 outb_p(actual, iobase + offset); 213 214 for (i = 0; i < actual; i++) 215 outb_p(buf[i], iobase + offset + i + 1); 216 217 return actual; 218 } 219 220 221 static void bluecard_write_wakeup(bluecard_info_t *info) 222 { 223 if (!info) { 224 BT_ERR("Unknown device"); 225 return; 226 } 227 228 if (!test_bit(XMIT_SENDING_READY, &(info->tx_state))) 229 return; 230 231 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) { 232 set_bit(XMIT_WAKEUP, &(info->tx_state)); 233 return; 234 } 235 236 do { 237 register unsigned int iobase = info->p_dev->io.BasePort1; 238 register unsigned int offset; 239 register unsigned char command; 240 register unsigned long ready_bit; 241 register struct sk_buff *skb; 242 register int len; 243 244 clear_bit(XMIT_WAKEUP, &(info->tx_state)); 245 246 if (!pcmcia_dev_present(info->p_dev)) 247 return; 248 249 if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) { 250 if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state))) 251 break; 252 offset = 0x10; 253 command = REG_COMMAND_TX_BUF_TWO; 254 ready_bit = XMIT_BUF_TWO_READY; 255 } else { 256 if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state))) 257 break; 258 offset = 0x00; 259 command = REG_COMMAND_TX_BUF_ONE; 260 ready_bit = XMIT_BUF_ONE_READY; 261 } 262 263 if (!(skb = skb_dequeue(&(info->txq)))) 264 break; 265 266 if (bt_cb(skb)->pkt_type & 0x80) { 267 /* Disable RTS */ 268 info->ctrl_reg |= REG_CONTROL_RTS; 269 outb(info->ctrl_reg, iobase + REG_CONTROL); 270 } 271 272 /* Activate LED */ 273 bluecard_enable_activity_led(info); 274 275 /* Send frame */ 276 len = bluecard_write(iobase, offset, skb->data, skb->len); 277 278 /* Tell the FPGA to send the data */ 279 outb_p(command, iobase + REG_COMMAND); 280 281 /* Mark the buffer as dirty */ 282 clear_bit(ready_bit, &(info->tx_state)); 283 284 if (bt_cb(skb)->pkt_type & 0x80) { 285 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 286 DEFINE_WAIT(wait); 287 288 unsigned char baud_reg; 289 290 switch (bt_cb(skb)->pkt_type) { 291 case PKT_BAUD_RATE_460800: 292 baud_reg = REG_CONTROL_BAUD_RATE_460800; 293 break; 294 case PKT_BAUD_RATE_230400: 295 baud_reg = REG_CONTROL_BAUD_RATE_230400; 296 break; 297 case PKT_BAUD_RATE_115200: 298 baud_reg = REG_CONTROL_BAUD_RATE_115200; 299 break; 300 case PKT_BAUD_RATE_57600: 301 /* Fall through... */ 302 default: 303 baud_reg = REG_CONTROL_BAUD_RATE_57600; 304 break; 305 } 306 307 /* Wait until the command reaches the baseband */ 308 prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE); 309 schedule_timeout(HZ/10); 310 finish_wait(&wq, &wait); 311 312 /* Set baud on baseband */ 313 info->ctrl_reg &= ~0x03; 314 info->ctrl_reg |= baud_reg; 315 outb(info->ctrl_reg, iobase + REG_CONTROL); 316 317 /* Enable RTS */ 318 info->ctrl_reg &= ~REG_CONTROL_RTS; 319 outb(info->ctrl_reg, iobase + REG_CONTROL); 320 321 /* Wait before the next HCI packet can be send */ 322 prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE); 323 schedule_timeout(HZ); 324 finish_wait(&wq, &wait); 325 } 326 327 if (len == skb->len) { 328 kfree_skb(skb); 329 } else { 330 skb_pull(skb, len); 331 skb_queue_head(&(info->txq), skb); 332 } 333 334 info->hdev->stat.byte_tx += len; 335 336 /* Change buffer */ 337 change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state)); 338 339 } while (test_bit(XMIT_WAKEUP, &(info->tx_state))); 340 341 clear_bit(XMIT_SENDING, &(info->tx_state)); 342 } 343 344 345 static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size) 346 { 347 int i, n, len; 348 349 outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND); 350 351 len = inb(iobase + offset); 352 n = 0; 353 i = 1; 354 355 while (n < len) { 356 357 if (i == 16) { 358 outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND); 359 i = 0; 360 } 361 362 buf[n] = inb(iobase + offset + i); 363 364 n++; 365 i++; 366 367 } 368 369 return len; 370 } 371 372 373 static void bluecard_receive(bluecard_info_t *info, unsigned int offset) 374 { 375 unsigned int iobase; 376 unsigned char buf[31]; 377 int i, len; 378 379 if (!info) { 380 BT_ERR("Unknown device"); 381 return; 382 } 383 384 iobase = info->p_dev->io.BasePort1; 385 386 if (test_bit(XMIT_SENDING_READY, &(info->tx_state))) 387 bluecard_enable_activity_led(info); 388 389 len = bluecard_read(iobase, offset, buf, sizeof(buf)); 390 391 for (i = 0; i < len; i++) { 392 393 /* Allocate packet */ 394 if (info->rx_skb == NULL) { 395 info->rx_state = RECV_WAIT_PACKET_TYPE; 396 info->rx_count = 0; 397 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) { 398 BT_ERR("Can't allocate mem for new packet"); 399 return; 400 } 401 } 402 403 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 404 405 info->rx_skb->dev = (void *) info->hdev; 406 bt_cb(info->rx_skb)->pkt_type = buf[i]; 407 408 switch (bt_cb(info->rx_skb)->pkt_type) { 409 410 case 0x00: 411 /* init packet */ 412 if (offset != 0x00) { 413 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 414 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 415 set_bit(XMIT_SENDING_READY, &(info->tx_state)); 416 bluecard_write_wakeup(info); 417 } 418 419 kfree_skb(info->rx_skb); 420 info->rx_skb = NULL; 421 break; 422 423 case HCI_EVENT_PKT: 424 info->rx_state = RECV_WAIT_EVENT_HEADER; 425 info->rx_count = HCI_EVENT_HDR_SIZE; 426 break; 427 428 case HCI_ACLDATA_PKT: 429 info->rx_state = RECV_WAIT_ACL_HEADER; 430 info->rx_count = HCI_ACL_HDR_SIZE; 431 break; 432 433 case HCI_SCODATA_PKT: 434 info->rx_state = RECV_WAIT_SCO_HEADER; 435 info->rx_count = HCI_SCO_HDR_SIZE; 436 break; 437 438 default: 439 /* unknown packet */ 440 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type); 441 info->hdev->stat.err_rx++; 442 443 kfree_skb(info->rx_skb); 444 info->rx_skb = NULL; 445 break; 446 447 } 448 449 } else { 450 451 *skb_put(info->rx_skb, 1) = buf[i]; 452 info->rx_count--; 453 454 if (info->rx_count == 0) { 455 456 int dlen; 457 struct hci_event_hdr *eh; 458 struct hci_acl_hdr *ah; 459 struct hci_sco_hdr *sh; 460 461 switch (info->rx_state) { 462 463 case RECV_WAIT_EVENT_HEADER: 464 eh = hci_event_hdr(info->rx_skb); 465 info->rx_state = RECV_WAIT_DATA; 466 info->rx_count = eh->plen; 467 break; 468 469 case RECV_WAIT_ACL_HEADER: 470 ah = hci_acl_hdr(info->rx_skb); 471 dlen = __le16_to_cpu(ah->dlen); 472 info->rx_state = RECV_WAIT_DATA; 473 info->rx_count = dlen; 474 break; 475 476 case RECV_WAIT_SCO_HEADER: 477 sh = hci_sco_hdr(info->rx_skb); 478 info->rx_state = RECV_WAIT_DATA; 479 info->rx_count = sh->dlen; 480 break; 481 482 case RECV_WAIT_DATA: 483 hci_recv_frame(info->rx_skb); 484 info->rx_skb = NULL; 485 break; 486 487 } 488 489 } 490 491 } 492 493 494 } 495 496 info->hdev->stat.byte_rx += len; 497 } 498 499 500 static irqreturn_t bluecard_interrupt(int irq, void *dev_inst) 501 { 502 bluecard_info_t *info = dev_inst; 503 unsigned int iobase; 504 unsigned char reg; 505 506 BUG_ON(!info->hdev); 507 508 if (!test_bit(CARD_READY, &(info->hw_state))) 509 return IRQ_HANDLED; 510 511 iobase = info->p_dev->io.BasePort1; 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->io.BasePort1; 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->io.BasePort1; 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->io.BasePort1; 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->type = 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->io.BasePort1; 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->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 869 link->io.NumPorts1 = 8; 870 link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT; 871 link->irq.IRQInfo1 = IRQ_LEVEL_ID; 872 873 link->irq.Handler = bluecard_interrupt; 874 link->irq.Instance = info; 875 876 link->conf.Attributes = CONF_ENABLE_IRQ; 877 link->conf.IntType = INT_MEMORY_AND_IO; 878 879 return bluecard_config(link); 880 } 881 882 883 static void bluecard_detach(struct pcmcia_device *link) 884 { 885 bluecard_info_t *info = link->priv; 886 887 bluecard_release(link); 888 kfree(info); 889 } 890 891 892 static int bluecard_config(struct pcmcia_device *link) 893 { 894 bluecard_info_t *info = link->priv; 895 int i, n; 896 897 link->conf.ConfigIndex = 0x20; 898 link->io.NumPorts1 = 64; 899 link->io.IOAddrLines = 6; 900 901 for (n = 0; n < 0x400; n += 0x40) { 902 link->io.BasePort1 = n ^ 0x300; 903 i = pcmcia_request_io(link, &link->io); 904 if (i == 0) 905 break; 906 } 907 908 if (i != 0) { 909 cs_error(link, RequestIO, i); 910 goto failed; 911 } 912 913 i = pcmcia_request_irq(link, &link->irq); 914 if (i != 0) { 915 cs_error(link, RequestIRQ, i); 916 link->irq.AssignedIRQ = 0; 917 } 918 919 i = pcmcia_request_configuration(link, &link->conf); 920 if (i != 0) { 921 cs_error(link, RequestConfiguration, i); 922 goto failed; 923 } 924 925 if (bluecard_open(info) != 0) 926 goto failed; 927 928 strcpy(info->node.dev_name, info->hdev->name); 929 link->dev_node = &info->node; 930 931 return 0; 932 933 failed: 934 bluecard_release(link); 935 return -ENODEV; 936 } 937 938 939 static void bluecard_release(struct pcmcia_device *link) 940 { 941 bluecard_info_t *info = link->priv; 942 943 bluecard_close(info); 944 945 del_timer(&(info->timer)); 946 947 pcmcia_disable_device(link); 948 } 949 950 static struct pcmcia_device_id bluecard_ids[] = { 951 PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e), 952 PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c), 953 PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab), 954 PCMCIA_DEVICE_NULL 955 }; 956 MODULE_DEVICE_TABLE(pcmcia, bluecard_ids); 957 958 static struct pcmcia_driver bluecard_driver = { 959 .owner = THIS_MODULE, 960 .drv = { 961 .name = "bluecard_cs", 962 }, 963 .probe = bluecard_probe, 964 .remove = bluecard_detach, 965 .id_table = bluecard_ids, 966 }; 967 968 static int __init init_bluecard_cs(void) 969 { 970 return pcmcia_register_driver(&bluecard_driver); 971 } 972 973 974 static void __exit exit_bluecard_cs(void) 975 { 976 pcmcia_unregister_driver(&bluecard_driver); 977 } 978 979 module_init(init_bluecard_cs); 980 module_exit(exit_bluecard_cs); 981