projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NFC: nfcwilink: Remove redundant dev_set_drvdata
[deliverable/linux.git] / drivers / nfc / pn533.c
CommitLineData
c46ee386
AAJ		 1/*
2 * Copyright (C) 2011 Instituto Nokia de Tecnologia
e70b96e9 3 * Copyright (C) 2012-2013 Tieto Poland
c46ee386
AAJ		 4 *
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.
9 *
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.
14 *
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.
19 */
20
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>
55eb94f9 28#include <net/nfc/nfc.h>
c46ee386 29
495af72e 30#define VERSION "0.2"
c46ee386
AAJ		 31
32#define PN533_VENDOR_ID 0x4CC
33#define PN533_PRODUCT_ID 0x2533
34
35#define SCM_VENDOR_ID 0x4E6
36#define SCL3711_PRODUCT_ID 0x5591
37
5c7b0531
SO		 38#define SONY_VENDOR_ID 0x054c
39#define PASORI_PRODUCT_ID 0x02e1
40
53cf4839
WR		 41#define ACS_VENDOR_ID 0x072f
42#define ACR122U_PRODUCT_ID 0x2200
43
44#define PN533_DEVICE_STD 0x1
45#define PN533_DEVICE_PASORI 0x2
46#define PN533_DEVICE_ACR122U 0x3
5c7b0531 47
01d719a2
SO		 48#define PN533_ALL_PROTOCOLS (NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK |\
49 NFC_PROTO_FELICA_MASK | NFC_PROTO_ISO14443_MASK |\
50 NFC_PROTO_NFC_DEP_MASK |\
51 NFC_PROTO_ISO14443_B_MASK)
5c7b0531
SO		 52
53#define PN533_NO_TYPE_B_PROTOCOLS (NFC_PROTO_JEWEL_MASK | \
54 NFC_PROTO_MIFARE_MASK | \
55 NFC_PROTO_FELICA_MASK | \
01d719a2 56 NFC_PROTO_ISO14443_MASK | \
5c7b0531
SO		 57 NFC_PROTO_NFC_DEP_MASK)
58
c46ee386 59static const struct usb_device_id pn533_table[] = {
5c7b0531
SO		 60 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
61 .idVendor = PN533_VENDOR_ID,
62 .idProduct = PN533_PRODUCT_ID,
63 .driver_info = PN533_DEVICE_STD,
64 },
65 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
66 .idVendor = SCM_VENDOR_ID,
67 .idProduct = SCL3711_PRODUCT_ID,
68 .driver_info = PN533_DEVICE_STD,
69 },
70 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
71 .idVendor = SONY_VENDOR_ID,
72 .idProduct = PASORI_PRODUCT_ID,
73 .driver_info = PN533_DEVICE_PASORI,
74 },
53cf4839
WR		 75 { .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
76 .idVendor = ACS_VENDOR_ID,
77 .idProduct = ACR122U_PRODUCT_ID,
78 .driver_info = PN533_DEVICE_ACR122U,
79 },
c46ee386
AAJ		 80 { }
81};
82MODULE_DEVICE_TABLE(usb, pn533_table);
83
6fbbdc16
SO		 84/* How much time we spend listening for initiators */
85#define PN533_LISTEN_TIME 2
46f793b0
SO		 86/* Delay between each poll frame (ms) */
87#define PN533_POLL_INTERVAL 10
6fbbdc16 88
1575b9d8 89/* Standard pn533 frame definitions (standard and extended)*/
63123108 90#define PN533_STD_FRAME_HEADER_LEN (sizeof(struct pn533_std_frame) \
b1bb290a 91 + 2) /* data[0] TFI, data[1] CC */
63123108 92#define PN533_STD_FRAME_TAIL_LEN 2 /* data[len] DCS, data[len + 1] postamble*/
82dec34d 93
1575b9d8
OG		 94#define PN533_EXT_FRAME_HEADER_LEN (sizeof(struct pn533_ext_frame) \
95 + 2) /* data[0] TFI, data[1] CC */
96
97#define PN533_CMD_DATAEXCH_DATA_MAXLEN 262
98#define PN533_CMD_DATAFRAME_MAXLEN 240 /* max data length (send) */
99
15461aeb
WR		 100/*
101 * Max extended frame payload len, excluding TFI and CC
102 * which are already in PN533_FRAME_HEADER_LEN.
103 */
63123108 104#define PN533_STD_FRAME_MAX_PAYLOAD_LEN 263
15461aeb 105
63123108 106#define PN533_STD_FRAME_ACK_SIZE 6 /* Preamble (1), SoPC (2), ACK Code (2),
5b5a4437 107 Postamble (1) */
63123108
WR		 108#define PN533_STD_FRAME_CHECKSUM(f) (f->data[f->datalen])
109#define PN533_STD_FRAME_POSTAMBLE(f) (f->data[f->datalen + 1])
1575b9d8
OG		 110/* Half start code (3), LEN (4) should be 0xffff for extended frame */
111#define PN533_STD_IS_EXTENDED(hdr) ((hdr)->datalen == 0xFF \
112 && (hdr)->datalen_checksum == 0xFF)
113#define PN533_EXT_FRAME_CHECKSUM(f) (f->data[be16_to_cpu(f->datalen)])
c46ee386
AAJ		 114
115/* start of frame */
63123108 116#define PN533_STD_FRAME_SOF 0x00FF
c46ee386 117
63123108
WR		 118/* standard frame identifier: in/out/error */
119#define PN533_STD_FRAME_IDENTIFIER(f) (f->data[0]) /* TFI */
120#define PN533_STD_FRAME_DIR_OUT 0xD4
121#define PN533_STD_FRAME_DIR_IN 0xD5
c46ee386 122
53cf4839
WR		 123/* ACS ACR122 pn533 frame definitions */
124#define PN533_ACR122_TX_FRAME_HEADER_LEN (sizeof(struct pn533_acr122_tx_frame) \
125 + 2)
126#define PN533_ACR122_TX_FRAME_TAIL_LEN 0
127#define PN533_ACR122_RX_FRAME_HEADER_LEN (sizeof(struct pn533_acr122_rx_frame) \
128 + 2)
129#define PN533_ACR122_RX_FRAME_TAIL_LEN 2
130#define PN533_ACR122_FRAME_MAX_PAYLOAD_LEN PN533_STD_FRAME_MAX_PAYLOAD_LEN
131
132/* CCID messages types */
133#define PN533_ACR122_PC_TO_RDR_ICCPOWERON 0x62
134#define PN533_ACR122_PC_TO_RDR_ESCAPE 0x6B
135
136#define PN533_ACR122_RDR_TO_PC_ESCAPE 0x83
137
c46ee386 138/* PN533 Commands */
1575b9d8 139#define PN533_FRAME_CMD(f) (f->data[1])
c46ee386
AAJ		 140
141#define PN533_CMD_GET_FIRMWARE_VERSION 0x02
142#define PN533_CMD_RF_CONFIGURATION 0x32
143#define PN533_CMD_IN_DATA_EXCHANGE 0x40
5c7b0531 144#define PN533_CMD_IN_COMM_THRU 0x42
c46ee386
AAJ		 145#define PN533_CMD_IN_LIST_PASSIVE_TARGET 0x4A
146#define PN533_CMD_IN_ATR 0x50
147#define PN533_CMD_IN_RELEASE 0x52
361f3cb7 148#define PN533_CMD_IN_JUMP_FOR_DEP 0x56
c46ee386 149
ad3823ce 150#define PN533_CMD_TG_INIT_AS_TARGET 0x8c
103b34cf 151#define PN533_CMD_TG_GET_DATA 0x86
dadb06f2 152#define PN533_CMD_TG_SET_DATA 0x8e
aada17ac 153#define PN533_CMD_UNDEF 0xff
ad3823ce 154
c46ee386
AAJ		 155#define PN533_CMD_RESPONSE(cmd) (cmd + 1)
156
157/* PN533 Return codes */
158#define PN533_CMD_RET_MASK 0x3F
159#define PN533_CMD_MI_MASK 0x40
160#define PN533_CMD_RET_SUCCESS 0x00
161
162struct pn533;
163
aada17ac
WR		 164typedef int (*pn533_send_async_complete_t) (struct pn533 *dev, void *arg,
165 struct sk_buff *resp);
166
c46ee386
AAJ		 167/* structs for pn533 commands */
168
169/* PN533_CMD_GET_FIRMWARE_VERSION */
170struct pn533_fw_version {
171 u8 ic;
172 u8 ver;
173 u8 rev;
174 u8 support;
175};
176
177/* PN533_CMD_RF_CONFIGURATION */
60d9edd5
SO		 178#define PN533_CFGITEM_RF_FIELD 0x01
179#define PN533_CFGITEM_TIMING 0x02
c46ee386 180#define PN533_CFGITEM_MAX_RETRIES 0x05
60d9edd5
SO		 181#define PN533_CFGITEM_PASORI 0x82
182
3a8eab39
SO		 183#define PN533_CFGITEM_RF_FIELD_AUTO_RFCA 0x2
184#define PN533_CFGITEM_RF_FIELD_ON 0x1
185#define PN533_CFGITEM_RF_FIELD_OFF 0x0
c46ee386 186
34a85bfc
SO		 187#define PN533_CONFIG_TIMING_102 0xb
188#define PN533_CONFIG_TIMING_204 0xc
189#define PN533_CONFIG_TIMING_409 0xd
190#define PN533_CONFIG_TIMING_819 0xe
191
c46ee386
AAJ		 192#define PN533_CONFIG_MAX_RETRIES_NO_RETRY 0x00
193#define PN533_CONFIG_MAX_RETRIES_ENDLESS 0xFF
194
195struct pn533_config_max_retries {
196 u8 mx_rty_atr;
197 u8 mx_rty_psl;
198 u8 mx_rty_passive_act;
199} __packed;
200
34a85bfc
SO		 201struct pn533_config_timing {
202 u8 rfu;
203 u8 atr_res_timeout;
204 u8 dep_timeout;
205} __packed;
206
c46ee386
AAJ		 207/* PN533_CMD_IN_LIST_PASSIVE_TARGET */
208
209/* felica commands opcode */
210#define PN533_FELICA_OPC_SENSF_REQ 0
211#define PN533_FELICA_OPC_SENSF_RES 1
212/* felica SENSF_REQ parameters */
213#define PN533_FELICA_SENSF_SC_ALL 0xFFFF
214#define PN533_FELICA_SENSF_RC_NO_SYSTEM_CODE 0
215#define PN533_FELICA_SENSF_RC_SYSTEM_CODE 1
216#define PN533_FELICA_SENSF_RC_ADVANCED_PROTOCOL 2
217
218/* type B initiator_data values */
219#define PN533_TYPE_B_AFI_ALL_FAMILIES 0
220#define PN533_TYPE_B_POLL_METHOD_TIMESLOT 0
221#define PN533_TYPE_B_POLL_METHOD_PROBABILISTIC 1
222
223union pn533_cmd_poll_initdata {
224 struct {
225 u8 afi;
226 u8 polling_method;
227 } __packed type_b;
228 struct {
229 u8 opcode;
230 __be16 sc;
231 u8 rc;
232 u8 tsn;
233 } __packed felica;
234};
235
236/* Poll modulations */
237enum {
238 PN533_POLL_MOD_106KBPS_A,
239 PN533_POLL_MOD_212KBPS_FELICA,
240 PN533_POLL_MOD_424KBPS_FELICA,
241 PN533_POLL_MOD_106KBPS_JEWEL,
242 PN533_POLL_MOD_847KBPS_B,
6fbbdc16 243 PN533_LISTEN_MOD,
c46ee386
AAJ		 244
245 __PN533_POLL_MOD_AFTER_LAST,
246};
247#define PN533_POLL_MOD_MAX (__PN533_POLL_MOD_AFTER_LAST - 1)
248
249struct pn533_poll_modulations {
250 struct {
251 u8 maxtg;
252 u8 brty;
253 union pn533_cmd_poll_initdata initiator_data;
254 } __packed data;
255 u8 len;
256};
257
ef3d56e1 258static const struct pn533_poll_modulations poll_mod[] = {
c46ee386
AAJ		 259 [PN533_POLL_MOD_106KBPS_A] = {
260 .data = {
261 .maxtg = 1,
262 .brty = 0,
263 },
264 .len = 2,
265 },
266 [PN533_POLL_MOD_212KBPS_FELICA] = {
267 .data = {
268 .maxtg = 1,
269 .brty = 1,
270 .initiator_data.felica = {
271 .opcode = PN533_FELICA_OPC_SENSF_REQ,
272 .sc = PN533_FELICA_SENSF_SC_ALL,
a94e10f7 273 .rc = PN533_FELICA_SENSF_RC_SYSTEM_CODE,
31c44464 274 .tsn = 0x03,
c46ee386
AAJ		 275 },
276 },
277 .len = 7,
278 },
279 [PN533_POLL_MOD_424KBPS_FELICA] = {
280 .data = {
281 .maxtg = 1,
282 .brty = 2,
283 .initiator_data.felica = {
284 .opcode = PN533_FELICA_OPC_SENSF_REQ,
285 .sc = PN533_FELICA_SENSF_SC_ALL,
a94e10f7 286 .rc = PN533_FELICA_SENSF_RC_SYSTEM_CODE,
31c44464 287 .tsn = 0x03,
c46ee386
AAJ		 288 },
289 },
290 .len = 7,
291 },
292 [PN533_POLL_MOD_106KBPS_JEWEL] = {
293 .data = {
294 .maxtg = 1,
295 .brty = 4,
296 },
297 .len = 2,
298 },
299 [PN533_POLL_MOD_847KBPS_B] = {
300 .data = {
301 .maxtg = 1,
302 .brty = 8,
303 .initiator_data.type_b = {
304 .afi = PN533_TYPE_B_AFI_ALL_FAMILIES,
305 .polling_method =
306 PN533_TYPE_B_POLL_METHOD_TIMESLOT,
307 },
308 },
309 .len = 3,
310 },
6fbbdc16
SO		 311 [PN533_LISTEN_MOD] = {
312 .len = 0,
313 },
c46ee386
AAJ		 314};
315
316/* PN533_CMD_IN_ATR */
317
c46ee386
AAJ		 318struct pn533_cmd_activate_response {
319 u8 status;
320 u8 nfcid3t[10];
321 u8 didt;
322 u8 bst;
323 u8 brt;
324 u8 to;
325 u8 ppt;
326 /* optional */
327 u8 gt[];
328} __packed;
329
361f3cb7
SO		 330struct pn533_cmd_jump_dep_response {
331 u8 status;
332 u8 tg;
333 u8 nfcid3t[10];
334 u8 didt;
335 u8 bst;
336 u8 brt;
337 u8 to;
338 u8 ppt;
339 /* optional */
340 u8 gt[];
341} __packed;
c46ee386 342
ad3823ce
SO		 343
344/* PN533_TG_INIT_AS_TARGET */
345#define PN533_INIT_TARGET_PASSIVE 0x1
346#define PN533_INIT_TARGET_DEP 0x2
347
fc40a8c1
SO		 348#define PN533_INIT_TARGET_RESP_FRAME_MASK 0x3
349#define PN533_INIT_TARGET_RESP_ACTIVE 0x1
350#define PN533_INIT_TARGET_RESP_DEP 0x4
351
58520373
WR		 352enum pn533_protocol_type {
353 PN533_PROTO_REQ_ACK_RESP = 0,
354 PN533_PROTO_REQ_RESP
355};
356
c46ee386
AAJ		 357struct pn533 {
358 struct usb_device *udev;
359 struct usb_interface *interface;
360 struct nfc_dev *nfc_dev;
d5590bba 361 u32 device_type;
58520373 362 enum pn533_protocol_type protocol_type;
c46ee386
AAJ		 363
364 struct urb *out_urb;
c46ee386 365 struct urb *in_urb;
c46ee386 366
6ff73fd2 367 struct sk_buff_head resp_q;
963a82e0 368 struct sk_buff_head fragment_skb;
6ff73fd2 369
4849f85e
SO		 370 struct workqueue_struct *wq;
371 struct work_struct cmd_work;
5d50b364 372 struct work_struct cmd_complete_work;
46f793b0 373 struct delayed_work poll_work;
963a82e0
OG		 374 struct work_struct mi_rx_work;
375 struct work_struct mi_tx_work;
103b34cf 376 struct work_struct tg_work;
17e9d9d4 377 struct work_struct rf_work;
d5590bba
WR		 378
379 struct list_head cmd_queue;
380 struct pn533_cmd *cmd;
381 u8 cmd_pending;
d5590bba 382 struct mutex cmd_lock; /* protects cmd queue */
c46ee386 383
b1e666f5 384 void *cmd_complete_mi_arg;
963a82e0 385 void *cmd_complete_dep_arg;
c46ee386
AAJ		 386
387 struct pn533_poll_modulations *poll_mod_active[PN533_POLL_MOD_MAX + 1];
388 u8 poll_mod_count;
389 u8 poll_mod_curr;
673088fb 390 u8 poll_dep;
c46ee386 391 u32 poll_protocols;
6fbbdc16 392 u32 listen_protocols;
d5590bba
WR		 393 struct timer_list listen_timer;
394 int cancel_listen;
6fbbdc16
SO		 395
396 u8 *gb;
397 size_t gb_len;
c46ee386
AAJ		 398
399 u8 tgt_available_prots;
400 u8 tgt_active_prot;
51ad304c 401 u8 tgt_mode;
5c7b0531 402
9e2d493e 403 struct pn533_frame_ops *ops;
5d50b364
SO		 404};
405
406struct pn533_cmd {
407 struct list_head queue;
4b2a9532 408 u8 code;
f87bc9fb 409 int status;
aada17ac
WR		 410 struct sk_buff *req;
411 struct sk_buff *resp;
9e2d493e 412 int resp_len;
4231604b
WR		 413 pn533_send_async_complete_t complete_cb;
414 void *complete_cb_context;
c46ee386
AAJ		 415};
416
63123108 417struct pn533_std_frame {
c46ee386
AAJ		 418 u8 preamble;
419 __be16 start_frame;
420 u8 datalen;
421 u8 datalen_checksum;
422 u8 data[];
423} __packed;
424
1575b9d8
OG		 425struct pn533_ext_frame { /* Extended Information frame */
426 u8 preamble;
427 __be16 start_frame;
428 __be16 eif_flag; /* fixed to 0xFFFF */
429 __be16 datalen;
430 u8 datalen_checksum;
431 u8 data[];
432} __packed;
433
9e2d493e
WR		 434struct pn533_frame_ops {
435 void (*tx_frame_init)(void *frame, u8 cmd_code);
436 void (*tx_frame_finish)(void *frame);
437 void (*tx_update_payload_len)(void *frame, int len);
438 int tx_header_len;
439 int tx_tail_len;
440
56a63c82 441 bool (*rx_is_frame_valid)(void *frame, struct pn533 *dev);
9e2d493e
WR		 442 int (*rx_frame_size)(void *frame);
443 int rx_header_len;
444 int rx_tail_len;
445
446 int max_payload_len;
447 u8 (*get_cmd_code)(void *frame);
448};
449
53cf4839
WR		 450struct pn533_acr122_ccid_hdr {
451 u8 type;
452 u32 datalen;
453 u8 slot;
454 u8 seq;
455 u8 params[3]; /* 3 msg specific bytes or status, error and 1 specific
456 byte for reposnse msg */
457 u8 data[]; /* payload */
458} __packed;
459
460struct pn533_acr122_apdu_hdr {
461 u8 class;
462 u8 ins;
463 u8 p1;
464 u8 p2;
465} __packed;
466
467struct pn533_acr122_tx_frame {
468 struct pn533_acr122_ccid_hdr ccid;
469 struct pn533_acr122_apdu_hdr apdu;
470 u8 datalen;
471 u8 data[]; /* pn533 frame: TFI ... */
472} __packed;
473
474struct pn533_acr122_rx_frame {
475 struct pn533_acr122_ccid_hdr ccid;
476 u8 data[]; /* pn533 frame : TFI ... */
477} __packed;
478
479static void pn533_acr122_tx_frame_init(void *_frame, u8 cmd_code)
480{
481 struct pn533_acr122_tx_frame *frame = _frame;
482
483 frame->ccid.type = PN533_ACR122_PC_TO_RDR_ESCAPE;
484 frame->ccid.datalen = sizeof(frame->apdu) + 1; /* sizeof(apdu_hdr) +
485 sizeof(datalen) */
486 frame->ccid.slot = 0;
487 frame->ccid.seq = 0;
488 frame->ccid.params[0] = 0;
489 frame->ccid.params[1] = 0;
490 frame->ccid.params[2] = 0;
491
492 frame->data[0] = PN533_STD_FRAME_DIR_OUT;
493 frame->data[1] = cmd_code;
494 frame->datalen = 2; /* data[0] + data[1] */
495
496 frame->apdu.class = 0xFF;
497 frame->apdu.ins = 0;
498 frame->apdu.p1 = 0;
499 frame->apdu.p2 = 0;
500}
501
502static void pn533_acr122_tx_frame_finish(void *_frame)
503{
504 struct pn533_acr122_tx_frame *frame = _frame;
505
506 frame->ccid.datalen += frame->datalen;
507}
508
509static void pn533_acr122_tx_update_payload_len(void *_frame, int len)
510{
511 struct pn533_acr122_tx_frame *frame = _frame;
512
513 frame->datalen += len;
514}
515
56a63c82 516static bool pn533_acr122_is_rx_frame_valid(void *_frame, struct pn533 *dev)
53cf4839
WR		 517{
518 struct pn533_acr122_rx_frame *frame = _frame;
519
520 if (frame->ccid.type != 0x83)
521 return false;
522
523 if (frame->data[frame->ccid.datalen - 2] == 0x63)
524 return false;
525
526 return true;
527}
528
529static int pn533_acr122_rx_frame_size(void *frame)
530{
531 struct pn533_acr122_rx_frame *f = frame;
532
533 /* f->ccid.datalen already includes tail length */
534 return sizeof(struct pn533_acr122_rx_frame) + f->ccid.datalen;
535}
536
537static u8 pn533_acr122_get_cmd_code(void *frame)
538{
539 struct pn533_acr122_rx_frame *f = frame;
540
1575b9d8 541 return PN533_FRAME_CMD(f);
53cf4839
WR		 542}
543
544static struct pn533_frame_ops pn533_acr122_frame_ops = {
545 .tx_frame_init = pn533_acr122_tx_frame_init,
546 .tx_frame_finish = pn533_acr122_tx_frame_finish,
547 .tx_update_payload_len = pn533_acr122_tx_update_payload_len,
548 .tx_header_len = PN533_ACR122_TX_FRAME_HEADER_LEN,
549 .tx_tail_len = PN533_ACR122_TX_FRAME_TAIL_LEN,
550
551 .rx_is_frame_valid = pn533_acr122_is_rx_frame_valid,
552 .rx_header_len = PN533_ACR122_RX_FRAME_HEADER_LEN,
553 .rx_tail_len = PN533_ACR122_RX_FRAME_TAIL_LEN,
554 .rx_frame_size = pn533_acr122_rx_frame_size,
555
556 .max_payload_len = PN533_ACR122_FRAME_MAX_PAYLOAD_LEN,
557 .get_cmd_code = pn533_acr122_get_cmd_code,
558};
559
1575b9d8
OG		 560/* The rule: value(high byte) + value(low byte) + checksum = 0 */
561static inline u8 pn533_ext_checksum(u16 value)
562{
563 return ~(u8)(((value & 0xFF00) >> 8) + (u8)(value & 0xFF)) + 1;
564}
565
c46ee386 566/* The rule: value + checksum = 0 */
63123108 567static inline u8 pn533_std_checksum(u8 value)
c46ee386
AAJ		 568{
569 return ~value + 1;
570}
571
572/* The rule: sum(data elements) + checksum = 0 */
63123108 573static u8 pn533_std_data_checksum(u8 *data, int datalen)
c46ee386
AAJ		 574{
575 u8 sum = 0;
576 int i;
577
578 for (i = 0; i < datalen; i++)
579 sum += data[i];
580
63123108 581 return pn533_std_checksum(sum);
c46ee386
AAJ		 582}
583
63123108 584static void pn533_std_tx_frame_init(void *_frame, u8 cmd_code)
c46ee386 585{
63123108 586 struct pn533_std_frame *frame = _frame;
9e2d493e 587
c46ee386 588 frame->preamble = 0;
63123108
WR		 589 frame->start_frame = cpu_to_be16(PN533_STD_FRAME_SOF);
590 PN533_STD_FRAME_IDENTIFIER(frame) = PN533_STD_FRAME_DIR_OUT;
1575b9d8 591 PN533_FRAME_CMD(frame) = cmd_code;
c46ee386
AAJ		 592 frame->datalen = 2;
593}
594
63123108 595static void pn533_std_tx_frame_finish(void *_frame)
c46ee386 596{
63123108 597 struct pn533_std_frame *frame = _frame;
9e2d493e 598
63123108 599 frame->datalen_checksum = pn533_std_checksum(frame->datalen);
c46ee386 600
63123108
WR		 601 PN533_STD_FRAME_CHECKSUM(frame) =
602 pn533_std_data_checksum(frame->data, frame->datalen);
c46ee386 603
63123108 604 PN533_STD_FRAME_POSTAMBLE(frame) = 0;
c46ee386
AAJ		 605}
606
63123108 607static void pn533_std_tx_update_payload_len(void *_frame, int len)
9e2d493e 608{
63123108 609 struct pn533_std_frame *frame = _frame;
9e2d493e
WR		 610
611 frame->datalen += len;
612}
613
56a63c82 614static bool pn533_std_rx_frame_is_valid(void *_frame, struct pn533 *dev)
c46ee386
AAJ		 615{
616 u8 checksum;
1575b9d8 617 struct pn533_std_frame *stdf = _frame;
c46ee386 618
1575b9d8 619 if (stdf->start_frame != cpu_to_be16(PN533_STD_FRAME_SOF))
c46ee386
AAJ		 620 return false;
621
1575b9d8
OG		 622 if (likely(!PN533_STD_IS_EXTENDED(stdf))) {
623 /* Standard frame code */
56a63c82 624 dev->ops->rx_header_len = PN533_STD_FRAME_HEADER_LEN;
1575b9d8
OG		 625
626 checksum = pn533_std_checksum(stdf->datalen);
627 if (checksum != stdf->datalen_checksum)
628 return false;
629
630 checksum = pn533_std_data_checksum(stdf->data, stdf->datalen);
631 if (checksum != PN533_STD_FRAME_CHECKSUM(stdf))
632 return false;
633 } else {
634 /* Extended */
635 struct pn533_ext_frame *eif = _frame;
636
56a63c82
OG		 637 dev->ops->rx_header_len = PN533_EXT_FRAME_HEADER_LEN;
638
1575b9d8
OG		 639 checksum = pn533_ext_checksum(be16_to_cpu(eif->datalen));
640 if (checksum != eif->datalen_checksum)
641 return false;
642
643 /* check data checksum */
644 checksum = pn533_std_data_checksum(eif->data,
645 be16_to_cpu(eif->datalen));
646 if (checksum != PN533_EXT_FRAME_CHECKSUM(eif))
647 return false;
648 }
c46ee386
AAJ		 649
650 return true;
651}
652
63123108 653static bool pn533_std_rx_frame_is_ack(struct pn533_std_frame *frame)
c46ee386 654{
63123108 655 if (frame->start_frame != cpu_to_be16(PN533_STD_FRAME_SOF))
c46ee386
AAJ		 656 return false;
657
658 if (frame->datalen != 0 || frame->datalen_checksum != 0xFF)
659 return false;
660
661 return true;
662}
663
63123108 664static inline int pn533_std_rx_frame_size(void *frame)
9e2d493e 665{
63123108 666 struct pn533_std_frame *f = frame;
9e2d493e 667
1575b9d8
OG		 668 /* check for Extended Information frame */
669 if (PN533_STD_IS_EXTENDED(f)) {
670 struct pn533_ext_frame *eif = frame;
671
672 return sizeof(struct pn533_ext_frame)
673 + be16_to_cpu(eif->datalen) + PN533_STD_FRAME_TAIL_LEN;
674 }
675
63123108
WR		 676 return sizeof(struct pn533_std_frame) + f->datalen +
677 PN533_STD_FRAME_TAIL_LEN;
9e2d493e
WR		 678}
679
63123108 680static u8 pn533_std_get_cmd_code(void *frame)
9e2d493e 681{
63123108 682 struct pn533_std_frame *f = frame;
1575b9d8 683 struct pn533_ext_frame *eif = frame;
9e2d493e 684
1575b9d8
OG		 685 if (PN533_STD_IS_EXTENDED(f))
686 return PN533_FRAME_CMD(eif);
687 else
688 return PN533_FRAME_CMD(f);
9e2d493e
WR		 689}
690
ef3d56e1 691static struct pn533_frame_ops pn533_std_frame_ops = {
63123108
WR		 692 .tx_frame_init = pn533_std_tx_frame_init,
693 .tx_frame_finish = pn533_std_tx_frame_finish,
694 .tx_update_payload_len = pn533_std_tx_update_payload_len,
695 .tx_header_len = PN533_STD_FRAME_HEADER_LEN,
696 .tx_tail_len = PN533_STD_FRAME_TAIL_LEN,
697
698 .rx_is_frame_valid = pn533_std_rx_frame_is_valid,
699 .rx_frame_size = pn533_std_rx_frame_size,
700 .rx_header_len = PN533_STD_FRAME_HEADER_LEN,
701 .rx_tail_len = PN533_STD_FRAME_TAIL_LEN,
702
703 .max_payload_len = PN533_STD_FRAME_MAX_PAYLOAD_LEN,
704 .get_cmd_code = pn533_std_get_cmd_code,
9e2d493e
WR		 705};
706
707static bool pn533_rx_frame_is_cmd_response(struct pn533 *dev, void *frame)
c46ee386 708{
2c206fb7 709 return (dev->ops->get_cmd_code(frame) ==
4b2a9532 710 PN533_CMD_RESPONSE(dev->cmd->code));
c46ee386
AAJ		 711}
712
c46ee386
AAJ		 713static void pn533_recv_response(struct urb *urb)
714{
715 struct pn533 *dev = urb->context;
f87bc9fb 716 struct pn533_cmd *cmd = dev->cmd;
9e2d493e 717 u8 *in_frame;
c46ee386 718
f87bc9fb
WR		 719 cmd->status = urb->status;
720
c46ee386
AAJ		 721 switch (urb->status) {
722 case 0:
f8f99171 723 break; /* success */
c46ee386
AAJ		 724 case -ECONNRESET:
725 case -ENOENT:
b4834839
JP		 726 dev_dbg(&dev->interface->dev,
727 "The urb has been canceled (status %d)\n",
728 urb->status);
4849f85e 729 goto sched_wq;
f8f99171 730 case -ESHUTDOWN:
c46ee386 731 default:
073a625f
JP		 732 nfc_err(&dev->interface->dev,
733 "Urb failure (status %d)\n", urb->status);
4849f85e 734 goto sched_wq;
c46ee386
AAJ		 735 }
736
737 in_frame = dev->in_urb->transfer_buffer;
738
b4834839 739 dev_dbg(&dev->interface->dev, "Received a frame\n");
e279f84f
SO		 740 print_hex_dump_debug("PN533 RX: ", DUMP_PREFIX_NONE, 16, 1, in_frame,
741 dev->ops->rx_frame_size(in_frame), false);
99e591be 742
56a63c82 743 if (!dev->ops->rx_is_frame_valid(in_frame, dev)) {
073a625f 744 nfc_err(&dev->interface->dev, "Received an invalid frame\n");
f87bc9fb 745 cmd->status = -EIO;
4849f85e 746 goto sched_wq;
c46ee386
AAJ		 747 }
748
9e2d493e 749 if (!pn533_rx_frame_is_cmd_response(dev, in_frame)) {
073a625f
JP		 750 nfc_err(&dev->interface->dev,
751 "It it not the response to the last command\n");
f87bc9fb 752 cmd->status = -EIO;
4849f85e 753 goto sched_wq;
c46ee386
AAJ		 754 }
755
4849f85e 756sched_wq:
5d50b364 757 queue_work(dev->wq, &dev->cmd_complete_work);
c46ee386
AAJ		 758}
759
760static int pn533_submit_urb_for_response(struct pn533 *dev, gfp_t flags)
761{
762 dev->in_urb->complete = pn533_recv_response;
763
764 return usb_submit_urb(dev->in_urb, flags);
765}
766
767static void pn533_recv_ack(struct urb *urb)
768{
769 struct pn533 *dev = urb->context;
f87bc9fb 770 struct pn533_cmd *cmd = dev->cmd;
63123108 771 struct pn533_std_frame *in_frame;
c46ee386
AAJ		 772 int rc;
773
f87bc9fb
WR		 774 cmd->status = urb->status;
775
c46ee386
AAJ		 776 switch (urb->status) {
777 case 0:
f8f99171 778 break; /* success */
c46ee386
AAJ		 779 case -ECONNRESET:
780 case -ENOENT:
b4834839
JP		 781 dev_dbg(&dev->interface->dev,
782 "The urb has been stopped (status %d)\n",
783 urb->status);
4849f85e 784 goto sched_wq;
f8f99171 785 case -ESHUTDOWN:
c46ee386 786 default:
073a625f
JP		 787 nfc_err(&dev->interface->dev,
788 "Urb failure (status %d)\n", urb->status);
4849f85e 789 goto sched_wq;
c46ee386
AAJ		 790 }
791
792 in_frame = dev->in_urb->transfer_buffer;
793
63123108 794 if (!pn533_std_rx_frame_is_ack(in_frame)) {
073a625f 795 nfc_err(&dev->interface->dev, "Received an invalid ack\n");
f87bc9fb 796 cmd->status = -EIO;
4849f85e 797 goto sched_wq;
c46ee386
AAJ		 798 }
799
c46ee386
AAJ		 800 rc = pn533_submit_urb_for_response(dev, GFP_ATOMIC);
801 if (rc) {
073a625f
JP		 802 nfc_err(&dev->interface->dev,
803 "usb_submit_urb failed with result %d\n", rc);
f87bc9fb 804 cmd->status = rc;
4849f85e 805 goto sched_wq;
c46ee386
AAJ		 806 }
807
808 return;
809
4849f85e 810sched_wq:
5d50b364 811 queue_work(dev->wq, &dev->cmd_complete_work);
c46ee386
AAJ		 812}
813
814static int pn533_submit_urb_for_ack(struct pn533 *dev, gfp_t flags)
815{
816 dev->in_urb->complete = pn533_recv_ack;
817
818 return usb_submit_urb(dev->in_urb, flags);
819}
820
821static int pn533_send_ack(struct pn533 *dev, gfp_t flags)
822{
63123108 823 u8 ack[PN533_STD_FRAME_ACK_SIZE] = {0x00, 0x00, 0xff, 0x00, 0xff, 0x00};
5b5a4437 824 /* spec 7.1.1.3: Preamble, SoPC (2), ACK Code (2), Postamble */
c46ee386
AAJ		 825 int rc;
826
5b5a4437
WR		 827 dev->out_urb->transfer_buffer = ack;
828 dev->out_urb->transfer_buffer_length = sizeof(ack);
c46ee386
AAJ		 829 rc = usb_submit_urb(dev->out_urb, flags);
830
831 return rc;
832}
833
e8f40531
WR		 834static int __pn533_send_frame_async(struct pn533 *dev,
835 struct sk_buff *out,
836 struct sk_buff *in,
ddf19d20 837 int in_len)
c46ee386
AAJ		 838{
839 int rc;
840
e8f40531
WR		 841 dev->out_urb->transfer_buffer = out->data;
842 dev->out_urb->transfer_buffer_length = out->len;
c46ee386 843
e8f40531
WR		 844 dev->in_urb->transfer_buffer = in->data;
845 dev->in_urb->transfer_buffer_length = in_len;
c46ee386 846
e279f84f
SO		 847 print_hex_dump_debug("PN533 TX: ", DUMP_PREFIX_NONE, 16, 1,
848 out->data, out->len, false);
99e591be 849
d94ea4f5 850 rc = usb_submit_urb(dev->out_urb, GFP_KERNEL);
c46ee386
AAJ		 851 if (rc)
852 return rc;
853
58520373
WR		 854 if (dev->protocol_type == PN533_PROTO_REQ_RESP) {
855 /* request for response for sent packet directly */
856 rc = pn533_submit_urb_for_response(dev, GFP_ATOMIC);
857 if (rc)
858 goto error;
859 } else if (dev->protocol_type == PN533_PROTO_REQ_ACK_RESP) {
860 /* request for ACK if that's the case */
861 rc = pn533_submit_urb_for_ack(dev, GFP_KERNEL);
862 if (rc)
863 goto error;
864 }
c46ee386
AAJ		 865
866 return 0;
867
868error:
869 usb_unlink_urb(dev->out_urb);
870 return rc;
871}
872
9e2d493e
WR		 873static void pn533_build_cmd_frame(struct pn533 *dev, u8 cmd_code,
874 struct sk_buff *skb)
aada17ac 875{
aada17ac
WR		 876 /* payload is already there, just update datalen */
877 int payload_len = skb->len;
9e2d493e 878 struct pn533_frame_ops *ops = dev->ops;
aada17ac 879
aada17ac 880
9e2d493e
WR		 881 skb_push(skb, ops->tx_header_len);
882 skb_put(skb, ops->tx_tail_len);
aada17ac 883
9e2d493e
WR		 884 ops->tx_frame_init(skb->data, cmd_code);
885 ops->tx_update_payload_len(skb->data, payload_len);
886 ops->tx_frame_finish(skb->data);
aada17ac
WR		 887}
888
ddf19d20 889static int pn533_send_async_complete(struct pn533 *dev)
aada17ac 890{
ddf19d20 891 struct pn533_cmd *cmd = dev->cmd;
f87bc9fb 892 int status = cmd->status;
aada17ac 893
4231604b
WR		 894 struct sk_buff *req = cmd->req;
895 struct sk_buff *resp = cmd->resp;
aada17ac 896
aada17ac
WR		 897 int rc;
898
899 dev_kfree_skb(req);
900
0c33d262 901 if (status < 0) {
4231604b
WR		 902 rc = cmd->complete_cb(dev, cmd->complete_cb_context,
903 ERR_PTR(status));
aada17ac 904 dev_kfree_skb(resp);
2c206fb7 905 goto done;
aada17ac
WR		 906 }
907
9e2d493e
WR		 908 skb_put(resp, dev->ops->rx_frame_size(resp->data));
909 skb_pull(resp, dev->ops->rx_header_len);
910 skb_trim(resp, resp->len - dev->ops->rx_tail_len);
aada17ac 911
4231604b 912 rc = cmd->complete_cb(dev, cmd->complete_cb_context, resp);
aada17ac 913
2c206fb7 914done:
4231604b 915 kfree(cmd);
2c206fb7 916 dev->cmd = NULL;
aada17ac
WR		 917 return rc;
918}
919
920static int __pn533_send_async(struct pn533 *dev, u8 cmd_code,
921 struct sk_buff *req, struct sk_buff *resp,
922 int resp_len,
923 pn533_send_async_complete_t complete_cb,
924 void *complete_cb_context)
925{
926 struct pn533_cmd *cmd;
aada17ac
WR		 927 int rc = 0;
928
b4834839 929 dev_dbg(&dev->interface->dev, "Sending command 0x%x\n", cmd_code);
aada17ac 930
4231604b
WR		 931 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
932 if (!cmd)
aada17ac
WR		 933 return -ENOMEM;
934
4b2a9532 935 cmd->code = cmd_code;
4231604b
WR		 936 cmd->req = req;
937 cmd->resp = resp;
938 cmd->resp_len = resp_len;
939 cmd->complete_cb = complete_cb;
940 cmd->complete_cb_context = complete_cb_context;
aada17ac 941
9e2d493e 942 pn533_build_cmd_frame(dev, cmd_code, req);
aada17ac
WR		 943
944 mutex_lock(&dev->cmd_lock);
945
946 if (!dev->cmd_pending) {
ddf19d20 947 rc = __pn533_send_frame_async(dev, req, resp, resp_len);
aada17ac
WR		 948 if (rc)
949 goto error;
950
951 dev->cmd_pending = 1;
2c206fb7 952 dev->cmd = cmd;
aada17ac
WR		 953 goto unlock;
954 }
955
b4834839
JP		 956 dev_dbg(&dev->interface->dev, "%s Queueing command 0x%x\n",
957 __func__, cmd_code);
aada17ac 958
aada17ac 959 INIT_LIST_HEAD(&cmd->queue);
aada17ac
WR		 960 list_add_tail(&cmd->queue, &dev->cmd_queue);
961
962 goto unlock;
963
964error:
4231604b 965 kfree(cmd);
aada17ac
WR		 966unlock:
967 mutex_unlock(&dev->cmd_lock);
968 return rc;
15461aeb
WR		 969}
970
971static int pn533_send_data_async(struct pn533 *dev, u8 cmd_code,
972 struct sk_buff *req,
973 pn533_send_async_complete_t complete_cb,
974 void *complete_cb_context)
975{
976 struct sk_buff *resp;
977 int rc;
9e2d493e
WR		 978 int resp_len = dev->ops->rx_header_len +
979 dev->ops->max_payload_len +
980 dev->ops->rx_tail_len;
15461aeb 981
15461aeb
WR		 982 resp = nfc_alloc_recv_skb(resp_len, GFP_KERNEL);
983 if (!resp)
984 return -ENOMEM;
985
986 rc = __pn533_send_async(dev, cmd_code, req, resp, resp_len, complete_cb,
987 complete_cb_context);
988 if (rc)
989 dev_kfree_skb(resp);
990
991 return rc;
aada17ac
WR		 992}
993
994static int pn533_send_cmd_async(struct pn533 *dev, u8 cmd_code,
995 struct sk_buff *req,
996 pn533_send_async_complete_t complete_cb,
997 void *complete_cb_context)
998{
999 struct sk_buff *resp;
1000 int rc;
9e2d493e
WR		 1001 int resp_len = dev->ops->rx_header_len +
1002 dev->ops->max_payload_len +
1003 dev->ops->rx_tail_len;
aada17ac 1004
9e2d493e 1005 resp = alloc_skb(resp_len, GFP_KERNEL);
aada17ac
WR		 1006 if (!resp)
1007 return -ENOMEM;
1008
9e2d493e
WR		 1009 rc = __pn533_send_async(dev, cmd_code, req, resp, resp_len, complete_cb,
1010 complete_cb_context);
aada17ac
WR		 1011 if (rc)
1012 dev_kfree_skb(resp);
1013
1014 return rc;
1015}
1016
b1e666f5
WR		 1017/*
1018 * pn533_send_cmd_direct_async
1019 *
1020 * The function sends a piority cmd directly to the chip omiting the cmd
1021 * queue. It's intended to be used by chaining mechanism of received responses
1022 * where the host has to request every single chunk of data before scheduling
1023 * next cmd from the queue.
1024 */
1025static int pn533_send_cmd_direct_async(struct pn533 *dev, u8 cmd_code,
1026 struct sk_buff *req,
1027 pn533_send_async_complete_t complete_cb,
1028 void *complete_cb_context)
1029{
b1e666f5 1030 struct sk_buff *resp;
4231604b 1031 struct pn533_cmd *cmd;
b1e666f5 1032 int rc;
9e2d493e
WR		 1033 int resp_len = dev->ops->rx_header_len +
1034 dev->ops->max_payload_len +
1035 dev->ops->rx_tail_len;
b1e666f5 1036
b1e666f5
WR		 1037 resp = alloc_skb(resp_len, GFP_KERNEL);
1038 if (!resp)
1039 return -ENOMEM;
1040
4231604b
WR		 1041 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1042 if (!cmd) {
b1e666f5
WR		 1043 dev_kfree_skb(resp);
1044 return -ENOMEM;
1045 }
1046
4b2a9532 1047 cmd->code = cmd_code;
4231604b
WR		 1048 cmd->req = req;
1049 cmd->resp = resp;
1050 cmd->resp_len = resp_len;
1051 cmd->complete_cb = complete_cb;
1052 cmd->complete_cb_context = complete_cb_context;
b1e666f5 1053
9e2d493e 1054 pn533_build_cmd_frame(dev, cmd_code, req);
b1e666f5 1055
ddf19d20 1056 rc = __pn533_send_frame_async(dev, req, resp, resp_len);
b1e666f5
WR		 1057 if (rc < 0) {
1058 dev_kfree_skb(resp);
4231604b 1059 kfree(cmd);
2c206fb7
WR		 1060 } else {
1061 dev->cmd = cmd;
b1e666f5
WR		 1062 }
1063
1064 return rc;
1065}
1066
c79490e1
WR		 1067static void pn533_wq_cmd_complete(struct work_struct *work)
1068{
1069 struct pn533 *dev = container_of(work, struct pn533, cmd_complete_work);
1070 int rc;
1071
1072 rc = pn533_send_async_complete(dev);
1073 if (rc != -EINPROGRESS)
1074 queue_work(dev->wq, &dev->cmd_work);
1075}
1076
5d50b364
SO		 1077static void pn533_wq_cmd(struct work_struct *work)
1078{
1079 struct pn533 *dev = container_of(work, struct pn533, cmd_work);
1080 struct pn533_cmd *cmd;
0ce1fbdd 1081 int rc;
5d50b364
SO		 1082
1083 mutex_lock(&dev->cmd_lock);
1084
1085 if (list_empty(&dev->cmd_queue)) {
1086 dev->cmd_pending = 0;
1087 mutex_unlock(&dev->cmd_lock);
1088 return;
1089 }
1090
1091 cmd = list_first_entry(&dev->cmd_queue, struct pn533_cmd, queue);
1092
60ad07ab
SJ		 1093 list_del(&cmd->queue);
1094
5d50b364
SO		 1095 mutex_unlock(&dev->cmd_lock);
1096
ddf19d20 1097 rc = __pn533_send_frame_async(dev, cmd->req, cmd->resp, cmd->resp_len);
0ce1fbdd
WR		 1098 if (rc < 0) {
1099 dev_kfree_skb(cmd->req);
1100 dev_kfree_skb(cmd->resp);
4231604b 1101 kfree(cmd);
2c206fb7 1102 return;
0ce1fbdd 1103 }
2c206fb7
WR		 1104
1105 dev->cmd = cmd;
5d50b364
SO		 1106}
1107
c46ee386 1108struct pn533_sync_cmd_response {
94c5c156 1109 struct sk_buff *resp;
c46ee386
AAJ		 1110 struct completion done;
1111};
1112
94c5c156
WR		 1113static int pn533_send_sync_complete(struct pn533 *dev, void *_arg,
1114 struct sk_buff *resp)
1115{
1116 struct pn533_sync_cmd_response *arg = _arg;
1117
94c5c156
WR		 1118 arg->resp = resp;
1119 complete(&arg->done);
1120
1121 return 0;
1122}
1123
1124/* pn533_send_cmd_sync
1125 *
1126 * Please note the req parameter is freed inside the function to
1127 * limit a number of return value interpretations by the caller.
1128 *
1129 * 1. negative in case of error during TX path -> req should be freed
1130 *
1131 * 2. negative in case of error during RX path -> req should not be freed
1132 * as it's been already freed at the begining of RX path by
1133 * async_complete_cb.
1134 *
1135 * 3. valid pointer in case of succesfult RX path
1136 *
1137 * A caller has to check a return value with IS_ERR macro. If the test pass,
1138 * the returned pointer is valid.
1139 *
1140 * */
1141static struct sk_buff *pn533_send_cmd_sync(struct pn533 *dev, u8 cmd_code,
1142 struct sk_buff *req)
1143{
1144 int rc;
1145 struct pn533_sync_cmd_response arg;
1146
94c5c156
WR		 1147 init_completion(&arg.done);
1148
1149 rc = pn533_send_cmd_async(dev, cmd_code, req,
1150 pn533_send_sync_complete, &arg);
1151 if (rc) {
1152 dev_kfree_skb(req);
1153 return ERR_PTR(rc);
1154 }
1155
1156 wait_for_completion(&arg.done);
1157
1158 return arg.resp;
1159}
1160
c46ee386
AAJ		 1161static void pn533_send_complete(struct urb *urb)
1162{
1163 struct pn533 *dev = urb->context;
1164
c46ee386
AAJ		 1165 switch (urb->status) {
1166 case 0:
f8f99171 1167 break; /* success */
c46ee386
AAJ		 1168 case -ECONNRESET:
1169 case -ENOENT:
b4834839
JP		 1170 dev_dbg(&dev->interface->dev,
1171 "The urb has been stopped (status %d)\n",
1172 urb->status);
c46ee386 1173 break;
f8f99171 1174 case -ESHUTDOWN:
c46ee386 1175 default:
073a625f
JP		 1176 nfc_err(&dev->interface->dev, "Urb failure (status %d)\n",
1177 urb->status);
c46ee386
AAJ		 1178 }
1179}
1180
10cff29a
WR		 1181static void pn533_abort_cmd(struct pn533 *dev, gfp_t flags)
1182{
1183 /* ACR122U does not support any command which aborts last
1184 * issued command i.e. as ACK for standard PN533. Additionally,
1185 * it behaves stange, sending broken or incorrect responses,
1186 * when we cancel urb before the chip will send response.
1187 */
1188 if (dev->device_type == PN533_DEVICE_ACR122U)
1189 return;
1190
1191 /* An ack will cancel the last issued command */
1192 pn533_send_ack(dev, flags);
1193
1194 /* cancel the urb request */
1195 usb_kill_urb(dev->in_urb);
1196}
1197
9e2d493e 1198static struct sk_buff *pn533_alloc_skb(struct pn533 *dev, unsigned int size)
d22b2db6
WR		 1199{
1200 struct sk_buff *skb;
1201
9e2d493e 1202 skb = alloc_skb(dev->ops->tx_header_len +
d22b2db6 1203 size +
9e2d493e 1204 dev->ops->tx_tail_len, GFP_KERNEL);
d22b2db6
WR		 1205
1206 if (skb)
9e2d493e 1207 skb_reserve(skb, dev->ops->tx_header_len);
d22b2db6
WR		 1208
1209 return skb;
1210}
1211
c46ee386
AAJ		 1212struct pn533_target_type_a {
1213 __be16 sens_res;
1214 u8 sel_res;
1215 u8 nfcid_len;
1216 u8 nfcid_data[];
1217} __packed;
1218
1219
1220#define PN533_TYPE_A_SENS_RES_NFCID1(x) ((u8)((be16_to_cpu(x) & 0x00C0) >> 6))
1221#define PN533_TYPE_A_SENS_RES_SSD(x) ((u8)((be16_to_cpu(x) & 0x001F) >> 0))
1222#define PN533_TYPE_A_SENS_RES_PLATCONF(x) ((u8)((be16_to_cpu(x) & 0x0F00) >> 8))
1223
1224#define PN533_TYPE_A_SENS_RES_SSD_JEWEL 0x00
1225#define PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL 0x0C
1226
1227#define PN533_TYPE_A_SEL_PROT(x) (((x) & 0x60) >> 5)
1228#define PN533_TYPE_A_SEL_CASCADE(x) (((x) & 0x04) >> 2)
1229
1230#define PN533_TYPE_A_SEL_PROT_MIFARE 0
1231#define PN533_TYPE_A_SEL_PROT_ISO14443 1
1232#define PN533_TYPE_A_SEL_PROT_DEP 2
1233#define PN533_TYPE_A_SEL_PROT_ISO14443_DEP 3
1234
1235static bool pn533_target_type_a_is_valid(struct pn533_target_type_a *type_a,
1236 int target_data_len)
1237{
1238 u8 ssd;
1239 u8 platconf;
1240
1241 if (target_data_len < sizeof(struct pn533_target_type_a))
1242 return false;
1243
1244 /* The lenght check of nfcid[] and ats[] are not being performed because
1245 the values are not being used */
1246
1247 /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
1248 ssd = PN533_TYPE_A_SENS_RES_SSD(type_a->sens_res);
1249 platconf = PN533_TYPE_A_SENS_RES_PLATCONF(type_a->sens_res);
1250
1251 if ((ssd == PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
5d467742
WR		 1252 platconf != PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL) ||
1253 (ssd != PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
1254 platconf == PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL))
c46ee386
AAJ		 1255 return false;
1256
1257 /* Requirements 4.8.2.1, 4.8.2.3, 4.8.2.5 and 4.8.2.7 from NFC Forum */
1258 if (PN533_TYPE_A_SEL_CASCADE(type_a->sel_res) != 0)
1259 return false;
1260
1261 return true;
1262}
1263
1264static int pn533_target_found_type_a(struct nfc_target *nfc_tgt, u8 *tgt_data,
1265 int tgt_data_len)
1266{
1267 struct pn533_target_type_a *tgt_type_a;
1268
37cf4fc6 1269 tgt_type_a = (struct pn533_target_type_a *)tgt_data;
c46ee386
AAJ		 1270
1271 if (!pn533_target_type_a_is_valid(tgt_type_a, tgt_data_len))
1272 return -EPROTO;
1273
1274 switch (PN533_TYPE_A_SEL_PROT(tgt_type_a->sel_res)) {
1275 case PN533_TYPE_A_SEL_PROT_MIFARE:
1276 nfc_tgt->supported_protocols = NFC_PROTO_MIFARE_MASK;
1277 break;
1278 case PN533_TYPE_A_SEL_PROT_ISO14443:
1279 nfc_tgt->supported_protocols = NFC_PROTO_ISO14443_MASK;
1280 break;
1281 case PN533_TYPE_A_SEL_PROT_DEP:
1282 nfc_tgt->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
1283 break;
1284 case PN533_TYPE_A_SEL_PROT_ISO14443_DEP:
1285 nfc_tgt->supported_protocols = NFC_PROTO_ISO14443_MASK |
1286 NFC_PROTO_NFC_DEP_MASK;
1287 break;
1288 }
1289
1290 nfc_tgt->sens_res = be16_to_cpu(tgt_type_a->sens_res);
1291 nfc_tgt->sel_res = tgt_type_a->sel_res;
c3b1e1e8
SO		 1292 nfc_tgt->nfcid1_len = tgt_type_a->nfcid_len;
1293 memcpy(nfc_tgt->nfcid1, tgt_type_a->nfcid_data, nfc_tgt->nfcid1_len);
c46ee386
AAJ		 1294
1295 return 0;
1296}
1297
1298struct pn533_target_felica {
1299 u8 pol_res;
1300 u8 opcode;
322bce95 1301 u8 nfcid2[NFC_NFCID2_MAXSIZE];
c46ee386
AAJ		 1302 u8 pad[8];
1303 /* optional */
1304 u8 syst_code[];
1305} __packed;
1306
1307#define PN533_FELICA_SENSF_NFCID2_DEP_B1 0x01
1308#define PN533_FELICA_SENSF_NFCID2_DEP_B2 0xFE
1309
1310static bool pn533_target_felica_is_valid(struct pn533_target_felica *felica,
1311 int target_data_len)
1312{
1313 if (target_data_len < sizeof(struct pn533_target_felica))
1314 return false;
1315
1316 if (felica->opcode != PN533_FELICA_OPC_SENSF_RES)
1317 return false;
1318
1319 return true;
1320}
1321
1322static int pn533_target_found_felica(struct nfc_target *nfc_tgt, u8 *tgt_data,
1323 int tgt_data_len)
1324{
1325 struct pn533_target_felica *tgt_felica;
1326
37cf4fc6 1327 tgt_felica = (struct pn533_target_felica *)tgt_data;
c46ee386
AAJ		 1328
1329 if (!pn533_target_felica_is_valid(tgt_felica, tgt_data_len))
1330 return -EPROTO;
1331
5d467742
WR		 1332 if ((tgt_felica->nfcid2[0] == PN533_FELICA_SENSF_NFCID2_DEP_B1) &&
1333 (tgt_felica->nfcid2[1] == PN533_FELICA_SENSF_NFCID2_DEP_B2))
c46ee386
AAJ		 1334 nfc_tgt->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
1335 else
1336 nfc_tgt->supported_protocols = NFC_PROTO_FELICA_MASK;
1337
7975754f
SO		 1338 memcpy(nfc_tgt->sensf_res, &tgt_felica->opcode, 9);
1339 nfc_tgt->sensf_res_len = 9;
1340
322bce95
SO		 1341 memcpy(nfc_tgt->nfcid2, tgt_felica->nfcid2, NFC_NFCID2_MAXSIZE);
1342 nfc_tgt->nfcid2_len = NFC_NFCID2_MAXSIZE;
1343
c46ee386
AAJ		 1344 return 0;
1345}
1346
1347struct pn533_target_jewel {
1348 __be16 sens_res;
1349 u8 jewelid[4];
1350} __packed;
1351
1352static bool pn533_target_jewel_is_valid(struct pn533_target_jewel *jewel,
1353 int target_data_len)
1354{
1355 u8 ssd;
1356 u8 platconf;
1357
1358 if (target_data_len < sizeof(struct pn533_target_jewel))
1359 return false;
1360
1361 /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
1362 ssd = PN533_TYPE_A_SENS_RES_SSD(jewel->sens_res);
1363 platconf = PN533_TYPE_A_SENS_RES_PLATCONF(jewel->sens_res);
1364
1365 if ((ssd == PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
5d467742
WR		 1366 platconf != PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL) ||
1367 (ssd != PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
1368 platconf == PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL))
c46ee386
AAJ		 1369 return false;
1370
1371 return true;
1372}
1373
1374static int pn533_target_found_jewel(struct nfc_target *nfc_tgt, u8 *tgt_data,
1375 int tgt_data_len)
1376{
1377 struct pn533_target_jewel *tgt_jewel;
1378
37cf4fc6 1379 tgt_jewel = (struct pn533_target_jewel *)tgt_data;
c46ee386
AAJ		 1380
1381 if (!pn533_target_jewel_is_valid(tgt_jewel, tgt_data_len))
1382 return -EPROTO;
1383
1384 nfc_tgt->supported_protocols = NFC_PROTO_JEWEL_MASK;
1385 nfc_tgt->sens_res = be16_to_cpu(tgt_jewel->sens_res);
d8dc1072
SO		 1386 nfc_tgt->nfcid1_len = 4;
1387 memcpy(nfc_tgt->nfcid1, tgt_jewel->jewelid, nfc_tgt->nfcid1_len);
c46ee386
AAJ		 1388
1389 return 0;
1390}
1391
1392struct pn533_type_b_prot_info {
1393 u8 bitrate;
1394 u8 fsci_type;
1395 u8 fwi_adc_fo;
1396} __packed;
1397
1398#define PN533_TYPE_B_PROT_FCSI(x) (((x) & 0xF0) >> 4)
1399#define PN533_TYPE_B_PROT_TYPE(x) (((x) & 0x0F) >> 0)
1400#define PN533_TYPE_B_PROT_TYPE_RFU_MASK 0x8
1401
1402struct pn533_type_b_sens_res {
1403 u8 opcode;
1404 u8 nfcid[4];
1405 u8 appdata[4];
1406 struct pn533_type_b_prot_info prot_info;
1407} __packed;
1408
1409#define PN533_TYPE_B_OPC_SENSB_RES 0x50
1410
1411struct pn533_target_type_b {
1412 struct pn533_type_b_sens_res sensb_res;
1413 u8 attrib_res_len;
1414 u8 attrib_res[];
1415} __packed;
1416
1417static bool pn533_target_type_b_is_valid(struct pn533_target_type_b *type_b,
1418 int target_data_len)
1419{
1420 if (target_data_len < sizeof(struct pn533_target_type_b))
1421 return false;
1422
1423 if (type_b->sensb_res.opcode != PN533_TYPE_B_OPC_SENSB_RES)
1424 return false;
1425
1426 if (PN533_TYPE_B_PROT_TYPE(type_b->sensb_res.prot_info.fsci_type) &
1427 PN533_TYPE_B_PROT_TYPE_RFU_MASK)
1428 return false;
1429
1430 return true;
1431}
1432
1433static int pn533_target_found_type_b(struct nfc_target *nfc_tgt, u8 *tgt_data,
1434 int tgt_data_len)
1435{
1436 struct pn533_target_type_b *tgt_type_b;
1437
37cf4fc6 1438 tgt_type_b = (struct pn533_target_type_b *)tgt_data;
c46ee386
AAJ		 1439
1440 if (!pn533_target_type_b_is_valid(tgt_type_b, tgt_data_len))
1441 return -EPROTO;
1442
01d719a2 1443 nfc_tgt->supported_protocols = NFC_PROTO_ISO14443_B_MASK;
c46ee386
AAJ		 1444
1445 return 0;
1446}
1447
b5193e5d
WR		 1448static int pn533_target_found(struct pn533 *dev, u8 tg, u8 *tgdata,
1449 int tgdata_len)
c46ee386 1450{
c46ee386
AAJ		 1451 struct nfc_target nfc_tgt;
1452 int rc;
1453
17936b43 1454 dev_dbg(&dev->interface->dev, "%s: modulation=%d\n",
b4834839 1455 __func__, dev->poll_mod_curr);
c46ee386 1456
b5193e5d 1457 if (tg != 1)
c46ee386
AAJ		 1458 return -EPROTO;
1459
98b3ac1b
SO		 1460 memset(&nfc_tgt, 0, sizeof(struct nfc_target));
1461
c46ee386
AAJ		 1462 switch (dev->poll_mod_curr) {
1463 case PN533_POLL_MOD_106KBPS_A:
b5193e5d 1464 rc = pn533_target_found_type_a(&nfc_tgt, tgdata, tgdata_len);
c46ee386
AAJ		 1465 break;
1466 case PN533_POLL_MOD_212KBPS_FELICA:
1467 case PN533_POLL_MOD_424KBPS_FELICA:
b5193e5d 1468 rc = pn533_target_found_felica(&nfc_tgt, tgdata, tgdata_len);
c46ee386
AAJ		 1469 break;
1470 case PN533_POLL_MOD_106KBPS_JEWEL:
b5193e5d 1471 rc = pn533_target_found_jewel(&nfc_tgt, tgdata, tgdata_len);
c46ee386
AAJ		 1472 break;
1473 case PN533_POLL_MOD_847KBPS_B:
b5193e5d 1474 rc = pn533_target_found_type_b(&nfc_tgt, tgdata, tgdata_len);
c46ee386
AAJ		 1475 break;
1476 default:
073a625f
JP		 1477 nfc_err(&dev->interface->dev,
1478 "Unknown current poll modulation\n");
c46ee386
AAJ		 1479 return -EPROTO;
1480 }
1481
1482 if (rc)
1483 return rc;
1484
1485 if (!(nfc_tgt.supported_protocols & dev->poll_protocols)) {
b4834839
JP		 1486 dev_dbg(&dev->interface->dev,
1487 "The Tg found doesn't have the desired protocol\n");
c46ee386
AAJ		 1488 return -EAGAIN;
1489 }
1490
b4834839
JP		 1491 dev_dbg(&dev->interface->dev,
1492 "Target found - supported protocols: 0x%x\n",
1493 nfc_tgt.supported_protocols);
c46ee386
AAJ		 1494
1495 dev->tgt_available_prots = nfc_tgt.supported_protocols;
1496
1497 nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);
1498
1499 return 0;
1500}
1501
6fbbdc16
SO		 1502static inline void pn533_poll_next_mod(struct pn533 *dev)
1503{
1504 dev->poll_mod_curr = (dev->poll_mod_curr + 1) % dev->poll_mod_count;
1505}
1506
c46ee386
AAJ		 1507static void pn533_poll_reset_mod_list(struct pn533 *dev)
1508{
1509 dev->poll_mod_count = 0;
1510}
1511
1512static void pn533_poll_add_mod(struct pn533 *dev, u8 mod_index)
1513{
1514 dev->poll_mod_active[dev->poll_mod_count] =
37cf4fc6 1515 (struct pn533_poll_modulations *)&poll_mod[mod_index];
c46ee386
AAJ		 1516 dev->poll_mod_count++;
1517}
1518
6fbbdc16
SO		 1519static void pn533_poll_create_mod_list(struct pn533 *dev,
1520 u32 im_protocols, u32 tm_protocols)
c46ee386
AAJ		 1521{
1522 pn533_poll_reset_mod_list(dev);
1523
b08e8603
WR		 1524 if ((im_protocols & NFC_PROTO_MIFARE_MASK) ||
1525 (im_protocols & NFC_PROTO_ISO14443_MASK) ||
1526 (im_protocols & NFC_PROTO_NFC_DEP_MASK))
c46ee386
AAJ		 1527 pn533_poll_add_mod(dev, PN533_POLL_MOD_106KBPS_A);
1528
b08e8603
WR		 1529 if (im_protocols & NFC_PROTO_FELICA_MASK ||
1530 im_protocols & NFC_PROTO_NFC_DEP_MASK) {
c46ee386
AAJ		 1531 pn533_poll_add_mod(dev, PN533_POLL_MOD_212KBPS_FELICA);
1532 pn533_poll_add_mod(dev, PN533_POLL_MOD_424KBPS_FELICA);
1533 }
1534
6fbbdc16 1535 if (im_protocols & NFC_PROTO_JEWEL_MASK)
c46ee386
AAJ		 1536 pn533_poll_add_mod(dev, PN533_POLL_MOD_106KBPS_JEWEL);
1537
01d719a2 1538 if (im_protocols & NFC_PROTO_ISO14443_B_MASK)
c46ee386 1539 pn533_poll_add_mod(dev, PN533_POLL_MOD_847KBPS_B);
c46ee386 1540
6fbbdc16
SO		 1541 if (tm_protocols)
1542 pn533_poll_add_mod(dev, PN533_LISTEN_MOD);
c46ee386
AAJ		 1543}
1544
b5193e5d 1545static int pn533_start_poll_complete(struct pn533 *dev, struct sk_buff *resp)
c46ee386 1546{
b5193e5d
WR		 1547 u8 nbtg, tg, *tgdata;
1548 int rc, tgdata_len;
c46ee386 1549
673088fb
SO		 1550 /* Toggle the DEP polling */
1551 dev->poll_dep = 1;
1552
b5193e5d
WR		 1553 nbtg = resp->data[0];
1554 tg = resp->data[1];
1555 tgdata = &resp->data[2];
1556 tgdata_len = resp->len - 2; /* nbtg + tg */
1557
1558 if (nbtg) {
1559 rc = pn533_target_found(dev, tg, tgdata, tgdata_len);
c46ee386
AAJ		 1560
1561 /* We must stop the poll after a valid target found */
6fbbdc16
SO		 1562 if (rc == 0) {
1563 pn533_poll_reset_mod_list(dev);
1564 return 0;
1565 }
c46ee386
AAJ		 1566 }
1567
6fbbdc16 1568 return -EAGAIN;
c46ee386
AAJ		 1569}
1570
9e2d493e 1571static struct sk_buff *pn533_alloc_poll_tg_frame(struct pn533 *dev)
ad3823ce 1572{
b5193e5d
WR		 1573 struct sk_buff *skb;
1574 u8 *felica, *nfcid3, *gb;
1575
9e2d493e
WR		 1576 u8 *gbytes = dev->gb;
1577 size_t gbytes_len = dev->gb_len;
1578
51d9e803
SO		 1579 u8 felica_params[18] = {0x1, 0xfe, /* DEP */
1580 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, /* random */
1581 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
1582 0xff, 0xff}; /* System code */
b5193e5d 1583
51d9e803
SO		 1584 u8 mifare_params[6] = {0x1, 0x1, /* SENS_RES */
1585 0x0, 0x0, 0x0,
1586 0x40}; /* SEL_RES for DEP */
ad3823ce 1587
b5193e5d
WR		 1588 unsigned int skb_len = 36 + /* mode (1), mifare (6),
1589 felica (18), nfcid3 (10), gb_len (1) */
1590 gbytes_len +
1591 1; /* len Tk*/
ad3823ce 1592
9e2d493e 1593 skb = pn533_alloc_skb(dev, skb_len);
b5193e5d
WR		 1594 if (!skb)
1595 return NULL;
ad3823ce
SO		 1596
1597 /* DEP support only */
52f2eaee 1598 *skb_put(skb, 1) = PN533_INIT_TARGET_DEP;
b5193e5d
WR		 1599
1600 /* MIFARE params */
1601 memcpy(skb_put(skb, 6), mifare_params, 6);
51d9e803
SO		 1602
1603 /* Felica params */
b5193e5d
WR		 1604 felica = skb_put(skb, 18);
1605 memcpy(felica, felica_params, 18);
1606 get_random_bytes(felica + 2, 6);
51d9e803
SO		 1607
1608 /* NFCID3 */
b5193e5d
WR		 1609 nfcid3 = skb_put(skb, 10);
1610 memset(nfcid3, 0, 10);
1611 memcpy(nfcid3, felica, 8);
51d9e803
SO		 1612
1613 /* General bytes */
b5193e5d 1614 *skb_put(skb, 1) = gbytes_len;
51d9e803 1615
b5193e5d
WR		 1616 gb = skb_put(skb, gbytes_len);
1617 memcpy(gb, gbytes, gbytes_len);
ad3823ce 1618
b5193e5d
WR		 1619 /* Len Tk */
1620 *skb_put(skb, 1) = 0;
51d9e803 1621
b5193e5d 1622 return skb;
ad3823ce
SO		 1623}
1624
b1bb290a 1625#define PN533_CMD_DATAEXCH_HEAD_LEN 1
103b34cf
SO		 1626#define PN533_CMD_DATAEXCH_DATA_MAXLEN 262
1627static int pn533_tm_get_data_complete(struct pn533 *dev, void *arg,
e4878823 1628 struct sk_buff *resp)
103b34cf 1629{
e4878823 1630 u8 status;
103b34cf 1631
b4834839 1632 dev_dbg(&dev->interface->dev, "%s\n", __func__);
103b34cf 1633
e4878823
WR		 1634 if (IS_ERR(resp))
1635 return PTR_ERR(resp);
103b34cf 1636
e4878823
WR		 1637 status = resp->data[0];
1638 skb_pull(resp, sizeof(status));
103b34cf 1639
e4878823 1640 if (status != 0) {
103b34cf 1641 nfc_tm_deactivated(dev->nfc_dev);
51ad304c 1642 dev->tgt_mode = 0;
e4878823 1643 dev_kfree_skb(resp);
103b34cf
SO		 1644 return 0;
1645 }
1646
e4878823 1647 return nfc_tm_data_received(dev->nfc_dev, resp);
103b34cf
SO		 1648}
1649
1650static void pn533_wq_tg_get_data(struct work_struct *work)
1651{
1652 struct pn533 *dev = container_of(work, struct pn533, tg_work);
e4878823
WR		 1653 struct sk_buff *skb;
1654 int rc;
103b34cf 1655
b4834839 1656 dev_dbg(&dev->interface->dev, "%s\n", __func__);
103b34cf 1657
9e2d493e 1658 skb = pn533_alloc_skb(dev, 0);
e4878823 1659 if (!skb)
103b34cf
SO		 1660 return;
1661
e4878823
WR		 1662 rc = pn533_send_data_async(dev, PN533_CMD_TG_GET_DATA, skb,
1663 pn533_tm_get_data_complete, NULL);
103b34cf 1664
e4878823
WR		 1665 if (rc < 0)
1666 dev_kfree_skb(skb);
103b34cf
SO		 1667
1668 return;
1669}
1670
fc40a8c1 1671#define ATR_REQ_GB_OFFSET 17
b5193e5d 1672static int pn533_init_target_complete(struct pn533 *dev, struct sk_buff *resp)
fe7c5800 1673{
b5193e5d 1674 u8 mode, *cmd, comm_mode = NFC_COMM_PASSIVE, *gb;
fc40a8c1 1675 size_t gb_len;
103b34cf 1676 int rc;
ad3823ce 1677
b4834839 1678 dev_dbg(&dev->interface->dev, "%s\n", __func__);
ad3823ce 1679
b5193e5d 1680 if (resp->len < ATR_REQ_GB_OFFSET + 1)
fc40a8c1
SO		 1681 return -EINVAL;
1682
b5193e5d
WR		 1683 mode = resp->data[0];
1684 cmd = &resp->data[1];
ad3823ce 1685
b4834839
JP		 1686 dev_dbg(&dev->interface->dev, "Target mode 0x%x len %d\n",
1687 mode, resp->len);
ad3823ce 1688
b5193e5d
WR		 1689 if ((mode & PN533_INIT_TARGET_RESP_FRAME_MASK) ==
1690 PN533_INIT_TARGET_RESP_ACTIVE)
fc40a8c1
SO		 1691 comm_mode = NFC_COMM_ACTIVE;
1692
b5193e5d 1693 if ((mode & PN533_INIT_TARGET_RESP_DEP) == 0) /* Only DEP supported */
fc40a8c1
SO		 1694 return -EOPNOTSUPP;
1695
b5193e5d
WR		 1696 gb = cmd + ATR_REQ_GB_OFFSET;
1697 gb_len = resp->len - (ATR_REQ_GB_OFFSET + 1);
fc40a8c1 1698
103b34cf
SO		 1699 rc = nfc_tm_activated(dev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1700 comm_mode, gb, gb_len);
1701 if (rc < 0) {
073a625f
JP		 1702 nfc_err(&dev->interface->dev,
1703 "Error when signaling target activation\n");
103b34cf
SO		 1704 return rc;
1705 }
1706
51ad304c 1707 dev->tgt_mode = 1;
103b34cf
SO		 1708 queue_work(dev->wq, &dev->tg_work);
1709
1710 return 0;
fe7c5800
SO		 1711}
1712
6fbbdc16 1713static void pn533_listen_mode_timer(unsigned long data)
ad3823ce 1714{
37cf4fc6 1715 struct pn533 *dev = (struct pn533 *)data;
6fbbdc16 1716
b4834839 1717 dev_dbg(&dev->interface->dev, "Listen mode timeout\n");
6fbbdc16 1718
6fbbdc16
SO		 1719 dev->cancel_listen = 1;
1720
6fbbdc16
SO		 1721 pn533_poll_next_mod(dev);
1722
46f793b0
SO		 1723 queue_delayed_work(dev->wq, &dev->poll_work,
1724 msecs_to_jiffies(PN533_POLL_INTERVAL));
6fbbdc16
SO		 1725}
1726
17e9d9d4
SO		 1727static int pn533_rf_complete(struct pn533 *dev, void *arg,
1728 struct sk_buff *resp)
1729{
1730 int rc = 0;
1731
b4834839 1732 dev_dbg(&dev->interface->dev, "%s\n", __func__);
17e9d9d4
SO		 1733
1734 if (IS_ERR(resp)) {
1735 rc = PTR_ERR(resp);
1736
073a625f 1737 nfc_err(&dev->interface->dev, "RF setting error %d", rc);
17e9d9d4
SO		 1738
1739 return rc;
1740 }
1741
46f793b0
SO		 1742 queue_delayed_work(dev->wq, &dev->poll_work,
1743 msecs_to_jiffies(PN533_POLL_INTERVAL));
17e9d9d4
SO		 1744
1745 dev_kfree_skb(resp);
1746 return rc;
1747}
1748
1749static void pn533_wq_rf(struct work_struct *work)
1750{
1751 struct pn533 *dev = container_of(work, struct pn533, rf_work);
1752 struct sk_buff *skb;
1753 int rc;
1754
b4834839 1755 dev_dbg(&dev->interface->dev, "%s\n", __func__);
17e9d9d4
SO		 1756
1757 skb = pn533_alloc_skb(dev, 2);
1758 if (!skb)
1759 return;
1760
1761 *skb_put(skb, 1) = PN533_CFGITEM_RF_FIELD;
3a8eab39 1762 *skb_put(skb, 1) = PN533_CFGITEM_RF_FIELD_AUTO_RFCA;
17e9d9d4
SO		 1763
1764 rc = pn533_send_cmd_async(dev, PN533_CMD_RF_CONFIGURATION, skb,
1765 pn533_rf_complete, NULL);
1766 if (rc < 0) {
1767 dev_kfree_skb(skb);
073a625f 1768 nfc_err(&dev->interface->dev, "RF setting error %d\n", rc);
17e9d9d4
SO		 1769 }
1770
1771 return;
1772}
1773
673088fb
SO		 1774static int pn533_poll_dep_complete(struct pn533 *dev, void *arg,
1775 struct sk_buff *resp)
1776{
1777 struct pn533_cmd_jump_dep_response *rsp;
1778 struct nfc_target nfc_target;
1779 u8 target_gt_len;
1780 int rc;
1781
1782 if (IS_ERR(resp))
1783 return PTR_ERR(resp);
1784
1785 rsp = (struct pn533_cmd_jump_dep_response *)resp->data;
1786
1787 rc = rsp->status & PN533_CMD_RET_MASK;
1788 if (rc != PN533_CMD_RET_SUCCESS) {
1789 /* Not target found, turn radio off */
1790 queue_work(dev->wq, &dev->rf_work);
1791
1792 dev_kfree_skb(resp);
1793 return 0;
1794 }
1795
1796 dev_dbg(&dev->interface->dev, "Creating new target");
1797
1798 nfc_target.supported_protocols = NFC_PROTO_NFC_DEP_MASK;
1799 nfc_target.nfcid1_len = 10;
1800 memcpy(nfc_target.nfcid1, rsp->nfcid3t, nfc_target.nfcid1_len);
1801 rc = nfc_targets_found(dev->nfc_dev, &nfc_target, 1);
1802 if (rc)
1803 goto error;
1804
1805 dev->tgt_available_prots = 0;
1806 dev->tgt_active_prot = NFC_PROTO_NFC_DEP;
1807
1808 /* ATR_RES general bytes are located at offset 17 */
1809 target_gt_len = resp->len - 17;
1810 rc = nfc_set_remote_general_bytes(dev->nfc_dev,
1811 rsp->gt, target_gt_len);
1812 if (!rc) {
1813 rc = nfc_dep_link_is_up(dev->nfc_dev,
1814 dev->nfc_dev->targets[0].idx,
1815 0, NFC_RF_INITIATOR);
1816
1817 if (!rc)
1818 pn533_poll_reset_mod_list(dev);
1819 }
1820error:
1821 dev_kfree_skb(resp);
1822 return rc;
1823}
1824
1825#define PASSIVE_DATA_LEN 5
1826static int pn533_poll_dep(struct nfc_dev *nfc_dev)
1827{
1828 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1829 struct sk_buff *skb;
1830 int rc, skb_len;
1831 u8 *next, nfcid3[NFC_NFCID3_MAXSIZE];
1832 u8 passive_data[PASSIVE_DATA_LEN] = {0x00, 0xff, 0xff, 0x00, 0x3};
1833
1834 dev_dbg(&dev->interface->dev, "%s", __func__);
1835
1836 if (!dev->gb) {
1837 dev->gb = nfc_get_local_general_bytes(nfc_dev, &dev->gb_len);
1838
1839 if (!dev->gb || !dev->gb_len) {
1840 dev->poll_dep = 0;
1841 queue_work(dev->wq, &dev->rf_work);
1842 }
1843 }
1844
1845 skb_len = 3 + dev->gb_len; /* ActPass + BR + Next */
1846 skb_len += PASSIVE_DATA_LEN;
1847
1848 /* NFCID3 */
1849 skb_len += NFC_NFCID3_MAXSIZE;
1850 nfcid3[0] = 0x1;
1851 nfcid3[1] = 0xfe;
1852 get_random_bytes(nfcid3 + 2, 6);
1853
1854 skb = pn533_alloc_skb(dev, skb_len);
1855 if (!skb)
1856 return -ENOMEM;
1857
1858 *skb_put(skb, 1) = 0x01; /* Active */
1859 *skb_put(skb, 1) = 0x02; /* 424 kbps */
1860
1861 next = skb_put(skb, 1); /* Next */
1862 *next = 0;
1863
1864 /* Copy passive data */
1865 memcpy(skb_put(skb, PASSIVE_DATA_LEN), passive_data, PASSIVE_DATA_LEN);
1866 *next |= 1;
1867
1868 /* Copy NFCID3 (which is NFCID2 from SENSF_RES) */
1869 memcpy(skb_put(skb, NFC_NFCID3_MAXSIZE), nfcid3,
1870 NFC_NFCID3_MAXSIZE);
1871 *next |= 2;
1872
1873 memcpy(skb_put(skb, dev->gb_len), dev->gb, dev->gb_len);
1874 *next |= 4; /* We have some Gi */
1875
1876 rc = pn533_send_cmd_async(dev, PN533_CMD_IN_JUMP_FOR_DEP, skb,
1877 pn533_poll_dep_complete, NULL);
1878
1879 if (rc < 0)
1880 dev_kfree_skb(skb);
1881
1882 return rc;
1883}
1884
6fbbdc16 1885static int pn533_poll_complete(struct pn533 *dev, void *arg,
b5193e5d 1886 struct sk_buff *resp)
6fbbdc16
SO		 1887{
1888 struct pn533_poll_modulations *cur_mod;
ad3823ce
SO		 1889 int rc;
1890
b4834839 1891 dev_dbg(&dev->interface->dev, "%s\n", __func__);
ad3823ce 1892
b5193e5d
WR		 1893 if (IS_ERR(resp)) {
1894 rc = PTR_ERR(resp);
1895
073a625f
JP		 1896 nfc_err(&dev->interface->dev, "%s Poll complete error %d\n",
1897 __func__, rc);
b5193e5d
WR		 1898
1899 if (rc == -ENOENT) {
1900 if (dev->poll_mod_count != 0)
1901 return rc;
1902 else
1903 goto stop_poll;
1904 } else if (rc < 0) {
073a625f
JP		 1905 nfc_err(&dev->interface->dev,
1906 "Error %d when running poll\n", rc);
b5193e5d
WR		 1907 goto stop_poll;
1908 }
6fbbdc16 1909 }
ad3823ce 1910
6fbbdc16
SO		 1911 cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
1912
b5193e5d 1913 if (cur_mod->len == 0) { /* Target mode */
6fbbdc16 1914 del_timer(&dev->listen_timer);
b5193e5d
WR		 1915 rc = pn533_init_target_complete(dev, resp);
1916 goto done;
6fbbdc16
SO		 1917 }
1918
b5193e5d
WR		 1919 /* Initiator mode */
1920 rc = pn533_start_poll_complete(dev, resp);
1921 if (!rc)
1922 goto done;
6fbbdc16 1923
95cb9e10 1924 if (!dev->poll_mod_count) {
b4834839 1925 dev_dbg(&dev->interface->dev, "Polling has been stopped\n");
95cb9e10
WR		 1926 goto done;
1927 }
1928
b5193e5d 1929 pn533_poll_next_mod(dev);
17e9d9d4
SO		 1930 /* Not target found, turn radio off */
1931 queue_work(dev->wq, &dev->rf_work);
6fbbdc16 1932
b5193e5d
WR		 1933done:
1934 dev_kfree_skb(resp);
1935 return rc;
6fbbdc16
SO		 1936
1937stop_poll:
073a625f 1938 nfc_err(&dev->interface->dev, "Polling operation has been stopped\n");
b5193e5d 1939
6fbbdc16
SO		 1940 pn533_poll_reset_mod_list(dev);
1941 dev->poll_protocols = 0;
b5193e5d 1942 return rc;
ad3823ce
SO		 1943}
1944
9e2d493e
WR		 1945static struct sk_buff *pn533_alloc_poll_in_frame(struct pn533 *dev,
1946 struct pn533_poll_modulations *mod)
c46ee386 1947{
b5193e5d 1948 struct sk_buff *skb;
c46ee386 1949
9e2d493e 1950 skb = pn533_alloc_skb(dev, mod->len);
b5193e5d
WR		 1951 if (!skb)
1952 return NULL;
c46ee386 1953
b5193e5d 1954 memcpy(skb_put(skb, mod->len), &mod->data, mod->len);
c46ee386 1955
b5193e5d 1956 return skb;
6fbbdc16 1957}
c46ee386 1958
6fbbdc16
SO		 1959static int pn533_send_poll_frame(struct pn533 *dev)
1960{
b5193e5d
WR		 1961 struct pn533_poll_modulations *mod;
1962 struct sk_buff *skb;
6fbbdc16 1963 int rc;
b5193e5d 1964 u8 cmd_code;
c46ee386 1965
b5193e5d 1966 mod = dev->poll_mod_active[dev->poll_mod_curr];
c46ee386 1967
b4834839
JP		 1968 dev_dbg(&dev->interface->dev, "%s mod len %d\n",
1969 __func__, mod->len);
c46ee386 1970
673088fb
SO		 1971 if (dev->poll_dep) {
1972 dev->poll_dep = 0;
1973 return pn533_poll_dep(dev->nfc_dev);
1974 }
1975
b5193e5d
WR		 1976 if (mod->len == 0) { /* Listen mode */
1977 cmd_code = PN533_CMD_TG_INIT_AS_TARGET;
9e2d493e 1978 skb = pn533_alloc_poll_tg_frame(dev);
b5193e5d
WR		 1979 } else { /* Polling mode */
1980 cmd_code = PN533_CMD_IN_LIST_PASSIVE_TARGET;
9e2d493e 1981 skb = pn533_alloc_poll_in_frame(dev, mod);
b5193e5d
WR		 1982 }
1983
1984 if (!skb) {
073a625f 1985 nfc_err(&dev->interface->dev, "Failed to allocate skb\n");
b5193e5d
WR		 1986 return -ENOMEM;
1987 }
1988
1989 rc = pn533_send_cmd_async(dev, cmd_code, skb, pn533_poll_complete,
1990 NULL);
1991 if (rc < 0) {
1992 dev_kfree_skb(skb);
073a625f 1993 nfc_err(&dev->interface->dev, "Polling loop error %d\n", rc);
b5193e5d 1994 }
c46ee386 1995
6fbbdc16
SO		 1996 return rc;
1997}
1998
1999static void pn533_wq_poll(struct work_struct *work)
2000{
46f793b0 2001 struct pn533 *dev = container_of(work, struct pn533, poll_work.work);
6fbbdc16
SO		 2002 struct pn533_poll_modulations *cur_mod;
2003 int rc;
2004
2005 cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
2006
b4834839
JP		 2007 dev_dbg(&dev->interface->dev,
2008 "%s cancel_listen %d modulation len %d\n",
2009 __func__, dev->cancel_listen, cur_mod->len);
6fbbdc16
SO		 2010
2011 if (dev->cancel_listen == 1) {
2012 dev->cancel_listen = 0;
10cff29a 2013 pn533_abort_cmd(dev, GFP_ATOMIC);
c46ee386
AAJ		 2014 }
2015
6fbbdc16
SO		 2016 rc = pn533_send_poll_frame(dev);
2017 if (rc)
2018 return;
c46ee386 2019
6fbbdc16
SO		 2020 if (cur_mod->len == 0 && dev->poll_mod_count > 1)
2021 mod_timer(&dev->listen_timer, jiffies + PN533_LISTEN_TIME * HZ);
c46ee386 2022
6fbbdc16 2023 return;
c46ee386
AAJ		 2024}
2025
fe7c5800
SO		 2026static int pn533_start_poll(struct nfc_dev *nfc_dev,
2027 u32 im_protocols, u32 tm_protocols)
2028{
2029 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
cec4b8ed 2030 struct pn533_poll_modulations *cur_mod;
dfccd0f5 2031 u8 rand_mod;
cec4b8ed 2032 int rc;
fe7c5800 2033
b4834839
JP		 2034 dev_dbg(&dev->interface->dev,
2035 "%s: im protocols 0x%x tm protocols 0x%x\n",
2036 __func__, im_protocols, tm_protocols);
fe7c5800
SO		 2037
2038 if (dev->tgt_active_prot) {
073a625f
JP		 2039 nfc_err(&dev->interface->dev,
2040 "Cannot poll with a target already activated\n");
fe7c5800
SO		 2041 return -EBUSY;
2042 }
2043
51ad304c 2044 if (dev->tgt_mode) {
073a625f
JP		 2045 nfc_err(&dev->interface->dev,
2046 "Cannot poll while already being activated\n");
51ad304c
SO		 2047 return -EBUSY;
2048 }
2049
6fbbdc16
SO		 2050 if (tm_protocols) {
2051 dev->gb = nfc_get_local_general_bytes(nfc_dev, &dev->gb_len);
2052 if (dev->gb == NULL)
2053 tm_protocols = 0;
2054 }
ad3823ce 2055
6fbbdc16
SO		 2056 pn533_poll_create_mod_list(dev, im_protocols, tm_protocols);
2057 dev->poll_protocols = im_protocols;
2058 dev->listen_protocols = tm_protocols;
ad3823ce 2059
dfccd0f5
SO		 2060 /* Do not always start polling from the same modulation */
2061 get_random_bytes(&rand_mod, sizeof(rand_mod));
2062 rand_mod %= dev->poll_mod_count;
2063 dev->poll_mod_curr = rand_mod;
2064
cec4b8ed
SO		 2065 cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
2066
2067 rc = pn533_send_poll_frame(dev);
2068
2069 /* Start listen timer */
2070 if (!rc && cur_mod->len == 0 && dev->poll_mod_count > 1)
2071 mod_timer(&dev->listen_timer, jiffies + PN533_LISTEN_TIME * HZ);
2072
2073 return rc;
fe7c5800
SO		 2074}
2075
c46ee386
AAJ		 2076static void pn533_stop_poll(struct nfc_dev *nfc_dev)
2077{
2078 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2079
6fbbdc16
SO		 2080 del_timer(&dev->listen_timer);
2081
c46ee386 2082 if (!dev->poll_mod_count) {
b4834839
JP		 2083 dev_dbg(&dev->interface->dev,
2084 "Polling operation was not running\n");
c46ee386
AAJ		 2085 return;
2086 }
2087
10cff29a 2088 pn533_abort_cmd(dev, GFP_KERNEL);
46f793b0 2089 flush_delayed_work(&dev->poll_work);
7c2a04a9 2090 pn533_poll_reset_mod_list(dev);
c46ee386
AAJ		 2091}
2092
2093static int pn533_activate_target_nfcdep(struct pn533 *dev)
2094{
cb950d93 2095 struct pn533_cmd_activate_response *rsp;
541d920b 2096 u16 gt_len;
c46ee386 2097 int rc;
cb950d93
WR		 2098 struct sk_buff *skb;
2099 struct sk_buff *resp;
c46ee386 2100
b4834839 2101 dev_dbg(&dev->interface->dev, "%s\n", __func__);
c46ee386 2102
9e2d493e 2103 skb = pn533_alloc_skb(dev, sizeof(u8) * 2); /*TG + Next*/
cb950d93
WR		 2104 if (!skb)
2105 return -ENOMEM;
c46ee386 2106
cb950d93
WR		 2107 *skb_put(skb, sizeof(u8)) = 1; /* TG */
2108 *skb_put(skb, sizeof(u8)) = 0; /* Next */
c46ee386 2109
cb950d93
WR		 2110 resp = pn533_send_cmd_sync(dev, PN533_CMD_IN_ATR, skb);
2111 if (IS_ERR(resp))
2112 return PTR_ERR(resp);
c46ee386 2113
37cf4fc6 2114 rsp = (struct pn533_cmd_activate_response *)resp->data;
cb950d93 2115 rc = rsp->status & PN533_CMD_RET_MASK;
8a0ecfe7 2116 if (rc != PN533_CMD_RET_SUCCESS) {
073a625f
JP		 2117 nfc_err(&dev->interface->dev,
2118 "Target activation failed (error 0x%x)\n", rc);
cb950d93 2119 dev_kfree_skb(resp);
c46ee386 2120 return -EIO;
8a0ecfe7 2121 }
c46ee386 2122
541d920b 2123 /* ATR_RES general bytes are located at offset 16 */
cb950d93
WR		 2124 gt_len = resp->len - 16;
2125 rc = nfc_set_remote_general_bytes(dev->nfc_dev, rsp->gt, gt_len);
541d920b 2126
cb950d93 2127 dev_kfree_skb(resp);
541d920b 2128 return rc;
c46ee386
AAJ		 2129}
2130
90099433
EL		 2131static int pn533_activate_target(struct nfc_dev *nfc_dev,
2132 struct nfc_target *target, u32 protocol)
c46ee386
AAJ		 2133{
2134 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2135 int rc;
2136
17936b43 2137 dev_dbg(&dev->interface->dev, "%s: protocol=%u\n", __func__, protocol);
c46ee386
AAJ		 2138
2139 if (dev->poll_mod_count) {
073a625f 2140 nfc_err(&dev->interface->dev,
b4834839 2141 "Cannot activate while polling\n");
c46ee386
AAJ		 2142 return -EBUSY;
2143 }
2144
2145 if (dev->tgt_active_prot) {
073a625f
JP		 2146 nfc_err(&dev->interface->dev,
2147 "There is already an active target\n");
c46ee386
AAJ		 2148 return -EBUSY;
2149 }
2150
2151 if (!dev->tgt_available_prots) {
073a625f
JP		 2152 nfc_err(&dev->interface->dev,
2153 "There is no available target to activate\n");
c46ee386
AAJ		 2154 return -EINVAL;
2155 }
2156
2157 if (!(dev->tgt_available_prots & (1 << protocol))) {
073a625f
JP		 2158 nfc_err(&dev->interface->dev,
2159 "Target doesn't support requested proto %u\n",
2160 protocol);
c46ee386
AAJ		 2161 return -EINVAL;
2162 }
2163
2164 if (protocol == NFC_PROTO_NFC_DEP) {
2165 rc = pn533_activate_target_nfcdep(dev);
2166 if (rc) {
073a625f
JP		 2167 nfc_err(&dev->interface->dev,
2168 "Activating target with DEP failed %d\n", rc);
c46ee386
AAJ		 2169 return rc;
2170 }
2171 }
2172
2173 dev->tgt_active_prot = protocol;
2174 dev->tgt_available_prots = 0;
2175
2176 return 0;
2177}
2178
90099433
EL		 2179static void pn533_deactivate_target(struct nfc_dev *nfc_dev,
2180 struct nfc_target *target)
c46ee386
AAJ		 2181{
2182 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
cb950d93
WR		 2183 struct sk_buff *skb;
2184 struct sk_buff *resp;
c46ee386
AAJ		 2185 int rc;
2186
b4834839 2187 dev_dbg(&dev->interface->dev, "%s\n", __func__);
c46ee386
AAJ		 2188
2189 if (!dev->tgt_active_prot) {
073a625f 2190 nfc_err(&dev->interface->dev, "There is no active target\n");
c46ee386
AAJ		 2191 return;
2192 }
2193
2194 dev->tgt_active_prot = 0;
6ff73fd2
SO		 2195 skb_queue_purge(&dev->resp_q);
2196
9e2d493e 2197 skb = pn533_alloc_skb(dev, sizeof(u8));
cb950d93
WR		 2198 if (!skb)
2199 return;
c46ee386 2200
cb950d93 2201 *skb_put(skb, 1) = 1; /* TG*/
c46ee386 2202
cb950d93
WR		 2203 resp = pn533_send_cmd_sync(dev, PN533_CMD_IN_RELEASE, skb);
2204 if (IS_ERR(resp))
c46ee386 2205 return;
c46ee386 2206
cb950d93 2207 rc = resp->data[0] & PN533_CMD_RET_MASK;
c46ee386 2208 if (rc != PN533_CMD_RET_SUCCESS)
073a625f
JP		 2209 nfc_err(&dev->interface->dev,
2210 "Error 0x%x when releasing the target\n", rc);
c46ee386 2211
cb950d93 2212 dev_kfree_skb(resp);
c46ee386
AAJ		 2213 return;
2214}
2215
361f3cb7
SO		 2216
2217static int pn533_in_dep_link_up_complete(struct pn533 *dev, void *arg,
13003649 2218 struct sk_buff *resp)
361f3cb7 2219{
13003649 2220 struct pn533_cmd_jump_dep_response *rsp;
361f3cb7
SO		 2221 u8 target_gt_len;
2222 int rc;
13003649 2223 u8 active = *(u8 *)arg;
70418e6e
WR		 2224
2225 kfree(arg);
361f3cb7 2226
13003649
WR		 2227 if (IS_ERR(resp))
2228 return PTR_ERR(resp);
361f3cb7
SO		 2229
2230 if (dev->tgt_available_prots &&
2231 !(dev->tgt_available_prots & (1 << NFC_PROTO_NFC_DEP))) {
073a625f
JP		 2232 nfc_err(&dev->interface->dev,
2233 "The target does not support DEP\n");
13003649
WR		 2234 rc = -EINVAL;
2235 goto error;
361f3cb7
SO		 2236 }
2237
13003649
WR		 2238 rsp = (struct pn533_cmd_jump_dep_response *)resp->data;
2239
2240 rc = rsp->status & PN533_CMD_RET_MASK;
361f3cb7 2241 if (rc != PN533_CMD_RET_SUCCESS) {
073a625f
JP		 2242 nfc_err(&dev->interface->dev,
2243 "Bringing DEP link up failed (error 0x%x)\n", rc);
13003649 2244 goto error;
361f3cb7
SO		 2245 }
2246
2247 if (!dev->tgt_available_prots) {
13003649
WR		 2248 struct nfc_target nfc_target;
2249
b4834839 2250 dev_dbg(&dev->interface->dev, "Creating new target\n");
361f3cb7
SO		 2251
2252 nfc_target.supported_protocols = NFC_PROTO_NFC_DEP_MASK;
2fbabfa4 2253 nfc_target.nfcid1_len = 10;
13003649 2254 memcpy(nfc_target.nfcid1, rsp->nfcid3t, nfc_target.nfcid1_len);
361f3cb7
SO		 2255 rc = nfc_targets_found(dev->nfc_dev, &nfc_target, 1);
2256 if (rc)
13003649 2257 goto error;
361f3cb7
SO		 2258
2259 dev->tgt_available_prots = 0;
2260 }
2261
2262 dev->tgt_active_prot = NFC_PROTO_NFC_DEP;
2263
2264 /* ATR_RES general bytes are located at offset 17 */
13003649 2265 target_gt_len = resp->len - 17;
361f3cb7 2266 rc = nfc_set_remote_general_bytes(dev->nfc_dev,
13003649 2267 rsp->gt, target_gt_len);
361f3cb7
SO		 2268 if (rc == 0)
2269 rc = nfc_dep_link_is_up(dev->nfc_dev,
13003649
WR		 2270 dev->nfc_dev->targets[0].idx,
2271 !active, NFC_RF_INITIATOR);
361f3cb7 2272
13003649
WR		 2273error:
2274 dev_kfree_skb(resp);
2275 return rc;
361f3cb7
SO		 2276}
2277
17e9d9d4 2278static int pn533_rf_field(struct nfc_dev *nfc_dev, u8 rf);
90099433 2279static int pn533_dep_link_up(struct nfc_dev *nfc_dev, struct nfc_target *target,
37cf4fc6 2280 u8 comm_mode, u8 *gb, size_t gb_len)
361f3cb7
SO		 2281{
2282 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
13003649 2283 struct sk_buff *skb;
5eef4845
SO		 2284 int rc, skb_len;
2285 u8 *next, *arg, nfcid3[NFC_NFCID3_MAXSIZE];
d7f3345d 2286 u8 passive_data[PASSIVE_DATA_LEN] = {0x00, 0xff, 0xff, 0x00, 0x3};
361f3cb7 2287
b4834839 2288 dev_dbg(&dev->interface->dev, "%s\n", __func__);
361f3cb7 2289
361f3cb7 2290 if (dev->poll_mod_count) {
073a625f
JP		 2291 nfc_err(&dev->interface->dev,
2292 "Cannot bring the DEP link up while polling\n");
361f3cb7
SO		 2293 return -EBUSY;
2294 }
2295
2296 if (dev->tgt_active_prot) {
073a625f
JP		 2297 nfc_err(&dev->interface->dev,
2298 "There is already an active target\n");
361f3cb7
SO		 2299 return -EBUSY;
2300 }
2301
13003649 2302 skb_len = 3 + gb_len; /* ActPass + BR + Next */
5eef4845 2303 skb_len += PASSIVE_DATA_LEN;
d7f3345d 2304
5eef4845
SO		 2305 /* NFCID3 */
2306 skb_len += NFC_NFCID3_MAXSIZE;
2307 if (target && !target->nfcid2_len) {
2308 nfcid3[0] = 0x1;
2309 nfcid3[1] = 0xfe;
2310 get_random_bytes(nfcid3 + 2, 6);
2311 }
322bce95 2312
9e2d493e 2313 skb = pn533_alloc_skb(dev, skb_len);
13003649 2314 if (!skb)
361f3cb7
SO		 2315 return -ENOMEM;
2316
13003649 2317 *skb_put(skb, 1) = !comm_mode; /* ActPass */
5eef4845 2318 *skb_put(skb, 1) = 0x02; /* 424 kbps */
13003649
WR		 2319
2320 next = skb_put(skb, 1); /* Next */
2321 *next = 0;
361f3cb7 2322
5eef4845
SO		 2323 /* Copy passive data */
2324 memcpy(skb_put(skb, PASSIVE_DATA_LEN), passive_data, PASSIVE_DATA_LEN);
2325 *next |= 1;
d7f3345d 2326
5eef4845
SO		 2327 /* Copy NFCID3 (which is NFCID2 from SENSF_RES) */
2328 if (target && target->nfcid2_len)
322bce95
SO		 2329 memcpy(skb_put(skb, NFC_NFCID3_MAXSIZE), target->nfcid2,
2330 target->nfcid2_len);
5eef4845
SO		 2331 else
2332 memcpy(skb_put(skb, NFC_NFCID3_MAXSIZE), nfcid3,
2333 NFC_NFCID3_MAXSIZE);
2334 *next |= 2;
322bce95 2335
47807d3d 2336 if (gb != NULL && gb_len > 0) {
13003649
WR		 2337 memcpy(skb_put(skb, gb_len), gb, gb_len);
2338 *next |= 4; /* We have some Gi */
361f3cb7 2339 } else {
13003649 2340 *next = 0;
361f3cb7
SO		 2341 }
2342
13003649
WR		 2343 arg = kmalloc(sizeof(*arg), GFP_KERNEL);
2344 if (!arg) {
2345 dev_kfree_skb(skb);
2346 return -ENOMEM;
2347 }
361f3cb7 2348
13003649 2349 *arg = !comm_mode;
361f3cb7 2350
17e9d9d4
SO		 2351 pn533_rf_field(dev->nfc_dev, 0);
2352
13003649
WR		 2353 rc = pn533_send_cmd_async(dev, PN533_CMD_IN_JUMP_FOR_DEP, skb,
2354 pn533_in_dep_link_up_complete, arg);
2355
2356 if (rc < 0) {
2357 dev_kfree_skb(skb);
2358 kfree(arg);
2359 }
361f3cb7
SO		 2360
2361 return rc;
2362}
2363
2364static int pn533_dep_link_down(struct nfc_dev *nfc_dev)
2365{
6fbbdc16
SO		 2366 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2367
b4834839 2368 dev_dbg(&dev->interface->dev, "%s\n", __func__);
fcfafc76 2369
6fbbdc16
SO		 2370 pn533_poll_reset_mod_list(dev);
2371
10cff29a
WR		 2372 if (dev->tgt_mode || dev->tgt_active_prot)
2373 pn533_abort_cmd(dev, GFP_KERNEL);
51ad304c
SO		 2374
2375 dev->tgt_active_prot = 0;
2376 dev->tgt_mode = 0;
2377
2378 skb_queue_purge(&dev->resp_q);
361f3cb7
SO		 2379
2380 return 0;
2381}
2382
c46ee386 2383struct pn533_data_exchange_arg {
c46ee386
AAJ		 2384 data_exchange_cb_t cb;
2385 void *cb_context;
2386};
2387
6ff73fd2
SO		 2388static struct sk_buff *pn533_build_response(struct pn533 *dev)
2389{
2390 struct sk_buff *skb, *tmp, *t;
2391 unsigned int skb_len = 0, tmp_len = 0;
2392
b4834839 2393 dev_dbg(&dev->interface->dev, "%s\n", __func__);
6ff73fd2
SO		 2394
2395 if (skb_queue_empty(&dev->resp_q))
2396 return NULL;
2397
2398 if (skb_queue_len(&dev->resp_q) == 1) {
2399 skb = skb_dequeue(&dev->resp_q);
2400 goto out;
2401 }
2402
2403 skb_queue_walk_safe(&dev->resp_q, tmp, t)
2404 skb_len += tmp->len;
2405
b4834839
JP		 2406 dev_dbg(&dev->interface->dev, "%s total length %d\n",
2407 __func__, skb_len);
6ff73fd2
SO		 2408
2409 skb = alloc_skb(skb_len, GFP_KERNEL);
2410 if (skb == NULL)
2411 goto out;
2412
2413 skb_put(skb, skb_len);
2414
2415 skb_queue_walk_safe(&dev->resp_q, tmp, t) {
2416 memcpy(skb->data + tmp_len, tmp->data, tmp->len);
2417 tmp_len += tmp->len;
2418 }
2419
2420out:
2421 skb_queue_purge(&dev->resp_q);
2422
2423 return skb;
2424}
2425
c46ee386 2426static int pn533_data_exchange_complete(struct pn533 *dev, void *_arg,
b1e666f5 2427 struct sk_buff *resp)
c46ee386
AAJ		 2428{
2429 struct pn533_data_exchange_arg *arg = _arg;
b1e666f5
WR		 2430 struct sk_buff *skb;
2431 int rc = 0;
2432 u8 status, ret, mi;
c46ee386 2433
b4834839 2434 dev_dbg(&dev->interface->dev, "%s\n", __func__);
c46ee386 2435
b1e666f5
WR		 2436 if (IS_ERR(resp)) {
2437 rc = PTR_ERR(resp);
2438 goto _error;
c46ee386
AAJ		 2439 }
2440
b1e666f5
WR		 2441 status = resp->data[0];
2442 ret = status & PN533_CMD_RET_MASK;
2443 mi = status & PN533_CMD_MI_MASK;
2444
2445 skb_pull(resp, sizeof(status));
c46ee386 2446
b1e666f5 2447 if (ret != PN533_CMD_RET_SUCCESS) {
073a625f
JP		 2448 nfc_err(&dev->interface->dev,
2449 "Exchanging data failed (error 0x%x)\n", ret);
b1e666f5 2450 rc = -EIO;
c46ee386
AAJ		 2451 goto error;
2452 }
2453
b1e666f5 2454 skb_queue_tail(&dev->resp_q, resp);
6ff73fd2 2455
b1e666f5
WR		 2456 if (mi) {
2457 dev->cmd_complete_mi_arg = arg;
963a82e0
OG		 2458 queue_work(dev->wq, &dev->mi_rx_work);
2459 return -EINPROGRESS;
2460 }
2461
2462 /* Prepare for the next round */
2463 if (skb_queue_len(&dev->fragment_skb) > 0) {
2464 dev->cmd_complete_dep_arg = arg;
2465 queue_work(dev->wq, &dev->mi_tx_work);
2466
6ff73fd2 2467 return -EINPROGRESS;
c46ee386
AAJ		 2468 }
2469
6ff73fd2 2470 skb = pn533_build_response(dev);
b1e666f5 2471 if (!skb)
6ff73fd2 2472 goto error;
c46ee386 2473
6ff73fd2 2474 arg->cb(arg->cb_context, skb, 0);
c46ee386
AAJ		 2475 kfree(arg);
2476 return 0;
2477
2478error:
b1e666f5
WR		 2479 dev_kfree_skb(resp);
2480_error:
6ff73fd2 2481 skb_queue_purge(&dev->resp_q);
b1e666f5 2482 arg->cb(arg->cb_context, NULL, rc);
c46ee386 2483 kfree(arg);
b1e666f5 2484 return rc;
c46ee386
AAJ		 2485}
2486
963a82e0
OG		 2487/* Split the Tx skb into small chunks */
2488static int pn533_fill_fragment_skbs(struct pn533 *dev, struct sk_buff *skb)
2489{
2490 struct sk_buff *frag;
2491 int frag_size;
2492
2493 do {
2494 /* Remaining size */
2495 if (skb->len > PN533_CMD_DATAFRAME_MAXLEN)
2496 frag_size = PN533_CMD_DATAFRAME_MAXLEN;
2497 else
2498 frag_size = skb->len;
2499
2500 /* Allocate and reserve */
2501 frag = pn533_alloc_skb(dev, frag_size);
2502 if (!frag) {
2503 skb_queue_purge(&dev->fragment_skb);
2504 break;
2505 }
2506
2507 /* Reserve the TG/MI byte */
2508 skb_reserve(frag, 1);
2509
2510 /* MI + TG */
2511 if (frag_size == PN533_CMD_DATAFRAME_MAXLEN)
2512 *skb_push(frag, sizeof(u8)) = (PN533_CMD_MI_MASK | 1);
2513 else
2514 *skb_push(frag, sizeof(u8)) = 1; /* TG */
2515
2516 memcpy(skb_put(frag, frag_size), skb->data, frag_size);
2517
2518 /* Reduce the size of incoming buffer */
2519 skb_pull(skb, frag_size);
2520
2521 /* Add this to skb_queue */
2522 skb_queue_tail(&dev->fragment_skb, frag);
2523
2524 } while (skb->len > 0);
2525
2526 dev_kfree_skb(skb);
2527
2528 return skb_queue_len(&dev->fragment_skb);
2529}
2530
be9ae4ce
SO		 2531static int pn533_transceive(struct nfc_dev *nfc_dev,
2532 struct nfc_target *target, struct sk_buff *skb,
2533 data_exchange_cb_t cb, void *cb_context)
c46ee386
AAJ		 2534{
2535 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
b1e666f5 2536 struct pn533_data_exchange_arg *arg = NULL;
c46ee386
AAJ		 2537 int rc;
2538
b4834839 2539 dev_dbg(&dev->interface->dev, "%s\n", __func__);
c46ee386
AAJ		 2540
2541 if (!dev->tgt_active_prot) {
073a625f
JP		 2542 nfc_err(&dev->interface->dev,
2543 "Can't exchange data if there is no active target\n");
c46ee386
AAJ		 2544 rc = -EINVAL;
2545 goto error;
2546 }
2547
b1e666f5 2548 arg = kmalloc(sizeof(*arg), GFP_KERNEL);
c46ee386
AAJ		 2549 if (!arg) {
2550 rc = -ENOMEM;
b1e666f5 2551 goto error;
c46ee386
AAJ		 2552 }
2553
c46ee386
AAJ		 2554 arg->cb = cb;
2555 arg->cb_context = cb_context;
2556
b1e666f5
WR		 2557 switch (dev->device_type) {
2558 case PN533_DEVICE_PASORI:
2559 if (dev->tgt_active_prot == NFC_PROTO_FELICA) {
2560 rc = pn533_send_data_async(dev, PN533_CMD_IN_COMM_THRU,
2561 skb,
2562 pn533_data_exchange_complete,
2563 arg);
2564
2565 break;
2566 }
2567 default:
963a82e0
OG		 2568 /* jumbo frame ? */
2569 if (skb->len > PN533_CMD_DATAEXCH_DATA_MAXLEN) {
2570 rc = pn533_fill_fragment_skbs(dev, skb);
2571 if (rc <= 0)
2572 goto error;
2573
2574 skb = skb_dequeue(&dev->fragment_skb);
2575 if (!skb) {
2576 rc = -EIO;
2577 goto error;
2578 }
2579 } else {
2580 *skb_push(skb, sizeof(u8)) = 1; /* TG */
2581 }
b1e666f5
WR		 2582
2583 rc = pn533_send_data_async(dev, PN533_CMD_IN_DATA_EXCHANGE,
2584 skb, pn533_data_exchange_complete,
2585 arg);
2586
2587 break;
c46ee386
AAJ		 2588 }
2589
b1e666f5
WR		 2590 if (rc < 0) /* rc from send_async */
2591 goto error;
2592
c46ee386
AAJ		 2593 return 0;
2594
c46ee386 2595error:
b1e666f5
WR		 2596 kfree(arg);
2597 dev_kfree_skb(skb);
c46ee386
AAJ		 2598 return rc;
2599}
2600
dadb06f2 2601static int pn533_tm_send_complete(struct pn533 *dev, void *arg,
e4878823 2602 struct sk_buff *resp)
dadb06f2 2603{
e4878823 2604 u8 status;
5b412fd1 2605
b4834839 2606 dev_dbg(&dev->interface->dev, "%s\n", __func__);
dadb06f2 2607
e4878823
WR		 2608 if (IS_ERR(resp))
2609 return PTR_ERR(resp);
5b412fd1 2610
e4878823 2611 status = resp->data[0];
dadb06f2 2612
e4878823 2613 dev_kfree_skb(resp);
dadb06f2 2614
e4878823 2615 if (status != 0) {
dadb06f2
SO		 2616 nfc_tm_deactivated(dev->nfc_dev);
2617
51ad304c
SO		 2618 dev->tgt_mode = 0;
2619
dadb06f2
SO		 2620 return 0;
2621 }
2622
2623 queue_work(dev->wq, &dev->tg_work);
2624
2625 return 0;
2626}
2627
2628static int pn533_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
2629{
2630 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
dadb06f2
SO		 2631 int rc;
2632
b4834839 2633 dev_dbg(&dev->interface->dev, "%s\n", __func__);
dadb06f2 2634
e4878823 2635 if (skb->len > PN533_CMD_DATAEXCH_DATA_MAXLEN) {
073a625f
JP		 2636 nfc_err(&dev->interface->dev,
2637 "Data length greater than the max allowed: %d\n",
2638 PN533_CMD_DATAEXCH_DATA_MAXLEN);
e4878823 2639 return -ENOSYS;
dadb06f2
SO		 2640 }
2641
e4878823
WR		 2642 rc = pn533_send_data_async(dev, PN533_CMD_TG_SET_DATA, skb,
2643 pn533_tm_send_complete, NULL);
2644 if (rc < 0)
2645 dev_kfree_skb(skb);
dadb06f2
SO		 2646
2647 return rc;
2648}
2649
6ff73fd2
SO		 2650static void pn533_wq_mi_recv(struct work_struct *work)
2651{
963a82e0 2652 struct pn533 *dev = container_of(work, struct pn533, mi_rx_work);
b1e666f5 2653 struct sk_buff *skb;
6ff73fd2
SO		 2654 int rc;
2655
b4834839 2656 dev_dbg(&dev->interface->dev, "%s\n", __func__);
6ff73fd2 2657
9e2d493e 2658 skb = pn533_alloc_skb(dev, PN533_CMD_DATAEXCH_HEAD_LEN);
b1e666f5
WR		 2659 if (!skb)
2660 goto error;
6ff73fd2 2661
b1e666f5
WR		 2662 switch (dev->device_type) {
2663 case PN533_DEVICE_PASORI:
2664 if (dev->tgt_active_prot == NFC_PROTO_FELICA) {
2665 rc = pn533_send_cmd_direct_async(dev,
2666 PN533_CMD_IN_COMM_THRU,
2667 skb,
2668 pn533_data_exchange_complete,
2669 dev->cmd_complete_mi_arg);
6ff73fd2 2670
b1e666f5
WR		 2671 break;
2672 }
2673 default:
2674 *skb_put(skb, sizeof(u8)) = 1; /*TG*/
6ff73fd2 2675
b1e666f5
WR		 2676 rc = pn533_send_cmd_direct_async(dev,
2677 PN533_CMD_IN_DATA_EXCHANGE,
2678 skb,
2679 pn533_data_exchange_complete,
2680 dev->cmd_complete_mi_arg);
b1bb290a 2681
b1e666f5 2682 break;
6ff73fd2
SO		 2683 }
2684
b1e666f5 2685 if (rc == 0) /* success */
6ff73fd2
SO		 2686 return;
2687
073a625f
JP		 2688 nfc_err(&dev->interface->dev,
2689 "Error %d when trying to perform data_exchange\n", rc);
6ff73fd2 2690
b1e666f5 2691 dev_kfree_skb(skb);
140ef7f6 2692 kfree(dev->cmd_complete_mi_arg);
6ff73fd2 2693
b1e666f5 2694error:
6ff73fd2 2695 pn533_send_ack(dev, GFP_KERNEL);
5d50b364 2696 queue_work(dev->wq, &dev->cmd_work);
6ff73fd2
SO		 2697}
2698
963a82e0
OG		 2699static void pn533_wq_mi_send(struct work_struct *work)
2700{
2701 struct pn533 *dev = container_of(work, struct pn533, mi_tx_work);
2702 struct sk_buff *skb;
2703 int rc;
2704
b4834839 2705 dev_dbg(&dev->interface->dev, "%s\n", __func__);
963a82e0
OG		 2706
2707 /* Grab the first skb in the queue */
2708 skb = skb_dequeue(&dev->fragment_skb);
2709
2710 if (skb == NULL) { /* No more data */
2711 /* Reset the queue for future use */
2712 skb_queue_head_init(&dev->fragment_skb);
2713 goto error;
2714 }
2715
2716 switch (dev->device_type) {
2717 case PN533_DEVICE_PASORI:
2718 if (dev->tgt_active_prot != NFC_PROTO_FELICA) {
2719 rc = -EIO;
2720 break;
2721 }
2722
2723 rc = pn533_send_cmd_direct_async(dev, PN533_CMD_IN_COMM_THRU,
2724 skb,
2725 pn533_data_exchange_complete,
2726 dev->cmd_complete_dep_arg);
2727
2728 break;
2729
2730 default:
2731 /* Still some fragments? */
2732 rc = pn533_send_cmd_direct_async(dev,PN533_CMD_IN_DATA_EXCHANGE,
2733 skb,
2734 pn533_data_exchange_complete,
2735 dev->cmd_complete_dep_arg);
2736
2737 break;
2738 }
2739
2740 if (rc == 0) /* success */
2741 return;
2742
073a625f
JP		 2743 nfc_err(&dev->interface->dev,
2744 "Error %d when trying to perform data_exchange\n", rc);
963a82e0
OG		 2745
2746 dev_kfree_skb(skb);
2747 kfree(dev->cmd_complete_dep_arg);
2748
2749error:
2750 pn533_send_ack(dev, GFP_KERNEL);
2751 queue_work(dev->wq, &dev->cmd_work);
2752}
2753
c46ee386
AAJ		 2754static int pn533_set_configuration(struct pn533 *dev, u8 cfgitem, u8 *cfgdata,
2755 u8 cfgdata_len)
2756{
cb950d93
WR		 2757 struct sk_buff *skb;
2758 struct sk_buff *resp;
cb950d93 2759 int skb_len;
c46ee386 2760
b4834839 2761 dev_dbg(&dev->interface->dev, "%s\n", __func__);
c46ee386 2762
cb950d93 2763 skb_len = sizeof(cfgitem) + cfgdata_len; /* cfgitem + cfgdata */
c46ee386 2764
9e2d493e 2765 skb = pn533_alloc_skb(dev, skb_len);
cb950d93
WR		 2766 if (!skb)
2767 return -ENOMEM;
c46ee386 2768
cb950d93
WR		 2769 *skb_put(skb, sizeof(cfgitem)) = cfgitem;
2770 memcpy(skb_put(skb, cfgdata_len), cfgdata, cfgdata_len);
c46ee386 2771
cb950d93
WR		 2772 resp = pn533_send_cmd_sync(dev, PN533_CMD_RF_CONFIGURATION, skb);
2773 if (IS_ERR(resp))
2774 return PTR_ERR(resp);
c46ee386 2775
cb950d93
WR		 2776 dev_kfree_skb(resp);
2777 return 0;
2778}
2779
2780static int pn533_get_firmware_version(struct pn533 *dev,
2781 struct pn533_fw_version *fv)
2782{
2783 struct sk_buff *skb;
2784 struct sk_buff *resp;
2785
9e2d493e 2786 skb = pn533_alloc_skb(dev, 0);
cb950d93
WR		 2787 if (!skb)
2788 return -ENOMEM;
2789
2790 resp = pn533_send_cmd_sync(dev, PN533_CMD_GET_FIRMWARE_VERSION, skb);
2791 if (IS_ERR(resp))
2792 return PTR_ERR(resp);
2793
2794 fv->ic = resp->data[0];
2795 fv->ver = resp->data[1];
2796 fv->rev = resp->data[2];
2797 fv->support = resp->data[3];
2798
2799 dev_kfree_skb(resp);
2800 return 0;
c46ee386
AAJ		 2801}
2802
f75c2913 2803static int pn533_pasori_fw_reset(struct pn533 *dev)
5c7b0531 2804{
cb950d93
WR		 2805 struct sk_buff *skb;
2806 struct sk_buff *resp;
5c7b0531 2807
b4834839 2808 dev_dbg(&dev->interface->dev, "%s\n", __func__);
5c7b0531 2809
9e2d493e 2810 skb = pn533_alloc_skb(dev, sizeof(u8));
cb950d93
WR		 2811 if (!skb)
2812 return -ENOMEM;
5c7b0531 2813
cb950d93 2814 *skb_put(skb, sizeof(u8)) = 0x1;
5c7b0531 2815
cb950d93
WR		 2816 resp = pn533_send_cmd_sync(dev, 0x18, skb);
2817 if (IS_ERR(resp))
2818 return PTR_ERR(resp);
5c7b0531 2819
cb950d93 2820 dev_kfree_skb(resp);
5c7b0531 2821
94c5c156 2822 return 0;
5c7b0531
SO		 2823}
2824
53cf4839
WR		 2825struct pn533_acr122_poweron_rdr_arg {
2826 int rc;
2827 struct completion done;
2828};
2829
2830static void pn533_acr122_poweron_rdr_resp(struct urb *urb)
2831{
2832 struct pn533_acr122_poweron_rdr_arg *arg = urb->context;
2833
b4834839 2834 dev_dbg(&urb->dev->dev, "%s\n", __func__);
53cf4839 2835
86eca4e7 2836 print_hex_dump_debug("ACR122 RX: ", DUMP_PREFIX_NONE, 16, 1,
53cf4839
WR		 2837 urb->transfer_buffer, urb->transfer_buffer_length,
2838 false);
2839
2840 arg->rc = urb->status;
2841 complete(&arg->done);
2842}
2843
2844static int pn533_acr122_poweron_rdr(struct pn533 *dev)
2845{
2846 /* Power on th reader (CCID cmd) */
2847 u8 cmd[10] = {PN533_ACR122_PC_TO_RDR_ICCPOWERON,
2848 0, 0, 0, 0, 0, 0, 3, 0, 0};
2849 u8 buf[255];
2850 int rc;
2851 void *cntx;
2852 struct pn533_acr122_poweron_rdr_arg arg;
2853
b4834839 2854 dev_dbg(&dev->interface->dev, "%s\n", __func__);
53cf4839
WR		 2855
2856 init_completion(&arg.done);
2857 cntx = dev->in_urb->context; /* backup context */
2858
2859 dev->in_urb->transfer_buffer = buf;
2860 dev->in_urb->transfer_buffer_length = 255;
2861 dev->in_urb->complete = pn533_acr122_poweron_rdr_resp;
2862 dev->in_urb->context = &arg;
2863
2864 dev->out_urb->transfer_buffer = cmd;
2865 dev->out_urb->transfer_buffer_length = sizeof(cmd);
2866
86eca4e7 2867 print_hex_dump_debug("ACR122 TX: ", DUMP_PREFIX_NONE, 16, 1,
53cf4839
WR		 2868 cmd, sizeof(cmd), false);
2869
2870 rc = usb_submit_urb(dev->out_urb, GFP_KERNEL);
2871 if (rc) {
073a625f
JP		 2872 nfc_err(&dev->interface->dev,
2873 "Reader power on cmd error %d\n", rc);
53cf4839
WR		 2874 return rc;
2875 }
2876
2877 rc = usb_submit_urb(dev->in_urb, GFP_KERNEL);
2878 if (rc) {
073a625f
JP		 2879 nfc_err(&dev->interface->dev,
2880 "Can't submit reader poweron cmd response %d\n", rc);
53cf4839
WR		 2881 return rc;
2882 }
2883
2884 wait_for_completion(&arg.done);
2885 dev->in_urb->context = cntx; /* restore context */
2886
2887 return arg.rc;
2888}
2889
60d9edd5
SO		 2890static int pn533_rf_field(struct nfc_dev *nfc_dev, u8 rf)
2891{
2892 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2893 u8 rf_field = !!rf;
2894 int rc;
2895
3a8eab39
SO		 2896 rf_field |= PN533_CFGITEM_RF_FIELD_AUTO_RFCA;
2897
60d9edd5
SO		 2898 rc = pn533_set_configuration(dev, PN533_CFGITEM_RF_FIELD,
2899 (u8 *)&rf_field, 1);
2900 if (rc) {
073a625f 2901 nfc_err(&dev->interface->dev, "Error on setting RF field\n");
60d9edd5
SO		 2902 return rc;
2903 }
2904
2905 return rc;
2906}
2907
2908int pn533_dev_up(struct nfc_dev *nfc_dev)
2909{
2910 return pn533_rf_field(nfc_dev, 1);
2911}
2912
2913int pn533_dev_down(struct nfc_dev *nfc_dev)
2914{
2915 return pn533_rf_field(nfc_dev, 0);
2916}
2917
5c7b0531 2918static struct nfc_ops pn533_nfc_ops = {
60d9edd5
SO		 2919 .dev_up = pn533_dev_up,
2920 .dev_down = pn533_dev_down,
361f3cb7
SO		 2921 .dep_link_up = pn533_dep_link_up,
2922 .dep_link_down = pn533_dep_link_down,
c46ee386
AAJ		 2923 .start_poll = pn533_start_poll,
2924 .stop_poll = pn533_stop_poll,
2925 .activate_target = pn533_activate_target,
2926 .deactivate_target = pn533_deactivate_target,
be9ae4ce 2927 .im_transceive = pn533_transceive,
dadb06f2 2928 .tm_send = pn533_tm_send,
c46ee386
AAJ		 2929};
2930
5c7b0531
SO		 2931static int pn533_setup(struct pn533 *dev)
2932{
2933 struct pn533_config_max_retries max_retries;
2934 struct pn533_config_timing timing;
2935 u8 pasori_cfg[3] = {0x08, 0x01, 0x08};
2936 int rc;
2937
2938 switch (dev->device_type) {
2939 case PN533_DEVICE_STD:
5c7b0531 2940 case PN533_DEVICE_PASORI:
53cf4839 2941 case PN533_DEVICE_ACR122U:
5c7b0531
SO		 2942 max_retries.mx_rty_atr = 0x2;
2943 max_retries.mx_rty_psl = 0x1;
2944 max_retries.mx_rty_passive_act =
2945 PN533_CONFIG_MAX_RETRIES_NO_RETRY;
2946
2947 timing.rfu = PN533_CONFIG_TIMING_102;
2948 timing.atr_res_timeout = PN533_CONFIG_TIMING_102;
2949 timing.dep_timeout = PN533_CONFIG_TIMING_204;
2950
2951 break;
2952
2953 default:
073a625f
JP		 2954 nfc_err(&dev->interface->dev, "Unknown device type %d\n",
2955 dev->device_type);
5c7b0531
SO		 2956 return -EINVAL;
2957 }
2958
2959 rc = pn533_set_configuration(dev, PN533_CFGITEM_MAX_RETRIES,
2960 (u8 *)&max_retries, sizeof(max_retries));
2961 if (rc) {
073a625f
JP		 2962 nfc_err(&dev->interface->dev,
2963 "Error on setting MAX_RETRIES config\n");
5c7b0531
SO		 2964 return rc;
2965 }
2966
2967
2968 rc = pn533_set_configuration(dev, PN533_CFGITEM_TIMING,
2969 (u8 *)&timing, sizeof(timing));
2970 if (rc) {
073a625f 2971 nfc_err(&dev->interface->dev, "Error on setting RF timings\n");
5c7b0531
SO		 2972 return rc;
2973 }
2974
2975 switch (dev->device_type) {
2976 case PN533_DEVICE_STD:
2977 break;
2978
2979 case PN533_DEVICE_PASORI:
f75c2913 2980 pn533_pasori_fw_reset(dev);
5c7b0531
SO		 2981
2982 rc = pn533_set_configuration(dev, PN533_CFGITEM_PASORI,
2983 pasori_cfg, 3);
2984 if (rc) {
073a625f
JP		 2985 nfc_err(&dev->interface->dev,
2986 "Error while settings PASORI config\n");
5c7b0531
SO		 2987 return rc;
2988 }
2989
f75c2913 2990 pn533_pasori_fw_reset(dev);
5c7b0531
SO		 2991
2992 break;
2993 }
2994
2995 return 0;
2996}
2997
c46ee386
AAJ		 2998static int pn533_probe(struct usb_interface *interface,
2999 const struct usb_device_id *id)
3000{
cb950d93 3001 struct pn533_fw_version fw_ver;
c46ee386
AAJ		 3002 struct pn533 *dev;
3003 struct usb_host_interface *iface_desc;
3004 struct usb_endpoint_descriptor *endpoint;
c46ee386
AAJ		 3005 int in_endpoint = 0;
3006 int out_endpoint = 0;
3007 int rc = -ENOMEM;
3008 int i;
3009 u32 protocols;
3010
3011 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3012 if (!dev)
3013 return -ENOMEM;
3014
3015 dev->udev = usb_get_dev(interface_to_usbdev(interface));
3016 dev->interface = interface;
0201ed03 3017 mutex_init(&dev->cmd_lock);
c46ee386
AAJ		 3018
3019 iface_desc = interface->cur_altsetting;
3020 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
3021 endpoint = &iface_desc->endpoint[i].desc;
3022
8d25ca79 3023 if (!in_endpoint && usb_endpoint_is_bulk_in(endpoint))
c46ee386 3024 in_endpoint = endpoint->bEndpointAddress;
c46ee386 3025
8d25ca79 3026 if (!out_endpoint && usb_endpoint_is_bulk_out(endpoint))
c46ee386 3027 out_endpoint = endpoint->bEndpointAddress;
c46ee386
AAJ		 3028 }
3029
3030 if (!in_endpoint || !out_endpoint) {
073a625f
JP		 3031 nfc_err(&interface->dev,
3032 "Could not find bulk-in or bulk-out endpoint\n");
c46ee386
AAJ		 3033 rc = -ENODEV;
3034 goto error;
3035 }
3036
c46ee386 3037 dev->in_urb = usb_alloc_urb(0, GFP_KERNEL);
c46ee386
AAJ		 3038 dev->out_urb = usb_alloc_urb(0, GFP_KERNEL);
3039
a5798094 3040 if (!dev->in_urb || !dev->out_urb)
c46ee386
AAJ		 3041 goto error;
3042
3043 usb_fill_bulk_urb(dev->in_urb, dev->udev,
5d467742
WR		 3044 usb_rcvbulkpipe(dev->udev, in_endpoint),
3045 NULL, 0, NULL, dev);
c46ee386 3046 usb_fill_bulk_urb(dev->out_urb, dev->udev,
5d467742
WR		 3047 usb_sndbulkpipe(dev->udev, out_endpoint),
3048 NULL, 0, pn533_send_complete, dev);
c46ee386 3049
5d50b364
SO		 3050 INIT_WORK(&dev->cmd_work, pn533_wq_cmd);
3051 INIT_WORK(&dev->cmd_complete_work, pn533_wq_cmd_complete);
963a82e0
OG		 3052 INIT_WORK(&dev->mi_rx_work, pn533_wq_mi_recv);
3053 INIT_WORK(&dev->mi_tx_work, pn533_wq_mi_send);
103b34cf 3054 INIT_WORK(&dev->tg_work, pn533_wq_tg_get_data);
46f793b0 3055 INIT_DELAYED_WORK(&dev->poll_work, pn533_wq_poll);
17e9d9d4 3056 INIT_WORK(&dev->rf_work, pn533_wq_rf);
58637c9b 3057 dev->wq = alloc_ordered_workqueue("pn533", 0);
4849f85e
SO		 3058 if (dev->wq == NULL)
3059 goto error;
c46ee386 3060
6fbbdc16
SO		 3061 init_timer(&dev->listen_timer);
3062 dev->listen_timer.data = (unsigned long) dev;
3063 dev->listen_timer.function = pn533_listen_mode_timer;
3064
6ff73fd2 3065 skb_queue_head_init(&dev->resp_q);
963a82e0 3066 skb_queue_head_init(&dev->fragment_skb);
6ff73fd2 3067
5d50b364
SO		 3068 INIT_LIST_HEAD(&dev->cmd_queue);
3069
c46ee386
AAJ		 3070 usb_set_intfdata(interface, dev);
3071
9e2d493e 3072 dev->ops = &pn533_std_frame_ops;
c46ee386 3073
58520373 3074 dev->protocol_type = PN533_PROTO_REQ_ACK_RESP;
5c7b0531
SO		 3075 dev->device_type = id->driver_info;
3076 switch (dev->device_type) {
3077 case PN533_DEVICE_STD:
3078 protocols = PN533_ALL_PROTOCOLS;
3079 break;
3080
3081 case PN533_DEVICE_PASORI:
3082 protocols = PN533_NO_TYPE_B_PROTOCOLS;
3083 break;
3084
53cf4839
WR		 3085 case PN533_DEVICE_ACR122U:
3086 protocols = PN533_NO_TYPE_B_PROTOCOLS;
3087 dev->ops = &pn533_acr122_frame_ops;
3088 dev->protocol_type = PN533_PROTO_REQ_RESP,
3089
3090 rc = pn533_acr122_poweron_rdr(dev);
3091 if (rc < 0) {
073a625f
JP		 3092 nfc_err(&dev->interface->dev,
3093 "Couldn't poweron the reader (error %d)\n", rc);
53cf4839
WR		 3094 goto destroy_wq;
3095 }
3096 break;
3097
5c7b0531 3098 default:
073a625f
JP		 3099 nfc_err(&dev->interface->dev, "Unknown device type %d\n",
3100 dev->device_type);
5c7b0531
SO		 3101 rc = -EINVAL;
3102 goto destroy_wq;
3103 }
c46ee386 3104
9e2d493e
WR		 3105 memset(&fw_ver, 0, sizeof(fw_ver));
3106 rc = pn533_get_firmware_version(dev, &fw_ver);
3107 if (rc < 0)
3108 goto destroy_wq;
3109
073a625f
JP		 3110 nfc_info(&dev->interface->dev,
3111 "NXP PN5%02X firmware ver %d.%d now attached\n",
3112 fw_ver.ic, fw_ver.ver, fw_ver.rev);
9e2d493e
WR		 3113
3114
e8753043 3115 dev->nfc_dev = nfc_allocate_device(&pn533_nfc_ops, protocols,
9e2d493e 3116 dev->ops->tx_header_len +
e8753043 3117 PN533_CMD_DATAEXCH_HEAD_LEN,
9e2d493e 3118 dev->ops->tx_tail_len);
4674d0fe
WY		 3119 if (!dev->nfc_dev) {
3120 rc = -ENOMEM;
4849f85e 3121 goto destroy_wq;
4674d0fe 3122 }
c46ee386
AAJ		 3123
3124 nfc_set_parent_dev(dev->nfc_dev, &interface->dev);
3125 nfc_set_drvdata(dev->nfc_dev, dev);
3126
3127 rc = nfc_register_device(dev->nfc_dev);
3128 if (rc)
3129 goto free_nfc_dev;
3130
5c7b0531
SO		 3131 rc = pn533_setup(dev);
3132 if (rc)
34a85bfc 3133 goto unregister_nfc_dev;
34a85bfc 3134
c46ee386
AAJ		 3135 return 0;
3136
9f2f8ba1
SO		 3137unregister_nfc_dev:
3138 nfc_unregister_device(dev->nfc_dev);
3139
c46ee386
AAJ		 3140free_nfc_dev:
3141 nfc_free_device(dev->nfc_dev);
9f2f8ba1 3142
4849f85e
SO		 3143destroy_wq:
3144 destroy_workqueue(dev->wq);
c46ee386 3145error:
c46ee386 3146 usb_free_urb(dev->in_urb);
c46ee386 3147 usb_free_urb(dev->out_urb);
7c5a54fb 3148 usb_put_dev(dev->udev);
c46ee386
AAJ		 3149 kfree(dev);
3150 return rc;
3151}
3152
3153static void pn533_disconnect(struct usb_interface *interface)
3154{
3155 struct pn533 *dev;
5d50b364 3156 struct pn533_cmd *cmd, *n;
c46ee386
AAJ		 3157
3158 dev = usb_get_intfdata(interface);
3159 usb_set_intfdata(interface, NULL);
3160
3161 nfc_unregister_device(dev->nfc_dev);
3162 nfc_free_device(dev->nfc_dev);
3163
3164 usb_kill_urb(dev->in_urb);
3165 usb_kill_urb(dev->out_urb);
3166
46f793b0 3167 flush_delayed_work(&dev->poll_work);
4849f85e 3168 destroy_workqueue(dev->wq);
c46ee386 3169
6ff73fd2
SO		 3170 skb_queue_purge(&dev->resp_q);
3171
6fbbdc16
SO		 3172 del_timer(&dev->listen_timer);
3173
5d50b364
SO		 3174 list_for_each_entry_safe(cmd, n, &dev->cmd_queue, queue) {
3175 list_del(&cmd->queue);
3176 kfree(cmd);
3177 }
3178
c46ee386 3179 usb_free_urb(dev->in_urb);
c46ee386
AAJ		 3180 usb_free_urb(dev->out_urb);
3181 kfree(dev);
3182
073a625f 3183 nfc_info(&interface->dev, "NXP PN533 NFC device disconnected\n");
c46ee386
AAJ		 3184}
3185
3186static struct usb_driver pn533_driver = {
3187 .name = "pn533",
3188 .probe = pn533_probe,
3189 .disconnect = pn533_disconnect,
3190 .id_table = pn533_table,
3191};
3192
fe748483 3193module_usb_driver(pn533_driver);
c46ee386 3194
e70b96e9
WR		 3195MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
3196MODULE_AUTHOR("Aloisio Almeida Jr <aloisio.almeida@openbossa.org>");
3197MODULE_AUTHOR("Waldemar Rymarkiewicz <waldemar.rymarkiewicz@tieto.com>");
c46ee386
AAJ		 3198MODULE_DESCRIPTION("PN533 usb driver ver " VERSION);
3199MODULE_VERSION(VERSION);
3200MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 1.425804 seconds and 5 git commands to generate.