From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1760305AbcJ1KB5 (ORCPT ); Fri, 28 Oct 2016 06:01:57 -0400 Received: from onstation.org ([52.200.56.107]:50840 "EHLO onstation.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1759928AbcJ1KAa (ORCPT ); Fri, 28 Oct 2016 06:00:30 -0400 From: Brian Masney To: jic23@kernel.org, linux-iio@vger.kernel.org Cc: devel@driverdev.osuosl.org, gregkh@linuxfoundation.org, lars@metafoo.de, pmeerw@pmeerw.net, knaack.h@gmx.de, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, robh+dt@kernel.org, Mark.Rutland@arm.com Subject: [PATCH 06/10] staging: iio: tsl2583: convert to use iio_chan_spec and {read,write}_raw Date: Fri, 28 Oct 2016 06:00:17 -0400 Message-Id: <1477648821-3786-7-git-send-email-masneyb@onstation.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1477648821-3786-1-git-send-email-masneyb@onstation.org> References: <1477648821-3786-1-git-send-email-masneyb@onstation.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The tsl2583 driver directly creates sysfs attributes that should instead be created by the IIO core on behalf of the driver. This patch adds the iio_chan_spec array, the relevant info_mask elements and the read_raw() and write_raw() functions to take advantage of features provided by the IIO core. These sysfs attributes were migrated with this patch: illuminance0_input, illuminance0_calibbias, illuminance0_integration_time. This also exposes the raw values read from the two channels on the sensor. With this change, these four sysfs entries have their prefix changed from illuminance0_ to in_illuminance_. This is deemed to be acceptable since none of the IIO light drivers in mainline use the illuminance0_ prefix, however 8 of the IIO light drivers in mainline use the in_illuminance_ prefix. Signed-off-by: Brian Masney --- drivers/staging/iio/light/tsl2583.c | 236 ++++++++++++++++++++++-------------- 1 file changed, 143 insertions(+), 93 deletions(-) diff --git a/drivers/staging/iio/light/tsl2583.c b/drivers/staging/iio/light/tsl2583.c index e975bba..6a61a86 100644 --- a/drivers/staging/iio/light/tsl2583.c +++ b/drivers/staging/iio/light/tsl2583.c @@ -211,28 +211,23 @@ static int taos_get_lux(struct iio_dev *indio_dev) u32 ch0lux = 0; u32 ch1lux = 0; - if (mutex_trylock(&chip->als_mutex) == 0) { - dev_info(&chip->client->dev, "taos_get_lux device is busy\n"); - return chip->als_cur_info.lux; /* busy, so return LAST VALUE */ - } - if (chip->taos_chip_status != TSL258X_CHIP_WORKING) { /* device is not enabled */ dev_err(&chip->client->dev, "taos_get_lux device is not enabled\n"); ret = -EBUSY; - goto out_unlock; + goto done; } ret = taos_i2c_read(chip->client, (TSL258X_CMD_REG), &buf[0], 1); if (ret < 0) { dev_err(&chip->client->dev, "taos_get_lux failed to read CMD_REG\n"); - goto out_unlock; + goto done; } /* is data new & valid */ if (!(buf[0] & TSL258X_STA_ADC_INTR)) { dev_err(&chip->client->dev, "taos_get_lux data not valid\n"); ret = chip->als_cur_info.lux; /* return LAST VALUE */ - goto out_unlock; + goto done; } for (i = 0; i < 4; i++) { @@ -243,7 +238,7 @@ static int taos_get_lux(struct iio_dev *indio_dev) dev_err(&chip->client->dev, "taos_get_lux failed to read register %x\n", reg); - goto out_unlock; + goto done; } } @@ -259,7 +254,7 @@ static int taos_get_lux(struct iio_dev *indio_dev) dev_err(&chip->client->dev, "taos_i2c_write_command failed in taos_get_lux, err = %d\n", ret); - goto out_unlock; /* have no data, so return failure */ + goto done; /* have no data, so return failure */ } /* extract ALS/lux data */ @@ -276,7 +271,7 @@ static int taos_get_lux(struct iio_dev *indio_dev) /* have no data, so return LAST VALUE */ ret = 0; chip->als_cur_info.lux = 0; - goto out_unlock; + goto done; } /* calculate ratio */ ratio = (ch1 << 15) / ch0; @@ -302,7 +297,7 @@ static int taos_get_lux(struct iio_dev *indio_dev) dev_dbg(&chip->client->dev, "No Data - Return last value\n"); ret = 0; chip->als_cur_info.lux = 0; - goto out_unlock; + goto done; } /* adjust for active time scale */ @@ -334,8 +329,7 @@ static int taos_get_lux(struct iio_dev *indio_dev) chip->als_cur_info.lux = lux; ret = lux; -out_unlock: - mutex_unlock(&chip->als_mutex); +done: return ret; } @@ -575,69 +569,12 @@ static ssize_t taos_gain_available_show(struct device *dev, return sprintf(buf, "%s\n", "1 8 16 111"); } -static ssize_t taos_als_time_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - struct iio_dev *indio_dev = dev_to_iio_dev(dev); - struct tsl2583_chip *chip = iio_priv(indio_dev); - - return sprintf(buf, "%d\n", chip->taos_settings.als_time); -} - -static ssize_t taos_als_time_store(struct device *dev, - struct device_attribute *attr, - const char *buf, size_t len) -{ - struct iio_dev *indio_dev = dev_to_iio_dev(dev); - struct tsl2583_chip *chip = iio_priv(indio_dev); - int value; - - if (kstrtoint(buf, 0, &value)) - return -EINVAL; - - if ((value < 50) || (value > 650)) - return -EINVAL; - - if (value % 50) - return -EINVAL; - - chip->taos_settings.als_time = value; - - return len; -} - static ssize_t taos_als_time_available_show(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "%s\n", - "50 100 150 200 250 300 350 400 450 500 550 600 650"); -} - -static ssize_t taos_als_trim_show(struct device *dev, - struct device_attribute *attr, char *buf) -{ - struct iio_dev *indio_dev = dev_to_iio_dev(dev); - struct tsl2583_chip *chip = iio_priv(indio_dev); - - return sprintf(buf, "%d\n", chip->taos_settings.als_gain_trim); -} - -static ssize_t taos_als_trim_store(struct device *dev, - struct device_attribute *attr, - const char *buf, size_t len) -{ - struct iio_dev *indio_dev = dev_to_iio_dev(dev); - struct tsl2583_chip *chip = iio_priv(indio_dev); - int value; - - if (kstrtoint(buf, 0, &value)) - return -EINVAL; - - if (value) - chip->taos_settings.als_gain_trim = value; - - return len; + "0.000050 0.000100 0.000150 0.000200 0.000250 0.000300 0.000350 0.000400 0.000450 0.000500 0.000550 0.000600 0.000650"); } static ssize_t taos_als_cal_target_show(struct device *dev, @@ -667,18 +604,6 @@ static ssize_t taos_als_cal_target_store(struct device *dev, return len; } -static ssize_t taos_lux_show(struct device *dev, struct device_attribute *attr, - char *buf) -{ - int ret; - - ret = taos_get_lux(dev_to_iio_dev(dev)); - if (ret < 0) - return ret; - - return sprintf(buf, "%d\n", ret); -} - static ssize_t taos_do_calibrate(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) @@ -771,18 +696,12 @@ static DEVICE_ATTR(illuminance0_calibscale, S_IRUGO | S_IWUSR, static DEVICE_ATTR(illuminance0_calibscale_available, S_IRUGO, taos_gain_available_show, NULL); -static DEVICE_ATTR(illuminance0_integration_time, S_IRUGO | S_IWUSR, - taos_als_time_show, taos_als_time_store); static DEVICE_ATTR(illuminance0_integration_time_available, S_IRUGO, taos_als_time_available_show, NULL); -static DEVICE_ATTR(illuminance0_calibbias, S_IRUGO | S_IWUSR, - taos_als_trim_show, taos_als_trim_store); - static DEVICE_ATTR(illuminance0_input_target, S_IRUGO | S_IWUSR, taos_als_cal_target_show, taos_als_cal_target_store); -static DEVICE_ATTR(illuminance0_input, S_IRUGO, taos_lux_show, NULL); static DEVICE_ATTR(illuminance0_calibrate, S_IWUSR, NULL, taos_do_calibrate); static DEVICE_ATTR(illuminance0_lux_table, S_IRUGO | S_IWUSR, taos_luxtable_show, taos_luxtable_store); @@ -790,11 +709,8 @@ static DEVICE_ATTR(illuminance0_lux_table, S_IRUGO | S_IWUSR, static struct attribute *sysfs_attrs_ctrl[] = { &dev_attr_illuminance0_calibscale.attr, /* Gain */ &dev_attr_illuminance0_calibscale_available.attr, - &dev_attr_illuminance0_integration_time.attr, /* I time*/ &dev_attr_illuminance0_integration_time_available.attr, - &dev_attr_illuminance0_calibbias.attr, /* trim */ &dev_attr_illuminance0_input_target.attr, - &dev_attr_illuminance0_input.attr, &dev_attr_illuminance0_calibrate.attr, &dev_attr_illuminance0_lux_table.attr, NULL @@ -810,9 +726,141 @@ static int taos_tsl258x_device(unsigned char *bufp) return ((bufp[TSL258X_CHIPID] & 0xf0) == 0x90); } +static const struct iio_chan_spec tsl2583_channels[] = { + { + .type = IIO_LIGHT, + .modified = 1, + .channel2 = IIO_MOD_LIGHT_IR, + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), + }, + { + .type = IIO_LIGHT, + .modified = 1, + .channel2 = IIO_MOD_LIGHT_BOTH, + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), + }, + { + .type = IIO_LIGHT, + .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | + BIT(IIO_CHAN_INFO_CALIBBIAS) | + BIT(IIO_CHAN_INFO_INT_TIME), + }, +}; + +static int tsl2583_read_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val, int *val2, long mask) +{ + struct tsl2583_chip *chip = iio_priv(indio_dev); + int ret = -EINVAL; + + mutex_lock(&chip->als_mutex); + + if (chip->taos_chip_status != TSL258X_CHIP_WORKING) { + ret = -EBUSY; + goto read_done; + } + + switch (mask) { + case IIO_CHAN_INFO_RAW: + if (chan->type == IIO_LIGHT) { + ret = taos_get_lux(indio_dev); + if (ret < 0) + goto read_done; + + /* + * From page 20 of the TSL2581, TSL2583 data + * sheet (TAOS134 − MARCH 2011): + * + * One of the photodiodes (channel 0) is + * sensitive to both visible and infrared light, + * while the second photodiode (channel 1) is + * sensitive primarily to infrared light. + */ + if (chan->channel2 == IIO_MOD_LIGHT_BOTH) + *val = chip->als_cur_info.als_ch0; + else + *val = chip->als_cur_info.als_ch1; + + ret = IIO_VAL_INT; + } + break; + case IIO_CHAN_INFO_PROCESSED: + if (chan->type == IIO_LIGHT) { + ret = taos_get_lux(indio_dev); + if (ret < 0) + goto read_done; + + *val = ret; + ret = IIO_VAL_INT; + } + break; + case IIO_CHAN_INFO_CALIBBIAS: + if (chan->type == IIO_LIGHT) { + *val = chip->taos_settings.als_gain_trim; + ret = IIO_VAL_INT; + } + break; + case IIO_CHAN_INFO_INT_TIME: + if (chan->type == IIO_LIGHT) { + *val = 0; + *val2 = chip->taos_settings.als_time; + ret = IIO_VAL_INT_PLUS_MICRO; + } + break; + default: + break; + } + +read_done: + mutex_unlock(&chip->als_mutex); + + return ret; +} + +static int tsl2583_write_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int val, int val2, long mask) +{ + struct tsl2583_chip *chip = iio_priv(indio_dev); + int ret = -EINVAL; + + mutex_lock(&chip->als_mutex); + + if (chip->taos_chip_status != TSL258X_CHIP_WORKING) { + ret = -EBUSY; + goto write_done; + } + + switch (mask) { + case IIO_CHAN_INFO_CALIBBIAS: + if (chan->type == IIO_LIGHT) { + chip->taos_settings.als_gain_trim = val; + ret = 0; + } + break; + case IIO_CHAN_INFO_INT_TIME: + if (chan->type == IIO_LIGHT && !val && val2 >= 50 && + val2 <= 650 && !(val2 % 50)) { + chip->taos_settings.als_time = val2; + ret = 0; + } + break; + default: + break; + } + +write_done: + mutex_unlock(&chip->als_mutex); + + return ret; +} + static const struct iio_info tsl2583_info = { .attrs = &tsl2583_attribute_group, .driver_module = THIS_MODULE, + .read_raw = tsl2583_read_raw, + .write_raw = tsl2583_write_raw, }; /* @@ -878,6 +926,8 @@ static int taos_probe(struct i2c_client *clientp, } indio_dev->info = &tsl2583_info; + indio_dev->channels = tsl2583_channels; + indio_dev->num_channels = ARRAY_SIZE(tsl2583_channels); indio_dev->dev.parent = &clientp->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->name = chip->client->name; -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Brian Masney Subject: [PATCH 06/10] staging: iio: tsl2583: convert to use iio_chan_spec and {read, write}_raw Date: Fri, 28 Oct 2016 06:00:17 -0400 Message-ID: <1477648821-3786-7-git-send-email-masneyb@onstation.org> References: <1477648821-3786-1-git-send-email-masneyb@onstation.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1477648821-3786-1-git-send-email-masneyb@onstation.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: driverdev-devel-bounces@linuxdriverproject.org Sender: "devel" To: jic23@kernel.org, linux-iio@vger.kernel.org Cc: devel@driverdev.osuosl.org, devicetree@vger.kernel.org, lars@metafoo.de, gregkh@linuxfoundation.org, linux-kernel@vger.kernel.org, robh+dt@kernel.org, pmeerw@pmeerw.net, knaack.h@gmx.de, Mark.Rutland@arm.com List-Id: devicetree@vger.kernel.org VGhlIHRzbDI1ODMgZHJpdmVyIGRpcmVjdGx5IGNyZWF0ZXMgc3lzZnMgYXR0cmlidXRlcyB0aGF0 IHNob3VsZCBpbnN0ZWFkCmJlIGNyZWF0ZWQgYnkgdGhlIElJTyBjb3JlIG9uIGJlaGFsZiBvZiB0 aGUgZHJpdmVyLiBUaGlzIHBhdGNoIGFkZHMgdGhlCmlpb19jaGFuX3NwZWMgYXJyYXksIHRoZSBy ZWxldmFudCBpbmZvX21hc2sgZWxlbWVudHMgYW5kIHRoZSByZWFkX3JhdygpCmFuZCB3cml0ZV9y YXcoKSBmdW5jdGlvbnMgdG8gdGFrZSBhZHZhbnRhZ2Ugb2YgZmVhdHVyZXMgcHJvdmlkZWQgYnkg dGhlCklJTyBjb3JlLiBUaGVzZSBzeXNmcyBhdHRyaWJ1dGVzIHdlcmUgbWlncmF0ZWQgd2l0aCB0 aGlzIHBhdGNoOgppbGx1bWluYW5jZTBfaW5wdXQsIGlsbHVtaW5hbmNlMF9jYWxpYmJpYXMsCmls bHVtaW5hbmNlMF9pbnRlZ3JhdGlvbl90aW1lLiBUaGlzIGFsc28gZXhwb3NlcyB0aGUgcmF3IHZh bHVlcyByZWFkCmZyb20gdGhlIHR3byBjaGFubmVscyBvbiB0aGUgc2Vuc29yLgoKV2l0aCB0aGlz IGNoYW5nZSwgdGhlc2UgZm91ciBzeXNmcyBlbnRyaWVzIGhhdmUgdGhlaXIgcHJlZml4IGNoYW5n ZWQKZnJvbSBpbGx1bWluYW5jZTBfIHRvIGluX2lsbHVtaW5hbmNlXy4gVGhpcyBpcyBkZWVtZWQg dG8gYmUgYWNjZXB0YWJsZQpzaW5jZSBub25lIG9mIHRoZSBJSU8gbGlnaHQgZHJpdmVycyBpbiBt YWlubGluZSB1c2UgdGhlIGlsbHVtaW5hbmNlMF8KcHJlZml4LCBob3dldmVyIDggb2YgdGhlIElJ TyBsaWdodCBkcml2ZXJzIGluIG1haW5saW5lIHVzZSB0aGUKaW5faWxsdW1pbmFuY2VfIHByZWZp eC4KClNpZ25lZC1vZmYtYnk6IEJyaWFuIE1hc25leSA8bWFzbmV5YkBvbnN0YXRpb24ub3JnPgot LS0KIGRyaXZlcnMvc3RhZ2luZy9paW8vbGlnaHQvdHNsMjU4My5jIHwgMjM2ICsrKysrKysrKysr KysrKysrKysrKystLS0tLS0tLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDE0MyBpbnNlcnRpb25z KCspLCA5MyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2xp Z2h0L3RzbDI1ODMuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vbGlnaHQvdHNsMjU4My5jCmluZGV4 IGU5NzViYmEuLjZhNjFhODYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vbGlnaHQv dHNsMjU4My5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vbGlnaHQvdHNsMjU4My5jCkBAIC0y MTEsMjggKzIxMSwyMyBAQCBzdGF0aWMgaW50IHRhb3NfZ2V0X2x1eChzdHJ1Y3QgaWlvX2RldiAq aW5kaW9fZGV2KQogCXUzMiBjaDBsdXggPSAwOwogCXUzMiBjaDFsdXggPSAwOwogCi0JaWYgKG11 dGV4X3RyeWxvY2soJmNoaXAtPmFsc19tdXRleCkgPT0gMCkgewotCQlkZXZfaW5mbygmY2hpcC0+ Y2xpZW50LT5kZXYsICJ0YW9zX2dldF9sdXggZGV2aWNlIGlzIGJ1c3lcbiIpOwotCQlyZXR1cm4g Y2hpcC0+YWxzX2N1cl9pbmZvLmx1eDsgLyogYnVzeSwgc28gcmV0dXJuIExBU1QgVkFMVUUgKi8K LQl9Ci0KIAlpZiAoY2hpcC0+dGFvc19jaGlwX3N0YXR1cyAhPSBUU0wyNThYX0NISVBfV09SS0lO RykgewogCQkvKiBkZXZpY2UgaXMgbm90IGVuYWJsZWQgKi8KIAkJZGV2X2VycigmY2hpcC0+Y2xp ZW50LT5kZXYsICJ0YW9zX2dldF9sdXggZGV2aWNlIGlzIG5vdCBlbmFibGVkXG4iKTsKIAkJcmV0 ID0gLUVCVVNZOwotCQlnb3RvIG91dF91bmxvY2s7CisJCWdvdG8gZG9uZTsKIAl9CiAKIAlyZXQg PSB0YW9zX2kyY19yZWFkKGNoaXAtPmNsaWVudCwgKFRTTDI1OFhfQ01EX1JFRyksICZidWZbMF0s IDEpOwogCWlmIChyZXQgPCAwKSB7CiAJCWRldl9lcnIoJmNoaXAtPmNsaWVudC0+ZGV2LCAidGFv c19nZXRfbHV4IGZhaWxlZCB0byByZWFkIENNRF9SRUdcbiIpOwotCQlnb3RvIG91dF91bmxvY2s7 CisJCWdvdG8gZG9uZTsKIAl9CiAJLyogaXMgZGF0YSBuZXcgJiB2YWxpZCAqLwogCWlmICghKGJ1 ZlswXSAmIFRTTDI1OFhfU1RBX0FEQ19JTlRSKSkgewogCQlkZXZfZXJyKCZjaGlwLT5jbGllbnQt PmRldiwgInRhb3NfZ2V0X2x1eCBkYXRhIG5vdCB2YWxpZFxuIik7CiAJCXJldCA9IGNoaXAtPmFs c19jdXJfaW5mby5sdXg7IC8qIHJldHVybiBMQVNUIFZBTFVFICovCi0JCWdvdG8gb3V0X3VubG9j azsKKwkJZ290byBkb25lOwogCX0KIAogCWZvciAoaSA9IDA7IGkgPCA0OyBpKyspIHsKQEAgLTI0 Myw3ICsyMzgsNyBAQCBzdGF0aWMgaW50IHRhb3NfZ2V0X2x1eChzdHJ1Y3QgaWlvX2RldiAqaW5k aW9fZGV2KQogCQkJZGV2X2VycigmY2hpcC0+Y2xpZW50LT5kZXYsCiAJCQkJInRhb3NfZ2V0X2x1 eCBmYWlsZWQgdG8gcmVhZCByZWdpc3RlciAleFxuIiwKIAkJCQlyZWcpOwotCQkJZ290byBvdXRf dW5sb2NrOworCQkJZ290byBkb25lOwogCQl9CiAJfQogCkBAIC0yNTksNyArMjU0LDcgQEAgc3Rh dGljIGludCB0YW9zX2dldF9sdXgoc3RydWN0IGlpb19kZXYgKmluZGlvX2RldikKIAkJZGV2X2Vy cigmY2hpcC0+Y2xpZW50LT5kZXYsCiAJCQkidGFvc19pMmNfd3JpdGVfY29tbWFuZCBmYWlsZWQg aW4gdGFvc19nZXRfbHV4LCBlcnIgPSAlZFxuIiwKIAkJCXJldCk7Ci0JCWdvdG8gb3V0X3VubG9j azsgLyogaGF2ZSBubyBkYXRhLCBzbyByZXR1cm4gZmFpbHVyZSAqLworCQlnb3RvIGRvbmU7IC8q IGhhdmUgbm8gZGF0YSwgc28gcmV0dXJuIGZhaWx1cmUgKi8KIAl9CiAKIAkvKiBleHRyYWN0IEFM Uy9sdXggZGF0YSAqLwpAQCAtMjc2LDcgKzI3MSw3IEBAIHN0YXRpYyBpbnQgdGFvc19nZXRfbHV4 KHN0cnVjdCBpaW9fZGV2ICppbmRpb19kZXYpCiAJCS8qIGhhdmUgbm8gZGF0YSwgc28gcmV0dXJu IExBU1QgVkFMVUUgKi8KIAkJcmV0ID0gMDsKIAkJY2hpcC0+YWxzX2N1cl9pbmZvLmx1eCA9IDA7 Ci0JCWdvdG8gb3V0X3VubG9jazsKKwkJZ290byBkb25lOwogCX0KIAkvKiBjYWxjdWxhdGUgcmF0 aW8gKi8KIAlyYXRpbyA9IChjaDEgPDwgMTUpIC8gY2gwOwpAQCAtMzAyLDcgKzI5Nyw3IEBAIHN0 YXRpYyBpbnQgdGFvc19nZXRfbHV4KHN0cnVjdCBpaW9fZGV2ICppbmRpb19kZXYpCiAJCWRldl9k YmcoJmNoaXAtPmNsaWVudC0+ZGV2LCAiTm8gRGF0YSAtIFJldHVybiBsYXN0IHZhbHVlXG4iKTsK IAkJcmV0ID0gMDsKIAkJY2hpcC0+YWxzX2N1cl9pbmZvLmx1eCA9IDA7Ci0JCWdvdG8gb3V0X3Vu bG9jazsKKwkJZ290byBkb25lOwogCX0KIAogCS8qIGFkanVzdCBmb3IgYWN0aXZlIHRpbWUgc2Nh bGUgKi8KQEAgLTMzNCw4ICszMjksNyBAQCBzdGF0aWMgaW50IHRhb3NfZ2V0X2x1eChzdHJ1Y3Qg aWlvX2RldiAqaW5kaW9fZGV2KQogCWNoaXAtPmFsc19jdXJfaW5mby5sdXggPSBsdXg7CiAJcmV0 ID0gbHV4OwogCi1vdXRfdW5sb2NrOgotCW11dGV4X3VubG9jaygmY2hpcC0+YWxzX211dGV4KTsK K2RvbmU6CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtNTc1LDY5ICs1NjksMTIgQEAgc3RhdGljIHNz aXplX3QgdGFvc19nYWluX2F2YWlsYWJsZV9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwKIAlyZXR1 cm4gc3ByaW50ZihidWYsICIlc1xuIiwgIjEgOCAxNiAxMTEiKTsKIH0KIAotc3RhdGljIHNzaXpl X3QgdGFvc19hbHNfdGltZV9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwKLQkJCQkgIHN0cnVjdCBk ZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCi17Ci0Jc3RydWN0IGlpb19kZXYgKmlu ZGlvX2RldiA9IGRldl90b19paW9fZGV2KGRldik7Ci0Jc3RydWN0IHRzbDI1ODNfY2hpcCAqY2hp cCA9IGlpb19wcml2KGluZGlvX2Rldik7Ci0KLQlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwg Y2hpcC0+dGFvc19zZXR0aW5ncy5hbHNfdGltZSk7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IHRhb3Nf YWxzX3RpbWVfc3RvcmUoc3RydWN0IGRldmljZSAqZGV2LAotCQkJCSAgIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLAotCQkJCSAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGxlbikKLXsK LQlzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2ID0gZGV2X3RvX2lpb19kZXYoZGV2KTsKLQlzdHJ1 Y3QgdHNsMjU4M19jaGlwICpjaGlwID0gaWlvX3ByaXYoaW5kaW9fZGV2KTsKLQlpbnQgdmFsdWU7 Ci0KLQlpZiAoa3N0cnRvaW50KGJ1ZiwgMCwgJnZhbHVlKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0K LQlpZiAoKHZhbHVlIDwgNTApIHx8ICh2YWx1ZSA+IDY1MCkpCi0JCXJldHVybiAtRUlOVkFMOwot Ci0JaWYgKHZhbHVlICUgNTApCi0JCXJldHVybiAtRUlOVkFMOwotCi0JY2hpcC0+dGFvc19zZXR0 aW5ncy5hbHNfdGltZSA9IHZhbHVlOwotCi0JcmV0dXJuIGxlbjsKLX0KLQogc3RhdGljIHNzaXpl X3QgdGFvc19hbHNfdGltZV9hdmFpbGFibGVfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJCQkJ CSAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKIAkJCQkJICAgIGNoYXIgKmJ1ZikK IHsKIAlyZXR1cm4gc3ByaW50ZihidWYsICIlc1xuIiwKLQkJIjUwIDEwMCAxNTAgMjAwIDI1MCAz MDAgMzUwIDQwMCA0NTAgNTAwIDU1MCA2MDAgNjUwIik7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IHRh b3NfYWxzX3RyaW1fc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsCi0JCQkJICBzdHJ1Y3QgZGV2aWNl X2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQotewotCXN0cnVjdCBpaW9fZGV2ICppbmRpb19k ZXYgPSBkZXZfdG9faWlvX2RldihkZXYpOwotCXN0cnVjdCB0c2wyNTgzX2NoaXAgKmNoaXAgPSBp aW9fcHJpdihpbmRpb19kZXYpOwotCi0JcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIGNoaXAt PnRhb3Nfc2V0dGluZ3MuYWxzX2dhaW5fdHJpbSk7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IHRhb3Nf YWxzX3RyaW1fc3RvcmUoc3RydWN0IGRldmljZSAqZGV2LAotCQkJCSAgIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLAotCQkJCSAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGxlbikKLXsK LQlzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2ID0gZGV2X3RvX2lpb19kZXYoZGV2KTsKLQlzdHJ1 Y3QgdHNsMjU4M19jaGlwICpjaGlwID0gaWlvX3ByaXYoaW5kaW9fZGV2KTsKLQlpbnQgdmFsdWU7 Ci0KLQlpZiAoa3N0cnRvaW50KGJ1ZiwgMCwgJnZhbHVlKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0K LQlpZiAodmFsdWUpCi0JCWNoaXAtPnRhb3Nfc2V0dGluZ3MuYWxzX2dhaW5fdHJpbSA9IHZhbHVl OwotCi0JcmV0dXJuIGxlbjsKKwkJIjAuMDAwMDUwIDAuMDAwMTAwIDAuMDAwMTUwIDAuMDAwMjAw IDAuMDAwMjUwIDAuMDAwMzAwIDAuMDAwMzUwIDAuMDAwNDAwIDAuMDAwNDUwIDAuMDAwNTAwIDAu MDAwNTUwIDAuMDAwNjAwIDAuMDAwNjUwIik7CiB9CiAKIHN0YXRpYyBzc2l6ZV90IHRhb3NfYWxz X2NhbF90YXJnZXRfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsCkBAIC02NjcsMTggKzYwNCw2IEBA IHN0YXRpYyBzc2l6ZV90IHRhb3NfYWxzX2NhbF90YXJnZXRfc3RvcmUoc3RydWN0IGRldmljZSAq ZGV2LAogCXJldHVybiBsZW47CiB9CiAKLXN0YXRpYyBzc2l6ZV90IHRhb3NfbHV4X3Nob3coc3Ry dWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKLQkJCSAgICAg Y2hhciAqYnVmKQotewotCWludCByZXQ7Ci0KLQlyZXQgPSB0YW9zX2dldF9sdXgoZGV2X3RvX2lp b19kZXYoZGV2KSk7Ci0JaWYgKHJldCA8IDApCi0JCXJldHVybiByZXQ7Ci0KLQlyZXR1cm4gc3By aW50ZihidWYsICIlZFxuIiwgcmV0KTsKLX0KLQogc3RhdGljIHNzaXplX3QgdGFvc19kb19jYWxp YnJhdGUoc3RydWN0IGRldmljZSAqZGV2LAogCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAq YXR0ciwKIAkJCQkgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgbGVuKQpAQCAtNzcxLDE4ICs2OTYs MTIgQEAgc3RhdGljIERFVklDRV9BVFRSKGlsbHVtaW5hbmNlMF9jYWxpYnNjYWxlLCBTX0lSVUdP IHwgU19JV1VTUiwKIHN0YXRpYyBERVZJQ0VfQVRUUihpbGx1bWluYW5jZTBfY2FsaWJzY2FsZV9h dmFpbGFibGUsIFNfSVJVR08sCiAJCXRhb3NfZ2Fpbl9hdmFpbGFibGVfc2hvdywgTlVMTCk7CiAK LXN0YXRpYyBERVZJQ0VfQVRUUihpbGx1bWluYW5jZTBfaW50ZWdyYXRpb25fdGltZSwgU19JUlVH TyB8IFNfSVdVU1IsCi0JCXRhb3NfYWxzX3RpbWVfc2hvdywgdGFvc19hbHNfdGltZV9zdG9yZSk7 CiBzdGF0aWMgREVWSUNFX0FUVFIoaWxsdW1pbmFuY2UwX2ludGVncmF0aW9uX3RpbWVfYXZhaWxh YmxlLCBTX0lSVUdPLAogCQl0YW9zX2Fsc190aW1lX2F2YWlsYWJsZV9zaG93LCBOVUxMKTsKIAot c3RhdGljIERFVklDRV9BVFRSKGlsbHVtaW5hbmNlMF9jYWxpYmJpYXMsIFNfSVJVR08gfCBTX0lX VVNSLAotCQl0YW9zX2Fsc190cmltX3Nob3csIHRhb3NfYWxzX3RyaW1fc3RvcmUpOwotCiBzdGF0 aWMgREVWSUNFX0FUVFIoaWxsdW1pbmFuY2UwX2lucHV0X3RhcmdldCwgU19JUlVHTyB8IFNfSVdV U1IsCiAJCXRhb3NfYWxzX2NhbF90YXJnZXRfc2hvdywgdGFvc19hbHNfY2FsX3RhcmdldF9zdG9y ZSk7CiAKLXN0YXRpYyBERVZJQ0VfQVRUUihpbGx1bWluYW5jZTBfaW5wdXQsIFNfSVJVR08sIHRh b3NfbHV4X3Nob3csIE5VTEwpOwogc3RhdGljIERFVklDRV9BVFRSKGlsbHVtaW5hbmNlMF9jYWxp YnJhdGUsIFNfSVdVU1IsIE5VTEwsIHRhb3NfZG9fY2FsaWJyYXRlKTsKIHN0YXRpYyBERVZJQ0Vf QVRUUihpbGx1bWluYW5jZTBfbHV4X3RhYmxlLCBTX0lSVUdPIHwgU19JV1VTUiwKIAkJdGFvc19s dXh0YWJsZV9zaG93LCB0YW9zX2x1eHRhYmxlX3N0b3JlKTsKQEAgLTc5MCwxMSArNzA5LDggQEAg c3RhdGljIERFVklDRV9BVFRSKGlsbHVtaW5hbmNlMF9sdXhfdGFibGUsIFNfSVJVR08gfCBTX0lX VVNSLAogc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnN5c2ZzX2F0dHJzX2N0cmxbXSA9IHsKIAkm ZGV2X2F0dHJfaWxsdW1pbmFuY2UwX2NhbGlic2NhbGUuYXR0ciwJCQkvKiBHYWluICAqLwogCSZk ZXZfYXR0cl9pbGx1bWluYW5jZTBfY2FsaWJzY2FsZV9hdmFpbGFibGUuYXR0ciwKLQkmZGV2X2F0 dHJfaWxsdW1pbmFuY2UwX2ludGVncmF0aW9uX3RpbWUuYXR0ciwJLyogSSB0aW1lKi8KIAkmZGV2 X2F0dHJfaWxsdW1pbmFuY2UwX2ludGVncmF0aW9uX3RpbWVfYXZhaWxhYmxlLmF0dHIsCi0JJmRl dl9hdHRyX2lsbHVtaW5hbmNlMF9jYWxpYmJpYXMuYXR0ciwJCQkvKiB0cmltICAqLwogCSZkZXZf YXR0cl9pbGx1bWluYW5jZTBfaW5wdXRfdGFyZ2V0LmF0dHIsCi0JJmRldl9hdHRyX2lsbHVtaW5h bmNlMF9pbnB1dC5hdHRyLAogCSZkZXZfYXR0cl9pbGx1bWluYW5jZTBfY2FsaWJyYXRlLmF0dHIs CiAJJmRldl9hdHRyX2lsbHVtaW5hbmNlMF9sdXhfdGFibGUuYXR0ciwKIAlOVUxMCkBAIC04MTAs OSArNzI2LDE0MSBAQCBzdGF0aWMgaW50IHRhb3NfdHNsMjU4eF9kZXZpY2UodW5zaWduZWQgY2hh ciAqYnVmcCkKIAlyZXR1cm4gKChidWZwW1RTTDI1OFhfQ0hJUElEXSAmIDB4ZjApID09IDB4OTAp OwogfQogCitzdGF0aWMgY29uc3Qgc3RydWN0IGlpb19jaGFuX3NwZWMgdHNsMjU4M19jaGFubmVs c1tdID0geworCXsKKwkJLnR5cGUgPSBJSU9fTElHSFQsCisJCS5tb2RpZmllZCA9IDEsCisJCS5j aGFubmVsMiA9IElJT19NT0RfTElHSFRfSVIsCisJCS5pbmZvX21hc2tfc2VwYXJhdGUgPSBCSVQo SUlPX0NIQU5fSU5GT19SQVcpLAorCX0sCisJeworCQkudHlwZSA9IElJT19MSUdIVCwKKwkJLm1v ZGlmaWVkID0gMSwKKwkJLmNoYW5uZWwyID0gSUlPX01PRF9MSUdIVF9CT1RILAorCQkuaW5mb19t YXNrX3NlcGFyYXRlID0gQklUKElJT19DSEFOX0lORk9fUkFXKSwKKwl9LAorCXsKKwkJLnR5cGUg PSBJSU9fTElHSFQsCisJCS5pbmZvX21hc2tfc2VwYXJhdGUgPSBCSVQoSUlPX0NIQU5fSU5GT19Q Uk9DRVNTRUQpIHwKKwkJCQkgICAgICBCSVQoSUlPX0NIQU5fSU5GT19DQUxJQkJJQVMpIHwKKwkJ CQkgICAgICBCSVQoSUlPX0NIQU5fSU5GT19JTlRfVElNRSksCisJfSwKK307CisKK3N0YXRpYyBp bnQgdHNsMjU4M19yZWFkX3JhdyhzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2LAorCQkJICAgIHN0 cnVjdCBpaW9fY2hhbl9zcGVjIGNvbnN0ICpjaGFuLAorCQkJICAgIGludCAqdmFsLCBpbnQgKnZh bDIsIGxvbmcgbWFzaykKK3sKKwlzdHJ1Y3QgdHNsMjU4M19jaGlwICpjaGlwID0gaWlvX3ByaXYo aW5kaW9fZGV2KTsKKwlpbnQgcmV0ID0gLUVJTlZBTDsKKworCW11dGV4X2xvY2soJmNoaXAtPmFs c19tdXRleCk7CisKKwlpZiAoY2hpcC0+dGFvc19jaGlwX3N0YXR1cyAhPSBUU0wyNThYX0NISVBf V09SS0lORykgeworCQlyZXQgPSAtRUJVU1k7CisJCWdvdG8gcmVhZF9kb25lOworCX0KKworCXN3 aXRjaCAobWFzaykgeworCWNhc2UgSUlPX0NIQU5fSU5GT19SQVc6CisJCWlmIChjaGFuLT50eXBl ID09IElJT19MSUdIVCkgeworCQkJcmV0ID0gdGFvc19nZXRfbHV4KGluZGlvX2Rldik7CisJCQlp ZiAocmV0IDwgMCkKKwkJCQlnb3RvIHJlYWRfZG9uZTsKKworCQkJLyoKKwkJCSAqIEZyb20gcGFn ZSAyMCBvZiB0aGUgVFNMMjU4MSwgVFNMMjU4MyBkYXRhCisJCQkgKiBzaGVldCAoVEFPUzEzNCDi iJIgTUFSQ0ggMjAxMSk6CisJCQkgKgorCQkJICogT25lIG9mIHRoZSBwaG90b2Rpb2RlcyAoY2hh bm5lbCAwKSBpcworCQkJICogc2Vuc2l0aXZlIHRvIGJvdGggdmlzaWJsZSBhbmQgaW5mcmFyZWQg bGlnaHQsCisJCQkgKiB3aGlsZSB0aGUgc2Vjb25kIHBob3RvZGlvZGUgKGNoYW5uZWwgMSkgaXMK KwkJCSAqIHNlbnNpdGl2ZSBwcmltYXJpbHkgdG8gaW5mcmFyZWQgbGlnaHQuCisJCQkgKi8KKwkJ CWlmIChjaGFuLT5jaGFubmVsMiA9PSBJSU9fTU9EX0xJR0hUX0JPVEgpCisJCQkJKnZhbCA9IGNo aXAtPmFsc19jdXJfaW5mby5hbHNfY2gwOworCQkJZWxzZQorCQkJCSp2YWwgPSBjaGlwLT5hbHNf Y3VyX2luZm8uYWxzX2NoMTsKKworCQkJcmV0ID0gSUlPX1ZBTF9JTlQ7CisJCX0KKwkJYnJlYWs7 CisJY2FzZSBJSU9fQ0hBTl9JTkZPX1BST0NFU1NFRDoKKwkJaWYgKGNoYW4tPnR5cGUgPT0gSUlP X0xJR0hUKSB7CisJCQlyZXQgPSB0YW9zX2dldF9sdXgoaW5kaW9fZGV2KTsKKwkJCWlmIChyZXQg PCAwKQorCQkJCWdvdG8gcmVhZF9kb25lOworCisJCQkqdmFsID0gcmV0OworCQkJcmV0ID0gSUlP X1ZBTF9JTlQ7CisJCX0KKwkJYnJlYWs7CisJY2FzZSBJSU9fQ0hBTl9JTkZPX0NBTElCQklBUzoK KwkJaWYgKGNoYW4tPnR5cGUgPT0gSUlPX0xJR0hUKSB7CisJCQkqdmFsID0gY2hpcC0+dGFvc19z ZXR0aW5ncy5hbHNfZ2Fpbl90cmltOworCQkJcmV0ID0gSUlPX1ZBTF9JTlQ7CisJCX0KKwkJYnJl YWs7CisJY2FzZSBJSU9fQ0hBTl9JTkZPX0lOVF9USU1FOgorCQlpZiAoY2hhbi0+dHlwZSA9PSBJ SU9fTElHSFQpIHsKKwkJCSp2YWwgPSAwOworCQkJKnZhbDIgPSBjaGlwLT50YW9zX3NldHRpbmdz LmFsc190aW1lOworCQkJcmV0ID0gSUlPX1ZBTF9JTlRfUExVU19NSUNSTzsKKwkJfQorCQlicmVh azsKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9CisKK3JlYWRfZG9uZToKKwltdXRleF91bmxvY2so JmNoaXAtPmFsc19tdXRleCk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IHRzbDI1 ODNfd3JpdGVfcmF3KHN0cnVjdCBpaW9fZGV2ICppbmRpb19kZXYsCisJCQkgICAgIHN0cnVjdCBp aW9fY2hhbl9zcGVjIGNvbnN0ICpjaGFuLAorCQkJICAgICBpbnQgdmFsLCBpbnQgdmFsMiwgbG9u ZyBtYXNrKQoreworCXN0cnVjdCB0c2wyNTgzX2NoaXAgKmNoaXAgPSBpaW9fcHJpdihpbmRpb19k ZXYpOworCWludCByZXQgPSAtRUlOVkFMOworCisJbXV0ZXhfbG9jaygmY2hpcC0+YWxzX211dGV4 KTsKKworCWlmIChjaGlwLT50YW9zX2NoaXBfc3RhdHVzICE9IFRTTDI1OFhfQ0hJUF9XT1JLSU5H KSB7CisJCXJldCA9IC1FQlVTWTsKKwkJZ290byB3cml0ZV9kb25lOworCX0KKworCXN3aXRjaCAo bWFzaykgeworCWNhc2UgSUlPX0NIQU5fSU5GT19DQUxJQkJJQVM6CisJCWlmIChjaGFuLT50eXBl ID09IElJT19MSUdIVCkgeworCQkJY2hpcC0+dGFvc19zZXR0aW5ncy5hbHNfZ2Fpbl90cmltID0g dmFsOworCQkJcmV0ID0gMDsKKwkJfQorCQlicmVhazsKKwljYXNlIElJT19DSEFOX0lORk9fSU5U X1RJTUU6CisJCWlmIChjaGFuLT50eXBlID09IElJT19MSUdIVCAmJiAhdmFsICYmIHZhbDIgPj0g NTAgJiYKKwkJICAgIHZhbDIgPD0gNjUwICYmICEodmFsMiAlIDUwKSkgeworCQkJY2hpcC0+dGFv c19zZXR0aW5ncy5hbHNfdGltZSA9IHZhbDI7CisJCQlyZXQgPSAwOworCQl9CisJCWJyZWFrOwor CWRlZmF1bHQ6CisJCWJyZWFrOworCX0KKword3JpdGVfZG9uZToKKwltdXRleF91bmxvY2soJmNo aXAtPmFsc19tdXRleCk7CisKKwlyZXR1cm4gcmV0OworfQorCiBzdGF0aWMgY29uc3Qgc3RydWN0 IGlpb19pbmZvIHRzbDI1ODNfaW5mbyA9IHsKIAkuYXR0cnMgPSAmdHNsMjU4M19hdHRyaWJ1dGVf Z3JvdXAsCiAJLmRyaXZlcl9tb2R1bGUgPSBUSElTX01PRFVMRSwKKwkucmVhZF9yYXcgPSB0c2wy NTgzX3JlYWRfcmF3LAorCS53cml0ZV9yYXcgPSB0c2wyNTgzX3dyaXRlX3JhdywKIH07CiAKIC8q CkBAIC04NzgsNiArOTI2LDggQEAgc3RhdGljIGludCB0YW9zX3Byb2JlKHN0cnVjdCBpMmNfY2xp ZW50ICpjbGllbnRwLAogCX0KIAogCWluZGlvX2Rldi0+aW5mbyA9ICZ0c2wyNTgzX2luZm87CisJ aW5kaW9fZGV2LT5jaGFubmVscyA9IHRzbDI1ODNfY2hhbm5lbHM7CisJaW5kaW9fZGV2LT5udW1f Y2hhbm5lbHMgPSBBUlJBWV9TSVpFKHRzbDI1ODNfY2hhbm5lbHMpOwogCWluZGlvX2Rldi0+ZGV2 LnBhcmVudCA9ICZjbGllbnRwLT5kZXY7CiAJaW5kaW9fZGV2LT5tb2RlcyA9IElORElPX0RJUkVD VF9NT0RFOwogCWluZGlvX2Rldi0+bmFtZSA9IGNoaXAtPmNsaWVudC0+bmFtZTsKLS0gCjIuNy40 CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkZXZlbCBt YWlsaW5nIGxpc3QKZGV2ZWxAbGludXhkcml2ZXJwcm9qZWN0Lm9yZwpodHRwOi8vZHJpdmVyZGV2 LmxpbnV4ZHJpdmVycHJvamVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcml2ZXJkZXYtZGV2ZWwK