Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 14 additions & 6 deletions arch/arm64/boot/dts/apple/t8103-j313.dts
Original file line number Diff line number Diff line change
Expand Up @@ -95,12 +95,18 @@
};

/*
* Mesa fingerprint sensor on SPI2. The power line (pin 108, active high) comes
* from the J313 platform device tree, which also lists an interrupt on pin 104. The
* interrupt is left out on purpose: the driver polls, and the trigger flags in
* the ADT (3) are not decoded with any certainty here. Pin 104 reads back as a
* plain input with a pull-down, which rules out the two active-low readings of
* that value but does not decide between the remaining ones.
* Mesa fingerprint sensor on SPI2. Power is pin 108, active high, from the
* J313 platform device tree. That tree also lists an interrupt on pin 104
* with trigger flags 3. Linux IRQ_TYPE_EDGE_BOTH is the value 3, and
* both-edges re-fires when the line falls and spins the capture loop. Apple
* GPIO mode 3 is level-low. The pin register saved on 2026-10-21 reads
* mode 0, pull-down, input enabled: iBoot left a plain input and programmed
* no trigger. Data-ready is the rising edge. The driver requests
* IRQF_TRIGGER_RISING, and J314s, J316s and J414 describe this line as
* IRQ_TYPE_EDGE_RISING. t8103.dtsi already includes irq.h.
*
* spi2 names the AIC as its interrupt parent. This node names pinctrl_ap,
* whose interrupt cells are <pin type>, so pin 104 is a GPIO interrupt.
*
* Do not add cs-gpios. The sensor needs the controller's native chip select,
* otherwise the SPI core skips the hardware CS timing.
Expand All @@ -112,6 +118,8 @@
&mesa {
status = "okay";
enable-gpios = <&pinctrl_ap 108 GPIO_ACTIVE_HIGH>;
interrupt-parent = <&pinctrl_ap>;
interrupts = <104 IRQ_TYPE_EDGE_RISING>;
spi-cs-setup-delay-ns = <20>;
spi-cs-hold-delay-ns = <20>;
/*
Expand Down
59 changes: 59 additions & 0 deletions drivers/soc/apple/registration.rs
Original file line number Diff line number Diff line change
Expand Up @@ -60,6 +60,37 @@ pub(crate) fn patch_loaded(nonce_session: bool, accepted: bool, needs_patch: boo
accepted && !(nonce_session && needs_patch)
}

/// Whether a completed registration can be left in place.
///
/// Stricter than [`patch_loaded`] on a 13.5 profile: state 9 forces a reload
/// even when the acknowledgement still reads accepted, because a power cycle
/// is what clears a stuck NEEDS_PATCH. `left_powered` is this driver's record
/// that it has not switched the sensor off since that registration.
pub(crate) fn registration_still_held(
established: bool,
left_powered: bool,
silent: bool,
accepted: bool,
needs_patch: bool,
) -> bool {
established && left_powered && !silent && accepted && !needs_patch
}

/// Whether calibration dropped the patch, so a profile without a nonce
/// session has to power-cycle and register again. A nonce-session profile
/// never takes that second wake: its parameter path does not.
pub(crate) fn needs_reload_after_calibration(
nonce_session: bool,
silent: bool,
accepted: bool,
needs_patch: bool,
) -> bool {
if nonce_session {
return false;
}
!registration_still_held(true, true, silent, accepted, needs_patch)
}

/// The bring-up stage retry `retry` (counted from 1) starts from.
///
/// The stage an attempt left stands: once the serial is registered, [`plan`]
Expand Down Expand Up @@ -365,6 +396,34 @@ mod tests {
);
}

#[test]
fn a_held_registration_needs_every_condition() {
assert!(registration_still_held(true, true, false, true, false));
assert!(!registration_still_held(false, true, false, true, false));
assert!(!registration_still_held(true, false, false, true, false));
assert!(!registration_still_held(true, true, true, true, false));
assert!(!registration_still_held(true, true, false, false, false));
assert!(!registration_still_held(true, true, false, true, true));
}

#[test]
fn calibration_skips_the_second_wake_while_the_patch_remains() {
assert!(!needs_reload_after_calibration(false, false, true, false));
}

#[test]
fn calibration_reloads_when_the_patch_is_gone() {
assert!(needs_reload_after_calibration(false, false, true, true));
assert!(needs_reload_after_calibration(false, true, true, false));
assert!(needs_reload_after_calibration(false, false, false, false));
}

#[test]
fn a_nonce_session_never_takes_the_post_calibration_wake() {
assert!(!needs_reload_after_calibration(true, true, false, true));
assert!(!needs_reload_after_calibration(true, false, true, false));
}

/// The enclave's sensor registration, as the boots on record show it.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Enclave {
Expand Down
130 changes: 105 additions & 25 deletions drivers/soc/apple/sbio.rs
Original file line number Diff line number Diff line change
Expand Up @@ -1107,8 +1107,9 @@ impl SepData {
registration::bring_up(retry, &mut attempts)
}

/// One attach-time bring-up. A profile without a nonce session only
/// wakes and patches the sensor here; its first verify calibrates it.
/// One attach-time bring-up. A profile without a nonce session wakes and
/// patches the sensor here, and configures the data-ready line once that
/// patch is in place. Its first verify calibrates it.
fn attach_bring_sensor_online(&self) -> bool {
if self.profile.nonce_session {
return self.bring_sensor_online();
Expand All @@ -1125,6 +1126,9 @@ impl SepData {
}
let online = self.complete_bringup(patch);
diag::sensor_brought_up(bind, online);
if online {
self.configure_data_ready();
}
online
}

Expand Down Expand Up @@ -1281,9 +1285,63 @@ impl SepData {
self.late_attach_wanted.xchg(false, Relaxed)
}

/// Configures the data-ready line once. The sensor is patched and idle
/// here: reconfiguring the line mid-capture drops the firmware patch, so
/// a later call returns once the line is available. A board that does not
/// describe the line falls back to SPI polling.
fn configure_data_ready(&self) {
if sensor::irq_available() {
return;
}
if sensor::irq_setup() {
dev_info!(self.dev, "sensor: interrupt-driven capture\n");
} else {
dev_warn!(
self.dev,
"sensor: no data-ready interrupt (describe it in DT); capture falls back to SPI polling\n"
);
}
}

/// Whether a 13.5 registration still holds a patched sensor this driver
/// left powered, so the next bring-up can skip the power cycle. A
/// nonce-session profile, a sensor this driver switched off, and a
/// registration that never completed return false without an SPI read.
/// State 9 forces a reload even when the acknowledgement is still accepted.
fn sensor_patch_held(&self) -> bool {
if self.profile.nonce_session
|| !sensor::left_powered()
|| self.bringup.load(Relaxed) < BRINGUP_ESTABLISHED
{
return false;
}
let Ok(st) = sensor::status() else {
return false;
};
registration::registration_still_held(
true,
true,
st.is_silent(),
st.patch_ack() == sensor::PATCH_ACCEPTED,
st.state == sensor::STATE_NEEDS_PATCH,
)
}

fn bring_sensor_online(&self) -> bool {
let bind = diag::sensor_bind();
let Some(mut patch) = self.wake_sensor() else {
let patch_held = self.sensor_patch_held();
if patch_held {
dev_info!(
self.dev,
"sensor: patch still acknowledged; keeping the registration\n"
);
}
let patch_now = if patch_held {
Some(PatchLoaded(()))
} else {
self.wake_sensor()
};
let Some(mut patch) = patch_now else {
diag::sensor_brought_up(bind, false);
return false;
};
Expand All @@ -1306,11 +1364,43 @@ impl SepData {
}
self.sensor_calibrated.store(true, Relaxed);
if parameters.is_none() {
let Some(reloaded_patch) = self.wake_sensor() else {
diag::sensor_brought_up(bind, false);
return false;
let reload = match sensor::status() {
Err(error) => {
dev_warn!(
self.dev,
"sensor: status read after calibration failed ({:?}); registering again\n",
error
);
true
}
Ok(st) => {
let again = registration::needs_reload_after_calibration(
self.profile.nonce_session,
st.is_silent(),
st.patch_ack() == sensor::PATCH_ACCEPTED,
st.state == sensor::STATE_NEEDS_PATCH,
);
if again {
dev_info!(
self.dev,
"sensor: status after calibration requires a new registration\n"
);
} else {
dev_info!(
self.dev,
"sensor: calibration left the patch in place; not registering again\n"
);
}
again
}
};
patch = reloaded_patch;
if reload {
let Some(reloaded_patch) = self.wake_sensor() else {
diag::sensor_brought_up(bind, false);
return false;
};
patch = reloaded_patch;
}
}
}

Expand All @@ -1323,19 +1413,8 @@ impl SepData {
None => self.complete_bringup(patch),
};
diag::sensor_brought_up(bind, ok);
// The sensor is patched and idle here -- the only safe moment to
// configure the data-ready interrupt, which is then left alone for the
// driver's life. Interrupt capture is the default; a machine that does
// not describe a data-ready line falls back to SPI polling.
if ok && !sensor::irq_available() {
if sensor::irq_setup() {
dev_info!(self.dev, "sensor: interrupt-driven capture\n");
} else {
dev_warn!(
self.dev,
"sensor: no data-ready interrupt (describe it in DT); capture falls back to SPI polling\n"
);
}
if ok {
self.configure_data_ready();
}
ok
}
Expand Down Expand Up @@ -1562,11 +1641,12 @@ impl SepData {
&& bio::verify_is_live(&self.bio_session.lock(), self.capture_epoch.load(Relaxed))
}

// Every verify registers the sensor again. On a profile with a nonce
// session that registration can fail as the attach-time one does, most
// often the first one after a system suspend, and a new attempt recovers
// it in the same way. Without one, the failure ends the user's
// authentication even though the sensor works.
// A nonce-session verify registers again. That registration can fail the
// way the attach-time one does, most often the first one after suspend,
// and a new attempt recovers it. Without a nonce session a failed
// bring-up ends the authentication. A 13.5 verify keeps a registration
// whose patch is still acknowledged, and power-cycles when this driver
// has switched the sensor off or the status no longer shows the patch.
fn bring_sensor_online_for_verify(&self) -> bool {
if !self.profile.nonce_session {
return self.bring_sensor_online();
Expand Down
21 changes: 19 additions & 2 deletions drivers/soc/apple/sensor.rs
Original file line number Diff line number Diff line change
Expand Up @@ -214,9 +214,16 @@ pub(crate) fn power_line() -> Option<i32> {
}
}

/// True after this driver switched the sensor on, and not since switched it
/// off. A failed power cycle stores false: a half-finished cycle is not a
/// sensor a status read may trust.
static LEFT_POWERED: Atomic<bool> = Atomic::new(false);

pub(crate) fn power_cycle() -> bool {
// SAFETY: the shim holds the descriptor and applies its delays.
unsafe { sep_sensor_power_cycle() == 0 }
let ok = unsafe { sep_sensor_power_cycle() == 0 };
LEFT_POWERED.store(ok, Relaxed);
ok
}

pub(crate) fn cs_timing() -> CsTiming {
Expand All @@ -231,7 +238,17 @@ pub(crate) fn power_source() -> PowerSource {

pub(crate) fn power(on: bool) -> bool {
// SAFETY: the shim holds the descriptor and applies its delays.
unsafe { sep_sensor_power(if on { 1 } else { 0 }) == 0 }
let ok = unsafe { sep_sensor_power(if on { 1 } else { 0 }) == 0 };
if ok {
LEFT_POWERED.store(on, Relaxed);
}
ok
}

/// Whether this driver left the sensor powered. Callers use it so they do not
/// issue an SPI status read to a sensor they have themselves switched off.
pub(crate) fn left_powered() -> bool {
LEFT_POWERED.load(Relaxed)
}

/// Sets up the data-ready interrupt once, while the sensor is idle. Returns
Expand Down