samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add 'nxp/opensource/driver/' from commit 'c6f0de7127de042241c6f2ac7c60c5deb77d7d85'

Browse Source 
git-subtree-dir: nxp/opensource/driver
git-subtree-mainline: 47018f8d6d
git-subtree-split: c6f0de7127
Change-Id:
repo: https://git.codelinaro.org/clo/la/platform/vendor/nxp/opensource/driver
tag: LA.VENDOR.14.3.0.r1-17300-lanai.QSSI15.0
This commit is contained in:
David Wronek
2024-10-06 16:43:44 +02:00
parent 47018f8d6d c6f0de7127
commit 99ab089c55
24 changed files with 3556 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

862
nxp/opensource/driver/nfc/common.c Normal file
View File

@@ -0,0 +1,862 @@
/******************************************************************************
* Copyright (C) 2015, The Linux Foundation. All rights reserved.
* Copyright (C) 2019-2022 NXP
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
******************************************************************************/
/*
* Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.
*
*****************************************************************************/
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/delay.h>
#include <linux/pinctrl/qcom-pinctrl.h>
#include "common.h"
bool secure_peripheral_not_found = true;
int nfc_parse_dt(struct device *dev, struct platform_configs *nfc_configs,
uint8_t interface)
{
int ret;
struct device_node *np = dev->of_node;
struct platform_gpio *nfc_gpio = &nfc_configs->gpio;
struct platform_ldo *ldo = &nfc_configs->ldo;
if (!np) {
pr_err("NxpDrv: %s: nfc of_node NULL\n", __func__);
return -EINVAL;
}
nfc_gpio->irq = -EINVAL;
nfc_gpio->dwl_req = -EINVAL;
nfc_gpio->ven = -EINVAL;
nfc_gpio->clkreq = -EINVAL;
/* irq required for i2c based chips only */
if (interface == PLATFORM_IF_I2C) {
nfc_gpio->irq = of_get_named_gpio(np, DTS_IRQ_GPIO_STR, 0);
if ((!gpio_is_valid(nfc_gpio->irq))) {
pr_err("NxpDrv: %s: irq gpio invalid %d\n", __func__,
nfc_gpio->irq);
return nfc_gpio->irq;
}
pr_info("NxpDrv: %s: irq %d\n", __func__, nfc_gpio->irq);
}
nfc_gpio->ven = of_get_named_gpio(np, DTS_VEN_GPIO_STR, 0);
if ((!gpio_is_valid(nfc_gpio->ven))) {
pr_err("NxpDrv: %s: ven gpio invalid %d\n", __func__, nfc_gpio->ven);
return nfc_gpio->ven;
}
/* some products like sn220 does not required fw dwl pin */
nfc_gpio->dwl_req = of_get_named_gpio(np, DTS_FWDN_GPIO_STR, 0);
/* not returning failure for dwl gpio as it is optional for sn220 */
if ((!gpio_is_valid(nfc_gpio->dwl_req))) {
pr_warn("NxpDrv: %s: dwl_req gpio invalid %d\n", __func__,
nfc_gpio->dwl_req);
}
/* Read clock request gpio configuration if MGPIO configurations are not preasent */
if (of_property_read_string(np, DTS_CLKSRC_GPIO_STR, &nfc_configs->clk_src_name)) {
nfc_configs->clk_pin_voting = false;
} else
nfc_configs->clk_pin_voting = true;
/* Read clkreq GPIO pin number from DTSI */
nfc_gpio->clkreq = of_get_named_gpio(np, DTS_CLKREQ_GPIO_STR, 0);
if (!gpio_is_valid(nfc_gpio->clkreq)) {
dev_err(dev, "NxpDrv: clkreq gpio invalid %d\n", nfc_gpio->clkreq);
return -EINVAL;
}
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
/* Read DTS_SZONE_STR to check secure zone support */
if (of_property_read_string(np, DTS_SZONE_STR, &nfc_configs->szone)) {
nfc_configs->CNSS_NFC_HW_SECURE_ENABLE = false;
}else
nfc_configs->CNSS_NFC_HW_SECURE_ENABLE = true;
#endif
pr_info("NxpDrv: %s: irq %d, ven %d, dwl %d, clkreq %d \n", __func__, nfc_gpio->irq, nfc_gpio->ven,
nfc_gpio->dwl_req, nfc_gpio->clkreq);
/* optional property */
ret = of_property_read_u32_array(np, NFC_LDO_VOL_DT_NAME,
(u32 *) ldo->vdd_levels,
ARRAY_SIZE(ldo->vdd_levels));
if (ret) {
dev_err(dev, "NxpDrv: error reading NFC VDDIO min and max value\n");
// set default as per datasheet
ldo->vdd_levels[0] = NFC_VDDIO_MIN;
ldo->vdd_levels[1] = NFC_VDDIO_MAX;
}
/* optional property */
ret = of_property_read_u32(np, NFC_LDO_CUR_DT_NAME, &ldo->max_current);
if (ret) {
dev_err(dev, "NxpDrv: error reading NFC current value\n");
// set default as per datasheet
ldo->max_current = NFC_CURRENT_MAX;
}
return 0;
}
void set_valid_gpio(int gpio, int value)
{
if (gpio_is_valid(gpio)) {
pr_debug("NxpDrv: %s: gpio %d value %d\n", __func__, gpio, value);
gpio_set_value(gpio, value);
/* hardware dependent delay */
usleep_range(NFC_GPIO_SET_WAIT_TIME_US,
NFC_GPIO_SET_WAIT_TIME_US + 100);
}
}
int get_valid_gpio(int gpio)
{
int value = -EINVAL;
if (gpio_is_valid(gpio)) {
value = gpio_get_value(gpio);
pr_debug("NxpDrv: %s: gpio %d value %d\n", __func__, gpio, value);
}
return value;
}
void gpio_set_ven(struct nfc_dev *nfc_dev, int value)
{
struct platform_gpio *nfc_gpio = &nfc_dev->configs.gpio;
if (gpio_get_value(nfc_gpio->ven) != value) {
pr_debug("NxpDrv: %s: value %d\n", __func__, value);
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
if(secure_peripheral_not_found)
{
/*secure peripheral feature is not enabled*/
gpio_set_value(nfc_gpio->ven, value);
}
else
{
/*secure peripheral feature is enabled*/
if(!nfc_hw_secure_check())
gpio_set_value(nfc_gpio->ven, value);
}
#else
gpio_set_value(nfc_gpio->ven, value);
#endif
/* hardware dependent delay */
usleep_range(NFC_GPIO_SET_WAIT_TIME_US,
NFC_GPIO_SET_WAIT_TIME_US + 100);
}
}
int configure_gpio(unsigned int gpio, int flag)
{
int ret;
pr_debug("NxpDrv: %s: nfc gpio [%d] flag [%01x]\n", __func__, gpio, flag);
if (gpio_is_valid(gpio)) {
ret = gpio_request(gpio, "nfc_gpio");
if (ret) {
pr_err("NxpDrv: %s: unable to request nfc gpio [%d]\n",
__func__, gpio);
return ret;
}
/* set direction and value for output pin */
if (flag & GPIO_OUTPUT) {
ret = gpio_direction_output(gpio, (GPIO_HIGH & flag));
pr_debug("NxpDrv: %s: nfc o/p gpio %d level %d\n", __func__,
gpio, gpio_get_value(gpio));
} else {
ret = gpio_direction_input(gpio);
pr_debug("NxpDrv: %s: nfc i/p gpio %d\n", __func__, gpio);
}
if (ret) {
pr_err("NxpDrv: %s: unable to set direction for nfc gpio [%d]\n", __func__, gpio);
gpio_free(gpio);
return ret;
}
/* Consider value as control for input IRQ pin */
if (flag & GPIO_IRQ) {
ret = gpio_to_irq(gpio);
if (ret < 0) {
pr_err("NxpDrv: %s: unable to set irq [%d]\n", __func__,
gpio);
gpio_free(gpio);
return ret;
}
pr_debug("NxpDrv: %s: gpio_to_irq successful [%d]\n", __func__,
gpio);
return ret;
}
} else {
pr_err("NxpDrv: %s: invalid gpio\n", __func__);
ret = -EINVAL;
}
return ret;
}
void gpio_free_all(struct nfc_dev *nfc_dev)
{
struct platform_gpio *nfc_gpio = &nfc_dev->configs.gpio;
if (gpio_is_valid(nfc_gpio->clkreq))
gpio_free(nfc_gpio->clkreq);
if (gpio_is_valid(nfc_gpio->dwl_req))
gpio_free(nfc_gpio->dwl_req);
if (gpio_is_valid(nfc_gpio->irq))
gpio_free(nfc_gpio->irq);
if (gpio_is_valid(nfc_gpio->ven))
gpio_free(nfc_gpio->ven);
}
void nfc_misc_unregister(struct nfc_dev *nfc_dev, int count)
{
pr_debug("NxpDrv: %s: entry\n", __func__);
kfree(nfc_dev->kbuf);
device_destroy(nfc_dev->nfc_class, nfc_dev->devno);
cdev_del(&nfc_dev->c_dev);
class_destroy(nfc_dev->nfc_class);
unregister_chrdev_region(nfc_dev->devno, count);
if (nfc_dev->ipcl)
ipc_log_context_destroy(nfc_dev->ipcl);
}
int nfc_misc_register(struct nfc_dev *nfc_dev,
const struct file_operations *nfc_fops, int count,
char *devname, char *classname)
{
int ret = 0;
ret = alloc_chrdev_region(&nfc_dev->devno, 0, count, devname);
if (ret < 0) {
pr_err("NxpDrv: %s: failed to alloc chrdev region ret %d\n", __func__,
ret);
return ret;
}
nfc_dev->nfc_class = class_create(THIS_MODULE, classname);
if (IS_ERR(nfc_dev->nfc_class)) {
ret = PTR_ERR(nfc_dev->nfc_class);
pr_err("NxpDrv: %s: failed to register device class ret %d\n", __func__,
ret);
unregister_chrdev_region(nfc_dev->devno, count);
return ret;
}
cdev_init(&nfc_dev->c_dev, nfc_fops);
ret = cdev_add(&nfc_dev->c_dev, nfc_dev->devno, count);
if (ret < 0) {
pr_err("NxpDrv: %s: failed to add cdev ret %d\n", __func__, ret);
class_destroy(nfc_dev->nfc_class);
unregister_chrdev_region(nfc_dev->devno, count);
return ret;
}
nfc_dev->nfc_device = device_create(nfc_dev->nfc_class, NULL,
nfc_dev->devno, nfc_dev, devname);
if (IS_ERR(nfc_dev->nfc_device)) {
ret = PTR_ERR(nfc_dev->nfc_device);
pr_err("NxpDrv: %s: failed to create the device ret %d\n", __func__,
ret);
cdev_del(&nfc_dev->c_dev);
class_destroy(nfc_dev->nfc_class);
unregister_chrdev_region(nfc_dev->devno, count);
return ret;
}
nfc_dev->ipcl = ipc_log_context_create(NUM_OF_IPC_LOG_PAGES,
dev_name(nfc_dev->nfc_device), 0);
nfc_dev->kbuflen = MAX_NCI_BUFFER_SIZE;
nfc_dev->kbuf = kzalloc(MAX_NCI_BUFFER_SIZE, GFP_KERNEL | GFP_DMA);
if (!nfc_dev->kbuf) {
nfc_misc_unregister(nfc_dev, count);
return -ENOMEM;
}
nfc_dev->cold_reset.rsp_pending = false;
nfc_dev->cold_reset.is_nfc_enabled = false;
nfc_dev->cold_reset.is_crp_en = false;
nfc_dev->cold_reset.last_src_ese_prot = ESE_COLD_RESET_ORIGIN_NONE;
init_waitqueue_head(&nfc_dev->cold_reset.read_wq);
return 0;
}
/**
* nfc_gpio_info() - gets the status of nfc gpio pins and encodes into a byte.
* @nfc_dev: nfc device data structure
* @arg: userspace buffer
*
* Encoding can be done in following manner
* 1) map the gpio value into INVALID(-2), SET(1), RESET(0).
* 2) mask the first 2 bits of gpio.
* 3) left shift the 2 bits as multiple of 2.
* 4) multiply factor can be defined as position of gpio pin in struct platform_gpio
*
* Return: -EFAULT, if unable to copy the data from kernel space to userspace, 0
* if Success(or no issue)
*/
static int nfc_gpio_info(struct nfc_dev *nfc_dev, unsigned long arg)
{
unsigned int gpios_status = 0;
int value = 0;
int gpio_no = 0;
int i;
int ret = 0;
struct platform_gpio *nfc_gpio = &nfc_dev->configs.gpio;
for (i = 0; i < sizeof(struct platform_gpio) / sizeof(unsigned int);
i++) {
gpio_no = *((unsigned int *)nfc_gpio + i);
value = get_valid_gpio(gpio_no);
if (value < 0)
value = -2;
gpios_status |= (value & GPIO_STATUS_MASK_BITS)<<(GPIO_POS_SHIFT_VAL*i);
}
ret = copy_to_user((uint32_t *) arg, &gpios_status, sizeof(value));
if (ret < 0) {
pr_err("NxpDrv: %s : Unable to copy data from kernel space to user space", __func__);
return -EFAULT;
}
return 0;
}
/**
* nfc_ioctl_power_states() - power control
* @nfc_dev: nfc device data structure
* @arg: mode that we want to move to
*
* Device power control. Depending on the arg value, device moves to
* different states, refer common.h for args
*
* Return: -ENOIOCTLCMD if arg is not supported, 0 if Success(or no issue)
* and error ret code otherwise
*/
static int nfc_ioctl_power_states(struct nfc_dev *nfc_dev, unsigned long arg)
{
int ret = 0;
struct platform_gpio *nfc_gpio = &nfc_dev->configs.gpio;
if (arg == NFC_POWER_OFF) {
/*
* We are attempting a hardware reset so let us disable
* interrupts to avoid spurious notifications to upper
* layers.
*/
nfc_dev->nfc_disable_intr(nfc_dev);
set_valid_gpio(nfc_gpio->dwl_req, 0);
gpio_set_ven(nfc_dev, 0);
nfc_dev->nfc_ven_enabled = false;
nfc_dev->nfc_state = NFC_STATE_NCI;
} else if (arg == NFC_POWER_ON) {
nfc_dev->nfc_enable_intr(nfc_dev);
set_valid_gpio(nfc_gpio->dwl_req, 0);
gpio_set_ven(nfc_dev, 1);
nfc_dev->nfc_ven_enabled = true;
nfc_dev->nfc_state = NFC_STATE_NCI;
} else if (arg == NFC_FW_DWL_VEN_TOGGLE) {
/*
* We are switching to download Mode, toggle the enable pin
* in order to set the NFCC in the new mode
*/
nfc_dev->nfc_disable_intr(nfc_dev);
set_valid_gpio(nfc_gpio->dwl_req, 1);
nfc_dev->nfc_state = NFC_STATE_FW_DWL;
gpio_set_ven(nfc_dev, 0);
gpio_set_ven(nfc_dev, 1);
nfc_dev->nfc_enable_intr(nfc_dev);
} else if (arg == NFC_FW_DWL_HIGH) {
/*
* Setting firmware download gpio to HIGH
* before FW download start
*/
pr_debug("NxpDrv: set fw gpio high\n");
set_valid_gpio(nfc_gpio->dwl_req, 1);
nfc_dev->nfc_state = NFC_STATE_FW_DWL;
} else if (arg == NFC_VEN_FORCED_HARD_RESET) {
nfc_dev->nfc_disable_intr(nfc_dev);
gpio_set_ven(nfc_dev, 0);
gpio_set_ven(nfc_dev, 1);
nfc_dev->nfc_enable_intr(nfc_dev);
pr_info("NxpDrv: %s VEN forced reset done\n", __func__);
} else if (arg == NFC_FW_DWL_LOW) {
/*
* Setting firmware download gpio to LOW
* FW download finished
*/
pr_debug("NxpDrv: set fw gpio LOW\n");
set_valid_gpio(nfc_gpio->dwl_req, 0);
nfc_dev->nfc_state = NFC_STATE_NCI;
} else if (arg == NFC_ENABLE) {
if (nfc_dev->configs.clk_pin_voting) {
/* Enabling nfc clock */
ret = nfc_clock_select(nfc_dev);
if (ret)
pr_err("%s unable to select clock\n", __func__);
}
/* Setting flag true when NFC is enabled */
nfc_dev->cold_reset.is_nfc_enabled = true;
} else if (arg == NFC_DISABLE) {
if (nfc_dev->configs.clk_pin_voting) {
/* Disabling nfc clock */
ret = nfc_clock_deselect(nfc_dev);
if (ret)
pr_err("%s unable to disable clock\n", __func__);
}
/* Setting flag true when NFC is disabled */
nfc_dev->cold_reset.is_nfc_enabled = false;
} else {
pr_err("NxpDrv: %s: bad arg %lu\n", __func__, arg);
ret = -ENOIOCTLCMD;
}
return ret;
}
#ifdef CONFIG_COMPAT
/**
* nfc_dev_compat_ioctl - used to set or get data from upper layer.
* @pfile file node for opened device.
* @cmd ioctl type from upper layer.
* @arg ioctl arg from upper layer.
*
* NFC and ESE Device power control, based on the argument value
*
* Return: -ENOIOCTLCMD if arg is not supported
* 0 if Success(or no issue)
* 0 or 1 in case of arg is ESE_GET_PWR/ESE_POWER_STATE
* and error ret code otherwise
*/
long nfc_dev_compat_ioctl(struct file *pfile, unsigned int cmd,
unsigned long arg)
{
int ret = 0;
arg = (compat_u64) arg;
pr_debug("NxpDrv: %s: cmd = %x arg = %zx\n", __func__, cmd, arg);
ret = nfc_dev_ioctl(pfile, cmd, arg);
return ret;
}
#endif
/**
* nfc_post_init() - Configuraing Ven GPIO and hardware check
* @nfc_dev: nfc device data structure
*
* Configure GPIOs post notification from TZ, ensuring it's a non-secure zone.
*
* Return: 0 if Success(or no issue) and error ret code otherwise
*/
int nfc_post_init(struct nfc_dev *nfc_dev)
{
int ret=0;
unsigned int clkreq_gpio = 0;
static int post_init_success;
struct platform_configs nfc_configs;
struct platform_gpio *nfc_gpio;
if(post_init_success)
return 0;
if (!nfc_dev)
return -ENODEV;
memcpy(&nfc_configs, &nfc_dev->configs, sizeof(struct platform_configs));
nfc_gpio = &nfc_configs.gpio;
ret = configure_gpio(nfc_gpio->ven, GPIO_OUTPUT);
if (ret) {
pr_err("NxpDrv: %s: unable to request nfc reset gpio [%d]\n",
__func__, nfc_gpio->ven);
return ret;
}
ret = configure_gpio(nfc_gpio->dwl_req, GPIO_OUTPUT);
if (ret) {
pr_err("NxpDrv: %s: unable to request nfc firm downl gpio [%d]\n",
__func__, nfc_gpio->dwl_req);
}
ret = configure_gpio(nfc_gpio->clkreq, GPIO_INPUT);
if (ret) {
pr_err("NxpDrv: %s: unable to request nfc clkreq gpio [%d]\n",
__func__, nfc_gpio->clkreq);
}
/* Read clkreq GPIO number from device tree*/
ret = of_property_read_u32_index(nfc_dev->i2c_dev.client->dev.of_node,
DTS_CLKREQ_GPIO_STR, 1, &clkreq_gpio);
if (ret < 0) {
pr_err("NxpDrv: %s Failed to read clkreq gipo number, ret: %d\n",
__func__, ret);
return ret;
}
/* configure clkreq GPIO as wakeup capable */
ret = msm_gpio_mpm_wake_set(clkreq_gpio, true);
if (ret < 0) {
pr_err("NxpDrv: %s clkreq gpio %d as wakeup capable failed, ret: %d\n",
__func__, clkreq_gpio, ret);
return ret;
}
ret = nfcc_hw_check(nfc_dev);
if (ret || nfc_dev->nfc_state == NFC_STATE_UNKNOWN) {
pr_err("NxpDrv: nfc hw check failed ret %d\n", ret);
gpio_free(nfc_gpio->dwl_req);
gpio_free(nfc_gpio->ven);
return ret;
}
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
/*Initialising sempahore to disbale NFC Ven GPIO only after eSE is power off flag is set */
if (nfc_dev->configs.CNSS_NFC_HW_SECURE_ENABLE == true) {
sema_init(&sem_eSE_pwr_off,0);
}
#endif
post_init_success = 1;
pr_info("NxpDrv: %s success\n", __func__);
return 0;
}
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
/**
* nfc_hw_secure_check() - Checks the NFC secure zone status
*
* Queries the TZ secure libraries if NFC is in secure zone statue or not.
*
* Return: 0 if FEATURE_NOT_SUPPORTED or PERIPHERAL_NOT_FOUND or nfc_sec_state = 2(non-secure zone) and
* return 1 if nfc_sec_state = 1(secure zone) or error otherwise
*/
bool nfc_hw_secure_check(void)
{
struct Object client_env;
struct Object app_object;
u32 nfc_uid = HW_NFC_UID;
union ObjectArg obj_arg[2] = {{{0, 0}}};
int ret;
bool retstat = 1;
u8 nfc_sec_state = 0;
/* get rootObj */
ret = get_client_env_object(&client_env);
if (ret) {
pr_err("NxpDrv: Failed to get client_env_object, ret: %d\n", ret);
return retstat;
}
ret = IClientEnv_open(client_env, HW_STATE_UID, &app_object);
if (ret) {
pr_debug("NxpDrv: Failed to get app_object, ret: %d\n", ret);
if (ret == FEATURE_NOT_SUPPORTED) {
retstat = 0; /* Do not Assert */
pr_debug("NxpDrv: Secure HW feature not supported\n");
}
goto exit_release_clientenv;
}
obj_arg[0].b = (struct ObjectBuf) {&nfc_uid, sizeof(u32)};
obj_arg[1].b = (struct ObjectBuf) {&nfc_sec_state, sizeof(u8)};
ret = Object_invoke(app_object, HW_OP_GET_STATE, obj_arg,
ObjectCounts_pack(1, 1, 0, 0));
pr_info("NxpDrv: TZ ret: %d nfc_sec_state: %d\n", ret, nfc_sec_state);
if (ret) {
if (ret == PERIPHERAL_NOT_FOUND) {
retstat = 0; /* Do not Assert */
pr_debug("NxpDrv: Secure HW mode is not updated. Peripheral not found\n");
}
goto exit_release_app_obj;
}
secure_peripheral_not_found = false;
/* Refer peripheral state utilities for different states of NFC peripherals */
if (nfc_sec_state == 1) {
/*Secure Zone*/
retstat = 1;
} else {
/*Non-Secure Zone*/
retstat = 0;
}
exit_release_app_obj:
Object_release(app_object);
exit_release_clientenv:
Object_release(client_env);
return retstat;
}
/**
* nfc_dynamic_protection_ioctl() - dynamic protection control
* @nfc_dev: nfc device data structure
* @sec_zone_trans: mode that we want to move to
* If sec_zone_trans = 1; transition from non-secure zone to secure zone
* If sec_zone_trans = 0; transition from secure zone to non - secure zone
*
* nfc periheral dynamic protection control. Depending on the sec_zone_trans value, device moves to
* secure zone and non-secure zone
*
* Return: -ENOIOCTLCMD if sec_zone_trans val is not supported, 0 if Success(or no issue)
* and error ret code otherwise
*/
int nfc_dynamic_protection_ioctl(struct nfc_dev *nfc_dev, unsigned long sec_zone_trans)
{
int ret = 0;
static int init_flag=1;
struct platform_gpio *nfc_gpio = &nfc_dev->configs.gpio;
if(sec_zone_trans == 1) {
/*check NFC is disabled, only then set Ven GPIO low*/
if(nfc_dev->cold_reset.is_nfc_enabled == false) {
pr_debug("NxpDrv: %s: value %d\n", __func__, gpio_get_value(nfc_gpio->ven));
chk_eSE_pwr_off = 1;
/*check if eSE is active, if yes, wait max of 1sec, until it's inactive */
if(nfc_dev->is_ese_session_active == true) {
if(down_timeout(&sem_eSE_pwr_off, msecs_to_jiffies(1000))) {
/*waited for 1sec yet eSE not turned off, so, ignoring eSE power off*/
pr_info("NxpDrv: Forcefull shutdown of eSE\n");
}
}
ret = nfc_ioctl_power_states(nfc_dev, 0);
/*set driver as secure zone, such that no ioctl calls are allowed*/
nfc_dev->secure_zone = true;
pr_info("NxpDrv: Driver Secure flag set successful\n");
} else {
ret = -1;
}
}
else if(sec_zone_trans == 0) {
chk_eSE_pwr_off = 0;
nfc_dev->secure_zone = false;
if(init_flag) {
/*Initialize once,only during the first non-secure entry*/
ret = nfc_post_init(nfc_dev);
if(ret == 0)
init_flag=0;
}
else {
if(!gpio_get_value(nfc_gpio->ven))
ret = nfc_ioctl_power_states(nfc_dev, 1);
}
pr_info("NxpDrv: Func Driver Secure flag clear successful\n");
} else {
pr_info("NxpDrv: INVALID ARG\n");
ret = -ENOIOCTLCMD;
}
return ret;
}
#endif
/**
* nfc_dev_ioctl - used to set or get data from upper layer.
* @pfile file node for opened device.
* @cmd ioctl type from upper layer.
* @arg ioctl arg from upper layer.
*
* NFC and ESE Device power control, based on the argument value
*
* Return: -ENOIOCTLCMD if arg is not supported
* 0 if Success(or no issue)
* 0 or 1 in case of arg is ESE_GET_PWR/ESE_POWER_STATE
* and error ret code otherwise
*/
long nfc_dev_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
{
int ret = 0;
struct nfc_dev *nfc_dev = pfile->private_data;
if (!nfc_dev)
return -ENODEV;
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
if( nfc_dev->configs.CNSS_NFC_HW_SECURE_ENABLE == true) {
/*Avoiding ioctl call in secure zone*/
if(nfc_dev->secure_zone) {
if(cmd!=NFC_SECURE_ZONE) {
pr_debug("NxpDrv: nfc_dev_ioctl failed\n");
return -1;
}
}
}
#endif
pr_debug("NxpDrv: %s: cmd = %x arg = %zx\n", __func__, cmd, arg);
switch (cmd) {
case NFC_SET_PWR:
ret = nfc_ioctl_power_states(nfc_dev, arg);
break;
case NFC_SET_RESET_READ_PENDING:
if (arg == NFC_SET_READ_PENDING) {
nfc_dev->cold_reset.is_nfc_read_pending = true;
/* Set default NFC state as NCI for Nfc read pending request */
nfc_dev->nfc_state = NFC_STATE_NCI;
} else if (arg == NFC_RESET_READ_PENDING) {
nfc_dev->cold_reset.is_nfc_read_pending = false;
} else {
ret = -EINVAL;
}
break;
case ESE_SET_PWR:
ret = nfc_ese_pwr(nfc_dev, arg);
break;
case ESE_GET_PWR:
ret = nfc_ese_pwr(nfc_dev, ESE_POWER_STATE);
break;
case NFC_GET_GPIO_STATUS:
ret = nfc_gpio_info(nfc_dev, arg);
break;
case NFCC_GET_INFO:
ret = nfc_ioctl_nfcc_info(pfile, arg);
break;
case ESE_COLD_RESET:
pr_debug("NxpDrv: nfc ese cold reset ioctl\n");
ret = ese_cold_reset_ioctl(nfc_dev, arg);
break;
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
case NFC_SECURE_ZONE:
if( nfc_dev->configs.CNSS_NFC_HW_SECURE_ENABLE == true) {
ret = nfc_dynamic_protection_ioctl(nfc_dev, arg);
}
break;
#endif
default:
pr_err("NxpDrv: %s: bad cmd %lu\n", __func__, arg);
ret = -ENOIOCTLCMD;
}
return ret;
}
int nfc_dev_open(struct inode *inode, struct file *filp)
{
struct nfc_dev *nfc_dev = NULL;
nfc_dev = container_of(inode->i_cdev, struct nfc_dev, c_dev);
if (!nfc_dev)
return -ENODEV;
pr_debug("NxpDrv: %s: %d, %d\n", __func__, imajor(inode), iminor(inode));
/* Set flag to block freezer fake signal if not set already.
* Without this Signal being set, Driver is trying to do a read
* which is causing the delay in moving to Hibernate Mode.
*/
if (!(current->flags & PF_NOFREEZE)) {
current->flags |= PF_NOFREEZE;
pr_debug("NxpDrv: %s: current->flags 0x%x. \n", __func__, current->flags);
}
mutex_lock(&nfc_dev->dev_ref_mutex);
filp->private_data = nfc_dev;
if (nfc_dev->dev_ref_count == 0) {
set_valid_gpio(nfc_dev->configs.gpio.dwl_req, 0);
nfc_dev->nfc_enable_intr(nfc_dev);
}
nfc_dev->dev_ref_count = nfc_dev->dev_ref_count + 1;
mutex_unlock(&nfc_dev->dev_ref_mutex);
return 0;
}
int nfc_dev_flush(struct file *pfile, fl_owner_t id)
{
struct nfc_dev *nfc_dev = pfile->private_data;
if (!nfc_dev)
return -ENODEV;
/*
* release blocked user thread waiting for pending read during close
*/
if (!mutex_trylock(&nfc_dev->read_mutex)) {
nfc_dev->release_read = true;
nfc_dev->nfc_disable_intr(nfc_dev);
wake_up(&nfc_dev->read_wq);
pr_debug("NxpDrv: %s: waiting for release of blocked read\n", __func__);
mutex_lock(&nfc_dev->read_mutex);
nfc_dev->release_read = false;
} else {
pr_debug("NxpDrv: %s: read thread already released\n", __func__);
}
mutex_unlock(&nfc_dev->read_mutex);
return 0;
}
int nfc_dev_close(struct inode *inode, struct file *filp)
{
struct nfc_dev *nfc_dev = NULL;
nfc_dev = container_of(inode->i_cdev, struct nfc_dev, c_dev);
if (!nfc_dev)
return -ENODEV;
pr_debug("NxpDrv: %s: %d, %d\n", __func__, imajor(inode), iminor(inode));
/* unset the flag to restore to previous state */
if (current->flags & PF_NOFREEZE) {
current->flags &= ~PF_NOFREEZE;
pr_debug("NxpDrv: %s: current->flags 0x%x. \n", __func__, current->flags);
}
mutex_lock(&nfc_dev->dev_ref_mutex);
if (nfc_dev->dev_ref_count == 1) {
nfc_dev->nfc_disable_intr(nfc_dev);
set_valid_gpio(nfc_dev->configs.gpio.dwl_req, 0);
}
if (nfc_dev->dev_ref_count > 0)
nfc_dev->dev_ref_count = nfc_dev->dev_ref_count - 1;
filp->private_data = NULL;
mutex_unlock(&nfc_dev->dev_ref_mutex);
return 0;
}
int validate_nfc_state_nci(struct nfc_dev *nfc_dev)
{
struct platform_gpio *nfc_gpio = &nfc_dev->configs.gpio;
if(!nfc_dev->secure_zone) {
if (!gpio_get_value(nfc_gpio->ven)) {
pr_err("NxpDrv: %s: ven low - nfcc powered off\n", __func__);
return -ENODEV;
}
}
if (get_valid_gpio(nfc_gpio->dwl_req) == 1) {
pr_err("NxpDrv: %s: fw download in-progress\n", __func__);
return -EBUSY;
}
if (nfc_dev->nfc_state != NFC_STATE_NCI) {
pr_err("NxpDrv: %s: fw download state\n", __func__);
return -EBUSY;
}
return 0;
}

