1/* -------------------------------------------------------------------------
2 * Copyright (C) 2014-2016, Intel Corporation
3 *
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.
8 *
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 * -------------------------------------------------------------------------
14 */
15
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>
22
23#include "fdp.h"
24
25#define FDP_OTP_PATCH_NAME "otp.bin"
26#define FDP_RAM_PATCH_NAME "ram.bin"
27#define FDP_FW_HEADER_SIZE 576
28#define FDP_FW_UPDATE_SLEEP 1000
29
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
34
35#define NCI_PATCH_TYPE_RAM 0x00
36#define NCI_PATCH_TYPE_OTP 0x01
37#define NCI_PATCH_TYPE_EOT 0xFF
38
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
43
44#define NCI_GID_PROP 0x0F
45#define NCI_OP_PROP_PATCH_OID 0x08
46#define NCI_OP_PROP_SET_PDATA_OID 0x23
47
48struct fdp_nci_info {
49 struct nfc_phy_ops *phy_ops;
50 struct fdp_i2c_phy *phy;
51 struct nci_dev *ndev;
52
53 const struct firmware *otp_patch;
54 const struct firmware *ram_patch;
55 u32 otp_patch_version;
56 u32 ram_patch_version;
57
58 u32 otp_version;
59 u32 ram_version;
60 u32 limited_otp_version;
61 u8 key_index;
62
63 u8 *fw_vsc_cfg;
64 u8 clock_type;
65 u32 clock_freq;
66
67 atomic_t data_pkt_counter;
68 void (*data_pkt_counter_cb)(struct nci_dev *ndev);
69 u8 setup_patch_sent;
70 u8 setup_patch_ntf;
71 u8 setup_patch_status;
72 u8 setup_reset_ntf;
73 wait_queue_head_t setup_wq;
74};
75
76static u8 nci_core_get_config_otp_ram_version[5] = {
77 0x04,
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
82};
83
84struct nci_core_get_config_rsp {
85 u8 status;
86 u8 count;
87 u8 data[0];
88};
89
90static int fdp_nci_create_conn(struct nci_dev *ndev)
91{
92 struct fdp_nci_info *info = nci_get_drvdata(ndev);
93 struct core_conn_create_dest_spec_params param;
94 int r;
95
96 /* proprietary destination specific paramerer without value */
97 param.type = FDP_PATCH_CONN_PARAM_TYPE;
98 param.length = 0x00;
99
100 r = nci_core_conn_create(info->ndev, FDP_PATCH_CONN_DEST, 1,
101 sizeof(param), &param);
102 if (r)
103 return r;
104
105 return nci_get_conn_info_by_dest_type_params(ndev,
106 FDP_PATCH_CONN_DEST, NULL);
107}
108
109static inline int fdp_nci_get_versions(struct nci_dev *ndev)
110{
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);
114}
115
116static inline int fdp_nci_patch_cmd(struct nci_dev *ndev, u8 type)
117{
118 return nci_prop_cmd(ndev, NCI_OP_PROP_PATCH_OID, sizeof(type), &type);
119}
120
121static inline int fdp_nci_set_production_data(struct nci_dev *ndev, u8 len,
122 char *data)
123{
124 return nci_prop_cmd(ndev, NCI_OP_PROP_SET_PDATA_OID, len, data);
125}
126
127static int fdp_nci_set_clock(struct nci_dev *ndev, u8 clock_type,
128 u32 clock_freq)
129{
130 u32 fc = 13560;
131 u32 nd, num, delta;
132 char data[9];
133
134 nd = (24 * fc) / clock_freq;
135 delta = 24 * fc - nd * clock_freq;
136 num = (32768 * delta) / clock_freq;
137
138 data[0] = 0x00;
139 data[1] = 0x00;
140 data[2] = 0x00;
141
142 data[3] = 0x10;
143 data[4] = 0x04;
144 data[5] = num & 0xFF;
145 data[6] = (num >> 8) & 0xff;
146 data[7] = nd;
147 data[8] = clock_type;
148
149 return fdp_nci_set_production_data(ndev, 9, data);
150}
151
152static void fdp_nci_send_patch_cb(struct nci_dev *ndev)
153{
154 struct fdp_nci_info *info = nci_get_drvdata(ndev);
155
156 info->setup_patch_sent = 1;
157 wake_up(&info->setup_wq);
158}
159
160/**
161 * Register a packet sent counter and a callback
162 *
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.
166 */
167static void fdp_nci_set_data_pkt_counter(struct nci_dev *ndev,
168 void (*cb)(struct nci_dev *ndev), int count)
169{
170 struct fdp_nci_info *info = nci_get_drvdata(ndev);
171 struct device *dev = &info->phy->i2c_dev->dev;
172
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;
176}
177
178/**
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.
184 *
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.
188 */
189static int fdp_nci_send_patch(struct nci_dev *ndev, u8 conn_id, u8 type)
190{
191 struct fdp_nci_info *info = nci_get_drvdata(ndev);
192 const struct firmware *fw;
193 struct sk_buff *skb;
194 unsigned long len;
195 u8 max_size, payload_size;
196 int rc = 0;
197
198 if ((type == NCI_PATCH_TYPE_OTP && !info->otp_patch) ||
199 (type == NCI_PATCH_TYPE_RAM && !info->ram_patch))
200 return -EINVAL;
201
202 if (type == NCI_PATCH_TYPE_OTP)
203 fw = info->otp_patch;
204 else
205 fw = info->ram_patch;
206
207 max_size = nci_conn_max_data_pkt_payload_size(ndev, conn_id);
208 if (max_size <= 0)
209 return -EINVAL;
210
211 len = fw->size;
212
213 fdp_nci_set_data_pkt_counter(ndev, fdp_nci_send_patch_cb,
214 DIV_ROUND_UP(fw->size, max_size));
215
216 while (len) {
217
218 payload_size = min_t(unsigned long, (unsigned long) max_size,
219 len);
220
221 skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + payload_size),
222 GFP_KERNEL);
223 if (!skb) {
224 fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
225 return -ENOMEM;
226 }
227
228
229 skb_reserve(skb, NCI_CTRL_HDR_SIZE);
230
231 skb_put_data(skb, fw->data + (fw->size - len), payload_size);
232
233 rc = nci_send_data(ndev, conn_id, skb);
234
235 if (rc) {
236 fdp_nci_set_data_pkt_counter(ndev, NULL, 0);
237 return rc;
238 }
239
240 len -= payload_size;
241 }
242
243 return rc;
244}
245
246static int fdp_nci_open(struct nci_dev *ndev)
247{
248 int r;
249 struct fdp_nci_info *info = nci_get_drvdata(ndev);
250 struct device *dev = &info->phy->i2c_dev->dev;
251
252 dev_dbg(dev, "%s\n", __func__);
253
254 r = info->phy_ops->enable(info->phy);
255
256 return r;
257}
258
259static int fdp_nci_close(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
264 dev_dbg(dev, "%s\n", __func__);
265 return 0;
266}
267
268static int fdp_nci_send(struct nci_dev *ndev, struct sk_buff *skb)
269{
270 struct fdp_nci_info *info = nci_get_drvdata(ndev);
271 struct device *dev = &info->phy->i2c_dev->dev;
272
273 dev_dbg(dev, "%s\n", __func__);
274
275 if (atomic_dec_and_test(&info->data_pkt_counter))
276 info->data_pkt_counter_cb(ndev);
277
278 return info->phy_ops->write(info->phy, skb);
279}
280
281int fdp_nci_recv_frame(struct nci_dev *ndev, struct sk_buff *skb)
282{
283 struct fdp_nci_info *info = nci_get_drvdata(ndev);
284 struct device *dev = &info->phy->i2c_dev->dev;
285
286 dev_dbg(dev, "%s\n", __func__);
287 return nci_recv_frame(ndev, skb);
288}
289EXPORT_SYMBOL(fdp_nci_recv_frame);
290
291static int fdp_nci_request_firmware(struct nci_dev *ndev)
292{
293 struct fdp_nci_info *info = nci_get_drvdata(ndev);
294 struct device *dev = &info->phy->i2c_dev->dev;
295 u8 *data;
296 int r;
297
298 r = request_firmware(&info->ram_patch, FDP_RAM_PATCH_NAME, dev);
299 if (r < 0) {
300 nfc_err(dev, "RAM patch request error\n");
301 goto error;
302 }
303
304 data = (u8 *) info->ram_patch->data;
305 info->ram_patch_version =
306 data[FDP_FW_HEADER_SIZE] |
307 (data[FDP_FW_HEADER_SIZE + 1] << 8) |
308 (data[FDP_FW_HEADER_SIZE + 2] << 16) |
309 (data[FDP_FW_HEADER_SIZE + 3] << 24);
310
311 dev_dbg(dev, "RAM patch version: %d, size: %d\n",
312 info->ram_patch_version, (int) info->ram_patch->size);
313
314
315 r = request_firmware(&info->otp_patch, FDP_OTP_PATCH_NAME, dev);
316 if (r < 0) {
317 nfc_err(dev, "OTP patch request error\n");
318 goto out;
319 }
320
321 data = (u8 *) info->otp_patch->data;
322 info->otp_patch_version =
323 data[FDP_FW_HEADER_SIZE] |
324 (data[FDP_FW_HEADER_SIZE + 1] << 8) |
325 (data[FDP_FW_HEADER_SIZE+2] << 16) |
326 (data[FDP_FW_HEADER_SIZE+3] << 24);
327
328 dev_dbg(dev, "OTP patch version: %d, size: %d\n",
329 info->otp_patch_version, (int) info->otp_patch->size);
330out:
331 return 0;
332error:
333 return r;
334}
335
336static void fdp_nci_release_firmware(struct nci_dev *ndev)
337{
338 struct fdp_nci_info *info = nci_get_drvdata(ndev);
339
340 if (info->otp_patch) {
341 release_firmware(info->otp_patch);
342 info->otp_patch = NULL;
343 }
344
345 if (info->ram_patch) {
346 release_firmware(info->ram_patch);
347 info->ram_patch = NULL;
348 }
349}
350
351static int fdp_nci_patch_otp(struct nci_dev *ndev)
352{
353 struct fdp_nci_info *info = nci_get_drvdata(ndev);
354 struct device *dev = &info->phy->i2c_dev->dev;
355 int conn_id;
356 int r = 0;
357
358 if (info->otp_version >= info->otp_patch_version)
359 goto out;
360
361 info->setup_patch_sent = 0;
362 info->setup_reset_ntf = 0;
363 info->setup_patch_ntf = 0;
364
365 /* Patch init request */
366 r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_OTP);
367 if (r)
368 goto out;
369
370 /* Patch data connection creation */
371 conn_id = fdp_nci_create_conn(ndev);
372 if (conn_id < 0) {
373 r = conn_id;
374 goto out;
375 }
376
377 /* Send the patch over the data connection */
378 r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_OTP);
379 if (r)
380 goto out;
381
382 /* Wait for all the packets to be send over i2c */
383 wait_event_interruptible(info->setup_wq,
384 info->setup_patch_sent == 1);
385
386 /* make sure that the NFCC processed the last data packet */
387 msleep(FDP_FW_UPDATE_SLEEP);
388
389 /* Close the data connection */
390 r = nci_core_conn_close(info->ndev, conn_id);
391 if (r)
392 goto out;
393
394 /* Patch finish message */
395 if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
396 nfc_err(dev, "OTP patch error 0x%x\n", r);
397 r = -EINVAL;
398 goto out;
399 }
400
401 /* If the patch notification didn't arrive yet, wait for it */
402 wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
403
404 /* Check if the patching was successful */
405 r = info->setup_patch_status;
406 if (r) {
407 nfc_err(dev, "OTP patch error 0x%x\n", r);
408 r = -EINVAL;
409 goto out;
410 }
411
412 /*
413 * We need to wait for the reset notification before we
414 * can continue
415 */
416 wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
417
418out:
419 return r;
420}
421
422static int fdp_nci_patch_ram(struct nci_dev *ndev)
423{
424 struct fdp_nci_info *info = nci_get_drvdata(ndev);
425 struct device *dev = &info->phy->i2c_dev->dev;
426 int conn_id;
427 int r = 0;
428
429 if (info->ram_version >= info->ram_patch_version)
430 goto out;
431
432 info->setup_patch_sent = 0;
433 info->setup_reset_ntf = 0;
434 info->setup_patch_ntf = 0;
435
436 /* Patch init request */
437 r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_RAM);
438 if (r)
439 goto out;
440
441 /* Patch data connection creation */
442 conn_id = fdp_nci_create_conn(ndev);
443 if (conn_id < 0) {
444 r = conn_id;
445 goto out;
446 }
447
448 /* Send the patch over the data connection */
449 r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_RAM);
450 if (r)
451 goto out;
452
453 /* Wait for all the packets to be send over i2c */
454 wait_event_interruptible(info->setup_wq,
455 info->setup_patch_sent == 1);
456
457 /* make sure that the NFCC processed the last data packet */
458 msleep(FDP_FW_UPDATE_SLEEP);
459
460 /* Close the data connection */
461 r = nci_core_conn_close(info->ndev, conn_id);
462 if (r)
463 goto out;
464
465 /* Patch finish message */
466 if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) {
467 nfc_err(dev, "RAM patch error 0x%x\n", r);
468 r = -EINVAL;
469 goto out;
470 }
471
472 /* If the patch notification didn't arrive yet, wait for it */
473 wait_event_interruptible(info->setup_wq, info->setup_patch_ntf);
474
475 /* Check if the patching was successful */
476 r = info->setup_patch_status;
477 if (r) {
478 nfc_err(dev, "RAM patch error 0x%x\n", r);
479 r = -EINVAL;
480 goto out;
481 }
482
483 /*
484 * We need to wait for the reset notification before we
485 * can continue
486 */
487 wait_event_interruptible(info->setup_wq, info->setup_reset_ntf);
488
489out:
490 return r;
491}
492
493static int fdp_nci_setup(struct nci_dev *ndev)
494{
495 /* Format: total length followed by an NCI packet */
496 struct fdp_nci_info *info = nci_get_drvdata(ndev);
497 struct device *dev = &info->phy->i2c_dev->dev;
498 int r;
499 u8 patched = 0;
500
501 dev_dbg(dev, "%s\n", __func__);
502
503 r = nci_core_init(ndev);
504 if (r)
505 goto error;
506
507 /* Get RAM and OTP version */
508 r = fdp_nci_get_versions(ndev);
509 if (r)
510 goto error;
511
512 /* Load firmware from disk */
513 r = fdp_nci_request_firmware(ndev);
514 if (r)
515 goto error;
516
517 /* Update OTP */
518 if (info->otp_version < info->otp_patch_version) {
519 r = fdp_nci_patch_otp(ndev);
520 if (r)
521 goto error;
522 patched = 1;
523 }
524
525 /* Update RAM */
526 if (info->ram_version < info->ram_patch_version) {
527 r = fdp_nci_patch_ram(ndev);
528 if (r)
529 goto error;
530 patched = 1;
531 }
532
533 /* Release the firmware buffers */
534 fdp_nci_release_firmware(ndev);
535
536 /* If a patch was applied the new version is checked */
537 if (patched) {
538 r = nci_core_init(ndev);
539 if (r)
540 goto error;
541
542 r = fdp_nci_get_versions(ndev);
543 if (r)
544 goto error;
545
546 if (info->otp_version != info->otp_patch_version ||
547 info->ram_version != info->ram_patch_version) {
548 nfc_err(dev, "Firmware update failed");
549 r = -EINVAL;
550 goto error;
551 }
552 }
553
554 /*
555 * We initialized the devices but the NFC subsystem expects
556 * it to not be initialized.
557 */
558 return nci_core_reset(ndev);
559
560error:
561 fdp_nci_release_firmware(ndev);
562 nfc_err(dev, "Setup error %d\n", r);
563 return r;
564}
565
566static int fdp_nci_post_setup(struct nci_dev *ndev)
567{
568 struct fdp_nci_info *info = nci_get_drvdata(ndev);
569 struct device *dev = &info->phy->i2c_dev->dev;
570 int r;
571
572 /* Check if the device has VSC */
573 if (info->fw_vsc_cfg && info->fw_vsc_cfg[0]) {
574
575 /* Set the vendor specific configuration */
576 r = fdp_nci_set_production_data(ndev, info->fw_vsc_cfg[3],
577 &info->fw_vsc_cfg[4]);
578 if (r) {
579 nfc_err(dev, "Vendor specific config set error %d\n",
580 r);
581 return r;
582 }
583 }
584
585 /* Set clock type and frequency */
586 r = fdp_nci_set_clock(ndev, info->clock_type, info->clock_freq);
587 if (r) {
588 nfc_err(dev, "Clock set error %d\n", r);
589 return r;
590 }
591
592 /*
593 * In order to apply the VSC FDP needs a reset
594 */
595 r = nci_core_reset(ndev);
596 if (r)
597 return r;
598
599 /**
600 * The nci core was initialized when post setup was called
601 * so we leave it like that
602 */
603 return nci_core_init(ndev);
604}
605
606static int fdp_nci_core_reset_ntf_packet(struct nci_dev *ndev,
607 struct sk_buff *skb)
608{
609 struct fdp_nci_info *info = nci_get_drvdata(ndev);
610 struct device *dev = &info->phy->i2c_dev->dev;
611
612 dev_dbg(dev, "%s\n", __func__);
613 info->setup_reset_ntf = 1;
614 wake_up(&info->setup_wq);
615
616 return 0;
617}
618
619static int fdp_nci_prop_patch_ntf_packet(struct nci_dev *ndev,
620 struct sk_buff *skb)
621{
622 struct fdp_nci_info *info = nci_get_drvdata(ndev);
623 struct device *dev = &info->phy->i2c_dev->dev;
624
625 dev_dbg(dev, "%s\n", __func__);
626 info->setup_patch_ntf = 1;
627 info->setup_patch_status = skb->data[0];
628 wake_up(&info->setup_wq);
629
630 return 0;
631}
632
633static int fdp_nci_prop_patch_rsp_packet(struct nci_dev *ndev,
634 struct sk_buff *skb)
635{
636 struct fdp_nci_info *info = nci_get_drvdata(ndev);
637 struct device *dev = &info->phy->i2c_dev->dev;
638 u8 status = skb->data[0];
639
640 dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
641 nci_req_complete(ndev, status);
642
643 return 0;
644}
645
646static int fdp_nci_prop_set_production_data_rsp_packet(struct nci_dev *ndev,
647 struct sk_buff *skb)
648{
649 struct fdp_nci_info *info = nci_get_drvdata(ndev);
650 struct device *dev = &info->phy->i2c_dev->dev;
651 u8 status = skb->data[0];
652
653 dev_dbg(dev, "%s: status 0x%x\n", __func__, status);
654 nci_req_complete(ndev, status);
655
656 return 0;
657}
658
659static int fdp_nci_core_get_config_rsp_packet(struct nci_dev *ndev,
660 struct sk_buff *skb)
661{
662 struct fdp_nci_info *info = nci_get_drvdata(ndev);
663 struct device *dev = &info->phy->i2c_dev->dev;
664 struct nci_core_get_config_rsp *rsp = (void *) skb->data;
665 u8 i, *p;
666
667 if (rsp->status == NCI_STATUS_OK) {
668
669 p = rsp->data;
670 for (i = 0; i < 4; i++) {
671
672 switch (*p++) {
673 case NCI_PARAM_ID_FW_RAM_VERSION:
674 p++;
675 info->ram_version = le32_to_cpup((__le32 *) p);
676 p += 4;
677 break;
678 case NCI_PARAM_ID_FW_OTP_VERSION:
679 p++;
680 info->otp_version = le32_to_cpup((__le32 *) p);
681 p += 4;
682 break;
683 case NCI_PARAM_ID_OTP_LIMITED_VERSION:
684 p++;
685 info->otp_version = le32_to_cpup((__le32 *) p);
686 p += 4;
687 break;
688 case NCI_PARAM_ID_KEY_INDEX_ID:
689 p++;
690 info->key_index = *p++;
691 }
692 }
693 }
694
695 dev_dbg(dev, "OTP version %d\n", info->otp_version);
696 dev_dbg(dev, "RAM version %d\n", info->ram_version);
697 dev_dbg(dev, "key index %d\n", info->key_index);
698 dev_dbg(dev, "%s: status 0x%x\n", __func__, rsp->status);
699
700 nci_req_complete(ndev, rsp->status);
701
702 return 0;
703}
704
705static struct nci_driver_ops fdp_core_ops[] = {
706 {
707 .opcode = NCI_OP_CORE_GET_CONFIG_RSP,
708 .rsp = fdp_nci_core_get_config_rsp_packet,
709 },
710 {
711 .opcode = NCI_OP_CORE_RESET_NTF,
712 .ntf = fdp_nci_core_reset_ntf_packet,
713 },
714};
715
716static struct nci_driver_ops fdp_prop_ops[] = {
717 {
718 .opcode = nci_opcode_pack(NCI_GID_PROP, NCI_OP_PROP_PATCH_OID),
719 .rsp = fdp_nci_prop_patch_rsp_packet,
720 .ntf = fdp_nci_prop_patch_ntf_packet,
721 },
722 {
723 .opcode = nci_opcode_pack(NCI_GID_PROP,
724 NCI_OP_PROP_SET_PDATA_OID),
725 .rsp = fdp_nci_prop_set_production_data_rsp_packet,
726 },
727};
728
729static struct nci_ops nci_ops = {
730 .open = fdp_nci_open,
731 .close = fdp_nci_close,
732 .send = fdp_nci_send,
733 .setup = fdp_nci_setup,
734 .post_setup = fdp_nci_post_setup,
735 .prop_ops = fdp_prop_ops,
736 .n_prop_ops = ARRAY_SIZE(fdp_prop_ops),
737 .core_ops = fdp_core_ops,
738 .n_core_ops = ARRAY_SIZE(fdp_core_ops),
739};
740
741int fdp_nci_probe(struct fdp_i2c_phy *phy, struct nfc_phy_ops *phy_ops,
742 struct nci_dev **ndevp, int tx_headroom,
743 int tx_tailroom, u8 clock_type, u32 clock_freq,
744 u8 *fw_vsc_cfg)
745{
746 struct device *dev = &phy->i2c_dev->dev;
747 struct fdp_nci_info *info;
748 struct nci_dev *ndev;
749 u32 protocols;
750 int r;
751
752 info = devm_kzalloc(dev, sizeof(struct fdp_nci_info), GFP_KERNEL);
753 if (!info)
754 return -ENOMEM;
755
756 info->phy = phy;
757 info->phy_ops = phy_ops;
758 info->clock_type = clock_type;
759 info->clock_freq = clock_freq;
760 info->fw_vsc_cfg = fw_vsc_cfg;
761
762 init_waitqueue_head(&info->setup_wq);
763
764 protocols = NFC_PROTO_JEWEL_MASK |
765 NFC_PROTO_MIFARE_MASK |
766 NFC_PROTO_FELICA_MASK |
767 NFC_PROTO_ISO14443_MASK |
768 NFC_PROTO_ISO14443_B_MASK |
769 NFC_PROTO_NFC_DEP_MASK |
770 NFC_PROTO_ISO15693_MASK;
771
772 ndev = nci_allocate_device(&nci_ops, protocols, tx_headroom,
773 tx_tailroom);
774 if (!ndev) {
775 nfc_err(dev, "Cannot allocate nfc ndev\n");
776 return -ENOMEM;
777 }
778
779 r = nci_register_device(ndev);
780 if (r)
781 goto err_regdev;
782
783 *ndevp = ndev;
784 info->ndev = ndev;
785
786 nci_set_drvdata(ndev, info);
787
788 return 0;
789
790err_regdev:
791 nci_free_device(ndev);
792 return r;
793}
794EXPORT_SYMBOL(fdp_nci_probe);
795
796void fdp_nci_remove(struct nci_dev *ndev)
797{
798 struct fdp_nci_info *info = nci_get_drvdata(ndev);
799 struct device *dev = &info->phy->i2c_dev->dev;
800
801 dev_dbg(dev, "%s\n", __func__);
802
803 nci_unregister_device(ndev);
804 nci_free_device(ndev);
805}
806EXPORT_SYMBOL(fdp_nci_remove);
807
808MODULE_LICENSE("GPL");
809MODULE_DESCRIPTION("NFC NCI driver for Intel Fields Peak NFC controller");
810MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");
811