forked from Minki/linux
8c896308fe
The driver programs a threshold of "coordinate_readouts" say 5. The REG_FIFO0THR registers says it should it be programmed to "threshold minus one". The driver does not expect just 5 coordinates but 5 * 2 + 2. Multiplied by two because 5 for X and 5 for Y and plus 2 because we have two Z. The whole thing kind of works because It reads the 5 coordinates for X and Y from FIFO0 and FIFO1 and the last element in each FIFO is ignored within the loop and read later. Nothing guaranties that FIFO1 is ready by the time it is read. In fact I could see that that FIFO1 reaturns for Y channels 8,9, 10, 12, 6 and for Y channel 7 for Z. The problem is that channel 7 and channel 12 got somehow mixed up. The other Problem is that FIFO1 is also used by the IIO part leading to wrong results if both (tsc & adc) are used. The patch tries to clean up the whole thing a little: - Remove the +1 and -1 in REG_STEPCONFIG, REG_STEPDELAY and its counter part in the for loop. This is just confusing. - Use only FIFO0 in TSC. The fifo has space for 64 entries so should be fine. - Read the whole FIFO in one function and check the channel. - in case we dawdle around, make sure we only read a multiple of our coordinate set. On the second interrupt we will cleanup the remaining enties. Acked-by: Dmitry Torokhov <dmitry.torokhov@gmail.com> Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
308 lines
7.3 KiB
C
308 lines
7.3 KiB
C
/*
|
|
* TI ADC MFD driver
|
|
*
|
|
* Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation version 2.
|
|
*
|
|
* This program is distributed "as is" WITHOUT ANY WARRANTY of any
|
|
* kind, whether express or implied; without even the implied warranty
|
|
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/err.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/io.h>
|
|
#include <linux/iio/iio.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/iio/machine.h>
|
|
#include <linux/iio/driver.h>
|
|
|
|
#include <linux/mfd/ti_am335x_tscadc.h>
|
|
|
|
struct tiadc_device {
|
|
struct ti_tscadc_dev *mfd_tscadc;
|
|
int channels;
|
|
};
|
|
|
|
static unsigned int tiadc_readl(struct tiadc_device *adc, unsigned int reg)
|
|
{
|
|
return readl(adc->mfd_tscadc->tscadc_base + reg);
|
|
}
|
|
|
|
static void tiadc_writel(struct tiadc_device *adc, unsigned int reg,
|
|
unsigned int val)
|
|
{
|
|
writel(val, adc->mfd_tscadc->tscadc_base + reg);
|
|
}
|
|
|
|
static u32 get_adc_step_mask(struct tiadc_device *adc_dev)
|
|
{
|
|
u32 step_en;
|
|
|
|
step_en = ((1 << adc_dev->channels) - 1);
|
|
step_en <<= TOTAL_STEPS - adc_dev->channels + 1;
|
|
return step_en;
|
|
}
|
|
|
|
static void tiadc_step_config(struct tiadc_device *adc_dev)
|
|
{
|
|
unsigned int stepconfig;
|
|
int i, channels = 0, steps;
|
|
u32 step_en;
|
|
|
|
/*
|
|
* There are 16 configurable steps and 8 analog input
|
|
* lines available which are shared between Touchscreen and ADC.
|
|
*
|
|
* Steps backwards i.e. from 16 towards 0 are used by ADC
|
|
* depending on number of input lines needed.
|
|
* Channel would represent which analog input
|
|
* needs to be given to ADC to digitalize data.
|
|
*/
|
|
|
|
steps = TOTAL_STEPS - adc_dev->channels;
|
|
channels = TOTAL_CHANNELS - adc_dev->channels;
|
|
|
|
stepconfig = STEPCONFIG_AVG_16 | STEPCONFIG_FIFO1;
|
|
|
|
for (i = steps; i < TOTAL_STEPS; i++) {
|
|
tiadc_writel(adc_dev, REG_STEPCONFIG(i),
|
|
stepconfig | STEPCONFIG_INP(channels));
|
|
tiadc_writel(adc_dev, REG_STEPDELAY(i),
|
|
STEPCONFIG_OPENDLY);
|
|
channels++;
|
|
}
|
|
step_en = get_adc_step_mask(adc_dev);
|
|
am335x_tsc_se_set(adc_dev->mfd_tscadc, step_en);
|
|
}
|
|
|
|
static const char * const chan_name_ain[] = {
|
|
"AIN0",
|
|
"AIN1",
|
|
"AIN2",
|
|
"AIN3",
|
|
"AIN4",
|
|
"AIN5",
|
|
"AIN6",
|
|
"AIN7",
|
|
};
|
|
|
|
static int tiadc_channel_init(struct iio_dev *indio_dev, int channels)
|
|
{
|
|
struct tiadc_device *adc_dev = iio_priv(indio_dev);
|
|
struct iio_chan_spec *chan_array;
|
|
struct iio_chan_spec *chan;
|
|
int i;
|
|
|
|
indio_dev->num_channels = channels;
|
|
chan_array = kcalloc(channels,
|
|
sizeof(struct iio_chan_spec), GFP_KERNEL);
|
|
if (chan_array == NULL)
|
|
return -ENOMEM;
|
|
|
|
chan = chan_array;
|
|
for (i = 0; i < channels; i++, chan++) {
|
|
|
|
chan->type = IIO_VOLTAGE;
|
|
chan->indexed = 1;
|
|
chan->channel = i;
|
|
chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
|
|
chan->datasheet_name = chan_name_ain[i];
|
|
chan->scan_type.sign = 'u';
|
|
chan->scan_type.realbits = 12;
|
|
chan->scan_type.storagebits = 32;
|
|
}
|
|
|
|
indio_dev->channels = chan_array;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void tiadc_channels_remove(struct iio_dev *indio_dev)
|
|
{
|
|
kfree(indio_dev->channels);
|
|
}
|
|
|
|
static int tiadc_read_raw(struct iio_dev *indio_dev,
|
|
struct iio_chan_spec const *chan,
|
|
int *val, int *val2, long mask)
|
|
{
|
|
struct tiadc_device *adc_dev = iio_priv(indio_dev);
|
|
int i;
|
|
unsigned int fifo1count, readx1;
|
|
|
|
/*
|
|
* When the sub-system is first enabled,
|
|
* the sequencer will always start with the
|
|
* lowest step (1) and continue until step (16).
|
|
* For ex: If we have enabled 4 ADC channels and
|
|
* currently use only 1 out of them, the
|
|
* sequencer still configures all the 4 steps,
|
|
* leading to 3 unwanted data.
|
|
* Hence we need to flush out this data.
|
|
*/
|
|
|
|
fifo1count = tiadc_readl(adc_dev, REG_FIFO1CNT);
|
|
for (i = 0; i < fifo1count; i++) {
|
|
readx1 = tiadc_readl(adc_dev, REG_FIFO1);
|
|
if (i == chan->channel)
|
|
*val = readx1 & 0xfff;
|
|
}
|
|
am335x_tsc_se_update(adc_dev->mfd_tscadc);
|
|
|
|
return IIO_VAL_INT;
|
|
}
|
|
|
|
static const struct iio_info tiadc_info = {
|
|
.read_raw = &tiadc_read_raw,
|
|
};
|
|
|
|
static int tiadc_probe(struct platform_device *pdev)
|
|
{
|
|
struct iio_dev *indio_dev;
|
|
struct tiadc_device *adc_dev;
|
|
struct device_node *node = pdev->dev.of_node;
|
|
int err;
|
|
u32 val32;
|
|
|
|
if (!node) {
|
|
dev_err(&pdev->dev, "Could not find valid DT data.\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
indio_dev = iio_device_alloc(sizeof(struct tiadc_device));
|
|
if (indio_dev == NULL) {
|
|
dev_err(&pdev->dev, "failed to allocate iio device\n");
|
|
err = -ENOMEM;
|
|
goto err_ret;
|
|
}
|
|
adc_dev = iio_priv(indio_dev);
|
|
|
|
adc_dev->mfd_tscadc = ti_tscadc_dev_get(pdev);
|
|
|
|
err = of_property_read_u32(node,
|
|
"ti,adc-channels", &val32);
|
|
if (err < 0)
|
|
goto err_free_device;
|
|
adc_dev->channels = val32;
|
|
|
|
indio_dev->dev.parent = &pdev->dev;
|
|
indio_dev->name = dev_name(&pdev->dev);
|
|
indio_dev->modes = INDIO_DIRECT_MODE;
|
|
indio_dev->info = &tiadc_info;
|
|
|
|
tiadc_step_config(adc_dev);
|
|
|
|
err = tiadc_channel_init(indio_dev, adc_dev->channels);
|
|
if (err < 0)
|
|
goto err_free_device;
|
|
|
|
err = iio_device_register(indio_dev);
|
|
if (err)
|
|
goto err_free_channels;
|
|
|
|
platform_set_drvdata(pdev, indio_dev);
|
|
|
|
return 0;
|
|
|
|
err_free_channels:
|
|
tiadc_channels_remove(indio_dev);
|
|
err_free_device:
|
|
iio_device_free(indio_dev);
|
|
err_ret:
|
|
return err;
|
|
}
|
|
|
|
static int tiadc_remove(struct platform_device *pdev)
|
|
{
|
|
struct iio_dev *indio_dev = platform_get_drvdata(pdev);
|
|
struct tiadc_device *adc_dev = iio_priv(indio_dev);
|
|
u32 step_en;
|
|
|
|
iio_device_unregister(indio_dev);
|
|
tiadc_channels_remove(indio_dev);
|
|
|
|
step_en = get_adc_step_mask(adc_dev);
|
|
am335x_tsc_se_clr(adc_dev->mfd_tscadc, step_en);
|
|
|
|
iio_device_free(indio_dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
static int tiadc_suspend(struct device *dev)
|
|
{
|
|
struct iio_dev *indio_dev = dev_get_drvdata(dev);
|
|
struct tiadc_device *adc_dev = iio_priv(indio_dev);
|
|
struct ti_tscadc_dev *tscadc_dev;
|
|
unsigned int idle;
|
|
|
|
tscadc_dev = ti_tscadc_dev_get(to_platform_device(dev));
|
|
if (!device_may_wakeup(tscadc_dev->dev)) {
|
|
idle = tiadc_readl(adc_dev, REG_CTRL);
|
|
idle &= ~(CNTRLREG_TSCSSENB);
|
|
tiadc_writel(adc_dev, REG_CTRL, (idle |
|
|
CNTRLREG_POWERDOWN));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int tiadc_resume(struct device *dev)
|
|
{
|
|
struct iio_dev *indio_dev = dev_get_drvdata(dev);
|
|
struct tiadc_device *adc_dev = iio_priv(indio_dev);
|
|
unsigned int restore;
|
|
|
|
/* Make sure ADC is powered up */
|
|
restore = tiadc_readl(adc_dev, REG_CTRL);
|
|
restore &= ~(CNTRLREG_POWERDOWN);
|
|
tiadc_writel(adc_dev, REG_CTRL, restore);
|
|
|
|
tiadc_step_config(adc_dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct dev_pm_ops tiadc_pm_ops = {
|
|
.suspend = tiadc_suspend,
|
|
.resume = tiadc_resume,
|
|
};
|
|
#define TIADC_PM_OPS (&tiadc_pm_ops)
|
|
#else
|
|
#define TIADC_PM_OPS NULL
|
|
#endif
|
|
|
|
static const struct of_device_id ti_adc_dt_ids[] = {
|
|
{ .compatible = "ti,am3359-adc", },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
|
|
|
|
static struct platform_driver tiadc_driver = {
|
|
.driver = {
|
|
.name = "TI-am335x-adc",
|
|
.owner = THIS_MODULE,
|
|
.pm = TIADC_PM_OPS,
|
|
.of_match_table = of_match_ptr(ti_adc_dt_ids),
|
|
},
|
|
.probe = tiadc_probe,
|
|
.remove = tiadc_remove,
|
|
};
|
|
module_platform_driver(tiadc_driver);
|
|
|
|
MODULE_DESCRIPTION("TI ADC controller driver");
|
|
MODULE_AUTHOR("Rachna Patil <rachna@ti.com>");
|
|
MODULE_LICENSE("GPL");
|