334
nxp/opensource/driver/nfc/common.h Normal file
View File

@@ -0,0 +1,334 @@
/******************************************************************************
* Copyright (C) 2015, The Linux Foundation. All rights reserved.
* Copyright (C) 2019-2022 NXP
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
******************************************************************************/
/*
* Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.
*****************************************************************************/
#ifndef _COMMON_H_
#define _COMMON_H_
#include <linux/cdev.h>
#include <linux/of_gpio.h>
#include <linux/delay.h>
#include <linux/ipc_logging.h>
#include <linux/clk.h>
#include <nfcinfo.h>
#include <sn_uapi.h>
#include "i2c_drv.h"
#include "ese_cold_reset.h"
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
/*secure library headers*/
#include "smcinvoke_object.h"
#include "IClientEnv.h"
#endif
/* Max device count for this driver */
#define DEV_COUNT 1
/* i2c device class */
#define CLASS_NAME "qti-nfc"
/* NFC character device name, this will be in /dev/ */
#define NFC_CHAR_DEV_NAME "nq-nci"
/* NCI packet details */
#define NCI_CMD (0x20)
#define NCI_RSP (0x40)
#define NCI_NTF (0x60)
#define NCI_HDR_LEN (3)
#define NCI_HDR_IDX (0)
#define DL_CMD 0x00
#define DL_PAYLOAD_BYTE_ZERO 0x00
#define NCI_HDR_OID_IDX (1)
#define NCI_PAYLOAD_IDX (3)
#define NCI_PAYLOAD_LEN_IDX (2)
/*Time to wait for first NCI rest response*/
#define NCI_RESET_RESP_READ_DELAY (10000) // 10ms
#define NCI_RESET_RESP_TIMEOUT (500) // 500ms
// FW DNLD packet details
#define FW_MSG_CMD_RSP 0x00
#define DL_HDR_LEN (2)
#define DL_CRC_LEN (2)
#define NCI_RSP_PKT_TYPE (0x40)
#define MAX_NCI_PAYLOAD_LEN (255)
#define MAX_NCI_BUFFER_SIZE (NCI_HDR_LEN + MAX_NCI_PAYLOAD_LEN)
/*
* From MW 11.04 buffer size increased to support
* frame size of 554 in FW download mode
* Frame len(2) + Frame Header(6) + DATA(512) + HASH(32) + CRC(2) + RFU(4)
*/
#define MAX_DL_PAYLOAD_LEN (550)
#define MAX_DL_BUFFER_SIZE (DL_HDR_LEN + DL_CRC_LEN + \
MAX_DL_PAYLOAD_LEN)
/* Retry count for normal write */
#define NO_RETRY (1)
/* Maximum retry count for standby writes */
#define MAX_RETRY_COUNT (3)
#define MAX_WRITE_IRQ_COUNT (5)
#define MAX_IRQ_WAIT_TIME (90)
#define WAKEUP_SRC_TIMEOUT (100)
/* command response timeout */
#define NCI_CMD_RSP_TIMEOUT_MS (2000)
/* Time to wait for NFCC to be ready again after any change in the GPIO */
#define NFC_GPIO_SET_WAIT_TIME_US (10000)
/* Time to wait before retrying writes */
#define WRITE_RETRY_WAIT_TIME_US (3000)
/* Time to wait before retrying read for some specific usecases */
#define READ_RETRY_WAIT_TIME_US (3500)
#define DTS_IRQ_GPIO_STR "qcom,sn-irq"
#define DTS_VEN_GPIO_STR "qcom,sn-ven"
#define DTS_FWDN_GPIO_STR "qcom,sn-firm"
#define DTS_CLKREQ_GPIO_STR "qcom,sn-clkreq"
#define DTS_CLKSRC_GPIO_STR "qcom,clk-src"
#define DTS_SZONE_STR "qcom,sn-szone"
#define NFC_LDO_SUPPLY_DT_NAME "qcom,sn-vdd-1p8"
#define NFC_LDO_SUPPLY_NAME "qcom,sn-vdd-1p8-supply"
#define NFC_LDO_VOL_DT_NAME "qcom,sn-vdd-1p8-voltage"
#define NFC_LDO_CUR_DT_NAME "qcom,sn-vdd-1p8-current"
//as per SN1x0 datasheet
#define NFC_VDDIO_MIN 1650000 //in uV
#define NFC_VDDIO_MAX 1950000 //in uV
#define NFC_CURRENT_MAX 157000 //in uA
/* Each GPIO occupies consecutive two bits */
#define GPIO_POS_SHIFT_VAL 2
/* Two bits to indicate GPIO status (Invalid(-2), Set(1) or Reset(0)) */
#define GPIO_STATUS_MASK_BITS 3
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
//NFC ID for registration with secure libraries
#define HW_STATE_UID 0x108
#define HW_OP_GET_STATE 1
#define HW_NFC_UID 0x506
#define FEATURE_NOT_SUPPORTED 12
#define PERIPHERAL_NOT_FOUND 10
#endif
#define NUM_OF_IPC_LOG_PAGES (2)
#define PKT_MAX_LEN (4) // no of max bytes to print for cmd/resp
#define GET_IPCLOG_MAX_PKT_LEN(c) ((c > PKT_MAX_LEN) ? PKT_MAX_LEN : c)
#define NFCLOG_IPC(nfc_dev, log_to_dmesg, x...) \
do { \
ipc_log_string(nfc_dev->ipcl, x); \
if (log_to_dmesg) { \
if (nfc_dev->nfc_device) \
dev_err((nfc_dev->nfc_device), x); \
else \
pr_err(x); \
} \
} while (0)
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
static struct semaphore sem_eSE_pwr_off;
static bool chk_eSE_pwr_off;
#endif
enum ese_ioctl_request {
/* eSE POWER ON */
ESE_POWER_ON = 0,
/* eSE POWER OFF */
ESE_POWER_OFF,
/* eSE POWER STATE */
ESE_POWER_STATE
};
enum nfcc_ioctl_request {
/* NFC disable request with VEN LOW */
NFC_POWER_OFF = 0,
/* NFC enable request with VEN Toggle */
NFC_POWER_ON,
/* firmware download request with VEN Toggle */
NFC_FW_DWL_VEN_TOGGLE,
/* ISO reset request */
NFC_ISO_RESET,
/* request for firmware download gpio HIGH */
NFC_FW_DWL_HIGH,
/* VEN hard reset request */
NFC_VEN_FORCED_HARD_RESET,
/* request for firmware download gpio LOW */
NFC_FW_DWL_LOW,
/* NFC enable without VEN gpio modification */
NFC_ENABLE,
/* NFC disable without VEN gpio modification */
NFC_DISABLE,
};
enum nfc_read_pending {
NFC_RESET_READ_PENDING,
NFC_SET_READ_PENDING,
};
/* nfc platform interface type */
enum interface_flags {
/* I2C physical IF for NFCC */
PLATFORM_IF_I2C = 0,
};
/* nfc state flags */
enum nfc_state_flags {
/* nfc in unknown state */
NFC_STATE_UNKNOWN = 0,
/* nfc in download mode */
NFC_STATE_FW_DWL = 0x1,
/* nfc booted in NCI mode */
NFC_STATE_NCI = 0x2,
/* nfc booted in Fw teared mode */
NFC_STATE_FW_TEARED = 0x4,
};
/*
* Power state for IBI handing, mainly needed to defer the IBI handling
* for the IBI received in suspend state to do it later in resume call
*/
enum pm_state_flags {
PM_STATE_NORMAL = 0,
PM_STATE_SUSPEND,
PM_STATE_IBI_BEFORE_RESUME,
};
/* Enum for GPIO values */
enum gpio_values {
GPIO_INPUT = 0x0,
GPIO_OUTPUT = 0x1,
GPIO_HIGH = 0x2,
GPIO_OUTPUT_HIGH = 0x3,
GPIO_IRQ = 0x4,
};
/* NFC GPIO variables */
struct platform_gpio {
unsigned int irq;
unsigned int ven;
unsigned int clkreq;
unsigned int dwl_req;
};
// NFC LDO entries from DT
struct platform_ldo {
int vdd_levels[2];
int max_current;
};
/* NFC Struct to get all the required configs from DTS */
struct platform_configs {
struct platform_gpio gpio;
struct platform_ldo ldo;
const char *clk_src_name;
/* NFC_CLK pin voting state */
bool clk_pin_voting;
const char *szone;
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
bool CNSS_NFC_HW_SECURE_ENABLE;
#endif
};
/* Device specific structure */
struct nfc_dev {
wait_queue_head_t read_wq;
struct mutex read_mutex;
struct mutex write_mutex;
uint8_t *read_kbuf;
uint8_t *write_kbuf;
struct mutex dev_ref_mutex;
unsigned int dev_ref_count;
struct class *nfc_class;
struct device *nfc_device;
struct cdev c_dev;
dev_t devno;
/* Interface flag */
uint8_t interface;
/* nfc state flags */
uint8_t nfc_state;
/* NFC VEN pin state */
bool nfc_ven_enabled;
/* current firmware major version */
uint8_t fw_major_version;
bool is_vreg_enabled;
bool is_ese_session_active;
bool release_read;
union {
struct i2c_dev i2c_dev;
};
struct platform_configs configs;
struct cold_reset cold_reset;
struct regulator *reg;
/* read buffer*/
size_t kbuflen;
u8 *kbuf;
union nqx_uinfo nqx_info;
/*secure zone state*/
bool secure_zone;
/* CLK control */
bool clk_run;
struct clk *s_clk;
void *ipcl;
/* function pointers for the common i2c functionality */
int (*nfc_read)(struct nfc_dev *dev, char *buf, size_t count,
int timeout);
int (*nfc_write)(struct nfc_dev *dev, const char *buf,
const size_t count, int max_retry_cnt);
int (*nfc_enable_intr)(struct nfc_dev *dev);
int (*nfc_disable_intr)(struct nfc_dev *dev);
};
int nfc_dev_open(struct inode *inode, struct file *filp);
int nfc_dev_flush(struct file *pfile, fl_owner_t id);
int nfc_dev_close(struct inode *inode, struct file *filp);
long nfc_dev_compat_ioctl(struct file *pfile, unsigned int cmd,
unsigned long arg);
long nfc_dev_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg);
int nfc_parse_dt(struct device *dev, struct platform_configs *nfc_configs,
uint8_t interface);
int nfc_misc_register(struct nfc_dev *nfc_dev,
const struct file_operations *nfc_fops, int count,
char *devname, char *classname);
void nfc_misc_unregister(struct nfc_dev *nfc_dev, int count);
int configure_gpio(unsigned int gpio, int flag);
void gpio_set_ven(struct nfc_dev *nfc_dev, int value);
void set_valid_gpio(int gpio, int value);
int nfcc_hw_check(struct nfc_dev *nfc_dev);
unsigned int nfc_ioctl_nfcc_info(struct file *, unsigned long);
void gpio_free_all(struct nfc_dev *nfc_dev);
int nfc_ldo_config(struct device *dev, struct nfc_dev *nfc_dev);
int nfc_ldo_vote(struct nfc_dev *nfc_dev);
int nfc_ese_pwr(struct nfc_dev *nfc_dev, unsigned long arg);
int nfc_ldo_unvote(struct nfc_dev *nfc_dev);
int is_nfc_data_available_for_read(struct nfc_dev *nfc_dev);
int validate_nfc_state_nci(struct nfc_dev *nfc_dev);
int nfc_clock_select(struct nfc_dev *nfc_dev);
int nfc_clock_deselect(struct nfc_dev *nfc_dev);
int nfc_post_init(struct nfc_dev *nfc_dev);
int nfc_dynamic_protection_ioctl(struct nfc_dev *nfc_dev, unsigned long sec_zone_trans);
bool nfc_hw_secure_check(void);
#endif /* _COMMON_H_ */

