Merge tag 'tag-chrome-platform-for-v5.7' of... (413a103c) · Commits · 戴 / test

drivers/iio/accel/cros_ec_accel_legacy.c

+2 −6

Original line number	Diff line number	Diff line
		@@ -170,7 +170,8 @@ static int cros_ec_accel_legacy_probe(struct platform_device *pdev)
		if (!indio_dev)
		return -ENOMEM;

		ret = cros_ec_sensors_core_init(pdev, indio_dev, true);
		ret = cros_ec_sensors_core_init(pdev, indio_dev, true,
		cros_ec_sensors_capture, NULL);
		if (ret)
		return ret;

		@@ -190,11 +191,6 @@ static int cros_ec_accel_legacy_probe(struct platform_device *pdev)
		state->sign[CROS_EC_SENSOR_Z] = -1;
		}

		ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL,
		cros_ec_sensors_capture, NULL);
		if (ret)
		return ret;

		return devm_iio_device_register(dev, indio_dev);
		}

drivers/iio/common/cros_ec_sensors/cros_ec_lid_angle.c

+1 −2

Original line number	Diff line number	Diff line
		@@ -97,7 +97,7 @@ static int cros_ec_lid_angle_probe(struct platform_device *pdev)
		if (!indio_dev)
		return -ENOMEM;

		ret = cros_ec_sensors_core_init(pdev, indio_dev, false);
		ret = cros_ec_sensors_core_init(pdev, indio_dev, false, NULL, NULL);
		if (ret)
		return ret;

		@@ -127,7 +127,6 @@ MODULE_DEVICE_TABLE(platform, cros_ec_lid_angle_ids);
		static struct platform_driver cros_ec_lid_angle_platform_driver = {
		.driver = {
		.name = DRV_NAME,
		.pm = &cros_ec_sensors_pm_ops,
		},
		.probe = cros_ec_lid_angle_probe,
		.id_table = cros_ec_lid_angle_ids,

drivers/iio/common/cros_ec_sensors/cros_ec_sensors.c

+5 −8

Original line number	Diff line number	Diff line
		@@ -230,10 +230,14 @@ static int cros_ec_sensors_probe(struct platform_device *pdev)
		if (!indio_dev)
		return -ENOMEM;

		ret = cros_ec_sensors_core_init(pdev, indio_dev, true);
		ret = cros_ec_sensors_core_init(pdev, indio_dev, true,
		cros_ec_sensors_capture,
		cros_ec_sensors_push_data);
		if (ret)
		return ret;

		iio_buffer_set_attrs(indio_dev->buffer, cros_ec_sensor_fifo_attributes);

		indio_dev->info = &ec_sensors_info;
		state = iio_priv(indio_dev);
		for (channel = state->channels, i = CROS_EC_SENSOR_X;
		@@ -245,7 +249,6 @@ static int cros_ec_sensors_probe(struct platform_device *pdev)
		BIT(IIO_CHAN_INFO_CALIBSCALE);
		channel->info_mask_shared_by_all =
		BIT(IIO_CHAN_INFO_SCALE) \|
		BIT(IIO_CHAN_INFO_FREQUENCY) \|
		BIT(IIO_CHAN_INFO_SAMP_FREQ);
		channel->info_mask_shared_by_all_available =
		BIT(IIO_CHAN_INFO_SAMP_FREQ);
		@@ -292,11 +295,6 @@ static int cros_ec_sensors_probe(struct platform_device *pdev)
		else
		state->core.read_ec_sensors_data = cros_ec_sensors_read_cmd;

		ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL,
		cros_ec_sensors_capture, NULL);
		if (ret)
		return ret;

		return devm_iio_device_register(dev, indio_dev);
		}

		@@ -317,7 +315,6 @@ MODULE_DEVICE_TABLE(platform, cros_ec_sensors_ids);
		static struct platform_driver cros_ec_sensors_platform_driver = {
		.driver = {
		.name = "cros-ec-sensors",
		.pm = &cros_ec_sensors_pm_ops,
		},
		.probe = cros_ec_sensors_probe,
		.id_table = cros_ec_sensors_ids,

drivers/iio/common/cros_ec_sensors/cros_ec_sensors_core.c

+289 −86

Original line number	Diff line number	Diff line
		@@ -11,7 +11,9 @@
		#include <linux/iio/common/cros_ec_sensors_core.h>
		#include <linux/iio/iio.h>
		#include <linux/iio/kfifo_buf.h>
		#include <linux/iio/sysfs.h>
		#include <linux/iio/trigger_consumer.h>
		#include <linux/iio/triggered_buffer.h>
		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/slab.h>
		@@ -20,6 +22,12 @@
		#include <linux/platform_data/cros_ec_sensorhub.h>
		#include <linux/platform_device.h>

		/*
		* Hard coded to the first device to support sensor fifo. The EC has a 2048
		* byte fifo and will trigger an interrupt when fifo is 2/3 full.
		*/
		#define CROS_EC_FIFO_SIZE (2048 * 2 / 3)

		static char *cros_ec_loc[] = {
		[MOTIONSENSE_LOC_BASE] = "base",
		[MOTIONSENSE_LOC_LID] = "lid",
		@@ -53,8 +61,15 @@ static int cros_ec_get_host_cmd_version_mask(struct cros_ec_device *ec_dev,

		static void get_default_min_max_freq(enum motionsensor_type type,
		u32 *min_freq,
		u32 *max_freq)
		u32 *max_freq,
		u32 *max_fifo_events)
		{
		/*
		* We don't know fifo size, set to size previously used by older
		* hardware.
		*/
		*max_fifo_events = CROS_EC_FIFO_SIZE;

		switch (type) {
		case MOTIONSENSE_TYPE_ACCEL:
		case MOTIONSENSE_TYPE_GYRO:
		@@ -82,9 +97,155 @@ static void get_default_min_max_freq(enum motionsensor_type type,
		}
		}

		static int cros_ec_sensor_set_ec_rate(struct cros_ec_sensors_core_state *st,
		int rate)
		{
		int ret;

		if (rate > U16_MAX)
		rate = U16_MAX;

		mutex_lock(&st->cmd_lock);
		st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
		st->param.ec_rate.data = rate;
		ret = cros_ec_motion_send_host_cmd(st, 0);
		mutex_unlock(&st->cmd_lock);
		return ret;
		}

		static ssize_t cros_ec_sensor_set_report_latency(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t len)
		{
		struct iio_dev *indio_dev = dev_to_iio_dev(dev);
		struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
		int integer, fract, ret;
		int latency;

		ret = iio_str_to_fixpoint(buf, 100000, &integer, &fract);
		if (ret)
		return ret;

		/* EC rate is in ms. */
		latency = integer * 1000 + fract / 1000;
		ret = cros_ec_sensor_set_ec_rate(st, latency);
		if (ret < 0)
		return ret;

		return len;
		}

		static ssize_t cros_ec_sensor_get_report_latency(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		{
		struct iio_dev *indio_dev = dev_to_iio_dev(dev);
		struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
		int latency, ret;

		mutex_lock(&st->cmd_lock);
		st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
		st->param.ec_rate.data = EC_MOTION_SENSE_NO_VALUE;

		ret = cros_ec_motion_send_host_cmd(st, 0);
		latency = st->resp->ec_rate.ret;
		mutex_unlock(&st->cmd_lock);
		if (ret < 0)
		return ret;

		return sprintf(buf, "%d.%06u\n",
		latency / 1000,
		(latency % 1000) * 1000);
		}

		static IIO_DEVICE_ATTR(hwfifo_timeout, 0644,
		cros_ec_sensor_get_report_latency,
		cros_ec_sensor_set_report_latency, 0);

		static ssize_t hwfifo_watermark_max_show(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		{
		struct iio_dev *indio_dev = dev_to_iio_dev(dev);
		struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);

		return sprintf(buf, "%d\n", st->fifo_max_event_count);
		}

		static IIO_DEVICE_ATTR_RO(hwfifo_watermark_max, 0);

		const struct attribute *cros_ec_sensor_fifo_attributes[] = {
		&iio_dev_attr_hwfifo_timeout.dev_attr.attr,
		&iio_dev_attr_hwfifo_watermark_max.dev_attr.attr,
		NULL,
		};
		EXPORT_SYMBOL_GPL(cros_ec_sensor_fifo_attributes);

		int cros_ec_sensors_push_data(struct iio_dev *indio_dev,
		s16 *data,
		s64 timestamp)
		{
		struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
		s16 *out;
		s64 delta;
		unsigned int i;

		/*
		* Ignore samples if the buffer is not set: it is needed if the ODR is
		* set but the buffer is not enabled yet.
		*/
		if (!iio_buffer_enabled(indio_dev))
		return 0;

		out = (s16 *)st->samples;
		for_each_set_bit(i,
		indio_dev->active_scan_mask,
		indio_dev->masklength) {
		*out = data[i];
		out++;
		}

		if (iio_device_get_clock(indio_dev) != CLOCK_BOOTTIME)
		delta = iio_get_time_ns(indio_dev) - cros_ec_get_time_ns();
		else
		delta = 0;

		iio_push_to_buffers_with_timestamp(indio_dev, st->samples,
		timestamp + delta);

		return 0;
		}
		EXPORT_SYMBOL_GPL(cros_ec_sensors_push_data);

		static void cros_ec_sensors_core_clean(void *arg)
		{
		struct platform_device pdev = (struct platform_device )arg;
		struct cros_ec_sensorhub *sensor_hub =
		dev_get_drvdata(pdev->dev.parent);
		struct iio_dev *indio_dev = platform_get_drvdata(pdev);
		struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
		u8 sensor_num = st->param.info.sensor_num;

		cros_ec_sensorhub_unregister_push_data(sensor_hub, sensor_num);
		}

		/**
		* cros_ec_sensors_core_init() - basic initialization of the core structure
		* @pdev: platform device created for the sensors
		* @indio_dev: iio device structure of the device
		* @physical_device: true if the device refers to a physical device
		* @trigger_capture: function pointer to call buffer is triggered,
		* for backward compatibility.
		* @push_data: function to call when cros_ec_sensorhub receives
		* a sample for that sensor.
		*
		* Return: 0 on success, -errno on failure.
		*/
		int cros_ec_sensors_core_init(struct platform_device *pdev,
		struct iio_dev *indio_dev,
		bool physical_device)
		bool physical_device,
		cros_ec_sensors_capture_t trigger_capture,
		cros_ec_sensorhub_push_data_cb_t push_data)
		{
		struct device *dev = &pdev->dev;
		struct cros_ec_sensors_core_state *state = iio_priv(indio_dev);
		@@ -92,6 +253,7 @@ int cros_ec_sensors_core_init(struct platform_device *pdev,
		struct cros_ec_dev *ec = sensor_hub->ec;
		struct cros_ec_sensor_platform *sensor_platform = dev_get_platdata(dev);
		u32 ver_mask;
		int frequencies[ARRAY_SIZE(state->frequencies) / 2] = { 0 };
		int ret, i;

		platform_set_drvdata(pdev, indio_dev);
		@@ -123,8 +285,6 @@ int cros_ec_sensors_core_init(struct platform_device *pdev,
		indio_dev->name = pdev->name;

		if (physical_device) {
		indio_dev->modes = INDIO_DIRECT_MODE;

		state->param.cmd = MOTIONSENSE_CMD_INFO;
		state->param.info.sensor_num = sensor_platform->sensor_num;
		ret = cros_ec_motion_send_host_cmd(state, 0);
		@@ -142,16 +302,63 @@ int cros_ec_sensors_core_init(struct platform_device *pdev,
		state->calib[i].scale = MOTION_SENSE_DEFAULT_SCALE;

		/* 0 is a correct value used to stop the device */
		state->frequencies[0] = 0;
		if (state->msg->version < 3) {
		get_default_min_max_freq(state->resp->info.type,
		&state->frequencies[1],
		&state->frequencies[2]);
		&frequencies[1],
		&frequencies[2],
		&state->fifo_max_event_count);
		} else {
		state->frequencies[1] =
		state->resp->info_3.min_frequency;
		state->frequencies[2] =
		state->resp->info_3.max_frequency;
		frequencies[1] = state->resp->info_3.min_frequency;
		frequencies[2] = state->resp->info_3.max_frequency;
		state->fifo_max_event_count =
		state->resp->info_3.fifo_max_event_count;
		}
		for (i = 0; i < ARRAY_SIZE(frequencies); i++) {
		state->frequencies[2 * i] = frequencies[i] / 1000;
		state->frequencies[2 * i + 1] =
		(frequencies[i] % 1000) * 1000;
		}

		if (cros_ec_check_features(ec, EC_FEATURE_MOTION_SENSE_FIFO)) {
		/*
		* Create a software buffer, feed by the EC FIFO.
		* We can not use trigger here, as events are generated
		* as soon as sample_frequency is set.
		*/
		struct iio_buffer *buffer;

		buffer = devm_iio_kfifo_allocate(dev);
		if (!buffer)
		return -ENOMEM;

		iio_device_attach_buffer(indio_dev, buffer);
		indio_dev->modes = INDIO_BUFFER_SOFTWARE;

		ret = cros_ec_sensorhub_register_push_data(
		sensor_hub, sensor_platform->sensor_num,
		indio_dev, push_data);
		if (ret)
		return ret;

		ret = devm_add_action_or_reset(
		dev, cros_ec_sensors_core_clean, pdev);
		if (ret)
		return ret;

		/* Timestamp coming from FIFO are in ns since boot. */
		ret = iio_device_set_clock(indio_dev, CLOCK_BOOTTIME);
		if (ret)
		return ret;
		} else {
		/*
		* The only way to get samples in buffer is to set a
		* software tigger (systrig, hrtimer).
		*/
		ret = devm_iio_triggered_buffer_setup(
		dev, indio_dev, NULL, trigger_capture,
		NULL);
		if (ret)
		return ret;
		}
		}

		@@ -159,6 +366,16 @@ int cros_ec_sensors_core_init(struct platform_device *pdev,
		}
		EXPORT_SYMBOL_GPL(cros_ec_sensors_core_init);

		/**
		* cros_ec_motion_send_host_cmd() - send motion sense host command
		* @state: pointer to state information for device
		* @opt_length: optional length to reduce the response size, useful on the data
		* path. Otherwise, the maximal allowed response size is used
		*
		* When called, the sub-command is assumed to be set in param->cmd.
		*
		* Return: 0 on success, -errno on failure.
		*/
		int cros_ec_motion_send_host_cmd(struct cros_ec_sensors_core_state *state,
		u16 opt_length)
		{
		@@ -421,6 +638,14 @@ int cros_ec_sensors_read_lpc(struct iio_dev *indio_dev,
		}
		EXPORT_SYMBOL_GPL(cros_ec_sensors_read_lpc);

		/**
		* cros_ec_sensors_read_cmd() - retrieve data using the EC command protocol
		* @indio_dev: pointer to IIO device
		* @scan_mask: bitmap of the sensor indices to scan
		* @data: location to store data
		*
		* Return: 0 on success, -errno on failure.
		*/
		int cros_ec_sensors_read_cmd(struct iio_dev *indio_dev,
		unsigned long scan_mask, s16 *data)
		{
		@@ -445,6 +670,18 @@ int cros_ec_sensors_read_cmd(struct iio_dev *indio_dev,
		}
		EXPORT_SYMBOL_GPL(cros_ec_sensors_read_cmd);

		/**
		* cros_ec_sensors_capture() - the trigger handler function
		* @irq: the interrupt number.
		* @p: a pointer to the poll function.
		*
		* On a trigger event occurring, if the pollfunc is attached then this
		* handler is called as a threaded interrupt (and hence may sleep). It
		* is responsible for grabbing data from the device and pushing it into
		* the associated buffer.
		*
		* Return: IRQ_HANDLED
		*/
		irqreturn_t cros_ec_sensors_capture(int irq, void *p)
		{
		struct iio_poll_func *pf = p;
		@@ -480,26 +717,24 @@ done:
		}
		EXPORT_SYMBOL_GPL(cros_ec_sensors_capture);

		/**
		* cros_ec_sensors_core_read() - function to request a value from the sensor
		* @st: pointer to state information for device
		* @chan: channel specification structure table
		* @val: will contain one element making up the returned value
		* @val2: will contain another element making up the returned value
		* @mask: specifies which values to be requested
		*
		* Return: the type of value returned by the device
		*/
		int cros_ec_sensors_core_read(struct cros_ec_sensors_core_state *st,
		struct iio_chan_spec const *chan,
		int val, int val2, long mask)
		{
		int ret;
		int ret, frequency;

		switch (mask) {
		case IIO_CHAN_INFO_SAMP_FREQ:
		st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
		st->param.ec_rate.data =
		EC_MOTION_SENSE_NO_VALUE;

		ret = cros_ec_motion_send_host_cmd(st, 0);
		if (ret)
		break;

		*val = st->resp->ec_rate.ret;
		ret = IIO_VAL_INT;
		break;
		case IIO_CHAN_INFO_FREQUENCY:
		st->param.cmd = MOTIONSENSE_CMD_SENSOR_ODR;
		st->param.sensor_odr.data =
		EC_MOTION_SENSE_NO_VALUE;
		@@ -508,8 +743,10 @@ int cros_ec_sensors_core_read(struct cros_ec_sensors_core_state *st,
		if (ret)
		break;

		*val = st->resp->sensor_odr.ret;
		ret = IIO_VAL_INT;
		frequency = st->resp->sensor_odr.ret;
		*val = frequency / 1000;
		val2 = (frequency % 1000) 1000;
		ret = IIO_VAL_INT_PLUS_MICRO;
		break;
		default:
		ret = -EINVAL;
		@@ -520,6 +757,17 @@ int cros_ec_sensors_core_read(struct cros_ec_sensors_core_state *st,
		}
		EXPORT_SYMBOL_GPL(cros_ec_sensors_core_read);

		/**
		* cros_ec_sensors_core_read_avail() - get available values
		* @indio_dev: pointer to state information for device
		* @chan: channel specification structure table
		* @vals: list of available values
		* @type: type of data returned
		* @length: number of data returned in the array
		* @mask: specifies which values to be requested
		*
		* Return: an error code, IIO_AVAIL_RANGE or IIO_AVAIL_LIST
		*/
		int cros_ec_sensors_core_read_avail(struct iio_dev *indio_dev,
		struct iio_chan_spec const *chan,
		const int **vals,
		@@ -533,7 +781,7 @@ int cros_ec_sensors_core_read_avail(struct iio_dev *indio_dev,
		case IIO_CHAN_INFO_SAMP_FREQ:
		*length = ARRAY_SIZE(state->frequencies);
		vals = (const int )&state->frequencies;
		*type = IIO_VAL_INT;
		*type = IIO_VAL_INT_PLUS_MICRO;
		return IIO_AVAIL_LIST;
		}

		@@ -541,31 +789,33 @@ int cros_ec_sensors_core_read_avail(struct iio_dev *indio_dev,
		}
		EXPORT_SYMBOL_GPL(cros_ec_sensors_core_read_avail);

		/**
		* cros_ec_sensors_core_write() - function to write a value to the sensor
		* @st: pointer to state information for device
		* @chan: channel specification structure table
		* @val: first part of value to write
		* @val2: second part of value to write
		* @mask: specifies which values to write
		*
		* Return: the type of value returned by the device
		*/
		int cros_ec_sensors_core_write(struct cros_ec_sensors_core_state *st,
		struct iio_chan_spec const *chan,
		int val, int val2, long mask)
		{
		int ret;
		int ret, frequency;

		switch (mask) {
		case IIO_CHAN_INFO_FREQUENCY:
		case IIO_CHAN_INFO_SAMP_FREQ:
		frequency = val * 1000 + val2 / 1000;
		st->param.cmd = MOTIONSENSE_CMD_SENSOR_ODR;
		st->param.sensor_odr.data = val;
		st->param.sensor_odr.data = frequency;

		/* Always roundup, so caller gets at least what it asks for. */
		st->param.sensor_odr.roundup = 1;

		ret = cros_ec_motion_send_host_cmd(st, 0);
		break;
		case IIO_CHAN_INFO_SAMP_FREQ:
		st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
		st->param.ec_rate.data = val;

		ret = cros_ec_motion_send_host_cmd(st, 0);
		if (ret)
		break;
		st->curr_sampl_freq = val;
		break;
		default:
		ret = -EINVAL;
		break;
		@@ -574,52 +824,5 @@ int cros_ec_sensors_core_write(struct cros_ec_sensors_core_state *st,
		}
		EXPORT_SYMBOL_GPL(cros_ec_sensors_core_write);

		static int __maybe_unused cros_ec_sensors_prepare(struct device *dev)
		{
		struct iio_dev *indio_dev = dev_get_drvdata(dev);
		struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);

		if (st->curr_sampl_freq == 0)
		return 0;

		/*
		* If the sensors are sampled at high frequency, we will not be able to
		* sleep. Set sampling to a long period if necessary.
		*/
		if (st->curr_sampl_freq < CROS_EC_MIN_SUSPEND_SAMPLING_FREQUENCY) {
		mutex_lock(&st->cmd_lock);
		st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
		st->param.ec_rate.data = CROS_EC_MIN_SUSPEND_SAMPLING_FREQUENCY;
		cros_ec_motion_send_host_cmd(st, 0);
		mutex_unlock(&st->cmd_lock);
		}
		return 0;
		}

		static void __maybe_unused cros_ec_sensors_complete(struct device *dev)
		{
		struct iio_dev *indio_dev = dev_get_drvdata(dev);
		struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);

		if (st->curr_sampl_freq == 0)
		return;

		if (st->curr_sampl_freq < CROS_EC_MIN_SUSPEND_SAMPLING_FREQUENCY) {
		mutex_lock(&st->cmd_lock);
		st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
		st->param.ec_rate.data = st->curr_sampl_freq;
		cros_ec_motion_send_host_cmd(st, 0);
		mutex_unlock(&st->cmd_lock);
		}
		}

		const struct dev_pm_ops cros_ec_sensors_pm_ops = {
		#ifdef CONFIG_PM_SLEEP
		.prepare = cros_ec_sensors_prepare,
		.complete = cros_ec_sensors_complete
		#endif
		};
		EXPORT_SYMBOL_GPL(cros_ec_sensors_pm_ops);

		MODULE_DESCRIPTION("ChromeOS EC sensor hub core functions");
		MODULE_LICENSE("GPL v2");

drivers/iio/industrialio-core.c

+7 −1

Original line number	Diff line number	Diff line
		@@ -189,7 +189,12 @@ ssize_t iio_read_const_attr(struct device *dev,
		}
		EXPORT_SYMBOL(iio_read_const_attr);

		static int iio_device_set_clock(struct iio_dev *indio_dev, clockid_t clock_id)
		/**
		* iio_device_set_clock() - Set current timestamping clock for the device
		* @indio_dev: IIO device structure containing the device
		* @clock_id: timestamping clock posix identifier to set.
		*/
		int iio_device_set_clock(struct iio_dev *indio_dev, clockid_t clock_id)
		{
		int ret;
		const struct iio_event_interface *ev_int = indio_dev->event_interface;
		@@ -207,6 +212,7 @@ static int iio_device_set_clock(struct iio_dev *indio_dev, clockid_t clock_id)

		return 0;
		}
		EXPORT_SYMBOL(iio_device_set_clock);

		/**
		* iio_get_time_ns() - utility function to get a time stamp for events etc

Admin message