Skip to content
Open
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
140 changes: 139 additions & 1 deletion drivers/iio/common/aop_sensors/aop_als.rs
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,9 @@ use kernel::{
bindings, c_str,
device::Core,
firmware::Firmware,
iio::common::aop_sensors::{AopSensorData, IIORegistration, MessageProcessor, MICRO},
iio::common::aop_sensors::{
AopSensorData, ChannelSpec, IIORegistration, MessageProcessor, MICRO,
},
module_platform_driver, of, platform,
prelude::*,
soc::apple::aop::{EPICService, FakehidRegistration, AOP},
Expand Down Expand Up @@ -172,6 +174,72 @@ fn f32_to_micro(f: u32) -> Option<u64> {
})
}

// FireFish2 / CT720 report, 55 bytes, lux float at +0x1d. The four counts are
// red, green, blue, clear. Clear is the wideband count (largest in room light;
// the calibration gains are 8, 8, 8, 4). Under the ~5460 K light captured on
// a J313 the first three ranked green, red, blue. Byte +0x2a is non-zero
// when the color temperature at +0x2b is valid. The integration time is stored
// twice at +0x2f (the AOP logs 197380 µs when it arms this sensor); disagreeing
// copies mean this is not that layout, and color is left unpublished.
const CT720_LEN: usize = 55;
const CT720_COUNT_OFF: [usize; 4] = [0x0d, 0x11, 0x15, 0x19];
const CT720_CCT_FLAG: usize = 0x2a;
const CT720_CCT_OFF: usize = 0x2b;
const CT720_INTEG_OFF: usize = 0x2f;
const CT720_INTEG_MAX: u32 = 10_000_000;
/// Clear counts at or below 11 on a covered J313 still had the firmware CCT
/// byte set, and the published temperatures were 788 K, 1288 K, 2904 K and
/// 6781 K. Publish CCT only when clear is at least this. Not hardware-tested.
const CT720_CCT_MIN_CLEAR: u32 = 12;

/// Channels of a CT720. Channel 0 is the lux channel every part has.
const CT720_RED: usize = 1;
const CT720_CLEAR: usize = 4;
const CT720_CCT: usize = 5;
const CT720_CHANS: usize = 6;

fn u32_at(message: &[u8], off: usize) -> Option<u32> {
let b = message.get(off..off + 4)?;
Some(u32::from_le_bytes([b[0], b[1], b[2], b[3]]))
}

/// Whether a CT720 report has the layout the color fields are read from.
fn ct720_layout(message: &[u8]) -> bool {
if message.len() < CT720_LEN {
return false;
}
match (
u32_at(message, CT720_INTEG_OFF),
u32_at(message, CT720_INTEG_OFF + 4),
) {
(Some(integ), Some(again)) => integ != 0 && integ == again && integ <= CT720_INTEG_MAX,
_ => false,
}
}

/// A color channel of a CT720 report: a count in whole units, or the color temperature.
fn ct720_color(message: &[u8], channel: usize) -> Option<u64> {
if !ct720_layout(message) {
return None;
}
if (CT720_RED..=CT720_CLEAR).contains(&channel) {
let count = u32_at(message, CT720_COUNT_OFF[channel - CT720_RED])?;
return Some(u64::from(count).saturating_mul(MICRO));
}
if channel != CT720_CCT || message.get(CT720_CCT_FLAG).copied() == Some(0) {
return None;
}
if u32_at(message, CT720_COUNT_OFF[CT720_CLEAR - CT720_RED])? < CT720_CCT_MIN_CLEAR {
return None;
}
let bits = u32_at(message, CT720_CCT_OFF)?;
if bits & 0x8000_0000 != 0 {
return None;
}
// Zero does not describe a colour temperature.
f32_to_micro(bits).filter(|value| *value != 0)
}

struct MsgProc(usize);

fn report_float(message: &[u8], offset: usize) -> Option<u64> {
Expand All @@ -191,9 +259,18 @@ impl MessageProcessor for MsgProc {
// Zero and negative CCT do not describe a colour temperature.
report_float(message, CCT_OFFSET_VD6286).filter(|value| *value != 0)
}
_ if self.0 == LUX_OFFSET_CT720 => ct720_color(message, channel),
_ => None,
}
}

/// A CT720 report that carries lux but not a color channel (another layout, no valid
/// color temperature, too little light for one) withdraws that channel's last reading:
/// it reads `ENODATA` rather than a stale color. A report with no lux reading leaves
/// every channel as it was.
fn channel_withdrawn(&self, message: &[u8], channel: usize) -> bool {
self.0 == LUX_OFFSET_CT720 && channel != 0 && self.process(message).is_some()
}
}

