Commit 596ef5cf authored by Ricardo Ribalda's avatar Ricardo Ribalda Committed by Jonathan Cameron
Browse files

iio: hid-sensor-prox: Add support for more channels



Egis620 supports 3 channels: presense, proximity and attention.

Modify the driver so it can read those channels as well.

Signed-off-by: default avatarRicardo Ribalda <ribalda@chromium.org>
Link: https://patch.msgid.link/20241101-hpd-v3-5-e9c80b7c7164@chromium.org


Signed-off-by: default avatarJonathan Cameron <Jonathan.Cameron@huawei.com>
parent f7a1fc1a
Loading
Loading
Loading
Loading
+104 −76
Original line number Diff line number Diff line
@@ -13,16 +13,32 @@
#include <linux/iio/buffer.h>
#include "../common/hid-sensors/hid-sensor-trigger.h"

#define CHANNEL_SCAN_INDEX_PRESENCE 0
static const u32 prox_usage_ids[] = {
	HID_USAGE_SENSOR_HUMAN_PRESENCE,
	HID_USAGE_SENSOR_HUMAN_PROXIMITY,
	HID_USAGE_SENSOR_HUMAN_ATTENTION,
};

#define MAX_CHANNELS ARRAY_SIZE(prox_usage_ids)

enum {
	HID_HUMAN_PRESENCE,
	HID_HUMAN_PROXIMITY,
	HID_HUMAN_ATTENTION,
};

struct prox_state {
	struct hid_sensor_hub_callbacks callbacks;
	struct hid_sensor_common common_attributes;
	struct hid_sensor_hub_attribute_info prox_attr;
	u32 human_presence;
	struct hid_sensor_hub_attribute_info prox_attr[MAX_CHANNELS];
	struct iio_chan_spec channels[MAX_CHANNELS];
	u32 channel2usage[MAX_CHANNELS];
	u32 human_presence[MAX_CHANNELS];
	int scale_pre_decml;
	int scale_post_decml;
	int scale_precision;
	unsigned long scan_mask[2]; /* One entry plus one terminator. */
	int num_channels;
};

