From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Zimmermann Date: Mon, 14 Oct 2019 14:04:13 +0000 Subject: [PATCH v2 12/15] drm/fbconv: Add helper documentation Message-Id: <20191014140416.28517-13-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 There's now a tutorial on how to create a DRM driver on top of fbconv helpers. The DRM TODO list contains an entry for converting fbdev drivers over to DRM. Signed-off-by: Thomas Zimmermann --- Documentation/gpu/drm-kms-helpers.rst | 12 ++ Documentation/gpu/todo.rst | 15 +++ drivers/gpu/drm/drm_fbconv_helper.c | 181 ++++++++++++++++++++++++++ 3 files changed, 208 insertions(+) diff --git a/Documentation/gpu/drm-kms-helpers.rst b/Documentation/gpu/drm-kms-helpers.rst index 9668a7fe2408..1232a3ef24ff 100644 --- a/Documentation/gpu/drm-kms-helpers.rst +++ b/Documentation/gpu/drm-kms-helpers.rst @@ -411,3 +411,15 @@ SHMEM GEM Helper Reference .. kernel-doc:: drivers/gpu/drm/drm_gem_shmem_helper.c :export: + +fbdev Conversion Helper Reference +================+ +.. kernel-doc:: drivers/gpu/drm/drm_fbconv_helper.c + :doc: fbconv helpers + +.. kernel-doc:: include/drm/drm_fbconv_helper.h + :internal: + +.. kernel-doc:: drivers/gpu/drm/drm_fbconv_helper.c + :export: diff --git a/Documentation/gpu/todo.rst b/Documentation/gpu/todo.rst index 79785559d711..1be44a17f3e8 100644 --- a/Documentation/gpu/todo.rst +++ b/Documentation/gpu/todo.rst @@ -462,3 +462,18 @@ Contact: Sam Ravnborg Outside DRM =====+ +Convert fbdev drivers to DRM +---------------------------- + +There are plenty of fbdev drivers for old hardware. With fbconv helpers, we +have a simple and clean way of transitioning fbdev drivers to DRM. Set up a +simple DRM driver that builds onto the fbconv helpers, copy over the fbdev +driver and connect both. This should result in a basic DRM driver that can +run X11 and Weston. There's a tutorial for this process with example source +code in the fbconv documentation. + +From there, refactor the driver source code into a clean DRM driver that +requires neither fbdev nor fbconv helpers. + +Contact: Thomas Zimmermann diff --git a/drivers/gpu/drm/drm_fbconv_helper.c b/drivers/gpu/drm/drm_fbconv_helper.c index 7d7e4da2a29e..1fa240a4789f 100644 --- a/drivers/gpu/drm/drm_fbconv_helper.c +++ b/drivers/gpu/drm/drm_fbconv_helper.c @@ -18,6 +18,187 @@ #include #include +/** + * DOC: fbconv helpers + * + * The Linux kernel's fbdev subsystem provides a wide range of drivers for + * older graphics hardware. Except for these existng drivers, fbdev is + * deprecated and expected to be removed at some point in the future. All new + * development happens in DRM. Some of the fbdev drivers are worth carrying + * forward. The fbconv helper functions provide a framework for porting fbdev + * drivers to DRM. + * + * When porting over fbdev drivers to DRM, the most significant problem is the + * difference in how the internal driver interfaces work. Fbdev has a single + * function, struct fb_ops.fb_set_par(), to set video mode and framebuffer + * format. DRM use a much more fine-grained interface. In fbdev, framebuffer + * memory is managed by a single client, while in DRM multiple clients can + * hold buffers with framebuffer data. + * + * The fbconv helper library provides a set of data structures and functions + * that connect DRM and fbdev. The resulting DRM driver maps DRM operations + * to fbdev interfaces and uses an fbdev driver for its hardware operations. + * Such a driver is not intended to be merged into DRM as-is. It does, + * however, provide a starting point for refactoring the fbdev driver's + * implementation into first-class DRM code. + * + * As an example, we create a DRM driver from vesafb, fbdev's generic + * vesa driver. We begin by creating a DRM stub driver vesadrm. Please keep + * in mind that the provided code is for illustrative purposes and requires + * error handling. + * + * .. code-block:: c + * + * DEFINE_DRM_GEM_SHMEM_FOPS(vesadrm_file_operations); + * + * static struct drm_driver vesadrm_driver = { + * .major = 1, + * .minor = 0, + * .patchlevel = 0, + * .name = "vesadrm", + * .desc = "DRM VESA driver", + * .date = "01/01/1970", + * .driver_features = DRIVER_ATOMIC | + * DRIVER_GEM | + * DRIVER_MODESET, + * .fops = &vesadrm_file_operations, + * DRM_GEM_SHMEM_DRIVER_OPS, + * }; + * + * Fbconv uses SHMEM, so we set up the structures accordingly. + * + * The fbdev code usually calls register_framebuffer() and + * unregister_framebuffer() to connect and disconnect itself to the fbdev + * core code. In our case, we replace these calls with + * vesadrm_register_framebuffer() and vesadrm_unregister_framebuffer(), which + * serve as entry points for vesafb. + * + * .. code-block:: c + * + * #include + * + * struct vesadrm_device { + * struct drm_device dev; + * struct fb_info *fb_info; + * + * struct drm_fbconv_modeset modeset; + * }; + * + * struct vesadrm_device* vesadrm_register_framebuffer(struct fb_info *fb_info) + * { + * struct vesadrm *vdev; + * + * drm_fbconv_fill_fb_info(fb_info); + * + * vdev = kzalloc(sizeof(*vdev), GFP_KERNEL); + * vesadrm_device_init(vdev, &vesadrm_driver, fb_info) + * + * drm_dev_register(&vdev->dev, 0); + * + * return vdev; + * } + * + * Here, we have the first references to fbconf helpers. The instance + * of struct drm_fbconv_modeset is the central data structure for fbconv. + * Built upon struct drm_simple_display_pipe, it stores most state for the + * DRM driver. + * + * The function vesadrm_register_framebuffer() will later be called by + * vesafb code with the fbdev driver's fb_info structure. In core fbdev, + * register_framebuffer() would fill fb_info with general state and complete + * registration. With fbconv helpers, drm_fbconv_fill_fb_info() does this. + * It's a simplified version of the fbdev setup process, without device file + * creation, registration, or events. No console is created either. + * Finally vesadrm_register_framebuffer() initializes the vesadrm device and + * registers the DRM device. At this point, vesadrm is completely initialized. + * + * For completeness, here's the implementation of + * vesadrm_unregister_framebuffer(), which shuts the device down. + * + * .. code-block:: c + * + * void vesadrm_unregister_framebuffer(struct vesadrm_device *vdev) + * { + * struct fb_info *fb_info = vdev->fb_info; + * + * vesadrm_device_cleanup(vdev); + * kfree(vdev); + * drm_fbconv_cleanup_fb_info(fb_info); + * } + * + * Next we need an implementation of vesadrm_device_init() and + * vesadrm_device_cleanup(). These functions handle the details of + * device configuration and console setup. As all this functionality + * is provided by helpers, the actual implementation is fairly small. + * + * .. code-block:: c + * + * static int vesadrm_device_init(struct vesadrm_device *vdev, + * struct drm_driver *drv, + * struct fb_info *fb_info) + * { + * static const uint32_t formats[] = { + * DRM_FORMAT_XRGB8888, + * DRM_FORMAT_RGB565 + * }; + * static unsigned int max_width = 1600; + * static unsigned int max_height = 1200; + * static unsigned int preferred_depth = 32; + * + * drm_dev_init(&vdev->dev, drv, fb_info->device); + * + * vdev->dev.dev_private = vdev; + * vdev->dev.pdev = container_of(fb_info->device, struct pci_dev, dev); + * vdev->fb_info = fb_info; + * + * drm_fbconv_modeset_init(&vdev->modeset, &vdev->dev, fb_info, + * max_width, max_height, preferred_depth); + * + * drm_fbconv_modeset_setup_pipe(&vdev->modeset, NULL, formats, + * ARRAY_SIZE(formats), NULL, NULL); + * + * drm_fbdev_generic_setup(&vdev->dev, 0); + * + * return 0; + * } + * + * static void vesadrm_device_cleanup(struct vesadrm_device *vdev) + * { + * struct drm_device *dev = &vdev->dev; + * + * drm_fbconv_modeset_cleanup(&vdev->modeset); + * + * drm_dev_fini(dev); + * dev->dev_private = NULL; + * } + * + * In vesadrm_device_init(), several device-specific constants are declared. + * Depending on the hardware, drivers should set them accordingly. + * The call to drm_fbconv_modeset_init() initializes fbconv modesetting + * helpers with these device constants. + * + * The drm_fbconv_modeset_setup_pipe() creates the simple display pipe with + * the specified color formats. By default, everything is set up + * automatically. But the function also accepts format modifiers, a DRM + * connector, and call-back functions for struct drm_simple_display_pipe. + * So each of these can be refactored individually later on. + * + * After setting up the fbconv helpers, there's is a call to + * drm_fbdev_generic_setup(), which set an initial mode and creates a + * framebuffer console. + * + * The implementation of vesadrm_device_cleanup() is the inverse of the + * init function. It cleans up the fbconv modesetting helper and releases + * the DRM device. + * + * What is left is connecting vesafb to vesadrm. As a first step, we need a + * copy the vesafb source files into the vesadrm driver and make them compile. + * Once this is done, we have to replace the call to register_framebuffer() + * with a call to vesadrm_register_framebuffer(), and unregister_framebuffer() + * with vesadrm_unregister_framebuffer(). We have now disconnected vesafb from + * the fbdev core and run it as part of DRM. + */ + /* * Format conversion helpers */ -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Zimmermann Subject: [PATCH v2 12/15] drm/fbconv: Add helper documentation Date: Mon, 14 Oct 2019 16:04:13 +0200 Message-ID: <20191014140416.28517-13-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 3E2B06E2E8 for ; Mon, 14 Oct 2019 14:04:26 +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 VGhlcmUncyBub3cgYSB0dXRvcmlhbCBvbiBob3cgdG8gY3JlYXRlIGEgRFJNIGRyaXZlciBvbiB0 b3Agb2YgZmJjb252CmhlbHBlcnMuIFRoZSBEUk0gVE9ETyBsaXN0IGNvbnRhaW5zIGFuIGVudHJ5 IGZvciBjb252ZXJ0aW5nIGZiZGV2CmRyaXZlcnMgb3ZlciB0byBEUk0uCgpTaWduZWQtb2ZmLWJ5 OiBUaG9tYXMgWmltbWVybWFubiA8dHppbW1lcm1hbm5Ac3VzZS5kZT4KLS0tCiBEb2N1bWVudGF0 aW9uL2dwdS9kcm0ta21zLWhlbHBlcnMucnN0IHwgIDEyICsrCiBEb2N1bWVudGF0aW9uL2dwdS90 b2RvLnJzdCAgICAgICAgICAgIHwgIDE1ICsrKwogZHJpdmVycy9ncHUvZHJtL2RybV9mYmNvbnZf aGVscGVyLmMgICB8IDE4MSArKysrKysrKysrKysrKysrKysrKysrKysrKwogMyBmaWxlcyBjaGFu Z2VkLCAyMDggaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ3B1L2Ry bS1rbXMtaGVscGVycy5yc3QgYi9Eb2N1bWVudGF0aW9uL2dwdS9kcm0ta21zLWhlbHBlcnMucnN0 CmluZGV4IDk2NjhhN2ZlMjQwOC4uMTIzMmEzZWYyNGZmIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0 aW9uL2dwdS9kcm0ta21zLWhlbHBlcnMucnN0CisrKyBiL0RvY3VtZW50YXRpb24vZ3B1L2RybS1r bXMtaGVscGVycy5yc3QKQEAgLTQxMSwzICs0MTEsMTUgQEAgU0hNRU0gR0VNIEhlbHBlciBSZWZl cmVuY2UKIAogLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZ3B1L2RybS9kcm1fZ2VtX3NobWVtX2hl bHBlci5jCiAgICA6ZXhwb3J0OgorCitmYmRldiBDb252ZXJzaW9uIEhlbHBlciBSZWZlcmVuY2UK Kz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorCisuLiBrZXJuZWwtZG9jOjogZHJp dmVycy9ncHUvZHJtL2RybV9mYmNvbnZfaGVscGVyLmMKKyAgIDpkb2M6IGZiY29udiBoZWxwZXJz CisKKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2RybS9kcm1fZmJjb252X2hlbHBlci5oCisgICA6 aW50ZXJuYWw6CisKKy4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2dwdS9kcm0vZHJtX2ZiY29udl9o ZWxwZXIuYworICAgOmV4cG9ydDoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ3B1L3RvZG8u cnN0IGIvRG9jdW1lbnRhdGlvbi9ncHUvdG9kby5yc3QKaW5kZXggNzk3ODU1NTlkNzExLi4xYmU0 NGExN2YzZTggMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ3B1L3RvZG8ucnN0CisrKyBiL0Rv Y3VtZW50YXRpb24vZ3B1L3RvZG8ucnN0CkBAIC00NjIsMyArNDYyLDE4IEBAIENvbnRhY3Q6IFNh bSBSYXZuYm9yZwogCiBPdXRzaWRlIERSTQogPT09PT09PT09PT0KKworQ29udmVydCBmYmRldiBk cml2ZXJzIHRvIERSTQorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitUaGVyZSBhcmUg cGxlbnR5IG9mIGZiZGV2IGRyaXZlcnMgZm9yIG9sZCBoYXJkd2FyZS4gV2l0aCBmYmNvbnYgaGVs cGVycywgd2UKK2hhdmUgYSBzaW1wbGUgYW5kIGNsZWFuIHdheSBvZiB0cmFuc2l0aW9uaW5nIGZi ZGV2IGRyaXZlcnMgdG8gRFJNLiBTZXQgdXAgYQorc2ltcGxlIERSTSBkcml2ZXIgdGhhdCBidWls ZHMgb250byB0aGUgZmJjb252IGhlbHBlcnMsIGNvcHkgb3ZlciB0aGUgZmJkZXYKK2RyaXZlciBh bmQgY29ubmVjdCBib3RoLiBUaGlzIHNob3VsZCByZXN1bHQgaW4gYSBiYXNpYyBEUk0gZHJpdmVy IHRoYXQgY2FuCitydW4gWDExIGFuZCBXZXN0b24uICBUaGVyZSdzIGEgdHV0b3JpYWwgZm9yIHRo aXMgcHJvY2VzcyB3aXRoIGV4YW1wbGUgc291cmNlCitjb2RlIGluIHRoZSBmYmNvbnYgZG9jdW1l bnRhdGlvbi4KKworRnJvbSB0aGVyZSwgcmVmYWN0b3IgdGhlIGRyaXZlciBzb3VyY2UgY29kZSBp bnRvIGEgY2xlYW4gRFJNIGRyaXZlciB0aGF0CityZXF1aXJlcyBuZWl0aGVyIGZiZGV2IG5vciBm YmNvbnYgaGVscGVycy4KKworQ29udGFjdDogVGhvbWFzIFppbW1lcm1hbm4KZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9kcm1fZmJjb252X2hlbHBlci5jIGIvZHJpdmVycy9ncHUvZHJtL2Ry bV9mYmNvbnZfaGVscGVyLmMKaW5kZXggN2Q3ZTRkYTJhMjllLi4xZmEyNDBhNDc4OWYgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fZmJjb252X2hlbHBlci5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9kcm1fZmJjb252X2hlbHBlci5jCkBAIC0xOCw2ICsxOCwxODcgQEAKICNpbmNsdWRl IDxkcm0vZHJtX3Byb2JlX2hlbHBlci5oPgogI2luY2x1ZGUgPGRybS9kcm1fdmJsYW5rLmg+CiAK Ky8qKgorICogRE9DOiBmYmNvbnYgaGVscGVycworICoKKyAqIFRoZSBMaW51eCBrZXJuZWwncyBm YmRldiBzdWJzeXN0ZW0gcHJvdmlkZXMgYSB3aWRlIHJhbmdlIG9mIGRyaXZlcnMgZm9yCisgKiBv bGRlciBncmFwaGljcyBoYXJkd2FyZS4gRXhjZXB0IGZvciB0aGVzZSBleGlzdG5nIGRyaXZlcnMs IGZiZGV2IGlzCisgKiBkZXByZWNhdGVkIGFuZCBleHBlY3RlZCB0byBiZSByZW1vdmVkIGF0IHNv bWUgcG9pbnQgaW4gdGhlIGZ1dHVyZS4gQWxsIG5ldworICogZGV2ZWxvcG1lbnQgaGFwcGVucyBp biBEUk0uIFNvbWUgb2YgdGhlIGZiZGV2IGRyaXZlcnMgYXJlIHdvcnRoIGNhcnJ5aW5nCisgKiBm b3J3YXJkLiBUaGUgZmJjb252IGhlbHBlciBmdW5jdGlvbnMgcHJvdmlkZSBhIGZyYW1ld29yayBm b3IgcG9ydGluZyBmYmRldgorICogZHJpdmVycyB0byBEUk0uCisgKgorICogV2hlbiBwb3J0aW5n IG92ZXIgZmJkZXYgZHJpdmVycyB0byBEUk0sIHRoZSBtb3N0IHNpZ25pZmljYW50IHByb2JsZW0g aXMgdGhlCisgKiBkaWZmZXJlbmNlIGluIGhvdyB0aGUgaW50ZXJuYWwgZHJpdmVyIGludGVyZmFj ZXMgd29yay4gRmJkZXYgaGFzIGEgc2luZ2xlCisgKiBmdW5jdGlvbiwgc3RydWN0IGZiX29wcy5m Yl9zZXRfcGFyKCksIHRvIHNldCB2aWRlbyBtb2RlIGFuZCBmcmFtZWJ1ZmZlcgorICogZm9ybWF0 LiBEUk0gdXNlIGEgbXVjaCBtb3JlIGZpbmUtZ3JhaW5lZCBpbnRlcmZhY2UuIEluIGZiZGV2LCBm cmFtZWJ1ZmZlcgorICogbWVtb3J5IGlzIG1hbmFnZWQgYnkgYSBzaW5nbGUgY2xpZW50LCB3aGls ZSBpbiBEUk0gbXVsdGlwbGUgY2xpZW50cyBjYW4KKyAqIGhvbGQgYnVmZmVycyB3aXRoIGZyYW1l YnVmZmVyIGRhdGEuCisgKgorICogVGhlIGZiY29udiBoZWxwZXIgbGlicmFyeSBwcm92aWRlcyBh IHNldCBvZiBkYXRhIHN0cnVjdHVyZXMgYW5kIGZ1bmN0aW9ucworICogdGhhdCBjb25uZWN0IERS TSBhbmQgZmJkZXYuIFRoZSByZXN1bHRpbmcgRFJNIGRyaXZlciBtYXBzIERSTSBvcGVyYXRpb25z CisgKiB0byBmYmRldiBpbnRlcmZhY2VzIGFuZCB1c2VzIGFuIGZiZGV2IGRyaXZlciBmb3IgaXRz IGhhcmR3YXJlIG9wZXJhdGlvbnMuCisgKiBTdWNoIGEgZHJpdmVyIGlzIG5vdCBpbnRlbmRlZCB0 byBiZSBtZXJnZWQgaW50byBEUk0gYXMtaXMuIEl0IGRvZXMsCisgKiBob3dldmVyLCBwcm92aWRl IGEgc3RhcnRpbmcgcG9pbnQgZm9yIHJlZmFjdG9yaW5nIHRoZSBmYmRldiBkcml2ZXIncworICog aW1wbGVtZW50YXRpb24gaW50byBmaXJzdC1jbGFzcyBEUk0gY29kZS4KKyAqCisgKiBBcyBhbiBl eGFtcGxlLCB3ZSBjcmVhdGUgYSBEUk0gZHJpdmVyIGZyb20gdmVzYWZiLCBmYmRldidzIGdlbmVy aWMKKyAqIHZlc2EgZHJpdmVyLiBXZSBiZWdpbiBieSBjcmVhdGluZyBhIERSTSBzdHViIGRyaXZl ciB2ZXNhZHJtLiBQbGVhc2Uga2VlcAorICogaW4gbWluZCB0aGF0IHRoZSBwcm92aWRlZCBjb2Rl IGlzIGZvciBpbGx1c3RyYXRpdmUgcHVycG9zZXMgYW5kIHJlcXVpcmVzCisgKiBlcnJvciBoYW5k bGluZy4KKyAqCisgKiAuLiBjb2RlLWJsb2NrOjogYworICoKKyAqCURFRklORV9EUk1fR0VNX1NI TUVNX0ZPUFModmVzYWRybV9maWxlX29wZXJhdGlvbnMpOworICoKKyAqCXN0YXRpYyBzdHJ1Y3Qg ZHJtX2RyaXZlciB2ZXNhZHJtX2RyaXZlciA9IHsKKyAqCQkubWFqb3IgPSAxLAorICoJCS5taW5v ciA9IDAsCisgKgkJLnBhdGNobGV2ZWwgPSAwLAorICoJCS5uYW1lID0gInZlc2Fkcm0iLAorICoJ CS5kZXNjID0gIkRSTSBWRVNBIGRyaXZlciIsCisgKgkJLmRhdGUgPSAiMDEvMDEvMTk3MCIsCisg KgkJLmRyaXZlcl9mZWF0dXJlcyA9IERSSVZFUl9BVE9NSUMgfAorICoJCQkJICAgRFJJVkVSX0dF TSB8CisgKgkJCQkgICBEUklWRVJfTU9ERVNFVCwKKyAqCQkuZm9wcyA9ICZ2ZXNhZHJtX2ZpbGVf b3BlcmF0aW9ucywKKyAqCQlEUk1fR0VNX1NITUVNX0RSSVZFUl9PUFMsCisgKgl9OworICoKKyAq IEZiY29udiB1c2VzIFNITUVNLCBzbyB3ZSBzZXQgdXAgdGhlIHN0cnVjdHVyZXMgYWNjb3JkaW5n bHkuCisgKgorICogVGhlIGZiZGV2IGNvZGUgdXN1YWxseSBjYWxscyByZWdpc3Rlcl9mcmFtZWJ1 ZmZlcigpIGFuZAorICogdW5yZWdpc3Rlcl9mcmFtZWJ1ZmZlcigpIHRvIGNvbm5lY3QgYW5kIGRp c2Nvbm5lY3QgaXRzZWxmIHRvIHRoZSBmYmRldgorICogY29yZSBjb2RlLiBJbiBvdXIgY2FzZSwg d2UgcmVwbGFjZSB0aGVzZSBjYWxscyB3aXRoCisgKiB2ZXNhZHJtX3JlZ2lzdGVyX2ZyYW1lYnVm ZmVyKCkgYW5kIHZlc2Fkcm1fdW5yZWdpc3Rlcl9mcmFtZWJ1ZmZlcigpLCB3aGljaAorICogc2Vy dmUgYXMgZW50cnkgcG9pbnRzIGZvciB2ZXNhZmIuCisgKgorICogLi4gY29kZS1ibG9jazo6IGMK KyAqCisgKgkjaW5jbHVkZSA8ZHJtL2RybS9mYmNvbnZfaGVscGVyLmg+CisgKgorICoJc3RydWN0 IHZlc2Fkcm1fZGV2aWNlIHsKKyAqCQlzdHJ1Y3QgZHJtX2RldmljZSBkZXY7CisgKgkJc3RydWN0 IGZiX2luZm8gKmZiX2luZm87CisgKgorICoJCXN0cnVjdCBkcm1fZmJjb252X21vZGVzZXQgbW9k ZXNldDsKKyAqCX07CisgKgorICoJc3RydWN0IHZlc2Fkcm1fZGV2aWNlKiB2ZXNhZHJtX3JlZ2lz dGVyX2ZyYW1lYnVmZmVyKHN0cnVjdCBmYl9pbmZvICpmYl9pbmZvKQorICoJeworICoJCXN0cnVj dCB2ZXNhZHJtICp2ZGV2OworICoKKyAqCQlkcm1fZmJjb252X2ZpbGxfZmJfaW5mbyhmYl9pbmZv KTsKKyAqCisgKgkJdmRldiA9IGt6YWxsb2Moc2l6ZW9mKCp2ZGV2KSwgR0ZQX0tFUk5FTCk7Cisg KgkJdmVzYWRybV9kZXZpY2VfaW5pdCh2ZGV2LCAmdmVzYWRybV9kcml2ZXIsIGZiX2luZm8pCisg KgorICoJCWRybV9kZXZfcmVnaXN0ZXIoJnZkZXYtPmRldiwgMCk7CisgKgorICoJCXJldHVybiB2 ZGV2OworICoJfQorICoKKyAqIEhlcmUsIHdlIGhhdmUgdGhlIGZpcnN0IHJlZmVyZW5jZXMgdG8g ZmJjb25mIGhlbHBlcnMuIFRoZSBpbnN0YW5jZQorICogb2Ygc3RydWN0IGRybV9mYmNvbnZfbW9k ZXNldCBpcyB0aGUgY2VudHJhbCBkYXRhIHN0cnVjdHVyZSBmb3IgZmJjb252LgorICogQnVpbHQg dXBvbiBzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUsIGl0IHN0b3JlcyBtb3N0IHN0YXRl IGZvciB0aGUKKyAqIERSTSBkcml2ZXIuCisgKgorICogVGhlIGZ1bmN0aW9uIHZlc2Fkcm1fcmVn aXN0ZXJfZnJhbWVidWZmZXIoKSB3aWxsIGxhdGVyIGJlIGNhbGxlZCBieQorICogdmVzYWZiIGNv ZGUgd2l0aCB0aGUgZmJkZXYgZHJpdmVyJ3MgZmJfaW5mbyBzdHJ1Y3R1cmUuIEluIGNvcmUgZmJk ZXYsCisgKiByZWdpc3Rlcl9mcmFtZWJ1ZmZlcigpIHdvdWxkIGZpbGwgZmJfaW5mbyB3aXRoIGdl bmVyYWwgc3RhdGUgYW5kIGNvbXBsZXRlCisgKiByZWdpc3RyYXRpb24uIFdpdGggZmJjb252IGhl bHBlcnMsIGRybV9mYmNvbnZfZmlsbF9mYl9pbmZvKCkgZG9lcyB0aGlzLgorICogSXQncyBhIHNp bXBsaWZpZWQgdmVyc2lvbiBvZiB0aGUgZmJkZXYgc2V0dXAgcHJvY2Vzcywgd2l0aG91dCBkZXZp Y2UgZmlsZQorICogY3JlYXRpb24sIHJlZ2lzdHJhdGlvbiwgb3IgZXZlbnRzLiBObyBjb25zb2xl IGlzIGNyZWF0ZWQgZWl0aGVyLgorICogRmluYWxseSB2ZXNhZHJtX3JlZ2lzdGVyX2ZyYW1lYnVm ZmVyKCkgaW5pdGlhbGl6ZXMgdGhlIHZlc2Fkcm0gZGV2aWNlIGFuZAorICogcmVnaXN0ZXJzIHRo ZSBEUk0gZGV2aWNlLiBBdCB0aGlzIHBvaW50LCB2ZXNhZHJtIGlzIGNvbXBsZXRlbHkgaW5pdGlh bGl6ZWQuCisgKgorICogRm9yIGNvbXBsZXRlbmVzcywgaGVyZSdzIHRoZSBpbXBsZW1lbnRhdGlv biBvZgorICogdmVzYWRybV91bnJlZ2lzdGVyX2ZyYW1lYnVmZmVyKCksIHdoaWNoIHNodXRzIHRo ZSBkZXZpY2UgZG93bi4KKyAqCisgKiAuLiBjb2RlLWJsb2NrOjogYworICoKKyAqCXZvaWQgdmVz YWRybV91bnJlZ2lzdGVyX2ZyYW1lYnVmZmVyKHN0cnVjdCB2ZXNhZHJtX2RldmljZSAqdmRldikK KyAqCXsKKyAqCQlzdHJ1Y3QgZmJfaW5mbyAqZmJfaW5mbyA9IHZkZXYtPmZiX2luZm87CisgKgor ICoJCXZlc2Fkcm1fZGV2aWNlX2NsZWFudXAodmRldik7CisgKgkJa2ZyZWUodmRldik7CisgKgkJ ZHJtX2ZiY29udl9jbGVhbnVwX2ZiX2luZm8oZmJfaW5mbyk7CisgKgl9CisgKgorICogTmV4dCB3 ZSBuZWVkIGFuIGltcGxlbWVudGF0aW9uIG9mIHZlc2Fkcm1fZGV2aWNlX2luaXQoKSBhbmQKKyAq IHZlc2Fkcm1fZGV2aWNlX2NsZWFudXAoKS4gVGhlc2UgZnVuY3Rpb25zIGhhbmRsZSB0aGUgZGV0 YWlscyBvZgorICogZGV2aWNlIGNvbmZpZ3VyYXRpb24gYW5kIGNvbnNvbGUgc2V0dXAuIEFzIGFs bCB0aGlzIGZ1bmN0aW9uYWxpdHkKKyAqIGlzIHByb3ZpZGVkIGJ5IGhlbHBlcnMsIHRoZSBhY3R1 YWwgaW1wbGVtZW50YXRpb24gaXMgZmFpcmx5IHNtYWxsLgorICoKKyAqIC4uIGNvZGUtYmxvY2s6 OiBjCisgKgorICoJc3RhdGljIGludCB2ZXNhZHJtX2RldmljZV9pbml0KHN0cnVjdCB2ZXNhZHJt X2RldmljZSAqdmRldiwKKyAqCQkJCSAgICAgICBzdHJ1Y3QgZHJtX2RyaXZlciAqZHJ2LAorICoJ CQkJICAgICAgIHN0cnVjdCBmYl9pbmZvICpmYl9pbmZvKQorICoJeworICoJCXN0YXRpYyBjb25z dCB1aW50MzJfdCBmb3JtYXRzW10gPSB7CisgKgkJCURSTV9GT1JNQVRfWFJHQjg4ODgsCisgKgkJ CURSTV9GT1JNQVRfUkdCNTY1CisgKgkJfTsKKyAqCQlzdGF0aWMgdW5zaWduZWQgaW50IG1heF93 aWR0aCA9IDE2MDA7CisgKgkJc3RhdGljIHVuc2lnbmVkIGludCBtYXhfaGVpZ2h0ID0gMTIwMDsK KyAqCQlzdGF0aWMgdW5zaWduZWQgaW50IHByZWZlcnJlZF9kZXB0aCA9IDMyOworICoKKyAqCQlk cm1fZGV2X2luaXQoJnZkZXYtPmRldiwgZHJ2LCBmYl9pbmZvLT5kZXZpY2UpOworICoKKyAqCQl2 ZGV2LT5kZXYuZGV2X3ByaXZhdGUgPSB2ZGV2OworICoJCXZkZXYtPmRldi5wZGV2ID0gY29udGFp bmVyX29mKGZiX2luZm8tPmRldmljZSwgc3RydWN0IHBjaV9kZXYsIGRldik7CisgKgkJdmRldi0+ ZmJfaW5mbyA9IGZiX2luZm87CisgKgorICoJCWRybV9mYmNvbnZfbW9kZXNldF9pbml0KCZ2ZGV2 LT5tb2Rlc2V0LCAmdmRldi0+ZGV2LCBmYl9pbmZvLAorICoJCQkJCW1heF93aWR0aCwgbWF4X2hl aWdodCwgcHJlZmVycmVkX2RlcHRoKTsKKyAqCisgKgkJZHJtX2ZiY29udl9tb2Rlc2V0X3NldHVw X3BpcGUoJnZkZXYtPm1vZGVzZXQsIE5VTEwsIGZvcm1hdHMsCisgKgkJCQkJICAgICAgQVJSQVlf U0laRShmb3JtYXRzKSwgTlVMTCwgTlVMTCk7CisgKgorICoJCWRybV9mYmRldl9nZW5lcmljX3Nl dHVwKCZ2ZGV2LT5kZXYsIDApOworICoKKyAqCQlyZXR1cm4gMDsKKyAqCX0KKyAqCisgKglzdGF0 aWMgdm9pZCB2ZXNhZHJtX2RldmljZV9jbGVhbnVwKHN0cnVjdCB2ZXNhZHJtX2RldmljZSAqdmRl dikKKyAqCXsKKyAqCQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gJnZkZXYtPmRldjsKKyAqCisg KgkJZHJtX2ZiY29udl9tb2Rlc2V0X2NsZWFudXAoJnZkZXYtPm1vZGVzZXQpOworICoKKyAqCQlk cm1fZGV2X2ZpbmkoZGV2KTsKKyAqCQlkZXYtPmRldl9wcml2YXRlID0gTlVMTDsKKyAqCX0KKyAq CisgKiBJbiB2ZXNhZHJtX2RldmljZV9pbml0KCksIHNldmVyYWwgZGV2aWNlLXNwZWNpZmljIGNv bnN0YW50cyBhcmUgZGVjbGFyZWQuCisgKiBEZXBlbmRpbmcgb24gdGhlIGhhcmR3YXJlLCBkcml2 ZXJzIHNob3VsZCBzZXQgdGhlbSBhY2NvcmRpbmdseS4KKyAqIFRoZSBjYWxsIHRvIGRybV9mYmNv bnZfbW9kZXNldF9pbml0KCkgaW5pdGlhbGl6ZXMgZmJjb252IG1vZGVzZXR0aW5nCisgKiBoZWxw ZXJzIHdpdGggdGhlc2UgZGV2aWNlIGNvbnN0YW50cy4KKyAqCisgKiBUaGUgZHJtX2ZiY29udl9t b2Rlc2V0X3NldHVwX3BpcGUoKSBjcmVhdGVzIHRoZSBzaW1wbGUgZGlzcGxheSBwaXBlIHdpdGgK KyAqIHRoZSBzcGVjaWZpZWQgY29sb3IgZm9ybWF0cy4gQnkgZGVmYXVsdCwgZXZlcnl0aGluZyBp cyBzZXQgdXAKKyAqIGF1dG9tYXRpY2FsbHkuIEJ1dCB0aGUgZnVuY3Rpb24gYWxzbyBhY2NlcHRz IGZvcm1hdCBtb2RpZmllcnMsIGEgRFJNCisgKiBjb25uZWN0b3IsIGFuZCBjYWxsLWJhY2sgZnVu Y3Rpb25zIGZvciBzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUuCisgKiBTbyBlYWNoIG9m IHRoZXNlIGNhbiBiZSByZWZhY3RvcmVkIGluZGl2aWR1YWxseSBsYXRlciBvbi4KKyAqCisgKiBB ZnRlciBzZXR0aW5nIHVwIHRoZSBmYmNvbnYgaGVscGVycywgdGhlcmUncyBpcyBhIGNhbGwgdG8K KyAqIGRybV9mYmRldl9nZW5lcmljX3NldHVwKCksIHdoaWNoIHNldCBhbiBpbml0aWFsIG1vZGUg YW5kIGNyZWF0ZXMgYQorICogZnJhbWVidWZmZXIgY29uc29sZS4KKyAqCisgKiBUaGUgaW1wbGVt ZW50YXRpb24gb2YgdmVzYWRybV9kZXZpY2VfY2xlYW51cCgpIGlzIHRoZSBpbnZlcnNlIG9mIHRo ZQorICogaW5pdCBmdW5jdGlvbi4gSXQgY2xlYW5zIHVwIHRoZSBmYmNvbnYgbW9kZXNldHRpbmcg aGVscGVyIGFuZCByZWxlYXNlcworICogdGhlIERSTSBkZXZpY2UuCisgKgorICogV2hhdCBpcyBs ZWZ0IGlzIGNvbm5lY3RpbmcgdmVzYWZiIHRvIHZlc2Fkcm0uIEFzIGEgZmlyc3Qgc3RlcCwgd2Ug bmVlZCBhCisgKiBjb3B5IHRoZSB2ZXNhZmIgc291cmNlIGZpbGVzIGludG8gdGhlIHZlc2Fkcm0g ZHJpdmVyIGFuZCBtYWtlIHRoZW0gY29tcGlsZS4KKyAqIE9uY2UgdGhpcyBpcyBkb25lLCB3ZSBo YXZlIHRvIHJlcGxhY2UgdGhlIGNhbGwgdG8gcmVnaXN0ZXJfZnJhbWVidWZmZXIoKQorICogd2l0 aCBhIGNhbGwgdG8gdmVzYWRybV9yZWdpc3Rlcl9mcmFtZWJ1ZmZlcigpLCBhbmQgdW5yZWdpc3Rl cl9mcmFtZWJ1ZmZlcigpCisgKiB3aXRoIHZlc2Fkcm1fdW5yZWdpc3Rlcl9mcmFtZWJ1ZmZlcigp LiBXZSBoYXZlIG5vdyBkaXNjb25uZWN0ZWQgdmVzYWZiIGZyb20KKyAqIHRoZSBmYmRldiBjb3Jl IGFuZCBydW4gaXQgYXMgcGFydCBvZiBEUk0uCisgKi8KKwogLyoKICAqIEZvcm1hdCBjb252ZXJz aW9uIGhlbHBlcnMKICAqLwotLSAKMi4yMy4wCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0 cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9s aXN0aW5mby9kcmktZGV2ZWw=