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 kfree_skb(skb); 368 info->async_cb(info->async_cb_context, NULL, 369 -EPROTO); 370 return; 371 } 372 373 if (skb->data[skb->len - 1] != 0) { 374 err = nfc_hci_result_to_errno( 375 skb->data[skb->len - 1]); 376 kfree_skb(skb); 377 info->async_cb(info->async_cb_context, NULL, 378 err); 379 return; 380 } 381 382 skb_trim(skb, skb->len - 1); /* RF Error ind. */ 383 } 384 info->async_cb(info->async_cb_context, skb, err); 385 break; 386 default: 387 if (err == 0) 388 kfree_skb(skb); 389 break; 390 } 391 } 392 393 /* 394 * Returns: 395 * <= 0: driver handled the data exchange 396 * 1: driver doesn't especially handle, please do standard processing 397 */ 398 static int microread_im_transceive(struct nfc_hci_dev *hdev, 399 struct nfc_target *target, 400 struct sk_buff *skb, data_exchange_cb_t cb, 401 void *cb_context) 402 { 403 struct microread_info *info = nfc_hci_get_clientdata(hdev); 404 u8 control_bits; 405 u16 crc; 406 407 pr_info("data exchange to gate 0x%x\n", target->hci_reader_gate); 408 409 if (target->hci_reader_gate == MICROREAD_GATE_ID_P2P_INITIATOR) { 410 *(u8 *)skb_push(skb, 1) = 0; 411 412 return nfc_hci_send_event(hdev, target->hci_reader_gate, 413 MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF, 414 skb->data, skb->len); 415 } 416 417 switch (target->hci_reader_gate) { 418 case MICROREAD_GATE_ID_MREAD_ISO_A: 419 control_bits = 0xCB; 420 break; 421 case MICROREAD_GATE_ID_MREAD_ISO_A_3: 422 control_bits = 0xCB; 423 break; 424 case MICROREAD_GATE_ID_MREAD_ISO_B: 425 control_bits = 0xCB; 426 break; 427 case MICROREAD_GATE_ID_MREAD_NFC_T1: 428 control_bits = 0x1B; 429 430 crc = crc_ccitt(0xffff, skb->data, skb->len); 431 crc = ~crc; 432 skb_put_u8(skb, crc & 0xff); 433 skb_put_u8(skb, crc >> 8); 434 break; 435 case MICROREAD_GATE_ID_MREAD_NFC_T3: 436 control_bits = 0xDB; 437 break; 438 default: 439 pr_info("Abort im_transceive to invalid gate 0x%x\n", 440 target->hci_reader_gate); 441 return 1; 442 } 443 444 *(u8 *)skb_push(skb, 1) = control_bits; 445 446 info->async_cb_type = MICROREAD_CB_TYPE_READER_ALL; 447 info->async_cb = cb; 448 info->async_cb_context = cb_context; 449 450 return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate, 451 MICROREAD_CMD_MREAD_EXCHANGE, 452 skb->data, skb->len, 453 microread_im_transceive_cb, info); 454 } 455 456 static int microread_tm_send(struct nfc_hci_dev *hdev, struct sk_buff *skb) 457 { 458 int r; 459 460 r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_TARGET, 461 MICROREAD_EVT_MCARD_EXCHANGE, 462 skb->data, skb->len); 463 464 kfree_skb(skb); 465 466 return r; 467 } 468 469 static void microread_target_discovered(struct nfc_hci_dev *hdev, u8 gate, 470 struct sk_buff *skb) 471 { 472 struct nfc_target *targets; 473 int r = 0; 474 475 pr_info("target discovered to gate 0x%x\n", gate); 476 477 targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL); 478 if (targets == NULL) { 479 r = -ENOMEM; 480 goto exit; 481 } 482 483 targets->hci_reader_gate = gate; 484 485 switch (gate) { 486 case MICROREAD_GATE_ID_MREAD_ISO_A: 487 targets->supported_protocols = 488 nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A_SAK]); 489 targets->sens_res = 490 be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A_ATQA]); 491 targets->sel_res = skb->data[MICROREAD_EMCF_A_SAK]; 492 targets->nfcid1_len = skb->data[MICROREAD_EMCF_A_LEN]; 493 if (targets->nfcid1_len > sizeof(targets->nfcid1)) { 494 r = -EINVAL; 495 goto exit_free; 496 } 497 memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A_UID], 498 targets->nfcid1_len); 499 break; 500 case MICROREAD_GATE_ID_MREAD_ISO_A_3: 501 targets->supported_protocols = 502 nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A3_SAK]); 503 targets->sens_res = 504 be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A3_ATQA]); 505 targets->sel_res = skb->data[MICROREAD_EMCF_A3_SAK]; 506 targets->nfcid1_len = skb->data[MICROREAD_EMCF_A3_LEN]; 507 if (targets->nfcid1_len > sizeof(targets->nfcid1)) { 508 r = -EINVAL; 509 goto exit_free; 510 } 511 memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A3_UID], 512 targets->nfcid1_len); 513 break; 514 case MICROREAD_GATE_ID_MREAD_ISO_B: 515 targets->supported_protocols = NFC_PROTO_ISO14443_B_MASK; 516 memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_B_UID], 4); 517 targets->nfcid1_len = 4; 518 break; 519 case MICROREAD_GATE_ID_MREAD_NFC_T1: 520 targets->supported_protocols = NFC_PROTO_JEWEL_MASK; 521 targets->sens_res = 522 le16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_T1_ATQA]); 523 memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T1_UID], 4); 524 targets->nfcid1_len = 4; 525 break; 526 case MICROREAD_GATE_ID_MREAD_NFC_T3: 527 targets->supported_protocols = NFC_PROTO_FELICA_MASK; 528 memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T3_UID], 8); 529 targets->nfcid1_len = 8; 530 break; 531 default: 532 pr_info("discard target discovered to gate 0x%x\n", gate); 533 goto exit_free; 534 } 535 536 r = nfc_targets_found(hdev->ndev, targets, 1); 537 538 exit_free: 539 kfree(targets); 540 541 exit: 542 kfree_skb(skb); 543 544 if (r) 545 pr_err("Failed to handle discovered target err=%d\n", r); 546 } 547 548 static int microread_event_received(struct nfc_hci_dev *hdev, u8 pipe, 549 u8 event, struct sk_buff *skb) 550 { 551 int r; 552 u8 gate = hdev->pipes[pipe].gate; 553 u8 mode; 554 555 pr_info("Microread received event 0x%x to gate 0x%x\n", event, gate); 556 557 switch (event) { 558 case MICROREAD_EVT_MREAD_CARD_FOUND: 559 microread_target_discovered(hdev, gate, skb); 560 return 0; 561 562 case MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF: 563 if (skb->len < 1) { 564 kfree_skb(skb); 565 return -EPROTO; 566 } 567 568 if (skb->data[skb->len - 1]) { 569 kfree_skb(skb); 570 return -EIO; 571 } 572 573 skb_trim(skb, skb->len - 1); 574 575 r = nfc_tm_data_received(hdev->ndev, skb); 576 break; 577 578 case MICROREAD_EVT_MCARD_FIELD_ON: 579 case MICROREAD_EVT_MCARD_FIELD_OFF: 580 kfree_skb(skb); 581 return 0; 582 583 case MICROREAD_EVT_P2P_TARGET_ACTIVATED: 584 r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK, 585 NFC_COMM_PASSIVE, skb->data, 586 skb->len); 587 588 kfree_skb(skb); 589 break; 590 591 case MICROREAD_EVT_MCARD_EXCHANGE: 592 if (skb->len < 1) { 593 kfree_skb(skb); 594 return -EPROTO; 595 } 596 597 if (skb->data[skb->len-1]) { 598 kfree_skb(skb); 599 return -EIO; 600 } 601 602 skb_trim(skb, skb->len - 1); 603 604 r = nfc_tm_data_received(hdev->ndev, skb); 605 break; 606 607 case MICROREAD_EVT_P2P_TARGET_DEACTIVATED: 608 kfree_skb(skb); 609 610 mode = 0xff; 611 r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET, 612 MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1); 613 if (r) 614 break; 615 616 r = nfc_hci_send_event(hdev, gate, 617 MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 618 0); 619 break; 620 621 default: 622 return 1; 623 } 624 625 return r; 626 } 627 628 static struct nfc_hci_ops microread_hci_ops = { 629 .open = microread_open, 630 .close = microread_close, 631 .hci_ready = microread_hci_ready, 632 .xmit = microread_xmit, 633 .start_poll = microread_start_poll, 634 .dep_link_up = microread_dep_link_up, 635 .dep_link_down = microread_dep_link_down, 636 .target_from_gate = microread_target_from_gate, 637 .complete_target_discovered = microread_complete_target_discovered, 638 .im_transceive = microread_im_transceive, 639 .tm_send = microread_tm_send, 640 .check_presence = NULL, 641 .event_received = microread_event_received, 642 }; 643 644 int microread_probe(void *phy_id, struct nfc_phy_ops *phy_ops, char *llc_name, 645 int phy_headroom, int phy_tailroom, int phy_payload, 646 struct nfc_hci_dev **hdev) 647 { 648 struct microread_info *info; 649 unsigned long quirks = 0; 650 u32 protocols; 651 struct nfc_hci_init_data init_data; 652 int r; 653 654 info = kzalloc(sizeof(struct microread_info), GFP_KERNEL); 655 if (!info) { 656 r = -ENOMEM; 657 goto err_info_alloc; 658 } 659 660 info->phy_ops = phy_ops; 661 info->phy_id = phy_id; 662 663 init_data.gate_count = ARRAY_SIZE(microread_gates); 664 memcpy(init_data.gates, microread_gates, sizeof(microread_gates)); 665 666 strcpy(init_data.session_id, "MICROREA"); 667 668 set_bit(NFC_HCI_QUIRK_SHORT_CLEAR, &quirks); 669 670 protocols = NFC_PROTO_JEWEL_MASK | 671 NFC_PROTO_MIFARE_MASK | 672 NFC_PROTO_FELICA_MASK | 673 NFC_PROTO_ISO14443_MASK | 674 NFC_PROTO_ISO14443_B_MASK | 675 NFC_PROTO_NFC_DEP_MASK; 676 677 info->hdev = nfc_hci_allocate_device(µread_hci_ops, &init_data, 678 quirks, protocols, llc_name, 679 phy_headroom + 680 MICROREAD_CMDS_HEADROOM, 681 phy_tailroom + 682 MICROREAD_CMD_TAILROOM, 683 phy_payload); 684 if (!info->hdev) { 685 pr_err("Cannot allocate nfc hdev\n"); 686 r = -ENOMEM; 687 goto err_alloc_hdev; 688 } 689 690 nfc_hci_set_clientdata(info->hdev, info); 691 692 r = nfc_hci_register_device(info->hdev); 693 if (r) 694 goto err_regdev; 695 696 *hdev = info->hdev; 697 698 return 0; 699 700 err_regdev: 701 nfc_hci_free_device(info->hdev); 702 703 err_alloc_hdev: 704 kfree(info); 705 706 err_info_alloc: 707 return r; 708 } 709 EXPORT_SYMBOL(microread_probe); 710 711 void microread_remove(struct nfc_hci_dev *hdev) 712 { 713 struct microread_info *info = nfc_hci_get_clientdata(hdev); 714 715 nfc_hci_unregister_device(hdev); 716 nfc_hci_free_device(hdev); 717 kfree(info); 718 } 719 EXPORT_SYMBOL(microread_remove); 720 721 MODULE_LICENSE("GPL"); 722 MODULE_DESCRIPTION(DRIVER_DESC); 723