[linux-2.6-block.git] / net / nfc / digital_dep.c

/*
 * 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.
 *
 */

#define pr_fmt(fmt) "digital: %s: " fmt, __func__

#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);
}

static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
				    struct sk_buff *resp)
{
	int rc;
	struct digital_dep_req_res *dep_req;
	size_t size;

	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;
	}

	size = sizeof(struct digital_dep_req_res);
	dep_req = (struct digital_dep_req_res *)resp->data;

	if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
	    dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
		rc = -EIO;
		goto exit;
	}

	if (DIGITAL_NFC_DEP_DID_BIT_SET(dep_req->pfb))
		size++;

	if (resp->len < size) {
		rc = -EIO;
		goto exit;
	}

	switch (DIGITAL_NFC_DEP_PFB_TYPE(dep_req->pfb)) {
	case DIGITAL_NFC_DEP_PFB_I_PDU:
		pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU");
		ddev->curr_nfc_dep_pni = DIGITAL_NFC_DEP_PFB_PNI(dep_req->pfb);
		break;
	case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
		pr_err("Received a ACK/NACK PDU");
		rc = -EINVAL;
		goto exit;
		break;
	case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
		pr_err("Received a SUPERVISOR PDU");
		rc = -EINVAL;
		goto exit;
		break;
	}

	skb_pull(resp, size);

	rc = nfc_tm_data_received(ddev->nfc_dev, resp);

exit:
	if (rc)
		kfree_skb(resp);
}

int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
{
	struct digital_dep_req_res *dep_res;

	skb_push(skb, sizeof(struct digital_dep_req_res));
	dep_res = (struct digital_dep_req_res *)skb->data;

	dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
	dep_res->cmd = DIGITAL_CMD_DEP_RES;
	dep_res->pfb = ddev->curr_nfc_dep_pni;

	digital_skb_push_dep_sod(ddev, skb);

	ddev->skb_add_crc(skb);

	return digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
				   NULL);
}

static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
					     void *arg, struct sk_buff *resp)
{
	u8 rf_tech = PTR_ERR(arg);

	if (IS_ERR(resp))
		return;

	digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);

	digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);

	dev_kfree_skb(resp);
}

static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
				   u8 rf_tech)
{
	struct digital_psl_res *psl_res;
	struct sk_buff *skb;
	int rc;

	skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
	if (!skb)
		return -ENOMEM;

	skb_put(skb, sizeof(struct digital_psl_res));

	psl_res = (struct digital_psl_res *)skb->data;

	psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
	psl_res->cmd = DIGITAL_CMD_PSL_RES;
	psl_res->did = did;

	digital_skb_push_dep_sod(ddev, skb);

	ddev->skb_add_crc(skb);

	rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
				 ERR_PTR(rf_tech));

	if (rc)
		kfree_skb(skb);

	return rc;
}

static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
				    struct sk_buff *resp)
{
	int rc;
	struct digital_psl_req *psl_req;
	u8 rf_tech;
	u8 dsi;

	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;
	}

	psl_req = (struct digital_psl_req *)resp->data;

	if (resp->len != sizeof(struct digital_psl_req) ||
	    psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
	    psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
		rc = -EIO;
		goto exit;
	}

	dsi = (psl_req->brs >> 3) & 0x07;
	switch (dsi) {
	case 0:
		rf_tech = NFC_DIGITAL_RF_TECH_106A;
		break;
	case 1:
		rf_tech = NFC_DIGITAL_RF_TECH_212F;
		break;
	case 2:
		rf_tech = NFC_DIGITAL_RF_TECH_424F;
		break;
	default:
		pr_err("Unsuported dsi value %d", dsi);
		goto exit;
	}

	rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);

exit:
	kfree_skb(resp);
}

static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
					     void *arg, struct sk_buff *resp)
{
	int offset;

	if (IS_ERR(resp)) {
		digital_poll_next_tech(ddev);
		return;
	}

	offset = 2;
	if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
		offset++;

	if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
		digital_tg_recv_psl_req(ddev, arg, resp);
	else
		digital_tg_recv_dep_req(ddev, arg, resp);
}

