linux/drivers/iio/dac/ad5446.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * AD5446 SPI DAC driver
 *
 * Copyright 2010 Analog Devices Inc.
 */

#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/sysfs.h>
#include <linux/list.h>
#include <linux/spi/spi.h>
#include <linux/i2c.h>
#include <linux/regulator/consumer.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>

#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>

#include <linux/unaligned.h>

#define MODE_PWRDWN_1k …
#define MODE_PWRDWN_100k …
#define MODE_PWRDWN_TRISTATE …

/**
 * struct ad5446_state - driver instance specific data
 * @dev:		this device
 * @chip_info:		chip model specific constants, available modes etc
 * @reg:		supply regulator
 * @vref_mv:		actual reference voltage used
 * @cached_val:		store/retrieve values during power down
 * @pwr_down_mode:	power down mode (1k, 100k or tristate)
 * @pwr_down:		true if the device is in power down
 * @lock:		lock to protect the data buffer during write ops
 */

struct ad5446_state { … };

/**
 * struct ad5446_chip_info - chip specific information
 * @channel:		channel spec for the DAC
 * @int_vref_mv:	AD5620/40/60: the internal reference voltage
 * @write:		chip specific helper function to write to the register
 */

struct ad5446_chip_info { … };

static const char * const ad5446_powerdown_modes[] = …;

static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev,
	const struct iio_chan_spec *chan, unsigned int mode)
{ … }

static int ad5446_get_powerdown_mode(struct iio_dev *indio_dev,
	const struct iio_chan_spec *chan)
{ … }

static const struct iio_enum ad5446_powerdown_mode_enum = …;

static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
					   uintptr_t private,
					   const struct iio_chan_spec *chan,
					   char *buf)
{ … }

static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
					    uintptr_t private,
					    const struct iio_chan_spec *chan,
					    const char *buf, size_t len)
{ … }

static const struct iio_chan_spec_ext_info ad5446_ext_info_powerdown[] = …;

#define _AD5446_CHANNEL(bits, storage, _shift, ext) …

#define AD5446_CHANNEL(bits, storage, shift) …

#define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) …

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

static int ad5446_write_raw(struct iio_dev *indio_dev,
			       struct iio_chan_spec const *chan,
			       int val,
			       int val2,
			       long mask)
{ … }

static const struct iio_info ad5446_info = …;

static int ad5446_probe(struct device *dev, const char *name,
			const struct ad5446_chip_info *chip_info)
{ … }

static void ad5446_remove(struct device *dev)
{ … }

#if IS_ENABLED(CONFIG_SPI_MASTER)

static int ad5446_write(struct ad5446_state *st, unsigned val)
{ … }

static int ad5660_write(struct ad5446_state *st, unsigned val)
{ … }

/*
 * ad5446_supported_spi_device_ids:
 * The AD5620/40/60 parts are available in different fixed internal reference
 * voltage options. The actual part numbers may look differently
 * (and a bit cryptic), however this style is used to make clear which
 * parts are supported here.
 */
enum ad5446_supported_spi_device_ids { … };

static const struct ad5446_chip_info ad5446_spi_chip_info[] = …;

static const struct spi_device_id ad5446_spi_ids[] = …;
MODULE_DEVICE_TABLE(spi, ad5446_spi_ids);

static const struct of_device_id ad5446_of_ids[] = …;
MODULE_DEVICE_TABLE(of, ad5446_of_ids);

static int ad5446_spi_probe(struct spi_device *spi)
{ … }

static void ad5446_spi_remove(struct spi_device *spi)
{ … }

static struct spi_driver ad5446_spi_driver = …;

static int __init ad5446_spi_register_driver(void)
{ … }

static void ad5446_spi_unregister_driver(void)
{ … }

#else

static inline int ad5446_spi_register_driver(void) { return 0; }
static inline void ad5446_spi_unregister_driver(void) { }

#endif

#if IS_ENABLED(CONFIG_I2C)

static int ad5622_write(struct ad5446_state *st, unsigned val)
{ … }

/*
 * ad5446_supported_i2c_device_ids:
 * The AD5620/40/60 parts are available in different fixed internal reference
 * voltage options. The actual part numbers may look differently
 * (and a bit cryptic), however this style is used to make clear which
 * parts are supported here.
 */
enum ad5446_supported_i2c_device_ids { … };

static const struct ad5446_chip_info ad5446_i2c_chip_info[] = …;

static int ad5446_i2c_probe(struct i2c_client *i2c)
{ … }

static void ad5446_i2c_remove(struct i2c_client *i2c)
{ … }

static const struct i2c_device_id ad5446_i2c_ids[] = …;
MODULE_DEVICE_TABLE(i2c, ad5446_i2c_ids);

static struct i2c_driver ad5446_i2c_driver = …;

static int __init ad5446_i2c_register_driver(void)
{ … }

static void __exit ad5446_i2c_unregister_driver(void)
{ … }

#else

static inline int ad5446_i2c_register_driver(void) { return 0; }
static inline void ad5446_i2c_unregister_driver(void) { }

#endif

static int __init ad5446_init(void)
{ … }
module_init(…) …;

static void __exit ad5446_exit(void)
{ … }
module_exit(ad5446_exit);

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