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