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