blob: 23c2a118ac9f98c3cfd11c871a9126664f54838e [file] [log] [blame]
Thierry Escande4b10884eb2013-09-19 17:55:25 +02001/*
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
Samuel Ortizc5da0e42013-09-20 09:05:48 +020016#define pr_fmt(fmt) "digital: %s: " fmt, __func__
17
Thierry Escande4b10884eb2013-09-19 17:55:25 +020018#include <linux/module.h>
19
20#include "digital.h"
21
Thierry Escande59ee2362013-09-19 17:55:26 +020022#define DIGITAL_PROTO_NFCA_RF_TECH \
Thierry Escande7d0911c2013-09-19 17:55:29 +020023 (NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK | NFC_PROTO_NFC_DEP_MASK)
Thierry Escande59ee2362013-09-19 17:55:26 +020024
Mark A. Greer24734602014-03-31 17:36:38 -070025#define DIGITAL_PROTO_NFCB_RF_TECH NFC_PROTO_ISO14443_B_MASK
26
Thierry Escande7d0911c2013-09-19 17:55:29 +020027#define DIGITAL_PROTO_NFCF_RF_TECH \
28 (NFC_PROTO_FELICA_MASK | NFC_PROTO_NFC_DEP_MASK)
Thierry Escande8c0695e42013-09-19 17:55:28 +020029
Mark A. Greera381d482014-01-21 16:23:59 -070030#define DIGITAL_PROTO_ISO15693_RF_TECH NFC_PROTO_ISO15693_MASK
31
Thierry Escande59ee2362013-09-19 17:55:26 +020032struct 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;
Thierry Escande1c7a4c22013-09-19 17:55:30 +020041 struct digital_tg_mdaa_params *mdaa_params;
Thierry Escande59ee2362013-09-19 17:55:26 +020042
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
Thierry Escande2c66dae2013-09-19 17:55:27 +020060void 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
Thierry Escande59ee2362013-09-19 17:55:26 +0200105static 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
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200141 kfree(cmd->mdaa_params);
Thierry Escande59ee2362013-09-19 17:55:26 +0200142 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;
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200161 struct digital_tg_mdaa_params *params;
Thierry Escande59ee2362013-09-19 17:55:26 +0200162 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;
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200186
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
Mark A. Greerbf30a672014-07-21 21:24:39 -0700204 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
Thierry Escande59ee2362013-09-19 17:55:26 +0200209 default:
Samuel Ortiz26042532013-09-20 16:56:40 +0200210 pr_err("Unknown cmd type %d\n", cmd->type);
Thierry Escande59ee2362013-09-19 17:55:26 +0200211 return;
212 }
213
214 if (!rc)
215 return;
216
Samuel Ortiz26042532013-09-20 16:56:40 +0200217 pr_err("in_send_command returned err %d\n", rc);
Thierry Escande59ee2362013-09-19 17:55:26 +0200218
219 mutex_lock(&ddev->cmd_lock);
220 list_del(&cmd->queue);
221 mutex_unlock(&ddev->cmd_lock);
222
223 kfree_skb(cmd->req);
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200224 kfree(cmd->mdaa_params);
Thierry Escande59ee2362013-09-19 17:55:26 +0200225 kfree(cmd);
226
227 schedule_work(&ddev->cmd_work);
228}
229
230int digital_send_cmd(struct nfc_digital_dev *ddev, u8 cmd_type,
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200231 struct sk_buff *skb, struct digital_tg_mdaa_params *params,
232 u16 timeout, nfc_digital_cmd_complete_t cmd_cb,
233 void *cb_context)
Thierry Escande59ee2362013-09-19 17:55:26 +0200234{
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;
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200244 cmd->mdaa_params = params;
Thierry Escande59ee2362013-09-19 17:55:26 +0200245 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)
Samuel Ortiz26042532013-09-20 16:56:40 +0200264 pr_err("in_configure_hw failed: %d\n", rc);
Thierry Escande59ee2362013-09-19 17:55:26 +0200265
266 return rc;
267}
268
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200269int 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)
Samuel Ortiz26042532013-09-20 16:56:40 +0200275 pr_err("tg_configure_hw failed: %d\n", rc);
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200276
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
Mark A. Greerbf30a672014-07-21 21:24:39 -0700301static 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
Thierry Escande2c66dae2013-09-19 17:55:27 +0200307int 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;
Mark A. Greer0529a7a2014-07-02 09:03:49 -0700313 u8 poll_tech_count;
Thierry Escande2c66dae2013-09-19 17:55:27 +0200314 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
Thierry Escande8c0695e42013-09-19 17:55:28 +0200332 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
Thierry Escande7d0911c2013-09-19 17:55:29 +0200338 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
Mark A. Greera381d482014-01-21 16:23:59 -0700350 case NFC_PROTO_ISO15693:
Mark A. Greerceeee422014-03-06 07:39:19 -0700351 framing = NFC_DIGITAL_FRAMING_ISO15693_T5T;
Mark A. Greera381d482014-01-21 16:23:59 -0700352 check_crc = digital_skb_check_crc_b;
353 add_crc = digital_skb_add_crc_b;
Thierry Escande564af142014-02-12 12:13:23 +0100354 break;
Thierry Escande12e3d242014-01-27 00:31:31 +0100355
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;
Mark A. Greera381d482014-01-21 16:23:59 -0700360 break;
361
Mark A. Greer24734602014-03-31 17:36:38 -0700362 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
Thierry Escande2c66dae2013-09-19 17:55:27 +0200368 default:
Samuel Ortiz26042532013-09-20 16:56:40 +0200369 pr_err("Invalid protocol %d\n", protocol);
Thierry Escande2c66dae2013-09-19 17:55:27 +0200370 return -EINVAL;
371 }
372
Samuel Ortiz26042532013-09-20 16:56:40 +0200373 pr_debug("rf_tech=%d, protocol=%d\n", rf_tech, protocol);
Thierry Escande2c66dae2013-09-19 17:55:27 +0200374
375 ddev->curr_rf_tech = rf_tech;
Thierry Escande2c66dae2013-09-19 17:55:27 +0200376
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);
Thierry Escande2c66dae2013-09-19 17:55:27 +0200390
Mark A. Greer0529a7a2014-07-02 09:03:49 -0700391 poll_tech_count = ddev->poll_tech_count;
Thierry Escande2c66dae2013-09-19 17:55:27 +0200392 ddev->poll_tech_count = 0;
393
Mark A. Greer0529a7a2014-07-02 09:03:49 -0700394 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
Thierry Escande2c66dae2013-09-19 17:55:27 +0200400 return 0;
401}
402
Thierry Escande59ee2362013-09-19 17:55:26 +0200403void digital_poll_next_tech(struct nfc_digital_dev *ddev)
404{
Thierry Escande9dc33702014-05-10 13:06:02 +0200405 u8 rand_mod;
406
Thierry Escande59ee2362013-09-19 17:55:26 +0200407 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
Thierry Escande9dc33702014-05-10 13:06:02 +0200416 get_random_bytes(&rand_mod, sizeof(rand_mod));
417 ddev->poll_tech_index = rand_mod % ddev->poll_tech_count;
Thierry Escande59ee2362013-09-19 17:55:26 +0200418
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 */
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200470static int digital_start_poll(struct nfc_dev *nfc_dev, __u32 im_protocols,
471 __u32 tm_protocols)
472{
Thierry Escande59ee2362013-09-19 17:55:26 +0200473 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
474 u32 matching_im_protocols, matching_tm_protocols;
475
Samuel Ortiz26042532013-09-20 16:56:40 +0200476 pr_debug("protocols: im 0x%x, tm 0x%x, supported 0x%x\n", im_protocols,
Samuel Ortizc5da0e42013-09-20 09:05:48 +0200477 tm_protocols, ddev->protocols);
Thierry Escande59ee2362013-09-19 17:55:26 +0200478
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) {
Samuel Ortiz26042532013-09-20 16:56:40 +0200483 pr_err("Unknown protocol\n");
Thierry Escande59ee2362013-09-19 17:55:26 +0200484 return -EINVAL;
485 }
486
487 if (ddev->poll_tech_count) {
Samuel Ortiz26042532013-09-20 16:56:40 +0200488 pr_err("Already polling\n");
Thierry Escande59ee2362013-09-19 17:55:26 +0200489 return -EBUSY;
490 }
491
492 if (ddev->curr_protocol) {
Samuel Ortiz26042532013-09-20 16:56:40 +0200493 pr_err("A target is already active\n");
Thierry Escande59ee2362013-09-19 17:55:26 +0200494 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
Mark A. Greer24734602014-03-31 17:36:38 -0700504 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
Axel Lin4f913d42014-02-22 10:16:11 +0800508 if (matching_im_protocols & DIGITAL_PROTO_NFCF_RF_TECH) {
Thierry Escande8c0695e42013-09-19 17:55:28 +0200509 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
Mark A. Greera381d482014-01-21 16:23:59 -0700516 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
Axel Lin4f913d42014-02-22 10:16:11 +0800520 if (matching_tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200521 if (ddev->ops->tg_listen_mdaa) {
522 digital_add_poll_tech(ddev, 0,
523 digital_tg_listen_mdaa);
Mark A. Greerbf30a672014-07-21 21:24:39 -0700524 } else if (ddev->ops->tg_listen_md) {
525 digital_add_poll_tech(ddev, 0,
526 digital_tg_listen_md);
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200527 } 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
Thierry Escande59ee2362013-09-19 17:55:26 +0200539 if (!ddev->poll_tech_count) {
Samuel Ortiz26042532013-09-20 16:56:40 +0200540 pr_err("Unsupported protocols: im=0x%x, tm=0x%x\n",
Thierry Escande59ee2362013-09-19 17:55:26 +0200541 matching_im_protocols, matching_tm_protocols);
542 return -EINVAL;
543 }
544
545 schedule_work(&ddev->poll_work);
546
547 return 0;
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200548}
549
550static void digital_stop_poll(struct nfc_dev *nfc_dev)
551{
Thierry Escande59ee2362013-09-19 17:55:26 +0200552 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
553
554 mutex_lock(&ddev->poll_lock);
555
556 if (!ddev->poll_tech_count) {
Samuel Ortiz26042532013-09-20 16:56:40 +0200557 pr_err("Polling operation was not running\n");
Thierry Escande59ee2362013-09-19 17:55:26 +0200558 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);
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200569}
570
571static int digital_dev_up(struct nfc_dev *nfc_dev)
572{
Thierry Escande59ee2362013-09-19 17:55:26 +0200573 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
574
575 digital_switch_rf(ddev, 1);
576
577 return 0;
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200578}
579
580static int digital_dev_down(struct nfc_dev *nfc_dev)
581{
Thierry Escande59ee2362013-09-19 17:55:26 +0200582 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
583
584 digital_switch_rf(ddev, 0);
585
586 return 0;
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200587}
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{
Thierry Escande7d0911c2013-09-19 17:55:29 +0200593 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
Thierry Escande48e10442014-01-06 23:34:37 +0100594 int rc;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200595
Thierry Escande48e10442014-01-06 23:34:37 +0100596 rc = digital_in_send_atr_req(ddev, target, comm_mode, gb, gb_len);
597
598 if (!rc)
599 ddev->curr_protocol = NFC_PROTO_NFC_DEP;
600
601 return rc;
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200602}
603
604static int digital_dep_link_down(struct nfc_dev *nfc_dev)
605{
Thierry Escande7d0911c2013-09-19 17:55:29 +0200606 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
607
608 ddev->curr_protocol = 0;
609
610 return 0;
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200611}
612
613static int digital_activate_target(struct nfc_dev *nfc_dev,
614 struct nfc_target *target, __u32 protocol)
615{
Thierry Escande48e10442014-01-06 23:34:37 +0100616 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
Thierry Escande59ee2362013-09-19 17:55:26 +0200630 return 0;
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200631}
632
633static void digital_deactivate_target(struct nfc_dev *nfc_dev,
Christophe Ricard96d45812015-10-25 22:54:43 +0100634 struct nfc_target *target,
635 u8 mode)
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200636{
Thierry Escande59ee2362013-09-19 17:55:26 +0200637 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
638
Thierry Escande48e10442014-01-06 23:34:37 +0100639 if (!ddev->curr_protocol) {
640 pr_err("No active target\n");
641 return;
642 }
643
Thierry Escande59ee2362013-09-19 17:55:26 +0200644 ddev->curr_protocol = 0;
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200645}
646
647static int digital_tg_send(struct nfc_dev *dev, struct sk_buff *skb)
648{
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200649 struct nfc_digital_dev *ddev = nfc_get_drvdata(dev);
650
651 return digital_tg_send_dep_res(ddev, skb);
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200652}
653
Thierry Escande2c66dae2013-09-19 17:55:27 +0200654static 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);
Thierry Escandec8130072014-01-27 00:31:32 +0100662 resp = NULL;
Thierry Escande2c66dae2013-09-19 17:55:27 +0200663 goto done;
664 }
665
Thierry Escandec8130072014-01-27 00:31:32 +0100666 if (ddev->curr_protocol == NFC_PROTO_MIFARE) {
Thierry Escande2c66dae2013-09-19 17:55:27 +0200667 rc = digital_in_recv_mifare_res(resp);
Thierry Escandec8130072014-01-27 00:31:32 +0100668 /* crc check is done in digital_in_recv_mifare_res() */
669 goto done;
670 }
Thierry Escande2c66dae2013-09-19 17:55:27 +0200671
Mark A. Greer24734602014-03-31 17:36:38 -0700672 if ((ddev->curr_protocol == NFC_PROTO_ISO14443) ||
673 (ddev->curr_protocol == NFC_PROTO_ISO14443_B)) {
Thierry Escandec8130072014-01-27 00:31:32 +0100674 rc = digital_in_iso_dep_pull_sod(ddev, resp);
675 if (rc)
676 goto done;
677 }
678
679 rc = ddev->skb_check_crc(resp);
680
681done:
Thierry Escande2c66dae2013-09-19 17:55:27 +0200682 if (rc) {
683 kfree_skb(resp);
684 resp = NULL;
685 }
686
Thierry Escande2c66dae2013-09-19 17:55:27 +0200687 data_exch->cb(data_exch->cb_context, resp, rc);
688
689 kfree(data_exch);
690}
691
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200692static 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{
Thierry Escande2c66dae2013-09-19 17:55:27 +0200696 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
697 struct digital_data_exch *data_exch;
Thierry Escandec8130072014-01-27 00:31:32 +0100698 int rc;
Thierry Escande2c66dae2013-09-19 17:55:27 +0200699
700 data_exch = kzalloc(sizeof(struct digital_data_exch), GFP_KERNEL);
701 if (!data_exch) {
Samuel Ortiz26042532013-09-20 16:56:40 +0200702 pr_err("Failed to allocate data_exch struct\n");
Thierry Escande2c66dae2013-09-19 17:55:27 +0200703 return -ENOMEM;
704 }
705
706 data_exch->cb = cb;
707 data_exch->cb_context = cb_context;
708
Thierry Escande6ea73982014-02-12 14:27:51 +0100709 if (ddev->curr_protocol == NFC_PROTO_NFC_DEP) {
710 rc = digital_in_send_dep_req(ddev, target, skb, data_exch);
711 goto exit;
712 }
Thierry Escande7d0911c2013-09-19 17:55:29 +0200713
Mark A. Greer24734602014-03-31 17:36:38 -0700714 if ((ddev->curr_protocol == NFC_PROTO_ISO14443) ||
715 (ddev->curr_protocol == NFC_PROTO_ISO14443_B)) {
Thierry Escandec8130072014-01-27 00:31:32 +0100716 rc = digital_in_iso_dep_push_sod(ddev, skb);
717 if (rc)
Thierry Escande6ea73982014-02-12 14:27:51 +0100718 goto exit;
Thierry Escandec8130072014-01-27 00:31:32 +0100719 }
720
Thierry Escande2c66dae2013-09-19 17:55:27 +0200721 ddev->skb_add_crc(skb);
722
Thierry Escande6ea73982014-02-12 14:27:51 +0100723 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;
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200731}
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 ||
Mark A. Greerbf30a672014-07-21 21:24:39 -0700755 !ops->switch_rf || (ops->tg_listen_md && !ops->tg_get_rf_tech))
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200756 return NULL;
757
758 ddev = kzalloc(sizeof(struct nfc_digital_dev), GFP_KERNEL);
Samuel Ortiz26042532013-09-20 16:56:40 +0200759 if (!ddev)
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200760 return NULL;
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200761
762 ddev->driver_capabilities = driver_capabilities;
763 ddev->ops = ops;
764
Thierry Escande59ee2362013-09-19 17:55:26 +0200765 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;
Thierry Escande8c0695e42013-09-19 17:55:28 +0200778 if (supported_protocols & NFC_PROTO_FELICA_MASK)
779 ddev->protocols |= NFC_PROTO_FELICA_MASK;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200780 if (supported_protocols & NFC_PROTO_NFC_DEP_MASK)
781 ddev->protocols |= NFC_PROTO_NFC_DEP_MASK;
Mark A. Greera381d482014-01-21 16:23:59 -0700782 if (supported_protocols & NFC_PROTO_ISO15693_MASK)
783 ddev->protocols |= NFC_PROTO_ISO15693_MASK;
Thierry Escande12e3d242014-01-27 00:31:31 +0100784 if (supported_protocols & NFC_PROTO_ISO14443_MASK)
785 ddev->protocols |= NFC_PROTO_ISO14443_MASK;
Mark A. Greer24734602014-03-31 17:36:38 -0700786 if (supported_protocols & NFC_PROTO_ISO14443_B_MASK)
787 ddev->protocols |= NFC_PROTO_ISO14443_B_MASK;
Thierry Escande59ee2362013-09-19 17:55:26 +0200788
789 ddev->tx_headroom = tx_headroom + DIGITAL_MAX_HEADER_LEN;
790 ddev->tx_tailroom = tx_tailroom + DIGITAL_CRC_LEN;
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200791
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) {
Samuel Ortiz26042532013-09-20 16:56:40 +0200796 pr_err("nfc_allocate_device failed\n");
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200797 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);
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200814 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{
Thierry Escande59ee2362013-09-19 17:55:26 +0200826 struct digital_cmd *cmd, *n;
827
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200828 nfc_unregister_device(ddev->nfc_dev);
Thierry Escande59ee2362013-09-19 17:55:26 +0200829
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);
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200840 kfree(cmd->mdaa_params);
Thierry Escande59ee2362013-09-19 17:55:26 +0200841 kfree(cmd);
842 }
Thierry Escande4b10884eb2013-09-19 17:55:25 +0200843}
844EXPORT_SYMBOL(nfc_digital_unregister_device);
845
846MODULE_LICENSE("GPL");