1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * -------------------------------------------------------------------- 4 * Driver for ST NFC Transceiver ST95HF 5 * -------------------------------------------------------------------- 6 * Copyright (C) 2015 STMicroelectronics Pvt. Ltd. All rights reserved. 7 */ 8 9 #include <linux/err.h> 10 #include <linux/gpio/consumer.h> 11 #include <linux/init.h> 12 #include <linux/interrupt.h> 13 #include <linux/irq.h> 14 #include <linux/module.h> 15 #include <linux/netdevice.h> 16 #include <linux/nfc.h> 17 #include <linux/of.h> 18 #include <linux/property.h> 19 #include <linux/regulator/consumer.h> 20 #include <linux/wait.h> 21 #include <net/nfc/digital.h> 22 #include <net/nfc/nfc.h> 23 24 #include "spi.h" 25 26 /* supported protocols */ 27 #define ST95HF_SUPPORTED_PROT (NFC_PROTO_ISO14443_MASK | \ 28 NFC_PROTO_ISO14443_B_MASK | \ 29 NFC_PROTO_ISO15693_MASK) 30 /* driver capabilities */ 31 #define ST95HF_CAPABILITIES NFC_DIGITAL_DRV_CAPS_IN_CRC 32 33 /* Command Send Interface */ 34 /* ST95HF_COMMAND_SEND CMD Ids */ 35 #define ECHO_CMD 0x55 36 #define WRITE_REGISTER_CMD 0x9 37 #define PROTOCOL_SELECT_CMD 0x2 38 #define SEND_RECEIVE_CMD 0x4 39 40 /* Select protocol codes */ 41 #define ISO15693_PROTOCOL_CODE 0x1 42 #define ISO14443A_PROTOCOL_CODE 0x2 43 #define ISO14443B_PROTOCOL_CODE 0x3 44 45 /* 46 * head room len is 3 47 * 1 byte for control byte 48 * 1 byte for cmd 49 * 1 byte for size 50 */ 51 #define ST95HF_HEADROOM_LEN 3 52 53 /* 54 * tailroom is 1 for ISO14443A 55 * and 0 for ISO14443B/ISO15693, 56 * hence the max value 1 should be 57 * taken. 58 */ 59 #define ST95HF_TAILROOM_LEN 1 60 61 /* Command Response interface */ 62 #define MAX_RESPONSE_BUFFER_SIZE 280 63 #define ECHORESPONSE 0x55 64 #define ST95HF_ERR_MASK 0xF 65 #define ST95HF_TIMEOUT_ERROR 0x87 66 #define ST95HF_NFCA_CRC_ERR_MASK 0x20 67 #define ST95HF_NFCB_CRC_ERR_MASK 0x01 68 69 /* ST95HF transmission flag values */ 70 #define TRFLAG_NFCA_SHORT_FRAME 0x07 71 #define TRFLAG_NFCA_STD_FRAME 0x08 72 #define TRFLAG_NFCA_STD_FRAME_CRC 0x28 73 74 /* Misc defs */ 75 #define HIGH 1 76 #define LOW 0 77 #define ISO14443A_RATS_REQ 0xE0 78 #define RATS_TB1_PRESENT_MASK 0x20 79 #define RATS_TA1_PRESENT_MASK 0x10 80 #define TB1_FWI_MASK 0xF0 81 #define WTX_REQ_FROM_TAG 0xF2 82 83 #define MAX_CMD_LEN 0x7 84 85 #define MAX_CMD_PARAMS 4 86 struct cmd { 87 int cmd_len; 88 unsigned char cmd_id; 89 unsigned char no_cmd_params; 90 unsigned char cmd_params[MAX_CMD_PARAMS]; 91 enum req_type req; 92 }; 93 94 struct param_list { 95 int param_offset; 96 int new_param_val; 97 }; 98 99 /* 100 * List of top-level cmds to be used internally by the driver. 101 * All these commands are build on top of ST95HF basic commands 102 * such as SEND_RECEIVE_CMD, PROTOCOL_SELECT_CMD, etc. 103 * These top level cmds are used internally while implementing various ops of 104 * digital layer/driver probe or extending the digital framework layer for 105 * features that are not yet implemented there, for example, WTX cmd handling. 106 */ 107 enum st95hf_cmd_list { 108 CMD_ECHO, 109 CMD_ISO14443A_CONFIG, 110 CMD_ISO14443A_DEMOGAIN, 111 CMD_ISO14443B_DEMOGAIN, 112 CMD_ISO14443A_PROTOCOL_SELECT, 113 CMD_ISO14443B_PROTOCOL_SELECT, 114 CMD_WTX_RESPONSE, 115 CMD_FIELD_OFF, 116 CMD_ISO15693_PROTOCOL_SELECT, 117 }; 118 119 static const struct cmd cmd_array[] = { 120 [CMD_ECHO] = { 121 .cmd_len = 0x2, 122 .cmd_id = ECHO_CMD, 123 .no_cmd_params = 0, 124 .req = SYNC, 125 }, 126 [CMD_ISO14443A_CONFIG] = { 127 .cmd_len = 0x7, 128 .cmd_id = WRITE_REGISTER_CMD, 129 .no_cmd_params = 0x4, 130 .cmd_params = {0x3A, 0x00, 0x5A, 0x04}, 131 .req = SYNC, 132 }, 133 [CMD_ISO14443A_DEMOGAIN] = { 134 .cmd_len = 0x7, 135 .cmd_id = WRITE_REGISTER_CMD, 136 .no_cmd_params = 0x4, 137 .cmd_params = {0x68, 0x01, 0x01, 0xDF}, 138 .req = SYNC, 139 }, 140 [CMD_ISO14443B_DEMOGAIN] = { 141 .cmd_len = 0x7, 142 .cmd_id = WRITE_REGISTER_CMD, 143 .no_cmd_params = 0x4, 144 .cmd_params = {0x68, 0x01, 0x01, 0x51}, 145 .req = SYNC, 146 }, 147 [CMD_ISO14443A_PROTOCOL_SELECT] = { 148 .cmd_len = 0x7, 149 .cmd_id = PROTOCOL_SELECT_CMD, 150 .no_cmd_params = 0x4, 151 .cmd_params = {ISO14443A_PROTOCOL_CODE, 0x00, 0x01, 0xA0}, 152 .req = SYNC, 153 }, 154 [CMD_ISO14443B_PROTOCOL_SELECT] = { 155 .cmd_len = 0x7, 156 .cmd_id = PROTOCOL_SELECT_CMD, 157 .no_cmd_params = 0x4, 158 .cmd_params = {ISO14443B_PROTOCOL_CODE, 0x01, 0x03, 0xFF}, 159 .req = SYNC, 160 }, 161 [CMD_WTX_RESPONSE] = { 162 .cmd_len = 0x6, 163 .cmd_id = SEND_RECEIVE_CMD, 164 .no_cmd_params = 0x3, 165 .cmd_params = {0xF2, 0x00, TRFLAG_NFCA_STD_FRAME_CRC}, 166 .req = ASYNC, 167 }, 168 [CMD_FIELD_OFF] = { 169 .cmd_len = 0x5, 170 .cmd_id = PROTOCOL_SELECT_CMD, 171 .no_cmd_params = 0x2, 172 .cmd_params = {0x0, 0x0}, 173 .req = SYNC, 174 }, 175 [CMD_ISO15693_PROTOCOL_SELECT] = { 176 .cmd_len = 0x5, 177 .cmd_id = PROTOCOL_SELECT_CMD, 178 .no_cmd_params = 0x2, 179 .cmd_params = {ISO15693_PROTOCOL_CODE, 0x0D}, 180 .req = SYNC, 181 }, 182 }; 183 184 /* st95_digital_cmd_complete_arg stores client context */ 185 struct st95_digital_cmd_complete_arg { 186 struct sk_buff *skb_resp; 187 nfc_digital_cmd_complete_t complete_cb; 188 void *cb_usrarg; 189 bool rats; 190 }; 191 192 /* 193 * structure containing ST95HF driver specific data. 194 * @spicontext: structure containing information required 195 * for spi communication between st95hf and host. 196 * @ddev: nfc digital device object. 197 * @nfcdev: nfc device object. 198 * @enable_gpiod: gpio used to enable st95hf transceiver. 199 * @complete_cb_arg: structure to store various context information 200 * that is passed from nfc requesting thread to the threaded ISR. 201 * @st95hf_supply: regulator "consumer" for NFC device. 202 * @sendrcv_trflag: last byte of frame send by sendrecv command 203 * of st95hf. This byte contains transmission flag info. 204 * @exchange_lock: semaphore used for signaling the st95hf_remove 205 * function that the last outstanding async nfc request is finished. 206 * @rm_lock: mutex for ensuring safe access of nfc digital object 207 * from threaded ISR. Usage of this mutex avoids any race between 208 * deletion of the object from st95hf_remove() and its access from 209 * the threaded ISR. 210 * @nfcdev_free: flag to have the state of nfc device object. 211 * [alive | died] 212 * @current_protocol: current nfc protocol. 213 * @current_rf_tech: current rf technology. 214 * @fwi: frame waiting index, received in reply of RATS according to 215 * digital protocol. 216 */ 217 struct st95hf_context { 218 struct st95hf_spi_context spicontext; 219 struct nfc_digital_dev *ddev; 220 struct nfc_dev *nfcdev; 221 struct gpio_desc *enable_gpiod; 222 struct st95_digital_cmd_complete_arg complete_cb_arg; 223 struct regulator *st95hf_supply; 224 unsigned char sendrcv_trflag; 225 struct semaphore exchange_lock; 226 struct mutex rm_lock; 227 bool nfcdev_free; 228 u8 current_protocol; 229 u8 current_rf_tech; 230 int fwi; 231 }; 232 233 /* 234 * st95hf_send_recv_cmd() is for sending commands to ST95HF 235 * that are described in the cmd_array[]. It can optionally 236 * receive the response if the cmd request is of type 237 * SYNC. For that to happen caller must pass true to recv_res. 238 * For ASYNC request, recv_res is ignored and the 239 * function will never try to receive the response on behalf 240 * of the caller. 241 */ 242 static int st95hf_send_recv_cmd(struct st95hf_context *st95context, 243 enum st95hf_cmd_list cmd, 244 int no_modif, 245 struct param_list *list_array, 246 bool recv_res) 247 { 248 unsigned char spi_cmd_buffer[MAX_CMD_LEN]; 249 int i, ret; 250 struct device *dev = &st95context->spicontext.spidev->dev; 251 252 if (cmd_array[cmd].cmd_len > MAX_CMD_LEN) 253 return -EINVAL; 254 if (cmd_array[cmd].no_cmd_params < no_modif) 255 return -EINVAL; 256 if (no_modif && !list_array) 257 return -EINVAL; 258 259 spi_cmd_buffer[0] = ST95HF_COMMAND_SEND; 260 spi_cmd_buffer[1] = cmd_array[cmd].cmd_id; 261 spi_cmd_buffer[2] = cmd_array[cmd].no_cmd_params; 262 263 memcpy(&spi_cmd_buffer[3], cmd_array[cmd].cmd_params, 264 spi_cmd_buffer[2]); 265 266 for (i = 0; i < no_modif; i++) { 267 if (list_array[i].param_offset >= cmd_array[cmd].no_cmd_params) 268 return -EINVAL; 269 spi_cmd_buffer[3 + list_array[i].param_offset] = 270 list_array[i].new_param_val; 271 } 272 273 ret = st95hf_spi_send(&st95context->spicontext, 274 spi_cmd_buffer, 275 cmd_array[cmd].cmd_len, 276 cmd_array[cmd].req); 277 if (ret) { 278 dev_err(dev, "st95hf_spi_send failed with error %d\n", ret); 279 return ret; 280 } 281 282 if (cmd_array[cmd].req == SYNC && recv_res) { 283 unsigned char st95hf_response_arr[2]; 284 285 ret = st95hf_spi_recv_response(&st95context->spicontext, 286 st95hf_response_arr); 287 if (ret < 0) { 288 dev_err(dev, "spi error from st95hf_spi_recv_response(), err = 0x%x\n", 289 ret); 290 return ret; 291 } 292 293 if (st95hf_response_arr[0]) { 294 dev_err(dev, "st95hf error from st95hf_spi_recv_response(), err = 0x%x\n", 295 st95hf_response_arr[0]); 296 return -EIO; 297 } 298 } 299 300 return 0; 301 } 302 303 static int st95hf_echo_command(struct st95hf_context *st95context) 304 { 305 int result = 0; 306 unsigned char echo_response; 307 308 result = st95hf_send_recv_cmd(st95context, CMD_ECHO, 0, NULL, false); 309 if (result) 310 return result; 311 312 /* If control reached here, response can be taken */ 313 result = st95hf_spi_recv_echo_res(&st95context->spicontext, 314 &echo_response); 315 if (result) { 316 dev_err(&st95context->spicontext.spidev->dev, 317 "err: echo response receive error = 0x%x\n", result); 318 return result; 319 } 320 321 if (echo_response == ECHORESPONSE) 322 return 0; 323 324 dev_err(&st95context->spicontext.spidev->dev, "err: echo res is 0x%x\n", 325 echo_response); 326 327 return -EIO; 328 } 329 330 static int secondary_configuration_type4a(struct st95hf_context *stcontext) 331 { 332 int result = 0; 333 struct device *dev = &stcontext->nfcdev->dev; 334 335 /* 14443A config setting after select protocol */ 336 result = st95hf_send_recv_cmd(stcontext, 337 CMD_ISO14443A_CONFIG, 338 0, 339 NULL, 340 true); 341 if (result) { 342 dev_err(dev, "type a config cmd, err = 0x%x\n", result); 343 return result; 344 } 345 346 /* 14443A demo gain setting */ 347 result = st95hf_send_recv_cmd(stcontext, 348 CMD_ISO14443A_DEMOGAIN, 349 0, 350 NULL, 351 true); 352 if (result) 353 dev_err(dev, "type a demogain cmd, err = 0x%x\n", result); 354 355 return result; 356 } 357 358 static int secondary_configuration_type4b(struct st95hf_context *stcontext) 359 { 360 int result = 0; 361 struct device *dev = &stcontext->nfcdev->dev; 362 363 result = st95hf_send_recv_cmd(stcontext, 364 CMD_ISO14443B_DEMOGAIN, 365 0, 366 NULL, 367 true); 368 if (result) 369 dev_err(dev, "type b demogain cmd, err = 0x%x\n", result); 370 371 return result; 372 } 373 374 static int st95hf_select_protocol(struct st95hf_context *stcontext, int type) 375 { 376 int result = 0; 377 struct device *dev; 378 379 dev = &stcontext->nfcdev->dev; 380 381 switch (type) { 382 case NFC_DIGITAL_RF_TECH_106A: 383 stcontext->current_rf_tech = NFC_DIGITAL_RF_TECH_106A; 384 result = st95hf_send_recv_cmd(stcontext, 385 CMD_ISO14443A_PROTOCOL_SELECT, 386 0, 387 NULL, 388 true); 389 if (result) { 390 dev_err(dev, "protocol sel, err = 0x%x\n", 391 result); 392 return result; 393 } 394 395 /* secondary config. for 14443Type 4A after protocol select */ 396 result = secondary_configuration_type4a(stcontext); 397 if (result) { 398 dev_err(dev, "type a secondary config, err = 0x%x\n", 399 result); 400 return result; 401 } 402 break; 403 case NFC_DIGITAL_RF_TECH_106B: 404 stcontext->current_rf_tech = NFC_DIGITAL_RF_TECH_106B; 405 result = st95hf_send_recv_cmd(stcontext, 406 CMD_ISO14443B_PROTOCOL_SELECT, 407 0, 408 NULL, 409 true); 410 if (result) { 411 dev_err(dev, "protocol sel send, err = 0x%x\n", 412 result); 413 return result; 414 } 415 416 /* 417 * delay of 5-6 ms is required after select protocol 418 * command in case of ISO14443 Type B 419 */ 420 usleep_range(50000, 60000); 421 422 /* secondary config. for 14443Type 4B after protocol select */ 423 result = secondary_configuration_type4b(stcontext); 424 if (result) { 425 dev_err(dev, "type b secondary config, err = 0x%x\n", 426 result); 427 return result; 428 } 429 break; 430 case NFC_DIGITAL_RF_TECH_ISO15693: 431 stcontext->current_rf_tech = NFC_DIGITAL_RF_TECH_ISO15693; 432 result = st95hf_send_recv_cmd(stcontext, 433 CMD_ISO15693_PROTOCOL_SELECT, 434 0, 435 NULL, 436 true); 437 if (result) { 438 dev_err(dev, "protocol sel send, err = 0x%x\n", 439 result); 440 return result; 441 } 442 break; 443 default: 444 return -EINVAL; 445 } 446 447 return 0; 448 } 449 450 static void st95hf_send_st95enable_negativepulse(struct st95hf_context *st95con) 451 { 452 /* First make irq_in pin high */ 453 gpiod_set_value(st95con->enable_gpiod, HIGH); 454 455 /* wait for 1 milisecond */ 456 usleep_range(1000, 2000); 457 458 /* Make irq_in pin low */ 459 gpiod_set_value(st95con->enable_gpiod, LOW); 460 461 /* wait for minimum interrupt pulse to make st95 active */ 462 usleep_range(1000, 2000); 463 464 /* At end make it high */ 465 gpiod_set_value(st95con->enable_gpiod, HIGH); 466 } 467 468 /* 469 * Send a reset sequence over SPI bus (Reset command + wait 3ms + 470 * negative pulse on st95hf enable gpio 471 */ 472 static int st95hf_send_spi_reset_sequence(struct st95hf_context *st95context) 473 { 474 int result = 0; 475 unsigned char reset_cmd = ST95HF_COMMAND_RESET; 476 477 result = st95hf_spi_send(&st95context->spicontext, 478 &reset_cmd, 479 ST95HF_RESET_CMD_LEN, 480 ASYNC); 481 if (result) { 482 dev_err(&st95context->spicontext.spidev->dev, 483 "spi reset sequence cmd error = %d", result); 484 return result; 485 } 486 487 /* wait for 3 milisecond to complete the controller reset process */ 488 usleep_range(3000, 4000); 489 490 /* send negative pulse to make st95hf active */ 491 st95hf_send_st95enable_negativepulse(st95context); 492 493 /* wait for 10 milisecond : HFO setup time */ 494 usleep_range(10000, 20000); 495 496 return result; 497 } 498 499 static int st95hf_por_sequence(struct st95hf_context *st95context) 500 { 501 int nth_attempt = 1; 502 int result; 503 504 st95hf_send_st95enable_negativepulse(st95context); 505 506 usleep_range(5000, 6000); 507 do { 508 /* send an ECHO command and checks ST95HF response */ 509 result = st95hf_echo_command(st95context); 510 511 dev_dbg(&st95context->spicontext.spidev->dev, 512 "response from echo function = 0x%x, attempt = %d\n", 513 result, nth_attempt); 514 515 if (!result) 516 return 0; 517 518 /* send an pulse on IRQ in case of the chip is on sleep state */ 519 if (nth_attempt == 2) 520 st95hf_send_st95enable_negativepulse(st95context); 521 else 522 st95hf_send_spi_reset_sequence(st95context); 523 524 /* delay of 50 milisecond */ 525 usleep_range(50000, 51000); 526 } while (nth_attempt++ < 3); 527 528 return -ETIMEDOUT; 529 } 530 531 static int iso14443_config_fdt(struct st95hf_context *st95context, int wtxm) 532 { 533 int result = 0; 534 struct device *dev = &st95context->spicontext.spidev->dev; 535 struct nfc_digital_dev *nfcddev = st95context->ddev; 536 unsigned char pp_typeb; 537 struct param_list new_params[2]; 538 539 pp_typeb = cmd_array[CMD_ISO14443B_PROTOCOL_SELECT].cmd_params[2]; 540 541 if (nfcddev->curr_protocol == NFC_PROTO_ISO14443 && 542 st95context->fwi < 4) 543 st95context->fwi = 4; 544 545 new_params[0].param_offset = 2; 546 if (nfcddev->curr_protocol == NFC_PROTO_ISO14443) 547 new_params[0].new_param_val = st95context->fwi; 548 else if (nfcddev->curr_protocol == NFC_PROTO_ISO14443_B) 549 new_params[0].new_param_val = pp_typeb; 550 551 new_params[1].param_offset = 3; 552 new_params[1].new_param_val = wtxm; 553 554 switch (nfcddev->curr_protocol) { 555 case NFC_PROTO_ISO14443: 556 result = st95hf_send_recv_cmd(st95context, 557 CMD_ISO14443A_PROTOCOL_SELECT, 558 2, 559 new_params, 560 true); 561 if (result) { 562 dev_err(dev, "WTX type a sel proto, err = 0x%x\n", 563 result); 564 return result; 565 } 566 567 /* secondary config. for 14443Type 4A after protocol select */ 568 result = secondary_configuration_type4a(st95context); 569 if (result) { 570 dev_err(dev, "WTX type a second. config, err = 0x%x\n", 571 result); 572 return result; 573 } 574 break; 575 case NFC_PROTO_ISO14443_B: 576 result = st95hf_send_recv_cmd(st95context, 577 CMD_ISO14443B_PROTOCOL_SELECT, 578 2, 579 new_params, 580 true); 581 if (result) { 582 dev_err(dev, "WTX type b sel proto, err = 0x%x\n", 583 result); 584 return result; 585 } 586 587 /* secondary config. for 14443Type 4B after protocol select */ 588 result = secondary_configuration_type4b(st95context); 589 if (result) { 590 dev_err(dev, "WTX type b second. config, err = 0x%x\n", 591 result); 592 return result; 593 } 594 break; 595 default: 596 return -EINVAL; 597 } 598 599 return 0; 600 } 601 602 static int st95hf_handle_wtx(struct st95hf_context *stcontext, 603 bool new_wtx, 604 int wtx_val) 605 { 606 int result = 0; 607 unsigned char val_mm = 0; 608 struct param_list new_params[1]; 609 struct nfc_digital_dev *nfcddev = stcontext->ddev; 610 struct device *dev = &stcontext->nfcdev->dev; 611 612 if (new_wtx) { 613 result = iso14443_config_fdt(stcontext, wtx_val & 0x3f); 614 if (result) { 615 dev_err(dev, "Config. setting error on WTX req, err = 0x%x\n", 616 result); 617 return result; 618 } 619 620 /* Send response of wtx with ASYNC as no response expected */ 621 new_params[0].param_offset = 1; 622 new_params[0].new_param_val = wtx_val; 623 624 result = st95hf_send_recv_cmd(stcontext, 625 CMD_WTX_RESPONSE, 626 1, 627 new_params, 628 false); 629 if (result) 630 dev_err(dev, "WTX response send, err = 0x%x\n", result); 631 return result; 632 } 633 634 /* if no new wtx, cofigure with default values */ 635 if (nfcddev->curr_protocol == NFC_PROTO_ISO14443) 636 val_mm = cmd_array[CMD_ISO14443A_PROTOCOL_SELECT].cmd_params[3]; 637 else if (nfcddev->curr_protocol == NFC_PROTO_ISO14443_B) 638 val_mm = cmd_array[CMD_ISO14443B_PROTOCOL_SELECT].cmd_params[3]; 639 640 result = iso14443_config_fdt(stcontext, val_mm); 641 if (result) 642 dev_err(dev, "Default config. setting error after WTX processing, err = 0x%x\n", 643 result); 644 645 return result; 646 } 647 648 static int st95hf_error_handling(struct st95hf_context *stcontext, 649 struct sk_buff *skb_resp, 650 int res_len) 651 { 652 int result = 0; 653 unsigned char error_byte; 654 struct device *dev = &stcontext->nfcdev->dev; 655 656 /* First check ST95HF specific error */ 657 if (skb_resp->data[0] & ST95HF_ERR_MASK) { 658 if (skb_resp->data[0] == ST95HF_TIMEOUT_ERROR) 659 result = -ETIMEDOUT; 660 else 661 result = -EIO; 662 return result; 663 } 664 665 /* Check for CRC err only if CRC is present in the tag response */ 666 switch (stcontext->current_rf_tech) { 667 case NFC_DIGITAL_RF_TECH_106A: 668 if (stcontext->sendrcv_trflag == TRFLAG_NFCA_STD_FRAME_CRC) { 669 error_byte = skb_resp->data[res_len - 3]; 670 if (error_byte & ST95HF_NFCA_CRC_ERR_MASK) { 671 /* CRC error occurred */ 672 dev_err(dev, "CRC error, byte received = 0x%x\n", 673 error_byte); 674 result = -EIO; 675 } 676 } 677 break; 678 case NFC_DIGITAL_RF_TECH_106B: 679 case NFC_DIGITAL_RF_TECH_ISO15693: 680 error_byte = skb_resp->data[res_len - 1]; 681 if (error_byte & ST95HF_NFCB_CRC_ERR_MASK) { 682 /* CRC error occurred */ 683 dev_err(dev, "CRC error, byte received = 0x%x\n", 684 error_byte); 685 result = -EIO; 686 } 687 break; 688 } 689 690 return result; 691 } 692 693 static int st95hf_response_handler(struct st95hf_context *stcontext, 694 struct sk_buff *skb_resp, 695 int res_len) 696 { 697 int result = 0; 698 int skb_len; 699 unsigned char val_mm; 700 struct nfc_digital_dev *nfcddev = stcontext->ddev; 701 struct device *dev = &stcontext->nfcdev->dev; 702 struct st95_digital_cmd_complete_arg *cb_arg; 703 704 cb_arg = &stcontext->complete_cb_arg; 705 706 /* Process the response */ 707 skb_put(skb_resp, res_len); 708 709 /* Remove st95 header */ 710 skb_pull(skb_resp, 2); 711 712 skb_len = skb_resp->len; 713 714 /* check if it is case of RATS request reply & FWI is present */ 715 if (nfcddev->curr_protocol == NFC_PROTO_ISO14443 && cb_arg->rats && 716 (skb_resp->data[1] & RATS_TB1_PRESENT_MASK)) { 717 if (skb_resp->data[1] & RATS_TA1_PRESENT_MASK) 718 stcontext->fwi = 719 (skb_resp->data[3] & TB1_FWI_MASK) >> 4; 720 else 721 stcontext->fwi = 722 (skb_resp->data[2] & TB1_FWI_MASK) >> 4; 723 724 val_mm = cmd_array[CMD_ISO14443A_PROTOCOL_SELECT].cmd_params[3]; 725 726 result = iso14443_config_fdt(stcontext, val_mm); 727 if (result) { 728 dev_err(dev, "error in config_fdt to handle fwi of ATS, error=%d\n", 729 result); 730 return result; 731 } 732 } 733 cb_arg->rats = false; 734 735 /* Remove CRC bytes only if received frames data has an eod (CRC) */ 736 switch (stcontext->current_rf_tech) { 737 case NFC_DIGITAL_RF_TECH_106A: 738 if (stcontext->sendrcv_trflag == TRFLAG_NFCA_STD_FRAME_CRC) 739 skb_trim(skb_resp, (skb_len - 5)); 740 else 741 skb_trim(skb_resp, (skb_len - 3)); 742 break; 743 case NFC_DIGITAL_RF_TECH_106B: 744 case NFC_DIGITAL_RF_TECH_ISO15693: 745 skb_trim(skb_resp, (skb_len - 3)); 746 break; 747 } 748 749 return result; 750 } 751 752 static irqreturn_t st95hf_irq_handler(int irq, void *st95hfcontext) 753 { 754 struct st95hf_context *stcontext = 755 (struct st95hf_context *)st95hfcontext; 756 757 if (stcontext->spicontext.req_issync) { 758 complete(&stcontext->spicontext.done); 759 stcontext->spicontext.req_issync = false; 760 return IRQ_HANDLED; 761 } 762 763 return IRQ_WAKE_THREAD; 764 } 765 766 static irqreturn_t st95hf_irq_thread_handler(int irq, void *st95hfcontext) 767 { 768 int result = 0; 769 int res_len; 770 static bool wtx; 771 struct device *spidevice; 772 struct sk_buff *skb_resp; 773 struct st95hf_context *stcontext = 774 (struct st95hf_context *)st95hfcontext; 775 struct st95_digital_cmd_complete_arg *cb_arg; 776 777 spidevice = &stcontext->spicontext.spidev->dev; 778 779 /* 780 * check semaphore, if not down() already, then we don't 781 * know in which context the ISR is called and surely it 782 * will be a bug. Note that down() of the semaphore is done 783 * in the corresponding st95hf_in_send_cmd() and then 784 * only this ISR should be called. ISR will up() the 785 * semaphore before leaving. Hence when the ISR is called 786 * the correct behaviour is down_trylock() should always 787 * return 1 (indicating semaphore cant be taken and hence no 788 * change in semaphore count). 789 * If not, then we up() the semaphore and crash on 790 * a BUG() ! 791 */ 792 if (!down_trylock(&stcontext->exchange_lock)) { 793 up(&stcontext->exchange_lock); 794 WARN(1, "unknown context in ST95HF ISR"); 795 return IRQ_NONE; 796 } 797 798 cb_arg = &stcontext->complete_cb_arg; 799 skb_resp = cb_arg->skb_resp; 800 801 mutex_lock(&stcontext->rm_lock); 802 res_len = st95hf_spi_recv_response(&stcontext->spicontext, 803 skb_resp->data); 804 if (res_len < 0) { 805 dev_err(spidevice, "TISR spi response err = 0x%x\n", res_len); 806 result = res_len; 807 goto end; 808 } 809 810 /* if stcontext->nfcdev_free is true, it means remove already ran */ 811 if (stcontext->nfcdev_free) { 812 result = -ENODEV; 813 goto end; 814 } 815 816 if (skb_resp->data[2] == WTX_REQ_FROM_TAG) { 817 /* Request for new FWT from tag */ 818 result = st95hf_handle_wtx(stcontext, true, skb_resp->data[3]); 819 if (result) 820 goto end; 821 822 wtx = true; 823 mutex_unlock(&stcontext->rm_lock); 824 return IRQ_HANDLED; 825 } 826 827 result = st95hf_error_handling(stcontext, skb_resp, res_len); 828 if (result) 829 goto end; 830 831 result = st95hf_response_handler(stcontext, skb_resp, res_len); 832 if (result) 833 goto end; 834 835 /* 836 * If select protocol is done on wtx req. do select protocol 837 * again with default values 838 */ 839 if (wtx) { 840 wtx = false; 841 result = st95hf_handle_wtx(stcontext, false, 0); 842 if (result) 843 goto end; 844 } 845 846 /* call digital layer callback */ 847 cb_arg->complete_cb(stcontext->ddev, cb_arg->cb_usrarg, skb_resp); 848 849 /* up the semaphore before returning */ 850 up(&stcontext->exchange_lock); 851 mutex_unlock(&stcontext->rm_lock); 852 853 return IRQ_HANDLED; 854 855 end: 856 kfree_skb(skb_resp); 857 wtx = false; 858 cb_arg->rats = false; 859 skb_resp = ERR_PTR(result); 860 /* call of callback with error */ 861 cb_arg->complete_cb(stcontext->ddev, cb_arg->cb_usrarg, skb_resp); 862 /* up the semaphore before returning */ 863 up(&stcontext->exchange_lock); 864 mutex_unlock(&stcontext->rm_lock); 865 return IRQ_HANDLED; 866 } 867 868 /* NFC ops functions definition */ 869 static int st95hf_in_configure_hw(struct nfc_digital_dev *ddev, 870 int type, 871 int param) 872 { 873 struct st95hf_context *stcontext = nfc_digital_get_drvdata(ddev); 874 875 if (type == NFC_DIGITAL_CONFIG_RF_TECH) 876 return st95hf_select_protocol(stcontext, param); 877 878 if (type == NFC_DIGITAL_CONFIG_FRAMING) { 879 switch (param) { 880 case NFC_DIGITAL_FRAMING_NFCA_SHORT: 881 stcontext->sendrcv_trflag = TRFLAG_NFCA_SHORT_FRAME; 882 break; 883 case NFC_DIGITAL_FRAMING_NFCA_STANDARD: 884 stcontext->sendrcv_trflag = TRFLAG_NFCA_STD_FRAME; 885 break; 886 case NFC_DIGITAL_FRAMING_NFCA_T4T: 887 case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP: 888 case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A: 889 stcontext->sendrcv_trflag = TRFLAG_NFCA_STD_FRAME_CRC; 890 break; 891 case NFC_DIGITAL_FRAMING_NFCB: 892 case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY: 893 case NFC_DIGITAL_FRAMING_ISO15693_T5T: 894 break; 895 } 896 } 897 898 return 0; 899 } 900 901 static int rf_off(struct st95hf_context *stcontext) 902 { 903 int rc; 904 struct device *dev; 905 906 dev = &stcontext->nfcdev->dev; 907 908 rc = st95hf_send_recv_cmd(stcontext, CMD_FIELD_OFF, 0, NULL, true); 909 if (rc) 910 dev_err(dev, "protocol sel send field off, err = 0x%x\n", rc); 911 912 return rc; 913 } 914 915 static int st95hf_in_send_cmd(struct nfc_digital_dev *ddev, 916 struct sk_buff *skb, 917 u16 timeout, 918 nfc_digital_cmd_complete_t cb, 919 void *arg) 920 { 921 struct st95hf_context *stcontext = nfc_digital_get_drvdata(ddev); 922 int rc; 923 struct sk_buff *skb_resp; 924 int len_data_to_tag = 0; 925 926 skb_resp = nfc_alloc_recv_skb(MAX_RESPONSE_BUFFER_SIZE, GFP_KERNEL); 927 if (!skb_resp) 928 return -ENOMEM; 929 930 switch (stcontext->current_rf_tech) { 931 case NFC_DIGITAL_RF_TECH_106A: 932 len_data_to_tag = skb->len + 1; 933 skb_put_u8(skb, stcontext->sendrcv_trflag); 934 break; 935 case NFC_DIGITAL_RF_TECH_106B: 936 case NFC_DIGITAL_RF_TECH_ISO15693: 937 len_data_to_tag = skb->len; 938 break; 939 default: 940 rc = -EINVAL; 941 goto free_skb_resp; 942 } 943 944 skb_push(skb, 3); 945 skb->data[0] = ST95HF_COMMAND_SEND; 946 skb->data[1] = SEND_RECEIVE_CMD; 947 skb->data[2] = len_data_to_tag; 948 949 stcontext->complete_cb_arg.skb_resp = skb_resp; 950 stcontext->complete_cb_arg.cb_usrarg = arg; 951 stcontext->complete_cb_arg.complete_cb = cb; 952 953 if ((skb->data[3] == ISO14443A_RATS_REQ) && 954 ddev->curr_protocol == NFC_PROTO_ISO14443) 955 stcontext->complete_cb_arg.rats = true; 956 957 /* 958 * down the semaphore to indicate to remove func that an 959 * ISR is pending, note that it will not block here in any case. 960 * If found blocked, it is a BUG! 961 */ 962 rc = down_killable(&stcontext->exchange_lock); 963 if (rc) { 964 WARN(1, "Semaphore is not found up in st95hf_in_send_cmd\n"); 965 goto free_skb_resp; 966 } 967 968 rc = st95hf_spi_send(&stcontext->spicontext, skb->data, 969 skb->len, 970 ASYNC); 971 if (rc) { 972 dev_err(&stcontext->nfcdev->dev, 973 "Error %d trying to perform data_exchange", rc); 974 /* up the semaphore since ISR will never come in this case */ 975 up(&stcontext->exchange_lock); 976 goto free_skb_resp; 977 } 978 979 kfree_skb(skb); 980 981 return rc; 982 983 free_skb_resp: 984 kfree_skb(skb_resp); 985 return rc; 986 } 987 988 /* p2p will be supported in a later release ! */ 989 static int st95hf_tg_configure_hw(struct nfc_digital_dev *ddev, 990 int type, 991 int param) 992 { 993 return 0; 994 } 995 996 static int st95hf_tg_send_cmd(struct nfc_digital_dev *ddev, 997 struct sk_buff *skb, 998 u16 timeout, 999 nfc_digital_cmd_complete_t cb, 1000 void *arg) 1001 { 1002 return 0; 1003 } 1004 1005 static int st95hf_tg_listen(struct nfc_digital_dev *ddev, 1006 u16 timeout, 1007 nfc_digital_cmd_complete_t cb, 1008 void *arg) 1009 { 1010 return 0; 1011 } 1012 1013 static int st95hf_tg_get_rf_tech(struct nfc_digital_dev *ddev, u8 *rf_tech) 1014 { 1015 return 0; 1016 } 1017 1018 static int st95hf_switch_rf(struct nfc_digital_dev *ddev, bool on) 1019 { 1020 u8 rf_tech; 1021 struct st95hf_context *stcontext = nfc_digital_get_drvdata(ddev); 1022 1023 rf_tech = ddev->curr_rf_tech; 1024 1025 if (on) 1026 /* switch on RF field */ 1027 return st95hf_select_protocol(stcontext, rf_tech); 1028 1029 /* switch OFF RF field */ 1030 return rf_off(stcontext); 1031 } 1032 1033 /* TODO st95hf_abort_cmd */ 1034 static void st95hf_abort_cmd(struct nfc_digital_dev *ddev) 1035 { 1036 } 1037 1038 static const struct nfc_digital_ops st95hf_nfc_digital_ops = { 1039 .in_configure_hw = st95hf_in_configure_hw, 1040 .in_send_cmd = st95hf_in_send_cmd, 1041 1042 .tg_listen = st95hf_tg_listen, 1043 .tg_configure_hw = st95hf_tg_configure_hw, 1044 .tg_send_cmd = st95hf_tg_send_cmd, 1045 .tg_get_rf_tech = st95hf_tg_get_rf_tech, 1046 1047 .switch_rf = st95hf_switch_rf, 1048 .abort_cmd = st95hf_abort_cmd, 1049 }; 1050 1051 static const struct spi_device_id st95hf_id[] = { 1052 { "st95hf", 0 }, 1053 {} 1054 }; 1055 MODULE_DEVICE_TABLE(spi, st95hf_id); 1056 1057 static const struct of_device_id st95hf_spi_of_match[] __maybe_unused = { 1058 { .compatible = "st,st95hf" }, 1059 {}, 1060 }; 1061 MODULE_DEVICE_TABLE(of, st95hf_spi_of_match); 1062 1063 static int st95hf_probe(struct spi_device *nfc_spi_dev) 1064 { 1065 struct device *dev = &nfc_spi_dev->dev; 1066 int ret; 1067 1068 struct st95hf_context *st95context; 1069 struct st95hf_spi_context *spicontext; 1070 1071 nfc_info(&nfc_spi_dev->dev, "ST95HF driver probe called.\n"); 1072 1073 st95context = devm_kzalloc(&nfc_spi_dev->dev, 1074 sizeof(struct st95hf_context), 1075 GFP_KERNEL); 1076 if (!st95context) 1077 return -ENOMEM; 1078 1079 spicontext = &st95context->spicontext; 1080 1081 spicontext->spidev = nfc_spi_dev; 1082 1083 st95context->fwi = 1084 cmd_array[CMD_ISO14443A_PROTOCOL_SELECT].cmd_params[2]; 1085 1086 if (device_property_present(&nfc_spi_dev->dev, "st95hfvin")) { 1087 st95context->st95hf_supply = 1088 devm_regulator_get(&nfc_spi_dev->dev, 1089 "st95hfvin"); 1090 if (IS_ERR(st95context->st95hf_supply)) { 1091 dev_err(&nfc_spi_dev->dev, "failed to acquire regulator\n"); 1092 return PTR_ERR(st95context->st95hf_supply); 1093 } 1094 1095 ret = regulator_enable(st95context->st95hf_supply); 1096 if (ret) { 1097 dev_err(&nfc_spi_dev->dev, "failed to enable regulator\n"); 1098 return ret; 1099 } 1100 } 1101 1102 init_completion(&spicontext->done); 1103 mutex_init(&spicontext->spi_lock); 1104 1105 /* 1106 * Store spicontext in spi device object for using it in 1107 * remove function 1108 */ 1109 dev_set_drvdata(&nfc_spi_dev->dev, spicontext); 1110 1111 st95context->enable_gpiod = devm_gpiod_get(dev, "enable", GPIOD_OUT_HIGH); 1112 if (IS_ERR(st95context->enable_gpiod)) { 1113 ret = PTR_ERR(st95context->enable_gpiod); 1114 dev_err(&nfc_spi_dev->dev, "No valid enable gpio\n"); 1115 goto err_disable_regulator; 1116 } 1117 1118 ret = gpiod_set_consumer_name(st95context->enable_gpiod, "enable_gpio"); 1119 if (ret) 1120 goto err_disable_regulator; 1121 1122 if (nfc_spi_dev->irq > 0) { 1123 if (devm_request_threaded_irq(&nfc_spi_dev->dev, 1124 nfc_spi_dev->irq, 1125 st95hf_irq_handler, 1126 st95hf_irq_thread_handler, 1127 IRQF_TRIGGER_FALLING, 1128 "st95hf", 1129 (void *)st95context) < 0) { 1130 dev_err(&nfc_spi_dev->dev, "err: irq request for st95hf is failed\n"); 1131 ret = -EINVAL; 1132 goto err_disable_regulator; 1133 } 1134 } else { 1135 dev_err(&nfc_spi_dev->dev, "not a valid IRQ associated with ST95HF\n"); 1136 ret = -EINVAL; 1137 goto err_disable_regulator; 1138 } 1139 1140 /* 1141 * First reset SPI to handle warm reset of the system. 1142 * It will put the ST95HF device in Power ON state 1143 * which make the state of device identical to state 1144 * at the time of cold reset of the system. 1145 */ 1146 ret = st95hf_send_spi_reset_sequence(st95context); 1147 if (ret) { 1148 dev_err(&nfc_spi_dev->dev, "err: spi_reset_sequence failed\n"); 1149 goto err_disable_regulator; 1150 } 1151 1152 /* call PowerOnReset sequence of ST95hf to activate it */ 1153 ret = st95hf_por_sequence(st95context); 1154 if (ret) { 1155 dev_err(&nfc_spi_dev->dev, "err: por seq failed for st95hf\n"); 1156 goto err_disable_regulator; 1157 } 1158 1159 /* create NFC dev object and register with NFC Subsystem */ 1160 st95context->ddev = nfc_digital_allocate_device(&st95hf_nfc_digital_ops, 1161 ST95HF_SUPPORTED_PROT, 1162 ST95HF_CAPABILITIES, 1163 ST95HF_HEADROOM_LEN, 1164 ST95HF_TAILROOM_LEN); 1165 if (!st95context->ddev) { 1166 ret = -ENOMEM; 1167 goto err_disable_regulator; 1168 } 1169 1170 st95context->nfcdev = st95context->ddev->nfc_dev; 1171 nfc_digital_set_parent_dev(st95context->ddev, &nfc_spi_dev->dev); 1172 1173 ret = nfc_digital_register_device(st95context->ddev); 1174 if (ret) { 1175 dev_err(&st95context->nfcdev->dev, "st95hf registration failed\n"); 1176 goto err_free_digital_device; 1177 } 1178 1179 /* store st95context in nfc device object */ 1180 nfc_digital_set_drvdata(st95context->ddev, st95context); 1181 1182 sema_init(&st95context->exchange_lock, 1); 1183 mutex_init(&st95context->rm_lock); 1184 1185 return ret; 1186 1187 err_free_digital_device: 1188 nfc_digital_free_device(st95context->ddev); 1189 err_disable_regulator: 1190 if (st95context->st95hf_supply) 1191 regulator_disable(st95context->st95hf_supply); 1192 1193 return ret; 1194 } 1195 1196 static void st95hf_remove(struct spi_device *nfc_spi_dev) 1197 { 1198 int result = 0; 1199 unsigned char reset_cmd = ST95HF_COMMAND_RESET; 1200 struct st95hf_spi_context *spictx = dev_get_drvdata(&nfc_spi_dev->dev); 1201 1202 struct st95hf_context *stcontext = container_of(spictx, 1203 struct st95hf_context, 1204 spicontext); 1205 1206 mutex_lock(&stcontext->rm_lock); 1207 1208 nfc_digital_unregister_device(stcontext->ddev); 1209 nfc_digital_free_device(stcontext->ddev); 1210 stcontext->nfcdev_free = true; 1211 1212 mutex_unlock(&stcontext->rm_lock); 1213 1214 /* if last in_send_cmd's ISR is pending, wait for it to finish */ 1215 result = down_killable(&stcontext->exchange_lock); 1216 if (result == -EINTR) 1217 dev_err(&spictx->spidev->dev, "sleep for semaphore interrupted by signal\n"); 1218 1219 /* next reset the ST95HF controller */ 1220 result = st95hf_spi_send(&stcontext->spicontext, 1221 &reset_cmd, 1222 ST95HF_RESET_CMD_LEN, 1223 ASYNC); 1224 if (result) 1225 dev_err(&spictx->spidev->dev, 1226 "ST95HF reset failed in remove() err = %d\n", result); 1227 1228 /* wait for 3 ms to complete the controller reset process */ 1229 usleep_range(3000, 4000); 1230 1231 /* disable regulator */ 1232 if (stcontext->st95hf_supply) 1233 regulator_disable(stcontext->st95hf_supply); 1234 } 1235 1236 /* Register as SPI protocol driver */ 1237 static struct spi_driver st95hf_driver = { 1238 .driver = { 1239 .name = "st95hf", 1240 .of_match_table = of_match_ptr(st95hf_spi_of_match), 1241 }, 1242 .id_table = st95hf_id, 1243 .probe = st95hf_probe, 1244 .remove = st95hf_remove, 1245 }; 1246 1247 module_spi_driver(st95hf_driver); 1248 1249 MODULE_AUTHOR("Shikha Singh <shikha.singh@st.com>"); 1250 MODULE_DESCRIPTION("ST NFC Transceiver ST95HF driver"); 1251 MODULE_LICENSE("GPL v2"); 1252