Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7d0911c0 authored by Thierry Escande's avatar Thierry Escande Committed by Samuel Ortiz
Browse files

NFC Digital: Add initiator NFC-DEP support 



This adds support for NFC-DEP protocol in initiator mode for NFC-A and
NFC-F technologies.

When a target is detected, the process flow is as follow:

For NFC-A technology:
1 - The digital stack receives a SEL_RES as the reply of the SEL_REQ
    command.
2   - If b7 of SEL_RES is set, the peer device is configure for NFC-DEP
      protocol. NFC core is notified through nfc_targets_found().
      Execution continues at step 4.
3   - Otherwise, it's a tag and the NFC core is notified. Detection
      ends.
4 - The digital stacks sends an ATR_REQ command containing a randomly
    generated NFCID3 and the general bytes obtained from the LLCP layer
    of NFC core.

For NFC-F technology:
1 - The digital stack receives a SENSF_RES as the reply of the
    SENSF_REQ command.
2   - If B1 and B2 of NFCID2 are 0x01 and 0xFE respectively, the peer
      device is configured for NFC-DEP protocol. NFC core is notified
      through nfc_targets_found(). Execution continues at step 4.
3   - Otherwise it's a type 3 tag. NFC core is notified. Detection
      ends.
4 - The digital stacks sends an ATR_REQ command containing the NFC-F
    NFCID2 as NFCID3 and the general bytes obtained from the LLCP layer
    of NFC core.

For both technologies:
5 - The digital stacks receives the ATR_RES response containing the
    NFCID3 and the general bytes of the peer device.
6 - The digital stack notifies NFC core that the DEP link is up through
    nfc_dep_link_up().
7 - The NFC core performs data exchange through tm_transceive().
8 - The digital stack sends a DEP_REQ command containing an I PDU with
    the data from NFC core.
9 - The digital stack receives a DEP_RES command
10  - If the DEP_RES response contains a supervisor PDU with timeout
      extension request (RTOX) the digital stack sends a DEP_REQ
      command containing a supervisor PDU acknowledging the RTOX
      request. The execution continues at step 9.
11  - If the DEP_RES response contains an I PDU, the response data is
      passed back to NFC core through the response callback. The
      execution continues at step 8.

Signed-off-by: default avatarThierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: default avatarSamuel Ortiz <sameo@linux.intel.com>
parent 8c0695e4

net/nfc/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -10,4 +10,4 @@ obj-$(CONFIG_NFC_DIGITAL) += nfc_digital.o 
nfc-objs := core.o netlink.o af_nfc.o rawsock.o llcp_core.o llcp_commands.o \

		llcp_sock.o



nfc_digital-objs := digital_core.o digital_technology.o
 
nfc_digital-objs := digital_core.o digital_technology.o digital_dep.o

net/nfc/digital.h

+14 −0
Original line number Diff line number Diff line
@@ -35,6 +35,13 @@ 
#define DIGITAL_MAX_HEADER_LEN 7

#define DIGITAL_CRC_LEN        2



#define DIGITAL_SENSF_NFCID2_NFC_DEP_B1 0x01

#define DIGITAL_SENSF_NFCID2_NFC_DEP_B2 0xFE



#define DIGITAL_SENS_RES_NFC_DEP 0x0100

#define DIGITAL_SEL_RES_NFC_DEP  0x40

#define DIGITAL_SENSF_FELICA_SC  0xFFFF



#define DIGITAL_DRV_CAPS_IN_CRC(ddev) \

	((ddev)->driver_capabilities & NFC_DIGITAL_DRV_CAPS_IN_CRC)