333
nxp/opensource/driver/nfc/common_nxp.c Normal file
View File

@@ -0,0 +1,333 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2015-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2019-2021 NXP
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
******************************************************************************/
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*
******************************************************************************/
#include "common.h"
#include "common_nxp.h"
/**
* get_nfcc_chip_type_dl() - get chip type in fw download command;
* @nfc_dev: nfc device data structure
*
* Perform get version command and determine chip
* type from response.
*
* @Return: enum chip_types value
*
*/
static enum chip_types get_nfcc_chip_type_dl(struct nfc_dev *nfc_dev)
{
int ret = 0;
uint8_t *cmd = nfc_dev->write_kbuf;
uint8_t *rsp = nfc_dev->read_kbuf;
enum chip_types chip_type = CHIP_UNKNOWN;
*cmd++ = DL_CMD;
*cmd++ = DL_GET_VERSION_CMD_PAYLOAD_LEN;
*cmd++ = DL_GET_VERSION_CMD_ID;
*cmd++ = DL_PAYLOAD_BYTE_ZERO;
*cmd++ = DL_PAYLOAD_BYTE_ZERO;
*cmd++ = DL_PAYLOAD_BYTE_ZERO;
*cmd++ = DL_GET_VERSION_CMD_CRC_1;
*cmd++ = DL_GET_VERSION_CMD_CRC_2;
pr_debug("NxpDrv: %s:Sending GET_VERSION cmd of size = %d\n", __func__, DL_GET_VERSION_CMD_LEN);
ret = nfc_dev->nfc_write(nfc_dev, nfc_dev->write_kbuf, DL_GET_VERSION_CMD_LEN,
MAX_RETRY_COUNT);
if (ret <= 0) {
pr_err("NxpDrv: %s: - nfc get version cmd error ret %d\n", __func__, ret);
goto err;
}
memset(rsp, 0x00, DL_GET_VERSION_RSP_LEN_2);
pr_debug("NxpDrv: %s:Reading response of GET_VERSION cmd\n", __func__);
ret = nfc_dev->nfc_read(nfc_dev, rsp, DL_GET_VERSION_RSP_LEN_2, NCI_CMD_RSP_TIMEOUT_MS);
if (ret <= 0) {
pr_err("NxpDrv: %s: - nfc get version rsp error ret %d\n", __func__, ret);
goto err;
}
if (rsp[0] == FW_MSG_CMD_RSP && ret >= DL_GET_VERSION_RSP_LEN_2) {
nfc_dev->fw_major_version = rsp[FW_MAJOR_VER_OFFSET];
if (rsp[FW_ROM_CODE_VER_OFFSET] == SN1XX_ROM_VER &&
rsp[FW_MAJOR_VER_OFFSET] == SN1xx_MAJOR_VER)
chip_type = CHIP_SN1XX;
else if (rsp[FW_ROM_CODE_VER_OFFSET] == SN220_ROM_VER &&
rsp[FW_MAJOR_VER_OFFSET] == SN220_MAJOR_VER)
chip_type = CHIP_SN220;
pr_debug("NxpDrv: %s:NFC Chip Type 0x%02x Rom Version 0x%02x FW Minor 0x%02x Major 0x%02x\n",
__func__, rsp[GET_VERSION_RSP_CHIP_TYPE_OFFSET],
rsp[FW_ROM_CODE_VER_OFFSET],
rsp[GET_VERSION_RSP_MINOR_VERSION_OFFSET],
rsp[FW_MAJOR_VER_OFFSET]);
nfc_dev->nqx_info.info.chip_type = rsp[GET_VERSION_RSP_CHIP_TYPE_OFFSET];
nfc_dev->nqx_info.info.rom_version = rsp[FW_ROM_CODE_VER_OFFSET];
nfc_dev->nqx_info.info.fw_minor = rsp[GET_VERSION_RSP_MINOR_VERSION_OFFSET];
nfc_dev->nqx_info.info.fw_major = rsp[FW_MAJOR_VER_OFFSET];
}
err:
return chip_type;
}
/**
* get_nfcc_session_state_dl() - gets the session state
* @nfc_dev: nfc device data structure
*
* Performs get session command and determine
* the nfcc state based on session status.
*
* @Return nfcc state based on session status.
* NFC_STATE_FW_TEARED if sessionis not closed
* NFC_STATE_FW_DWL if session closed
* NFC_STATE_UNKNOWN in error cases.
*/
enum nfc_state_flags get_nfcc_session_state_dl(struct nfc_dev *nfc_dev)
{
int ret = 0;
uint8_t *cmd = nfc_dev->write_kbuf;
uint8_t *rsp = nfc_dev->read_kbuf;
enum nfc_state_flags nfc_state = NFC_STATE_UNKNOWN;
*cmd++ = DL_CMD;
*cmd++ = DL_GET_SESSION_STATE_CMD_PAYLOAD_LEN;
*cmd++ = DL_GET_SESSION_CMD_ID;
*cmd++ = DL_PAYLOAD_BYTE_ZERO;
*cmd++ = DL_PAYLOAD_BYTE_ZERO;
*cmd++ = DL_PAYLOAD_BYTE_ZERO;
*cmd++ = DL_GET_SESSION_CMD_CRC_1;
*cmd++ = DL_GET_SESSION_CMD_CRC_2;
pr_debug("NxpDrv: %s:Sending GET_SESSION_STATE cmd of size = %d\n", __func__,
DL_GET_SESSION_STATE_CMD_LEN);
ret = nfc_dev->nfc_write(nfc_dev, nfc_dev->write_kbuf, DL_GET_SESSION_STATE_CMD_LEN,
MAX_RETRY_COUNT);
if (ret <= 0) {
pr_err("NxpDrv: %s: - nfc get session cmd error ret %d\n", __func__, ret);
goto err;
}
memset(rsp, 0x00, DL_GET_SESSION_STATE_RSP_LEN);
pr_debug("NxpDrv: %s:Reading response of GET_SESSION_STATE cmd\n", __func__);
ret = nfc_dev->nfc_read(nfc_dev, rsp, DL_GET_SESSION_STATE_RSP_LEN, NCI_CMD_RSP_TIMEOUT_MS);
if (ret <= 0) {
pr_err("NxpDrv: %s: - nfc get session rsp error ret %d\n", __func__, ret);
goto err;
}
if (rsp[0] != FW_MSG_CMD_RSP) {
pr_err("NxpDrv: %s: - nfc invalid get session state rsp\n", __func__);
goto err;
}
pr_debug("NxpDrv: Response bytes are %02x%02x%02x%02x%02x%02x%02x%02x\n",
rsp[0], rsp[1], rsp[2], rsp[3], rsp[4], rsp[5], rsp[6], rsp[7]);
/*verify fw in non-teared state */
if (rsp[GET_SESSION_STS_OFF] != NFCC_SESSION_STS_CLOSED) {
pr_err("NxpDrv: %s NFCC booted in FW teared state\n", __func__);
nfc_state = NFC_STATE_FW_TEARED;
} else {
pr_info("NxpDrv: %s NFCC booted in FW DN mode\n", __func__);
nfc_state = NFC_STATE_FW_DWL;
}
err:
return nfc_state;
}
/**
* get_nfcc_chip_type() - get nfcc chip type in nci mode.
* @nfc_dev: nfc device data structure.
*
* Function to perform nci core reset and extract
* chip type from the response.
*
* @Return: enum chip_types value
*
*/
static enum chip_types get_nfcc_chip_type(struct nfc_dev *nfc_dev)
{
int ret = 0;
uint8_t major_version = 0;
uint8_t rom_version = 0;
uint8_t *cmd = nfc_dev->write_kbuf;
uint8_t *rsp = nfc_dev->read_kbuf;
enum chip_types chip_type = CHIP_UNKNOWN;
*cmd++ = NCI_CMD;
*cmd++ = NCI_CORE_RESET_CMD_OID;
*cmd++ = NCI_CORE_RESET_CMD_PAYLOAD_LEN;
*cmd++ = NCI_CORE_RESET_KEEP_CONFIG;
pr_debug("NxpDrv: %s:Sending NCI Core Reset cmd of size = %d\n", __func__, NCI_RESET_CMD_LEN);
ret = nfc_dev->nfc_write(nfc_dev, nfc_dev->write_kbuf, NCI_RESET_CMD_LEN, NO_RETRY);
if (ret <= 0) {
pr_err("NxpDrv: %s: - nfc nci core reset cmd error ret %d\n", __func__, ret);
goto err;
}
/* to flush out debug NTF this delay is required */
usleep_range(NCI_RESET_RESP_READ_DELAY, NCI_RESET_RESP_READ_DELAY + 100);
nfc_dev->nfc_enable_intr(nfc_dev);
memset(rsp, 0x00, NCI_RESET_RSP_LEN);
pr_debug("NxpDrv: %s:Reading NCI Core Reset rsp\n", __func__);
ret = nfc_dev->nfc_read(nfc_dev, rsp, NCI_RESET_RSP_LEN, NCI_CMD_RSP_TIMEOUT_MS);
if (ret <= 0) {
pr_err("NxpDrv: %s: - nfc nci core reset rsp error ret %d\n", __func__, ret);
goto err_disable_intr;
}
pr_debug("NxpDrv: %s: nci core reset response 0x%02x%02x%02x%02x\n",
__func__, rsp[0], rsp[1], rsp[2], rsp[3]);
if (rsp[0] != NCI_RSP) {
/* reset response failed response*/
pr_err("NxpDrv: %s invalid nci core reset response\n", __func__);
goto err_disable_intr;
}
memset(rsp, 0x00, NCI_RESET_NTF_LEN);
/* read nci rest response ntf */
ret = nfc_dev->nfc_read(nfc_dev, rsp, NCI_RESET_NTF_LEN, NCI_CMD_RSP_TIMEOUT_MS);
if (ret <= 0) {
pr_err("NxpDrv: %s - nfc nci rest rsp ntf error status %d\n", __func__, ret);
goto err_disable_intr;
}
if (rsp[0] == NCI_NTF) {
/* read version info from NCI Reset Notification */
rom_version = rsp[NCI_HDR_LEN + rsp[NCI_PAYLOAD_LEN_IDX] - 3];
major_version = rsp[NCI_HDR_LEN + rsp[NCI_PAYLOAD_LEN_IDX] - 2];
/* determine chip type based on version info */
if (rom_version == SN1XX_ROM_VER && major_version == SN1xx_MAJOR_VER)
chip_type = CHIP_SN1XX;
else if (rom_version == SN220_ROM_VER && major_version == SN220_MAJOR_VER)
chip_type = CHIP_SN220;
pr_debug("NxpDrv: %s:NCI Core Reset ntf 0x%02x%02x%02x%02x\n",
__func__, rsp[0], rsp[1], rsp[2], rsp[3]);
nfc_dev->nqx_info.info.chip_type = rsp[NCI_HDR_LEN + rsp[NCI_PAYLOAD_LEN_IDX] -
NFC_CHIP_TYPE_OFF];
nfc_dev->nqx_info.info.rom_version = rom_version;
nfc_dev->nqx_info.info.fw_major = major_version;
nfc_dev->nqx_info.info.fw_minor = rsp[NCI_HDR_LEN + rsp[NCI_PAYLOAD_LEN_IDX] -
NFC_FW_MINOR_OFF];
}
err_disable_intr:
nfc_dev->nfc_disable_intr(nfc_dev);
err:
return chip_type;
}
/**
* validate_download_gpio() - validate download gpio.
* @nfc_dev: nfc_dev device data structure.
* @chip_type: chip type of the platform.
*
* Validates dwnld gpio should configured for supported and
* should not be configured for unsupported platform.
*
* @Return: true if gpio validation successful ortherwise
* false if validation fails.
*/
static bool validate_download_gpio(struct nfc_dev *nfc_dev, enum chip_types chip_type)
{
bool status = false;
struct platform_gpio *nfc_gpio;
if (nfc_dev == NULL) {
pr_err("NxpDrv: %s nfc devices structure is null\n", __func__);
return status;
}
nfc_gpio = &nfc_dev->configs.gpio;
if (chip_type == CHIP_SN1XX) {
/* gpio should be configured for SN1xx */
status = gpio_is_valid(nfc_gpio->dwl_req);
} else if (chip_type == CHIP_SN220) {
/* gpio should not be configured for SN220 */
set_valid_gpio(nfc_gpio->dwl_req, 0);
gpio_free(nfc_gpio->dwl_req);
nfc_gpio->dwl_req = -EINVAL;
status = true;
}
return status;
}
/* Check for availability of NFC controller hardware */
int nfcc_hw_check(struct nfc_dev *nfc_dev)
{
int ret = 0;
enum nfc_state_flags nfc_state = NFC_STATE_UNKNOWN;
enum chip_types chip_type = CHIP_UNKNOWN;
struct platform_gpio *nfc_gpio = &nfc_dev->configs.gpio;
/*get fw version in nci mode*/
gpio_set_ven(nfc_dev, 1);
gpio_set_ven(nfc_dev, 0);
gpio_set_ven(nfc_dev, 1);
chip_type = get_nfcc_chip_type(nfc_dev);
/*get fw version in fw dwl mode*/
if (chip_type == CHIP_UNKNOWN) {
nfc_dev->nfc_enable_intr(nfc_dev);
/*Chip is unknown, initially assume with fw dwl pin enabled*/
set_valid_gpio(nfc_gpio->dwl_req, 1);
gpio_set_ven(nfc_dev, 0);
gpio_set_ven(nfc_dev, 1);
chip_type = get_nfcc_chip_type_dl(nfc_dev);
/*get the state of nfcc normal/teared in fw dwl mode*/
} else {
nfc_state = NFC_STATE_NCI;
}
/*validate gpio config required as per the chip*/
if (!validate_download_gpio(nfc_dev, chip_type)) {
pr_info("NxpDrv: %s gpio validation fail\n", __func__);
ret = -ENXIO;
goto err;
}
/*check whether the NFCC is in FW DN or Teared state*/
if (nfc_state != NFC_STATE_NCI)
nfc_state = get_nfcc_session_state_dl(nfc_dev);
/*nfcc state specific operations */
switch (nfc_state) {
case NFC_STATE_FW_TEARED:
pr_warn("NxpDrv: %s: - NFCC FW Teared State\n", __func__);
break;
case NFC_STATE_FW_DWL:
case NFC_STATE_NCI:
break;
case NFC_STATE_UNKNOWN:
default:
ret = -ENXIO;
pr_err("NxpDrv: %s: - NFCC HW not available\n", __func__);
goto err;
}
nfc_dev->nfc_state = nfc_state;
err:
nfc_dev->nfc_disable_intr(nfc_dev);
set_valid_gpio(nfc_gpio->dwl_req, 0);
gpio_set_ven(nfc_dev, 0);
gpio_set_ven(nfc_dev, 1);
nfc_dev->nfc_ven_enabled = true;
return ret;
}