enum AlsIio {
Expand All @@ -203,6 +280,59 @@ enum AlsIio {
Color {
_registration: IIORegistration<MsgProc, 2>,
},
Ct720 {
_registration: IIORegistration<MsgProc, CT720_CHANS>,
},
}

/// Lux and color temperature are processed values; the four counts are raw.
fn ct720_channels() -> [ChannelSpec; CT720_CHANS] {
let raw = 1 << bindings::BINDINGS_IIO_CHAN_INFO_RAW;
let processed = 1 << bindings::BINDINGS_IIO_CHAN_INFO_PROCESSED;
let count = |modifier| ChannelSpec {
ty: bindings::BINDINGS_IIO_INTENSITY,
modifier: Some(modifier),
info_mask: raw,
};
[
ChannelSpec {
ty: bindings::BINDINGS_IIO_LIGHT,
modifier: None,
info_mask: processed,
},
count(bindings::BINDINGS_IIO_MOD_LIGHT_RED),
count(bindings::BINDINGS_IIO_MOD_LIGHT_GREEN),
count(bindings::BINDINGS_IIO_MOD_LIGHT_BLUE),
count(bindings::BINDINGS_IIO_MOD_LIGHT_CLEAR),
ChannelSpec {
ty: bindings::BINDINGS_IIO_COLORTEMP,
modifier: None,
info_mask: processed,
},
]
}

fn register_ct720(
pdev: &platform::Device,
aop: &Arc<dyn AOP>,
service: EPICService,
offset: usize,
) -> Result<(FakehidRegistration, IIORegistration<MsgProc, CT720_CHANS>)> {
let channels = ct720_channels();
let data = AopSensorData::new_channels(
pdev.as_ref().into(),
channels.map(|channel| channel.ty),
MsgProc(offset),
)?;
let listener = FakehidRegistration::new(aop.clone(), service, data.clone())?;
enable_als(aop.as_ref(), pdev, &service, offset)?;
let iio = IIORegistration::new_specs(
data,
c"aop-sensors-als",
channels,
kernel::module::this_module::<crate::LocalModule>(),
)?;
Ok((listener, iio))
}

struct IIOAopAlsDriver {
Expand Down Expand Up @@ -276,6 +406,14 @@ impl platform::Driver for IIOAopAlsDriver {
_registration: registration,
},
)
} else if offset == LUX_OFFSET_CT720 {
let (listener, registration) = register_ct720(pdev, &adata, service, offset)?;
(
listener,
AlsIio::Ct720 {
_registration: registration,
},
)
} else {
let (listener, registration) = register_channels(pdev, &adata, service, offset, [ty])?;
(
Expand Down
5 changes: 5 additions & 0 deletions rust/bindings/bindings_helper.h
Original file line number Diff line number Diff line change
Expand Up @@ -178,6 +178,11 @@ const u32 BINDINGS_IIO_CHAN_INFO_SCALE = IIO_CHAN_INFO_SCALE;
const u32 BINDINGS_IIO_ANGL = IIO_ANGL;
const u32 BINDINGS_IIO_LIGHT = IIO_LIGHT;
const u32 BINDINGS_IIO_COLORTEMP = IIO_COLORTEMP;
const u32 BINDINGS_IIO_INTENSITY = IIO_INTENSITY;
const u32 BINDINGS_IIO_MOD_LIGHT_RED = IIO_MOD_LIGHT_RED;
const u32 BINDINGS_IIO_MOD_LIGHT_GREEN = IIO_MOD_LIGHT_GREEN;
const u32 BINDINGS_IIO_MOD_LIGHT_BLUE = IIO_MOD_LIGHT_BLUE;
const u32 BINDINGS_IIO_MOD_LIGHT_CLEAR = IIO_MOD_LIGHT_CLEAR;
const u32 BINDINGS_IIO_ACCEL = IIO_ACCEL;
const u32 BINDINGS_IIO_ANGL_VEL = IIO_ANGL_VEL;
const u32 BINDINGS_IIO_ROT = IIO_ROT;
Expand Down
74 changes: 60 additions & 14 deletions rust/kernel/iio/common/aop_sensors.rs
Original file line number Diff line number Diff line change
Expand Up @@ -57,6 +57,25 @@ pub trait MessageProcessor: Send + Sync {
None
}
}

/// Whether `message` says that `channel` has no reading any more, so that the reading it
/// last had must stop being reported: reads return `ENODATA` until the next one arrives.
/// It is asked only when [`Self::process_channel`] returned `None` for the same message.
fn channel_withdrawn(&self, _message: &[u8], _channel: usize) -> bool {
false
}
}

