?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpio: rcar: Fix runtime PM imbalance on error
[linux/fpc-iii.git] / drivers / nfc / pn544 / pn544.c
blobb788870473e85d7d1c89493fce399ee37993b138
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * HCI based Driver for NXP PN544 NFC Chip
4 *
5 * Copyright (C) 2012 Intel Corporation. All rights reserved.
6 */
7
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10 #include <linux/delay.h>
11 #include <linux/slab.h>
12 #include <linux/module.h>
13
14 #include <linux/nfc.h>
15 #include <net/nfc/hci.h>
16 #include <net/nfc/llc.h>
17
18 #include "pn544.h"
19
20 /* Timing restrictions (ms) */
21 #define PN544_HCI_RESETVEN_TIME 30
22
23 enum pn544_state {
24 PN544_ST_COLD,
25 PN544_ST_FW_READY,
26 PN544_ST_READY,
27 };
28
29 #define FULL_VERSION_LEN 11
30
31 /* Proprietary commands */
32 #define PN544_WRITE 0x3f
33 #define PN544_TEST_SWP 0x21
34
35 /* Proprietary gates, events, commands and registers */
36
37 /* NFC_HCI_RF_READER_A_GATE additional registers and commands */
38 #define PN544_RF_READER_A_AUTO_ACTIVATION 0x10
39 #define PN544_RF_READER_A_CMD_CONTINUE_ACTIVATION 0x12
40 #define PN544_MIFARE_CMD 0x21
41
42 /* Commands that apply to all RF readers */
43 #define PN544_RF_READER_CMD_PRESENCE_CHECK 0x30
44 #define PN544_RF_READER_CMD_ACTIVATE_NEXT 0x32
45
46 /* NFC_HCI_ID_MGMT_GATE additional registers */
47 #define PN544_ID_MGMT_FULL_VERSION_SW 0x10
48
49 #define PN544_RF_READER_ISO15693_GATE 0x12
50
51 #define PN544_RF_READER_F_GATE 0x14
52 #define PN544_FELICA_ID 0x04
53 #define PN544_FELICA_RAW 0x20
54
55 #define PN544_RF_READER_JEWEL_GATE 0x15
56 #define PN544_JEWEL_RAW_CMD 0x23
57
58 #define PN544_RF_READER_NFCIP1_INITIATOR_GATE 0x30
59 #define PN544_RF_READER_NFCIP1_TARGET_GATE 0x31
60
61 #define PN544_SYS_MGMT_GATE 0x90
62 #define PN544_SYS_MGMT_INFO_NOTIFICATION 0x02
63
64 #define PN544_POLLING_LOOP_MGMT_GATE 0x94
65 #define PN544_DEP_MODE 0x01
66 #define PN544_DEP_ATR_REQ 0x02
67 #define PN544_DEP_ATR_RES 0x03
68 #define PN544_DEP_MERGE 0x0D
69 #define PN544_PL_RDPHASES 0x06
70 #define PN544_PL_EMULATION 0x07
71 #define PN544_PL_NFCT_DEACTIVATED 0x09
72
73 #define PN544_SWP_MGMT_GATE 0xA0
74 #define PN544_SWP_DEFAULT_MODE 0x01
75
76 #define PN544_NFC_WI_MGMT_GATE 0xA1
77 #define PN544_NFC_ESE_DEFAULT_MODE 0x01
78
79 #define PN544_HCI_EVT_SND_DATA 0x01
80 #define PN544_HCI_EVT_ACTIVATED 0x02
81 #define PN544_HCI_EVT_DEACTIVATED 0x03
82 #define PN544_HCI_EVT_RCV_DATA 0x04
83 #define PN544_HCI_EVT_CONTINUE_MI 0x05
84 #define PN544_HCI_EVT_SWITCH_MODE 0x03
85
86 #define PN544_HCI_CMD_ATTREQUEST 0x12
87 #define PN544_HCI_CMD_CONTINUE_ACTIVATION 0x13
88
89 static struct nfc_hci_gate pn544_gates[] = {
90 {NFC_HCI_ADMIN_GATE, NFC_HCI_INVALID_PIPE},
91 {NFC_HCI_LOOPBACK_GATE, NFC_HCI_INVALID_PIPE},
92 {NFC_HCI_ID_MGMT_GATE, NFC_HCI_INVALID_PIPE},
93 {NFC_HCI_LINK_MGMT_GATE, NFC_HCI_INVALID_PIPE},
94 {NFC_HCI_RF_READER_B_GATE, NFC_HCI_INVALID_PIPE},
95 {NFC_HCI_RF_READER_A_GATE, NFC_HCI_INVALID_PIPE},
96 {PN544_SYS_MGMT_GATE, NFC_HCI_INVALID_PIPE},
97 {PN544_SWP_MGMT_GATE, NFC_HCI_INVALID_PIPE},
98 {PN544_POLLING_LOOP_MGMT_GATE, NFC_HCI_INVALID_PIPE},
99 {PN544_NFC_WI_MGMT_GATE, NFC_HCI_INVALID_PIPE},
100 {PN544_RF_READER_F_GATE, NFC_HCI_INVALID_PIPE},
101 {PN544_RF_READER_JEWEL_GATE, NFC_HCI_INVALID_PIPE},
102 {PN544_RF_READER_ISO15693_GATE, NFC_HCI_INVALID_PIPE},
103 {PN544_RF_READER_NFCIP1_INITIATOR_GATE, NFC_HCI_INVALID_PIPE},
104 {PN544_RF_READER_NFCIP1_TARGET_GATE, NFC_HCI_INVALID_PIPE}
105 };
106
107 /* Largest headroom needed for outgoing custom commands */
108 #define PN544_CMDS_HEADROOM 2
109
110 struct pn544_hci_info {
111 struct nfc_phy_ops *phy_ops;
112 void *phy_id;
113
114 struct nfc_hci_dev *hdev;
115
116 enum pn544_state state;
117
118 struct mutex info_lock;
119
120 int async_cb_type;
121 data_exchange_cb_t async_cb;
122 void *async_cb_context;
123
124 fw_download_t fw_download;
125 };
126
127 static int pn544_hci_open(struct nfc_hci_dev *hdev)
128 {
129 struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
130 int r = 0;
131
132 mutex_lock(&info->info_lock);
133
134 if (info->state != PN544_ST_COLD) {
135 r = -EBUSY;
136 goto out;
137 }
138
139 r = info->phy_ops->enable(info->phy_id);
140
141 if (r == 0)
142 info->state = PN544_ST_READY;
143
144 out:
145 mutex_unlock(&info->info_lock);
146 return r;
147 }
148
149 static void pn544_hci_close(struct nfc_hci_dev *hdev)
150 {
151 struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
152
153 mutex_lock(&info->info_lock);
154
155 if (info->state == PN544_ST_COLD)
156 goto out;
157
158 info->phy_ops->disable(info->phy_id);
159
160 info->state = PN544_ST_COLD;
161
162 out:
163 mutex_unlock(&info->info_lock);
164 }
165
166 static int pn544_hci_ready(struct nfc_hci_dev *hdev)
167 {
168 struct sk_buff *skb;
169 static struct hw_config {
170 u8 adr[2];
171 u8 value;
172 } hw_config[] = {
173 {{0x9f, 0x9a}, 0x00},
174
175 {{0x98, 0x10}, 0xbc},
176
177 {{0x9e, 0x71}, 0x00},
178
179 {{0x98, 0x09}, 0x00},
180
181 {{0x9e, 0xb4}, 0x00},
182
183 {{0x9c, 0x01}, 0x08},
184
185 {{0x9e, 0xaa}, 0x01},
186
187 {{0x9b, 0xd1}, 0x17},
188 {{0x9b, 0xd2}, 0x58},
189 {{0x9b, 0xd3}, 0x10},
190 {{0x9b, 0xd4}, 0x47},
191 {{0x9b, 0xd5}, 0x0c},
192 {{0x9b, 0xd6}, 0x37},
193 {{0x9b, 0xdd}, 0x33},
194
195 {{0x9b, 0x84}, 0x00},
196 {{0x99, 0x81}, 0x79},
197 {{0x99, 0x31}, 0x79},
198
199 {{0x98, 0x00}, 0x3f},
200
201 {{0x9f, 0x09}, 0x02},
202
203 {{0x9f, 0x0a}, 0x05},
204
205 {{0x9e, 0xd1}, 0xa1},
206 {{0x99, 0x23}, 0x01},
207
208 {{0x9e, 0x74}, 0x00},
209 {{0x9e, 0x90}, 0x00},
210 {{0x9f, 0x28}, 0x10},
211
212 {{0x9f, 0x35}, 0x04},
213
214 {{0x9f, 0x36}, 0x11},
215
216 {{0x9c, 0x31}, 0x00},
217
218 {{0x9c, 0x32}, 0x00},
219
220 {{0x9c, 0x19}, 0x0a},
221
222 {{0x9c, 0x1a}, 0x0a},
223
224 {{0x9c, 0x0c}, 0x00},
225
226 {{0x9c, 0x0d}, 0x00},
227
228 {{0x9c, 0x12}, 0x00},
229
230 {{0x9c, 0x13}, 0x00},
231
232 {{0x98, 0xa2}, 0x09},
233
234 {{0x98, 0x93}, 0x00},
235
236 {{0x98, 0x7d}, 0x08},
237 {{0x98, 0x7e}, 0x00},
238 {{0x9f, 0xc8}, 0x00},
239 };
240 struct hw_config *p = hw_config;
241 int count = ARRAY_SIZE(hw_config);
242 struct sk_buff *res_skb;
243 u8 param[4];
244 int r;
245
246 param[0] = 0;
247 while (count--) {
248 param[1] = p->adr[0];
249 param[2] = p->adr[1];
250 param[3] = p->value;
251
252 r = nfc_hci_send_cmd(hdev, PN544_SYS_MGMT_GATE, PN544_WRITE,
253 param, 4, &res_skb);
254 if (r < 0)
255 return r;
256
257 if (res_skb->len != 1) {
258 kfree_skb(res_skb);
259 return -EPROTO;
260 }
261
262 if (res_skb->data[0] != p->value) {
263 kfree_skb(res_skb);
264 return -EIO;
265 }
266
267 kfree_skb(res_skb);
268
269 p++;
270 }
271
272 param[0] = NFC_HCI_UICC_HOST_ID;
273 r = nfc_hci_set_param(hdev, NFC_HCI_ADMIN_GATE,
274 NFC_HCI_ADMIN_WHITELIST, param, 1);
275 if (r < 0)
276 return r;
277
278 param[0] = 0x3d;
279 r = nfc_hci_set_param(hdev, PN544_SYS_MGMT_GATE,
280 PN544_SYS_MGMT_INFO_NOTIFICATION, param, 1);
281 if (r < 0)
282 return r;
283
284 param[0] = 0x0;
285 r = nfc_hci_set_param(hdev, NFC_HCI_RF_READER_A_GATE,
286 PN544_RF_READER_A_AUTO_ACTIVATION, param, 1);
287 if (r < 0)
288 return r;
289
290 r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
291 NFC_HCI_EVT_END_OPERATION, NULL, 0);
292 if (r < 0)
293 return r;
294
295 param[0] = 0x1;
296 r = nfc_hci_set_param(hdev, PN544_POLLING_LOOP_MGMT_GATE,
297 PN544_PL_NFCT_DEACTIVATED, param, 1);
298 if (r < 0)
299 return r;
300
301 param[0] = 0x0;
302 r = nfc_hci_set_param(hdev, PN544_POLLING_LOOP_MGMT_GATE,
303 PN544_PL_RDPHASES, param, 1);
304 if (r < 0)
305 return r;
306
307 r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
308 PN544_ID_MGMT_FULL_VERSION_SW, &skb);
309 if (r < 0)
310 return r;
311
312 if (skb->len != FULL_VERSION_LEN) {
313 kfree_skb(skb);
314 return -EINVAL;
315 }
316
317 print_hex_dump(KERN_DEBUG, "FULL VERSION SOFTWARE INFO: ",
318 DUMP_PREFIX_NONE, 16, 1,
319 skb->data, FULL_VERSION_LEN, false);
320
321 kfree_skb(skb);
322
323 return 0;
324 }
325
326 static int pn544_hci_xmit(struct nfc_hci_dev *hdev, struct sk_buff *skb)
327 {
328 struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
329
330 return info->phy_ops->write(info->phy_id, skb);
331 }
332
333 static int pn544_hci_start_poll(struct nfc_hci_dev *hdev,
334 u32 im_protocols, u32 tm_protocols)
335 {
336 u8 phases = 0;
337 int r;
338 u8 duration[2];
339 u8 activated;
340 u8 i_mode = 0x3f; /* Enable all supported modes */
341 u8 t_mode = 0x0f;
342 u8 t_merge = 0x01; /* Enable merge by default */
343
344 pr_info(DRIVER_DESC ": %s protocols 0x%x 0x%x\n",
345 __func__, im_protocols, tm_protocols);
346
347 r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
348 NFC_HCI_EVT_END_OPERATION, NULL, 0);
349 if (r < 0)
350 return r;
351
352 duration[0] = 0x18;
353 duration[1] = 0x6a;
354 r = nfc_hci_set_param(hdev, PN544_POLLING_LOOP_MGMT_GATE,
355 PN544_PL_EMULATION, duration, 2);
356 if (r < 0)
357 return r;
358
359 activated = 0;
360 r = nfc_hci_set_param(hdev, PN544_POLLING_LOOP_MGMT_GATE,
361 PN544_PL_NFCT_DEACTIVATED, &activated, 1);
362 if (r < 0)
363 return r;
364
365 if (im_protocols & (NFC_PROTO_ISO14443_MASK | NFC_PROTO_MIFARE_MASK |
366 NFC_PROTO_JEWEL_MASK))
367 phases |= 1; /* Type A */
368 if (im_protocols & NFC_PROTO_FELICA_MASK) {
369 phases |= (1 << 2); /* Type F 212 */
370 phases |= (1 << 3); /* Type F 424 */
371 }
372
373 phases |= (1 << 5); /* NFC active */
374
375 r = nfc_hci_set_param(hdev, PN544_POLLING_LOOP_MGMT_GATE,
376 PN544_PL_RDPHASES, &phases, 1);
377 if (r < 0)
378 return r;
379
380 if ((im_protocols | tm_protocols) & NFC_PROTO_NFC_DEP_MASK) {
381 hdev->gb = nfc_get_local_general_bytes(hdev->ndev,
382 &hdev->gb_len);
383 pr_debug("generate local bytes %p\n", hdev->gb);
384 if (hdev->gb == NULL || hdev->gb_len == 0) {
385 im_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
386 tm_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
387 }
388 }
389
390 if (im_protocols & NFC_PROTO_NFC_DEP_MASK) {
391 r = nfc_hci_send_event(hdev,
392 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
393 NFC_HCI_EVT_END_OPERATION, NULL, 0);
394 if (r < 0)
395 return r;
396
397 r = nfc_hci_set_param(hdev,
398 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
399 PN544_DEP_MODE, &i_mode, 1);
400 if (r < 0)
401 return r;
402
403 r = nfc_hci_set_param(hdev,
404 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
405 PN544_DEP_ATR_REQ, hdev->gb, hdev->gb_len);
406 if (r < 0)
407 return r;
408
409 r = nfc_hci_send_event(hdev,
410 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
411 NFC_HCI_EVT_READER_REQUESTED, NULL, 0);
412 if (r < 0)
413 nfc_hci_send_event(hdev,
414 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
415 NFC_HCI_EVT_END_OPERATION, NULL, 0);
416 }
417
418 if (tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
419 r = nfc_hci_set_param(hdev, PN544_RF_READER_NFCIP1_TARGET_GATE,
420 PN544_DEP_MODE, &t_mode, 1);
421 if (r < 0)
422 return r;
423
424 r = nfc_hci_set_param(hdev, PN544_RF_READER_NFCIP1_TARGET_GATE,
425 PN544_DEP_ATR_RES, hdev->gb, hdev->gb_len);
426 if (r < 0)
427 return r;
428
429 r = nfc_hci_set_param(hdev, PN544_RF_READER_NFCIP1_TARGET_GATE,
430 PN544_DEP_MERGE, &t_merge, 1);
431 if (r < 0)
432 return r;
433 }
434
435 r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
436 NFC_HCI_EVT_READER_REQUESTED, NULL, 0);
437 if (r < 0)
438 nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
439 NFC_HCI_EVT_END_OPERATION, NULL, 0);
440
441 return r;
442 }
443
444 static int pn544_hci_dep_link_up(struct nfc_hci_dev *hdev,
445 struct nfc_target *target, u8 comm_mode,
446 u8 *gb, size_t gb_len)
447 {
448 struct sk_buff *rgb_skb = NULL;
449 int r;
450
451 r = nfc_hci_get_param(hdev, target->hci_reader_gate,
452 PN544_DEP_ATR_RES, &rgb_skb);
453 if (r < 0)
454 return r;
455
456 if (rgb_skb->len == 0 || rgb_skb->len > NFC_GB_MAXSIZE) {
457 r = -EPROTO;
458 goto exit;
459 }
460 print_hex_dump(KERN_DEBUG, "remote gb: ", DUMP_PREFIX_OFFSET,
461 16, 1, rgb_skb->data, rgb_skb->len, true);
462
463 r = nfc_set_remote_general_bytes(hdev->ndev, rgb_skb->data,
464 rgb_skb->len);
465
466 if (r == 0)
467 r = nfc_dep_link_is_up(hdev->ndev, target->idx, comm_mode,
468 NFC_RF_INITIATOR);
469 exit:
470 kfree_skb(rgb_skb);
471 return r;
472 }
473
474 static int pn544_hci_dep_link_down(struct nfc_hci_dev *hdev)
475 {
476
477 return nfc_hci_send_event(hdev, PN544_RF_READER_NFCIP1_INITIATOR_GATE,
478 NFC_HCI_EVT_END_OPERATION, NULL, 0);
479 }
480
481 static int pn544_hci_target_from_gate(struct nfc_hci_dev *hdev, u8 gate,
482 struct nfc_target *target)
483 {
484 switch (gate) {
485 case PN544_RF_READER_F_GATE:
486 target->supported_protocols = NFC_PROTO_FELICA_MASK;
487 break;
488 case PN544_RF_READER_JEWEL_GATE:
489 target->supported_protocols = NFC_PROTO_JEWEL_MASK;
490 target->sens_res = 0x0c00;
491 break;
492 case PN544_RF_READER_NFCIP1_INITIATOR_GATE:
493 target->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
494 break;
495 default:
496 return -EPROTO;
497 }
498
499 return 0;
500 }
501
502 static int pn544_hci_complete_target_discovered(struct nfc_hci_dev *hdev,
503 u8 gate,
504 struct nfc_target *target)
505 {
506 struct sk_buff *uid_skb;
507 int r = 0;
508
509 if (gate == PN544_RF_READER_NFCIP1_INITIATOR_GATE)
510 return r;
511
512 if (target->supported_protocols & NFC_PROTO_NFC_DEP_MASK) {
513 r = nfc_hci_send_cmd(hdev,
514 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
515 PN544_HCI_CMD_CONTINUE_ACTIVATION, NULL, 0, NULL);
516 if (r < 0)
517 return r;
518
519 target->hci_reader_gate = PN544_RF_READER_NFCIP1_INITIATOR_GATE;
520 } else if (target->supported_protocols & NFC_PROTO_MIFARE_MASK) {
521 if (target->nfcid1_len != 4 && target->nfcid1_len != 7 &&
522 target->nfcid1_len != 10)
523 return -EPROTO;
524
525 r = nfc_hci_send_cmd(hdev, NFC_HCI_RF_READER_A_GATE,
526 PN544_RF_READER_CMD_ACTIVATE_NEXT,
527 target->nfcid1, target->nfcid1_len, NULL);
528 } else if (target->supported_protocols & NFC_PROTO_FELICA_MASK) {
529 r = nfc_hci_get_param(hdev, PN544_RF_READER_F_GATE,
530 PN544_FELICA_ID, &uid_skb);
531 if (r < 0)
532 return r;
533
534 if (uid_skb->len != 8) {
535 kfree_skb(uid_skb);
536 return -EPROTO;
537 }
538
539 /* Type F NFC-DEP IDm has prefix 0x01FE */
540 if ((uid_skb->data[0] == 0x01) && (uid_skb->data[1] == 0xfe)) {
541 kfree_skb(uid_skb);
542 r = nfc_hci_send_cmd(hdev,
543 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
544 PN544_HCI_CMD_CONTINUE_ACTIVATION,
545 NULL, 0, NULL);
546 if (r < 0)
547 return r;
548
549 target->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
550 target->hci_reader_gate =
551 PN544_RF_READER_NFCIP1_INITIATOR_GATE;
552 } else {
553 r = nfc_hci_send_cmd(hdev, PN544_RF_READER_F_GATE,
554 PN544_RF_READER_CMD_ACTIVATE_NEXT,
555 uid_skb->data, uid_skb->len, NULL);
556 kfree_skb(uid_skb);
557 }
558 } else if (target->supported_protocols & NFC_PROTO_ISO14443_MASK) {
559 /*
560 * TODO: maybe other ISO 14443 require some kind of continue
561 * activation, but for now we've seen only this one below.
562 */
563 if (target->sens_res == 0x4403) /* Type 4 Mifare DESFire */
564 r = nfc_hci_send_cmd(hdev, NFC_HCI_RF_READER_A_GATE,
565 PN544_RF_READER_A_CMD_CONTINUE_ACTIVATION,
566 NULL, 0, NULL);
567 }
568
569 return r;
570 }
571
572 #define PN544_CB_TYPE_READER_F 1
573
574 static void pn544_hci_data_exchange_cb(void *context, struct sk_buff *skb,
575 int err)
576 {
577 struct pn544_hci_info *info = context;
578
579 switch (info->async_cb_type) {
580 case PN544_CB_TYPE_READER_F:
581 if (err == 0)
582 skb_pull(skb, 1);
583 info->async_cb(info->async_cb_context, skb, err);
584 break;
585 default:
586 if (err == 0)
587 kfree_skb(skb);
588 break;
589 }
590 }
591
592 #define MIFARE_CMD_AUTH_KEY_A 0x60
593 #define MIFARE_CMD_AUTH_KEY_B 0x61
594 #define MIFARE_CMD_HEADER 2
595 #define MIFARE_UID_LEN 4
596 #define MIFARE_KEY_LEN 6
597 #define MIFARE_CMD_LEN 12
598 /*
599 * Returns:
600 * <= 0: driver handled the data exchange
601 * 1: driver doesn't especially handle, please do standard processing
602 */
603 static int pn544_hci_im_transceive(struct nfc_hci_dev *hdev,
604 struct nfc_target *target,
605 struct sk_buff *skb, data_exchange_cb_t cb,
606 void *cb_context)
607 {
608 struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
609
610 pr_info(DRIVER_DESC ": %s for gate=%d\n", __func__,
611 target->hci_reader_gate);
612
613 switch (target->hci_reader_gate) {
614 case NFC_HCI_RF_READER_A_GATE:
615 if (target->supported_protocols & NFC_PROTO_MIFARE_MASK) {
616 /*
617 * It seems that pn544 is inverting key and UID for
618 * MIFARE authentication commands.
619 */
620 if (skb->len == MIFARE_CMD_LEN &&
621 (skb->data[0] == MIFARE_CMD_AUTH_KEY_A ||
622 skb->data[0] == MIFARE_CMD_AUTH_KEY_B)) {
623 u8 uid[MIFARE_UID_LEN];
624 u8 *data = skb->data + MIFARE_CMD_HEADER;
625
626 memcpy(uid, data + MIFARE_KEY_LEN,
627 MIFARE_UID_LEN);
628 memmove(data + MIFARE_UID_LEN, data,
629 MIFARE_KEY_LEN);
630 memcpy(data, uid, MIFARE_UID_LEN);
631 }
632
633 return nfc_hci_send_cmd_async(hdev,
634 target->hci_reader_gate,
635 PN544_MIFARE_CMD,
636 skb->data, skb->len,
637 cb, cb_context);
638 } else
639 return 1;
640 case PN544_RF_READER_F_GATE:
641 *(u8 *)skb_push(skb, 1) = 0;
642 *(u8 *)skb_push(skb, 1) = 0;
643
644 info->async_cb_type = PN544_CB_TYPE_READER_F;
645 info->async_cb = cb;
646 info->async_cb_context = cb_context;
647
648 return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
649 PN544_FELICA_RAW, skb->data,
650 skb->len,
651 pn544_hci_data_exchange_cb, info);
652 case PN544_RF_READER_JEWEL_GATE:
653 return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
654 PN544_JEWEL_RAW_CMD, skb->data,
655 skb->len, cb, cb_context);
656 case PN544_RF_READER_NFCIP1_INITIATOR_GATE:
657 *(u8 *)skb_push(skb, 1) = 0;
658
659 return nfc_hci_send_event(hdev, target->hci_reader_gate,
660 PN544_HCI_EVT_SND_DATA, skb->data,
661 skb->len);
662 default:
663 return 1;
664 }
665 }
666
667 static int pn544_hci_tm_send(struct nfc_hci_dev *hdev, struct sk_buff *skb)
668 {
669 int r;
670
671 /* Set default false for multiple information chaining */
672 *(u8 *)skb_push(skb, 1) = 0;
673
674 r = nfc_hci_send_event(hdev, PN544_RF_READER_NFCIP1_TARGET_GATE,
675 PN544_HCI_EVT_SND_DATA, skb->data, skb->len);
676
677 kfree_skb(skb);
678
679 return r;
680 }
681
682 static int pn544_hci_check_presence(struct nfc_hci_dev *hdev,
683 struct nfc_target *target)
684 {
685 pr_debug("supported protocol %d\n", target->supported_protocols);
686 if (target->supported_protocols & (NFC_PROTO_ISO14443_MASK |
687 NFC_PROTO_ISO14443_B_MASK)) {
688 return nfc_hci_send_cmd(hdev, target->hci_reader_gate,
689 PN544_RF_READER_CMD_PRESENCE_CHECK,
690 NULL, 0, NULL);
691 } else if (target->supported_protocols & NFC_PROTO_MIFARE_MASK) {
692 if (target->nfcid1_len != 4 && target->nfcid1_len != 7 &&
693 target->nfcid1_len != 10)
694 return -EOPNOTSUPP;
695
696 return nfc_hci_send_cmd(hdev, NFC_HCI_RF_READER_A_GATE,
697 PN544_RF_READER_CMD_ACTIVATE_NEXT,
698 target->nfcid1, target->nfcid1_len, NULL);
699 } else if (target->supported_protocols & (NFC_PROTO_JEWEL_MASK |
700 NFC_PROTO_FELICA_MASK)) {
701 return -EOPNOTSUPP;
702 } else if (target->supported_protocols & NFC_PROTO_NFC_DEP_MASK) {
703 return nfc_hci_send_cmd(hdev, target->hci_reader_gate,
704 PN544_HCI_CMD_ATTREQUEST,
705 NULL, 0, NULL);
706 }
707
708 return 0;
709 }
710
711 /*
712 * Returns:
713 * <= 0: driver handled the event, skb consumed
714 * 1: driver does not handle the event, please do standard processing
715 */
716 static int pn544_hci_event_received(struct nfc_hci_dev *hdev, u8 pipe, u8 event,
717 struct sk_buff *skb)
718 {
719 struct sk_buff *rgb_skb = NULL;
720 u8 gate = hdev->pipes[pipe].gate;
721 int r;
722
723 pr_debug("hci event %d\n", event);
724 switch (event) {
725 case PN544_HCI_EVT_ACTIVATED:
726 if (gate == PN544_RF_READER_NFCIP1_INITIATOR_GATE) {
727 r = nfc_hci_target_discovered(hdev, gate);
728 } else if (gate == PN544_RF_READER_NFCIP1_TARGET_GATE) {
729 r = nfc_hci_get_param(hdev, gate, PN544_DEP_ATR_REQ,
730 &rgb_skb);
731 if (r < 0)
732 goto exit;
733
734 r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK,
735 NFC_COMM_PASSIVE, rgb_skb->data,
736 rgb_skb->len);
737
738 kfree_skb(rgb_skb);
739 } else {
740 r = -EINVAL;
741 }
742 break;
743 case PN544_HCI_EVT_DEACTIVATED:
744 r = nfc_hci_send_event(hdev, gate, NFC_HCI_EVT_END_OPERATION,
745 NULL, 0);
746 break;
747 case PN544_HCI_EVT_RCV_DATA:
748 if (skb->len < 2) {
749 r = -EPROTO;
750 goto exit;
751 }
752
753 if (skb->data[0] != 0) {
754 pr_debug("data0 %d\n", skb->data[0]);
755 r = -EPROTO;
756 goto exit;
757 }
758
759 skb_pull(skb, 2);
760 return nfc_tm_data_received(hdev->ndev, skb);
761 default:
762 return 1;
763 }
764
765 exit:
766 kfree_skb(skb);
767
768 return r;
769 }
770
771 static int pn544_hci_fw_download(struct nfc_hci_dev *hdev,
772 const char *firmware_name)
773 {
774 struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
775
776 if (info->fw_download == NULL)
777 return -ENOTSUPP;
778
779 return info->fw_download(info->phy_id, firmware_name, hdev->sw_romlib);
780 }
781
782 static int pn544_hci_discover_se(struct nfc_hci_dev *hdev)
783 {
784 u32 se_idx = 0;
785 u8 ese_mode = 0x01; /* Default mode */
786 struct sk_buff *res_skb;
787 int r;
788
789 r = nfc_hci_send_cmd(hdev, PN544_SYS_MGMT_GATE, PN544_TEST_SWP,
790 NULL, 0, &res_skb);
791
792 if (r == 0) {
793 if (res_skb->len == 2 && res_skb->data[0] == 0x00)
794 nfc_add_se(hdev->ndev, se_idx++, NFC_SE_UICC);
795
796 kfree_skb(res_skb);
797 }
798
799 r = nfc_hci_send_event(hdev, PN544_NFC_WI_MGMT_GATE,
800 PN544_HCI_EVT_SWITCH_MODE,
801 &ese_mode, 1);
802 if (r == 0)
803 nfc_add_se(hdev->ndev, se_idx++, NFC_SE_EMBEDDED);
804
805 return !se_idx;
806 }
807
808 #define PN544_SE_MODE_OFF 0x00
809 #define PN544_SE_MODE_ON 0x01
810 static int pn544_hci_enable_se(struct nfc_hci_dev *hdev, u32 se_idx)
811 {
812 struct nfc_se *se;
813 u8 enable = PN544_SE_MODE_ON;
814 static struct uicc_gatelist {
815 u8 head;
816 u8 adr[2];
817 u8 value;
818 } uicc_gatelist[] = {
819 {0x00, {0x9e, 0xd9}, 0x23},
820 {0x00, {0x9e, 0xda}, 0x21},
821 {0x00, {0x9e, 0xdb}, 0x22},
822 {0x00, {0x9e, 0xdc}, 0x24},
823 };
824 struct uicc_gatelist *p = uicc_gatelist;
825 int count = ARRAY_SIZE(uicc_gatelist);
826 struct sk_buff *res_skb;
827 int r;
828
829 se = nfc_find_se(hdev->ndev, se_idx);
830
831 switch (se->type) {
832 case NFC_SE_UICC:
833 while (count--) {
834 r = nfc_hci_send_cmd(hdev, PN544_SYS_MGMT_GATE,
835 PN544_WRITE, (u8 *)p, 4, &res_skb);
836 if (r < 0)
837 return r;
838
839 if (res_skb->len != 1) {
840 kfree_skb(res_skb);
841 return -EPROTO;
842 }
843
844 if (res_skb->data[0] != p->value) {
845 kfree_skb(res_skb);
846 return -EIO;
847 }
848
849 kfree_skb(res_skb);
850
851 p++;
852 }
853
854 return nfc_hci_set_param(hdev, PN544_SWP_MGMT_GATE,
855 PN544_SWP_DEFAULT_MODE, &enable, 1);
856 case NFC_SE_EMBEDDED:
857 return nfc_hci_set_param(hdev, PN544_NFC_WI_MGMT_GATE,
858 PN544_NFC_ESE_DEFAULT_MODE, &enable, 1);
859
860 default:
861 return -EINVAL;
862 }
863 }
864
865 static int pn544_hci_disable_se(struct nfc_hci_dev *hdev, u32 se_idx)
866 {
867 struct nfc_se *se;
868 u8 disable = PN544_SE_MODE_OFF;
869
870 se = nfc_find_se(hdev->ndev, se_idx);
871
872 switch (se->type) {
873 case NFC_SE_UICC:
874 return nfc_hci_set_param(hdev, PN544_SWP_MGMT_GATE,
875 PN544_SWP_DEFAULT_MODE, &disable, 1);
876 case NFC_SE_EMBEDDED:
877 return nfc_hci_set_param(hdev, PN544_NFC_WI_MGMT_GATE,
878 PN544_NFC_ESE_DEFAULT_MODE, &disable, 1);
879 default:
880 return -EINVAL;
881 }
882 }
883
884 static struct nfc_hci_ops pn544_hci_ops = {
885 .open = pn544_hci_open,
886 .close = pn544_hci_close,
887 .hci_ready = pn544_hci_ready,
888 .xmit = pn544_hci_xmit,
889 .start_poll = pn544_hci_start_poll,
890 .dep_link_up = pn544_hci_dep_link_up,
891 .dep_link_down = pn544_hci_dep_link_down,
892 .target_from_gate = pn544_hci_target_from_gate,
893 .complete_target_discovered = pn544_hci_complete_target_discovered,
894 .im_transceive = pn544_hci_im_transceive,
895 .tm_send = pn544_hci_tm_send,
896 .check_presence = pn544_hci_check_presence,
897 .event_received = pn544_hci_event_received,
898 .fw_download = pn544_hci_fw_download,
899 .discover_se = pn544_hci_discover_se,
900 .enable_se = pn544_hci_enable_se,
901 .disable_se = pn544_hci_disable_se,
902 };
903
904 int pn544_hci_probe(void *phy_id, struct nfc_phy_ops *phy_ops, char *llc_name,
905 int phy_headroom, int phy_tailroom, int phy_payload,
906 fw_download_t fw_download, struct nfc_hci_dev **hdev)
907 {
908 struct pn544_hci_info *info;
909 u32 protocols;
910 struct nfc_hci_init_data init_data;
911 int r;
912
913 info = kzalloc(sizeof(struct pn544_hci_info), GFP_KERNEL);
914 if (!info) {
915 r = -ENOMEM;
916 goto err_info_alloc;
917 }
918
919 info->phy_ops = phy_ops;
920 info->phy_id = phy_id;
921 info->fw_download = fw_download;
922 info->state = PN544_ST_COLD;
923 mutex_init(&info->info_lock);
924
925 init_data.gate_count = ARRAY_SIZE(pn544_gates);
926
927 memcpy(init_data.gates, pn544_gates, sizeof(pn544_gates));
928
929 /*
930 * TODO: Session id must include the driver name + some bus addr
931 * persistent info to discriminate 2 identical chips
932 */
933 strcpy(init_data.session_id, "ID544HCI");
934
935 protocols = NFC_PROTO_JEWEL_MASK |
936 NFC_PROTO_MIFARE_MASK |
937 NFC_PROTO_FELICA_MASK |
938 NFC_PROTO_ISO14443_MASK |
939 NFC_PROTO_ISO14443_B_MASK |
940 NFC_PROTO_NFC_DEP_MASK;
941
942 info->hdev = nfc_hci_allocate_device(&pn544_hci_ops, &init_data, 0,
943 protocols, llc_name,
944 phy_headroom + PN544_CMDS_HEADROOM,
945 phy_tailroom, phy_payload);
946 if (!info->hdev) {
947 pr_err("Cannot allocate nfc hdev\n");
948 r = -ENOMEM;
949 goto err_alloc_hdev;
950 }
951
952 nfc_hci_set_clientdata(info->hdev, info);
953
954 r = nfc_hci_register_device(info->hdev);
955 if (r)
956 goto err_regdev;
957
958 *hdev = info->hdev;
959
960 return 0;
961
962 err_regdev:
963 nfc_hci_free_device(info->hdev);
964
965 err_alloc_hdev:
966 kfree(info);
967
968 err_info_alloc:
969 return r;
970 }
971 EXPORT_SYMBOL(pn544_hci_probe);
972
973 void pn544_hci_remove(struct nfc_hci_dev *hdev)
974 {
975 struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
976
977 nfc_hci_unregister_device(hdev);
978 nfc_hci_free_device(hdev);
979 kfree(info);
980 }
981 EXPORT_SYMBOL(pn544_hci_remove);
982
983 MODULE_LICENSE("GPL");
984 MODULE_DESCRIPTION(DRIVER_DESC);
Linux with added FPC-III support