linux/drivers/nfc/fdp/fdp.c
<<
>>
Prefs
   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
  40struct 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
  68static 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
  76struct nci_core_get_config_rsp {
  77        u8 status;
  78        u8 count;
  79        u8 data[];
  80};
  81
  82static 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
 101static 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
 108static 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
 113static 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
 119static 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
 144static 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 */
 159static 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 */
 181static 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
 237static 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
 247static 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
 256static 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
 269int 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}
 277EXPORT_SYMBOL(fdp_nci_recv_frame);
 278
 279static 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);
 318out:
 319        return 0;
 320error:
 321        return r;
 322}
 323
 324static 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
 339static 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
 405static 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
 471static 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
 538error:
 539        fdp_nci_release_firmware(ndev);
 540        nfc_err(dev, "Setup error %d\n", r);
 541        return r;
 542}
 543
 544static 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
 584static 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
 597static 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
 611static 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
 624static 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
 637static 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
 683static 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
 694static 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
 707static 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
 719int 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
 768err_regdev:
 769        nci_free_device(ndev);
 770        return r;
 771}
 772EXPORT_SYMBOL(fdp_nci_probe);
 773
 774void 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}
 784EXPORT_SYMBOL(fdp_nci_remove);
 785
 786MODULE_LICENSE("GPL");
 787MODULE_DESCRIPTION("NFC NCI driver for Intel Fields Peak NFC controller");
 788MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");
 789