[mirror_ubuntu-jammy-kernel.git] / drivers / nfc / st-nci / spi.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * SPI Link Layer for ST NCI based Driver
 * Copyright (C) 2014-2015 STMicroelectronics SAS. All rights reserved.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/spi/spi.h>
#include <linux/gpio/consumer.h>
#include <linux/acpi.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/nfc.h>
#include <linux/of.h>
#include <net/nfc/nci.h>

#include "st-nci.h"

#define DRIVER_DESC "NCI NFC driver for ST_NCI"

/* ndlc header */
#define ST_NCI_FRAME_HEADROOM	1
#define ST_NCI_FRAME_TAILROOM	0

#define ST_NCI_SPI_MIN_SIZE 4   /* PCB(1) + NCI Packet header(3) */
#define ST_NCI_SPI_MAX_SIZE 250 /* req 4.2.1 */

#define ST_NCI_DRIVER_NAME "st_nci"
#define ST_NCI_SPI_DRIVER_NAME "st_nci_spi"

struct st_nci_spi_phy {
	struct spi_device *spi_dev;
	struct llt_ndlc *ndlc;

	bool irq_active;

	struct gpio_desc *gpiod_reset;

	struct st_nci_se_status se_status;
};

static int st_nci_spi_enable(void *phy_id)
{
	struct st_nci_spi_phy *phy = phy_id;

	gpiod_set_value(phy->gpiod_reset, 0);
	usleep_range(10000, 15000);
	gpiod_set_value(phy->gpiod_reset, 1);
	usleep_range(80000, 85000);

	if (phy->ndlc->powered == 0 && phy->irq_active == 0) {
		enable_irq(phy->spi_dev->irq);
		phy->irq_active = true;
	}

	return 0;
}

static void st_nci_spi_disable(void *phy_id)
{
	struct st_nci_spi_phy *phy = phy_id;

	disable_irq_nosync(phy->spi_dev->irq);
	phy->irq_active = false;
}

/*
 * Writing a frame must not return the number of written bytes.
 * It must return either zero for success, or <0 for error.
 * In addition, it must not alter the skb
 */
static int st_nci_spi_write(void *phy_id, struct sk_buff *skb)
{
	int r;
	struct st_nci_spi_phy *phy = phy_id;
	struct spi_device *dev = phy->spi_dev;
	struct sk_buff *skb_rx;
	u8 buf[ST_NCI_SPI_MAX_SIZE + NCI_DATA_HDR_SIZE +
	       ST_NCI_FRAME_HEADROOM + ST_NCI_FRAME_TAILROOM];
	struct spi_transfer spi_xfer = {
		.tx_buf = skb->data,
		.rx_buf = buf,
		.len = skb->len,
	};

	if (phy->ndlc->hard_fault != 0)
		return phy->ndlc->hard_fault;

	r = spi_sync_transfer(dev, &spi_xfer, 1);
	/*
	 * We may have received some valuable data on miso line.
	 * Send them back in the ndlc state machine.
	 */
	if (!r) {
		skb_rx = alloc_skb(skb->len, GFP_KERNEL);
		if (!skb_rx) {
			r = -ENOMEM;
			goto exit;
		}

		skb_put(skb_rx, skb->len);
		memcpy(skb_rx->data, buf, skb->len);
		ndlc_recv(phy->ndlc, skb_rx);
	}

exit:
	return r;
}

/*
 * Reads an ndlc frame and returns it in a newly allocated sk_buff.
 * returns:
 * 0 : if received frame is complete
 * -EREMOTEIO : i2c read error (fatal)
 * -EBADMSG : frame was incorrect and discarded
 * -ENOMEM : cannot allocate skb, frame dropped
 */
static int st_nci_spi_read(struct st_nci_spi_phy *phy,
			struct sk_buff **skb)
{
	int r;
	u8 len;
	u8 buf[ST_NCI_SPI_MAX_SIZE];
	struct spi_device *dev = phy->spi_dev;
	struct spi_transfer spi_xfer = {
		.rx_buf = buf,
		.len = ST_NCI_SPI_MIN_SIZE,
	};

	r = spi_sync_transfer(dev, &spi_xfer, 1);
	if (r < 0)
		return -EREMOTEIO;

	len = be16_to_cpu(*(__be16 *) (buf + 2));
	if (len > ST_NCI_SPI_MAX_SIZE) {
		nfc_err(&dev->dev, "invalid frame len\n");
		phy->ndlc->hard_fault = 1;
		return -EBADMSG;
	}

	*skb = alloc_skb(ST_NCI_SPI_MIN_SIZE + len, GFP_KERNEL);
	if (*skb == NULL)
		return -ENOMEM;

	skb_reserve(*skb, ST_NCI_SPI_MIN_SIZE);
	skb_put(*skb, ST_NCI_SPI_MIN_SIZE);
	memcpy((*skb)->data, buf, ST_NCI_SPI_MIN_SIZE);

	if (!len)
		return 0;

	spi_xfer.len = len;
	r = spi_sync_transfer(dev, &spi_xfer, 1);
	if (r < 0) {
		kfree_skb(*skb);
		return -EREMOTEIO;
	}

	skb_put(*skb, len);
	memcpy((*skb)->data + ST_NCI_SPI_MIN_SIZE, buf, len);

	return 0;
}

/*
 * Reads an ndlc frame from the chip.
 *
 * On ST21NFCB, IRQ goes in idle state when read starts.
 */
static irqreturn_t st_nci_irq_thread_fn(int irq, void *phy_id)
{
	struct st_nci_spi_phy *phy = phy_id;
	struct spi_device *dev;
	struct sk_buff *skb = NULL;
	int r;

	if (!phy || !phy->ndlc || irq != phy->spi_dev->irq) {
		WARN_ON_ONCE(1);
		return IRQ_NONE;
	}

	dev = phy->spi_dev;
	dev_dbg(&dev->dev, "IRQ\n");

	if (phy->ndlc->hard_fault)
		return IRQ_HANDLED;

	if (!phy->ndlc->powered) {
		st_nci_spi_disable(phy);
		return IRQ_HANDLED;
	}

	r = st_nci_spi_read(phy, &skb);
	if (r == -EREMOTEIO || r == -ENOMEM || r == -EBADMSG)
		return IRQ_HANDLED;

	ndlc_recv(phy->ndlc, skb);

	return IRQ_HANDLED;
}

static struct nfc_phy_ops spi_phy_ops = {
	.write = st_nci_spi_write,
	.enable = st_nci_spi_enable,
	.disable = st_nci_spi_disable,
};

static const struct acpi_gpio_params reset_gpios = { 1, 0, false };

static const struct acpi_gpio_mapping acpi_st_nci_gpios[] = {
	{ "reset-gpios", &reset_gpios, 1 },
	{},
};

static int st_nci_spi_probe(struct spi_device *dev)
{
	struct st_nci_spi_phy *phy;
	int r;

	dev_dbg(&dev->dev, "%s\n", __func__);
	dev_dbg(&dev->dev, "IRQ: %d\n", dev->irq);

	/* Check SPI platform functionnalities */
	if (!dev) {
		pr_debug("%s: dev is NULL. Device is not accessible.\n",
			__func__);
		return -ENODEV;
	}

	phy = devm_kzalloc(&dev->dev, sizeof(struct st_nci_spi_phy),
			   GFP_KERNEL);
	if (!phy)
		return -ENOMEM;

	phy->spi_dev = dev;

	spi_set_drvdata(dev, phy);

	r = devm_acpi_dev_add_driver_gpios(&dev->dev, acpi_st_nci_gpios);
	if (r)
		dev_dbg(&dev->dev, "Unable to add GPIO mapping table\n");

	/* Get RESET GPIO */
	phy->gpiod_reset = devm_gpiod_get(&dev->dev, "reset", GPIOD_OUT_HIGH);
	if (IS_ERR(phy->gpiod_reset)) {
		nfc_err(&dev->dev, "Unable to get RESET GPIO\n");
		return PTR_ERR(phy->gpiod_reset);
	}

	phy->se_status.is_ese_present =
			device_property_read_bool(&dev->dev, "ese-present");
	phy->se_status.is_uicc_present =
			device_property_read_bool(&dev->dev, "uicc-present");

	r = ndlc_probe(phy, &spi_phy_ops, &dev->dev,
			ST_NCI_FRAME_HEADROOM, ST_NCI_FRAME_TAILROOM,
			&phy->ndlc, &phy->se_status);
	if (r < 0) {
		nfc_err(&dev->dev, "Unable to register ndlc layer\n");
		return r;
	}

	phy->irq_active = true;
	r = devm_request_threaded_irq(&dev->dev, dev->irq, NULL,
				st_nci_irq_thread_fn,
				IRQF_ONESHOT,
				ST_NCI_SPI_DRIVER_NAME, phy);
	if (r < 0)
		nfc_err(&dev->dev, "Unable to register IRQ handler\n");

	return r;
}

static int st_nci_spi_remove(struct spi_device *dev)
{
	struct st_nci_spi_phy *phy = spi_get_drvdata(dev);

	dev_dbg(&dev->dev, "%s\n", __func__);

	ndlc_remove(phy->ndlc);

	return 0;
}

static struct spi_device_id st_nci_spi_id_table[] = {
	{ST_NCI_SPI_DRIVER_NAME, 0},
	{}
};
MODULE_DEVICE_TABLE(spi, st_nci_spi_id_table);

static const struct acpi_device_id st_nci_spi_acpi_match[] = {
	{"SMO2101", 0},
	{}
};
MODULE_DEVICE_TABLE(acpi, st_nci_spi_acpi_match);

static const struct of_device_id of_st_nci_spi_match[] = {
	{ .compatible = "st,st21nfcb-spi", },
	{}
};
MODULE_DEVICE_TABLE(of, of_st_nci_spi_match);

static struct spi_driver st_nci_spi_driver = {
	.driver = {
		.name = ST_NCI_SPI_DRIVER_NAME,
		.of_match_table = of_match_ptr(of_st_nci_spi_match),
		.acpi_match_table = ACPI_PTR(st_nci_spi_acpi_match),
	},
	.probe = st_nci_spi_probe,
	.id_table = st_nci_spi_id_table,
	.remove = st_nci_spi_remove,
};
module_spi_driver(st_nci_spi_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION(DRIVER_DESC);
Commit	Line	Data
46fe7771	1	// SPDX-License-Identifier: GPL-2.0-only
2bc4d4f8 CR	2	/*
	3	* SPI Link Layer for ST NCI based Driver
	4	* Copyright (C) 2014-2015 STMicroelectronics SAS. All rights reserved.
2bc4d4f8 CR	5	*/
	6
	7	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	8
	9	#include <linux/module.h>
	10	#include <linux/spi/spi.h>
60cd6d89	11	#include <linux/gpio/consumer.h>
60cd6d89	12	#include <linux/acpi.h>
2bc4d4f8 CR	13	#include <linux/interrupt.h>
	14	#include <linux/delay.h>
	15	#include <linux/nfc.h>
a89e68f1	16	#include <linux/of.h>
a1269dd1	17	#include <net/nfc/nci.h>
2bc4d4f8	18
e67e7e59	19	#include "st-nci.h"
2bc4d4f8 CR	20
	21	#define DRIVER_DESC "NCI NFC driver for ST_NCI"
	22
	23	/* ndlc header */
	24	#define ST_NCI_FRAME_HEADROOM 1
ba2c231c	25	#define ST_NCI_FRAME_TAILROOM 0
2bc4d4f8 CR	26
	27	#define ST_NCI_SPI_MIN_SIZE 4 /* PCB(1) + NCI Packet header(3) */
	28	#define ST_NCI_SPI_MAX_SIZE 250 /* req 4.2.1 */
	29
61a04101	30	#define ST_NCI_DRIVER_NAME "st_nci"
2bc4d4f8 CR	31	#define ST_NCI_SPI_DRIVER_NAME "st_nci_spi"
2bc4d4f8 CR	32
2bc4d4f8 CR	33	struct st_nci_spi_phy {
	34	struct spi_device *spi_dev;
	35	struct llt_ndlc *ndlc;
	36
bb2496c3 CR	37	bool irq_active;
bb2496c3 CR	38
a89e68f1	39	struct gpio_desc *gpiod_reset;
3648dc6d CR	40
3648dc6d CR	41	struct st_nci_se_status se_status;
2bc4d4f8 CR	42	};
2bc4d4f8 CR	43
2bc4d4f8 CR	44	static int st_nci_spi_enable(void *phy_id)
	45	{
	46	struct st_nci_spi_phy *phy = phy_id;
	47
a89e68f1	48	gpiod_set_value(phy->gpiod_reset, 0);
2bc4d4f8	49	usleep_range(10000, 15000);
a89e68f1	50	gpiod_set_value(phy->gpiod_reset, 1);
2bc4d4f8 CR	51	usleep_range(80000, 85000);
2bc4d4f8 CR	52
bb2496c3	53	if (phy->ndlc->powered == 0 && phy->irq_active == 0) {
2bc4d4f8	54	enable_irq(phy->spi_dev->irq);
bb2496c3 CR	55	phy->irq_active = true;
bb2496c3 CR	56	}
2bc4d4f8 CR	57
	58	return 0;
	59	}
	60
	61	static void st_nci_spi_disable(void *phy_id)
	62	{
	63	struct st_nci_spi_phy *phy = phy_id;
	64
	65	disable_irq_nosync(phy->spi_dev->irq);
bb2496c3	66	phy->irq_active = false;
2bc4d4f8 CR	67	}
	68
	69	/*
	70	* Writing a frame must not return the number of written bytes.
	71	* It must return either zero for success, or <0 for error.
	72	* In addition, it must not alter the skb
	73	*/
	74	static int st_nci_spi_write(void phy_id, struct sk_buff skb)
	75	{
	76	int r;
	77	struct st_nci_spi_phy *phy = phy_id;
	78	struct spi_device *dev = phy->spi_dev;
	79	struct sk_buff *skb_rx;
a1269dd1 CR	80	u8 buf[ST_NCI_SPI_MAX_SIZE + NCI_DATA_HDR_SIZE +
a1269dd1 CR	81	ST_NCI_FRAME_HEADROOM + ST_NCI_FRAME_TAILROOM];
2bc4d4f8 CR	82	struct spi_transfer spi_xfer = {
	83	.tx_buf = skb->data,
	84	.rx_buf = buf,
	85	.len = skb->len,
	86	};
	87
2bc4d4f8 CR	88	if (phy->ndlc->hard_fault != 0)
	89	return phy->ndlc->hard_fault;
	90
	91	r = spi_sync_transfer(dev, &spi_xfer, 1);
	92	/*
	93	* We may have received some valuable data on miso line.
	94	* Send them back in the ndlc state machine.
	95	*/
	96	if (!r) {
	97	skb_rx = alloc_skb(skb->len, GFP_KERNEL);
	98	if (!skb_rx) {
	99	r = -ENOMEM;
	100	goto exit;
	101	}
	102
	103	skb_put(skb_rx, skb->len);
	104	memcpy(skb_rx->data, buf, skb->len);
	105	ndlc_recv(phy->ndlc, skb_rx);
	106	}
	107
	108	exit:
	109	return r;
	110	}
	111
	112	/*
	113	* Reads an ndlc frame and returns it in a newly allocated sk_buff.
	114	* returns:
	115	* 0 : if received frame is complete
	116	* -EREMOTEIO : i2c read error (fatal)
	117	* -EBADMSG : frame was incorrect and discarded
	118	* -ENOMEM : cannot allocate skb, frame dropped
	119	*/
	120	static int st_nci_spi_read(struct st_nci_spi_phy *phy,
	121	struct sk_buff **skb)
	122	{
	123	int r;
	124	u8 len;
	125	u8 buf[ST_NCI_SPI_MAX_SIZE];
	126	struct spi_device *dev = phy->spi_dev;
	127	struct spi_transfer spi_xfer = {
	128	.rx_buf = buf,
	129	.len = ST_NCI_SPI_MIN_SIZE,
	130	};
	131
	132	r = spi_sync_transfer(dev, &spi_xfer, 1);
	133	if (r < 0)
	134	return -EREMOTEIO;
	135
	136	len = be16_to_cpu((__be16 ) (buf + 2));
	137	if (len > ST_NCI_SPI_MAX_SIZE) {
	138	nfc_err(&dev->dev, "invalid frame len\n");
	139	phy->ndlc->hard_fault = 1;
	140	return -EBADMSG;
	141	}
	142
	143	*skb = alloc_skb(ST_NCI_SPI_MIN_SIZE + len, GFP_KERNEL);
	144	if (*skb == NULL)
	145	return -ENOMEM;
	146
	147	skb_reserve(*skb, ST_NCI_SPI_MIN_SIZE);
	148	skb_put(*skb, ST_NCI_SPI_MIN_SIZE);
	149	memcpy((*skb)->data, buf, ST_NCI_SPI_MIN_SIZE);
	150
	151	if (!len)
152	return 0;
153
154	spi_xfer.len = len;
155	r = spi_sync_transfer(dev, &spi_xfer, 1);
156	if (r < 0) {
157	kfree_skb(*skb);
158	return -EREMOTEIO;
159	}
160
161	skb_put(*skb, len);
162	memcpy((*skb)->data + ST_NCI_SPI_MIN_SIZE, buf, len);
163
2bc4d4f8 CR	164	return 0;
	165	}
	166
	167	/*
	168	* Reads an ndlc frame from the chip.
	169	*
	170	* On ST21NFCB, IRQ goes in idle state when read starts.
	171	*/
	172	static irqreturn_t st_nci_irq_thread_fn(int irq, void *phy_id)
	173	{
	174	struct st_nci_spi_phy *phy = phy_id;
	175	struct spi_device *dev;
	176	struct sk_buff *skb = NULL;
	177	int r;
	178
	179	if (!phy \|\| !phy->ndlc \|\| irq != phy->spi_dev->irq) {
	180	WARN_ON_ONCE(1);
	181	return IRQ_NONE;
	182	}
	183
	184	dev = phy->spi_dev;
	185	dev_dbg(&dev->dev, "IRQ\n");
	186
	187	if (phy->ndlc->hard_fault)
	188	return IRQ_HANDLED;
	189
	190	if (!phy->ndlc->powered) {
	191	st_nci_spi_disable(phy);
	192	return IRQ_HANDLED;
	193	}
	194
	195	r = st_nci_spi_read(phy, &skb);
	196	if (r == -EREMOTEIO \|\| r == -ENOMEM \|\| r == -EBADMSG)
	197	return IRQ_HANDLED;
	198
	199	ndlc_recv(phy->ndlc, skb);
	200
	201	return IRQ_HANDLED;
	202	}
	203
	204	static struct nfc_phy_ops spi_phy_ops = {
	205	.write = st_nci_spi_write,
	206	.enable = st_nci_spi_enable,
	207	.disable = st_nci_spi_disable,
	208	};
	209
85d23e77 AS	210	static const struct acpi_gpio_params reset_gpios = { 1, 0, false };
	211
	212	static const struct acpi_gpio_mapping acpi_st_nci_gpios[] = {
	213	{ "reset-gpios", &reset_gpios, 1 },
	214	{},
	215	};
	216
2bc4d4f8 CR	217	static int st_nci_spi_probe(struct spi_device *dev)
	218	{
	219	struct st_nci_spi_phy *phy;
2bc4d4f8 CR	220	int r;
	221
	222	dev_dbg(&dev->dev, "%s\n", __func__);
	223	dev_dbg(&dev->dev, "IRQ: %d\n", dev->irq);
	224
	225	/* Check SPI platform functionnalities */
	226	if (!dev) {
	227	pr_debug("%s: dev is NULL. Device is not accessible.\n",
	228	__func__);
	229	return -ENODEV;
	230	}
	231
	232	phy = devm_kzalloc(&dev->dev, sizeof(struct st_nci_spi_phy),
	233	GFP_KERNEL);
	234	if (!phy)
	235	return -ENOMEM;
	236
	237	phy->spi_dev = dev;
	238
	239	spi_set_drvdata(dev, phy);
	240
c745120e AS	241	r = devm_acpi_dev_add_driver_gpios(&dev->dev, acpi_st_nci_gpios);
	242	if (r)
	243	dev_dbg(&dev->dev, "Unable to add GPIO mapping table\n");
	244
	245	/* Get RESET GPIO */
	246	phy->gpiod_reset = devm_gpiod_get(&dev->dev, "reset", GPIOD_OUT_HIGH);
	247	if (IS_ERR(phy->gpiod_reset)) {
	248	nfc_err(&dev->dev, "Unable to get RESET GPIO\n");
	249	return PTR_ERR(phy->gpiod_reset);
2bc4d4f8 CR	250	}
2bc4d4f8 CR	251
75719b2b AS	252	phy->se_status.is_ese_present =
	253	device_property_read_bool(&dev->dev, "ese-present");
	254	phy->se_status.is_uicc_present =
	255	device_property_read_bool(&dev->dev, "uicc-present");
	256
2bc4d4f8 CR	257	r = ndlc_probe(phy, &spi_phy_ops, &dev->dev,
2bc4d4f8 CR	258	ST_NCI_FRAME_HEADROOM, ST_NCI_FRAME_TAILROOM,
3648dc6d	259	&phy->ndlc, &phy->se_status);
2bc4d4f8 CR	260	if (r < 0) {
	261	nfc_err(&dev->dev, "Unable to register ndlc layer\n");
	262	return r;
	263	}
	264
bb2496c3	265	phy->irq_active = true;
2bc4d4f8 CR	266	r = devm_request_threaded_irq(&dev->dev, dev->irq, NULL,
2bc4d4f8 CR	267	st_nci_irq_thread_fn,
1af9fea6	268	IRQF_ONESHOT,
2bc4d4f8 CR	269	ST_NCI_SPI_DRIVER_NAME, phy);
	270	if (r < 0)
	271	nfc_err(&dev->dev, "Unable to register IRQ handler\n");
	272
	273	return r;
	274	}
	275
	276	static int st_nci_spi_remove(struct spi_device *dev)
	277	{
	278	struct st_nci_spi_phy *phy = spi_get_drvdata(dev);
	279
	280	dev_dbg(&dev->dev, "%s\n", __func__);
	281
	282	ndlc_remove(phy->ndlc);
	283
	284	return 0;
	285	}
	286
3252897f CR	287	static struct spi_device_id st_nci_spi_id_table[] = {
	288	{ST_NCI_SPI_DRIVER_NAME, 0},
	289	{}
	290	};
	291	MODULE_DEVICE_TABLE(spi, st_nci_spi_id_table);
	292
60cd6d89 CR	293	static const struct acpi_device_id st_nci_spi_acpi_match[] = {
	294	{"SMO2101", 0},
	295	{}
	296	};
	297	MODULE_DEVICE_TABLE(acpi, st_nci_spi_acpi_match);
	298
2bc4d4f8 CR	299	static const struct of_device_id of_st_nci_spi_match[] = {
	300	{ .compatible = "st,st21nfcb-spi", },
	301	{}
	302	};
	303	MODULE_DEVICE_TABLE(of, of_st_nci_spi_match);
2bc4d4f8 CR	304
	305	static struct spi_driver st_nci_spi_driver = {
	306	.driver = {
2bc4d4f8 CR	307	.name = ST_NCI_SPI_DRIVER_NAME,
2bc4d4f8 CR	308	.of_match_table = of_match_ptr(of_st_nci_spi_match),
60cd6d89	309	.acpi_match_table = ACPI_PTR(st_nci_spi_acpi_match),
2bc4d4f8 CR	310	},
	311	.probe = st_nci_spi_probe,
	312	.id_table = st_nci_spi_id_table,
	313	.remove = st_nci_spi_remove,
	314	};
2bc4d4f8 CR	315	module_spi_driver(st_nci_spi_driver);
	316
	317	MODULE_LICENSE("GPL");
	318	MODULE_DESCRIPTION(DRIVER_DESC);