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 if (!info || !info->hdev) 507 /* our irq handler is shared */ 508 return IRQ_NONE; 509 510 if (!test_bit(CARD_READY, &(info->hw_state))) 511 return IRQ_HANDLED; 512 513 iobase = info->p_dev->io.BasePort1; 514 515 spin_lock(&(info->lock)); 516 517 /* Disable interrupt */ 518 info->ctrl_reg &= ~REG_CONTROL_INTERRUPT; 519 outb(info->ctrl_reg, iobase + REG_CONTROL); 520 521 reg = inb(iobase + REG_INTERRUPT); 522 523 if ((reg != 0x00) && (reg != 0xff)) { 524 525 if (reg & 0x04) { 526 bluecard_receive(info, 0x00); 527 outb(0x04, iobase + REG_INTERRUPT); 528 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND); 529 } 530 531 if (reg & 0x08) { 532 bluecard_receive(info, 0x10); 533 outb(0x08, iobase + REG_INTERRUPT); 534 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND); 535 } 536 537 if (reg & 0x01) { 538 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 539 outb(0x01, iobase + REG_INTERRUPT); 540 bluecard_write_wakeup(info); 541 } 542 543 if (reg & 0x02) { 544 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 545 outb(0x02, iobase + REG_INTERRUPT); 546 bluecard_write_wakeup(info); 547 } 548 549 } 550 551 /* Enable interrupt */ 552 info->ctrl_reg |= REG_CONTROL_INTERRUPT; 553 outb(info->ctrl_reg, iobase + REG_CONTROL); 554 555 spin_unlock(&(info->lock)); 556 557 return IRQ_HANDLED; 558 } 559 560 561 562 /* ======================== Device specific HCI commands ======================== */ 563 564 565 static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud) 566 { 567 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 568 struct sk_buff *skb; 569 570 /* Ericsson baud rate command */ 571 unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 }; 572 573 if (!(skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) { 574 BT_ERR("Can't allocate mem for new packet"); 575 return -1; 576 } 577 578 switch (baud) { 579 case 460800: 580 cmd[4] = 0x00; 581 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_460800; 582 break; 583 case 230400: 584 cmd[4] = 0x01; 585 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_230400; 586 break; 587 case 115200: 588 cmd[4] = 0x02; 589 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_115200; 590 break; 591 case 57600: 592 /* Fall through... */ 593 default: 594 cmd[4] = 0x03; 595 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_57600; 596 break; 597 } 598 599 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd)); 600 601 skb_queue_tail(&(info->txq), skb); 602 603 bluecard_write_wakeup(info); 604 605 return 0; 606 } 607 608 609 610 /* ======================== HCI interface ======================== */ 611 612 613 static int bluecard_hci_flush(struct hci_dev *hdev) 614 { 615 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 616 617 /* Drop TX queue */ 618 skb_queue_purge(&(info->txq)); 619 620 return 0; 621 } 622 623 624 static int bluecard_hci_open(struct hci_dev *hdev) 625 { 626 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 627 unsigned int iobase = info->p_dev->io.BasePort1; 628 629 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 630 bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE); 631 632 if (test_and_set_bit(HCI_RUNNING, &(hdev->flags))) 633 return 0; 634 635 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) { 636 /* Enable LED */ 637 outb(0x08 | 0x20, iobase + 0x30); 638 } 639 640 return 0; 641 } 642 643 644 static int bluecard_hci_close(struct hci_dev *hdev) 645 { 646 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 647 unsigned int iobase = info->p_dev->io.BasePort1; 648 649 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags))) 650 return 0; 651 652 bluecard_hci_flush(hdev); 653 654 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) { 655 /* Disable LED */ 656 outb(0x00, iobase + 0x30); 657 } 658 659 return 0; 660 } 661 662 663 static int bluecard_hci_send_frame(struct sk_buff *skb) 664 { 665 bluecard_info_t *info; 666 struct hci_dev *hdev = (struct hci_dev *)(skb->dev); 667 668 if (!hdev) { 669 BT_ERR("Frame for unknown HCI device (hdev=NULL)"); 670 return -ENODEV; 671 } 672 673 info = (bluecard_info_t *)(hdev->driver_data); 674 675 switch (bt_cb(skb)->pkt_type) { 676 case HCI_COMMAND_PKT: 677 hdev->stat.cmd_tx++; 678 break; 679 case HCI_ACLDATA_PKT: 680 hdev->stat.acl_tx++; 681 break; 682 case HCI_SCODATA_PKT: 683 hdev->stat.sco_tx++; 684 break; 685 }; 686 687 /* Prepend skb with frame type */ 688 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 689 skb_queue_tail(&(info->txq), skb); 690 691 bluecard_write_wakeup(info); 692 693 return 0; 694 } 695 696 697 static void bluecard_hci_destruct(struct hci_dev *hdev) 698 { 699 } 700 701 702 static int bluecard_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg) 703 { 704 return -ENOIOCTLCMD; 705 } 706 707 708 709 /* ======================== Card services HCI interaction ======================== */ 710 711 712 static int bluecard_open(bluecard_info_t *info) 713 { 714 unsigned int iobase = info->p_dev->io.BasePort1; 715 struct hci_dev *hdev; 716 unsigned char id; 717 718 spin_lock_init(&(info->lock)); 719 720 init_timer(&(info->timer)); 721 info->timer.function = &bluecard_activity_led_timeout; 722 info->timer.data = (u_long)info; 723 724 skb_queue_head_init(&(info->txq)); 725 726 info->rx_state = RECV_WAIT_PACKET_TYPE; 727 info->rx_count = 0; 728 info->rx_skb = NULL; 729 730 /* Initialize HCI device */ 731 hdev = hci_alloc_dev(); 732 if (!hdev) { 733 BT_ERR("Can't allocate HCI device"); 734 return -ENOMEM; 735 } 736 737 info->hdev = hdev; 738 739 hdev->type = HCI_PCCARD; 740 hdev->driver_data = info; 741 SET_HCIDEV_DEV(hdev, &info->p_dev->dev); 742 743 hdev->open = bluecard_hci_open; 744 hdev->close = bluecard_hci_close; 745 hdev->flush = bluecard_hci_flush; 746 hdev->send = bluecard_hci_send_frame; 747 hdev->destruct = bluecard_hci_destruct; 748 hdev->ioctl = bluecard_hci_ioctl; 749 750 hdev->owner = THIS_MODULE; 751 752 id = inb(iobase + 0x30); 753 754 if ((id & 0x0f) == 0x02) 755 set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)); 756 757 if (id & 0x10) 758 set_bit(CARD_HAS_POWER_LED, &(info->hw_state)); 759 760 if (id & 0x20) 761 set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state)); 762 763 /* Reset card */ 764 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; 765 outb(info->ctrl_reg, iobase + REG_CONTROL); 766 767 /* Turn FPGA off */ 768 outb(0x80, iobase + 0x30); 769 770 /* Wait some time */ 771 msleep(10); 772 773 /* Turn FPGA on */ 774 outb(0x00, iobase + 0x30); 775 776 /* Activate card */ 777 info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU; 778 outb(info->ctrl_reg, iobase + REG_CONTROL); 779 780 /* Enable interrupt */ 781 outb(0xff, iobase + REG_INTERRUPT); 782 info->ctrl_reg |= REG_CONTROL_INTERRUPT; 783 outb(info->ctrl_reg, iobase + REG_CONTROL); 784 785 if ((id & 0x0f) == 0x03) { 786 /* Disable RTS */ 787 info->ctrl_reg |= REG_CONTROL_RTS; 788 outb(info->ctrl_reg, iobase + REG_CONTROL); 789 790 /* Set baud rate */ 791 info->ctrl_reg |= 0x03; 792 outb(info->ctrl_reg, iobase + REG_CONTROL); 793 794 /* Enable RTS */ 795 info->ctrl_reg &= ~REG_CONTROL_RTS; 796 outb(info->ctrl_reg, iobase + REG_CONTROL); 797 798 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 799 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 800 set_bit(XMIT_SENDING_READY, &(info->tx_state)); 801 } 802 803 /* Start the RX buffers */ 804 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND); 805 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND); 806 807 /* Signal that the hardware is ready */ 808 set_bit(CARD_READY, &(info->hw_state)); 809 810 /* Drop TX queue */ 811 skb_queue_purge(&(info->txq)); 812 813 /* Control the point at which RTS is enabled */ 814 outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL); 815 816 /* Timeout before it is safe to send the first HCI packet */ 817 msleep(1250); 818 819 /* Register HCI device */ 820 if (hci_register_dev(hdev) < 0) { 821 BT_ERR("Can't register HCI device"); 822 info->hdev = NULL; 823 hci_free_dev(hdev); 824 return -ENODEV; 825 } 826 827 return 0; 828 } 829 830 831 static int bluecard_close(bluecard_info_t *info) 832 { 833 unsigned int iobase = info->p_dev->io.BasePort1; 834 struct hci_dev *hdev = info->hdev; 835 836 if (!hdev) 837 return -ENODEV; 838 839 bluecard_hci_close(hdev); 840 841 clear_bit(CARD_READY, &(info->hw_state)); 842 843 /* Reset card */ 844 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; 845 outb(info->ctrl_reg, iobase + REG_CONTROL); 846 847 /* Turn FPGA off */ 848 outb(0x80, iobase + 0x30); 849 850 if (hci_unregister_dev(hdev) < 0) 851 BT_ERR("Can't unregister HCI device %s", hdev->name); 852 853 hci_free_dev(hdev); 854 855 return 0; 856 } 857 858 static int bluecard_probe(struct pcmcia_device *link) 859 { 860 bluecard_info_t *info; 861 862 /* Create new info device */ 863 info = kzalloc(sizeof(*info), GFP_KERNEL); 864 if (!info) 865 return -ENOMEM; 866 867 info->p_dev = link; 868 link->priv = info; 869 870 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 871 link->io.NumPorts1 = 8; 872 link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING; 873 874 link->irq.Handler = bluecard_interrupt; 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 goto failed; 910 911 i = pcmcia_request_irq(link, &link->irq); 912 if (i != 0) 913 link->irq.AssignedIRQ = 0; 914 915 i = pcmcia_request_configuration(link, &link->conf); 916 if (i != 0) 917 goto failed; 918 919 if (bluecard_open(info) != 0) 920 goto failed; 921 922 strcpy(info->node.dev_name, info->hdev->name); 923 link->dev_node = &info->node; 924 925 return 0; 926 927 failed: 928 bluecard_release(link); 929 return -ENODEV; 930 } 931 932 933 static void bluecard_release(struct pcmcia_device *link) 934 { 935 bluecard_info_t *info = link->priv; 936 937 bluecard_close(info); 938 939 del_timer(&(info->timer)); 940 941 pcmcia_disable_device(link); 942 } 943 944 static struct pcmcia_device_id bluecard_ids[] = { 945 PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e), 946 PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c), 947 PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab), 948 PCMCIA_DEVICE_NULL 949 }; 950 MODULE_DEVICE_TABLE(pcmcia, bluecard_ids); 951 952 static struct pcmcia_driver bluecard_driver = { 953 .owner = THIS_MODULE, 954 .drv = { 955 .name = "bluecard_cs", 956 }, 957 .probe = bluecard_probe, 958 .remove = bluecard_detach, 959 .id_table = bluecard_ids, 960 }; 961 962 static int __init init_bluecard_cs(void) 963 { 964 return pcmcia_register_driver(&bluecard_driver); 965 } 966 967 968 static void __exit exit_bluecard_cs(void) 969 { 970 pcmcia_unregister_driver(&bluecard_driver); 971 } 972 973 module_init(init_bluecard_cs); 974 module_exit(exit_bluecard_cs); 975