static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
				   struct digital_atr_req *atr_req)
{
	struct digital_atr_res *atr_res;
	struct sk_buff *skb;
	u8 *gb;
	size_t gb_len;
	int rc;

	gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
	if (!gb)
		gb_len = 0;

	skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
	if (!skb)
		return -ENOMEM;

	skb_put(skb, sizeof(struct digital_atr_res));
	atr_res = (struct digital_atr_res *)skb->data;

	memset(atr_res, 0, sizeof(struct digital_atr_res));

	atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
	atr_res->cmd = DIGITAL_CMD_ATR_RES;
	memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
	atr_res->to = 8;
	atr_res->pp = DIGITAL_LR_BITS_PAYLOAD_SIZE_254B;
	if (gb_len) {
		skb_put(skb, gb_len);

		atr_res->pp |= DIGITAL_GB_BIT;
		memcpy(atr_res->gb, gb, gb_len);
	}

	digital_skb_push_dep_sod(ddev, skb);

	ddev->skb_add_crc(skb);

	rc = digital_tg_send_cmd(ddev, skb, 999,
				 digital_tg_send_atr_res_complete, NULL);
	if (rc) {
		kfree_skb(skb);
		return rc;
	}

	return rc;
}

void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
			     struct sk_buff *resp)
{
	int rc;
	struct digital_atr_req *atr_req;
	size_t gb_len, min_size;

	if (IS_ERR(resp)) {
		rc = PTR_ERR(resp);
		resp = NULL;
		goto exit;
	}

	if (!resp->len) {
		rc = -EIO;
		goto exit;
	}

	if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
		min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;

		ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_106A;
		ddev->skb_add_crc = digital_skb_add_crc_a;
		ddev->skb_check_crc = digital_skb_check_crc_a;
	} else {
		min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;

		ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_212F;
		ddev->skb_add_crc = digital_skb_add_crc_f;
		ddev->skb_check_crc = digital_skb_check_crc_f;
	}

	if (resp->len < min_size) {
		rc = -EIO;
		goto exit;
	}

	if (DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
		ddev->skb_add_crc = digital_skb_add_crc_none;
		ddev->skb_check_crc = digital_skb_check_crc_none;
	}

	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;
	}

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

	if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
	    atr_req->cmd != DIGITAL_CMD_ATR_REQ) {
		rc = -EINVAL;
		goto exit;
	}

	rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
				     NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
	if (rc)
		goto exit;

	rc = digital_tg_send_atr_res(ddev, atr_req);
	if (rc)
		goto exit;

	gb_len = resp->len - sizeof(struct digital_atr_req);
	rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
			      NFC_COMM_PASSIVE, atr_req->gb, gb_len);
	if (rc)
		goto exit;

	ddev->poll_tech_count = 0;

	rc = 0;
exit:
	if (rc)
		digital_poll_next_tech(ddev);

	dev_kfree_skb(resp);
}
Commit	Line	Data
7d0911c0 TE	1	/*
	2	* NFC Digital Protocol stack
	3	* Copyright (c) 2013, Intel Corporation.
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms and conditions of the GNU General Public License,
	7	* version 2, as published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	*/
	15
