DOCSLIB.ORG

Creating Digital Products Part 2 : Software

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Creating Digital Products Part 2 : Software Cambridge Game Creators London – 2015-05-21 Laurent Pinchart [email protected] Problem Definition Problem Definition Problem Definition Linux System Boot Loader Up & Running Kernel Initialization 0 1 4 15 time Graphics Use Cases Fixed Logo Boot Loader Fixed Logo Linux Kernel Animation, Feedback System Initialization Full Graphics Stack Up & Running Traditional Linux Graphics Architecture Qt GTK+ EFL Apps Xlib Xorg X server DDX Mesa 3D libdrm FBDEV DRM/KMS Kernel Hardware X11 Graphics Stack ● DDX – Device Dependent X driver. Handles initialization, manages the display, performs 2D accelerated rendering. ● DRM – Direct Rendering Manager. Subsystem of the Linux kernel responsible for interfacing with GPUs. ● EFL, GTK+, Qt – Open-source graphical toolkits. ● EGL – Interface between rendering APIs and the underlying native platform windowing system. ● FBDEV – Frame Buffer Device. Subsystem of the Linux kernel responsible for accessing the display framebuffer. ● GLES – GL Embedded System. Embedded profile of the OpenGL API. ● KMS – Kernel Mode Setting. Subsystem of the Linux kernel responsible for interfacing with display controllers. Handles mode setting and hardware composition. ● Mesa (3D) – Open-source implementation of the EGL, GL, GLES, … APIs. ● Xlib – Reference implementation of the client side of the X11 protocol. ● Xorg – Reference implementation of the server side of the system. Acronyms X11 Client . X11 Client Compositor X Server FBDEV evdev DRM/KMS X11 Composition X11 Client . X11 Client Compositor X Server 1 FBDEV evdev DRM/KMS X11 Composition X11 Client . X11 Client 2 3 Compositor X Server 1 FBDEV evdev DRM/KMS X11 Composition X11 Client . X11 Client 2 3 4 Compositor X Server 1 FBDEV evdev DRM/KMS X11 Composition X11 Client . X11 Client 2 3 4 Compositor 5 X Server 1 FBDEV evdev DRM/KMS X11 Composition X11 Client . X11 Client 2 3 4 Compositor 5 X Server 1 6 FBDEV evdev DRM/KMS X11 Composition Linux Kernel Display APIs FBDEV vs. DRM APIs Frame Buffer Display (memory) Device Device Model – FBDEV Planes CRTC Encoder Connector (memory) Device Model – DRM/KMS Source: http://xkcd.com/619/ Features DRM FB Dynamic Allocation Yes No Multiple Buffers Yes panning Import dmabuf No dmabuf Export mmap mmap Memory Management DRM FB RGB Formats 4CC 4CC Enumeration Planes No Negotiation No No Atomicity Yes No Mode Setting DRM FB Overlays Yes No Rotation Yes No Scaling Yes No Cropping/Panning Yes Yes Transformations DRM, Linux 2.2.18 2000 Activity – DRM/KMS GEM 2008 KMS, TTM 2009 Dumb Buffers 2011 Planes, DMABUF 2012 Atomic mode setting 2013-... Sync & fences FBDEV, Linux 1.3.94 1996 Blanking 2000 Activity – FBDEV 4CC Formats 2012 4CC Formats 2012 Activity – FBDEV Source: http://valdodge.com/2010/07/ 3000 2500 2000 1500 drm fb drm+bug 1000 500 0 Mailing List Traffic 2000 1800 1600 1400 1200 drm 1000 fb 800 600 400 200 fb 0 drm Cumulative Changes - API 70000 60000 50000 40000 drm fb 30000 20000 10000 fb 0 drm Cumulative Changes - Core 1800000 1600000 1400000 1200000 1000000 drm 800000 fb 600000 400000 200000 fb 0 drm Cumulative Changes - Drivers Source: http://xkcd.com/927/ Use Cases Use Cases - FBDEV (that's it...) Use Cases - FBDEV Everything Use Cases – DRM/KMS Beyond X11 X11 Client . X11 Client 2 3 4 Compositor 5 X Server 1 6 DRM/KMS evdev FBDEV X11 Composition by Shmuel Csaba Otto Traian; GNU FDL 1.2+ and CC-BY-SA 3.0+; created 2013-08-28; updated 2014-02-27 GNOME Video Clutter 1.17.4 W2EGL EGL glue libwayland-client code Inkscape GTK+ 3.12 W2EGL EGL glue libwayland-client code KDE Plasma Qt 5.3 W2EGL EGL glue libwayland-client code EGL libwayland-server Wayland Compositor libwayland-EGL libEGL-mesa-drivers Weston, Mutter, KWin, Clayland, libEGL-mesa EGL libGBM Enlightenment, ... D 3 OpenGL|ES libGLES-mesa libOpenVG-mesa libinput a OpenVG s e M Graphics device drivers libGL-mesa-DRI ① ④ ioctl libDRM evdev KMS DRM Kernel CPU & main memory USB, PS/2, ... GPU & graphic memory framebuffer Wayland Graphics Stack Wayland Wayland Client . Client 2 3 Wayland Compositor 1 4 evdev DRM/KMS Wayland Composition Single GUI Application Toolkit (Qt, SDL, ...) DRM/KMS evdev FBDEV Custom Application The DRM and KMS APIs DRM ? KMS APIs ● Memory Management ● Command Stream ● Vertical Blanking ● Version, Authentication, Master, ... DRM ● Device Model ● Frame Buffer ● Modes ● Page Flip ● Planes ● Cursor, Gamma, ... KMS drm kms armada exynos i810 i915 mga msm nouveau omap qxl r128 radeon savage sis tegra via DRM/KMS API Planes CRTC Encoder Connector (memory) Connector Encoder Connector Device Model Planes CRTC Encoder Connector (memory) Encoder Connector Memory SoC Off-Chip Device Model - SoC Frame Buffer KMS – Scanout Root Plane Composition Overlay Plane(s) KMS – Composition Frame Buffer ● width ● height GEM ● format Object(s) ● pitches CRTC ● offsets Memory Properties KMS – Frame Buffer Frame Buffer GEM Object ● width ● height CRTC ● bpp Memory ● pitch ● size Properties DRM/KMS – GEM Object Process A Process B 3 Send FD SCM_RIGHTS Local Global Global Local 1 2 4 Handle FD FD Handle GEM Object DRM – Handles sync back porch active area Active Area front porch KMS – Modes (1/2) hdisplay hsync_start hsync_end htotal sync back porch active area Active Area front porch KMS – Modes (2/2) fb x mode m o d e . Active v y d i Area s p crtc l a y mode.hdisplay *connectors struct drm_mode_set { num_connectors struct drm_framebuffer *fb; struct drm_crtc *crtc; struct drm_display_mode *mode; uint32_t x; uint32_t y; struct drm_connector **connectors; size_t num_connectors; }; KMS – Mode Setting KMS Programming Example Code Ahead Error handling omitted for readability Disclaimer #include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> int main(int argc, char **argv) { return 0; } Skeleton /* * Open * * #include <xf86drm.h> * * int drmOpen(const char *name, const char *busid); */ int fd; fd = drmOpen("imx-drm", NULL); Open /* * Get resources * * #include <xf86drmMode.h> * * drmModeResPtr drmModeGetResources(int fd); * void drmModeFreeResources(drmModeResPtr ptr); */ drmModeResPtr resources; uint32_t crtc_id; uint32_t connector_id; resources = drmModeGetResources(fd); crtc_id = resources->crtcs[0]; connector_id = resources->connectors[0]; Get Resources /* * Get modes * * #include <xf86drmMode.h> * * drmModeConnectorPtr drmModeGetConnector(int fd, * uint32_t connectorId); * void drmModeFreeConnector(drmModeConnectorPtr ptr); */ drmModeConnectorPtr connector; drmModeModeInfo mode; uint32_t width; uint32_t height; connector = drmModeGetConnector(fd, connector_id); mode = connector->modes[0]; width = mode.hdisplay; height = mode.vdisplay; Get Modes /* * Create buffer * * #include <drm.h> * #include <drm_mode.h> * * #define DRM_IOCTL_MODE_CREATE_DUMB ... * * int drmIoctl(int fd, unsigned long request, void *arg); */ struct drm_mode_create_dumb bo_create; memset(&bo_create, 0, sizeof(bo_create)); bo_create.bpp = 32; bo_create.width = width; bo_create.height = height; drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &bo_create); Create Buffer /* * Fill buffer * * #include <drm.h> * #include <drm_mode.h> * #include <xf86drm.h> * * #define DRM_IOCTL_MODE_MAP_DUMB ... * * int drmIoctl(int fd, unsigned long request, void *arg); */ struct drm_mode_map_dumb bo_map; memset(&bo_map, 0, sizeof(bo_map)); bo_map.handle = bo_create.handle; drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &bo_map); Fill Buffer (1/2) /* * Fill buffer * * #include <sys/mman.h> * * void *mmap(void *addr, size_t length, int prot, * int flags, int fd, off_t offset) * int munmap(void *addr, size_t length); */ void *mem; mem = mmap(0, bo_create.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, bo_map.offset); fill_pattern(DRM_FORMAT_ARGB8888, mem, width, height, bo_create.pitch); munmap(mem, bo_create.size); Fill Buffer (2/2) /* * Create frame buffer * * #include <drm_fourcc.h> * #include <xf86drmMode.h> * * int drmModeAddFB2(int fd, uint32_t width, * uint32_t height, uint32_t pixel_format, * uint32_t bo_handles[4], uint32_t pitches[4], * uint32_t offsets[4], uint32_t *buf_id, * uint32_t flags); */ uint32_t handles[4] = { bo_create.handle, }; uint32_t pitches[4] = { bo_create.pitch, }; uint32_t offsets[4] = { 0, }; uint32_t fb_id; drmModeAddFB2(fd, width, height, DRM_FORMAT_ARGB8888, handles, pitches, offsets, &fb_id, 0); Create Frame Buffer /* * Set the mode * * #include <xf86drmMode.h> * * int drmModeSetCrtc(int fd, uint32_t crtcId, * uint32_t bufferId, uint32_t x, uint32_t y, * uint32_t *connectors, int count, * drmModeModeInfoPtr mode); */ drmModeSetCrtc(fd, crtc_id, fb_id, 0, 0, &connector_id, 1, &mode); Set the Mode /* * Get plane resources * * #include <xf86drmMode.h> * * drmModePlaneResPtr drmModeGetPlaneResources(int fd); * void drmModeFreePlaneResources(drmModePlaneResPtr ptr); */ drmModePlaneResPtr planes; uint32_t plane_id; planes = drmModeGetPlaneResources(fd); plane_id = planes->planes[0]; Get Plane Resources /* * Set the plane * * #include <xf86drmMode.h> * * int drmModeSetPlane(int fd, * uint32_t plane_id, uint32_t crtc_id, * uint32_t fb_id, uint32_t flags, * uint32_t crtc_x, uint32_t crtc_y, * uint32_t crtc_w, uint32_t crtc_h, * uint32_t src_x, uint32_t src_y, * uint32_t src_w, uint32_t src_h); */ drmModeSetPlane(fd, plane_id, crtc_id, fb_id, 0, width / 4, height / 4, width / 2, height / 2, 0, 0, (width / 2) << 16, (height / 2) << 16); Set the Plane /* * List plane properties * * #include <drm_mode.h> * #include <xf86drmMode.h> * * drmModeObjectPropertiesPtr drmModeObjectGetProperties( * int fd, uint32_t object_id, uint32_t object_type);
Recommended publications
  • GLSL 4.50 Spec

    GLSL 4.50 Spec

    The OpenGL® Shading Language Language Version: 4.50 Document Revision: 7 09-May-2017 Editor: John Kessenich, Google Version 1.1 Authors: John Kessenich, Dave Baldwin, Randi Rost Copyright (c) 2008-2017 The Khronos Group Inc. All Rights Reserved. This specification is protected by copyright laws and contains material proprietary to the Khronos Group, Inc. It or any components may not be reproduced, republished, distributed, transmitted, displayed, broadcast, or otherwise exploited in any manner without the express prior written permission of Khronos Group. You may use this specification for implementing the functionality therein, without altering or removing any trademark, copyright or other notice from the specification, but the receipt or possession of this specification does not convey any rights to reproduce, disclose, or distribute its contents, or to manufacture, use, or sell anything that it may describe, in whole or in part. Khronos Group grants express permission to any current Promoter, Contributor or Adopter member of Khronos to copy and redistribute UNMODIFIED versions of this specification in any fashion, provided that NO CHARGE is made for the specification and the latest available update of the specification for any version of the API is used whenever possible. Such distributed specification may be reformatted AS LONG AS the contents of the specification are not changed in any way. The specification may be incorporated into a product that is sold as long as such product includes significant independent work developed by the seller. A link to the current version of this specification on the Khronos Group website should be included whenever possible with specification distributions.
  • Reverse Engineering Power Management on NVIDIA Gpus - Anatomy of an Autonomic-Ready System Martin Peres

    Reverse Engineering Power Management on NVIDIA Gpus - Anatomy of an Autonomic-Ready System Martin Peres

    Reverse Engineering Power Management on NVIDIA GPUs - Anatomy of an Autonomic-ready System Martin Peres To cite this version: Martin Peres. Reverse Engineering Power Management on NVIDIA GPUs - Anatomy of an Autonomic-ready System. ECRTS, Operating Systems Platforms for Embedded Real-Time appli- cations 2013, Jul 2013, Paris, France. hal-00853849 HAL Id: hal-00853849 https://hal.archives-ouvertes.fr/hal-00853849 Submitted on 23 Aug 2013 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Reverse engineering power management on NVIDIA GPUs - Anatomy of an autonomic-ready system Martin Peres Ph.D. student at LaBRI University of Bordeaux Hobbyist Linux/Nouveau Developer Email: [email protected] Abstract—Research in power management is currently limited supported nor documented by NVIDIA. As GPUs are leading by the fact that companies do not release enough documentation the market in terms of performance-per-Watt [3], they are or interfaces to fully exploit the potential found in modern a good candidate for a reverse engineering effort of their processors. This problem is even more present in GPUs despite power management features. The choice of reverse engineering having the highest performance-per-Watt ratio found in today’s NVIDIA’s power management features makes sense as they processors.
  • High Speed Visualization in the Jetos Aviation Operating System Using Hardware Acceleration*

    High Speed Visualization in the Jetos Aviation Operating System Using Hardware Acceleration*

    High Speed Visualization in the JetOS Aviation Operating System Using Hardware Acceleration* Boris Barladian[0000-0002-2391-2067], Nikolay Deryabin[0000-0003-1248-6047], Alexey Voloboy[0000-0003-1252-8294], Vladimir Galaktionov[0000-0001-6460-7539], and Lev Shapiro[0000-0002-6350-851X] The Keldysh Institute of the Applied Mathematics of RAS, Moscow, Russia [email protected],{voloboy, vlgal, pls}@gin.keldysh.ru Abstract. The paper discusses details of the pilot display visualization that uses the hardware acceleration capabilities of the Vivante graphics processor in the JetOS aviation operating system. Previously the OpenGL Safety Critical library was implemented without hardware acceleration. This was done in such a way because software library is easier to certify in accordance with the avionics re- quirements. But usage of the software OpenGL does not provide acceptable visualization speed for modern Flight Display and 3D relief applications. So more complex visualization approach utilized the GPU acceleration capabilities was elaborated. Although the OpenGL library was implemented for a specific GPU and took into account its specificity, the described approach to adapt the MESA open source library can be used for other GPUs. An effective algorithm for multi-window visualization using the implemented library with hardware acceleration is present. The described approach allows you to achieve the visu- alization speed acceptable for the pilot display of the aircraft. Keywords: Pilot Display, Embedded Systems, Real-time Operating System, OpenGL Safety Critical, Multi-windowing. 1 Introduction In [1] requirements were formulated for a real-time operating system (RTOS) de- signed to work with integrated modular avionics. In particular, the RTOS should comply with the ARINC 653 standard [2].
  • Porting Tizen-IVI 3.0 to an ARM Based Soc Platform

    Porting Tizen-IVI 3.0 to an ARM Based Soc Platform

    Porting Tizen-IVI 3.0 to an ARM based SoC Platform Damian Hobson-Garcia Automotive Linux Summit July 1-2, 2014 Tokyo, Japan Tizen IVI support Until recently… Intel architecture (x86) system – Tizen IVI 2.0alpha, Tizen IVI 3.0 ARM architecture based system – Tizen IVI 2.0alpha (ivi-panda) Need to port Tizen IVI 3.0 to ARM ourselves Current State of Affairs Intel architecture (x86) system – Tizen IVI 2.0alpha, Tizen IVI 3.0 – Tizen Common NEW ARM architecture based system – Tizen IVI 2.0alpha (ivi-panda) – Tizen Common NEW Tizen IVI now based on Tizen Common – Lots of reuse Target Platform Renesas R-Car Gen2 series platform R-Car M2 – ARM Cortex A15 x2 R-Car H2 – ARM Cortex A15 x4, + ARM Cortex A7 x4 (option) 3D Graphics System – Imagination Technologies PowerVR series On board IP blocks – H/W video decode/encode – image processing Agenda Objective Methodology Porting Tasks – Weston/Wayland Integration – WebKit Integration – GStreamer Integration Objective Tizen IVI 3.0 on R-Car M2/H2 1. Standard Native Applications – Terminal program – Open GL/ES applications 2. Web – Browser and web applications 3. Multimedia – Video playback (1080p @ 30fps) Local Build Methodology Tizen IVI 3.0 milestone releases we used: – M2-Sep (released Oct 11, 2013) – M2-EOY (released Jan 15, 2014) – M2-March2014 (released April 11, 2014) Non-hardware dependant packages – Rebuild for ARM instruction set Hardware dependant packages – Replace/update with R-Car M2/H2 support Tizen Common/IVI Rebase Methodology Reuse Tizen Common ARM support for Tizen
  • Ati Driver Freebsd

    Ati Driver Freebsd

    Ati driver freebsd Hey, I`m new to teh the bsd *BSD world and just installed Freebsd FreeBSD. Only thing missing is my video driver. ATI Radeon X How to Solved - Switch between ATI and VESA drivers? If you want to automatically load a video driver at boot time, we recommend to do it from /etc/:Radeon​: ​ It allows the use of newer xfvideo-ati drivers and AMD GPUs. This project started in January Initial radeon code comes from Linux. EndSection DESCRIPTION radeon is an Xorg driver for ATI/AMD RADEON-based video cards with the following features: o Full support for 8-, , and. This package contains the xfvideo-ati driver. xdrivers/drm-kmod: Port for the DRM kernel drivers for FreeBSD This port. If I boot X11 with no or with ati driver, the system stops responding, although cursor continues to follow mouse movements. (I suppose. To all those concerned, I have read that FreeBSD would be supported by the latest graphic card drivers, which was also confirmed by. I bought an expensive ATI card when they announced they'll go Note that AMD doesn't provide a driver for FreeBSD, so you'll be using the. We now know for sure that FreeBSD will ship with a kernel mode-setting driver for supporting open-source AMD Radeon graphics with its. AMD tech support has allegedly confirmed that Catalyst is being ported to FreeBSD. A Phoronix reader pointed out this thread. I am not sure that FreeBSD will fully support this card. The Xorg version for FreeBSD is and the ATI driver used is version The reason is, AMD/ATI doesn't support FreeBSD, and you have to resort to the sucky open source drivers.
  • Opengl ES / Openvg / Opencl / Webgl / Etc

    Opengl ES / Openvg / Opencl / Webgl / Etc

    KNU-3DC : Education and Training Plan 24 July 2013 Hwanyong LEE, Ph.D. Principal Engineer & Industry Cooperation Prof., KNU 3DC [email protected] KNU-3DC Introduction • Kyungpook National Univ. 3D Convergence Technology Center . Korea Government Funded Org. 23 staffs (10 Ph.D) . Research / Supporting Industry . Training and Education • Training and Education . Dassault Training Center . KIKS(Korea Institute of Khronos Study) • Constructing New Center Building . HUGE ! 7 Floors ! (2014E) 2 KNU-3DC KIKS • KIKS(Korea Institute of Khronos Study) . Leading Role in Korea for Training and Education of Khronos Standard – Collaboration with Khronos Group . Open Lecture + Develop Coursework for • OpenGL / OpenGL ES / OpenVG / OpenCL / WebGL / etc. • Opening / Sponsoring Workshop and Forum . Participating Khronos Activities • Contributor Member (Plan, now Processing) • Active participation of Khronos WG . Other Standard Activities • Make Khronos Standard into Korea National Standard. (WebGL) • W3C, ISO/IEC JTC1, IEEE 3333.X . Research and Consulting for Industry and Academy 3 KIKS Course • KIKS Course will be categorized into . Basic / Advanced / Packaged . Special Course - For instance Overview / Optimization / Consulting • Developing Courseware (for Khronos API) . OpenGL ES Basic & Advanced . OpenGL Basic & Advanced . OpenVG . OpenCL Basic & Advanced . WebGL . Etc. – new standards (Red - Started / Orange – Start at 4Q2013 / Dark Blue – Start at 2014) 4 Different View of Courses University Computer Game Image Parallel View Graphics Develop Processing … Processing JavaScript Khronos Canvas View … iPhone Android Company Web-App Parallel App App Application Develop View Develop Develop … Develop Course Development – Packaging Example • Android Application with OpenGL ES . General Android API’s – JNI, Java etc. OpenGL ES • iPhone App. Development with OpenGL ES . General iPhone APP API – cocoa, Objective-C, etc.
  • Openvg 1.1 API Quick Reference Card - Page 1

    Openvg 1.1 API Quick Reference Card - Page 1

    OpenVG 1.1 API Quick Reference Card - Page 1 OpenVG® is an API for hardware-accelerated two-dimensional Errors [4.1] vector and raster graphics. It provides a device-independent Error codes and their numerical values are defined by the VGErrorCode enumeration and can be and vendor-neutral interface for sophisticated 2D graphical obtained with the function: VGErrorCode vgGetError(void). The possible values are as follows: applications, while allowing device manufacturers to provide VG_NO_ERROR 0 VG_UNSUPPORTED_IMAGE_FORMAT_ERROR 0x1004 hardware acceleration where appropriate. VG_BAD_HANDLE_ERROR 0x1000 VG_UNSUPPORTED_PATH_FORMAT_ERROR 0x1005 • [n.n.n] refers to sections and tables in the OpenVG 1.1 API VG_ILLEGAL_ARGUMENT_ERROR 0x1001 VG_IMAGE_IN_USE_ERROR 0x1006 specification available at www.khronos.org/openvg/ VG_OUT_OF_MEMORY_ERROR 0x1002 VG_NO_CONTEXT_ERROR 0x1007 • Default values are shown in blue. VG_PATH_CAPABILITY_ERROR 0x1003 Data Types & Number Representations Colors [3.4] The sRGB color space defines values R’sRGB, G’sRGB, B’sRGB in terms of the linear lRGB primaries. Primitive Data Types [3.2] Colors in OpenVG other than those stored in image pixels are represented as non-premultiplied sRGBA color values. openvg.h khronos_type.h range Convert from lRGB to sRGB Convert from sRGB to lRGB Image pixel color and alpha values lie in the range [0,1] (gamma mapping) (1) (inverse gamma mapping) (2) VGbyte khronos_int8_t [-128, 127] unless otherwise noted. -1 VGubyte khronos_uint8_t [0, 255] R’sRGB = γ(R) R = γ (R’sRGB) Color Space Definitions -1 The linear lRGB color space is defined in terms of the G’sRGB = γ(G) G = γ (G’sRGB) VGshort khronos_int16_t [-32768, 32767] -1 standard CIE XYZ color space, following ITU Rec.
  • Linux Kernel and Driver Development Training Slides

    Linux Kernel and Driver Development Training Slides

    Linux Kernel and Driver Development Training Linux Kernel and Driver Development Training © Copyright 2004-2021, Bootlin. Creative Commons BY-SA 3.0 license. Latest update: October 9, 2021. Document updates and sources: https://bootlin.com/doc/training/linux-kernel Corrections, suggestions, contributions and translations are welcome! embedded Linux and kernel engineering Send them to [email protected] - Kernel, drivers and embedded Linux - Development, consulting, training and support - https://bootlin.com 1/470 Rights to copy © Copyright 2004-2021, Bootlin License: Creative Commons Attribution - Share Alike 3.0 https://creativecommons.org/licenses/by-sa/3.0/legalcode You are free: I to copy, distribute, display, and perform the work I to make derivative works I to make commercial use of the work Under the following conditions: I Attribution. You must give the original author credit. I Share Alike. If you alter, transform, or build upon this work, you may distribute the resulting work only under a license identical to this one. I For any reuse or distribution, you must make clear to others the license terms of this work. I Any of these conditions can be waived if you get permission from the copyright holder. Your fair use and other rights are in no way affected by the above. Document sources: https://github.com/bootlin/training-materials/ - Kernel, drivers and embedded Linux - Development, consulting, training and support - https://bootlin.com 2/470 Hyperlinks in the document There are many hyperlinks in the document I Regular hyperlinks: https://kernel.org/ I Kernel documentation links: dev-tools/kasan I Links to kernel source files and directories: drivers/input/ include/linux/fb.h I Links to the declarations, definitions and instances of kernel symbols (functions, types, data, structures): platform_get_irq() GFP_KERNEL struct file_operations - Kernel, drivers and embedded Linux - Development, consulting, training and support - https://bootlin.com 3/470 Company at a glance I Engineering company created in 2004, named ”Free Electrons” until Feb.
  • Hardware Implementation of a Tessellation Accelerator for the Openvg Standard

    Hardware Implementation of a Tessellation Accelerator for the Openvg Standard

    IEICE Electronics Express, Vol.7, No.6, 440–446 Hardware implementation of a tessellation accelerator for the OpenVG standard Seung Hun Kim, Yunho Oh, Karam Park, and Won Woo Roa) School of Electrical and Electronic Engineering, Yonsei University, 134 Shinchon-Dong, Seodaemun-Gu, SEOUL, 120–749, KOREA a) [email protected] Abstract: The OpenVG standard has been introduced as an efficient vector graphics API for embedded systems. There have been several OpenVG implementations that are based on the software rendering of image. However, the software rendering needs more execution time and power consumption than hardware accelerated rendering. For the effi- cient hardware implementation, we merge eight pipeline stages in the original specification to four pipeline stages. The first hardware accel- eration stage is the tessellation part which is one of the pipeline stages that calculates the edge of vector graphics. In this paper, we provide an efficient hardware design for the tessellation stage and claim this would eventually reduce the execution time and hardware complexity. Keywords: OpenVG, vector graphics, tessellation, hardware acceler- ator Classification: Electron devices, circuits, and systems References [1] K. Pulli, “New APIs for mobile graphics,” Proc. SPIE - The International Society for Optical Engineering, vol. 6074, pp. 1–13, 2006. [2] Khronos Group Inc., “OpenVG specification Version 1.0.1” [Online] http://www.khronos.org/openvg/ [3] S.-Y. Lee, S. Kim, J. Chung, and B.-U. Choi, “Salable Vector Graphics (OpenVG) for Creating Animation Image in Embedded Systems,” Lecture Notes in Computer Science, vol. 4693, pp. 99–108, 2007. [4] G. He, B. Bai, Z. Pan, and X.
  • A Simplified Graphics System Based on Direct Rendering Manager System

    A Simplified Graphics System Based on Direct Rendering Manager System

    J. lnf. Commun. Converg. Eng. 16(2): 125-129, Jun. 2018 Regular paper A Simplified Graphics System Based on Direct Rendering Manager System Nakhoon Baek* , Member, KIICE School of Computer Science and Engineering, Kyungpook National University, Daegu 41566, Korea Abstract In the field of computer graphics, rendering speed is one of the most important factors. Contemporary rendering is performed using 3D graphics systems with windowing system support. Since typical graphics systems, including OpenGL and the DirectX library, focus on the variety of graphics rendering features, the rendering process itself consists of many complicated operations. In contrast, early computer systems used direct manipulation of computer graphics hardware, and achieved simple and efficient graphics handling operations. We suggest an alternative method of accelerated 2D and 3D graphics output, based on directly accessing modern GPU hardware using the direct rendering manager (DRM) system. On the basis of this DRM support, we exchange the graphics instructions and graphics data directly, and achieve better performance than full 3D graphics systems. We present a prototype system for providing a set of simple 2D and 3D graphics primitives. Experimental results and their screen shots are included. Index Terms: Direct rendering manager, Efficient handling, Graphics acceleration, Light-weight implementation, Prototype system I. INTRODUCTION Rendering speed is one of the most important factors for 3D graphics application programs. Typical present-day graph- After graphics output devices became publicly available, a ics programs need to be able to handle very large quantities large number of graphics applications were developed for a of graphics data. The larger the data size, and the more sen- broad spectrum of uses including computer animations, com- sitive to the rendering speed, the better the speed-up that can puter games, user experiences, and human-computer inter- be achieved, even for minor aspects of the graphics pipeline.
  • The Linux Graphics Stack Attributions

    The Linux Graphics Stack Attributions

    I - Hardware : Anatomy of a GPU II - Host : The Linux graphics stack Attributions Introduction to GPUs and to the Linux Graphics Stack Martin Peres CC By-SA 3.0 Nouveau developer Ph.D. student at LaBRI November 26, 2012 1 / 36 I - Hardware : Anatomy of a GPU II - Host : The Linux graphics stack Attributions General overview Outline 1 I - Hardware : Anatomy of a GPU General overview Driving screens Host < − > GPU communication 2 II - Host : The Linux graphics stack General overview DRM and libdrm Mesa X11 Wayland X11 vs Wayland 3 Attributions Attributions 2 / 36 I - Hardware : Anatomy of a GPU II - Host : The Linux graphics stack Attributions General overview General overview of a modern GPU's functions Display content on a screen Accelerate 2D operations Accelerate 3D operations Decode videos Accelerate scientific calculations 3 / 36 I - Hardware : Anatomy of a GPU II - Host : The Linux graphics stack Attributions General overview CPU Clock Front-side Graphics Generator bus card slot Chipset Memory Slots High-speed graphics bus (AGP or PCI Northbridge Memory Express) bus (memory controller hub) Internal Bus PCI Bus Onboard Southbridge graphics PCI (I/O controller controller Bus hub) IDE SATA USB Cables and Ethernet ports leading Audio Codec CMOS Memory off-board PCI Slots LPC Bus Super I/O Serial Port Parallel Port Flash ROM Floppy Disk Keyboard (BIOS) Mouse 4 / 36 I - Hardware : Anatomy of a GPU II - Host : The Linux graphics stack Attributions General overview Hardware architecture GPU: Where all the calculations are made VRAM: Stores
  • Freiesmagazin 07/2009

    Freiesmagazin 07/2009

    freiesMagazin Juli 2009 Topthemen dieser Ausgabe ZevenOS – Linux goes BeOS Seite 4 Ein biologisches Phänomen hat längst Einzug in die Linux-Welt gehalten: Mimikry. Das bedeu- tet, dass eine Spezies wegen bestimmter Vorteile eine andere Spezies nachahmt, z. B. legt sich eine harmlose Fliegenart das Aussehen von Wespen zu. Einer der neueren Fälle in der Linux-Welt ist ZevenOS, eine Linux-Distribution, die auf Ubuntu aufbaut. Das Besondere: Sie will im Aussehen und in der Benutzung etwas vom Feeling des legendären und leider im Nebel der Geschichte verschwundenen Betriebssystems BeOS vermitteln. (weiterlesen) easyVDR – The easy VDR Distribution Seite 12 Die Distribution easyVDR ist eine unter der GNU General Public License (GPL) veröffentlichte Distribution, die sich den Themen Video und TV widmet. Hat man noch ausgemusterte Rech- ner zuhause, lassen sich diese mit der Hilfe von easyVDR als digitaler Videorekorder nutzen – mit dem Vorteil, in vielen Belangen anpassbar zu sein; ein digitaler Selbstbaukasten sozusa- gen. (weiterlesen) Was bieten freie CRM-Lösungen? – Im Vergleich: SugarCRM und vtiger CRM Seite 34 CRM steht für Customer Relationship Management und beschreibt die Verwaltung von Kunden- daten und Kundenbeziehungen. Anhand eines konkreten Anwendungsfalls der fiktiven Firma EVENTO, einer Veranstaltungsagentur mit dem Schwerpunkt auf außergewöhnliche Orte, wer- den zwei CRM-Lösungen verglichen. Aus der Vielzahl an frei verfügbaren Programmen wurden die zwei populären Vertreter SugarCRM Version 5.2.0c und vtiger CRM Version 5.0.4 ausge- wählt. (weiterlesen) © freiesMagazin GNU FDL Ausgabe 07/2009 ISSN 1867-7991 MAGAZIN Editorial Anleitung: Wie verprellt man eine Community? Wir befinden uns im Jahre 2009 n. Chr. Die ganze ten [5].