77
nxp/opensource/driver/nfc/common_nxp.h Normal file
View File

@@ -0,0 +1,77 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2015-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2019-2021 NXP
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
******************************************************************************/
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*
******************************************************************************/
#ifndef _COMMON_QCOM_H_
#define _COMMON_QCOM_H_
#define NCI_RESET_CMD_LEN (4)
#define NCI_RESET_RSP_LEN (4)
#define NCI_CORE_RESET_CMD_OID (0x0)
#define NCI_CORE_RESET_CMD_PAYLOAD_LEN (0x1)
#define NCI_CORE_RESET_KEEP_CONFIG (0x0)
#define NCI_RESET_NTF_LEN (13)
/*command response timeout*/
#define NCI_CMD_RSP_TIMEOUT_MS (2000) //2s
#define SN1XX_ROM_VER 0x01
#define SN1xx_MAJOR_VER 0x10
#define SN220_ROM_VER 0x01
#define SN220_MAJOR_VER 0x01
#define FW_ROM_CODE_VER_OFFSET 4
#define FW_MAJOR_VER_OFFSET 7
#define GET_VERSION_RSP_CHIP_TYPE_OFFSET 3
#define GET_VERSION_RSP_MINOR_VERSION_OFFSET 6
#define DL_GET_VERSION_CMD_LEN (8)
#define DL_GET_VERSION_RSP_LEN_1 (12) /* SN110 */
#define DL_GET_VERSION_RSP_LEN_2 (20) /* SN220 */
#define DL_GET_VERSION_CMD_PAYLOAD_LEN (4)
#define DL_GET_VERSION_CMD_ID (0xF1)
#define DL_GET_VERSION_CMD_CRC_1 (0x6E)
#define DL_GET_VERSION_CMD_CRC_2 (0xEF)
#define DL_RESET_CMD_LEN (8)
#define DL_GET_SESSION_STATE_CMD_LEN (8)
#define DL_GET_SESSION_STATE_RSP_LEN (8)
#define DL_GET_SESSION_STATE_CMD_PAYLOAD_LEN (4)
#define DL_GET_SESSION_CMD_ID (0xF2)
#define DL_GET_SESSION_CMD_CRC_1 (0xF5)
#define DL_GET_SESSION_CMD_CRC_2 (0x33)
#define GET_SESSION_STS_OFF (3)
#define NFCC_SESSION_STS_CLOSED (0x0)
/* Below offsets should be subtracted from NCI header length + payload length */
#define NFC_CHIP_TYPE_OFF (4)
#define NFC_FW_MINOR_OFF (1)
enum chip_types {
CHIP_SN1XX = 0x01,
CHIP_SN220 = 0x02,
CHIP_UNKNOWN = 0xFF,
};
#endif //_COMMON_QCOM_H_