#define DIGITAL_DRV_CAPS_TG_CRC(ddev) \
@@ -72,6 +79,13 @@ int digital_target_found(struct nfc_digital_dev *ddev, 


int digital_in_recv_mifare_res(struct sk_buff *resp);



int digital_in_send_atr_req(struct nfc_digital_dev *ddev,

			    struct nfc_target *target, __u8 comm_mode, __u8 *gb,

			    size_t gb_len);

int digital_in_send_dep_req(struct nfc_digital_dev *ddev,

			    struct nfc_target *target, struct sk_buff *skb,

			    struct digital_data_exch *data_exch);



typedef u16 (*crc_func_t)(u16, const u8 *, size_t);



#define CRC_A_INIT 0x6363

net/nfc/digital_core.c

+28 −4
Original line number Diff line number Diff line
@@ -18,9 +18,10 @@ 
#include "digital.h"



#define DIGITAL_PROTO_NFCA_RF_TECH \

	(NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK)

	(NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK | NFC_PROTO_NFC_DEP_MASK)



#define DIGITAL_PROTO_NFCF_RF_TECH (NFC_PROTO_FELICA_MASK)

#define DIGITAL_PROTO_NFCF_RF_TECH \

	(NFC_PROTO_FELICA_MASK | NFC_PROTO_NFC_DEP_MASK)



struct digital_cmd {

	struct list_head queue;
@@ -260,6 +261,18 @@ int digital_target_found(struct nfc_digital_dev *ddev, 
		add_crc = digital_skb_add_crc_f;

		break;



	case NFC_PROTO_NFC_DEP:

		if (rf_tech == NFC_DIGITAL_RF_TECH_106A) {

			framing = NFC_DIGITAL_FRAMING_NFCA_NFC_DEP;

			check_crc = digital_skb_check_crc_a;

			add_crc = digital_skb_add_crc_a;

		} else {

			framing = NFC_DIGITAL_FRAMING_NFCF_NFC_DEP;

			check_crc = digital_skb_check_crc_f;

			add_crc = digital_skb_add_crc_f;

		}

		break;



	default:

		PR_ERR("Invalid protocol %d", protocol);

		return -EINVAL;
@@ -453,12 +466,18 @@ static int digital_dep_link_up(struct nfc_dev *nfc_dev, 
			       struct nfc_target *target,

			       __u8 comm_mode, __u8 *gb, size_t gb_len)

{

	return -EOPNOTSUPP;

	struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);



	return digital_in_send_atr_req(ddev, target, comm_mode, gb, gb_len);

}



static int digital_dep_link_down(struct nfc_dev *nfc_dev)

{

	return -EOPNOTSUPP;

	struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);



	ddev->curr_protocol = 0;



	return 0;

}



static int digital_activate_target(struct nfc_dev *nfc_dev,
@@ -523,6 +542,9 @@ static int digital_in_send(struct nfc_dev *nfc_dev, struct nfc_target *target, 
	data_exch->cb = cb;

	data_exch->cb_context = cb_context;



	if (ddev->curr_protocol == NFC_PROTO_NFC_DEP)

		return digital_in_send_dep_req(ddev, target, skb, data_exch);



	ddev->skb_add_crc(skb);



	return digital_in_send_cmd(ddev, skb, 500, digital_in_send_complete,
@@ -578,6 +600,8 @@ struct nfc_digital_dev *nfc_digital_allocate_device(struct nfc_digital_ops *ops, 
		ddev->protocols |= NFC_PROTO_MIFARE_MASK;

	if (supported_protocols & NFC_PROTO_FELICA_MASK)

		ddev->protocols |= NFC_PROTO_FELICA_MASK;

	if (supported_protocols & NFC_PROTO_NFC_DEP_MASK)

		ddev->protocols |= NFC_PROTO_NFC_DEP_MASK;



	ddev->tx_headroom = tx_headroom + DIGITAL_MAX_HEADER_LEN;

	ddev->tx_tailroom = tx_tailroom + DIGITAL_CRC_LEN;

net/nfc/digital_dep.c

0 → 100644
+381 −0
Original line number Diff line number Diff line 
/*

 * NFC Digital Protocol stack

 * Copyright (c) 2013, Intel Corporation.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 */



#include "digital.h"



#define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4

#define DIGITAL_NFC_DEP_FRAME_DIR_IN  0xD5



#define DIGITAL_NFC_DEP_NFCA_SOD_SB   0xF0



#define DIGITAL_CMD_ATR_REQ 0x00

#define DIGITAL_CMD_ATR_RES 0x01

#define DIGITAL_CMD_PSL_REQ 0x04

#define DIGITAL_CMD_PSL_RES 0x05

#define DIGITAL_CMD_DEP_REQ 0x06

#define DIGITAL_CMD_DEP_RES 0x07



#define DIGITAL_ATR_REQ_MIN_SIZE 16

#define DIGITAL_ATR_REQ_MAX_SIZE 64



#define DIGITAL_NFCID3_LEN ((u8)8)

#define DIGITAL_LR_BITS_PAYLOAD_SIZE_254B 0x30

#define DIGITAL_GB_BIT	0x02



#define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)



#define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10



#define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \

				((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)

#define DIGITAL_NFC_DEP_MI_BIT_SET(pfb)  ((pfb) & 0x10)

#define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)

#define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & 0x04)

#define DIGITAL_NFC_DEP_PFB_PNI(pfb)     ((pfb) & 0x03)



#define DIGITAL_NFC_DEP_PFB_I_PDU          0x00

#define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU   0x40

#define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80



struct digital_atr_req {

	u8 dir;

	u8 cmd;

	u8 nfcid3[10];

	u8 did;

	u8 bs;

	u8 br;

	u8 pp;

	u8 gb[0];

} __packed;



struct digital_atr_res {

	u8 dir;

	u8 cmd;

	u8 nfcid3[10];

	u8 did;

	u8 bs;

	u8 br;

	u8 to;

	u8 pp;

	u8 gb[0];

} __packed;



struct digital_psl_req {

	u8 dir;

	u8 cmd;

	u8 did;

	u8 brs;

	u8 fsl;

} __packed;



struct digital_psl_res {

	u8 dir;

	u8 cmd;

	u8 did;

} __packed;



struct digital_dep_req_res {

	u8 dir;

	u8 cmd;

	u8 pfb;

} __packed;



static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,

				    struct sk_buff *resp);



static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,

				     struct sk_buff *skb)

{

	skb_push(skb, sizeof(u8));



	skb->data[0] = skb->len;



	if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)

		*skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;

}



static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,

				    struct sk_buff *skb)

{

	u8 size;



	if (skb->len < 2)

		return -EIO;



	if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)

		skb_pull(skb, sizeof(u8));



	size = skb->data[0];

	if (size != skb->len)

		return -EIO;



	skb_pull(skb, sizeof(u8));



	return 0;

}



static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg,

				 struct sk_buff *resp)

