2 * NFC Digital Protocol stack
3 * Copyright (c) 2013, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 #define pr_fmt(fmt) "digital: %s: " fmt, __func__
18 #include <linux/module.h>
22 #define DIGITAL_PROTO_NFCA_RF_TECH \
23 (NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK | NFC_PROTO_NFC_DEP_MASK)
25 #define DIGITAL_PROTO_NFCB_RF_TECH NFC_PROTO_ISO14443_B_MASK
27 #define DIGITAL_PROTO_NFCF_RF_TECH \
28 (NFC_PROTO_FELICA_MASK | NFC_PROTO_NFC_DEP_MASK)
30 #define DIGITAL_PROTO_ISO15693_RF_TECH NFC_PROTO_ISO15693_MASK
33 struct list_head queue
;
41 struct digital_tg_mdaa_params
*mdaa_params
;
43 nfc_digital_cmd_complete_t cmd_cb
;
47 struct sk_buff
*digital_skb_alloc(struct nfc_digital_dev
*ddev
,
52 skb
= alloc_skb(len
+ ddev
->tx_headroom
+ ddev
->tx_tailroom
,
55 skb_reserve(skb
, ddev
->tx_headroom
);
60 void digital_skb_add_crc(struct sk_buff
*skb
, crc_func_t crc_func
, u16 init
,
61 u8 bitwise_inv
, u8 msb_first
)
65 crc
= crc_func(init
, skb
->data
, skb
->len
);
73 *skb_put(skb
, 1) = crc
& 0xFF;
74 *skb_put(skb
, 1) = (crc
>> 8) & 0xFF;
77 int digital_skb_check_crc(struct sk_buff
*skb
, crc_func_t crc_func
,
78 u16 crc_init
, u8 bitwise_inv
, u8 msb_first
)
86 crc
= crc_func(crc_init
, skb
->data
, skb
->len
- 2);
94 rc
= (skb
->data
[skb
->len
- 2] - (crc
& 0xFF)) +
95 (skb
->data
[skb
->len
- 1] - ((crc
>> 8) & 0xFF));
100 skb_trim(skb
, skb
->len
- 2);
105 static inline void digital_switch_rf(struct nfc_digital_dev
*ddev
, bool on
)
107 ddev
->ops
->switch_rf(ddev
, on
);
110 static inline void digital_abort_cmd(struct nfc_digital_dev
*ddev
)
112 ddev
->ops
->abort_cmd(ddev
);
115 static void digital_wq_cmd_complete(struct work_struct
*work
)
117 struct digital_cmd
*cmd
;
118 struct nfc_digital_dev
*ddev
= container_of(work
,
119 struct nfc_digital_dev
,
122 mutex_lock(&ddev
->cmd_lock
);
124 cmd
= list_first_entry_or_null(&ddev
->cmd_queue
, struct digital_cmd
,
127 mutex_unlock(&ddev
->cmd_lock
);
131 list_del(&cmd
->queue
);
133 mutex_unlock(&ddev
->cmd_lock
);
135 if (!IS_ERR(cmd
->resp
))
136 print_hex_dump_debug("DIGITAL RX: ", DUMP_PREFIX_NONE
, 16, 1,
137 cmd
->resp
->data
, cmd
->resp
->len
, false);
139 cmd
->cmd_cb(ddev
, cmd
->cb_context
, cmd
->resp
);
141 kfree(cmd
->mdaa_params
);
144 schedule_work(&ddev
->cmd_work
);
147 static void digital_send_cmd_complete(struct nfc_digital_dev
*ddev
,
148 void *arg
, struct sk_buff
*resp
)
150 struct digital_cmd
*cmd
= arg
;
154 schedule_work(&ddev
->cmd_complete_work
);
157 static void digital_wq_cmd(struct work_struct
*work
)
160 struct digital_cmd
*cmd
;
161 struct digital_tg_mdaa_params
*params
;
162 struct nfc_digital_dev
*ddev
= container_of(work
,
163 struct nfc_digital_dev
,
166 mutex_lock(&ddev
->cmd_lock
);
168 cmd
= list_first_entry_or_null(&ddev
->cmd_queue
, struct digital_cmd
,
170 if (!cmd
|| cmd
->pending
) {
171 mutex_unlock(&ddev
->cmd_lock
);
175 mutex_unlock(&ddev
->cmd_lock
);
178 print_hex_dump_debug("DIGITAL TX: ", DUMP_PREFIX_NONE
, 16, 1,
179 cmd
->req
->data
, cmd
->req
->len
, false);
182 case DIGITAL_CMD_IN_SEND
:
183 rc
= ddev
->ops
->in_send_cmd(ddev
, cmd
->req
, cmd
->timeout
,
184 digital_send_cmd_complete
, cmd
);
187 case DIGITAL_CMD_TG_SEND
:
188 rc
= ddev
->ops
->tg_send_cmd(ddev
, cmd
->req
, cmd
->timeout
,
189 digital_send_cmd_complete
, cmd
);
192 case DIGITAL_CMD_TG_LISTEN
:
193 rc
= ddev
->ops
->tg_listen(ddev
, cmd
->timeout
,
194 digital_send_cmd_complete
, cmd
);
197 case DIGITAL_CMD_TG_LISTEN_MDAA
:
198 params
= cmd
->mdaa_params
;
200 rc
= ddev
->ops
->tg_listen_mdaa(ddev
, params
, cmd
->timeout
,
201 digital_send_cmd_complete
, cmd
);
205 pr_err("Unknown cmd type %d\n", cmd
->type
);
212 pr_err("in_send_command returned err %d\n", rc
);
214 mutex_lock(&ddev
->cmd_lock
);
215 list_del(&cmd
->queue
);
216 mutex_unlock(&ddev
->cmd_lock
);
219 kfree(cmd
->mdaa_params
);
222 schedule_work(&ddev
->cmd_work
);
225 int digital_send_cmd(struct nfc_digital_dev
*ddev
, u8 cmd_type
,
226 struct sk_buff
*skb
, struct digital_tg_mdaa_params
*params
,
227 u16 timeout
, nfc_digital_cmd_complete_t cmd_cb
,
230 struct digital_cmd
*cmd
;
232 cmd
= kzalloc(sizeof(struct digital_cmd
), GFP_KERNEL
);
236 cmd
->type
= cmd_type
;
237 cmd
->timeout
= timeout
;
239 cmd
->mdaa_params
= params
;
240 cmd
->cmd_cb
= cmd_cb
;
241 cmd
->cb_context
= cb_context
;
242 INIT_LIST_HEAD(&cmd
->queue
);
244 mutex_lock(&ddev
->cmd_lock
);
245 list_add_tail(&cmd
->queue
, &ddev
->cmd_queue
);
246 mutex_unlock(&ddev
->cmd_lock
);
248 schedule_work(&ddev
->cmd_work
);
253 int digital_in_configure_hw(struct nfc_digital_dev
*ddev
, int type
, int param
)
257 rc
= ddev
->ops
->in_configure_hw(ddev
, type
, param
);
259 pr_err("in_configure_hw failed: %d\n", rc
);
264 int digital_tg_configure_hw(struct nfc_digital_dev
*ddev
, int type
, int param
)
268 rc
= ddev
->ops
->tg_configure_hw(ddev
, type
, param
);
270 pr_err("tg_configure_hw failed: %d\n", rc
);
275 static int digital_tg_listen_mdaa(struct nfc_digital_dev
*ddev
, u8 rf_tech
)
277 struct digital_tg_mdaa_params
*params
;
279 params
= kzalloc(sizeof(struct digital_tg_mdaa_params
), GFP_KERNEL
);
283 params
->sens_res
= DIGITAL_SENS_RES_NFC_DEP
;
284 get_random_bytes(params
->nfcid1
, sizeof(params
->nfcid1
));
285 params
->sel_res
= DIGITAL_SEL_RES_NFC_DEP
;
287 params
->nfcid2
[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1
;
288 params
->nfcid2
[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2
;
289 get_random_bytes(params
->nfcid2
+ 2, NFC_NFCID2_MAXSIZE
- 2);
290 params
->sc
= DIGITAL_SENSF_FELICA_SC
;
292 return digital_send_cmd(ddev
, DIGITAL_CMD_TG_LISTEN_MDAA
, NULL
, params
,
293 500, digital_tg_recv_atr_req
, NULL
);
296 int digital_target_found(struct nfc_digital_dev
*ddev
,
297 struct nfc_target
*target
, u8 protocol
)
303 int (*check_crc
)(struct sk_buff
*skb
);
304 void (*add_crc
)(struct sk_buff
*skb
);
306 rf_tech
= ddev
->poll_techs
[ddev
->poll_tech_index
].rf_tech
;
309 case NFC_PROTO_JEWEL
:
310 framing
= NFC_DIGITAL_FRAMING_NFCA_T1T
;
311 check_crc
= digital_skb_check_crc_b
;
312 add_crc
= digital_skb_add_crc_b
;
315 case NFC_PROTO_MIFARE
:
316 framing
= NFC_DIGITAL_FRAMING_NFCA_T2T
;
317 check_crc
= digital_skb_check_crc_a
;
318 add_crc
= digital_skb_add_crc_a
;
321 case NFC_PROTO_FELICA
:
322 framing
= NFC_DIGITAL_FRAMING_NFCF_T3T
;
323 check_crc
= digital_skb_check_crc_f
;
324 add_crc
= digital_skb_add_crc_f
;
327 case NFC_PROTO_NFC_DEP
:
328 if (rf_tech
== NFC_DIGITAL_RF_TECH_106A
) {
329 framing
= NFC_DIGITAL_FRAMING_NFCA_NFC_DEP
;
330 check_crc
= digital_skb_check_crc_a
;
331 add_crc
= digital_skb_add_crc_a
;
333 framing
= NFC_DIGITAL_FRAMING_NFCF_NFC_DEP
;
334 check_crc
= digital_skb_check_crc_f
;
335 add_crc
= digital_skb_add_crc_f
;
339 case NFC_PROTO_ISO15693
:
340 framing
= NFC_DIGITAL_FRAMING_ISO15693_T5T
;
341 check_crc
= digital_skb_check_crc_b
;
342 add_crc
= digital_skb_add_crc_b
;
345 case NFC_PROTO_ISO14443
:
346 framing
= NFC_DIGITAL_FRAMING_NFCA_T4T
;
347 check_crc
= digital_skb_check_crc_a
;
348 add_crc
= digital_skb_add_crc_a
;
351 case NFC_PROTO_ISO14443_B
:
352 framing
= NFC_DIGITAL_FRAMING_NFCB_T4T
;
353 check_crc
= digital_skb_check_crc_b
;
354 add_crc
= digital_skb_add_crc_b
;
358 pr_err("Invalid protocol %d\n", protocol
);
362 pr_debug("rf_tech=%d, protocol=%d\n", rf_tech
, protocol
);
364 ddev
->curr_rf_tech
= rf_tech
;
366 if (DIGITAL_DRV_CAPS_IN_CRC(ddev
)) {
367 ddev
->skb_add_crc
= digital_skb_add_crc_none
;
368 ddev
->skb_check_crc
= digital_skb_check_crc_none
;
370 ddev
->skb_add_crc
= add_crc
;
371 ddev
->skb_check_crc
= check_crc
;
374 rc
= digital_in_configure_hw(ddev
, NFC_DIGITAL_CONFIG_FRAMING
, framing
);
378 target
->supported_protocols
= (1 << protocol
);
380 poll_tech_count
= ddev
->poll_tech_count
;
381 ddev
->poll_tech_count
= 0;
383 rc
= nfc_targets_found(ddev
->nfc_dev
, target
, 1);
385 ddev
->poll_tech_count
= poll_tech_count
;
392 void digital_poll_next_tech(struct nfc_digital_dev
*ddev
)
396 digital_switch_rf(ddev
, 0);
398 mutex_lock(&ddev
->poll_lock
);
400 if (!ddev
->poll_tech_count
) {
401 mutex_unlock(&ddev
->poll_lock
);
405 get_random_bytes(&rand_mod
, sizeof(rand_mod
));
406 ddev
->poll_tech_index
= rand_mod
% ddev
->poll_tech_count
;
408 mutex_unlock(&ddev
->poll_lock
);
410 schedule_work(&ddev
->poll_work
);
413 static void digital_wq_poll(struct work_struct
*work
)
416 struct digital_poll_tech
*poll_tech
;
417 struct nfc_digital_dev
*ddev
= container_of(work
,
418 struct nfc_digital_dev
,
420 mutex_lock(&ddev
->poll_lock
);
422 if (!ddev
->poll_tech_count
) {
423 mutex_unlock(&ddev
->poll_lock
);
427 poll_tech
= &ddev
->poll_techs
[ddev
->poll_tech_index
];
429 mutex_unlock(&ddev
->poll_lock
);
431 rc
= poll_tech
->poll_func(ddev
, poll_tech
->rf_tech
);
433 digital_poll_next_tech(ddev
);
436 static void digital_add_poll_tech(struct nfc_digital_dev
*ddev
, u8 rf_tech
,
437 digital_poll_t poll_func
)
439 struct digital_poll_tech
*poll_tech
;
441 if (ddev
->poll_tech_count
>= NFC_DIGITAL_POLL_MODE_COUNT_MAX
)
444 poll_tech
= &ddev
->poll_techs
[ddev
->poll_tech_count
++];
446 poll_tech
->rf_tech
= rf_tech
;
447 poll_tech
->poll_func
= poll_func
;
451 * start_poll operation
453 * For every supported protocol, the corresponding polling function is added
454 * to the table of polling technologies (ddev->poll_techs[]) using
455 * digital_add_poll_tech().
456 * When a polling function fails (by timeout or protocol error) the next one is
457 * schedule by digital_poll_next_tech() on the poll workqueue (ddev->poll_work).
459 static int digital_start_poll(struct nfc_dev
*nfc_dev
, __u32 im_protocols
,
462 struct nfc_digital_dev
*ddev
= nfc_get_drvdata(nfc_dev
);
463 u32 matching_im_protocols
, matching_tm_protocols
;
465 pr_debug("protocols: im 0x%x, tm 0x%x, supported 0x%x\n", im_protocols
,
466 tm_protocols
, ddev
->protocols
);
468 matching_im_protocols
= ddev
->protocols
& im_protocols
;
469 matching_tm_protocols
= ddev
->protocols
& tm_protocols
;
471 if (!matching_im_protocols
&& !matching_tm_protocols
) {
472 pr_err("Unknown protocol\n");
476 if (ddev
->poll_tech_count
) {
477 pr_err("Already polling\n");
481 if (ddev
->curr_protocol
) {
482 pr_err("A target is already active\n");
486 ddev
->poll_tech_count
= 0;
487 ddev
->poll_tech_index
= 0;
489 if (matching_im_protocols
& DIGITAL_PROTO_NFCA_RF_TECH
)
490 digital_add_poll_tech(ddev
, NFC_DIGITAL_RF_TECH_106A
,
491 digital_in_send_sens_req
);
493 if (matching_im_protocols
& DIGITAL_PROTO_NFCB_RF_TECH
)
494 digital_add_poll_tech(ddev
, NFC_DIGITAL_RF_TECH_106B
,
495 digital_in_send_sensb_req
);
497 if (matching_im_protocols
& DIGITAL_PROTO_NFCF_RF_TECH
) {
498 digital_add_poll_tech(ddev
, NFC_DIGITAL_RF_TECH_212F
,
499 digital_in_send_sensf_req
);
501 digital_add_poll_tech(ddev
, NFC_DIGITAL_RF_TECH_424F
,
502 digital_in_send_sensf_req
);
505 if (matching_im_protocols
& DIGITAL_PROTO_ISO15693_RF_TECH
)
506 digital_add_poll_tech(ddev
, NFC_DIGITAL_RF_TECH_ISO15693
,
507 digital_in_send_iso15693_inv_req
);
509 if (matching_tm_protocols
& NFC_PROTO_NFC_DEP_MASK
) {
510 if (ddev
->ops
->tg_listen_mdaa
) {
511 digital_add_poll_tech(ddev
, 0,
512 digital_tg_listen_mdaa
);
514 digital_add_poll_tech(ddev
, NFC_DIGITAL_RF_TECH_106A
,
515 digital_tg_listen_nfca
);
517 digital_add_poll_tech(ddev
, NFC_DIGITAL_RF_TECH_212F
,
518 digital_tg_listen_nfcf
);
520 digital_add_poll_tech(ddev
, NFC_DIGITAL_RF_TECH_424F
,
521 digital_tg_listen_nfcf
);
525 if (!ddev
->poll_tech_count
) {
526 pr_err("Unsupported protocols: im=0x%x, tm=0x%x\n",
527 matching_im_protocols
, matching_tm_protocols
);
531 schedule_work(&ddev
->poll_work
);
536 static void digital_stop_poll(struct nfc_dev
*nfc_dev
)
538 struct nfc_digital_dev
*ddev
= nfc_get_drvdata(nfc_dev
);
540 mutex_lock(&ddev
->poll_lock
);
542 if (!ddev
->poll_tech_count
) {
543 pr_err("Polling operation was not running\n");
544 mutex_unlock(&ddev
->poll_lock
);
548 ddev
->poll_tech_count
= 0;
550 mutex_unlock(&ddev
->poll_lock
);
552 cancel_work_sync(&ddev
->poll_work
);
554 digital_abort_cmd(ddev
);
557 static int digital_dev_up(struct nfc_dev
*nfc_dev
)
559 struct nfc_digital_dev
*ddev
= nfc_get_drvdata(nfc_dev
);
561 digital_switch_rf(ddev
, 1);
566 static int digital_dev_down(struct nfc_dev
*nfc_dev
)
568 struct nfc_digital_dev
*ddev
= nfc_get_drvdata(nfc_dev
);
570 digital_switch_rf(ddev
, 0);
575 static int digital_dep_link_up(struct nfc_dev
*nfc_dev
,
576 struct nfc_target
*target
,
577 __u8 comm_mode
, __u8
*gb
, size_t gb_len
)
579 struct nfc_digital_dev
*ddev
= nfc_get_drvdata(nfc_dev
);
582 rc
= digital_in_send_atr_req(ddev
, target
, comm_mode
, gb
, gb_len
);
585 ddev
->curr_protocol
= NFC_PROTO_NFC_DEP
;
590 static int digital_dep_link_down(struct nfc_dev
*nfc_dev
)
592 struct nfc_digital_dev
*ddev
= nfc_get_drvdata(nfc_dev
);
594 ddev
->curr_protocol
= 0;
599 static int digital_activate_target(struct nfc_dev
*nfc_dev
,
600 struct nfc_target
*target
, __u32 protocol
)
602 struct nfc_digital_dev
*ddev
= nfc_get_drvdata(nfc_dev
);
604 if (ddev
->poll_tech_count
) {
605 pr_err("Can't activate a target while polling\n");
609 if (ddev
->curr_protocol
) {
610 pr_err("A target is already active\n");
614 ddev
->curr_protocol
= protocol
;
619 static void digital_deactivate_target(struct nfc_dev
*nfc_dev
,
620 struct nfc_target
*target
)
622 struct nfc_digital_dev
*ddev
= nfc_get_drvdata(nfc_dev
);
624 if (!ddev
->curr_protocol
) {
625 pr_err("No active target\n");
629 ddev
->curr_protocol
= 0;
632 static int digital_tg_send(struct nfc_dev
*dev
, struct sk_buff
*skb
)
634 struct nfc_digital_dev
*ddev
= nfc_get_drvdata(dev
);
636 return digital_tg_send_dep_res(ddev
, skb
);
639 static void digital_in_send_complete(struct nfc_digital_dev
*ddev
, void *arg
,
640 struct sk_buff
*resp
)
642 struct digital_data_exch
*data_exch
= arg
;
651 if (ddev
->curr_protocol
== NFC_PROTO_MIFARE
) {
652 rc
= digital_in_recv_mifare_res(resp
);
653 /* crc check is done in digital_in_recv_mifare_res() */
657 if ((ddev
->curr_protocol
== NFC_PROTO_ISO14443
) ||
658 (ddev
->curr_protocol
== NFC_PROTO_ISO14443_B
)) {
659 rc
= digital_in_iso_dep_pull_sod(ddev
, resp
);
664 rc
= ddev
->skb_check_crc(resp
);
672 data_exch
->cb(data_exch
->cb_context
, resp
, rc
);
677 static int digital_in_send(struct nfc_dev
*nfc_dev
, struct nfc_target
*target
,
678 struct sk_buff
*skb
, data_exchange_cb_t cb
,
681 struct nfc_digital_dev
*ddev
= nfc_get_drvdata(nfc_dev
);
682 struct digital_data_exch
*data_exch
;
685 data_exch
= kzalloc(sizeof(struct digital_data_exch
), GFP_KERNEL
);
687 pr_err("Failed to allocate data_exch struct\n");
692 data_exch
->cb_context
= cb_context
;
694 if (ddev
->curr_protocol
== NFC_PROTO_NFC_DEP
) {
695 rc
= digital_in_send_dep_req(ddev
, target
, skb
, data_exch
);
699 if ((ddev
->curr_protocol
== NFC_PROTO_ISO14443
) ||
700 (ddev
->curr_protocol
== NFC_PROTO_ISO14443_B
)) {
701 rc
= digital_in_iso_dep_push_sod(ddev
, skb
);
706 ddev
->skb_add_crc(skb
);
708 rc
= digital_in_send_cmd(ddev
, skb
, 500, digital_in_send_complete
,
718 static struct nfc_ops digital_nfc_ops
= {
719 .dev_up
= digital_dev_up
,
720 .dev_down
= digital_dev_down
,
721 .start_poll
= digital_start_poll
,
722 .stop_poll
= digital_stop_poll
,
723 .dep_link_up
= digital_dep_link_up
,
724 .dep_link_down
= digital_dep_link_down
,
725 .activate_target
= digital_activate_target
,
726 .deactivate_target
= digital_deactivate_target
,
727 .tm_send
= digital_tg_send
,
728 .im_transceive
= digital_in_send
,
731 struct nfc_digital_dev
*nfc_digital_allocate_device(struct nfc_digital_ops
*ops
,
732 __u32 supported_protocols
,
733 __u32 driver_capabilities
,
734 int tx_headroom
, int tx_tailroom
)
736 struct nfc_digital_dev
*ddev
;
738 if (!ops
->in_configure_hw
|| !ops
->in_send_cmd
|| !ops
->tg_listen
||
739 !ops
->tg_configure_hw
|| !ops
->tg_send_cmd
|| !ops
->abort_cmd
||
743 ddev
= kzalloc(sizeof(struct nfc_digital_dev
), GFP_KERNEL
);
747 ddev
->driver_capabilities
= driver_capabilities
;
750 mutex_init(&ddev
->cmd_lock
);
751 INIT_LIST_HEAD(&ddev
->cmd_queue
);
753 INIT_WORK(&ddev
->cmd_work
, digital_wq_cmd
);
754 INIT_WORK(&ddev
->cmd_complete_work
, digital_wq_cmd_complete
);
756 mutex_init(&ddev
->poll_lock
);
757 INIT_WORK(&ddev
->poll_work
, digital_wq_poll
);
759 if (supported_protocols
& NFC_PROTO_JEWEL_MASK
)
760 ddev
->protocols
|= NFC_PROTO_JEWEL_MASK
;
761 if (supported_protocols
& NFC_PROTO_MIFARE_MASK
)
762 ddev
->protocols
|= NFC_PROTO_MIFARE_MASK
;
763 if (supported_protocols
& NFC_PROTO_FELICA_MASK
)
764 ddev
->protocols
|= NFC_PROTO_FELICA_MASK
;
765 if (supported_protocols
& NFC_PROTO_NFC_DEP_MASK
)
766 ddev
->protocols
|= NFC_PROTO_NFC_DEP_MASK
;
767 if (supported_protocols
& NFC_PROTO_ISO15693_MASK
)
768 ddev
->protocols
|= NFC_PROTO_ISO15693_MASK
;
769 if (supported_protocols
& NFC_PROTO_ISO14443_MASK
)
770 ddev
->protocols
|= NFC_PROTO_ISO14443_MASK
;
771 if (supported_protocols
& NFC_PROTO_ISO14443_B_MASK
)
772 ddev
->protocols
|= NFC_PROTO_ISO14443_B_MASK
;
774 ddev
->tx_headroom
= tx_headroom
+ DIGITAL_MAX_HEADER_LEN
;
775 ddev
->tx_tailroom
= tx_tailroom
+ DIGITAL_CRC_LEN
;
777 ddev
->nfc_dev
= nfc_allocate_device(&digital_nfc_ops
, ddev
->protocols
,
780 if (!ddev
->nfc_dev
) {
781 pr_err("nfc_allocate_device failed\n");
785 nfc_set_drvdata(ddev
->nfc_dev
, ddev
);
794 EXPORT_SYMBOL(nfc_digital_allocate_device
);
796 void nfc_digital_free_device(struct nfc_digital_dev
*ddev
)
798 nfc_free_device(ddev
->nfc_dev
);
801 EXPORT_SYMBOL(nfc_digital_free_device
);
803 int nfc_digital_register_device(struct nfc_digital_dev
*ddev
)
805 return nfc_register_device(ddev
->nfc_dev
);
807 EXPORT_SYMBOL(nfc_digital_register_device
);
809 void nfc_digital_unregister_device(struct nfc_digital_dev
*ddev
)
811 struct digital_cmd
*cmd
, *n
;
813 nfc_unregister_device(ddev
->nfc_dev
);
815 mutex_lock(&ddev
->poll_lock
);
816 ddev
->poll_tech_count
= 0;
817 mutex_unlock(&ddev
->poll_lock
);
819 cancel_work_sync(&ddev
->poll_work
);
820 cancel_work_sync(&ddev
->cmd_work
);
821 cancel_work_sync(&ddev
->cmd_complete_work
);
823 list_for_each_entry_safe(cmd
, n
, &ddev
->cmd_queue
, queue
) {
824 list_del(&cmd
->queue
);
825 kfree(cmd
->mdaa_params
);
829 EXPORT_SYMBOL(nfc_digital_unregister_device
);
831 MODULE_LICENSE("GPL");