nfc/nci/rsp.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  *
0008  *  Written by Ilan Elias <ilane@ti.com>
0009  *
0010  *  Acknowledgements:
0011  *  This file is based on hci_event.c, which was written
0012  *  by Maxim Krasnyansky.
0013  */
0014
0015 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
0016
0017 #include <linux/types.h>
0018 #include <linux/interrupt.h>
0019 #include <linux/bitops.h>
0020 #include <linux/skbuff.h>
0021
0022 #include "../nfc.h"
0023 #include <net/nfc/nci.h>
0024 #include <net/nfc/nci_core.h>
0025
0026 /* Handle NCI Response packets */
0027
0028 static void nci_core_reset_rsp_packet(struct nci_dev *ndev,
0029                       const struct sk_buff *skb)
0030 {
0031     const struct nci_core_reset_rsp *rsp = (void *)skb->data;
0032
0033     pr_debug("status 0x%x\n", rsp->status);
0034
0035     /* Handle NCI 1.x ver */
0036     if (skb->len != 1) {
0037         if (rsp->status == NCI_STATUS_OK) {
0038             ndev->nci_ver = rsp->nci_ver;
0039             pr_debug("nci_ver 0x%x, config_status 0x%x\n",
0040                  rsp->nci_ver, rsp->config_status);
0041         }
0042
0043         nci_req_complete(ndev, rsp->status);
0044     }
0045 }
0046
0047 static u8 nci_core_init_rsp_packet_v1(struct nci_dev *ndev,
0048                       const struct sk_buff *skb)
0049 {
0050     const struct nci_core_init_rsp_1 *rsp_1 = (void *)skb->data;
0051     const struct nci_core_init_rsp_2 *rsp_2;
0052
0053     pr_debug("status 0x%x\n", rsp_1->status);
0054
0055     if (rsp_1->status != NCI_STATUS_OK)
0056         return rsp_1->status;
0057
0058     ndev->nfcc_features = __le32_to_cpu(rsp_1->nfcc_features);
0059     ndev->num_supported_rf_interfaces = rsp_1->num_supported_rf_interfaces;
0060
0061     ndev->num_supported_rf_interfaces =
0062         min((int)ndev->num_supported_rf_interfaces,
0063             NCI_MAX_SUPPORTED_RF_INTERFACES);
0064
0065     memcpy(ndev->supported_rf_interfaces,
0066            rsp_1->supported_rf_interfaces,
0067            ndev->num_supported_rf_interfaces);
0068
0069     rsp_2 = (void *) (skb->data + 6 + rsp_1->num_supported_rf_interfaces);
0070
0071     ndev->max_logical_connections = rsp_2->max_logical_connections;
0072     ndev->max_routing_table_size =
0073         __le16_to_cpu(rsp_2->max_routing_table_size);
0074     ndev->max_ctrl_pkt_payload_len =
0075         rsp_2->max_ctrl_pkt_payload_len;
0076     ndev->max_size_for_large_params =
0077         __le16_to_cpu(rsp_2->max_size_for_large_params);
0078     ndev->manufact_id =
0079         rsp_2->manufact_id;
0080     ndev->manufact_specific_info =
0081         __le32_to_cpu(rsp_2->manufact_specific_info);
0082
0083     return NCI_STATUS_OK;
0084 }
0085
0086 static u8 nci_core_init_rsp_packet_v2(struct nci_dev *ndev,
0087                       const struct sk_buff *skb)
0088 {
0089     const struct nci_core_init_rsp_nci_ver2 *rsp = (void *)skb->data;
0090     const u8 *supported_rf_interface = rsp->supported_rf_interfaces;
0091     u8 rf_interface_idx = 0;
0092     u8 rf_extension_cnt = 0;
0093
0094     pr_debug("status %x\n", rsp->status);
0095
0096     if (rsp->status != NCI_STATUS_OK)
0097         return rsp->status;
0098
0099     ndev->nfcc_features = __le32_to_cpu(rsp->nfcc_features);
0100     ndev->num_supported_rf_interfaces = rsp->num_supported_rf_interfaces;
0101
0102     ndev->num_supported_rf_interfaces =
0103         min((int)ndev->num_supported_rf_interfaces,
0104             NCI_MAX_SUPPORTED_RF_INTERFACES);
0105
0106     while (rf_interface_idx < ndev->num_supported_rf_interfaces) {
0107         ndev->supported_rf_interfaces[rf_interface_idx++] = *supported_rf_interface++;
0108
0109         /* skip rf extension parameters */
0110         rf_extension_cnt = *supported_rf_interface++;
0111         supported_rf_interface += rf_extension_cnt;
0112     }
0113
0114     ndev->max_logical_connections = rsp->max_logical_connections;
0115     ndev->max_routing_table_size =
0116             __le16_to_cpu(rsp->max_routing_table_size);
0117     ndev->max_ctrl_pkt_payload_len =
0118             rsp->max_ctrl_pkt_payload_len;
0119     ndev->max_size_for_large_params = NCI_MAX_LARGE_PARAMS_NCI_v2;
0120
0121     return NCI_STATUS_OK;
0122 }
0123
0124 static void nci_core_init_rsp_packet(struct nci_dev *ndev, const struct sk_buff *skb)
0125 {
0126     u8 status = 0;
0127
0128     if (!(ndev->nci_ver & NCI_VER_2_MASK))
0129         status = nci_core_init_rsp_packet_v1(ndev, skb);
0130     else
0131         status = nci_core_init_rsp_packet_v2(ndev, skb);
0132
0133     if (status != NCI_STATUS_OK)
0134         goto exit;
0135
0136     pr_debug("nfcc_features 0x%x\n",
0137          ndev->nfcc_features);
0138     pr_debug("num_supported_rf_interfaces %d\n",
0139          ndev->num_supported_rf_interfaces);
0140     pr_debug("supported_rf_interfaces[0] 0x%x\n",
0141          ndev->supported_rf_interfaces[0]);
0142     pr_debug("supported_rf_interfaces[1] 0x%x\n",
0143          ndev->supported_rf_interfaces[1]);
0144     pr_debug("supported_rf_interfaces[2] 0x%x\n",
0145          ndev->supported_rf_interfaces[2]);
0146     pr_debug("supported_rf_interfaces[3] 0x%x\n",
0147          ndev->supported_rf_interfaces[3]);
0148     pr_debug("max_logical_connections %d\n",
0149          ndev->max_logical_connections);
0150     pr_debug("max_routing_table_size %d\n",
0151          ndev->max_routing_table_size);
0152     pr_debug("max_ctrl_pkt_payload_len %d\n",
0153          ndev->max_ctrl_pkt_payload_len);
0154     pr_debug("max_size_for_large_params %d\n",
0155          ndev->max_size_for_large_params);
0156     pr_debug("manufact_id 0x%x\n",
0157          ndev->manufact_id);
0158     pr_debug("manufact_specific_info 0x%x\n",
0159          ndev->manufact_specific_info);
0160
0161 exit:
0162     nci_req_complete(ndev, status);
0163 }
0164
0165 static void nci_core_set_config_rsp_packet(struct nci_dev *ndev,
0166                        const struct sk_buff *skb)
0167 {
0168     const struct nci_core_set_config_rsp *rsp = (void *)skb->data;
0169
0170     pr_debug("status 0x%x\n", rsp->status);
0171
0172     nci_req_complete(ndev, rsp->status);
0173 }
0174
0175 static void nci_rf_disc_map_rsp_packet(struct nci_dev *ndev,
0176                        const struct sk_buff *skb)
0177 {
0178     __u8 status = skb->data[0];
0179
0180     pr_debug("status 0x%x\n", status);
0181
0182     nci_req_complete(ndev, status);
0183 }
0184
0185 static void nci_rf_disc_rsp_packet(struct nci_dev *ndev,
0186                    const struct sk_buff *skb)
0187 {
0188     struct nci_conn_info *conn_info;
0189     __u8 status = skb->data[0];
0190
0191     pr_debug("status 0x%x\n", status);
0192
0193     if (status == NCI_STATUS_OK) {
0194         atomic_set(&ndev->state, NCI_DISCOVERY);
0195
0196         conn_info = ndev->rf_conn_info;
0197         if (!conn_info) {
0198             conn_info = devm_kzalloc(&ndev->nfc_dev->dev,
0199                          sizeof(struct nci_conn_info),
0200                          GFP_KERNEL);
0201             if (!conn_info) {
0202                 status = NCI_STATUS_REJECTED;
0203                 goto exit;
0204             }
0205             conn_info->conn_id = NCI_STATIC_RF_CONN_ID;
0206             INIT_LIST_HEAD(&conn_info->list);
0207             list_add(&conn_info->list, &ndev->conn_info_list);
0208             ndev->rf_conn_info = conn_info;
0209         }
0210     }
0211
0212 exit:
0213     nci_req_complete(ndev, status);
0214 }
0215
0216 static void nci_rf_disc_select_rsp_packet(struct nci_dev *ndev,
0217                       const struct sk_buff *skb)
0218 {
0219     __u8 status = skb->data[0];
0220
0221     pr_debug("status 0x%x\n", status);
0222
0223     /* Complete the request on intf_activated_ntf or generic_error_ntf */
0224     if (status != NCI_STATUS_OK)
0225         nci_req_complete(ndev, status);
0226 }
0227
0228 static void nci_rf_deactivate_rsp_packet(struct nci_dev *ndev,
0229                      const struct sk_buff *skb)
0230 {
0231     __u8 status = skb->data[0];
0232
0233     pr_debug("status 0x%x\n", status);
0234
0235     /* If target was active, complete the request only in deactivate_ntf */
0236     if ((status != NCI_STATUS_OK) ||
0237         (atomic_read(&ndev->state) != NCI_POLL_ACTIVE)) {
0238         nci_clear_target_list(ndev);
0239         atomic_set(&ndev->state, NCI_IDLE);
0240         nci_req_complete(ndev, status);
0241     }
0242 }
0243
0244 static void nci_nfcee_discover_rsp_packet(struct nci_dev *ndev,
0245                       const struct sk_buff *skb)
0246 {
0247     const struct nci_nfcee_discover_rsp *discover_rsp;
0248
0249     if (skb->len != 2) {
0250         nci_req_complete(ndev, NCI_STATUS_NFCEE_PROTOCOL_ERROR);
0251         return;
0252     }
0253
0254     discover_rsp = (struct nci_nfcee_discover_rsp *)skb->data;
0255
0256     if (discover_rsp->status != NCI_STATUS_OK ||
0257         discover_rsp->num_nfcee == 0)
0258         nci_req_complete(ndev, discover_rsp->status);
0259 }
0260
0261 static void nci_nfcee_mode_set_rsp_packet(struct nci_dev *ndev,
0262                       const struct sk_buff *skb)
0263 {
0264     __u8 status = skb->data[0];
0265
0266     pr_debug("status 0x%x\n", status);
0267     nci_req_complete(ndev, status);
0268 }
0269
0270 static void nci_core_conn_create_rsp_packet(struct nci_dev *ndev,
0271                         const struct sk_buff *skb)
0272 {
0273     __u8 status = skb->data[0];
0274     struct nci_conn_info *conn_info = NULL;
0275     const struct nci_core_conn_create_rsp *rsp;
0276
0277     pr_debug("status 0x%x\n", status);
0278
0279     if (status == NCI_STATUS_OK) {
0280         rsp = (struct nci_core_conn_create_rsp *)skb->data;
0281
0282         conn_info = devm_kzalloc(&ndev->nfc_dev->dev,
0283                      sizeof(*conn_info), GFP_KERNEL);
0284         if (!conn_info) {
0285             status = NCI_STATUS_REJECTED;
0286             goto exit;
0287         }
0288
0289         conn_info->dest_params = devm_kzalloc(&ndev->nfc_dev->dev,
0290                         sizeof(struct dest_spec_params),
0291                         GFP_KERNEL);
0292         if (!conn_info->dest_params) {
0293             status = NCI_STATUS_REJECTED;
0294             goto free_conn_info;
0295         }
0296
0297         conn_info->dest_type = ndev->cur_dest_type;
0298         conn_info->dest_params->id = ndev->cur_params.id;
0299         conn_info->dest_params->protocol = ndev->cur_params.protocol;
0300         conn_info->conn_id = rsp->conn_id;
0301
0302         /* Note: data_exchange_cb and data_exchange_cb_context need to
0303          * be specify out of nci_core_conn_create_rsp_packet
0304          */
0305
0306         INIT_LIST_HEAD(&conn_info->list);
0307         list_add(&conn_info->list, &ndev->conn_info_list);
0308
0309         if (ndev->cur_params.id == ndev->hci_dev->nfcee_id)
0310             ndev->hci_dev->conn_info = conn_info;
0311
0312         conn_info->conn_id = rsp->conn_id;
0313         conn_info->max_pkt_payload_len = rsp->max_ctrl_pkt_payload_len;
0314         atomic_set(&conn_info->credits_cnt, rsp->credits_cnt);
0315     }
0316
0317 free_conn_info:
0318     if (status == NCI_STATUS_REJECTED)
0319         devm_kfree(&ndev->nfc_dev->dev, conn_info);
0320 exit:
0321
0322     nci_req_complete(ndev, status);
0323 }
0324
0325 static void nci_core_conn_close_rsp_packet(struct nci_dev *ndev,
0326                        const struct sk_buff *skb)
0327 {
0328     struct nci_conn_info *conn_info;
0329     __u8 status = skb->data[0];
0330
0331     pr_debug("status 0x%x\n", status);
0332     if (status == NCI_STATUS_OK) {
0333         conn_info = nci_get_conn_info_by_conn_id(ndev,
0334                              ndev->cur_conn_id);
0335         if (conn_info) {
0336             list_del(&conn_info->list);
0337             if (conn_info == ndev->rf_conn_info)
0338                 ndev->rf_conn_info = NULL;
0339             devm_kfree(&ndev->nfc_dev->dev, conn_info);
0340         }
0341     }
0342     nci_req_complete(ndev, status);
0343 }
0344
0345 void nci_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
0346 {
0347     __u16 rsp_opcode = nci_opcode(skb->data);
0348
0349     /* we got a rsp, stop the cmd timer */
0350     del_timer(&ndev->cmd_timer);
0351
0352     pr_debug("NCI RX: MT=rsp, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",
0353          nci_pbf(skb->data),
0354          nci_opcode_gid(rsp_opcode),
0355          nci_opcode_oid(rsp_opcode),
0356          nci_plen(skb->data));
0357
0358     /* strip the nci control header */
0359     skb_pull(skb, NCI_CTRL_HDR_SIZE);
0360
0361     if (nci_opcode_gid(rsp_opcode) == NCI_GID_PROPRIETARY) {
0362         if (nci_prop_rsp_packet(ndev, rsp_opcode, skb) == -ENOTSUPP) {
0363             pr_err("unsupported rsp opcode 0x%x\n",
0364                    rsp_opcode);
0365         }
0366
0367         goto end;
0368     }
0369
0370     switch (rsp_opcode) {
0371     case NCI_OP_CORE_RESET_RSP:
0372         nci_core_reset_rsp_packet(ndev, skb);
0373         break;
0374
0375     case NCI_OP_CORE_INIT_RSP:
0376         nci_core_init_rsp_packet(ndev, skb);
0377         break;
0378
0379     case NCI_OP_CORE_SET_CONFIG_RSP:
0380         nci_core_set_config_rsp_packet(ndev, skb);
0381         break;
0382
0383     case NCI_OP_CORE_CONN_CREATE_RSP:
0384         nci_core_conn_create_rsp_packet(ndev, skb);
0385         break;
0386
0387     case NCI_OP_CORE_CONN_CLOSE_RSP:
0388         nci_core_conn_close_rsp_packet(ndev, skb);
0389         break;
0390
0391     case NCI_OP_RF_DISCOVER_MAP_RSP:
0392         nci_rf_disc_map_rsp_packet(ndev, skb);
0393         break;
0394
0395     case NCI_OP_RF_DISCOVER_RSP:
0396         nci_rf_disc_rsp_packet(ndev, skb);
0397         break;
0398
0399     case NCI_OP_RF_DISCOVER_SELECT_RSP:
0400         nci_rf_disc_select_rsp_packet(ndev, skb);
0401         break;
0402
0403     case NCI_OP_RF_DEACTIVATE_RSP:
0404         nci_rf_deactivate_rsp_packet(ndev, skb);
0405         break;
0406
0407     case NCI_OP_NFCEE_DISCOVER_RSP:
0408         nci_nfcee_discover_rsp_packet(ndev, skb);
0409         break;
0410
0411     case NCI_OP_NFCEE_MODE_SET_RSP:
0412         nci_nfcee_mode_set_rsp_packet(ndev, skb);
0413         break;
0414
0415     default:
0416         pr_err("unknown rsp opcode 0x%x\n", rsp_opcode);
0417         break;
0418     }
0419
0420     nci_core_rsp_packet(ndev, rsp_opcode, skb);
0421 end:
0422     kfree_skb(skb);
0423
0424     /* trigger the next cmd */
0425     atomic_set(&ndev->cmd_cnt, 1);
0426     if (!skb_queue_empty(&ndev->cmd_q))
0427         queue_work(ndev->cmd_wq, &ndev->cmd_work);
0428 }