{

	struct nfc_target *target = arg;

	struct digital_atr_res *atr_res;

	u8 gb_len;

	int rc;



	if (IS_ERR(resp)) {

		rc = PTR_ERR(resp);

		resp = NULL;

		goto exit;

	}



	rc = ddev->skb_check_crc(resp);

	if (rc) {

		PROTOCOL_ERR("14.4.1.6");

		goto exit;

	}



	rc = digital_skb_pull_dep_sod(ddev, resp);

	if (rc) {

		PROTOCOL_ERR("14.4.1.2");

		goto exit;

	}



	if (resp->len < sizeof(struct digital_atr_res)) {

		rc = -EIO;

		goto exit;

	}



	gb_len = resp->len - sizeof(struct digital_atr_res);



	atr_res = (struct digital_atr_res *)resp->data;



	rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);

	if (rc)

		goto exit;



	rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,

				NFC_RF_INITIATOR);



	ddev->curr_nfc_dep_pni = 0;



exit:

	dev_kfree_skb(resp);



	if (rc)

		ddev->curr_protocol = 0;

}



int digital_in_send_atr_req(struct nfc_digital_dev *ddev,

			    struct nfc_target *target, __u8 comm_mode, __u8 *gb,

			    size_t gb_len)

{

	struct sk_buff *skb;

	struct digital_atr_req *atr_req;

	uint size;



	size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;



	if (size > DIGITAL_ATR_REQ_MAX_SIZE) {

		PROTOCOL_ERR("14.6.1.1");

		return -EINVAL;

	}



	skb = digital_skb_alloc(ddev, size);

	if (!skb)

		return -ENOMEM;



	skb_put(skb, sizeof(struct digital_atr_req));



	atr_req = (struct digital_atr_req *)skb->data;

	memset(atr_req, 0, sizeof(struct digital_atr_req));



	atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;

	atr_req->cmd = DIGITAL_CMD_ATR_REQ;

	if (target->nfcid2_len)

		memcpy(atr_req->nfcid3, target->nfcid2,

		       max(target->nfcid2_len, DIGITAL_NFCID3_LEN));

	else

		get_random_bytes(atr_req->nfcid3, DIGITAL_NFCID3_LEN);



	atr_req->did = 0;

	atr_req->bs = 0;

	atr_req->br = 0;



	atr_req->pp = DIGITAL_LR_BITS_PAYLOAD_SIZE_254B;



	if (gb_len) {

		atr_req->pp |= DIGITAL_GB_BIT;

		memcpy(skb_put(skb, gb_len), gb, gb_len);

	}



	digital_skb_push_dep_sod(ddev, skb);



	ddev->skb_add_crc(skb);



	digital_in_send_cmd(ddev, skb, 500, digital_in_recv_atr_res, target);



	return 0;

}



static int digital_in_send_rtox(struct nfc_digital_dev *ddev,

				struct digital_data_exch *data_exch, u8 rtox)

{

	struct digital_dep_req_res *dep_req;

	struct sk_buff *skb;

	int rc;



	skb = digital_skb_alloc(ddev, 1);

	if (!skb)

		return -ENOMEM;



	*skb_put(skb, 1) = rtox;



	skb_push(skb, sizeof(struct digital_dep_req_res));



	dep_req = (struct digital_dep_req_res *)skb->data;



	dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;

	dep_req->cmd = DIGITAL_CMD_DEP_REQ;

	dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU |

		       DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT;



	digital_skb_push_dep_sod(ddev, skb);



	ddev->skb_add_crc(skb);



	rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,

				 data_exch);



	return rc;

}



static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,

				    struct sk_buff *resp)

