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