1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* -------------------------------------------------------------------------
3 * Copyright (C) 2014-2016, Intel Corporation
5 * -------------------------------------------------------------------------
8 #include <linux/module.h>
10 #include <linux/i2c.h>
11 #include <linux/delay.h>
12 #include <linux/firmware.h>
13 #include <net/nfc/nci_core.h>
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
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
27 #define NCI_PATCH_TYPE_RAM 0x00
28 #define NCI_PATCH_TYPE_OTP 0x01
29 #define NCI_PATCH_TYPE_EOT 0xFF
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
36 #define NCI_GID_PROP 0x0F
37 #define NCI_OP_PROP_PATCH_OID 0x08
38 #define NCI_OP_PROP_SET_PDATA_OID 0x23
41 struct nfc_phy_ops *phy_ops;
42 struct fdp_i2c_phy *phy;
45 const struct firmware *otp_patch;
46 const struct firmware *ram_patch;
47 u32 otp_patch_version;
48 u32 ram_patch_version;
52 u32 limited_otp_version;
59 atomic_t data_pkt_counter;
60 void (*data_pkt_counter_cb)(struct nci_dev *ndev);
63 u8 setup_patch_status;
65 wait_queue_head_t setup_wq;
68 static u8 nci_core_get_config_otp_ram_version[5] = {
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
76 struct nci_core_get_config_rsp {
82 static int fdp_nci_create_conn(struct nci_dev *ndev)
84 struct fdp_nci_info *info = nci_get_drvdata(ndev);
85 struct core_conn_create_dest_spec_params param;
88 /* proprietary destination specific paramerer without value */
89 param.type = FDP_PATCH_CONN_PARAM_TYPE;
92 r = nci_core_conn_create(info->ndev, FDP_PATCH_CONN_DEST, 1,
93 sizeof(param), ¶m);
97 return nci_get_conn_info_by_dest_type_params(ndev,
98 FDP_PATCH_CONN_DEST, NULL);
101 static inline int fdp_nci_get_versions(struct nci_dev *ndev)
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);
108 static inline int fdp_nci_patch_cmd(struct nci_dev *ndev, u8 type)
110 return nci_prop_cmd(ndev, NCI_OP_PROP_PATCH_OID, sizeof(type), &type);
113 static inline int fdp_nci_set_production_data(struct nci_dev *ndev, u8 len,
116 return nci_prop_cmd(ndev, NCI_OP_PROP_SET_PDATA_OID, len, data);
119 static int fdp_nci_set_clock(struct nci_dev *ndev, u8 clock_type,
126 nd = (24 * fc) / clock_freq;
127 delta = 24 * fc - nd * clock_freq;
128 num = (32768 * delta) / clock_freq;
136 data[5] = num & 0xFF;
137 data[6] = (num >> 8) & 0xff;
139 data[8] = clock_type;
141 return fdp_nci_set_production_data(ndev, 9, data);
144 static void fdp_nci_send_patch_cb(struct nci_dev *ndev)
146 struct fdp_nci_info *info = nci_get_drvdata(ndev);
148 info->setup_patch_sent = 1;
149 wake_up(&info->setup_wq);
153 * Register a packet sent counter and a callback
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.
159 static void fdp_nci_set_data_pkt_counter(struct nci_dev *ndev,
160 void (*cb)(struct nci_dev *ndev), int count)
162 struct fdp_nci_info *info = nci_get_drvdata(ndev);
163 struct device *dev = &info->phy->i2c_dev->dev;
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;
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.
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 packaet and a NCI_OP_CORE_RESET_NTF packet.
181 static int fdp_nci_send_patch(struct nci_dev *ndev, u8 conn_id, u8 type)
183 struct fdp_nci_info *info = nci_get_drvdata(ndev);
184 const struct firmware *fw;
187 u8 max_size, payload_size;
190 if ((type == NCI_PATCH_TYPE_OTP && !info->otp_patch) ||
191 (type == NCI_PATCH_TYPE_RAM && !info->ram_patch))
194 if (type == NCI_PATCH_TYPE_OTP)
195 fw = info->otp_patch;
197 fw = info->ram_patch;
199 max_size = nci_conn_max_data_pkt_payload_size(ndev, conn_id);
205 fdp_nci_set_data_pkt_counter(ndev, fdp_nci_send_patch_cb,
206 DIV_ROUND_UP(fw->size, max_size));
210 payload_size = min_t(unsigned long, (unsigned long) max_size,
213 skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + payload_size),
216 fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
221 skb_reserve(skb, NCI_CTRL_HDR_SIZE);
223 skb_put_data(skb, fw->data + (fw->size - len), payload_size);
225 rc = nci_send_data(ndev, conn_id, skb);
228 fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
238 static int fdp_nci_open(struct nci_dev *ndev)
241 struct fdp_nci_info *info = nci_get_drvdata(ndev);
242 struct device *dev = &info->phy->i2c_dev->dev;
244 dev_dbg(dev, "%s\n", __func__);
246 r = info->phy_ops->enable(info->phy);
251 static int fdp_nci_close(struct nci_dev *ndev)
253 struct fdp_nci_info *info = nci_get_drvdata(ndev);
254 struct device *dev = &info->phy->i2c_dev->dev;
256 dev_dbg(dev, "%s\n", __func__);
260 static int fdp_nci_send(struct nci_dev *ndev, struct sk_buff *skb)
262 struct fdp_nci_info *info = nci_get_drvdata(ndev);
263 struct device *dev = &info->phy->i2c_dev->dev;
265 dev_dbg(dev, "%s\n", __func__);
267 if (atomic_dec_and_test(&info->data_pkt_counter))
268 info->data_pkt_counter_cb(ndev);
270 return info->phy_ops->write(info->phy, skb);
273 int fdp_nci_recv_frame(struct nci_dev *ndev, struct sk_buff *skb)
275 struct fdp_nci_info *info = nci_get_drvdata(ndev);
276 struct device *dev = &info->phy->i2c_dev->dev;
278 dev_dbg(dev, "%s\n", __func__);
279 return nci_recv_frame(ndev, skb);
281 EXPORT_SYMBOL(fdp_nci_recv_frame);
283 static int fdp_nci_request_firmware(struct nci_dev *ndev)
285 struct fdp_nci_info *info = nci_get_drvdata(ndev);
286 struct device *dev = &info->phy->i2c_dev->dev;
290 r = request_firmware(&info->ram_patch, FDP_RAM_PATCH_NAME, dev);
292 nfc_err(dev, "RAM patch request error\n");
296 data = (u8 *) info->ram_patch->data;
297 info->ram_patch_version =
298 data[FDP_FW_HEADER_SIZE] |
299 (data[FDP_FW_HEADER_SIZE + 1] << 8) |
300 (data[FDP_FW_HEADER_SIZE + 2] << 16) |
301 (data[FDP_FW_HEADER_SIZE + 3] << 24);
303 dev_dbg(dev, "RAM patch version: %d, size: %d\n",
304 info->ram_patch_version, (int) info->ram_patch->size);
307 r = request_firmware(&info->otp_patch, FDP_OTP_PATCH_NAME, dev);
309 nfc_err(dev, "OTP patch request error\n");
313 data = (u8 *) info->otp_patch->data;
314 info->otp_patch_version =
315 data[FDP_FW_HEADER_SIZE] |
316 (data[FDP_FW_HEADER_SIZE + 1] << 8) |
317 (data[FDP_FW_HEADER_SIZE+2] << 16) |
318 (data[FDP_FW_HEADER_SIZE+3] << 24);
320 dev_dbg(dev, "OTP patch version: %d, size: %d\n",
321 info->otp_patch_version, (int) info->otp_patch->size);
328 static void fdp_nci_release_firmware(struct nci_dev *ndev)
330 struct fdp_nci_info *info = nci_get_drvdata(ndev);
332 if (info->otp_patch) {
333 release_firmware(info->otp_patch);
334 info->otp_patch = NULL;
337 if (info->ram_patch) {
338 release_firmware(info->ram_patch);
339 info->ram_patch = NULL;
343 static int fdp_nci_patch_otp(struct nci_dev *ndev)
345 struct fdp_nci_info *info = nci_get_drvdata(ndev);
346 struct device *dev = &info->phy->i2c_dev->dev;
350 if (info->otp_version >= info->otp_patch_version)
353 info->setup_patch_sent = 0;
354 info->setup_reset_ntf = 0;
355 info->setup_patch_ntf = 0;
357 /* Patch init request */
358 r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_OTP);
362 /* Patch data connection creation */
363 conn_id = fdp_nci_create_conn(ndev);
369 /* Send the patch over the data connection */
370 r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_OTP);
374 /* Wait for all the packets to be send over i2c */
375 wait_event_interruptible(info->setup_wq,
376 info->setup_patch_sent == 1);
378 /* make sure that the NFCC processed the last data packet */
379 msleep(FDP_FW_UPDATE_SLEEP);
381 /* Close the data connection */
382 r = nci_core_conn_close(info->ndev, conn_id);
386 /* Patch finish message */
387 if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
388 nfc_err(dev, "OTP patch error 0x%x\n", r);
393 /* If the patch notification didn't arrive yet, wait for it */
394 wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
396 /* Check if the patching was successful */
397 r = info->setup_patch_status;
399 nfc_err(dev, "OTP patch error 0x%x\n", r);
405 * We need to wait for the reset notification before we
408 wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
414 static int fdp_nci_patch_ram(struct nci_dev *ndev)
416 struct fdp_nci_info *info = nci_get_drvdata(ndev);
417 struct device *dev = &info->phy->i2c_dev->dev;
421 if (info->ram_version >= info->ram_patch_version)
424 info->setup_patch_sent = 0;
425 info->setup_reset_ntf = 0;
426 info->setup_patch_ntf = 0;
428 /* Patch init request */
429 r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_RAM);
433 /* Patch data connection creation */
434 conn_id = fdp_nci_create_conn(ndev);
440 /* Send the patch over the data connection */
441 r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_RAM);
445 /* Wait for all the packets to be send over i2c */
446 wait_event_interruptible(info->setup_wq,
447 info->setup_patch_sent == 1);
449 /* make sure that the NFCC processed the last data packet */
450 msleep(FDP_FW_UPDATE_SLEEP);
452 /* Close the data connection */
453 r = nci_core_conn_close(info->ndev, conn_id);
457 /* Patch finish message */
458 if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
459 nfc_err(dev, "RAM patch error 0x%x\n", r);
464 /* If the patch notification didn't arrive yet, wait for it */
465 wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
467 /* Check if the patching was successful */
468 r = info->setup_patch_status;
470 nfc_err(dev, "RAM patch error 0x%x\n", r);
476 * We need to wait for the reset notification before we
479 wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
485 static int fdp_nci_setup(struct nci_dev *ndev)
487 /* Format: total length followed by an NCI packet */
488 struct fdp_nci_info *info = nci_get_drvdata(ndev);
489 struct device *dev = &info->phy->i2c_dev->dev;
493 dev_dbg(dev, "%s\n", __func__);
495 r = nci_core_init(ndev);
499 /* Get RAM and OTP version */
500 r = fdp_nci_get_versions(ndev);
504 /* Load firmware from disk */
505 r = fdp_nci_request_firmware(ndev);
510 if (info->otp_version < info->otp_patch_version) {
511 r = fdp_nci_patch_otp(ndev);
518 if (info->ram_version < info->ram_patch_version) {
519 r = fdp_nci_patch_ram(ndev);
525 /* Release the firmware buffers */
526 fdp_nci_release_firmware(ndev);
528 /* If a patch was applied the new version is checked */
530 r = nci_core_init(ndev);
534 r = fdp_nci_get_versions(ndev);
538 if (info->otp_version != info->otp_patch_version ||
539 info->ram_version != info->ram_patch_version) {
540 nfc_err(dev, "Firmware update failed");
547 * We initialized the devices but the NFC subsystem expects
548 * it to not be initialized.
550 return nci_core_reset(ndev);
553 fdp_nci_release_firmware(ndev);
554 nfc_err(dev, "Setup error %d\n", r);
558 static int fdp_nci_post_setup(struct nci_dev *ndev)
560 struct fdp_nci_info *info = nci_get_drvdata(ndev);
561 struct device *dev = &info->phy->i2c_dev->dev;
564 /* Check if the device has VSC */
565 if (info->fw_vsc_cfg && info->fw_vsc_cfg[0]) {
567 /* Set the vendor specific configuration */
568 r = fdp_nci_set_production_data(ndev, info->fw_vsc_cfg[3],
569 &info->fw_vsc_cfg[4]);
571 nfc_err(dev, "Vendor specific config set error %d\n",
577 /* Set clock type and frequency */
578 r = fdp_nci_set_clock(ndev, info->clock_type, info->clock_freq);
580 nfc_err(dev, "Clock set error %d\n", r);
585 * In order to apply the VSC FDP needs a reset
587 r = nci_core_reset(ndev);
592 * The nci core was initialized when post setup was called
593 * so we leave it like that
595 return nci_core_init(ndev);
598 static int fdp_nci_core_reset_ntf_packet(struct nci_dev *ndev,
601 struct fdp_nci_info *info = nci_get_drvdata(ndev);
602 struct device *dev = &info->phy->i2c_dev->dev;
604 dev_dbg(dev, "%s\n", __func__);
605 info->setup_reset_ntf = 1;
606 wake_up(&info->setup_wq);
611 static int fdp_nci_prop_patch_ntf_packet(struct nci_dev *ndev,
614 struct fdp_nci_info *info = nci_get_drvdata(ndev);
615 struct device *dev = &info->phy->i2c_dev->dev;
617 dev_dbg(dev, "%s\n", __func__);
618 info->setup_patch_ntf = 1;
619 info->setup_patch_status = skb->data[0];
620 wake_up(&info->setup_wq);
625 static int fdp_nci_prop_patch_rsp_packet(struct nci_dev *ndev,
628 struct fdp_nci_info *info = nci_get_drvdata(ndev);
629 struct device *dev = &info->phy->i2c_dev->dev;
630 u8 status = skb->data[0];
632 dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
633 nci_req_complete(ndev, status);
638 static int fdp_nci_prop_set_production_data_rsp_packet(struct nci_dev *ndev,
641 struct fdp_nci_info *info = nci_get_drvdata(ndev);
642 struct device *dev = &info->phy->i2c_dev->dev;
643 u8 status = skb->data[0];
645 dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
646 nci_req_complete(ndev, status);
651 static int fdp_nci_core_get_config_rsp_packet(struct nci_dev *ndev,
654 struct fdp_nci_info *info = nci_get_drvdata(ndev);
655 struct device *dev = &info->phy->i2c_dev->dev;
656 struct nci_core_get_config_rsp *rsp = (void *) skb->data;
659 if (rsp->status == NCI_STATUS_OK) {
662 for (i = 0; i < 4; i++) {
665 case NCI_PARAM_ID_FW_RAM_VERSION:
667 info->ram_version = le32_to_cpup((__le32 *) p);
670 case NCI_PARAM_ID_FW_OTP_VERSION:
672 info->otp_version = le32_to_cpup((__le32 *) p);
675 case NCI_PARAM_ID_OTP_LIMITED_VERSION:
677 info->otp_version = le32_to_cpup((__le32 *) p);
680 case NCI_PARAM_ID_KEY_INDEX_ID:
682 info->key_index = *p++;
687 dev_dbg(dev, "OTP version %d\n", info->otp_version);
688 dev_dbg(dev, "RAM version %d\n", info->ram_version);
689 dev_dbg(dev, "key index %d\n", info->key_index);
690 dev_dbg(dev, "%s: status 0x%x\n", __func__, rsp->status);
692 nci_req_complete(ndev, rsp->status);
697 static struct nci_driver_ops fdp_core_ops[] = {
699 .opcode = NCI_OP_CORE_GET_CONFIG_RSP,
700 .rsp = fdp_nci_core_get_config_rsp_packet,
703 .opcode = NCI_OP_CORE_RESET_NTF,
704 .ntf = fdp_nci_core_reset_ntf_packet,
708 static struct nci_driver_ops fdp_prop_ops[] = {
710 .opcode = nci_opcode_pack(NCI_GID_PROP, NCI_OP_PROP_PATCH_OID),
711 .rsp = fdp_nci_prop_patch_rsp_packet,
712 .ntf = fdp_nci_prop_patch_ntf_packet,
715 .opcode = nci_opcode_pack(NCI_GID_PROP,
716 NCI_OP_PROP_SET_PDATA_OID),
717 .rsp = fdp_nci_prop_set_production_data_rsp_packet,
721 static struct nci_ops nci_ops = {
722 .open = fdp_nci_open,
723 .close = fdp_nci_close,
724 .send = fdp_nci_send,
725 .setup = fdp_nci_setup,
726 .post_setup = fdp_nci_post_setup,
727 .prop_ops = fdp_prop_ops,
728 .n_prop_ops = ARRAY_SIZE(fdp_prop_ops),
729 .core_ops = fdp_core_ops,
730 .n_core_ops = ARRAY_SIZE(fdp_core_ops),
733 int fdp_nci_probe(struct fdp_i2c_phy *phy, struct nfc_phy_ops *phy_ops,
734 struct nci_dev **ndevp, int tx_headroom,
735 int tx_tailroom, u8 clock_type, u32 clock_freq,
738 struct device *dev = &phy->i2c_dev->dev;
739 struct fdp_nci_info *info;
740 struct nci_dev *ndev;
744 info = devm_kzalloc(dev, sizeof(struct fdp_nci_info), GFP_KERNEL);
749 info->phy_ops = phy_ops;
750 info->clock_type = clock_type;
751 info->clock_freq = clock_freq;
752 info->fw_vsc_cfg = fw_vsc_cfg;
754 init_waitqueue_head(&info->setup_wq);
756 protocols = NFC_PROTO_JEWEL_MASK |
757 NFC_PROTO_MIFARE_MASK |
758 NFC_PROTO_FELICA_MASK |
759 NFC_PROTO_ISO14443_MASK |
760 NFC_PROTO_ISO14443_B_MASK |
761 NFC_PROTO_NFC_DEP_MASK |
762 NFC_PROTO_ISO15693_MASK;
764 ndev = nci_allocate_device(&nci_ops, protocols, tx_headroom,
767 nfc_err(dev, "Cannot allocate nfc ndev\n");
771 r = nci_register_device(ndev);
778 nci_set_drvdata(ndev, info);
783 nci_free_device(ndev);
786 EXPORT_SYMBOL(fdp_nci_probe);
788 void fdp_nci_remove(struct nci_dev *ndev)
790 struct fdp_nci_info *info = nci_get_drvdata(ndev);
791 struct device *dev = &info->phy->i2c_dev->dev;
793 dev_dbg(dev, "%s\n", __func__);
795 nci_unregister_device(ndev);
796 nci_free_device(ndev);
798 EXPORT_SYMBOL(fdp_nci_remove);
800 MODULE_LICENSE("GPL");
801 MODULE_DESCRIPTION("NFC NCI driver for Intel Fields Peak NFC controller");
802 MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");