From nobody Sat Sep 21 14:46:20 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 71D6EC433FE for ; Tue, 11 Oct 2022 04:06:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229605AbiJKEGt (ORCPT ); Tue, 11 Oct 2022 00:06:49 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37866 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229656AbiJKEGe (ORCPT ); Tue, 11 Oct 2022 00:06:34 -0400 Received: from mail-pg1-x52d.google.com (mail-pg1-x52d.google.com [IPv6:2607:f8b0:4864:20::52d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E42695E654; Mon, 10 Oct 2022 21:06:31 -0700 (PDT) Received: by mail-pg1-x52d.google.com with SMTP id q9so11830175pgq.8; Mon, 10 Oct 2022 21:06:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=PtFOofl3HzPXQb6ejygWuIjg4jgLjKFGQaehtDjpwJY=; b=QkoFmwBwbigtLk25z0TOBfKJdz1JK3eeM6Um7ycq1Liq6t+asM4DOo+iZAEyJhWo2X ZtSYKbzOqcbywEzEViU5LTUGl4UxlFyd3wHwhk4av/lnZ/spcB7EabOSjV6K66Xz9fll jzJ85hafLMDsR6fTycCyoHnD+n9jMdX4Pduxi8OgxpUwCTWZuVqao4yib8fgczgIQ7/j njI4NZq0Dm9txODbW23AtC4W9ZFJJh4XkMk5BRT+YjxwuwFv0wcGoSdxoo5zKvXcAg4X 8ozyT+qd/PzyP9I7gudmC1iDBef4WqYZgnaSDGV0xIbxgzImD2zQckjaHGntnHRUTvw4 rEnw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=PtFOofl3HzPXQb6ejygWuIjg4jgLjKFGQaehtDjpwJY=; b=FaXfaQa64k4AeN8eJvbHTZwOhogTCI/Nm0oXXG+dIhBa1tEnhUATS30KVi0mqs5DgX 8jaE+CzvmZ0hdEDf27rHEMMvSAWSoq40wubQPRXVUdZEEt8wknagwYphWKapCyuB+8dD DP3ymSgE4kKEA4j2OjXX9QgJaaajJIQNwxa1o94XvhClvJ6Ta+ICaSfAJ0oM/pe+zw01 w17mtu4sidbznvudSJYDixkbo/Sc1/1LCjxyQtFTaviRMthvsJz88J7A9xZW2MDXsshf hdRPyOD5xUjURBaALWL5AGXSZC4xvoq4TiiQ11TdDB6o4AiM9gvyuKJ0f3UGy6pNUjOV Et+g== X-Gm-Message-State: ACrzQf1BJT85RPEqXyRQx9qYdjSuPoUQpFQxhVuXX+sr52W+xw8LKjio DgNt3hUyxbhGUWF3gt+sZlk= X-Google-Smtp-Source: AMsMyM5tdrhKLJCI37FPGwJPq5ca0cBlO60bI7zT04A6Xdt6i3bilwAA9kQsRS6hGBDLS14rJu/2BQ== X-Received: by 2002:a63:c4e:0:b0:45f:795:c20a with SMTP id 14-20020a630c4e000000b0045f0795c20amr16772567pgm.559.1665461191279; Mon, 10 Oct 2022 21:06:31 -0700 (PDT) Received: from RD-3580-24288.rt.l (114-137-131-130.emome-ip.hinet.net. [114.137.131.130]) by smtp.gmail.com with ESMTPSA id b8-20020a17090a7ac800b00205d70ccfeesm9755968pjl.33.2022.10.10.21.06.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Oct 2022 21:06:30 -0700 (PDT) From: ChiaEn Wu To: pavel@ucw.cz, matthias.bgg@gmail.com, jic23@kernel.org, lars@metafoo.de, andriy.shevchenko@linux.intel.com Cc: chiaen_wu@richtek.com, alice_chen@richtek.com, cy_huang@richtek.com, linux-leds@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-mediatek@lists.infradead.org, linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, szunichen@gmail.com, AngeloGioacchino Del Regno , Andy Shevchenko , Jonathan Cameron Subject: [PATCH v14 1/3] iio: adc: mt6370: Add MediaTek MT6370 support Date: Tue, 11 Oct 2022 12:05:45 +0800 Message-Id: <81ec58ae89030e48508d6810396de2679c40d26c.1665488982.git.chiaen_wu@richtek.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: ChiaEn Wu MediaTek MT6370 is a SubPMIC consisting of a single cell battery charger with ADC monitoring, RGB LEDs, dual channel flashlight, WLED backlight driver, display bias voltage supply, one general purpose LDO, and the USB Type-C & PD controller complies with the latest USB Type-C and PD standards. Add support for the MT6370 ADC driver for system monitoring, including charger current, voltage, and temperature. Reviewed-by: AngeloGioacchino Del Regno Reviewed-by: Andy Shevchenko Acked-by: Jonathan Cameron Signed-off-by: ChiaEn Wu --- v14 - Revise the scale value of 'VBUSDIV2' in 'mt6370_adc_read_scale()' (50 --> 10) - Revise the return value of 'TEMP_JC' in 'mt6370_adc_read_scale()' (return IIO_VAL_FRACTIONAL; --> return IIO_VAL_INT;) --- drivers/iio/adc/Kconfig | 12 ++ drivers/iio/adc/Makefile | 1 + drivers/iio/adc/mt6370-adc.c | 305 +++++++++++++++++++++++++++++++++++++++= ++++ 3 files changed, 318 insertions(+) create mode 100644 drivers/iio/adc/mt6370-adc.c diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig index 791612c..f4fdca8 100644 --- a/drivers/iio/adc/Kconfig +++ b/drivers/iio/adc/Kconfig @@ -752,6 +752,18 @@ config MEDIATEK_MT6360_ADC is used in smartphones and tablets and supports a 11 channel general purpose ADC. =20 +config MEDIATEK_MT6370_ADC + tristate "MediaTek MT6370 ADC driver" + depends on MFD_MT6370 + help + Say yes here to enable MediaTek MT6370 ADC support. + + This ADC driver provides 9 channels for system monitoring (charger + current, voltage, and temperature). + + This driver can also be built as a module. If so, the module + will be called "mt6370-adc". + config MEDIATEK_MT6577_AUXADC tristate "MediaTek AUXADC driver" depends on ARCH_MEDIATEK || COMPILE_TEST diff --git a/drivers/iio/adc/Makefile b/drivers/iio/adc/Makefile index 46caba7..953fada 100644 --- a/drivers/iio/adc/Makefile +++ b/drivers/iio/adc/Makefile @@ -69,6 +69,7 @@ obj-$(CONFIG_MCP320X) +=3D mcp320x.o obj-$(CONFIG_MCP3422) +=3D mcp3422.o obj-$(CONFIG_MCP3911) +=3D mcp3911.o obj-$(CONFIG_MEDIATEK_MT6360_ADC) +=3D mt6360-adc.o +obj-$(CONFIG_MEDIATEK_MT6370_ADC) +=3D mt6370-adc.o obj-$(CONFIG_MEDIATEK_MT6577_AUXADC) +=3D mt6577_auxadc.o obj-$(CONFIG_MEN_Z188_ADC) +=3D men_z188_adc.o obj-$(CONFIG_MESON_SARADC) +=3D meson_saradc.o diff --git a/drivers/iio/adc/mt6370-adc.c b/drivers/iio/adc/mt6370-adc.c new file mode 100644 index 0000000..bc62e5a --- /dev/null +++ b/drivers/iio/adc/mt6370-adc.c @@ -0,0 +1,305 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2022 Richtek Technology Corp. + * + * Author: ChiaEn Wu + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define MT6370_REG_CHG_CTRL3 0x113 +#define MT6370_REG_CHG_CTRL7 0x117 +#define MT6370_REG_CHG_ADC 0x121 +#define MT6370_REG_ADC_DATA_H 0x14C + +#define MT6370_ADC_START_MASK BIT(0) +#define MT6370_ADC_IN_SEL_MASK GENMASK(7, 4) +#define MT6370_AICR_ICHG_MASK GENMASK(7, 2) + +#define MT6370_AICR_100_mA 0x0 +#define MT6370_AICR_150_mA 0x1 +#define MT6370_AICR_200_mA 0x2 +#define MT6370_AICR_250_mA 0x3 +#define MT6370_AICR_300_mA 0x4 +#define MT6370_AICR_350_mA 0x5 + +#define MT6370_ICHG_100_mA 0x0 +#define MT6370_ICHG_200_mA 0x1 +#define MT6370_ICHG_300_mA 0x2 +#define MT6370_ICHG_400_mA 0x3 +#define MT6370_ICHG_500_mA 0x4 +#define MT6370_ICHG_600_mA 0x5 +#define MT6370_ICHG_700_mA 0x6 +#define MT6370_ICHG_800_mA 0x7 + +#define ADC_CONV_TIME_MS 35 +#define ADC_CONV_POLLING_TIME_US 1000 + +struct mt6370_adc_data { + struct device *dev; + struct regmap *regmap; + /* + * This mutex lock is for preventing the different ADC channels + * from being read at the same time. + */ + struct mutex adc_lock; +}; + +static int mt6370_adc_read_channel(struct mt6370_adc_data *priv, int chan, + unsigned long addr, int *val) +{ + unsigned int reg_val; + __be16 be_val; + int ret; + + mutex_lock(&priv->adc_lock); + + reg_val =3D MT6370_ADC_START_MASK | + FIELD_PREP(MT6370_ADC_IN_SEL_MASK, addr); + ret =3D regmap_write(priv->regmap, MT6370_REG_CHG_ADC, reg_val); + if (ret) + goto adc_unlock; + + msleep(ADC_CONV_TIME_MS); + + ret =3D regmap_read_poll_timeout(priv->regmap, + MT6370_REG_CHG_ADC, reg_val, + !(reg_val & MT6370_ADC_START_MASK), + ADC_CONV_POLLING_TIME_US, + ADC_CONV_TIME_MS * MILLI * 3); + if (ret) { + dev_err(priv->dev, "Failed to read ADC register (%d)\n", ret); + goto adc_unlock; + } + + ret =3D regmap_raw_read(priv->regmap, MT6370_REG_ADC_DATA_H, + &be_val, sizeof(be_val)); + if (ret) + goto adc_unlock; + + *val =3D be16_to_cpu(be_val); + ret =3D IIO_VAL_INT; + +adc_unlock: + mutex_unlock(&priv->adc_lock); + + return ret; +} + +static int mt6370_adc_read_scale(struct mt6370_adc_data *priv, + int chan, int *val1, int *val2) +{ + unsigned int reg_val; + int ret; + + switch (chan) { + case MT6370_CHAN_VBAT: + case MT6370_CHAN_VSYS: + case MT6370_CHAN_CHG_VDDP: + *val1 =3D 5; + return IIO_VAL_INT; + case MT6370_CHAN_IBUS: + ret =3D regmap_read(priv->regmap, MT6370_REG_CHG_CTRL3, ®_val); + if (ret) + return ret; + + reg_val =3D FIELD_GET(MT6370_AICR_ICHG_MASK, reg_val); + switch (reg_val) { + case MT6370_AICR_100_mA: + case MT6370_AICR_150_mA: + case MT6370_AICR_200_mA: + case MT6370_AICR_250_mA: + case MT6370_AICR_300_mA: + case MT6370_AICR_350_mA: + *val1 =3D 3350; + break; + default: + *val1 =3D 5000; + break; + } + + *val2 =3D 100; + + return IIO_VAL_FRACTIONAL; + case MT6370_CHAN_IBAT: + ret =3D regmap_read(priv->regmap, MT6370_REG_CHG_CTRL7, ®_val); + if (ret) + return ret; + + reg_val =3D FIELD_GET(MT6370_AICR_ICHG_MASK, reg_val); + switch (reg_val) { + case MT6370_ICHG_100_mA: + case MT6370_ICHG_200_mA: + case MT6370_ICHG_300_mA: + case MT6370_ICHG_400_mA: + *val1 =3D 2375; + break; + case MT6370_ICHG_500_mA: + case MT6370_ICHG_600_mA: + case MT6370_ICHG_700_mA: + case MT6370_ICHG_800_mA: + *val1 =3D 2680; + break; + default: + *val1 =3D 5000; + break; + } + + *val2 =3D 100; + + return IIO_VAL_FRACTIONAL; + case MT6370_CHAN_VBUSDIV5: + *val1 =3D 25; + return IIO_VAL_INT; + case MT6370_CHAN_VBUSDIV2: + *val1 =3D 10; + return IIO_VAL_INT; + case MT6370_CHAN_TS_BAT: + *val1 =3D 25; + *val2 =3D 10000; + return IIO_VAL_FRACTIONAL; + case MT6370_CHAN_TEMP_JC: + *val1 =3D 2000; + return IIO_VAL_INT; + default: + return -EINVAL; + } +} + +static int mt6370_adc_read_offset(struct mt6370_adc_data *priv, + int chan, int *val) +{ + *val =3D -20; + + return IIO_VAL_INT; +} + +static int mt6370_adc_read_raw(struct iio_dev *iio_dev, + const struct iio_chan_spec *chan, + int *val, int *val2, long mask) +{ + struct mt6370_adc_data *priv =3D iio_priv(iio_dev); + + switch (mask) { + case IIO_CHAN_INFO_RAW: + return mt6370_adc_read_channel(priv, chan->channel, + chan->address, val); + case IIO_CHAN_INFO_SCALE: + return mt6370_adc_read_scale(priv, chan->channel, val, val2); + case IIO_CHAN_INFO_OFFSET: + return mt6370_adc_read_offset(priv, chan->channel, val); + default: + return -EINVAL; + } +} + +static const char * const mt6370_channel_labels[MT6370_CHAN_MAX] =3D { + [MT6370_CHAN_VBUSDIV5] =3D "vbusdiv5", + [MT6370_CHAN_VBUSDIV2] =3D "vbusdiv2", + [MT6370_CHAN_VSYS] =3D "vsys", + [MT6370_CHAN_VBAT] =3D "vbat", + [MT6370_CHAN_TS_BAT] =3D "ts_bat", + [MT6370_CHAN_IBUS] =3D "ibus", + [MT6370_CHAN_IBAT] =3D "ibat", + [MT6370_CHAN_CHG_VDDP] =3D "chg_vddp", + [MT6370_CHAN_TEMP_JC] =3D "temp_jc", +}; + +static int mt6370_adc_read_label(struct iio_dev *iio_dev, + struct iio_chan_spec const *chan, char *label) +{ + return sysfs_emit(label, "%s\n", mt6370_channel_labels[chan->channel]); +} + +static const struct iio_info mt6370_adc_iio_info =3D { + .read_raw =3D mt6370_adc_read_raw, + .read_label =3D mt6370_adc_read_label, +}; + +#define MT6370_ADC_CHAN(_idx, _type, _addr, _extra_info) { \ + .type =3D _type, \ + .channel =3D MT6370_CHAN_##_idx, \ + .address =3D _addr, \ + .scan_index =3D MT6370_CHAN_##_idx, \ + .indexed =3D 1, \ + .info_mask_separate =3D BIT(IIO_CHAN_INFO_RAW) | \ + BIT(IIO_CHAN_INFO_SCALE) | \ + _extra_info, \ +} + +static const struct iio_chan_spec mt6370_adc_channels[] =3D { + MT6370_ADC_CHAN(VBUSDIV5, IIO_VOLTAGE, 1, 0), + MT6370_ADC_CHAN(VBUSDIV2, IIO_VOLTAGE, 2, 0), + MT6370_ADC_CHAN(VSYS, IIO_VOLTAGE, 3, 0), + MT6370_ADC_CHAN(VBAT, IIO_VOLTAGE, 4, 0), + MT6370_ADC_CHAN(TS_BAT, IIO_VOLTAGE, 6, 0), + MT6370_ADC_CHAN(IBUS, IIO_CURRENT, 8, 0), + MT6370_ADC_CHAN(IBAT, IIO_CURRENT, 9, 0), + MT6370_ADC_CHAN(CHG_VDDP, IIO_VOLTAGE, 11, 0), + MT6370_ADC_CHAN(TEMP_JC, IIO_TEMP, 12, BIT(IIO_CHAN_INFO_OFFSET)), +}; + +static int mt6370_adc_probe(struct platform_device *pdev) +{ + struct device *dev =3D &pdev->dev; + struct mt6370_adc_data *priv; + struct iio_dev *indio_dev; + struct regmap *regmap; + int ret; + + regmap =3D dev_get_regmap(pdev->dev.parent, NULL); + if (!regmap) + return dev_err_probe(dev, -ENODEV, "Failed to get regmap\n"); + + indio_dev =3D devm_iio_device_alloc(dev, sizeof(*priv)); + if (!indio_dev) + return -ENOMEM; + + priv =3D iio_priv(indio_dev); + priv->dev =3D dev; + priv->regmap =3D regmap; + mutex_init(&priv->adc_lock); + + ret =3D regmap_write(priv->regmap, MT6370_REG_CHG_ADC, 0); + if (ret) + return dev_err_probe(dev, ret, "Failed to reset ADC\n"); + + indio_dev->name =3D "mt6370-adc"; + indio_dev->info =3D &mt6370_adc_iio_info; + indio_dev->modes =3D INDIO_DIRECT_MODE; + indio_dev->channels =3D mt6370_adc_channels; + indio_dev->num_channels =3D ARRAY_SIZE(mt6370_adc_channels); + + return devm_iio_device_register(dev, indio_dev); +} + +static const struct of_device_id mt6370_adc_of_id[] =3D { + { .compatible =3D "mediatek,mt6370-adc", }, + {} +}; +MODULE_DEVICE_TABLE(of, mt6370_adc_of_id); + +static struct platform_driver mt6370_adc_driver =3D { + .driver =3D { + .name =3D "mt6370-adc", + .of_match_table =3D mt6370_adc_of_id, + }, + .probe =3D mt6370_adc_probe, +}; +module_platform_driver(mt6370_adc_driver); + +MODULE_AUTHOR("ChiaEn Wu "); +MODULE_DESCRIPTION("MT6370 ADC Driver"); +MODULE_LICENSE("GPL v2"); --=20 2.7.4