1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
20#include <linux/crc-ccitt.h>
21#include <linux/module.h>
22#include <linux/i2c.h>
23#include <linux/gpio.h>
24#include <linux/gpio/consumer.h>
25#include <linux/of_irq.h>
26#include <linux/of_gpio.h>
27#include <linux/acpi.h>
28#include <linux/miscdevice.h>
29#include <linux/interrupt.h>
30#include <linux/delay.h>
31#include <linux/nfc.h>
32#include <linux/firmware.h>
33#include <linux/platform_data/st21nfca.h>
34#include <asm/unaligned.h>
35
36#include <net/nfc/hci.h>
37#include <net/nfc/llc.h>
38#include <net/nfc/nfc.h>
39
40#include "st21nfca.h"
41
42
43
44
45
46
47
48
49
50
51#define ST21NFCA_SOF_EOF 0x7e
52#define ST21NFCA_BYTE_STUFFING_MASK 0x20
53#define ST21NFCA_ESCAPE_BYTE_STUFFING 0x7d
54
55
56#define ST21NFCA_FRAME_HEADROOM 2
57
58
59#define ST21NFCA_FRAME_TAILROOM 3
60#define IS_START_OF_FRAME(buf) (buf[0] == ST21NFCA_SOF_EOF && \
61 buf[1] == 0)
62
63#define ST21NFCA_HCI_I2C_DRIVER_NAME "st21nfca_hci_i2c"
64
65#define ST21NFCA_GPIO_NAME_EN "enable"
66
67struct st21nfca_i2c_phy {
68 struct i2c_client *i2c_dev;
69 struct nfc_hci_dev *hdev;
70
71 unsigned int gpio_ena;
72 unsigned int irq_polarity;
73
74 struct st21nfca_se_status se_status;
75
76 struct sk_buff *pending_skb;
77 int current_read_len;
78
79
80
81
82 int crc_trials;
83
84 int powered;
85 int run_mode;
86
87
88
89
90
91 int hard_fault;
92 struct mutex phy_lock;
93};
94
95static u8 len_seq[] = { 16, 24, 12, 29 };
96static u16 wait_tab[] = { 2, 3, 5, 15, 20, 40};
97
98#define I2C_DUMP_SKB(info, skb) \
99do { \
100 pr_debug("%s:\n", info); \
101 print_hex_dump(KERN_DEBUG, "i2c: ", DUMP_PREFIX_OFFSET, \
102 16, 1, (skb)->data, (skb)->len, 0); \
103} while (0)
104
105
106
107
108
109
110
111static int st21nfca_hci_platform_init(struct st21nfca_i2c_phy *phy)
112{
113 u16 wait_reboot[] = { 50, 300, 1000 };
114 char reboot_cmd[] = { 0x7E, 0x66, 0x48, 0xF6, 0x7E };
115 u8 tmp[ST21NFCA_HCI_LLC_MAX_SIZE];
116 int i, r = -1;
117
118 for (i = 0; i < ARRAY_SIZE(wait_reboot) && r < 0; i++) {
119 r = i2c_master_send(phy->i2c_dev, reboot_cmd,
120 sizeof(reboot_cmd));
121 if (r < 0)
122 msleep(wait_reboot[i]);
123 }
124 if (r < 0)
125 return r;
126
127
128 msleep(20);
129 r = -1;
130 for (i = 0; i < ARRAY_SIZE(wait_reboot) && r < 0; i++) {
131 r = i2c_master_recv(phy->i2c_dev, tmp,
132 ST21NFCA_HCI_LLC_MAX_SIZE);
133 if (r < 0)
134 msleep(wait_reboot[i]);
135 }
136 if (r < 0)
137 return r;
138
139 for (i = 0; i < ST21NFCA_HCI_LLC_MAX_SIZE &&
140 tmp[i] == ST21NFCA_SOF_EOF; i++)
141 ;
142
143 if (r != ST21NFCA_HCI_LLC_MAX_SIZE)
144 return -ENODEV;
145
146 usleep_range(1000, 1500);
147 return 0;
148}
149
150static int st21nfca_hci_i2c_enable(void *phy_id)
151{
152 struct st21nfca_i2c_phy *phy = phy_id;
153
154 gpio_set_value(phy->gpio_ena, 1);
155 phy->powered = 1;
156 phy->run_mode = ST21NFCA_HCI_MODE;
157
158 usleep_range(10000, 15000);
159
160 return 0;
161}
162
163static void st21nfca_hci_i2c_disable(void *phy_id)
164{
165 struct st21nfca_i2c_phy *phy = phy_id;
166
167 gpio_set_value(phy->gpio_ena, 0);
168
169 phy->powered = 0;
170}
171
172static void st21nfca_hci_add_len_crc(struct sk_buff *skb)
173{
174 u16 crc;
175 u8 tmp;
176
177 *skb_push(skb, 1) = 0;
178
179 crc = crc_ccitt(0xffff, skb->data, skb->len);
180 crc = ~crc;
181
182 tmp = crc & 0x00ff;
183 *skb_put(skb, 1) = tmp;
184
185 tmp = (crc >> 8) & 0x00ff;
186 *skb_put(skb, 1) = tmp;
187}
188
189static void st21nfca_hci_remove_len_crc(struct sk_buff *skb)
190{
191 skb_pull(skb, ST21NFCA_FRAME_HEADROOM);
192 skb_trim(skb, skb->len - ST21NFCA_FRAME_TAILROOM);
193}
194
195
196
197
198
199
200static int st21nfca_hci_i2c_write(void *phy_id, struct sk_buff *skb)
201{
202 int r = -1, i, j;
203 struct st21nfca_i2c_phy *phy = phy_id;
204 struct i2c_client *client = phy->i2c_dev;
205 u8 tmp[ST21NFCA_HCI_LLC_MAX_SIZE * 2];
206
207 I2C_DUMP_SKB("st21nfca_hci_i2c_write", skb);
208
209 if (phy->hard_fault != 0)
210 return phy->hard_fault;
211
212
213
214
215
216
217 st21nfca_hci_add_len_crc(skb);
218
219
220 *skb_put(skb, 1) = ST21NFCA_SOF_EOF;
221
222 *skb_push(skb, 1) = ST21NFCA_SOF_EOF;
223
224
225
226
227
228
229
230 tmp[0] = skb->data[0];
231 for (i = 1, j = 1; i < skb->len - 1; i++, j++) {
232 if (skb->data[i] == ST21NFCA_SOF_EOF
233 || skb->data[i] == ST21NFCA_ESCAPE_BYTE_STUFFING) {
234 tmp[j] = ST21NFCA_ESCAPE_BYTE_STUFFING;
235 j++;
236 tmp[j] = skb->data[i] ^ ST21NFCA_BYTE_STUFFING_MASK;
237 } else {
238 tmp[j] = skb->data[i];
239 }
240 }
241 tmp[j] = skb->data[i];
242 j++;
243
244
245
246
247
248 mutex_lock(&phy->phy_lock);
249 for (i = 0; i < ARRAY_SIZE(wait_tab) && r < 0; i++) {
250 r = i2c_master_send(client, tmp, j);
251 if (r < 0)
252 msleep(wait_tab[i]);
253 }
254 mutex_unlock(&phy->phy_lock);
255
256 if (r >= 0) {
257 if (r != j)
258 r = -EREMOTEIO;
259 else
260 r = 0;
261 }
262
263 st21nfca_hci_remove_len_crc(skb);
264
265 return r;
266}
267
268static int get_frame_size(u8 *buf, int buflen)
269{
270 int len = 0;
271
272 if (buf[len + 1] == ST21NFCA_SOF_EOF)
273 return 0;
274
275 for (len = 1; len < buflen && buf[len] != ST21NFCA_SOF_EOF; len++)
276 ;
277
278 return len;
279}
280
281static int check_crc(u8 *buf, int buflen)
282{
283 u16 crc;
284
285 crc = crc_ccitt(0xffff, buf, buflen - 2);
286 crc = ~crc;
287
288 if (buf[buflen - 2] != (crc & 0xff) || buf[buflen - 1] != (crc >> 8)) {
289 pr_err(ST21NFCA_HCI_DRIVER_NAME
290 ": CRC error 0x%x != 0x%x 0x%x\n", crc, buf[buflen - 1],
291 buf[buflen - 2]);
292
293 pr_info(DRIVER_DESC ": %s : BAD CRC\n", __func__);
294 print_hex_dump(KERN_DEBUG, "crc: ", DUMP_PREFIX_NONE,
295 16, 2, buf, buflen, false);
296 return -EPERM;
297 }
298 return 0;
299}
300
301
302
303
304
305
306
307
308
309static int st21nfca_hci_i2c_repack(struct sk_buff *skb)
310{
311 int i, j, r, size;
312
313 if (skb->len < 1 || (skb->len > 1 && skb->data[1] != 0))
314 return -EBADMSG;
315
316 size = get_frame_size(skb->data, skb->len);
317 if (size > 0) {
318 skb_trim(skb, size);
319
320 for (i = 1, j = 0; i < skb->len; i++) {
321 if (skb->data[i + j] ==
322 (u8) ST21NFCA_ESCAPE_BYTE_STUFFING) {
323 skb->data[i] = skb->data[i + j + 1]
324 | ST21NFCA_BYTE_STUFFING_MASK;
325 i++;
326 j++;
327 }
328 skb->data[i] = skb->data[i + j];
329 }
330
331 skb_trim(skb, i - j);
332
333 skb_pull(skb, 1);
334
335 r = check_crc(skb->data, skb->len);
336 if (r != 0) {
337 i = 0;
338 return -EBADMSG;
339 }
340
341
342 skb_pull(skb, 1);
343
344 skb_trim(skb, skb->len - 2);
345 return skb->len;
346 }
347 return 0;
348}
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365static int st21nfca_hci_i2c_read(struct st21nfca_i2c_phy *phy,
366 struct sk_buff *skb)
367{
368 int r, i;
369 u8 len;
370 u8 buf[ST21NFCA_HCI_LLC_MAX_PAYLOAD];
371 struct i2c_client *client = phy->i2c_dev;
372
373 if (phy->current_read_len < ARRAY_SIZE(len_seq)) {
374 len = len_seq[phy->current_read_len];
375
376
377
378
379
380
381 r = 0;
382 mutex_lock(&phy->phy_lock);
383 for (i = 0; i < ARRAY_SIZE(wait_tab) && r <= 0; i++) {
384 r = i2c_master_recv(client, buf, len);
385 if (r < 0)
386 msleep(wait_tab[i]);
387 }
388 mutex_unlock(&phy->phy_lock);
389
390 if (r != len) {
391 phy->current_read_len = 0;
392 return -EREMOTEIO;
393 }
394
395
396
397
398
399 if (!phy->current_read_len && !IS_START_OF_FRAME(buf)) {
400 skb_trim(skb, 0);
401 phy->current_read_len = 0;
402 return -EIO;
403 } else if (phy->current_read_len && IS_START_OF_FRAME(buf)) {
404
405
406
407
408
409 skb_trim(skb, 0);
410 phy->current_read_len = 0;
411 }
412
413 memcpy(skb_put(skb, len), buf, len);
414
415 if (skb->data[skb->len - 1] == ST21NFCA_SOF_EOF) {
416 phy->current_read_len = 0;
417 return st21nfca_hci_i2c_repack(skb);
418 }
419 phy->current_read_len++;
420 return -EAGAIN;
421 }
422 return -EIO;
423}
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439static irqreturn_t st21nfca_hci_irq_thread_fn(int irq, void *phy_id)
440{
441 struct st21nfca_i2c_phy *phy = phy_id;
442 struct i2c_client *client;
443
444 int r;
445
446 if (!phy || irq != phy->i2c_dev->irq) {
447 WARN_ON_ONCE(1);
448 return IRQ_NONE;
449 }
450
451 client = phy->i2c_dev;
452 dev_dbg(&client->dev, "IRQ\n");
453
454 if (phy->hard_fault != 0)
455 return IRQ_HANDLED;
456
457 r = st21nfca_hci_i2c_read(phy, phy->pending_skb);
458 if (r == -EREMOTEIO) {
459 phy->hard_fault = r;
460
461 nfc_hci_recv_frame(phy->hdev, NULL);
462
463 return IRQ_HANDLED;
464 } else if (r == -EAGAIN || r == -EIO) {
465 return IRQ_HANDLED;
466 } else if (r == -EBADMSG && phy->crc_trials < ARRAY_SIZE(wait_tab)) {
467
468
469
470
471
472
473
474
475
476 msleep(wait_tab[phy->crc_trials]);
477 phy->crc_trials++;
478 phy->current_read_len = 0;
479 kfree_skb(phy->pending_skb);
480 } else if (r > 0) {
481
482
483
484
485
486 nfc_hci_recv_frame(phy->hdev, phy->pending_skb);
487 phy->crc_trials = 0;
488 } else {
489 kfree_skb(phy->pending_skb);
490 }
491
492 phy->pending_skb = alloc_skb(ST21NFCA_HCI_LLC_MAX_SIZE * 2, GFP_KERNEL);
493 if (phy->pending_skb == NULL) {
494 phy->hard_fault = -ENOMEM;
495 nfc_hci_recv_frame(phy->hdev, NULL);
496 }
497
498 return IRQ_HANDLED;
499}
500
501static struct nfc_phy_ops i2c_phy_ops = {
502 .write = st21nfca_hci_i2c_write,
503 .enable = st21nfca_hci_i2c_enable,
504 .disable = st21nfca_hci_i2c_disable,
505};
506
507static int st21nfca_hci_i2c_acpi_request_resources(struct i2c_client *client)
508{
509 struct st21nfca_i2c_phy *phy = i2c_get_clientdata(client);
510 struct gpio_desc *gpiod_ena;
511 struct device *dev = &client->dev;
512 u8 tmp;
513
514
515 gpiod_ena = devm_gpiod_get_index(dev, ST21NFCA_GPIO_NAME_EN, 1,
516 GPIOD_OUT_LOW);
517 if (!IS_ERR(gpiod_ena)) {
518 nfc_err(dev, "Unable to get ENABLE GPIO\n");
519 return -ENODEV;
520 }
521
522 phy->gpio_ena = desc_to_gpio(gpiod_ena);
523
524 phy->irq_polarity = irq_get_trigger_type(client->irq);
525
526 phy->se_status.is_ese_present = false;
527 phy->se_status.is_uicc_present = false;
528
529 if (device_property_present(dev, "ese-present")) {
530 device_property_read_u8(dev, "ese-present", &tmp);
531 phy->se_status.is_ese_present = tmp;
532 }
533
534 if (device_property_present(dev, "uicc-present")) {
535 device_property_read_u8(dev, "uicc-present", &tmp);
536 phy->se_status.is_uicc_present = tmp;
537 }
538
539 return 0;
540}
541
542static int st21nfca_hci_i2c_of_request_resources(struct i2c_client *client)
543{
544 struct st21nfca_i2c_phy *phy = i2c_get_clientdata(client);
545 struct device_node *pp;
546 int gpio;
547 int r;
548
549 pp = client->dev.of_node;
550 if (!pp)
551 return -ENODEV;
552
553
554 gpio = of_get_named_gpio(pp, "enable-gpios", 0);
555 if (gpio < 0) {
556 nfc_err(&client->dev, "Failed to retrieve enable-gpios from device tree\n");
557 return gpio;
558 }
559
560
561 r = devm_gpio_request_one(&client->dev, gpio, GPIOF_OUT_INIT_HIGH,
562 ST21NFCA_GPIO_NAME_EN);
563 if (r) {
564 nfc_err(&client->dev, "Failed to request enable pin\n");
565 return r;
566 }
567
568 phy->gpio_ena = gpio;
569
570 phy->irq_polarity = irq_get_trigger_type(client->irq);
571
572 phy->se_status.is_ese_present =
573 of_property_read_bool(pp, "ese-present");
574 phy->se_status.is_uicc_present =
575 of_property_read_bool(pp, "uicc-present");
576
577 return 0;
578}
579
580static int st21nfca_hci_i2c_request_resources(struct i2c_client *client)
581{
582 struct st21nfca_nfc_platform_data *pdata;
583 struct st21nfca_i2c_phy *phy = i2c_get_clientdata(client);
584 int r;
585
586 pdata = client->dev.platform_data;
587 if (pdata == NULL) {
588 nfc_err(&client->dev, "No platform data\n");
589 return -EINVAL;
590 }
591
592
593 phy->gpio_ena = pdata->gpio_ena;
594 phy->irq_polarity = pdata->irq_polarity;
595
596 if (phy->gpio_ena > 0) {
597 r = devm_gpio_request_one(&client->dev, phy->gpio_ena,
598 GPIOF_OUT_INIT_HIGH,
599 ST21NFCA_GPIO_NAME_EN);
600 if (r) {
601 pr_err("%s : ena gpio_request failed\n", __FILE__);
602 return r;
603 }
604 }
605
606 phy->se_status.is_ese_present = pdata->is_ese_present;
607 phy->se_status.is_uicc_present = pdata->is_uicc_present;
608
609 return 0;
610}
611
612static int st21nfca_hci_i2c_probe(struct i2c_client *client,
613 const struct i2c_device_id *id)
614{
615 struct st21nfca_i2c_phy *phy;
616 struct st21nfca_nfc_platform_data *pdata;
617 int r;
618
619 dev_dbg(&client->dev, "%s\n", __func__);
620 dev_dbg(&client->dev, "IRQ: %d\n", client->irq);
621
622 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
623 nfc_err(&client->dev, "Need I2C_FUNC_I2C\n");
624 return -ENODEV;
625 }
626
627 phy = devm_kzalloc(&client->dev, sizeof(struct st21nfca_i2c_phy),
628 GFP_KERNEL);
629 if (!phy)
630 return -ENOMEM;
631
632 phy->i2c_dev = client;
633 phy->pending_skb = alloc_skb(ST21NFCA_HCI_LLC_MAX_SIZE * 2, GFP_KERNEL);
634 if (phy->pending_skb == NULL)
635 return -ENOMEM;
636
637 phy->current_read_len = 0;
638 phy->crc_trials = 0;
639 mutex_init(&phy->phy_lock);
640 i2c_set_clientdata(client, phy);
641
642 pdata = client->dev.platform_data;
643 if (!pdata && client->dev.of_node) {
644 r = st21nfca_hci_i2c_of_request_resources(client);
645 if (r) {
646 nfc_err(&client->dev, "No platform data\n");
647 return r;
648 }
649 } else if (pdata) {
650 r = st21nfca_hci_i2c_request_resources(client);
651 if (r) {
652 nfc_err(&client->dev, "Cannot get platform resources\n");
653 return r;
654 }
655 } else if (ACPI_HANDLE(&client->dev)) {
656 r = st21nfca_hci_i2c_acpi_request_resources(client);
657 if (r) {
658 nfc_err(&client->dev, "Cannot get ACPI data\n");
659 return r;
660 }
661 } else {
662 nfc_err(&client->dev, "st21nfca platform resources not available\n");
663 return -ENODEV;
664 }
665
666 r = st21nfca_hci_platform_init(phy);
667 if (r < 0) {
668 nfc_err(&client->dev, "Unable to reboot st21nfca\n");
669 return r;
670 }
671
672 r = devm_request_threaded_irq(&client->dev, client->irq, NULL,
673 st21nfca_hci_irq_thread_fn,
674 phy->irq_polarity | IRQF_ONESHOT,
675 ST21NFCA_HCI_DRIVER_NAME, phy);
676 if (r < 0) {
677 nfc_err(&client->dev, "Unable to register IRQ handler\n");
678 return r;
679 }
680
681 return st21nfca_hci_probe(phy, &i2c_phy_ops, LLC_SHDLC_NAME,
682 ST21NFCA_FRAME_HEADROOM,
683 ST21NFCA_FRAME_TAILROOM,
684 ST21NFCA_HCI_LLC_MAX_PAYLOAD,
685 &phy->hdev,
686 &phy->se_status);
687}
688
689static int st21nfca_hci_i2c_remove(struct i2c_client *client)
690{
691 struct st21nfca_i2c_phy *phy = i2c_get_clientdata(client);
692
693 dev_dbg(&client->dev, "%s\n", __func__);
694
695 st21nfca_hci_remove(phy->hdev);
696
697 if (phy->powered)
698 st21nfca_hci_i2c_disable(phy);
699
700 return 0;
701}
702
703static struct i2c_device_id st21nfca_hci_i2c_id_table[] = {
704 {ST21NFCA_HCI_DRIVER_NAME, 0},
705 {}
706};
707MODULE_DEVICE_TABLE(i2c, st21nfca_hci_i2c_id_table);
708
709static const struct acpi_device_id st21nfca_hci_i2c_acpi_match[] = {
710 {"SMO2100", 0},
711 {}
712};
713MODULE_DEVICE_TABLE(acpi, st21nfca_hci_i2c_acpi_match);
714
715static const struct of_device_id of_st21nfca_i2c_match[] = {
716 { .compatible = "st,st21nfca-i2c", },
717 { .compatible = "st,st21nfca_i2c", },
718 {}
719};
720MODULE_DEVICE_TABLE(of, of_st21nfca_i2c_match);
721
722static struct i2c_driver st21nfca_hci_i2c_driver = {
723 .driver = {
724 .name = ST21NFCA_HCI_I2C_DRIVER_NAME,
725 .of_match_table = of_match_ptr(of_st21nfca_i2c_match),
726 .acpi_match_table = ACPI_PTR(st21nfca_hci_i2c_acpi_match),
727 },
728 .probe = st21nfca_hci_i2c_probe,
729 .id_table = st21nfca_hci_i2c_id_table,
730 .remove = st21nfca_hci_i2c_remove,
731};
732module_i2c_driver(st21nfca_hci_i2c_driver);
733
734MODULE_LICENSE("GPL");
735MODULE_DESCRIPTION(DRIVER_DESC);
736