linux-imx

// SPDX-License-Identifier: GPL-2.0-only

/* Hwmon client for industrial I/O devices

 *

 * Copyright (c) 2011 Jonathan Cameron

 */

​

#include <linux/kernel.h>

#include <linux/slab.h>

#include <linux/module.h>

#include <linux/err.h>

#include <linux/platform_device.h>

#include <linux/hwmon.h>

#include <linux/of.h>

#include <linux/hwmon-sysfs.h>

#include <linux/iio/consumer.h>

#include <linux/iio/types.h>

​

/**

 * struct iio_hwmon_state - device instance state

 * @channels:       filled with array of channels from iio

 * @num_channels:   number of channels in channels (saves counting twice)

 * @attr_group:     the group of attributes

 * @groups:     null terminated array of attribute groups

 * @attrs:      null terminated array of attribute pointers.

 */

struct iio_hwmon_state {

    struct iio_channel *channels;

    int num_channels;

    struct attribute_group attr_group;

    const struct attribute_group *groups[2];

    struct attribute **attrs;

};

​

/*

 * Assumes that IIO and hwmon operate in the same base units.

 * This is supposed to be true, but needs verification for

 * new channel types.

 */

static ssize_t iio_hwmon_read_val(struct device *dev,

                  struct device_attribute *attr,

                  char *buf)

{

    int result;

    int ret;

    struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);

    struct iio_hwmon_state *state = dev_get_drvdata(dev);

​

    ret = iio_read_channel_processed(&state->channels[sattr->index],

                    &result);

    if (ret < 0)

        return ret;

​

    return sprintf(buf, "%d\n", result);

}

​

static int iio_hwmon_probe(struct platform_device *pdev)

{

    struct device *dev = &pdev->dev;

    struct iio_hwmon_state *st;

    struct sensor_device_attribute *a;

    int ret, i;

    int in_i = 1, temp_i = 1, curr_i = 1, humidity_i = 1;

    enum iio_chan_type type;

    struct iio_channel *channels;

    struct device *hwmon_dev;

    char *sname;

​

    channels = devm_iio_channel_get_all(dev);

    if (IS_ERR(channels)) {

        if (PTR_ERR(channels) == -ENODEV)

            return -EPROBE_DEFER;

        return PTR_ERR(channels);

    }

​

    st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL);

    if (st == NULL)

        return -ENOMEM;

​

    st->channels = channels;

​

    /* count how many attributes we have */

    while (st->channels[st->num_channels].indio_dev)

        st->num_channels++;

​

    st->attrs = devm_kcalloc(dev,

                 st->num_channels + 1, sizeof(*st->attrs),

                 GFP_KERNEL);

    if (st->attrs == NULL)

        return -ENOMEM;

​

    for (i = 0; i < st->num_channels; i++) {

        const char *prefix;