204
nxp/opensource/driver/nfc/common_qcom.c Normal file
View File

@@ -0,0 +1,204 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
*
***************************************************************************/
/*
* Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.
*
***************************************************************************/
#include "common.h"
/*
* Inside nfc_ioctl_nfcc_info
*
* @brief nfc_ioctl_nfcc_info
*
* Check the NFC Chipset and firmware version details
*/
unsigned int nfc_ioctl_nfcc_info(struct file *filp, unsigned long arg)
{
unsigned int r = 0;
struct nfc_dev *nfc_dev = filp->private_data;
r = nfc_dev->nqx_info.i;
pr_debug("NxpDrv: nfc : %s r = 0x%x\n", __func__, r);
return r;
}
/*
* Inside is_nfc_data_available_for_read
*
* @nfc_dev: nfc device data structure
*
* Checks if the data is available for reading
* on waiting queue.
*
* @Return: status value
*
*/
int is_nfc_data_available_for_read(struct nfc_dev *nfc_dev)
{
int ret;
nfc_dev->nfc_enable_intr(nfc_dev);
ret = wait_event_interruptible_timeout(nfc_dev->read_wq,
!nfc_dev->i2c_dev.irq_enabled,
msecs_to_jiffies(MAX_IRQ_WAIT_TIME));
return ret;
}
/**
* nfc_ldo_vote()
* @nfc_dev: NFC device containing regulator handle
*
* LDO voting based on voltage and current entries in DT
*
* Return: 0 on success and -ve on failure
*/
int nfc_ldo_vote(struct nfc_dev *nfc_dev)
{
int ret;
ret = regulator_set_voltage(nfc_dev->reg,
nfc_dev->configs.ldo.vdd_levels[0],
nfc_dev->configs.ldo.vdd_levels[1]);
if (ret < 0) {
pr_err("NxpDrv: %s: set voltage failed\n", __func__);
return ret;
}
/* pass expected current from NFC in uA */
ret = regulator_set_load(nfc_dev->reg, nfc_dev->configs.ldo.max_current);
if (ret < 0) {
pr_err("NxpDrv: %s: set load failed\n", __func__);
return ret;
}
ret = regulator_enable(nfc_dev->reg);
if (ret < 0)
pr_err("NxpDrv: %s: regulator_enable failed\n", __func__);
else
nfc_dev->is_vreg_enabled = true;
return ret;
}
/**
* nfc_ldo_config()
* @dev: device instance to read DT entry
* @nfc_dev: NFC device containing regulator handle
*
* Configure LDO if entry is present in DT file otherwise
* return with success as it's optional
*
* Return: 0 on success and -ve on failure
*/
int nfc_ldo_config(struct device *dev, struct nfc_dev *nfc_dev)
{
int ret;
if (of_get_property(dev->of_node, NFC_LDO_SUPPLY_NAME, NULL)) {
// Get the regulator handle
nfc_dev->reg = regulator_get(dev, NFC_LDO_SUPPLY_DT_NAME);
if (IS_ERR(nfc_dev->reg)) {
ret = PTR_ERR(nfc_dev->reg);
nfc_dev->reg = NULL;
pr_err("NxpDrv: %s: regulator_get failed, ret = %d\n",
__func__, ret);
return ret;
}
} else {
nfc_dev->reg = NULL;
pr_err("NxpDrv: %s: regulator entry not present\n", __func__);
// return success as it's optional to configure LDO
return 0;
}
// LDO config supported by platform DT
ret = nfc_ldo_vote(nfc_dev);
if (ret < 0) {
pr_err("NxpDrv: %s: LDO voting failed, ret = %d\n", __func__, ret);
regulator_put(nfc_dev->reg);
}
return ret;
}
/**
* nfc_ldo_unvote()
* @nfc_dev: NFC device containing regulator handle
*
* set voltage and load to zero and disable regulator
*
* Return: 0 on success and -ve on failure
*/
int nfc_ldo_unvote(struct nfc_dev *nfc_dev)
{
int ret;
if (!nfc_dev->is_vreg_enabled) {
pr_err("NxpDrv: %s: regulator already disabled\n", __func__);
return -EINVAL;
}
ret = regulator_disable(nfc_dev->reg);
if (ret < 0) {
pr_err("NxpDrv: %s: regulator_disable failed\n", __func__);
return ret;
}
nfc_dev->is_vreg_enabled = false;
ret = regulator_set_voltage(nfc_dev->reg, 0, NFC_VDDIO_MAX);
if (ret < 0) {
pr_err("NxpDrv: %s: set voltage failed\n", __func__);
return ret;
}
ret = regulator_set_load(nfc_dev->reg, 0);
if (ret < 0)
pr_err("NxpDrv: %s: set load failed\n", __func__);
return ret;
}
/*
* Routine to enable clock.
* this routine can be extended to select from multiple
* sources based on clk name.
*/
int nfc_clock_select(struct nfc_dev *nfc_dev)
{
int r = 0;
nfc_dev->s_clk = clk_get(&nfc_dev->i2c_dev.client->dev, "nfc_ref_clk");
if (IS_ERR(nfc_dev->s_clk))
return PTR_ERR(nfc_dev->s_clk);
if (!nfc_dev->clk_run)
r = clk_prepare_enable(nfc_dev->s_clk);
if (r)
return r;
nfc_dev->clk_run = true;
return r;
}
/*
* Routine to disable clocks
*/
int nfc_clock_deselect(struct nfc_dev *nfc_dev)
{
int r = -EINVAL;
if (nfc_dev->s_clk != NULL) {
if (nfc_dev->clk_run) {
clk_disable_unprepare(nfc_dev->s_clk);
nfc_dev->clk_run = false;
}
return 0;
}
return r;
}

