From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Zimmermann Date: Mon, 14 Oct 2019 14:04:08 +0000 Subject: [PATCH v2 07/15] drm/fbconv: Add modesetting infrastructure Message-Id: <20191014140416.28517-8-tzimmermann@suse.de> List-Id: References: <20191014140416.28517-1-tzimmermann@suse.de> In-Reply-To: <20191014140416.28517-1-tzimmermann@suse.de> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: airlied@linux.ie, daniel@ffwll.ch, maarten.lankhorst@linux.intel.com, mripard@kernel.org, sean@poorly.run, b.zolnierkie@samsung.com, ajax@redhat.com, ville.syrjala@linux.intel.com, malat@debian.org, michel@daenzer.net Cc: gregkh@linuxfoundation.org, linux-fbdev@vger.kernel.org, Thomas Zimmermann , dri-devel@lists.freedesktop.org, corbet@lwn.net Modesetting for fbconv supports a single display pipeline with CRTC, primary plane, encoder and connector. It's implementation is based on struct drm_simple_display_pipe, which fits this use case nicely. Signed-off-by: Thomas Zimmermann --- drivers/gpu/drm/drm_fbconv_helper.c | 382 ++++++++++++++++++++++++++++ include/drm/drm_fbconv_helper.h | 78 ++++++ 2 files changed, 460 insertions(+) diff --git a/drivers/gpu/drm/drm_fbconv_helper.c b/drivers/gpu/drm/drm_fbconv_helper.c index e5a58a361ae9..4cda1f15e072 100644 --- a/drivers/gpu/drm/drm_fbconv_helper.c +++ b/drivers/gpu/drm/drm_fbconv_helper.c @@ -4,8 +4,13 @@ #include +#include #include +#include +#include #include +#include +#include /* * Format conversion helpers @@ -635,3 +640,380 @@ void drm_fbconv_init_fb_var_screeninfo_from_mode( drm_fbconv_update_fb_var_screeninfo_from_mode(fb_var, mode); } EXPORT_SYMBOL(drm_fbconv_init_fb_var_screeninfo_from_mode); + +/* + * Connector + */ + +static int connector_helper_get_modes(struct drm_connector *connector) +{ + return 0; +} + +static int connector_helper_detect_ctx(struct drm_connector *connector, + struct drm_modeset_acquire_ctx *ctx, + bool force) +{ + return connector_status_connected; +} + +static enum drm_mode_status connector_helper_mode_valid( + struct drm_connector *connector, struct drm_display_mode *mode) +{ + return MODE_OK; +} + +static int connector_helper_atomic_check(struct drm_connector *connector, + struct drm_atomic_state *state) +{ + return 0; +} + +static void connector_helper_atomic_commit(struct drm_connector *connector, + struct drm_connector_state *state) +{ } + +static const struct drm_connector_helper_funcs connector_helper_funcs = { + .get_modes = connector_helper_get_modes, + .detect_ctx = connector_helper_detect_ctx, + .mode_valid = connector_helper_mode_valid, + .best_encoder = NULL, /* use default */ + .atomic_best_encoder = NULL, /* use best_encoder instead */ + .atomic_check = connector_helper_atomic_check, + .atomic_commit = connector_helper_atomic_commit +}; + +static enum drm_connector_status connector_detect( + struct drm_connector *connector, bool force) +{ + return connector_status_connected; +} + +static void connector_force(struct drm_connector *connector) +{ } + +static void connector_destroy(struct drm_connector *connector) +{ } + +static int connector_atomic_set_property(struct drm_connector *connector, + struct drm_connector_state *state, + struct drm_property *property, + uint64_t val) +{ + return -EINVAL; +} + +static int connector_atomic_get_property( + struct drm_connector *connector, + const struct drm_connector_state *state, struct drm_property *property, + uint64_t *val) +{ + return -EINVAL; +} + +static const struct drm_connector_funcs connector_funcs = { + .dpms = NULL, /* not used by atomic drivers */ + .reset = drm_atomic_helper_connector_reset, + .detect = connector_detect, + .force = connector_force, + .fill_modes = drm_helper_probe_single_connector_modes, + .set_property = NULL, + .late_register = NULL, + .early_unregister = NULL, + .destroy = connector_destroy, + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, + .atomic_set_property = connector_atomic_set_property, + .atomic_get_property = connector_atomic_get_property, + .atomic_print_state = NULL +}; + +/* + * Simple display pipe + */ + +/** + * drm_fbconv_simple_display_pipe_mode_valid - default implementation for + * struct drm_simple_display_pipe_funcs.mode_valid + * @crtc: the DRM CRTC structure + * @mode: the display mode to validate + * Returns: + * MODE_OK on success, or + * a MODE constant otherwise + */ +enum drm_mode_status +drm_fbconv_simple_display_pipe_mode_valid(struct drm_crtc *crtc, + const struct drm_display_mode *mode) +{ + return MODE_OK; +} +EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_mode_valid); + +/** + * drm_fbconv_simple_display_pipe_mode_fixup - default implementation for + * struct drm_simple_display_pipe_funcs.mode_fixup + * @crtc: the DRM CRTC structure + * @mode: the display mode + * @adjusted_mode: the adjusted display mode + * Returns: + * true on success, or + * false otherwise + */ +bool drm_fbconv_simple_display_pipe_mode_fixup( + struct drm_crtc *crtc, const struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + return true; +} +EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_mode_fixup); + +/** + * drm_fbconv_simple_display_pipe_enable - default implementation for + * struct drm_simple_display_pipe_funcs.enable + * @pipe: the display pipe structure + * @crtc_state: the new CRTC state + * @plane_state: the new plane state + */ +void +drm_fbconv_simple_display_pipe_enable(struct drm_simple_display_pipe *pipe, + struct drm_crtc_state *crtc_state, + struct drm_plane_state *plane_state) +{ } +EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_enable); + +/** + * drm_fbconv_simple_display_pipe_disable - default implementation for + * struct drm_simple_display_pipe_funcs.disable + * @pipe: the display pipe structure + */ +void +drm_fbconv_simple_display_pipe_disable(struct drm_simple_display_pipe *pipe) +{ } +EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_disable); + +/** + * drm_fbconv_simple_display_pipe_check - default implementation for + * struct drm_simple_display_pipe_funcs.check + * @pipe: the display pipe structure + * @plane_state: the new plane state + * @crtc_state: the new CRTC state + */ +int +drm_fbconv_simple_display_pipe_check(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *plane_state, + struct drm_crtc_state *crtc_state) +{ + return 0; +} +EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_check); + +/** + * drm_fbconv_simple_display_pipe_mode_update - default implementation for + * struct drm_simple_display_pipe_funcs.update + * @pipe: the display pipe structure + * @old_plane_state: the old plane state + */ +void +drm_fbconv_simple_display_pipe_update(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *old_plane_state) +{ } +EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_update); + +/** + * drm_fbconv_simple_display_pipe_prepare_fb - default implementation for + * struct drm_simple_display_pipe_funcs.prepare_fb + * @pipe: the display pipe structure + * @plane_state: the new plane state + * Returns: + * 0 on success, or + * a negative error code otherwise. + * + * The implementation of struct drm_simple_display_pipe_funcs.prepare_fb + * maps the framebuffer's buffer object and the fbdev's screen memory, if + * necessary. After converting the fbdev driver to DRM, only the buffer-object + * mapping should remaing. See drm_fbconv_simple_display_pipe_cleanup_fb() for + * the corresponding clean-up helper. + */ +int +drm_fbconv_simple_display_pipe_prepare_fb(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *plane_state) +{ } +EXPORT_SYMBOL(drm_fbconv_simple_display_pipe_prepare_fb); + +/** + * drm_fbconv_simple_display_pipe_cleanup_fb - default implementation for + * struct drm_simple_display_pipe_funcs.cleanup_fb + * @pipe: the display pipe structure + * @plane_state: the old plane state + * + * This function cleans up the framebuffer state after a plane update. See + * drm_fbconv_simple_display_pipe_prepare_fb() for the corresponding prepare + * helper. + */ +void +drm_fbconv_simple_display_pipe_cleanup_fb(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *plane_state) +{ } + +static const struct drm_simple_display_pipe_funcs simple_display_pipe_funcs = { + .mode_valid = drm_fbconv_simple_display_pipe_mode_valid, + .mode_fixup = drm_fbconv_simple_display_pipe_mode_fixup, + .enable = drm_fbconv_simple_display_pipe_enable, + .disable = drm_fbconv_simple_display_pipe_disable, + .check = drm_fbconv_simple_display_pipe_check, + .update = drm_fbconv_simple_display_pipe_update, + .prepare_fb = drm_fbconv_simple_display_pipe_prepare_fb, + .cleanup_fb = drm_fbconv_simple_display_pipe_cleanup_fb, +}; + +/* + * Mode config + */ + +static enum drm_mode_status mode_config_mode_valid( + struct drm_device *dev, const struct drm_display_mode *mode) +{ + return MODE_OK; +} + +static const struct drm_mode_config_funcs mode_config_funcs = { + .fb_create = drm_gem_fb_create_with_dirty, + .get_format_info = NULL, + /* DRM porting notes: the output_poll_changed callback is used by + * fb helpers to implement fbdev emulation. If you're porting an + * fbdev driver to DRM and enable fbdev emulation, this callback + * will become useful. + */ + .output_poll_changed = drm_fb_helper_output_poll_changed, + .mode_valid = mode_config_mode_valid, + .atomic_check = drm_atomic_helper_check, + .atomic_commit = drm_atomic_helper_commit, + .atomic_state_alloc = NULL, + .atomic_state_clear = NULL, + .atomic_state_free = NULL +}; + +/** + * drm_fbconv_modeset_init - initializes an fbconv modesetting structure + * @modeset: the fbconv modesetting structure to initialize + * @dev: the DRM device + * @fb_info: the fbdev driver's fb_info structure + * @max_width: the maximum display width that is supported by + * the device + * @max_height: the maximum display height that is supported by + * the device + * @preferred_depth: the device's preferred color depth + * Returns: + * 0 on success, or + * a negative error code otherwise + * + * This function initializes an instance of struct drm_fbconv_modeset. The + * supplied values for max_width, max_height, and max_depth should match the + * devices capabilities and be supported by the fbdev driver. DRM helpers + * will use these to auto-configure and validate display settings. + */ +int drm_fbconv_modeset_init(struct drm_fbconv_modeset *modeset, + struct drm_device *dev, struct fb_info *fb_info, + unsigned int max_width, unsigned int max_height, + unsigned int preferred_depth) +{ + struct drm_mode_config *mode_config = &dev->mode_config; + + modeset->dev = dev; + modeset->fb_info = fb_info; + + drm_mode_config_init(dev); + + mode_config->max_width = (int)max_width; + mode_config->max_height = (int)max_height; + mode_config->fb_base = fb_info->fix.smem_start; + mode_config->preferred_depth = preferred_depth; + mode_config->prefer_shadow_fbdev = true; + mode_config->funcs = &mode_config_funcs; + + return 0; +} +EXPORT_SYMBOL(drm_fbconv_modeset_init); + +/** + * drm_fbconv_modeset_cleanup - Cleans up an fbconv modesetting structure + * @modeset: the fbconv modesetting structure to clean up + */ +void drm_fbconv_modeset_cleanup(struct drm_fbconv_modeset *modeset) +{ + drm_mode_config_cleanup(modeset->dev); +} +EXPORT_SYMBOL(drm_fbconv_modeset_cleanup); + +/** + * drm_fbconv_modeset_setup_pipe - sets up the display pipeline for fbconv + * @modeset: an fbconv modesetting structure + * @funcs: an implementation of + * struct drm_simple_display_pipe_funcs, or NULL + * @formats: the device's supported display formats + * @format_count: the number of entries in @formats + * @format_modifiers: DRM format modifiers, or NULL + * @connector: the DRM connector, or NULL + * Returns: + * 0 on success, or + * a negative error code otherwise + * + * This function sets up the display pipeline for an initialized instance of + * struct drm_fbconv_modeset. For maximum compatibility with userspace, the + * provided list of formats should contain at least DRM_FORMAT_XRGB8888 and + * DRM_FORMAT_RGB565. The necessary conversion to the hardware's actual + * configuration can be performed by drm_fbconv_simple_display_pipe_update(). + * + * The values for @funcs, @format_modifiers, and @connector should be NULL + * by default. Explicitly settings these parameters will only be helpful for + * refactoring an fbdev driver into a DRM driver. + */ +int +drm_fbconv_modeset_setup_pipe(struct drm_fbconv_modeset *modeset, + const struct drm_simple_display_pipe_funcs *funcs, + const uint32_t *formats, + unsigned int format_count, + const uint64_t *format_modifiers, + struct drm_connector *connector) +{ + int ret; + + /* DRM porting note: Now let's enable the display pipeline. If + * you're porting a framebuffer driver to DRM, you may want to + * set the correct connector type or replace the simple display + * pipeline with something more sophisticated. + */ + + if (!funcs) + funcs = &simple_display_pipe_funcs; + + if (!connector) { + connector = &modeset->connector; + + ret = drm_connector_init(modeset->dev, connector, + &connector_funcs, + DRM_MODE_CONNECTOR_Unknown); + if (ret) + return ret; + drm_connector_helper_add(connector, &connector_helper_funcs); + + ret = drm_connector_register(connector); + if (ret < 0) + return ret; + + } + + ret = drm_simple_display_pipe_init(modeset->dev, &modeset->pipe, + funcs, formats, format_count, + format_modifiers, connector); + if (ret) + return ret; + + /* Final step: resetting the device's mode config creates + * state for all objects in the mode-setting pipeline. + */ + drm_mode_config_reset(modeset->dev); + + return 0; +} +EXPORT_SYMBOL(drm_fbconv_modeset_setup_pipe); diff --git a/include/drm/drm_fbconv_helper.h b/include/drm/drm_fbconv_helper.h index cbb13228c76c..79716af687c1 100644 --- a/include/drm/drm_fbconv_helper.h +++ b/include/drm/drm_fbconv_helper.h @@ -3,7 +3,11 @@ #ifndef DRM_FBCONV_HELPER_H #define DRM_FBCONV_HELPER_H +#include +#include +#include #include +#include struct drm_device; struct drm_display_mode; @@ -51,4 +55,78 @@ void drm_fbconv_update_fb_var_screeninfo_from_mode( void drm_fbconv_init_fb_var_screeninfo_from_mode( struct fb_var_screeninfo *var, const struct drm_display_mode *mode); +/* + * Simple display pipe + */ + +enum drm_mode_status +drm_fbconv_simple_display_pipe_mode_valid(struct drm_crtc *crtc, + const struct drm_display_mode *mode); + +bool drm_fbconv_simple_display_pipe_mode_fixup( + struct drm_crtc *crtc, const struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode); + +void +drm_fbconv_simple_display_pipe_enable(struct drm_simple_display_pipe *pipe, + struct drm_crtc_state *crtc_state, + struct drm_plane_state *plane_state); + +void +drm_fbconv_simple_display_pipe_disable(struct drm_simple_display_pipe *pipe); + +int +drm_fbconv_simple_display_pipe_check(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *plane_state, + struct drm_crtc_state *crtc_state); + +void +drm_fbconv_simple_display_pipe_update(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *old_plane_state); + +int +drm_fbconv_simple_display_pipe_prepare_fb(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *plane_state); + +void +drm_fbconv_simple_display_pipe_cleanup_fb(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *plane_state); + +/* + * Modeset helpers + */ + +/** + * struct drm_fbconv_modeset - contains state for fbconv modesetting + * @connector: the DRM connector + * @pipe: the modesetting pipeline + * @dev: the DRM device + * @fb_info: the fbdev driver's fb_info structure + */ +struct drm_fbconv_modeset { + struct drm_connector connector; + struct drm_simple_display_pipe pipe; + + struct drm_device *dev; + struct fb_info *fb_info; +}; + +static inline struct drm_fbconv_modeset *drm_fbconv_modeset_of_pipe( + struct drm_simple_display_pipe *pipe) +{ + return container_of(pipe, struct drm_fbconv_modeset, pipe); +} + +int drm_fbconv_modeset_init(struct drm_fbconv_modeset *modeset, + struct drm_device *dev, struct fb_info *fb_info, + unsigned int max_width, unsigned int max_height, + unsigned int preferred_depth); +void drm_fbconv_modeset_cleanup(struct drm_fbconv_modeset *modeset); + +int drm_fbconv_modeset_setup_pipe( + struct drm_fbconv_modeset *modeset, + const struct drm_simple_display_pipe_funcs *funcs, + const uint32_t *formats, unsigned int format_count, + const uint64_t *format_modifiers, struct drm_connector *connector); + #endif -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Zimmermann Subject: [PATCH v2 07/15] drm/fbconv: Add modesetting infrastructure Date: Mon, 14 Oct 2019 16:04:08 +0200 Message-ID: <20191014140416.28517-8-tzimmermann@suse.de> References: <20191014140416.28517-1-tzimmermann@suse.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mx1.suse.de (mx2.suse.de [195.135.220.15]) by gabe.freedesktop.org (Postfix) with ESMTPS id 323436E4AB for ; Mon, 14 Oct 2019 14:04:24 +0000 (UTC) In-Reply-To: <20191014140416.28517-1-tzimmermann@suse.de> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: airlied@linux.ie, daniel@ffwll.ch, maarten.lankhorst@linux.intel.com, mripard@kernel.org, sean@poorly.run, b.zolnierkie@samsung.com, ajax@redhat.com, ville.syrjala@linux.intel.com, malat@debian.org, michel@daenzer.net Cc: gregkh@linuxfoundation.org, linux-fbdev@vger.kernel.org, Thomas Zimmermann , dri-devel@lists.freedesktop.org, corbet@lwn.net List-Id: dri-devel@lists.freedesktop.org TW9kZXNldHRpbmcgZm9yIGZiY29udiBzdXBwb3J0cyBhIHNpbmdsZSBkaXNwbGF5IHBpcGVsaW5l IHdpdGggQ1JUQywKcHJpbWFyeSBwbGFuZSwgZW5jb2RlciBhbmQgY29ubmVjdG9yLiBJdCdzIGlt cGxlbWVudGF0aW9uIGlzIGJhc2VkIG9uCnN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSwg d2hpY2ggZml0cyB0aGlzIHVzZSBjYXNlIG5pY2VseS4KClNpZ25lZC1vZmYtYnk6IFRob21hcyBa aW1tZXJtYW5uIDx0emltbWVybWFubkBzdXNlLmRlPgotLS0KIGRyaXZlcnMvZ3B1L2RybS9kcm1f ZmJjb252X2hlbHBlci5jIHwgMzgyICsrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGluY2x1 ZGUvZHJtL2RybV9mYmNvbnZfaGVscGVyLmggICAgIHwgIDc4ICsrKysrKwogMiBmaWxlcyBjaGFu Z2VkLCA0NjAgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1f ZmJjb252X2hlbHBlci5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9mYmNvbnZfaGVscGVyLmMKaW5k ZXggZTVhNThhMzYxYWU5Li40Y2RhMWYxNWUwNzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9kcm1fZmJjb252X2hlbHBlci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZmJjb252X2hl bHBlci5jCkBAIC00LDggKzQsMTMgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2ZiLmg+CiAKKyNpbmNs dWRlIDxkcm0vZHJtX2F0b21pY19oZWxwZXIuaD4KICNpbmNsdWRlIDxkcm0vZHJtX2ZiY29udl9o ZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2ZiX2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9k cm1fZ2VtX2ZyYW1lYnVmZmVyX2hlbHBlci5oPgogI2luY2x1ZGUgPGRybS9kcm1fbW9kZXMuaD4K KyNpbmNsdWRlIDxkcm0vZHJtX21vZGVzZXRfaGVscGVyX3Z0YWJsZXMuaD4KKyNpbmNsdWRlIDxk cm0vZHJtX3Byb2JlX2hlbHBlci5oPgogCiAvKgogICogRm9ybWF0IGNvbnZlcnNpb24gaGVscGVy cwpAQCAtNjM1LDMgKzY0MCwzODAgQEAgdm9pZCBkcm1fZmJjb252X2luaXRfZmJfdmFyX3NjcmVl bmluZm9fZnJvbV9tb2RlKAogCWRybV9mYmNvbnZfdXBkYXRlX2ZiX3Zhcl9zY3JlZW5pbmZvX2Zy b21fbW9kZShmYl92YXIsIG1vZGUpOwogfQogRVhQT1JUX1NZTUJPTChkcm1fZmJjb252X2luaXRf ZmJfdmFyX3NjcmVlbmluZm9fZnJvbV9tb2RlKTsKKworLyoKKyAqIENvbm5lY3RvcgorICovCisK K3N0YXRpYyBpbnQgY29ubmVjdG9yX2hlbHBlcl9nZXRfbW9kZXMoc3RydWN0IGRybV9jb25uZWN0 b3IgKmNvbm5lY3RvcikKK3sKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBjb25uZWN0b3Jf aGVscGVyX2RldGVjdF9jdHgoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKKwkJCQkg ICAgICAgc3RydWN0IGRybV9tb2Rlc2V0X2FjcXVpcmVfY3R4ICpjdHgsCisJCQkJICAgICAgIGJv b2wgZm9yY2UpCit7CisJcmV0dXJuIGNvbm5lY3Rvcl9zdGF0dXNfY29ubmVjdGVkOworfQorCitz dGF0aWMgZW51bSBkcm1fbW9kZV9zdGF0dXMgY29ubmVjdG9yX2hlbHBlcl9tb2RlX3ZhbGlkKAor CXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsIHN0cnVjdCBkcm1fZGlzcGxheV9tb2Rl ICptb2RlKQoreworCXJldHVybiBNT0RFX09LOworfQorCitzdGF0aWMgaW50IGNvbm5lY3Rvcl9o ZWxwZXJfYXRvbWljX2NoZWNrKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCisJCQkJ CSBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCit7CisJcmV0dXJuIDA7Cit9CisKK3N0 YXRpYyB2b2lkIGNvbm5lY3Rvcl9oZWxwZXJfYXRvbWljX2NvbW1pdChzdHJ1Y3QgZHJtX2Nvbm5l Y3RvciAqY29ubmVjdG9yLAorCQkJCQkgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqc3Rh dGUpCit7IH0KKworc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2hlbHBlcl9mdW5j cyBjb25uZWN0b3JfaGVscGVyX2Z1bmNzID0geworCS5nZXRfbW9kZXMgPSBjb25uZWN0b3JfaGVs cGVyX2dldF9tb2RlcywKKwkuZGV0ZWN0X2N0eCA9IGNvbm5lY3Rvcl9oZWxwZXJfZGV0ZWN0X2N0 eCwKKwkubW9kZV92YWxpZCA9IGNvbm5lY3Rvcl9oZWxwZXJfbW9kZV92YWxpZCwKKwkuYmVzdF9l bmNvZGVyID0gTlVMTCwgLyogdXNlIGRlZmF1bHQgKi8KKwkuYXRvbWljX2Jlc3RfZW5jb2RlciA9 IE5VTEwsIC8qIHVzZSBiZXN0X2VuY29kZXIgaW5zdGVhZCAqLworCS5hdG9taWNfY2hlY2sgPSBj b25uZWN0b3JfaGVscGVyX2F0b21pY19jaGVjaywKKwkuYXRvbWljX2NvbW1pdCA9IGNvbm5lY3Rv cl9oZWxwZXJfYXRvbWljX2NvbW1pdAorfTsKKworc3RhdGljIGVudW0gZHJtX2Nvbm5lY3Rvcl9z dGF0dXMgY29ubmVjdG9yX2RldGVjdCgKKwlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9y LCBib29sIGZvcmNlKQoreworCXJldHVybiBjb25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3RlZDsKK30K Kworc3RhdGljIHZvaWQgY29ubmVjdG9yX2ZvcmNlKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25u ZWN0b3IpCit7IH0KKworc3RhdGljIHZvaWQgY29ubmVjdG9yX2Rlc3Ryb3koc3RydWN0IGRybV9j b25uZWN0b3IgKmNvbm5lY3RvcikKK3sgfQorCitzdGF0aWMgaW50IGNvbm5lY3Rvcl9hdG9taWNf c2V0X3Byb3BlcnR5KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCisJCQkJCSBzdHJ1 Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqc3RhdGUsCisJCQkJCSBzdHJ1Y3QgZHJtX3Byb3BlcnR5 ICpwcm9wZXJ0eSwKKwkJCQkJIHVpbnQ2NF90IHZhbCkKK3sKKwlyZXR1cm4gLUVJTlZBTDsKK30K Kworc3RhdGljIGludCBjb25uZWN0b3JfYXRvbWljX2dldF9wcm9wZXJ0eSgKKwlzdHJ1Y3QgZHJt X2Nvbm5lY3RvciAqY29ubmVjdG9yLAorCWNvbnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRl ICpzdGF0ZSwgc3RydWN0IGRybV9wcm9wZXJ0eSAqcHJvcGVydHksCisJdWludDY0X3QgKnZhbCkK K3sKKwlyZXR1cm4gLUVJTlZBTDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fY29ubmVj dG9yX2Z1bmNzIGNvbm5lY3Rvcl9mdW5jcyA9IHsKKwkuZHBtcyA9IE5VTEwsIC8qIG5vdCB1c2Vk IGJ5IGF0b21pYyBkcml2ZXJzICovCisJLnJlc2V0ID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVj dG9yX3Jlc2V0LAorCS5kZXRlY3QgPSBjb25uZWN0b3JfZGV0ZWN0LAorCS5mb3JjZSA9IGNvbm5l Y3Rvcl9mb3JjZSwKKwkuZmlsbF9tb2RlcyA9IGRybV9oZWxwZXJfcHJvYmVfc2luZ2xlX2Nvbm5l Y3Rvcl9tb2RlcywKKwkuc2V0X3Byb3BlcnR5ID0gTlVMTCwKKwkubGF0ZV9yZWdpc3RlciA9IE5V TEwsCisJLmVhcmx5X3VucmVnaXN0ZXIgPSBOVUxMLAorCS5kZXN0cm95ID0gY29ubmVjdG9yX2Rl c3Ryb3ksCisJLmF0b21pY19kdXBsaWNhdGVfc3RhdGUgPSBkcm1fYXRvbWljX2hlbHBlcl9jb25u ZWN0b3JfZHVwbGljYXRlX3N0YXRlLAorCS5hdG9taWNfZGVzdHJveV9zdGF0ZSA9IGRybV9hdG9t aWNfaGVscGVyX2Nvbm5lY3Rvcl9kZXN0cm95X3N0YXRlLAorCS5hdG9taWNfc2V0X3Byb3BlcnR5 ID0gY29ubmVjdG9yX2F0b21pY19zZXRfcHJvcGVydHksCisJLmF0b21pY19nZXRfcHJvcGVydHkg PSBjb25uZWN0b3JfYXRvbWljX2dldF9wcm9wZXJ0eSwKKwkuYXRvbWljX3ByaW50X3N0YXRlID0g TlVMTAorfTsKKworLyoKKyAqIFNpbXBsZSBkaXNwbGF5IHBpcGUKKyAqLworCisvKioKKyAqIGRy bV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9tb2RlX3ZhbGlkIC0gZGVmYXVsdCBpbXBsZW1l bnRhdGlvbiBmb3IKKyAqCXN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZV9mdW5jcy5tb2Rl X3ZhbGlkCisgKiBAY3J0YzoJdGhlIERSTSBDUlRDIHN0cnVjdHVyZQorICogQG1vZGU6CXRoZSBk aXNwbGF5IG1vZGUgdG8gdmFsaWRhdGUKKyAqIFJldHVybnM6CisgKglNT0RFX09LIG9uIHN1Y2Nl c3MsIG9yCisgKglhIE1PREUgY29uc3RhbnQgb3RoZXJ3aXNlCisgKi8KK2VudW0gZHJtX21vZGVf c3RhdHVzCitkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfbW9kZV92YWxpZChzdHJ1Y3Qg ZHJtX2NydGMgKmNydGMsCisJCQkJCSAgY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1v ZGUpCit7CisJcmV0dXJuIE1PREVfT0s7Cit9CitFWFBPUlRfU1lNQk9MKGRybV9mYmNvbnZfc2lt cGxlX2Rpc3BsYXlfcGlwZV9tb2RlX3ZhbGlkKTsKKworLyoqCisgKiBkcm1fZmJjb252X3NpbXBs ZV9kaXNwbGF5X3BpcGVfbW9kZV9maXh1cCAtIGRlZmF1bHQgaW1wbGVtZW50YXRpb24gZm9yCisg KglzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfZnVuY3MubW9kZV9maXh1cAorICogQGNy dGM6CQl0aGUgRFJNIENSVEMgc3RydWN0dXJlCisgKiBAbW9kZToJCXRoZSBkaXNwbGF5IG1vZGUK KyAqIEBhZGp1c3RlZF9tb2RlOgl0aGUgYWRqdXN0ZWQgZGlzcGxheSBtb2RlCisgKiBSZXR1cm5z OgorICoJdHJ1ZSBvbiBzdWNjZXNzLCBvcgorICoJZmFsc2Ugb3RoZXJ3aXNlCisgKi8KK2Jvb2wg ZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX21vZGVfZml4dXAoCisJc3RydWN0IGRybV9j cnRjICpjcnRjLCBjb25zdCBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSwKKwlzdHJ1Y3Qg ZHJtX2Rpc3BsYXlfbW9kZSAqYWRqdXN0ZWRfbW9kZSkKK3sKKwlyZXR1cm4gdHJ1ZTsKK30KK0VY UE9SVF9TWU1CT0woZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX21vZGVfZml4dXApOwor CisvKioKKyAqIGRybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9lbmFibGUgLSBkZWZhdWx0 IGltcGxlbWVudGF0aW9uIGZvcgorICoJc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlX2Z1 bmNzLmVuYWJsZQorICogQHBpcGU6CQl0aGUgZGlzcGxheSBwaXBlIHN0cnVjdHVyZQorICogQGNy dGNfc3RhdGU6CQl0aGUgbmV3IENSVEMgc3RhdGUKKyAqIEBwbGFuZV9zdGF0ZToJdGhlIG5ldyBw bGFuZSBzdGF0ZQorICovCit2b2lkCitkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfZW5h YmxlKHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSAqcGlwZSwKKwkJCQkgICAgICBzdHJ1 Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCisJCQkJICAgICAgc3RydWN0IGRybV9wbGFu ZV9zdGF0ZSAqcGxhbmVfc3RhdGUpCit7IH0KK0VYUE9SVF9TWU1CT0woZHJtX2ZiY29udl9zaW1w bGVfZGlzcGxheV9waXBlX2VuYWJsZSk7CisKKy8qKgorICogZHJtX2ZiY29udl9zaW1wbGVfZGlz cGxheV9waXBlX2Rpc2FibGUgLSBkZWZhdWx0IGltcGxlbWVudGF0aW9uIGZvcgorICoJc3RydWN0 IGRybV9zaW1wbGVfZGlzcGxheV9waXBlX2Z1bmNzLmRpc2FibGUKKyAqIEBwaXBlOgkJdGhlIGRp c3BsYXkgcGlwZSBzdHJ1Y3R1cmUKKyAqLwordm9pZAorZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxh eV9waXBlX2Rpc2FibGUoc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlICpwaXBlKQoreyB9 CitFWFBPUlRfU1lNQk9MKGRybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9kaXNhYmxlKTsK KworLyoqCisgKiBkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfY2hlY2sgLSBkZWZhdWx0 IGltcGxlbWVudGF0aW9uIGZvcgorICoJc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlX2Z1 bmNzLmNoZWNrCisgKiBAcGlwZToJCXRoZSBkaXNwbGF5IHBpcGUgc3RydWN0dXJlCisgKiBAcGxh bmVfc3RhdGU6CXRoZSBuZXcgcGxhbmUgc3RhdGUKKyAqIEBjcnRjX3N0YXRlOgkJdGhlIG5ldyBD UlRDIHN0YXRlCisgKi8KK2ludAorZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX2NoZWNr KHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSAqcGlwZSwKKwkJCQkgICAgIHN0cnVjdCBk cm1fcGxhbmVfc3RhdGUgKnBsYW5lX3N0YXRlLAorCQkJCSAgICAgc3RydWN0IGRybV9jcnRjX3N0 YXRlICpjcnRjX3N0YXRlKQoreworCXJldHVybiAwOworfQorRVhQT1JUX1NZTUJPTChkcm1fZmJj b252X3NpbXBsZV9kaXNwbGF5X3BpcGVfY2hlY2spOworCisvKioKKyAqIGRybV9mYmNvbnZfc2lt cGxlX2Rpc3BsYXlfcGlwZV9tb2RlX3VwZGF0ZSAtIGRlZmF1bHQgaW1wbGVtZW50YXRpb24gZm9y CisgKglzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfZnVuY3MudXBkYXRlCisgKiBAcGlw ZToJCXRoZSBkaXNwbGF5IHBpcGUgc3RydWN0dXJlCisgKiBAb2xkX3BsYW5lX3N0YXRlOgl0aGUg b2xkIHBsYW5lIHN0YXRlCisgKi8KK3ZvaWQKK2RybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlw ZV91cGRhdGUoc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlICpwaXBlLAorCQkJCSAgICAg IHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKm9sZF9wbGFuZV9zdGF0ZSkKK3sgfQorRVhQT1JUX1NZ TUJPTChkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfdXBkYXRlKTsKKworLyoqCisgKiBk cm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfcHJlcGFyZV9mYiAtIGRlZmF1bHQgaW1wbGVt ZW50YXRpb24gZm9yCisgKglzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfZnVuY3MucHJl cGFyZV9mYgorICogQHBpcGU6CQl0aGUgZGlzcGxheSBwaXBlIHN0cnVjdHVyZQorICogQHBsYW5l X3N0YXRlOgl0aGUgbmV3IHBsYW5lIHN0YXRlCisgKiBSZXR1cm5zOgorICoJMCBvbiBzdWNjZXNz LCBvcgorICoJYSBuZWdhdGl2ZSBlcnJvciBjb2RlIG90aGVyd2lzZS4KKyAqCisgKiBUaGUgaW1w bGVtZW50YXRpb24gb2Ygc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlX2Z1bmNzLnByZXBh cmVfZmIKKyAqIG1hcHMgdGhlIGZyYW1lYnVmZmVyJ3MgYnVmZmVyIG9iamVjdCBhbmQgdGhlIGZi ZGV2J3Mgc2NyZWVuIG1lbW9yeSwgaWYKKyAqIG5lY2Vzc2FyeS4gQWZ0ZXIgY29udmVydGluZyB0 aGUgZmJkZXYgZHJpdmVyIHRvIERSTSwgb25seSB0aGUgYnVmZmVyLW9iamVjdAorICogbWFwcGlu ZyBzaG91bGQgcmVtYWluZy4gU2VlIGRybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9jbGVh bnVwX2ZiKCkgZm9yCisgKiB0aGUgY29ycmVzcG9uZGluZyBjbGVhbi11cCBoZWxwZXIuCisgKi8K K2ludAorZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX3ByZXBhcmVfZmIoc3RydWN0IGRy bV9zaW1wbGVfZGlzcGxheV9waXBlICpwaXBlLAorCQkJCQkgIHN0cnVjdCBkcm1fcGxhbmVfc3Rh dGUgKnBsYW5lX3N0YXRlKQoreyB9CitFWFBPUlRfU1lNQk9MKGRybV9mYmNvbnZfc2ltcGxlX2Rp c3BsYXlfcGlwZV9wcmVwYXJlX2ZiKTsKKworLyoqCisgKiBkcm1fZmJjb252X3NpbXBsZV9kaXNw bGF5X3BpcGVfY2xlYW51cF9mYiAtIGRlZmF1bHQgaW1wbGVtZW50YXRpb24gZm9yCisgKglzdHJ1 Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfZnVuY3MuY2xlYW51cF9mYgorICogQHBpcGU6CQl0 aGUgZGlzcGxheSBwaXBlIHN0cnVjdHVyZQorICogQHBsYW5lX3N0YXRlOgl0aGUgb2xkIHBsYW5l IHN0YXRlCisgKgorICogVGhpcyBmdW5jdGlvbiBjbGVhbnMgdXAgdGhlIGZyYW1lYnVmZmVyIHN0 YXRlIGFmdGVyIGEgcGxhbmUgdXBkYXRlLiBTZWUKKyAqIGRybV9mYmNvbnZfc2ltcGxlX2Rpc3Bs YXlfcGlwZV9wcmVwYXJlX2ZiKCkgZm9yIHRoZSBjb3JyZXNwb25kaW5nIHByZXBhcmUKKyAqIGhl bHBlci4KKyAqLwordm9pZAorZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX2NsZWFudXBf ZmIoc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlICpwaXBlLAorCQkJCQkgIHN0cnVjdCBk cm1fcGxhbmVfc3RhdGUgKnBsYW5lX3N0YXRlKQoreyB9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qg ZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfZnVuY3Mgc2ltcGxlX2Rpc3BsYXlfcGlwZV9mdW5jcyA9 IHsKKwkubW9kZV92YWxpZCA9IGRybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9tb2RlX3Zh bGlkLAorCS5tb2RlX2ZpeHVwID0gZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX21vZGVf Zml4dXAsCisJLmVuYWJsZQkgICAgPSBkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfZW5h YmxlLAorCS5kaXNhYmxlICAgID0gZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX2Rpc2Fi bGUsCisJLmNoZWNrCSAgICA9IGRybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9jaGVjaywK KwkudXBkYXRlCSAgICA9IGRybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV91cGRhdGUsCisJ LnByZXBhcmVfZmIgPSBkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfcHJlcGFyZV9mYiwK KwkuY2xlYW51cF9mYiA9IGRybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9jbGVhbnVwX2Zi LAorfTsKKworLyoKKyAqIE1vZGUgY29uZmlnCisgKi8KKworc3RhdGljIGVudW0gZHJtX21vZGVf c3RhdHVzIG1vZGVfY29uZmlnX21vZGVfdmFsaWQoCisJc3RydWN0IGRybV9kZXZpY2UgKmRldiwg Y29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUpCit7CisJcmV0dXJuIE1PREVfT0s7 Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX21vZGVfY29uZmlnX2Z1bmNzIG1vZGVfY29u ZmlnX2Z1bmNzID0geworCS5mYl9jcmVhdGUgPSBkcm1fZ2VtX2ZiX2NyZWF0ZV93aXRoX2RpcnR5 LAorCS5nZXRfZm9ybWF0X2luZm8gPSBOVUxMLAorCS8qIERSTSBwb3J0aW5nIG5vdGVzOiB0aGUg b3V0cHV0X3BvbGxfY2hhbmdlZCBjYWxsYmFjayBpcyB1c2VkIGJ5CisJICogZmIgaGVscGVycyB0 byBpbXBsZW1lbnQgZmJkZXYgZW11bGF0aW9uLiBJZiB5b3UncmUgcG9ydGluZyBhbgorCSAqIGZi ZGV2IGRyaXZlciB0byBEUk0gYW5kIGVuYWJsZSBmYmRldiBlbXVsYXRpb24sIHRoaXMgY2FsbGJh Y2sKKwkgKiB3aWxsIGJlY29tZSB1c2VmdWwuCisJICovCisJLm91dHB1dF9wb2xsX2NoYW5nZWQg PSBkcm1fZmJfaGVscGVyX291dHB1dF9wb2xsX2NoYW5nZWQsCisJLm1vZGVfdmFsaWQgPSBtb2Rl X2NvbmZpZ19tb2RlX3ZhbGlkLAorCS5hdG9taWNfY2hlY2sgPSBkcm1fYXRvbWljX2hlbHBlcl9j aGVjaywKKwkuYXRvbWljX2NvbW1pdCA9IGRybV9hdG9taWNfaGVscGVyX2NvbW1pdCwKKwkuYXRv bWljX3N0YXRlX2FsbG9jID0gTlVMTCwKKwkuYXRvbWljX3N0YXRlX2NsZWFyID0gTlVMTCwKKwku YXRvbWljX3N0YXRlX2ZyZWUgPSBOVUxMCit9OworCisvKioKKyAqIGRybV9mYmNvbnZfbW9kZXNl dF9pbml0IC0gaW5pdGlhbGl6ZXMgYW4gZmJjb252IG1vZGVzZXR0aW5nIHN0cnVjdHVyZQorICog QG1vZGVzZXQ6CQl0aGUgZmJjb252IG1vZGVzZXR0aW5nIHN0cnVjdHVyZSB0byBpbml0aWFsaXpl CisgKiBAZGV2OgkJdGhlIERSTSBkZXZpY2UKKyAqIEBmYl9pbmZvOgkJdGhlIGZiZGV2IGRyaXZl cidzIGZiX2luZm8gc3RydWN0dXJlCisgKiBAbWF4X3dpZHRoOgkJdGhlIG1heGltdW0gZGlzcGxh eSB3aWR0aCB0aGF0IGlzIHN1cHBvcnRlZCBieQorICogICAgICAgICAgICAgICAgICAgICAgdGhl IGRldmljZQorICogQG1heF9oZWlnaHQ6CQl0aGUgbWF4aW11bSBkaXNwbGF5IGhlaWdodCB0aGF0 IGlzIHN1cHBvcnRlZCBieQorICogICAgICAgICAgICAgICAgICAgICAgdGhlIGRldmljZQorICog QHByZWZlcnJlZF9kZXB0aDoJdGhlIGRldmljZSdzIHByZWZlcnJlZCBjb2xvciBkZXB0aAorICog UmV0dXJuczoKKyAqCTAgb24gc3VjY2Vzcywgb3IKKyAqCWEgbmVnYXRpdmUgZXJyb3IgY29kZSBv dGhlcndpc2UKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGluaXRpYWxpemVzIGFuIGluc3RhbmNlIG9m IHN0cnVjdCBkcm1fZmJjb252X21vZGVzZXQuIFRoZQorICogc3VwcGxpZWQgdmFsdWVzIGZvciBt YXhfd2lkdGgsIG1heF9oZWlnaHQsIGFuZCBtYXhfZGVwdGggc2hvdWxkIG1hdGNoIHRoZQorICog ZGV2aWNlcyBjYXBhYmlsaXRpZXMgYW5kIGJlIHN1cHBvcnRlZCBieSB0aGUgZmJkZXYgZHJpdmVy LiBEUk0gaGVscGVycworICogd2lsbCB1c2UgdGhlc2UgdG8gYXV0by1jb25maWd1cmUgYW5kIHZh bGlkYXRlIGRpc3BsYXkgc2V0dGluZ3MuCisgKi8KK2ludCBkcm1fZmJjb252X21vZGVzZXRfaW5p dChzdHJ1Y3QgZHJtX2ZiY29udl9tb2Rlc2V0ICptb2Rlc2V0LAorCQkJICAgIHN0cnVjdCBkcm1f ZGV2aWNlICpkZXYsIHN0cnVjdCBmYl9pbmZvICpmYl9pbmZvLAorCQkJICAgIHVuc2lnbmVkIGlu dCBtYXhfd2lkdGgsIHVuc2lnbmVkIGludCBtYXhfaGVpZ2h0LAorCQkJICAgIHVuc2lnbmVkIGlu dCBwcmVmZXJyZWRfZGVwdGgpCit7CisJc3RydWN0IGRybV9tb2RlX2NvbmZpZyAqbW9kZV9jb25m aWcgPSAmZGV2LT5tb2RlX2NvbmZpZzsKKworCW1vZGVzZXQtPmRldiA9IGRldjsKKwltb2Rlc2V0 LT5mYl9pbmZvID0gZmJfaW5mbzsKKworCWRybV9tb2RlX2NvbmZpZ19pbml0KGRldik7CisKKwlt b2RlX2NvbmZpZy0+bWF4X3dpZHRoID0gKGludCltYXhfd2lkdGg7CisJbW9kZV9jb25maWctPm1h eF9oZWlnaHQgPSAoaW50KW1heF9oZWlnaHQ7CisJbW9kZV9jb25maWctPmZiX2Jhc2UgPSBmYl9p bmZvLT5maXguc21lbV9zdGFydDsKKwltb2RlX2NvbmZpZy0+cHJlZmVycmVkX2RlcHRoID0gcHJl ZmVycmVkX2RlcHRoOworCW1vZGVfY29uZmlnLT5wcmVmZXJfc2hhZG93X2ZiZGV2ID0gdHJ1ZTsK Kwltb2RlX2NvbmZpZy0+ZnVuY3MgPSAmbW9kZV9jb25maWdfZnVuY3M7CisKKwlyZXR1cm4gMDsK K30KK0VYUE9SVF9TWU1CT0woZHJtX2ZiY29udl9tb2Rlc2V0X2luaXQpOworCisvKioKKyAqIGRy bV9mYmNvbnZfbW9kZXNldF9jbGVhbnVwIC0gQ2xlYW5zIHVwIGFuIGZiY29udiBtb2Rlc2V0dGlu ZyBzdHJ1Y3R1cmUKKyAqIEBtb2Rlc2V0Ogl0aGUgZmJjb252IG1vZGVzZXR0aW5nIHN0cnVjdHVy ZSB0byBjbGVhbiB1cAorICovCit2b2lkIGRybV9mYmNvbnZfbW9kZXNldF9jbGVhbnVwKHN0cnVj dCBkcm1fZmJjb252X21vZGVzZXQgKm1vZGVzZXQpCit7CisJZHJtX21vZGVfY29uZmlnX2NsZWFu dXAobW9kZXNldC0+ZGV2KTsKK30KK0VYUE9SVF9TWU1CT0woZHJtX2ZiY29udl9tb2Rlc2V0X2Ns ZWFudXApOworCisvKioKKyAqIGRybV9mYmNvbnZfbW9kZXNldF9zZXR1cF9waXBlIC0gc2V0cyB1 cCB0aGUgZGlzcGxheSBwaXBlbGluZSBmb3IgZmJjb252CisgKiBAbW9kZXNldDoJCWFuIGZiY29u diBtb2Rlc2V0dGluZyBzdHJ1Y3R1cmUKKyAqIEBmdW5jczoJCWFuIGltcGxlbWVudGF0aW9uIG9m CisgKiAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVf ZnVuY3MsIG9yIE5VTEwKKyAqIEBmb3JtYXRzOgkJdGhlIGRldmljZSdzIHN1cHBvcnRlZCBkaXNw bGF5IGZvcm1hdHMKKyAqIEBmb3JtYXRfY291bnQ6CXRoZSBudW1iZXIgb2YgZW50cmllcyBpbiBA Zm9ybWF0cworICogQGZvcm1hdF9tb2RpZmllcnM6CURSTSBmb3JtYXQgbW9kaWZpZXJzLCBvciBO VUxMCisgKiBAY29ubmVjdG9yOgkJdGhlIERSTSBjb25uZWN0b3IsIG9yIE5VTEwKKyAqIFJldHVy bnM6CisgKgkwIG9uIHN1Y2Nlc3MsIG9yCisgKglhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb3RoZXJ3 aXNlCisgKgorICogVGhpcyBmdW5jdGlvbiBzZXRzIHVwIHRoZSBkaXNwbGF5IHBpcGVsaW5lIGZv ciBhbiBpbml0aWFsaXplZCBpbnN0YW5jZSBvZgorICogc3RydWN0IGRybV9mYmNvbnZfbW9kZXNl dC4gRm9yIG1heGltdW0gY29tcGF0aWJpbGl0eSB3aXRoIHVzZXJzcGFjZSwgdGhlCisgKiBwcm92 aWRlZCBsaXN0IG9mIGZvcm1hdHMgc2hvdWxkIGNvbnRhaW4gYXQgbGVhc3QgRFJNX0ZPUk1BVF9Y UkdCODg4OCBhbmQKKyAqIERSTV9GT1JNQVRfUkdCNTY1LiBUaGUgbmVjZXNzYXJ5IGNvbnZlcnNp b24gdG8gdGhlIGhhcmR3YXJlJ3MgYWN0dWFsCisgKiBjb25maWd1cmF0aW9uIGNhbiBiZSBwZXJm b3JtZWQgYnkgZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX3VwZGF0ZSgpLgorICoKKyAq IFRoZSB2YWx1ZXMgZm9yIEBmdW5jcywgQGZvcm1hdF9tb2RpZmllcnMsIGFuZCBAY29ubmVjdG9y IHNob3VsZCBiZSBOVUxMCisgKiBieSBkZWZhdWx0LiBFeHBsaWNpdGx5IHNldHRpbmdzIHRoZXNl IHBhcmFtZXRlcnMgd2lsbCBvbmx5IGJlIGhlbHBmdWwgZm9yCisgKiByZWZhY3RvcmluZyBhbiBm YmRldiBkcml2ZXIgaW50byBhIERSTSBkcml2ZXIuCisgKi8KK2ludAorZHJtX2ZiY29udl9tb2Rl c2V0X3NldHVwX3BpcGUoc3RydWN0IGRybV9mYmNvbnZfbW9kZXNldCAqbW9kZXNldCwKKwkJCSAg ICAgIGNvbnN0IHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZV9mdW5jcyAqZnVuY3MsCisJ CQkgICAgICBjb25zdCB1aW50MzJfdCAqZm9ybWF0cywKKwkJCSAgICAgIHVuc2lnbmVkIGludCBm b3JtYXRfY291bnQsCisJCQkgICAgICBjb25zdCB1aW50NjRfdCAqZm9ybWF0X21vZGlmaWVycywK KwkJCSAgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpCit7CisJaW50IHJldDsK KworCS8qIERSTSBwb3J0aW5nIG5vdGU6IE5vdyBsZXQncyBlbmFibGUgdGhlIGRpc3BsYXkgcGlw ZWxpbmUuIElmCisJICogeW91J3JlIHBvcnRpbmcgYSBmcmFtZWJ1ZmZlciBkcml2ZXIgdG8gRFJN LCB5b3UgbWF5IHdhbnQgdG8KKwkgKiBzZXQgdGhlIGNvcnJlY3QgY29ubmVjdG9yIHR5cGUgb3Ig cmVwbGFjZSB0aGUgc2ltcGxlIGRpc3BsYXkKKwkgKiBwaXBlbGluZSB3aXRoIHNvbWV0aGluZyBt b3JlIHNvcGhpc3RpY2F0ZWQuCisJICovCisKKwlpZiAoIWZ1bmNzKQorCQlmdW5jcyA9ICZzaW1w bGVfZGlzcGxheV9waXBlX2Z1bmNzOworCisJaWYgKCFjb25uZWN0b3IpIHsKKwkJY29ubmVjdG9y ID0gJm1vZGVzZXQtPmNvbm5lY3RvcjsKKworCQlyZXQgPSBkcm1fY29ubmVjdG9yX2luaXQobW9k ZXNldC0+ZGV2LCBjb25uZWN0b3IsCisJCQkJCSAmY29ubmVjdG9yX2Z1bmNzLAorCQkJCQkgRFJN X01PREVfQ09OTkVDVE9SX1Vua25vd24pOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwkJ ZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfYWRkKGNvbm5lY3RvciwgJmNvbm5lY3Rvcl9oZWxwZXJfZnVu Y3MpOworCisJCXJldCA9IGRybV9jb25uZWN0b3JfcmVnaXN0ZXIoY29ubmVjdG9yKTsKKwkJaWYg KHJldCA8IDApCisJCQlyZXR1cm4gcmV0OworCisJfQorCisJcmV0ID0gZHJtX3NpbXBsZV9kaXNw bGF5X3BpcGVfaW5pdChtb2Rlc2V0LT5kZXYsICZtb2Rlc2V0LT5waXBlLAorCQkJCQkgICBmdW5j cywgZm9ybWF0cywgZm9ybWF0X2NvdW50LAorCQkJCQkgICBmb3JtYXRfbW9kaWZpZXJzLCBjb25u ZWN0b3IpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwkvKiBGaW5hbCBzdGVwOiByZXNl dHRpbmcgdGhlIGRldmljZSdzIG1vZGUgY29uZmlnIGNyZWF0ZXMKKwkgKiBzdGF0ZSBmb3IgYWxs IG9iamVjdHMgaW4gdGhlIG1vZGUtc2V0dGluZyBwaXBlbGluZS4KKwkgKi8KKwlkcm1fbW9kZV9j b25maWdfcmVzZXQobW9kZXNldC0+ZGV2KTsKKworCXJldHVybiAwOworfQorRVhQT1JUX1NZTUJP TChkcm1fZmJjb252X21vZGVzZXRfc2V0dXBfcGlwZSk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2Ry bS9kcm1fZmJjb252X2hlbHBlci5oIGIvaW5jbHVkZS9kcm0vZHJtX2ZiY29udl9oZWxwZXIuaApp bmRleCBjYmIxMzIyOGM3NmMuLjc5NzE2YWY2ODdjMSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0v ZHJtX2ZiY29udl9oZWxwZXIuaAorKysgYi9pbmNsdWRlL2RybS9kcm1fZmJjb252X2hlbHBlci5o CkBAIC0zLDcgKzMsMTEgQEAKICNpZm5kZWYgRFJNX0ZCQ09OVl9IRUxQRVJfSAogI2RlZmluZSBE Uk1fRkJDT05WX0hFTFBFUl9ICiAKKyNpbmNsdWRlIDxkcm0vZHJtX2Nvbm5lY3Rvci5oPgorI2lu Y2x1ZGUgPGRybS9kcm1fY3J0Yy5oPgorI2luY2x1ZGUgPGRybS9kcm1fZW5jb2Rlci5oPgogI2lu Y2x1ZGUgPGRybS9kcm1fZm91cmNjLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9zaW1wbGVfa21zX2hl bHBlci5oPgogCiBzdHJ1Y3QgZHJtX2RldmljZTsKIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlOwpA QCAtNTEsNCArNTUsNzggQEAgdm9pZCBkcm1fZmJjb252X3VwZGF0ZV9mYl92YXJfc2NyZWVuaW5m b19mcm9tX21vZGUoCiB2b2lkIGRybV9mYmNvbnZfaW5pdF9mYl92YXJfc2NyZWVuaW5mb19mcm9t X21vZGUoCiAJc3RydWN0IGZiX3Zhcl9zY3JlZW5pbmZvICp2YXIsIGNvbnN0IHN0cnVjdCBkcm1f ZGlzcGxheV9tb2RlICptb2RlKTsKIAorLyoKKyAqIFNpbXBsZSBkaXNwbGF5IHBpcGUKKyAqLwor CitlbnVtIGRybV9tb2RlX3N0YXR1cworZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX21v ZGVfdmFsaWQoc3RydWN0IGRybV9jcnRjICpjcnRjLAorCQkJCQkgIGNvbnN0IHN0cnVjdCBkcm1f ZGlzcGxheV9tb2RlICptb2RlKTsKKworYm9vbCBkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3Bp cGVfbW9kZV9maXh1cCgKKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMsIGNvbnN0IHN0cnVjdCBkcm1f ZGlzcGxheV9tb2RlICptb2RlLAorCXN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICphZGp1c3RlZF9t b2RlKTsKKwordm9pZAorZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX2VuYWJsZShzdHJ1 Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCisJCQkJICAgICAgc3RydWN0IGRybV9j cnRjX3N0YXRlICpjcnRjX3N0YXRlLAorCQkJCSAgICAgIHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUg KnBsYW5lX3N0YXRlKTsKKwordm9pZAorZHJtX2ZiY29udl9zaW1wbGVfZGlzcGxheV9waXBlX2Rp c2FibGUoc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlICpwaXBlKTsKKworaW50Citkcm1f ZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfY2hlY2soc3RydWN0IGRybV9zaW1wbGVfZGlzcGxh eV9waXBlICpwaXBlLAorCQkJCSAgICAgc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqcGxhbmVfc3Rh dGUsCisJCQkJICAgICBzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUpOworCit2b2lk Citkcm1fZmJjb252X3NpbXBsZV9kaXNwbGF5X3BpcGVfdXBkYXRlKHN0cnVjdCBkcm1fc2ltcGxl X2Rpc3BsYXlfcGlwZSAqcGlwZSwKKwkJCQkgICAgICBzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpv bGRfcGxhbmVfc3RhdGUpOworCitpbnQKK2RybV9mYmNvbnZfc2ltcGxlX2Rpc3BsYXlfcGlwZV9w cmVwYXJlX2ZiKHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSAqcGlwZSwKKwkJCQkJICBz dHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSk7CisKK3ZvaWQKK2RybV9mYmNvbnZf c2ltcGxlX2Rpc3BsYXlfcGlwZV9jbGVhbnVwX2ZiKHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlf cGlwZSAqcGlwZSwKKwkJCQkJICBzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSk7 CisKKy8qCisgKiBNb2Rlc2V0IGhlbHBlcnMKKyAqLworCisvKioKKyAqIHN0cnVjdCBkcm1fZmJj b252X21vZGVzZXQgLSBjb250YWlucyBzdGF0ZSBmb3IgZmJjb252IG1vZGVzZXR0aW5nCisgKiBA Y29ubmVjdG9yOgl0aGUgRFJNIGNvbm5lY3RvcgorICogQHBpcGU6CXRoZSBtb2Rlc2V0dGluZyBw aXBlbGluZQorICogQGRldjoJdGhlIERSTSBkZXZpY2UKKyAqIEBmYl9pbmZvOgl0aGUgZmJkZXYg ZHJpdmVyJ3MgZmJfaW5mbyBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IGRybV9mYmNvbnZfbW9kZXNl dCB7CisJc3RydWN0IGRybV9jb25uZWN0b3IgY29ubmVjdG9yOworCXN0cnVjdCBkcm1fc2ltcGxl X2Rpc3BsYXlfcGlwZSBwaXBlOworCisJc3RydWN0IGRybV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3Qg ZmJfaW5mbyAqZmJfaW5mbzsKK307CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGRybV9mYmNvbnZf bW9kZXNldCAqZHJtX2ZiY29udl9tb2Rlc2V0X29mX3BpcGUoCisJc3RydWN0IGRybV9zaW1wbGVf ZGlzcGxheV9waXBlICpwaXBlKQoreworCXJldHVybiBjb250YWluZXJfb2YocGlwZSwgc3RydWN0 IGRybV9mYmNvbnZfbW9kZXNldCwgcGlwZSk7Cit9CisKK2ludCBkcm1fZmJjb252X21vZGVzZXRf aW5pdChzdHJ1Y3QgZHJtX2ZiY29udl9tb2Rlc2V0ICptb2Rlc2V0LAorCQkJICAgIHN0cnVjdCBk cm1fZGV2aWNlICpkZXYsIHN0cnVjdCBmYl9pbmZvICpmYl9pbmZvLAorCQkJICAgIHVuc2lnbmVk IGludCBtYXhfd2lkdGgsIHVuc2lnbmVkIGludCBtYXhfaGVpZ2h0LAorCQkJICAgIHVuc2lnbmVk IGludCBwcmVmZXJyZWRfZGVwdGgpOwordm9pZCBkcm1fZmJjb252X21vZGVzZXRfY2xlYW51cChz dHJ1Y3QgZHJtX2ZiY29udl9tb2Rlc2V0ICptb2Rlc2V0KTsKKworaW50IGRybV9mYmNvbnZfbW9k ZXNldF9zZXR1cF9waXBlKAorCXN0cnVjdCBkcm1fZmJjb252X21vZGVzZXQgKm1vZGVzZXQsCisJ Y29uc3Qgc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlX2Z1bmNzICpmdW5jcywKKwljb25z dCB1aW50MzJfdCAqZm9ybWF0cywgdW5zaWduZWQgaW50IGZvcm1hdF9jb3VudCwKKwljb25zdCB1 aW50NjRfdCAqZm9ybWF0X21vZGlmaWVycywgc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3Rv cik7CisKICNlbmRpZgotLSAKMi4yMy4wCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0 aW5mby9kcmktZGV2ZWw=