hcp.c 3.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) 2012 Intel Corporation. All rights reserved.
  4. */
  5. #define pr_fmt(fmt) "hci: %s: " fmt, __func__
  6. #include <linux/init.h>
  7. #include <linux/kernel.h>
  8. #include <linux/module.h>
  9. #include <net/nfc/hci.h>
  10. #include "hci.h"
  11. /*
  12. * Payload is the HCP message data only. Instruction will be prepended.
  13. * Guarantees that cb will be called upon completion or timeout delay
  14. * counted from the moment the cmd is sent to the transport.
  15. */
  16. int nfc_hci_hcp_message_tx(struct nfc_hci_dev *hdev, u8 pipe,
  17. u8 type, u8 instruction,
  18. const u8 *payload, size_t payload_len,
  19. data_exchange_cb_t cb, void *cb_context,
  20. unsigned long completion_delay)
  21. {
  22. struct nfc_dev *ndev = hdev->ndev;
  23. struct hci_msg *cmd;
  24. const u8 *ptr = payload;
  25. int hci_len, err;
  26. bool firstfrag = true;
  27. cmd = kzalloc(sizeof(struct hci_msg), GFP_KERNEL);
  28. if (cmd == NULL)
  29. return -ENOMEM;
  30. INIT_LIST_HEAD(&cmd->msg_l);
  31. skb_queue_head_init(&cmd->msg_frags);
  32. cmd->wait_response = (type == NFC_HCI_HCP_COMMAND) ? true : false;
  33. cmd->cb = cb;
  34. cmd->cb_context = cb_context;
  35. cmd->completion_delay = completion_delay;
  36. hci_len = payload_len + 1;
  37. while (hci_len > 0) {
  38. struct sk_buff *skb;
  39. int skb_len, data_link_len;
  40. struct hcp_packet *packet;
  41. if (NFC_HCI_HCP_PACKET_HEADER_LEN + hci_len <=
  42. hdev->max_data_link_payload)
  43. data_link_len = hci_len;
  44. else
  45. data_link_len = hdev->max_data_link_payload -
  46. NFC_HCI_HCP_PACKET_HEADER_LEN;
  47. skb_len = ndev->tx_headroom + NFC_HCI_HCP_PACKET_HEADER_LEN +
  48. data_link_len + ndev->tx_tailroom;
  49. hci_len -= data_link_len;
  50. skb = alloc_skb(skb_len, GFP_KERNEL);
  51. if (skb == NULL) {
  52. err = -ENOMEM;
  53. goto out_skb_err;
  54. }
  55. skb_reserve(skb, ndev->tx_headroom);
  56. skb_put(skb, NFC_HCI_HCP_PACKET_HEADER_LEN + data_link_len);
  57. /* Only the last fragment will have the cb bit set to 1 */
  58. packet = (struct hcp_packet *)skb->data;
  59. packet->header = pipe;
  60. if (firstfrag) {
  61. firstfrag = false;
  62. packet->message.header = HCP_HEADER(type, instruction);
  63. if (ptr) {
  64. memcpy(packet->message.data, ptr,
  65. data_link_len - 1);
  66. ptr += data_link_len - 1;
  67. }
  68. } else {
  69. memcpy(&packet->message, ptr, data_link_len);
  70. ptr += data_link_len;
  71. }
  72. /* This is the last fragment, set the cb bit */
  73. if (hci_len == 0)
  74. packet->header |= ~NFC_HCI_FRAGMENT;
  75. skb_queue_tail(&cmd->msg_frags, skb);
  76. }
  77. mutex_lock(&hdev->msg_tx_mutex);
  78. if (hdev->shutting_down) {
  79. err = -ESHUTDOWN;
  80. mutex_unlock(&hdev->msg_tx_mutex);
  81. goto out_skb_err;
  82. }
  83. list_add_tail(&cmd->msg_l, &hdev->msg_tx_queue);
  84. mutex_unlock(&hdev->msg_tx_mutex);
  85. schedule_work(&hdev->msg_tx_work);
  86. return 0;
  87. out_skb_err:
  88. skb_queue_purge(&cmd->msg_frags);
  89. kfree(cmd);
  90. return err;
  91. }
  92. /*
  93. * Receive hcp message for pipe, with type and cmd.
  94. * skb contains optional message data only.
  95. */
  96. void nfc_hci_hcp_message_rx(struct nfc_hci_dev *hdev, u8 pipe, u8 type,
  97. u8 instruction, struct sk_buff *skb)
  98. {
  99. switch (type) {
  100. case NFC_HCI_HCP_RESPONSE:
  101. nfc_hci_resp_received(hdev, instruction, skb);
  102. break;
  103. case NFC_HCI_HCP_COMMAND:
  104. nfc_hci_cmd_received(hdev, pipe, instruction, skb);
  105. break;
  106. case NFC_HCI_HCP_EVENT:
  107. nfc_hci_event_received(hdev, pipe, instruction, skb);
  108. break;
  109. default:
  110. pr_err("UNKNOWN MSG Type %d, instruction=%d\n",
  111. type, instruction);
  112. kfree_skb(skb);
  113. break;
  114. }
  115. }