2 * Copyright (C) 2011 Instituto Nokia de Tecnologia
3 * Copyright (C) 2012-2013 Tieto Poland
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the
17 * Free Software Foundation, Inc.,
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 #include <linux/device.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/usb.h>
26 #include <linux/nfc.h>
27 #include <linux/netdevice.h>
28 #include <net/nfc/nfc.h>
32 #define PN533_VENDOR_ID 0x4CC
33 #define PN533_PRODUCT_ID 0x2533
35 #define SCM_VENDOR_ID 0x4E6
36 #define SCL3711_PRODUCT_ID 0x5591
38 #define SONY_VENDOR_ID 0x054c
39 #define PASORI_PRODUCT_ID 0x02e1
41 #define PN533_DEVICE_STD 0x1
42 #define PN533_DEVICE_PASORI 0x2
44 #define PN533_ALL_PROTOCOLS (NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK |\
45 NFC_PROTO_FELICA_MASK | NFC_PROTO_ISO14443_MASK |\
46 NFC_PROTO_NFC_DEP_MASK |\
47 NFC_PROTO_ISO14443_B_MASK)
49 #define PN533_NO_TYPE_B_PROTOCOLS (NFC_PROTO_JEWEL_MASK | \
50 NFC_PROTO_MIFARE_MASK | \
51 NFC_PROTO_FELICA_MASK | \
52 NFC_PROTO_ISO14443_MASK | \
53 NFC_PROTO_NFC_DEP_MASK)
55 static const struct usb_device_id pn533_table
[] = {
56 { .match_flags
= USB_DEVICE_ID_MATCH_DEVICE
,
57 .idVendor
= PN533_VENDOR_ID
,
58 .idProduct
= PN533_PRODUCT_ID
,
59 .driver_info
= PN533_DEVICE_STD
,
61 { .match_flags
= USB_DEVICE_ID_MATCH_DEVICE
,
62 .idVendor
= SCM_VENDOR_ID
,
63 .idProduct
= SCL3711_PRODUCT_ID
,
64 .driver_info
= PN533_DEVICE_STD
,
66 { .match_flags
= USB_DEVICE_ID_MATCH_DEVICE
,
67 .idVendor
= SONY_VENDOR_ID
,
68 .idProduct
= PASORI_PRODUCT_ID
,
69 .driver_info
= PN533_DEVICE_PASORI
,
73 MODULE_DEVICE_TABLE(usb
, pn533_table
);
75 /* How much time we spend listening for initiators */
76 #define PN533_LISTEN_TIME 2
78 /* Standard pn533 frame definitions */
79 #define PN533_STD_FRAME_HEADER_LEN (sizeof(struct pn533_std_frame) \
80 + 2) /* data[0] TFI, data[1] CC */
81 #define PN533_STD_FRAME_TAIL_LEN 2 /* data[len] DCS, data[len + 1] postamble*/
84 * Max extended frame payload len, excluding TFI and CC
85 * which are already in PN533_FRAME_HEADER_LEN.
87 #define PN533_STD_FRAME_MAX_PAYLOAD_LEN 263
89 #define PN533_STD_FRAME_ACK_SIZE 6 /* Preamble (1), SoPC (2), ACK Code (2),
91 #define PN533_STD_FRAME_CHECKSUM(f) (f->data[f->datalen])
92 #define PN533_STD_FRAME_POSTAMBLE(f) (f->data[f->datalen + 1])
95 #define PN533_STD_FRAME_SOF 0x00FF
97 /* standard frame identifier: in/out/error */
98 #define PN533_STD_FRAME_IDENTIFIER(f) (f->data[0]) /* TFI */
99 #define PN533_STD_FRAME_DIR_OUT 0xD4
100 #define PN533_STD_FRAME_DIR_IN 0xD5
103 #define PN533_STD_FRAME_CMD(f) (f->data[1])
105 #define PN533_CMD_GET_FIRMWARE_VERSION 0x02
106 #define PN533_CMD_RF_CONFIGURATION 0x32
107 #define PN533_CMD_IN_DATA_EXCHANGE 0x40
108 #define PN533_CMD_IN_COMM_THRU 0x42
109 #define PN533_CMD_IN_LIST_PASSIVE_TARGET 0x4A
110 #define PN533_CMD_IN_ATR 0x50
111 #define PN533_CMD_IN_RELEASE 0x52
112 #define PN533_CMD_IN_JUMP_FOR_DEP 0x56
114 #define PN533_CMD_TG_INIT_AS_TARGET 0x8c
115 #define PN533_CMD_TG_GET_DATA 0x86
116 #define PN533_CMD_TG_SET_DATA 0x8e
117 #define PN533_CMD_UNDEF 0xff
119 #define PN533_CMD_RESPONSE(cmd) (cmd + 1)
121 /* PN533 Return codes */
122 #define PN533_CMD_RET_MASK 0x3F
123 #define PN533_CMD_MI_MASK 0x40
124 #define PN533_CMD_RET_SUCCESS 0x00
128 typedef int (*pn533_cmd_complete_t
) (struct pn533
*dev
, void *arg
, int status
);
130 typedef int (*pn533_send_async_complete_t
) (struct pn533
*dev
, void *arg
,
131 struct sk_buff
*resp
);
133 /* structs for pn533 commands */
135 /* PN533_CMD_GET_FIRMWARE_VERSION */
136 struct pn533_fw_version
{
143 /* PN533_CMD_RF_CONFIGURATION */
144 #define PN533_CFGITEM_TIMING 0x02
145 #define PN533_CFGITEM_MAX_RETRIES 0x05
146 #define PN533_CFGITEM_PASORI 0x82
148 #define PN533_CONFIG_TIMING_102 0xb
149 #define PN533_CONFIG_TIMING_204 0xc
150 #define PN533_CONFIG_TIMING_409 0xd
151 #define PN533_CONFIG_TIMING_819 0xe
153 #define PN533_CONFIG_MAX_RETRIES_NO_RETRY 0x00
154 #define PN533_CONFIG_MAX_RETRIES_ENDLESS 0xFF
156 struct pn533_config_max_retries
{
159 u8 mx_rty_passive_act
;
162 struct pn533_config_timing
{
168 /* PN533_CMD_IN_LIST_PASSIVE_TARGET */
170 /* felica commands opcode */
171 #define PN533_FELICA_OPC_SENSF_REQ 0
172 #define PN533_FELICA_OPC_SENSF_RES 1
173 /* felica SENSF_REQ parameters */
174 #define PN533_FELICA_SENSF_SC_ALL 0xFFFF
175 #define PN533_FELICA_SENSF_RC_NO_SYSTEM_CODE 0
176 #define PN533_FELICA_SENSF_RC_SYSTEM_CODE 1
177 #define PN533_FELICA_SENSF_RC_ADVANCED_PROTOCOL 2
179 /* type B initiator_data values */
180 #define PN533_TYPE_B_AFI_ALL_FAMILIES 0
181 #define PN533_TYPE_B_POLL_METHOD_TIMESLOT 0
182 #define PN533_TYPE_B_POLL_METHOD_PROBABILISTIC 1
184 union pn533_cmd_poll_initdata
{
197 /* Poll modulations */
199 PN533_POLL_MOD_106KBPS_A
,
200 PN533_POLL_MOD_212KBPS_FELICA
,
201 PN533_POLL_MOD_424KBPS_FELICA
,
202 PN533_POLL_MOD_106KBPS_JEWEL
,
203 PN533_POLL_MOD_847KBPS_B
,
206 __PN533_POLL_MOD_AFTER_LAST
,
208 #define PN533_POLL_MOD_MAX (__PN533_POLL_MOD_AFTER_LAST - 1)
210 struct pn533_poll_modulations
{
214 union pn533_cmd_poll_initdata initiator_data
;
219 static const struct pn533_poll_modulations poll_mod
[] = {
220 [PN533_POLL_MOD_106KBPS_A
] = {
227 [PN533_POLL_MOD_212KBPS_FELICA
] = {
231 .initiator_data
.felica
= {
232 .opcode
= PN533_FELICA_OPC_SENSF_REQ
,
233 .sc
= PN533_FELICA_SENSF_SC_ALL
,
234 .rc
= PN533_FELICA_SENSF_RC_NO_SYSTEM_CODE
,
240 [PN533_POLL_MOD_424KBPS_FELICA
] = {
244 .initiator_data
.felica
= {
245 .opcode
= PN533_FELICA_OPC_SENSF_REQ
,
246 .sc
= PN533_FELICA_SENSF_SC_ALL
,
247 .rc
= PN533_FELICA_SENSF_RC_NO_SYSTEM_CODE
,
253 [PN533_POLL_MOD_106KBPS_JEWEL
] = {
260 [PN533_POLL_MOD_847KBPS_B
] = {
264 .initiator_data
.type_b
= {
265 .afi
= PN533_TYPE_B_AFI_ALL_FAMILIES
,
267 PN533_TYPE_B_POLL_METHOD_TIMESLOT
,
272 [PN533_LISTEN_MOD
] = {
277 /* PN533_CMD_IN_ATR */
279 struct pn533_cmd_activate_response
{
291 struct pn533_cmd_jump_dep_response
{
305 /* PN533_TG_INIT_AS_TARGET */
306 #define PN533_INIT_TARGET_PASSIVE 0x1
307 #define PN533_INIT_TARGET_DEP 0x2
309 #define PN533_INIT_TARGET_RESP_FRAME_MASK 0x3
310 #define PN533_INIT_TARGET_RESP_ACTIVE 0x1
311 #define PN533_INIT_TARGET_RESP_DEP 0x4
314 struct usb_device
*udev
;
315 struct usb_interface
*interface
;
316 struct nfc_dev
*nfc_dev
;
322 struct sk_buff_head resp_q
;
324 struct workqueue_struct
*wq
;
325 struct work_struct cmd_work
;
326 struct work_struct cmd_complete_work
;
327 struct work_struct poll_work
;
328 struct work_struct mi_work
;
329 struct work_struct tg_work
;
331 struct list_head cmd_queue
;
332 struct pn533_cmd
*cmd
;
334 struct mutex cmd_lock
; /* protects cmd queue */
336 void *cmd_complete_mi_arg
;
338 struct pn533_poll_modulations
*poll_mod_active
[PN533_POLL_MOD_MAX
+ 1];
342 u32 listen_protocols
;
343 struct timer_list listen_timer
;
349 u8 tgt_available_prots
;
353 struct pn533_frame_ops
*ops
;
357 struct list_head queue
;
361 struct sk_buff
*resp
;
363 pn533_send_async_complete_t complete_cb
;
364 void *complete_cb_context
;
367 struct pn533_std_frame
{
375 struct pn533_frame_ops
{
376 void (*tx_frame_init
)(void *frame
, u8 cmd_code
);
377 void (*tx_frame_finish
)(void *frame
);
378 void (*tx_update_payload_len
)(void *frame
, int len
);
382 bool (*rx_is_frame_valid
)(void *frame
);
383 int (*rx_frame_size
)(void *frame
);
388 u8 (*get_cmd_code
)(void *frame
);
391 /* The rule: value + checksum = 0 */
392 static inline u8
pn533_std_checksum(u8 value
)
397 /* The rule: sum(data elements) + checksum = 0 */
398 static u8
pn533_std_data_checksum(u8
*data
, int datalen
)
403 for (i
= 0; i
< datalen
; i
++)
406 return pn533_std_checksum(sum
);
409 static void pn533_std_tx_frame_init(void *_frame
, u8 cmd_code
)
411 struct pn533_std_frame
*frame
= _frame
;
414 frame
->start_frame
= cpu_to_be16(PN533_STD_FRAME_SOF
);
415 PN533_STD_FRAME_IDENTIFIER(frame
) = PN533_STD_FRAME_DIR_OUT
;
416 PN533_STD_FRAME_CMD(frame
) = cmd_code
;
420 static void pn533_std_tx_frame_finish(void *_frame
)
422 struct pn533_std_frame
*frame
= _frame
;
424 frame
->datalen_checksum
= pn533_std_checksum(frame
->datalen
);
426 PN533_STD_FRAME_CHECKSUM(frame
) =
427 pn533_std_data_checksum(frame
->data
, frame
->datalen
);
429 PN533_STD_FRAME_POSTAMBLE(frame
) = 0;
432 static void pn533_std_tx_update_payload_len(void *_frame
, int len
)
434 struct pn533_std_frame
*frame
= _frame
;
436 frame
->datalen
+= len
;
439 static bool pn533_std_rx_frame_is_valid(void *_frame
)
442 struct pn533_std_frame
*frame
= _frame
;
444 if (frame
->start_frame
!= cpu_to_be16(PN533_STD_FRAME_SOF
))
447 checksum
= pn533_std_checksum(frame
->datalen
);
448 if (checksum
!= frame
->datalen_checksum
)
451 checksum
= pn533_std_data_checksum(frame
->data
, frame
->datalen
);
452 if (checksum
!= PN533_STD_FRAME_CHECKSUM(frame
))
458 static bool pn533_std_rx_frame_is_ack(struct pn533_std_frame
*frame
)
460 if (frame
->start_frame
!= cpu_to_be16(PN533_STD_FRAME_SOF
))
463 if (frame
->datalen
!= 0 || frame
->datalen_checksum
!= 0xFF)
469 static inline int pn533_std_rx_frame_size(void *frame
)
471 struct pn533_std_frame
*f
= frame
;
473 return sizeof(struct pn533_std_frame
) + f
->datalen
+
474 PN533_STD_FRAME_TAIL_LEN
;
477 static u8
pn533_std_get_cmd_code(void *frame
)
479 struct pn533_std_frame
*f
= frame
;
481 return PN533_STD_FRAME_CMD(f
);
484 static struct pn533_frame_ops pn533_std_frame_ops
= {
485 .tx_frame_init
= pn533_std_tx_frame_init
,
486 .tx_frame_finish
= pn533_std_tx_frame_finish
,
487 .tx_update_payload_len
= pn533_std_tx_update_payload_len
,
488 .tx_header_len
= PN533_STD_FRAME_HEADER_LEN
,
489 .tx_tail_len
= PN533_STD_FRAME_TAIL_LEN
,
491 .rx_is_frame_valid
= pn533_std_rx_frame_is_valid
,
492 .rx_frame_size
= pn533_std_rx_frame_size
,
493 .rx_header_len
= PN533_STD_FRAME_HEADER_LEN
,
494 .rx_tail_len
= PN533_STD_FRAME_TAIL_LEN
,
496 .max_payload_len
= PN533_STD_FRAME_MAX_PAYLOAD_LEN
,
497 .get_cmd_code
= pn533_std_get_cmd_code
,
500 static bool pn533_rx_frame_is_cmd_response(struct pn533
*dev
, void *frame
)
502 return (dev
->ops
->get_cmd_code(frame
) ==
503 PN533_CMD_RESPONSE(dev
->cmd
->code
));
506 static void pn533_recv_response(struct urb
*urb
)
508 struct pn533
*dev
= urb
->context
;
509 struct pn533_cmd
*cmd
= dev
->cmd
;
512 cmd
->status
= urb
->status
;
514 switch (urb
->status
) {
519 nfc_dev_dbg(&dev
->interface
->dev
,
520 "The urb has been canceled (status %d)",
525 nfc_dev_err(&dev
->interface
->dev
,
526 "Urb failure (status %d)", urb
->status
);
530 in_frame
= dev
->in_urb
->transfer_buffer
;
532 nfc_dev_dbg(&dev
->interface
->dev
, "Received a frame.");
533 print_hex_dump_debug("PN533 RX: ", DUMP_PREFIX_NONE
, 16, 1, in_frame
,
534 dev
->ops
->rx_frame_size(in_frame
), false);
536 if (!dev
->ops
->rx_is_frame_valid(in_frame
)) {
537 nfc_dev_err(&dev
->interface
->dev
, "Received an invalid frame");
542 if (!pn533_rx_frame_is_cmd_response(dev
, in_frame
)) {
543 nfc_dev_err(&dev
->interface
->dev
,
544 "It it not the response to the last command");
550 queue_work(dev
->wq
, &dev
->cmd_complete_work
);
553 static int pn533_submit_urb_for_response(struct pn533
*dev
, gfp_t flags
)
555 dev
->in_urb
->complete
= pn533_recv_response
;
557 return usb_submit_urb(dev
->in_urb
, flags
);
560 static void pn533_recv_ack(struct urb
*urb
)
562 struct pn533
*dev
= urb
->context
;
563 struct pn533_cmd
*cmd
= dev
->cmd
;
564 struct pn533_std_frame
*in_frame
;
567 cmd
->status
= urb
->status
;
569 switch (urb
->status
) {
574 nfc_dev_dbg(&dev
->interface
->dev
,
575 "The urb has been stopped (status %d)",
580 nfc_dev_err(&dev
->interface
->dev
,
581 "Urb failure (status %d)", urb
->status
);
585 in_frame
= dev
->in_urb
->transfer_buffer
;
587 if (!pn533_std_rx_frame_is_ack(in_frame
)) {
588 nfc_dev_err(&dev
->interface
->dev
, "Received an invalid ack");
593 rc
= pn533_submit_urb_for_response(dev
, GFP_ATOMIC
);
595 nfc_dev_err(&dev
->interface
->dev
,
596 "usb_submit_urb failed with result %d", rc
);
604 queue_work(dev
->wq
, &dev
->cmd_complete_work
);
607 static int pn533_submit_urb_for_ack(struct pn533
*dev
, gfp_t flags
)
609 dev
->in_urb
->complete
= pn533_recv_ack
;
611 return usb_submit_urb(dev
->in_urb
, flags
);
614 static int pn533_send_ack(struct pn533
*dev
, gfp_t flags
)
616 u8 ack
[PN533_STD_FRAME_ACK_SIZE
] = {0x00, 0x00, 0xff, 0x00, 0xff, 0x00};
617 /* spec 7.1.1.3: Preamble, SoPC (2), ACK Code (2), Postamble */
620 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
622 dev
->out_urb
->transfer_buffer
= ack
;
623 dev
->out_urb
->transfer_buffer_length
= sizeof(ack
);
624 rc
= usb_submit_urb(dev
->out_urb
, flags
);
629 static int __pn533_send_frame_async(struct pn533
*dev
,
636 dev
->out_urb
->transfer_buffer
= out
->data
;
637 dev
->out_urb
->transfer_buffer_length
= out
->len
;
639 dev
->in_urb
->transfer_buffer
= in
->data
;
640 dev
->in_urb
->transfer_buffer_length
= in_len
;
642 print_hex_dump_debug("PN533 TX: ", DUMP_PREFIX_NONE
, 16, 1,
643 out
->data
, out
->len
, false);
645 rc
= usb_submit_urb(dev
->out_urb
, GFP_KERNEL
);
649 rc
= pn533_submit_urb_for_ack(dev
, GFP_KERNEL
);
656 usb_unlink_urb(dev
->out_urb
);
660 static void pn533_build_cmd_frame(struct pn533
*dev
, u8 cmd_code
,
663 /* payload is already there, just update datalen */
664 int payload_len
= skb
->len
;
665 struct pn533_frame_ops
*ops
= dev
->ops
;
668 skb_push(skb
, ops
->tx_header_len
);
669 skb_put(skb
, ops
->tx_tail_len
);
671 ops
->tx_frame_init(skb
->data
, cmd_code
);
672 ops
->tx_update_payload_len(skb
->data
, payload_len
);
673 ops
->tx_frame_finish(skb
->data
);
676 static int pn533_send_async_complete(struct pn533
*dev
)
678 struct pn533_cmd
*cmd
= dev
->cmd
;
679 int status
= cmd
->status
;
681 struct sk_buff
*req
= cmd
->req
;
682 struct sk_buff
*resp
= cmd
->resp
;
689 rc
= cmd
->complete_cb(dev
, cmd
->complete_cb_context
,
695 skb_put(resp
, dev
->ops
->rx_frame_size(resp
->data
));
696 skb_pull(resp
, dev
->ops
->rx_header_len
);
697 skb_trim(resp
, resp
->len
- dev
->ops
->rx_tail_len
);
699 rc
= cmd
->complete_cb(dev
, cmd
->complete_cb_context
, resp
);
707 static int __pn533_send_async(struct pn533
*dev
, u8 cmd_code
,
708 struct sk_buff
*req
, struct sk_buff
*resp
,
710 pn533_send_async_complete_t complete_cb
,
711 void *complete_cb_context
)
713 struct pn533_cmd
*cmd
;
716 nfc_dev_dbg(&dev
->interface
->dev
, "Sending command 0x%x", cmd_code
);
718 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
722 cmd
->code
= cmd_code
;
725 cmd
->resp_len
= resp_len
;
726 cmd
->complete_cb
= complete_cb
;
727 cmd
->complete_cb_context
= complete_cb_context
;
729 pn533_build_cmd_frame(dev
, cmd_code
, req
);
731 mutex_lock(&dev
->cmd_lock
);
733 if (!dev
->cmd_pending
) {
734 rc
= __pn533_send_frame_async(dev
, req
, resp
, resp_len
);
738 dev
->cmd_pending
= 1;
743 nfc_dev_dbg(&dev
->interface
->dev
, "%s Queueing command 0x%x", __func__
,
746 INIT_LIST_HEAD(&cmd
->queue
);
747 list_add_tail(&cmd
->queue
, &dev
->cmd_queue
);
754 mutex_unlock(&dev
->cmd_lock
);
758 static int pn533_send_data_async(struct pn533
*dev
, u8 cmd_code
,
760 pn533_send_async_complete_t complete_cb
,
761 void *complete_cb_context
)
763 struct sk_buff
*resp
;
765 int resp_len
= dev
->ops
->rx_header_len
+
766 dev
->ops
->max_payload_len
+
767 dev
->ops
->rx_tail_len
;
769 resp
= nfc_alloc_recv_skb(resp_len
, GFP_KERNEL
);
773 rc
= __pn533_send_async(dev
, cmd_code
, req
, resp
, resp_len
, complete_cb
,
774 complete_cb_context
);
781 static int pn533_send_cmd_async(struct pn533
*dev
, u8 cmd_code
,
783 pn533_send_async_complete_t complete_cb
,
784 void *complete_cb_context
)
786 struct sk_buff
*resp
;
788 int resp_len
= dev
->ops
->rx_header_len
+
789 dev
->ops
->max_payload_len
+
790 dev
->ops
->rx_tail_len
;
792 resp
= alloc_skb(resp_len
, GFP_KERNEL
);
796 rc
= __pn533_send_async(dev
, cmd_code
, req
, resp
, resp_len
, complete_cb
,
797 complete_cb_context
);
805 * pn533_send_cmd_direct_async
807 * The function sends a piority cmd directly to the chip omiting the cmd
808 * queue. It's intended to be used by chaining mechanism of received responses
809 * where the host has to request every single chunk of data before scheduling
810 * next cmd from the queue.
812 static int pn533_send_cmd_direct_async(struct pn533
*dev
, u8 cmd_code
,
814 pn533_send_async_complete_t complete_cb
,
815 void *complete_cb_context
)
817 struct sk_buff
*resp
;
818 struct pn533_cmd
*cmd
;
820 int resp_len
= dev
->ops
->rx_header_len
+
821 dev
->ops
->max_payload_len
+
822 dev
->ops
->rx_tail_len
;
824 resp
= alloc_skb(resp_len
, GFP_KERNEL
);
828 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
834 cmd
->code
= cmd_code
;
837 cmd
->resp_len
= resp_len
;
838 cmd
->complete_cb
= complete_cb
;
839 cmd
->complete_cb_context
= complete_cb_context
;
841 pn533_build_cmd_frame(dev
, cmd_code
, req
);
843 rc
= __pn533_send_frame_async(dev
, req
, resp
, resp_len
);
854 static void pn533_wq_cmd_complete(struct work_struct
*work
)
856 struct pn533
*dev
= container_of(work
, struct pn533
, cmd_complete_work
);
859 rc
= pn533_send_async_complete(dev
);
860 if (rc
!= -EINPROGRESS
)
861 queue_work(dev
->wq
, &dev
->cmd_work
);
864 static void pn533_wq_cmd(struct work_struct
*work
)
866 struct pn533
*dev
= container_of(work
, struct pn533
, cmd_work
);
867 struct pn533_cmd
*cmd
;
870 mutex_lock(&dev
->cmd_lock
);
872 if (list_empty(&dev
->cmd_queue
)) {
873 dev
->cmd_pending
= 0;
874 mutex_unlock(&dev
->cmd_lock
);
878 cmd
= list_first_entry(&dev
->cmd_queue
, struct pn533_cmd
, queue
);
880 list_del(&cmd
->queue
);
882 mutex_unlock(&dev
->cmd_lock
);
884 rc
= __pn533_send_frame_async(dev
, cmd
->req
, cmd
->resp
, cmd
->resp_len
);
886 dev_kfree_skb(cmd
->req
);
887 dev_kfree_skb(cmd
->resp
);
895 struct pn533_sync_cmd_response
{
896 struct sk_buff
*resp
;
897 struct completion done
;
900 static int pn533_send_sync_complete(struct pn533
*dev
, void *_arg
,
901 struct sk_buff
*resp
)
903 struct pn533_sync_cmd_response
*arg
= _arg
;
906 complete(&arg
->done
);
911 /* pn533_send_cmd_sync
913 * Please note the req parameter is freed inside the function to
914 * limit a number of return value interpretations by the caller.
916 * 1. negative in case of error during TX path -> req should be freed
918 * 2. negative in case of error during RX path -> req should not be freed
919 * as it's been already freed at the begining of RX path by
922 * 3. valid pointer in case of succesfult RX path
924 * A caller has to check a return value with IS_ERR macro. If the test pass,
925 * the returned pointer is valid.
928 static struct sk_buff
*pn533_send_cmd_sync(struct pn533
*dev
, u8 cmd_code
,
932 struct pn533_sync_cmd_response arg
;
934 init_completion(&arg
.done
);
936 rc
= pn533_send_cmd_async(dev
, cmd_code
, req
,
937 pn533_send_sync_complete
, &arg
);
943 wait_for_completion(&arg
.done
);
948 static void pn533_send_complete(struct urb
*urb
)
950 struct pn533
*dev
= urb
->context
;
952 switch (urb
->status
) {
957 nfc_dev_dbg(&dev
->interface
->dev
,
958 "The urb has been stopped (status %d)",
963 nfc_dev_err(&dev
->interface
->dev
,
964 "Urb failure (status %d)", urb
->status
);
968 static struct sk_buff
*pn533_alloc_skb(struct pn533
*dev
, unsigned int size
)
972 skb
= alloc_skb(dev
->ops
->tx_header_len
+
974 dev
->ops
->tx_tail_len
, GFP_KERNEL
);
977 skb_reserve(skb
, dev
->ops
->tx_header_len
);
982 struct pn533_target_type_a
{
990 #define PN533_TYPE_A_SENS_RES_NFCID1(x) ((u8)((be16_to_cpu(x) & 0x00C0) >> 6))
991 #define PN533_TYPE_A_SENS_RES_SSD(x) ((u8)((be16_to_cpu(x) & 0x001F) >> 0))
992 #define PN533_TYPE_A_SENS_RES_PLATCONF(x) ((u8)((be16_to_cpu(x) & 0x0F00) >> 8))
994 #define PN533_TYPE_A_SENS_RES_SSD_JEWEL 0x00
995 #define PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL 0x0C
997 #define PN533_TYPE_A_SEL_PROT(x) (((x) & 0x60) >> 5)
998 #define PN533_TYPE_A_SEL_CASCADE(x) (((x) & 0x04) >> 2)
1000 #define PN533_TYPE_A_SEL_PROT_MIFARE 0
1001 #define PN533_TYPE_A_SEL_PROT_ISO14443 1
1002 #define PN533_TYPE_A_SEL_PROT_DEP 2
1003 #define PN533_TYPE_A_SEL_PROT_ISO14443_DEP 3
1005 static bool pn533_target_type_a_is_valid(struct pn533_target_type_a
*type_a
,
1006 int target_data_len
)
1011 if (target_data_len
< sizeof(struct pn533_target_type_a
))
1014 /* The lenght check of nfcid[] and ats[] are not being performed because
1015 the values are not being used */
1017 /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
1018 ssd
= PN533_TYPE_A_SENS_RES_SSD(type_a
->sens_res
);
1019 platconf
= PN533_TYPE_A_SENS_RES_PLATCONF(type_a
->sens_res
);
1021 if ((ssd
== PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
1022 platconf
!= PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
) ||
1023 (ssd
!= PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
1024 platconf
== PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
))
1027 /* Requirements 4.8.2.1, 4.8.2.3, 4.8.2.5 and 4.8.2.7 from NFC Forum */
1028 if (PN533_TYPE_A_SEL_CASCADE(type_a
->sel_res
) != 0)
1034 static int pn533_target_found_type_a(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
1037 struct pn533_target_type_a
*tgt_type_a
;
1039 tgt_type_a
= (struct pn533_target_type_a
*)tgt_data
;
1041 if (!pn533_target_type_a_is_valid(tgt_type_a
, tgt_data_len
))
1044 switch (PN533_TYPE_A_SEL_PROT(tgt_type_a
->sel_res
)) {
1045 case PN533_TYPE_A_SEL_PROT_MIFARE
:
1046 nfc_tgt
->supported_protocols
= NFC_PROTO_MIFARE_MASK
;
1048 case PN533_TYPE_A_SEL_PROT_ISO14443
:
1049 nfc_tgt
->supported_protocols
= NFC_PROTO_ISO14443_MASK
;
1051 case PN533_TYPE_A_SEL_PROT_DEP
:
1052 nfc_tgt
->supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
1054 case PN533_TYPE_A_SEL_PROT_ISO14443_DEP
:
1055 nfc_tgt
->supported_protocols
= NFC_PROTO_ISO14443_MASK
|
1056 NFC_PROTO_NFC_DEP_MASK
;
1060 nfc_tgt
->sens_res
= be16_to_cpu(tgt_type_a
->sens_res
);
1061 nfc_tgt
->sel_res
= tgt_type_a
->sel_res
;
1062 nfc_tgt
->nfcid1_len
= tgt_type_a
->nfcid_len
;
1063 memcpy(nfc_tgt
->nfcid1
, tgt_type_a
->nfcid_data
, nfc_tgt
->nfcid1_len
);
1068 struct pn533_target_felica
{
1077 #define PN533_FELICA_SENSF_NFCID2_DEP_B1 0x01
1078 #define PN533_FELICA_SENSF_NFCID2_DEP_B2 0xFE
1080 static bool pn533_target_felica_is_valid(struct pn533_target_felica
*felica
,
1081 int target_data_len
)
1083 if (target_data_len
< sizeof(struct pn533_target_felica
))
1086 if (felica
->opcode
!= PN533_FELICA_OPC_SENSF_RES
)
1092 static int pn533_target_found_felica(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
1095 struct pn533_target_felica
*tgt_felica
;
1097 tgt_felica
= (struct pn533_target_felica
*)tgt_data
;
1099 if (!pn533_target_felica_is_valid(tgt_felica
, tgt_data_len
))
1102 if ((tgt_felica
->nfcid2
[0] == PN533_FELICA_SENSF_NFCID2_DEP_B1
) &&
1103 (tgt_felica
->nfcid2
[1] == PN533_FELICA_SENSF_NFCID2_DEP_B2
))
1104 nfc_tgt
->supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
1106 nfc_tgt
->supported_protocols
= NFC_PROTO_FELICA_MASK
;
1108 memcpy(nfc_tgt
->sensf_res
, &tgt_felica
->opcode
, 9);
1109 nfc_tgt
->sensf_res_len
= 9;
1114 struct pn533_target_jewel
{
1119 static bool pn533_target_jewel_is_valid(struct pn533_target_jewel
*jewel
,
1120 int target_data_len
)
1125 if (target_data_len
< sizeof(struct pn533_target_jewel
))
1128 /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
1129 ssd
= PN533_TYPE_A_SENS_RES_SSD(jewel
->sens_res
);
1130 platconf
= PN533_TYPE_A_SENS_RES_PLATCONF(jewel
->sens_res
);
1132 if ((ssd
== PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
1133 platconf
!= PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
) ||
1134 (ssd
!= PN533_TYPE_A_SENS_RES_SSD_JEWEL
&&
1135 platconf
== PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL
))
1141 static int pn533_target_found_jewel(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
1144 struct pn533_target_jewel
*tgt_jewel
;
1146 tgt_jewel
= (struct pn533_target_jewel
*)tgt_data
;
1148 if (!pn533_target_jewel_is_valid(tgt_jewel
, tgt_data_len
))
1151 nfc_tgt
->supported_protocols
= NFC_PROTO_JEWEL_MASK
;
1152 nfc_tgt
->sens_res
= be16_to_cpu(tgt_jewel
->sens_res
);
1153 nfc_tgt
->nfcid1_len
= 4;
1154 memcpy(nfc_tgt
->nfcid1
, tgt_jewel
->jewelid
, nfc_tgt
->nfcid1_len
);
1159 struct pn533_type_b_prot_info
{
1165 #define PN533_TYPE_B_PROT_FCSI(x) (((x) & 0xF0) >> 4)
1166 #define PN533_TYPE_B_PROT_TYPE(x) (((x) & 0x0F) >> 0)
1167 #define PN533_TYPE_B_PROT_TYPE_RFU_MASK 0x8
1169 struct pn533_type_b_sens_res
{
1173 struct pn533_type_b_prot_info prot_info
;
1176 #define PN533_TYPE_B_OPC_SENSB_RES 0x50
1178 struct pn533_target_type_b
{
1179 struct pn533_type_b_sens_res sensb_res
;
1184 static bool pn533_target_type_b_is_valid(struct pn533_target_type_b
*type_b
,
1185 int target_data_len
)
1187 if (target_data_len
< sizeof(struct pn533_target_type_b
))
1190 if (type_b
->sensb_res
.opcode
!= PN533_TYPE_B_OPC_SENSB_RES
)
1193 if (PN533_TYPE_B_PROT_TYPE(type_b
->sensb_res
.prot_info
.fsci_type
) &
1194 PN533_TYPE_B_PROT_TYPE_RFU_MASK
)
1200 static int pn533_target_found_type_b(struct nfc_target
*nfc_tgt
, u8
*tgt_data
,
1203 struct pn533_target_type_b
*tgt_type_b
;
1205 tgt_type_b
= (struct pn533_target_type_b
*)tgt_data
;
1207 if (!pn533_target_type_b_is_valid(tgt_type_b
, tgt_data_len
))
1210 nfc_tgt
->supported_protocols
= NFC_PROTO_ISO14443_B_MASK
;
1215 static int pn533_target_found(struct pn533
*dev
, u8 tg
, u8
*tgdata
,
1218 struct nfc_target nfc_tgt
;
1221 nfc_dev_dbg(&dev
->interface
->dev
, "%s - modulation=%d", __func__
,
1222 dev
->poll_mod_curr
);
1227 memset(&nfc_tgt
, 0, sizeof(struct nfc_target
));
1229 switch (dev
->poll_mod_curr
) {
1230 case PN533_POLL_MOD_106KBPS_A
:
1231 rc
= pn533_target_found_type_a(&nfc_tgt
, tgdata
, tgdata_len
);
1233 case PN533_POLL_MOD_212KBPS_FELICA
:
1234 case PN533_POLL_MOD_424KBPS_FELICA
:
1235 rc
= pn533_target_found_felica(&nfc_tgt
, tgdata
, tgdata_len
);
1237 case PN533_POLL_MOD_106KBPS_JEWEL
:
1238 rc
= pn533_target_found_jewel(&nfc_tgt
, tgdata
, tgdata_len
);
1240 case PN533_POLL_MOD_847KBPS_B
:
1241 rc
= pn533_target_found_type_b(&nfc_tgt
, tgdata
, tgdata_len
);
1244 nfc_dev_err(&dev
->interface
->dev
,
1245 "Unknown current poll modulation");
1252 if (!(nfc_tgt
.supported_protocols
& dev
->poll_protocols
)) {
1253 nfc_dev_dbg(&dev
->interface
->dev
,
1254 "The Tg found doesn't have the desired protocol");
1258 nfc_dev_dbg(&dev
->interface
->dev
,
1259 "Target found - supported protocols: 0x%x",
1260 nfc_tgt
.supported_protocols
);
1262 dev
->tgt_available_prots
= nfc_tgt
.supported_protocols
;
1264 nfc_targets_found(dev
->nfc_dev
, &nfc_tgt
, 1);
1269 static inline void pn533_poll_next_mod(struct pn533
*dev
)
1271 dev
->poll_mod_curr
= (dev
->poll_mod_curr
+ 1) % dev
->poll_mod_count
;
1274 static void pn533_poll_reset_mod_list(struct pn533
*dev
)
1276 dev
->poll_mod_count
= 0;
1279 static void pn533_poll_add_mod(struct pn533
*dev
, u8 mod_index
)
1281 dev
->poll_mod_active
[dev
->poll_mod_count
] =
1282 (struct pn533_poll_modulations
*)&poll_mod
[mod_index
];
1283 dev
->poll_mod_count
++;
1286 static void pn533_poll_create_mod_list(struct pn533
*dev
,
1287 u32 im_protocols
, u32 tm_protocols
)
1289 pn533_poll_reset_mod_list(dev
);
1291 if ((im_protocols
& NFC_PROTO_MIFARE_MASK
) ||
1292 (im_protocols
& NFC_PROTO_ISO14443_MASK
) ||
1293 (im_protocols
& NFC_PROTO_NFC_DEP_MASK
))
1294 pn533_poll_add_mod(dev
, PN533_POLL_MOD_106KBPS_A
);
1296 if (im_protocols
& NFC_PROTO_FELICA_MASK
||
1297 im_protocols
& NFC_PROTO_NFC_DEP_MASK
) {
1298 pn533_poll_add_mod(dev
, PN533_POLL_MOD_212KBPS_FELICA
);
1299 pn533_poll_add_mod(dev
, PN533_POLL_MOD_424KBPS_FELICA
);
1302 if (im_protocols
& NFC_PROTO_JEWEL_MASK
)
1303 pn533_poll_add_mod(dev
, PN533_POLL_MOD_106KBPS_JEWEL
);
1305 if (im_protocols
& NFC_PROTO_ISO14443_B_MASK
)
1306 pn533_poll_add_mod(dev
, PN533_POLL_MOD_847KBPS_B
);
1309 pn533_poll_add_mod(dev
, PN533_LISTEN_MOD
);
1312 static int pn533_start_poll_complete(struct pn533
*dev
, struct sk_buff
*resp
)
1314 u8 nbtg
, tg
, *tgdata
;
1317 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
1319 nbtg
= resp
->data
[0];
1321 tgdata
= &resp
->data
[2];
1322 tgdata_len
= resp
->len
- 2; /* nbtg + tg */
1325 rc
= pn533_target_found(dev
, tg
, tgdata
, tgdata_len
);
1327 /* We must stop the poll after a valid target found */
1329 pn533_poll_reset_mod_list(dev
);
1337 static struct sk_buff
*pn533_alloc_poll_tg_frame(struct pn533
*dev
)
1339 struct sk_buff
*skb
;
1340 u8
*felica
, *nfcid3
, *gb
;
1342 u8
*gbytes
= dev
->gb
;
1343 size_t gbytes_len
= dev
->gb_len
;
1345 u8 felica_params
[18] = {0x1, 0xfe, /* DEP */
1346 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, /* random */
1347 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
1348 0xff, 0xff}; /* System code */
1350 u8 mifare_params
[6] = {0x1, 0x1, /* SENS_RES */
1352 0x40}; /* SEL_RES for DEP */
1354 unsigned int skb_len
= 36 + /* mode (1), mifare (6),
1355 felica (18), nfcid3 (10), gb_len (1) */
1359 skb
= pn533_alloc_skb(dev
, skb_len
);
1363 /* DEP support only */
1364 *skb_put(skb
, 1) = PN533_INIT_TARGET_DEP
;
1367 memcpy(skb_put(skb
, 6), mifare_params
, 6);
1370 felica
= skb_put(skb
, 18);
1371 memcpy(felica
, felica_params
, 18);
1372 get_random_bytes(felica
+ 2, 6);
1375 nfcid3
= skb_put(skb
, 10);
1376 memset(nfcid3
, 0, 10);
1377 memcpy(nfcid3
, felica
, 8);
1380 *skb_put(skb
, 1) = gbytes_len
;
1382 gb
= skb_put(skb
, gbytes_len
);
1383 memcpy(gb
, gbytes
, gbytes_len
);
1386 *skb_put(skb
, 1) = 0;
1391 #define PN533_CMD_DATAEXCH_HEAD_LEN 1
1392 #define PN533_CMD_DATAEXCH_DATA_MAXLEN 262
1393 static int pn533_tm_get_data_complete(struct pn533
*dev
, void *arg
,
1394 struct sk_buff
*resp
)
1398 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
1401 return PTR_ERR(resp
);
1403 status
= resp
->data
[0];
1404 skb_pull(resp
, sizeof(status
));
1407 nfc_tm_deactivated(dev
->nfc_dev
);
1409 dev_kfree_skb(resp
);
1413 return nfc_tm_data_received(dev
->nfc_dev
, resp
);
1416 static void pn533_wq_tg_get_data(struct work_struct
*work
)
1418 struct pn533
*dev
= container_of(work
, struct pn533
, tg_work
);
1420 struct sk_buff
*skb
;
1423 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
1425 skb
= pn533_alloc_skb(dev
, 0);
1429 rc
= pn533_send_data_async(dev
, PN533_CMD_TG_GET_DATA
, skb
,
1430 pn533_tm_get_data_complete
, NULL
);
1438 #define ATR_REQ_GB_OFFSET 17
1439 static int pn533_init_target_complete(struct pn533
*dev
, struct sk_buff
*resp
)
1441 u8 mode
, *cmd
, comm_mode
= NFC_COMM_PASSIVE
, *gb
;
1445 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
1447 if (resp
->len
< ATR_REQ_GB_OFFSET
+ 1)
1450 mode
= resp
->data
[0];
1451 cmd
= &resp
->data
[1];
1453 nfc_dev_dbg(&dev
->interface
->dev
, "Target mode 0x%x len %d\n",
1456 if ((mode
& PN533_INIT_TARGET_RESP_FRAME_MASK
) ==
1457 PN533_INIT_TARGET_RESP_ACTIVE
)
1458 comm_mode
= NFC_COMM_ACTIVE
;
1460 if ((mode
& PN533_INIT_TARGET_RESP_DEP
) == 0) /* Only DEP supported */
1463 gb
= cmd
+ ATR_REQ_GB_OFFSET
;
1464 gb_len
= resp
->len
- (ATR_REQ_GB_OFFSET
+ 1);
1466 rc
= nfc_tm_activated(dev
->nfc_dev
, NFC_PROTO_NFC_DEP_MASK
,
1467 comm_mode
, gb
, gb_len
);
1469 nfc_dev_err(&dev
->interface
->dev
,
1470 "Error when signaling target activation");
1475 queue_work(dev
->wq
, &dev
->tg_work
);
1480 static void pn533_listen_mode_timer(unsigned long data
)
1482 struct pn533
*dev
= (struct pn533
*)data
;
1484 nfc_dev_dbg(&dev
->interface
->dev
, "Listen mode timeout");
1486 /* An ack will cancel the last issued command (poll) */
1487 pn533_send_ack(dev
, GFP_ATOMIC
);
1489 dev
->cancel_listen
= 1;
1491 pn533_poll_next_mod(dev
);
1493 queue_work(dev
->wq
, &dev
->poll_work
);
1496 static int pn533_poll_complete(struct pn533
*dev
, void *arg
,
1497 struct sk_buff
*resp
)
1499 struct pn533_poll_modulations
*cur_mod
;
1502 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
1507 nfc_dev_err(&dev
->interface
->dev
, "%s Poll complete error %d",
1510 if (rc
== -ENOENT
) {
1511 if (dev
->poll_mod_count
!= 0)
1515 } else if (rc
< 0) {
1516 nfc_dev_err(&dev
->interface
->dev
,
1517 "Error %d when running poll", rc
);
1522 cur_mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1524 if (cur_mod
->len
== 0) { /* Target mode */
1525 del_timer(&dev
->listen_timer
);
1526 rc
= pn533_init_target_complete(dev
, resp
);
1530 /* Initiator mode */
1531 rc
= pn533_start_poll_complete(dev
, resp
);
1535 if (!dev
->poll_mod_count
) {
1536 nfc_dev_dbg(&dev
->interface
->dev
, "Polling has been stoped.");
1540 pn533_poll_next_mod(dev
);
1541 queue_work(dev
->wq
, &dev
->poll_work
);
1544 dev_kfree_skb(resp
);
1548 nfc_dev_err(&dev
->interface
->dev
, "Polling operation has been stopped");
1550 pn533_poll_reset_mod_list(dev
);
1551 dev
->poll_protocols
= 0;
1555 static struct sk_buff
*pn533_alloc_poll_in_frame(struct pn533
*dev
,
1556 struct pn533_poll_modulations
*mod
)
1558 struct sk_buff
*skb
;
1560 skb
= pn533_alloc_skb(dev
, mod
->len
);
1564 memcpy(skb_put(skb
, mod
->len
), &mod
->data
, mod
->len
);
1569 static int pn533_send_poll_frame(struct pn533
*dev
)
1571 struct pn533_poll_modulations
*mod
;
1572 struct sk_buff
*skb
;
1576 mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1578 nfc_dev_dbg(&dev
->interface
->dev
, "%s mod len %d\n",
1579 __func__
, mod
->len
);
1581 if (mod
->len
== 0) { /* Listen mode */
1582 cmd_code
= PN533_CMD_TG_INIT_AS_TARGET
;
1583 skb
= pn533_alloc_poll_tg_frame(dev
);
1584 } else { /* Polling mode */
1585 cmd_code
= PN533_CMD_IN_LIST_PASSIVE_TARGET
;
1586 skb
= pn533_alloc_poll_in_frame(dev
, mod
);
1590 nfc_dev_err(&dev
->interface
->dev
, "Failed to allocate skb.");
1594 rc
= pn533_send_cmd_async(dev
, cmd_code
, skb
, pn533_poll_complete
,
1598 nfc_dev_err(&dev
->interface
->dev
, "Polling loop error %d", rc
);
1604 static void pn533_wq_poll(struct work_struct
*work
)
1606 struct pn533
*dev
= container_of(work
, struct pn533
, poll_work
);
1607 struct pn533_poll_modulations
*cur_mod
;
1610 cur_mod
= dev
->poll_mod_active
[dev
->poll_mod_curr
];
1612 nfc_dev_dbg(&dev
->interface
->dev
,
1613 "%s cancel_listen %d modulation len %d",
1614 __func__
, dev
->cancel_listen
, cur_mod
->len
);
1616 if (dev
->cancel_listen
== 1) {
1617 dev
->cancel_listen
= 0;
1618 usb_kill_urb(dev
->in_urb
);
1621 rc
= pn533_send_poll_frame(dev
);
1625 if (cur_mod
->len
== 0 && dev
->poll_mod_count
> 1)
1626 mod_timer(&dev
->listen_timer
, jiffies
+ PN533_LISTEN_TIME
* HZ
);
1631 static int pn533_start_poll(struct nfc_dev
*nfc_dev
,
1632 u32 im_protocols
, u32 tm_protocols
)
1634 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1636 nfc_dev_dbg(&dev
->interface
->dev
,
1637 "%s: im protocols 0x%x tm protocols 0x%x",
1638 __func__
, im_protocols
, tm_protocols
);
1640 if (dev
->tgt_active_prot
) {
1641 nfc_dev_err(&dev
->interface
->dev
,
1642 "Cannot poll with a target already activated");
1646 if (dev
->tgt_mode
) {
1647 nfc_dev_err(&dev
->interface
->dev
,
1648 "Cannot poll while already being activated");
1653 dev
->gb
= nfc_get_local_general_bytes(nfc_dev
, &dev
->gb_len
);
1654 if (dev
->gb
== NULL
)
1658 dev
->poll_mod_curr
= 0;
1659 pn533_poll_create_mod_list(dev
, im_protocols
, tm_protocols
);
1660 dev
->poll_protocols
= im_protocols
;
1661 dev
->listen_protocols
= tm_protocols
;
1663 return pn533_send_poll_frame(dev
);
1666 static void pn533_stop_poll(struct nfc_dev
*nfc_dev
)
1668 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1670 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
1672 del_timer(&dev
->listen_timer
);
1674 if (!dev
->poll_mod_count
) {
1675 nfc_dev_dbg(&dev
->interface
->dev
,
1676 "Polling operation was not running");
1680 /* An ack will cancel the last issued command (poll) */
1681 pn533_send_ack(dev
, GFP_KERNEL
);
1683 /* prevent pn533_start_poll_complete to issue a new poll meanwhile */
1684 usb_kill_urb(dev
->in_urb
);
1686 pn533_poll_reset_mod_list(dev
);
1689 static int pn533_activate_target_nfcdep(struct pn533
*dev
)
1691 struct pn533_cmd_activate_response
*rsp
;
1695 struct sk_buff
*skb
;
1696 struct sk_buff
*resp
;
1698 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
1700 skb
= pn533_alloc_skb(dev
, sizeof(u8
) * 2); /*TG + Next*/
1704 *skb_put(skb
, sizeof(u8
)) = 1; /* TG */
1705 *skb_put(skb
, sizeof(u8
)) = 0; /* Next */
1707 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_IN_ATR
, skb
);
1709 return PTR_ERR(resp
);
1711 rsp
= (struct pn533_cmd_activate_response
*)resp
->data
;
1712 rc
= rsp
->status
& PN533_CMD_RET_MASK
;
1713 if (rc
!= PN533_CMD_RET_SUCCESS
) {
1714 nfc_dev_err(&dev
->interface
->dev
,
1715 "Target activation failed (error 0x%x)", rc
);
1716 dev_kfree_skb(resp
);
1720 /* ATR_RES general bytes are located at offset 16 */
1721 gt_len
= resp
->len
- 16;
1722 rc
= nfc_set_remote_general_bytes(dev
->nfc_dev
, rsp
->gt
, gt_len
);
1724 dev_kfree_skb(resp
);
1728 static int pn533_activate_target(struct nfc_dev
*nfc_dev
,
1729 struct nfc_target
*target
, u32 protocol
)
1731 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1734 nfc_dev_dbg(&dev
->interface
->dev
, "%s - protocol=%u", __func__
,
1737 if (dev
->poll_mod_count
) {
1738 nfc_dev_err(&dev
->interface
->dev
,
1739 "Cannot activate while polling");
1743 if (dev
->tgt_active_prot
) {
1744 nfc_dev_err(&dev
->interface
->dev
,
1745 "There is already an active target");
1749 if (!dev
->tgt_available_prots
) {
1750 nfc_dev_err(&dev
->interface
->dev
,
1751 "There is no available target to activate");
1755 if (!(dev
->tgt_available_prots
& (1 << protocol
))) {
1756 nfc_dev_err(&dev
->interface
->dev
,
1757 "Target doesn't support requested proto %u",
1762 if (protocol
== NFC_PROTO_NFC_DEP
) {
1763 rc
= pn533_activate_target_nfcdep(dev
);
1765 nfc_dev_err(&dev
->interface
->dev
,
1766 "Activating target with DEP failed %d", rc
);
1771 dev
->tgt_active_prot
= protocol
;
1772 dev
->tgt_available_prots
= 0;
1777 static void pn533_deactivate_target(struct nfc_dev
*nfc_dev
,
1778 struct nfc_target
*target
)
1780 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1782 struct sk_buff
*skb
;
1783 struct sk_buff
*resp
;
1787 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
1789 if (!dev
->tgt_active_prot
) {
1790 nfc_dev_err(&dev
->interface
->dev
, "There is no active target");
1794 dev
->tgt_active_prot
= 0;
1795 skb_queue_purge(&dev
->resp_q
);
1797 skb
= pn533_alloc_skb(dev
, sizeof(u8
));
1801 *skb_put(skb
, 1) = 1; /* TG*/
1803 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_IN_RELEASE
, skb
);
1807 rc
= resp
->data
[0] & PN533_CMD_RET_MASK
;
1808 if (rc
!= PN533_CMD_RET_SUCCESS
)
1809 nfc_dev_err(&dev
->interface
->dev
,
1810 "Error 0x%x when releasing the target", rc
);
1812 dev_kfree_skb(resp
);
1817 static int pn533_in_dep_link_up_complete(struct pn533
*dev
, void *arg
,
1818 struct sk_buff
*resp
)
1820 struct pn533_cmd_jump_dep_response
*rsp
;
1823 u8 active
= *(u8
*)arg
;
1828 return PTR_ERR(resp
);
1830 if (dev
->tgt_available_prots
&&
1831 !(dev
->tgt_available_prots
& (1 << NFC_PROTO_NFC_DEP
))) {
1832 nfc_dev_err(&dev
->interface
->dev
,
1833 "The target does not support DEP");
1838 rsp
= (struct pn533_cmd_jump_dep_response
*)resp
->data
;
1840 rc
= rsp
->status
& PN533_CMD_RET_MASK
;
1841 if (rc
!= PN533_CMD_RET_SUCCESS
) {
1842 nfc_dev_err(&dev
->interface
->dev
,
1843 "Bringing DEP link up failed (error 0x%x)", rc
);
1847 if (!dev
->tgt_available_prots
) {
1848 struct nfc_target nfc_target
;
1850 nfc_dev_dbg(&dev
->interface
->dev
, "Creating new target");
1852 nfc_target
.supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
1853 nfc_target
.nfcid1_len
= 10;
1854 memcpy(nfc_target
.nfcid1
, rsp
->nfcid3t
, nfc_target
.nfcid1_len
);
1855 rc
= nfc_targets_found(dev
->nfc_dev
, &nfc_target
, 1);
1859 dev
->tgt_available_prots
= 0;
1862 dev
->tgt_active_prot
= NFC_PROTO_NFC_DEP
;
1864 /* ATR_RES general bytes are located at offset 17 */
1865 target_gt_len
= resp
->len
- 17;
1866 rc
= nfc_set_remote_general_bytes(dev
->nfc_dev
,
1867 rsp
->gt
, target_gt_len
);
1869 rc
= nfc_dep_link_is_up(dev
->nfc_dev
,
1870 dev
->nfc_dev
->targets
[0].idx
,
1871 !active
, NFC_RF_INITIATOR
);
1874 dev_kfree_skb(resp
);
1878 static int pn533_mod_to_baud(struct pn533
*dev
)
1880 switch (dev
->poll_mod_curr
) {
1881 case PN533_POLL_MOD_106KBPS_A
:
1883 case PN533_POLL_MOD_212KBPS_FELICA
:
1885 case PN533_POLL_MOD_424KBPS_FELICA
:
1892 #define PASSIVE_DATA_LEN 5
1893 static int pn533_dep_link_up(struct nfc_dev
*nfc_dev
, struct nfc_target
*target
,
1894 u8 comm_mode
, u8
*gb
, size_t gb_len
)
1896 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1897 struct sk_buff
*skb
;
1898 int rc
, baud
, skb_len
;
1901 u8 passive_data
[PASSIVE_DATA_LEN
] = {0x00, 0xff, 0xff, 0x00, 0x3};
1903 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
1905 if (dev
->poll_mod_count
) {
1906 nfc_dev_err(&dev
->interface
->dev
,
1907 "Cannot bring the DEP link up while polling");
1911 if (dev
->tgt_active_prot
) {
1912 nfc_dev_err(&dev
->interface
->dev
,
1913 "There is already an active target");
1917 baud
= pn533_mod_to_baud(dev
);
1919 nfc_dev_err(&dev
->interface
->dev
,
1920 "Invalid curr modulation %d", dev
->poll_mod_curr
);
1924 skb_len
= 3 + gb_len
; /* ActPass + BR + Next */
1925 if (comm_mode
== NFC_COMM_PASSIVE
)
1926 skb_len
+= PASSIVE_DATA_LEN
;
1928 skb
= pn533_alloc_skb(dev
, skb_len
);
1932 *skb_put(skb
, 1) = !comm_mode
; /* ActPass */
1933 *skb_put(skb
, 1) = baud
; /* Baud rate */
1935 next
= skb_put(skb
, 1); /* Next */
1938 if (comm_mode
== NFC_COMM_PASSIVE
&& baud
> 0) {
1939 memcpy(skb_put(skb
, PASSIVE_DATA_LEN
), passive_data
,
1944 if (gb
!= NULL
&& gb_len
> 0) {
1945 memcpy(skb_put(skb
, gb_len
), gb
, gb_len
);
1946 *next
|= 4; /* We have some Gi */
1951 arg
= kmalloc(sizeof(*arg
), GFP_KERNEL
);
1959 rc
= pn533_send_cmd_async(dev
, PN533_CMD_IN_JUMP_FOR_DEP
, skb
,
1960 pn533_in_dep_link_up_complete
, arg
);
1970 static int pn533_dep_link_down(struct nfc_dev
*nfc_dev
)
1972 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
1974 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
1976 pn533_poll_reset_mod_list(dev
);
1978 if (dev
->tgt_mode
|| dev
->tgt_active_prot
) {
1979 pn533_send_ack(dev
, GFP_KERNEL
);
1980 usb_kill_urb(dev
->in_urb
);
1983 dev
->tgt_active_prot
= 0;
1986 skb_queue_purge(&dev
->resp_q
);
1991 struct pn533_data_exchange_arg
{
1992 data_exchange_cb_t cb
;
1996 static struct sk_buff
*pn533_build_response(struct pn533
*dev
)
1998 struct sk_buff
*skb
, *tmp
, *t
;
1999 unsigned int skb_len
= 0, tmp_len
= 0;
2001 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
2003 if (skb_queue_empty(&dev
->resp_q
))
2006 if (skb_queue_len(&dev
->resp_q
) == 1) {
2007 skb
= skb_dequeue(&dev
->resp_q
);
2011 skb_queue_walk_safe(&dev
->resp_q
, tmp
, t
)
2012 skb_len
+= tmp
->len
;
2014 nfc_dev_dbg(&dev
->interface
->dev
, "%s total length %d\n",
2017 skb
= alloc_skb(skb_len
, GFP_KERNEL
);
2021 skb_put(skb
, skb_len
);
2023 skb_queue_walk_safe(&dev
->resp_q
, tmp
, t
) {
2024 memcpy(skb
->data
+ tmp_len
, tmp
->data
, tmp
->len
);
2025 tmp_len
+= tmp
->len
;
2029 skb_queue_purge(&dev
->resp_q
);
2034 static int pn533_data_exchange_complete(struct pn533
*dev
, void *_arg
,
2035 struct sk_buff
*resp
)
2037 struct pn533_data_exchange_arg
*arg
= _arg
;
2038 struct sk_buff
*skb
;
2042 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
2049 status
= resp
->data
[0];
2050 ret
= status
& PN533_CMD_RET_MASK
;
2051 mi
= status
& PN533_CMD_MI_MASK
;
2053 skb_pull(resp
, sizeof(status
));
2055 if (ret
!= PN533_CMD_RET_SUCCESS
) {
2056 nfc_dev_err(&dev
->interface
->dev
,
2057 "Exchanging data failed (error 0x%x)", ret
);
2062 skb_queue_tail(&dev
->resp_q
, resp
);
2065 dev
->cmd_complete_mi_arg
= arg
;
2066 queue_work(dev
->wq
, &dev
->mi_work
);
2067 return -EINPROGRESS
;
2070 skb
= pn533_build_response(dev
);
2074 arg
->cb(arg
->cb_context
, skb
, 0);
2079 dev_kfree_skb(resp
);
2081 skb_queue_purge(&dev
->resp_q
);
2082 arg
->cb(arg
->cb_context
, NULL
, rc
);
2087 static int pn533_transceive(struct nfc_dev
*nfc_dev
,
2088 struct nfc_target
*target
, struct sk_buff
*skb
,
2089 data_exchange_cb_t cb
, void *cb_context
)
2091 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
2092 struct pn533_data_exchange_arg
*arg
= NULL
;
2095 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
2097 if (skb
->len
> PN533_CMD_DATAEXCH_DATA_MAXLEN
) {
2098 /* TODO: Implement support to multi-part data exchange */
2099 nfc_dev_err(&dev
->interface
->dev
,
2100 "Data length greater than the max allowed: %d",
2101 PN533_CMD_DATAEXCH_DATA_MAXLEN
);
2106 if (!dev
->tgt_active_prot
) {
2107 nfc_dev_err(&dev
->interface
->dev
,
2108 "Can't exchange data if there is no active target");
2113 arg
= kmalloc(sizeof(*arg
), GFP_KERNEL
);
2120 arg
->cb_context
= cb_context
;
2122 switch (dev
->device_type
) {
2123 case PN533_DEVICE_PASORI
:
2124 if (dev
->tgt_active_prot
== NFC_PROTO_FELICA
) {
2125 rc
= pn533_send_data_async(dev
, PN533_CMD_IN_COMM_THRU
,
2127 pn533_data_exchange_complete
,
2133 *skb_push(skb
, sizeof(u8
)) = 1; /*TG*/
2135 rc
= pn533_send_data_async(dev
, PN533_CMD_IN_DATA_EXCHANGE
,
2136 skb
, pn533_data_exchange_complete
,
2142 if (rc
< 0) /* rc from send_async */
2153 static int pn533_tm_send_complete(struct pn533
*dev
, void *arg
,
2154 struct sk_buff
*resp
)
2158 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
2161 return PTR_ERR(resp
);
2163 status
= resp
->data
[0];
2165 dev_kfree_skb(resp
);
2168 nfc_tm_deactivated(dev
->nfc_dev
);
2175 queue_work(dev
->wq
, &dev
->tg_work
);
2180 static int pn533_tm_send(struct nfc_dev
*nfc_dev
, struct sk_buff
*skb
)
2182 struct pn533
*dev
= nfc_get_drvdata(nfc_dev
);
2185 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
2187 if (skb
->len
> PN533_CMD_DATAEXCH_DATA_MAXLEN
) {
2188 nfc_dev_err(&dev
->interface
->dev
,
2189 "Data length greater than the max allowed: %d",
2190 PN533_CMD_DATAEXCH_DATA_MAXLEN
);
2194 rc
= pn533_send_data_async(dev
, PN533_CMD_TG_SET_DATA
, skb
,
2195 pn533_tm_send_complete
, NULL
);
2202 static void pn533_wq_mi_recv(struct work_struct
*work
)
2204 struct pn533
*dev
= container_of(work
, struct pn533
, mi_work
);
2206 struct sk_buff
*skb
;
2209 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
2211 skb
= pn533_alloc_skb(dev
, PN533_CMD_DATAEXCH_HEAD_LEN
);
2215 switch (dev
->device_type
) {
2216 case PN533_DEVICE_PASORI
:
2217 if (dev
->tgt_active_prot
== NFC_PROTO_FELICA
) {
2218 rc
= pn533_send_cmd_direct_async(dev
,
2219 PN533_CMD_IN_COMM_THRU
,
2221 pn533_data_exchange_complete
,
2222 dev
->cmd_complete_mi_arg
);
2227 *skb_put(skb
, sizeof(u8
)) = 1; /*TG*/
2229 rc
= pn533_send_cmd_direct_async(dev
,
2230 PN533_CMD_IN_DATA_EXCHANGE
,
2232 pn533_data_exchange_complete
,
2233 dev
->cmd_complete_mi_arg
);
2238 if (rc
== 0) /* success */
2241 nfc_dev_err(&dev
->interface
->dev
,
2242 "Error %d when trying to perform data_exchange", rc
);
2245 kfree(dev
->cmd_complete_mi_arg
);
2248 pn533_send_ack(dev
, GFP_KERNEL
);
2249 queue_work(dev
->wq
, &dev
->cmd_work
);
2252 static int pn533_set_configuration(struct pn533
*dev
, u8 cfgitem
, u8
*cfgdata
,
2255 struct sk_buff
*skb
;
2256 struct sk_buff
*resp
;
2260 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
2262 skb_len
= sizeof(cfgitem
) + cfgdata_len
; /* cfgitem + cfgdata */
2264 skb
= pn533_alloc_skb(dev
, skb_len
);
2268 *skb_put(skb
, sizeof(cfgitem
)) = cfgitem
;
2269 memcpy(skb_put(skb
, cfgdata_len
), cfgdata
, cfgdata_len
);
2271 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_RF_CONFIGURATION
, skb
);
2273 return PTR_ERR(resp
);
2275 dev_kfree_skb(resp
);
2279 static int pn533_get_firmware_version(struct pn533
*dev
,
2280 struct pn533_fw_version
*fv
)
2282 struct sk_buff
*skb
;
2283 struct sk_buff
*resp
;
2285 skb
= pn533_alloc_skb(dev
, 0);
2289 resp
= pn533_send_cmd_sync(dev
, PN533_CMD_GET_FIRMWARE_VERSION
, skb
);
2291 return PTR_ERR(resp
);
2293 fv
->ic
= resp
->data
[0];
2294 fv
->ver
= resp
->data
[1];
2295 fv
->rev
= resp
->data
[2];
2296 fv
->support
= resp
->data
[3];
2298 dev_kfree_skb(resp
);
2302 static int pn533_pasori_fw_reset(struct pn533
*dev
)
2304 struct sk_buff
*skb
;
2305 struct sk_buff
*resp
;
2307 nfc_dev_dbg(&dev
->interface
->dev
, "%s", __func__
);
2309 skb
= pn533_alloc_skb(dev
, sizeof(u8
));
2313 *skb_put(skb
, sizeof(u8
)) = 0x1;
2315 resp
= pn533_send_cmd_sync(dev
, 0x18, skb
);
2317 return PTR_ERR(resp
);
2319 dev_kfree_skb(resp
);
2324 static struct nfc_ops pn533_nfc_ops
= {
2327 .dep_link_up
= pn533_dep_link_up
,
2328 .dep_link_down
= pn533_dep_link_down
,
2329 .start_poll
= pn533_start_poll
,
2330 .stop_poll
= pn533_stop_poll
,
2331 .activate_target
= pn533_activate_target
,
2332 .deactivate_target
= pn533_deactivate_target
,
2333 .im_transceive
= pn533_transceive
,
2334 .tm_send
= pn533_tm_send
,
2337 static int pn533_setup(struct pn533
*dev
)
2339 struct pn533_config_max_retries max_retries
;
2340 struct pn533_config_timing timing
;
2341 u8 pasori_cfg
[3] = {0x08, 0x01, 0x08};
2344 switch (dev
->device_type
) {
2345 case PN533_DEVICE_STD
:
2346 max_retries
.mx_rty_atr
= PN533_CONFIG_MAX_RETRIES_ENDLESS
;
2347 max_retries
.mx_rty_psl
= 2;
2348 max_retries
.mx_rty_passive_act
=
2349 PN533_CONFIG_MAX_RETRIES_NO_RETRY
;
2351 timing
.rfu
= PN533_CONFIG_TIMING_102
;
2352 timing
.atr_res_timeout
= PN533_CONFIG_TIMING_204
;
2353 timing
.dep_timeout
= PN533_CONFIG_TIMING_409
;
2357 case PN533_DEVICE_PASORI
:
2358 max_retries
.mx_rty_atr
= 0x2;
2359 max_retries
.mx_rty_psl
= 0x1;
2360 max_retries
.mx_rty_passive_act
=
2361 PN533_CONFIG_MAX_RETRIES_NO_RETRY
;
2363 timing
.rfu
= PN533_CONFIG_TIMING_102
;
2364 timing
.atr_res_timeout
= PN533_CONFIG_TIMING_102
;
2365 timing
.dep_timeout
= PN533_CONFIG_TIMING_204
;
2370 nfc_dev_err(&dev
->interface
->dev
, "Unknown device type %d\n",
2375 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_MAX_RETRIES
,
2376 (u8
*)&max_retries
, sizeof(max_retries
));
2378 nfc_dev_err(&dev
->interface
->dev
,
2379 "Error on setting MAX_RETRIES config");
2384 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_TIMING
,
2385 (u8
*)&timing
, sizeof(timing
));
2387 nfc_dev_err(&dev
->interface
->dev
,
2388 "Error on setting RF timings");
2392 switch (dev
->device_type
) {
2393 case PN533_DEVICE_STD
:
2396 case PN533_DEVICE_PASORI
:
2397 pn533_pasori_fw_reset(dev
);
2399 rc
= pn533_set_configuration(dev
, PN533_CFGITEM_PASORI
,
2402 nfc_dev_err(&dev
->interface
->dev
,
2403 "Error while settings PASORI config");
2407 pn533_pasori_fw_reset(dev
);
2415 static int pn533_probe(struct usb_interface
*interface
,
2416 const struct usb_device_id
*id
)
2418 struct pn533_fw_version fw_ver
;
2420 struct usb_host_interface
*iface_desc
;
2421 struct usb_endpoint_descriptor
*endpoint
;
2422 int in_endpoint
= 0;
2423 int out_endpoint
= 0;
2428 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
2432 dev
->udev
= usb_get_dev(interface_to_usbdev(interface
));
2433 dev
->interface
= interface
;
2434 mutex_init(&dev
->cmd_lock
);
2436 iface_desc
= interface
->cur_altsetting
;
2437 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
2438 endpoint
= &iface_desc
->endpoint
[i
].desc
;
2440 if (!in_endpoint
&& usb_endpoint_is_bulk_in(endpoint
))
2441 in_endpoint
= endpoint
->bEndpointAddress
;
2443 if (!out_endpoint
&& usb_endpoint_is_bulk_out(endpoint
))
2444 out_endpoint
= endpoint
->bEndpointAddress
;
2447 if (!in_endpoint
|| !out_endpoint
) {
2448 nfc_dev_err(&interface
->dev
,
2449 "Could not find bulk-in or bulk-out endpoint");
2454 dev
->in_urb
= usb_alloc_urb(0, GFP_KERNEL
);
2455 dev
->out_urb
= usb_alloc_urb(0, GFP_KERNEL
);
2457 if (!dev
->in_urb
|| !dev
->out_urb
)
2460 usb_fill_bulk_urb(dev
->in_urb
, dev
->udev
,
2461 usb_rcvbulkpipe(dev
->udev
, in_endpoint
),
2462 NULL
, 0, NULL
, dev
);
2463 usb_fill_bulk_urb(dev
->out_urb
, dev
->udev
,
2464 usb_sndbulkpipe(dev
->udev
, out_endpoint
),
2465 NULL
, 0, pn533_send_complete
, dev
);
2467 INIT_WORK(&dev
->cmd_work
, pn533_wq_cmd
);
2468 INIT_WORK(&dev
->cmd_complete_work
, pn533_wq_cmd_complete
);
2469 INIT_WORK(&dev
->mi_work
, pn533_wq_mi_recv
);
2470 INIT_WORK(&dev
->tg_work
, pn533_wq_tg_get_data
);
2471 INIT_WORK(&dev
->poll_work
, pn533_wq_poll
);
2472 dev
->wq
= alloc_ordered_workqueue("pn533", 0);
2473 if (dev
->wq
== NULL
)
2476 init_timer(&dev
->listen_timer
);
2477 dev
->listen_timer
.data
= (unsigned long) dev
;
2478 dev
->listen_timer
.function
= pn533_listen_mode_timer
;
2480 skb_queue_head_init(&dev
->resp_q
);
2482 INIT_LIST_HEAD(&dev
->cmd_queue
);
2484 usb_set_intfdata(interface
, dev
);
2486 dev
->ops
= &pn533_std_frame_ops
;
2488 dev
->device_type
= id
->driver_info
;
2489 switch (dev
->device_type
) {
2490 case PN533_DEVICE_STD
:
2491 protocols
= PN533_ALL_PROTOCOLS
;
2494 case PN533_DEVICE_PASORI
:
2495 protocols
= PN533_NO_TYPE_B_PROTOCOLS
;
2499 nfc_dev_err(&dev
->interface
->dev
, "Unknown device type %d\n",
2505 memset(&fw_ver
, 0, sizeof(fw_ver
));
2506 rc
= pn533_get_firmware_version(dev
, &fw_ver
);
2510 nfc_dev_info(&dev
->interface
->dev
,
2511 "NXP PN533 firmware ver %d.%d now attached",
2512 fw_ver
.ver
, fw_ver
.rev
);
2515 dev
->nfc_dev
= nfc_allocate_device(&pn533_nfc_ops
, protocols
,
2517 dev
->ops
->tx_header_len
+
2518 PN533_CMD_DATAEXCH_HEAD_LEN
,
2519 dev
->ops
->tx_tail_len
);
2523 nfc_set_parent_dev(dev
->nfc_dev
, &interface
->dev
);
2524 nfc_set_drvdata(dev
->nfc_dev
, dev
);
2526 rc
= nfc_register_device(dev
->nfc_dev
);
2530 rc
= pn533_setup(dev
);
2532 goto unregister_nfc_dev
;
2537 nfc_unregister_device(dev
->nfc_dev
);
2540 nfc_free_device(dev
->nfc_dev
);
2543 destroy_workqueue(dev
->wq
);
2545 usb_free_urb(dev
->in_urb
);
2546 usb_free_urb(dev
->out_urb
);
2551 static void pn533_disconnect(struct usb_interface
*interface
)
2554 struct pn533_cmd
*cmd
, *n
;
2556 dev
= usb_get_intfdata(interface
);
2557 usb_set_intfdata(interface
, NULL
);
2559 nfc_unregister_device(dev
->nfc_dev
);
2560 nfc_free_device(dev
->nfc_dev
);
2562 usb_kill_urb(dev
->in_urb
);
2563 usb_kill_urb(dev
->out_urb
);
2565 destroy_workqueue(dev
->wq
);
2567 skb_queue_purge(&dev
->resp_q
);
2569 del_timer(&dev
->listen_timer
);
2571 list_for_each_entry_safe(cmd
, n
, &dev
->cmd_queue
, queue
) {
2572 list_del(&cmd
->queue
);
2576 usb_free_urb(dev
->in_urb
);
2577 usb_free_urb(dev
->out_urb
);
2580 nfc_dev_info(&interface
->dev
, "NXP PN533 NFC device disconnected");
2583 static struct usb_driver pn533_driver
= {
2585 .probe
= pn533_probe
,
2586 .disconnect
= pn533_disconnect
,
2587 .id_table
= pn533_table
,
2590 module_usb_driver(pn533_driver
);
2592 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
2593 MODULE_AUTHOR("Aloisio Almeida Jr <aloisio.almeida@openbossa.org>");
2594 MODULE_AUTHOR("Waldemar Rymarkiewicz <waldemar.rymarkiewicz@tieto.com>");
2595 MODULE_DESCRIPTION("PN533 usb driver ver " VERSION
);
2596 MODULE_VERSION(VERSION
);
2597 MODULE_LICENSE("GPL");