drivers/nfc/microread/microread.c

   1 /*
   2  * HCI based Driver for Inside Secure microread NFC Chip
   3  *
   4  * Copyright (C) 2013  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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  22
  23 #include <linux/module.h>
  24 #include <linux/delay.h>
  25 #include <linux/slab.h>
  26 #include <linux/crc-ccitt.h>
  27
  28 #include <linux/nfc.h>
  29 #include <net/nfc/nfc.h>
  30 #include <net/nfc/hci.h>
  31 #include <net/nfc/llc.h>
  32
  33 #include "microread.h"
  34
  35 /* Proprietary gates, events, commands and registers */
  36 /* Admin */
  37 #define MICROREAD_GATE_ID_ADM NFC_HCI_ADMIN_GATE
  38 #define MICROREAD_GATE_ID_MGT 0x01
  39 #define MICROREAD_GATE_ID_OS 0x02
  40 #define MICROREAD_GATE_ID_TESTRF 0x03
  41 #define MICROREAD_GATE_ID_LOOPBACK NFC_HCI_LOOPBACK_GATE
  42 #define MICROREAD_GATE_ID_IDT NFC_HCI_ID_MGMT_GATE
  43 #define MICROREAD_GATE_ID_LMS NFC_HCI_LINK_MGMT_GATE
  44
  45 /* Reader */
  46 #define MICROREAD_GATE_ID_MREAD_GEN 0x10
  47 #define MICROREAD_GATE_ID_MREAD_ISO_B NFC_HCI_RF_READER_B_GATE
  48 #define MICROREAD_GATE_ID_MREAD_NFC_T1 0x12
  49 #define MICROREAD_GATE_ID_MREAD_ISO_A NFC_HCI_RF_READER_A_GATE
  50 #define MICROREAD_GATE_ID_MREAD_NFC_T3 0x14
  51 #define MICROREAD_GATE_ID_MREAD_ISO_15_3 0x15
  52 #define MICROREAD_GATE_ID_MREAD_ISO_15_2 0x16
  53 #define MICROREAD_GATE_ID_MREAD_ISO_B_3 0x17
  54 #define MICROREAD_GATE_ID_MREAD_BPRIME 0x18
  55 #define MICROREAD_GATE_ID_MREAD_ISO_A_3 0x19
  56
  57 /* Card */
  58 #define MICROREAD_GATE_ID_MCARD_GEN 0x20
  59 #define MICROREAD_GATE_ID_MCARD_ISO_B 0x21
  60 #define MICROREAD_GATE_ID_MCARD_BPRIME 0x22
  61 #define MICROREAD_GATE_ID_MCARD_ISO_A 0x23
  62 #define MICROREAD_GATE_ID_MCARD_NFC_T3 0x24
  63 #define MICROREAD_GATE_ID_MCARD_ISO_15_3 0x25
  64 #define MICROREAD_GATE_ID_MCARD_ISO_15_2 0x26
  65 #define MICROREAD_GATE_ID_MCARD_ISO_B_2 0x27
  66 #define MICROREAD_GATE_ID_MCARD_ISO_CUSTOM 0x28
  67 #define MICROREAD_GATE_ID_SECURE_ELEMENT 0x2F
  68
  69 /* P2P */
  70 #define MICROREAD_GATE_ID_P2P_GEN 0x30
  71 #define MICROREAD_GATE_ID_P2P_TARGET 0x31
  72 #define MICROREAD_PAR_P2P_TARGET_MODE 0x01
  73 #define MICROREAD_PAR_P2P_TARGET_GT 0x04
  74 #define MICROREAD_GATE_ID_P2P_INITIATOR 0x32
  75 #define MICROREAD_PAR_P2P_INITIATOR_GI 0x01
  76 #define MICROREAD_PAR_P2P_INITIATOR_GT 0x03
  77
  78 /* Those pipes are created/opened by default in the chip */
  79 #define MICROREAD_PIPE_ID_LMS 0x00
  80 #define MICROREAD_PIPE_ID_ADMIN 0x01
  81 #define MICROREAD_PIPE_ID_MGT 0x02
  82 #define MICROREAD_PIPE_ID_OS 0x03
  83 #define MICROREAD_PIPE_ID_HDS_LOOPBACK 0x04
  84 #define MICROREAD_PIPE_ID_HDS_IDT 0x05
  85 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_B 0x08
  86 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_BPRIME 0x09
  87 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_A 0x0A
  88 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_15_3 0x0B
  89 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_15_2 0x0C
  90 #define MICROREAD_PIPE_ID_HDS_MCARD_NFC_T3 0x0D
  91 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_B_2 0x0E
  92 #define MICROREAD_PIPE_ID_HDS_MCARD_CUSTOM 0x0F
  93 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_B 0x10
  94 #define MICROREAD_PIPE_ID_HDS_MREAD_NFC_T1 0x11
  95 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_A 0x12
  96 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_15_3 0x13
  97 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_15_2 0x14
  98 #define MICROREAD_PIPE_ID_HDS_MREAD_NFC_T3 0x15
  99 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_B_3 0x16
 100 #define MICROREAD_PIPE_ID_HDS_MREAD_BPRIME 0x17
 101 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_A_3 0x18
 102 #define MICROREAD_PIPE_ID_HDS_MREAD_GEN 0x1B
 103 #define MICROREAD_PIPE_ID_HDS_STACKED_ELEMENT 0x1C
 104 #define MICROREAD_PIPE_ID_HDS_INSTANCES 0x1D
 105 #define MICROREAD_PIPE_ID_HDS_TESTRF 0x1E
 106 #define MICROREAD_PIPE_ID_HDS_P2P_TARGET 0x1F
 107 #define MICROREAD_PIPE_ID_HDS_P2P_INITIATOR 0x20
 108
 109 /* Events */
 110 #define MICROREAD_EVT_MREAD_DISCOVERY_OCCURED NFC_HCI_EVT_TARGET_DISCOVERED
 111 #define MICROREAD_EVT_MREAD_CARD_FOUND 0x3D
 112 #define MICROREAD_EMCF_A_ATQA 0
 113 #define MICROREAD_EMCF_A_SAK 2
 114 #define MICROREAD_EMCF_A_LEN 3
 115 #define MICROREAD_EMCF_A_UID 4
 116 #define MICROREAD_EMCF_A3_ATQA 0
 117 #define MICROREAD_EMCF_A3_SAK 2
 118 #define MICROREAD_EMCF_A3_LEN 3
 119 #define MICROREAD_EMCF_A3_UID 4
 120 #define MICROREAD_EMCF_B_UID 0
 121 #define MICROREAD_EMCF_T1_ATQA 0
 122 #define MICROREAD_EMCF_T1_UID 4
 123 #define MICROREAD_EMCF_T3_UID 0
 124 #define MICROREAD_EVT_MREAD_DISCOVERY_START NFC_HCI_EVT_READER_REQUESTED
 125 #define MICROREAD_EVT_MREAD_DISCOVERY_START_SOME 0x3E
 126 #define MICROREAD_EVT_MREAD_DISCOVERY_STOP NFC_HCI_EVT_END_OPERATION
 127 #define MICROREAD_EVT_MREAD_SIM_REQUESTS 0x3F
 128 #define MICROREAD_EVT_MCARD_EXCHANGE NFC_HCI_EVT_TARGET_DISCOVERED
 129 #define MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF 0x20
 130 #define MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF 0x21
 131 #define MICROREAD_EVT_MCARD_FIELD_ON 0x11
 132 #define MICROREAD_EVT_P2P_TARGET_ACTIVATED 0x13
 133 #define MICROREAD_EVT_P2P_TARGET_DEACTIVATED 0x12
 134 #define MICROREAD_EVT_MCARD_FIELD_OFF 0x14
 135
 136 /* Commands */
 137 #define MICROREAD_CMD_MREAD_EXCHANGE 0x10
 138 #define MICROREAD_CMD_MREAD_SUBSCRIBE 0x3F
 139
 140 /* Hosts IDs */
 141 #define MICROREAD_ELT_ID_HDS NFC_HCI_TERMINAL_HOST_ID
 142 #define MICROREAD_ELT_ID_SIM NFC_HCI_UICC_HOST_ID
 143 #define MICROREAD_ELT_ID_SE1 0x03
 144 #define MICROREAD_ELT_ID_SE2 0x04
 145 #define MICROREAD_ELT_ID_SE3 0x05
 146
 147 static struct nfc_hci_gate microread_gates[] = {
 148         {MICROREAD_GATE_ID_ADM, MICROREAD_PIPE_ID_ADMIN},
 149         {MICROREAD_GATE_ID_LOOPBACK, MICROREAD_PIPE_ID_HDS_LOOPBACK},
 150         {MICROREAD_GATE_ID_IDT, MICROREAD_PIPE_ID_HDS_IDT},
 151         {MICROREAD_GATE_ID_LMS, MICROREAD_PIPE_ID_LMS},
 152         {MICROREAD_GATE_ID_MREAD_ISO_B, MICROREAD_PIPE_ID_HDS_MREAD_ISO_B},
 153         {MICROREAD_GATE_ID_MREAD_ISO_A, MICROREAD_PIPE_ID_HDS_MREAD_ISO_A},
 154         {MICROREAD_GATE_ID_MREAD_ISO_A_3, MICROREAD_PIPE_ID_HDS_MREAD_ISO_A_3},
 155         {MICROREAD_GATE_ID_MGT, MICROREAD_PIPE_ID_MGT},
 156         {MICROREAD_GATE_ID_OS, MICROREAD_PIPE_ID_OS},
 157         {MICROREAD_GATE_ID_MREAD_NFC_T1, MICROREAD_PIPE_ID_HDS_MREAD_NFC_T1},
 158         {MICROREAD_GATE_ID_MREAD_NFC_T3, MICROREAD_PIPE_ID_HDS_MREAD_NFC_T3},
 159         {MICROREAD_GATE_ID_P2P_TARGET, MICROREAD_PIPE_ID_HDS_P2P_TARGET},
 160         {MICROREAD_GATE_ID_P2P_INITIATOR, MICROREAD_PIPE_ID_HDS_P2P_INITIATOR}
 161 };
 162
 163 /* Largest headroom needed for outgoing custom commands */
 164 #define MICROREAD_CMDS_HEADROOM 2
 165 #define MICROREAD_CMD_TAILROOM  2
 166
 167 struct microread_info {
 168         struct nfc_phy_ops *phy_ops;
 169         void *phy_id;
 170
 171         struct nfc_hci_dev *hdev;
 172
 173         int async_cb_type;
 174         data_exchange_cb_t async_cb;
 175         void *async_cb_context;
 176 };
 177
 178 static int microread_open(struct nfc_hci_dev *hdev)
 179 {
 180         struct microread_info *info = nfc_hci_get_clientdata(hdev);
 181
 182         return info->phy_ops->enable(info->phy_id);
 183 }
 184
 185 static void microread_close(struct nfc_hci_dev *hdev)
 186 {
 187         struct microread_info *info = nfc_hci_get_clientdata(hdev);
 188
 189         info->phy_ops->disable(info->phy_id);
 190 }
 191
 192 static int microread_hci_ready(struct nfc_hci_dev *hdev)
 193 {
 194         int r;
 195         u8 param[4];
 196
 197         param[0] = 0x03;
 198         r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
 199                              MICROREAD_CMD_MREAD_SUBSCRIBE, param, 1, NULL);
 200         if (r)
 201                 return r;
 202
 203         r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_A_3,
 204                              MICROREAD_CMD_MREAD_SUBSCRIBE, NULL, 0, NULL);
 205         if (r)
 206                 return r;
 207
 208         param[0] = 0x00;
 209         param[1] = 0x03;
 210         param[2] = 0x00;
 211         r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_B,
 212                              MICROREAD_CMD_MREAD_SUBSCRIBE, param, 3, NULL);
 213         if (r)
 214                 return r;
 215
 216         r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_NFC_T1,
 217                              MICROREAD_CMD_MREAD_SUBSCRIBE, NULL, 0, NULL);
 218         if (r)
 219                 return r;
 220
 221         param[0] = 0xFF;
 222         param[1] = 0xFF;
 223         param[2] = 0x00;
 224         param[3] = 0x00;
 225         r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_NFC_T3,
 226                              MICROREAD_CMD_MREAD_SUBSCRIBE, param, 4, NULL);
 227
 228         return r;
 229 }
 230
 231 static int microread_xmit(struct nfc_hci_dev *hdev, struct sk_buff *skb)
 232 {
 233         struct microread_info *info = nfc_hci_get_clientdata(hdev);
 234
 235         return info->phy_ops->write(info->phy_id, skb);
 236 }
 237
 238 static int microread_start_poll(struct nfc_hci_dev *hdev,
 239                                 u32 im_protocols, u32 tm_protocols)
 240 {
 241         int r;
 242
 243         u8 param[2];
 244         u8 mode;
 245
 246         param[0] = 0x00;
 247         param[1] = 0x00;
 248
 249         if (im_protocols & NFC_PROTO_ISO14443_MASK)
 250                 param[0] |= (1 << 2);
 251
 252         if (im_protocols & NFC_PROTO_ISO14443_B_MASK)
 253                 param[0] |= 1;
 254
 255         if (im_protocols & NFC_PROTO_MIFARE_MASK)
 256                 param[1] |= 1;
 257
 258         if (im_protocols & NFC_PROTO_JEWEL_MASK)
 259                 param[0] |= (1 << 1);
 260
 261         if (im_protocols & NFC_PROTO_FELICA_MASK)
 262                 param[0] |= (1 << 5);
 263
 264         if (im_protocols & NFC_PROTO_NFC_DEP_MASK)
 265                 param[1] |= (1 << 1);
 266
 267         if ((im_protocols | tm_protocols) & NFC_PROTO_NFC_DEP_MASK) {
 268                 hdev->gb = nfc_get_local_general_bytes(hdev->ndev,
 269                                                        &hdev->gb_len);
 270                 if (hdev->gb == NULL || hdev->gb_len == 0) {
 271                         im_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
 272                         tm_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
 273                 }
 274         }
 275
 276         r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
 277                                MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 0);
 278         if (r)
 279                 return r;
 280
 281         mode = 0xff;
 282         r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
 283                               MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
 284         if (r)
 285                 return r;
 286
 287         if (im_protocols & NFC_PROTO_NFC_DEP_MASK) {
 288                 r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_INITIATOR,
 289                                       MICROREAD_PAR_P2P_INITIATOR_GI,
 290                                       hdev->gb, hdev->gb_len);
 291                 if (r)
 292                         return r;
 293         }
 294
 295         if (tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
 296                 r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
 297                                       MICROREAD_PAR_P2P_TARGET_GT,
 298                                       hdev->gb, hdev->gb_len);
 299                 if (r)
 300                         return r;
 301
 302                 mode = 0x02;
 303                 r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
 304                                       MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
 305                 if (r)
 306                         return r;
 307         }
 308
 309         return nfc_hci_send_event(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
 310                                   MICROREAD_EVT_MREAD_DISCOVERY_START_SOME,
 311                                   param, 2);
 312 }
 313
 314 static int microread_dep_link_up(struct nfc_hci_dev *hdev,
 315                                 struct nfc_target *target, u8 comm_mode,
 316                                 u8 *gb, size_t gb_len)
 317 {
 318         struct sk_buff *rgb_skb = NULL;
 319         int r;
 320
 321         r = nfc_hci_get_param(hdev, target->hci_reader_gate,
 322                               MICROREAD_PAR_P2P_INITIATOR_GT, &rgb_skb);
 323         if (r < 0)
 324                 return r;
 325
 326         if (rgb_skb->len == 0 || rgb_skb->len > NFC_GB_MAXSIZE) {
 327                 r = -EPROTO;
 328                 goto exit;
 329         }
 330
 331         r = nfc_set_remote_general_bytes(hdev->ndev, rgb_skb->data,
 332                                          rgb_skb->len);
 333         if (r == 0)
 334                 r = nfc_dep_link_is_up(hdev->ndev, target->idx, comm_mode,
 335                                        NFC_RF_INITIATOR);
 336 exit:
 337         kfree_skb(rgb_skb);
 338
 339         return r;
 340 }
 341
 342 static int microread_dep_link_down(struct nfc_hci_dev *hdev)
 343 {
 344         return nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_INITIATOR,
 345                                   MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 0);
 346 }
 347
 348 static int microread_target_from_gate(struct nfc_hci_dev *hdev, u8 gate,
 349                                       struct nfc_target *target)
 350 {
 351         switch (gate) {
 352         case MICROREAD_GATE_ID_P2P_INITIATOR:
 353                 target->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
 354                 break;
 355         default:
 356                 return -EPROTO;
 357         }
 358
 359         return 0;
 360 }
 361
 362 static int microread_complete_target_discovered(struct nfc_hci_dev *hdev,
 363                                                 u8 gate,
 364                                                 struct nfc_target *target)
 365 {
 366         return 0;
 367 }
 368
 369 #define MICROREAD_CB_TYPE_READER_ALL 1
 370
 371 static void microread_im_transceive_cb(void *context, struct sk_buff *skb,
 372                                        int err)
 373 {
 374         struct microread_info *info = context;
 375
 376         switch (info->async_cb_type) {
 377         case MICROREAD_CB_TYPE_READER_ALL:
 378                 if (err == 0) {
 379                         if (skb->len == 0) {
 380                                 err = -EPROTO;
 381                                 kfree_skb(skb);
 382                                 info->async_cb(info->async_cb_context, NULL,
 383                                                -EPROTO);
 384                                 return;
 385                         }
 386
 387                         if (skb->data[skb->len - 1] != 0) {
 388                                 err = nfc_hci_result_to_errno(
 389                                                        skb->data[skb->len - 1]);
 390                                 kfree_skb(skb);
 391                                 info->async_cb(info->async_cb_context, NULL,
 392                                                err);
 393                                 return;
 394                         }
 395
 396                         skb_trim(skb, skb->len - 1);    /* RF Error ind. */
 397                 }
 398                 info->async_cb(info->async_cb_context, skb, err);
 399                 break;
 400         default:
 401                 if (err == 0)
 402                         kfree_skb(skb);
 403                 break;
 404         }
 405 }
 406
 407 /*
 408  * Returns:
 409  * <= 0: driver handled the data exchange
 410  *    1: driver doesn't especially handle, please do standard processing
 411  */
 412 static int microread_im_transceive(struct nfc_hci_dev *hdev,
 413                                    struct nfc_target *target,
 414                                    struct sk_buff *skb, data_exchange_cb_t cb,
 415                                    void *cb_context)
 416 {
 417         struct microread_info *info = nfc_hci_get_clientdata(hdev);
 418         u8 control_bits;
 419         u16 crc;
 420
 421         pr_info("data exchange to gate 0x%x\n", target->hci_reader_gate);
 422
 423         if (target->hci_reader_gate == MICROREAD_GATE_ID_P2P_INITIATOR) {
 424                 *skb_push(skb, 1) = 0;
 425
 426                 return nfc_hci_send_event(hdev, target->hci_reader_gate,
 427                                      MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF,
 428                                      skb->data, skb->len);
 429         }
 430
 431         switch (target->hci_reader_gate) {
 432         case MICROREAD_GATE_ID_MREAD_ISO_A:
 433                 control_bits = 0xCB;
 434                 break;
 435         case MICROREAD_GATE_ID_MREAD_ISO_A_3:
 436                 control_bits = 0xCB;
 437                 break;
 438         case MICROREAD_GATE_ID_MREAD_ISO_B:
 439                 control_bits = 0xCB;
 440                 break;
 441         case MICROREAD_GATE_ID_MREAD_NFC_T1:
 442                 control_bits = 0x1B;
 443
 444                 crc = crc_ccitt(0xffff, skb->data, skb->len);
 445                 crc = ~crc;
 446                 *skb_put(skb, 1) = crc & 0xff;
 447                 *skb_put(skb, 1) = crc >> 8;
 448                 break;
 449         case MICROREAD_GATE_ID_MREAD_NFC_T3:
 450                 control_bits = 0xDB;
 451                 break;
 452         default:
 453                 pr_info("Abort im_transceive to invalid gate 0x%x\n",
 454                         target->hci_reader_gate);
 455                 return 1;
 456         }
 457
 458         *skb_push(skb, 1) = control_bits;
 459
 460         info->async_cb_type = MICROREAD_CB_TYPE_READER_ALL;
 461         info->async_cb = cb;
 462         info->async_cb_context = cb_context;
 463
 464         return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
 465                                       MICROREAD_CMD_MREAD_EXCHANGE,
 466                                       skb->data, skb->len,
 467                                       microread_im_transceive_cb, info);
 468 }
 469
 470 static int microread_tm_send(struct nfc_hci_dev *hdev, struct sk_buff *skb)
 471 {
 472         int r;
 473
 474         r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_TARGET,
 475                                MICROREAD_EVT_MCARD_EXCHANGE,
 476                                skb->data, skb->len);
 477
 478         kfree_skb(skb);
 479
 480         return r;
 481 }
 482
 483 static void microread_target_discovered(struct nfc_hci_dev *hdev, u8 gate,
 484                                         struct sk_buff *skb)
 485 {
 486         struct nfc_target *targets;
 487         int r = 0;
 488
 489         pr_info("target discovered to gate 0x%x\n", gate);
 490
 491         targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
 492         if (targets == NULL) {
 493                 r = -ENOMEM;
 494                 goto exit;
 495         }
 496
 497         targets->hci_reader_gate = gate;
 498
 499         switch (gate) {
 500         case MICROREAD_GATE_ID_MREAD_ISO_A:
 501                 targets->supported_protocols =
 502                       nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A_SAK]);
 503                 targets->sens_res =
 504                          be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A_ATQA]);
 505                 targets->sel_res = skb->data[MICROREAD_EMCF_A_SAK];
 506                 memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A_UID],
 507                        skb->data[MICROREAD_EMCF_A_LEN]);
 508                 targets->nfcid1_len = skb->data[MICROREAD_EMCF_A_LEN];
 509                 break;
 510         case MICROREAD_GATE_ID_MREAD_ISO_A_3:
 511                 targets->supported_protocols =
 512                       nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A3_SAK]);
 513                 targets->sens_res =
 514                          be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A3_ATQA]);
 515                 targets->sel_res = skb->data[MICROREAD_EMCF_A3_SAK];
 516                 memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A3_UID],
 517                        skb->data[MICROREAD_EMCF_A3_LEN]);
 518                 targets->nfcid1_len = skb->data[MICROREAD_EMCF_A3_LEN];
 519                 break;
 520         case MICROREAD_GATE_ID_MREAD_ISO_B:
 521                 targets->supported_protocols = NFC_PROTO_ISO14443_B_MASK;
 522                 memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_B_UID], 4);
 523                 targets->nfcid1_len = 4;
 524                 break;
 525         case MICROREAD_GATE_ID_MREAD_NFC_T1:
 526                 targets->supported_protocols = NFC_PROTO_JEWEL_MASK;
 527                 targets->sens_res =
 528                         le16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_T1_ATQA]);
 529                 memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T1_UID], 4);
 530                 targets->nfcid1_len = 4;
 531                 break;
 532         case MICROREAD_GATE_ID_MREAD_NFC_T3:
 533                 targets->supported_protocols = NFC_PROTO_FELICA_MASK;
 534                 memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T3_UID], 8);
 535                 targets->nfcid1_len = 8;
 536                 break;
 537         default:
 538                 pr_info("discard target discovered to gate 0x%x\n", gate);
 539                 goto exit_free;
 540         }
 541
 542         r = nfc_targets_found(hdev->ndev, targets, 1);
 543
 544 exit_free:
 545         kfree(targets);
 546
 547 exit:
 548         kfree_skb(skb);
 549
 550         if (r)
 551                 pr_err("Failed to handle discovered target err=%d\n", r);
 552 }
 553
 554 static int microread_event_received(struct nfc_hci_dev *hdev, u8 gate,
 555                                      u8 event, struct sk_buff *skb)
 556 {
 557         int r;
 558         u8 mode;
 559
 560         pr_info("Microread received event 0x%x to gate 0x%x\n", event, gate);
 561
 562         switch (event) {
 563         case MICROREAD_EVT_MREAD_CARD_FOUND:
 564                 microread_target_discovered(hdev, gate, skb);
 565                 return 0;
 566
 567         case MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF:
 568                 if (skb->len < 1) {
 569                         kfree_skb(skb);
 570                         return -EPROTO;
 571                 }
 572
 573                 if (skb->data[skb->len - 1]) {
 574                         kfree_skb(skb);
 575                         return -EIO;
 576                 }
 577
 578                 skb_trim(skb, skb->len - 1);
 579
 580                 r = nfc_tm_data_received(hdev->ndev, skb);
 581                 break;
 582
 583         case MICROREAD_EVT_MCARD_FIELD_ON:
 584         case MICROREAD_EVT_MCARD_FIELD_OFF:
 585                 kfree_skb(skb);
 586                 return 0;
 587
 588         case MICROREAD_EVT_P2P_TARGET_ACTIVATED:
 589                 r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK,
 590                                      NFC_COMM_PASSIVE, skb->data,
 591                                      skb->len);
 592
 593                 kfree_skb(skb);
 594                 break;
 595
 596         case MICROREAD_EVT_MCARD_EXCHANGE:
 597                 if (skb->len < 1) {
 598                         kfree_skb(skb);
 599                         return -EPROTO;
 600                 }
 601
 602                 if (skb->data[skb->len-1]) {
 603                         kfree_skb(skb);
 604                         return -EIO;
 605                 }
 606
 607                 skb_trim(skb, skb->len - 1);
 608
 609                 r = nfc_tm_data_received(hdev->ndev, skb);
 610                 break;
 611
 612         case MICROREAD_EVT_P2P_TARGET_DEACTIVATED:
 613                 kfree_skb(skb);
 614
 615                 mode = 0xff;
 616                 r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
 617                                       MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
 618                 if (r)
 619                         break;
 620
 621                 r = nfc_hci_send_event(hdev, gate,
 622                                        MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL,
 623                                        0);
 624                 break;
 625
 626         default:
 627                 return 1;
 628         }
 629
 630         return r;
 631 }
 632
 633 static struct nfc_hci_ops microread_hci_ops = {
 634         .open = microread_open,
 635         .close = microread_close,
 636         .hci_ready = microread_hci_ready,
 637         .xmit = microread_xmit,
 638         .start_poll = microread_start_poll,
 639         .dep_link_up = microread_dep_link_up,
 640         .dep_link_down = microread_dep_link_down,
 641         .target_from_gate = microread_target_from_gate,
 642         .complete_target_discovered = microread_complete_target_discovered,
 643         .im_transceive = microread_im_transceive,
 644         .tm_send = microread_tm_send,
 645         .check_presence = NULL,
 646         .event_received = microread_event_received,
 647 };
 648
 649 int microread_probe(void *phy_id, struct nfc_phy_ops *phy_ops, char *llc_name,
 650                     int phy_headroom, int phy_tailroom, int phy_payload,
 651                     struct nfc_hci_dev **hdev)
 652 {
 653         struct microread_info *info;
 654         unsigned long quirks = 0;
 655         u32 protocols;
 656         struct nfc_hci_init_data init_data;
 657         int r;
 658
 659         info = kzalloc(sizeof(struct microread_info), GFP_KERNEL);
 660         if (!info) {
 661                 r = -ENOMEM;
 662                 goto err_info_alloc;
 663         }
 664
 665         info->phy_ops = phy_ops;
 666         info->phy_id = phy_id;
 667
 668         init_data.gate_count = ARRAY_SIZE(microread_gates);
 669         memcpy(init_data.gates, microread_gates, sizeof(microread_gates));
 670
 671         strcpy(init_data.session_id, "MICROREA");
 672
 673         set_bit(NFC_HCI_QUIRK_SHORT_CLEAR, &quirks);
 674
 675         protocols = NFC_PROTO_JEWEL_MASK |
 676                     NFC_PROTO_MIFARE_MASK |
 677                     NFC_PROTO_FELICA_MASK |
 678                     NFC_PROTO_ISO14443_MASK |
 679                     NFC_PROTO_ISO14443_B_MASK |
 680                     NFC_PROTO_NFC_DEP_MASK;
 681
 682         info->hdev = nfc_hci_allocate_device(&microread_hci_ops, &init_data,
 683                                              quirks, protocols, llc_name,
 684                                              phy_headroom +
 685                                              MICROREAD_CMDS_HEADROOM,
 686                                              phy_tailroom +
 687                                              MICROREAD_CMD_TAILROOM,
 688                                              phy_payload);
 689         if (!info->hdev) {
 690                 pr_err("Cannot allocate nfc hdev\n");
 691                 r = -ENOMEM;
 692                 goto err_alloc_hdev;
 693         }
 694
 695         nfc_hci_set_clientdata(info->hdev, info);
 696
 697         r = nfc_hci_register_device(info->hdev);
 698         if (r)
 699                 goto err_regdev;
 700
 701         *hdev = info->hdev;
 702
 703         return 0;
 704
 705 err_regdev:
 706         nfc_hci_free_device(info->hdev);
 707
 708 err_alloc_hdev:
 709         kfree(info);
 710
 711 err_info_alloc:
 712         return r;
 713 }
 714 EXPORT_SYMBOL(microread_probe);
 715
 716 void microread_remove(struct nfc_hci_dev *hdev)
 717 {
 718         struct microread_info *info = nfc_hci_get_clientdata(hdev);
 719
 720         nfc_hci_unregister_device(hdev);
 721         nfc_hci_free_device(hdev);
 722         kfree(info);
 723 }
 724 EXPORT_SYMBOL(microread_remove);
 725
 726 MODULE_LICENSE("GPL");
 727 MODULE_DESCRIPTION(DRIVER_DESC);