c5da0e4a SO	16	#define pr_fmt(fmt) "digital: %s: " fmt, __func__
c5da0e4a SO	17
7d0911c0 TE	18	#include "digital.h"
	19
	20	#define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4
	21	#define DIGITAL_NFC_DEP_FRAME_DIR_IN 0xD5
	22
	23	#define DIGITAL_NFC_DEP_NFCA_SOD_SB 0xF0
	24
	25	#define DIGITAL_CMD_ATR_REQ 0x00
	26	#define DIGITAL_CMD_ATR_RES 0x01
	27	#define DIGITAL_CMD_PSL_REQ 0x04
	28	#define DIGITAL_CMD_PSL_RES 0x05
	29	#define DIGITAL_CMD_DEP_REQ 0x06
	30	#define DIGITAL_CMD_DEP_RES 0x07
	31
	32	#define DIGITAL_ATR_REQ_MIN_SIZE 16
	33	#define DIGITAL_ATR_REQ_MAX_SIZE 64
	34
	35	#define DIGITAL_NFCID3_LEN ((u8)8)
	36	#define DIGITAL_LR_BITS_PAYLOAD_SIZE_254B 0x30
	37	#define DIGITAL_GB_BIT 0x02
	38
	39	#define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
	40
	41	#define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10
	42
	43	#define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
	44	((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)
	45	#define DIGITAL_NFC_DEP_MI_BIT_SET(pfb) ((pfb) & 0x10)
	46	#define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
	47	#define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & 0x04)
	48	#define DIGITAL_NFC_DEP_PFB_PNI(pfb) ((pfb) & 0x03)
	49
	50	#define DIGITAL_NFC_DEP_PFB_I_PDU 0x00
	51	#define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU 0x40
	52	#define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80
	53
	54	struct digital_atr_req {
	55	u8 dir;
	56	u8 cmd;
	57	u8 nfcid3[10];
	58	u8 did;
	59	u8 bs;
	60	u8 br;
	61	u8 pp;
	62	u8 gb[0];
	63	} __packed;
	64
	65	struct digital_atr_res {
	66	u8 dir;
	67	u8 cmd;
	68	u8 nfcid3[10];
	69	u8 did;
	70	u8 bs;
	71	u8 br;
	72	u8 to;
	73	u8 pp;
	74	u8 gb[0];
	75	} __packed;
	76
	77	struct digital_psl_req {
	78	u8 dir;
	79	u8 cmd;
	80	u8 did;
	81	u8 brs;
82	u8 fsl;
83	} __packed;
84
85	struct digital_psl_res {
86	u8 dir;
87	u8 cmd;
88	u8 did;
89	} __packed;
90
91	struct digital_dep_req_res {
92	u8 dir;
93	u8 cmd;
94	u8 pfb;
95	} __packed;
96
97	static void digital_in_recv_dep_res(struct nfc_digital_dev ddev, void arg,
98	struct sk_buff *resp);
99
100	static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,
101	struct sk_buff *skb)
102	{
103	skb_push(skb, sizeof(u8));
104
105	skb->data[0] = skb->len;
106
107	if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
108	*skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;
109	}
110
111	static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,
112	struct sk_buff *skb)
113	{
114	u8 size;
115
116	if (skb->len < 2)
117	return -EIO;
118
119	if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
120	skb_pull(skb, sizeof(u8));
121
122	size = skb->data[0];
123	if (size != skb->len)
124	return -EIO;
125
126	skb_pull(skb, sizeof(u8));
127
128	return 0;
129	}
130
131	static void digital_in_recv_atr_res(struct nfc_digital_dev ddev, void arg,
132	struct sk_buff *resp)
133	{
134	struct nfc_target *target = arg;
135	struct digital_atr_res *atr_res;
136	u8 gb_len;
137	int rc;
138
139	if (IS_ERR(resp)) {
140	rc = PTR_ERR(resp);
141	resp = NULL;
142	goto exit;
143	}
144
145	rc = ddev->skb_check_crc(resp);
146	if (rc) {
147	PROTOCOL_ERR("14.4.1.6");
148	goto exit;
149	}
150
151	rc = digital_skb_pull_dep_sod(ddev, resp);
152	if (rc) {
153	PROTOCOL_ERR("14.4.1.2");
154	goto exit;
155	}
156
157	if (resp->len < sizeof(struct digital_atr_res)) {
158	rc = -EIO;
159	goto exit;
160	}
161
162	gb_len = resp->len - sizeof(struct digital_atr_res);
163
164	atr_res = (struct digital_atr_res *)resp->data;
165
166	rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
167	if (rc)
168	goto exit;
169
170	rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
171	NFC_RF_INITIATOR);
172
173	ddev->curr_nfc_dep_pni = 0;
174
175	exit:
176	dev_kfree_skb(resp);
177
178	if (rc)
179	ddev->curr_protocol = 0;
180	}
181
182	int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
183	struct nfc_target target, __u8 comm_mode, __u8 gb,
184	size_t gb_len)
185	{
186	struct sk_buff *skb;
187	struct digital_atr_req *atr_req;
188	uint size;
189
190	size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;
191
192	if (size > DIGITAL_ATR_REQ_MAX_SIZE) {
193	PROTOCOL_ERR("14.6.1.1");
194	return -EINVAL;
195	}
196
197	skb = digital_skb_alloc(ddev, size);
198	if (!skb)
199	return -ENOMEM;
200
201	skb_put(skb, sizeof(struct digital_atr_req));
202
203	atr_req = (struct digital_atr_req *)skb->data;
204	memset(atr_req, 0, sizeof(struct digital_atr_req));
205
206	atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
207	atr_req->cmd = DIGITAL_CMD_ATR_REQ;
208	if (target->nfcid2_len)
209	memcpy(atr_req->nfcid3, target->nfcid2,
210	max(target->nfcid2_len, DIGITAL_NFCID3_LEN));
211	else
212	get_random_bytes(atr_req->nfcid3, DIGITAL_NFCID3_LEN);
213
214	atr_req->did = 0;
215	atr_req->bs = 0;
216	atr_req->br = 0;
217
218	atr_req->pp = DIGITAL_LR_BITS_PAYLOAD_SIZE_254B;
219
220	if (gb_len) {
221	atr_req->pp \|= DIGITAL_GB_BIT;
222	memcpy(skb_put(skb, gb_len), gb, gb_len);
223	}
224
225	digital_skb_push_dep_sod(ddev, skb);
226
227	ddev->skb_add_crc(skb);
228
229	digital_in_send_cmd(ddev, skb, 500, digital_in_recv_atr_res, target);
230
231	return 0;
232	}
233
234	static int digital_in_send_rtox(struct nfc_digital_dev *ddev,
235	struct digital_data_exch *data_exch, u8 rtox)
236	{
237	struct digital_dep_req_res *dep_req;
238	struct sk_buff *skb;
239	int rc;
240
241	skb = digital_skb_alloc(ddev, 1);
242	if (!skb)
243	return -ENOMEM;
244
245	*skb_put(skb, 1) = rtox;
246
247	skb_push(skb, sizeof(struct digital_dep_req_res));
248
249	dep_req = (struct digital_dep_req_res *)skb->data;
250
251	dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
252	dep_req->cmd = DIGITAL_CMD_DEP_REQ;
253	dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU \|
254	DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT;
255
256	digital_skb_push_dep_sod(ddev, skb);
257
258	ddev->skb_add_crc(skb);
259
260	rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
261	data_exch);
262
263	return rc;
264	}
265
266	static void digital_in_recv_dep_res(struct nfc_digital_dev ddev, void arg,
267	struct sk_buff *resp)
268	{
269	struct digital_data_exch *data_exch = arg;
270	struct digital_dep_req_res *dep_res;
271	u8 pfb;
272	uint size;
273	int rc;
274
275	if (IS_ERR(resp)) {
276	rc = PTR_ERR(resp);
277	resp = NULL;
278	goto exit;
279	}
280
281	rc = ddev->skb_check_crc(resp);
282	if (rc) {
283	PROTOCOL_ERR("14.4.1.6");
284	goto error;
285	}
286
287	rc = digital_skb_pull_dep_sod(ddev, resp);
288	if (rc) {
289	PROTOCOL_ERR("14.4.1.2");
290	goto exit;
291	}
292
293	dep_res = (struct digital_dep_req_res *)resp->data;
294
295	if (resp->len < sizeof(struct digital_dep_req_res) \|\|
296	dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN \|\|
297	dep_res->cmd != DIGITAL_CMD_DEP_RES) {
298	rc = -EIO;
299	goto error;
300	}
301
302	pfb = dep_res->pfb;
303
304	switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
305	case DIGITAL_NFC_DEP_PFB_I_PDU:
306	if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
307	PROTOCOL_ERR("14.12.3.3");
308	rc = -EIO;
309	goto error;
310	}
311
312	ddev->curr_nfc_dep_pni =
313	DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
314	rc = 0;
315	break;
316
317	case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
c5da0e4a	318	pr_err("Received a ACK/NACK PDU");
7d0911c0 TE	319	rc = -EIO;
	320	goto error;
	321
	322	case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
	323	if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
	324	rc = -EINVAL;
	325	goto error;
	326	}
	327
	328	rc = digital_in_send_rtox(ddev, data_exch, resp->data[3]);
	329	if (rc)
	330	goto error;
	331
	332	kfree_skb(resp);
	333	return;
	334	}
	335
	336	if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {
c5da0e4a	337	pr_err("MI bit set. Chained PDU not supported.");
7d0911c0 TE	338	rc = -EIO;
	339	goto error;
	340	}
	341
	342	size = sizeof(struct digital_dep_req_res);
	343
	344	if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb))
	345	size++;
	346
	347	if (size > resp->len) {
	348	rc = -EIO;
	349	goto error;
	350	}
	351
	352	skb_pull(resp, size);
	353
	354	exit:
	355	data_exch->cb(data_exch->cb_context, resp, rc);
	356
	357	error:
	358	kfree(data_exch);
	359
	360	if (rc)
	361	kfree_skb(resp);
	362	}
	363
	364	int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
	365	struct nfc_target target, struct sk_buff skb,
	366	struct digital_data_exch *data_exch)
	367	{
	368	struct digital_dep_req_res *dep_req;
	369
	370	skb_push(skb, sizeof(struct digital_dep_req_res));
	371
	372	dep_req = (struct digital_dep_req_res *)skb->data;
	373	dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
	374	dep_req->cmd = DIGITAL_CMD_DEP_REQ;
	375	dep_req->pfb = ddev->curr_nfc_dep_pni;
	376
	377	digital_skb_push_dep_sod(ddev, skb);
	378
	379	ddev->skb_add_crc(skb);
	380
	381	return digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
	382	data_exch);
	383	}
