net/nfc/digital_core.c

   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 | NFC_PROTO_NFC_DEP_MASK)
  24
  25 #define DIGITAL_PROTO_NFCB_RF_TECH      NFC_PROTO_ISO14443_B_MASK
  26
  27 #define DIGITAL_PROTO_NFCF_RF_TECH \
  28         (NFC_PROTO_FELICA_MASK | NFC_PROTO_NFC_DEP_MASK)
  29
  30 #define DIGITAL_PROTO_ISO15693_RF_TECH  NFC_PROTO_ISO15693_MASK
  31
  32 struct 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;
  41         struct digital_tg_mdaa_params *mdaa_params;
  42
  43         nfc_digital_cmd_complete_t cmd_cb;
  44         void *cb_context;
  45 };
  46
  47 struct 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
  60 void 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
  77 int 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
 105 static inline void digital_switch_rf(struct nfc_digital_dev *ddev, bool on)
 106 {
 107         ddev->ops->switch_rf(ddev, on);
 108 }
 109
 110 static inline void digital_abort_cmd(struct nfc_digital_dev *ddev)
 111 {
 112         ddev->ops->abort_cmd(ddev);
 113 }
 114
 115 static 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
 141         kfree(cmd->mdaa_params);
 142         kfree(cmd);
 143
 144         schedule_work(&ddev->cmd_work);
 145 }
 146
 147 static 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
 157 static void digital_wq_cmd(struct work_struct *work)
 158 {
 159         int rc;
 160         struct digital_cmd *cmd;
 161         struct digital_tg_mdaa_params *params;
 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;
 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
 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
 209         default:
 210                 pr_err("Unknown cmd type %d\n", cmd->type);
 211                 return;
 212         }
 213
 214         if (!rc)
 215                 return;
 216
 217         pr_err("in_send_command returned err %d\n", rc);
 218
 219         mutex_lock(&ddev->cmd_lock);
 220         list_del(&cmd->queue);
 221         mutex_unlock(&ddev->cmd_lock);
 222
 223         kfree_skb(cmd->req);
 224         kfree(cmd->mdaa_params);
 225         kfree(cmd);
 226
 227         schedule_work(&ddev->cmd_work);
 228 }
 229
 230 int digital_send_cmd(struct nfc_digital_dev *ddev, u8 cmd_type,
 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)
 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;
 244         cmd->mdaa_params = params;
 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
 258 int 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)
 264                 pr_err("in_configure_hw failed: %d\n", rc);
 265
 266         return rc;
 267 }
 268
 269 int 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)
 275                 pr_err("tg_configure_hw failed: %d\n", rc);
 276
 277         return rc;
 278 }
 279
 280 static 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
 301 static 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
 307 int 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;
 313         u8 poll_tech_count;
 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
 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
 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
 350         case NFC_PROTO_ISO15693:
 351                 framing = NFC_DIGITAL_FRAMING_ISO15693_T5T;
 352                 check_crc = digital_skb_check_crc_b;
 353                 add_crc = digital_skb_add_crc_b;
 354                 break;
 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;
 360                 break;
 361
 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
 368         default:
 369                 pr_err("Invalid protocol %d\n", protocol);
 370                 return -EINVAL;
 371         }
 372
 373         pr_debug("rf_tech=%d, protocol=%d\n", rf_tech, protocol);
 374
 375         ddev->curr_rf_tech = rf_tech;
 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);
 390
 391         poll_tech_count = ddev->poll_tech_count;
 392         ddev->poll_tech_count = 0;
 393
 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
 400         return 0;
 401 }
 402
 403 void digital_poll_next_tech(struct nfc_digital_dev *ddev)
 404 {
 405         u8 rand_mod;
 406
 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
 416         get_random_bytes(&rand_mod, sizeof(rand_mod));
 417         ddev->poll_tech_index = rand_mod % ddev->poll_tech_count;
 418
 419         mutex_unlock(&ddev->poll_lock);
 420
 421         schedule_work(&ddev->poll_work);
 422 }
 423
 424 static 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
 447 static 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  */
 470 static int digital_start_poll(struct nfc_dev *nfc_dev, __u32 im_protocols,
 471                               __u32 tm_protocols)
 472 {
 473         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
 474         u32 matching_im_protocols, matching_tm_protocols;
 475
 476         pr_debug("protocols: im 0x%x, tm 0x%x, supported 0x%x\n", im_protocols,
 477                  tm_protocols, ddev->protocols);
 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) {
 483                 pr_err("Unknown protocol\n");
 484                 return -EINVAL;
 485         }
 486
 487         if (ddev->poll_tech_count) {
 488                 pr_err("Already polling\n");
 489                 return -EBUSY;
 490         }
 491
 492         if (ddev->curr_protocol) {
 493                 pr_err("A target is already active\n");
 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
 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
 508         if (matching_im_protocols & DIGITAL_PROTO_NFCF_RF_TECH) {
 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
 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
 520         if (matching_tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
 521                 if (ddev->ops->tg_listen_mdaa) {
 522                         digital_add_poll_tech(ddev, 0,
 523                                               digital_tg_listen_mdaa);
 524                 } else if (ddev->ops->tg_listen_md) {
 525                         digital_add_poll_tech(ddev, 0,
 526                                               digital_tg_listen_md);
 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
 539         if (!ddev->poll_tech_count) {
 540                 pr_err("Unsupported protocols: im=0x%x, tm=0x%x\n",
 541                        matching_im_protocols, matching_tm_protocols);
 542                 return -EINVAL;
 543         }
 544
 545         schedule_work(&ddev->poll_work);
 546
 547         return 0;
 548 }
 549
 550 static void digital_stop_poll(struct nfc_dev *nfc_dev)
 551 {
 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) {
 557                 pr_err("Polling operation was not running\n");
 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);
 569 }
 570
 571 static int digital_dev_up(struct nfc_dev *nfc_dev)
 572 {
 573         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
 574
 575         digital_switch_rf(ddev, 1);
 576
 577         return 0;
 578 }
 579
 580 static int digital_dev_down(struct nfc_dev *nfc_dev)
 581 {
 582         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
 583
 584         digital_switch_rf(ddev, 0);
 585
 586         return 0;
 587 }
 588
 589 static 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 {
 593         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
 594         int rc;
 595
 596         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;
 602 }
 603
 604 static int digital_dep_link_down(struct nfc_dev *nfc_dev)
 605 {
 606         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
 607
 608         ddev->curr_protocol = 0;
 609
 610         return 0;
 611 }
 612
 613 static int digital_activate_target(struct nfc_dev *nfc_dev,
 614                                    struct nfc_target *target, __u32 protocol)
 615 {
 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
 630         return 0;
 631 }
 632
 633 static void digital_deactivate_target(struct nfc_dev *nfc_dev,
 634                                       struct nfc_target *target,
 635                                       u8 mode)
 636 {
 637         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
 638
 639         if (!ddev->curr_protocol) {
 640                 pr_err("No active target\n");
 641                 return;
 642         }
 643
 644         ddev->curr_protocol = 0;
 645 }
 646
 647 static int digital_tg_send(struct nfc_dev *dev, struct sk_buff *skb)
 648 {
 649         struct nfc_digital_dev *ddev = nfc_get_drvdata(dev);
 650
 651         return digital_tg_send_dep_res(ddev, skb);
 652 }
 653
 654 static 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);
 662                 resp = NULL;
 663                 goto done;
 664         }
 665
 666         if (ddev->curr_protocol == NFC_PROTO_MIFARE) {
 667                 rc = digital_in_recv_mifare_res(resp);
 668                 /* crc check is done in digital_in_recv_mifare_res() */
 669                 goto done;
 670         }
 671
 672         if ((ddev->curr_protocol == NFC_PROTO_ISO14443) ||
 673             (ddev->curr_protocol == NFC_PROTO_ISO14443_B)) {
 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);
 680
 681 done:
 682         if (rc) {
 683                 kfree_skb(resp);
 684                 resp = NULL;
 685         }
 686
 687         data_exch->cb(data_exch->cb_context, resp, rc);
 688
 689         kfree(data_exch);
 690 }
 691
 692 static 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 {
 696         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
 697         struct digital_data_exch *data_exch;
 698         int rc;
 699
 700         data_exch = kzalloc(sizeof(struct digital_data_exch), GFP_KERNEL);
 701         if (!data_exch) {
 702                 pr_err("Failed to allocate data_exch struct\n");
 703                 return -ENOMEM;
 704         }
 705
 706         data_exch->cb = cb;
 707         data_exch->cb_context = cb_context;
 708
 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         }
 713
 714         if ((ddev->curr_protocol == NFC_PROTO_ISO14443) ||
 715             (ddev->curr_protocol == NFC_PROTO_ISO14443_B)) {
 716                 rc = digital_in_iso_dep_push_sod(ddev, skb);
 717                 if (rc)
 718                         goto exit;
 719         }
 720
 721         ddev->skb_add_crc(skb);
 722
 723         rc = digital_in_send_cmd(ddev, skb, 500, digital_in_send_complete,
 724                                  data_exch);
 725
 726 exit:
 727         if (rc)
 728                 kfree(data_exch);
 729
 730         return rc;
 731 }
 732
 733 static 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
 746 struct 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 ||
 755             !ops->switch_rf || (ops->tg_listen_md && !ops->tg_get_rf_tech))
 756                 return NULL;
 757
 758         ddev = kzalloc(sizeof(struct nfc_digital_dev), GFP_KERNEL);
 759         if (!ddev)
 760                 return NULL;
 761
 762         ddev->driver_capabilities = driver_capabilities;
 763         ddev->ops = ops;
 764
 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;
 778         if (supported_protocols & NFC_PROTO_FELICA_MASK)
 779                 ddev->protocols |= NFC_PROTO_FELICA_MASK;
 780         if (supported_protocols & NFC_PROTO_NFC_DEP_MASK)
 781                 ddev->protocols |= NFC_PROTO_NFC_DEP_MASK;
 782         if (supported_protocols & NFC_PROTO_ISO15693_MASK)
 783                 ddev->protocols |= NFC_PROTO_ISO15693_MASK;
 784         if (supported_protocols & NFC_PROTO_ISO14443_MASK)
 785                 ddev->protocols |= NFC_PROTO_ISO14443_MASK;
 786         if (supported_protocols & NFC_PROTO_ISO14443_B_MASK)
 787                 ddev->protocols |= NFC_PROTO_ISO14443_B_MASK;
 788
 789         ddev->tx_headroom = tx_headroom + DIGITAL_MAX_HEADER_LEN;
 790         ddev->tx_tailroom = tx_tailroom + DIGITAL_CRC_LEN;
 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) {
 796                 pr_err("nfc_allocate_device failed\n");
 797                 goto free_dev;
 798         }
 799
 800         nfc_set_drvdata(ddev->nfc_dev, ddev);
 801
 802         return ddev;
 803
 804 free_dev:
 805         kfree(ddev);
 806
 807         return NULL;
 808 }
 809 EXPORT_SYMBOL(nfc_digital_allocate_device);
 810
 811 void nfc_digital_free_device(struct nfc_digital_dev *ddev)
 812 {
 813         nfc_free_device(ddev->nfc_dev);
 814         kfree(ddev);
 815 }
 816 EXPORT_SYMBOL(nfc_digital_free_device);
 817
 818 int nfc_digital_register_device(struct nfc_digital_dev *ddev)
 819 {
 820         return nfc_register_device(ddev->nfc_dev);
 821 }
 822 EXPORT_SYMBOL(nfc_digital_register_device);
 823
 824 void nfc_digital_unregister_device(struct nfc_digital_dev *ddev)
 825 {
 826         struct digital_cmd *cmd, *n;
 827
 828         nfc_unregister_device(ddev->nfc_dev);
 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);
 840                 kfree(cmd->mdaa_params);
 841                 kfree(cmd);
 842         }
 843 }
 844 EXPORT_SYMBOL(nfc_digital_unregister_device);
 845
 846 MODULE_LICENSE("GPL");