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