blob: 3a4343b3bd6d0dfeb0ef98370d4e23f89b39f996 [file] [log] [blame]
Bing Zhao132ff4e2009-06-02 14:29:35 -07001/**
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
Paul Gortmakera59b9682011-08-29 16:44:23 -040021#include <linux/module.h>
22
Bing Zhao132ff4e2009-06-02 14:29:35 -070023#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{
Bing Zhao132ff4e2009-06-02 14:29:35 -070037 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);
Bing Zhao132ff4e2009-06-02 14:29:35 -070044}
45EXPORT_SYMBOL_GPL(btmrvl_interrupt);
46
Andrei Emeltchenkoea1e76a2012-06-13 13:35:44 +030047bool btmrvl_check_evtpkt(struct btmrvl_private *priv, struct sk_buff *skb)
Bing Zhao132ff4e2009-06-02 14:29:35 -070048{
Marcel Holtmann4271e082009-06-09 16:00:22 +020049 struct hci_event_hdr *hdr = (void *) skb->data;
Bing Zhao132ff4e2009-06-02 14:29:35 -070050
Bing Zhao132ff4e2009-06-02 14:29:35 -070051 if (hdr->evt == HCI_EV_CMD_COMPLETE) {
Andrei Emeltchenko2c2453f2012-07-09 13:57:18 +030052 struct hci_ev_cmd_complete *ec;
53 u16 opcode, ocf, ogf;
54
Marcel Holtmann4271e082009-06-09 16:00:22 +020055 ec = (void *) (skb->data + HCI_EVENT_HDR_SIZE);
Bing Zhao132ff4e2009-06-02 14:29:35 -070056 opcode = __le16_to_cpu(ec->opcode);
57 ocf = hci_opcode_ocf(opcode);
Andrei Emeltchenkoea1e76a2012-06-13 13:35:44 +030058 ogf = hci_opcode_ogf(opcode);
59
Marcel Holtmann4271e082009-06-09 16:00:22 +020060 if (ocf == BT_CMD_MODULE_CFG_REQ &&
61 priv->btmrvl_dev.sendcmdflag) {
Bing Zhao132ff4e2009-06-02 14:29:35 -070062 priv->btmrvl_dev.sendcmdflag = false;
63 priv->adapter->cmd_complete = true;
64 wake_up_interruptible(&priv->adapter->cmd_wait_q);
65 }
Andrei Emeltchenkoea1e76a2012-06-13 13:35:44 +030066
67 if (ogf == OGF) {
Andrei Emeltchenko2c2453f2012-07-09 13:57:18 +030068 BT_DBG("vendor event skipped: ogf 0x%4.4x ocf 0x%4.4x",
69 ogf, ocf);
Andrei Emeltchenkoea1e76a2012-06-13 13:35:44 +030070 kfree_skb(skb);
71 return false;
72 }
Bing Zhao132ff4e2009-06-02 14:29:35 -070073 }
Andrei Emeltchenkoea1e76a2012-06-13 13:35:44 +030074
75 return true;
Bing Zhao132ff4e2009-06-02 14:29:35 -070076}
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;
Bing Zhao132ff4e2009-06-02 14:29:35 -070082 struct btmrvl_event *event;
Dan Carpenter31f085f2010-03-08 15:15:59 +030083 int ret = 0;
Bing Zhao132ff4e2009-06-02 14:29:35 -070084
Bing Zhao132ff4e2009-06-02 14:29:35 -070085 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],
Marcel Holtmann4271e082009-06-09 16:00:22 +0200109 event->data[2]);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700110 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:
Marcel Holtmann4271e082009-06-09 16:00:22 +0200127 if (priv->btmrvl_dev.sendcmdflag &&
128 event->data[1] == MODULE_BRINGUP_REQ) {
Bing Zhao903c8432010-03-03 14:37:35 -0800129 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");
Bing Zhaof120c6b2010-03-03 14:37:37 -0800133
David Vrabel8f1e1742010-08-09 17:38:10 -0400134 if (event->length > 3 && event->data[3])
135 priv->btmrvl_dev.dev_type = HCI_AMP;
Bing Zhaof120c6b2010-03-03 14:37:37 -0800136 else
137 priv->btmrvl_dev.dev_type = HCI_BREDR;
138
139 BT_DBG("dev_type: %d", priv->btmrvl_dev.dev_type);
Marcel Holtmann4271e082009-06-09 16:00:22 +0200140 } else if (priv->btmrvl_dev.sendcmdflag &&
141 event->data[1] == MODULE_SHUTDOWN_REQ) {
Bing Zhao132ff4e2009-06-02 14:29:35 -0700142 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
Bing Zhao132ff4e2009-06-02 14:29:35 -0700167 return ret;
168}
169EXPORT_SYMBOL_GPL(btmrvl_process_event);
170
171int btmrvl_send_module_cfg_cmd(struct btmrvl_private *priv, int subcmd)
172{
Marcel Holtmann4271e082009-06-09 16:00:22 +0200173 struct sk_buff *skb;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700174 struct btmrvl_cmd *cmd;
Marcel Holtmann93742532009-06-13 07:40:18 +0200175 int ret = 0;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700176
177 skb = bt_skb_alloc(sizeof(*cmd), GFP_ATOMIC);
178 if (skb == NULL) {
179 BT_ERR("No free skb");
Marcel Holtmann93742532009-06-13 07:40:18 +0200180 return -ENOMEM;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700181 }
182
Marcel Holtmanne0721f92009-06-13 07:27:19 +0200183 cmd = (struct btmrvl_cmd *) skb_put(skb, sizeof(*cmd));
Marcel Holtmann91d69732009-06-10 12:18:50 +0200184 cmd->ocf_ogf = cpu_to_le16(hci_opcode_pack(OGF, BT_CMD_MODULE_CFG_REQ));
Bing Zhao132ff4e2009-06-02 14:29:35 -0700185 cmd->length = 1;
186 cmd->data[0] = subcmd;
187
188 bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT;
189
Marcel Holtmann4271e082009-06-09 16:00:22 +0200190 skb->dev = (void *) priv->btmrvl_dev.hcidev;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700191 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
Marcel Holtmann4271e082009-06-09 16:00:22 +0200201 if (!wait_event_interruptible_timeout(priv->adapter->cmd_wait_q,
202 priv->adapter->cmd_complete,
203 msecs_to_jiffies(WAIT_UNTIL_CMD_RESP))) {
Bing Zhao132ff4e2009-06-02 14:29:35 -0700204 ret = -ETIMEDOUT;
205 BT_ERR("module_cfg_cmd(%x): timeout: %d",
Marcel Holtmann4271e082009-06-09 16:00:22 +0200206 subcmd, priv->btmrvl_dev.sendcmdflag);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700207 }
208
209 BT_DBG("module cfg Command done");
210
Bing Zhao132ff4e2009-06-02 14:29:35 -0700211 return ret;
212}
213EXPORT_SYMBOL_GPL(btmrvl_send_module_cfg_cmd);
214
Amitkumar Karwar2a8ff612012-04-24 16:31:40 -0700215int 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
Amitkumar Karwar32fd6392009-09-30 11:18:30 -0700245int 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
Amitkumar Karwarba54a162012-04-25 11:43:54 -0700277int btmrvl_enable_hs(struct btmrvl_private *priv)
Bing Zhao132ff4e2009-06-02 14:29:35 -0700278{
Marcel Holtmann4271e082009-06-09 16:00:22 +0200279 struct sk_buff *skb;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700280 struct btmrvl_cmd *cmd;
Marcel Holtmann93742532009-06-13 07:40:18 +0200281 int ret = 0;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700282
283 skb = bt_skb_alloc(sizeof(*cmd), GFP_ATOMIC);
284 if (skb == NULL) {
285 BT_ERR("No free skb");
Marcel Holtmann93742532009-06-13 07:40:18 +0200286 return -ENOMEM;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700287 }
288
Marcel Holtmanne0721f92009-06-13 07:27:19 +0200289 cmd = (struct btmrvl_cmd *) skb_put(skb, sizeof(*cmd));
Marcel Holtmann91d69732009-06-10 12:18:50 +0200290 cmd->ocf_ogf = cpu_to_le16(hci_opcode_pack(OGF, BT_CMD_HOST_SLEEP_ENABLE));
Bing Zhao132ff4e2009-06-02 14:29:35 -0700291 cmd->length = 0;
292
293 bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT;
294
Marcel Holtmann4271e082009-06-09 16:00:22 +0200295 skb->dev = (void *) priv->btmrvl_dev.hcidev;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700296 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
Marcel Holtmann4271e082009-06-09 16:00:22 +0200302 if (!wait_event_interruptible_timeout(priv->adapter->cmd_wait_q,
Bing Zhao132ff4e2009-06-02 14:29:35 -0700303 priv->adapter->hs_state,
304 msecs_to_jiffies(WAIT_UNTIL_HS_STATE_CHANGED))) {
305 ret = -ETIMEDOUT;
Marcel Holtmann4271e082009-06-09 16:00:22 +0200306 BT_ERR("timeout: %d, %d,%d", priv->adapter->hs_state,
307 priv->adapter->ps_state,
308 priv->adapter->wakeup_tries);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700309 }
310
Bing Zhao132ff4e2009-06-02 14:29:35 -0700311 return ret;
312}
Amitkumar Karwarba54a162012-04-25 11:43:54 -0700313EXPORT_SYMBOL_GPL(btmrvl_enable_hs);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700314
315int btmrvl_prepare_command(struct btmrvl_private *priv)
316{
Marcel Holtmann93742532009-06-13 07:40:18 +0200317 int ret = 0;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700318
319 if (priv->btmrvl_dev.hscfgcmd) {
320 priv->btmrvl_dev.hscfgcmd = 0;
Amitkumar Karwar2a8ff612012-04-24 16:31:40 -0700321 btmrvl_send_hscfg_cmd(priv);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700322 }
323
324 if (priv->btmrvl_dev.pscmd) {
325 priv->btmrvl_dev.pscmd = 0;
Amitkumar Karwar32fd6392009-09-30 11:18:30 -0700326 btmrvl_enable_ps(priv);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700327 }
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
Bing Zhao132ff4e2009-06-02 14:29:35 -0700340 return ret;
341}
342
343static int btmrvl_tx_pkt(struct btmrvl_private *priv, struct sk_buff *skb)
344{
Marcel Holtmann93742532009-06-13 07:40:18 +0200345 int ret = 0;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700346
Marcel Holtmann93742532009-06-13 07:40:18 +0200347 if (!skb || !skb->data)
Bing Zhao132ff4e2009-06-02 14:29:35 -0700348 return -EINVAL;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700349
350 if (!skb->len || ((skb->len + BTM_HEADER_LEN) > BTM_UPLD_SIZE)) {
351 BT_ERR("Tx Error: Bad skb length %d : %d",
Marcel Holtmann4271e082009-06-09 16:00:22 +0200352 skb->len, BTM_UPLD_SIZE);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700353 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;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700364 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
Bing Zhao132ff4e2009-06-02 14:29:35 -0700385 return ret;
386}
387
388static void btmrvl_init_adapter(struct btmrvl_private *priv)
389{
Bing Zhao132ff4e2009-06-02 14:29:35 -0700390 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);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700395}
396
397static void btmrvl_free_adapter(struct btmrvl_private *priv)
398{
Bing Zhao132ff4e2009-06-02 14:29:35 -0700399 skb_queue_purge(&priv->adapter->tx_queue);
400
401 kfree(priv->adapter);
402
403 priv->adapter = NULL;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700404}
405
Marcel Holtmann4271e082009-06-09 16:00:22 +0200406static int btmrvl_ioctl(struct hci_dev *hdev,
407 unsigned int cmd, unsigned long arg)
Bing Zhao132ff4e2009-06-02 14:29:35 -0700408{
Bing Zhao132ff4e2009-06-02 14:29:35 -0700409 return -ENOIOCTLCMD;
410}
411
Bing Zhao132ff4e2009-06-02 14:29:35 -0700412static int btmrvl_send_frame(struct sk_buff *skb)
413{
Marcel Holtmann4271e082009-06-09 16:00:22 +0200414 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700415 struct btmrvl_private *priv = NULL;
416
Marcel Holtmann93742532009-06-13 07:40:18 +0200417 BT_DBG("type=%d, len=%d", skb->pkt_type, skb->len);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700418
David Herrmann155961e2012-02-09 21:58:32 +0100419 if (!hdev) {
Bing Zhao132ff4e2009-06-02 14:29:35 -0700420 BT_ERR("Frame for unknown HCI device");
Bing Zhao132ff4e2009-06-02 14:29:35 -0700421 return -ENODEV;
422 }
423
David Herrmann155961e2012-02-09 21:58:32 +0100424 priv = hci_get_drvdata(hdev);
425
Bing Zhao132ff4e2009-06-02 14:29:35 -0700426 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,
Marcel Holtmann4271e082009-06-09 16:00:22 +0200429 skb->data, skb->len);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700430 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
Bing Zhao132ff4e2009-06-02 14:29:35 -0700451 return 0;
452}
453
454static int btmrvl_flush(struct hci_dev *hdev)
455{
David Herrmann155961e2012-02-09 21:58:32 +0100456 struct btmrvl_private *priv = hci_get_drvdata(hdev);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700457
Bing Zhao132ff4e2009-06-02 14:29:35 -0700458 skb_queue_purge(&priv->adapter->tx_queue);
459
Bing Zhao132ff4e2009-06-02 14:29:35 -0700460 return 0;
461}
462
463static int btmrvl_close(struct hci_dev *hdev)
464{
David Herrmann155961e2012-02-09 21:58:32 +0100465 struct btmrvl_private *priv = hci_get_drvdata(hdev);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700466
Marcel Holtmann93742532009-06-13 07:40:18 +0200467 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
Bing Zhao132ff4e2009-06-02 14:29:35 -0700468 return 0;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700469
470 skb_queue_purge(&priv->adapter->tx_queue);
471
Bing Zhao132ff4e2009-06-02 14:29:35 -0700472 return 0;
473}
474
475static int btmrvl_open(struct hci_dev *hdev)
476{
Bing Zhao132ff4e2009-06-02 14:29:35 -0700477 set_bit(HCI_RUNNING, &hdev->flags);
478
Bing Zhao132ff4e2009-06-02 14:29:35 -0700479 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
Bing Zhao132ff4e2009-06-02 14:29:35 -0700495 init_waitqueue_entry(&wait, current);
496
Bing Zhao132ff4e2009-06-02 14:29:35 -0700497 for (;;) {
498 add_wait_queue(&thread->wait_q, &wait);
499
500 set_current_state(TASK_INTERRUPTIBLE);
501
502 if (adapter->wakeup_tries ||
Marcel Holtmann4271e082009-06-09 16:00:22 +0200503 ((!adapter->int_count) &&
504 (!priv->btmrvl_dev.tx_dnld_rdy ||
505 skb_queue_empty(&adapter->tx_queue)))) {
Bing Zhao132ff4e2009-06-02 14:29:35 -0700506 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;
Amitkumar Karward1d10d72010-05-27 16:38:37 -0700524 spin_unlock_irqrestore(&priv->driver_lock, flags);
525 priv->hw_process_int_status(priv);
Marcel Holtmann4271e082009-06-09 16:00:22 +0200526 } else if (adapter->ps_state == PS_SLEEP &&
527 !skb_queue_empty(&adapter->tx_queue)) {
Bing Zhao132ff4e2009-06-02 14:29:35 -0700528 spin_unlock_irqrestore(&priv->driver_lock, flags);
529 adapter->wakeup_tries++;
530 priv->hw_wakeup_firmware(priv);
531 continue;
Amitkumar Karward1d10d72010-05-27 16:38:37 -0700532 } else {
533 spin_unlock_irqrestore(&priv->driver_lock, flags);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700534 }
Bing Zhao132ff4e2009-06-02 14:29:35 -0700535
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
Marcel Holtmann4271e082009-06-09 16:00:22 +0200547 priv->btmrvl_dev.hcidev->stat.byte_tx += skb->len;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700548
549 kfree_skb(skb);
550 }
551 }
552
Bing Zhao132ff4e2009-06-02 14:29:35 -0700553 return 0;
554}
555
Bing Zhao64061602010-03-03 14:37:36 -0800556int btmrvl_register_hdev(struct btmrvl_private *priv)
Bing Zhao132ff4e2009-06-02 14:29:35 -0700557{
558 struct hci_dev *hdev = NULL;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700559 int ret;
560
Bing Zhao64061602010-03-03 14:37:36 -0800561 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;
David Herrmann155961e2012-02-09 21:58:32 +0100568 hci_set_drvdata(hdev, priv);
Bing Zhao64061602010-03-03 14:37:36 -0800569
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;
Bing Zhao64061602010-03-03 14:37:36 -0800575 hdev->ioctl = btmrvl_ioctl;
Bing Zhao64061602010-03-03 14:37:36 -0800576
577 btmrvl_send_module_cfg_cmd(priv, MODULE_BRINGUP_REQ);
578
Bing Zhaof120c6b2010-03-03 14:37:37 -0800579 hdev->dev_type = priv->btmrvl_dev.dev_type;
580
Bing Zhao64061602010-03-03 14:37:36 -0800581 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
Bing Zhao132ff4e2009-06-02 14:29:35 -0700611 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
Bing Zhao132ff4e2009-06-02 14:29:35 -0700625 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,
Marcel Holtmann4271e082009-06-09 16:00:22 +0200631 &priv->main_thread, "btmrvl_main_service");
Bing Zhao132ff4e2009-06-02 14:29:35 -0700632
Bing Zhao132ff4e2009-06-02 14:29:35 -0700633 priv->btmrvl_dev.card = card;
Bing Zhao132ff4e2009-06-02 14:29:35 -0700634 priv->btmrvl_dev.tx_dnld_rdy = true;
635
Bing Zhao132ff4e2009-06-02 14:29:35 -0700636 return priv;
637
Bing Zhao132ff4e2009-06-02 14:29:35 -0700638err_adapter:
639 kfree(priv);
640
641err_priv:
Bing Zhao132ff4e2009-06-02 14:29:35 -0700642 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
Bing Zhao132ff4e2009-06-02 14:29:35 -0700650 hdev = priv->btmrvl_dev.hcidev;
651
652 wake_up_interruptible(&priv->adapter->cmd_wait_q);
653
654 kthread_stop(priv->main_thread.task);
655
Bing Zhaofb784f02009-06-02 14:29:37 -0700656#ifdef CONFIG_DEBUG_FS
657 btmrvl_debugfs_remove(hdev);
658#endif
659
Bing Zhao132ff4e2009-06-02 14:29:35 -0700660 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
Bing Zhao132ff4e2009-06-02 14:29:35 -0700670 return 0;
671}
672EXPORT_SYMBOL_GPL(btmrvl_remove_card);
673
674MODULE_AUTHOR("Marvell International Ltd.");
Marcel Holtmann9666fb32009-06-09 21:45:04 +0200675MODULE_DESCRIPTION("Marvell Bluetooth driver ver " VERSION);
Bing Zhao132ff4e2009-06-02 14:29:35 -0700676MODULE_VERSION(VERSION);
677MODULE_LICENSE("GPL v2");