1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2014 STMicroelectronics SAS. All rights reserved. 4 */ 5 6 #include <net/nfc/hci.h> 7 8 #include "st21nfca.h" 9 10 #define ST21NFCA_NFCIP1_INITIATOR 0x00 11 #define ST21NFCA_NFCIP1_REQ 0xd4 12 #define ST21NFCA_NFCIP1_RES 0xd5 13 #define ST21NFCA_NFCIP1_ATR_REQ 0x00 14 #define ST21NFCA_NFCIP1_ATR_RES 0x01 15 #define ST21NFCA_NFCIP1_PSL_REQ 0x04 16 #define ST21NFCA_NFCIP1_PSL_RES 0x05 17 #define ST21NFCA_NFCIP1_DEP_REQ 0x06 18 #define ST21NFCA_NFCIP1_DEP_RES 0x07 19 20 #define ST21NFCA_NFC_DEP_PFB_PNI(pfb) ((pfb) & 0x03) 21 #define ST21NFCA_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0) 22 #define ST21NFCA_NFC_DEP_PFB_IS_TIMEOUT(pfb) \ 23 ((pfb) & ST21NFCA_NFC_DEP_PFB_TIMEOUT_BIT) 24 #define ST21NFCA_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & 0x04) 25 #define ST21NFCA_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08) 26 #define ST21NFCA_NFC_DEP_PFB_TIMEOUT_BIT 0x10 27 28 #define ST21NFCA_NFC_DEP_PFB_IS_TIMEOUT(pfb) \ 29 ((pfb) & ST21NFCA_NFC_DEP_PFB_TIMEOUT_BIT) 30 31 #define ST21NFCA_NFC_DEP_PFB_I_PDU 0x00 32 #define ST21NFCA_NFC_DEP_PFB_ACK_NACK_PDU 0x40 33 #define ST21NFCA_NFC_DEP_PFB_SUPERVISOR_PDU 0x80 34 35 #define ST21NFCA_ATR_REQ_MIN_SIZE 17 36 #define ST21NFCA_ATR_REQ_MAX_SIZE 65 37 #define ST21NFCA_LR_BITS_PAYLOAD_SIZE_254B 0x30 38 #define ST21NFCA_GB_BIT 0x02 39 40 #define ST21NFCA_EVT_SEND_DATA 0x10 41 #define ST21NFCA_EVT_FIELD_ON 0x11 42 #define ST21NFCA_EVT_CARD_DEACTIVATED 0x12 43 #define ST21NFCA_EVT_CARD_ACTIVATED 0x13 44 #define ST21NFCA_EVT_FIELD_OFF 0x14 45 46 #define ST21NFCA_EVT_CARD_F_BITRATE 0x16 47 #define ST21NFCA_EVT_READER_F_BITRATE 0x13 48 #define ST21NFCA_PSL_REQ_SEND_SPEED(brs) (brs & 0x38) 49 #define ST21NFCA_PSL_REQ_RECV_SPEED(brs) (brs & 0x07) 50 #define ST21NFCA_PP2LRI(pp) ((pp & 0x30) >> 4) 51 #define ST21NFCA_CARD_BITRATE_212 0x01 52 #define ST21NFCA_CARD_BITRATE_424 0x02 53 54 #define ST21NFCA_DEFAULT_TIMEOUT 0x0a 55 56 57 #define PROTOCOL_ERR(req) pr_err("%d: ST21NFCA Protocol error: %s\n", \ 58 __LINE__, req) 59 60 struct st21nfca_atr_req { 61 u8 length; 62 u8 cmd0; 63 u8 cmd1; 64 u8 nfcid3[NFC_NFCID3_MAXSIZE]; 65 u8 did; 66 u8 bsi; 67 u8 bri; 68 u8 ppi; 69 u8 gbi[]; 70 } __packed; 71 72 struct st21nfca_atr_res { 73 u8 length; 74 u8 cmd0; 75 u8 cmd1; 76 u8 nfcid3[NFC_NFCID3_MAXSIZE]; 77 u8 did; 78 u8 bsi; 79 u8 bri; 80 u8 to; 81 u8 ppi; 82 u8 gbi[]; 83 } __packed; 84 85 struct st21nfca_psl_req { 86 u8 length; 87 u8 cmd0; 88 u8 cmd1; 89 u8 did; 90 u8 brs; 91 u8 fsl; 92 } __packed; 93 94 struct st21nfca_psl_res { 95 u8 length; 96 u8 cmd0; 97 u8 cmd1; 98 u8 did; 99 } __packed; 100 101 struct st21nfca_dep_req_res { 102 u8 length; 103 u8 cmd0; 104 u8 cmd1; 105 u8 pfb; 106 u8 did; 107 u8 nad; 108 } __packed; 109 110 static void st21nfca_tx_work(struct work_struct *work) 111 { 112 struct st21nfca_hci_info *info = container_of(work, 113 struct st21nfca_hci_info, 114 dep_info.tx_work); 115 116 struct nfc_dev *dev; 117 struct sk_buff *skb; 118 119 if (info) { 120 dev = info->hdev->ndev; 121 skb = info->dep_info.tx_pending; 122 123 device_lock(&dev->dev); 124 125 nfc_hci_send_cmd_async(info->hdev, ST21NFCA_RF_READER_F_GATE, 126 ST21NFCA_WR_XCHG_DATA, skb->data, skb->len, 127 info->async_cb, info); 128 device_unlock(&dev->dev); 129 kfree_skb(skb); 130 } 131 } 132 133 static void st21nfca_im_send_pdu(struct st21nfca_hci_info *info, 134 struct sk_buff *skb) 135 { 136 info->dep_info.tx_pending = skb; 137 schedule_work(&info->dep_info.tx_work); 138 } 139 140 static int st21nfca_tm_send_atr_res(struct nfc_hci_dev *hdev, 141 struct st21nfca_atr_req *atr_req) 142 { 143 struct st21nfca_atr_res *atr_res; 144 struct sk_buff *skb; 145 size_t gb_len; 146 int r; 147 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev); 148 149 gb_len = atr_req->length - sizeof(struct st21nfca_atr_req); 150 skb = alloc_skb(atr_req->length + 1, GFP_KERNEL); 151 if (!skb) 152 return -ENOMEM; 153 154 skb_put(skb, sizeof(struct st21nfca_atr_res)); 155 156 atr_res = (struct st21nfca_atr_res *)skb->data; 157 memset(atr_res, 0, sizeof(struct st21nfca_atr_res)); 158 159 atr_res->length = atr_req->length + 1; 160 atr_res->cmd0 = ST21NFCA_NFCIP1_RES; 161 atr_res->cmd1 = ST21NFCA_NFCIP1_ATR_RES; 162 163 memcpy(atr_res->nfcid3, atr_req->nfcid3, 6); 164 atr_res->bsi = 0x00; 165 atr_res->bri = 0x00; 166 atr_res->to = ST21NFCA_DEFAULT_TIMEOUT; 167 atr_res->ppi = ST21NFCA_LR_BITS_PAYLOAD_SIZE_254B; 168 169 if (gb_len) { 170 skb_put(skb, gb_len); 171 172 atr_res->ppi |= ST21NFCA_GB_BIT; 173 memcpy(atr_res->gbi, atr_req->gbi, gb_len); 174 r = nfc_set_remote_general_bytes(hdev->ndev, atr_res->gbi, 175 gb_len); 176 if (r < 0) 177 return r; 178 } 179 180 info->dep_info.curr_nfc_dep_pni = 0; 181 182 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE, 183 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len); 184 kfree_skb(skb); 185 return r; 186 } 187 188 static int st21nfca_tm_recv_atr_req(struct nfc_hci_dev *hdev, 189 struct sk_buff *skb) 190 { 191 struct st21nfca_atr_req *atr_req; 192 size_t gb_len; 193 int r; 194 195 skb_trim(skb, skb->len - 1); 196 197 if (!skb->len) { 198 r = -EIO; 199 goto exit; 200 } 201 202 if (skb->len < ST21NFCA_ATR_REQ_MIN_SIZE) { 203 r = -EPROTO; 204 goto exit; 205 } 206 207 atr_req = (struct st21nfca_atr_req *)skb->data; 208 209 if (atr_req->length < sizeof(struct st21nfca_atr_req)) { 210 r = -EPROTO; 211 goto exit; 212 } 213 214 r = st21nfca_tm_send_atr_res(hdev, atr_req); 215 if (r) 216 goto exit; 217 218 gb_len = skb->len - sizeof(struct st21nfca_atr_req); 219 220 r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK, 221 NFC_COMM_PASSIVE, atr_req->gbi, gb_len); 222 if (r) 223 goto exit; 224 225 r = 0; 226 227 exit: 228 return r; 229 } 230 231 static int st21nfca_tm_send_psl_res(struct nfc_hci_dev *hdev, 232 struct st21nfca_psl_req *psl_req) 233 { 234 struct st21nfca_psl_res *psl_res; 235 struct sk_buff *skb; 236 u8 bitrate[2] = {0, 0}; 237 int r; 238 239 skb = alloc_skb(sizeof(struct st21nfca_psl_res), GFP_KERNEL); 240 if (!skb) 241 return -ENOMEM; 242 skb_put(skb, sizeof(struct st21nfca_psl_res)); 243 244 psl_res = (struct st21nfca_psl_res *)skb->data; 245 246 psl_res->length = sizeof(struct st21nfca_psl_res); 247 psl_res->cmd0 = ST21NFCA_NFCIP1_RES; 248 psl_res->cmd1 = ST21NFCA_NFCIP1_PSL_RES; 249 psl_res->did = psl_req->did; 250 251 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE, 252 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len); 253 if (r < 0) 254 goto error; 255 256 /* 257 * ST21NFCA only support P2P passive. 258 * PSL_REQ BRS value != 0 has only a meaning to 259 * change technology to type F. 260 * We change to BITRATE 424Kbits. 261 * In other case switch to BITRATE 106Kbits. 262 */ 263 if (ST21NFCA_PSL_REQ_SEND_SPEED(psl_req->brs) && 264 ST21NFCA_PSL_REQ_RECV_SPEED(psl_req->brs)) { 265 bitrate[0] = ST21NFCA_CARD_BITRATE_424; 266 bitrate[1] = ST21NFCA_CARD_BITRATE_424; 267 } 268 269 /* Send an event to change bitrate change event to card f */ 270 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE, 271 ST21NFCA_EVT_CARD_F_BITRATE, bitrate, 2); 272 error: 273 kfree_skb(skb); 274 return r; 275 } 276 277 static int st21nfca_tm_recv_psl_req(struct nfc_hci_dev *hdev, 278 struct sk_buff *skb) 279 { 280 struct st21nfca_psl_req *psl_req; 281 int r; 282 283 skb_trim(skb, skb->len - 1); 284 285 if (!skb->len) { 286 r = -EIO; 287 goto exit; 288 } 289 290 psl_req = (struct st21nfca_psl_req *)skb->data; 291 292 if (skb->len < sizeof(struct st21nfca_psl_req)) { 293 r = -EIO; 294 goto exit; 295 } 296 297 r = st21nfca_tm_send_psl_res(hdev, psl_req); 298 exit: 299 return r; 300 } 301 302 int st21nfca_tm_send_dep_res(struct nfc_hci_dev *hdev, struct sk_buff *skb) 303 { 304 int r; 305 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev); 306 307 *(u8 *)skb_push(skb, 1) = info->dep_info.curr_nfc_dep_pni; 308 *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_DEP_RES; 309 *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_RES; 310 *(u8 *)skb_push(skb, 1) = skb->len; 311 312 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE, 313 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len); 314 kfree_skb(skb); 315 316 return r; 317 } 318 EXPORT_SYMBOL(st21nfca_tm_send_dep_res); 319 320 static int st21nfca_tm_recv_dep_req(struct nfc_hci_dev *hdev, 321 struct sk_buff *skb) 322 { 323 struct st21nfca_dep_req_res *dep_req; 324 u8 size; 325 int r; 326 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev); 327 328 skb_trim(skb, skb->len - 1); 329 330 size = 4; 331 332 dep_req = (struct st21nfca_dep_req_res *)skb->data; 333 if (skb->len < size) { 334 r = -EIO; 335 goto exit; 336 } 337 338 if (ST21NFCA_NFC_DEP_DID_BIT_SET(dep_req->pfb)) 339 size++; 340 if (ST21NFCA_NFC_DEP_NAD_BIT_SET(dep_req->pfb)) 341 size++; 342 343 if (skb->len < size) { 344 r = -EIO; 345 goto exit; 346 } 347 348 /* Receiving DEP_REQ - Decoding */ 349 switch (ST21NFCA_NFC_DEP_PFB_TYPE(dep_req->pfb)) { 350 case ST21NFCA_NFC_DEP_PFB_I_PDU: 351 info->dep_info.curr_nfc_dep_pni = 352 ST21NFCA_NFC_DEP_PFB_PNI(dep_req->pfb); 353 break; 354 case ST21NFCA_NFC_DEP_PFB_ACK_NACK_PDU: 355 pr_err("Received a ACK/NACK PDU\n"); 356 break; 357 case ST21NFCA_NFC_DEP_PFB_SUPERVISOR_PDU: 358 pr_err("Received a SUPERVISOR PDU\n"); 359 break; 360 } 361 362 skb_pull(skb, size); 363 364 return nfc_tm_data_received(hdev->ndev, skb); 365 exit: 366 return r; 367 } 368 369 static int st21nfca_tm_event_send_data(struct nfc_hci_dev *hdev, 370 struct sk_buff *skb) 371 { 372 u8 cmd0, cmd1; 373 int r; 374 375 cmd0 = skb->data[1]; 376 switch (cmd0) { 377 case ST21NFCA_NFCIP1_REQ: 378 cmd1 = skb->data[2]; 379 switch (cmd1) { 380 case ST21NFCA_NFCIP1_ATR_REQ: 381 r = st21nfca_tm_recv_atr_req(hdev, skb); 382 break; 383 case ST21NFCA_NFCIP1_PSL_REQ: 384 r = st21nfca_tm_recv_psl_req(hdev, skb); 385 break; 386 case ST21NFCA_NFCIP1_DEP_REQ: 387 r = st21nfca_tm_recv_dep_req(hdev, skb); 388 break; 389 default: 390 return 1; 391 } 392 break; 393 default: 394 return 1; 395 } 396 return r; 397 } 398 399 /* 400 * Returns: 401 * <= 0: driver handled the event, skb consumed 402 * 1: driver does not handle the event, please do standard processing 403 */ 404 int st21nfca_dep_event_received(struct nfc_hci_dev *hdev, 405 u8 event, struct sk_buff *skb) 406 { 407 int r = 0; 408 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev); 409 410 pr_debug("dep event: %d\n", event); 411 412 switch (event) { 413 case ST21NFCA_EVT_CARD_ACTIVATED: 414 info->dep_info.curr_nfc_dep_pni = 0; 415 break; 416 case ST21NFCA_EVT_CARD_DEACTIVATED: 417 break; 418 case ST21NFCA_EVT_FIELD_ON: 419 break; 420 case ST21NFCA_EVT_FIELD_OFF: 421 break; 422 case ST21NFCA_EVT_SEND_DATA: 423 r = st21nfca_tm_event_send_data(hdev, skb); 424 if (r < 0) 425 return r; 426 return 0; 427 default: 428 nfc_err(&hdev->ndev->dev, "Unexpected event on card f gate\n"); 429 return 1; 430 } 431 kfree_skb(skb); 432 return r; 433 } 434 EXPORT_SYMBOL(st21nfca_dep_event_received); 435 436 static void st21nfca_im_send_psl_req(struct nfc_hci_dev *hdev, u8 did, u8 bsi, 437 u8 bri, u8 lri) 438 { 439 struct sk_buff *skb; 440 struct st21nfca_psl_req *psl_req; 441 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev); 442 443 skb = 444 alloc_skb(sizeof(struct st21nfca_psl_req) + 1, GFP_KERNEL); 445 if (!skb) 446 return; 447 skb_reserve(skb, 1); 448 449 skb_put(skb, sizeof(struct st21nfca_psl_req)); 450 psl_req = (struct st21nfca_psl_req *) skb->data; 451 452 psl_req->length = sizeof(struct st21nfca_psl_req); 453 psl_req->cmd0 = ST21NFCA_NFCIP1_REQ; 454 psl_req->cmd1 = ST21NFCA_NFCIP1_PSL_REQ; 455 psl_req->did = did; 456 psl_req->brs = (0x30 & bsi << 4) | (bri & 0x03); 457 psl_req->fsl = lri; 458 459 *(u8 *)skb_push(skb, 1) = info->dep_info.to | 0x10; 460 461 st21nfca_im_send_pdu(info, skb); 462 } 463 464 #define ST21NFCA_CB_TYPE_READER_F 1 465 static void st21nfca_im_recv_atr_res_cb(void *context, struct sk_buff *skb, 466 int err) 467 { 468 struct st21nfca_hci_info *info = context; 469 struct st21nfca_atr_res *atr_res; 470 int r; 471 472 if (err != 0) 473 return; 474 475 if (!skb) 476 return; 477 478 switch (info->async_cb_type) { 479 case ST21NFCA_CB_TYPE_READER_F: 480 skb_trim(skb, skb->len - 1); 481 atr_res = (struct st21nfca_atr_res *)skb->data; 482 r = nfc_set_remote_general_bytes(info->hdev->ndev, 483 atr_res->gbi, 484 skb->len - sizeof(struct st21nfca_atr_res)); 485 if (r < 0) 486 return; 487 488 if (atr_res->to >= 0x0e) 489 info->dep_info.to = 0x0e; 490 else 491 info->dep_info.to = atr_res->to + 1; 492 493 info->dep_info.to |= 0x10; 494 495 r = nfc_dep_link_is_up(info->hdev->ndev, info->dep_info.idx, 496 NFC_COMM_PASSIVE, NFC_RF_INITIATOR); 497 if (r < 0) 498 return; 499 500 info->dep_info.curr_nfc_dep_pni = 0; 501 if (ST21NFCA_PP2LRI(atr_res->ppi) != info->dep_info.lri) 502 st21nfca_im_send_psl_req(info->hdev, atr_res->did, 503 atr_res->bsi, atr_res->bri, 504 ST21NFCA_PP2LRI(atr_res->ppi)); 505 break; 506 default: 507 kfree_skb(skb); 508 break; 509 } 510 } 511 512 int st21nfca_im_send_atr_req(struct nfc_hci_dev *hdev, u8 *gb, size_t gb_len) 513 { 514 struct sk_buff *skb; 515 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev); 516 struct st21nfca_atr_req *atr_req; 517 struct nfc_target *target; 518 uint size; 519 520 info->dep_info.to = ST21NFCA_DEFAULT_TIMEOUT; 521 size = ST21NFCA_ATR_REQ_MIN_SIZE + gb_len; 522 if (size > ST21NFCA_ATR_REQ_MAX_SIZE) { 523 PROTOCOL_ERR("14.6.1.1"); 524 return -EINVAL; 525 } 526 527 skb = 528 alloc_skb(sizeof(struct st21nfca_atr_req) + gb_len + 1, GFP_KERNEL); 529 if (!skb) 530 return -ENOMEM; 531 532 skb_reserve(skb, 1); 533 534 skb_put(skb, sizeof(struct st21nfca_atr_req)); 535 536 atr_req = (struct st21nfca_atr_req *)skb->data; 537 memset(atr_req, 0, sizeof(struct st21nfca_atr_req)); 538 539 atr_req->cmd0 = ST21NFCA_NFCIP1_REQ; 540 atr_req->cmd1 = ST21NFCA_NFCIP1_ATR_REQ; 541 memset(atr_req->nfcid3, 0, NFC_NFCID3_MAXSIZE); 542 target = hdev->ndev->targets; 543 544 if (target->sensf_res_len > 0) 545 memcpy(atr_req->nfcid3, target->sensf_res, 546 target->sensf_res_len); 547 else 548 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE); 549 550 atr_req->did = 0x0; 551 552 atr_req->bsi = 0x00; 553 atr_req->bri = 0x00; 554 atr_req->ppi = ST21NFCA_LR_BITS_PAYLOAD_SIZE_254B; 555 if (gb_len) { 556 atr_req->ppi |= ST21NFCA_GB_BIT; 557 skb_put_data(skb, gb, gb_len); 558 } 559 atr_req->length = sizeof(struct st21nfca_atr_req) + hdev->gb_len; 560 561 *(u8 *)skb_push(skb, 1) = info->dep_info.to | 0x10; /* timeout */ 562 563 info->async_cb_type = ST21NFCA_CB_TYPE_READER_F; 564 info->async_cb_context = info; 565 info->async_cb = st21nfca_im_recv_atr_res_cb; 566 info->dep_info.bri = atr_req->bri; 567 info->dep_info.bsi = atr_req->bsi; 568 info->dep_info.lri = ST21NFCA_PP2LRI(atr_req->ppi); 569 570 return nfc_hci_send_cmd_async(hdev, ST21NFCA_RF_READER_F_GATE, 571 ST21NFCA_WR_XCHG_DATA, skb->data, 572 skb->len, info->async_cb, info); 573 } 574 EXPORT_SYMBOL(st21nfca_im_send_atr_req); 575 576 static void st21nfca_im_recv_dep_res_cb(void *context, struct sk_buff *skb, 577 int err) 578 { 579 struct st21nfca_hci_info *info = context; 580 struct st21nfca_dep_req_res *dep_res; 581 582 int size; 583 584 if (err != 0) 585 return; 586 587 if (!skb) 588 return; 589 590 switch (info->async_cb_type) { 591 case ST21NFCA_CB_TYPE_READER_F: 592 dep_res = (struct st21nfca_dep_req_res *)skb->data; 593 594 size = 3; 595 if (skb->len < size) 596 goto exit; 597 598 if (ST21NFCA_NFC_DEP_DID_BIT_SET(dep_res->pfb)) 599 size++; 600 if (ST21NFCA_NFC_DEP_NAD_BIT_SET(dep_res->pfb)) 601 size++; 602 603 if (skb->len < size) 604 goto exit; 605 606 skb_trim(skb, skb->len - 1); 607 608 /* Receiving DEP_REQ - Decoding */ 609 switch (ST21NFCA_NFC_DEP_PFB_TYPE(dep_res->pfb)) { 610 case ST21NFCA_NFC_DEP_PFB_ACK_NACK_PDU: 611 pr_err("Received a ACK/NACK PDU\n"); 612 /* fall through */ 613 case ST21NFCA_NFC_DEP_PFB_I_PDU: 614 info->dep_info.curr_nfc_dep_pni = 615 ST21NFCA_NFC_DEP_PFB_PNI(dep_res->pfb + 1); 616 size++; 617 skb_pull(skb, size); 618 nfc_tm_data_received(info->hdev->ndev, skb); 619 break; 620 case ST21NFCA_NFC_DEP_PFB_SUPERVISOR_PDU: 621 pr_err("Received a SUPERVISOR PDU\n"); 622 skb_pull(skb, size); 623 *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_DEP_REQ; 624 *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_REQ; 625 *(u8 *)skb_push(skb, 1) = skb->len; 626 *(u8 *)skb_push(skb, 1) = info->dep_info.to | 0x10; 627 628 st21nfca_im_send_pdu(info, skb); 629 break; 630 } 631 632 return; 633 default: 634 break; 635 } 636 637 exit: 638 kfree_skb(skb); 639 } 640 641 int st21nfca_im_send_dep_req(struct nfc_hci_dev *hdev, struct sk_buff *skb) 642 { 643 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev); 644 645 info->async_cb_type = ST21NFCA_CB_TYPE_READER_F; 646 info->async_cb_context = info; 647 info->async_cb = st21nfca_im_recv_dep_res_cb; 648 649 *(u8 *)skb_push(skb, 1) = info->dep_info.curr_nfc_dep_pni; 650 *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_DEP_REQ; 651 *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_REQ; 652 *(u8 *)skb_push(skb, 1) = skb->len; 653 654 *(u8 *)skb_push(skb, 1) = info->dep_info.to | 0x10; 655 656 return nfc_hci_send_cmd_async(hdev, ST21NFCA_RF_READER_F_GATE, 657 ST21NFCA_WR_XCHG_DATA, 658 skb->data, skb->len, 659 info->async_cb, info); 660 } 661 EXPORT_SYMBOL(st21nfca_im_send_dep_req); 662 663 void st21nfca_dep_init(struct nfc_hci_dev *hdev) 664 { 665 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev); 666 667 INIT_WORK(&info->dep_info.tx_work, st21nfca_tx_work); 668 info->dep_info.curr_nfc_dep_pni = 0; 669 info->dep_info.idx = 0; 670 info->dep_info.to = ST21NFCA_DEFAULT_TIMEOUT; 671 } 672 EXPORT_SYMBOL(st21nfca_dep_init); 673 674 void st21nfca_dep_deinit(struct nfc_hci_dev *hdev) 675 { 676 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev); 677 678 cancel_work_sync(&info->dep_info.tx_work); 679 } 680 EXPORT_SYMBOL(st21nfca_dep_deinit); 681