linux/drivers/bluetooth/bt3c_cs.c
<<
>>
Prefs
   1/*
   2 *
   3 *  Driver for the 3Com Bluetooth PCMCIA card
   4 *
   5 *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org>
   6 *                           Jose Orlando Pereira <jop@di.uminho.pt>
   7 *
   8 *
   9 *  This program is free software; you can redistribute it and/or modify
  10 *  it under the terms of the GNU General Public License version 2 as
  11 *  published by the Free Software Foundation;
  12 *
  13 *  Software distributed under the License is distributed on an "AS
  14 *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  15 *  implied. See the License for the specific language governing
  16 *  rights and limitations under the License.
  17 *
  18 *  The initial developer of the original code is David A. Hinds
  19 *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  20 *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  21 *
  22 */
  23
  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/delay.h>
  31#include <linux/errno.h>
  32#include <linux/ptrace.h>
  33#include <linux/ioport.h>
  34#include <linux/spinlock.h>
  35#include <linux/moduleparam.h>
  36
  37#include <linux/skbuff.h>
  38#include <linux/string.h>
  39#include <linux/serial.h>
  40#include <linux/serial_reg.h>
  41#include <linux/bitops.h>
  42#include <asm/io.h>
  43
  44#include <linux/device.h>
  45#include <linux/firmware.h>
  46
  47#include <pcmcia/cistpl.h>
  48#include <pcmcia/ciscode.h>
  49#include <pcmcia/ds.h>
  50#include <pcmcia/cisreg.h>
  51
  52#include <net/bluetooth/bluetooth.h>
  53#include <net/bluetooth/hci_core.h>
  54
  55
  56
  57/* ======================== Module parameters ======================== */
  58
  59
  60MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
  61MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
  62MODULE_LICENSE("GPL");
  63MODULE_FIRMWARE("BT3CPCC.bin");
  64
  65
  66
  67/* ======================== Local structures ======================== */
  68
  69
  70struct bt3c_info {
  71        struct pcmcia_device *p_dev;
  72
  73        struct hci_dev *hdev;
  74
  75        spinlock_t lock;                /* For serializing operations */
  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
  85
  86static int bt3c_config(struct pcmcia_device *link);
  87static void bt3c_release(struct pcmcia_device *link);
  88
  89static void bt3c_detach(struct pcmcia_device *p_dev);
  90
  91
  92/* Transmit states  */
  93#define XMIT_SENDING  1
  94#define XMIT_WAKEUP   2
  95#define XMIT_WAITING  8
  96
  97/* Receiver states */
  98#define RECV_WAIT_PACKET_TYPE   0
  99#define RECV_WAIT_EVENT_HEADER  1
 100#define RECV_WAIT_ACL_HEADER    2
 101#define RECV_WAIT_SCO_HEADER    3
 102#define RECV_WAIT_DATA          4
 103
 104
 105
 106/* ======================== Special I/O functions ======================== */
 107
 108
 109#define DATA_L   0
 110#define DATA_H   1
 111#define ADDR_L   2
 112#define ADDR_H   3
 113#define CONTROL  4
 114
 115
 116static inline void bt3c_address(unsigned int iobase, unsigned short addr)
 117{
 118        outb(addr & 0xff, iobase + ADDR_L);
 119        outb((addr >> 8) & 0xff, iobase + ADDR_H);
 120}
 121
 122
 123static inline void bt3c_put(unsigned int iobase, unsigned short value)
 124{
 125        outb(value & 0xff, iobase + DATA_L);
 126        outb((value >> 8) & 0xff, iobase + DATA_H);
 127}
 128
 129
 130static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
 131{
 132        bt3c_address(iobase, addr);
 133        bt3c_put(iobase, value);
 134}
 135
 136
 137static inline unsigned short bt3c_get(unsigned int iobase)
 138{
 139        unsigned short value = inb(iobase + DATA_L);
 140
 141        value |= inb(iobase + DATA_H) << 8;
 142
 143        return value;
 144}
 145
 146
 147static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
 148{
 149        bt3c_address(iobase, addr);
 150
 151        return bt3c_get(iobase);
 152}
 153
 154
 155
 156/* ======================== Interrupt handling ======================== */
 157
 158
 159static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
 160{
 161        int actual = 0;
 162
 163        bt3c_address(iobase, 0x7080);
 164
 165        /* Fill FIFO with current frame */
 166        while (actual < len) {
 167                /* Transmit next byte */
 168                bt3c_put(iobase, buf[actual]);
 169                actual++;
 170        }
 171
 172        bt3c_io_write(iobase, 0x7005, actual);
 173
 174        return actual;
 175}
 176
 177
 178static void bt3c_write_wakeup(struct bt3c_info *info)
 179{
 180        if (!info) {
 181                BT_ERR("Unknown device");
 182                return;
 183        }
 184
 185        if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
 186                return;
 187
 188        do {
 189                unsigned int iobase = info->p_dev->resource[0]->start;
 190                register struct sk_buff *skb;
 191                int len;
 192
 193                if (!pcmcia_dev_present(info->p_dev))
 194                        break;
 195
 196                skb = skb_dequeue(&(info->txq));
 197                if (!skb) {
 198                        clear_bit(XMIT_SENDING, &(info->tx_state));
 199                        break;
 200                }
 201
 202                /* Send frame */
 203                len = bt3c_write(iobase, 256, skb->data, skb->len);
 204
 205                if (len != skb->len)
 206                        BT_ERR("Very strange");
 207
 208                kfree_skb(skb);
 209
 210                info->hdev->stat.byte_tx += len;
 211
 212        } while (0);
 213}
 214
 215
 216static void bt3c_receive(struct bt3c_info *info)
 217{
 218        unsigned int iobase;
 219        int size = 0, avail;
 220
 221        if (!info) {
 222                BT_ERR("Unknown device");
 223                return;
 224        }
 225
 226        iobase = info->p_dev->resource[0]->start;
 227
 228        avail = bt3c_read(iobase, 0x7006);
 229
 230        bt3c_address(iobase, 0x7480);
 231        while (size < avail) {
 232                size++;
 233                info->hdev->stat.byte_rx++;
 234
 235                /* Allocate packet */
 236                if (!info->rx_skb) {
 237                        info->rx_state = RECV_WAIT_PACKET_TYPE;
 238                        info->rx_count = 0;
 239                        info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
 240                        if (!info->rx_skb) {
 241                                BT_ERR("Can't allocate mem for new packet");
 242                                return;
 243                        }
 244                }
 245
 246
 247                if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
 248
 249                        hci_skb_pkt_type(info->rx_skb) = inb(iobase + DATA_L);
 250                        inb(iobase + DATA_H);
 251
 252                        switch (hci_skb_pkt_type(info->rx_skb)) {
 253
 254                        case HCI_EVENT_PKT:
 255                                info->rx_state = RECV_WAIT_EVENT_HEADER;
 256                                info->rx_count = HCI_EVENT_HDR_SIZE;
 257                                break;
 258
 259                        case HCI_ACLDATA_PKT:
 260                                info->rx_state = RECV_WAIT_ACL_HEADER;
 261                                info->rx_count = HCI_ACL_HDR_SIZE;
 262                                break;
 263
 264                        case HCI_SCODATA_PKT:
 265                                info->rx_state = RECV_WAIT_SCO_HEADER;
 266                                info->rx_count = HCI_SCO_HDR_SIZE;
 267                                break;
 268
 269                        default:
 270                                /* Unknown packet */
 271                                BT_ERR("Unknown HCI packet with type 0x%02x received",
 272                                       hci_skb_pkt_type(info->rx_skb));
 273                                info->hdev->stat.err_rx++;
 274
 275                                kfree_skb(info->rx_skb);
 276                                info->rx_skb = NULL;
 277                                break;
 278
 279                        }
 280
 281                } else {
 282
 283                        __u8 x = inb(iobase + DATA_L);
 284
 285                        skb_put_u8(info->rx_skb, x);
 286                        inb(iobase + DATA_H);
 287                        info->rx_count--;
 288
 289                        if (info->rx_count == 0) {
 290
 291                                int dlen;
 292                                struct hci_event_hdr *eh;
 293                                struct hci_acl_hdr *ah;
 294                                struct hci_sco_hdr *sh;
 295
 296                                switch (info->rx_state) {
 297
 298                                case RECV_WAIT_EVENT_HEADER:
 299                                        eh = hci_event_hdr(info->rx_skb);
 300                                        info->rx_state = RECV_WAIT_DATA;
 301                                        info->rx_count = eh->plen;
 302                                        break;
 303
 304                                case RECV_WAIT_ACL_HEADER:
 305                                        ah = hci_acl_hdr(info->rx_skb);
 306                                        dlen = __le16_to_cpu(ah->dlen);
 307                                        info->rx_state = RECV_WAIT_DATA;
 308                                        info->rx_count = dlen;
 309                                        break;
 310
 311                                case RECV_WAIT_SCO_HEADER:
 312                                        sh = hci_sco_hdr(info->rx_skb);
 313                                        info->rx_state = RECV_WAIT_DATA;
 314                                        info->rx_count = sh->dlen;
 315                                        break;
 316
 317                                case RECV_WAIT_DATA:
 318                                        hci_recv_frame(info->hdev, info->rx_skb);
 319                                        info->rx_skb = NULL;
 320                                        break;
 321
 322                                }
 323
 324                        }
 325
 326                }
 327
 328        }
 329
 330        bt3c_io_write(iobase, 0x7006, 0x0000);
 331}
 332
 333
 334static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
 335{
 336        struct bt3c_info *info = dev_inst;
 337        unsigned int iobase;
 338        int iir;
 339        irqreturn_t r = IRQ_NONE;
 340
 341        if (!info || !info->hdev)
 342                /* our irq handler is shared */
 343                return IRQ_NONE;
 344
 345        iobase = info->p_dev->resource[0]->start;
 346
 347        spin_lock(&(info->lock));
 348
 349        iir = inb(iobase + CONTROL);
 350        if (iir & 0x80) {
 351                int stat = bt3c_read(iobase, 0x7001);
 352
 353                if ((stat & 0xff) == 0x7f) {
 354                        BT_ERR("Very strange (stat=0x%04x)", stat);
 355                } else if ((stat & 0xff) != 0xff) {
 356                        if (stat & 0x0020) {
 357                                int status = bt3c_read(iobase, 0x7002) & 0x10;
 358                                bt_dev_info(info->hdev, "Antenna %s",
 359                                                        status ? "out" : "in");
 360                        }
 361                        if (stat & 0x0001)
 362                                bt3c_receive(info);
 363                        if (stat & 0x0002) {
 364                                clear_bit(XMIT_SENDING, &(info->tx_state));
 365                                bt3c_write_wakeup(info);
 366                        }
 367
 368                        bt3c_io_write(iobase, 0x7001, 0x0000);
 369
 370                        outb(iir, iobase + CONTROL);
 371                }
 372                r = IRQ_HANDLED;
 373        }
 374
 375        spin_unlock(&(info->lock));
 376
 377        return r;
 378}
 379
 380
 381
 382/* ======================== HCI interface ======================== */
 383
 384
 385static int bt3c_hci_flush(struct hci_dev *hdev)
 386{
 387        struct bt3c_info *info = hci_get_drvdata(hdev);
 388
 389        /* Drop TX queue */
 390        skb_queue_purge(&(info->txq));
 391
 392        return 0;
 393}
 394
 395
 396static int bt3c_hci_open(struct hci_dev *hdev)
 397{
 398        return 0;
 399}
 400
 401
 402static int bt3c_hci_close(struct hci_dev *hdev)
 403{
 404        bt3c_hci_flush(hdev);
 405
 406        return 0;
 407}
 408
 409
 410static int bt3c_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 411{
 412        struct bt3c_info *info = hci_get_drvdata(hdev);
 413        unsigned long flags;
 414
 415        switch (hci_skb_pkt_type(skb)) {
 416        case HCI_COMMAND_PKT:
 417                hdev->stat.cmd_tx++;
 418                break;
 419        case HCI_ACLDATA_PKT:
 420                hdev->stat.acl_tx++;
 421                break;
 422        case HCI_SCODATA_PKT:
 423                hdev->stat.sco_tx++;
 424                break;
 425        }
 426
 427        /* Prepend skb with frame type */
 428        memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
 429        skb_queue_tail(&(info->txq), skb);
 430
 431        spin_lock_irqsave(&(info->lock), flags);
 432
 433        bt3c_write_wakeup(info);
 434
 435        spin_unlock_irqrestore(&(info->lock), flags);
 436
 437        return 0;
 438}
 439
 440
 441
 442/* ======================== Card services HCI interaction ======================== */
 443
 444
 445static int bt3c_load_firmware(struct bt3c_info *info,
 446                              const unsigned char *firmware,
 447                              int count)
 448{
 449        char *ptr = (char *) firmware;
 450        char b[9];
 451        unsigned int iobase, tmp;
 452        unsigned long size, addr, fcs;
 453        int i, err = 0;
 454
 455        iobase = info->p_dev->resource[0]->start;
 456
 457        /* Reset */
 458        bt3c_io_write(iobase, 0x8040, 0x0404);
 459        bt3c_io_write(iobase, 0x8040, 0x0400);
 460
 461        udelay(1);
 462
 463        bt3c_io_write(iobase, 0x8040, 0x0404);
 464
 465        udelay(17);
 466
 467        /* Load */
 468        while (count) {
 469                if (ptr[0] != 'S') {
 470                        BT_ERR("Bad address in firmware");
 471                        err = -EFAULT;
 472                        goto error;
 473                }
 474
 475                memset(b, 0, sizeof(b));
 476                memcpy(b, ptr + 2, 2);
 477                if (kstrtoul(b, 16, &size) < 0)
 478                        return -EINVAL;
 479
 480                memset(b, 0, sizeof(b));
 481                memcpy(b, ptr + 4, 8);
 482                if (kstrtoul(b, 16, &addr) < 0)
 483                        return -EINVAL;
 484
 485                memset(b, 0, sizeof(b));
 486                memcpy(b, ptr + (size * 2) + 2, 2);
 487                if (kstrtoul(b, 16, &fcs) < 0)
 488                        return -EINVAL;
 489
 490                memset(b, 0, sizeof(b));
 491                for (tmp = 0, i = 0; i < size; i++) {
 492                        memcpy(b, ptr + (i * 2) + 2, 2);
 493                        tmp += simple_strtol(b, NULL, 16);
 494                }
 495
 496                if (((tmp + fcs) & 0xff) != 0xff) {
 497                        BT_ERR("Checksum error in firmware");
 498                        err = -EILSEQ;
 499                        goto error;
 500                }
 501
 502                if (ptr[1] == '3') {
 503                        bt3c_address(iobase, addr);
 504
 505                        memset(b, 0, sizeof(b));
 506                        for (i = 0; i < (size - 4) / 2; i++) {
 507                                memcpy(b, ptr + (i * 4) + 12, 4);
 508                                tmp = simple_strtoul(b, NULL, 16);
 509                                bt3c_put(iobase, tmp);
 510                        }
 511                }
 512
 513                ptr   += (size * 2) + 6;
 514                count -= (size * 2) + 6;
 515        }
 516
 517        udelay(17);
 518
 519        /* Boot */
 520        bt3c_address(iobase, 0x3000);
 521        outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
 522
 523error:
 524        udelay(17);
 525
 526        /* Clear */
 527        bt3c_io_write(iobase, 0x7006, 0x0000);
 528        bt3c_io_write(iobase, 0x7005, 0x0000);
 529        bt3c_io_write(iobase, 0x7001, 0x0000);
 530
 531        return err;
 532}
 533
 534
 535static int bt3c_open(struct bt3c_info *info)
 536{
 537        const struct firmware *firmware;
 538        struct hci_dev *hdev;
 539        int err;
 540
 541        spin_lock_init(&(info->lock));
 542
 543        skb_queue_head_init(&(info->txq));
 544
 545        info->rx_state = RECV_WAIT_PACKET_TYPE;
 546        info->rx_count = 0;
 547        info->rx_skb = NULL;
 548
 549        /* Initialize HCI device */
 550        hdev = hci_alloc_dev();
 551        if (!hdev) {
 552                BT_ERR("Can't allocate HCI device");
 553                return -ENOMEM;
 554        }
 555
 556        info->hdev = hdev;
 557
 558        hdev->bus = HCI_PCCARD;
 559        hci_set_drvdata(hdev, info);
 560        SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 561
 562        hdev->open  = bt3c_hci_open;
 563        hdev->close = bt3c_hci_close;
 564        hdev->flush = bt3c_hci_flush;
 565        hdev->send  = bt3c_hci_send_frame;
 566
 567        /* Load firmware */
 568        err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
 569        if (err < 0) {
 570                BT_ERR("Firmware request failed");
 571                goto error;
 572        }
 573
 574        err = bt3c_load_firmware(info, firmware->data, firmware->size);
 575
 576        release_firmware(firmware);
 577
 578        if (err < 0) {
 579                BT_ERR("Firmware loading failed");
 580                goto error;
 581        }
 582
 583        /* Timeout before it is safe to send the first HCI packet */
 584        msleep(1000);
 585
 586        /* Register HCI device */
 587        err = hci_register_dev(hdev);
 588        if (err < 0) {
 589                BT_ERR("Can't register HCI device");
 590                goto error;
 591        }
 592
 593        return 0;
 594
 595error:
 596        info->hdev = NULL;
 597        hci_free_dev(hdev);
 598        return err;
 599}
 600
 601
 602static int bt3c_close(struct bt3c_info *info)
 603{
 604        struct hci_dev *hdev = info->hdev;
 605
 606        if (!hdev)
 607                return -ENODEV;
 608
 609        bt3c_hci_close(hdev);
 610
 611        hci_unregister_dev(hdev);
 612        hci_free_dev(hdev);
 613
 614        return 0;
 615}
 616
 617static int bt3c_probe(struct pcmcia_device *link)
 618{
 619        struct bt3c_info *info;
 620
 621        /* Create new info device */
 622        info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
 623        if (!info)
 624                return -ENOMEM;
 625
 626        info->p_dev = link;
 627        link->priv = info;
 628
 629        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
 630                CONF_AUTO_SET_IO;
 631
 632        return bt3c_config(link);
 633}
 634
 635
 636static void bt3c_detach(struct pcmcia_device *link)
 637{
 638        bt3c_release(link);
 639}
 640
 641static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
 642{
 643        int *try = priv_data;
 644
 645        if (!try)
 646                p_dev->io_lines = 16;
 647
 648        if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
 649                return -EINVAL;
 650
 651        p_dev->resource[0]->end = 8;
 652        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 653        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 654
 655        return pcmcia_request_io(p_dev);
 656}
 657
 658static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
 659                                      void *priv_data)
 660{
 661        static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 662        int j;
 663
 664        if (p_dev->io_lines > 3)
 665                return -ENODEV;
 666
 667        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 668        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 669        p_dev->resource[0]->end = 8;
 670
 671        for (j = 0; j < 5; j++) {
 672                p_dev->resource[0]->start = base[j];
 673                p_dev->io_lines = base[j] ? 16 : 3;
 674                if (!pcmcia_request_io(p_dev))
 675                        return 0;
 676        }
 677        return -ENODEV;
 678}
 679
 680static int bt3c_config(struct pcmcia_device *link)
 681{
 682        struct bt3c_info *info = link->priv;
 683        int i;
 684        unsigned long try;
 685
 686        /* First pass: look for a config entry that looks normal.
 687         * Two tries: without IO aliases, then with aliases
 688         */
 689        for (try = 0; try < 2; try++)
 690                if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
 691                        goto found_port;
 692
 693        /* Second pass: try to find an entry that isn't picky about
 694         * its base address, then try to grab any standard serial port
 695         * address, and finally try to get any free port.
 696         */
 697        if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
 698                goto found_port;
 699
 700        BT_ERR("No usable port range found");
 701        goto failed;
 702
 703found_port:
 704        i = pcmcia_request_irq(link, &bt3c_interrupt);
 705        if (i != 0)
 706                goto failed;
 707
 708        i = pcmcia_enable_device(link);
 709        if (i != 0)
 710                goto failed;
 711
 712        if (bt3c_open(info) != 0)
 713                goto failed;
 714
 715        return 0;
 716
 717failed:
 718        bt3c_release(link);
 719        return -ENODEV;
 720}
 721
 722
 723static void bt3c_release(struct pcmcia_device *link)
 724{
 725        struct bt3c_info *info = link->priv;
 726
 727        bt3c_close(info);
 728
 729        pcmcia_disable_device(link);
 730}
 731
 732
 733static const struct pcmcia_device_id bt3c_ids[] = {
 734        PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
 735        PCMCIA_DEVICE_NULL
 736};
 737MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
 738
 739static struct pcmcia_driver bt3c_driver = {
 740        .owner          = THIS_MODULE,
 741        .name           = "bt3c_cs",
 742        .probe          = bt3c_probe,
 743        .remove         = bt3c_detach,
 744        .id_table       = bt3c_ids,
 745};
 746module_pcmcia_driver(bt3c_driver);
 747