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