nfc/nci/data.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  The NFC Controller Interface is the communication protocol between an
0004  *  NFC Controller (NFCC) and a Device Host (DH).
0005  *
0006  *  Copyright (C) 2011 Texas Instruments, Inc.
0007  *  Copyright (C) 2014 Marvell International Ltd.
0008  *
0009  *  Written by Ilan Elias <ilane@ti.com>
0010  */
0011
0012 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
0013
0014 #include <linux/types.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/wait.h>
0017 #include <linux/bitops.h>
0018 #include <linux/skbuff.h>
0019
0020 #include "../nfc.h"
0021 #include <net/nfc/nci.h>
0022 #include <net/nfc/nci_core.h>
0023 #include <linux/nfc.h>
0024
0025 /* Complete data exchange transaction and forward skb to nfc core */
0026 void nci_data_exchange_complete(struct nci_dev *ndev, struct sk_buff *skb,
0027                 __u8 conn_id, int err)
0028 {
0029     const struct nci_conn_info *conn_info;
0030     data_exchange_cb_t cb;
0031     void *cb_context;
0032
0033     conn_info = nci_get_conn_info_by_conn_id(ndev, conn_id);
0034     if (!conn_info) {
0035         kfree_skb(skb);
0036         goto exit;
0037     }
0038
0039     cb = conn_info->data_exchange_cb;
0040     cb_context = conn_info->data_exchange_cb_context;
0041
0042     pr_debug("len %d, err %d\n", skb ? skb->len : 0, err);
0043
0044     /* data exchange is complete, stop the data timer */
0045     del_timer_sync(&ndev->data_timer);
0046     clear_bit(NCI_DATA_EXCHANGE_TO, &ndev->flags);
0047
0048     if (cb) {
0049         /* forward skb to nfc core */
0050         cb(cb_context, skb, err);
0051     } else if (skb) {
0052         pr_err("no rx callback, dropping rx data...\n");
0053
0054         /* no waiting callback, free skb */
0055         kfree_skb(skb);
0056     }
0057
0058 exit:
0059     clear_bit(NCI_DATA_EXCHANGE, &ndev->flags);
0060 }
0061
0062 /* ----------------- NCI TX Data ----------------- */
0063
0064 static inline void nci_push_data_hdr(struct nci_dev *ndev,
0065                      __u8 conn_id,
0066                      struct sk_buff *skb,
0067                      __u8 pbf)
0068 {
0069     struct nci_data_hdr *hdr;
0070     int plen = skb->len;
0071
0072     hdr = skb_push(skb, NCI_DATA_HDR_SIZE);
0073     hdr->conn_id = conn_id;
0074     hdr->rfu = 0;
0075     hdr->plen = plen;
0076
0077     nci_mt_set((__u8 *)hdr, NCI_MT_DATA_PKT);
0078     nci_pbf_set((__u8 *)hdr, pbf);
0079 }
0080
0081 int nci_conn_max_data_pkt_payload_size(struct nci_dev *ndev, __u8 conn_id)
0082 {
0083     const struct nci_conn_info *conn_info;
0084
0085     conn_info = nci_get_conn_info_by_conn_id(ndev, conn_id);
0086     if (!conn_info)
0087         return -EPROTO;
0088
0089     return conn_info->max_pkt_payload_len;
0090 }
0091 EXPORT_SYMBOL(nci_conn_max_data_pkt_payload_size);
0092
0093 static int nci_queue_tx_data_frags(struct nci_dev *ndev,
0094                    __u8 conn_id,
0095                    struct sk_buff *skb) {
0096     const struct nci_conn_info *conn_info;
0097     int total_len = skb->len;
0098     const unsigned char *data = skb->data;
0099     unsigned long flags;
0100     struct sk_buff_head frags_q;
0101     struct sk_buff *skb_frag;
0102     int frag_len;
0103     int rc = 0;
0104
0105     pr_debug("conn_id 0x%x, total_len %d\n", conn_id, total_len);
0106
0107     conn_info = nci_get_conn_info_by_conn_id(ndev, conn_id);
0108     if (!conn_info) {
0109         rc = -EPROTO;
0110         goto exit;
0111     }
0112
0113     __skb_queue_head_init(&frags_q);
0114
0115     while (total_len) {
0116         frag_len =
0117             min_t(int, total_len, conn_info->max_pkt_payload_len);
0118
0119         skb_frag = nci_skb_alloc(ndev,
0120                      (NCI_DATA_HDR_SIZE + frag_len),
0121                      GFP_ATOMIC);
0122         if (skb_frag == NULL) {
0123             rc = -ENOMEM;
0124             goto free_exit;
0125         }
0126         skb_reserve(skb_frag, NCI_DATA_HDR_SIZE);
0127
0128         /* first, copy the data */
0129         skb_put_data(skb_frag, data, frag_len);
0130
0131         /* second, set the header */
0132         nci_push_data_hdr(ndev, conn_id, skb_frag,
0133                   ((total_len == frag_len) ?
0134                    (NCI_PBF_LAST) : (NCI_PBF_CONT)));
0135
0136         __skb_queue_tail(&frags_q, skb_frag);
0137
0138         data += frag_len;
0139         total_len -= frag_len;
0140
0141         pr_debug("frag_len %d, remaining total_len %d\n",
0142              frag_len, total_len);
0143     }
0144
0145     /* queue all fragments atomically */
0146     spin_lock_irqsave(&ndev->tx_q.lock, flags);
0147
0148     while ((skb_frag = __skb_dequeue(&frags_q)) != NULL)
0149         __skb_queue_tail(&ndev->tx_q, skb_frag);
0150
0151     spin_unlock_irqrestore(&ndev->tx_q.lock, flags);
0152
0153     /* free the original skb */
0154     kfree_skb(skb);
0155
0156     goto exit;
0157
0158 free_exit:
0159     while ((skb_frag = __skb_dequeue(&frags_q)) != NULL)
0160         kfree_skb(skb_frag);
0161
0162 exit:
0163     return rc;
0164 }
0165
0166 /* Send NCI data */
0167 int nci_send_data(struct nci_dev *ndev, __u8 conn_id, struct sk_buff *skb)
0168 {
0169     const struct nci_conn_info *conn_info;
0170     int rc = 0;
0171
0172     pr_debug("conn_id 0x%x, plen %d\n", conn_id, skb->len);
0173
0174     conn_info = nci_get_conn_info_by_conn_id(ndev, conn_id);
0175     if (!conn_info) {
0176         rc = -EPROTO;
0177         goto free_exit;
0178     }
0179
0180     /* check if the packet need to be fragmented */
0181     if (skb->len <= conn_info->max_pkt_payload_len) {
0182         /* no need to fragment packet */
0183         nci_push_data_hdr(ndev, conn_id, skb, NCI_PBF_LAST);
0184
0185         skb_queue_tail(&ndev->tx_q, skb);
0186     } else {
0187         /* fragment packet and queue the fragments */
0188         rc = nci_queue_tx_data_frags(ndev, conn_id, skb);
0189         if (rc) {
0190             pr_err("failed to fragment tx data packet\n");
0191             goto free_exit;
0192         }
0193     }
0194
0195     ndev->cur_conn_id = conn_id;
0196     queue_work(ndev->tx_wq, &ndev->tx_work);
0197
0198     goto exit;
0199
0200 free_exit:
0201     kfree_skb(skb);
0202
0203 exit:
0204     return rc;
0205 }
0206 EXPORT_SYMBOL(nci_send_data);
0207
0208 /* ----------------- NCI RX Data ----------------- */
0209
0210 static void nci_add_rx_data_frag(struct nci_dev *ndev,
0211                  struct sk_buff *skb,
0212                  __u8 pbf, __u8 conn_id, __u8 status)
0213 {
0214     int reassembly_len;
0215     int err = 0;
0216
0217     if (status) {
0218         err = status;
0219         goto exit;
0220     }
0221
0222     if (ndev->rx_data_reassembly) {
0223         reassembly_len = ndev->rx_data_reassembly->len;
0224
0225         /* first, make enough room for the already accumulated data */
0226         if (skb_cow_head(skb, reassembly_len)) {
0227             pr_err("error adding room for accumulated rx data\n");
0228
0229             kfree_skb(skb);
0230             skb = NULL;
0231
0232             kfree_skb(ndev->rx_data_reassembly);
0233             ndev->rx_data_reassembly = NULL;
0234
0235             err = -ENOMEM;
0236             goto exit;
0237         }
0238
0239         /* second, combine the two fragments */
0240         memcpy(skb_push(skb, reassembly_len),
0241                ndev->rx_data_reassembly->data,
0242                reassembly_len);
0243
0244         /* third, free old reassembly */
0245         kfree_skb(ndev->rx_data_reassembly);
0246         ndev->rx_data_reassembly = NULL;
0247     }
0248
0249     if (pbf == NCI_PBF_CONT) {
0250         /* need to wait for next fragment, store skb and exit */
0251         ndev->rx_data_reassembly = skb;
0252         return;
0253     }
0254
0255 exit:
0256     if (ndev->nfc_dev->rf_mode == NFC_RF_TARGET) {
0257         /* Data received in Target mode, forward to nfc core */
0258         err = nfc_tm_data_received(ndev->nfc_dev, skb);
0259         if (err)
0260             pr_err("unable to handle received data\n");
0261     } else {
0262         nci_data_exchange_complete(ndev, skb, conn_id, err);
0263     }
0264 }
0265
0266 /* Rx Data packet */
0267 void nci_rx_data_packet(struct nci_dev *ndev, struct sk_buff *skb)
0268 {
0269     __u8 pbf = nci_pbf(skb->data);
0270     __u8 status = 0;
0271     __u8 conn_id = nci_conn_id(skb->data);
0272     const struct nci_conn_info *conn_info;
0273
0274     pr_debug("len %d\n", skb->len);
0275
0276     pr_debug("NCI RX: MT=data, PBF=%d, conn_id=%d, plen=%d\n",
0277          nci_pbf(skb->data),
0278          nci_conn_id(skb->data),
0279          nci_plen(skb->data));
0280
0281     conn_info = nci_get_conn_info_by_conn_id(ndev, nci_conn_id(skb->data));
0282     if (!conn_info)
0283         return;
0284
0285     /* strip the nci data header */
0286     skb_pull(skb, NCI_DATA_HDR_SIZE);
0287
0288     if (ndev->target_active_prot == NFC_PROTO_MIFARE ||
0289         ndev->target_active_prot == NFC_PROTO_JEWEL ||
0290         ndev->target_active_prot == NFC_PROTO_FELICA ||
0291         ndev->target_active_prot == NFC_PROTO_ISO15693) {
0292         /* frame I/F => remove the status byte */
0293         pr_debug("frame I/F => remove the status byte\n");
0294         status = skb->data[skb->len - 1];
0295         skb_trim(skb, (skb->len - 1));
0296     }
0297
0298     nci_add_rx_data_frag(ndev, skb, pbf, conn_id, nci_to_errno(status));
0299 }