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/config.h> 24 #include <linux/module.h> 25 26 #include <linux/kernel.h> 27 #include <linux/init.h> 28 #include <linux/slab.h> 29 #include <linux/types.h> 30 #include <linux/sched.h> 31 #include <linux/delay.h> 32 #include <linux/timer.h> 33 #include <linux/errno.h> 34 #include <linux/ptrace.h> 35 #include <linux/ioport.h> 36 #include <linux/spinlock.h> 37 #include <linux/moduleparam.h> 38 #include <linux/wait.h> 39 40 #include <linux/skbuff.h> 41 #include <asm/io.h> 42 43 #include <pcmcia/version.h> 44 #include <pcmcia/cs_types.h> 45 #include <pcmcia/cs.h> 46 #include <pcmcia/cistpl.h> 47 #include <pcmcia/ciscode.h> 48 #include <pcmcia/ds.h> 49 #include <pcmcia/cisreg.h> 50 51 #include <net/bluetooth/bluetooth.h> 52 #include <net/bluetooth/hci_core.h> 53 54 55 56 /* ======================== Module parameters ======================== */ 57 58 59 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 60 MODULE_DESCRIPTION("Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)"); 61 MODULE_LICENSE("GPL"); 62 63 64 65 /* ======================== Local structures ======================== */ 66 67 68 typedef struct bluecard_info_t { 69 dev_link_t link; 70 dev_node_t node; 71 72 struct hci_dev *hdev; 73 74 spinlock_t lock; /* For serializing operations */ 75 struct timer_list timer; /* For LED control */ 76 77 struct sk_buff_head txq; 78 unsigned long tx_state; 79 80 unsigned long rx_state; 81 unsigned long rx_count; 82 struct sk_buff *rx_skb; 83 84 unsigned char ctrl_reg; 85 unsigned long hw_state; /* Status of the hardware and LED control */ 86 } bluecard_info_t; 87 88 89 static void bluecard_config(dev_link_t *link); 90 static void bluecard_release(dev_link_t *link); 91 static int bluecard_event(event_t event, int priority, event_callback_args_t *args); 92 93 static dev_info_t dev_info = "bluecard_cs"; 94 95 static dev_link_t *bluecard_attach(void); 96 static void bluecard_detach(dev_link_t *); 97 98 static dev_link_t *dev_list = NULL; 99 100 101 /* Default baud rate: 57600, 115200, 230400 or 460800 */ 102 #define DEFAULT_BAUD_RATE 230400 103 104 105 /* Hardware states */ 106 #define CARD_READY 1 107 #define CARD_HAS_PCCARD_ID 4 108 #define CARD_HAS_POWER_LED 5 109 #define CARD_HAS_ACTIVITY_LED 6 110 111 /* Transmit states */ 112 #define XMIT_SENDING 1 113 #define XMIT_WAKEUP 2 114 #define XMIT_BUFFER_NUMBER 5 /* unset = buffer one, set = buffer two */ 115 #define XMIT_BUF_ONE_READY 6 116 #define XMIT_BUF_TWO_READY 7 117 #define XMIT_SENDING_READY 8 118 119 /* Receiver states */ 120 #define RECV_WAIT_PACKET_TYPE 0 121 #define RECV_WAIT_EVENT_HEADER 1 122 #define RECV_WAIT_ACL_HEADER 2 123 #define RECV_WAIT_SCO_HEADER 3 124 #define RECV_WAIT_DATA 4 125 126 /* Special packet types */ 127 #define PKT_BAUD_RATE_57600 0x80 128 #define PKT_BAUD_RATE_115200 0x81 129 #define PKT_BAUD_RATE_230400 0x82 130 #define PKT_BAUD_RATE_460800 0x83 131 132 133 /* These are the register offsets */ 134 #define REG_COMMAND 0x20 135 #define REG_INTERRUPT 0x21 136 #define REG_CONTROL 0x22 137 #define REG_RX_CONTROL 0x24 138 #define REG_CARD_RESET 0x30 139 #define REG_LED_CTRL 0x30 140 141 /* REG_COMMAND */ 142 #define REG_COMMAND_TX_BUF_ONE 0x01 143 #define REG_COMMAND_TX_BUF_TWO 0x02 144 #define REG_COMMAND_RX_BUF_ONE 0x04 145 #define REG_COMMAND_RX_BUF_TWO 0x08 146 #define REG_COMMAND_RX_WIN_ONE 0x00 147 #define REG_COMMAND_RX_WIN_TWO 0x10 148 149 /* REG_CONTROL */ 150 #define REG_CONTROL_BAUD_RATE_57600 0x00 151 #define REG_CONTROL_BAUD_RATE_115200 0x01 152 #define REG_CONTROL_BAUD_RATE_230400 0x02 153 #define REG_CONTROL_BAUD_RATE_460800 0x03 154 #define REG_CONTROL_RTS 0x04 155 #define REG_CONTROL_BT_ON 0x08 156 #define REG_CONTROL_BT_RESET 0x10 157 #define REG_CONTROL_BT_RES_PU 0x20 158 #define REG_CONTROL_INTERRUPT 0x40 159 #define REG_CONTROL_CARD_RESET 0x80 160 161 /* REG_RX_CONTROL */ 162 #define RTS_LEVEL_SHIFT_BITS 0x02 163 164 165 166 /* ======================== LED handling routines ======================== */ 167 168 169 static void bluecard_activity_led_timeout(u_long arg) 170 { 171 bluecard_info_t *info = (bluecard_info_t *)arg; 172 unsigned int iobase = info->link.io.BasePort1; 173 174 if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 175 return; 176 177 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) { 178 /* Disable activity LED */ 179 outb(0x08 | 0x20, iobase + 0x30); 180 } else { 181 /* Disable power LED */ 182 outb(0x00, iobase + 0x30); 183 } 184 } 185 186 187 static void bluecard_enable_activity_led(bluecard_info_t *info) 188 { 189 unsigned int iobase = info->link.io.BasePort1; 190 191 if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 192 return; 193 194 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) { 195 /* Enable activity LED */ 196 outb(0x10 | 0x40, iobase + 0x30); 197 198 /* Stop the LED after HZ/4 */ 199 mod_timer(&(info->timer), jiffies + HZ / 4); 200 } else { 201 /* Enable power LED */ 202 outb(0x08 | 0x20, iobase + 0x30); 203 204 /* Stop the LED after HZ/2 */ 205 mod_timer(&(info->timer), jiffies + HZ / 2); 206 } 207 } 208 209 210 211 /* ======================== Interrupt handling ======================== */ 212 213 214 static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len) 215 { 216 int i, actual; 217 218 actual = (len > 15) ? 15 : len; 219 220 outb_p(actual, iobase + offset); 221 222 for (i = 0; i < actual; i++) 223 outb_p(buf[i], iobase + offset + i + 1); 224 225 return actual; 226 } 227 228 229 static void bluecard_write_wakeup(bluecard_info_t *info) 230 { 231 if (!info) { 232 BT_ERR("Unknown device"); 233 return; 234 } 235 236 if (!test_bit(XMIT_SENDING_READY, &(info->tx_state))) 237 return; 238 239 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) { 240 set_bit(XMIT_WAKEUP, &(info->tx_state)); 241 return; 242 } 243 244 do { 245 register unsigned int iobase = info->link.io.BasePort1; 246 register unsigned int offset; 247 register unsigned char command; 248 register unsigned long ready_bit; 249 register struct sk_buff *skb; 250 register int len; 251 252 clear_bit(XMIT_WAKEUP, &(info->tx_state)); 253 254 if (!(info->link.state & DEV_PRESENT)) 255 return; 256 257 if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) { 258 if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state))) 259 break; 260 offset = 0x10; 261 command = REG_COMMAND_TX_BUF_TWO; 262 ready_bit = XMIT_BUF_TWO_READY; 263 } else { 264 if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state))) 265 break; 266 offset = 0x00; 267 command = REG_COMMAND_TX_BUF_ONE; 268 ready_bit = XMIT_BUF_ONE_READY; 269 } 270 271 if (!(skb = skb_dequeue(&(info->txq)))) 272 break; 273 274 if (skb->pkt_type & 0x80) { 275 /* Disable RTS */ 276 info->ctrl_reg |= REG_CONTROL_RTS; 277 outb(info->ctrl_reg, iobase + REG_CONTROL); 278 } 279 280 /* Activate LED */ 281 bluecard_enable_activity_led(info); 282 283 /* Send frame */ 284 len = bluecard_write(iobase, offset, skb->data, skb->len); 285 286 /* Tell the FPGA to send the data */ 287 outb_p(command, iobase + REG_COMMAND); 288 289 /* Mark the buffer as dirty */ 290 clear_bit(ready_bit, &(info->tx_state)); 291 292 if (skb->pkt_type & 0x80) { 293 DECLARE_WAIT_QUEUE_HEAD(wq); 294 DEFINE_WAIT(wait); 295 296 unsigned char baud_reg; 297 298 switch (skb->pkt_type) { 299 case PKT_BAUD_RATE_460800: 300 baud_reg = REG_CONTROL_BAUD_RATE_460800; 301 break; 302 case PKT_BAUD_RATE_230400: 303 baud_reg = REG_CONTROL_BAUD_RATE_230400; 304 break; 305 case PKT_BAUD_RATE_115200: 306 baud_reg = REG_CONTROL_BAUD_RATE_115200; 307 break; 308 case PKT_BAUD_RATE_57600: 309 /* Fall through... */ 310 default: 311 baud_reg = REG_CONTROL_BAUD_RATE_57600; 312 break; 313 } 314 315 /* Wait until the command reaches the baseband */ 316 prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE); 317 schedule_timeout(HZ/10); 318 finish_wait(&wq, &wait); 319 320 /* Set baud on baseband */ 321 info->ctrl_reg &= ~0x03; 322 info->ctrl_reg |= baud_reg; 323 outb(info->ctrl_reg, iobase + REG_CONTROL); 324 325 /* Enable RTS */ 326 info->ctrl_reg &= ~REG_CONTROL_RTS; 327 outb(info->ctrl_reg, iobase + REG_CONTROL); 328 329 /* Wait before the next HCI packet can be send */ 330 prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE); 331 schedule_timeout(HZ); 332 finish_wait(&wq, &wait); 333 } 334 335 if (len == skb->len) { 336 kfree_skb(skb); 337 } else { 338 skb_pull(skb, len); 339 skb_queue_head(&(info->txq), skb); 340 } 341 342 info->hdev->stat.byte_tx += len; 343 344 /* Change buffer */ 345 change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state)); 346 347 } while (test_bit(XMIT_WAKEUP, &(info->tx_state))); 348 349 clear_bit(XMIT_SENDING, &(info->tx_state)); 350 } 351 352 353 static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size) 354 { 355 int i, n, len; 356 357 outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND); 358 359 len = inb(iobase + offset); 360 n = 0; 361 i = 1; 362 363 while (n < len) { 364 365 if (i == 16) { 366 outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND); 367 i = 0; 368 } 369 370 buf[n] = inb(iobase + offset + i); 371 372 n++; 373 i++; 374 375 } 376 377 return len; 378 } 379 380 381 static void bluecard_receive(bluecard_info_t *info, unsigned int offset) 382 { 383 unsigned int iobase; 384 unsigned char buf[31]; 385 int i, len; 386 387 if (!info) { 388 BT_ERR("Unknown device"); 389 return; 390 } 391 392 iobase = info->link.io.BasePort1; 393 394 if (test_bit(XMIT_SENDING_READY, &(info->tx_state))) 395 bluecard_enable_activity_led(info); 396 397 len = bluecard_read(iobase, offset, buf, sizeof(buf)); 398 399 for (i = 0; i < len; i++) { 400 401 /* Allocate packet */ 402 if (info->rx_skb == NULL) { 403 info->rx_state = RECV_WAIT_PACKET_TYPE; 404 info->rx_count = 0; 405 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) { 406 BT_ERR("Can't allocate mem for new packet"); 407 return; 408 } 409 } 410 411 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 412 413 info->rx_skb->dev = (void *) info->hdev; 414 info->rx_skb->pkt_type = buf[i]; 415 416 switch (info->rx_skb->pkt_type) { 417 418 case 0x00: 419 /* init packet */ 420 if (offset != 0x00) { 421 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 422 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 423 set_bit(XMIT_SENDING_READY, &(info->tx_state)); 424 bluecard_write_wakeup(info); 425 } 426 427 kfree_skb(info->rx_skb); 428 info->rx_skb = NULL; 429 break; 430 431 case HCI_EVENT_PKT: 432 info->rx_state = RECV_WAIT_EVENT_HEADER; 433 info->rx_count = HCI_EVENT_HDR_SIZE; 434 break; 435 436 case HCI_ACLDATA_PKT: 437 info->rx_state = RECV_WAIT_ACL_HEADER; 438 info->rx_count = HCI_ACL_HDR_SIZE; 439 break; 440 441 case HCI_SCODATA_PKT: 442 info->rx_state = RECV_WAIT_SCO_HEADER; 443 info->rx_count = HCI_SCO_HDR_SIZE; 444 break; 445 446 default: 447 /* unknown packet */ 448 BT_ERR("Unknown HCI packet with type 0x%02x received", info->rx_skb->pkt_type); 449 info->hdev->stat.err_rx++; 450 451 kfree_skb(info->rx_skb); 452 info->rx_skb = NULL; 453 break; 454 455 } 456 457 } else { 458 459 *skb_put(info->rx_skb, 1) = buf[i]; 460 info->rx_count--; 461 462 if (info->rx_count == 0) { 463 464 int dlen; 465 struct hci_event_hdr *eh; 466 struct hci_acl_hdr *ah; 467 struct hci_sco_hdr *sh; 468 469 switch (info->rx_state) { 470 471 case RECV_WAIT_EVENT_HEADER: 472 eh = (struct hci_event_hdr *)(info->rx_skb->data); 473 info->rx_state = RECV_WAIT_DATA; 474 info->rx_count = eh->plen; 475 break; 476 477 case RECV_WAIT_ACL_HEADER: 478 ah = (struct hci_acl_hdr *)(info->rx_skb->data); 479 dlen = __le16_to_cpu(ah->dlen); 480 info->rx_state = RECV_WAIT_DATA; 481 info->rx_count = dlen; 482 break; 483 484 case RECV_WAIT_SCO_HEADER: 485 sh = (struct hci_sco_hdr *)(info->rx_skb->data); 486 info->rx_state = RECV_WAIT_DATA; 487 info->rx_count = sh->dlen; 488 break; 489 490 case RECV_WAIT_DATA: 491 hci_recv_frame(info->rx_skb); 492 info->rx_skb = NULL; 493 break; 494 495 } 496 497 } 498 499 } 500 501 502 } 503 504 info->hdev->stat.byte_rx += len; 505 } 506 507 508 static irqreturn_t bluecard_interrupt(int irq, void *dev_inst, struct pt_regs *regs) 509 { 510 bluecard_info_t *info = dev_inst; 511 unsigned int iobase; 512 unsigned char reg; 513 514 if (!info || !info->hdev) { 515 BT_ERR("Call of irq %d for unknown device", irq); 516 return IRQ_NONE; 517 } 518 519 if (!test_bit(CARD_READY, &(info->hw_state))) 520 return IRQ_HANDLED; 521 522 iobase = info->link.io.BasePort1; 523 524 spin_lock(&(info->lock)); 525 526 /* Disable interrupt */ 527 info->ctrl_reg &= ~REG_CONTROL_INTERRUPT; 528 outb(info->ctrl_reg, iobase + REG_CONTROL); 529 530 reg = inb(iobase + REG_INTERRUPT); 531 532 if ((reg != 0x00) && (reg != 0xff)) { 533 534 if (reg & 0x04) { 535 bluecard_receive(info, 0x00); 536 outb(0x04, iobase + REG_INTERRUPT); 537 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND); 538 } 539 540 if (reg & 0x08) { 541 bluecard_receive(info, 0x10); 542 outb(0x08, iobase + REG_INTERRUPT); 543 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND); 544 } 545 546 if (reg & 0x01) { 547 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 548 outb(0x01, iobase + REG_INTERRUPT); 549 bluecard_write_wakeup(info); 550 } 551 552 if (reg & 0x02) { 553 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 554 outb(0x02, iobase + REG_INTERRUPT); 555 bluecard_write_wakeup(info); 556 } 557 558 } 559 560 /* Enable interrupt */ 561 info->ctrl_reg |= REG_CONTROL_INTERRUPT; 562 outb(info->ctrl_reg, iobase + REG_CONTROL); 563 564 spin_unlock(&(info->lock)); 565 566 return IRQ_HANDLED; 567 } 568 569 570 571 /* ======================== Device specific HCI commands ======================== */ 572 573 574 static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud) 575 { 576 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 577 struct sk_buff *skb; 578 579 /* Ericsson baud rate command */ 580 unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 }; 581 582 if (!(skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) { 583 BT_ERR("Can't allocate mem for new packet"); 584 return -1; 585 } 586 587 switch (baud) { 588 case 460800: 589 cmd[4] = 0x00; 590 skb->pkt_type = PKT_BAUD_RATE_460800; 591 break; 592 case 230400: 593 cmd[4] = 0x01; 594 skb->pkt_type = PKT_BAUD_RATE_230400; 595 break; 596 case 115200: 597 cmd[4] = 0x02; 598 skb->pkt_type = PKT_BAUD_RATE_115200; 599 break; 600 case 57600: 601 /* Fall through... */ 602 default: 603 cmd[4] = 0x03; 604 skb->pkt_type = PKT_BAUD_RATE_57600; 605 break; 606 } 607 608 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd)); 609 610 skb_queue_tail(&(info->txq), skb); 611 612 bluecard_write_wakeup(info); 613 614 return 0; 615 } 616 617 618 619 /* ======================== HCI interface ======================== */ 620 621 622 static int bluecard_hci_flush(struct hci_dev *hdev) 623 { 624 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 625 626 /* Drop TX queue */ 627 skb_queue_purge(&(info->txq)); 628 629 return 0; 630 } 631 632 633 static int bluecard_hci_open(struct hci_dev *hdev) 634 { 635 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 636 unsigned int iobase = info->link.io.BasePort1; 637 638 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) 639 bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE); 640 641 if (test_and_set_bit(HCI_RUNNING, &(hdev->flags))) 642 return 0; 643 644 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) { 645 /* Enable LED */ 646 outb(0x08 | 0x20, iobase + 0x30); 647 } 648 649 return 0; 650 } 651 652 653 static int bluecard_hci_close(struct hci_dev *hdev) 654 { 655 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data); 656 unsigned int iobase = info->link.io.BasePort1; 657 658 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags))) 659 return 0; 660 661 bluecard_hci_flush(hdev); 662 663 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) { 664 /* Disable LED */ 665 outb(0x00, iobase + 0x30); 666 } 667 668 return 0; 669 } 670 671 672 static int bluecard_hci_send_frame(struct sk_buff *skb) 673 { 674 bluecard_info_t *info; 675 struct hci_dev *hdev = (struct hci_dev *)(skb->dev); 676 677 if (!hdev) { 678 BT_ERR("Frame for unknown HCI device (hdev=NULL)"); 679 return -ENODEV; 680 } 681 682 info = (bluecard_info_t *)(hdev->driver_data); 683 684 switch (skb->pkt_type) { 685 case HCI_COMMAND_PKT: 686 hdev->stat.cmd_tx++; 687 break; 688 case HCI_ACLDATA_PKT: 689 hdev->stat.acl_tx++; 690 break; 691 case HCI_SCODATA_PKT: 692 hdev->stat.sco_tx++; 693 break; 694 }; 695 696 /* Prepend skb with frame type */ 697 memcpy(skb_push(skb, 1), &(skb->pkt_type), 1); 698 skb_queue_tail(&(info->txq), skb); 699 700 bluecard_write_wakeup(info); 701 702 return 0; 703 } 704 705 706 static void bluecard_hci_destruct(struct hci_dev *hdev) 707 { 708 } 709 710 711 static int bluecard_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg) 712 { 713 return -ENOIOCTLCMD; 714 } 715 716 717 718 /* ======================== Card services HCI interaction ======================== */ 719 720 721 static int bluecard_open(bluecard_info_t *info) 722 { 723 unsigned int iobase = info->link.io.BasePort1; 724 struct hci_dev *hdev; 725 unsigned char id; 726 727 spin_lock_init(&(info->lock)); 728 729 init_timer(&(info->timer)); 730 info->timer.function = &bluecard_activity_led_timeout; 731 info->timer.data = (u_long)info; 732 733 skb_queue_head_init(&(info->txq)); 734 735 info->rx_state = RECV_WAIT_PACKET_TYPE; 736 info->rx_count = 0; 737 info->rx_skb = NULL; 738 739 /* Initialize HCI device */ 740 hdev = hci_alloc_dev(); 741 if (!hdev) { 742 BT_ERR("Can't allocate HCI device"); 743 return -ENOMEM; 744 } 745 746 info->hdev = hdev; 747 748 hdev->type = HCI_PCCARD; 749 hdev->driver_data = info; 750 751 hdev->open = bluecard_hci_open; 752 hdev->close = bluecard_hci_close; 753 hdev->flush = bluecard_hci_flush; 754 hdev->send = bluecard_hci_send_frame; 755 hdev->destruct = bluecard_hci_destruct; 756 hdev->ioctl = bluecard_hci_ioctl; 757 758 hdev->owner = THIS_MODULE; 759 760 id = inb(iobase + 0x30); 761 762 if ((id & 0x0f) == 0x02) 763 set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)); 764 765 if (id & 0x10) 766 set_bit(CARD_HAS_POWER_LED, &(info->hw_state)); 767 768 if (id & 0x20) 769 set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state)); 770 771 /* Reset card */ 772 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; 773 outb(info->ctrl_reg, iobase + REG_CONTROL); 774 775 /* Turn FPGA off */ 776 outb(0x80, iobase + 0x30); 777 778 /* Wait some time */ 779 msleep(10); 780 781 /* Turn FPGA on */ 782 outb(0x00, iobase + 0x30); 783 784 /* Activate card */ 785 info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU; 786 outb(info->ctrl_reg, iobase + REG_CONTROL); 787 788 /* Enable interrupt */ 789 outb(0xff, iobase + REG_INTERRUPT); 790 info->ctrl_reg |= REG_CONTROL_INTERRUPT; 791 outb(info->ctrl_reg, iobase + REG_CONTROL); 792 793 if ((id & 0x0f) == 0x03) { 794 /* Disable RTS */ 795 info->ctrl_reg |= REG_CONTROL_RTS; 796 outb(info->ctrl_reg, iobase + REG_CONTROL); 797 798 /* Set baud rate */ 799 info->ctrl_reg |= 0x03; 800 outb(info->ctrl_reg, iobase + REG_CONTROL); 801 802 /* Enable RTS */ 803 info->ctrl_reg &= ~REG_CONTROL_RTS; 804 outb(info->ctrl_reg, iobase + REG_CONTROL); 805 806 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state)); 807 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state)); 808 set_bit(XMIT_SENDING_READY, &(info->tx_state)); 809 } 810 811 /* Start the RX buffers */ 812 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND); 813 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND); 814 815 /* Signal that the hardware is ready */ 816 set_bit(CARD_READY, &(info->hw_state)); 817 818 /* Drop TX queue */ 819 skb_queue_purge(&(info->txq)); 820 821 /* Control the point at which RTS is enabled */ 822 outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL); 823 824 /* Timeout before it is safe to send the first HCI packet */ 825 msleep(1250); 826 827 /* Register HCI device */ 828 if (hci_register_dev(hdev) < 0) { 829 BT_ERR("Can't register HCI device"); 830 info->hdev = NULL; 831 hci_free_dev(hdev); 832 return -ENODEV; 833 } 834 835 return 0; 836 } 837 838 839 static int bluecard_close(bluecard_info_t *info) 840 { 841 unsigned int iobase = info->link.io.BasePort1; 842 struct hci_dev *hdev = info->hdev; 843 844 if (!hdev) 845 return -ENODEV; 846 847 bluecard_hci_close(hdev); 848 849 clear_bit(CARD_READY, &(info->hw_state)); 850 851 /* Reset card */ 852 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; 853 outb(info->ctrl_reg, iobase + REG_CONTROL); 854 855 /* Turn FPGA off */ 856 outb(0x80, iobase + 0x30); 857 858 if (hci_unregister_dev(hdev) < 0) 859 BT_ERR("Can't unregister HCI device %s", hdev->name); 860 861 hci_free_dev(hdev); 862 863 return 0; 864 } 865 866 static dev_link_t *bluecard_attach(void) 867 { 868 bluecard_info_t *info; 869 client_reg_t client_reg; 870 dev_link_t *link; 871 int ret; 872 873 /* Create new info device */ 874 info = kmalloc(sizeof(*info), GFP_KERNEL); 875 if (!info) 876 return NULL; 877 memset(info, 0, sizeof(*info)); 878 879 link = &info->link; 880 link->priv = info; 881 882 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 883 link->io.NumPorts1 = 8; 884 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT; 885 link->irq.IRQInfo1 = IRQ_LEVEL_ID; 886 887 link->irq.Handler = bluecard_interrupt; 888 link->irq.Instance = info; 889 890 link->conf.Attributes = CONF_ENABLE_IRQ; 891 link->conf.Vcc = 50; 892 link->conf.IntType = INT_MEMORY_AND_IO; 893 894 /* Register with Card Services */ 895 link->next = dev_list; 896 dev_list = link; 897 client_reg.dev_info = &dev_info; 898 client_reg.EventMask = 899 CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL | 900 CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET | 901 CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME; 902 client_reg.event_handler = &bluecard_event; 903 client_reg.Version = 0x0210; 904 client_reg.event_callback_args.client_data = link; 905 906 ret = pcmcia_register_client(&link->handle, &client_reg); 907 if (ret != CS_SUCCESS) { 908 cs_error(link->handle, RegisterClient, ret); 909 bluecard_detach(link); 910 return NULL; 911 } 912 913 return link; 914 } 915 916 917 static void bluecard_detach(dev_link_t *link) 918 { 919 bluecard_info_t *info = link->priv; 920 dev_link_t **linkp; 921 int ret; 922 923 /* Locate device structure */ 924 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) 925 if (*linkp == link) 926 break; 927 928 if (*linkp == NULL) 929 return; 930 931 if (link->state & DEV_CONFIG) 932 bluecard_release(link); 933 934 if (link->handle) { 935 ret = pcmcia_deregister_client(link->handle); 936 if (ret != CS_SUCCESS) 937 cs_error(link->handle, DeregisterClient, ret); 938 } 939 940 /* Unlink device structure, free bits */ 941 *linkp = link->next; 942 943 kfree(info); 944 } 945 946 947 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse) 948 { 949 int i; 950 951 i = pcmcia_get_first_tuple(handle, tuple); 952 if (i != CS_SUCCESS) 953 return CS_NO_MORE_ITEMS; 954 955 i = pcmcia_get_tuple_data(handle, tuple); 956 if (i != CS_SUCCESS) 957 return i; 958 959 return pcmcia_parse_tuple(handle, tuple, parse); 960 } 961 962 static void bluecard_config(dev_link_t *link) 963 { 964 client_handle_t handle = link->handle; 965 bluecard_info_t *info = link->priv; 966 tuple_t tuple; 967 u_short buf[256]; 968 cisparse_t parse; 969 config_info_t config; 970 int i, n, last_ret, last_fn; 971 972 tuple.TupleData = (cisdata_t *)buf; 973 tuple.TupleOffset = 0; 974 tuple.TupleDataMax = 255; 975 tuple.Attributes = 0; 976 977 /* Get configuration register information */ 978 tuple.DesiredTuple = CISTPL_CONFIG; 979 last_ret = first_tuple(handle, &tuple, &parse); 980 if (last_ret != CS_SUCCESS) { 981 last_fn = ParseTuple; 982 goto cs_failed; 983 } 984 link->conf.ConfigBase = parse.config.base; 985 link->conf.Present = parse.config.rmask[0]; 986 987 /* Configure card */ 988 link->state |= DEV_CONFIG; 989 i = pcmcia_get_configuration_info(handle, &config); 990 link->conf.Vcc = config.Vcc; 991 992 link->conf.ConfigIndex = 0x20; 993 link->io.NumPorts1 = 64; 994 link->io.IOAddrLines = 6; 995 996 for (n = 0; n < 0x400; n += 0x40) { 997 link->io.BasePort1 = n ^ 0x300; 998 i = pcmcia_request_io(link->handle, &link->io); 999 if (i == CS_SUCCESS) 1000 break; 1001 } 1002 1003 if (i != CS_SUCCESS) { 1004 cs_error(link->handle, RequestIO, i); 1005 goto failed; 1006 } 1007 1008 i = pcmcia_request_irq(link->handle, &link->irq); 1009 if (i != CS_SUCCESS) { 1010 cs_error(link->handle, RequestIRQ, i); 1011 link->irq.AssignedIRQ = 0; 1012 } 1013 1014 i = pcmcia_request_configuration(link->handle, &link->conf); 1015 if (i != CS_SUCCESS) { 1016 cs_error(link->handle, RequestConfiguration, i); 1017 goto failed; 1018 } 1019 1020 if (bluecard_open(info) != 0) 1021 goto failed; 1022 1023 strcpy(info->node.dev_name, info->hdev->name); 1024 link->dev = &info->node; 1025 link->state &= ~DEV_CONFIG_PENDING; 1026 1027 return; 1028 1029 cs_failed: 1030 cs_error(link->handle, last_fn, last_ret); 1031 1032 failed: 1033 bluecard_release(link); 1034 } 1035 1036 1037 static void bluecard_release(dev_link_t *link) 1038 { 1039 bluecard_info_t *info = link->priv; 1040 1041 if (link->state & DEV_PRESENT) 1042 bluecard_close(info); 1043 1044 del_timer(&(info->timer)); 1045 1046 link->dev = NULL; 1047 1048 pcmcia_release_configuration(link->handle); 1049 pcmcia_release_io(link->handle, &link->io); 1050 pcmcia_release_irq(link->handle, &link->irq); 1051 1052 link->state &= ~DEV_CONFIG; 1053 } 1054 1055 1056 static int bluecard_event(event_t event, int priority, event_callback_args_t *args) 1057 { 1058 dev_link_t *link = args->client_data; 1059 bluecard_info_t *info = link->priv; 1060 1061 switch (event) { 1062 case CS_EVENT_CARD_REMOVAL: 1063 link->state &= ~DEV_PRESENT; 1064 if (link->state & DEV_CONFIG) { 1065 bluecard_close(info); 1066 bluecard_release(link); 1067 } 1068 break; 1069 case CS_EVENT_CARD_INSERTION: 1070 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; 1071 bluecard_config(link); 1072 break; 1073 case CS_EVENT_PM_SUSPEND: 1074 link->state |= DEV_SUSPEND; 1075 /* Fall through... */ 1076 case CS_EVENT_RESET_PHYSICAL: 1077 if (link->state & DEV_CONFIG) 1078 pcmcia_release_configuration(link->handle); 1079 break; 1080 case CS_EVENT_PM_RESUME: 1081 link->state &= ~DEV_SUSPEND; 1082 /* Fall through... */ 1083 case CS_EVENT_CARD_RESET: 1084 if (DEV_OK(link)) 1085 pcmcia_request_configuration(link->handle, &link->conf); 1086 break; 1087 } 1088 1089 return 0; 1090 } 1091 1092 static struct pcmcia_driver bluecard_driver = { 1093 .owner = THIS_MODULE, 1094 .drv = { 1095 .name = "bluecard_cs", 1096 }, 1097 .attach = bluecard_attach, 1098 .detach = bluecard_detach, 1099 }; 1100 1101 static int __init init_bluecard_cs(void) 1102 { 1103 return pcmcia_register_driver(&bluecard_driver); 1104 } 1105 1106 1107 static void __exit exit_bluecard_cs(void) 1108 { 1109 pcmcia_unregister_driver(&bluecard_driver); 1110 BUG_ON(dev_list != NULL); 1111 } 1112 1113 module_init(init_bluecard_cs); 1114 module_exit(exit_bluecard_cs); 1115