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_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
48static void fdp_nci_i2c_reset(struct fdp_i2c_phy *phy)
49{
50
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
57static 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
67static 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
75static void fdp_nci_i2c_add_len_lrc(struct sk_buff *skb)
76{
77 u8 lrc = 0;
78 u16 len, i;
79
80
81 len = skb->len;
82 *skb_push(skb, 1) = len & 0xff;
83 *skb_push(skb, 1) = len >> 8;
84
85
86 for (i = 0; i < len + 2; i++)
87 lrc ^= skb->data[i];
88
89 *skb_put(skb, 1) = lrc;
90}
91
92static 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
98static 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) {
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
134static 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
140static 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
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
162 for (lrc = i = 0; i < r; i++)
163 lrc ^= tmp[i];
164
165
166
167
168
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
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 memcpy(skb_put(*skb, len), 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
198flush:
199
200 if (i2c_master_recv(client, tmp, sizeof(tmp)) < 0)
201 r = -EREMOTEIO;
202
203 return r;
204}
205
206static 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 client = phy->i2c_dev;
214 dev_dbg(&client->dev, "%s\n", __func__);
215
216 if (!phy || irq != phy->i2c_dev->irq) {
217 WARN_ON_ONCE(1);
218 return IRQ_NONE;
219 }
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
234static 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
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 {
275vsc_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
284static 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
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
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
335 fdp_nci_i2c_read_device_properties(dev, &clock_type, &clock_freq,
336 &fw_vsc_cfg);
337
338
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
351static 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
363static struct i2c_device_id fdp_nci_i2c_id_table[] = {
364 {"int339a", 0},
365 {}
366};
367MODULE_DEVICE_TABLE(i2c, fdp_nci_i2c_id_table);
368
369static const struct acpi_device_id fdp_nci_i2c_acpi_match[] = {
370 {"INT339A", 0},
371 {}
372};
373MODULE_DEVICE_TABLE(acpi, fdp_nci_i2c_acpi_match);
374
375static 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};
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
