Lines Matching refs:trf
456 static int trf7970a_cmd(struct trf7970a *trf, u8 opcode)
461 dev_dbg(trf->dev, "cmd: 0x%x\n", cmd);
463 ret = spi_write(trf->spi, &cmd, 1);
465 dev_err(trf->dev, "%s - cmd: 0x%x, ret: %d\n", __func__, cmd,
470 static int trf7970a_read(struct trf7970a *trf, u8 reg, u8 *val)
475 ret = spi_write_then_read(trf->spi, &addr, 1, val, 1);
477 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
480 dev_dbg(trf->dev, "read(0x%x): 0x%x\n", addr, *val);
485 static int trf7970a_read_cont(struct trf7970a *trf, u8 reg, u8 *buf,
493 dev_dbg(trf->dev, "read_cont(0x%x, %zd)\n", addr, len);
507 ret = spi_sync(trf->spi, &m);
509 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
514 static int trf7970a_write(struct trf7970a *trf, u8 reg, u8 val)
519 dev_dbg(trf->dev, "write(0x%x): 0x%x\n", reg, val);
521 ret = spi_write(trf->spi, buf, 2);
523 dev_err(trf->dev, "%s - write: 0x%x 0x%x, ret: %d\n", __func__,
529 static int trf7970a_read_irqstatus(struct trf7970a *trf, u8 *status)
537 if (trf->quirks & TRF7970A_QUIRK_IRQ_STATUS_READ) {
539 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2);
541 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 1);
545 dev_err(trf->dev, "%s - irqstatus: Status read failed: %d\n",
553 static int trf7970a_read_target_proto(struct trf7970a *trf, u8 *target_proto)
562 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2);
564 dev_err(trf->dev, "%s - target_proto: Read failed: %d\n",
572 static int trf7970a_mode_detect(struct trf7970a *trf, u8 *rf_tech)
577 ret = trf7970a_read_target_proto(trf, &target_proto);
595 dev_dbg(trf->dev, "%s - mode_detect: target_proto: 0x%x\n",
605 static void trf7970a_send_upstream(struct trf7970a *trf)
607 dev_kfree_skb_any(trf->tx_skb);
608 trf->tx_skb = NULL;
610 if (trf->rx_skb && !IS_ERR(trf->rx_skb) && !trf->aborting)
612 16, 1, trf->rx_skb->data, trf->rx_skb->len,
615 trf->state = TRF7970A_ST_IDLE;
617 if (trf->aborting) {
618 dev_dbg(trf->dev, "Abort process complete\n");
620 if (!IS_ERR(trf->rx_skb)) {
621 kfree_skb(trf->rx_skb);
622 trf->rx_skb = ERR_PTR(-ECANCELED);
625 trf->aborting = false;
628 trf->cb(trf->ddev, trf->cb_arg, trf->rx_skb);
630 trf->rx_skb = NULL;
633 static void trf7970a_send_err_upstream(struct trf7970a *trf, int errno)
635 dev_dbg(trf->dev, "Error - state: %d, errno: %d\n", trf->state, errno);
637 cancel_delayed_work(&trf->timeout_work);
639 kfree_skb(trf->rx_skb);
640 trf->rx_skb = ERR_PTR(errno);
642 trf7970a_send_upstream(trf);
645 static int trf7970a_transmit(struct trf7970a *trf, struct sk_buff *skb,
669 ret = spi_sync(trf->spi, &m);
671 dev_err(trf->dev, "%s - Can't send tx data: %d\n", __func__,
679 trf->state = TRF7970A_ST_WAIT_FOR_TX_FIFO;
682 if (trf->issue_eof) {
683 trf->state = TRF7970A_ST_WAIT_TO_ISSUE_EOF;
686 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
688 if (!trf->timeout)
691 timeout = trf->timeout;
695 dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n", timeout,
696 trf->state);
698 schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout));
703 static void trf7970a_fill_fifo(struct trf7970a *trf)
705 struct sk_buff *skb = trf->tx_skb;
711 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
713 trf7970a_send_err_upstream(trf, ret);
717 dev_dbg(trf->dev, "Filling FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
724 schedule_delayed_work(&trf->timeout_work,
733 ret = trf7970a_transmit(trf, skb, len, &prefix, sizeof(prefix));
735 trf7970a_send_err_upstream(trf, ret);
738 static void trf7970a_drain_fifo(struct trf7970a *trf, u8 status)
740 struct sk_buff *skb = trf->rx_skb;
745 trf7970a_send_err_upstream(trf, -EIO);
749 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
751 trf7970a_send_err_upstream(trf, ret);
755 dev_dbg(trf->dev, "Draining FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
768 trf7970a_send_err_upstream(trf, -ENOMEM);
772 kfree_skb(trf->rx_skb);
773 trf->rx_skb = skb;
776 ret = trf7970a_read_cont(trf, TRF7970A_FIFO_IO_REGISTER,
779 trf7970a_send_err_upstream(trf, ret);
784 if ((trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T) && (skb->len == 1) &&
785 (trf->special_fcn_reg1 == TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX)) {
789 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA_CONT;
791 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
793 trf7970a_send_err_upstream(trf, ret);
809 trf7970a_send_upstream(trf);
813 dev_dbg(trf->dev, "Setting timeout for %d ms\n",
816 schedule_delayed_work(&trf->timeout_work,
822 struct trf7970a *trf = dev_id;
826 mutex_lock(&trf->lock);
828 if (trf->state == TRF7970A_ST_RF_OFF) {
829 mutex_unlock(&trf->lock);
833 ret = trf7970a_read_irqstatus(trf, &status);
835 mutex_unlock(&trf->lock);
839 dev_dbg(trf->dev, "IRQ - state: %d, status: 0x%x\n", trf->state,
843 mutex_unlock(&trf->lock);
847 switch (trf->state) {
855 if (trf->is_initiator && (status & TRF7970A_IRQ_STATUS_ERROR)) {
856 trf7970a_cmd(trf, TRF7970A_CMD_BLOCK_RX);
857 trf->state = TRF7970A_ST_IDLE_RX_BLOCKED;
860 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
864 trf->ignore_timeout =
865 !cancel_delayed_work(&trf->timeout_work);
866 trf7970a_fill_fifo(trf);
868 trf7970a_send_err_upstream(trf, -EIO);
874 trf->ignore_timeout =
875 !cancel_delayed_work(&trf->timeout_work);
876 trf7970a_drain_fifo(trf, status);
878 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS,
884 trf7970a_send_err_upstream(trf, ret);
886 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
888 (!trf->is_initiator &&
891 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
893 if (!trf->timeout) {
894 trf->ignore_timeout =
895 !cancel_delayed_work(&trf->timeout_work);
896 trf->rx_skb = ERR_PTR(0);
897 trf7970a_send_upstream(trf);
901 if (trf->is_initiator)
904 iso_ctrl = trf->iso_ctrl;
906 switch (trf->framing) {
908 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
910 trf->iso_ctrl = 0xff; /* Force ISO_CTRL write */
913 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
915 trf->iso_ctrl = 0xff; /* Force ISO_CTRL write */
918 ret = trf7970a_write(trf,
924 trf->special_fcn_reg1 =
931 if (iso_ctrl != trf->iso_ctrl) {
932 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL,
937 trf->iso_ctrl = iso_ctrl;
940 trf7970a_send_err_upstream(trf, -EIO);
945 trf7970a_send_err_upstream(trf, -EIO);
949 trf->ignore_timeout =
950 !cancel_delayed_work(&trf->timeout_work);
951 trf7970a_drain_fifo(trf, status);
953 trf7970a_send_err_upstream(trf, -EIO);
958 trf->ignore_timeout =
959 !cancel_delayed_work(&trf->timeout_work);
961 ret = trf7970a_mode_detect(trf, &trf->md_rf_tech);
963 trf7970a_send_err_upstream(trf, ret);
965 trf->state = TRF7970A_ST_LISTENING;
966 trf7970a_drain_fifo(trf, status);
969 trf7970a_send_err_upstream(trf, -EIO);
973 dev_err(trf->dev, "%s - Driver in invalid state: %d\n",
974 __func__, trf->state);
978 mutex_unlock(&trf->lock);
982 static void trf7970a_issue_eof(struct trf7970a *trf)
986 dev_dbg(trf->dev, "Issuing EOF\n");
988 ret = trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
990 trf7970a_send_err_upstream(trf, ret);
992 ret = trf7970a_cmd(trf, TRF7970A_CMD_EOF);
994 trf7970a_send_err_upstream(trf, ret);
996 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
998 dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n",
999 trf->timeout, trf->state);
1001 schedule_delayed_work(&trf->timeout_work,
1002 msecs_to_jiffies(trf->timeout));
1007 struct trf7970a *trf = container_of(work, struct trf7970a,
1010 dev_dbg(trf->dev, "Timeout - state: %d, ignore_timeout: %d\n",
1011 trf->state, trf->ignore_timeout);
1013 mutex_lock(&trf->lock);
1015 if (trf->ignore_timeout)
1016 trf->ignore_timeout = false;
1017 else if (trf->state == TRF7970A_ST_WAIT_FOR_RX_DATA_CONT)
1018 trf7970a_drain_fifo(trf, TRF7970A_IRQ_STATUS_SRX);
1019 else if (trf->state == TRF7970A_ST_WAIT_TO_ISSUE_EOF)
1020 trf7970a_issue_eof(trf);
1022 trf7970a_send_err_upstream(trf, -ETIMEDOUT);
1024 mutex_unlock(&trf->lock);
1027 static int trf7970a_init(struct trf7970a *trf)
1031 dev_dbg(trf->dev, "Initializing device - state: %d\n", trf->state);
1033 ret = trf7970a_cmd(trf, TRF7970A_CMD_SOFT_INIT);
1037 ret = trf7970a_cmd(trf, TRF7970A_CMD_IDLE);
1041 ret = trf7970a_write(trf, TRF7970A_REG_IO_CTRL,
1042 trf->io_ctrl | TRF7970A_REG_IO_CTRL_VRS(0x1));
1046 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 0);
1052 trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON;
1054 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
1055 trf->modulator_sys_clk_ctrl);
1059 ret = trf7970a_write(trf, TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS,
1065 ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1, 0);
1069 trf->special_fcn_reg1 = 0;
1071 trf->iso_ctrl = 0xff;
1075 dev_dbg(trf->dev, "Couldn't init device: %d\n", ret);
1079 static void trf7970a_switch_rf_off(struct trf7970a *trf)
1081 if ((trf->state == TRF7970A_ST_PWR_OFF) ||
1082 (trf->state == TRF7970A_ST_RF_OFF))
1085 dev_dbg(trf->dev, "Switching rf off\n");
1087 trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON;
1089 trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, trf->chip_status_ctrl);
1091 trf->aborting = false;
1092 trf->state = TRF7970A_ST_RF_OFF;
1094 pm_runtime_mark_last_busy(trf->dev);
1095 pm_runtime_put_autosuspend(trf->dev);
1098 static int trf7970a_switch_rf_on(struct trf7970a *trf)
1102 dev_dbg(trf->dev, "Switching rf on\n");
1104 pm_runtime_get_sync(trf->dev);
1106 if (trf->state != TRF7970A_ST_RF_OFF) { /* Power on, RF off */
1107 dev_err(trf->dev, "%s - Incorrect state: %d\n", __func__,
1108 trf->state);
1112 ret = trf7970a_init(trf);
1114 dev_err(trf->dev, "%s - Can't initialize: %d\n", __func__, ret);
1118 trf->state = TRF7970A_ST_IDLE;
1125 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1128 dev_dbg(trf->dev, "Switching RF - state: %d, on: %d\n", trf->state, on);
1130 mutex_lock(&trf->lock);
1133 switch (trf->state) {
1136 ret = trf7970a_switch_rf_on(trf);
1142 dev_err(trf->dev, "%s - Invalid request: %d %d\n",
1143 __func__, trf->state, on);
1144 trf7970a_switch_rf_off(trf);
1148 switch (trf->state) {
1153 dev_err(trf->dev, "%s - Invalid request: %d %d\n",
1154 __func__, trf->state, on);
1161 trf7970a_switch_rf_off(trf);
1165 mutex_unlock(&trf->lock);
1169 static int trf7970a_in_config_rf_tech(struct trf7970a *trf, int tech)
1173 dev_dbg(trf->dev, "rf technology: %d\n", tech);
1177 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443A_106;
1178 trf->modulator_sys_clk_ctrl =
1179 (trf->modulator_sys_clk_ctrl & 0xf8) |
1181 trf->guard_time = TRF7970A_GUARD_TIME_NFCA;
1184 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443B_106;
1185 trf->modulator_sys_clk_ctrl =
1186 (trf->modulator_sys_clk_ctrl & 0xf8) |
1188 trf->guard_time = TRF7970A_GUARD_TIME_NFCB;
1191 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_212;
1192 trf->modulator_sys_clk_ctrl =
1193 (trf->modulator_sys_clk_ctrl & 0xf8) |
1195 trf->guard_time = TRF7970A_GUARD_TIME_NFCF;
1198 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_424;
1199 trf->modulator_sys_clk_ctrl =
1200 (trf->modulator_sys_clk_ctrl & 0xf8) |
1202 trf->guard_time = TRF7970A_GUARD_TIME_NFCF;
1205 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648;
1206 trf->modulator_sys_clk_ctrl =
1207 (trf->modulator_sys_clk_ctrl & 0xf8) |
1209 trf->guard_time = TRF7970A_GUARD_TIME_15693;
1212 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
1216 trf->technology = tech;
1219 * PSL sequence (indicated by 'trf->iso_ctrl == 0xff' from
1223 if (trf->iso_ctrl == 0xff)
1224 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 0);
1229 static int trf7970a_is_rf_field(struct trf7970a *trf, bool *is_rf_field)
1234 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1235 trf->chip_status_ctrl |
1240 ret = trf7970a_cmd(trf, TRF7970A_CMD_TEST_EXT_RF);
1246 ret = trf7970a_read(trf, TRF7970A_RSSI_OSC_STATUS, &rssi);
1250 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1251 trf->chip_status_ctrl);
1263 static int trf7970a_in_config_framing(struct trf7970a *trf, int framing)
1265 u8 iso_ctrl = trf->iso_ctrl_tech;
1269 dev_dbg(trf->dev, "framing: %d\n", framing);
1274 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
1287 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1291 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1295 dev_dbg(trf->dev, "Unsupported Framing: %d\n", framing);
1299 trf->framing = framing;
1301 if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
1302 ret = trf7970a_is_rf_field(trf, &is_rf_field);
1310 if (iso_ctrl != trf->iso_ctrl) {
1311 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1315 trf->iso_ctrl = iso_ctrl;
1317 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
1318 trf->modulator_sys_clk_ctrl);
1323 if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
1324 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1325 trf->chip_status_ctrl |
1330 trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
1332 usleep_range(trf->guard_time, trf->guard_time + 1000);
1341 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1344 dev_dbg(trf->dev, "Configure hw - type: %d, param: %d\n", type, param);
1346 mutex_lock(&trf->lock);
1348 trf->is_initiator = true;
1350 if ((trf->state == TRF7970A_ST_PWR_OFF) ||
1351 (trf->state == TRF7970A_ST_RF_OFF)) {
1352 ret = trf7970a_switch_rf_on(trf);
1359 ret = trf7970a_in_config_rf_tech(trf, param);
1362 ret = trf7970a_in_config_framing(trf, param);
1365 dev_dbg(trf->dev, "Unknown type: %d\n", type);
1370 mutex_unlock(&trf->lock);
1390 static int trf7970a_per_cmd_config(struct trf7970a *trf, struct sk_buff *skb)
1396 trf->issue_eof = false;
1407 if ((trf->technology == NFC_DIGITAL_RF_TECH_106A) &&
1408 (trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T)) {
1414 if (special_fcn_reg1 != trf->special_fcn_reg1) {
1415 ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1,
1420 trf->special_fcn_reg1 = special_fcn_reg1;
1422 } else if (trf->technology == NFC_DIGITAL_RF_TECH_ISO15693) {
1423 iso_ctrl = trf->iso_ctrl & ~TRF7970A_ISO_CTRL_RFID_SPEED_MASK;
1441 if (iso_ctrl != trf->iso_ctrl) {
1442 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1446 trf->iso_ctrl = iso_ctrl;
1449 if ((trf->framing == NFC_DIGITAL_FRAMING_ISO15693_T5T) &&
1452 trf->issue_eof = true;
1462 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1468 dev_dbg(trf->dev, "New request - state: %d, timeout: %d ms, len: %d\n",
1469 trf->state, timeout, skb->len);
1474 mutex_lock(&trf->lock);
1476 if ((trf->state != TRF7970A_ST_IDLE) &&
1477 (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
1478 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
1479 trf->state);
1484 if (trf->aborting) {
1485 dev_dbg(trf->dev, "Abort process complete\n");
1486 trf->aborting = false;
1492 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
1494 if (!trf->rx_skb) {
1495 dev_dbg(trf->dev, "Can't alloc rx_skb\n");
1501 if (trf->state == TRF7970A_ST_IDLE_RX_BLOCKED) {
1502 ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
1506 trf->state = TRF7970A_ST_IDLE;
1509 if (trf->is_initiator) {
1510 ret = trf7970a_per_cmd_config(trf, skb);
1515 trf->ddev = ddev;
1516 trf->tx_skb = skb;
1517 trf->cb = cb;
1518 trf->cb_arg = arg;
1519 trf->timeout = timeout;
1520 trf->ignore_timeout = false;
1532 TRF7970A_CMD_BIT_OPCODE(trf->tx_cmd);
1535 if (trf->framing == NFC_DIGITAL_FRAMING_NFCA_SHORT) {
1547 ret = trf7970a_read_irqstatus(trf, &status);
1551 ret = trf7970a_transmit(trf, skb, len, prefix, sizeof(prefix));
1553 kfree_skb(trf->rx_skb);
1554 trf->rx_skb = NULL;
1558 mutex_unlock(&trf->lock);
1562 static int trf7970a_tg_config_rf_tech(struct trf7970a *trf, int tech)
1566 dev_dbg(trf->dev, "rf technology: %d\n", tech);
1570 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1572 trf->modulator_sys_clk_ctrl =
1573 (trf->modulator_sys_clk_ctrl & 0xf8) |
1577 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1579 trf->modulator_sys_clk_ctrl =
1580 (trf->modulator_sys_clk_ctrl & 0xf8) |
1584 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1586 trf->modulator_sys_clk_ctrl =
1587 (trf->modulator_sys_clk_ctrl & 0xf8) |
1591 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
1595 trf->technology = tech;
1604 if ((trf->framing == NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED) &&
1605 (trf->iso_ctrl_tech != trf->iso_ctrl)) {
1606 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL,
1607 trf->iso_ctrl_tech);
1609 trf->iso_ctrl = trf->iso_ctrl_tech;
1621 static int trf7970a_tg_config_framing(struct trf7970a *trf, int framing)
1623 u8 iso_ctrl = trf->iso_ctrl_tech;
1626 dev_dbg(trf->dev, "framing: %d\n", framing);
1630 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
1637 iso_ctrl = trf->iso_ctrl; /* Don't write to ISO_CTRL yet */
1640 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1644 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1648 dev_dbg(trf->dev, "Unsupported Framing: %d\n", framing);
1652 trf->framing = framing;
1654 if (iso_ctrl != trf->iso_ctrl) {
1655 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1659 trf->iso_ctrl = iso_ctrl;
1661 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
1662 trf->modulator_sys_clk_ctrl);
1667 if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
1668 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1669 trf->chip_status_ctrl |
1674 trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
1683 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1686 dev_dbg(trf->dev, "Configure hw - type: %d, param: %d\n", type, param);
1688 mutex_lock(&trf->lock);
1690 trf->is_initiator = false;
1692 if ((trf->state == TRF7970A_ST_PWR_OFF) ||
1693 (trf->state == TRF7970A_ST_RF_OFF)) {
1694 ret = trf7970a_switch_rf_on(trf);
1701 ret = trf7970a_tg_config_rf_tech(trf, param);
1704 ret = trf7970a_tg_config_framing(trf, param);
1707 dev_dbg(trf->dev, "Unknown type: %d\n", type);
1712 mutex_unlock(&trf->lock);
1720 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1723 mutex_lock(&trf->lock);
1725 if ((trf->state != TRF7970A_ST_IDLE) &&
1726 (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
1727 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
1728 trf->state);
1733 if (trf->aborting) {
1734 dev_dbg(trf->dev, "Abort process complete\n");
1735 trf->aborting = false;
1740 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
1742 if (!trf->rx_skb) {
1743 dev_dbg(trf->dev, "Can't alloc rx_skb\n");
1748 ret = trf7970a_write(trf, TRF7970A_RX_SPECIAL_SETTINGS,
1756 ret = trf7970a_write(trf, TRF7970A_REG_IO_CTRL,
1757 trf->io_ctrl | TRF7970A_REG_IO_CTRL_VRS(0x1));
1761 ret = trf7970a_write(trf, TRF7970A_NFC_LOW_FIELD_LEVEL,
1766 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL,
1771 trf->ddev = ddev;
1772 trf->cb = cb;
1773 trf->cb_arg = arg;
1774 trf->timeout = timeout;
1775 trf->ignore_timeout = false;
1777 ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
1781 trf->state = mode_detect ? TRF7970A_ST_LISTENING_MD :
1784 schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout));
1787 mutex_unlock(&trf->lock);
1794 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1796 dev_dbg(trf->dev, "Listen - state: %d, timeout: %d ms\n",
1797 trf->state, timeout);
1806 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1809 dev_dbg(trf->dev, "Listen MD - state: %d, timeout: %d ms\n",
1810 trf->state, timeout);
1827 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1829 dev_dbg(trf->dev, "Get RF Tech - state: %d, rf_tech: %d\n",
1830 trf->state, trf->md_rf_tech);
1832 *rf_tech = trf->md_rf_tech;
1839 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1841 dev_dbg(trf->dev, "Abort process initiated\n");
1843 mutex_lock(&trf->lock);
1845 switch (trf->state) {
1850 trf->aborting = true;
1853 trf->ignore_timeout = !cancel_delayed_work(&trf->timeout_work);
1854 trf7970a_send_err_upstream(trf, -ECANCELED);
1855 dev_dbg(trf->dev, "Abort process complete\n");
1861 mutex_unlock(&trf->lock);
1876 static int trf7970a_power_up(struct trf7970a *trf)
1880 dev_dbg(trf->dev, "Powering up - state: %d\n", trf->state);
1882 if (trf->state != TRF7970A_ST_PWR_OFF)
1885 ret = regulator_enable(trf->regulator);
1887 dev_err(trf->dev, "%s - Can't enable VIN: %d\n", __func__, ret);
1893 if (trf->en2_gpiod &&
1894 !(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW)) {
1895 gpiod_set_value_cansleep(trf->en2_gpiod, 1);
1899 gpiod_set_value_cansleep(trf->en_gpiod, 1);
1903 trf->state = TRF7970A_ST_RF_OFF;
1908 static int trf7970a_power_down(struct trf7970a *trf)
1912 dev_dbg(trf->dev, "Powering down - state: %d\n", trf->state);
1914 if (trf->state == TRF7970A_ST_PWR_OFF)
1917 if (trf->state != TRF7970A_ST_RF_OFF) {
1918 dev_dbg(trf->dev, "Can't power down - not RF_OFF state (%d)\n",
1919 trf->state);
1923 gpiod_set_value_cansleep(trf->en_gpiod, 0);
1925 if (trf->en2_gpiod && !(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW))
1926 gpiod_set_value_cansleep(trf->en2_gpiod, 0);
1928 ret = regulator_disable(trf->regulator);
1930 dev_err(trf->dev, "%s - Can't disable VIN: %d\n", __func__,
1933 trf->state = TRF7970A_ST_PWR_OFF;
1938 static int trf7970a_startup(struct trf7970a *trf)
1942 ret = trf7970a_power_up(trf);
1946 pm_runtime_set_active(trf->dev);
1947 pm_runtime_enable(trf->dev);
1948 pm_runtime_mark_last_busy(trf->dev);
1953 static void trf7970a_shutdown(struct trf7970a *trf)
1955 switch (trf->state) {
1961 trf7970a_send_err_upstream(trf, -ECANCELED);
1965 trf7970a_switch_rf_off(trf);
1971 pm_runtime_disable(trf->dev);
1972 pm_runtime_set_suspended(trf->dev);
1974 trf7970a_power_down(trf);
1991 struct trf7970a *trf;
2000 trf = devm_kzalloc(&spi->dev, sizeof(*trf), GFP_KERNEL);
2001 if (!trf)
2004 trf->state = TRF7970A_ST_PWR_OFF;
2005 trf->dev = &spi->dev;
2006 trf->spi = spi;
2013 dev_err(trf->dev, "Can't set up SPI Communication\n");
2018 trf->quirks |= TRF7970A_QUIRK_IRQ_STATUS_READ;
2021 trf->en_gpiod = devm_gpiod_get_index(trf->dev, "ti,enable", 0,
2023 if (IS_ERR(trf->en_gpiod)) {
2024 dev_err(trf->dev, "No EN GPIO property\n");
2025 return PTR_ERR(trf->en_gpiod);
2028 trf->en2_gpiod = devm_gpiod_get_index_optional(trf->dev, "ti,enable", 1,
2030 if (!trf->en2_gpiod) {
2031 dev_info(trf->dev, "No EN2 GPIO property\n");
2032 } else if (IS_ERR(trf->en2_gpiod)) {
2033 dev_err(trf->dev, "Error getting EN2 GPIO property: %ld\n",
2034 PTR_ERR(trf->en2_gpiod));
2035 return PTR_ERR(trf->en2_gpiod);
2037 trf->quirks |= TRF7970A_QUIRK_EN2_MUST_STAY_LOW;
2043 dev_err(trf->dev,
2049 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_27MHZ;
2050 dev_dbg(trf->dev, "trf7970a configured for 27MHz crystal\n");
2052 trf->modulator_sys_clk_ctrl = 0;
2055 ret = devm_request_threaded_irq(trf->dev, spi->irq, NULL,
2058 "trf7970a", trf);
2060 dev_err(trf->dev, "Can't request IRQ#%d: %d\n", spi->irq, ret);
2064 mutex_init(&trf->lock);
2065 INIT_DELAYED_WORK(&trf->timeout_work, trf7970a_timeout_work_handler);
2067 trf->regulator = devm_regulator_get(&spi->dev, "vin");
2068 if (IS_ERR(trf->regulator)) {
2069 ret = PTR_ERR(trf->regulator);
2070 dev_err(trf->dev, "Can't get VIN regulator: %d\n", ret);
2074 ret = regulator_enable(trf->regulator);
2076 dev_err(trf->dev, "Can't enable VIN: %d\n", ret);
2080 uvolts = regulator_get_voltage(trf->regulator);
2082 trf->chip_status_ctrl = TRF7970A_CHIP_STATUS_VRS5_3;
2084 trf->regulator = devm_regulator_get(&spi->dev, "vdd-io");
2085 if (IS_ERR(trf->regulator)) {
2086 ret = PTR_ERR(trf->regulator);
2087 dev_err(trf->dev, "Can't get VDD_IO regulator: %d\n", ret);
2091 ret = regulator_enable(trf->regulator);
2093 dev_err(trf->dev, "Can't enable VDD_IO: %d\n", ret);
2097 if (regulator_get_voltage(trf->regulator) == 1800000) {
2098 trf->io_ctrl = TRF7970A_REG_IO_CTRL_IO_LOW;
2099 dev_dbg(trf->dev, "trf7970a config vdd_io to 1.8V\n");
2102 trf->ddev = nfc_digital_allocate_device(&trf7970a_nfc_ops,
2107 if (!trf->ddev) {
2108 dev_err(trf->dev, "Can't allocate NFC digital device\n");
2113 nfc_digital_set_parent_dev(trf->ddev, trf->dev);
2114 nfc_digital_set_drvdata(trf->ddev, trf);
2115 spi_set_drvdata(spi, trf);
2119 pm_runtime_set_autosuspend_delay(trf->dev, autosuspend_delay);
2120 pm_runtime_use_autosuspend(trf->dev);
2122 ret = trf7970a_startup(trf);
2126 ret = nfc_digital_register_device(trf->ddev);
2128 dev_err(trf->dev, "Can't register NFC digital device: %d\n",
2136 trf7970a_shutdown(trf);
2138 nfc_digital_free_device(trf->ddev);
2140 regulator_disable(trf->regulator);
2142 mutex_destroy(&trf->lock);
2148 struct trf7970a *trf = spi_get_drvdata(spi);
2150 mutex_lock(&trf->lock);
2152 trf7970a_shutdown(trf);
2154 mutex_unlock(&trf->lock);
2156 nfc_digital_unregister_device(trf->ddev);
2157 nfc_digital_free_device(trf->ddev);
2159 regulator_disable(trf->regulator);
2161 mutex_destroy(&trf->lock);
2170 struct trf7970a *trf = spi_get_drvdata(spi);
2174 mutex_lock(&trf->lock);
2176 trf7970a_shutdown(trf);
2178 mutex_unlock(&trf->lock);
2186 struct trf7970a *trf = spi_get_drvdata(spi);
2191 mutex_lock(&trf->lock);
2193 ret = trf7970a_startup(trf);
2195 mutex_unlock(&trf->lock);
2205 struct trf7970a *trf = spi_get_drvdata(spi);
2210 mutex_lock(&trf->lock);
2212 ret = trf7970a_power_down(trf);
2214 mutex_unlock(&trf->lock);
2222 struct trf7970a *trf = spi_get_drvdata(spi);
2227 ret = trf7970a_power_up(trf);