Commit 68957303 authored by Christophe Ricard's avatar Christophe Ricard Committed by Samuel Ortiz

NFC: ST21NFCA: Add driver for STMicroelectronics ST21NFCA NFC Chip

Add driver for STMicroelectronics ST21NFCA NFC controller.
ST21NFCA is using HCI protocol, shdlc as LLC layer & I2C as
communication protocol.

Adding support for Reader/Writer mode with Tag type 1/2/3/4 A & B.
It is using proprietary gate 15 for ISO14443-3 such as type 1 &
type 2 tags. It is using proprietary gate 14 for type F tags.
ST21NFCA_DEVICE_MGNT_GATE gives access to proprietary CLF configuration.
Standard gate for ISO14443-4 A (13) & B (11) are also used.

ST21NFCA specific mecanism:

One particular point to notice for the data handling is that frame
does not contain any length value. Therefore the i2c part of this driver
is managing the reception with a read length sequence until the end of
frame (0x7e) is reached.

In order to avoid conflict between sof & eof a mecanism
called byte stuffing concist of an escape byte (0x7d) insertion before
special byte (0x7e, 0x7d). The special byte is then xored with 0x20.

In this driver, When data are available in the CLF, the interrupt
gpio is driven to active state and triggered an interrupt.
Once the i2c_master_recv start, the interrupt gpio is driven to idle
state until its complete. If the frame is incomplete or data are still
available, interrupts will be triggered again.
Signed-off-by: default avatarChristophe Ricard <[email protected]>
Signed-off-by: default avatarSamuel Ortiz <[email protected]>
parent 321d03c8
......@@ -71,5 +71,6 @@ config NFC_PORT100
source "drivers/nfc/pn544/Kconfig"
source "drivers/nfc/microread/Kconfig"
source "drivers/nfc/nfcmrvl/Kconfig"
source "drivers/nfc/st21nfca/Kconfig"
endmenu
......@@ -11,5 +11,6 @@ obj-$(CONFIG_NFC_SIM) += nfcsim.o
obj-$(CONFIG_NFC_PORT100) += port100.o
obj-$(CONFIG_NFC_MRVL) += nfcmrvl/
obj-$(CONFIG_NFC_TRF7970A) += trf7970a.o
obj-$(CONFIG_NFC_ST21NFCA) += st21nfca/
ccflags-$(CONFIG_NFC_DEBUG) := -DDEBUG
config NFC_ST21NFCA
tristate "STMicroelectronics ST21NFCA NFC driver"
depends on NFC_HCI
select CRC_CCITT
default n
---help---
STMicroelectronics ST21NFCA core driver. It implements the chipset
HCI logic and hooks into the NFC kernel APIs. Physical layers will
register against it.
To compile this driver as a module, choose m here. The module will
be called st21nfca.
Say N if unsure.
config NFC_ST21NFCA_I2C
tristate "NFC ST21NFCA i2c support"
depends on NFC_ST21NFCA && I2C && NFC_SHDLC
---help---
This module adds support for the STMicroelectronics st21nfca i2c interface.
Select this if your platform is using the i2c bus.
If you choose to build a module, it'll be called st21nfca_i2c.
Say N if unsure.
#
# Makefile for ST21NFCA HCI based NFC driver
#
st21nfca_i2c-objs = i2c.o
obj-$(CONFIG_NFC_ST21NFCA) += st21nfca.o
obj-$(CONFIG_NFC_ST21NFCA_I2C) += st21nfca_i2c.o
/*
* I2C Link Layer for ST21NFCA HCI based Driver
* Copyright (C) 2014 STMicroelectronics SAS. All rights reserved.
*
* 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 that 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.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/crc-ccitt.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/miscdevice.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/nfc.h>
#include <linux/firmware.h>
#include <linux/unaligned/access_ok.h>
#include <linux/platform_data/st21nfca.h>
#include <net/nfc/hci.h>
#include <net/nfc/llc.h>
#include <net/nfc/nfc.h>
#include "st21nfca.h"
/*
* Every frame starts with ST21NFCA_SOF_EOF and ends with ST21NFCA_SOF_EOF.
* Because ST21NFCA_SOF_EOF is a possible data value, there is a mecanism
* called byte stuffing has been introduced.
*
* if byte == ST21NFCA_SOF_EOF or ST21NFCA_ESCAPE_BYTE_STUFFING
* - insert ST21NFCA_ESCAPE_BYTE_STUFFING (escape byte)
* - xor byte with ST21NFCA_BYTE_STUFFING_MASK
*/
#define ST21NFCA_SOF_EOF 0x7e
#define ST21NFCA_BYTE_STUFFING_MASK 0x20
#define ST21NFCA_ESCAPE_BYTE_STUFFING 0x7d
/* SOF + 00 fill size */
#define ST21NFCA_FRAME_HEADROOM 2
/* 4 bytes crc (worst case byte stuffing) + EOF */
#define ST21NFCA_FRAME_TAILROOM 5
#define ST21NFCA_HCI_I2C_DRIVER_NAME "st21nfca_hci_i2c"
static struct i2c_device_id st21nfca_hci_i2c_id_table[] = {
{ST21NFCA_HCI_DRIVER_NAME, 0},
{}
};
MODULE_DEVICE_TABLE(i2c, st21nfca_hci_i2c_id_table);
struct st21nfca_i2c_phy {
struct i2c_client *i2c_dev;
struct nfc_hci_dev *hdev;
unsigned int gpio_ena;
unsigned int gpio_irq;
unsigned int irq_polarity;
struct sk_buff *pending_skb;
int current_read_len;
/*
* crc might have fail because i2c macro
* is disable due to other interface activity
*/
int crc_trials;
int powered;
int run_mode;
/*
* < 0 if hardware error occured (e.g. i2c err)
* and prevents normal operation.
*/
int hard_fault;
};
static u8 len_seq[] = { 13, 24, 15, 29 };
static u16 wait_tab[] = { 2, 3, 5, 15, 20, 40};
#define I2C_DUMP_SKB(info, skb) \
do { \
pr_debug("%s:\n", info); \
print_hex_dump(KERN_DEBUG, "i2c: ", DUMP_PREFIX_OFFSET, \
16, 1, (skb)->data, (skb)->len, 0); \
} while (0)
static void st21nfca_hci_platform_init(struct st21nfca_i2c_phy *phy)
{
u16 wait_tab[] = { 50, 300, 1000 };
char reboot_cmd[] = { 0x7E, 0x66, 0x48, 0xF6, 0x7E };
u8 tmp[ST21NFCA_HCI_LLC_MAX_SIZE];
int i, r = -1;
for (i = 0; i < ARRAY_SIZE(wait_tab) && r < 0; i++)
r = i2c_master_recv(phy->i2c_dev, tmp,
ST21NFCA_HCI_LLC_MAX_SIZE);
r = -1;
for (i = 0; i < ARRAY_SIZE(wait_tab) && r < 0; i++)
r = i2c_master_send(phy->i2c_dev, reboot_cmd,
sizeof(reboot_cmd));
usleep_range(1000, 1500);
}
static int st21nfca_hci_i2c_enable(void *phy_id)
{
struct st21nfca_i2c_phy *phy = phy_id;
gpio_set_value(phy->gpio_ena, 1);
phy->powered = 1;
phy->run_mode = ST21NFCA_HCI_MODE;
usleep_range(10000, 15000);
return 0;
}
static void st21nfca_hci_i2c_disable(void *phy_id)
{
struct st21nfca_i2c_phy *phy = phy_id;
pr_info("\n");
gpio_set_value(phy->gpio_ena, 0);
phy->powered = 0;
}
static int st21nfca_hci_add_len_crc(struct sk_buff *skb)
{
int ret = 2;
u16 crc;
u8 tmp;
*skb_push(skb, 1) = 0;
crc = crc_ccitt(0xffff, skb->data, skb->len);
crc = ~crc;
tmp = crc & 0x00ff;
*skb_put(skb, 1) = tmp;
tmp = (crc >> 8) & 0x00ff;
*skb_put(skb, 1) = tmp;
return ret;
}
static void st21nfca_hci_remove_len_crc(struct sk_buff *skb, int crc_len)
{
skb_pull(skb, ST21NFCA_FRAME_HEADROOM);
skb_trim(skb, crc_len);
}
/*
* Writing a frame must not return the number of written bytes.
* It must return either zero for success, or <0 for error.
* In addition, it must not alter the skb
*/
static int st21nfca_hci_i2c_write(void *phy_id, struct sk_buff *skb)
{
int r = -1, i, j, len;
struct st21nfca_i2c_phy *phy = phy_id;
struct i2c_client *client = phy->i2c_dev;
u16 wait_tab[] = { 2, 3, 5, 15, 20, 40};
u8 tmp[ST21NFCA_HCI_LLC_MAX_SIZE * 2];
I2C_DUMP_SKB("st21nfca_hci_i2c_write", skb);
if (phy->hard_fault != 0)
return phy->hard_fault;
/*
* Compute CRC before byte stuffing computation on frame
* Note st21nfca_hci_add_len_crc is doing a byte stuffing
* on its own value
*/
len = st21nfca_hci_add_len_crc(skb);
/* add ST21NFCA_SOF_EOF on tail */
*skb_put(skb, 1) = ST21NFCA_SOF_EOF;
/* add ST21NFCA_SOF_EOF on head */
*skb_push(skb, 1) = ST21NFCA_SOF_EOF;
/*
* Compute byte stuffing
* if byte == ST21NFCA_SOF_EOF or ST21NFCA_ESCAPE_BYTE_STUFFING
* insert ST21NFCA_ESCAPE_BYTE_STUFFING (escape byte)
* xor byte with ST21NFCA_BYTE_STUFFING_MASK
*/
tmp[0] = skb->data[0];
for (i = 1, j = 1; i < skb->len - 1; i++, j++) {
if (skb->data[i] == ST21NFCA_SOF_EOF
|| skb->data[i] == ST21NFCA_ESCAPE_BYTE_STUFFING) {
tmp[j] = ST21NFCA_ESCAPE_BYTE_STUFFING;
j++;
tmp[j] = skb->data[i] ^ ST21NFCA_BYTE_STUFFING_MASK;
} else {
tmp[j] = skb->data[i];
}
}
tmp[j] = skb->data[i];
j++;
/*
* Manage sleep mode
* Try 3 times to send data with delay between each
*/
for (i = 0; i < ARRAY_SIZE(wait_tab) && r < 0; i++) {
r = i2c_master_send(client, tmp, j);
if (r < 0)
msleep(wait_tab[i]);
}
if (r >= 0) {
if (r != j)
r = -EREMOTEIO;
else
r = 0;
}
st21nfca_hci_remove_len_crc(skb, len);
return r;
}
static int get_frame_size(u8 *buf, int buflen)
{
int len = 0;
if (buf[len + 1] == ST21NFCA_SOF_EOF)
return 0;
for (len = 1; len < buflen && buf[len] != ST21NFCA_SOF_EOF; len++)
;
return len;
}
static int check_crc(u8 *buf, int buflen)
{
u16 crc;
crc = crc_ccitt(0xffff, buf, buflen - 2);
crc = ~crc;
if (buf[buflen - 2] != (crc & 0xff) || buf[buflen - 1] != (crc >> 8)) {
pr_err(ST21NFCA_HCI_DRIVER_NAME
": CRC error 0x%x != 0x%x 0x%x\n", crc, buf[buflen - 1],
buf[buflen - 2]);
pr_info(DRIVER_DESC ": %s : BAD CRC\n", __func__);
print_hex_dump(KERN_DEBUG, "crc: ", DUMP_PREFIX_NONE,
16, 2, buf, buflen, false);
return -EPERM;
}
return 0;
}
/*
* Prepare received data for upper layer.
* Received data include byte stuffing, crc and sof/eof
* which is not usable by hci part.
* returns:
* frame size without sof/eof, header and byte stuffing
* -EBADMSG : frame was incorrect and discarded
*/
static int st21nfca_hci_i2c_repack(struct sk_buff *skb)
{
int i, j, r, size;
if (skb->len < 1 || (skb->len > 1 && skb->data[1] != 0))
return -EBADMSG;
size = get_frame_size(skb->data, skb->len);
if (size > 0) {
skb_trim(skb, size);
/* remove ST21NFCA byte stuffing for upper layer */
for (i = 1, j = 0; i < skb->len; i++) {
if (skb->data[i] ==
(u8) ST21NFCA_ESCAPE_BYTE_STUFFING) {
skb->data[i] =
skb->data[i +
1] | ST21NFCA_BYTE_STUFFING_MASK;
i++;
j++;
}
skb->data[i] = skb->data[i + j];
}
/* remove byte stuffing useless byte */
skb_trim(skb, i - j);
/* remove ST21NFCA_SOF_EOF from head */
skb_pull(skb, 1);
r = check_crc(skb->data, skb->len);
if (r != 0) {
i = 0;
return -EBADMSG;
}
/* remove headbyte */
skb_pull(skb, 1);
/* remove crc. Byte Stuffing is already removed here */
skb_trim(skb, skb->len - 2);
return skb->len;
}
return 0;
}
/*
* Reads an shdlc frame and returns it in a newly allocated sk_buff. Guarantees
* that i2c bus will be flushed and that next read will start on a new frame.
* returned skb contains only LLC header and payload.
* returns:
* frame size : if received frame is complete (find ST21NFCA_SOF_EOF at
* end of read)
* -EAGAIN : if received frame is incomplete (not find ST21NFCA_SOF_EOF
* at end of read)
* -EREMOTEIO : i2c read error (fatal)
* -EBADMSG : frame was incorrect and discarded
* (value returned from st21nfca_hci_i2c_repack)
* -EIO : if no ST21NFCA_SOF_EOF is found after reaching
* the read length end sequence
*/
static int st21nfca_hci_i2c_read(struct st21nfca_i2c_phy *phy,
struct sk_buff *skb)
{
int r, i;
u8 len;
struct i2c_client *client = phy->i2c_dev;
if (phy->current_read_len < ARRAY_SIZE(len_seq)) {
len = len_seq[phy->current_read_len];
/*
* Add retry mecanism
* Operation on I2C interface may fail in case of operation on
* RF or SWP interface
*/
r = 0;
for (i = 0; i < ARRAY_SIZE(wait_tab) && r <= 0; i++) {
r = i2c_master_recv(client, skb_put(skb, len), len);
if (r < 0)
msleep(wait_tab[i]);
}
if (r != len) {
phy->current_read_len = 0;
return -EREMOTEIO;
}
if (memchr(skb->data + 2, ST21NFCA_SOF_EOF,
skb->len - 2) != NULL) {
phy->current_read_len = 0;
return st21nfca_hci_i2c_repack(skb);
}
phy->current_read_len++;
return -EAGAIN;
}
return -EIO;
}
/*
* Reads an shdlc frame from the chip. This is not as straightforward as it
* seems. The frame format is data-crc, and corruption can occur anywhere
* while transiting on i2c bus, such that we could read an invalid data.
* The tricky case is when we read a corrupted data or crc. We must detect
* this here in order to determine that data can be transmitted to the hci
* core. This is the reason why we check the crc here.
* The CLF will repeat a frame until we send a RR on that frame.
*
* On ST21NFCA, IRQ goes in idle when read starts. As no size information are
* available in the incoming data, other IRQ might come. Every IRQ will trigger
* a read sequence with different length and will fill the current frame.
* The reception is complete once we reach a ST21NFCA_SOF_EOF.
*/
static irqreturn_t st21nfca_hci_irq_thread_fn(int irq, void *phy_id)
{
struct st21nfca_i2c_phy *phy = phy_id;
struct i2c_client *client;
int r;
if (!phy || irq != phy->i2c_dev->irq) {
WARN_ON_ONCE(1);
return IRQ_NONE;
}
client = phy->i2c_dev;
dev_dbg(&client->dev, "IRQ\n");
if (phy->hard_fault != 0)
return IRQ_HANDLED;
r = st21nfca_hci_i2c_read(phy, phy->pending_skb);
if (r == -EREMOTEIO) {
phy->hard_fault = r;
nfc_hci_recv_frame(phy->hdev, NULL);
return IRQ_HANDLED;
} else if (r == -EAGAIN || r == -EIO) {
return IRQ_HANDLED;
} else if (r == -EBADMSG && phy->crc_trials < ARRAY_SIZE(wait_tab)) {
/*
* With ST21NFCA, only one interface (I2C, RF or SWP)
* may be active at a time.
* Having incorrect crc is usually due to i2c macrocell
* deactivation in the middle of a transmission.
* It may generate corrupted data on i2c.
* We give sometime to get i2c back.
* The complete frame will be repeated.
*/
msleep(wait_tab[phy->crc_trials]);
phy->crc_trials++;
phy->current_read_len = 0;
} else if (r > 0) {
/*
* We succeeded to read data from the CLF and
* data is valid.
* Reset counter.
*/
nfc_hci_recv_frame(phy->hdev, phy->pending_skb);
phy->crc_trials = 0;
}
phy->pending_skb = alloc_skb(ST21NFCA_HCI_LLC_MAX_SIZE * 2, GFP_KERNEL);
if (phy->pending_skb == NULL) {
phy->hard_fault = -ENOMEM;
nfc_hci_recv_frame(phy->hdev, NULL);
}
return IRQ_HANDLED;
}
static struct nfc_phy_ops i2c_phy_ops = {
.write = st21nfca_hci_i2c_write,
.enable = st21nfca_hci_i2c_enable,
.disable = st21nfca_hci_i2c_disable,
};
static int st21nfca_request_resources(struct st21nfca_i2c_phy *phy,
struct i2c_client *client)
{
struct st21nfca_nfc_platform_data *pdata;
int r;
pdata = client->dev.platform_data;
if (pdata == NULL) {
nfc_err(&client->dev, "No platform data\n");
return -EINVAL;
}
/* store for later use */
phy->gpio_irq = pdata->gpio_irq;
phy->gpio_ena = pdata->gpio_ena;
phy->irq_polarity = pdata->irq_polarity;
phy->i2c_dev = client;
r = devm_gpio_request(&client->dev, phy->gpio_irq, "wake_up");
if (r) {
pr_err("%s : gpio_request failed\n", __FILE__);
return -ENODEV;
}
r = gpio_direction_input(phy->gpio_irq);
if (r) {
pr_err("%s : gpio_direction_input failed\n", __FILE__);
return -ENODEV;
}
if (phy->gpio_ena != 0) {
r = devm_gpio_request(&client->dev,
phy->gpio_ena, "clf_enable");
if (r) {
pr_err("%s : ena gpio_request failed\n", __FILE__);
return -ENODEV;
}
r = gpio_direction_output(phy->gpio_ena, 1);
if (r) {
pr_err("%s : ena gpio_direction_output failed\n",
__FILE__);
return -ENODEV;
}
}
phy->pending_skb = alloc_skb(ST21NFCA_HCI_LLC_MAX_SIZE * 2, GFP_KERNEL);
if (phy->pending_skb == NULL)
return -ENOMEM;
phy->current_read_len = 0;
phy->crc_trials = 0;
return r;
}
static int st21nfca_hci_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct st21nfca_i2c_phy *phy;
struct st21nfca_nfc_platform_data *pdata;
int r = 0;
dev_dbg(&client->dev, "%s\n", __func__);
dev_dbg(&client->dev, "IRQ: %d\n", client->irq);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
nfc_err(&client->dev, "Need I2C_FUNC_I2C\n");
return -ENODEV;
}
phy = devm_kzalloc(&client->dev, sizeof(struct st21nfca_i2c_phy),
GFP_KERNEL);
if (!phy) {
nfc_err(&client->dev,
"Cannot allocate memory for st21nfca i2c phy.\n");
return -ENOMEM;
}
phy->i2c_dev = client;
i2c_set_clientdata(client, phy);
pdata = client->dev.platform_data;
if (pdata == NULL) {
nfc_err(&client->dev, "No platform data\n");
return -EINVAL;
}
r = st21nfca_request_resources(phy, client);
if (r) {
nfc_err(&client->dev, "Cannot get platform resources\n");
return r;
}
st21nfca_hci_platform_init(phy);
r = devm_request_threaded_irq(&client->dev, client->irq, NULL,
st21nfca_hci_irq_thread_fn,
phy->irq_polarity | IRQF_ONESHOT,
ST21NFCA_HCI_DRIVER_NAME, phy);
if (r < 0) {
nfc_err(&client->dev, "Unable to register IRQ handler\n");
return r;
}
r = st21nfca_hci_probe(phy, &i2c_phy_ops, LLC_SHDLC_NAME,
ST21NFCA_FRAME_HEADROOM, ST21NFCA_FRAME_TAILROOM,
ST21NFCA_HCI_LLC_MAX_PAYLOAD, &phy->hdev);
if (r < 0)
return r;
return 0;
}