1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * I2C link layer for the NXP NCI driver |
4 | * |
5 | * Copyright (C) 2014 NXP Semiconductors All rights reserved. |
6 | * Copyright (C) 2012-2015 Intel Corporation. All rights reserved. |
7 | * |
8 | * Authors: Clément Perrochaud <clement.perrochaud@nxp.com> |
9 | * Authors: Oleg Zhurakivskyy <oleg.zhurakivskyy@intel.com> |
10 | * |
11 | * Derived from PN544 device driver: |
12 | * Copyright (C) 2012 Intel Corporation. All rights reserved. |
13 | */ |
14 | |
15 | #include <linux/acpi.h> |
16 | #include <linux/delay.h> |
17 | #include <linux/i2c.h> |
18 | #include <linux/interrupt.h> |
19 | #include <linux/module.h> |
20 | #include <linux/nfc.h> |
21 | #include <linux/gpio/consumer.h> |
22 | #include <asm/unaligned.h> |
23 | |
24 | #include <net/nfc/nfc.h> |
25 | |
26 | #include "nxp-nci.h" |
27 | |
28 | #define NXP_NCI_I2C_DRIVER_NAME "nxp-nci_i2c" |
29 | |
30 | #define NXP_NCI_I2C_MAX_PAYLOAD 32 |
31 | |
32 | struct nxp_nci_i2c_phy { |
33 | struct i2c_client *i2c_dev; |
34 | struct nci_dev *ndev; |
35 | |
36 | struct gpio_desc *gpiod_en; |
37 | struct gpio_desc *gpiod_fw; |
38 | |
39 | int hard_fault; /* |
40 | * < 0 if hardware error occurred (e.g. i2c err) |
41 | * and prevents normal operation. |
42 | */ |
43 | }; |
44 | |
45 | static int nxp_nci_i2c_set_mode(void *phy_id, |
46 | enum nxp_nci_mode mode) |
47 | { |
48 | struct nxp_nci_i2c_phy *phy = (struct nxp_nci_i2c_phy *) phy_id; |
49 | |
50 | gpiod_set_value(desc: phy->gpiod_fw, value: (mode == NXP_NCI_MODE_FW) ? 1 : 0); |
51 | gpiod_set_value(desc: phy->gpiod_en, value: (mode != NXP_NCI_MODE_COLD) ? 1 : 0); |
52 | usleep_range(min: 10000, max: 15000); |
53 | |
54 | if (mode == NXP_NCI_MODE_COLD) |
55 | phy->hard_fault = 0; |
56 | |
57 | return 0; |
58 | } |
59 | |
60 | static int nxp_nci_i2c_write(void *phy_id, struct sk_buff *skb) |
61 | { |
62 | int r; |
63 | struct nxp_nci_i2c_phy *phy = phy_id; |
64 | struct i2c_client *client = phy->i2c_dev; |
65 | |
66 | if (phy->hard_fault != 0) |
67 | return phy->hard_fault; |
68 | |
69 | r = i2c_master_send(client, buf: skb->data, count: skb->len); |
70 | if (r < 0) { |
71 | /* Retry, chip was in standby */ |
72 | msleep(msecs: 110); |
73 | r = i2c_master_send(client, buf: skb->data, count: skb->len); |
74 | } |
75 | |
76 | if (r < 0) { |
77 | nfc_err(&client->dev, "Error %d on I2C send\n" , r); |
78 | } else if (r != skb->len) { |
79 | nfc_err(&client->dev, |
80 | "Invalid length sent: %u (expected %u)\n" , |
81 | r, skb->len); |
82 | r = -EREMOTEIO; |
83 | } else { |
84 | /* Success but return 0 and not number of bytes */ |
85 | r = 0; |
86 | } |
87 | |
88 | return r; |
89 | } |
90 | |
91 | static const struct nxp_nci_phy_ops i2c_phy_ops = { |
92 | .set_mode = nxp_nci_i2c_set_mode, |
93 | .write = nxp_nci_i2c_write, |
94 | }; |
95 | |
96 | static int nxp_nci_i2c_fw_read(struct nxp_nci_i2c_phy *phy, |
97 | struct sk_buff **skb) |
98 | { |
99 | struct i2c_client *client = phy->i2c_dev; |
100 | size_t frame_len; |
101 | __be16 ; |
102 | int r; |
103 | |
104 | r = i2c_master_recv(client, buf: (u8 *) &header, NXP_NCI_FW_HDR_LEN); |
105 | if (r < 0) { |
106 | goto fw_read_exit; |
107 | } else if (r != NXP_NCI_FW_HDR_LEN) { |
108 | nfc_err(&client->dev, "Incorrect header length: %u\n" , r); |
109 | r = -EBADMSG; |
110 | goto fw_read_exit; |
111 | } |
112 | |
113 | frame_len = (be16_to_cpu(header) & NXP_NCI_FW_FRAME_LEN_MASK) + |
114 | NXP_NCI_FW_CRC_LEN; |
115 | |
116 | *skb = alloc_skb(NXP_NCI_FW_HDR_LEN + frame_len, GFP_KERNEL); |
117 | if (*skb == NULL) { |
118 | r = -ENOMEM; |
119 | goto fw_read_exit; |
120 | } |
121 | |
122 | skb_put_data(skb: *skb, data: &header, NXP_NCI_FW_HDR_LEN); |
123 | |
124 | r = i2c_master_recv(client, buf: skb_put(skb: *skb, len: frame_len), count: frame_len); |
125 | if (r < 0) { |
126 | goto fw_read_exit_free_skb; |
127 | } else if (r != frame_len) { |
128 | nfc_err(&client->dev, |
129 | "Invalid frame length: %u (expected %zu)\n" , |
130 | r, frame_len); |
131 | r = -EBADMSG; |
132 | goto fw_read_exit_free_skb; |
133 | } |
134 | |
135 | return 0; |
136 | |
137 | fw_read_exit_free_skb: |
138 | kfree_skb(skb: *skb); |
139 | fw_read_exit: |
140 | return r; |
141 | } |
142 | |
143 | static int nxp_nci_i2c_nci_read(struct nxp_nci_i2c_phy *phy, |
144 | struct sk_buff **skb) |
145 | { |
146 | struct nci_ctrl_hdr ; /* May actually be a data header */ |
147 | struct i2c_client *client = phy->i2c_dev; |
148 | int r; |
149 | |
150 | r = i2c_master_recv(client, buf: (u8 *) &header, NCI_CTRL_HDR_SIZE); |
151 | if (r < 0) { |
152 | goto nci_read_exit; |
153 | } else if (r != NCI_CTRL_HDR_SIZE) { |
154 | nfc_err(&client->dev, "Incorrect header length: %u\n" , r); |
155 | r = -EBADMSG; |
156 | goto nci_read_exit; |
157 | } |
158 | |
159 | *skb = alloc_skb(NCI_CTRL_HDR_SIZE + header.plen, GFP_KERNEL); |
160 | if (*skb == NULL) { |
161 | r = -ENOMEM; |
162 | goto nci_read_exit; |
163 | } |
164 | |
165 | skb_put_data(skb: *skb, data: (void *)&header, NCI_CTRL_HDR_SIZE); |
166 | |
167 | if (!header.plen) |
168 | return 0; |
169 | |
170 | r = i2c_master_recv(client, buf: skb_put(skb: *skb, len: header.plen), count: header.plen); |
171 | if (r < 0) { |
172 | goto nci_read_exit_free_skb; |
173 | } else if (r != header.plen) { |
174 | nfc_err(&client->dev, |
175 | "Invalid frame payload length: %u (expected %u)\n" , |
176 | r, header.plen); |
177 | r = -EBADMSG; |
178 | goto nci_read_exit_free_skb; |
179 | } |
180 | |
181 | return 0; |
182 | |
183 | nci_read_exit_free_skb: |
184 | kfree_skb(skb: *skb); |
185 | nci_read_exit: |
186 | return r; |
187 | } |
188 | |
189 | static irqreturn_t nxp_nci_i2c_irq_thread_fn(int irq, void *phy_id) |
190 | { |
191 | struct nxp_nci_i2c_phy *phy = phy_id; |
192 | struct i2c_client *client; |
193 | struct nxp_nci_info *info; |
194 | |
195 | struct sk_buff *skb = NULL; |
196 | int r = 0; |
197 | |
198 | if (!phy || !phy->ndev) |
199 | goto exit_irq_none; |
200 | |
201 | client = phy->i2c_dev; |
202 | |
203 | if (!client || irq != client->irq) |
204 | goto exit_irq_none; |
205 | |
206 | info = nci_get_drvdata(ndev: phy->ndev); |
207 | |
208 | if (!info) |
209 | goto exit_irq_none; |
210 | |
211 | mutex_lock(&info->info_lock); |
212 | |
213 | if (phy->hard_fault != 0) |
214 | goto exit_irq_handled; |
215 | |
216 | switch (info->mode) { |
217 | case NXP_NCI_MODE_NCI: |
218 | r = nxp_nci_i2c_nci_read(phy, skb: &skb); |
219 | break; |
220 | case NXP_NCI_MODE_FW: |
221 | r = nxp_nci_i2c_fw_read(phy, skb: &skb); |
222 | break; |
223 | case NXP_NCI_MODE_COLD: |
224 | r = -EREMOTEIO; |
225 | break; |
226 | } |
227 | |
228 | if (r == -EREMOTEIO) { |
229 | phy->hard_fault = r; |
230 | if (info->mode == NXP_NCI_MODE_FW) |
231 | nxp_nci_fw_recv_frame(ndev: phy->ndev, NULL); |
232 | } |
233 | if (r < 0) { |
234 | nfc_err(&client->dev, "Read failed with error %d\n" , r); |
235 | goto exit_irq_handled; |
236 | } |
237 | |
238 | switch (info->mode) { |
239 | case NXP_NCI_MODE_NCI: |
240 | nci_recv_frame(ndev: phy->ndev, skb); |
241 | break; |
242 | case NXP_NCI_MODE_FW: |
243 | nxp_nci_fw_recv_frame(ndev: phy->ndev, skb); |
244 | break; |
245 | case NXP_NCI_MODE_COLD: |
246 | break; |
247 | } |
248 | |
249 | exit_irq_handled: |
250 | mutex_unlock(lock: &info->info_lock); |
251 | return IRQ_HANDLED; |
252 | exit_irq_none: |
253 | WARN_ON_ONCE(1); |
254 | return IRQ_NONE; |
255 | } |
256 | |
257 | static const struct acpi_gpio_params firmware_gpios = { 1, 0, false }; |
258 | static const struct acpi_gpio_params enable_gpios = { 2, 0, false }; |
259 | |
260 | static const struct acpi_gpio_mapping acpi_nxp_nci_gpios[] = { |
261 | { "enable-gpios" , &enable_gpios, 1 }, |
262 | { "firmware-gpios" , &firmware_gpios, 1 }, |
263 | { } |
264 | }; |
265 | |
266 | static int nxp_nci_i2c_probe(struct i2c_client *client) |
267 | { |
268 | struct device *dev = &client->dev; |
269 | struct nxp_nci_i2c_phy *phy; |
270 | int r; |
271 | |
272 | if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_I2C)) { |
273 | nfc_err(&client->dev, "Need I2C_FUNC_I2C\n" ); |
274 | return -ENODEV; |
275 | } |
276 | |
277 | phy = devm_kzalloc(dev: &client->dev, size: sizeof(struct nxp_nci_i2c_phy), |
278 | GFP_KERNEL); |
279 | if (!phy) |
280 | return -ENOMEM; |
281 | |
282 | phy->i2c_dev = client; |
283 | i2c_set_clientdata(client, data: phy); |
284 | |
285 | r = devm_acpi_dev_add_driver_gpios(dev, gpios: acpi_nxp_nci_gpios); |
286 | if (r) |
287 | dev_dbg(dev, "Unable to add GPIO mapping table\n" ); |
288 | |
289 | phy->gpiod_en = devm_gpiod_get(dev, con_id: "enable" , flags: GPIOD_OUT_LOW); |
290 | if (IS_ERR(ptr: phy->gpiod_en)) { |
291 | nfc_err(dev, "Failed to get EN gpio\n" ); |
292 | return PTR_ERR(ptr: phy->gpiod_en); |
293 | } |
294 | |
295 | phy->gpiod_fw = devm_gpiod_get_optional(dev, con_id: "firmware" , flags: GPIOD_OUT_LOW); |
296 | if (IS_ERR(ptr: phy->gpiod_fw)) { |
297 | nfc_err(dev, "Failed to get FW gpio\n" ); |
298 | return PTR_ERR(ptr: phy->gpiod_fw); |
299 | } |
300 | |
301 | r = nxp_nci_probe(phy_id: phy, pdev: &client->dev, phy_ops: &i2c_phy_ops, |
302 | NXP_NCI_I2C_MAX_PAYLOAD, ndev: &phy->ndev); |
303 | if (r < 0) |
304 | return r; |
305 | |
306 | r = request_threaded_irq(irq: client->irq, NULL, |
307 | thread_fn: nxp_nci_i2c_irq_thread_fn, |
308 | IRQF_TRIGGER_RISING | IRQF_ONESHOT, |
309 | NXP_NCI_I2C_DRIVER_NAME, dev: phy); |
310 | if (r < 0) |
311 | nfc_err(&client->dev, "Unable to register IRQ handler\n" ); |
312 | |
313 | return r; |
314 | } |
315 | |
316 | static void nxp_nci_i2c_remove(struct i2c_client *client) |
317 | { |
318 | struct nxp_nci_i2c_phy *phy = i2c_get_clientdata(client); |
319 | |
320 | nxp_nci_remove(ndev: phy->ndev); |
321 | free_irq(client->irq, phy); |
322 | } |
323 | |
324 | static const struct i2c_device_id nxp_nci_i2c_id_table[] = { |
325 | {"nxp-nci_i2c" , 0}, |
326 | {} |
327 | }; |
328 | MODULE_DEVICE_TABLE(i2c, nxp_nci_i2c_id_table); |
329 | |
330 | static const struct of_device_id of_nxp_nci_i2c_match[] = { |
331 | { .compatible = "nxp,nxp-nci-i2c" , }, |
332 | {} |
333 | }; |
334 | MODULE_DEVICE_TABLE(of, of_nxp_nci_i2c_match); |
335 | |
336 | #ifdef CONFIG_ACPI |
337 | static const struct acpi_device_id acpi_id[] = { |
338 | { "NXP1001" }, |
339 | { "NXP1002" }, |
340 | { "NXP7471" }, |
341 | { } |
342 | }; |
343 | MODULE_DEVICE_TABLE(acpi, acpi_id); |
344 | #endif |
345 | |
346 | static struct i2c_driver nxp_nci_i2c_driver = { |
347 | .driver = { |
348 | .name = NXP_NCI_I2C_DRIVER_NAME, |
349 | .acpi_match_table = ACPI_PTR(acpi_id), |
350 | .of_match_table = of_nxp_nci_i2c_match, |
351 | }, |
352 | .probe = nxp_nci_i2c_probe, |
353 | .id_table = nxp_nci_i2c_id_table, |
354 | .remove = nxp_nci_i2c_remove, |
355 | }; |
356 | |
357 | module_i2c_driver(nxp_nci_i2c_driver); |
358 | |
359 | MODULE_LICENSE("GPL" ); |
360 | MODULE_DESCRIPTION("I2C driver for NXP NCI NFC controllers" ); |
361 | MODULE_AUTHOR("Clément Perrochaud <clement.perrochaud@nxp.com>" ); |
362 | MODULE_AUTHOR("Oleg Zhurakivskyy <oleg.zhurakivskyy@intel.com>" ); |
363 | |