projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bcm63xx_uart: Use the device name when registering an interrupt
[linux-2.6-block.git] / net / nfc / digital_core.c
CommitLineData
4b10884e
TE		 1/*
2 * NFC Digital Protocol stack
3 * Copyright (c) 2013, Intel Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 */
15
c5da0e4a
SO		 16#define pr_fmt(fmt) "digital: %s: " fmt, __func__
17
4b10884e
TE		 18#include <linux/module.h>
19
20#include "digital.h"
21
59ee2361 22#define DIGITAL_PROTO_NFCA_RF_TECH \
7d0911c0 23 (NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK | NFC_PROTO_NFC_DEP_MASK)
59ee2361 24
24734607
MG		 25#define DIGITAL_PROTO_NFCB_RF_TECH NFC_PROTO_ISO14443_B_MASK
26
7d0911c0
TE		 27#define DIGITAL_PROTO_NFCF_RF_TECH \
28 (NFC_PROTO_FELICA_MASK | NFC_PROTO_NFC_DEP_MASK)
8c0695e4 29
a381d482
MG		 30#define DIGITAL_PROTO_ISO15693_RF_TECH NFC_PROTO_ISO15693_MASK
31
59ee2361
TE		 32struct digital_cmd {
33 struct list_head queue;
34
35 u8 type;
36 u8 pending;
37
38 u16 timeout;
39 struct sk_buff *req;
40 struct sk_buff *resp;
1c7a4c24 41 struct digital_tg_mdaa_params *mdaa_params;
59ee2361
TE		 42
43 nfc_digital_cmd_complete_t cmd_cb;
44 void *cb_context;
45};
46
47struct sk_buff *digital_skb_alloc(struct nfc_digital_dev *ddev,
48 unsigned int len)
49{
50 struct sk_buff *skb;
51
52 skb = alloc_skb(len + ddev->tx_headroom + ddev->tx_tailroom,
53 GFP_KERNEL);
54 if (skb)
55 skb_reserve(skb, ddev->tx_headroom);
56
57 return skb;
58}
59
2c66daec
TE		 60void digital_skb_add_crc(struct sk_buff *skb, crc_func_t crc_func, u16 init,
61 u8 bitwise_inv, u8 msb_first)
62{
63 u16 crc;
64
65 crc = crc_func(init, skb->data, skb->len);
66
67 if (bitwise_inv)
68 crc = ~crc;
69
70 if (msb_first)
71 crc = __fswab16(crc);
72
73 *skb_put(skb, 1) = crc & 0xFF;
74 *skb_put(skb, 1) = (crc >> 8) & 0xFF;
75}
76
77int digital_skb_check_crc(struct sk_buff *skb, crc_func_t crc_func,
78 u16 crc_init, u8 bitwise_inv, u8 msb_first)
79{
80 int rc;
81 u16 crc;
82
83 if (skb->len <= 2)
84 return -EIO;
85
86 crc = crc_func(crc_init, skb->data, skb->len - 2);
87
88 if (bitwise_inv)
89 crc = ~crc;
90
91 if (msb_first)
92 crc = __swab16(crc);
93
94 rc = (skb->data[skb->len - 2] - (crc & 0xFF)) +
95 (skb->data[skb->len - 1] - ((crc >> 8) & 0xFF));
96
97 if (rc)
98 return -EIO;
99
100 skb_trim(skb, skb->len - 2);
101
102 return 0;
103}
104
59ee2361
TE		 105static inline void digital_switch_rf(struct nfc_digital_dev *ddev, bool on)
106{
107 ddev->ops->switch_rf(ddev, on);
108}
109
110static inline void digital_abort_cmd(struct nfc_digital_dev *ddev)
111{
112 ddev->ops->abort_cmd(ddev);
113}
114
115static void digital_wq_cmd_complete(struct work_struct *work)
116{
117 struct digital_cmd *cmd;
118 struct nfc_digital_dev *ddev = container_of(work,
119 struct nfc_digital_dev,
120 cmd_complete_work);
121
122 mutex_lock(&ddev->cmd_lock);
123
124 cmd = list_first_entry_or_null(&ddev->cmd_queue, struct digital_cmd,
125 queue);
126 if (!cmd) {
127 mutex_unlock(&ddev->cmd_lock);
128 return;
129 }
130
131 list_del(&cmd->queue);
132
133 mutex_unlock(&ddev->cmd_lock);
134
135 if (!IS_ERR(cmd->resp))
136 print_hex_dump_debug("DIGITAL RX: ", DUMP_PREFIX_NONE, 16, 1,
137 cmd->resp->data, cmd->resp->len, false);
138
139 cmd->cmd_cb(ddev, cmd->cb_context, cmd->resp);
140
1c7a4c24 141 kfree(cmd->mdaa_params);
59ee2361
TE		 142 kfree(cmd);
143
144 schedule_work(&ddev->cmd_work);
145}
146
147static void digital_send_cmd_complete(struct nfc_digital_dev *ddev,
148 void *arg, struct sk_buff *resp)
149{
150 struct digital_cmd *cmd = arg;
151
152 cmd->resp = resp;
153
154 schedule_work(&ddev->cmd_complete_work);
155}
156
157static void digital_wq_cmd(struct work_struct *work)
158{
159 int rc;
160 struct digital_cmd *cmd;
1c7a4c24 161 struct digital_tg_mdaa_params *params;
59ee2361
TE		 162 struct nfc_digital_dev *ddev = container_of(work,
163 struct nfc_digital_dev,
164 cmd_work);
165
166 mutex_lock(&ddev->cmd_lock);
167
168 cmd = list_first_entry_or_null(&ddev->cmd_queue, struct digital_cmd,
169 queue);
170 if (!cmd || cmd->pending) {
171 mutex_unlock(&ddev->cmd_lock);
172 return;
173 }
174
175 mutex_unlock(&ddev->cmd_lock);
176
177 if (cmd->req)
178 print_hex_dump_debug("DIGITAL TX: ", DUMP_PREFIX_NONE, 16, 1,
179 cmd->req->data, cmd->req->len, false);
180
181 switch (cmd->type) {
182 case DIGITAL_CMD_IN_SEND:
183 rc = ddev->ops->in_send_cmd(ddev, cmd->req, cmd->timeout,
184 digital_send_cmd_complete, cmd);
185 break;
1c7a4c24
TE		 186
187 case DIGITAL_CMD_TG_SEND:
188 rc = ddev->ops->tg_send_cmd(ddev, cmd->req, cmd->timeout,
189 digital_send_cmd_complete, cmd);
190 break;
191
192 case DIGITAL_CMD_TG_LISTEN:
193 rc = ddev->ops->tg_listen(ddev, cmd->timeout,
194 digital_send_cmd_complete, cmd);
195 break;
196
197 case DIGITAL_CMD_TG_LISTEN_MDAA:
198 params = cmd->mdaa_params;
199
200 rc = ddev->ops->tg_listen_mdaa(ddev, params, cmd->timeout,
201 digital_send_cmd_complete, cmd);
202 break;
203
bf30a67c
MG		 204 case DIGITAL_CMD_TG_LISTEN_MD:
205 rc = ddev->ops->tg_listen_md(ddev, cmd->timeout,
206 digital_send_cmd_complete, cmd);
207 break;
208
59ee2361 209 default:
26042530 210 pr_err("Unknown cmd type %d\n", cmd->type);
59ee2361
TE		 211 return;
212 }
213
214 if (!rc)
215 return;
216
26042530 217 pr_err("in_send_command returned err %d\n", rc);
59ee2361
TE		 218
219 mutex_lock(&ddev->cmd_lock);
220 list_del(&cmd->queue);
221 mutex_unlock(&ddev->cmd_lock);
222
223 kfree_skb(cmd->req);
1c7a4c24 224 kfree(cmd->mdaa_params);
59ee2361
TE		 225 kfree(cmd);
226
227 schedule_work(&ddev->cmd_work);
228}
229
230int digital_send_cmd(struct nfc_digital_dev *ddev, u8 cmd_type,
1c7a4c24
TE		 231 struct sk_buff *skb, struct digital_tg_mdaa_params *params,
232 u16 timeout, nfc_digital_cmd_complete_t cmd_cb,
233 void *cb_context)
59ee2361
TE		 234{
235 struct digital_cmd *cmd;
236
237 cmd = kzalloc(sizeof(struct digital_cmd), GFP_KERNEL);
238 if (!cmd)
239 return -ENOMEM;
240
241 cmd->type = cmd_type;
242 cmd->timeout = timeout;
243 cmd->req = skb;
1c7a4c24 244 cmd->mdaa_params = params;
59ee2361
TE		 245 cmd->cmd_cb = cmd_cb;
246 cmd->cb_context = cb_context;
247 INIT_LIST_HEAD(&cmd->queue);
248
249 mutex_lock(&ddev->cmd_lock);
250 list_add_tail(&cmd->queue, &ddev->cmd_queue);
251 mutex_unlock(&ddev->cmd_lock);
252
253 schedule_work(&ddev->cmd_work);
254
255 return 0;
256}
257
258int digital_in_configure_hw(struct nfc_digital_dev *ddev, int type, int param)
259{
260 int rc;
261
262 rc = ddev->ops->in_configure_hw(ddev, type, param);
263 if (rc)
26042530 264 pr_err("in_configure_hw failed: %d\n", rc);
59ee2361
TE		 265
266 return rc;
267}
268
1c7a4c24
TE		 269int digital_tg_configure_hw(struct nfc_digital_dev *ddev, int type, int param)
270{
271 int rc;
272
273 rc = ddev->ops->tg_configure_hw(ddev, type, param);
274 if (rc)
26042530 275 pr_err("tg_configure_hw failed: %d\n", rc);
1c7a4c24
TE		 276
277 return rc;
278}
279
280static int digital_tg_listen_mdaa(struct nfc_digital_dev *ddev, u8 rf_tech)
281{
282 struct digital_tg_mdaa_params *params;
283
284 params = kzalloc(sizeof(struct digital_tg_mdaa_params), GFP_KERNEL);
285 if (!params)
286 return -ENOMEM;
287
288 params->sens_res = DIGITAL_SENS_RES_NFC_DEP;
289 get_random_bytes(params->nfcid1, sizeof(params->nfcid1));
290 params->sel_res = DIGITAL_SEL_RES_NFC_DEP;
291
292 params->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
293 params->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
294 get_random_bytes(params->nfcid2 + 2, NFC_NFCID2_MAXSIZE - 2);
295 params->sc = DIGITAL_SENSF_FELICA_SC;
296
297 return digital_send_cmd(ddev, DIGITAL_CMD_TG_LISTEN_MDAA, NULL, params,
298 500, digital_tg_recv_atr_req, NULL);
299}
300
bf30a67c
MG		 301static int digital_tg_listen_md(struct nfc_digital_dev *ddev, u8 rf_tech)
302{
303 return digital_send_cmd(ddev, DIGITAL_CMD_TG_LISTEN_MD, NULL, NULL, 500,
304 digital_tg_recv_md_req, NULL);
305}
306
2c66daec
TE		 307int digital_target_found(struct nfc_digital_dev *ddev,
308 struct nfc_target *target, u8 protocol)
309{
310 int rc;
311 u8 framing;
312 u8 rf_tech;
0529a7ad 313 u8 poll_tech_count;
2c66daec
TE		 314 int (*check_crc)(struct sk_buff *skb);
315 void (*add_crc)(struct sk_buff *skb);
316
317 rf_tech = ddev->poll_techs[ddev->poll_tech_index].rf_tech;
318
319 switch (protocol) {
320 case NFC_PROTO_JEWEL:
321 framing = NFC_DIGITAL_FRAMING_NFCA_T1T;
322 check_crc = digital_skb_check_crc_b;
323 add_crc = digital_skb_add_crc_b;
324 break;
325
326 case NFC_PROTO_MIFARE:
327 framing = NFC_DIGITAL_FRAMING_NFCA_T2T;
328 check_crc = digital_skb_check_crc_a;
329 add_crc = digital_skb_add_crc_a;
330 break;
331
8c0695e4
TE		 332 case NFC_PROTO_FELICA:
333 framing = NFC_DIGITAL_FRAMING_NFCF_T3T;
334 check_crc = digital_skb_check_crc_f;
335 add_crc = digital_skb_add_crc_f;
336 break;
337
7d0911c0
TE		 338 case NFC_PROTO_NFC_DEP:
339 if (rf_tech == NFC_DIGITAL_RF_TECH_106A) {
340 framing = NFC_DIGITAL_FRAMING_NFCA_NFC_DEP;
341 check_crc = digital_skb_check_crc_a;
342 add_crc = digital_skb_add_crc_a;
343 } else {
344 framing = NFC_DIGITAL_FRAMING_NFCF_NFC_DEP;
345 check_crc = digital_skb_check_crc_f;
346 add_crc = digital_skb_add_crc_f;
347 }
348 break;
349
a381d482 350 case NFC_PROTO_ISO15693:
ceeee42d 351 framing = NFC_DIGITAL_FRAMING_ISO15693_T5T;
a381d482
MG		 352 check_crc = digital_skb_check_crc_b;
353 add_crc = digital_skb_add_crc_b;
564af14e 354 break;
12e3d241
TE		 355
356 case NFC_PROTO_ISO14443:
357 framing = NFC_DIGITAL_FRAMING_NFCA_T4T;
358 check_crc = digital_skb_check_crc_a;
359 add_crc = digital_skb_add_crc_a;
a381d482
MG		 360 break;
361
24734607
MG		 362 case NFC_PROTO_ISO14443_B:
363 framing = NFC_DIGITAL_FRAMING_NFCB_T4T;
364 check_crc = digital_skb_check_crc_b;
365 add_crc = digital_skb_add_crc_b;
366 break;
367
2c66daec 368 default:
26042530 369 pr_err("Invalid protocol %d\n", protocol);
2c66daec
TE		 370 return -EINVAL;
371 }
372
26042530 373 pr_debug("rf_tech=%d, protocol=%d\n", rf_tech, protocol);
2c66daec
TE		 374
375 ddev->curr_rf_tech = rf_tech;
2c66daec
TE		 376
377 if (DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
378 ddev->skb_add_crc = digital_skb_add_crc_none;
379 ddev->skb_check_crc = digital_skb_check_crc_none;
380 } else {
381 ddev->skb_add_crc = add_crc;
382 ddev->skb_check_crc = check_crc;
383 }
384
385 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, framing);
386 if (rc)
387 return rc;
388
389 target->supported_protocols = (1 << protocol);
2c66daec 390
0529a7ad 391 poll_tech_count = ddev->poll_tech_count;
2c66daec
TE		 392 ddev->poll_tech_count = 0;
393
0529a7ad
MG		 394 rc = nfc_targets_found(ddev->nfc_dev, target, 1);
395 if (rc) {
396 ddev->poll_tech_count = poll_tech_count;
397 return rc;
398 }
399
2c66daec
TE		 400 return 0;
401}
402
59ee2361
TE		 403void digital_poll_next_tech(struct nfc_digital_dev *ddev)
404{
9dc33705
TE		 405 u8 rand_mod;
406
59ee2361
TE		 407 digital_switch_rf(ddev, 0);
408
409 mutex_lock(&ddev->poll_lock);
410
411 if (!ddev->poll_tech_count) {
412 mutex_unlock(&ddev->poll_lock);
413 return;
414 }
415
9dc33705
TE		 416 get_random_bytes(&rand_mod, sizeof(rand_mod));
417 ddev->poll_tech_index = rand_mod % ddev->poll_tech_count;
59ee2361
TE		 418
419 mutex_unlock(&ddev->poll_lock);
420
421 schedule_work(&ddev->poll_work);
422}
423
424static void digital_wq_poll(struct work_struct *work)
425{
426 int rc;
427 struct digital_poll_tech *poll_tech;
428 struct nfc_digital_dev *ddev = container_of(work,
429 struct nfc_digital_dev,
430 poll_work);
431 mutex_lock(&ddev->poll_lock);
432
433 if (!ddev->poll_tech_count) {
434 mutex_unlock(&ddev->poll_lock);
435 return;
436 }
437
438 poll_tech = &ddev->poll_techs[ddev->poll_tech_index];
439
440 mutex_unlock(&ddev->poll_lock);
441
442 rc = poll_tech->poll_func(ddev, poll_tech->rf_tech);
443 if (rc)
444 digital_poll_next_tech(ddev);
445}
446
447static void digital_add_poll_tech(struct nfc_digital_dev *ddev, u8 rf_tech,
448 digital_poll_t poll_func)
449{
450 struct digital_poll_tech *poll_tech;
451
452 if (ddev->poll_tech_count >= NFC_DIGITAL_POLL_MODE_COUNT_MAX)
453 return;
454
455 poll_tech = &ddev->poll_techs[ddev->poll_tech_count++];
456
457 poll_tech->rf_tech = rf_tech;
458 poll_tech->poll_func = poll_func;
459}
460
461/**
462 * start_poll operation
463 *
464 * For every supported protocol, the corresponding polling function is added
465 * to the table of polling technologies (ddev->poll_techs[]) using
466 * digital_add_poll_tech().
467 * When a polling function fails (by timeout or protocol error) the next one is
468 * schedule by digital_poll_next_tech() on the poll workqueue (ddev->poll_work).
469 */
4b10884e
TE		 470static int digital_start_poll(struct nfc_dev *nfc_dev, __u32 im_protocols,
471 __u32 tm_protocols)
472{
59ee2361
TE		 473 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
474 u32 matching_im_protocols, matching_tm_protocols;
475
26042530 476 pr_debug("protocols: im 0x%x, tm 0x%x, supported 0x%x\n", im_protocols,
c5da0e4a 477 tm_protocols, ddev->protocols);
59ee2361
TE		 478
479 matching_im_protocols = ddev->protocols & im_protocols;
480 matching_tm_protocols = ddev->protocols & tm_protocols;
481
482 if (!matching_im_protocols && !matching_tm_protocols) {
26042530 483 pr_err("Unknown protocol\n");
59ee2361
TE		 484 return -EINVAL;
485 }
486
487 if (ddev->poll_tech_count) {
26042530 488 pr_err("Already polling\n");
59ee2361
TE		 489 return -EBUSY;
490 }
491
492 if (ddev->curr_protocol) {
26042530 493 pr_err("A target is already active\n");
59ee2361
TE		 494 return -EBUSY;
495 }
496
497 ddev->poll_tech_count = 0;
498 ddev->poll_tech_index = 0;
499
500 if (matching_im_protocols & DIGITAL_PROTO_NFCA_RF_TECH)
501 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_106A,
502 digital_in_send_sens_req);
503
24734607
MG		 504 if (matching_im_protocols & DIGITAL_PROTO_NFCB_RF_TECH)
505 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_106B,
506 digital_in_send_sensb_req);
507
4f913d46 508 if (matching_im_protocols & DIGITAL_PROTO_NFCF_RF_TECH) {
8c0695e4
TE		 509 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_212F,
510 digital_in_send_sensf_req);
511
512 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_424F,
513 digital_in_send_sensf_req);
514 }
515
a381d482
MG		 516 if (matching_im_protocols & DIGITAL_PROTO_ISO15693_RF_TECH)
517 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_ISO15693,
518 digital_in_send_iso15693_inv_req);
519
4f913d46 520 if (matching_tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
1c7a4c24
TE		 521 if (ddev->ops->tg_listen_mdaa) {
522 digital_add_poll_tech(ddev, 0,
523 digital_tg_listen_mdaa);
bf30a67c
MG		 524 } else if (ddev->ops->tg_listen_md) {
525 digital_add_poll_tech(ddev, 0,
526 digital_tg_listen_md);
1c7a4c24
TE		 527 } else {
528 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_106A,
529 digital_tg_listen_nfca);
530
531 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_212F,
532 digital_tg_listen_nfcf);
533
534 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_424F,
535 digital_tg_listen_nfcf);
536 }
537 }
538
59ee2361 539 if (!ddev->poll_tech_count) {
26042530 540 pr_err("Unsupported protocols: im=0x%x, tm=0x%x\n",
59ee2361
TE		 541 matching_im_protocols, matching_tm_protocols);
542 return -EINVAL;
543 }
544
545 schedule_work(&ddev->poll_work);
546
547 return 0;
4b10884e
TE		 548}
549
550static void digital_stop_poll(struct nfc_dev *nfc_dev)
551{
59ee2361
TE		 552 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
553
554 mutex_lock(&ddev->poll_lock);
555
556 if (!ddev->poll_tech_count) {
26042530 557 pr_err("Polling operation was not running\n");
59ee2361
TE		 558 mutex_unlock(&ddev->poll_lock);
559 return;
560 }
561
562 ddev->poll_tech_count = 0;
563
564 mutex_unlock(&ddev->poll_lock);
565
566 cancel_work_sync(&ddev->poll_work);
567
568 digital_abort_cmd(ddev);
4b10884e
TE		 569}
570
571static int digital_dev_up(struct nfc_dev *nfc_dev)
572{
59ee2361
TE		 573 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
574
575 digital_switch_rf(ddev, 1);
576
577 return 0;
4b10884e
TE		 578}
579
580static int digital_dev_down(struct nfc_dev *nfc_dev)
581{
59ee2361
TE		 582 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
583
584 digital_switch_rf(ddev, 0);
585
586 return 0;
4b10884e
TE		 587}
588
589static int digital_dep_link_up(struct nfc_dev *nfc_dev,
590 struct nfc_target *target,
591 __u8 comm_mode, __u8 *gb, size_t gb_len)
592{
7d0911c0 593 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
48e10445
TE		 594 int rc;
595
596 rc = digital_in_send_atr_req(ddev, target, comm_mode, gb, gb_len);
7d0911c0 597
48e10445
TE		 598 if (!rc)
599 ddev->curr_protocol = NFC_PROTO_NFC_DEP;
600
601 return rc;
4b10884e
TE		 602}
603
604static int digital_dep_link_down(struct nfc_dev *nfc_dev)
605{
7d0911c0
TE		 606 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
607
608 ddev->curr_protocol = 0;
609
610 return 0;
4b10884e
TE		 611}
612
613static int digital_activate_target(struct nfc_dev *nfc_dev,
614 struct nfc_target *target, __u32 protocol)
615{
48e10445
TE		 616 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
617
618 if (ddev->poll_tech_count) {
619 pr_err("Can't activate a target while polling\n");
620 return -EBUSY;
621 }
622
623 if (ddev->curr_protocol) {
624 pr_err("A target is already active\n");
625 return -EBUSY;
626 }
627
628 ddev->curr_protocol = protocol;
629
59ee2361 630 return 0;
4b10884e
TE		 631}
632
633static void digital_deactivate_target(struct nfc_dev *nfc_dev,
96d4581f
CR		 634 struct nfc_target *target,
635 u8 mode)
4b10884e 636{
59ee2361
TE		 637 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
638
48e10445
TE		 639 if (!ddev->curr_protocol) {
640 pr_err("No active target\n");
641 return;
642 }
643
59ee2361 644 ddev->curr_protocol = 0;
4b10884e
TE		 645}
646
647static int digital_tg_send(struct nfc_dev *dev, struct sk_buff *skb)
648{
1c7a4c24
TE		 649 struct nfc_digital_dev *ddev = nfc_get_drvdata(dev);
650
651 return digital_tg_send_dep_res(ddev, skb);
4b10884e
TE		 652}
653
2c66daec
TE		 654static void digital_in_send_complete(struct nfc_digital_dev *ddev, void *arg,
655 struct sk_buff *resp)
656{
657 struct digital_data_exch *data_exch = arg;
658 int rc;
659
660 if (IS_ERR(resp)) {
661 rc = PTR_ERR(resp);
c813007f 662 resp = NULL;
2c66daec
TE		 663 goto done;
664 }
665
c813007f 666 if (ddev->curr_protocol == NFC_PROTO_MIFARE) {
2c66daec 667 rc = digital_in_recv_mifare_res(resp);
c813007f
TE		 668 /* crc check is done in digital_in_recv_mifare_res() */
669 goto done;
670 }
671
24734607
MG		 672 if ((ddev->curr_protocol == NFC_PROTO_ISO14443) ||
673 (ddev->curr_protocol == NFC_PROTO_ISO14443_B)) {
c813007f
TE		 674 rc = digital_in_iso_dep_pull_sod(ddev, resp);
675 if (rc)
676 goto done;
677 }
678
679 rc = ddev->skb_check_crc(resp);
2c66daec 680
c813007f 681done:
2c66daec
TE		 682 if (rc) {
683 kfree_skb(resp);
684 resp = NULL;
685 }
686
2c66daec
TE		 687 data_exch->cb(data_exch->cb_context, resp, rc);
688
689 kfree(data_exch);
690}
691
4b10884e
TE		 692static int digital_in_send(struct nfc_dev *nfc_dev, struct nfc_target *target,
693 struct sk_buff *skb, data_exchange_cb_t cb,
694 void *cb_context)
695{
2c66daec
TE		 696 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
697 struct digital_data_exch *data_exch;
c813007f 698 int rc;
2c66daec
TE		 699
700 data_exch = kzalloc(sizeof(struct digital_data_exch), GFP_KERNEL);
701 if (!data_exch) {
26042530 702 pr_err("Failed to allocate data_exch struct\n");
2c66daec
TE		 703 return -ENOMEM;
704 }
705
706 data_exch->cb = cb;
707 data_exch->cb_context = cb_context;
708
6ea7398d
TE		 709 if (ddev->curr_protocol == NFC_PROTO_NFC_DEP) {
710 rc = digital_in_send_dep_req(ddev, target, skb, data_exch);
711 goto exit;
712 }
7d0911c0 713
24734607
MG		 714 if ((ddev->curr_protocol == NFC_PROTO_ISO14443) ||
715 (ddev->curr_protocol == NFC_PROTO_ISO14443_B)) {
c813007f
TE		 716 rc = digital_in_iso_dep_push_sod(ddev, skb);
717 if (rc)
6ea7398d 718 goto exit;
c813007f
TE		 719 }
720
2c66daec
TE		 721 ddev->skb_add_crc(skb);
722
6ea7398d
TE		 723 rc = digital_in_send_cmd(ddev, skb, 500, digital_in_send_complete,
724 data_exch);
725
726exit:
727 if (rc)
728 kfree(data_exch);
729
730 return rc;
4b10884e
TE		 731}
732
733static struct nfc_ops digital_nfc_ops = {
734 .dev_up = digital_dev_up,
735 .dev_down = digital_dev_down,
736 .start_poll = digital_start_poll,
737 .stop_poll = digital_stop_poll,
738 .dep_link_up = digital_dep_link_up,
739 .dep_link_down = digital_dep_link_down,
740 .activate_target = digital_activate_target,
741 .deactivate_target = digital_deactivate_target,
742 .tm_send = digital_tg_send,
743 .im_transceive = digital_in_send,
744};
745
746struct nfc_digital_dev *nfc_digital_allocate_device(struct nfc_digital_ops *ops,
747 __u32 supported_protocols,
748 __u32 driver_capabilities,
749 int tx_headroom, int tx_tailroom)
750{
751 struct nfc_digital_dev *ddev;
752
753 if (!ops->in_configure_hw || !ops->in_send_cmd || !ops->tg_listen ||
754 !ops->tg_configure_hw || !ops->tg_send_cmd || !ops->abort_cmd ||
bf30a67c 755 !ops->switch_rf || (ops->tg_listen_md && !ops->tg_get_rf_tech))
4b10884e
TE		 756 return NULL;
757
758 ddev = kzalloc(sizeof(struct nfc_digital_dev), GFP_KERNEL);
26042530 759 if (!ddev)
4b10884e 760 return NULL;
4b10884e
TE		 761
762 ddev->driver_capabilities = driver_capabilities;
763 ddev->ops = ops;
764
59ee2361
TE		 765 mutex_init(&ddev->cmd_lock);
766 INIT_LIST_HEAD(&ddev->cmd_queue);
767
768 INIT_WORK(&ddev->cmd_work, digital_wq_cmd);
769 INIT_WORK(&ddev->cmd_complete_work, digital_wq_cmd_complete);
770
771 mutex_init(&ddev->poll_lock);
772 INIT_WORK(&ddev->poll_work, digital_wq_poll);
773
774 if (supported_protocols & NFC_PROTO_JEWEL_MASK)
775 ddev->protocols |= NFC_PROTO_JEWEL_MASK;
776 if (supported_protocols & NFC_PROTO_MIFARE_MASK)
777 ddev->protocols |= NFC_PROTO_MIFARE_MASK;
8c0695e4
TE		 778 if (supported_protocols & NFC_PROTO_FELICA_MASK)
779 ddev->protocols |= NFC_PROTO_FELICA_MASK;
7d0911c0
TE		 780 if (supported_protocols & NFC_PROTO_NFC_DEP_MASK)
781 ddev->protocols |= NFC_PROTO_NFC_DEP_MASK;
a381d482
MG		 782 if (supported_protocols & NFC_PROTO_ISO15693_MASK)
783 ddev->protocols |= NFC_PROTO_ISO15693_MASK;
12e3d241
TE		 784 if (supported_protocols & NFC_PROTO_ISO14443_MASK)
785 ddev->protocols |= NFC_PROTO_ISO14443_MASK;
24734607
MG		 786 if (supported_protocols & NFC_PROTO_ISO14443_B_MASK)
787 ddev->protocols |= NFC_PROTO_ISO14443_B_MASK;
59ee2361
TE		 788
789 ddev->tx_headroom = tx_headroom + DIGITAL_MAX_HEADER_LEN;
790 ddev->tx_tailroom = tx_tailroom + DIGITAL_CRC_LEN;
4b10884e
TE		 791
792 ddev->nfc_dev = nfc_allocate_device(&digital_nfc_ops, ddev->protocols,
793 ddev->tx_headroom,
794 ddev->tx_tailroom);
795 if (!ddev->nfc_dev) {
26042530 796 pr_err("nfc_allocate_device failed\n");
4b10884e
TE		 797 goto free_dev;
798 }
799
800 nfc_set_drvdata(ddev->nfc_dev, ddev);
801
802 return ddev;
803
804free_dev:
805 kfree(ddev);
806
807 return NULL;
808}
809EXPORT_SYMBOL(nfc_digital_allocate_device);
810
811void nfc_digital_free_device(struct nfc_digital_dev *ddev)
812{
813 nfc_free_device(ddev->nfc_dev);
4b10884e
TE		 814 kfree(ddev);
815}
816EXPORT_SYMBOL(nfc_digital_free_device);
817
818int nfc_digital_register_device(struct nfc_digital_dev *ddev)
819{
820 return nfc_register_device(ddev->nfc_dev);
821}
822EXPORT_SYMBOL(nfc_digital_register_device);
823
824void nfc_digital_unregister_device(struct nfc_digital_dev *ddev)
825{
59ee2361
TE		 826 struct digital_cmd *cmd, *n;
827
4b10884e 828 nfc_unregister_device(ddev->nfc_dev);
59ee2361
TE		 829
830 mutex_lock(&ddev->poll_lock);
831 ddev->poll_tech_count = 0;
832 mutex_unlock(&ddev->poll_lock);
833
834 cancel_work_sync(&ddev->poll_work);
835 cancel_work_sync(&ddev->cmd_work);
836 cancel_work_sync(&ddev->cmd_complete_work);
837
838 list_for_each_entry_safe(cmd, n, &ddev->cmd_queue, queue) {
839 list_del(&cmd->queue);
1c7a4c24 840 kfree(cmd->mdaa_params);
59ee2361
TE		 841 kfree(cmd);
842 }
4b10884e
TE		 843}
844EXPORT_SYMBOL(nfc_digital_unregister_device);
845
846MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)