1 /* -------------------------------------------------------------------------
2 * Copyright (C) 2014-2016, Intel Corporation
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 * -------------------------------------------------------------------------
16 #include <linux/module.h>
17 #include <linux/nfc.h>
18 #include <linux/i2c.h>
19 #include <linux/delay.h>
20 #include <linux/firmware.h>
21 #include <net/nfc/nci_core.h>
25 #define FDP_OTP_PATCH_NAME "/*(DEBLOBBED)*/"
26 #define FDP_RAM_PATCH_NAME "/*(DEBLOBBED)*/"
27 #define FDP_FW_HEADER_SIZE 576
28 #define FDP_FW_UPDATE_SLEEP 1000
30 #define NCI_GET_VERSION_TIMEOUT 8000
31 #define NCI_PATCH_REQUEST_TIMEOUT 8000
32 #define FDP_PATCH_CONN_DEST 0xC2
33 #define FDP_PATCH_CONN_PARAM_TYPE 0xA0
35 #define NCI_PATCH_TYPE_RAM 0x00
36 #define NCI_PATCH_TYPE_OTP 0x01
37 #define NCI_PATCH_TYPE_EOT 0xFF
39 #define NCI_PARAM_ID_FW_RAM_VERSION 0xA0
40 #define NCI_PARAM_ID_FW_OTP_VERSION 0xA1
41 #define NCI_PARAM_ID_OTP_LIMITED_VERSION 0xC5
42 #define NCI_PARAM_ID_KEY_INDEX_ID 0xC6
44 #define NCI_GID_PROP 0x0F
45 #define NCI_OP_PROP_PATCH_OID 0x08
46 #define NCI_OP_PROP_SET_PDATA_OID 0x23
49 struct nfc_phy_ops *phy_ops;
50 struct fdp_i2c_phy *phy;
53 const struct firmware *otp_patch;
54 const struct firmware *ram_patch;
55 u32 otp_patch_version;
56 u32 ram_patch_version;
60 u32 limited_otp_version;
67 atomic_t data_pkt_counter;
68 void (*data_pkt_counter_cb)(struct nci_dev *ndev);
71 u8 setup_patch_status;
73 wait_queue_head_t setup_wq;
76 static u8 nci_core_get_config_otp_ram_version[5] = {
78 NCI_PARAM_ID_FW_RAM_VERSION,
79 NCI_PARAM_ID_FW_OTP_VERSION,
80 NCI_PARAM_ID_OTP_LIMITED_VERSION,
81 NCI_PARAM_ID_KEY_INDEX_ID
84 struct nci_core_get_config_rsp {
90 static int fdp_nci_create_conn(struct nci_dev *ndev)
92 struct fdp_nci_info *info = nci_get_drvdata(ndev);
93 struct core_conn_create_dest_spec_params param;
96 /* proprietary destination specific paramerer without value */
97 param.type = FDP_PATCH_CONN_PARAM_TYPE;
100 r = nci_core_conn_create(info->ndev, FDP_PATCH_CONN_DEST, 1,
101 sizeof(param), ¶m);
105 return nci_get_conn_info_by_dest_type_params(ndev,
106 FDP_PATCH_CONN_DEST, NULL);
109 static inline int fdp_nci_get_versions(struct nci_dev *ndev)
111 return nci_core_cmd(ndev, NCI_OP_CORE_GET_CONFIG_CMD,
112 sizeof(nci_core_get_config_otp_ram_version),
113 (__u8 *) &nci_core_get_config_otp_ram_version);
116 static inline int fdp_nci_patch_cmd(struct nci_dev *ndev, u8 type)
118 return nci_prop_cmd(ndev, NCI_OP_PROP_PATCH_OID, sizeof(type), &type);
121 static inline int fdp_nci_set_production_data(struct nci_dev *ndev, u8 len,
124 return nci_prop_cmd(ndev, NCI_OP_PROP_SET_PDATA_OID, len, data);
127 static int fdp_nci_set_clock(struct nci_dev *ndev, u8 clock_type,
134 nd = (24 * fc) / clock_freq;
135 delta = 24 * fc - nd * clock_freq;
136 num = (32768 * delta) / clock_freq;
144 data[5] = num & 0xFF;
145 data[6] = (num >> 8) & 0xff;
147 data[8] = clock_type;
149 return fdp_nci_set_production_data(ndev, 9, data);
152 static void fdp_nci_send_patch_cb(struct nci_dev *ndev)
154 struct fdp_nci_info *info = nci_get_drvdata(ndev);
156 info->setup_patch_sent = 1;
157 wake_up(&info->setup_wq);
161 * Register a packet sent counter and a callback
163 * We have no other way of knowing when all firmware packets were sent out
164 * on the i2c bus. We need to know that in order to close the connection and
165 * send the patch end message.
167 static void fdp_nci_set_data_pkt_counter(struct nci_dev *ndev,
168 void (*cb)(struct nci_dev *ndev), int count)
170 struct fdp_nci_info *info = nci_get_drvdata(ndev);
171 struct device *dev = &info->phy->i2c_dev->dev;
173 dev_dbg(dev, "NCI data pkt counter %d\n", count);
174 atomic_set(&info->data_pkt_counter, count);
175 info->data_pkt_counter_cb = cb;
179 * The device is expecting a stream of packets. All packets need to
180 * have the PBF flag set to 0x0 (last packet) even if the firmware
181 * file is segmented and there are multiple packets. If we give the
182 * whole firmware to nci_send_data it will segment it and it will set
183 * the PBF flag to 0x01 so we need to do the segmentation here.
185 * The firmware will be analyzed and applied when we send NCI_OP_PROP_PATCH_CMD
186 * command with NCI_PATCH_TYPE_EOT parameter. The device will send a
187 * NFCC_PATCH_NTF packaet and a NCI_OP_CORE_RESET_NTF packet.
189 static int fdp_nci_send_patch(struct nci_dev *ndev, u8 conn_id, u8 type)
191 struct fdp_nci_info *info = nci_get_drvdata(ndev);
192 const struct firmware *fw;
195 int max_size, payload_size;
198 if ((type == NCI_PATCH_TYPE_OTP && !info->otp_patch) ||
199 (type == NCI_PATCH_TYPE_RAM && !info->ram_patch))
202 if (type == NCI_PATCH_TYPE_OTP)
203 fw = info->otp_patch;
205 fw = info->ram_patch;
207 max_size = nci_conn_max_data_pkt_payload_size(ndev, conn_id);
213 fdp_nci_set_data_pkt_counter(ndev, fdp_nci_send_patch_cb,
214 DIV_ROUND_UP(fw->size, max_size));
218 payload_size = min_t(unsigned long, max_size, len);
220 skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + payload_size),
223 fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
228 skb_reserve(skb, NCI_CTRL_HDR_SIZE);
230 skb_put_data(skb, fw->data + (fw->size - len), payload_size);
232 rc = nci_send_data(ndev, conn_id, skb);
235 fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
245 static int fdp_nci_open(struct nci_dev *ndev)
248 struct fdp_nci_info *info = nci_get_drvdata(ndev);
249 struct device *dev = &info->phy->i2c_dev->dev;
251 dev_dbg(dev, "%s\n", __func__);
253 r = info->phy_ops->enable(info->phy);
258 static int fdp_nci_close(struct nci_dev *ndev)
260 struct fdp_nci_info *info = nci_get_drvdata(ndev);
261 struct device *dev = &info->phy->i2c_dev->dev;
263 dev_dbg(dev, "%s\n", __func__);
267 static int fdp_nci_send(struct nci_dev *ndev, struct sk_buff *skb)
269 struct fdp_nci_info *info = nci_get_drvdata(ndev);
270 struct device *dev = &info->phy->i2c_dev->dev;
272 dev_dbg(dev, "%s\n", __func__);
274 if (atomic_dec_and_test(&info->data_pkt_counter))
275 info->data_pkt_counter_cb(ndev);
277 return info->phy_ops->write(info->phy, skb);
280 int fdp_nci_recv_frame(struct nci_dev *ndev, struct sk_buff *skb)
282 struct fdp_nci_info *info = nci_get_drvdata(ndev);
283 struct device *dev = &info->phy->i2c_dev->dev;
285 dev_dbg(dev, "%s\n", __func__);
286 return nci_recv_frame(ndev, skb);
288 EXPORT_SYMBOL(fdp_nci_recv_frame);
290 static int fdp_nci_request_firmware(struct nci_dev *ndev)
292 struct fdp_nci_info *info = nci_get_drvdata(ndev);
293 struct device *dev = &info->phy->i2c_dev->dev;
297 r = reject_firmware(&info->ram_patch, FDP_RAM_PATCH_NAME, dev);
299 nfc_err(dev, "RAM patch request error\n");
303 data = (u8 *) info->ram_patch->data;
304 info->ram_patch_version =
305 data[FDP_FW_HEADER_SIZE] |
306 (data[FDP_FW_HEADER_SIZE + 1] << 8) |
307 (data[FDP_FW_HEADER_SIZE + 2] << 16) |
308 (data[FDP_FW_HEADER_SIZE + 3] << 24);
310 dev_dbg(dev, "RAM patch version: %d, size: %d\n",
311 info->ram_patch_version, (int) info->ram_patch->size);
314 r = reject_firmware(&info->otp_patch, FDP_OTP_PATCH_NAME, dev);
316 nfc_err(dev, "OTP patch request error\n");
320 data = (u8 *) info->otp_patch->data;
321 info->otp_patch_version =
322 data[FDP_FW_HEADER_SIZE] |
323 (data[FDP_FW_HEADER_SIZE + 1] << 8) |
324 (data[FDP_FW_HEADER_SIZE+2] << 16) |
325 (data[FDP_FW_HEADER_SIZE+3] << 24);
327 dev_dbg(dev, "OTP patch version: %d, size: %d\n",
328 info->otp_patch_version, (int) info->otp_patch->size);
335 static void fdp_nci_release_firmware(struct nci_dev *ndev)
337 struct fdp_nci_info *info = nci_get_drvdata(ndev);
339 if (info->otp_patch) {
340 release_firmware(info->otp_patch);
341 info->otp_patch = NULL;
344 if (info->ram_patch) {
345 release_firmware(info->ram_patch);
346 info->ram_patch = NULL;
350 static int fdp_nci_patch_otp(struct nci_dev *ndev)
352 struct fdp_nci_info *info = nci_get_drvdata(ndev);
353 struct device *dev = &info->phy->i2c_dev->dev;
357 if (info->otp_version >= info->otp_patch_version)
360 info->setup_patch_sent = 0;
361 info->setup_reset_ntf = 0;
362 info->setup_patch_ntf = 0;
364 /* Patch init request */
365 r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_OTP);
369 /* Patch data connection creation */
370 conn_id = fdp_nci_create_conn(ndev);
376 /* Send the patch over the data connection */
377 r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_OTP);
381 /* Wait for all the packets to be send over i2c */
382 wait_event_interruptible(info->setup_wq,
383 info->setup_patch_sent == 1);
385 /* make sure that the NFCC processed the last data packet */
386 msleep(FDP_FW_UPDATE_SLEEP);
388 /* Close the data connection */
389 r = nci_core_conn_close(info->ndev, conn_id);
393 /* Patch finish message */
394 if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
395 nfc_err(dev, "OTP patch error 0x%x\n", r);
400 /* If the patch notification didn't arrive yet, wait for it */
401 wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
403 /* Check if the patching was successful */
404 r = info->setup_patch_status;
406 nfc_err(dev, "OTP patch error 0x%x\n", r);
412 * We need to wait for the reset notification before we
415 wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
421 static int fdp_nci_patch_ram(struct nci_dev *ndev)
423 struct fdp_nci_info *info = nci_get_drvdata(ndev);
424 struct device *dev = &info->phy->i2c_dev->dev;
428 if (info->ram_version >= info->ram_patch_version)
431 info->setup_patch_sent = 0;
432 info->setup_reset_ntf = 0;
433 info->setup_patch_ntf = 0;
435 /* Patch init request */
436 r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_RAM);
440 /* Patch data connection creation */
441 conn_id = fdp_nci_create_conn(ndev);
447 /* Send the patch over the data connection */
448 r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_RAM);
452 /* Wait for all the packets to be send over i2c */
453 wait_event_interruptible(info->setup_wq,
454 info->setup_patch_sent == 1);
456 /* make sure that the NFCC processed the last data packet */
457 msleep(FDP_FW_UPDATE_SLEEP);
459 /* Close the data connection */
460 r = nci_core_conn_close(info->ndev, conn_id);
464 /* Patch finish message */
465 if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
466 nfc_err(dev, "RAM patch error 0x%x\n", r);
471 /* If the patch notification didn't arrive yet, wait for it */
472 wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
474 /* Check if the patching was successful */
475 r = info->setup_patch_status;
477 nfc_err(dev, "RAM patch error 0x%x\n", r);
483 * We need to wait for the reset notification before we
486 wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
492 static int fdp_nci_setup(struct nci_dev *ndev)
494 /* Format: total length followed by an NCI packet */
495 struct fdp_nci_info *info = nci_get_drvdata(ndev);
496 struct device *dev = &info->phy->i2c_dev->dev;
500 dev_dbg(dev, "%s\n", __func__);
502 r = nci_core_init(ndev);
506 /* Get RAM and OTP version */
507 r = fdp_nci_get_versions(ndev);
511 /* Load firmware from disk */
512 r = fdp_nci_request_firmware(ndev);
517 if (info->otp_version < info->otp_patch_version) {
518 r = fdp_nci_patch_otp(ndev);
525 if (info->ram_version < info->ram_patch_version) {
526 r = fdp_nci_patch_ram(ndev);
532 /* Release the firmware buffers */
533 fdp_nci_release_firmware(ndev);
535 /* If a patch was applied the new version is checked */
537 r = nci_core_init(ndev);
541 r = fdp_nci_get_versions(ndev);
545 if (info->otp_version != info->otp_patch_version ||
546 info->ram_version != info->ram_patch_version) {
547 nfc_err(dev, "Firmware update failed");
554 * We initialized the devices but the NFC subsystem expects
555 * it to not be initialized.
557 return nci_core_reset(ndev);
560 fdp_nci_release_firmware(ndev);
561 nfc_err(dev, "Setup error %d\n", r);
565 static int fdp_nci_post_setup(struct nci_dev *ndev)
567 struct fdp_nci_info *info = nci_get_drvdata(ndev);
568 struct device *dev = &info->phy->i2c_dev->dev;
571 /* Check if the device has VSC */
572 if (info->fw_vsc_cfg && info->fw_vsc_cfg[0]) {
574 /* Set the vendor specific configuration */
575 r = fdp_nci_set_production_data(ndev, info->fw_vsc_cfg[3],
576 &info->fw_vsc_cfg[4]);
578 nfc_err(dev, "Vendor specific config set error %d\n",
584 /* Set clock type and frequency */
585 r = fdp_nci_set_clock(ndev, info->clock_type, info->clock_freq);
587 nfc_err(dev, "Clock set error %d\n", r);
592 * In order to apply the VSC FDP needs a reset
594 r = nci_core_reset(ndev);
599 * The nci core was initialized when post setup was called
600 * so we leave it like that
602 return nci_core_init(ndev);
605 static int fdp_nci_core_reset_ntf_packet(struct nci_dev *ndev,
608 struct fdp_nci_info *info = nci_get_drvdata(ndev);
609 struct device *dev = &info->phy->i2c_dev->dev;
611 dev_dbg(dev, "%s\n", __func__);
612 info->setup_reset_ntf = 1;
613 wake_up(&info->setup_wq);
618 static int fdp_nci_prop_patch_ntf_packet(struct nci_dev *ndev,
621 struct fdp_nci_info *info = nci_get_drvdata(ndev);
622 struct device *dev = &info->phy->i2c_dev->dev;
624 dev_dbg(dev, "%s\n", __func__);
625 info->setup_patch_ntf = 1;
626 info->setup_patch_status = skb->data[0];
627 wake_up(&info->setup_wq);
632 static int fdp_nci_prop_patch_rsp_packet(struct nci_dev *ndev,
635 struct fdp_nci_info *info = nci_get_drvdata(ndev);
636 struct device *dev = &info->phy->i2c_dev->dev;
637 u8 status = skb->data[0];
639 dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
640 nci_req_complete(ndev, status);
645 static int fdp_nci_prop_set_production_data_rsp_packet(struct nci_dev *ndev,
648 struct fdp_nci_info *info = nci_get_drvdata(ndev);
649 struct device *dev = &info->phy->i2c_dev->dev;
650 u8 status = skb->data[0];
652 dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
653 nci_req_complete(ndev, status);
658 static int fdp_nci_core_get_config_rsp_packet(struct nci_dev *ndev,
661 struct fdp_nci_info *info = nci_get_drvdata(ndev);
662 struct device *dev = &info->phy->i2c_dev->dev;
663 struct nci_core_get_config_rsp *rsp = (void *) skb->data;
666 if (rsp->status == NCI_STATUS_OK) {
669 for (i = 0; i < 4; i++) {
672 case NCI_PARAM_ID_FW_RAM_VERSION:
674 info->ram_version = le32_to_cpup((__le32 *) p);
677 case NCI_PARAM_ID_FW_OTP_VERSION:
679 info->otp_version = le32_to_cpup((__le32 *) p);
682 case NCI_PARAM_ID_OTP_LIMITED_VERSION:
684 info->otp_version = le32_to_cpup((__le32 *) p);
687 case NCI_PARAM_ID_KEY_INDEX_ID:
689 info->key_index = *p++;
694 dev_dbg(dev, "OTP version %d\n", info->otp_version);
695 dev_dbg(dev, "RAM version %d\n", info->ram_version);
696 dev_dbg(dev, "key index %d\n", info->key_index);
697 dev_dbg(dev, "%s: status 0x%x\n", __func__, rsp->status);
699 nci_req_complete(ndev, rsp->status);
704 static struct nci_driver_ops fdp_core_ops[] = {
706 .opcode = NCI_OP_CORE_GET_CONFIG_RSP,
707 .rsp = fdp_nci_core_get_config_rsp_packet,
710 .opcode = NCI_OP_CORE_RESET_NTF,
711 .ntf = fdp_nci_core_reset_ntf_packet,
715 static struct nci_driver_ops fdp_prop_ops[] = {
717 .opcode = nci_opcode_pack(NCI_GID_PROP, NCI_OP_PROP_PATCH_OID),
718 .rsp = fdp_nci_prop_patch_rsp_packet,
719 .ntf = fdp_nci_prop_patch_ntf_packet,
722 .opcode = nci_opcode_pack(NCI_GID_PROP,
723 NCI_OP_PROP_SET_PDATA_OID),
724 .rsp = fdp_nci_prop_set_production_data_rsp_packet,
728 struct nci_ops nci_ops = {
729 .open = fdp_nci_open,
730 .close = fdp_nci_close,
731 .send = fdp_nci_send,
732 .setup = fdp_nci_setup,
733 .post_setup = fdp_nci_post_setup,
734 .prop_ops = fdp_prop_ops,
735 .n_prop_ops = ARRAY_SIZE(fdp_prop_ops),
736 .core_ops = fdp_core_ops,
737 .n_core_ops = ARRAY_SIZE(fdp_core_ops),
740 int fdp_nci_probe(struct fdp_i2c_phy *phy, struct nfc_phy_ops *phy_ops,
741 struct nci_dev **ndevp, int tx_headroom,
742 int tx_tailroom, u8 clock_type, u32 clock_freq,
745 struct device *dev = &phy->i2c_dev->dev;
746 struct fdp_nci_info *info;
747 struct nci_dev *ndev;
751 info = devm_kzalloc(dev, sizeof(struct fdp_nci_info), GFP_KERNEL);
756 info->phy_ops = phy_ops;
757 info->clock_type = clock_type;
758 info->clock_freq = clock_freq;
759 info->fw_vsc_cfg = fw_vsc_cfg;
761 init_waitqueue_head(&info->setup_wq);
763 protocols = NFC_PROTO_JEWEL_MASK |
764 NFC_PROTO_MIFARE_MASK |
765 NFC_PROTO_FELICA_MASK |
766 NFC_PROTO_ISO14443_MASK |
767 NFC_PROTO_ISO14443_B_MASK |
768 NFC_PROTO_NFC_DEP_MASK |
769 NFC_PROTO_ISO15693_MASK;
771 ndev = nci_allocate_device(&nci_ops, protocols, tx_headroom,
774 nfc_err(dev, "Cannot allocate nfc ndev\n");
778 r = nci_register_device(ndev);
785 nci_set_drvdata(ndev, info);
790 nci_free_device(ndev);
793 EXPORT_SYMBOL(fdp_nci_probe);
795 void fdp_nci_remove(struct nci_dev *ndev)
797 struct fdp_nci_info *info = nci_get_drvdata(ndev);
798 struct device *dev = &info->phy->i2c_dev->dev;
800 dev_dbg(dev, "%s\n", __func__);
802 nci_unregister_device(ndev);
803 nci_free_device(ndev);
805 EXPORT_SYMBOL(fdp_nci_remove);
807 MODULE_LICENSE("GPL");
808 MODULE_DESCRIPTION("NFC NCI driver for Intel Fields Peak NFC controller");
809 MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");