1
2
3
4
5
6
7
8
9
10
11
12
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_CLOCK_TYPE_NAME "clock-type"
31#define FDP_DP_CLOCK_FREQ_NAME "clock-freq"
32#define FDP_DP_FW_VSC_CFG_NAME "fw-vsc-cfg"
33
34#define FDP_FRAME_HEADROOM 2
35#define FDP_FRAME_TAILROOM 1
36
37#define FDP_NCI_I2C_MIN_PAYLOAD 5
38#define FDP_NCI_I2C_MAX_PAYLOAD 261
39
40#define FDP_POWER_OFF 0
41#define FDP_POWER_ON 1
42
43#define fdp_nci_i2c_dump_skb(dev, prefix, skb) \
44 print_hex_dump(KERN_DEBUG, prefix": ", DUMP_PREFIX_OFFSET, \
45 16, 1, (skb)->data, (skb)->len, 0)
46
47static void fdp_nci_i2c_reset(struct fdp_i2c_phy *phy)
48{
49
50 gpiod_set_value_cansleep(phy->power_gpio, FDP_POWER_OFF);
51 usleep_range(1000, 4000);
52 gpiod_set_value_cansleep(phy->power_gpio, FDP_POWER_ON);
53 usleep_range(10000, 14000);
54}
55
56static int fdp_nci_i2c_enable(void *phy_id)
57{
58 struct fdp_i2c_phy *phy = phy_id;
59
60 dev_dbg(&phy->i2c_dev->dev, "%s\n", __func__);
61 fdp_nci_i2c_reset(phy);
62
63 return 0;
64}
65
66static void fdp_nci_i2c_disable(void *phy_id)
67{
68 struct fdp_i2c_phy *phy = phy_id;
69
70 dev_dbg(&phy->i2c_dev->dev, "%s\n", __func__);
71 fdp_nci_i2c_reset(phy);
72}
73
74static void fdp_nci_i2c_add_len_lrc(struct sk_buff *skb)
75{
76 u8 lrc = 0;
77 u16 len, i;
78
79
80 len = skb->len;
81 *(u8 *)skb_push(skb, 1) = len & 0xff;
82 *(u8 *)skb_push(skb, 1) = len >> 8;
83
84
85 for (i = 0; i < len + 2; i++)
86 lrc ^= skb->data[i];
87
88 skb_put_u8(skb, lrc);
89}
90
91static void fdp_nci_i2c_remove_len_lrc(struct sk_buff *skb)
92{
93 skb_pull(skb, FDP_FRAME_HEADROOM);
94 skb_trim(skb, skb->len - FDP_FRAME_TAILROOM);
95}
96
97static int fdp_nci_i2c_write(void *phy_id, struct sk_buff *skb)
98{
99 struct fdp_i2c_phy *phy = phy_id;
100 struct i2c_client *client = phy->i2c_dev;
101 int r;
102
103 if (phy->hard_fault != 0)
104 return phy->hard_fault;
105
106 fdp_nci_i2c_add_len_lrc(skb);
107 fdp_nci_i2c_dump_skb(&client->dev, "fdp_wr", skb);
108
109 r = i2c_master_send(client, skb->data, skb->len);
110 if (r == -EREMOTEIO) {
111 usleep_range(1000, 4000);
112 r = i2c_master_send(client, skb->data, skb->len);
113 }
114
115 if (r < 0 || r != skb->len)
116 dev_dbg(&client->dev, "%s: error err=%d len=%d\n",
117 __func__, r, skb->len);
118
119 if (r >= 0) {
120 if (r != skb->len) {
121 phy->hard_fault = r;
122 r = -EREMOTEIO;
123 } else {
124 r = 0;
125 }
126 }
127
128 fdp_nci_i2c_remove_len_lrc(skb);
129
130 return r;
131}
132
133static struct nfc_phy_ops i2c_phy_ops = {
134 .write = fdp_nci_i2c_write,
135 .enable = fdp_nci_i2c_enable,
136 .disable = fdp_nci_i2c_disable,
137};
138
139static int fdp_nci_i2c_read(struct fdp_i2c_phy *phy, struct sk_buff **skb)
140{
141 int r, len;
142 u8 tmp[FDP_NCI_I2C_MAX_PAYLOAD], lrc, k;
143 u16 i;
144 struct i2c_client *client = phy->i2c_dev;
145
146 *skb = NULL;
147
148
149 for (k = 0; k < 2; k++) {
150
151 len = phy->next_read_size;
152
153 r = i2c_master_recv(client, tmp, len);
154 if (r != len) {
155 dev_dbg(&client->dev, "%s: i2c recv err: %d\n",
156 __func__, r);
157 goto flush;
158 }
159
160
161 for (lrc = i = 0; i < r; i++)
162 lrc ^= tmp[i];
163
164
165
166
167
168
169 if (lrc) {
170 dev_dbg(&client->dev, "%s: corrupted packet\n",
171 __func__);
172 phy->next_read_size = 5;
173 goto flush;
174 }
175
176
177 if (tmp[0] == 0 && tmp[1] == 0) {
178 phy->next_read_size = (tmp[2] << 8) + tmp[3] + 3;
179 } else {
180 phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD;
181
182 *skb = alloc_skb(len, GFP_KERNEL);
183 if (*skb == NULL) {
184 r = -ENOMEM;
185 goto flush;
186 }
187
188 skb_put_data(*skb, tmp, len);
189 fdp_nci_i2c_dump_skb(&client->dev, "fdp_rd", *skb);
190
191 fdp_nci_i2c_remove_len_lrc(*skb);
192 }
193 }
194
195 return 0;
196
197flush:
198
199 if (i2c_master_recv(client, tmp, sizeof(tmp)) < 0)
200 r = -EREMOTEIO;
201
202 return r;
203}
204
205static irqreturn_t fdp_nci_i2c_irq_thread_fn(int irq, void *phy_id)
206{
207 struct fdp_i2c_phy *phy = phy_id;
208 struct i2c_client *client;
209 struct sk_buff *skb;
210 int r;
211
212 if (!phy || irq != phy->i2c_dev->irq) {
213 WARN_ON_ONCE(1);
214 return IRQ_NONE;
215 }
216
217 client = phy->i2c_dev;
218 dev_dbg(&client->dev, "%s\n", __func__);
219
220 r = fdp_nci_i2c_read(phy, &skb);
221
222 if (r == -EREMOTEIO)
223 return IRQ_HANDLED;
224 else if (r == -ENOMEM || r == -EBADMSG)
225 return IRQ_HANDLED;
226
227 if (skb != NULL)
228 fdp_nci_recv_frame(phy->ndev, skb);
229
230 return IRQ_HANDLED;
231}
232
233static void fdp_nci_i2c_read_device_properties(struct device *dev,
234 u8 *clock_type, u32 *clock_freq,
235 u8 **fw_vsc_cfg)
236{
237 int r;
238 u8 len;
239
240 r = device_property_read_u8(dev, FDP_DP_CLOCK_TYPE_NAME, clock_type);
241 if (r) {
242 dev_dbg(dev, "Using default clock type");
243 *clock_type = 0;
244 }
245
246 r = device_property_read_u32(dev, FDP_DP_CLOCK_FREQ_NAME, clock_freq);
247 if (r) {
248 dev_dbg(dev, "Using default clock frequency\n");
249 *clock_freq = 26000;
250 }
251
252 if (device_property_present(dev, FDP_DP_FW_VSC_CFG_NAME)) {
253 r = device_property_read_u8(dev, FDP_DP_FW_VSC_CFG_NAME,
254 &len);
255
256 if (r || len <= 0)
257 goto vsc_read_err;
258
259
260 len++;
261
262 *fw_vsc_cfg = devm_kmalloc_array(dev,
263 len, sizeof(**fw_vsc_cfg),
264 GFP_KERNEL);
265
266 r = device_property_read_u8_array(dev, FDP_DP_FW_VSC_CFG_NAME,
267 *fw_vsc_cfg, len);
268
269 if (r) {
270 devm_kfree(dev, fw_vsc_cfg);
271 goto vsc_read_err;
272 }
273 } else {
274vsc_read_err:
275 dev_dbg(dev, "FW vendor specific commands not present\n");
276 *fw_vsc_cfg = NULL;
277 }
278
279 dev_dbg(dev, "Clock type: %d, clock frequency: %d, VSC: %s",
280 *clock_type, *clock_freq, *fw_vsc_cfg != NULL ? "yes" : "no");
281}
282
283static const struct acpi_gpio_params power_gpios = { 0, 0, false };
284
285static const struct acpi_gpio_mapping acpi_fdp_gpios[] = {
286 { "power-gpios", &power_gpios, 1 },
287 {},
288};
289
290static int fdp_nci_i2c_probe(struct i2c_client *client)
291{
292 struct fdp_i2c_phy *phy;
293 struct device *dev = &client->dev;
294 u8 *fw_vsc_cfg;
295 u8 clock_type;
296 u32 clock_freq;
297 int r = 0;
298
299 dev_dbg(dev, "%s\n", __func__);
300
301 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
302 nfc_err(dev, "No I2C_FUNC_I2C support\n");
303 return -ENODEV;
304 }
305
306
307 if (client->irq <= 0) {
308 nfc_err(dev, "IRQ not present\n");
309 return -ENODEV;
310 }
311
312 phy = devm_kzalloc(dev, sizeof(struct fdp_i2c_phy), GFP_KERNEL);
313 if (!phy)
314 return -ENOMEM;
315
316 phy->i2c_dev = client;
317 phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD;
318 i2c_set_clientdata(client, phy);
319
320 r = devm_request_threaded_irq(dev, client->irq,
321 NULL, fdp_nci_i2c_irq_thread_fn,
322 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
323 FDP_I2C_DRIVER_NAME, phy);
324
325 if (r < 0) {
326 nfc_err(&client->dev, "Unable to register IRQ handler\n");
327 return r;
328 }
329
330 r = devm_acpi_dev_add_driver_gpios(dev, acpi_fdp_gpios);
331 if (r)
332 dev_dbg(dev, "Unable to add GPIO mapping table\n");
333
334
335 phy->power_gpio = devm_gpiod_get(dev, "power", GPIOD_OUT_LOW);
336 if (IS_ERR(phy->power_gpio)) {
337 nfc_err(dev, "Power GPIO request failed\n");
338 return PTR_ERR(phy->power_gpio);
339 }
340
341
342 fdp_nci_i2c_read_device_properties(dev, &clock_type, &clock_freq,
343 &fw_vsc_cfg);
344
345
346 r = fdp_nci_probe(phy, &i2c_phy_ops, &phy->ndev,
347 FDP_FRAME_HEADROOM, FDP_FRAME_TAILROOM,
348 clock_type, clock_freq, fw_vsc_cfg);
349 if (r < 0) {
350 nfc_err(dev, "NCI probing error\n");
351 return r;
352 }
353
354 dev_dbg(dev, "I2C driver loaded\n");
355 return 0;
356}
357
358static int fdp_nci_i2c_remove(struct i2c_client *client)
359{
360 struct fdp_i2c_phy *phy = i2c_get_clientdata(client);
361
362 dev_dbg(&client->dev, "%s\n", __func__);
363
364 fdp_nci_remove(phy->ndev);
365 fdp_nci_i2c_disable(phy);
366
367 return 0;
368}
369
370static const struct acpi_device_id fdp_nci_i2c_acpi_match[] = {
371 {"INT339A", 0},
372 {}
373};
374MODULE_DEVICE_TABLE(acpi, fdp_nci_i2c_acpi_match);
375
376static struct i2c_driver fdp_nci_i2c_driver = {
377 .driver = {
378 .name = FDP_I2C_DRIVER_NAME,
379 .acpi_match_table = ACPI_PTR(fdp_nci_i2c_acpi_match),
380 },
381 .probe_new = fdp_nci_i2c_probe,
382 .remove = fdp_nci_i2c_remove,
383};
384module_i2c_driver(fdp_nci_i2c_driver);
385
386MODULE_LICENSE("GPL");
387MODULE_DESCRIPTION("I2C driver for Intel Fields Peak NFC controller");
388MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");
389