407
nxp/opensource/driver/nfc/ese_cold_reset.c Normal file
View File

@@ -0,0 +1,407 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
*
***************************************************************************/
/*
* Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
*
***************************************************************************/
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/uaccess.h>
#include "common.h"
/*
* Power management of the eSE
* eSE and NFCC both are powered using VEN gpio,
* VEN HIGH - eSE and NFCC both are powered on
* VEN LOW - eSE and NFCC both are power down
*/
int nfc_ese_pwr(struct nfc_dev *nfc_dev, unsigned long arg)
{
int ret = 0;
if (arg == ESE_POWER_ON) {
/*
* Let's store the NFC VEN pin state
* will check stored value in case of eSE power off request,
* to find out if NFC MW also sent request to set VEN HIGH
* VEN state will remain HIGH if NFC is enabled otherwise
* it will be set as LOW
*/
nfc_dev->nfc_ven_enabled = gpio_get_value(nfc_dev->configs.gpio.ven);
if (!nfc_dev->nfc_ven_enabled) {
pr_debug("eSE HAL service setting ven HIGH\n");
gpio_set_ven(nfc_dev, 1);
} else {
pr_debug("ven already HIGH\n");
}
nfc_dev->is_ese_session_active = true;
} else if (arg == ESE_POWER_OFF) {
if (!nfc_dev->nfc_ven_enabled) {
pr_debug("NFC not enabled, disabling ven\n");
gpio_set_ven(nfc_dev, 0);
} else {
pr_debug("keep ven high as NFC is enabled\n");
}
nfc_dev->is_ese_session_active = false;
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
if (nfc_dev->configs.CNSS_NFC_HW_SECURE_ENABLE == true) {
if(chk_eSE_pwr_off)
up(&sem_eSE_pwr_off);
}
#endif
} else if (arg == ESE_POWER_STATE) {
/* get VEN gpio state for eSE, as eSE also enabled through same GPIO */
ret = gpio_get_value(nfc_dev->configs.gpio.ven);
} else {
pr_err("%s bad arg %lu\n", __func__, arg);
ret = -ENOIOCTLCMD;
}
return ret;
}
/**
* send_ese_cmd() - Send eSE command to NFC controller.
* @nfc_dev: NFC device handle.
*
* Return: 0 on pass and negative value on failure.
*/
static int send_ese_cmd(struct nfc_dev *nfc_dev)
{
int ret;
if (nfc_dev->nfc_state == NFC_STATE_FW_DWL) {
dev_err(nfc_dev->nfc_device,
"cannot send ese cmd as FW download is in-progress\n");
return -EBUSY;
}
if (!gpio_get_value(nfc_dev->configs.gpio.ven)) {
dev_err(nfc_dev->nfc_device,
"cannot send ese cmd as NFCC powered off\n");
return -ENODEV;
}
if (nfc_dev->cold_reset.cmd_buf == NULL)
return -EFAULT;
ret = nfc_dev->nfc_write(nfc_dev, nfc_dev->cold_reset.cmd_buf,
nfc_dev->cold_reset.cmd_len,
MAX_RETRY_COUNT);
if (ret <= 0)
dev_err(nfc_dev->nfc_device,
"%s: write failed after max retry, ret %d\n",
__func__, ret);
return ret;
}
/**
* read_cold_reset_rsp() - Read response of the cold reset command.
* @nfc_dev: NFC device handle.
* @header: Pointer to NCI header if it is already read.
*
* Return: 0 on pass and negative value on failure.
*/
int read_cold_reset_rsp(struct nfc_dev *nfc_dev, char *header)
{
int ret = -EPERM;
struct cold_reset *cold_rst = &nfc_dev->cold_reset;
char *rsp_buf = NULL;
if (cold_rst->rsp_len < COLD_RESET_RSP_LEN) {
dev_err(nfc_dev->nfc_device,
"%s: received cold reset rsp buffer length is invalid \n",
__func__);
return -EINVAL;
}
rsp_buf = kzalloc(cold_rst->rsp_len, GFP_DMA | GFP_KERNEL);
if (!rsp_buf)
return -ENOMEM;
/*
* read header if NFC is disabled
* for enable case, header is read by nfc read thread(for i2c)
*/
if ((!cold_rst->is_nfc_enabled) &&
(nfc_dev->interface == PLATFORM_IF_I2C)) {
ret = i2c_master_recv(nfc_dev->i2c_dev.client, rsp_buf, NCI_HDR_LEN);
if (ret <= 0) {
dev_err(nfc_dev->nfc_device,
"%s: failure to read cold reset rsp header\n",
__func__);
ret = -EIO;
goto error;
}
/*
* return failure, if packet is not a response packet or
* if response's OID doesn't match with the CMD's OID
*/
if (!(rsp_buf[0] & NCI_RSP_PKT_TYPE) ||
(!cold_rst->cmd_buf) ||
(rsp_buf[1] != cold_rst->cmd_buf[1])) {
dev_err(nfc_dev->nfc_device,
"%s: - invalid cold reset response 0x%x 0x%x\n",
__func__, rsp_buf[0], rsp_buf[1]);
ret = -EINVAL;
goto error;
}
} else if (header) {
memcpy(rsp_buf, header, NCI_HDR_LEN);
} else {
dev_err(nfc_dev->nfc_device,
"%s: - invalid or NULL header\n", __func__);
ret = -EINVAL;
goto error;
}
if ((NCI_HDR_LEN + rsp_buf[NCI_PAYLOAD_LEN_IDX]) >
cold_rst->rsp_len) {
dev_err(nfc_dev->nfc_device,
"%s: - no space for cold_reset resp\n", __func__);
ret = -ENOMEM;
goto error;
}
if (nfc_dev->interface == PLATFORM_IF_I2C) {
ret = nfc_dev->nfc_read(nfc_dev,
&rsp_buf[NCI_PAYLOAD_IDX],
rsp_buf[NCI_PAYLOAD_LEN_IDX],
NCI_CMD_RSP_TIMEOUT_MS);
if (ret <= 0) {
dev_err(nfc_dev->nfc_device,
"%s: failure to read cold reset rsp payload\n",
__func__);
ret = -EIO;
goto error;
}
ret = cold_rst->status = rsp_buf[NCI_PAYLOAD_IDX];
pr_debug("nfc ese rsp hdr 0x%x 0x%x 0x%x, payload byte0 0x%x\n",
rsp_buf[0], rsp_buf[1], rsp_buf[2], rsp_buf[3]);
}
error:
kfree(rsp_buf);
return ret;
}
/**
* ese_cold_reset_ioctl() - This function handles the eSE cold reset ioctls.
* @nfc_dev: NFC device handle.
* @arg: ioctl argument.
*
* Return: 0 on pass and negative value on failure.
*/
int ese_cold_reset_ioctl(struct nfc_dev *nfc_dev, unsigned long arg)
{
int ret;
struct ese_ioctl_arg ioctl_arg;
struct ese_cold_reset_arg *cold_reset_arg = NULL;
if (!arg) {
dev_err(nfc_dev->nfc_device, "arg is invalid\n");
return -EINVAL;
}
ret = copy_from_user((void *)&ioctl_arg, (const void *)arg,
sizeof(ioctl_arg));
if (ret) {
dev_err(nfc_dev->nfc_device,
"ese ioctl arg copy from user failed\n");
return -EFAULT;
}
cold_reset_arg = kzalloc(sizeof(struct ese_cold_reset_arg), GFP_KERNEL);
if (!cold_reset_arg)
return -ENOMEM;
mutex_lock(&nfc_dev->write_mutex);
ret = copy_struct_from_user(cold_reset_arg,
sizeof(struct ese_cold_reset_arg),
u64_to_user_ptr(ioctl_arg.buf),
sizeof(struct ese_cold_reset_arg));
if (ret) {
dev_err(nfc_dev->nfc_device,
"ese ioctl arg buffer copy from user failed\n");
ret = -EFAULT;
goto err;
}
switch (cold_reset_arg->sub_cmd) {
case ESE_COLD_RESET_DO:
/*
* cold reset allowed during protection enable, only if the
* source is same as the one which enabled protection.
*/
if (nfc_dev->cold_reset.is_crp_en &&
(cold_reset_arg->src !=
nfc_dev->cold_reset.last_src_ese_prot)) {
dev_err(nfc_dev->nfc_device,
"cold reset from %d denied, protection is on\n",
cold_reset_arg->src);
ret = -EACCES;
goto err;
}
nfc_dev->cold_reset.cmd_buf = kzalloc(COLD_RESET_CMD_LEN,
GFP_DMA | GFP_KERNEL);
if (!nfc_dev->cold_reset.cmd_buf) {
ret = -ENOMEM;
goto err;
}
nfc_dev->cold_reset.cmd_buf[0] = PROP_NCI_CMD_GID;
nfc_dev->cold_reset.cmd_buf[1] = COLD_RESET_OID;
nfc_dev->cold_reset.cmd_buf[2] = COLD_RESET_CMD_PL_LEN;
nfc_dev->cold_reset.cmd_len = NCI_HDR_LEN +
COLD_RESET_CMD_PL_LEN;
nfc_dev->cold_reset.rsp_len = COLD_RESET_RSP_LEN;
break;
case ESE_COLD_RESET_PROTECT_EN:
if (nfc_dev->cold_reset.is_crp_en) {
if (cold_reset_arg->src !=
nfc_dev->cold_reset.last_src_ese_prot) {
dev_err(nfc_dev->nfc_device,
"ese protection enable denied\n");
ret = -EACCES;
goto err;
}
pr_warn("ese protection already enabled\n");
ret = 0;
/* free buffers and exit with pass */
goto err;
}
fallthrough;
case ESE_COLD_RESET_PROTECT_DIS:
if (nfc_dev->cold_reset.is_crp_en &&
cold_reset_arg->src !=
nfc_dev->cold_reset.last_src_ese_prot) {
pr_err("ese cold reset protection disable denied\n");
ret = -EACCES;
goto err;
}
nfc_dev->cold_reset.cmd_buf = kzalloc(COLD_RESET_PROT_CMD_LEN,
GFP_DMA | GFP_KERNEL);
if (!nfc_dev->cold_reset.cmd_buf) {
ret = -ENOMEM;
goto err;
}
nfc_dev->cold_reset.cmd_buf[0] = PROP_NCI_CMD_GID;
nfc_dev->cold_reset.cmd_buf[1] = COLD_RESET_PROT_OID;
nfc_dev->cold_reset.cmd_buf[2] = COLD_RESET_PROT_CMD_PL_LEN;
nfc_dev->cold_reset.cmd_len = NCI_HDR_LEN +
COLD_RESET_PROT_CMD_PL_LEN;
nfc_dev->cold_reset.rsp_len = COLD_RESET_PROT_RSP_LEN;
if (cold_reset_arg->sub_cmd == ESE_COLD_RESET_PROTECT_EN)
nfc_dev->cold_reset.cmd_buf[3] = 0x1;
else
nfc_dev->cold_reset.cmd_buf[3] = 0x0;
break;
default:
pr_err("%s invalid ese ioctl sub cmd %d\n", __func__,
cold_reset_arg->sub_cmd);
ret = -ENOIOCTLCMD;
goto err;
}
pr_debug("nfc ese cmd hdr 0x%x 0x%x 0x%x\n",
nfc_dev->cold_reset.cmd_buf[0],
nfc_dev->cold_reset.cmd_buf[1],
nfc_dev->cold_reset.cmd_buf[2]);
ret = send_ese_cmd(nfc_dev);
if (ret <= 0) {
pr_err("failed to send ese command\n");
goto err;
}
nfc_dev->cold_reset.rsp_pending = true;
/* check if NFC is enabled */
if (nfc_dev->cold_reset.is_nfc_enabled) {
/*
* nfc_read thread will initiate cold reset response
* and it will signal for data available
*/
wait_event_interruptible(nfc_dev->cold_reset.read_wq,
!nfc_dev->cold_reset.rsp_pending);
} else {
/*
* Read data as NFC read thread is not active
*/
if (nfc_dev->interface == PLATFORM_IF_I2C) {
ret = is_nfc_data_available_for_read(nfc_dev);
if (ret <= 0) {
nfc_dev->nfc_disable_intr(nfc_dev);
nfc_dev->cold_reset.rsp_pending = false;
goto err;
}
ret = read_cold_reset_rsp(nfc_dev, NULL);
nfc_dev->cold_reset.rsp_pending = false;
if (ret < 0) {
pr_err("%s rsp read err\n", __func__);
goto err;
}
} else {
/*
* Enable intr as it is disabled when NFC is in disable
* state
*/
nfc_dev->nfc_enable_intr(nfc_dev);
wait_event_interruptible(
nfc_dev->cold_reset.read_wq,
!nfc_dev->cold_reset.rsp_pending);
}
nfc_dev->nfc_disable_intr(nfc_dev);
}
if (cold_reset_arg->sub_cmd == ESE_COLD_RESET_PROTECT_EN) {
nfc_dev->cold_reset.is_crp_en = true;
nfc_dev->cold_reset.last_src_ese_prot = cold_reset_arg->src;
} else if (cold_reset_arg->sub_cmd == ESE_COLD_RESET_PROTECT_DIS) {
nfc_dev->cold_reset.is_crp_en = false;
nfc_dev->cold_reset.last_src_ese_prot =
ESE_COLD_RESET_ORIGIN_NONE;
} else
pr_debug("ese cmd is %d\n", cold_reset_arg->sub_cmd);
ret = nfc_dev->cold_reset.status;
err:
if (nfc_dev->cold_reset.cmd_buf != NULL) {
kfree(nfc_dev->cold_reset.cmd_buf);
nfc_dev->cold_reset.cmd_buf = NULL;
}
if (cold_reset_arg != NULL) {
kfree(cold_reset_arg);
cold_reset_arg = NULL;
}
mutex_unlock(&nfc_dev->write_mutex);
return ret;
}

