hci_h4.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296
  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 "hci_uart.h"
  43. #ifndef CONFIG_BT_HCIUART_DEBUG
  44. #undef BT_DBG
  45. #define BT_DBG( A... )
  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. if (h4->rx_skb)
  88. kfree_skb(h4->rx_skb);
  89. hu->priv = NULL;
  90. kfree(h4);
  91. return 0;
  92. }
  93. /* Enqueue frame for transmittion (padding, crc, etc) */
  94. static int h4_enqueue(struct hci_uart *hu, struct sk_buff *skb)
  95. {
  96. struct h4_struct *h4 = hu->priv;
  97. BT_DBG("hu %p skb %p", hu, skb);
  98. /* Prepend skb with frame type */
  99. memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
  100. skb_queue_tail(&h4->txq, skb);
  101. return 0;
  102. }
  103. static inline int h4_check_data_len(struct h4_struct *h4, int len)
  104. {
  105. register int room = skb_tailroom(h4->rx_skb);
  106. BT_DBG("len %d room %d", len, room);
  107. if (!len) {
  108. hci_recv_frame(h4->rx_skb);
  109. } else if (len > room) {
  110. BT_ERR("Data length is too large");
  111. kfree_skb(h4->rx_skb);
  112. } else {
  113. h4->rx_state = H4_W4_DATA;
  114. h4->rx_count = len;
  115. return len;
  116. }
  117. h4->rx_state = H4_W4_PACKET_TYPE;
  118. h4->rx_skb = NULL;
  119. h4->rx_count = 0;
  120. return 0;
  121. }
  122. /* Recv data */
  123. static int h4_recv(struct hci_uart *hu, void *data, int count)
  124. {
  125. struct h4_struct *h4 = hu->priv;
  126. register char *ptr;
  127. struct hci_event_hdr *eh;
  128. struct hci_acl_hdr *ah;
  129. struct hci_sco_hdr *sh;
  130. register int len, type, dlen;
  131. BT_DBG("hu %p count %d rx_state %ld rx_count %ld",
  132. hu, count, h4->rx_state, h4->rx_count);
  133. ptr = data;
  134. while (count) {
  135. if (h4->rx_count) {
  136. len = min_t(unsigned int, h4->rx_count, count);
  137. memcpy(skb_put(h4->rx_skb, len), ptr, len);
  138. h4->rx_count -= len; count -= len; ptr += len;
  139. if (h4->rx_count)
  140. continue;
  141. switch (h4->rx_state) {
  142. case H4_W4_DATA:
  143. BT_DBG("Complete data");
  144. hci_recv_frame(h4->rx_skb);
  145. h4->rx_state = H4_W4_PACKET_TYPE;
  146. h4->rx_skb = NULL;
  147. continue;
  148. case H4_W4_EVENT_HDR:
  149. eh = (struct hci_event_hdr *) h4->rx_skb->data;
  150. BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);
  151. h4_check_data_len(h4, eh->plen);
  152. continue;
  153. case H4_W4_ACL_HDR:
  154. ah = (struct hci_acl_hdr *) h4->rx_skb->data;
  155. dlen = __le16_to_cpu(ah->dlen);
  156. BT_DBG("ACL header: dlen %d", dlen);
  157. h4_check_data_len(h4, dlen);
  158. continue;
  159. case H4_W4_SCO_HDR:
  160. sh = (struct hci_sco_hdr *) h4->rx_skb->data;
  161. BT_DBG("SCO header: dlen %d", sh->dlen);
  162. h4_check_data_len(h4, sh->dlen);
  163. continue;
  164. }
  165. }
  166. /* H4_W4_PACKET_TYPE */
  167. switch (*ptr) {
  168. case HCI_EVENT_PKT:
  169. BT_DBG("Event packet");
  170. h4->rx_state = H4_W4_EVENT_HDR;
  171. h4->rx_count = HCI_EVENT_HDR_SIZE;
  172. type = HCI_EVENT_PKT;
  173. break;
  174. case HCI_ACLDATA_PKT:
  175. BT_DBG("ACL packet");
  176. h4->rx_state = H4_W4_ACL_HDR;
  177. h4->rx_count = HCI_ACL_HDR_SIZE;
  178. type = HCI_ACLDATA_PKT;
  179. break;
  180. case HCI_SCODATA_PKT:
  181. BT_DBG("SCO packet");
  182. h4->rx_state = H4_W4_SCO_HDR;
  183. h4->rx_count = HCI_SCO_HDR_SIZE;
  184. type = HCI_SCODATA_PKT;
  185. break;
  186. default:
  187. BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);
  188. hu->hdev->stat.err_rx++;
  189. ptr++; count--;
  190. continue;
  191. };
  192. ptr++; count--;
  193. /* Allocate packet */
  194. h4->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
  195. if (!h4->rx_skb) {
  196. BT_ERR("Can't allocate mem for new packet");
  197. h4->rx_state = H4_W4_PACKET_TYPE;
  198. h4->rx_count = 0;
  199. return 0;
  200. }
  201. h4->rx_skb->dev = (void *) hu->hdev;
  202. bt_cb(h4->rx_skb)->pkt_type = type;
  203. }
  204. return count;
  205. }
  206. static struct sk_buff *h4_dequeue(struct hci_uart *hu)
  207. {
  208. struct h4_struct *h4 = hu->priv;
  209. return skb_dequeue(&h4->txq);
  210. }
  211. static struct hci_uart_proto h4p = {
  212. .id = HCI_UART_H4,
  213. .open = h4_open,
  214. .close = h4_close,
  215. .recv = h4_recv,
  216. .enqueue = h4_enqueue,
  217. .dequeue = h4_dequeue,
  218. .flush = h4_flush,
  219. };
  220. int h4_init(void)
  221. {
  222. int err = hci_uart_register_proto(&h4p);
  223. if (!err)
  224. BT_INFO("HCI H4 protocol initialized");
  225. else
  226. BT_ERR("HCI H4 protocol registration failed");
  227. return err;
  228. }
  229. int h4_deinit(void)
  230. {
  231. return hci_uart_unregister_proto(&h4p);
  232. }