static const u32 prox_sensitivity_addresses[] = {
@@ -30,18 +46,24 @@ static const u32 prox_sensitivity_addresses[] = {
	HID_USAGE_SENSOR_DATA_PRESENCE,
};

/* Channel definitions */
static const struct iio_chan_spec prox_channels[] = {
	{
		.type = IIO_PROXIMITY,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
		BIT(IIO_CHAN_INFO_SCALE) |
		BIT(IIO_CHAN_INFO_SAMP_FREQ) |
		BIT(IIO_CHAN_INFO_HYSTERESIS),
		.scan_index = CHANNEL_SCAN_INDEX_PRESENCE,
		.indexed = true,
#define PROX_CHANNEL(_is_proximity, _channel) \
	{\
		.type = _is_proximity ? IIO_PROXIMITY : IIO_ATTENTION,\
		.info_mask_separate = _is_proximity ? BIT(IIO_CHAN_INFO_RAW) :\
				      BIT(IIO_CHAN_INFO_PROCESSED),\
		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |\
		BIT(IIO_CHAN_INFO_SCALE) |\
		BIT(IIO_CHAN_INFO_SAMP_FREQ) |\
		BIT(IIO_CHAN_INFO_HYSTERESIS),\
		.indexed = _is_proximity,\
		.channel = _channel,\
	}

/* Channel definitions (same order as prox_usage_ids) */
static const struct iio_chan_spec prox_channels[] = {
	PROX_CHANNEL(true, HID_HUMAN_PRESENCE),
	PROX_CHANNEL(true, HID_HUMAN_PROXIMITY),
	PROX_CHANNEL(false, 0),
};

/* Adjust channel real bits based on report descriptor */
@@ -63,7 +85,7 @@ static int prox_read_raw(struct iio_dev *indio_dev,
{
	struct prox_state *prox_state = iio_priv(indio_dev);
	struct hid_sensor_hub_device *hsdev;
	int report_id = -1;
	int report_id;
	u32 address;
	int ret_type;
	s32 min;
@@ -72,29 +94,23 @@ static int prox_read_raw(struct iio_dev *indio_dev,
	*val2 = 0;
	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		switch (chan->scan_index) {
		case  CHANNEL_SCAN_INDEX_PRESENCE:
			report_id = prox_state->prox_attr.report_id;
			min = prox_state->prox_attr.logical_minimum;
			address = HID_USAGE_SENSOR_HUMAN_PRESENCE;
			hsdev = prox_state->common_attributes.hsdev;
			break;
		default:
			report_id = -1;
			break;
		}
		if (report_id >= 0) {
			hid_sensor_power_state(&prox_state->common_attributes,
						true);
			*val = sensor_hub_input_attr_get_raw_value(
				hsdev, hsdev->usage, address, report_id,
				SENSOR_HUB_SYNC, min < 0);
			hid_sensor_power_state(&prox_state->common_attributes,
						false);
		} else {
			*val = 0;
		if (chan->scan_index >= prox_state->num_channels)
			return -EINVAL;
		}
		address = prox_state->channel2usage[chan->scan_index];
		report_id = prox_state->prox_attr[chan->scan_index].report_id;
		hsdev = prox_state->common_attributes.hsdev;
		min = prox_state->prox_attr[chan->scan_index].logical_minimum;
		hid_sensor_power_state(&prox_state->common_attributes, true);
		*val = sensor_hub_input_attr_get_raw_value(hsdev,
							   hsdev->usage,
							   address,
							   report_id,
							   SENSOR_HUB_SYNC,
							   min < 0);
		if (prox_state->channel2usage[chan->scan_index] ==
		    HID_USAGE_SENSOR_HUMAN_ATTENTION)
			*val *= 100;
		hid_sensor_power_state(&prox_state->common_attributes, false);
		ret_type = IIO_VAL_INT;
		break;
	case IIO_CHAN_INFO_SCALE:
@@ -104,7 +120,7 @@ static int prox_read_raw(struct iio_dev *indio_dev,
		break;
	case IIO_CHAN_INFO_OFFSET:
		*val = hid_sensor_convert_exponent(
				prox_state->prox_attr.unit_expo);
			prox_state->prox_attr[chan->scan_index].unit_expo);
		ret_type = IIO_VAL_INT;
		break;
	case IIO_CHAN_INFO_SAMP_FREQ:
@@ -179,48 +195,67 @@ static int prox_capture_sample(struct hid_sensor_hub_device *hsdev,
{
	struct iio_dev *indio_dev = platform_get_drvdata(priv);
	struct prox_state *prox_state = iio_priv(indio_dev);
	int ret = -EINVAL;
	int multiplier = 1;
	int chan;

	for (chan = 0; chan < prox_state->num_channels; chan++)
		if (prox_state->channel2usage[chan] == usage_id)
			break;
	if (chan == prox_state->num_channels)
		return -EINVAL;

	if (usage_id == HID_USAGE_SENSOR_HUMAN_ATTENTION)
		multiplier = 100;

	switch (usage_id) {
	case HID_USAGE_SENSOR_HUMAN_PRESENCE:
	switch (raw_len) {
	case 1:
			prox_state->human_presence = *(u8 *)raw_data;
		prox_state->human_presence[chan] = *(u8 *)raw_data * multiplier;
		return 0;
	case 4:
			prox_state->human_presence = *(u32 *)raw_data;
		prox_state->human_presence[chan] = *(u32 *)raw_data * multiplier;
		return 0;
		default:
			break;
		}
		break;
	}

	return ret;
	return -EINVAL;
}

/* Parse report which is specific to an usage id*/
static int prox_parse_report(struct platform_device *pdev,
				struct hid_sensor_hub_device *hsdev,
				struct iio_chan_spec *channels,
				unsigned usage_id,
				struct prox_state *st)
{
	struct iio_chan_spec *channels = st->channels;
	int index = 0;
	int ret;
	int i;

	ret = sensor_hub_input_get_attribute_info(hsdev, HID_INPUT_REPORT,
	for (i = 0; i < MAX_CHANNELS; i++) {
		u32 usage_id = prox_usage_ids[i];

		ret = sensor_hub_input_get_attribute_info(hsdev,
							  HID_INPUT_REPORT,
							  hsdev->usage,
							  usage_id,
			HID_USAGE_SENSOR_HUMAN_PRESENCE,
			&st->prox_attr);
							  &st->prox_attr[index]);
		if (ret < 0)
			continue;
		st->channel2usage[index] = usage_id;
		st->scan_mask[0] |= BIT(index);
		channels[index] = prox_channels[i];
		channels[index].scan_index = index;
		prox_adjust_channel_bit_mask(channels, index,
					     st->prox_attr[index].size);
		dev_dbg(&pdev->dev, "prox %x:%x\n", st->prox_attr[index].index,
			st->prox_attr[index].report_id);
		index++;
	}

	if (!index)
		return ret;
	prox_adjust_channel_bit_mask(channels, CHANNEL_SCAN_INDEX_PRESENCE,
					st->prox_attr.size);

	dev_dbg(&pdev->dev, "prox %x:%x\n", st->prox_attr.index,
			st->prox_attr.report_id);
	st->num_channels = index;

	return ret;
	return 0;
}

/* Function to initialize the processing for usage id */
@@ -251,22 +286,15 @@ static int hid_prox_probe(struct platform_device *pdev)
		return ret;
	}

	indio_dev->channels = devm_kmemdup(&pdev->dev, prox_channels,
					   sizeof(prox_channels), GFP_KERNEL);
	if (!indio_dev->channels) {
		dev_err(&pdev->dev, "failed to duplicate channels\n");
		return -ENOMEM;
	}

	ret = prox_parse_report(pdev, hsdev,
				(struct iio_chan_spec *)indio_dev->channels,
				hsdev->usage, prox_state);
	ret = prox_parse_report(pdev, hsdev, prox_state);
	if (ret) {
		dev_err(&pdev->dev, "failed to setup attributes\n");
		return ret;
	}

	indio_dev->num_channels = ARRAY_SIZE(prox_channels);
	indio_dev->num_channels = prox_state->num_channels;
	indio_dev->channels = prox_state->channels;
	indio_dev->available_scan_masks = prox_state->scan_mask;
	indio_dev->info = &prox_info;
	indio_dev->name = name;
	indio_dev->modes = INDIO_DIRECT_MODE;