Root/drivers/bluetooth/btmrvl_main.c

1/**
2 * Marvell Bluetooth driver
3 *
4 * Copyright (C) 2009, Marvell International Ltd.
5 *
6 * This software file (the "File") is distributed by Marvell International
7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8 * (the "License"). You may use, redistribute and/or modify this File in
9 * accordance with the terms and conditions of the License, a copy of which
10 * is available by writing to the Free Software Foundation, Inc.,
11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
13 *
14 *
15 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
17 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
18 * this warranty disclaimer.
19 **/
20
21#include <linux/module.h>
22
23#include <net/bluetooth/bluetooth.h>
24#include <net/bluetooth/hci_core.h>
25
26#include "btmrvl_drv.h"
27
28#define VERSION "1.0"
29
30/*
31 * This function is called by interface specific interrupt handler.
32 * It updates Power Save & Host Sleep states, and wakes up the main
33 * thread.
34 */
35void btmrvl_interrupt(struct btmrvl_private *priv)
36{
37    priv->adapter->ps_state = PS_AWAKE;
38
39    priv->adapter->wakeup_tries = 0;
40
41    priv->adapter->int_count++;
42
43    wake_up_interruptible(&priv->main_thread.wait_q);
44}
45EXPORT_SYMBOL_GPL(btmrvl_interrupt);
46
47bool btmrvl_check_evtpkt(struct btmrvl_private *priv, struct sk_buff *skb)
48{
49    struct hci_event_hdr *hdr = (void *) skb->data;
50
51    if (hdr->evt == HCI_EV_CMD_COMPLETE) {
52        struct hci_ev_cmd_complete *ec;
53        u16 opcode, ocf, ogf;
54
55        ec = (void *) (skb->data + HCI_EVENT_HDR_SIZE);
56        opcode = __le16_to_cpu(ec->opcode);
57        ocf = hci_opcode_ocf(opcode);
58        ogf = hci_opcode_ogf(opcode);
59
60        if (ocf == BT_CMD_MODULE_CFG_REQ &&
61                    priv->btmrvl_dev.sendcmdflag) {
62            priv->btmrvl_dev.sendcmdflag = false;
63            priv->adapter->cmd_complete = true;
64            wake_up_interruptible(&priv->adapter->cmd_wait_q);
65        }
66
67        if (ogf == OGF) {
68            BT_DBG("vendor event skipped: ogf 0x%4.4x ocf 0x%4.4x",
69                   ogf, ocf);
70            kfree_skb(skb);
71            return false;
72        }
73    }
74
75    return true;
76}
77EXPORT_SYMBOL_GPL(btmrvl_check_evtpkt);
78
79int btmrvl_process_event(struct btmrvl_private *priv, struct sk_buff *skb)
80{
81    struct btmrvl_adapter *adapter = priv->adapter;
82    struct btmrvl_event *event;
83    int ret = 0;
84
85    event = (struct btmrvl_event *) skb->data;
86    if (event->ec != 0xff) {
87        BT_DBG("Not Marvell Event=%x", event->ec);
88        ret = -EINVAL;
89        goto exit;
90    }
91
92    switch (event->data[0]) {
93    case BT_CMD_AUTO_SLEEP_MODE:
94        if (!event->data[2]) {
95            if (event->data[1] == BT_PS_ENABLE)
96                adapter->psmode = 1;
97            else
98                adapter->psmode = 0;
99            BT_DBG("PS Mode:%s",
100                (adapter->psmode) ? "Enable" : "Disable");
101        } else {
102            BT_DBG("PS Mode command failed");
103        }
104        break;
105
106    case BT_CMD_HOST_SLEEP_CONFIG:
107        if (!event->data[3])
108            BT_DBG("gpio=%x, gap=%x", event->data[1],
109                            event->data[2]);
110        else
111            BT_DBG("HSCFG command failed");
112        break;
113
114    case BT_CMD_HOST_SLEEP_ENABLE:
115        if (!event->data[1]) {
116            adapter->hs_state = HS_ACTIVATED;
117            if (adapter->psmode)
118                adapter->ps_state = PS_SLEEP;
119            wake_up_interruptible(&adapter->cmd_wait_q);
120            BT_DBG("HS ACTIVATED!");
121        } else {
122            BT_DBG("HS Enable failed");
123        }
124        break;
125
126    case BT_CMD_MODULE_CFG_REQ:
127        if (priv->btmrvl_dev.sendcmdflag &&
128                event->data[1] == MODULE_BRINGUP_REQ) {
129            BT_DBG("EVENT:%s",
130                ((event->data[2] == MODULE_BROUGHT_UP) ||
131                (event->data[2] == MODULE_ALREADY_UP)) ?
132                "Bring-up succeed" : "Bring-up failed");
133
134            if (event->length > 3 && event->data[3])
135                priv->btmrvl_dev.dev_type = HCI_AMP;
136            else
137                priv->btmrvl_dev.dev_type = HCI_BREDR;
138
139            BT_DBG("dev_type: %d", priv->btmrvl_dev.dev_type);
140        } else if (priv->btmrvl_dev.sendcmdflag &&
141                event->data[1] == MODULE_SHUTDOWN_REQ) {
142            BT_DBG("EVENT:%s", (event->data[2]) ?
143                "Shutdown failed" : "Shutdown succeed");
144        } else {
145            BT_DBG("BT_CMD_MODULE_CFG_REQ resp for APP");
146            ret = -EINVAL;
147        }
148        break;
149
150    case BT_EVENT_POWER_STATE:
151        if (event->data[1] == BT_PS_SLEEP)
152            adapter->ps_state = PS_SLEEP;
153        BT_DBG("EVENT:%s",
154            (adapter->ps_state) ? "PS_SLEEP" : "PS_AWAKE");
155        break;
156
157    default:
158        BT_DBG("Unknown Event=%d", event->data[0]);
159        ret = -EINVAL;
160        break;
161    }
162
163exit:
164    if (!ret)
165        kfree_skb(skb);
166
167    return ret;
168}
169EXPORT_SYMBOL_GPL(btmrvl_process_event);
170
171int btmrvl_send_module_cfg_cmd(struct btmrvl_private *priv, int subcmd)
172{
173    struct sk_buff *skb;
174    struct btmrvl_cmd *cmd;
175    int ret = 0;
176
177    skb = bt_skb_alloc(sizeof(*cmd), GFP_ATOMIC);
178    if (skb == NULL) {
179        BT_ERR("No free skb");
180        return -ENOMEM;
181    }
182
183    cmd = (struct btmrvl_cmd *) skb_put(skb, sizeof(*cmd));
184    cmd->ocf_ogf = cpu_to_le16(hci_opcode_pack(OGF, BT_CMD_MODULE_CFG_REQ));
185    cmd->length = 1;
186    cmd->data[0] = subcmd;
187
188    bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT;
189
190    skb->dev = (void *) priv->btmrvl_dev.hcidev;
191    skb_queue_head(&priv->adapter->tx_queue, skb);
192
193    priv->btmrvl_dev.sendcmdflag = true;
194
195    priv->adapter->cmd_complete = false;
196
197    BT_DBG("Queue module cfg Command");
198
199    wake_up_interruptible(&priv->main_thread.wait_q);
200
201    if (!wait_event_interruptible_timeout(priv->adapter->cmd_wait_q,
202                priv->adapter->cmd_complete,
203                msecs_to_jiffies(WAIT_UNTIL_CMD_RESP))) {
204        ret = -ETIMEDOUT;
205        BT_ERR("module_cfg_cmd(%x): timeout: %d",
206                    subcmd, priv->btmrvl_dev.sendcmdflag);
207    }
208
209    BT_DBG("module cfg Command done");
210
211    return ret;
212}
213EXPORT_SYMBOL_GPL(btmrvl_send_module_cfg_cmd);
214
215int btmrvl_send_hscfg_cmd(struct btmrvl_private *priv)
216{
217    struct sk_buff *skb;
218    struct btmrvl_cmd *cmd;
219
220    skb = bt_skb_alloc(sizeof(*cmd), GFP_ATOMIC);
221    if (!skb) {
222        BT_ERR("No free skb");
223        return -ENOMEM;
224    }
225
226    cmd = (struct btmrvl_cmd *) skb_put(skb, sizeof(*cmd));
227    cmd->ocf_ogf = cpu_to_le16(hci_opcode_pack(OGF,
228                           BT_CMD_HOST_SLEEP_CONFIG));
229    cmd->length = 2;
230    cmd->data[0] = (priv->btmrvl_dev.gpio_gap & 0xff00) >> 8;
231    cmd->data[1] = (u8) (priv->btmrvl_dev.gpio_gap & 0x00ff);
232
233    bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT;
234
235    skb->dev = (void *) priv->btmrvl_dev.hcidev;
236    skb_queue_head(&priv->adapter->tx_queue, skb);
237
238    BT_DBG("Queue HSCFG Command, gpio=0x%x, gap=0x%x", cmd->data[0],
239           cmd->data[1]);
240
241    return 0;
242}
243EXPORT_SYMBOL_GPL(btmrvl_send_hscfg_cmd);
244
245int btmrvl_enable_ps(struct btmrvl_private *priv)
246{
247    struct sk_buff *skb;
248    struct btmrvl_cmd *cmd;
249
250    skb = bt_skb_alloc(sizeof(*cmd), GFP_ATOMIC);
251    if (skb == NULL) {
252        BT_ERR("No free skb");
253        return -ENOMEM;
254    }
255
256    cmd = (struct btmrvl_cmd *) skb_put(skb, sizeof(*cmd));
257    cmd->ocf_ogf = cpu_to_le16(hci_opcode_pack(OGF,
258                    BT_CMD_AUTO_SLEEP_MODE));
259    cmd->length = 1;
260
261    if (priv->btmrvl_dev.psmode)
262        cmd->data[0] = BT_PS_ENABLE;
263    else
264        cmd->data[0] = BT_PS_DISABLE;
265
266    bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT;
267
268    skb->dev = (void *) priv->btmrvl_dev.hcidev;
269    skb_queue_head(&priv->adapter->tx_queue, skb);
270
271    BT_DBG("Queue PSMODE Command:%d", cmd->data[0]);
272
273    return 0;
274}
275EXPORT_SYMBOL_GPL(btmrvl_enable_ps);
276
277int btmrvl_enable_hs(struct btmrvl_private *priv)
278{
279    struct sk_buff *skb;
280    struct btmrvl_cmd *cmd;
281    int ret = 0;
282
283    skb = bt_skb_alloc(sizeof(*cmd), GFP_ATOMIC);
284    if (skb == NULL) {
285        BT_ERR("No free skb");
286        return -ENOMEM;
287    }
288
289    cmd = (struct btmrvl_cmd *) skb_put(skb, sizeof(*cmd));
290    cmd->ocf_ogf = cpu_to_le16(hci_opcode_pack(OGF, BT_CMD_HOST_SLEEP_ENABLE));
291    cmd->length = 0;
292
293    bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT;
294
295    skb->dev = (void *) priv->btmrvl_dev.hcidev;
296    skb_queue_head(&priv->adapter->tx_queue, skb);
297
298    BT_DBG("Queue hs enable Command");
299
300    wake_up_interruptible(&priv->main_thread.wait_q);
301
302    if (!wait_event_interruptible_timeout(priv->adapter->cmd_wait_q,
303            priv->adapter->hs_state,
304            msecs_to_jiffies(WAIT_UNTIL_HS_STATE_CHANGED))) {
305        ret = -ETIMEDOUT;
306        BT_ERR("timeout: %d, %d,%d", priv->adapter->hs_state,
307                        priv->adapter->ps_state,
308                        priv->adapter->wakeup_tries);
309    }
310
311    return ret;
312}
313EXPORT_SYMBOL_GPL(btmrvl_enable_hs);
314
315int btmrvl_prepare_command(struct btmrvl_private *priv)
316{
317    int ret = 0;
318
319    if (priv->btmrvl_dev.hscfgcmd) {
320        priv->btmrvl_dev.hscfgcmd = 0;
321        btmrvl_send_hscfg_cmd(priv);
322    }
323
324    if (priv->btmrvl_dev.pscmd) {
325        priv->btmrvl_dev.pscmd = 0;
326        btmrvl_enable_ps(priv);
327    }
328
329    if (priv->btmrvl_dev.hscmd) {
330        priv->btmrvl_dev.hscmd = 0;
331
332        if (priv->btmrvl_dev.hsmode) {
333            ret = btmrvl_enable_hs(priv);
334        } else {
335            ret = priv->hw_wakeup_firmware(priv);
336            priv->adapter->hs_state = HS_DEACTIVATED;
337        }
338    }
339
340    return ret;
341}
342
343static int btmrvl_tx_pkt(struct btmrvl_private *priv, struct sk_buff *skb)
344{
345    int ret = 0;
346
347    if (!skb || !skb->data)
348        return -EINVAL;
349
350    if (!skb->len || ((skb->len + BTM_HEADER_LEN) > BTM_UPLD_SIZE)) {
351        BT_ERR("Tx Error: Bad skb length %d : %d",
352                        skb->len, BTM_UPLD_SIZE);
353        return -EINVAL;
354    }
355
356    if (skb_headroom(skb) < BTM_HEADER_LEN) {
357        struct sk_buff *tmp = skb;
358
359        skb = skb_realloc_headroom(skb, BTM_HEADER_LEN);
360        if (!skb) {
361            BT_ERR("Tx Error: realloc_headroom failed %d",
362                BTM_HEADER_LEN);
363            skb = tmp;
364            return -EINVAL;
365        }
366
367        kfree_skb(tmp);
368    }
369
370    skb_push(skb, BTM_HEADER_LEN);
371
372    /* header type: byte[3]
373     * HCI_COMMAND = 1, ACL_DATA = 2, SCO_DATA = 3, 0xFE = Vendor
374     * header length: byte[2][1][0]
375     */
376
377    skb->data[0] = (skb->len & 0x0000ff);
378    skb->data[1] = (skb->len & 0x00ff00) >> 8;
379    skb->data[2] = (skb->len & 0xff0000) >> 16;
380    skb->data[3] = bt_cb(skb)->pkt_type;
381
382    if (priv->hw_host_to_card)
383        ret = priv->hw_host_to_card(priv, skb->data, skb->len);
384
385    return ret;
386}
387
388static void btmrvl_init_adapter(struct btmrvl_private *priv)
389{
390    skb_queue_head_init(&priv->adapter->tx_queue);
391
392    priv->adapter->ps_state = PS_AWAKE;
393
394    init_waitqueue_head(&priv->adapter->cmd_wait_q);
395}
396
397static void btmrvl_free_adapter(struct btmrvl_private *priv)
398{
399    skb_queue_purge(&priv->adapter->tx_queue);
400
401    kfree(priv->adapter);
402
403    priv->adapter = NULL;
404}
405
406static int btmrvl_ioctl(struct hci_dev *hdev,
407                unsigned int cmd, unsigned long arg)
408{
409    return -ENOIOCTLCMD;
410}
411
412static int btmrvl_send_frame(struct sk_buff *skb)
413{
414    struct hci_dev *hdev = (struct hci_dev *) skb->dev;
415    struct btmrvl_private *priv = NULL;
416
417    BT_DBG("type=%d, len=%d", skb->pkt_type, skb->len);
418
419    if (!hdev) {
420        BT_ERR("Frame for unknown HCI device");
421        return -ENODEV;
422    }
423
424    priv = hci_get_drvdata(hdev);
425
426    if (!test_bit(HCI_RUNNING, &hdev->flags)) {
427        BT_ERR("Failed testing HCI_RUNING, flags=%lx", hdev->flags);
428        print_hex_dump_bytes("data: ", DUMP_PREFIX_OFFSET,
429                            skb->data, skb->len);
430        return -EBUSY;
431    }
432
433    switch (bt_cb(skb)->pkt_type) {
434    case HCI_COMMAND_PKT:
435        hdev->stat.cmd_tx++;
436        break;
437
438    case HCI_ACLDATA_PKT:
439        hdev->stat.acl_tx++;
440        break;
441
442    case HCI_SCODATA_PKT:
443        hdev->stat.sco_tx++;
444        break;
445    }
446
447    skb_queue_tail(&priv->adapter->tx_queue, skb);
448
449    wake_up_interruptible(&priv->main_thread.wait_q);
450
451    return 0;
452}
453
454static int btmrvl_flush(struct hci_dev *hdev)
455{
456    struct btmrvl_private *priv = hci_get_drvdata(hdev);
457
458    skb_queue_purge(&priv->adapter->tx_queue);
459
460    return 0;
461}
462
463static int btmrvl_close(struct hci_dev *hdev)
464{
465    struct btmrvl_private *priv = hci_get_drvdata(hdev);
466
467    if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
468        return 0;
469
470    skb_queue_purge(&priv->adapter->tx_queue);
471
472    return 0;
473}
474
475static int btmrvl_open(struct hci_dev *hdev)
476{
477    set_bit(HCI_RUNNING, &hdev->flags);
478
479    return 0;
480}
481
482/*
483 * This function handles the event generated by firmware, rx data
484 * received from firmware, and tx data sent from kernel.
485 */
486static int btmrvl_service_main_thread(void *data)
487{
488    struct btmrvl_thread *thread = data;
489    struct btmrvl_private *priv = thread->priv;
490    struct btmrvl_adapter *adapter = priv->adapter;
491    wait_queue_t wait;
492    struct sk_buff *skb;
493    ulong flags;
494
495    init_waitqueue_entry(&wait, current);
496
497    for (;;) {
498        add_wait_queue(&thread->wait_q, &wait);
499
500        set_current_state(TASK_INTERRUPTIBLE);
501
502        if (adapter->wakeup_tries ||
503                ((!adapter->int_count) &&
504                (!priv->btmrvl_dev.tx_dnld_rdy ||
505                skb_queue_empty(&adapter->tx_queue)))) {
506            BT_DBG("main_thread is sleeping...");
507            schedule();
508        }
509
510        set_current_state(TASK_RUNNING);
511
512        remove_wait_queue(&thread->wait_q, &wait);
513
514        BT_DBG("main_thread woke up");
515
516        if (kthread_should_stop()) {
517            BT_DBG("main_thread: break from main thread");
518            break;
519        }
520
521        spin_lock_irqsave(&priv->driver_lock, flags);
522        if (adapter->int_count) {
523            adapter->int_count = 0;
524            spin_unlock_irqrestore(&priv->driver_lock, flags);
525            priv->hw_process_int_status(priv);
526        } else if (adapter->ps_state == PS_SLEEP &&
527                    !skb_queue_empty(&adapter->tx_queue)) {
528            spin_unlock_irqrestore(&priv->driver_lock, flags);
529            adapter->wakeup_tries++;
530            priv->hw_wakeup_firmware(priv);
531            continue;
532        } else {
533            spin_unlock_irqrestore(&priv->driver_lock, flags);
534        }
535
536        if (adapter->ps_state == PS_SLEEP)
537            continue;
538
539        if (!priv->btmrvl_dev.tx_dnld_rdy)
540            continue;
541
542        skb = skb_dequeue(&adapter->tx_queue);
543        if (skb) {
544            if (btmrvl_tx_pkt(priv, skb))
545                priv->btmrvl_dev.hcidev->stat.err_tx++;
546            else
547                priv->btmrvl_dev.hcidev->stat.byte_tx += skb->len;
548
549            kfree_skb(skb);
550        }
551    }
552
553    return 0;
554}
555
556int btmrvl_register_hdev(struct btmrvl_private *priv)
557{
558    struct hci_dev *hdev = NULL;
559    int ret;
560
561    hdev = hci_alloc_dev();
562    if (!hdev) {
563        BT_ERR("Can not allocate HCI device");
564        goto err_hdev;
565    }
566
567    priv->btmrvl_dev.hcidev = hdev;
568    hci_set_drvdata(hdev, priv);
569
570    hdev->bus = HCI_SDIO;
571    hdev->open = btmrvl_open;
572    hdev->close = btmrvl_close;
573    hdev->flush = btmrvl_flush;
574    hdev->send = btmrvl_send_frame;
575    hdev->ioctl = btmrvl_ioctl;
576
577    btmrvl_send_module_cfg_cmd(priv, MODULE_BRINGUP_REQ);
578
579    hdev->dev_type = priv->btmrvl_dev.dev_type;
580
581    ret = hci_register_dev(hdev);
582    if (ret < 0) {
583        BT_ERR("Can not register HCI device");
584        goto err_hci_register_dev;
585    }
586
587#ifdef CONFIG_DEBUG_FS
588    btmrvl_debugfs_init(hdev);
589#endif
590
591    return 0;
592
593err_hci_register_dev:
594    hci_free_dev(hdev);
595
596err_hdev:
597    /* Stop the thread servicing the interrupts */
598    kthread_stop(priv->main_thread.task);
599
600    btmrvl_free_adapter(priv);
601    kfree(priv);
602
603    return -ENOMEM;
604}
605EXPORT_SYMBOL_GPL(btmrvl_register_hdev);
606
607struct btmrvl_private *btmrvl_add_card(void *card)
608{
609    struct btmrvl_private *priv;
610
611    priv = kzalloc(sizeof(*priv), GFP_KERNEL);
612    if (!priv) {
613        BT_ERR("Can not allocate priv");
614        goto err_priv;
615    }
616
617    priv->adapter = kzalloc(sizeof(*priv->adapter), GFP_KERNEL);
618    if (!priv->adapter) {
619        BT_ERR("Allocate buffer for btmrvl_adapter failed!");
620        goto err_adapter;
621    }
622
623    btmrvl_init_adapter(priv);
624
625    BT_DBG("Starting kthread...");
626    priv->main_thread.priv = priv;
627    spin_lock_init(&priv->driver_lock);
628
629    init_waitqueue_head(&priv->main_thread.wait_q);
630    priv->main_thread.task = kthread_run(btmrvl_service_main_thread,
631                &priv->main_thread, "btmrvl_main_service");
632
633    priv->btmrvl_dev.card = card;
634    priv->btmrvl_dev.tx_dnld_rdy = true;
635
636    return priv;
637
638err_adapter:
639    kfree(priv);
640
641err_priv:
642    return NULL;
643}
644EXPORT_SYMBOL_GPL(btmrvl_add_card);
645
646int btmrvl_remove_card(struct btmrvl_private *priv)
647{
648    struct hci_dev *hdev;
649
650    hdev = priv->btmrvl_dev.hcidev;
651
652    wake_up_interruptible(&priv->adapter->cmd_wait_q);
653
654    kthread_stop(priv->main_thread.task);
655
656#ifdef CONFIG_DEBUG_FS
657    btmrvl_debugfs_remove(hdev);
658#endif
659
660    hci_unregister_dev(hdev);
661
662    hci_free_dev(hdev);
663
664    priv->btmrvl_dev.hcidev = NULL;
665
666    btmrvl_free_adapter(priv);
667
668    kfree(priv);
669
670    return 0;
671}
672EXPORT_SYMBOL_GPL(btmrvl_remove_card);
673
674MODULE_AUTHOR("Marvell International Ltd.");
675MODULE_DESCRIPTION("Marvell Bluetooth driver ver " VERSION);
676MODULE_VERSION(VERSION);
677MODULE_LICENSE("GPL v2");
678

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive