1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Marvell NFC-over-SPI driver: SPI interface related functions |
4 | * |
5 | * Copyright (C) 2015, Marvell International Ltd. |
6 | */ |
7 | |
8 | #include <linux/module.h> |
9 | #include <linux/interrupt.h> |
10 | #include <linux/nfc.h> |
11 | #include <linux/of_irq.h> |
12 | #include <net/nfc/nci.h> |
13 | #include <net/nfc/nci_core.h> |
14 | #include <linux/spi/spi.h> |
15 | #include "nfcmrvl.h" |
16 | |
17 | #define SPI_WAIT_HANDSHAKE 1 |
18 | |
19 | struct nfcmrvl_spi_drv_data { |
20 | unsigned long flags; |
21 | struct spi_device *spi; |
22 | struct nci_spi *nci_spi; |
23 | struct completion handshake_completion; |
24 | struct nfcmrvl_private *priv; |
25 | }; |
26 | |
27 | static irqreturn_t nfcmrvl_spi_int_irq_thread_fn(int irq, void *drv_data_ptr) |
28 | { |
29 | struct nfcmrvl_spi_drv_data *drv_data = drv_data_ptr; |
30 | struct sk_buff *skb; |
31 | |
32 | /* |
33 | * Special case where we are waiting for SPI_INT deassertion to start a |
34 | * transfer. |
35 | */ |
36 | if (test_and_clear_bit(SPI_WAIT_HANDSHAKE, addr: &drv_data->flags)) { |
37 | complete(&drv_data->handshake_completion); |
38 | return IRQ_HANDLED; |
39 | } |
40 | |
41 | /* Normal case, SPI_INT deasserted by slave to trigger a master read */ |
42 | |
43 | skb = nci_spi_read(nspi: drv_data->nci_spi); |
44 | if (!skb) { |
45 | nfc_err(&drv_data->spi->dev, "failed to read spi packet" ); |
46 | return IRQ_HANDLED; |
47 | } |
48 | |
49 | if (nfcmrvl_nci_recv_frame(priv: drv_data->priv, skb) < 0) |
50 | nfc_err(&drv_data->spi->dev, "corrupted RX packet" ); |
51 | |
52 | return IRQ_HANDLED; |
53 | } |
54 | |
55 | static int nfcmrvl_spi_nci_open(struct nfcmrvl_private *priv) |
56 | { |
57 | return 0; |
58 | } |
59 | |
60 | static int nfcmrvl_spi_nci_close(struct nfcmrvl_private *priv) |
61 | { |
62 | return 0; |
63 | } |
64 | |
65 | static int nfcmrvl_spi_nci_send(struct nfcmrvl_private *priv, |
66 | struct sk_buff *skb) |
67 | { |
68 | struct nfcmrvl_spi_drv_data *drv_data = priv->drv_data; |
69 | int err; |
70 | |
71 | /* Reinit completion for slave handshake */ |
72 | reinit_completion(x: &drv_data->handshake_completion); |
73 | set_bit(SPI_WAIT_HANDSHAKE, addr: &drv_data->flags); |
74 | |
75 | /* |
76 | * Append a dummy byte at the end of SPI frame. This is due to a |
77 | * specific DMA implementation in the controller |
78 | */ |
79 | skb_put(skb, len: 1); |
80 | |
81 | /* Send the SPI packet */ |
82 | err = nci_spi_send(nspi: drv_data->nci_spi, write_handshake_completion: &drv_data->handshake_completion, |
83 | skb); |
84 | if (err) |
85 | nfc_err(priv->dev, "spi_send failed %d" , err); |
86 | |
87 | return err; |
88 | } |
89 | |
90 | static void nfcmrvl_spi_nci_update_config(struct nfcmrvl_private *priv, |
91 | const void *param) |
92 | { |
93 | struct nfcmrvl_spi_drv_data *drv_data = priv->drv_data; |
94 | const struct nfcmrvl_fw_spi_config *config = param; |
95 | |
96 | drv_data->nci_spi->xfer_speed_hz = config->clk; |
97 | } |
98 | |
99 | static const struct nfcmrvl_if_ops spi_ops = { |
100 | .nci_open = nfcmrvl_spi_nci_open, |
101 | .nci_close = nfcmrvl_spi_nci_close, |
102 | .nci_send = nfcmrvl_spi_nci_send, |
103 | .nci_update_config = nfcmrvl_spi_nci_update_config, |
104 | }; |
105 | |
106 | static int nfcmrvl_spi_parse_dt(struct device_node *node, |
107 | struct nfcmrvl_platform_data *pdata) |
108 | { |
109 | int ret; |
110 | |
111 | ret = nfcmrvl_parse_dt(node, pdata); |
112 | if (ret < 0) { |
113 | pr_err("Failed to get generic entries\n" ); |
114 | return ret; |
115 | } |
116 | |
117 | ret = irq_of_parse_and_map(node, index: 0); |
118 | if (!ret) { |
119 | pr_err("Unable to get irq\n" ); |
120 | return -EINVAL; |
121 | } |
122 | pdata->irq = ret; |
123 | |
124 | return 0; |
125 | } |
126 | |
127 | static int nfcmrvl_spi_probe(struct spi_device *spi) |
128 | { |
129 | const struct nfcmrvl_platform_data *pdata; |
130 | struct nfcmrvl_platform_data config; |
131 | struct nfcmrvl_spi_drv_data *drv_data; |
132 | int ret = 0; |
133 | |
134 | drv_data = devm_kzalloc(dev: &spi->dev, size: sizeof(*drv_data), GFP_KERNEL); |
135 | if (!drv_data) |
136 | return -ENOMEM; |
137 | |
138 | drv_data->spi = spi; |
139 | drv_data->priv = NULL; |
140 | spi_set_drvdata(spi, data: drv_data); |
141 | |
142 | pdata = spi->dev.platform_data; |
143 | |
144 | if (!pdata && spi->dev.of_node) |
145 | if (nfcmrvl_spi_parse_dt(node: spi->dev.of_node, pdata: &config) == 0) |
146 | pdata = &config; |
147 | |
148 | if (!pdata) |
149 | return -EINVAL; |
150 | |
151 | ret = devm_request_threaded_irq(dev: &drv_data->spi->dev, irq: pdata->irq, |
152 | NULL, thread_fn: nfcmrvl_spi_int_irq_thread_fn, |
153 | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
154 | devname: "nfcmrvl_spi_int" , dev_id: drv_data); |
155 | if (ret < 0) { |
156 | nfc_err(&drv_data->spi->dev, "Unable to register IRQ handler" ); |
157 | return -ENODEV; |
158 | } |
159 | |
160 | drv_data->priv = nfcmrvl_nci_register_dev(phy: NFCMRVL_PHY_SPI, |
161 | drv_data, ops: &spi_ops, |
162 | dev: &drv_data->spi->dev, |
163 | pdata); |
164 | if (IS_ERR(ptr: drv_data->priv)) |
165 | return PTR_ERR(ptr: drv_data->priv); |
166 | |
167 | drv_data->priv->support_fw_dnld = true; |
168 | |
169 | drv_data->nci_spi = nci_spi_allocate_spi(spi: drv_data->spi, acknowledge_mode: 0, delay: 10, |
170 | ndev: drv_data->priv->ndev); |
171 | |
172 | /* Init completion for slave handshake */ |
173 | init_completion(x: &drv_data->handshake_completion); |
174 | return 0; |
175 | } |
176 | |
177 | static void nfcmrvl_spi_remove(struct spi_device *spi) |
178 | { |
179 | struct nfcmrvl_spi_drv_data *drv_data = spi_get_drvdata(spi); |
180 | |
181 | nfcmrvl_nci_unregister_dev(priv: drv_data->priv); |
182 | } |
183 | |
184 | static const struct of_device_id of_nfcmrvl_spi_match[] __maybe_unused = { |
185 | { .compatible = "marvell,nfc-spi" , }, |
186 | {}, |
187 | }; |
188 | MODULE_DEVICE_TABLE(of, of_nfcmrvl_spi_match); |
189 | |
190 | static const struct spi_device_id nfcmrvl_spi_id_table[] = { |
191 | { "nfcmrvl_spi" , 0 }, |
192 | { } |
193 | }; |
194 | MODULE_DEVICE_TABLE(spi, nfcmrvl_spi_id_table); |
195 | |
196 | static struct spi_driver nfcmrvl_spi_driver = { |
197 | .probe = nfcmrvl_spi_probe, |
198 | .remove = nfcmrvl_spi_remove, |
199 | .id_table = nfcmrvl_spi_id_table, |
200 | .driver = { |
201 | .name = "nfcmrvl_spi" , |
202 | .owner = THIS_MODULE, |
203 | .of_match_table = of_match_ptr(of_nfcmrvl_spi_match), |
204 | }, |
205 | }; |
206 | |
207 | module_spi_driver(nfcmrvl_spi_driver); |
208 | |
209 | MODULE_AUTHOR("Marvell International Ltd." ); |
210 | MODULE_DESCRIPTION("Marvell NFC-over-SPI driver" ); |
211 | MODULE_LICENSE("GPL v2" ); |
212 | |