drivers/nfc/st21nfca/dep.c

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