{

	struct digital_data_exch *data_exch = arg;

	struct digital_dep_req_res *dep_res;

	u8 pfb;

	uint size;

	int rc;



	if (IS_ERR(resp)) {

		rc = PTR_ERR(resp);

		resp = NULL;

		goto exit;

	}



	rc = ddev->skb_check_crc(resp);

	if (rc) {

		PROTOCOL_ERR("14.4.1.6");

		goto error;

	}



	rc = digital_skb_pull_dep_sod(ddev, resp);

	if (rc) {

		PROTOCOL_ERR("14.4.1.2");

		goto exit;

	}



	dep_res = (struct digital_dep_req_res *)resp->data;



	if (resp->len < sizeof(struct digital_dep_req_res) ||

	    dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||

	    dep_res->cmd != DIGITAL_CMD_DEP_RES) {

		rc = -EIO;

		goto error;

	}



	pfb = dep_res->pfb;



	switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {

	case DIGITAL_NFC_DEP_PFB_I_PDU:

		if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {

			PROTOCOL_ERR("14.12.3.3");

			rc = -EIO;

			goto error;

		}



		ddev->curr_nfc_dep_pni =

			DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);

		rc = 0;

		break;



	case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:

		PR_ERR("Received a ACK/NACK PDU");

		rc = -EIO;

		goto error;



	case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:

		if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {

			rc = -EINVAL;

			goto error;

		}



		rc = digital_in_send_rtox(ddev, data_exch, resp->data[3]);

		if (rc)

			goto error;



		kfree_skb(resp);

		return;

	}



	if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {

		PR_ERR("MI bit set. Chained PDU not supported.");

		rc = -EIO;

		goto error;

	}



	size = sizeof(struct digital_dep_req_res);



	if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb))

		size++;



	if (size > resp->len) {

		rc = -EIO;

		goto error;

	}



	skb_pull(resp, size);



exit:

	data_exch->cb(data_exch->cb_context, resp, rc);



error:

	kfree(data_exch);



	if (rc)

		kfree_skb(resp);

}



int digital_in_send_dep_req(struct nfc_digital_dev *ddev,

			    struct nfc_target *target, struct sk_buff *skb,

			    struct digital_data_exch *data_exch)

{

	struct digital_dep_req_res *dep_req;



	skb_push(skb, sizeof(struct digital_dep_req_res));



	dep_req = (struct digital_dep_req_res *)skb->data;

	dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;

	dep_req->cmd = DIGITAL_CMD_DEP_REQ;

	dep_req->pfb = ddev->curr_nfc_dep_pni;



	digital_skb_push_dep_sod(ddev, skb);



	ddev->skb_add_crc(skb);



	return digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,

				   data_exch);

}

net/nfc/digital_technology.c

+11 −1
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 


#define DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res) (!((sel_res) & 0x04))

#define DIGITAL_SEL_RES_IS_T2T(sel_res) (!((sel_res) & 0x60))

#define DIGITAL_SEL_RES_IS_NFC_DEP(sel_res) ((sel_res) & 0x40)



#define DIGITAL_SENS_RES_IS_T1T(sens_res) (((sens_res) & 0x000C) == 0x000C)

#define DIGITAL_SENS_RES_IS_VALID(sens_res) \
@@ -121,6 +122,8 @@ static void digital_in_recv_sel_res(struct nfc_digital_dev *ddev, void *arg, 


	if (DIGITAL_SEL_RES_IS_T2T(sel_res)) {

		nfc_proto = NFC_PROTO_MIFARE;

	} else if (DIGITAL_SEL_RES_IS_NFC_DEP(sel_res)) {

		nfc_proto = NFC_PROTO_NFC_DEP;

	} else {

		rc = -EOPNOTSUPP;

		goto exit;
@@ -379,6 +382,7 @@ static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg, 
				   struct sk_buff *resp)

{

	int rc;

	u8 proto;

	struct nfc_target target;

	struct digital_sensf_res *sensf_res;
@@ -413,7 +417,13 @@ static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg, 
	memcpy(target.nfcid2, sensf_res->nfcid2, NFC_NFCID2_MAXSIZE);

	target.nfcid2_len = NFC_NFCID2_MAXSIZE;



	rc = digital_target_found(ddev, &target, NFC_PROTO_FELICA);

	if (target.nfcid2[0] == DIGITAL_SENSF_NFCID2_NFC_DEP_B1 &&

	    target.nfcid2[1] == DIGITAL_SENSF_NFCID2_NFC_DEP_B2)

		proto = NFC_PROTO_NFC_DEP;

	else

		proto = NFC_PROTO_FELICA;



	rc = digital_target_found(ddev, &target, proto);



exit:

	dev_kfree_skb(resp);