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