mirror of
https://github.com/torvalds/linux.git
synced 2024-11-23 12:42:02 +00:00
eb09fc2d14
The module loads firmware so add MODULE_FIRMWARE macros to provide that information via modinfo. Signed-off-by: Juerg Haefliger <juerg.haefliger@canonical.com> Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org> Signed-off-by: David S. Miller <davem@davemloft.net>
768 lines
18 KiB
C
768 lines
18 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/* -------------------------------------------------------------------------
|
|
* Copyright (C) 2014-2016, Intel Corporation
|
|
*
|
|
* -------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/nfc.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/firmware.h>
|
|
#include <net/nfc/nci_core.h>
|
|
|
|
#include "fdp.h"
|
|
|
|
#define FDP_OTP_PATCH_NAME "otp.bin"
|
|
#define FDP_RAM_PATCH_NAME "ram.bin"
|
|
#define FDP_FW_HEADER_SIZE 576
|
|
#define FDP_FW_UPDATE_SLEEP 1000
|
|
|
|
#define NCI_GET_VERSION_TIMEOUT 8000
|
|
#define NCI_PATCH_REQUEST_TIMEOUT 8000
|
|
#define FDP_PATCH_CONN_DEST 0xC2
|
|
#define FDP_PATCH_CONN_PARAM_TYPE 0xA0
|
|
|
|
#define NCI_PATCH_TYPE_RAM 0x00
|
|
#define NCI_PATCH_TYPE_OTP 0x01
|
|
#define NCI_PATCH_TYPE_EOT 0xFF
|
|
|
|
#define NCI_PARAM_ID_FW_RAM_VERSION 0xA0
|
|
#define NCI_PARAM_ID_FW_OTP_VERSION 0xA1
|
|
#define NCI_PARAM_ID_OTP_LIMITED_VERSION 0xC5
|
|
#define NCI_PARAM_ID_KEY_INDEX_ID 0xC6
|
|
|
|
#define NCI_GID_PROP 0x0F
|
|
#define NCI_OP_PROP_PATCH_OID 0x08
|
|
#define NCI_OP_PROP_SET_PDATA_OID 0x23
|
|
|
|
struct fdp_nci_info {
|
|
const struct nfc_phy_ops *phy_ops;
|
|
struct fdp_i2c_phy *phy;
|
|
struct nci_dev *ndev;
|
|
|
|
const struct firmware *otp_patch;
|
|
const struct firmware *ram_patch;
|
|
u32 otp_patch_version;
|
|
u32 ram_patch_version;
|
|
|
|
u32 otp_version;
|
|
u32 ram_version;
|
|
u32 limited_otp_version;
|
|
u8 key_index;
|
|
|
|
const u8 *fw_vsc_cfg;
|
|
u8 clock_type;
|
|
u32 clock_freq;
|
|
|
|
atomic_t data_pkt_counter;
|
|
void (*data_pkt_counter_cb)(struct nci_dev *ndev);
|
|
u8 setup_patch_sent;
|
|
u8 setup_patch_ntf;
|
|
u8 setup_patch_status;
|
|
u8 setup_reset_ntf;
|
|
wait_queue_head_t setup_wq;
|
|
};
|
|
|
|
static const u8 nci_core_get_config_otp_ram_version[5] = {
|
|
0x04,
|
|
NCI_PARAM_ID_FW_RAM_VERSION,
|
|
NCI_PARAM_ID_FW_OTP_VERSION,
|
|
NCI_PARAM_ID_OTP_LIMITED_VERSION,
|
|
NCI_PARAM_ID_KEY_INDEX_ID
|
|
};
|
|
|
|
struct nci_core_get_config_rsp {
|
|
u8 status;
|
|
u8 count;
|
|
u8 data[];
|
|
};
|
|
|
|
static int fdp_nci_create_conn(struct nci_dev *ndev)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
struct core_conn_create_dest_spec_params param;
|
|
int r;
|
|
|
|
/* proprietary destination specific paramerer without value */
|
|
param.type = FDP_PATCH_CONN_PARAM_TYPE;
|
|
param.length = 0x00;
|
|
|
|
r = nci_core_conn_create(info->ndev, FDP_PATCH_CONN_DEST, 1,
|
|
sizeof(param), ¶m);
|
|
if (r)
|
|
return r;
|
|
|
|
return nci_get_conn_info_by_dest_type_params(ndev,
|
|
FDP_PATCH_CONN_DEST, NULL);
|
|
}
|
|
|
|
static inline int fdp_nci_get_versions(struct nci_dev *ndev)
|
|
{
|
|
return nci_core_cmd(ndev, NCI_OP_CORE_GET_CONFIG_CMD,
|
|
sizeof(nci_core_get_config_otp_ram_version),
|
|
(__u8 *) &nci_core_get_config_otp_ram_version);
|
|
}
|
|
|
|
static inline int fdp_nci_patch_cmd(struct nci_dev *ndev, u8 type)
|
|
{
|
|
return nci_prop_cmd(ndev, NCI_OP_PROP_PATCH_OID, sizeof(type), &type);
|
|
}
|
|
|
|
static inline int fdp_nci_set_production_data(struct nci_dev *ndev, u8 len,
|
|
const char *data)
|
|
{
|
|
return nci_prop_cmd(ndev, NCI_OP_PROP_SET_PDATA_OID, len, data);
|
|
}
|
|
|
|
static int fdp_nci_set_clock(struct nci_dev *ndev, u8 clock_type,
|
|
u32 clock_freq)
|
|
{
|
|
u32 fc = 13560;
|
|
u32 nd, num, delta;
|
|
char data[9];
|
|
|
|
nd = (24 * fc) / clock_freq;
|
|
delta = 24 * fc - nd * clock_freq;
|
|
num = (32768 * delta) / clock_freq;
|
|
|
|
data[0] = 0x00;
|
|
data[1] = 0x00;
|
|
data[2] = 0x00;
|
|
|
|
data[3] = 0x10;
|
|
data[4] = 0x04;
|
|
data[5] = num & 0xFF;
|
|
data[6] = (num >> 8) & 0xff;
|
|
data[7] = nd;
|
|
data[8] = clock_type;
|
|
|
|
return fdp_nci_set_production_data(ndev, 9, data);
|
|
}
|
|
|
|
static void fdp_nci_send_patch_cb(struct nci_dev *ndev)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
|
|
info->setup_patch_sent = 1;
|
|
wake_up(&info->setup_wq);
|
|
}
|
|
|
|
/*
|
|
* Register a packet sent counter and a callback
|
|
*
|
|
* We have no other way of knowing when all firmware packets were sent out
|
|
* on the i2c bus. We need to know that in order to close the connection and
|
|
* send the patch end message.
|
|
*/
|
|
static void fdp_nci_set_data_pkt_counter(struct nci_dev *ndev,
|
|
void (*cb)(struct nci_dev *ndev), int count)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
struct device *dev = &info->phy->i2c_dev->dev;
|
|
|
|
dev_dbg(dev, "NCI data pkt counter %d\n", count);
|
|
atomic_set(&info->data_pkt_counter, count);
|
|
info->data_pkt_counter_cb = cb;
|
|
}
|
|
|
|
/*
|
|
* The device is expecting a stream of packets. All packets need to
|
|
* have the PBF flag set to 0x0 (last packet) even if the firmware
|
|
* file is segmented and there are multiple packets. If we give the
|
|
* whole firmware to nci_send_data it will segment it and it will set
|
|
* the PBF flag to 0x01 so we need to do the segmentation here.
|
|
*
|
|
* The firmware will be analyzed and applied when we send NCI_OP_PROP_PATCH_CMD
|
|
* command with NCI_PATCH_TYPE_EOT parameter. The device will send a
|
|
* NFCC_PATCH_NTF packet and a NCI_OP_CORE_RESET_NTF packet.
|
|
*/
|
|
static int fdp_nci_send_patch(struct nci_dev *ndev, u8 conn_id, u8 type)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
const struct firmware *fw;
|
|
struct sk_buff *skb;
|
|
unsigned long len;
|
|
int max_size, payload_size;
|
|
int rc = 0;
|
|
|
|
if ((type == NCI_PATCH_TYPE_OTP && !info->otp_patch) ||
|
|
(type == NCI_PATCH_TYPE_RAM && !info->ram_patch))
|
|
return -EINVAL;
|
|
|
|
if (type == NCI_PATCH_TYPE_OTP)
|
|
fw = info->otp_patch;
|
|
else
|
|
fw = info->ram_patch;
|
|
|
|
max_size = nci_conn_max_data_pkt_payload_size(ndev, conn_id);
|
|
if (max_size <= 0)
|
|
return -EINVAL;
|
|
|
|
len = fw->size;
|
|
|
|
fdp_nci_set_data_pkt_counter(ndev, fdp_nci_send_patch_cb,
|
|
DIV_ROUND_UP(fw->size, max_size));
|
|
|
|
while (len) {
|
|
|
|
payload_size = min_t(unsigned long, max_size, len);
|
|
|
|
skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + payload_size),
|
|
GFP_KERNEL);
|
|
if (!skb) {
|
|
fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
|
|
skb_reserve(skb, NCI_CTRL_HDR_SIZE);
|
|
|
|
skb_put_data(skb, fw->data + (fw->size - len), payload_size);
|
|
|
|
rc = nci_send_data(ndev, conn_id, skb);
|
|
|
|
if (rc) {
|
|
fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
|
|
return rc;
|
|
}
|
|
|
|
len -= payload_size;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int fdp_nci_open(struct nci_dev *ndev)
|
|
{
|
|
const struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
|
|
return info->phy_ops->enable(info->phy);
|
|
}
|
|
|
|
static int fdp_nci_close(struct nci_dev *ndev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int fdp_nci_send(struct nci_dev *ndev, struct sk_buff *skb)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
int ret;
|
|
|
|
if (atomic_dec_and_test(&info->data_pkt_counter))
|
|
info->data_pkt_counter_cb(ndev);
|
|
|
|
ret = info->phy_ops->write(info->phy, skb);
|
|
if (ret < 0) {
|
|
kfree_skb(skb);
|
|
return ret;
|
|
}
|
|
|
|
consume_skb(skb);
|
|
return 0;
|
|
}
|
|
|
|
static int fdp_nci_request_firmware(struct nci_dev *ndev)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
struct device *dev = &info->phy->i2c_dev->dev;
|
|
const u8 *data;
|
|
int r;
|
|
|
|
r = request_firmware(&info->ram_patch, FDP_RAM_PATCH_NAME, dev);
|
|
if (r < 0) {
|
|
nfc_err(dev, "RAM patch request error\n");
|
|
return r;
|
|
}
|
|
|
|
data = info->ram_patch->data;
|
|
info->ram_patch_version =
|
|
data[FDP_FW_HEADER_SIZE] |
|
|
(data[FDP_FW_HEADER_SIZE + 1] << 8) |
|
|
(data[FDP_FW_HEADER_SIZE + 2] << 16) |
|
|
(data[FDP_FW_HEADER_SIZE + 3] << 24);
|
|
|
|
dev_dbg(dev, "RAM patch version: %d, size: %zu\n",
|
|
info->ram_patch_version, info->ram_patch->size);
|
|
|
|
|
|
r = request_firmware(&info->otp_patch, FDP_OTP_PATCH_NAME, dev);
|
|
if (r < 0) {
|
|
nfc_err(dev, "OTP patch request error\n");
|
|
return 0;
|
|
}
|
|
|
|
data = (u8 *) info->otp_patch->data;
|
|
info->otp_patch_version =
|
|
data[FDP_FW_HEADER_SIZE] |
|
|
(data[FDP_FW_HEADER_SIZE + 1] << 8) |
|
|
(data[FDP_FW_HEADER_SIZE+2] << 16) |
|
|
(data[FDP_FW_HEADER_SIZE+3] << 24);
|
|
|
|
dev_dbg(dev, "OTP patch version: %d, size: %zu\n",
|
|
info->otp_patch_version, info->otp_patch->size);
|
|
return 0;
|
|
}
|
|
|
|
static void fdp_nci_release_firmware(struct nci_dev *ndev)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
|
|
if (info->otp_patch) {
|
|
release_firmware(info->otp_patch);
|
|
info->otp_patch = NULL;
|
|
}
|
|
|
|
if (info->ram_patch) {
|
|
release_firmware(info->ram_patch);
|
|
info->ram_patch = NULL;
|
|
}
|
|
}
|
|
|
|
static int fdp_nci_patch_otp(struct nci_dev *ndev)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
struct device *dev = &info->phy->i2c_dev->dev;
|
|
int conn_id;
|
|
int r = 0;
|
|
|
|
if (info->otp_version >= info->otp_patch_version)
|
|
return r;
|
|
|
|
info->setup_patch_sent = 0;
|
|
info->setup_reset_ntf = 0;
|
|
info->setup_patch_ntf = 0;
|
|
|
|
/* Patch init request */
|
|
r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_OTP);
|
|
if (r)
|
|
return r;
|
|
|
|
/* Patch data connection creation */
|
|
conn_id = fdp_nci_create_conn(ndev);
|
|
if (conn_id < 0)
|
|
return conn_id;
|
|
|
|
/* Send the patch over the data connection */
|
|
r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_OTP);
|
|
if (r)
|
|
return r;
|
|
|
|
/* Wait for all the packets to be send over i2c */
|
|
wait_event_interruptible(info->setup_wq,
|
|
info->setup_patch_sent == 1);
|
|
|
|
/* make sure that the NFCC processed the last data packet */
|
|
msleep(FDP_FW_UPDATE_SLEEP);
|
|
|
|
/* Close the data connection */
|
|
r = nci_core_conn_close(info->ndev, conn_id);
|
|
if (r)
|
|
return r;
|
|
|
|
/* Patch finish message */
|
|
if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
|
|
nfc_err(dev, "OTP patch error 0x%x\n", r);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* If the patch notification didn't arrive yet, wait for it */
|
|
wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
|
|
|
|
/* Check if the patching was successful */
|
|
r = info->setup_patch_status;
|
|
if (r) {
|
|
nfc_err(dev, "OTP patch error 0x%x\n", r);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/*
|
|
* We need to wait for the reset notification before we
|
|
* can continue
|
|
*/
|
|
wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
|
|
|
|
return r;
|
|
}
|
|
|
|
static int fdp_nci_patch_ram(struct nci_dev *ndev)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
struct device *dev = &info->phy->i2c_dev->dev;
|
|
int conn_id;
|
|
int r = 0;
|
|
|
|
if (info->ram_version >= info->ram_patch_version)
|
|
return r;
|
|
|
|
info->setup_patch_sent = 0;
|
|
info->setup_reset_ntf = 0;
|
|
info->setup_patch_ntf = 0;
|
|
|
|
/* Patch init request */
|
|
r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_RAM);
|
|
if (r)
|
|
return r;
|
|
|
|
/* Patch data connection creation */
|
|
conn_id = fdp_nci_create_conn(ndev);
|
|
if (conn_id < 0)
|
|
return conn_id;
|
|
|
|
/* Send the patch over the data connection */
|
|
r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_RAM);
|
|
if (r)
|
|
return r;
|
|
|
|
/* Wait for all the packets to be send over i2c */
|
|
wait_event_interruptible(info->setup_wq,
|
|
info->setup_patch_sent == 1);
|
|
|
|
/* make sure that the NFCC processed the last data packet */
|
|
msleep(FDP_FW_UPDATE_SLEEP);
|
|
|
|
/* Close the data connection */
|
|
r = nci_core_conn_close(info->ndev, conn_id);
|
|
if (r)
|
|
return r;
|
|
|
|
/* Patch finish message */
|
|
if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
|
|
nfc_err(dev, "RAM patch error 0x%x\n", r);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* If the patch notification didn't arrive yet, wait for it */
|
|
wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
|
|
|
|
/* Check if the patching was successful */
|
|
r = info->setup_patch_status;
|
|
if (r) {
|
|
nfc_err(dev, "RAM patch error 0x%x\n", r);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/*
|
|
* We need to wait for the reset notification before we
|
|
* can continue
|
|
*/
|
|
wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
|
|
|
|
return r;
|
|
}
|
|
|
|
static int fdp_nci_setup(struct nci_dev *ndev)
|
|
{
|
|
/* Format: total length followed by an NCI packet */
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
struct device *dev = &info->phy->i2c_dev->dev;
|
|
int r;
|
|
u8 patched = 0;
|
|
|
|
r = nci_core_init(ndev);
|
|
if (r)
|
|
goto error;
|
|
|
|
/* Get RAM and OTP version */
|
|
r = fdp_nci_get_versions(ndev);
|
|
if (r)
|
|
goto error;
|
|
|
|
/* Load firmware from disk */
|
|
r = fdp_nci_request_firmware(ndev);
|
|
if (r)
|
|
goto error;
|
|
|
|
/* Update OTP */
|
|
if (info->otp_version < info->otp_patch_version) {
|
|
r = fdp_nci_patch_otp(ndev);
|
|
if (r)
|
|
goto error;
|
|
patched = 1;
|
|
}
|
|
|
|
/* Update RAM */
|
|
if (info->ram_version < info->ram_patch_version) {
|
|
r = fdp_nci_patch_ram(ndev);
|
|
if (r)
|
|
goto error;
|
|
patched = 1;
|
|
}
|
|
|
|
/* Release the firmware buffers */
|
|
fdp_nci_release_firmware(ndev);
|
|
|
|
/* If a patch was applied the new version is checked */
|
|
if (patched) {
|
|
r = nci_core_init(ndev);
|
|
if (r)
|
|
goto error;
|
|
|
|
r = fdp_nci_get_versions(ndev);
|
|
if (r)
|
|
goto error;
|
|
|
|
if (info->otp_version != info->otp_patch_version ||
|
|
info->ram_version != info->ram_patch_version) {
|
|
nfc_err(dev, "Firmware update failed");
|
|
r = -EINVAL;
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We initialized the devices but the NFC subsystem expects
|
|
* it to not be initialized.
|
|
*/
|
|
return nci_core_reset(ndev);
|
|
|
|
error:
|
|
fdp_nci_release_firmware(ndev);
|
|
nfc_err(dev, "Setup error %d\n", r);
|
|
return r;
|
|
}
|
|
|
|
static int fdp_nci_post_setup(struct nci_dev *ndev)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
struct device *dev = &info->phy->i2c_dev->dev;
|
|
int r;
|
|
|
|
/* Check if the device has VSC */
|
|
if (info->fw_vsc_cfg && info->fw_vsc_cfg[0]) {
|
|
|
|
/* Set the vendor specific configuration */
|
|
r = fdp_nci_set_production_data(ndev, info->fw_vsc_cfg[3],
|
|
&info->fw_vsc_cfg[4]);
|
|
if (r) {
|
|
nfc_err(dev, "Vendor specific config set error %d\n",
|
|
r);
|
|
return r;
|
|
}
|
|
}
|
|
|
|
/* Set clock type and frequency */
|
|
r = fdp_nci_set_clock(ndev, info->clock_type, info->clock_freq);
|
|
if (r) {
|
|
nfc_err(dev, "Clock set error %d\n", r);
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
* In order to apply the VSC FDP needs a reset
|
|
*/
|
|
r = nci_core_reset(ndev);
|
|
if (r)
|
|
return r;
|
|
|
|
/**
|
|
* The nci core was initialized when post setup was called
|
|
* so we leave it like that
|
|
*/
|
|
return nci_core_init(ndev);
|
|
}
|
|
|
|
static int fdp_nci_core_reset_ntf_packet(struct nci_dev *ndev,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
|
|
info->setup_reset_ntf = 1;
|
|
wake_up(&info->setup_wq);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int fdp_nci_prop_patch_ntf_packet(struct nci_dev *ndev,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
|
|
info->setup_patch_ntf = 1;
|
|
info->setup_patch_status = skb->data[0];
|
|
wake_up(&info->setup_wq);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int fdp_nci_prop_patch_rsp_packet(struct nci_dev *ndev,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
struct device *dev = &info->phy->i2c_dev->dev;
|
|
u8 status = skb->data[0];
|
|
|
|
dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
|
|
nci_req_complete(ndev, status);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int fdp_nci_prop_set_production_data_rsp_packet(struct nci_dev *ndev,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
struct device *dev = &info->phy->i2c_dev->dev;
|
|
u8 status = skb->data[0];
|
|
|
|
dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
|
|
nci_req_complete(ndev, status);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int fdp_nci_core_get_config_rsp_packet(struct nci_dev *ndev,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct fdp_nci_info *info = nci_get_drvdata(ndev);
|
|
struct device *dev = &info->phy->i2c_dev->dev;
|
|
const struct nci_core_get_config_rsp *rsp = (void *) skb->data;
|
|
unsigned int i;
|
|
const u8 *p;
|
|
|
|
if (rsp->status == NCI_STATUS_OK) {
|
|
|
|
p = rsp->data;
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
switch (*p++) {
|
|
case NCI_PARAM_ID_FW_RAM_VERSION:
|
|
p++;
|
|
info->ram_version = le32_to_cpup((__le32 *) p);
|
|
p += 4;
|
|
break;
|
|
case NCI_PARAM_ID_FW_OTP_VERSION:
|
|
p++;
|
|
info->otp_version = le32_to_cpup((__le32 *) p);
|
|
p += 4;
|
|
break;
|
|
case NCI_PARAM_ID_OTP_LIMITED_VERSION:
|
|
p++;
|
|
info->otp_version = le32_to_cpup((__le32 *) p);
|
|
p += 4;
|
|
break;
|
|
case NCI_PARAM_ID_KEY_INDEX_ID:
|
|
p++;
|
|
info->key_index = *p++;
|
|
}
|
|
}
|
|
}
|
|
|
|
dev_dbg(dev, "OTP version %d\n", info->otp_version);
|
|
dev_dbg(dev, "RAM version %d\n", info->ram_version);
|
|
dev_dbg(dev, "key index %d\n", info->key_index);
|
|
dev_dbg(dev, "%s: status 0x%x\n", __func__, rsp->status);
|
|
|
|
nci_req_complete(ndev, rsp->status);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct nci_driver_ops fdp_core_ops[] = {
|
|
{
|
|
.opcode = NCI_OP_CORE_GET_CONFIG_RSP,
|
|
.rsp = fdp_nci_core_get_config_rsp_packet,
|
|
},
|
|
{
|
|
.opcode = NCI_OP_CORE_RESET_NTF,
|
|
.ntf = fdp_nci_core_reset_ntf_packet,
|
|
},
|
|
};
|
|
|
|
static const struct nci_driver_ops fdp_prop_ops[] = {
|
|
{
|
|
.opcode = nci_opcode_pack(NCI_GID_PROP, NCI_OP_PROP_PATCH_OID),
|
|
.rsp = fdp_nci_prop_patch_rsp_packet,
|
|
.ntf = fdp_nci_prop_patch_ntf_packet,
|
|
},
|
|
{
|
|
.opcode = nci_opcode_pack(NCI_GID_PROP,
|
|
NCI_OP_PROP_SET_PDATA_OID),
|
|
.rsp = fdp_nci_prop_set_production_data_rsp_packet,
|
|
},
|
|
};
|
|
|
|
static const struct nci_ops nci_ops = {
|
|
.open = fdp_nci_open,
|
|
.close = fdp_nci_close,
|
|
.send = fdp_nci_send,
|
|
.setup = fdp_nci_setup,
|
|
.post_setup = fdp_nci_post_setup,
|
|
.prop_ops = fdp_prop_ops,
|
|
.n_prop_ops = ARRAY_SIZE(fdp_prop_ops),
|
|
.core_ops = fdp_core_ops,
|
|
.n_core_ops = ARRAY_SIZE(fdp_core_ops),
|
|
};
|
|
|
|
int fdp_nci_probe(struct fdp_i2c_phy *phy, const struct nfc_phy_ops *phy_ops,
|
|
struct nci_dev **ndevp, int tx_headroom,
|
|
int tx_tailroom, u8 clock_type, u32 clock_freq,
|
|
const u8 *fw_vsc_cfg)
|
|
{
|
|
struct device *dev = &phy->i2c_dev->dev;
|
|
struct fdp_nci_info *info;
|
|
struct nci_dev *ndev;
|
|
u32 protocols;
|
|
int r;
|
|
|
|
info = devm_kzalloc(dev, sizeof(struct fdp_nci_info), GFP_KERNEL);
|
|
if (!info)
|
|
return -ENOMEM;
|
|
|
|
info->phy = phy;
|
|
info->phy_ops = phy_ops;
|
|
info->clock_type = clock_type;
|
|
info->clock_freq = clock_freq;
|
|
info->fw_vsc_cfg = fw_vsc_cfg;
|
|
|
|
init_waitqueue_head(&info->setup_wq);
|
|
|
|
protocols = NFC_PROTO_JEWEL_MASK |
|
|
NFC_PROTO_MIFARE_MASK |
|
|
NFC_PROTO_FELICA_MASK |
|
|
NFC_PROTO_ISO14443_MASK |
|
|
NFC_PROTO_ISO14443_B_MASK |
|
|
NFC_PROTO_NFC_DEP_MASK |
|
|
NFC_PROTO_ISO15693_MASK;
|
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(fdp_prop_ops) > NCI_MAX_PROPRIETARY_CMD);
|
|
ndev = nci_allocate_device(&nci_ops, protocols, tx_headroom,
|
|
tx_tailroom);
|
|
if (!ndev) {
|
|
nfc_err(dev, "Cannot allocate nfc ndev\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
r = nci_register_device(ndev);
|
|
if (r)
|
|
goto err_regdev;
|
|
|
|
*ndevp = ndev;
|
|
info->ndev = ndev;
|
|
|
|
nci_set_drvdata(ndev, info);
|
|
|
|
return 0;
|
|
|
|
err_regdev:
|
|
nci_free_device(ndev);
|
|
return r;
|
|
}
|
|
EXPORT_SYMBOL(fdp_nci_probe);
|
|
|
|
void fdp_nci_remove(struct nci_dev *ndev)
|
|
{
|
|
nci_unregister_device(ndev);
|
|
nci_free_device(ndev);
|
|
}
|
|
EXPORT_SYMBOL(fdp_nci_remove);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("NFC NCI driver for Intel Fields Peak NFC controller");
|
|
MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");
|
|
|
|
MODULE_FIRMWARE(FDP_OTP_PATCH_NAME);
|
|
MODULE_FIRMWARE(FDP_RAM_PATCH_NAME);
|