drivers/nfc/fdp/fdp.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* -------------------------------------------------------------------------
   3  * Copyright (C) 2014-2016, Intel Corporation
   4  *
   5  * -------------------------------------------------------------------------
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/nfc.h>
  10 #include <linux/i2c.h>
  11 #include <linux/delay.h>
  12 #include <linux/firmware.h>
  13 #include <net/nfc/nci_core.h>
  14
  15 #include "fdp.h"
  16
  17 #define FDP_OTP_PATCH_NAME                      "otp.bin"
  18 #define FDP_RAM_PATCH_NAME                      "ram.bin"
  19 #define FDP_FW_HEADER_SIZE                      576
  20 #define FDP_FW_UPDATE_SLEEP                     1000
  21
  22 #define NCI_GET_VERSION_TIMEOUT                 8000
  23 #define NCI_PATCH_REQUEST_TIMEOUT               8000
  24 #define FDP_PATCH_CONN_DEST                     0xC2
  25 #define FDP_PATCH_CONN_PARAM_TYPE               0xA0
  26
  27 #define NCI_PATCH_TYPE_RAM                      0x00
  28 #define NCI_PATCH_TYPE_OTP                      0x01
  29 #define NCI_PATCH_TYPE_EOT                      0xFF
  30
  31 #define NCI_PARAM_ID_FW_RAM_VERSION             0xA0
  32 #define NCI_PARAM_ID_FW_OTP_VERSION             0xA1
  33 #define NCI_PARAM_ID_OTP_LIMITED_VERSION        0xC5
  34 #define NCI_PARAM_ID_KEY_INDEX_ID               0xC6
  35
  36 #define NCI_GID_PROP                            0x0F
  37 #define NCI_OP_PROP_PATCH_OID                   0x08
  38 #define NCI_OP_PROP_SET_PDATA_OID               0x23
  39
  40 struct fdp_nci_info {
  41         const struct nfc_phy_ops *phy_ops;
  42         struct fdp_i2c_phy *phy;
  43         struct nci_dev *ndev;
  44
  45         const struct firmware *otp_patch;
  46         const struct firmware *ram_patch;
  47         u32 otp_patch_version;
  48         u32 ram_patch_version;
  49
  50         u32 otp_version;
  51         u32 ram_version;
  52         u32 limited_otp_version;
  53         u8 key_index;
  54
  55         u8 *fw_vsc_cfg;
  56         u8 clock_type;
  57         u32 clock_freq;
  58
  59         atomic_t data_pkt_counter;
  60         void (*data_pkt_counter_cb)(struct nci_dev *ndev);
  61         u8 setup_patch_sent;
  62         u8 setup_patch_ntf;
  63         u8 setup_patch_status;
  64         u8 setup_reset_ntf;
  65         wait_queue_head_t setup_wq;
  66 };
  67
  68 static u8 nci_core_get_config_otp_ram_version[5] = {
  69         0x04,
  70         NCI_PARAM_ID_FW_RAM_VERSION,
  71         NCI_PARAM_ID_FW_OTP_VERSION,
  72         NCI_PARAM_ID_OTP_LIMITED_VERSION,
  73         NCI_PARAM_ID_KEY_INDEX_ID
  74 };
  75
  76 struct nci_core_get_config_rsp {
  77         u8 status;
  78         u8 count;
  79         u8 data[];
  80 };
  81
  82 static int fdp_nci_create_conn(struct nci_dev *ndev)
  83 {
  84         struct fdp_nci_info *info = nci_get_drvdata(ndev);
  85         struct core_conn_create_dest_spec_params param;
  86         int r;
  87
  88         /* proprietary destination specific paramerer without value */
  89         param.type = FDP_PATCH_CONN_PARAM_TYPE;
  90         param.length = 0x00;
  91
  92         r = nci_core_conn_create(info->ndev, FDP_PATCH_CONN_DEST, 1,
  93                                  sizeof(param), &param);
  94         if (r)
  95                 return r;
  96
  97         return nci_get_conn_info_by_dest_type_params(ndev,
  98                                                      FDP_PATCH_CONN_DEST, NULL);
  99 }
 100
 101 static inline int fdp_nci_get_versions(struct nci_dev *ndev)
 102 {
 103         return nci_core_cmd(ndev, NCI_OP_CORE_GET_CONFIG_CMD,
 104                             sizeof(nci_core_get_config_otp_ram_version),
 105                             (__u8 *) &nci_core_get_config_otp_ram_version);
 106 }
 107
 108 static inline int fdp_nci_patch_cmd(struct nci_dev *ndev, u8 type)
 109 {
 110         return nci_prop_cmd(ndev, NCI_OP_PROP_PATCH_OID, sizeof(type), &type);
 111 }
 112
 113 static inline int fdp_nci_set_production_data(struct nci_dev *ndev, u8 len,
 114                                               char *data)
 115 {
 116         return nci_prop_cmd(ndev, NCI_OP_PROP_SET_PDATA_OID, len, data);
 117 }
 118
 119 static int fdp_nci_set_clock(struct nci_dev *ndev, u8 clock_type,
 120                              u32 clock_freq)
 121 {
 122         u32 fc = 13560;
 123         u32 nd, num, delta;
 124         char data[9];
 125
 126         nd = (24 * fc) / clock_freq;
 127         delta = 24 * fc - nd * clock_freq;
 128         num = (32768 * delta) / clock_freq;
 129
 130         data[0] = 0x00;
 131         data[1] = 0x00;
 132         data[2] = 0x00;
 133
 134         data[3] = 0x10;
 135         data[4] = 0x04;
 136         data[5] = num & 0xFF;
 137         data[6] = (num >> 8) & 0xff;
 138         data[7] = nd;
 139         data[8] = clock_type;
 140
 141         return fdp_nci_set_production_data(ndev, 9, data);
 142 }
 143
 144 static void fdp_nci_send_patch_cb(struct nci_dev *ndev)
 145 {
 146         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 147
 148         info->setup_patch_sent = 1;
 149         wake_up(&info->setup_wq);
 150 }
 151
 152 /*
 153  * Register a packet sent counter and a callback
 154  *
 155  * We have no other way of knowing when all firmware packets were sent out
 156  * on the i2c bus. We need to know that in order to close the connection and
 157  * send the patch end message.
 158  */
 159 static void fdp_nci_set_data_pkt_counter(struct nci_dev *ndev,
 160                                   void (*cb)(struct nci_dev *ndev), int count)
 161 {
 162         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 163         struct device *dev = &info->phy->i2c_dev->dev;
 164
 165         dev_dbg(dev, "NCI data pkt counter %d\n", count);
 166         atomic_set(&info->data_pkt_counter, count);
 167         info->data_pkt_counter_cb = cb;
 168 }
 169
 170 /*
 171  * The device is expecting a stream of packets. All packets need to
 172  * have the PBF flag set to 0x0 (last packet) even if the firmware
 173  * file is segmented and there are multiple packets. If we give the
 174  * whole firmware to nci_send_data it will segment it and it will set
 175  * the PBF flag to 0x01 so we need to do the segmentation here.
 176  *
 177  * The firmware will be analyzed and applied when we send NCI_OP_PROP_PATCH_CMD
 178  * command with NCI_PATCH_TYPE_EOT parameter. The device will send a
 179  * NFCC_PATCH_NTF packet and a NCI_OP_CORE_RESET_NTF packet.
 180  */
 181 static int fdp_nci_send_patch(struct nci_dev *ndev, u8 conn_id, u8 type)
 182 {
 183         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 184         const struct firmware *fw;
 185         struct sk_buff *skb;
 186         unsigned long len;
 187         int max_size, payload_size;
 188         int rc = 0;
 189
 190         if ((type == NCI_PATCH_TYPE_OTP && !info->otp_patch) ||
 191             (type == NCI_PATCH_TYPE_RAM && !info->ram_patch))
 192                 return -EINVAL;
 193
 194         if (type == NCI_PATCH_TYPE_OTP)
 195                 fw = info->otp_patch;
 196         else
 197                 fw = info->ram_patch;
 198
 199         max_size = nci_conn_max_data_pkt_payload_size(ndev, conn_id);
 200         if (max_size <= 0)
 201                 return -EINVAL;
 202
 203         len = fw->size;
 204
 205         fdp_nci_set_data_pkt_counter(ndev, fdp_nci_send_patch_cb,
 206                                      DIV_ROUND_UP(fw->size, max_size));
 207
 208         while (len) {
 209
 210                 payload_size = min_t(unsigned long, max_size, len);
 211
 212                 skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + payload_size),
 213                                     GFP_KERNEL);
 214                 if (!skb) {
 215                         fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
 216                         return -ENOMEM;
 217                 }
 218
 219
 220                 skb_reserve(skb, NCI_CTRL_HDR_SIZE);
 221
 222                 skb_put_data(skb, fw->data + (fw->size - len), payload_size);
 223
 224                 rc = nci_send_data(ndev, conn_id, skb);
 225
 226                 if (rc) {
 227                         fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
 228                         return rc;
 229                 }
 230
 231                 len -= payload_size;
 232         }
 233
 234         return rc;
 235 }
 236
 237 static int fdp_nci_open(struct nci_dev *ndev)
 238 {
 239         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 240
 241         return info->phy_ops->enable(info->phy);
 242 }
 243
 244 static int fdp_nci_close(struct nci_dev *ndev)
 245 {
 246         return 0;
 247 }
 248
 249 static int fdp_nci_send(struct nci_dev *ndev, struct sk_buff *skb)
 250 {
 251         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 252
 253         if (atomic_dec_and_test(&info->data_pkt_counter))
 254                 info->data_pkt_counter_cb(ndev);
 255
 256         return info->phy_ops->write(info->phy, skb);
 257 }
 258
 259 static int fdp_nci_request_firmware(struct nci_dev *ndev)
 260 {
 261         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 262         struct device *dev = &info->phy->i2c_dev->dev;
 263         u8 *data;
 264         int r;
 265
 266         r = request_firmware(&info->ram_patch, FDP_RAM_PATCH_NAME, dev);
 267         if (r < 0) {
 268                 nfc_err(dev, "RAM patch request error\n");
 269                 return r;
 270         }
 271
 272         data = (u8 *) info->ram_patch->data;
 273         info->ram_patch_version =
 274                 data[FDP_FW_HEADER_SIZE] |
 275                 (data[FDP_FW_HEADER_SIZE + 1] << 8) |
 276                 (data[FDP_FW_HEADER_SIZE + 2] << 16) |
 277                 (data[FDP_FW_HEADER_SIZE + 3] << 24);
 278
 279         dev_dbg(dev, "RAM patch version: %d, size: %zu\n",
 280                   info->ram_patch_version, info->ram_patch->size);
 281
 282
 283         r = request_firmware(&info->otp_patch, FDP_OTP_PATCH_NAME, dev);
 284         if (r < 0) {
 285                 nfc_err(dev, "OTP patch request error\n");
 286                 return 0;
 287         }
 288
 289         data = (u8 *) info->otp_patch->data;
 290         info->otp_patch_version =
 291                 data[FDP_FW_HEADER_SIZE] |
 292                 (data[FDP_FW_HEADER_SIZE + 1] << 8) |
 293                 (data[FDP_FW_HEADER_SIZE+2] << 16) |
 294                 (data[FDP_FW_HEADER_SIZE+3] << 24);
 295
 296         dev_dbg(dev, "OTP patch version: %d, size: %zu\n",
 297                  info->otp_patch_version, info->otp_patch->size);
 298         return 0;
 299 }
 300
 301 static void fdp_nci_release_firmware(struct nci_dev *ndev)
 302 {
 303         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 304
 305         if (info->otp_patch) {
 306                 release_firmware(info->otp_patch);
 307                 info->otp_patch = NULL;
 308         }
 309
 310         if (info->ram_patch) {
 311                 release_firmware(info->ram_patch);
 312                 info->ram_patch = NULL;
 313         }
 314 }
 315
 316 static int fdp_nci_patch_otp(struct nci_dev *ndev)
 317 {
 318         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 319         struct device *dev = &info->phy->i2c_dev->dev;
 320         int conn_id;
 321         int r = 0;
 322
 323         if (info->otp_version >= info->otp_patch_version)
 324                 return r;
 325
 326         info->setup_patch_sent = 0;
 327         info->setup_reset_ntf = 0;
 328         info->setup_patch_ntf = 0;
 329
 330         /* Patch init request */
 331         r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_OTP);
 332         if (r)
 333                 return r;
 334
 335         /* Patch data connection creation */
 336         conn_id = fdp_nci_create_conn(ndev);
 337         if (conn_id < 0)
 338                 return conn_id;
 339
 340         /* Send the patch over the data connection */
 341         r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_OTP);
 342         if (r)
 343                 return r;
 344
 345         /* Wait for all the packets to be send over i2c */
 346         wait_event_interruptible(info->setup_wq,
 347                                  info->setup_patch_sent == 1);
 348
 349         /* make sure that the NFCC processed the last data packet */
 350         msleep(FDP_FW_UPDATE_SLEEP);
 351
 352         /* Close the data connection */
 353         r = nci_core_conn_close(info->ndev, conn_id);
 354         if (r)
 355                 return r;
 356
 357         /* Patch finish message */
 358         if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
 359                 nfc_err(dev, "OTP patch error 0x%x\n", r);
 360                 return -EINVAL;
 361         }
 362
 363         /* If the patch notification didn't arrive yet, wait for it */
 364         wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
 365
 366         /* Check if the patching was successful */
 367         r = info->setup_patch_status;
 368         if (r) {
 369                 nfc_err(dev, "OTP patch error 0x%x\n", r);
 370                 return -EINVAL;
 371         }
 372
 373         /*
 374          * We need to wait for the reset notification before we
 375          * can continue
 376          */
 377         wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
 378
 379         return r;
 380 }
 381
 382 static int fdp_nci_patch_ram(struct nci_dev *ndev)
 383 {
 384         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 385         struct device *dev = &info->phy->i2c_dev->dev;
 386         int conn_id;
 387         int r = 0;
 388
 389         if (info->ram_version >= info->ram_patch_version)
 390                 return r;
 391
 392         info->setup_patch_sent = 0;
 393         info->setup_reset_ntf = 0;
 394         info->setup_patch_ntf = 0;
 395
 396         /* Patch init request */
 397         r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_RAM);
 398         if (r)
 399                 return r;
 400
 401         /* Patch data connection creation */
 402         conn_id = fdp_nci_create_conn(ndev);
 403         if (conn_id < 0)
 404                 return conn_id;
 405
 406         /* Send the patch over the data connection */
 407         r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_RAM);
 408         if (r)
 409                 return r;
 410
 411         /* Wait for all the packets to be send over i2c */
 412         wait_event_interruptible(info->setup_wq,
 413                                  info->setup_patch_sent == 1);
 414
 415         /* make sure that the NFCC processed the last data packet */
 416         msleep(FDP_FW_UPDATE_SLEEP);
 417
 418         /* Close the data connection */
 419         r = nci_core_conn_close(info->ndev, conn_id);
 420         if (r)
 421                 return r;
 422
 423         /* Patch finish message */
 424         if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
 425                 nfc_err(dev, "RAM patch error 0x%x\n", r);
 426                 return -EINVAL;
 427         }
 428
 429         /* If the patch notification didn't arrive yet, wait for it */
 430         wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
 431
 432         /* Check if the patching was successful */
 433         r = info->setup_patch_status;
 434         if (r) {
 435                 nfc_err(dev, "RAM patch error 0x%x\n", r);
 436                 return -EINVAL;
 437         }
 438
 439         /*
 440          * We need to wait for the reset notification before we
 441          * can continue
 442          */
 443         wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
 444
 445         return r;
 446 }
 447
 448 static int fdp_nci_setup(struct nci_dev *ndev)
 449 {
 450         /* Format: total length followed by an NCI packet */
 451         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 452         struct device *dev = &info->phy->i2c_dev->dev;
 453         int r;
 454         u8 patched = 0;
 455
 456         r = nci_core_init(ndev);
 457         if (r)
 458                 goto error;
 459
 460         /* Get RAM and OTP version */
 461         r = fdp_nci_get_versions(ndev);
 462         if (r)
 463                 goto error;
 464
 465         /* Load firmware from disk */
 466         r = fdp_nci_request_firmware(ndev);
 467         if (r)
 468                 goto error;
 469
 470         /* Update OTP */
 471         if (info->otp_version < info->otp_patch_version) {
 472                 r = fdp_nci_patch_otp(ndev);
 473                 if (r)
 474                         goto error;
 475                 patched = 1;
 476         }
 477
 478         /* Update RAM */
 479         if (info->ram_version < info->ram_patch_version) {
 480                 r = fdp_nci_patch_ram(ndev);
 481                 if (r)
 482                         goto error;
 483                 patched = 1;
 484         }
 485
 486         /* Release the firmware buffers */
 487         fdp_nci_release_firmware(ndev);
 488
 489         /* If a patch was applied the new version is checked */
 490         if (patched) {
 491                 r = nci_core_init(ndev);
 492                 if (r)
 493                         goto error;
 494
 495                 r = fdp_nci_get_versions(ndev);
 496                 if (r)
 497                         goto error;
 498
 499                 if (info->otp_version != info->otp_patch_version ||
 500                     info->ram_version != info->ram_patch_version) {
 501                         nfc_err(dev, "Firmware update failed");
 502                         r = -EINVAL;
 503                         goto error;
 504                 }
 505         }
 506
 507         /*
 508          * We initialized the devices but the NFC subsystem expects
 509          * it to not be initialized.
 510          */
 511         return nci_core_reset(ndev);
 512
 513 error:
 514         fdp_nci_release_firmware(ndev);
 515         nfc_err(dev, "Setup error %d\n", r);
 516         return r;
 517 }
 518
 519 static int fdp_nci_post_setup(struct nci_dev *ndev)
 520 {
 521         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 522         struct device *dev = &info->phy->i2c_dev->dev;
 523         int r;
 524
 525         /* Check if the device has VSC */
 526         if (info->fw_vsc_cfg && info->fw_vsc_cfg[0]) {
 527
 528                 /* Set the vendor specific configuration */
 529                 r = fdp_nci_set_production_data(ndev, info->fw_vsc_cfg[3],
 530                                                 &info->fw_vsc_cfg[4]);
 531                 if (r) {
 532                         nfc_err(dev, "Vendor specific config set error %d\n",
 533                                 r);
 534                         return r;
 535                 }
 536         }
 537
 538         /* Set clock type and frequency */
 539         r = fdp_nci_set_clock(ndev, info->clock_type, info->clock_freq);
 540         if (r) {
 541                 nfc_err(dev, "Clock set error %d\n", r);
 542                 return r;
 543         }
 544
 545         /*
 546          * In order to apply the VSC FDP needs a reset
 547          */
 548         r = nci_core_reset(ndev);
 549         if (r)
 550                 return r;
 551
 552         /**
 553          * The nci core was initialized when post setup was called
 554          * so we leave it like that
 555          */
 556         return nci_core_init(ndev);
 557 }
 558
 559 static int fdp_nci_core_reset_ntf_packet(struct nci_dev *ndev,
 560                                           struct sk_buff *skb)
 561 {
 562         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 563
 564         info->setup_reset_ntf = 1;
 565         wake_up(&info->setup_wq);
 566
 567         return 0;
 568 }
 569
 570 static int fdp_nci_prop_patch_ntf_packet(struct nci_dev *ndev,
 571                                           struct sk_buff *skb)
 572 {
 573         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 574
 575         info->setup_patch_ntf = 1;
 576         info->setup_patch_status = skb->data[0];
 577         wake_up(&info->setup_wq);
 578
 579         return 0;
 580 }
 581
 582 static int fdp_nci_prop_patch_rsp_packet(struct nci_dev *ndev,
 583                                           struct sk_buff *skb)
 584 {
 585         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 586         struct device *dev = &info->phy->i2c_dev->dev;
 587         u8 status = skb->data[0];
 588
 589         dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
 590         nci_req_complete(ndev, status);
 591
 592         return 0;
 593 }
 594
 595 static int fdp_nci_prop_set_production_data_rsp_packet(struct nci_dev *ndev,
 596                                                         struct sk_buff *skb)
 597 {
 598         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 599         struct device *dev = &info->phy->i2c_dev->dev;
 600         u8 status = skb->data[0];
 601
 602         dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
 603         nci_req_complete(ndev, status);
 604
 605         return 0;
 606 }
 607
 608 static int fdp_nci_core_get_config_rsp_packet(struct nci_dev *ndev,
 609                                                 struct sk_buff *skb)
 610 {
 611         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 612         struct device *dev = &info->phy->i2c_dev->dev;
 613         struct nci_core_get_config_rsp *rsp = (void *) skb->data;
 614         u8 i, *p;
 615
 616         if (rsp->status == NCI_STATUS_OK) {
 617
 618                 p = rsp->data;
 619                 for (i = 0; i < 4; i++) {
 620
 621                         switch (*p++) {
 622                         case NCI_PARAM_ID_FW_RAM_VERSION:
 623                                 p++;
 624                                 info->ram_version = le32_to_cpup((__le32 *) p);
 625                                 p += 4;
 626                                 break;
 627                         case NCI_PARAM_ID_FW_OTP_VERSION:
 628                                 p++;
 629                                 info->otp_version = le32_to_cpup((__le32 *) p);
 630                                 p += 4;
 631                                 break;
 632                         case NCI_PARAM_ID_OTP_LIMITED_VERSION:
 633                                 p++;
 634                                 info->otp_version = le32_to_cpup((__le32 *) p);
 635                                 p += 4;
 636                                 break;
 637                         case NCI_PARAM_ID_KEY_INDEX_ID:
 638                                 p++;
 639                                 info->key_index = *p++;
 640                         }
 641                 }
 642         }
 643
 644         dev_dbg(dev, "OTP version %d\n", info->otp_version);
 645         dev_dbg(dev, "RAM version %d\n", info->ram_version);
 646         dev_dbg(dev, "key index %d\n", info->key_index);
 647         dev_dbg(dev, "%s: status 0x%x\n", __func__, rsp->status);
 648
 649         nci_req_complete(ndev, rsp->status);
 650
 651         return 0;
 652 }
 653
 654 static const struct nci_driver_ops fdp_core_ops[] = {
 655         {
 656                 .opcode = NCI_OP_CORE_GET_CONFIG_RSP,
 657                 .rsp = fdp_nci_core_get_config_rsp_packet,
 658         },
 659         {
 660                 .opcode = NCI_OP_CORE_RESET_NTF,
 661                 .ntf = fdp_nci_core_reset_ntf_packet,
 662         },
 663 };
 664
 665 static const struct nci_driver_ops fdp_prop_ops[] = {
 666         {
 667                 .opcode = nci_opcode_pack(NCI_GID_PROP, NCI_OP_PROP_PATCH_OID),
 668                 .rsp = fdp_nci_prop_patch_rsp_packet,
 669                 .ntf = fdp_nci_prop_patch_ntf_packet,
 670         },
 671         {
 672                 .opcode = nci_opcode_pack(NCI_GID_PROP,
 673                                           NCI_OP_PROP_SET_PDATA_OID),
 674                 .rsp = fdp_nci_prop_set_production_data_rsp_packet,
 675         },
 676 };
 677
 678 static const struct nci_ops nci_ops = {
 679         .open = fdp_nci_open,
 680         .close = fdp_nci_close,
 681         .send = fdp_nci_send,
 682         .setup = fdp_nci_setup,
 683         .post_setup = fdp_nci_post_setup,
 684         .prop_ops = fdp_prop_ops,
 685         .n_prop_ops = ARRAY_SIZE(fdp_prop_ops),
 686         .core_ops = fdp_core_ops,
 687         .n_core_ops = ARRAY_SIZE(fdp_core_ops),
 688 };
 689
 690 int fdp_nci_probe(struct fdp_i2c_phy *phy, const struct nfc_phy_ops *phy_ops,
 691                         struct nci_dev **ndevp, int tx_headroom,
 692                         int tx_tailroom, u8 clock_type, u32 clock_freq,
 693                         u8 *fw_vsc_cfg)
 694 {
 695         struct device *dev = &phy->i2c_dev->dev;
 696         struct fdp_nci_info *info;
 697         struct nci_dev *ndev;
 698         u32 protocols;
 699         int r;
 700
 701         info = devm_kzalloc(dev, sizeof(struct fdp_nci_info), GFP_KERNEL);
 702         if (!info)
 703                 return -ENOMEM;
 704
 705         info->phy = phy;
 706         info->phy_ops = phy_ops;
 707         info->clock_type = clock_type;
 708         info->clock_freq = clock_freq;
 709         info->fw_vsc_cfg = fw_vsc_cfg;
 710
 711         init_waitqueue_head(&info->setup_wq);
 712
 713         protocols = NFC_PROTO_JEWEL_MASK |
 714                     NFC_PROTO_MIFARE_MASK |
 715                     NFC_PROTO_FELICA_MASK |
 716                     NFC_PROTO_ISO14443_MASK |
 717                     NFC_PROTO_ISO14443_B_MASK |
 718                     NFC_PROTO_NFC_DEP_MASK |
 719                     NFC_PROTO_ISO15693_MASK;
 720
 721         BUILD_BUG_ON(ARRAY_SIZE(fdp_prop_ops) > NCI_MAX_PROPRIETARY_CMD);
 722         ndev = nci_allocate_device(&nci_ops, protocols, tx_headroom,
 723                                    tx_tailroom);
 724         if (!ndev) {
 725                 nfc_err(dev, "Cannot allocate nfc ndev\n");
 726                 return -ENOMEM;
 727         }
 728
 729         r = nci_register_device(ndev);
 730         if (r)
 731                 goto err_regdev;
 732
 733         *ndevp = ndev;
 734         info->ndev = ndev;
 735
 736         nci_set_drvdata(ndev, info);
 737
 738         return 0;
 739
 740 err_regdev:
 741         nci_free_device(ndev);
 742         return r;
 743 }
 744 EXPORT_SYMBOL(fdp_nci_probe);
 745
 746 void fdp_nci_remove(struct nci_dev *ndev)
 747 {
 748         nci_unregister_device(ndev);
 749         nci_free_device(ndev);
 750 }
 751 EXPORT_SYMBOL(fdp_nci_remove);
 752
 753 MODULE_LICENSE("GPL");
 754 MODULE_DESCRIPTION("NFC NCI driver for Intel Fields Peak NFC controller");
 755 MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");