OpenE2K/linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
e70bdd81bf
linux/drivers/iio/adc/da9150-gpadc.c
Thomas Gleixner 2874c5fd28 treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 152 
Based on 1 normalized pattern(s):

  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 either version 2 of the license or at
  your option any later version

extracted by the scancode license scanner the SPDX license identifier

  GPL-2.0-or-later

has been chosen to replace the boilerplate/reference in 3029 file(s).

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Allison Randal <allison@lohutok.net>
Cc: linux-spdx@vger.kernel.org
Link: https://lkml.kernel.org/r/20190527070032.746973796@linutronix.de
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-05-30 11:26:32 -07:00

403 lines
10 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0-or-later
/*
* DA9150 GPADC Driver
*
* Copyright (c) 2014 Dialog Semiconductor
*
* Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com>
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/mutex.h>
#include <linux/completion.h>
#include <linux/iio/iio.h>
#include <linux/iio/machine.h>
#include <linux/iio/driver.h>
#include <linux/mfd/da9150/core.h>
#include <linux/mfd/da9150/registers.h>
/* Channels */
enum da9150_gpadc_hw_channel {
DA9150_GPADC_HW_CHAN_GPIOA_2V = 0,
DA9150_GPADC_HW_CHAN_GPIOA_2V_,
DA9150_GPADC_HW_CHAN_GPIOB_2V,
DA9150_GPADC_HW_CHAN_GPIOB_2V_,
DA9150_GPADC_HW_CHAN_GPIOC_2V,
DA9150_GPADC_HW_CHAN_GPIOC_2V_,
DA9150_GPADC_HW_CHAN_GPIOD_2V,
DA9150_GPADC_HW_CHAN_GPIOD_2V_,
DA9150_GPADC_HW_CHAN_IBUS_SENSE,
DA9150_GPADC_HW_CHAN_IBUS_SENSE_,
DA9150_GPADC_HW_CHAN_VBUS_DIV,
DA9150_GPADC_HW_CHAN_VBUS_DIV_,
DA9150_GPADC_HW_CHAN_ID,
DA9150_GPADC_HW_CHAN_ID_,
DA9150_GPADC_HW_CHAN_VSYS,
DA9150_GPADC_HW_CHAN_VSYS_,
DA9150_GPADC_HW_CHAN_GPIOA_6V,
DA9150_GPADC_HW_CHAN_GPIOA_6V_,
DA9150_GPADC_HW_CHAN_GPIOB_6V,
DA9150_GPADC_HW_CHAN_GPIOB_6V_,
DA9150_GPADC_HW_CHAN_GPIOC_6V,
DA9150_GPADC_HW_CHAN_GPIOC_6V_,
DA9150_GPADC_HW_CHAN_GPIOD_6V,
DA9150_GPADC_HW_CHAN_GPIOD_6V_,
DA9150_GPADC_HW_CHAN_VBAT,
DA9150_GPADC_HW_CHAN_VBAT_,
DA9150_GPADC_HW_CHAN_TBAT,
DA9150_GPADC_HW_CHAN_TBAT_,
DA9150_GPADC_HW_CHAN_TJUNC_CORE,
DA9150_GPADC_HW_CHAN_TJUNC_CORE_,
DA9150_GPADC_HW_CHAN_TJUNC_OVP,
DA9150_GPADC_HW_CHAN_TJUNC_OVP_,
};
enum da9150_gpadc_channel {
DA9150_GPADC_CHAN_GPIOA = 0,
DA9150_GPADC_CHAN_GPIOB,
DA9150_GPADC_CHAN_GPIOC,
DA9150_GPADC_CHAN_GPIOD,
DA9150_GPADC_CHAN_IBUS,
DA9150_GPADC_CHAN_VBUS,
DA9150_GPADC_CHAN_VSYS,
DA9150_GPADC_CHAN_VBAT,
DA9150_GPADC_CHAN_TBAT,
DA9150_GPADC_CHAN_TJUNC_CORE,
DA9150_GPADC_CHAN_TJUNC_OVP,
};
/* Private data */
struct da9150_gpadc {
struct da9150 *da9150;
struct device *dev;
struct mutex lock;
struct completion complete;
};
static irqreturn_t da9150_gpadc_irq(int irq, void *data)
{
struct da9150_gpadc *gpadc = data;
complete(&gpadc->complete);
return IRQ_HANDLED;
}
static int da9150_gpadc_read_adc(struct da9150_gpadc *gpadc, int hw_chan)
{
u8 result_regs[2];
int result;
mutex_lock(&gpadc->lock);
/* Set channel & enable measurement */
da9150_reg_write(gpadc->da9150, DA9150_GPADC_MAN,
(DA9150_GPADC_EN_MASK |
hw_chan << DA9150_GPADC_MUX_SHIFT));
/* Consume left-over completion from a previous timeout */
try_wait_for_completion(&gpadc->complete);
/* Check for actual completion */
wait_for_completion_timeout(&gpadc->complete, msecs_to_jiffies(5));
/* Read result and status from device */
da9150_bulk_read(gpadc->da9150, DA9150_GPADC_RES_A, 2, result_regs);
mutex_unlock(&gpadc->lock);
/* Check to make sure device really has completed reading */
if (result_regs[1] & DA9150_GPADC_RUN_MASK) {
dev_err(gpadc->dev, "Timeout on channel %d of GPADC\n",
hw_chan);
return -ETIMEDOUT;
}
/* LSBs - 2 bits */
result = (result_regs[1] & DA9150_GPADC_RES_L_MASK) >>
DA9150_GPADC_RES_L_SHIFT;
/* MSBs - 8 bits */
result |= result_regs[0] << DA9150_GPADC_RES_L_BITS;
return result;
}
static inline int da9150_gpadc_gpio_6v_voltage_now(int raw_val)
{
/* Convert to mV */
return (6 * ((raw_val * 1000) + 500)) / 1024;
}
static inline int da9150_gpadc_ibus_current_avg(int raw_val)
{
/* Convert to mA */
return (4 * ((raw_val * 1000) + 500)) / 2048;
}
static inline int da9150_gpadc_vbus_21v_voltage_now(int raw_val)
{
/* Convert to mV */
return (21 * ((raw_val * 1000) + 500)) / 1024;
}
static inline int da9150_gpadc_vsys_6v_voltage_now(int raw_val)
{
/* Convert to mV */
return (3 * ((raw_val * 1000) + 500)) / 512;
}
static int da9150_gpadc_read_processed(struct da9150_gpadc *gpadc, int channel,
int hw_chan, int *val)
{
int raw_val;
raw_val = da9150_gpadc_read_adc(gpadc, hw_chan);
if (raw_val < 0)
return raw_val;
switch (channel) {
case DA9150_GPADC_CHAN_GPIOA:
case DA9150_GPADC_CHAN_GPIOB:
case DA9150_GPADC_CHAN_GPIOC:
case DA9150_GPADC_CHAN_GPIOD:
*val = da9150_gpadc_gpio_6v_voltage_now(raw_val);
break;
case DA9150_GPADC_CHAN_IBUS:
*val = da9150_gpadc_ibus_current_avg(raw_val);
break;
case DA9150_GPADC_CHAN_VBUS:
*val = da9150_gpadc_vbus_21v_voltage_now(raw_val);
break;
case DA9150_GPADC_CHAN_VSYS:
*val = da9150_gpadc_vsys_6v_voltage_now(raw_val);
break;
default:
/* No processing for other channels so return raw value */
*val = raw_val;
break;
}
return IIO_VAL_INT;
}
static int da9150_gpadc_read_scale(int channel, int *val, int *val2)
{
switch (channel) {
case DA9150_GPADC_CHAN_VBAT:
*val = 2932;
*val2 = 1000;
return IIO_VAL_FRACTIONAL;
case DA9150_GPADC_CHAN_TJUNC_CORE:
case DA9150_GPADC_CHAN_TJUNC_OVP:
*val = 1000000;
*val2 = 4420;
return IIO_VAL_FRACTIONAL;
default:
return -EINVAL;
}
}
static int da9150_gpadc_read_offset(int channel, int *val)
{
switch (channel) {
case DA9150_GPADC_CHAN_VBAT:
*val = 1500000 / 2932;
return IIO_VAL_INT;
case DA9150_GPADC_CHAN_TJUNC_CORE:
case DA9150_GPADC_CHAN_TJUNC_OVP:
*val = -144;
return IIO_VAL_INT;
default:
return -EINVAL;
}
}
static int da9150_gpadc_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2, long mask)
{
struct da9150_gpadc *gpadc = iio_priv(indio_dev);
if ((chan->channel < DA9150_GPADC_CHAN_GPIOA) ||
(chan->channel > DA9150_GPADC_CHAN_TJUNC_OVP))
return -EINVAL;
switch (mask) {
case IIO_CHAN_INFO_RAW:
case IIO_CHAN_INFO_PROCESSED:
return da9150_gpadc_read_processed(gpadc, chan->channel,
chan->address, val);
case IIO_CHAN_INFO_SCALE:
return da9150_gpadc_read_scale(chan->channel, val, val2);
case IIO_CHAN_INFO_OFFSET:
return da9150_gpadc_read_offset(chan->channel, val);
default:
return -EINVAL;
}
}
static const struct iio_info da9150_gpadc_info = {
.read_raw = &da9150_gpadc_read_raw,
};
#define DA9150_GPADC_CHANNEL(_id, _hw_id, _type, chan_info, \
_ext_name) { \
.type = _type, \
.indexed = 1, \
.channel = DA9150_GPADC_CHAN_##_id, \
.address = DA9150_GPADC_HW_CHAN_##_hw_id, \
.info_mask_separate = chan_info, \
.extend_name = _ext_name, \
.datasheet_name = #_id, \
}
#define DA9150_GPADC_CHANNEL_RAW(_id, _hw_id, _type, _ext_name) \
DA9150_GPADC_CHANNEL(_id, _hw_id, _type, \
BIT(IIO_CHAN_INFO_RAW), _ext_name)
#define DA9150_GPADC_CHANNEL_SCALED(_id, _hw_id, _type, _ext_name) \
DA9150_GPADC_CHANNEL(_id, _hw_id, _type, \
BIT(IIO_CHAN_INFO_RAW) | \
BIT(IIO_CHAN_INFO_SCALE) | \
BIT(IIO_CHAN_INFO_OFFSET), \
_ext_name)
#define DA9150_GPADC_CHANNEL_PROCESSED(_id, _hw_id, _type, _ext_name) \
DA9150_GPADC_CHANNEL(_id, _hw_id, _type, \
BIT(IIO_CHAN_INFO_PROCESSED), _ext_name)
/* Supported channels */
static const struct iio_chan_spec da9150_gpadc_channels[] = {
DA9150_GPADC_CHANNEL_PROCESSED(GPIOA, GPIOA_6V, IIO_VOLTAGE, NULL),
DA9150_GPADC_CHANNEL_PROCESSED(GPIOB, GPIOB_6V, IIO_VOLTAGE, NULL),
DA9150_GPADC_CHANNEL_PROCESSED(GPIOC, GPIOC_6V, IIO_VOLTAGE, NULL),
DA9150_GPADC_CHANNEL_PROCESSED(GPIOD, GPIOD_6V, IIO_VOLTAGE, NULL),
DA9150_GPADC_CHANNEL_PROCESSED(IBUS, IBUS_SENSE, IIO_CURRENT, "ibus"),
DA9150_GPADC_CHANNEL_PROCESSED(VBUS, VBUS_DIV_, IIO_VOLTAGE, "vbus"),
DA9150_GPADC_CHANNEL_PROCESSED(VSYS, VSYS, IIO_VOLTAGE, "vsys"),
DA9150_GPADC_CHANNEL_SCALED(VBAT, VBAT, IIO_VOLTAGE, "vbat"),
DA9150_GPADC_CHANNEL_RAW(TBAT, TBAT, IIO_VOLTAGE, "tbat"),
DA9150_GPADC_CHANNEL_SCALED(TJUNC_CORE, TJUNC_CORE, IIO_TEMP,
"tjunc_core"),
DA9150_GPADC_CHANNEL_SCALED(TJUNC_OVP, TJUNC_OVP, IIO_TEMP,
"tjunc_ovp"),
};
/* Default maps used by da9150-charger */
static struct iio_map da9150_gpadc_default_maps[] = {
{
.consumer_dev_name = "da9150-charger",
.consumer_channel = "CHAN_IBUS",
.adc_channel_label = "IBUS",
},
{
.consumer_dev_name = "da9150-charger",
.consumer_channel = "CHAN_VBUS",
.adc_channel_label = "VBUS",
},
{
.consumer_dev_name = "da9150-charger",
.consumer_channel = "CHAN_TJUNC",
.adc_channel_label = "TJUNC_CORE",
},
{
.consumer_dev_name = "da9150-charger",
.consumer_channel = "CHAN_VBAT",
.adc_channel_label = "VBAT",
},
{},
};
static int da9150_gpadc_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct da9150 *da9150 = dev_get_drvdata(dev->parent);
struct da9150_gpadc *gpadc;
struct iio_dev *indio_dev;
int irq, ret;
indio_dev = devm_iio_device_alloc(dev, sizeof(*gpadc));
if (!indio_dev) {
dev_err(&pdev->dev, "Failed to allocate IIO device\n");
return -ENOMEM;
}
gpadc = iio_priv(indio_dev);
platform_set_drvdata(pdev, indio_dev);
gpadc->da9150 = da9150;
gpadc->dev = dev;
mutex_init(&gpadc->lock);
init_completion(&gpadc->complete);
irq = platform_get_irq_byname(pdev, "GPADC");
if (irq < 0) {
dev_err(dev, "Failed to get IRQ: %d\n", irq);
return irq;
}
ret = devm_request_threaded_irq(dev, irq, NULL, da9150_gpadc_irq,
IRQF_ONESHOT, "GPADC", gpadc);
if (ret) {
dev_err(dev, "Failed to request IRQ %d: %d\n", irq, ret);
return ret;
}
ret = iio_map_array_register(indio_dev, da9150_gpadc_default_maps);
if (ret) {
dev_err(dev, "Failed to register IIO maps: %d\n", ret);
return ret;
}
indio_dev->name = dev_name(dev);
indio_dev->dev.parent = dev;
indio_dev->dev.of_node = pdev->dev.of_node;
indio_dev->info = &da9150_gpadc_info;
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->channels = da9150_gpadc_channels;
indio_dev->num_channels = ARRAY_SIZE(da9150_gpadc_channels);
ret = iio_device_register(indio_dev);
if (ret) {
dev_err(dev, "Failed to register IIO device: %d\n", ret);
goto iio_map_unreg;
}
return 0;
iio_map_unreg:
iio_map_array_unregister(indio_dev);
return ret;
}
static int da9150_gpadc_remove(struct platform_device *pdev)
{
struct iio_dev *indio_dev = platform_get_drvdata(pdev);
iio_device_unregister(indio_dev);
iio_map_array_unregister(indio_dev);
return 0;
}
static struct platform_driver da9150_gpadc_driver = {
.driver = {
.name = "da9150-gpadc",
},
.probe = da9150_gpadc_probe,
.remove = da9150_gpadc_remove,
};
module_platform_driver(da9150_gpadc_driver);
MODULE_DESCRIPTION("GPADC Driver for DA9150");
MODULE_AUTHOR("Adam Thomson <Adam.Thomson.Opensource@diasemi.com>");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink