hci_h4.c 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327
  1. /*
  2. *
  3. * Bluetooth HCI UART driver
  4. *
  5. * Copyright (C) 2000-2001 Qualcomm Incorporated
  6. * Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
  7. * Copyright (C) 2004-2005 Marcel Holtmann <marcel@holtmann.org>
  8. *
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License as published by
  12. * the Free Software Foundation; either version 2 of the License, or
  13. * (at your option) any later version.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to the Free Software
  22. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23. *
  24. */
  25. #include <linux/module.h>
  26. #include <linux/kernel.h>
  27. #include <linux/init.h>
  28. #include <linux/types.h>
  29. #include <linux/fcntl.h>
  30. #include <linux/interrupt.h>
  31. #include <linux/ptrace.h>
  32. #include <linux/poll.h>
  33. #include <linux/slab.h>
  34. #include <linux/tty.h>
  35. #include <linux/errno.h>
  36. #include <linux/string.h>
  37. #include <linux/signal.h>
  38. #include <linux/ioctl.h>
  39. #include <linux/skbuff.h>
  40. #include <net/bluetooth/bluetooth.h>
  41. #include <net/bluetooth/hci_core.h>
  42. #include <linux/version.h>
  43. #include "hci_uart.h"
  44. #ifdef BTCOEX
  45. #include "rtk_coex.h"
  46. #endif
  47. //#define VERSION "1.2"
  48. struct h4_struct {
  49. unsigned long rx_state;
  50. unsigned long rx_count;
  51. struct sk_buff *rx_skb;
  52. struct sk_buff_head txq;
  53. };
  54. /* H4 receiver States */
  55. #define H4_W4_PACKET_TYPE 0
  56. #define H4_W4_EVENT_HDR 1
  57. #define H4_W4_ACL_HDR 2
  58. #define H4_W4_SCO_HDR 3
  59. #define H4_W4_DATA 4
  60. /* Initialize protocol */
  61. static int h4_open(struct hci_uart *hu)
  62. {
  63. struct h4_struct *h4;
  64. BT_DBG("hu %p", hu);
  65. h4 = kzalloc(sizeof(*h4), GFP_ATOMIC);
  66. if (!h4)
  67. return -ENOMEM;
  68. skb_queue_head_init(&h4->txq);
  69. hu->priv = h4;
  70. return 0;
  71. }
  72. /* Flush protocol data */
  73. static int h4_flush(struct hci_uart *hu)
  74. {
  75. struct h4_struct *h4 = hu->priv;
  76. BT_DBG("hu %p", hu);
  77. skb_queue_purge(&h4->txq);
  78. return 0;
  79. }
  80. /* Close protocol */
  81. static int h4_close(struct hci_uart *hu)
  82. {
  83. struct h4_struct *h4 = hu->priv;
  84. hu->priv = NULL;
  85. BT_DBG("hu %p", hu);
  86. skb_queue_purge(&h4->txq);
  87. kfree_skb(h4->rx_skb);
  88. hu->priv = NULL;
  89. kfree(h4);
  90. return 0;
  91. }
  92. /* Enqueue frame for transmittion (padding, crc, etc) */
  93. static int h4_enqueue(struct hci_uart *hu, struct sk_buff *skb)
  94. {
  95. struct h4_struct *h4 = hu->priv;
  96. BT_DBG("hu %p skb %p", hu, skb);
  97. /* Prepend skb with frame type */
  98. memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
  99. skb_queue_tail(&h4->txq, skb);
  100. return 0;
  101. }
  102. #if HCI_VERSION_CODE < KERNEL_VERSION(3, 13, 0)
  103. static inline int h4_check_data_len(struct h4_struct *h4, int len)
  104. #else
  105. static inline int h4_check_data_len(struct hci_dev *hdev, struct h4_struct *h4, int len)
  106. #endif
  107. {
  108. register int room = skb_tailroom(h4->rx_skb);
  109. BT_DBG("len %d room %d", len, room);
  110. if (!len) {
  111. #if HCI_VERSION_CODE < KERNEL_VERSION(3, 13, 0)
  112. hci_recv_frame(h4->rx_skb);
  113. #else
  114. hci_recv_frame(hdev, h4->rx_skb);
  115. #endif
  116. } else if (len > room) {
  117. BT_ERR("Data length is too large");
  118. kfree_skb(h4->rx_skb);
  119. } else {
  120. h4->rx_state = H4_W4_DATA;
  121. h4->rx_count = len;
  122. return len;
  123. }
  124. h4->rx_state = H4_W4_PACKET_TYPE;
  125. h4->rx_skb = NULL;
  126. h4->rx_count = 0;
  127. return 0;
  128. }
  129. /* Recv data */
  130. static int h4_recv(struct hci_uart *hu, void *data, int count)
  131. {
  132. struct h4_struct *h4 = hu->priv;
  133. register char *ptr;
  134. struct hci_event_hdr *eh;
  135. struct hci_acl_hdr *ah;
  136. struct hci_sco_hdr *sh;
  137. register int len, type, dlen;
  138. BT_DBG("hu %p count %d rx_state %ld rx_count %ld",
  139. hu, count, h4->rx_state, h4->rx_count);
  140. ptr = data;
  141. while (count) {
  142. if (h4->rx_count) {
  143. len = min_t(unsigned int, h4->rx_count, count);
  144. memcpy(skb_put(h4->rx_skb, len), ptr, len);
  145. h4->rx_count -= len; count -= len; ptr += len;
  146. if (h4->rx_count)
  147. continue;
  148. switch (h4->rx_state) {
  149. case H4_W4_DATA:
  150. BT_DBG("Complete data");
  151. #ifdef BTCOEX
  152. if(bt_cb(h4->rx_skb)->pkt_type == HCI_EVENT_PKT)
  153. rtk_btcoex_parse_event(
  154. h4->rx_skb->data,
  155. h4->rx_skb->len);
  156. if(bt_cb(h4->rx_skb)->pkt_type == HCI_ACLDATA_PKT)
  157. rtk_btcoex_parse_l2cap_data_rx(
  158. h4->rx_skb->data,
  159. h4->rx_skb->len);
  160. #endif
  161. #if HCI_VERSION_CODE < KERNEL_VERSION(3, 13, 0)
  162. hci_recv_frame(h4->rx_skb);
  163. #else
  164. hci_recv_frame(hu->hdev, h4->rx_skb);
  165. #endif
  166. h4->rx_state = H4_W4_PACKET_TYPE;
  167. h4->rx_skb = NULL;
  168. continue;
  169. case H4_W4_EVENT_HDR:
  170. eh = hci_event_hdr(h4->rx_skb);
  171. BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);
  172. #if HCI_VERSION_CODE < KERNEL_VERSION(3, 13, 0)
  173. h4_check_data_len(h4, eh->plen);
  174. #else
  175. h4_check_data_len(hu->hdev, h4, eh->plen);
  176. #endif
  177. continue;
  178. case H4_W4_ACL_HDR:
  179. ah = hci_acl_hdr(h4->rx_skb);
  180. dlen = __le16_to_cpu(ah->dlen);
  181. BT_DBG("ACL header: dlen %d", dlen);
  182. #if HCI_VERSION_CODE < KERNEL_VERSION(3, 13, 0)
  183. h4_check_data_len(h4, dlen);
  184. #else
  185. h4_check_data_len(hu->hdev, h4, dlen);
  186. #endif
  187. continue;
  188. case H4_W4_SCO_HDR:
  189. sh = hci_sco_hdr(h4->rx_skb);
  190. BT_DBG("SCO header: dlen %d", sh->dlen);
  191. #if HCI_VERSION_CODE < KERNEL_VERSION(3, 13, 0)
  192. h4_check_data_len(h4, sh->dlen);
  193. #else
  194. h4_check_data_len(hu->hdev, h4, sh->dlen);
  195. #endif
  196. continue;
  197. }
  198. }
  199. /* H4_W4_PACKET_TYPE */
  200. switch (*ptr) {
  201. case HCI_EVENT_PKT:
  202. BT_DBG("Event packet");
  203. h4->rx_state = H4_W4_EVENT_HDR;
  204. h4->rx_count = HCI_EVENT_HDR_SIZE;
  205. type = HCI_EVENT_PKT;
  206. break;
  207. case HCI_ACLDATA_PKT:
  208. BT_DBG("ACL packet");
  209. h4->rx_state = H4_W4_ACL_HDR;
  210. h4->rx_count = HCI_ACL_HDR_SIZE;
  211. type = HCI_ACLDATA_PKT;
  212. break;
  213. case HCI_SCODATA_PKT:
  214. BT_DBG("SCO packet");
  215. h4->rx_state = H4_W4_SCO_HDR;
  216. h4->rx_count = HCI_SCO_HDR_SIZE;
  217. type = HCI_SCODATA_PKT;
  218. break;
  219. default:
  220. BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);
  221. hu->hdev->stat.err_rx++;
  222. ptr++; count--;
  223. continue;
  224. };
  225. ptr++; count--;
  226. /* Allocate packet */
  227. h4->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
  228. if (!h4->rx_skb) {
  229. BT_ERR("Can't allocate mem for new packet");
  230. h4->rx_state = H4_W4_PACKET_TYPE;
  231. h4->rx_count = 0;
  232. return -ENOMEM;
  233. }
  234. h4->rx_skb->dev = (void *) hu->hdev;
  235. bt_cb(h4->rx_skb)->pkt_type = type;
  236. }
  237. return count;
  238. }
  239. static struct sk_buff *h4_dequeue(struct hci_uart *hu)
  240. {
  241. struct h4_struct *h4 = hu->priv;
  242. return skb_dequeue(&h4->txq);
  243. }
  244. static struct hci_uart_proto h4p = {
  245. .id = HCI_UART_H4,
  246. .open = h4_open,
  247. .close = h4_close,
  248. .recv = h4_recv,
  249. .enqueue = h4_enqueue,
  250. .dequeue = h4_dequeue,
  251. .flush = h4_flush,
  252. };
  253. int __init h4_init(void)
  254. {
  255. int err = hci_uart_register_proto(&h4p);
  256. if (!err)
  257. BT_INFO("HCI H4 protocol initialized");
  258. else
  259. BT_ERR("HCI H4 protocol registration failed");
  260. return err;
  261. }
  262. int __exit h4_deinit(void)
  263. {
  264. return hci_uart_unregister_proto(&h4p);
  265. }