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