NFC: Digital Protocol stack implementation
This is the initial commit of the NFC Digital Protocol stack
implementation.
It offers an interface for devices that don't have an embedded NFC
Digital protocol stack. The driver instantiates the digital stack by
calling nfc_digital_allocate_device(). Within the nfc_digital_ops
structure, the driver specifies a set of function pointers for driver
operations. These functions must be implemented by the driver and are:
in_configure_hw:
Hardware configuration for RF technology and communication framing in
initiator mode. This is a synchronous function.
in_send_cmd:
Initiator mode data exchange using RF technology and framing previously
set with in_configure_hw. The peer response is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_configure_hw:
Hardware configuration for RF technology and communication framing in
target mode. This is a synchronous function.
tg_send_cmd:
Target mode data exchange using RF technology and framing previously
set with tg_configure_hw. The peer next command is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_listen:
Put the device in listen mode waiting for data from the peer device.
This is an asynchronous function.
tg_listen_mdaa:
If supported, put the device in automatic listen mode with mode
detection and automatic anti-collision. In this mode, the device
automatically detects the RF technology and executes the
anti-collision detection using the command responses specified in
mdaa_params. The mdaa_params structure contains SENS_RES, NFCID1, and
SEL_RES for 106A RF tech. NFCID2 and system code (sc) for 212F and
424F. The driver returns the NFC-DEP ATR_REQ command through cb. The
digital stack deducts the RF tech by analyzing the SoD of the frame
containing the ATR_REQ command. This is an asynchronous function.
switch_rf:
Turns device radio on or off. The stack does not call explicitly
switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
the device radio on.
abort_cmd:
Discard the last sent command.
Then the driver registers itself against the digital stack by using
nfc_digital_register_device() which in turn registers the digital stack
against the NFC core layer. The digital stack implements common NFC
operations like dev_up(), dev_down(), start_poll(), stop_poll(), etc.
This patch is only a skeleton and NFC operations are just stubs.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:25 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __NFC_DIGITAL_H
|
|
|
|
#define __NFC_DIGITAL_H
|
|
|
|
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <net/nfc/nfc.h>
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Configuration types for in_configure_hw and tg_configure_hw.
|
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
NFC_DIGITAL_CONFIG_RF_TECH = 0,
|
|
|
|
NFC_DIGITAL_CONFIG_FRAMING,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* RF technology values passed as param argument to in_configure_hw and
|
|
|
|
* tg_configure_hw for NFC_DIGITAL_CONFIG_RF_TECH configuration type.
|
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
NFC_DIGITAL_RF_TECH_106A = 0,
|
|
|
|
NFC_DIGITAL_RF_TECH_212F,
|
|
|
|
NFC_DIGITAL_RF_TECH_424F,
|
2014-01-15 07:52:09 +07:00
|
|
|
NFC_DIGITAL_RF_TECH_ISO15693,
|
2014-04-01 07:36:37 +07:00
|
|
|
NFC_DIGITAL_RF_TECH_106B,
|
NFC: Digital Protocol stack implementation
This is the initial commit of the NFC Digital Protocol stack
implementation.
It offers an interface for devices that don't have an embedded NFC
Digital protocol stack. The driver instantiates the digital stack by
calling nfc_digital_allocate_device(). Within the nfc_digital_ops
structure, the driver specifies a set of function pointers for driver
operations. These functions must be implemented by the driver and are:
in_configure_hw:
Hardware configuration for RF technology and communication framing in
initiator mode. This is a synchronous function.
in_send_cmd:
Initiator mode data exchange using RF technology and framing previously
set with in_configure_hw. The peer response is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_configure_hw:
Hardware configuration for RF technology and communication framing in
target mode. This is a synchronous function.
tg_send_cmd:
Target mode data exchange using RF technology and framing previously
set with tg_configure_hw. The peer next command is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_listen:
Put the device in listen mode waiting for data from the peer device.
This is an asynchronous function.
tg_listen_mdaa:
If supported, put the device in automatic listen mode with mode
detection and automatic anti-collision. In this mode, the device
automatically detects the RF technology and executes the
anti-collision detection using the command responses specified in
mdaa_params. The mdaa_params structure contains SENS_RES, NFCID1, and
SEL_RES for 106A RF tech. NFCID2 and system code (sc) for 212F and
424F. The driver returns the NFC-DEP ATR_REQ command through cb. The
digital stack deducts the RF tech by analyzing the SoD of the frame
containing the ATR_REQ command. This is an asynchronous function.
switch_rf:
Turns device radio on or off. The stack does not call explicitly
switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
the device radio on.
abort_cmd:
Discard the last sent command.
Then the driver registers itself against the digital stack by using
nfc_digital_register_device() which in turn registers the digital stack
against the NFC core layer. The digital stack implements common NFC
operations like dev_up(), dev_down(), start_poll(), stop_poll(), etc.
This patch is only a skeleton and NFC operations are just stubs.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:25 +07:00
|
|
|
|
|
|
|
NFC_DIGITAL_RF_TECH_LAST,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Framing configuration passed as param argument to in_configure_hw and
|
|
|
|
* tg_configure_hw for NFC_DIGITAL_CONFIG_FRAMING configuration type.
|
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
NFC_DIGITAL_FRAMING_NFCA_SHORT = 0,
|
|
|
|
NFC_DIGITAL_FRAMING_NFCA_STANDARD,
|
|
|
|
NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A,
|
2014-07-03 00:16:15 +07:00
|
|
|
NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE,
|
NFC: Digital Protocol stack implementation
This is the initial commit of the NFC Digital Protocol stack
implementation.
It offers an interface for devices that don't have an embedded NFC
Digital protocol stack. The driver instantiates the digital stack by
calling nfc_digital_allocate_device(). Within the nfc_digital_ops
structure, the driver specifies a set of function pointers for driver
operations. These functions must be implemented by the driver and are:
in_configure_hw:
Hardware configuration for RF technology and communication framing in
initiator mode. This is a synchronous function.
in_send_cmd:
Initiator mode data exchange using RF technology and framing previously
set with in_configure_hw. The peer response is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_configure_hw:
Hardware configuration for RF technology and communication framing in
target mode. This is a synchronous function.
tg_send_cmd:
Target mode data exchange using RF technology and framing previously
set with tg_configure_hw. The peer next command is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_listen:
Put the device in listen mode waiting for data from the peer device.
This is an asynchronous function.
tg_listen_mdaa:
If supported, put the device in automatic listen mode with mode
detection and automatic anti-collision. In this mode, the device
automatically detects the RF technology and executes the
anti-collision detection using the command responses specified in
mdaa_params. The mdaa_params structure contains SENS_RES, NFCID1, and
SEL_RES for 106A RF tech. NFCID2 and system code (sc) for 212F and
424F. The driver returns the NFC-DEP ATR_REQ command through cb. The
digital stack deducts the RF tech by analyzing the SoD of the frame
containing the ATR_REQ command. This is an asynchronous function.
switch_rf:
Turns device radio on or off. The stack does not call explicitly
switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
the device radio on.
abort_cmd:
Discard the last sent command.
Then the driver registers itself against the digital stack by using
nfc_digital_register_device() which in turn registers the digital stack
against the NFC core layer. The digital stack implements common NFC
operations like dev_up(), dev_down(), start_poll(), stop_poll(), etc.
This patch is only a skeleton and NFC operations are just stubs.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:25 +07:00
|
|
|
|
|
|
|
NFC_DIGITAL_FRAMING_NFCA_T1T,
|
|
|
|
NFC_DIGITAL_FRAMING_NFCA_T2T,
|
2014-01-27 06:31:31 +07:00
|
|
|
NFC_DIGITAL_FRAMING_NFCA_T4T,
|
NFC: Digital Protocol stack implementation
This is the initial commit of the NFC Digital Protocol stack
implementation.
It offers an interface for devices that don't have an embedded NFC
Digital protocol stack. The driver instantiates the digital stack by
calling nfc_digital_allocate_device(). Within the nfc_digital_ops
structure, the driver specifies a set of function pointers for driver
operations. These functions must be implemented by the driver and are:
in_configure_hw:
Hardware configuration for RF technology and communication framing in
initiator mode. This is a synchronous function.
in_send_cmd:
Initiator mode data exchange using RF technology and framing previously
set with in_configure_hw. The peer response is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_configure_hw:
Hardware configuration for RF technology and communication framing in
target mode. This is a synchronous function.
tg_send_cmd:
Target mode data exchange using RF technology and framing previously
set with tg_configure_hw. The peer next command is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_listen:
Put the device in listen mode waiting for data from the peer device.
This is an asynchronous function.
tg_listen_mdaa:
If supported, put the device in automatic listen mode with mode
detection and automatic anti-collision. In this mode, the device
automatically detects the RF technology and executes the
anti-collision detection using the command responses specified in
mdaa_params. The mdaa_params structure contains SENS_RES, NFCID1, and
SEL_RES for 106A RF tech. NFCID2 and system code (sc) for 212F and
424F. The driver returns the NFC-DEP ATR_REQ command through cb. The
digital stack deducts the RF tech by analyzing the SoD of the frame
containing the ATR_REQ command. This is an asynchronous function.
switch_rf:
Turns device radio on or off. The stack does not call explicitly
switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
the device radio on.
abort_cmd:
Discard the last sent command.
Then the driver registers itself against the digital stack by using
nfc_digital_register_device() which in turn registers the digital stack
against the NFC core layer. The digital stack implements common NFC
operations like dev_up(), dev_down(), start_poll(), stop_poll(), etc.
This patch is only a skeleton and NFC operations are just stubs.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:25 +07:00
|
|
|
NFC_DIGITAL_FRAMING_NFCA_NFC_DEP,
|
|
|
|
|
|
|
|
NFC_DIGITAL_FRAMING_NFCF,
|
|
|
|
NFC_DIGITAL_FRAMING_NFCF_T3T,
|
|
|
|
NFC_DIGITAL_FRAMING_NFCF_NFC_DEP,
|
|
|
|
NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED,
|
|
|
|
|
2014-01-15 07:52:09 +07:00
|
|
|
NFC_DIGITAL_FRAMING_ISO15693_INVENTORY,
|
2014-03-06 21:39:19 +07:00
|
|
|
NFC_DIGITAL_FRAMING_ISO15693_T5T,
|
2014-01-15 07:52:09 +07:00
|
|
|
|
2014-04-01 07:36:37 +07:00
|
|
|
NFC_DIGITAL_FRAMING_NFCB,
|
|
|
|
NFC_DIGITAL_FRAMING_NFCB_T4T,
|
|
|
|
|
NFC: Digital Protocol stack implementation
This is the initial commit of the NFC Digital Protocol stack
implementation.
It offers an interface for devices that don't have an embedded NFC
Digital protocol stack. The driver instantiates the digital stack by
calling nfc_digital_allocate_device(). Within the nfc_digital_ops
structure, the driver specifies a set of function pointers for driver
operations. These functions must be implemented by the driver and are:
in_configure_hw:
Hardware configuration for RF technology and communication framing in
initiator mode. This is a synchronous function.
in_send_cmd:
Initiator mode data exchange using RF technology and framing previously
set with in_configure_hw. The peer response is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_configure_hw:
Hardware configuration for RF technology and communication framing in
target mode. This is a synchronous function.
tg_send_cmd:
Target mode data exchange using RF technology and framing previously
set with tg_configure_hw. The peer next command is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_listen:
Put the device in listen mode waiting for data from the peer device.
This is an asynchronous function.
tg_listen_mdaa:
If supported, put the device in automatic listen mode with mode
detection and automatic anti-collision. In this mode, the device
automatically detects the RF technology and executes the
anti-collision detection using the command responses specified in
mdaa_params. The mdaa_params structure contains SENS_RES, NFCID1, and
SEL_RES for 106A RF tech. NFCID2 and system code (sc) for 212F and
424F. The driver returns the NFC-DEP ATR_REQ command through cb. The
digital stack deducts the RF tech by analyzing the SoD of the frame
containing the ATR_REQ command. This is an asynchronous function.
switch_rf:
Turns device radio on or off. The stack does not call explicitly
switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
the device radio on.
abort_cmd:
Discard the last sent command.
Then the driver registers itself against the digital stack by using
nfc_digital_register_device() which in turn registers the digital stack
against the NFC core layer. The digital stack implements common NFC
operations like dev_up(), dev_down(), start_poll(), stop_poll(), etc.
This patch is only a skeleton and NFC operations are just stubs.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:25 +07:00
|
|
|
NFC_DIGITAL_FRAMING_LAST,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define DIGITAL_MDAA_NFCID1_SIZE 3
|
|
|
|
|
|
|
|
struct digital_tg_mdaa_params {
|
|
|
|
u16 sens_res;
|
|
|
|
u8 nfcid1[DIGITAL_MDAA_NFCID1_SIZE];
|
|
|
|
u8 sel_res;
|
|
|
|
|
|
|
|
u8 nfcid2[NFC_NFCID2_MAXSIZE];
|
|
|
|
u16 sc;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct nfc_digital_dev;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nfc_digital_cmd_complete_t - Definition of command result callback
|
|
|
|
*
|
|
|
|
* @ddev: nfc_digital_device ref
|
|
|
|
* @arg: user data
|
|
|
|
* @resp: response data
|
|
|
|
*
|
|
|
|
* resp pointer can be an error code and will be checked with IS_ERR() macro.
|
|
|
|
* The callback is responsible for freeing resp sk_buff.
|
|
|
|
*/
|
|
|
|
typedef void (*nfc_digital_cmd_complete_t)(struct nfc_digital_dev *ddev,
|
|
|
|
void *arg, struct sk_buff *resp);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Device side NFC Digital operations
|
|
|
|
*
|
|
|
|
* Initiator mode:
|
|
|
|
* @in_configure_hw: Hardware configuration for RF technology and communication
|
|
|
|
* framing in initiator mode. This is a synchronous function.
|
|
|
|
* @in_send_cmd: Initiator mode data exchange using RF technology and framing
|
|
|
|
* previously set with in_configure_hw. The peer response is returned
|
|
|
|
* through callback cb. If an io error occurs or the peer didn't reply
|
|
|
|
* within the specified timeout (ms), the error code is passed back through
|
|
|
|
* the resp pointer. This is an asynchronous function.
|
|
|
|
*
|
|
|
|
* Target mode: Only NFC-DEP protocol is supported in target mode.
|
|
|
|
* @tg_configure_hw: Hardware configuration for RF technology and communication
|
|
|
|
* framing in target mode. This is a synchronous function.
|
|
|
|
* @tg_send_cmd: Target mode data exchange using RF technology and framing
|
|
|
|
* previously set with tg_configure_hw. The peer next command is returned
|
|
|
|
* through callback cb. If an io error occurs or the peer didn't reply
|
|
|
|
* within the specified timeout (ms), the error code is passed back through
|
|
|
|
* the resp pointer. This is an asynchronous function.
|
|
|
|
* @tg_listen: Put the device in listen mode waiting for data from the peer
|
|
|
|
* device. This is an asynchronous function.
|
|
|
|
* @tg_listen_mdaa: If supported, put the device in automatic listen mode with
|
|
|
|
* mode detection and automatic anti-collision. In this mode, the device
|
|
|
|
* automatically detects the RF technology and executes the anti-collision
|
|
|
|
* detection using the command responses specified in mdaa_params. The
|
|
|
|
* mdaa_params structure contains SENS_RES, NFCID1, and SEL_RES for 106A RF
|
|
|
|
* tech. NFCID2 and system code (sc) for 212F and 424F. The driver returns
|
|
|
|
* the NFC-DEP ATR_REQ command through cb. The digital stack deducts the RF
|
|
|
|
* tech by analyzing the SoD of the frame containing the ATR_REQ command.
|
|
|
|
* This is an asynchronous function.
|
2014-07-22 11:24:39 +07:00
|
|
|
* @tg_listen_md: If supported, put the device in automatic listen mode with
|
|
|
|
* mode detection but without automatic anti-collision. In this mode, the
|
|
|
|
* device automatically detects the RF technology. What the actual
|
|
|
|
* RF technology is can be retrieved by calling @tg_get_rf_tech.
|
|
|
|
* The digital stack will then perform the appropriate anti-collision
|
|
|
|
* sequence. This is an asynchronous function.
|
|
|
|
* @tg_get_rf_tech: Required when @tg_listen_md is supported, unused otherwise.
|
|
|
|
* Return the RF Technology that was detected by the @tg_listen_md call.
|
|
|
|
* This is a synchronous function.
|
NFC: Digital Protocol stack implementation
This is the initial commit of the NFC Digital Protocol stack
implementation.
It offers an interface for devices that don't have an embedded NFC
Digital protocol stack. The driver instantiates the digital stack by
calling nfc_digital_allocate_device(). Within the nfc_digital_ops
structure, the driver specifies a set of function pointers for driver
operations. These functions must be implemented by the driver and are:
in_configure_hw:
Hardware configuration for RF technology and communication framing in
initiator mode. This is a synchronous function.
in_send_cmd:
Initiator mode data exchange using RF technology and framing previously
set with in_configure_hw. The peer response is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_configure_hw:
Hardware configuration for RF technology and communication framing in
target mode. This is a synchronous function.
tg_send_cmd:
Target mode data exchange using RF technology and framing previously
set with tg_configure_hw. The peer next command is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_listen:
Put the device in listen mode waiting for data from the peer device.
This is an asynchronous function.
tg_listen_mdaa:
If supported, put the device in automatic listen mode with mode
detection and automatic anti-collision. In this mode, the device
automatically detects the RF technology and executes the
anti-collision detection using the command responses specified in
mdaa_params. The mdaa_params structure contains SENS_RES, NFCID1, and
SEL_RES for 106A RF tech. NFCID2 and system code (sc) for 212F and
424F. The driver returns the NFC-DEP ATR_REQ command through cb. The
digital stack deducts the RF tech by analyzing the SoD of the frame
containing the ATR_REQ command. This is an asynchronous function.
switch_rf:
Turns device radio on or off. The stack does not call explicitly
switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
the device radio on.
abort_cmd:
Discard the last sent command.
Then the driver registers itself against the digital stack by using
nfc_digital_register_device() which in turn registers the digital stack
against the NFC core layer. The digital stack implements common NFC
operations like dev_up(), dev_down(), start_poll(), stop_poll(), etc.
This patch is only a skeleton and NFC operations are just stubs.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:25 +07:00
|
|
|
*
|
|
|
|
* @switch_rf: Turns device radio on or off. The stack does not call explicitly
|
|
|
|
* switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
|
|
|
|
* the device radio on.
|
|
|
|
* @abort_cmd: Discard the last sent command.
|
2014-01-02 17:58:12 +07:00
|
|
|
*
|
|
|
|
* Notes: Asynchronous functions have a timeout parameter. It is the driver
|
|
|
|
* responsibility to call the digital stack back through the
|
|
|
|
* nfc_digital_cmd_complete_t callback when no RF respsonse has been
|
|
|
|
* received within the specified time (in milliseconds). In that case the
|
|
|
|
* driver must set the resp sk_buff to ERR_PTR(-ETIMEDOUT).
|
|
|
|
* Since the digital stack serializes commands to be sent, it's mandatory
|
|
|
|
* for the driver to handle the timeout correctly. Otherwise the stack
|
|
|
|
* would not be able to send new commands, waiting for the reply of the
|
|
|
|
* current one.
|
NFC: Digital Protocol stack implementation
This is the initial commit of the NFC Digital Protocol stack
implementation.
It offers an interface for devices that don't have an embedded NFC
Digital protocol stack. The driver instantiates the digital stack by
calling nfc_digital_allocate_device(). Within the nfc_digital_ops
structure, the driver specifies a set of function pointers for driver
operations. These functions must be implemented by the driver and are:
in_configure_hw:
Hardware configuration for RF technology and communication framing in
initiator mode. This is a synchronous function.
in_send_cmd:
Initiator mode data exchange using RF technology and framing previously
set with in_configure_hw. The peer response is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_configure_hw:
Hardware configuration for RF technology and communication framing in
target mode. This is a synchronous function.
tg_send_cmd:
Target mode data exchange using RF technology and framing previously
set with tg_configure_hw. The peer next command is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_listen:
Put the device in listen mode waiting for data from the peer device.
This is an asynchronous function.
tg_listen_mdaa:
If supported, put the device in automatic listen mode with mode
detection and automatic anti-collision. In this mode, the device
automatically detects the RF technology and executes the
anti-collision detection using the command responses specified in
mdaa_params. The mdaa_params structure contains SENS_RES, NFCID1, and
SEL_RES for 106A RF tech. NFCID2 and system code (sc) for 212F and
424F. The driver returns the NFC-DEP ATR_REQ command through cb. The
digital stack deducts the RF tech by analyzing the SoD of the frame
containing the ATR_REQ command. This is an asynchronous function.
switch_rf:
Turns device radio on or off. The stack does not call explicitly
switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
the device radio on.
abort_cmd:
Discard the last sent command.
Then the driver registers itself against the digital stack by using
nfc_digital_register_device() which in turn registers the digital stack
against the NFC core layer. The digital stack implements common NFC
operations like dev_up(), dev_down(), start_poll(), stop_poll(), etc.
This patch is only a skeleton and NFC operations are just stubs.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:25 +07:00
|
|
|
*/
|
|
|
|
struct nfc_digital_ops {
|
|
|
|
int (*in_configure_hw)(struct nfc_digital_dev *ddev, int type,
|
|
|
|
int param);
|
|
|
|
int (*in_send_cmd)(struct nfc_digital_dev *ddev, struct sk_buff *skb,
|
|
|
|
u16 timeout, nfc_digital_cmd_complete_t cb,
|
|
|
|
void *arg);
|
|
|
|
|
|
|
|
int (*tg_configure_hw)(struct nfc_digital_dev *ddev, int type,
|
|
|
|
int param);
|
|
|
|
int (*tg_send_cmd)(struct nfc_digital_dev *ddev, struct sk_buff *skb,
|
|
|
|
u16 timeout, nfc_digital_cmd_complete_t cb,
|
|
|
|
void *arg);
|
|
|
|
int (*tg_listen)(struct nfc_digital_dev *ddev, u16 timeout,
|
|
|
|
nfc_digital_cmd_complete_t cb, void *arg);
|
|
|
|
int (*tg_listen_mdaa)(struct nfc_digital_dev *ddev,
|
|
|
|
struct digital_tg_mdaa_params *mdaa_params,
|
|
|
|
u16 timeout, nfc_digital_cmd_complete_t cb,
|
|
|
|
void *arg);
|
2014-07-22 11:24:39 +07:00
|
|
|
int (*tg_listen_md)(struct nfc_digital_dev *ddev, u16 timeout,
|
|
|
|
nfc_digital_cmd_complete_t cb, void *arg);
|
|
|
|
int (*tg_get_rf_tech)(struct nfc_digital_dev *ddev, u8 *rf_tech);
|
NFC: Digital Protocol stack implementation
This is the initial commit of the NFC Digital Protocol stack
implementation.
It offers an interface for devices that don't have an embedded NFC
Digital protocol stack. The driver instantiates the digital stack by
calling nfc_digital_allocate_device(). Within the nfc_digital_ops
structure, the driver specifies a set of function pointers for driver
operations. These functions must be implemented by the driver and are:
in_configure_hw:
Hardware configuration for RF technology and communication framing in
initiator mode. This is a synchronous function.
in_send_cmd:
Initiator mode data exchange using RF technology and framing previously
set with in_configure_hw. The peer response is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_configure_hw:
Hardware configuration for RF technology and communication framing in
target mode. This is a synchronous function.
tg_send_cmd:
Target mode data exchange using RF technology and framing previously
set with tg_configure_hw. The peer next command is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_listen:
Put the device in listen mode waiting for data from the peer device.
This is an asynchronous function.
tg_listen_mdaa:
If supported, put the device in automatic listen mode with mode
detection and automatic anti-collision. In this mode, the device
automatically detects the RF technology and executes the
anti-collision detection using the command responses specified in
mdaa_params. The mdaa_params structure contains SENS_RES, NFCID1, and
SEL_RES for 106A RF tech. NFCID2 and system code (sc) for 212F and
424F. The driver returns the NFC-DEP ATR_REQ command through cb. The
digital stack deducts the RF tech by analyzing the SoD of the frame
containing the ATR_REQ command. This is an asynchronous function.
switch_rf:
Turns device radio on or off. The stack does not call explicitly
switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
the device radio on.
abort_cmd:
Discard the last sent command.
Then the driver registers itself against the digital stack by using
nfc_digital_register_device() which in turn registers the digital stack
against the NFC core layer. The digital stack implements common NFC
operations like dev_up(), dev_down(), start_poll(), stop_poll(), etc.
This patch is only a skeleton and NFC operations are just stubs.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:25 +07:00
|
|
|
|
|
|
|
int (*switch_rf)(struct nfc_digital_dev *ddev, bool on);
|
|
|
|
void (*abort_cmd)(struct nfc_digital_dev *ddev);
|
|
|
|
};
|
|
|
|
|
2013-09-19 22:55:26 +07:00
|
|
|
#define NFC_DIGITAL_POLL_MODE_COUNT_MAX 6 /* 106A, 212F, and 424F in & tg */
|
|
|
|
|
|
|
|
typedef int (*digital_poll_t)(struct nfc_digital_dev *ddev, u8 rf_tech);
|
|
|
|
|
|
|
|
struct digital_poll_tech {
|
|
|
|
u8 rf_tech;
|
|
|
|
digital_poll_t poll_func;
|
|
|
|
};
|
|
|
|
|
NFC: Digital Protocol stack implementation
This is the initial commit of the NFC Digital Protocol stack
implementation.
It offers an interface for devices that don't have an embedded NFC
Digital protocol stack. The driver instantiates the digital stack by
calling nfc_digital_allocate_device(). Within the nfc_digital_ops
structure, the driver specifies a set of function pointers for driver
operations. These functions must be implemented by the driver and are:
in_configure_hw:
Hardware configuration for RF technology and communication framing in
initiator mode. This is a synchronous function.
in_send_cmd:
Initiator mode data exchange using RF technology and framing previously
set with in_configure_hw. The peer response is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_configure_hw:
Hardware configuration for RF technology and communication framing in
target mode. This is a synchronous function.
tg_send_cmd:
Target mode data exchange using RF technology and framing previously
set with tg_configure_hw. The peer next command is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_listen:
Put the device in listen mode waiting for data from the peer device.
This is an asynchronous function.
tg_listen_mdaa:
If supported, put the device in automatic listen mode with mode
detection and automatic anti-collision. In this mode, the device
automatically detects the RF technology and executes the
anti-collision detection using the command responses specified in
mdaa_params. The mdaa_params structure contains SENS_RES, NFCID1, and
SEL_RES for 106A RF tech. NFCID2 and system code (sc) for 212F and
424F. The driver returns the NFC-DEP ATR_REQ command through cb. The
digital stack deducts the RF tech by analyzing the SoD of the frame
containing the ATR_REQ command. This is an asynchronous function.
switch_rf:
Turns device radio on or off. The stack does not call explicitly
switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
the device radio on.
abort_cmd:
Discard the last sent command.
Then the driver registers itself against the digital stack by using
nfc_digital_register_device() which in turn registers the digital stack
against the NFC core layer. The digital stack implements common NFC
operations like dev_up(), dev_down(), start_poll(), stop_poll(), etc.
This patch is only a skeleton and NFC operations are just stubs.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:25 +07:00
|
|
|
/**
|
|
|
|
* Driver capabilities - bit mask made of the following values
|
|
|
|
*
|
|
|
|
* @NFC_DIGITAL_DRV_CAPS_IN_CRC: The driver handles CRC calculation in initiator
|
|
|
|
* mode.
|
|
|
|
* @NFC_DIGITAL_DRV_CAPS_TG_CRC: The driver handles CRC calculation in target
|
|
|
|
* mode.
|
|
|
|
*/
|
|
|
|
#define NFC_DIGITAL_DRV_CAPS_IN_CRC 0x0001
|
|
|
|
#define NFC_DIGITAL_DRV_CAPS_TG_CRC 0x0002
|
|
|
|
|
|
|
|
struct nfc_digital_dev {
|
|
|
|
struct nfc_dev *nfc_dev;
|
|
|
|
struct nfc_digital_ops *ops;
|
|
|
|
|
|
|
|
u32 protocols;
|
|
|
|
|
|
|
|
int tx_headroom;
|
|
|
|
int tx_tailroom;
|
|
|
|
|
|
|
|
u32 driver_capabilities;
|
|
|
|
void *driver_data;
|
2013-09-19 22:55:26 +07:00
|
|
|
|
|
|
|
struct digital_poll_tech poll_techs[NFC_DIGITAL_POLL_MODE_COUNT_MAX];
|
|
|
|
u8 poll_tech_count;
|
|
|
|
u8 poll_tech_index;
|
|
|
|
struct mutex poll_lock;
|
|
|
|
|
|
|
|
struct work_struct cmd_work;
|
|
|
|
struct work_struct cmd_complete_work;
|
|
|
|
struct list_head cmd_queue;
|
|
|
|
struct mutex cmd_lock;
|
|
|
|
|
|
|
|
struct work_struct poll_work;
|
|
|
|
|
|
|
|
u8 curr_protocol;
|
|
|
|
u8 curr_rf_tech;
|
|
|
|
u8 curr_nfc_dep_pni;
|
2014-09-24 06:38:05 +07:00
|
|
|
u8 did;
|
NFC Digital: Add NFC-A technology support
This adds support for NFC-A technology at 106 kbits/s. The stack can
detect tags of type 1 and 2. There is no support for collision
detection. Tags can be read and written by using a user space
application or a daemon like neard.
The flow of polling operations for NFC-A detection is as follow:
1 - The digital stack sends the SENS_REQ command to the NFC device.
2 - The NFC device receives a SENS_RES response from a peer device and
passes it to the digital stack.
3 - If the SENS_RES response identifies a type 1 tag, detection ends.
NFC core is notified through nfc_targets_found().
4 - Otherwise, the digital stack sets the cascade level of NFCID1 to
CL1 and sends the SDD_REQ command.
5 - The digital stack selects SEL_CMD and SEL_PAR according to the
cascade level and sends the SDD_REQ command.
4 - The digital stack receives a SDD_RES response for the cascade level
passed in the SDD_REQ command.
5 - The digital stack analyses (part of) NFCID1 and verify BCC.
6 - The digital stack sends the SEL_REQ command with the NFCID1
received in the SDD_RES.
6 - The peer device replies with a SEL_RES response
7 - Detection ends if NFCID1 is complete. NFC core notified of new
target by nfc_targets_found().
8 - If NFCID1 is not complete, the cascade level is incremented (up
to and including CL3) and the execution continues at step 5 to
get the remaining bytes of NFCID1.
Once target detection is done, type 1 and 2 tag commands must be
handled by a user space application (i.e neard) through the NFC core.
Responses for type 1 tag are returned directly to user space via NFC
core.
Responses of type 2 commands are handled differently. The digital stack
doesn't analyse the type of commands sent through im_transceive() and
must differentiate valid responses from error ones.
The response process flow is as follow:
1 - If the response length is 16 bytes, it is a valid response of a
READ command. the packet is returned to the NFC core through the
callback passed to im_transceive(). Processing stops.
2 - If the response is 1 byte long and is a ACK byte (0x0A), it is a
valid response of a WRITE command for example. First packet byte
is set to 0 for no-error and passed back to the NFC core.
Processing stops.
3 - Any other response is treated as an error and -EIO error code is
returned to the NFC core through the response callback.
Moreover, since the driver can't differentiate success response from a
NACK response, the digital stack has to handle CRC calculation.
Thus, this patch also adds support for CRC calculation. If the driver
doesn't handle it, the digital stack will calculate CRC and will add it
to sent frames. CRC will also be checked and removed from received
frames. Pointers to the correct CRC calculation functions are stored in
the digital stack device structure when a target is detected. This
avoids the need to check the current target type for every call to
im_transceive() and for every response received from a peer device.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:27 +07:00
|
|
|
|
2014-01-27 06:31:31 +07:00
|
|
|
u16 target_fsc;
|
|
|
|
|
NFC Digital: Add NFC-A technology support
This adds support for NFC-A technology at 106 kbits/s. The stack can
detect tags of type 1 and 2. There is no support for collision
detection. Tags can be read and written by using a user space
application or a daemon like neard.
The flow of polling operations for NFC-A detection is as follow:
1 - The digital stack sends the SENS_REQ command to the NFC device.
2 - The NFC device receives a SENS_RES response from a peer device and
passes it to the digital stack.
3 - If the SENS_RES response identifies a type 1 tag, detection ends.
NFC core is notified through nfc_targets_found().
4 - Otherwise, the digital stack sets the cascade level of NFCID1 to
CL1 and sends the SDD_REQ command.
5 - The digital stack selects SEL_CMD and SEL_PAR according to the
cascade level and sends the SDD_REQ command.
4 - The digital stack receives a SDD_RES response for the cascade level
passed in the SDD_REQ command.
5 - The digital stack analyses (part of) NFCID1 and verify BCC.
6 - The digital stack sends the SEL_REQ command with the NFCID1
received in the SDD_RES.
6 - The peer device replies with a SEL_RES response
7 - Detection ends if NFCID1 is complete. NFC core notified of new
target by nfc_targets_found().
8 - If NFCID1 is not complete, the cascade level is incremented (up
to and including CL3) and the execution continues at step 5 to
get the remaining bytes of NFCID1.
Once target detection is done, type 1 and 2 tag commands must be
handled by a user space application (i.e neard) through the NFC core.
Responses for type 1 tag are returned directly to user space via NFC
core.
Responses of type 2 commands are handled differently. The digital stack
doesn't analyse the type of commands sent through im_transceive() and
must differentiate valid responses from error ones.
The response process flow is as follow:
1 - If the response length is 16 bytes, it is a valid response of a
READ command. the packet is returned to the NFC core through the
callback passed to im_transceive(). Processing stops.
2 - If the response is 1 byte long and is a ACK byte (0x0A), it is a
valid response of a WRITE command for example. First packet byte
is set to 0 for no-error and passed back to the NFC core.
Processing stops.
3 - Any other response is treated as an error and -EIO error code is
returned to the NFC core through the response callback.
Moreover, since the driver can't differentiate success response from a
NACK response, the digital stack has to handle CRC calculation.
Thus, this patch also adds support for CRC calculation. If the driver
doesn't handle it, the digital stack will calculate CRC and will add it
to sent frames. CRC will also be checked and removed from received
frames. Pointers to the correct CRC calculation functions are stored in
the digital stack device structure when a target is detected. This
avoids the need to check the current target type for every call to
im_transceive() and for every response received from a peer device.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:27 +07:00
|
|
|
int (*skb_check_crc)(struct sk_buff *skb);
|
|
|
|
void (*skb_add_crc)(struct sk_buff *skb);
|
NFC: Digital Protocol stack implementation
This is the initial commit of the NFC Digital Protocol stack
implementation.
It offers an interface for devices that don't have an embedded NFC
Digital protocol stack. The driver instantiates the digital stack by
calling nfc_digital_allocate_device(). Within the nfc_digital_ops
structure, the driver specifies a set of function pointers for driver
operations. These functions must be implemented by the driver and are:
in_configure_hw:
Hardware configuration for RF technology and communication framing in
initiator mode. This is a synchronous function.
in_send_cmd:
Initiator mode data exchange using RF technology and framing previously
set with in_configure_hw. The peer response is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_configure_hw:
Hardware configuration for RF technology and communication framing in
target mode. This is a synchronous function.
tg_send_cmd:
Target mode data exchange using RF technology and framing previously
set with tg_configure_hw. The peer next command is returned through
callback cb. If an io error occurs or the peer didn't reply within the
specified timeout (ms), the error code is passed back through the resp
pointer. This is an asynchronous function.
tg_listen:
Put the device in listen mode waiting for data from the peer device.
This is an asynchronous function.
tg_listen_mdaa:
If supported, put the device in automatic listen mode with mode
detection and automatic anti-collision. In this mode, the device
automatically detects the RF technology and executes the
anti-collision detection using the command responses specified in
mdaa_params. The mdaa_params structure contains SENS_RES, NFCID1, and
SEL_RES for 106A RF tech. NFCID2 and system code (sc) for 212F and
424F. The driver returns the NFC-DEP ATR_REQ command through cb. The
digital stack deducts the RF tech by analyzing the SoD of the frame
containing the ATR_REQ command. This is an asynchronous function.
switch_rf:
Turns device radio on or off. The stack does not call explicitly
switch_rf to turn the radio on. A call to in|tg_configure_hw must turn
the device radio on.
abort_cmd:
Discard the last sent command.
Then the driver registers itself against the digital stack by using
nfc_digital_register_device() which in turn registers the digital stack
against the NFC core layer. The digital stack implements common NFC
operations like dev_up(), dev_down(), start_poll(), stop_poll(), etc.
This patch is only a skeleton and NFC operations are just stubs.
Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
2013-09-19 22:55:25 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct nfc_digital_dev *nfc_digital_allocate_device(struct nfc_digital_ops *ops,
|
|
|
|
__u32 supported_protocols,
|
|
|
|
__u32 driver_capabilities,
|
|
|
|
int tx_headroom,
|
|
|
|
int tx_tailroom);
|
|
|
|
void nfc_digital_free_device(struct nfc_digital_dev *ndev);
|
|
|
|
int nfc_digital_register_device(struct nfc_digital_dev *ndev);
|
|
|
|
void nfc_digital_unregister_device(struct nfc_digital_dev *ndev);
|
|
|
|
|
|
|
|
static inline void nfc_digital_set_parent_dev(struct nfc_digital_dev *ndev,
|
|
|
|
struct device *dev)
|
|
|
|
{
|
|
|
|
nfc_set_parent_dev(ndev->nfc_dev, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void nfc_digital_set_drvdata(struct nfc_digital_dev *dev,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
dev->driver_data = data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *nfc_digital_get_drvdata(struct nfc_digital_dev *dev)
|
|
|
|
{
|
|
|
|
return dev->driver_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* __NFC_DIGITAL_H */
|