81
nxp/opensource/driver/nfc/ese_cold_reset.h Normal file
View File

@@ -0,0 +1,81 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#ifndef __ESE_COLD_RESET_H
#define __ESE_COLD_RESET_H
#include <nfcinfo.h>
#define MAX_BUFF_SIZE 264
/* ESE_COLD_RESET MACROS */
#define COLD_RESET_CMD_LEN 3
#define COLD_RESET_RSP_LEN 4
#define COLD_RESET_PROT_CMD_LEN 4
#define COLD_RESET_PROT_RSP_LEN 4
#define PROP_NCI_CMD_GID 0x2F
#define COLD_RESET_CMD_PL_LEN 0x00
#define COLD_RESET_PROT_CMD_PL_LEN 0x01
#define PROP_NCI_RSP_GID 0x4F
#define COLD_RESET_OID 0x1E
#define COLD_RESET_PROT_OID 0x1F
enum ese_ioctl_arg_type {
ESE_ARG_TYPE_COLD_RESET = 0,
};
/* ESE_COLD_RESET ioctl origin, max 4 are supported */
enum ese_cold_reset_origin {
ESE_COLD_RESET_ORIGIN_ESE = 0,
ESE_COLD_RESET_ORIGIN_NFC,
ESE_COLD_RESET_ORIGIN_OTHER = 0x20,
ESE_COLD_RESET_ORIGIN_NONE = 0xFF,
};
/* ESE_COLD_RESET ioctl sub commands, max 8 are supported */
enum ese_cold_reset_sub_cmd {
ESE_COLD_RESET_DO = 0,
ESE_COLD_RESET_PROTECT_EN,
ESE_COLD_RESET_PROTECT_DIS,
};
/* Data passed in buf of ese cold reset ioctl */
struct ese_cold_reset_arg {
__u8 src;
__u8 sub_cmd;
__u16 rfu;
};
/* Argument buffer passed to ese ioctl */
struct ese_ioctl_arg {
__u64 buf;
__u32 buf_size;
__u8 type;
};
/* Features specific Parameters */
struct cold_reset {
wait_queue_head_t read_wq;
char *cmd_buf;
uint16_t cmd_len;
uint16_t rsp_len;
/* Source of last ese protection command */
uint8_t last_src_ese_prot;
uint8_t status;
/* Is cold reset protection enabled */
bool is_crp_en;
bool rsp_pending;
/* Is NFC enabled from UI */
bool is_nfc_enabled;
bool is_nfc_read_pending;
};
struct nfc_dev;
int ese_cold_reset_ioctl(struct nfc_dev *nfc_dev, unsigned long arg);
int read_cold_reset_rsp(struct nfc_dev *nfc_dev, char *header);
#endif

609
nxp/opensource/driver/nfc/i2c_drv.c Normal file
View File

