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,
1397 trf->issue_eof = false;
1408 if ((trf->technology == NFC_DIGITAL_RF_TECH_106A) &&
1409 (trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T)) {
1415 if (special_fcn_reg1 != trf->special_fcn_reg1) {
1416 ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1,
1421 trf->special_fcn_reg1 = special_fcn_reg1;
1423 } else if (trf->technology == NFC_DIGITAL_RF_TECH_ISO15693) {
1424 iso_ctrl = trf->iso_ctrl & ~TRF7970A_ISO_CTRL_RFID_SPEED_MASK;
1442 if (iso_ctrl != trf->iso_ctrl) {
1443 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1447 trf->iso_ctrl = iso_ctrl;
1450 if ((trf->framing == NFC_DIGITAL_FRAMING_ISO15693_T5T) &&
1453 trf->issue_eof = true;
1463 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1469 dev_dbg(trf->dev, "New request - state: %d, timeout: %d ms, len: %d\n",
1470 trf->state, timeout, skb->len);
1475 mutex_lock(&trf->lock);
1477 if ((trf->state != TRF7970A_ST_IDLE) &&
1478 (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
1479 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
1480 trf->state);
1485 if (trf->aborting) {
1486 dev_dbg(trf->dev, "Abort process complete\n");
1487 trf->aborting = false;
1493 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
1495 if (!trf->rx_skb) {
1496 dev_dbg(trf->dev, "Can't alloc rx_skb\n");
1502 if (trf->state == TRF7970A_ST_IDLE_RX_BLOCKED) {
1503 ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
1507 trf->state = TRF7970A_ST_IDLE;
1510 if (trf->is_initiator) {
1511 ret = trf7970a_per_cmd_config(trf, skb);
1516 trf->ddev = ddev;
1517 trf->tx_skb = skb;
1518 trf->cb = cb;
1519 trf->cb_arg = arg;
1520 trf->timeout = timeout;
1521 trf->ignore_timeout = false;
1533 TRF7970A_CMD_BIT_OPCODE(trf->tx_cmd);
1536 if (trf->framing == NFC_DIGITAL_FRAMING_NFCA_SHORT) {
1548 ret = trf7970a_read_irqstatus(trf, &status);
1552 ret = trf7970a_transmit(trf, skb, len, prefix, sizeof(prefix));
1554 kfree_skb(trf->rx_skb);
1555 trf->rx_skb = NULL;
1559 mutex_unlock(&trf->lock);
1563 static int trf7970a_tg_config_rf_tech(struct trf7970a *trf, int tech)
1567 dev_dbg(trf->dev, "rf technology: %d\n", tech);
1571 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1573 trf->modulator_sys_clk_ctrl =
1574 (trf->modulator_sys_clk_ctrl & 0xf8) |
1578 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1580 trf->modulator_sys_clk_ctrl =
1581 (trf->modulator_sys_clk_ctrl & 0xf8) |
1585 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1587 trf->modulator_sys_clk_ctrl =
1588 (trf->modulator_sys_clk_ctrl & 0xf8) |
1592 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
1596 trf->technology = tech;
1605 if ((trf->framing == NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED) &&
1606 (trf->iso_ctrl_tech != trf->iso_ctrl)) {
1607 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL,
1608 trf->iso_ctrl_tech);
1610 trf->iso_ctrl = trf->iso_ctrl_tech;
1622 static int trf7970a_tg_config_framing(struct trf7970a *trf, int framing)
1624 u8 iso_ctrl = trf->iso_ctrl_tech;
1627 dev_dbg(trf->dev, "framing: %d\n", framing);
1631 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
1638 iso_ctrl = trf->iso_ctrl; /* Don't write to ISO_CTRL yet */
1641 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1645 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1649 dev_dbg(trf->dev, "Unsupported Framing: %d\n", framing);
1653 trf->framing = framing;
1655 if (iso_ctrl != trf->iso_ctrl) {
1656 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1660 trf->iso_ctrl = iso_ctrl;
1662 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
1663 trf->modulator_sys_clk_ctrl);
1668 if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
1669 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1670 trf->chip_status_ctrl |
1675 trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
1684 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1687 dev_dbg(trf->dev, "Configure hw - type: %d, param: %d\n", type, param);
1689 mutex_lock(&trf->lock);
1691 trf->is_initiator = false;
1693 if ((trf->state == TRF7970A_ST_PWR_OFF) ||
1694 (trf->state == TRF7970A_ST_RF_OFF)) {
1695 ret = trf7970a_switch_rf_on(trf);
1702 ret = trf7970a_tg_config_rf_tech(trf, param);
1705 ret = trf7970a_tg_config_framing(trf, param);
1708 dev_dbg(trf->dev, "Unknown type: %d\n", type);
1713 mutex_unlock(&trf->lock);
1721 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1724 mutex_lock(&trf->lock);
1726 if ((trf->state != TRF7970A_ST_IDLE) &&
1727 (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
1728 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
1729 trf->state);
1734 if (trf->aborting) {
1735 dev_dbg(trf->dev, "Abort process complete\n");
1736 trf->aborting = false;
1741 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
1743 if (!trf->rx_skb) {
1744 dev_dbg(trf->dev, "Can't alloc rx_skb\n");
1749 ret = trf7970a_write(trf, TRF7970A_RX_SPECIAL_SETTINGS,
1757 ret = trf7970a_write(trf, TRF7970A_REG_IO_CTRL,
1758 trf->io_ctrl | TRF7970A_REG_IO_CTRL_VRS(0x1));
1762 ret = trf7970a_write(trf, TRF7970A_NFC_LOW_FIELD_LEVEL,
1767 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL,
1772 trf->ddev = ddev;
1773 trf->cb = cb;
1774 trf->cb_arg = arg;
1775 trf->timeout = timeout;
1776 trf->ignore_timeout = false;
1778 ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
1782 trf->state = mode_detect ? TRF7970A_ST_LISTENING_MD :
1785 schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout));
1788 mutex_unlock(&trf->lock);
1795 const struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1797 dev_dbg(trf->dev, "Listen - state: %d, timeout: %d ms\n",
1798 trf->state, timeout);
1807 const struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1810 dev_dbg(trf->dev, "Listen MD - state: %d, timeout: %d ms\n",
1811 trf->state, timeout);
1828 const struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1830 dev_dbg(trf->dev, "Get RF Tech - state: %d, rf_tech: %d\n",
1831 trf->state, trf->md_rf_tech);
1833 *rf_tech = trf->md_rf_tech;
1840 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1842 dev_dbg(trf->dev, "Abort process initiated\n");
1844 mutex_lock(&trf->lock);
1846 switch (trf->state) {
1851 trf->aborting = true;
1854 trf->ignore_timeout = !cancel_delayed_work(&trf->timeout_work);
1855 trf7970a_send_err_upstream(trf, -ECANCELED);
1856 dev_dbg(trf->dev, "Abort process complete\n");
1862 mutex_unlock(&trf->lock);
1877 static int trf7970a_power_up(struct trf7970a *trf)
1881 dev_dbg(trf->dev, "Powering up - state: %d\n", trf->state);
1883 if (trf->state != TRF7970A_ST_PWR_OFF)
1886 ret = regulator_enable(trf->regulator);
1888 dev_err(trf->dev, "%s - Can't enable VIN: %d\n", __func__, ret);
1894 if (trf->en2_gpiod &&
1895 !(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW)) {
1896 gpiod_set_value_cansleep(trf->en2_gpiod, 1);
1900 gpiod_set_value_cansleep(trf->en_gpiod, 1);
1904 trf->state = TRF7970A_ST_RF_OFF;
1909 static int trf7970a_power_down(struct trf7970a *trf)
1913 dev_dbg(trf->dev, "Powering down - state: %d\n", trf->state);
1915 if (trf->state == TRF7970A_ST_PWR_OFF)
1918 if (trf->state != TRF7970A_ST_RF_OFF) {
1919 dev_dbg(trf->dev, "Can't power down - not RF_OFF state (%d)\n",
1920 trf->state);
1924 gpiod_set_value_cansleep(trf->en_gpiod, 0);
1926 if (trf->en2_gpiod && !(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW))
1927 gpiod_set_value_cansleep(trf->en2_gpiod, 0);
1929 ret = regulator_disable(trf->regulator);
1931 dev_err(trf->dev, "%s - Can't disable VIN: %d\n", __func__,
1934 trf->state = TRF7970A_ST_PWR_OFF;
1939 static int trf7970a_startup(struct trf7970a *trf)
1943 ret = trf7970a_power_up(trf);
1947 pm_runtime_set_active(trf->dev);
1948 pm_runtime_enable(trf->dev);
1949 pm_runtime_mark_last_busy(trf->dev);
1954 static void trf7970a_shutdown(struct trf7970a *trf)
1956 switch (trf->state) {
1962 trf7970a_send_err_upstream(trf, -ECANCELED);
1966 trf7970a_switch_rf_off(trf);
1972 pm_runtime_disable(trf->dev);
1973 pm_runtime_set_suspended(trf->dev);
1975 trf7970a_power_down(trf);
1992 struct trf7970a *trf;
2001 trf = devm_kzalloc(&spi->dev, sizeof(*trf), GFP_KERNEL);
2002 if (!trf)
2005 trf->state = TRF7970A_ST_PWR_OFF;
2006 trf->dev = &spi->dev;
2007 trf->spi = spi;
2014 dev_err(trf->dev, "Can't set up SPI Communication\n");
2019 trf->quirks |= TRF7970A_QUIRK_IRQ_STATUS_READ;
2022 trf->en_gpiod = devm_gpiod_get_index(trf->dev, "ti,enable", 0,
2024 if (IS_ERR(trf->en_gpiod)) {
2025 dev_err(trf->dev, "No EN GPIO property\n");
2026 return PTR_ERR(trf->en_gpiod);
2029 trf->en2_gpiod = devm_gpiod_get_index_optional(trf->dev, "ti,enable", 1,
2031 if (!trf->en2_gpiod) {
2032 dev_info(trf->dev, "No EN2 GPIO property\n");
2033 } else if (IS_ERR(trf->en2_gpiod)) {
2034 dev_err(trf->dev, "Error getting EN2 GPIO property: %ld\n",
2035 PTR_ERR(trf->en2_gpiod));
2036 return PTR_ERR(trf->en2_gpiod);
2038 trf->quirks |= TRF7970A_QUIRK_EN2_MUST_STAY_LOW;
2044 dev_err(trf->dev,
2050 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_27MHZ;
2051 dev_dbg(trf->dev, "trf7970a configured for 27MHz crystal\n");
2053 trf->modulator_sys_clk_ctrl = 0;
2056 ret = devm_request_threaded_irq(trf->dev, spi->irq, NULL,
2059 "trf7970a", trf);
2061 dev_err(trf->dev, "Can't request IRQ#%d: %d\n", spi->irq, ret);
2065 mutex_init(&trf->lock);
2066 INIT_DELAYED_WORK(&trf->timeout_work, trf7970a_timeout_work_handler);
2068 trf->regulator = devm_regulator_get(&spi->dev, "vin");
2069 if (IS_ERR(trf->regulator)) {
2070 ret = PTR_ERR(trf->regulator);
2071 dev_err(trf->dev, "Can't get VIN regulator: %d\n", ret);
2075 ret = regulator_enable(trf->regulator);
2077 dev_err(trf->dev, "Can't enable VIN: %d\n", ret);
2081 uvolts = regulator_get_voltage(trf->regulator);
2083 trf->chip_status_ctrl = TRF7970A_CHIP_STATUS_VRS5_3;
2085 trf->regulator = devm_regulator_get(&spi->dev, "vdd-io");
2086 if (IS_ERR(trf->regulator)) {
2087 ret = PTR_ERR(trf->regulator);
2088 dev_err(trf->dev, "Can't get VDD_IO regulator: %d\n", ret);
2092 ret = regulator_enable(trf->regulator);
2094 dev_err(trf->dev, "Can't enable VDD_IO: %d\n", ret);
2098 if (regulator_get_voltage(trf->regulator) == 1800000) {
2099 trf->io_ctrl = TRF7970A_REG_IO_CTRL_IO_LOW;
2100 dev_dbg(trf->dev, "trf7970a config vdd_io to 1.8V\n");
2103 trf->ddev = nfc_digital_allocate_device(&trf7970a_nfc_ops,
2108 if (!trf->ddev) {
2109 dev_err(trf->dev, "Can't allocate NFC digital device\n");
2114 nfc_digital_set_parent_dev(trf->ddev, trf->dev);
2115 nfc_digital_set_drvdata(trf->ddev, trf);
2116 spi_set_drvdata(spi, trf);
2120 pm_runtime_set_autosuspend_delay(trf->dev, autosuspend_delay);
2121 pm_runtime_use_autosuspend(trf->dev);
2123 ret = trf7970a_startup(trf);
2127 ret = nfc_digital_register_device(trf->ddev);
2129 dev_err(trf->dev, "Can't register NFC digital device: %d\n",
2137 trf7970a_shutdown(trf);
2139 nfc_digital_free_device(trf->ddev);
2141 regulator_disable(trf->regulator);
2143 mutex_destroy(&trf->lock);
2149 struct trf7970a *trf = spi_get_drvdata(spi);
2151 mutex_lock(&trf->lock);
2153 trf7970a_shutdown(trf);
2155 mutex_unlock(&trf->lock);
2157 nfc_digital_unregister_device(trf->ddev);
2158 nfc_digital_free_device(trf->ddev);
2160 regulator_disable(trf->regulator);
2162 mutex_destroy(&trf->lock);
2169 struct trf7970a *trf = spi_get_drvdata(spi);
2171 mutex_lock(&trf->lock);
2173 trf7970a_shutdown(trf);
2175 mutex_unlock(&trf->lock);
2183 struct trf7970a *trf = spi_get_drvdata(spi);
2186 mutex_lock(&trf->lock);
2188 ret = trf7970a_startup(trf);
2190 mutex_unlock(&trf->lock);
2200 struct trf7970a *trf = spi_get_drvdata(spi);
2203 mutex_lock(&trf->lock);
2205 ret = trf7970a_power_down(trf);
2207 mutex_unlock(&trf->lock);
2215 struct trf7970a *trf = spi_get_drvdata(spi);
2218 ret = trf7970a_power_up(trf);