treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / nfc / fdp / fdp.c
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         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
68 static 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[0];
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), &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
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                                               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 packaet 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         u8 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, (unsigned long) max_size,
211                                      len);
212
213                 skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + payload_size),
214                                     GFP_KERNEL);
215                 if (!skb) {
216                         fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
217                         return -ENOMEM;
218                 }
219
220
221                 skb_reserve(skb, NCI_CTRL_HDR_SIZE);
222
223                 skb_put_data(skb, fw->data + (fw->size - len), payload_size);
224
225                 rc = nci_send_data(ndev, conn_id, skb);
226
227                 if (rc) {
228                         fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
229                         return rc;
230                 }
231
232                 len -= payload_size;
233         }
234
235         return rc;
236 }
237
238 static int fdp_nci_open(struct nci_dev *ndev)
239 {
240         int r;
241         struct fdp_nci_info *info = nci_get_drvdata(ndev);
242         struct device *dev = &info->phy->i2c_dev->dev;
243
244         dev_dbg(dev, "%s\n", __func__);
245
246         r = info->phy_ops->enable(info->phy);
247
248         return r;
249 }
250
251 static int fdp_nci_close(struct nci_dev *ndev)
252 {
253         struct fdp_nci_info *info = nci_get_drvdata(ndev);
254         struct device *dev = &info->phy->i2c_dev->dev;
255
256         dev_dbg(dev, "%s\n", __func__);
257         return 0;
258 }
259
260 static int fdp_nci_send(struct nci_dev *ndev, struct sk_buff *skb)
261 {
262         struct fdp_nci_info *info = nci_get_drvdata(ndev);
263         struct device *dev = &info->phy->i2c_dev->dev;
264
265         dev_dbg(dev, "%s\n", __func__);
266
267         if (atomic_dec_and_test(&info->data_pkt_counter))
268                 info->data_pkt_counter_cb(ndev);
269
270         return info->phy_ops->write(info->phy, skb);
271 }
272
273 int fdp_nci_recv_frame(struct nci_dev *ndev, struct sk_buff *skb)
274 {
275         struct fdp_nci_info *info = nci_get_drvdata(ndev);
276         struct device *dev = &info->phy->i2c_dev->dev;
277
278         dev_dbg(dev, "%s\n", __func__);
279         return nci_recv_frame(ndev, skb);
280 }
281 EXPORT_SYMBOL(fdp_nci_recv_frame);
282
283 static int fdp_nci_request_firmware(struct nci_dev *ndev)
284 {
285         struct fdp_nci_info *info = nci_get_drvdata(ndev);
286         struct device *dev = &info->phy->i2c_dev->dev;
287         u8 *data;
288         int r;
289
290         r = request_firmware(&info->ram_patch, FDP_RAM_PATCH_NAME, dev);
291         if (r < 0) {
292                 nfc_err(dev, "RAM patch request error\n");
293                 goto error;
294         }
295
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);
302
303         dev_dbg(dev, "RAM patch version: %d, size: %d\n",
304                   info->ram_patch_version, (int) info->ram_patch->size);
305
306
307         r = request_firmware(&info->otp_patch, FDP_OTP_PATCH_NAME, dev);
308         if (r < 0) {
309                 nfc_err(dev, "OTP patch request error\n");
310                 goto out;
311         }
312
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);
319
320         dev_dbg(dev, "OTP patch version: %d, size: %d\n",
321                  info->otp_patch_version, (int) info->otp_patch->size);
322 out:
323         return 0;
324 error:
325         return r;
326 }
327
328 static void fdp_nci_release_firmware(struct nci_dev *ndev)
329 {
330         struct fdp_nci_info *info = nci_get_drvdata(ndev);
331
332         if (info->otp_patch) {
333                 release_firmware(info->otp_patch);
334                 info->otp_patch = NULL;
335         }
336
337         if (info->ram_patch) {
338                 release_firmware(info->ram_patch);
339                 info->ram_patch = NULL;
340         }
341 }
342
343 static int fdp_nci_patch_otp(struct nci_dev *ndev)
344 {
345         struct fdp_nci_info *info = nci_get_drvdata(ndev);
346         struct device *dev = &info->phy->i2c_dev->dev;
347         int conn_id;
348         int r = 0;
349
350         if (info->otp_version >= info->otp_patch_version)
351                 goto out;
352
353         info->setup_patch_sent = 0;
354         info->setup_reset_ntf = 0;
355         info->setup_patch_ntf = 0;
356
357         /* Patch init request */
358         r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_OTP);
359         if (r)
360                 goto out;
361
362         /* Patch data connection creation */
363         conn_id = fdp_nci_create_conn(ndev);
364         if (conn_id < 0) {
365                 r = conn_id;
366                 goto out;
367         }
368
369         /* Send the patch over the data connection */
370         r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_OTP);
371         if (r)
372                 goto out;
373
374         /* Wait for all the packets to be send over i2c */
375         wait_event_interruptible(info->setup_wq,
376                                  info->setup_patch_sent == 1);
377
378         /* make sure that the NFCC processed the last data packet */
379         msleep(FDP_FW_UPDATE_SLEEP);
380
381         /* Close the data connection */
382         r = nci_core_conn_close(info->ndev, conn_id);
383         if (r)
384                 goto out;
385
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);
389                 r = -EINVAL;
390                 goto out;
391         }
392
393         /* If the patch notification didn't arrive yet, wait for it */
394         wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
395
396         /* Check if the patching was successful */
397         r = info->setup_patch_status;
398         if (r) {
399                 nfc_err(dev, "OTP patch error 0x%x\n", r);
400                 r = -EINVAL;
401                 goto out;
402         }
403
404         /*
405          * We need to wait for the reset notification before we
406          * can continue
407          */
408         wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
409
410 out:
411         return r;
412 }
413
414 static int fdp_nci_patch_ram(struct nci_dev *ndev)
415 {
416         struct fdp_nci_info *info = nci_get_drvdata(ndev);
417         struct device *dev = &info->phy->i2c_dev->dev;
418         int conn_id;
419         int r = 0;
420
421         if (info->ram_version >= info->ram_patch_version)
422                 goto out;
423
424         info->setup_patch_sent = 0;
425         info->setup_reset_ntf = 0;
426         info->setup_patch_ntf = 0;
427
428         /* Patch init request */
429         r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_RAM);
430         if (r)
431                 goto out;
432
433         /* Patch data connection creation */
434         conn_id = fdp_nci_create_conn(ndev);
435         if (conn_id < 0) {
436                 r = conn_id;
437                 goto out;
438         }
439
440         /* Send the patch over the data connection */
441         r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_RAM);
442         if (r)
443                 goto out;
444
445         /* Wait for all the packets to be send over i2c */
446         wait_event_interruptible(info->setup_wq,
447                                  info->setup_patch_sent == 1);
448
449         /* make sure that the NFCC processed the last data packet */
450         msleep(FDP_FW_UPDATE_SLEEP);
451
452         /* Close the data connection */
453         r = nci_core_conn_close(info->ndev, conn_id);
454         if (r)
455                 goto out;
456
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);
460                 r = -EINVAL;
461                 goto out;
462         }
463
464         /* If the patch notification didn't arrive yet, wait for it */
465         wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
466
467         /* Check if the patching was successful */
468         r = info->setup_patch_status;
469         if (r) {
470                 nfc_err(dev, "RAM patch error 0x%x\n", r);
471                 r = -EINVAL;
472                 goto out;
473         }
474
475         /*
476          * We need to wait for the reset notification before we
477          * can continue
478          */
479         wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
480
481 out:
482         return r;
483 }
484
485 static int fdp_nci_setup(struct nci_dev *ndev)
486 {
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;
490         int r;
491         u8 patched = 0;
492
493         dev_dbg(dev, "%s\n", __func__);
494
495         r = nci_core_init(ndev);
496         if (r)
497                 goto error;
498
499         /* Get RAM and OTP version */
500         r = fdp_nci_get_versions(ndev);
501         if (r)
502                 goto error;
503
504         /* Load firmware from disk */
505         r = fdp_nci_request_firmware(ndev);
506         if (r)
507                 goto error;
508
509         /* Update OTP */
510         if (info->otp_version < info->otp_patch_version) {
511                 r = fdp_nci_patch_otp(ndev);
512                 if (r)
513                         goto error;
514                 patched = 1;
515         }
516
517         /* Update RAM */
518         if (info->ram_version < info->ram_patch_version) {
519                 r = fdp_nci_patch_ram(ndev);
520                 if (r)
521                         goto error;
522                 patched = 1;
523         }
524
525         /* Release the firmware buffers */
526         fdp_nci_release_firmware(ndev);
527
528         /* If a patch was applied the new version is checked */
529         if (patched) {
530                 r = nci_core_init(ndev);
531                 if (r)
532                         goto error;
533
534                 r = fdp_nci_get_versions(ndev);
535                 if (r)
536                         goto error;
537
538                 if (info->otp_version != info->otp_patch_version ||
539                     info->ram_version != info->ram_patch_version) {
540                         nfc_err(dev, "Firmware update failed");
541                         r = -EINVAL;
542                         goto error;
543                 }
544         }
545
546         /*
547          * We initialized the devices but the NFC subsystem expects
548          * it to not be initialized.
549          */
550         return nci_core_reset(ndev);
551
552 error:
553         fdp_nci_release_firmware(ndev);
554         nfc_err(dev, "Setup error %d\n", r);
555         return r;
556 }
557
558 static int fdp_nci_post_setup(struct nci_dev *ndev)
559 {
560         struct fdp_nci_info *info = nci_get_drvdata(ndev);
561         struct device *dev = &info->phy->i2c_dev->dev;
562         int r;
563
564         /* Check if the device has VSC */
565         if (info->fw_vsc_cfg && info->fw_vsc_cfg[0]) {
566
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]);
570                 if (r) {
571                         nfc_err(dev, "Vendor specific config set error %d\n",
572                                 r);
573                         return r;
574                 }
575         }
576
577         /* Set clock type and frequency */
578         r = fdp_nci_set_clock(ndev, info->clock_type, info->clock_freq);
579         if (r) {
580                 nfc_err(dev, "Clock set error %d\n", r);
581                 return r;
582         }
583
584         /*
585          * In order to apply the VSC FDP needs a reset
586          */
587         r = nci_core_reset(ndev);
588         if (r)
589                 return r;
590
591         /**
592          * The nci core was initialized when post setup was called
593          * so we leave it like that
594          */
595         return nci_core_init(ndev);
596 }
597
598 static int fdp_nci_core_reset_ntf_packet(struct nci_dev *ndev,
599                                           struct sk_buff *skb)
600 {
601         struct fdp_nci_info *info = nci_get_drvdata(ndev);
602         struct device *dev = &info->phy->i2c_dev->dev;
603
604         dev_dbg(dev, "%s\n", __func__);
605         info->setup_reset_ntf = 1;
606         wake_up(&info->setup_wq);
607
608         return 0;
609 }
610
611 static int fdp_nci_prop_patch_ntf_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
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);
621
622         return 0;
623 }
624
625 static int fdp_nci_prop_patch_rsp_packet(struct nci_dev *ndev,
626                                           struct sk_buff *skb)
627 {
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];
631
632         dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
633         nci_req_complete(ndev, status);
634
635         return 0;
636 }
637
638 static int fdp_nci_prop_set_production_data_rsp_packet(struct nci_dev *ndev,
639                                                         struct sk_buff *skb)
640 {
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];
644
645         dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
646         nci_req_complete(ndev, status);
647
648         return 0;
649 }
650
651 static int fdp_nci_core_get_config_rsp_packet(struct nci_dev *ndev,
652                                                 struct sk_buff *skb)
653 {
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;
657         u8 i, *p;
658
659         if (rsp->status == NCI_STATUS_OK) {
660
661                 p = rsp->data;
662                 for (i = 0; i < 4; i++) {
663
664                         switch (*p++) {
665                         case NCI_PARAM_ID_FW_RAM_VERSION:
666                                 p++;
667                                 info->ram_version = le32_to_cpup((__le32 *) p);
668                                 p += 4;
669                                 break;
670                         case NCI_PARAM_ID_FW_OTP_VERSION:
671                                 p++;
672                                 info->otp_version = le32_to_cpup((__le32 *) p);
673                                 p += 4;
674                                 break;
675                         case NCI_PARAM_ID_OTP_LIMITED_VERSION:
676                                 p++;
677                                 info->otp_version = le32_to_cpup((__le32 *) p);
678                                 p += 4;
679                                 break;
680                         case NCI_PARAM_ID_KEY_INDEX_ID:
681                                 p++;
682                                 info->key_index = *p++;
683                         }
684                 }
685         }
686
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);
691
692         nci_req_complete(ndev, rsp->status);
693
694         return 0;
695 }
696
697 static struct nci_driver_ops fdp_core_ops[] = {
698         {
699                 .opcode = NCI_OP_CORE_GET_CONFIG_RSP,
700                 .rsp = fdp_nci_core_get_config_rsp_packet,
701         },
702         {
703                 .opcode = NCI_OP_CORE_RESET_NTF,
704                 .ntf = fdp_nci_core_reset_ntf_packet,
705         },
706 };
707
708 static struct nci_driver_ops fdp_prop_ops[] = {
709         {
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,
713         },
714         {
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,
718         },
719 };
720
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),
731 };
732
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,
736                         u8 *fw_vsc_cfg)
737 {
738         struct device *dev = &phy->i2c_dev->dev;
739         struct fdp_nci_info *info;
740         struct nci_dev *ndev;
741         u32 protocols;
742         int r;
743
744         info = devm_kzalloc(dev, sizeof(struct fdp_nci_info), GFP_KERNEL);
745         if (!info)
746                 return -ENOMEM;
747
748         info->phy = phy;
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;
753
754         init_waitqueue_head(&info->setup_wq);
755
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;
763
764         ndev = nci_allocate_device(&nci_ops, protocols, tx_headroom,
765                                    tx_tailroom);
766         if (!ndev) {
767                 nfc_err(dev, "Cannot allocate nfc ndev\n");
768                 return -ENOMEM;
769         }
770
771         r = nci_register_device(ndev);
772         if (r)
773                 goto err_regdev;
774
775         *ndevp = ndev;
776         info->ndev = ndev;
777
778         nci_set_drvdata(ndev, info);
779
780         return 0;
781
782 err_regdev:
783         nci_free_device(ndev);
784         return r;
785 }
786 EXPORT_SYMBOL(fdp_nci_probe);
787
788 void fdp_nci_remove(struct nci_dev *ndev)
789 {
790         struct fdp_nci_info *info = nci_get_drvdata(ndev);
791         struct device *dev = &info->phy->i2c_dev->dev;
792
793         dev_dbg(dev, "%s\n", __func__);
794
795         nci_unregister_device(ndev);
796         nci_free_device(ndev);
797 }
798 EXPORT_SYMBOL(fdp_nci_remove);
799
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>");