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