From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1378DC43387 for ; Fri, 18 Jan 2019 12:21:29 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id CA08420652 for ; Fri, 18 Jan 2019 12:21:28 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727885AbfARMV1 (ORCPT ); Fri, 18 Jan 2019 07:21:27 -0500 Received: from mx1.redhat.com ([209.132.183.28]:45622 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727592AbfARMUa (ORCPT ); Fri, 18 Jan 2019 07:20:30 -0500 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 90F18C0528BD; Fri, 18 Jan 2019 12:20:28 +0000 (UTC) Received: from sirius.home.kraxel.org (ovpn-116-38.ams2.redhat.com [10.36.116.38]) by smtp.corp.redhat.com (Postfix) with ESMTP id 62CE960BE8; Fri, 18 Jan 2019 12:20:27 +0000 (UTC) Received: by sirius.home.kraxel.org (Postfix, from userid 1000) id 20E871FCD6; Fri, 18 Jan 2019 13:20:23 +0100 (CET) From: Gerd Hoffmann To: dri-devel@lists.freedesktop.org Cc: Gerd Hoffmann , Dave Airlie , David Airlie , Daniel Vetter , linux-kernel@vger.kernel.org (open list), virtualization@lists.linux-foundation.org (open list:DRM DRIVER FOR QXL VIRTUAL GPU), spice-devel@lists.freedesktop.org (open list:DRM DRIVER FOR QXL VIRTUAL GPU) Subject: [PATCH v3 18/23] drm/qxl: remove dead qxl fbdev emulation code Date: Fri, 18 Jan 2019 13:20:15 +0100 Message-Id: <20190118122020.27596-19-kraxel@redhat.com> In-Reply-To: <20190118122020.27596-1-kraxel@redhat.com> References: <20190118122020.27596-1-kraxel@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.31]); Fri, 18 Jan 2019 12:20:28 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Lovely diffstat, thanks to the new generic fbdev emulation. drm/qxl/Makefile | 2 drm/qxl/qxl_draw.c | 232 ---------------------------------------- drm/qxl/qxl_drv.h | 21 --- drm/qxl/qxl_fb.c | 300 ----------------------------------------------------- Signed-off-by: Gerd Hoffmann --- drivers/gpu/drm/qxl/qxl_drv.h | 21 --- drivers/gpu/drm/qxl/qxl_draw.c | 232 ------------------------------- drivers/gpu/drm/qxl/qxl_fb.c | 300 ----------------------------------------- drivers/gpu/drm/qxl/Makefile | 2 +- 4 files changed, 1 insertion(+), 554 deletions(-) delete mode 100644 drivers/gpu/drm/qxl/qxl_fb.c diff --git a/drivers/gpu/drm/qxl/qxl_drv.h b/drivers/gpu/drm/qxl/qxl_drv.h index 8c3af1cdbe..4a0331b3ff 100644 --- a/drivers/gpu/drm/qxl/qxl_drv.h +++ b/drivers/gpu/drm/qxl/qxl_drv.h @@ -220,8 +220,6 @@ struct qxl_device { struct qxl_mman mman; struct qxl_gem gem; - struct drm_fb_helper fb_helper; - void *ram_physical; struct qxl_ring *release_ring; @@ -322,12 +320,6 @@ qxl_bo_physical_address(struct qxl_device *qdev, struct qxl_bo *bo, return slot->high_bits | (bo->tbo.offset - slot->gpu_offset + offset); } -/* qxl_fb.c */ -#define QXLFB_CONN_LIMIT 1 - -int qxl_fbdev_init(struct qxl_device *qdev); -void qxl_fbdev_fini(struct qxl_device *qdev); - /* qxl_display.c */ void qxl_display_read_client_monitors_config(struct qxl_device *qdev); int qxl_create_monitors_object(struct qxl_device *qdev); @@ -432,9 +424,6 @@ int qxl_alloc_bo_reserved(struct qxl_device *qdev, struct qxl_bo **_bo); /* qxl drawing commands */ -void qxl_draw_opaque_fb(const struct qxl_fb_image *qxl_fb_image, - int stride /* filled in if 0 */); - void qxl_draw_dirty_fb(struct qxl_device *qdev, struct drm_framebuffer *fb, struct qxl_bo *bo, @@ -443,13 +432,6 @@ void qxl_draw_dirty_fb(struct qxl_device *qdev, unsigned int num_clips, int inc, uint32_t dumb_shadow_offset); -void qxl_draw_fill(struct qxl_draw_fill *qxl_draw_fill_rec); - -void qxl_draw_copyarea(struct qxl_device *qdev, - u32 width, u32 height, - u32 sx, u32 sy, - u32 dx, u32 dy); - void qxl_release_free(struct qxl_device *qdev, struct qxl_release *release); @@ -481,9 +463,6 @@ int qxl_gem_prime_mmap(struct drm_gem_object *obj, int qxl_irq_init(struct qxl_device *qdev); irqreturn_t qxl_irq_handler(int irq, void *arg); -/* qxl_fb.c */ -bool qxl_fbdev_qobj_is_fb(struct qxl_device *qdev, struct qxl_bo *qobj); - int qxl_debugfs_add_files(struct qxl_device *qdev, struct drm_info_list *files, unsigned int nfiles); diff --git a/drivers/gpu/drm/qxl/qxl_draw.c b/drivers/gpu/drm/qxl/qxl_draw.c index 5313ad21c1..97c3f1a95a 100644 --- a/drivers/gpu/drm/qxl/qxl_draw.c +++ b/drivers/gpu/drm/qxl/qxl_draw.c @@ -109,152 +109,6 @@ make_drawable(struct qxl_device *qdev, int surface, uint8_t type, return 0; } -static int alloc_palette_object(struct qxl_device *qdev, - struct qxl_release *release, - struct qxl_bo **palette_bo) -{ - return qxl_alloc_bo_reserved(qdev, release, - sizeof(struct qxl_palette) + sizeof(uint32_t) * 2, - palette_bo); -} - -static int qxl_palette_create_1bit(struct qxl_bo *palette_bo, - struct qxl_release *release, - const struct qxl_fb_image *qxl_fb_image) -{ - const struct fb_image *fb_image = &qxl_fb_image->fb_image; - uint32_t visual = qxl_fb_image->visual; - const uint32_t *pseudo_palette = qxl_fb_image->pseudo_palette; - struct qxl_palette *pal; - int ret; - uint32_t fgcolor, bgcolor; - static uint64_t unique; /* we make no attempt to actually set this - * correctly globaly, since that would require - * tracking all of our palettes. */ - ret = qxl_bo_kmap(palette_bo, (void **)&pal); - if (ret) - return ret; - pal->num_ents = 2; - pal->unique = unique++; - if (visual == FB_VISUAL_TRUECOLOR || visual == FB_VISUAL_DIRECTCOLOR) { - /* NB: this is the only used branch currently. */ - fgcolor = pseudo_palette[fb_image->fg_color]; - bgcolor = pseudo_palette[fb_image->bg_color]; - } else { - fgcolor = fb_image->fg_color; - bgcolor = fb_image->bg_color; - } - pal->ents[0] = bgcolor; - pal->ents[1] = fgcolor; - qxl_bo_kunmap(palette_bo); - return 0; -} - -void qxl_draw_opaque_fb(const struct qxl_fb_image *qxl_fb_image, - int stride /* filled in if 0 */) -{ - struct qxl_device *qdev = qxl_fb_image->qdev; - struct qxl_drawable *drawable; - struct qxl_rect rect; - const struct fb_image *fb_image = &qxl_fb_image->fb_image; - int x = fb_image->dx; - int y = fb_image->dy; - int width = fb_image->width; - int height = fb_image->height; - const char *src = fb_image->data; - int depth = fb_image->depth; - struct qxl_release *release; - struct qxl_image *image; - int ret; - struct qxl_drm_image *dimage; - struct qxl_bo *palette_bo = NULL; - - if (stride == 0) - stride = depth * width / 8; - - ret = alloc_drawable(qdev, &release); - if (ret) - return; - - ret = qxl_image_alloc_objects(qdev, release, - &dimage, - height, stride); - if (ret) - goto out_free_drawable; - - if (depth == 1) { - ret = alloc_palette_object(qdev, release, &palette_bo); - if (ret) - goto out_free_image; - } - - /* do a reservation run over all the objects we just allocated */ - ret = qxl_release_reserve_list(release, true); - if (ret) - goto out_free_palette; - - rect.left = x; - rect.right = x + width; - rect.top = y; - rect.bottom = y + height; - - ret = make_drawable(qdev, 0, QXL_DRAW_COPY, &rect, release); - if (ret) { - qxl_release_backoff_reserve_list(release); - goto out_free_palette; - } - - ret = qxl_image_init(qdev, release, dimage, - (const uint8_t *)src, 0, 0, - width, height, depth, stride); - if (ret) { - qxl_release_backoff_reserve_list(release); - qxl_release_free(qdev, release); - return; - } - - if (depth == 1) { - void *ptr; - - ret = qxl_palette_create_1bit(palette_bo, release, qxl_fb_image); - - ptr = qxl_bo_kmap_atomic_page(qdev, dimage->bo, 0); - image = ptr; - image->u.bitmap.palette = - qxl_bo_physical_address(qdev, palette_bo, 0); - qxl_bo_kunmap_atomic_page(qdev, dimage->bo, ptr); - } - - drawable = (struct qxl_drawable *)qxl_release_map(qdev, release); - - drawable->u.copy.src_area.top = 0; - drawable->u.copy.src_area.bottom = height; - drawable->u.copy.src_area.left = 0; - drawable->u.copy.src_area.right = width; - - drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT; - drawable->u.copy.scale_mode = 0; - drawable->u.copy.mask.flags = 0; - drawable->u.copy.mask.pos.x = 0; - drawable->u.copy.mask.pos.y = 0; - drawable->u.copy.mask.bitmap = 0; - - drawable->u.copy.src_bitmap = - qxl_bo_physical_address(qdev, dimage->bo, 0); - qxl_release_unmap(qdev, release, &drawable->release_info); - - qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false); - qxl_release_fence_buffer_objects(release); - -out_free_palette: - qxl_bo_unref(&palette_bo); -out_free_image: - qxl_image_free_objects(qdev, dimage); -out_free_drawable: - if (ret) - free_drawable(qdev, release); -} - /* push a draw command using the given clipping rectangles as * the sources from the shadow framebuffer. * @@ -402,89 +256,3 @@ void qxl_draw_dirty_fb(struct qxl_device *qdev, free_drawable(qdev, release); } - -void qxl_draw_copyarea(struct qxl_device *qdev, - u32 width, u32 height, - u32 sx, u32 sy, - u32 dx, u32 dy) -{ - struct qxl_drawable *drawable; - struct qxl_rect rect; - struct qxl_release *release; - int ret; - - ret = alloc_drawable(qdev, &release); - if (ret) - return; - - /* do a reservation run over all the objects we just allocated */ - ret = qxl_release_reserve_list(release, true); - if (ret) - goto out_free_release; - - rect.left = dx; - rect.top = dy; - rect.right = dx + width; - rect.bottom = dy + height; - ret = make_drawable(qdev, 0, QXL_COPY_BITS, &rect, release); - if (ret) { - qxl_release_backoff_reserve_list(release); - goto out_free_release; - } - - drawable = (struct qxl_drawable *)qxl_release_map(qdev, release); - drawable->u.copy_bits.src_pos.x = sx; - drawable->u.copy_bits.src_pos.y = sy; - qxl_release_unmap(qdev, release, &drawable->release_info); - - qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false); - qxl_release_fence_buffer_objects(release); - -out_free_release: - if (ret) - free_drawable(qdev, release); -} - -void qxl_draw_fill(struct qxl_draw_fill *qxl_draw_fill_rec) -{ - struct qxl_device *qdev = qxl_draw_fill_rec->qdev; - struct qxl_rect rect = qxl_draw_fill_rec->rect; - uint32_t color = qxl_draw_fill_rec->color; - uint16_t rop = qxl_draw_fill_rec->rop; - struct qxl_drawable *drawable; - struct qxl_release *release; - int ret; - - ret = alloc_drawable(qdev, &release); - if (ret) - return; - - /* do a reservation run over all the objects we just allocated */ - ret = qxl_release_reserve_list(release, true); - if (ret) - goto out_free_release; - - ret = make_drawable(qdev, 0, QXL_DRAW_FILL, &rect, release); - if (ret) { - qxl_release_backoff_reserve_list(release); - goto out_free_release; - } - - drawable = (struct qxl_drawable *)qxl_release_map(qdev, release); - drawable->u.fill.brush.type = SPICE_BRUSH_TYPE_SOLID; - drawable->u.fill.brush.u.color = color; - drawable->u.fill.rop_descriptor = rop; - drawable->u.fill.mask.flags = 0; - drawable->u.fill.mask.pos.x = 0; - drawable->u.fill.mask.pos.y = 0; - drawable->u.fill.mask.bitmap = 0; - - qxl_release_unmap(qdev, release, &drawable->release_info); - - qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false); - qxl_release_fence_buffer_objects(release); - -out_free_release: - if (ret) - free_drawable(qdev, release); -} diff --git a/drivers/gpu/drm/qxl/qxl_fb.c b/drivers/gpu/drm/qxl/qxl_fb.c deleted file mode 100644 index a819d24225..0000000000 --- a/drivers/gpu/drm/qxl/qxl_fb.c +++ /dev/null @@ -1,300 +0,0 @@ -/* - * Copyright © 2013 Red Hat - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice (including the next - * paragraph) shall be included in all copies or substantial portions of the - * Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER - * DEALINGS IN THE SOFTWARE. - * - * Authors: - * David Airlie - */ -#include - -#include -#include -#include -#include -#include -#include - -#include "qxl_drv.h" - -#include "qxl_object.h" - -static void qxl_fb_image_init(struct qxl_fb_image *qxl_fb_image, - struct qxl_device *qdev, struct fb_info *info, - const struct fb_image *image) -{ - qxl_fb_image->qdev = qdev; - if (info) { - qxl_fb_image->visual = info->fix.visual; - if (qxl_fb_image->visual == FB_VISUAL_TRUECOLOR || - qxl_fb_image->visual == FB_VISUAL_DIRECTCOLOR) - memcpy(&qxl_fb_image->pseudo_palette, - info->pseudo_palette, - sizeof(qxl_fb_image->pseudo_palette)); - } else { - /* fallback */ - if (image->depth == 1) - qxl_fb_image->visual = FB_VISUAL_MONO10; - else - qxl_fb_image->visual = FB_VISUAL_DIRECTCOLOR; - } - if (image) { - memcpy(&qxl_fb_image->fb_image, image, - sizeof(qxl_fb_image->fb_image)); - } -} - -static struct fb_ops qxlfb_ops = { - .owner = THIS_MODULE, - DRM_FB_HELPER_DEFAULT_OPS, - .fb_fillrect = drm_fb_helper_sys_fillrect, - .fb_copyarea = drm_fb_helper_sys_copyarea, - .fb_imageblit = drm_fb_helper_sys_imageblit, -}; - -static void qxlfb_destroy_pinned_object(struct drm_gem_object *gobj) -{ - struct qxl_bo *qbo = gem_to_qxl_bo(gobj); - - qxl_bo_kunmap(qbo); - qxl_bo_unpin(qbo); - - drm_gem_object_put_unlocked(gobj); -} - -static int qxlfb_create_pinned_object(struct qxl_device *qdev, - const struct drm_mode_fb_cmd2 *mode_cmd, - struct drm_gem_object **gobj_p) -{ - struct drm_gem_object *gobj = NULL; - struct qxl_bo *qbo = NULL; - int ret; - int aligned_size, size; - int height = mode_cmd->height; - - size = mode_cmd->pitches[0] * height; - aligned_size = ALIGN(size, PAGE_SIZE); - /* TODO: unallocate and reallocate surface0 for real. Hack to just - * have a large enough surface0 for 1024x768 Xorg 32bpp mode */ - ret = qxl_gem_object_create(qdev, aligned_size, 0, - QXL_GEM_DOMAIN_SURFACE, - false, /* is discardable */ - false, /* is kernel (false means device) */ - NULL, - &gobj); - if (ret) { - pr_err("failed to allocate framebuffer (%d)\n", - aligned_size); - return -ENOMEM; - } - qbo = gem_to_qxl_bo(gobj); - - qbo->surf.width = mode_cmd->width; - qbo->surf.height = mode_cmd->height; - qbo->surf.stride = mode_cmd->pitches[0]; - qbo->surf.format = SPICE_SURFACE_FMT_32_xRGB; - - ret = qxl_bo_pin(qbo); - if (ret) { - goto out_unref; - } - ret = qxl_bo_kmap(qbo, NULL); - - if (ret) - goto out_unref; - - *gobj_p = gobj; - return 0; -out_unref: - qxlfb_destroy_pinned_object(gobj); - *gobj_p = NULL; - return ret; -} - -/* - * FIXME - * It should not be necessary to have a special dirty() callback for fbdev. - */ -static int qxlfb_framebuffer_dirty(struct drm_framebuffer *fb, - struct drm_file *file_priv, - unsigned int flags, unsigned int color, - struct drm_clip_rect *clips, - unsigned int num_clips) -{ - struct qxl_device *qdev = fb->dev->dev_private; - struct fb_info *info = qdev->fb_helper.fbdev; - struct qxl_fb_image qxl_fb_image; - struct fb_image *image = &qxl_fb_image.fb_image; - - /* TODO: hard coding 32 bpp */ - int stride = fb->pitches[0]; - - /* - * we are using a shadow draw buffer, at qdev->surface0_shadow - */ - image->dx = clips->x1; - image->dy = clips->y1; - image->width = clips->x2 - clips->x1; - image->height = clips->y2 - clips->y1; - image->fg_color = 0xffffffff; /* unused, just to avoid uninitialized - warnings */ - image->bg_color = 0; - image->depth = 32; /* TODO: take from somewhere? */ - image->cmap.start = 0; - image->cmap.len = 0; - image->cmap.red = NULL; - image->cmap.green = NULL; - image->cmap.blue = NULL; - image->cmap.transp = NULL; - image->data = info->screen_base + (clips->x1 * 4) + (stride * clips->y1); - - qxl_fb_image_init(&qxl_fb_image, qdev, info, NULL); - qxl_draw_opaque_fb(&qxl_fb_image, stride); - - return 0; -} - -static const struct drm_framebuffer_funcs qxlfb_fb_funcs = { - .destroy = drm_gem_fb_destroy, - .create_handle = drm_gem_fb_create_handle, - .dirty = qxlfb_framebuffer_dirty, -}; - -static int qxlfb_create(struct drm_fb_helper *helper, - struct drm_fb_helper_surface_size *sizes) -{ - struct qxl_device *qdev = - container_of(helper, struct qxl_device, fb_helper); - struct fb_info *info; - struct drm_framebuffer *fb = NULL; - struct drm_mode_fb_cmd2 mode_cmd; - struct drm_gem_object *gobj = NULL; - struct qxl_bo *qbo = NULL; - int ret; - int bpp = sizes->surface_bpp; - int depth = sizes->surface_depth; - void *shadow; - - mode_cmd.width = sizes->surface_width; - mode_cmd.height = sizes->surface_height; - - mode_cmd.pitches[0] = ALIGN(mode_cmd.width * ((bpp + 1) / 8), 64); - mode_cmd.pixel_format = drm_mode_legacy_fb_format(bpp, depth); - - ret = qxlfb_create_pinned_object(qdev, &mode_cmd, &gobj); - if (ret < 0) - return ret; - - qbo = gem_to_qxl_bo(gobj); - DRM_DEBUG_DRIVER("%dx%d %d\n", mode_cmd.width, - mode_cmd.height, mode_cmd.pitches[0]); - - shadow = vmalloc(array_size(mode_cmd.pitches[0], mode_cmd.height)); - /* TODO: what's the usual response to memory allocation errors? */ - BUG_ON(!shadow); - DRM_DEBUG_DRIVER("surface0 at gpu offset %lld, mmap_offset %lld (virt %p, shadow %p)\n", - qxl_bo_gpu_offset(qbo), qxl_bo_mmap_offset(qbo), - qbo->kptr, shadow); - - info = drm_fb_helper_alloc_fbi(helper); - if (IS_ERR(info)) { - ret = PTR_ERR(info); - goto out_unref; - } - - info->par = helper; - - fb = drm_gem_fbdev_fb_create(&qdev->ddev, sizes, 64, gobj, - &qxlfb_fb_funcs); - if (IS_ERR(fb)) { - DRM_ERROR("Failed to create framebuffer: %ld\n", PTR_ERR(fb)); - ret = PTR_ERR(fb); - goto out_unref; - } - - /* setup helper with fb data */ - qdev->fb_helper.fb = fb; - - strcpy(info->fix.id, "qxldrmfb"); - - drm_fb_helper_fill_fix(info, fb->pitches[0], fb->format->depth); - - info->fbops = &qxlfb_ops; - - /* - * TODO: using gobj->size in various places in this function. Not sure - * what the difference between the different sizes is. - */ - info->fix.smem_start = qdev->vram_base; /* TODO - correct? */ - info->fix.smem_len = gobj->size; - info->screen_base = shadow; - info->screen_size = gobj->size; - - drm_fb_helper_fill_var(info, &qdev->fb_helper, sizes->fb_width, - sizes->fb_height); - - /* setup aperture base/size for vesafb takeover */ - info->apertures->ranges[0].base = qdev->ddev.mode_config.fb_base; - info->apertures->ranges[0].size = qdev->vram_size; - - info->fix.mmio_start = 0; - info->fix.mmio_len = 0; - - if (info->screen_base == NULL) { - ret = -ENOSPC; - goto out_unref; - } - - /* XXX error handling. */ - drm_fb_helper_defio_init(helper); - - DRM_INFO("fb mappable at 0x%lX, size %lu\n", info->fix.smem_start, (unsigned long)info->screen_size); - DRM_INFO("fb: depth %d, pitch %d, width %d, height %d\n", - fb->format->depth, fb->pitches[0], fb->width, fb->height); - return 0; - -out_unref: - if (qbo) { - qxl_bo_kunmap(qbo); - qxl_bo_unpin(qbo); - } - drm_gem_object_put_unlocked(gobj); - return ret; -} - -static const struct drm_fb_helper_funcs qxl_fb_helper_funcs = { - .fb_probe = qxlfb_create, -}; - -int qxl_fbdev_init(struct qxl_device *qdev) -{ - return drm_fb_helper_fbdev_setup(&qdev->ddev, &qdev->fb_helper, - &qxl_fb_helper_funcs, 32, - QXLFB_CONN_LIMIT); -} - -void qxl_fbdev_fini(struct qxl_device *qdev) -{ - struct fb_info *fbi = qdev->fb_helper.fbdev; - void *shadow = fbi ? fbi->screen_buffer : NULL; - - drm_fb_helper_fbdev_teardown(&qdev->ddev); - vfree(shadow); -} diff --git a/drivers/gpu/drm/qxl/Makefile b/drivers/gpu/drm/qxl/Makefile index 33a7d0c434..fc59d42b31 100644 --- a/drivers/gpu/drm/qxl/Makefile +++ b/drivers/gpu/drm/qxl/Makefile @@ -2,6 +2,6 @@ # Makefile for the drm device driver. This driver provides support for the # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher. -qxl-y := qxl_drv.o qxl_kms.o qxl_display.o qxl_ttm.o qxl_fb.o qxl_object.o qxl_gem.o qxl_cmd.o qxl_image.o qxl_draw.o qxl_debugfs.o qxl_irq.o qxl_dumb.o qxl_ioctl.o qxl_release.o qxl_prime.o +qxl-y := qxl_drv.o qxl_kms.o qxl_display.o qxl_ttm.o qxl_object.o qxl_gem.o qxl_cmd.o qxl_image.o qxl_draw.o qxl_debugfs.o qxl_irq.o qxl_dumb.o qxl_ioctl.o qxl_release.o qxl_prime.o obj-$(CONFIG_DRM_QXL)+= qxl.o -- 2.9.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gerd Hoffmann Subject: [PATCH v3 18/23] drm/qxl: remove dead qxl fbdev emulation code Date: Fri, 18 Jan 2019 13:20:15 +0100 Message-ID: <20190118122020.27596-19-kraxel@redhat.com> References: <20190118122020.27596-1-kraxel@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190118122020.27596-1-kraxel@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: spice-devel-bounces@lists.freedesktop.org Sender: "Spice-devel" To: dri-devel@lists.freedesktop.org Cc: David Airlie , open list , "open list:DRM DRIVER FOR QXL VIRTUAL GPU" , Gerd Hoffmann , Daniel Vetter , "open list:DRM DRIVER FOR QXL VIRTUAL GPU" , Dave Airlie List-Id: dri-devel@lists.freedesktop.org TG92ZWx5IGRpZmZzdGF0LCB0aGFua3MgdG8gdGhlIG5ldyBnZW5lcmljIGZiZGV2IGVtdWxhdGlv bi4KCiBkcm0vcXhsL01ha2VmaWxlICAgfCAgICAyCiBkcm0vcXhsL3F4bF9kcmF3LmMgfCAgMjMy IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGRybS9xeGwvcXhsX2Ry di5oICB8ICAgMjEgLS0tCiBkcm0vcXhsL3F4bF9mYi5jICAgfCAgMzAwIC0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgpTaWduZWQtb2ZmLWJ5OiBH ZXJkIEhvZmZtYW5uIDxrcmF4ZWxAcmVkaGF0LmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vcXhs L3F4bF9kcnYuaCAgfCAgMjEgLS0tCiBkcml2ZXJzL2dwdS9kcm0vcXhsL3F4bF9kcmF3LmMgfCAy MzIgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL3F4bC9x eGxfZmIuYyAgIHwgMzAwIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t CiBkcml2ZXJzL2dwdS9kcm0vcXhsL01ha2VmaWxlICAgfCAgIDIgKy0KIDQgZmlsZXMgY2hhbmdl ZCwgMSBpbnNlcnRpb24oKyksIDU1NCBkZWxldGlvbnMoLSkKIGRlbGV0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2dwdS9kcm0vcXhsL3F4bF9mYi5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L3F4bC9xeGxfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vcXhsL3F4bF9kcnYuaAppbmRleCA4YzNh ZjFjZGJlLi40YTAzMzFiM2ZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcXhsL3F4bF9k cnYuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vcXhsL3F4bF9kcnYuaApAQCAtMjIwLDggKzIyMCw2 IEBAIHN0cnVjdCBxeGxfZGV2aWNlIHsKIAlzdHJ1Y3QgcXhsX21tYW4JCW1tYW47CiAJc3RydWN0 IHF4bF9nZW0JCWdlbTsKIAotCXN0cnVjdCBkcm1fZmJfaGVscGVyCWZiX2hlbHBlcjsKLQogCXZv aWQgKnJhbV9waHlzaWNhbDsKIAogCXN0cnVjdCBxeGxfcmluZyAqcmVsZWFzZV9yaW5nOwpAQCAt MzIyLDEyICszMjAsNiBAQCBxeGxfYm9fcGh5c2ljYWxfYWRkcmVzcyhzdHJ1Y3QgcXhsX2Rldmlj ZSAqcWRldiwgc3RydWN0IHF4bF9ibyAqYm8sCiAJcmV0dXJuIHNsb3QtPmhpZ2hfYml0cyB8IChi by0+dGJvLm9mZnNldCAtIHNsb3QtPmdwdV9vZmZzZXQgKyBvZmZzZXQpOwogfQogCi0vKiBxeGxf ZmIuYyAqLwotI2RlZmluZSBRWExGQl9DT05OX0xJTUlUIDEKLQotaW50IHF4bF9mYmRldl9pbml0 KHN0cnVjdCBxeGxfZGV2aWNlICpxZGV2KTsKLXZvaWQgcXhsX2ZiZGV2X2Zpbmkoc3RydWN0IHF4 bF9kZXZpY2UgKnFkZXYpOwotCiAvKiBxeGxfZGlzcGxheS5jICovCiB2b2lkIHF4bF9kaXNwbGF5 X3JlYWRfY2xpZW50X21vbml0b3JzX2NvbmZpZyhzdHJ1Y3QgcXhsX2RldmljZSAqcWRldik7CiBp bnQgcXhsX2NyZWF0ZV9tb25pdG9yc19vYmplY3Qoc3RydWN0IHF4bF9kZXZpY2UgKnFkZXYpOwpA QCAtNDMyLDkgKzQyNCw2IEBAIGludCBxeGxfYWxsb2NfYm9fcmVzZXJ2ZWQoc3RydWN0IHF4bF9k ZXZpY2UgKnFkZXYsCiAJCQkgIHN0cnVjdCBxeGxfYm8gKipfYm8pOwogLyogcXhsIGRyYXdpbmcg Y29tbWFuZHMgKi8KIAotdm9pZCBxeGxfZHJhd19vcGFxdWVfZmIoY29uc3Qgc3RydWN0IHF4bF9m Yl9pbWFnZSAqcXhsX2ZiX2ltYWdlLAotCQkJaW50IHN0cmlkZSAvKiBmaWxsZWQgaW4gaWYgMCAq Lyk7Ci0KIHZvaWQgcXhsX2RyYXdfZGlydHlfZmIoc3RydWN0IHF4bF9kZXZpY2UgKnFkZXYsCiAJ CSAgICAgICBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiwKIAkJICAgICAgIHN0cnVjdCBxeGxf Ym8gKmJvLApAQCAtNDQzLDEzICs0MzIsNiBAQCB2b2lkIHF4bF9kcmF3X2RpcnR5X2ZiKHN0cnVj dCBxeGxfZGV2aWNlICpxZGV2LAogCQkgICAgICAgdW5zaWduZWQgaW50IG51bV9jbGlwcywgaW50 IGluYywKIAkJICAgICAgIHVpbnQzMl90IGR1bWJfc2hhZG93X29mZnNldCk7CiAKLXZvaWQgcXhs X2RyYXdfZmlsbChzdHJ1Y3QgcXhsX2RyYXdfZmlsbCAqcXhsX2RyYXdfZmlsbF9yZWMpOwotCi12 b2lkIHF4bF9kcmF3X2NvcHlhcmVhKHN0cnVjdCBxeGxfZGV2aWNlICpxZGV2LAotCQkgICAgICAg dTMyIHdpZHRoLCB1MzIgaGVpZ2h0LAotCQkgICAgICAgdTMyIHN4LCB1MzIgc3ksCi0JCSAgICAg ICB1MzIgZHgsIHUzMiBkeSk7Ci0KIHZvaWQgcXhsX3JlbGVhc2VfZnJlZShzdHJ1Y3QgcXhsX2Rl dmljZSAqcWRldiwKIAkJICAgICAgc3RydWN0IHF4bF9yZWxlYXNlICpyZWxlYXNlKTsKIApAQCAt NDgxLDkgKzQ2Myw2IEBAIGludCBxeGxfZ2VtX3ByaW1lX21tYXAoc3RydWN0IGRybV9nZW1fb2Jq ZWN0ICpvYmosCiBpbnQgcXhsX2lycV9pbml0KHN0cnVjdCBxeGxfZGV2aWNlICpxZGV2KTsKIGly cXJldHVybl90IHF4bF9pcnFfaGFuZGxlcihpbnQgaXJxLCB2b2lkICphcmcpOwogCi0vKiBxeGxf ZmIuYyAqLwotYm9vbCBxeGxfZmJkZXZfcW9ial9pc19mYihzdHJ1Y3QgcXhsX2RldmljZSAqcWRl diwgc3RydWN0IHF4bF9ibyAqcW9iaik7Ci0KIGludCBxeGxfZGVidWdmc19hZGRfZmlsZXMoc3Ry dWN0IHF4bF9kZXZpY2UgKnFkZXYsCiAJCQkgIHN0cnVjdCBkcm1faW5mb19saXN0ICpmaWxlcywK IAkJCSAgdW5zaWduZWQgaW50IG5maWxlcyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v cXhsL3F4bF9kcmF3LmMgYi9kcml2ZXJzL2dwdS9kcm0vcXhsL3F4bF9kcmF3LmMKaW5kZXggNTMx M2FkMjFjMS4uOTdjM2YxYTk1YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3F4bC9xeGxf ZHJhdy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9xeGwvcXhsX2RyYXcuYwpAQCAtMTA5LDE1MiAr MTA5LDYgQEAgbWFrZV9kcmF3YWJsZShzdHJ1Y3QgcXhsX2RldmljZSAqcWRldiwgaW50IHN1cmZh Y2UsIHVpbnQ4X3QgdHlwZSwKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBhbGxvY19wYWxl dHRlX29iamVjdChzdHJ1Y3QgcXhsX2RldmljZSAqcWRldiwKLQkJCQlzdHJ1Y3QgcXhsX3JlbGVh c2UgKnJlbGVhc2UsCi0JCQkJc3RydWN0IHF4bF9ibyAqKnBhbGV0dGVfYm8pCi17Ci0JcmV0dXJu IHF4bF9hbGxvY19ib19yZXNlcnZlZChxZGV2LCByZWxlYXNlLAotCQkJCSAgICAgc2l6ZW9mKHN0 cnVjdCBxeGxfcGFsZXR0ZSkgKyBzaXplb2YodWludDMyX3QpICogMiwKLQkJCQkgICAgIHBhbGV0 dGVfYm8pOwotfQotCi1zdGF0aWMgaW50IHF4bF9wYWxldHRlX2NyZWF0ZV8xYml0KHN0cnVjdCBx eGxfYm8gKnBhbGV0dGVfYm8sCi0JCQkJICAgc3RydWN0IHF4bF9yZWxlYXNlICpyZWxlYXNlLAot CQkJCSAgIGNvbnN0IHN0cnVjdCBxeGxfZmJfaW1hZ2UgKnF4bF9mYl9pbWFnZSkKLXsKLQljb25z dCBzdHJ1Y3QgZmJfaW1hZ2UgKmZiX2ltYWdlID0gJnF4bF9mYl9pbWFnZS0+ZmJfaW1hZ2U7Ci0J dWludDMyX3QgdmlzdWFsID0gcXhsX2ZiX2ltYWdlLT52aXN1YWw7Ci0JY29uc3QgdWludDMyX3Qg KnBzZXVkb19wYWxldHRlID0gcXhsX2ZiX2ltYWdlLT5wc2V1ZG9fcGFsZXR0ZTsKLQlzdHJ1Y3Qg cXhsX3BhbGV0dGUgKnBhbDsKLQlpbnQgcmV0OwotCXVpbnQzMl90IGZnY29sb3IsIGJnY29sb3I7 Ci0Jc3RhdGljIHVpbnQ2NF90IHVuaXF1ZTsgLyogd2UgbWFrZSBubyBhdHRlbXB0IHRvIGFjdHVh bGx5IHNldCB0aGlzCi0JCQkJICogY29ycmVjdGx5IGdsb2JhbHksIHNpbmNlIHRoYXQgd291bGQg cmVxdWlyZQotCQkJCSAqIHRyYWNraW5nIGFsbCBvZiBvdXIgcGFsZXR0ZXMuICovCi0JcmV0ID0g cXhsX2JvX2ttYXAocGFsZXR0ZV9ibywgKHZvaWQgKiopJnBhbCk7Ci0JaWYgKHJldCkKLQkJcmV0 dXJuIHJldDsKLQlwYWwtPm51bV9lbnRzID0gMjsKLQlwYWwtPnVuaXF1ZSA9IHVuaXF1ZSsrOwot CWlmICh2aXN1YWwgPT0gRkJfVklTVUFMX1RSVUVDT0xPUiB8fCB2aXN1YWwgPT0gRkJfVklTVUFM X0RJUkVDVENPTE9SKSB7Ci0JCS8qIE5COiB0aGlzIGlzIHRoZSBvbmx5IHVzZWQgYnJhbmNoIGN1 cnJlbnRseS4gKi8KLQkJZmdjb2xvciA9IHBzZXVkb19wYWxldHRlW2ZiX2ltYWdlLT5mZ19jb2xv cl07Ci0JCWJnY29sb3IgPSBwc2V1ZG9fcGFsZXR0ZVtmYl9pbWFnZS0+YmdfY29sb3JdOwotCX0g ZWxzZSB7Ci0JCWZnY29sb3IgPSBmYl9pbWFnZS0+ZmdfY29sb3I7Ci0JCWJnY29sb3IgPSBmYl9p bWFnZS0+YmdfY29sb3I7Ci0JfQotCXBhbC0+ZW50c1swXSA9IGJnY29sb3I7Ci0JcGFsLT5lbnRz WzFdID0gZmdjb2xvcjsKLQlxeGxfYm9fa3VubWFwKHBhbGV0dGVfYm8pOwotCXJldHVybiAwOwot fQotCi12b2lkIHF4bF9kcmF3X29wYXF1ZV9mYihjb25zdCBzdHJ1Y3QgcXhsX2ZiX2ltYWdlICpx eGxfZmJfaW1hZ2UsCi0JCQlpbnQgc3RyaWRlIC8qIGZpbGxlZCBpbiBpZiAwICovKQotewotCXN0 cnVjdCBxeGxfZGV2aWNlICpxZGV2ID0gcXhsX2ZiX2ltYWdlLT5xZGV2OwotCXN0cnVjdCBxeGxf ZHJhd2FibGUgKmRyYXdhYmxlOwotCXN0cnVjdCBxeGxfcmVjdCByZWN0OwotCWNvbnN0IHN0cnVj dCBmYl9pbWFnZSAqZmJfaW1hZ2UgPSAmcXhsX2ZiX2ltYWdlLT5mYl9pbWFnZTsKLQlpbnQgeCA9 IGZiX2ltYWdlLT5keDsKLQlpbnQgeSA9IGZiX2ltYWdlLT5keTsKLQlpbnQgd2lkdGggPSBmYl9p bWFnZS0+d2lkdGg7Ci0JaW50IGhlaWdodCA9IGZiX2ltYWdlLT5oZWlnaHQ7Ci0JY29uc3QgY2hh ciAqc3JjID0gZmJfaW1hZ2UtPmRhdGE7Ci0JaW50IGRlcHRoID0gZmJfaW1hZ2UtPmRlcHRoOwot CXN0cnVjdCBxeGxfcmVsZWFzZSAqcmVsZWFzZTsKLQlzdHJ1Y3QgcXhsX2ltYWdlICppbWFnZTsK LQlpbnQgcmV0OwotCXN0cnVjdCBxeGxfZHJtX2ltYWdlICpkaW1hZ2U7Ci0Jc3RydWN0IHF4bF9i byAqcGFsZXR0ZV9ibyA9IE5VTEw7Ci0KLQlpZiAoc3RyaWRlID09IDApCi0JCXN0cmlkZSA9IGRl cHRoICogd2lkdGggLyA4OwotCi0JcmV0ID0gYWxsb2NfZHJhd2FibGUocWRldiwgJnJlbGVhc2Up OwotCWlmIChyZXQpCi0JCXJldHVybjsKLQotCXJldCA9IHF4bF9pbWFnZV9hbGxvY19vYmplY3Rz KHFkZXYsIHJlbGVhc2UsCi0JCQkJICAgICAgJmRpbWFnZSwKLQkJCQkgICAgICBoZWlnaHQsIHN0 cmlkZSk7Ci0JaWYgKHJldCkKLQkJZ290byBvdXRfZnJlZV9kcmF3YWJsZTsKLQotCWlmIChkZXB0 aCA9PSAxKSB7Ci0JCXJldCA9IGFsbG9jX3BhbGV0dGVfb2JqZWN0KHFkZXYsIHJlbGVhc2UsICZw YWxldHRlX2JvKTsKLQkJaWYgKHJldCkKLQkJCWdvdG8gb3V0X2ZyZWVfaW1hZ2U7Ci0JfQotCi0J LyogZG8gYSByZXNlcnZhdGlvbiBydW4gb3ZlciBhbGwgdGhlIG9iamVjdHMgd2UganVzdCBhbGxv Y2F0ZWQgKi8KLQlyZXQgPSBxeGxfcmVsZWFzZV9yZXNlcnZlX2xpc3QocmVsZWFzZSwgdHJ1ZSk7 Ci0JaWYgKHJldCkKLQkJZ290byBvdXRfZnJlZV9wYWxldHRlOwotCi0JcmVjdC5sZWZ0ID0geDsK LQlyZWN0LnJpZ2h0ID0geCArIHdpZHRoOwotCXJlY3QudG9wID0geTsKLQlyZWN0LmJvdHRvbSA9 IHkgKyBoZWlnaHQ7Ci0KLQlyZXQgPSBtYWtlX2RyYXdhYmxlKHFkZXYsIDAsIFFYTF9EUkFXX0NP UFksICZyZWN0LCByZWxlYXNlKTsKLQlpZiAocmV0KSB7Ci0JCXF4bF9yZWxlYXNlX2JhY2tvZmZf cmVzZXJ2ZV9saXN0KHJlbGVhc2UpOwotCQlnb3RvIG91dF9mcmVlX3BhbGV0dGU7Ci0JfQotCi0J cmV0ID0gcXhsX2ltYWdlX2luaXQocWRldiwgcmVsZWFzZSwgZGltYWdlLAotCQkJICAgICAoY29u c3QgdWludDhfdCAqKXNyYywgMCwgMCwKLQkJCSAgICAgd2lkdGgsIGhlaWdodCwgZGVwdGgsIHN0 cmlkZSk7Ci0JaWYgKHJldCkgewotCQlxeGxfcmVsZWFzZV9iYWNrb2ZmX3Jlc2VydmVfbGlzdChy ZWxlYXNlKTsKLQkJcXhsX3JlbGVhc2VfZnJlZShxZGV2LCByZWxlYXNlKTsKLQkJcmV0dXJuOwot CX0KLQotCWlmIChkZXB0aCA9PSAxKSB7Ci0JCXZvaWQgKnB0cjsKLQotCQlyZXQgPSBxeGxfcGFs ZXR0ZV9jcmVhdGVfMWJpdChwYWxldHRlX2JvLCByZWxlYXNlLCBxeGxfZmJfaW1hZ2UpOwotCi0J CXB0ciA9IHF4bF9ib19rbWFwX2F0b21pY19wYWdlKHFkZXYsIGRpbWFnZS0+Ym8sIDApOwotCQlp bWFnZSA9IHB0cjsKLQkJaW1hZ2UtPnUuYml0bWFwLnBhbGV0dGUgPQotCQkJcXhsX2JvX3BoeXNp Y2FsX2FkZHJlc3MocWRldiwgcGFsZXR0ZV9ibywgMCk7Ci0JCXF4bF9ib19rdW5tYXBfYXRvbWlj X3BhZ2UocWRldiwgZGltYWdlLT5ibywgcHRyKTsKLQl9Ci0KLQlkcmF3YWJsZSA9IChzdHJ1Y3Qg cXhsX2RyYXdhYmxlICopcXhsX3JlbGVhc2VfbWFwKHFkZXYsIHJlbGVhc2UpOwotCi0JZHJhd2Fi bGUtPnUuY29weS5zcmNfYXJlYS50b3AgPSAwOwotCWRyYXdhYmxlLT51LmNvcHkuc3JjX2FyZWEu Ym90dG9tID0gaGVpZ2h0OwotCWRyYXdhYmxlLT51LmNvcHkuc3JjX2FyZWEubGVmdCA9IDA7Ci0J ZHJhd2FibGUtPnUuY29weS5zcmNfYXJlYS5yaWdodCA9IHdpZHRoOwotCi0JZHJhd2FibGUtPnUu Y29weS5yb3BfZGVzY3JpcHRvciA9IFNQSUNFX1JPUERfT1BfUFVUOwotCWRyYXdhYmxlLT51LmNv cHkuc2NhbGVfbW9kZSA9IDA7Ci0JZHJhd2FibGUtPnUuY29weS5tYXNrLmZsYWdzID0gMDsKLQlk cmF3YWJsZS0+dS5jb3B5Lm1hc2sucG9zLnggPSAwOwotCWRyYXdhYmxlLT51LmNvcHkubWFzay5w b3MueSA9IDA7Ci0JZHJhd2FibGUtPnUuY29weS5tYXNrLmJpdG1hcCA9IDA7Ci0KLQlkcmF3YWJs ZS0+dS5jb3B5LnNyY19iaXRtYXAgPQotCQlxeGxfYm9fcGh5c2ljYWxfYWRkcmVzcyhxZGV2LCBk aW1hZ2UtPmJvLCAwKTsKLQlxeGxfcmVsZWFzZV91bm1hcChxZGV2LCByZWxlYXNlLCAmZHJhd2Fi bGUtPnJlbGVhc2VfaW5mbyk7Ci0KLQlxeGxfcHVzaF9jb21tYW5kX3JpbmdfcmVsZWFzZShxZGV2 LCByZWxlYXNlLCBRWExfQ01EX0RSQVcsIGZhbHNlKTsKLQlxeGxfcmVsZWFzZV9mZW5jZV9idWZm ZXJfb2JqZWN0cyhyZWxlYXNlKTsKLQotb3V0X2ZyZWVfcGFsZXR0ZToKLQlxeGxfYm9fdW5yZWYo JnBhbGV0dGVfYm8pOwotb3V0X2ZyZWVfaW1hZ2U6Ci0JcXhsX2ltYWdlX2ZyZWVfb2JqZWN0cyhx ZGV2LCBkaW1hZ2UpOwotb3V0X2ZyZWVfZHJhd2FibGU6Ci0JaWYgKHJldCkKLQkJZnJlZV9kcmF3 YWJsZShxZGV2LCByZWxlYXNlKTsKLX0KLQogLyogcHVzaCBhIGRyYXcgY29tbWFuZCB1c2luZyB0 aGUgZ2l2ZW4gY2xpcHBpbmcgcmVjdGFuZ2xlcyBhcwogICogdGhlIHNvdXJjZXMgZnJvbSB0aGUg c2hhZG93IGZyYW1lYnVmZmVyLgogICoKQEAgLTQwMiw4OSArMjU2LDMgQEAgdm9pZCBxeGxfZHJh d19kaXJ0eV9mYihzdHJ1Y3QgcXhsX2RldmljZSAqcWRldiwKIAkJZnJlZV9kcmF3YWJsZShxZGV2 LCByZWxlYXNlKTsKIAogfQotCi12b2lkIHF4bF9kcmF3X2NvcHlhcmVhKHN0cnVjdCBxeGxfZGV2 aWNlICpxZGV2LAotCQkgICAgICAgdTMyIHdpZHRoLCB1MzIgaGVpZ2h0LAotCQkgICAgICAgdTMy IHN4LCB1MzIgc3ksCi0JCSAgICAgICB1MzIgZHgsIHUzMiBkeSkKLXsKLQlzdHJ1Y3QgcXhsX2Ry YXdhYmxlICpkcmF3YWJsZTsKLQlzdHJ1Y3QgcXhsX3JlY3QgcmVjdDsKLQlzdHJ1Y3QgcXhsX3Jl bGVhc2UgKnJlbGVhc2U7Ci0JaW50IHJldDsKLQotCXJldCA9IGFsbG9jX2RyYXdhYmxlKHFkZXYs ICZyZWxlYXNlKTsKLQlpZiAocmV0KQotCQlyZXR1cm47Ci0KLQkvKiBkbyBhIHJlc2VydmF0aW9u IHJ1biBvdmVyIGFsbCB0aGUgb2JqZWN0cyB3ZSBqdXN0IGFsbG9jYXRlZCAqLwotCXJldCA9IHF4 bF9yZWxlYXNlX3Jlc2VydmVfbGlzdChyZWxlYXNlLCB0cnVlKTsKLQlpZiAocmV0KQotCQlnb3Rv IG91dF9mcmVlX3JlbGVhc2U7Ci0KLQlyZWN0LmxlZnQgPSBkeDsKLQlyZWN0LnRvcCA9IGR5Owot CXJlY3QucmlnaHQgPSBkeCArIHdpZHRoOwotCXJlY3QuYm90dG9tID0gZHkgKyBoZWlnaHQ7Ci0J cmV0ID0gbWFrZV9kcmF3YWJsZShxZGV2LCAwLCBRWExfQ09QWV9CSVRTLCAmcmVjdCwgcmVsZWFz ZSk7Ci0JaWYgKHJldCkgewotCQlxeGxfcmVsZWFzZV9iYWNrb2ZmX3Jlc2VydmVfbGlzdChyZWxl YXNlKTsKLQkJZ290byBvdXRfZnJlZV9yZWxlYXNlOwotCX0KLQotCWRyYXdhYmxlID0gKHN0cnVj dCBxeGxfZHJhd2FibGUgKilxeGxfcmVsZWFzZV9tYXAocWRldiwgcmVsZWFzZSk7Ci0JZHJhd2Fi bGUtPnUuY29weV9iaXRzLnNyY19wb3MueCA9IHN4OwotCWRyYXdhYmxlLT51LmNvcHlfYml0cy5z cmNfcG9zLnkgPSBzeTsKLQlxeGxfcmVsZWFzZV91bm1hcChxZGV2LCByZWxlYXNlLCAmZHJhd2Fi bGUtPnJlbGVhc2VfaW5mbyk7Ci0KLQlxeGxfcHVzaF9jb21tYW5kX3JpbmdfcmVsZWFzZShxZGV2 LCByZWxlYXNlLCBRWExfQ01EX0RSQVcsIGZhbHNlKTsKLQlxeGxfcmVsZWFzZV9mZW5jZV9idWZm ZXJfb2JqZWN0cyhyZWxlYXNlKTsKLQotb3V0X2ZyZWVfcmVsZWFzZToKLQlpZiAocmV0KQotCQlm cmVlX2RyYXdhYmxlKHFkZXYsIHJlbGVhc2UpOwotfQotCi12b2lkIHF4bF9kcmF3X2ZpbGwoc3Ry dWN0IHF4bF9kcmF3X2ZpbGwgKnF4bF9kcmF3X2ZpbGxfcmVjKQotewotCXN0cnVjdCBxeGxfZGV2 aWNlICpxZGV2ID0gcXhsX2RyYXdfZmlsbF9yZWMtPnFkZXY7Ci0Jc3RydWN0IHF4bF9yZWN0IHJl Y3QgPSBxeGxfZHJhd19maWxsX3JlYy0+cmVjdDsKLQl1aW50MzJfdCBjb2xvciA9IHF4bF9kcmF3 X2ZpbGxfcmVjLT5jb2xvcjsKLQl1aW50MTZfdCByb3AgPSBxeGxfZHJhd19maWxsX3JlYy0+cm9w OwotCXN0cnVjdCBxeGxfZHJhd2FibGUgKmRyYXdhYmxlOwotCXN0cnVjdCBxeGxfcmVsZWFzZSAq cmVsZWFzZTsKLQlpbnQgcmV0OwotCi0JcmV0ID0gYWxsb2NfZHJhd2FibGUocWRldiwgJnJlbGVh c2UpOwotCWlmIChyZXQpCi0JCXJldHVybjsKLQotCS8qIGRvIGEgcmVzZXJ2YXRpb24gcnVuIG92 ZXIgYWxsIHRoZSBvYmplY3RzIHdlIGp1c3QgYWxsb2NhdGVkICovCi0JcmV0ID0gcXhsX3JlbGVh c2VfcmVzZXJ2ZV9saXN0KHJlbGVhc2UsIHRydWUpOwotCWlmIChyZXQpCi0JCWdvdG8gb3V0X2Zy ZWVfcmVsZWFzZTsKLQotCXJldCA9IG1ha2VfZHJhd2FibGUocWRldiwgMCwgUVhMX0RSQVdfRklM TCwgJnJlY3QsIHJlbGVhc2UpOwotCWlmIChyZXQpIHsKLQkJcXhsX3JlbGVhc2VfYmFja29mZl9y ZXNlcnZlX2xpc3QocmVsZWFzZSk7Ci0JCWdvdG8gb3V0X2ZyZWVfcmVsZWFzZTsKLQl9Ci0KLQlk cmF3YWJsZSA9IChzdHJ1Y3QgcXhsX2RyYXdhYmxlICopcXhsX3JlbGVhc2VfbWFwKHFkZXYsIHJl bGVhc2UpOwotCWRyYXdhYmxlLT51LmZpbGwuYnJ1c2gudHlwZSA9IFNQSUNFX0JSVVNIX1RZUEVf U09MSUQ7Ci0JZHJhd2FibGUtPnUuZmlsbC5icnVzaC51LmNvbG9yID0gY29sb3I7Ci0JZHJhd2Fi bGUtPnUuZmlsbC5yb3BfZGVzY3JpcHRvciA9IHJvcDsKLQlkcmF3YWJsZS0+dS5maWxsLm1hc2su ZmxhZ3MgPSAwOwotCWRyYXdhYmxlLT51LmZpbGwubWFzay5wb3MueCA9IDA7Ci0JZHJhd2FibGUt PnUuZmlsbC5tYXNrLnBvcy55ID0gMDsKLQlkcmF3YWJsZS0+dS5maWxsLm1hc2suYml0bWFwID0g MDsKLQotCXF4bF9yZWxlYXNlX3VubWFwKHFkZXYsIHJlbGVhc2UsICZkcmF3YWJsZS0+cmVsZWFz ZV9pbmZvKTsKLQotCXF4bF9wdXNoX2NvbW1hbmRfcmluZ19yZWxlYXNlKHFkZXYsIHJlbGVhc2Us IFFYTF9DTURfRFJBVywgZmFsc2UpOwotCXF4bF9yZWxlYXNlX2ZlbmNlX2J1ZmZlcl9vYmplY3Rz KHJlbGVhc2UpOwotCi1vdXRfZnJlZV9yZWxlYXNlOgotCWlmIChyZXQpCi0JCWZyZWVfZHJhd2Fi bGUocWRldiwgcmVsZWFzZSk7Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcXhsL3F4 bF9mYi5jIGIvZHJpdmVycy9ncHUvZHJtL3F4bC9xeGxfZmIuYwpkZWxldGVkIGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggYTgxOWQyNDIyNS4uMDAwMDAwMDAwMAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v cXhsL3F4bF9mYi5jCisrKyAvZGV2L251bGwKQEAgLTEsMzAwICswLDAgQEAKLS8qCi0gKiBDb3B5 cmlnaHQgwqkgMjAxMyBSZWQgSGF0Ci0gKgotICogUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRl ZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEKLSAqIGNvcHkgb2Yg dGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgIlNv ZnR3YXJlIiksCi0gKiB0byBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9u LCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uCi0gKiB0aGUgcmlnaHRzIHRvIHVzZSwgY29w eSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwKLSAqIGFu ZC9vciBzZWxsIGNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0 byB3aG9tIHRoZQotICogU29mdHdhcmUgaXMgZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRv IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKLSAqCi0gKiBUaGUgYWJvdmUgY29weXJpZ2h0IG5v dGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSAoaW5jbHVkaW5nIHRoZSBuZXh0Ci0gKiBw YXJhZ3JhcGgpIHNoYWxsIGJlIGluY2x1ZGVkIGluIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwg cG9ydGlvbnMgb2YgdGhlCi0gKiBTb2Z0d2FyZS4KLSAqCi0gKiBUSEUgU09GVFdBUkUgSVMgUFJP VklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgot ICogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFksCi0gKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB TkQgTk9OSU5GUklOR0VNRU5ULiAgSU4gTk8gRVZFTlQgU0hBTEwKLSAqIFRIRSBBVVRIT1JTIE9S IENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9U SEVSCi0gKiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JU IE9SIE9USEVSV0lTRSwgQVJJU0lORwotICogRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04g V0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUgotICogREVBTElOR1MgSU4gVEhF IFNPRlRXQVJFLgotICoKLSAqIEF1dGhvcnM6Ci0gKiAgICAgRGF2aWQgQWlybGllCi0gKi8KLSNp bmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KLQotI2luY2x1ZGUgPGRybS9kcm1QLmg+Ci0jaW5jbHVk ZSA8ZHJtL2RybS5oPgotI2luY2x1ZGUgPGRybS9kcm1fY3J0Yy5oPgotI2luY2x1ZGUgPGRybS9k cm1fY3J0Y19oZWxwZXIuaD4KLSNpbmNsdWRlIDxkcm0vZHJtX2ZiX2hlbHBlci5oPgotI2luY2x1 ZGUgPGRybS9kcm1fZ2VtX2ZyYW1lYnVmZmVyX2hlbHBlci5oPgotCi0jaW5jbHVkZSAicXhsX2Ry di5oIgotCi0jaW5jbHVkZSAicXhsX29iamVjdC5oIgotCi1zdGF0aWMgdm9pZCBxeGxfZmJfaW1h Z2VfaW5pdChzdHJ1Y3QgcXhsX2ZiX2ltYWdlICpxeGxfZmJfaW1hZ2UsCi0JCQkgICAgICBzdHJ1 Y3QgcXhsX2RldmljZSAqcWRldiwgc3RydWN0IGZiX2luZm8gKmluZm8sCi0JCQkgICAgICBjb25z dCBzdHJ1Y3QgZmJfaW1hZ2UgKmltYWdlKQotewotCXF4bF9mYl9pbWFnZS0+cWRldiA9IHFkZXY7 Ci0JaWYgKGluZm8pIHsKLQkJcXhsX2ZiX2ltYWdlLT52aXN1YWwgPSBpbmZvLT5maXgudmlzdWFs OwotCQlpZiAocXhsX2ZiX2ltYWdlLT52aXN1YWwgPT0gRkJfVklTVUFMX1RSVUVDT0xPUiB8fAot CQkgICAgcXhsX2ZiX2ltYWdlLT52aXN1YWwgPT0gRkJfVklTVUFMX0RJUkVDVENPTE9SKQotCQkJ bWVtY3B5KCZxeGxfZmJfaW1hZ2UtPnBzZXVkb19wYWxldHRlLAotCQkJICAgICAgIGluZm8tPnBz ZXVkb19wYWxldHRlLAotCQkJICAgICAgIHNpemVvZihxeGxfZmJfaW1hZ2UtPnBzZXVkb19wYWxl dHRlKSk7Ci0JfSBlbHNlIHsKLQkJIC8qIGZhbGxiYWNrICovCi0JCWlmIChpbWFnZS0+ZGVwdGgg PT0gMSkKLQkJCXF4bF9mYl9pbWFnZS0+dmlzdWFsID0gRkJfVklTVUFMX01PTk8xMDsKLQkJZWxz ZQotCQkJcXhsX2ZiX2ltYWdlLT52aXN1YWwgPSBGQl9WSVNVQUxfRElSRUNUQ09MT1I7Ci0JfQot CWlmIChpbWFnZSkgewotCQltZW1jcHkoJnF4bF9mYl9pbWFnZS0+ZmJfaW1hZ2UsIGltYWdlLAot CQkgICAgICAgc2l6ZW9mKHF4bF9mYl9pbWFnZS0+ZmJfaW1hZ2UpKTsKLQl9Ci19Ci0KLXN0YXRp YyBzdHJ1Y3QgZmJfb3BzIHF4bGZiX29wcyA9IHsKLQkub3duZXIgPSBUSElTX01PRFVMRSwKLQlE Uk1fRkJfSEVMUEVSX0RFRkFVTFRfT1BTLAotCS5mYl9maWxscmVjdCA9IGRybV9mYl9oZWxwZXJf c3lzX2ZpbGxyZWN0LAotCS5mYl9jb3B5YXJlYSA9IGRybV9mYl9oZWxwZXJfc3lzX2NvcHlhcmVh LAotCS5mYl9pbWFnZWJsaXQgPSBkcm1fZmJfaGVscGVyX3N5c19pbWFnZWJsaXQsCi19OwotCi1z dGF0aWMgdm9pZCBxeGxmYl9kZXN0cm95X3Bpbm5lZF9vYmplY3Qoc3RydWN0IGRybV9nZW1fb2Jq ZWN0ICpnb2JqKQotewotCXN0cnVjdCBxeGxfYm8gKnFibyA9IGdlbV90b19xeGxfYm8oZ29iaik7 Ci0KLQlxeGxfYm9fa3VubWFwKHFibyk7Ci0JcXhsX2JvX3VucGluKHFibyk7Ci0KLQlkcm1fZ2Vt X29iamVjdF9wdXRfdW5sb2NrZWQoZ29iaik7Ci19Ci0KLXN0YXRpYyBpbnQgcXhsZmJfY3JlYXRl X3Bpbm5lZF9vYmplY3Qoc3RydWN0IHF4bF9kZXZpY2UgKnFkZXYsCi0JCQkJICAgICAgY29uc3Qg c3RydWN0IGRybV9tb2RlX2ZiX2NtZDIgKm1vZGVfY21kLAotCQkJCSAgICAgIHN0cnVjdCBkcm1f Z2VtX29iamVjdCAqKmdvYmpfcCkKLXsKLQlzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdvYmogPSBO VUxMOwotCXN0cnVjdCBxeGxfYm8gKnFibyA9IE5VTEw7Ci0JaW50IHJldDsKLQlpbnQgYWxpZ25l ZF9zaXplLCBzaXplOwotCWludCBoZWlnaHQgPSBtb2RlX2NtZC0+aGVpZ2h0OwotCi0Jc2l6ZSA9 IG1vZGVfY21kLT5waXRjaGVzWzBdICogaGVpZ2h0OwotCWFsaWduZWRfc2l6ZSA9IEFMSUdOKHNp emUsIFBBR0VfU0laRSk7Ci0JLyogVE9ETzogdW5hbGxvY2F0ZSBhbmQgcmVhbGxvY2F0ZSBzdXJm YWNlMCBmb3IgcmVhbC4gSGFjayB0byBqdXN0Ci0JICogaGF2ZSBhIGxhcmdlIGVub3VnaCBzdXJm YWNlMCBmb3IgMTAyNHg3NjggWG9yZyAzMmJwcCBtb2RlICovCi0JcmV0ID0gcXhsX2dlbV9vYmpl Y3RfY3JlYXRlKHFkZXYsIGFsaWduZWRfc2l6ZSwgMCwKLQkJCQkgICAgUVhMX0dFTV9ET01BSU5f U1VSRkFDRSwKLQkJCQkgICAgZmFsc2UsIC8qIGlzIGRpc2NhcmRhYmxlICovCi0JCQkJICAgIGZh bHNlLCAvKiBpcyBrZXJuZWwgKGZhbHNlIG1lYW5zIGRldmljZSkgKi8KLQkJCQkgICAgTlVMTCwK LQkJCQkgICAgJmdvYmopOwotCWlmIChyZXQpIHsKLQkJcHJfZXJyKCJmYWlsZWQgdG8gYWxsb2Nh dGUgZnJhbWVidWZmZXIgKCVkKVxuIiwKLQkJICAgICAgIGFsaWduZWRfc2l6ZSk7Ci0JCXJldHVy biAtRU5PTUVNOwotCX0KLQlxYm8gPSBnZW1fdG9fcXhsX2JvKGdvYmopOwotCi0JcWJvLT5zdXJm LndpZHRoID0gbW9kZV9jbWQtPndpZHRoOwotCXFiby0+c3VyZi5oZWlnaHQgPSBtb2RlX2NtZC0+ aGVpZ2h0OwotCXFiby0+c3VyZi5zdHJpZGUgPSBtb2RlX2NtZC0+cGl0Y2hlc1swXTsKLQlxYm8t PnN1cmYuZm9ybWF0ID0gU1BJQ0VfU1VSRkFDRV9GTVRfMzJfeFJHQjsKLQotCXJldCA9IHF4bF9i b19waW4ocWJvKTsKLQlpZiAocmV0KSB7Ci0JCWdvdG8gb3V0X3VucmVmOwotCX0KLQlyZXQgPSBx eGxfYm9fa21hcChxYm8sIE5VTEwpOwotCi0JaWYgKHJldCkKLQkJZ290byBvdXRfdW5yZWY7Ci0K LQkqZ29ial9wID0gZ29iajsKLQlyZXR1cm4gMDsKLW91dF91bnJlZjoKLQlxeGxmYl9kZXN0cm95 X3Bpbm5lZF9vYmplY3QoZ29iaik7Ci0JKmdvYmpfcCA9IE5VTEw7Ci0JcmV0dXJuIHJldDsKLX0K LQotLyoKLSAqIEZJWE1FCi0gKiBJdCBzaG91bGQgbm90IGJlIG5lY2Vzc2FyeSB0byBoYXZlIGEg c3BlY2lhbCBkaXJ0eSgpIGNhbGxiYWNrIGZvciBmYmRldi4KLSAqLwotc3RhdGljIGludCBxeGxm Yl9mcmFtZWJ1ZmZlcl9kaXJ0eShzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiwKLQkJCQkgICBz dHJ1Y3QgZHJtX2ZpbGUgKmZpbGVfcHJpdiwKLQkJCQkgICB1bnNpZ25lZCBpbnQgZmxhZ3MsIHVu c2lnbmVkIGludCBjb2xvciwKLQkJCQkgICBzdHJ1Y3QgZHJtX2NsaXBfcmVjdCAqY2xpcHMsCi0J CQkJICAgdW5zaWduZWQgaW50IG51bV9jbGlwcykKLXsKLQlzdHJ1Y3QgcXhsX2RldmljZSAqcWRl diA9IGZiLT5kZXYtPmRldl9wcml2YXRlOwotCXN0cnVjdCBmYl9pbmZvICppbmZvID0gcWRldi0+ ZmJfaGVscGVyLmZiZGV2OwotCXN0cnVjdCBxeGxfZmJfaW1hZ2UgcXhsX2ZiX2ltYWdlOwotCXN0 cnVjdCBmYl9pbWFnZSAqaW1hZ2UgPSAmcXhsX2ZiX2ltYWdlLmZiX2ltYWdlOwotCi0JLyogVE9E TzogaGFyZCBjb2RpbmcgMzIgYnBwICovCi0JaW50IHN0cmlkZSA9IGZiLT5waXRjaGVzWzBdOwot Ci0JLyoKLQkgKiB3ZSBhcmUgdXNpbmcgYSBzaGFkb3cgZHJhdyBidWZmZXIsIGF0IHFkZXYtPnN1 cmZhY2UwX3NoYWRvdwotCSAqLwotCWltYWdlLT5keCA9IGNsaXBzLT54MTsKLQlpbWFnZS0+ZHkg PSBjbGlwcy0+eTE7Ci0JaW1hZ2UtPndpZHRoID0gY2xpcHMtPngyIC0gY2xpcHMtPngxOwotCWlt YWdlLT5oZWlnaHQgPSBjbGlwcy0+eTIgLSBjbGlwcy0+eTE7Ci0JaW1hZ2UtPmZnX2NvbG9yID0g MHhmZmZmZmZmZjsgLyogdW51c2VkLCBqdXN0IHRvIGF2b2lkIHVuaW5pdGlhbGl6ZWQKLQkJCQkJ IHdhcm5pbmdzICovCi0JaW1hZ2UtPmJnX2NvbG9yID0gMDsKLQlpbWFnZS0+ZGVwdGggPSAzMjsJ ICAgICAvKiBUT0RPOiB0YWtlIGZyb20gc29tZXdoZXJlPyAqLwotCWltYWdlLT5jbWFwLnN0YXJ0 ID0gMDsKLQlpbWFnZS0+Y21hcC5sZW4gPSAwOwotCWltYWdlLT5jbWFwLnJlZCA9IE5VTEw7Ci0J aW1hZ2UtPmNtYXAuZ3JlZW4gPSBOVUxMOwotCWltYWdlLT5jbWFwLmJsdWUgPSBOVUxMOwotCWlt YWdlLT5jbWFwLnRyYW5zcCA9IE5VTEw7Ci0JaW1hZ2UtPmRhdGEgPSBpbmZvLT5zY3JlZW5fYmFz ZSArIChjbGlwcy0+eDEgKiA0KSArIChzdHJpZGUgKiBjbGlwcy0+eTEpOwotCi0JcXhsX2ZiX2lt YWdlX2luaXQoJnF4bF9mYl9pbWFnZSwgcWRldiwgaW5mbywgTlVMTCk7Ci0JcXhsX2RyYXdfb3Bh cXVlX2ZiKCZxeGxfZmJfaW1hZ2UsIHN0cmlkZSk7Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGlj IGNvbnN0IHN0cnVjdCBkcm1fZnJhbWVidWZmZXJfZnVuY3MgcXhsZmJfZmJfZnVuY3MgPSB7Ci0J LmRlc3Ryb3kgPSBkcm1fZ2VtX2ZiX2Rlc3Ryb3ksCi0JLmNyZWF0ZV9oYW5kbGUgPSBkcm1fZ2Vt X2ZiX2NyZWF0ZV9oYW5kbGUsCi0JLmRpcnR5ID0gcXhsZmJfZnJhbWVidWZmZXJfZGlydHksCi19 OwotCi1zdGF0aWMgaW50IHF4bGZiX2NyZWF0ZShzdHJ1Y3QgZHJtX2ZiX2hlbHBlciAqaGVscGVy LAotCQkJc3RydWN0IGRybV9mYl9oZWxwZXJfc3VyZmFjZV9zaXplICpzaXplcykKLXsKLQlzdHJ1 Y3QgcXhsX2RldmljZSAqcWRldiA9Ci0JCWNvbnRhaW5lcl9vZihoZWxwZXIsIHN0cnVjdCBxeGxf ZGV2aWNlLCBmYl9oZWxwZXIpOwotCXN0cnVjdCBmYl9pbmZvICppbmZvOwotCXN0cnVjdCBkcm1f ZnJhbWVidWZmZXIgKmZiID0gTlVMTDsKLQlzdHJ1Y3QgZHJtX21vZGVfZmJfY21kMiBtb2RlX2Nt ZDsKLQlzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdvYmogPSBOVUxMOwotCXN0cnVjdCBxeGxfYm8g KnFibyA9IE5VTEw7Ci0JaW50IHJldDsKLQlpbnQgYnBwID0gc2l6ZXMtPnN1cmZhY2VfYnBwOwot CWludCBkZXB0aCA9IHNpemVzLT5zdXJmYWNlX2RlcHRoOwotCXZvaWQgKnNoYWRvdzsKLQotCW1v ZGVfY21kLndpZHRoID0gc2l6ZXMtPnN1cmZhY2Vfd2lkdGg7Ci0JbW9kZV9jbWQuaGVpZ2h0ID0g c2l6ZXMtPnN1cmZhY2VfaGVpZ2h0OwotCi0JbW9kZV9jbWQucGl0Y2hlc1swXSA9IEFMSUdOKG1v ZGVfY21kLndpZHRoICogKChicHAgKyAxKSAvIDgpLCA2NCk7Ci0JbW9kZV9jbWQucGl4ZWxfZm9y bWF0ID0gZHJtX21vZGVfbGVnYWN5X2ZiX2Zvcm1hdChicHAsIGRlcHRoKTsKLQotCXJldCA9IHF4 bGZiX2NyZWF0ZV9waW5uZWRfb2JqZWN0KHFkZXYsICZtb2RlX2NtZCwgJmdvYmopOwotCWlmIChy ZXQgPCAwKQotCQlyZXR1cm4gcmV0OwotCi0JcWJvID0gZ2VtX3RvX3F4bF9ibyhnb2JqKTsKLQlE Uk1fREVCVUdfRFJJVkVSKCIlZHglZCAlZFxuIiwgbW9kZV9jbWQud2lkdGgsCi0JCQkgbW9kZV9j bWQuaGVpZ2h0LCBtb2RlX2NtZC5waXRjaGVzWzBdKTsKLQotCXNoYWRvdyA9IHZtYWxsb2MoYXJy YXlfc2l6ZShtb2RlX2NtZC5waXRjaGVzWzBdLCBtb2RlX2NtZC5oZWlnaHQpKTsKLQkvKiBUT0RP OiB3aGF0J3MgdGhlIHVzdWFsIHJlc3BvbnNlIHRvIG1lbW9yeSBhbGxvY2F0aW9uIGVycm9ycz8g Ki8KLQlCVUdfT04oIXNoYWRvdyk7Ci0JRFJNX0RFQlVHX0RSSVZFUigic3VyZmFjZTAgYXQgZ3B1 IG9mZnNldCAlbGxkLCBtbWFwX29mZnNldCAlbGxkICh2aXJ0ICVwLCBzaGFkb3cgJXApXG4iLAot CQkJIHF4bF9ib19ncHVfb2Zmc2V0KHFibyksIHF4bF9ib19tbWFwX29mZnNldChxYm8pLAotCQkJ IHFiby0+a3B0ciwgc2hhZG93KTsKLQotCWluZm8gPSBkcm1fZmJfaGVscGVyX2FsbG9jX2ZiaSho ZWxwZXIpOwotCWlmIChJU19FUlIoaW5mbykpIHsKLQkJcmV0ID0gUFRSX0VSUihpbmZvKTsKLQkJ Z290byBvdXRfdW5yZWY7Ci0JfQotCi0JaW5mby0+cGFyID0gaGVscGVyOwotCi0JZmIgPSBkcm1f Z2VtX2ZiZGV2X2ZiX2NyZWF0ZSgmcWRldi0+ZGRldiwgc2l6ZXMsIDY0LCBnb2JqLAotCQkJCSAg ICAgJnF4bGZiX2ZiX2Z1bmNzKTsKLQlpZiAoSVNfRVJSKGZiKSkgewotCQlEUk1fRVJST1IoIkZh aWxlZCB0byBjcmVhdGUgZnJhbWVidWZmZXI6ICVsZFxuIiwgUFRSX0VSUihmYikpOwotCQlyZXQg PSBQVFJfRVJSKGZiKTsKLQkJZ290byBvdXRfdW5yZWY7Ci0JfQotCi0JLyogc2V0dXAgaGVscGVy IHdpdGggZmIgZGF0YSAqLwotCXFkZXYtPmZiX2hlbHBlci5mYiA9IGZiOwotCi0Jc3RyY3B5KGlu Zm8tPmZpeC5pZCwgInF4bGRybWZiIik7Ci0KLQlkcm1fZmJfaGVscGVyX2ZpbGxfZml4KGluZm8s IGZiLT5waXRjaGVzWzBdLCBmYi0+Zm9ybWF0LT5kZXB0aCk7Ci0KLQlpbmZvLT5mYm9wcyA9ICZx eGxmYl9vcHM7Ci0KLQkvKgotCSAqIFRPRE86IHVzaW5nIGdvYmotPnNpemUgaW4gdmFyaW91cyBw bGFjZXMgaW4gdGhpcyBmdW5jdGlvbi4gTm90IHN1cmUKLQkgKiB3aGF0IHRoZSBkaWZmZXJlbmNl IGJldHdlZW4gdGhlIGRpZmZlcmVudCBzaXplcyBpcy4KLQkgKi8KLQlpbmZvLT5maXguc21lbV9z dGFydCA9IHFkZXYtPnZyYW1fYmFzZTsgLyogVE9ETyAtIGNvcnJlY3Q/ICovCi0JaW5mby0+Zml4 LnNtZW1fbGVuID0gZ29iai0+c2l6ZTsKLQlpbmZvLT5zY3JlZW5fYmFzZSA9IHNoYWRvdzsKLQlp bmZvLT5zY3JlZW5fc2l6ZSA9IGdvYmotPnNpemU7Ci0KLQlkcm1fZmJfaGVscGVyX2ZpbGxfdmFy KGluZm8sICZxZGV2LT5mYl9oZWxwZXIsIHNpemVzLT5mYl93aWR0aCwKLQkJCSAgICAgICBzaXpl cy0+ZmJfaGVpZ2h0KTsKLQotCS8qIHNldHVwIGFwZXJ0dXJlIGJhc2Uvc2l6ZSBmb3IgdmVzYWZi IHRha2VvdmVyICovCi0JaW5mby0+YXBlcnR1cmVzLT5yYW5nZXNbMF0uYmFzZSA9IHFkZXYtPmRk ZXYubW9kZV9jb25maWcuZmJfYmFzZTsKLQlpbmZvLT5hcGVydHVyZXMtPnJhbmdlc1swXS5zaXpl ID0gcWRldi0+dnJhbV9zaXplOwotCi0JaW5mby0+Zml4Lm1taW9fc3RhcnQgPSAwOwotCWluZm8t PmZpeC5tbWlvX2xlbiA9IDA7Ci0KLQlpZiAoaW5mby0+c2NyZWVuX2Jhc2UgPT0gTlVMTCkgewot CQlyZXQgPSAtRU5PU1BDOwotCQlnb3RvIG91dF91bnJlZjsKLQl9Ci0KLQkvKiBYWFggZXJyb3Ig aGFuZGxpbmcuICovCi0JZHJtX2ZiX2hlbHBlcl9kZWZpb19pbml0KGhlbHBlcik7Ci0KLQlEUk1f SU5GTygiZmIgbWFwcGFibGUgYXQgMHglbFgsIHNpemUgJWx1XG4iLCAgaW5mby0+Zml4LnNtZW1f c3RhcnQsICh1bnNpZ25lZCBsb25nKWluZm8tPnNjcmVlbl9zaXplKTsKLQlEUk1fSU5GTygiZmI6 IGRlcHRoICVkLCBwaXRjaCAlZCwgd2lkdGggJWQsIGhlaWdodCAlZFxuIiwKLQkJIGZiLT5mb3Jt YXQtPmRlcHRoLCBmYi0+cGl0Y2hlc1swXSwgZmItPndpZHRoLCBmYi0+aGVpZ2h0KTsKLQlyZXR1 cm4gMDsKLQotb3V0X3VucmVmOgotCWlmIChxYm8pIHsKLQkJcXhsX2JvX2t1bm1hcChxYm8pOwot CQlxeGxfYm9fdW5waW4ocWJvKTsKLQl9Ci0JZHJtX2dlbV9vYmplY3RfcHV0X3VubG9ja2VkKGdv YmopOwotCXJldHVybiByZXQ7Ci19Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2ZiX2hlbHBl cl9mdW5jcyBxeGxfZmJfaGVscGVyX2Z1bmNzID0gewotCS5mYl9wcm9iZSA9IHF4bGZiX2NyZWF0 ZSwKLX07Ci0KLWludCBxeGxfZmJkZXZfaW5pdChzdHJ1Y3QgcXhsX2RldmljZSAqcWRldikKLXsK LQlyZXR1cm4gZHJtX2ZiX2hlbHBlcl9mYmRldl9zZXR1cCgmcWRldi0+ZGRldiwgJnFkZXYtPmZi X2hlbHBlciwKLQkJCQkJICZxeGxfZmJfaGVscGVyX2Z1bmNzLCAzMiwKLQkJCQkJIFFYTEZCX0NP Tk5fTElNSVQpOwotfQotCi12b2lkIHF4bF9mYmRldl9maW5pKHN0cnVjdCBxeGxfZGV2aWNlICpx ZGV2KQotewotCXN0cnVjdCBmYl9pbmZvICpmYmkgPSBxZGV2LT5mYl9oZWxwZXIuZmJkZXY7Ci0J dm9pZCAqc2hhZG93ID0gZmJpID8gZmJpLT5zY3JlZW5fYnVmZmVyIDogTlVMTDsKLQotCWRybV9m Yl9oZWxwZXJfZmJkZXZfdGVhcmRvd24oJnFkZXYtPmRkZXYpOwotCXZmcmVlKHNoYWRvdyk7Ci19 CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcXhsL01ha2VmaWxlIGIvZHJpdmVycy9ncHUv ZHJtL3F4bC9NYWtlZmlsZQppbmRleCAzM2E3ZDBjNDM0Li5mYzU5ZDQyYjMxIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vcXhsL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9xeGwv TWFrZWZpbGUKQEAgLTIsNiArMiw2IEBACiAjIE1ha2VmaWxlIGZvciB0aGUgZHJtIGRldmljZSBk cml2ZXIuICBUaGlzIGRyaXZlciBwcm92aWRlcyBzdXBwb3J0IGZvciB0aGUKICMgRGlyZWN0IFJl bmRlcmluZyBJbmZyYXN0cnVjdHVyZSAoRFJJKSBpbiBYRnJlZTg2IDQuMS4wIGFuZCBoaWdoZXIu CiAKLXF4bC15IDo9IHF4bF9kcnYubyBxeGxfa21zLm8gcXhsX2Rpc3BsYXkubyBxeGxfdHRtLm8g cXhsX2ZiLm8gcXhsX29iamVjdC5vIHF4bF9nZW0ubyBxeGxfY21kLm8gcXhsX2ltYWdlLm8gcXhs X2RyYXcubyBxeGxfZGVidWdmcy5vIHF4bF9pcnEubyBxeGxfZHVtYi5vIHF4bF9pb2N0bC5vIHF4 bF9yZWxlYXNlLm8gcXhsX3ByaW1lLm8KK3F4bC15IDo9IHF4bF9kcnYubyBxeGxfa21zLm8gcXhs X2Rpc3BsYXkubyBxeGxfdHRtLm8gcXhsX29iamVjdC5vIHF4bF9nZW0ubyBxeGxfY21kLm8gcXhs X2ltYWdlLm8gcXhsX2RyYXcubyBxeGxfZGVidWdmcy5vIHF4bF9pcnEubyBxeGxfZHVtYi5vIHF4 bF9pb2N0bC5vIHF4bF9yZWxlYXNlLm8gcXhsX3ByaW1lLm8KIAogb2JqLSQoQ09ORklHX0RSTV9R WEwpKz0gcXhsLm8KLS0gCjIuOS4zCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpTcGljZS1kZXZlbCBtYWlsaW5nIGxpc3QKU3BpY2UtZGV2ZWxAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vc3BpY2UtZGV2ZWwK