← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-backports-modules-3.5.0/quantal-updates

« back to all changes in this revision

Viewing changes to updates/cw-3.6/drivers/bluetooth/bluecard_cs.c

  • Committer: Package Import Robot
  • Author(s): Leann Ogasawara
  • Date: 2012-10-10 22:28:55 UTC
  • Revision ID: package-import@ubuntu.com-20121010222855-qepocc61xktv6gs9
Tags: 3.5.0-17.1
https://launchpad.net/bugs/1066123
* Open Quantal LBM
* Add compat-wireless 3.6
  -LP: #1066123

Show diffs side-by-side

added added

removed removed

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