From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755216Ab3B1BM7 (ORCPT ); Wed, 27 Feb 2013 20:12:59 -0500 Received: from mailout1.samsung.com ([203.254.224.24]:15424 "EHLO mailout1.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751737Ab3B1BM5 (ORCPT ); Wed, 27 Feb 2013 20:12:57 -0500 X-AuditID: cbfee690-b7f6b6d000004563-54-512eaf1753fb Date: Thu, 28 Feb 2013 01:12:55 +0000 (GMT) From: Jingoo Han Subject: Re: [PATCH 1/2] leds: Add support for Palmas LEDs To: Ian Lartey Cc: "linux-kernel@vger.kernel.org" , "linux-leds@vger.kernel.org" , "devicetree-discuss@lists.ozlabs.org" , "ldewangan@nvidia.com" , "j-keerthy@ti.com" , "gg@slimlogic.co.uk" , "cooloney@gmail.com" , "rpurdie@rpsys.net" , "grant.likely@secretlab.ca" , "rob.herring@calxeda.com" , "sameo@linux.intel.com" , "broonie@opensource.wolfsonmicro.com" , Jingoo Han Reply-to: jg1.han@samsung.com MIME-version: 1.0 X-MTR: 20130228011210436@jg1.han Msgkey: 20130228011210436@jg1.han X-EPLocale: en_US.euc-kr X-Priority: 3 X-EPWebmail-Msg-Type: personal X-EPWebmail-Reply-Demand: 0 X-EPApproval-Locale: X-EPHeader: ML X-EPTrCode: X-EPTrName: X-MLAttribute: X-RootMTR: 20130228011210436@jg1.han X-ParentMTR: X-ArchiveUser: EV X-CPGSPASS: Y Content-type: text/plain; charset=euc-kr MIME-version: 1.0 Message-id: <24550733.220381362013975218.JavaMail.weblogic@epml02> X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFnrKJsWRmVeSWpSXmKPExsVy+t8zA12J9XqBBlc3MFlc3jWHzYHR4/Mm uQDGqAZGm8Si5IzMslSF1Lzk/JTMvHRbpdAQN10LJYWM/OISW6VoIwNjPSNTEz0jE3M9S4NY KyNTJYW8xNxUW6UKXaheJYWi5AKg2tzKYqABOal6UHG94tS8FIes/FKQS/SKE3OLS/PS9ZLz c5UUyhJzSoFGKOknTGXM+L37MmPBlZeMFedmHGZpYLzwmLGLkZNDSEBJYtLJvWC2hICJxIHn U5khbDGJC/fWs3UxcgHVLGOUuLF7GlCCA6yo50otRO98RolrZ+NAbBYBVYk/E3cwgdhsAuoS E343s4DYwgJWEh3Nl1hBbBEBNYmvD3YygsxkFjjGKtH7cgkzxCBZiXuTZ4PZvAKCEidnPmGB OEJBomfFLzaIuKLE2kk/2SDiEhJ37u9nhbB5JWa0P4Wql5OY9nUN1APSEudnbWCEeWbx98dQ cX6JY7dBDuUA631yPxhmzO7NX6DGC0hMPXMQqlVV4n1XL1Qrn8SahW+hVglKnL7WzQzT27Dx NzuIzQx05pTuh1C2lsSXH/vY0L3FK+Ak8efvf5YJjMqzkKRmIWmfhaQdWc0CRpZVjKKpBckF xUnpRSbI0b2JEZIKJ+xgvHfA+hDjfkZgpExklhJNzgcm07ySeENjYxMzE1MTc0tTc1MKhM2N TA2AadXAkDrCSuK88pdkAoUE0hNLUrNTUwtSi+KLSnNSiw8xMnFwSjUwyrn1mco0SN2fs+qk zLkpU2sCuGUXvahSnnhv0uropcx7/JizWbK2JK1du3my8NkLUeknJ68zXWGx7uznlw2nDs7M 95q2eXGVmMo2ybkBiUs3LvadOe3h9le2xd/fsjRZ9uWG39L6a3jhQET864cuk3S2ROdqHuT7 1pV31CfwU3HYS6V1j11XP1diKc5INNRiLipOBADkb4By+AMAAA== X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFmpmk+LIzCtJLcpLzFFi42I5/e/2DF3x9XqBBt93WFhc3jWHzYHR4/Mm uQDGqAybjNTElNQihdS85PyUzLx0WyXv4HjneFMzA0NdQ0sLcyWFvMTcVFslF58AXbfMHKCh SgpliTmlQKGAxOJiJX07m6L80pJUhYz84hJbpWgjA2M9I1MTPSNjAz1jy1grQwMDI1OgqoSM jN+7LzMWXHnJWHFuxmGWBsYLjxm7GDk5hASUJCad3Atkc3BICJhI9FypBQlLCIhJXLi3ng2i ZD6jxLWzcSA2i4CqxJ+JO5hAbDYBdYkJv5tZQGxhASuJjuZLrCC2iICaxNcHO4FGcnEwCxxj leh9uYQZYpCsxL3Js8FsXgFBiZMzn7BALFOQ6Fnxiw0iriixdtJPNoi4hMSd+/tZIWxeiRnt T6Hq5SSmfV3DDGFLS5yftYER5ujF3x9Dxfkljt0GOZQDrPfJ/WCYMbs3f4EaLyAx9cxBqFZV ifddvVCtfBJrFr6FWiUocfpaNzNMb8PG3+wgNjPQmVO6H0LZWhJffuxjQ/cWr4CTxJ+//1km MMrNQpKahaR9FpJ2ZDULGFlWMYqmFiQXFCelVxjrFSfmFpfmpesl5+duYgQnqWeLdzD+P299 iFGAg1GJh9fBQS9QiDWxrLgy9xCjBAezkgjvtjqgEG9KYmVValF+fFFpTmrxIcZkYAxOZJYS Tc4HJtC8knhDY2MTMxNTcwMLA0tz0oSVxHlDbNQDhQTSE0tSs1NTC1KLYLYwcXBKNTD6fElg O5MqpGI44Xe3woFWtv0idf6d1z8WTp8aGMa+MEJPUdftr2S3TOnO3UxTP+8W/rNXZW1Wm5sM X+7MzKoVjjYzdtjorlfm/9/TvLNAcUvkuxrbbz5f/pcall3IY6xYnmDMeF1rubPrpJyUzTa/ zjZLTWOWmLcsSis5194qqXx6UiXnDyWW4oxEQy3mouJEAMlJJMqWAwAA DLP-Filter: Pass X-CFilter-Loop: Reflected Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by mail.home.local id r1S1D3te010912 On Wednesday, February 27, 2013 10:13 PM, Ian Lartey wrote: > > The Palmas familly of chips has LED support. This is not always muxed > to output pins so depending on the setting of the mux this driver > will create the appropriate LED class devices. Hi Ian Lartey, I added some minor comments :) Good luck. > > Signed-off-by: Graeme Gregory > Signed-off-by: Ian Lartey > --- > drivers/leds/leds-palmas.c | 574 ++++++++++++++++++++++++++++++++++++++++++++ > include/linux/mfd/palmas.h | 60 +++++ > 2 files changed, 634 insertions(+), 0 deletions(-) > create mode 100644 drivers/leds/leds-palmas.c > > diff --git a/drivers/leds/leds-palmas.c b/drivers/leds/leds-palmas.c > new file mode 100644 > index 0000000..4cb73aa > --- /dev/null > +++ b/drivers/leds/leds-palmas.c > @@ -0,0 +1,574 @@ > +/* > + * Driver for LED part of Palmas PMIC Chips > + * > + * Copyright 2011 Texas Instruments Inc. 2013 ? > + * > + * Author: Graeme Gregory > + * Author: Ian Lartey > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms of the GNU General Public License as published by the > + * Free Software Foundation; either version 2 of the License, or (at your > + * option) any later version. > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include Would you order header files according to alphabetical ordering? It would be better for the readability. > + > +struct palmas_leds_data; > + > +struct palmas_led { > + struct led_classdev cdev; > + struct palmas_leds_data *leds_data; > + int led_no; > + struct work_struct work; > + struct mutex mutex; > + > + spinlock_t value_lock; > + > + int blink; > + int on_time; > + int period; > + enum led_brightness brightness; > +}; > + > +struct palmas_leds_data { > + struct device *dev; > + struct led_classdev cdev; > + struct palmas *palmas; > + > + struct palmas_led *palmas_led; > + int no_leds; > +}; > + > +#define to_palmas_led(led_cdev) \ > + container_of(led_cdev, struct palmas_led, cdev) > + > +#define LED_ON_62_5MS 0x00 > +#define LED_ON_125MS 0x01 > +#define LED_ON_250MS 0x02 > +#define LED_ON_500MS 0x03 > + > +#define LED_PERIOD_OFF 0x00 > +#define LED_PERIOD_125MS 0x01 > +#define LED_PERIOD_250MS 0x02 > +#define LED_PERIOD_500MS 0x03 > +#define LED_PERIOD_1000MS 0x04 > +#define LED_PERIOD_2000MS 0x05 > +#define LED_PERIOD_4000MS 0x06 > +#define LED_PERIOD_8000MS 0x07 > + > + > +static char *palmas_led_names[] = { > + "palmas:led1", > + "palmas:led2", > + "palmas:led3", > + "palmas:led4", > +}; > + > +static int palmas_led_read(struct palmas_leds_data *leds, unsigned int reg, > + unsigned int *dest) > +{ > + unsigned int addr; > + > + addr = PALMAS_BASE_TO_REG(PALMAS_LED_BASE, reg); > + > + return palmas_read(leds->palmas, PALMAS_LED_BASE, addr, dest); > +} > + > +static int palmas_led_write(struct palmas_leds_data *leds, unsigned int reg, > + unsigned int value) > +{ > + unsigned int addr; > + > + addr = PALMAS_BASE_TO_REG(PALMAS_LED_BASE, reg); > + > + return palmas_write(leds->palmas, PALMAS_LED_BASE, addr, value); > +} > + > +static int palmas_led_update_bits(struct palmas_leds_data *leds, > + unsigned int reg, unsigned int mask, unsigned int value) > +{ > + unsigned int addr; > + > + addr = PALMAS_BASE_TO_REG(PALMAS_LED_BASE, reg); > + > + return palmas_update_bits(leds->palmas, PALMAS_LED_BASE, > + addr, mask, value); > +} > + > +static void palmas_leds_work(struct work_struct *work) > +{ > + struct palmas_led *led = container_of(work, struct palmas_led, work); > + unsigned int period, ctrl; > + unsigned long flags; > + > + mutex_lock(&led->mutex); > + > + palmas_led_read(led->leds_data, PALMAS_LED_CTRL, &ctrl); > + palmas_led_read(led->leds_data, PALMAS_LED_PERIOD_CTRL, &period); > + > + spin_lock_irqsave(&led->value_lock, flags); > + > + switch (led->led_no) { > + case 1: > + ctrl &= ~PALMAS_LED_CTRL_LED_1_ON_TIME_MASK; > + period &= ~PALMAS_LED_PERIOD_CTRL_LED_1_PERIOD_MASK; > + > + if (led->blink) { > + ctrl |= led->on_time << > + PALMAS_LED_CTRL_LED_1_ON_TIME_SHIFT; > + period |= led->period << > + PALMAS_LED_PERIOD_CTRL_LED_1_PERIOD_SHIFT; > + } else { > + /* > + * for off value is zero which we already set by > + * masking earlier. > + */ > + if (led->brightness) { > + ctrl |= LED_ON_500MS << > + PALMAS_LED_CTRL_LED_1_ON_TIME_SHIFT; > + period |= LED_PERIOD_500MS << > + PALMAS_LED_PERIOD_CTRL_LED_1_PERIOD_SHIFT; > + } > + } > + case 2: > + ctrl &= ~PALMAS_LED_CTRL_LED_2_ON_TIME_MASK; > + period &= ~PALMAS_LED_PERIOD_CTRL_LED_2_PERIOD_MASK; > + > + if (led->blink) { > + ctrl |= led->on_time << > + PALMAS_LED_CTRL_LED_2_ON_TIME_SHIFT; > + period |= led->period << > + PALMAS_LED_PERIOD_CTRL_LED_2_PERIOD_SHIFT; > + } else { > + /* > + * for off value is zero which we already set by > + * masking earlier. > + */ > + if (led->brightness) { > + ctrl |= LED_ON_500MS << > + PALMAS_LED_CTRL_LED_2_ON_TIME_SHIFT; > + period |= LED_PERIOD_500MS << > + PALMAS_LED_PERIOD_CTRL_LED_2_PERIOD_SHIFT; > + } > + } > + case 3: > + ctrl &= ~PALMAS_LED_CTRL2_LED_3_ON_TIME_MASK; > + period &= ~PALMAS_LED_PERIOD2_CTRL_LED_3_PERIOD_MASK; > + > + if (led->blink) { > + ctrl |= led->on_time << > + PALMAS_LED_CTRL2_LED_3_ON_TIME_SHIFT; > + period |= led->period << > + PALMAS_LED_PERIOD2_CTRL_LED_3_PERIOD_SHIFT; > + } else { > + /* > + * for off value is zero which we already set by > + * masking earlier. > + */ > + if (led->brightness) { > + ctrl |= LED_ON_500MS << > + PALMAS_LED_CTRL2_LED_3_ON_TIME_SHIFT; > + period |= LED_PERIOD_500MS << > + PALMAS_LED_PERIOD2_CTRL_LED_3_PERIOD_SHIFT; > + } > + } > + break; > + case 4: > + ctrl &= ~PALMAS_LED_CTRL2_CHRG_LED_ON_TIME_MASK; > + period &= ~PALMAS_LED_PERIOD2_CTRL_CHRG_LED_PERIOD_MASK; > + > + if (led->blink) { > + ctrl |= led->on_time << > + PALMAS_LED_CTRL2_CHRG_LED_ON_TIME_SHIFT; > + period |= led->period << > + PALMAS_LED_PERIOD2_CTRL_CHRG_LED_PERIOD_SHIFT; > + } else { > + /* > + * for off value is zero which we already set by > + * masking earlier. > + */ > + if (led->brightness) { > + ctrl |= LED_ON_500MS << > + PALMAS_LED_CTRL2_CHRG_LED_ON_TIME_SHIFT; > + period |= LED_PERIOD_500MS << > + PALMAS_LED_PERIOD2_CTRL_CHRG_LED_PERIOD_SHIFT; > + } > + } > + break; > + } > + spin_unlock_irqrestore(&led->value_lock, flags); > + > + if (led->led_no < 3) { > + palmas_led_write(led->leds_data, PALMAS_LED_CTRL, ctrl); > + palmas_led_write(led->leds_data, PALMAS_LED_PERIOD_CTRL, > + period); > + } else { > + palmas_led_write(led->leds_data, PALMAS_LED_CTRL2, ctrl); > + palmas_led_write(led->leds_data, PALMAS_LED_PERIOD2_CTRL, > + period); > + } > + > + if (is_palmas_charger(led->leds_data->palmas->product_id)) { > + if (led->brightness || led->blink) > + palmas_led_update_bits(led->leds_data, PALMAS_LED_EN, > + 1 << (led->led_no - 1), 0xFF); > + else > + palmas_led_update_bits(led->leds_data, PALMAS_LED_EN, > + 1 << (led->led_no - 1), 0x00); > + } > + mutex_unlock(&led->mutex); > +} > + > +static void palmas_leds_set(struct led_classdev *led_cdev, > + enum led_brightness value) > +{ > + struct palmas_led *led = to_palmas_led(led_cdev); > + unsigned long flags; > + > + spin_lock_irqsave(&led->value_lock, flags); > + led->brightness = value; > + led->blink = 0; > + schedule_work(&led->work); > + spin_unlock_irqrestore(&led->value_lock, flags); > +} > + > +static int palmas_leds_blink_set(struct led_classdev *led_cdev, > + unsigned long *delay_on, > + unsigned long *delay_off) > +{ > + struct palmas_led *led = to_palmas_led(led_cdev); > + unsigned long flags; > + int ret = 0; > + int period; > + > + /* Pick some defaults if we've not been given times */ > + if (*delay_on == 0 && *delay_off == 0) { > + *delay_on = 250; > + *delay_off = 250; > + } > + > + spin_lock_irqsave(&led->value_lock, flags); > + > + /* We only have a limited selection of settings, see if we can > + * support the configuration we're being given */ According to the Coding Style, the preferred style for multi-line comments is: + /* + * We only have a limited selection of settings, see if we can + * support the configuration we're being given + */ > + switch (*delay_on) { > + case 500: > + led->on_time = LED_ON_500MS; > + break; > + case 250: > + led->on_time = LED_ON_250MS; > + break; > + case 125: > + led->on_time = LED_ON_125MS; > + break; > + case 62: > + case 63: > + /* Actually 62.5ms */ > + led->on_time = LED_ON_62_5MS; > + break; > + default: > + ret = -EINVAL; > + break; > + } > + > + period = *delay_on + *delay_off; > + > + if (ret == 0) { > + switch (period) { > + case 124: > + case 125: > + case 126: > + /* All possible variations of 62.5 + 62.5 */ > + led->period = LED_PERIOD_125MS; > + break; > + case 250: > + led->period = LED_PERIOD_250MS; > + break; > + case 500: > + led->period = LED_PERIOD_500MS; > + break; > + case 1000: > + led->period = LED_PERIOD_1000MS; > + break; > + case 2000: > + led->period = LED_PERIOD_2000MS; > + break; > + case 4000: > + led->period = LED_PERIOD_4000MS; > + break; > + case 8000: > + led->period = LED_PERIOD_8000MS; > + break; > + default: > + ret = -EINVAL; > + break; > + } > + } > + > + if (ret == 0) > + led->blink = 1; > + else > + led->blink = 0; > + > + /* Always update; if we fail turn off blinking since we expect > + * a software fallback. */ Same as above. > + schedule_work(&led->work); > + > + spin_unlock_irqrestore(&led->value_lock, flags); > + > + return ret; > +} > + > +static void palmas_init_led(struct palmas_leds_data *leds_data, int offset, > + int led_no) > +{ > + mutex_init(&leds_data->palmas_led[offset].mutex); > + INIT_WORK(&leds_data->palmas_led[offset].work, palmas_leds_work); > + spin_lock_init(&leds_data->palmas_led[offset].value_lock); > + > + leds_data->palmas_led[offset].leds_data = leds_data; > + leds_data->palmas_led[offset].led_no = led_no; > + leds_data->palmas_led[offset].cdev.name = palmas_led_names[led_no - 1]; > + leds_data->palmas_led[offset].cdev.default_trigger = NULL; > + leds_data->palmas_led[offset].cdev.brightness_set = palmas_leds_set; > + leds_data->palmas_led[offset].cdev.blink_set = palmas_leds_blink_set; > +} > + > +static int palmas_dt_to_pdata(struct device *dev, > + struct device_node *node, > + struct palmas_leds_platform_data *pdata) > +{ > + struct device_node *child_node; > + int ret; > + u32 prop; > + > + child_node = of_get_child_by_name(node, "palmas_leds"); > + if (!child_node) { > + dev_err(dev, "child node 'palmas_leds' not found\n"); > + return -EINVAL; > + } > + > + ret = of_property_read_u32(child_node, "ti,led1_current", &prop); > + if (!ret) > + pdata->led1_current = prop; > + > + ret = of_property_read_u32(child_node, "ti,led2_current", &prop); > + if (!ret) > + pdata->led2_current = prop; > + > + ret = of_property_read_u32(child_node, "ti,led3_current", &prop); > + if (!ret) > + pdata->led3_current = prop; > + > + ret = of_property_read_u32(child_node, "ti,led4_current", &prop); > + if (!ret) > + pdata->led4_current = prop; > + > + ret = of_property_read_u32(child_node, "ti,chrg_led_mode", &prop); > + if (!ret) > + pdata->chrg_led_mode = prop; > + > + ret = of_property_read_u32(child_node, "ti,chrg_led_vbat_low", &prop); > + if (!ret) > + pdata->chrg_led_vbat_low = prop; > + > + return 0; > +} > + > +static int palmas_leds_probe(struct platform_device *pdev) > +{ > + struct palmas *palmas = dev_get_drvdata(pdev->dev.parent); > + struct palmas_leds_platform_data *pdata = pdev->dev.platform_data; > + struct palmas_leds_data *leds_data; > + struct device_node *node = pdev->dev.of_node; > + int ret, i; > + int offset = 0; > + > + if (!palmas->led_muxed && !is_palmas_charger(palmas->product_id)) { > + dev_err(&pdev->dev, "there are no LEDs muxed\n"); > + return -EINVAL; > + } > + > + /* Palmas charger requires platform data */ > + if (is_palmas_charger(palmas->product_id) && node && !pdata) { > + pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); > + > + if (!pdata) > + return -ENOMEM; > + > + ret = palmas_dt_to_pdata(&pdev->dev, node, pdata); > + if (ret) > + return ret; > + } > + > + if (is_palmas_charger(palmas->product_id) && !pdata) > + return -EINVAL; > + > + leds_data = kzalloc(sizeof(*leds_data), GFP_KERNEL); How about using devm_kzalloc()? Memory allocated with this function is automatically freed on driver detach. So it makes error path more simple. > + if (!leds_data) > + return -ENOMEM; > + platform_set_drvdata(pdev, leds_data); > + > + leds_data->palmas = palmas; > + > + switch (palmas->led_muxed) { > + case PALMAS_LED1_MUXED | PALMAS_LED2_MUXED: > + leds_data->no_leds = 2; > + break; > + case PALMAS_LED1_MUXED: > + case PALMAS_LED2_MUXED: > + leds_data->no_leds = 1; > + break; > + default: > + leds_data->no_leds = 0; > + break; > + } > + > + if (is_palmas_charger(palmas->product_id)) { > + if (pdata->chrg_led_mode) > + leds_data->no_leds += 2; > + else > + leds_data->no_leds++; > + } > + > + leds_data->palmas_led = kcalloc(leds_data->no_leds, > + sizeof(struct palmas_led), GFP_KERNEL); How about using devm_kzalloc()? > + > + /* Initialise LED1 */ > + if (palmas->led_muxed & PALMAS_LED1_MUXED) { > + palmas_init_led(leds_data, offset, 1); > + offset++; > + } > + > + /* Initialise LED2 */ > + if (palmas->led_muxed & PALMAS_LED2_MUXED) { > + palmas_init_led(leds_data, offset, 2); > + offset++; > + } > + > + if (is_palmas_charger(palmas->product_id)) { > + palmas_init_led(leds_data, offset, 3); > + offset++; > + > + if (pdata->chrg_led_mode) { > + palmas_led_update_bits(leds_data, PALMAS_CHRG_LED_CTRL, > + PALMAS_CHRG_LED_CTRL_CHRG_LED_MODE, > + PALMAS_CHRG_LED_CTRL_CHRG_LED_MODE); > + > + palmas_init_led(leds_data, offset, 4); > + } > + } > + > + for (i = 0; i < leds_data->no_leds; i++) { > + ret = led_classdev_register(leds_data->dev, > + &leds_data->palmas_led[i].cdev); > + if (ret < 0) { > + dev_err(&pdev->dev, > + "Failed to register LED no: %d err: %d\n", > + i, ret); > + goto err_led; > + } > + } > + > + if (!is_palmas_charger(palmas->product_id)) > + return 0; > + > + /* Set the LED current registers if set in platform data */ > + if (pdata->led1_current) > + palmas_led_update_bits(leds_data, PALMAS_LED_CURRENT_CTRL1, > + PALMAS_LED_CURRENT_CTRL1_LED_1_CURRENT_MASK, > + pdata->led1_current); > + > + if (pdata->led2_current) > + palmas_led_update_bits(leds_data, PALMAS_LED_CURRENT_CTRL1, > + PALMAS_LED_CURRENT_CTRL1_LED_2_CURRENT_MASK, > + pdata->led2_current << > + PALMAS_LED_CURRENT_CTRL1_LED_2_CURRENT_SHIFT); > + > + if (pdata->led3_current) > + palmas_led_update_bits(leds_data, PALMAS_LED_CURRENT_CTRL2, > + PALMAS_LED_CURRENT_CTRL2_LED_3_CURRENT_MASK, > + pdata->led3_current); > + > + if (pdata->led3_current) > + palmas_led_update_bits(leds_data, PALMAS_LED_CURRENT_CTRL2, > + PALMAS_LED_CURRENT_CTRL2_LED_3_CURRENT_MASK, > + pdata->led3_current); > + > + if (pdata->led4_current) > + palmas_led_update_bits(leds_data, PALMAS_CHRG_LED_CTRL, > + PALMAS_CHRG_LED_CTRL_CHRG_LED_CURRENT_MASK, > + pdata->led4_current << > + PALMAS_CHRG_LED_CTRL_CHRG_LED_CURRENT_SHIFT); > + > + if (pdata->chrg_led_vbat_low) > + palmas_led_update_bits(leds_data, PALMAS_CHRG_LED_CTRL, > + PALMAS_CHRG_LED_CTRL_CHRG_LOWBAT_BLK_DIS, > + PALMAS_CHRG_LED_CTRL_CHRG_LOWBAT_BLK_DIS); > + > + return 0; > + > +err_led: > + for (i = 0; i < leds_data->no_leds; i++) > + led_classdev_unregister(&leds_data->palmas_led[i].cdev); > + kfree(leds_data->palmas_led); > + kfree(leds_data); If you use devm_kzalloc() above, you don't need to use kfree(). > + return ret; > +} > + > +static int palmas_leds_remove(struct platform_device *pdev) > +{ > + struct palmas_leds_data *leds_data = platform_get_drvdata(pdev); > + int i; > + > + for (i = 0; i < leds_data->no_leds; i++) > + led_classdev_unregister(&leds_data->palmas_led[i].cdev); > + if (i) > + kfree(leds_data->palmas_led); > + kfree(leds_data); If you use devm_kzalloc() above, you don't need to use kfree(). > + > + return 0; > +} > + > +static struct of_device_id of_palmas_match_tbl[] = { > + { .compatible = "ti,palmas-leds", }, > + { /* end */ } > +}; > + > +static struct platform_driver palmas_leds_driver = { > + .driver = { > + .name = "palmas-leds", > + .of_match_table = of_palmas_match_tbl, > + .owner = THIS_MODULE, > + }, > + .probe = palmas_leds_probe, > + .remove = palmas_leds_remove, > +}; > + > +static int palmas_leds_init(void) > +{ > + return platform_driver_register(&palmas_leds_driver); > +} > +module_init(palmas_leds_init); > + > +static void palmas_leds_exit(void) > +{ > + platform_driver_unregister(&palmas_leds_driver); > +} > +module_exit(palmas_leds_exit); Please use module_platform_driver() macro which makes the code smaller and simpler. +module_platform_driver(palmas_leds_driver); > + > +MODULE_AUTHOR("Graeme Gregory "); > +MODULE_DESCRIPTION("Palmas LED driver"); > +MODULE_LICENSE("GPL"); > +MODULE_ALIAS("platform:palmas-leds"); > +MODULE_DEVICE_TABLE(of, of_palmas_match_tbl); > diff --git a/include/linux/mfd/palmas.h b/include/linux/mfd/palmas.h > index 0b86845..856f54e 100644 > --- a/include/linux/mfd/palmas.h > +++ b/include/linux/mfd/palmas.h > @@ -232,6 +232,16 @@ struct palmas_clk_platform_data { > int clk32kgaudio_mode_sleep; > }; > > +struct palmas_leds_platform_data { > + int led1_current; > + int led2_current; > + int led3_current; > + int led4_current; > + > + int chrg_led_mode; > + int chrg_led_vbat_low; > +}; > + > struct palmas_platform_data { > int gpio_base; > > @@ -1855,6 +1865,12 @@ enum usb_irq_events { > #define PALMAS_LED_CTRL 0x1 > #define PALMAS_PWM_CTRL1 0x2 > #define PALMAS_PWM_CTRL2 0x3 > +#define PALMAS_LED_PERIOD2_CTRL 0x4 > +#define PALMAS_LED_CTRL2 0x5 > +#define PALMAS_LED_CURRENT_CTRL1 0x6 > +#define PALMAS_LED_CURRENT_CTRL2 0x7 > +#define PALMAS_CHRG_LED_CTRL 0x8 > +#define PALMAS_LED_EN 0x9 > > /* Bit definitions for LED_PERIOD_CTRL */ > #define PALMAS_LED_PERIOD_CTRL_LED_2_PERIOD_MASK 0x38 > @@ -1882,6 +1898,50 @@ enum usb_irq_events { > #define PALMAS_PWM_CTRL2_PWM_DUTY_SEL_MASK 0xff > #define PALMAS_PWM_CTRL2_PWM_DUTY_SEL_SHIFT 0 > > +/* Bit definitions for LED_PERIOD2_CTRL */ > +#define PALMAS_LED_PERIOD2_CTRL_CHRG_LED_PERIOD_MASK 0x38 > +#define PALMAS_LED_PERIOD2_CTRL_CHRG_LED_PERIOD_SHIFT 3 > +#define PALMAS_LED_PERIOD2_CTRL_LED_3_PERIOD_MASK 0x07 > +#define PALMAS_LED_PERIOD2_CTRL_LED_3_PERIOD_SHIFT 0 > + > +/* Bit definitions for LED_CTRL2 */ > +#define PALMAS_LED_CTRL2_CHRG_LED_SEQ 0x20 > +#define PALMAS_LED_CTRL2_CHRG_LED_SEQ_SHIFT 5 > +#define PALMAS_LED_CTRL2_LED_3_SEQ 0x10 > +#define PALMAS_LED_CTRL2_LED_3_SEQ_SHIFT 4 > +#define PALMAS_LED_CTRL2_CHRG_LED_ON_TIME_MASK 0x0c > +#define PALMAS_LED_CTRL2_CHRG_LED_ON_TIME_SHIFT 2 > +#define PALMAS_LED_CTRL2_LED_3_ON_TIME_MASK 0x03 > +#define PALMAS_LED_CTRL2_LED_3_ON_TIME_SHIFT 0 > + > +/* Bit definitions for LED_CURRENT_CTRL1 */ > +#define PALMAS_LED_CURRENT_CTRL1_LED_2_CURRENT_MASK 0x38 > +#define PALMAS_LED_CURRENT_CTRL1_LED_2_CURRENT_SHIFT 3 > +#define PALMAS_LED_CURRENT_CTRL1_LED_1_CURRENT_MASK 0x07 > +#define PALMAS_LED_CURRENT_CTRL1_LED_1_CURRENT_SHIFT 0 > + > +/* Bit definitions for LED_CURRENT_CTRL2 */ > +#define PALMAS_LED_CURRENT_CTRL2_LED_3_CURRENT_MASK 0x07 > +#define PALMAS_LED_CURRENT_CTRL2_LED_3_CURRENT_SHIFT 0 > + > +/* Bit definitions for CHRG_LED_CTRL */ > +#define PALMAS_CHRG_LED_CTRL_CHRG_LED_CURRENT_MASK 0x38 > +#define PALMAS_CHRG_LED_CTRL_CHRG_LED_CURRENT_SHIFT 3 > +#define PALMAS_CHRG_LED_CTRL_CHRG_LOWBAT_BLK_DIS 0x02 > +#define PALMAS_CHRG_LED_CTRL_CHRG_LOWBAT_BLK_DIS_SHIFT 1 > +#define PALMAS_CHRG_LED_CTRL_CHRG_LED_MODE 0x01 > +#define PALMAS_CHRG_LED_CTRL_CHRG_LED_MODE_SHIFT 0 > + > +/* Bit definitions for LED_EN */ > +#define PALMAS_LED_EN_CHRG_LED_EN 0x08 > +#define PALMAS_LED_EN_CHRG_LED_EN_SHIFT 3 > +#define PALMAS_LED_EN_LED_3_EN 0x04 > +#define PALMAS_LED_EN_LED_3_EN_SHIFT 2 > +#define PALMAS_LED_EN_LED_2_EN 0x02 > +#define PALMAS_LED_EN_LED_2_EN_SHIFT 1 > +#define PALMAS_LED_EN_LED_1_EN 0x01 > +#define PALMAS_LED_EN_LED_1_EN_SHIFT 0 > + > /* Registers for function INTERRUPT */ > #define PALMAS_INT1_STATUS 0x0 > #define PALMAS_INT1_MASK 0x1 > -- > 1.7.0.4 > > -- > To unsubscribe from this list: send the line "unsubscribe linux-leds" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jingoo Han Subject: Re: [PATCH 1/2] leds: Add support for Palmas LEDs Date: Thu, 28 Feb 2013 01:12:55 +0000 (GMT) Message-ID: <24550733.220381362013975218.JavaMail.weblogic@epml02> Reply-To: jg1.han@samsung.com Mime-Version: 1.0 Content-Type: text/plain; charset=euc-kr Content-Transfer-Encoding: base64 Return-path: MIME-version: 1.0 Sender: linux-kernel-owner@vger.kernel.org To: Ian Lartey Cc: "linux-kernel@vger.kernel.org" , "linux-leds@vger.kernel.org" , "devicetree-discuss@lists.ozlabs.org" , "ldewangan@nvidia.com" , "j-keerthy@ti.com" , "gg@slimlogic.co.uk" , "cooloney@gmail.com" , "rpurdie@rpsys.net" , "grant.likely@secretlab.ca" , "rob.herring@calxeda.com" , "sameo@linux.intel.com" , "broonie@opensource.wolfsonmicro.com" , Jingoo Han List-Id: devicetree@vger.kernel.org T24gV2VkbmVzZGF5LCBGZWJydWFyeSAyNywgMjAxMyAxMDoxMyBQTSwgSWFuIExhcnRleSB3cm90 ZToNCj4gDQo+IFRoZSBQYWxtYXMgZmFtaWxseSBvZiBjaGlwcyBoYXMgTEVEIHN1cHBvcnQuIFRo aXMgaXMgbm90IGFsd2F5cyBtdXhlZA0KPiB0byBvdXRwdXQgcGlucyBzbyBkZXBlbmRpbmcgb24g dGhlIHNldHRpbmcgb2YgdGhlIG11eCB0aGlzIGRyaXZlcg0KPiB3aWxsIGNyZWF0ZSB0aGUgYXBw cm9wcmlhdGUgTEVEIGNsYXNzIGRldmljZXMuDQoNCkhpIElhbiBMYXJ0ZXksDQoNCkkgYWRkZWQg c29tZSBtaW5vciBjb21tZW50cyA6KQ0KR29vZCBsdWNrLg0KDQo+IA0KPiBTaWduZWQtb2ZmLWJ5 OiBHcmFlbWUgR3JlZ29yeSA8Z2dAc2xpbWxvZ2ljLmNvLnVrPg0KPiBTaWduZWQtb2ZmLWJ5OiBJ YW4gTGFydGV5IDxpYW5Ac2xpbWxvZ2ljLmNvLnVrPg0KPiAtLS0NCj4gIGRyaXZlcnMvbGVkcy9s ZWRzLXBhbG1hcy5jIHwgIDU3NCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKw0KPiAgaW5jbHVkZS9saW51eC9tZmQvcGFsbWFzLmggfCAgIDYwICsrKysrDQo+ICAy IGZpbGVzIGNoYW5nZWQsIDYzNCBpbnNlcnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQ0KPiAgY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbGVkcy9sZWRzLXBhbG1hcy5jDQo+IA0KPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9sZWRzL2xlZHMtcGFsbWFzLmMgYi9kcml2ZXJzL2xlZHMvbGVkcy1wYWxt YXMuYw0KPiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiBpbmRleCAwMDAwMDAwLi40Y2I3M2FhDQo+ IC0tLSAvZGV2L251bGwNCj4gKysrIGIvZHJpdmVycy9sZWRzL2xlZHMtcGFsbWFzLmMNCj4gQEAg LTAsMCArMSw1NzQgQEANCj4gKy8qDQo+ICsgKiBEcml2ZXIgZm9yIExFRCBwYXJ0IG9mIFBhbG1h cyBQTUlDIENoaXBzDQo+ICsgKg0KPiArICogQ29weXJpZ2h0IDIwMTEgVGV4YXMgSW5zdHJ1bWVu dHMgSW5jLg0KDQoyMDEzID8NCg0KPiArICoNCj4gKyAqIEF1dGhvcjogR3JhZW1lIEdyZWdvcnkg PGdnQHNsaW1sb2dpYy5jby51az4NCj4gKyAqIEF1dGhvcjogSWFuIExhcnRleSA8aWFuQHNsaW1s b2dpYy5jby51az4NCj4gKyAqDQo+ICsgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7 IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQNCj4gKyAqICB1bmRlciAg dGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCAgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVk IGJ5IHRoZQ0KPiArICogIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgIGVpdGhlciB2ZXJzaW9u IDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyDQo+ICsgKiAgb3B0aW9uKSBhbnkgbGF0ZXIg dmVyc2lvbi4NCj4gKyAqDQo+ICsgKi8NCj4gKw0KPiArI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5o Pg0KPiArI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9y bV9kZXZpY2UuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+DQo+ICsjaW5jbHVkZSA8bGlu dXgvbGVkcy5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L2Vyci5oPg0KPiArI2luY2x1ZGUgPGxpbnV4 L21mZC9wYWxtYXMuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4NCj4gKyNpbmNsdWRl IDxsaW51eC9vZl9wbGF0Zm9ybS5oPg0KDQpXb3VsZCB5b3Ugb3JkZXIgaGVhZGVyIGZpbGVzIGFj Y29yZGluZyB0byBhbHBoYWJldGljYWwgb3JkZXJpbmc/DQpJdCB3b3VsZCBiZSBiZXR0ZXIgZm9y IHRoZSByZWFkYWJpbGl0eS4NCg0KPiArDQo+ICtzdHJ1Y3QgcGFsbWFzX2xlZHNfZGF0YTsNCj4g Kw0KPiArc3RydWN0IHBhbG1hc19sZWQgew0KPiArCXN0cnVjdCBsZWRfY2xhc3NkZXYgY2RldjsN Cj4gKwlzdHJ1Y3QgcGFsbWFzX2xlZHNfZGF0YSAqbGVkc19kYXRhOw0KPiArCWludCBsZWRfbm87 DQo+ICsJc3RydWN0IHdvcmtfc3RydWN0IHdvcms7DQo+ICsJc3RydWN0IG11dGV4IG11dGV4Ow0K PiArDQo+ICsJc3BpbmxvY2tfdCB2YWx1ZV9sb2NrOw0KPiArDQo+ICsJaW50IGJsaW5rOw0KPiAr CWludCBvbl90aW1lOw0KPiArCWludCBwZXJpb2Q7DQo+ICsJZW51bSBsZWRfYnJpZ2h0bmVzcyBi cmlnaHRuZXNzOw0KPiArfTsNCj4gKw0KPiArc3RydWN0IHBhbG1hc19sZWRzX2RhdGEgew0KPiAr CXN0cnVjdCBkZXZpY2UgKmRldjsNCj4gKwlzdHJ1Y3QgbGVkX2NsYXNzZGV2IGNkZXY7DQo+ICsJ c3RydWN0IHBhbG1hcyAqcGFsbWFzOw0KPiArDQo+ICsJc3RydWN0IHBhbG1hc19sZWQgKnBhbG1h c19sZWQ7DQo+ICsJaW50IG5vX2xlZHM7DQo+ICt9Ow0KPiArDQo+ICsjZGVmaW5lIHRvX3BhbG1h c19sZWQobGVkX2NkZXYpIFwNCj4gKwljb250YWluZXJfb2YobGVkX2NkZXYsIHN0cnVjdCBwYWxt YXNfbGVkLCBjZGV2KQ0KPiArDQo+ICsjZGVmaW5lIExFRF9PTl82Ml81TVMJCTB4MDANCj4gKyNk ZWZpbmUgTEVEX09OXzEyNU1TCQkweDAxDQo+ICsjZGVmaW5lIExFRF9PTl8yNTBNUwkJMHgwMg0K PiArI2RlZmluZSBMRURfT05fNTAwTVMJCTB4MDMNCj4gKw0KPiArI2RlZmluZSBMRURfUEVSSU9E X09GRgkJMHgwMA0KPiArI2RlZmluZSBMRURfUEVSSU9EXzEyNU1TCTB4MDENCj4gKyNkZWZpbmUg TEVEX1BFUklPRF8yNTBNUwkweDAyDQo+ICsjZGVmaW5lIExFRF9QRVJJT0RfNTAwTVMJMHgwMw0K PiArI2RlZmluZSBMRURfUEVSSU9EXzEwMDBNUwkweDA0DQo+ICsjZGVmaW5lIExFRF9QRVJJT0Rf MjAwME1TCTB4MDUNCj4gKyNkZWZpbmUgTEVEX1BFUklPRF80MDAwTVMJMHgwNg0KPiArI2RlZmlu ZSBMRURfUEVSSU9EXzgwMDBNUwkweDA3DQo+ICsNCj4gKw0KPiArc3RhdGljIGNoYXIgKnBhbG1h c19sZWRfbmFtZXNbXSA9IHsNCj4gKwkicGFsbWFzOmxlZDEiLA0KPiArCSJwYWxtYXM6bGVkMiIs DQo+ICsJInBhbG1hczpsZWQzIiwNCj4gKwkicGFsbWFzOmxlZDQiLA0KPiArfTsNCj4gKw0KPiAr c3RhdGljIGludCBwYWxtYXNfbGVkX3JlYWQoc3RydWN0IHBhbG1hc19sZWRzX2RhdGEgKmxlZHMs IHVuc2lnbmVkIGludCByZWcsDQo+ICsJCXVuc2lnbmVkIGludCAqZGVzdCkNCj4gK3sNCj4gKwl1 bnNpZ25lZCBpbnQgYWRkcjsNCj4gKw0KPiArCWFkZHIgPSBQQUxNQVNfQkFTRV9UT19SRUcoUEFM TUFTX0xFRF9CQVNFLCByZWcpOw0KPiArDQo+ICsJcmV0dXJuIHBhbG1hc19yZWFkKGxlZHMtPnBh bG1hcywgUEFMTUFTX0xFRF9CQVNFLCBhZGRyLCBkZXN0KTsNCj4gK30NCj4gKw0KPiArc3RhdGlj IGludCBwYWxtYXNfbGVkX3dyaXRlKHN0cnVjdCBwYWxtYXNfbGVkc19kYXRhICpsZWRzLCB1bnNp Z25lZCBpbnQgcmVnLA0KPiArCQl1bnNpZ25lZCBpbnQgdmFsdWUpDQo+ICt7DQo+ICsJdW5zaWdu ZWQgaW50IGFkZHI7DQo+ICsNCj4gKwlhZGRyID0gUEFMTUFTX0JBU0VfVE9fUkVHKFBBTE1BU19M RURfQkFTRSwgcmVnKTsNCj4gKw0KPiArCXJldHVybiBwYWxtYXNfd3JpdGUobGVkcy0+cGFsbWFz LCBQQUxNQVNfTEVEX0JBU0UsIGFkZHIsIHZhbHVlKTsNCj4gK30NCj4gKw0KPiArc3RhdGljIGlu dCBwYWxtYXNfbGVkX3VwZGF0ZV9iaXRzKHN0cnVjdCBwYWxtYXNfbGVkc19kYXRhICpsZWRzLA0K PiArCQl1bnNpZ25lZCBpbnQgcmVnLCB1bnNpZ25lZCBpbnQgbWFzaywgdW5zaWduZWQgaW50IHZh bHVlKQ0KPiArew0KPiArCXVuc2lnbmVkIGludCBhZGRyOw0KPiArDQo+ICsJYWRkciA9IFBBTE1B U19CQVNFX1RPX1JFRyhQQUxNQVNfTEVEX0JBU0UsIHJlZyk7DQo+ICsNCj4gKwlyZXR1cm4gcGFs bWFzX3VwZGF0ZV9iaXRzKGxlZHMtPnBhbG1hcywgUEFMTUFTX0xFRF9CQVNFLA0KPiArCQkJYWRk ciwgbWFzaywgdmFsdWUpOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgdm9pZCBwYWxtYXNfbGVkc193 b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykNCj4gK3sNCj4gKwlzdHJ1Y3QgcGFsbWFzX2xl ZCAqbGVkID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBwYWxtYXNfbGVkLCB3b3JrKTsNCj4g Kwl1bnNpZ25lZCBpbnQgcGVyaW9kLCBjdHJsOw0KPiArCXVuc2lnbmVkIGxvbmcgZmxhZ3M7DQo+ ICsNCj4gKwltdXRleF9sb2NrKCZsZWQtPm11dGV4KTsNCj4gKw0KPiArCXBhbG1hc19sZWRfcmVh ZChsZWQtPmxlZHNfZGF0YSwgUEFMTUFTX0xFRF9DVFJMLCAmY3RybCk7DQo+ICsJcGFsbWFzX2xl ZF9yZWFkKGxlZC0+bGVkc19kYXRhLCBQQUxNQVNfTEVEX1BFUklPRF9DVFJMLCAmcGVyaW9kKTsN Cj4gKw0KPiArCXNwaW5fbG9ja19pcnFzYXZlKCZsZWQtPnZhbHVlX2xvY2ssIGZsYWdzKTsNCj4g Kw0KPiArCXN3aXRjaCAobGVkLT5sZWRfbm8pIHsNCj4gKwljYXNlIDE6DQo+ICsJCWN0cmwgJj0g flBBTE1BU19MRURfQ1RSTF9MRURfMV9PTl9USU1FX01BU0s7DQo+ICsJCXBlcmlvZCAmPSB+UEFM TUFTX0xFRF9QRVJJT0RfQ1RSTF9MRURfMV9QRVJJT0RfTUFTSzsNCj4gKw0KPiArCQlpZiAobGVk LT5ibGluaykgew0KPiArCQkJY3RybCB8PSBsZWQtPm9uX3RpbWUgPDwNCj4gKwkJCQlQQUxNQVNf TEVEX0NUUkxfTEVEXzFfT05fVElNRV9TSElGVDsNCj4gKwkJCXBlcmlvZCB8PSBsZWQtPnBlcmlv ZCA8PA0KPiArCQkJCVBBTE1BU19MRURfUEVSSU9EX0NUUkxfTEVEXzFfUEVSSU9EX1NISUZUOw0K PiArCQl9IGVsc2Ugew0KPiArCQkJLyoNCj4gKwkJCSAqIGZvciBvZmYgdmFsdWUgaXMgemVybyB3 aGljaCB3ZSBhbHJlYWR5IHNldCBieQ0KPiArCQkJICogbWFza2luZyBlYXJsaWVyLg0KPiArCQkJ ICovDQo+ICsJCQlpZiAobGVkLT5icmlnaHRuZXNzKSB7DQo+ICsJCQkJY3RybCB8PSBMRURfT05f NTAwTVMgPDwNCj4gKwkJCQkJUEFMTUFTX0xFRF9DVFJMX0xFRF8xX09OX1RJTUVfU0hJRlQ7DQo+ ICsJCQkJcGVyaW9kIHw9IExFRF9QRVJJT0RfNTAwTVMgPDwNCj4gKwkJCQlQQUxNQVNfTEVEX1BF UklPRF9DVFJMX0xFRF8xX1BFUklPRF9TSElGVDsNCj4gKwkJCX0NCj4gKwkJfQ0KPiArCWNhc2Ug MjoNCj4gKwkJY3RybCAmPSB+UEFMTUFTX0xFRF9DVFJMX0xFRF8yX09OX1RJTUVfTUFTSzsNCj4g KwkJcGVyaW9kICY9IH5QQUxNQVNfTEVEX1BFUklPRF9DVFJMX0xFRF8yX1BFUklPRF9NQVNLOw0K PiArDQo+ICsJCWlmIChsZWQtPmJsaW5rKSB7DQo+ICsJCQljdHJsIHw9IGxlZC0+b25fdGltZSA8 PA0KPiArCQkJCVBBTE1BU19MRURfQ1RSTF9MRURfMl9PTl9USU1FX1NISUZUOw0KPiArCQkJcGVy aW9kIHw9IGxlZC0+cGVyaW9kIDw8DQo+ICsJCQkJUEFMTUFTX0xFRF9QRVJJT0RfQ1RSTF9MRURf Ml9QRVJJT0RfU0hJRlQ7DQo+ICsJCX0gZWxzZSB7DQo+ICsJCQkvKg0KPiArCQkJICogZm9yIG9m ZiB2YWx1ZSBpcyB6ZXJvIHdoaWNoIHdlIGFscmVhZHkgc2V0IGJ5DQo+ICsJCQkgKiBtYXNraW5n IGVhcmxpZXIuDQo+ICsJCQkgKi8NCj4gKwkJCWlmIChsZWQtPmJyaWdodG5lc3MpIHsNCj4gKwkJ CQljdHJsIHw9IExFRF9PTl81MDBNUyA8PA0KPiArCQkJCQlQQUxNQVNfTEVEX0NUUkxfTEVEXzJf T05fVElNRV9TSElGVDsNCj4gKwkJCQlwZXJpb2QgfD0gTEVEX1BFUklPRF81MDBNUyA8PA0KPiAr CQkJCVBBTE1BU19MRURfUEVSSU9EX0NUUkxfTEVEXzJfUEVSSU9EX1NISUZUOw0KPiArCQkJfQ0K PiArCQl9DQo+ICsJY2FzZSAzOg0KPiArCQljdHJsICY9IH5QQUxNQVNfTEVEX0NUUkwyX0xFRF8z X09OX1RJTUVfTUFTSzsNCj4gKwkJcGVyaW9kICY9IH5QQUxNQVNfTEVEX1BFUklPRDJfQ1RSTF9M RURfM19QRVJJT0RfTUFTSzsNCj4gKw0KPiArCQlpZiAobGVkLT5ibGluaykgew0KPiArCQkJY3Ry bCB8PSBsZWQtPm9uX3RpbWUgPDwNCj4gKwkJCQlQQUxNQVNfTEVEX0NUUkwyX0xFRF8zX09OX1RJ TUVfU0hJRlQ7DQo+ICsJCQlwZXJpb2QgfD0gbGVkLT5wZXJpb2QgPDwNCj4gKwkJCQlQQUxNQVNf TEVEX1BFUklPRDJfQ1RSTF9MRURfM19QRVJJT0RfU0hJRlQ7DQo+ICsJCX0gZWxzZSB7DQo+ICsJ CQkvKg0KPiArCQkJICogZm9yIG9mZiB2YWx1ZSBpcyB6ZXJvIHdoaWNoIHdlIGFscmVhZHkgc2V0 IGJ5DQo+ICsJCQkgKiBtYXNraW5nIGVhcmxpZXIuDQo+ICsJCQkgKi8NCj4gKwkJCWlmIChsZWQt PmJyaWdodG5lc3MpIHsNCj4gKwkJCQljdHJsIHw9IExFRF9PTl81MDBNUyA8PA0KPiArCQkJCQlQ QUxNQVNfTEVEX0NUUkwyX0xFRF8zX09OX1RJTUVfU0hJRlQ7DQo+ICsJCQkJcGVyaW9kIHw9IExF RF9QRVJJT0RfNTAwTVMgPDwNCj4gKwkJCQlQQUxNQVNfTEVEX1BFUklPRDJfQ1RSTF9MRURfM19Q RVJJT0RfU0hJRlQ7DQo+ICsJCQl9DQo+ICsJCX0NCj4gKwkJYnJlYWs7DQo+ICsJY2FzZSA0Og0K PiArCQljdHJsICY9IH5QQUxNQVNfTEVEX0NUUkwyX0NIUkdfTEVEX09OX1RJTUVfTUFTSzsNCj4g KwkJcGVyaW9kICY9IH5QQUxNQVNfTEVEX1BFUklPRDJfQ1RSTF9DSFJHX0xFRF9QRVJJT0RfTUFT SzsNCj4gKw0KPiArCQlpZiAobGVkLT5ibGluaykgew0KPiArCQkJY3RybCB8PSBsZWQtPm9uX3Rp bWUgPDwNCj4gKwkJCQlQQUxNQVNfTEVEX0NUUkwyX0NIUkdfTEVEX09OX1RJTUVfU0hJRlQ7DQo+ ICsJCQlwZXJpb2QgfD0gbGVkLT5wZXJpb2QgPDwNCj4gKwkJCQlQQUxNQVNfTEVEX1BFUklPRDJf Q1RSTF9DSFJHX0xFRF9QRVJJT0RfU0hJRlQ7DQo+ICsJCX0gZWxzZSB7DQo+ICsJCQkvKg0KPiAr CQkJICogZm9yIG9mZiB2YWx1ZSBpcyB6ZXJvIHdoaWNoIHdlIGFscmVhZHkgc2V0IGJ5DQo+ICsJ CQkgKiBtYXNraW5nIGVhcmxpZXIuDQo+ICsJCQkgKi8NCj4gKwkJCWlmIChsZWQtPmJyaWdodG5l c3MpIHsNCj4gKwkJCQljdHJsIHw9IExFRF9PTl81MDBNUyA8PA0KPiArCQkJCQlQQUxNQVNfTEVE X0NUUkwyX0NIUkdfTEVEX09OX1RJTUVfU0hJRlQ7DQo+ICsJCQkJcGVyaW9kIHw9IExFRF9QRVJJ T0RfNTAwTVMgPDwNCj4gKwkJCQlQQUxNQVNfTEVEX1BFUklPRDJfQ1RSTF9DSFJHX0xFRF9QRVJJ T0RfU0hJRlQ7DQo+ICsJCQl9DQo+ICsJCX0NCj4gKwkJYnJlYWs7DQo+ICsJfQ0KPiArCXNwaW5f dW5sb2NrX2lycXJlc3RvcmUoJmxlZC0+dmFsdWVfbG9jaywgZmxhZ3MpOw0KPiArDQo+ICsJaWYg KGxlZC0+bGVkX25vIDwgMykgew0KPiArCQlwYWxtYXNfbGVkX3dyaXRlKGxlZC0+bGVkc19kYXRh LCBQQUxNQVNfTEVEX0NUUkwsIGN0cmwpOw0KPiArCQlwYWxtYXNfbGVkX3dyaXRlKGxlZC0+bGVk c19kYXRhLCBQQUxNQVNfTEVEX1BFUklPRF9DVFJMLA0KPiArCQkJCXBlcmlvZCk7DQo+ICsJfSBl bHNlIHsNCj4gKwkJcGFsbWFzX2xlZF93cml0ZShsZWQtPmxlZHNfZGF0YSwgUEFMTUFTX0xFRF9D VFJMMiwgY3RybCk7DQo+ICsJCXBhbG1hc19sZWRfd3JpdGUobGVkLT5sZWRzX2RhdGEsIFBBTE1B U19MRURfUEVSSU9EMl9DVFJMLA0KPiArCQkJCXBlcmlvZCk7DQo+ICsJfQ0KPiArDQo+ICsJaWYg KGlzX3BhbG1hc19jaGFyZ2VyKGxlZC0+bGVkc19kYXRhLT5wYWxtYXMtPnByb2R1Y3RfaWQpKSB7 DQo+ICsJCWlmIChsZWQtPmJyaWdodG5lc3MgfHwgbGVkLT5ibGluaykNCj4gKwkJCXBhbG1hc19s ZWRfdXBkYXRlX2JpdHMobGVkLT5sZWRzX2RhdGEsIFBBTE1BU19MRURfRU4sDQo+ICsJCQkJCTEg PDwgKGxlZC0+bGVkX25vIC0gMSksIDB4RkYpOw0KPiArCQllbHNlDQo+ICsJCQlwYWxtYXNfbGVk X3VwZGF0ZV9iaXRzKGxlZC0+bGVkc19kYXRhLCBQQUxNQVNfTEVEX0VOLA0KPiArCQkJCQkxIDw8 IChsZWQtPmxlZF9ubyAtIDEpLCAweDAwKTsNCj4gKwl9DQo+ICsJbXV0ZXhfdW5sb2NrKCZsZWQt Pm11dGV4KTsNCj4gK30NCj4gKw0KPiArc3RhdGljIHZvaWQgcGFsbWFzX2xlZHNfc2V0KHN0cnVj dCBsZWRfY2xhc3NkZXYgKmxlZF9jZGV2LA0KPiArCQkJICAgZW51bSBsZWRfYnJpZ2h0bmVzcyB2 YWx1ZSkNCj4gK3sNCj4gKwlzdHJ1Y3QgcGFsbWFzX2xlZCAqbGVkID0gdG9fcGFsbWFzX2xlZChs ZWRfY2Rldik7DQo+ICsJdW5zaWduZWQgbG9uZyBmbGFnczsNCj4gKw0KPiArCXNwaW5fbG9ja19p cnFzYXZlKCZsZWQtPnZhbHVlX2xvY2ssIGZsYWdzKTsNCj4gKwlsZWQtPmJyaWdodG5lc3MgPSB2 YWx1ZTsNCj4gKwlsZWQtPmJsaW5rID0gMDsNCj4gKwlzY2hlZHVsZV93b3JrKCZsZWQtPndvcmsp Ow0KPiArCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmxlZC0+dmFsdWVfbG9jaywgZmxhZ3MpOw0K PiArfQ0KPiArDQo+ICtzdGF0aWMgaW50IHBhbG1hc19sZWRzX2JsaW5rX3NldChzdHJ1Y3QgbGVk X2NsYXNzZGV2ICpsZWRfY2RldiwNCj4gKwkJCQkgICB1bnNpZ25lZCBsb25nICpkZWxheV9vbiwN Cj4gKwkJCQkgICB1bnNpZ25lZCBsb25nICpkZWxheV9vZmYpDQo+ICt7DQo+ICsJc3RydWN0IHBh bG1hc19sZWQgKmxlZCA9IHRvX3BhbG1hc19sZWQobGVkX2NkZXYpOw0KPiArCXVuc2lnbmVkIGxv bmcgZmxhZ3M7DQo+ICsJaW50IHJldCA9IDA7DQo+ICsJaW50IHBlcmlvZDsNCj4gKw0KPiArCS8q IFBpY2sgc29tZSBkZWZhdWx0cyBpZiB3ZSd2ZSBub3QgYmVlbiBnaXZlbiB0aW1lcyAqLw0KPiAr CWlmICgqZGVsYXlfb24gPT0gMCAmJiAqZGVsYXlfb2ZmID09IDApIHsNCj4gKwkJKmRlbGF5X29u ID0gMjUwOw0KPiArCQkqZGVsYXlfb2ZmID0gMjUwOw0KPiArCX0NCj4gKw0KPiArCXNwaW5fbG9j a19pcnFzYXZlKCZsZWQtPnZhbHVlX2xvY2ssIGZsYWdzKTsNCj4gKw0KPiArCS8qIFdlIG9ubHkg aGF2ZSBhIGxpbWl0ZWQgc2VsZWN0aW9uIG9mIHNldHRpbmdzLCBzZWUgaWYgd2UgY2FuDQo+ICsJ ICogc3VwcG9ydCB0aGUgY29uZmlndXJhdGlvbiB3ZSdyZSBiZWluZyBnaXZlbiAqLw0KDQpBY2Nv cmRpbmcgdG8gdGhlIENvZGluZyBTdHlsZSwgdGhlIHByZWZlcnJlZCBzdHlsZSBmb3IgbXVsdGkt bGluZSBjb21tZW50cyBpczoNCg0KICsJLyoNCiArCSAqIFdlIG9ubHkgaGF2ZSBhIGxpbWl0ZWQg c2VsZWN0aW9uIG9mIHNldHRpbmdzLCBzZWUgaWYgd2UgY2FuDQogKwkgKiBzdXBwb3J0IHRoZSBj b25maWd1cmF0aW9uIHdlJ3JlIGJlaW5nIGdpdmVuDQogKwkgKi8NCg0KDQo+ICsJc3dpdGNoICgq ZGVsYXlfb24pIHsNCj4gKwljYXNlIDUwMDoNCj4gKwkJbGVkLT5vbl90aW1lID0gTEVEX09OXzUw ME1TOw0KPiArCQlicmVhazsNCj4gKwljYXNlIDI1MDoNCj4gKwkJbGVkLT5vbl90aW1lID0gTEVE X09OXzI1ME1TOw0KPiArCQlicmVhazsNCj4gKwljYXNlIDEyNToNCj4gKwkJbGVkLT5vbl90aW1l ID0gTEVEX09OXzEyNU1TOw0KPiArCQlicmVhazsNCj4gKwljYXNlIDYyOg0KPiArCWNhc2UgNjM6 DQo+ICsJCS8qIEFjdHVhbGx5IDYyLjVtcyAqLw0KPiArCQlsZWQtPm9uX3RpbWUgPSBMRURfT05f NjJfNU1TOw0KPiArCQlicmVhazsNCj4gKwlkZWZhdWx0Og0KPiArCQlyZXQgPSAtRUlOVkFMOw0K PiArCQlicmVhazsNCj4gKwl9DQo+ICsNCj4gKwlwZXJpb2QgPSAqZGVsYXlfb24gKyAqZGVsYXlf b2ZmOw0KPiArDQo+ICsJaWYgKHJldCA9PSAwKSB7DQo+ICsJCXN3aXRjaCAocGVyaW9kKSB7DQo+ ICsJCWNhc2UgMTI0Og0KPiArCQljYXNlIDEyNToNCj4gKwkJY2FzZSAxMjY6DQo+ICsJCQkvKiBB bGwgcG9zc2libGUgdmFyaWF0aW9ucyBvZiA2Mi41ICsgNjIuNSAqLw0KPiArCQkJbGVkLT5wZXJp b2QgPSBMRURfUEVSSU9EXzEyNU1TOw0KPiArCQkJYnJlYWs7DQo+ICsJCWNhc2UgMjUwOg0KPiAr CQkJbGVkLT5wZXJpb2QgPSBMRURfUEVSSU9EXzI1ME1TOw0KPiArCQkJYnJlYWs7DQo+ICsJCWNh c2UgNTAwOg0KPiArCQkJbGVkLT5wZXJpb2QgPSBMRURfUEVSSU9EXzUwME1TOw0KPiArCQkJYnJl YWs7DQo+ICsJCWNhc2UgMTAwMDoNCj4gKwkJCWxlZC0+cGVyaW9kID0gTEVEX1BFUklPRF8xMDAw TVM7DQo+ICsJCQlicmVhazsNCj4gKwkJY2FzZSAyMDAwOg0KPiArCQkJbGVkLT5wZXJpb2QgPSBM RURfUEVSSU9EXzIwMDBNUzsNCj4gKwkJCWJyZWFrOw0KPiArCQljYXNlIDQwMDA6DQo+ICsJCQls ZWQtPnBlcmlvZCA9IExFRF9QRVJJT0RfNDAwME1TOw0KPiArCQkJYnJlYWs7DQo+ICsJCWNhc2Ug ODAwMDoNCj4gKwkJCWxlZC0+cGVyaW9kID0gTEVEX1BFUklPRF84MDAwTVM7DQo+ICsJCQlicmVh azsNCj4gKwkJZGVmYXVsdDoNCj4gKwkJCXJldCA9IC1FSU5WQUw7DQo+ICsJCQlicmVhazsNCj4g KwkJfQ0KPiArCX0NCj4gKw0KPiArCWlmIChyZXQgPT0gMCkNCj4gKwkJbGVkLT5ibGluayA9IDE7 DQo+ICsJZWxzZQ0KPiArCQlsZWQtPmJsaW5rID0gMDsNCj4gKw0KPiArCS8qIEFsd2F5cyB1cGRh dGU7IGlmIHdlIGZhaWwgdHVybiBvZmYgYmxpbmtpbmcgc2luY2Ugd2UgZXhwZWN0DQo+ICsJICog YSBzb2Z0d2FyZSBmYWxsYmFjay4gKi8NCg0KU2FtZSBhcyBhYm92ZS4NCg0KPiArCXNjaGVkdWxl X3dvcmsoJmxlZC0+d29yayk7DQo+ICsNCj4gKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZsZWQt PnZhbHVlX2xvY2ssIGZsYWdzKTsNCj4gKw0KPiArCXJldHVybiByZXQ7DQo+ICt9DQo+ICsNCj4g K3N0YXRpYyB2b2lkIHBhbG1hc19pbml0X2xlZChzdHJ1Y3QgcGFsbWFzX2xlZHNfZGF0YSAqbGVk c19kYXRhLCBpbnQgb2Zmc2V0LA0KPiArCQlpbnQgbGVkX25vKQ0KPiArew0KPiArCW11dGV4X2lu aXQoJmxlZHNfZGF0YS0+cGFsbWFzX2xlZFtvZmZzZXRdLm11dGV4KTsNCj4gKwlJTklUX1dPUkso JmxlZHNfZGF0YS0+cGFsbWFzX2xlZFtvZmZzZXRdLndvcmssIHBhbG1hc19sZWRzX3dvcmspOw0K PiArCXNwaW5fbG9ja19pbml0KCZsZWRzX2RhdGEtPnBhbG1hc19sZWRbb2Zmc2V0XS52YWx1ZV9s b2NrKTsNCj4gKw0KPiArCWxlZHNfZGF0YS0+cGFsbWFzX2xlZFtvZmZzZXRdLmxlZHNfZGF0YSA9 IGxlZHNfZGF0YTsNCj4gKwlsZWRzX2RhdGEtPnBhbG1hc19sZWRbb2Zmc2V0XS5sZWRfbm8gPSBs ZWRfbm87DQo+ICsJbGVkc19kYXRhLT5wYWxtYXNfbGVkW29mZnNldF0uY2Rldi5uYW1lID0gcGFs bWFzX2xlZF9uYW1lc1tsZWRfbm8gLSAxXTsNCj4gKwlsZWRzX2RhdGEtPnBhbG1hc19sZWRbb2Zm c2V0XS5jZGV2LmRlZmF1bHRfdHJpZ2dlciA9IE5VTEw7DQo+ICsJbGVkc19kYXRhLT5wYWxtYXNf bGVkW29mZnNldF0uY2Rldi5icmlnaHRuZXNzX3NldCA9IHBhbG1hc19sZWRzX3NldDsNCj4gKwls ZWRzX2RhdGEtPnBhbG1hc19sZWRbb2Zmc2V0XS5jZGV2LmJsaW5rX3NldCA9IHBhbG1hc19sZWRz X2JsaW5rX3NldDsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCAgcGFsbWFzX2R0X3RvX3BkYXRh KHN0cnVjdCBkZXZpY2UgKmRldiwNCj4gKwkJc3RydWN0IGRldmljZV9ub2RlICpub2RlLA0KPiAr CQlzdHJ1Y3QgcGFsbWFzX2xlZHNfcGxhdGZvcm1fZGF0YSAqcGRhdGEpDQo+ICt7DQo+ICsJc3Ry dWN0IGRldmljZV9ub2RlICpjaGlsZF9ub2RlOw0KPiArCWludCByZXQ7DQo+ICsJdTMyIHByb3A7 DQo+ICsNCj4gKwljaGlsZF9ub2RlID0gb2ZfZ2V0X2NoaWxkX2J5X25hbWUobm9kZSwgInBhbG1h c19sZWRzIik7DQo+ICsJaWYgKCFjaGlsZF9ub2RlKSB7DQo+ICsJCWRldl9lcnIoZGV2LCAiY2hp bGQgbm9kZSAncGFsbWFzX2xlZHMnIG5vdCBmb3VuZFxuIik7DQo+ICsJCXJldHVybiAtRUlOVkFM Ow0KPiArCX0NCj4gKw0KPiArCXJldCA9IG9mX3Byb3BlcnR5X3JlYWRfdTMyKGNoaWxkX25vZGUs ICJ0aSxsZWQxX2N1cnJlbnQiLCAmcHJvcCk7DQo+ICsJaWYgKCFyZXQpDQo+ICsJCXBkYXRhLT5s ZWQxX2N1cnJlbnQgPSBwcm9wOw0KPiArDQo+ICsJcmV0ID0gb2ZfcHJvcGVydHlfcmVhZF91MzIo Y2hpbGRfbm9kZSwgInRpLGxlZDJfY3VycmVudCIsICZwcm9wKTsNCj4gKwlpZiAoIXJldCkNCj4g KwkJcGRhdGEtPmxlZDJfY3VycmVudCA9IHByb3A7DQo+ICsNCj4gKwlyZXQgPSBvZl9wcm9wZXJ0 eV9yZWFkX3UzMihjaGlsZF9ub2RlLCAidGksbGVkM19jdXJyZW50IiwgJnByb3ApOw0KPiArCWlm ICghcmV0KQ0KPiArCQlwZGF0YS0+bGVkM19jdXJyZW50ID0gcHJvcDsNCj4gKw0KPiArCXJldCA9 IG9mX3Byb3BlcnR5X3JlYWRfdTMyKGNoaWxkX25vZGUsICJ0aSxsZWQ0X2N1cnJlbnQiLCAmcHJv cCk7DQo+ICsJaWYgKCFyZXQpDQo+ICsJCXBkYXRhLT5sZWQ0X2N1cnJlbnQgPSBwcm9wOw0KPiAr DQo+ICsJcmV0ID0gb2ZfcHJvcGVydHlfcmVhZF91MzIoY2hpbGRfbm9kZSwgInRpLGNocmdfbGVk X21vZGUiLCAmcHJvcCk7DQo+ICsJaWYgKCFyZXQpDQo+ICsJCXBkYXRhLT5jaHJnX2xlZF9tb2Rl ID0gcHJvcDsNCj4gKw0KPiArCXJldCA9IG9mX3Byb3BlcnR5X3JlYWRfdTMyKGNoaWxkX25vZGUs ICJ0aSxjaHJnX2xlZF92YmF0X2xvdyIsICZwcm9wKTsNCj4gKwlpZiAoIXJldCkNCj4gKwkJcGRh dGEtPmNocmdfbGVkX3ZiYXRfbG93ID0gcHJvcDsNCj4gKw0KPiArCXJldHVybiAwOw0KPiArfQ0K PiArDQo+ICtzdGF0aWMgaW50IHBhbG1hc19sZWRzX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpDQo+ICt7DQo+ICsJc3RydWN0IHBhbG1hcyAqcGFsbWFzID0gZGV2X2dldF9kcnZk YXRhKHBkZXYtPmRldi5wYXJlbnQpOw0KPiArCXN0cnVjdCBwYWxtYXNfbGVkc19wbGF0Zm9ybV9k YXRhICpwZGF0YSA9IHBkZXYtPmRldi5wbGF0Zm9ybV9kYXRhOw0KPiArCXN0cnVjdCBwYWxtYXNf bGVkc19kYXRhICpsZWRzX2RhdGE7DQo+ICsJc3RydWN0IGRldmljZV9ub2RlICpub2RlID0gcGRl di0+ZGV2Lm9mX25vZGU7DQo+ICsJaW50IHJldCwgaTsNCj4gKwlpbnQgb2Zmc2V0ID0gMDsNCj4g Kw0KPiArCWlmICghcGFsbWFzLT5sZWRfbXV4ZWQgJiYgIWlzX3BhbG1hc19jaGFyZ2VyKHBhbG1h cy0+cHJvZHVjdF9pZCkpIHsNCj4gKwkJZGV2X2VycigmcGRldi0+ZGV2LCAidGhlcmUgYXJlIG5v IExFRHMgbXV4ZWRcbiIpOw0KPiArCQlyZXR1cm4gLUVJTlZBTDsNCj4gKwl9DQo+ICsNCj4gKwkv KiBQYWxtYXMgY2hhcmdlciByZXF1aXJlcyBwbGF0Zm9ybSBkYXRhICovDQo+ICsJaWYgKGlzX3Bh bG1hc19jaGFyZ2VyKHBhbG1hcy0+cHJvZHVjdF9pZCkgJiYgbm9kZSAmJiAhcGRhdGEpIHsNCj4g KwkJcGRhdGEgPSBkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKCpwZGF0YSksIEdGUF9L RVJORUwpOw0KPiArDQo+ICsJCWlmICghcGRhdGEpDQo+ICsJCQlyZXR1cm4gLUVOT01FTTsNCj4g Kw0KPiArCQlyZXQgPSBwYWxtYXNfZHRfdG9fcGRhdGEoJnBkZXYtPmRldiwgbm9kZSwgcGRhdGEp Ow0KPiArCQlpZiAocmV0KQ0KPiArCQkJcmV0dXJuIHJldDsNCj4gKwl9DQo+ICsNCj4gKwlpZiAo aXNfcGFsbWFzX2NoYXJnZXIocGFsbWFzLT5wcm9kdWN0X2lkKSAmJiAhcGRhdGEpDQo+ICsJCXJl dHVybiAtRUlOVkFMOw0KPiArDQo+ICsJbGVkc19kYXRhID0ga3phbGxvYyhzaXplb2YoKmxlZHNf ZGF0YSksIEdGUF9LRVJORUwpOw0KDQpIb3cgYWJvdXQgdXNpbmcgZGV2bV9remFsbG9jKCk/DQpN ZW1vcnkgYWxsb2NhdGVkIHdpdGggdGhpcyBmdW5jdGlvbiBpcyBhdXRvbWF0aWNhbGx5IGZyZWVk DQpvbiBkcml2ZXIgZGV0YWNoLiBTbyBpdCBtYWtlcyBlcnJvciBwYXRoIG1vcmUgc2ltcGxlLg0K DQoNCj4gKwlpZiAoIWxlZHNfZGF0YSkNCj4gKwkJcmV0dXJuIC1FTk9NRU07DQo+ICsJcGxhdGZv cm1fc2V0X2RydmRhdGEocGRldiwgbGVkc19kYXRhKTsNCj4gKw0KPiArCWxlZHNfZGF0YS0+cGFs bWFzID0gcGFsbWFzOw0KPiArDQo+ICsJc3dpdGNoIChwYWxtYXMtPmxlZF9tdXhlZCkgew0KPiAr CWNhc2UgUEFMTUFTX0xFRDFfTVVYRUQgfCBQQUxNQVNfTEVEMl9NVVhFRDoNCj4gKwkJbGVkc19k YXRhLT5ub19sZWRzID0gMjsNCj4gKwkJYnJlYWs7DQo+ICsJY2FzZSBQQUxNQVNfTEVEMV9NVVhF RDoNCj4gKwljYXNlIFBBTE1BU19MRUQyX01VWEVEOg0KPiArCQlsZWRzX2RhdGEtPm5vX2xlZHMg PSAxOw0KPiArCQlicmVhazsNCj4gKwlkZWZhdWx0Og0KPiArCQlsZWRzX2RhdGEtPm5vX2xlZHMg PSAwOw0KPiArCQlicmVhazsNCj4gKwl9DQo+ICsNCj4gKwlpZiAoaXNfcGFsbWFzX2NoYXJnZXIo cGFsbWFzLT5wcm9kdWN0X2lkKSkgew0KPiArCQlpZiAocGRhdGEtPmNocmdfbGVkX21vZGUpDQo+ ICsJCQlsZWRzX2RhdGEtPm5vX2xlZHMgKz0gMjsNCj4gKwkJZWxzZQ0KPiArCQkJbGVkc19kYXRh LT5ub19sZWRzKys7DQo+ICsJfQ0KPiArDQo+ICsJbGVkc19kYXRhLT5wYWxtYXNfbGVkID0ga2Nh bGxvYyhsZWRzX2RhdGEtPm5vX2xlZHMsDQo+ICsJCQlzaXplb2Yoc3RydWN0IHBhbG1hc19sZWQp LCBHRlBfS0VSTkVMKTsNCg0KSG93IGFib3V0IHVzaW5nIGRldm1fa3phbGxvYygpPw0KDQoNCj4g Kw0KPiArCS8qIEluaXRpYWxpc2UgTEVEMSAqLw0KPiArCWlmIChwYWxtYXMtPmxlZF9tdXhlZCAm IFBBTE1BU19MRUQxX01VWEVEKSB7DQo+ICsJCXBhbG1hc19pbml0X2xlZChsZWRzX2RhdGEsIG9m ZnNldCwgMSk7DQo+ICsJCW9mZnNldCsrOw0KPiArCX0NCj4gKw0KPiArCS8qIEluaXRpYWxpc2Ug TEVEMiAqLw0KPiArCWlmIChwYWxtYXMtPmxlZF9tdXhlZCAmIFBBTE1BU19MRUQyX01VWEVEKSB7 DQo+ICsJCXBhbG1hc19pbml0X2xlZChsZWRzX2RhdGEsIG9mZnNldCwgMik7DQo+ICsJCW9mZnNl dCsrOw0KPiArCX0NCj4gKw0KPiArCWlmIChpc19wYWxtYXNfY2hhcmdlcihwYWxtYXMtPnByb2R1 Y3RfaWQpKSB7DQo+ICsJCXBhbG1hc19pbml0X2xlZChsZWRzX2RhdGEsIG9mZnNldCwgMyk7DQo+ ICsJCW9mZnNldCsrOw0KPiArDQo+ICsJCWlmIChwZGF0YS0+Y2hyZ19sZWRfbW9kZSkgew0KPiAr CQkJcGFsbWFzX2xlZF91cGRhdGVfYml0cyhsZWRzX2RhdGEsIFBBTE1BU19DSFJHX0xFRF9DVFJM LA0KPiArCQkJCQlQQUxNQVNfQ0hSR19MRURfQ1RSTF9DSFJHX0xFRF9NT0RFLA0KPiArCQkJCQlQ QUxNQVNfQ0hSR19MRURfQ1RSTF9DSFJHX0xFRF9NT0RFKTsNCj4gKw0KPiArCQkJcGFsbWFzX2lu aXRfbGVkKGxlZHNfZGF0YSwgb2Zmc2V0LCA0KTsNCj4gKwkJfQ0KPiArCX0NCj4gKw0KPiArCWZv ciAoaSA9IDA7IGkgPCBsZWRzX2RhdGEtPm5vX2xlZHM7IGkrKykgew0KPiArCQlyZXQgPSBsZWRf Y2xhc3NkZXZfcmVnaXN0ZXIobGVkc19kYXRhLT5kZXYsDQo+ICsJCQkJJmxlZHNfZGF0YS0+cGFs bWFzX2xlZFtpXS5jZGV2KTsNCj4gKwkJaWYgKHJldCA8IDApIHsNCj4gKwkJCWRldl9lcnIoJnBk ZXYtPmRldiwNCj4gKwkJCQkiRmFpbGVkIHRvIHJlZ2lzdGVyIExFRCBubzogJWQgZXJyOiAlZFxu IiwNCj4gKwkJCQlpLCByZXQpOw0KPiArCQkJZ290byBlcnJfbGVkOw0KPiArCQl9DQo+ICsJfQ0K PiArDQo+ICsJaWYgKCFpc19wYWxtYXNfY2hhcmdlcihwYWxtYXMtPnByb2R1Y3RfaWQpKQ0KPiAr CQlyZXR1cm4gMDsNCj4gKw0KPiArCS8qIFNldCB0aGUgTEVEIGN1cnJlbnQgcmVnaXN0ZXJzIGlm IHNldCBpbiBwbGF0Zm9ybSBkYXRhICovDQo+ICsJaWYgKHBkYXRhLT5sZWQxX2N1cnJlbnQpDQo+ ICsJCXBhbG1hc19sZWRfdXBkYXRlX2JpdHMobGVkc19kYXRhLCBQQUxNQVNfTEVEX0NVUlJFTlRf Q1RSTDEsDQo+ICsJCQkJUEFMTUFTX0xFRF9DVVJSRU5UX0NUUkwxX0xFRF8xX0NVUlJFTlRfTUFT SywNCj4gKwkJCQlwZGF0YS0+bGVkMV9jdXJyZW50KTsNCj4gKw0KPiArCWlmIChwZGF0YS0+bGVk Ml9jdXJyZW50KQ0KPiArCQlwYWxtYXNfbGVkX3VwZGF0ZV9iaXRzKGxlZHNfZGF0YSwgUEFMTUFT X0xFRF9DVVJSRU5UX0NUUkwxLA0KPiArCQkJCVBBTE1BU19MRURfQ1VSUkVOVF9DVFJMMV9MRURf Ml9DVVJSRU5UX01BU0ssDQo+ICsJCQkJcGRhdGEtPmxlZDJfY3VycmVudCA8PA0KPiArCQkJCVBB TE1BU19MRURfQ1VSUkVOVF9DVFJMMV9MRURfMl9DVVJSRU5UX1NISUZUKTsNCj4gKw0KPiArCWlm IChwZGF0YS0+bGVkM19jdXJyZW50KQ0KPiArCQlwYWxtYXNfbGVkX3VwZGF0ZV9iaXRzKGxlZHNf ZGF0YSwgUEFMTUFTX0xFRF9DVVJSRU5UX0NUUkwyLA0KPiArCQkJCVBBTE1BU19MRURfQ1VSUkVO VF9DVFJMMl9MRURfM19DVVJSRU5UX01BU0ssDQo+ICsJCQkJcGRhdGEtPmxlZDNfY3VycmVudCk7 DQo+ICsNCj4gKwlpZiAocGRhdGEtPmxlZDNfY3VycmVudCkNCj4gKwkJcGFsbWFzX2xlZF91cGRh dGVfYml0cyhsZWRzX2RhdGEsIFBBTE1BU19MRURfQ1VSUkVOVF9DVFJMMiwNCj4gKwkJCQlQQUxN QVNfTEVEX0NVUlJFTlRfQ1RSTDJfTEVEXzNfQ1VSUkVOVF9NQVNLLA0KPiArCQkJCXBkYXRhLT5s ZWQzX2N1cnJlbnQpOw0KPiArDQo+ICsJaWYgKHBkYXRhLT5sZWQ0X2N1cnJlbnQpDQo+ICsJCXBh bG1hc19sZWRfdXBkYXRlX2JpdHMobGVkc19kYXRhLCBQQUxNQVNfQ0hSR19MRURfQ1RSTCwNCj4g KwkJCQlQQUxNQVNfQ0hSR19MRURfQ1RSTF9DSFJHX0xFRF9DVVJSRU5UX01BU0ssDQo+ICsJCQkJ cGRhdGEtPmxlZDRfY3VycmVudCA8PA0KPiArCQkJCVBBTE1BU19DSFJHX0xFRF9DVFJMX0NIUkdf TEVEX0NVUlJFTlRfU0hJRlQpOw0KPiArDQo+ICsJaWYgKHBkYXRhLT5jaHJnX2xlZF92YmF0X2xv dykNCj4gKwkJcGFsbWFzX2xlZF91cGRhdGVfYml0cyhsZWRzX2RhdGEsIFBBTE1BU19DSFJHX0xF RF9DVFJMLA0KPiArCQkJCVBBTE1BU19DSFJHX0xFRF9DVFJMX0NIUkdfTE9XQkFUX0JMS19ESVMs DQo+ICsJCQkJUEFMTUFTX0NIUkdfTEVEX0NUUkxfQ0hSR19MT1dCQVRfQkxLX0RJUyk7DQo+ICsN Cj4gKwlyZXR1cm4gMDsNCj4gKw0KPiArZXJyX2xlZDoNCj4gKwlmb3IgKGkgPSAwOyBpIDwgbGVk c19kYXRhLT5ub19sZWRzOyBpKyspDQo+ICsJCWxlZF9jbGFzc2Rldl91bnJlZ2lzdGVyKCZsZWRz X2RhdGEtPnBhbG1hc19sZWRbaV0uY2Rldik7DQo+ICsJa2ZyZWUobGVkc19kYXRhLT5wYWxtYXNf bGVkKTsNCj4gKwlrZnJlZShsZWRzX2RhdGEpOw0KDQpJZiB5b3UgdXNlIGRldm1fa3phbGxvYygp IGFib3ZlLCB5b3UgZG9uJ3QgbmVlZCB0byB1c2Uga2ZyZWUoKS4NCg0KPiArCXJldHVybiByZXQ7 DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgcGFsbWFzX2xlZHNfcmVtb3ZlKHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYpDQo+ICt7DQo+ICsJc3RydWN0IHBhbG1hc19sZWRzX2RhdGEgKmxl ZHNfZGF0YSA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOw0KPiArCWludCBpOw0KPiArDQo+ ICsJZm9yIChpID0gMDsgaSA8IGxlZHNfZGF0YS0+bm9fbGVkczsgaSsrKQ0KPiArCQlsZWRfY2xh c3NkZXZfdW5yZWdpc3RlcigmbGVkc19kYXRhLT5wYWxtYXNfbGVkW2ldLmNkZXYpOw0KPiArCWlm IChpKQ0KPiArCQlrZnJlZShsZWRzX2RhdGEtPnBhbG1hc19sZWQpOw0KPiArCWtmcmVlKGxlZHNf ZGF0YSk7DQoNCklmIHlvdSB1c2UgZGV2bV9remFsbG9jKCkgYWJvdmUsIHlvdSBkb24ndCBuZWVk IHRvIHVzZSBrZnJlZSgpLg0KDQo+ICsNCj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3Rh dGljIHN0cnVjdCBvZl9kZXZpY2VfaWQgb2ZfcGFsbWFzX21hdGNoX3RibFtdID0gew0KPiArCXsg LmNvbXBhdGlibGUgPSAidGkscGFsbWFzLWxlZHMiLCB9LA0KPiArCXsgLyogZW5kICovIH0NCj4g K307DQo+ICsNCj4gK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHBhbG1hc19sZWRzX2Ry aXZlciA9IHsNCj4gKwkuZHJpdmVyID0gew0KPiArCQkubmFtZSA9ICJwYWxtYXMtbGVkcyIsDQo+ ICsJCS5vZl9tYXRjaF90YWJsZSA9IG9mX3BhbG1hc19tYXRjaF90YmwsDQo+ICsJCS5vd25lciA9 IFRISVNfTU9EVUxFLA0KPiArCX0sDQo+ICsJLnByb2JlID0gcGFsbWFzX2xlZHNfcHJvYmUsDQo+ ICsJLnJlbW92ZSA9IHBhbG1hc19sZWRzX3JlbW92ZSwNCj4gK307DQo+ICsNCj4gK3N0YXRpYyBp bnQgIHBhbG1hc19sZWRzX2luaXQodm9pZCkNCj4gK3sNCj4gKwlyZXR1cm4gcGxhdGZvcm1fZHJp dmVyX3JlZ2lzdGVyKCZwYWxtYXNfbGVkc19kcml2ZXIpOw0KPiArfQ0KPiArbW9kdWxlX2luaXQo cGFsbWFzX2xlZHNfaW5pdCk7DQo+ICsNCj4gK3N0YXRpYyB2b2lkIHBhbG1hc19sZWRzX2V4aXQo dm9pZCkNCj4gK3sNCj4gKwlwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3RlcigmcGFsbWFzX2xlZHNf ZHJpdmVyKTsNCj4gK30NCj4gK21vZHVsZV9leGl0KHBhbG1hc19sZWRzX2V4aXQpOw0KDQpQbGVh c2UgdXNlIG1vZHVsZV9wbGF0Zm9ybV9kcml2ZXIoKSBtYWNybyB3aGljaCBtYWtlcyB0aGUgY29k ZQ0Kc21hbGxlciBhbmQgc2ltcGxlci4NCg0KK21vZHVsZV9wbGF0Zm9ybV9kcml2ZXIocGFsbWFz X2xlZHNfZHJpdmVyKTsNCg0KDQo+ICsNCj4gK01PRFVMRV9BVVRIT1IoIkdyYWVtZSBHcmVnb3J5 IDxnZ0BzbGltbG9naWMuY28udWs+Iik7DQo+ICtNT0RVTEVfREVTQ1JJUFRJT04oIlBhbG1hcyBM RUQgZHJpdmVyIik7DQo+ICtNT0RVTEVfTElDRU5TRSgiR1BMIik7DQo+ICtNT0RVTEVfQUxJQVMo InBsYXRmb3JtOnBhbG1hcy1sZWRzIik7DQo+ICtNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBvZl9w YWxtYXNfbWF0Y2hfdGJsKTsNCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbWZkL3BhbG1h cy5oIGIvaW5jbHVkZS9saW51eC9tZmQvcGFsbWFzLmgNCj4gaW5kZXggMGI4Njg0NS4uODU2ZjU0 ZSAxMDA2NDQNCj4gLS0tIGEvaW5jbHVkZS9saW51eC9tZmQvcGFsbWFzLmgNCj4gKysrIGIvaW5j bHVkZS9saW51eC9tZmQvcGFsbWFzLmgNCj4gQEAgLTIzMiw2ICsyMzIsMTYgQEAgc3RydWN0IHBh bG1hc19jbGtfcGxhdGZvcm1fZGF0YSB7DQo+ICAJaW50IGNsazMya2dhdWRpb19tb2RlX3NsZWVw Ow0KPiAgfTsNCj4gDQo+ICtzdHJ1Y3QgcGFsbWFzX2xlZHNfcGxhdGZvcm1fZGF0YSB7DQo+ICsJ aW50IGxlZDFfY3VycmVudDsNCj4gKwlpbnQgbGVkMl9jdXJyZW50Ow0KPiArCWludCBsZWQzX2N1 cnJlbnQ7DQo+ICsJaW50IGxlZDRfY3VycmVudDsNCj4gKw0KPiArCWludCBjaHJnX2xlZF9tb2Rl Ow0KPiArCWludCBjaHJnX2xlZF92YmF0X2xvdzsNCj4gK307DQo+ICsNCj4gIHN0cnVjdCBwYWxt YXNfcGxhdGZvcm1fZGF0YSB7DQo+ICAJaW50IGdwaW9fYmFzZTsNCj4gDQo+IEBAIC0xODU1LDYg KzE4NjUsMTIgQEAgZW51bSB1c2JfaXJxX2V2ZW50cyB7DQo+ICAjZGVmaW5lIFBBTE1BU19MRURf Q1RSTAkJCQkJCTB4MQ0KPiAgI2RlZmluZSBQQUxNQVNfUFdNX0NUUkwxCQkJCQkweDINCj4gICNk ZWZpbmUgUEFMTUFTX1BXTV9DVFJMMgkJCQkJMHgzDQo+ICsjZGVmaW5lIFBBTE1BU19MRURfUEVS SU9EMl9DVFJMCQkJCQkweDQNCj4gKyNkZWZpbmUgUEFMTUFTX0xFRF9DVFJMMgkJCQkJMHg1DQo+ ICsjZGVmaW5lIFBBTE1BU19MRURfQ1VSUkVOVF9DVFJMMQkJCQkweDYNCj4gKyNkZWZpbmUgUEFM TUFTX0xFRF9DVVJSRU5UX0NUUkwyCQkJCTB4Nw0KPiArI2RlZmluZSBQQUxNQVNfQ0hSR19MRURf Q1RSTAkJCQkJMHg4DQo+ICsjZGVmaW5lIFBBTE1BU19MRURfRU4JCQkJCQkweDkNCj4gDQo+ICAv KiBCaXQgZGVmaW5pdGlvbnMgZm9yIExFRF9QRVJJT0RfQ1RSTCAqLw0KPiAgI2RlZmluZSBQQUxN QVNfTEVEX1BFUklPRF9DVFJMX0xFRF8yX1BFUklPRF9NQVNLCQkweDM4DQo+IEBAIC0xODgyLDYg KzE4OTgsNTAgQEAgZW51bSB1c2JfaXJxX2V2ZW50cyB7DQo+ICAjZGVmaW5lIFBBTE1BU19QV01f Q1RSTDJfUFdNX0RVVFlfU0VMX01BU0sJCQkweGZmDQo+ICAjZGVmaW5lIFBBTE1BU19QV01fQ1RS TDJfUFdNX0RVVFlfU0VMX1NISUZUCQkJMA0KPiANCj4gKy8qIEJpdCBkZWZpbml0aW9ucyBmb3Ig TEVEX1BFUklPRDJfQ1RSTCAqLw0KPiArI2RlZmluZSBQQUxNQVNfTEVEX1BFUklPRDJfQ1RSTF9D SFJHX0xFRF9QRVJJT0RfTUFTSwkJMHgzOA0KPiArI2RlZmluZSBQQUxNQVNfTEVEX1BFUklPRDJf Q1RSTF9DSFJHX0xFRF9QRVJJT0RfU0hJRlQJCTMNCj4gKyNkZWZpbmUgUEFMTUFTX0xFRF9QRVJJ T0QyX0NUUkxfTEVEXzNfUEVSSU9EX01BU0sJCTB4MDcNCj4gKyNkZWZpbmUgUEFMTUFTX0xFRF9Q RVJJT0QyX0NUUkxfTEVEXzNfUEVSSU9EX1NISUZUCQkwDQo+ICsNCj4gKy8qIEJpdCBkZWZpbml0 aW9ucyBmb3IgTEVEX0NUUkwyICovDQo+ICsjZGVmaW5lIFBBTE1BU19MRURfQ1RSTDJfQ0hSR19M RURfU0VRCQkJCTB4MjANCj4gKyNkZWZpbmUgUEFMTUFTX0xFRF9DVFJMMl9DSFJHX0xFRF9TRVFf U0hJRlQJCQk1DQo+ICsjZGVmaW5lIFBBTE1BU19MRURfQ1RSTDJfTEVEXzNfU0VRCQkJCTB4MTAN Cj4gKyNkZWZpbmUgUEFMTUFTX0xFRF9DVFJMMl9MRURfM19TRVFfU0hJRlQJCQk0DQo+ICsjZGVm aW5lIFBBTE1BU19MRURfQ1RSTDJfQ0hSR19MRURfT05fVElNRV9NQVNLCQkJMHgwYw0KPiArI2Rl ZmluZSBQQUxNQVNfTEVEX0NUUkwyX0NIUkdfTEVEX09OX1RJTUVfU0hJRlQJCQkyDQo+ICsjZGVm aW5lIFBBTE1BU19MRURfQ1RSTDJfTEVEXzNfT05fVElNRV9NQVNLCQkJMHgwMw0KPiArI2RlZmlu ZSBQQUxNQVNfTEVEX0NUUkwyX0xFRF8zX09OX1RJTUVfU0hJRlQJCQkwDQo+ICsNCj4gKy8qIEJp dCBkZWZpbml0aW9ucyBmb3IgTEVEX0NVUlJFTlRfQ1RSTDEgKi8NCj4gKyNkZWZpbmUgUEFMTUFT X0xFRF9DVVJSRU5UX0NUUkwxX0xFRF8yX0NVUlJFTlRfTUFTSwkJMHgzOA0KPiArI2RlZmluZSBQ QUxNQVNfTEVEX0NVUlJFTlRfQ1RSTDFfTEVEXzJfQ1VSUkVOVF9TSElGVAkJMw0KPiArI2RlZmlu ZSBQQUxNQVNfTEVEX0NVUlJFTlRfQ1RSTDFfTEVEXzFfQ1VSUkVOVF9NQVNLCQkweDA3DQo+ICsj ZGVmaW5lIFBBTE1BU19MRURfQ1VSUkVOVF9DVFJMMV9MRURfMV9DVVJSRU5UX1NISUZUCQkwDQo+ ICsNCj4gKy8qIEJpdCBkZWZpbml0aW9ucyBmb3IgTEVEX0NVUlJFTlRfQ1RSTDIgKi8NCj4gKyNk ZWZpbmUgUEFMTUFTX0xFRF9DVVJSRU5UX0NUUkwyX0xFRF8zX0NVUlJFTlRfTUFTSwkJMHgwNw0K PiArI2RlZmluZSBQQUxNQVNfTEVEX0NVUlJFTlRfQ1RSTDJfTEVEXzNfQ1VSUkVOVF9TSElGVAkJ MA0KPiArDQo+ICsvKiBCaXQgZGVmaW5pdGlvbnMgZm9yIENIUkdfTEVEX0NUUkwgKi8NCj4gKyNk ZWZpbmUgUEFMTUFTX0NIUkdfTEVEX0NUUkxfQ0hSR19MRURfQ1VSUkVOVF9NQVNLCQkweDM4DQo+ ICsjZGVmaW5lIFBBTE1BU19DSFJHX0xFRF9DVFJMX0NIUkdfTEVEX0NVUlJFTlRfU0hJRlQJCTMN Cj4gKyNkZWZpbmUgUEFMTUFTX0NIUkdfTEVEX0NUUkxfQ0hSR19MT1dCQVRfQkxLX0RJUwkJMHgw Mg0KPiArI2RlZmluZSBQQUxNQVNfQ0hSR19MRURfQ1RSTF9DSFJHX0xPV0JBVF9CTEtfRElTX1NI SUZUCQkxDQo+ICsjZGVmaW5lIFBBTE1BU19DSFJHX0xFRF9DVFJMX0NIUkdfTEVEX01PREUJCQkw eDAxDQo+ICsjZGVmaW5lIFBBTE1BU19DSFJHX0xFRF9DVFJMX0NIUkdfTEVEX01PREVfU0hJRlQJ CTANCj4gKw0KPiArLyogQml0IGRlZmluaXRpb25zIGZvciBMRURfRU4gKi8NCj4gKyNkZWZpbmUg UEFMTUFTX0xFRF9FTl9DSFJHX0xFRF9FTgkJCQkweDA4DQo+ICsjZGVmaW5lIFBBTE1BU19MRURf RU5fQ0hSR19MRURfRU5fU0hJRlQJCQkJMw0KPiArI2RlZmluZSBQQUxNQVNfTEVEX0VOX0xFRF8z X0VOCQkJCQkweDA0DQo+ICsjZGVmaW5lIFBBTE1BU19MRURfRU5fTEVEXzNfRU5fU0hJRlQJCQkJ Mg0KPiArI2RlZmluZSBQQUxNQVNfTEVEX0VOX0xFRF8yX0VOCQkJCQkweDAyDQo+ICsjZGVmaW5l IFBBTE1BU19MRURfRU5fTEVEXzJfRU5fU0hJRlQJCQkJMQ0KPiArI2RlZmluZSBQQUxNQVNfTEVE X0VOX0xFRF8xX0VOCQkJCQkweDAxDQo+ICsjZGVmaW5lIFBBTE1BU19MRURfRU5fTEVEXzFfRU5f U0hJRlQJCQkJMA0KPiArDQo+ICAvKiBSZWdpc3RlcnMgZm9yIGZ1bmN0aW9uIElOVEVSUlVQVCAq Lw0KPiAgI2RlZmluZSBQQUxNQVNfSU5UMV9TVEFUVVMJCQkJCTB4MA0KPiAgI2RlZmluZSBQQUxN QVNfSU5UMV9NQVNLCQkJCQkweDENCj4gLS0NCj4gMS43LjAuNA0KPiANCj4gLS0NCj4gVG8gdW5z dWJzY3JpYmUgZnJvbSB0aGlzIGxpc3Q6IHNlbmQgdGhlIGxpbmUgInVuc3Vic2NyaWJlIGxpbnV4 LWxlZHMiIGluDQo+IHRoZSBib2R5IG9mIGEgbWVzc2FnZSB0byBtYWpvcmRvbW9Admdlci5rZXJu ZWwub3JnDQo+IE1vcmUgbWFqb3Jkb21vIGluZm8gYXQgIGh0dHA6Ly92Z2VyLmtlcm5lbC5vcmcv bWFqb3Jkb21vLWluZm8uaHRtbA0K