@@ -0,0 +1,609 @@
/******************************************************************************
* Copyright (C) 2015, The Linux Foundation. All rights reserved.
* Copyright (C) 2013-2022 NXP
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
******************************************************************************/
/*
* Copyright (C) 2010 Trusted Logic S.A.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*
****************************************************************************/
/*
* Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.
*
****************************************************************************/
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <linux/gpio.h>
#ifdef CONFIG_COMPAT
#include <linux/compat.h>
#endif
#include "common.h"
/**
* i2c_disable_irq()
*
* Check if interrupt is disabled or not
* and disable interrupt
*
* Return: int
*/
int i2c_disable_irq(struct nfc_dev *dev)
{
unsigned long flags;
spin_lock_irqsave(&dev->i2c_dev.irq_enabled_lock, flags);
if (dev->i2c_dev.irq_enabled) {
disable_irq_nosync(dev->i2c_dev.client->irq);
dev->i2c_dev.irq_enabled = false;
}
spin_unlock_irqrestore(&dev->i2c_dev.irq_enabled_lock, flags);
return 0;
}
/**
* i2c_enable_irq()
*
* Check if interrupt is enabled or not
* and enable interrupt
*
* Return: int
*/
int i2c_enable_irq(struct nfc_dev *dev)
{
unsigned long flags;
spin_lock_irqsave(&dev->i2c_dev.irq_enabled_lock, flags);
if (!dev->i2c_dev.irq_enabled) {
dev->i2c_dev.irq_enabled = true;
enable_irq(dev->i2c_dev.client->irq);
}
spin_unlock_irqrestore(&dev->i2c_dev.irq_enabled_lock, flags);
return 0;
}
static irqreturn_t i2c_irq_handler(int irq, void *dev_id)
{
struct nfc_dev *nfc_dev = dev_id;
struct i2c_dev *i2c_dev = &nfc_dev->i2c_dev;
if (device_may_wakeup(&i2c_dev->client->dev))
pm_wakeup_event(&i2c_dev->client->dev, WAKEUP_SRC_TIMEOUT);
i2c_disable_irq(nfc_dev);
wake_up(&nfc_dev->read_wq);
return IRQ_HANDLED;
}
int i2c_read(struct nfc_dev *nfc_dev, char *buf, size_t count, int timeout)
{
int ret;
struct i2c_dev *i2c_dev = &nfc_dev->i2c_dev;
struct platform_gpio *nfc_gpio = &nfc_dev->configs.gpio;
uint16_t i = 0;
uint16_t disp_len = GET_IPCLOG_MAX_PKT_LEN(count);
pr_debug("NxpDrv: %s: reading %zu bytes.\n", __func__, count);
if (timeout > NCI_CMD_RSP_TIMEOUT_MS)
timeout = NCI_CMD_RSP_TIMEOUT_MS;
if (count > MAX_NCI_BUFFER_SIZE)
count = MAX_NCI_BUFFER_SIZE;
if (!gpio_get_value(nfc_gpio->irq)) {
while (1) {
ret = 0;
if (!i2c_dev->irq_enabled) {
i2c_dev->irq_enabled = true;
enable_irq(i2c_dev->client->irq);
}
if (!gpio_get_value(nfc_gpio->irq)) {
if (timeout) {
ret = wait_event_interruptible_timeout(
nfc_dev->read_wq,
!i2c_dev->irq_enabled,
msecs_to_jiffies(timeout));
if (ret <= 0) {
pr_err("NxpDrv: %s: timeout error\n",
__func__);
goto err;
}
} else {
ret = wait_event_interruptible(
nfc_dev->read_wq,
!i2c_dev->irq_enabled);
if (ret) {
pr_err("NxpDrv: %s: err wakeup of wq\n",
__func__);
goto err;
}
}
}
i2c_disable_irq(nfc_dev);
if (gpio_get_value(nfc_gpio->irq))
break;
if(!nfc_dev->secure_zone) {
if (!gpio_get_value(nfc_gpio->ven)) {
pr_info("NxpDrv: %s: releasing read\n", __func__);
ret = -EIO;
goto err;
}
}
/*
* NFC service wanted to close the driver so,
* release the calling reader thread asap.
*
* This can happen in case of nfc node close call from
* eSE HAL in that case the NFC HAL reader thread
* will again call read system call
*/
if (nfc_dev->release_read) {
pr_debug("NxpDrv: %s: releasing read\n", __func__);
return 0;
}
pr_warn("NxpDrv: %s: spurious interrupt detected\n", __func__);
}
}
memset(buf, 0x00, count);
/* Read data */
ret = i2c_master_recv(nfc_dev->i2c_dev.client, buf, count);
NFCLOG_IPC(nfc_dev, false, "%s of %d bytes, ret %d", __func__, count,
ret);
if (ret <= 0) {
pr_err("NxpDrv: %s: returned %d\n", __func__, ret);
goto err;
}
for (i = 0; i < disp_len; i++)
NFCLOG_IPC(nfc_dev, false, " %02x", buf[i]);
/* check if it's response of cold reset command
* NFC HAL process shouldn't receive this data as
* command was sent by esepowermanager
*/
if (nfc_dev->cold_reset.rsp_pending && nfc_dev->cold_reset.cmd_buf
&& (buf[0] == PROP_NCI_RSP_GID)
&& (buf[1] == nfc_dev->cold_reset.cmd_buf[1])) {
read_cold_reset_rsp(nfc_dev, buf);
nfc_dev->cold_reset.rsp_pending = false;
wake_up_interruptible(&nfc_dev->cold_reset.read_wq);
/*
* NFC process doesn't know about cold reset command
* being sent as it was initiated by eSE process
* we shouldn't return any data to NFC process
*/
return 0;
}
err:
return ret;
}
int i2c_write(struct nfc_dev *nfc_dev, const char *buf, size_t count,
int max_retry_cnt)
{
int ret = -EINVAL;
int retry_cnt;
uint16_t i = 0;
uint16_t disp_len = GET_IPCLOG_MAX_PKT_LEN(count);
struct platform_gpio *nfc_gpio = &nfc_dev->configs.gpio;
if (count > MAX_DL_BUFFER_SIZE)
count = MAX_DL_BUFFER_SIZE;
pr_debug("NxpDrv: %s: writing %zu bytes.\n", __func__, count);
NFCLOG_IPC(nfc_dev, false, "%s sending %d B", __func__, count);
for (i = 0; i < disp_len; i++)
NFCLOG_IPC(nfc_dev, false, " %02x", buf[i]);
/*
* Wait for any pending read for max 15ms before write
* This is to avoid any packet corruption during read, when
* the host cmds resets NFCC during any parallel read operation
*/
for (retry_cnt = 1; retry_cnt <= MAX_WRITE_IRQ_COUNT; retry_cnt++) {
if (gpio_get_value(nfc_gpio->irq)) {
pr_warn("NxpDrv: %s: irq high during write, wait\n", __func__);
usleep_range(WRITE_RETRY_WAIT_TIME_US,
WRITE_RETRY_WAIT_TIME_US + 100);
} else {
break;
}
if (retry_cnt == MAX_WRITE_IRQ_COUNT &&
gpio_get_value(nfc_gpio->irq)) {
pr_warn("NxpDrv: %s: allow after maximum wait\n", __func__);
}
}
for (retry_cnt = 1; retry_cnt <= max_retry_cnt; retry_cnt++) {
ret = i2c_master_send(nfc_dev->i2c_dev.client, buf, count);
NFCLOG_IPC(nfc_dev, false, "%s ret %d", __func__, ret);
if (ret <= 0) {
pr_warn("NxpDrv: %s: write failed ret(%d), maybe in standby\n",
__func__, ret);
usleep_range(WRITE_RETRY_WAIT_TIME_US,
WRITE_RETRY_WAIT_TIME_US + 100);
} else if (ret != count) {
pr_err("NxpDrv: %s: failed to write %d\n", __func__, ret);
ret = -EIO;
} else if (ret == count)
break;
}
return ret;
}
ssize_t nfc_i2c_dev_read(struct file *filp, char __user *buf, size_t count,
loff_t *offset)
{
int ret;
struct nfc_dev *nfc_dev = (struct nfc_dev *)filp->private_data;
if (!nfc_dev) {
pr_err("NxpDrv: %s: device doesn't exist anymore\n", __func__);
return -ENODEV;
}
mutex_lock(&nfc_dev->read_mutex);
if (count > MAX_NCI_BUFFER_SIZE)
count = MAX_NCI_BUFFER_SIZE;
if (filp->f_flags & O_NONBLOCK) {
ret = i2c_master_recv(nfc_dev->i2c_dev.client, nfc_dev->read_kbuf, count);
pr_debug("NxpDrv: %s: NONBLOCK read ret = %d\n", __func__, ret);
} else {
ret = i2c_read(nfc_dev, nfc_dev->read_kbuf, count, 0);
}
if (ret > 0) {
if (copy_to_user(buf, nfc_dev->read_kbuf, ret)) {
pr_warn("NxpDrv: %s: failed to copy to user space\n", __func__);
ret = -EFAULT;
}
}
mutex_unlock(&nfc_dev->read_mutex);
return ret;
}
ssize_t nfc_i2c_dev_write(struct file *filp, const char __user *buf,
size_t count, loff_t *offset)
{
int ret;
struct nfc_dev *nfc_dev = (struct nfc_dev *)filp->private_data;
if (count > MAX_DL_BUFFER_SIZE)
count = MAX_DL_BUFFER_SIZE;
if (!nfc_dev) {
pr_err("NxpDrv: %s: device doesn't exist anymore\n", __func__);
return -ENODEV;
}
mutex_lock(&nfc_dev->write_mutex);
if (copy_from_user(nfc_dev->write_kbuf, buf, count)) {
pr_err("NxpDrv: %s: failed to copy from user space\n", __func__);
mutex_unlock(&nfc_dev->write_mutex);
return -EFAULT;
}
ret = i2c_write(nfc_dev, nfc_dev->write_kbuf, count, NO_RETRY);
mutex_unlock(&nfc_dev->write_mutex);
return ret;
}
static const struct file_operations nfc_i2c_dev_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read = nfc_i2c_dev_read,
.write = nfc_i2c_dev_write,
.open = nfc_dev_open,
.flush = nfc_dev_flush,
.release = nfc_dev_close,
.unlocked_ioctl = nfc_dev_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = nfc_dev_compat_ioctl,
#endif
};
int nfc_i2c_dev_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret = 0;
struct nfc_dev *nfc_dev = NULL;
struct i2c_dev *i2c_dev = NULL;
struct platform_configs *nfc_configs = NULL;
struct platform_gpio *nfc_gpio = NULL;
pr_debug("NxpDrv: %s: enter\n", __func__);
nfc_dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL);
if (nfc_dev == NULL) {
ret = -ENOMEM;
goto err;
}
nfc_configs = &nfc_dev->configs;
nfc_gpio = &nfc_configs->gpio;
/* retrieve details of gpios from dt */
ret = nfc_parse_dt(&client->dev,nfc_configs, PLATFORM_IF_I2C);
if (ret) {
pr_err("NxpDrv: %s: failed to parse dt\n", __func__);
goto err_free_nfc_dev;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("NxpDrv: %s: need I2C_FUNC_I2C\n", __func__);
ret = -ENODEV;
goto err_free_nfc_dev;
}
nfc_dev->read_kbuf = kzalloc(MAX_NCI_BUFFER_SIZE, GFP_DMA | GFP_KERNEL);
if (!nfc_dev->read_kbuf) {
ret = -ENOMEM;
goto err_free_nfc_dev;
}
nfc_dev->write_kbuf = kzalloc(MAX_DL_BUFFER_SIZE, GFP_DMA | GFP_KERNEL);
if (!nfc_dev->write_kbuf) {
ret = -ENOMEM;
goto err_free_read_kbuf;
}
nfc_dev->interface = PLATFORM_IF_I2C;
nfc_dev->nfc_state = NFC_STATE_NCI;
nfc_dev->i2c_dev.client = client;
i2c_dev = &nfc_dev->i2c_dev;
nfc_dev->nfc_read = i2c_read;
nfc_dev->nfc_write = i2c_write;
nfc_dev->nfc_enable_intr = i2c_enable_irq;
nfc_dev->nfc_disable_intr = i2c_disable_irq;
ret = configure_gpio(nfc_gpio->irq, GPIO_IRQ);
if (ret <= 0) {
pr_err("NxpDrv: %s: unable to request nfc irq gpio [%d]\n", __func__,
nfc_gpio->irq);
goto err_free_gpio;
}
client->irq = ret;
/* init mutex and queues */
init_waitqueue_head(&nfc_dev->read_wq);
mutex_init(&nfc_dev->read_mutex);
mutex_init(&nfc_dev->write_mutex);
mutex_init(&nfc_dev->dev_ref_mutex);
spin_lock_init(&i2c_dev->irq_enabled_lock);
ret = nfc_misc_register(nfc_dev, &nfc_i2c_dev_fops, DEV_COUNT,
NFC_CHAR_DEV_NAME, CLASS_NAME);
if (ret) {
pr_err("NxpDrv: %s: nfc_misc_register failed\n", __func__);
goto err_mutex_destroy;
}
/* interrupt initializations */
pr_info("NxpDrv: %s: requesting IRQ %d\n", __func__, client->irq);
i2c_dev->irq_enabled = true;
ret = request_irq(client->irq, i2c_irq_handler, IRQF_TRIGGER_HIGH,
client->name, nfc_dev);
if (ret) {
pr_err("NxpDrv: %s: request_irq failed\n", __func__);
goto err_nfc_misc_unregister;
}
i2c_disable_irq(nfc_dev);
ret = nfc_ldo_config(&client->dev, nfc_dev);
if (ret) {
pr_err("NxpDrv: LDO config failed\n");
goto err_ldo_config_failed;
}
#ifdef NFC_SECURE_PERIPHERAL_ENABLED
if( nfc_dev->configs.CNSS_NFC_HW_SECURE_ENABLE == true) {
/*Check NFC Secure Zone status*/
if(!nfc_hw_secure_check()) {
nfc_post_init(nfc_dev);
nfc_dev->secure_zone = false;
}
else {
nfc_dev->secure_zone = true;
}
pr_info("NxpDrv: %s:nfc secure_zone = %s", __func__, nfc_dev->secure_zone ? "true" : "false");
}else {
nfc_post_init(nfc_dev);
}
#else
nfc_dev->secure_zone = false;
nfc_post_init(nfc_dev);
#endif
if (nfc_dev->configs.clk_pin_voting)
nfc_dev->clk_run = false;
else
nfc_dev->clk_run = true;
device_init_wakeup(&client->dev, true);
i2c_set_clientdata(client, nfc_dev);
i2c_dev->irq_wake_up = false;
nfc_dev->is_ese_session_active = false;
pr_info("NxpDrv: %s: probing nfc i2c success\n", __func__);
return 0;
err_ldo_config_failed:
free_irq(client->irq, nfc_dev);
err_nfc_misc_unregister:
nfc_misc_unregister(nfc_dev, DEV_COUNT);
err_mutex_destroy:
mutex_destroy(&nfc_dev->dev_ref_mutex);
mutex_destroy(&nfc_dev->read_mutex);
mutex_destroy(&nfc_dev->write_mutex);
err_free_gpio:
gpio_free_all(nfc_dev);
kfree(nfc_dev->write_kbuf);
err_free_read_kbuf:
kfree(nfc_dev->read_kbuf);
err_free_nfc_dev:
kfree(nfc_dev);
err:
pr_err("NxpDrv: %s: probing not successful, check hardware\n", __func__);
return ret;
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0))
void nfc_i2c_dev_remove(struct i2c_client *client)
#else
int nfc_i2c_dev_remove(struct i2c_client *client)
#endif
{
struct nfc_dev *nfc_dev = NULL;
pr_info("NxpDrv: %s: remove device\n", __func__);
nfc_dev = i2c_get_clientdata(client);
if (!nfc_dev) {
pr_err("NxpDrv: %s: device doesn't exist anymore\n", __func__);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(6, 1, 0))
return -ENODEV;
#endif
}
if (nfc_dev->dev_ref_count > 0) {
pr_err("NxpDrv: %s: device already in use\n", __func__);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(6, 1, 0))
return -EBUSY;
#endif
}
gpio_set_value(nfc_dev->configs.gpio.ven, 0);
// HW dependent delay before LDO goes into LPM mode
usleep_range(10000, 10100);
if (nfc_dev->reg) {
nfc_ldo_unvote(nfc_dev);
regulator_put(nfc_dev->reg);
}
device_init_wakeup(&client->dev, false);
free_irq(client->irq, nfc_dev);
nfc_misc_unregister(nfc_dev, DEV_COUNT);
mutex_destroy(&nfc_dev->dev_ref_mutex);
mutex_destroy(&nfc_dev->read_mutex);
mutex_destroy(&nfc_dev->write_mutex);
gpio_free_all(nfc_dev);
kfree(nfc_dev->read_kbuf);
kfree(nfc_dev->write_kbuf);
kfree(nfc_dev);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(6, 1, 0))
return 0;
#endif
}
int nfc_i2c_dev_suspend(struct device *device)
{
struct i2c_client *client = to_i2c_client(device);
struct nfc_dev *nfc_dev = i2c_get_clientdata(client);
struct i2c_dev *i2c_dev = NULL;
if (!nfc_dev) {
pr_err("NxpDrv: %s: device doesn't exist anymore\n", __func__);
return -ENODEV;
}
i2c_dev = &nfc_dev->i2c_dev;
NFCLOG_IPC(nfc_dev, false, "%s: irq_enabled = %d", __func__,
i2c_dev->irq_enabled);
if (device_may_wakeup(&client->dev) && i2c_dev->irq_enabled) {
if (!enable_irq_wake(client->irq))
i2c_dev->irq_wake_up = true;
}
pr_debug("NxpDrv: %s: irq_wake_up = %d", __func__, i2c_dev->irq_wake_up);
return 0;
}
int nfc_i2c_dev_resume(struct device *device)
{
struct i2c_client *client = to_i2c_client(device);
struct nfc_dev *nfc_dev = i2c_get_clientdata(client);
struct i2c_dev *i2c_dev = NULL;
if (!nfc_dev) {
pr_err("NxpDrv: %s: device doesn't exist anymore\n", __func__);
return -ENODEV;
}
i2c_dev = &nfc_dev->i2c_dev;
NFCLOG_IPC(nfc_dev, false, "%s: irq_wake_up = %d", __func__,
i2c_dev->irq_wake_up);
if (device_may_wakeup(&client->dev) && i2c_dev->irq_wake_up) {
if (!disable_irq_wake(client->irq))
i2c_dev->irq_wake_up = false;
}
pr_debug("NxpDrv: %s: irq_wake_up = %d", __func__, i2c_dev->irq_wake_up);
return 0;
}
static const struct i2c_device_id nfc_i2c_dev_id[] = { { NFC_I2C_DEV_ID, 0 },
{} };
static const struct of_device_id nfc_i2c_dev_match_table[] = {
{
.compatible = NFC_I2C_DRV_STR,
},
{}
};
static const struct dev_pm_ops nfc_i2c_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(
nfc_i2c_dev_suspend, nfc_i2c_dev_resume) };
static struct i2c_driver nfc_i2c_dev_driver = {
.id_table = nfc_i2c_dev_id,
.probe = nfc_i2c_dev_probe,
.remove = nfc_i2c_dev_remove,
.driver = {
.name = NFC_I2C_DRV_STR,
.pm = &nfc_i2c_dev_pm_ops,
.of_match_table = nfc_i2c_dev_match_table,
.probe_type = PROBE_PREFER_ASYNCHRONOUS,
},
};
MODULE_DEVICE_TABLE(of, nfc_i2c_dev_match_table);
static int __init nfc_i2c_dev_init(void)
{
int ret = 0;
pr_info("NxpDrv: %s: Loading NXP NFC I2C driver\n", __func__);
ret = i2c_add_driver(&nfc_i2c_dev_driver);
if (ret != 0)
pr_err("NxpDrv: %s: NFC I2C add driver error ret %d\n", __func__, ret);
return ret;
}
module_init(nfc_i2c_dev_init);
static void __exit nfc_i2c_dev_exit(void)
{
pr_info("NxpDrv: %s: Unloading NXP NFC I2C driver\n", __func__);
i2c_del_driver(&nfc_i2c_dev_driver);
}
module_exit(nfc_i2c_dev_exit);
MODULE_DESCRIPTION("NXP NFC I2C driver");
MODULE_LICENSE("GPL");

66
nxp/opensource/driver/nfc/i2c_drv.h Normal file
View File

@@ -0,0 +1,66 @@
/******************************************************************************
* Copyright (C) 2015, The Linux Foundation. All rights reserved.
* Copyright (C) 2019-2021 NXP
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
******************************************************************************/
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*
******************************************************************************/
#ifndef _I2C_DRV_H_
#define _I2C_DRV_H_
#include <linux/i2c.h>
#include <linux/version.h>
#define NFC_I2C_DRV_STR "qcom,sn-nci" /*kept same as dts */
#define NFC_I2C_DEV_ID "sn-i2c"
struct nfc_dev;
/* Interface specific parameters */
struct i2c_dev {
struct i2c_client *client;
/* IRQ parameters */
bool irq_enabled;
spinlock_t irq_enabled_lock;
/* NFC_IRQ wake-up state */
bool irq_wake_up;
};
long nfc_i2c_dev_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg);
int nfc_i2c_dev_probe(struct i2c_client *client,
const struct i2c_device_id *id);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0))
void nfc_i2c_dev_remove(struct i2c_client *client);
#else
int nfc_i2c_dev_remove(struct i2c_client *client);
#endif
int nfc_i2c_dev_suspend(struct device *device);
int nfc_i2c_dev_resume(struct device *device);
#if IS_ENABLED(CONFIG_NXP_NFC_I2C)
int i2c_enable_irq(struct nfc_dev *dev);
int i2c_disable_irq(struct nfc_dev *dev);
int i2c_write(struct nfc_dev *dev, const char *buf, size_t count,
int max_retry_cnt);
int i2c_read(struct nfc_dev *dev, char *buf, size_t count, int timeout);
#endif
#endif //_I2C_DRV_H_