Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
btmrvl_main.c
Go to the documentation of this file.
1 
21 #include <linux/module.h>
22 
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  */
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 }
46 
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 }
78 
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]) {
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 
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 
115  if (!event->data[1]) {
116  adapter->hs_state = HS_ACTIVATED;
117  if (adapter->psmode)
118  adapter->ps_state = PS_SLEEP;
120  BT_DBG("HS ACTIVATED!");
121  } else {
122  BT_DBG("HS Enable failed");
123  }
124  break;
125 
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 
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 
163 exit:
164  if (!ret)
165  kfree_skb(skb);
166 
167  return ret;
168 }
170 
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));
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,
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 }
214 
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));
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 }
244 
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));
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 }
276 
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));
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,
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 }
314 
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 
343 static 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 
360  if (!skb) {
361  BT_ERR("Tx Error: realloc_headroom failed %d",
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 
388 static 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 
397 static 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 
406 static int btmrvl_ioctl(struct hci_dev *hdev,
407  unsigned int cmd, unsigned long arg)
408 {
409  return -ENOIOCTLCMD;
410 }
411 
412 static 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 
454 static 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 
463 static 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 
475 static 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  */
486 static 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;
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 
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 
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 
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 
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 
593 err_hci_register_dev:
594  hci_free_dev(hdev);
595 
596 err_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 }
606 
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 
638 err_adapter:
639  kfree(priv);
640 
641 err_priv:
642  return NULL;
643 }
645 
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 }
673 
674 MODULE_AUTHOR("Marvell International Ltd.");
675 MODULE_DESCRIPTION("Marvell Bluetooth driver ver " VERSION);
677 MODULE_LICENSE("GPL v2");