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

drivers/iio/light/hid-sensor-prox.c

+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;