/// One IIO channel of a sensor: its type, an optional modifier (`IIO_MOD_*`) and the
/// `info_mask_separate` bits it answers.
#[derive(Clone, Copy)]
pub struct ChannelSpec {
/// The `IIO_*` channel type.
pub ty: u32,
/// The `IIO_MOD_*` modifier of a modified channel.
pub modifier: Option<u32>,
/// The `IIO_CHAN_INFO_*` bits of the channel.
pub info_mask: usize,
}

/// The state shared between a sensor's report listener and its IIO device: the latest reading.
Expand Down Expand Up @@ -104,6 +123,8 @@ impl<T: MessageProcessor, const N: usize> FakehidListener for AopSensorData<T, N
self.value[channel].store(value.min(MAX_MICRO), Relaxed);
// Publishes the reading above to readers that see `valid`.
self.valid[channel].store(true, Release);
} else if self.msg_proc.channel_withdrawn(data, channel) {
self.valid[channel].store(false, Release);
}
}
Ok(())
Expand Down Expand Up @@ -199,26 +220,51 @@ impl<T: MessageProcessor + 'static, const N: usize> IIORegistration<T, N> {
info_mask: usize,
module: &ThisModule,
) -> Result<Self> {
if ty != data.ty {
Self::new_specs(
data,
name,
ty.map(|ty| ChannelSpec {
ty,
modifier: None,
info_mask,
}),
module,
)
}

/// Registers the sensor's channels, each with its own modifier and info mask. The types
/// must match those of `data`.
pub fn new_specs(
data: Arc<AopSensorData<T, N>>,
name: &'static CStr,
channels: [ChannelSpec; N],
module: &ThisModule,
) -> Result<Self> {
if channels.map(|channel| channel.ty) != data.ty {
return Err(EINVAL);
}
let spec = KBox::pin(
IIOSpec {
spec: core::array::from_fn(|channel| bindings::iio_chan_spec {
type_: ty[channel],
address: channel as _,
__bindgen_anon_1: bindings::iio_chan_spec__bindgen_ty_1 {
scan_type: bindings::iio_scan_type {
__bindgen_anon_1: bindings::iio_scan_type__bindgen_ty_1 {
format: b'u' as _,
spec: core::array::from_fn(|channel| {
let mut spec = bindings::iio_chan_spec {
type_: channels[channel].ty,
channel2: channels[channel].modifier.unwrap_or(0) as _,
address: channel as _,
__bindgen_anon_1: bindings::iio_chan_spec__bindgen_ty_1 {
scan_type: bindings::iio_scan_type {
__bindgen_anon_1: bindings::iio_scan_type__bindgen_ty_1 {
format: b'u' as _,
},
realbits: 32,
storagebits: 32,
..Default::default()
},
realbits: 32,
storagebits: 32,
..Default::default()
},
},
info_mask_separate: info_mask,
..Default::default()
info_mask_separate: channels[channel].info_mask,
..Default::default()
};
spec.set_modified(channels[channel].modifier.is_some() as _);
spec
}),
vtable: bindings::iio_info {
read_raw: Some(aop_read_raw::<T, N>),
Expand Down
58 changes: 58 additions & 0 deletions tools/asahi/aop-als-channel-tests.py
Original file line number Diff line number Diff line change
Expand Up @@ -119,6 +119,58 @@ def source():
assert_eq!(f32_to_micro((-0.25f32).to_bits()),Some(0));
assert_eq!(f32_to_micro(1u32),Some(0));
}
fn ct720(counts:[u32;4],flag:u8,cct:f32,integ:(u32,u32),lux:f32)->[u8;55] {
let mut report=[0u8;55];
for (i,count) in counts.iter().enumerate() { report[0x0d+4*i..0x11+4*i].copy_from_slice(&count.to_le_bytes()); }
put(&mut report,0x1d,lux); report[0x2a]=flag; put(&mut report,0x2b,cct);
report[0x2f..0x33].copy_from_slice(&integ.0.to_le_bytes()); report[0x33..0x37].copy_from_slice(&integ.1.to_le_bytes());
report
}
#[test] fn ct720_color_channels() {
const T:[u32;6]=[5,9,9,9,9,6];
let data=AopSensorData::new_channels(std::sync::Arc::new(device::Device),T,MsgProc(LUX_OFFSET_CT720)).unwrap();
let all=|data:&AopSensorData<MsgProc,6>| -> Vec<(i32,i32,i32)> { (0..6).map(|c| read(data,c as u64,T[c])).collect() };
for channel in 0..6 { assert_eq!(read(&data,channel as u64,T[channel]).0,-61); }
// Red, green, blue, clear in report order; lux and the color temperature as floats.
data.process_fakehid_report(&ct720([100,200,300,400],1,5460.5,(197380,197380),12.5)).unwrap();
assert_eq!(all(&data),[(2,12,500000),(2,100,0),(2,200,0),(2,300,0),(2,400,0),(2,5460,500000)]);
// Too little light for a color temperature: the counts stay, the temperature reads ENODATA.
data.process_fakehid_report(&ct720([1,2,3,11],1,788.0,(197380,197380),0.5)).unwrap();
assert_eq!(all(&data),[(2,0,500000),(2,1,0),(2,2,0),(2,3,0),(2,11,0),(-61,-1,-1)]);
data.process_fakehid_report(&ct720([1,2,3,12],1,2904.0,(197380,197380),0.5)).unwrap();
assert_eq!(read(&data,5,6),(2,2904,0));
// The firmware's validity byte, and a zero, negative or non-finite temperature.
for (flag,cct) in [(0,5000.0),(1,0.0),(1,-5000.0),(1,f32::NAN),(1,f32::INFINITY)] {
data.process_fakehid_report(&ct720([10,20,30,40],1,4000.0,(197380,197380),1.0)).unwrap();
assert_eq!(read(&data,5,6),(2,4000,0));
data.process_fakehid_report(&ct720([10,20,30,40],flag,cct,(197380,197380),1.0)).unwrap();
assert_eq!(read(&data,5,6).0,-61); assert_eq!(read(&data,4,9),(2,40,0));
}
// Not the layout the color fields are read from: lux advances, the color sample is withdrawn.
for integ in [(197380,197381),(0,0),(10_000_001,10_000_001)] {
data.process_fakehid_report(&ct720([10,20,30,40],1,4000.0,(197380,197380),1.0)).unwrap();
data.process_fakehid_report(&ct720([70,80,90,95],1,6000.0,integ,2.0)).unwrap();
assert_eq!(all(&data),[(2,2,0),(-61,-1,-1),(-61,-1,-1),(-61,-1,-1),(-61,-1,-1),(-61,-1,-1)]);
}
data.process_fakehid_report(&ct720([10,20,30,40],1,4000.0,(10_000_000,10_000_000),1.0)).unwrap();
assert_eq!(read(&data,1,9),(2,10,0));
// A short report still carries lux.
data.process_fakehid_report(&ct720([70,80,90,95],1,6000.0,(197380,197380),3.0)[..54]).unwrap();
assert_eq!(read(&data,0,5),(2,3,0)); assert_eq!(read(&data,1,9).0,-61);
// A report with no lux reading leaves every channel as it was.
data.process_fakehid_report(&ct720([10,20,30,40],1,4000.0,(197380,197380),1.0)).unwrap();
let before=all(&data);
data.process_fakehid_report(&ct720([70,80,90,95],0,6000.0,(1,2),f32::NAN)).unwrap();
assert_eq!(all(&data),before);
// A count of u32::MAX saturates the stored reading without touching its neighbours.
data.process_fakehid_report(&ct720([u32::MAX,20,30,40],1,4000.0,(197380,197380),1.0)).unwrap();
assert_eq!(read(&data,1,9),(2,i32::MAX,999999)); assert_eq!(read(&data,2,9),(2,20,0));
// The other parts keep their channels: no CT720 field is read at another lux offset.
let report=ct720([100,200,300,400],1,5460.5,(197380,197380),12.5);
for offset in [LUX_OFFSET_VD6286,LUX_OFFSET_CT817] {
for channel in 1..6 { assert_eq!(MsgProc(offset).process_channel(&report,channel),None); assert!(!MsgProc(offset).channel_withdrawn(&report,channel)); }
}
}
'''


Expand All @@ -130,6 +182,12 @@ def main():
'cct-zero-valid': ('.filter(|value| *value != 0)', ''),
'channel-alias': ('report_float(message, CCT_OFFSET_VD6286)', 'report_float(message, LUX_OFFSET_VD6286)'),
'missing-saturation': ('value.min(MAX_MICRO)', 'value'),
'ct720-clear-gate': ('CT720_CCT_MIN_CLEAR: u32 = 12', 'CT720_CCT_MIN_CLEAR: u32 = 1'),
'ct720-integration-copies': ('integ != 0 && integ == again && ', 'integ != 0 && again != 0 && '),
'ct720-integration-bound': (' && integ <= CT720_INTEG_MAX', ''),
'ct720-count-order': ('[0x0d, 0x11, 0x15, 0x19]', '[0x11, 0x0d, 0x15, 0x19]'),
'ct720-keeps-stale-color': ('self.0 == LUX_OFFSET_CT720 && channel != 0 && self.process(message).is_some()', 'self.0 == LUX_OFFSET_CT720 && channel != 0 && self.process(message).is_none()'),
'ct720-validity-byte': (' || message.get(CT720_CCT_FLAG).copied() == Some(0)', ''),
}
with tempfile.TemporaryDirectory(prefix='aop-als-channels-') as directory:
directory = Path(directory)
Expand Down
Loading