~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/nfc/digital_core.c

Version: ~ [ linux-5.9 ] ~ [ linux-5.8.14 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.70 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.150 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.200 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.238 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.238 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp