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
 241        return info->phy_ops->enable(info->phy);
 242}
 243
 244static int fdp_nci_close(struct nci_dev *ndev)
 245{
 246        return 0;
 247}
 248
 249static 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
 259static 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: %d\n",
 280                  info->ram_patch_version, (int) 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: %d\n",
 297                 info->otp_patch_version, (int) info->otp_patch->size);
 298        return 0;
 299}
 300
 301static 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
 316static 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
 382static 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
 448static 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
 513error:
 514        fdp_nci_release_firmware(ndev);
 515        nfc_err(dev, "Setup error %d\n", r);
 516        return r;
 517}
 518
 519static 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
 559static 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
 570static 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
 582static 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
 595static 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
 608static 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
 654static 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
 665static 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
 678static 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
 690int fdp_nci_probe(struct fdp_i2c_phy *phy, 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        ndev = nci_allocate_device(&nci_ops, protocols, tx_headroom,
 722                                   tx_tailroom);
 723        if (!ndev) {
 724                nfc_err(dev, "Cannot allocate nfc ndev\n");
 725                return -ENOMEM;
 726        }
 727
 728        r = nci_register_device(ndev);
 729        if (r)
 730                goto err_regdev;
 731
 732        *ndevp = ndev;
 733        info->ndev = ndev;
 734
 735        nci_set_drvdata(ndev, info);
 736
 737        return 0;
 738
 739err_regdev:
 740        nci_free_device(ndev);
 741        return r;
 742}
 743EXPORT_SYMBOL(fdp_nci_probe);
 744
 745void fdp_nci_remove(struct nci_dev *ndev)
 746{
 747        nci_unregister_device(ndev);
 748        nci_free_device(ndev);
 749}
 750EXPORT_SYMBOL(fdp_nci_remove);
 751
 752MODULE_LICENSE("GPL");
 753MODULE_DESCRIPTION("NFC NCI driver for Intel Fields Peak NFC controller");
 754MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");
 755