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