LXR linux/drivers/bluetooth/btuart

   1/*
   2 *
   3 *  Driver for Bluetooth PCMCIA cards with HCI UART interface
   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/delay.h>
  30#include <linux/errno.h>
  31#include <linux/ptrace.h>
  32#include <linux/ioport.h>
  33#include <linux/spinlock.h>
  34#include <linux/moduleparam.h>
  35
  36#include <linux/skbuff.h>
  37#include <linux/string.h>
  38#include <linux/serial.h>
  39#include <linux/serial_reg.h>
  40#include <linux/bitops.h>
  41#include <asm/io.h>
  42
  43#include <pcmcia/cistpl.h>
  44#include <pcmcia/ciscode.h>
  45#include <pcmcia/ds.h>
  46#include <pcmcia/cisreg.h>
  47
  48#include <net/bluetooth/bluetooth.h>
  49#include <net/bluetooth/hci_core.h>
  50
  51
  52
  53/* ======================== Module parameters ======================== */
  54
  55
  56MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
  57MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
  58MODULE_LICENSE("GPL");
  59
  60
  61
  62/* ======================== Local structures ======================== */
  63
  64
  65struct btuart_info {
  66        struct pcmcia_device *p_dev;
  67
  68        struct hci_dev *hdev;
  69
  70        spinlock_t lock;        /* For serializing operations */
  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
  80
  81static int btuart_config(struct pcmcia_device *link);
  82static void btuart_release(struct pcmcia_device *link);
  83
  84static void btuart_detach(struct pcmcia_device *p_dev);
  85
  86
  87/* Maximum baud rate */
  88#define SPEED_MAX  115200
  89
  90/* Default baud rate: 57600, 115200, 230400 or 460800 */
  91#define DEFAULT_BAUD_RATE  115200
  92
  93
  94/* Transmit states  */
  95#define XMIT_SENDING    1
  96#define XMIT_WAKEUP     2
  97#define XMIT_WAITING    8
  98
  99/* Receiver states */
 100#define RECV_WAIT_PACKET_TYPE   0
 101#define RECV_WAIT_EVENT_HEADER  1
 102#define RECV_WAIT_ACL_HEADER    2
 103#define RECV_WAIT_SCO_HEADER    3
 104#define RECV_WAIT_DATA          4
 105
 106
 107
 108/* ======================== Interrupt handling ======================== */
 109
 110
 111static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
 112{
 113        int actual = 0;
 114
 115        /* Tx FIFO should be empty */
 116        if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
 117                return 0;
 118
 119        /* Fill FIFO with current frame */
 120        while ((fifo_size-- > 0) && (actual < len)) {
 121                /* Transmit next byte */
 122                outb(buf[actual], iobase + UART_TX);
 123                actual++;
 124        }
 125
 126        return actual;
 127}
 128
 129
 130static void btuart_write_wakeup(struct btuart_info *info)
 131{
 132        if (!info) {
 133                BT_ERR("Unknown device");
 134                return;
 135        }
 136
 137        if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
 138                set_bit(XMIT_WAKEUP, &(info->tx_state));
 139                return;
 140        }
 141
 142        do {
 143                unsigned int iobase = info->p_dev->resource[0]->start;
 144                register struct sk_buff *skb;
 145                int len;
 146
 147                clear_bit(XMIT_WAKEUP, &(info->tx_state));
 148
 149                if (!pcmcia_dev_present(info->p_dev))
 150                        return;
 151
 152                skb = skb_dequeue(&(info->txq));
 153                if (!skb)
 154                        break;
 155
 156                /* Send frame */
 157                len = btuart_write(iobase, 16, skb->data, skb->len);
 158                set_bit(XMIT_WAKEUP, &(info->tx_state));
 159
 160                if (len == skb->len) {
 161                        kfree_skb(skb);
 162                } else {
 163                        skb_pull(skb, len);
 164                        skb_queue_head(&(info->txq), skb);
 165                }
 166
 167                info->hdev->stat.byte_tx += len;
 168
 169        } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
 170
 171        clear_bit(XMIT_SENDING, &(info->tx_state));
 172}
 173
 174
 175static void btuart_receive(struct btuart_info *info)
 176{
 177        unsigned int iobase;
 178        int boguscount = 0;
 179
 180        if (!info) {
 181                BT_ERR("Unknown device");
 182                return;
 183        }
 184
 185        iobase = info->p_dev->resource[0]->start;
 186
 187        do {
 188                info->hdev->stat.byte_rx++;
 189
 190                /* Allocate packet */
 191                if (info->rx_skb == NULL) {
 192                        info->rx_state = RECV_WAIT_PACKET_TYPE;
 193                        info->rx_count = 0;
 194                        info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
 195                        if (!info->rx_skb) {
 196                                BT_ERR("Can't allocate mem for new packet");
 197                                return;
 198                        }
 199                }
 200
 201                if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
 202
 203                        bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
 204
 205                        switch (bt_cb(info->rx_skb)->pkt_type) {
 206
 207                        case HCI_EVENT_PKT:
 208                                info->rx_state = RECV_WAIT_EVENT_HEADER;
 209                                info->rx_count = HCI_EVENT_HDR_SIZE;
 210                                break;
 211
 212                        case HCI_ACLDATA_PKT:
 213                                info->rx_state = RECV_WAIT_ACL_HEADER;
 214                                info->rx_count = HCI_ACL_HDR_SIZE;
 215                                break;
 216
 217                        case HCI_SCODATA_PKT:
 218                                info->rx_state = RECV_WAIT_SCO_HEADER;
 219                                info->rx_count = HCI_SCO_HDR_SIZE;
 220                                break;
 221
 222                        default:
 223                                /* Unknown packet */
 224                                BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
 225                                info->hdev->stat.err_rx++;
 226                                clear_bit(HCI_RUNNING, &(info->hdev->flags));
 227
 228                                kfree_skb(info->rx_skb);
 229                                info->rx_skb = NULL;
 230                                break;
 231
 232                        }
 233
 234                } else {
 235
 236                        *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
 237                        info->rx_count--;
 238
 239                        if (info->rx_count == 0) {
 240
 241                                int dlen;
 242                                struct hci_event_hdr *eh;
 243                                struct hci_acl_hdr *ah;
 244                                struct hci_sco_hdr *sh;
 245
 246
 247                                switch (info->rx_state) {
 248
 249                                case RECV_WAIT_EVENT_HEADER:
 250                                        eh = hci_event_hdr(info->rx_skb);
 251                                        info->rx_state = RECV_WAIT_DATA;
 252                                        info->rx_count = eh->plen;
 253                                        break;
 254
 255                                case RECV_WAIT_ACL_HEADER:
 256                                        ah = hci_acl_hdr(info->rx_skb);
 257                                        dlen = __le16_to_cpu(ah->dlen);
 258                                        info->rx_state = RECV_WAIT_DATA;
 259                                        info->rx_count = dlen;
 260                                        break;
 261
 262                                case RECV_WAIT_SCO_HEADER:
 263                                        sh = hci_sco_hdr(info->rx_skb);
 264                                        info->rx_state = RECV_WAIT_DATA;
 265                                        info->rx_count = sh->dlen;
 266                                        break;
 267
 268                                case RECV_WAIT_DATA:
 269                                        hci_recv_frame(info->hdev, info->rx_skb);
 270                                        info->rx_skb = NULL;
 271                                        break;
 272
 273                                }
 274
 275                        }
 276
 277                }
 278
 279                /* Make sure we don't stay here too long */
 280                if (boguscount++ > 16)
 281                        break;
 282
 283        } while (inb(iobase + UART_LSR) & UART_LSR_DR);
 284}
 285
 286
 287static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
 288{
 289        struct btuart_info *info = dev_inst;
 290        unsigned int iobase;
 291        int boguscount = 0;
 292        int iir, lsr;
 293        irqreturn_t r = IRQ_NONE;
 294
 295        if (!info || !info->hdev)
 296                /* our irq handler is shared */
 297                return IRQ_NONE;
 298
 299        iobase = info->p_dev->resource[0]->start;
 300
 301        spin_lock(&(info->lock));
 302
 303        iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 304        while (iir) {
 305                r = IRQ_HANDLED;
 306
 307                /* Clear interrupt */
 308                lsr = inb(iobase + UART_LSR);
 309
 310                switch (iir) {
 311                case UART_IIR_RLSI:
 312                        BT_ERR("RLSI");
 313                        break;
 314                case UART_IIR_RDI:
 315                        /* Receive interrupt */
 316                        btuart_receive(info);
 317                        break;
 318                case UART_IIR_THRI:
 319                        if (lsr & UART_LSR_THRE) {
 320                                /* Transmitter ready for data */
 321                                btuart_write_wakeup(info);
 322                        }
 323                        break;
 324                default:
 325                        BT_ERR("Unhandled IIR=%#x", iir);
 326                        break;
 327                }
 328
 329                /* Make sure we don't stay here too long */
 330                if (boguscount++ > 100)
 331                        break;
 332
 333                iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 334
 335        }
 336
 337        spin_unlock(&(info->lock));
 338
 339        return r;
 340}
 341
 342
 343static void btuart_change_speed(struct btuart_info *info,
 344                                unsigned int speed)
 345{
 346        unsigned long flags;
 347        unsigned int iobase;
 348        int fcr;                /* FIFO control reg */
 349        int lcr;                /* Line control reg */
 350        int divisor;
 351
 352        if (!info) {
 353                BT_ERR("Unknown device");
 354                return;
 355        }
 356
 357        iobase = info->p_dev->resource[0]->start;
 358
 359        spin_lock_irqsave(&(info->lock), flags);
 360
 361        /* Turn off interrupts */
 362        outb(0, iobase + UART_IER);
 363
 364        divisor = SPEED_MAX / speed;
 365
 366        fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
 367
 368        /* 
 369         * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
 370         * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
 371         * about this timeout since it will always be fast enough. 
 372         */
 373
 374        if (speed < 38400)
 375                fcr |= UART_FCR_TRIGGER_1;
 376        else
 377                fcr |= UART_FCR_TRIGGER_14;
 378
 379        /* Bluetooth cards use 8N1 */
 380        lcr = UART_LCR_WLEN8;
 381
 382        outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);   /* Set DLAB */
 383        outb(divisor & 0xff, iobase + UART_DLL);        /* Set speed */
 384        outb(divisor >> 8, iobase + UART_DLM);
 385        outb(lcr, iobase + UART_LCR);   /* Set 8N1  */
 386        outb(fcr, iobase + UART_FCR);   /* Enable FIFO's */
 387
 388        /* Turn on interrupts */
 389        outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 390
 391        spin_unlock_irqrestore(&(info->lock), flags);
 392}
 393
 394
 395
 396/* ======================== HCI interface ======================== */
 397
 398
 399static int btuart_hci_flush(struct hci_dev *hdev)
 400{
 401        struct btuart_info *info = hci_get_drvdata(hdev);
 402
 403        /* Drop TX queue */
 404        skb_queue_purge(&(info->txq));
 405
 406        return 0;
 407}
 408
 409
 410static int btuart_hci_open(struct hci_dev *hdev)
 411{
 412        set_bit(HCI_RUNNING, &(hdev->flags));
 413
 414        return 0;
 415}
 416
 417
 418static int btuart_hci_close(struct hci_dev *hdev)
 419{
 420        if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
 421                return 0;
 422
 423        btuart_hci_flush(hdev);
 424
 425        return 0;
 426}
 427
 428
 429static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 430{
 431        struct btuart_info *info = hci_get_drvdata(hdev);
 432
 433        switch (bt_cb(skb)->pkt_type) {
 434        case HCI_COMMAND_PKT:
 435                hdev->stat.cmd_tx++;
 436                break;
 437        case HCI_ACLDATA_PKT:
 438                hdev->stat.acl_tx++;
 439                break;
 440        case HCI_SCODATA_PKT:
 441                hdev->stat.sco_tx++;
 442                break;
 443        }
 444
 445        /* Prepend skb with frame type */
 446        memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 447        skb_queue_tail(&(info->txq), skb);
 448
 449        btuart_write_wakeup(info);
 450
 451        return 0;
 452}
 453
 454
 455
 456/* ======================== Card services HCI interaction ======================== */
 457
 458
 459static int btuart_open(struct btuart_info *info)
 460{
 461        unsigned long flags;
 462        unsigned int iobase = info->p_dev->resource[0]->start;
 463        struct hci_dev *hdev;
 464
 465        spin_lock_init(&(info->lock));
 466
 467        skb_queue_head_init(&(info->txq));
 468
 469        info->rx_state = RECV_WAIT_PACKET_TYPE;
 470        info->rx_count = 0;
 471        info->rx_skb = NULL;
 472
 473        /* Initialize HCI device */
 474        hdev = hci_alloc_dev();
 475        if (!hdev) {
 476                BT_ERR("Can't allocate HCI device");
 477                return -ENOMEM;
 478        }
 479
 480        info->hdev = hdev;
 481
 482        hdev->bus = HCI_PCCARD;
 483        hci_set_drvdata(hdev, info);
 484        SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 485
 486        hdev->open  = btuart_hci_open;
 487        hdev->close = btuart_hci_close;
 488        hdev->flush = btuart_hci_flush;
 489        hdev->send  = btuart_hci_send_frame;
 490
 491        spin_lock_irqsave(&(info->lock), flags);
 492
 493        /* Reset UART */
 494        outb(0, iobase + UART_MCR);
 495
 496        /* Turn off interrupts */
 497        outb(0, iobase + UART_IER);
 498
 499        /* Initialize UART */
 500        outb(UART_LCR_WLEN8, iobase + UART_LCR);        /* Reset DLAB */
 501        outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
 502
 503        /* Turn on interrupts */
 504        // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 505
 506        spin_unlock_irqrestore(&(info->lock), flags);
 507
 508        btuart_change_speed(info, DEFAULT_BAUD_RATE);
 509
 510        /* Timeout before it is safe to send the first HCI packet */
 511        msleep(1000);
 512
 513        /* Register HCI device */
 514        if (hci_register_dev(hdev) < 0) {
 515                BT_ERR("Can't register HCI device");
 516                info->hdev = NULL;
 517                hci_free_dev(hdev);
 518                return -ENODEV;
 519        }
 520
 521        return 0;
 522}
 523
 524
 525static int btuart_close(struct btuart_info *info)
 526{
 527        unsigned long flags;
 528        unsigned int iobase = info->p_dev->resource[0]->start;
 529        struct hci_dev *hdev = info->hdev;
 530
 531        if (!hdev)
 532                return -ENODEV;
 533
 534        btuart_hci_close(hdev);
 535
 536        spin_lock_irqsave(&(info->lock), flags);
 537
 538        /* Reset UART */
 539        outb(0, iobase + UART_MCR);
 540
 541        /* Turn off interrupts */
 542        outb(0, iobase + UART_IER);
 543
 544        spin_unlock_irqrestore(&(info->lock), flags);
 545
 546        hci_unregister_dev(hdev);
 547        hci_free_dev(hdev);
 548
 549        return 0;
 550}
 551
 552static int btuart_probe(struct pcmcia_device *link)
 553{
 554        struct btuart_info *info;
 555
 556        /* Create new info device */
 557        info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
 558        if (!info)
 559                return -ENOMEM;
 560
 561        info->p_dev = link;
 562        link->priv = info;
 563
 564        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
 565                CONF_AUTO_SET_IO;
 566
 567        return btuart_config(link);
 568}
 569
 570
 571static void btuart_detach(struct pcmcia_device *link)
 572{
 573        btuart_release(link);
 574}
 575
 576static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
 577{
 578        int *try = priv_data;
 579
 580        if (!try)
 581                p_dev->io_lines = 16;
 582
 583        if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
 584                return -EINVAL;
 585
 586        p_dev->resource[0]->end = 8;
 587        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 588        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 589
 590        return pcmcia_request_io(p_dev);
 591}
 592
 593static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
 594                                        void *priv_data)
 595{
 596        static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 597        int j;
 598
 599        if (p_dev->io_lines > 3)
 600                return -ENODEV;
 601
 602        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 603        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 604        p_dev->resource[0]->end = 8;
 605
 606        for (j = 0; j < 5; j++) {
 607                p_dev->resource[0]->start = base[j];
 608                p_dev->io_lines = base[j] ? 16 : 3;
 609                if (!pcmcia_request_io(p_dev))
 610                        return 0;
 611        }
 612        return -ENODEV;
 613}
 614
 615static int btuart_config(struct pcmcia_device *link)
 616{
 617        struct btuart_info *info = link->priv;
 618        int i;
 619        int try;
 620
 621        /* First pass: look for a config entry that looks normal.
 622           Two tries: without IO aliases, then with aliases */
 623        for (try = 0; try < 2; try++)
 624                if (!pcmcia_loop_config(link, btuart_check_config, &try))
 625                        goto found_port;
 626
 627        /* Second pass: try to find an entry that isn't picky about
 628           its base address, then try to grab any standard serial port
 629           address, and finally try to get any free port. */
 630        if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
 631                goto found_port;
 632
 633        BT_ERR("No usable port range found");
 634        goto failed;
 635
 636found_port:
 637        i = pcmcia_request_irq(link, btuart_interrupt);
 638        if (i != 0)
 639                goto failed;
 640
 641        i = pcmcia_enable_device(link);
 642        if (i != 0)
 643                goto failed;
 644
 645        if (btuart_open(info) != 0)
 646                goto failed;
 647
 648        return 0;
 649
 650failed:
 651        btuart_release(link);
 652        return -ENODEV;
 653}
 654
 655
 656static void btuart_release(struct pcmcia_device *link)
 657{
 658        struct btuart_info *info = link->priv;
 659
 660        btuart_close(info);
 661
 662        pcmcia_disable_device(link);
 663}
 664
 665static const struct pcmcia_device_id btuart_ids[] = {
 666        /* don't use this driver. Use serial_cs + hci_uart instead */
 667        PCMCIA_DEVICE_NULL
 668};
 669MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
 670
 671static struct pcmcia_driver btuart_driver = {
 672        .owner          = THIS_MODULE,
 673        .name           = "btuart_cs",
 674        .probe          = btuart_probe,
 675        .remove         = btuart_detach,
 676        .id_table       = btuart_ids,
 677};
 678module_pcmcia_driver(btuart_driver);
 679