From: Lee Jones <lee.jones@linaro.org> To: "Opensource [Steve Twiss]" <stwiss.opensource@diasemi.com> Cc: Guenter Roeck <linux@roeck-us.net>, Jean Delvare <jdelvare@suse.de>, David Dajun Chen <david.chen@diasemi.com>, LINUX-DOC <linux-doc@vger.kernel.org>, LINUX-KERNEL <linux-kernel@vger.kernel.org>, LM-SENSORS <lm-sensors@lm-sensors.org>, Mark Brown <broonie@linaro.org>, Philipp Zabel <p.zabel@pengutronix.de>, Rob Landley <rob@landley.net>, Samuel Ortiz <sameo@linux.intel.com> Subject: Re: [RFC V1 1/3] hwmon: da9063: HWMON driver Date: Mon, 24 Mar 2014 07:52:21 +0000 [thread overview] Message-ID: <20140324075221.GF8541@lee--X1> (raw) In-Reply-To: <420d4f5c8436a66b511693531cfeda131258ce69.1395607051.git.stwiss.opensource@diasemi.com> > From: Opensource [Steve Twiss] <stwiss.opensource@diasemi.com> > > Add the HWMON driver for DA9063 > > Signed-off-by: Opensource [Steve Twiss] <stwiss.opensource@diasemi.com> > --- > > drivers/hwmon/Kconfig | 10 + > drivers/hwmon/Makefile | 1 + > drivers/hwmon/da9063-hwmon.c | 456 ++++++++++++++++++++++++++++++++++ > include/linux/mfd/da9063/registers.h | 34 +++ I'd prefer to see all values in hex, but this probably a preference thing rather than something which would prevent acceptance. For the MFD header changes: Acked-by: Lee Jones <lee.jones@linaro.org> > 4 files changed, 501 insertions(+) > create mode 100644 drivers/hwmon/da9063-hwmon.c > > diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig > index f288b60..68aa886 100644 > --- a/drivers/hwmon/Kconfig > +++ b/drivers/hwmon/Kconfig > @@ -391,6 +391,16 @@ config SENSORS_DA9055 > This driver can also be built as a module. If so, the module > will be called da9055-hwmon. > > +config SENSORS_DA9063 > + tristate "Dialog Semiconductor DA9063" > + depends on MFD_DA9063 > + help > + If you say yes here you get support for the hardware > + monitoring features of the DA9063 Power Management IC. > + > + This driver can also be built as a module. If so, the module > + will be called da9063-hwmon. > + > config SENSORS_I5K_AMB > tristate "FB-DIMM AMB temperature sensor on Intel 5000 series chipsets" > depends on PCI > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile > index c48f987..4174b07 100644 > --- a/drivers/hwmon/Makefile > +++ b/drivers/hwmon/Makefile > @@ -49,6 +49,7 @@ obj-$(CONFIG_SENSORS_ATXP1) += atxp1.o > obj-$(CONFIG_SENSORS_CORETEMP) += coretemp.o > obj-$(CONFIG_SENSORS_DA9052_ADC)+= da9052-hwmon.o > obj-$(CONFIG_SENSORS_DA9055)+= da9055-hwmon.o > +obj-$(CONFIG_SENSORS_DA9063) += da9063-hwmon.o > obj-$(CONFIG_SENSORS_DME1737) += dme1737.o > obj-$(CONFIG_SENSORS_DS620) += ds620.o > obj-$(CONFIG_SENSORS_DS1621) += ds1621.o > diff --git a/drivers/hwmon/da9063-hwmon.c b/drivers/hwmon/da9063-hwmon.c > new file mode 100644 > index 0000000..7756cb2 > --- /dev/null > +++ b/drivers/hwmon/da9063-hwmon.c > @@ -0,0 +1,456 @@ > +/* da9063-hwmon.c - Hardware monitor support for DA9063 > + * Copyright (C) 2014 Dialog Semiconductor Ltd. > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Library General Public > + * License as published by the Free Software Foundation; either > + * version 2 of the License, or (at your option) any later version. > + * > + * This library is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * Library General Public License for more details. > + */ > + > +#include <linux/kernel.h> > +#include <linux/module.h> > +#include <linux/err.h> > +#include <linux/delay.h> > +#include <linux/init.h> > +#include <linux/slab.h> > +#include <linux/string.h> > +#include <linux/platform_device.h> > +#include <linux/hwmon.h> > +#include <linux/hwmon-sysfs.h> > +#include <linux/regmap.h> > +#include <linux/mfd/da9063/core.h> > +#include <linux/mfd/da9063/pdata.h> > + > +#define DA9063_ADC_RES (1 << (DA9063_ADC_RES_L_BITS + DA9063_ADC_RES_M_BITS)) > +#define DA9063_ADC_MAX (DA9063_ADC_RES - 1) > +#define DA9063_2V5 2500 > +#define DA9063_5V0 5000 > +#define DA9063_5V5 5500 > +#define DA9063_TJUNC_M -420 > +#define DA9063_TJUNC_C -812 > +#define DA9063_VBBAT_M 2048 > + > +enum da9063_adc { > + DA9063_CHAN_VSYS = DA9063_ADC_MUX_VSYS, > + DA9063_CHAN_ADCIN1 = DA9063_ADC_MUX_ADCIN1, > + DA9063_CHAN_ADCIN2 = DA9063_ADC_MUX_ADCIN2, > + DA9063_CHAN_ADCIN3 = DA9063_ADC_MUX_ADCIN3, > + DA9063_CHAN_TJUNC = DA9063_ADC_MUX_T_SENSE, > + DA9063_CHAN_VBBAT = DA9063_ADC_MUX_VBBAT, > + DA9063_CHAN_LDO_G1 = DA9063_ADC_MUX_LDO_G1, > + DA9063_CHAN_LDO_G2 = DA9063_ADC_MUX_LDO_G2, > + DA9063_CHAN_LDO_G3 = DA9063_ADC_MUX_LDO_G3 > +}; > + > +struct da9063_hwmon { > + struct da9063 *da9063; > + struct device *classdev; > + struct mutex hwmon_mutex; > + struct completion adc_ready; > + signed char tjunc_offset; > + int irq; > +}; > + > +static int da9063_adc_convert(struct da9063_hwmon *hwmon, int channel, > + int *value) > +{ > + int val = *value; > + int ret = 0; > + > + switch (channel) { > + case DA9063_CHAN_ADCIN1: > + case DA9063_CHAN_ADCIN2: > + case DA9063_CHAN_ADCIN3: > + val = (DA9063_2V5 * val) / DA9063_ADC_MAX; > + break; > + case DA9063_CHAN_VSYS: > + val = ((DA9063_5V5 - DA9063_2V5) * val) / DA9063_ADC_MAX + > + DA9063_2V5; > + break; > + case DA9063_CHAN_TJUNC: > + val -= hwmon->tjunc_offset; > + val = (DA9063_TJUNC_M * (val + DA9063_TJUNC_C)) >> 10; > + break; > + case DA9063_CHAN_VBBAT: > + val = (DA9063_5V0 * val) / DA9063_ADC_MAX; > + break; > + default: > + ret = -EINVAL; > + goto err_convert; > + } > + > + *value = val; > +err_convert: > + return ret; > +} > + > +static int da9063_adc_current_switch(struct da9063_hwmon *hwmon, int channel, > + bool on) > +{ > + int ret; > + unsigned int val; > + unsigned int mask; > + > + switch (channel) { > + case DA9063_CHAN_ADCIN1: > + mask = DA9063_ADC_AD1_ISRC_EN; > + break; > + case DA9063_CHAN_ADCIN2: > + mask = DA9063_ADC_AD2_ISRC_EN; > + break; > + case DA9063_CHAN_ADCIN3: > + mask = DA9063_ADC_AD3_ISRC_EN; > + break; > + default: > + ret = -EINVAL; > + goto err_switch; > + } > + > + if (on) > + val = mask; > + else > + val = ~mask; > + > + ret = regmap_update_bits(hwmon->da9063->regmap, DA9063_REG_ADC_CONT, > + mask, val); > +err_switch: > + return ret; > + > +} > + > +static int da9063_adc_manual_read(struct da9063_hwmon *hwmon, int channel) > +{ > + int ret; > + unsigned char val; > + unsigned char data[2]; > + int adc_man; > + > + mutex_lock(&hwmon->hwmon_mutex); > + > + init_completion(&hwmon->adc_ready); > + > + val = (channel & DA9063_ADC_MUX_MASK) | DA9063_ADC_MAN; > + ret = regmap_update_bits(hwmon->da9063->regmap, DA9063_REG_ADC_MAN, > + DA9063_ADC_MUX_MASK | DA9063_ADC_MAN, val); > + if (ret < 0) > + goto err_mread; > + > + ret = wait_for_completion_timeout(&hwmon->adc_ready, > + msecs_to_jiffies(1000)); > + if (ret == 0) { > + ret = -ETIMEDOUT; > + goto err_mread; > + } > + > + ret = regmap_read(hwmon->da9063->regmap, DA9063_REG_ADC_MAN, &adc_man); > + if (ret < 0) > + goto err_mread; > + > + /* data value is not ready */ > + if (adc_man & DA9063_ADC_MAN == 0) { > + ret = -EINVAL; > + goto err_mread; > + } > + > + ret = regmap_bulk_read(hwmon->da9063->regmap, > + DA9063_REG_ADC_RES_L, data, 2); > + if (ret < 0) > + goto err_mread; > + > + ret = (data[0] & DA9063_ADC_RES_L_MASK) >> DA9063_ADC_RES_L_SHIFT; > + ret |= data[1] << DA9063_ADC_RES_L_BITS; > +err_mread: > + mutex_unlock(&hwmon->hwmon_mutex); > + return ret; > +} > + > +static irqreturn_t da9063_hwmon_irq_handler(int irq, void *irq_data) > +{ > + struct da9063_hwmon *hwmon = irq_data; > + complete(&hwmon->adc_ready); > + return IRQ_HANDLED; > +} > + > +static ssize_t da9063_adc_read(struct device *dev, > + struct device_attribute *devattr, char *buf) > +{ > + struct da9063_hwmon *hwmon = dev_get_drvdata(dev); > + int channel = to_sensor_dev_attr(devattr)->index; > + int val; > + int ret; > + > + switch (channel) { > + case DA9063_CHAN_ADCIN1: > + case DA9063_CHAN_ADCIN2: > + case DA9063_CHAN_ADCIN3: > + /* fallthrough for ADC measures */ > + ret = da9063_adc_current_switch(hwmon, channel, true); > + if (ret < 0) > + goto err_read; > + > + val = da9063_adc_manual_read(hwmon, channel); > + if (val < 0) { > + ret = val; > + if (ret == -EINVAL) > + dev_err(dev, "Conversion was not completed\n"); > + else > + dev_err(dev, "ADC read error %d\n", ret); > + goto err_read; > + } > + > + ret = da9063_adc_current_switch(hwmon, channel, false); > + if (ret < 0) { > + dev_err(dev, "Could not switch current\n"); > + goto err_read; > + } > + break; > + > + case DA9063_CHAN_VSYS: > + case DA9063_CHAN_TJUNC: > + case DA9063_CHAN_VBBAT: > + /* fallthrough for internal measures */ > + val = da9063_adc_manual_read(hwmon, channel); > + if (val < 0) { > + dev_err(dev, "ADC read error %d\n", val); > + return val; > + } > + break; > + > + default: > + /* error case */ > + ret = -EINVAL; > + goto err_read; > + } > + > + ret = da9063_adc_convert(hwmon, channel, &val); > + if (ret < 0) { > + dev_err(dev, "Failed to convert ADC value %d\n", ret); > + goto err_read; > + } > + > + return sprintf(buf, "%d\n", val); > +err_read: > + return ret; > +} > + > +static ssize_t da9063_show_name(struct device *dev, > + struct device_attribute *attr, char *buf) > +{ > + return sprintf(buf, DA9063_DRVNAME_HWMON "\n"); > +} > + > +static ssize_t da9063_show_label(struct device *dev, > + struct device_attribute *devattr, char *buf) > +{ > + int channel = to_sensor_dev_attr(devattr)->index; > + char *label; > + > + switch (channel) { > + case DA9063_CHAN_VSYS: > + label = "VSYS"; > + break; > + case DA9063_CHAN_ADCIN1: > + label = "ADCIN1"; > + break; > + case DA9063_CHAN_ADCIN2: > + label = "ADCIN2"; > + break; > + case DA9063_CHAN_ADCIN3: > + label = "ADCIN3"; > + break; > + case DA9063_CHAN_TJUNC: > + label = "TJUNC"; > + break; > + case DA9063_CHAN_VBBAT: > + label = "VBBAT"; > + break; > + default: > + label = "UNKNOWN"; > + } > + > + return sprintf(buf, "%s\n", label); > +} > + > +static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, > + da9063_adc_read, NULL, DA9063_CHAN_VSYS); > +static SENSOR_DEVICE_ATTR(in0_label, S_IRUGO, > + da9063_show_label, NULL, DA9063_CHAN_VSYS); > + > +static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, > + da9063_adc_read, NULL, DA9063_CHAN_ADCIN1); > +static SENSOR_DEVICE_ATTR(in1_label, S_IRUGO, > + da9063_show_label, NULL, DA9063_CHAN_ADCIN1); > + > +static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, > + da9063_adc_read, NULL, DA9063_CHAN_ADCIN2); > +static SENSOR_DEVICE_ATTR(in2_label, S_IRUGO, > + da9063_show_label, NULL, DA9063_CHAN_ADCIN2); > + > +static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, > + da9063_adc_read, NULL, DA9063_CHAN_ADCIN3); > +static SENSOR_DEVICE_ATTR(in3_label, S_IRUGO, > + da9063_show_label, NULL, DA9063_CHAN_ADCIN3); > + > +static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, > + da9063_adc_read, NULL, DA9063_CHAN_VBBAT); > +static SENSOR_DEVICE_ATTR(in4_label, S_IRUGO, > + da9063_show_label, NULL, DA9063_CHAN_VBBAT); > + > +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, > + da9063_adc_read, NULL, DA9063_CHAN_TJUNC); > + > +static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, > + da9063_show_label, NULL, DA9063_CHAN_TJUNC); > + > +static DEVICE_ATTR(name, S_IRUGO, da9063_show_name, NULL); > + > +static struct attribute *da9063_attributes[] = { > + &dev_attr_name.attr, > + &sensor_dev_attr_in0_input.dev_attr.attr, > + &sensor_dev_attr_in0_label.dev_attr.attr, > + &sensor_dev_attr_in1_input.dev_attr.attr, > + &sensor_dev_attr_in1_label.dev_attr.attr, > + &sensor_dev_attr_in2_input.dev_attr.attr, > + &sensor_dev_attr_in2_label.dev_attr.attr, > + &sensor_dev_attr_in3_input.dev_attr.attr, > + &sensor_dev_attr_in3_label.dev_attr.attr, > + &sensor_dev_attr_in4_input.dev_attr.attr, > + &sensor_dev_attr_in4_label.dev_attr.attr, > + &sensor_dev_attr_temp1_input.dev_attr.attr, > + &sensor_dev_attr_temp1_label.dev_attr.attr, > + NULL > +}; > + > +static const struct attribute_group da9063_attr_group = { > + .attrs = da9063_attributes, > +}; > + > +static int da9063_hwmon_probe(struct platform_device *pdev) > +{ > + struct da9063 *da9063 = dev_get_drvdata(pdev->dev.parent); > + struct da9063_pdata *pdata = da9063->dev->platform_data; > + struct da9063_hwmon *hwmon; > + int ret; > + unsigned int val; > + > + hwmon = devm_kzalloc(&pdev->dev, sizeof(struct da9063_hwmon), > + GFP_KERNEL); > + if (!hwmon) > + return -ENOMEM; > + > + mutex_init(&hwmon->hwmon_mutex); > + init_completion(&hwmon->adc_ready); > + hwmon->da9063 = da9063; > + > + /* enable the ADC functions for GPIO 0,1,2 */ > + val = (DA9063_GPIO0_PIN_ADCIN1 << DA9063_GPIO0_PIN_MASK_SHIFT | > + DA9063_GPIO1_PIN_ADCIN2_COMP << DA9063_GPIO1_PIN_MASK_SHIFT); > + ret = regmap_update_bits(hwmon->da9063->regmap, DA9063_REG_GPIO_0_1, > + (DA9063_GPIO0_PIN_MASK | > + DA9063_GPIO1_PIN_MASK), val); > + if (ret < 0) { > + dev_err(&pdev->dev, > + "Failed to alter the ADCIN 1,2 bits for the GPIO 0,1 register\n"); > + return -EIO; > + } > + > + val = DA9063_GPIO2_PIN_ADCIN3 << DA9063_GPIO2_PIN_MASK_SHIFT; > + ret = regmap_update_bits(hwmon->da9063->regmap, DA9063_REG_GPIO_2_3, > + DA9063_GPIO2_PIN_MASK, val); > + if (ret < 0) { > + dev_err(&pdev->dev, > + "Failed to alter the ADCIN 3 bits for the GPIO 2,3 register\n"); > + return -EIO; > + } > + > + /* debounce ADC I settings */ > + val = (DA9063_ADCIN1_DEB_ON << DA9063_REG_ADCIN1_DEB_SHIFT | > + DA9063_ADCIN2_DEB_ON << DA9063_REG_ADCIN2_DEB_SHIFT | > + DA9063_ADCIN3_DEB_ON << DA9063_REG_ADCIN3_DEB_SHIFT); > + ret = regmap_update_bits(hwmon->da9063->regmap, DA9063_REG_ADC_CFG, > + (DA9063_REG_ADCIN1_DEB_MASK | > + DA9063_REG_ADCIN2_DEB_MASK | > + DA9063_REG_ADCIN3_DEB_MASK), val); > + if (ret < 0) { > + dev_err(&pdev->dev, > + "Failed to alter the ADC configuration register\n"); > + return -EIO; > + } > + > + /* set up the current configurations */ > + val = (pdata->hwmon_pdata->adcin1_cur << DA9063_REG_ADCIN1_CUR_SHIFT | > + pdata->hwmon_pdata->adcin2_cur << DA9063_REG_ADCIN2_CUR_SHIFT | > + pdata->hwmon_pdata->adcin3_cur << DA9063_REG_ADCIN3_CUR_SHIFT); > + ret = regmap_update_bits(hwmon->da9063->regmap, DA9063_REG_ADC_CFG, > + (DA9063_REG_ADCIN1_CUR_MASK | > + DA9063_REG_ADCIN2_CUR_MASK | > + DA9063_REG_ADCIN3_CUR_MASK), val); > + > + ret = regmap_read(da9063->regmap, DA9063_REG_ADC_CFG, &val); > + if (ret < 0) { > + dev_err(&pdev->dev, > + "Failed to read read the ADC configuration register\n"); > + return -EIO; > + } > + > + hwmon->irq = platform_get_irq_byname(pdev, DA9063_DRVNAME_HWMON); > + if (hwmon->irq < 0) > + return hwmon->irq; > + > + ret = devm_request_threaded_irq(&pdev->dev, hwmon->irq, NULL, > + da9063_hwmon_irq_handler, > + IRQF_TRIGGER_LOW | IRQF_ONESHOT, > + "HWMON", hwmon); > + if (ret) { > + dev_err(&pdev->dev, "Failed to request IRQ.\n"); > + return ret; > + } > + > + platform_set_drvdata(pdev, hwmon); > + > + /* set trim temperature offset to value read at startup */ > + hwmon->tjunc_offset = (signed char)hwmon->da9063->t_offset; > + > + ret = sysfs_create_group(&pdev->dev.kobj, &da9063_attr_group); > + if (ret) > + return ret; > + > + hwmon->classdev = hwmon_device_register(&pdev->dev); > + if (IS_ERR(hwmon->classdev)) { > + sysfs_remove_group(&pdev->dev.kobj, &da9063_attr_group); > + return PTR_ERR(hwmon->classdev); > + } > + > + return 0; > +} > + > +static int da9063_hwmon_remove(struct platform_device *pdev) > +{ > + struct da9063_hwmon *hwmon = platform_get_drvdata(pdev); > + > + hwmon_device_unregister(hwmon->classdev); > + sysfs_remove_group(&pdev->dev.kobj, &da9063_attr_group); > + > + return 0; > +} > + > +static struct platform_driver da9063_hwmon_driver = { > + .probe = da9063_hwmon_probe, > + .remove = da9063_hwmon_remove, > + .driver = { > + .name = DA9063_DRVNAME_HWMON, > + .owner = THIS_MODULE, > + }, > +}; > + > +module_platform_driver(da9063_hwmon_driver); > + > +MODULE_DESCRIPTION("Hardware monitor support device driver for Dialog DA9063"); > +MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>"); > +MODULE_LICENSE("GPL v2"); > +MODULE_ALIAS("platform:" DA9063_DRVNAME_HWMON); > diff --git a/include/linux/mfd/da9063/registers.h b/include/linux/mfd/da9063/registers.h > index 09a85c6..922371b 100644 > --- a/include/linux/mfd/da9063/registers.h > +++ b/include/linux/mfd/da9063/registers.h > @@ -474,6 +474,7 @@ > > /* DA9063_REG_GPIO_0_1 (addr=0x15) */ > #define DA9063_GPIO0_PIN_MASK 0x03 > +#define DA9063_GPIO0_PIN_MASK_SHIFT 0 > #define DA9063_GPIO0_PIN_ADCIN1 0x00 > #define DA9063_GPIO0_PIN_GPI 0x01 > #define DA9063_GPIO0_PIN_GPO_OD 0x02 > @@ -485,6 +486,7 @@ > #define DA9063_GPIO0_TYPE_GPO_VDD_IO2 0x04 > #define DA9063_GPIO0_NO_WAKEUP 0x08 > #define DA9063_GPIO1_PIN_MASK 0x30 > +#define DA9063_GPIO1_PIN_MASK_SHIFT 4 > #define DA9063_GPIO1_PIN_ADCIN2_COMP 0x00 > #define DA9063_GPIO1_PIN_GPI 0x10 > #define DA9063_GPIO1_PIN_GPO_OD 0x20 > @@ -498,6 +500,7 @@ > > /* DA9063_REG_GPIO_2_3 (addr=0x16) */ > #define DA9063_GPIO2_PIN_MASK 0x03 > +#define DA9063_GPIO2_PIN_MASK_SHIFT 0 > #define DA9063_GPIO2_PIN_ADCIN3 0x00 > #define DA9063_GPIO2_PIN_GPI 0x01 > #define DA9063_GPIO2_PIN_GPO_PSS 0x02 > @@ -813,6 +816,7 @@ > #define DA9063_VSYS_VAL_BASE 0x00 > > /* DA9063_REG_ADC_RES_L (addr=0x37) */ > +#define DA9063_ADC_RES_L_SHIFT 6 > #define DA9063_ADC_RES_L_BITS 2 > #define DA9063_ADC_RES_L_MASK 0xC0 > > @@ -979,6 +983,36 @@ > #define DA9063_GPIO_DIM 0x80 > #define DA9063_GPIO_PWM_MASK 0x7F > > +/* DA9063_REG_ADC_CFG (addr=0xC9) */ > +#define DA9063_REG_ADCIN1_CUR_MASK 0x03 > +#define DA9063_REG_ADCIN1_CUR_SHIFT 0 > +#define DA9063_ADCIN1_CUR_1UA 0x00 > +#define DA9063_ADCIN1_CUR_2UA 0x01 > +#define DA9063_ADCIN1_CUR_10UA 0x02 > +#define DA9063_ADCIN1_CUR_40UA 0x03 > +#define DA9063_REG_ADCIN2_CUR_MASK 0x0C > +#define DA9063_REG_ADCIN2_CUR_SHIFT 2 > +#define DA9063_ADCIN2_CUR_1UA 0x00 > +#define DA9063_ADCIN2_CUR_2UA 0x01 > +#define DA9063_ADCIN2_CUR_10UA 0x02 > +#define DA9063_ADCIN2_CUR_40UA 0x03 > +#define DA9063_REG_ADCIN3_CUR_MASK 0x10 > +#define DA9063_REG_ADCIN3_CUR_SHIFT 4 > +#define DA9063_ADCIN3_CUR_10UA 0x00 > +#define DA9063_ADCIN3_CUR_40UA 0x01 > +#define DA9063_REG_ADCIN1_DEB_MASK 0x20 > +#define DA9063_REG_ADCIN1_DEB_SHIFT 5 > +#define DA9063_ADCIN1_DEB_OFF 0x00 > +#define DA9063_ADCIN1_DEB_ON 0x01 > +#define DA9063_REG_ADCIN2_DEB_MASK 0x40 > +#define DA9063_REG_ADCIN2_DEB_SHIFT 6 > +#define DA9063_ADCIN2_DEB_OFF 0x00 > +#define DA9063_ADCIN2_DEB_ON 0x01 > +#define DA9063_REG_ADCIN3_DEB_MASK 0x80 > +#define DA9063_REG_ADCIN3_DEB_SHIFT 7 > +#define DA9063_ADCIN3_DEB_OFF 0x00 > +#define DA9063_ADCIN3_DEB_ON 0x01 > + > /* DA9063_REG_CONFIG_H (addr=0x10D) */ > #define DA9063_PWM_CLK_MASK 0x01 > #define DA9063_PWM_CLK_PWM2MHZ 0x00 -- Lee Jones Linaro STMicroelectronics Landing Team Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog
WARNING: multiple messages have this Message-ID (diff)
From: Lee Jones <lee.jones@linaro.org> To: "Opensource [Steve Twiss]" <stwiss.opensource@diasemi.com> Cc: Guenter Roeck <linux@roeck-us.net>, Jean Delvare <jdelvare@suse.de>, David Dajun Chen <david.chen@diasemi.com>, LINUX-DOC <linux-doc@vger.kernel.org>, LINUX-KERNEL <linux-kernel@vger.kernel.org>, LM-SENSORS <lm-sensors@lm-sensors.org>, Mark Brown <broonie@linaro.org>, Philipp Zabel <p.zabel@pengutronix.de>, Rob Landley <rob@landley.net>, Samuel Ortiz <sameo@linux.intel.com> Subject: Re: [lm-sensors] [RFC V1 1/3] hwmon: da9063: HWMON driver Date: Mon, 24 Mar 2014 07:52:21 +0000 [thread overview] Message-ID: <20140324075221.GF8541@lee--X1> (raw) In-Reply-To: <420d4f5c8436a66b511693531cfeda131258ce69.1395607051.git.stwiss.opensource@diasemi.com> PiBGcm9tOiBPcGVuc291cmNlIFtTdGV2ZSBUd2lzc10gPHN0d2lzcy5vcGVuc291cmNlQGRpYXNl bWkuY29tPgo+IAo+IEFkZCB0aGUgSFdNT04gZHJpdmVyIGZvciBEQTkwNjMKPiAKPiBTaWduZWQt b2ZmLWJ5OiBPcGVuc291cmNlIFtTdGV2ZSBUd2lzc10gPHN0d2lzcy5vcGVuc291cmNlQGRpYXNl bWkuY29tPgo+IC0tLQo+IAo+ICBkcml2ZXJzL2h3bW9uL0tjb25maWcgICAgICAgICAgICAgICAg fCAgIDEwICsKPiAgZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgICAgICAgICAgIHwgICAgMSAr Cj4gIGRyaXZlcnMvaHdtb24vZGE5MDYzLWh3bW9uLmMgICAgICAgICB8ICA0NTYgKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBpbmNsdWRlL2xpbnV4L21mZC9kYTkwNjMvcmVn aXN0ZXJzLmggfCAgIDM0ICsrKwoKSSdkIHByZWZlciB0byBzZWUgYWxsIHZhbHVlcyBpbiBoZXgs IGJ1dCB0aGlzIHByb2JhYmx5IGEgcHJlZmVyZW5jZQp0aGluZyByYXRoZXIgdGhhbiBzb21ldGhp bmcgd2hpY2ggd291bGQgcHJldmVudCBhY2NlcHRhbmNlLgoKRm9yIHRoZSBNRkQgaGVhZGVyIGNo YW5nZXM6CiAgQWNrZWQtYnk6IExlZSBKb25lcyA8bGVlLmpvbmVzQGxpbmFyby5vcmc+Cgo+ICA0 IGZpbGVzIGNoYW5nZWQsIDUwMSBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2h3bW9uL2RhOTA2My1od21vbi5jCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdt b24vS2NvbmZpZyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IGluZGV4IGYyODhiNjAuLjY4YWE4 ODYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4gKysrIGIvZHJpdmVycy9o d21vbi9LY29uZmlnCj4gQEAgLTM5MSw2ICszOTEsMTYgQEAgY29uZmlnIFNFTlNPUlNfREE5MDU1 Cj4gIAkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEgbW9kdWxlLiAgSWYgc28s IHRoZSBtb2R1bGUKPiAgCSAgd2lsbCBiZSBjYWxsZWQgZGE5MDU1LWh3bW9uLgo+ICAKPiArY29u ZmlnIFNFTlNPUlNfREE5MDYzCj4gKwl0cmlzdGF0ZSAiRGlhbG9nIFNlbWljb25kdWN0b3IgREE5 MDYzIgo+ICsJZGVwZW5kcyBvbiBNRkRfREE5MDYzCj4gKwloZWxwCj4gKwkgIElmIHlvdSBzYXkg eWVzIGhlcmUgeW91IGdldCBzdXBwb3J0IGZvciB0aGUgaGFyZHdhcmUKPiArCSAgbW9uaXRvcmlu ZyBmZWF0dXJlcyBvZiB0aGUgREE5MDYzIFBvd2VyIE1hbmFnZW1lbnQgSUMuCj4gKwo+ICsJICBU aGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYgc28sIHRoZSBtb2R1 bGUKPiArCSAgd2lsbCBiZSBjYWxsZWQgZGE5MDYzLWh3bW9uLgo+ICsKPiAgY29uZmlnIFNFTlNP UlNfSTVLX0FNQgo+ICAJdHJpc3RhdGUgIkZCLURJTU0gQU1CIHRlbXBlcmF0dXJlIHNlbnNvciBv biBJbnRlbCA1MDAwIHNlcmllcyBjaGlwc2V0cyIKPiAgCWRlcGVuZHMgb24gUENJCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4g aW5kZXggYzQ4Zjk4Ny4uNDE3NGIwNyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2Vm aWxlCj4gKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+IEBAIC00OSw2ICs0OSw3IEBAIG9i ai0kKENPTkZJR19TRU5TT1JTX0FUWFAxKQkrPSBhdHhwMS5vCj4gIG9iai0kKENPTkZJR19TRU5T T1JTX0NPUkVURU1QKQkrPSBjb3JldGVtcC5vCj4gIG9iai0kKENPTkZJR19TRU5TT1JTX0RBOTA1 Ml9BREMpKz0gZGE5MDUyLWh3bW9uLm8KPiAgb2JqLSQoQ09ORklHX1NFTlNPUlNfREE5MDU1KSs9 IGRhOTA1NS1od21vbi5vCj4gK29iai0kKENPTkZJR19TRU5TT1JTX0RBOTA2MykJKz0gZGE5MDYz LWh3bW9uLm8KPiAgb2JqLSQoQ09ORklHX1NFTlNPUlNfRE1FMTczNykJKz0gZG1lMTczNy5vCj4g IG9iai0kKENPTkZJR19TRU5TT1JTX0RTNjIwKQkrPSBkczYyMC5vCj4gIG9iai0kKENPTkZJR19T RU5TT1JTX0RTMTYyMSkJKz0gZHMxNjIxLm8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9k YTkwNjMtaHdtb24uYyBiL2RyaXZlcnMvaHdtb24vZGE5MDYzLWh3bW9uLmMKPiBuZXcgZmlsZSBt b2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLjc3NTZjYjIKPiAtLS0gL2Rldi9udWxsCj4gKysr IGIvZHJpdmVycy9od21vbi9kYTkwNjMtaHdtb24uYwo+IEBAIC0wLDAgKzEsNDU2IEBACj4gKy8q IGRhOTA2My1od21vbi5jIC0gSGFyZHdhcmUgbW9uaXRvciBzdXBwb3J0IGZvciBEQTkwNjMKPiAr ICogQ29weXJpZ2h0IChDKSAyMDE0IERpYWxvZyBTZW1pY29uZHVjdG9yIEx0ZC4KPiArICoKPiAr ICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgo+ICsgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYwo+ICsgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKPiArICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgo+ICsgKgo+ICsgKiBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1 bCwKPiArICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKPiArICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKPiArICogTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4 L2tlcm5lbC5oPgo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51 eC9lcnIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9p bml0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zdHJp bmcuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgo+ICsjaW5jbHVkZSA8 bGludXgvaHdtb24uaD4KPiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLXN5c2ZzLmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9yZWdtYXAuaD4KPiArI2luY2x1ZGUgPGxpbnV4L21mZC9kYTkwNjMvY29yZS5o Pgo+ICsjaW5jbHVkZSA8bGludXgvbWZkL2RhOTA2My9wZGF0YS5oPgo+ICsKPiArI2RlZmluZSBE QTkwNjNfQURDX1JFUwkoMSA8PCAoREE5MDYzX0FEQ19SRVNfTF9CSVRTICsgREE5MDYzX0FEQ19S RVNfTV9CSVRTKSkKPiArI2RlZmluZSBEQTkwNjNfQURDX01BWAkoREE5MDYzX0FEQ19SRVMgLSAx KQo+ICsjZGVmaW5lIERBOTA2M18yVjUJMjUwMAo+ICsjZGVmaW5lIERBOTA2M181VjAJNTAwMAo+ ICsjZGVmaW5lIERBOTA2M181VjUJNTUwMAo+ICsjZGVmaW5lIERBOTA2M19USlVOQ19NCS00MjAK PiArI2RlZmluZSBEQTkwNjNfVEpVTkNfQwktODEyCj4gKyNkZWZpbmUgREE5MDYzX1ZCQkFUX00J MjA0OAo+ICsKPiArZW51bSBkYTkwNjNfYWRjIHsKPiArCURBOTA2M19DSEFOX1ZTWVMgPSBEQTkw NjNfQURDX01VWF9WU1lTLAo+ICsJREE5MDYzX0NIQU5fQURDSU4xID0gREE5MDYzX0FEQ19NVVhf QURDSU4xLAo+ICsJREE5MDYzX0NIQU5fQURDSU4yID0gREE5MDYzX0FEQ19NVVhfQURDSU4yLAo+ ICsJREE5MDYzX0NIQU5fQURDSU4zID0gREE5MDYzX0FEQ19NVVhfQURDSU4zLAo+ICsJREE5MDYz X0NIQU5fVEpVTkMgPSBEQTkwNjNfQURDX01VWF9UX1NFTlNFLAo+ICsJREE5MDYzX0NIQU5fVkJC QVQgPSBEQTkwNjNfQURDX01VWF9WQkJBVCwKPiArCURBOTA2M19DSEFOX0xET19HMSA9IERBOTA2 M19BRENfTVVYX0xET19HMSwKPiArCURBOTA2M19DSEFOX0xET19HMiA9IERBOTA2M19BRENfTVVY X0xET19HMiwKPiArCURBOTA2M19DSEFOX0xET19HMyA9IERBOTA2M19BRENfTVVYX0xET19HMwo+ ICt9Owo+ICsKPiArc3RydWN0IGRhOTA2M19od21vbiB7Cj4gKwlzdHJ1Y3QgZGE5MDYzICpkYTkw NjM7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpjbGFzc2RldjsKPiArCXN0cnVjdCBtdXRleCBod21vbl9t dXRleDsKPiArCXN0cnVjdCBjb21wbGV0aW9uIGFkY19yZWFkeTsKPiArCXNpZ25lZCBjaGFyIHRq dW5jX29mZnNldDsKPiArCWludCBpcnE7Cj4gK307Cj4gKwo+ICtzdGF0aWMgaW50IGRhOTA2M19h ZGNfY29udmVydChzdHJ1Y3QgZGE5MDYzX2h3bW9uICpod21vbiwgaW50IGNoYW5uZWwsCj4gKwkJ CSAgICAgIGludCAqdmFsdWUpCj4gK3sKPiArCWludCB2YWwgPSAqdmFsdWU7Cj4gKwlpbnQgcmV0 ID0gMDsKPiArCj4gKwlzd2l0Y2ggKGNoYW5uZWwpIHsKPiArCWNhc2UgREE5MDYzX0NIQU5fQURD SU4xOgo+ICsJY2FzZSBEQTkwNjNfQ0hBTl9BRENJTjI6Cj4gKwljYXNlIERBOTA2M19DSEFOX0FE Q0lOMzoKPiArCQl2YWwgPSAoREE5MDYzXzJWNSAqIHZhbCkgLyBEQTkwNjNfQURDX01BWDsKPiAr CQlicmVhazsKPiArCWNhc2UgREE5MDYzX0NIQU5fVlNZUzoKPiArCQl2YWwgPSAoKERBOTA2M181 VjUgLSBEQTkwNjNfMlY1KSAqIHZhbCkgLyBEQTkwNjNfQURDX01BWCArCj4gKwkJCURBOTA2M18y VjU7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIERBOTA2M19DSEFOX1RKVU5DOgo+ICsJCXZhbCAtPSBo d21vbi0+dGp1bmNfb2Zmc2V0Owo+ICsJCXZhbCA9IChEQTkwNjNfVEpVTkNfTSAqICh2YWwgKyBE QTkwNjNfVEpVTkNfQykpID4+IDEwOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBEQTkwNjNfQ0hBTl9W QkJBVDoKPiArCQl2YWwgPSAoREE5MDYzXzVWMCAqIHZhbCkgLyBEQTkwNjNfQURDX01BWDsKPiAr CQlicmVhazsKPiArCWRlZmF1bHQ6Cj4gKwkJcmV0ID0gLUVJTlZBTDsKPiArCQlnb3RvIGVycl9j b252ZXJ0Owo+ICsJfQo+ICsKPiArCSp2YWx1ZSA9IHZhbDsKPiArZXJyX2NvbnZlcnQ6Cj4gKwly ZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGRhOTA2M19hZGNfY3VycmVudF9zd2l0 Y2goc3RydWN0IGRhOTA2M19od21vbiAqaHdtb24sIGludCBjaGFubmVsLAo+ICsJCQkJICAgICBi b29sIG9uKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsJdW5zaWduZWQgaW50IHZhbDsKPiArCXVuc2ln bmVkIGludCBtYXNrOwo+ICsKPiArCXN3aXRjaCAoY2hhbm5lbCkgewo+ICsJY2FzZSBEQTkwNjNf Q0hBTl9BRENJTjE6Cj4gKwkJbWFzayA9IERBOTA2M19BRENfQUQxX0lTUkNfRU47Cj4gKwkJYnJl YWs7Cj4gKwljYXNlIERBOTA2M19DSEFOX0FEQ0lOMjoKPiArCQltYXNrID0gREE5MDYzX0FEQ19B RDJfSVNSQ19FTjsKPiArCQlicmVhazsKPiArCWNhc2UgREE5MDYzX0NIQU5fQURDSU4zOgo+ICsJ CW1hc2sgPSBEQTkwNjNfQURDX0FEM19JU1JDX0VOOwo+ICsJCWJyZWFrOwo+ICsJZGVmYXVsdDoK PiArCQlyZXQgPSAtRUlOVkFMOwo+ICsJCWdvdG8gZXJyX3N3aXRjaDsKPiArCX0KPiArCj4gKwlp ZiAob24pCj4gKwkJdmFsID0gbWFzazsKPiArCWVsc2UKPiArCQl2YWwgPSB+bWFzazsKPiArCj4g KwlyZXQgPSByZWdtYXBfdXBkYXRlX2JpdHMoaHdtb24tPmRhOTA2My0+cmVnbWFwLCBEQTkwNjNf UkVHX0FEQ19DT05ULAo+ICsJCQkJIG1hc2ssIHZhbCk7Cj4gK2Vycl9zd2l0Y2g6Cj4gKwlyZXR1 cm4gcmV0Owo+ICsKPiArfQo+ICsKPiArc3RhdGljIGludCBkYTkwNjNfYWRjX21hbnVhbF9yZWFk KHN0cnVjdCBkYTkwNjNfaHdtb24gKmh3bW9uLCBpbnQgY2hhbm5lbCkKPiArewo+ICsJaW50IHJl dDsKPiArCXVuc2lnbmVkIGNoYXIgdmFsOwo+ICsJdW5zaWduZWQgY2hhciBkYXRhWzJdOwo+ICsJ aW50IGFkY19tYW47Cj4gKwo+ICsJbXV0ZXhfbG9jaygmaHdtb24tPmh3bW9uX211dGV4KTsKPiAr Cj4gKwlpbml0X2NvbXBsZXRpb24oJmh3bW9uLT5hZGNfcmVhZHkpOwo+ICsKPiArCXZhbCA9IChj aGFubmVsICYgREE5MDYzX0FEQ19NVVhfTUFTSykgfCBEQTkwNjNfQURDX01BTjsKPiArCXJldCA9 IHJlZ21hcF91cGRhdGVfYml0cyhod21vbi0+ZGE5MDYzLT5yZWdtYXAsIERBOTA2M19SRUdfQURD X01BTiwKPiArCQkJCSBEQTkwNjNfQURDX01VWF9NQVNLIHwgREE5MDYzX0FEQ19NQU4sIHZhbCk7 Cj4gKwlpZiAocmV0IDwgMCkKPiArCQlnb3RvIGVycl9tcmVhZDsKPiArCj4gKwlyZXQgPSB3YWl0 X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmh3bW9uLT5hZGNfcmVhZHksCj4gKwkJCQkJICBtc2Vj c190b19qaWZmaWVzKDEwMDApKTsKPiArCWlmIChyZXQgPT0gMCkgewo+ICsJCXJldCA9IC1FVElN RURPVVQ7Cj4gKwkJZ290byBlcnJfbXJlYWQ7Cj4gKwl9Cj4gKwo+ICsJcmV0ID0gcmVnbWFwX3Jl YWQoaHdtb24tPmRhOTA2My0+cmVnbWFwLCBEQTkwNjNfUkVHX0FEQ19NQU4sICZhZGNfbWFuKTsK PiArCWlmIChyZXQgPCAwKQo+ICsJCWdvdG8gZXJyX21yZWFkOwo+ICsKPiArCS8qIGRhdGEgdmFs dWUgaXMgbm90IHJlYWR5ICovCj4gKwlpZiAoYWRjX21hbiAmIERBOTA2M19BRENfTUFOID09IDAp IHsKPiArCQlyZXQgPSAtRUlOVkFMOwo+ICsJCWdvdG8gZXJyX21yZWFkOwo+ICsJfQo+ICsKPiAr CXJldCA9IHJlZ21hcF9idWxrX3JlYWQoaHdtb24tPmRhOTA2My0+cmVnbWFwLAo+ICsJCQkgICAg ICAgREE5MDYzX1JFR19BRENfUkVTX0wsIGRhdGEsIDIpOwo+ICsJaWYgKHJldCA8IDApCj4gKwkJ Z290byBlcnJfbXJlYWQ7Cj4gKwo+ICsJcmV0ID0gKGRhdGFbMF0gJiBEQTkwNjNfQURDX1JFU19M X01BU0spID4+IERBOTA2M19BRENfUkVTX0xfU0hJRlQ7Cj4gKwlyZXQgfD0gZGF0YVsxXSA8PCBE QTkwNjNfQURDX1JFU19MX0JJVFM7Cj4gK2Vycl9tcmVhZDoKPiArCW11dGV4X3VubG9jaygmaHdt b24tPmh3bW9uX211dGV4KTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpcnFy ZXR1cm5fdCBkYTkwNjNfaHdtb25faXJxX2hhbmRsZXIoaW50IGlycSwgdm9pZCAqaXJxX2RhdGEp Cj4gK3sKPiArCXN0cnVjdCBkYTkwNjNfaHdtb24gKmh3bW9uID0gaXJxX2RhdGE7Cj4gKwljb21w bGV0ZSgmaHdtb24tPmFkY19yZWFkeSk7Cj4gKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cj4gK30KPiAr Cj4gK3N0YXRpYyBzc2l6ZV90IGRhOTA2M19hZGNfcmVhZChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4g KwkJCSAgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwgY2hhciAqYnVmKQo+ ICt7Cj4gKwlzdHJ1Y3QgZGE5MDYzX2h3bW9uICpod21vbiA9IGRldl9nZXRfZHJ2ZGF0YShkZXYp Owo+ICsJaW50IGNoYW5uZWwgPSB0b19zZW5zb3JfZGV2X2F0dHIoZGV2YXR0ciktPmluZGV4Owo+ ICsJaW50IHZhbDsKPiArCWludCByZXQ7Cj4gKwo+ICsJc3dpdGNoIChjaGFubmVsKSB7Cj4gKwlj YXNlIERBOTA2M19DSEFOX0FEQ0lOMToKPiArCWNhc2UgREE5MDYzX0NIQU5fQURDSU4yOgo+ICsJ Y2FzZSBEQTkwNjNfQ0hBTl9BRENJTjM6Cj4gKwkJLyogZmFsbHRocm91Z2ggZm9yIEFEQyBtZWFz dXJlcyAqLwo+ICsJCXJldCA9IGRhOTA2M19hZGNfY3VycmVudF9zd2l0Y2goaHdtb24sIGNoYW5u ZWwsIHRydWUpOwo+ICsJCWlmIChyZXQgPCAwKQo+ICsJCQlnb3RvIGVycl9yZWFkOwo+ICsKPiAr CQl2YWwgPSBkYTkwNjNfYWRjX21hbnVhbF9yZWFkKGh3bW9uLCBjaGFubmVsKTsKPiArCQlpZiAo dmFsIDwgMCkgewo+ICsJCQlyZXQgPSB2YWw7Cj4gKwkJCWlmIChyZXQgPT0gLUVJTlZBTCkKPiAr CQkJCWRldl9lcnIoZGV2LCAiQ29udmVyc2lvbiB3YXMgbm90IGNvbXBsZXRlZFxuIik7Cj4gKwkJ CWVsc2UKPiArCQkJCWRldl9lcnIoZGV2LCAiQURDIHJlYWQgZXJyb3IgJWRcbiIsIHJldCk7Cj4g KwkJCWdvdG8gZXJyX3JlYWQ7Cj4gKwkJfQo+ICsKPiArCQlyZXQgPSBkYTkwNjNfYWRjX2N1cnJl bnRfc3dpdGNoKGh3bW9uLCBjaGFubmVsLCBmYWxzZSk7Cj4gKwkJaWYgKHJldCA8IDApIHsKPiAr CQkJZGV2X2VycihkZXYsICJDb3VsZCBub3Qgc3dpdGNoIGN1cnJlbnRcbiIpOwo+ICsJCQlnb3Rv IGVycl9yZWFkOwo+ICsJCX0KPiArCQlicmVhazsKPiArCj4gKwljYXNlIERBOTA2M19DSEFOX1ZT WVM6Cj4gKwljYXNlIERBOTA2M19DSEFOX1RKVU5DOgo+ICsJY2FzZSBEQTkwNjNfQ0hBTl9WQkJB VDoKPiArCQkvKiBmYWxsdGhyb3VnaCBmb3IgaW50ZXJuYWwgbWVhc3VyZXMgKi8KPiArCQl2YWwg PSBkYTkwNjNfYWRjX21hbnVhbF9yZWFkKGh3bW9uLCBjaGFubmVsKTsKPiArCQlpZiAodmFsIDwg MCkgewo+ICsJCQlkZXZfZXJyKGRldiwgIkFEQyByZWFkIGVycm9yICVkXG4iLCB2YWwpOwo+ICsJ CQlyZXR1cm4gdmFsOwo+ICsJCX0KPiArCQlicmVhazsKPiArCj4gKwlkZWZhdWx0Ogo+ICsJCS8q IGVycm9yIGNhc2UgKi8KPiArCQlyZXQgPSAtRUlOVkFMOwo+ICsJCWdvdG8gZXJyX3JlYWQ7Cj4g Kwl9Cj4gKwo+ICsJcmV0ID0gZGE5MDYzX2FkY19jb252ZXJ0KGh3bW9uLCBjaGFubmVsLCAmdmFs KTsKPiArCWlmIChyZXQgPCAwKSB7Cj4gKwkJZGV2X2VycihkZXYsICJGYWlsZWQgdG8gY29udmVy dCBBREMgdmFsdWUgJWRcbiIsIHJldCk7Cj4gKwkJZ290byBlcnJfcmVhZDsKPiArCX0KPiArCj4g KwlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgdmFsKTsKPiArZXJyX3JlYWQ6Cj4gKwlyZXR1 cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCBkYTkwNjNfc2hvd19uYW1lKHN0cnVj dCBkZXZpY2UgKmRldiwKPiArCQkJCXN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFy ICpidWYpCj4gK3sKPiArCXJldHVybiBzcHJpbnRmKGJ1ZiwgREE5MDYzX0RSVk5BTUVfSFdNT04g IlxuIik7Cj4gK30KPiArCj4gK3N0YXRpYyBzc2l6ZV90IGRhOTA2M19zaG93X2xhYmVsKHN0cnVj dCBkZXZpY2UgKmRldiwKPiArCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwg Y2hhciAqYnVmKQo+ICt7Cj4gKwlpbnQgY2hhbm5lbCA9IHRvX3NlbnNvcl9kZXZfYXR0cihkZXZh dHRyKS0+aW5kZXg7Cj4gKwljaGFyICpsYWJlbDsKPiArCj4gKwlzd2l0Y2ggKGNoYW5uZWwpIHsK PiArCWNhc2UgREE5MDYzX0NIQU5fVlNZUzoKPiArCQlsYWJlbCA9ICJWU1lTIjsKPiArCQlicmVh azsKPiArCWNhc2UgREE5MDYzX0NIQU5fQURDSU4xOgo+ICsJCWxhYmVsID0gIkFEQ0lOMSI7Cj4g KwkJYnJlYWs7Cj4gKwljYXNlIERBOTA2M19DSEFOX0FEQ0lOMjoKPiArCQlsYWJlbCA9ICJBRENJ TjIiOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBEQTkwNjNfQ0hBTl9BRENJTjM6Cj4gKwkJbGFiZWwg PSAiQURDSU4zIjsKPiArCQlicmVhazsKPiArCWNhc2UgREE5MDYzX0NIQU5fVEpVTkM6Cj4gKwkJ bGFiZWwgPSAiVEpVTkMiOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBEQTkwNjNfQ0hBTl9WQkJBVDoK PiArCQlsYWJlbCA9ICJWQkJBVCI7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCWxhYmVs ID0gIlVOS05PV04iOwo+ICsJfQo+ICsKPiArCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4iLCBs YWJlbCk7Cj4gK30KPiArCj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoaW4wX2lucHV0LCBT X0lSVUdPLAo+ICsJCQkgIGRhOTA2M19hZGNfcmVhZCwgTlVMTCwgREE5MDYzX0NIQU5fVlNZUyk7 Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoaW4wX2xhYmVsLCBTX0lSVUdPLAo+ICsJCQkg IGRhOTA2M19zaG93X2xhYmVsLCBOVUxMLCBEQTkwNjNfQ0hBTl9WU1lTKTsKPiArCj4gK3N0YXRp YyBTRU5TT1JfREVWSUNFX0FUVFIoaW4xX2lucHV0LCBTX0lSVUdPLAo+ICsJCQkgIGRhOTA2M19h ZGNfcmVhZCwgTlVMTCwgREE5MDYzX0NIQU5fQURDSU4xKTsKPiArc3RhdGljIFNFTlNPUl9ERVZJ Q0VfQVRUUihpbjFfbGFiZWwsIFNfSVJVR08sCj4gKwkJCSAgZGE5MDYzX3Nob3dfbGFiZWwsIE5V TEwsIERBOTA2M19DSEFOX0FEQ0lOMSk7Cj4gKwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRS KGluMl9pbnB1dCwgU19JUlVHTywKPiArCQkJICBkYTkwNjNfYWRjX3JlYWQsIE5VTEwsIERBOTA2 M19DSEFOX0FEQ0lOMik7Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoaW4yX2xhYmVsLCBT X0lSVUdPLAo+ICsJCQkgIGRhOTA2M19zaG93X2xhYmVsLCBOVUxMLCBEQTkwNjNfQ0hBTl9BRENJ TjIpOwo+ICsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihpbjNfaW5wdXQsIFNfSVJVR08s Cj4gKwkJCSAgZGE5MDYzX2FkY19yZWFkLCBOVUxMLCBEQTkwNjNfQ0hBTl9BRENJTjMpOwo+ICtz dGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGluM19sYWJlbCwgU19JUlVHTywKPiArCQkJICBkYTkw NjNfc2hvd19sYWJlbCwgTlVMTCwgREE5MDYzX0NIQU5fQURDSU4zKTsKPiArCj4gK3N0YXRpYyBT RU5TT1JfREVWSUNFX0FUVFIoaW40X2lucHV0LCBTX0lSVUdPLAo+ICsJCQkgIGRhOTA2M19hZGNf cmVhZCwgTlVMTCwgREE5MDYzX0NIQU5fVkJCQVQpOwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9B VFRSKGluNF9sYWJlbCwgU19JUlVHTywKPiArCQkJICBkYTkwNjNfc2hvd19sYWJlbCwgTlVMTCwg REE5MDYzX0NIQU5fVkJCQVQpOwo+ICsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1w MV9pbnB1dCwgU19JUlVHTywKPiArCQkJICBkYTkwNjNfYWRjX3JlYWQsIE5VTEwsIERBOTA2M19D SEFOX1RKVU5DKTsKPiArCj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbGFiZWws IFNfSVJVR08sCj4gKwkJCSAgZGE5MDYzX3Nob3dfbGFiZWwsIE5VTEwsIERBOTA2M19DSEFOX1RK VU5DKTsKPiArCj4gK3N0YXRpYyBERVZJQ0VfQVRUUihuYW1lLCBTX0lSVUdPLCBkYTkwNjNfc2hv d19uYW1lLCBOVUxMKTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpkYTkwNjNfYXR0 cmlidXRlc1tdID0gewo+ICsJJmRldl9hdHRyX25hbWUuYXR0ciwKPiArCSZzZW5zb3JfZGV2X2F0 dHJfaW4wX2lucHV0LmRldl9hdHRyLmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRyX2luMF9sYWJl bC5kZXZfYXR0ci5hdHRyLAo+ICsJJnNlbnNvcl9kZXZfYXR0cl9pbjFfaW5wdXQuZGV2X2F0dHIu YXR0ciwKPiArCSZzZW5zb3JfZGV2X2F0dHJfaW4xX2xhYmVsLmRldl9hdHRyLmF0dHIsCj4gKwkm c2Vuc29yX2Rldl9hdHRyX2luMl9pbnB1dC5kZXZfYXR0ci5hdHRyLAo+ICsJJnNlbnNvcl9kZXZf YXR0cl9pbjJfbGFiZWwuZGV2X2F0dHIuYXR0ciwKPiArCSZzZW5zb3JfZGV2X2F0dHJfaW4zX2lu cHV0LmRldl9hdHRyLmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRyX2luM19sYWJlbC5kZXZfYXR0 ci5hdHRyLAo+ICsJJnNlbnNvcl9kZXZfYXR0cl9pbjRfaW5wdXQuZGV2X2F0dHIuYXR0ciwKPiAr CSZzZW5zb3JfZGV2X2F0dHJfaW40X2xhYmVsLmRldl9hdHRyLmF0dHIsCj4gKwkmc2Vuc29yX2Rl dl9hdHRyX3RlbXAxX2lucHV0LmRldl9hdHRyLmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRyX3Rl bXAxX2xhYmVsLmRldl9hdHRyLmF0dHIsCj4gKwlOVUxMCj4gK307Cj4gKwo+ICtzdGF0aWMgY29u c3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBkYTkwNjNfYXR0cl9ncm91cCA9IHsKPiArCS5hdHRy cyA9IGRhOTA2M19hdHRyaWJ1dGVzLAo+ICt9Owo+ICsKPiArc3RhdGljIGludCBkYTkwNjNfaHdt b25fcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiArewo+ICsJc3RydWN0IGRh OTA2MyAqZGE5MDYzID0gZGV2X2dldF9kcnZkYXRhKHBkZXYtPmRldi5wYXJlbnQpOwo+ICsJc3Ry dWN0IGRhOTA2M19wZGF0YSAqcGRhdGEgPSBkYTkwNjMtPmRldi0+cGxhdGZvcm1fZGF0YTsKPiAr CXN0cnVjdCBkYTkwNjNfaHdtb24gKmh3bW9uOwo+ICsJaW50IHJldDsKPiArCXVuc2lnbmVkIGlu dCB2YWw7Cj4gKwo+ICsJaHdtb24gPSBkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKHN0 cnVjdCBkYTkwNjNfaHdtb24pLAo+ICsJCQkgICAgIEdGUF9LRVJORUwpOwo+ICsJaWYgKCFod21v bikKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwltdXRleF9pbml0KCZod21vbi0+aHdtb25f bXV0ZXgpOwo+ICsJaW5pdF9jb21wbGV0aW9uKCZod21vbi0+YWRjX3JlYWR5KTsKPiArCWh3bW9u LT5kYTkwNjMgPSBkYTkwNjM7Cj4gKwo+ICsJLyogZW5hYmxlIHRoZSBBREMgZnVuY3Rpb25zIGZv ciBHUElPIDAsMSwyICovCj4gKwl2YWwgPSAoREE5MDYzX0dQSU8wX1BJTl9BRENJTjEgPDwgREE5 MDYzX0dQSU8wX1BJTl9NQVNLX1NISUZUIHwKPiArCSAgICAgICBEQTkwNjNfR1BJTzFfUElOX0FE Q0lOMl9DT01QIDw8IERBOTA2M19HUElPMV9QSU5fTUFTS19TSElGVCk7Cj4gKwlyZXQgPSByZWdt YXBfdXBkYXRlX2JpdHMoaHdtb24tPmRhOTA2My0+cmVnbWFwLCBEQTkwNjNfUkVHX0dQSU9fMF8x LAo+ICsJCQkJIChEQTkwNjNfR1BJTzBfUElOX01BU0sgfAo+ICsJCQkJICBEQTkwNjNfR1BJTzFf UElOX01BU0spLCB2YWwpOwo+ICsJaWYgKHJldCA8IDApIHsKPiArCQlkZXZfZXJyKCZwZGV2LT5k ZXYsCj4gKwkJCSJGYWlsZWQgdG8gYWx0ZXIgdGhlIEFEQ0lOIDEsMiBiaXRzIGZvciB0aGUgR1BJ TyAwLDEgcmVnaXN0ZXJcbiIpOwo+ICsJCXJldHVybiAtRUlPOwo+ICsJfQo+ICsKPiArCXZhbCA9 IERBOTA2M19HUElPMl9QSU5fQURDSU4zIDw8IERBOTA2M19HUElPMl9QSU5fTUFTS19TSElGVDsK PiArCXJldCA9IHJlZ21hcF91cGRhdGVfYml0cyhod21vbi0+ZGE5MDYzLT5yZWdtYXAsIERBOTA2 M19SRUdfR1BJT18yXzMsCj4gKwkJCQkgREE5MDYzX0dQSU8yX1BJTl9NQVNLLCB2YWwpOwo+ICsJ aWYgKHJldCA8IDApIHsKPiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsCj4gKwkJCSJGYWlsZWQgdG8g YWx0ZXIgdGhlIEFEQ0lOIDMgYml0cyBmb3IgdGhlIEdQSU8gMiwzIHJlZ2lzdGVyXG4iKTsKPiAr CQlyZXR1cm4gLUVJTzsKPiArCX0KPiArCj4gKwkvKiBkZWJvdW5jZSBBREMgSSBzZXR0aW5ncyAq Lwo+ICsJdmFsID0gKERBOTA2M19BRENJTjFfREVCX09OIDw8IERBOTA2M19SRUdfQURDSU4xX0RF Ql9TSElGVCB8Cj4gKwkgICAgICAgREE5MDYzX0FEQ0lOMl9ERUJfT04gPDwgREE5MDYzX1JFR19B RENJTjJfREVCX1NISUZUIHwKPiArCSAgICAgICBEQTkwNjNfQURDSU4zX0RFQl9PTiA8PCBEQTkw NjNfUkVHX0FEQ0lOM19ERUJfU0hJRlQpOwo+ICsJcmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRzKGh3 bW9uLT5kYTkwNjMtPnJlZ21hcCwgREE5MDYzX1JFR19BRENfQ0ZHLAo+ICsJCQkJIChEQTkwNjNf UkVHX0FEQ0lOMV9ERUJfTUFTSyB8Cj4gKwkJCQkgIERBOTA2M19SRUdfQURDSU4yX0RFQl9NQVNL IHwKPiArCQkJCSAgREE5MDYzX1JFR19BRENJTjNfREVCX01BU0spLCB2YWwpOwo+ICsJaWYgKHJl dCA8IDApIHsKPiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsCj4gKwkJCSJGYWlsZWQgdG8gYWx0ZXIg dGhlIEFEQyBjb25maWd1cmF0aW9uIHJlZ2lzdGVyXG4iKTsKPiArCQlyZXR1cm4gLUVJTzsKPiAr CX0KPiArCj4gKwkvKiBzZXQgdXAgdGhlIGN1cnJlbnQgY29uZmlndXJhdGlvbnMgKi8KPiArCXZh bCA9IChwZGF0YS0+aHdtb25fcGRhdGEtPmFkY2luMV9jdXIgPDwgREE5MDYzX1JFR19BRENJTjFf Q1VSX1NISUZUIHwKPiArCSAgICAgICBwZGF0YS0+aHdtb25fcGRhdGEtPmFkY2luMl9jdXIgPDwg REE5MDYzX1JFR19BRENJTjJfQ1VSX1NISUZUIHwKPiArCSAgICAgICBwZGF0YS0+aHdtb25fcGRh dGEtPmFkY2luM19jdXIgPDwgREE5MDYzX1JFR19BRENJTjNfQ1VSX1NISUZUKTsKPiArCXJldCA9 IHJlZ21hcF91cGRhdGVfYml0cyhod21vbi0+ZGE5MDYzLT5yZWdtYXAsIERBOTA2M19SRUdfQURD X0NGRywKPiArCQkJCSAoREE5MDYzX1JFR19BRENJTjFfQ1VSX01BU0sgfAo+ICsJCQkJICBEQTkw NjNfUkVHX0FEQ0lOMl9DVVJfTUFTSyB8Cj4gKwkJCQkgIERBOTA2M19SRUdfQURDSU4zX0NVUl9N QVNLKSwgdmFsKTsKPiArCj4gKwlyZXQgPSByZWdtYXBfcmVhZChkYTkwNjMtPnJlZ21hcCwgREE5 MDYzX1JFR19BRENfQ0ZHLCAmdmFsKTsKPiArCWlmIChyZXQgPCAwKSB7Cj4gKwkJZGV2X2Vycigm cGRldi0+ZGV2LAo+ICsJCQkiRmFpbGVkIHRvIHJlYWQgcmVhZCB0aGUgQURDIGNvbmZpZ3VyYXRp b24gcmVnaXN0ZXJcbiIpOwo+ICsJCXJldHVybiAtRUlPOwo+ICsJfQo+ICsKPiArCWh3bW9uLT5p cnEgPSBwbGF0Zm9ybV9nZXRfaXJxX2J5bmFtZShwZGV2LCBEQTkwNjNfRFJWTkFNRV9IV01PTik7 Cj4gKwlpZiAoaHdtb24tPmlycSA8IDApCj4gKwkJcmV0dXJuIGh3bW9uLT5pcnE7Cj4gKwo+ICsJ cmV0ID0gZGV2bV9yZXF1ZXN0X3RocmVhZGVkX2lycSgmcGRldi0+ZGV2LCBod21vbi0+aXJxLCBO VUxMLAo+ICsJCQkJCWRhOTA2M19od21vbl9pcnFfaGFuZGxlciwKPiArCQkJCQlJUlFGX1RSSUdH RVJfTE9XIHwgSVJRRl9PTkVTSE9ULAo+ICsJCQkJCSJIV01PTiIsIGh3bW9uKTsKPiArCWlmIChy ZXQpIHsKPiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJGYWlsZWQgdG8gcmVxdWVzdCBJUlEuXG4i KTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiArCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBk ZXYsIGh3bW9uKTsKPiArCj4gKwkvKiBzZXQgdHJpbSB0ZW1wZXJhdHVyZSBvZmZzZXQgdG8gdmFs dWUgcmVhZCBhdCBzdGFydHVwICovCj4gKwlod21vbi0+dGp1bmNfb2Zmc2V0ID0gKHNpZ25lZCBj aGFyKWh3bW9uLT5kYTkwNjMtPnRfb2Zmc2V0Owo+ICsKPiArCXJldCA9IHN5c2ZzX2NyZWF0ZV9n cm91cCgmcGRldi0+ZGV2LmtvYmosICZkYTkwNjNfYXR0cl9ncm91cCk7Cj4gKwlpZiAocmV0KQo+ ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJaHdtb24tPmNsYXNzZGV2ID0gaHdtb25fZGV2aWNlX3Jl Z2lzdGVyKCZwZGV2LT5kZXYpOwo+ICsJaWYgKElTX0VSUihod21vbi0+Y2xhc3NkZXYpKSB7Cj4g KwkJc3lzZnNfcmVtb3ZlX2dyb3VwKCZwZGV2LT5kZXYua29iaiwgJmRhOTA2M19hdHRyX2dyb3Vw KTsKPiArCQlyZXR1cm4gUFRSX0VSUihod21vbi0+Y2xhc3NkZXYpOwo+ICsJfQo+ICsKPiArCXJl dHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGRhOTA2M19od21vbl9yZW1vdmUoc3RydWN0 IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiArewo+ICsJc3RydWN0IGRhOTA2M19od21vbiAqaHdt b24gPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKPiArCj4gKwlod21vbl9kZXZpY2VfdW5y ZWdpc3Rlcihod21vbi0+Y2xhc3NkZXYpOwo+ICsJc3lzZnNfcmVtb3ZlX2dyb3VwKCZwZGV2LT5k ZXYua29iaiwgJmRhOTA2M19hdHRyX2dyb3VwKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsK PiArc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgZGE5MDYzX2h3bW9uX2RyaXZlciA9IHsK PiArCS5wcm9iZSA9IGRhOTA2M19od21vbl9wcm9iZSwKPiArCS5yZW1vdmUgPSBkYTkwNjNfaHdt b25fcmVtb3ZlLAo+ICsJLmRyaXZlciA9IHsKPiArCQkgICAubmFtZSA9IERBOTA2M19EUlZOQU1F X0hXTU9OLAo+ICsJCSAgIC5vd25lciA9IFRISVNfTU9EVUxFLAo+ICsJCSAgIH0sCj4gK307Cj4g Kwo+ICttb2R1bGVfcGxhdGZvcm1fZHJpdmVyKGRhOTA2M19od21vbl9kcml2ZXIpOwo+ICsKPiAr TU9EVUxFX0RFU0NSSVBUSU9OKCJIYXJkd2FyZSBtb25pdG9yIHN1cHBvcnQgZGV2aWNlIGRyaXZl ciBmb3IgRGlhbG9nIERBOTA2MyIpOwo+ICtNT0RVTEVfQVVUSE9SKCJTIFR3aXNzIDxzdHdpc3Mu b3BlbnNvdXJjZUBkaWFzZW1pLmNvbT4iKTsKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwo+ ICtNT0RVTEVfQUxJQVMoInBsYXRmb3JtOiIgREE5MDYzX0RSVk5BTUVfSFdNT04pOwo+IGRpZmYg LS1naXQgYS9pbmNsdWRlL2xpbnV4L21mZC9kYTkwNjMvcmVnaXN0ZXJzLmggYi9pbmNsdWRlL2xp bnV4L21mZC9kYTkwNjMvcmVnaXN0ZXJzLmgKPiBpbmRleCAwOWE4NWM2Li45MjIzNzFiIDEwMDY0 NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvbWZkL2RhOTA2My9yZWdpc3RlcnMuaAo+ICsrKyBiL2lu Y2x1ZGUvbGludXgvbWZkL2RhOTA2My9yZWdpc3RlcnMuaAo+IEBAIC00NzQsNiArNDc0LDcgQEAK PiAgCj4gIC8qIERBOTA2M19SRUdfR1BJT18wXzEgKGFkZHI9MHgxNSkgKi8KPiAgI2RlZmluZQlE QTkwNjNfR1BJTzBfUElOX01BU0sJCQkweDAzCj4gKyNkZWZpbmUJREE5MDYzX0dQSU8wX1BJTl9N QVNLX1NISUZUCQkwCj4gICNkZWZpbmUJCURBOTA2M19HUElPMF9QSU5fQURDSU4xCQkweDAwCj4g ICNkZWZpbmUJCURBOTA2M19HUElPMF9QSU5fR1BJCQkweDAxCj4gICNkZWZpbmUJCURBOTA2M19H UElPMF9QSU5fR1BPX09ECQkweDAyCj4gQEAgLTQ4NSw2ICs0ODYsNyBAQAo+ICAjZGVmaW5lCQlE QTkwNjNfR1BJTzBfVFlQRV9HUE9fVkREX0lPMgkweDA0Cj4gICNkZWZpbmUJREE5MDYzX0dQSU8w X05PX1dBS0VVUAkJCTB4MDgKPiAgI2RlZmluZQlEQTkwNjNfR1BJTzFfUElOX01BU0sJCQkweDMw Cj4gKyNkZWZpbmUJREE5MDYzX0dQSU8xX1BJTl9NQVNLX1NISUZUCQk0Cj4gICNkZWZpbmUJCURB OTA2M19HUElPMV9QSU5fQURDSU4yX0NPTVAJMHgwMAo+ICAjZGVmaW5lCQlEQTkwNjNfR1BJTzFf UElOX0dQSQkJMHgxMAo+ICAjZGVmaW5lCQlEQTkwNjNfR1BJTzFfUElOX0dQT19PRAkJMHgyMAo+ IEBAIC00OTgsNiArNTAwLDcgQEAKPiAgCj4gIC8qIERBOTA2M19SRUdfR1BJT18yXzMgKGFkZHI9 MHgxNikgKi8KPiAgI2RlZmluZQlEQTkwNjNfR1BJTzJfUElOX01BU0sJCQkweDAzCj4gKyNkZWZp bmUJREE5MDYzX0dQSU8yX1BJTl9NQVNLX1NISUZUCQkwCj4gICNkZWZpbmUJCURBOTA2M19HUElP Ml9QSU5fQURDSU4zCQkweDAwCj4gICNkZWZpbmUJCURBOTA2M19HUElPMl9QSU5fR1BJCQkweDAx Cj4gICNkZWZpbmUJCURBOTA2M19HUElPMl9QSU5fR1BPX1BTUwkweDAyCj4gQEAgLTgxMyw2ICs4 MTYsNyBAQAo+ICAjZGVmaW5lCURBOTA2M19WU1lTX1ZBTF9CQVNFCQkJMHgwMAo+ICAKPiAgLyog REE5MDYzX1JFR19BRENfUkVTX0wgKGFkZHI9MHgzNykgKi8KPiArI2RlZmluZQlEQTkwNjNfQURD X1JFU19MX1NISUZUCQkJNgo+ICAjZGVmaW5lCURBOTA2M19BRENfUkVTX0xfQklUUwkJCTIKPiAg I2RlZmluZQlEQTkwNjNfQURDX1JFU19MX01BU0sJCQkweEMwCj4gIAo+IEBAIC05NzksNiArOTgz LDM2IEBACj4gICNkZWZpbmUgREE5MDYzX0dQSU9fRElNCQkJCTB4ODAKPiAgI2RlZmluZSBEQTkw NjNfR1BJT19QV01fTUFTSwkJCTB4N0YKPiAgCj4gKy8qIERBOTA2M19SRUdfQURDX0NGRyAoYWRk cj0weEM5KSAqLwo+ICsjZGVmaW5lIERBOTA2M19SRUdfQURDSU4xX0NVUl9NQVNLCQkweDAzCj4g KyNkZWZpbmUgREE5MDYzX1JFR19BRENJTjFfQ1VSX1NISUZUCQkwCj4gKyNkZWZpbmUJCURBOTA2 M19BRENJTjFfQ1VSXzFVQQkJMHgwMAo+ICsjZGVmaW5lCQlEQTkwNjNfQURDSU4xX0NVUl8yVUEJ CTB4MDEKPiArI2RlZmluZQkJREE5MDYzX0FEQ0lOMV9DVVJfMTBVQQkJMHgwMgo+ICsjZGVmaW5l CQlEQTkwNjNfQURDSU4xX0NVUl80MFVBCQkweDAzCj4gKyNkZWZpbmUgREE5MDYzX1JFR19BRENJ TjJfQ1VSX01BU0sJCTB4MEMKPiArI2RlZmluZSBEQTkwNjNfUkVHX0FEQ0lOMl9DVVJfU0hJRlQJ CTIKPiArI2RlZmluZQkJREE5MDYzX0FEQ0lOMl9DVVJfMVVBCQkweDAwCj4gKyNkZWZpbmUJCURB OTA2M19BRENJTjJfQ1VSXzJVQQkJMHgwMQo+ICsjZGVmaW5lCQlEQTkwNjNfQURDSU4yX0NVUl8x MFVBCQkweDAyCj4gKyNkZWZpbmUJCURBOTA2M19BRENJTjJfQ1VSXzQwVUEJCTB4MDMKPiArI2Rl ZmluZSBEQTkwNjNfUkVHX0FEQ0lOM19DVVJfTUFTSwkJMHgxMAo+ICsjZGVmaW5lIERBOTA2M19S RUdfQURDSU4zX0NVUl9TSElGVAkJNAo+ICsjZGVmaW5lCQlEQTkwNjNfQURDSU4zX0NVUl8xMFVB CQkweDAwCj4gKyNkZWZpbmUJCURBOTA2M19BRENJTjNfQ1VSXzQwVUEJCTB4MDEKPiArI2RlZmlu ZSBEQTkwNjNfUkVHX0FEQ0lOMV9ERUJfTUFTSwkJMHgyMAo+ICsjZGVmaW5lIERBOTA2M19SRUdf QURDSU4xX0RFQl9TSElGVAkJNQo+ICsjZGVmaW5lCQlEQTkwNjNfQURDSU4xX0RFQl9PRkYJCTB4 MDAKPiArI2RlZmluZQkJREE5MDYzX0FEQ0lOMV9ERUJfT04JCTB4MDEKPiArI2RlZmluZSBEQTkw NjNfUkVHX0FEQ0lOMl9ERUJfTUFTSwkJMHg0MAo+ICsjZGVmaW5lIERBOTA2M19SRUdfQURDSU4y X0RFQl9TSElGVAkJNgo+ICsjZGVmaW5lCQlEQTkwNjNfQURDSU4yX0RFQl9PRkYJCTB4MDAKPiAr I2RlZmluZQkJREE5MDYzX0FEQ0lOMl9ERUJfT04JCTB4MDEKPiArI2RlZmluZSBEQTkwNjNfUkVH X0FEQ0lOM19ERUJfTUFTSwkJMHg4MAo+ICsjZGVmaW5lIERBOTA2M19SRUdfQURDSU4zX0RFQl9T SElGVAkJNwo+ICsjZGVmaW5lCQlEQTkwNjNfQURDSU4zX0RFQl9PRkYJCTB4MDAKPiArI2RlZmlu ZQkJREE5MDYzX0FEQ0lOM19ERUJfT04JCTB4MDEKPiArCj4gIC8qIERBOTA2M19SRUdfQ09ORklH X0ggKGFkZHI9MHgxMEQpICovCj4gICNkZWZpbmUgREE5MDYzX1BXTV9DTEtfTUFTSwkJCTB4MDEK PiAgI2RlZmluZQkJREE5MDYzX1BXTV9DTEtfUFdNMk1IWgkJMHgwMAoKLS0gCkxlZSBKb25lcwpM aW5hcm8gU1RNaWNyb2VsZWN0cm9uaWNzIExhbmRpbmcgVGVhbSBMZWFkCkxpbmFyby5vcmcg4pSC IE9wZW4gc291cmNlIHNvZnR3YXJlIGZvciBBUk0gU29DcwpGb2xsb3cgTGluYXJvOiBGYWNlYm9v ayB8IFR3aXR0ZXIgfCBCbG9nCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMu b3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNv cnM
next prev parent reply other threads:[~2014-03-24 7:52 UTC|newest] Thread overview: 24+ messages / expand[flat|nested] mbox.gz Atom feed top 2014-03-23 20:37 [RFC V1 0/3] da9063: Addition of HWMON support for DA9063 Opensource [Steve Twiss] 2014-03-23 20:37 ` [lm-sensors] " Opensource [Steve Twiss] 2014-03-23 20:37 ` [RFC V1 1/3] hwmon: da9063: HWMON driver Opensource [Steve Twiss] 2014-03-23 20:37 ` [lm-sensors] " Opensource [Steve Twiss] 2014-03-24 3:27 ` Guenter Roeck 2014-03-24 3:27 ` [lm-sensors] " Guenter Roeck 2014-03-24 3:39 ` Guenter Roeck 2014-03-24 3:39 ` [lm-sensors] " Guenter Roeck 2014-03-24 7:48 ` Opensource [Steve Twiss] 2014-03-24 7:48 ` [lm-sensors] " Opensource [Steve Twiss] 2014-03-24 9:24 ` Lee Jones 2014-03-24 9:24 ` [lm-sensors] " Lee Jones 2014-03-24 7:52 ` Lee Jones [this message] 2014-03-24 7:52 ` Lee Jones 2014-03-24 8:12 ` Opensource [Steve Twiss] 2014-03-24 8:12 ` [lm-sensors] " Opensource [Steve Twiss] 2014-03-23 20:37 ` [RFC V1 2/3] mfd: da9063: Add HWMON dependencies Opensource [Steve Twiss] 2014-03-23 20:37 ` [lm-sensors] " Opensource [Steve Twiss] 2014-03-24 8:02 ` Lee Jones 2014-03-24 8:02 ` [lm-sensors] " Lee Jones 2014-03-24 8:28 ` Opensource [Steve Twiss] 2014-03-24 8:28 ` [lm-sensors] " Opensource [Steve Twiss] 2014-03-23 20:37 ` [RFC V1 3/3] Documentation: hwmon: New information for DA9063 Opensource [Steve Twiss] 2014-03-23 20:37 ` [lm-sensors] " Opensource [Steve Twiss]
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=20140324075221.GF8541@lee--X1 \ --to=lee.jones@linaro.org \ --cc=broonie@linaro.org \ --cc=david.chen@diasemi.com \ --cc=jdelvare@suse.de \ --cc=linux-doc@vger.kernel.org \ --cc=linux-kernel@vger.kernel.org \ --cc=linux@roeck-us.net \ --cc=lm-sensors@lm-sensors.org \ --cc=p.zabel@pengutronix.de \ --cc=rob@landley.net \ --cc=sameo@linux.intel.com \ --cc=stwiss.opensource@diasemi.com \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.