xref: /aosp_15_r20/system/nfc/tools/casimir/src/controller.rs (revision 7eba2f3b06c51ae21384f6a4f14577b668a869b3)

// Copyright 2023, The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! Implementation of the NFCC.

use crate::packets::{nci, rf};
use anyhow::Result;
use core::time::Duration;
use futures::StreamExt;
use log::{debug, error, info, trace, warn};
use pdl_runtime::Packet;
use std::convert::TryFrom;
use std::future::Future;
use std::pin::pin;
use std::time::Instant;
use tokio::sync::mpsc;
use tokio::time;

const NCI_VERSION: nci::NciVersion = nci::NciVersion::Version20;
const MANUFACTURER_ID: u8 = 0x02;
const MANUFACTURER_SPECIFIC_INFORMATION: [u8; 26] =
    [5, 3, 3, 19, 4, 25, 1, 7, 0, 0, 68, 100, 214, 0, 0, 90, 172, 0, 0, 0, 1, 44, 176, 153, 243, 0];

/// Read-only configuration parameters
const PB_ATTRIB_PARAM1: u8 = 0x00;
const LF_T3T_MAX: u8 = 16;
const LLCP_VERSION: u8 = 0x00;

/// Writable configuration parameters with default
/// value defined by the NFCC.
const TOTAL_DURATION: u16 = 1000;
const PA_DEVICES_LIMIT: u8 = 255;
const PB_DEVICES_LIMIT: u8 = 255;
const PF_DEVICES_LIMIT: u8 = 255;
const PV_DEVICES_LIMIT: u8 = 255;
const LA_BIT_FRAME_SDD: u8 = 0x10;
const LA_PLATFORM_CONFIG: u8 = 0x0c;
const LA_SEL_INFO: u8 = 0x60; // Supports ISO-DEP and NFC-DEP.
const LB_SENSB_INFO: u8 = 0x1; // Supports ISO-DEP.
const LB_SFGI: u8 = 0;
const LB_FWI_ADC_FO: u8 = 0x00;
const LF_PROTOCOL_TYPE: u8 = 0x02; // Supports NFC-DEP.
const LI_A_RATS_TB1: u8 = 0x70;
const LI_A_RATS_TC1: u8 = 0x02;

const MAX_LOGICAL_CONNECTIONS: u8 = 2;
const MAX_ROUTING_TABLE_SIZE: u16 = 512;
const MAX_CONTROL_PACKET_PAYLOAD_SIZE: u8 = 255;
const MAX_DATA_PACKET_PAYLOAD_SIZE: u8 = 255;
const NUMBER_OF_CREDITS: u8 = 1;
const MAX_NFCV_RF_FRAME_SIZE: u16 = 512;

/// Time in milliseconds that Casimir waits for poll responses after
/// sending a poll command.
const POLL_RESPONSE_TIMEOUT: u64 = 200;

/// All configuration parameters of the NFCC.
/// The configuration is filled with default values from the specification
/// See [NCI] Table 46: Common Parameters for Discovery Configuration
/// for the format of each parameter and the default value.
#[derive(Clone, Debug, PartialEq, Eq)]
#[allow(missing_docs)]
pub struct ConfigParameters {
    total_duration: u16,
    /// [NCI] Table 47: Values for CON_DISCOVERY_PARAM.
    con_discovery_param: u8,
    power_state: u8,
    pa_bail_out: u8,
    pa_devices_limit: u8,
    pb_afi: u8,
    pb_bail_out: u8,
    pb_attrib_param1: u8,
    /// [NCI] Table 26: Values for PB_SENSB_REQ_PARAM.
    pb_sensb_req_param: u8,
    pb_devices_limit: u8,
    pf_bit_rate: u8,
    pf_bail_out: u8,
    pf_devices_limit: u8,
    pi_b_h_info: Vec<u8>,
    pi_bit_rate: u8,
    pn_nfc_dep_psl: u8,
    pn_atr_req_gen_bytes: Vec<u8>,
    /// [NCI] Table 30: Values for PN_ATR_REQ_CONFIG.
    pn_atr_req_config: u8,
    pv_devices_limit: u8,
    la_bit_frame_sdd: u8,
    la_platform_config: u8,
    /// [NCI] Table 34: LA_SEL_INFO Coding.
    la_sel_info: u8,
    la_nfcid1: Vec<u8>,
    /// [NCI] Table 36: LB_SENSB_INFO Values.
    lb_sensb_info: u8,
    lb_nfcid0: [u8; 4],
    lb_application_data: u32,
    lb_sfgi: u8,
    /// [NCI] Table 37: LB_FWI_ADC_FO Values.
    lb_fwi_adc_fo: u8,
    lb_bit_rate: u8,
    lf_t3t_identifiers_1: [u8; 18],
    lf_t3t_identifiers_2: [u8; 18],
    lf_t3t_identifiers_3: [u8; 18],
    lf_t3t_identifiers_4: [u8; 18],
    lf_t3t_identifiers_5: [u8; 18],
    lf_t3t_identifiers_6: [u8; 18],
    lf_t3t_identifiers_7: [u8; 18],
    lf_t3t_identifiers_8: [u8; 18],
    lf_t3t_identifiers_9: [u8; 18],
    lf_t3t_identifiers_10: [u8; 18],
    lf_t3t_identifiers_11: [u8; 18],
    lf_t3t_identifiers_12: [u8; 18],
    lf_t3t_identifiers_13: [u8; 18],
    lf_t3t_identifiers_14: [u8; 18],
    lf_t3t_identifiers_15: [u8; 18],
    lf_t3t_identifiers_16: [u8; 18],
    lf_t3t_pmm_default: [u8; 8],
    lf_t3t_max: u8,
    lf_t3t_flags: u16,
    lf_t3t_rd_allowed: u8,
    /// [NCI] Table 39: Supported Protocols for Listen F.
    lf_protocol_type: u8,
    li_a_rats_tb1: u8,
    li_a_hist_by: Vec<u8>,
    li_b_h_info_resp: Vec<u8>,
    li_a_bit_rate: u8,
    li_a_rats_tc1: u8,
    ln_wt: u8,
    ln_atr_res_gen_bytes: Vec<u8>,
    ln_atr_res_config: u8,
    pacm_bit_rate: u8,
    /// [NCI] Table 23: RF Field Information Configuration Parameter.
    rf_field_info: u8,
    rf_nfcee_action: u8,
    nfcdep_op: u8,
    /// [NCI] Table 115: LLCP Version Parameter.
    llcp_version: u8,
    /// [NCI] Table 65: Value Field for NFCC Configuration Control.
    nfcc_config_control: u8,
}

/// State of an NFCC logical connection with the DH.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[allow(missing_docs)]
pub enum LogicalConnection {
    RemoteNfcEndpoint { rf_discovery_id: u8, rf_protocol_type: nci::RfProtocolType },
}

/// State of the RF Discovery of an NFCC instance.
/// The state WaitForAllDiscoveries is not represented as it is implied
/// by the discovery routine.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[allow(missing_docs)]
pub enum RfState {
    Idle,
    Discovery,
    PollActive {
        id: u16,
        rf_interface: nci::RfInterfaceType,
        rf_technology: rf::Technology,
        rf_protocol: rf::Protocol,
    },
    ListenSleep {
        id: u16,
    },
    ListenActive {
        id: u16,
        rf_interface: nci::RfInterfaceType,
        rf_technology: rf::Technology,
        rf_protocol: rf::Protocol,
    },
    WaitForHostSelect,
    WaitForSelectResponse {
        id: u16,
        rf_discovery_id: usize,
        rf_interface: nci::RfInterfaceType,
        rf_technology: rf::Technology,
        rf_protocol: rf::Protocol,
    },
}

/// State of the emulated eSE (ST) NFCEE.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[allow(missing_docs)]
pub enum NfceeState {
    Enabled,
    Disabled,
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[allow(missing_docs)]
pub enum RfMode {
    Poll,
    Listen,
}

/// Poll responses received in the context of RF discovery in active
/// Listen mode.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct RfPollResponse {
    id: u16,
    rf_protocol: rf::Protocol,
    rf_technology: rf::Technology,
    rf_technology_specific_parameters: Vec<u8>,
}

/// State of an NFCC instance.
#[allow(missing_docs)]
pub struct State {
    pub config_parameters: ConfigParameters,
    pub logical_connections: [Option<LogicalConnection>; MAX_LOGICAL_CONNECTIONS as usize],
    pub discover_configuration: Vec<nci::DiscoverConfiguration>,
    pub discover_map: Vec<nci::MappingConfiguration>,
    pub nfcee_state: NfceeState,
    pub rf_state: RfState,
    pub rf_poll_responses: Vec<RfPollResponse>,
    pub rf_activation_parameters: Vec<u8>,
    pub passive_observe_mode: nci::PassiveObserveMode,
    pub start_time: std::time::Instant,
}

/// State of an NFCC instance.
pub struct Controller<'a> {
    id: u16,
    nci_stream: nci::StreamRefMut<'a>,
    nci_writer: nci::Writer,
    rf_rx: mpsc::UnboundedReceiver<rf::RfPacket>,
    rf_tx: mpsc::UnboundedSender<rf::RfPacket>,
    state: State,
}

