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