909 lines · c
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 modify9 * it under the terms of the GNU General Public License version 2 as10 * published by the Free Software Foundation;11 *12 * Software distributed under the License is distributed on an "AS13 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or14 * implied. See the License for the specific language governing15 * rights and limitations under the License.16 *17 * The initial developer of the original code is David A. Hinds18 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds19 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.20 *21 */22 23#include <linux/module.h>24 25#include <linux/kernel.h>26#include <linux/init.h>27#include <linux/slab.h>28#include <linux/types.h>29#include <linux/sched.h>30#include <linux/delay.h>31#include <linux/timer.h>32#include <linux/errno.h>33#include <linux/ptrace.h>34#include <linux/ioport.h>35#include <linux/spinlock.h>36#include <linux/moduleparam.h>37#include <linux/wait.h>38 39#include <linux/skbuff.h>40#include <linux/io.h>41 42#include <pcmcia/cistpl.h>43#include <pcmcia/ciscode.h>44#include <pcmcia/ds.h>45#include <pcmcia/cisreg.h>46 47#include <net/bluetooth/bluetooth.h>48#include <net/bluetooth/hci_core.h>49 50 51 52/* ======================== Module parameters ======================== */53 54 55MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");56MODULE_DESCRIPTION("Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)");57MODULE_LICENSE("GPL");58 59 60 61/* ======================== Local structures ======================== */62 63 64struct bluecard_info {65 struct pcmcia_device *p_dev;66 67 struct hci_dev *hdev;68 69 spinlock_t lock; /* For serializing operations */70 struct timer_list timer; /* For LED control */71 72 struct sk_buff_head txq;73 unsigned long tx_state;74 75 unsigned long rx_state;76 unsigned long rx_count;77 struct sk_buff *rx_skb;78 79 unsigned char ctrl_reg;80 unsigned long hw_state; /* Status of the hardware and LED control */81};82 83 84static int bluecard_config(struct pcmcia_device *link);85static void bluecard_release(struct pcmcia_device *link);86 87static void bluecard_detach(struct pcmcia_device *p_dev);88 89 90/* Default baud rate: 57600, 115200, 230400 or 460800 */91#define DEFAULT_BAUD_RATE 23040092 93 94/* Hardware states */95#define CARD_READY 196#define CARD_ACTIVITY 297#define CARD_HAS_PCCARD_ID 498#define CARD_HAS_POWER_LED 599#define CARD_HAS_ACTIVITY_LED 6100 101/* Transmit states */102#define XMIT_SENDING 1103#define XMIT_WAKEUP 2104#define XMIT_BUFFER_NUMBER 5 /* unset = buffer one, set = buffer two */105#define XMIT_BUF_ONE_READY 6106#define XMIT_BUF_TWO_READY 7107#define XMIT_SENDING_READY 8108 109/* Receiver states */110#define RECV_WAIT_PACKET_TYPE 0111#define RECV_WAIT_EVENT_HEADER 1112#define RECV_WAIT_ACL_HEADER 2113#define RECV_WAIT_SCO_HEADER 3114#define RECV_WAIT_DATA 4115 116/* Special packet types */117#define PKT_BAUD_RATE_57600 0x80118#define PKT_BAUD_RATE_115200 0x81119#define PKT_BAUD_RATE_230400 0x82120#define PKT_BAUD_RATE_460800 0x83121 122 123/* These are the register offsets */124#define REG_COMMAND 0x20125#define REG_INTERRUPT 0x21126#define REG_CONTROL 0x22127#define REG_RX_CONTROL 0x24128#define REG_CARD_RESET 0x30129#define REG_LED_CTRL 0x30130 131/* REG_COMMAND */132#define REG_COMMAND_TX_BUF_ONE 0x01133#define REG_COMMAND_TX_BUF_TWO 0x02134#define REG_COMMAND_RX_BUF_ONE 0x04135#define REG_COMMAND_RX_BUF_TWO 0x08136#define REG_COMMAND_RX_WIN_ONE 0x00137#define REG_COMMAND_RX_WIN_TWO 0x10138 139/* REG_CONTROL */140#define REG_CONTROL_BAUD_RATE_57600 0x00141#define REG_CONTROL_BAUD_RATE_115200 0x01142#define REG_CONTROL_BAUD_RATE_230400 0x02143#define REG_CONTROL_BAUD_RATE_460800 0x03144#define REG_CONTROL_RTS 0x04145#define REG_CONTROL_BT_ON 0x08146#define REG_CONTROL_BT_RESET 0x10147#define REG_CONTROL_BT_RES_PU 0x20148#define REG_CONTROL_INTERRUPT 0x40149#define REG_CONTROL_CARD_RESET 0x80150 151/* REG_RX_CONTROL */152#define RTS_LEVEL_SHIFT_BITS 0x02153 154 155 156/* ======================== LED handling routines ======================== */157 158 159static void bluecard_activity_led_timeout(struct timer_list *t)160{161 struct bluecard_info *info = from_timer(info, t, timer);162 unsigned int iobase = info->p_dev->resource[0]->start;163 164 if (test_bit(CARD_ACTIVITY, &(info->hw_state))) {165 /* leave LED in inactive state for HZ/10 for blink effect */166 clear_bit(CARD_ACTIVITY, &(info->hw_state));167 mod_timer(&(info->timer), jiffies + HZ / 10);168 }169 170 /* Disable activity LED, enable power LED */171 outb(0x08 | 0x20, iobase + 0x30);172}173 174 175static void bluecard_enable_activity_led(struct bluecard_info *info)176{177 unsigned int iobase = info->p_dev->resource[0]->start;178 179 /* don't disturb running blink timer */180 if (timer_pending(&(info->timer)))181 return;182 183 set_bit(CARD_ACTIVITY, &(info->hw_state));184 185 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) {186 /* Enable activity LED, keep power LED enabled */187 outb(0x18 | 0x60, iobase + 0x30);188 } else {189 /* Disable power LED */190 outb(0x00, iobase + 0x30);191 }192 193 /* Stop the LED after HZ/10 */194 mod_timer(&(info->timer), jiffies + HZ / 10);195}196 197 198 199/* ======================== Interrupt handling ======================== */200 201 202static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len)203{204 int i, actual;205 206 actual = (len > 15) ? 15 : len;207 208 outb_p(actual, iobase + offset);209 210 for (i = 0; i < actual; i++)211 outb_p(buf[i], iobase + offset + i + 1);212 213 return actual;214}215 216 217static void bluecard_write_wakeup(struct bluecard_info *info)218{219 if (!info) {220 BT_ERR("Unknown device");221 return;222 }223 224 if (!test_bit(XMIT_SENDING_READY, &(info->tx_state)))225 return;226 227 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {228 set_bit(XMIT_WAKEUP, &(info->tx_state));229 return;230 }231 232 do {233 unsigned int iobase = info->p_dev->resource[0]->start;234 unsigned int offset;235 unsigned char command;236 unsigned long ready_bit;237 register struct sk_buff *skb;238 int len;239 240 clear_bit(XMIT_WAKEUP, &(info->tx_state));241 242 if (!pcmcia_dev_present(info->p_dev))243 return;244 245 if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) {246 if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state)))247 break;248 offset = 0x10;249 command = REG_COMMAND_TX_BUF_TWO;250 ready_bit = XMIT_BUF_TWO_READY;251 } else {252 if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state)))253 break;254 offset = 0x00;255 command = REG_COMMAND_TX_BUF_ONE;256 ready_bit = XMIT_BUF_ONE_READY;257 }258 259 skb = skb_dequeue(&(info->txq));260 if (!skb)261 break;262 263 if (hci_skb_pkt_type(skb) & 0x80) {264 /* Disable RTS */265 info->ctrl_reg |= REG_CONTROL_RTS;266 outb(info->ctrl_reg, iobase + REG_CONTROL);267 }268 269 /* Activate LED */270 bluecard_enable_activity_led(info);271 272 /* Send frame */273 len = bluecard_write(iobase, offset, skb->data, skb->len);274 275 /* Tell the FPGA to send the data */276 outb_p(command, iobase + REG_COMMAND);277 278 /* Mark the buffer as dirty */279 clear_bit(ready_bit, &(info->tx_state));280 281 if (hci_skb_pkt_type(skb) & 0x80) {282 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);283 DEFINE_WAIT(wait);284 285 unsigned char baud_reg;286 287 switch (hci_skb_pkt_type(skb)) {288 case PKT_BAUD_RATE_460800:289 baud_reg = REG_CONTROL_BAUD_RATE_460800;290 break;291 case PKT_BAUD_RATE_230400:292 baud_reg = REG_CONTROL_BAUD_RATE_230400;293 break;294 case PKT_BAUD_RATE_115200:295 baud_reg = REG_CONTROL_BAUD_RATE_115200;296 break;297 case PKT_BAUD_RATE_57600:298 default:299 baud_reg = REG_CONTROL_BAUD_RATE_57600;300 break;301 }302 303 /* Wait until the command reaches the baseband */304 mdelay(100);305 306 /* Set baud on baseband */307 info->ctrl_reg &= ~0x03;308 info->ctrl_reg |= baud_reg;309 outb(info->ctrl_reg, iobase + REG_CONTROL);310 311 /* Enable RTS */312 info->ctrl_reg &= ~REG_CONTROL_RTS;313 outb(info->ctrl_reg, iobase + REG_CONTROL);314 315 /* Wait before the next HCI packet can be send */316 mdelay(1000);317 }318 319 if (len == skb->len) {320 kfree_skb(skb);321 } else {322 skb_pull(skb, len);323 skb_queue_head(&(info->txq), skb);324 }325 326 info->hdev->stat.byte_tx += len;327 328 /* Change buffer */329 change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state));330 331 } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));332 333 clear_bit(XMIT_SENDING, &(info->tx_state));334}335 336 337static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size)338{339 int i, n, len;340 341 outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND);342 343 len = inb(iobase + offset);344 n = 0;345 i = 1;346 347 while (n < len) {348 349 if (i == 16) {350 outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND);351 i = 0;352 }353 354 buf[n] = inb(iobase + offset + i);355 356 n++;357 i++;358 359 }360 361 return len;362}363 364 365static void bluecard_receive(struct bluecard_info *info,366 unsigned int offset)367{368 unsigned int iobase;369 unsigned char buf[31];370 int i, len;371 372 if (!info) {373 BT_ERR("Unknown device");374 return;375 }376 377 iobase = info->p_dev->resource[0]->start;378 379 if (test_bit(XMIT_SENDING_READY, &(info->tx_state)))380 bluecard_enable_activity_led(info);381 382 len = bluecard_read(iobase, offset, buf, sizeof(buf));383 384 for (i = 0; i < len; i++) {385 386 /* Allocate packet */387 if (!info->rx_skb) {388 info->rx_state = RECV_WAIT_PACKET_TYPE;389 info->rx_count = 0;390 info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);391 if (!info->rx_skb) {392 BT_ERR("Can't allocate mem for new packet");393 return;394 }395 }396 397 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {398 399 hci_skb_pkt_type(info->rx_skb) = buf[i];400 401 switch (hci_skb_pkt_type(info->rx_skb)) {402 403 case 0x00:404 /* init packet */405 if (offset != 0x00) {406 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));407 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));408 set_bit(XMIT_SENDING_READY, &(info->tx_state));409 bluecard_write_wakeup(info);410 }411 412 kfree_skb(info->rx_skb);413 info->rx_skb = NULL;414 break;415 416 case HCI_EVENT_PKT:417 info->rx_state = RECV_WAIT_EVENT_HEADER;418 info->rx_count = HCI_EVENT_HDR_SIZE;419 break;420 421 case HCI_ACLDATA_PKT:422 info->rx_state = RECV_WAIT_ACL_HEADER;423 info->rx_count = HCI_ACL_HDR_SIZE;424 break;425 426 case HCI_SCODATA_PKT:427 info->rx_state = RECV_WAIT_SCO_HEADER;428 info->rx_count = HCI_SCO_HDR_SIZE;429 break;430 431 default:432 /* unknown packet */433 BT_ERR("Unknown HCI packet with type 0x%02x received",434 hci_skb_pkt_type(info->rx_skb));435 info->hdev->stat.err_rx++;436 437 kfree_skb(info->rx_skb);438 info->rx_skb = NULL;439 break;440 441 }442 443 } else {444 445 skb_put_u8(info->rx_skb, buf[i]);446 info->rx_count--;447 448 if (info->rx_count == 0) {449 450 int dlen;451 struct hci_event_hdr *eh;452 struct hci_acl_hdr *ah;453 struct hci_sco_hdr *sh;454 455 switch (info->rx_state) {456 457 case RECV_WAIT_EVENT_HEADER:458 eh = hci_event_hdr(info->rx_skb);459 info->rx_state = RECV_WAIT_DATA;460 info->rx_count = eh->plen;461 break;462 463 case RECV_WAIT_ACL_HEADER:464 ah = hci_acl_hdr(info->rx_skb);465 dlen = __le16_to_cpu(ah->dlen);466 info->rx_state = RECV_WAIT_DATA;467 info->rx_count = dlen;468 break;469 470 case RECV_WAIT_SCO_HEADER:471 sh = hci_sco_hdr(info->rx_skb);472 info->rx_state = RECV_WAIT_DATA;473 info->rx_count = sh->dlen;474 break;475 476 case RECV_WAIT_DATA:477 hci_recv_frame(info->hdev, info->rx_skb);478 info->rx_skb = NULL;479 break;480 481 }482 483 }484 485 }486 487 488 }489 490 info->hdev->stat.byte_rx += len;491}492 493 494static irqreturn_t bluecard_interrupt(int irq, void *dev_inst)495{496 struct bluecard_info *info = dev_inst;497 unsigned int iobase;498 unsigned char reg;499 500 if (!info || !info->hdev)501 /* our irq handler is shared */502 return IRQ_NONE;503 504 if (!test_bit(CARD_READY, &(info->hw_state)))505 return IRQ_HANDLED;506 507 iobase = info->p_dev->resource[0]->start;508 509 spin_lock(&(info->lock));510 511 /* Disable interrupt */512 info->ctrl_reg &= ~REG_CONTROL_INTERRUPT;513 outb(info->ctrl_reg, iobase + REG_CONTROL);514 515 reg = inb(iobase + REG_INTERRUPT);516 517 if ((reg != 0x00) && (reg != 0xff)) {518 519 if (reg & 0x04) {520 bluecard_receive(info, 0x00);521 outb(0x04, iobase + REG_INTERRUPT);522 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);523 }524 525 if (reg & 0x08) {526 bluecard_receive(info, 0x10);527 outb(0x08, iobase + REG_INTERRUPT);528 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);529 }530 531 if (reg & 0x01) {532 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));533 outb(0x01, iobase + REG_INTERRUPT);534 bluecard_write_wakeup(info);535 }536 537 if (reg & 0x02) {538 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));539 outb(0x02, iobase + REG_INTERRUPT);540 bluecard_write_wakeup(info);541 }542 543 }544 545 /* Enable interrupt */546 info->ctrl_reg |= REG_CONTROL_INTERRUPT;547 outb(info->ctrl_reg, iobase + REG_CONTROL);548 549 spin_unlock(&(info->lock));550 551 return IRQ_HANDLED;552}553 554 555 556/* ======================== Device specific HCI commands ======================== */557 558 559static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud)560{561 struct bluecard_info *info = hci_get_drvdata(hdev);562 struct sk_buff *skb;563 564 /* Ericsson baud rate command */565 unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 };566 567 skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_KERNEL);568 if (!skb) {569 BT_ERR("Can't allocate mem for new packet");570 return -1;571 }572 573 switch (baud) {574 case 460800:575 cmd[4] = 0x00;576 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_460800;577 break;578 case 230400:579 cmd[4] = 0x01;580 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_230400;581 break;582 case 115200:583 cmd[4] = 0x02;584 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_115200;585 break;586 case 57600:587 default:588 cmd[4] = 0x03;589 hci_skb_pkt_type(skb) = PKT_BAUD_RATE_57600;590 break;591 }592 593 skb_put_data(skb, cmd, sizeof(cmd));594 595 skb_queue_tail(&(info->txq), skb);596 597 bluecard_write_wakeup(info);598 599 return 0;600}601 602 603 604/* ======================== HCI interface ======================== */605 606 607static int bluecard_hci_flush(struct hci_dev *hdev)608{609 struct bluecard_info *info = hci_get_drvdata(hdev);610 611 /* Drop TX queue */612 skb_queue_purge(&(info->txq));613 614 return 0;615}616 617 618static int bluecard_hci_open(struct hci_dev *hdev)619{620 struct bluecard_info *info = hci_get_drvdata(hdev);621 unsigned int iobase = info->p_dev->resource[0]->start;622 623 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))624 bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE);625 626 /* Enable power LED */627 outb(0x08 | 0x20, iobase + 0x30);628 629 return 0;630}631 632 633static int bluecard_hci_close(struct hci_dev *hdev)634{635 struct bluecard_info *info = hci_get_drvdata(hdev);636 unsigned int iobase = info->p_dev->resource[0]->start;637 638 bluecard_hci_flush(hdev);639 640 /* Stop LED timer */641 del_timer_sync(&(info->timer));642 643 /* Disable power LED */644 outb(0x00, iobase + 0x30);645 646 return 0;647}648 649 650static int bluecard_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)651{652 struct bluecard_info *info = hci_get_drvdata(hdev);653 654 switch (hci_skb_pkt_type(skb)) {655 case HCI_COMMAND_PKT:656 hdev->stat.cmd_tx++;657 break;658 case HCI_ACLDATA_PKT:659 hdev->stat.acl_tx++;660 break;661 case HCI_SCODATA_PKT:662 hdev->stat.sco_tx++;663 break;664 }665 666 /* Prepend skb with frame type */667 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);668 skb_queue_tail(&(info->txq), skb);669 670 bluecard_write_wakeup(info);671 672 return 0;673}674 675 676 677/* ======================== Card services HCI interaction ======================== */678 679 680static int bluecard_open(struct bluecard_info *info)681{682 unsigned int iobase = info->p_dev->resource[0]->start;683 struct hci_dev *hdev;684 unsigned char id;685 686 spin_lock_init(&(info->lock));687 688 timer_setup(&info->timer, bluecard_activity_led_timeout, 0);689 690 skb_queue_head_init(&(info->txq));691 692 info->rx_state = RECV_WAIT_PACKET_TYPE;693 info->rx_count = 0;694 info->rx_skb = NULL;695 696 /* Initialize HCI device */697 hdev = hci_alloc_dev();698 if (!hdev) {699 BT_ERR("Can't allocate HCI device");700 return -ENOMEM;701 }702 703 info->hdev = hdev;704 705 hdev->bus = HCI_PCCARD;706 hci_set_drvdata(hdev, info);707 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);708 709 hdev->open = bluecard_hci_open;710 hdev->close = bluecard_hci_close;711 hdev->flush = bluecard_hci_flush;712 hdev->send = bluecard_hci_send_frame;713 714 id = inb(iobase + 0x30);715 716 if ((id & 0x0f) == 0x02)717 set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state));718 719 if (id & 0x10)720 set_bit(CARD_HAS_POWER_LED, &(info->hw_state));721 722 if (id & 0x20)723 set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state));724 725 /* Reset card */726 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;727 outb(info->ctrl_reg, iobase + REG_CONTROL);728 729 /* Turn FPGA off */730 outb(0x80, iobase + 0x30);731 732 /* Wait some time */733 msleep(10);734 735 /* Turn FPGA on */736 outb(0x00, iobase + 0x30);737 738 /* Activate card */739 info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU;740 outb(info->ctrl_reg, iobase + REG_CONTROL);741 742 /* Enable interrupt */743 outb(0xff, iobase + REG_INTERRUPT);744 info->ctrl_reg |= REG_CONTROL_INTERRUPT;745 outb(info->ctrl_reg, iobase + REG_CONTROL);746 747 if ((id & 0x0f) == 0x03) {748 /* Disable RTS */749 info->ctrl_reg |= REG_CONTROL_RTS;750 outb(info->ctrl_reg, iobase + REG_CONTROL);751 752 /* Set baud rate */753 info->ctrl_reg |= 0x03;754 outb(info->ctrl_reg, iobase + REG_CONTROL);755 756 /* Enable RTS */757 info->ctrl_reg &= ~REG_CONTROL_RTS;758 outb(info->ctrl_reg, iobase + REG_CONTROL);759 760 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));761 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));762 set_bit(XMIT_SENDING_READY, &(info->tx_state));763 }764 765 /* Start the RX buffers */766 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);767 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);768 769 /* Signal that the hardware is ready */770 set_bit(CARD_READY, &(info->hw_state));771 772 /* Drop TX queue */773 skb_queue_purge(&(info->txq));774 775 /* Control the point at which RTS is enabled */776 outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL);777 778 /* Timeout before it is safe to send the first HCI packet */779 msleep(1250);780 781 /* Register HCI device */782 if (hci_register_dev(hdev) < 0) {783 BT_ERR("Can't register HCI device");784 info->hdev = NULL;785 hci_free_dev(hdev);786 return -ENODEV;787 }788 789 return 0;790}791 792 793static int bluecard_close(struct bluecard_info *info)794{795 unsigned int iobase = info->p_dev->resource[0]->start;796 struct hci_dev *hdev = info->hdev;797 798 if (!hdev)799 return -ENODEV;800 801 bluecard_hci_close(hdev);802 803 clear_bit(CARD_READY, &(info->hw_state));804 805 /* Reset card */806 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;807 outb(info->ctrl_reg, iobase + REG_CONTROL);808 809 /* Turn FPGA off */810 outb(0x80, iobase + 0x30);811 812 hci_unregister_dev(hdev);813 hci_free_dev(hdev);814 815 return 0;816}817 818static int bluecard_probe(struct pcmcia_device *link)819{820 struct bluecard_info *info;821 822 /* Create new info device */823 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);824 if (!info)825 return -ENOMEM;826 827 info->p_dev = link;828 link->priv = info;829 830 link->config_flags |= CONF_ENABLE_IRQ;831 832 return bluecard_config(link);833}834 835 836static void bluecard_detach(struct pcmcia_device *link)837{838 bluecard_release(link);839}840 841 842static int bluecard_config(struct pcmcia_device *link)843{844 struct bluecard_info *info = link->priv;845 int i, n;846 847 link->config_index = 0x20;848 849 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;850 link->resource[0]->end = 64;851 link->io_lines = 6;852 853 for (n = 0; n < 0x400; n += 0x40) {854 link->resource[0]->start = n ^ 0x300;855 i = pcmcia_request_io(link);856 if (i == 0)857 break;858 }859 860 if (i != 0)861 goto failed;862 863 i = pcmcia_request_irq(link, bluecard_interrupt);864 if (i != 0)865 goto failed;866 867 i = pcmcia_enable_device(link);868 if (i != 0)869 goto failed;870 871 if (bluecard_open(info) != 0)872 goto failed;873 874 return 0;875 876failed:877 bluecard_release(link);878 return -ENODEV;879}880 881 882static void bluecard_release(struct pcmcia_device *link)883{884 struct bluecard_info *info = link->priv;885 886 bluecard_close(info);887 888 del_timer_sync(&(info->timer));889 890 pcmcia_disable_device(link);891}892 893static const struct pcmcia_device_id bluecard_ids[] = {894 PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e),895 PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c),896 PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab),897 PCMCIA_DEVICE_NULL898};899MODULE_DEVICE_TABLE(pcmcia, bluecard_ids);900 901static struct pcmcia_driver bluecard_driver = {902 .owner = THIS_MODULE,903 .name = "bluecard_cs",904 .probe = bluecard_probe,905 .remove = bluecard_detach,906 .id_table = bluecard_ids,907};908module_pcmcia_driver(bluecard_driver);909