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         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         struct device *dev = &info->phy->i2c_dev->dev;
 241
 242         dev_dbg(dev, "%s\n", __func__);
 243
 244         return info->phy_ops->enable(info->phy);
 245 }
 246
 247 static int fdp_nci_close(struct nci_dev *ndev)
 248 {
 249         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 250         struct device *dev = &info->phy->i2c_dev->dev;
 251
 252         dev_dbg(dev, "%s\n", __func__);
 253         return 0;
 254 }
 255
 256 static int fdp_nci_send(struct nci_dev *ndev, struct sk_buff *skb)
 257 {
 258         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 259         struct device *dev = &info->phy->i2c_dev->dev;
 260
 261         dev_dbg(dev, "%s\n", __func__);
 262
 263         if (atomic_dec_and_test(&info->data_pkt_counter))
 264                 info->data_pkt_counter_cb(ndev);
 265
 266         return info->phy_ops->write(info->phy, skb);
 267 }
 268
 269 int fdp_nci_recv_frame(struct nci_dev *ndev, struct sk_buff *skb)
 270 {
 271         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 272         struct device *dev = &info->phy->i2c_dev->dev;
 273
 274         dev_dbg(dev, "%s\n", __func__);
 275         return nci_recv_frame(ndev, skb);
 276 }
 277 EXPORT_SYMBOL(fdp_nci_recv_frame);
 278
 279 static int fdp_nci_request_firmware(struct nci_dev *ndev)
 280 {
 281         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 282         struct device *dev = &info->phy->i2c_dev->dev;
 283         u8 *data;
 284         int r;
 285
 286         r = request_firmware(&info->ram_patch, FDP_RAM_PATCH_NAME, dev);
 287         if (r < 0) {
 288                 nfc_err(dev, "RAM patch request error\n");
 289                 goto error;
 290         }
 291
 292         data = (u8 *) info->ram_patch->data;
 293         info->ram_patch_version =
 294                 data[FDP_FW_HEADER_SIZE] |
 295                 (data[FDP_FW_HEADER_SIZE + 1] << 8) |
 296                 (data[FDP_FW_HEADER_SIZE + 2] << 16) |
 297                 (data[FDP_FW_HEADER_SIZE + 3] << 24);
 298
 299         dev_dbg(dev, "RAM patch version: %d, size: %d\n",
 300                   info->ram_patch_version, (int) info->ram_patch->size);
 301
 302
 303         r = request_firmware(&info->otp_patch, FDP_OTP_PATCH_NAME, dev);
 304         if (r < 0) {
 305                 nfc_err(dev, "OTP patch request error\n");
 306                 goto out;
 307         }
 308
 309         data = (u8 *) info->otp_patch->data;
 310         info->otp_patch_version =
 311                 data[FDP_FW_HEADER_SIZE] |
 312                 (data[FDP_FW_HEADER_SIZE + 1] << 8) |
 313                 (data[FDP_FW_HEADER_SIZE+2] << 16) |
 314                 (data[FDP_FW_HEADER_SIZE+3] << 24);
 315
 316         dev_dbg(dev, "OTP patch version: %d, size: %d\n",
 317                  info->otp_patch_version, (int) info->otp_patch->size);
 318 out:
 319         return 0;
 320 error:
 321         return r;
 322 }
 323
 324 static void fdp_nci_release_firmware(struct nci_dev *ndev)
 325 {
 326         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 327
 328         if (info->otp_patch) {
 329                 release_firmware(info->otp_patch);
 330                 info->otp_patch = NULL;
 331         }
 332
 333         if (info->ram_patch) {
 334                 release_firmware(info->ram_patch);
 335                 info->ram_patch = NULL;
 336         }
 337 }
 338
 339 static int fdp_nci_patch_otp(struct nci_dev *ndev)
 340 {
 341         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 342         struct device *dev = &info->phy->i2c_dev->dev;
 343         int conn_id;
 344         int r = 0;
 345
 346         if (info->otp_version >= info->otp_patch_version)
 347                 return r;
 348
 349         info->setup_patch_sent = 0;
 350         info->setup_reset_ntf = 0;
 351         info->setup_patch_ntf = 0;
 352
 353         /* Patch init request */
 354         r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_OTP);
 355         if (r)
 356                 return r;
 357
 358         /* Patch data connection creation */
 359         conn_id = fdp_nci_create_conn(ndev);
 360         if (conn_id < 0)
 361                 return conn_id;
 362
 363         /* Send the patch over the data connection */
 364         r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_OTP);
 365         if (r)
 366                 return r;
 367
 368         /* Wait for all the packets to be send over i2c */
 369         wait_event_interruptible(info->setup_wq,
 370                                  info->setup_patch_sent == 1);
 371
 372         /* make sure that the NFCC processed the last data packet */
 373         msleep(FDP_FW_UPDATE_SLEEP);
 374
 375         /* Close the data connection */
 376         r = nci_core_conn_close(info->ndev, conn_id);
 377         if (r)
 378                 return r;
 379
 380         /* Patch finish message */
 381         if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
 382                 nfc_err(dev, "OTP patch error 0x%x\n", r);
 383                 return -EINVAL;
 384         }
 385
 386         /* If the patch notification didn't arrive yet, wait for it */
 387         wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
 388
 389         /* Check if the patching was successful */
 390         r = info->setup_patch_status;
 391         if (r) {
 392                 nfc_err(dev, "OTP patch error 0x%x\n", r);
 393                 return -EINVAL;
 394         }
 395
 396         /*
 397          * We need to wait for the reset notification before we
 398          * can continue
 399          */
 400         wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
 401
 402         return r;
 403 }
 404
 405 static int fdp_nci_patch_ram(struct nci_dev *ndev)
 406 {
 407         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 408         struct device *dev = &info->phy->i2c_dev->dev;
 409         int conn_id;
 410         int r = 0;
 411
 412         if (info->ram_version >= info->ram_patch_version)
 413                 return r;
 414
 415         info->setup_patch_sent = 0;
 416         info->setup_reset_ntf = 0;
 417         info->setup_patch_ntf = 0;
 418
 419         /* Patch init request */
 420         r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_RAM);
 421         if (r)
 422                 return r;
 423
 424         /* Patch data connection creation */
 425         conn_id = fdp_nci_create_conn(ndev);
 426         if (conn_id < 0)
 427                 return conn_id;
 428
 429         /* Send the patch over the data connection */
 430         r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_RAM);
 431         if (r)
 432                 return r;
 433
 434         /* Wait for all the packets to be send over i2c */
 435         wait_event_interruptible(info->setup_wq,
 436                                  info->setup_patch_sent == 1);
 437
 438         /* make sure that the NFCC processed the last data packet */
 439         msleep(FDP_FW_UPDATE_SLEEP);
 440
 441         /* Close the data connection */
 442         r = nci_core_conn_close(info->ndev, conn_id);
 443         if (r)
 444                 return r;
 445
 446         /* Patch finish message */
 447         if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
 448                 nfc_err(dev, "RAM patch error 0x%x\n", r);
 449                 return -EINVAL;
 450         }
 451
 452         /* If the patch notification didn't arrive yet, wait for it */
 453         wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
 454
 455         /* Check if the patching was successful */
 456         r = info->setup_patch_status;
 457         if (r) {
 458                 nfc_err(dev, "RAM patch error 0x%x\n", r);
 459                 return -EINVAL;
 460         }
 461
 462         /*
 463          * We need to wait for the reset notification before we
 464          * can continue
 465          */
 466         wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
 467
 468         return r;
 469 }
 470
 471 static int fdp_nci_setup(struct nci_dev *ndev)
 472 {
 473         /* Format: total length followed by an NCI packet */
 474         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 475         struct device *dev = &info->phy->i2c_dev->dev;
 476         int r;
 477         u8 patched = 0;
 478
 479         dev_dbg(dev, "%s\n", __func__);
 480
 481         r = nci_core_init(ndev);
 482         if (r)
 483                 goto error;
 484
 485         /* Get RAM and OTP version */
 486         r = fdp_nci_get_versions(ndev);
 487         if (r)
 488                 goto error;
 489
 490         /* Load firmware from disk */
 491         r = fdp_nci_request_firmware(ndev);
 492         if (r)
 493                 goto error;
 494
 495         /* Update OTP */
 496         if (info->otp_version < info->otp_patch_version) {
 497                 r = fdp_nci_patch_otp(ndev);
 498                 if (r)
 499                         goto error;
 500                 patched = 1;
 501         }
 502
 503         /* Update RAM */
 504         if (info->ram_version < info->ram_patch_version) {
 505                 r = fdp_nci_patch_ram(ndev);
 506                 if (r)
 507                         goto error;
 508                 patched = 1;
 509         }
 510
 511         /* Release the firmware buffers */
 512         fdp_nci_release_firmware(ndev);
 513
 514         /* If a patch was applied the new version is checked */
 515         if (patched) {
 516                 r = nci_core_init(ndev);
 517                 if (r)
 518                         goto error;
 519
 520                 r = fdp_nci_get_versions(ndev);
 521                 if (r)
 522                         goto error;
 523
 524                 if (info->otp_version != info->otp_patch_version ||
 525                     info->ram_version != info->ram_patch_version) {
 526                         nfc_err(dev, "Firmware update failed");
 527                         r = -EINVAL;
 528                         goto error;
 529                 }
 530         }
 531
 532         /*
 533          * We initialized the devices but the NFC subsystem expects
 534          * it to not be initialized.
 535          */
 536         return nci_core_reset(ndev);
 537
 538 error:
 539         fdp_nci_release_firmware(ndev);
 540         nfc_err(dev, "Setup error %d\n", r);
 541         return r;
 542 }
 543
 544 static int fdp_nci_post_setup(struct nci_dev *ndev)
 545 {
 546         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 547         struct device *dev = &info->phy->i2c_dev->dev;
 548         int r;
 549
 550         /* Check if the device has VSC */
 551         if (info->fw_vsc_cfg && info->fw_vsc_cfg[0]) {
 552
 553                 /* Set the vendor specific configuration */
 554                 r = fdp_nci_set_production_data(ndev, info->fw_vsc_cfg[3],
 555                                                 &info->fw_vsc_cfg[4]);
 556                 if (r) {
 557                         nfc_err(dev, "Vendor specific config set error %d\n",
 558                                 r);
 559                         return r;
 560                 }
 561         }
 562
 563         /* Set clock type and frequency */
 564         r = fdp_nci_set_clock(ndev, info->clock_type, info->clock_freq);
 565         if (r) {
 566                 nfc_err(dev, "Clock set error %d\n", r);
 567                 return r;
 568         }
 569
 570         /*
 571          * In order to apply the VSC FDP needs a reset
 572          */
 573         r = nci_core_reset(ndev);
 574         if (r)
 575                 return r;
 576
 577         /**
 578          * The nci core was initialized when post setup was called
 579          * so we leave it like that
 580          */
 581         return nci_core_init(ndev);
 582 }
 583
 584 static int fdp_nci_core_reset_ntf_packet(struct nci_dev *ndev,
 585                                           struct sk_buff *skb)
 586 {
 587         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 588         struct device *dev = &info->phy->i2c_dev->dev;
 589
 590         dev_dbg(dev, "%s\n", __func__);
 591         info->setup_reset_ntf = 1;
 592         wake_up(&info->setup_wq);
 593
 594         return 0;
 595 }
 596
 597 static int fdp_nci_prop_patch_ntf_packet(struct nci_dev *ndev,
 598                                           struct sk_buff *skb)
 599 {
 600         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 601         struct device *dev = &info->phy->i2c_dev->dev;
 602
 603         dev_dbg(dev, "%s\n", __func__);
 604         info->setup_patch_ntf = 1;
 605         info->setup_patch_status = skb->data[0];
 606         wake_up(&info->setup_wq);
 607
 608         return 0;
 609 }
 610
 611 static int fdp_nci_prop_patch_rsp_packet(struct nci_dev *ndev,
 612                                           struct sk_buff *skb)
 613 {
 614         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 615         struct device *dev = &info->phy->i2c_dev->dev;
 616         u8 status = skb->data[0];
 617
 618         dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
 619         nci_req_complete(ndev, status);
 620
 621         return 0;
 622 }
 623
 624 static int fdp_nci_prop_set_production_data_rsp_packet(struct nci_dev *ndev,
 625                                                         struct sk_buff *skb)
 626 {
 627         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 628         struct device *dev = &info->phy->i2c_dev->dev;
 629         u8 status = skb->data[0];
 630
 631         dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
 632         nci_req_complete(ndev, status);
 633
 634         return 0;
 635 }
 636
 637 static int fdp_nci_core_get_config_rsp_packet(struct nci_dev *ndev,
 638                                                 struct sk_buff *skb)
 639 {
 640         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 641         struct device *dev = &info->phy->i2c_dev->dev;
 642         struct nci_core_get_config_rsp *rsp = (void *) skb->data;
 643         u8 i, *p;
 644
 645         if (rsp->status == NCI_STATUS_OK) {
 646
 647                 p = rsp->data;
 648                 for (i = 0; i < 4; i++) {
 649
 650                         switch (*p++) {
 651                         case NCI_PARAM_ID_FW_RAM_VERSION:
 652                                 p++;
 653                                 info->ram_version = le32_to_cpup((__le32 *) p);
 654                                 p += 4;
 655                                 break;
 656                         case NCI_PARAM_ID_FW_OTP_VERSION:
 657                                 p++;
 658                                 info->otp_version = le32_to_cpup((__le32 *) p);
 659                                 p += 4;
 660                                 break;
 661                         case NCI_PARAM_ID_OTP_LIMITED_VERSION:
 662                                 p++;
 663                                 info->otp_version = le32_to_cpup((__le32 *) p);
 664                                 p += 4;
 665                                 break;
 666                         case NCI_PARAM_ID_KEY_INDEX_ID:
 667                                 p++;
 668                                 info->key_index = *p++;
 669                         }
 670                 }
 671         }
 672
 673         dev_dbg(dev, "OTP version %d\n", info->otp_version);
 674         dev_dbg(dev, "RAM version %d\n", info->ram_version);
 675         dev_dbg(dev, "key index %d\n", info->key_index);
 676         dev_dbg(dev, "%s: status 0x%x\n", __func__, rsp->status);
 677
 678         nci_req_complete(ndev, rsp->status);
 679
 680         return 0;
 681 }
 682
 683 static struct nci_driver_ops fdp_core_ops[] = {
 684         {
 685                 .opcode = NCI_OP_CORE_GET_CONFIG_RSP,
 686                 .rsp = fdp_nci_core_get_config_rsp_packet,
 687         },
 688         {
 689                 .opcode = NCI_OP_CORE_RESET_NTF,
 690                 .ntf = fdp_nci_core_reset_ntf_packet,
 691         },
 692 };
 693
 694 static struct nci_driver_ops fdp_prop_ops[] = {
 695         {
 696                 .opcode = nci_opcode_pack(NCI_GID_PROP, NCI_OP_PROP_PATCH_OID),
 697                 .rsp = fdp_nci_prop_patch_rsp_packet,
 698                 .ntf = fdp_nci_prop_patch_ntf_packet,
 699         },
 700         {
 701                 .opcode = nci_opcode_pack(NCI_GID_PROP,
 702                                           NCI_OP_PROP_SET_PDATA_OID),
 703                 .rsp = fdp_nci_prop_set_production_data_rsp_packet,
 704         },
 705 };
 706
 707 static struct nci_ops nci_ops = {
 708         .open = fdp_nci_open,
 709         .close = fdp_nci_close,
 710         .send = fdp_nci_send,
 711         .setup = fdp_nci_setup,
 712         .post_setup = fdp_nci_post_setup,
 713         .prop_ops = fdp_prop_ops,
 714         .n_prop_ops = ARRAY_SIZE(fdp_prop_ops),
 715         .core_ops = fdp_core_ops,
 716         .n_core_ops = ARRAY_SIZE(fdp_core_ops),
 717 };
 718
 719 int fdp_nci_probe(struct fdp_i2c_phy *phy, struct nfc_phy_ops *phy_ops,
 720                         struct nci_dev **ndevp, int tx_headroom,
 721                         int tx_tailroom, u8 clock_type, u32 clock_freq,
 722                         u8 *fw_vsc_cfg)
 723 {
 724         struct device *dev = &phy->i2c_dev->dev;
 725         struct fdp_nci_info *info;
 726         struct nci_dev *ndev;
 727         u32 protocols;
 728         int r;
 729
 730         info = devm_kzalloc(dev, sizeof(struct fdp_nci_info), GFP_KERNEL);
 731         if (!info)
 732                 return -ENOMEM;
 733
 734         info->phy = phy;
 735         info->phy_ops = phy_ops;
 736         info->clock_type = clock_type;
 737         info->clock_freq = clock_freq;
 738         info->fw_vsc_cfg = fw_vsc_cfg;
 739
 740         init_waitqueue_head(&info->setup_wq);
 741
 742         protocols = NFC_PROTO_JEWEL_MASK |
 743                     NFC_PROTO_MIFARE_MASK |
 744                     NFC_PROTO_FELICA_MASK |
 745                     NFC_PROTO_ISO14443_MASK |
 746                     NFC_PROTO_ISO14443_B_MASK |
 747                     NFC_PROTO_NFC_DEP_MASK |
 748                     NFC_PROTO_ISO15693_MASK;
 749
 750         ndev = nci_allocate_device(&nci_ops, protocols, tx_headroom,
 751                                    tx_tailroom);
 752         if (!ndev) {
 753                 nfc_err(dev, "Cannot allocate nfc ndev\n");
 754                 return -ENOMEM;
 755         }
 756
 757         r = nci_register_device(ndev);
 758         if (r)
 759                 goto err_regdev;
 760
 761         *ndevp = ndev;
 762         info->ndev = ndev;
 763
 764         nci_set_drvdata(ndev, info);
 765
 766         return 0;
 767
 768 err_regdev:
 769         nci_free_device(ndev);
 770         return r;
 771 }
 772 EXPORT_SYMBOL(fdp_nci_probe);
 773
 774 void fdp_nci_remove(struct nci_dev *ndev)
 775 {
 776         struct fdp_nci_info *info = nci_get_drvdata(ndev);
 777         struct device *dev = &info->phy->i2c_dev->dev;
 778
 779         dev_dbg(dev, "%s\n", __func__);
 780
 781         nci_unregister_device(ndev);
 782         nci_free_device(ndev);
 783 }
 784 EXPORT_SYMBOL(fdp_nci_remove);
 785
 786 MODULE_LICENSE("GPL");
 787 MODULE_DESCRIPTION("NFC NCI driver for Intel Fields Peak NFC controller");
 788 MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");