2 * Driver for NXP PN533 NFC Chip - core functions
4 * Copyright (C) 2011 Instituto Nokia de Tecnologia
5 * Copyright (C) 2012-2013 Tieto Poland
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 #include <linux/device.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/nfc.h>
26 #include <linux/netdevice.h>
27 #include <net/nfc/nfc.h>
32 /* How much time we spend listening for initiators */
33 #define PN533_LISTEN_TIME 2
34 /* Delay between each poll frame (ms) */
35 #define PN533_POLL_INTERVAL 10
37 /* structs for pn533 commands */
39 /* PN533_CMD_GET_FIRMWARE_VERSION */
40 struct pn533_fw_version
{
47 /* PN533_CMD_RF_CONFIGURATION */
48 #define PN533_CFGITEM_RF_FIELD 0x01
49 #define PN533_CFGITEM_TIMING 0x02
50 #define PN533_CFGITEM_MAX_RETRIES 0x05
51 #define PN533_CFGITEM_PASORI 0x82
53 #define PN533_CFGITEM_RF_FIELD_AUTO_RFCA 0x2
54 #define PN533_CFGITEM_RF_FIELD_ON 0x1
55 #define PN533_CFGITEM_RF_FIELD_OFF 0x0
57 #define PN533_CONFIG_TIMING_102 0xb
58 #define PN533_CONFIG_TIMING_204 0xc
59 #define PN533_CONFIG_TIMING_409 0xd
60 #define PN533_CONFIG_TIMING_819 0xe
62 #define PN533_CONFIG_MAX_RETRIES_NO_RETRY 0x00
63 #define PN533_CONFIG_MAX_RETRIES_ENDLESS 0xFF
65 struct pn533_config_max_retries
{
68 u8 mx_rty_passive_act
;
71 struct pn533_config_timing
{
77 /* PN533_CMD_IN_LIST_PASSIVE_TARGET */
79 /* felica commands opcode */
80 #define PN533_FELICA_OPC_SENSF_REQ 0
81 #define PN533_FELICA_OPC_SENSF_RES 1
82 /* felica SENSF_REQ parameters */
83 #define PN533_FELICA_SENSF_SC_ALL 0xFFFF
84 #define PN533_FELICA_SENSF_RC_NO_SYSTEM_CODE 0
85 #define PN533_FELICA_SENSF_RC_SYSTEM_CODE 1
86 #define PN533_FELICA_SENSF_RC_ADVANCED_PROTOCOL 2
88 /* type B initiator_data values */
89 #define PN533_TYPE_B_AFI_ALL_FAMILIES 0
90 #define PN533_TYPE_B_POLL_METHOD_TIMESLOT 0
91 #define PN533_TYPE_B_POLL_METHOD_PROBABILISTIC 1
93 union pn533_cmd_poll_initdata
{
106 struct pn533_poll_modulations
{
110 union pn533_cmd_poll_initdata initiator_data
;
115 static const struct pn533_poll_modulations poll_mod
[] = {
116 [PN533_POLL_MOD_106KBPS_A
] = {
123 [PN533_POLL_MOD_212KBPS_FELICA
] = {
127 .initiator_data
.felica
= {
128 .opcode
= PN533_FELICA_OPC_SENSF_REQ
,
129 .sc
= PN533_FELICA_SENSF_SC_ALL
,
130 .rc
= PN533_FELICA_SENSF_RC_SYSTEM_CODE
,
136 [PN533_POLL_MOD_424KBPS_FELICA
] = {
140 .initiator_data
.felica
= {
141 .opcode
= PN533_FELICA_OPC_SENSF_REQ
,
142 .sc
= PN533_FELICA_SENSF_SC_ALL
,
143 .rc
= PN533_FELICA_SENSF_RC_SYSTEM_CODE
,
149 [PN533_POLL_MOD_106KBPS_JEWEL
] = {
156 [PN533_POLL_MOD_847KBPS_B
] = {
160 .initiator_data
.type_b
= {
161 .afi
= PN533_TYPE_B_AFI_ALL_FAMILIES
,
163 PN533_TYPE_B_POLL_METHOD_TIMESLOT
,
168 [PN533_LISTEN_MOD
] = {
173 /* PN533_CMD_IN_ATR */
175 struct pn533_cmd_activate_response
{
187 struct pn533_cmd_jump_dep_response
{
201 /* PN533_TG_INIT_AS_TARGET */
202 #define PN533_INIT_TARGET_PASSIVE 0x1
203 #define PN533_INIT_TARGET_DEP 0x2
205 #define PN533_INIT_TARGET_RESP_FRAME_MASK 0x3
206 #define PN533_INIT_TARGET_RESP_ACTIVE 0x1
207 #define PN533_INIT_TARGET_RESP_DEP 0x4
209 /* The rule: value(high byte) + value(low byte) + checksum = 0 */
210 static inline u8
pn533_ext_checksum(u16 value
)
212 return ~(u8
)(((value
& 0xFF00) >> 8) + (u8
)(value
& 0xFF)) + 1;
215 /* The rule: value + checksum = 0 */
216 static inline u8
pn533_std_checksum(u8 value
)
221 /* The rule: sum(data elements) + checksum = 0 */
222 static u8
pn533_std_data_checksum(u8
*data
, int datalen
)
227 for (i
= 0; i
< datalen
; i
++)
230 return pn533_std_checksum(sum
);
233 static void pn533_std_tx_frame_init(void *_frame
, u8 cmd_code
)
235 struct pn533_std_frame
*frame
= _frame
;
238 frame
->start_frame
= cpu_to_be16(PN533_STD_FRAME_SOF
);
239 PN533_STD_FRAME_IDENTIFIER(frame
) = PN533_STD_FRAME_DIR_OUT
;
240 PN533_FRAME_CMD(frame
) = cmd_code
;
244 static void pn533_std_tx_frame_finish(void *_frame
)
246 struct pn533_std_frame
*frame
= _frame
;
248 frame
->datalen_checksum
= pn533_std_checksum(frame
->datalen
);
250 PN533_STD_FRAME_CHECKSUM(frame
) =
251 pn533_std_data_checksum(frame
->data
, frame
->datalen
);
253 PN533_STD_FRAME_POSTAMBLE(frame
) = 0;
256 static void pn533_std_tx_update_payload_len(void *_frame
, int len
)
258 struct pn533_std_frame
*frame
= _frame
;
260 frame
->datalen
+= len
;
263 static bool pn533_std_rx_frame_is_valid(void *_frame
, struct pn533
*dev
)
266 struct pn533_std_frame
*stdf
= _frame
;
268 if (stdf
->start_frame
!= cpu_to_be16(PN533_STD_FRAME_SOF
))
271 if (likely(!PN533_STD_IS_EXTENDED(stdf
))) {
272 /* Standard frame code */
273 dev
->ops
->rx_header_len
= PN533_STD_FRAME_HEADER_LEN
;
275 checksum
= pn533_std_checksum(stdf
->datalen
);
276 if (checksum
!= stdf
->datalen_checksum
)
279 checksum
= pn533_std_data_checksum(stdf
->data
, stdf
->datalen
);
280 if (checksum
!= PN533_STD_FRAME_CHECKSUM(stdf
))
284 struct pn533_ext_frame
*eif
= _frame
;
286 dev
->ops
->rx_header_len
= PN533_EXT_FRAME_HEADER_LEN
;
288 checksum
= pn533_ext_checksum(be16_to_cpu(eif
->datalen
));
289 if (checksum
!= eif
->datalen_checksum
)
292 /* check data checksum */
293 checksum
= pn533_std_data_checksum(eif
->data
,
294 be16_to_cpu(eif
->datalen
));
295 if (checksum
!= PN533_EXT_FRAME_CHECKSUM(eif
))
302 bool pn533_rx_frame_is_ack(void *_frame
)
304 struct pn533_std_frame
*frame
= _frame
;
306 if (frame
->start_frame
!= cpu_to_be16(PN533_STD_FRAME_SOF
))
309 if (frame
->datalen
!= 0 || frame
->datalen_checksum
!= 0xFF)
314 EXPORT_SYMBOL_GPL(pn533_rx_frame_is_ack
);
316 static inline int pn533_std_rx_frame_size(void *frame
)
318 struct pn533_std_frame
*f
= frame
;
320 /* check for Extended Information frame */
321 if (PN533_STD_IS_EXTENDED(f
)) {
322 struct pn533_ext_frame
*eif
= frame
;
324 return sizeof(struct pn533_ext_frame
)
325 + be16_to_cpu(eif
->datalen
) + PN533_STD_FRAME_TAIL_LEN
;
328 return sizeof(struct pn533_std_frame
) + f
->datalen
+
329 PN533_STD_FRAME_TAIL_LEN
;
332 static u8
pn533_std_get_cmd_code(void *frame
)
334 struct pn533_std_frame
*f
= frame
;
335 struct pn533_ext_frame
*eif
= frame
;
337 if (PN533_STD_IS_EXTENDED(f
))
338 return PN533_FRAME_CMD(eif
);
340 return PN533_FRAME_CMD(f
);
343 bool pn533_rx_frame_is_cmd_response(struct pn533
*dev
, void *frame
)
345 return (dev
->ops
->get_cmd_code(frame
) ==
346 PN533_CMD_RESPONSE(dev
->cmd
->code
));
348 EXPORT_SYMBOL_GPL(pn533_rx_frame_is_cmd_response
);
351 static struct pn533_frame_ops pn533_std_frame_ops
= {
352 .tx_frame_init
= pn533_std_tx_frame_init
,
353 .tx_frame_finish
= pn533_std_tx_frame_finish
,
354 .tx_update_payload_len
= pn533_std_tx_update_payload_len
,
355 .tx_header_len
= PN533_STD_FRAME_HEADER_LEN
,
356 .tx_tail_len
= PN533_STD_FRAME_TAIL_LEN
,
358 .rx_is_frame_valid
= pn533_std_rx_frame_is_valid
,
359 .rx_frame_size
= pn533_std_rx_frame_size
,
360 .rx_header_len
= PN533_STD_FRAME_HEADER_LEN
,
361 .rx_tail_len
= PN533_STD_FRAME_TAIL_LEN
,
363 .max_payload_len
= PN533_STD_FRAME_MAX_PAYLOAD_LEN
,
364 .get_cmd_code
= pn533_std_get_cmd_code
,
367 static void pn533_build_cmd_frame(struct pn533
*dev
, u8 cmd_code
,
370 /* payload is already there, just update datalen */
371 int payload_len
= skb
->len
;
372 struct pn533_frame_ops
*ops
= dev
->ops
;
375 skb_push(skb
, ops
->tx_header_len
);
376 skb_put(skb
, ops
->tx_tail_len
);
378 ops
->tx_frame_init(skb
->data
, cmd_code
);
379 ops
->tx_update_payload_len(skb
->data
, payload_len
);
380 ops
->tx_frame_finish(skb
->data
);
383 static int pn533_send_async_complete(struct pn533
*dev
)
385 struct pn533_cmd
*cmd
= dev
->cmd
;
386 int status
= cmd
->status
;
388 struct sk_buff
*req
= cmd
->req
;
389 struct sk_buff
*resp
= cmd
->resp
;
396 rc
= cmd
->complete_cb(dev
, cmd
->complete_cb_context
,
402 skb_pull(resp
, dev
->ops
->rx_header_len
);
403 skb_trim(resp
, resp
->len
- dev
->ops
->rx_tail_len
);
405 rc
= cmd
->complete_cb(dev
, cmd
->complete_cb_context
, resp
);
413 static int __pn533_send_async(struct pn533
*dev
, u8 cmd_code
,
415 pn533_send_async_complete_t complete_cb
,
416 void *complete_cb_context
)
418 struct pn533_cmd
*cmd
;
421 dev_dbg(dev
->dev
, "Sending command 0x%x\n", cmd_code
);
423 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
427 cmd
->code
= cmd_code
;
429 cmd
->complete_cb
= complete_cb
;
430 cmd
->complete_cb_context
= complete_cb_context
;
432 pn533_build_cmd_frame(dev
, cmd_code
, req
);
434 mutex_lock(&dev
->cmd_lock
);
436 if (!dev
->cmd_pending
) {
437 rc
= dev
->phy_ops
->send_frame(dev
, req
);
441 dev
->cmd_pending
= 1;
446 dev_dbg(dev
->dev
, "%s Queueing command 0x%x\n",
449 INIT_LIST_HEAD(&cmd
->queue
);
450 list_add_tail(&cmd
->queue
, &dev
->cmd_queue
);
457 mutex_unlock(&dev
->cmd_lock
);
461 static int pn533_send_data_async(struct pn533
*dev
, u8 cmd_code
,
463 pn533_send_async_complete_t complete_cb
,
464 void *complete_cb_context
)
468 rc
= __pn533_send_async(dev
, cmd_code
, req
, complete_cb
,
469 complete_cb_context
);
474 static int pn533_send_cmd_async(struct pn533
*dev
, u8 cmd_code
,
476 pn533_send_async_complete_t complete_cb
,
477 void *complete_cb_context
)
481 rc
= __pn533_send_async(dev
, cmd_code
, req
, complete_cb
,
482 complete_cb_context
);
488 * pn533_send_cmd_direct_async
490 * The function sends a piority cmd directly to the chip omiting the cmd
491 * queue. It's intended to be used by chaining mechanism of received responses
492 * where the host has to request every single chunk of data before scheduling
493 * next cmd from the queue.
495 static int pn533_send_cmd_direct_async(struct pn533
*dev
, u8 cmd_code
,
497 pn533_send_async_complete_t complete_cb
,
498 void *complete_cb_context
)
500 struct pn533_cmd
*cmd
;
503 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
507 cmd
->code
= cmd_code
;
509 cmd
->complete_cb
= complete_cb
;
510 cmd
->complete_cb_context
= complete_cb_context
;
512 pn533_build_cmd_frame(dev
, cmd_code
, req
);
514 rc
= dev
->phy_ops
->send_frame(dev
, req
);
523 static void pn533_wq_cmd_complete(struct work_struct
*work
)
525 struct pn533
*dev
= container_of(work
, struct pn533
, cmd_complete_work
);
528 rc
= pn533_send_async_complete(dev
);
529 if (rc
!= -EINPROGRESS
)
530 queue_work(dev
->wq
, &dev
->cmd_work
);
533 static void pn533_wq_cmd(struct work_struct
*work
)
535 struct pn533
*dev
= container_of(work
, struct pn533
, cmd_work
);
536 struct pn533_cmd
*cmd
;
539 mutex_lock(&dev
->cmd_lock
);
541 if (list_empty(&dev
->cmd_queue
)) {
542 dev
->cmd_pending
= 0;
543 mutex_unlock(&dev
->cmd_lock
);
547 cmd
= list_first_entry(&dev
->cmd_queue
, struct pn533_cmd
, queue
);
549 list_del(&cmd
->queue
);
551 mutex_unlock(&dev
->cmd_lock
);
553 rc
= dev
->phy_ops
->send_frame(dev
, cmd
->req
);
555 dev_kfree_skb(cmd
->req
);
563 struct pn533_sync_cmd_response
{
564 struct sk_buff
*resp
;
565 struct completion done
;
568 static int pn533_send_sync_complete(struct pn533
*dev
, void *_arg
,
569 struct sk_buff
*resp
)
571 struct pn533_sync_cmd_response
*arg
= _arg
;
574 complete(&arg
->done
);
579 /* pn533_send_cmd_sync
581 * Please note the req parameter is freed inside the function to
582 * limit a number of return value interpretations by the caller.
584 * 1. negative in case of error during TX path -> req should be freed
586 * 2. negative in case of error during RX path -> req should not be freed
587 * as it's been already freed at the beginning of RX path by
590 * 3. valid pointer in case of succesfult RX path
592 * A caller has to check a return value with IS_ERR macro. If the test pass,
593 * the returned pointer is valid.
596 static struct sk_buff
*pn533_send_cmd_sync(struct pn533
*dev
, u8 cmd_code
,
600 struct pn533_sync_cmd_response arg
;
602 init_completion(&arg
.done
);
604 rc
= pn533_send_cmd_async(dev
, cmd_code
, req
,
605 pn533_send_sync_complete
, &arg
);
611 wait_for_completion(&arg
.done
);
616 static struct sk_buff
*pn533_alloc_skb(struct pn533
*dev
, unsigned int size
)
620 skb
= alloc_skb(dev
->ops
->tx_header_len
+
622 dev
->ops
->tx_tail_len
, GFP_KERNEL
);
625 skb_reserve(skb
, dev
->ops
->tx_header_len
);
630 struct pn533_target_type_a
{
638 #define PN533_TYPE_A_SENS_RES_NFCID1(x) ((u8)((be16_to_cpu(x) & 0x00C0) >> 6))
639 #define PN533_TYPE_A_SENS_RES_SSD(x) ((u8)((be16_to_cpu(x) & 0x001F) >> 0))
640 #define PN533_TYPE_A_SENS_RES_PLATCONF(x) ((u8)((be16_to_cpu(x) & 0x0F00) >> 8))
642 #define PN533_TYPE_A_SENS_RES_SSD_JEWEL 0x00
643 #define PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL 0x0C
645 #define PN533_TYPE_A_SEL_PROT(x) (((x) & 0x60) >> 5)
646 #define PN533_TYPE_A_SEL_CASCADE(x) (((x) & 0x04) >> 2)
648 #define PN533_TYPE_A_SEL_PROT_MIFARE 0
649 #define PN533_TYPE_A_SEL_PROT_ISO14443 1
650 #define PN533_TYPE_A_SEL_PROT_DEP 2
651 #define PN533_TYPE_A_SEL_PROT_ISO14443_DEP 3
653 static bool pn533_target_type_a_is_valid(struct pn533_target_type_a
*type_a
,
659 if (target_data_len
< sizeof(struct pn533_target_type_a
))
663 * The length check of nfcid[] and ats[] are not being performed because
664 * the values are not being used
667 /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
668 ssd
= PN533_TYPE_A_SENS_RES_SSD(type_a
->sens_res
);
669 platconf
= PN533_TYPE_A_SENS_RES_PLATCONF(type_a
->sens_res
);
671 if ((ssd
== PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
672 platconf
!= PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
) ||
673 (ssd
!= PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
674 platconf
== PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
))
677 /* Requirements 4.8.2.1, 4.8.2.3, 4.8.2.5 and 4.8.2.7 from NFC Forum */
678 if (PN533_TYPE_A_SEL_CASCADE(type_a
->sel_res
) != 0)
684 static int pn533_target_found_type_a(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
687 struct pn533_target_type_a
*tgt_type_a
;
689 tgt_type_a
= (struct pn533_target_type_a
*)tgt_data
;
691 if (!pn533_target_type_a_is_valid(tgt_type_a
, tgt_data_len
))
694 switch (PN533_TYPE_A_SEL_PROT(tgt_type_a
->sel_res
)) {
695 case PN533_TYPE_A_SEL_PROT_MIFARE
:
696 nfc_tgt
->supported_protocols
= NFC_PROTO_MIFARE_MASK
;
698 case PN533_TYPE_A_SEL_PROT_ISO14443
:
699 nfc_tgt
->supported_protocols
= NFC_PROTO_ISO14443_MASK
;
701 case PN533_TYPE_A_SEL_PROT_DEP
:
702 nfc_tgt
->supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
704 case PN533_TYPE_A_SEL_PROT_ISO14443_DEP
:
705 nfc_tgt
->supported_protocols
= NFC_PROTO_ISO14443_MASK
|
706 NFC_PROTO_NFC_DEP_MASK
;
710 nfc_tgt
->sens_res
= be16_to_cpu(tgt_type_a
->sens_res
);
711 nfc_tgt
->sel_res
= tgt_type_a
->sel_res
;
712 nfc_tgt
->nfcid1_len
= tgt_type_a
->nfcid_len
;
713 memcpy(nfc_tgt
->nfcid1
, tgt_type_a
->nfcid_data
, nfc_tgt
->nfcid1_len
);
718 struct pn533_target_felica
{
721 u8 nfcid2
[NFC_NFCID2_MAXSIZE
];
727 #define PN533_FELICA_SENSF_NFCID2_DEP_B1 0x01
728 #define PN533_FELICA_SENSF_NFCID2_DEP_B2 0xFE
730 static bool pn533_target_felica_is_valid(struct pn533_target_felica
*felica
,
733 if (target_data_len
< sizeof(struct pn533_target_felica
))
736 if (felica
->opcode
!= PN533_FELICA_OPC_SENSF_RES
)
742 static int pn533_target_found_felica(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
745 struct pn533_target_felica
*tgt_felica
;
747 tgt_felica
= (struct pn533_target_felica
*)tgt_data
;
749 if (!pn533_target_felica_is_valid(tgt_felica
, tgt_data_len
))
752 if ((tgt_felica
->nfcid2
[0] == PN533_FELICA_SENSF_NFCID2_DEP_B1
) &&
753 (tgt_felica
->nfcid2
[1] == PN533_FELICA_SENSF_NFCID2_DEP_B2
))
754 nfc_tgt
->supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
756 nfc_tgt
->supported_protocols
= NFC_PROTO_FELICA_MASK
;
758 memcpy(nfc_tgt
->sensf_res
, &tgt_felica
->opcode
, 9);
759 nfc_tgt
->sensf_res_len
= 9;
761 memcpy(nfc_tgt
->nfcid2
, tgt_felica
->nfcid2
, NFC_NFCID2_MAXSIZE
);
762 nfc_tgt
->nfcid2_len
= NFC_NFCID2_MAXSIZE
;
767 struct pn533_target_jewel
{
772 static bool pn533_target_jewel_is_valid(struct pn533_target_jewel
*jewel
,
778 if (target_data_len
< sizeof(struct pn533_target_jewel
))
781 /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
782 ssd
= PN533_TYPE_A_SENS_RES_SSD(jewel
->sens_res
);
783 platconf
= PN533_TYPE_A_SENS_RES_PLATCONF(jewel
->sens_res
);
785 if ((ssd
== PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
786 platconf
!= PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
) ||
787 (ssd
!= PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
788 platconf
== PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
))
794 static int pn533_target_found_jewel(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
797 struct pn533_target_jewel
*tgt_jewel
;
799 tgt_jewel
= (struct pn533_target_jewel
*)tgt_data
;
801 if (!pn533_target_jewel_is_valid(tgt_jewel
, tgt_data_len
))
804 nfc_tgt
->supported_protocols
= NFC_PROTO_JEWEL_MASK
;
805 nfc_tgt
->sens_res
= be16_to_cpu(tgt_jewel
->sens_res
);
806 nfc_tgt
->nfcid1_len
= 4;
807 memcpy(nfc_tgt
->nfcid1
, tgt_jewel
->jewelid
, nfc_tgt
->nfcid1_len
);
812 struct pn533_type_b_prot_info
{
818 #define PN533_TYPE_B_PROT_FCSI(x) (((x) & 0xF0) >> 4)
819 #define PN533_TYPE_B_PROT_TYPE(x) (((x) & 0x0F) >> 0)
820 #define PN533_TYPE_B_PROT_TYPE_RFU_MASK 0x8
822 struct pn533_type_b_sens_res
{
826 struct pn533_type_b_prot_info prot_info
;
829 #define PN533_TYPE_B_OPC_SENSB_RES 0x50
831 struct pn533_target_type_b
{
832 struct pn533_type_b_sens_res sensb_res
;
837 static bool pn533_target_type_b_is_valid(struct pn533_target_type_b
*type_b
,
840 if (target_data_len
< sizeof(struct pn533_target_type_b
))
843 if (type_b
->sensb_res
.opcode
!= PN533_TYPE_B_OPC_SENSB_RES
)
846 if (PN533_TYPE_B_PROT_TYPE(type_b
->sensb_res
.prot_info
.fsci_type
) &
847 PN533_TYPE_B_PROT_TYPE_RFU_MASK
)
853 static int pn533_target_found_type_b(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
856 struct pn533_target_type_b
*tgt_type_b
;
858 tgt_type_b
= (struct pn533_target_type_b
*)tgt_data
;
860 if (!pn533_target_type_b_is_valid(tgt_type_b
, tgt_data_len
))
863 nfc_tgt
->supported_protocols
= NFC_PROTO_ISO14443_B_MASK
;
868 static int pn533_target_found(struct pn533
*dev
, u8 tg
, u8
*tgdata
,
871 struct nfc_target nfc_tgt
;
874 dev_dbg(dev
->dev
, "%s: modulation=%d\n",
875 __func__
, dev
->poll_mod_curr
);
880 memset(&nfc_tgt
, 0, sizeof(struct nfc_target
));
882 switch (dev
->poll_mod_curr
) {
883 case PN533_POLL_MOD_106KBPS_A
:
884 rc
= pn533_target_found_type_a(&nfc_tgt
, tgdata
, tgdata_len
);
886 case PN533_POLL_MOD_212KBPS_FELICA
:
887 case PN533_POLL_MOD_424KBPS_FELICA
:
888 rc
= pn533_target_found_felica(&nfc_tgt
, tgdata
, tgdata_len
);
890 case PN533_POLL_MOD_106KBPS_JEWEL
:
891 rc
= pn533_target_found_jewel(&nfc_tgt
, tgdata
, tgdata_len
);
893 case PN533_POLL_MOD_847KBPS_B
:
894 rc
= pn533_target_found_type_b(&nfc_tgt
, tgdata
, tgdata_len
);
898 "Unknown current poll modulation\n");
905 if (!(nfc_tgt
.supported_protocols
& dev
->poll_protocols
)) {
907 "The Tg found doesn't have the desired protocol\n");
912 "Target found - supported protocols: 0x%x\n",
913 nfc_tgt
.supported_protocols
);
915 dev
->tgt_available_prots
= nfc_tgt
.supported_protocols
;
917 nfc_targets_found(dev
->nfc_dev
, &nfc_tgt
, 1);
922 static inline void pn533_poll_next_mod(struct pn533
*dev
)
924 dev
->poll_mod_curr
= (dev
->poll_mod_curr
+ 1) % dev
->poll_mod_count
;
927 static void pn533_poll_reset_mod_list(struct pn533
*dev
)
929 dev
->poll_mod_count
= 0;
932 static void pn533_poll_add_mod(struct pn533
*dev
, u8 mod_index
)
934 dev
->poll_mod_active
[dev
->poll_mod_count
] =
935 (struct pn533_poll_modulations
*)&poll_mod
[mod_index
];
936 dev
->poll_mod_count
++;
939 static void pn533_poll_create_mod_list(struct pn533
*dev
,
940 u32 im_protocols
, u32 tm_protocols
)
942 pn533_poll_reset_mod_list(dev
);
944 if ((im_protocols
& NFC_PROTO_MIFARE_MASK
) ||
945 (im_protocols
& NFC_PROTO_ISO14443_MASK
) ||
946 (im_protocols
& NFC_PROTO_NFC_DEP_MASK
))
947 pn533_poll_add_mod(dev
, PN533_POLL_MOD_106KBPS_A
);
949 if (im_protocols
& NFC_PROTO_FELICA_MASK
||
950 im_protocols
& NFC_PROTO_NFC_DEP_MASK
) {
951 pn533_poll_add_mod(dev
, PN533_POLL_MOD_212KBPS_FELICA
);
952 pn533_poll_add_mod(dev
, PN533_POLL_MOD_424KBPS_FELICA
);
955 if (im_protocols
& NFC_PROTO_JEWEL_MASK
)
956 pn533_poll_add_mod(dev
, PN533_POLL_MOD_106KBPS_JEWEL
);
958 if (im_protocols
& NFC_PROTO_ISO14443_B_MASK
)
959 pn533_poll_add_mod(dev
, PN533_POLL_MOD_847KBPS_B
);
962 pn533_poll_add_mod(dev
, PN533_LISTEN_MOD
);
965 static int pn533_start_poll_complete(struct pn533
*dev
, struct sk_buff
*resp
)
967 u8 nbtg
, tg
, *tgdata
;
970 /* Toggle the DEP polling */
971 if (dev
->poll_protocols
& NFC_PROTO_NFC_DEP_MASK
)
974 nbtg
= resp
->data
[0];
976 tgdata
= &resp
->data
[2];
977 tgdata_len
= resp
->len
- 2; /* nbtg + tg */
980 rc
= pn533_target_found(dev
, tg
, tgdata
, tgdata_len
);
982 /* We must stop the poll after a valid target found */
984 pn533_poll_reset_mod_list(dev
);
992 static struct sk_buff
*pn533_alloc_poll_tg_frame(struct pn533
*dev
)
995 u8
*felica
, *nfcid3
, *gb
;
997 u8
*gbytes
= dev
->gb
;
998 size_t gbytes_len
= dev
->gb_len
;
1000 u8 felica_params
[18] = {0x1, 0xfe, /* DEP */
1001 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, /* random */
1002 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
1003 0xff, 0xff}; /* System code */
1005 u8 mifare_params
[6] = {0x1, 0x1, /* SENS_RES */
1007 0x40}; /* SEL_RES for DEP */
1009 unsigned int skb_len
= 36 + /*
1010 * mode (1), mifare (6),
1011 * felica (18), nfcid3 (10), gb_len (1)
1016 skb
= pn533_alloc_skb(dev
, skb_len
);
1020 /* DEP support only */
1021 *skb_put(skb
, 1) = PN533_INIT_TARGET_DEP
;
1024 memcpy(skb_put(skb
, 6), mifare_params
, 6);
1027 felica
= skb_put(skb
, 18);
1028 memcpy(felica
, felica_params
, 18);
1029 get_random_bytes(felica
+ 2, 6);
1032 nfcid3
= skb_put(skb
, 10);
1033 memset(nfcid3
, 0, 10);
1034 memcpy(nfcid3
, felica
, 8);
1037 *skb_put(skb
, 1) = gbytes_len
;
1039 gb
= skb_put(skb
, gbytes_len
);
1040 memcpy(gb
, gbytes
, gbytes_len
);
1043 *skb_put(skb
, 1) = 0;
1048 static void pn533_wq_tm_mi_recv(struct work_struct
*work
);
1049 static struct sk_buff
*pn533_build_response(struct pn533
*dev
);
1051 static int pn533_tm_get_data_complete(struct pn533
*dev
, void *arg
,
1052 struct sk_buff
*resp
)
1054 struct sk_buff
*skb
;
1058 dev_dbg(dev
->dev
, "%s\n", __func__
);
1061 skb_queue_purge(&dev
->resp_q
);
1062 return PTR_ERR(resp
);
1065 status
= resp
->data
[0];
1067 ret
= status
& PN533_CMD_RET_MASK
;
1068 mi
= status
& PN533_CMD_MI_MASK
;
1070 skb_pull(resp
, sizeof(status
));
1072 if (ret
!= PN533_CMD_RET_SUCCESS
) {
1077 skb_queue_tail(&dev
->resp_q
, resp
);
1080 queue_work(dev
->wq
, &dev
->mi_tm_rx_work
);
1081 return -EINPROGRESS
;
1084 skb
= pn533_build_response(dev
);
1090 return nfc_tm_data_received(dev
->nfc_dev
, skb
);
1093 nfc_tm_deactivated(dev
->nfc_dev
);
1095 skb_queue_purge(&dev
->resp_q
);
1096 dev_kfree_skb(resp
);
1101 static void pn533_wq_tm_mi_recv(struct work_struct
*work
)
1103 struct pn533
*dev
= container_of(work
, struct pn533
, mi_tm_rx_work
);
1104 struct sk_buff
*skb
;
1107 dev_dbg(dev
->dev
, "%s\n", __func__
);
1109 skb
= pn533_alloc_skb(dev
, 0);
1113 rc
= pn533_send_cmd_direct_async(dev
,
1114 PN533_CMD_TG_GET_DATA
,
1116 pn533_tm_get_data_complete
,
1123 static int pn533_tm_send_complete(struct pn533
*dev
, void *arg
,
1124 struct sk_buff
*resp
);
1125 static void pn533_wq_tm_mi_send(struct work_struct
*work
)
1127 struct pn533
*dev
= container_of(work
, struct pn533
, mi_tm_tx_work
);
1128 struct sk_buff
*skb
;
1131 dev_dbg(dev
->dev
, "%s\n", __func__
);
1133 /* Grab the first skb in the queue */
1134 skb
= skb_dequeue(&dev
->fragment_skb
);
1135 if (skb
== NULL
) { /* No more data */
1136 /* Reset the queue for future use */
1137 skb_queue_head_init(&dev
->fragment_skb
);
1141 /* last entry - remove MI bit */
1142 if (skb_queue_len(&dev
->fragment_skb
) == 0) {
1143 rc
= pn533_send_cmd_direct_async(dev
, PN533_CMD_TG_SET_DATA
,
1144 skb
, pn533_tm_send_complete
, NULL
);
1146 rc
= pn533_send_cmd_direct_async(dev
,
1147 PN533_CMD_TG_SET_META_DATA
,
1148 skb
, pn533_tm_send_complete
, NULL
);
1150 if (rc
== 0) /* success */
1154 "Error %d when trying to perform set meta data_exchange", rc
);
1159 dev
->phy_ops
->send_ack(dev
, GFP_KERNEL
);
1160 queue_work(dev
->wq
, &dev
->cmd_work
);
1163 static void pn533_wq_tg_get_data(struct work_struct
*work
)
1165 struct pn533
*dev
= container_of(work
, struct pn533
, tg_work
);
1166 struct sk_buff
*skb
;
1169 dev_dbg(dev
->dev
, "%s\n", __func__
);
1171 skb
= pn533_alloc_skb(dev
, 0);
1175 rc
= pn533_send_data_async(dev
, PN533_CMD_TG_GET_DATA
, skb
,
1176 pn533_tm_get_data_complete
, NULL
);
1182 #define ATR_REQ_GB_OFFSET 17
1183 static int pn533_init_target_complete(struct pn533
*dev
, struct sk_buff
*resp
)
1185 u8 mode
, *cmd
, comm_mode
= NFC_COMM_PASSIVE
, *gb
;
1189 dev_dbg(dev
->dev
, "%s\n", __func__
);
1191 if (resp
->len
< ATR_REQ_GB_OFFSET
+ 1)
1194 mode
= resp
->data
[0];
1195 cmd
= &resp
->data
[1];
1197 dev_dbg(dev
->dev
, "Target mode 0x%x len %d\n",
1200 if ((mode
& PN533_INIT_TARGET_RESP_FRAME_MASK
) ==
1201 PN533_INIT_TARGET_RESP_ACTIVE
)
1202 comm_mode
= NFC_COMM_ACTIVE
;
1204 if ((mode
& PN533_INIT_TARGET_RESP_DEP
) == 0) /* Only DEP supported */
1207 gb
= cmd
+ ATR_REQ_GB_OFFSET
;
1208 gb_len
= resp
->len
- (ATR_REQ_GB_OFFSET
+ 1);
1210 rc
= nfc_tm_activated(dev
->nfc_dev
, NFC_PROTO_NFC_DEP_MASK
,
1211 comm_mode
, gb
, gb_len
);
1214 "Error when signaling target activation\n");
1219 queue_work(dev
->wq
, &dev
->tg_work
);
1224 static void pn533_listen_mode_timer(unsigned long data
)
1226 struct pn533
*dev
= (struct pn533
*)data
;
1228 dev_dbg(dev
->dev
, "Listen mode timeout\n");
1230 dev
->cancel_listen
= 1;
1232 pn533_poll_next_mod(dev
);
1234 queue_delayed_work(dev
->wq
, &dev
->poll_work
,
1235 msecs_to_jiffies(PN533_POLL_INTERVAL
));
1238 static int pn533_rf_complete(struct pn533
*dev
, void *arg
,
1239 struct sk_buff
*resp
)
1243 dev_dbg(dev
->dev
, "%s\n", __func__
);
1248 nfc_err(dev
->dev
, "RF setting error %d\n", rc
);
1253 queue_delayed_work(dev
->wq
, &dev
->poll_work
,
1254 msecs_to_jiffies(PN533_POLL_INTERVAL
));
1256 dev_kfree_skb(resp
);
1260 static void pn533_wq_rf(struct work_struct
*work
)
1262 struct pn533
*dev
= container_of(work
, struct pn533
, rf_work
);
1263 struct sk_buff
*skb
;
1266 dev_dbg(dev
->dev
, "%s\n", __func__
);
1268 skb
= pn533_alloc_skb(dev
, 2);
1272 *skb_put(skb
, 1) = PN533_CFGITEM_RF_FIELD
;
1273 *skb_put(skb
, 1) = PN533_CFGITEM_RF_FIELD_AUTO_RFCA
;
1275 rc
= pn533_send_cmd_async(dev
, PN533_CMD_RF_CONFIGURATION
, skb
,
1276 pn533_rf_complete
, NULL
);
1279 nfc_err(dev
->dev
, "RF setting error %d\n", rc
);
1283 static int pn533_poll_dep_complete(struct pn533
*dev
, void *arg
,
1284 struct sk_buff
*resp
)
1286 struct pn533_cmd_jump_dep_response
*rsp
;
1287 struct nfc_target nfc_target
;
1292 return PTR_ERR(resp
);
1294 rsp
= (struct pn533_cmd_jump_dep_response
*)resp
->data
;
1296 rc
= rsp
->status
& PN533_CMD_RET_MASK
;
1297 if (rc
!= PN533_CMD_RET_SUCCESS
) {
1298 /* Not target found, turn radio off */
1299 queue_work(dev
->wq
, &dev
->rf_work
);
1301 dev_kfree_skb(resp
);
1305 dev_dbg(dev
->dev
, "Creating new target");
1307 nfc_target
.supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
1308 nfc_target
.nfcid1_len
= 10;
1309 memcpy(nfc_target
.nfcid1
, rsp
->nfcid3t
, nfc_target
.nfcid1_len
);
1310 rc
= nfc_targets_found(dev
->nfc_dev
, &nfc_target
, 1);
1314 dev
->tgt_available_prots
= 0;
1315 dev
->tgt_active_prot
= NFC_PROTO_NFC_DEP
;
1317 /* ATR_RES general bytes are located at offset 17 */
1318 target_gt_len
= resp
->len
- 17;
1319 rc
= nfc_set_remote_general_bytes(dev
->nfc_dev
,
1320 rsp
->gt
, target_gt_len
);
1322 rc
= nfc_dep_link_is_up(dev
->nfc_dev
,
1323 dev
->nfc_dev
->targets
[0].idx
,
1324 0, NFC_RF_INITIATOR
);
1327 pn533_poll_reset_mod_list(dev
);
1330 dev_kfree_skb(resp
);
1334 #define PASSIVE_DATA_LEN 5
1335 static int pn533_poll_dep(struct nfc_dev
*nfc_dev
)
1337 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1338 struct sk_buff
*skb
;
1340 u8
*next
, nfcid3
[NFC_NFCID3_MAXSIZE
];
1341 u8 passive_data
[PASSIVE_DATA_LEN
] = {0x00, 0xff, 0xff, 0x00, 0x3};
1343 dev_dbg(dev
->dev
, "%s", __func__
);
1346 dev
->gb
= nfc_get_local_general_bytes(nfc_dev
, &dev
->gb_len
);
1348 if (!dev
->gb
|| !dev
->gb_len
) {
1350 queue_work(dev
->wq
, &dev
->rf_work
);
1354 skb_len
= 3 + dev
->gb_len
; /* ActPass + BR + Next */
1355 skb_len
+= PASSIVE_DATA_LEN
;
1358 skb_len
+= NFC_NFCID3_MAXSIZE
;
1361 get_random_bytes(nfcid3
+ 2, 6);
1363 skb
= pn533_alloc_skb(dev
, skb_len
);
1367 *skb_put(skb
, 1) = 0x01; /* Active */
1368 *skb_put(skb
, 1) = 0x02; /* 424 kbps */
1370 next
= skb_put(skb
, 1); /* Next */
1373 /* Copy passive data */
1374 memcpy(skb_put(skb
, PASSIVE_DATA_LEN
), passive_data
, PASSIVE_DATA_LEN
);
1377 /* Copy NFCID3 (which is NFCID2 from SENSF_RES) */
1378 memcpy(skb_put(skb
, NFC_NFCID3_MAXSIZE
), nfcid3
,
1379 NFC_NFCID3_MAXSIZE
);
1382 memcpy(skb_put(skb
, dev
->gb_len
), dev
->gb
, dev
->gb_len
);
1383 *next
|= 4; /* We have some Gi */
1385 rc
= pn533_send_cmd_async(dev
, PN533_CMD_IN_JUMP_FOR_DEP
, skb
,
1386 pn533_poll_dep_complete
, NULL
);
1394 static int pn533_poll_complete(struct pn533
*dev
, void *arg
,
1395 struct sk_buff
*resp
)
1397 struct pn533_poll_modulations
*cur_mod
;
1400 dev_dbg(dev
->dev
, "%s\n", __func__
);
1405 nfc_err(dev
->dev
, "%s Poll complete error %d\n",
1408 if (rc
== -ENOENT
) {
1409 if (dev
->poll_mod_count
!= 0)
1412 } else if (rc
< 0) {
1414 "Error %d when running poll\n", rc
);
1419 cur_mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1421 if (cur_mod
->len
== 0) { /* Target mode */
1422 del_timer(&dev
->listen_timer
);
1423 rc
= pn533_init_target_complete(dev
, resp
);
1427 /* Initiator mode */
1428 rc
= pn533_start_poll_complete(dev
, resp
);
1432 if (!dev
->poll_mod_count
) {
1433 dev_dbg(dev
->dev
, "Polling has been stopped\n");
1437 pn533_poll_next_mod(dev
);
1438 /* Not target found, turn radio off */
1439 queue_work(dev
->wq
, &dev
->rf_work
);
1442 dev_kfree_skb(resp
);
1446 nfc_err(dev
->dev
, "Polling operation has been stopped\n");
1448 pn533_poll_reset_mod_list(dev
);
1449 dev
->poll_protocols
= 0;
1453 static struct sk_buff
*pn533_alloc_poll_in_frame(struct pn533
*dev
,
1454 struct pn533_poll_modulations
*mod
)
1456 struct sk_buff
*skb
;
1458 skb
= pn533_alloc_skb(dev
, mod
->len
);
1462 memcpy(skb_put(skb
, mod
->len
), &mod
->data
, mod
->len
);
1467 static int pn533_send_poll_frame(struct pn533
*dev
)
1469 struct pn533_poll_modulations
*mod
;
1470 struct sk_buff
*skb
;
1474 mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1476 dev_dbg(dev
->dev
, "%s mod len %d\n",
1477 __func__
, mod
->len
);
1479 if ((dev
->poll_protocols
& NFC_PROTO_NFC_DEP_MASK
) && dev
->poll_dep
) {
1481 return pn533_poll_dep(dev
->nfc_dev
);
1484 if (mod
->len
== 0) { /* Listen mode */
1485 cmd_code
= PN533_CMD_TG_INIT_AS_TARGET
;
1486 skb
= pn533_alloc_poll_tg_frame(dev
);
1487 } else { /* Polling mode */
1488 cmd_code
= PN533_CMD_IN_LIST_PASSIVE_TARGET
;
1489 skb
= pn533_alloc_poll_in_frame(dev
, mod
);
1493 nfc_err(dev
->dev
, "Failed to allocate skb\n");
1497 rc
= pn533_send_cmd_async(dev
, cmd_code
, skb
, pn533_poll_complete
,
1501 nfc_err(dev
->dev
, "Polling loop error %d\n", rc
);
1507 static void pn533_wq_poll(struct work_struct
*work
)
1509 struct pn533
*dev
= container_of(work
, struct pn533
, poll_work
.work
);
1510 struct pn533_poll_modulations
*cur_mod
;
1513 cur_mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1516 "%s cancel_listen %d modulation len %d\n",
1517 __func__
, dev
->cancel_listen
, cur_mod
->len
);
1519 if (dev
->cancel_listen
== 1) {
1520 dev
->cancel_listen
= 0;
1521 dev
->phy_ops
->abort_cmd(dev
, GFP_ATOMIC
);
1524 rc
= pn533_send_poll_frame(dev
);
1528 if (cur_mod
->len
== 0 && dev
->poll_mod_count
> 1)
1529 mod_timer(&dev
->listen_timer
, jiffies
+ PN533_LISTEN_TIME
* HZ
);
1532 static int pn533_start_poll(struct nfc_dev
*nfc_dev
,
1533 u32 im_protocols
, u32 tm_protocols
)
1535 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1536 struct pn533_poll_modulations
*cur_mod
;
1541 "%s: im protocols 0x%x tm protocols 0x%x\n",
1542 __func__
, im_protocols
, tm_protocols
);
1544 if (dev
->tgt_active_prot
) {
1546 "Cannot poll with a target already activated\n");
1550 if (dev
->tgt_mode
) {
1552 "Cannot poll while already being activated\n");
1557 dev
->gb
= nfc_get_local_general_bytes(nfc_dev
, &dev
->gb_len
);
1558 if (dev
->gb
== NULL
)
1562 pn533_poll_create_mod_list(dev
, im_protocols
, tm_protocols
);
1563 dev
->poll_protocols
= im_protocols
;
1564 dev
->listen_protocols
= tm_protocols
;
1566 /* Do not always start polling from the same modulation */
1567 get_random_bytes(&rand_mod
, sizeof(rand_mod
));
1568 rand_mod
%= dev
->poll_mod_count
;
1569 dev
->poll_mod_curr
= rand_mod
;
1571 cur_mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1573 rc
= pn533_send_poll_frame(dev
);
1575 /* Start listen timer */
1576 if (!rc
&& cur_mod
->len
== 0 && dev
->poll_mod_count
> 1)
1577 mod_timer(&dev
->listen_timer
, jiffies
+ PN533_LISTEN_TIME
* HZ
);
1582 static void pn533_stop_poll(struct nfc_dev
*nfc_dev
)
1584 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1586 del_timer(&dev
->listen_timer
);
1588 if (!dev
->poll_mod_count
) {
1590 "Polling operation was not running\n");
1594 dev
->phy_ops
->abort_cmd(dev
, GFP_KERNEL
);
1595 flush_delayed_work(&dev
->poll_work
);
1596 pn533_poll_reset_mod_list(dev
);
1599 static int pn533_activate_target_nfcdep(struct pn533
*dev
)
1601 struct pn533_cmd_activate_response
*rsp
;
1604 struct sk_buff
*skb
;
1605 struct sk_buff
*resp
;
1607 dev_dbg(dev
->dev
, "%s\n", __func__
);
1609 skb
= pn533_alloc_skb(dev
, sizeof(u8
) * 2); /*TG + Next*/
1613 *skb_put(skb
, sizeof(u8
)) = 1; /* TG */
1614 *skb_put(skb
, sizeof(u8
)) = 0; /* Next */
1616 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_IN_ATR
, skb
);
1618 return PTR_ERR(resp
);
1620 rsp
= (struct pn533_cmd_activate_response
*)resp
->data
;
1621 rc
= rsp
->status
& PN533_CMD_RET_MASK
;
1622 if (rc
!= PN533_CMD_RET_SUCCESS
) {
1624 "Target activation failed (error 0x%x)\n", rc
);
1625 dev_kfree_skb(resp
);
1629 /* ATR_RES general bytes are located at offset 16 */
1630 gt_len
= resp
->len
- 16;
1631 rc
= nfc_set_remote_general_bytes(dev
->nfc_dev
, rsp
->gt
, gt_len
);
1633 dev_kfree_skb(resp
);
1637 static int pn533_activate_target(struct nfc_dev
*nfc_dev
,
1638 struct nfc_target
*target
, u32 protocol
)
1640 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1643 dev_dbg(dev
->dev
, "%s: protocol=%u\n", __func__
, protocol
);
1645 if (dev
->poll_mod_count
) {
1647 "Cannot activate while polling\n");
1651 if (dev
->tgt_active_prot
) {
1653 "There is already an active target\n");
1657 if (!dev
->tgt_available_prots
) {
1659 "There is no available target to activate\n");
1663 if (!(dev
->tgt_available_prots
& (1 << protocol
))) {
1665 "Target doesn't support requested proto %u\n",
1670 if (protocol
== NFC_PROTO_NFC_DEP
) {
1671 rc
= pn533_activate_target_nfcdep(dev
);
1674 "Activating target with DEP failed %d\n", rc
);
1679 dev
->tgt_active_prot
= protocol
;
1680 dev
->tgt_available_prots
= 0;
1685 static int pn533_deactivate_target_complete(struct pn533
*dev
, void *arg
,
1686 struct sk_buff
*resp
)
1690 dev_dbg(dev
->dev
, "%s\n", __func__
);
1695 nfc_err(dev
->dev
, "Target release error %d\n", rc
);
1700 rc
= resp
->data
[0] & PN533_CMD_RET_MASK
;
1701 if (rc
!= PN533_CMD_RET_SUCCESS
)
1703 "Error 0x%x when releasing the target\n", rc
);
1705 dev_kfree_skb(resp
);
1709 static void pn533_deactivate_target(struct nfc_dev
*nfc_dev
,
1710 struct nfc_target
*target
, u8 mode
)
1712 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1713 struct sk_buff
*skb
;
1716 dev_dbg(dev
->dev
, "%s\n", __func__
);
1718 if (!dev
->tgt_active_prot
) {
1719 nfc_err(dev
->dev
, "There is no active target\n");
1723 dev
->tgt_active_prot
= 0;
1724 skb_queue_purge(&dev
->resp_q
);
1726 skb
= pn533_alloc_skb(dev
, sizeof(u8
));
1730 *skb_put(skb
, 1) = 1; /* TG*/
1732 rc
= pn533_send_cmd_async(dev
, PN533_CMD_IN_RELEASE
, skb
,
1733 pn533_deactivate_target_complete
, NULL
);
1736 nfc_err(dev
->dev
, "Target release error %d\n", rc
);
1741 static int pn533_in_dep_link_up_complete(struct pn533
*dev
, void *arg
,
1742 struct sk_buff
*resp
)
1744 struct pn533_cmd_jump_dep_response
*rsp
;
1747 u8 active
= *(u8
*)arg
;
1752 return PTR_ERR(resp
);
1754 if (dev
->tgt_available_prots
&&
1755 !(dev
->tgt_available_prots
& (1 << NFC_PROTO_NFC_DEP
))) {
1757 "The target does not support DEP\n");
1762 rsp
= (struct pn533_cmd_jump_dep_response
*)resp
->data
;
1764 rc
= rsp
->status
& PN533_CMD_RET_MASK
;
1765 if (rc
!= PN533_CMD_RET_SUCCESS
) {
1767 "Bringing DEP link up failed (error 0x%x)\n", rc
);
1771 if (!dev
->tgt_available_prots
) {
1772 struct nfc_target nfc_target
;
1774 dev_dbg(dev
->dev
, "Creating new target\n");
1776 nfc_target
.supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
1777 nfc_target
.nfcid1_len
= 10;
1778 memcpy(nfc_target
.nfcid1
, rsp
->nfcid3t
, nfc_target
.nfcid1_len
);
1779 rc
= nfc_targets_found(dev
->nfc_dev
, &nfc_target
, 1);
1783 dev
->tgt_available_prots
= 0;
1786 dev
->tgt_active_prot
= NFC_PROTO_NFC_DEP
;
1788 /* ATR_RES general bytes are located at offset 17 */
1789 target_gt_len
= resp
->len
- 17;
1790 rc
= nfc_set_remote_general_bytes(dev
->nfc_dev
,
1791 rsp
->gt
, target_gt_len
);
1793 rc
= nfc_dep_link_is_up(dev
->nfc_dev
,
1794 dev
->nfc_dev
->targets
[0].idx
,
1795 !active
, NFC_RF_INITIATOR
);
1798 dev_kfree_skb(resp
);
1802 static int pn533_rf_field(struct nfc_dev
*nfc_dev
, u8 rf
);
1803 static int pn533_dep_link_up(struct nfc_dev
*nfc_dev
, struct nfc_target
*target
,
1804 u8 comm_mode
, u8
*gb
, size_t gb_len
)
1806 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1807 struct sk_buff
*skb
;
1809 u8
*next
, *arg
, nfcid3
[NFC_NFCID3_MAXSIZE
];
1810 u8 passive_data
[PASSIVE_DATA_LEN
] = {0x00, 0xff, 0xff, 0x00, 0x3};
1812 dev_dbg(dev
->dev
, "%s\n", __func__
);
1814 if (dev
->poll_mod_count
) {
1816 "Cannot bring the DEP link up while polling\n");
1820 if (dev
->tgt_active_prot
) {
1822 "There is already an active target\n");
1826 skb_len
= 3 + gb_len
; /* ActPass + BR + Next */
1827 skb_len
+= PASSIVE_DATA_LEN
;
1830 skb_len
+= NFC_NFCID3_MAXSIZE
;
1831 if (target
&& !target
->nfcid2_len
) {
1834 get_random_bytes(nfcid3
+ 2, 6);
1837 skb
= pn533_alloc_skb(dev
, skb_len
);
1841 *skb_put(skb
, 1) = !comm_mode
; /* ActPass */
1842 *skb_put(skb
, 1) = 0x02; /* 424 kbps */
1844 next
= skb_put(skb
, 1); /* Next */
1847 /* Copy passive data */
1848 memcpy(skb_put(skb
, PASSIVE_DATA_LEN
), passive_data
, PASSIVE_DATA_LEN
);
1851 /* Copy NFCID3 (which is NFCID2 from SENSF_RES) */
1852 if (target
&& target
->nfcid2_len
)
1853 memcpy(skb_put(skb
, NFC_NFCID3_MAXSIZE
), target
->nfcid2
,
1854 target
->nfcid2_len
);
1856 memcpy(skb_put(skb
, NFC_NFCID3_MAXSIZE
), nfcid3
,
1857 NFC_NFCID3_MAXSIZE
);
1860 if (gb
!= NULL
&& gb_len
> 0) {
1861 memcpy(skb_put(skb
, gb_len
), gb
, gb_len
);
1862 *next
|= 4; /* We have some Gi */
1867 arg
= kmalloc(sizeof(*arg
), GFP_KERNEL
);
1875 pn533_rf_field(dev
->nfc_dev
, 0);
1877 rc
= pn533_send_cmd_async(dev
, PN533_CMD_IN_JUMP_FOR_DEP
, skb
,
1878 pn533_in_dep_link_up_complete
, arg
);
1888 static int pn533_dep_link_down(struct nfc_dev
*nfc_dev
)
1890 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1892 dev_dbg(dev
->dev
, "%s\n", __func__
);
1894 pn533_poll_reset_mod_list(dev
);
1896 if (dev
->tgt_mode
|| dev
->tgt_active_prot
)
1897 dev
->phy_ops
->abort_cmd(dev
, GFP_KERNEL
);
1899 dev
->tgt_active_prot
= 0;
1902 skb_queue_purge(&dev
->resp_q
);
1907 struct pn533_data_exchange_arg
{
1908 data_exchange_cb_t cb
;
1912 static struct sk_buff
*pn533_build_response(struct pn533
*dev
)
1914 struct sk_buff
*skb
, *tmp
, *t
;
1915 unsigned int skb_len
= 0, tmp_len
= 0;
1917 dev_dbg(dev
->dev
, "%s\n", __func__
);
1919 if (skb_queue_empty(&dev
->resp_q
))
1922 if (skb_queue_len(&dev
->resp_q
) == 1) {
1923 skb
= skb_dequeue(&dev
->resp_q
);
1927 skb_queue_walk_safe(&dev
->resp_q
, tmp
, t
)
1928 skb_len
+= tmp
->len
;
1930 dev_dbg(dev
->dev
, "%s total length %d\n",
1933 skb
= alloc_skb(skb_len
, GFP_KERNEL
);
1937 skb_put(skb
, skb_len
);
1939 skb_queue_walk_safe(&dev
->resp_q
, tmp
, t
) {
1940 memcpy(skb
->data
+ tmp_len
, tmp
->data
, tmp
->len
);
1941 tmp_len
+= tmp
->len
;
1945 skb_queue_purge(&dev
->resp_q
);
1950 static int pn533_data_exchange_complete(struct pn533
*dev
, void *_arg
,
1951 struct sk_buff
*resp
)
1953 struct pn533_data_exchange_arg
*arg
= _arg
;
1954 struct sk_buff
*skb
;
1958 dev_dbg(dev
->dev
, "%s\n", __func__
);
1965 status
= resp
->data
[0];
1966 ret
= status
& PN533_CMD_RET_MASK
;
1967 mi
= status
& PN533_CMD_MI_MASK
;
1969 skb_pull(resp
, sizeof(status
));
1971 if (ret
!= PN533_CMD_RET_SUCCESS
) {
1973 "Exchanging data failed (error 0x%x)\n", ret
);
1978 skb_queue_tail(&dev
->resp_q
, resp
);
1981 dev
->cmd_complete_mi_arg
= arg
;
1982 queue_work(dev
->wq
, &dev
->mi_rx_work
);
1983 return -EINPROGRESS
;
1986 /* Prepare for the next round */
1987 if (skb_queue_len(&dev
->fragment_skb
) > 0) {
1988 dev
->cmd_complete_dep_arg
= arg
;
1989 queue_work(dev
->wq
, &dev
->mi_tx_work
);
1991 return -EINPROGRESS
;
1994 skb
= pn533_build_response(dev
);
2000 arg
->cb(arg
->cb_context
, skb
, 0);
2005 dev_kfree_skb(resp
);
2007 skb_queue_purge(&dev
->resp_q
);
2008 arg
->cb(arg
->cb_context
, NULL
, rc
);
2014 * Receive an incoming pn533 frame. skb contains only header and payload.
2015 * If skb == NULL, it is a notification that the link below is dead.
2017 void pn533_recv_frame(struct pn533
*dev
, struct sk_buff
*skb
, int status
)
2019 dev
->cmd
->status
= status
;
2022 pr_err("NULL Frame -> link is dead\n");
2026 if (pn533_rx_frame_is_ack(skb
->data
)) {
2027 dev_dbg(dev
->dev
, "%s: Received ACK frame\n", __func__
);
2032 print_hex_dump_debug("PN533 RX: ", DUMP_PREFIX_NONE
, 16, 1, skb
->data
,
2033 dev
->ops
->rx_frame_size(skb
->data
), false);
2035 if (!dev
->ops
->rx_is_frame_valid(skb
->data
, dev
)) {
2036 nfc_err(dev
->dev
, "Received an invalid frame\n");
2037 dev
->cmd
->status
= -EIO
;
2038 } else if (!pn533_rx_frame_is_cmd_response(dev
, skb
->data
)) {
2039 nfc_err(dev
->dev
, "It it not the response to the last command\n");
2040 dev
->cmd
->status
= -EIO
;
2043 dev
->cmd
->resp
= skb
;
2046 queue_work(dev
->wq
, &dev
->cmd_complete_work
);
2048 EXPORT_SYMBOL(pn533_recv_frame
);
2050 /* Split the Tx skb into small chunks */
2051 static int pn533_fill_fragment_skbs(struct pn533
*dev
, struct sk_buff
*skb
)
2053 struct sk_buff
*frag
;
2057 /* Remaining size */
2058 if (skb
->len
> PN533_CMD_DATAFRAME_MAXLEN
)
2059 frag_size
= PN533_CMD_DATAFRAME_MAXLEN
;
2061 frag_size
= skb
->len
;
2063 /* Allocate and reserve */
2064 frag
= pn533_alloc_skb(dev
, frag_size
);
2066 skb_queue_purge(&dev
->fragment_skb
);
2070 if (!dev
->tgt_mode
) {
2071 /* Reserve the TG/MI byte */
2072 skb_reserve(frag
, 1);
2075 if (frag_size
== PN533_CMD_DATAFRAME_MAXLEN
)
2076 *skb_push(frag
, sizeof(u8
)) =
2077 (PN533_CMD_MI_MASK
| 1);
2079 *skb_push(frag
, sizeof(u8
)) = 1; /* TG */
2082 memcpy(skb_put(frag
, frag_size
), skb
->data
, frag_size
);
2084 /* Reduce the size of incoming buffer */
2085 skb_pull(skb
, frag_size
);
2087 /* Add this to skb_queue */
2088 skb_queue_tail(&dev
->fragment_skb
, frag
);
2090 } while (skb
->len
> 0);
2094 return skb_queue_len(&dev
->fragment_skb
);
2097 static int pn533_transceive(struct nfc_dev
*nfc_dev
,
2098 struct nfc_target
*target
, struct sk_buff
*skb
,
2099 data_exchange_cb_t cb
, void *cb_context
)
2101 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
2102 struct pn533_data_exchange_arg
*arg
= NULL
;
2105 dev_dbg(dev
->dev
, "%s\n", __func__
);
2107 if (!dev
->tgt_active_prot
) {
2109 "Can't exchange data if there is no active target\n");
2114 arg
= kmalloc(sizeof(*arg
), GFP_KERNEL
);
2121 arg
->cb_context
= cb_context
;
2123 switch (dev
->device_type
) {
2124 case PN533_DEVICE_PASORI
:
2125 if (dev
->tgt_active_prot
== NFC_PROTO_FELICA
) {
2126 rc
= pn533_send_data_async(dev
, PN533_CMD_IN_COMM_THRU
,
2128 pn533_data_exchange_complete
,
2135 if (skb
->len
> PN533_CMD_DATAEXCH_DATA_MAXLEN
) {
2136 rc
= pn533_fill_fragment_skbs(dev
, skb
);
2140 skb
= skb_dequeue(&dev
->fragment_skb
);
2146 *skb_push(skb
, sizeof(u8
)) = 1; /* TG */
2149 rc
= pn533_send_data_async(dev
, PN533_CMD_IN_DATA_EXCHANGE
,
2150 skb
, pn533_data_exchange_complete
,
2156 if (rc
< 0) /* rc from send_async */
2167 static int pn533_tm_send_complete(struct pn533
*dev
, void *arg
,
2168 struct sk_buff
*resp
)
2172 dev_dbg(dev
->dev
, "%s\n", __func__
);
2175 return PTR_ERR(resp
);
2177 status
= resp
->data
[0];
2179 /* Prepare for the next round */
2180 if (skb_queue_len(&dev
->fragment_skb
) > 0) {
2181 queue_work(dev
->wq
, &dev
->mi_tm_tx_work
);
2182 return -EINPROGRESS
;
2184 dev_kfree_skb(resp
);
2187 nfc_tm_deactivated(dev
->nfc_dev
);
2194 queue_work(dev
->wq
, &dev
->tg_work
);
2199 static int pn533_tm_send(struct nfc_dev
*nfc_dev
, struct sk_buff
*skb
)
2201 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
2204 dev_dbg(dev
->dev
, "%s\n", __func__
);
2206 /* let's split in multiple chunks if size's too big */
2207 if (skb
->len
> PN533_CMD_DATAEXCH_DATA_MAXLEN
) {
2208 rc
= pn533_fill_fragment_skbs(dev
, skb
);
2212 /* get the first skb */
2213 skb
= skb_dequeue(&dev
->fragment_skb
);
2219 rc
= pn533_send_data_async(dev
, PN533_CMD_TG_SET_META_DATA
, skb
,
2220 pn533_tm_send_complete
, NULL
);
2223 rc
= pn533_send_data_async(dev
, PN533_CMD_TG_SET_DATA
, skb
,
2224 pn533_tm_send_complete
, NULL
);
2230 skb_queue_purge(&dev
->fragment_skb
);
2236 static void pn533_wq_mi_recv(struct work_struct
*work
)
2238 struct pn533
*dev
= container_of(work
, struct pn533
, mi_rx_work
);
2239 struct sk_buff
*skb
;
2242 dev_dbg(dev
->dev
, "%s\n", __func__
);
2244 skb
= pn533_alloc_skb(dev
, PN533_CMD_DATAEXCH_HEAD_LEN
);
2248 switch (dev
->device_type
) {
2249 case PN533_DEVICE_PASORI
:
2250 if (dev
->tgt_active_prot
== NFC_PROTO_FELICA
) {
2251 rc
= pn533_send_cmd_direct_async(dev
,
2252 PN533_CMD_IN_COMM_THRU
,
2254 pn533_data_exchange_complete
,
2255 dev
->cmd_complete_mi_arg
);
2260 *skb_put(skb
, sizeof(u8
)) = 1; /*TG*/
2262 rc
= pn533_send_cmd_direct_async(dev
,
2263 PN533_CMD_IN_DATA_EXCHANGE
,
2265 pn533_data_exchange_complete
,
2266 dev
->cmd_complete_mi_arg
);
2271 if (rc
== 0) /* success */
2275 "Error %d when trying to perform data_exchange\n", rc
);
2278 kfree(dev
->cmd_complete_mi_arg
);
2281 dev
->phy_ops
->send_ack(dev
, GFP_KERNEL
);
2282 queue_work(dev
->wq
, &dev
->cmd_work
);
2285 static void pn533_wq_mi_send(struct work_struct
*work
)
2287 struct pn533
*dev
= container_of(work
, struct pn533
, mi_tx_work
);
2288 struct sk_buff
*skb
;
2291 dev_dbg(dev
->dev
, "%s\n", __func__
);
2293 /* Grab the first skb in the queue */
2294 skb
= skb_dequeue(&dev
->fragment_skb
);
2296 if (skb
== NULL
) { /* No more data */
2297 /* Reset the queue for future use */
2298 skb_queue_head_init(&dev
->fragment_skb
);
2302 switch (dev
->device_type
) {
2303 case PN533_DEVICE_PASORI
:
2304 if (dev
->tgt_active_prot
!= NFC_PROTO_FELICA
) {
2309 rc
= pn533_send_cmd_direct_async(dev
, PN533_CMD_IN_COMM_THRU
,
2311 pn533_data_exchange_complete
,
2312 dev
->cmd_complete_dep_arg
);
2317 /* Still some fragments? */
2318 rc
= pn533_send_cmd_direct_async(dev
,
2319 PN533_CMD_IN_DATA_EXCHANGE
,
2321 pn533_data_exchange_complete
,
2322 dev
->cmd_complete_dep_arg
);
2327 if (rc
== 0) /* success */
2331 "Error %d when trying to perform data_exchange\n", rc
);
2334 kfree(dev
->cmd_complete_dep_arg
);
2337 dev
->phy_ops
->send_ack(dev
, GFP_KERNEL
);
2338 queue_work(dev
->wq
, &dev
->cmd_work
);
2341 static int pn533_set_configuration(struct pn533
*dev
, u8 cfgitem
, u8
*cfgdata
,
2344 struct sk_buff
*skb
;
2345 struct sk_buff
*resp
;
2348 dev_dbg(dev
->dev
, "%s\n", __func__
);
2350 skb_len
= sizeof(cfgitem
) + cfgdata_len
; /* cfgitem + cfgdata */
2352 skb
= pn533_alloc_skb(dev
, skb_len
);
2356 *skb_put(skb
, sizeof(cfgitem
)) = cfgitem
;
2357 memcpy(skb_put(skb
, cfgdata_len
), cfgdata
, cfgdata_len
);
2359 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_RF_CONFIGURATION
, skb
);
2361 return PTR_ERR(resp
);
2363 dev_kfree_skb(resp
);
2367 static int pn533_get_firmware_version(struct pn533
*dev
,
2368 struct pn533_fw_version
*fv
)
2370 struct sk_buff
*skb
;
2371 struct sk_buff
*resp
;
2373 skb
= pn533_alloc_skb(dev
, 0);
2377 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_GET_FIRMWARE_VERSION
, skb
);
2379 return PTR_ERR(resp
);
2381 fv
->ic
= resp
->data
[0];
2382 fv
->ver
= resp
->data
[1];
2383 fv
->rev
= resp
->data
[2];
2384 fv
->support
= resp
->data
[3];
2386 dev_kfree_skb(resp
);
2390 static int pn533_pasori_fw_reset(struct pn533
*dev
)
2392 struct sk_buff
*skb
;
2393 struct sk_buff
*resp
;
2395 dev_dbg(dev
->dev
, "%s\n", __func__
);
2397 skb
= pn533_alloc_skb(dev
, sizeof(u8
));
2401 *skb_put(skb
, sizeof(u8
)) = 0x1;
2403 resp
= pn533_send_cmd_sync(dev
, 0x18, skb
);
2405 return PTR_ERR(resp
);
2407 dev_kfree_skb(resp
);
2412 static int pn533_rf_field(struct nfc_dev
*nfc_dev
, u8 rf
)
2414 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
2418 rf_field
|= PN533_CFGITEM_RF_FIELD_AUTO_RFCA
;
2420 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_RF_FIELD
,
2421 (u8
*)&rf_field
, 1);
2423 nfc_err(dev
->dev
, "Error on setting RF field\n");
2430 static int pn533_dev_up(struct nfc_dev
*nfc_dev
)
2432 return pn533_rf_field(nfc_dev
, 1);
2435 static int pn533_dev_down(struct nfc_dev
*nfc_dev
)
2437 return pn533_rf_field(nfc_dev
, 0);
2440 static struct nfc_ops pn533_nfc_ops
= {
2441 .dev_up
= pn533_dev_up
,
2442 .dev_down
= pn533_dev_down
,
2443 .dep_link_up
= pn533_dep_link_up
,
2444 .dep_link_down
= pn533_dep_link_down
,
2445 .start_poll
= pn533_start_poll
,
2446 .stop_poll
= pn533_stop_poll
,
2447 .activate_target
= pn533_activate_target
,
2448 .deactivate_target
= pn533_deactivate_target
,
2449 .im_transceive
= pn533_transceive
,
2450 .tm_send
= pn533_tm_send
,
2453 static int pn533_setup(struct pn533
*dev
)
2455 struct pn533_config_max_retries max_retries
;
2456 struct pn533_config_timing timing
;
2457 u8 pasori_cfg
[3] = {0x08, 0x01, 0x08};
2460 switch (dev
->device_type
) {
2461 case PN533_DEVICE_STD
:
2462 case PN533_DEVICE_PASORI
:
2463 case PN533_DEVICE_ACR122U
:
2464 max_retries
.mx_rty_atr
= 0x2;
2465 max_retries
.mx_rty_psl
= 0x1;
2466 max_retries
.mx_rty_passive_act
=
2467 PN533_CONFIG_MAX_RETRIES_NO_RETRY
;
2469 timing
.rfu
= PN533_CONFIG_TIMING_102
;
2470 timing
.atr_res_timeout
= PN533_CONFIG_TIMING_102
;
2471 timing
.dep_timeout
= PN533_CONFIG_TIMING_204
;
2476 nfc_err(dev
->dev
, "Unknown device type %d\n",
2481 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_MAX_RETRIES
,
2482 (u8
*)&max_retries
, sizeof(max_retries
));
2485 "Error on setting MAX_RETRIES config\n");
2490 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_TIMING
,
2491 (u8
*)&timing
, sizeof(timing
));
2493 nfc_err(dev
->dev
, "Error on setting RF timings\n");
2497 switch (dev
->device_type
) {
2498 case PN533_DEVICE_STD
:
2501 case PN533_DEVICE_PASORI
:
2502 pn533_pasori_fw_reset(dev
);
2504 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_PASORI
,
2508 "Error while settings PASORI config\n");
2512 pn533_pasori_fw_reset(dev
);
2520 struct pn533
*pn533_register_device(u32 device_type
,
2522 enum pn533_protocol_type protocol_type
,
2524 struct pn533_phy_ops
*phy_ops
,
2525 struct pn533_frame_ops
*fops
,
2528 struct pn533_fw_version fw_ver
;
2532 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
2534 return ERR_PTR(-ENOMEM
);
2537 priv
->phy_ops
= phy_ops
;
2542 priv
->ops
= &pn533_std_frame_ops
;
2544 priv
->protocol_type
= protocol_type
;
2545 priv
->device_type
= device_type
;
2547 mutex_init(&priv
->cmd_lock
);
2549 INIT_WORK(&priv
->cmd_work
, pn533_wq_cmd
);
2550 INIT_WORK(&priv
->cmd_complete_work
, pn533_wq_cmd_complete
);
2551 INIT_WORK(&priv
->mi_rx_work
, pn533_wq_mi_recv
);
2552 INIT_WORK(&priv
->mi_tx_work
, pn533_wq_mi_send
);
2553 INIT_WORK(&priv
->tg_work
, pn533_wq_tg_get_data
);
2554 INIT_WORK(&priv
->mi_tm_rx_work
, pn533_wq_tm_mi_recv
);
2555 INIT_WORK(&priv
->mi_tm_tx_work
, pn533_wq_tm_mi_send
);
2556 INIT_DELAYED_WORK(&priv
->poll_work
, pn533_wq_poll
);
2557 INIT_WORK(&priv
->rf_work
, pn533_wq_rf
);
2558 priv
->wq
= alloc_ordered_workqueue("pn533", 0);
2559 if (priv
->wq
== NULL
)
2562 init_timer(&priv
->listen_timer
);
2563 priv
->listen_timer
.data
= (unsigned long) priv
;
2564 priv
->listen_timer
.function
= pn533_listen_mode_timer
;
2566 skb_queue_head_init(&priv
->resp_q
);
2567 skb_queue_head_init(&priv
->fragment_skb
);
2569 INIT_LIST_HEAD(&priv
->cmd_queue
);
2571 memset(&fw_ver
, 0, sizeof(fw_ver
));
2572 rc
= pn533_get_firmware_version(priv
, &fw_ver
);
2576 nfc_info(dev
, "NXP PN5%02X firmware ver %d.%d now attached\n",
2577 fw_ver
.ic
, fw_ver
.ver
, fw_ver
.rev
);
2580 priv
->nfc_dev
= nfc_allocate_device(&pn533_nfc_ops
, protocols
,
2581 priv
->ops
->tx_header_len
+
2582 PN533_CMD_DATAEXCH_HEAD_LEN
,
2583 priv
->ops
->tx_tail_len
);
2584 if (!priv
->nfc_dev
) {
2589 nfc_set_drvdata(priv
->nfc_dev
, priv
);
2591 rc
= nfc_register_device(priv
->nfc_dev
);
2595 rc
= pn533_setup(priv
);
2597 goto unregister_nfc_dev
;
2602 nfc_unregister_device(priv
->nfc_dev
);
2605 nfc_free_device(priv
->nfc_dev
);
2608 destroy_workqueue(priv
->wq
);
2613 EXPORT_SYMBOL_GPL(pn533_register_device
);
2615 void pn533_unregister_device(struct pn533
*priv
)
2617 struct pn533_cmd
*cmd
, *n
;
2619 nfc_unregister_device(priv
->nfc_dev
);
2620 nfc_free_device(priv
->nfc_dev
);
2622 flush_delayed_work(&priv
->poll_work
);
2623 destroy_workqueue(priv
->wq
);
2625 skb_queue_purge(&priv
->resp_q
);
2627 del_timer(&priv
->listen_timer
);
2629 list_for_each_entry_safe(cmd
, n
, &priv
->cmd_queue
, queue
) {
2630 list_del(&cmd
->queue
);
2636 EXPORT_SYMBOL_GPL(pn533_unregister_device
);
2639 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
2640 MODULE_AUTHOR("Aloisio Almeida Jr <aloisio.almeida@openbossa.org>");
2641 MODULE_AUTHOR("Waldemar Rymarkiewicz <waldemar.rymarkiewicz@tieto.com>");
2642 MODULE_DESCRIPTION("PN533 driver ver " VERSION
);
2643 MODULE_VERSION(VERSION
);
2644 MODULE_LICENSE("GPL");