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