impl ConfigParameters {
    fn get(&self, id: nci::ConfigParameterId) -> Result<Vec<u8>> {
        match id {
            nci::ConfigParameterId::TotalDuration => Ok(self.total_duration.to_le_bytes().to_vec()),
            nci::ConfigParameterId::ConDiscoveryParam => {
                Ok(self.con_discovery_param.to_le_bytes().to_vec())
            }
            nci::ConfigParameterId::PowerState => Ok(vec![self.power_state]),
            nci::ConfigParameterId::PaBailOut => Ok(vec![self.pa_bail_out]),
            nci::ConfigParameterId::PaDevicesLimit => Ok(vec![self.pa_devices_limit]),
            nci::ConfigParameterId::PbAfi => Ok(vec![self.pb_afi]),
            nci::ConfigParameterId::PbBailOut => Ok(vec![self.pb_bail_out]),
            nci::ConfigParameterId::PbAttribParam1 => Ok(vec![self.pb_attrib_param1]),
            nci::ConfigParameterId::PbSensbReqParam => Ok(vec![self.pb_sensb_req_param]),
            nci::ConfigParameterId::PbDevicesLimit => Ok(vec![self.pb_devices_limit]),
            nci::ConfigParameterId::PfBitRate => Ok(vec![self.pf_bit_rate]),
            nci::ConfigParameterId::PfBailOut => Ok(vec![self.pf_bail_out]),
            nci::ConfigParameterId::PfDevicesLimit => Ok(vec![self.pf_devices_limit]),
            nci::ConfigParameterId::PiBHInfo => Ok(self.pi_b_h_info.clone()),
            nci::ConfigParameterId::PiBitRate => Ok(vec![self.pi_bit_rate]),
            nci::ConfigParameterId::PnNfcDepPsl => Ok(vec![self.pn_nfc_dep_psl]),
            nci::ConfigParameterId::PnAtrReqGenBytes => Ok(self.pn_atr_req_gen_bytes.clone()),
            nci::ConfigParameterId::PnAtrReqConfig => Ok(vec![self.pn_atr_req_config]),
            nci::ConfigParameterId::PvDevicesLimit => Ok(vec![self.pv_devices_limit]),
            nci::ConfigParameterId::LaBitFrameSdd => Ok(vec![self.la_bit_frame_sdd]),
            nci::ConfigParameterId::LaPlatformConfig => Ok(vec![self.la_platform_config]),
            nci::ConfigParameterId::LaSelInfo => Ok(vec![self.la_sel_info]),
            nci::ConfigParameterId::LaNfcid1 => Ok(self.la_nfcid1.clone()),
            nci::ConfigParameterId::LbSensbInfo => Ok(vec![self.lb_sensb_info]),
            nci::ConfigParameterId::LbNfcid0 => Ok(self.lb_nfcid0.to_vec()),
            nci::ConfigParameterId::LbApplicationData => {
                Ok(self.lb_application_data.to_le_bytes().to_vec())
            }
            nci::ConfigParameterId::LbSfgi => Ok(vec![self.lb_sfgi]),
            nci::ConfigParameterId::LbFwiAdcFo => Ok(vec![self.lb_fwi_adc_fo]),
            nci::ConfigParameterId::LbBitRate => Ok(vec![self.lb_bit_rate]),
            nci::ConfigParameterId::LfT3tIdentifiers1 => Ok(self.lf_t3t_identifiers_1.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers2 => Ok(self.lf_t3t_identifiers_2.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers3 => Ok(self.lf_t3t_identifiers_3.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers4 => Ok(self.lf_t3t_identifiers_4.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers5 => Ok(self.lf_t3t_identifiers_5.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers6 => Ok(self.lf_t3t_identifiers_6.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers7 => Ok(self.lf_t3t_identifiers_7.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers8 => Ok(self.lf_t3t_identifiers_8.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers9 => Ok(self.lf_t3t_identifiers_9.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers10 => Ok(self.lf_t3t_identifiers_10.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers11 => Ok(self.lf_t3t_identifiers_11.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers12 => Ok(self.lf_t3t_identifiers_12.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers13 => Ok(self.lf_t3t_identifiers_13.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers14 => Ok(self.lf_t3t_identifiers_14.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers15 => Ok(self.lf_t3t_identifiers_15.to_vec()),
            nci::ConfigParameterId::LfT3tIdentifiers16 => Ok(self.lf_t3t_identifiers_16.to_vec()),
            nci::ConfigParameterId::LfT3tPmmDefault => Ok(self.lf_t3t_pmm_default.to_vec()),
            nci::ConfigParameterId::LfT3tMax => Ok(vec![self.lf_t3t_max]),
            nci::ConfigParameterId::LfT3tFlags => Ok(self.lf_t3t_flags.to_le_bytes().to_vec()),
            nci::ConfigParameterId::LfT3tRdAllowed => Ok(vec![self.lf_t3t_rd_allowed]),
            nci::ConfigParameterId::LfProtocolType => Ok(vec![self.lf_protocol_type]),
            nci::ConfigParameterId::LiARatsTb1 => Ok(vec![self.li_a_rats_tb1]),
            nci::ConfigParameterId::LiAHistBy => Ok(self.li_a_hist_by.clone()),
            nci::ConfigParameterId::LiBHInfoResp => Ok(self.li_b_h_info_resp.clone()),
            nci::ConfigParameterId::LiABitRate => Ok(vec![self.li_a_bit_rate]),
            nci::ConfigParameterId::LiARatsTc1 => Ok(vec![self.li_a_rats_tc1]),
            nci::ConfigParameterId::LnWt => Ok(vec![self.ln_wt]),
            nci::ConfigParameterId::LnAtrResGenBytes => Ok(self.ln_atr_res_gen_bytes.clone()),
            nci::ConfigParameterId::LnAtrResConfig => Ok(vec![self.ln_atr_res_config]),
            nci::ConfigParameterId::PacmBitRate => Ok(vec![self.pacm_bit_rate]),
            nci::ConfigParameterId::RfFieldInfo => Ok(vec![self.rf_field_info]),
            nci::ConfigParameterId::RfNfceeAction => Ok(vec![self.rf_nfcee_action]),
            nci::ConfigParameterId::NfcdepOp => Ok(vec![self.nfcdep_op]),
            nci::ConfigParameterId::LlcpVersion => Ok(vec![self.llcp_version]),
            nci::ConfigParameterId::NfccConfigControl => Ok(vec![self.nfcc_config_control]),
            _ => Err(anyhow::anyhow!("unknown config parameter ID")),
        }
    }

    fn set(&mut self, id: nci::ConfigParameterId, value: &[u8]) -> Result<()> {
        match id {
            nci::ConfigParameterId::TotalDuration => {
                self.total_duration = u16::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::ConDiscoveryParam => {
                self.con_discovery_param = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PowerState => {
                self.power_state = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PaBailOut => {
                self.pa_bail_out = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PaDevicesLimit => {
                self.pa_devices_limit = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PbAfi => {
                self.pb_afi = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PbBailOut => {
                self.pb_bail_out = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PbAttribParam1 => {
                self.pb_attrib_param1 = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PbSensbReqParam => {
                self.pb_sensb_req_param = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PbDevicesLimit => {
                self.pb_devices_limit = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PfBitRate => {
                self.pf_bit_rate = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PfBailOut => {
                self.pf_bail_out = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PfDevicesLimit => {
                self.pf_devices_limit = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PiBHInfo => {
                self.pi_b_h_info = value.to_vec();
                Ok(())
            }
            nci::ConfigParameterId::PiBitRate => {
                self.pi_bit_rate = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PnNfcDepPsl => {
                self.pn_nfc_dep_psl = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PnAtrReqGenBytes => {
                self.pn_atr_req_gen_bytes = value.to_vec();
                Ok(())
            }
            nci::ConfigParameterId::PnAtrReqConfig => {
                self.pn_atr_req_config = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PvDevicesLimit => {
                self.pv_devices_limit = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LaBitFrameSdd => {
                self.la_bit_frame_sdd = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LaPlatformConfig => {
                self.la_platform_config = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LaSelInfo => {
                self.la_sel_info = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LaNfcid1 => {
                self.la_nfcid1 = value.to_vec();
                Ok(())
            }
            nci::ConfigParameterId::LbSensbInfo => {
                self.lb_sensb_info = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LbNfcid0 => {
                self.lb_nfcid0 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LbApplicationData => {
                self.lb_application_data = u32::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LbSfgi => {
                self.lb_sfgi = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LbFwiAdcFo => {
                self.lb_fwi_adc_fo = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LbBitRate => {
                self.lb_bit_rate = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers1 => {
                self.lf_t3t_identifiers_1 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers2 => {
                self.lf_t3t_identifiers_2 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers3 => {
                self.lf_t3t_identifiers_3 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers4 => {
                self.lf_t3t_identifiers_4 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers5 => {
                self.lf_t3t_identifiers_5 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers6 => {
                self.lf_t3t_identifiers_6 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers7 => {
                self.lf_t3t_identifiers_7 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers8 => {
                self.lf_t3t_identifiers_8 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers9 => {
                self.lf_t3t_identifiers_9 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers10 => {
                self.lf_t3t_identifiers_10 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers11 => {
                self.lf_t3t_identifiers_11 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers12 => {
                self.lf_t3t_identifiers_12 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers13 => {
                self.lf_t3t_identifiers_13 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers14 => {
                self.lf_t3t_identifiers_14 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers15 => {
                self.lf_t3t_identifiers_15 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tIdentifiers16 => {
                self.lf_t3t_identifiers_16 = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tPmmDefault => {
                self.lf_t3t_pmm_default = value.try_into()?;
                Ok(())
            }
            nci::ConfigParameterId::LfT3tMax => Err(anyhow::anyhow!("read-only config parameter")),
            nci::ConfigParameterId::LfT3tFlags => {
                self.lf_t3t_flags = u16::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LfT3tRdAllowed => {
                self.lf_t3t_rd_allowed = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LfProtocolType => {
                self.lf_protocol_type = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LiARatsTb1 => {
                self.li_a_rats_tb1 = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LiAHistBy => {
                self.li_a_hist_by = value.to_vec();
                Ok(())
            }
            nci::ConfigParameterId::LiBHInfoResp => {
                self.li_b_h_info_resp = value.to_vec();
                Ok(())
            }
            nci::ConfigParameterId::LiABitRate => {
                self.li_a_bit_rate = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LiARatsTc1 => {
                self.li_a_rats_tc1 = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LnWt => {
                self.ln_wt = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LnAtrResGenBytes => {
                self.ln_atr_res_gen_bytes = value.to_vec();
                Ok(())
            }
            nci::ConfigParameterId::LnAtrResConfig => {
                self.ln_atr_res_config = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::PacmBitRate => {
                self.pacm_bit_rate = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::RfFieldInfo => {
                self.rf_field_info = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::RfNfceeAction => {
                self.rf_nfcee_action = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::NfcdepOp => {
                self.nfcdep_op = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::LlcpVersion => {
                self.llcp_version = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            nci::ConfigParameterId::NfccConfigControl => {
                self.nfcc_config_control = u8::from_le_bytes(value.try_into()?);
                Ok(())
            }
            _ => Err(anyhow::anyhow!("unknown config parameter ID")),
        }
    }
}

impl Default for ConfigParameters {
    fn default() -> Self {
        ConfigParameters {
            total_duration: TOTAL_DURATION,
            con_discovery_param: 0x01,
            power_state: 0x02,
            pa_bail_out: 0x00,
            pa_devices_limit: PA_DEVICES_LIMIT,
            pb_afi: 0x00,
            pb_bail_out: 0x00,
            pb_attrib_param1: PB_ATTRIB_PARAM1,
            pb_sensb_req_param: 0x00,
            pb_devices_limit: PB_DEVICES_LIMIT,
            pf_bit_rate: 0x01,
            pf_bail_out: 0x00,
            pf_devices_limit: PF_DEVICES_LIMIT,
            pi_b_h_info: vec![],
            pi_bit_rate: 0x00,
            pn_nfc_dep_psl: 0x00,
            pn_atr_req_gen_bytes: vec![],
            pn_atr_req_config: 0x30,
            pv_devices_limit: PV_DEVICES_LIMIT,
            la_bit_frame_sdd: LA_BIT_FRAME_SDD,
            la_platform_config: LA_PLATFORM_CONFIG,
            la_sel_info: LA_SEL_INFO,
            la_nfcid1: vec![0x08, 0x00, 0x00, 0x00],
            lb_sensb_info: LB_SENSB_INFO,
            lb_nfcid0: [0x08, 0x00, 0x00, 0x00],
            lb_application_data: 0x00000000,
            lb_sfgi: LB_SFGI,
            lb_fwi_adc_fo: LB_FWI_ADC_FO,
            lb_bit_rate: 0x00,
            lf_t3t_identifiers_1: [0; 18],
            lf_t3t_identifiers_2: [0; 18],
            lf_t3t_identifiers_3: [0; 18],
            lf_t3t_identifiers_4: [0; 18],
            lf_t3t_identifiers_5: [0; 18],
            lf_t3t_identifiers_6: [0; 18],
            lf_t3t_identifiers_7: [0; 18],
            lf_t3t_identifiers_8: [0; 18],
            lf_t3t_identifiers_9: [0; 18],
            lf_t3t_identifiers_10: [0; 18],
            lf_t3t_identifiers_11: [0; 18],
            lf_t3t_identifiers_12: [0; 18],
            lf_t3t_identifiers_13: [0; 18],
            lf_t3t_identifiers_14: [0; 18],
            lf_t3t_identifiers_15: [0; 18],
            lf_t3t_identifiers_16: [0; 18],
            lf_t3t_pmm_default: [0xff; 8],
            lf_t3t_max: LF_T3T_MAX,
            lf_t3t_flags: 0x0000,
            lf_t3t_rd_allowed: 0x00,
            lf_protocol_type: LF_PROTOCOL_TYPE,
            li_a_rats_tb1: LI_A_RATS_TB1,
            li_a_hist_by: vec![],
            li_b_h_info_resp: vec![],
            li_a_bit_rate: 0x00,
            li_a_rats_tc1: LI_A_RATS_TC1,
            ln_wt: 10,
            ln_atr_res_gen_bytes: vec![],
            ln_atr_res_config: 0x30,
            pacm_bit_rate: 0x01,
            rf_field_info: 0x00,
            rf_nfcee_action: 0x01,
            // [NCI] Table 101: NFC-DEP Operation Parameter.
            nfcdep_op: 0x1f,
            llcp_version: LLCP_VERSION,
            nfcc_config_control: 0x00,
        }
    }
}

impl State {
    /// Craft the NFCID1 used by this instance in NFC-A poll responses.
    /// Returns a dynamically generated NFCID1 (4 byte long and starts with 08h).
    fn nfcid1(&self) -> Vec<u8> {
        if self.config_parameters.la_nfcid1.len() == 4
            && self.config_parameters.la_nfcid1[0] == 0x08
        {
            vec![0x08, 186, 7, 99] // TODO(hchataing) pseudo random
        } else {
            self.config_parameters.la_nfcid1.clone()
        }
    }

    /// Select the interface to be preferably used for the selected protocol.
    fn select_interface(
        &self,
        mode: RfMode,
        rf_protocol: nci::RfProtocolType,
    ) -> nci::RfInterfaceType {
        for config in self.discover_map.iter() {
            match (mode, config.mode.poll_mode, config.mode.listen_mode) {
                _ if config.rf_protocol != rf_protocol => (),
                (RfMode::Poll, nci::FeatureFlag::Enabled, _)
                | (RfMode::Listen, _, nci::FeatureFlag::Enabled) => return config.rf_interface,
                _ => (),
            }
        }

        // [NCI] 6.2 RF Interface Mapping Configuration
        //
        // The NFCC SHALL set the default mapping of RF Interface to RF Protocols /
        // Modes to the following values:
        //
        // • If the NFCC supports the ISO-DEP RF interface, the NFCC SHALL map the
        //   ISO-DEP RF Protocol to the ISO-DEP RF Interface for Poll Mode and
        //   Listen Mode.
        // • If the NFCC supports the NFC-DEP RF interface, the NFCC SHALL map the
        //   NFC-DEP RF Protocol to the NFC-DEP RF Interface for Poll Mode and
        //   Listen Mode.
        // • If the NFCC supports the NDEF RF interface, the NFCC SHALL map the
        //   NDEF RF Protocol to the NDEF RF Interface for Poll Mode.
        // • Otherwise, the NFCC SHALL map to the Frame RF Interface by default
        match rf_protocol {
            nci::RfProtocolType::IsoDep => nci::RfInterfaceType::IsoDep,
            nci::RfProtocolType::NfcDep => nci::RfInterfaceType::NfcDep,
            nci::RfProtocolType::Ndef if mode == RfMode::Poll => nci::RfInterfaceType::Ndef,
            _ => nci::RfInterfaceType::Frame,
        }
    }

    /// Insert a poll response into the discovery list.
    /// The response is not inserted if the device was already discovered
    /// with the same parameters.
    fn add_poll_response(&mut self, poll_response: RfPollResponse) {
        if !self.rf_poll_responses.contains(&poll_response) {
            self.rf_poll_responses.push(poll_response);
        }
    }
}

impl<'a> Controller<'a> {
    /// Create a new NFCC instance with default configuration.
    pub fn new(
        id: u16,
        nci_stream: nci::StreamRefMut<'a>,
        nci_writer: nci::Writer,
        rf_rx: mpsc::UnboundedReceiver<rf::RfPacket>,
        rf_tx: mpsc::UnboundedSender<rf::RfPacket>,
    ) -> Controller<'a> {
        Controller {
            id,
            nci_stream,
            nci_writer,
            rf_rx,
            rf_tx,
            state: State {
                config_parameters: Default::default(),
                logical_connections: [None; MAX_LOGICAL_CONNECTIONS as usize],
                discover_map: vec![],
                discover_configuration: vec![],
                nfcee_state: NfceeState::Disabled,
                rf_state: RfState::Idle,
                rf_poll_responses: vec![],
                rf_activation_parameters: vec![],
                passive_observe_mode: nci::PassiveObserveMode::Disable,
                start_time: Instant::now(),
            },
        }
    }

    async fn send_control(&mut self, packet: impl Into<nci::ControlPacket>) -> Result<()> {
        self.nci_writer.write(&packet.into().encode_to_vec()?).await
    }

    async fn send_data(&mut self, packet: impl Into<nci::DataPacket>) -> Result<()> {
        self.nci_writer.write(&packet.into().encode_to_vec()?).await
    }

    async fn send_rf(&self, packet: impl Into<rf::RfPacket>) -> Result<()> {
        self.rf_tx.send(packet.into())?;
        Ok(())
    }

    async fn core_reset(&mut self, cmd: nci::CoreResetCommand) -> Result<()> {
        info!("[{}] CORE_RESET_CMD", self.id);
        info!("         ResetType: {:?}", cmd.get_reset_type());

        match cmd.get_reset_type() {
            nci::ResetType::KeepConfig => (),
            nci::ResetType::ResetConfig => self.state.config_parameters = Default::default(),
        }

        for i in 0..MAX_LOGICAL_CONNECTIONS {
            self.state.logical_connections[i as usize] = None;
        }

        self.state.discover_map.clear();
        self.state.discover_configuration.clear();
        self.state.rf_state = RfState::Idle;
        self.state.rf_poll_responses.clear();

        self.send_control(nci::CoreResetResponseBuilder { status: nci::Status::Ok }).await?;

        self.send_control(nci::CoreResetNotificationBuilder {
            trigger: nci::ResetTrigger::ResetCommand,
            config_status: match cmd.get_reset_type() {
                nci::ResetType::KeepConfig => nci::ConfigStatus::ConfigKept,
                nci::ResetType::ResetConfig => nci::ConfigStatus::ConfigReset,
            },
            nci_version: NCI_VERSION,
            manufacturer_id: MANUFACTURER_ID,
            manufacturer_specific_information: MANUFACTURER_SPECIFIC_INFORMATION.to_vec(),
        })
        .await?;

        Ok(())
    }

    async fn core_init(&mut self, _cmd: nci::CoreInitCommand) -> Result<()> {
        info!("[{}] CORE_INIT_CMD", self.id);

        self.send_control(nci::CoreInitResponseBuilder {
            status: nci::Status::Ok,
            nfcc_features: nci::NfccFeatures {
                discovery_frequency_configuration: nci::FeatureFlag::Disabled,
                discovery_configuration_mode: nci::DiscoveryConfigurationMode::DhOnly,
                hci_network_support: nci::FeatureFlag::Enabled,
                active_communication_mode: nci::FeatureFlag::Enabled,
                technology_based_routing: nci::FeatureFlag::Enabled,
                protocol_based_routing: nci::FeatureFlag::Enabled,
                aid_based_routing: nci::FeatureFlag::Enabled,
                system_code_based_routing: nci::FeatureFlag::Enabled,
                apdu_pattern_based_routing: nci::FeatureFlag::Enabled,
                forced_nfcee_routing: nci::FeatureFlag::Enabled,
                battery_off_state: nci::FeatureFlag::Disabled,
                switched_off_state: nci::FeatureFlag::Enabled,
                switched_on_substates: nci::FeatureFlag::Enabled,
                rf_configuration_in_switched_off_state: nci::FeatureFlag::Disabled,
                proprietary_capabilities: 0,
            },
            max_logical_connections: MAX_LOGICAL_CONNECTIONS,
            max_routing_table_size: MAX_ROUTING_TABLE_SIZE,
            max_control_packet_payload_size: MAX_CONTROL_PACKET_PAYLOAD_SIZE,
            max_data_packet_payload_size: MAX_DATA_PACKET_PAYLOAD_SIZE,
            number_of_credits: NUMBER_OF_CREDITS,
            max_nfcv_rf_frame_size: MAX_NFCV_RF_FRAME_SIZE,
            supported_rf_interfaces: vec![
                nci::RfInterface { interface: nci::RfInterfaceType::Frame, extensions: vec![] },
                nci::RfInterface { interface: nci::RfInterfaceType::IsoDep, extensions: vec![] },
                nci::RfInterface { interface: nci::RfInterfaceType::NfcDep, extensions: vec![] },
                nci::RfInterface {
                    interface: nci::RfInterfaceType::NfceeDirect,
                    extensions: vec![],
                },
            ],
        })
        .await?;

        Ok(())
    }

    async fn core_set_config(&mut self, cmd: nci::CoreSetConfigCommand) -> Result<()> {
        info!("[{}] CORE_SET_CONFIG_CMD", self.id);

        let mut invalid_parameters = vec![];
        for parameter in cmd.get_parameters().iter() {
            info!("         Type: {:?}", parameter.id);
            info!("         Value: {:?}", parameter.value);
            match parameter.id {
                nci::ConfigParameterId::Rfu(_) => invalid_parameters.push(parameter.id),
                // TODO(henrichataing):
                // [NCI] 5.2.1 State RFST_IDLE
                // Unless otherwise specified, discovery related configuration
                // defined in Sections 6.1, 6.2, 6.3 and 7.1 SHALL only be set
                // while in IDLE state.
                //
                // Respond with Semantic Error as indicated by
                // [NCI] 3.2.2 Exception Handling for Control Messages
                // An unexpected Command SHALL NOT cause any action by the NFCC.
                // Unless otherwise specified, the NFCC SHALL send a Response
                // with a Status value of STATUS_SEMANTIC_ERROR and no
                // additional fields.
                _ => {
                    if self.state.config_parameters.set(parameter.id, &parameter.value).is_err() {
                        invalid_parameters.push(parameter.id)
                    }
                }
            }
        }

        self.send_control(nci::CoreSetConfigResponseBuilder {
            status: if invalid_parameters.is_empty() {
                // A Status of STATUS_OK SHALL indicate that all configuration parameters
                // have been set to these new values in the NFCC.
                nci::Status::Ok
            } else {
                // If the DH tries to set a parameter that is not applicable for the NFCC,
                // the NFCC SHALL respond with a CORE_SET_CONFIG_RSP with a Status field
                // of STATUS_INVALID_PARAM and including one or more invalid Parameter ID(s).
                // All other configuration parameters SHALL have been set to the new values
                // in the NFCC.
                warn!(
                    "[{}] rejecting unknown configuration parameter ids: {:?}",
                    self.id, invalid_parameters
                );
                nci::Status::InvalidParam
            },
            parameters: invalid_parameters,
        })
        .await?;

        Ok(())
    }

    async fn core_get_config(&mut self, cmd: nci::CoreGetConfigCommand) -> Result<()> {
        info!("[{}] CORE_GET_CONFIG_CMD", self.id);

        let mut valid_parameters = vec![];
        let mut invalid_parameters = vec![];
        for id in cmd.get_parameters() {
            info!("         ID: {:?}", id);
            match self.state.config_parameters.get(*id) {
                Ok(value) => {
                    valid_parameters.push(nci::ConfigParameter { id: *id, value: value.to_vec() })
                }
                Err(_) => invalid_parameters.push(nci::ConfigParameter { id: *id, value: vec![] }),
            }
        }

        self.send_control(if invalid_parameters.is_empty() {
            // If the NFCC is able to respond with all requested parameters, the
            // NFCC SHALL respond with the CORE_GET_CONFIG_RSP with a Status
            // of STATUS_OK.
            nci::CoreGetConfigResponseBuilder {
                status: nci::Status::Ok,
                parameters: valid_parameters,
            }
        } else {
            // If the DH tries to retrieve any parameter(s) that are not available
            // in the NFCC, the NFCC SHALL respond with a CORE_GET_CONFIG_RSP with
            // a Status field of STATUS_INVALID_PARAM, containing each unavailable
            // Parameter ID with a Parameter Len field of value zero.
            nci::CoreGetConfigResponseBuilder {
                status: nci::Status::InvalidParam,
                parameters: invalid_parameters,
            }
        })
        .await?;

        Ok(())
    }

    async fn core_conn_create(&mut self, cmd: nci::CoreConnCreateCommand) -> Result<()> {
        info!("[{}] CORE_CONN_CREATE_CMD", self.id);

        let result: std::result::Result<u8, nci::Status> = (|| {
            // Retrieve an unused connection ID for the logical connection.
            let conn_id = {
                (0..MAX_LOGICAL_CONNECTIONS)
                    .find(|conn_id| self.state.logical_connections[*conn_id as usize].is_none())
                    .ok_or(nci::Status::Rejected)?
            };

            // Check that the selected destination type is supported and validate
            // the destination specific parameters.
            let logical_connection = match cmd.get_destination_type() {
                // If the value of Destination Type is that of a Remote NFC
                // Endpoint (0x02), then only the Destination-specific Parameter
                // with Type 0x00 or proprietary parameters (as defined in Table 16)
                // SHALL be present.
                nci::DestinationType::RemoteNfcEndpoint => {
                    let mut rf_discovery_id: Option<u8> = None;
                    let mut rf_protocol_type: Option<nci::RfProtocolType> = None;

                    for parameter in cmd.get_parameters() {
                        match parameter.id {
                            nci::DestinationSpecificParameterId::RfDiscovery => {
                                rf_discovery_id = parameter.value.first().cloned();
                                rf_protocol_type = parameter
                                    .value
                                    .get(1)
                                    .and_then(|t| nci::RfProtocolType::try_from(*t).ok());
                            }
                            _ => return Err(nci::Status::Rejected),
                        }
                    }

                    LogicalConnection::RemoteNfcEndpoint {
                        rf_discovery_id: rf_discovery_id.ok_or(nci::Status::Rejected)?,
                        rf_protocol_type: rf_protocol_type.ok_or(nci::Status::Rejected)?,
                    }
                }
                nci::DestinationType::NfccLoopback | nci::DestinationType::Nfcee => {
                    return Err(nci::Status::Rejected)
                }
            };

            // The combination of Destination Type and Destination Specific
            // Parameters SHALL uniquely identify a single destination for the
            // Logical Connection.
            if self
                .state
                .logical_connections
                .iter()
                .any(|c| c.as_ref() == Some(&logical_connection))
            {
                return Err(nci::Status::Rejected);
            }

            // Create the connection.
            self.state.logical_connections[conn_id as usize] = Some(logical_connection);

            Ok(conn_id)
        })();

        self.send_control(match result {
            Ok(conn_id) => nci::CoreConnCreateResponseBuilder {
                status: nci::Status::Ok,
                max_data_packet_payload_size: MAX_DATA_PACKET_PAYLOAD_SIZE,
                initial_number_of_credits: 0xff,
                conn_id: nci::ConnId::from_dynamic(conn_id),
            },
            Err(status) => nci::CoreConnCreateResponseBuilder {
                status,
                max_data_packet_payload_size: 0,
                initial_number_of_credits: 0xff,
                conn_id: 0.try_into().unwrap(),
            },
        })
        .await?;

        Ok(())
    }

    async fn core_conn_close(&mut self, cmd: nci::CoreConnCloseCommand) -> Result<()> {
        info!("[{}] CORE_CONN_CLOSE_CMD", self.id);

        let conn_id = match cmd.get_conn_id() {
            nci::ConnId::StaticRf | nci::ConnId::StaticHci => {
                warn!("[{}] core_conn_close called with static conn_id", self.id);
                self.send_control(nci::CoreConnCloseResponseBuilder {
                    status: nci::Status::Rejected,
                })
                .await?;
                return Ok(());
            }
            nci::ConnId::Dynamic(id) => nci::ConnId::to_dynamic(id),
        };

        let status = if conn_id >= MAX_LOGICAL_CONNECTIONS
            || self.state.logical_connections[conn_id as usize].is_none()
        {
            // If there is no connection associated to the Conn ID in the CORE_CONN_CLOSE_CMD, the
            // NFCC SHALL reject the connection closure request by sending a CORE_CONN_CLOSE_RSP
            // with a Status of STATUS_REJECTED.
            nci::Status::Rejected
        } else {
            // When it receives a CORE_CONN_CLOSE_CMD for an existing connection, the NFCC SHALL
            // accept the connection closure request by sending a CORE_CONN_CLOSE_RSP with a Status of
            // STATUS_OK, and the Logical Connection is closed.
            self.state.logical_connections[conn_id as usize] = None;
            nci::Status::Ok
        };

        self.send_control(nci::CoreConnCloseResponseBuilder { status }).await?;

        Ok(())
    }

    async fn core_set_power_sub_state(
        &mut self,
        cmd: nci::CoreSetPowerSubStateCommand,
    ) -> Result<()> {
        info!("[{}] CORE_SET_POWER_SUB_STATE_CMD", self.id);
        info!("         State: {:?}", cmd.get_power_state());

        self.send_control(nci::CoreSetPowerSubStateResponseBuilder { status: nci::Status::Ok })
            .await?;

        Ok(())
    }

    async fn rf_discover_map(&mut self, cmd: nci::RfDiscoverMapCommand) -> Result<()> {
        info!("[{}] RF_DISCOVER_MAP_CMD", self.id);

        self.state.discover_map.clone_from(cmd.get_mapping_configurations());
        self.send_control(nci::RfDiscoverMapResponseBuilder { status: nci::Status::Ok }).await?;

        Ok(())
    }

    async fn rf_set_listen_mode_routing(
        &mut self,
        _cmd: nci::RfSetListenModeRoutingCommand,
    ) -> Result<()> {
        info!("[{}] RF_SET_LISTEN_MODE_ROUTING_CMD", self.id);

        self.send_control(nci::RfSetListenModeRoutingResponseBuilder { status: nci::Status::Ok })
            .await?;

        Ok(())
    }

    async fn rf_get_listen_mode_routing(
        &mut self,
        _cmd: nci::RfGetListenModeRoutingCommand,
    ) -> Result<()> {
        info!("[{}] RF_GET_LISTEN_MODE_ROUTING_CMD", self.id);

        self.send_control(nci::RfGetListenModeRoutingResponseBuilder {
            status: nci::Status::Ok,
            more_to_follow: 0,
            routing_entries: vec![],
        })
        .await?;

        Ok(())
    }

    async fn rf_discover(&mut self, cmd: nci::RfDiscoverCommand) -> Result<()> {
        info!("[{}] RF_DISCOVER_CMD", self.id);
        for config in cmd.get_configurations() {
            info!("         TechMode: {:?}", config.technology_and_mode);
        }

        if self.state.rf_state != RfState::Idle {
            warn!("[{}] rf_discover received in {:?} state", self.id, self.state.rf_state);
            self.send_control(nci::RfDiscoverResponseBuilder {
                status: nci::Status::SemanticError,
            })
            .await?;
            return Ok(());
        }

        self.state.discover_configuration.clone_from(cmd.get_configurations());
        self.state.rf_state = RfState::Discovery;

        self.send_control(nci::RfDiscoverResponseBuilder { status: nci::Status::Ok }).await?;

        Ok(())
    }

    async fn rf_discover_select(&mut self, cmd: nci::RfDiscoverSelectCommand) -> Result<()> {
        info!("[{}] RF_DISCOVER_SELECT_CMD", self.id);
        info!("         DiscoveryID: {:?}", cmd.get_rf_discovery_id());
        info!("         Protocol: {:?}", cmd.get_rf_protocol());
        info!("         Interface: {:?}", cmd.get_rf_interface());

        if self.state.rf_state != RfState::WaitForHostSelect {
            warn!("[{}] rf_discover_select received in {:?} state", self.id, self.state.rf_state);
            self.send_control(nci::RfDiscoverSelectResponseBuilder {
                status: nci::Status::SemanticError,
            })
            .await?;
            return Ok(());
        }

        let rf_discovery_id = match cmd.get_rf_discovery_id() {
            nci::RfDiscoveryId::Rfu(_) => {
                warn!("[{}] rf_discover_select with reserved rf_discovery_id", self.id);
                self.send_control(nci::RfDiscoverSelectResponseBuilder {
                    status: nci::Status::Rejected,
                })
                .await?;
                return Ok(());
            }
            nci::RfDiscoveryId::Id(id) => nci::RfDiscoveryId::to_index(id),
        };

        // If the RF Discovery ID, RF Protocol or RF Interface is not valid,
        // the NFCC SHALL respond with RF_DISCOVER_SELECT_RSP with a Status of
        // STATUS_REJECTED.
        if rf_discovery_id >= self.state.rf_poll_responses.len() {
            warn!("[{}] rf_discover_select with invalid rf_discovery_id", self.id);
            self.send_control(nci::RfDiscoverSelectResponseBuilder {
                status: nci::Status::Rejected,
            })
            .await?;
            return Ok(());
        }

        if cmd.get_rf_protocol() != self.state.rf_poll_responses[rf_discovery_id].rf_protocol.into()
        {
            warn!("[{}] rf_discover_select with invalid rf_protocol", self.id);
            self.send_control(nci::RfDiscoverSelectResponseBuilder {
                status: nci::Status::Rejected,
            })
            .await?;
            return Ok(());
        }

        self.send_control(nci::RfDiscoverSelectResponseBuilder { status: nci::Status::Ok }).await?;

        // Send RF select command to the peer to activate the device.
        // The command has varying parameters based on the activated protocol.
        self.activate_poll_interface(
            rf_discovery_id,
            cmd.get_rf_protocol(),
            cmd.get_rf_interface(),
        )
        .await?;

        Ok(())
    }

    async fn rf_deactivate(&mut self, cmd: nci::RfDeactivateCommand) -> Result<()> {
        info!("[{}] RF_DEACTIVATE_CMD", self.id);
        info!("         Type: {:?}", cmd.get_deactivation_type());

        use nci::DeactivationType::*;

        let (status, mut next_state) = match (self.state.rf_state, cmd.get_deactivation_type()) {
            (RfState::Idle, _) => (nci::Status::SemanticError, RfState::Idle),
            (RfState::Discovery, IdleMode) => (nci::Status::Ok, RfState::Idle),
            (RfState::Discovery, _) => (nci::Status::SemanticError, RfState::Discovery),
            (RfState::PollActive { .. }, IdleMode) => (nci::Status::Ok, RfState::Idle),
            (RfState::PollActive { .. }, SleepMode | SleepAfMode) => {
                (nci::Status::Ok, RfState::WaitForHostSelect)
            }
            (RfState::PollActive { .. }, Discovery) => (nci::Status::Ok, RfState::Discovery),
            (RfState::ListenSleep { .. }, IdleMode) => (nci::Status::Ok, RfState::Idle),
            (RfState::ListenSleep { .. }, _) => (nci::Status::SemanticError, self.state.rf_state),
            (RfState::ListenActive { .. }, IdleMode) => (nci::Status::Ok, RfState::Idle),
            (RfState::ListenActive { id, .. }, SleepMode | SleepAfMode) => {
                (nci::Status::Ok, RfState::ListenSleep { id })
            }
            (RfState::ListenActive { .. }, Discovery) => (nci::Status::Ok, RfState::Discovery),
            (RfState::WaitForHostSelect, IdleMode) => (nci::Status::Ok, RfState::Idle),
            (RfState::WaitForHostSelect, _) => {
                (nci::Status::SemanticError, RfState::WaitForHostSelect)
            }
            (RfState::WaitForSelectResponse { .. }, IdleMode) => (nci::Status::Ok, RfState::Idle),
            (RfState::WaitForSelectResponse { .. }, _) => {
                (nci::Status::SemanticError, self.state.rf_state)
            }
        };

        // Update the state now to prevent interface activation from
        // completing if a remote device is being selected.
        (next_state, self.state.rf_state) = (self.state.rf_state, next_state);

        self.send_control(nci::RfDeactivateResponseBuilder { status }).await?;

        // Deactivate the active RF interface if applicable
        // (next_state is the previous state in this context).
        match next_state {
            RfState::PollActive { .. } | RfState::ListenActive { .. } => {
                info!("[{}] RF_DEACTIVATE_NTF", self.id);
                info!("         Type: {:?}", cmd.get_deactivation_type());
                info!("         Reason: DH_Request");
                self.field_info(rf::FieldStatus::FieldOff, 255).await?;
                self.send_control(nci::RfDeactivateNotificationBuilder {
                    deactivation_type: cmd.get_deactivation_type(),
                    deactivation_reason: nci::DeactivationReason::DhRequest,
                })
                .await?
            }
            _ => (),
        }

        // Deselect the remote device if applicable.
        match next_state {
            RfState::PollActive { id, rf_protocol, rf_technology, .. }
            | RfState::WaitForSelectResponse { id, rf_protocol, rf_technology, .. } => {
                self.send_rf(rf::DeactivateNotificationBuilder {
                    receiver: id,
                    protocol: rf_protocol,
                    technology: rf_technology,
                    power_level: 255,
                    sender: self.id,
                    type_: cmd.get_deactivation_type().into(),
                    reason: rf::DeactivateReason::EndpointRequest,
                })
                .await?
            }
            _ => (),
        }

        Ok(())
    }

    async fn nfcee_discover(&mut self, _cmd: nci::NfceeDiscoverCommand) -> Result<()> {
        info!("[{}] NFCEE_DISCOVER_CMD", self.id);

        self.send_control(nci::NfceeDiscoverResponseBuilder {
            status: nci::Status::Ok,
            number_of_nfcees: 1,
        })
        .await?;

        self.send_control(nci::NfceeDiscoverNotificationBuilder {
            nfcee_id: nci::NfceeId::hci_nfcee(0x86),
            nfcee_status: nci::NfceeStatus::Disabled,
            supported_nfcee_protocols: vec![],
            nfcee_information: vec![nci::NfceeInformation {
                r#type: nci::NfceeInformationType::HostId,
                value: vec![0xc0],
            }],
            nfcee_supply_power: nci::NfceeSupplyPower::NfccHasNoControl,
        })
        .await?;

        Ok(())
    }

    async fn nfcee_mode_set(&mut self, cmd: nci::NfceeModeSetCommand) -> Result<()> {
        info!("[{}] NFCEE_MODE_SET_CMD", self.id);
        info!("         NFCEE ID: {:?}", cmd.get_nfcee_id());
        info!("         NFCEE Mode: {:?}", cmd.get_nfcee_mode());

        if cmd.get_nfcee_id() != nci::NfceeId::hci_nfcee(0x86) {
            warn!("[{}] nfcee_mode_set with invalid nfcee_id", self.id);
            self.send_control(nci::NfceeModeSetResponseBuilder { status: nci::Status::Ok }).await?;
            return Ok(());
        }

        self.state.nfcee_state = match cmd.get_nfcee_mode() {
            nci::NfceeMode::Enable => NfceeState::Enabled,
            nci::NfceeMode::Disable => NfceeState::Disabled,
        };

        self.send_control(nci::NfceeModeSetResponseBuilder { status: nci::Status::Ok }).await?;

        self.send_control(nci::NfceeModeSetNotificationBuilder { status: nci::Status::Ok }).await?;

        if self.state.nfcee_state == NfceeState::Enabled {
            // Android host stack expects this notification to know when the
            // NFCEE completes start-up. The list of information entries is
            // filled with defaults observed on real phones.
            self.send_data(nci::DataPacketBuilder {
                mt: nci::MessageType::Data,
                conn_id: nci::ConnId::StaticHci,
                cr: 0,
                payload: Some(bytes::Bytes::copy_from_slice(&[0x81, 0x43, 0xc0, 0x01])),
            })
            .await?;

            self.send_control(nci::RfNfceeDiscoveryReqNotificationBuilder {
                information_entries: vec![
                    nci::InformationEntry {
                        r#type: nci::InformationEntryType::AddDiscoveryRequest,
                        nfcee_id: nci::NfceeId::hci_nfcee(0x86),
                        rf_technology_and_mode: nci::RfTechnologyAndMode::NfcFPassiveListenMode,
                        rf_protocol: nci::RfProtocolType::T3t,
                    },
                    nci::InformationEntry {
                        r#type: nci::InformationEntryType::AddDiscoveryRequest,
                        nfcee_id: nci::NfceeId::hci_nfcee(0x86),
                        rf_technology_and_mode: nci::RfTechnologyAndMode::NfcAPassiveListenMode,
                        rf_protocol: nci::RfProtocolType::IsoDep,
                    },
                    nci::InformationEntry {
                        r#type: nci::InformationEntryType::AddDiscoveryRequest,
                        nfcee_id: nci::NfceeId::hci_nfcee(0x86),
                        rf_technology_and_mode: nci::RfTechnologyAndMode::NfcBPassiveListenMode,
                        rf_protocol: nci::RfProtocolType::IsoDep,
                    },
                ],
            })
            .await?;
        }

        Ok(())
    }

    async fn android_get_caps(&mut self, _cmd: nci::AndroidGetCapsCommand) -> Result<()> {
        info!("[{}] ANDROID_GET_CAPS_CMD", self.id);
        let cap_tlvs = vec![
            nci::CapTlv { t: nci::CapTlvType::PassiveObserverMode, v: vec![1] },
            nci::CapTlv { t: nci::CapTlvType::PollingFrameNotification, v: vec![1] },
        ];
        self.send_control(nci::AndroidGetCapsResponseBuilder {
            status: nci::Status::Ok,
            android_version: 0,
            tlvs: cap_tlvs,
        })
        .await?;
        Ok(())
    }

    async fn android_passive_observe_mode(
        &mut self,
        cmd: nci::AndroidPassiveObserveModeCommand,
    ) -> Result<()> {
        info!("[{}] ANDROID_PASSIVE_OBSERVE_MODE_CMD", self.id);
        info!("     Mode: {:?}", cmd.get_passive_observe_mode());

        self.state.passive_observe_mode = cmd.get_passive_observe_mode();
        self.send_control(nci::AndroidPassiveObserveModeResponseBuilder {
            status: nci::Status::Ok,
        })
        .await?;
        Ok(())
    }

    async fn android_query_passive_observe_mode(
        &mut self,
        _cmd: nci::AndroidQueryPassiveObserveModeCommand,
    ) -> Result<()> {
        info!("[{}] ANDROID_QUERY_PASSIVE_OBSERVE_MODE_CMD", self.id);

        self.send_control(nci::AndroidQueryPassiveObserveModeResponseBuilder {
            status: nci::Status::Ok,
            passive_observe_mode: self.state.passive_observe_mode,
        })
        .await?;
        Ok(())
    }

    async fn receive_command(&mut self, packet: nci::ControlPacket) -> Result<()> {
        use nci::AndroidPacketChild::*;
        use nci::ControlPacketChild::*;
        use nci::CorePacketChild::*;
        use nci::NfceePacketChild::*;
        use nci::ProprietaryPacketChild::*;
        use nci::RfPacketChild::*;

        match packet.specialize() {
            CorePacket(packet) => match packet.specialize() {
                CoreResetCommand(cmd) => self.core_reset(cmd).await,
                CoreInitCommand(cmd) => self.core_init(cmd).await,
                CoreSetConfigCommand(cmd) => self.core_set_config(cmd).await,
                CoreGetConfigCommand(cmd) => self.core_get_config(cmd).await,
                CoreConnCreateCommand(cmd) => self.core_conn_create(cmd).await,
                CoreConnCloseCommand(cmd) => self.core_conn_close(cmd).await,
                CoreSetPowerSubStateCommand(cmd) => self.core_set_power_sub_state(cmd).await,
                _ => unimplemented!("unsupported core oid {:?}", packet.get_oid()),
            },
            RfPacket(packet) => match packet.specialize() {
                RfDiscoverMapCommand(cmd) => self.rf_discover_map(cmd).await,
                RfSetListenModeRoutingCommand(cmd) => self.rf_set_listen_mode_routing(cmd).await,
                RfGetListenModeRoutingCommand(cmd) => self.rf_get_listen_mode_routing(cmd).await,
                RfDiscoverCommand(cmd) => self.rf_discover(cmd).await,
                RfDiscoverSelectCommand(cmd) => self.rf_discover_select(cmd).await,
                RfDeactivateCommand(cmd) => self.rf_deactivate(cmd).await,
                _ => unimplemented!("unsupported rf oid {:?}", packet.get_oid()),
            },
            NfceePacket(packet) => match packet.specialize() {
                NfceeDiscoverCommand(cmd) => self.nfcee_discover(cmd).await,
                NfceeModeSetCommand(cmd) => self.nfcee_mode_set(cmd).await,
                _ => unimplemented!("unsupported nfcee oid {:?}", packet.get_oid()),
            },
            ProprietaryPacket(packet) => match packet.specialize() {
                AndroidPacket(packet) => match packet.specialize() {
                    AndroidGetCapsCommand(cmd) => self.android_get_caps(cmd).await,
                    AndroidPassiveObserveModeCommand(cmd) => {
                        self.android_passive_observe_mode(cmd).await
                    }
                    AndroidQueryPassiveObserveModeCommand(cmd) => {
                        self.android_query_passive_observe_mode(cmd).await
                    }
                    _ => {
                        unimplemented!("unsupported android oid {:?}", packet.get_android_sub_oid())
                    }
                },
                _ => unimplemented!("unsupported proprietary oid {:?}", packet.get_oid()),
            },
            _ => unimplemented!("unsupported gid {:?}", packet.get_gid()),
        }
    }

    async fn rf_conn_data(&mut self, packet: nci::DataPacket) -> Result<()> {
        info!("[{}] received data on RF logical connection", self.id);

        // TODO(henrichataing) implement credit based control flow.
        match self.state.rf_state {
            RfState::PollActive {
                id,
                rf_technology,
                rf_protocol: rf::Protocol::IsoDep,
                rf_interface: nci::RfInterfaceType::IsoDep,
                ..
            }
            | RfState::ListenActive {
                id,
                rf_technology,
                rf_protocol: rf::Protocol::IsoDep,
                rf_interface: nci::RfInterfaceType::IsoDep,
                ..
            } => {
                self.send_rf(rf::DataBuilder {
                    receiver: id,
                    sender: self.id,
                    power_level: 255,
                    protocol: rf::Protocol::IsoDep,
                    technology: rf_technology,
                    data: packet.get_payload().into(),
                })
                .await?;
                // Resplenish the credit count for the RF Connection.
                self.send_control(
                    nci::CoreConnCreditsNotificationBuilder {
                        connections: vec![nci::ConnectionCredits {
                            conn_id: nci::ConnId::StaticRf,
                            credits: 1,
                        }],
                    }
                    .build(),
                )
                .await
            }
            RfState::PollActive {
                rf_protocol: rf::Protocol::IsoDep,
                rf_interface: nci::RfInterfaceType::Frame,
                ..
            } => {
                println!("ISO-DEP frame data {:?}", packet.get_payload());
                match packet.get_payload() {
                    // RATS command
                    // TODO(henrichataing) Send back the response received from
                    // the peer in the RF packet.
                    [0xe0, _] => {
                        warn!("[{}] frame RATS command", self.id);
                        self.send_data(nci::DataPacketBuilder {
                            mt: nci::MessageType::Data,
                            conn_id: nci::ConnId::StaticRf,
                            cr: 0,
                            payload: Some(bytes::Bytes::copy_from_slice(
                                &self.state.rf_activation_parameters,
                            )),
                        })
                        .await?
                    }
                    // DESELECT command
                    // TODO(henrichataing) check if the command should be
                    // forwarded to the peer, and if it warrants a response
                    [0xc2] => warn!("[{}] unimplemented frame DESELECT command", self.id),
                    // SLP_REQ command
                    // No response is expected for this command.
                    // TODO(henrichataing) forward a deactivation request to
                    // the peer and deactivate the local interface.
                    [0x50, 0x00] => warn!("[{}] unimplemented frame SLP_REQ command", self.id),
                    _ => unimplemented!(),
                };
                // Resplenish the credit count for the RF Connection.
                self.send_control(
                    nci::CoreConnCreditsNotificationBuilder {
                        connections: vec![nci::ConnectionCredits {
                            conn_id: nci::ConnId::StaticRf,
                            credits: 1,
                        }],
                    }
                    .build(),
                )
                .await
            }
            RfState::PollActive { rf_protocol, rf_interface, .. }
            | RfState::ListenActive { rf_protocol, rf_interface, .. } => unimplemented!(
                "unsupported combination of RF protocol {:?} and interface {:?}",
                rf_protocol,
                rf_interface
            ),
            _ => {
                warn!(
                    "[{}] ignored RF data packet while not in active listen or poll mode",
                    self.id
                );
                Ok(())
            }
        }
    }

    async fn hci_conn_data(&mut self, packet: nci::DataPacket) -> Result<()> {
        info!("[{}] received data on HCI logical connection", self.id);

        // TODO: parse and understand HCI Control Protocol (HCP)
        // to accurately respond to the requests. For now it is sufficient
        // to return hardcoded answers to identified requests.
        let response = match packet.get_payload() {
            // ANY_OPEN_PIPE()
            [0x81, 0x03] => vec![0x81, 0x80],
            // ANY_GET_PARAMETER(index=1)
            [0x81, 0x02, 0x01] => vec![0x81, 0x80, 0xd7, 0xfe, 0x65, 0x66, 0xc7, 0xfe, 0x65, 0x66],
            // ANY_GET_PARAMETER(index=4)
            [0x81, 0x02, 0x04] => vec![0x81, 0x80, 0x00, 0xc0, 0x01],
            // ANY_SET_PARAMETER()
            [0x81, 0x01, 0x03, 0x02, 0xc0]
            | [0x81, 0x01, 0x03, _, _, _]
            | [0x81, 0x01, 0x01, _, 0x00, 0x00, 0x00, _, 0x00, 0x00, 0x00] => vec![0x81, 0x80],
            // ADM_CLEAR_ALL_PIPE()
            [0x81, 0x14, 0x02, 0x01] => vec![0x81, 0x80],
            _ => {
                error!("unimplemented HCI command : {:?}", packet.get_payload());
                unimplemented!()
            }
        };

        self.send_data(nci::DataPacketBuilder {
            mt: nci::MessageType::Data,
            conn_id: nci::ConnId::StaticHci,
            cr: 0,
            payload: Some(bytes::Bytes::copy_from_slice(&response)),
        })
        .await?;

        // Resplenish the credit count for the HCI Connection.
        self.send_control(
            nci::CoreConnCreditsNotificationBuilder {
                connections: vec![nci::ConnectionCredits {
                    conn_id: nci::ConnId::StaticHci,
                    credits: 1,
                }],
            }
            .build(),
        )
        .await
    }

    async fn dynamic_conn_data(&self, _conn_id: u8, _packet: nci::DataPacket) -> Result<()> {
        info!("[{}] received data on dynamic logical connection", self.id);
        todo!()
    }

    async fn receive_data(&mut self, packet: nci::DataPacket) -> Result<()> {
        info!("[{}] receive_data({})", self.id, u8::from(packet.get_conn_id()));

        match packet.get_conn_id() {
            nci::ConnId::StaticRf => self.rf_conn_data(packet).await,
            nci::ConnId::StaticHci => self.hci_conn_data(packet).await,
            nci::ConnId::Dynamic(id) => self.dynamic_conn_data(*id, packet).await,
        }
    }

    async fn field_info(&mut self, field_status: rf::FieldStatus, power_level: u8) -> Result<()> {
        if self.state.config_parameters.rf_field_info != 0 {
            self.send_control(nci::RfFieldInfoNotificationBuilder {
                rf_field_status: match field_status {
                    rf::FieldStatus::FieldOn => nci::RfFieldStatus::FieldDetected,
                    rf::FieldStatus::FieldOff => nci::RfFieldStatus::NoFieldDetected,
                },
            })
            .await?;
        }
        self.send_control(nci::AndroidPollingLoopNotificationBuilder {
            polling_frames: vec![nci::PollingFrame {
                frame_type: nci::PollingFrameType::RemoteField,
                flags: 0,
                timestamp: (self.state.start_time.elapsed().as_micros() as u32).to_be_bytes(),
                gain: power_level,
                payload: vec![field_status.into()],
            }],
        })
        .await?;
        Ok(())
    }

    async fn poll_command(&mut self, cmd: rf::PollCommand) -> Result<()> {
        trace!("[{}] poll_command()", self.id);

        if self.state.rf_state != RfState::Discovery {
            return Ok(());
        }
        let technology = cmd.get_technology();

        // Android proprietary extension for polling frame notifications.
        // The NFCC should send the NCI_ANDROID_POLLING_FRAME_NTF to the Host
        // after each polling loop frame
        // This notification is independent of whether Passive Observe Mode is
        // active or not. When Passive Observe Mode is active, the NFCC
        // should always send this notification before proceeding with the
        // transaction.
        self.send_control(nci::AndroidPollingLoopNotificationBuilder {
            polling_frames: vec![nci::PollingFrame {
                frame_type: match technology {
                    rf::Technology::NfcA => nci::PollingFrameType::Reqa,
                    rf::Technology::NfcB => nci::PollingFrameType::Reqb,
                    rf::Technology::NfcF => nci::PollingFrameType::Reqf,
                    rf::Technology::NfcV => nci::PollingFrameType::Reqv,
                    rf::Technology::Raw => nci::PollingFrameType::Unknown,
                },
                flags: 0,
                timestamp: (self.state.start_time.elapsed().as_micros() as u32).to_be_bytes(),
                gain: cmd.get_power_level(),
                payload: cmd.get_payload().to_vec(),
            }],
        })
        .await?;

        // When the Passive Observe Mode is active, the NFCC shall not respond
        // to any poll requests during the polling loop in Listen Mode, until
        // explicitly authorized by the Host.
        if self.state.passive_observe_mode == nci::PassiveObserveMode::Enable {
            return Ok(());
        }

        if self.state.discover_configuration.iter().any(|config| {
            matches!(
                (config.technology_and_mode, technology),
                (nci::RfTechnologyAndMode::NfcAPassiveListenMode, rf::Technology::NfcA)
                    | (nci::RfTechnologyAndMode::NfcBPassiveListenMode, rf::Technology::NfcB)
                    | (nci::RfTechnologyAndMode::NfcFPassiveListenMode, rf::Technology::NfcF)
            )
        }) {
            match technology {
                rf::Technology::NfcA => {
                    self.send_rf(rf::NfcAPollResponseBuilder {
                        protocol: rf::Protocol::Undetermined,
                        receiver: cmd.get_sender(),
                        sender: self.id,
                        power_level: 255,
                        nfcid1: self.state.nfcid1(),
                        int_protocol: self.state.config_parameters.la_sel_info >> 5,
                        bit_frame_sdd: self.state.config_parameters.la_bit_frame_sdd,
                    })
                    .await?
                }
                // TODO(b/346715736) implement support for NFC-B technology
                rf::Technology::NfcB => (),
                rf::Technology::NfcF => todo!(),
                _ => (),
            }
        }

        Ok(())
    }

    async fn nfca_poll_response(&mut self, cmd: rf::NfcAPollResponse) -> Result<()> {
        info!("[{}] nfca_poll_response()", self.id);

        if self.state.rf_state != RfState::Discovery {
            return Ok(());
        }

        let int_protocol = cmd.get_int_protocol();
        let rf_protocols = match int_protocol {
            0b00 => [rf::Protocol::T2t].iter(),
            0b01 => [rf::Protocol::IsoDep].iter(),
            0b10 => [rf::Protocol::NfcDep].iter(),
            0b11 => [rf::Protocol::NfcDep, rf::Protocol::IsoDep].iter(),
            _ => return Ok(()),
        };
        let sens_res = match cmd.get_nfcid1().len() {
            4 => 0x00,
            7 => 0x40,
            10 => 0x80,
            _ => panic!(),
        } | cmd.get_bit_frame_sdd() as u16;
        let sel_res = int_protocol << 5;

        for rf_protocol in rf_protocols {
            self.state.add_poll_response(RfPollResponse {
                id: cmd.get_sender(),
                rf_protocol: *rf_protocol,
                rf_technology: rf::Technology::NfcA,
                rf_technology_specific_parameters:
                    nci::NfcAPollModeTechnologySpecificParametersBuilder {
                        sens_res,
                        nfcid1: cmd.get_nfcid1().clone(),
                        sel_res,
                    }
                    .build()
                    .encode_to_vec()?,
            })
        }

        Ok(())
    }

    async fn t4at_select_command(&mut self, cmd: rf::T4ATSelectCommand) -> Result<()> {
        info!("[{}] t4at_select_command()", self.id);

        match self.state.rf_state {
            RfState::Discovery => (),
            RfState::ListenSleep { id } if id == cmd.get_sender() => (),
            _ => return Ok(()),
        };

        // TODO(henrichataing): validate that the protocol and technology are
        // valid for the current discovery settings.

        // TODO(henrichataing): use listen mode routing table to decide which
        // interface should be used for the activating device.

        self.state.rf_state = RfState::ListenActive {
            id: cmd.get_sender(),
            rf_technology: rf::Technology::NfcA,
            rf_protocol: rf::Protocol::IsoDep,
            rf_interface: nci::RfInterfaceType::IsoDep,
        };

        // [DIGITAL] 14.6.2 RATS Response (Answer To Select)
        // Construct the response from the values passed in the configuration
        // parameters. The TL byte is excluded from the response.
        let mut rats_response = vec![
            0x78, // TC(1), TB(1), TA(1) transmitted, FSCI=8
            0x80, // TA(1)
            self.state.config_parameters.li_a_rats_tb1,
            self.state.config_parameters.li_a_rats_tc1,
        ];

        rats_response.extend_from_slice(&self.state.config_parameters.li_a_hist_by);

        self.send_rf(rf::T4ATSelectResponseBuilder {
            receiver: cmd.get_sender(),
            sender: self.id,
            power_level: 255,
            rats_response,
        })
        .await?;

        info!("[{}] RF_INTF_ACTIVATED_NTF", self.id);
        info!("         DiscoveryID: {:?}", nci::RfDiscoveryId::from_index(0));
        info!("         Interface: ISO-DEP");
        info!("         Protocol: ISO-DEP");
        info!("         ActivationTechnology: NFC_A_PASSIVE_LISTEN");
        info!("         RATS: {}", cmd.get_param());

        self.send_control(nci::RfIntfActivatedNotificationBuilder {
            rf_discovery_id: nci::RfDiscoveryId::from_index(0),
            rf_interface: nci::RfInterfaceType::IsoDep,
            rf_protocol: nci::RfProtocolType::IsoDep,
            activation_rf_technology_and_mode: nci::RfTechnologyAndMode::NfcAPassiveListenMode,
            max_data_packet_payload_size: MAX_DATA_PACKET_PAYLOAD_SIZE,
            initial_number_of_credits: 1,
            // No parameters are currently defined for NFC-A Listen Mode.
            rf_technology_specific_parameters: vec![],
            data_exchange_rf_technology_and_mode: nci::RfTechnologyAndMode::NfcAPassiveListenMode,
            data_exchange_transmit_bit_rate: nci::BitRate::BitRate106KbitS,
            data_exchange_receive_bit_rate: nci::BitRate::BitRate106KbitS,
            activation_parameters: nci::NfcAIsoDepListenModeActivationParametersBuilder {
                param: cmd.get_param(),
            }
            .build()
            .encode_to_vec()?,
        })
        .await?;

        Ok(())
    }

    async fn t4at_select_response(&mut self, cmd: rf::T4ATSelectResponse) -> Result<()> {
        info!("[{}] t4at_select_response()", self.id);

        let (id, rf_discovery_id, rf_interface, rf_protocol) = match self.state.rf_state {
            RfState::WaitForSelectResponse {
                id,
                rf_discovery_id,
                rf_interface,
                rf_protocol,
                ..
            } => (id, rf_discovery_id, rf_interface, rf_protocol),
            _ => return Ok(()),
        };

        if cmd.get_sender() != id {
            return Ok(());
        }

        self.state.rf_state = RfState::PollActive {
            id,
            rf_protocol: self.state.rf_poll_responses[rf_discovery_id].rf_protocol,
            rf_technology: self.state.rf_poll_responses[rf_discovery_id].rf_technology,
            rf_interface,
        };

        // Save the activation parameters for the RF frame interface
        // implementation. Note: TL is not included in the RATS response
        // and needs to be added manually to the activation parameters.
        self.state.rf_activation_parameters = vec![cmd.get_rats_response().len() as u8];
        self.state.rf_activation_parameters.extend_from_slice(cmd.get_rats_response());

        info!("[{}] RF_INTF_ACTIVATED_NTF", self.id);
        info!("         DiscoveryID: {:?}", nci::RfDiscoveryId::from_index(rf_discovery_id));
        info!("         Interface: {:?}", rf_interface);
        info!("         Protocol: {:?}", rf_protocol);
        info!("         ActivationTechnology: NFC_A_PASSIVE_POLL");
        info!("         RATS: {:?}", cmd.get_rats_response());

        self.send_control(nci::RfIntfActivatedNotificationBuilder {
            rf_discovery_id: nci::RfDiscoveryId::from_index(rf_discovery_id),
            rf_interface,
            rf_protocol: rf_protocol.into(),
            activation_rf_technology_and_mode: nci::RfTechnologyAndMode::NfcAPassivePollMode,
            max_data_packet_payload_size: MAX_DATA_PACKET_PAYLOAD_SIZE,
            initial_number_of_credits: 1,
            rf_technology_specific_parameters: self.state.rf_poll_responses[rf_discovery_id]
                .rf_technology_specific_parameters
                .clone(),
            data_exchange_rf_technology_and_mode: nci::RfTechnologyAndMode::NfcAPassivePollMode,
            data_exchange_transmit_bit_rate: nci::BitRate::BitRate106KbitS,
            data_exchange_receive_bit_rate: nci::BitRate::BitRate106KbitS,
            // TODO(hchataing) the activation parameters should be empty
            // when the RF frame interface is used, since the protocol
            // activation is managed by the DH.
            activation_parameters: nci::NfcAIsoDepPollModeActivationParametersBuilder {
                rats_response: cmd.get_rats_response().clone(),
            }
            .build()
            .encode_to_vec()?,
        })
        .await?;

        Ok(())
    }

    async fn data_packet(&mut self, data: rf::Data) -> Result<()> {
        info!("[{}] data_packet()", self.id);

        match (self.state.rf_state, data.get_protocol()) {
            (
                RfState::PollActive {
                    id, rf_technology, rf_protocol: rf::Protocol::IsoDep, ..
                },
                rf::Protocol::IsoDep,
            )
            | (
                RfState::ListenActive {
                    id, rf_technology, rf_protocol: rf::Protocol::IsoDep, ..
                },
                rf::Protocol::IsoDep,
            ) if data.get_sender() == id && data.get_technology() == rf_technology => {
                self.send_data(nci::DataPacketBuilder {
                    mt: nci::MessageType::Data,
                    conn_id: nci::ConnId::StaticRf,
                    cr: 1, // TODO(henrichataing): credit based control flow
                    payload: Some(bytes::Bytes::copy_from_slice(data.get_data())),
                })
                .await
            }
            (RfState::PollActive { id, .. }, _) | (RfState::ListenActive { id, .. }, _)
                if id != data.get_sender() =>
            {
                warn!("[{}] ignored RF data packet sent from an un-selected device", self.id);
                Ok(())
            }
            (RfState::PollActive { .. }, _) | (RfState::ListenActive { .. }, _) => {
                unimplemented!("unsupported combination of technology and protocol")
            }
            (_, _) => {
                warn!("[{}] ignored RF data packet received in inactive state", self.id);
                Ok(())
            }
        }
    }

    async fn deactivate_notification(&mut self, cmd: rf::DeactivateNotification) -> Result<()> {
        info!("[{}] deactivate_notification()", self.id);

        use rf::DeactivateType::*;

        let mut next_state = match (self.state.rf_state, cmd.get_type_()) {
            (RfState::PollActive { id, .. }, IdleMode) if id == cmd.get_sender() => RfState::Idle,
            (RfState::PollActive { id, .. }, SleepMode | SleepAfMode) if id == cmd.get_sender() => {
                RfState::WaitForHostSelect
            }
            (RfState::PollActive { id, .. }, Discovery) if id == cmd.get_sender() => {
                RfState::Discovery
            }
            (RfState::ListenSleep { id, .. }, IdleMode) if id == cmd.get_sender() => RfState::Idle,
            (RfState::ListenSleep { id, .. }, Discovery) if id == cmd.get_sender() => {
                RfState::Discovery
            }
            (RfState::ListenActive { id, .. }, IdleMode) if id == cmd.get_sender() => RfState::Idle,
            (RfState::ListenActive { id, .. }, SleepMode | SleepAfMode)
                if id == cmd.get_sender() =>
            {
                RfState::ListenSleep { id }
            }
            (RfState::ListenActive { id, .. }, Discovery) if id == cmd.get_sender() => {
                RfState::Discovery
            }
            (_, _) => self.state.rf_state,
        };

        // Update the state now to prevent interface activation from
        // completing if a remote device is being selected.
        (next_state, self.state.rf_state) = (self.state.rf_state, next_state);

        // Deactivate the active RF interface if applicable.
        if next_state != self.state.rf_state {
            self.field_info(rf::FieldStatus::FieldOff, 255).await?;
            self.send_control(nci::RfDeactivateNotificationBuilder {
                deactivation_type: cmd.get_type_().into(),
                deactivation_reason: cmd.get_reason().into(),
            })
            .await?
        }

        Ok(())
    }

    async fn receive_rf(&mut self, packet: rf::RfPacket) -> Result<()> {
        use rf::RfPacketChild::*;

        match packet.specialize() {
            PollCommand(cmd) => self.poll_command(cmd).await,
            FieldInfo(cmd) => self.field_info(cmd.get_field_status(), cmd.get_power_level()).await,
            NfcAPollResponse(cmd) => self.nfca_poll_response(cmd).await,
            // [NCI] 5.2.2 State RFST_DISCOVERY
            // If discovered by a Remote NFC Endpoint in Listen mode, once the
            // Remote NFC Endpoint has established any underlying protocol(s) needed
            // by the configured RF Interface, the NFCC SHALL send
            // RF_INTF_ACTIVATED_NTF (Listen Mode) to the DH and the state is
            // changed to RFST_LISTEN_ACTIVE.
            T4ATSelectCommand(cmd) => self.t4at_select_command(cmd).await,
            T4ATSelectResponse(cmd) => self.t4at_select_response(cmd).await,
            SelectCommand(_) => unimplemented!(),
            DeactivateNotification(cmd) => self.deactivate_notification(cmd).await,
            Data(cmd) => self.data_packet(cmd).await,
            _ => unimplemented!(),
        }
    }

    /// Activity for activating an RF interface for a discovered device.
    ///
    /// The method send a notification when the interface is successfully
    /// activated, or when the device activation fails.
    ///
    ///  * `rf_discovery_id` - index of the discovered device
    ///  * `rf_interface` - interface to activate
    ///
    /// The RF state is changed to WaitForSelectResponse when
    /// the select command is successfully sent.
    async fn activate_poll_interface(
        &mut self,
        rf_discovery_id: usize,
        rf_protocol: nci::RfProtocolType,
        rf_interface: nci::RfInterfaceType,
    ) -> Result<()> {
        info!("[{}] activate_poll_interface({:?})", self.id, rf_interface);

        let rf_technology = self.state.rf_poll_responses[rf_discovery_id].rf_technology;
        match (rf_protocol, rf_technology) {
            (nci::RfProtocolType::T2t, rf::Technology::NfcA) => {
                self.send_rf(rf::SelectCommandBuilder {
                    sender: self.id,
                    receiver: self.state.rf_poll_responses[rf_discovery_id].id,
                    technology: rf::Technology::NfcA,
                    power_level: 255,
                    protocol: rf::Protocol::T2t,
                })
                .await?
            }
            (nci::RfProtocolType::IsoDep, rf::Technology::NfcA) => {
                self.send_rf(rf::T4ATSelectCommandBuilder {
                    sender: self.id,
                    receiver: self.state.rf_poll_responses[rf_discovery_id].id,
                    power_level: 255,
                    // [DIGITAL] 14.6.1.6 The FSD supported by the
                    // Reader/Writer SHALL be FSD T4AT,MIN
                    // (set to 256 in Appendix B.6).
                    param: 0x80,
                })
                .await?
            }
            (nci::RfProtocolType::NfcDep, rf::Technology::NfcA) => {
                self.send_rf(rf::NfcDepSelectCommandBuilder {
                    sender: self.id,
                    receiver: self.state.rf_poll_responses[rf_discovery_id].id,
                    power_level: 255,
                    technology: rf::Technology::NfcA,
                    lr: 0,
                })
                .await?
            }
            _ => todo!(),
        }

        self.state.rf_state = RfState::WaitForSelectResponse {
            id: self.state.rf_poll_responses[rf_discovery_id].id,
            rf_discovery_id,
            rf_interface,
            rf_protocol: rf_protocol.into(),
            rf_technology,
        };
        Ok(())
    }

    async fn run_until<O>(&mut self, future: impl Future<Output = O>) -> Result<O> {
        let mut future = pin!(future);
        loop {
            tokio::select! {
                packet = self.nci_stream.next() => {
                    let packet = packet.ok_or(anyhow::anyhow!("nci channel closed"))??;
                    let header = nci::PacketHeader::parse(&packet[0..3])?;
                    match header.get_mt() {
                        nci::MessageType::Data => {
                            self.receive_data(nci::DataPacket::parse(&packet)?).await?
                        }
                        nci::MessageType::Command => {
                            self.receive_command(nci::ControlPacket::parse(&packet)?).await?
                        }
                        mt => {
                            return Err(anyhow::anyhow!(
                                "unexpected message type {:?} in received NCI packet",
                                mt
                            ))
                        }
                    }
                },
                rf_packet = self.rf_rx.recv() => {
                    self.receive_rf(
                        rf_packet.ok_or(anyhow::anyhow!("rf_rx channel closed"))?,
                    )
                    .await?
                },
                output = &mut future => break Ok(output)
            }
        }
    }

    /// Timer handler method. This function is invoked at regular interval
    /// on the NFCC instance and is used to drive internal timers.
    async fn tick(&mut self) -> Result<()> {
        if self.state.rf_state != RfState::Discovery {
            return Ok(());
        }

        //info!("[{}] poll", self.id);

        // [NCI] 5.2.2 State RFST_DISCOVERY
        //
        // In this state the NFCC stays in Poll Mode and/or Listen Mode (based
        // on the discovery configuration) until at least one Remote NFC
        // Endpoint is detected or the RF Discovery Process is stopped by
        // the DH.
        //
        // The following implements the Poll Mode Discovery, Listen Mode
        // Discover is implicitly implemented in response to poll and
        // select commands.

        // RF Discovery is ongoing and no peer device has been discovered
        // so far. Send a RF poll command for all enabled technologies.
        self.state.rf_poll_responses.clear();
        for configuration in self.state.discover_configuration.iter() {
            self.send_rf(rf::PollCommandBuilder {
                sender: self.id,
                receiver: u16::MAX,
                protocol: rf::Protocol::Undetermined,
                technology: match configuration.technology_and_mode {
                    nci::RfTechnologyAndMode::NfcAPassivePollMode => rf::Technology::NfcA,
                    nci::RfTechnologyAndMode::NfcBPassivePollMode => rf::Technology::NfcB,
                    nci::RfTechnologyAndMode::NfcFPassivePollMode => rf::Technology::NfcF,
                    nci::RfTechnologyAndMode::NfcVPassivePollMode => rf::Technology::NfcV,
                    _ => continue,
                },
                power_level: 255,
                payload: Some(bytes::Bytes::new()),
            })
            .await?
        }

        // Wait for poll responses to return.
        self.run_until(time::sleep(Duration::from_millis(POLL_RESPONSE_TIMEOUT))).await?;

        // Check if device was activated in Listen mode during
        // the poll interval, or if the discovery got cancelled.
        if self.state.rf_state != RfState::Discovery || self.state.rf_poll_responses.is_empty() {
            return Ok(());
        }

        // While polling, if the NFCC discovers just one Remote NFC Endpoint
        // that supports just one protocol, the NFCC SHALL try to automatically
        // activate it. The NFCC SHALL first establish any underlying
        // protocol(s) with the Remote NFC Endpoint that are needed by the
        // configured RF Interface. On completion, the NFCC SHALL activate the
        // RF Interface and send RF_INTF_ACTIVATED_NTF (Poll Mode) to the DH.
        // At this point, the state is changed to RFST_POLL_ACTIVE. If the
        // protocol activation is not successful, the NFCC SHALL send
        // CORE_GENERIC_ERROR_NTF to the DH with status
        // DISCOVERY_TARGET_ACTIVATION_FAILED and SHALL stay in the
        // RFST_DISCOVERY state.
        if self.state.rf_poll_responses.len() == 1 {
            let rf_protocol = self.state.rf_poll_responses[0].rf_protocol.into();
            let rf_interface = self.state.select_interface(RfMode::Poll, rf_protocol);
            return self.activate_poll_interface(0, rf_protocol, rf_interface).await;
        }

        debug!("[{}] received {} poll response(s)", self.id, self.state.rf_poll_responses.len());

        // While polling, if the NFCC discovers more than one Remote NFC
        // Endpoint, or a Remote NFC Endpoint that supports more than one RF
        // Protocol, it SHALL start sending RF_DISCOVER_NTF messages to the DH.
        // At this point, the state is changed to RFST_W4_ALL_DISCOVERIES.
        self.state.rf_state = RfState::WaitForHostSelect;
        let last_index = self.state.rf_poll_responses.len() - 1;
        for (index, response) in self.state.rf_poll_responses.clone().iter().enumerate() {
            self.send_control(nci::RfDiscoverNotificationBuilder {
                rf_discovery_id: nci::RfDiscoveryId::from_index(index),
                rf_protocol: response.rf_protocol.into(),
                rf_technology_and_mode: match response.rf_technology {
                    rf::Technology::NfcA => nci::RfTechnologyAndMode::NfcAPassivePollMode,
                    rf::Technology::NfcB => nci::RfTechnologyAndMode::NfcBPassivePollMode,
                    _ => todo!(),
                },
                rf_technology_specific_parameters: response
                    .rf_technology_specific_parameters
                    .clone(),
                notification_type: if index == last_index {
                    nci::DiscoverNotificationType::LastNotification
                } else {
                    nci::DiscoverNotificationType::MoreNotifications
                },
            })
            .await?
        }

        Ok(())
    }

    /// Main NFCC instance routine.
    pub async fn run(
        id: u16,
        nci_stream: nci::StreamRefMut<'a>,
        nci_writer: nci::Writer,
        rf_rx: mpsc::UnboundedReceiver<rf::RfPacket>,
        rf_tx: mpsc::UnboundedSender<rf::RfPacket>,
    ) -> Result<()> {
        // Local controller state.
        let mut nfcc = Controller::new(id, nci_stream, nci_writer, rf_rx, rf_tx);

        // Timer for tick events.
        let mut timer = time::interval(Duration::from_millis(1000));

        loop {
            nfcc.run_until(timer.tick()).await?;
            nfcc.tick().await?;
        }
    }
}