drivers/nfc/pn544/pn544.c

   1 /*
   2  * HCI based Driver for NXP PN544 NFC Chip
   3  *
   4  * Copyright (C) 2012  Intel Corporation. All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the
  17  * Free Software Foundation, Inc.,
  18  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <linux/delay.h>
  22 #include <linux/slab.h>
  23 #include <linux/module.h>
  24
  25 #include <linux/nfc.h>
  26 #include <net/nfc/hci.h>
  27 #include <net/nfc/llc.h>
  28
  29 #include "pn544.h"
  30
  31 /* Timing restrictions (ms) */
  32 #define PN544_HCI_RESETVEN_TIME         30
  33
  34 #define HCI_MODE 0
  35 #define FW_MODE 1
  36
  37 enum pn544_state {
  38         PN544_ST_COLD,
  39         PN544_ST_FW_READY,
  40         PN544_ST_READY,
  41 };
  42
  43 #define FULL_VERSION_LEN 11
  44
  45 /* Proprietary commands */
  46 #define PN544_WRITE             0x3f
  47
  48 /* Proprietary gates, events, commands and registers */
  49
  50 /* NFC_HCI_RF_READER_A_GATE additional registers and commands */
  51 #define PN544_RF_READER_A_AUTO_ACTIVATION                       0x10
  52 #define PN544_RF_READER_A_CMD_CONTINUE_ACTIVATION               0x12
  53 #define PN544_MIFARE_CMD                                        0x21
  54
  55 /* Commands that apply to all RF readers */
  56 #define PN544_RF_READER_CMD_PRESENCE_CHECK      0x30
  57 #define PN544_RF_READER_CMD_ACTIVATE_NEXT       0x32
  58
  59 /* NFC_HCI_ID_MGMT_GATE additional registers */
  60 #define PN544_ID_MGMT_FULL_VERSION_SW           0x10
  61
  62 #define PN544_RF_READER_ISO15693_GATE           0x12
  63
  64 #define PN544_RF_READER_F_GATE                  0x14
  65 #define PN544_FELICA_ID                         0x04
  66 #define PN544_FELICA_RAW                        0x20
  67
  68 #define PN544_RF_READER_JEWEL_GATE              0x15
  69 #define PN544_JEWEL_RAW_CMD                     0x23
  70
  71 #define PN544_RF_READER_NFCIP1_INITIATOR_GATE   0x30
  72 #define PN544_RF_READER_NFCIP1_TARGET_GATE      0x31
  73
  74 #define PN544_SYS_MGMT_GATE                     0x90
  75 #define PN544_SYS_MGMT_INFO_NOTIFICATION        0x02
  76
  77 #define PN544_POLLING_LOOP_MGMT_GATE            0x94
  78 #define PN544_DEP_MODE                          0x01
  79 #define PN544_DEP_ATR_REQ                       0x02
  80 #define PN544_DEP_ATR_RES                       0x03
  81 #define PN544_DEP_MERGE                         0x0D
  82 #define PN544_PL_RDPHASES                       0x06
  83 #define PN544_PL_EMULATION                      0x07
  84 #define PN544_PL_NFCT_DEACTIVATED               0x09
  85
  86 #define PN544_SWP_MGMT_GATE                     0xA0
  87
  88 #define PN544_NFC_WI_MGMT_GATE                  0xA1
  89
  90 #define PN544_HCI_EVT_SND_DATA                  0x01
  91 #define PN544_HCI_EVT_ACTIVATED                 0x02
  92 #define PN544_HCI_EVT_DEACTIVATED               0x03
  93 #define PN544_HCI_EVT_RCV_DATA                  0x04
  94 #define PN544_HCI_EVT_CONTINUE_MI               0x05
  95
  96 #define PN544_HCI_CMD_ATTREQUEST                0x12
  97 #define PN544_HCI_CMD_CONTINUE_ACTIVATION       0x13
  98
  99 static struct nfc_hci_gate pn544_gates[] = {
 100         {NFC_HCI_ADMIN_GATE, NFC_HCI_INVALID_PIPE},
 101         {NFC_HCI_LOOPBACK_GATE, NFC_HCI_INVALID_PIPE},
 102         {NFC_HCI_ID_MGMT_GATE, NFC_HCI_INVALID_PIPE},
 103         {NFC_HCI_LINK_MGMT_GATE, NFC_HCI_INVALID_PIPE},
 104         {NFC_HCI_RF_READER_B_GATE, NFC_HCI_INVALID_PIPE},
 105         {NFC_HCI_RF_READER_A_GATE, NFC_HCI_INVALID_PIPE},
 106         {PN544_SYS_MGMT_GATE, NFC_HCI_INVALID_PIPE},
 107         {PN544_SWP_MGMT_GATE, NFC_HCI_INVALID_PIPE},
 108         {PN544_POLLING_LOOP_MGMT_GATE, NFC_HCI_INVALID_PIPE},
 109         {PN544_NFC_WI_MGMT_GATE, NFC_HCI_INVALID_PIPE},
 110         {PN544_RF_READER_F_GATE, NFC_HCI_INVALID_PIPE},
 111         {PN544_RF_READER_JEWEL_GATE, NFC_HCI_INVALID_PIPE},
 112         {PN544_RF_READER_ISO15693_GATE, NFC_HCI_INVALID_PIPE},
 113         {PN544_RF_READER_NFCIP1_INITIATOR_GATE, NFC_HCI_INVALID_PIPE},
 114         {PN544_RF_READER_NFCIP1_TARGET_GATE, NFC_HCI_INVALID_PIPE}
 115 };
 116
 117 /* Largest headroom needed for outgoing custom commands */
 118 #define PN544_CMDS_HEADROOM     2
 119
 120 struct pn544_hci_info {
 121         struct nfc_phy_ops *phy_ops;
 122         void *phy_id;
 123
 124         struct nfc_hci_dev *hdev;
 125
 126         enum pn544_state state;
 127
 128         struct mutex info_lock;
 129
 130         int async_cb_type;
 131         data_exchange_cb_t async_cb;
 132         void *async_cb_context;
 133 };
 134
 135 static int pn544_hci_open(struct nfc_hci_dev *hdev)
 136 {
 137         struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
 138         int r = 0;
 139
 140         mutex_lock(&info->info_lock);
 141
 142         if (info->state != PN544_ST_COLD) {
 143                 r = -EBUSY;
 144                 goto out;
 145         }
 146
 147         r = info->phy_ops->enable(info->phy_id);
 148
 149         if (r == 0)
 150                 info->state = PN544_ST_READY;
 151
 152 out:
 153         mutex_unlock(&info->info_lock);
 154         return r;
 155 }
 156
 157 static void pn544_hci_close(struct nfc_hci_dev *hdev)
 158 {
 159         struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
 160
 161         mutex_lock(&info->info_lock);
 162
 163         if (info->state == PN544_ST_COLD)
 164                 goto out;
 165
 166         info->phy_ops->disable(info->phy_id);
 167
 168         info->state = PN544_ST_COLD;
 169
 170 out:
 171         mutex_unlock(&info->info_lock);
 172 }
 173
 174 static int pn544_hci_ready(struct nfc_hci_dev *hdev)
 175 {
 176         struct sk_buff *skb;
 177         static struct hw_config {
 178                 u8 adr[2];
 179                 u8 value;
 180         } hw_config[] = {
 181                 {{0x9f, 0x9a}, 0x00},
 182
 183                 {{0x98, 0x10}, 0xbc},
 184
 185                 {{0x9e, 0x71}, 0x00},
 186
 187                 {{0x98, 0x09}, 0x00},
 188
 189                 {{0x9e, 0xb4}, 0x00},
 190
 191                 {{0x9e, 0xd9}, 0xff},
 192                 {{0x9e, 0xda}, 0xff},
 193                 {{0x9e, 0xdb}, 0x23},
 194                 {{0x9e, 0xdc}, 0x21},
 195                 {{0x9e, 0xdd}, 0x22},
 196                 {{0x9e, 0xde}, 0x24},
 197
 198                 {{0x9c, 0x01}, 0x08},
 199
 200                 {{0x9e, 0xaa}, 0x01},
 201
 202                 {{0x9b, 0xd1}, 0x0d},
 203                 {{0x9b, 0xd2}, 0x24},
 204                 {{0x9b, 0xd3}, 0x0a},
 205                 {{0x9b, 0xd4}, 0x22},
 206                 {{0x9b, 0xd5}, 0x08},
 207                 {{0x9b, 0xd6}, 0x1e},
 208                 {{0x9b, 0xdd}, 0x1c},
 209
 210                 {{0x9b, 0x84}, 0x13},
 211                 {{0x99, 0x81}, 0x7f},
 212                 {{0x99, 0x31}, 0x70},
 213
 214                 {{0x98, 0x00}, 0x3f},
 215
 216                 {{0x9f, 0x09}, 0x00},
 217
 218                 {{0x9f, 0x0a}, 0x05},
 219
 220                 {{0x9e, 0xd1}, 0xa1},
 221                 {{0x99, 0x23}, 0x00},
 222
 223                 {{0x9e, 0x74}, 0x80},
 224
 225                 {{0x9f, 0x28}, 0x10},
 226
 227                 {{0x9f, 0x35}, 0x14},
 228
 229                 {{0x9f, 0x36}, 0x60},
 230
 231                 {{0x9c, 0x31}, 0x00},
 232
 233                 {{0x9c, 0x32}, 0xc8},
 234
 235                 {{0x9c, 0x19}, 0x40},
 236
 237                 {{0x9c, 0x1a}, 0x40},
 238
 239                 {{0x9c, 0x0c}, 0x00},
 240
 241                 {{0x9c, 0x0d}, 0x00},
 242
 243                 {{0x9c, 0x12}, 0x00},
 244
 245                 {{0x9c, 0x13}, 0x00},
 246
 247                 {{0x98, 0xa2}, 0x0e},
 248
 249                 {{0x98, 0x93}, 0x40},
 250
 251                 {{0x98, 0x7d}, 0x02},
 252                 {{0x98, 0x7e}, 0x00},
 253                 {{0x9f, 0xc8}, 0x01},
 254         };
 255         struct hw_config *p = hw_config;
 256         int count = ARRAY_SIZE(hw_config);
 257         struct sk_buff *res_skb;
 258         u8 param[4];
 259         int r;
 260
 261         param[0] = 0;
 262         while (count--) {
 263                 param[1] = p->adr[0];
 264                 param[2] = p->adr[1];
 265                 param[3] = p->value;
 266
 267                 r = nfc_hci_send_cmd(hdev, PN544_SYS_MGMT_GATE, PN544_WRITE,
 268                                      param, 4, &res_skb);
 269                 if (r < 0)
 270                         return r;
 271
 272                 if (res_skb->len != 1) {
 273                         kfree_skb(res_skb);
 274                         return -EPROTO;
 275                 }
 276
 277                 if (res_skb->data[0] != p->value) {
 278                         kfree_skb(res_skb);
 279                         return -EIO;
 280                 }
 281
 282                 kfree_skb(res_skb);
 283
 284                 p++;
 285         }
 286
 287         param[0] = NFC_HCI_UICC_HOST_ID;
 288         r = nfc_hci_set_param(hdev, NFC_HCI_ADMIN_GATE,
 289                               NFC_HCI_ADMIN_WHITELIST, param, 1);
 290         if (r < 0)
 291                 return r;
 292
 293         param[0] = 0x3d;
 294         r = nfc_hci_set_param(hdev, PN544_SYS_MGMT_GATE,
 295                               PN544_SYS_MGMT_INFO_NOTIFICATION, param, 1);
 296         if (r < 0)
 297                 return r;
 298
 299         param[0] = 0x0;
 300         r = nfc_hci_set_param(hdev, NFC_HCI_RF_READER_A_GATE,
 301                               PN544_RF_READER_A_AUTO_ACTIVATION, param, 1);
 302         if (r < 0)
 303                 return r;
 304
 305         r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
 306                                NFC_HCI_EVT_END_OPERATION, NULL, 0);
 307         if (r < 0)
 308                 return r;
 309
 310         param[0] = 0x1;
 311         r = nfc_hci_set_param(hdev, PN544_POLLING_LOOP_MGMT_GATE,
 312                               PN544_PL_NFCT_DEACTIVATED, param, 1);
 313         if (r < 0)
 314                 return r;
 315
 316         param[0] = 0x0;
 317         r = nfc_hci_set_param(hdev, PN544_POLLING_LOOP_MGMT_GATE,
 318                               PN544_PL_RDPHASES, param, 1);
 319         if (r < 0)
 320                 return r;
 321
 322         r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
 323                               PN544_ID_MGMT_FULL_VERSION_SW, &skb);
 324         if (r < 0)
 325                 return r;
 326
 327         if (skb->len != FULL_VERSION_LEN) {
 328                 kfree_skb(skb);
 329                 return -EINVAL;
 330         }
 331
 332         print_hex_dump(KERN_DEBUG, "FULL VERSION SOFTWARE INFO: ",
 333                        DUMP_PREFIX_NONE, 16, 1,
 334                        skb->data, FULL_VERSION_LEN, false);
 335
 336         kfree_skb(skb);
 337
 338         return 0;
 339 }
 340
 341 static int pn544_hci_xmit(struct nfc_hci_dev *hdev, struct sk_buff *skb)
 342 {
 343         struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
 344
 345         return info->phy_ops->write(info->phy_id, skb);
 346 }
 347
 348 static int pn544_hci_start_poll(struct nfc_hci_dev *hdev,
 349                                 u32 im_protocols, u32 tm_protocols)
 350 {
 351         u8 phases = 0;
 352         int r;
 353         u8 duration[2];
 354         u8 activated;
 355         u8 i_mode = 0x3f; /* Enable all supported modes */
 356         u8 t_mode = 0x0f;
 357         u8 t_merge = 0x01; /* Enable merge by default */
 358
 359         pr_info(DRIVER_DESC ": %s protocols 0x%x 0x%x\n",
 360                 __func__, im_protocols, tm_protocols);
 361
 362         r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
 363                                NFC_HCI_EVT_END_OPERATION, NULL, 0);
 364         if (r < 0)
 365                 return r;
 366
 367         duration[0] = 0x18;
 368         duration[1] = 0x6a;
 369         r = nfc_hci_set_param(hdev, PN544_POLLING_LOOP_MGMT_GATE,
 370                               PN544_PL_EMULATION, duration, 2);
 371         if (r < 0)
 372                 return r;
 373
 374         activated = 0;
 375         r = nfc_hci_set_param(hdev, PN544_POLLING_LOOP_MGMT_GATE,
 376                               PN544_PL_NFCT_DEACTIVATED, &activated, 1);
 377         if (r < 0)
 378                 return r;
 379
 380         if (im_protocols & (NFC_PROTO_ISO14443_MASK | NFC_PROTO_MIFARE_MASK |
 381                          NFC_PROTO_JEWEL_MASK))
 382                 phases |= 1;            /* Type A */
 383         if (im_protocols & NFC_PROTO_FELICA_MASK) {
 384                 phases |= (1 << 2);     /* Type F 212 */
 385                 phases |= (1 << 3);     /* Type F 424 */
 386         }
 387
 388         phases |= (1 << 5);             /* NFC active */
 389
 390         r = nfc_hci_set_param(hdev, PN544_POLLING_LOOP_MGMT_GATE,
 391                               PN544_PL_RDPHASES, &phases, 1);
 392         if (r < 0)
 393                 return r;
 394
 395         if ((im_protocols | tm_protocols) & NFC_PROTO_NFC_DEP_MASK) {
 396                 hdev->gb = nfc_get_local_general_bytes(hdev->ndev,
 397                                                         &hdev->gb_len);
 398                 pr_debug("generate local bytes %p", hdev->gb);
 399                 if (hdev->gb == NULL || hdev->gb_len == 0) {
 400                         im_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
 401                         tm_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
 402                 }
 403         }
 404
 405         if (im_protocols & NFC_PROTO_NFC_DEP_MASK) {
 406                 r = nfc_hci_send_event(hdev,
 407                                 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
 408                                 NFC_HCI_EVT_END_OPERATION, NULL, 0);
 409                 if (r < 0)
 410                         return r;
 411
 412                 r = nfc_hci_set_param(hdev,
 413                                 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
 414                                 PN544_DEP_MODE, &i_mode, 1);
 415                 if (r < 0)
 416                         return r;
 417
 418                 r = nfc_hci_set_param(hdev,
 419                                 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
 420                                 PN544_DEP_ATR_REQ, hdev->gb, hdev->gb_len);
 421                 if (r < 0)
 422                         return r;
 423
 424                 r = nfc_hci_send_event(hdev,
 425                                 PN544_RF_READER_NFCIP1_INITIATOR_GATE,
 426                                 NFC_HCI_EVT_READER_REQUESTED, NULL, 0);
 427                 if (r < 0)
 428                         nfc_hci_send_event(hdev,
 429                                         PN544_RF_READER_NFCIP1_INITIATOR_GATE,
 430                                         NFC_HCI_EVT_END_OPERATION, NULL, 0);
 431         }
 432
 433         if (tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
 434                 r = nfc_hci_set_param(hdev, PN544_RF_READER_NFCIP1_TARGET_GATE,
 435                                 PN544_DEP_MODE, &t_mode, 1);
 436                 if (r < 0)
 437                         return r;
 438
 439                 r = nfc_hci_set_param(hdev, PN544_RF_READER_NFCIP1_TARGET_GATE,
 440                                 PN544_DEP_ATR_RES, hdev->gb, hdev->gb_len);
 441                 if (r < 0)
 442                         return r;
 443
 444                 r = nfc_hci_set_param(hdev, PN544_RF_READER_NFCIP1_TARGET_GATE,
 445                                 PN544_DEP_MERGE, &t_merge, 1);
 446                 if (r < 0)
 447                         return r;
 448         }
 449
 450         r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
 451                                NFC_HCI_EVT_READER_REQUESTED, NULL, 0);
 452         if (r < 0)
 453                 nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
 454                                    NFC_HCI_EVT_END_OPERATION, NULL, 0);
 455
 456         return r;
 457 }
 458
 459 static int pn544_hci_dep_link_up(struct nfc_hci_dev *hdev,
 460                                 struct nfc_target *target, u8 comm_mode,
 461                                 u8 *gb, size_t gb_len)
 462 {
 463         struct sk_buff *rgb_skb = NULL;
 464         int r;
 465
 466         r = nfc_hci_get_param(hdev, target->hci_reader_gate,
 467                                 PN544_DEP_ATR_RES, &rgb_skb);
 468         if (r < 0)
 469                 return r;
 470
 471         if (rgb_skb->len == 0 || rgb_skb->len > NFC_GB_MAXSIZE) {
 472                 r = -EPROTO;
 473                 goto exit;
 474         }
 475         print_hex_dump(KERN_DEBUG, "remote gb: ", DUMP_PREFIX_OFFSET,
 476                         16, 1, rgb_skb->data, rgb_skb->len, true);
 477
 478         r = nfc_set_remote_general_bytes(hdev->ndev, rgb_skb->data,
 479                                                 rgb_skb->len);
 480
 481         if (r == 0)
 482                 r = nfc_dep_link_is_up(hdev->ndev, target->idx, comm_mode,
 483                                         NFC_RF_INITIATOR);
 484 exit:
 485         kfree_skb(rgb_skb);
 486         return r;
 487 }
 488
 489 static int pn544_hci_dep_link_down(struct nfc_hci_dev *hdev)
 490 {
 491
 492         return nfc_hci_send_event(hdev, PN544_RF_READER_NFCIP1_INITIATOR_GATE,
 493                                         NFC_HCI_EVT_END_OPERATION, NULL, 0);
 494 }
 495
 496 static int pn544_hci_target_from_gate(struct nfc_hci_dev *hdev, u8 gate,
 497                                       struct nfc_target *target)
 498 {
 499         switch (gate) {
 500         case PN544_RF_READER_F_GATE:
 501                 target->supported_protocols = NFC_PROTO_FELICA_MASK;
 502                 break;
 503         case PN544_RF_READER_JEWEL_GATE:
 504                 target->supported_protocols = NFC_PROTO_JEWEL_MASK;
 505                 target->sens_res = 0x0c00;
 506                 break;
 507         case PN544_RF_READER_NFCIP1_INITIATOR_GATE:
 508                 target->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
 509                 break;
 510         default:
 511                 return -EPROTO;
 512         }
 513
 514         return 0;
 515 }
 516
 517 static int pn544_hci_complete_target_discovered(struct nfc_hci_dev *hdev,
 518                                                 u8 gate,
 519                                                 struct nfc_target *target)
 520 {
 521         struct sk_buff *uid_skb;
 522         int r = 0;
 523
 524         if (gate == PN544_RF_READER_NFCIP1_INITIATOR_GATE)
 525                 return r;
 526
 527         if (target->supported_protocols & NFC_PROTO_NFC_DEP_MASK) {
 528                 r = nfc_hci_send_cmd(hdev,
 529                         PN544_RF_READER_NFCIP1_INITIATOR_GATE,
 530                         PN544_HCI_CMD_CONTINUE_ACTIVATION, NULL, 0, NULL);
 531                 if (r < 0)
 532                         return r;
 533
 534                 target->hci_reader_gate = PN544_RF_READER_NFCIP1_INITIATOR_GATE;
 535         } else if (target->supported_protocols & NFC_PROTO_MIFARE_MASK) {
 536                 if (target->nfcid1_len != 4 && target->nfcid1_len != 7 &&
 537                     target->nfcid1_len != 10)
 538                         return -EPROTO;
 539
 540                 r = nfc_hci_send_cmd(hdev, NFC_HCI_RF_READER_A_GATE,
 541                                      PN544_RF_READER_CMD_ACTIVATE_NEXT,
 542                                      target->nfcid1, target->nfcid1_len, NULL);
 543         } else if (target->supported_protocols & NFC_PROTO_FELICA_MASK) {
 544                 r = nfc_hci_get_param(hdev, PN544_RF_READER_F_GATE,
 545                                       PN544_FELICA_ID, &uid_skb);
 546                 if (r < 0)
 547                         return r;
 548
 549                 if (uid_skb->len != 8) {
 550                         kfree_skb(uid_skb);
 551                         return -EPROTO;
 552                 }
 553
 554                 r = nfc_hci_send_cmd(hdev, PN544_RF_READER_F_GATE,
 555                                      PN544_RF_READER_CMD_ACTIVATE_NEXT,
 556                                      uid_skb->data, uid_skb->len, NULL);
 557                 kfree_skb(uid_skb);
 558
 559                 r = nfc_hci_send_cmd(hdev,
 560                                         PN544_RF_READER_NFCIP1_INITIATOR_GATE,
 561                                         PN544_HCI_CMD_CONTINUE_ACTIVATION,
 562                                         NULL, 0, NULL);
 563                 if (r < 0)
 564                         return r;
 565
 566                 target->hci_reader_gate = PN544_RF_READER_NFCIP1_INITIATOR_GATE;
 567                 target->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
 568         } else if (target->supported_protocols & NFC_PROTO_ISO14443_MASK) {
 569                 /*
 570                  * TODO: maybe other ISO 14443 require some kind of continue
 571                  * activation, but for now we've seen only this one below.
 572                  */
 573                 if (target->sens_res == 0x4403) /* Type 4 Mifare DESFire */
 574                         r = nfc_hci_send_cmd(hdev, NFC_HCI_RF_READER_A_GATE,
 575                               PN544_RF_READER_A_CMD_CONTINUE_ACTIVATION,
 576                               NULL, 0, NULL);
 577         }
 578
 579         return r;
 580 }
 581
 582 #define PN544_CB_TYPE_READER_F 1
 583
 584 static void pn544_hci_data_exchange_cb(void *context, struct sk_buff *skb,
 585                                        int err)
 586 {
 587         struct pn544_hci_info *info = context;
 588
 589         switch (info->async_cb_type) {
 590         case PN544_CB_TYPE_READER_F:
 591                 if (err == 0)
 592                         skb_pull(skb, 1);
 593                 info->async_cb(info->async_cb_context, skb, err);
 594                 break;
 595         default:
 596                 if (err == 0)
 597                         kfree_skb(skb);
 598                 break;
 599         }
 600 }
 601
 602 #define MIFARE_CMD_AUTH_KEY_A   0x60
 603 #define MIFARE_CMD_AUTH_KEY_B   0x61
 604 #define MIFARE_CMD_HEADER       2
 605 #define MIFARE_UID_LEN          4
 606 #define MIFARE_KEY_LEN          6
 607 #define MIFARE_CMD_LEN          12
 608 /*
 609  * Returns:
 610  * <= 0: driver handled the data exchange
 611  *    1: driver doesn't especially handle, please do standard processing
 612  */
 613 static int pn544_hci_im_transceive(struct nfc_hci_dev *hdev,
 614                                    struct nfc_target *target,
 615                                    struct sk_buff *skb, data_exchange_cb_t cb,
 616                                    void *cb_context)
 617 {
 618         struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
 619
 620         pr_info(DRIVER_DESC ": %s for gate=%d\n", __func__,
 621                 target->hci_reader_gate);
 622
 623         switch (target->hci_reader_gate) {
 624         case NFC_HCI_RF_READER_A_GATE:
 625                 if (target->supported_protocols & NFC_PROTO_MIFARE_MASK) {
 626                         /*
 627                          * It seems that pn544 is inverting key and UID for
 628                          * MIFARE authentication commands.
 629                          */
 630                         if (skb->len == MIFARE_CMD_LEN &&
 631                             (skb->data[0] == MIFARE_CMD_AUTH_KEY_A ||
 632                              skb->data[0] == MIFARE_CMD_AUTH_KEY_B)) {
 633                                 u8 uid[MIFARE_UID_LEN];
 634                                 u8 *data = skb->data + MIFARE_CMD_HEADER;
 635
 636                                 memcpy(uid, data + MIFARE_KEY_LEN,
 637                                        MIFARE_UID_LEN);
 638                                 memmove(data + MIFARE_UID_LEN, data,
 639                                         MIFARE_KEY_LEN);
 640                                 memcpy(data, uid, MIFARE_UID_LEN);
 641                         }
 642
 643                         return nfc_hci_send_cmd_async(hdev,
 644                                                       target->hci_reader_gate,
 645                                                       PN544_MIFARE_CMD,
 646                                                       skb->data, skb->len,
 647                                                       cb, cb_context);
 648                 } else
 649                         return 1;
 650         case PN544_RF_READER_F_GATE:
 651                 *skb_push(skb, 1) = 0;
 652                 *skb_push(skb, 1) = 0;
 653
 654                 info->async_cb_type = PN544_CB_TYPE_READER_F;
 655                 info->async_cb = cb;
 656                 info->async_cb_context = cb_context;
 657
 658                 return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
 659                                               PN544_FELICA_RAW, skb->data,
 660                                               skb->len,
 661                                               pn544_hci_data_exchange_cb, info);
 662         case PN544_RF_READER_JEWEL_GATE:
 663                 return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
 664                                               PN544_JEWEL_RAW_CMD, skb->data,
 665                                               skb->len, cb, cb_context);
 666         case PN544_RF_READER_NFCIP1_INITIATOR_GATE:
 667                 *skb_push(skb, 1) = 0;
 668
 669                 return nfc_hci_send_event(hdev, target->hci_reader_gate,
 670                                         PN544_HCI_EVT_SND_DATA, skb->data,
 671                                         skb->len);
 672         default:
 673                 return 1;
 674         }
 675 }
 676
 677 static int pn544_hci_tm_send(struct nfc_hci_dev *hdev, struct sk_buff *skb)
 678 {
 679         int r;
 680
 681         /* Set default false for multiple information chaining */
 682         *skb_push(skb, 1) = 0;
 683
 684         r = nfc_hci_send_event(hdev, PN544_RF_READER_NFCIP1_TARGET_GATE,
 685                                PN544_HCI_EVT_SND_DATA, skb->data, skb->len);
 686
 687         kfree_skb(skb);
 688
 689         return r;
 690 }
 691
 692 static int pn544_hci_check_presence(struct nfc_hci_dev *hdev,
 693                                    struct nfc_target *target)
 694 {
 695         pr_debug("supported protocol %d", target->supported_protocols);
 696         if (target->supported_protocols & (NFC_PROTO_ISO14443_MASK |
 697                                         NFC_PROTO_ISO14443_B_MASK)) {
 698                 return nfc_hci_send_cmd(hdev, target->hci_reader_gate,
 699                                         PN544_RF_READER_CMD_PRESENCE_CHECK,
 700                                         NULL, 0, NULL);
 701         } else if (target->supported_protocols & NFC_PROTO_MIFARE_MASK) {
 702                 if (target->nfcid1_len != 4 && target->nfcid1_len != 7 &&
 703                     target->nfcid1_len != 10)
 704                         return -EOPNOTSUPP;
 705
 706                  return nfc_hci_send_cmd(hdev, NFC_HCI_RF_READER_A_GATE,
 707                                      PN544_RF_READER_CMD_ACTIVATE_NEXT,
 708                                      target->nfcid1, target->nfcid1_len, NULL);
 709         } else if (target->supported_protocols & NFC_PROTO_JEWEL_MASK) {
 710                 return nfc_hci_send_cmd(hdev, target->hci_reader_gate,
 711                                         PN544_JEWEL_RAW_CMD, NULL, 0, NULL);
 712         } else if (target->supported_protocols & NFC_PROTO_FELICA_MASK) {
 713                 return nfc_hci_send_cmd(hdev, PN544_RF_READER_F_GATE,
 714                                         PN544_FELICA_RAW, NULL, 0, NULL);
 715         } else if (target->supported_protocols & NFC_PROTO_NFC_DEP_MASK) {
 716                 return nfc_hci_send_cmd(hdev, target->hci_reader_gate,
 717                                         PN544_HCI_CMD_ATTREQUEST,
 718                                         NULL, 0, NULL);
 719         }
 720
 721         return 0;
 722 }
 723
 724 /*
 725  * Returns:
 726  * <= 0: driver handled the event, skb consumed
 727  *    1: driver does not handle the event, please do standard processing
 728  */
 729 static int pn544_hci_event_received(struct nfc_hci_dev *hdev, u8 gate, u8 event,
 730                                     struct sk_buff *skb)
 731 {
 732         struct sk_buff *rgb_skb = NULL;
 733         int r;
 734
 735         pr_debug("hci event %d", event);
 736         switch (event) {
 737         case PN544_HCI_EVT_ACTIVATED:
 738                 if (gate == PN544_RF_READER_NFCIP1_INITIATOR_GATE) {
 739                         r = nfc_hci_target_discovered(hdev, gate);
 740                 } else if (gate == PN544_RF_READER_NFCIP1_TARGET_GATE) {
 741                         r = nfc_hci_get_param(hdev, gate, PN544_DEP_ATR_REQ,
 742                                               &rgb_skb);
 743                         if (r < 0)
 744                                 goto exit;
 745
 746                         r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK,
 747                                              NFC_COMM_PASSIVE, rgb_skb->data,
 748                                              rgb_skb->len);
 749
 750                         kfree_skb(rgb_skb);
 751                 } else {
 752                         r = -EINVAL;
 753                 }
 754                 break;
 755         case PN544_HCI_EVT_DEACTIVATED:
 756                 r = nfc_hci_send_event(hdev, gate, NFC_HCI_EVT_END_OPERATION,
 757                                        NULL, 0);
 758                 break;
 759         case PN544_HCI_EVT_RCV_DATA:
 760                 if (skb->len < 2) {
 761                         r = -EPROTO;
 762                         goto exit;
 763                 }
 764
 765                 if (skb->data[0] != 0) {
 766                         pr_debug("data0 %d", skb->data[0]);
 767                         r = -EPROTO;
 768                         goto exit;
 769                 }
 770
 771                 skb_pull(skb, 2);
 772                 return nfc_tm_data_received(hdev->ndev, skb);
 773         default:
 774                 return 1;
 775         }
 776
 777 exit:
 778         kfree_skb(skb);
 779
 780         return r;
 781 }
 782
 783 static struct nfc_hci_ops pn544_hci_ops = {
 784         .open = pn544_hci_open,
 785         .close = pn544_hci_close,
 786         .hci_ready = pn544_hci_ready,
 787         .xmit = pn544_hci_xmit,
 788         .start_poll = pn544_hci_start_poll,
 789         .dep_link_up = pn544_hci_dep_link_up,
 790         .dep_link_down = pn544_hci_dep_link_down,
 791         .target_from_gate = pn544_hci_target_from_gate,
 792         .complete_target_discovered = pn544_hci_complete_target_discovered,
 793         .im_transceive = pn544_hci_im_transceive,
 794         .tm_send = pn544_hci_tm_send,
 795         .check_presence = pn544_hci_check_presence,
 796         .event_received = pn544_hci_event_received,
 797 };
 798
 799 int pn544_hci_probe(void *phy_id, struct nfc_phy_ops *phy_ops, char *llc_name,
 800                     int phy_headroom, int phy_tailroom, int phy_payload,
 801                     struct nfc_hci_dev **hdev)
 802 {
 803         struct pn544_hci_info *info;
 804         u32 protocols, se;
 805         struct nfc_hci_init_data init_data;
 806         int r;
 807
 808         info = kzalloc(sizeof(struct pn544_hci_info), GFP_KERNEL);
 809         if (!info) {
 810                 pr_err("Cannot allocate memory for pn544_hci_info.\n");
 811                 r = -ENOMEM;
 812                 goto err_info_alloc;
 813         }
 814
 815         info->phy_ops = phy_ops;
 816         info->phy_id = phy_id;
 817         info->state = PN544_ST_COLD;
 818         mutex_init(&info->info_lock);
 819
 820         init_data.gate_count = ARRAY_SIZE(pn544_gates);
 821
 822         memcpy(init_data.gates, pn544_gates, sizeof(pn544_gates));
 823
 824         /*
 825          * TODO: Session id must include the driver name + some bus addr
 826          * persistent info to discriminate 2 identical chips
 827          */
 828         strcpy(init_data.session_id, "ID544HCI");
 829
 830         protocols = NFC_PROTO_JEWEL_MASK |
 831                     NFC_PROTO_MIFARE_MASK |
 832                     NFC_PROTO_FELICA_MASK |
 833                     NFC_PROTO_ISO14443_MASK |
 834                     NFC_PROTO_ISO14443_B_MASK |
 835                     NFC_PROTO_NFC_DEP_MASK;
 836
 837         se = NFC_SE_UICC | NFC_SE_EMBEDDED;
 838
 839         info->hdev = nfc_hci_allocate_device(&pn544_hci_ops, &init_data, 0,
 840                                              protocols, se, llc_name,
 841                                              phy_headroom + PN544_CMDS_HEADROOM,
 842                                              phy_tailroom, phy_payload);
 843         if (!info->hdev) {
 844                 pr_err("Cannot allocate nfc hdev.\n");
 845                 r = -ENOMEM;
 846                 goto err_alloc_hdev;
 847         }
 848
 849         nfc_hci_set_clientdata(info->hdev, info);
 850
 851         r = nfc_hci_register_device(info->hdev);
 852         if (r)
 853                 goto err_regdev;
 854
 855         *hdev = info->hdev;
 856
 857         return 0;
 858
 859 err_regdev:
 860         nfc_hci_free_device(info->hdev);
 861
 862 err_alloc_hdev:
 863         kfree(info);
 864
 865 err_info_alloc:
 866         return r;
 867 }
 868 EXPORT_SYMBOL(pn544_hci_probe);
 869
 870 void pn544_hci_remove(struct nfc_hci_dev *hdev)
 871 {
 872         struct pn544_hci_info *info = nfc_hci_get_clientdata(hdev);
 873
 874         nfc_hci_unregister_device(hdev);
 875         nfc_hci_free_device(hdev);
 876         kfree(info);
 877 }
 878 EXPORT_SYMBOL(pn544_hci_remove);
 879
 880 MODULE_LICENSE("GPL");
 881 MODULE_DESCRIPTION(DRIVER_DESC);