linux/drivers/iio/adc/mxs-lradc-adc.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Freescale MXS LRADC ADC driver
 *
 * Copyright (c) 2012 DENX Software Engineering, GmbH.
 * Copyright (c) 2017 Ksenija Stanojevic <[email protected]>
 *
 * Authors:
 *  Marek Vasut <[email protected]>
 *  Ksenija Stanojevic <[email protected]>
 */

#include <linux/completion.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/mfd/core.h>
#include <linux/mfd/mxs-lradc.h>
#include <linux/module.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>
#include <linux/sysfs.h>

#include <linux/iio/buffer.h>
#include <linux/iio/iio.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/iio/sysfs.h>

/*
 * Make this runtime configurable if necessary. Currently, if the buffered mode
 * is enabled, the LRADC takes LRADC_DELAY_TIMER_LOOP samples of data before
 * triggering IRQ. The sampling happens every (LRADC_DELAY_TIMER_PER / 2000)
 * seconds. The result is that the samples arrive every 500mS.
 */
#define LRADC_DELAY_TIMER_PER …
#define LRADC_DELAY_TIMER_LOOP …

#define VREF_MV_BASE …

static const char *mx23_lradc_adc_irq_names[] = …;

static const char *mx28_lradc_adc_irq_names[] = …;

static const u32 mxs_lradc_adc_vref_mv[][LRADC_MAX_TOTAL_CHANS] = …;

enum mxs_lradc_divbytwo { … };

struct mxs_lradc_scale { … };

struct mxs_lradc_adc { … };


/* Raw I/O operations */
static int mxs_lradc_adc_read_single(struct iio_dev *iio_dev, int chan,
				     int *val)
{ … }

static int mxs_lradc_adc_read_temp(struct iio_dev *iio_dev, int *val)
{ … }

static int mxs_lradc_adc_read_raw(struct iio_dev *iio_dev,
			      const struct iio_chan_spec *chan,
			      int *val, int *val2, long m)
{ … }

static int mxs_lradc_adc_write_raw(struct iio_dev *iio_dev,
				   const struct iio_chan_spec *chan,
				   int val, int val2, long m)
{ … }

static int mxs_lradc_adc_write_raw_get_fmt(struct iio_dev *iio_dev,
					   const struct iio_chan_spec *chan,
					   long m)
{ … }

static ssize_t mxs_lradc_adc_show_scale_avail(struct device *dev,
						 struct device_attribute *attr,
						 char *buf)
{ … }

#define SHOW_SCALE_AVAILABLE_ATTR(ch) …

static SHOW_SCALE_AVAILABLE_ATTR(0);
static SHOW_SCALE_AVAILABLE_ATTR(1);
static SHOW_SCALE_AVAILABLE_ATTR(2);
static SHOW_SCALE_AVAILABLE_ATTR(3);
static SHOW_SCALE_AVAILABLE_ATTR(4);
static SHOW_SCALE_AVAILABLE_ATTR(5);
static SHOW_SCALE_AVAILABLE_ATTR(6);
static SHOW_SCALE_AVAILABLE_ATTR(7);
static SHOW_SCALE_AVAILABLE_ATTR(10);
static SHOW_SCALE_AVAILABLE_ATTR(11);
static SHOW_SCALE_AVAILABLE_ATTR(12);
static SHOW_SCALE_AVAILABLE_ATTR(13);
static SHOW_SCALE_AVAILABLE_ATTR(14);
static SHOW_SCALE_AVAILABLE_ATTR(15);

static struct attribute *mxs_lradc_adc_attributes[] = …;

static const struct attribute_group mxs_lradc_adc_attribute_group = …;

static const struct iio_info mxs_lradc_adc_iio_info = …;

/* IRQ Handling */
static irqreturn_t mxs_lradc_adc_handle_irq(int irq, void *data)
{ … }


/* Trigger handling */
static irqreturn_t mxs_lradc_adc_trigger_handler(int irq, void *p)
{ … }

static int mxs_lradc_adc_configure_trigger(struct iio_trigger *trig, bool state)
{ … }

static const struct iio_trigger_ops mxs_lradc_adc_trigger_ops = …;

static int mxs_lradc_adc_trigger_init(struct iio_dev *iio)
{ … }

static void mxs_lradc_adc_trigger_remove(struct iio_dev *iio)
{ … }

static int mxs_lradc_adc_buffer_preenable(struct iio_dev *iio)
{ … }

static int mxs_lradc_adc_buffer_postdisable(struct iio_dev *iio)
{ … }

static bool mxs_lradc_adc_validate_scan_mask(struct iio_dev *iio,
					     const unsigned long *mask)
{ … }

static const struct iio_buffer_setup_ops mxs_lradc_adc_buffer_ops = …;

/* Driver initialization */
#define MXS_ADC_CHAN(idx, chan_type, name) …

static const struct iio_chan_spec mx23_lradc_chan_spec[] = …;

static const struct iio_chan_spec mx28_lradc_chan_spec[] = …;

static void mxs_lradc_adc_hw_init(struct mxs_lradc_adc *adc)
{ … }

static void mxs_lradc_adc_hw_stop(struct mxs_lradc_adc *adc)
{ … }

static int mxs_lradc_adc_probe(struct platform_device *pdev)
{ … }

static void mxs_lradc_adc_remove(struct platform_device *pdev)
{ … }

static struct platform_driver mxs_lradc_adc_driver = …;
module_platform_driver(…) …;

MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;
MODULE_ALIAS(…) …;