mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-11-24 03:10:52 +07:00
d3be83244c
This patch applies the semantic patch: @@ expression I, P, SP; @@ I = devm_iio_device_alloc(P, SP); ... - I->dev.parent = P; It updates 302 files and does 307 deletions. This semantic patch also removes some comments like '/* Establish that the iio_dev is a child of the i2c device */' But this is is only done in case where the block is left empty. The patch does not seem to cover all cases. It looks like in some cases a different variable is used in some cases to assign the parent, but it points to the same reference. In other cases, the block covered by ... may be just too big to be covered by the semantic patch. However, this looks pretty good as well, as it does cover a big bulk of the drivers that should remove the parent assignment. Signed-off-by: Alexandru Ardelean <alexandru.ardelean@analog.com> Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
375 lines
9.3 KiB
C
375 lines
9.3 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* IIO driver for the Apex Embedded Systems STX104
|
|
* Copyright (C) 2016 William Breathitt Gray
|
|
*/
|
|
#include <linux/bitops.h>
|
|
#include <linux/device.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/gpio/driver.h>
|
|
#include <linux/iio/iio.h>
|
|
#include <linux/iio/types.h>
|
|
#include <linux/io.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/isa.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/spinlock.h>
|
|
|
|
#define STX104_OUT_CHAN(chan) { \
|
|
.type = IIO_VOLTAGE, \
|
|
.channel = chan, \
|
|
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
|
|
.indexed = 1, \
|
|
.output = 1 \
|
|
}
|
|
#define STX104_IN_CHAN(chan, diff) { \
|
|
.type = IIO_VOLTAGE, \
|
|
.channel = chan, \
|
|
.channel2 = chan, \
|
|
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_HARDWAREGAIN) | \
|
|
BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_SCALE), \
|
|
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
|
|
.indexed = 1, \
|
|
.differential = diff \
|
|
}
|
|
|
|
#define STX104_NUM_OUT_CHAN 2
|
|
|
|
#define STX104_EXTENT 16
|
|
|
|
static unsigned int base[max_num_isa_dev(STX104_EXTENT)];
|
|
static unsigned int num_stx104;
|
|
module_param_hw_array(base, uint, ioport, &num_stx104, 0);
|
|
MODULE_PARM_DESC(base, "Apex Embedded Systems STX104 base addresses");
|
|
|
|
/**
|
|
* struct stx104_iio - IIO device private data structure
|
|
* @chan_out_states: channels' output states
|
|
* @base: base port address of the IIO device
|
|
*/
|
|
struct stx104_iio {
|
|
unsigned int chan_out_states[STX104_NUM_OUT_CHAN];
|
|
unsigned int base;
|
|
};
|
|
|
|
/**
|
|
* struct stx104_gpio - GPIO device private data structure
|
|
* @chip: instance of the gpio_chip
|
|
* @lock: synchronization lock to prevent I/O race conditions
|
|
* @base: base port address of the GPIO device
|
|
* @out_state: output bits state
|
|
*/
|
|
struct stx104_gpio {
|
|
struct gpio_chip chip;
|
|
spinlock_t lock;
|
|
unsigned int base;
|
|
unsigned int out_state;
|
|
};
|
|
|
|
static int stx104_read_raw(struct iio_dev *indio_dev,
|
|
struct iio_chan_spec const *chan, int *val, int *val2, long mask)
|
|
{
|
|
struct stx104_iio *const priv = iio_priv(indio_dev);
|
|
unsigned int adc_config;
|
|
int adbu;
|
|
int gain;
|
|
|
|
switch (mask) {
|
|
case IIO_CHAN_INFO_HARDWAREGAIN:
|
|
/* get gain configuration */
|
|
adc_config = inb(priv->base + 11);
|
|
gain = adc_config & 0x3;
|
|
|
|
*val = 1 << gain;
|
|
return IIO_VAL_INT;
|
|
case IIO_CHAN_INFO_RAW:
|
|
if (chan->output) {
|
|
*val = priv->chan_out_states[chan->channel];
|
|
return IIO_VAL_INT;
|
|
}
|
|
|
|
/* select ADC channel */
|
|
outb(chan->channel | (chan->channel << 4), priv->base + 2);
|
|
|
|
/* trigger ADC sample capture and wait for completion */
|
|
outb(0, priv->base);
|
|
while (inb(priv->base + 8) & BIT(7));
|
|
|
|
*val = inw(priv->base);
|
|
return IIO_VAL_INT;
|
|
case IIO_CHAN_INFO_OFFSET:
|
|
/* get ADC bipolar/unipolar configuration */
|
|
adc_config = inb(priv->base + 11);
|
|
adbu = !(adc_config & BIT(2));
|
|
|
|
*val = -32768 * adbu;
|
|
return IIO_VAL_INT;
|
|
case IIO_CHAN_INFO_SCALE:
|
|
/* get ADC bipolar/unipolar and gain configuration */
|
|
adc_config = inb(priv->base + 11);
|
|
adbu = !(adc_config & BIT(2));
|
|
gain = adc_config & 0x3;
|
|
|
|
*val = 5;
|
|
*val2 = 15 - adbu + gain;
|
|
return IIO_VAL_FRACTIONAL_LOG2;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int stx104_write_raw(struct iio_dev *indio_dev,
|
|
struct iio_chan_spec const *chan, int val, int val2, long mask)
|
|
{
|
|
struct stx104_iio *const priv = iio_priv(indio_dev);
|
|
|
|
switch (mask) {
|
|
case IIO_CHAN_INFO_HARDWAREGAIN:
|
|
/* Only four gain states (x1, x2, x4, x8) */
|
|
switch (val) {
|
|
case 1:
|
|
outb(0, priv->base + 11);
|
|
break;
|
|
case 2:
|
|
outb(1, priv->base + 11);
|
|
break;
|
|
case 4:
|
|
outb(2, priv->base + 11);
|
|
break;
|
|
case 8:
|
|
outb(3, priv->base + 11);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
case IIO_CHAN_INFO_RAW:
|
|
if (chan->output) {
|
|
/* DAC can only accept up to a 16-bit value */
|
|
if ((unsigned int)val > 65535)
|
|
return -EINVAL;
|
|
|
|
priv->chan_out_states[chan->channel] = val;
|
|
outw(val, priv->base + 4 + 2 * chan->channel);
|
|
|
|
return 0;
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static const struct iio_info stx104_info = {
|
|
.read_raw = stx104_read_raw,
|
|
.write_raw = stx104_write_raw
|
|
};
|
|
|
|
/* single-ended input channels configuration */
|
|
static const struct iio_chan_spec stx104_channels_sing[] = {
|
|
STX104_OUT_CHAN(0), STX104_OUT_CHAN(1),
|
|
STX104_IN_CHAN(0, 0), STX104_IN_CHAN(1, 0), STX104_IN_CHAN(2, 0),
|
|
STX104_IN_CHAN(3, 0), STX104_IN_CHAN(4, 0), STX104_IN_CHAN(5, 0),
|
|
STX104_IN_CHAN(6, 0), STX104_IN_CHAN(7, 0), STX104_IN_CHAN(8, 0),
|
|
STX104_IN_CHAN(9, 0), STX104_IN_CHAN(10, 0), STX104_IN_CHAN(11, 0),
|
|
STX104_IN_CHAN(12, 0), STX104_IN_CHAN(13, 0), STX104_IN_CHAN(14, 0),
|
|
STX104_IN_CHAN(15, 0)
|
|
};
|
|
/* differential input channels configuration */
|
|
static const struct iio_chan_spec stx104_channels_diff[] = {
|
|
STX104_OUT_CHAN(0), STX104_OUT_CHAN(1),
|
|
STX104_IN_CHAN(0, 1), STX104_IN_CHAN(1, 1), STX104_IN_CHAN(2, 1),
|
|
STX104_IN_CHAN(3, 1), STX104_IN_CHAN(4, 1), STX104_IN_CHAN(5, 1),
|
|
STX104_IN_CHAN(6, 1), STX104_IN_CHAN(7, 1)
|
|
};
|
|
|
|
static int stx104_gpio_get_direction(struct gpio_chip *chip,
|
|
unsigned int offset)
|
|
{
|
|
/* GPIO 0-3 are input only, while the rest are output only */
|
|
if (offset < 4)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int stx104_gpio_direction_input(struct gpio_chip *chip,
|
|
unsigned int offset)
|
|
{
|
|
if (offset >= 4)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int stx104_gpio_direction_output(struct gpio_chip *chip,
|
|
unsigned int offset, int value)
|
|
{
|
|
if (offset < 4)
|
|
return -EINVAL;
|
|
|
|
chip->set(chip, offset, value);
|
|
return 0;
|
|
}
|
|
|
|
static int stx104_gpio_get(struct gpio_chip *chip, unsigned int offset)
|
|
{
|
|
struct stx104_gpio *const stx104gpio = gpiochip_get_data(chip);
|
|
|
|
if (offset >= 4)
|
|
return -EINVAL;
|
|
|
|
return !!(inb(stx104gpio->base) & BIT(offset));
|
|
}
|
|
|
|
static int stx104_gpio_get_multiple(struct gpio_chip *chip, unsigned long *mask,
|
|
unsigned long *bits)
|
|
{
|
|
struct stx104_gpio *const stx104gpio = gpiochip_get_data(chip);
|
|
|
|
*bits = inb(stx104gpio->base);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void stx104_gpio_set(struct gpio_chip *chip, unsigned int offset,
|
|
int value)
|
|
{
|
|
struct stx104_gpio *const stx104gpio = gpiochip_get_data(chip);
|
|
const unsigned int mask = BIT(offset) >> 4;
|
|
unsigned long flags;
|
|
|
|
if (offset < 4)
|
|
return;
|
|
|
|
spin_lock_irqsave(&stx104gpio->lock, flags);
|
|
|
|
if (value)
|
|
stx104gpio->out_state |= mask;
|
|
else
|
|
stx104gpio->out_state &= ~mask;
|
|
|
|
outb(stx104gpio->out_state, stx104gpio->base);
|
|
|
|
spin_unlock_irqrestore(&stx104gpio->lock, flags);
|
|
}
|
|
|
|
#define STX104_NGPIO 8
|
|
static const char *stx104_names[STX104_NGPIO] = {
|
|
"DIN0", "DIN1", "DIN2", "DIN3", "DOUT0", "DOUT1", "DOUT2", "DOUT3"
|
|
};
|
|
|
|
static void stx104_gpio_set_multiple(struct gpio_chip *chip,
|
|
unsigned long *mask, unsigned long *bits)
|
|
{
|
|
struct stx104_gpio *const stx104gpio = gpiochip_get_data(chip);
|
|
unsigned long flags;
|
|
|
|
/* verify masked GPIO are output */
|
|
if (!(*mask & 0xF0))
|
|
return;
|
|
|
|
*mask >>= 4;
|
|
*bits >>= 4;
|
|
|
|
spin_lock_irqsave(&stx104gpio->lock, flags);
|
|
|
|
stx104gpio->out_state &= ~*mask;
|
|
stx104gpio->out_state |= *mask & *bits;
|
|
outb(stx104gpio->out_state, stx104gpio->base);
|
|
|
|
spin_unlock_irqrestore(&stx104gpio->lock, flags);
|
|
}
|
|
|
|
static int stx104_probe(struct device *dev, unsigned int id)
|
|
{
|
|
struct iio_dev *indio_dev;
|
|
struct stx104_iio *priv;
|
|
struct stx104_gpio *stx104gpio;
|
|
int err;
|
|
|
|
indio_dev = devm_iio_device_alloc(dev, sizeof(*priv));
|
|
if (!indio_dev)
|
|
return -ENOMEM;
|
|
|
|
stx104gpio = devm_kzalloc(dev, sizeof(*stx104gpio), GFP_KERNEL);
|
|
if (!stx104gpio)
|
|
return -ENOMEM;
|
|
|
|
if (!devm_request_region(dev, base[id], STX104_EXTENT,
|
|
dev_name(dev))) {
|
|
dev_err(dev, "Unable to lock port addresses (0x%X-0x%X)\n",
|
|
base[id], base[id] + STX104_EXTENT);
|
|
return -EBUSY;
|
|
}
|
|
|
|
indio_dev->info = &stx104_info;
|
|
indio_dev->modes = INDIO_DIRECT_MODE;
|
|
|
|
/* determine if differential inputs */
|
|
if (inb(base[id] + 8) & BIT(5)) {
|
|
indio_dev->num_channels = ARRAY_SIZE(stx104_channels_diff);
|
|
indio_dev->channels = stx104_channels_diff;
|
|
} else {
|
|
indio_dev->num_channels = ARRAY_SIZE(stx104_channels_sing);
|
|
indio_dev->channels = stx104_channels_sing;
|
|
}
|
|
|
|
indio_dev->name = dev_name(dev);
|
|
|
|
priv = iio_priv(indio_dev);
|
|
priv->base = base[id];
|
|
|
|
/* configure device for software trigger operation */
|
|
outb(0, base[id] + 9);
|
|
|
|
/* initialize gain setting to x1 */
|
|
outb(0, base[id] + 11);
|
|
|
|
/* initialize DAC output to 0V */
|
|
outw(0, base[id] + 4);
|
|
outw(0, base[id] + 6);
|
|
|
|
stx104gpio->chip.label = dev_name(dev);
|
|
stx104gpio->chip.parent = dev;
|
|
stx104gpio->chip.owner = THIS_MODULE;
|
|
stx104gpio->chip.base = -1;
|
|
stx104gpio->chip.ngpio = STX104_NGPIO;
|
|
stx104gpio->chip.names = stx104_names;
|
|
stx104gpio->chip.get_direction = stx104_gpio_get_direction;
|
|
stx104gpio->chip.direction_input = stx104_gpio_direction_input;
|
|
stx104gpio->chip.direction_output = stx104_gpio_direction_output;
|
|
stx104gpio->chip.get = stx104_gpio_get;
|
|
stx104gpio->chip.get_multiple = stx104_gpio_get_multiple;
|
|
stx104gpio->chip.set = stx104_gpio_set;
|
|
stx104gpio->chip.set_multiple = stx104_gpio_set_multiple;
|
|
stx104gpio->base = base[id] + 3;
|
|
stx104gpio->out_state = 0x0;
|
|
|
|
spin_lock_init(&stx104gpio->lock);
|
|
|
|
err = devm_gpiochip_add_data(dev, &stx104gpio->chip, stx104gpio);
|
|
if (err) {
|
|
dev_err(dev, "GPIO registering failed (%d)\n", err);
|
|
return err;
|
|
}
|
|
|
|
return devm_iio_device_register(dev, indio_dev);
|
|
}
|
|
|
|
static struct isa_driver stx104_driver = {
|
|
.probe = stx104_probe,
|
|
.driver = {
|
|
.name = "stx104"
|
|
},
|
|
};
|
|
|
|
module_isa_driver(stx104_driver, num_stx104);
|
|
|
|
MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>");
|
|
MODULE_DESCRIPTION("Apex Embedded Systems STX104 IIO driver");
|
|
MODULE_LICENSE("GPL v2");
|