// SPDX-License-Identifier: GPL-2.0-only /* * Driver for Chrome OS EC Sensor hub FIFO. * * Copyright 2020 Google LLC */ #include <linux/delay.h> #include <linux/device.h> #include <linux/iio/iio.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/platform_data/cros_ec_commands.h> #include <linux/platform_data/cros_ec_proto.h> #include <linux/platform_data/cros_ec_sensorhub.h> #include <linux/platform_device.h> #include <linux/sort.h> #include <linux/slab.h> #define CREATE_TRACE_POINTS #include "cros_ec_sensorhub_trace.h" /* Precision of fixed point for the m values from the filter */ #define M_PRECISION … /* Only activate the filter once we have at least this many elements. */ #define TS_HISTORY_THRESHOLD … /* * If we don't have any history entries for this long, empty the filter to * make sure there are no big discontinuities. */ #define TS_HISTORY_BORED_US … /* To measure by how much the filter is overshooting, if it happens. */ #define FUTURE_TS_ANALYTICS_COUNT_MAX … static inline int cros_sensorhub_send_sample(struct cros_ec_sensorhub *sensorhub, struct cros_ec_sensors_ring_sample *sample) { … } /** * cros_ec_sensorhub_register_push_data() - register the callback to the hub. * * @sensorhub : Sensor Hub object * @sensor_num : The sensor the caller is interested in. * @indio_dev : The iio device to use when a sample arrives. * @cb : The callback to call when a sample arrives. * * The callback cb will be used by cros_ec_sensorhub_ring to distribute events * from the EC. * * Return: 0 when callback is registered. * EINVAL is the sensor number is invalid or the slot already used. */ int cros_ec_sensorhub_register_push_data(struct cros_ec_sensorhub *sensorhub, u8 sensor_num, struct iio_dev *indio_dev, cros_ec_sensorhub_push_data_cb_t cb) { … } EXPORT_SYMBOL_GPL(…); void cros_ec_sensorhub_unregister_push_data(struct cros_ec_sensorhub *sensorhub, u8 sensor_num) { … } EXPORT_SYMBOL_GPL(…); /** * cros_ec_sensorhub_ring_fifo_enable() - Enable or disable interrupt generation * for FIFO events. * @sensorhub: Sensor Hub object * @on: true when events are requested. * * To be called before sleeping or when no one is listening. * Return: 0 on success, or an error when we can not communicate with the EC. * */ int cros_ec_sensorhub_ring_fifo_enable(struct cros_ec_sensorhub *sensorhub, bool on) { … } static void cros_ec_sensor_ring_median_swap(s64 *a, s64 *b) { … } /* * cros_ec_sensor_ring_median: Gets median of an array of numbers * * It's implemented using the quickselect algorithm, which achieves an * average time complexity of O(n) the middle element. In the worst case, * the runtime of quickselect could regress to O(n^2). To mitigate this, * algorithms like median-of-medians exist, which can guarantee O(n) even * in the worst case. However, these algorithms come with a higher * overhead and are more complex to implement, making quickselect a * pragmatic choice for our use case. * * Warning: the input array gets modified! */ static s64 cros_ec_sensor_ring_median(s64 *array, size_t length) { … } /* * IRQ Timestamp Filtering * * Lower down in cros_ec_sensor_ring_process_event(), for each sensor event * we have to calculate it's timestamp in the AP timebase. There are 3 time * points: * a - EC timebase, sensor event * b - EC timebase, IRQ * c - AP timebase, IRQ * a' - what we want: sensor even in AP timebase * * While a and b are recorded at accurate times (due to the EC real time * nature); c is pretty untrustworthy, even though it's recorded the * first thing in ec_irq_handler(). There is a very good chance we'll get * added latency due to: * other irqs * ddrfreq * cpuidle * * Normally a' = c - b + a, but if we do that naive math any jitter in c * will get coupled in a', which we don't want. We want a function * a' = cros_ec_sensor_ring_ts_filter(a) which will filter out outliers in c. * * Think of a graph of AP time(b) on the y axis vs EC time(c) on the x axis. * The slope of the line won't be exactly 1, there will be some clock drift * between the 2 chips for various reasons (mechanical stress, temperature, * voltage). We need to extrapolate values for a future x, without trusting * recent y values too much. * * We use a median filter for the slope, then another median filter for the * y-intercept to calculate this function: * dx[n] = x[n-1] - x[n] * dy[n] = x[n-1] - x[n] * m[n] = dy[n] / dx[n] * median_m = median(m[n-k:n]) * error[i] = y[n-i] - median_m * x[n-i] * median_error = median(error[:k]) * predicted_y = median_m * x + median_error * * Implementation differences from above: * - Redefined y to be actually c - b, this gives us a lot more precision * to do the math. (c-b)/b variations are more obvious than c/b variations. * - Since we don't have floating point, any operations involving slope are * done using fixed point math (*M_PRECISION) * - Since x and y grow with time, we keep zeroing the graph (relative to * the last sample), this way math involving *x[n-i] will not overflow * - EC timestamps are kept in us, it improves the slope calculation precision */ /** * cros_ec_sensor_ring_ts_filter_update() - Update filter history. * * @state: Filter information. * @b: IRQ timestamp, EC timebase (us) * @c: IRQ timestamp, AP timebase (ns) * * Given a new IRQ timestamp pair (EC and AP timebases), add it to the filter * history. */ static void cros_ec_sensor_ring_ts_filter_update(struct cros_ec_sensors_ts_filter_state *state, s64 b, s64 c) { … } /** * cros_ec_sensor_ring_ts_filter() - Translate EC timebase timestamp to AP * timebase * * @state: filter information. * @x: any ec timestamp (us): * * cros_ec_sensor_ring_ts_filter(a) => a' event timestamp, AP timebase * cros_ec_sensor_ring_ts_filter(b) => calculated timestamp when the EC IRQ * should have happened on the AP, with low jitter * * Note: The filter will only activate once state->history_len goes * over TS_HISTORY_THRESHOLD. Otherwise it'll just do the naive c - b + a * transform. * * How to derive the formula, starting from: * f(x) = median_m * x + median_error * That's the calculated AP - EC offset (at the x point in time) * Undo the coordinate system transform: * f(x) = median_m * (x - x_offset) + median_error + y_offset * Remember to undo the "y = c - b * 1000" modification: * f(x) = median_m * (x - x_offset) + median_error + y_offset + x * 1000 * * Return: timestamp in AP timebase (ns) */ static s64 cros_ec_sensor_ring_ts_filter(struct cros_ec_sensors_ts_filter_state *state, s64 x) { … } /* * Since a and b were originally 32 bit values from the EC, * they overflow relatively often, casting is not enough, so we need to * add an offset. */ static void cros_ec_sensor_ring_fix_overflow(s64 *ts, const s64 overflow_period, struct cros_ec_sensors_ec_overflow_state *state) { … } static void cros_ec_sensor_ring_check_for_past_timestamp(struct cros_ec_sensorhub *sensorhub, struct cros_ec_sensors_ring_sample *sample) { … } /** * cros_ec_sensor_ring_process_event() - Process one EC FIFO event * * @sensorhub: Sensor Hub object. * @fifo_info: FIFO information from the EC (includes b point, EC timebase). * @fifo_timestamp: EC IRQ, kernel timebase (aka c). * @current_timestamp: calculated event timestamp, kernel timebase (aka a'). * @in: incoming FIFO event from EC (includes a point, EC timebase). * @out: outgoing event to user space (includes a'). * * Process one EC event, add it in the ring if necessary. * * Return: true if out event has been populated. */ static bool cros_ec_sensor_ring_process_event(struct cros_ec_sensorhub *sensorhub, const struct ec_response_motion_sense_fifo_info *fifo_info, const ktime_t fifo_timestamp, ktime_t *current_timestamp, struct ec_response_motion_sensor_data *in, struct cros_ec_sensors_ring_sample *out) { … } /* * cros_ec_sensor_ring_spread_add: Calculate proper timestamps then add to * ringbuffer. * * This is the new spreading code, assumes every sample's timestamp * precedes the sample. Run if tight_timestamps == true. * * Sometimes the EC receives only one interrupt (hence timestamp) for * a batch of samples. Only the first sample will have the correct * timestamp. So we must interpolate the other samples. * We use the previous batch timestamp and our current batch timestamp * as a way to calculate period, then spread the samples evenly. * * s0 int, 0ms * s1 int, 10ms * s2 int, 20ms * 30ms point goes by, no interrupt, previous one is still asserted * downloading s2 and s3 * s3 sample, 20ms (incorrect timestamp) * s4 int, 40ms * * The batches are [(s0), (s1), (s2, s3), (s4)]. Since the 3rd batch * has 2 samples in them, we adjust the timestamp of s3. * s2 - s1 = 10ms, so s3 must be s2 + 10ms => 20ms. If s1 would have * been part of a bigger batch things would have gotten a little * more complicated. * * Note: we also assume another sensor sample doesn't break up a batch * in 2 or more partitions. Example, there can't ever be a sync sensor * in between S2 and S3. This simplifies the following code. */ static void cros_ec_sensor_ring_spread_add(struct cros_ec_sensorhub *sensorhub, unsigned long sensor_mask, struct cros_ec_sensors_ring_sample *last_out) { … } /* * cros_ec_sensor_ring_spread_add_legacy: Calculate proper timestamps then * add to ringbuffer (legacy). * * Note: This assumes we're running old firmware, where timestamp * is inserted after its sample(s)e. There can be several samples between * timestamps, so several samples can have the same timestamp. * * timestamp | count * ----------------- * 1st sample --> TS1 | 1 * TS2 | 2 * TS2 | 3 * TS3 | 4 * last_out --> * * * We spread time for the samples using period p = (current - TS1)/4. * between TS1 and TS2: [TS1+p/4, TS1+2p/4, TS1+3p/4, current_timestamp]. * */ static void cros_ec_sensor_ring_spread_add_legacy(struct cros_ec_sensorhub *sensorhub, unsigned long sensor_mask, s64 current_timestamp, struct cros_ec_sensors_ring_sample *last_out) { … } /** * cros_ec_sensorhub_ring_handler() - The trigger handler function * * @sensorhub: Sensor Hub object. * * Called by the notifier, process the EC sensor FIFO queue. */ static void cros_ec_sensorhub_ring_handler(struct cros_ec_sensorhub *sensorhub) { … } static int cros_ec_sensorhub_event(struct notifier_block *nb, unsigned long queued_during_suspend, void *_notify) { … } /** * cros_ec_sensorhub_ring_allocate() - Prepare the FIFO functionality if the EC * supports it. * * @sensorhub : Sensor Hub object. * * Return: 0 on success. */ int cros_ec_sensorhub_ring_allocate(struct cros_ec_sensorhub *sensorhub) { … } /** * cros_ec_sensorhub_ring_add() - Add the FIFO functionality if the EC * supports it. * * @sensorhub : Sensor Hub object. * * Return: 0 on success. */ int cros_ec_sensorhub_ring_add(struct cros_ec_sensorhub *sensorhub) { … } void cros_ec_sensorhub_ring_remove(void *arg) { … }
Codebase Browser
linux