1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* -------------------------------------------------------------------------
3 * Copyright (C) 2014-2016, Intel Corporation
4 *
5 * -------------------------------------------------------------------------
6 */
7
8 #include <linux/module.h>
9 #include <linux/acpi.h>
10 #include <linux/i2c.h>
11 #include <linux/interrupt.h>
12 #include <linux/nfc.h>
13 #include <linux/delay.h>
14 #include <linux/gpio/consumer.h>
15 #include <net/nfc/nfc.h>
16 #include <net/nfc/nci_core.h>
17
18 #include "fdp.h"
19
20 #define FDP_I2C_DRIVER_NAME "fdp_nci_i2c"
21
22 #define FDP_DP_CLOCK_TYPE_NAME "clock-type"
23 #define FDP_DP_CLOCK_FREQ_NAME "clock-freq"
24 #define FDP_DP_FW_VSC_CFG_NAME "fw-vsc-cfg"
25
26 #define FDP_FRAME_HEADROOM 2
27 #define FDP_FRAME_TAILROOM 1
28
29 #define FDP_NCI_I2C_MIN_PAYLOAD 5
30 #define FDP_NCI_I2C_MAX_PAYLOAD 261
31
32 #define FDP_POWER_OFF 0
33 #define FDP_POWER_ON 1
34
35 #define fdp_nci_i2c_dump_skb(dev, prefix, skb) \
36 print_hex_dump(KERN_DEBUG, prefix": ", DUMP_PREFIX_OFFSET, \
37 16, 1, (skb)->data, (skb)->len, 0)
38
fdp_nci_i2c_reset(const struct fdp_i2c_phy * phy)39 static void fdp_nci_i2c_reset(const struct fdp_i2c_phy *phy)
40 {
41 /* Reset RST/WakeUP for at least 100 micro-second */
42 gpiod_set_value_cansleep(phy->power_gpio, FDP_POWER_OFF);
43 usleep_range(1000, 4000);
44 gpiod_set_value_cansleep(phy->power_gpio, FDP_POWER_ON);
45 usleep_range(10000, 14000);
46 }
47
fdp_nci_i2c_enable(void * phy_id)48 static int fdp_nci_i2c_enable(void *phy_id)
49 {
50 const struct fdp_i2c_phy *phy = phy_id;
51
52 fdp_nci_i2c_reset(phy);
53
54 return 0;
55 }
56
fdp_nci_i2c_disable(void * phy_id)57 static void fdp_nci_i2c_disable(void *phy_id)
58 {
59 const struct fdp_i2c_phy *phy = phy_id;
60
61 fdp_nci_i2c_reset(phy);
62 }
63
fdp_nci_i2c_add_len_lrc(struct sk_buff * skb)64 static void fdp_nci_i2c_add_len_lrc(struct sk_buff *skb)
65 {
66 u8 lrc = 0;
67 u16 len, i;
68
69 /* Add length header */
70 len = skb->len;
71 *(u8 *)skb_push(skb, 1) = len & 0xff;
72 *(u8 *)skb_push(skb, 1) = len >> 8;
73
74 /* Compute and add lrc */
75 for (i = 0; i < len + 2; i++)
76 lrc ^= skb->data[i];
77
78 skb_put_u8(skb, lrc);
79 }
80
fdp_nci_i2c_remove_len_lrc(struct sk_buff * skb)81 static void fdp_nci_i2c_remove_len_lrc(struct sk_buff *skb)
82 {
83 skb_pull(skb, FDP_FRAME_HEADROOM);
84 skb_trim(skb, skb->len - FDP_FRAME_TAILROOM);
85 }
86
fdp_nci_i2c_write(void * phy_id,struct sk_buff * skb)87 static int fdp_nci_i2c_write(void *phy_id, struct sk_buff *skb)
88 {
89 struct fdp_i2c_phy *phy = phy_id;
90 struct i2c_client *client = phy->i2c_dev;
91 int r;
92
93 if (phy->hard_fault != 0)
94 return phy->hard_fault;
95
96 fdp_nci_i2c_add_len_lrc(skb);
97 fdp_nci_i2c_dump_skb(&client->dev, "fdp_wr", skb);
98
99 r = i2c_master_send(client, skb->data, skb->len);
100 if (r == -EREMOTEIO) { /* Retry, chip was in standby */
101 usleep_range(1000, 4000);
102 r = i2c_master_send(client, skb->data, skb->len);
103 }
104
105 if (r < 0 || r != skb->len)
106 dev_dbg(&client->dev, "%s: error err=%d len=%d\n",
107 __func__, r, skb->len);
108
109 if (r >= 0) {
110 if (r != skb->len) {
111 phy->hard_fault = r;
112 r = -EREMOTEIO;
113 } else {
114 r = 0;
115 }
116 }
117
118 fdp_nci_i2c_remove_len_lrc(skb);
119
120 return r;
121 }
122
123 static const struct nfc_phy_ops i2c_phy_ops = {
124 .write = fdp_nci_i2c_write,
125 .enable = fdp_nci_i2c_enable,
126 .disable = fdp_nci_i2c_disable,
127 };
128
fdp_nci_i2c_read(struct fdp_i2c_phy * phy,struct sk_buff ** skb)129 static int fdp_nci_i2c_read(struct fdp_i2c_phy *phy, struct sk_buff **skb)
130 {
131 int r, len;
132 u8 tmp[FDP_NCI_I2C_MAX_PAYLOAD], lrc, k;
133 u16 i;
134 struct i2c_client *client = phy->i2c_dev;
135
136 *skb = NULL;
137
138 /* Read the length packet and the data packet */
139 for (k = 0; k < 2; k++) {
140
141 len = phy->next_read_size;
142
143 r = i2c_master_recv(client, tmp, len);
144 if (r != len) {
145 dev_dbg(&client->dev, "%s: i2c recv err: %d\n",
146 __func__, r);
147 goto flush;
148 }
149
150 /* Check packet integruty */
151 for (lrc = i = 0; i < r; i++)
152 lrc ^= tmp[i];
153
154 /*
155 * LRC check failed. This may due to transmission error or
156 * desynchronization between driver and FDP. Drop the packet
157 * and force resynchronization
158 */
159 if (lrc) {
160 dev_dbg(&client->dev, "%s: corrupted packet\n",
161 __func__);
162 phy->next_read_size = 5;
163 goto flush;
164 }
165
166 /* Packet that contains a length */
167 if (tmp[0] == 0 && tmp[1] == 0) {
168 phy->next_read_size = (tmp[2] << 8) + tmp[3] + 3;
169
170 /*
171 * next_read_size is taken from the device and is used
172 * as the i2c_master_recv() count for the next packet
173 * and as the data skb size. A value above the receive
174 * buffer overflows tmp[]; one below the minimum frame
175 * size runs the header/LRC strip and the length-field
176 * read past a short receive. Either way the packet is
177 * corrupt: drop it and force resynchronization.
178 */
179 if (phy->next_read_size < FDP_NCI_I2C_MIN_PAYLOAD ||
180 phy->next_read_size > FDP_NCI_I2C_MAX_PAYLOAD) {
181 dev_dbg(&client->dev, "%s: corrupted packet\n",
182 __func__);
183 phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD;
184 goto flush;
185 }
186 } else {
187 phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD;
188
189 /*
190 * Only one data packet is delivered per call; if the
191 * device sends another, do not overwrite and leak the
192 * skb allocated for the previous one.
193 */
194 if (*skb) {
195 kfree_skb(*skb);
196 *skb = NULL;
197 }
198
199 *skb = alloc_skb(len, GFP_KERNEL);
200 if (*skb == NULL) {
201 r = -ENOMEM;
202 goto flush;
203 }
204
205 skb_put_data(*skb, tmp, len);
206 fdp_nci_i2c_dump_skb(&client->dev, "fdp_rd", *skb);
207
208 fdp_nci_i2c_remove_len_lrc(*skb);
209 }
210 }
211
212 return 0;
213
214 flush:
215 /* Flush the remaining data */
216 if (i2c_master_recv(client, tmp, sizeof(tmp)) < 0)
217 r = -EREMOTEIO;
218
219 return r;
220 }
221
fdp_nci_i2c_irq_thread_fn(int irq,void * phy_id)222 static irqreturn_t fdp_nci_i2c_irq_thread_fn(int irq, void *phy_id)
223 {
224 struct fdp_i2c_phy *phy = phy_id;
225 struct sk_buff *skb;
226 int r;
227
228 if (!phy || irq != phy->i2c_dev->irq) {
229 WARN_ON_ONCE(1);
230 return IRQ_NONE;
231 }
232
233 r = fdp_nci_i2c_read(phy, &skb);
234
235 if (r == -EREMOTEIO || r == -ENOMEM || r == -EBADMSG)
236 return IRQ_HANDLED;
237
238 if (skb != NULL)
239 nci_recv_frame(phy->ndev, skb);
240
241 return IRQ_HANDLED;
242 }
243
fdp_nci_i2c_read_device_properties(struct device * dev,u8 * clock_type,u32 * clock_freq,u8 ** fw_vsc_cfg)244 static void fdp_nci_i2c_read_device_properties(struct device *dev,
245 u8 *clock_type, u32 *clock_freq,
246 u8 **fw_vsc_cfg)
247 {
248 int r;
249 u8 len;
250
251 r = device_property_read_u8(dev, FDP_DP_CLOCK_TYPE_NAME, clock_type);
252 if (r) {
253 dev_dbg(dev, "Using default clock type");
254 *clock_type = 0;
255 }
256
257 r = device_property_read_u32(dev, FDP_DP_CLOCK_FREQ_NAME, clock_freq);
258 if (r) {
259 dev_dbg(dev, "Using default clock frequency\n");
260 *clock_freq = 26000;
261 }
262
263 if (device_property_present(dev, FDP_DP_FW_VSC_CFG_NAME)) {
264 r = device_property_read_u8(dev, FDP_DP_FW_VSC_CFG_NAME,
265 &len);
266
267 if (r || len <= 0)
268 goto vsc_read_err;
269
270 /* Add 1 to the length to inclue the length byte itself */
271 len++;
272
273 *fw_vsc_cfg = devm_kmalloc_array(dev,
274 len, sizeof(**fw_vsc_cfg),
275 GFP_KERNEL);
276
277 if (!*fw_vsc_cfg)
278 goto alloc_err;
279
280 r = device_property_read_u8_array(dev, FDP_DP_FW_VSC_CFG_NAME,
281 *fw_vsc_cfg, len);
282
283 if (r) {
284 devm_kfree(dev, *fw_vsc_cfg);
285 goto vsc_read_err;
286 }
287 } else {
288 vsc_read_err:
289 dev_dbg(dev, "FW vendor specific commands not present\n");
290 *fw_vsc_cfg = NULL;
291 }
292
293 alloc_err:
294 dev_dbg(dev, "Clock type: %d, clock frequency: %d, VSC: %s",
295 *clock_type, *clock_freq, *fw_vsc_cfg != NULL ? "yes" : "no");
296 }
297
298 static const struct acpi_gpio_params power_gpios = { 0, 0, false };
299
300 static const struct acpi_gpio_mapping acpi_fdp_gpios[] = {
301 { "power-gpios", &power_gpios, 1 },
302 {},
303 };
304
fdp_nci_i2c_probe(struct i2c_client * client)305 static int fdp_nci_i2c_probe(struct i2c_client *client)
306 {
307 struct fdp_i2c_phy *phy;
308 struct device *dev = &client->dev;
309 u8 *fw_vsc_cfg;
310 u8 clock_type;
311 u32 clock_freq;
312 int r = 0;
313
314 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
315 nfc_err(dev, "No I2C_FUNC_I2C support\n");
316 return -ENODEV;
317 }
318
319 /* Checking if we have an irq */
320 if (client->irq <= 0) {
321 nfc_err(dev, "IRQ not present\n");
322 return -ENODEV;
323 }
324
325 phy = devm_kzalloc(dev, sizeof(struct fdp_i2c_phy), GFP_KERNEL);
326 if (!phy)
327 return -ENOMEM;
328
329 phy->i2c_dev = client;
330 phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD;
331 i2c_set_clientdata(client, phy);
332
333 r = devm_request_threaded_irq(dev, client->irq,
334 NULL, fdp_nci_i2c_irq_thread_fn,
335 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
336 FDP_I2C_DRIVER_NAME, phy);
337
338 if (r < 0) {
339 nfc_err(&client->dev, "Unable to register IRQ handler\n");
340 return r;
341 }
342
343 r = devm_acpi_dev_add_driver_gpios(dev, acpi_fdp_gpios);
344 if (r)
345 dev_dbg(dev, "Unable to add GPIO mapping table\n");
346
347 /* Requesting the power gpio */
348 phy->power_gpio = devm_gpiod_get(dev, "power", GPIOD_OUT_LOW);
349 if (IS_ERR(phy->power_gpio)) {
350 nfc_err(dev, "Power GPIO request failed\n");
351 return PTR_ERR(phy->power_gpio);
352 }
353
354 /* read device properties to get the clock and production settings */
355 fdp_nci_i2c_read_device_properties(dev, &clock_type, &clock_freq,
356 &fw_vsc_cfg);
357
358 /* Call the NFC specific probe function */
359 r = fdp_nci_probe(phy, &i2c_phy_ops, &phy->ndev,
360 FDP_FRAME_HEADROOM, FDP_FRAME_TAILROOM,
361 clock_type, clock_freq, fw_vsc_cfg);
362 if (r < 0) {
363 nfc_err(dev, "NCI probing error\n");
364 return r;
365 }
366
367 return 0;
368 }
369
fdp_nci_i2c_remove(struct i2c_client * client)370 static void fdp_nci_i2c_remove(struct i2c_client *client)
371 {
372 struct fdp_i2c_phy *phy = i2c_get_clientdata(client);
373
374 fdp_nci_remove(phy->ndev);
375 fdp_nci_i2c_disable(phy);
376 }
377
378 static const struct acpi_device_id fdp_nci_i2c_acpi_match[] = {
379 { .id = "INT339A" },
380 { }
381 };
382 MODULE_DEVICE_TABLE(acpi, fdp_nci_i2c_acpi_match);
383
384 static struct i2c_driver fdp_nci_i2c_driver = {
385 .driver = {
386 .name = FDP_I2C_DRIVER_NAME,
387 .acpi_match_table = fdp_nci_i2c_acpi_match,
388 },
389 .probe = fdp_nci_i2c_probe,
390 .remove = fdp_nci_i2c_remove,
391 };
392 module_i2c_driver(fdp_nci_i2c_driver);
393
394 MODULE_LICENSE("GPL");
395 MODULE_DESCRIPTION("I2C driver for Intel Fields Peak NFC controller");
396 MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");
397