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