drivers/nfc/st21nfca/dep.c

   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                         kfree_skb(skb);
 178                         return r;
 179                 }
 180         }
 181
 182         info->dep_info.curr_nfc_dep_pni = 0;
 183
 184         r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
 185                                 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len);
 186         kfree_skb(skb);
 187         return r;
 188 }
 189
 190 static int st21nfca_tm_recv_atr_req(struct nfc_hci_dev *hdev,
 191                                     struct sk_buff *skb)
 192 {
 193         struct st21nfca_atr_req *atr_req;
 194         size_t gb_len;
 195         int r;
 196
 197         skb_trim(skb, skb->len - 1);
 198
 199         if (!skb->len) {
 200                 r = -EIO;
 201                 goto exit;
 202         }
 203
 204         if (skb->len < ST21NFCA_ATR_REQ_MIN_SIZE) {
 205                 r = -EPROTO;
 206                 goto exit;
 207         }
 208
 209         atr_req = (struct st21nfca_atr_req *)skb->data;
 210
 211         if (atr_req->length < sizeof(struct st21nfca_atr_req)) {
 212                 r = -EPROTO;
 213                 goto exit;
 214         }
 215
 216         r = st21nfca_tm_send_atr_res(hdev, atr_req);
 217         if (r)
 218                 goto exit;
 219
 220         gb_len = skb->len - sizeof(struct st21nfca_atr_req);
 221
 222         r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK,
 223                               NFC_COMM_PASSIVE, atr_req->gbi, gb_len);
 224         if (r)
 225                 goto exit;
 226
 227         r = 0;
 228
 229 exit:
 230         return r;
 231 }
 232
 233 static int st21nfca_tm_send_psl_res(struct nfc_hci_dev *hdev,
 234                                     struct st21nfca_psl_req *psl_req)
 235 {
 236         struct st21nfca_psl_res *psl_res;
 237         struct sk_buff *skb;
 238         u8 bitrate[2] = {0, 0};
 239         int r;
 240
 241         skb = alloc_skb(sizeof(struct st21nfca_psl_res), GFP_KERNEL);
 242         if (!skb)
 243                 return -ENOMEM;
 244         skb_put(skb, sizeof(struct st21nfca_psl_res));
 245
 246         psl_res = (struct st21nfca_psl_res *)skb->data;
 247
 248         psl_res->length = sizeof(struct st21nfca_psl_res);
 249         psl_res->cmd0 = ST21NFCA_NFCIP1_RES;
 250         psl_res->cmd1 = ST21NFCA_NFCIP1_PSL_RES;
 251         psl_res->did = psl_req->did;
 252
 253         r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
 254                                 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len);
 255         if (r < 0)
 256                 goto error;
 257
 258         /*
 259          * ST21NFCA only support P2P passive.
 260          * PSL_REQ BRS value != 0 has only a meaning to
 261          * change technology to type F.
 262          * We change to BITRATE 424Kbits.
 263          * In other case switch to BITRATE 106Kbits.
 264          */
 265         if (ST21NFCA_PSL_REQ_SEND_SPEED(psl_req->brs) &&
 266             ST21NFCA_PSL_REQ_RECV_SPEED(psl_req->brs)) {
 267                 bitrate[0] = ST21NFCA_CARD_BITRATE_424;
 268                 bitrate[1] = ST21NFCA_CARD_BITRATE_424;
 269         }
 270
 271         /* Send an event to change bitrate change event to card f */
 272         r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
 273                         ST21NFCA_EVT_CARD_F_BITRATE, bitrate, 2);
 274 error:
 275         kfree_skb(skb);
 276         return r;
 277 }
 278
 279 static int st21nfca_tm_recv_psl_req(struct nfc_hci_dev *hdev,
 280                                     struct sk_buff *skb)
 281 {
 282         struct st21nfca_psl_req *psl_req;
 283         int r;
 284
 285         skb_trim(skb, skb->len - 1);
 286
 287         if (!skb->len) {
 288                 r = -EIO;
 289                 goto exit;
 290         }
 291
 292         psl_req = (struct st21nfca_psl_req *)skb->data;
 293
 294         if (skb->len < sizeof(struct st21nfca_psl_req)) {
 295                 r = -EIO;
 296                 goto exit;
 297         }
 298
 299         r = st21nfca_tm_send_psl_res(hdev, psl_req);
 300 exit:
 301         return r;
 302 }
 303
 304 int st21nfca_tm_send_dep_res(struct nfc_hci_dev *hdev, struct sk_buff *skb)
 305 {
 306         int r;
 307         struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
 308
 309         *(u8 *)skb_push(skb, 1) = info->dep_info.curr_nfc_dep_pni;
 310         *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_DEP_RES;
 311         *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_RES;
 312         *(u8 *)skb_push(skb, 1) = skb->len;
 313
 314         r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
 315                         ST21NFCA_EVT_SEND_DATA, skb->data, skb->len);
 316         kfree_skb(skb);
 317
 318         return r;
 319 }
 320 EXPORT_SYMBOL(st21nfca_tm_send_dep_res);
 321
 322 static int st21nfca_tm_recv_dep_req(struct nfc_hci_dev *hdev,
 323                                     struct sk_buff *skb)
 324 {
 325         struct st21nfca_dep_req_res *dep_req;
 326         u8 size;
 327         int r;
 328         struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
 329
 330         skb_trim(skb, skb->len - 1);
 331
 332         size = 4;
 333
 334         dep_req = (struct st21nfca_dep_req_res *)skb->data;
 335         if (skb->len < size) {
 336                 r = -EIO;
 337                 goto exit;
 338         }
 339
 340         if (ST21NFCA_NFC_DEP_DID_BIT_SET(dep_req->pfb))
 341                 size++;
 342         if (ST21NFCA_NFC_DEP_NAD_BIT_SET(dep_req->pfb))
 343                 size++;
 344
 345         if (skb->len < size) {
 346                 r = -EIO;
 347                 goto exit;
 348         }
 349
 350         /* Receiving DEP_REQ - Decoding */
 351         switch (ST21NFCA_NFC_DEP_PFB_TYPE(dep_req->pfb)) {
 352         case ST21NFCA_NFC_DEP_PFB_I_PDU:
 353                 info->dep_info.curr_nfc_dep_pni =
 354                                 ST21NFCA_NFC_DEP_PFB_PNI(dep_req->pfb);
 355                 break;
 356         case ST21NFCA_NFC_DEP_PFB_ACK_NACK_PDU:
 357                 pr_err("Received a ACK/NACK PDU\n");
 358                 break;
 359         case ST21NFCA_NFC_DEP_PFB_SUPERVISOR_PDU:
 360                 pr_err("Received a SUPERVISOR PDU\n");
 361                 break;
 362         }
 363
 364         skb_pull(skb, size);
 365
 366         return nfc_tm_data_received(hdev->ndev, skb);
 367 exit:
 368         return r;
 369 }
 370
 371 static int st21nfca_tm_event_send_data(struct nfc_hci_dev *hdev,
 372                                 struct sk_buff *skb)
 373 {
 374         u8 cmd0, cmd1;
 375         int r;
 376
 377         cmd0 = skb->data[1];
 378         switch (cmd0) {
 379         case ST21NFCA_NFCIP1_REQ:
 380                 cmd1 = skb->data[2];
 381                 switch (cmd1) {
 382                 case ST21NFCA_NFCIP1_ATR_REQ:
 383                         r = st21nfca_tm_recv_atr_req(hdev, skb);
 384                         break;
 385                 case ST21NFCA_NFCIP1_PSL_REQ:
 386                         r = st21nfca_tm_recv_psl_req(hdev, skb);
 387                         break;
 388                 case ST21NFCA_NFCIP1_DEP_REQ:
 389                         r = st21nfca_tm_recv_dep_req(hdev, skb);
 390                         break;
 391                 default:
 392                         return 1;
 393                 }
 394                 break;
 395         default:
 396                 return 1;
 397         }
 398         return r;
 399 }
 400
 401 /*
 402  * Returns:
 403  * <= 0: driver handled the event, skb consumed
 404  *    1: driver does not handle the event, please do standard processing
 405  */
 406 int st21nfca_dep_event_received(struct nfc_hci_dev *hdev,
 407                                 u8 event, struct sk_buff *skb)
 408 {
 409         int r = 0;
 410         struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
 411
 412         pr_debug("dep event: %d\n", event);
 413
 414         switch (event) {
 415         case ST21NFCA_EVT_CARD_ACTIVATED:
 416                 info->dep_info.curr_nfc_dep_pni = 0;
 417                 break;
 418         case ST21NFCA_EVT_CARD_DEACTIVATED:
 419                 break;
 420         case ST21NFCA_EVT_FIELD_ON:
 421                 break;
 422         case ST21NFCA_EVT_FIELD_OFF:
 423                 break;
 424         case ST21NFCA_EVT_SEND_DATA:
 425                 r = st21nfca_tm_event_send_data(hdev, skb);
 426                 if (r < 0)
 427                         return r;
 428                 return 0;
 429         default:
 430                 nfc_err(&hdev->ndev->dev, "Unexpected event on card f gate\n");
 431                 return 1;
 432         }
 433         kfree_skb(skb);
 434         return r;
 435 }
 436 EXPORT_SYMBOL(st21nfca_dep_event_received);
 437
 438 static void st21nfca_im_send_psl_req(struct nfc_hci_dev *hdev, u8 did, u8 bsi,
 439                                      u8 bri, u8 lri)
 440 {
 441         struct sk_buff *skb;
 442         struct st21nfca_psl_req *psl_req;
 443         struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
 444
 445         skb =
 446             alloc_skb(sizeof(struct st21nfca_psl_req) + 1, GFP_KERNEL);
 447         if (!skb)
 448                 return;
 449         skb_reserve(skb, 1);
 450
 451         skb_put(skb, sizeof(struct st21nfca_psl_req));
 452         psl_req = (struct st21nfca_psl_req *) skb->data;
 453
 454         psl_req->length = sizeof(struct st21nfca_psl_req);
 455         psl_req->cmd0 = ST21NFCA_NFCIP1_REQ;
 456         psl_req->cmd1 = ST21NFCA_NFCIP1_PSL_REQ;
 457         psl_req->did = did;
 458         psl_req->brs = (0x30 & bsi << 4) | (bri & 0x03);
 459         psl_req->fsl = lri;
 460
 461         *(u8 *)skb_push(skb, 1) = info->dep_info.to | 0x10;
 462
 463         st21nfca_im_send_pdu(info, skb);
 464 }
 465
 466 #define ST21NFCA_CB_TYPE_READER_F 1
 467 static void st21nfca_im_recv_atr_res_cb(void *context, struct sk_buff *skb,
 468                                         int err)
 469 {
 470         struct st21nfca_hci_info *info = context;
 471         struct st21nfca_atr_res *atr_res;
 472         int r;
 473
 474         if (err != 0)
 475                 return;
 476
 477         if (!skb)
 478                 return;
 479
 480         switch (info->async_cb_type) {
 481         case ST21NFCA_CB_TYPE_READER_F:
 482                 skb_trim(skb, skb->len - 1);
 483                 atr_res = (struct st21nfca_atr_res *)skb->data;
 484                 r = nfc_set_remote_general_bytes(info->hdev->ndev,
 485                                 atr_res->gbi,
 486                                 skb->len - sizeof(struct st21nfca_atr_res));
 487                 if (r < 0)
 488                         return;
 489
 490                 if (atr_res->to >= 0x0e)
 491                         info->dep_info.to = 0x0e;
 492                 else
 493                         info->dep_info.to = atr_res->to + 1;
 494
 495                 info->dep_info.to |= 0x10;
 496
 497                 r = nfc_dep_link_is_up(info->hdev->ndev, info->dep_info.idx,
 498                                         NFC_COMM_PASSIVE, NFC_RF_INITIATOR);
 499                 if (r < 0)
 500                         return;
 501
 502                 info->dep_info.curr_nfc_dep_pni = 0;
 503                 if (ST21NFCA_PP2LRI(atr_res->ppi) != info->dep_info.lri)
 504                         st21nfca_im_send_psl_req(info->hdev, atr_res->did,
 505                                                 atr_res->bsi, atr_res->bri,
 506                                                 ST21NFCA_PP2LRI(atr_res->ppi));
 507                 break;
 508         default:
 509                 kfree_skb(skb);
 510                 break;
 511         }
 512 }
 513
 514 int st21nfca_im_send_atr_req(struct nfc_hci_dev *hdev, u8 *gb, size_t gb_len)
 515 {
 516         struct sk_buff *skb;
 517         struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
 518         struct st21nfca_atr_req *atr_req;
 519         struct nfc_target *target;
 520         uint size;
 521
 522         info->dep_info.to = ST21NFCA_DEFAULT_TIMEOUT;
 523         size = ST21NFCA_ATR_REQ_MIN_SIZE + gb_len;
 524         if (size > ST21NFCA_ATR_REQ_MAX_SIZE) {
 525                 PROTOCOL_ERR("14.6.1.1");
 526                 return -EINVAL;
 527         }
 528
 529         skb =
 530             alloc_skb(sizeof(struct st21nfca_atr_req) + gb_len + 1, GFP_KERNEL);
 531         if (!skb)
 532                 return -ENOMEM;
 533
 534         skb_reserve(skb, 1);
 535
 536         skb_put(skb, sizeof(struct st21nfca_atr_req));
 537
 538         atr_req = (struct st21nfca_atr_req *)skb->data;
 539         memset(atr_req, 0, sizeof(struct st21nfca_atr_req));
 540
 541         atr_req->cmd0 = ST21NFCA_NFCIP1_REQ;
 542         atr_req->cmd1 = ST21NFCA_NFCIP1_ATR_REQ;
 543         memset(atr_req->nfcid3, 0, NFC_NFCID3_MAXSIZE);
 544         target = hdev->ndev->targets;
 545
 546         if (target->sensf_res_len > 0)
 547                 memcpy(atr_req->nfcid3, target->sensf_res,
 548                                 target->sensf_res_len);
 549         else
 550                 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE);
 551
 552         atr_req->did = 0x0;
 553
 554         atr_req->bsi = 0x00;
 555         atr_req->bri = 0x00;
 556         atr_req->ppi = ST21NFCA_LR_BITS_PAYLOAD_SIZE_254B;
 557         if (gb_len) {
 558                 atr_req->ppi |= ST21NFCA_GB_BIT;
 559                 skb_put_data(skb, gb, gb_len);
 560         }
 561         atr_req->length = sizeof(struct st21nfca_atr_req) + hdev->gb_len;
 562
 563         *(u8 *)skb_push(skb, 1) = info->dep_info.to | 0x10; /* timeout */
 564
 565         info->async_cb_type = ST21NFCA_CB_TYPE_READER_F;
 566         info->async_cb_context = info;
 567         info->async_cb = st21nfca_im_recv_atr_res_cb;
 568         info->dep_info.bri = atr_req->bri;
 569         info->dep_info.bsi = atr_req->bsi;
 570         info->dep_info.lri = ST21NFCA_PP2LRI(atr_req->ppi);
 571
 572         return nfc_hci_send_cmd_async(hdev, ST21NFCA_RF_READER_F_GATE,
 573                                 ST21NFCA_WR_XCHG_DATA, skb->data,
 574                                 skb->len, info->async_cb, info);
 575 }
 576 EXPORT_SYMBOL(st21nfca_im_send_atr_req);
 577
 578 static void st21nfca_im_recv_dep_res_cb(void *context, struct sk_buff *skb,
 579                                         int err)
 580 {
 581         struct st21nfca_hci_info *info = context;
 582         struct st21nfca_dep_req_res *dep_res;
 583
 584         int size;
 585
 586         if (err != 0)
 587                 return;
 588
 589         if (!skb)
 590                 return;
 591
 592         switch (info->async_cb_type) {
 593         case ST21NFCA_CB_TYPE_READER_F:
 594                 dep_res = (struct st21nfca_dep_req_res *)skb->data;
 595
 596                 size = 3;
 597                 if (skb->len < size)
 598                         goto exit;
 599
 600                 if (ST21NFCA_NFC_DEP_DID_BIT_SET(dep_res->pfb))
 601                         size++;
 602                 if (ST21NFCA_NFC_DEP_NAD_BIT_SET(dep_res->pfb))
 603                         size++;
 604
 605                 if (skb->len < size)
 606                         goto exit;
 607
 608                 skb_trim(skb, skb->len - 1);
 609
 610                 /* Receiving DEP_REQ - Decoding */
 611                 switch (ST21NFCA_NFC_DEP_PFB_TYPE(dep_res->pfb)) {
 612                 case ST21NFCA_NFC_DEP_PFB_ACK_NACK_PDU:
 613                         pr_err("Received a ACK/NACK PDU\n");
 614                         fallthrough;
 615                 case ST21NFCA_NFC_DEP_PFB_I_PDU:
 616                         info->dep_info.curr_nfc_dep_pni =
 617                             ST21NFCA_NFC_DEP_PFB_PNI(dep_res->pfb + 1);
 618                         size++;
 619                         skb_pull(skb, size);
 620                         nfc_tm_data_received(info->hdev->ndev, skb);
 621                         break;
 622                 case ST21NFCA_NFC_DEP_PFB_SUPERVISOR_PDU:
 623                         pr_err("Received a SUPERVISOR PDU\n");
 624                         skb_pull(skb, size);
 625                         *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_DEP_REQ;
 626                         *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_REQ;
 627                         *(u8 *)skb_push(skb, 1) = skb->len;
 628                         *(u8 *)skb_push(skb, 1) = info->dep_info.to | 0x10;
 629
 630                         st21nfca_im_send_pdu(info, skb);
 631                         break;
 632                 }
 633
 634                 return;
 635         default:
 636                 break;
 637         }
 638
 639 exit:
 640         kfree_skb(skb);
 641 }
 642
 643 int st21nfca_im_send_dep_req(struct nfc_hci_dev *hdev, struct sk_buff *skb)
 644 {
 645         struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
 646
 647         info->async_cb_type = ST21NFCA_CB_TYPE_READER_F;
 648         info->async_cb_context = info;
 649         info->async_cb = st21nfca_im_recv_dep_res_cb;
 650
 651         *(u8 *)skb_push(skb, 1) = info->dep_info.curr_nfc_dep_pni;
 652         *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_DEP_REQ;
 653         *(u8 *)skb_push(skb, 1) = ST21NFCA_NFCIP1_REQ;
 654         *(u8 *)skb_push(skb, 1) = skb->len;
 655
 656         *(u8 *)skb_push(skb, 1) = info->dep_info.to | 0x10;
 657
 658         return nfc_hci_send_cmd_async(hdev, ST21NFCA_RF_READER_F_GATE,
 659                                       ST21NFCA_WR_XCHG_DATA,
 660                                       skb->data, skb->len,
 661                                       info->async_cb, info);
 662 }
 663 EXPORT_SYMBOL(st21nfca_im_send_dep_req);
 664
 665 void st21nfca_dep_init(struct nfc_hci_dev *hdev)
 666 {
 667         struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
 668
 669         INIT_WORK(&info->dep_info.tx_work, st21nfca_tx_work);
 670         info->dep_info.curr_nfc_dep_pni = 0;
 671         info->dep_info.idx = 0;
 672         info->dep_info.to = ST21NFCA_DEFAULT_TIMEOUT;
 673 }
 674 EXPORT_SYMBOL(st21nfca_dep_init);
 675
 676 void st21nfca_dep_deinit(struct nfc_hci_dev *hdev)
 677 {
 678         struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
 679
 680         cancel_work_sync(&info->dep_info.tx_work);
 681 }
 682 EXPORT_SYMBOL(st21nfca_dep_deinit);