1c7a4c24 TE	384
	385	static void digital_tg_recv_dep_req(struct nfc_digital_dev ddev, void arg,
	386	struct sk_buff *resp)
	387	{
	388	int rc;
	389	struct digital_dep_req_res *dep_req;
	390	size_t size;
	391
	392	if (IS_ERR(resp)) {
	393	rc = PTR_ERR(resp);
	394	resp = NULL;
	395	goto exit;
	396	}
	397
	398	rc = ddev->skb_check_crc(resp);
	399	if (rc) {
	400	PROTOCOL_ERR("14.4.1.6");
	401	goto exit;
	402	}
	403
	404	rc = digital_skb_pull_dep_sod(ddev, resp);
	405	if (rc) {
	406	PROTOCOL_ERR("14.4.1.2");
	407	goto exit;
	408	}
	409
	410	size = sizeof(struct digital_dep_req_res);
	411	dep_req = (struct digital_dep_req_res *)resp->data;
	412
	413	if (resp->len < size \|\| dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT \|\|
	414	dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
	415	rc = -EIO;
	416	goto exit;
	417	}
	418
	419	if (DIGITAL_NFC_DEP_DID_BIT_SET(dep_req->pfb))
	420	size++;
	421
	422	if (resp->len < size) {
	423	rc = -EIO;
	424	goto exit;
	425	}
	426
	427	switch (DIGITAL_NFC_DEP_PFB_TYPE(dep_req->pfb)) {
	428	case DIGITAL_NFC_DEP_PFB_I_PDU:
c5da0e4a	429	pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU");
1c7a4c24 TE	430	ddev->curr_nfc_dep_pni = DIGITAL_NFC_DEP_PFB_PNI(dep_req->pfb);
	431	break;
	432	case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
c5da0e4a	433	pr_err("Received a ACK/NACK PDU");
1c7a4c24 TE	434	rc = -EINVAL;
	435	goto exit;
	436	break;
	437	case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
c5da0e4a	438	pr_err("Received a SUPERVISOR PDU");
1c7a4c24 TE	439	rc = -EINVAL;
	440	goto exit;
	441	break;
	442	}
	443
	444	skb_pull(resp, size);
	445
	446	rc = nfc_tm_data_received(ddev->nfc_dev, resp);
	447
	448	exit:
	449	if (rc)
	450	kfree_skb(resp);
	451	}
	452
	453	int digital_tg_send_dep_res(struct nfc_digital_dev ddev, struct sk_buff skb)
	454	{
	455	struct digital_dep_req_res *dep_res;
	456
	457	skb_push(skb, sizeof(struct digital_dep_req_res));
	458	dep_res = (struct digital_dep_req_res *)skb->data;
	459
	460	dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
	461	dep_res->cmd = DIGITAL_CMD_DEP_RES;
	462	dep_res->pfb = ddev->curr_nfc_dep_pni;
	463
	464	digital_skb_push_dep_sod(ddev, skb);
	465
	466	ddev->skb_add_crc(skb);
	467
	468	return digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
	469	NULL);
	470	}
	471
	472	static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
	473	void arg, struct sk_buff resp)
	474	{
	475	u8 rf_tech = PTR_ERR(arg);
	476
	477	if (IS_ERR(resp))
	478	return;
	479
	480	digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
	481
	482	digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
	483
	484	dev_kfree_skb(resp);
	485	}
	486
	487	static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
	488	u8 rf_tech)
	489	{
	490	struct digital_psl_res *psl_res;
	491	struct sk_buff *skb;
	492	int rc;
	493
	494	skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
	495	if (!skb)
	496	return -ENOMEM;
	497
	498	skb_put(skb, sizeof(struct digital_psl_res));
	499
	500	psl_res = (struct digital_psl_res *)skb->data;
	501
	502	psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
503	psl_res->cmd = DIGITAL_CMD_PSL_RES;
504	psl_res->did = did;
505
506	digital_skb_push_dep_sod(ddev, skb);
507
508	ddev->skb_add_crc(skb);
509
510	rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
511	ERR_PTR(rf_tech));
512
513	if (rc)
514	kfree_skb(skb);
515
516	return rc;
517	}
518
519	static void digital_tg_recv_psl_req(struct nfc_digital_dev ddev, void arg,
520	struct sk_buff *resp)
521	{
522	int rc;
523	struct digital_psl_req *psl_req;
524	u8 rf_tech;
525	u8 dsi;
526
527	if (IS_ERR(resp)) {
528	rc = PTR_ERR(resp);
529	resp = NULL;
530	goto exit;
531	}
532
533	rc = ddev->skb_check_crc(resp);
534	if (rc) {
535	PROTOCOL_ERR("14.4.1.6");
536	goto exit;
537	}
538
539	rc = digital_skb_pull_dep_sod(ddev, resp);
540	if (rc) {
541	PROTOCOL_ERR("14.4.1.2");
542	goto exit;
543	}
544
545	psl_req = (struct digital_psl_req *)resp->data;
546
547	if (resp->len != sizeof(struct digital_psl_req) \|\|
548	psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT \|\|
549	psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
550	rc = -EIO;
551	goto exit;
552	}
553
554	dsi = (psl_req->brs >> 3) & 0x07;
555	switch (dsi) {
556	case 0:
557	rf_tech = NFC_DIGITAL_RF_TECH_106A;
558	break;
559	case 1:
560	rf_tech = NFC_DIGITAL_RF_TECH_212F;
561	break;
562	case 2:
563	rf_tech = NFC_DIGITAL_RF_TECH_424F;
564	break;
565	default:
c5da0e4a	566	pr_err("Unsuported dsi value %d", dsi);
1c7a4c24 TE	567	goto exit;
	568	}
	569
	570	rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
	571
	572	exit:
	573	kfree_skb(resp);
	574	}
	575
	576	static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
	577	void arg, struct sk_buff resp)
	578	{
	579	int offset;
	580
	581	if (IS_ERR(resp)) {
	582	digital_poll_next_tech(ddev);
	583	return;
	584	}
	585
	586	offset = 2;
	587	if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
	588	offset++;
	589
	590	if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
	591	digital_tg_recv_psl_req(ddev, arg, resp);
	592	else
	593	digital_tg_recv_dep_req(ddev, arg, resp);
	594	}
	595
	596	static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
	597	struct digital_atr_req *atr_req)
	598	{
	599	struct digital_atr_res *atr_res;
	600	struct sk_buff *skb;
	601	u8 *gb;
	602	size_t gb_len;
	603	int rc;
	604
	605	gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
	606	if (!gb)
	607	gb_len = 0;
	608
	609	skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
	610	if (!skb)
	611	return -ENOMEM;
	612
	613	skb_put(skb, sizeof(struct digital_atr_res));
	614	atr_res = (struct digital_atr_res *)skb->data;
	615
	616	memset(atr_res, 0, sizeof(struct digital_atr_res));
	617
	618	atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
	619	atr_res->cmd = DIGITAL_CMD_ATR_RES;
	620	memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
	621	atr_res->to = 8;
	622	atr_res->pp = DIGITAL_LR_BITS_PAYLOAD_SIZE_254B;
	623	if (gb_len) {
	624	skb_put(skb, gb_len);
	625
	626	atr_res->pp \|= DIGITAL_GB_BIT;
	627	memcpy(atr_res->gb, gb, gb_len);
	628	}
	629
	630	digital_skb_push_dep_sod(ddev, skb);
631
632	ddev->skb_add_crc(skb);
633
634	rc = digital_tg_send_cmd(ddev, skb, 999,
635	digital_tg_send_atr_res_complete, NULL);
636	if (rc) {
637	kfree_skb(skb);
638	return rc;
639	}
640
641	return rc;
642	}
643
644	void digital_tg_recv_atr_req(struct nfc_digital_dev ddev, void arg,
645	struct sk_buff *resp)
646	{
647	int rc;
648	struct digital_atr_req *atr_req;
649	size_t gb_len, min_size;
650
651	if (IS_ERR(resp)) {
652	rc = PTR_ERR(resp);
653	resp = NULL;
654	goto exit;
655	}
656
657	if (!resp->len) {
658	rc = -EIO;
659	goto exit;
660	}
661
662	if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
663	min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
664
665	ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_106A;
666	ddev->skb_add_crc = digital_skb_add_crc_a;
667	ddev->skb_check_crc = digital_skb_check_crc_a;
668	} else {
669	min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
670
671	ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_212F;
672	ddev->skb_add_crc = digital_skb_add_crc_f;
673	ddev->skb_check_crc = digital_skb_check_crc_f;
674	}
675
676	if (resp->len < min_size) {
677	rc = -EIO;
678	goto exit;
679	}
680
681	if (DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
682	ddev->skb_add_crc = digital_skb_add_crc_none;
683	ddev->skb_check_crc = digital_skb_check_crc_none;
684	}
685
686	rc = ddev->skb_check_crc(resp);
687	if (rc) {
688	PROTOCOL_ERR("14.4.1.6");
689	goto exit;
690	}
691
692	rc = digital_skb_pull_dep_sod(ddev, resp);
693	if (rc) {
694	PROTOCOL_ERR("14.4.1.2");
695	goto exit;
696	}
697
698	atr_req = (struct digital_atr_req *)resp->data;
699
700	if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT \|\|
701	atr_req->cmd != DIGITAL_CMD_ATR_REQ) {
702	rc = -EINVAL;
703	goto exit;
704	}
705
706	rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
707	NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
708	if (rc)
709	goto exit;
710
711	rc = digital_tg_send_atr_res(ddev, atr_req);
712	if (rc)
713	goto exit;
714
715	gb_len = resp->len - sizeof(struct digital_atr_req);
716	rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
717	NFC_COMM_PASSIVE, atr_req->gb, gb_len);
718	if (rc)
719	goto exit;
720
721	ddev->poll_tech_count = 0;
722
723	rc = 0;
724	exit:
725	if (rc)
726	digital_poll_next_tech(ddev);
727
728	dev_kfree_skb(resp);
729	}