nfc/hci/hcp.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2012  Intel Corporation. All rights reserved.
0004  */
0005
0006 #define pr_fmt(fmt) "hci: %s: " fmt, __func__
0007
0008 #include <linux/init.h>
0009 #include <linux/kernel.h>
0010 #include <linux/module.h>
0011
0012 #include <net/nfc/hci.h>
0013
0014 #include "hci.h"
0015
0016 /*
0017  * Payload is the HCP message data only. Instruction will be prepended.
0018  * Guarantees that cb will be called upon completion or timeout delay
0019  * counted from the moment the cmd is sent to the transport.
0020  */
0021 int nfc_hci_hcp_message_tx(struct nfc_hci_dev *hdev, u8 pipe,
0022                u8 type, u8 instruction,
0023                const u8 *payload, size_t payload_len,
0024                data_exchange_cb_t cb, void *cb_context,
0025                unsigned long completion_delay)
0026 {
0027     struct nfc_dev *ndev = hdev->ndev;
0028     struct hci_msg *cmd;
0029     const u8 *ptr = payload;
0030     int hci_len, err;
0031     bool firstfrag = true;
0032
0033     cmd = kzalloc(sizeof(struct hci_msg), GFP_KERNEL);
0034     if (cmd == NULL)
0035         return -ENOMEM;
0036
0037     INIT_LIST_HEAD(&cmd->msg_l);
0038     skb_queue_head_init(&cmd->msg_frags);
0039     cmd->wait_response = (type == NFC_HCI_HCP_COMMAND) ? true : false;
0040     cmd->cb = cb;
0041     cmd->cb_context = cb_context;
0042     cmd->completion_delay = completion_delay;
0043
0044     hci_len = payload_len + 1;
0045     while (hci_len > 0) {
0046         struct sk_buff *skb;
0047         int skb_len, data_link_len;
0048         struct hcp_packet *packet;
0049
0050         if (NFC_HCI_HCP_PACKET_HEADER_LEN + hci_len <=
0051             hdev->max_data_link_payload)
0052             data_link_len = hci_len;
0053         else
0054             data_link_len = hdev->max_data_link_payload -
0055                     NFC_HCI_HCP_PACKET_HEADER_LEN;
0056
0057         skb_len = ndev->tx_headroom + NFC_HCI_HCP_PACKET_HEADER_LEN +
0058               data_link_len + ndev->tx_tailroom;
0059         hci_len -= data_link_len;
0060
0061         skb = alloc_skb(skb_len, GFP_KERNEL);
0062         if (skb == NULL) {
0063             err = -ENOMEM;
0064             goto out_skb_err;
0065         }
0066         skb_reserve(skb, ndev->tx_headroom);
0067
0068         skb_put(skb, NFC_HCI_HCP_PACKET_HEADER_LEN + data_link_len);
0069
0070         /* Only the last fragment will have the cb bit set to 1 */
0071         packet = (struct hcp_packet *)skb->data;
0072         packet->header = pipe;
0073         if (firstfrag) {
0074             firstfrag = false;
0075             packet->message.header = HCP_HEADER(type, instruction);
0076             if (ptr) {
0077                 memcpy(packet->message.data, ptr,
0078                        data_link_len - 1);
0079                 ptr += data_link_len - 1;
0080             }
0081         } else {
0082             memcpy(&packet->message, ptr, data_link_len);
0083             ptr += data_link_len;
0084         }
0085
0086         /* This is the last fragment, set the cb bit */
0087         if (hci_len == 0)
0088             packet->header |= ~NFC_HCI_FRAGMENT;
0089
0090         skb_queue_tail(&cmd->msg_frags, skb);
0091     }
0092
0093     mutex_lock(&hdev->msg_tx_mutex);
0094
0095     if (hdev->shutting_down) {
0096         err = -ESHUTDOWN;
0097         mutex_unlock(&hdev->msg_tx_mutex);
0098         goto out_skb_err;
0099     }
0100
0101     list_add_tail(&cmd->msg_l, &hdev->msg_tx_queue);
0102     mutex_unlock(&hdev->msg_tx_mutex);
0103
0104     schedule_work(&hdev->msg_tx_work);
0105
0106     return 0;
0107
0108 out_skb_err:
0109     skb_queue_purge(&cmd->msg_frags);
0110     kfree(cmd);
0111
0112     return err;
0113 }
0114
0115 /*
0116  * Receive hcp message for pipe, with type and cmd.
0117  * skb contains optional message data only.
0118  */
0119 void nfc_hci_hcp_message_rx(struct nfc_hci_dev *hdev, u8 pipe, u8 type,
0120                 u8 instruction, struct sk_buff *skb)
0121 {
0122     switch (type) {
0123     case NFC_HCI_HCP_RESPONSE:
0124         nfc_hci_resp_received(hdev, instruction, skb);
0125         break;
0126     case NFC_HCI_HCP_COMMAND:
0127         nfc_hci_cmd_received(hdev, pipe, instruction, skb);
0128         break;
0129     case NFC_HCI_HCP_EVENT:
0130         nfc_hci_event_received(hdev, pipe, instruction, skb);
0131         break;
0132     default:
0133         pr_err("UNKNOWN MSG Type %d, instruction=%d\n",
0134                type, instruction);
0135         kfree_skb(skb);
0136         break;
0137     }
0138 }