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 struct sk_buff
*resp
;
390 dev_dbg(dev
->dev
, "%s: cmd not set\n", __func__
);
394 dev_kfree_skb(cmd
->req
);
396 status
= cmd
->status
;
400 rc
= cmd
->complete_cb(dev
, cmd
->complete_cb_context
,
406 /* when no response is set we got interrupted */
408 resp
= ERR_PTR(-EINTR
);
411 skb_pull(resp
, dev
->ops
->rx_header_len
);
412 skb_trim(resp
, resp
->len
- dev
->ops
->rx_tail_len
);
415 rc
= cmd
->complete_cb(dev
, cmd
->complete_cb_context
, resp
);
423 static int __pn533_send_async(struct pn533
*dev
, u8 cmd_code
,
425 pn533_send_async_complete_t complete_cb
,
426 void *complete_cb_context
)
428 struct pn533_cmd
*cmd
;
431 dev_dbg(dev
->dev
, "Sending command 0x%x\n", cmd_code
);
433 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
437 cmd
->code
= cmd_code
;
439 cmd
->complete_cb
= complete_cb
;
440 cmd
->complete_cb_context
= complete_cb_context
;
442 pn533_build_cmd_frame(dev
, cmd_code
, req
);
444 mutex_lock(&dev
->cmd_lock
);
446 if (!dev
->cmd_pending
) {
448 rc
= dev
->phy_ops
->send_frame(dev
, req
);
454 dev
->cmd_pending
= 1;
458 dev_dbg(dev
->dev
, "%s Queueing command 0x%x\n",
461 INIT_LIST_HEAD(&cmd
->queue
);
462 list_add_tail(&cmd
->queue
, &dev
->cmd_queue
);
469 mutex_unlock(&dev
->cmd_lock
);
473 static int pn533_send_data_async(struct pn533
*dev
, u8 cmd_code
,
475 pn533_send_async_complete_t complete_cb
,
476 void *complete_cb_context
)
480 rc
= __pn533_send_async(dev
, cmd_code
, req
, complete_cb
,
481 complete_cb_context
);
486 static int pn533_send_cmd_async(struct pn533
*dev
, u8 cmd_code
,
488 pn533_send_async_complete_t complete_cb
,
489 void *complete_cb_context
)
493 rc
= __pn533_send_async(dev
, cmd_code
, req
, complete_cb
,
494 complete_cb_context
);
500 * pn533_send_cmd_direct_async
502 * The function sends a piority cmd directly to the chip omitting the cmd
503 * queue. It's intended to be used by chaining mechanism of received responses
504 * where the host has to request every single chunk of data before scheduling
505 * next cmd from the queue.
507 static int pn533_send_cmd_direct_async(struct pn533
*dev
, u8 cmd_code
,
509 pn533_send_async_complete_t complete_cb
,
510 void *complete_cb_context
)
512 struct pn533_cmd
*cmd
;
515 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
519 cmd
->code
= cmd_code
;
521 cmd
->complete_cb
= complete_cb
;
522 cmd
->complete_cb_context
= complete_cb_context
;
524 pn533_build_cmd_frame(dev
, cmd_code
, req
);
527 rc
= dev
->phy_ops
->send_frame(dev
, req
);
536 static void pn533_wq_cmd_complete(struct work_struct
*work
)
538 struct pn533
*dev
= container_of(work
, struct pn533
, cmd_complete_work
);
541 rc
= pn533_send_async_complete(dev
);
542 if (rc
!= -EINPROGRESS
)
543 queue_work(dev
->wq
, &dev
->cmd_work
);
546 static void pn533_wq_cmd(struct work_struct
*work
)
548 struct pn533
*dev
= container_of(work
, struct pn533
, cmd_work
);
549 struct pn533_cmd
*cmd
;
552 mutex_lock(&dev
->cmd_lock
);
554 if (list_empty(&dev
->cmd_queue
)) {
555 dev
->cmd_pending
= 0;
556 mutex_unlock(&dev
->cmd_lock
);
560 cmd
= list_first_entry(&dev
->cmd_queue
, struct pn533_cmd
, queue
);
562 list_del(&cmd
->queue
);
564 mutex_unlock(&dev
->cmd_lock
);
567 rc
= dev
->phy_ops
->send_frame(dev
, cmd
->req
);
570 dev_kfree_skb(cmd
->req
);
577 struct pn533_sync_cmd_response
{
578 struct sk_buff
*resp
;
579 struct completion done
;
582 static int pn533_send_sync_complete(struct pn533
*dev
, void *_arg
,
583 struct sk_buff
*resp
)
585 struct pn533_sync_cmd_response
*arg
= _arg
;
588 complete(&arg
->done
);
593 /* pn533_send_cmd_sync
595 * Please note the req parameter is freed inside the function to
596 * limit a number of return value interpretations by the caller.
598 * 1. negative in case of error during TX path -> req should be freed
600 * 2. negative in case of error during RX path -> req should not be freed
601 * as it's been already freed at the beginning of RX path by
604 * 3. valid pointer in case of succesfult RX path
606 * A caller has to check a return value with IS_ERR macro. If the test pass,
607 * the returned pointer is valid.
610 static struct sk_buff
*pn533_send_cmd_sync(struct pn533
*dev
, u8 cmd_code
,
614 struct pn533_sync_cmd_response arg
;
616 init_completion(&arg
.done
);
618 rc
= pn533_send_cmd_async(dev
, cmd_code
, req
,
619 pn533_send_sync_complete
, &arg
);
625 wait_for_completion(&arg
.done
);
630 static struct sk_buff
*pn533_alloc_skb(struct pn533
*dev
, unsigned int size
)
634 skb
= alloc_skb(dev
->ops
->tx_header_len
+
636 dev
->ops
->tx_tail_len
, GFP_KERNEL
);
639 skb_reserve(skb
, dev
->ops
->tx_header_len
);
644 struct pn533_target_type_a
{
652 #define PN533_TYPE_A_SENS_RES_NFCID1(x) ((u8)((be16_to_cpu(x) & 0x00C0) >> 6))
653 #define PN533_TYPE_A_SENS_RES_SSD(x) ((u8)((be16_to_cpu(x) & 0x001F) >> 0))
654 #define PN533_TYPE_A_SENS_RES_PLATCONF(x) ((u8)((be16_to_cpu(x) & 0x0F00) >> 8))
656 #define PN533_TYPE_A_SENS_RES_SSD_JEWEL 0x00
657 #define PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL 0x0C
659 #define PN533_TYPE_A_SEL_PROT(x) (((x) & 0x60) >> 5)
660 #define PN533_TYPE_A_SEL_CASCADE(x) (((x) & 0x04) >> 2)
662 #define PN533_TYPE_A_SEL_PROT_MIFARE 0
663 #define PN533_TYPE_A_SEL_PROT_ISO14443 1
664 #define PN533_TYPE_A_SEL_PROT_DEP 2
665 #define PN533_TYPE_A_SEL_PROT_ISO14443_DEP 3
667 static bool pn533_target_type_a_is_valid(struct pn533_target_type_a
*type_a
,
673 if (target_data_len
< sizeof(struct pn533_target_type_a
))
677 * The length check of nfcid[] and ats[] are not being performed because
678 * the values are not being used
681 /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
682 ssd
= PN533_TYPE_A_SENS_RES_SSD(type_a
->sens_res
);
683 platconf
= PN533_TYPE_A_SENS_RES_PLATCONF(type_a
->sens_res
);
685 if ((ssd
== PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
686 platconf
!= PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
) ||
687 (ssd
!= PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
688 platconf
== PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
))
691 /* Requirements 4.8.2.1, 4.8.2.3, 4.8.2.5 and 4.8.2.7 from NFC Forum */
692 if (PN533_TYPE_A_SEL_CASCADE(type_a
->sel_res
) != 0)
698 static int pn533_target_found_type_a(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
701 struct pn533_target_type_a
*tgt_type_a
;
703 tgt_type_a
= (struct pn533_target_type_a
*)tgt_data
;
705 if (!pn533_target_type_a_is_valid(tgt_type_a
, tgt_data_len
))
708 switch (PN533_TYPE_A_SEL_PROT(tgt_type_a
->sel_res
)) {
709 case PN533_TYPE_A_SEL_PROT_MIFARE
:
710 nfc_tgt
->supported_protocols
= NFC_PROTO_MIFARE_MASK
;
712 case PN533_TYPE_A_SEL_PROT_ISO14443
:
713 nfc_tgt
->supported_protocols
= NFC_PROTO_ISO14443_MASK
;
715 case PN533_TYPE_A_SEL_PROT_DEP
:
716 nfc_tgt
->supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
718 case PN533_TYPE_A_SEL_PROT_ISO14443_DEP
:
719 nfc_tgt
->supported_protocols
= NFC_PROTO_ISO14443_MASK
|
720 NFC_PROTO_NFC_DEP_MASK
;
724 nfc_tgt
->sens_res
= be16_to_cpu(tgt_type_a
->sens_res
);
725 nfc_tgt
->sel_res
= tgt_type_a
->sel_res
;
726 nfc_tgt
->nfcid1_len
= tgt_type_a
->nfcid_len
;
727 memcpy(nfc_tgt
->nfcid1
, tgt_type_a
->nfcid_data
, nfc_tgt
->nfcid1_len
);
732 struct pn533_target_felica
{
735 u8 nfcid2
[NFC_NFCID2_MAXSIZE
];
741 #define PN533_FELICA_SENSF_NFCID2_DEP_B1 0x01
742 #define PN533_FELICA_SENSF_NFCID2_DEP_B2 0xFE
744 static bool pn533_target_felica_is_valid(struct pn533_target_felica
*felica
,
747 if (target_data_len
< sizeof(struct pn533_target_felica
))
750 if (felica
->opcode
!= PN533_FELICA_OPC_SENSF_RES
)
756 static int pn533_target_found_felica(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
759 struct pn533_target_felica
*tgt_felica
;
761 tgt_felica
= (struct pn533_target_felica
*)tgt_data
;
763 if (!pn533_target_felica_is_valid(tgt_felica
, tgt_data_len
))
766 if ((tgt_felica
->nfcid2
[0] == PN533_FELICA_SENSF_NFCID2_DEP_B1
) &&
767 (tgt_felica
->nfcid2
[1] == PN533_FELICA_SENSF_NFCID2_DEP_B2
))
768 nfc_tgt
->supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
770 nfc_tgt
->supported_protocols
= NFC_PROTO_FELICA_MASK
;
772 memcpy(nfc_tgt
->sensf_res
, &tgt_felica
->opcode
, 9);
773 nfc_tgt
->sensf_res_len
= 9;
775 memcpy(nfc_tgt
->nfcid2
, tgt_felica
->nfcid2
, NFC_NFCID2_MAXSIZE
);
776 nfc_tgt
->nfcid2_len
= NFC_NFCID2_MAXSIZE
;
781 struct pn533_target_jewel
{
786 static bool pn533_target_jewel_is_valid(struct pn533_target_jewel
*jewel
,
792 if (target_data_len
< sizeof(struct pn533_target_jewel
))
795 /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
796 ssd
= PN533_TYPE_A_SENS_RES_SSD(jewel
->sens_res
);
797 platconf
= PN533_TYPE_A_SENS_RES_PLATCONF(jewel
->sens_res
);
799 if ((ssd
== PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
800 platconf
!= PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
) ||
801 (ssd
!= PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
802 platconf
== PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
))
808 static int pn533_target_found_jewel(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
811 struct pn533_target_jewel
*tgt_jewel
;
813 tgt_jewel
= (struct pn533_target_jewel
*)tgt_data
;
815 if (!pn533_target_jewel_is_valid(tgt_jewel
, tgt_data_len
))
818 nfc_tgt
->supported_protocols
= NFC_PROTO_JEWEL_MASK
;
819 nfc_tgt
->sens_res
= be16_to_cpu(tgt_jewel
->sens_res
);
820 nfc_tgt
->nfcid1_len
= 4;
821 memcpy(nfc_tgt
->nfcid1
, tgt_jewel
->jewelid
, nfc_tgt
->nfcid1_len
);
826 struct pn533_type_b_prot_info
{
832 #define PN533_TYPE_B_PROT_FCSI(x) (((x) & 0xF0) >> 4)
833 #define PN533_TYPE_B_PROT_TYPE(x) (((x) & 0x0F) >> 0)
834 #define PN533_TYPE_B_PROT_TYPE_RFU_MASK 0x8
836 struct pn533_type_b_sens_res
{
840 struct pn533_type_b_prot_info prot_info
;
843 #define PN533_TYPE_B_OPC_SENSB_RES 0x50
845 struct pn533_target_type_b
{
846 struct pn533_type_b_sens_res sensb_res
;
851 static bool pn533_target_type_b_is_valid(struct pn533_target_type_b
*type_b
,
854 if (target_data_len
< sizeof(struct pn533_target_type_b
))
857 if (type_b
->sensb_res
.opcode
!= PN533_TYPE_B_OPC_SENSB_RES
)
860 if (PN533_TYPE_B_PROT_TYPE(type_b
->sensb_res
.prot_info
.fsci_type
) &
861 PN533_TYPE_B_PROT_TYPE_RFU_MASK
)
867 static int pn533_target_found_type_b(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
870 struct pn533_target_type_b
*tgt_type_b
;
872 tgt_type_b
= (struct pn533_target_type_b
*)tgt_data
;
874 if (!pn533_target_type_b_is_valid(tgt_type_b
, tgt_data_len
))
877 nfc_tgt
->supported_protocols
= NFC_PROTO_ISO14443_B_MASK
;
882 static void pn533_poll_reset_mod_list(struct pn533
*dev
);
883 static int pn533_target_found(struct pn533
*dev
, u8 tg
, u8
*tgdata
,
886 struct nfc_target nfc_tgt
;
889 dev_dbg(dev
->dev
, "%s: modulation=%d\n",
890 __func__
, dev
->poll_mod_curr
);
895 memset(&nfc_tgt
, 0, sizeof(struct nfc_target
));
897 switch (dev
->poll_mod_curr
) {
898 case PN533_POLL_MOD_106KBPS_A
:
899 rc
= pn533_target_found_type_a(&nfc_tgt
, tgdata
, tgdata_len
);
901 case PN533_POLL_MOD_212KBPS_FELICA
:
902 case PN533_POLL_MOD_424KBPS_FELICA
:
903 rc
= pn533_target_found_felica(&nfc_tgt
, tgdata
, tgdata_len
);
905 case PN533_POLL_MOD_106KBPS_JEWEL
:
906 rc
= pn533_target_found_jewel(&nfc_tgt
, tgdata
, tgdata_len
);
908 case PN533_POLL_MOD_847KBPS_B
:
909 rc
= pn533_target_found_type_b(&nfc_tgt
, tgdata
, tgdata_len
);
913 "Unknown current poll modulation\n");
920 if (!(nfc_tgt
.supported_protocols
& dev
->poll_protocols
)) {
922 "The Tg found doesn't have the desired protocol\n");
927 "Target found - supported protocols: 0x%x\n",
928 nfc_tgt
.supported_protocols
);
930 dev
->tgt_available_prots
= nfc_tgt
.supported_protocols
;
932 pn533_poll_reset_mod_list(dev
);
933 nfc_targets_found(dev
->nfc_dev
, &nfc_tgt
, 1);
938 static inline void pn533_poll_next_mod(struct pn533
*dev
)
940 dev
->poll_mod_curr
= (dev
->poll_mod_curr
+ 1) % dev
->poll_mod_count
;
943 static void pn533_poll_reset_mod_list(struct pn533
*dev
)
945 dev
->poll_mod_count
= 0;
948 static void pn533_poll_add_mod(struct pn533
*dev
, u8 mod_index
)
950 dev
->poll_mod_active
[dev
->poll_mod_count
] =
951 (struct pn533_poll_modulations
*)&poll_mod
[mod_index
];
952 dev
->poll_mod_count
++;
955 static void pn533_poll_create_mod_list(struct pn533
*dev
,
956 u32 im_protocols
, u32 tm_protocols
)
958 pn533_poll_reset_mod_list(dev
);
960 if ((im_protocols
& NFC_PROTO_MIFARE_MASK
) ||
961 (im_protocols
& NFC_PROTO_ISO14443_MASK
) ||
962 (im_protocols
& NFC_PROTO_NFC_DEP_MASK
))
963 pn533_poll_add_mod(dev
, PN533_POLL_MOD_106KBPS_A
);
965 if (im_protocols
& NFC_PROTO_FELICA_MASK
||
966 im_protocols
& NFC_PROTO_NFC_DEP_MASK
) {
967 pn533_poll_add_mod(dev
, PN533_POLL_MOD_212KBPS_FELICA
);
968 pn533_poll_add_mod(dev
, PN533_POLL_MOD_424KBPS_FELICA
);
971 if (im_protocols
& NFC_PROTO_JEWEL_MASK
)
972 pn533_poll_add_mod(dev
, PN533_POLL_MOD_106KBPS_JEWEL
);
974 if (im_protocols
& NFC_PROTO_ISO14443_B_MASK
)
975 pn533_poll_add_mod(dev
, PN533_POLL_MOD_847KBPS_B
);
978 pn533_poll_add_mod(dev
, PN533_LISTEN_MOD
);
981 static int pn533_start_poll_complete(struct pn533
*dev
, struct sk_buff
*resp
)
983 u8 nbtg
, tg
, *tgdata
;
986 /* Toggle the DEP polling */
987 if (dev
->poll_protocols
& NFC_PROTO_NFC_DEP_MASK
)
990 nbtg
= resp
->data
[0];
992 tgdata
= &resp
->data
[2];
993 tgdata_len
= resp
->len
- 2; /* nbtg + tg */
996 rc
= pn533_target_found(dev
, tg
, tgdata
, tgdata_len
);
998 /* We must stop the poll after a valid target found */
1006 static struct sk_buff
*pn533_alloc_poll_tg_frame(struct pn533
*dev
)
1008 struct sk_buff
*skb
;
1009 u8
*felica
, *nfcid3
, *gb
;
1011 u8
*gbytes
= dev
->gb
;
1012 size_t gbytes_len
= dev
->gb_len
;
1014 u8 felica_params
[18] = {0x1, 0xfe, /* DEP */
1015 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, /* random */
1016 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
1017 0xff, 0xff}; /* System code */
1019 u8 mifare_params
[6] = {0x1, 0x1, /* SENS_RES */
1021 0x40}; /* SEL_RES for DEP */
1023 unsigned int skb_len
= 36 + /*
1024 * mode (1), mifare (6),
1025 * felica (18), nfcid3 (10), gb_len (1)
1030 skb
= pn533_alloc_skb(dev
, skb_len
);
1034 /* DEP support only */
1035 *skb_put(skb
, 1) = PN533_INIT_TARGET_DEP
;
1038 memcpy(skb_put(skb
, 6), mifare_params
, 6);
1041 felica
= skb_put(skb
, 18);
1042 memcpy(felica
, felica_params
, 18);
1043 get_random_bytes(felica
+ 2, 6);
1046 nfcid3
= skb_put(skb
, 10);
1047 memset(nfcid3
, 0, 10);
1048 memcpy(nfcid3
, felica
, 8);
1051 *skb_put(skb
, 1) = gbytes_len
;
1053 gb
= skb_put(skb
, gbytes_len
);
1054 memcpy(gb
, gbytes
, gbytes_len
);
1057 *skb_put(skb
, 1) = 0;
1062 static void pn533_wq_tm_mi_recv(struct work_struct
*work
);
1063 static struct sk_buff
*pn533_build_response(struct pn533
*dev
);
1065 static int pn533_tm_get_data_complete(struct pn533
*dev
, void *arg
,
1066 struct sk_buff
*resp
)
1068 struct sk_buff
*skb
;
1072 dev_dbg(dev
->dev
, "%s\n", __func__
);
1075 skb_queue_purge(&dev
->resp_q
);
1076 return PTR_ERR(resp
);
1079 status
= resp
->data
[0];
1081 ret
= status
& PN533_CMD_RET_MASK
;
1082 mi
= status
& PN533_CMD_MI_MASK
;
1084 skb_pull(resp
, sizeof(status
));
1086 if (ret
!= PN533_CMD_RET_SUCCESS
) {
1091 skb_queue_tail(&dev
->resp_q
, resp
);
1094 queue_work(dev
->wq
, &dev
->mi_tm_rx_work
);
1095 return -EINPROGRESS
;
1098 skb
= pn533_build_response(dev
);
1104 return nfc_tm_data_received(dev
->nfc_dev
, skb
);
1107 nfc_tm_deactivated(dev
->nfc_dev
);
1109 skb_queue_purge(&dev
->resp_q
);
1110 dev_kfree_skb(resp
);
1115 static void pn533_wq_tm_mi_recv(struct work_struct
*work
)
1117 struct pn533
*dev
= container_of(work
, struct pn533
, mi_tm_rx_work
);
1118 struct sk_buff
*skb
;
1121 dev_dbg(dev
->dev
, "%s\n", __func__
);
1123 skb
= pn533_alloc_skb(dev
, 0);
1127 rc
= pn533_send_cmd_direct_async(dev
,
1128 PN533_CMD_TG_GET_DATA
,
1130 pn533_tm_get_data_complete
,
1137 static int pn533_tm_send_complete(struct pn533
*dev
, void *arg
,
1138 struct sk_buff
*resp
);
1139 static void pn533_wq_tm_mi_send(struct work_struct
*work
)
1141 struct pn533
*dev
= container_of(work
, struct pn533
, mi_tm_tx_work
);
1142 struct sk_buff
*skb
;
1145 dev_dbg(dev
->dev
, "%s\n", __func__
);
1147 /* Grab the first skb in the queue */
1148 skb
= skb_dequeue(&dev
->fragment_skb
);
1149 if (skb
== NULL
) { /* No more data */
1150 /* Reset the queue for future use */
1151 skb_queue_head_init(&dev
->fragment_skb
);
1155 /* last entry - remove MI bit */
1156 if (skb_queue_len(&dev
->fragment_skb
) == 0) {
1157 rc
= pn533_send_cmd_direct_async(dev
, PN533_CMD_TG_SET_DATA
,
1158 skb
, pn533_tm_send_complete
, NULL
);
1160 rc
= pn533_send_cmd_direct_async(dev
,
1161 PN533_CMD_TG_SET_META_DATA
,
1162 skb
, pn533_tm_send_complete
, NULL
);
1164 if (rc
== 0) /* success */
1168 "Error %d when trying to perform set meta data_exchange", rc
);
1173 dev
->phy_ops
->send_ack(dev
, GFP_KERNEL
);
1174 queue_work(dev
->wq
, &dev
->cmd_work
);
1177 static void pn533_wq_tg_get_data(struct work_struct
*work
)
1179 struct pn533
*dev
= container_of(work
, struct pn533
, tg_work
);
1180 struct sk_buff
*skb
;
1183 dev_dbg(dev
->dev
, "%s\n", __func__
);
1185 skb
= pn533_alloc_skb(dev
, 0);
1189 rc
= pn533_send_data_async(dev
, PN533_CMD_TG_GET_DATA
, skb
,
1190 pn533_tm_get_data_complete
, NULL
);
1196 #define ATR_REQ_GB_OFFSET 17
1197 static int pn533_init_target_complete(struct pn533
*dev
, struct sk_buff
*resp
)
1199 u8 mode
, *cmd
, comm_mode
= NFC_COMM_PASSIVE
, *gb
;
1203 dev_dbg(dev
->dev
, "%s\n", __func__
);
1205 if (resp
->len
< ATR_REQ_GB_OFFSET
+ 1)
1208 mode
= resp
->data
[0];
1209 cmd
= &resp
->data
[1];
1211 dev_dbg(dev
->dev
, "Target mode 0x%x len %d\n",
1214 if ((mode
& PN533_INIT_TARGET_RESP_FRAME_MASK
) ==
1215 PN533_INIT_TARGET_RESP_ACTIVE
)
1216 comm_mode
= NFC_COMM_ACTIVE
;
1218 if ((mode
& PN533_INIT_TARGET_RESP_DEP
) == 0) /* Only DEP supported */
1221 gb
= cmd
+ ATR_REQ_GB_OFFSET
;
1222 gb_len
= resp
->len
- (ATR_REQ_GB_OFFSET
+ 1);
1224 rc
= nfc_tm_activated(dev
->nfc_dev
, NFC_PROTO_NFC_DEP_MASK
,
1225 comm_mode
, gb
, gb_len
);
1228 "Error when signaling target activation\n");
1233 queue_work(dev
->wq
, &dev
->tg_work
);
1238 static void pn533_listen_mode_timer(unsigned long data
)
1240 struct pn533
*dev
= (struct pn533
*)data
;
1242 dev_dbg(dev
->dev
, "Listen mode timeout\n");
1244 dev
->cancel_listen
= 1;
1246 pn533_poll_next_mod(dev
);
1248 queue_delayed_work(dev
->wq
, &dev
->poll_work
,
1249 msecs_to_jiffies(PN533_POLL_INTERVAL
));
1252 static int pn533_rf_complete(struct pn533
*dev
, void *arg
,
1253 struct sk_buff
*resp
)
1257 dev_dbg(dev
->dev
, "%s\n", __func__
);
1262 nfc_err(dev
->dev
, "RF setting error %d\n", rc
);
1267 queue_delayed_work(dev
->wq
, &dev
->poll_work
,
1268 msecs_to_jiffies(PN533_POLL_INTERVAL
));
1270 dev_kfree_skb(resp
);
1274 static void pn533_wq_rf(struct work_struct
*work
)
1276 struct pn533
*dev
= container_of(work
, struct pn533
, rf_work
);
1277 struct sk_buff
*skb
;
1280 dev_dbg(dev
->dev
, "%s\n", __func__
);
1282 skb
= pn533_alloc_skb(dev
, 2);
1286 *skb_put(skb
, 1) = PN533_CFGITEM_RF_FIELD
;
1287 *skb_put(skb
, 1) = PN533_CFGITEM_RF_FIELD_AUTO_RFCA
;
1289 rc
= pn533_send_cmd_async(dev
, PN533_CMD_RF_CONFIGURATION
, skb
,
1290 pn533_rf_complete
, NULL
);
1293 nfc_err(dev
->dev
, "RF setting error %d\n", rc
);
1297 static int pn533_poll_dep_complete(struct pn533
*dev
, void *arg
,
1298 struct sk_buff
*resp
)
1300 struct pn533_cmd_jump_dep_response
*rsp
;
1301 struct nfc_target nfc_target
;
1306 return PTR_ERR(resp
);
1308 rsp
= (struct pn533_cmd_jump_dep_response
*)resp
->data
;
1310 rc
= rsp
->status
& PN533_CMD_RET_MASK
;
1311 if (rc
!= PN533_CMD_RET_SUCCESS
) {
1312 /* Not target found, turn radio off */
1313 queue_work(dev
->wq
, &dev
->rf_work
);
1315 dev_kfree_skb(resp
);
1319 dev_dbg(dev
->dev
, "Creating new target");
1321 nfc_target
.supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
1322 nfc_target
.nfcid1_len
= 10;
1323 memcpy(nfc_target
.nfcid1
, rsp
->nfcid3t
, nfc_target
.nfcid1_len
);
1324 rc
= nfc_targets_found(dev
->nfc_dev
, &nfc_target
, 1);
1328 dev
->tgt_available_prots
= 0;
1329 dev
->tgt_active_prot
= NFC_PROTO_NFC_DEP
;
1331 /* ATR_RES general bytes are located at offset 17 */
1332 target_gt_len
= resp
->len
- 17;
1333 rc
= nfc_set_remote_general_bytes(dev
->nfc_dev
,
1334 rsp
->gt
, target_gt_len
);
1336 rc
= nfc_dep_link_is_up(dev
->nfc_dev
,
1337 dev
->nfc_dev
->targets
[0].idx
,
1338 0, NFC_RF_INITIATOR
);
1341 pn533_poll_reset_mod_list(dev
);
1344 dev_kfree_skb(resp
);
1348 #define PASSIVE_DATA_LEN 5
1349 static int pn533_poll_dep(struct nfc_dev
*nfc_dev
)
1351 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1352 struct sk_buff
*skb
;
1354 u8
*next
, nfcid3
[NFC_NFCID3_MAXSIZE
];
1355 u8 passive_data
[PASSIVE_DATA_LEN
] = {0x00, 0xff, 0xff, 0x00, 0x3};
1357 dev_dbg(dev
->dev
, "%s", __func__
);
1360 dev
->gb
= nfc_get_local_general_bytes(nfc_dev
, &dev
->gb_len
);
1362 if (!dev
->gb
|| !dev
->gb_len
) {
1364 queue_work(dev
->wq
, &dev
->rf_work
);
1368 skb_len
= 3 + dev
->gb_len
; /* ActPass + BR + Next */
1369 skb_len
+= PASSIVE_DATA_LEN
;
1372 skb_len
+= NFC_NFCID3_MAXSIZE
;
1375 get_random_bytes(nfcid3
+ 2, 6);
1377 skb
= pn533_alloc_skb(dev
, skb_len
);
1381 *skb_put(skb
, 1) = 0x01; /* Active */
1382 *skb_put(skb
, 1) = 0x02; /* 424 kbps */
1384 next
= skb_put(skb
, 1); /* Next */
1387 /* Copy passive data */
1388 memcpy(skb_put(skb
, PASSIVE_DATA_LEN
), passive_data
, PASSIVE_DATA_LEN
);
1391 /* Copy NFCID3 (which is NFCID2 from SENSF_RES) */
1392 memcpy(skb_put(skb
, NFC_NFCID3_MAXSIZE
), nfcid3
,
1393 NFC_NFCID3_MAXSIZE
);
1396 memcpy(skb_put(skb
, dev
->gb_len
), dev
->gb
, dev
->gb_len
);
1397 *next
|= 4; /* We have some Gi */
1399 rc
= pn533_send_cmd_async(dev
, PN533_CMD_IN_JUMP_FOR_DEP
, skb
,
1400 pn533_poll_dep_complete
, NULL
);
1408 static int pn533_poll_complete(struct pn533
*dev
, void *arg
,
1409 struct sk_buff
*resp
)
1411 struct pn533_poll_modulations
*cur_mod
;
1414 dev_dbg(dev
->dev
, "%s\n", __func__
);
1419 nfc_err(dev
->dev
, "%s Poll complete error %d\n",
1422 if (rc
== -ENOENT
) {
1423 if (dev
->poll_mod_count
!= 0)
1426 } else if (rc
< 0) {
1428 "Error %d when running poll\n", rc
);
1433 cur_mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1435 if (cur_mod
->len
== 0) { /* Target mode */
1436 del_timer(&dev
->listen_timer
);
1437 rc
= pn533_init_target_complete(dev
, resp
);
1441 /* Initiator mode */
1442 rc
= pn533_start_poll_complete(dev
, resp
);
1446 if (!dev
->poll_mod_count
) {
1447 dev_dbg(dev
->dev
, "Polling has been stopped\n");
1451 pn533_poll_next_mod(dev
);
1452 /* Not target found, turn radio off */
1453 queue_work(dev
->wq
, &dev
->rf_work
);
1456 dev_kfree_skb(resp
);
1460 nfc_err(dev
->dev
, "Polling operation has been stopped\n");
1462 pn533_poll_reset_mod_list(dev
);
1463 dev
->poll_protocols
= 0;
1467 static struct sk_buff
*pn533_alloc_poll_in_frame(struct pn533
*dev
,
1468 struct pn533_poll_modulations
*mod
)
1470 struct sk_buff
*skb
;
1472 skb
= pn533_alloc_skb(dev
, mod
->len
);
1476 memcpy(skb_put(skb
, mod
->len
), &mod
->data
, mod
->len
);
1481 static int pn533_send_poll_frame(struct pn533
*dev
)
1483 struct pn533_poll_modulations
*mod
;
1484 struct sk_buff
*skb
;
1488 mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1490 dev_dbg(dev
->dev
, "%s mod len %d\n",
1491 __func__
, mod
->len
);
1493 if ((dev
->poll_protocols
& NFC_PROTO_NFC_DEP_MASK
) && dev
->poll_dep
) {
1495 return pn533_poll_dep(dev
->nfc_dev
);
1498 if (mod
->len
== 0) { /* Listen mode */
1499 cmd_code
= PN533_CMD_TG_INIT_AS_TARGET
;
1500 skb
= pn533_alloc_poll_tg_frame(dev
);
1501 } else { /* Polling mode */
1502 cmd_code
= PN533_CMD_IN_LIST_PASSIVE_TARGET
;
1503 skb
= pn533_alloc_poll_in_frame(dev
, mod
);
1507 nfc_err(dev
->dev
, "Failed to allocate skb\n");
1511 rc
= pn533_send_cmd_async(dev
, cmd_code
, skb
, pn533_poll_complete
,
1515 nfc_err(dev
->dev
, "Polling loop error %d\n", rc
);
1521 static void pn533_wq_poll(struct work_struct
*work
)
1523 struct pn533
*dev
= container_of(work
, struct pn533
, poll_work
.work
);
1524 struct pn533_poll_modulations
*cur_mod
;
1527 cur_mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1530 "%s cancel_listen %d modulation len %d\n",
1531 __func__
, dev
->cancel_listen
, cur_mod
->len
);
1533 if (dev
->cancel_listen
== 1) {
1534 dev
->cancel_listen
= 0;
1535 dev
->phy_ops
->abort_cmd(dev
, GFP_ATOMIC
);
1538 rc
= pn533_send_poll_frame(dev
);
1542 if (cur_mod
->len
== 0 && dev
->poll_mod_count
> 1)
1543 mod_timer(&dev
->listen_timer
, jiffies
+ PN533_LISTEN_TIME
* HZ
);
1546 static int pn533_start_poll(struct nfc_dev
*nfc_dev
,
1547 u32 im_protocols
, u32 tm_protocols
)
1549 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1550 struct pn533_poll_modulations
*cur_mod
;
1555 "%s: im protocols 0x%x tm protocols 0x%x\n",
1556 __func__
, im_protocols
, tm_protocols
);
1558 if (dev
->tgt_active_prot
) {
1560 "Cannot poll with a target already activated\n");
1564 if (dev
->tgt_mode
) {
1566 "Cannot poll while already being activated\n");
1571 dev
->gb
= nfc_get_local_general_bytes(nfc_dev
, &dev
->gb_len
);
1572 if (dev
->gb
== NULL
)
1576 pn533_poll_create_mod_list(dev
, im_protocols
, tm_protocols
);
1577 dev
->poll_protocols
= im_protocols
;
1578 dev
->listen_protocols
= tm_protocols
;
1580 /* Do not always start polling from the same modulation */
1581 get_random_bytes(&rand_mod
, sizeof(rand_mod
));
1582 rand_mod
%= dev
->poll_mod_count
;
1583 dev
->poll_mod_curr
= rand_mod
;
1585 cur_mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1587 rc
= pn533_send_poll_frame(dev
);
1589 /* Start listen timer */
1590 if (!rc
&& cur_mod
->len
== 0 && dev
->poll_mod_count
> 1)
1591 mod_timer(&dev
->listen_timer
, jiffies
+ PN533_LISTEN_TIME
* HZ
);
1596 static void pn533_stop_poll(struct nfc_dev
*nfc_dev
)
1598 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1600 del_timer(&dev
->listen_timer
);
1602 if (!dev
->poll_mod_count
) {
1604 "Polling operation was not running\n");
1608 dev
->phy_ops
->abort_cmd(dev
, GFP_KERNEL
);
1609 flush_delayed_work(&dev
->poll_work
);
1610 pn533_poll_reset_mod_list(dev
);
1613 static int pn533_activate_target_nfcdep(struct pn533
*dev
)
1615 struct pn533_cmd_activate_response
*rsp
;
1618 struct sk_buff
*skb
;
1619 struct sk_buff
*resp
;
1621 dev_dbg(dev
->dev
, "%s\n", __func__
);
1623 skb
= pn533_alloc_skb(dev
, sizeof(u8
) * 2); /*TG + Next*/
1627 *skb_put(skb
, sizeof(u8
)) = 1; /* TG */
1628 *skb_put(skb
, sizeof(u8
)) = 0; /* Next */
1630 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_IN_ATR
, skb
);
1632 return PTR_ERR(resp
);
1634 rsp
= (struct pn533_cmd_activate_response
*)resp
->data
;
1635 rc
= rsp
->status
& PN533_CMD_RET_MASK
;
1636 if (rc
!= PN533_CMD_RET_SUCCESS
) {
1638 "Target activation failed (error 0x%x)\n", rc
);
1639 dev_kfree_skb(resp
);
1643 /* ATR_RES general bytes are located at offset 16 */
1644 gt_len
= resp
->len
- 16;
1645 rc
= nfc_set_remote_general_bytes(dev
->nfc_dev
, rsp
->gt
, gt_len
);
1647 dev_kfree_skb(resp
);
1651 static int pn533_activate_target(struct nfc_dev
*nfc_dev
,
1652 struct nfc_target
*target
, u32 protocol
)
1654 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1657 dev_dbg(dev
->dev
, "%s: protocol=%u\n", __func__
, protocol
);
1659 if (dev
->poll_mod_count
) {
1661 "Cannot activate while polling\n");
1665 if (dev
->tgt_active_prot
) {
1667 "There is already an active target\n");
1671 if (!dev
->tgt_available_prots
) {
1673 "There is no available target to activate\n");
1677 if (!(dev
->tgt_available_prots
& (1 << protocol
))) {
1679 "Target doesn't support requested proto %u\n",
1684 if (protocol
== NFC_PROTO_NFC_DEP
) {
1685 rc
= pn533_activate_target_nfcdep(dev
);
1688 "Activating target with DEP failed %d\n", rc
);
1693 dev
->tgt_active_prot
= protocol
;
1694 dev
->tgt_available_prots
= 0;
1699 static int pn533_deactivate_target_complete(struct pn533
*dev
, void *arg
,
1700 struct sk_buff
*resp
)
1704 dev_dbg(dev
->dev
, "%s\n", __func__
);
1709 nfc_err(dev
->dev
, "Target release error %d\n", rc
);
1714 rc
= resp
->data
[0] & PN533_CMD_RET_MASK
;
1715 if (rc
!= PN533_CMD_RET_SUCCESS
)
1717 "Error 0x%x when releasing the target\n", rc
);
1719 dev_kfree_skb(resp
);
1723 static void pn533_deactivate_target(struct nfc_dev
*nfc_dev
,
1724 struct nfc_target
*target
, u8 mode
)
1726 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1727 struct sk_buff
*skb
;
1730 dev_dbg(dev
->dev
, "%s\n", __func__
);
1732 if (!dev
->tgt_active_prot
) {
1733 nfc_err(dev
->dev
, "There is no active target\n");
1737 dev
->tgt_active_prot
= 0;
1738 skb_queue_purge(&dev
->resp_q
);
1740 skb
= pn533_alloc_skb(dev
, sizeof(u8
));
1744 *skb_put(skb
, 1) = 1; /* TG*/
1746 rc
= pn533_send_cmd_async(dev
, PN533_CMD_IN_RELEASE
, skb
,
1747 pn533_deactivate_target_complete
, NULL
);
1750 nfc_err(dev
->dev
, "Target release error %d\n", rc
);
1755 static int pn533_in_dep_link_up_complete(struct pn533
*dev
, void *arg
,
1756 struct sk_buff
*resp
)
1758 struct pn533_cmd_jump_dep_response
*rsp
;
1761 u8 active
= *(u8
*)arg
;
1766 return PTR_ERR(resp
);
1768 if (dev
->tgt_available_prots
&&
1769 !(dev
->tgt_available_prots
& (1 << NFC_PROTO_NFC_DEP
))) {
1771 "The target does not support DEP\n");
1776 rsp
= (struct pn533_cmd_jump_dep_response
*)resp
->data
;
1778 rc
= rsp
->status
& PN533_CMD_RET_MASK
;
1779 if (rc
!= PN533_CMD_RET_SUCCESS
) {
1781 "Bringing DEP link up failed (error 0x%x)\n", rc
);
1785 if (!dev
->tgt_available_prots
) {
1786 struct nfc_target nfc_target
;
1788 dev_dbg(dev
->dev
, "Creating new target\n");
1790 nfc_target
.supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
1791 nfc_target
.nfcid1_len
= 10;
1792 memcpy(nfc_target
.nfcid1
, rsp
->nfcid3t
, nfc_target
.nfcid1_len
);
1793 rc
= nfc_targets_found(dev
->nfc_dev
, &nfc_target
, 1);
1797 dev
->tgt_available_prots
= 0;
1800 dev
->tgt_active_prot
= NFC_PROTO_NFC_DEP
;
1802 /* ATR_RES general bytes are located at offset 17 */
1803 target_gt_len
= resp
->len
- 17;
1804 rc
= nfc_set_remote_general_bytes(dev
->nfc_dev
,
1805 rsp
->gt
, target_gt_len
);
1807 rc
= nfc_dep_link_is_up(dev
->nfc_dev
,
1808 dev
->nfc_dev
->targets
[0].idx
,
1809 !active
, NFC_RF_INITIATOR
);
1812 dev_kfree_skb(resp
);
1816 static int pn533_rf_field(struct nfc_dev
*nfc_dev
, u8 rf
);
1817 static int pn533_dep_link_up(struct nfc_dev
*nfc_dev
, struct nfc_target
*target
,
1818 u8 comm_mode
, u8
*gb
, size_t gb_len
)
1820 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1821 struct sk_buff
*skb
;
1823 u8
*next
, *arg
, nfcid3
[NFC_NFCID3_MAXSIZE
];
1824 u8 passive_data
[PASSIVE_DATA_LEN
] = {0x00, 0xff, 0xff, 0x00, 0x3};
1826 dev_dbg(dev
->dev
, "%s\n", __func__
);
1828 if (dev
->poll_mod_count
) {
1830 "Cannot bring the DEP link up while polling\n");
1834 if (dev
->tgt_active_prot
) {
1836 "There is already an active target\n");
1840 skb_len
= 3 + gb_len
; /* ActPass + BR + Next */
1841 skb_len
+= PASSIVE_DATA_LEN
;
1844 skb_len
+= NFC_NFCID3_MAXSIZE
;
1845 if (target
&& !target
->nfcid2_len
) {
1848 get_random_bytes(nfcid3
+ 2, 6);
1851 skb
= pn533_alloc_skb(dev
, skb_len
);
1855 *skb_put(skb
, 1) = !comm_mode
; /* ActPass */
1856 *skb_put(skb
, 1) = 0x02; /* 424 kbps */
1858 next
= skb_put(skb
, 1); /* Next */
1861 /* Copy passive data */
1862 memcpy(skb_put(skb
, PASSIVE_DATA_LEN
), passive_data
, PASSIVE_DATA_LEN
);
1865 /* Copy NFCID3 (which is NFCID2 from SENSF_RES) */
1866 if (target
&& target
->nfcid2_len
)
1867 memcpy(skb_put(skb
, NFC_NFCID3_MAXSIZE
), target
->nfcid2
,
1868 target
->nfcid2_len
);
1870 memcpy(skb_put(skb
, NFC_NFCID3_MAXSIZE
), nfcid3
,
1871 NFC_NFCID3_MAXSIZE
);
1874 if (gb
!= NULL
&& gb_len
> 0) {
1875 memcpy(skb_put(skb
, gb_len
), gb
, gb_len
);
1876 *next
|= 4; /* We have some Gi */
1881 arg
= kmalloc(sizeof(*arg
), GFP_KERNEL
);
1889 pn533_rf_field(dev
->nfc_dev
, 0);
1891 rc
= pn533_send_cmd_async(dev
, PN533_CMD_IN_JUMP_FOR_DEP
, skb
,
1892 pn533_in_dep_link_up_complete
, arg
);
1902 static int pn533_dep_link_down(struct nfc_dev
*nfc_dev
)
1904 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1906 dev_dbg(dev
->dev
, "%s\n", __func__
);
1908 pn533_poll_reset_mod_list(dev
);
1910 if (dev
->tgt_mode
|| dev
->tgt_active_prot
)
1911 dev
->phy_ops
->abort_cmd(dev
, GFP_KERNEL
);
1913 dev
->tgt_active_prot
= 0;
1916 skb_queue_purge(&dev
->resp_q
);
1921 struct pn533_data_exchange_arg
{
1922 data_exchange_cb_t cb
;
1926 static struct sk_buff
*pn533_build_response(struct pn533
*dev
)
1928 struct sk_buff
*skb
, *tmp
, *t
;
1929 unsigned int skb_len
= 0, tmp_len
= 0;
1931 dev_dbg(dev
->dev
, "%s\n", __func__
);
1933 if (skb_queue_empty(&dev
->resp_q
))
1936 if (skb_queue_len(&dev
->resp_q
) == 1) {
1937 skb
= skb_dequeue(&dev
->resp_q
);
1941 skb_queue_walk_safe(&dev
->resp_q
, tmp
, t
)
1942 skb_len
+= tmp
->len
;
1944 dev_dbg(dev
->dev
, "%s total length %d\n",
1947 skb
= alloc_skb(skb_len
, GFP_KERNEL
);
1951 skb_put(skb
, skb_len
);
1953 skb_queue_walk_safe(&dev
->resp_q
, tmp
, t
) {
1954 memcpy(skb
->data
+ tmp_len
, tmp
->data
, tmp
->len
);
1955 tmp_len
+= tmp
->len
;
1959 skb_queue_purge(&dev
->resp_q
);
1964 static int pn533_data_exchange_complete(struct pn533
*dev
, void *_arg
,
1965 struct sk_buff
*resp
)
1967 struct pn533_data_exchange_arg
*arg
= _arg
;
1968 struct sk_buff
*skb
;
1972 dev_dbg(dev
->dev
, "%s\n", __func__
);
1979 status
= resp
->data
[0];
1980 ret
= status
& PN533_CMD_RET_MASK
;
1981 mi
= status
& PN533_CMD_MI_MASK
;
1983 skb_pull(resp
, sizeof(status
));
1985 if (ret
!= PN533_CMD_RET_SUCCESS
) {
1987 "Exchanging data failed (error 0x%x)\n", ret
);
1992 skb_queue_tail(&dev
->resp_q
, resp
);
1995 dev
->cmd_complete_mi_arg
= arg
;
1996 queue_work(dev
->wq
, &dev
->mi_rx_work
);
1997 return -EINPROGRESS
;
2000 /* Prepare for the next round */
2001 if (skb_queue_len(&dev
->fragment_skb
) > 0) {
2002 dev
->cmd_complete_dep_arg
= arg
;
2003 queue_work(dev
->wq
, &dev
->mi_tx_work
);
2005 return -EINPROGRESS
;
2008 skb
= pn533_build_response(dev
);
2014 arg
->cb(arg
->cb_context
, skb
, 0);
2019 dev_kfree_skb(resp
);
2021 skb_queue_purge(&dev
->resp_q
);
2022 arg
->cb(arg
->cb_context
, NULL
, rc
);
2028 * Receive an incoming pn533 frame. skb contains only header and payload.
2029 * If skb == NULL, it is a notification that the link below is dead.
2031 void pn533_recv_frame(struct pn533
*dev
, struct sk_buff
*skb
, int status
)
2036 dev
->cmd
->status
= status
;
2039 dev_dbg(dev
->dev
, "%s: Error received: %d\n", __func__
, status
);
2044 pr_err("NULL Frame -> link is dead\n");
2048 if (pn533_rx_frame_is_ack(skb
->data
)) {
2049 dev_dbg(dev
->dev
, "%s: Received ACK frame\n", __func__
);
2054 print_hex_dump_debug("PN533 RX: ", DUMP_PREFIX_NONE
, 16, 1, skb
->data
,
2055 dev
->ops
->rx_frame_size(skb
->data
), false);
2057 if (!dev
->ops
->rx_is_frame_valid(skb
->data
, dev
)) {
2058 nfc_err(dev
->dev
, "Received an invalid frame\n");
2059 dev
->cmd
->status
= -EIO
;
2060 } else if (!pn533_rx_frame_is_cmd_response(dev
, skb
->data
)) {
2061 nfc_err(dev
->dev
, "It it not the response to the last command\n");
2062 dev
->cmd
->status
= -EIO
;
2065 dev
->cmd
->resp
= skb
;
2068 queue_work(dev
->wq
, &dev
->cmd_complete_work
);
2070 EXPORT_SYMBOL(pn533_recv_frame
);
2072 /* Split the Tx skb into small chunks */
2073 static int pn533_fill_fragment_skbs(struct pn533
*dev
, struct sk_buff
*skb
)
2075 struct sk_buff
*frag
;
2079 /* Remaining size */
2080 if (skb
->len
> PN533_CMD_DATAFRAME_MAXLEN
)
2081 frag_size
= PN533_CMD_DATAFRAME_MAXLEN
;
2083 frag_size
= skb
->len
;
2085 /* Allocate and reserve */
2086 frag
= pn533_alloc_skb(dev
, frag_size
);
2088 skb_queue_purge(&dev
->fragment_skb
);
2092 if (!dev
->tgt_mode
) {
2093 /* Reserve the TG/MI byte */
2094 skb_reserve(frag
, 1);
2097 if (frag_size
== PN533_CMD_DATAFRAME_MAXLEN
)
2098 *skb_push(frag
, sizeof(u8
)) =
2099 (PN533_CMD_MI_MASK
| 1);
2101 *skb_push(frag
, sizeof(u8
)) = 1; /* TG */
2104 memcpy(skb_put(frag
, frag_size
), skb
->data
, frag_size
);
2106 /* Reduce the size of incoming buffer */
2107 skb_pull(skb
, frag_size
);
2109 /* Add this to skb_queue */
2110 skb_queue_tail(&dev
->fragment_skb
, frag
);
2112 } while (skb
->len
> 0);
2116 return skb_queue_len(&dev
->fragment_skb
);
2119 static int pn533_transceive(struct nfc_dev
*nfc_dev
,
2120 struct nfc_target
*target
, struct sk_buff
*skb
,
2121 data_exchange_cb_t cb
, void *cb_context
)
2123 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
2124 struct pn533_data_exchange_arg
*arg
= NULL
;
2127 dev_dbg(dev
->dev
, "%s\n", __func__
);
2129 if (!dev
->tgt_active_prot
) {
2131 "Can't exchange data if there is no active target\n");
2136 arg
= kmalloc(sizeof(*arg
), GFP_KERNEL
);
2143 arg
->cb_context
= cb_context
;
2145 switch (dev
->device_type
) {
2146 case PN533_DEVICE_PASORI
:
2147 if (dev
->tgt_active_prot
== NFC_PROTO_FELICA
) {
2148 rc
= pn533_send_data_async(dev
, PN533_CMD_IN_COMM_THRU
,
2150 pn533_data_exchange_complete
,
2157 if (skb
->len
> PN533_CMD_DATAEXCH_DATA_MAXLEN
) {
2158 rc
= pn533_fill_fragment_skbs(dev
, skb
);
2162 skb
= skb_dequeue(&dev
->fragment_skb
);
2168 *skb_push(skb
, sizeof(u8
)) = 1; /* TG */
2171 rc
= pn533_send_data_async(dev
, PN533_CMD_IN_DATA_EXCHANGE
,
2172 skb
, pn533_data_exchange_complete
,
2178 if (rc
< 0) /* rc from send_async */
2189 static int pn533_tm_send_complete(struct pn533
*dev
, void *arg
,
2190 struct sk_buff
*resp
)
2194 dev_dbg(dev
->dev
, "%s\n", __func__
);
2197 return PTR_ERR(resp
);
2199 status
= resp
->data
[0];
2201 /* Prepare for the next round */
2202 if (skb_queue_len(&dev
->fragment_skb
) > 0) {
2203 queue_work(dev
->wq
, &dev
->mi_tm_tx_work
);
2204 return -EINPROGRESS
;
2206 dev_kfree_skb(resp
);
2209 nfc_tm_deactivated(dev
->nfc_dev
);
2216 queue_work(dev
->wq
, &dev
->tg_work
);
2221 static int pn533_tm_send(struct nfc_dev
*nfc_dev
, struct sk_buff
*skb
)
2223 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
2226 dev_dbg(dev
->dev
, "%s\n", __func__
);
2228 /* let's split in multiple chunks if size's too big */
2229 if (skb
->len
> PN533_CMD_DATAEXCH_DATA_MAXLEN
) {
2230 rc
= pn533_fill_fragment_skbs(dev
, skb
);
2234 /* get the first skb */
2235 skb
= skb_dequeue(&dev
->fragment_skb
);
2241 rc
= pn533_send_data_async(dev
, PN533_CMD_TG_SET_META_DATA
, skb
,
2242 pn533_tm_send_complete
, NULL
);
2245 rc
= pn533_send_data_async(dev
, PN533_CMD_TG_SET_DATA
, skb
,
2246 pn533_tm_send_complete
, NULL
);
2252 skb_queue_purge(&dev
->fragment_skb
);
2258 static void pn533_wq_mi_recv(struct work_struct
*work
)
2260 struct pn533
*dev
= container_of(work
, struct pn533
, mi_rx_work
);
2261 struct sk_buff
*skb
;
2264 dev_dbg(dev
->dev
, "%s\n", __func__
);
2266 skb
= pn533_alloc_skb(dev
, PN533_CMD_DATAEXCH_HEAD_LEN
);
2270 switch (dev
->device_type
) {
2271 case PN533_DEVICE_PASORI
:
2272 if (dev
->tgt_active_prot
== NFC_PROTO_FELICA
) {
2273 rc
= pn533_send_cmd_direct_async(dev
,
2274 PN533_CMD_IN_COMM_THRU
,
2276 pn533_data_exchange_complete
,
2277 dev
->cmd_complete_mi_arg
);
2282 *skb_put(skb
, sizeof(u8
)) = 1; /*TG*/
2284 rc
= pn533_send_cmd_direct_async(dev
,
2285 PN533_CMD_IN_DATA_EXCHANGE
,
2287 pn533_data_exchange_complete
,
2288 dev
->cmd_complete_mi_arg
);
2293 if (rc
== 0) /* success */
2297 "Error %d when trying to perform data_exchange\n", rc
);
2300 kfree(dev
->cmd_complete_mi_arg
);
2303 dev
->phy_ops
->send_ack(dev
, GFP_KERNEL
);
2304 queue_work(dev
->wq
, &dev
->cmd_work
);
2307 static void pn533_wq_mi_send(struct work_struct
*work
)
2309 struct pn533
*dev
= container_of(work
, struct pn533
, mi_tx_work
);
2310 struct sk_buff
*skb
;
2313 dev_dbg(dev
->dev
, "%s\n", __func__
);
2315 /* Grab the first skb in the queue */
2316 skb
= skb_dequeue(&dev
->fragment_skb
);
2318 if (skb
== NULL
) { /* No more data */
2319 /* Reset the queue for future use */
2320 skb_queue_head_init(&dev
->fragment_skb
);
2324 switch (dev
->device_type
) {
2325 case PN533_DEVICE_PASORI
:
2326 if (dev
->tgt_active_prot
!= NFC_PROTO_FELICA
) {
2331 rc
= pn533_send_cmd_direct_async(dev
, PN533_CMD_IN_COMM_THRU
,
2333 pn533_data_exchange_complete
,
2334 dev
->cmd_complete_dep_arg
);
2339 /* Still some fragments? */
2340 rc
= pn533_send_cmd_direct_async(dev
,
2341 PN533_CMD_IN_DATA_EXCHANGE
,
2343 pn533_data_exchange_complete
,
2344 dev
->cmd_complete_dep_arg
);
2349 if (rc
== 0) /* success */
2353 "Error %d when trying to perform data_exchange\n", rc
);
2356 kfree(dev
->cmd_complete_dep_arg
);
2359 dev
->phy_ops
->send_ack(dev
, GFP_KERNEL
);
2360 queue_work(dev
->wq
, &dev
->cmd_work
);
2363 static int pn533_set_configuration(struct pn533
*dev
, u8 cfgitem
, u8
*cfgdata
,
2366 struct sk_buff
*skb
;
2367 struct sk_buff
*resp
;
2370 dev_dbg(dev
->dev
, "%s\n", __func__
);
2372 skb_len
= sizeof(cfgitem
) + cfgdata_len
; /* cfgitem + cfgdata */
2374 skb
= pn533_alloc_skb(dev
, skb_len
);
2378 *skb_put(skb
, sizeof(cfgitem
)) = cfgitem
;
2379 memcpy(skb_put(skb
, cfgdata_len
), cfgdata
, cfgdata_len
);
2381 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_RF_CONFIGURATION
, skb
);
2383 return PTR_ERR(resp
);
2385 dev_kfree_skb(resp
);
2389 static int pn533_get_firmware_version(struct pn533
*dev
,
2390 struct pn533_fw_version
*fv
)
2392 struct sk_buff
*skb
;
2393 struct sk_buff
*resp
;
2395 skb
= pn533_alloc_skb(dev
, 0);
2399 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_GET_FIRMWARE_VERSION
, skb
);
2401 return PTR_ERR(resp
);
2403 fv
->ic
= resp
->data
[0];
2404 fv
->ver
= resp
->data
[1];
2405 fv
->rev
= resp
->data
[2];
2406 fv
->support
= resp
->data
[3];
2408 dev_kfree_skb(resp
);
2412 static int pn533_pasori_fw_reset(struct pn533
*dev
)
2414 struct sk_buff
*skb
;
2415 struct sk_buff
*resp
;
2417 dev_dbg(dev
->dev
, "%s\n", __func__
);
2419 skb
= pn533_alloc_skb(dev
, sizeof(u8
));
2423 *skb_put(skb
, sizeof(u8
)) = 0x1;
2425 resp
= pn533_send_cmd_sync(dev
, 0x18, skb
);
2427 return PTR_ERR(resp
);
2429 dev_kfree_skb(resp
);
2434 static int pn533_rf_field(struct nfc_dev
*nfc_dev
, u8 rf
)
2436 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
2440 rf_field
|= PN533_CFGITEM_RF_FIELD_AUTO_RFCA
;
2442 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_RF_FIELD
,
2443 (u8
*)&rf_field
, 1);
2445 nfc_err(dev
->dev
, "Error on setting RF field\n");
2452 static int pn532_sam_configuration(struct nfc_dev
*nfc_dev
)
2454 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
2455 struct sk_buff
*skb
;
2456 struct sk_buff
*resp
;
2458 skb
= pn533_alloc_skb(dev
, 1);
2462 *skb_put(skb
, 1) = 0x01;
2464 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_SAM_CONFIGURATION
, skb
);
2466 return PTR_ERR(resp
);
2468 dev_kfree_skb(resp
);
2472 static int pn533_dev_up(struct nfc_dev
*nfc_dev
)
2474 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
2476 if (dev
->device_type
== PN533_DEVICE_PN532
) {
2477 int rc
= pn532_sam_configuration(nfc_dev
);
2483 return pn533_rf_field(nfc_dev
, 1);
2486 static int pn533_dev_down(struct nfc_dev
*nfc_dev
)
2488 return pn533_rf_field(nfc_dev
, 0);
2491 static struct nfc_ops pn533_nfc_ops
= {
2492 .dev_up
= pn533_dev_up
,
2493 .dev_down
= pn533_dev_down
,
2494 .dep_link_up
= pn533_dep_link_up
,
2495 .dep_link_down
= pn533_dep_link_down
,
2496 .start_poll
= pn533_start_poll
,
2497 .stop_poll
= pn533_stop_poll
,
2498 .activate_target
= pn533_activate_target
,
2499 .deactivate_target
= pn533_deactivate_target
,
2500 .im_transceive
= pn533_transceive
,
2501 .tm_send
= pn533_tm_send
,
2504 static int pn533_setup(struct pn533
*dev
)
2506 struct pn533_config_max_retries max_retries
;
2507 struct pn533_config_timing timing
;
2508 u8 pasori_cfg
[3] = {0x08, 0x01, 0x08};
2511 switch (dev
->device_type
) {
2512 case PN533_DEVICE_STD
:
2513 case PN533_DEVICE_PASORI
:
2514 case PN533_DEVICE_ACR122U
:
2515 case PN533_DEVICE_PN532
:
2516 max_retries
.mx_rty_atr
= 0x2;
2517 max_retries
.mx_rty_psl
= 0x1;
2518 max_retries
.mx_rty_passive_act
=
2519 PN533_CONFIG_MAX_RETRIES_NO_RETRY
;
2521 timing
.rfu
= PN533_CONFIG_TIMING_102
;
2522 timing
.atr_res_timeout
= PN533_CONFIG_TIMING_102
;
2523 timing
.dep_timeout
= PN533_CONFIG_TIMING_204
;
2528 nfc_err(dev
->dev
, "Unknown device type %d\n",
2533 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_MAX_RETRIES
,
2534 (u8
*)&max_retries
, sizeof(max_retries
));
2537 "Error on setting MAX_RETRIES config\n");
2542 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_TIMING
,
2543 (u8
*)&timing
, sizeof(timing
));
2545 nfc_err(dev
->dev
, "Error on setting RF timings\n");
2549 switch (dev
->device_type
) {
2550 case PN533_DEVICE_STD
:
2551 case PN533_DEVICE_PN532
:
2554 case PN533_DEVICE_PASORI
:
2555 pn533_pasori_fw_reset(dev
);
2557 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_PASORI
,
2561 "Error while settings PASORI config\n");
2565 pn533_pasori_fw_reset(dev
);
2573 int pn533_finalize_setup(struct pn533
*dev
)
2576 struct pn533_fw_version fw_ver
;
2579 memset(&fw_ver
, 0, sizeof(fw_ver
));
2581 rc
= pn533_get_firmware_version(dev
, &fw_ver
);
2583 nfc_err(dev
->dev
, "Unable to get FW version\n");
2587 nfc_info(dev
->dev
, "NXP PN5%02X firmware ver %d.%d now attached\n",
2588 fw_ver
.ic
, fw_ver
.ver
, fw_ver
.rev
);
2590 rc
= pn533_setup(dev
);
2596 EXPORT_SYMBOL_GPL(pn533_finalize_setup
);
2598 struct pn533
*pn533_register_device(u32 device_type
,
2600 enum pn533_protocol_type protocol_type
,
2602 struct pn533_phy_ops
*phy_ops
,
2603 struct pn533_frame_ops
*fops
,
2605 struct device
*parent
)
2610 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
2612 return ERR_PTR(-ENOMEM
);
2615 priv
->phy_ops
= phy_ops
;
2620 priv
->ops
= &pn533_std_frame_ops
;
2622 priv
->protocol_type
= protocol_type
;
2623 priv
->device_type
= device_type
;
2625 mutex_init(&priv
->cmd_lock
);
2627 INIT_WORK(&priv
->cmd_work
, pn533_wq_cmd
);
2628 INIT_WORK(&priv
->cmd_complete_work
, pn533_wq_cmd_complete
);
2629 INIT_WORK(&priv
->mi_rx_work
, pn533_wq_mi_recv
);
2630 INIT_WORK(&priv
->mi_tx_work
, pn533_wq_mi_send
);
2631 INIT_WORK(&priv
->tg_work
, pn533_wq_tg_get_data
);
2632 INIT_WORK(&priv
->mi_tm_rx_work
, pn533_wq_tm_mi_recv
);
2633 INIT_WORK(&priv
->mi_tm_tx_work
, pn533_wq_tm_mi_send
);
2634 INIT_DELAYED_WORK(&priv
->poll_work
, pn533_wq_poll
);
2635 INIT_WORK(&priv
->rf_work
, pn533_wq_rf
);
2636 priv
->wq
= alloc_ordered_workqueue("pn533", 0);
2637 if (priv
->wq
== NULL
)
2640 init_timer(&priv
->listen_timer
);
2641 priv
->listen_timer
.data
= (unsigned long) priv
;
2642 priv
->listen_timer
.function
= pn533_listen_mode_timer
;
2644 skb_queue_head_init(&priv
->resp_q
);
2645 skb_queue_head_init(&priv
->fragment_skb
);
2647 INIT_LIST_HEAD(&priv
->cmd_queue
);
2649 priv
->nfc_dev
= nfc_allocate_device(&pn533_nfc_ops
, protocols
,
2650 priv
->ops
->tx_header_len
+
2651 PN533_CMD_DATAEXCH_HEAD_LEN
,
2652 priv
->ops
->tx_tail_len
);
2653 if (!priv
->nfc_dev
) {
2658 nfc_set_parent_dev(priv
->nfc_dev
, parent
);
2659 nfc_set_drvdata(priv
->nfc_dev
, priv
);
2661 rc
= nfc_register_device(priv
->nfc_dev
);
2668 nfc_free_device(priv
->nfc_dev
);
2671 destroy_workqueue(priv
->wq
);
2676 EXPORT_SYMBOL_GPL(pn533_register_device
);
2678 void pn533_unregister_device(struct pn533
*priv
)
2680 struct pn533_cmd
*cmd
, *n
;
2682 nfc_unregister_device(priv
->nfc_dev
);
2683 nfc_free_device(priv
->nfc_dev
);
2685 flush_delayed_work(&priv
->poll_work
);
2686 destroy_workqueue(priv
->wq
);
2688 skb_queue_purge(&priv
->resp_q
);
2690 del_timer(&priv
->listen_timer
);
2692 list_for_each_entry_safe(cmd
, n
, &priv
->cmd_queue
, queue
) {
2693 list_del(&cmd
->queue
);
2699 EXPORT_SYMBOL_GPL(pn533_unregister_device
);
2702 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
2703 MODULE_AUTHOR("Aloisio Almeida Jr <aloisio.almeida@openbossa.org>");
2704 MODULE_AUTHOR("Waldemar Rymarkiewicz <waldemar.rymarkiewicz@tieto.com>");
2705 MODULE_DESCRIPTION("PN533 driver ver " VERSION
);
2706 MODULE_VERSION(VERSION
);
2707 MODULE_LICENSE("GPL");