[go: up one dir, main page]
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
40struct 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
68static 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
76struct nci_core_get_config_rsp {
77 u8 status;
78 u8 count;
79 u8 data[];
80};
81
82static 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(ndev: info->ndev, FDP_PATCH_CONN_DEST, number_destination_params: 1,
93 params_len: sizeof(param), params: &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
101static inline int fdp_nci_get_versions(struct nci_dev *ndev)
102{
103 return nci_core_cmd(ndev, NCI_OP_CORE_GET_CONFIG_CMD,
104 len: sizeof(nci_core_get_config_otp_ram_version),
105 payload: (__u8 *) &nci_core_get_config_otp_ram_version);
106}
107
108static inline int fdp_nci_patch_cmd(struct nci_dev *ndev, u8 type)
109{
110 return nci_prop_cmd(ndev, NCI_OP_PROP_PATCH_OID, len: sizeof(type), payload: &type);
111}
112
113static 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, payload: data);
117}
118
119static 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, len: 9, data);
142}
143
144static 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 */
159static 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(v: &info->data_pkt_counter, i: 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 */
181static 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, cb: 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, len: (NCI_CTRL_HDR_SIZE + payload_size),
213 GFP_KERNEL);
214 if (!skb) {
215 fdp_nci_set_data_pkt_counter(ndev, NULL, count: 0);
216 return -ENOMEM;
217 }
218
219
220 skb_reserve(skb, NCI_CTRL_HDR_SIZE);
221
222 skb_put_data(skb, data: fw->data + (fw->size - len), 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, count: 0);
228 return rc;
229 }
230
231 len -= payload_size;
232 }
233
234 return rc;
235}
236
237static 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
244static int fdp_nci_close(struct nci_dev *ndev)
245{
246 return 0;
247}
248
249static 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(v: &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
267static 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(fw: &info->ram_patch, FDP_RAM_PATCH_NAME, device: 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(fw: &info->otp_patch, FDP_OTP_PATCH_NAME, device: 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
309static 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(fw: info->otp_patch);
315 info->otp_patch = NULL;
316 }
317
318 if (info->ram_patch) {
319 release_firmware(fw: info->ram_patch);
320 info->ram_patch = NULL;
321 }
322}
323
324static 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(ndev: 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
390static 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(ndev: 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
456static 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
521error:
522 fdp_nci_release_firmware(ndev);
523 nfc_err(dev, "Setup error %d\n", r);
524 return r;
525}
526
527static 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, len: info->fw_vsc_cfg[3],
538 data: &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, clock_type: info->clock_type, clock_freq: 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
567static 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
578static 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
590static 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, result: status);
599
600 return 0;
601}
602
603static 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, result: status);
612
613 return 0;
614}
615
616static 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(p: (__le32 *) p);
634 p += 4;
635 break;
636 case NCI_PARAM_ID_FW_OTP_VERSION:
637 p++;
638 info->otp_version = le32_to_cpup(p: (__le32 *) p);
639 p += 4;
640 break;
641 case NCI_PARAM_ID_OTP_LIMITED_VERSION:
642 p++;
643 info->otp_version = le32_to_cpup(p: (__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, result: rsp->status);
659
660 return 0;
661}
662
663static 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
674static 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
687static 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
699int 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, size: 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(ops: &nci_ops, supported_protocols: 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, data: info);
746
747 return 0;
748
749err_regdev:
750 nci_free_device(ndev);
751 return r;
752}
753EXPORT_SYMBOL(fdp_nci_probe);
754
755void fdp_nci_remove(struct nci_dev *ndev)
756{
757 nci_unregister_device(ndev);
758 nci_free_device(ndev);
759}
760EXPORT_SYMBOL(fdp_nci_remove);
761
762MODULE_LICENSE("GPL");
763MODULE_DESCRIPTION("NFC NCI driver for Intel Fields Peak NFC controller");
764MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");
765
766MODULE_FIRMWARE(FDP_OTP_PATCH_NAME);
767MODULE_FIRMWARE(FDP_RAM_PATCH_NAME);
768

source code of linux/drivers/nfc/fdp/fdp.c