From mboxrd@z Thu Jan 1 00:00:00 1970 From: lee.jones@linaro.org (Lee Jones) Date: Mon, 22 Apr 2013 11:47:36 +0100 Subject: [PATCH 14/23] regulator: ab3100: device tree support In-Reply-To: <1366624645-6614-1-git-send-email-linus.walleij@stericsson.com> References: <1366624645-6614-1-git-send-email-linus.walleij@stericsson.com> Message-ID: <20130422104736.GM3432@gmail.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Mon, 22 Apr 2013, Linus Walleij wrote: > From: Linus Walleij > > This implements device tree support for the AB3100 regulators > driver. The initial settings are moved out of platform data > and into the driver for the device tree case, as it appears > that there is no way to supply this as AUXDATA for an I2C > device. The style and bindings are heavily inspired by > Lee Jones' style for AB8500. > > Cc: Lee Jones > Cc: Mark Brown > Signed-off-by: Linus Walleij I don't see any issues with it. Acked-by: Lee Jones > --- > Hi Mark, seeking an ACK on this to take it through the ARM > SoC tree. > --- > drivers/mfd/ab3100-core.c | 1 + > drivers/regulator/ab3100.c | 123 ++++++++++++++++++++++++++++++++++++++++++--- > 2 files changed, 118 insertions(+), 6 deletions(-) > > diff --git a/drivers/mfd/ab3100-core.c b/drivers/mfd/ab3100-core.c > index 2ec7725..a9bb140 100644 > --- a/drivers/mfd/ab3100-core.c > +++ b/drivers/mfd/ab3100-core.c > @@ -753,6 +753,7 @@ static struct mfd_cell ab3100_devs[] = { > }, > { > .name = "ab3100-regulators", > + .of_compatible = "stericsson,ab3100-regulators", > .id = -1, > }, > { > diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c > index 740735d..be1e6ad 100644 > --- a/drivers/regulator/ab3100.c > +++ b/drivers/regulator/ab3100.c > @@ -17,6 +17,8 @@ > #include > #include > #include > +#include > +#include > > /* LDO registers and some handy masking definitions for AB3100 */ > #define AB3100_LDO_A 0x40 > @@ -345,7 +347,11 @@ static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg) > { > struct ab3100_regulator *abreg = rdev_get_drvdata(reg); > > - return abreg->plfdata->external_voltage; > + if (abreg->plfdata) > + return abreg->plfdata->external_voltage; > + else > + /* TODO: encode external voltage into device tree */ > + return 0; > } > > static struct regulator_ops regulator_ops_fixed = { > @@ -490,6 +496,8 @@ ab3100_regulator_desc[AB3100_NUM_REGULATORS] = { > > static int ab3100_regulator_register(struct platform_device *pdev, > struct ab3100_platform_data *plfdata, > + struct regulator_init_data *init_data, > + struct device_node *np, > int id) > { > struct regulator_desc *desc; > @@ -518,9 +526,11 @@ static int ab3100_regulator_register(struct platform_device *pdev, > */ > reg->dev = &pdev->dev; > if (plfdata) { > - /* This will be replaced by device tree data */ > reg->plfdata = plfdata; > config.init_data = &plfdata->reg_constraints[i]; > + } else if (np) { > + config.of_node = np; > + config.init_data = init_data; > } > config.dev = &pdev->dev; > config.driver_data = reg; > @@ -540,15 +550,103 @@ static int ab3100_regulator_register(struct platform_device *pdev, > return 0; > } > > +static struct of_regulator_match ab3100_regulator_matches[] = { > + { .name = "ab3100_ldo_a", .driver_data = (void *) AB3100_LDO_A, }, > + { .name = "ab3100_ldo_c", .driver_data = (void *) AB3100_LDO_C, }, > + { .name = "ab3100_ldo_d", .driver_data = (void *) AB3100_LDO_D, }, > + { .name = "ab3100_ldo_e", .driver_data = (void *) AB3100_LDO_E, }, > + { .name = "ab3100_ldo_f", .driver_data = (void *) AB3100_LDO_F }, > + { .name = "ab3100_ldo_g", .driver_data = (void *) AB3100_LDO_G }, > + { .name = "ab3100_ldo_h", .driver_data = (void *) AB3100_LDO_H }, > + { .name = "ab3100_ldo_k", .driver_data = (void *) AB3100_LDO_K }, > + { .name = "ab3100_ext", .driver_data = (void *) AB3100_LDO_EXT }, > + { .name = "ab3100_buck", .driver_data = (void *) AB3100_BUCK }, > +}; > + > /* > - * NOTE: the following functions are regulators pluralis - it is the > - * binding to the AB3100 core driver and the parent platform device > - * for all the different regulators. > + * Initial settings of ab3100 registers. > + * Common for below LDO regulator settings are that > + * bit 7-5 controls voltage. Bit 4 turns regulator ON(1) or OFF(0). > + * Bit 3-2 controls sleep enable and bit 1-0 controls sleep mode. > */ > +/* LDO_A 0x16: 2.75V, ON, SLEEP_A, SLEEP OFF GND */ > +#define LDO_A_SETTING 0x16 > +/* LDO_C 0x10: 2.65V, ON, SLEEP_A or B, SLEEP full power */ > +#define LDO_C_SETTING 0x10 > +/* LDO_D 0x10: 2.65V, ON, sleep mode not used */ > +#define LDO_D_SETTING 0x10 > +/* LDO_E 0x10: 1.8V, ON, SLEEP_A or B, SLEEP full power */ > +#define LDO_E_SETTING 0x10 > +/* LDO_E SLEEP 0x00: 1.8V, not used, SLEEP_A or B, not used */ > +#define LDO_E_SLEEP_SETTING 0x00 > +/* LDO_F 0xD0: 2.5V, ON, SLEEP_A or B, SLEEP full power */ > +#define LDO_F_SETTING 0xD0 > +/* LDO_G 0x00: 2.85V, OFF, SLEEP_A or B, SLEEP full power */ > +#define LDO_G_SETTING 0x00 > +/* LDO_H 0x18: 2.75V, ON, SLEEP_B, SLEEP full power */ > +#define LDO_H_SETTING 0x18 > +/* LDO_K 0x00: 2.75V, OFF, SLEEP_A or B, SLEEP full power */ > +#define LDO_K_SETTING 0x00 > +/* LDO_EXT 0x00: Voltage not set, OFF, not used, not used */ > +#define LDO_EXT_SETTING 0x00 > +/* BUCK 0x7D: 1.2V, ON, SLEEP_A and B, SLEEP low power */ > +#define BUCK_SETTING 0x7D > +/* BUCK SLEEP 0xAC: 1.05V, Not used, SLEEP_A and B, Not used */ > +#define BUCK_SLEEP_SETTING 0xAC > + > +static const u8 ab3100_reg_initvals[] = { > + LDO_A_SETTING, > + LDO_C_SETTING, > + LDO_E_SETTING, > + LDO_E_SLEEP_SETTING, > + LDO_F_SETTING, > + LDO_G_SETTING, > + LDO_H_SETTING, > + LDO_K_SETTING, > + LDO_EXT_SETTING, > + BUCK_SETTING, > + BUCK_SLEEP_SETTING, > + LDO_D_SETTING, > +}; > + > +static int > +ab3100_regulator_of_probe(struct platform_device *pdev, struct device_node *np) > +{ > + int err, i; > + > + /* > + * Set up the regulator registers, as was previously done with > + * platform data. > + */ > + /* Set up regulators */ > + for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) { > + err = abx500_set_register_interruptible(&pdev->dev, 0, > + ab3100_reg_init_order[i], > + ab3100_reg_initvals[i]); > + if (err) { > + dev_err(&pdev->dev, "regulator initialization failed with error %d\n", > + err); > + return err; > + } > + } > + > + for (i = 0; i < ARRAY_SIZE(ab3100_regulator_matches); i++) { > + err = ab3100_regulator_register( > + pdev, NULL, ab3100_regulator_matches[i].init_data, > + ab3100_regulator_matches[i].of_node, > + (int) ab3100_regulator_matches[i].driver_data); > + if (err) > + return err; > + } > + > + return 0; > +} > + > > static int ab3100_regulators_probe(struct platform_device *pdev) > { > struct ab3100_platform_data *plfdata = pdev->dev.platform_data; > + struct device_node *np = pdev->dev.of_node; > int err = 0; > u8 data; > int i; > @@ -567,6 +665,18 @@ static int ab3100_regulators_probe(struct platform_device *pdev) > dev_notice(&pdev->dev, > "chip is in inactive mode (Cold start)\n"); > > + if (np) { > + err = of_regulator_match(&pdev->dev, np, > + ab3100_regulator_matches, > + ARRAY_SIZE(ab3100_regulator_matches)); > + if (err < 0) { > + dev_err(&pdev->dev, > + "Error parsing regulator init data: %d\n", err); > + return err; > + } > + return ab3100_regulator_of_probe(pdev, np); > + } > + > /* Set up regulators */ > for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) { > err = abx500_set_register_interruptible(&pdev->dev, 0, > @@ -583,7 +693,8 @@ static int ab3100_regulators_probe(struct platform_device *pdev) > for (i = 0; i < AB3100_NUM_REGULATORS; i++) { > struct regulator_desc *desc = &ab3100_regulator_desc[i]; > > - err = ab3100_regulator_register(pdev, plfdata, desc->id); > + err = ab3100_regulator_register(pdev, plfdata, NULL, NULL, > + desc->id); > if (err) > return err; > } -- Lee Jones Linaro ST-Ericsson Landing Team Lead Linaro.org ? Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lee Jones Subject: Re: [PATCH 14/23] regulator: ab3100: device tree support Date: Mon, 22 Apr 2013 11:47:36 +0100 Message-ID: <20130422104736.GM3432@gmail.com> References: <1366624645-6614-1-git-send-email-linus.walleij@stericsson.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1366624645-6614-1-git-send-email-linus.walleij-0IS4wlFg1OjSUeElwK9/Pw@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: devicetree-discuss-bounces+gldd-devicetree-discuss=m.gmane.org-uLR06cmDAlY/bJ5BZ2RsiQ@public.gmane.org Sender: "devicetree-discuss" To: Linus Walleij Cc: devicetree-discuss-uLR06cmDAlY/bJ5BZ2RsiQ@public.gmane.org, Liam Girdwood , Mark Brown , linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org List-Id: devicetree@vger.kernel.org T24gTW9uLCAyMiBBcHIgMjAxMywgTGludXMgV2FsbGVpaiB3cm90ZToKCj4gRnJvbTogTGludXMg V2FsbGVpaiA8bGludXMud2FsbGVpakBsaW5hcm8ub3JnPgo+IAo+IFRoaXMgaW1wbGVtZW50cyBk ZXZpY2UgdHJlZSBzdXBwb3J0IGZvciB0aGUgQUIzMTAwIHJlZ3VsYXRvcnMKPiBkcml2ZXIuIFRo ZSBpbml0aWFsIHNldHRpbmdzIGFyZSBtb3ZlZCBvdXQgb2YgcGxhdGZvcm0gZGF0YQo+IGFuZCBp bnRvIHRoZSBkcml2ZXIgZm9yIHRoZSBkZXZpY2UgdHJlZSBjYXNlLCBhcyBpdCBhcHBlYXJzCj4g dGhhdCB0aGVyZSBpcyBubyB3YXkgdG8gc3VwcGx5IHRoaXMgYXMgQVVYREFUQSBmb3IgYW4gSTJD Cj4gZGV2aWNlLiBUaGUgc3R5bGUgYW5kIGJpbmRpbmdzIGFyZSBoZWF2aWx5IGluc3BpcmVkIGJ5 Cj4gTGVlIEpvbmVzJyBzdHlsZSBmb3IgQUI4NTAwLgo+IAo+IENjOiBMZWUgSm9uZXMgPGxlZS5q b25lc0BsaW5hcm8ub3JnPgo+IENjOiBNYXJrIEJyb3duIDxicm9vbmllQGtlcm5lbC5vcmc+Cj4g U2lnbmVkLW9mZi1ieTogTGludXMgV2FsbGVpaiA8bGludXMud2FsbGVpakBsaW5hcm8ub3JnPgoK SSBkb24ndCBzZWUgYW55IGlzc3VlcyB3aXRoIGl0LgoKQWNrZWQtYnk6IExlZSBKb25lcyA8bGVl LmpvbmVzQGxpbmFyby5vcmc+Cgo+IC0tLQo+IEhpIE1hcmssIHNlZWtpbmcgYW4gQUNLIG9uIHRo aXMgdG8gdGFrZSBpdCB0aHJvdWdoIHRoZSBBUk0KPiBTb0MgdHJlZS4KPiAtLS0KPiAgZHJpdmVy cy9tZmQvYWIzMTAwLWNvcmUuYyAgfCAgIDEgKwo+ICBkcml2ZXJzL3JlZ3VsYXRvci9hYjMxMDAu YyB8IDEyMyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0KPiAg MiBmaWxlcyBjaGFuZ2VkLCAxMTggaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKPiAKPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvYWIzMTAwLWNvcmUuYyBiL2RyaXZlcnMvbWZkL2FiMzEw MC1jb3JlLmMKPiBpbmRleCAyZWM3NzI1Li5hOWJiMTQwIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv bWZkL2FiMzEwMC1jb3JlLmMKPiArKysgYi9kcml2ZXJzL21mZC9hYjMxMDAtY29yZS5jCj4gQEAg LTc1Myw2ICs3NTMsNyBAQCBzdGF0aWMgc3RydWN0IG1mZF9jZWxsIGFiMzEwMF9kZXZzW10gPSB7 Cj4gIAl9LAo+ICAJewo+ICAJCS5uYW1lID0gImFiMzEwMC1yZWd1bGF0b3JzIiwKPiArCQkub2Zf Y29tcGF0aWJsZSA9ICJzdGVyaWNzc29uLGFiMzEwMC1yZWd1bGF0b3JzIiwKPiAgCQkuaWQgPSAt MSwKPiAgCX0sCj4gIAl7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvcmVndWxhdG9yL2FiMzEwMC5j IGIvZHJpdmVycy9yZWd1bGF0b3IvYWIzMTAwLmMKPiBpbmRleCA3NDA3MzVkLi5iZTFlNmFkIDEw MDY0NAo+IC0tLSBhL2RyaXZlcnMvcmVndWxhdG9yL2FiMzEwMC5jCj4gKysrIGIvZHJpdmVycy9y ZWd1bGF0b3IvYWIzMTAwLmMKPiBAQCAtMTcsNiArMTcsOCBAQAo+ICAjaW5jbHVkZSA8bGludXgv cmVndWxhdG9yL2RyaXZlci5oPgo+ICAjaW5jbHVkZSA8bGludXgvbWZkL2FiMzEwMC5oPgo+ICAj aW5jbHVkZSA8bGludXgvbWZkL2FieDUwMC5oPgo+ICsjaW5jbHVkZSA8bGludXgvb2YuaD4KPiAr I2luY2x1ZGUgPGxpbnV4L3JlZ3VsYXRvci9vZl9yZWd1bGF0b3IuaD4KPiAgCj4gIC8qIExETyBy ZWdpc3RlcnMgYW5kIHNvbWUgaGFuZHkgbWFza2luZyBkZWZpbml0aW9ucyBmb3IgQUIzMTAwICov Cj4gICNkZWZpbmUgQUIzMTAwX0xET19BCQkweDQwCj4gQEAgLTM0NSw3ICszNDcsMTEgQEAgc3Rh dGljIGludCBhYjMxMDBfZ2V0X3ZvbHRhZ2VfcmVndWxhdG9yX2V4dGVybmFsKHN0cnVjdCByZWd1 bGF0b3JfZGV2ICpyZWcpCj4gIHsKPiAgCXN0cnVjdCBhYjMxMDBfcmVndWxhdG9yICphYnJlZyA9 IHJkZXZfZ2V0X2RydmRhdGEocmVnKTsKPiAgCj4gLQlyZXR1cm4gYWJyZWctPnBsZmRhdGEtPmV4 dGVybmFsX3ZvbHRhZ2U7Cj4gKwlpZiAoYWJyZWctPnBsZmRhdGEpCj4gKwkJcmV0dXJuIGFicmVn LT5wbGZkYXRhLT5leHRlcm5hbF92b2x0YWdlOwo+ICsJZWxzZQo+ICsJCS8qIFRPRE86IGVuY29k ZSBleHRlcm5hbCB2b2x0YWdlIGludG8gZGV2aWNlIHRyZWUgKi8KPiArCQlyZXR1cm4gMDsKPiAg fQo+ICAKPiAgc3RhdGljIHN0cnVjdCByZWd1bGF0b3Jfb3BzIHJlZ3VsYXRvcl9vcHNfZml4ZWQg PSB7Cj4gQEAgLTQ5MCw2ICs0OTYsOCBAQCBhYjMxMDBfcmVndWxhdG9yX2Rlc2NbQUIzMTAwX05V TV9SRUdVTEFUT1JTXSA9IHsKPiAgCj4gIHN0YXRpYyBpbnQgYWIzMTAwX3JlZ3VsYXRvcl9yZWdp c3RlcihzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAo+ICAJCQkJICAgICBzdHJ1Y3QgYWIz MTAwX3BsYXRmb3JtX2RhdGEgKnBsZmRhdGEsCj4gKwkJCQkgICAgIHN0cnVjdCByZWd1bGF0b3Jf aW5pdF9kYXRhICppbml0X2RhdGEsCj4gKwkJCQkgICAgIHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAs Cj4gIAkJCQkgICAgIGludCBpZCkKPiAgewo+ICAJc3RydWN0IHJlZ3VsYXRvcl9kZXNjICpkZXNj Owo+IEBAIC01MTgsOSArNTI2LDExIEBAIHN0YXRpYyBpbnQgYWIzMTAwX3JlZ3VsYXRvcl9yZWdp c3RlcihzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAo+ICAJICovCj4gIAlyZWctPmRldiA9 ICZwZGV2LT5kZXY7Cj4gIAlpZiAocGxmZGF0YSkgewo+IC0JCS8qIFRoaXMgd2lsbCBiZSByZXBs YWNlZCBieSBkZXZpY2UgdHJlZSBkYXRhICovCj4gIAkJcmVnLT5wbGZkYXRhID0gcGxmZGF0YTsK PiAgCQljb25maWcuaW5pdF9kYXRhID0gJnBsZmRhdGEtPnJlZ19jb25zdHJhaW50c1tpXTsKPiAr CX0gZWxzZSBpZiAobnApIHsKPiArCQljb25maWcub2Zfbm9kZSA9IG5wOwo+ICsJCWNvbmZpZy5p bml0X2RhdGEgPSBpbml0X2RhdGE7Cj4gIAl9Cj4gIAljb25maWcuZGV2ID0gJnBkZXYtPmRldjsK PiAgCWNvbmZpZy5kcml2ZXJfZGF0YSA9IHJlZzsKPiBAQCAtNTQwLDE1ICs1NTAsMTAzIEBAIHN0 YXRpYyBpbnQgYWIzMTAwX3JlZ3VsYXRvcl9yZWdpc3RlcihzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpwZGV2LAo+ICAJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gK3N0YXRpYyBzdHJ1Y3Qgb2ZfcmVndWxh dG9yX21hdGNoIGFiMzEwMF9yZWd1bGF0b3JfbWF0Y2hlc1tdID0gewo+ICsJeyAubmFtZSA9ICJh YjMxMDBfbGRvX2EiLCAuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSBBQjMxMDBfTERPX0EsIH0sCj4g Kwl7IC5uYW1lID0gImFiMzEwMF9sZG9fYyIsIC5kcml2ZXJfZGF0YSA9ICh2b2lkICopIEFCMzEw MF9MRE9fQywgfSwKPiArCXsgLm5hbWUgPSAiYWIzMTAwX2xkb19kIiwgLmRyaXZlcl9kYXRhID0g KHZvaWQgKikgQUIzMTAwX0xET19ELCB9LAo+ICsJeyAubmFtZSA9ICJhYjMxMDBfbGRvX2UiLCAu ZHJpdmVyX2RhdGEgPSAodm9pZCAqKSBBQjMxMDBfTERPX0UsIH0sCj4gKwl7IC5uYW1lID0gImFi MzEwMF9sZG9fZiIsIC5kcml2ZXJfZGF0YSA9ICh2b2lkICopIEFCMzEwMF9MRE9fRiB9LAo+ICsJ eyAubmFtZSA9ICJhYjMxMDBfbGRvX2ciLCAuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSBBQjMxMDBf TERPX0cgfSwKPiArCXsgLm5hbWUgPSAiYWIzMTAwX2xkb19oIiwgLmRyaXZlcl9kYXRhID0gKHZv aWQgKikgQUIzMTAwX0xET19IIH0sCj4gKwl7IC5uYW1lID0gImFiMzEwMF9sZG9fayIsIC5kcml2 ZXJfZGF0YSA9ICh2b2lkICopIEFCMzEwMF9MRE9fSyB9LAo+ICsJeyAubmFtZSA9ICJhYjMxMDBf ZXh0IiwgLmRyaXZlcl9kYXRhID0gKHZvaWQgKikgQUIzMTAwX0xET19FWFQgfSwKPiArCXsgLm5h bWUgPSAiYWIzMTAwX2J1Y2siLCAuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSBBQjMxMDBfQlVDSyB9 LAo+ICt9Owo+ICsKPiAgLyoKPiAtICogTk9URTogdGhlIGZvbGxvd2luZyBmdW5jdGlvbnMgYXJl IHJlZ3VsYXRvcnMgcGx1cmFsaXMgLSBpdCBpcyB0aGUKPiAtICogYmluZGluZyB0byB0aGUgQUIz MTAwIGNvcmUgZHJpdmVyIGFuZCB0aGUgcGFyZW50IHBsYXRmb3JtIGRldmljZQo+IC0gKiBmb3Ig YWxsIHRoZSBkaWZmZXJlbnQgcmVndWxhdG9ycy4KPiArICogSW5pdGlhbCBzZXR0aW5ncyBvZiBh YjMxMDAgcmVnaXN0ZXJzLgo+ICsgKiBDb21tb24gZm9yIGJlbG93IExETyByZWd1bGF0b3Igc2V0 dGluZ3MgYXJlIHRoYXQKPiArICogYml0IDctNSBjb250cm9scyB2b2x0YWdlLiBCaXQgNCB0dXJu cyByZWd1bGF0b3IgT04oMSkgb3IgT0ZGKDApLgo+ICsgKiBCaXQgMy0yIGNvbnRyb2xzIHNsZWVw IGVuYWJsZSBhbmQgYml0IDEtMCBjb250cm9scyBzbGVlcCBtb2RlLgo+ICAgKi8KPiArLyogTERP X0EgMHgxNjogMi43NVYsIE9OLCBTTEVFUF9BLCBTTEVFUCBPRkYgR05EICovCj4gKyNkZWZpbmUg TERPX0FfU0VUVElORwkJMHgxNgo+ICsvKiBMRE9fQyAweDEwOiAyLjY1ViwgT04sIFNMRUVQX0Eg b3IgQiwgU0xFRVAgZnVsbCBwb3dlciAqLwo+ICsjZGVmaW5lIExET19DX1NFVFRJTkcJCTB4MTAK PiArLyogTERPX0QgMHgxMDogMi42NVYsIE9OLCBzbGVlcCBtb2RlIG5vdCB1c2VkICovCj4gKyNk ZWZpbmUgTERPX0RfU0VUVElORwkJMHgxMAo+ICsvKiBMRE9fRSAweDEwOiAxLjhWLCBPTiwgU0xF RVBfQSBvciBCLCBTTEVFUCBmdWxsIHBvd2VyICovCj4gKyNkZWZpbmUgTERPX0VfU0VUVElORwkJ MHgxMAo+ICsvKiBMRE9fRSBTTEVFUCAweDAwOiAxLjhWLCBub3QgdXNlZCwgU0xFRVBfQSBvciBC LCBub3QgdXNlZCAqLwo+ICsjZGVmaW5lIExET19FX1NMRUVQX1NFVFRJTkcJMHgwMAo+ICsvKiBM RE9fRiAweEQwOiAyLjVWLCBPTiwgU0xFRVBfQSBvciBCLCBTTEVFUCBmdWxsIHBvd2VyICovCj4g KyNkZWZpbmUgTERPX0ZfU0VUVElORwkJMHhEMAo+ICsvKiBMRE9fRyAweDAwOiAyLjg1ViwgT0ZG LCBTTEVFUF9BIG9yIEIsIFNMRUVQIGZ1bGwgcG93ZXIgKi8KPiArI2RlZmluZSBMRE9fR19TRVRU SU5HCQkweDAwCj4gKy8qIExET19IIDB4MTg6IDIuNzVWLCBPTiwgU0xFRVBfQiwgU0xFRVAgZnVs bCBwb3dlciAqLwo+ICsjZGVmaW5lIExET19IX1NFVFRJTkcJCTB4MTgKPiArLyogTERPX0sgMHgw MDogMi43NVYsIE9GRiwgU0xFRVBfQSBvciBCLCBTTEVFUCBmdWxsIHBvd2VyICovCj4gKyNkZWZp bmUgTERPX0tfU0VUVElORwkJMHgwMAo+ICsvKiBMRE9fRVhUIDB4MDA6IFZvbHRhZ2Ugbm90IHNl dCwgT0ZGLCBub3QgdXNlZCwgbm90IHVzZWQgKi8KPiArI2RlZmluZSBMRE9fRVhUX1NFVFRJTkcJ CTB4MDAKPiArLyogQlVDSyAweDdEOiAxLjJWLCBPTiwgU0xFRVBfQSBhbmQgQiwgU0xFRVAgbG93 IHBvd2VyICovCj4gKyNkZWZpbmUgQlVDS19TRVRUSU5HCTB4N0QKPiArLyogQlVDSyBTTEVFUCAw eEFDOiAxLjA1ViwgTm90IHVzZWQsIFNMRUVQX0EgYW5kIEIsIE5vdCB1c2VkICovCj4gKyNkZWZp bmUgQlVDS19TTEVFUF9TRVRUSU5HCTB4QUMKPiArCj4gK3N0YXRpYyBjb25zdCB1OCBhYjMxMDBf cmVnX2luaXR2YWxzW10gPSB7Cj4gKwlMRE9fQV9TRVRUSU5HLAo+ICsJTERPX0NfU0VUVElORywK PiArCUxET19FX1NFVFRJTkcsCj4gKwlMRE9fRV9TTEVFUF9TRVRUSU5HLAo+ICsJTERPX0ZfU0VU VElORywKPiArCUxET19HX1NFVFRJTkcsCj4gKwlMRE9fSF9TRVRUSU5HLAo+ICsJTERPX0tfU0VU VElORywKPiArCUxET19FWFRfU0VUVElORywKPiArCUJVQ0tfU0VUVElORywKPiArCUJVQ0tfU0xF RVBfU0VUVElORywKPiArCUxET19EX1NFVFRJTkcsCj4gK307Cj4gKwo+ICtzdGF0aWMgaW50Cj4g K2FiMzEwMF9yZWd1bGF0b3Jfb2ZfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwg c3RydWN0IGRldmljZV9ub2RlICpucCkKPiArewo+ICsJaW50IGVyciwgaTsKPiArCj4gKwkvKgo+ ICsJICogU2V0IHVwIHRoZSByZWd1bGF0b3IgcmVnaXN0ZXJzLCBhcyB3YXMgcHJldmlvdXNseSBk b25lIHdpdGgKPiArCSAqIHBsYXRmb3JtIGRhdGEuCj4gKwkgKi8KPiArCS8qIFNldCB1cCByZWd1 bGF0b3JzICovCj4gKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShhYjMxMDBfcmVnX2luaXRf b3JkZXIpOyBpKyspIHsKPiArCQllcnIgPSBhYng1MDBfc2V0X3JlZ2lzdGVyX2ludGVycnVwdGli bGUoJnBkZXYtPmRldiwgMCwKPiArCQkJCQlhYjMxMDBfcmVnX2luaXRfb3JkZXJbaV0sCj4gKwkJ CQkJYWIzMTAwX3JlZ19pbml0dmFsc1tpXSk7Cj4gKwkJaWYgKGVycikgewo+ICsJCQlkZXZfZXJy KCZwZGV2LT5kZXYsICJyZWd1bGF0b3IgaW5pdGlhbGl6YXRpb24gZmFpbGVkIHdpdGggZXJyb3Ig JWRcbiIsCj4gKwkJCQllcnIpOwo+ICsJCQlyZXR1cm4gZXJyOwo+ICsJCX0KPiArCX0KPiArCj4g Kwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShhYjMxMDBfcmVndWxhdG9yX21hdGNoZXMpOyBp KyspIHsKPiArCQllcnIgPSBhYjMxMDBfcmVndWxhdG9yX3JlZ2lzdGVyKAo+ICsJCQlwZGV2LCBO VUxMLCBhYjMxMDBfcmVndWxhdG9yX21hdGNoZXNbaV0uaW5pdF9kYXRhLAo+ICsJCQlhYjMxMDBf cmVndWxhdG9yX21hdGNoZXNbaV0ub2Zfbm9kZSwKPiArCQkJKGludCkgYWIzMTAwX3JlZ3VsYXRv cl9tYXRjaGVzW2ldLmRyaXZlcl9kYXRhKTsKPiArCQlpZiAoZXJyKQo+ICsJCQlyZXR1cm4gZXJy Owo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICAKPiAgc3RhdGljIGludCBhYjMx MDBfcmVndWxhdG9yc19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICB7Cj4g IAlzdHJ1Y3QgYWIzMTAwX3BsYXRmb3JtX2RhdGEgKnBsZmRhdGEgPSBwZGV2LT5kZXYucGxhdGZv cm1fZGF0YTsKPiArCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAgPSBwZGV2LT5kZXYub2Zfbm9kZTsK PiAgCWludCBlcnIgPSAwOwo+ICAJdTggZGF0YTsKPiAgCWludCBpOwo+IEBAIC01NjcsNiArNjY1 LDE4IEBAIHN0YXRpYyBpbnQgYWIzMTAwX3JlZ3VsYXRvcnNfcHJvYmUoc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRldikKPiAgCQlkZXZfbm90aWNlKCZwZGV2LT5kZXYsCj4gIAkJCSAgICJjaGlw IGlzIGluIGluYWN0aXZlIG1vZGUgKENvbGQgc3RhcnQpXG4iKTsKPiAgCj4gKwlpZiAobnApIHsK PiArCQllcnIgPSBvZl9yZWd1bGF0b3JfbWF0Y2goJnBkZXYtPmRldiwgbnAsCj4gKwkJCQkJIGFi MzEwMF9yZWd1bGF0b3JfbWF0Y2hlcywKPiArCQkJCQkgQVJSQVlfU0laRShhYjMxMDBfcmVndWxh dG9yX21hdGNoZXMpKTsKPiArCQlpZiAoZXJyIDwgMCkgewo+ICsJCQlkZXZfZXJyKCZwZGV2LT5k ZXYsCj4gKwkJCQkiRXJyb3IgcGFyc2luZyByZWd1bGF0b3IgaW5pdCBkYXRhOiAlZFxuIiwgZXJy KTsKPiArCQkJcmV0dXJuIGVycjsKPiArCQl9Cj4gKwkJcmV0dXJuIGFiMzEwMF9yZWd1bGF0b3Jf b2ZfcHJvYmUocGRldiwgbnApOwo+ICsJfQo+ICsKPiAgCS8qIFNldCB1cCByZWd1bGF0b3JzICov Cj4gIAlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShhYjMxMDBfcmVnX2luaXRfb3JkZXIpOyBp KyspIHsKPiAgCQllcnIgPSBhYng1MDBfc2V0X3JlZ2lzdGVyX2ludGVycnVwdGlibGUoJnBkZXYt PmRldiwgMCwKPiBAQCAtNTgzLDcgKzY5Myw4IEBAIHN0YXRpYyBpbnQgYWIzMTAwX3JlZ3VsYXRv cnNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiAgCWZvciAoaSA9IDA7IGkg PCBBQjMxMDBfTlVNX1JFR1VMQVRPUlM7IGkrKykgewo+ICAJCXN0cnVjdCByZWd1bGF0b3JfZGVz YyAqZGVzYyA9ICZhYjMxMDBfcmVndWxhdG9yX2Rlc2NbaV07Cj4gIAo+IC0JCWVyciA9IGFiMzEw MF9yZWd1bGF0b3JfcmVnaXN0ZXIocGRldiwgcGxmZGF0YSwgZGVzYy0+aWQpOwo+ICsJCWVyciA9 IGFiMzEwMF9yZWd1bGF0b3JfcmVnaXN0ZXIocGRldiwgcGxmZGF0YSwgTlVMTCwgTlVMTCwKPiAr CQkJCQkJZGVzYy0+aWQpOwo+ICAJCWlmIChlcnIpCj4gIAkJCXJldHVybiBlcnI7Cj4gIAl9Cgot LSAKTGVlIEpvbmVzCkxpbmFybyBTVC1Fcmljc3NvbiBMYW5kaW5nIFRlYW0gTGVhZApMaW5hcm8u b3JnIOKUgiBPcGVuIHNvdXJjZSBzb2Z0d2FyZSBmb3IgQVJNIFNvQ3MKRm9sbG93IExpbmFybzog RmFjZWJvb2sgfCBUd2l0dGVyIHwgQmxvZwpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpkZXZpY2V0cmVlLWRpc2N1c3MgbWFpbGluZyBsaXN0CmRldmljZXRy ZWUtZGlzY3Vzc0BsaXN0cy5vemxhYnMub3JnCmh0dHBzOi8vbGlzdHMub3psYWJzLm9yZy9saXN0 aW5mby9kZXZpY2V0cmVlLWRpc2N1c3MK