linux/drivers/bluetooth/bluecard_cs.c
<<
>>
Prefs
   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 <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
  64typedef struct bluecard_info_t {
  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} bluecard_info_t;
  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  230400
  92
  93
  94/* Hardware states */
  95#define CARD_READY             1
  96#define CARD_HAS_PCCARD_ID     4
  97#define CARD_HAS_POWER_LED     5
  98#define CARD_HAS_ACTIVITY_LED  6
  99
 100/* Transmit states  */
 101#define XMIT_SENDING         1
 102#define XMIT_WAKEUP          2
 103#define XMIT_BUFFER_NUMBER   5  /* unset = buffer one, set = buffer two */
 104#define XMIT_BUF_ONE_READY   6
 105#define XMIT_BUF_TWO_READY   7
 106#define XMIT_SENDING_READY   8
 107
 108/* Receiver states */
 109#define RECV_WAIT_PACKET_TYPE   0
 110#define RECV_WAIT_EVENT_HEADER  1
 111#define RECV_WAIT_ACL_HEADER    2
 112#define RECV_WAIT_SCO_HEADER    3
 113#define RECV_WAIT_DATA          4
 114
 115/* Special packet types */
 116#define PKT_BAUD_RATE_57600   0x80
 117#define PKT_BAUD_RATE_115200  0x81
 118#define PKT_BAUD_RATE_230400  0x82
 119#define PKT_BAUD_RATE_460800  0x83
 120
 121
 122/* These are the register offsets */
 123#define REG_COMMAND     0x20
 124#define REG_INTERRUPT   0x21
 125#define REG_CONTROL     0x22
 126#define REG_RX_CONTROL  0x24
 127#define REG_CARD_RESET  0x30
 128#define REG_LED_CTRL    0x30
 129
 130/* REG_COMMAND */
 131#define REG_COMMAND_TX_BUF_ONE  0x01
 132#define REG_COMMAND_TX_BUF_TWO  0x02
 133#define REG_COMMAND_RX_BUF_ONE  0x04
 134#define REG_COMMAND_RX_BUF_TWO  0x08
 135#define REG_COMMAND_RX_WIN_ONE  0x00
 136#define REG_COMMAND_RX_WIN_TWO  0x10
 137
 138/* REG_CONTROL */
 139#define REG_CONTROL_BAUD_RATE_57600   0x00
 140#define REG_CONTROL_BAUD_RATE_115200  0x01
 141#define REG_CONTROL_BAUD_RATE_230400  0x02
 142#define REG_CONTROL_BAUD_RATE_460800  0x03
 143#define REG_CONTROL_RTS               0x04
 144#define REG_CONTROL_BT_ON             0x08
 145#define REG_CONTROL_BT_RESET          0x10
 146#define REG_CONTROL_BT_RES_PU         0x20
 147#define REG_CONTROL_INTERRUPT         0x40
 148#define REG_CONTROL_CARD_RESET        0x80
 149
 150/* REG_RX_CONTROL */
 151#define RTS_LEVEL_SHIFT_BITS  0x02
 152
 153
 154
 155/* ======================== LED handling routines ======================== */
 156
 157
 158static void bluecard_activity_led_timeout(u_long arg)
 159{
 160        bluecard_info_t *info = (bluecard_info_t *)arg;
 161        unsigned int iobase = info->p_dev->resource[0]->start;
 162
 163        if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
 164                return;
 165
 166        if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) {
 167                /* Disable activity LED */
 168                outb(0x08 | 0x20, iobase + 0x30);
 169        } else {
 170                /* Disable power LED */
 171                outb(0x00, iobase + 0x30);
 172        }
 173}
 174
 175
 176static void bluecard_enable_activity_led(bluecard_info_t *info)
 177{
 178        unsigned int iobase = info->p_dev->resource[0]->start;
 179
 180        if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
 181                return;
 182
 183        if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) {
 184                /* Enable activity LED */
 185                outb(0x10 | 0x40, iobase + 0x30);
 186
 187                /* Stop the LED after HZ/4 */
 188                mod_timer(&(info->timer), jiffies + HZ / 4);
 189        } else {
 190                /* Enable power LED */
 191                outb(0x08 | 0x20, iobase + 0x30);
 192
 193                /* Stop the LED after HZ/2 */
 194                mod_timer(&(info->timer), jiffies + HZ / 2);
 195        }
 196}
 197
 198
 199
 200/* ======================== Interrupt handling ======================== */
 201
 202
 203static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len)
 204{
 205        int i, actual;
 206
 207        actual = (len > 15) ? 15 : len;
 208
 209        outb_p(actual, iobase + offset);
 210
 211        for (i = 0; i < actual; i++)
 212                outb_p(buf[i], iobase + offset + i + 1);
 213
 214        return actual;
 215}
 216
 217
 218static void bluecard_write_wakeup(bluecard_info_t *info)
 219{
 220        if (!info) {
 221                BT_ERR("Unknown device");
 222                return;
 223        }
 224
 225        if (!test_bit(XMIT_SENDING_READY, &(info->tx_state)))
 226                return;
 227
 228        if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
 229                set_bit(XMIT_WAKEUP, &(info->tx_state));
 230                return;
 231        }
 232
 233        do {
 234                unsigned int iobase = info->p_dev->resource[0]->start;
 235                unsigned int offset;
 236                unsigned char command;
 237                unsigned long ready_bit;
 238                register struct sk_buff *skb;
 239                int len;
 240
 241                clear_bit(XMIT_WAKEUP, &(info->tx_state));
 242
 243                if (!pcmcia_dev_present(info->p_dev))
 244                        return;
 245
 246                if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) {
 247                        if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state)))
 248                                break;
 249                        offset = 0x10;
 250                        command = REG_COMMAND_TX_BUF_TWO;
 251                        ready_bit = XMIT_BUF_TWO_READY;
 252                } else {
 253                        if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state)))
 254                                break;
 255                        offset = 0x00;
 256                        command = REG_COMMAND_TX_BUF_ONE;
 257                        ready_bit = XMIT_BUF_ONE_READY;
 258                }
 259
 260                if (!(skb = skb_dequeue(&(info->txq))))
 261                        break;
 262
 263                if (bt_cb(skb)->pkt_type & 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 (bt_cb(skb)->pkt_type & 0x80) {
 282                        DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
 283                        DEFINE_WAIT(wait);
 284
 285                        unsigned char baud_reg;
 286
 287                        switch (bt_cb(skb)->pkt_type) {
 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                                /* Fall through... */
 299                        default:
 300                                baud_reg = REG_CONTROL_BAUD_RATE_57600;
 301                                break;
 302                        }
 303
 304                        /* Wait until the command reaches the baseband */
 305                        prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE);
 306                        schedule_timeout(HZ/10);
 307                        finish_wait(&wq, &wait);
 308
 309                        /* Set baud on baseband */
 310                        info->ctrl_reg &= ~0x03;
 311                        info->ctrl_reg |= baud_reg;
 312                        outb(info->ctrl_reg, iobase + REG_CONTROL);
 313
 314                        /* Enable RTS */
 315                        info->ctrl_reg &= ~REG_CONTROL_RTS;
 316                        outb(info->ctrl_reg, iobase + REG_CONTROL);
 317
 318                        /* Wait before the next HCI packet can be send */
 319                        prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE);
 320                        schedule_timeout(HZ);
 321                        finish_wait(&wq, &wait);
 322                }
 323
 324                if (len == skb->len) {
 325                        kfree_skb(skb);
 326                } else {
 327                        skb_pull(skb, len);
 328                        skb_queue_head(&(info->txq), skb);
 329                }
 330
 331                info->hdev->stat.byte_tx += len;
 332
 333                /* Change buffer */
 334                change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state));
 335
 336        } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
 337
 338        clear_bit(XMIT_SENDING, &(info->tx_state));
 339}
 340
 341
 342static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size)
 343{
 344        int i, n, len;
 345
 346        outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND);
 347
 348        len = inb(iobase + offset);
 349        n = 0;
 350        i = 1;
 351
 352        while (n < len) {
 353
 354                if (i == 16) {
 355                        outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND);
 356                        i = 0;
 357                }
 358
 359                buf[n] = inb(iobase + offset + i);
 360
 361                n++;
 362                i++;
 363
 364        }
 365
 366        return len;
 367}
 368
 369
 370static void bluecard_receive(bluecard_info_t *info, unsigned int offset)
 371{
 372        unsigned int iobase;
 373        unsigned char buf[31];
 374        int i, len;
 375
 376        if (!info) {
 377                BT_ERR("Unknown device");
 378                return;
 379        }
 380
 381        iobase = info->p_dev->resource[0]->start;
 382
 383        if (test_bit(XMIT_SENDING_READY, &(info->tx_state)))
 384                bluecard_enable_activity_led(info);
 385
 386        len = bluecard_read(iobase, offset, buf, sizeof(buf));
 387
 388        for (i = 0; i < len; i++) {
 389
 390                /* Allocate packet */
 391                if (info->rx_skb == NULL) {
 392                        info->rx_state = RECV_WAIT_PACKET_TYPE;
 393                        info->rx_count = 0;
 394                        if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
 395                                BT_ERR("Can't allocate mem for new packet");
 396                                return;
 397                        }
 398                }
 399
 400                if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
 401
 402                        info->rx_skb->dev = (void *) info->hdev;
 403                        bt_cb(info->rx_skb)->pkt_type = buf[i];
 404
 405                        switch (bt_cb(info->rx_skb)->pkt_type) {
 406
 407                        case 0x00:
 408                                /* init packet */
 409                                if (offset != 0x00) {
 410                                        set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
 411                                        set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
 412                                        set_bit(XMIT_SENDING_READY, &(info->tx_state));
 413                                        bluecard_write_wakeup(info);
 414                                }
 415
 416                                kfree_skb(info->rx_skb);
 417                                info->rx_skb = NULL;
 418                                break;
 419
 420                        case HCI_EVENT_PKT:
 421                                info->rx_state = RECV_WAIT_EVENT_HEADER;
 422                                info->rx_count = HCI_EVENT_HDR_SIZE;
 423                                break;
 424
 425                        case HCI_ACLDATA_PKT:
 426                                info->rx_state = RECV_WAIT_ACL_HEADER;
 427                                info->rx_count = HCI_ACL_HDR_SIZE;
 428                                break;
 429
 430                        case HCI_SCODATA_PKT:
 431                                info->rx_state = RECV_WAIT_SCO_HEADER;
 432                                info->rx_count = HCI_SCO_HDR_SIZE;
 433                                break;
 434
 435                        default:
 436                                /* unknown packet */
 437                                BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
 438                                info->hdev->stat.err_rx++;
 439
 440                                kfree_skb(info->rx_skb);
 441                                info->rx_skb = NULL;
 442                                break;
 443
 444                        }
 445
 446                } else {
 447
 448                        *skb_put(info->rx_skb, 1) = buf[i];
 449                        info->rx_count--;
 450
 451                        if (info->rx_count == 0) {
 452
 453                                int dlen;
 454                                struct hci_event_hdr *eh;
 455                                struct hci_acl_hdr *ah;
 456                                struct hci_sco_hdr *sh;
 457
 458                                switch (info->rx_state) {
 459
 460                                case RECV_WAIT_EVENT_HEADER:
 461                                        eh = hci_event_hdr(info->rx_skb);
 462                                        info->rx_state = RECV_WAIT_DATA;
 463                                        info->rx_count = eh->plen;
 464                                        break;
 465
 466                                case RECV_WAIT_ACL_HEADER:
 467                                        ah = hci_acl_hdr(info->rx_skb);
 468                                        dlen = __le16_to_cpu(ah->dlen);
 469                                        info->rx_state = RECV_WAIT_DATA;
 470                                        info->rx_count = dlen;
 471                                        break;
 472
 473                                case RECV_WAIT_SCO_HEADER:
 474                                        sh = hci_sco_hdr(info->rx_skb);
 475                                        info->rx_state = RECV_WAIT_DATA;
 476                                        info->rx_count = sh->dlen;
 477                                        break;
 478
 479                                case RECV_WAIT_DATA:
 480                                        hci_recv_frame(info->rx_skb);
 481                                        info->rx_skb = NULL;
 482                                        break;
 483
 484                                }
 485
 486                        }
 487
 488                }
 489
 490
 491        }
 492
 493        info->hdev->stat.byte_rx += len;
 494}
 495
 496
 497static irqreturn_t bluecard_interrupt(int irq, void *dev_inst)
 498{
 499        bluecard_info_t *info = dev_inst;
 500        unsigned int iobase;
 501        unsigned char reg;
 502
 503        if (!info || !info->hdev)
 504                /* our irq handler is shared */
 505                return IRQ_NONE;
 506
 507        if (!test_bit(CARD_READY, &(info->hw_state)))
 508                return IRQ_HANDLED;
 509
 510        iobase = info->p_dev->resource[0]->start;
 511
 512        spin_lock(&(info->lock));
 513
 514        /* Disable interrupt */
 515        info->ctrl_reg &= ~REG_CONTROL_INTERRUPT;
 516        outb(info->ctrl_reg, iobase + REG_CONTROL);
 517
 518        reg = inb(iobase + REG_INTERRUPT);
 519
 520        if ((reg != 0x00) && (reg != 0xff)) {
 521
 522                if (reg & 0x04) {
 523                        bluecard_receive(info, 0x00);
 524                        outb(0x04, iobase + REG_INTERRUPT);
 525                        outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);
 526                }
 527
 528                if (reg & 0x08) {
 529                        bluecard_receive(info, 0x10);
 530                        outb(0x08, iobase + REG_INTERRUPT);
 531                        outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);
 532                }
 533
 534                if (reg & 0x01) {
 535                        set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
 536                        outb(0x01, iobase + REG_INTERRUPT);
 537                        bluecard_write_wakeup(info);
 538                }
 539
 540                if (reg & 0x02) {
 541                        set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
 542                        outb(0x02, iobase + REG_INTERRUPT);
 543                        bluecard_write_wakeup(info);
 544                }
 545
 546        }
 547
 548        /* Enable interrupt */
 549        info->ctrl_reg |= REG_CONTROL_INTERRUPT;
 550        outb(info->ctrl_reg, iobase + REG_CONTROL);
 551
 552        spin_unlock(&(info->lock));
 553
 554        return IRQ_HANDLED;
 555}
 556
 557
 558
 559/* ======================== Device specific HCI commands ======================== */
 560
 561
 562static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud)
 563{
 564        bluecard_info_t *info = hci_get_drvdata(hdev);
 565        struct sk_buff *skb;
 566
 567        /* Ericsson baud rate command */
 568        unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 };
 569
 570        if (!(skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
 571                BT_ERR("Can't allocate mem for new packet");
 572                return -1;
 573        }
 574
 575        switch (baud) {
 576        case 460800:
 577                cmd[4] = 0x00;
 578                bt_cb(skb)->pkt_type = PKT_BAUD_RATE_460800;
 579                break;
 580        case 230400:
 581                cmd[4] = 0x01;
 582                bt_cb(skb)->pkt_type = PKT_BAUD_RATE_230400;
 583                break;
 584        case 115200:
 585                cmd[4] = 0x02;
 586                bt_cb(skb)->pkt_type = PKT_BAUD_RATE_115200;
 587                break;
 588        case 57600:
 589                /* Fall through... */
 590        default:
 591                cmd[4] = 0x03;
 592                bt_cb(skb)->pkt_type = PKT_BAUD_RATE_57600;
 593                break;
 594        }
 595
 596        memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
 597
 598        skb_queue_tail(&(info->txq), skb);
 599
 600        bluecard_write_wakeup(info);
 601
 602        return 0;
 603}
 604
 605
 606
 607/* ======================== HCI interface ======================== */
 608
 609
 610static int bluecard_hci_flush(struct hci_dev *hdev)
 611{
 612        bluecard_info_t *info = hci_get_drvdata(hdev);
 613
 614        /* Drop TX queue */
 615        skb_queue_purge(&(info->txq));
 616
 617        return 0;
 618}
 619
 620
 621static int bluecard_hci_open(struct hci_dev *hdev)
 622{
 623        bluecard_info_t *info = hci_get_drvdata(hdev);
 624
 625        if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
 626                bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE);
 627
 628        if (test_and_set_bit(HCI_RUNNING, &(hdev->flags)))
 629                return 0;
 630
 631        if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) {
 632                unsigned int iobase = info->p_dev->resource[0]->start;
 633
 634                /* Enable LED */
 635                outb(0x08 | 0x20, iobase + 0x30);
 636        }
 637
 638        return 0;
 639}
 640
 641
 642static int bluecard_hci_close(struct hci_dev *hdev)
 643{
 644        bluecard_info_t *info = hci_get_drvdata(hdev);
 645
 646        if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
 647                return 0;
 648
 649        bluecard_hci_flush(hdev);
 650
 651        if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) {
 652                unsigned int iobase = info->p_dev->resource[0]->start;
 653
 654                /* Disable LED */
 655                outb(0x00, iobase + 0x30);
 656        }
 657
 658        return 0;
 659}
 660
 661
 662static int bluecard_hci_send_frame(struct sk_buff *skb)
 663{
 664        bluecard_info_t *info;
 665        struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
 666
 667        if (!hdev) {
 668                BT_ERR("Frame for unknown HCI device (hdev=NULL)");
 669                return -ENODEV;
 670        }
 671
 672        info = hci_get_drvdata(hdev);
 673
 674        switch (bt_cb(skb)->pkt_type) {
 675        case HCI_COMMAND_PKT:
 676                hdev->stat.cmd_tx++;
 677                break;
 678        case HCI_ACLDATA_PKT:
 679                hdev->stat.acl_tx++;
 680                break;
 681        case HCI_SCODATA_PKT:
 682                hdev->stat.sco_tx++;
 683                break;
 684        };
 685
 686        /* Prepend skb with frame type */
 687        memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 688        skb_queue_tail(&(info->txq), skb);
 689
 690        bluecard_write_wakeup(info);
 691
 692        return 0;
 693}
 694
 695
 696static int bluecard_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
 697{
 698        return -ENOIOCTLCMD;
 699}
 700
 701
 702
 703/* ======================== Card services HCI interaction ======================== */
 704
 705
 706static int bluecard_open(bluecard_info_t *info)
 707{
 708        unsigned int iobase = info->p_dev->resource[0]->start;
 709        struct hci_dev *hdev;
 710        unsigned char id;
 711
 712        spin_lock_init(&(info->lock));
 713
 714        init_timer(&(info->timer));
 715        info->timer.function = &bluecard_activity_led_timeout;
 716        info->timer.data = (u_long)info;
 717
 718        skb_queue_head_init(&(info->txq));
 719
 720        info->rx_state = RECV_WAIT_PACKET_TYPE;
 721        info->rx_count = 0;
 722        info->rx_skb = NULL;
 723
 724        /* Initialize HCI device */
 725        hdev = hci_alloc_dev();
 726        if (!hdev) {
 727                BT_ERR("Can't allocate HCI device");
 728                return -ENOMEM;
 729        }
 730
 731        info->hdev = hdev;
 732
 733        hdev->bus = HCI_PCCARD;
 734        hci_set_drvdata(hdev, info);
 735        SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 736
 737        hdev->open     = bluecard_hci_open;
 738        hdev->close    = bluecard_hci_close;
 739        hdev->flush    = bluecard_hci_flush;
 740        hdev->send     = bluecard_hci_send_frame;
 741        hdev->ioctl    = bluecard_hci_ioctl;
 742
 743        id = inb(iobase + 0x30);
 744
 745        if ((id & 0x0f) == 0x02)
 746                set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state));
 747
 748        if (id & 0x10)
 749                set_bit(CARD_HAS_POWER_LED, &(info->hw_state));
 750
 751        if (id & 0x20)
 752                set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state));
 753
 754        /* Reset card */
 755        info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;
 756        outb(info->ctrl_reg, iobase + REG_CONTROL);
 757
 758        /* Turn FPGA off */
 759        outb(0x80, iobase + 0x30);
 760
 761        /* Wait some time */
 762        msleep(10);
 763
 764        /* Turn FPGA on */
 765        outb(0x00, iobase + 0x30);
 766
 767        /* Activate card */
 768        info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU;
 769        outb(info->ctrl_reg, iobase + REG_CONTROL);
 770
 771        /* Enable interrupt */
 772        outb(0xff, iobase + REG_INTERRUPT);
 773        info->ctrl_reg |= REG_CONTROL_INTERRUPT;
 774        outb(info->ctrl_reg, iobase + REG_CONTROL);
 775
 776        if ((id & 0x0f) == 0x03) {
 777                /* Disable RTS */
 778                info->ctrl_reg |= REG_CONTROL_RTS;
 779                outb(info->ctrl_reg, iobase + REG_CONTROL);
 780
 781                /* Set baud rate */
 782                info->ctrl_reg |= 0x03;
 783                outb(info->ctrl_reg, iobase + REG_CONTROL);
 784
 785                /* Enable RTS */
 786                info->ctrl_reg &= ~REG_CONTROL_RTS;
 787                outb(info->ctrl_reg, iobase + REG_CONTROL);
 788
 789                set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
 790                set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
 791                set_bit(XMIT_SENDING_READY, &(info->tx_state));
 792        }
 793
 794        /* Start the RX buffers */
 795        outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);
 796        outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);
 797
 798        /* Signal that the hardware is ready */
 799        set_bit(CARD_READY, &(info->hw_state));
 800
 801        /* Drop TX queue */
 802        skb_queue_purge(&(info->txq));
 803
 804        /* Control the point at which RTS is enabled */
 805        outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL);
 806
 807        /* Timeout before it is safe to send the first HCI packet */
 808        msleep(1250);
 809
 810        /* Register HCI device */
 811        if (hci_register_dev(hdev) < 0) {
 812                BT_ERR("Can't register HCI device");
 813                info->hdev = NULL;
 814                hci_free_dev(hdev);
 815                return -ENODEV;
 816        }
 817
 818        return 0;
 819}
 820
 821
 822static int bluecard_close(bluecard_info_t *info)
 823{
 824        unsigned int iobase = info->p_dev->resource[0]->start;
 825        struct hci_dev *hdev = info->hdev;
 826
 827        if (!hdev)
 828                return -ENODEV;
 829
 830        bluecard_hci_close(hdev);
 831
 832        clear_bit(CARD_READY, &(info->hw_state));
 833
 834        /* Reset card */
 835        info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;
 836        outb(info->ctrl_reg, iobase + REG_CONTROL);
 837
 838        /* Turn FPGA off */
 839        outb(0x80, iobase + 0x30);
 840
 841        hci_unregister_dev(hdev);
 842        hci_free_dev(hdev);
 843
 844        return 0;
 845}
 846
 847static int bluecard_probe(struct pcmcia_device *link)
 848{
 849        bluecard_info_t *info;
 850
 851        /* Create new info device */
 852        info = kzalloc(sizeof(*info), GFP_KERNEL);
 853        if (!info)
 854                return -ENOMEM;
 855
 856        info->p_dev = link;
 857        link->priv = info;
 858
 859        link->config_flags |= CONF_ENABLE_IRQ;
 860
 861        return bluecard_config(link);
 862}
 863
 864
 865static void bluecard_detach(struct pcmcia_device *link)
 866{
 867        bluecard_info_t *info = link->priv;
 868
 869        bluecard_release(link);
 870        kfree(info);
 871}
 872
 873
 874static int bluecard_config(struct pcmcia_device *link)
 875{
 876        bluecard_info_t *info = link->priv;
 877        int i, n;
 878
 879        link->config_index = 0x20;
 880
 881        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 882        link->resource[0]->end = 64;
 883        link->io_lines = 6;
 884
 885        for (n = 0; n < 0x400; n += 0x40) {
 886                link->resource[0]->start = n ^ 0x300;
 887                i = pcmcia_request_io(link);
 888                if (i == 0)
 889                        break;
 890        }
 891
 892        if (i != 0)
 893                goto failed;
 894
 895        i = pcmcia_request_irq(link, bluecard_interrupt);
 896        if (i != 0)
 897                goto failed;
 898
 899        i = pcmcia_enable_device(link);
 900        if (i != 0)
 901                goto failed;
 902
 903        if (bluecard_open(info) != 0)
 904                goto failed;
 905
 906        return 0;
 907
 908failed:
 909        bluecard_release(link);
 910        return -ENODEV;
 911}
 912
 913
 914static void bluecard_release(struct pcmcia_device *link)
 915{
 916        bluecard_info_t *info = link->priv;
 917
 918        bluecard_close(info);
 919
 920        del_timer(&(info->timer));
 921
 922        pcmcia_disable_device(link);
 923}
 924
 925static const struct pcmcia_device_id bluecard_ids[] = {
 926        PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e),
 927        PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c),
 928        PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab),
 929        PCMCIA_DEVICE_NULL
 930};
 931MODULE_DEVICE_TABLE(pcmcia, bluecard_ids);
 932
 933static struct pcmcia_driver bluecard_driver = {
 934        .owner          = THIS_MODULE,
 935        .name           = "bluecard_cs",
 936        .probe          = bluecard_probe,
 937        .remove         = bluecard_detach,
 938        .id_table       = bluecard_ids,
 939};
 940
 941static int __init init_bluecard_cs(void)
 942{
 943        return pcmcia_register_driver(&bluecard_driver);
 944}
 945
 946
 947static void __exit exit_bluecard_cs(void)
 948{
 949        pcmcia_unregister_driver(&bluecard_driver);
 950}
 951
 952module_init(init_bluecard_cs);
 953module_exit(exit_bluecard_cs);
 954
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.